aac_enc_psychoacoustic_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) 2003-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_fp.h"
#include "aac_sfb_tables.h"
#include "align.h"

#define MIN(a,b)    (((a) < (b)) ? (a) : (b))

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

float sprdngf(float b1,
              float b2)
{
  float tmpx,tmpy,tmpz;

  tmpx = (b2 >= b1) ? 3*(b2-b1) : 1.5f*(b2-b1);

  tmpz = 8 * MIN((tmpx-0.5f)*(tmpx-0.5f) - 2*(tmpx-0.5f), 0);

  tmpy = 15.811389f + 7.5f*(tmpx + 0.474f)-
         17.5f*(float)sqrt(1 + (tmpx+0.474f)*(tmpx+0.474f));

  return (tmpy < -100 ? 0 : (float)pow(10,(float)(tmpz + tmpy)/10));
}

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

#ifdef SMR_IS_USED

void psy_smr(sPsychoacousticBlock* pBlock,
             sPsychoacousticBlockCom* pBlockCom,
             Ipp32f* rsqr_long,
             Ipp32f* rsqr_short)
/* Calculate the signal-to-mask ratio, SMR(n) and the codec threshold xmin(n) */
/* r- represents the magnitude, f - represent the phase */
{
  Ipp32f thr[MAX_PPT_LONG];
  Ipp32f tmp_thr[1024];
  Ipp32f epart[MAX_SFB];
  Ipp32f npart[MAX_SFB];
  Ipp32f minthr[MAX_SFB];
  Ipp32f buflen[MAX_SFB];
  Ipp32f *rsqr;
  Ipp32f *smr;
  int    *sfb_offset;
  int b, n, win_counter;
  int num_ptt_long = pBlockCom->longWindow->num_ptt;
  int num_ptt_short = pBlockCom->shortWindow->num_ptt;

  ////////  Long window processing /////////

  sfb_offset = pBlockCom->sfb_offset_long;
  smr = (Ipp32f*)pBlock->smr_long[pBlockCom->nb_curr_index];
  rsqr = rsqr_long;

  ippsDiv_32f((Ipp32f*)pBlockCom->longWindow->w_width,
              (Ipp32f*)pBlock->nb_long[pBlockCom->nb_curr_index],
              thr, num_ptt_long);

  for (b = 0; b < num_ptt_long; b++) {
    ippsSet_32f(thr[b], &tmp_thr[pBlockCom->longWindow->w_low[b]],
      pBlockCom->longWindow->w_high[b] - pBlockCom->longWindow->w_low[b] + 1);
  }

  for (n = 0;  n < pBlockCom->num_sfb_long; n++) {
    int start = sfb_offset[n];
    int len = sfb_offset[n + 1] - sfb_offset[n];

    buflen[n] = (Ipp32f)len;
    ippsSum_32f(&rsqr[start], len, &epart[n], ippAlgHintNone);
    ippsMin_32f(&rsqr[start], len, &minthr[n]);
  }

  ippsMul_32f(minthr, buflen, npart, pBlockCom->num_sfb_long);
  ippsDiv_32f(npart, epart, smr, pBlockCom->num_sfb_long);

  ////////  Short windows processing /////////

  sfb_offset = pBlockCom->sfb_offset_short;
  smr = (Ipp32f*)pBlock->smr_short[pBlockCom->nb_curr_index];
  rsqr = rsqr_short;

  for (win_counter = 0; win_counter < 8; win_counter++) {
    ippsDiv_32f((Ipp32f*)pBlockCom->shortWindow->w_width,
                (Ipp32f*)pBlock->nb_short[pBlockCom->nb_curr_index][win_counter],
                thr, num_ptt_long);

    for (b = 0; b < num_ptt_short; b++) {
      ippsSet_32f(thr[b], &tmp_thr[pBlockCom->shortWindow->w_low[b]],
        pBlockCom->shortWindow->w_high[b] - pBlockCom->shortWindow->w_low[b] + 1);
    }

    for (n = 0;  n < pBlockCom->num_sfb_short; n++) {
      int start = sfb_offset[n];
      int len = sfb_offset[n + 1] - sfb_offset[n];

      buflen[n] = (Ipp32f)len;
      ippsSum_32f(&rsqr[start], len, &epart[n], ippAlgHintNone);
      ippsMin_32f(&rsqr[start], len, &minthr[n]);
    }

    ippsMul_32f(minthr, buflen, npart, pBlockCom->num_sfb_short);
    ippsDiv_32f(npart, epart, smr, pBlockCom->num_sfb_short);

    rsqr += 128;
  }
}

#endif

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

void psy_long_window(sPsychoacousticBlock* pBlock,
                     sPsychoacousticBlockCom* pBlockCom,
                     Ipp32f* rsqr_long)
{
__ALIGN Ipp32f  sw[1024*2];
__ALIGN Ipp32f  fft_line[2*1024+2];
  Ipp32f        c_w[1024];
  Ipp32f        e_b[MAX_PPT_LONG];
  Ipp32f        c_b[MAX_PPT_LONG];
  Ipp32f        ecb[MAX_PPT_LONG];
  Ipp32f        ct[MAX_PPT_LONG];
  Ipp32f        tmp_ecb[MAX_PPT_LONG];
  Ipp32f        tmp_ct[MAX_PPT_LONG];
  Ipp32f        cb[MAX_PPT_LONG];
  Ipp32f        ecb_h_limit[MAX_PPT_LONG];
  Ipp32f        ecb_l_limit[MAX_PPT_LONG];
  Ipp32f        tmp[NUM_UNPRED_LINES_LONG];
  Ipp32f        tmp0[NUM_UNPRED_LINES_LONG];
  Ipp32f        tmp1[NUM_UNPRED_LINES_LONG];
  Ipp32f        tmp2[NUM_UNPRED_LINES_LONG];
  Ipp32f        num[NUM_UNPRED_LINES_LONG];
  Ipp32f        denum[NUM_UNPRED_LINES_LONG];
  Ipp32f        r_pred[NUM_UNPRED_LINES_LONG];
  Ipp32f        re_pred[NUM_UNPRED_LINES_LONG];
  Ipp32f        im_pred[NUM_UNPRED_LINES_LONG];
  Ipp32f        *r, *r_prev, *r_prev_prev;
  Ipp32f        *re, *re_prev, *re_prev_prev;
  Ipp32f        *im, *im_prev, *im_prev_prev;
  Ipp32f        *tmp_dst[2];
  float         *nb,*nb_l;
  int           b, num_ptt;

  ippsMul_32f((Ipp32f*)pBlockCom->input_data[0],
               (Ipp32f*)pBlockCom->hann_window_long,
               sw, pBlockCom->iblen_long);
  ippsMul_32f((Ipp32f*)pBlockCom->input_data[1],
              (Ipp32f*)&pBlockCom->hann_window_long[1024],
               &sw[1024], pBlockCom->iblen_long);

  ippsFFTFwd_RToCCS_32f(sw, fft_line, pBlockCom->pFFTSpecLong, pBlockCom->pBuffer);

  r            = (Ipp32f*)pBlock->r[pBlockCom->current_f_r_index];
  r_prev       = (Ipp32f*)pBlock->r[pBlockCom->prev_f_r_index];
  r_prev_prev  = (Ipp32f*)pBlock->r[pBlockCom->prev_prev_f_r_index];

  re           = (Ipp32f*)pBlock->re[pBlockCom->current_f_r_index];
  re_prev      = (Ipp32f*)pBlock->re[pBlockCom->prev_f_r_index];
  re_prev_prev = (Ipp32f*)pBlock->re[pBlockCom->prev_prev_f_r_index];

  im           = (Ipp32f*)pBlock->im[pBlockCom->current_f_r_index];
  im_prev      = (Ipp32f*)pBlock->im[pBlockCom->prev_f_r_index];
  im_prev_prev = (Ipp32f*)pBlock->im[pBlockCom->prev_prev_f_r_index];

  ippsMagnitude_32fc((Ipp32fc*)fft_line, (Ipp32f*)r, pBlockCom->iblen_long);
  ippsThreshold_LT_32f_I((Ipp32f*)r, pBlockCom->iblen_long, 1);

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

  /* 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)/(r_prev*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)/(r_prev*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 = prev_prev_r*cos(prev_prev_f),         */
  /*       im_prev_prev = prev_prev_r*sin(prev_prev_f),         */
  /*       re_prev = prev_r*cos(prev_prev_f),                   */
  /*       im_prev = prev_r*sin(prev_prev_f)                    */

  ippsDeinterleave_32f(fft_line, 2,  NUM_UNPRED_LINES_LONG, tmp_dst);

  /* tmp0 = (2*r_prev-r_prev_prev)/(r_prev*r_prev*r_prev_prev) */
  ippsMulC_32f(r_prev, (Ipp32f)2, r_pred,  NUM_UNPRED_LINES_LONG);
  ippsSub_32f_I(r_prev_prev, r_pred,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f(r_prev, r_prev, denum,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f_I(r_prev_prev, denum,  NUM_UNPRED_LINES_LONG);
  ippsDiv_32f(denum, r_pred, tmp0,  NUM_UNPRED_LINES_LONG);

  /* tmp1 = 2*re_prev*im_prev */
  ippsMulC_32f(re_prev, (Ipp32f)2, tmp1,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f_I(im_prev, tmp1,  NUM_UNPRED_LINES_LONG);

  /* tmp2 = re_prev*re_prev-im_prev*im_prev */
  ippsMul_32f(re_prev, re_prev, tmp,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f(im_prev, im_prev, tmp2,  NUM_UNPRED_LINES_LONG);
  ippsSub_32f_I(tmp, tmp2,  NUM_UNPRED_LINES_LONG);

  ippsMul_32f(im_prev_prev, tmp1, re_pred,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f(re_prev_prev, tmp2, tmp,  NUM_UNPRED_LINES_LONG);
  ippsAdd_32f_I(tmp, re_pred,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f_I(tmp0, re_pred,  NUM_UNPRED_LINES_LONG);

  ippsMul_32f(re_prev_prev, tmp1, im_pred,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f(im_prev_prev, tmp2, tmp,  NUM_UNPRED_LINES_LONG);
  ippsSub_32f_I(tmp, im_pred,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f_I(tmp0, im_pred,  NUM_UNPRED_LINES_LONG);

  ippsSub_32f(re, re_pred, tmp0,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f_I(tmp0, tmp0,  NUM_UNPRED_LINES_LONG);

  ippsSub_32f(im, im_pred, tmp1,  NUM_UNPRED_LINES_LONG);
  ippsMul_32f_I(tmp1, tmp1,  NUM_UNPRED_LINES_LONG);

  ippsAdd_32f(tmp0, tmp1, num,  NUM_UNPRED_LINES_LONG);
  ippsSqrt_32f_I(num,  NUM_UNPRED_LINES_LONG);

  ippsAbs_32f(r_pred, denum,  NUM_UNPRED_LINES_LONG);
  ippsAdd_32f_I(r, denum,  NUM_UNPRED_LINES_LONG);

  ippsDiv_32f(denum, num, c_w,  NUM_UNPRED_LINES_LONG);

  ippsSet_32f((Ipp32f)0.4, &c_w[ NUM_UNPRED_LINES_LONG],
               1024 -  NUM_UNPRED_LINES_LONG);

  ippsSqr_32f((Ipp32f*)r, rsqr_long, 1024);

  num_ptt = pBlockCom->longWindow->num_ptt;

  for (b = 0; b < num_ptt; b++) {
    int w_high = pBlockCom->longWindow->w_high[b];
    int w_low = pBlockCom->longWindow->w_low[b];
    Ipp32f *tmp_rsqr = &rsqr_long[w_low];
    Ipp32f *tmp_c_w = (Ipp32f*)&c_w[w_low];
    int len = w_high - w_low + 1;

    ippsSum_32f(tmp_rsqr, len, &e_b[b], ippAlgHintNone);
    ippsDotProd_32f(tmp_rsqr, tmp_c_w, len, &c_b[b]);
  }

  nb   = pBlock->nb_long[pBlockCom->nb_curr_index];
  nb_l = pBlock->nb_long[pBlockCom->nb_prev_index];

  pBlock->next_frame_PE = 0;

  for (b = 0; b < num_ptt; b++) {
    Ipp32f *tmp_ptr = (Ipp32f*)pBlockCom->sprdngf_long + b * num_ptt;

    ippsDotProd_32f(e_b, tmp_ptr, num_ptt, &ecb[b]);
    ippsDotProd_32f(c_b, tmp_ptr, num_ptt, &ct[b]);
  }

  ippsMulC_32f(ecb, (Ipp32f)0.00964116, tmp_ecb, num_ptt);
  ippsMulC_32f(ct, (Ipp32f)0.52280978, tmp_ct, num_ptt);

  ippsAdd_32f(tmp_ct, tmp_ecb, cb, num_ptt);

  ippsMulC_32f(ecb, (Ipp32f)0.25118864, ecb_h_limit, num_ptt);
  ippsMulC_32f(ecb, (Ipp32f)0.0158489, ecb_l_limit, num_ptt);
  ippsMaxEvery_32f_I(ecb_l_limit, cb, num_ptt);
  ippsMinEvery_32f_I(ecb_h_limit, cb, num_ptt);
  ippsMul_32f((Ipp32f*)pBlockCom->rnorm_long, cb,
              (Ipp32f*)nb, num_ptt);

  /* instead of nb[b] = MAX( pow(10.0,pBlock->qsthr_long[b]/10.0)/32767.0, */
  /*                         MIN(nb[b],2.0*nb_l[b]));                      */
  /* we use only nb[b] = MIN(nb[b],2.0*nb_l[b]) yet                        */

  ippsMulC_32f_I(2, (Ipp32f*)nb_l, num_ptt);
  ippsMinEvery_32f_I((Ipp32f*)nb_l, (Ipp32f*)nb, num_ptt);

  for (b = 0; b < num_ptt; b++) {
    pBlock->next_frame_PE -=
      (float)(pBlockCom->longWindow->w_width[b] * log10(nb[b] / e_b[b]));
  }
}

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

void psy_short_window(sPsychoacousticBlock* pBlock,
                      sPsychoacousticBlockCom* pBlockCom,
                      Ipp32f *s_en,
                      Ipp32f* rsqr_short)
{
__ALIGN float   sw_short[8][__ALIGNED(256)];
__ALIGN Ipp32f  fft_line[2*128+2];
  Ipp32f        *ptr_input_data;
  float         *r;
  int           win_counter;
#ifdef SMR_IS_USED
  float         c_w[128];
  Ipp32f        e_b[MAX_PPT_LONG];
  Ipp32f        c_b[MAX_PPT_LONG];
  Ipp32f        ecb[MAX_PPT_LONG];
  Ipp32f        ct[MAX_PPT_LONG];
  Ipp32f        tmp_ecb[MAX_PPT_LONG];
  Ipp32f        tmp_ct[MAX_PPT_LONG];
  Ipp32f        cb[MAX_PPT_LONG];
  Ipp32f        ecb_h_limit[MAX_PPT_LONG];
  Ipp32f        ecb_l_limit[MAX_PPT_LONG];
  Ipp32f        tmp[128];
  Ipp32f        tmp0[128];
  Ipp32f        tmp1[128];
  Ipp32f        tmp2[128];
  Ipp32f        num[128];
  Ipp32f        denum[128];
  Ipp32f        r_pred[128];
  Ipp32f        re_pred[128];
  Ipp32f        im_pred[128];
  Ipp32f        *r_prev, *r_prev_prev;
  Ipp32f        *re, *re_prev, *re_prev_prev;
  Ipp32f        *im, *im_prev, *im_prev_prev;
  Ipp32f        *rsqr;
  Ipp32f        *tmp_dst[2];
  float         *nb,*nb_l;
  int           b, num_ptt;
#endif

  ptr_input_data = (Ipp32f*)pBlockCom->input_data[0] + 448;

  for (win_counter = 0; win_counter < 3; win_counter++) {
    ippsMul_32f(ptr_input_data, (Ipp32f*)pBlockCom->hann_window_short,
                (Ipp32f*)sw_short[win_counter], 2 * pBlockCom->iblen_short);
    ptr_input_data += pBlockCom->iblen_short;
  }