aac_enc_psychoacoustic_int.c

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

    ippsMul_16s_Sfs(tmp1, im, tmp5, pBlock->iblen_short, 17);
    ippsSub_16s_Sfs(tmp2, tmp4, tmp0, pBlock->iblen_short, 1);
    ippsSub_16s_Sfs(tmp3, tmp5, tmp1, pBlock->iblen_short, 1);
    ippsMagnitude_16s_Sfs(tmp0, tmp1, c_w, pBlock->iblen_short, -3);

    rsqr = rsqr_short + 128 * win_counter;

    ippsMul_16s32s_Sfs((Ipp16s*)r, (Ipp16s*)r, rsqr, pBlock->iblen_short, 0);
    rsqr_shortScale[win_counter] = 2 * rScaleFactor;

    for (b = 0; b < pBlock->num_ptt_short; b++) {
      Ipp32s *tmp_rsqr = &rsqr[pBlock->w_low_short[b]];
      Ipp16s *tmp_c_w = (Ipp16s*)&c_w[pBlock->w_low_short[b]];
      int len = pBlock->w_width_short[b];

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

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

    for (b = 0; b < pBlock->num_ptt_short; b++) {
      Ipp16s *tmp_ptr = (Ipp16s*)pBlock->sprdngf_short +
                                 b * pBlock->num_ptt_short;

      ippsDotProd_16s32s32s_Sfs(tmp_ptr, e_b, pBlock->num_ptt_short, &ecb[b], 15);
      ippsDotProd_16s32s32s_Sfs(tmp_ptr, c_b, pBlock->num_ptt_short, &ct[b], 15);
    }

    ippsMulC_32s_Sfs(ecb, 20219, tmp_ecb, pBlock->num_ptt_short, 21);
    ippsMulC_32s_Sfs(ct, 17131, tmp_ct, pBlock->num_ptt_short, 15);

    ippsAdd_32s_Sfs(tmp_ct, tmp_ecb, nb, pBlock->num_ptt_short, 0);
    ippsMulC_32s_Sfs(ecb, 16462, ecb_h_limit, pBlock->num_ptt_short, 16);
    ippsMulC_32s_Sfs(ecb, 16619, ecb_l_limit, pBlock->num_ptt_short, 20);
    ippsMaxEvery_32s_I(ecb_l_limit, nb, pBlock->num_ptt_short);
    ippsMinEvery_32s_I(ecb_h_limit, nb, pBlock->num_ptt_short);

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

    nb_ScaleFactor = rsqr_shortScale[win_counter] + pBlock->shortScale - 1;
    nb_lScaleFactor = pBlock->nb_shortScaleFactor[win_counter];

    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, pBlock->num_ptt_short, -shift);
    } 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, pBlock->num_ptt_short, -shift);
      nb_ScaleFactor = nb_lScaleFactor;
    }
    ippsMinEvery_32s_I(nb_l, nb, pBlock->num_ptt_short);

    pBlock->nb_shortScaleFactor[win_counter] = nb_ScaleFactor;
#endif
  }
}

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

AACStatus InitPsychoacousticCom(sPsychoacousticBlockCom* pBlock,
                                int sf_index)
{
  int i;
  int size, size_short, max_len;
  int num_ptt, b, bb;
  Ipp16s *bval;
  Ipp16s *sprdngf;
  int jj;

  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 = (Ipp16s*)pBlock->longWindow->bval;
  sprdngf = (Ipp16s*)pBlock->sprdngf_long;

  for (jj = 0; jj < 2; jj++) {

    for (b = 0; b < num_ptt; b++) {
      Ipp16s *tmp_ptr = sprdngf + b * num_ptt;
      int tmp = 0;
      int scalef = -15;
      Ipp16s src2 = bval[b];

      for (bb = 0; bb < num_ptt; bb++) {
        ippsSpread_16s_Sfs(bval[bb], src2, -10, tmp_ptr + bb);
        tmp += tmp_ptr[bb];
      }

      while (tmp >= 32768) {
        scalef += 1;
        tmp >>= 1;
      }

      ippsDivC_16s_ISfs((short)tmp, tmp_ptr, num_ptt, scalef);
    }

    num_ptt = pBlock->shortWindow->num_ptt;
    bval = (Ipp16s*)pBlock->shortWindow->bval;
    sprdngf = (Ipp16s*)pBlock->sprdngf_short;
  }

  max_len = 0;
  for (i = 0; i < pBlock->longWindow->num_ptt; i++) {
    int len = pBlock->longWindow->w_width[i];
    if (len > max_len) max_len = len;
  }

  pBlock->longScale = 0;
  while (max_len > (1 << pBlock->longScale)) {
    pBlock->longScale++;
  }

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

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

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

  if (ippsFFTGetBufSize_R_16s(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] = 0x7FFFFFFF;
  }

  pBlock->nb_longScaleFactor = 0x7FFFFFF;

  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;
  }

  pBlock->rScaleFactor[0] = 0;
  pBlock->rScaleFactor[1] = 0;
  pBlock->rScaleFactor[2] = 0;

  pBlock->ScaleFactor[0] = 0;
  pBlock->ScaleFactor[1] = 0;
  pBlock->ScaleFactor[2] = 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] = 0x7FFFFFFF;
    }
    pBlock->nb_shortScaleFactor[i] = 0x7FFFFFF;
  }

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

  for (i = 0; i < pBlock->num_sfb_long; i++) {
    int len = pBlock->sfb_offset_long[i + 1] - pBlock->sfb_offset_long[i];
    pBlock->sfb_width_long[i] = len;
    if (len > max_len) max_len = len;
  }

  pBlock->sfb_width_longScale = 0;
  while (max_len > (1 << pBlock->sfb_width_longScale)) {
    pBlock->sfb_width_longScale++;
  }

  for (i = 0; i < pBlock->num_sfb_short; i++) {
    int len = pBlock->sfb_offset_short[i + 1] - pBlock->sfb_offset_short[i];
    pBlock->sfb_width_short[i] = len;
    if (len > max_len) max_len = len;
  }

  pBlock->sfb_width_shortScale = 0;
  while (max_len > (1 << pBlock->sfb_width_shortScale)) {
    pBlock->sfb_width_shortScale++;
  }

  {
    Ipp16u tmp_buf[((MAX_PPT_LONG > MAX_PPT_SHORT) ? MAX_PPT_LONG : MAX_PPT_SHORT)];

    for (i = 0; i < pBlock->longWindow->num_ptt; i++) {
      tmp_buf[i] = pBlock->w_width_long[i];
    }

    ippsDivCRev_16u_I(0x8000, tmp_buf, pBlock->longWindow->num_ptt);

    for (i = 0; i < pBlock->longWindow->num_ptt; i++) {
      pBlock->w_width_long_inv[i] = tmp_buf[i];
    }

    for (i = 0; i < pBlock->num_ptt_short; i++) {
      tmp_buf[i] = pBlock->w_width_short[i];
    }

    ippsDivCRev_16u_I(0x8000, tmp_buf, pBlock->num_ptt_short);

    for (i = 0; i < pBlock->num_ptt_short; i++) {
      pBlock->w_width_short_inv[i] = tmp_buf[i];
    }
  }
#endif
}

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

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

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

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

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

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

  pBlock->curr_frame_PE = pBlock->next_frame_PE;

  psy_long_window(pBlock, pBlockCom, rsqr_long, &rsqr_longScale);
  psy_short_window(pBlock, pBlockCom, s_en, rsqr_short, rsqr_shortScale);

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

  /* part 1 */
  if (pBlock->next_frame_PE > 5800) {
    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 > 1900)) {
    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_longScale,
          rsqr_short, rsqr_shortScale);
#endif
}

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