frameworks/base/media/libstagefright/codecs/mp3dec/src/pvmp3_framedecoder.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 ------------------------------------------------------------------------------
  20
  21    PacketVideo Corp.
  22    MP3 Decoder Library
  23
  24    Filename: pvmp3_framedecoder.cpp
  25
  26    Functions:
  27     pvmp3_framedecoder
  28     pvmp3_InitDecoder
  29     pvmp3_resetDecoder
  30
  31     Date: 09/21/2007
  32
  33 ------------------------------------------------------------------------------
  34  REVISION HISTORY
  35
  36
  37  Description:
  38
  39 ------------------------------------------------------------------------------
  40  INPUT AND OUTPUT DEFINITIONS
  41
  42 Input
  43     pExt = pointer to the external interface structure. See the file
  44            pvmp3decoder_api.h for a description of each field.
  45            Data type of pointer to a tPVMP3DecoderExternal
  46            structure.
  47
  48     pMem = void pointer to hide the internal implementation of the library
  49            It is cast back to a tmp3dec_file structure. This structure
  50            contains information that needs to persist between calls to
  51            this function, or is too big to be placed on the stack, even
  52            though the data is only needed during execution of this function
  53            Data type void pointer, internally pointer to a tmp3dec_file
  54            structure.
  55
  56
  57  Outputs:
  58      status = ERROR condition.  see structure  ERROR_CODE
  59
  60  Pointers and Buffers Modified:
  61     pMem contents are modified.
  62     pExt: (more detail in the file pvmp3decoder_api.h)
  63     inputBufferUsedLength - number of array elements used up by the stream.
  64     samplingRate - sampling rate in samples per sec
  65     bitRate - bit rate in bits per second, varies frame to frame.
  66
  67
  68
  69 ------------------------------------------------------------------------------
  70  FUNCTIONS DESCRIPTION
  71
  72     pvmp3_framedecoder
  73         frame decoder library driver
  74     pvmp3_InitDecoder
  75         Decoder Initialization
  76     pvmp3_resetDecoder
  77         Reset Decoder
  78
  79 ------------------------------------------------------------------------------
  80  REQUIREMENTS
  81
  82
  83 ------------------------------------------------------------------------------
  84  REFERENCES
  85
  86  [1] ISO MPEG Audio Subgroup Software Simulation Group (1996)
  87      ISO 13818-3 MPEG-2 Audio Decoder - Lower Sampling Frequency Extension
  88
  89 ------------------------------------------------------------------------------
  90  PSEUDO-CODE
  91
  92 ------------------------------------------------------------------------------
  93 */
  94
  95
  96 /*----------------------------------------------------------------------------
  97 ; INCLUDES
  98 ----------------------------------------------------------------------------*/
  99
 100
 101 #include "pvmp3_framedecoder.h"
 102 #include "pvmp3_dec_defs.h"
 103 #include "pvmp3_poly_phase_synthesis.h"
 104 #include "pvmp3_tables.h"
 105 #include "pvmp3_imdct_synth.h"
 106 #include "pvmp3_alias_reduction.h"
 107 #include "pvmp3_reorder.h"
 108 #include "pvmp3_dequantize_sample.h"
 109 #include "pvmp3_stereo_proc.h"
 110 #include "pvmp3_mpeg2_stereo_proc.h"
 111 #include "pvmp3_get_side_info.h"
 112 #include "pvmp3_get_scale_factors.h"
 113 #include "pvmp3_mpeg2_get_scale_factors.h"
 114 #include "pvmp3_decode_header.h"
 115 #include "pvmp3_get_main_data_size.h"
 116 #include "s_tmp3dec_file.h"
 117 #include "pvmp3_getbits.h"
 118 #include "mp3_mem_funcs.h"
 119
 120
 121 /*----------------------------------------------------------------------------
 122 ; MACROS
 123 ; Define module specific macros here
 124 ----------------------------------------------------------------------------*/
 125
 126
 127 /*----------------------------------------------------------------------------
 128 ; DEFINES
 129 ; Include all pre-processor statements here. Include conditional
 130 ; compile variables also.
 131 ----------------------------------------------------------------------------*/
 132
 133 /*----------------------------------------------------------------------------
 134 ; LOCAL FUNCTION DEFINITIONS
 135 ; Function Prototype declaration
 136 ----------------------------------------------------------------------------*/
 137
 138 /*----------------------------------------------------------------------------
 139 ; LOCAL STORE/BUFFER/POINTER DEFINITIONS
 140 ; Variable declaration - defined here and used outside this module
 141 ----------------------------------------------------------------------------*/
 142
 143 /*----------------------------------------------------------------------------
 144 ; EXTERNAL FUNCTION REFERENCES
 145 ; Declare functions defined elsewhere and referenced in this module
 146 ----------------------------------------------------------------------------*/
 147
 148 /*----------------------------------------------------------------------------
 149 ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
 150 ; Declare variables used in this module but defined elsewhere
 151 ----------------------------------------------------------------------------*/
 152
 153 /*----------------------------------------------------------------------------
 154 ; FUNCTION CODE
 155 ----------------------------------------------------------------------------*/
 156
 157 ERROR_CODE pvmp3_framedecoder(tPVMP3DecoderExternal *pExt,
 158                               void              *pMem)
 159 {
 160
 161     ERROR_CODE        errorCode  = NO_DECODING_ERROR;
 162
 163     int32   crc_error_count = 0;
 164     uint32  sent_crc = 0;
 165     uint32  computed_crc = 0;
 166
 167     tmp3dec_chan   *pChVars[CHAN];
 168     tmp3dec_file   *pVars = (tmp3dec_file *)pMem;
 169
 170     mp3Header info_data;
 171     mp3Header *info = &info_data;
 172
 173     pVars->inputStream.pBuffer  = pExt->pInputBuffer;
 174
 175
 176     pVars->inputStream.usedBits  = pExt->inputBufferUsedLength << 3;
 177     pVars->inputStream.inputBufferCurrentLength  = pExt->inputBufferCurrentLength;
 178
 179
 180     errorCode = pvmp3_decode_header(&pVars->inputStream,
 181                                     info,
 182                                     &computed_crc);
 183
 184     if (errorCode != NO_DECODING_ERROR)
 185     {
 186         pExt->outputFrameSize = 0;
 187         return errorCode;
 188     }
 189
 190     pVars->num_channels = (info->mode == MPG_MD_MONO) ? 1 : 2;
 191     pExt->num_channels = pVars->num_channels;
 192
 193     int32 outputFrameSize = (info->version_x == MPEG_1) ?
 194                             2 * SUBBANDS_NUMBER * FILTERBANK_BANDS :
 195                             SUBBANDS_NUMBER * FILTERBANK_BANDS;
 196
 197     outputFrameSize = (info->mode == MPG_MD_MONO) ? outputFrameSize : outputFrameSize << 1;
 198
 199
 200     /*
 201      *  Check if output buffer has enough room to hold output PCM
 202      */
 203     if (pExt->outputFrameSize >= outputFrameSize)
 204     {
 205         pExt->outputFrameSize = outputFrameSize;
 206     }
 207     else
 208     {
 209         pExt->outputFrameSize = 0;
 210         return OUTPUT_BUFFER_TOO_SMALL;
 211     }
 212
 213
 214     pChVars[ LEFT] = &pVars->perChan[ LEFT];
 215     pChVars[RIGHT] = &pVars->perChan[RIGHT];
 216
 217
 218
 219
 220     if (info->error_protection)
 221     {
 222         /*
 223          *  Get crc content
 224          */
 225         sent_crc = getUpTo17bits(&pVars->inputStream, 16);
 226     }
 227
 228
 229     if (info->layer_description == 3)
 230     {
 231         int32 gr;
 232         int32 ch;
 233         uint32 main_data_end;
 234         int32 bytes_to_discard;
 235         int16 *ptrOutBuffer = pExt->pOutputBuffer;
 236
 237         /*
 238          * Side Information must be extracted from the bitstream and store for use
 239          * during the decoded of the associated frame
 240          */
 241
 242         errorCode = pvmp3_get_side_info(&pVars->inputStream,
 243                                         &pVars->sideInfo,
 244                                         info,
 245                                         &computed_crc);
 246
 247         if (errorCode != NO_DECODING_ERROR)
 248         {
 249             pExt->outputFrameSize = 0;
 250             return errorCode;
 251         }
 252
 253         /*
 254          *  If CRC was sent, check that matches the one got while parsing data
 255          *  disable crc if this is the desired mode
 256          */
 257         if (info->error_protection)
 258         {
 259             if ((computed_crc != sent_crc) && pExt->crcEnabled)
 260             {
 261                 crc_error_count++;
 262             }
 263         }
 264
 265         /*
 266          * main data (scalefactors, Huffman coded, etc,) are not necessarily located
 267          * adjacent to the side-info. Beginning of main data is located using
 268          * field "main_data_begin" of the current frame. The length does not include
 269          * header and side info.
 270          * "main_data_begin" points to the first bit of main data of a frame. It is a negative
 271          * offset in bytes from the first byte of the sync word
 272          * main_data_begin = 0  <===> main data start rigth after side info.
 273          */
 274
 275         int32 temp = pvmp3_get_main_data_size(info, pVars);
 276
 277
 278         /*
 279          *  Check if available data holds a full frame, if not flag an error
 280          */
 281
 282         if ((uint32)pVars->predicted_frame_size > pVars->inputStream.inputBufferCurrentLength)
 283         {
 284             pExt->outputFrameSize = 0;
 285             return NO_ENOUGH_MAIN_DATA_ERROR;
 286         }
 287
 288         /*
 289          *  Fill in internal circular buffer
 290          */
 291         fillMainDataBuf(pVars, temp);
 292
 293
 294         main_data_end = pVars->mainDataStream.usedBits >> 3; /* in bytes */
 295         if ((main_data_end << 3) < pVars->mainDataStream.usedBits)
 296         {
 297             main_data_end++;
 298             pVars->mainDataStream.usedBits = main_data_end << 3;
 299         }
 300
 301
 302         bytes_to_discard = pVars->frame_start - pVars->sideInfo.main_data_begin - main_data_end;
 303
 304
 305         if (main_data_end > BUFSIZE)   /* check overflow on the buffer */
 306         {
 307             pVars->frame_start -= BUFSIZE;
 308
 309             pVars->mainDataStream.usedBits -= (BUFSIZE << 3);
 310         }
 311
 312         pVars->frame_start += temp;
 313
 314
 315         if (bytes_to_discard < 0 || crc_error_count)
 316         {
 317             /*
 318              *  Not enough data to decode, then we should avoid reading this
 319              *  data ( getting/ignoring sido info and scale data)
 320              *  Main data could be located in the previous frame, so an unaccounted
 321              *  frame can cause incorrect processing
 322              *  Just run the polyphase filter to "clean" the history buffer
 323              */
 324             errorCode = NO_ENOUGH_MAIN_DATA_ERROR;
 325
 326             /*
 327              *  Clear the input to these filters
 328              */
 329
 330             pv_memset((void*)pChVars[RIGHT]->work_buf_int32,
 331                       0,
 332                       SUBBANDS_NUMBER*FILTERBANK_BANDS*sizeof(pChVars[RIGHT]->work_buf_int32[0]));
 333
 334             pv_memset((void*)pChVars[LEFT]->work_buf_int32,
 335                       0,
 336                       SUBBANDS_NUMBER*FILTERBANK_BANDS*sizeof(pChVars[LEFT]->work_buf_int32[0]));
 337
 338             /*  clear circular buffers, to avoid any glitch */
 339             pv_memset((void*)&pChVars[ LEFT]->circ_buffer[576],
 340                       0,
 341                       480*sizeof(pChVars[ LEFT]->circ_buffer[0]));
 342             pv_memset((void*)&pChVars[RIGHT]->circ_buffer[576],
 343                       0,
 344                       480*sizeof(pChVars[RIGHT]->circ_buffer[0]));
 345
 346             pChVars[ LEFT]->used_freq_lines = 575;
 347             pChVars[RIGHT]->used_freq_lines = 575;
 348
 349         }
 350         else
 351         {
 352             pVars->mainDataStream.usedBits += (bytes_to_discard << 3);
 353         }
 354
 355         /*
 356          *  if (fr_ps->header->version_x == MPEG_1), use 2 granules, otherwise just 1
 357          */
 358         for (gr = 0; gr < (1 + !(info->version_x)); gr++)
 359         {
 360             if (errorCode != NO_ENOUGH_MAIN_DATA_ERROR)
 361             {
 362                 for (ch = 0; ch < pVars->num_channels; ch++)
 363                 {
 364                     int32 part2_start = pVars->mainDataStream.usedBits;
 365
 366                     if (info->version_x == MPEG_1)
 367                     {
 368
 369                         pvmp3_get_scale_factors(&pVars->scaleFactors[ch],
 370                                                 &pVars->sideInfo,
 371                                                 gr,
 372                                                 ch,
 373                                                 &pVars->mainDataStream);
 374                     }
 375                     else
 376                     {
 377                         int32 * tmp = pVars->Scratch_mem;
 378                         pvmp3_mpeg2_get_scale_factors(&pVars->scaleFactors[ch],
 379                                                       &pVars->sideInfo,
 380                                                       gr,
 381                                                       ch,
 382                                                       info,
 383                                                       (uint32 *)tmp,
 384                                                       &pVars->mainDataStream);
 385                     }
 386
 387                     pChVars[ch]->used_freq_lines = pvmp3_huffman_parsing(pChVars[ch]->work_buf_int32,
 388                                                    &pVars->sideInfo.ch[ch].gran[gr],
 389                                                    pVars,
 390                                                    part2_start,
 391                                                    info);
 392
 393
 394                     pvmp3_dequantize_sample(pChVars[ch]->work_buf_int32,
 395                                             &pVars->scaleFactors[ch],
 396                                             &pVars->sideInfo.ch[ch].gran[gr],
 397                                             pChVars[ch]->used_freq_lines,
 398                                             info);
 399
 400
 401
 402
 403                 }   /* for (ch=0; ch<stereo; ch++)  */
 404
 405                 if (pVars->num_channels == 2)
 406                 {
 407
 408                     int32 used_freq_lines = (pChVars[ LEFT]->used_freq_lines  >
 409                                              pChVars[RIGHT]->used_freq_lines) ?
 410                                             pChVars[ LEFT]->used_freq_lines  :
 411                                             pChVars[RIGHT]->used_freq_lines;
 412
 413                     pChVars[ LEFT]->used_freq_lines = used_freq_lines;
 414                     pChVars[RIGHT]->used_freq_lines = used_freq_lines;
 415
 416                     if (info->version_x == MPEG_1)
 417                     {
 418                         pvmp3_stereo_proc(pChVars[ LEFT]->work_buf_int32,
 419                                           pChVars[RIGHT]->work_buf_int32,
 420                                           &pVars->scaleFactors[RIGHT],
 421                                           &pVars->sideInfo.ch[LEFT].gran[gr],
 422                                           used_freq_lines,
 423                                           info);
 424                     }
 425                     else
 426                     {
 427                         int32 * tmp = pVars->Scratch_mem;
 428                         pvmp3_mpeg2_stereo_proc(pChVars[ LEFT]->work_buf_int32,
 429                                                 pChVars[RIGHT]->work_buf_int32,
 430                                                 &pVars->scaleFactors[RIGHT],
 431                                                 &pVars->sideInfo.ch[ LEFT].gran[gr],
 432                                                 &pVars->sideInfo.ch[RIGHT].gran[gr],
 433                                                 (uint32 *)tmp,
 434                                                 used_freq_lines,
 435                                                 info);
 436                     }
 437                 }
 438
 439             } /* if ( errorCode != NO_ENOUGH_MAIN_DATA_ERROR) */
 440
 441             for (ch = 0; ch < pVars->num_channels; ch++)
 442             {
 443
 444                 pvmp3_reorder(pChVars[ch]->work_buf_int32,
 445                               &pVars->sideInfo.ch[ch].gran[gr],
 446                               &pChVars[ ch]->used_freq_lines,
 447                               info,
 448                               pVars->Scratch_mem);
 449
 450                 pvmp3_alias_reduction(pChVars[ch]->work_buf_int32,
 451                                       &pVars->sideInfo.ch[ch].gran[gr],
 452                                       &pChVars[ ch]->used_freq_lines,
 453                                       info);
 454
 455
 456                 /*
 457                  *   IMDCT
 458                  */
 459                 /* set mxposition
 460                  * In case of mixed blocks, # of bands with long
 461                  * blocks (2 or 4) else 0
 462                  */
 463                 uint16 mixedBlocksLongBlocks = 0; /*  0 = long or short, 2=mixed, 4=mixed 2.5@8000 */
 464                 if (pVars->sideInfo.ch[ch].gran[gr].mixed_block_flag &&
 465                         pVars->sideInfo.ch[ch].gran[gr].window_switching_flag)
 466                 {
 467                     if ((info->version_x == MPEG_2_5) && (info->sampling_frequency == 2))
 468                     {
 469                         mixedBlocksLongBlocks = 4; /* mpeg2.5 @ 8 KHz */
 470                     }
 471                     else
 472                     {
 473                         mixedBlocksLongBlocks = 2;
 474                     }
 475                 }
 476
 477                 pvmp3_imdct_synth(pChVars[ch]->work_buf_int32,
 478                                   pChVars[ch]->overlap,
 479                                   pVars->sideInfo.ch[ch].gran[gr].block_type,
 480                                   mixedBlocksLongBlocks,
 481                                   pChVars[ ch]->used_freq_lines,
 482                                   pVars->Scratch_mem);
 483
 484
 485                 /*
 486                  *   Polyphase synthesis
 487                  */
 488
 489                 pvmp3_poly_phase_synthesis(pChVars[ch],
 490                                            pVars->num_channels,
 491                                            pExt->equalizerType,
 492                                            &ptrOutBuffer[ch]);
 493
 494
 495             }/* end ch loop */
 496
 497             ptrOutBuffer += pVars->num_channels * SUBBANDS_NUMBER * FILTERBANK_BANDS;
 498         }  /*   for (gr=0;gr<Max_gr;gr++)  */
 499
 500         /* skip ancillary data */
 501         if (info->bitrate_index > 0)
 502         { /* if not free-format */
 503
 504             int32 ancillary_data_lenght = pVars->predicted_frame_size << 3;
 505
 506             ancillary_data_lenght  -= pVars->inputStream.usedBits;
 507
 508             /* skip ancillary data */
 509             if (ancillary_data_lenght > 0)
 510             {
 511                 pVars->inputStream.usedBits += ancillary_data_lenght;
 512             }
 513
 514         }
 515
 516         /*
 517          *  This overrides a possible NO_ENOUGH_MAIN_DATA_ERROR
 518          */
 519         errorCode = NO_DECODING_ERROR;
 520
 521     }
 522     else
 523     {
 524         /*
 525          * The info on the header leads to an unsupported layer, more data
 526          * will not fix this, so this is a bad frame,
 527          */
 528
 529         pExt->outputFrameSize = 0;
 530         return UNSUPPORTED_LAYER;
 531     }
 532
 533     pExt->inputBufferUsedLength = pVars->inputStream.usedBits >> 3;
 534     pExt->totalNumberOfBitsUsed += pVars->inputStream.usedBits;
 535     pExt->version = info->version_x;
 536     pExt->samplingRate = mp3_s_freq[info->version_x][info->sampling_frequency];
 537     pExt->bitRate = mp3_bitrate[pExt->version][info->bitrate_index];
 538
 539
 540     /*
 541      *  Always verify buffer overrun condition
 542      */
 543
 544     if (pExt->inputBufferUsedLength > pExt->inputBufferCurrentLength)
 545     {
 546         pExt->outputFrameSize = 0;
 547         errorCode = NO_ENOUGH_MAIN_DATA_ERROR;
 548     }
 549
 550     return errorCode;
 551
 552 }
 553
 554
 555 /*----------------------------------------------------------------------------
 556 ; FUNCTION CODE
 557 ----------------------------------------------------------------------------*/
 558
 559 __inline void fillDataBuf(tmp3Bits *pMainData,
 560                           uint32 val)       /* val to write into the buffer */
 561 {
 562     pMainData->pBuffer[module(pMainData->offset++, BUFSIZE)] = (uint8)val;
 563 }
 564
 565
 566 void fillMainDataBuf(void  *pMem, int32 temp)
 567 {
 568     tmp3dec_file   *pVars = (tmp3dec_file *)pMem;
 569
 570
 571     int32 offset = (pVars->inputStream.usedBits) >> INBUF_ARRAY_INDEX_SHIFT;
 572
 573     /*
 574      *  Check if input circular buffer boundaries need to be enforced
 575      */
 576     if ((offset + temp) < BUFSIZE)
 577     {
 578         uint8 * ptr = pVars->inputStream.pBuffer + offset;
 579
 580         offset = pVars->mainDataStream.offset;
 581
 582         /*
 583          *  Check if main data circular buffer boundaries need to be enforced
 584          */
 585         if ((offset + temp) < BUFSIZE)
 586         {
 587             pv_memcpy((pVars->mainDataStream.pBuffer + offset), ptr, temp*sizeof(uint8));
 588             pVars->mainDataStream.offset += temp;
 589         }
 590         else
 591         {
 592             int32 tmp1 = *(ptr++);
 593             for (int32 nBytes = temp >> 1; nBytes != 0; nBytes--)  /* read main data. */
 594             {
 595                 int32 tmp2 = *(ptr++);
 596                 fillDataBuf(&pVars->mainDataStream, tmp1);
 597                 fillDataBuf(&pVars->mainDataStream, tmp2);
 598                 tmp1 = *(ptr++);
 599             }
 600
 601             if (temp&1)
 602             {
 603                 fillDataBuf(&pVars->mainDataStream, tmp1);
 604             }
 605
 606             /* adjust circular buffer counter */
 607             pVars->mainDataStream.offset = module(pVars->mainDataStream.offset, BUFSIZE);
 608         }
 609     }
 610     else
 611     {
 612         for (int32 nBytes = temp >> 1; nBytes != 0; nBytes--)  /* read main data. */
 613         {
 614             fillDataBuf(&pVars->mainDataStream, *(pVars->inputStream.pBuffer + module(offset++  , BUFSIZE)));
 615             fillDataBuf(&pVars->mainDataStream, *(pVars->inputStream.pBuffer + module(offset++  , BUFSIZE)));
 616         }
 617         if (temp&1)
 618         {
 619             fillDataBuf(&pVars->mainDataStream, *(pVars->inputStream.pBuffer + module(offset  , BUFSIZE)));
 620         }
 621     }
 622
 623
 624     pVars->inputStream.usedBits += (temp) << INBUF_ARRAY_INDEX_SHIFT;
 625 }
 626
 627
 628
 629
 630 /*----------------------------------------------------------------------------
 631 ; FUNCTION CODE
 632 ----------------------------------------------------------------------------*/
 633
 634 uint32 pvmp3_decoderMemRequirements(void)
 635 {
 636     uint32 size;
 637
 638     size = (uint32) sizeof(tmp3dec_file);
 639     return (size);
 640 }
 641
 642
 643
 644 /*----------------------------------------------------------------------------
 645 ; FUNCTION CODE
 646 ----------------------------------------------------------------------------*/
 647
 648 #include "pvmp3_decode_huff_cw.h"
 649
 650 void pvmp3_InitDecoder(tPVMP3DecoderExternal *pExt,
 651                        void  *pMem)
 652 {
 653
 654     tmp3dec_file      *pVars;
 655     huffcodetab       *pHuff;
 656
 657     pVars = (tmp3dec_file *)pMem;
 658
 659     pVars->num_channels = 0;
 660
 661     pExt->totalNumberOfBitsUsed = 0;
 662     pExt->inputBufferCurrentLength = 0;
 663     pExt->inputBufferUsedLength    = 0;
 664
 665     pVars->mainDataStream.offset = 0;
 666
 667     pv_memset((void*)pVars->mainDataBuffer,
 668               0,
 669               BUFSIZE*sizeof(*pVars->mainDataBuffer));
 670
 671
 672     pVars->inputStream.pBuffer = pExt->pInputBuffer;
 673
 674     /*
 675      *  Initialize huffman decoding table
 676      */
 677
 678     pHuff = pVars->ht;
 679     pHuff[0].linbits = 0;
 680     pHuff[0].pdec_huff_tab = pvmp3_decode_huff_cw_tab0;
 681     pHuff[1].linbits = 0;
 682     pHuff[1].pdec_huff_tab = pvmp3_decode_huff_cw_tab1;
 683     pHuff[2].linbits = 0;
 684     pHuff[2].pdec_huff_tab = pvmp3_decode_huff_cw_tab2;
 685     pHuff[3].linbits = 0;
 686     pHuff[3].pdec_huff_tab = pvmp3_decode_huff_cw_tab3;
 687     pHuff[4].linbits = 0;
 688     pHuff[4].pdec_huff_tab = pvmp3_decode_huff_cw_tab0; /* tbl 4 is not used */
 689     pHuff[5].linbits = 4;
 690     pHuff[5].pdec_huff_tab = pvmp3_decode_huff_cw_tab5;
 691     pHuff[6].linbits = 0;
 692     pHuff[6].pdec_huff_tab = pvmp3_decode_huff_cw_tab6;
 693     pHuff[7].linbits = 0;
 694     pHuff[7].pdec_huff_tab = pvmp3_decode_huff_cw_tab7;
 695     pHuff[8].linbits = 0;
 696     pHuff[8].pdec_huff_tab = pvmp3_decode_huff_cw_tab8;
 697     pHuff[9].linbits = 0;
 698     pHuff[9].pdec_huff_tab = pvmp3_decode_huff_cw_tab9;
 699     pHuff[10].linbits = 0;
 700     pHuff[10].pdec_huff_tab = pvmp3_decode_huff_cw_tab10;
 701     pHuff[11].linbits = 0;
 702     pHuff[11].pdec_huff_tab = pvmp3_decode_huff_cw_tab11;
 703     pHuff[12].linbits = 0;
 704     pHuff[12].pdec_huff_tab = pvmp3_decode_huff_cw_tab12;
 705     pHuff[13].linbits = 0;
 706     pHuff[13].pdec_huff_tab = pvmp3_decode_huff_cw_tab13;
 707     pHuff[14].linbits = 0;
 708     pHuff[14].pdec_huff_tab = pvmp3_decode_huff_cw_tab0; /* tbl 14 is not used */
 709     pHuff[15].linbits = 0;
 710     pHuff[15].pdec_huff_tab = pvmp3_decode_huff_cw_tab15;
 711     pHuff[16].linbits = 1;
 712     pHuff[16].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 713     pHuff[17].linbits = 2;
 714     pHuff[17].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 715     pHuff[18].linbits = 3;
 716     pHuff[18].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 717     pHuff[19].linbits = 4;
 718     pHuff[19].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 719     pHuff[20].linbits = 6;
 720     pHuff[20].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 721     pHuff[21].linbits = 8;
 722     pHuff[21].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 723     pHuff[22].linbits = 10;
 724     pHuff[22].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 725     pHuff[23].linbits = 13;
 726     pHuff[23].pdec_huff_tab = pvmp3_decode_huff_cw_tab16;
 727     pHuff[24].linbits = 4;
 728     pHuff[24].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 729     pHuff[25].linbits = 5;
 730     pHuff[25].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 731     pHuff[26].linbits = 6;
 732     pHuff[26].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 733     pHuff[27].linbits = 7;
 734     pHuff[27].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 735     pHuff[28].linbits = 8;
 736     pHuff[28].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 737     pHuff[29].linbits = 9;
 738     pHuff[29].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 739     pHuff[30].linbits = 11;
 740     pHuff[30].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 741     pHuff[31].linbits = 13;
 742     pHuff[31].pdec_huff_tab = pvmp3_decode_huff_cw_tab24;
 743     pHuff[32].linbits = 0;
 744     pHuff[32].pdec_huff_tab = pvmp3_decode_huff_cw_tab32;
 745     pHuff[33].linbits = 0;
 746     pHuff[33].pdec_huff_tab = pvmp3_decode_huff_cw_tab33;
 747
 748     /*
 749      *  Initialize polysynthesis circular buffer mechanism
 750      */
 751     /* clear buffers */
 752
 753     pvmp3_resetDecoder(pMem);
 754
 755 }
 756
 757
 758 /*----------------------------------------------------------------------------
 759 ; FUNCTION CODE
 760 ----------------------------------------------------------------------------*/
 761
 762
 763 void pvmp3_resetDecoder(void  *pMem)
 764 {
 765
 766     tmp3dec_file      *pVars;
 767     tmp3dec_chan      *pChVars[CHAN];
 768
 769     pVars = (tmp3dec_file *)pMem;
 770     pChVars[ LEFT] = &pVars->perChan[ LEFT];
 771     pChVars[RIGHT] = &pVars->perChan[RIGHT];
 772
 773     pVars->frame_start = 0;
 774
 775     pVars->mainDataStream.offset = 0;
 776
 777     pVars->mainDataStream.pBuffer =  pVars->mainDataBuffer;
 778     pVars->mainDataStream.usedBits = 0;
 779
 780
 781     pVars->inputStream.usedBits = 0; // in bits
 782
 783
 784     pChVars[ LEFT]->used_freq_lines = 575;
 785     pChVars[RIGHT]->used_freq_lines = 575;
 786
 787
 788     /*
 789      *  Initialize polysynthesis circular buffer mechanism
 790      */
 791
 792     pv_memset((void*)&pChVars[ LEFT]->circ_buffer[576],
 793               0,
 794               480*sizeof(pChVars[ LEFT]->circ_buffer[0]));
 795     pv_memset((void*)&pChVars[RIGHT]->circ_buffer[576],
 796               0,
 797               480*sizeof(pChVars[RIGHT]->circ_buffer[0]));
 798
 799
 800     pv_memset((void*)pChVars[ LEFT]->overlap,
 801               0,
 802               SUBBANDS_NUMBER*FILTERBANK_BANDS*sizeof(pChVars[ LEFT]->overlap[0]));
 803
 804
 805     pv_memset((void*)pChVars[ RIGHT]->overlap,
 806               0,
 807               SUBBANDS_NUMBER*FILTERBANK_BANDS*sizeof(pChVars[ RIGHT]->overlap[0]));
 808
 809
 810
 811
 812
 813     /*
 814      *  Clear all the structures
 815      */
 816
 817
 818     pv_memset((void*)&pVars->scaleFactors[RIGHT],
 819               0,
 820               sizeof(mp3ScaleFactors));
 821
 822     pv_memset((void*)&pVars->scaleFactors[LEFT],
 823               0,
 824               sizeof(mp3ScaleFactors));
 825
 826     pv_memset((void*)&pVars->sideInfo,
 827               0,
 828               sizeof(mp3SideInfo));
 829
 830     pv_memset((void*)&pVars->sideInfo,
 831               0,
 832               sizeof(mp3SideInfo));
 833
 834 }