aac_filterbank_int.c

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

    res = ippsFFTGetSize_C_32sc(order, IPP_FFT_NODIV_BY_ANY, ippAlgHintNone, &FFTSpecSize, pSizeInit, &bufSize);
    if (res != ippStsNoErr) {
      return (res);
    }
  }

  MDCT_BUFSIZE_COUNT(bufSize, bufSize)
  *pSizeBuf = bufSize;
  MDCTSpecSize = sizeof(IppMDCTContext_32s) + (len/2) * sizeof(Ipp32s) + 2 * MALLOC_ALIGNED_BYTES;

  *pSizeSpec = FFTSpecSize + MALLOC_ALIGNED_BYTES + MDCTSpecSize;

  return (ippStsNoErr);
}

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

static IppStatus ippsMDCTFwdGetBufSize_32s (const IppsMDCTFwdSpec_32s *pMDCTSpec,
                                            int                       *pSize)
{
  IppMDCTContext_32s *pCtxMDCT = (IppMDCTContext_32s*)pMDCTSpec;

  *pSize = pCtxMDCT->bufSize;
  return (ippStsNoErr);
}


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

static IppStatus ippsMDCTInvGetBufSize_32s (const IppsMDCTInvSpec_32s *pMDCTSpec,
                                            int                 *pSize)
{
  IppMDCTContext_32s *pCtxMDCT = (IppMDCTContext_32s*)pMDCTSpec;
  *pSize = pCtxMDCT->bufSize;
  return (ippStsNoErr);
}


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

static IppStatus ippsMDCTFwd_32s_Sfs (const Ipp32s              *pSrc,
                                            Ipp32s              *pDst,
                                      const IppsMDCTFwdSpec_32s *pMDCTSpec,
                                            int                 scaleFactor,
                                            Ipp8u               *pBuffer)
{
  IppMDCTContext_32s *pCtxMDCT  = (IppMDCTContext_32s*)pMDCTSpec;
  IppStatus          res        = ippStsNoErr;
  Ipp32sc            *pBuf      = NULL;
  Ipp32s             min0, max0;
  int                len, min, max, scalef;

  if (pBuffer != NULL) {
    pBuf = (Ipp32sc*)ALIGNED_PTR(pBuffer, MALLOC_ALIGNED_BYTES);
  } else {
    pBuf = (Ipp32sc*)ippsMalloc_8u(pCtxMDCT->bufSize);
    if (pBuf == NULL) {
      return ippStsMemAllocErr;
    }
  }

  len = pCtxMDCT->len;

  ippsMinMax_32s(pSrc, len, &min0, &max0);

  min = -((int)min0);
  max = max0;

  if (min > max) {
    max = min;
  }

  if (max == 0) {
    ippsZero_32s(pDst, len/2);
    GOTO_RET(ippStsNoErr);
  }

  scalef = 0;

  while (max <= 0x3FFFFFFF) {
    max *= 2;
    scalef++;
  }

/*
  if (max <= 0x5a827999) {   * 0x80000000 / sgrt(2) *
    scalef++;
  }
*/
  if (IS_POWER_2(len)) {

    ownMDCTFwdPreProc_32s((Ipp32s*)pSrc, pBuf, len, scalef, pCtxMDCT->sincos);
    res = ippsFFTFwd_CToC_32sc_Sfs(pBuf, pBuf, pCtxMDCT->ctxFFT, pCtxMDCT->order + 1, (Ipp8u*)(pBuf+len/4));
    if (res != ippStsNoErr) {
      GOTO_RET(res);
    }

    ownMDCTFwdPostProc_32s(pBuf, (Ipp64s*)(pBuf+len/4), len, pCtxMDCT->sincos);
    ippsConvert_64s32s_Sfs((Ipp64s*)(pBuf+len/4), pDst, len/2, ippRndZero, scaleFactor - pCtxMDCT->order + 26 + scalef);

  }

RET:
  if (pBuffer == NULL) {
    ippsFree(pBuf);
  }
  return (res);
}

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

static IppStatus ippsMDCTInv_32s_Sfs (const Ipp32s              *pSrc,
                                            Ipp32s              *pDst,
                                      const IppsMDCTInvSpec_32s *pMDCTSpec,
                                            int                 scaleFactor,
                                            Ipp8u               *pBuffer)
{
  IppMDCTContext_32s *pCtxMDCT  = (IppMDCTContext_32s*)pMDCTSpec;
  IppStatus          res        = ippStsNoErr;
  Ipp32sc            *pBuf      = NULL;
  Ipp32s             min0, max0;
  int                len, min, max, scalef;

  if (pBuffer != NULL) {
    pBuf = (Ipp32sc*)ALIGNED_PTR(pBuffer, MALLOC_ALIGNED_BYTES);
  } else {
    pBuf = (Ipp32sc*)ippsMalloc_8u(pCtxMDCT->bufSize);
    if (pBuf == NULL) {
      return ippStsMemAllocErr;
    }
  }

  len = pCtxMDCT->len;

  ippsMinMax_32s(pSrc, len, &min0, &max0);

  min = -((int)min0);
  max = max0;

  if (min > max) {
    max = min;
  }

  if (max == 0) {
    ippsZero_32s(pDst, len);
    GOTO_RET(ippStsNoErr);
  }

  scalef = 0;

  while (max <= 0x3FFFFFFF) {
    max *= 2;
    scalef++;
  }

  if (IS_POWER_2(len)) {

    ownMDCTInvPreProc_32s((Ipp32s*)pSrc, pBuf, len, scalef, pCtxMDCT->sincos);

    res = ippsFFTFwd_CToC_32sc_Sfs(pBuf, pBuf, pCtxMDCT->ctxFFT, pCtxMDCT->order, (Ipp8u*)(pBuf+len/4));
    if (res != ippStsNoErr) {
      GOTO_RET(res);
    }

    ownMDCTInvPostProc_32s(pBuf, (Ipp64s*)(pBuf+len/4), len, pCtxMDCT->sincos);
    ippsConvert_64s32s_Sfs((Ipp64s*)(pBuf+len/4), pDst, len, ippRndZero, scaleFactor + 29 + scalef);

  }

RET:
  if (pBuffer == NULL) {
    ippsFree(pBuf);
  }
  return (res);
}

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

AACStatus InitFilterbankInt(sFilterbankInt* pBlock,
                            int mode)
{
  int size, size_short, size_long;

  ippsZero_8u((Ipp8u*)pBlock, sizeof(sFilterbankInt));

  if (pBlock == NULL)
    return AAC_ALLOC;

  size = 0;

  if (mode & FB_DECODER) {
    if (ippsMDCTInvInitAlloc_32s(&pBlock->p_mdct_inv_long, N_LONG) != ippStsOk)
      return AAC_ALLOC;

    if (ippsMDCTInvInitAlloc_32s(&pBlock->p_mdct_inv_short, N_SHORT) != ippStsOk)
      return AAC_ALLOC;

    if (ippsMDCTInvGetBufSize_32s(pBlock->p_mdct_inv_long, &size) != ippStsOk)
      return AAC_ALLOC;

    if (ippsMDCTInvGetBufSize_32s(pBlock->p_mdct_inv_short, &size_short) != ippStsOk)
      return AAC_ALLOC;

    if (size < size_short) size = size_short;
  }

  if (mode & FB_ENCODER) {
    if (ippsMDCTFwdInitAlloc_32s(&pBlock->p_mdct_fwd_long, N_LONG) != ippStsOk)
      return AAC_ALLOC;

    if (ippsMDCTFwdInitAlloc_32s(&pBlock->p_mdct_fwd_short, N_SHORT) != ippStsOk)
      return AAC_ALLOC;

    if (ippsMDCTFwdGetBufSize_32s(pBlock->p_mdct_fwd_long, &size_long) != ippStsOk)
      return AAC_ALLOC;

    if (ippsMDCTFwdGetBufSize_32s(pBlock->p_mdct_fwd_short, &size_short) != ippStsOk)
      return AAC_ALLOC;

    if (size < size_long) size = size_long;
    if (size < size_short) size = size_short;
  }

  if (size != 0) {
    pBlock->p_buffer_inv = ippsMalloc_8u(size);
    pBlock->p_buffer_fwd = pBlock->p_buffer_inv;
  }

  return AAC_OK;
}

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

void FreeFilterbankInt(sFilterbankInt* pBlock)
{
  if (pBlock->p_mdct_inv_long)
      ippsMDCTInvFree_32s(pBlock->p_mdct_inv_long);
  if (pBlock->p_mdct_inv_short)
      ippsMDCTInvFree_32s(pBlock->p_mdct_inv_short);

  if (pBlock->p_mdct_fwd_long)
      ippsMDCTFwdFree_32s(pBlock->p_mdct_fwd_long);
  if (pBlock->p_mdct_fwd_short)
      ippsMDCTFwdFree_32s(pBlock->p_mdct_fwd_short);

  if (pBlock->p_buffer_inv)
    ippsFree(pBlock->p_buffer_inv);
}

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

void FilterbankDecInt(sFilterbankInt* p_data,
                      Ipp32s* p_in_spectrum,
                      Ipp32s* p_in_prev_samples,
                      int window_sequence,
                      int window_shape,
                      int prev_window_shape,
                      Ipp32s* p_out_samples_1st_part,
                      Ipp32s* p_out_samples_2nd_part)
{
  Ipp32s samples[N_LONG];
  Ipp32s* p_samples;
  Ipp32s* p_spectrum;
  Ipp32s *window_table_long, *prev_window_table_long;
  Ipp32s *window_table_short, *prev_window_table_short;
  Ipp32s mdct_out_short[N_SHORT];
  int j;

  if (0 == window_shape) {
    window_table_long  = SIN_longInt;
    window_table_short = SIN_shortInt;
  } else {
    window_table_long  = KBD_longInt;
    window_table_short = KBD_shortInt;
  }

  if (0 == prev_window_shape) {
    prev_window_table_long  = SIN_longInt;
    prev_window_table_short = SIN_shortInt;
  } else {
    prev_window_table_long  = KBD_longInt;
    prev_window_table_short = KBD_shortInt;
  }

  switch(window_sequence)
  {
  case ONLY_LONG_SEQUENCE:
    ippsMDCTInv_32s_Sfs(p_in_spectrum, samples, p_data->p_mdct_inv_long,
                        -6, p_data->p_buffer_inv);

    ippsMul_32s_Sfs(prev_window_table_long, samples,
                    p_out_samples_1st_part, N_LONG/2, 31);

    ippsAdd_32s_ISfs(p_in_prev_samples, p_out_samples_1st_part, N_LONG/2, 0);

    ippsMul_32s_Sfs(&window_table_long[N_LONG/2], &samples[N_LONG/2],
                    p_out_samples_2nd_part, N_LONG/2, 31);
    break;
  case LONG_START_SEQUENCE:
    ippsMDCTInv_32s_Sfs(p_in_spectrum, samples, p_data->p_mdct_inv_long,
                        -6, p_data->p_buffer_inv);

    ippsMul_32s_Sfs(prev_window_table_long, samples,
                    p_out_samples_1st_part, N_LONG/2, 31);

    ippsAdd_32s_ISfs(p_in_prev_samples, p_out_samples_1st_part, N_LONG/2, 0);

    ippsCopy_32s(&samples[N_LONG / 2], p_out_samples_2nd_part,
                ((3*N_LONG-N_SHORT)/4-N_LONG/2));

    ippsMul_32s_Sfs(&window_table_short[N_SHORT / 2],
                    &samples[(3*N_LONG-N_SHORT)/4],
                    &p_out_samples_2nd_part[((3*N_LONG-N_SHORT)/4-N_LONG/2)],
                    N_SHORT/2, 31);

    ippsZero_32s(&p_out_samples_2nd_part[(3*N_LONG+N_SHORT)/4-N_LONG/2],
                  N_LONG-(3*N_LONG+N_SHORT)/4);
    break;
  case LONG_STOP_SEQUENCE:
    ippsMDCTInv_32s_Sfs(p_in_spectrum, samples, p_data->p_mdct_inv_long,
                        -6, p_data->p_buffer_inv);

    ippsZero_32s(p_out_samples_1st_part, (N_LONG-N_SHORT)/4);

    ippsMul_32s_Sfs(prev_window_table_short, &samples[(N_LONG-N_SHORT)/4],
                    &p_out_samples_1st_part[(N_LONG-N_SHORT)/4], N_SHORT/2, 31);

    ippsCopy_32s(&samples[(N_LONG+N_SHORT)/4],
                  &p_out_samples_1st_part[(N_LONG + N_SHORT)/4],
                  ((N_LONG/2)-((N_LONG+N_SHORT)/4)));

    ippsAdd_32s_ISfs(p_in_prev_samples, p_out_samples_1st_part, N_LONG/2, 0);

    ippsMul_32s_Sfs(&window_table_long[N_LONG/2],
                    &samples[N_LONG/2], p_out_samples_2nd_part, N_LONG/2, 31);
    break;
  case EIGHT_SHORT_SEQUENCE:
    p_samples = samples;
    p_spectrum = p_in_spectrum;

    ippsZero_32s(p_samples, N_LONG);
    p_samples += (N_LONG - N_SHORT) / 4;
    ippsMDCTInv_32s_Sfs(p_spectrum, (Ipp32s*)mdct_out_short,
                        p_data->p_mdct_inv_short, -3, p_data->p_buffer_inv);

    ippsMul_32s_Sfs(prev_window_table_short, mdct_out_short, p_samples, N_SHORT/2, 31);
    ippsMul_32s_Sfs(&window_table_short[N_SHORT/2], &mdct_out_short[N_SHORT/2],
                    &p_samples[N_SHORT/2],N_SHORT/2, 31);

    p_samples  += N_SHORT/2;
    p_spectrum += N_SHORT/2;

    for (j = 1; j < 8; j++) {
      ippsMDCTInv_32s_Sfs(p_spectrum, (Ipp32s*)mdct_out_short,
                          p_data->p_mdct_inv_short, -3, p_data->p_buffer_inv);

      ippsMul_32s_ISfs(window_table_short, mdct_out_short, N_SHORT, 31);
      ippsAdd_32s_ISfs(mdct_out_short, p_samples, N_SHORT, 0);
      p_samples  += N_SHORT/2;
      p_spectrum += N_SHORT/2;
    }

    ippsAdd_32s_Sfs(p_in_prev_samples, samples,
                    p_out_samples_1st_part, N_LONG/2, 0);
    ippsCopy_32s(&samples[N_LONG/2], p_out_samples_2nd_part, N_LONG/2);
    break;
  }
}

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

void FilterbankEncInt(sFilterbankInt* p_data,
                      Ipp32s* p_in_samples_1st_part,
                      Ipp32s* p_in_samples_2nd_part,
                      int window_sequence,
                      int window_shape,
                      int prev_window_shape,
                      Ipp32s* p_out_spectrum)
{
  Ipp32s mdct_in[N_LONG];
  Ipp32s *window_table_long, *prev_window_table_long;
  Ipp32s *window_table_short, *prev_window_table_short;

  if (0 == window_shape) {
    window_table_long  = SIN_longInt;
    window_table_short = SIN_shortInt;
  } else {
      window_table_long  = KBD_longInt;
      window_table_short = KBD_shortInt;
  }

  if (0 == prev_window_shape) {
      prev_window_table_long  = SIN_longInt;
      prev_window_table_short = SIN_shortInt;
  } else {
      prev_window_table_long  = KBD_longInt;
      prev_window_table_short = KBD_shortInt;
  }

  switch(window_sequence)
  {
  case ONLY_LONG_SEQUENCE:
    ippsMul_32s_Sfs(p_in_samples_1st_part, prev_window_table_long,
                    mdct_in, N_LONG/2, 31);

    ippsMul_32s_Sfs(p_in_samples_2nd_part,
                    &window_table_long[N_LONG/2],
                    &mdct_in[N_LONG/2], N_LONG/2, 31);

    ippsMDCTFwd_32s_Sfs(mdct_in, p_out_spectrum, p_data->p_mdct_fwd_long,
                        12, p_data->p_buffer_fwd);
    break;
  case LONG_START_SEQUENCE:
    ippsMul_32s_Sfs(p_in_samples_1st_part, prev_window_table_long,
                    mdct_in, N_LONG/2, 31);

    ippsCopy_32s(p_in_samples_2nd_part, &mdct_in[1024], 1472-1024);

    ippsMul_32s_Sfs(&p_in_samples_2nd_part[1472-1024],
                    &window_table_short[N_SHORT/2],
                    &mdct_in[1472], 1600-1472, 31);

    ippsZero_32s(&mdct_in[1600], (2048-1600));

    ippsMDCTFwd_32s_Sfs(mdct_in, p_out_spectrum, p_data->p_mdct_fwd_long,
                        12, p_data->p_buffer_fwd);
    break;
  case LONG_STOP_SEQUENCE:
    ippsZero_32s(mdct_in, 448);

    ippsMul_32s_Sfs(&p_in_samples_1st_part[448], prev_window_table_short,
                    &mdct_in[448], 576-448, 31);

    ippsCopy_32s(&p_in_samples_1st_part[576], &mdct_in[576], 1024-576);

    ippsMul_32s_Sfs(p_in_samples_2nd_part,
                    &window_table_long[N_LONG/2],
                    &mdct_in[N_LONG/2], N_LONG/2, 31);

    ippsMDCTFwd_32s_Sfs(mdct_in, p_out_spectrum, p_data->p_mdct_fwd_long,
                        12, p_data->p_buffer_fwd);
    break;
  case EIGHT_SHORT_SEQUENCE:
    ippsMul_32s_Sfs(&p_in_samples_1st_part[0], prev_window_table_short,
                    &mdct_in[0], N_SHORT/2, 31);
    ippsMul_32s_Sfs(&p_in_samples_1st_part[128], &window_table_short[N_SHORT/2],
                    &mdct_in[N_SHORT/2], N_SHORT/2, 31);

    ippsMDCTFwd_32s_Sfs(mdct_in,
                        p_out_spectrum,
                        p_data->p_mdct_fwd_short,
                        9, p_data->p_buffer_fwd);
    break;
  default:
    break;
  }
}

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