aac_dec_sbr_fp.c

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

                    com->sbrHeader.Reset, ch, decode_mode );

    sbrActiveSync( // in data
                   ws->XBuf[ch],
                   ws->YBuf[ch],
                   transitionBand, com->kx_prev, com->kx,
                   // out data
                   ws->ZBuf[ch],
                   decode_mode);


    /* UpDate High Band */
    sbrUpDateBands(ws->YBuf[ch]);

   /* store ch independ */
    com->transitionBand[ch] = stopBand - NUM_TIME_SLOTS * RATE;

  } else {
    sbrPassiveSync(ws->XBuf[ch],
                   ws->ZBuf[ch],
                   decode_mode);
  }

#if 1

 /* ---------------------------------- Parametric Stereo Part ---------------------------- */
  /*********************************************************************************
  * complex input of SBR_SynthesisQMF == input of PS tool.                         *
  * but SBR delay has to be removed                                                *
  *********************************************************************************/
  if( 0xA & decode_modePS ){
    ownSynchronization_PS_32fc( (Ipp32fc**)(ws->XBuf[ch]), (Ipp32fc**)(ws->ZBuf[ch]) );
    //aya_printf_qmf((Ipp32fc**)(ws->ZBuf[ch]));

    if( criterion_valid ){ //SBR ACTIVE
      //ownPassiveUpdate_PS_32fc( (Ipp32fc**)(ws->ZBuf[ch]), (Ipp32fc**)(ws->ZBuf[ch+1]) );
      psdecDecode_32fc((Ipp32fc**)(ws->ZBuf[ch]),
                       (Ipp32fc**)(ws->ZBuf[ch+1]),
                        pSbr->pPSDecState,
                        com->sbrFreqTabsState.fHiBandTab[ com->sbrFreqTabsState.nHiBand ]);
    } else { // SBR PASSIVE
      ownPassiveUpdate_PS_32fc( (Ipp32fc**)(ws->ZBuf[ch]), (Ipp32fc**)(ws->ZBuf[ch+1]) );
    }
  }

#endif


/* -------------------------------- Synthesis OR SynthesisDown ---------------------------- */
  /*********************************************************************************
   * see comment in sbrPassiveSync OR sbrActiveSync functions
   * or see fixed-point version
   *********************************************************************************/
  {
    Ipp32s curCh, indxOutCh, nCh = (0xA & decode_modePS) ? 2 : ch + 1;
    Ipp32f* pOutBuf[2];

    pOutBuf[0] = pDst;
    pOutBuf[1] = pDstR;

    for( indxOutCh = 0, curCh = ch; curCh < nCh; curCh++, indxOutCh++ ){

      switch (decode_mode | dwnsmpl_mode) {

      case (HEAAC_HQ_MODE | HEAAC_DWNSMPL_OFF):
          ippsSynthesisFilter_SBR_CToR_32fc32f_D2L( (const Ipp32fc**)(ws->ZBuf[curCh]), pOutBuf[indxOutCh],
                                                SBR_TABLE_QMF_WINDOW_640,
                                                NUM_TIME_SLOTS * RATE,
                                                (IppsFilterSpec_SBR_C_32fc *)sbr_filter->pSynthesisFilterSpec[curCh],
                                                pWorkBuffer );
          break;

      case (HEAAC_HQ_MODE | HEAAC_DWNSMPL_ON):
          ippsSynthesisDownFilter_SBR_CToR_32fc32f_D2L((const Ipp32fc**)(ws->ZBuf[curCh]), pOutBuf[indxOutCh],
                                                  SBR_TABLE_QMF_WINDOW_320,
                                                  NUM_TIME_SLOTS * RATE,
                                                  (IppsFilterSpec_SBR_C_32fc *)sbr_filter->pSynthesisDownFilterSpec[curCh],
                                                  pWorkBuffer );
          break;

      case (HEAAC_LP_MODE | HEAAC_DWNSMPL_OFF):
          ippsSynthesisFilter_SBR_RToR_32f_D2L((const Ipp32f**)(ws->ZBuf[curCh]), pOutBuf[indxOutCh],
                                              SBR_TABLE_QMF_WINDOW_640,
                                              NUM_TIME_SLOTS * RATE,
                                              (IppsFilterSpec_SBR_R_32f *)sbr_filter->pSynthesisFilterSpec[curCh],
                                              pWorkBuffer );
          break;

      default:
          ippsSynthesisDownFilter_SBR_RToR_32f_D2L( (const Ipp32f**)(ws->ZBuf[curCh]), pOutBuf[indxOutCh],
                                                  SBR_TABLE_QMF_WINDOW_320,
                                                  NUM_TIME_SLOTS * RATE,
                                                  (IppsFilterSpec_SBR_R_32f *)sbr_filter->pSynthesisDownFilterSpec[curCh],
                                                  pWorkBuffer );
          break;
      } // END OF switch (decode_mode | dwnsmpl_mode) {

    } // END OF for( curCh = 0; curCh < nCh; curCh++ ){
  } // END FOR PS BLOCK

  /* UpDate Low Bands */
  sbrUpDateBands(ws->XBuf[ch] );

/* ---------------------------- <store ch depend> ---------------------------- */

  if ((com->id_aac == ID_SCE) || ((com->id_aac == ID_CPE) && (ch == 1))) {
    com->kx_prev = com->kx;
    com->M_prev = com->M;
    com->sbrHeader.Reset = 0;
  }

  return 0;     // OK
}

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

Ipp32s sbrPassiveSync(Ipp32f **XBuf, Ipp32f **ZBuf, Ipp32s mode)
{
  Ipp32s  l;

  Ipp32s xScale = (HEAAC_LP_MODE == mode) ? 1 : 2;

  for (l = 0; l < NUM_TIME_SLOTS * RATE; l++) {
    ippsCopy_32f(XBuf[l + SBR_TIME_HFADJ], ZBuf[l], NUM_TIME_SLOTS * RATE * xScale);
    ippsZero_32f(ZBuf[l] + 32 * xScale, NUM_TIME_SLOTS * RATE * xScale);
  }

  return 0;     // OK
}

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

Ipp32s sbrActiveSync(Ipp32f **XBuf,
                           Ipp32f **YBuf,
                           Ipp32s transitionBand, Ipp32s kx_prev, Ipp32s kx,
                           Ipp32f **ZBuf, Ipp32s mode)
{
  Ipp32s k, l;
  Ipp32s xoverBand;
  Ipp32s xScale = (HEAAC_LP_MODE == mode) ? 1 : 2;

  /********************************************************************
   * NOTE: code may be optimized (memory), if synthesis implement here
   ********************************************************************/

  for (l = 0; l < 32; l++) {
    if (l < transitionBand) {
      xoverBand = kx_prev;
    } else {
      xoverBand = kx;
    }

    for (k = 0; k < xoverBand * xScale; k++) {
      ZBuf[l][k] = XBuf[SBR_TIME_HFADJ + l][k];
    }

    if (mode == HEAAC_LP_MODE) {
      ZBuf[l][xoverBand - 1] += YBuf[SBR_TIME_HFADJ + l][xoverBand - 1];
    }

    for (k = xoverBand * xScale; k < 64 * xScale; k++) {
      ZBuf[l][k] = YBuf[SBR_TIME_HFADJ + l][k];
    }
  }

  return 0;     // OK
}

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

/* Set HF subbands to zero */
Ipp32s sbrCleanHFBand(Ipp32f** pYBuf, Ipp32s startBand, Ipp32s stopBand, Ipp32s mode)
{
  Ipp32s i;
  Ipp32s xScale = (HEAAC_LP_MODE == mode) ? 1 : 2;

  for (i = startBand; i < stopBand; i++) {
    ippsZero_32f(pYBuf[i + SBR_TIME_HFADJ], 64 * xScale);
  }

  return 0; //OK
}

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

Ipp32s sbrUpDateBands(Ipp32f** ppSrc)
{
  Ipp32s  l;
  Ipp32f* pBufTmp;

  for (l = 0; l < SBR_TIME_HFGEN; l++) {
    // Re part
    pBufTmp    = ppSrc[l];
    ppSrc[l] = ppSrc[NUM_TIME_SLOTS * RATE + l];
    ppSrc[NUM_TIME_SLOTS * RATE + l] = pBufTmp;
  }

  return 0;
}

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

Ipp32s ownSynchronization_PS_32fc( Ipp32fc** ppSrc, Ipp32fc** ppDst )
{
  Ipp32s l = 0, k = 0;

  for( l = NUM_TIME_SLOTS * RATE; l < NUM_TIME_SLOTS * RATE + 6; l++ ){
    for( k = 0; k < 5; k++){
      ppDst[l][k] = ppSrc[l + SBR_TIME_HFADJ][k];
    }
  }

  return 0;//OK
}

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

Ipp32s ownPassiveUpdate_PS_32fc( Ipp32fc** ppSrc, Ipp32fc** ppDst )
{
  Ipp32s l = 0;

  for(l = 0; l < 32; l++){
    ippsCopy_32fc(ppSrc[l], ppDst[l], 64);
  }

  return 0;
}

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