omxacaac_noiselessdecode.c

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

                                nextBit = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
                                
                                if(nextBit == 1 )
                                {
                                    Coeff3 = -Coeff3;
                                }
                            }
                            if(Coeff4 != 0)
                            {
                                nextBit = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
                                
                                if(nextBit == 1 )
                                {
                                    Coeff4 = -Coeff4;
                                }
                            }
                        }
                        
                        *pDstQuantizedSpectralCoef++ = Coeff1;
                        *pDstQuantizedSpectralCoef++ = Coeff2;
                        *pDstQuantizedSpectralCoef++ = Coeff3;
                        *pDstQuantizedSpectralCoef++ = Coeff4;
                        
                        i += 4;

                    }/*End if (cbNum < FIRST_PAIR_HCB)*/
                    else 
                    {
                        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) - signOffset;
                        indexCb -= (Coeff1 + signOffset)*modulo;
                        
                        Coeff2   = indexCb - signOffset;
                        
                        if(armACAAC_signCb[cbNum] == 1)
                        {
                            
                            if(Coeff1 != 0)
                            {
                                signBit1 = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
                                
                                if(signBit1 == 1 )
                                {
                                    Coeff1 = -Coeff1;
                                }
                            }
                            
                            if(Coeff2 != 0)
                            {
                                signBit2 = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
                                
                                if(signBit2 == 1 )
                                {
                                    Coeff2 = -Coeff2;
                                }
                            }
                        }
                        
                        if(cbNum == ARM_AAC_ESC_HCB)
                        {

                            if(
                                Coeff1 ==  ARM_AAC_ESC_FLAG || 
                                Coeff1 == -ARM_AAC_ESC_FLAG 
                              )
                            {
                                Coeff1   = (1 << 4);
                                bitCount = 4;
                                
                                while( ( nextBit = (OMX_INT)armGetBits(ppBitStream,pOffset,1) ) != 0)
                                {
                                    Coeff1 <<= 1;
                                    bitCount++;
                                    armAssert(bitCount <= 12);
                                }
                                
                                Coeff1 += (OMX_S32)armGetBits(ppBitStream,pOffset,bitCount);

                                if(signBit1 == 1 )
                                {
                                    Coeff1 = -Coeff1;
                                }
                                
                            }
                            
                            if(
                                Coeff2 ==  ARM_AAC_ESC_FLAG ||
                                Coeff2 == -ARM_AAC_ESC_FLAG
                              )
                            {
                                Coeff2   = (1 << 4);
                                bitCount = 4;

                                while( ( nextBit = (OMX_INT)armGetBits(ppBitStream,pOffset,1) ) != 0)
                                {
                                    Coeff2 <<= 1;
                                    bitCount++;
                                    armAssert(bitCount <= 12);
                                }
                                
                                Coeff2 += (OMX_S32)armGetBits(ppBitStream,pOffset,bitCount);

                                if(signBit2 == 1 )
                                {
                                    Coeff2 = -Coeff2;
                                }

                            }
                        }
                        
                        *pDstQuantizedSpectralCoef++ = Coeff1;
                        *pDstQuantizedSpectralCoef++ = Coeff2;

                        i += 2;

                    }/*End else */
                
                }/*End if()*/
                else
                {
                    /*CodeBook - ZERO_HCB,INTENSITY_HCB,INTENSITY_HCB2,NOISE_HCB*/
                    *pDstQuantizedSpectralCoef++ = 0;
                    i++;
                }
                
            }/*End for() - The i loop*/
            
            sectStart = sectEnd;
            sectEnd   = *(++pSectEnd);

        }/*End for() - The sectNum loop*/
        
    }/*End for() - The groupNum loop*/
    
    return OMX_Sts_NoErr;
}

static OMXResult armACAAC_DecodePulseData(
                            const OMX_U8 **ppBitStream,
                            OMX_INT *pOffset,
                            const OMX_U16 *pOffsetTable,
                            OMX_INT *numPulse,
                            OMX_INT *pulseStart,
                            OMX_INT *pulseOff,
                            OMX_INT *pulseAmp,
                            OMX_U16 numSwb
                          )
{
    
    OMX_INT i,k;
    
    *numPulse   = (OMX_INT)armGetBits(ppBitStream,pOffset,2);
    *pulseStart = (OMX_INT)armGetBits(ppBitStream,pOffset,6);

    if (*pulseStart >= (OMX_INT)numSwb || *pulseStart >= 51)
    {
        return OMX_StsACAAC_PlsDataErr;
    }

    k = pOffsetTable[*pulseStart];

    for(i = 0;i < (*numPulse + 1); i++)
    {
        pulseOff[i] = (OMX_INT)armGetBits(ppBitStream,pOffset,5);
        pulseAmp[i] = (OMX_INT)armGetBits(ppBitStream,pOffset,4);
        
        k += pulseOff[i];
        
        armRetDataErrIf(k >= ARM_AAC_WIN_LONG , OMX_StsACAAC_PlsDataErr)

    }
    
    return OMX_Sts_NoErr;
}



static OMXVoid armACAAC_DecodeTNSData(
                            const OMX_U8 **ppBitStream,
                            OMX_INT *pOffset,
                            OMX_INT audioObjectType,
                            OMX_S8 *pDstTnsFiltCoef,
                            OMXAACChanInfo *pChanInfo
                        )
{
        
    OMX_INT *pTnsRegionLen,*pTnsFiltOrder,*pTnsDirection;
    OMX_INT TnsMaxOrder,numWin,numBits,nextVar,i,j;
    
    /* Local array declarations for TNS coefficients decode*/
    
    OMX_S8 signMask[] = { 0x2, 0x4, 0x8 };
    OMX_S8 negMask[]  = { ~0x3, ~0x7, ~0xf };
    OMX_S8 coeff,nMask,sMask;

    OMXAACIcsInfo *pIcsInfo = pChanInfo->pIcsInfo;
   
    if(audioObjectType == 3)
    {
        /*Scaleable Sampling Rate profile*/
        TnsMaxOrder = 12;
    }
    else
    {
        if(pIcsInfo->winSequence == ARM_AAC_EIGHT_SHORT_SEQUENCE)
        {
            /*Short Window*/
            TnsMaxOrder = 7;
        }
        else
        {
            /*Long Window*/
            if(pChanInfo->samplingRateIndex >= 5)
            {
                /*Sampling rate at and below 32 Khz*/
                TnsMaxOrder = 20;
            }
            else
            {
                TnsMaxOrder = 12;
            }
        
        }
    }

    pTnsRegionLen = pChanInfo->pTnsRegionLen;
    pTnsFiltOrder = pChanInfo->pTnsFiltOrder;
    pTnsDirection = pChanInfo->pTnsDirection;
    
    for(numWin = 0;numWin < pChanInfo->numWin; numWin++)
    {
        if(pIcsInfo->winSequence == ARM_AAC_EIGHT_SHORT_SEQUENCE) 
        {
            pChanInfo->pTnsNumFilt[numWin] = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
        }
        else
        {
            pChanInfo->pTnsNumFilt[numWin] = (OMX_INT)armGetBits(ppBitStream,pOffset,2);
        }
        
        if(pChanInfo->pTnsNumFilt[numWin] > 0)
        {
            pChanInfo->pTnsFiltCoefRes[numWin] = ( (OMX_INT)armGetBits(ppBitStream,pOffset,1) + 3);
        }

        for(i = 0; i< pChanInfo->pTnsNumFilt[numWin] ; i++ )
        {
            if(pIcsInfo->winSequence == ARM_AAC_EIGHT_SHORT_SEQUENCE) 
            {
                pTnsRegionLen[numWin + i] = (OMX_INT)armGetBits(ppBitStream,pOffset,4);
                pTnsFiltOrder[numWin + i] = (OMX_INT)armGetBits(ppBitStream,pOffset,3);
            }
            else
            {
                pTnsRegionLen[numWin + i] = (OMX_INT)armGetBits(ppBitStream,pOffset,6);
                pTnsFiltOrder[numWin + i] = (OMX_INT)armGetBits(ppBitStream,pOffset,5);
            }
        
            if(pTnsFiltOrder[numWin + i] > TnsMaxOrder)
            {
                pTnsFiltOrder[numWin + i] = TnsMaxOrder;
            }
            
            if(pTnsFiltOrder[numWin + i] > 0)
            {
                pTnsDirection[numWin + i] = (OMX_INT)armGetBits(ppBitStream,pOffset,1);
                
                nextVar        = (OMX_INT)armGetBits(ppBitStream,pOffset,1); 
                numBits        = pChanInfo->pTnsFiltCoefRes[numWin] - nextVar;
                
                /* Conversion to signed integer */
                
                sMask = signMask[ numBits - 2 ]; 
                nMask = negMask[ numBits - 2 ]; 

                for(j = 0; j < pTnsFiltOrder[numWin + i] ; j++ )
                {
                    coeff = (OMX_S8)armGetBits(ppBitStream,pOffset,numBits);
                    
                    if( (coeff & sMask) == 0)
                    {
                        *pDstTnsFiltCoef = coeff;
                    }
                    else
                    {
                        /*Sign extension*/
                        *pDstTnsFiltCoef = ( coeff | nMask );
                    }

                    pDstTnsFiltCoef++;
                }
            }
        }
    }
    
    return;
}


/*End Of File*/