fix sbr 2

This reverts commit ce9ef54af5.

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: [

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)

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

cmake/utils.cmake

@@ -51,6 +51,7 @@ function(libxaac_add_definitions)
     add_definitions(-DX86_64 -D_X86_64_)
   endif()
   add_definitions(-DLOUDNESS_LEVELING_SUPPORT)
+  add_definitions(-DAAC_NEW_TABLES)
 endfunction()
 
 # Adds libraries needed for executables

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 <= 0 || *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;

decoder/ixheaacd_api.c

@@ -579,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);
           }
@@ -940,6 +940,7 @@ 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;
         }
@@ -2530,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));
 
@@ -3676,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 =

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++) {

decoder/ixheaacd_struct_def.h

@@ -162,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;

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) {

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)
 

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;
 }
 

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 {

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);
         }
       }
     }

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,

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,

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,

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];

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],

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;

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;

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  */

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;

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) {

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*/
 

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;

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,

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)) {

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 */

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
   }
 }
 

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: [

test/decoder/ixheaacd_main.c

@@ -33,16 +33,6 @@
 #include "ixheaacd_metadata_read.h"
 #include "impd_drc_config_params.h"
 
-#ifdef SUPPORT_MP4
-#include "ISOMovies.h"
-#define _IA_HANDLE_ERROR_MP4(a)                               \
-if (a)                                                        \
-{                                                             \
-  printf("ISOBMFF parser library error. Error No: %d\n", a);  \
-  exit(1);                                                    \
-}
-#endif
-
 IA_ERRORCODE ixheaacd_dec_api(pVOID p_ia_module_obj, WORD32 i_cmd, WORD32 i_idx,
                               pVOID pv_value);
 
@@ -110,23 +100,13 @@ FileWrapperPtr g_pf_inp; /* file pointer to bitstream file (mp4) */
 
 WORD32 mpeg_d_drc_on = 0;
 
-#ifndef SUPPORT_MP4
 metadata_info meta_info;  // metadata pointer;
 WORD32 ixheaacd_i_bytes_to_read;
+WORD32 prev_i_bytes_to_read;
+WORD32 flush_frame = 0;
 FILE *g_pf_meta;
 
 WORD32 raw_testing = 0;
-#else
-WORD32 mp4_flag = 0;
-WORD32 ixheaacd_i_bytes_to_read;
-ISOMedia media;
-ISOTrack trak;
-ISOTrackReader reader;
-ISOHandle sample_hdl;
-ISOHandle decoder_cfg_hdl;
-#endif
-WORD32 prev_i_bytes_to_read;
-WORD32 flush_frame = 0;
 WORD32 eld_testing = 0;
 WORD32 ec_enable = 0;
 WORD32 esbr_testing = 1;
@@ -407,7 +387,6 @@ IA_ERRORCODE ixheaacd_set_config_param(WORD32 argc, pWORD8 argv[],
   ia_error_info_struct *p_proc_err_info = &ixheaacd_error_info;
 
   for (i = 0; i < argc; i++) {
-#ifndef SUPPORT_MP4
     /* To indicate if its a MP4 file or not. */
     if (!strncmp((pCHAR8)argv[i], "-mp4:", 5)) {
       pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 5);
@@ -417,7 +396,6 @@ IA_ERRORCODE ixheaacd_set_config_param(WORD32 argc, pWORD8 argv[],
           IA_XHEAAC_DEC_CONFIG_PARAM_MP4FLAG, &ui_mp4_flag);
       _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
     }
-#endif
     /* PCM WORD Size (For single input file) */
     if (!strncmp((pCHAR8)argv[i], "-pcmsz:", 7)) {
       pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 7);
@@ -701,15 +679,6 @@ IA_ERRORCODE ixheaacd_set_config_param(WORD32 argc, pWORD8 argv[],
     }
 #endif
   }
-#ifdef SUPPORT_MP4
-  {
-    UWORD32 ui_mp4_flag = mp4_flag;
-    err_code = (*p_ia_process_api)(
-        p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
-        IA_ENHAACPLUS_DEC_CONFIG_PARAM_ISMP4, &ui_mp4_flag);
-    _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-  }
-#endif
 
   return IA_NO_ERROR;
 }
@@ -914,11 +883,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
   WORD32 prev_sampling_rate = 0;
   WORD32 skip_samples = 0;
   WORD32 total_samples = 0;
-#ifdef SUPPORT_MP4
-  s64 segment_duration = 0;
-  s64 start_offset_duration = 0;
-  u32 entryIndex = 1;
-#endif
   WORD32 write_flag = 1;
   WORD32 bytes_to_write = 0;
   WORD32 ixheaacd_drc_offset = 0;
@@ -969,10 +933,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
   /* The process error info structure */
   ia_error_info_struct *p_proc_err_info;
 
-#ifdef SUPPORT_MP4
-  ISOErr err = ISONoErr;
-#endif
-
   /* Process struct initing */
   p_ia_process_api = ixheaacd_dec_api;
   p_set_config_param = ixheaacd_set_config_param;
@@ -1250,7 +1210,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
   do {
     i_bytes_read = 0;
 
-#ifndef SUPPORT_MP4
     if ((ui_inp_size - (i_buff_size - i_bytes_consumed)) > 0) {
       for (i = 0; i < (i_buff_size - i_bytes_consumed); i++) {
         pb_inp_buf[i] = pb_inp_buf[i + i_bytes_consumed];
@@ -1313,72 +1272,8 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
 #endif
       return 1;
     }
-#else
-    if (!mp4_flag)
-    {
-      if ((ui_inp_size - (i_buff_size - i_bytes_consumed)) > 0) {
-        for (i = 0; i < (i_buff_size - i_bytes_consumed); i++) {
-          pb_inp_buf[i] = pb_inp_buf[i + i_bytes_consumed];
-        }
 
-        FileWrapper_Read(g_pf_inp, (unsigned char *)(pb_inp_buf + i_buff_size -
-                                                     i_bytes_consumed),
-                         (ui_inp_size - (i_buff_size - i_bytes_consumed)),
-                         (pUWORD32)&i_bytes_read);
-
-        i_buff_size = i_buff_size - (i_bytes_consumed - i_bytes_read);
-
-        /* Tell input is over, if algorithm returns with insufficient input and
-           there is no
-               more input left in the bitstream*/
-        if ((i_buff_size <= 0) ||
-            ((err_code_reinit == 0x00001804) && i_bytes_read == 0))
-        {
-          i_buff_size = 0;
-          /* Tell that the input is over in this buffer */
-          err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                         IA_API_CMD_INPUT_OVER, 0, NULL);
-          _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-        }
-      }
-
-      if ((i_buff_size <= 0) ||
-          ((err_code_reinit == 0x00001804) && i_bytes_read == 0)) {
-        i_buff_size = 0;
-        /* Tell that the input is over in this buffer */
-        err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                       IA_API_CMD_INPUT_OVER, 0, NULL);
-        _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-#ifdef WAV_HEADER
-#ifndef ARM_PROFILE_BOARD
-        /* ******************************************************************/
-        /* Get config params from API                                       */
-        /* ******************************************************************/
-
-        err_code =
-            (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq,
-                                &i_num_chan, &i_pcm_wd_sz, &i_channel_mask,
-                                &i_sbr_mode, &ui_aot);
-        _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-
-        // This is done in those cases, where file decodes ends at init time
-        // Since init is incomplete, sampling freq might be zero and will result
-        // in
-        // writing invalid wave header
-
-        if (i_samp_freq == 0) i_samp_freq = prev_sampling_rate;
-
-        if (!fseek(g_pf_out, 0, SEEK_SET))
-          write_wav_header(g_pf_out, i_total_bytes, i_samp_freq, i_num_chan,
-                           i_pcm_wd_sz, i_channel_mask);
-#endif
-#endif
-        return 1;
-      }
-    }
-#endif
     if (init_iteration == 1) {
-#ifndef SUPPORT_MP4
       if (raw_testing)
         ixheaacd_i_bytes_to_read = get_metadata_dec_info_init(meta_info);
       else
@@ -1389,52 +1284,8 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
           (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES,
                               0, &ixheaacd_i_bytes_to_read);
       init_iteration++;
-#else
-      if (!mp4_flag)
-      {
-        ixheaacd_i_bytes_to_read = i_buff_size;
-        /* Set number of bytes to be processed */
-        err_code =
-            (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES,
-                                0, &ixheaacd_i_bytes_to_read);
-      }
-      else
-      {
-        u32 samp_desc_idx = 1, obj_type = 0, output_size;
-        u32 avg_br = 0, max_br = 0, strm_type = 0, strm_up = 0;
-        err = MP4GetMediaDecoderInformation(media,
-            samp_desc_idx,
-            &obj_type,
-            &strm_type,
-            &output_size,
-            &strm_up,
-            &max_br,
-            &avg_br,
-            decoder_cfg_hdl);
-        _IA_HANDLE_ERROR_MP4(err);
-        err = MP4GetHandleSize(decoder_cfg_hdl, &ixheaacd_i_bytes_to_read);
-        _IA_HANDLE_ERROR_MP4(err);
-        if (ixheaacd_i_bytes_to_read > (WORD32)ui_inp_size)
-          return IA_FATAL_ERROR;
-        /* Set number of bytes to be processed */
-        err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                       IA_API_CMD_SET_INPUT_BYTES, 0,
-                                       &ixheaacd_i_bytes_to_read);
-        memcpy(pb_inp_buf, *decoder_cfg_hdl, ixheaacd_i_bytes_to_read);
 
-        if (ixheaacd_i_bytes_to_read <= 0) {
-          err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                         IA_API_CMD_INPUT_OVER, 0, NULL);
-
-          _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-
-          return IA_NO_ERROR;
-        }
-      }
-      init_iteration++;
-#endif
     } else {
-#ifndef SUPPORT_MP4
       if (raw_testing) {
         ixheaacd_i_bytes_to_read =
             get_metadata_dec_exec(meta_info, frame_counter);
@@ -1461,44 +1312,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
         err_code = (*p_ia_process_api)(
             pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0, &i_buff_size);
       }
-#else
-      if (mp4_flag) {
-        u32 unit_size;
-        s32 cts;
-        s32 dts;
-        u32 sample_flags;
-        err = MP4TrackReaderGetNextAccessUnit(
-              reader, sample_hdl, &unit_size, &sample_flags, &cts, &dts);
-        if (err)
-        {
-          if (err == ISOEOF) err = ISONoErr;
-            break;
-        }
-        ixheaacd_i_bytes_to_read = unit_size;
-        i_bytes_read = ixheaacd_i_bytes_to_read;
-        if (ixheaacd_i_bytes_to_read > (WORD32)ui_inp_size)
-          return IA_FATAL_ERROR;
-
-        if (ixheaacd_i_bytes_to_read <= 0) {
-          err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                         IA_API_CMD_INPUT_OVER, 0, NULL);
-
-          _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-          return IA_NO_ERROR;
-        }
-
-        /* Set number of bytes to be processed */
-        err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                       IA_API_CMD_SET_INPUT_BYTES, 0,
-                                       &ixheaacd_i_bytes_to_read);
-        memcpy(pb_inp_buf, *((char **)sample_hdl), ixheaacd_i_bytes_to_read);
-        init_iteration++;
-      } else {
-        /* Set number of bytes to be processed */
-        err_code = (*p_ia_process_api)(
-            pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0, &i_buff_size);
-      }
-#endif
     }
 
     _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
@@ -1862,7 +1675,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
   if (ui_aot == 42)
     esbr_testing = 1;
 
-#ifndef SUPPORT_MP4
   if (raw_testing) {
     skip_samples = get_start_offset_in_samples(meta_info);
     if (ui_aot >= 23 && esbr_testing) {
@@ -1873,21 +1685,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
     }
     if (eld_testing == 0) total_samples = get_play_time_in_samples(meta_info);
   }
-#else
-  if (mp4_flag) {
-    u32 entry_count = 1;
-    err = ISOGetTrackEditlistEntryCount(trak, &entry_count);
-    if (err == MP4NoErr)
-    {
-      err = ISOGetTrackEditlist(trak, &segment_duration, &start_offset_duration, 1);
-      if (err == MP4NoErr)
-      {
-        skip_samples = (WORD32)start_offset_duration;
-        if (eld_testing == 0) total_samples = (WORD32)segment_duration;
-      }
-    }
-  }
-#endif
 
 /* End second part */
 
@@ -1904,67 +1701,26 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
 #endif
   prev_sampling_rate = i_samp_freq;
 
-#if SUPPORT_MP4
-  UWORD32 number_of_frames = 0;
-  err = ISOGetMediaSampleCount(media, &number_of_frames);
-  if (err) return err;
-#else
-  UWORD32 number_of_frames = meta_info.ia_mp4_stsz_entries;
-#endif
-
   do {
     if (((WORD32)ui_inp_size - (WORD32)(i_buff_size - i_bytes_consumed)) > 0) {
       if (i_sbr_mode && (ui_aot < 23) && esbr_testing) {
-        if (number_of_frames != frame_counter) {
+        if (meta_info.ia_mp4_stsz_entries != frame_counter) {
           for (i = 0; i < (i_buff_size - i_bytes_consumed); i++) {
             pb_inp_buf[i] = pb_inp_buf[i + i_bytes_consumed];
           }
-#ifndef SUPPORT_MP4
+
           FileWrapper_Read(
               g_pf_inp,
               (unsigned char *)(pb_inp_buf + i_buff_size - i_bytes_consumed),
               ((WORD32)ui_inp_size - (WORD32)(i_buff_size - i_bytes_consumed)),
               (pUWORD32)&i_bytes_read);
-#else
-          if (!mp4_flag)
-          {
-            FileWrapper_Read(
-                g_pf_inp,
-                (unsigned char *)(pb_inp_buf + i_buff_size - i_bytes_consumed),
-                ((WORD32)ui_inp_size - (WORD32)(i_buff_size - i_bytes_consumed)),
-                (pUWORD32)&i_bytes_read);
-          }
-          else
-          {
-            if (i_bytes_consumed)
-            {
-              u32 unit_size;
-              s32 cts;
-              s32 dts;
-              u32 sample_flags;
-              err = MP4TrackReaderGetNextAccessUnit(
-                  reader, sample_hdl, &unit_size, &sample_flags, &cts, &dts);
-              if (err)
-              {
-                if (err == ISOEOF) err = ISONoErr;
-                break;
-              }
-              i_bytes_read = unit_size;
-              memcpy(pb_inp_buf, *((char **)sample_hdl), i_bytes_read);
-            }
-          }
-#endif
-		  
+
           i_buff_size = i_buff_size - (i_bytes_consumed - i_bytes_read);
 
           if ((i_buff_size <= 0) ||
               ((err_code_reinit == 0x00001804) && i_bytes_read == 0)) {
             i_buff_size = 0;
-#ifndef SUPPORT_MP4
             raw_testing = 0;
-#else
-            mp4_flag = 0;
-#endif
             /* Tell that the input is over in this buffer */
             err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
                                            IA_API_CMD_INPUT_OVER, 0, NULL);
@@ -1976,49 +1732,19 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
         for (i = 0; i < (i_buff_size - i_bytes_consumed); i++) {
           pb_inp_buf[i] = pb_inp_buf[i + i_bytes_consumed];
         }
-#ifndef SUPPORT_MP4
+
         FileWrapper_Read(g_pf_inp, (unsigned char *)(pb_inp_buf + i_buff_size -
             i_bytes_consumed),
             ((WORD32)ui_inp_size - (WORD32)(i_buff_size - i_bytes_consumed)),
             (pUWORD32)&i_bytes_read);
-#else
-        if (!mp4_flag)
-        {
-          FileWrapper_Read(g_pf_inp,
-                (unsigned char *)(pb_inp_buf + i_buff_size - i_bytes_consumed),
-                ((WORD32)ui_inp_size - (WORD32)(i_buff_size - i_bytes_consumed)),
-                (pUWORD32)&i_bytes_read);
-        }
-        else
-        {
-          if (i_bytes_consumed)
-          {
-            u32 unit_size;
-            s32 cts;
-            s32 dts;
-            u32 sample_flags;
-            err = MP4TrackReaderGetNextAccessUnit(
-                  reader, sample_hdl, &unit_size, &sample_flags, &cts, &dts);
-            if (err)
-            {
-              if (err == ISOEOF) err = ISONoErr;
-                break;
-            }
-            i_bytes_read = unit_size;
-            memcpy(pb_inp_buf, *((char **)sample_hdl), i_bytes_read);
-          }
-        }
-#endif
+
         i_buff_size = i_buff_size - (i_bytes_consumed - i_bytes_read);
 
         if ((i_buff_size <= 0) ||
             ((err_code_reinit == 0x00001804) && i_bytes_read == 0)) {
           i_buff_size = 0;
-#ifndef SUPPORT_MP4
           raw_testing = 0;
-#else
-          mp4_flag = 0;
-#endif
+
           err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
               IA_API_CMD_INPUT_OVER, 0, NULL);
 
@@ -2027,8 +1753,7 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
       }
     }
     if (i_sbr_mode && (ui_aot < 23) && esbr_testing) {
-      if (number_of_frames != frame_counter) {
-#ifndef SUPPORT_MP4
+      if (meta_info.ia_mp4_stsz_entries != frame_counter) {
         if (raw_testing) {
           ixheaacd_i_bytes_to_read =
               get_metadata_dec_exec(meta_info, frame_counter);
@@ -2047,31 +1772,11 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
               (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES,
                   0, &ixheaacd_i_bytes_to_read);
         } else {
-#else
-        if (mp4_flag) {
-          ixheaacd_i_bytes_to_read = i_bytes_read;
-
-          if (ixheaacd_i_bytes_to_read > (WORD32)ui_inp_size)
-            return IA_FATAL_ERROR;
-          if (ixheaacd_i_bytes_to_read <= 0 && ec_enable == 0) {
-            err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                           IA_API_CMD_INPUT_OVER, 0, NULL);
-
-            _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-
-            return IA_NO_ERROR;
-          }
-          err_code =
-              (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES,
-                  0, &ixheaacd_i_bytes_to_read);
-        } else {
-#endif
           err_code = (*p_ia_process_api)(
               pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0, &i_buff_size);
         }
       }
     } else {
-#ifndef SUPPORT_MP4
     if (raw_testing) {
       ixheaacd_i_bytes_to_read =
           get_metadata_dec_exec(meta_info, frame_counter);
@@ -2102,37 +1807,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
                                          &ixheaacd_i_bytes_to_read);
         }
     } else {
-#else
-    if (mp4_flag) {
-      ixheaacd_i_bytes_to_read = i_bytes_read;
-
-      if (ixheaacd_i_bytes_to_read > (WORD32)ui_inp_size) return IA_FATAL_ERROR;
-
-      if (ixheaacd_i_bytes_to_read <= 0) {
-        err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
-                                       IA_API_CMD_INPUT_OVER, 0, NULL);
-
-        _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
-
-        return IA_NO_ERROR;
-      }
-
-      if (ec_enable == 1) {
-        if (ixheaacd_i_bytes_to_read != 0) {
-          err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0,
-                                         &ixheaacd_i_bytes_to_read);
-        } else {
-          if (i_buff_size != 0) {
-            err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0,
-                                           &i_buff_size);
-          }
-        }
-      } else {
-          err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0,
-                                         &ixheaacd_i_bytes_to_read);
-      }
-    } else {
-#endif
       /* Set number of bytes to be processed */
       err_code = (*p_ia_process_api)(
           pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0, &i_buff_size);
@@ -2419,13 +2093,7 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
 
     if (total_samples != 0)  // Usac stream
     {
-#ifndef SUPPORT_MP4
       if (raw_testing) {
-#else
-      if (mp4_flag) {
-        WORD32 frame_size = i_out_bytes / (i_num_chan * (i_pcm_wd_sz >> 3));
-        skip_samples = skip_samples % frame_size;
-#endif
         if (i_total_bytes <= skip_samples * i_num_chan * (i_pcm_wd_sz >> 3)) {
           err_code =
               (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq,
@@ -2449,7 +2117,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
         }
       }
 
-#ifndef SUPPORT_MP4
       if (raw_testing) {
         samples_written += current_samples;
 
@@ -2459,17 +2126,6 @@ int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
           if (i_out_bytes < 0) i_out_bytes = 0;
         }
       }
-#else
-      if (mp4_flag) {
-        samples_written += current_samples;
-
-        if (samples_written > total_samples) {
-          i_out_bytes = (total_samples - (samples_written - current_samples)) *
-                        (i_num_chan * (i_pcm_wd_sz >> 3));
-          if (i_out_bytes < 0) i_out_bytes = 0;
-        }
-      }
-#endif
     }
 
     if (write_flag) {
@@ -2671,7 +2327,7 @@ void print_usage() {
   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  <loudness_leveling_flag> is to enable / disable loudness leveling.");
   printf("\n    Default value is 1");
 #endif
 }
@@ -2706,17 +2362,10 @@ void print_usage() {
 int main(WORD32 argc, char *argv[]) {
   WORD32 i, err_code = IA_NO_ERROR;
 
-#ifdef SUPPORT_MP4
-  ISOErr err;
-  u32 handler_type;
-  ISOMovie moov;
-#endif
   ia_testbench_error_handler_init();
 
   g_pf_inp = NULL;
-#ifndef SUPPORT_MP4
   g_pf_meta = NULL;
-#endif
   g_pf_out = NULL;
 
   for (i = 1; i < argc; i++) {
@@ -2724,7 +2373,7 @@ int main(WORD32 argc, char *argv[]) {
 
     if (!strncmp((const char *)argv[i], "-ifile:", 7)) {
       pWORD8 pb_arg_val = (pWORD8)argv[i] + 7;
-#ifndef SUPPORT_MP4
+
       g_pf_inp = FileWrapper_Open((char *)pb_arg_val);
       if (g_pf_inp == NULL) {
         err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
@@ -2733,43 +2382,8 @@ int main(WORD32 argc, char *argv[]) {
         exit(1);
       }
       raw_testing = 0;
-#else
-      err = ISOOpenMovieFile(&moov, (char *)pb_arg_val,
-            MP4OpenMovieNormal);
-      if (err != MP4NoErr)
-      {
-        mp4_flag = 0;
-        g_pf_inp = FileWrapper_Open((char *)pb_arg_val);
-        if (g_pf_inp == NULL) {
-          err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
-          ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
-                                 (pWORD8) "Input File", err_code);
-          exit(1);
-        }
-      }
-      else
-      {
-        u32 tot_num_tracks = 0;
-        mp4_flag = 1;
-        err = ISOGetMovieTrackCount(moov, &tot_num_tracks);
-        _IA_HANDLE_ERROR_MP4(err);
-        err = ISOGetMovieIndTrack(moov, tot_num_tracks, &trak);
-        _IA_HANDLE_ERROR_MP4(err);
-        err = ISOGetTrackMedia(trak, &media);
-        _IA_HANDLE_ERROR_MP4(err);
-        err = ISOGetMediaHandlerDescription(
-              media, &handler_type, NULL);
-        _IA_HANDLE_ERROR_MP4(err);
-        err = ISONewHandle(0, &decoder_cfg_hdl);
-        _IA_HANDLE_ERROR_MP4(err);
-        err = ISONewHandle(0, &sample_hdl);
-        _IA_HANDLE_ERROR_MP4(err);
-        err = ISOCreateTrackReader(trak, &reader);
-        _IA_HANDLE_ERROR_MP4(err);
-      }
-#endif
     }
-#ifndef SUPPORT_MP4
+
     if (!strncmp((const char *)argv[i], "-imeta:", 7)) {
       pWORD8 pb_arg_val = (pWORD8)argv[i] + 7;
 
@@ -2789,7 +2403,6 @@ int main(WORD32 argc, char *argv[]) {
       }
       raw_testing = 1;
     }
-#endif
 
     if (!strncmp((const char *)argv[i], "-ofile:", 7)) {
       pWORD8 pb_arg_val = (pWORD8)argv[i] + 7;
@@ -2804,7 +2417,6 @@ int main(WORD32 argc, char *argv[]) {
     }
   }
 
-#ifndef SUPPORT_MP4
   if ((g_pf_inp == NULL) || (g_pf_out == NULL)) {
     print_usage();
     err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
@@ -2812,33 +2424,11 @@ int main(WORD32 argc, char *argv[]) {
                            (pWORD8) "Input or Output File", err_code);
     exit(1);
   }
-#else
-  if (!mp4_flag)
-  {
-    if ((g_pf_inp == NULL) || (g_pf_out == NULL)) {
-      print_usage();
-      err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
-      ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
-                             (pWORD8) "Input or Output File", err_code);
-      exit(1);
-    }
-  }
-  else
-  {
-    if (g_pf_out == NULL) {
-      print_usage();
-      err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
-      ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
-                             (pWORD8) "Output File", err_code);
-      exit(1);
-    }
-  }
-#endif
 
   g_w_malloc_count = 0;
 
   printf("\n");
-#ifndef SUPPORT_MP4
+
   for (i = 0; i < argc; i++) {
     if (!strcmp((pCHAR8)argv[i], "-mp4:1")) {
       if (g_pf_meta == NULL) {
@@ -2850,7 +2440,7 @@ int main(WORD32 argc, char *argv[]) {
       }
     }
   }
-#endif
+
   for (i = 0; i < argc; i++) {
     if (strcmp((pCHAR8)argv[i], "-eld_testing:1"))
       eld_testing = 0;
@@ -2866,29 +2456,12 @@ int main(WORD32 argc, char *argv[]) {
     if (g_pv_arr_alloc_memory[i]) free(g_pv_arr_alloc_memory[i]);
   }
   if (g_pf_out) fclose(g_pf_out);
-#ifndef SUPPORT_MP4
+
   if (g_pf_meta) {
     fclose(g_pf_meta);
     metadata_mp4_stsz_size_free(&meta_info);
   }
   FileWrapper_Close(g_pf_inp);
-#else
-  if (!mp4_flag)
-  {
-    FileWrapper_Close(g_pf_inp);
-  }
-  else
-  {
-    err = ISODisposeHandle(sample_hdl);
-    _IA_HANDLE_ERROR_MP4(err);
-    err = ISODisposeHandle(decoder_cfg_hdl);
-    _IA_HANDLE_ERROR_MP4(err);
-    err = ISODisposeTrackReader(reader);
-    _IA_HANDLE_ERROR_MP4(err);
-    err = ISODisposeMovie(moov);
-    _IA_HANDLE_ERROR_MP4(err);
-  }
-#endif
   mpeg_d_drc_on = 0;
 
   return IA_NO_ERROR;

test/decoder/xaacdec.cmake

@@ -1,70 +1,27 @@
-list(APPEND XAACDEC_SRCS
-  "${XAAC_ROOT}/test/decoder/ixheaacd_error.c"
-  "${XAAC_ROOT}/test/decoder/ixheaacd_fileifc.c"
-  "${XAAC_ROOT}/test/decoder/ixheaacd_main.c"
-  "${XAAC_ROOT}/test/decoder/ixheaacd_metadata_read.c"
-)
+list(APPEND XAACDEC_SRCS "${XAAC_ROOT}/test/decoder/ixheaacd_error.c"
+     "${XAAC_ROOT}/test/decoder/ixheaacd_fileifc.c" "${XAAC_ROOT}/test/decoder/ixheaacd_main.c"
+     "${XAAC_ROOT}/test/decoder/ixheaacd_metadata_read.c")
 
-set(LIBXAACDEC_INCLUDES
-  ${XAAC_ROOT}/decoder
-  ${XAAC_ROOT}/test/decoder/
-  ${XAAC_ROOT}/decoder/drc_src
-)
+set(LIBXAACDEC_INCLUDES ${XAAC_ROOT}/decoder ${XAAC_ROOT}/test/decoder/
+                        ${XAAC_ROOT}/decoder/drc_src)
 
-if(SUPPORT_MP4)
-  set(LIBISOMEDIA_INCLUDES "${XAAC_ROOT}/../isobmff/IsoLib/libisomediafile/src")
+include_directories(${LIBXAACDEC_INCLUDES})
 
-  # Platform-specific includes
-  if(MSVC)
-    set(LIBISOOSW32_INCLUDES "${XAAC_ROOT}/../isobmff/IsoLib/libisomediafile/w32")
-    include_directories(${LIBXAACDEC_INCLUDES} ${LIBISOMEDIA_INCLUDES} ${LIBISOOSW32_INCLUDES})
-  else()
-    set(LIBISOMEDIA_PLATFORM_INCLUDES ${XAAC_ROOT}/../isobmff/IsoLib/libisomediafile/linux)
-    include_directories(${LIBXAACDEC_INCLUDES} ${LIBISOMEDIA_INCLUDES} ${LIBISOMEDIA_PLATFORM_INCLUDES})
-  endif()
-else()
-  include_directories(${LIBXAACDEC_INCLUDES})
-endif()
+libxaac_add_executable(xaacdec libxaacdec SOURCES ${XAACDEC_SRCS} INCLUDES
+                       ${LIBXAACDEC_INCLUDES})
 
-# Add xaacdec executable
-libxaac_add_executable(xaacdec libxaacdec SOURCES ${XAACDEC_SRCS} INCLUDES ${LIBXAACDEC_INCLUDES})
-
-# Platform-specific linking of MP4 library
-if(SUPPORT_MP4)
-  if(MSVC)
-    # Use Visual Studio project on Windows
-    include_external_msproject(libisomediafile
-        ${XAAC_ROOT}/../isobmff/build/IsoLib/libisomediafile/libisomediafile.vcxproj)
-
-    add_dependencies(xaacdec libisomediafile)
-
-  else()
-    # Linux: link prebuilt static .a library
-    set(LIBISOMEDIA_LIB_PATH "${XAAC_ROOT}/../isobmff/lib/liblibisomediafile.a")
-    target_link_libraries(xaacdec ${LIBISOMEDIA_LIB_PATH})
-  endif()
-endif()
-
-# Common compile flags
-set(COMMON_FLAGS "-UARM_PROFILE_HW -UARM_PROFILE_BOARD -DDRC_ENABLE -DMULTICHANNEL_ENABLE -DECLIPSE -DWIN32 -DLOUDNESS_LEVELING_SUPPORT")
-
-if(SUPPORT_MP4)
-  set(MP4_FLAG "-DSUPPORT_MP4")
-endif()
-
-# Apply compile flags per platform
 if(MSVC)
   set_target_properties(
     xaacdec
     PROPERTIES
       COMPILE_FLAGS
-      "${COMMON_FLAGS} -D_CRT_SECURE_NO_WARNINGS ${MP4_FLAG}"
+      "-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
-      "${COMMON_FLAGS} ${MP4_FLAG}"
+      "-UARM_PROFILE_HW -UARM_PROFILE_BOARD -DDRC_ENABLE -DMULTICHANNEL_ENABLE -DECLIPSE -DWIN32 -DLOUDNESS_LEVELING_SUPPORT"
   )
 endif()

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

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;
 }

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) {

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()