sbrdec_decoder_fp.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2005 Intel Corporation. All Rights Reserved.
//
*/

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

#include<ipps.h>
#include<ippac.h>
#include<math.h>

#include"sbrdec_api_fp.h"
#include"sbrdec_element.h"
#include"sbrdec_tables.h"

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

#ifndef ID_SCE
#define ID_SCE    0x0
#endif

#ifndef ID_CPE
#define ID_CPE    0x1
#endif

#ifndef UMC_MAX
#define UMC_MAX(a,b)    (((a) > (b)) ? (a) : (b))
#endif
#ifndef UMC_MIN
#define UMC_MIN(a,b)    (((a) < (b)) ? (a) : (b))
#endif

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

static Ipp32s sbrPassiveUpsampling(Ipp32f **XBufRe, Ipp32f **XBufIm,
                                   Ipp32f **ZBufRe, Ipp32f **ZBufIm, Ipp32s mode);

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

static Ipp32s sbrActiveUpsampling(Ipp32f **XBufRe, Ipp32f **XBufIm,
                                  Ipp32f **YBufRe, Ipp32f **YBufIm, Ipp32s transitionBand,
                                  Ipp32s kx_prev, Ipp32s kx,
                                  Ipp32s M, Ipp32s M_prev,
                                  Ipp32f **ZBufRe, Ipp32f **ZBufIm, Ipp32s mode);

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

/* Set HF subbands to zero */
int sbrCleanHFBand(Ipp32f** pYBufRe, Ipp32f** pYBufIm, int startBand, int stopBand);

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

int sbrUpDateLowBand(Ipp32f** pXBufRe, Ipp32f** pXBufIm, int decode_mode );

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

static int sbrUpdateAmpRes( int bs_frame_class, int L_E, int bs_amp_res)
{
  if ((bs_frame_class == FIXFIX) && (L_E == 1))
    bs_amp_res = 0;

  return bs_amp_res;
}

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

Ipp32s sbrdecReset( sSbrBlock* pSbr )
{
  IppStatus status;

  sbrdecResetCommon( &(pSbr->sbr_com) );

  status = ippsZero_32f(pSbr->sbr_WS.BufGain[0][0], 2*MAX_NUM_ENV*MAX_NUM_ENV_VAL);
  status = ippsZero_32f(pSbr->sbr_WS.BufNoise[0][0], 2*MAX_NUM_ENV*MAX_NUM_ENV_VAL);
  status = ippsZero_32f(pSbr->sbr_WS.bwArray[0], 2 * MAX_NUM_NOISE_VAL);

  return 0;//OK
}

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

sSbrBlock *sbrInitDecoder( void )
{
  Ipp32s  ch, j;
  sSbrBlock *pSbr = 0;

  const Ipp32s Size32 = (32) * (NUM_TIME_SLOTS * RATE + SBR_TIME_HFGEN);
  const Ipp32s Size64 = (64) * (NUM_TIME_SLOTS * RATE + SBR_TIME_HFGEN);

  IppStatus status = ippStsNoErr;

  pSbr = (sSbrBlock *) ippsMalloc_8u(sizeof(sSbrBlock));

  if ( pSbr == 0 )
    return 0;

/* -------------------------------- set memory for matrix ------------------------------------ */
  for (ch = 0; ch < 2; ch++) {
    pSbr->sbr_WS.XBufRe[ch][0] = ippsMalloc_32f((Size32 + 2 * Size64) * 2);
    ippsZero_32f(pSbr->sbr_WS.XBufRe[ch][0], (Size32 + 2 * Size64) * 2);

    /* process need because mixing memory will be done */
    pSbr->sbr_WS._dcMemoryMatrix[ch] = 0;
    pSbr->sbr_WS._dcMemoryMatrix[ch] = pSbr->sbr_WS.XBufRe[ch][0];

    for (j = 0; j < (NUM_TIME_SLOTS * RATE + SBR_TIME_HFGEN); j++) {
      pSbr->sbr_WS.XBufRe[ch][j] = pSbr->sbr_WS.XBufRe[ch][0] + j * (32);
      pSbr->sbr_WS.XBufIm[ch][j] = pSbr->sbr_WS.XBufRe[ch][0] + (Size32 + 2 * Size64) + j * (32);

      pSbr->sbr_WS.ZBufRe[ch][j] = pSbr->sbr_WS.XBufRe[ch][0] + (Size32 + 0 * Size64)+ j * (64);
      pSbr->sbr_WS.ZBufIm[ch][j] =
        pSbr->sbr_WS.XBufRe[ch][0] + (Size32 + 2 * Size64) + (Size32 + 0 * Size64)+ j * (64);

      pSbr->sbr_WS.YBufRe[ch][j] = pSbr->sbr_WS.XBufRe[ch][0] + (Size32 + 1 * Size64)+ j * (64);
      pSbr->sbr_WS.YBufIm[ch][j] =
        pSbr->sbr_WS.XBufRe[ch][0] + (Size32 + 2 * Size64) + (Size32 + 1 * Size64)+ j * (64);
    }
  }
/* --------------------------------  set default values ------------------------------------ */

  // FLOAT POINT BLOCK
  sbrdecReset( pSbr );

  // only once time
  pSbr->sbr_com.sbrHeaderFlagPresent = 0;

/* -------------------------------- malloc memory for general work buffer ---------------------------- */

  if (status == ippStsNoErr)
    return pSbr;        // OK
  else
    return 0;
}

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

Ipp32s sbrFreeDecoder(sSbrBlock * pSbr)
{
  Ipp32s  ch;

  if( pSbr == 0 )
    return 0;

  for (ch = 0; ch < 2; ch++) {
    if( pSbr->sbr_WS._dcMemoryMatrix[ch] )
      ippsFree( (Ipp32f*)(pSbr->sbr_WS._dcMemoryMatrix[ch]) );
  }

  //if( pSbr->sbr_com.WorkBuffer )
  //  ippsFree( pSbr->sbr_com.WorkBuffer );

  ippsFree(pSbr);

  return 0;     // OK
}

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

Ipp32s sbrGetFrame(Ipp32f *pSrc, Ipp32f *pDst, sSbrBlock * pSbr, sSbrDecFilter* sbr_filter,
                   Ipp32s ch, Ipp32s decode_mode, Ipp32s dwnsmpl_mode, Ipp8u* pWorkBuffer )
{

  sSbrDecCommon* com   = &(pSbr->sbr_com);
  sSbrDecWorkSpace* ws = &(pSbr->sbr_WS);
  Ipp32s  l;
  Ipp32s  transitionBand = com->transitionBand[ch];
  int bs_amp_res;

/* -------------------------------- Analysis ---------------------------- */
  if (decode_mode == HEAAC_HQ_MODE)
    ippsAnalysisFilter_SBR_RToC_32f_D2L(pSrc,
                                        ws->XBufRe[ch], ws->XBufIm[ch],
                                        SBR_TABLE_QMF_WINDOW_320,
                                        NUM_TIME_SLOTS * RATE, SBR_TIME_HFGEN,
                                        pSbr->sbr_com.kx,
                                        sbr_filter->pAnalysisFilterSpec_HQmode[ch],
                                        pWorkBuffer );
  else {
    for(l=0; l<NUM_TIME_SLOTS * RATE; l++) {

      /*********************************************************************
       * NOTE:
       * (1) matrix idea is better than 1D
       *     but if you can use this function for non-matrix,
       *     you must use such consrtuctions
       * (2) you can use non-standard function of window and get better
       *     result (speech codec or other area)
       *********************************************************************/
      ippsAnalysisFilter_SBR_RToR_32f_D2L(pSrc + l*32,
                                          ws->XBufRe[ch] + l + SBR_TIME_HFGEN,
                                          SBR_TABLE_QMF_WINDOW_320,
                                          1, 0,
                                          com->kx,
                                          sbr_filter->pAnalysisFilterSpec_LPmode[ch],
                                          pWorkBuffer );
    }
  }

/* -------------------------------- SBR process ---------------------------- */
  if ((com->sbrHeaderFlagPresent != 0) && (com->sbrFlagError == 0) &&
      ((com->id_aac == ID_SCE) || (com->id_aac == ID_CPE))) {

        if ( !ch || !com->bs_coupling )
        {
           bs_amp_res = sbrUpdateAmpRes( com->bs_frame_class[ch], com->L_E[ch],
                                        com->bs_amp_res);

           sbrDequantization(com, ws, ch,  bs_amp_res);
        }

        /* Set HF subbands to zero */
        {
          int startBand = RATE * com->tE[ch][0];
          int stopBand  = RATE * com->tE[ch][ com->L_E[ch] ];

          sbrCleanHFBand(ws->YBufRe[ch], ws->YBufIm[ch], startBand, stopBand);
        }

        sbrGenerationHF(ws->XBufRe[ch], ws->XBufIm[ch],
                        ws->YBufRe[ch], ws->YBufIm[ch],
                        com, ws->bwArray[ch], ws->degPatched[ch],
                        ch, decode_mode,  (Ipp32f*)pWorkBuffer );

    if (decode_mode == HEAAC_LP_MODE) {
      for (l = RATE * com->tE[ch][0]; l < RATE * com->tE[ch][com->L_E[ch]];
           l++) {
        ippsZero_32f(ws->YBufRe[ch][SBR_TIME_HFADJ + l], com->kx);
      }
    }

    sbrAdjustmentHF(ws->YBufRe[ch], ws->YBufIm[ch],
                    ws->vecEnvOrig[ch], ws->vecNoiseOrig[ch],
                    ws->BufGain[ch], ws->BufNoise[ch],
                    com, ws->degPatched[ch], pWorkBuffer,
                     com->Reset, ch, decode_mode );

    sbrActiveUpsampling(        // in data
                         ws->XBufRe[ch], ws->XBufIm[ch],
                         ws->YBufRe[ch], ws->YBufIm[ch],
                         transitionBand, com->kx_prev, com->kx,
                         com->M, com->M_prev,
                 // out data
                         ws->ZBufRe[ch], ws->ZBufIm[ch],
                         decode_mode);

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

  } else {
    sbrPassiveUpsampling(ws->XBufRe[ch], ws->XBufIm[ch],
                         ws->ZBufRe[ch],    ws->ZBufIm[ch],
                         decode_mode);
  }

/* -------------------------------- Synthesis OR SynthesisDown ---------------------------- */
  /*********************************************************************************
   * see comment in sbrPassiveUpsampling OR sbrActiveUpsampling functions
   *********************************************************************************/

  if (decode_mode == HEAAC_HQ_MODE) {
    if (dwnsmpl_mode == HEAAC_DWNSMPL_OFF)
      ippsSynthesisFilter_SBR_CToR_32f_D2L(ws->ZBufRe[ch], ws->ZBufIm[ch], pDst,
                                           SBR_TABLE_QMF_WINDOW_640,
                                           NUM_TIME_SLOTS * RATE,
                                           sbr_filter->pSynthesisFilterSpec_HQmode[ch],
                                           pWorkBuffer );
    else
      ippsSynthesisDownFilter_SBR_CToR_32f_D2L(ws->ZBufRe[ch], ws->ZBufIm[ch],
                                               pDst, SBR_TABLE_QMF_WINDOW_320,
                                               NUM_TIME_SLOTS * RATE,
                                               sbr_filter->pSynthesisDownFilterSpec_HQmode[ch],
                                               pWorkBuffer );

  } else {
    if (dwnsmpl_mode == HEAAC_DWNSMPL_OFF)
      ippsSynthesisFilter_SBR_RToR_32f_D2L(ws->ZBufRe[ch], pDst,
                                           SBR_TABLE_QMF_WINDOW_640,
                                           NUM_TIME_SLOTS * RATE,
                                           sbr_filter->pSynthesisFilterSpec_LPmode[ch],
                                           pWorkBuffer );
    else
      ippsSynthesisDownFilter_SBR_RToR_32f_D2L(ws->ZBufRe[ch], pDst,
                                               SBR_TABLE_QMF_WINDOW_320,
                                               NUM_TIME_SLOTS * RATE,
                                               sbr_filter->pSynthesisDownFilterSpec_LPmode[ch],
                                               pWorkBuffer );
  }

  sbrUpDateLowBand(ws->XBufRe[ch], ws->XBufIm[ch], decode_mode );

/* ---------------------------- <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->Reset = 0;
  }

  return 0;     // OK
}

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

Ipp32s sbrPassiveUpsampling(Ipp32f **XBufRe, Ipp32f **XBufIm, Ipp32f **ZBufRe,
                            Ipp32f **ZBufIm, Ipp32s mode)
{
  Ipp32s  l;
  /********************************************************************
   * NOTE: code may be optimized (memory), if synthesis implement here
   ********************************************************************/
  for (l = 0; l < NUM_TIME_SLOTS * RATE; l++) {

    ippsCopy_32f(XBufRe[l + SBR_TIME_HFADJ], ZBufRe[l], NUM_TIME_SLOTS * RATE);
    ippsZero_32f(&(ZBufRe[l][32]), NUM_TIME_SLOTS * RATE);

    if (mode == HEAAC_HQ_MODE) {
      ippsCopy_32f(XBufIm[l + SBR_TIME_HFADJ], ZBufIm[l], NUM_TIME_SLOTS * RATE);
      ippsZero_32f(&(ZBufIm[l][32]), NUM_TIME_SLOTS * RATE);
    }
  }

  return 0;     // OK
}

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

Ipp32s sbrActiveUpsampling(
                            Ipp32f **XBufRe, Ipp32f **XBufIm, Ipp32f **YBufRe,
                            Ipp32f **YBufIm, Ipp32s transitionBand, Ipp32s kx_prev,
                            Ipp32s kx, Ipp32s M, Ipp32s M_prev,
                            Ipp32f **ZBufRe, Ipp32f **ZBufIm, Ipp32s mode)
{
  Ipp32s  k, l;
  Ipp32s  xoverBand, xoverM;

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

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

    for (k = 0; k < xoverBand; k++) {
      ZBufRe[l][k] = XBufRe[SBR_TIME_HFADJ + l][k];
      ZBufIm[l][k] = XBufIm[SBR_TIME_HFADJ + l][k];
    }

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

    for (k = xoverBand; k < 64; k++) {
      ZBufRe[l][k] = YBufRe[SBR_TIME_HFADJ + l][k];
      ZBufIm[l][k] = YBufIm[SBR_TIME_HFADJ + l][k];
    }

  }
/* ----------------------- <Update High Band Data>------------------------- */
  for (l = 0; l < SBR_TIME_HFGEN; l++) {

    Ipp32f* pBufTmp = YBufRe[l];
    YBufRe[l] = YBufRe[l + 32];
    YBufRe[l + 32] = pBufTmp;
    if (mode == HEAAC_HQ_MODE) {

      pBufTmp = YBufIm[l];
      YBufIm[l] = YBufIm[l + 32];
      YBufIm[l + 32] = pBufTmp;
    }
  }

  return 0;     // OK
}

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

/* Set HF subbands to zero */
int sbrCleanHFBand(Ipp32f** pYBufRe, Ipp32f** pYBufIm, int startBand, int stopBand)
{
  int i;

  for (i = startBand; i < stopBand; i++) {
    ippsZero_32f(pYBufRe[i + SBR_TIME_HFADJ], 64);
    ippsZero_32f(pYBufIm[i + SBR_TIME_HFADJ], 64);
  }

  return 0; //OK
}

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

int sbrUpDateLowBand(Ipp32f** pXBufRe, Ipp32f** pXBufIm, int decode_mode )
{
  int l;

  for (l = 0; l < SBR_TIME_HFGEN; l++) {
    Ipp32f* pBufTmp;

    pBufTmp = pXBufRe[0 + l];
    pXBufRe[0 + l] = pXBufRe[NUM_TIME_SLOTS * RATE + l];
    pXBufRe[NUM_TIME_SLOTS * RATE + l] = pBufTmp;

    if (decode_mode == HEAAC_HQ_MODE) {

      pBufTmp = pXBufIm[0 + l];
      pXBufIm[0 + l] = pXBufIm[NUM_TIME_SLOTS * RATE + l];
      pXBufIm[NUM_TIME_SLOTS * RATE + l] = pBufTmp;
    }
  }

  return 0;
}

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

/* EOF */