src/third_party/webrtc/modules/audio_coding/codecs/g722/g722_decode.c

   1 /*
   2  * SpanDSP - a series of DSP components for telephony
   3  *
   4  * g722_decode.c - The ITU G.722 codec, decode part.
   5  *
   6  * Written by Steve Underwood <steveu@coppice.org>
   7  *
   8  * Copyright (C) 2005 Steve Underwood
   9  *
  10  *  Despite my general liking of the GPL, I place my own contributions
  11  *  to this code in the public domain for the benefit of all mankind -
  12  *  even the slimy ones who might try to proprietize my work and use it
  13  *  to my detriment.
  14  *
  15  * Based in part on a single channel G.722 codec which is:
  16  *
  17  * Copyright (c) CMU 1993
  18  * Computer Science, Speech Group
  19  * Chengxiang Lu and Alex Hauptmann
  20  *
  21  * $Id: g722_decode.c,v 1.15 2006/07/07 16:37:49 steveu Exp $
  22  *
  23  * Modifications for WebRtc, 2011/04/28, by tlegrand:
  24  * -Removed usage of inttypes.h and tgmath.h
  25  * -Changed to use WebRtc types
  26  * -Changed __inline__ to __inline
  27  * -Added saturation check on output
  28  */
  29
  30 /*! \file */
  31
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include <config.h>
  35 #endif
  36
  37 #include <memory.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40
  41 #include "g722_enc_dec.h"
  42 #include "webrtc/typedefs.h"
  43
  44 #if !defined(FALSE)
  45 #define FALSE 0
  46 #endif
  47 #if !defined(TRUE)
  48 #define TRUE (!FALSE)
  49 #endif
  50
  51 static __inline int16_t saturate(int32_t amp)
  52 {
  53     int16_t amp16;
  54
  55     /* Hopefully this is optimised for the common case - not clipping */
  56     amp16 = (int16_t) amp;
  57     if (amp == amp16)
  58         return amp16;
  59     if (amp > WEBRTC_INT16_MAX)
  60         return  WEBRTC_INT16_MAX;
  61     return  WEBRTC_INT16_MIN;
  62 }
  63 /*- End of function --------------------------------------------------------*/
  64
  65 static void block4(g722_decode_state_t *s, int band, int d);
  66
  67 static void block4(g722_decode_state_t *s, int band, int d)
  68 {
  69     int wd1;
  70     int wd2;
  71     int wd3;
  72     int i;
  73
  74     /* Block 4, RECONS */
  75     s->band[band].d[0] = d;
  76     s->band[band].r[0] = saturate(s->band[band].s + d);
  77
  78     /* Block 4, PARREC */
  79     s->band[band].p[0] = saturate(s->band[band].sz + d);
  80
  81     /* Block 4, UPPOL2 */
  82     for (i = 0;  i < 3;  i++)
  83         s->band[band].sg[i] = s->band[band].p[i] >> 15;
  84     wd1 = saturate(s->band[band].a[1] << 2);
  85
  86     wd2 = (s->band[band].sg[0] == s->band[band].sg[1])  ?  -wd1  :  wd1;
  87     if (wd2 > 32767)
  88         wd2 = 32767;
  89     wd3 = (s->band[band].sg[0] == s->band[band].sg[2])  ?  128  :  -128;
  90     wd3 += (wd2 >> 7);
  91     wd3 += (s->band[band].a[2]*32512) >> 15;
  92     if (wd3 > 12288)
  93         wd3 = 12288;
  94     else if (wd3 < -12288)
  95         wd3 = -12288;
  96     s->band[band].ap[2] = wd3;
  97
  98     /* Block 4, UPPOL1 */
  99     s->band[band].sg[0] = s->band[band].p[0] >> 15;
 100     s->band[band].sg[1] = s->band[band].p[1] >> 15;
 101     wd1 = (s->band[band].sg[0] == s->band[band].sg[1])  ?  192  :  -192;
 102     wd2 = (s->band[band].a[1]*32640) >> 15;
 103
 104     s->band[band].ap[1] = saturate(wd1 + wd2);
 105     wd3 = saturate(15360 - s->band[band].ap[2]);
 106     if (s->band[band].ap[1] > wd3)
 107         s->band[band].ap[1] = wd3;
 108     else if (s->band[band].ap[1] < -wd3)
 109         s->band[band].ap[1] = -wd3;
 110
 111     /* Block 4, UPZERO */
 112     wd1 = (d == 0)  ?  0  :  128;
 113     s->band[band].sg[0] = d >> 15;
 114     for (i = 1;  i < 7;  i++)
 115     {
 116         s->band[band].sg[i] = s->band[band].d[i] >> 15;
 117         wd2 = (s->band[band].sg[i] == s->band[band].sg[0])  ?  wd1  :  -wd1;
 118         wd3 = (s->band[band].b[i]*32640) >> 15;
 119         s->band[band].bp[i] = saturate(wd2 + wd3);
 120     }
 121
 122     /* Block 4, DELAYA */
 123     for (i = 6;  i > 0;  i--)
 124     {
 125         s->band[band].d[i] = s->band[band].d[i - 1];
 126         s->band[band].b[i] = s->band[band].bp[i];
 127     }
 128
 129     for (i = 2;  i > 0;  i--)
 130     {
 131         s->band[band].r[i] = s->band[band].r[i - 1];
 132         s->band[band].p[i] = s->band[band].p[i - 1];
 133         s->band[band].a[i] = s->band[band].ap[i];
 134     }
 135
 136     /* Block 4, FILTEP */
 137     wd1 = saturate(s->band[band].r[1] + s->band[band].r[1]);
 138     wd1 = (s->band[band].a[1]*wd1) >> 15;
 139     wd2 = saturate(s->band[band].r[2] + s->band[band].r[2]);
 140     wd2 = (s->band[band].a[2]*wd2) >> 15;
 141     s->band[band].sp = saturate(wd1 + wd2);
 142
 143     /* Block 4, FILTEZ */
 144     s->band[band].sz = 0;
 145     for (i = 6;  i > 0;  i--)
 146     {
 147         wd1 = saturate(s->band[band].d[i] + s->band[band].d[i]);
 148         s->band[band].sz += (s->band[band].b[i]*wd1) >> 15;
 149     }
 150     s->band[band].sz = saturate(s->band[band].sz);
 151
 152     /* Block 4, PREDIC */
 153     s->band[band].s = saturate(s->band[band].sp + s->band[band].sz);
 154 }
 155 /*- End of function --------------------------------------------------------*/
 156
 157 g722_decode_state_t *WebRtc_g722_decode_init(g722_decode_state_t *s,
 158                                              int rate,
 159                                              int options)
 160 {
 161     if (s == NULL)
 162     {
 163         if ((s = (g722_decode_state_t *) malloc(sizeof(*s))) == NULL)
 164             return NULL;
 165     }
 166     memset(s, 0, sizeof(*s));
 167     if (rate == 48000)
 168         s->bits_per_sample = 6;
 169     else if (rate == 56000)
 170         s->bits_per_sample = 7;
 171     else
 172         s->bits_per_sample = 8;
 173     if ((options & G722_SAMPLE_RATE_8000))
 174         s->eight_k = TRUE;
 175     if ((options & G722_PACKED)  &&  s->bits_per_sample != 8)
 176         s->packed = TRUE;
 177     else
 178         s->packed = FALSE;
 179     s->band[0].det = 32;
 180     s->band[1].det = 8;
 181     return s;
 182 }
 183 /*- End of function --------------------------------------------------------*/
 184
 185 int WebRtc_g722_decode_release(g722_decode_state_t *s)
 186 {
 187     free(s);
 188     return 0;
 189 }
 190 /*- End of function --------------------------------------------------------*/
 191
 192 int WebRtc_g722_decode(g722_decode_state_t *s, int16_t amp[],
 193                        const uint8_t g722_data[], int len)
 194 {
 195     static const int wl[8] = {-60, -30, 58, 172, 334, 538, 1198, 3042 };
 196     static const int rl42[16] = {0, 7, 6, 5, 4, 3, 2, 1,
 197                                  7, 6, 5, 4, 3,  2, 1, 0 };
 198     static const int ilb[32] =
 199     {
 200         2048, 2093, 2139, 2186, 2233, 2282, 2332,
 201         2383, 2435, 2489, 2543, 2599, 2656, 2714,
 202         2774, 2834, 2896, 2960, 3025, 3091, 3158,
 203         3228, 3298, 3371, 3444, 3520, 3597, 3676,
 204         3756, 3838, 3922, 4008
 205     };
 206     static const int wh[3] = {0, -214, 798};
 207     static const int rh2[4] = {2, 1, 2, 1};
 208     static const int qm2[4] = {-7408, -1616,  7408,   1616};
 209     static const int qm4[16] =
 210     {
 211               0, -20456, -12896,  -8968,
 212           -6288,  -4240,  -2584,  -1200,
 213           20456,  12896,   8968,   6288,
 214            4240,   2584,   1200,      0
 215     };
 216     static const int qm5[32] =
 217     {
 218            -280,   -280, -23352, -17560,
 219          -14120, -11664,  -9752,  -8184,
 220           -6864,  -5712,  -4696,  -3784,
 221           -2960,  -2208,  -1520,   -880,
 222           23352,  17560,  14120,  11664,
 223            9752,   8184,   6864,   5712,
 224            4696,   3784,   2960,   2208,
 225            1520,    880,    280,   -280
 226     };
 227     static const int qm6[64] =
 228     {
 229            -136,   -136,   -136,   -136,
 230          -24808, -21904, -19008, -16704,
 231          -14984, -13512, -12280, -11192,
 232          -10232,  -9360,  -8576,  -7856,
 233           -7192,  -6576,  -6000,  -5456,
 234           -4944,  -4464,  -4008,  -3576,
 235           -3168,  -2776,  -2400,  -2032,
 236           -1688,  -1360,  -1040,   -728,
 237           24808,  21904,  19008,  16704,
 238           14984,  13512,  12280,  11192,
 239           10232,   9360,   8576,   7856,
 240            7192,   6576,   6000,   5456,
 241            4944,   4464,   4008,   3576,
 242            3168,   2776,   2400,   2032,
 243            1688,   1360,   1040,    728,
 244             432,    136,   -432,   -136
 245     };
 246     static const int qmf_coeffs[12] =
 247     {
 248            3,  -11,   12,   32, -210,  951, 3876, -805,  362, -156,   53,  -11,
 249     };
 250
 251     int dlowt;
 252     int rlow;
 253     int ihigh;
 254     int dhigh;
 255     int rhigh;
 256     int xout1;
 257     int xout2;
 258     int wd1;
 259     int wd2;
 260     int wd3;
 261     int code;
 262     int outlen;
 263     int i;
 264     int j;
 265
 266     outlen = 0;
 267     rhigh = 0;
 268     for (j = 0;  j < len;  )
 269     {
 270         if (s->packed)
 271         {
 272             /* Unpack the code bits */
 273             if (s->in_bits < s->bits_per_sample)
 274             {
 275                 s->in_buffer |= (g722_data[j++] << s->in_bits);
 276                 s->in_bits += 8;
 277             }
 278             code = s->in_buffer & ((1 << s->bits_per_sample) - 1);
 279             s->in_buffer >>= s->bits_per_sample;
 280             s->in_bits -= s->bits_per_sample;
 281         }
 282         else
 283         {
 284             code = g722_data[j++];
 285         }
 286
 287         switch (s->bits_per_sample)
 288         {
 289         default:
 290         case 8:
 291             wd1 = code & 0x3F;
 292             ihigh = (code >> 6) & 0x03;
 293             wd2 = qm6[wd1];
 294             wd1 >>= 2;
 295             break;
 296         case 7:
 297             wd1 = code & 0x1F;
 298             ihigh = (code >> 5) & 0x03;
 299             wd2 = qm5[wd1];
 300             wd1 >>= 1;
 301             break;
 302         case 6:
 303             wd1 = code & 0x0F;
 304             ihigh = (code >> 4) & 0x03;
 305             wd2 = qm4[wd1];
 306             break;
 307         }
 308         /* Block 5L, LOW BAND INVQBL */
 309         wd2 = (s->band[0].det*wd2) >> 15;
 310         /* Block 5L, RECONS */
 311         rlow = s->band[0].s + wd2;
 312         /* Block 6L, LIMIT */
 313         if (rlow > 16383)
 314             rlow = 16383;
 315         else if (rlow < -16384)
 316             rlow = -16384;
 317
 318         /* Block 2L, INVQAL */
 319         wd2 = qm4[wd1];
 320         dlowt = (s->band[0].det*wd2) >> 15;
 321
 322         /* Block 3L, LOGSCL */
 323         wd2 = rl42[wd1];
 324         wd1 = (s->band[0].nb*127) >> 7;
 325         wd1 += wl[wd2];
 326         if (wd1 < 0)
 327             wd1 = 0;
 328         else if (wd1 > 18432)
 329             wd1 = 18432;
 330         s->band[0].nb = wd1;
 331
 332         /* Block 3L, SCALEL */
 333         wd1 = (s->band[0].nb >> 6) & 31;
 334         wd2 = 8 - (s->band[0].nb >> 11);
 335         wd3 = (wd2 < 0)  ?  (ilb[wd1] << -wd2)  :  (ilb[wd1] >> wd2);
 336         s->band[0].det = wd3 << 2;
 337
 338         block4(s, 0, dlowt);
 339
 340         if (!s->eight_k)
 341         {
 342             /* Block 2H, INVQAH */
 343             wd2 = qm2[ihigh];
 344             dhigh = (s->band[1].det*wd2) >> 15;
 345             /* Block 5H, RECONS */
 346             rhigh = dhigh + s->band[1].s;
 347             /* Block 6H, LIMIT */
 348             if (rhigh > 16383)
 349                 rhigh = 16383;
 350             else if (rhigh < -16384)
 351                 rhigh = -16384;
 352
 353             /* Block 2H, INVQAH */
 354             wd2 = rh2[ihigh];
 355             wd1 = (s->band[1].nb*127) >> 7;
 356             wd1 += wh[wd2];
 357             if (wd1 < 0)
 358                 wd1 = 0;
 359             else if (wd1 > 22528)
 360                 wd1 = 22528;
 361             s->band[1].nb = wd1;
 362
 363             /* Block 3H, SCALEH */
 364             wd1 = (s->band[1].nb >> 6) & 31;
 365             wd2 = 10 - (s->band[1].nb >> 11);
 366             wd3 = (wd2 < 0)  ?  (ilb[wd1] << -wd2)  :  (ilb[wd1] >> wd2);
 367             s->band[1].det = wd3 << 2;
 368
 369             block4(s, 1, dhigh);
 370         }
 371
 372         if (s->itu_test_mode)
 373         {
 374             amp[outlen++] = (int16_t) (rlow << 1);
 375             amp[outlen++] = (int16_t) (rhigh << 1);
 376         }
 377         else
 378         {
 379             if (s->eight_k)
 380             {
 381                 amp[outlen++] = (int16_t) (rlow << 1);
 382             }
 383             else
 384             {
 385                 /* Apply the receive QMF */
 386                 for (i = 0;  i < 22;  i++)
 387                     s->x[i] = s->x[i + 2];
 388                 s->x[22] = rlow + rhigh;
 389                 s->x[23] = rlow - rhigh;
 390
 391                 xout1 = 0;
 392                 xout2 = 0;
 393                 for (i = 0;  i < 12;  i++)
 394                 {
 395                     xout2 += s->x[2*i]*qmf_coeffs[i];
 396                     xout1 += s->x[2*i + 1]*qmf_coeffs[11 - i];
 397                 }
 398                 /* We shift by 12 to allow for the QMF filters (DC gain = 4096), less 1
 399                    to allow for the 15 bit input to the G.722 algorithm. */
 400                 /* WebRtc, tlegrand: added saturation */
 401                 amp[outlen++] = saturate(xout1 >> 11);
 402                 amp[outlen++] = saturate(xout2 >> 11);
 403             }
 404         }
 405     }
 406     return outlen;
 407 }
 408 /*- End of function --------------------------------------------------------*/
 409 /*- End of file ------------------------------------------------------------*/