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