aac_enc_psychoacoustic_fp.c

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

  ippsMul_32f((Ipp32f*)(pBlockCom->input_data[0] + 832),
              (Ipp32f*)pBlockCom->hann_window_short,
              (Ipp32f*)sw_short[3], 2 * pBlockCom->iblen_short - 64);

  ippsMul_32f((Ipp32f*)pBlockCom->input_data[1],
              (Ipp32f*)&pBlockCom->hann_window_short[2 * pBlockCom->iblen_short - 64],
              (Ipp32f*)&sw_short[3][2 * pBlockCom->iblen_short - 64], 64);

  ippsMul_32f((Ipp32f*)(pBlockCom->input_data[0] + 960),
              (Ipp32f*)pBlockCom->hann_window_short,
              (Ipp32f*)sw_short[4], 64);

  ippsMul_32f((Ipp32f*)pBlockCom->input_data[1],
              (Ipp32f*)&pBlockCom->hann_window_short[64],
              (Ipp32f*)&sw_short[4][64], 2 * pBlockCom->iblen_short - 64);

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

  for (win_counter = 5; win_counter < 8; 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;
  }

  for (win_counter = 0; win_counter < 8; win_counter++) {
    ippsFFTFwd_RToCCS_32f(sw_short[win_counter],
                          fft_line, pBlockCom->pFFTSpecShort,
                          pBlockCom->pBuffer);

    r = pBlock->r_short[pBlockCom->current_f_r_index][win_counter];

    ippsMagnitude_32fc((Ipp32fc*)fft_line, r, pBlockCom->iblen_short);
    ippsThreshold_LT_32f_I(r, pBlockCom->iblen_short, 1);
    ippsDotProd_32f(&r[32], &r[32], 96, &s_en[win_counter]);

#ifdef SMR_IS_USED
    r_prev       = (Ipp32f*)pBlock->r_short[pBlockCom->prev_f_r_index][win_counter];
    r_prev_prev  = (Ipp32f*)pBlock->r_short[pBlockCom->prev_prev_f_r_index][win_counter];

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

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

    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,  pBlockCom->iblen_short, tmp_dst);

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

    /* tmp1 = 2*re_prev*im_prev */
    ippsMulC_32f(re_prev, (Ipp32f)2, tmp1,  pBlockCom->iblen_short);
    ippsMul_32f_I(im_prev, tmp1,  pBlockCom->iblen_short);

    /* tmp2 = re_prev*re_prev-im_prev*im_prev */
    ippsMul_32f(re_prev, re_prev, tmp,  pBlockCom->iblen_short);
    ippsMul_32f(im_prev, im_prev, tmp2,  pBlockCom->iblen_short);
    ippsSub_32f_I(tmp, tmp2,  pBlockCom->iblen_short);

    ippsMul_32f(im_prev_prev, tmp1, re_pred,  pBlockCom->iblen_short);
    ippsMul_32f(re_prev_prev, tmp2, tmp,  pBlockCom->iblen_short);
    ippsAdd_32f_I(tmp, re_pred,  pBlockCom->iblen_short);
    ippsMul_32f_I(tmp0, re_pred,  pBlockCom->iblen_short);

    ippsMul_32f(re_prev_prev, tmp1, im_pred,  pBlockCom->iblen_short);
    ippsMul_32f(im_prev_prev, tmp2, tmp,  pBlockCom->iblen_short);
    ippsSub_32f_I(tmp, im_pred,  pBlockCom->iblen_short);
    ippsMul_32f_I(tmp0, im_pred,  pBlockCom->iblen_short);

    ippsSub_32f(re, re_pred, tmp0,  pBlockCom->iblen_short);
    ippsMul_32f_I(tmp0, tmp0,  pBlockCom->iblen_short);

    ippsSub_32f(im, im_pred, tmp1,  pBlockCom->iblen_short);
    ippsMul_32f_I(tmp1, tmp1,  pBlockCom->iblen_short);

    ippsAdd_32f(tmp0, tmp1, num,  pBlockCom->iblen_short);
    ippsSqrt_32f_I(num,  pBlockCom->iblen_short);

    ippsAbs_32f(r_pred, denum,  pBlockCom->iblen_short);
    ippsAdd_32f_I(r, denum,  pBlockCom->iblen_short);

    ippsDiv_32f(denum, num, c_w,  pBlockCom->iblen_short);

    rsqr = rsqr_short + 128 * win_counter;

    ippsSqr_32f(r, rsqr, 128);

    num_ptt = pBlockCom->shortWindow->num_ptt;

    for (b = 0; b < num_ptt; b++) {
      int w_high = pBlockCom->shortWindow->w_high[b];
      int w_low = pBlockCom->shortWindow->w_low[b];
      Ipp32f *tmp_rsqr = &rsqr_short[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_short[pBlockCom->nb_curr_index][win_counter];
    nb_l = pBlock->nb_short[pBlockCom->nb_prev_index][win_counter];

    for (b = 0; b < num_ptt; b++) {
      Ipp32f *tmp_ptr = (Ipp32f*)pBlockCom->sprdngf_short + 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_short, cb,
                (Ipp32f*)nb, num_ptt);

    /* instead of nb[b] = MAX( pow(10.0,pBlock->qsthr_short[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);
#endif
  }
}

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

AACStatus InitPsychoacousticCom(sPsychoacousticBlockCom* pBlock,
                                int sf_index)
{
  int i;
  int size, size_short;
  int num_ptt, b, bb;
  float *bval;

  ippsZero_8u((Ipp8u*)pBlock, sizeof(sPsychoacousticBlockCom));

  pBlock->iblen_long  = 1024;
  pBlock->iblen_short = 128;

  pBlock->nb_curr_index = 1;
  pBlock->nb_prev_index = 0;

  pBlock->sfb_offset_long  = sfb_tables[sf_index].sfb_offset_long_window;
  pBlock->sfb_offset_short = sfb_tables[sf_index].sfb_offset_short_window;
  pBlock->num_sfb_long = sfb_tables[sf_index].num_sfb_long_window;
  pBlock->num_sfb_short = sfb_tables[sf_index].num_sfb_short_window;

  pBlock->longWindow    = &psy_partition_tables_long[sf_index];
  pBlock->shortWindow   = &psy_partition_tables_short[sf_index];

  num_ptt = pBlock->longWindow->num_ptt;
  bval = pBlock->longWindow->bval;

  for (b = 0; b < num_ptt; b++) {
    float *tmp_ptr = pBlock->sprdngf_long + b * num_ptt;
    float tmp = 0;

    for (bb = 0; bb < num_ptt; bb++) {
      tmp_ptr[bb] = sprdngf(bval[bb], bval[b]);
      tmp += tmp_ptr[bb];
    }
    pBlock->rnorm_long[b] = 1/tmp;
  }

  num_ptt = pBlock->shortWindow->num_ptt;
  bval = pBlock->shortWindow->bval;

  for (b = 0; b < num_ptt; b++) {
    float *tmp_ptr = pBlock->sprdngf_short + b * num_ptt;
    float tmp = 0;

    for (bb = 0; bb < num_ptt; bb++) {
      tmp_ptr[bb] = sprdngf(bval[bb], bval[b]);
      tmp += tmp_ptr[bb];
    }
    pBlock->rnorm_short[b] = 1/tmp;
  }

  /* filling Hann windows */
  for (i = 0; i < pBlock->iblen_long * 2; i++)
    pBlock->hann_window_long[i] =
    (float)(0.5f * (1 - cos(PI * (i + 0.5f) / pBlock->iblen_long)));

  for (i = 0; i < pBlock->iblen_short * 2; i++)
    pBlock->hann_window_short[i] =
    (float)(0.5f * (1 - cos(PI * (i + 0.5f) / pBlock->iblen_short)));


  if (ippsFFTInitAlloc_R_32f(&(pBlock->pFFTSpecLong),
        11, IPP_FFT_NODIV_BY_ANY, ippAlgHintFast) != ippStsOk)
        return AAC_ALLOC;

  if (ippsFFTInitAlloc_R_32f(&(pBlock->pFFTSpecShort),
         8, IPP_FFT_NODIV_BY_ANY, ippAlgHintFast)  != ippStsOk)
         return AAC_ALLOC;

  if (ippsFFTGetBufSize_R_32f(pBlock->pFFTSpecLong, &size) != ippStsOk)
    return AAC_ALLOC;

  if (ippsFFTGetBufSize_R_32f(pBlock->pFFTSpecShort, &size_short) != ippStsOk)
    return AAC_ALLOC;

  if (size < size_short) size = size_short;

  if (size != 0) {
    pBlock->pBuffer = ippsMalloc_8u(size);
    if (pBlock->pBuffer == NULL)
      return AAC_ALLOC;
  }
  return AAC_OK;
}

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

void InitPsychoacoustic(sPsychoacousticBlock* pBlock)
{
  int i, j;

  pBlock->block_type = ONLY_LONG_SEQUENCE;
  pBlock->desired_block_type = ONLY_LONG_SEQUENCE;
  pBlock->next_frame_PE = 0;

  for (i = 0; i < MAX_PPT_LONG; i++) {
    pBlock->nb_long[0][i] = pBlock->nb_long[1][i] = (float)1.0e30;
  }

  for (i = 0; i < 1024; i++) {
    pBlock->r[0][i] = pBlock->r[1][i] = pBlock->r[2][i] = 1;
    pBlock->re[0][i] = pBlock->re[1][i] = pBlock->re[2][i] = 1;
    pBlock->im[0][i] = pBlock->im[1][i] = pBlock->im[2][i] = 0;
  }

  for (j = 0; j < 8; j++) {
    for (i = 0; i < 128; i++) {
      pBlock->r_short[0][j][i] = pBlock->r_short[1][j][i] =
      pBlock->r_short[2][j][i] = 1;

      pBlock->re_short[0][j][i] = pBlock->re_short[1][j][i] =
      pBlock->re_short[2][j][i] = 1;

      pBlock->im_short[0][j][i] = pBlock->im_short[1][j][i] =
      pBlock->im_short[2][j][i] = 0;
    }

    for (i = 0; i < MAX_PPT_SHORT; i++) {
      pBlock->nb_short[0][j][i] = pBlock->nb_short[1][j][i] = (float)1.0e30;
    }
  }

#ifdef SMR_IS_USED
  for (i= 0; i < MAX_SFB; i++) {
    pBlock->smr_short[0][i] = pBlock->smr_long[0][i] = 0;
    pBlock->smr_short[1][i] = pBlock->smr_long[1][i] = 0;
  }
#endif
}

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

void FreePsychoacousticCom(sPsychoacousticBlockCom* pBlock)
{
  if (pBlock) {
    if (pBlock->pFFTSpecShort)
      ippsFFTFree_R_32f(pBlock->pFFTSpecShort);

    if (pBlock->pFFTSpecLong)
      ippsFFTFree_R_32f(pBlock->pFFTSpecLong);

    if (pBlock->pBuffer)
      ippsFree(pBlock->pBuffer);
  }
}

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

void Psychoacoustic(sPsychoacousticBlock* pBlock,
                    sPsychoacousticBlockCom* pBlockCom)
{
  __ALIGN Ipp32f  rsqr_long[1024];
  __ALIGN Ipp32f  rsqr_short[1024];
  Ipp32f  s_en[8];
  Ipp32f  min, max;

  pBlock->curr_frame_PE = pBlock->next_frame_PE;

  psy_long_window(pBlock, pBlockCom, rsqr_long);
  psy_short_window(pBlock, pBlockCom, s_en, rsqr_short);

  ippsMinMax_32f(s_en, 8, &min, &max);

  /* part 1 */

  if (pBlock->next_frame_PE > 2500) {
    pBlock->next_desired_block_type = EIGHT_SHORT_SEQUENCE;
  } else if (max > 25 * min) {
    pBlock->next_desired_block_type = EIGHT_SHORT_SEQUENCE;
  } else if ((max > 10 * min) && (pBlock->next_frame_PE > 800)) {
    pBlock->next_desired_block_type = EIGHT_SHORT_SEQUENCE;
  } else {
    pBlock->next_desired_block_type = ONLY_LONG_SEQUENCE;
  }

  /* part 2 */
  if ((pBlock->block_type == EIGHT_SHORT_SEQUENCE) ||
      (pBlock->block_type == LONG_START_SEQUENCE)) {
    if ((pBlock->desired_block_type==ONLY_LONG_SEQUENCE) &&
      (pBlock->next_desired_block_type==ONLY_LONG_SEQUENCE)) {
      pBlock->block_type=LONG_STOP_SEQUENCE;
    } else {
      pBlock->block_type=EIGHT_SHORT_SEQUENCE;
    }
  } else if (pBlock->next_desired_block_type==EIGHT_SHORT_SEQUENCE) {
    pBlock->block_type=LONG_START_SEQUENCE;
  } else {
    pBlock->block_type=ONLY_LONG_SEQUENCE;
  }
  pBlock->desired_block_type=pBlock->next_desired_block_type;

#ifdef SMR_IS_USED
  psy_smr(pBlock, pBlockCom, rsqr_long, rsqr_short);
#endif

}

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