aac_dec_api_fp.c

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

  psInitDecoder_32f( &(state->psState), pMem );

  return AAC_OK;
}

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

AACStatus aacdecUpdateObjMemMap(AACDec *state, Ipp32s mShift)
{
  Ipp32s  i;

  //AACDEC_UPDATE_PTR(IppsMDCTInvSpec_32f, state->m_filterbank.p_mdct_inv_long, mShift)
  //AACDEC_UPDATE_PTR(IppsMDCTInvSpec_32f, state->m_filterbank.p_mdct_inv_short, mShift)
  //AACDEC_UPDATE_PTR(Ipp8u, state->m_filterbank.p_buffer_inv, mShift)

  //AACDEC_UPDATE_PTR(IppsMDCTFwdSpec_32f, state->m_filterbank.p_mdct_fwd_long, mShift)
  //AACDEC_UPDATE_PTR(IppsMDCTFwdSpec_32f, state->m_filterbank.p_mdct_fwd_short, mShift)
  //AACDEC_UPDATE_PTR(Ipp8u, state->m_filterbank.p_buffer_fwd, mShift)

  if (state->com.m_audio_object_type == AOT_AAC_MAIN) {
    for (i = 0; i < CH_MAX + COUPL_CH_MAX; i++) {
      AACDEC_UPDATE_PTR(void, state->pFDPState[i], mShift)
    }
  }
  return AAC_OK;
}

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

AACStatus aacdecUpdateStateMemMap(AACDec *state, Ipp32s mShift)
{
  Ipp32s  i;

  if (!state)
    return AAC_NULL_PTR;

  for (i = 0; i < 16; i++) {
    AACDEC_UPDATE_PTR(void, state->com.huffman_tables[i], mShift)
  }
  for (i = 0; i < 10; i++) {
    AACDEC_UPDATE_PTR(IppsVLCDecodeSpec_32s, state->com.sbrHuffTables[i], mShift)
  }
  for (i = 0; i < 10; i++) {
    AACDEC_UPDATE_PTR(IppsVLCDecodeSpec_32s, state->psState.comState.psHuffTables[i], mShift)
  }

  AACDEC_UPDATE_PTR(Ipp8u, state->pWorkBuffer, mShift)

  (state->com.m_sce).stream.p_huffman_tables = (void **)&(state->com.huffman_tables[0]);
  (state->com.m_cpe).streams[0].p_huffman_tables = (void **)&(state->com.huffman_tables[0]);
  (state->com.m_cpe).streams[1].p_huffman_tables = (void **)&(state->com.huffman_tables[0]);
  (state->com.m_cce).stream.p_huffman_tables = (void **)&(state->com.huffman_tables[0]);
  (state->com.m_lfe).stream.p_huffman_tables = (void **)&(state->com.huffman_tables[0]);

  sbrdecUpdateMemMap(state, mShift);
  psdecUpdateMemMap (&(state->psState), mShift);

  return AAC_OK;
}

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

#define RETURN_AAC_BAD_STREAM                                     \
{                                                                 \
  GET_BITS_COUNT(pBS, (*decodedBytes))                            \
  *decodedBytes = (*decodedBytes + 7) >> 3;                       \
  state_com->m_channel_number = state_com->m_channel_number_save; \
  state_com->m_is_chmap_valid = save_m_is_chmap_valid;            \
  state_com->m_is_pce_valid = save_m_is_pce_valid;                \
  return AAC_BAD_STREAM;                                          \
}

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

static Ipp32s aacGetChannel(Ipp32s id,
                            Ipp32s tag,
                            Ipp32s element_number,
                            sEl_map_item elmap[])
{
  Ipp32s i;
  for (i = 0; i < element_number; i++) {
    if ((elmap[i].id == id) && (elmap[i].tag == tag)) {
      return elmap[i].ch;
    }
  }
  return -1;
}

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

AACStatus aacdecGetFrame(Ipp8u  *inPointer,
                         Ipp32s *decodedBytes,
                         Ipp16s *outPointer,
                         Ipp32s outBufferSize,
                         AACDec *state)
{
  sData_stream_element m_data;
  sDynamic_range_info m_drc_info;
  sEl_map_item m_elmap[EL_TAG_MAX];

  sBitsreamBuffer BS;
  sBitsreamBuffer *pBS = &BS;
  AACDec_com      *state_com;

  Ipp32s  el_num;
  Ipp32s  ch_num;
  Ipp32s  order_counter = 0;
  Ipp32s  cur_frame_el_num = 0;
  Ipp32s  save_m_is_chmap_valid;
  Ipp32s  save_m_is_pce_valid;

  Ipp32s  id;
  Ipp32s  tag = 0;
  Ipp32s  ch = 0;
  Ipp32s  ncch = 0;
  Ipp32s  tag_counter[4][EL_TAG_MAX];

/* HE-AAC param */
  Ipp32s  cnt_fill_sbr_element = 0;
  Ipp32s  cnt_idaac_sbr_element = 0;
  Ipp32s  sbrFlagPresentLFE = 0;
  Ipp32s  NumRealCh = 0;
  Ipp32s  ch_counter;
  Ipp32s  errSBRParser = 0;
  Ipp32s  criterionPS  = 0;

  s_tns_data tns_data0;
  Ipp32s  i, j;

  if (!inPointer || !outPointer)
    return AAC_NULL_PTR;

  for (i = 0; i < 4; i++) {
    for (j = 0; j < EL_TAG_MAX; j++) {
      tag_counter[i][j] = 0;
    }
  }

  state_com = &(state->com);
  el_num = state_com->m_element_number;
  ch_num = state_com->m_channel_number_all;

  save_m_is_chmap_valid = state_com->m_is_chmap_valid;
  save_m_is_pce_valid = state_com->m_is_pce_valid;

  /* state_com->decodedBytes != 0 means that this frame   */
  /* has been decoded already but output buffer was small */
  if (state_com->decodedBytes == 0) {

    GET_INIT_BITSTREAM(pBS, inPointer)

    // init
    state->com.m_up_sample  = 1;

    GET_BITS(pBS, id, 3, Ipp32s)
    while (id != ID_END) {
      if (CH_MAX - 1 < NumRealCh)
        RETURN_AAC_BAD_STREAM;
      switch (id) {
      case ID_SCE:
        /* may be there is HE-AAC element */
        state->sbrBlock[cnt_idaac_sbr_element++].comState.id_aac = ID_SCE;
        NumRealCh++;

        /* Parsing bitstream */
        (state_com->m_sce).crc = state_com->crc;
        (state_com->m_sce).crc_enable = state_com->crc_enable;
        if (dec_sce_channel_element(&(state_com->m_sce), pBS, state_com->m_audio_object_type) < 0)
          RETURN_AAC_BAD_STREAM;
        state_com->crc = (state_com->m_sce).crc;
        tag = (state_com->m_sce).element_instance_tag;
        /* several equal tags are supported */
        tag_counter[0][tag] += 1;
        tag += ((tag_counter[0][tag] - 1) * EL_TAG_MAX);
        break;
      case ID_CPE:
        /* may be there is HE-AAC element */
      state->sbrBlock[cnt_idaac_sbr_element++].comState.id_aac = ID_CPE;
        NumRealCh += 2;

        /* Parsing bitstream */
        (state_com->m_cpe).crc = state_com->crc;
        (state_com->m_cpe).crc_enable = state_com->crc_enable;
        if (dec_cpe_channel_element(&(state_com->m_cpe), pBS, state_com->m_audio_object_type) < 0)
          RETURN_AAC_BAD_STREAM;
        state_com->crc = (state_com->m_cpe).crc;
        tag = (state_com->m_cpe).element_instance_tag;
        /* several equal tags are supported */
        tag_counter[1][tag] += 1;
        tag += ((tag_counter[1][tag] - 1) * EL_TAG_MAX);
        break;
      case ID_CCE:
        if (COUPL_CH_MAX - 1 < ncch)
          RETURN_AAC_BAD_STREAM;

        (state_com->m_cce).crc = state_com->crc;
        (state_com->m_cce).crc_enable = state_com->crc_enable;
        if (dec_coupling_channel_element(&(state_com->m_cce), &(state_com->m_cdata[ncch]),
              pBS, state_com->m_audio_object_type) < 0)
          RETURN_AAC_BAD_STREAM;
        state_com->crc = (state_com->m_cce).crc;
        tag = (state_com->m_cce).element_instance_tag;
        /* several equal tags are supported */
        tag_counter[2][tag] += 1;
        tag += ((tag_counter[2][tag] - 1) * EL_TAG_MAX);
        break;
      case ID_LFE:
        /* may be there is HE-AAC element */
        if (CH_MAX - 1 < cnt_idaac_sbr_element)
          RETURN_AAC_BAD_STREAM;

        state->sbrBlock[cnt_idaac_sbr_element++].comState.id_aac = ID_LFE;

        if (cnt_fill_sbr_element > 0) {
          sbrFlagPresentLFE++;

          if ( CH_MAX - 1 < cnt_fill_sbr_element )
            RETURN_AAC_BAD_STREAM;

          cnt_fill_sbr_element++;
        }

        /* Parsing bitstream */
        (state_com->m_lfe).crc = state_com->crc;
        (state_com->m_lfe).crc_enable = state_com->crc_enable;
        if (dec_lfe_channel_element(&(state_com->m_lfe), pBS, state_com->m_audio_object_type) < 0)
          RETURN_AAC_BAD_STREAM;
        state_com->crc = (state_com->m_lfe).crc;
        tag = (state_com->m_lfe).element_instance_tag;
        /* several equal tags are supported */
        tag_counter[3][tag] += 1;
        tag += ((tag_counter[3][tag] - 1) * EL_TAG_MAX);
        NumRealCh++;
        break;
      case ID_DSE:
        dec_data_stream_element(&m_data, pBS);
        break;
      case ID_PCE:
        {
          Ipp32u  *crc_ptr = 0;
          Ipp32s  crc_offset = 0;
          Ipp32s  decodedBits0 = 0;
          Ipp32s  decodedBits2 = 0;

          if (state_com->crc_enable) {
            crc_ptr = pBS->pCurrent_dword;
            crc_offset = pBS->nBit_offset;
            GET_BITS_COUNT(pBS, decodedBits0)
          }

          dec_program_config_element(&(state_com->m_pce), pBS);

          if (state_com->crc_enable) {
            Ipp32u crc = (Ipp32u)state_com->crc;
            GET_BITS_COUNT(pBS, decodedBits2)
            bs_CRC_update(crc_ptr, crc_offset, decodedBits2 - decodedBits0, &crc);
            state_com->crc = (Ipp32s)crc;
          }
          state_com->m_is_chmap_valid = 0;
          state_com->m_is_pce_valid = 1;
        }
        break;
      case ID_FIL:
/*
* NOTES:
* (1)SBR FILL ELEMENT there is for SCE & CPE modes only.
* (2)If AOT AAC is MAIN, LC or LTP
* then
*   <SCE> <FIL <EXT_SBR_DATA(SCE)>> // center
*   <CPE> <FIL <EXT_SBR_DATA(CPE)>> // front L/R
*   <CPE> <FIL <EXT_SBR_DATA(CPE)>> // back L/R
*   <LFE> // sub
*   <END> // (end of raw data block)
*
* (3)If AOT AAC is ER LC or ER LTP
* then
*   <SCE> <CPE> <CPE> <LFE> <EXT <SBR(SCE)> <SBR(CPE)> <SBR(CPE)>>
*
* (4) may be more then one FILL ELEMENT, for ex:
*  <SCE> <FILL.. <CPE> <FILL.. <CPE> <FILL..><FILL..> <LFE><FILL..><FILL..><FILL..>
*/
        if ( CH_MAX - 1 < cnt_fill_sbr_element )
          RETURN_AAC_BAD_STREAM;

      state->sbrBlock[cnt_fill_sbr_element].comState.sbr_freq_sample =
          state_com->m_sampling_frequency * 2;

        if (state->com.m_sampling_frequency_index >= 3)
        state->sbrBlock[cnt_fill_sbr_element].comState.sbr_freq_indx =
            state->com.m_sampling_frequency_index - 3;

        /* PARAMETRIC STEREO PATCH */
        criterionPS = 0;
        if( 0x1 & state_com->m_flag_PS_support_lev){

          if( 0 == cnt_fill_sbr_element &&
              state->sbrBlock[cnt_fill_sbr_element].comState.id_aac == ID_SCE ){
            criterionPS = 1;
          }
        }

        if( criterionPS){
          state->sbrBlock[cnt_fill_sbr_element].comState.psState = &(state->psState.comState);
        } else {
          state->sbrBlock[cnt_fill_sbr_element].comState.psState = NULL;
        }
      errSBRParser = dec_fill_element(
                        &(state->sbrBlock[cnt_fill_sbr_element].comState),
                        &cnt_fill_sbr_element,
                        &m_drc_info,
                        pBS,
                        //SBR_ENABLE
                        state->com.m_flag_SBR_support_lev
                        );

        /*************************************************************
        * if there is problem with HE-AAC parser then QUIT
        *************************************************************/
        if ( errSBRParser )
          RETURN_AAC_BAD_STREAM

        break;
      }

      if ((ID_DSE > id) && (ID_CCE != id)) {
        ch = aacGetChannel(id, tag, el_num, state_com->m_elmap);

        if (ch < 0) {
          if (el_num >= CH_MAX)
            RETURN_AAC_BAD_STREAM
          state_com->m_elmap[el_num].id = (Ipp16s)id;
          state_com->m_elmap[el_num].tag = (Ipp16s)tag;
          state_com->m_elmap[el_num].ch = (Ipp16s)ch_num;
          ch = ch_num;
          el_num++;
          ch_num++;
          if (ID_CPE == id) ch_num++;
        }

        m_elmap[cur_frame_el_num].id = (Ipp16s)id;
        m_elmap[cur_frame_el_num].tag = (Ipp16s)tag;
        m_elmap[cur_frame_el_num].ch = (Ipp16s)ch;


        cur_frame_el_num++;

        state_com->m_order[order_counter] = ch;
        order_counter++;

        if (ch >= CH_MAX)
          RETURN_AAC_BAD_STREAM

        if (ID_CPE == id) {
          state_com->m_order[order_counter] = ch+1;
          order_counter++;
          if (ch+1 >= CH_MAX)
            RETURN_AAC_BAD_STREAM
        }
      }

      switch (id) {
      case ID_SCE:

        state_com->m_curr_win_shape[ch] = (state_com->m_sce).stream.window_shape;
        state_com->m_curr_win_sequence[ch] = (state_com->m_sce).stream.window_sequence;

        if (0 != (state_com->m_sce).stream.pulse_data_present) {
          ics_apply_pulse_I(&(state_com->m_sce).stream);
        }
        ics_apply_scale_factors(&(state_com->m_sce).stream, state->m_spectrum_data[ch]);
        apply_pns(&(state_com->m_sce).stream, NULL, state->m_spectrum_data[ch], NULL, 1,
                  0, NULL, &(state_com->noiseState));

        deinterlieve(&(state_com->m_sce).stream, state->m_spectrum_data[ch]);

        ics_calc_tns_data(&(state_com->m_sce).stream, &(state->tns_data[ch]));

        if (AOT_AAC_MAIN == state_com->m_audio_object_type) {

          FDP(state->m_spectrum_data[ch], &(state_com->m_sce).stream,
              state->pFDPState[ch]);

        } else if (AOT_AAC_LTP == state_com->m_audio_object_type) {
          state->m_ltp.p_samples_1st_part = state->m_ltp_buf[ch][state_com->m_index_1st];
          state->m_ltp.p_samples_2nd_part = state->m_ltp_buf[ch][state_com->m_index_2nd];
          state->m_ltp.p_samples_3rd_part = state->m_ltp_buf[ch][state_com->m_index_3rd];
          state->m_ltp.prev_windows_shape = state_com->m_prev_win_shape[ch];

          state->m_ltp.p_filterbank_data = &(state->m_filterbank);
          state->m_ltp.p_tns_data = &(state->tns_data[ch]);

          ics_apply_ltp_I(&(state->m_ltp), &(state_com->m_sce).stream, state->m_spectrum_data[ch]);
        } else if (AOT_AAC_SSR == state_com->m_audio_object_type) {
          save_gain_control_data(ch, &(state_com->m_sce).stream, state_com);
        }

        //if (0 != state->tns_data[ch].m_tns_data_present) {
        //  ics_apply_tns_dec_I(&(state->tns_data[ch]), state->m_spectrum_data[ch]);
        //}
        break;
      case ID_CPE:

        state_com->m_curr_win_shape[ch] = (state_com->m_cpe).streams[0].window_shape;
        state_com->m_curr_win_sequence[ch] = (state_com->m_cpe).streams[0].window_sequence;
        state_com->m_curr_win_shape[ch + 1] = (state_com->m_cpe).streams[1].window_shape;
        state_com->m_curr_win_sequence[ch + 1] = (state_com->m_cpe).streams[1].window_sequence;

        if (0 != (state_com->m_cpe).streams[0].pulse_data_present) {
          ics_apply_pulse_I(&(state_com->m_cpe).streams[0]);