aac_enc_psychoacoustic_int.c

audio-video-codecs.rar语音编解码器

      }
    }
    smr = (Ipp32s*)pBlock->smr_long[pBlockCom->nb_curr_index];
    ippsDiv_32s_Sfs(epart, npart, smr, pBlockCom->num_sfb_long, -21);
  }
}

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

static void aaciencPsy_short_window(sPsychoacousticBlock* pBlock,
                                    sPsychoacousticBlockCom* pBlockCom,
                                    Ipp32s* s_en,
                                    Ipp32s ch,
                                    Ipp32s ind)
{
__ALIGN Ipp16s  sw_short[8][__ALIGNED(N_SHORT)];
__ALIGN Ipp16s  abs_sw[N_SHORT];
__ALIGN Ipp16s  fft_line[__ALIGNED(2*128+2)];
  Ipp16s        *ptr_input_data;
  Ipp16s        *r;
  Ipp32s        win_counter;
  Ipp32s        scaleFactor[8], shift;
  Ipp32s        min_shift, maxScaleFactor;
  Ipp32s        sum;
__ALIGN Ipp32s  rsqr_short[128];
__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 Ipp32s  nb[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        b;
  Ipp32s        shift0, shift1;
  Ipp32s        rScaleFactor, r_prevScaleFactor;
  Ipp32s        r_prev_prevScaleFactor, r_predScaleFactor;
  Ipp32s        rsqr_shortScale;
  Ipp32s        num_ptt_short = pBlockCom->shortWindow->num_ptt;

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

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

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

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

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

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

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

  for (win_counter = 5; win_counter < 8; win_counter++) {
    ippsMul_16s_Sfs(ptr_input_data, AACI_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);

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

    ippsMagnitude_16sc_Sfs((Ipp16sc *)fft_line, 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];

    if (pBlockCom->ns_mode) {
      re           = (Ipp16s*)pBlock->re_short[ind][pBlockCom->current_f_r_index][win_counter];
      im           = (Ipp16s*)pBlock->im_short[ind][pBlockCom->current_f_r_index][win_counter];

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

      ippsDeinterleave_16s(fft_line, 2, pBlockCom->iblen_short, tmp_dst);

      ippsDiv_16s_ISfs(r, re, pBlockCom->iblen_short, -14);
      ippsDiv_16s_ISfs(r, im, pBlockCom->iblen_short, -14);
    }
  }

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

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

    /* The scalefactor 12 - (2*shift+1) is calculated from max value to multiplay. */
    /* This value less than                                                        */
    /* (pBlockCom->iblen_short - (pBlockCom->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));

    if (pBlockCom->ns_mode) {
      Ipp32s epart[MAX_SFB];
      Ipp32s npart[MAX_SFB];
      Ipp32s *smr;
      Ipp32s sb;

      re           = (Ipp16s*)pBlock->re_short[ind][pBlockCom->current_f_r_index][win_counter];
      im           = (Ipp16s*)pBlock->im_short[ind][pBlockCom->current_f_r_index][win_counter];

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

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

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

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

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

      r_prev_prevScaleFactor =
        pBlock->rScaleFactorShort[ind][pBlockCom->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, pBlockCom->iblen_short);
        ippsSub_16s_Sfs(r_prev_prev, tmp0, r_pred, pBlockCom->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, pBlockCom->iblen_short);
        ippsSub_16s_Sfs(tmp0, r_prev, r_pred, pBlockCom->iblen_short, 1);
        r_predScaleFactor++;
      } else {
        ippsSub_16s_Sfs(r_prev_prev, r_prev, r_pred, pBlockCom->iblen_short, 1);
        r_predScaleFactor++;
      }

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

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

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

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

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

      /* denumScaleFactor = (shift0 == 0) ? r_predScaleFactor + 1 : rScaleFactor + 1 */
      if (r_predScaleFactor > rScaleFactor) {
        shift0 = 0;
        shift1 = r_predScaleFactor - rScaleFactor;
        if (shift1 > 16) shift1 = 16;
        ippsRShiftC_16s(r, shift1, tmp0, pBlockCom->iblen_short);
        ippsAdd_16s_ISfs(tmp0, denum, pBlockCom->iblen_short, 1);
      } else if (r_predScaleFactor < rScaleFactor) {
        shift0 = rScaleFactor - r_predScaleFactor;
        shift1 = 0;
        if (shift0 > 16) shift0 = 16;
        ippsRShiftC_16s(denum, shift0, tmp0, pBlockCom->iblen_short);
        ippsAdd_16s_Sfs(r, tmp0, denum, pBlockCom->iblen_short, 1);
      } else {
        shift0 = 0;
        shift1 = 0;
        ippsAdd_16s_ISfs(r, denum, pBlockCom->iblen_short, 1);
      }

      /* tmp0 in Q15 */
      ippsDiv_16s_Sfs(denum, r_pred, tmp0, pBlockCom->iblen_short, -14 + shift0);

      /* tmp1 in Q15 */
      ippsDiv_16s_Sfs(denum, r, tmp1, pBlockCom->iblen_short, -14 + shift1);

      /* tmp2 in Q13 */
      ippsMul_16s_Sfs(tmp0, re_pred, tmp2, pBlockCom->iblen_short, 15);
      /* tmp3 in Q13 */
      ippsMul_16s_Sfs(tmp0, im_pred, tmp3, pBlockCom->iblen_short, 15);
      /* tmp4 in Q13 */
      ippsMul_16s_Sfs(tmp1, re, tmp4, pBlockCom->iblen_short, 17);
      /* tmp5 in Q13 */
      ippsMul_16s_Sfs(tmp1, im, tmp5, pBlockCom->iblen_short, 17);
      /* tmp0 in Q12 */
      ippsSub_16s_Sfs(tmp2, tmp4, tmp0, pBlockCom->iblen_short, 1);
      /* tmp1 in Q12 */
      ippsSub_16s_Sfs(tmp3, tmp5, tmp1, pBlockCom->iblen_short, 1);
      /* c_w in Q15 */
      ippsMagnitude_16s_Sfs(tmp0, tmp1, c_w, pBlockCom->iblen_short, -3);

      rsqr = rsqr_short;

      ippsMul_16s32s_Sfs((Ipp16s*)r, (Ipp16s*)r, rsqr, pBlockCom->iblen_short, 0);
      rsqr_shortScale = 2 * rScaleFactor;

      for (b = 0; b < num_ptt_short; b++) {
        Ipp32s *tmp_rsqr = &rsqr[pBlockCom->shortWindow->w_low[b]];
        Ipp16s *tmp_c_w = (Ipp16s*)&c_w[pBlockCom->shortWindow->w_low[b]];
        Ipp32s len = pBlockCom->shortWindow->w_width[b];

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

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

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

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

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

      for (sb = 0; sb < pBlockCom->num_sfb_short; sb++) {
        Ipp32s start = pBlockCom->aacenc_p2sb_s[sb].bu;
        Ipp32s end = pBlockCom->aacenc_p2sb_s[sb].bo;

        epart[sb] = (Ipp32s)((((Ipp64s)pBlockCom->aacenc_p2sb_s[sb].w1 * e_b[start]) >> 32) +
                             (((Ipp64s)pBlockCom->aacenc_p2sb_s[sb].w2 * e_b[end]) >> 32));

        npart[sb] = (Ipp32s)((((Ipp64s)pBlockCom->aacenc_p2sb_s[sb].w1 * nb[start]) >> 32) +
                             (((Ipp64s)pBlockCom->aacenc_p2sb_s[sb].w2 * nb[end]) >> 32));

        for (b = start + 1; b < end; b++) {
          epart[sb] += (e_b[b] >> 2);
          npart[sb] += (nb[b] >> 2);
        }
      }

      smr = (Ipp32s*)pBlock->smr_short[pBlockCom->nb_curr_index] +
        pBlockCom->num_sfb_short * win_counter;

      ippsDiv_32s_Sfs(epart, npart, smr, pBlockCom->num_sfb_short, -21);
    }
  }
}

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

AACStatus aaciencInitPsychoacousticCom(sPsychoacousticBlockCom* pBlock,
                                       Ipp8u* mem,
                                       Ipp32s sf_index,
                                       Ipp32s ns_mode,
                                       Ipp32s *size_all)
{
  Ipp32s i;
  Ipp32s max_len;
  Ipp32s num_ptt, b, bb;
  Ipp8u  *pBufInit;
  Ipp16s *bval;
  Ipp16s *sprdngf;