/******************************************************************************
 *
 * 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 <stdio.h>
#include <string.h>
#include <math.h>
#include "impd_type_def.h"
#include "impd_drc_bitbuffer.h"
#include "impd_drc_extr_delta_coded_info.h"
#include "impd_drc_common.h"
#include "impd_drc_struct.h"
#include "impd_drc_parser.h"
#include "impd_drc_filter_bank.h"
#include "impd_drc_rom.h"

static VOID impd_parametric_drc_ffwd_init_drc_curve_params(
    WORD32 drc_characteristic, ia_parametric_drc_type_feed_forward_struct*
                                   str_parametric_drc_type_feed_forward) {
  WORD32* node_level = str_parametric_drc_type_feed_forward->node_level;
  WORD32* node_gain = str_parametric_drc_type_feed_forward->node_gain;

  switch (drc_characteristic) {
    case 7:
      str_parametric_drc_type_feed_forward->node_count = 5;
      node_level[0] = -22;
      node_gain[0] = 6;
      node_level[1] = -10;
      node_gain[1] = 0;
      node_level[2] = 10;
      node_gain[2] = 0;
      node_level[3] = 20;
      node_gain[3] = -5;
      node_level[4] = 40;
      node_gain[4] = -24;
      break;
    case 8:
      str_parametric_drc_type_feed_forward->node_count = 5;
      node_level[0] = -12;
      node_gain[0] = 6;
      node_level[1] = 0;
      node_gain[1] = 0;
      node_level[2] = 5;
      node_gain[2] = 0;
      node_level[3] = 15;
      node_gain[3] = -5;
      node_level[4] = 35;
      node_gain[4] = -24;
      break;
    case 9:
      str_parametric_drc_type_feed_forward->node_count = 4;
      node_level[0] = -34;
      node_gain[0] = 12;
      node_level[1] = -10;
      node_gain[1] = 0;
      node_level[2] = 10;
      node_gain[2] = 0;
      node_level[3] = 40;
      node_gain[3] = -15;
      break;
    case 10:
      str_parametric_drc_type_feed_forward->node_count = 5;
      node_level[0] = -24;
      node_gain[0] = 12;
      node_level[1] = 0;
      node_gain[1] = 0;
      node_level[2] = 5;
      node_gain[2] = 0;
      node_level[3] = 15;
      node_gain[3] = -5;
      node_level[4] = 35;
      node_gain[4] = -24;
      break;
    case 11:
      str_parametric_drc_type_feed_forward->node_count = 5;
      node_level[0] = -19;
      node_gain[0] = 15;
      node_level[1] = 0;
      node_gain[1] = 0;
      node_level[2] = 5;
      node_gain[2] = 0;
      node_level[3] = 15;
      node_gain[3] = -5;
      node_level[4] = 35;
      node_gain[4] = -24;
      break;
    default:
      str_parametric_drc_type_feed_forward->disable_paramteric_drc = 1;
  }

  return;
}

static VOID impd_parametric_drc_ffwd_init_drc_gain_smooth_params(
    WORD32 drc_characteristic, ia_parametric_drc_type_feed_forward_struct*
                                   str_parametric_drc_type_feed_forward) {
  str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow = 100;
  str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present = 1;
  str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast = 10;
  str_parametric_drc_type_feed_forward->gain_smooth_threshold_present = 1;
  str_parametric_drc_type_feed_forward->gain_smooth_hold_off_count_present = 1;
  str_parametric_drc_type_feed_forward->gain_smooth_hold_off = 10;

  switch (drc_characteristic) {
    case 7:
    case 8:
    case 9:
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
          3000;
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
          1000;
      str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15;
      str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20;
      break;
    case 10:
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
          10000;
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
          1000;
      str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15;
      str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20;
      break;
    case 11:
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
          1000;
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = 200;
      str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 10;
      str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 10;
      break;
    default:
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
          3000;
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
          1000;
      str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15;
      str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20;
      break;
  }

  return;
}

static WORD32 impd_parse_parametric_drc_ffwd(
    ia_bit_buf_struct* it_bit_buff, WORD32 parametric_drc_frame_size,
    ia_parametric_drc_type_feed_forward_struct*
        str_parametric_drc_type_feed_forward) {
  WORD32 i = 0, tmp = 0;
  // WORD32 err = 0;

  str_parametric_drc_type_feed_forward->disable_paramteric_drc = 0;

  tmp = impd_read_bits_buf(it_bit_buff, 3);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_parametric_drc_type_feed_forward->level_estim_k_weighting_type =
      (tmp >> 1) & 3;
  str_parametric_drc_type_feed_forward->level_estim_integration_time_present =
      tmp & 1;

  if (str_parametric_drc_type_feed_forward
          ->level_estim_integration_time_present) {
    tmp = impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;
    str_parametric_drc_type_feed_forward->level_estim_integration_time =
        (tmp + 1) * parametric_drc_frame_size;
  } else {
    str_parametric_drc_type_feed_forward->level_estim_integration_time =
        parametric_drc_frame_size;
  }

  str_parametric_drc_type_feed_forward->drc_curve_definition_type =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (str_parametric_drc_type_feed_forward->drc_curve_definition_type == 0) {
    str_parametric_drc_type_feed_forward->drc_characteristic =
        impd_read_bits_buf(it_bit_buff, 7);
    if (it_bit_buff->error) return it_bit_buff->error;
    impd_parametric_drc_ffwd_init_drc_curve_params(
        str_parametric_drc_type_feed_forward->drc_characteristic,
        str_parametric_drc_type_feed_forward);
  } else {
    str_parametric_drc_type_feed_forward->drc_characteristic = 0;

    tmp = impd_read_bits_buf(it_bit_buff, 15);
    if (it_bit_buff->error) return it_bit_buff->error;

    str_parametric_drc_type_feed_forward->node_count = ((tmp >> 12) & 3) + 2;
    str_parametric_drc_type_feed_forward->node_level[0] =
        -11 - ((tmp >> 6) & 0x3f);
    str_parametric_drc_type_feed_forward->node_gain[0] = (tmp & 0x3f) - 39;

    for (i = 1; i < str_parametric_drc_type_feed_forward->node_count; i++) {
      tmp = impd_read_bits_buf(it_bit_buff, 11);
      if (it_bit_buff->error) return it_bit_buff->error;

      str_parametric_drc_type_feed_forward->node_level[i] =
          str_parametric_drc_type_feed_forward->node_level[i - 1] + 1 +
          ((tmp >> 6) & 0x1f);
      str_parametric_drc_type_feed_forward->node_gain[i] = (tmp & 0x3f) - 39;
    }
  }

  impd_parametric_drc_ffwd_init_drc_gain_smooth_params(
      str_parametric_drc_type_feed_forward->drc_characteristic,
      str_parametric_drc_type_feed_forward);

  str_parametric_drc_type_feed_forward->drc_gain_smooth_parameters_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;
  if (str_parametric_drc_type_feed_forward
          ->drc_gain_smooth_parameters_present) {
    tmp = impd_read_bits_buf(it_bit_buff, 17);
    if (it_bit_buff->error) return it_bit_buff->error;

    str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow =
        ((tmp >> 9) & 0xff) * 5;
    str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
        ((tmp >> 1) & 0xff) * 40;
    str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present =
        tmp & 1;

    if (str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present) {
      tmp = impd_read_bits_buf(it_bit_buff, 17);
      if (it_bit_buff->error) return it_bit_buff->error;

      str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast =
          ((tmp >> 9) & 0xff) * 5;
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
          ((tmp >> 1) & 0xff) * 20;
      str_parametric_drc_type_feed_forward->gain_smooth_threshold_present =
          tmp & 1;

      if (str_parametric_drc_type_feed_forward->gain_smooth_threshold_present) {
        str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold =
            impd_read_bits_buf(it_bit_buff, 5);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (str_parametric_drc_type_feed_forward
                ->gain_smooth_attack_threshold == 31) {
          str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold =
              1000;
        }

        str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold =
            impd_read_bits_buf(it_bit_buff, 5);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold ==
            31) {
          str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold =
              1000;
        }
      }
    } else {
      str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast =
          str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow;
      str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
          str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow;
    }

    str_parametric_drc_type_feed_forward->gain_smooth_hold_off_count_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (str_parametric_drc_type_feed_forward
            ->gain_smooth_hold_off_count_present) {
      str_parametric_drc_type_feed_forward->gain_smooth_hold_off =
          impd_read_bits_buf(it_bit_buff, 7);
      if (it_bit_buff->error) return it_bit_buff->error;
    }
  }
  return 0;
}

static WORD32 impd_parse_parametric_drc_lim(
    ia_bit_buf_struct* it_bit_buff,
    ia_parametric_drc_lim_struct* parametric_drc_lim) {
  // WORD32 err = 0;
  WORD32 tmp = 0;

  parametric_drc_lim->disable_paramteric_drc = 0;

  parametric_drc_lim->parametric_lim_threshold_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (parametric_drc_lim->parametric_lim_threshold_present) {
    tmp = impd_read_bits_buf(it_bit_buff, 8);
    if (it_bit_buff->error) return it_bit_buff->error;
    parametric_drc_lim->parametric_lim_threshold = -tmp * 0.125f;
  } else {
    parametric_drc_lim->parametric_lim_threshold =
        PARAM_DRC_TYPE_LIM_THRESHOLD_DEFAULT;
  }

  parametric_drc_lim->parametric_lim_release_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;
  if (parametric_drc_lim->parametric_lim_release_present) {
    tmp = impd_read_bits_buf(it_bit_buff, 8);
    if (it_bit_buff->error) return it_bit_buff->error;
    parametric_drc_lim->parametric_lim_release = tmp * 10;
  } else {
    parametric_drc_lim->parametric_lim_release =
        PARAM_DRC_TYPE_LIM_RELEASE_DEFAULT;
  }

  parametric_drc_lim->parametric_lim_attack = PARAM_DRC_TYPE_LIM_ATTACK_DEFAULT;
  parametric_drc_lim->drc_characteristic = 0;

  return 0;
}

WORD32
impd_parametric_drc_parse_gain_set_params(
    ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config,
    ia_parametric_drc_gain_set_params_struct*
        str_parametric_drc_gain_set_params) {
  WORD32 i = 0, bsDrcInputLoudness = 0, bs_channel_weight = 0, temp;
  // WORD32 err = 0;
  temp = impd_read_bits_buf(it_bit_buff, 7);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_parametric_drc_gain_set_params->parametric_drc_id = (temp >> 3) & 0xf;
  str_parametric_drc_gain_set_params->side_chain_config_type = temp & 7;

  if (str_parametric_drc_gain_set_params->side_chain_config_type) {
    temp = impd_read_bits_buf(it_bit_buff, 8);
    if (it_bit_buff->error) return it_bit_buff->error;

    str_parametric_drc_gain_set_params->downmix_id = (temp >> 1) & 0x7f;
    str_parametric_drc_gain_set_params->level_estim_channel_weight_format =
        temp & 1;

    if (str_parametric_drc_gain_set_params->downmix_id == ID_FOR_BASE_LAYOUT) {
      str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id =
          drc_config->channel_layout.base_channel_count;
    } else if (str_parametric_drc_gain_set_params->downmix_id ==
               ID_FOR_ANY_DOWNMIX) {
      str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = 1;
    } else {
      for (i = 0; i < drc_config->dwnmix_instructions_count; i++) {
        if (str_parametric_drc_gain_set_params->downmix_id ==
            drc_config->dwnmix_instructions[i].downmix_id)
          break;
      }
      if (i == drc_config->dwnmix_instructions_count) {
        /* dwnmix_instructions not found */
        return (UNEXPECTED_ERROR);
      }
      str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id =
          drc_config->dwnmix_instructions[i].target_channel_count;
    }

    for (i = 0; i < str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id;
         i++) {
      if (str_parametric_drc_gain_set_params
              ->level_estim_channel_weight_format == 0) {
        str_parametric_drc_gain_set_params->level_estim_ch_weight[i] =
            (FLOAT32)impd_read_bits_buf(it_bit_buff, 1);
        if (it_bit_buff->error) return it_bit_buff->error;
      } else {
        bs_channel_weight = impd_read_bits_buf(it_bit_buff, 4);
        if (it_bit_buff->error) return it_bit_buff->error;
        str_parametric_drc_gain_set_params->level_estim_ch_weight[i] =
            (FLOAT32)pow(10.0f, 0.05f * channel_weight[bs_channel_weight]);
      }
    }
  } else {
    str_parametric_drc_gain_set_params->downmix_id = 0;
    str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = 0;
  }

  str_parametric_drc_gain_set_params->drc_input_loudness_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (str_parametric_drc_gain_set_params->drc_input_loudness_present) {
    bsDrcInputLoudness = impd_read_bits_buf(it_bit_buff, 8);
    if (it_bit_buff->error) return it_bit_buff->error;
    str_parametric_drc_gain_set_params->drc_input_loudness =
        -57.75f + bsDrcInputLoudness * 0.25f;
  }

  return 0;
}

static WORD32 impd_parametric_drc_gen_virtual_gain_sets(
    ia_drc_config* drc_config) {
  WORD32 i = 0, j = 0, c1 = -1, c0 = -1, parametric_drc_id = 0,
         drc_characteristic = 0;
  ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc;
  ia_parametric_drc_instructions_struct* str_parametric_drc_instructions;
  ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc =
      &(drc_config->str_drc_config_ext.str_drc_coeff_param_drc);

  for (i = 0; i < drc_config->drc_coefficients_drc_count; i++) {
    if (drc_config->str_p_loc_drc_coefficients_uni_drc[i].drc_location ==
        str_drc_coeff_param_drc->drc_location) {
      if (drc_config->str_p_loc_drc_coefficients_uni_drc[i].version == 0) {
        c0 = i;
      } else {
        c1 = i;
      }
    }
  }
  if (c1 >= 0) {
    str_p_loc_drc_coefficients_uni_drc =
        &(drc_config->str_p_loc_drc_coefficients_uni_drc[c1]);
  } else if (c0 >= 0) {
    str_p_loc_drc_coefficients_uni_drc =
        &(drc_config->str_p_loc_drc_coefficients_uni_drc[c0]);
  } else {
    str_p_loc_drc_coefficients_uni_drc =
        &drc_config->str_p_loc_drc_coefficients_uni_drc
             [drc_config->drc_coefficients_drc_count];

    str_p_loc_drc_coefficients_uni_drc->version = 1;
    str_p_loc_drc_coefficients_uni_drc->drc_location =
        str_drc_coeff_param_drc->drc_location;
    str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = 0;

    str_p_loc_drc_coefficients_uni_drc->gain_set_count = 0;
    str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus = 0;

    str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present = 0;
    str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present = 0;
    str_p_loc_drc_coefficients_uni_drc->shape_filters_present = 0;
    str_p_loc_drc_coefficients_uni_drc->gain_sequence_count = 0;
    drc_config->drc_coefficients_drc_count += 1;
  }
  str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus =
      str_p_loc_drc_coefficients_uni_drc->gain_set_count +
      str_drc_coeff_param_drc->parametric_drc_gain_set_count;
  for (i = str_p_loc_drc_coefficients_uni_drc->gain_set_count;
       i < str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus; i++) {
    str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count = 1;

    parametric_drc_id =
        drc_config->str_drc_config_ext.str_drc_coeff_param_drc
            .str_parametric_drc_gain_set_params
                [i - str_p_loc_drc_coefficients_uni_drc->gain_set_count]
            .parametric_drc_id;

    for (j = 0;
         j < drc_config->str_drc_config_ext.parametric_drc_instructions_count;
         j++) {
      if (parametric_drc_id ==
          drc_config->str_drc_config_ext.str_parametric_drc_instructions[j]
              .parametric_drc_id)
        break;
    }
    if (j == drc_config->str_drc_config_ext.parametric_drc_instructions_count) {
      /* str_parametric_drc_instructions not found */
      return (UNEXPECTED_ERROR);
    }
    str_parametric_drc_instructions =
        &drc_config->str_drc_config_ext.str_parametric_drc_instructions[j];

    drc_characteristic = 0;
    if (str_parametric_drc_instructions->parametric_drc_preset_id_present) {
      drc_characteristic = str_parametric_drc_instructions->drc_characteristic;
    } else if (str_parametric_drc_instructions->parametric_drc_type ==
               PARAM_DRC_TYPE_FF) {
      if (str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
              .drc_curve_definition_type == 0) {
        drc_characteristic =
            str_parametric_drc_instructions
                ->str_parametric_drc_type_feed_forward.drc_characteristic;
      }
    }
    if (drc_characteristic != 0) {
      str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
          .gain_params[0]
          .drc_characteristic_present = 1;
      str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
          .gain_params[0]
          .drc_characteristic_format_is_cicp = 1;
      str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
          .gain_params[0]
          .drc_characteristic = drc_characteristic;
    } else {
      str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
          .gain_params[0]
          .drc_characteristic_present = 0;
      str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
          .gain_params[0]
          .drc_characteristic_format_is_cicp = 0;
      str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
          .gain_params[0]
          .drc_characteristic = 0;
    }
  }

  return 0;
}

static WORD32 impd_parametic_drc_parse_coeff(
    ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config,
    ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc) {
  WORD32 i = 0, err = 0, code = 0, mu = 0, nu = 0, temp;

  temp = impd_read_bits_buf(it_bit_buff, 5);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_drc_coeff_param_drc->drc_location = (temp >> 1) & 0xf;
  str_drc_coeff_param_drc->parametric_drc_frame_size_format = temp & 1;

  if (str_drc_coeff_param_drc->parametric_drc_frame_size) {
    code = impd_read_bits_buf(it_bit_buff, 15);
    if (it_bit_buff->error) return it_bit_buff->error;
    str_drc_coeff_param_drc->parametric_drc_frame_size = code + 1;
  } else {
    code = impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;
    str_drc_coeff_param_drc->parametric_drc_frame_size = 1 << code;
  }

  str_drc_coeff_param_drc->parametric_drc_delay_max_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (str_drc_coeff_param_drc->parametric_drc_delay_max_present) {
    temp = impd_read_bits_buf(it_bit_buff, 8);
    if (it_bit_buff->error) return it_bit_buff->error;

    mu = (temp >> 3) & 0x1f;
    nu = temp & 3;

    str_drc_coeff_param_drc->parametric_drc_delay_max = 16 * mu * (1 << nu);
  }

  temp = impd_read_bits_buf(it_bit_buff, 7);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_drc_coeff_param_drc->reset_parametric_drc = (temp >> 6) & 1;
  str_drc_coeff_param_drc->parametric_drc_gain_set_count = temp & 0x3f;

  if (str_drc_coeff_param_drc->parametric_drc_gain_set_count >
      SEQUENCE_COUNT_MAX)
    return (UNEXPECTED_ERROR);

  for (i = 0; i < str_drc_coeff_param_drc->parametric_drc_gain_set_count; i++) {
    err = impd_parametric_drc_parse_gain_set_params(
        it_bit_buff, drc_config,
        &(str_drc_coeff_param_drc->str_parametric_drc_gain_set_params[i]));
    if (err) return (err);
  }

  return 0;
}

static WORD32 impd_parse_parametric_drc_instructions(
    ia_bit_buf_struct* it_bit_buff, WORD32 parametric_drc_frame_size,
    ia_parametric_drc_instructions_struct* str_parametric_drc_instructions) {
  WORD32 i = 0, err = 0, temp;
  WORD32 bit_size_len, bit_size, other_bit;

  str_parametric_drc_instructions->drc_characteristic = 0;
  str_parametric_drc_instructions->disable_paramteric_drc = 0;

  temp = impd_read_bits_buf(it_bit_buff, 5);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_parametric_drc_instructions->parametric_drc_id = (temp >> 1) & 0xf;
  str_parametric_drc_instructions->parametric_drc_look_ahead_flag = temp & 1;

  if (str_parametric_drc_instructions->parametric_drc_look_ahead_flag) {
    str_parametric_drc_instructions->parametric_drc_look_ahead =
        impd_read_bits_buf(it_bit_buff, 7);
    if (it_bit_buff->error) return it_bit_buff->error;
  } else {
    str_parametric_drc_instructions->parametric_drc_look_ahead = 0;
  }

  str_parametric_drc_instructions->parametric_drc_preset_id_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (str_parametric_drc_instructions->parametric_drc_preset_id_present) {
    str_parametric_drc_instructions->parametric_drc_preset_id =
        impd_read_bits_buf(it_bit_buff, 7);
    if (it_bit_buff->error) return it_bit_buff->error;

    switch (str_parametric_drc_instructions->parametric_drc_preset_id) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        str_parametric_drc_instructions->drc_characteristic =
            str_parametric_drc_instructions->parametric_drc_preset_id + 7;
        str_parametric_drc_instructions->parametric_drc_type =
            PARAM_DRC_TYPE_FF;

        str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
            .level_estim_k_weighting_type = 2;
        str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
            .level_estim_integration_time = parametric_drc_frame_size;

        impd_parametric_drc_ffwd_init_drc_curve_params(
            str_parametric_drc_instructions->drc_characteristic,
            &str_parametric_drc_instructions
                 ->str_parametric_drc_type_feed_forward);
        impd_parametric_drc_ffwd_init_drc_gain_smooth_params(
            str_parametric_drc_instructions->drc_characteristic,
            &str_parametric_drc_instructions
                 ->str_parametric_drc_type_feed_forward);

        break;
      default:
        str_parametric_drc_instructions->disable_paramteric_drc = 1;
        break;
    }
  } else {
    str_parametric_drc_instructions->parametric_drc_type =
        impd_read_bits_buf(it_bit_buff, 3);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (str_parametric_drc_instructions->parametric_drc_type ==
        PARAM_DRC_TYPE_FF) {
      err = impd_parse_parametric_drc_ffwd(
          it_bit_buff, parametric_drc_frame_size,
          &(str_parametric_drc_instructions
                ->str_parametric_drc_type_feed_forward));
      if (err) return (err);
      str_parametric_drc_instructions->disable_paramteric_drc =
          str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
              .disable_paramteric_drc;
      str_parametric_drc_instructions->drc_characteristic =
          str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
              .drc_characteristic;
    } else if (str_parametric_drc_instructions->parametric_drc_type ==
               PARAM_DRC_TYPE_LIM) {
      err = impd_parse_parametric_drc_lim(
          it_bit_buff, &(str_parametric_drc_instructions->parametric_drc_lim));
      if (err) return (err);
      str_parametric_drc_instructions->disable_paramteric_drc =
          str_parametric_drc_instructions->parametric_drc_lim
              .disable_paramteric_drc;
      str_parametric_drc_instructions->drc_characteristic =
          str_parametric_drc_instructions->parametric_drc_lim
              .drc_characteristic;
      if (str_parametric_drc_instructions->parametric_drc_look_ahead_flag) {
        str_parametric_drc_instructions->parametric_drc_lim
            .parametric_lim_attack =
            str_parametric_drc_instructions->parametric_drc_look_ahead;
      }
    } else {
      bit_size_len = impd_read_bits_buf(it_bit_buff, 3) + 4;
      if (it_bit_buff->error) return it_bit_buff->error;

      bit_size = impd_read_bits_buf(it_bit_buff, bit_size_len);
      if (it_bit_buff->error) return it_bit_buff->error;
      str_parametric_drc_instructions->len_bit_size = bit_size + 1;

      switch (str_parametric_drc_instructions->parametric_drc_type) {
        default:
          str_parametric_drc_instructions->disable_paramteric_drc = 1;
          for (i = 0; i < str_parametric_drc_instructions->len_bit_size; i++) {
            other_bit = impd_read_bits_buf(it_bit_buff, 1);
            if (it_bit_buff->error) return it_bit_buff->error;
          }
          break;
      }
    }
  }

  return 0;
}

WORD32 impd_parse_loud_info_set_ext_eq(
    ia_bit_buf_struct* it_bit_buff,
    ia_drc_loudness_info_set_struct* loudness_info_set) {
  WORD32 err, i, offset, version = 1, temp;
  WORD32 loudness_info_v1_album_cnt, loudness_info_v1_cnt;

  temp = impd_read_bits_buf(it_bit_buff, 12);
  if (it_bit_buff->error) return it_bit_buff->error;

  loudness_info_v1_album_cnt = (temp >> 6) & 0x3f;
  loudness_info_v1_cnt = temp & 0x3f;

  offset = loudness_info_set->loudness_info_album_count;
  loudness_info_set->loudness_info_album_count += loudness_info_v1_album_cnt;
  if ((offset + loudness_info_v1_album_cnt) > LOUDNESS_INFO_COUNT_MAX)
    return (UNEXPECTED_ERROR);
  for (i = 0; i < loudness_info_v1_album_cnt; i++) {
    err = impd_parse_loudness_info(
        it_bit_buff, version,
        &loudness_info_set->str_loudness_info_album[i + offset]);
    if (err) return (err);
  }
  offset = loudness_info_set->loudness_info_count;
  loudness_info_set->loudness_info_count += loudness_info_v1_cnt;
  if (offset + loudness_info_v1_cnt > LOUDNESS_INFO_COUNT_MAX)
    return (UNEXPECTED_ERROR);
  for (i = 0; i < loudness_info_v1_cnt; i++) {
    err = impd_parse_loudness_info(
        it_bit_buff, version, &loudness_info_set->loudness_info[i + offset]);
    if (err) return (err);
  }
  return (0);
}

WORD32 impd_parse_ch_layout(ia_bit_buf_struct* it_bit_buff,
                            ia_drc_params_bs_dec_struct* ia_drc_params_struct,
                            ia_channel_layout_struct* channel_layout) {
  // WORD32 err = 0;
  WORD32 i;

  channel_layout->base_channel_count = impd_read_bits_buf(it_bit_buff, 7);
  if (it_bit_buff->error) return it_bit_buff->error;
  if (ia_drc_params_struct->lfe_channel_map_count != -1 &&
      channel_layout->base_channel_count !=
          ia_drc_params_struct->lfe_channel_map_count) {
    return (UNEXPECTED_ERROR);
  }
  channel_layout->layout_signaling_present = impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (channel_layout->layout_signaling_present) {
    channel_layout->defined_layout = impd_read_bits_buf(it_bit_buff, 8);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (channel_layout->defined_layout == 0) {
      for (i = 0; i < channel_layout->base_channel_count; i++) {
        channel_layout->speaker_position[i] =
            impd_read_bits_buf(it_bit_buff, 7);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (channel_layout->speaker_position[i] == 3 ||
            channel_layout->speaker_position[i] == 26) {
          ia_drc_params_struct->lfe_channel_map[i] = 1;
        } else {
          ia_drc_params_struct->lfe_channel_map[i] = 0;
        }
      }
    }
  }

  return (0);
}

WORD32
impd_parse_dwnmix_instructions(
    ia_bit_buf_struct* it_bit_buff, WORD32 version,
    ia_drc_params_bs_dec_struct* ia_drc_params_struct,
    ia_channel_layout_struct* channel_layout,
    ia_downmix_instructions_struct* dwnmix_instructions) {
  // WORD32 err = 0;
  WORD32 i, j, k, temp;

  temp = impd_read_bits_buf(it_bit_buff, 23);
  if (it_bit_buff->error) return it_bit_buff->error;

  dwnmix_instructions->downmix_id = (temp >> 16) & 0x7f;
  dwnmix_instructions->target_channel_count = (temp >> 9) & 0x7f;
  dwnmix_instructions->target_layout = (temp >> 1) & 0xff;
  dwnmix_instructions->downmix_coefficients_present = temp & 1;

  if (dwnmix_instructions->downmix_coefficients_present) {
    if (version == 0) {
      WORD32 dmix_coeff;
      k = 0;
      for (i = 0; i < dwnmix_instructions->target_channel_count; i++) {
        for (j = 0; j < channel_layout->base_channel_count; j++) {
          dmix_coeff = impd_read_bits_buf(it_bit_buff, 4);
          if (it_bit_buff->error) return it_bit_buff->error;

          if (k >= DOWNMIX_COEFF_COUNT_MAX) return (UNEXPECTED_ERROR);
          if (ia_drc_params_struct->lfe_channel_map[j]) {
            dwnmix_instructions->downmix_coefficient[k] =
                (FLOAT32)pow(10.0f, 0.05f * dwnmix_coeff_lfe[dmix_coeff]);
          } else {
            dwnmix_instructions->downmix_coefficient[k] =
                (FLOAT32)pow(10.0f, 0.05f * dwnmix_coeff[dmix_coeff]);
          }
          k++;
        }
      }
    } else {
      WORD32 dmix_coeff_v1, bs_dmix_offset;
      FLOAT32 a, b, dmix_offset, sum;

      bs_dmix_offset = impd_read_bits_buf(it_bit_buff, 4);
      if (it_bit_buff->error) return it_bit_buff->error;
      k = 0;

      for (i = 0; i < dwnmix_instructions->target_channel_count; i++) {
        for (j = 0; j < channel_layout->base_channel_count; j++) {
          dmix_coeff_v1 = impd_read_bits_buf(it_bit_buff, 5);
          if (it_bit_buff->error) return it_bit_buff->error;
          if (k >= DOWNMIX_COEFF_COUNT_MAX) return (UNEXPECTED_ERROR);
          dwnmix_instructions->downmix_coefficient[k] =
              dwnmix_coeff_v1[dmix_coeff_v1];
          k++;
        }
      }
      switch (bs_dmix_offset) {
        case 0:
          dmix_offset = 0.0f;
          break;
        case 1:
          a = 20.0f * (FLOAT32)log10(
                          (FLOAT32)dwnmix_instructions->target_channel_count /
                          (FLOAT32)channel_layout->base_channel_count);
          dmix_offset = 0.5f * (FLOAT32)floor(0.5f + a);
          break;
        case 2:
          a = 20.0f * (FLOAT32)log10(
                          (FLOAT32)dwnmix_instructions->target_channel_count /
                          (FLOAT32)channel_layout->base_channel_count);
          dmix_offset = 0.5f * (FLOAT32)floor(0.5f + 2.0f * a);
          break;
        case 3:
          sum = 0.0f;
          for (k = 0; k < dwnmix_instructions->target_channel_count *
                              channel_layout->base_channel_count;
               k++) {
            sum += (FLOAT32)pow(
                10.0f, 0.1f * dwnmix_instructions->downmix_coefficient[k]);
          }
          b = 10.0f * (FLOAT32)log10(sum);
          dmix_offset = 0.5f * (FLOAT32)floor(0.5f + 2.0f * b);
          break;

        default:
          return (BITSTREAM_ERROR);
          break;
      }
      for (k = 0; k < dwnmix_instructions->target_channel_count *
                          channel_layout->base_channel_count;
           k++) {
        dwnmix_instructions->downmix_coefficient[k] = (FLOAT32)pow(
            10.0f, 0.05f * (dwnmix_instructions->downmix_coefficient[k] +
                            dmix_offset));
      }
    }
  }
  return (0);
}

VOID impd_drc_gen_instructions_for_drc_off(ia_drc_config* drc_config) {
  WORD32 i, k, s;
  ia_drc_instructions_struct* str_drc_instruction_str;
  s = -1;

  k = drc_config->drc_instructions_uni_drc_count;

  str_drc_instruction_str = &(drc_config->str_drc_instruction_str[k]);
  memset(str_drc_instruction_str, 0, sizeof(ia_drc_instructions_struct));
  str_drc_instruction_str->drc_set_id = s;
  s--;
  str_drc_instruction_str->downmix_id[0] = ID_FOR_BASE_LAYOUT;
  str_drc_instruction_str->dwnmix_id_count = 1;
  str_drc_instruction_str->drc_apply_to_dwnmix = 0;
  str_drc_instruction_str->depends_on_drc_set_present = 0;
  str_drc_instruction_str->no_independent_use = 0;
  str_drc_instruction_str->gain_element_count = 0;
  for (i = 1; i < drc_config->dwnmix_instructions_count + 1; i++) {
    str_drc_instruction_str = &(drc_config->str_drc_instruction_str[k + i]);
    memset(str_drc_instruction_str, 0, sizeof(ia_drc_instructions_struct));
    str_drc_instruction_str->drc_set_id = s;
    s--;
    str_drc_instruction_str->drc_set_complexity_level = 0;
    str_drc_instruction_str->requires_eq = 0;
    str_drc_instruction_str->downmix_id[0] =
        drc_config->dwnmix_instructions[i - 1].downmix_id;
    str_drc_instruction_str->dwnmix_id_count = 1;
    str_drc_instruction_str->drc_apply_to_dwnmix = 0;
    str_drc_instruction_str->depends_on_drc_set_present = 0;
    str_drc_instruction_str->no_independent_use = 0;
    str_drc_instruction_str->gain_element_count = 0;
  }
  drc_config->drc_instructions_count_plus =
      drc_config->drc_instructions_uni_drc_count +
      drc_config->dwnmix_instructions_count + 1;
  return;
}

WORD32
impd_parse_drc_config_ext(ia_bit_buf_struct* it_bit_buff,
                          ia_drc_params_bs_dec_struct* ia_drc_params_struct,
                          ia_drc_config* drc_config,
                          ia_drc_config_ext* str_drc_config_ext) {
  WORD32 err = 0, i, k;
  WORD32 bit_size_len, ext_size_bits, bit_size, other_bit;

  k = 0;
  str_drc_config_ext->drc_config_ext_type[k] =
      impd_read_bits_buf(it_bit_buff, 4);
  if (it_bit_buff->error) return it_bit_buff->error;
  while (str_drc_config_ext->drc_config_ext_type[k] != UNIDRCCONFEXT_TERM) {
    if (k >= (EXT_COUNT_MAX - 1)) return UNEXPECTED_ERROR;
    bit_size_len = impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;
    ext_size_bits = bit_size_len + 4;

    bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits);
    if (it_bit_buff->error) return it_bit_buff->error;
    str_drc_config_ext->ext_bit_size[k] = bit_size + 1;

    switch (str_drc_config_ext->drc_config_ext_type[k]) {
      case UNIDRCCONFEXT_PARAM_DRC:
        str_drc_config_ext->parametric_drc_present = 1;
        err = impd_parametic_drc_parse_coeff(
            it_bit_buff, drc_config,
            &(str_drc_config_ext->str_drc_coeff_param_drc));
        if (err) return (err);
        str_drc_config_ext->parametric_drc_instructions_count =
            impd_read_bits_buf(it_bit_buff, 4);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (str_drc_config_ext->parametric_drc_instructions_count >
            PARAM_DRC_INSTRUCTIONS_COUNT_MAX)
          return (UNEXPECTED_ERROR);

        for (i = 0; i < str_drc_config_ext->parametric_drc_instructions_count;
             i++) {
          err = impd_parse_parametric_drc_instructions(
              it_bit_buff, str_drc_config_ext->str_drc_coeff_param_drc
                               .parametric_drc_frame_size,
              &(str_drc_config_ext->str_parametric_drc_instructions[i]));
          if (err) return (err);
        }
        break;
      case UNIDRCCONFEXT_V1:
        str_drc_config_ext->drc_extension_v1_present = 1;
        err = impd_parse_drc_ext_v1(it_bit_buff, ia_drc_params_struct,
                                    drc_config, str_drc_config_ext);
        if (err) return (err);
        break;
      default:
        for (i = 0; i < str_drc_config_ext->ext_bit_size[k]; i++) {
          other_bit = impd_read_bits_buf(it_bit_buff, 1);
          if (it_bit_buff->error) return it_bit_buff->error;
        }
        break;
    }
    k++;
    str_drc_config_ext->drc_config_ext_type[k] =
        impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;
  }

  return (0);
}

static WORD32 impd_parse_split_drc_characteristic(
    ia_bit_buf_struct* it_bit_buff, const WORD32 side,
    ia_split_drc_characteristic_struct* split_drc_characteristic) {
  // WORD32 err = 0;
  WORD32 i, temp;

  split_drc_characteristic->characteristic_format =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;
  if (split_drc_characteristic->characteristic_format == 0) {
    WORD32 bsGain, bsIoRatio, bsExp;
    bsGain = impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (side == LEFT_SIDE) {
      split_drc_characteristic->gain = (FLOAT32)bsGain;
    } else {
      split_drc_characteristic->gain = (FLOAT32)-bsGain;
    }
    temp = impd_read_bits_buf(it_bit_buff, 8);
    if (it_bit_buff->error) return it_bit_buff->error;

    bsIoRatio = (temp >> 4) & 0xf;
    bsExp = temp & 0xf;
    split_drc_characteristic->in_out_ratio = 0.05f + 0.15f * bsIoRatio;

    if (bsExp < 15) {
      split_drc_characteristic->exp = 1.0f + 2.0f * bsExp;
    } else {
      split_drc_characteristic->exp = 1000.0f;
    }
    split_drc_characteristic->flip_sign = impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
  } else {
    WORD32 char_node_cnt, node_level_delta, node_gain;
    char_node_cnt = impd_read_bits_buf(it_bit_buff, 2);
    if (it_bit_buff->error) return it_bit_buff->error;
    split_drc_characteristic->characteristic_node_count = char_node_cnt + 1;
    split_drc_characteristic->node_level[0] = DRC_INPUT_LOUDNESS_TARGET;
    split_drc_characteristic->node_gain[0] = 0.0f;
    for (i = 1; i <= split_drc_characteristic->characteristic_node_count; i++) {
      node_level_delta = impd_read_bits_buf(it_bit_buff, 5);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (side == LEFT_SIDE) {
        split_drc_characteristic->node_level[i] =
            split_drc_characteristic->node_level[i - 1] -
            (1.0f + node_level_delta);
      } else {
        split_drc_characteristic->node_level[i] =
            split_drc_characteristic->node_level[i - 1] +
            (1.0f + node_level_delta);
      }
      node_gain = impd_read_bits_buf(it_bit_buff, 8);
      if (it_bit_buff->error) return it_bit_buff->error;
      split_drc_characteristic->node_gain[i] = 0.5f * node_gain - 64.0f;
    }
  }
  return (0);
}

WORD32
impd_drc_gen_instructions_derived_data(
    ia_drc_config* drc_config,
    ia_drc_params_bs_dec_struct* ia_drc_params_struct,
    ia_drc_instructions_struct* str_drc_instruction_str) {
  WORD32 n, g;
  ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc = NULL;
  ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc = NULL;
  WORD32 gain_element_count = 0;

  for (n = 0; n < drc_config->drc_coefficients_drc_count; n++) {
    if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].drc_location ==
        str_drc_instruction_str->drc_location)
      break;
  }
  if ((n == drc_config->drc_coefficients_drc_count) &&
      (drc_config->drc_coefficients_drc_count > 0)) {
    return -1;
  }
  str_p_loc_drc_coefficients_uni_drc =
      &(drc_config->str_p_loc_drc_coefficients_uni_drc[n]);

  if (drc_config->drc_config_ext_present &&
      drc_config->str_drc_config_ext.parametric_drc_present &&
      drc_config->str_drc_config_ext.str_drc_coeff_param_drc.drc_location ==
          str_drc_instruction_str->drc_location) {
    str_drc_coeff_param_drc =
        &drc_config->str_drc_config_ext.str_drc_coeff_param_drc;
  }

  for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
    WORD32 seq = str_drc_instruction_str->gain_set_index_for_channel_group[g];
    if (seq != -1 &&
        (drc_config->drc_coefficients_drc_count == 0 ||
         seq >= str_p_loc_drc_coefficients_uni_drc->gain_set_count)) {
      str_drc_instruction_str->ch_group_parametric_drc_flag[g] = 1;
      if (drc_config->drc_coefficients_drc_count != 0) {
        seq = seq - str_p_loc_drc_coefficients_uni_drc->gain_set_count;
      }
      str_drc_instruction_str->gain_set_idx_of_ch_group_parametric_drc[g] = seq;

      if (str_drc_coeff_param_drc == NULL ||
          seq >= str_drc_coeff_param_drc->parametric_drc_gain_set_count) {
        /* parametric drc gain set not available */
        return (EXTERNAL_ERROR);
      }
      str_drc_instruction_str->gain_interpolation_type_for_channel_group[g] = 1;
      str_drc_instruction_str->time_delta_min_for_channel_group[g] =
          str_drc_coeff_param_drc->parametric_drc_frame_size;
      str_drc_instruction_str->time_alignment_for_channel_group[g] = 0;
    } else {
      str_drc_instruction_str->ch_group_parametric_drc_flag[g] = 0;
    }
    if (str_drc_instruction_str->ch_group_parametric_drc_flag[g] == 0) {
      if (seq >= str_p_loc_drc_coefficients_uni_drc->gain_set_count) {
        return -1;
      }
      str_drc_instruction_str->gain_interpolation_type_for_channel_group[g] =
          str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
              .gain_interpolation_type;
      if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
              .time_delt_min_flag) {
        str_drc_instruction_str->time_delta_min_for_channel_group[g] =
            str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
                .time_delt_min_val;
      } else {
        str_drc_instruction_str->time_delta_min_for_channel_group[g] =
            ia_drc_params_struct->delta_tmin_default;
      }
      str_drc_instruction_str->time_alignment_for_channel_group[g] =
          str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
              .time_alignment;
    }
  }

  if (str_drc_instruction_str->drc_set_effect &
      (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) {
    str_drc_instruction_str->gain_element_count =
        str_drc_instruction_str->num_drc_ch_groups;
  } else {
    for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
      if (str_drc_instruction_str->ch_group_parametric_drc_flag[g] == 1) {
        gain_element_count++;
        str_drc_instruction_str->band_count_of_ch_group[g] = 1;
      } else {
        WORD32 seq, band_count;
        seq = str_drc_instruction_str->gain_set_index_for_channel_group[g];
        band_count =
            str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq].band_count;
        str_drc_instruction_str->band_count_of_ch_group[g] = band_count;
        gain_element_count += band_count;
      }
    }
    str_drc_instruction_str->gain_element_count = gain_element_count;
  }

  return (0);
}

WORD32
impd_parse_drc_config(ia_bit_buf_struct* it_bit_buff,
                      ia_drc_params_bs_dec_struct* ia_drc_params_struct,
                      ia_drc_config* drc_config) {
  WORD32 i, err = 0, temp;
  WORD32 version = 0;

  drc_config->sample_rate_present = impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (drc_config->sample_rate_present == 1) {
    WORD32 bssample_rate;
    bssample_rate = impd_read_bits_buf(it_bit_buff, 18);
    if (it_bit_buff->error) return it_bit_buff->error;
    drc_config->sampling_rate = bssample_rate + 1000;
  }

  temp = impd_read_bits_buf(it_bit_buff, 8);
  if (it_bit_buff->error) return it_bit_buff->error;

  drc_config->dwnmix_instructions_count = (temp >> 1) & 0x7f;
  if (drc_config->dwnmix_instructions_count > DOWNMIX_INSTRUCTION_COUNT_MAX)
    return (UNEXPECTED_ERROR);

  drc_config->drc_description_basic_present = temp & 1;

  if (drc_config->drc_description_basic_present == 1) {
    temp = impd_read_bits_buf(it_bit_buff, 7);
    if (it_bit_buff->error) return it_bit_buff->error;

    drc_config->drc_coefficients_basic_count = (temp >> 4) & 7;
    drc_config->drc_instructions_basic_count = temp & 0xf;

  } else {
    drc_config->drc_coefficients_basic_count = 0;
    drc_config->drc_instructions_basic_count = 0;
  }

  temp = impd_read_bits_buf(it_bit_buff, 9);
  if (it_bit_buff->error) return it_bit_buff->error;

  drc_config->drc_coefficients_drc_count = (temp >> 6) & 7;
  drc_config->drc_instructions_uni_drc_count = temp & 0x3f;

  if (drc_config->drc_instructions_uni_drc_count > DRC_INSTRUCTIONS_COUNT_MAX)
    return (UNEXPECTED_ERROR);

  err = impd_parse_ch_layout(it_bit_buff, ia_drc_params_struct,
                             &drc_config->channel_layout);
  if (err) return (err);

  for (i = 0; i < drc_config->dwnmix_instructions_count; i++) {
    err = impd_parse_dwnmix_instructions(
        it_bit_buff, version, ia_drc_params_struct, &drc_config->channel_layout,
        &(drc_config->dwnmix_instructions[i]));
    if (err) return (err);
  }
  for (i = 0; i < drc_config->drc_coefficients_basic_count; i++) {
    temp = impd_read_bits_buf(it_bit_buff, 11);
    if (it_bit_buff->error) return it_bit_buff->error;

    drc_config->str_drc_coefficients_basic[i].drc_location = (temp >> 7) & 0xf;
    drc_config->str_drc_coefficients_basic[i].drc_characteristic = temp & 0x3f;
  }
  for (i = 0; i < drc_config->drc_instructions_basic_count; i++) {
    err = impd_drc_parse_instructions_basic(
        it_bit_buff, &(drc_config->str_drc_instructions_basic[i]));
    if (err) return (err);
  }
  for (i = 0; i < drc_config->drc_coefficients_drc_count; i++) {
    err = impd_drc_parse_coeff(
        it_bit_buff, version, ia_drc_params_struct,
        &(drc_config->str_p_loc_drc_coefficients_uni_drc[i]));
    if (err) return (err);
  }
  for (i = 0; i < drc_config->drc_instructions_uni_drc_count; i++) {
    err = impd_parse_drc_instructions_uni_drc(
        it_bit_buff, version, drc_config,
        &(drc_config->str_drc_instruction_str[i]));
    if (err) return (err);
  }

  drc_config->drc_config_ext_present = impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (drc_config->drc_config_ext_present == 1) {
    err =
        impd_parse_drc_config_ext(it_bit_buff, ia_drc_params_struct, drc_config,
                                  &(drc_config->str_drc_config_ext));
    if (err) return (err);
  }

  if (drc_config->str_drc_config_ext.parametric_drc_present) {
    err = impd_parametric_drc_gen_virtual_gain_sets(drc_config);
    if (err) return (err);
  }

  for (i = 0; i < drc_config->drc_instructions_uni_drc_count; i++) {
    err = impd_drc_gen_instructions_derived_data(
        drc_config, ia_drc_params_struct,
        &(drc_config->str_drc_instruction_str[i]));
    if (err) return (err);
  }

  impd_drc_gen_instructions_for_drc_off(drc_config);
  return (0);
}

WORD32
impd_dec_method_value(ia_bit_buf_struct* it_bit_buff, WORD32 method_def,
                      FLOAT32* method_val) {
  // WORD32 err = 0;
  WORD32 tmp;
  FLOAT32 val;
  switch (method_def) {
    case METHOD_DEFINITION_UNKNOWN_OTHER:
    case METHOD_DEFINITION_PROGRAM_LOUDNESS:
    case METHOD_DEFINITION_ANCHOR_LOUDNESS:
    case METHOD_DEFINITION_MAX_OF_LOUDNESS_RANGE:
    case METHOD_DEFINITION_MOMENTARY_LOUDNESS_MAX:
    case METHOD_DEFINITION_SHORT_TERM_LOUDNESS_MAX:
      tmp = impd_read_bits_buf(it_bit_buff, 8);
      if (it_bit_buff->error) return it_bit_buff->error;
      val = -57.75f + tmp * 0.25f;
      break;
    case METHOD_DEFINITION_LOUDNESS_RANGE:
      tmp = impd_read_bits_buf(it_bit_buff, 8);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (tmp == 0)
        val = 0.0f;
      else if (tmp <= 128)
        val = tmp * 0.25f;
      else if (tmp <= 204)
        val = 0.5f * tmp - 32.0f;
      else
        val = tmp - 134.0f;
      break;
    case METHOD_DEFINITION_MIXING_LEVEL:
      tmp = impd_read_bits_buf(it_bit_buff, 5);
      if (it_bit_buff->error) return it_bit_buff->error;
      val = tmp + 80.0f;
      break;
    case METHOD_DEFINITION_ROOM_TYPE:
      tmp = impd_read_bits_buf(it_bit_buff, 2);
      if (it_bit_buff->error) return it_bit_buff->error;
      val = (FLOAT32)tmp;
      break;
    case METHOD_DEFINITION_SHORT_TERM_LOUDNESS:
      tmp = impd_read_bits_buf(it_bit_buff, 8);
      if (it_bit_buff->error) return it_bit_buff->error;
      val = -116.f + tmp * 0.5f;
      break;
    default:
      return -1;
      break;
  }
  *method_val = val;
  return 0;
}

WORD32
impd_parse_loudness_info_set(
    ia_bit_buf_struct* it_bit_buff,
    ia_drc_loudness_info_set_struct* loudness_info_set) {
  WORD32 err = 0, i, version = 0, offset, temp;
  WORD32 loudness_info_album_count, loudness_info_count;

  temp = impd_read_bits_buf(it_bit_buff, 12);
  if (it_bit_buff->error) return it_bit_buff->error;

  loudness_info_album_count = (temp >> 6) & 0x3f;
  loudness_info_count = temp & 0x3f;

  offset = loudness_info_set->loudness_info_album_count;
  loudness_info_set->loudness_info_album_count += loudness_info_album_count;
  if ((offset + loudness_info_set->loudness_info_album_count) >
      LOUDNESS_INFO_COUNT_MAX)
    return (UNEXPECTED_ERROR);
  for (i = 0; i < loudness_info_set->loudness_info_album_count; i++) {
    err = impd_parse_loudness_info(
        it_bit_buff, version,
        &(loudness_info_set->str_loudness_info_album[i + offset]));
    if (err) return (err);
  }

  offset = loudness_info_set->loudness_info_count;
  loudness_info_set->loudness_info_count += loudness_info_count;
  if ((offset + loudness_info_set->loudness_info_count) >
      LOUDNESS_INFO_COUNT_MAX)
    return (UNEXPECTED_ERROR);
  for (i = 0; i < loudness_info_set->loudness_info_count; i++) {
    err = impd_parse_loudness_info(
        it_bit_buff, version, &(loudness_info_set->loudness_info[i + offset]));
    if (err) return (err);
  }

  loudness_info_set->loudness_info_set_ext_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (loudness_info_set->loudness_info_set_ext_present == 1) {
    err = impd_parse_loudness_info_set_ext(it_bit_buff, loudness_info_set);
    if (err) return (err);
  }

  return (0);
}

WORD32
impd_parse_gain_set_params_characteristics(ia_bit_buf_struct* it_bit_buff,
                                           WORD32 version,
                                           ia_gain_params_struct* gain_params) {
  // WORD32 err = 0;
  WORD32 temp;
  if (version == 0) {
    gain_params->drc_characteristic = impd_read_bits_buf(it_bit_buff, 7);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (gain_params->drc_characteristic > 0) {
      gain_params->drc_characteristic_present = 1;
      gain_params->drc_characteristic_format_is_cicp = 1;
    } else {
      gain_params->drc_characteristic_present = 0;
    }
  } else {
    gain_params->drc_characteristic_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (gain_params->drc_characteristic_present) {
      gain_params->drc_characteristic_format_is_cicp =
          impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (gain_params->drc_characteristic_format_is_cicp) {
        gain_params->drc_characteristic = impd_read_bits_buf(it_bit_buff, 7);
        if (it_bit_buff->error) return it_bit_buff->error;
      } else {
        temp = impd_read_bits_buf(it_bit_buff, 8);
        if (it_bit_buff->error) return it_bit_buff->error;

        gain_params->drc_characteristic_left_index = (temp >> 4) & 0xf;
        gain_params->drc_characteristic_right_index = temp & 0xf;
      }
    }
  }
  return (0);
}

WORD32
impd_parse_loudness_measure(ia_bit_buf_struct* it_bit_buff,
                            ia_loudness_measure_struct* loudness_measure) {
  WORD32 err = 0, temp;

  loudness_measure->method_def = impd_read_bits_buf(it_bit_buff, 4);
  if (it_bit_buff->error) return it_bit_buff->error;

  err = impd_dec_method_value(it_bit_buff, loudness_measure->method_def,
                              &(loudness_measure->method_val));
  if (err) return err;

  temp = impd_read_bits_buf(it_bit_buff, 6);
  if (it_bit_buff->error) return it_bit_buff->error;

  loudness_measure->measurement_system = (temp >> 2) & 0xf;
  if (loudness_measure->measurement_system > MEASUREMENT_SYSTEM_RESERVED_E)
    return (UNEXPECTED_ERROR);
  /* Parsed but unused */
  loudness_measure->reliability = temp & 3;

  return (0);
}

WORD32
impd_dec_gain_modifiers(ia_bit_buf_struct* it_bit_buff, WORD32 version,
                        WORD32 band_count,
                        ia_gain_modifiers_struct* pstr_gain_modifiers) {
  // WORD32 err = 0;
  WORD32 sign, temp;

  if (version > 0) {
    WORD32 b;
    for (b = 0; b < band_count; b++) {
      pstr_gain_modifiers->target_characteristic_left_present[b] =
          impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (pstr_gain_modifiers->target_characteristic_left_present[b]) {
        pstr_gain_modifiers->target_characteristic_left_index[b] =
            impd_read_bits_buf(it_bit_buff, 4);
        if (it_bit_buff->error) return it_bit_buff->error;
      }
      pstr_gain_modifiers->target_characteristic_right_present[b] =
          impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (pstr_gain_modifiers->target_characteristic_right_present[b]) {
        pstr_gain_modifiers->target_characteristic_right_index[b] =
            impd_read_bits_buf(it_bit_buff, 4);
        if (it_bit_buff->error) return it_bit_buff->error;
      }
      pstr_gain_modifiers->gain_scaling_flag[b] =
          impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (pstr_gain_modifiers->gain_scaling_flag[b]) {
        temp = impd_read_bits_buf(it_bit_buff, 8);
        if (it_bit_buff->error) return it_bit_buff->error;

        pstr_gain_modifiers->attn_scaling[b] = ((temp >> 4) & 0xf) * 0.125f;
        pstr_gain_modifiers->ampl_scaling[b] = (temp & 0xf) * 0.125f;
      }

      pstr_gain_modifiers->gain_offset_flag[b] =
          impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (pstr_gain_modifiers->gain_offset_flag[b]) {
        FLOAT32 gain_offset;
        temp = impd_read_bits_buf(it_bit_buff, 6);
        if (it_bit_buff->error) return it_bit_buff->error;

        sign = ((temp >> 5) & 1);
        gain_offset = (1 + (temp & 0x1f)) * 0.25f;

        if (sign) {
          gain_offset = -gain_offset;
        }
        pstr_gain_modifiers->gain_offset[b] = gain_offset;
      }
    }
    if (band_count == 1) {
      pstr_gain_modifiers->shape_filter_flag =
          impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (pstr_gain_modifiers->shape_filter_flag) {
        pstr_gain_modifiers->shape_filter_idx =
            impd_read_bits_buf(it_bit_buff, 4);
        if (it_bit_buff->error) return it_bit_buff->error;
      }
    }
  } else if (version == 0) {
    WORD32 b, gain_scaling_flag, gain_offset_flag;
    FLOAT32 attn_scaling = 1.0f, ampl_scaling = 1.0f, gain_offset = 0.0f;

    gain_scaling_flag = impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (gain_scaling_flag) {
      temp = impd_read_bits_buf(it_bit_buff, 8);
      if (it_bit_buff->error) return it_bit_buff->error;

      attn_scaling = ((temp >> 4) & 0xf) * 0.125f;
      ampl_scaling = (temp & 0xf) * 0.125f;
    }

    gain_offset_flag = impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (gain_offset_flag) {
      temp = impd_read_bits_buf(it_bit_buff, 6);
      if (it_bit_buff->error) return it_bit_buff->error;

      sign = ((temp >> 5) & 1);
      gain_offset = (1 + (temp & 0x1f)) * 0.25f;

      if (sign) {
        gain_offset = -gain_offset;
      }
    }
    for (b = 0; b < band_count; b++) {
      pstr_gain_modifiers->target_characteristic_left_present[b] = 0;
      pstr_gain_modifiers->target_characteristic_right_present[b] = 0;
      pstr_gain_modifiers->gain_scaling_flag[b] = gain_scaling_flag;
      pstr_gain_modifiers->attn_scaling[b] = attn_scaling;
      pstr_gain_modifiers->ampl_scaling[b] = ampl_scaling;
      pstr_gain_modifiers->gain_offset_flag[b] = gain_offset_flag;
      pstr_gain_modifiers->gain_offset[b] = gain_offset;
    }
    pstr_gain_modifiers->shape_filter_flag = 0;
  }
  return (0);
}

WORD32
impd_parse_gain_set_params(ia_bit_buf_struct* it_bit_buff, WORD32 version,
                           WORD32* gain_seq_idx,
                           ia_gain_set_params_struct* gain_set_params) {
  WORD32 err = 0, i, temp;

  temp = impd_read_bits_buf(it_bit_buff, 6);
  if (it_bit_buff->error) return it_bit_buff->error;

  gain_set_params->gain_coding_profile = (temp >> 4) & 3;
  gain_set_params->gain_interpolation_type = (temp >> 3) & 1;
  gain_set_params->full_frame = (temp >> 2) & 1;
  gain_set_params->time_alignment = (temp >> 1) & 1;
  gain_set_params->time_delt_min_flag = temp & 1;

  if (gain_set_params->time_delt_min_flag) {
    WORD32 time_delta_min;
    time_delta_min = impd_read_bits_buf(it_bit_buff, 11);
    if (it_bit_buff->error) return it_bit_buff->error;
    gain_set_params->time_delt_min_val = time_delta_min + 1;
  }

  if (gain_set_params->gain_coding_profile == GAIN_CODING_PROFILE_CONSTANT) {
    gain_set_params->band_count = 1;
    *gain_seq_idx = (*gain_seq_idx) + 1;
  } else {
    gain_set_params->band_count = impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (gain_set_params->band_count > BAND_COUNT_MAX) return (UNEXPECTED_ERROR);

    if (gain_set_params->band_count > 1) {
      gain_set_params->drc_band_type = impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
    }
    for (i = 0; i < gain_set_params->band_count; i++) {
      if (version == 0) {
        *gain_seq_idx = (*gain_seq_idx) + 1;
      } else {
        WORD32 indexPresent;
        indexPresent = impd_read_bits_buf(it_bit_buff, 1);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (indexPresent) {
          WORD32 bsIndex;
          bsIndex = impd_read_bits_buf(it_bit_buff, 6);
          if (it_bit_buff->error) return it_bit_buff->error;
          *gain_seq_idx = bsIndex;
        } else {
          *gain_seq_idx = (*gain_seq_idx) + 1;
        }
      }

      if (*gain_seq_idx >= SEQUENCE_COUNT_MAX) return UNEXPECTED_ERROR;

      gain_set_params->gain_params[i].gain_seq_idx = *gain_seq_idx;
      err = impd_parse_gain_set_params_characteristics(
          it_bit_buff, version, &(gain_set_params->gain_params[i]));
      if (err) return (err);
    }
    if (gain_set_params->drc_band_type) {
      for (i = 1; i < gain_set_params->band_count; i++) {
        gain_set_params->gain_params[i].crossover_freq_idx =
            impd_read_bits_buf(it_bit_buff, 4);
        if (it_bit_buff->error) return it_bit_buff->error;
      }
    } else {
      for (i = 1; i < gain_set_params->band_count; i++) {
        gain_set_params->gain_params[i].start_subband_index =
            impd_read_bits_buf(it_bit_buff, 10);
        if (it_bit_buff->error) return it_bit_buff->error;
      }
    }
  }

  return (0);
}

WORD32
impd_sel_drc_coeff(
    ia_drc_config* drc_config, WORD32 location,
    ia_uni_drc_coeffs_struct** str_p_loc_drc_coefficients_uni_drc) {
  WORD32 n;
  WORD32 c1 = -1;
  WORD32 c0 = -1;
  for (n = 0; n < drc_config->drc_coefficients_drc_count; n++) {
    if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].drc_location ==
        location) {
      if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].version == 0) {
        c0 = n;
      } else {
        c1 = n;
      }
    }
  }
  if (c1 >= 0) {
    *str_p_loc_drc_coefficients_uni_drc =
        &(drc_config->str_p_loc_drc_coefficients_uni_drc[c1]);
  } else if (c0 >= 0) {
    *str_p_loc_drc_coefficients_uni_drc =
        &(drc_config->str_p_loc_drc_coefficients_uni_drc[c0]);
  } else {
    *str_p_loc_drc_coefficients_uni_drc = NULL;
  }
  return (0);
}

WORD32
impd_parse_loudness_info_set_ext(
    ia_bit_buf_struct* it_bit_buff,
    ia_drc_loudness_info_set_struct* loudness_info_set) {
  WORD32 err = 0, i, k;
  WORD32 bit_size_len, ext_size_bits, bit_size, other_bit;

  k = 0;
  loudness_info_set->str_loudness_info_set_ext.loudness_info_set_ext_type[k] =
      impd_read_bits_buf(it_bit_buff, 4);
  if (it_bit_buff->error) return it_bit_buff->error;
  while (loudness_info_set->str_loudness_info_set_ext
             .loudness_info_set_ext_type[k] != UNIDRCLOUDEXT_TERM) {
    bit_size_len = impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;
    ext_size_bits = bit_size_len + 4;

    bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (k >= (EXT_COUNT_MAX - 1)) return UNEXPECTED_ERROR;
    loudness_info_set->str_loudness_info_set_ext.ext_bit_size[k] = bit_size + 1;

    switch (loudness_info_set->str_loudness_info_set_ext
                .loudness_info_set_ext_type[k]) {
      case UNIDRCLOUDEXT_EQ:
        err = impd_parse_loud_info_set_ext_eq(it_bit_buff, loudness_info_set);
        if (err) return (err);
        break;
      default:
        for (i = 0;
             i < loudness_info_set->str_loudness_info_set_ext.ext_bit_size[k];
             i++) {
          other_bit = impd_read_bits_buf(it_bit_buff, 1);
          if (it_bit_buff->error) return it_bit_buff->error;
        }
        break;
    }
    k++;
    loudness_info_set->str_loudness_info_set_ext.loudness_info_set_ext_type[k] =
        impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;
  }

  return (0);
}

WORD32
impd_drc_parse_coeff(
    ia_bit_buf_struct* it_bit_buff, WORD32 version,
    ia_drc_params_bs_dec_struct* ia_drc_params_struct,
    ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc) {
  WORD32 err = 0, i, drc_frame_size, temp;
  WORD32 gain_seq_idx = -1;

  str_p_loc_drc_coefficients_uni_drc->version = version;
  if (version == 0) {
    WORD32 gain_sequence_count = 0;
    temp = impd_read_bits_buf(it_bit_buff, 5);
    if (it_bit_buff->error) return it_bit_buff->error;

    str_p_loc_drc_coefficients_uni_drc->drc_location = (temp >> 1) & 0xf;
    str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = temp & 1;

    if (str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present == 1) {
      drc_frame_size = impd_read_bits_buf(it_bit_buff, 15);
      if (it_bit_buff->error) return it_bit_buff->error;
      str_p_loc_drc_coefficients_uni_drc->drc_frame_size = drc_frame_size + 1;
    }

    str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present = 0;
    str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present = 0;
    str_p_loc_drc_coefficients_uni_drc->shape_filters_present = 0;
    str_p_loc_drc_coefficients_uni_drc->gain_set_count =
        impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (str_p_loc_drc_coefficients_uni_drc->gain_set_count > GAIN_SET_COUNT_MAX)
      return (UNEXPECTED_ERROR);

    str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus =
        str_p_loc_drc_coefficients_uni_drc->gain_set_count;
    for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) {
      err = impd_parse_gain_set_params(
          it_bit_buff, version, &gain_seq_idx,
          &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]));
      if (err) return (err);

      if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
              .time_delt_min_flag) {
        if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                .time_delt_min_val > ia_drc_params_struct->drc_frame_size) {
          /* drc time interval too big */
          return (PARAM_ERROR);
        }
        str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
            .num_gain_max_values =
            ia_drc_params_struct->drc_frame_size /
            str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                .time_delt_min_val;
        err = impd_init_tbls(
            str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                .num_gain_max_values,
            &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                  .str_tables));
        if (err) return (err);
      }
      gain_sequence_count +=
          str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count;
    }
    str_p_loc_drc_coefficients_uni_drc->gain_sequence_count =
        gain_sequence_count;
  } else {
    ia_shape_filter_block_params_struct* pstr_shape_filter_block_params;
    for (i = 0; i < SEQUENCE_COUNT_MAX; i++) {
      str_p_loc_drc_coefficients_uni_drc
          ->gain_set_params_index_for_gain_sequence[i] = -1;
    }

    temp = impd_read_bits_buf(it_bit_buff, 5);
    if (it_bit_buff->error) return it_bit_buff->error;

    str_p_loc_drc_coefficients_uni_drc->drc_location = (temp >> 1) & 0xf;
    str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = temp & 1;

    if (str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present == 1) {
      drc_frame_size = impd_read_bits_buf(it_bit_buff, 15);
      if (it_bit_buff->error) return it_bit_buff->error;
      str_p_loc_drc_coefficients_uni_drc->drc_frame_size = drc_frame_size + 1;
    }
    str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present ==
        1) {
      str_p_loc_drc_coefficients_uni_drc->characteristic_left_count =
          impd_read_bits_buf(it_bit_buff, 4);
      if (it_bit_buff->error) return it_bit_buff->error;

      if (str_p_loc_drc_coefficients_uni_drc->characteristic_left_count >
          SPLIT_CHARACTERISTIC_COUNT_MAX)
        return (UNEXPECTED_ERROR);

      for (i = 1;
           i <= str_p_loc_drc_coefficients_uni_drc->characteristic_left_count;
           i++) {
        err = impd_parse_split_drc_characteristic(
            it_bit_buff, LEFT_SIDE, &(str_p_loc_drc_coefficients_uni_drc
                                          ->str_split_characteristic_left[i]));
        if (err) return (err);
      }
    }
    str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present ==
        1) {
      str_p_loc_drc_coefficients_uni_drc->characteristic_right_count =
          impd_read_bits_buf(it_bit_buff, 4);
      if (it_bit_buff->error) return it_bit_buff->error;

      if (str_p_loc_drc_coefficients_uni_drc->characteristic_right_count >
          SPLIT_CHARACTERISTIC_COUNT_MAX)
        return (UNEXPECTED_ERROR);
      for (i = 1;
           i <= str_p_loc_drc_coefficients_uni_drc->characteristic_right_count;
           i++) {
        err = impd_parse_split_drc_characteristic(
            it_bit_buff, RIGHT_SIDE,
            &(str_p_loc_drc_coefficients_uni_drc
                  ->str_split_characteristic_right[i]));
        if (err) return (err);
      }
    }
    str_p_loc_drc_coefficients_uni_drc->shape_filters_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (str_p_loc_drc_coefficients_uni_drc->shape_filters_present == 1) {
      str_p_loc_drc_coefficients_uni_drc->shape_num_filter =
          impd_read_bits_buf(it_bit_buff, 4);
      if (it_bit_buff->error) return it_bit_buff->error;
      if (str_p_loc_drc_coefficients_uni_drc->shape_num_filter >
          SHAPE_FILTER_COUNT_MAX)
        return (UNEXPECTED_ERROR);
      for (i = 1; i <= str_p_loc_drc_coefficients_uni_drc->shape_num_filter;
           i++) {
        pstr_shape_filter_block_params =
            &(str_p_loc_drc_coefficients_uni_drc
                  ->str_shape_filter_block_params[i]);
        pstr_shape_filter_block_params->lf_cut_filter_present =
            impd_read_bits_buf(it_bit_buff, 1);
        if (it_bit_buff->error) return it_bit_buff->error;

        if (pstr_shape_filter_block_params->lf_cut_filter_present == 1) {
          temp = impd_read_bits_buf(it_bit_buff, 5);
          if (it_bit_buff->error) return it_bit_buff->error;

          pstr_shape_filter_block_params->str_lf_cut_params.corner_freq_index =
              (temp >> 2) & 7;
          pstr_shape_filter_block_params->str_lf_cut_params
              .filter_strength_index = temp & 3;
        }
        pstr_shape_filter_block_params->lf_boost_filter_present =
            impd_read_bits_buf(it_bit_buff, 1);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (pstr_shape_filter_block_params->lf_boost_filter_present == 1) {
          temp = impd_read_bits_buf(it_bit_buff, 5);
          if (it_bit_buff->error) return it_bit_buff->error;

          pstr_shape_filter_block_params->str_lf_boost_params
              .corner_freq_index = (temp >> 2) & 7;
          pstr_shape_filter_block_params->str_lf_boost_params
              .filter_strength_index = temp & 3;
        }
        pstr_shape_filter_block_params->hf_cut_filter_present =
            impd_read_bits_buf(it_bit_buff, 1);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (pstr_shape_filter_block_params->hf_cut_filter_present == 1) {
          temp = impd_read_bits_buf(it_bit_buff, 5);
          if (it_bit_buff->error) return it_bit_buff->error;

          pstr_shape_filter_block_params->str_hfCutParams.corner_freq_index =
              (temp >> 2) & 7;
          pstr_shape_filter_block_params->str_hfCutParams
              .filter_strength_index = temp & 3;
        }
        pstr_shape_filter_block_params->hf_boost_filter_present =
            impd_read_bits_buf(it_bit_buff, 1);
        if (it_bit_buff->error) return it_bit_buff->error;
        if (pstr_shape_filter_block_params->hf_boost_filter_present == 1) {
          temp = impd_read_bits_buf(it_bit_buff, 5);
          if (it_bit_buff->error) return it_bit_buff->error;

          pstr_shape_filter_block_params->str_hf_boost_params
              .corner_freq_index = (temp >> 2) & 7;
          pstr_shape_filter_block_params->str_hf_boost_params
              .filter_strength_index = temp & 3;
        }
      }
    }

    temp = impd_read_bits_buf(it_bit_buff, 12);
    if (it_bit_buff->error) return it_bit_buff->error;

    str_p_loc_drc_coefficients_uni_drc->gain_sequence_count =
        (temp >> 6) & 0x3f;

    if (str_p_loc_drc_coefficients_uni_drc->gain_sequence_count >
        SEQUENCE_COUNT_MAX)
      return UNEXPECTED_ERROR;

    str_p_loc_drc_coefficients_uni_drc->gain_set_count = temp & 0x3f;

    if (str_p_loc_drc_coefficients_uni_drc->gain_set_count > GAIN_SET_COUNT_MAX)
      return (UNEXPECTED_ERROR);

    str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus =
        str_p_loc_drc_coefficients_uni_drc->gain_set_count;
    for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) {
      err = impd_parse_gain_set_params(
          it_bit_buff, version, &gain_seq_idx,
          &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]));
      if (err) return (err);

      if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
              .time_delt_min_flag) {
        if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                .time_delt_min_val > ia_drc_params_struct->drc_frame_size) {
          /* drc time interval too big */
          return (PARAM_ERROR);
        }
        str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
            .num_gain_max_values =
            ia_drc_params_struct->drc_frame_size /
            str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                .time_delt_min_val;
        err = impd_init_tbls(
            str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                .num_gain_max_values,
            &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                  .str_tables));
        if (err) return (err);
      }
    }

    for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) {
      WORD32 b;
      for (b = 0;
           b <
           str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count;
           b++) {
        str_p_loc_drc_coefficients_uni_drc
            ->gain_set_params_index_for_gain_sequence
                [str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
                     .gain_params[b]
                     .gain_seq_idx] = i;
      }
    }
  }
  return (0);
}

WORD32
impd_drc_parse_instructions_basic(
    ia_bit_buf_struct* it_bit_buff,
    ia_drc_instructions_basic_struct* str_drc_instructions_basic) {
  // WORD32 err = 0;
  WORD32 i, limiter_peak_target, temp;
  WORD32 additional_dmix_id_present, additional_dmix_id_cnt;

  temp = impd_read_bits_buf(it_bit_buff, 18);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_drc_instructions_basic->drc_set_id = (temp >> 12) & 0x3f;
  str_drc_instructions_basic->drc_location = (temp >> 8) & 0xf;
  str_drc_instructions_basic->downmix_id[0] = (temp >> 1) & 0x7f;
  additional_dmix_id_present = temp & 1;
  str_drc_instructions_basic->dwnmix_id_count = 1;

  if (additional_dmix_id_present) {
    additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 3);
    if (it_bit_buff->error) return it_bit_buff->error;
    for (i = 0; i < additional_dmix_id_cnt; i++) {
      str_drc_instructions_basic->downmix_id[i + 1] =
          impd_read_bits_buf(it_bit_buff, 7);
      if (it_bit_buff->error) return it_bit_buff->error;
    }
    str_drc_instructions_basic->dwnmix_id_count = 1 + additional_dmix_id_cnt;
  }

  str_drc_instructions_basic->drc_set_effect =
      impd_read_bits_buf(it_bit_buff, 16);
  if (it_bit_buff->error) return it_bit_buff->error;

  if ((str_drc_instructions_basic->drc_set_effect &
       (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) == 0) {
    str_drc_instructions_basic->limiter_peak_target_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (str_drc_instructions_basic->limiter_peak_target_present) {
      limiter_peak_target = impd_read_bits_buf(it_bit_buff, 8);
      if (it_bit_buff->error) return it_bit_buff->error;
      str_drc_instructions_basic->limiter_peak_target =
          -limiter_peak_target * 0.125f;
    }
  }

  str_drc_instructions_basic->drc_set_target_loudness_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_drc_instructions_basic->drc_set_target_loudness_value_upper = 0;
  str_drc_instructions_basic->drc_set_target_loudness_value_lower = -63;

  if (str_drc_instructions_basic->drc_set_target_loudness_present == 1) {
    WORD32 bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower;
    bsDrcSetTargetLoudnessValueUpper = impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;
    str_drc_instructions_basic->drc_set_target_loudness_value_upper =
        bsDrcSetTargetLoudnessValueUpper - 63;

    str_drc_instructions_basic->drc_set_target_loudness_value_lower_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (str_drc_instructions_basic
            ->drc_set_target_loudness_value_lower_present == 1) {
      bsDrcSetTargetLoudnessValueLower = impd_read_bits_buf(it_bit_buff, 6);
      if (it_bit_buff->error) return it_bit_buff->error;
      str_drc_instructions_basic->drc_set_target_loudness_value_lower =
          bsDrcSetTargetLoudnessValueLower - 63;
    }
  }

  return (0);
}

WORD32
impd_dec_ducking_scaling(ia_bit_buf_struct* it_bit_buff,
                         WORD32* ducking_scaling_flag,
                         FLOAT32* p_ducking_scaling) {
  WORD32 ducking_scaling_present, ducking_scaling, sigma, mu;

  ducking_scaling_present = impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (ducking_scaling_present == 0) {
    *ducking_scaling_flag = 0;
    *p_ducking_scaling = 1.0f;
  } else {
    *ducking_scaling_flag = 1;
    ducking_scaling = impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;

    sigma = ducking_scaling >> 3;
    mu = ducking_scaling & 0x7;

    if (sigma == 0) {
      *p_ducking_scaling = 1.0f + 0.125f * (1.0f + mu);
    } else {
      *p_ducking_scaling = 1.0f - 0.125f * (1.0f + mu);
    }
  }
  return (0);
}

WORD32
impd_parse_drc_instructions_uni_drc(
    ia_bit_buf_struct* it_bit_buff, WORD32 version, ia_drc_config* drc_config,
    ia_drc_instructions_struct* str_drc_instruction_str) {
  WORD32 err = 0, i, n, k, g, c, limiter_peak_target, idx;
  WORD32 additional_dmix_id_present, additional_dmix_id_cnt;
  ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc = NULL;
  WORD32 ch_cnt;
  WORD32 unique_idx[MAX_CHANNEL_COUNT];
  FLOAT32 unique_scaling[MAX_CHANNEL_COUNT];
  WORD32 match;
  WORD32 dmix_id_present;
  WORD32 repeat_parameters, repeat_parameters_cnt;
  WORD32 ducking_sequence;
  FLOAT32 factor;

  str_drc_instruction_str->drc_set_id = impd_read_bits_buf(it_bit_buff, 6);
  if (it_bit_buff->error) return it_bit_buff->error;
  if (str_drc_instruction_str->drc_set_id >= DRC_INSTRUCTIONS_COUNT_MAX)
    return UNEXPECTED_ERROR;
  if (version == 0) {
    str_drc_instruction_str->drc_set_complexity_level =
        DRC_COMPLEXITY_LEVEL_MAX;
  } else {
    str_drc_instruction_str->drc_set_complexity_level =
        impd_read_bits_buf(it_bit_buff, 4);
    if (it_bit_buff->error) return it_bit_buff->error;
  }
  str_drc_instruction_str->drc_location = impd_read_bits_buf(it_bit_buff, 4);
  if (it_bit_buff->error) return it_bit_buff->error;
  dmix_id_present = 1;
  if (version >= 1) {
    dmix_id_present = impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
  }
  if (dmix_id_present == 1) {
    str_drc_instruction_str->downmix_id[0] = impd_read_bits_buf(it_bit_buff, 7);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (version >= 1) {
      str_drc_instruction_str->drc_apply_to_dwnmix =
          impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;
    }
    if (version == 0) {
      if (str_drc_instruction_str->downmix_id[0] == 0) {
        str_drc_instruction_str->drc_apply_to_dwnmix = 0;
      } else {
        str_drc_instruction_str->drc_apply_to_dwnmix = 1;
      }
    }
    additional_dmix_id_present = impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (additional_dmix_id_present) {
      additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 3);
      if (it_bit_buff->error) return it_bit_buff->error;
      for (i = 0; i < additional_dmix_id_cnt; i++) {
        str_drc_instruction_str->downmix_id[i + 1] =
            impd_read_bits_buf(it_bit_buff, 7);
        if (it_bit_buff->error) return it_bit_buff->error;
      }
      str_drc_instruction_str->dwnmix_id_count = 1 + additional_dmix_id_cnt;
    } else {
      str_drc_instruction_str->dwnmix_id_count = 1;
    }
  } else {
    str_drc_instruction_str->downmix_id[0] = 0;
    str_drc_instruction_str->dwnmix_id_count = 1;
  }

  str_drc_instruction_str->drc_set_effect = impd_read_bits_buf(it_bit_buff, 16);
  if (it_bit_buff->error) return it_bit_buff->error;

  if ((str_drc_instruction_str->drc_set_effect &
       (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) == 0) {
    str_drc_instruction_str->limiter_peak_target_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (str_drc_instruction_str->limiter_peak_target_present) {
      limiter_peak_target = impd_read_bits_buf(it_bit_buff, 8);
      if (it_bit_buff->error) return it_bit_buff->error;
      str_drc_instruction_str->limiter_peak_target =
          -limiter_peak_target * 0.125f;
    }
  }

  str_drc_instruction_str->drc_set_target_loudness_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_drc_instruction_str->drc_set_target_loudness_value_upper = 0;
  str_drc_instruction_str->drc_set_target_loudness_value_lower = -63;

  if (str_drc_instruction_str->drc_set_target_loudness_present == 1) {
    WORD32 bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower;
    bsDrcSetTargetLoudnessValueUpper = impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;
    str_drc_instruction_str->drc_set_target_loudness_value_upper =
        bsDrcSetTargetLoudnessValueUpper - 63;
    str_drc_instruction_str->drc_set_target_loudness_value_lower_present =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
    if (str_drc_instruction_str->drc_set_target_loudness_value_lower_present ==
        1) {
      bsDrcSetTargetLoudnessValueLower = impd_read_bits_buf(it_bit_buff, 6);
      if (it_bit_buff->error) return it_bit_buff->error;
      str_drc_instruction_str->drc_set_target_loudness_value_lower =
          bsDrcSetTargetLoudnessValueLower - 63;
    }
  }

  str_drc_instruction_str->depends_on_drc_set_present =
      impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  str_drc_instruction_str->no_independent_use = 0;
  if (str_drc_instruction_str->depends_on_drc_set_present) {
    str_drc_instruction_str->depends_on_drc_set =
        impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;
  } else {
    str_drc_instruction_str->no_independent_use =
        impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
  }
  if (version == 0) {
    str_drc_instruction_str->requires_eq = 0;
  } else {
    str_drc_instruction_str->requires_eq = impd_read_bits_buf(it_bit_buff, 1);
    if (it_bit_buff->error) return it_bit_buff->error;
  }

  err = impd_sel_drc_coeff(drc_config, str_drc_instruction_str->drc_location,
                           &str_p_loc_drc_coefficients_uni_drc);
  if (err) return (err);

  ch_cnt = drc_config->channel_layout.base_channel_count;

  if (ch_cnt > MAX_CHANNEL_COUNT) return (UNEXPECTED_ERROR);
  for (c = 0; c < MAX_CHANNEL_COUNT; c++) {
    unique_idx[c] = -10;
    unique_scaling[c] = -10.0f;
  }

  if (str_drc_instruction_str->drc_set_effect &
      (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) {
    c = 0;
    while (c < ch_cnt) {
      WORD32 bs_gain_set_idx;
      bs_gain_set_idx = impd_read_bits_buf(it_bit_buff, 6);
      if (it_bit_buff->error) return it_bit_buff->error;
      if ((bs_gain_set_idx == 0) || (bs_gain_set_idx > GAIN_SET_COUNT_MAX))
        return UNEXPECTED_ERROR;
      str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1;
      impd_dec_ducking_scaling(
          it_bit_buff,
          &(str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
                .ducking_scaling_flag),
          &(str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
                .ducking_scaling));

      c++;

      repeat_parameters = impd_read_bits_buf(it_bit_buff, 1);
      if (it_bit_buff->error) return it_bit_buff->error;

      if (repeat_parameters == 1) {
        repeat_parameters_cnt = impd_read_bits_buf(it_bit_buff, 5);
        if (it_bit_buff->error) return it_bit_buff->error;

        repeat_parameters_cnt += 1;
        if ((c + repeat_parameters_cnt) > MAX_CHANNEL_COUNT)
          return (UNEXPECTED_ERROR);
        for (k = 0; k < repeat_parameters_cnt; k++) {
          str_drc_instruction_str->gain_set_index[c] =
              str_drc_instruction_str->gain_set_index[c - 1];
          str_drc_instruction_str->str_ducking_modifiers_for_channel[c] =
              str_drc_instruction_str->str_ducking_modifiers_for_channel[c - 1];
          c++;
        }
      }
    }
    if (c > ch_cnt) {
      return (UNEXPECTED_ERROR);
    }
    ducking_sequence = -1;
    g = 0;
    if (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_OTHER) {
      for (c = 0; c < ch_cnt; c++) {
        match = 0;
        idx = str_drc_instruction_str->gain_set_index[c];
        factor = str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
                     .ducking_scaling;
        if (idx < 0) {
          for (n = 0; n < g; n++) {
            if (unique_scaling[n] == factor) {
              match = 1;
              str_drc_instruction_str->channel_group_of_ch[c] = n;
              break;
            }
          }
          if (match == 0) {
            unique_idx[g] = idx;
            unique_scaling[g] = factor;
            str_drc_instruction_str->channel_group_of_ch[c] = g;
            g++;
          }
        } else {
          if ((ducking_sequence > 0) && (ducking_sequence != idx)) {
            /* drc for ducking can have only one ducking sequence */
            return (UNEXPECTED_ERROR);
          }
          ducking_sequence = idx;
          str_drc_instruction_str->channel_group_of_ch[c] = -1;
        }
      }
      str_drc_instruction_str->num_drc_ch_groups = g;
      if (ducking_sequence == -1) {
        /* ducking sequence not found */
        return (UNEXPECTED_ERROR);
      }
    } else if (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
      for (c = 0; c < ch_cnt; c++) {
        match = 0;
        idx = str_drc_instruction_str->gain_set_index[c];
        factor = str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
                     .ducking_scaling;
        if (idx >= 0) {
          for (n = 0; n < g; n++) {
            if ((unique_idx[n] == idx) && (unique_scaling[n] == factor)) {
              match = 1;
              str_drc_instruction_str->channel_group_of_ch[c] = n;
              break;
            }
          }
          if (match == 0) {
            unique_idx[g] = idx;
            unique_scaling[g] = factor;
            str_drc_instruction_str->channel_group_of_ch[c] = g;
            g++;
          }
        } else {
          str_drc_instruction_str->channel_group_of_ch[c] = -1;
        }
      }
      str_drc_instruction_str->num_drc_ch_groups = g;
    }

    if (str_drc_instruction_str->num_drc_ch_groups >
        min(CHANNEL_GROUP_COUNT_MAX, MAX_CHANNEL_COUNT))
      return UNEXPECTED_ERROR;
    for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
      WORD32 set =
          (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_OTHER)
              ? ducking_sequence
              : unique_idx[g];
      str_drc_instruction_str->gain_set_index_for_channel_group[g] = set;
      str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g]
          .ducking_scaling = unique_scaling[g];
      if (unique_scaling[g] != 1.0f) {
        str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g]
            .ducking_scaling_flag = 1;
      } else {
        str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g]
            .ducking_scaling_flag = 0;
      }
      str_drc_instruction_str->band_count_of_ch_group[g] = 1;
    }
  } else {
    if (((version == 0) ||
         (str_drc_instruction_str->drc_apply_to_dwnmix != 0)) &&
        (str_drc_instruction_str->downmix_id[0] != 0) &&
        (str_drc_instruction_str->downmix_id[0] != ID_FOR_ANY_DOWNMIX) &&
        (str_drc_instruction_str->dwnmix_id_count == 1)) {
      for (i = 0; i < drc_config->dwnmix_instructions_count; i++) {
        if (str_drc_instruction_str->downmix_id[0] ==
            drc_config->dwnmix_instructions[i].downmix_id)
          break;
      }
      if (i == drc_config->dwnmix_instructions_count) {
        /* dwnmix_instructions not found */
        return (UNEXPECTED_ERROR);
      }
      ch_cnt = drc_config->dwnmix_instructions[i].target_channel_count;
    } else if (((version == 0) ||
                (str_drc_instruction_str->drc_apply_to_dwnmix != 0)) &&
               ((str_drc_instruction_str->downmix_id[0] ==
                 ID_FOR_ANY_DOWNMIX) ||
                (str_drc_instruction_str->dwnmix_id_count > 1))) {
      ch_cnt = 1;
    }

    if (ch_cnt > MAX_CHANNEL_COUNT) return (UNEXPECTED_ERROR);
    c = 0;
    while (c < ch_cnt) {
      WORD32 bs_gain_set_idx;
      WORD32 repeat_gain_set_idx, repeat_gain_set_idx_cnt, temp;

      temp = impd_read_bits_buf(it_bit_buff, 7);
      if (it_bit_buff->error) return it_bit_buff->error;

      bs_gain_set_idx = (temp >> 1) & 0x7f;
      repeat_gain_set_idx = temp & 1;

      if ((bs_gain_set_idx == 0) || (bs_gain_set_idx > GAIN_SET_COUNT_MAX))
        return UNEXPECTED_ERROR;

      str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1;
      c++;

      if (repeat_gain_set_idx == 1) {
        repeat_gain_set_idx_cnt = impd_read_bits_buf(it_bit_buff, 5);
        if (it_bit_buff->error) return it_bit_buff->error;

        repeat_gain_set_idx_cnt += 1;
        if ((c + repeat_gain_set_idx_cnt) > MAX_CHANNEL_COUNT)
          return (UNEXPECTED_ERROR);
        for (k = 0; k < repeat_gain_set_idx_cnt; k++) {
          str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1;
          c++;
        }
      }
    }
    if (c > ch_cnt) {
      return (UNEXPECTED_ERROR);
    }

    g = 0;
    if ((str_drc_instruction_str->downmix_id[0] == ID_FOR_ANY_DOWNMIX) ||
        (str_drc_instruction_str->dwnmix_id_count > 1)) {
      WORD32 idx = str_drc_instruction_str->gain_set_index[0];
      if (idx >= 0) {
        unique_idx[0] = idx;
        g = 1;
      }
    } else {
      for (c = 0; c < ch_cnt; c++) {
        WORD32 idx = str_drc_instruction_str->gain_set_index[c];
        match = 0;
        if (idx >= 0) {
          for (n = 0; n < g; n++) {
            if (unique_idx[n] == idx) {
              match = 1;
              str_drc_instruction_str->channel_group_of_ch[c] = n;
              break;
            }
          }
          if (match == 0) {
            unique_idx[g] = idx;
            str_drc_instruction_str->channel_group_of_ch[c] = g;
            g++;
          }
        } else {
          str_drc_instruction_str->channel_group_of_ch[c] = -1;
        }
      }
    }

    str_drc_instruction_str->num_drc_ch_groups = g;

    if (str_drc_instruction_str->num_drc_ch_groups >
        min(CHANNEL_GROUP_COUNT_MAX, MAX_CHANNEL_COUNT))
      return UNEXPECTED_ERROR;
    for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
      WORD32 set, band_count;

      set = unique_idx[g];
      str_drc_instruction_str->gain_set_index_for_channel_group[g] = set;

      if (str_p_loc_drc_coefficients_uni_drc != NULL &&
          set < str_p_loc_drc_coefficients_uni_drc->gain_set_count) {
        band_count =
            str_p_loc_drc_coefficients_uni_drc->gain_set_params[set].band_count;
      } else {
        band_count = 1;
      }

      err = impd_dec_gain_modifiers(
          it_bit_buff, version, band_count,
          &(str_drc_instruction_str->str_gain_modifiers_of_ch_group[g]));
      if (err) return (err);
    }
  }

  return (0);
}
WORD32
impd_parse_loudness_info(ia_bit_buf_struct* it_bit_buff, WORD32 version,
                         ia_loudness_info_struct* loudness_info) {
  WORD32 err = 0, sample_peak_level, true_peak_level, i, temp;

  loudness_info->drc_set_id = impd_read_bits_buf(it_bit_buff, 6);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (version >= 1) {
    loudness_info->eq_set_id = impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;
  } else {
    loudness_info->eq_set_id = 0;
  }

  temp = impd_read_bits_buf(it_bit_buff, 8);
  if (it_bit_buff->error) return it_bit_buff->error;

  loudness_info->downmix_id = (temp >> 1) & 0x7f;
  loudness_info->sample_peak_level_present = temp & 1;

  if (loudness_info->sample_peak_level_present) {
    sample_peak_level = impd_read_bits_buf(it_bit_buff, 12);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (sample_peak_level == 0) {
      loudness_info->sample_peak_level_present = 0;
      loudness_info->sample_peak_level = 0.0f;
    } else {
      loudness_info->sample_peak_level = 20.0f - sample_peak_level * 0.03125f;
    }
  }

  loudness_info->true_peak_level_present = impd_read_bits_buf(it_bit_buff, 1);
  if (it_bit_buff->error) return it_bit_buff->error;

  if (loudness_info->true_peak_level_present) {
    true_peak_level = impd_read_bits_buf(it_bit_buff, 12);
    if (it_bit_buff->error) return it_bit_buff->error;

    if (true_peak_level == 0) {
      loudness_info->true_peak_level_present = 0;
      loudness_info->true_peak_level = 0.0f;
    } else {
      loudness_info->true_peak_level = 20.0f - true_peak_level * 0.03125f;
    }

    temp = impd_read_bits_buf(it_bit_buff, 6);
    if (it_bit_buff->error) return it_bit_buff->error;

    /* Parsed but unused */
    loudness_info->true_peak_level_measurement_system = (temp >> 2) & 0xf;
    /* Parsed but unused */
    loudness_info->true_peak_level_reliability = temp & 3;
  }

  loudness_info->measurement_count = impd_read_bits_buf(it_bit_buff, 4);
  if (it_bit_buff->error) return it_bit_buff->error;

  for (i = 0; i < loudness_info->measurement_count; i++) {
    err = impd_parse_loudness_measure(it_bit_buff,
                                      &(loudness_info->loudness_measure[i]));
    if (err) return (err);
  }

  return (0);
}