mp3enc_psychoacoustic_int.cpp

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

    } else {
      while (sum <= 16383) {
        sum *= 2;
        scaleFactor--;
      }
    }
  }

  ippsFFTFwd_RToCCS_16s_Sfs(sw, fft_line, ipa_pFFTSpecLong,
                            scaleFactor, ipa_pBuffer);

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

  r            = (Ipp16s*)ipa_r[ch][current_f_r_index];
  re           = (Ipp16s*)ipa_re[ch][current_f_r_index];
  im           = (Ipp16s*)ipa_im[ch][current_f_r_index];

  ippsMagnitude_16sc_Sfs((Ipp16sc *)fft_line, r, pa_iblen_long, 1);
  ippsThreshold_LT_16s_I(r, pa_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, pa_iblen_long, shift)
  ippsLShiftC_16s_I(shift, r, pa_iblen_long);
  rScaleFactor = scaleFactor + 1 - shift;

  ipa_rScaleFactor[ch][current_f_r_index] = rScaleFactor;

  r_prev       = (Ipp16s*)ipa_r[ch][prev_f_r_index];
  re_prev      = (Ipp16s*)ipa_re[ch][prev_f_r_index];
  im_prev      = (Ipp16s*)ipa_im[ch][prev_f_r_index];

  r_prevScaleFactor = ipa_rScaleFactor[ch][prev_f_r_index];

  r_prev_prev  = (Ipp16s*)ipa_r[ch][prev_prev_f_r_index];
  re_prev_prev = (Ipp16s*)ipa_re[ch][prev_prev_f_r_index];
  im_prev_prev = (Ipp16s*)ipa_im[ch][prev_prev_f_r_index];

  r_prev_prevScaleFactor = ipa_rScaleFactor[ch][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);
  ippsSub_16s_Sfs(tmp2, tmp4, tmp0, NUM_UNPRED_LINES_LONG, 1);
  ippsSub_16s_Sfs(tmp3, tmp5, tmp1, NUM_UNPRED_LINES_LONG, 1);
  ippsMagnitude_16s_Sfs(tmp0, tmp1, c_w, NUM_UNPRED_LINES_LONG, -3);

  ippsSet_16s(13107, &c_w[ NUM_UNPRED_LINES_LONG],
               pa_iblen_long -  NUM_UNPRED_LINES_LONG);

  ippsMul_16s32s_Sfs((Ipp16s*)r, (Ipp16s*)r, rsqr_long, pa_iblen_long, 0);
  rsqr_longScale[0] = 2 * rScaleFactor;

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

    ippsSum_32s_Sfs(tmp_rsqr, len, &e_b[b], ipa_longScale - 2);
    ippsDotProd_16s32s32s_Sfs(tmp_c_w, tmp_rsqr, len,
                              &c_b[b], ipa_longScale + 13);
    index += len;
  }

  nb   = (Ipp32s *)ipa_nb_long[ch][ipa_nb_curr_index[ch]];
  nb_l = (Ipp32s *)ipa_nb_long[ch][ipa_nb_prev_index[ch]];

  ipa_next_frame_PE[ch] = 0;

  for (b = 0; b < pa_num_ptt_long; b++) {
    Ipp16s *tmp_ptr = (Ipp16s*)ipa_sprdngf_long +
                               b * pa_num_ptt_long;

    ippsDotProd_16s32s32s_Sfs(tmp_ptr, e_b, pa_num_ptt_long, &ecb[b], 15);
    ippsDotProd_16s32s32s_Sfs(tmp_ptr, c_b, pa_num_ptt_long, &ct[b], 15);
  }

  ippsMulC_32s_Sfs(ecb, 20219, tmp_ecb, pa_num_ptt_long, 21);
  ippsMulC_32s_Sfs(ct, 17131, tmp_ct, pa_num_ptt_long, 15);

  ippsAdd_32s_Sfs(tmp_ct, tmp_ecb, nb, pa_num_ptt_long, 0);
  ippsMulC_32s_Sfs(ecb, 16462, ecb_h_limit, pa_num_ptt_long, 16);
  ippsMulC_32s_Sfs(ecb, 16619, ecb_l_limit, pa_num_ptt_long, 20);
  ippsMaxEvery_32s_I(ecb_l_limit, nb, pa_num_ptt_long);
  ippsMinEvery_32s_I(ecb_h_limit, nb, pa_num_ptt_long);

  /* 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                        */

  nb_ScaleFactor = rsqr_longScale[0] + ipa_longScale - 1;
  nb_lScaleFactor = ipa_nb_longScaleFactor[ch];

  nb_lScaleFactor += 1;
  if (nb_lScaleFactor > nb_ScaleFactor) {
    shift = nb_lScaleFactor - nb_ScaleFactor;
    /* I use MulC here because LShiftC doesn't provide saturation */
    ippsMulC_32s_ISfs(1, nb_l, pa_num_ptt_long, -shift);
    ippsMinEvery_32s_I(nb_l, nb, pa_num_ptt_long);
    ippsLn_32s16s_Sfs(nb, tmp_ln0, pa_num_ptt_long, -10);
  } else if (nb_lScaleFactor < nb_ScaleFactor) {
    shift = nb_ScaleFactor - nb_lScaleFactor;
    if (shift > 31) shift = 31;
    /* I use MulC here because LShiftC doesn't provide saturation */
    ippsMulC_32s_ISfs(1, nb, pa_num_ptt_long, -shift);
    ippsMinEvery_32s_I(nb_l, nb, pa_num_ptt_long);
    ippsRShiftC_32s(nb, shift, ltmp0, pa_num_ptt_long);
    ippsLn_32s16s_Sfs(ltmp0, tmp_ln0, pa_num_ptt_long, -10);
    nb_ScaleFactor = nb_lScaleFactor;
  } else {
    ippsMinEvery_32s_I(nb_l, nb, pa_num_ptt_long);
    ippsLn_32s16s_Sfs(nb, tmp_ln0, pa_num_ptt_long, -10);
  }

  ipa_nb_longScaleFactor[ch] = nb_ScaleFactor;

  ippsLn_32s16s_Sfs(e_b, tmp_ln1, pa_num_ptt_long, -10);
  ippsSub_16s_Sfs(tmp_ln0, tmp_ln1, tmp_ln, pa_num_ptt_long, 1);
  FIND_NORM_SHIFT_16S(tmp_ln, pa_num_ptt_long, shift)
  ippsMul_16s_ISfs(mp3enc_pa_numlines_l[header.samplingFreq], tmp_ln, pa_num_ptt_long,
                   ipa_longScale - shift);
  ippsSum_16s32s_Sfs(tmp_ln, pa_num_ptt_long, &ipa_next_frame_PE[ch],
                     9 - ipa_longScale + shift);
}

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

void MP3EncoderInt::psy_short_window(Ipp16s *input_data,
                        Ipp32s* s_en,
                        Ipp32s* rsqr_short,
                        Ipp32s* rsqr_shortScale,
                        int ch)
{
  VM_ALIGN16_DECL(Ipp16s) sw_short[3][N_SHORT];
  VM_ALIGN16_DECL(Ipp16s) abs_sw[N_SHORT];
  VM_ALIGN16_DECL(Ipp16s) fft_line[N_SHORT+2];
  Ipp16s        *ptr_input_data;
  Ipp16s        *r;
  int           win_counter;
  int           scaleFactor[8], shift;
  int           min_shift, maxScaleFactor;
  Ipp32s        sum;

  ptr_input_data = input_data;

  for (win_counter = 0; win_counter < 3; win_counter++) {
    ptr_input_data += 192;
    ippsMul_16s_Sfs(ptr_input_data, ipa_hann_window_short,
                    sw_short[win_counter],
                    2 * pa_iblen_short, 15);
  }

  min_shift = 100;
  maxScaleFactor = -100;

  for (win_counter = 0; win_counter < 3; win_counter++) {
    ippsAbs_16s(sw_short[win_counter], abs_sw, 2 * pa_iblen_short);
    ippsSum_16s32s_Sfs(abs_sw, 2 * pa_iblen_short, &sum, 0);

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