sbrdec_filter_inv_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<math.h>
#include<string.h>
#include "ipps.h"
#include "ippac.h"
#include "sbrdec_element.h"
#include "sbrdec_own_int.h"
#include "sbrdec_setting_int.h"

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

#ifndef MUL32_SBR_32S
#define MUL32_SBR_32S(x, y) \
  (Ipp32s)(((Ipp64s)((Ipp64s)(x) * (Ipp64s)(y)))>>32)
#endif

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

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

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

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

int sbrNormalizationCovElements(Ipp64sc * vIn, Ipp32sc *vOut, int len)
{
  int     n, nDataBit, nGuardBit, shift;
  int     absMax;

  absMax = 0;

  for (n = 0; n < len; n++) {
    absMax |=
      (int)abs((int)(vIn[n].re >> 32)) | (int)abs((int)(vIn[n].im >> 32));
  }

  if (absMax == 0) {

    absMax = 0;
    for (n = 0; n < len; n++) {
      absMax |= (int)abs((int)vIn[n].re) | (int)abs((int)vIn[n].im);
    }
    nGuardBit = 32 + sbrCalcGuardBit(absMax);

  } else {

    absMax = 0;
    for (n = 0; n < len; n++) {
      absMax |=
        (int)abs((int)(vIn[n].re >> 32)) | (int)abs((int)(vIn[n].im >> 32));
    }

    nGuardBit = sbrCalcGuardBit(absMax);
  }

  nDataBit = 64 - nGuardBit;
  if (nDataBit <= 30) {

    shift = (30 - nDataBit);
    for (n = 0; n < len; n++) {
      vOut[n].re = (int)vIn[n].re << shift;
      vOut[n].im = (int)vIn[n].im << shift;
    }
    return (2 * SCALE_FACTOR_QMFA_OUT + shift);

  } else {      /* if (nDataBit < 32 + 30) */

    shift = (nDataBit - 30);

    for (n = 0; n < len; n++) {
      vOut[n].re = (int)(vIn[n].re >> shift);
      vOut[n].im = (int)(vIn[n].im >> shift);
    }
    return (2 * SCALE_FACTOR_QMFA_OUT - shift);

  }

//  return 0;
}

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

IppStatus ippsPredictCoef_SBR_C_32s_D2L(Ipp32s** pSrcRe,
                                        Ipp32s** pSrcIm,
                                        Ipp32s *pAlpha0Re, Ipp32s *pAlpha0Im,
                                        Ipp32s *pAlpha1Re, Ipp32s *pAlpha1Im,
                                        int k0, int len, int scaleFactor)
{
  const int TIME_HF_ADJ = 2;
  int     i, j, k, n;
  int     offset;
  int     vAbsMaxRe[40];
  int     vAbsMaxIm[40];
  int     maxRe, maxIm, maxCommon;
  int     nGuardBit;

  Ipp64sc vIn[5];
  Ipp32sc vOut[5];
  Ipp32s  iDet, iInvD;
  Ipp32sc coef;
  Ipp32s *iA0Re = pAlpha0Re;
  Ipp32s *iA0Im = pAlpha0Im;
  Ipp32s *iA1Re = pAlpha1Re;
  Ipp32s *iA1Im = pAlpha1Im;

  int** pXRe = pSrcRe + TIME_HF_ADJ;
  int** pXIm = pSrcIm + TIME_HF_ADJ;

  int     scaleFactorOut;

  const Ipp64sc zerro_64sc = { 0, 0 };

  Ipp64sc fi01, fi02, fi11, fi12, fi22;
  Ipp32sc iFi01, iFi02, iFi11, iFi12, iFi22;

/* step 1: estimate MaxVal */
  for (k = 0; k < 40; k++) {
    ippsMaxAbs_32s(pSrcRe[k], 32, vAbsMaxRe + k);
    ippsMaxAbs_32s(pSrcIm[k], 32, vAbsMaxIm + k);
  }

  ippsMax_32s(vAbsMaxRe, 40, &maxRe);
  ippsMax_32s(vAbsMaxIm, 40, &maxIm);

  maxCommon = UMC_MAX(maxRe, maxIm);

  if (maxCommon == 0) {

    return ippStsNoErr;   // OK
  }

/* step 2: calculate num Guard bit */
  nGuardBit = sbrCalcGuardBit(maxCommon);
  nGuardBit -= 1;       // remove "sign"

/* step 3: check  nGuardBit >= 3 (!!!) */
  offset = 0;
  if (nGuardBit < 3)
    offset = 3 - nGuardBit;

/* step 4: scale */
  if (offset) {
    for (k = 0; k < 40; k++) {
      ippsRShiftC_32s_I(offset, (Ipp32s *)pSrcRe[k], 32);
      ippsRShiftC_32s_I(offset, (Ipp32s *)pSrcIm[k], 32);
    }
  }

/* step 5: main loop */
  for (k = 0; k < k0; k++) {
    fi01 = fi02 = fi11 = fi12 = fi22 = zerro_64sc;

/* ---------------------------- correlation ---------------------------- */
/*
 * step 5.1: correlation
 */
    for (n = 0; n < len; n++) {
      i = 0;
      j = 1;
      fi01.re +=
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) +
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);

      fi01.im +=
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) -
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);

      i = 0;
      j = 2;
      fi02.re +=
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) +
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);

      fi02.im +=
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) -
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);

      i = 1;
      j = 1;
      fi11.re +=
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) +
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);

      i = 1;
      j = 2;
      fi12.re +=
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) +
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);

      fi12.im +=
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) -
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);

      i = 2;
      j = 2;
      fi22.re +=
        (Ipp64s)(pXRe[n - i][k]) * (Ipp64s)(pXRe[n - j][k]) +
        (Ipp64s)(pXIm[n - i][k]) * (Ipp64s)(pXIm[n - j][k]);
    }

/* ---------------------------- determinant ---------------------------- */
/*
 * step 5.2: "exactly" normalization
 */
/*
 * step 5.2.1: fill vector In
 */
    vIn[0] = fi01;
    vIn[1] = fi02;
    vIn[2] = fi11;
    vIn[3] = fi12;
    vIn[4] = fi22;

/*
 * step 5.2.2: Normalization
 */
    scaleFactorOut = sbrNormalizationCovElements(vIn, vOut, 5);

/*
 * step 5.2.3: fill
 */
    iFi01 = vOut[0];
    iFi02 = vOut[1];
    iFi11 = vOut[2];
    iFi12 = vOut[3];
    iFi22 = vOut[4];

    scaleFactorOut = scaleFactorOut - 2 * offset;

/*
 * step 5.3: calc determinant
 */
    iDet =
      MUL32_SBR_32S(iFi12.re, iFi12.re) + MUL32_SBR_32S(iFi12.im,
                                                                    iFi12.im);
    iDet = MUL32_SBR_32S(iFi11.re, iFi22.re) - iDet;

/* ---------------------------- coefs Alpha1 ---------------------------- */

    if (iDet) {

      coef.re =
        MUL32_SBR_32S(iFi01.re, iFi12.re) - MUL32_SBR_32S(iFi01.im,
                                                                      iFi12.im);
      coef.re = coef.re - MUL32_SBR_32S(iFi02.re, iFi11.re);
      ippsDiv_32s_ISfs(&iDet, &coef.re, 1, -SCALE_FACTOR_LP_COEFS);

      coef.im =
        MUL32_SBR_32S(iFi01.re, iFi12.im) + MUL32_SBR_32S(iFi01.im,
                                                                      iFi12.re);
      coef.im = coef.im - MUL32_SBR_32S(iFi02.im, iFi11.re);
      ippsDiv_32s_ISfs(&iDet, &coef.im, 1, -SCALE_FACTOR_LP_COEFS);

      iA1Re[k] = coef.re;
      iA1Im[k] = coef.im;
    }

/* ---------------------------- coefs Alpha0 ---------------------------- */

    if (iFi11.re) {

      nGuardBit = sbrCalcGuardBit(iFi11.re) - 1;
      iFi11.re <<= nGuardBit;

      iInvD = 1;
      ippsDiv_32s_ISfs(&iFi11.re, &iInvD, 1, -60);

/*
 * { Ipp64s my_Unit = 0x1000000000000000L;//Q60 iInvD = (int)(my_Unit /
 * iFi11.re); }
 */

      // Re part
      coef.re =
        (iFi01.re >> 3) + MUL32_SBR_32S(iFi12.re, iA1Re[k]) +
        MUL32_SBR_32S(iFi12.im, iA1Im[k]);

      coef.re = -MUL32_SBR_32S(coef.re, iInvD) << (SCALE_FACTOR_LP_COEFS - 25 + nGuardBit);

      // Im part
      coef.im = (iFi01.im >> 3) - MUL32_SBR_32S(iFi12.im, iA1Re[k]) +
        MUL32_SBR_32S(iFi12.re, iA1Im[k]);

      coef.im = -MUL32_SBR_32S(coef.im, iInvD) << (SCALE_FACTOR_LP_COEFS - 25 + nGuardBit);

      iA0Re[k] = coef.re;
      iA0Im[k] = coef.im;
    }

    { // CHECK THRESHOLD
      int sum1, sum2;

      sum1 = MUL32_SBR_32S(iA0Re[k], iA0Re[k]) + MUL32_SBR_32S(iA0Im[k], iA0Im[k]);
      sum2 = MUL32_SBR_32S(iA1Re[k], iA1Re[k]) + MUL32_SBR_32S(iA1Im[k], iA1Im[k]);

      if (sum1 >= THRESHOLD_LP_COEFS || sum2 >= THRESHOLD_LP_COEFS) {

        iA0Re[k] = iA0Im[k] = iA1Re[k] = iA1Im[k] = 0;
      }
    }
// -----------------------
  }     /* for(k=0; k<k0; k++) */

/* ---------------------------- Reset ---------------------------- */
/*
 * RESET
 */
  if (offset) {
    for (k = 0; k < 40; k++) {
      ippsLShiftC_32s_I(offset, (Ipp32s *)pSrcRe[k], 32);
      ippsLShiftC_32s_I(offset, (Ipp32s *)pSrcIm[k], 32);
    }
  }

  return ippStsNoErr;
}

/* EOF */