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

 *                                                                            *

 * 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 <stdlib.h>

#include <string.h>

#include "ixheaac_type_def.h"

#include "ixheaac_error_standards.h"

#include "ixheaacd_memory_standards.h"

#include "ixheaacd_sbrdecsettings.h"

#include "ixheaacd_sbr_scale.h"

#include "ixheaacd_env_extr_part.h"

#include "ixheaacd_defines.h"

#include "ixheaacd_aac_rom.h"

#include "ixheaacd_common_rom.h"

#include "ixheaacd_sbr_rom.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_pulsedata.h"

#include "ixheaacd_pns.h"

#include "ixheaacd_interface.h"

#include "ixheaacd_info.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_sbr_common.h"

#include "ixheaacd_drc_data_struct.h"

#include "ixheaacd_drc_dec.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_mps_polyphase.h"

#include "ixheaacd_config.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 "ixheaac_constants.h"

#include "ixheaacd_mps_dec.h"

#include "ixheaacd_struct_def.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_interface.h"

#include "ixheaacd_tns_usac.h"

#include "ixheaacd_acelp_info.h"

#include "ixheaacd_sbrdecsettings.h"

#include "ixheaacd_info.h"

#include "ixheaacd_sbrdecoder.h"

#include "ixheaacd_mps_polyphase.h"

#include "ixheaac_sbr_const.h"

#include "ixheaacd_main.h"

#include "ixheaacd_arith_dec.h"

#include "ixheaacd_config.h"

#include "ixheaacd_struct.h"

#include "ixheaacd_create.h"

#include "ixheaacd_dec_main.h"

#include "ixheaac_error_standards.h"

#include "ixheaacd_headerdecode.h"

#include "ixheaacd_error_codes.h"

VOID ixheaacd_samples_sat(WORD8 *outbuffer, WORD32 num_samples_out,

                          WORD32 pcmsize, FLOAT32 (*out_samples)[4096],

                          WORD32 *out_bytes, WORD32 num_channel_out) {

  WORD32 num;

  WORD32 i;

  WORD32 write_local;

  FLOAT32 write_local_float;

  WORD16 *out_buf = (WORD16 *)outbuffer;

  num = num_channel_out * num_samples_out;

  if (pcmsize == 16) {

    for (i = 0; i < num; i++) {

      write_local_float =

          (out_samples[i % num_channel_out][i / num_channel_out]);

      if (write_local_float > 32767.0f) {

        write_local_float = 32767.0f;

      } else if (write_local_float < -32768.0f) {

        write_local_float = -32768.0f;

      }

      out_buf[i] = (WORD16)write_local_float;

    }

    *out_bytes = num * sizeof(WORD16);

  } else {

    WORD8 *out_24bit = (WORD8 *)out_buf;

    for (i = 0; i < num; i++) {

      write_local_float =

          (out_samples[i % num_channel_out][i / num_channel_out] * 256);

      if (write_local_float > 8388607.0f) {

        write_local_float = 8388607.0f;

      } else if (write_local_float < -8388608.0f) {

        write_local_float = -8388608.0f;

      }

      write_local = (WORD32)write_local_float;

      *out_24bit++ = (WORD32)write_local & 0xff;

      *out_24bit++ = ((WORD32)write_local >> 8) & 0xff;

      *out_24bit++ = ((WORD32)write_local >> 16) & 0xff;

    }

    *out_bytes = num * 3 * sizeof(WORD8);

  }

}

VOID ixheaacd_samples_sat_mc(WORD8* outbuffer, WORD32 num_samples_out,

    FLOAT32(*out_samples)[4096], WORD32* out_bytes,

    WORD32 num_channel_out, WORD32 ch_fac) {

  WORD32 num;

  WORD32 i;

  FLOAT32 write_local_float;

  WORD16* out_buf = (WORD16*)outbuffer;

  num = num_channel_out * num_samples_out;

  if (num_channel_out == 1) {

    for (i = 0; i < num; i++) {

      write_local_float =

          (out_samples[i % num_channel_out][i / num_channel_out]);

      if (write_local_float > 32767.0f) {

        write_local_float = 32767.0f;

      } else if (write_local_float < -32768.0f) {

        write_local_float = -32768.0f;

      }

      out_buf[i * ch_fac] = (WORD16)write_local_float;

    }

  } else if (num_channel_out == 2) {

    for (i = 0; i < num_samples_out; i++) {

      write_local_float =

          (out_samples[(2*i) % num_channel_out][(2 * i) / num_channel_out]);

      if (write_local_float > 32767.0f) {

          write_local_float = 32767.0f;

      } else if (write_local_float < -32768.0f) {

          write_local_float = -32768.0f;

      }

      out_buf[i * ch_fac] = (WORD16)write_local_float;

      write_local_float =

          (out_samples[((2 * i) + 1) % num_channel_out][((2 * i) + 1) / num_channel_out]);

      if (write_local_float > 32767.0f) {

          write_local_float = 32767.0f;

      } else if (write_local_float < -32768.0f) {

          write_local_float = -32768.0f;

      }

      out_buf[i * ch_fac + 1] = (WORD16)write_local_float;

    }

  }

  *out_bytes = num * sizeof(WORD16);

}

/* audio pre roll frame parsing*/

static WORD32 ixheaacd_audio_preroll_parsing(

    ia_dec_data_struct *pstr_dec_data, UWORD8 *conf_buf, WORD32 *preroll_units,

    WORD32 *preroll_frame_offset, ia_aac_dec_state_struct *aac_dec_handle,

    WORD32 *config_changed, WORD32 *apply_crossfade) {

  ia_bit_buf_struct *temp_buff =

      (ia_bit_buf_struct *)&(pstr_dec_data->dec_bit_buf);

  WORD32 ext_ele_present = 0;

  WORD32 ext_ele_use_dflt_len = 0;

  WORD32 ext_ele_payload_len = 0;

  WORD32 num_pre_roll_frames = 0;

  WORD32 frame_idx = 0;

  WORD32 temp = 0;

  WORD32 config_len = 0;

  WORD32 loop;

  if (pstr_dec_data->str_frame_data.str_audio_specific_config.str_usac_config

          .str_usac_dec_config.usac_element_type[0] == ID_USAC_EXT) {

    temp = ixheaacd_show_bits_buf(temp_buff, 3);

    ext_ele_present = (temp >> 1) & 0x1;

    if (ext_ele_present) {

      ext_ele_use_dflt_len = temp & 0x1;

      if (ext_ele_use_dflt_len != 0) return 0;

      ixheaacd_read_bits_buf(temp_buff, 3);

      ext_ele_payload_len = ixheaacd_read_bits_buf(temp_buff, 8);

      if (ext_ele_payload_len == 255) {

        WORD32 val_add = 0;

        val_add = ixheaacd_read_bits_buf(temp_buff, 16);

        ext_ele_payload_len =

            (UWORD32)((WORD32)ext_ele_payload_len + val_add - 2);

      }

      config_len = ixheaacd_read_bits_buf(temp_buff, 4);

      if (config_len == 15) {

        WORD32 val_add = 0;

        val_add = ixheaacd_read_bits_buf(temp_buff, 4);

        config_len += val_add;

        if (val_add == 15) {

          WORD32 val_add1 = 0;

          val_add1 = ixheaacd_read_bits_buf(temp_buff, 8);

          config_len += val_add1;

        }

      }

      for (loop = 0; loop < config_len; loop++)

        conf_buf[loop] = ixheaacd_read_bits_buf(temp_buff, 8);

      if (aac_dec_handle->preroll_config_present == 1) {

        if (!(memcmp(aac_dec_handle->preroll_config_prev, conf_buf,

                     sizeof(UWORD8) * config_len))) {

          config_len = 0;

        }

        if (memcmp(aac_dec_handle->preroll_config_prev, conf_buf,

                   sizeof(UWORD8) * config_len) != 0) {

          *config_changed = 1;

        } else {

          *config_changed = 0;

        }

      }

      aac_dec_handle->preroll_config_present = 1;

      memcpy(aac_dec_handle->preroll_config_prev, conf_buf,

             sizeof(UWORD8) * config_len);

      *apply_crossfade = ixheaacd_read_bits_buf(temp_buff, 1);

      ixheaacd_read_bits_buf(temp_buff, 1);

      num_pre_roll_frames = ixheaacd_read_bits_buf(temp_buff, 2);

      if (num_pre_roll_frames == 3) {

        WORD32 val_add = 0;

        val_add = ixheaacd_read_bits_buf(temp_buff, 4);

        num_pre_roll_frames += val_add;

      }

      if (num_pre_roll_frames > MAX_AUDIO_PREROLLS) {

        if (pstr_dec_data->str_usac_data.ec_flag) {

          num_pre_roll_frames = 0;

          longjmp(*(pstr_dec_data->xaac_jmp_buf),

                  IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);

        } else {

          return IA_FATAL_ERROR;

        }

      }

      for (frame_idx = 0; frame_idx < num_pre_roll_frames; frame_idx++) {

        WORD32 au_len = 0;

        au_len = ixheaacd_read_bits_buf(temp_buff, 16);

        if (au_len == 65535) {

          WORD32 val_add = ixheaacd_read_bits_buf(temp_buff, 16);

          au_len += val_add;

        }

        if (config_len != 0) {

          preroll_frame_offset[frame_idx] =

              temp_buff->size - temp_buff->cnt_bits;

        }

        temp_buff->ptr_read_next += au_len;

        temp_buff->cnt_bits -= au_len * 8;

        if (temp_buff->cnt_bits < 0) {

          if (pstr_dec_data->str_usac_data.ec_flag) {

            temp_buff->cnt_bits = 0;

            longjmp(*(pstr_dec_data->xaac_jmp_buf),

                    IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);

          } else {

            return IA_FATAL_ERROR;

          }

        }

      }

    }

  }

  if (config_len == 0)

    *preroll_units = 0;

  else

    *preroll_units = num_pre_roll_frames;

  return config_len;

}

WORD32 ixheaacd_dec_main(VOID *temp_handle, WORD8 *inbuffer, WORD8 *outbuffer,

                         WORD32 *out_bytes, WORD32 frames_done, WORD32 pcmsize,

                         WORD32 *num_channel_out) {

  WORD32 err = 0;

  ia_exhaacplus_dec_api_struct *handle =

      (ia_exhaacplus_dec_api_struct *)temp_handle;

  ia_aac_dec_state_struct *aac_dec_handle = handle->p_state_aac;

  WORD32 tmp;

  ia_audio_specific_config_struct *pstr_audio_specific_config =

      (ia_audio_specific_config_struct *)

          aac_dec_handle->ia_audio_specific_config;

  WORD32 suitable_tracks = 1;

  WORD32 num_samples_out;

  ia_dec_data_struct *pstr_dec_data;

  UWORD8 config[MAX_PREROLL_SIZE];

  WORD32 config_len;

  WORD32 delay;

  WORD preroll_frame_offset[MAX_PREROLL_FRAME_OFFSET] = {0};

  WORD preroll_units = -1;

  WORD32 access_units = 0;

  WORD32 bits_consumed = 0;

  if (frames_done == 0) {

    if ((pstr_audio_specific_config->channel_configuration > 2) ||

        (pstr_audio_specific_config->channel_configuration == 0)) {

      return -1;

    }

    pstr_dec_data = (ia_dec_data_struct *)aac_dec_handle->pstr_dec_data;

    tmp = pstr_audio_specific_config->channel_configuration;

    suitable_tracks =

        ixheaacd_frm_data_init(pstr_audio_specific_config, pstr_dec_data);

    pstr_audio_specific_config->channel_configuration = tmp;

    if (suitable_tracks <= 0) {

      return -1;

    }

  }

  {

    WORD32 tot_out_bytes = 0;

    jmp_buf local;

    pstr_dec_data = (ia_dec_data_struct *)aac_dec_handle->pstr_dec_data;

    pstr_dec_data->str_usac_data.frame_ok = 1;

    pstr_dec_data->str_usac_data.ec_flag = aac_dec_handle->p_config->ui_err_conceal;

    if (pstr_dec_data->str_usac_data.ec_flag) {

      err = setjmp(local);

    }

    if (aac_dec_handle->p_config->ui_err_conceal) {

      if (err == 0) {

        if (pstr_dec_data->dec_bit_buf.cnt_bits) {

          aac_dec_handle->ui_in_bytes += (pstr_dec_data->dec_bit_buf.cnt_bits >> 3);

          if (aac_dec_handle->ui_in_bytes > IA_MAX_INP_BUFFER_SIZE) {

            aac_dec_handle->ui_in_bytes = 0;

          }

        }

      } else {

        pstr_dec_data->str_usac_data.frame_ok = 0;

      }

    }

    if (frames_done == 0) {

      WORD32 delay;

      pstr_dec_data->str_usac_data.first_frame = 1;

      if (aac_dec_handle->decode_create_done == 0) {

        delay = ixheaacd_decode_create(

            handle, pstr_dec_data,

            pstr_dec_data->str_frame_data.scal_out_select + 1);

        if (delay == -1) return -1;

      }

      pstr_dec_data->dec_bit_buf.max_size =

          handle->p_mem_info_aac[IA_MEMTYPE_INPUT].ui_size;

      *num_channel_out = pstr_dec_data->str_frame_data.scal_out_num_channels;

      return 0;

    }

    pstr_dec_data->dec_bit_buf.ptr_bit_buf_base = (UWORD8 *)inbuffer;

    pstr_dec_data->dec_bit_buf.size = aac_dec_handle->ui_in_bytes << 3;

    pstr_dec_data->dec_bit_buf.ptr_bit_buf_end =

        (UWORD8 *)inbuffer + aac_dec_handle->ui_in_bytes - 1;

    pstr_dec_data->dec_bit_buf.ptr_read_next = (UWORD8 *)inbuffer;

    pstr_dec_data->dec_bit_buf.bit_pos = 7;

    pstr_dec_data->dec_bit_buf.cnt_bits = pstr_dec_data->dec_bit_buf.size;

    pstr_dec_data->dec_bit_buf.xaac_jmp_buf = &(aac_dec_handle->xaac_jmp_buf);

    if (pstr_dec_data->str_usac_data.ec_flag) {

      pstr_dec_data->xaac_jmp_buf = &local;

    }

    pstr_dec_data->str_usac_data.usac_flag = aac_dec_handle->usac_flag;

    pstr_dec_data->str_usac_data.esbr_hq = handle->aac_config.ui_hq_esbr;

    pstr_dec_data->str_usac_data.enh_sbr = 1;

    pstr_dec_data->str_usac_data.enh_sbr_ps = handle->aac_config.ui_enh_sbr_ps;

    if (pstr_dec_data->dec_bit_buf.size > pstr_dec_data->dec_bit_buf.max_size)

      pstr_dec_data->dec_bit_buf.max_size = pstr_dec_data->dec_bit_buf.size;

    /* audio pre roll frame parsing*/

    if (aac_dec_handle->bs_format == LOAS_BSFORMAT && pstr_dec_data->str_usac_data.frame_ok) {

      WORD32 sync = ixheaacd_read_bits_buf(&pstr_dec_data->dec_bit_buf, 11);

      if (sync == 0x2b7) {

        WORD32 result = ixheaacd_latm_audio_mux_element(

          &pstr_dec_data->dec_bit_buf, &aac_dec_handle->latm_struct_element,

          aac_dec_handle,

          (ia_sampling_rate_info_struct *)&handle->aac_tables

          .pstr_huffmann_tables->str_sample_rate_info[0]);

        if (result < 0) {

          if (aac_dec_handle->p_config->ui_err_conceal)

            pstr_dec_data->str_usac_data.frame_ok = 0;

          else

            return result;

        }

      }

      bits_consumed = pstr_dec_data->dec_bit_buf.size - pstr_dec_data->dec_bit_buf.cnt_bits;

    }

    do {

      config_len = 0;

      if (err == 0 || aac_dec_handle->p_config->ui_err_conceal == 0) {

        if (access_units == 0 &&

            pstr_audio_specific_config->str_usac_config.str_usac_dec_config.preroll_flag) {

          config_len = ixheaacd_audio_preroll_parsing(

              pstr_dec_data, &config[0], &preroll_units, &preroll_frame_offset[0], aac_dec_handle,

              &aac_dec_handle->drc_config_changed, &aac_dec_handle->apply_crossfade);

          if (config_len == IA_FATAL_ERROR) return IA_FATAL_ERROR;

        }

        if (config_len != 0) {

          ia_bit_buf_struct config_bit_buf = {0};

          config_bit_buf.ptr_bit_buf_base = config;

          config_bit_buf.size = config_len << 3;

          config_bit_buf.ptr_read_next = config_bit_buf.ptr_bit_buf_base;

          config_bit_buf.ptr_bit_buf_end = (UWORD8 *)config + config_len;

          config_bit_buf.bit_pos = 7;

          config_bit_buf.cnt_bits = config_bit_buf.size;

          if (pstr_dec_data->str_usac_data.ec_flag) {

            config_bit_buf.xaac_jmp_buf = &local;

          } else {

            config_bit_buf.xaac_jmp_buf = &(aac_dec_handle->xaac_jmp_buf);

          }

          suitable_tracks = ixheaacd_frm_data_init(pstr_audio_specific_config, pstr_dec_data);

          if (suitable_tracks <= 0) return -1;

          aac_dec_handle->decode_create_done = 0;

          if (aac_dec_handle->p_config->ui_err_conceal) {

            if (pstr_dec_data->str_usac_data.frame_ok == 1 && err == 0) {

              err = ixheaacd_config(

                  &config_bit_buf,

                  &(pstr_dec_data->str_frame_data.str_audio_specific_config.str_usac_config),

                  &(pstr_audio_specific_config->channel_configuration),

                  aac_dec_handle->p_config->ui_err_conceal);

              if (err != 0) {

                if (frames_done == 0)

                  return -1;

                else

                  pstr_dec_data->str_usac_data.frame_ok = 0;

              }

            }

          } else {

            err = ixheaacd_config(

                &config_bit_buf,

                &(pstr_dec_data->str_frame_data.str_audio_specific_config.str_usac_config),

                &(pstr_audio_specific_config->channel_configuration),

                aac_dec_handle->p_config->ui_err_conceal);

            if (err != 0) {

              return err;

            }

          }

          pstr_dec_data->str_frame_data.str_audio_specific_config.sampling_frequency =

              pstr_dec_data->str_frame_data.str_audio_specific_config.str_usac_config

                  .usac_sampling_frequency;

          delay = ixheaacd_decode_create(handle, pstr_dec_data,

                                         pstr_dec_data->str_frame_data.scal_out_select + 1);

          if (delay == -1) return -1;

          *num_channel_out = pstr_dec_data->str_frame_data.scal_out_num_channels;

        }

      } else {

        pstr_dec_data->str_usac_data.frame_ok = 0;

      }

      pstr_dec_data->dec_bit_buf.ptr_bit_buf_base = (UWORD8 *)inbuffer;

      pstr_dec_data->dec_bit_buf.size = aac_dec_handle->ui_in_bytes << 3;

      pstr_dec_data->dec_bit_buf.ptr_bit_buf_end =

          (UWORD8 *)inbuffer + aac_dec_handle->ui_in_bytes - 1;

      pstr_dec_data->dec_bit_buf.ptr_read_next = (UWORD8 *)inbuffer;

      pstr_dec_data->dec_bit_buf.bit_pos = 7;

      pstr_dec_data->dec_bit_buf.cnt_bits = pstr_dec_data->dec_bit_buf.size;

      pstr_dec_data->dec_bit_buf.xaac_jmp_buf = &(aac_dec_handle->xaac_jmp_buf);

      pstr_dec_data->str_usac_data.usac_flag = aac_dec_handle->usac_flag;

      pstr_dec_data->str_usac_data.esbr_hq = handle->aac_config.ui_hq_esbr;

      pstr_dec_data->str_usac_data.enh_sbr = 1;

      pstr_dec_data->str_usac_data.enh_sbr_ps = handle->aac_config.ui_enh_sbr_ps;

      if (preroll_frame_offset[access_units] &&

          ((pstr_dec_data->str_usac_data.ec_flag && pstr_dec_data->str_usac_data.frame_ok == 1) ||

           pstr_dec_data->str_usac_data.ec_flag == 0)) {

        pstr_dec_data->dec_bit_buf.cnt_bits =

            pstr_dec_data->dec_bit_buf.size -

            preroll_frame_offset[access_units];

        pstr_dec_data->dec_bit_buf.bit_pos =

            7 - preroll_frame_offset[access_units] % 8;

        pstr_dec_data->dec_bit_buf.ptr_read_next =

            pstr_dec_data->dec_bit_buf.ptr_read_next +

            (preroll_frame_offset[access_units] / 8);

      } else {

        pstr_dec_data->dec_bit_buf.cnt_bits =

          pstr_dec_data->dec_bit_buf.size -

          (bits_consumed);

        pstr_dec_data->dec_bit_buf.bit_pos =

          7 - (bits_consumed) % 8;

        pstr_dec_data->dec_bit_buf.ptr_read_next =

          pstr_dec_data->dec_bit_buf.ptr_read_next +

          (bits_consumed / 8);

      }

      if (pstr_dec_data->str_usac_data.ec_flag) {

        if (!aac_dec_handle->decode_create_done && pstr_dec_data->str_usac_data.frame_ok == 1 &&

            config_len != 0)

          return IA_FATAL_ERROR;

      } else {

        if (!aac_dec_handle->decode_create_done) return IA_FATAL_ERROR;

      }

      err =

          ixheaacd_usac_process(pstr_dec_data, num_channel_out, aac_dec_handle);

      switch (pstr_dec_data->str_usac_data.sbr_ratio_idx) {

        case 0:

          handle->aac_config.ui_sbr_mode = 0;

          break;

        case 1:

          handle->aac_config.ui_sbr_mode = 1;

          break;

        case 2:

          handle->aac_config.ui_sbr_mode = 1;

          break;

        case 3:

          handle->aac_config.ui_sbr_mode = 3;

          break;

        default:

          handle->aac_config.ui_sbr_mode = 0;

      }

      if (err == -1) return err;

      num_samples_out = pstr_dec_data->str_usac_data.output_samples;

      if (!handle->aac_config.peak_limiter_off && pstr_dec_data->str_usac_data.ec_flag) {

        aac_dec_handle->peak_limiter.num_channels = *num_channel_out;

        ixheaacd_peak_limiter_process_float(&aac_dec_handle->peak_limiter,

                                            pstr_dec_data->str_usac_data.time_sample_vector,

                                            num_samples_out);

      }

      ixheaacd_samples_sat((WORD8 *)outbuffer + tot_out_bytes, num_samples_out,

                           pcmsize,

                           pstr_dec_data->str_usac_data.time_sample_vector,

                           out_bytes, *num_channel_out);

      {

        WORD32 preroll_counter =

            pstr_dec_data->str_frame_data.str_audio_specific_config

                .str_usac_config.str_usac_dec_config.preroll_counter;

        UWORD8 i;  // for looping index used for payload calculation

        WORD32 payload_buffer_offset = 0;

        WORD32 copy_bytes =

            pstr_dec_data->str_frame_data.str_audio_specific_config

                .str_usac_config.str_usac_dec_config

                .usac_ext_gain_payload_len[preroll_counter] *

            sizeof(WORD8);

        pstr_audio_specific_config->str_usac_config.str_usac_dec_config

            .usac_ext_gain_payload_len[preroll_counter] =

            pstr_dec_data->str_frame_data.str_audio_specific_config

                .str_usac_config.str_usac_dec_config

                .usac_ext_gain_payload_len[preroll_counter];

        for (i = 0; i < preroll_counter; i++)

          payload_buffer_offset +=

              pstr_dec_data->str_frame_data.str_audio_specific_config

                  .str_usac_config.str_usac_dec_config

                  .usac_ext_gain_payload_len[i] *

              sizeof(WORD8);

        memcpy(pstr_audio_specific_config->str_usac_config.str_usac_dec_config

                       .usac_ext_gain_payload_buf +

                   payload_buffer_offset,

               pstr_dec_data->str_frame_data.str_audio_specific_config

                       .str_usac_config.str_usac_dec_config

                       .usac_ext_gain_payload_buf +

                   payload_buffer_offset,

               copy_bytes);

        pstr_audio_specific_config->str_usac_config.str_usac_dec_config

            .preroll_bytes[preroll_counter] = *out_bytes;

        preroll_counter++;

        if (preroll_counter > (MAX_AUDIO_PREROLLS + 1)) return IA_FATAL_ERROR;

        pstr_dec_data->str_frame_data.str_audio_specific_config.str_usac_config

            .str_usac_dec_config.preroll_counter = preroll_counter;

        ia_usac_decoder_config_struct *pstr_usac_dec_config_state =

            &pstr_audio_specific_config->str_usac_config.str_usac_dec_config;

        ia_usac_decoder_config_struct *pstr_usac_dec_config_dec_data =

            &pstr_dec_data->str_frame_data.str_audio_specific_config.str_usac_config

            .str_usac_dec_config;

        pstr_usac_dec_config_state->num_config_extensions =

            pstr_usac_dec_config_dec_data->num_config_extensions;

        pstr_usac_dec_config_state->num_elements =

            pstr_usac_dec_config_dec_data->num_elements;

        memcpy(pstr_usac_dec_config_state->usac_cfg_ext_info_buf,

            pstr_usac_dec_config_dec_data->usac_cfg_ext_info_buf,

            sizeof(pstr_usac_dec_config_state->usac_cfg_ext_info_buf));

        memcpy(pstr_usac_dec_config_state->usac_ext_ele_payload_present,

            pstr_usac_dec_config_dec_data->usac_ext_ele_payload_present,

            sizeof(pstr_usac_dec_config_dec_data->usac_ext_ele_payload_present));

        memcpy(pstr_usac_dec_config_state->usac_ext_ele_payload_buf,

            pstr_usac_dec_config_dec_data->usac_ext_ele_payload_buf,

            sizeof(pstr_usac_dec_config_state->usac_ext_ele_payload_buf));

      }

      access_units++;

      preroll_units--;

      tot_out_bytes += (*out_bytes);

    } while (preroll_units >= 0);

    *out_bytes = tot_out_bytes;

  }

  if (aac_dec_handle->bs_format == LOAS_BSFORMAT) {

    pstr_dec_data->dec_bit_buf.ptr_bit_buf_base = (UWORD8 *)inbuffer;

    pstr_dec_data->dec_bit_buf.size = aac_dec_handle->ui_in_bytes << 3;

    pstr_dec_data->dec_bit_buf.ptr_bit_buf_end =

      (UWORD8 *)inbuffer + aac_dec_handle->ui_in_bytes - 1;

    pstr_dec_data->dec_bit_buf.ptr_read_next = (UWORD8 *)inbuffer;

    pstr_dec_data->dec_bit_buf.bit_pos = 7;

    pstr_dec_data->dec_bit_buf.cnt_bits = pstr_dec_data->dec_bit_buf.size;

    pstr_dec_data->dec_bit_buf.xaac_jmp_buf = &(aac_dec_handle->xaac_jmp_buf);

    ixheaacd_read_bits_buf(&pstr_dec_data->dec_bit_buf, 11);

    aac_dec_handle->i_bytes_consumed =

        ixheaacd_read_bits_buf(&pstr_dec_data->dec_bit_buf, 13) + 3;

  }

  return err;

}