aac_enc_psychoacoustic_int.c

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

  Ipp32s jj;
  Ipp32s sizeSpecLong, sizeInit, sizeWork;
  Ipp32s sizeSpecShort, sizeInitShort, sizeWorkShort;

  if (pBlock) {
    pBlock->iblen_long  = 1024;
    pBlock->iblen_short = 128;

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

    pBlock->aacenc_p2sb_l = aacienc_p2sb_l[sf_index];
    pBlock->aacenc_p2sb_s = aacienc_p2sb_s[sf_index];
    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    = &aacienc_psy_partition_tables_long[sf_index];
    pBlock->shortWindow   = &aacienc_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;
        Ipp32s tmp = 0;
        Ipp32s 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((Ipp16s)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++) {
      Ipp32s 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 (ippsFFTGetSize_R_16s(11, IPP_FFT_NODIV_BY_ANY, ippAlgHintFast,
                           &sizeSpecLong, &sizeInit, &sizeWork) != ippStsOk) {
    return AAC_ALLOC;
  }

  if (ippsFFTGetSize_R_16s(8, IPP_FFT_NODIV_BY_ANY, ippAlgHintFast,
                           &sizeSpecShort, &sizeInitShort, &sizeWorkShort) != ippStsOk) {
    return AAC_ALLOC;
  }

  if (sizeInit < sizeInitShort)
    sizeInit = sizeInitShort;

  if (sizeWork < sizeWorkShort)
    sizeWork = sizeWorkShort;

  *size_all = sizeSpecLong + sizeSpecShort + sizeWork + sizeInit;

  if (pBlock) {
    pBlock->pBuffer = mem + sizeSpecLong + sizeSpecShort;
    pBufInit = pBlock->pBuffer + sizeWork;

    if (ippsFFTInit_R_16s(&(pBlock->pFFTSpecLong), 11, IPP_FFT_NODIV_BY_ANY,
                          ippAlgHintFast, mem, pBufInit) != ippStsOk) {
      return AAC_ALLOC;
    }

    if (ippsFFTInit_R_16s(&(pBlock->pFFTSpecLong), 8, IPP_FFT_NODIV_BY_ANY,
                          ippAlgHintFast, mem + sizeSpecLong, pBufInit) != ippStsOk) {
      return AAC_ALLOC;
    }

    pBlock->ns_mode = ns_mode;

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

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

      max_len = 0;
      for (i = 0; i < pBlock->num_sfb_long; i++) {
        Ipp32s 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++;
      }

      max_len = 0;
      for (i = 0; i < pBlock->num_sfb_short; i++) {
        Ipp32s 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->longWindow->w_width[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->shortWindow->num_ptt; i++) {
          tmp_buf[i] = pBlock->shortWindow->w_width[i];
        }

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

        for (i = 0; i < pBlock->shortWindow->num_ptt; i++) {
          pBlock->w_width_short_inv[i] = tmp_buf[i];
        }
      }
    }
  }
  return AAC_OK;
}

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

void aaciencInitPsychoacoustic(sPsychoacousticBlock* pBlock)
{
  Ipp32s i, j, k;

  pBlock->block_type = ONLY_LONG_SEQUENCE;
  pBlock->desired_block_type = ONLY_LONG_SEQUENCE;
  pBlock->next_frame_PE = 0;
  pBlock->stereo_mode[0] = pBlock->stereo_mode[1] = AAC_LR_STEREO;
  pBlock->ms_coef[0] = pBlock->ms_coef[1] = 8;

  for (k = 0; k < 2; k++) {
    for (j = 0; j < 3; j++) {
      ippsSet_16s(1, pBlock->r[k][j], 1024);
      ippsSet_16s(1, pBlock->re[k][j], 1024);
      ippsSet_16s(0, pBlock->im[k][j], 1024);
      pBlock->rScaleFactor[k][j] = 0;
      //pBlock->ScaleFactor[k][j] = 0;
    }
    ippsSet_32s(0x7FFFFFFF, pBlock->nb_long[k][0], MAX_PPT_LONG);
    ippsSet_32s(0x7FFFFFFF, pBlock->nb_long[k][1], MAX_PPT_LONG);
    pBlock->nb_longScaleFactor[k] = 0x7FFFFFF;
  }

  for (k = 0; k < 2; k++) {
    for (j = 0; j < 3; j++) {
      for (i = 0; i < 8; i++) {
        ippsSet_16s(1, pBlock->r_short[k][j][i], 128);
        ippsSet_16s(1, pBlock->re_short[k][j][i], 128);
        ippsSet_16s(0, pBlock->im_short[k][j][i], 128);
      }
    }
  }

  for (k = 0; k < 2; k++) {
    ippsSet_32s(0, pBlock->smr_long[k], MAX_SFB);
    ippsSet_32s(0, pBlock->smr_short[k], MAX_SFB);
  }
}

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

void aaciencFreePsychoacousticCom(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);
  }
}

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

static void aaciencPsy_block_def(sPsychoacousticBlock* pBlock,
                                 sPsychoacousticBlockCom* pBlockCom,
                                 Ipp32s *ms_pwr,
                                 Ipp32s *ms_pwr_Scalef,
                                 Ipp32s *PE,
                                 Ipp32s ch,
                                 Ipp32s ind)
{
  Ipp32s  s_en[8];
  Ipp32s  min, max;

  pBlock->curr_frame_PE = pBlock->next_frame_PE;

  aaciencPsy_long_window(pBlock, pBlockCom, ms_pwr, ms_pwr_Scalef, PE, ch, ind);
  aaciencPsy_short_window(pBlock, pBlockCom, s_en, ch, ind);

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

  /* part 1 */
  if (pBlock->next_frame_PE > 5800) {
    pBlock->next_desired_block_type[ind] = EIGHT_SHORT_SEQUENCE;
  } else if (max > 25 * min) {
    pBlock->next_desired_block_type[ind] = EIGHT_SHORT_SEQUENCE;
  } else if ((max > 10 * min) && (PE[0] > 1900)) {
    pBlock->next_desired_block_type[ind] = EIGHT_SHORT_SEQUENCE;
  } else {
    pBlock->next_desired_block_type[ind] = ONLY_LONG_SEQUENCE;
  }
}

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

void aaciencPsychoacoustic(sPsychoacousticBlock** pBlock,
                           sPsychoacousticBlockCom* pBlockCom,
                           Ipp32s ms_thr,
                           Ipp32s numCh)
{
  Ipp32s *stereo_mode = &pBlock[0]->stereo_mode[pBlockCom->nb_curr_index];
  Ipp32s coef, abs_coef, ms_pwr[2], ms_pwr_Scalef[2], PE[2][2];
  Ipp32s ch, ms, shift;

  for (ch = 0; ch < numCh; ch++) {
    aaciencPsy_block_def(pBlock[ch], pBlockCom, &ms_pwr[ch],
                         &ms_pwr_Scalef[ch], &PE[0][ch], ch, 0);
  }

  if (stereo_mode[0] == AAC_MS_STEREO || stereo_mode[0] == AAC_JOINT_STEREO) {
    Ipp16s bufL[2][1024];
    Ipp16s bufR[2][1024];
    Ipp16s *ptrL, *ptrR;
    Ipp32s k, w;

    for (w = 0; w < 2; w++) {
      ptrL = pBlockCom->input_data[0][w];
      ptrR = pBlockCom->input_data[1][w];

      for (k = 0; k < 1024; k++) {
        bufL[w][k] = (Ipp16s)(((Ipp32s)ptrL[k] + (Ipp32s)ptrR[k]) >> 1);
        bufR[w][k] = (Ipp16s)(((Ipp32s)ptrL[k] - (Ipp32s)ptrR[k]) >> 1);
      }

      pBlockCom->input_data[0][w] = bufL[w];
      pBlockCom->input_data[1][w] = bufR[w];
    }

    for (ch = 0; ch < 2; ch++) {
      aaciencPsy_block_def(pBlock[ch], pBlockCom, &ms_pwr[ch],
                           &ms_pwr_Scalef[ch], &PE[1][ch], ch, 1);
    }

    for (k = 0; k < 2; k++) {
      if (pBlock[0]->next_desired_block_type[k] !=
        pBlock[1]->next_desired_block_type[k]) {
          pBlock[0]->next_desired_block_type[k] =
            pBlock[1]->next_desired_block_type[k] = EIGHT_SHORT_SEQUENCE;
        }
    }

    if (ms_pwr_Scalef[0] > ms_pwr_Scalef[1]) {
      shift = ms_pwr_Scalef[0] - ms_pwr_Scalef[1];
      if (shift > 31) shift = 31;
      ms_pwr[1] >>= shift;
    } else {
      shift = ms_pwr_Scalef[1] - ms_pwr_Scalef[0];
      if (shift > 31) shift = 31;
      ms_pwr[0] >>= shift;
    }

    coef = ms_pwr[0] + ms_pwr[1]; /* coef is less than 2 * 1024 * 32768 */
    if (coef > 0) {
      coef = (ms_pwr[0] * 16) / coef; /* Q4 */
    } else {
      coef = 8;
    }

    abs_coef = coef - 8;
    if (abs_coef < 0) abs_coef = -abs_coef;

    if (stereo_mode[0] == AAC_JOINT_STEREO) {
      if (((PE[1][0] + PE[1][1]) < ((11 * (PE[0][0] + PE[0][1])) >> 4)) ||
           abs_coef > ms_thr)
        stereo_mode[0] = AAC_MS_STEREO;
      else
        stereo_mode[0] = AAC_LR_STEREO;
    }
    pBlock[0]->ms_coef[pBlockCom->nb_curr_index] = coef;
  }

  ms = stereo_mode[0] == AAC_MS_STEREO ? 1 : 0;

  for (ch = 0; ch < numCh; ch++) {
    Ipp32s next_desired_block_type = pBlock[ch]->next_desired_block_type[ms];

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