/src/libxaac/decoder/ixheaacd_init_config.c

Source
/******************************************************************************
 *                                                                            *
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>

#include "ixheaac_type_def.h"
#include "ixheaac_constants.h"
#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_defines.h"
#include "ixheaacd_memory_standards.h"
#include "ixheaacd_sbrdecsettings.h"
#include "ixheaacd_sbr_scale.h"
#include "ixheaacd_env_extr_part.h"
#include "ixheaacd_aac_rom.h"
#include "ixheaacd_common_rom.h"
#include "ixheaacd_sbr_rom.h"
#include "ixheaacd_pulsedata.h"
#include "ixheaacd_pns.h"

#include "ixheaacd_sbr_common.h"
#include "ixheaacd_drc_data_struct.h"
#include "ixheaacd_drc_dec.h"

#include "ixheaacd_lt_predict.h"
#include "ixheaacd_cnst.h"
#include "ixheaacd_ec_defines.h"
#include "ixheaacd_ec_struct_def.h"
#include "ixheaacd_channelinfo.h"
#include "ixheaacd_channel.h"
#include "ixheaacd_sbrdecoder.h"
#include "ixheaacd_audioobjtypes.h"
#include "ixheaacd_latmdemux.h"
#include "ixheaacd_aacdec.h"
#include "ixheaacd_sbr_common.h"

#include "ixheaacd_hybrid.h"
#include "ixheaacd_ps_dec.h"
#include "ixheaacd_qmf_dec.h"
#include "ixheaacd_mps_macro_def.h"
#include "ixheaacd_mps_struct_def.h"
#include "ixheaacd_mps_res_rom.h"
#include "ixheaacd_mps_aac_struct.h"
#include "ixheaacd_mps_polyphase.h"
#include "ixheaacd_config.h"
#include "ixheaacd_mps_dec.h"
#include "ixheaacd_struct_def.h"

#include "ixheaacd_config.h"
#include "ixheaacd_interface.h"
#include "ixheaacd_info.h"
#include "ixheaacd_struct.h"
#include "ixheaac_error_standards.h"

#include "ixheaacd_error_codes.h"

static const WORD32 sampling_rate_tbl[] = {
    96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025,
    8000,  7350,  0,     0,     57600, 51200, 40000, 38400, 34150, 28800, 25600,
    20000, 19200, 17075, 14400, 12800, 9600,  0,     0,     0};

UWORD32 ixheaacd_sbr_ratio(UWORD32 core_sbr_framelength_idx) {
  UWORD32 sbr_ratio_index = 0x0FF;

  switch (core_sbr_framelength_idx) {
    case 0:
    case 1:
      sbr_ratio_index = USAC_SBR_RATIO_NO_SBR;
      break;
    case 2:
      sbr_ratio_index = USAC_SBR_RATIO_INDEX_8_3;
      break;
    case 3:
      sbr_ratio_index = USAC_SBR_RATIO_INDEX_2_1;
      break;
    case 4:
      sbr_ratio_index = USAC_SBR_RATIO_INDEX_4_1;
      break;
  }

  return sbr_ratio_index;
}

static WORD32 ixheaacd_get_sample_freq_indx(WORD32 sampling_freq) {
  WORD32 index;
  const WORD32 tbl_size = sizeof(sampling_rate_tbl) / sizeof(WORD32) - 1;

  for (index = 0; index < tbl_size; index++) {
    if (sampling_rate_tbl[index] == sampling_freq) break;
  }
  return index;
}
UWORD32 ixheaacd_sbr_params(UWORD32 core_sbr_framelength_idx,
                            WORD32 *output_framelength, WORD32 *block_size,
                            WORD32 *output_samples, WORD32 *sample_rate_layer,
                            UWORD32 *sample_freq_indx) {
  UWORD32 sbr_ratio_index = 0x0FF;

  *output_framelength = -1;

  switch (core_sbr_framelength_idx) {
    case 0:
      sbr_ratio_index = USAC_SBR_RATIO_NO_SBR;
      *output_framelength = USAC_OUT_FRAMELENGTH_768;
      *block_size = 768;
      *output_samples = *block_size;
      break;
    case 1:
      sbr_ratio_index = USAC_SBR_RATIO_NO_SBR;
      *output_framelength = USAC_OUT_FRAMELENGTH_1024;
      *block_size = 1024;
      *output_samples = *block_size;
      break;
    case 2:
      sbr_ratio_index = USAC_SBR_RATIO_INDEX_8_3;
      *output_framelength = USAC_OUT_FRAMELENGTH_2048;
      *block_size = 768;
      *output_samples = (*block_size * 8) / 3;
      *sample_rate_layer = (*sample_rate_layer * 3) >> 3;
      break;
    case 3:
      sbr_ratio_index = USAC_SBR_RATIO_INDEX_2_1;
      *output_framelength = USAC_OUT_FRAMELENGTH_2048;
      *block_size = 1024;
      *output_samples = *block_size * 2;
      *sample_rate_layer = *sample_rate_layer >> 1;
      break;
    case 4:
      sbr_ratio_index = USAC_SBR_RATIO_INDEX_4_1;
      *output_framelength = USAC_OUT_FRAMELENGTH_4096;
      *block_size = 1024;
      *output_samples = *block_size * 4;
      *sample_rate_layer = *sample_rate_layer >> 2;
      break;
  }

  *sample_freq_indx = ixheaacd_get_sample_freq_indx(*sample_rate_layer);

  return sbr_ratio_index;
}

VOID ixheaacd_read_escape_value(ia_bit_buf_struct *it_bit_buff,
                                UWORD32 *ext_ele_value, UWORD32 no_bits1,
                                UWORD32 no_bits2, UWORD32 no_bits3) {
  UWORD32 value = 0;
  UWORD32 val_add = 0;
  UWORD32 max_val1 = (1 << no_bits1) - 1;
  UWORD32 max_val2 = (1 << no_bits2) - 1;

  value = ixheaacd_read_bits_buf(it_bit_buff, no_bits1);

  if (value == max_val1) {
    val_add = ixheaacd_read_bits_buf(it_bit_buff, no_bits2);

    value += val_add;

    if (val_add == max_val2) {
      val_add = ixheaacd_read_bits_buf(it_bit_buff, no_bits3);

      value += val_add;
    }
  }

  *ext_ele_value = value;
}

static IA_ERRORCODE ixheaacd_get_usac_chan_conf(ia_usac_config_struct *pstr_usac_config,
                        UWORD32 ch_config_index, ia_bit_buf_struct *it_bit_buff, WORD32 ec_flag)
{
  switch (ch_config_index) {
    case 1:
      pstr_usac_config->num_out_channels = 1;
      pstr_usac_config->output_channel_pos[0] = BS_OUTPUT_CHANNEL_POS_C;
      break;
    case 2:
      pstr_usac_config->num_out_channels = 2;
      pstr_usac_config->output_channel_pos[0] = BS_OUTPUT_CHANNEL_POS_L;
      pstr_usac_config->output_channel_pos[1] = BS_OUTPUT_CHANNEL_POS_R;
      break;
    case 8:
      pstr_usac_config->num_out_channels = 2;
      pstr_usac_config->output_channel_pos[0] = BS_OUTPUT_CHANNEL_POS_NA;
      pstr_usac_config->output_channel_pos[1] = BS_OUTPUT_CHANNEL_POS_NA;
      break;

    default:
      if (ec_flag)
        longjmp(*(it_bit_buff->xaac_jmp_buf),
            IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
      else
        return IA_FATAL_ERROR;
      break;
  }
  return IA_NO_ERROR;
}

VOID ixheaacd_sbr_config(ia_bit_buf_struct *it_bit_buff,
                         ia_usac_dec_sbr_config_struct *pstr_usac_sbr_config) {
  pstr_usac_sbr_config->harmonic_sbr = ixheaacd_read_bits_buf(it_bit_buff, 1);
  pstr_usac_sbr_config->bs_inter_tes = ixheaacd_read_bits_buf(it_bit_buff, 1);
  pstr_usac_sbr_config->bs_pvc = ixheaacd_read_bits_buf(it_bit_buff, 1);
  pstr_usac_sbr_config->dflt_start_freq =
      ixheaacd_read_bits_buf(it_bit_buff, 4);

  pstr_usac_sbr_config->dflt_stop_freq = ixheaacd_read_bits_buf(it_bit_buff, 4);
  pstr_usac_sbr_config->dflt_header_extra1 =
      ixheaacd_read_bits_buf(it_bit_buff, 1);
  pstr_usac_sbr_config->dflt_header_extra2 =
      ixheaacd_read_bits_buf(it_bit_buff, 1);

  if (pstr_usac_sbr_config->dflt_header_extra1) {
    pstr_usac_sbr_config->dflt_freq_scale =
        ixheaacd_read_bits_buf(it_bit_buff, 2);
    pstr_usac_sbr_config->dflt_alter_scale =
        ixheaacd_read_bits_buf(it_bit_buff, 1);
    pstr_usac_sbr_config->dflt_noise_bands =
        ixheaacd_read_bits_buf(it_bit_buff, 2);
  }

  if (pstr_usac_sbr_config->dflt_header_extra2) {
    pstr_usac_sbr_config->dflt_limiter_bands =
        ixheaacd_read_bits_buf(it_bit_buff, 2);
    pstr_usac_sbr_config->dflt_limiter_gains =
        ixheaacd_read_bits_buf(it_bit_buff, 2);
    pstr_usac_sbr_config->dflt_interpol_freq =
        ixheaacd_read_bits_buf(it_bit_buff, 1);
    pstr_usac_sbr_config->dflt_smoothing_mode =
        ixheaacd_read_bits_buf(it_bit_buff, 1);
  }
}

WORD32 ixheaacd_ext_element_config(
    ia_bit_buf_struct *it_bit_buff,
    ia_usac_dec_element_config_struct *pstr_usac_element_config,
    UWORD8 *ptr_usac_ext_ele_payload, WORD32 *ptr_usac_ext_ele_payload_len,
    WORD32 *preroll_flag) {
  UWORD32 usac_ext_element_type, usac_ext_element_config_length, flag;

  UWORD32 i;

  ixheaacd_read_escape_value(it_bit_buff, &(usac_ext_element_type), 4, 8, 16);

  ixheaacd_read_escape_value(it_bit_buff, &(usac_ext_element_config_length), 4,
                             8, 16);
  if (usac_ext_element_config_length >= 768) return -1;

  flag = ixheaacd_read_bits_buf(it_bit_buff, 1);

  *ptr_usac_ext_ele_payload_len = 0;

  if (flag) {
    ixheaacd_read_escape_value(
        it_bit_buff,
        (UWORD32 *)(&(pstr_usac_element_config->usac_ext_eleme_def_len)), 8, 16,
        0);
    pstr_usac_element_config->usac_ext_eleme_def_len += 1;

  } else {
    pstr_usac_element_config->usac_ext_eleme_def_len = 0;
  }

  pstr_usac_element_config->usac_ext_elem_pld_frag =
      ixheaacd_read_bits_buf(it_bit_buff, 1);

  switch (usac_ext_element_type) {
    case ID_EXT_ELE_FILL:
      break;
    case ID_EXT_ELE_AUDIOPREROLL:
      *preroll_flag = 1;
      break;
    case ID_EXT_ELE_UNI_DRC:
      for (i = 0; i < usac_ext_element_config_length; i++) {
        ptr_usac_ext_ele_payload[i] = ixheaacd_read_bits_buf(it_bit_buff, 8);
      }
      *ptr_usac_ext_ele_payload_len = usac_ext_element_config_length;
      break;

    default:
      if ((it_bit_buff->cnt_bits >> 3) < (WORD32)usac_ext_element_config_length)
        return -1;
      it_bit_buff->ptr_read_next += usac_ext_element_config_length;
      it_bit_buff->cnt_bits -= (usac_ext_element_config_length << 3);

      break;
  }

  return 0;
}

IA_ERRORCODE ixheaacd_mps212_config(
    ia_bit_buf_struct *it_bit_buff,
    ia_usac_dec_mps_config_struct *pstr_usac_mps212_config,
    WORD32 stereo_config_index) {
  pstr_usac_mps212_config->bs_freq_res = ixheaacd_read_bits_buf(it_bit_buff, 3);

  pstr_usac_mps212_config->bs_fixed_gain_dmx =
      ixheaacd_read_bits_buf(it_bit_buff, 3);

  pstr_usac_mps212_config->bs_temp_shape_config =
      ixheaacd_read_bits_buf(it_bit_buff, 2);

  pstr_usac_mps212_config->bs_decorr_config =
      ixheaacd_read_bits_buf(it_bit_buff, 2);
  if (pstr_usac_mps212_config->bs_decorr_config > MAX_DECOR_CONFIG_IDX)
    return IA_FATAL_ERROR;

  pstr_usac_mps212_config->bs_high_rate_mode =
      ixheaacd_read_bits_buf(it_bit_buff, 1);

  pstr_usac_mps212_config->bs_phase_coding =
      ixheaacd_read_bits_buf(it_bit_buff, 1);

  pstr_usac_mps212_config->bs_ott_bands_phase_present =
      ixheaacd_read_bits_buf(it_bit_buff, 1);

  if (pstr_usac_mps212_config->bs_ott_bands_phase_present) {
    pstr_usac_mps212_config->bs_ott_bands_phase =
        ixheaacd_read_bits_buf(it_bit_buff, 5);
    if (pstr_usac_mps212_config->bs_ott_bands_phase > MAX_PARAMETER_BANDS)
      return IA_FATAL_ERROR;
  }

  if (stereo_config_index > 1) {
    pstr_usac_mps212_config->bs_residual_bands =
        ixheaacd_read_bits_buf(it_bit_buff, 5);

    if (pstr_usac_mps212_config->bs_residual_bands > MAX_PARAMETER_BANDS)
      return IA_FATAL_ERROR;

    pstr_usac_mps212_config->bs_ott_bands_phase =
        max(pstr_usac_mps212_config->bs_ott_bands_phase,
            pstr_usac_mps212_config->bs_residual_bands);

    pstr_usac_mps212_config->bs_pseudo_lr =
        ixheaacd_read_bits_buf(it_bit_buff, 1);
  }

  if (pstr_usac_mps212_config->bs_temp_shape_config == 2)
    pstr_usac_mps212_config->bs_env_quant_mode =
        ixheaacd_read_bits_buf(it_bit_buff, 1);

  return IA_NO_ERROR;
}

IA_ERRORCODE ixheaacd_cpe_config(
    ia_bit_buf_struct *it_bit_buff,
    ia_usac_dec_element_config_struct *pstr_usac_element_config,
    WORD32 sbr_ratio_index) {
  pstr_usac_element_config->tw_mdct = ixheaacd_read_bits_buf(it_bit_buff, 1);
  pstr_usac_element_config->noise_filling =
      ixheaacd_read_bits_buf(it_bit_buff, 1);

  if (sbr_ratio_index > 0) {
    ixheaacd_sbr_config(it_bit_buff,
                        &(pstr_usac_element_config->str_usac_sbr_config));
    pstr_usac_element_config->stereo_config_index =
        ixheaacd_read_bits_buf(it_bit_buff, 2);

  } else {
    pstr_usac_element_config->stereo_config_index = 0;
  }

  if (pstr_usac_element_config->stereo_config_index > 0)
    return ixheaacd_mps212_config(
        it_bit_buff, &(pstr_usac_element_config->str_usac_mps212_config),
        pstr_usac_element_config->stereo_config_index);

  return IA_NO_ERROR;
}

WORD32 ixheaacd_decoder_config(
    ia_bit_buf_struct *it_bit_buff,
    ia_usac_decoder_config_struct *pstr_usac_decoder_config,
    WORD32 sbr_ratio_index, UINT32 *chan, WORD32 ec_flag) {
  UWORD32 elem_idx = 0;
  UWORD32 err = 0;
  WORD32 num_channels = 0;

  ixheaacd_read_escape_value(
      it_bit_buff, &(pstr_usac_decoder_config->num_elements), 4, 8, 16);
  pstr_usac_decoder_config->num_elements += 1;
  pstr_usac_decoder_config->preroll_flag = 0;

  if (pstr_usac_decoder_config->num_elements > USAC_MAX_ELEMENTS) {
    if (ec_flag) {
      pstr_usac_decoder_config->num_elements = USAC_MAX_ELEMENTS;
      longjmp(*(it_bit_buff->xaac_jmp_buf), IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
    } else {
      return IA_FATAL_ERROR;
    }
  }

  for (elem_idx = 0; elem_idx < pstr_usac_decoder_config->num_elements;
       elem_idx++) {
    ia_usac_dec_element_config_struct *pstr_usac_element_config =
        &(pstr_usac_decoder_config->str_usac_element_config[elem_idx]);

    pstr_usac_decoder_config->usac_element_type[elem_idx] =
        ixheaacd_read_bits_buf(it_bit_buff, 2);

    switch (pstr_usac_decoder_config->usac_element_type[elem_idx]) {
      case ID_USAC_SCE:
        num_channels++;
        pstr_usac_element_config->tw_mdct =
            ixheaacd_read_bits_buf(it_bit_buff, 1);
        pstr_usac_element_config->noise_filling =
            ixheaacd_read_bits_buf(it_bit_buff, 1);
        pstr_usac_element_config->stereo_config_index = 0;
        if (sbr_ratio_index > 0)
          ixheaacd_sbr_config(it_bit_buff,
                              &(pstr_usac_element_config->str_usac_sbr_config));

        break;

      case ID_USAC_CPE:
        num_channels += 2;
        if (ixheaacd_cpe_config(it_bit_buff, pstr_usac_element_config, sbr_ratio_index) !=
            IA_NO_ERROR) {
          if (ec_flag) {
            longjmp(*(it_bit_buff->xaac_jmp_buf),
                    IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
          } else {
            return IA_FATAL_ERROR;
          }
        }
        if (pstr_usac_element_config->stereo_config_index > 1 && *chan < 2) {
          if (ec_flag) {
            longjmp(*(it_bit_buff->xaac_jmp_buf),
                    IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
          } else {
            return IA_FATAL_ERROR;
          }
        }
        break;

      case ID_USAC_LFE:
        num_channels++;
        pstr_usac_element_config->tw_mdct = 0;
        pstr_usac_element_config->noise_filling = 0;
        pstr_usac_element_config->stereo_config_index = 0;
        break;

      case ID_USAC_EXT:
        err = ixheaacd_ext_element_config(
            it_bit_buff, pstr_usac_element_config,
            &pstr_usac_decoder_config->usac_ext_ele_payload_buf[elem_idx][0],
            &pstr_usac_decoder_config->usac_ext_ele_payload_len[elem_idx],
            &(pstr_usac_decoder_config->preroll_flag));

        if (pstr_usac_decoder_config->usac_ext_ele_payload_len[elem_idx] > 0) {
          pstr_usac_decoder_config->usac_ext_ele_payload_present[elem_idx] = 1;
        } else {
          pstr_usac_decoder_config->usac_ext_ele_payload_present[elem_idx] = 0;
        }
        if (err != 0) {
          if (ec_flag) {
            longjmp(*(it_bit_buff->xaac_jmp_buf),
                    IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
          } else {
            return IA_FATAL_ERROR;
          }
        }
        break;
      default:
        if (ec_flag) {
          longjmp(*(it_bit_buff->xaac_jmp_buf),
                  IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
        } else {
          return IA_FATAL_ERROR;
        }
        break;
    }
    if (num_channels > 2) {
      if (ec_flag) {
        longjmp(*(it_bit_buff->xaac_jmp_buf),
                IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
      } else {
        return IA_FATAL_ERROR;
      }
    }
  }
  return err;
}

WORD32 ixheaacd_config_extension(ia_bit_buf_struct *it_bit_buff,
    ia_usac_decoder_config_struct *pstr_usac_decoder_config, WORD32 ec_flag) {
  UWORD32 i, j;
  UWORD32 num_config_extensions;
  UWORD32 usac_config_ext_type, usac_config_ext_len;

  ixheaacd_read_escape_value(it_bit_buff, &(num_config_extensions), 2, 4, 8);
  num_config_extensions += 1;
  if (USAC_MAX_CONFIG_EXTENSIONS < num_config_extensions) {
    if (ec_flag) {
      longjmp(*(it_bit_buff->xaac_jmp_buf), IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
    } else {
      return IA_FATAL_ERROR;
    }
  }

  pstr_usac_decoder_config->num_config_extensions = num_config_extensions;
  memset(pstr_usac_decoder_config->usac_cfg_ext_info_len, 0,
         USAC_MAX_CONFIG_EXTENSIONS * sizeof(WORD32));
  memset(pstr_usac_decoder_config->usac_cfg_ext_info_present, 0,
         USAC_MAX_CONFIG_EXTENSIONS * sizeof(WORD32));

  for (j = 0; j < num_config_extensions; j++) {
    UWORD32 fill_byte_val = 0xa5;

    ixheaacd_read_escape_value(it_bit_buff, &(usac_config_ext_type), 4, 8, 16);
    ixheaacd_read_escape_value(it_bit_buff, &(usac_config_ext_len), 4, 8, 16);

    if (usac_config_ext_len > 768) {
      if (ec_flag) {
        longjmp(*(it_bit_buff->xaac_jmp_buf),
                IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
      } else {
        return IA_FATAL_ERROR;
      }
    }

    switch (usac_config_ext_type) {
      case ID_CONFIG_EXT_FILL:
        for (i = 0; i < usac_config_ext_len; i++) {
          fill_byte_val = ixheaacd_read_bits_buf(it_bit_buff, 8);
          if (fill_byte_val != 0xa5) {
            if (ec_flag) {
              longjmp(*(it_bit_buff->xaac_jmp_buf),
                      IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
            } else {
              return IA_FATAL_ERROR;
            }
          }
        }
        break;
      default:
        if ((WORD32)usac_config_ext_len > (it_bit_buff->cnt_bits >> 3)) {
          if (ec_flag) {
            longjmp(*(it_bit_buff->xaac_jmp_buf),
                    IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
          } else {
            return IA_FATAL_ERROR;
          }
        }
        if (ID_CONFIG_EXT_LOUDNESS_INFO == usac_config_ext_type) {
          for (i = 0; i < usac_config_ext_len; i++) {
            UWORD8 byte_val = ixheaacd_read_bits_buf(it_bit_buff, 8);
            pstr_usac_decoder_config->usac_cfg_ext_info_buf[j][i] = byte_val;
          }
          pstr_usac_decoder_config->usac_cfg_ext_info_len[j] =
              usac_config_ext_len;
          pstr_usac_decoder_config->usac_cfg_ext_info_present[j] = 1;
        } else {
          for (i = 0; i < usac_config_ext_len; i++)
            ixheaacd_read_bits_buf(it_bit_buff, 8);
        }
        break;
    }
  }

  return 0;
}

WORD32 ixheaacd_config(ia_bit_buf_struct *it_bit_buff, ia_usac_config_struct *pstr_usac_conf,
                       UINT32 *chan, WORD32 ec_flag) {
  WORD32 tmp, err;
  err = 0;

  pstr_usac_conf->usac_sampling_frequency_index =
      ixheaacd_read_bits_buf(it_bit_buff, 5);

  if (pstr_usac_conf->usac_sampling_frequency_index == 0x1f) {
    pstr_usac_conf->usac_sampling_frequency =
        ixheaacd_read_bits_buf(it_bit_buff, 24);

    if (pstr_usac_conf->usac_sampling_frequency > USAC_MAX_SAMPLE_RATE) {
      if (ec_flag) {
        longjmp(*(it_bit_buff->xaac_jmp_buf),
                IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
      } else {
        return IA_FATAL_ERROR;
      }
    }

  } else {
    pstr_usac_conf->usac_sampling_frequency =
        sampling_rate_tbl[pstr_usac_conf->usac_sampling_frequency_index];
  }

  if (pstr_usac_conf->usac_sampling_frequency == 0) {
    if (ec_flag) {
      longjmp(*(it_bit_buff->xaac_jmp_buf), IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
    } else {
      return IA_FATAL_ERROR;
    }
  }
  pstr_usac_conf->core_sbr_framelength_index =
      ixheaacd_read_bits_buf(it_bit_buff, 3);

  if (pstr_usac_conf->core_sbr_framelength_index > MAX_CORE_SBR_FRAME_LEN_IDX) {
    if (ec_flag) {
      longjmp(*(it_bit_buff->xaac_jmp_buf), IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
    } else {
      return IA_FATAL_ERROR;
    }
  }

  pstr_usac_conf->channel_configuration_index =
      ixheaacd_read_bits_buf(it_bit_buff, 5);
  if ((pstr_usac_conf->channel_configuration_index >= 3) &&
      (pstr_usac_conf->channel_configuration_index != 8)) {
    if (ec_flag) {
      longjmp(*(it_bit_buff->xaac_jmp_buf), IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
    } else {
      return IA_FATAL_ERROR;
    }
  }

  if (pstr_usac_conf->channel_configuration_index == 0) {
    UWORD32 i;

    ixheaacd_read_escape_value(it_bit_buff,
                               (UWORD32 *)(&(pstr_usac_conf->num_out_channels)),
                               5, 8, 16);
    if (BS_MAX_NUM_OUT_CHANNELS < pstr_usac_conf->num_out_channels) {
      return IA_XHEAAC_DEC_INIT_FATAL_STREAM_CHAN_GT_MAX;
    }
    if (pstr_usac_conf->num_out_channels < 1) {
      return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
    }
    for (i = 0; i < pstr_usac_conf->num_out_channels; i++)
      pstr_usac_conf->output_channel_pos[i] =
          ixheaacd_read_bits_buf(it_bit_buff, 5);

    if (ec_flag) {
      longjmp(*(it_bit_buff->xaac_jmp_buf), IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
    }
  } else {
    err = ixheaacd_get_usac_chan_conf(pstr_usac_conf, pstr_usac_conf->channel_configuration_index,
                                      it_bit_buff, ec_flag);
    if (err != 0)
      return err;
  }

  err = ixheaacd_decoder_config(
      it_bit_buff, &(pstr_usac_conf->str_usac_dec_config),
      ixheaacd_sbr_ratio(pstr_usac_conf->core_sbr_framelength_index), chan, ec_flag);
  if (err != 0) return err;

  tmp = ixheaacd_read_bits_buf(it_bit_buff, 1);

  if (tmp) {
    err = ixheaacd_config_extension(it_bit_buff,
                                    &pstr_usac_conf->str_usac_dec_config, ec_flag);
    if (err != 0) return -1;
  }

  return err;
}

VOID ixheaacd_conf_default(ia_usac_config_struct *pstr_usac_conf) {
  WORD32 i;

  pstr_usac_conf->num_out_channels = 0;

  for (i = 0; i < BS_MAX_NUM_OUT_CHANNELS; i++)
    pstr_usac_conf->output_channel_pos[i] = BS_OUTPUT_CHANNEL_POS_NA;

  pstr_usac_conf->str_usac_dec_config.num_elements = 0;

  for (i = 0; i < USAC_MAX_ELEMENTS; i++)
    pstr_usac_conf->str_usac_dec_config.usac_element_type[i] = ID_USAC_INVALID;

  return;
}

Coverage Report

Created: 2026-02-26 06:35