fix sbr 2

retweak
fix
2025-08-24 13:31:40 +07:00 · 2025-08-24 09:14:50 +07:00 · 2025-08-22 19:48:17 +07:00 · 2025-08-22 19:35:23 +07:00 · 2025-08-22 19:34:35 +07:00 · 2025-08-22 16:06:28 +07:00
54 changed files with 1116 additions and 166 deletions
--- a/Android.bp
+++ b/Android.bp
@ -28,6 +28,7 @@ cc_library_static {
    host_supported: true,
    cflags: [
        "-O3",
+        "-DLOUDNESS_LEVELING_SUPPORT",
    ],

    export_include_dirs: [
@ -354,6 +355,7 @@ cc_library_static {
    host_supported: true,
    cflags: [
        "-O3",
+        "-DLOUDNESS_LEVELING_SUPPORT",
    ],

    export_include_dirs: [
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -27,3 +27,5 @@ include("${XAAC_ROOT}/encoder/libxaacenc.cmake")
 include("${XAAC_ROOT}/test/encoder/xaacenc.cmake")
 include("${XAAC_ROOT}/fuzzer/xaac_enc_fuzzer.cmake")

+set_property(TARGET libxaacenc PROPERTY POSITION_INDEPENDENT_CODE 1)
+set_property(TARGET libxaacdec PROPERTY POSITION_INDEPENDENT_CODE 1)
--- a/README_dec.md
+++ b/README_dec.md
@ -39,8 +39,8 @@ A single API is used to get and set configurations and execute the decode thread
 |IA_API_CMD_SET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_PEAK_LIMITER | Sets the flag to disable/enable peak limiter |
 |IA_API_CMD_SET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_FRAMELENGTH_FLAG | Sets to flag to indicate whether decoder should decode for frame length 960 or 1024 |
 |IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_DRC_TARGET_LEVEL | Sets the value of DRC target level |
-|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_ERROR_CONCEALMENT | Sets to flag to disable/enable error concealment |
-|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_ESBR | Sets to flag to disable/enable eSBR |
+|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_ERROR_CONCEALMENT | Sets the flag to disable/enable error concealment |
+|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_ESBR | Sets the flag to disable/enable eSBR |
 |IA_API_CMD_GET_N_MEMTABS | 0 | Gets the number of memory types |
 |IA_API_CMD_GET_N_TABLES | 0 | Gets the number of tables |
 |IA_API_CMD_GET_MEM_INFO_SIZE | 0 | Gets the size of the memory type being referred to by the index |
@ -66,6 +66,7 @@ A single API is used to get and set configurations and execute the decode thread
 |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LOUDNESS | Gets the value of DRC target loudness |
 |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_LOUD_NORM | Gets the value of DRC loudness normalization level |
 |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_AOT | Gets the value of audio object type |
+|IA_API_CMD_GET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING | Gets the value of loudness leveling flag |
 |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_PTR | Gets the extension element pointer |
 |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_BUF_SIZES | Gets the extension element buffer sizes |
 |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_NUM_ELE | Gets the number of configuration elements |
@ -132,7 +133,7 @@ A single API is used to get and set configurations and execute the decode thread
 |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS | Sets the number of channels in the input stream/data |
 |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_PCM_WDSZ | Sets the PCM word size of the input data |
 |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT | Sets the bit stream format |
-|IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_INT_PRESENT | Sets the DRC decoder’s interface present flag to 1 or 0 |
+|IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_INT_PRESENT | Sets the DRC decoders interface present flag to 1 or 0 |
 |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_FRAME_SIZE | Sets the frame size |
 |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_DRC_EFFECT_TYPE | Sets the value of DRC effect type |
 |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_DRC_TARGET_LOUDNESS | Sets the value of DRC target loudness |
@ -191,6 +192,7 @@ Command line usage :
 [-peak_limiter_off:<peak_limiter_off_flag>]
 [-err_conceal:<error_concealment_flag>]
 [-esbr:<esbr_flag>]
+[-loudness_leveling:<loudness_leveling_flag>]

 where,
  <input_file>             is the input AAC-LC/HE-AACv1/HE-AACv2/AAC-LD/AAC-ELD/AAC-ELDv2/USAC file name.
@ -222,8 +224,10 @@ where,
  <peak_limiter_off_flag>  is to enable/disable peak limiter. Default value is 0.
  <error_concealment_flag> is to enable/disable error concealment. Default value is 0.
  <esbr_flag>              is to enable/disable eSBR. Default value is 1.
+  <loudness_leveling_flag> is to enable / disable loudness leveling. Default value is 1.

 ```
+Note: `loudness_leveling_flag` is applicable only if `LOUDNESS_LEVELING_SUPPORT` macro is enabled.
 Sample CLI:
 ```
 <xaac_dec_exe> -ifile:in_file.aac -ofile:out_file.wav -pcmsz:16
--- a/cmake/utils.cmake
+++ b/cmake/utils.cmake
@ -50,6 +50,8 @@ function(libxaac_add_definitions)
  elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
    add_definitions(-DX86_64 -D_X86_64_)
  endif()
+  add_definitions(-DLOUDNESS_LEVELING_SUPPORT)
+  add_definitions(-DAAC_NEW_TABLES)
 endfunction()

 # Adds libraries needed for executables
--- a/decoder/drc_src/impd_drc_api.c
+++ b/decoder/drc_src/impd_drc_api.c
@ -246,7 +246,7 @@ IA_ERRORCODE ia_drc_dec_api(pVOID p_ia_drc_dec_obj, WORD32 i_cmd, WORD32 i_idx,
    case IA_API_CMD_SET_CONFIG_PARAM: {
      switch (i_idx) {
        case IA_DRC_DEC_CONFIG_PARAM_SAMP_FREQ: {
-          if (*pus_value < 8000 || *pus_value > 96000) {
+          if (*pus_value == 0 || *pus_value > 96000) {
            return IA_DRC_DEC_CONFIG_NON_FATAL_INVALID_SAMP_FREQ;
          }
          p_obj_drc->str_config.sampling_rate = *pus_value;
@ -328,6 +328,12 @@ IA_ERRORCODE ia_drc_dec_api(pVOID p_ia_drc_dec_obj, WORD32 i_cmd, WORD32 i_idx,
          p_obj_drc->str_config.compress_set = 1;
          break;
        }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+        case IA_DRC_DEC_CONFIG_DRC_LOUDNESS_LEVELING: {
+          p_obj_drc->str_config.loudness_leveling_flag = *pus_value;
+          break;
+        }
+#endif
        default: { return -1; }
      }
      break;
--- a/decoder/drc_src/impd_drc_api_struct_def.h
+++ b/decoder/drc_src/impd_drc_api_struct_def.h
@ -63,6 +63,9 @@ typedef struct ia_drc_config_struct {
  WORD32 apply_crossfade;
  WORD32 is_config_changed;
  WORD32 ln_dbgain_prev;
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD32 loudness_leveling_flag;
+#endif
 } ia_drc_config_struct;

 /* DRC bitsteam handler */
--- a/decoder/drc_src/impd_drc_common.h
+++ b/decoder/drc_src/impd_drc_common.h
@ -193,6 +193,9 @@ extern "C" {
 #define UNIDRCCONFEXT_V1 0x2
 #define UNIDRCLOUDEXT_EQ 0x1
 #define UNIDRCINTERFACEEXT_EQ 0x1
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#define UNIDRCCONFEXT_LEVELING (0x4)
+#endif

 #define LOUD_EQ_REQUEST_OFF 0x0
 #define LOUD_EQ_REQUEST_LIGHT 0x1
--- a/decoder/drc_src/impd_drc_config_params.h
+++ b/decoder/drc_src/impd_drc_config_params.h
@ -46,4 +46,7 @@
 #define IA_DRC_DEC_CONFIG_DRC_COMPRESS 0x0016
 #define IA_DRC_DEC_CONFIG_PARAM_APPLY_CROSSFADE 0x0017
 #define IA_DRC_DEC_CONFIG_PARAM_CONFIG_CHANGED 0x0018
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#define IA_DRC_DEC_CONFIG_DRC_LOUDNESS_LEVELING 0x0019
+#endif
 #endif
--- a/decoder/drc_src/impd_drc_dynamic_payload.c
+++ b/decoder/drc_src/impd_drc_dynamic_payload.c
@ -28,6 +28,10 @@
 #include "impd_drc_parser.h"
 #include "impd_drc_filter_bank.h"
 #include "impd_drc_rom.h"
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#include "impd_drc_error_codes.h"
+#include "ixheaacd_error_codes.h"
+#endif
 WORD32 impd_parse_loud_eq_instructions(
    ia_bit_buf_struct* it_bit_buff,
    ia_loud_eq_instructions_struct* loud_eq_instructions);
@ -646,6 +650,42 @@ WORD32 impd_parse_drc_ext_v1(ia_bit_buf_struct* it_bit_buff,
  return 0;
 }

+#ifdef LOUDNESS_LEVELING_SUPPORT
+IA_ERROR_CODE impd_leveling_instructions(ia_bit_buf_struct* it_bit_buff,
+                                         ia_drc_config* pstr_drc_config) {
+  WORD32 i;
+  IA_ERROR_CODE err = IA_NO_ERROR;
+  WORD32 drc_instruction_uni_drc_count = pstr_drc_config->drc_instructions_uni_drc_count;
+
+  for (i = 0; i < drc_instruction_uni_drc_count; ++i) {
+    if ((pstr_drc_config->str_drc_instruction_str[i].drc_set_effect & (1 << 11)) != 0) {
+      pstr_drc_config->str_drc_instruction_str[i].leveling_present =
+          impd_read_bits_buf(it_bit_buff, 1);
+
+      if (pstr_drc_config->str_drc_instruction_str[i].leveling_present) {
+        WORD32 ducking_only_drc_set_present = impd_read_bits_buf(it_bit_buff, 1);
+
+        if (ducking_only_drc_set_present) {
+          pstr_drc_config->drc_instructions_uni_drc_count++;
+
+          if (pstr_drc_config->drc_instructions_uni_drc_count > DRC_INSTRUCTIONS_COUNT_MAX) {
+            return IA_XHEAAC_DEC_INIT_NONFATAL_MAX_INSTRUCTIONS_ERROR;
+          }
+
+          err = impd_parse_drc_instructions_uni_drc(
+              it_bit_buff, 1, pstr_drc_config,
+              &pstr_drc_config
+                   ->str_drc_instruction_str[pstr_drc_config->drc_instructions_uni_drc_count -
+                                             1]);
+          if (err) return err;
+        }
+      }
+    }
+  }
+  return err;
+}
+#endif
+
 WORD32 impd_parse_filt_block(ia_bit_buf_struct* it_bit_buff,
                             ia_filt_block_struct* str_filter_block,
                             WORD32 block_count) {
--- a/decoder/drc_src/impd_drc_init.c
+++ b/decoder/drc_src/impd_drc_init.c
@ -58,10 +58,15 @@ impd_drc_dec_interface_process(ia_bit_buf_struct *it_bit_buff,
                               WORD32 *num_bits_read);

 WORD32
-impd_drc_dec_interface_add_effect_type(
-    ia_drc_interface_struct *pstr_drc_interface, WORD32 drc_effect_type,
-    WORD32 target_loudness, WORD32 loud_norm, WORD32 album_mode, FLOAT32 boost,
-    FLOAT32 compress);
+impd_drc_dec_interface_add_effect_type(ia_drc_interface_struct *pstr_drc_interface,
+                                       WORD32 drc_effect_type, WORD32 target_loudness,
+                                       WORD32 loud_norm, WORD32 album_mode, FLOAT32 boost,
+                                       FLOAT32 compress
+#ifdef LOUDNESS_LEVELING_SUPPORT
+                                       ,
+                                       WORD32 loudness_leveling_flag
+#endif
+);

 #define BITSTREAM_FILE_FORMAT_SPLIT 1
 #define LIM_DEFAULT_THRESHOLD (0.89125094f)
@ -411,10 +416,15 @@ IA_ERRORCODE impd_drc_init(ia_drc_api_struct *p_obj_drc) {
    p_obj_drc->str_config.compress = 1.0f;

  err_code = impd_drc_dec_interface_add_effect_type(
-      p_obj_drc->str_payload.pstr_drc_interface,
-      p_obj_drc->str_config.effect_type, p_obj_drc->str_config.target_loudness,
-      p_obj_drc->str_config.loud_norm_flag, p_obj_drc->str_config.album_mode,
-      p_obj_drc->str_config.boost, p_obj_drc->str_config.compress);
+      p_obj_drc->str_payload.pstr_drc_interface, p_obj_drc->str_config.effect_type,
+      p_obj_drc->str_config.target_loudness, p_obj_drc->str_config.loud_norm_flag,
+      p_obj_drc->str_config.album_mode, p_obj_drc->str_config.boost,
+      p_obj_drc->str_config.compress
+#ifdef LOUDNESS_LEVELING_SUPPORT
+      ,
+      p_obj_drc->str_config.loudness_leveling_flag
+#endif
+  );

  if (err_code != IA_NO_ERROR) return err_code;

--- a/decoder/drc_src/impd_drc_interface.h
+++ b/decoder/drc_src/impd_drc_interface.h
@ -42,6 +42,11 @@ typedef struct {
 typedef struct {
  WORD32 interface_ext_count;
  ia_specific_interface_extension_struct specific_interface_ext[EXT_COUNT_MAX];
+
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD32 loudness_leveling_on;
+#endif
+
  WORD32 loudness_eq_parameter_interface_flag;
  WORD32 eq_ctrl_interface_flag;
  ia_loudness_eq_parameter_interface_struct loudness_eq_parameter_interface;
--- a/decoder/drc_src/impd_drc_interface_decoder.c
+++ b/decoder/drc_src/impd_drc_interface_decoder.c
@ -29,10 +29,15 @@
 #include "impd_drc_parser_interface.h"

 WORD32
-impd_drc_dec_interface_add_effect_type(
-    ia_drc_interface_struct* pstr_drc_interface, WORD32 drc_effect_type,
-    WORD32 target_loudness, WORD32 loud_norm, WORD32 album_mode, FLOAT32 boost,
-    FLOAT32 compress) {
+impd_drc_dec_interface_add_effect_type(ia_drc_interface_struct* pstr_drc_interface,
+                                       WORD32 drc_effect_type, WORD32 target_loudness,
+                                       WORD32 loud_norm, WORD32 album_mode, FLOAT32 boost,
+                                       FLOAT32 compress
+#ifdef LOUDNESS_LEVELING_SUPPORT
+                                       ,
+                                       WORD32 loudness_leveling_flag
+#endif
+) {
  WORD32 err = 0;
  WORD32 i = 0;

@ -65,7 +70,9 @@ impd_drc_dec_interface_add_effect_type(
    }
    pstr_drc_interface->loudness_norm_ctrl_interface.target_loudness =
        (FLOAT32)target_loudness;
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    pstr_drc_interface->drc_uni_interface_ext.loudness_leveling_on = loudness_leveling_flag;
+#endif
    pstr_drc_interface->loudness_norm_parameter_interface_flag = 1;
    pstr_drc_interface->loudness_norm_param_interface.album_mode = album_mode;
    pstr_drc_interface->loudness_norm_param_interface.peak_limiter = 0;
--- a/decoder/drc_src/impd_drc_parser.h
+++ b/decoder/drc_src/impd_drc_parser.h
@ -73,6 +73,10 @@ impd_parse_drc_ext_v1(ia_bit_buf_struct* it_bit_buff,
                      ia_drc_config* drc_config,
                      ia_drc_config_ext* str_drc_config_ext);

+#ifdef LOUDNESS_LEVELING_SUPPORT
+WORD32 impd_leveling_instructions(ia_bit_buf_struct* it_bit_buff, ia_drc_config* pstr_drc_config);
+#endif
+
 WORD32
 impd_parse_drc_config(ia_bit_buf_struct* it_bit_buff,
                      ia_drc_params_bs_dec_struct* ia_drc_params_struct,
--- a/decoder/drc_src/impd_drc_selection_process.h
+++ b/decoder/drc_src/impd_drc_selection_process.h
@ -82,6 +82,10 @@ typedef struct ia_drc_sel_proc_params_struct {
  FLOAT32 playback_gain;
  WORD32 eq_set_purpose_request;

+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD32 loudness_leveling_on;
+#endif
+
  FLOAT32 boost;
  FLOAT32 compress;
  WORD32 drc_characteristic_target;
--- a/decoder/drc_src/impd_drc_selection_process_drcset_selection.c
+++ b/decoder/drc_src/impd_drc_selection_process_drcset_selection.c
@ -30,6 +30,9 @@
 #include "impd_drc_loudness_control.h"
 #include "impd_drc_filter_bank.h"
 #include "impd_drc_rom.h"
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#include "ixheaac_error_standards.h"
+#endif

 static const WORD32 effect_types_request_table[] = {
    EFFECT_BIT_NIGHT,    EFFECT_BIT_NOISY,   EFFECT_BIT_LIMITED,
@ -170,6 +173,12 @@ WORD32 impd_get_ducking_drc_set(ia_drc_sel_pro_struct* pstr_drc_uni_sel_proc) {
        (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) {
      for (k = 0; k < str_drc_instruction_str->dwnmix_id_count; k++) {
        if (str_drc_instruction_str->downmix_id[k] == requested_dwnmix_id) {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+          if (drc_instructions_index != -1) break;
+          if (pstr_drc_uni_sel_proc->uni_drc_sel_proc_params.loudness_leveling_on == 0 &&
+              str_drc_instruction_str->leveling_present == 1)
+            continue;
+#endif
          drc_instructions_index = n;
        }
      }
@ -186,6 +195,12 @@ WORD32 impd_get_ducking_drc_set(ia_drc_sel_pro_struct* pstr_drc_uni_sel_proc) {
          (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) {
        for (k = 0; k < str_drc_instruction_str->dwnmix_id_count; k++) {
          if (str_drc_instruction_str->downmix_id[k] == ID_FOR_BASE_LAYOUT) {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+            if (drc_instructions_index != -1) break;
+            if (pstr_drc_uni_sel_proc->uni_drc_sel_proc_params.loudness_leveling_on == 0 &&
+                str_drc_instruction_str->leveling_present == 1)
+              continue;
+#endif
            drc_instructions_index = n;
          }
        }
--- a/decoder/drc_src/impd_drc_selection_process_init.c
+++ b/decoder/drc_src/impd_drc_selection_process_init.c
@ -104,6 +104,10 @@ WORD32 impd_drc_sel_proc_init_dflt(
    pstr_drc_uni_sel_proc->eq_inst_index[0] = -1;
    pstr_drc_uni_sel_proc->eq_inst_index[1] = -1;
    pstr_drc_uni_sel_proc->sel_proc_request_flag = 1;
+
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    pstr_drc_uni_sel_proc->uni_drc_sel_proc_params.loudness_leveling_on = 1;
+#endif
  } else {
    return 1;
  }
@ -133,6 +137,10 @@ VOID impd_drc_sel_proc_init_interface_params(
  WORD32 i, j;

  if (pstr_drc_uni_sel_proc != NULL && pstr_drc_interface != NULL) {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    pstr_drc_uni_sel_proc->uni_drc_sel_proc_params.loudness_leveling_on =
+        pstr_drc_interface->drc_uni_interface_ext.loudness_leveling_on;
+#endif
    if (pstr_drc_interface->system_interface_flag) {
      if (pstr_drc_uni_sel_proc->uni_drc_sel_proc_params
              .target_config_request_type !=
--- a/decoder/drc_src/impd_drc_static_payload.c
+++ b/decoder/drc_src/impd_drc_static_payload.c
@ -954,6 +954,13 @@ impd_parse_drc_config_ext(ia_bit_buf_struct* it_bit_buff,
                                    drc_config, str_drc_config_ext);
        if (err) return (err);
        break;
+
+#ifdef LOUDNESS_LEVELING_SUPPORT
+      case UNIDRCCONFEXT_LEVELING:
+        err = impd_leveling_instructions(it_bit_buff, drc_config);
+        if (err) return err;
+        break;
+#endif
      default:
        for (i = 0; i < str_drc_config_ext->ext_bit_size[k]; i++) {
          impd_read_bits_buf(it_bit_buff, 1);
--- a/decoder/drc_src/impd_drc_struct.h
+++ b/decoder/drc_src/impd_drc_struct.h
@ -424,6 +424,9 @@ typedef struct {
  WORD32 gain_set_idx_of_ch_group_parametric_drc[CHANNEL_GROUP_COUNT_MAX];
  WORD32 parametric_drc_look_ahead_samples[CHANNEL_GROUP_COUNT_MAX];
  WORD32 parametric_drc_look_ahead_samples_max;
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD32 leveling_present;
+#endif
 } ia_drc_instructions_struct;

 typedef struct {
--- a/decoder/ixheaacd_aac_config.h
+++ b/decoder/ixheaacd_aac_config.h
@ -65,6 +65,10 @@

 #define IA_XHEAAC_DEC_CONFIG_PARAM_ESBR 0x0028

+#ifdef LOUDNESS_LEVELING_SUPPORT
+#define IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING 0x0029
+#endif
+
 #define IA_ENHAACPLUS_DEC_CONFIG_PARAM_PCM_WDSZ IA_XHEAAC_DEC_CONFIG_PARAM_PCM_WDSZ
 #define IA_ENHAACPLUS_DEC_CONFIG_PARAM_SAMP_FREQ IA_XHEAAC_DEC_CONFIG_PARAM_SAMP_FREQ
 #define IA_ENHAACPLUS_DEC_CONFIG_PARAM_NUM_CHANNELS IA_XHEAAC_DEC_CONFIG_PARAM_NUM_CHANNELS
--- a/decoder/ixheaacd_api.c
+++ b/decoder/ixheaacd_api.c
@ -480,7 +480,9 @@ IA_ERRORCODE ixheaacd_dec_api(pVOID p_ia_xheaac_dec_obj, WORD32 i_cmd,
          p_obj_exhaacplus_dec->aac_config.ui_drc_set = 0;
          p_obj_exhaacplus_dec->aac_config.ui_flush_cmd = 0;
          p_obj_exhaacplus_dec->aac_config.output_level = -1;
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+          p_obj_exhaacplus_dec->aac_config.ui_loudness_leveling_flag = 1;
+#endif
          p_obj_exhaacplus_dec->aac_config.ui_max_channels = 6;

          p_obj_exhaacplus_dec->aac_config.ui_coupling_channel = 0;
@ -577,7 +579,7 @@ IA_ERRORCODE ixheaacd_dec_api(pVOID p_ia_xheaac_dec_obj, WORD32 i_cmd,
          break;
        }
        case IA_XHEAAC_DEC_CONFIG_PARAM_PCM_WDSZ: {
-          if ((*pui_value != 16) && (*pui_value != 24)) {
+          if ((*pui_value != 16) && (*pui_value != 24) && (*pui_value != 32)) {
            p_obj_exhaacplus_dec->aac_config.ui_pcm_wdsz = 16;
            return (IA_XHEAAC_DEC_CONFIG_NONFATAL_INVALID_PCM_WDSZ);
          }
@ -789,6 +791,16 @@ IA_ERRORCODE ixheaacd_dec_api(pVOID p_ia_xheaac_dec_obj, WORD32 i_cmd,
          p_obj_exhaacplus_dec->aac_config.ui_enh_sbr = *pui_value_signed;
          break;
        }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+        case IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING: {
+          if (((*pui_value_signed) != 0) && ((*pui_value_signed) != 1)) {
+            p_obj_exhaacplus_dec->aac_config.ui_loudness_leveling_flag = 1;
+            return (IA_XHEAAC_DEC_CONFIG_NONFATAL_INVALID_LOUDNESS_LEVELING_FLAG);
+          }
+          p_obj_exhaacplus_dec->aac_config.ui_loudness_leveling_flag = *pui_value_signed;
+          break;
+        }
+#endif
        default: { return IA_XHEAAC_DEC_API_FATAL_INVALID_CONFIG_PARAM; }
      }
      break;
@ -928,10 +940,19 @@ IA_ERRORCODE ixheaacd_dec_api(pVOID p_ia_xheaac_dec_obj, WORD32 i_cmd,
          } else {
            *pui_value = p_obj_exhaacplus_dec->p_state_aac->audio_object_type;
          }
+          if (*pui_value == AOT_AAC_LC) *pui_value = p_obj_exhaacplus_dec->p_state_aac->init_sbr_flag ? (p_obj_exhaacplus_dec->p_state_aac->init_ps_flag ? AOT_PS : AOT_SBR) : AOT_AAC_LC;
        } else {
          *pui_value = AOT_AAC_LC;
        }
-      } else {
+      }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+      else if (IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING == i_idx) {
+        WORD32 *ui_value =
+            (WORD32 *)(&p_obj_exhaacplus_dec->aac_config.ui_loudness_leveling_flag);
+        *pui_value = *ui_value;
+      }
+#endif
+      else {
        return IA_XHEAAC_DEC_API_FATAL_INVALID_CONFIG_PARAM;
      }
      break;
@ -2510,6 +2531,8 @@ IA_ERRORCODE ixheaacd_dec_init(
    p_obj_exhaacplus_dec->aac_config.ui_n_channels = num_channels_1;
    p_obj_exhaacplus_dec->aac_config.ui_samp_freq = sample_rate;
    p_state_enhaacplus_dec->ui_init_done = 1;
+    p_state_enhaacplus_dec->init_sbr_flag = sbr_present_flag;
+    p_state_enhaacplus_dec->init_ps_flag = !p_obj_exhaacplus_dec->aac_config.ui_channel_mode;

    memcpy(it_bit_buff, &temp_bit_buff, sizeof(struct ia_bit_buf_struct));

@ -3656,9 +3679,12 @@ IA_ERRORCODE ixheaacd_dec_execute(
      p_obj_exhaacplus_dec->p_state_aac->heaac_mps_handle.ec_flag =
          p_obj_exhaacplus_dec->aac_config.ui_err_conceal;

-      ixheaacd_heaac_mps_apply(p_obj_exhaacplus_dec, actual_out_buffer,
-                               mps_buffer,
-                               p_state_enhaacplus_dec->ui_mps_out_bytes);
+      error_code = ixheaacd_heaac_mps_apply(p_obj_exhaacplus_dec, actual_out_buffer, mps_buffer,
+                                            p_state_enhaacplus_dec->ui_mps_out_bytes);
+
+      if (error_code != IA_NO_ERROR) {
+        return error_code;
+      }

      p_state_enhaacplus_dec->heaac_mps_handle.mps_decode = 1;
      p_obj_exhaacplus_dec->p_state_aac->ui_out_bytes =
--- a/decoder/ixheaacd_decode_main.c
+++ b/decoder/ixheaacd_decode_main.c
@ -88,6 +88,7 @@ VOID ixheaacd_samples_sat(WORD8 *outbuffer, WORD32 num_samples_out,
  FLOAT32 write_local_float;

  WORD16 *out_buf = (WORD16 *)outbuffer;
+  FLOAT32 *out_buf_float = (FLOAT32 *)outbuffer;

  num = num_channel_out * num_samples_out;

@ -105,6 +106,20 @@ VOID ixheaacd_samples_sat(WORD8 *outbuffer, WORD32 num_samples_out,
    }

    *out_bytes = num * sizeof(WORD16);
+  } else if (pcmsize == 32) {
+    for (i = 0; i < num; i++) {
+      write_local_float =
+          (out_samples[i % num_channel_out][i / num_channel_out]);
+
+      if (write_local_float > 32767.0f) {
+        write_local_float = 32767.0f;
+      } else if (write_local_float < -32768.0f) {
+        write_local_float = -32768.0f;
+      }
+      out_buf_float[i] = write_local_float / 32767;
+    }
+
+    *out_bytes = num * sizeof(FLOAT32);
  } else {
    WORD8 *out_24bit = (WORD8 *)out_buf;
    for (i = 0; i < num; i++) {
--- a/decoder/ixheaacd_error_codes.h
+++ b/decoder/ixheaacd_error_codes.h
@ -63,6 +63,9 @@
 #define IA_XHEAAC_DEC_CONFIG_NONFATAL_INVALID_ESBR_HQ_FLAG 0x00000815
 #define IA_XHEAAC_DEC_CONFIG_NONFATAL_INVALID_FRAMELENGTHFLAG 0x00000816
 #define IA_XHEAAC_DEC_CONFIG_NONFATAL_INVALID_ESBR_FLAG 0x00000817
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#define IA_XHEAAC_DEC_CONFIG_NONFATAL_INVALID_LOUDNESS_LEVELING_FLAG 0x00000818
+#endif
 /* Fatal Errors */
 #define IA_XHEAAC_DEC_CONFIG_FATAL_INVALID_SAMPLE_RATE 0xFFFF8800

@ -75,7 +78,7 @@
 #define IA_XHEAAC_DEC_INIT_NONFATAL_EC_INIT_FAIL 0x00001002
 #define IA_XHEAAC_DEC_INIT_NONFATAL_INSUFFICIENT_INPUT_BYTES 0x00001003
 #define IA_XHEAAC_DEC_INIT_NONFATAL_DECODE_FRAME_ERROR 0x00001004
-
+#define IA_XHEAAC_DEC_INIT_NONFATAL_MAX_INSTRUCTIONS_ERROR 0x00001005
 /* Fatal Errors */
 #define IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL 0xFFFF9000
 #define IA_XHEAAC_DEC_INIT_FATAL_EO_INPUT_REACHED 0xFFFF9001
--- a/decoder/ixheaacd_struct_def.h
+++ b/decoder/ixheaacd_struct_def.h
@ -137,6 +137,9 @@ typedef struct {

  WORD32 ui_err_conceal;
  FLAG first_frame;
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD32 ui_loudness_leveling_flag;
+#endif
 } ia_aac_dec_config_struct;

 typedef struct ia_aac_dec_state_struct {
@ -159,6 +162,8 @@ typedef struct ia_aac_dec_state_struct {
  UWORD32 ui_input_over;
  UWORD32 header_dec_done;
  WORD32 frame_counter;
+  WORD32 init_sbr_flag;
+  WORD32 init_ps_flag;
  ia_aac_decoder_struct *pstr_aac_dec_info[MAX_BS_ELEMENT];

  UWORD32 ch_config;
--- a/encoder/drc_src/impd_drc_api.c
+++ b/encoder/drc_src/impd_drc_api.c
@ -88,6 +88,15 @@ IA_ERRORCODE impd_drc_validate_config_params(ia_drc_input_config *pstr_inp_confi
    }
    IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config->str_drc_instructions_uni_drc[i].limiter_peak_target,
                         MIN_LIMITER_PEAK_TARGET, 0.0f);
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].drc_set_effect &
+        EFFECT_BIT_DUCK_SELF) {
+      IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config->str_drc_instructions_uni_drc[i].leveling_present,
+                           0, 1);
+      IMPD_DRC_BOUND_CHECK(
+          pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present, 0, 1);
+    }
+#endif
  }

  IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config->drc_coefficients_uni_drc_count, 0,
@ -395,6 +404,16 @@ IA_ERRORCODE impd_drc_validate_config_params(ia_drc_input_config *pstr_inp_confi
        IMPD_DRC_BOUND_CHECK(
            pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].limiter_peak_target,
            MIN_LIMITER_PEAK_TARGET, 0.0f);
+#ifdef LOUDNESS_LEVELING_SUPPORT
+        if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].drc_set_effect &
+            EFFECT_BIT_DUCK_SELF) {
+          IMPD_DRC_BOUND_CHECK(
+              pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].leveling_present, 0, 1);
+          IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i]
+                                   .ducking_only_set_present,
+                               0, 1);
+        }
+#endif
      }
    }
  }
@ -423,8 +442,67 @@ static IA_ERRORCODE impd_drc_validate_drc_instructions(
    if (profile_found == FALSE) {
      return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
    }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].drc_set_effect &
+        EFFECT_BIT_DUCK_SELF) {
+      if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].leveling_present &&
+          pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present) {
+        if (i < pstr_uni_drc_config->drc_instructions_uni_drc_count - 1) {
+          if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].drc_set_effect !=
+                  EFFECT_BIT_DUCK_SELF &&
+              pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].drc_set_effect !=
+                  EFFECT_BIT_DUCK_OTHER) {
+            pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].drc_set_effect =
+                EFFECT_BIT_DUCK_SELF;
+          }
+          pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].leveling_present = 0;
+          pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].ducking_only_set_present = 0;
+        } else {
+          pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present = 0;
+        }
+      } else if (!pstr_uni_drc_config->str_drc_instructions_uni_drc[i].leveling_present &&
+                 pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present) {
+        pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present = 0;
+      }
+    }
+#endif
  }
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  if (pstr_uni_drc_config->uni_drc_config_ext_present) {
+    ia_drc_uni_drc_config_ext_struct *pstr_uni_drc_config_ext =
+        &pstr_uni_drc_config->str_uni_drc_config_ext;
+    for (i = 0; i < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count; i++) {
+      if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].drc_set_effect &
+          EFFECT_BIT_DUCK_SELF) {
+        if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].leveling_present &&
+            pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i]
+                .ducking_only_set_present) {
+          if (i < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count - 1) {
+            if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].drc_set_effect !=
+                    EFFECT_BIT_DUCK_SELF &&
+                pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].drc_set_effect !=
+                    EFFECT_BIT_DUCK_OTHER) {
+              pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].drc_set_effect =
+                  EFFECT_BIT_DUCK_SELF;
+            }
+            pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].leveling_present = 0;
+            pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1]
+                .ducking_only_set_present = 0;
+          } else {
+            pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].ducking_only_set_present =
+                0;
+          }
+        } else if (!pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i]
+                        .leveling_present &&
+                   pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i]
+                       .ducking_only_set_present) {
+          pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].ducking_only_set_present =
+              0;
+        }
+      }
+    }
+  }
+#endif
  return IA_NO_ERROR;
 }

@ -461,6 +539,18 @@ IA_ERRORCODE impd_drc_enc_init(VOID *pstr_drc_state, VOID *ptr_drc_scratch,
  if (err_code) {
    return err_code;
  }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  err_code = impd_drc_validate_drc_instructions(&pstr_inp_config->str_uni_drc_config);
+
+  if (err_code & IA_FATAL_ERROR) {
+    return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
+  }
+
+  pstr_drc_state_local->str_enc_params = pstr_inp_config->str_enc_params;
+  pstr_drc_state_local->str_uni_drc_config = pstr_inp_config->str_uni_drc_config;
+  pstr_drc_state_local->str_enc_gain_extension = pstr_inp_config->str_enc_gain_extension;
+  pstr_drc_state_local->str_gain_enc.str_uni_drc_config = pstr_inp_config->str_uni_drc_config;
+#else
  pstr_drc_state_local->str_enc_params = pstr_inp_config->str_enc_params;
  pstr_drc_state_local->str_uni_drc_config = pstr_inp_config->str_uni_drc_config;
  pstr_drc_state_local->str_enc_gain_extension = pstr_inp_config->str_enc_gain_extension;
@ -469,6 +559,7 @@ IA_ERRORCODE impd_drc_enc_init(VOID *pstr_drc_state, VOID *ptr_drc_scratch,
  if (err_code & IA_FATAL_ERROR) {
    return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
  }
+#endif

  err_code = impd_drc_write_uni_drc_config(pstr_drc_state_local, &bit_count, 1);
  if (err_code & IA_FATAL_ERROR) {
--- a/encoder/drc_src/impd_drc_common_enc.h
+++ b/encoder/drc_src/impd_drc_common_enc.h
@ -36,7 +36,11 @@
 #define MAX_CHANNEL_GROUP_COUNT (MAX_SEQUENCE_COUNT)
 #define MAX_ADDITIONAL_DOWNMIX_ID (7)
 #define DELAY_MODE_REGULAR_DELAY (0)
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#define MAX_EXT_COUNT (3)
+#else
 #define MAX_EXT_COUNT (2)
+#endif
 #define MAX_GAIN_POINTS (256)
 #define MAX_DRC_INSTRUCTIONS_BASIC_COUNT (15)

@ -46,6 +50,9 @@
 #define UNIDRC_CONF_EXT_PARAM_DRC (0x1)
 #define UNIDRC_CONF_EXT_V1 (0x2)
 #define UNIDRC_LOUD_EXT_EQ (0x1)
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#define UNIDRCCONFEXT_LEVELING (0x4)
+#endif

 #define MAX_PARAM_DRC_INSTRUCTIONS_COUNT (8)

--- a/encoder/drc_src/impd_drc_mux.c
+++ b/encoder/drc_src/impd_drc_mux.c
@ -1099,6 +1099,97 @@ static IA_ERRORCODE impd_drc_write_drc_instruct_uni_drc(
  return err_code;
 }

+#ifdef LOUDNESS_LEVELING_SUPPORT
+static UWORD32 get_num_ducking_only_drc_sets(
+    ia_drc_instructions_uni_drc const *pstr_drc_instructions_uni_drc,
+    UWORD32 drc_intructions_uni_drc_count) {
+  UWORD32 num_ducking_only_drc_sets = 0;
+  for (UWORD16 i = 0; i < drc_intructions_uni_drc_count; i++) {
+    if (pstr_drc_instructions_uni_drc[i].ducking_only_set_present) {
+      num_ducking_only_drc_sets++;
+    }
+  }
+
+  return num_ducking_only_drc_sets;
+}
+
+static WORD32 write_loudness_leveling_extension(ia_bit_buf_struct *it_bit_buf,
+                                                ia_drc_uni_drc_config_struct *pstr_uni_drc_config,
+                                                ia_drc_gain_enc_struct *pstr_gain_enc,
+                                                VOID *ptr_scratch, WORD32 *bit_cnt) {
+  IA_ERRORCODE err_code = IA_NO_ERROR;
+  WORD32 bit_cnt_local = 0;
+  WORD32 drc_instructions_uni_drc_count_v1 =
+      pstr_uni_drc_config->str_uni_drc_config_ext.drc_instructions_uni_drc_v1_count;
+  WORD32 drc_instructions_uni_drc_count = pstr_uni_drc_config->drc_instructions_uni_drc_count;
+  WORD32 version = 0;
+  WORD16 ducking_set_expected = 0;
+  // V0 instructions
+  for (WORD16 i = 0; i < drc_instructions_uni_drc_count; i++) {
+    ia_drc_instructions_uni_drc *pstr_drc_instruction =
+        &pstr_uni_drc_config->str_drc_instructions_uni_drc[i];
+    if (pstr_drc_instruction->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
+      if (ducking_set_expected) {
+        ia_drc_instructions_uni_drc *pstr_drc_instruction_prev =
+            &pstr_uni_drc_config->str_drc_instructions_uni_drc[i - 1];
+        if (pstr_drc_instruction_prev->ducking_only_set_present) {
+          err_code = impd_drc_write_drc_instruct_uni_drc(it_bit_buf, version, pstr_uni_drc_config,
+                                                         pstr_gain_enc, pstr_drc_instruction,
+                                                         ptr_scratch, &bit_cnt_local);
+          if (err_code & IA_FATAL_ERROR) {
+            return (err_code);
+          }
+        }
+        ducking_set_expected = 0;
+      } else {
+        bit_cnt_local +=
+            iusace_write_bits_buf(it_bit_buf, pstr_drc_instruction->leveling_present, 1);
+        if (pstr_drc_instruction->leveling_present) {
+          ducking_set_expected = 1;
+          bit_cnt_local += iusace_write_bits_buf(
+              it_bit_buf, pstr_drc_instruction->ducking_only_set_present, 1);
+          continue;
+        }
+      }
+    }
+  }
+
+  // V1 instructions
+  version = 1;
+  ducking_set_expected = 0;
+  for (WORD16 i = 0; i < drc_instructions_uni_drc_count_v1; i++) {
+    ia_drc_instructions_uni_drc *pstr_drc_instruction =
+        &pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_instructions_uni_drc_v1[i];
+    if (pstr_drc_instruction->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
+      if (ducking_set_expected) {
+        ia_drc_instructions_uni_drc *pstr_drc_instruction_prev =
+            &pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_instructions_uni_drc_v1[i - 1];
+        if (pstr_drc_instruction_prev->ducking_only_set_present) {
+          err_code = impd_drc_write_drc_instruct_uni_drc(it_bit_buf, version, pstr_uni_drc_config,
+                                                         pstr_gain_enc, pstr_drc_instruction,
+                                                         ptr_scratch, &bit_cnt_local);
+          if (err_code & IA_FATAL_ERROR) {
+            return (err_code);
+          }
+        }
+        ducking_set_expected = 0;
+      } else {
+        bit_cnt_local +=
+            iusace_write_bits_buf(it_bit_buf, pstr_drc_instruction->leveling_present, 1);
+        if (pstr_drc_instruction->leveling_present) {
+          ducking_set_expected = 1;
+          bit_cnt_local += iusace_write_bits_buf(
+              it_bit_buf, pstr_drc_instruction->ducking_only_set_present, 1);
+          continue;
+        }
+      }
+    }
+  }
+  *bit_cnt += bit_cnt_local;
+  return IA_NO_ERROR;
+}
+#endif
+
 static VOID impd_drc_write_gain_params(ia_bit_buf_struct *it_bit_buf, const WORD32 version,
                                       const WORD32 band_count, const WORD32 drc_band_type,
                                       ia_drc_gain_params_struct *pstr_gain_params,
@ -2536,6 +2627,9 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn(
         pstr_uni_drc_config_ext->uni_drc_config_ext_type[counter] != UNIDRC_CONF_EXT_TERM) {
    switch (pstr_uni_drc_config_ext->uni_drc_config_ext_type[counter]) {
      case UNIDRC_CONF_EXT_PARAM_DRC: {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+        bit_cnt_local_ext = 0;
+#endif  // LOUDNESS_LEVELING_SUPPORT
        err_code = impd_drc_write_drc_coeff_parametric_drc(
            ptr_bit_buf_ext, pstr_uni_drc_config,
            &(pstr_uni_drc_config_ext->str_drc_coeff_parametric_drc), &bit_cnt_local_ext);
@ -2559,6 +2653,9 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn(
      } break;
      case UNIDRC_CONF_EXT_V1: {
        version = 1;
+#ifdef LOUDNESS_LEVELING_SUPPORT
+        bit_cnt_local_ext = 0;
+#endif  // LOUDNESS_LEVELING_SUPPORT
        bit_cnt_local_ext += iusace_write_bits_buf(
            ptr_bit_buf_ext, pstr_uni_drc_config_ext->downmix_instructions_v1_present, 1);
        if (pstr_uni_drc_config_ext->downmix_instructions_v1_present == 1) {
@ -2583,10 +2680,27 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn(
                &(pstr_uni_drc_config_ext->str_drc_coefficients_uni_drc_v1[idx]),
                &bit_cnt_local_ext);
          }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+          UWORD32 num_ducking_only_drc_sets = get_num_ducking_only_drc_sets(
+              pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1,
+              pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count);

+          bit_cnt_local_ext +=
+              iusace_write_bits_buf(ptr_bit_buf_ext,
+                                    pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count -
+                                        num_ducking_only_drc_sets,
+                                    6);
+#else
          bit_cnt_local_ext += iusace_write_bits_buf(
              ptr_bit_buf_ext, pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count, 6);
+#endif
          for (idx = 0; idx < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count; idx++) {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+            if (idx > 0 && pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx - 1]
+                               .ducking_only_set_present) {
+              continue;
+            }
+#endif
            err_code = impd_drc_write_drc_instruct_uni_drc(
                ptr_bit_buf_ext, version, pstr_uni_drc_config, pstr_gain_enc,
                &(pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx]), ptr_scratch,
@ -2632,6 +2746,17 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn(
          }
        }
      } break;
+
+#ifdef LOUDNESS_LEVELING_SUPPORT
+      case UNIDRCCONFEXT_LEVELING: {
+        bit_cnt_local_ext = 0;
+        err_code = write_loudness_leveling_extension(
+            ptr_bit_buf_ext, pstr_uni_drc_config, pstr_gain_enc, ptr_scratch, &bit_cnt_local_ext);
+        if (err_code & IA_FATAL_ERROR) {
+          return (err_code);
+        }
+      } break;
+#endif
      default:
        break;
    }
@ -2639,6 +2764,9 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn(
    pstr_uni_drc_config_ext->ext_bit_size[counter] = bit_cnt_local_ext;
    bit_size = pstr_uni_drc_config_ext->ext_bit_size[counter] - 1;
    ext_size_bits = (WORD32)(log((FLOAT32)bit_size) / log(2.f)) + 1;
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    ext_size_bits = (ext_size_bits < 4) ? 4 : ext_size_bits;
+#endif  // LOUDNESS_LEVELING_SUPPORT
    bit_size_len = ext_size_bits - 4;

    bit_cnt_local += iusace_write_bits_buf(it_bit_buf, bit_size_len, 4);
@ -2693,10 +2821,26 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn(
                it_bit_buf, version,
                &(pstr_uni_drc_config_ext->str_drc_coefficients_uni_drc_v1[idx]), &bit_cnt_local);
          }
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+          UWORD32 num_ducking_only_drc_sets = get_num_ducking_only_drc_sets(
+              pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1,
+              pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count);
+          bit_cnt_local +=
+              iusace_write_bits_buf(it_bit_buf,
+                                    pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count -
+                                        num_ducking_only_drc_sets,
+                                    6);
+#else
          bit_cnt_local += iusace_write_bits_buf(
              it_bit_buf, pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count, 6);
+#endif
          for (idx = 0; idx < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count; idx++) {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+            if (idx > 0 && pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx - 1]
+                               .ducking_only_set_present) {
+              continue;
+            }
+#endif
            err_code = impd_drc_write_drc_instruct_uni_drc(
                it_bit_buf, version, pstr_uni_drc_config, pstr_gain_enc,
                &(pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx]), ptr_scratch,
@ -2741,6 +2885,15 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn(
          }
        }
      } break;
+#ifdef LOUDNESS_LEVELING_SUPPORT
+      case UNIDRCCONFEXT_LEVELING: {
+        err_code = write_loudness_leveling_extension(it_bit_buf, pstr_uni_drc_config,
+                                                     pstr_gain_enc, ptr_scratch, &bit_cnt_local);
+        if (err_code & IA_FATAL_ERROR) {
+          return (err_code);
+        }
+      } break;
+#endif
      default:
        for (idx = 0; idx < pstr_uni_drc_config_ext->ext_bit_size[counter]; idx++) {
          bit_cnt_local += iusace_write_bits_buf(it_bit_buf, 0, 1);
@ -3019,7 +3172,7 @@ IA_ERRORCODE impd_drc_write_measured_loudness_info(ia_drc_enc_state *pstr_drc_st
    return (err_code);
  }
  pstr_drc_state->drc_config_ext_data_size_bit = bit_cnt_lis;
- 
+
  return err_code;
 }

--- a/encoder/drc_src/impd_drc_uni_drc.h
+++ b/encoder/drc_src/impd_drc_uni_drc.h
@ -388,6 +388,10 @@ typedef struct {
  WORD32 multiband_audio_signal_count;
  WORD32 channel_group_is_parametric_drc[MAX_CHANNEL_GROUP_COUNT];
  WORD32 gain_set_idx_for_ch_group_parametric_drc[MAX_CHANNEL_GROUP_COUNT];
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD32 leveling_present;
+  WORD32 ducking_only_set_present;
+#endif
 } ia_drc_instructions_uni_drc;

 typedef struct {
--- a/encoder/ixheaace_api.c
+++ b/encoder/ixheaace_api.c
@ -831,7 +831,7 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str
    return err_code;
  }

-  if (pstr_input_config->ui_pcm_wd_sz != 16) {
+  if (pstr_input_config->ui_pcm_wd_sz != 16 && pstr_input_config->ui_pcm_wd_sz != 32) {
    return (IA_EXHEAACE_CONFIG_FATAL_PCM_WDSZ);
  }
  if ((pstr_input_config->aac_config.inv_quant != 0) &&
@ -901,6 +901,7 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str
        (AOT_AAC_ELD == pstr_input_config->aot)) {
      pstr_api_struct->config[ele_idx].aac_classic = 0;
    }
+#ifndef AAC_NEW_TABLES
    if (pstr_api_struct->config[ele_idx].sample_rate < 32000) {
      if (pstr_api_struct->config[ele_idx].aac_classic == 0) {
        pstr_api_struct->config[ele_idx].aac_classic = 1;
@ -912,6 +913,7 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str
        pstr_input_config->aot = AOT_AAC_LD;
      }
    }
+#endif
    pstr_api_struct->config[ele_idx].eldsbr_found =
        !(pstr_api_struct->config[ele_idx].aac_classic);
  }
@ -1213,6 +1215,8 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str
    }
    pstr_api_struct->config[0].aac_config.full_bandwidth =
        pstr_input_config->aac_config.full_bandwidth;
+    pstr_api_struct->config[0].aac_config.band_width =
+        pstr_input_config->aac_config.bandwidth;
  }

  return IA_NO_ERROR;
@ -2474,7 +2478,7 @@ static IA_ERRORCODE ia_enhaacplus_enc_init(ixheaace_api_struct *pstr_api_struct,
          pstr_aac_config->bit_rate,
          (pstr_api_struct->pstr_state->mps_enable
               ? 1
-               : pstr_api_struct->config[ele_idx].chmode_nchannels),
+               : pstr_aac_config->num_out_channels),
          pstr_aac_config->sample_rate, &core_sample_rate,
          pstr_api_struct->spectral_band_replication_tabs.ptr_qmf_tab,
          pstr_api_struct->pstr_state->aot)) {
@ -2692,6 +2696,7 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru
  iexheaac_encoder_str **pstr_aac_enc;
  iaace_config *pstr_aac_config;
  pWORD16 pw_inp_buf = NULL;
+  pFLOAT32 pw_inp_buf_float = NULL;
  pUWORD8 pub_out_buf = NULL;
  FLOAT32 *ptr_input_buffer = NULL;
  FLOAT32 *ptr_input_buffer_mps = NULL;
@ -2729,6 +2734,8 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru
  pstr_aac_enc = pstr_api_struct->pstr_state->aac_enc_pers_mem;

  pw_inp_buf = (pWORD16)pstr_api_struct->pp_mem[IA_ENHAACPLUSENC_INPUT_IDX];
+  pw_inp_buf_float = (pFLOAT32)pstr_api_struct->pp_mem[IA_ENHAACPLUSENC_INPUT_IDX];
+
  if (ele_idx == 0) {
    pstr_api_struct->pstr_state->i_out_bytes = 0;
    pub_out_buf = ((pUWORD8)pstr_api_struct->pp_mem[IA_ENHAACPLUSENC_OUTPUT_IDX]);
@ -2851,25 +2858,25 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru
            (!((pstr_api_struct->pstr_mps_212_enc != NULL) &&
               pstr_api_struct->pstr_state->mps_enable))) {
          for (idx = 0; idx < (num_samples_read); idx++) {
-            ptr_input_buffer[write_off_set + idx] = (FLOAT32)pw_inp_buf[idx];
+            ptr_input_buffer[write_off_set + idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767);
          }
        } else if (pstr_api_struct->config[ele_idx].i_channels == 1) {
          for (idx = 0; idx < num_samples_read; idx++) {
            ptr_input_buffer[write_off_set + (IXHEAACE_MAX_CH_IN_BS_ELE * idx)] =
-                (FLOAT32)pw_inp_buf[idx];
+                pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767);
          }
        } else if ((pstr_api_struct->pstr_mps_212_enc != NULL) &&
                   pstr_api_struct->pstr_state->mps_enable) {
          ptr_input_buffer_mps = pstr_api_struct->pstr_state->time_signal_mps;
          for (idx = 0; idx < (num_samples_read / 2); idx++) {
-            ptr_input_buffer_mps[idx] = (FLOAT32)pw_inp_buf[2 * idx];
+            ptr_input_buffer_mps[idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[2 * idx] : (pw_inp_buf_float[2 * idx] * 32767);
            ptr_input_buffer_mps[(num_samples_read / 2) + idx] =
-                (FLOAT32)pw_inp_buf[(2 * idx) + 1];
+                pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[(2 * idx) + 1] : (pw_inp_buf_float[(2 * idx) + 1] * 32767);
          }
        }
      } else {
        for (idx = 0; idx < (num_samples_read + write_off_set); idx++) {
-          ptr_input_buffer[idx] = (FLOAT32)pw_inp_buf[idx];
+          ptr_input_buffer[idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767);
        }
      }
    } else {
@ -2877,9 +2884,9 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru
        slot = pstr_api_struct->config[ele_idx].element_slot;
        for (idx = 0; idx < num_samples_read / 2; idx++) {
          ptr_input_buffer[2 * idx + write_off_set] =
-              (FLOAT32)pw_inp_buf[total_channels * idx + slot];
+              pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[total_channels * idx + slot] : (pw_inp_buf_float[total_channels * idx + slot] * 32767);
          ptr_input_buffer[2 * idx + write_off_set + 1] =
-              (FLOAT32)pw_inp_buf[total_channels * idx + slot + 1];
+              pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[total_channels * idx + slot + 1] : (pw_inp_buf_float[total_channels * idx + slot + 1] * 32767);
        }
      }

@ -2887,14 +2894,14 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru
        slot = pstr_api_struct->config[ele_idx].element_slot;
        for (idx = 0; idx < num_samples_read; idx++) {
          ptr_input_buffer[write_off_set + (IXHEAACE_MAX_CH_IN_BS_ELE * idx)] =
-              (FLOAT32)pw_inp_buf[total_channels * idx + slot];
+              pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[total_channels * idx + slot] : (pw_inp_buf_float[total_channels * idx + slot] * 32767);
        }
      }

      if (pstr_api_struct->config[ele_idx].i_channels == 6) {
        ptr_input_buffer_mps = pstr_api_struct->pstr_state->time_signal_mps;
        for (idx = 0; idx < num_samples_read; idx++) {
-          ptr_input_buffer_mps[idx] = (FLOAT32)pw_inp_buf[idx];
+          ptr_input_buffer_mps[idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767);
        }
      }
    }
--- a/encoder/ixheaace_asc_write.c
+++ b/encoder/ixheaace_asc_write.c
@ -412,6 +412,7 @@ WORD32 ixheaace_get_audiospecific_config_bytes(
    pstr_audio_specific_config->sampling_frequency /= 2;

    if ((AOT_SBR == aot) || (AOT_PS == aot)) {
+      ext_aot = aot;
      aot = AOT_AAC_LC;
    }
  }
@ -460,9 +461,12 @@ WORD32 ixheaace_get_audiospecific_config_bytes(
  bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff,
                                   (pstr_audio_specific_config->channel_configuration), 4);

+  if (ext_aot != -1) aot = ext_aot;
+
  if ((AOT_SBR == aot) || (AOT_PS == aot)) {
    ext_aot = AOT_SBR;
    sbr_present_flag = 1;
+
    tmp = 0x0f;
    for (i = 0; i < sizeof(ia_sampl_freq_table) / sizeof(ia_sampl_freq_table[0]); i++) {
      if (ia_sampl_freq_table[i] == pstr_audio_specific_config->ext_sampling_frequency) {
@ -470,18 +474,12 @@ WORD32 ixheaace_get_audiospecific_config_bytes(
        break;
      }
    }
+
    pstr_audio_specific_config->ext_samp_freq_index = (UWORD32)tmp;
-    bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff,
-                                     (pstr_audio_specific_config->ext_samp_freq_index), 4);
-    if (pstr_audio_specific_config->ext_samp_freq_index == 0xf) {
-      bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff,
-                                       (pstr_audio_specific_config->ext_sampling_frequency), 24);
-    }
+
    if (AOT_PS == aot) {
      ps_present_flag = 1;
    }
-
-    bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, AOT_AAC_LC, 5);
  }
  switch (aot) {
    case AOT_AAC_ELD: {
@ -506,7 +504,7 @@ WORD32 ixheaace_get_audiospecific_config_bytes(
        ext_id = 0x2b7;
        bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, ext_id, 11);

-        bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, aot, 5);
+        bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, ext_aot, 5);
        bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, sbr_present_flag, 1);
        if (sbr_present_flag) {
          bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff,
--- a/encoder/ixheaace_enc_init.c
+++ b/encoder/ixheaace_enc_init.c
@ -374,7 +374,7 @@ IA_ERRORCODE ia_enhaacplus_enc_aac_enc_open(iexheaac_encoder_str **ppstr_exheaac

  WORD32 tns_mask = config.use_tns;
  if (config.full_bandwidth) {
-    pstr_exheaac_encoder->config.band_width = config.core_sample_rate >> 2;
+    pstr_exheaac_encoder->config.band_width = config.core_sample_rate >> (aot == AOT_USAC ? 2 : 1);
  } else {
    ixheaace_determine_bandwidth(pstr_exheaac_encoder->config.band_width, config.bit_rate,
                                 config.core_sample_rate, pstr_element_info->n_channels_in_el,
--- a/encoder/ixheaace_rom.c
+++ b/encoder/ixheaace_rom.c
@ -1620,6 +1620,7 @@ const ixheaace_temporal_noise_shaping_tables ixheaace_enhaacplus_enc_tns_tab = {
     {8000, 39, 14, 39, 14, 31, 30}},

    /*tns_info_tab[5]*/
+#ifndef AAC_NEW_TABLES
    {{4000,
      12000,
      {1.2f, 1800, 16000, 0.6f},
@ -1654,7 +1655,49 @@ const ixheaace_temporal_noise_shaping_tables ixheaace_enhaacplus_enc_tns_tab = {
      {1.41f, 3750, 16000, 0.3f},
      {1.41f, 2500, 16000, 0.5f},
      {1.41f, 3750, 16000, 0.3f}}},
+#else
+    {{4000,
+      12000,
+      {1.2f, 1800, 16000, 0.6f},
+      {1.2f, 2500, 16000, 0.6f},
+      {1.2f, 1800, 16000, 0.6f},
+      {1.2f, 2500, 16000, 0.6f}},

+     {12001,
+      20000,
+      {1.41f, 2500, 16000, 0.6f},
+      {1.41f, 3750, 16000, 0.6f},
+      {1.41f, 2500, 16000, 0.6f},
+      {1.41f, 3750, 16000, 0.6f}},
+
+     {20001,
+      28000,
+      {1.41f, 2500, 16000, 0.5f},
+      {1.41f, 3750, 16000, 0.5f},
+      {1.41f, 2500, 16000, 0.5f},
+      {1.41f, 3750, 16000, 0.5f}},
+
+     {28001,
+      36000,
+      {1.41f, 2500, 16000, 0.8f},
+      {1.41f, 3750, 16000, 0.3f},
+      {1.41f, 2500, 16000, 0.5f},
+      {1.41f, 3750, 16000, 0.3f}},
+
+     {36001,
+      52000,
+      {1.41f, 2500, 16000, 0.5f},
+      {1.41f, 3750, 16000, 0.1f},
+      {1.41f, 2500, 16000, 0.5f},
+      {1.41f, 3750, 16000, 0.1f}},
+
+     {52001,
+      576000,
+      {1.41f, 2500, 16000, 0.3f},
+      {1.41f, 3750, 16000, 0.1f},
+      {1.41f, 2500, 16000, 0.3f},
+      {1.41f, 3750, 16000, 0.1f}}},
+#endif
    /*tns_coeff_3[8]*/

    {-0.98480773f, -0.866025389f, -0.642787576f, -0.342020154f, 0.0f, 0.433883727f, 0.781831503f,
--- a/encoder/ixheaace_rom.h
+++ b/encoder/ixheaace_rom.h
@ -100,7 +100,7 @@ typedef struct {
 extern const ixheaace_quant_tables ixheaace_enc_quant_tab;
 typedef struct {
  const ixheaace_temporal_noise_shaping_max_table tns_max_bands_table[12];
-  const ixheaace_temporal_noise_shaping_info_tab tns_info_tab[5];
+  const ixheaace_temporal_noise_shaping_info_tab tns_info_tab[6];
  const FLOAT32 tns_coeff_3[8];
  const FLOAT32 tns_coeff_3_borders[8];
  const FLOAT32 tns_coeff_4[16];
--- a/encoder/ixheaace_sbr_env_est.c
+++ b/encoder/ixheaace_sbr_env_est.c
@ -2155,7 +2155,7 @@ IA_ERRORCODE ixheaace_extract_sbr_envelope(FLOAT32 *ptr_in_time, FLOAT32 *ptr_co
    } else if (pstr_sbr_extract_env->time_step == 4) {
      ixheaace_detect_transient_4_1(pstr_sbr_extract_env->ptr_y_buffer,
                                    &pstr_env_ch[ch]->str_sbr_trans_detector, transient_info[ch],
-                                    pstr_sbr_extract_env->time_step, pstr_sbr_cfg->sbr_codec);
+                                    pstr_sbr_extract_env->time_step);
    } else {
      ixheaace_detect_transient(pstr_sbr_extract_env->ptr_y_buffer,
                                &pstr_env_ch[ch]->str_sbr_trans_detector, transient_info[ch],
--- a/encoder/ixheaace_sbr_env_est.h
+++ b/encoder/ixheaace_sbr_env_est.h
@ -47,8 +47,7 @@ ixheaace_create_extract_sbr_envelope(WORD32 ch,
                                     ixheaace_pstr_sbr_extract_envelope pstr_sbr_ext_env,
                                     WORD32 start_index, WORD32 *ptr_common_buffer2,
                                     FLOAT32 *ptr_sbr_env_r_buf, FLOAT32 *ptr_sbr_env_i_buf,
-                                     WORD32 is_ld_sbr, WORD32 frame_flag_480,
-                                     ixheaace_sbr_codec_type sbr_codec);
+                                     WORD32 frame_flag_480, ixheaace_sbr_codec_type sbr_codec);

 struct ixheaace_str_sbr_config_data;
 struct ixheaace_str_sbr_bitstream_data;
--- a/encoder/ixheaace_sbr_env_est_init.c
+++ b/encoder/ixheaace_sbr_env_est_init.c
@ -62,8 +62,7 @@ ixheaace_create_extract_sbr_envelope(WORD32 ch,
                                     ixheaace_pstr_sbr_extract_envelope pstr_sbr_ext_env,
                                     WORD32 start_index, WORD32 *ptr_common_buffer2,
                                     FLOAT32 *ptr_sbr_env_r_buf, FLOAT32 *ptr_sbr_env_i_buf,
-                                     WORD32 is_ld_sbr, WORD32 frame_flag_480,
-                                     ixheaace_sbr_codec_type sbr_codec) {
+                                     WORD32 frame_flag_480, ixheaace_sbr_codec_type sbr_codec) {
  WORD32 i;
  WORD32 y_buffer_length, r_buffer_length;
  WORD32 offset = 0;
--- a/encoder/ixheaace_sbr_freq_scaling.c
+++ b/encoder/ixheaace_sbr_freq_scaling.c
@ -231,16 +231,16 @@ static WORD32 ixheaace_get_stop_freq(WORD32 fs, WORD32 stop_freq) {

  switch (fs) {
    case 16000:
-      k1_min = ixheaace_stop_freq_16k[0];
-      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_16k[0];
+      k1_min = ixheaace_usac_stop_freq_16k[0];
+      v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_16k[0];
      break;
    case 22050:
-      k1_min = ixheaace_stop_freq_22k[0];
-      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_22k[0];
+      k1_min = ixheaace_usac_stop_freq_22k[0];
+      v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_22k[0];
      break;
    case 24000:
-      k1_min = ixheaace_stop_freq_24k[0];
-      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_24k[0];
+      k1_min = ixheaace_usac_stop_freq_24k[0];
+      v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_24k[0];
      break;
    case 32000:
      k1_min = 32;
@ -260,6 +260,24 @@ static WORD32 ixheaace_get_stop_freq(WORD32 fs, WORD32 stop_freq) {
      v_stop_freq = (WORD32 *)vector_stop_freq_48;
      break;

+    case 64000:
+      k1_min = 20;
+
+      v_stop_freq = (WORD32 *)vector_stop_freq_64;
+      break;
+
+    case 88200:
+      k1_min = 15;
+
+      v_stop_freq = (WORD32 *)vector_stop_freq_88;
+      break;
+
+    case 96000:
+      k1_min = 13;
+
+      v_stop_freq = (WORD32 *)vector_stop_freq_96;
+      break;
+
    default:
      v_stop_freq = (WORD32 *)vector_stop_freq_32;
      k1_min = 21; /* illegal fs  */
--- a/encoder/ixheaace_sbr_main.c
+++ b/encoder/ixheaace_sbr_main.c
@ -100,7 +100,7 @@ FLOAT32 *ixheaace_get_hbe_resample_buffer(ixheaace_pstr_sbr_enc pstr_env_enc) {
 static FLAG ia_enhaacplus_enc_get_sbr_tuning_table_idx(
    UWORD32 bitrate, UWORD32 num_ch, UWORD32 sample_rate, ixheaace_str_qmf_tabs *pstr_qmf_tab,
    UWORD32 *ptr_closest_br, WORD32 *ptr_idx_sr, WORD32 *ptr_idx_ch, WORD32 *ptr_idx_entry,
-    ixheaace_sbr_tuning_tables sbr_tune_table[10][2][10]) {
+    ixheaace_sbr_tuning_tables sbr_tune_table[10][2][20]) {
  WORD32 found = 0;
  WORD32 i_sr, br_closest_lower_idx_sr = -1, br_closest_upper_idx_sr = -1;
  WORD32 br_closest_lower_idx_ch = -1, br_closest_upper_idx_sch = -1;
@ -262,7 +262,7 @@ static IA_ERRORCODE ixheaace_create_env_channel(
  }
  err_code = ixheaace_create_extract_sbr_envelope(
      ch, &pstr_env->str_sbr_extract_env, start_index, ptr_common_buffer2, ptr_sbr_env_r_buf,
-      ptr_sbr_env_i_buf, params->is_ld_sbr, params->frame_flag_480, params->sbr_codec);
+      ptr_sbr_env_i_buf, params->frame_flag_480, params->sbr_codec);
  if (err_code) {
    return err_code;
  }
@ -386,6 +386,7 @@ ixheaace_is_sbr_setting_available(UWORD32 bitrate, UWORD32 num_output_channels,
  WORD32 idx_ch;
  WORD32 idx_entry;

+#ifndef AAC_NEW_TABLES
  switch (num_output_channels) {
    case MONO:
      if (sample_rate_input < 16000 || sample_rate_input > 48000) {
@ -396,6 +397,7 @@ ixheaace_is_sbr_setting_available(UWORD32 bitrate, UWORD32 num_output_channels,
        return 0;
      }
  }
+#endif

  *ptr_core_sr = sample_rate_input / 2;

@ -965,7 +967,7 @@ ixheaace_env_open(ixheaace_pstr_sbr_enc *pstr_env_encoder, ixheaace_pstr_sbr_cfg
  pstr_env_enc->str_sbr_cfg.stereo_mode =
      (params->codec_settings.num_channels == 2) ? params->stereo_mode : IXHEAACE_SBR_MODE_MONO;

-  if (params->codec_settings.sample_freq <= 24000) {
+  if (1) {
    pstr_env_enc->str_sbr_hdr.sample_rate_mode = IXHEAACE_DUAL_RATE;
    if (params->sbr_codec == USAC_SBR) {
      pstr_env_enc->str_sbr_cfg.sample_freq = 2 * params->codec_settings.sample_freq;
--- a/encoder/ixheaace_sbr_noise_floor_est.c
+++ b/encoder/ixheaace_sbr_noise_floor_est.c
@ -136,8 +136,10 @@ static VOID ia_enhaacplus_enc_qmf_based_noise_floor_detection(
      mean_org += ton_org;
      mean_sbr += ton_sbr;
    }
-    mean_org /= (stop_channel - start_channel);
-    mean_sbr /= (stop_channel - start_channel);
+    if ((stop_channel - start_channel) > 0) {
+      mean_org /= (stop_channel - start_channel);
+      mean_sbr /= (stop_channel - start_channel);
+    }
  }

  if (mean_org < SBR_TON_MEAN_P0009 && mean_sbr < SBR_TON_MEAN_P0009) {
--- a/encoder/ixheaace_sbr_rom.c
+++ b/encoder/ixheaace_sbr_rom.c
@ -48,6 +48,9 @@ const WORD32 vector_offset_def[] = {0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20, 2
 const WORD32 vector_stop_freq_32[14] = {32, 34, 36, 38, 40, 42, 44, 46, 49, 52, 55, 58, 61, 64};
 const WORD32 vector_stop_freq_44[14] = {23, 25, 27, 29, 32, 34, 37, 40, 43, 47, 51, 55, 59, 64};
 const WORD32 vector_stop_freq_48[14] = {21, 23, 25, 27, 30, 32, 35, 38, 42, 45, 49, 54, 59, 64};
+const WORD32 vector_stop_freq_64[14] = {20, 22, 24, 26, 29, 31, 34, 37, 41, 45, 49, 54, 59, 64};
+const WORD32 vector_stop_freq_88[14] = {15, 17, 19, 21, 23, 26, 29, 33, 37, 41, 46, 51, 57, 64};
+const WORD32 vector_stop_freq_96[14] = {13, 15, 17, 19, 21, 24, 27, 31, 35, 39, 44, 50, 57, 64};

 const ixheaace_str_ps_tab ia_enhaacplus_enc_ps_tab = {
    /*a_hyb_res[3]*/
@ -621,6 +624,7 @@ const ixheaace_str_qmf_tabs ixheaace_qmf_tab = {
    {0.05857864376269f, 0.2f, 0.34142135623731f, 0.4f},

    {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000},
+#ifndef AAC_NEW_TABLES
    {{{{8000, 10000, {7, 11}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
       {10000, 12000, {11, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
       {12000, 48001, {14, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
@ -738,6 +742,200 @@ const ixheaace_str_qmf_tabs ixheaace_qmf_tab = {
       {0}}}

    },
+#else
+    {{{
+       /*** 8000hz 1ch SBR_AAC ***/
+       {8000, 10000, {7, 11}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {10000, 12000, {11, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {12000, 16000, {14, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 24000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {24000, 32000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {32000, 48001, {14, 15}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 8000hz 2ch SBR_AAC ***/
+       {16000, 24000, {6, 9}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {9, 11}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 36000, {11, 11}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {14, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 128001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 11025hz 1ch SBR_AAC ***/
+       {8000, 10000, {5, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {10000, 12000, {8, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {12000, 16000, {12, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 20000, {12, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {20000, 24000, {13, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {24000, 32000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {32000, 48000, {15, 15}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {48000, 66001, {15, 15}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 11025hz 2ch SBR_AAC ***/
+       {16000, 24000, {7, 9}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {10, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 36000, {12, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {14, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 132301, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 12000hz 1ch SBR_AAC ***/
+       {8000, 10000, {4, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {10000, 12000, {7, 11}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {12000, 16000, {11, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 20000, {11, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {20000, 24000, {12, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {24000, 32000, {13, 13}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {32000, 48000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {48000, 72001, {15, 15}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 12000hz 2ch SBR_AAC ***/
+       {16000, 24000, {6, 9}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {9, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 36000, {11, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {12, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {14, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 144001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 16000hz 1ch SBR_AAC ***/
+       {6000, 8000, {0, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {8000, 10000, {1, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {10000, 12000, {2, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {12000, 16000, {4, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 18000, {4, 8}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {18000, 22000, {6, 11}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {22000, 28000, {10, 12}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {28000, 36000, {12, 13}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 44000, {14, 13}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {44000, 96001, {15, 13}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 16000hz 2ch SBR_AAC ***/
+       {16000, 24000, {4, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {8, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 36000, {10, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {15, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 192001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 22050hz 1ch SBR_AAC ***/
+       {8000, 11369, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {11369, 16000, {3, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 18000, {3, 5}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {18000, 22000, {4, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {22000, 28000, {7, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {28000, 36000, {10, 9}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 44000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {44000, 132151, {13, 12}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 22050hz 2ch SBR_AAC ***/
+       {16000, 24000, {2, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {5, 6}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 32000, {5, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {32000, 36000, {7, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {10, 9}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {12, 9}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {13, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 101000, {14, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {101000, 264601, {15, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 24000hz 1ch SBR_AAC ***/
+       {8000, 12000, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {12000, 16000, {3, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 18000, {3, 5}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {18000, 22000, {4, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {22000, 28000, {7, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {28000, 36000, {10, 9}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 44000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {44000, 144001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 24000hz 2ch SBR_AAC ***/
+       {16000, 24000, {2, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {5, 6}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 36000, {7, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {10, 9}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {12, 9}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {13, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {14, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 288001, {15, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 32000hz 1ch SBR_AAC ***/
+       {24000, 36000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 60000, {7, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {60000, 72000, {9, 8}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {72000, 100000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {100000, 192001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 32000hz 2ch SBR_AAC ***/
+       {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {80000, 112000, {9, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {112000, 144000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {144000, 384001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 44100hz 1ch SBR_AAC ***/
+       {24000, 36000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 60000, {7, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {60000, 72000, {9, 8}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {72000, 100000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {100000, 264601, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 44100hz 2ch SBR_AAC ***/
+       {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {80000, 112000, {9, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {112000, 144000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {144000, 529201, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 48000hz 1ch SBR_AAC ***/
+       {24000, 36000, {4, 9}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 60000, {7, 10}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {60000, 72000, {9, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {72000, 100000, {11, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {100000, 288001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 48000hz 2ch SBR_AAC ***/
+       {32000, 60000, {4, 9}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 80000, {7, 10}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {80000, 112000, {9, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {112000, 144000, {11, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {144000, 576001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}}
+
+    },
+#endif
+#ifndef AAC_NEW_TABLES
    {{{{0}}},

     {{{0}}},
@ -824,7 +1022,146 @@ const ixheaace_str_qmf_tabs ixheaace_qmf_tab = {
       {144000, 176000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
       {176000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
       {0}}}}
+#else
+    {{{{0}}},

+     {{{0}}},
+
+     {{
+       /*** 12000hz 1ch ***/
+       {8000, 32000, {1, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       {0}}},
+
+     {{
+       /*** 16000hz 1ch ***/
+       {8000, 10000, {1, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {10000, 12000, {2, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {12000, 16000, {4, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 18000, {4, 9}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {18000, 22000, {7, 12}, 3, {1, 6, 9}, IXHEAACE_SBR_MODE_MONO},
+       {22000, 28000, {6, 9}, 3, {2, 3, 6}, IXHEAACE_SBR_MODE_MONO},
+       {28000, 36000, {8, 12}, 3, {2, 9, 12}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 44000, {10, 12}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {44000, 64001, {11, 13}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 16000hz 2ch ***/
+       {16000, 24000, {4, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {8, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 36000, {10, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {10, 11}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {14, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 128001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 22050hz 1ch ***/
+       {8000, 11369, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {11369, 16000, {1, 3}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 18000, {2, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {18000, 22000, {4, 5}, 3, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {22000, 28000, {5, 6}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {28000, 36000, {7, 8}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 44000, {9, 9}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {44000, 52000, {12, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {52000, 70000, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {70000, 88001, {14, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 22050hz 2ch ***/
+       {16000, 24000, {0, 0}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {3, 5}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 32000, {3, 7}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {32000, 36000, {5, 7}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {5, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {7, 8}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {9, 9}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {10, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 82000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {82000, 128001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 24000hz 1ch ***/
+       {8000, 12000, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {12000, 16000, {1, 3}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {16000, 18000, {1, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO},
+       {18000, 22000, {4, 8}, 2, {2, 3, 6}, IXHEAACE_SBR_MODE_MONO},
+       {22000, 28000, {3, 8}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {28000, 36000, {4, 8}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 56000, {8, 9}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {56000, 70000, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {70000, 88001, {14, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 24000hz 2ch ***/
+       {16000, 24000, {0, 0}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {24000, 28000, {3, 5}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {28000, 36000, {5, 7}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {36000, 44000, {4, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {44000, 52000, {6, 8}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {52000, 60000, {9, 9}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 76000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {76000, 88000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {88000, 128001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 32000hz 1ch ***/
+       {24000, 36000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 60000, {7, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {60000, 72000, {9, 8}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {72000, 100000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {100000, 160001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 32000hz 2ch ***/
+       {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {80000, 112000, {9, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {112000, 144000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {144000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 44100hz 1ch ***/
+       {24000, 36000, {4, 9}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 60000, {8, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {60000, 72000, {9, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {72000, 100000, {11, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {100000, 160001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 44100hz 2ch ***/
+       {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {80000, 112000, {10, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {112000, 144000, {12, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {144000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}},
+
+     {{
+       /*** 48000hz 1ch ***/
+       {24000, 36000, {4, 3}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {36000, 60000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {60000, 72000, {9, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {72000, 100000, {11, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {100000, 160001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO},
+       {0}},
+      {
+       /*** 48000hz 2ch ***/
+       {32000, 60000, {4, 9}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {60000, 80000, {7, 10}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC},
+       {80000, 112000, {9, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {112000, 144000, {11, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {144000, 176000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {176000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT},
+       {0}}}}
+#endif
 };
 /*End of QMF Tables*/

--- a/encoder/ixheaace_sbr_rom.h
+++ b/encoder/ixheaace_sbr_rom.h
@ -120,8 +120,8 @@ typedef struct {
  ixheaace_str_frame_info_sbr frame_480_info4_2048;
  const FLOAT32 ptr_smooth_filter[4];
  UWORD32 supported_sample_rate[9];
-  ixheaace_sbr_tuning_tables sbr_tuning_table_lc[10][2][10];
-  ixheaace_sbr_tuning_tables sbr_tuning_table_ld[10][2][10];
+  ixheaace_sbr_tuning_tables sbr_tuning_table_lc[10][2][20];
+  ixheaace_sbr_tuning_tables sbr_tuning_table_ld[10][2][20];
 } ixheaace_str_qmf_tabs;

 typedef struct {
@ -181,6 +181,9 @@ extern const WORD32 vector_offset_def[];
 extern const WORD32 vector_stop_freq_32[14];
 extern const WORD32 vector_stop_freq_44[14];
 extern const WORD32 vector_stop_freq_48[14];
+extern const WORD32 vector_stop_freq_64[14];
+extern const WORD32 vector_stop_freq_88[14];
+extern const WORD32 vector_stop_freq_96[14];

 /* Resampler tables */
 extern const ixheaace_resampler_table ixheaace_resamp_2_to_1_iir_filt_params;
--- a/encoder/ixheaace_sbr_tran_det.h
+++ b/encoder/ixheaace_sbr_tran_det.h
@ -61,8 +61,7 @@ VOID ixheaace_detect_transient(FLOAT32 **ptr_energies,

 VOID ixheaace_detect_transient_4_1(FLOAT32 **ptr_energies,
                                   ixheaace_pstr_sbr_trans_detector pstr_sbr_trans_det,
-                                   WORD32 *ptr_tran_vector, WORD32 time_step,
-                                   ixheaace_sbr_codec_type sbr_codec);
+                                   WORD32 *ptr_tran_vector, WORD32 time_step);

 VOID ixheaace_detect_transient_eld(FLOAT32 **ptr_energies,
                                   ixheaace_pstr_sbr_trans_detector pstr_sbr_trans_det,
--- a/encoder/ixheaace_sbr_tran_det_hp.c
+++ b/encoder/ixheaace_sbr_tran_det_hp.c
@ -162,8 +162,7 @@ VOID ixheaace_detect_transient(FLOAT32 **ptr_energies,
 }

 static VOID ixheaace_calc_thresholds_4_1(FLOAT32 **ptr_energies, WORD32 num_cols, WORD32 num_rows,
-                                         FLOAT32 *ptr_thresholds,
-                                         ixheaace_sbr_codec_type sbr_codec, WORD32 time_step) {
+                                         FLOAT32 *ptr_thresholds, WORD32 time_step) {
  FLOAT32 mean_val, std_val, thr;
  FLOAT32 *ptr_energy;
  FLOAT32 inv_num_cols = 1.0f / (FLOAT32)((num_cols + num_cols / 2) / time_step);
@ -207,7 +206,7 @@ static VOID ixheaace_extract_transient_candidates_4_1(FLOAT32 **ptr_energies,
                                                      FLOAT32 *ptr_thresholds,
                                                      FLOAT32 *ptr_transients, WORD32 num_cols,
                                                      WORD32 start_band, WORD32 stop_band,
-                                                      WORD32 buf_len, WORD32 time_step)
+                                                      WORD32 time_step)

 {
  WORD32 idx;
@ -233,8 +232,7 @@ static VOID ixheaace_extract_transient_candidates_4_1(FLOAT32 **ptr_energies,

 VOID ixheaace_detect_transient_4_1(FLOAT32 **ptr_energies,
                                   ixheaace_pstr_sbr_trans_detector pstr_sbr_trans_det,
-                                   WORD32 *ptr_tran_vector, WORD32 time_step,
-                                   ixheaace_sbr_codec_type sbr_codec) {
+                                   WORD32 *ptr_tran_vector, WORD32 time_step) {
  WORD32 i;
  WORD32 no_cols = pstr_sbr_trans_det->no_cols;
  WORD32 qmf_start_sample = time_step * 4;
@ -246,12 +244,11 @@ VOID ixheaace_detect_transient_4_1(FLOAT32 **ptr_energies,

  ixheaace_calc_thresholds_4_1(ptr_energies, pstr_sbr_trans_det->no_cols,
                               pstr_sbr_trans_det->no_rows, pstr_sbr_trans_det->ptr_thresholds,
-                               sbr_codec, time_step);
+                               time_step);

  ixheaace_extract_transient_candidates_4_1(
      ptr_energies, pstr_sbr_trans_det->ptr_thresholds, pstr_sbr_trans_det->ptr_transients,
-      pstr_sbr_trans_det->no_cols, 0, pstr_sbr_trans_det->no_rows,
-      pstr_sbr_trans_det->buffer_length, time_step);
+      pstr_sbr_trans_det->no_cols, 0, pstr_sbr_trans_det->no_rows, time_step);

  for (i = 0; i < no_cols; i++) {
    if ((ptr_trans[i] < 0.9f * ptr_trans[i - 1]) && (ptr_trans[i - 1] > int_thr)) {
--- a/encoder/ixheaace_write_adts_adif.c
+++ b/encoder/ixheaace_write_adts_adif.c
@ -310,7 +310,7 @@ WORD32 ia_enhaacplus_enc_write_ADTS_header(pUWORD8 buffer, WORD32 bytes_used, WO
  if (write_flag) {
    /* Fixed ADTS header */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0xFFFF, 12); /* 12 bit Syncword */
-    ia_enhaacplus_enc_putbit(pstr_bitstream, 1 /*aacStateStruct->aacConfigSturct.mpegVersion*/,
+    ia_enhaacplus_enc_putbit(pstr_bitstream, 0 /*aacStateStruct->aacConfigSturct.mpegVersion*/,
                             1);                    /* ID == 0 for MPEG4 AAC, 1 for MPEG2 AAC */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 2); /* layer == 0 */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 1, 1); /* protection absent */
--- a/fuzzer/xaac_dec_fuzzer.cpp
+++ b/fuzzer/xaac_dec_fuzzer.cpp
@ -240,6 +240,10 @@ enum {
  DRC_BOOST_OFFSET,
  DRC_COMPRESS_OFFSET,
  DRC_EFFECT_OFFSET
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  ,
+  DRC_LOUDNESS_LEVELING_OFFSET
+#endif
 };

 IA_ERRORCODE Codec::initXAACDrc(const uint8_t* data, size_t size) {
@ -295,6 +299,15 @@ IA_ERRORCODE Codec::initXAACDrc(const uint8_t* data, size_t size) {
  err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM,
                              IA_ENHAACPLUS_DEC_DRC_EFFECT_TYPE, &ui_drc_val);

+#ifdef LOUDNESS_LEVELING_SUPPORT
+  // DRC_LOUDNESS_LEVELING_FLAG
+  size_t flagOffset = std::min((size_t)DRC_LOUDNESS_LEVELING_OFFSET, size - 1);
+  uint8_t loudnessFlag = data[flagOffset];
+  ui_drc_val = (unsigned int)loudnessFlag;
+  err_code = ixheaacd_dec_api(mXheaacCodecHandle, IA_API_CMD_SET_CONFIG_PARAM,
+                              IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING, &ui_drc_val);
+#endif
+
  return IA_NO_ERROR;
 }

--- a/fuzzer/xaac_enc_fuzzer.cpp
+++ b/fuzzer/xaac_enc_fuzzer.cpp
@ -56,7 +56,10 @@ static VOID ixheaace_read_drc_config_params(
    WORD32 in_ch) {
  WORD32 n, g, s, m, ch, p;
  WORD32 gain_set_channels;
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  UWORD32 loudness_leveling_extension_present = 0;
+  UWORD32 config_extension_count = 0;
+#endif
  pstr_enc_params->gain_sequence_present = fuzzed_data->ConsumeBool();
  pstr_enc_params->delay_mode = fuzzed_data->ConsumeBool();
  pstr_uni_drc_config->sample_rate_present = fuzzed_data->ConsumeBool();
@ -121,6 +124,13 @@ static VOID ixheaace_read_drc_config_params(
    pstr_drc_instructions_uni_drc->drc_instructions_type = fuzzed_data->ConsumeIntegral<WORD8>();
    pstr_drc_instructions_uni_drc->mae_group_id = fuzzed_data->ConsumeIntegral<WORD8>();
    pstr_drc_instructions_uni_drc->mae_group_preset_id = fuzzed_data->ConsumeIntegral<WORD8>();
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    if (pstr_drc_instructions_uni_drc->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
+      pstr_drc_instructions_uni_drc->leveling_present = fuzzed_data->ConsumeBool();
+      pstr_drc_instructions_uni_drc->ducking_only_set_present = fuzzed_data->ConsumeBool();
+      loudness_leveling_extension_present = 1;
+    }
+#endif
  }

  pstr_uni_drc_config->drc_coefficients_uni_drc_count =
@ -305,7 +315,13 @@ static VOID ixheaace_read_drc_config_params(
  pstr_enc_gain_extension->uni_drc_gain_ext_present = fuzzed_data->ConsumeBool();

  if (pstr_uni_drc_config->uni_drc_config_ext_present) {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[config_extension_count] =
+        UNIDRC_CONF_EXT_V1;
+    config_extension_count++;
+#else
    pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[0] = UNIDRC_CONF_EXT_V1;
+#endif
    pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present =
        fuzzed_data->ConsumeBool();
    if (pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present) {
@ -496,8 +512,23 @@ static VOID ixheaace_read_drc_config_params(
        pstr_drc_instructions_uni_drc->mae_group_id = fuzzed_data->ConsumeIntegral<WORD8>();
        pstr_drc_instructions_uni_drc->mae_group_preset_id =
            fuzzed_data->ConsumeIntegral<WORD8>();
+#ifdef LOUDNESS_LEVELING_SUPPORT
+
+        if (pstr_drc_instructions_uni_drc->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
+          pstr_drc_instructions_uni_drc->leveling_present = fuzzed_data->ConsumeBool();
+          pstr_drc_instructions_uni_drc->ducking_only_set_present = fuzzed_data->ConsumeBool();
+          loudness_leveling_extension_present = 1;
+        }
+#endif
      }
    }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    if (loudness_leveling_extension_present) {
+      pstr_uni_drc_config->str_uni_drc_config_ext
+          .uni_drc_config_ext_type[config_extension_count] = UNIDRCCONFEXT_LEVELING;
+      config_extension_count++;
+    }
+#endif
  }
 }

--- a/test/Android.bp
+++ b/test/Android.bp
@ -21,7 +21,8 @@ cc_test {
        "-DECLIPSE",
        "-DDRC_ENABLE",
        "-DMULTICHANNEL_ENABLE",
-        "-DENABLE_DRC"
+        "-DENABLE_DRC",
+        "-DLOUDNESS_LEVELING_SUPPORT",
    ],

    include_dirs: [
@ -50,6 +51,7 @@ cc_test {
    cflags: [
        "-O3",
        "-D_X86_",
+        "-DLOUDNESS_LEVELING_SUPPORT",
    ],

    include_dirs: [
--- a/test/decoder/impd_drc_config_params.h
+++ b/test/decoder/impd_drc_config_params.h
@ -44,7 +44,9 @@

 #define IA_DRC_DEC_CONFIG_PARAM_APPLY_CROSSFADE 0x0017
 #define IA_DRC_DEC_CONFIG_PARAM_CONFIG_CHANGED 0x0018
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+#define IA_DRC_DEC_CONFIG_DRC_LOUDNESS_LEVELING 0x0019
+#endif
 #define IA_API_CMD_SET_INPUT_BYTES_BS 0x0026
 #define IA_API_CMD_SET_INPUT_BYTES_IC_BS 0x0027
 #define IA_API_CMD_SET_INPUT_BYTES_IL_BS 0x0029
--- a/test/decoder/ixheaacd_error.c
+++ b/test/decoder/ixheaacd_error.c
@ -75,7 +75,12 @@ pWORD8 ixheaacd_ppb_config_non_fatal[IA_MAX_ERROR_SUB_CODE] = {
    (pWORD8) "Invalid target loudness value",
    (pWORD8) "Invalid HQ eSBR flag option. Setting to default 0",
    (pWORD8) "Invalid frame length flag option. Setting to default 0",
-    (pWORD8) "Invalid eSBR flag option. Setting to default 1"};
+    (pWORD8) "Invalid eSBR flag option. Setting to default 1"
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    ,
+    (pWORD8) "Invalid Loudness leveling flag option. Setting to default 1"
+#endif
+};
 /* Fatal Errors */
 pWORD8 ixheaacd_ppb_config_fatal[IA_MAX_ERROR_SUB_CODE] = {
    (pWORD8) "Invalid Sample rate specified for RAW decoding"};
@ -87,7 +92,12 @@ pWORD8 ixheaacd_ppb_config_fatal[IA_MAX_ERROR_SUB_CODE] = {
 pWORD8 ixheaacd_ppb_init_non_fatal[IA_MAX_ERROR_SUB_CODE] = {
    (pWORD8) "Header not found at the beginning of input data continuing syncing",
    (pWORD8) "Invalid number of QMF bands", (pWORD8) "Decoder initialization failed",
-    (pWORD8) "Input bytes insufficient for decoding", (pWORD8) "Error in AAC decoding"};
+    (pWORD8) "Input bytes insufficient for decoding", (pWORD8) "Error in AAC decoding"
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    ,
+    (pWORD8) "DRC instruction count exceeded"
+#endif
+};
 /* Fatal Errors */
 pWORD8 ixheaacd_ppb_init_fatal[IA_MAX_ERROR_SUB_CODE] = {
    (pWORD8) "AAC Decoder initialization failed",
--- a/test/decoder/ixheaacd_main.c
+++ b/test/decoder/ixheaacd_main.c
@ -667,6 +667,17 @@ IA_ERRORCODE ixheaacd_set_config_param(WORD32 argc, pWORD8 argv[],
      _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
      ec_enable = ui_err_conceal;
    }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    /* For loudness leveling*/
+    if (!strncmp((pCHAR8)argv[i], "-loudness_leveling:", 19)) {
+      pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 19);
+      UWORD32 loudness_leveling_flag = atoi(pb_arg_val);
+      err_code = (*p_ia_process_api)(p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
+                                     IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING,
+                                     &loudness_leveling_flag);
+      _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
+    }
+#endif
  }

  return IA_NO_ERROR;
@ -899,7 +910,9 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
  WORD32 drc_flag = 0;
  WORD32 mpegd_drc_present = 0;
  WORD32 uo_num_chan;
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD32 i_loudness_leveling_flag = 1;
+#endif
  /* The process API function */
  IA_ERRORCODE(*p_ia_process_api)
  (pVOID p_ia_process_api_obj, WORD32 i_cmd, WORD32 i_idx, pVOID pv_value);
@ -1410,6 +1423,22 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
      _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
    }

+#ifdef LOUDNESS_LEVELING_SUPPORT
+    /*Set loudness leveling */
+
+    {
+      err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
+                                     IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING,
+                                     &i_loudness_leveling_flag);
+      _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
+
+      err_code =
+          ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
+                         IA_DRC_DEC_CONFIG_DRC_LOUDNESS_LEVELING, &i_loudness_leveling_flag);
+      _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
+    }
+#endif
+
    /*Set loud_norm_flag*/
    {
      err_code = (*p_ia_process_api)(
@ -2238,6 +2267,9 @@ void print_usage() {
  printf("\n[-peak_limiter_off:<peak_limiter_off_flag>]");
  printf("\n[-err_conceal:<error_concealment_flag>]");
  printf("\n[-esbr:<esbr_flag>]");
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  printf("\n[-loudness_leveling:<loudness_leveling_flag>]");
+#endif
  printf("\n\nwhere, \n  <input_file> is the input AAC-LC/HE-AACv1/HE-AACv2//AAC-LD/AAC-ELD/AAC-ELDv2/USAC file name");
  printf("\n  <meta_data_file> is a text file which contains metadata.");
  printf("\n   To be given when -mp4:1 is enabled");
@ -2294,6 +2326,10 @@ void print_usage() {
  printf("\n  <error_concealment_flag> is to enable / disable error concealment.");
  printf("\n    Default value is 0");
  printf("\n  <esbr_flag> is to enable / disable eSBR. Default value is 1\n\n");
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  printf("\n  <loudness_leveling_flag> is to enable / disable loudness leveling.");
+  printf("\n    Default value is 1");
+#endif
 }

 /*******************************************************************************/
--- a/test/decoder/xaacdec.cmake
+++ b/test/decoder/xaacdec.cmake
@ -15,13 +15,13 @@ if(MSVC)
    xaacdec
    PROPERTIES
      COMPILE_FLAGS
-      "-UARM_PROFILE_HW -UARM_PROFILE_BOARD -DDRC_ENABLE -DMULTICHANNEL_ENABLE -DECLIPSE -DWIN32 -D_CRT_SECURE_NO_WARNINGS"
+      "-UARM_PROFILE_HW -UARM_PROFILE_BOARD -DDRC_ENABLE -DMULTICHANNEL_ENABLE -DECLIPSE -DWIN32 -D_CRT_SECURE_NO_WARNINGS -DLOUDNESS_LEVELING_SUPPORT"
  )
 else()
  set_target_properties(
    xaacdec
    PROPERTIES
      COMPILE_FLAGS
-      "-UARM_PROFILE_HW -UARM_PROFILE_BOARD -DDRC_ENABLE -DMULTICHANNEL_ENABLE -DECLIPSE -DWIN32"
+      "-UARM_PROFILE_HW -UARM_PROFILE_BOARD -DDRC_ENABLE -DMULTICHANNEL_ENABLE -DECLIPSE -DWIN32 -DLOUDNESS_LEVELING_SUPPORT"
  )
 endif()
--- a/test/encoder/impd_drc_config_params.txt
+++ b/test/encoder/impd_drc_config_params.txt
@ -1,3 +1,8 @@
+#In order to support DRC AMD-2(ISO/IEC 23003-4:2020/Amd. 2:2023(E)), `leveling_present` and `ducking_only_set` fields are introduced in DRC config file.
+#For a given DRC effect, when both `leveling_present` and `ducking_only_set` are set to 1, automatically the next drc instruction is treated as ducking only set.
+#For example, if the second DRC effect is marked as 2048/4096 with  `leveling_present` is set to 1 and `ducking_only_set` is set to 1, then the third DRC effect will be treated as ducking-only.
+#For the last drc instruction, `leveling_present` and `ducking_only_set` fields are ignored and reset to 0. Maximum supported instructions are 8.
+
 #####str_drc_instructions_uni_drc#####
 drc_instructions_uni_drc_count:0
 #####str_drc_coefficients_uni_drc#####
@ -28,10 +33,9 @@ attack:2.0
 decay:5.0
 #end gain parameters
 #####str_drc_instructions_uni_drc_v1#####
-drc_instructions_uni_drc_count:8
+drc_instructions_uni_drc_count_v1:3
 #n=0
 downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
 drc_set_effect:0x0001
 gain_set_channels:8
 gain_set_index:0
@ -45,8 +49,7 @@ gain_set_index:0
 num_drc_channel_groups:1
 #n=1
 downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
-drc_set_effect:0x0002
+drc_set_effect:0x800
 gain_set_channels:8
 gain_set_index:0
 gain_set_index:0
@ -57,80 +60,13 @@ gain_set_index:0
 gain_set_index:0
 gain_set_index:0
 num_drc_channel_groups:1
+#leveling present flag
+leveling_present:1
+#if ducking_only_set is one next drc instruction's set effect is set to 0x800 (ducking/leveling self)
+ducking_only_set:1
 #n=2
 downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
-drc_set_effect:0x0004
-gain_set_channels:8
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-num_drc_channel_groups:1
-#n=3
-downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
-drc_set_effect:0x0008
-gain_set_channels:8
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-num_drc_channel_groups:1
-#n=4
-downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
-drc_set_effect:0x0010
-gain_set_channels:8
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-num_drc_channel_groups:1
-#n=5
-downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
-drc_set_effect:0x0020
-gain_set_channels:8
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-num_drc_channel_groups:1
-#n=6
-downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
-drc_set_effect:0x0040
-gain_set_channels:8
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-gain_set_index:0
-num_drc_channel_groups:1
-#n=7
-downmix_id:0
-#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_
-drc_set_effect:0x0080
+drc_set_effect:0x0800
 gain_set_channels:8
 gain_set_index:0
 gain_set_index:0
--- a/test/encoder/impd_drc_user_config.c
+++ b/test/encoder/impd_drc_user_config.c
@ -92,7 +92,10 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en
  pstr_uni_drc_config->sample_rate_present = 1;
  pstr_uni_drc_config->str_drc_coefficients_uni_drc->drc_frame_size_present = 0;
  pstr_uni_drc_config->loudness_info_set_present = 1;
-
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  WORD16 loudness_leveling_extension_present = 0;
+  UWORD32 config_extension_count = 0;
+#endif
  /***********  str_drc_instructions_uni_drc  *************/

  pstr_uni_drc_config->drc_instructions_uni_drc_count = impd_drc_get_integer_value(fp);
@ -145,8 +148,15 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en
    pstr_drc_instructions_uni_drc->drc_instructions_type = 0;
    pstr_drc_instructions_uni_drc->mae_group_id = 0;
    pstr_drc_instructions_uni_drc->mae_group_preset_id = 0;
-  }

+#ifdef LOUDNESS_LEVELING_SUPPORT
+    if (pstr_drc_instructions_uni_drc->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
+      pstr_drc_instructions_uni_drc->leveling_present = impd_drc_get_integer_value(fp);
+      pstr_drc_instructions_uni_drc->ducking_only_set_present = impd_drc_get_integer_value(fp);
+      loudness_leveling_extension_present = 1;
+    }
+#endif  // LOUDNESS_LEVELING_SUPPORT
+  }
  /***********  str_drc_coefficients_uni_drc  *************/

  pstr_uni_drc_config->drc_coefficients_uni_drc_count = impd_drc_get_integer_value(fp);
@ -247,7 +257,13 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en

  pstr_uni_drc_config->uni_drc_config_ext_present = 1;
  if (pstr_uni_drc_config->uni_drc_config_ext_present) {
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[config_extension_count] =
+        UNIDRC_CONF_EXT_V1;
+    config_extension_count++;
+#else
    pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[0] = UNIDRC_CONF_EXT_V1;
+#endif

    pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present = 1;
    if (pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present) {
@ -420,9 +436,25 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en
        pstr_drc_instructions_uni_drc->drc_instructions_type = 0;
        pstr_drc_instructions_uni_drc->mae_group_id = 0;
        pstr_drc_instructions_uni_drc->mae_group_preset_id = 0;
+#ifdef LOUDNESS_LEVELING_SUPPORT
+        if (pstr_drc_instructions_uni_drc->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
+          pstr_drc_instructions_uni_drc->leveling_present = impd_drc_get_integer_value(fp);
+          pstr_drc_instructions_uni_drc->ducking_only_set_present =
+              impd_drc_get_integer_value(fp);
+          loudness_leveling_extension_present = 1;
+        }
+#endif  // LOUDNESS_LEVELING_SUPPORT
      }
    }
  }
+
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  if (loudness_leveling_extension_present) {
+    pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[config_extension_count] =
+        UNIDRCCONFEXT_LEVELING;
+    config_extension_count++;
+  }
+#endif
  pstr_enc_loudness_info_set->loudness_info_set_ext_present = 0;
  pstr_enc_gain_extension->uni_drc_gain_ext_present = 0;
 }
--- a/test/encoder/ixheaace_testbench.c
+++ b/test/encoder/ixheaace_testbench.c
@ -218,6 +218,7 @@ void ia_enhaacplus_enc_print_usage() {
  printf("\n[-aot:<audio_object_type>]");
  printf("\n[-esbr:<esbr_flag>]");
  printf("\n[-full_bandwidth:<enable_full_bandwidth>]");
+  printf("\n[-bandwidth:<bandwidth>]");
  printf("\n[-max_out_buffer_per_ch:<bitreservoir_size>]");
  printf("\n[-tree_cfg:<tree_config>]");
  printf("\n[-usac:<usac_encoding_mode>]");
@ -269,6 +270,7 @@ void ia_enhaacplus_enc_print_usage() {
  printf(
      "\n  <enable_full_bandwidth> Enable use of full bandwidth of input. Valid values are "
      "0(disable full bandwidth) and 1(enable full bandwidth). Default is 0.");
+  printf("\n  <bandwidth> specifies the bandwidth for the input (cutoff). Default is 0.");
  printf("\n  <bitreservoir_size> is the maximum size of bit reservoir to be used.");
  printf(
      "\n        Valid values are from -1 to 6144. -1 will omit use of bit reservoir. Default is "
@ -362,6 +364,11 @@ static VOID ixheaace_parse_config_param(WORD32 argc, pWORD8 argv[], pVOID ptr_en
      char *pb_arg_val = (char *)argv[i] + 16;
      pstr_enc_api->input_config.aac_config.full_bandwidth = atoi(pb_arg_val);
    }
+    /* Bandwidth */
+    if (!strncmp((const char *)argv[i], "-bandwidth:", 11)) {
+      char *pb_arg_val = (char *)argv[i] + 11;
+      pstr_enc_api->input_config.aac_config.bandwidth = atoi(pb_arg_val);
+    }
    /* frame size */
    if (!strncmp((const char *)argv[i], "-framesize:", 11)) {
      char *pb_arg_val = (char *)argv[i] + 11;
@ -577,6 +584,20 @@ static VOID ixheaace_print_drc_config_params(ixheaace_input_config *pstr_input_c
        pstr_uni_drc_config_user->str_drc_instructions_uni_drc[i].limiter_peak_target) {
      flag = 1;
    }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+    if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].drc_set_effect !=
+        pstr_uni_drc_config_user->str_drc_instructions_uni_drc[i].drc_set_effect) {
+      flag = 1;
+    }
+    if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].leveling_present !=
+        pstr_uni_drc_config_user->str_drc_instructions_uni_drc[i].leveling_present) {
+      flag = 1;
+    }
+    if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present !=
+        pstr_uni_drc_config_user->str_drc_instructions_uni_drc[i].ducking_only_set_present) {
+      flag = 1;
+    }
+#endif
  }
  if (flag == 1) {
    printf("\nDRC : Invalid config str_drc_instructions_uni_drc");
@ -653,6 +674,33 @@ static VOID ixheaace_print_drc_config_params(ixheaace_input_config *pstr_input_c
    printf("\nDRC : Invalid config: str_drc_coefficients_uni_drc");
    flag = 0;
  }
+#ifdef LOUDNESS_LEVELING_SUPPORT
+  ia_drc_uni_drc_config_ext_struct *pstr_uni_drc_config_ext =
+      &pstr_uni_drc_config->str_uni_drc_config_ext;
+  ia_drc_uni_drc_config_ext_struct *pstr_uni_drc_config_ext_user =
+      &pstr_uni_drc_config_user->str_uni_drc_config_ext;
+
+  for (i = 0; i < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count; i++) {
+    if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].drc_set_effect !=
+        pstr_uni_drc_config_ext_user->str_drc_instructions_uni_drc_v1[i].drc_set_effect) {
+      flag = 1;
+    }
+    if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].leveling_present !=
+        pstr_uni_drc_config_ext_user->str_drc_instructions_uni_drc_v1[i].leveling_present) {
+      flag = 1;
+    }
+    if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].ducking_only_set_present !=
+        pstr_uni_drc_config_ext_user->str_drc_instructions_uni_drc_v1[i]
+            .ducking_only_set_present) {
+      flag = 1;
+    }
+  }
+
+  if (flag == 1) {
+    printf("\nDRC : Invalid config str_drc_instructions_uni_drc_v1");
+    flag = 0;
+  }
+#endif
  for (i = 0; i < pstr_enc_loudness_info_set->loudness_info_count; i++) {
    if (pstr_enc_loudness_info_set->str_loudness_info[i].sample_peak_level !=
        pstr_enc_loudness_info_set_user->str_loudness_info[i].sample_peak_level) {
--- a/test/encoder/xaacenc.cmake
+++ b/test/encoder/xaacenc.cmake
@ -18,12 +18,12 @@ if (MSVC)
        xaacenc 
        PROPERTIES 
        COMPILE_FLAGS
-        "-D_CRT_SECURE_NO_WARNINGS -D_X86_") 
+        "-D_CRT_SECURE_NO_WARNINGS -D_X86_ -DLOUDNESS_LEVELING_SUPPORT") 
 else()
    set_target_properties(
        xaacenc 
        PROPERTIES 
        COMPILE_FLAGS
-        "-D_X86_ -c -O3 -Wall -Wsequence-point -Wunused-function"
+        "-D_X86_ -c -O3 -Wall -Wsequence-point -Wunused-function -DLOUDNESS_LEVELING_SUPPORT"
        ) 
 endif()
Author	SHA1	Message	Date
wrapper	1e660479c8	fix sbr 2 Some checks failed CMake / build (push) Has been cancelled Details	2025-08-24 13:31:40 +07:00
wrapper	d2211d963d	retweak Some checks are pending CMake / build (push) Waiting to run Details	2025-08-24 09:14:50 +07:00
wrapper	29b7a4eb4c	fix Some checks failed CMake / build (push) Has been cancelled Details	2025-08-22 19:48:17 +07:00
wrapper	e33d5a718e	make dual rate unlikely Some checks are pending CMake / build (push) Waiting to run Details	2025-08-22 19:35:23 +07:00
wrapper	c10720f05d	Revert "add downsampled frequency scaling" This reverts commit `ce9ef54af5`.	2025-08-22 19:34:35 +07:00
wrapper	ce9ef54af5	add downsampled frequency scaling Some checks are pending CMake / build (push) Waiting to run Details	2025-08-22 16:06:28 +07:00
wrapper	1feae4f6e0	again Some checks failed CMake / build (push) Has been cancelled Details	2025-08-15 14:18:49 +07:00
wrapper	90c8770efe	fix aot detect Some checks are pending CMake / build (push) Waiting to run Details	2025-08-15 14:13:18 +07:00
wrapper	f398a98363	correct aot Some checks are pending CMake / build (push) Waiting to run Details	2025-08-15 13:13:14 +07:00
wrapper	ddcb11cbc8	fix mean division by 0 Some checks are pending CMake / build (push) Waiting to run Details	2025-08-14 16:55:43 +07:00
wrapper	b828e89275	fix sbr setting Some checks are pending CMake / build (push) Waiting to run Details	2025-08-14 13:42:29 +07:00
wrapper	06aa3c1ba5	fix stop freq 2 Some checks are pending CMake / build (push) Waiting to run Details	2025-08-14 10:58:44 +07:00
wrapper	68e3e867f8	fix stop freq Some checks are pending CMake / build (push) Waiting to run Details	2025-08-14 09:56:39 +07:00
wrapper	d3d43727c5	fix freq scaling again Some checks failed CMake / build (push) Has been cancelled Details	2025-08-13 07:17:36 +07:00
wrapper	b743f48ca1	going pic Some checks failed CMake / build (push) Has been cancelled Details	2025-08-11 17:27:52 +07:00
wrapper	80a67bda85	fix broken freq scaling Some checks are pending CMake / build (push) Waiting to run Details	2025-08-11 13:20:11 +07:00
wrapper	aadabc426a	new eld bitrates Some checks are pending CMake / build (push) Waiting to run Details	2025-08-10 11:46:26 +07:00
wrapper	938e3892fb	tns too Some checks are pending CMake / build (push) Waiting to run Details	2025-08-10 10:20:00 +07:00
wrapper	b21dc24ee5	size again Some checks are pending CMake / build (push) Waiting to run Details	2025-08-10 10:18:01 +07:00
wrapper	65ed01a2f4	update encode Some checks are pending CMake / build (push) Waiting to run Details	2025-08-10 10:15:44 +07:00
wrapper	3d995a0119	new encode tables Some checks are pending CMake / build (push) Waiting to run Details	2025-08-10 10:09:01 +07:00
wrapper	56a15e2211	disable sample rate limit Some checks are pending CMake / build (push) Waiting to run Details	2025-08-09 23:06:33 +07:00
wrapper	07e7c9dde8	floating Some checks failed CMake / build (push) Has been cancelled Details	2025-08-06 19:24:37 +07:00
wrapper	17b657d7c3	32-bit floating point samples, adjustable bandwidth Some checks failed CMake / build (push) Has been cancelled Details	2025-08-04 20:52:12 +07:00
wrapper	433d6c3eb6	fix ASC, fix full bandwidth for non USAC	2025-08-04 20:50:17 +07:00
ShashankPathmudi	1f798f1cc5	Fix for UBSAN issue observed with libxaac decoder (#98 ) * Fix for UBSAN issue observed with libxaac decoder Significance: - This change propogates the error returned from ixheaacd_heaac_mps_apply to ixheaacd_dec_execute. Testing: - All previous fuzzer crashes are tested. No crash observed. - CTS and Conformance for x86, x86_64, armv7 and armv8 are passing. * Fix for UBSAN issue observed with libxaac Decoder Significance: - Comparison is made against IA_NO_ERROR using 'not equal to', instead of checking for equality with IA_FATAL_ERROR Testing: - All previous fuzzer crashes are tested. No crash observed. - CTS and Conformance for x86, x86_64, armv7 and armv8 are passing.	2025-07-30 12:13:09 +05:30
akshayragir833	3dfa708b6e	Loudness leveling support for encoder and decoder (#99 ) * Loudness leveling support for encoder and decoder - Addition of loudness leveling support to encoder and decoder as per ISO/IEC 23003-4:2020/Amd.2:2023(E) Testing: Encoder: Smoke-test Decoder: CTS and Conformance for x86, x86_64, armv7 and armv8 are passing * Addressed review comments * Addressed minor nits in documentation --------- Co-authored-by: Akshay Ragir <100833@ittiam.com>	2025-07-28 17:40:45 +05:30