aac_enc_psychoacoustic_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) 2004-2005 Intel Corporation. All Rights Reserved.
//
//     Intel Integrated Performance Primitives AAC Encode Sample for Windows*
//
//  By downloading and installing this sample, you hereby agree that the
//  accompanying Materials are being provided to you under the terms and
//  conditions of the End User License Agreement for the Intel Integrated
//  Performance Primitives product previously accepted by you. Please refer
//  to the file ipplic.htm located in the root directory of your Intel IPP
//  product installation for more information.
//
//  MPEG-4 and AAC are international standards promoted by ISO, IEC, ITU, ETSI
//  and other organizations. Implementations of these standards, or the standard
//  enabled platforms may require licenses from various entities, including
//  Intel Corporation.
//
*/

#include <stdio.h>
#include <math.h>
#include "ipps.h"
#include "ippac.h"
#include "aac_enc_psychoacoustic_int.h"
#include "aac_sfb_tables.h"

#define FIND_NORM_SHIFT_16S(pSrc, len, shift) \
{                                             \
  Ipp16s _min0, _max0;                        \
  int    _min, _max;                          \
                                              \
  ippsMinMax_16s(pSrc, len, &_min0, &_max0);  \
                                              \
  _min = -((int)_min0);                       \
  _max = _max0;                               \
                                              \
  if (_min > _max) {                          \
    _max = _min - 1;                          \
  }                                           \
                                              \
  shift = 0;                                  \
                                              \
  if (_max > 0) {                             \
    while (_max <= 16384) {                   \
      _max = _max << 1;                       \
      shift++;                                \
    }                                         \
  }                                           \
}

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

#ifdef SMR_IS_USED

void psy_smr(sPsychoacousticBlock* pBlock,
             sPsychoacousticBlockCom* pBlockCom,
             Ipp32s* rsqr_long,
             Ipp32s  rsqr_longScale,
             Ipp32s* rsqr_short,
             Ipp32s* rsqr_shortScale)
/* Calculate the signal-to-mask ratio, SMR(n) and the codec threshold xmin(n) */
/* r- represents the magnitude, f - represent the phase */
{
  Ipp32s thr[((MAX_PPT_LONG > MAX_PPT_SHORT) ? MAX_PPT_LONG : MAX_PPT_SHORT)];
  Ipp32s tmp_thr[1024];
  Ipp32s epart[MAX_SFB];
  Ipp32s npart[MAX_SFB];
  Ipp32s minthr[MAX_SFB];
  Ipp32s *rsqr;
  Ipp32s *smr;
  int b, n, win_counter, max;

  ////////  Long window processing /////////
  smr = (Ipp32s*)pBlock->smr_long[pBlock->nb_curr_index];

  ippsMul_32s_Sfs(pBlock->w_width_long_inv,
                  pBlock->nb_long[pBlock->nb_curr_index],
                  thr, pBlock->num_ptt_long, 15);

  for (b = 0; b < pBlock->num_ptt_long; b++) {
    ippsSet_32s(thr[b], &tmp_thr[pBlock->w_low_long[b]],
                pBlock->w_width_long[b]);
  }

  for (n = 0;  n < pBlock->num_sfb_long; n++) {
    int start = pBlock->sfb_offset_long[n];
    int len = pBlock->sfb_width_long[n];

    ippsSum_32s_Sfs(&rsqr_long[start], len, &epart[n],
                    pBlock->sfb_width_longScale - 1);

    ippsMinMax_32s(&tmp_thr[start], pBlock->sfb_width_long[n],
                   &minthr[n], &max);
  }

  ippsMul_32s_Sfs(minthr, pBlock->sfb_width_long, npart,
                  pBlock->num_sfb_long, pBlock->sfb_width_longScale);
  /* Q31 */
  ippsDiv_32s_Sfs(epart, npart, smr, pBlock->num_sfb_long,
                  31 - rsqr_longScale + 1 - pBlock->nb_longScaleFactor);

  ////////  Short windows processing /////////
  smr = (Ipp32s*)pBlock->smr_short[pBlock->nb_curr_index];
  rsqr = rsqr_short;

  for (win_counter = 0; win_counter < 8; win_counter++) {
    ippsMul_32s_Sfs(pBlock->w_width_short_inv,
                    pBlock->nb_short[pBlock->nb_curr_index][win_counter],
                    thr, pBlock->num_ptt_short, 15);

    for (b = 0; b < pBlock->num_ptt_short; b++) {
      ippsSet_32s(thr[b], &tmp_thr[pBlock->w_low_short[b]],
                  pBlock->w_width_short[b]);
    }

    for (n = 0;  n < pBlock->num_sfb_short; n++) {
      int start = pBlock->sfb_offset_short[n];
      int len = pBlock->sfb_width_short[n];

      ippsSum_32s_Sfs(&rsqr[start], len, &epart[n],
                      pBlock->sfb_width_shortScale - 1);

      ippsMinMax_32s(&tmp_thr[start], pBlock->sfb_width_short[n],
                     &minthr[n], &max);
    }

    ippsMul_32s_Sfs(minthr, pBlock->sfb_width_short, npart,
                    pBlock->num_sfb_short, pBlock->sfb_width_shortScale);
    /* Q31 */
    ippsDiv_32s_Sfs(epart, npart, smr, pBlock->num_sfb_short,
                    31 - rsqr_shortScale[win_counter] + 1 -
                    pBlock->nb_shortScaleFactor[win_counter]);

    rsqr += 128;
  }
}

#endif

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

void psy_long_window(sPsychoacousticBlock* pBlock,
                     sPsychoacousticBlockCom* pBlockCom,
                     Ipp32s* rsqr_long,
                     Ipp32s* rsqr_longScale)
{
__ALIGN Ipp16s  sw[N_LONG];
__ALIGN Ipp16s  abs_sw[N_LONG];
__ALIGN Ipp16s  fft_line[N_LONG+2];
__ALIGN Ipp16sc fft_unpack[2*N_LONG];
__ALIGN Ipp32s  e_b[MAX_PPT_LONG];
__ALIGN Ipp32s  c_b[MAX_PPT_LONG];
__ALIGN Ipp32s  ecb[MAX_PPT_LONG];
__ALIGN Ipp32s  ct[MAX_PPT_LONG];
__ALIGN Ipp32s  tmp_ecb[MAX_PPT_LONG];
__ALIGN Ipp32s  tmp_ct[MAX_PPT_LONG];
__ALIGN Ipp32s  ecb_h_limit[MAX_PPT_LONG];
__ALIGN Ipp32s  ecb_l_limit[MAX_PPT_LONG];
__ALIGN Ipp32s  ltmp0[MAX_PPT_LONG];
__ALIGN Ipp16s  c_w[1024];
__ALIGN Ipp16s  tmp_ln[MAX_PPT_LONG];
__ALIGN Ipp16s  tmp_ln0[MAX_PPT_LONG];
__ALIGN Ipp16s  tmp_ln1[MAX_PPT_LONG];
__ALIGN Ipp16s  tmp[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  tmp0[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  tmp1[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  tmp2[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  tmp3[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  tmp4[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  tmp5[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  denum[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  r_pred[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  re_pred[NUM_UNPRED_LINES_LONG];
__ALIGN Ipp16s  im_pred[NUM_UNPRED_LINES_LONG];
  Ipp16s        *r, *r_prev, *r_prev_prev;
  Ipp16s        *re, *re_prev, *re_prev_prev;
  Ipp16s        *im, *im_prev, *im_prev_prev;
  Ipp16s        *tmp_dst[2];
  Ipp32s        *nb,*nb_l;
  int           b, scaleFactor;
  Ipp32s        sum;
  int           shift0, shift1, shift;
  int           rScaleFactor, r_prevScaleFactor;
  int           r_prev_prevScaleFactor, r_predScaleFactor;
  int           nb_ScaleFactor, nb_lScaleFactor;
  int           num_ptt_long = pBlockCom->longWindow->num_ptt;

  ippsMul_16s_Sfs((Ipp16s*)pBlockCom->input_data[0], AAC_HANN_long,
                   sw, pBlockCom->iblen_long, 15);
  ippsMul_16s_Sfs((Ipp16s*)pBlockCom->input_data[1],
                   &AAC_HANN_long[pBlockCom->iblen_long],
                   &sw[1024], pBlockCom->iblen_long, 15);
  ippsAbs_16s(sw, abs_sw, 2 * pBlockCom->iblen_long);
  ippsSum_16s32s_Sfs(abs_sw, 2 * pBlockCom->iblen_long, &sum, 0);

  scaleFactor = 0;
  if (sum != 0) {
    if (sum > 32768) {
      while (sum > 32768) {
        sum >>= 1;
        scaleFactor++;
      }
    } else {
      while (sum <= 16384) {
        sum *= 2;
        scaleFactor--;
      }
    }
  }

  ippsFFTFwd_RToCCS_16s_Sfs(sw, fft_line, pBlockCom->pFFTSpecLong,
                            scaleFactor, pBlockCom->pBuffer);

  ippsConjCcs_16sc(fft_line, fft_unpack, 2 * pBlockCom->iblen_long);

  r            = (Ipp16s*)pBlock->r[pBlockCom->current_f_r_index];
  re           = (Ipp16s*)pBlock->re[pBlockCom->current_f_r_index];
  im           = (Ipp16s*)pBlock->im[pBlockCom->current_f_r_index];

  ippsMagnitude_16sc_Sfs(fft_unpack, r, pBlockCom->iblen_long, 1);
  ippsThreshold_LT_16s_I(r, pBlockCom->iblen_long, 1);

  tmp_dst[0] = re;
  tmp_dst[1] = im;

  ippsDeinterleave_16s(fft_line, 2, NUM_UNPRED_LINES_LONG, tmp_dst);
  ippsDiv_16s_ISfs(r, re, NUM_UNPRED_LINES_LONG, -14);
  ippsDiv_16s_ISfs(r, im, NUM_UNPRED_LINES_LONG, -14);

  FIND_NORM_SHIFT_16S(r, pBlockCom->iblen_long, shift)
  ippsLShiftC_16s_I(shift, r, pBlockCom->iblen_long);
  rScaleFactor = scaleFactor + 1 - shift;

  pBlock->rScaleFactor[pBlockCom->current_f_r_index] = rScaleFactor;

  r_prev       = (Ipp16s*)pBlock->r[pBlockCom->prev_f_r_index];
  re_prev      = (Ipp16s*)pBlock->re[pBlockCom->prev_f_r_index];
  im_prev      = (Ipp16s*)pBlock->im[pBlockCom->prev_f_r_index];

  r_prevScaleFactor = pBlock->rScaleFactor[pBlockCom->prev_f_r_index];

  r_prev_prev  = (Ipp16s*)pBlock->r[pBlockCom->prev_prev_f_r_index];
  re_prev_prev = (Ipp16s*)pBlock->re[pBlockCom->prev_prev_f_r_index];
  im_prev_prev = (Ipp16s*)pBlock->im[pBlockCom->prev_prev_f_r_index];

  r_prev_prevScaleFactor = pBlock->rScaleFactor[pBlockCom->prev_prev_f_r_index];

  /* Calculate the unpredictebility measure c(w)                */
  /* Some transformations:                                      */
  /* re((2*r_prev-r_prev_prev)*exp(-j(2*f_prev-f_prev_prev))) = */
  /* (2*r_prev-r_prev_prev)*                                    */
  /* (2*im_prev_prev*re_prev*im_prev +                          */
  /* re_prev_prev*(re_prev*re_prev-im_prev*im_prev))            */
  /*                                                            */
  /* im((2*r_prev-r_prev_prev)*exp(-j(2*f_prev-f_prev_prev))) = */
  /* (2*r_prev-r_prev_prev) *                                   */
  /* (2*re_prev_prev*re_prev*im_prev -                          */
  /* im_prev_prev*(re_prev*re_prev-im_prev*im_prev))            */
  /*                                                            */
  /* where re_prev_prev = cos(prev_prev_f),                     */
  /*       im_prev_prev = sin(prev_prev_f),                     */
  /*       re_prev = cos(prev_prev_f),                          */
  /*       im_prev = sin(prev_prev_f)                           */

  /* r_pred = (2*r_prev-r_prev_prev) */
  r_predScaleFactor = r_prevScaleFactor + 1;
  if (r_prev_prevScaleFactor > r_predScaleFactor) {
    shift = r_prev_prevScaleFactor - r_predScaleFactor;
    if (shift > 16) shift = 16;
    ippsRShiftC_16s(r_prev, shift, tmp0, NUM_UNPRED_LINES_LONG);
    ippsSub_16s_Sfs(r_prev_prev, tmp0, r_pred, NUM_UNPRED_LINES_LONG, 1);
    r_predScaleFactor = r_prev_prevScaleFactor + 1;
  } else if (r_prev_prevScaleFactor < r_predScaleFactor) {
    shift = r_predScaleFactor - r_prev_prevScaleFactor;
    if (shift > 16) shift = 16;
    ippsRShiftC_16s(r_prev_prev, shift, tmp0,NUM_UNPRED_LINES_LONG);
    ippsSub_16s_Sfs(tmp0, r_prev, r_pred, NUM_UNPRED_LINES_LONG, 1);
    r_predScaleFactor++;
  } else {
    ippsSub_16s_Sfs(r_prev_prev, r_prev, r_pred, NUM_UNPRED_LINES_LONG, 1);
    r_predScaleFactor++;
  }

  /* tmp1 = 2*re_prev*im_prev */
  ippsMul_16s_Sfs(re_prev, im_prev, tmp1, NUM_UNPRED_LINES_LONG, 15);

  /* tmp2 = re_prev*re_prev-im_prev*im_prev */
  ippsMul_16s_Sfs(re_prev, re_prev, tmp2, NUM_UNPRED_LINES_LONG, 15);
  ippsMul_16s_Sfs(im_prev, im_prev, tmp, NUM_UNPRED_LINES_LONG, 15);
  ippsSub_16s_ISfs(tmp, tmp2,  NUM_UNPRED_LINES_LONG, 1);

  /* im_prev_prev * tmp1 + re_prev_prev * tmp2 */
  ippsMul_16s_Sfs(im_prev_prev, tmp1, re_pred, NUM_UNPRED_LINES_LONG, 15);
  ippsMul_16s_Sfs(re_prev_prev, tmp2, tmp, NUM_UNPRED_LINES_LONG, 15);
  ippsAdd_16s_ISfs(tmp, re_pred, NUM_UNPRED_LINES_LONG, 1);

  /* re_prev_prev * tmp1 - im_prev_prev * tmp2 */
  ippsMul_16s_Sfs(re_prev_prev, tmp1, im_pred, NUM_UNPRED_LINES_LONG, 15);
  ippsMul_16s_Sfs(im_prev_prev, tmp2, tmp, NUM_UNPRED_LINES_LONG, 15);
  ippsSub_16s_ISfs(tmp, im_pred, NUM_UNPRED_LINES_LONG, 1);

  ippsAbs_16s(r_pred, denum,  NUM_UNPRED_LINES_LONG);

  if (r_predScaleFactor > rScaleFactor) {
    shift0 = 0;
    shift1 = r_predScaleFactor - rScaleFactor;
    if (shift > 16) shift1 = 16;
    ippsRShiftC_16s(r, shift1, tmp0, NUM_UNPRED_LINES_LONG);
    ippsAdd_16s_ISfs(tmp0, denum, NUM_UNPRED_LINES_LONG, 1);
  } else if (r_predScaleFactor < rScaleFactor) {
    shift0 = rScaleFactor - r_predScaleFactor;
    shift1 = 0;
    if (shift0 > 16) shift0 = 16;
    ippsRShiftC_16s(denum, shift0, tmp0, NUM_UNPRED_LINES_LONG);
    ippsAdd_16s_Sfs(r, tmp0, denum, NUM_UNPRED_LINES_LONG, 1);
  } else {
    shift0 = 0;
    shift1 = 0;
    ippsAdd_16s_ISfs(r, denum, NUM_UNPRED_LINES_LONG, 1);
  }

  ippsDiv_16s_Sfs(denum, r_pred, tmp0, NUM_UNPRED_LINES_LONG, -14 + shift0);
  ippsDiv_16s_Sfs(denum, r, tmp1, NUM_UNPRED_LINES_LONG, -14 + shift1);

  ippsMul_16s_Sfs(tmp0, re_pred, tmp2, NUM_UNPRED_LINES_LONG, 15);
  ippsMul_16s_Sfs(tmp0, im_pred, tmp3, NUM_UNPRED_LINES_LONG, 15);
  ippsMul_16s_Sfs(tmp1, re, tmp4, NUM_UNPRED_LINES_LONG, 17);
  ippsMul_16s_Sfs(tmp1, im, tmp5, NUM_UNPRED_LINES_LONG, 17);