aac_dec_ps_fp.c

audio-video-codecs.rar语音编解码器

  }// END for( band = 0;


  /* [3] post-process of filtering */
  if( CONFIG_HA_BAND1020 == flag ){

    for( band = 3; band < 5; band++ ){
      for( sbr_band = 0; sbr_band < 12; sbr_band++ ){
        pState->mMemBuf[band][sbr_band] = ppSrc[ sbr_band + 26 ][band];
      }
    }

    for( band = 0; band < NUM_SBR_BAND; band++ ){
      ppDst[band][3].re += ppDst[band][4].re;
      ppDst[band][3].im += ppDst[band][4].im;
      ppDst[band][4].re  = ppDst[band][4].im = 0.f;

      ppDst[band][2].re += ppDst[band][5].re;
      ppDst[band][2].im += ppDst[band][5].im;
      ppDst[band][5].re  = ppDst[band][5].im = 0.f;
    }
  }

  return 0;//OK
}

/********************************************************************/

static Ipp32s ownCalcAttenuation_32f(Ipp32f* pPowLine,
                                      Ipp32f* pGAttenLine,
                                      sPSDecState_32f* pPSDecState,
                                      Ipp32s stopBand)
{
  const Ipp32f factorPeakDecay   = 0.76592833836465f;
  const Ipp32f coefSmooth        = 0.25f;
  const Ipp32f factorTransImpact = 1.5f;

  Ipp32f  nrgPeakDecayDiff, nrg;

  Ipp32s bin;

  for( bin = 0; bin < stopBand; bin++ ){

    /* [2.1] - peak decay */
    pPSDecState->bufPeakDecayNrg[bin] *= factorPeakDecay;
    if( pPSDecState->bufPeakDecayNrg[bin] <  pPowLine[bin]) {
      pPSDecState->bufPeakDecayNrg[bin] = pPowLine[bin];
    }

    /* [2.2] - filter power & peak decay */
    nrgPeakDecayDiff  = pPSDecState->bufPeakDecayDiffNrgPrev[bin];
    nrgPeakDecayDiff += coefSmooth * (pPSDecState->bufPeakDecayNrg[bin] - pPowLine[bin] - nrgPeakDecayDiff);
    pPSDecState->bufPeakDecayDiffNrgPrev[bin] = nrgPeakDecayDiff;

    /* [2.3] - transient attenuator */
    nrg  = pPSDecState->bufPeakDecayNrgPrev[bin];
    nrg += coefSmooth * (pPowLine[bin] - nrg);
    pPSDecState->bufPeakDecayNrgPrev[bin] = nrg;

    pGAttenLine[bin] = 1.f;
    if( factorTransImpact* nrgPeakDecayDiff > nrg ) {
      pGAttenLine[bin] = nrg / (factorTransImpact * nrgPeakDecayDiff);
    }

  }// end for(k = 0;


  return 0;//OK
}

/********************************************************************/

static Ipp32fc ownAllPassFilter_32fc(Ipp32fc*** pppMem, Ipp32fc* pTabQ, Ipp32s* pDelayIndx,
                                     Ipp32f coef, Ipp32s pos, Ipp32fc HS )
{

  Ipp32s m = 0;
  Ipp32f coefDecay;
  Ipp32fc tmp0, tmp;

  for( m = 0; m < 3; m++ ){

    tmp0   = pppMem[m][ pDelayIndx[m] ][pos];

    tmp.re = tmp0.re * pTabQ[m].re - tmp0.im * pTabQ[m].im;
    tmp.im = tmp0.re * pTabQ[m].im + tmp0.im * pTabQ[m].re;

    coefDecay = (Ipp32f)exp(- tabNumSampleDelayMem[m] / 7.f);

    tmp.re -= coef * coefDecay * HS.re;
    tmp.im -= coef * coefDecay * HS.im;

    pppMem[m][ pDelayIndx[m] ][pos].re = HS.re + coef * coefDecay * tmp.re;
    pppMem[m][ pDelayIndx[m] ][pos].im = HS.im + coef * coefDecay * tmp.im;

    HS = tmp;
  }

  return HS;
}

/********************************************************************/
// strategy from ref code: clean state of decorrelation instead of remapping
static Ipp32s ownResetDecorrState( sPSDecState_32f* pState )
{
  int i, j;

  /* 1D */
  ippsZero_32f(pState->bufPeakDecayNrg, 34);
  ippsZero_32f(pState->bufPeakDecayDiffNrgPrev, 34);
  ippsZero_32f(pState->bufPeakDecayNrgPrev, 34);

  /* 2D */
  for( i = 0; i < 14; i++ ){
    ippsZero_32fc(pState->ppDelaySubQMF[i], 32);
    ippsZero_32fc(pState->ppDelayQMF[i], 64);
  }

  /* 3D */
  for( i = 0; i < 3; i++ ){
    for( j = 0; j < 5; j++ ){
      ippsZero_32fc(pState->pppAllPassFilterMemSubQMF[i][j], 32);
      ippsZero_32fc(pState->pppAllPassFilterMemQMF[i][j], 64);
    }
  }

  return 0;//OK
}

/********************************************************************/

static Ipp32s ownDecorrelation_PSDec_32fc(Ipp32fc** ppSrcL,
                                          Ipp32fc** ppSrcR,
                                          sTDSpec* pTDSpec,
                                          sPSDecState_32f* pPSDecState)
{
  Ipp32f  mPower[32][34];
  Ipp32f  mGTransRatio[32][34];
  Ipp32f  transRatio = 0.f;
  Ipp32fc val, inputLeft;

  Ipp32s  group = 0, bk = 0, k = 0, n = 0, bord = 0, m = 0;
  Ipp32s  tmpDelayLenIndx = 0, tmpIndx2 = 0, condition = 0;

  Ipp32s  delayIndxMem[3];

  /* matrix */
  Ipp32fc*** pppAllPassFilterMem = NULL;
  Ipp32fc**  ppDelayQMF          = NULL;
  Ipp32fc**  ppFracDelayLenTabQ  = NULL;
  Ipp32fc*   pFracDelayLenTabFi  = NULL;
  Ipp32fc**  ppTabQ              = NULL;
  Ipp32fc*   pTabFi              = NULL;

  Ipp32fc**  ppSrc               = NULL; // dynamic input for every case [ppSrcL OR ppHybL]
  Ipp32fc**  ppDst               = NULL; // dynamic output for every case[ppSrcR OR ppHybR]


  /* code */
  /* [y] tuning */
  if( CONFIG_HA_BAND1020 == pPSDecState->comState.flag_HAconfig ){
    ppTabQ = pPSDecState->ppFracDelayLenTab1020;
    pTabFi = pPSDecState->pFracDelayLenTab1020;
  } else {
    ppTabQ = pPSDecState->ppFracDelayLenTab34;
    pTabFi = pPSDecState->pFracDelayLenTab34;
  }

  /* [1] power matrix */
  ippsZero_32f( mPower[0], 32*34 );

  for( group = 0; group < pTDSpec->nGroup; group++ ){

    bk = pTDSpec->pBinTab[ group ];
    ppSrc = ( group < pTDSpec->thres ) ? pPSDecState->ppHybridL : ppSrcL;

    for( k = pTDSpec->pStartBordTab[group]; k < pTDSpec->pStopBordTab[group]; k++ ){
      for( n = 0; n < 32; n++ ){
        val = ppSrc[n][k];
        mPower[n][bk] += val.re*val.re + val.im*val.im;
      }
    }
  }

  /* [x] reset if switch 20<=>34 band detected */
  if( pPSDecState->comState.flag_HAconfig != pPSDecState->comState.flag_HAconfigPrev ){
    ownResetDecorrState( pPSDecState );
  }

  /* [2] transient attenuator */
  for( k = 0; k < 32; k++ ){
    ownCalcAttenuation_32f(mPower[k], mGTransRatio[k], pPSDecState, pTDSpec->nBin);
  }

  /* [3] calc decorrelated signal */
  for( group = 0; group < pTDSpec->nGroup; group++ ){

     ppSrc = ( group < pTDSpec->thres ) ? pPSDecState->ppHybridL : ppSrcL;
     ppDst = ( group < pTDSpec->thres ) ? pPSDecState->ppHybridR : ppSrcR;

    /* common place to change */
    if( group < pTDSpec->thres ){
      pFracDelayLenTabFi = pTabFi; //vector fi
      ppFracDelayLenTabQ = ppTabQ;//matrix Q

      pppAllPassFilterMem= pPSDecState->pppAllPassFilterMemSubQMF;
      ppDelayQMF         = pPSDecState->ppDelaySubQMF;

    } else {
      pFracDelayLenTabFi = pPSDecState->pFracDelayLenTabQMF; //vector fi
      ppFracDelayLenTabQ = pPSDecState->ppFracDelayLenTabQMF;//matrix Q

      pppAllPassFilterMem= pPSDecState->pppAllPassFilterMemQMF;
      ppDelayQMF         = pPSDecState->ppDelayQMF;
    }

    bk = pTDSpec->pBinTab[ group ];

    for( bord = pTDSpec->pStartBordTab[group]; bord < pTDSpec->pStopBordTab[group]; bord++ ){

      Ipp32f factorDecaySlope = 1.0f;

      if ( group >= pTDSpec->thres && bord > pTDSpec->decay_cutoff ){
        factorDecaySlope += pTDSpec->decay_cutoff * DECAY_SLOPE - DECAY_SLOPE * bord;
        factorDecaySlope  = IPP_MAX(factorDecaySlope, 0.0f);
      }

      tmpDelayLenIndx = pPSDecState->comState.delayLenIndx;

      ippsCopy_32s( pPSDecState->delayIndxMem, delayIndxMem, 3);

      for( k = 0; k < 32; k++ ){
        Ipp32fc tmp, HS;

        inputLeft = ppSrc[k][bord];

        condition = (group >= IPP_MAX(pTDSpec->firstDelayGroup, pTDSpec->thres)) &&
                    (bord  >= pTDSpec->firstDelaySb);

        tmpIndx2 = ( condition ) ? pPSDecState->bufIndexDelayQMF[bord] : tmpDelayLenIndx;

        HS = ppDelayQMF[ tmpIndx2 ][bord];
        ppDelayQMF[ tmpIndx2 ][bord] = inputLeft;

        if( 0 == condition ){
          tmp.re = HS.re * pFracDelayLenTabFi[bord].re - HS.im * pFracDelayLenTabFi[bord].im;
          tmp.im = HS.re * pFracDelayLenTabFi[bord].im + HS.im * pFracDelayLenTabFi[bord].re;

          HS = ownAllPassFilter_32fc(pppAllPassFilterMem, ppFracDelayLenTabQ[bord], delayIndxMem,
                                     factorDecaySlope, bord, tmp);
        }// end if(0 == condition)

        transRatio = mGTransRatio[k][bk];

        /* "right" channel, output data */
        ppDst[k][bord].re = transRatio * HS.re;
        ppDst[k][bord].im = transRatio * HS.im;

        /* update delay index buffer */
        tmpDelayLenIndx = (tmpDelayLenIndx) ? 0 : 1;

        // AYA: dirty part of code
        //-------------------
        if( condition ){
          if( ++(pPSDecState->bufIndexDelayQMF[bord]) >= pPSDecState->bufNumSampleDelayQMF[bord] ){
            pPSDecState->bufIndexDelayQMF[bord] = 0;
          }
        }

        for( m = 0; m < 3; m++ ){
          if( ++delayIndxMem[m] >= tabNumSampleDelayMem[m] ){
            delayIndxMem[m] = 0;
          }
        }
        //-------------------

      }//end for( k = 0;
    }//for( bord =
  }// end for( group = 0;

  /* update */
  pPSDecState->comState.delayLenIndx = tmpDelayLenIndx;
  ippsCopy_32s( delayIndxMem, pPSDecState->delayIndxMem, 3);

  return 0;//OK
}

/********************************************************************/

static Ipp32s ownMap20To34_32fc(Ipp32fc* pSrcDst)
{
  Ipp32fc bufIDX[34];

  bufIDX[0]  = pSrcDst[0];

  bufIDX[1].re  = (pSrcDst[0].re + pSrcDst[1].re)/2.f;
  bufIDX[1].im  = (pSrcDst[0].im + pSrcDst[1].im)/2.f;

  bufIDX[2]  = pSrcDst[1];
  bufIDX[3]  = pSrcDst[2];

  bufIDX[4].re  = (pSrcDst[2].re + pSrcDst[3].re)/2.f;
  bufIDX[4].im  = (pSrcDst[2].im + pSrcDst[3].im)/2.f;

  bufIDX[5]  = pSrcDst[3];
  bufIDX[6]  = pSrcDst[4];
  bufIDX[7]  = pSrcDst[4];
  bufIDX[8]  = pSrcDst[5];
  bufIDX[9]  = pSrcDst[5];
  bufIDX[10] = pSrcDst[6];
  bufIDX[11] = pSrcDst[7];
  bufIDX[12] = pSrcDst[8];
  bufIDX[13] = pSrcDst[8];
  bufIDX[14] = pSrcDst[9];
  bufIDX[15] = pSrcDst[9];
  bufIDX[16] = pSrcDst[10];
  bufIDX[17] = pSrcDst[11];
  bufIDX[18] = pSrcDst[12];
  bufIDX[19] = pSrcDst[13];
  bufIDX[20] = pSrcDst[14];
  bufIDX[21] = pSrcDst[14];
  bufIDX[22] = pSrcDst[15];
  bufIDX[23] = pSrcDst[15];
  bufIDX[24] = pSrcDst[16];
  bufIDX[25] = pSrcDst[16];
  bufIDX[26] = pSrcDst[17];
  bufIDX[27] = pSrcDst[17];
  bufIDX[28] = pSrcDst[18];
  bufIDX[29] = pSrcDst[18];
  bufIDX[30] = pSrcDst[18];
  bufIDX[31] = pSrcDst[18];
  bufIDX[32] = pSrcDst[19];
  bufIDX[33] = pSrcDst[19];

  ippsCopy_32fc(bufIDX, pSrcDst, 34);

  return 0;//OK
}

/********************************************************************/

static Ipp32s ownMap34To20_32fc(Ipp32fc* pSrcDst)
{
  pSrcDst[0].re  = (2*pSrcDst[0].re+pSrcDst[1].re)/3.f;
  pSrcDst[0].im  = (2*pSrcDst[0].im+pSrcDst[1].im)/3.f;

  pSrcDst[1].re  = (pSrcDst[1].re+2*pSrcDst[2].re)/3.f;
  pSrcDst[1].im  = (pSrcDst[1].im+2*pSrcDst[2].im)/3.f;

  pSrcDst[2].re  = (2*pSrcDst[3].re+pSrcDst[4].re)/3.f;
  pSrcDst[2].im  = (2*pSrcDst[3].im+pSrcDst[4].im)/3.f;

  pSrcDst[3].re  = (pSrcDst[4].re+2*pSrcDst[5].re)/3.f;
  pSrcDst[3].im  = (pSrcDst[4].im+2*pSrcDst[5].im)/3.f;

  pSrcDst[4].re  = (pSrcDst[6].re+pSrcDst[7].re)/2.f;
  pSrcDst[4].im  = (pSrcDst[6].im+pSrcDst[7].im)/2.f;

  pSrcDst[5].re  = (pSrcDst[8].re+pSrcDst[9].re)/2.f;
  pSrcDst[5].im  = (pSrcDst[8].im+pSrcDst[9].im)/2.f;

  pSrcDst[6]  = pSrcDst[10];
  pSrcDst[7]  = pSrcDst[11];

  pSrcDst[8].re  = (pSrcDst[12].re+pSrcDst[13].re)/2.f;
  pSrcDst[8].im  = (pSrcDst[12].im+pSrcDst[13].im)/2.f;

  pSrcDst[9].re  = (pSrcDst[14].re+pSrcDst[15].re)/2.f;
  pSrcDst[9].im  = (pSrcDst[14].im+pSrcDst[15].im)/2.f;

  pSrcDst[10] = pSrcDst[16];
  pSrcDst[11] = pSrcDst[17];
  pSrcDst[12] = pSrcDst[18];
  pSrcDst[13] = pSrcDst[19];

  pSrcDst[14].re = (pSrcDst[20].re+pSrcDst[21].re)/2.f;
  pSrcDst[14].im = (pSrcDst[20].im+pSrcDst[21].im)/2.f;

  pSrcDst[15].re = (pSrcDst[22].re+pSrcDst[23].re)/2.f;
  pSrcDst[15].im = (pSrcDst[22].im+pSrcDst[23].im)/2.f;