aac_dec_stream_elements.c

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

  if (pElement->stream.window_sequence != EIGHT_SHORT_SEQUENCE) {
    pData->sfb_offset = pElement->stream.sfb_offset_long_window;
  } else {
    pData->sfb_offset = pElement->stream.sfb_offset_short_window;
  }

  pData->cge[0] = 1;
  pElement->cc_fact[0][0][0] = 0;

  for (c = 1; c < pData->num_gain_element_lists; c++) {
    if (pData->ind_sw_cce_flag) {
      pData->cge[c] = 1;
    } else {
      GET_BITS(pBS, pData->cge[c], 1, Ipp32s)
    }

    if (pData->cge[c]) {
      pSrc = (Ipp8u *)pBS->pCurrent_dword + ((32 - pBS->nBit_offset) >> 3);
      bitoffset = (32 - pBS->nBit_offset) & 0x7;
      ippsVLCDecodeOne_1u16s(&pSrc, &bitoffset, &t, pVLCDecSpec);
      pElement->cc_fact[c][0][0] = t - SF_MID;
      pBS->pCurrent_dword = (Ipp32u *)(pSrc - ((Ipp32s)(pSrc) & 3));
      pBS->dword = BSWAP(pBS->pCurrent_dword[0]);
      pBS->nBit_offset =
        32 - ((pSrc - (Ipp8u *)pBS->pCurrent_dword) << 3) - bitoffset;
    } else {
      dec_scale_factor_data(&pElement->stream, pElement->cc_fact[c], 0,
                            pElement->stream.global_gain - 90, pBS);
    }
  }

  if (pElement->crc_enable) {
    Ipp32s len;
    Ipp32u crc = (Ipp32u)pElement->crc;

    GET_BITS_COUNT(pBS, decodedBits2)

    len = decodedBits2 - decodedBits0;
    if (len > 192) len = 192;
    bs_CRC_update(crc_ptr, crc_offset, len, &crc);

    if (len < 192)
      bs_CRC_update_zero(192 - len, &crc);

    pElement->crc = (Ipp32s)crc;
  }

  return 0;
}

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

Ipp32s dec_data_stream_element(sData_stream_element *pData,
                               sBitsreamBuffer *pBS)
{
  Ipp32s  data_byte_align_flag;
  Ipp32s  count;
  Ipp32s  cnt;
  Ipp32s  i;

  GET_BITS(pBS, pData->element_instance_tag, 4, Ipp32s)
  GET_BITS(pBS, data_byte_align_flag, 1, Ipp32s)
  GET_BITS(pBS, count, 8, Ipp32s)
  cnt = count;
  if (cnt == 255) {
    GET_BITS(pBS, count, 8, Ipp32s)
    cnt += count;
  }
  if (data_byte_align_flag) {
    Byte_alignment(pBS);
  }
  for (i = 0; i < cnt; i++) {
    GET_BITS(pBS, pData->data_stream_byte[i], 8, Ipp8s)
  }
  return 0;
}

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

static
Ipp32s dec_extension_payload(sSBRDecComState * pSBRItem,
                             Ipp32s *pNumFillSbr,
                             sDynamic_range_info *pInfo,
                             sBitsreamBuffer *pBS,
                             Ipp32s cnt,
                             eSBR_SUPPORT flag_SBR_support_lev)
{
  Ipp32s  extension_type = - 123;
  Ipp32s  ret_value;
  Ipp32s  fill_nibble;
  Ipp32s  fill_byte;
  Ipp32s  i;
  Ipp32s  other_bits;
  //Ipp32s  flag_SBR_enable = 1;

  ret_value = 0;

  if( SBR_ENABLE == flag_SBR_support_lev ){
    GET_BITS(pBS, extension_type, 4, Ipp32s)
    pSBRItem->cnt_bit -= 4;
  }

  switch (extension_type) {
  case EXT_DYNAMIC_RANGE:
    ret_value = dec_dynamic_range_info(pInfo, pBS);
    break;

  case EXT_SBR_DATA:
    *pNumFillSbr += 1;
    ret_value = sbr_extension_data(pSBRItem->id_aac, 0, pSBRItem, pBS, cnt);

    /* diagnostic */
    if (SBR_ERR_REQUIREMENTS == ret_value) {
      pSBRItem->sbrFlagError = SBR_ERR_REQUIREMENTS;
    }
    break;

  case EXT_SBR_DATA_CRC:
    *pNumFillSbr += 1;
    ret_value = sbr_extension_data(pSBRItem->id_aac, 1, pSBRItem, pBS, cnt);
    /* diagnostic */
    if (SBR_ERR_REQUIREMENTS == ret_value) {
      pSBRItem->sbrFlagError = SBR_ERR_REQUIREMENTS;
    }
    break;

  case EXT_FILL_DATA:
    GET_BITS(pBS, fill_nibble, 4, Ipp32s)
    for (i = 0; i < cnt - 1; i++) {
      GET_BITS(pBS, fill_byte, 8, Ipp32s)
    }
    ret_value = cnt;
    break;
  default:

    if( SBR_ENABLE == flag_SBR_support_lev ){
      for (i = 0; i < 8 * (cnt - 1) + 4; i++) {
        GET_BITS(pBS, other_bits, 1, Ipp32s)
      }
    } else {
      for (i = 0; i < (cnt ); i++) {
        GET_BITS(pBS, other_bits, 8, Ipp32s)
      }
    }

    ret_value = cnt;
    break;
  }

  /******************************************************
   * ret_value - positive, number of bit has been read
   * but...
   * if there is error,
   * then ret_value = SBR_ERR_REQUIREMENTS
   ******************************************************/
  return ret_value;
}

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

Ipp32s dec_fill_element(sSBRDecComState *pSBRItem,
                        //sPSDecComState*     pPSItem,
                        Ipp32s *cnt_fill_sbr_element,
                        sDynamic_range_info *pInfo,
                        sBitsreamBuffer * pBS,
                        eSBR_SUPPORT flag_SBR_support_lev)
{
  Ipp32s  cnt;
  Ipp32s  ret;

  GET_BITS(pBS, cnt, 4, Ipp32s)

  if (cnt == 15) {
    Ipp32s tmp;

    GET_BITS(pBS, tmp, 8, Ipp32s)
    cnt += tmp - 1;
  }
  pSBRItem->cnt_bit = cnt * 8;

  /******************************************************
   * ret - positive value, number of bit has been read
   * but...
   * if there is error,
   * then ret = SBR_ERR_REQUIREMENTS
   ******************************************************/
  while (cnt > 0) {
    ret = dec_extension_payload(pSBRItem,
                                //pPSItem,
                                cnt_fill_sbr_element,
                                pInfo,
                                pBS,
                                cnt,
                                flag_SBR_support_lev);

    if ( ret < 0 )
      return SBR_ERR_REQUIREMENTS;
    else
      cnt -= ret;
  }

  return 0;
}

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

Ipp32s dec_excluded_channels(sExcluded_channels *pData,
                             sBitsreamBuffer *pBS)
{
  Ipp32s  n, i;

  n = 0;

  pData->num_excl_chan = 7;
  for (i = 0; i < 7; i++) {
    GET_BITS(pBS, pData->exclude_mask[i], 1, Ipp8u)
    n++;
  }

  GET_BITS(pBS, pData->additional_excluded_chns[n - 1], 1, Ipp8u)
  while (pData->additional_excluded_chns[n - 1] == 1) {
    for (i = pData->num_excl_chan; i < pData->num_excl_chan + 7; i++) {
      GET_BITS(pBS, pData->exclude_mask[i], 1, Ipp8u)
    }
    n++;
    /* diagnostic */
    if (n > 10) return -1;
    pData->num_excl_chan += 7;
    GET_BITS(pBS, pData->additional_excluded_chns[n - 1], 1, Ipp8u)
  }
  return n;
}

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

Ipp32s dec_dynamic_range_info(sDynamic_range_info *pInfo,
                              sBitsreamBuffer *pBS)
{
  Ipp32s  n, i;

  n = 1;

  pInfo->drc_num_bands = 1;
  GET_BITS(pBS, pInfo->pce_tag_present, 1, Ipp32s)

  if (pInfo->pce_tag_present == 1) {
    GET_BITS(pBS, pInfo->pce_innstance_tag, 4, Ipp32s)
    GET_BITS(pBS, pInfo->drc_tag_reserved_bits, 4, Ipp32s)
    n++;
  }

  GET_BITS(pBS, pInfo->excluded_chns_present, 1, Ipp32s)

  if (pInfo->excluded_chns_present == 1) {
    Ipp32s tmp_res = dec_excluded_channels(&pInfo->ec_data, pBS);

    if (tmp_res < 0) {
      return -1;
    }
    n += tmp_res;
  }

  GET_BITS(pBS, pInfo->drc_bands_present, 1, Ipp32s)
  if (pInfo->drc_bands_present == 1) {
    GET_BITS(pBS, pInfo->drc_band_incr, 4, Ipp32s)
    GET_BITS(pBS, pInfo->drc_bands_reserved_bits, 4, Ipp32s)
    n++;

    pInfo->drc_num_bands += pInfo->drc_band_incr;

    for (i = 0; i < pInfo->drc_num_bands; i++) {
      GET_BITS(pBS, pInfo->drc_band_top[i], 8, Ipp32s)
      n++;
    }
  }

  GET_BITS(pBS, pInfo->prog_ref_level_present, 1, Ipp32s)

  if (pInfo->prog_ref_level_present == 1) {
    GET_BITS(pBS, pInfo->prog_ref_level, 7, Ipp32s)
    GET_BITS(pBS, pInfo->prog_ref_level_reserved_bits, 1, Ipp32s)
    n++;
  }

  for (i = 0; i < pInfo->drc_num_bands; i++) {
    GET_BITS(pBS, pInfo->dyn_rng_sgn[i], 1, Ipp32s)
    GET_BITS(pBS, pInfo->dyn_rng_ctl[i], 7, Ipp32s)
    n++;
  }

  return n;
}

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

Ipp32s dec_gain_control_data(s_SE_Individual_channel_stream *pData,
                             sBitsreamBuffer *pBS)
{
  Ipp32s  bd, ad, wd;

  GET_BITS(pBS, pData->max_band, 2, Ipp32s)

  if (pData->window_sequence == ONLY_LONG_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 1; wd++) {
        GET_BITS(pBS, pData->SSRInfo[bd][wd].adjust_num, 3, Ipp32s)
        for (ad = 0; ad < pData->SSRInfo[bd][wd].adjust_num; ad++) {
          GET_BITS(pBS, pData->SSRInfo[bd][wd].alevcode[ad], 4, Ipp32s)
          GET_BITS(pBS, pData->SSRInfo[bd][wd].aloccode[ad], 5, Ipp32s)
        }
      }
    }
  } else if (pData->window_sequence == LONG_START_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 2; wd++) {
        GET_BITS(pBS, pData->SSRInfo[bd][wd].adjust_num, 3, Ipp32s)
        for (ad = 0; ad < pData->SSRInfo[bd][wd].adjust_num; ad++) {
          GET_BITS(pBS, pData->SSRInfo[bd][wd].alevcode[ad], 4, Ipp32s)
          if (wd == 0) {
            GET_BITS(pBS, pData->SSRInfo[bd][wd].aloccode[ad], 4, Ipp32s)
          } else {
            GET_BITS(pBS, pData->SSRInfo[bd][wd].aloccode[ad], 2, Ipp32s)
          }
        }
      }
    }
  } else if (pData->window_sequence == EIGHT_SHORT_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 8; wd++) {
        GET_BITS(pBS, pData->SSRInfo[bd][wd].adjust_num, 3, Ipp32s)
        for (ad = 0; ad < pData->SSRInfo[bd][wd].adjust_num; ad++) {
          GET_BITS(pBS, pData->SSRInfo[bd][wd].alevcode[ad], 4, Ipp32s)
          GET_BITS(pBS, pData->SSRInfo[bd][wd].aloccode[ad], 2, Ipp32s)
        }
      }
    }
  } else if (pData->window_sequence == LONG_STOP_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 2; wd++) {
        GET_BITS(pBS, pData->SSRInfo[bd][wd].adjust_num, 3, Ipp32s)
        for (ad = 0; ad < pData->SSRInfo[bd][wd].adjust_num; ad++) {
          GET_BITS(pBS, pData->SSRInfo[bd][wd].alevcode[ad], 4, Ipp32s)
          if (wd == 0) {
            GET_BITS(pBS, pData->SSRInfo[bd][wd].aloccode[ad], 4, Ipp32s)
          } else {
            GET_BITS(pBS, pData->SSRInfo[bd][wd].aloccode[ad], 5, Ipp32s)
          }
        }
      }
    }
  }

  return 0;
}

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

void save_gain_control_data(Ipp32s ch,
                            s_SE_Individual_channel_stream *pData,
                            AACDec_com *state_com)
{
  Ipp32s  bd, ad, wd, max_wd = 0;

  if (pData->gain_control_data_present) {
    if (pData->window_sequence == ONLY_LONG_SEQUENCE) {
      max_wd = 1;
    } else if (pData->window_sequence == LONG_START_SEQUENCE) {
      max_wd = 2;
    } else if (pData->window_sequence == EIGHT_SHORT_SEQUENCE) {
      max_wd = 8;
    } else if (pData->window_sequence == LONG_STOP_SEQUENCE) {
      max_wd = 2;
    }

    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < max_wd; wd++) {
        state_com->SSRInfo[ch][bd][wd].adjust_num = pData->SSRInfo[bd][wd].adjust_num;
        for (ad = 0; ad < pData->SSRInfo[bd][wd].adjust_num; ad++) {
          state_com->SSRInfo[ch][bd][wd].alevcode[ad] = pData->SSRInfo[bd][wd].alevcode[ad];
          state_com->SSRInfo[ch][bd][wd].aloccode[ad] = pData->SSRInfo[bd][wd].aloccode[ad];
        }
      }
    }
  }
}

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

Ipp32s ics_apply_pulse_I(s_SE_Individual_channel_stream *p_data)
{
  Ipp32s  i, k;

  k = p_data->sfb_offset_long_window[p_data->pulse_start_sfb];

  for (i = 0; i <= p_data->number_pulse; i++) {
    k += p_data->pulse_offset[i];
    if (p_data->spectrum_data[k] > 0) {
      p_data->spectrum_data[k] = p_data->spectrum_data[k] + (Ipp16s)p_data->pulse_amp[i];
    } else {
      p_data->spectrum_data[k] = p_data->spectrum_data[k] - (Ipp16s)p_data->pulse_amp[i];
    }

  }
  return 0;
}