sbrdec_filter_qmf_int.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<string.h>

#include "aaccmn_chmap.h"
#include "sbrdec.h"
#include "sbrdec_api_int.h"
#include "sbrdec_tables_int.h"
#include "sbrdec_own_int.h"

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

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

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

Ipp32s sbrdecInitFilter( sSbrDecFilter** pDC, int* pSizeWorkBuf )
{
  int pSizeSpec = 0, pSizeInit = 0, pSizeBuf = 0;
  Ipp8u* pBufInit;

  *pDC = (sSbrDecFilter*)ippsMalloc_8u( sizeof(sSbrDecFilter) );

  // analysis
  ippsFFTGetSize_C_32s
                   ( 6, IPP_FFT_NODIV_BY_ANY, ippAlgHintAccurate,
                     &pSizeSpec, &pSizeInit, &pSizeBuf );

  if( pSizeInit )
    pBufInit = ippsMalloc_8u(pSizeInit);
  else
    pBufInit = 0;

  if( pSizeSpec )
    (*pDC)->pMemSpecQMFA = ippsMalloc_8u(pSizeSpec);
  else
    (*pDC)->pMemSpecQMFA = 0;

  ippsFFTInit_C_32s
    ( &( (*pDC)->pFFTSpecQMFA),
                     6, IPP_FFT_NODIV_BY_ANY, ippAlgHintAccurate,
                     (*pDC)->pMemSpecQMFA, pBufInit );

  if( pBufInit )
    ippsFree(pBufInit);

  *pSizeWorkBuf = UMC_MAX( *pSizeWorkBuf, pSizeBuf );

  //synthesis

  ippsFFTGetSize_C_32sc
                   ( 7, IPP_FFT_NODIV_BY_ANY, ippAlgHintAccurate,
                     &pSizeSpec, &pSizeInit, &pSizeBuf );

  if( pSizeInit )
    pBufInit = ippsMalloc_8u(pSizeInit);
  else
    pBufInit = 0;

  if( pSizeSpec )
    (*pDC)->pMemSpecQMFS = ippsMalloc_8u(pSizeSpec);
  else
    (*pDC)->pMemSpecQMFS = 0;

  ippsFFTInit_C_32sc( &( (*pDC)->pFFTSpecQMFS), 7, IPP_FFT_NODIV_BY_ANY, ippAlgHintAccurate,
                     (*pDC)->pMemSpecQMFS, pBufInit );

  if( pBufInit )
    ippsFree(pBufInit);

  *pSizeWorkBuf = UMC_MAX( *pSizeWorkBuf, pSizeBuf );


  return 0;//OK;
}

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

Ipp32s sbrdecFreeFilter( sSbrDecFilter* pDC )
{
  if( pDC == 0 )
    return 0;

  //if( pDC != 0 ){
  if( pDC->pMemSpecQMFA )
    ippsFree( pDC->pMemSpecQMFA );

  if( pDC->pMemSpecQMFS )
    ippsFree( pDC->pMemSpecQMFS );
  //}

  ippsFree( pDC );

  return 0;//OK;
}

/********************************************************************
 *
 * <------------------QMF ANALYSIS BLOCK----------------------------->
 *
 ********************************************************************/

int PreQMFA_SBR_32s(int* pSrc, int* pDstRe, int* pDstIm)
{

  ippsMul_32s_Sfs(pSrc, SBR_TABLE_PRE_QMFA_COS_INT_Q30, pDstRe, 64, 32);
  ippsMul_32s_Sfs(pSrc, SBR_TABLE_PRE_QMFA_SIN_INT_Q30, pDstIm, 64, 32);

  return 0;
}

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

int PostQMFA_SBR_32s(int* pSrcRe, int* pSrcIm, int* pDstRe, int* pDstIm)
{
  int l;

  for(l=0; l<32; l++)
  {
    pDstRe[l] = MUL32_SBR_32S( pSrcRe[l], SBR_TABLE_POST_QMFA_COS_INT_Q30[l] ) -
                MUL32_SBR_32S( pSrcIm[l], SBR_TABLE_POST_QMFA_SIN_INT_Q30[l] );

    pDstIm[l] = MUL32_SBR_32S( pSrcRe[l], SBR_TABLE_POST_QMFA_SIN_INT_Q30[l] ) +
                MUL32_SBR_32S( pSrcIm[l], SBR_TABLE_POST_QMFA_COS_INT_Q30[l] );
  }

  return 0;
}

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

int  ippsAnalysisFilter_FT_SBR_RToC_32s32s_Sfs(int* pSrc, int* pDstRe, int* pDstIm,
                                        IppsFFTSpec_C_32s* pFFTSpecQMFA,
                                        int scaleFactor, Ipp8u* pWorkBuffer)
{
  int preRe[64], preIm[64], postRe[64], postIm[64];

  PreQMFA_SBR_32s(pSrc, preRe, preIm);

  ippsFFTInv_CToC_32s_Sfs
                   ( preRe, preIm,
                     postRe, postIm,
                     pFFTSpecQMFA,
                     scaleFactor - 4,  pWorkBuffer);


  PostQMFA_SBR_32s(postRe, postIm, pDstRe, pDstIm);

  return 0;//OK

}

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

int ippsAnalysisFilter_SBR_RToC_32s_Sfs(Ipp32s* pSrc,
                                        Ipp32s* pDstRe, Ipp32s* pDstIm,
                                        Ipp32s* pWinTable, int kx,
                                        IppsFFTSpec_C_32s* pFFTSpecQMFA,
                                        int* pDelayCoefs,
                                        Ipp8u* pWorkBuf, int ScaleFactor)
{
  int n, k, j;
  int status = 0;
  Ipp32s  z_int[320];
  Ipp32s  u_int[64];

  for (n = 319; n >= 32; n--) {
      pDelayCoefs[n] = pDelayCoefs[n - 32];
    }
    for (n = 31; n >= 0; n--) {
      pDelayCoefs[n] = pSrc[31 - n] << (SCALE_FACTOR_QMFA_IN - ScaleFactor);
    }

   ippsMul_32s_Sfs(pDelayCoefs, pWinTable, z_int, 320, 31);

    for (n = 0; n <= 63; n++) {
      u_int[n] = 0;
      for (j = 0; j <= 4; j++) {
        u_int[n] += z_int[n + j * 64];
      }
    }

    ippsAnalysisFilter_FT_SBR_RToC_32s32s_Sfs(u_int,
                                             pDstRe,
                                             pDstIm,
                                             pFFTSpecQMFA,
                                             7,
                                             pWorkBuf);

// set zerro high band
    for (k = kx; k < 32; k++) {
      pDstRe[k] = 0;
      pDstIm[k] = 0;
    }

    return status;
}

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

int ippsAnalysisFilter_SBR_RToC_32s_D2L_Sfs(Ipp32s* pSrc,
                                    Ipp32s* pDstRe[], Ipp32s* pDstIm[],
                                    Ipp32s* pWinTable, int NumLoop, int kx,
                                    IppsFFTSpec_C_32s* pFFTSpecQMFA,
                                    int* pDelayCoefs,
                                    Ipp8u* pWorkBuf, int ScaleFactor)
{
  int l;
  int status = 0;

  for (l = 0; l < NumLoop; l++) {

    ippsAnalysisFilter_SBR_RToC_32s_Sfs(pSrc + 32 * l,
                                        pDstRe[l], pDstIm[l],
                                        pWinTable, kx,
                                        pFFTSpecQMFA,
                                        pDelayCoefs,
                                        pWorkBuf,
                                        ScaleFactor);

  }

  return status;
}
/********************************************************************
 *
 * <------------------QMF SYNTHESIS BLOCK--------------------------->
 *
 ********************************************************************/

int PreQMFS_SBR_32sc(Ipp32sc* pSrc,  Ipp32sc* pDst)
{
  int k;
  //float xCos, ySin, angle;
  //Ipp32f SBR_PI = 3.14159265358979f;

  for(k = 0; k < 64; k++)
  {
    //angle = -SBR_PI / 128 * ( 255*k +1 )  ;
    //xCos = cos(angle);
    //ySin = sin(angle);

    pDst[k].re = MUL32_SBR_32S( pSrc[k].re, SBR_TABLE_PRE_QMFS_COS_INT_Q31[k] )  -
                 MUL32_SBR_32S( pSrc[k].im, SBR_TABLE_PRE_QMFS_SIN_INT_Q31[k] );

    pDst[k].im = MUL32_SBR_32S( pSrc[k].im, SBR_TABLE_PRE_QMFS_COS_INT_Q31[k] ) +
                 MUL32_SBR_32S( pSrc[k].re, SBR_TABLE_PRE_QMFS_SIN_INT_Q31[k] );
  }

  return 0;
}

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

int PostQMFS_SBR_32sc(Ipp32sc* pSrc,  Ipp32sc* pDst)
{
  int n;
  //float xCos, ySin, angle;
  //Ipp32f SBR_PI = 3.14159265358979f;

  for(n = 0; n < 128; n++)
  {
    //angle = SBR_PI / 128 * (n - 126.5f);
    //xCos = cos(angle);
    //ySin = sin(angle);

    pDst[n].re = MUL32_SBR_32S( pSrc[n].re, SBR_TABLE_POST_QMFS_COS_INT_Q31[n] )  -
                 MUL32_SBR_32S( pSrc[n].im, SBR_TABLE_POST_QMFS_SIN_INT_Q31[n] );

    pDst[n].im = MUL32_SBR_32S( pSrc[n].im, SBR_TABLE_POST_QMFS_COS_INT_Q31[n] ) +
                 MUL32_SBR_32S( pSrc[n].re, SBR_TABLE_POST_QMFS_SIN_INT_Q31[n] );

  }

  return 0;
}

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

int sbrClip_64s32s(Ipp64s inData)
{
  int outData;

  if (inData > 0x7FFFFFFF )
    outData = 0x7FFFFFFF;
  else if (inData < -0x7FFFFFFF)
    outData = -0x7FFFFFFF;
  else
    outData = (int)inData;

  return outData;
}

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

int ippsRealToCplx_32s(const int* pSrcRe, const int* pSrcIm, Ipp32sc* pSrc, int len)
{
  int k;

  for(k=0; k<len; k++)
  {
    pSrc[k].re = pSrcRe[k];
    pSrc[k].im = pSrcIm[k];
  }

  return 0;
}

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

int ippsCplxToReal_32sc(const Ipp32sc* pSrc, int* pSrcRe, int* pSrcIm, int len)
{
  int k;

  for(k=0; k<len; k++)
  {
    pSrcRe[k] = pSrc[k].re;
    pSrcIm[k] = pSrc[k].im;
  }

  return 0;
}

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

int  ippsSynthesisFilter_FT_SBR_RToC_32s32s_Sfs(const int* pSrcRe,
                                               const int* pSrcIm,
                                               IppsFFTSpec_C_32sc* pFFTSpecQMFS,
                                               int* pDst,
                                               Ipp8u *pWorkBuf)

{
  Ipp32sc vec_128_32sc[128];
  Ipp32s  vec_128_32s[128];
  Ipp32sc fft_out[128];
  Ipp32sc pSrc[64];

  ippsZero_32sc(&(vec_128_32sc[64]), 64);

  ippsRealToCplx_32s(pSrcRe, pSrcIm, pSrc, 64);

  PreQMFS_SBR_32sc(pSrc,  vec_128_32sc); //Q(5) * Q(31) * Q(-32) = Q(5-1)

  ippsFFTInv_CToC_32sc_Sfs(vec_128_32sc, fft_out, pFFTSpecQMFS, 3, pWorkBuf);//Q(5+2)

  PostQMFS_SBR_32sc(fft_out, fft_out);//Q(5+2) * Q(31) * Q(-32) = Q(5+1)

  ippsCplxToReal_32sc(fft_out, pDst, vec_128_32s, 128);

  return 0;
}

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

int ippsSynthesisFilter_SBR_CToR_32s(const int* piSrcRe,
                                     const int* piSrcIm,
                                     Ipp32s *pDst,

                                     const Ipp32s *pSbrTableWindow,
                                     IppsFFTSpec_C_32sc* pFFTSpecQMFS,
                                     int* pDelayCoefs,
                                     int* scaleFactor,
                                     Ipp8u *pWorkBuf)
{
  Ipp32s g[640];
  Ipp32s* v ;
  int n,k;
  int status = 0;

  v = pDelayCoefs;

  ippsMove_32s(v, v+128, 1280-128);

  ippsSynthesisFilter_FT_SBR_RToC_32s32s_Sfs(piSrcRe, piSrcIm, pFFTSpecQMFS, v, pWorkBuf);

  for (n=0; n<5; n++) {
    for (k=0; k<=63; k++) {
      g[128*n + k]      = v[256*n + k];
      g[128*n + 64 + k] = v[256*n + 192 + k];
    }
  }

  ippsMul_32s_ISfs(pSbrTableWindow, g, 640, 32);

  for (k=0; k<=63; k++) {
    Ipp64s sum = 0L;

    for (n=0; n<=9; n++) {
      sum += g[64*n + k];
    }
    pDst[k] = sbrClip_64s32s( sum );//Q(5)
  }


  *scaleFactor =  5 ;

  return status;
}

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

int ippsSynthesisFilter_SBR_CToR_32s_D2L(const int** piSrcRe,
                                         const int** piSrcIm,

                                         Ipp32s *pDst,

                                         const Ipp32s *pSbrTableWindow,
                                         int NumLoop,
                                         IppsFFTSpec_C_32sc* pFFTSpecQMFS,
                                         int* pDelayCoefs,
                                         int* scaleFactor,
                                         Ipp8u *pWorkBuf)
{
  int l;
  int status = 0;

  for (l=0; l<NumLoop; l++) {

    ippsSynthesisFilter_SBR_CToR_32s( piSrcRe[l],
                                      piSrcIm[l],
                                      pDst + 64*l,

                                     pSbrTableWindow,
                                     pFFTSpecQMFS,
                                     pDelayCoefs,
                                     scaleFactor,
                                     pWorkBuf);
  }

  *scaleFactor =  5 ;

  return status;
}

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

/* EOF */