| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| /* |
| ------------------------------------------------------------------------------ |
| |
| PacketVideo Corp. |
| MP3 Decoder Library |
| |
| Filename: pvmp3_decode_huff_cw.cpp |
| |
| Funtions: |
| pvmp3_decode_huff_cw_tab0 |
| pvmp3_decode_huff_cw_tab1 |
| pvmp3_decode_huff_cw_tab2 |
| pvmp3_decode_huff_cw_tab3 |
| pvmp3_decode_huff_cw_tab5 |
| pvmp3_decode_huff_cw_tab6 |
| pvmp3_decode_huff_cw_tab7 |
| pvmp3_decode_huff_cw_tab8 |
| pvmp3_decode_huff_cw_tab9 |
| pvmp3_decode_huff_cw_tab10 |
| pvmp3_decode_huff_cw_tab11 |
| pvmp3_decode_huff_cw_tab12 |
| pvmp3_decode_huff_cw_tab13 |
| pvmp3_decode_huff_cw_tab15 |
| pvmp3_decode_huff_cw_tab16 |
| pvmp3_decode_huff_cw_tab24 |
| pvmp3_decode_huff_cw_tab32 |
| pvmp3_decode_huff_cw_tab33 |
| |
| Date: 09/21/2007 |
| |
| ------------------------------------------------------------------------------ |
| REVISION HISTORY |
| |
| |
| Description: |
| |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| BITS *pMainData = pointer to input mp3 Main data bit stream |
| |
| |
| Outputs: |
| cw = bit field extracted from a leaf entry of packed mp3 Huffman Tables |
| |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| These functions are used to decode huffman codewords from the input |
| bitstream using combined binary search and look-up table approach. |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| [1] ISO MPEG Audio Subgroup Software Simulation Group (1996) |
| ISO 13818-3 MPEG-2 Audio Decoder - Lower Sampling Frequency Extension |
| |
| [2] Introduction to Algorithms, |
| Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest. |
| The MIT press, 1990 |
| |
| [3] "Selecting an Optimal Huffman Decoder for AAC", |
| Vladimir Z. Mesarovic, et al. |
| AES 111th Convention, September 21-24, 2001, New York, USA |
| |
| ------------------------------------------------------------------------------ |
| PSEUDO-CODE |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; INCLUDES |
| ----------------------------------------------------------------------------*/ |
| #include "pv_mp3dec_fxd_op.h" |
| #include "pvmp3_tables.h" |
| #include "pvmp3_getbits.h" |
| #include "pvmp3_decode_huff_cw.h" |
| |
| /*---------------------------------------------------------------------------- |
| ; MACROS |
| ; Define module specific macros here |
| ----------------------------------------------------------------------------*/ |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; DEFINES |
| ; Include all pre-processor statements here. Include conditional |
| ; compile variables also. |
| ----------------------------------------------------------------------------*/ |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL FUNCTION DEFINITIONS |
| ; Function Prototype declaration |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL STORE/BUFFER/POINTER DEFINITIONS |
| ; Variable declaration - defined here and used outside this module |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; EXTERNAL FUNCTION REFERENCES |
| ; Declare functions defined elsewhere and referenced in this module |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES |
| ; Declare variables used in this module but defined elsewhere |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| |
| uint16 pvmp3_decode_huff_cw_tab0(tmp3Bits *pMainData) |
| { |
| OSCL_UNUSED_ARG(pMainData); |
| return(0); |
| |
| } |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab1(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo9bits(pMainData, 3); /* hufftable1 */ |
| |
| cw = *(huffTable_1 + tmp); |
| pMainData->usedBits -= (3 - (cw & 0xFF)); |
| return(cw >> 8); |
| |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab2(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo9bits(pMainData, 6); /* huffTable_2,3 */ |
| |
| if (tmp >> 3) |
| { |
| tmp = (tmp >> 3) - 1; |
| } |
| else |
| { |
| tmp = tmp + 7; |
| } |
| |
| cw = *(huffTable_2 + tmp); |
| pMainData->usedBits -= (6 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab3(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo9bits(pMainData, 6); /* huffTable_2,3 */ |
| |
| if (tmp >> 3) |
| { |
| tmp = (tmp >> 3) - 1; |
| } |
| else |
| { |
| tmp = tmp + 7; |
| } |
| |
| cw = *(huffTable_3 + tmp); |
| pMainData->usedBits -= (6 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab5(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo9bits(pMainData, 8); /* huffTable_5 */ |
| |
| if ((tmp >> 5)) |
| { |
| tmp = (tmp >> 5) - 1; |
| } |
| else if ((tmp >> 1) >= 2) |
| { |
| tmp = (tmp >> 1) - 2 + 7; |
| } |
| else |
| { |
| tmp = (tmp & 3) + 21; |
| } |
| |
| cw = *(huffTable_5 + tmp); |
| pMainData->usedBits -= (8 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab6(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo9bits(pMainData, 7); /* huffTable_6 */ |
| if ((tmp >> 3) >= 3) |
| { |
| tmp = (tmp >> 3) - 3; |
| } |
| else if (tmp >> 1) |
| { |
| tmp = (tmp >> 1) - 1 + 13; |
| } |
| else |
| { |
| tmp = tmp + 24; |
| } |
| |
| cw = *(huffTable_6 + tmp); |
| pMainData->usedBits -= (7 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab7(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 10); /* huffTable_7 */ |
| if ((tmp >> 7) >= 2) |
| { |
| tmp = (tmp >> 7) - 2; |
| } |
| else if ((tmp >> 4) >= 7) |
| { |
| tmp = (tmp >> 4) - 7 + 6; |
| } |
| else if ((tmp >> 1) >= 2) |
| { |
| tmp = (tmp >> 1) - 2 + 15; |
| } |
| else |
| { |
| tmp = (tmp & 3) + 69; |
| } |
| |
| cw = *(huffTable_7 + tmp); |
| pMainData->usedBits -= (10 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab8(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 11); /* huffTable_8 */ |
| if ((tmp >> 7) >= 2) |
| { |
| tmp = (tmp >> 7) - 2; |
| } |
| else if ((tmp >> 5) >= 5) |
| { |
| tmp = (tmp >> 5) - 5 + 14; |
| } |
| else if ((tmp >> 2) >= 3) |
| { |
| tmp = (tmp >> 2) - 3 + 17; |
| } |
| else |
| { |
| tmp = (tmp) + 54; |
| } |
| |
| cw = *(huffTable_8 + tmp); |
| pMainData->usedBits -= (11 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab9(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo9bits(pMainData, 9); /* huffTable_9 */ |
| if ((tmp >> 5) >= 5) |
| { |
| tmp = (tmp >> 5) - 5; |
| } |
| else if ((tmp >> 3) >= 6) |
| { |
| tmp = (tmp >> 3) - 6 + 11; |
| } |
| else if ((tmp >> 1) >= 4) |
| { |
| tmp = (tmp >> 1) - 4 + 25; |
| } |
| else |
| { |
| tmp = tmp + 45; |
| } |
| |
| cw = *(huffTable_9 + tmp); |
| pMainData->usedBits -= (9 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab10(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 11); /* huffTable_10 */ |
| if (tmp >> 10) |
| { |
| tmp = (tmp >> 10) - 1; |
| } |
| else if ((tmp >> 7) >= 3) |
| { |
| tmp = (tmp >> 7) - 3 + 1; |
| } |
| else if ((tmp >> 5) >= 8) |
| { |
| tmp = (tmp >> 5) - 8 + 6; |
| } |
| else if ((tmp >> 3) >= 18) |
| { |
| tmp = (tmp >> 3) - 18 + 10; |
| } |
| else if ((tmp >> 2) >= 24) |
| { |
| tmp = (tmp >> 2) - 24 + 24; |
| } |
| else if ((tmp >> 1) >= 12) |
| { |
| tmp = (tmp >> 1) - 12 + 36; |
| } |
| else |
| { |
| tmp = (tmp) + 72; |
| } |
| |
| cw = *(huffTable_10 + tmp); |
| pMainData->usedBits -= (11 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab11(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 11); /* huffTable_11 */ |
| if ((tmp >> 8) >= 3) |
| { |
| tmp = (tmp >> 8) - 3; |
| } |
| else if ((tmp >> 6) >= 7) |
| { |
| tmp = (tmp >> 6) - 7 + 5; |
| } |
| else if ((tmp >> 3) >= 32) |
| { |
| tmp = (tmp >> 3) - 32 + 10; |
| } |
| else if ((tmp >> 2) >= 10) |
| { |
| tmp = (tmp >> 2) - 10 + 34; |
| } |
| else if ((tmp >> 1) >= 8) |
| { |
| tmp = (tmp >> 1) - 8 + 88; |
| } |
| else |
| { |
| tmp = (tmp & 0xFF) + 100; |
| } |
| cw = *(huffTable_11 + tmp); |
| pMainData->usedBits -= (11 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab12(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 10); /* huffTable_12 */ |
| if ((tmp >> 7) >= 5) |
| { |
| tmp = (tmp >> 7) - 5; |
| } |
| else if ((tmp >> 5) >= 12) |
| { |
| tmp = (tmp >> 5) - 12 + 3; |
| } |
| else if ((tmp >> 4) >= 17) |
| { |
| tmp = (tmp >> 4) - 17 + 11; |
| } |
| else if ((tmp >> 2) >= 32) |
| { |
| tmp = (tmp >> 2) - 32 + 18; |
| } |
| else if ((tmp >> 1) >= 16) |
| { |
| tmp = (tmp >> 1) - 16 + 54; |
| } |
| else |
| { |
| tmp = (tmp & 0x1F) + 102; |
| |
| } |
| cw = *(huffTable_12 + tmp); |
| pMainData->usedBits -= (10 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab13(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getNbits(pMainData, 19); /* huffTable_13 */ |
| if (tmp >> 18) |
| { |
| tmp = 0; |
| } |
| else if ((tmp >> 15) >= 4) |
| { |
| tmp = (tmp >> 15) - 4 + 1; |
| } |
| else if ((tmp >> 11) >= 32) |
| { |
| tmp = (tmp >> 11) - 32 + 5; |
| } |
| else if ((tmp >> 9) >= 64) |
| { |
| tmp = (tmp >> 9) - 64 + 37; |
| } |
| else if ((tmp >> 8) >= 64) |
| { |
| tmp = (tmp >> 8) - 64 + 101; |
| } |
| else if ((tmp >> 7) >= 64) |
| { |
| tmp = (tmp >> 7) - 64 + 165; |
| } |
| else if ((tmp >> 6) >= 32) |
| { |
| tmp = (tmp >> 6) - 32 + 229; |
| } |
| else if ((tmp >> 5) >= 32) |
| { |
| tmp = (tmp >> 5) - 32 + 325; |
| } |
| else if ((tmp >> 4) >= 32) |
| { |
| tmp = (tmp >> 4) - 32 + 357; |
| } |
| else if ((tmp >> 3) >= 32) |
| { |
| tmp = (tmp >> 3) - 32 + 389; |
| } |
| else if ((tmp >> 2) >= 2) |
| { |
| tmp = (tmp >> 2) - 2 + 421; |
| } |
| else |
| { |
| tmp = (tmp & 0x7) + 483; |
| } |
| |
| cw = *(huffTable_13 + tmp); |
| pMainData->usedBits -= (19 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab15(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 13); /* huffTable_15 */ |
| if ((tmp >> 9) >= 10) |
| { |
| tmp = (tmp >> 9) - 10; |
| } |
| else if ((tmp >> 6) >= 39) |
| { |
| tmp = (tmp >> 6) - 39 + 6; |
| } |
| else if ((tmp >> 4) >= 62) |
| { |
| tmp = (tmp >> 4) - 62 + 47; |
| } |
| else if ((tmp >> 3) >= 60) |
| { |
| tmp = (tmp >> 3) - 60 + 141; |
| } |
| else if ((tmp >> 2) >= 64) |
| { |
| tmp = (tmp >> 2) - 64 + 205; |
| } |
| else if ((tmp >> 1) >= 32) |
| { |
| tmp = (tmp >> 1) - 32 + 261; |
| } |
| else |
| { |
| tmp = (tmp & 0x3f) + 357; |
| } |
| |
| cw = *(huffTable_15 + tmp); |
| pMainData->usedBits -= (13 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab16(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 17); /* huffTable_16 */ |
| if (tmp >> 16) |
| { |
| tmp = 0; |
| } |
| else if ((tmp >> 13) >= 4) |
| { |
| tmp = (tmp >> 13) - 4 + 1; |
| } |
| else if ((tmp >> 9) >= 38) |
| { |
| tmp = (tmp >> 9) - 38 + 5; |
| } |
| else if ((tmp >> 7) >= 94) |
| { |
| tmp = (tmp >> 7) - 94 + 31; |
| } |
| else if ((tmp >> 5) >= 214) |
| { |
| tmp = (tmp >> 5) - 214 + 89; |
| } |
| else if ((tmp >> 3) >= 704) |
| { |
| if ((tmp >> 4) >= 384) |
| { |
| tmp = (tmp >> 4) - 384 + 315; |
| } |
| else |
| { |
| tmp = (tmp >> 3) - 704 + 251; |
| } |
| } |
| else if ((tmp >> 8) >= 14) |
| { |
| tmp = (tmp >> 8) - 14 + 359; |
| } |
| else if ((tmp) >= 3456) |
| { |
| if ((tmp >> 2) >= 868) |
| { |
| tmp = (tmp >> 2) - 868 + 383; |
| } |
| else |
| { |
| tmp = (tmp) - 3456 + 367; |
| } |
| } |
| else |
| { |
| tmp = ((tmp >> 6) & 0x3f) + 411; |
| } |
| |
| cw = *(huffTable_16 + tmp); |
| pMainData->usedBits -= (17 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab24(tmp3Bits *pMainData) |
| { |
| uint32 tmp; |
| uint16 cw; |
| |
| tmp = getUpTo17bits(pMainData, 12); /* huffTable_24 */ |
| if ((tmp >> 6) >= 41) |
| { |
| tmp = (tmp >> 6) - 41; |
| } |
| else if ((tmp >> 3) >= 218) |
| { |
| tmp = (tmp >> 3) - 218 + 23; |
| } |
| else if ((tmp >> 2) >= 336) |
| { |
| tmp = (tmp >> 2) - 336 + 133; |
| } |
| else if ((tmp >> 1) >= 520) |
| { |
| tmp = (tmp >> 1) - 520 + 233; |
| } |
| else if ((tmp) >= 1024) |
| { |
| tmp = (tmp) - 1024 + 385; |
| } |
| else if ((tmp >> 1) >= 352) |
| { |
| if ((tmp >> 8) == 3) |
| { |
| tmp = (tmp >> 8) - 3 + 433; |
| } |
| else |
| { |
| tmp = (tmp >> 1) - 352 + 401; |
| } |
| } |
| else |
| { |
| tmp = ((tmp >> 4) & 0x3f) + 434; |
| } |
| |
| cw = *(huffTable_24 + tmp); |
| pMainData->usedBits -= (12 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| uint16 pvmp3_decode_huff_cw_tab32(tmp3Bits *pMainData) |
| { |
| uint32 tmp = getUpTo9bits(pMainData, 6); /* huffTable_32 */ |
| if ((tmp >> 5)) |
| { |
| pMainData->usedBits -= 5; |
| return(0); |
| } |
| else |
| { |
| uint16 cw = *(huffTable_32 + (tmp & 0x1f)); |
| pMainData->usedBits -= (6 - (cw & 0xFF)); |
| |
| return(cw >> 8); |
| } |
| |
| } |
| |
| |
| uint16 pvmp3_decode_huff_cw_tab33(tmp3Bits *pMainData) |
| { |
| |
| uint16 tmp = getUpTo9bits(pMainData, 4); /* huffTable_33 */ |
| |
| return((0x0f - tmp)); |
| } |
| |