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