Remove pthread.h from source. We should be using asterisk/lock.h everywhere instead...
[asterisk/asterisk.git] / codecs / codec_adpcm.c
1 /* codec_adpcm.c - translate between signed linear and Dialogic ADPCM
2  * 
3  * Asterisk -- A telephony toolkit for Linux.
4  *
5  * Based on frompcm.c and topcm.c from the Emiliano MIPL browser/
6  * interpreter.  See http://www.bsdtelephony.com.mx
7  *
8  * Copyright (c) 2001 Linux Support Services, Inc.  All rights reserved.
9  *
10  * Karl Sackett <krs@linux-support.net>, 2001-3-21
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License
14  */
15
16 #include <asterisk/lock.h>
17 #include <asterisk/logger.h>
18 #include <asterisk/module.h>
19 #include <asterisk/translate.h>
20 #include <asterisk/channel.h>
21 #include <fcntl.h>
22 #include <netinet/in.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 #define BUFFER_SIZE   8096      /* size for the translation buffers */
29
30 AST_MUTEX_DEFINE_STATIC(localuser_lock);
31 static int localusecnt = 0;
32
33 static char *tdesc = "Adaptive Differential PCM Coder/Decoder";
34
35 /* Sample frame data */
36
37 #include "slin_adpcm_ex.h"
38 #include "adpcm_slin_ex.h"
39
40 /*
41  * Step size index shift table 
42  */
43
44 static short indsft[8] = { -1, -1, -1, -1, 2, 4, 6, 8 };
45
46 /*
47  * Step size table, where stpsz[i]=floor[16*(11/10)^i]
48  */
49
50 static short stpsz[49] = {
51   16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73,
52   80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279,
53   307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963,
54   1060, 1166, 1282, 1411, 1552
55 };
56
57 /* 
58  * Nibble to bit map
59  */
60
61 static short nbl2bit[16][4] = {
62   {1, 0, 0, 0}, {1, 0, 0, 1}, {1, 0, 1, 0}, {1, 0, 1, 1},
63   {1, 1, 0, 0}, {1, 1, 0, 1}, {1, 1, 1, 0}, {1, 1, 1, 1},
64   {-1, 0, 0, 0}, {-1, 0, 0, 1}, {-1, 0, 1, 0}, {-1, 0, 1, 1},
65   {-1, 1, 0, 0}, {-1, 1, 0, 1}, {-1, 1, 1, 0}, {-1, 1, 1, 1}
66 };
67
68 /*
69  * Decode(encoded)
70  *  Decodes the encoded nibble from the adpcm file.
71  *
72  * Results:
73  *  Returns the encoded difference.
74  *
75  * Side effects:
76  *  Sets the index to the step size table for the next encode.
77  */
78
79 static inline void 
80 decode (unsigned char encoded, short *ssindex, short *signal, unsigned char *rkey, unsigned char *next)
81 {
82   short diff, step;
83   step = stpsz[*ssindex];
84
85   diff = step * nbl2bit[encoded][1] +
86                 (step >> 1) * nbl2bit[encoded][2] +
87                 (step >> 2) * nbl2bit[encoded][3] +
88                 (step >> 3);
89   if (nbl2bit[encoded][2] && (step & 0x1))
90         diff++;
91   diff *= nbl2bit[encoded][0];
92
93   if ( *next & 0x1 )
94         *signal -= 8;
95   else if ( *next & 0x2 )
96         *signal += 8;
97
98   *signal += diff;
99
100   if (*signal > 2047)
101         *signal = 2047;
102   else if (*signal < -2047)
103         *signal = -2047;
104
105   *next = 0;
106
107 #ifdef AUTO_RETURN
108   if( encoded & 0x7 )
109         *rkey = 0;
110   else if ( ++(*rkey) == 24 ) {
111         *rkey = 0;
112         if (*signal > 0)
113                 *next = 0x1;
114         else if (*signal < 0)
115                 *next = 0x2;
116   }
117 #endif
118
119   *ssindex = *ssindex + indsft[(encoded & 7)];
120   if (*ssindex < 0)
121     *ssindex = 0;
122   else if (*ssindex > 48)
123     *ssindex = 48;
124 }
125
126 /*
127  * Adpcm
128  *  Takes a signed linear signal and encodes it as ADPCM
129  *  For more information see http://support.dialogic.com/appnotes/adpcm.pdf
130  *
131  * Results:
132  *  Foo.
133  *
134  * Side effects:
135  *  signal gets updated with each pass.
136  */
137
138 static inline unsigned char
139 adpcm (short csig, short *ssindex, short *signal, unsigned char *rkey, unsigned char *next)
140 {
141   short diff, step;
142   unsigned char encoded;
143   step = stpsz[*ssindex];
144   /* 
145    * Clip csig if too large or too small
146    */
147    
148   csig >>= 4;
149
150   diff = csig - *signal;
151   
152   if (diff < 0)
153     {
154       encoded = 8;
155       diff = -diff;
156     }
157   else
158     encoded = 0;
159   if (diff >= step)
160     {
161       encoded |= 4;
162       diff -= step;
163     }
164   step >>= 1;
165   if (diff >= step)
166     {
167       encoded |= 2;
168       diff -= step;
169     }
170   step >>= 1;
171   if (diff >= step)
172     encoded |= 1;
173     
174   decode (encoded, ssindex, signal, rkey, next);
175   return (encoded);
176 }
177
178 /*
179  * Private workspace for translating signed linear signals to ADPCM.
180  */
181
182 struct adpcm_encoder_pvt
183 {
184   struct ast_frame f;
185   char offset[AST_FRIENDLY_OFFSET];   /* Space to build offset */
186   short inbuf[BUFFER_SIZE];           /* Unencoded signed linear values */
187   unsigned char outbuf[BUFFER_SIZE];  /* Encoded ADPCM, two nibbles to a word */
188   short ssindex;
189   short signal;
190   unsigned char zero_count;
191   unsigned char next_flag;
192   int tail;
193 };
194
195 /*
196  * Private workspace for translating ADPCM signals to signed linear.
197  */
198
199 struct adpcm_decoder_pvt
200 {
201   struct ast_frame f;
202   char offset[AST_FRIENDLY_OFFSET];     /* Space to build offset */
203   short outbuf[BUFFER_SIZE];    /* Decoded signed linear values */
204   short ssindex;
205   short signal;
206   unsigned char zero_count;
207   unsigned char next_flag;
208   int tail;
209 };
210
211 /*
212  * AdpcmToLin_New
213  *  Create a new instance of adpcm_decoder_pvt.
214  *
215  * Results:
216  *  Returns a pointer to the new instance.
217  *
218  * Side effects:
219  *  None.
220  */
221
222 static struct ast_translator_pvt *
223 adpcmtolin_new (void)
224 {
225   struct adpcm_decoder_pvt *tmp;
226   tmp = malloc (sizeof (struct adpcm_decoder_pvt));
227   if (tmp)
228     {
229           memset(tmp, 0, sizeof(*tmp));
230       tmp->tail = 0;
231       localusecnt++;
232       ast_update_use_count ();
233     }
234   return (struct ast_translator_pvt *) tmp;
235 }
236
237 /*
238  * LinToAdpcm_New
239  *  Create a new instance of adpcm_encoder_pvt.
240  *
241  * Results:
242  *  Returns a pointer to the new instance.
243  *
244  * Side effects:
245  *  None.
246  */
247
248 static struct ast_translator_pvt *
249 lintoadpcm_new (void)
250 {
251   struct adpcm_encoder_pvt *tmp;
252   tmp = malloc (sizeof (struct adpcm_encoder_pvt));
253   if (tmp)
254     {
255           memset(tmp, 0, sizeof(*tmp));
256       localusecnt++;
257       ast_update_use_count ();
258       tmp->tail = 0;
259     }
260   return (struct ast_translator_pvt *) tmp;
261 }
262
263 /*
264  * AdpcmToLin_FrameIn
265  *  Fill an input buffer with packed 4-bit ADPCM values if there is room
266  *  left.
267  *
268  * Results:
269  *  Foo
270  *
271  * Side effects:
272  *  tmp->tail is the number of packed values in the buffer.
273  */
274
275 static int
276 adpcmtolin_framein (struct ast_translator_pvt *pvt, struct ast_frame *f)
277 {
278   struct adpcm_decoder_pvt *tmp = (struct adpcm_decoder_pvt *) pvt;
279   int x;
280   unsigned char *b;
281
282   if (f->datalen * 4 > sizeof(tmp->outbuf)) {
283         ast_log(LOG_WARNING, "Out of buffer space\n");
284         return -1;
285   }
286
287   b = f->data;
288
289   for (x=0;x<f->datalen;x++) {
290         decode((b[x] >> 4) & 0xf, &tmp->ssindex, &tmp->signal, &tmp->zero_count, &tmp->next_flag);
291         tmp->outbuf[tmp->tail++] = tmp->signal << 4;
292
293         decode(b[x] & 0x0f, &tmp->ssindex, &tmp->signal, &tmp->zero_count, &tmp->next_flag);
294         tmp->outbuf[tmp->tail++] = tmp->signal << 4;
295   }
296
297   return 0;
298 }
299
300 /*
301  * AdpcmToLin_FrameOut
302  *  Convert 4-bit ADPCM encoded signals to 16-bit signed linear.
303  *
304  * Results:
305  *  Converted signals are placed in tmp->f.data, tmp->f.datalen
306  *  and tmp->f.samples are calculated.
307  *
308  * Side effects:
309  *  None.
310  */
311
312 static struct ast_frame *
313 adpcmtolin_frameout (struct ast_translator_pvt *pvt)
314 {
315   struct adpcm_decoder_pvt *tmp = (struct adpcm_decoder_pvt *) pvt;
316
317   if (!tmp->tail)
318     return NULL;
319
320   tmp->f.frametype = AST_FRAME_VOICE;
321   tmp->f.subclass = AST_FORMAT_SLINEAR;
322   tmp->f.datalen = tmp->tail *2;
323   tmp->f.samples = tmp->tail;
324   tmp->f.mallocd = 0;
325   tmp->f.offset = AST_FRIENDLY_OFFSET;
326   tmp->f.src = __PRETTY_FUNCTION__;
327   tmp->f.data = tmp->outbuf;
328   tmp->tail = 0;
329   return &tmp->f;
330 }
331
332 /*
333  * LinToAdpcm_FrameIn
334  *  Fill an input buffer with 16-bit signed linear PCM values.
335  *
336  * Results:
337  *  None.
338  *
339  * Side effects:
340  *  tmp->tail is number of signal values in the input buffer.
341  */
342
343 static int
344 lintoadpcm_framein (struct ast_translator_pvt *pvt, struct ast_frame *f)
345 {
346   struct adpcm_encoder_pvt *tmp = (struct adpcm_encoder_pvt *) pvt;
347
348   if ((tmp->tail + f->datalen / 2) < (sizeof (tmp->inbuf) / 2))
349     {
350       memcpy (&tmp->inbuf[tmp->tail], f->data, f->datalen);
351       tmp->tail += f->datalen / 2;
352     }
353   else
354     {
355       ast_log (LOG_WARNING, "Out of buffer space\n");
356       return -1;
357     }
358   return 0;
359 }
360
361 /*
362  * LinToAdpcm_FrameOut
363  *  Convert a buffer of raw 16-bit signed linear PCM to a buffer
364  *  of 4-bit ADPCM packed two to a byte (Big Endian).
365  *
366  * Results:
367  *  Foo
368  *
369  * Side effects:
370  *  Leftover inbuf data gets packed, tail gets updated.
371  */
372
373 static struct ast_frame *
374 lintoadpcm_frameout (struct ast_translator_pvt *pvt)
375 {
376   struct adpcm_encoder_pvt *tmp = (struct adpcm_encoder_pvt *) pvt;
377   unsigned char adpcm0, adpcm1;
378   int i_max, i;
379   
380   if (tmp->tail < 2) return NULL;
381
382
383   i_max = (tmp->tail / 2) * 2;
384
385   tmp->outbuf[0] = tmp->ssindex & 0xff;
386   tmp->outbuf[1] = (tmp->signal >> 8) & 0xff;
387   tmp->outbuf[2] = (tmp->signal & 0xff);
388   tmp->outbuf[3] = tmp->zero_count;
389   tmp->outbuf[4] = tmp->next_flag;
390
391   for (i = 0; i < i_max; i+=2)
392   {
393     adpcm0 = adpcm (tmp->inbuf[i], &tmp->ssindex, &tmp->signal, &tmp->zero_count, &tmp->next_flag);
394     adpcm1 = adpcm (tmp->inbuf[i+1], &tmp->ssindex, &tmp->signal, &tmp->zero_count, &tmp->next_flag);
395
396     tmp->outbuf[i/2] = (adpcm0 << 4) | adpcm1;
397   };
398
399
400   tmp->f.frametype = AST_FRAME_VOICE;
401   tmp->f.subclass = AST_FORMAT_ADPCM;
402   tmp->f.samples = i_max;
403   tmp->f.mallocd = 0;
404   tmp->f.offset = AST_FRIENDLY_OFFSET;
405   tmp->f.src = __PRETTY_FUNCTION__;
406   tmp->f.data = tmp->outbuf;
407   tmp->f.datalen = i_max / 2;
408
409   /*
410    * If there is a signal left over (there should be no more than
411    * one) move it to the beginning of the input buffer.
412    */
413
414   if (tmp->tail == i_max)
415     tmp->tail = 0;
416   else
417     {
418       tmp->inbuf[0] = tmp->inbuf[tmp->tail];
419       tmp->tail = 1;
420     }
421   return &tmp->f;
422 }
423
424
425 /*
426  * AdpcmToLin_Sample
427  */
428
429 static struct ast_frame *
430 adpcmtolin_sample (void)
431 {
432   static struct ast_frame f;
433   f.frametype = AST_FRAME_VOICE;
434   f.subclass = AST_FORMAT_ADPCM;
435   f.datalen = sizeof (adpcm_slin_ex);
436   f.samples = sizeof(adpcm_slin_ex) * 2;
437   f.mallocd = 0;
438   f.offset = 0;
439   f.src = __PRETTY_FUNCTION__;
440   f.data = adpcm_slin_ex;
441   return &f;
442 }
443
444 /*
445  * LinToAdpcm_Sample
446  */
447
448 static struct ast_frame *
449 lintoadpcm_sample (void)
450 {
451   static struct ast_frame f;
452   f.frametype = AST_FRAME_VOICE;
453   f.subclass = AST_FORMAT_SLINEAR;
454   f.datalen = sizeof (slin_adpcm_ex);
455   /* Assume 8000 Hz */
456   f.samples = sizeof (slin_adpcm_ex) / 2;
457   f.mallocd = 0;
458   f.offset = 0;
459   f.src = __PRETTY_FUNCTION__;
460   f.data = slin_adpcm_ex;
461   return &f;
462 }
463
464 /*
465  * Adpcm_Destroy
466  *  Destroys a private workspace.
467  *
468  * Results:
469  *  It's gone!
470  *
471  * Side effects:
472  *  None.
473  */
474
475 static void
476 adpcm_destroy (struct ast_translator_pvt *pvt)
477 {
478   free (pvt);
479   localusecnt--;
480   ast_update_use_count ();
481 }
482
483 /*
484  * The complete translator for ADPCMToLin.
485  */
486
487 static struct ast_translator adpcmtolin = {
488   "adpcmtolin",
489   AST_FORMAT_ADPCM,
490   AST_FORMAT_SLINEAR,
491   adpcmtolin_new,
492   adpcmtolin_framein,
493   adpcmtolin_frameout,
494   adpcm_destroy,
495   /* NULL */
496   adpcmtolin_sample
497 };
498
499 /*
500  * The complete translator for LinToADPCM.
501  */
502
503 static struct ast_translator lintoadpcm = {
504   "lintoadpcm",
505   AST_FORMAT_SLINEAR,
506   AST_FORMAT_ADPCM,
507   lintoadpcm_new,
508   lintoadpcm_framein,
509   lintoadpcm_frameout,
510   adpcm_destroy,
511   /* NULL */
512   lintoadpcm_sample
513 };
514
515 int
516 unload_module (void)
517 {
518   int res;
519   ast_mutex_lock (&localuser_lock);
520   res = ast_unregister_translator (&lintoadpcm);
521   if (!res)
522     res = ast_unregister_translator (&adpcmtolin);
523   if (localusecnt)
524     res = -1;
525   ast_mutex_unlock (&localuser_lock);
526   return res;
527 }
528
529 int
530 load_module (void)
531 {
532   int res;
533   res = ast_register_translator (&adpcmtolin);
534   if (!res)
535     res = ast_register_translator (&lintoadpcm);
536   else
537     ast_unregister_translator (&adpcmtolin);
538   return res;
539 }
540
541 /*
542  * Return a description of this module.
543  */
544
545 char *
546 description (void)
547 {
548   return tdesc;
549 }
550
551 int
552 usecount (void)
553 {
554   int res;
555   STANDARD_USECOUNT (res);
556   return res;
557 }
558
559 char *
560 key ()
561 {
562   return ASTERISK_GPL_KEY;
563 }