omxacaac_noiselessdecode.c

The OpenMAX DL (Development Layer) APIs contain a comprehensive set of audio, video, signal processi

            else
            {
                pDstQuantizedSpectralCoef[k] -= pulseAmp[j];
            }
        }
    }

    return OMX_Sts_NoErr;
}


static OMXVoid armACAAC_DecodeSectionData(
                                const OMX_U8 **ppBitStream,
                                OMX_INT *pOffset,
                                OMX_U8 *pDstSfbCb,
                                OMXAACChanInfo *pChanInfo
                             )
{
    OMX_INT         sectEscVal,groupNum,nextVar;
    OMX_INT         sfbNum,sectNum,sectLen,sfb;

    OMXAACIcsInfo   *pIcsInfo = pChanInfo->pIcsInfo;
    OMX_U8          *pSectCb  = pChanInfo->pSectCb;
    OMX_U8          *pSectEnd = pChanInfo->pSectEnd;
    
    if(pIcsInfo->winSequence == ARM_AAC_EIGHT_SHORT_SEQUENCE) 
    {
        sectEscVal = (1 << 3) - 1;
    }
    else
    {
        sectEscVal = (1 << 5) - 1;
    }
    
    for(groupNum = 0 ; groupNum < pIcsInfo->numWinGrp ; groupNum ++)
    {
        sfbNum  = 0;
        sectNum = 0;
        
        while(sfbNum < pIcsInfo->maxSfb)
        {
            *pSectCb = (OMX_INT)armGetBits(ppBitStream,pOffset,4);
            sectLen   = 0;
            
            do
            {
                if(pIcsInfo->winSequence == ARM_AAC_EIGHT_SHORT_SEQUENCE) 
                {
                    nextVar = (OMX_INT)armGetBits(ppBitStream,pOffset,3);
                }
                else
                {
                    nextVar = (OMX_INT)armGetBits(ppBitStream,pOffset,5);
                }
            
                sectLen += nextVar;
                
                armAssert(sectLen <= OMX_AAC_SF_MAX);
                
            }while(nextVar == sectEscVal);
            
            *pSectEnd = sfbNum + sectLen;
            pSectEnd++;
        
            for(sfb = sfbNum ; sfb < (sfbNum + sectLen) ; sfb++ )
            {
                *pDstSfbCb = *pSectCb;
                pDstSfbCb++;
            }
            
            sfbNum += sectLen;
            sectNum++;
            pSectCb++;
        }
        
        pChanInfo->pMaxSect[groupNum] = sectNum; 
    }
    
    return;
}

static OMXResult armACAAC_DecodeScaleFactorData(
                                    const OMX_U8 **ppBitStream,
                                    OMX_INT *pOffset,
                                    OMX_U8 *pDstSfbCb,
                                    OMX_S16 *pDstScalefactor,
                                    OMX_INT globGain,
                                    OMXAACIcsInfo *pIcsInfo
                                    )
{

    OMX_INT groupNum,sfbNum,cbNum,noiseFlag;
    OMX_INT lastSf,dpcmSf;
    OMX_INT lastIsPos,dpcmIsPos;
    OMX_INT lastNoiseNrg = 0,dpcmNoiseNrg;
    OMX_S16 index;

    lastSf    = globGain;
    lastIsPos = 0;
    noiseFlag = 1;
    
    for(groupNum = 0 ; groupNum < pIcsInfo->numWinGrp ; groupNum ++)
    {
        for(sfbNum = 0; sfbNum < pIcsInfo->maxSfb ; sfbNum++)
        {
            cbNum = *pDstSfbCb++;
            
            switch(cbNum)            
            {
                case ARM_AAC_NOISE_HCB:
                    
                    if(noiseFlag)
                    {
                        lastNoiseNrg  = (OMX_INT)armGetBits(ppBitStream,pOffset,9);
                        lastNoiseNrg += globGain - ARM_AAC_NOISE_OFFSET - 256;
                        
                        noiseFlag = 0;
                    }
                    else
                    {
                        index = armUnPackVLC32(ppBitStream,pOffset,armACAAC_CodeBooks[0]);
                        
                        if(index == -1)
                        {
                            return OMX_Sts_Err;
                        }

                        dpcmNoiseNrg = index - ARM_AAC_INDEX_OFFSET;
                        lastNoiseNrg = dpcmNoiseNrg + lastNoiseNrg;
                    }

                    *pDstScalefactor++ = lastNoiseNrg;
                
                    break;
                    
                case ARM_AAC_INTENSITY_HCB:
                case ARM_AAC_INTENSITY_HCB2:
                    
                    index = armUnPackVLC32(ppBitStream,pOffset,armACAAC_CodeBooks[0]);

                    if(index == -1)
                    {
                        return OMX_Sts_Err;
                    }

                    dpcmIsPos = index - ARM_AAC_INDEX_OFFSET;
                    lastIsPos = dpcmIsPos + lastIsPos;

                    *pDstScalefactor++ = lastIsPos;
                    
                    break;
                    
                case ARM_AAC_ZERO_HCB:

                    *pDstScalefactor++ = 0;
                    
                    break;
                
                default:

                    index = armUnPackVLC32(ppBitStream,pOffset,armACAAC_CodeBooks[0]);

                    if(index == -1)
                    {
                        return OMX_Sts_Err;
                    }

                    dpcmSf = index - ARM_AAC_INDEX_OFFSET;
                    lastSf = dpcmSf + lastSf;

                    *pDstScalefactor++ = lastSf;

            } /*End switch(cbNum)*/

        }
        
    }

    return OMX_Sts_NoErr;
}


static OMXResult armACAAC_DecodeSpectralData(
                                const OMX_U8 **ppBitStream,
                                OMX_INT *pOffset,
                                OMX_S32 *pDstQuantizedSpectralCoef,
                                OMXAACChanInfo *pChanInfo
                              )
{
    OMX_INT         groupNum,sectNum,cbNum,sectSfb;
    OMX_INT         offset,sfbNum,width,indexCb,bitCount,signOffset,i;
    OMX_INT         modulo,nextBit,signBit1 = 0,signBit2 = 0;
        
    OMX_S32         Coeff1,Coeff2,Coeff3,Coeff4;
    OMX_INT         sectSfbOffset[OMX_AAC_GROUP_NUM_MAX][OMX_AAC_SF_MAX];
    const OMX_U16   *pOffsetTable;
    
    OMXAACIcsInfo   *pIcsInfo = pChanInfo->pIcsInfo;
    OMX_U8          *pSectCb  = pChanInfo->pSectCb;
    OMX_U8          *pSectEnd = pChanInfo->pSectEnd;
    
    OMX_U8          sectStart;
    OMX_U8          sectEnd   = *pSectEnd;
    
    /*Populate sectSfbOffset*/
    
    if(pIcsInfo->winSequence == ARM_AAC_EIGHT_SHORT_SEQUENCE)
    {
 
        pOffsetTable = armACAAC_swbOffsetShortWindow[pChanInfo->samplingRateIndex];
        
        for( groupNum = 0; groupNum < pIcsInfo->numWinGrp ; groupNum++ ) 
        {
            sectSfb = 0;
            offset = 0;
            
            for( sfbNum = 0; sfbNum <= pIcsInfo->maxSfb; sfbNum++ )
            {
                width  = pOffsetTable[sfbNum+1] - pOffsetTable[sfbNum];
                width *= pIcsInfo->pWinGrpLen[groupNum];
                
                sectSfbOffset[groupNum][sectSfb] = offset;
                
                offset += width;
                sectSfb++;
            }

            sectSfbOffset[groupNum][sectSfb] = offset;
        }
    
    }
    else
    {
        pOffsetTable = armACAAC_swbOffsetLongWindow[pChanInfo->samplingRateIndex];
        
        for( sfbNum = 0; sfbNum <= pIcsInfo->maxSfb + 1; sfbNum ++ )
        {
            sectSfbOffset[0][sfbNum] = pOffsetTable[sfbNum];
        }
            
    }
    
    
    for(groupNum = 0 ; groupNum < pIcsInfo->numWinGrp ; groupNum ++)
    {
        sectStart = 0;

        for(sectNum = 0 ; sectNum < pChanInfo->pMaxSect[groupNum] ; sectNum++)
        {
            cbNum = *pSectCb++;
            
            for(i = sectSfbOffset[groupNum][sectStart] ;
                i < sectSfbOffset[groupNum][ sectEnd ] ;)
            {

        
                if(
                    cbNum != ARM_AAC_ZERO_HCB       &&
                    cbNum != ARM_AAC_NOISE_HCB      &&
                    cbNum != ARM_AAC_INTENSITY_HCB  &&
                    cbNum != ARM_AAC_INTENSITY_HCB2 
                  )
                {
                
                    if(cbNum < ARM_AAC_FIRST_PAIR_HCB)
                    {
                        indexCb = armUnPackVLC32(ppBitStream,pOffset,armACAAC_CodeBooks[cbNum]);

                        if(indexCb == -1)
                        {
                            return OMX_Sts_Err;
                        }

                        if(armACAAC_signCb[cbNum] == 1)
                        {
                            modulo     = armACAAC_lavCb[cbNum] + 1;
                            signOffset = 0;
                        }
                        else
                        {
                            modulo     = 2*armACAAC_lavCb[cbNum] + 1;
                            signOffset = armACAAC_lavCb[cbNum];
                        }

                        Coeff1   = (OMX_S32)(indexCb/(modulo*modulo*modulo)) - signOffset;
                        indexCb -= (Coeff1 + signOffset)*(modulo*modulo*modulo);
                        
                        Coeff2   = (OMX_S32)(indexCb/(modulo*modulo)) - signOffset;
                        indexCb -= (Coeff2 + signOffset)*(modulo*modulo);
                        
                        Coeff3   = (OMX_S32)(indexCb/modulo) - signOffset;
                        indexCb -= (Coeff3 + signOffset)*modulo;
                        
                        Coeff4   = indexCb - signOffset;
                        
                        if(armACAAC_signCb[cbNum] == 1)
                        {
                            
                            if(Coeff1 != 0)
                            {
                                nextBit = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
                                
                                if(nextBit == 1 )
                                {
                                    Coeff1 = -Coeff1;
                                }
                            }
                            if(Coeff2 != 0)
                            {
                                nextBit = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
                                
                                if(nextBit == 1 )
                                {
                                    Coeff2 = -Coeff2;
                                }
                            }
                            if(Coeff3 != 0)
                            {