media/libstagefright/codecs/mp3dec/src/pvmp3_decode_huff_cw.cpp

/* ------------------------------------------------------------------
 * 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));
}