frameworks/base/media/libstagefright/codecs/amrnb/dec/src/d8_31pf.cpp

   1 /* ------------------------------------------------------------------
   2  * Copyright (C) 1998-2009 PacketVideo
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  13  * express or implied.
  14  * See the License for the specific language governing permissions
  15  * and limitations under the License.
  16  * -------------------------------------------------------------------
  17  */
  18 /****************************************************************************************
  19 Portions of this file are derived from the following 3GPP standard:
  20
  21     3GPP TS 26.073
  22     ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
  23     Available from http://www.3gpp.org
  24
  25 (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
  26 Permission to distribute, modify and use this file under the standard license
  27 terms listed above has been obtained from the copyright holder.
  28 ****************************************************************************************/
  29 /*
  30 ------------------------------------------------------------------------------
  31
  32
  33
  34  Pathname: ./audio/gsm-amr/c/src/d8_31pf.c
  35  Functions:
  36
  37
  38      Date: 01/28/2002
  39
  40 ------------------------------------------------------------------------------
  41  REVISION HISTORY
  42
  43  Description: Modified to pass overflow flag through to basic math function.
  44  The flag is passed back to the calling function by pointer reference.
  45
  46  Description: Per review comments...
  47  (1) Removed include of "count.h" and "basic_op.h"
  48  (2) Added includes of mult.h, shl.h, shr.h, add.h, sub.h, negate.h,
  49      L_mult.h, and L_shr.h
  50
  51  Description:  Replaced "int" and/or "char" with OSCL defined types.
  52
  53  Description:
  54
  55 ------------------------------------------------------------------------------
  56  MODULE DESCRIPTION
  57 */
  58
  59 /*----------------------------------------------------------------------------
  60 ; INCLUDES
  61 ----------------------------------------------------------------------------*/
  62 #include "d8_31pf.h"
  63 #include "typedef.h"
  64 #include "basic_op.h"
  65 #include "cnst.h"
  66
  67
  68 /*----------------------------------------------------------------------------
  69 ; MACROS
  70 ; Define module specific macros here
  71 ----------------------------------------------------------------------------*/
  72
  73 /*----------------------------------------------------------------------------
  74 ; DEFINES
  75 ; Include all pre-processor statements here. Include conditional
  76 ; compile variables also.
  77 ----------------------------------------------------------------------------*/
  78 #define NB_PULSE  8           /* number of pulses  */
  79
  80 /* define values/representation for output codevector and sign */
  81 #define POS_CODE  8191
  82 #define NEG_CODE  8191
  83
  84
  85 /*----------------------------------------------------------------------------
  86 ; LOCAL FUNCTION DEFINITIONS
  87 ; Function Prototype declaration
  88 ----------------------------------------------------------------------------*/
  89
  90 /*----------------------------------------------------------------------------
  91 ; LOCAL VARIABLE DEFINITIONS
  92 ; Variable declaration - defined here and used outside this module
  93 ----------------------------------------------------------------------------*/
  94
  95 /*
  96 ------------------------------------------------------------------------------
  97  FUNCTION NAME: decompress10
  98 ------------------------------------------------------------------------------
  99  INPUT AND OUTPUT DEFINITIONS
 100
 101  Inputs:
 102    MSBs -- Word16 -- MSB part of the index
 103    LSBs -- Word16 -- LSB part of the index
 104    index1 -- Word16 -- index for first pos in pos_index[]
 105    index2 -- Word16 -- index for second pos in pos_index[]
 106    index3 -- Word16 -- index for third pos in pos_index[]
 107
 108  Outputs:
 109    pos_indx[] -- array of type Word16 -- position of 3 pulses (decompressed)
 110
 111    pOverflow  Flag set when overflow occurs, pointer of type Flag *
 112
 113  Returns:
 114     None
 115
 116  Global Variables Used:
 117     None
 118
 119  Local Variables Needed:
 120     None
 121
 122 ------------------------------------------------------------------------------
 123  FUNCTION DESCRIPTION
 124
 125
 126 ------------------------------------------------------------------------------
 127  REQUIREMENTS
 128
 129  None
 130
 131 ------------------------------------------------------------------------------
 132  REFERENCES
 133
 134  d8_31pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
 135
 136 ------------------------------------------------------------------------------
 137  PSEUDO-CODE
 138
 139
 140 ------------------------------------------------------------------------------
 141  RESOURCES USED [optional]
 142
 143  When the code is written for a specific target processor the
 144  the resources used should be documented below.
 145
 146  HEAP MEMORY USED: x bytes
 147
 148  STACK MEMORY USED: x bytes
 149
 150  CLOCK CYCLES: (cycle count equation for this function) + (variable
 151                 used to represent cycle count for each subroutine
 152                 called)
 153      where: (cycle count variable) = cycle count for [subroutine
 154                                      name]
 155
 156 ------------------------------------------------------------------------------
 157  CAUTION [optional]
 158  [State any special notes, constraints or cautions for users of this function]
 159
 160 ------------------------------------------------------------------------------
 161 */
 162
 163 static void decompress10(
 164     Word16 MSBs,        /* i : MSB part of the index                 */
 165     Word16 LSBs,        /* i : LSB part of the index                 */
 166     Word16 index1,      /* i : index for first pos in pos_index[]    */
 167     Word16 index2,      /* i : index for second pos in pos_index[]   */
 168     Word16 index3,      /* i : index for third pos in pos_index[]    */
 169     Word16 pos_indx[],  /* o : position of 3 pulses (decompressed)   */
 170     Flag  *pOverflow)   /* o : Flag set when overflow occurs         */
 171 {
 172     Word16 ia;
 173     Word16 ib;
 174     Word16 ic;
 175     Word32 tempWord32;
 176
 177     /*
 178       pos_indx[index1] = ((MSBs-25*(MSBs/25))%5)*2 + (LSBs-4*(LSBs/4))%2;
 179       pos_indx[index2] = ((MSBs-25*(MSBs/25))/5)*2 + (LSBs-4*(LSBs/4))/2;
 180       pos_indx[index3] = (MSBs/25)*2 + LSBs/4;
 181     */
 182
 183     if (MSBs > 124)
 184     {
 185         MSBs = 124;
 186     }
 187
 188     ia =
 189         mult(
 190             MSBs,
 191             1311,
 192             pOverflow);
 193
 194     tempWord32 =
 195         L_mult(
 196             ia,
 197             25,
 198             pOverflow);
 199
 200
 201     ia = (Word16)(MSBs - (tempWord32 >> 1));
 202     ib =
 203         mult(
 204             ia,
 205             6554,
 206             pOverflow);
 207
 208     tempWord32 =
 209         L_mult(
 210             ib,
 211             5,
 212             pOverflow);
 213
 214     ib = ia - (Word16)(tempWord32 >> 1);
 215
 216     ib =
 217         shl(
 218             ib,
 219             1,
 220             pOverflow);
 221
 222
 223     ic = LSBs - ((LSBs >> 2) << 2);
 224
 225
 226     pos_indx[index1] = ib + (ic & 1);
 227
 228
 229     ib =
 230         mult(
 231             ia,
 232             6554,
 233             pOverflow);
 234
 235     ib =
 236         shl(
 237             ib,
 238             1,
 239             pOverflow);
 240
 241
 242     pos_indx[index2] = ib + (ic >> 1);
 243
 244
 245     ib = LSBs >> 2;
 246
 247     ic =
 248         mult(
 249             MSBs,
 250             1311,
 251             pOverflow);
 252
 253     ic =
 254         shl(
 255             ic,
 256             1,
 257             pOverflow);
 258
 259     pos_indx[index3] =
 260         add(
 261             ib,
 262             ic,
 263             pOverflow);
 264
 265     return;
 266 }
 267
 268
 269 /*
 270 ------------------------------------------------------------------------------
 271  FUNCTION NAME: decompress_code
 272 ------------------------------------------------------------------------------
 273  INPUT AND OUTPUT DEFINITIONS
 274
 275  Inputs:
 276     indx[] -- array of type Word16 -- position and sign of
 277                                       8 pulses (compressed)
 278
 279  Outputs:
 280     sign_indx[] -- array of type Word16 -- signs of 4 pulses (signs only)
 281     pos_indx[]  -- array of type Word16 -- position index of 8 pulses
 282                                            (position only)
 283     pOverflow pointer to type Flag -- Flag set when overflow occurs
 284
 285  Returns:
 286     None
 287
 288  Global Variables Used:
 289     None
 290
 291  Local Variables Needed:
 292     None
 293
 294 ------------------------------------------------------------------------------
 295  FUNCTION DESCRIPTION
 296
 297     PURPOSE: decompression of the linear codewords to 4+three indeces
 298              one bit from each pulse is made robust to errors by
 299              minimizing the phase shift of a bit error.
 300              4 signs (one for each track)
 301              i0,i4,i1 => one index (7+3) bits, 3   LSBs more robust
 302              i2,i6,i5 => one index (7+3) bits, 3   LSBs more robust
 303              i3,i7    => one index (5+2) bits, 2-3 LSbs more robust
 304
 305 ------------------------------------------------------------------------------
 306  REQUIREMENTS
 307
 308  None
 309
 310 ------------------------------------------------------------------------------
 311  REFERENCES
 312
 313  d8_31pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
 314
 315 ------------------------------------------------------------------------------
 316  PSEUDO-CODE
 317
 318
 319 ------------------------------------------------------------------------------
 320  RESOURCES USED [optional]
 321
 322  When the code is written for a specific target processor the
 323  the resources used should be documented below.
 324
 325  HEAP MEMORY USED: x bytes
 326
 327  STACK MEMORY USED: x bytes
 328
 329  CLOCK CYCLES: (cycle count equation for this function) + (variable
 330                 used to represent cycle count for each subroutine
 331                 called)
 332      where: (cycle count variable) = cycle count for [subroutine
 333                                      name]
 334
 335 ------------------------------------------------------------------------------
 336  CAUTION [optional]
 337  [State any special notes, constraints or cautions for users of this function]
 338
 339 ------------------------------------------------------------------------------
 340 */
 341
 342 static void decompress_code(
 343     Word16 indx[],      /* i : position and sign of 8 pulses (compressed) */
 344     Word16 sign_indx[], /* o : signs of 4 pulses (signs only)             */
 345     Word16 pos_indx[],  /* o : position index of 8 pulses (position only) */
 346     Flag  *pOverflow    /* o : Flag set when overflow occurs              */
 347 )
 348 {
 349     Word16 i;
 350     Word16 ia;
 351     Word16 ib;
 352     Word16 MSBs;
 353     Word16 LSBs;
 354     Word16 MSBs0_24;
 355     Word32 tempWord32;
 356
 357     for (i = 0; i < NB_TRACK_MR102; i++)
 358     {
 359         sign_indx[i] = indx[i];
 360     }
 361
 362     /*
 363       First index: 10x10x10 -> 2x5x2x5x2x5-> 125x2x2x2 -> 7+1x3 bits
 364       MSBs = indx[NB_TRACK]/8;
 365       LSBs = indx[NB_TRACK]%8;
 366       */
 367     MSBs = indx[NB_TRACK_MR102] >> 3;
 368
 369     LSBs = indx[NB_TRACK_MR102] & 0x7;
 370
 371     decompress10(
 372         MSBs,
 373         LSBs,
 374         0,
 375         4,
 376         1,
 377         pos_indx,
 378         pOverflow);
 379
 380     /*
 381       Second index: 10x10x10 -> 2x5x2x5x2x5-> 125x2x2x2 -> 7+1x3 bits
 382       MSBs = indx[NB_TRACK+1]/8;
 383       LSBs = indx[NB_TRACK+1]%8;
 384       */
 385     MSBs = indx[NB_TRACK_MR102+1] >> 3;
 386
 387     LSBs = indx[NB_TRACK_MR102+1] & 0x7;
 388
 389     decompress10(
 390         MSBs,
 391         LSBs,
 392         2,
 393         6,
 394         5,
 395         pos_indx,
 396         pOverflow);
 397
 398     /*
 399       Third index: 10x10 -> 2x5x2x5-> 25x2x2 -> 5+1x2 bits
 400       MSBs = indx[NB_TRACK+2]/4;
 401       LSBs = indx[NB_TRACK+2]%4;
 402       MSBs0_24 = (MSBs*25+12)/32;
 403       if ((MSBs0_24/5)%2==1)
 404          pos_indx[3] = (4-(MSBs0_24%5))*2 + LSBs%2;
 405       else
 406          pos_indx[3] = (MSBs0_24%5)*2 + LSBs%2;
 407       pos_indx[7] = (MSBs0_24/5)*2 + LSBs/2;
 408       */
 409
 410     MSBs = indx[NB_TRACK_MR102+2] >> 2;
 411
 412     LSBs = indx[NB_TRACK_MR102+2] & 0x3;
 413
 414     tempWord32 =
 415         L_mult(
 416             MSBs,
 417             25,
 418             pOverflow);
 419
 420     ia =
 421         (Word16)
 422         L_shr(
 423             tempWord32,
 424             1,
 425             pOverflow);
 426
 427     ia += 12;
 428
 429     MSBs0_24 = ia >> 5;
 430
 431
 432     ia =
 433         mult(
 434             MSBs0_24,
 435             6554,
 436             pOverflow);
 437
 438     ia &= 1;
 439
 440
 441     ib =
 442         mult(
 443             MSBs0_24,
 444             6554,
 445             pOverflow);
 446
 447     tempWord32 =
 448         L_mult(
 449             ib,
 450             5,
 451             pOverflow);
 452
 453
 454     ib = MSBs0_24 - (Word16)(tempWord32 >> 1);
 455
 456     if (ia == 1)
 457     {
 458         ib = 4 - ib;
 459
 460     }
 461
 462
 463     ib =
 464         shl(
 465             ib,
 466             1,
 467             pOverflow);
 468
 469     ia = LSBs & 0x1;
 470
 471     pos_indx[3] =
 472         add(
 473             ib,
 474             ia,
 475             pOverflow);
 476
 477     ia =
 478         mult(
 479             MSBs0_24,
 480             6554,
 481             pOverflow);
 482
 483     ia =
 484         shl(
 485             ia,
 486             1,
 487             pOverflow);
 488
 489     pos_indx[7] = ia + (LSBs >> 1);
 490
 491 }
 492
 493 /*
 494 ------------------------------------------------------------------------------
 495  FUNCTION NAME: dec_8i40_31bits
 496 ------------------------------------------------------------------------------
 497  INPUT AND OUTPUT DEFINITIONS
 498
 499  Inputs:
 500     index   array of type Word16 --  index of 8 pulses (sign+position)
 501
 502  Outputs:
 503     cod     array of type Word16 --  algebraic (fixed) codebook excitation
 504     pOverflow pointer to type Flag -- Flag set when overflow occurs
 505
 506  Returns:
 507     None
 508
 509  Global Variables Used:
 510     None
 511
 512  Local Variables Needed:
 513     None
 514
 515 ------------------------------------------------------------------------------
 516  FUNCTION DESCRIPTION
 517
 518  PURPOSE:  Builds the innovative codevector from the received
 519            index of algebraic codebook.
 520
 521 ------------------------------------------------------------------------------
 522  REQUIREMENTS
 523
 524  None
 525
 526 ------------------------------------------------------------------------------
 527  REFERENCES
 528
 529  d8_31pf.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
 530
 531 ------------------------------------------------------------------------------
 532  PSEUDO-CODE
 533
 534
 535 ------------------------------------------------------------------------------
 536  RESOURCES USED [optional]
 537
 538  When the code is written for a specific target processor the
 539  the resources used should be documented below.
 540
 541  HEAP MEMORY USED: x bytes
 542
 543  STACK MEMORY USED: x bytes
 544
 545  CLOCK CYCLES: (cycle count equation for this function) + (variable
 546                 used to represent cycle count for each subroutine
 547                 called)
 548      where: (cycle count variable) = cycle count for [subroutine
 549                                      name]
 550
 551 ------------------------------------------------------------------------------
 552  CAUTION [optional]
 553  [State any special notes, constraints or cautions for users of this function]
 554
 555 ------------------------------------------------------------------------------
 556 */
 557
 558 void dec_8i40_31bits(
 559     Word16 index[],    /* i : index of 8 pulses (sign+position)         */
 560     Word16 cod[],      /* o : algebraic (fixed) codebook excitation     */
 561     Flag  *pOverflow   /* o : Flag set when overflow occurs             */
 562 )
 563 {
 564     Word16 i;
 565     Word16 j;
 566     Word16 pos1;
 567     Word16 pos2;
 568     Word16 sign;
 569
 570     Word16 linear_signs[NB_TRACK_MR102];
 571     Word16 linear_codewords[NB_PULSE];
 572
 573     for (i = 0; i < L_CODE; i++)
 574     {
 575         cod[i] = 0;
 576     }
 577
 578     decompress_code(
 579         index,
 580         linear_signs,
 581         linear_codewords,
 582         pOverflow);
 583
 584     /* decode the positions and signs of pulses and build the codeword */
 585     for (j = 0; j < NB_TRACK_MR102; j++)    /* NB_TRACK_MR102 = 4 */
 586     {
 587         /* position of pulse "j" */
 588
 589         pos1 = (linear_codewords[j] << 2) + j;
 590
 591
 592         if (linear_signs[j] == 0)
 593         {
 594             sign = POS_CODE; /* +1.0 */
 595         }
 596         else
 597         {
 598             sign = -NEG_CODE; /* -1.0 */
 599         }
 600
 601         if (pos1 < L_SUBFR)
 602         {
 603             cod[pos1] = sign;    /* avoid buffer overflow */
 604         }
 605
 606         /* compute index i */
 607         /* position of pulse "j+4" */
 608
 609         pos2 = (linear_codewords[j + 4] << 2) + j;
 610
 611
 612         if (pos2 < pos1)
 613         {
 614             sign = negate(sign);
 615         }
 616
 617         if (pos2 < L_SUBFR)
 618         {
 619             cod[pos2] += sign;     /* avoid buffer overflow */
 620         }
 621
 622
 623     } /* for (j = 0; j < NB_TRACK_MR102; j++) */
 624
 625     return;
 626 }