aac_dec_ps_fp.c

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

  pSrcDst[16].re = (pSrcDst[24].re+pSrcDst[25].re)/2.f;
  pSrcDst[16].im = (pSrcDst[24].im+pSrcDst[25].im)/2.f;

  pSrcDst[17].re = (pSrcDst[26].re+pSrcDst[27].re)/2.f;
  pSrcDst[17].im = (pSrcDst[26].im+pSrcDst[27].im)/2.f;

  pSrcDst[18].re = (pSrcDst[28].re+pSrcDst[29].re+pSrcDst[30].re+pSrcDst[31].re)/4.f;
  pSrcDst[18].im = (pSrcDst[28].im+pSrcDst[29].im+pSrcDst[30].im+pSrcDst[31].im)/4.f;

  pSrcDst[19].re = (pSrcDst[32].re+pSrcDst[33].re)/2.f;
  pSrcDst[19].im = (pSrcDst[32].im+pSrcDst[33].im)/2.f;

  return 0;//OK
}

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

static Ipp32s ownSmoothRemap_32fc( Ipp32fc* pCoef11, Ipp32fc* pCoef12,
                                   Ipp32fc* pCoef21, Ipp32fc* pCoef22,
                                   Ipp32s flag)
{
  if( flag ){ /* map 20->34 bands */
    ownMap20To34_32fc( pCoef11 );
    ownMap20To34_32fc( pCoef12 );
    ownMap20To34_32fc( pCoef21 );
    ownMap20To34_32fc( pCoef22 );
  } else {   /* map 34->20 bands */
    ownMap34To20_32fc( pCoef11 );
    ownMap34To20_32fc( pCoef12 );
    ownMap34To20_32fc( pCoef21 );
    ownMap34To20_32fc( pCoef22 );
  }

  return 0;//OK
}

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

static Ipp32s ownStereoFilter_32fc(Ipp32fc* pSrcL, Ipp32fc* pSrcR,
                                   Ipp32fc* bufH,  int iStart, int iStop)
{

  int i;
  Ipp32fc tmpL, tmpR;

  for( i = iStart; i < iStop; i++ ){
    tmpL.re =  bufH[0].re * pSrcL[i].re -  bufH[0].im * pSrcL[i].im +
               bufH[2].re * pSrcR[i].re - bufH[2].im * pSrcR[i].im;

    tmpL.im  =  bufH[0].im * pSrcL[i].re +  bufH[0].re * pSrcL[i].im +
                bufH[2].im * pSrcR[i].re + bufH[2].re * pSrcR[i].im;

    tmpR.re =  bufH[1].re * pSrcL[i].re - bufH[1].im * pSrcL[i].im +
               bufH[3].re * pSrcR[i].re - bufH[3].im * pSrcR[i].im;

    tmpR.im =  bufH[1].im * pSrcL[i].re +  bufH[1].re * pSrcL[i].im +
               bufH[3].im * pSrcR[i].re + bufH[3].re * pSrcR[i].im;

    pSrcL[i] = tmpL;
    pSrcR[i] = tmpR;
  }

  return 0;//OK
}

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

static Ipp32s ownIpdOpdSmooth_32fc(Ipp32fc* pCoeffs, sPSDecComState* pCom, int env, int pos)
{
  Ipp32f ipd, ipd1, ipd2;
  Ipp32f opd, opd1, opd2;
  Ipp32fc tmpL, tmpR;

  ipd  = IPDOPD_SF * pCom->indxIpdMapped[env][pos];
  ipd1 = IPDOPD_SF * pCom->indxIpdMapped_1[pos];
  ipd2 = IPDOPD_SF * pCom->indxIpdMapped_2[pos];

  opd  = IPDOPD_SF * pCom->indxOpdMapped[env][pos];
  opd1 = IPDOPD_SF * pCom->indxOpdMapped_1[pos];
  opd2 = IPDOPD_SF * pCom->indxOpdMapped_2[pos];

  tmpL.re = (Ipp32f)(cos(ipd) + 0.5f*cos(ipd1) + 0.25f*cos(ipd2));
  tmpL.im = (Ipp32f)(sin(ipd) + 0.5f*sin(ipd1) + 0.25f*sin(ipd2));
  tmpR.re = (Ipp32f)(cos(opd) + 0.5f*cos(opd1) + 0.25f*cos(opd2));
  tmpR.im = (Ipp32f)(sin(opd) + 0.5f*sin(opd1) + 0.25f*sin(opd2));

  ipd = (Ipp32f)atan2( tmpL.im, tmpL.re );
  opd = (Ipp32f)atan2( tmpR.im, tmpR.re );

  /* phase rotation */
  tmpL.re  = (Ipp32f)cos( opd );
  tmpL.im  = (Ipp32f)sin( opd );
  opd -= ipd;
  tmpR.re = (Ipp32f)cos( opd );
  tmpR.im = (Ipp32f)sin( opd );

  pCoeffs[0].im = pCoeffs[0].re * tmpL.im;
  pCoeffs[1].im = pCoeffs[1].re * tmpR.im;
  pCoeffs[2].im = pCoeffs[2].re * tmpL.im;
  pCoeffs[3].im = pCoeffs[3].re * tmpR.im;

  pCoeffs[0].re *= tmpL.re;
  pCoeffs[1].re *= tmpR.re;
  pCoeffs[2].re *= tmpL.re;
  pCoeffs[3].re *= tmpR.re;

  return 0;//OK
}

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

static Ipp32s ownStereoProcessing_PSDec_32fc(Ipp32fc** ppSrcL,
                                             Ipp32fc** ppSrcR,
                                             sTDSpec*  pTDSpec,
                                             sPSDecState_32f* pPSDecState)
{
  /* internal tables */
  const Ipp32f tabAlphas[8] = {0.f, 0.17842767f, 0.2856673f, 0.46307236f,
                               0.59716314f, 0.78539819f, 1.1003085f, 1.5707964f};

  Ipp32fc bufCoeffs[4];
  Ipp32fc bufH[4];

  Ipp32f  scaleL, scaleR;
  Ipp32f  alpha,  beta, arg;

  Ipp32s  group = 0, i = 0, len = 0, indx = 0;
  Ipp32s  nIIDSteps, env = 0, bin = 0, typeMix = 0;

  sPSDecComState*  pCom       = NULL;
  Ipp32fc**        ppSuitSrcL = NULL;
  Ipp32fc**        ppSuitSrcR = NULL;
  Ipp32f*          pTabScale  = NULL;
  Ipp32s*          pTabQuantIID = NULL;

  pCom    = &(pPSDecState->comState);
  indx    = ( CONFIG_HA_BAND1020 == pPSDecState->comState.flag_HAconfig ) ? 0 : 1;
  typeMix = pCom->mix_strategy;

  /* [1]. tuning params */
  if( pCom->iid_quant ){
    nIIDSteps = NUM_IID_FINE_GRID_STEPS;
    pTabScale = (Ipp32f*)tabScaleIidFine;
    pTabQuantIID = (Ipp32s*)tabQuantIidFine;
  } else {
    nIIDSteps = NUM_IID_GRID_STEPS;
    pTabScale = (Ipp32f*)tabScaleIidStd;
    pTabQuantIID = (Ipp32s*)tabQuantIidStd;
  }

  /* [2]. smooth remapping */
  if( pCom->flag_HAconfig != pCom->flag_HAconfigPrev ){

    ownSmoothRemap_32fc( pPSDecState->h11Prev, pPSDecState->h12Prev,
                         pPSDecState->h21Prev, pPSDecState->h22Prev, indx);

    /* common part */
    ippsZero_32s(pCom->indxIpdMapped_1, 17);
    ippsZero_32s(pCom->indxIpdMapped_2, 17);
    ippsZero_32s(pCom->indxOpdMapped_1, 17);
    ippsZero_32s(pCom->indxOpdMapped_2, 17);
  }

  /* [3]. processing */
  for( env = 0; env < pCom->nEnv; env++ ){
    for( bin = 0; bin < pTDSpec->nBin; bin++ ){

      if( PS_MIX_RA == typeMix ){/* Mixing Ra */
        Ipp32s id = pCom->indxIidMapped[env][bin];

        scaleR = pTabScale[ nIIDSteps + id ];
        scaleL = pTabScale[ nIIDSteps - id ];

        alpha = tabAlphas[ pCom->indxIccMapped[env][bin] ];
        beta  = alpha * ( scaleR - scaleL ) / (Ipp32f)IPP_SQRT2;

        bufCoeffs[0].re = ( Ipp32f )( scaleL * cos( beta + alpha ) );
        bufCoeffs[1].re = ( Ipp32f )( scaleR * cos( beta - alpha ) );
        bufCoeffs[2].re = ( Ipp32f )( scaleL * sin( beta + alpha ) );
        bufCoeffs[3].re = ( Ipp32f )( scaleR * sin( beta - alpha ) );

      } else {/* Mixing Rb */
        Ipp32f c, rho, mu, alpha, gamma;
        int i;

        i = pCom->indxIidMapped[env][bin];
        c = (Ipp32f)pow(10.0, pTabQuantIID[ i + nIIDSteps ] / 20.f);

        rho = tabQuantRHO[pCom->indxIccMapped[env][bin]];
        rho = IPP_MAX(rho, 0.05f);

        if ( fabs(c - 1.f) < PS_EPS_0 ) { //if ( c == 1 )
          alpha = (Ipp32f)IPP_PI/4.0f;
        } else {
          arg   = (2.0f*c*rho) / (c*c - 1.0f);
          alpha = (Ipp32f)( 0.5f * atan(arg) );

          if (alpha < 0.f ) alpha += (Ipp32f)IPP_PI/2.0f; //not tested yet
        }

        arg = c + 1.0f/c;
        mu  = 1.0f + (4.0f*rho*rho-4.0f) / (arg*arg);

        arg   = (Ipp32f)sqrt( (1.0f-sqrt(mu)) / (1.0f+sqrt(mu)) );
        gamma = (Ipp32f)atan( arg );

        bufCoeffs[0].re =  ( Ipp32f )( IPP_SQRT2 * cos(alpha) * cos(gamma) );
        bufCoeffs[1].re =  ( Ipp32f )( IPP_SQRT2 * sin(alpha) * cos(gamma) );
        bufCoeffs[2].re = -( Ipp32f )( IPP_SQRT2 * sin(alpha) * sin(gamma) );
        bufCoeffs[3].re =  ( Ipp32f )( IPP_SQRT2 * cos(alpha) * sin(gamma) );
      }

      /* first the ipd/opd are smoothed */
      if( bin < pCom->nIpdOpdBands ){
        ownIpdOpdSmooth_32fc(bufCoeffs, pCom, env, bin);
      } else {
        bufCoeffs[0].im = bufCoeffs[1].im = bufCoeffs[2].im = bufCoeffs[3].im = 0.f;
      }

      /* update */
      pPSDecState->h11Curr[bin] = bufCoeffs[0];
      pPSDecState->h12Curr[bin] = bufCoeffs[1];
      pPSDecState->h21Curr[bin] = bufCoeffs[2];
      pPSDecState->h22Curr[bin] = bufCoeffs[3];

    }//for( bin = 0; bin <

    for( group = 0; group < pTDSpec->nGroup; group++ ){
      Ipp32s param;
      Ipp32fc deltaH[4];

      /* tuning */
      bin        = pTDSpec->pBinTab[ group ];
      len        = pCom->bufBordPos[env + 1] - pCom->bufBordPos[env];
      param      = (pTDSpec->pPostBinTab[group]) ? -1 : 1;
      ppSuitSrcL = (group < pTDSpec->thres) ? pPSDecState->ppHybridL : ppSrcL;
      ppSuitSrcR = (group < pTDSpec->thres) ? pPSDecState->ppHybridR : ppSrcR;

      /* calc */
      // HXY
      OWN_MULC(pPSDecState->h11Prev[bin], bufH[0], param);
      OWN_MULC(pPSDecState->h12Prev[bin], bufH[1], param);
      OWN_MULC(pPSDecState->h21Prev[bin], bufH[2], param);
      OWN_MULC(pPSDecState->h22Prev[bin], bufH[3], param);

      // hxy
      OWN_MULC(pPSDecState->h11Curr[bin], bufCoeffs[0], param);
      OWN_MULC(pPSDecState->h12Curr[bin], bufCoeffs[1], param);
      OWN_MULC(pPSDecState->h21Curr[bin], bufCoeffs[2], param);
      OWN_MULC(pPSDecState->h22Curr[bin], bufCoeffs[3], param);

      /* delta */
      ippsSub_32fc(bufH, bufCoeffs, deltaH, 4);
      ippsMulC_32f_I(1.f/len, (Ipp32f*)deltaH, 4*2);

      for( i = pCom->bufBordPos[env]; i < pCom->bufBordPos[env+1]; i++ ){
        ippsAdd_32fc_I(deltaH, bufH, 4);
        ownStereoFilter_32fc(ppSuitSrcL[i], ppSuitSrcR[i], bufH,
                             pTDSpec->pStartBordTab[group], pTDSpec->pStopBordTab[group]);
      }
    }// for(group = 0; group < ...

    //update
    for( bin = 0; bin < pTDSpec->nBin; bin++ ){
      pPSDecState->h11Prev[bin] = pPSDecState->h11Curr[bin];
      pPSDecState->h12Prev[bin] = pPSDecState->h12Curr[bin];
      pPSDecState->h21Prev[bin] = pPSDecState->h21Curr[bin];
      pPSDecState->h22Prev[bin] = pPSDecState->h22Curr[bin];
    }

    for( bin = 0; bin < pCom->nIpdOpdBands; bin++ ){
      pCom->indxIpdMapped_2[bin] = pCom->indxIpdMapped_1[bin];
      pCom->indxOpdMapped_2[bin] = pCom->indxOpdMapped_1[bin];
      pCom->indxIpdMapped_1[bin] = pCom->indxIpdMapped[env][bin];
      pCom->indxOpdMapped_1[bin] = pCom->indxOpdMapped[env][bin];
    }
  }//for( env = 0; env < ...

  return 0;//OK
}

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

static Ipp32s ownSynthesisFilter_PSDec_32fc(Ipp32fc** ppSrc,
                                            Ipp32fc** pDst,
                                            Ipp32s* pResTab,
                                            Ipp32s frameSize)
{
  Ipp32s band, k, n, res, offset = 0, nBand;
  Ipp32s* pTab = NULL;

  nBand = pResTab[0];
  pTab  = pResTab + 1;

  for( band = 0; band < nBand; band++ ){
    res = pTab[band];

    for( n = 0; n < frameSize; n++ ){
      pDst[n][band].re = pDst[n][band].im = 0.f;

      for( k = 0; k < res; k++ ){
        pDst[n][band].re += ppSrc[n][offset + k].re;
        pDst[n][band].im += ppSrc[n][offset + k].im;
      }
    }
    offset += res;
  }

  return 0;//OK
}

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

static Ipp32s ownUpdateBands_PSDec_32fc( sPSDecState_32f* pState, Ipp32s startBand )
{
  Ipp32s band = 0, i = 0, k = 0;

  for( band = startBand; band < 64; band++ ){

    for( i = 0; i < 3; i++ ){
      for( k = 0; k < tabNumSampleDelayMem[i]; k++ ){
        pState->pppAllPassFilterMemQMF[i][k][band].re = pState->pppAllPassFilterMemQMF[i][k][band].im = 0.f;
      }
    }

    /* ************ */
    for( k = 0; k < 14; k++ ){
      pState->ppDelayQMF[k][band].re = pState->ppDelayQMF[k][band].im = 0.f;
    }
  }

  return 0;//OK
}

/********************************************************************/
/*             High Level API of Parametric Stereo                  */
/********************************************************************/

Ipp32s psdecDecode_32fc(Ipp32fc** ppSrcL,
                        Ipp32fc** ppSrcR,
                        sPSDecState_32f* pPSDecState,
                        Ipp32s startBand)
{
  Ipp32fc** ppHybL = pPSDecState->ppHybridL;
  Ipp32fc** ppHybR = pPSDecState->ppHybridR;
  Ipp32s*   pTabRes[2] = {(Ipp32s*)tabResBand1020,  (Ipp32s*)tabResBand34};
  sTDSpec*  pConfSet[2]= {(sTDSpec*)&setConfBand20, (sTDSpec*)&setConfBand34};
  Ipp32s    indx;

  indx = ( CONFIG_HA_BAND1020 == pPSDecState->comState.flag_HAconfig ) ? 0 : 1;

  /* step [1] - HybridAnalysis */
  ownAnalysisFilter_PSDec_32fc(ppSrcL,
                               ppHybL,
                               &(pPSDecState->haState),
                               pPSDecState->comState.flag_HAconfig );

  /* step [2] - decorrelation, i use 20_band only */
  ownDecorrelation_PSDec_32fc(ppSrcL, ppSrcR, pConfSet[indx], pPSDecState);

  /* step [3] - stereo processing */
  ownStereoProcessing_PSDec_32fc(ppSrcL, ppSrcR, pConfSet[indx], pPSDecState);

#if 1
  /* step [4] - */
  /* L channel */
  ownSynthesisFilter_PSDec_32fc(ppHybL, ppSrcL, pTabRes[indx], 32);
  /* R channel */
  ownSynthesisFilter_PSDec_32fc(ppHybR, ppSrcR, pTabRes[indx], 32);
#endif

  /* step [x] - update HA_CONFIG */
  pPSDecState->comState.flag_HAconfigPrev = pPSDecState->comState.flag_HAconfig;
  ownUpdateBands_PSDec_32fc( pPSDecState, startBand );

  return 0;//OK
}

/********************************************************************/
/* EOF */