aac_enc_psychoacoustic_int.c

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

  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],
               pBlockCom->iblen_long -  NUM_UNPRED_LINES_LONG);

  ippsMul_16s32s_Sfs((Ipp16s*)r, (Ipp16s*)r, rsqr_long, pBlockCom->iblen_long, 0);
  rsqr_longScale[0] = 2 * rScaleFactor;

  for (b = 0; b < num_ptt_long; b++) {
    Ipp32s *tmp_rsqr = &rsqr_long[pBlockCom->longWindow->w_low[b]];
    Ipp16s *tmp_c_w = (Ipp16s*)&c_w[pBlockCom->longWindow->w_low[b]];
    int len = pBlockCom->longWindow->w_width[b];

    ippsSum_32s_Sfs(tmp_rsqr, len, &e_b[b], pBlockCom->longScale - 1);
    ippsDotProd_16s32s32s_Sfs(tmp_c_w, tmp_rsqr, len,
                              &c_b[b], pBlockCom->longScale + 14);
  }

  nb   = (Ipp32s *)pBlock->nb_long[pBlockCom->nb_curr_index];
  nb_l = (Ipp32s *)pBlock->nb_long[pBlockCom->nb_prev_index];

  pBlock->next_frame_PE = 0;

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

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

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

  ippsAdd_32s_Sfs(tmp_ct, tmp_ecb, nb, num_ptt_long, 0);
  ippsMulC_32s_Sfs(ecb, 16462, ecb_h_limit, num_ptt_long, 16);
  ippsMulC_32s_Sfs(ecb, 16619, ecb_l_limit, num_ptt_long, 20);
  ippsMaxEvery_32s_I(ecb_l_limit, nb, num_ptt_long);
  ippsMinEvery_32s_I(ecb_h_limit, nb, 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] + pBlockCom->longScale - 1;
  nb_lScaleFactor = pBlock->nb_longScaleFactor;

  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, num_ptt_long, -shift);
    ippsMinEvery_32s_I(nb_l, nb, num_ptt_long);
    ippsLn_32s16s_Sfs(nb, tmp_ln0, 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, num_ptt_long, -shift);
    ippsMinEvery_32s_I(nb_l, nb, num_ptt_long);
    ippsRShiftC_32s(nb, shift, ltmp0, num_ptt_long);
    ippsLn_32s16s_Sfs(ltmp0, tmp_ln0, num_ptt_long, -10);
    nb_ScaleFactor = nb_lScaleFactor;
  } else {
    ippsMinEvery_32s_I(nb_l, nb, num_ptt_long);
    ippsLn_32s16s_Sfs(nb, tmp_ln0, num_ptt_long, -10);
  }

  pBlock->nb_longScaleFactor = nb_ScaleFactor;

  ippsLn_32s16s_Sfs(e_b, tmp_ln1, num_ptt_long, -10);
  ippsSub_16s_Sfs(tmp_ln0, tmp_ln1, tmp_ln, num_ptt_long, 1);
  FIND_NORM_SHIFT_16S(tmp_ln, num_ptt_long, shift)
  ippsMul_16s_ISfs(pBlockCom->longWindow->w_width, tmp_ln, num_ptt_long,
                   pBlockCom->longScale - shift);
  ippsSum_16s32s_Sfs(tmp_ln, num_ptt_long, &pBlock->next_frame_PE,
                     9 - pBlockCom->longScale + shift);
}

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

void psy_short_window(sPsychoacousticBlock* pBlock,
                      sPsychoacousticBlockCom* pBlockCom,
                      Ipp32s* s_en,
                      Ipp32s* rsqr_short,
                      Ipp32s* rsqr_shortScale)
{
__ALIGN Ipp16s  sw_short[8][__ALIGNED(N_SHORT)];
__ALIGN Ipp16s  abs_sw[N_SHORT];
__ALIGN Ipp16s  fft_line[N_SHORT+2];
__ALIGN Ipp16sc fft_unpack[2*N_SHORT];
  Ipp16s        *ptr_input_data;
  Ipp16s        *r;
  int           win_counter;
  int           scaleFactor[8], shift;
  int           min_shift, maxScaleFactor;
  Ipp32s        sum;
#ifdef SMR_IS_USED
__ALIGN Ipp32s  e_b[MAX_PPT_SHORT];
__ALIGN Ipp32s  c_b[MAX_PPT_SHORT];
__ALIGN Ipp32s  ecb[MAX_PPT_SHORT];
__ALIGN Ipp32s  ct[MAX_PPT_SHORT];
__ALIGN Ipp32s  tmp_ecb[MAX_PPT_SHORT];
__ALIGN Ipp32s  tmp_ct[MAX_PPT_SHORT];
__ALIGN Ipp32s  ecb_h_limit[MAX_PPT_SHORT];
__ALIGN Ipp32s  ecb_l_limit[MAX_PPT_SHORT];
__ALIGN Ipp16s  c_w[128];
__ALIGN Ipp16s  tmp[128];
__ALIGN Ipp16s  tmp0[128];
__ALIGN Ipp16s  tmp1[128];
__ALIGN Ipp16s  tmp2[128];
__ALIGN Ipp16s  tmp3[128];
__ALIGN Ipp16s  tmp4[128];
__ALIGN Ipp16s  tmp5[128];
__ALIGN Ipp16s  denum[128];
__ALIGN Ipp16s  r_pred[128];
__ALIGN Ipp16s  re_pred[128];
__ALIGN Ipp16s  im_pred[128];
  Ipp32s        *rsqr;
  Ipp16s        *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;
  int           shift0, shift1;
  int           rScaleFactor, r_prevScaleFactor;
  int           r_prev_prevScaleFactor, r_predScaleFactor;
  int           nb_ScaleFactor, nb_lScaleFactor;
#endif

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

  for (win_counter = 0; win_counter < 3; win_counter++) {
    ippsMul_16s_Sfs(ptr_input_data, AAC_HANN_short,
                    sw_short[win_counter],
                    2 * pBlockCom->iblen_short, 15);
    ptr_input_data += pBlockCom->iblen_short;
  }

  ippsMul_16s_Sfs((Ipp16s*)(pBlockCom->input_data[0] + 832), AAC_HANN_short,
                  sw_short[3], 2 * pBlockCom->iblen_short - 64, 15);

  ippsMul_16s_Sfs((Ipp16s*)pBlockCom->input_data[1],
                  &AAC_HANN_short[2 * pBlockCom->iblen_short - 64],
                  &sw_short[3][2 * pBlockCom->iblen_short - 64], 64, 15);

  ippsMul_16s_Sfs((Ipp16s*)(pBlockCom->input_data[0] + 960), AAC_HANN_short,
                  sw_short[4], 64, 15);

  ippsMul_16s_Sfs((Ipp16s*)pBlockCom->input_data[1], &AAC_HANN_short[64],
                  &sw_short[4][64], 2 * pBlockCom->iblen_short - 64, 15);

  ptr_input_data = (Ipp16s*)pBlockCom->input_data[1] + 64;

  for (win_counter = 5; win_counter < 8; win_counter++) {
    ippsMul_16s_Sfs(ptr_input_data, AAC_HANN_short,
                    sw_short[win_counter],
                   2 * pBlockCom->iblen_short, 15);
    ptr_input_data += pBlockCom->iblen_short;
  }

  min_shift = 100;
  maxScaleFactor = -100;

  for (win_counter = 0; win_counter < 8; win_counter++) {
    ippsAbs_16s(sw_short[win_counter], abs_sw, 2 * pBlockCom->iblen_short);
    ippsSum_16s32s_Sfs(abs_sw, 2 * pBlockCom->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 <= 16384) {
          sum *= 2;
          scaleFactor[win_counter]--;
        }
      }
    }

    ippsFFTFwd_RToCCS_16s_Sfs(sw_short[win_counter],
                              fft_line, pBlockCom->pFFTSpecShort,
                              scaleFactor[win_counter],
                              pBlockCom->pBuffer);

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


    r = (Ipp16s*)pBlock->r_short[pBlockCom->current_f_r_index][win_counter];

    ippsMagnitude_16sc_Sfs(fft_unpack, r, pBlockCom->iblen_short, 1);
    ippsThreshold_LT_16s_I(r, pBlockCom->iblen_short, 1);
    FIND_NORM_SHIFT_16S(&r[(pBlockCom->iblen_short >> 2)],
                        pBlockCom->iblen_short - (pBlockCom->iblen_short >> 2),
                        shift)
    if (min_shift > shift) min_shift = shift;
    if (maxScaleFactor < scaleFactor[win_counter])
      maxScaleFactor = scaleFactor[win_counter];
  }

  for (win_counter = 0; win_counter < 8; win_counter++) {

    r = (Ipp16s*)pBlock->r_short[pBlockCom->current_f_r_index][win_counter];

    /* The scalefactor 12 - (2*shift+1) is calculated from max value to multiplay. */
    /* This value less than                                                        */
    /* (pBlock->iblen_short - (pBlock->iblen_short >> 2)) * 25 < 96 * 25 = 2400    */
    /* The value 25 is used in comparison (Psychoacoustic module)                  */
    ippsDotProd_16s32s_Sfs(&r[(pBlockCom->iblen_short >> 2)],
                           &r[(pBlockCom->iblen_short >> 2)],
                           pBlockCom->iblen_short - (pBlockCom->iblen_short >> 2),
                           &s_en[win_counter],
                           12 + 2 * (maxScaleFactor- scaleFactor[win_counter])
                           - (2*min_shift+1));

#ifdef SMR_IS_USED
    re           = (Ipp16s*)pBlock->re_short[pBlock->current_f_r_index][win_counter];
    im           = (Ipp16s*)pBlock->im_short[pBlock->current_f_r_index][win_counter];

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

    ippsDeinterleave_16s(fft_line, 2, pBlock->iblen_short, tmp_dst);
    ippsDiv_16s_ISfs(r, re, pBlock->iblen_short, -14);
    ippsDiv_16s_ISfs(r, im, pBlock->iblen_short, -14);

    FIND_NORM_SHIFT_16S(r, pBlock->iblen_short, shift)
    ippsLShiftC_16s_I(shift, r, pBlock->iblen_short);
    rScaleFactor = scaleFactor[win_counter] + 1 - shift;

    pBlock->rScaleFactorShort[pBlock->current_f_r_index][win_counter] =
            rScaleFactor;

    r_prev       = (Ipp16s*)pBlock->r_short[pBlock->prev_f_r_index][win_counter];
    re_prev      = (Ipp16s*)pBlock->re_short[pBlock->prev_f_r_index][win_counter];
    im_prev      = (Ipp16s*)pBlock->im_short[pBlock->prev_f_r_index][win_counter];

    r_prevScaleFactor =
      pBlock->rScaleFactorShort[pBlock->prev_f_r_index][win_counter];

    r_prev_prev  = (Ipp16s*)pBlock->r_short[pBlock->prev_prev_f_r_index][win_counter];
    re_prev_prev = (Ipp16s*)pBlock->re_short[pBlock->prev_prev_f_r_index][win_counter];
    im_prev_prev = (Ipp16s*)pBlock->im_short[pBlock->prev_prev_f_r_index][win_counter];

    r_prev_prevScaleFactor =
      pBlock->rScaleFactorShort[pBlock->prev_prev_f_r_index][win_counter];

    /* 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, pBlock->iblen_short);
      ippsSub_16s_Sfs(r_prev_prev, tmp0, r_pred, pBlock->iblen_short, 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, pBlock->iblen_short);
      ippsSub_16s_Sfs(tmp0, r_prev, r_pred, pBlock->iblen_short, 1);
      r_predScaleFactor++;
    } else {
      ippsSub_16s_Sfs(r_prev_prev, r_prev, r_pred, pBlock->iblen_short, 1);
      r_predScaleFactor++;
    }

    /* tmp1 = 2*re_prev*im_prev */
    ippsMul_16s_Sfs(re_prev, im_prev, tmp1, pBlock->iblen_short, 15);

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

    /* im_prev_prev * tmp1 + re_prev_prev * tmp2 */
    ippsMul_16s_Sfs(im_prev_prev, tmp1, re_pred, pBlock->iblen_short, 15);
    ippsMul_16s_Sfs(re_prev_prev, tmp2, tmp, pBlock->iblen_short, 15);
    ippsAdd_16s_ISfs(tmp, re_pred, pBlock->iblen_short, 1);

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

    ippsAbs_16s(r_pred, denum,  pBlock->iblen_short);

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

    ippsDiv_16s_Sfs(denum, r_pred, tmp0, pBlock->iblen_short, -14 + shift0);
    ippsDiv_16s_Sfs(denum, r, tmp1, pBlock->iblen_short, -14 + shift1);

    ippsMul_16s_Sfs(tmp0, re_pred, tmp2, pBlock->iblen_short, 15);
    ippsMul_16s_Sfs(tmp0, im_pred, tmp3, pBlock->iblen_short, 15);
    ippsMul_16s_Sfs(tmp1, re, tmp4, pBlock->iblen_short, 17);