mp3enc_psychoacoustic_fp.cpp

这是在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 "umc_mp3_encoder.h"

namespace UMC {

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

const int mp3enc_pa_numlines_l[3][CBANDS_l] = {
    {
        1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   2,   2,   2,
        2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   3,   3,   3,   3,   3,   3,   3,   4,
        4,   4,   5,   5,   5,   6,   6,   7,   7,   7,   9,   9,   9,  10,  10,  11,  14,  14,
        15,  20,  20,  21,  27,  27,  36,  73,  18, /* {47,*/
    },
    {
        1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   2,   2,
        2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   3,   3,   3,   3,   3,   4,   4,
        4,   4,   4,   5,   5,   5,   6,   7,   7,   8,   8,   8,  10,  10,  10,  13,  13,  14,
        18,  18, 20,  25,  25,  35,  67,  67,
    },
    {
        2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
        3,   3,   3,   3,   3,   3,   3,   3,   3,   4,   4,   4,   5,   5,   5,   5,   5,   6,
        6,   6,   8,   8,   8,  10,  10,  10,  12,  12,  13,  14,  14,  16,  20,  20,  23,  27,
        27,  32,  37,  37,  12,  24,
    }
};

const float mp3enc_bval_l[3][CBANDS_l] = {
    {
        0.000f, 0.431f, 0.861f, 1.292f, 1.723f, 2.153f, 2.584f, 3.015f, 3.445f, 3.876f, 4.279f, 4.670f, 5.057f,
        5.416f, 5.774f, 6.422f, 7.026f, 7.609f, 8.168f, 8.710f, 9.207f, 9.662f, 10.099f, 10.515f, 10.917f, 11.293f,
        11.652f, 11.997f, 12.394f, 12.850f, 13.277f, 13.681f, 14.062f, 14.411f, 14.751f, 15.119f, 15.508f, 15.883f,
        16.263f, 16.654f, 17.020f, 17.374f, 17.744f, 18.104f, 18.447f, 18.782f, 19.130f, 19.487f, 19.838f, 20.179f,
        20.510f, 20.852f, 21.196f, 21.531f, 21.870f, 22.214f, 22.558f, 22.898f, 23.232f, 23.564f, 23.897f, 24.229f, 24.442f
    },
    {
        0.000f, 0.469f, 0.938f, 1.406f, 1.875f, 2.344f, 2.813f, 3.281f, 3.750f, 4.199f, 4.625f, 5.047f, 5.438f, 5.828f,
        6.188f, 6.522f, 7.174f, 7.801f, 8.402f, 8.966f, 9.484f, 9.966f, 10.426f, 10.866f, 11.279f, 11.669f, 12.042f,
        12.386f, 12.721f, 13.115f, 13.562f, 13.984f, 14.371f, 14.741f, 15.140f, 15.563f, 15.962f, 16.324f, 16.665f,
        17.020f, 17.373f, 17.708f, 18.045f, 18.398f, 18.762f, 19.120f, 19.466f, 19.807f, 20.159f, 20.522f, 20.874f,
        21.214f, 21.553f, 21.892f, 22.231f, 22.569f, 22.909f, 23.248f, 23.583f, 23.915f, 24.246f, 24.576f
    },
    {
        0.313f, 0.938f, 1.563f, 2.188f, 2.813f, 3.438f, 4.045f, 4.625f, 5.173f, 5.698f, 6.185f, 6.634f, 7.070f, 7.492f,
        7.905f, 8.305f, 8.695f, 9.064f, 9.484f, 9.966f, 10.426f, 10.866f, 11.279f, 11.669f, 12.042f, 12.386f, 12.721f,
        13.091f, 13.488f, 13.873f, 14.268f, 14.679f, 15.067f, 15.424f, 15.771f, 16.120f, 16.466f, 16.807f, 17.158f,
        17.518f, 17.869f, 18.215f, 18.563f, 18.902f, 19.239f, 19.580f, 19.925f, 20.269f, 20.606f, 20.944f, 21.288f,
        21.635f, 21.980f, 22.319f, 22.656f, 22.993f, 23.326f, 23.656f, 23.937f, 24.237f,
    }
};

static 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.0,(tmpz + tmpy)/10.0));
}

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

void MP3Encoder::psy_long_window(float *input_data,
                     float* rsqr_long, int ch)
{
  VM_ALIGN16_DECL(Ipp32f)  sw[1024];
  VM_ALIGN16_DECL(Ipp32f)  fft_line[2*512+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, index;
  int current_f_r_index, prev_f_r_index, prev_prev_f_r_index;

  ippsMul_32f(input_data, pa_hann_window_long,
               sw, pa_iblen_long * 2);

  ippsFFTFwd_RToCCS_32f(sw, fft_line, pa_pFFTSpecLong, pa_pBufferLong);

  current_f_r_index = pa_current_f_r_index[ch];
  prev_f_r_index = current_f_r_index - 1;
  if (prev_f_r_index < 0) prev_f_r_index = 2;
  prev_prev_f_r_index = prev_f_r_index - 1;
  if (prev_prev_f_r_index < 0) prev_prev_f_r_index = 2;

  r            = (Ipp32f*)pa_r[ch][current_f_r_index];
  r_prev       = (Ipp32f*)pa_r[ch][prev_f_r_index];
  r_prev_prev  = (Ipp32f*)pa_r[ch][prev_prev_f_r_index];

  re           = (Ipp32f*)pa_re[ch][current_f_r_index];
  re_prev      = (Ipp32f*)pa_re[ch][prev_f_r_index];
  re_prev_prev = (Ipp32f*)pa_re[ch][prev_prev_f_r_index];

  im           = (Ipp32f*)pa_im[ch][current_f_r_index];
  im_prev      = (Ipp32f*)pa_im[ch][prev_f_r_index];
  im_prev_prev = (Ipp32f*)pa_im[ch][prev_prev_f_r_index];

  ippsMagnitude_32fc((Ipp32fc *)fft_line, (Ipp32f*)r, 512);
  ippsThreshold_LT_32f_I((Ipp32f*)r, 512, 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],
               512 -  NUM_UNPRED_LINES_LONG);

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

  index = 0;

  for (b = 0; b < pa_num_ptt_long; b++) {
    Ipp32f *tmp_rsqr = &rsqr_long[index];
    Ipp32f *tmp_c_w = (Ipp32f*)&c_w[index];
    int len = mp3enc_pa_numlines_l[header.samplingFreq][b];

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

  nb   = pa_nb_long[ch][pa_nb_curr_index[ch]];
  nb_l = pa_nb_long[ch][pa_nb_prev_index[ch]];