diff --git a/Android.bp b/Android.bp index 58d76bb..99f361d 100644 --- a/Android.bp +++ b/Android.bp @@ -28,6 +28,7 @@ cc_library_static { host_supported: true, cflags: [ "-O3", + "-DLOUDNESS_LEVELING_SUPPORT", ], export_include_dirs: [ @@ -354,6 +355,7 @@ cc_library_static { host_supported: true, cflags: [ "-O3", + "-DLOUDNESS_LEVELING_SUPPORT", ], export_include_dirs: [ diff --git a/CMakeLists.txt b/CMakeLists.txt index 82539b7..4996c67 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -27,3 +27,5 @@ include("${XAAC_ROOT}/encoder/libxaacenc.cmake") include("${XAAC_ROOT}/test/encoder/xaacenc.cmake") include("${XAAC_ROOT}/fuzzer/xaac_enc_fuzzer.cmake") +set_property(TARGET libxaacenc PROPERTY POSITION_INDEPENDENT_CODE 1) +set_property(TARGET libxaacdec PROPERTY POSITION_INDEPENDENT_CODE 1) diff --git a/README_dec.md b/README_dec.md index 02d57dd..ae7edff 100644 --- a/README_dec.md +++ b/README_dec.md @@ -39,8 +39,8 @@ A single API is used to get and set configurations and execute the decode thread |IA_API_CMD_SET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_PEAK_LIMITER | Sets the flag to disable/enable peak limiter | |IA_API_CMD_SET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_FRAMELENGTH_FLAG | Sets to flag to indicate whether decoder should decode for frame length 960 or 1024 | |IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_DRC_TARGET_LEVEL | Sets the value of DRC target level | -|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_ERROR_CONCEALMENT | Sets to flag to disable/enable error concealment | -|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_ESBR | Sets to flag to disable/enable eSBR | +|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_ERROR_CONCEALMENT | Sets the flag to disable/enable error concealment | +|IA_API_CMD_SET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_ESBR | Sets the flag to disable/enable eSBR | |IA_API_CMD_GET_N_MEMTABS | 0 | Gets the number of memory types | |IA_API_CMD_GET_N_TABLES | 0 | Gets the number of tables | |IA_API_CMD_GET_MEM_INFO_SIZE | 0 | Gets the size of the memory type being referred to by the index | @@ -66,6 +66,7 @@ A single API is used to get and set configurations and execute the decode thread |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LOUDNESS | Gets the value of DRC target loudness | |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_LOUD_NORM | Gets the value of DRC loudness normalization level | |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_PARAM_AOT | Gets the value of audio object type | +|IA_API_CMD_GET_CONFIG_PARAM | IA_XHEAAC_DEC_CONFIG_PARAM_DRC_LOUDNESS_LEVELING | Gets the value of loudness leveling flag | |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_PTR | Gets the extension element pointer | |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_BUF_SIZES | Gets the extension element buffer sizes | |IA_API_CMD_GET_CONFIG_PARAM | IA_ENHAACPLUS_DEC_CONFIG_NUM_ELE | Gets the number of configuration elements | @@ -132,7 +133,7 @@ A single API is used to get and set configurations and execute the decode thread |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS | Sets the number of channels in the input stream/data | |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_PCM_WDSZ | Sets the PCM word size of the input data | |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT | Sets the bit stream format | -|IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_INT_PRESENT | Sets the DRC decoder’s interface present flag to 1 or 0 | +|IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_INT_PRESENT | Sets the DRC decoders interface present flag to 1 or 0 | |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_PARAM_FRAME_SIZE | Sets the frame size | |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_DRC_EFFECT_TYPE | Sets the value of DRC effect type | |IA_API_CMD_SET_CONFIG_PARAM | IA_DRC_DEC_CONFIG_DRC_TARGET_LOUDNESS | Sets the value of DRC target loudness | @@ -191,6 +192,7 @@ Command line usage : [-peak_limiter_off:] [-err_conceal:] [-esbr:] +[-loudness_leveling:] where, is the input AAC-LC/HE-AACv1/HE-AACv2/AAC-LD/AAC-ELD/AAC-ELDv2/USAC file name. @@ -222,8 +224,10 @@ where, is to enable/disable peak limiter. Default value is 0. is to enable/disable error concealment. Default value is 0. is to enable/disable eSBR. Default value is 1. + 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: ``` -ifile:in_file.aac -ofile:out_file.wav -pcmsz:16 diff --git a/cmake/utils.cmake b/cmake/utils.cmake index 5d9cd37..3196501 100644 --- a/cmake/utils.cmake +++ b/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 diff --git a/decoder/drc_src/impd_drc_api.c b/decoder/drc_src/impd_drc_api.c index 529d1a5..d9f0466 100644 --- a/decoder/drc_src/impd_drc_api.c +++ b/decoder/drc_src/impd_drc_api.c @@ -246,7 +246,7 @@ IA_ERRORCODE ia_drc_dec_api(pVOID p_ia_drc_dec_obj, WORD32 i_cmd, WORD32 i_idx, case IA_API_CMD_SET_CONFIG_PARAM: { switch (i_idx) { case IA_DRC_DEC_CONFIG_PARAM_SAMP_FREQ: { - if (*pus_value <= 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; diff --git a/decoder/ixheaacd_api.c b/decoder/ixheaacd_api.c index 31157d2..3504a10 100644 --- a/decoder/ixheaacd_api.c +++ b/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 = diff --git a/decoder/ixheaacd_decode_main.c b/decoder/ixheaacd_decode_main.c index 982a6aa..d827687 100644 --- a/decoder/ixheaacd_decode_main.c +++ b/decoder/ixheaacd_decode_main.c @@ -88,6 +88,7 @@ VOID ixheaacd_samples_sat(WORD8 *outbuffer, WORD32 num_samples_out, FLOAT32 write_local_float; WORD16 *out_buf = (WORD16 *)outbuffer; + FLOAT32 *out_buf_float = (FLOAT32 *)outbuffer; num = num_channel_out * num_samples_out; @@ -105,6 +106,20 @@ VOID ixheaacd_samples_sat(WORD8 *outbuffer, WORD32 num_samples_out, } *out_bytes = num * sizeof(WORD16); + } else if (pcmsize == 32) { + for (i = 0; i < num; i++) { + write_local_float = + (out_samples[i % num_channel_out][i / num_channel_out]); + + if (write_local_float > 32767.0f) { + write_local_float = 32767.0f; + } else if (write_local_float < -32768.0f) { + write_local_float = -32768.0f; + } + out_buf_float[i] = write_local_float / 32767; + } + + *out_bytes = num * sizeof(FLOAT32); } else { WORD8 *out_24bit = (WORD8 *)out_buf; for (i = 0; i < num; i++) { diff --git a/decoder/ixheaacd_struct_def.h b/decoder/ixheaacd_struct_def.h index fea3b56..8518407 100644 --- a/decoder/ixheaacd_struct_def.h +++ b/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; diff --git a/encoder/drc_src/impd_drc_api.c b/encoder/drc_src/impd_drc_api.c index 5527b6d..60034b9 100644 --- a/encoder/drc_src/impd_drc_api.c +++ b/encoder/drc_src/impd_drc_api.c @@ -88,6 +88,15 @@ IA_ERRORCODE impd_drc_validate_config_params(ia_drc_input_config *pstr_inp_confi } IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config->str_drc_instructions_uni_drc[i].limiter_peak_target, MIN_LIMITER_PEAK_TARGET, 0.0f); +#ifdef LOUDNESS_LEVELING_SUPPORT + if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].drc_set_effect & + EFFECT_BIT_DUCK_SELF) { + IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config->str_drc_instructions_uni_drc[i].leveling_present, + 0, 1); + IMPD_DRC_BOUND_CHECK( + pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present, 0, 1); + } +#endif } IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config->drc_coefficients_uni_drc_count, 0, @@ -395,6 +404,16 @@ IA_ERRORCODE impd_drc_validate_config_params(ia_drc_input_config *pstr_inp_confi IMPD_DRC_BOUND_CHECK( pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].limiter_peak_target, MIN_LIMITER_PEAK_TARGET, 0.0f); +#ifdef LOUDNESS_LEVELING_SUPPORT + if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].drc_set_effect & + EFFECT_BIT_DUCK_SELF) { + IMPD_DRC_BOUND_CHECK( + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].leveling_present, 0, 1); + IMPD_DRC_BOUND_CHECK(pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i] + .ducking_only_set_present, + 0, 1); + } +#endif } } } @@ -423,8 +442,67 @@ static IA_ERRORCODE impd_drc_validate_drc_instructions( if (profile_found == FALSE) { return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG; } +#ifdef LOUDNESS_LEVELING_SUPPORT + if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].drc_set_effect & + EFFECT_BIT_DUCK_SELF) { + if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].leveling_present && + pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present) { + if (i < pstr_uni_drc_config->drc_instructions_uni_drc_count - 1) { + if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].drc_set_effect != + EFFECT_BIT_DUCK_SELF && + pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].drc_set_effect != + EFFECT_BIT_DUCK_OTHER) { + pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].drc_set_effect = + EFFECT_BIT_DUCK_SELF; + } + pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].leveling_present = 0; + pstr_uni_drc_config->str_drc_instructions_uni_drc[i + 1].ducking_only_set_present = 0; + } else { + pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present = 0; + } + } else if (!pstr_uni_drc_config->str_drc_instructions_uni_drc[i].leveling_present && + pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present) { + pstr_uni_drc_config->str_drc_instructions_uni_drc[i].ducking_only_set_present = 0; + } + } +#endif } - +#ifdef LOUDNESS_LEVELING_SUPPORT + if (pstr_uni_drc_config->uni_drc_config_ext_present) { + ia_drc_uni_drc_config_ext_struct *pstr_uni_drc_config_ext = + &pstr_uni_drc_config->str_uni_drc_config_ext; + for (i = 0; i < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count; i++) { + if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].drc_set_effect & + EFFECT_BIT_DUCK_SELF) { + if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].leveling_present && + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i] + .ducking_only_set_present) { + if (i < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count - 1) { + if (pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].drc_set_effect != + EFFECT_BIT_DUCK_SELF && + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].drc_set_effect != + EFFECT_BIT_DUCK_OTHER) { + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].drc_set_effect = + EFFECT_BIT_DUCK_SELF; + } + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1].leveling_present = 0; + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i + 1] + .ducking_only_set_present = 0; + } else { + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].ducking_only_set_present = + 0; + } + } else if (!pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i] + .leveling_present && + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i] + .ducking_only_set_present) { + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[i].ducking_only_set_present = + 0; + } + } + } + } +#endif return IA_NO_ERROR; } @@ -461,6 +539,18 @@ IA_ERRORCODE impd_drc_enc_init(VOID *pstr_drc_state, VOID *ptr_drc_scratch, if (err_code) { return err_code; } +#ifdef LOUDNESS_LEVELING_SUPPORT + err_code = impd_drc_validate_drc_instructions(&pstr_inp_config->str_uni_drc_config); + + if (err_code & IA_FATAL_ERROR) { + return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG; + } + + pstr_drc_state_local->str_enc_params = pstr_inp_config->str_enc_params; + pstr_drc_state_local->str_uni_drc_config = pstr_inp_config->str_uni_drc_config; + pstr_drc_state_local->str_enc_gain_extension = pstr_inp_config->str_enc_gain_extension; + pstr_drc_state_local->str_gain_enc.str_uni_drc_config = pstr_inp_config->str_uni_drc_config; +#else pstr_drc_state_local->str_enc_params = pstr_inp_config->str_enc_params; pstr_drc_state_local->str_uni_drc_config = pstr_inp_config->str_uni_drc_config; pstr_drc_state_local->str_enc_gain_extension = pstr_inp_config->str_enc_gain_extension; @@ -469,6 +559,7 @@ IA_ERRORCODE impd_drc_enc_init(VOID *pstr_drc_state, VOID *ptr_drc_scratch, if (err_code & IA_FATAL_ERROR) { return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG; } +#endif err_code = impd_drc_write_uni_drc_config(pstr_drc_state_local, &bit_count, 1); if (err_code & IA_FATAL_ERROR) { diff --git a/encoder/drc_src/impd_drc_common_enc.h b/encoder/drc_src/impd_drc_common_enc.h index 1bb46e3..c6a3626 100644 --- a/encoder/drc_src/impd_drc_common_enc.h +++ b/encoder/drc_src/impd_drc_common_enc.h @@ -36,7 +36,11 @@ #define MAX_CHANNEL_GROUP_COUNT (MAX_SEQUENCE_COUNT) #define MAX_ADDITIONAL_DOWNMIX_ID (7) #define DELAY_MODE_REGULAR_DELAY (0) +#ifdef LOUDNESS_LEVELING_SUPPORT +#define MAX_EXT_COUNT (3) +#else #define MAX_EXT_COUNT (2) +#endif #define MAX_GAIN_POINTS (256) #define MAX_DRC_INSTRUCTIONS_BASIC_COUNT (15) @@ -46,6 +50,9 @@ #define UNIDRC_CONF_EXT_PARAM_DRC (0x1) #define UNIDRC_CONF_EXT_V1 (0x2) #define UNIDRC_LOUD_EXT_EQ (0x1) +#ifdef LOUDNESS_LEVELING_SUPPORT +#define UNIDRCCONFEXT_LEVELING (0x4) +#endif #define MAX_PARAM_DRC_INSTRUCTIONS_COUNT (8) diff --git a/encoder/drc_src/impd_drc_mux.c b/encoder/drc_src/impd_drc_mux.c index 43bb87e..fa3aac1 100644 --- a/encoder/drc_src/impd_drc_mux.c +++ b/encoder/drc_src/impd_drc_mux.c @@ -1099,6 +1099,97 @@ static IA_ERRORCODE impd_drc_write_drc_instruct_uni_drc( return err_code; } +#ifdef LOUDNESS_LEVELING_SUPPORT +static UWORD32 get_num_ducking_only_drc_sets( + ia_drc_instructions_uni_drc const *pstr_drc_instructions_uni_drc, + UWORD32 drc_intructions_uni_drc_count) { + UWORD32 num_ducking_only_drc_sets = 0; + for (UWORD16 i = 0; i < drc_intructions_uni_drc_count; i++) { + if (pstr_drc_instructions_uni_drc[i].ducking_only_set_present) { + num_ducking_only_drc_sets++; + } + } + + return num_ducking_only_drc_sets; +} + +static WORD32 write_loudness_leveling_extension(ia_bit_buf_struct *it_bit_buf, + ia_drc_uni_drc_config_struct *pstr_uni_drc_config, + ia_drc_gain_enc_struct *pstr_gain_enc, + VOID *ptr_scratch, WORD32 *bit_cnt) { + IA_ERRORCODE err_code = IA_NO_ERROR; + WORD32 bit_cnt_local = 0; + WORD32 drc_instructions_uni_drc_count_v1 = + pstr_uni_drc_config->str_uni_drc_config_ext.drc_instructions_uni_drc_v1_count; + WORD32 drc_instructions_uni_drc_count = pstr_uni_drc_config->drc_instructions_uni_drc_count; + WORD32 version = 0; + WORD16 ducking_set_expected = 0; + // V0 instructions + for (WORD16 i = 0; i < drc_instructions_uni_drc_count; i++) { + ia_drc_instructions_uni_drc *pstr_drc_instruction = + &pstr_uni_drc_config->str_drc_instructions_uni_drc[i]; + if (pstr_drc_instruction->drc_set_effect & EFFECT_BIT_DUCK_SELF) { + if (ducking_set_expected) { + ia_drc_instructions_uni_drc *pstr_drc_instruction_prev = + &pstr_uni_drc_config->str_drc_instructions_uni_drc[i - 1]; + if (pstr_drc_instruction_prev->ducking_only_set_present) { + err_code = impd_drc_write_drc_instruct_uni_drc(it_bit_buf, version, pstr_uni_drc_config, + pstr_gain_enc, pstr_drc_instruction, + ptr_scratch, &bit_cnt_local); + if (err_code & IA_FATAL_ERROR) { + return (err_code); + } + } + ducking_set_expected = 0; + } else { + bit_cnt_local += + iusace_write_bits_buf(it_bit_buf, pstr_drc_instruction->leveling_present, 1); + if (pstr_drc_instruction->leveling_present) { + ducking_set_expected = 1; + bit_cnt_local += iusace_write_bits_buf( + it_bit_buf, pstr_drc_instruction->ducking_only_set_present, 1); + continue; + } + } + } + } + + // V1 instructions + version = 1; + ducking_set_expected = 0; + for (WORD16 i = 0; i < drc_instructions_uni_drc_count_v1; i++) { + ia_drc_instructions_uni_drc *pstr_drc_instruction = + &pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_instructions_uni_drc_v1[i]; + if (pstr_drc_instruction->drc_set_effect & EFFECT_BIT_DUCK_SELF) { + if (ducking_set_expected) { + ia_drc_instructions_uni_drc *pstr_drc_instruction_prev = + &pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_instructions_uni_drc_v1[i - 1]; + if (pstr_drc_instruction_prev->ducking_only_set_present) { + err_code = impd_drc_write_drc_instruct_uni_drc(it_bit_buf, version, pstr_uni_drc_config, + pstr_gain_enc, pstr_drc_instruction, + ptr_scratch, &bit_cnt_local); + if (err_code & IA_FATAL_ERROR) { + return (err_code); + } + } + ducking_set_expected = 0; + } else { + bit_cnt_local += + iusace_write_bits_buf(it_bit_buf, pstr_drc_instruction->leveling_present, 1); + if (pstr_drc_instruction->leveling_present) { + ducking_set_expected = 1; + bit_cnt_local += iusace_write_bits_buf( + it_bit_buf, pstr_drc_instruction->ducking_only_set_present, 1); + continue; + } + } + } + } + *bit_cnt += bit_cnt_local; + return IA_NO_ERROR; +} +#endif + static VOID impd_drc_write_gain_params(ia_bit_buf_struct *it_bit_buf, const WORD32 version, const WORD32 band_count, const WORD32 drc_band_type, ia_drc_gain_params_struct *pstr_gain_params, @@ -2536,6 +2627,9 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn( pstr_uni_drc_config_ext->uni_drc_config_ext_type[counter] != UNIDRC_CONF_EXT_TERM) { switch (pstr_uni_drc_config_ext->uni_drc_config_ext_type[counter]) { case UNIDRC_CONF_EXT_PARAM_DRC: { +#ifdef LOUDNESS_LEVELING_SUPPORT + bit_cnt_local_ext = 0; +#endif // LOUDNESS_LEVELING_SUPPORT err_code = impd_drc_write_drc_coeff_parametric_drc( ptr_bit_buf_ext, pstr_uni_drc_config, &(pstr_uni_drc_config_ext->str_drc_coeff_parametric_drc), &bit_cnt_local_ext); @@ -2559,6 +2653,9 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn( } break; case UNIDRC_CONF_EXT_V1: { version = 1; +#ifdef LOUDNESS_LEVELING_SUPPORT + bit_cnt_local_ext = 0; +#endif // LOUDNESS_LEVELING_SUPPORT bit_cnt_local_ext += iusace_write_bits_buf( ptr_bit_buf_ext, pstr_uni_drc_config_ext->downmix_instructions_v1_present, 1); if (pstr_uni_drc_config_ext->downmix_instructions_v1_present == 1) { @@ -2583,10 +2680,27 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn( &(pstr_uni_drc_config_ext->str_drc_coefficients_uni_drc_v1[idx]), &bit_cnt_local_ext); } +#ifdef LOUDNESS_LEVELING_SUPPORT + UWORD32 num_ducking_only_drc_sets = get_num_ducking_only_drc_sets( + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1, + pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count); + bit_cnt_local_ext += + iusace_write_bits_buf(ptr_bit_buf_ext, + pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count - + num_ducking_only_drc_sets, + 6); +#else bit_cnt_local_ext += iusace_write_bits_buf( ptr_bit_buf_ext, pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count, 6); +#endif for (idx = 0; idx < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count; idx++) { +#ifdef LOUDNESS_LEVELING_SUPPORT + if (idx > 0 && pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx - 1] + .ducking_only_set_present) { + continue; + } +#endif err_code = impd_drc_write_drc_instruct_uni_drc( ptr_bit_buf_ext, version, pstr_uni_drc_config, pstr_gain_enc, &(pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx]), ptr_scratch, @@ -2632,6 +2746,17 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn( } } } break; + +#ifdef LOUDNESS_LEVELING_SUPPORT + case UNIDRCCONFEXT_LEVELING: { + bit_cnt_local_ext = 0; + err_code = write_loudness_leveling_extension( + ptr_bit_buf_ext, pstr_uni_drc_config, pstr_gain_enc, ptr_scratch, &bit_cnt_local_ext); + if (err_code & IA_FATAL_ERROR) { + return (err_code); + } + } break; +#endif default: break; } @@ -2639,6 +2764,9 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn( pstr_uni_drc_config_ext->ext_bit_size[counter] = bit_cnt_local_ext; bit_size = pstr_uni_drc_config_ext->ext_bit_size[counter] - 1; ext_size_bits = (WORD32)(log((FLOAT32)bit_size) / log(2.f)) + 1; +#ifdef LOUDNESS_LEVELING_SUPPORT + ext_size_bits = (ext_size_bits < 4) ? 4 : ext_size_bits; +#endif // LOUDNESS_LEVELING_SUPPORT bit_size_len = ext_size_bits - 4; bit_cnt_local += iusace_write_bits_buf(it_bit_buf, bit_size_len, 4); @@ -2693,10 +2821,26 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn( it_bit_buf, version, &(pstr_uni_drc_config_ext->str_drc_coefficients_uni_drc_v1[idx]), &bit_cnt_local); } - +#ifdef LOUDNESS_LEVELING_SUPPORT + UWORD32 num_ducking_only_drc_sets = get_num_ducking_only_drc_sets( + pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1, + pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count); + bit_cnt_local += + iusace_write_bits_buf(it_bit_buf, + pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count - + num_ducking_only_drc_sets, + 6); +#else bit_cnt_local += iusace_write_bits_buf( it_bit_buf, pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count, 6); +#endif for (idx = 0; idx < pstr_uni_drc_config_ext->drc_instructions_uni_drc_v1_count; idx++) { +#ifdef LOUDNESS_LEVELING_SUPPORT + if (idx > 0 && pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx - 1] + .ducking_only_set_present) { + continue; + } +#endif err_code = impd_drc_write_drc_instruct_uni_drc( it_bit_buf, version, pstr_uni_drc_config, pstr_gain_enc, &(pstr_uni_drc_config_ext->str_drc_instructions_uni_drc_v1[idx]), ptr_scratch, @@ -2741,6 +2885,15 @@ static IA_ERRORCODE impd_drc_write_uni_drc_config_extn( } } } break; +#ifdef LOUDNESS_LEVELING_SUPPORT + case UNIDRCCONFEXT_LEVELING: { + err_code = write_loudness_leveling_extension(it_bit_buf, pstr_uni_drc_config, + pstr_gain_enc, ptr_scratch, &bit_cnt_local); + if (err_code & IA_FATAL_ERROR) { + return (err_code); + } + } break; +#endif default: for (idx = 0; idx < pstr_uni_drc_config_ext->ext_bit_size[counter]; idx++) { bit_cnt_local += iusace_write_bits_buf(it_bit_buf, 0, 1); @@ -3019,7 +3172,7 @@ IA_ERRORCODE impd_drc_write_measured_loudness_info(ia_drc_enc_state *pstr_drc_st return (err_code); } pstr_drc_state->drc_config_ext_data_size_bit = bit_cnt_lis; - + return err_code; } diff --git a/encoder/drc_src/impd_drc_uni_drc.h b/encoder/drc_src/impd_drc_uni_drc.h index 13e43ca..7cb720b 100644 --- a/encoder/drc_src/impd_drc_uni_drc.h +++ b/encoder/drc_src/impd_drc_uni_drc.h @@ -388,6 +388,10 @@ typedef struct { WORD32 multiband_audio_signal_count; WORD32 channel_group_is_parametric_drc[MAX_CHANNEL_GROUP_COUNT]; WORD32 gain_set_idx_for_ch_group_parametric_drc[MAX_CHANNEL_GROUP_COUNT]; +#ifdef LOUDNESS_LEVELING_SUPPORT + WORD32 leveling_present; + WORD32 ducking_only_set_present; +#endif } ia_drc_instructions_uni_drc; typedef struct { diff --git a/encoder/ixheaace_api.c b/encoder/ixheaace_api.c index 6d5c47e..749cac6 100644 --- a/encoder/ixheaace_api.c +++ b/encoder/ixheaace_api.c @@ -831,7 +831,7 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str return err_code; } - if (pstr_input_config->ui_pcm_wd_sz != 16) { + if (pstr_input_config->ui_pcm_wd_sz != 16 && pstr_input_config->ui_pcm_wd_sz != 32) { return (IA_EXHEAACE_CONFIG_FATAL_PCM_WDSZ); } if ((pstr_input_config->aac_config.inv_quant != 0) && @@ -901,6 +901,7 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str (AOT_AAC_ELD == pstr_input_config->aot)) { pstr_api_struct->config[ele_idx].aac_classic = 0; } +#ifndef AAC_NEW_TABLES if (pstr_api_struct->config[ele_idx].sample_rate < 32000) { if (pstr_api_struct->config[ele_idx].aac_classic == 0) { pstr_api_struct->config[ele_idx].aac_classic = 1; @@ -912,6 +913,7 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str pstr_input_config->aot = AOT_AAC_LD; } } +#endif pstr_api_struct->config[ele_idx].eldsbr_found = !(pstr_api_struct->config[ele_idx].aac_classic); } @@ -1213,6 +1215,8 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str } pstr_api_struct->config[0].aac_config.full_bandwidth = pstr_input_config->aac_config.full_bandwidth; + pstr_api_struct->config[0].aac_config.band_width = + pstr_input_config->aac_config.bandwidth; } return IA_NO_ERROR; @@ -2474,7 +2478,7 @@ static IA_ERRORCODE ia_enhaacplus_enc_init(ixheaace_api_struct *pstr_api_struct, pstr_aac_config->bit_rate, (pstr_api_struct->pstr_state->mps_enable ? 1 - : pstr_api_struct->config[ele_idx].chmode_nchannels), + : pstr_aac_config->num_out_channels), pstr_aac_config->sample_rate, &core_sample_rate, pstr_api_struct->spectral_band_replication_tabs.ptr_qmf_tab, pstr_api_struct->pstr_state->aot)) { @@ -2692,6 +2696,7 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru iexheaac_encoder_str **pstr_aac_enc; iaace_config *pstr_aac_config; pWORD16 pw_inp_buf = NULL; + pFLOAT32 pw_inp_buf_float = NULL; pUWORD8 pub_out_buf = NULL; FLOAT32 *ptr_input_buffer = NULL; FLOAT32 *ptr_input_buffer_mps = NULL; @@ -2729,6 +2734,8 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru pstr_aac_enc = pstr_api_struct->pstr_state->aac_enc_pers_mem; pw_inp_buf = (pWORD16)pstr_api_struct->pp_mem[IA_ENHAACPLUSENC_INPUT_IDX]; + pw_inp_buf_float = (pFLOAT32)pstr_api_struct->pp_mem[IA_ENHAACPLUSENC_INPUT_IDX]; + if (ele_idx == 0) { pstr_api_struct->pstr_state->i_out_bytes = 0; pub_out_buf = ((pUWORD8)pstr_api_struct->pp_mem[IA_ENHAACPLUSENC_OUTPUT_IDX]); @@ -2851,25 +2858,25 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru (!((pstr_api_struct->pstr_mps_212_enc != NULL) && pstr_api_struct->pstr_state->mps_enable))) { for (idx = 0; idx < (num_samples_read); idx++) { - ptr_input_buffer[write_off_set + idx] = (FLOAT32)pw_inp_buf[idx]; + ptr_input_buffer[write_off_set + idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767); } } else if (pstr_api_struct->config[ele_idx].i_channels == 1) { for (idx = 0; idx < num_samples_read; idx++) { ptr_input_buffer[write_off_set + (IXHEAACE_MAX_CH_IN_BS_ELE * idx)] = - (FLOAT32)pw_inp_buf[idx]; + pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767); } } else if ((pstr_api_struct->pstr_mps_212_enc != NULL) && pstr_api_struct->pstr_state->mps_enable) { ptr_input_buffer_mps = pstr_api_struct->pstr_state->time_signal_mps; for (idx = 0; idx < (num_samples_read / 2); idx++) { - ptr_input_buffer_mps[idx] = (FLOAT32)pw_inp_buf[2 * idx]; + ptr_input_buffer_mps[idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[2 * idx] : (pw_inp_buf_float[2 * idx] * 32767); ptr_input_buffer_mps[(num_samples_read / 2) + idx] = - (FLOAT32)pw_inp_buf[(2 * idx) + 1]; + pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[(2 * idx) + 1] : (pw_inp_buf_float[(2 * idx) + 1] * 32767); } } } else { for (idx = 0; idx < (num_samples_read + write_off_set); idx++) { - ptr_input_buffer[idx] = (FLOAT32)pw_inp_buf[idx]; + ptr_input_buffer[idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767); } } } else { @@ -2877,9 +2884,9 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru slot = pstr_api_struct->config[ele_idx].element_slot; for (idx = 0; idx < num_samples_read / 2; idx++) { ptr_input_buffer[2 * idx + write_off_set] = - (FLOAT32)pw_inp_buf[total_channels * idx + slot]; + pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[total_channels * idx + slot] : (pw_inp_buf_float[total_channels * idx + slot] * 32767); ptr_input_buffer[2 * idx + write_off_set + 1] = - (FLOAT32)pw_inp_buf[total_channels * idx + slot + 1]; + pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[total_channels * idx + slot + 1] : (pw_inp_buf_float[total_channels * idx + slot + 1] * 32767); } } @@ -2887,14 +2894,14 @@ static IA_ERRORCODE ia_enhaacplus_enc_execute(ixheaace_api_struct *pstr_api_stru slot = pstr_api_struct->config[ele_idx].element_slot; for (idx = 0; idx < num_samples_read; idx++) { ptr_input_buffer[write_off_set + (IXHEAACE_MAX_CH_IN_BS_ELE * idx)] = - (FLOAT32)pw_inp_buf[total_channels * idx + slot]; + pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[total_channels * idx + slot] : (pw_inp_buf_float[total_channels * idx + slot] * 32767); } } if (pstr_api_struct->config[ele_idx].i_channels == 6) { ptr_input_buffer_mps = pstr_api_struct->pstr_state->time_signal_mps; for (idx = 0; idx < num_samples_read; idx++) { - ptr_input_buffer_mps[idx] = (FLOAT32)pw_inp_buf[idx]; + ptr_input_buffer_mps[idx] = pstr_api_struct->config->ui_pcm_wd_sz == 16 ? (FLOAT32)pw_inp_buf[idx] : (pw_inp_buf_float[idx] * 32767); } } } diff --git a/encoder/ixheaace_asc_write.c b/encoder/ixheaace_asc_write.c index 3bf2736..356dc11 100644 --- a/encoder/ixheaace_asc_write.c +++ b/encoder/ixheaace_asc_write.c @@ -412,6 +412,7 @@ WORD32 ixheaace_get_audiospecific_config_bytes( pstr_audio_specific_config->sampling_frequency /= 2; if ((AOT_SBR == aot) || (AOT_PS == aot)) { + ext_aot = aot; aot = AOT_AAC_LC; } } @@ -460,9 +461,12 @@ WORD32 ixheaace_get_audiospecific_config_bytes( bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, (pstr_audio_specific_config->channel_configuration), 4); + if (ext_aot != -1) aot = ext_aot; + if ((AOT_SBR == aot) || (AOT_PS == aot)) { ext_aot = AOT_SBR; sbr_present_flag = 1; + tmp = 0x0f; for (i = 0; i < sizeof(ia_sampl_freq_table) / sizeof(ia_sampl_freq_table[0]); i++) { if (ia_sampl_freq_table[i] == pstr_audio_specific_config->ext_sampling_frequency) { @@ -470,18 +474,12 @@ WORD32 ixheaace_get_audiospecific_config_bytes( break; } } + pstr_audio_specific_config->ext_samp_freq_index = (UWORD32)tmp; - bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, - (pstr_audio_specific_config->ext_samp_freq_index), 4); - if (pstr_audio_specific_config->ext_samp_freq_index == 0xf) { - bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, - (pstr_audio_specific_config->ext_sampling_frequency), 24); - } + if (AOT_PS == aot) { ps_present_flag = 1; } - - bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, AOT_AAC_LC, 5); } switch (aot) { case AOT_AAC_ELD: { @@ -506,7 +504,7 @@ WORD32 ixheaace_get_audiospecific_config_bytes( ext_id = 0x2b7; bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, ext_id, 11); - bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, aot, 5); + bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, ext_aot, 5); bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, sbr_present_flag, 1); if (sbr_present_flag) { bit_cnt += iusace_write_bits_buf(pstr_it_bit_buff, diff --git a/encoder/ixheaace_enc_init.c b/encoder/ixheaace_enc_init.c index dc6ba74..da43291 100644 --- a/encoder/ixheaace_enc_init.c +++ b/encoder/ixheaace_enc_init.c @@ -374,7 +374,7 @@ IA_ERRORCODE ia_enhaacplus_enc_aac_enc_open(iexheaac_encoder_str **ppstr_exheaac WORD32 tns_mask = config.use_tns; if (config.full_bandwidth) { - pstr_exheaac_encoder->config.band_width = config.core_sample_rate >> 2; + pstr_exheaac_encoder->config.band_width = config.core_sample_rate >> (aot == AOT_USAC ? 2 : 1); } else { ixheaace_determine_bandwidth(pstr_exheaac_encoder->config.band_width, config.bit_rate, config.core_sample_rate, pstr_element_info->n_channels_in_el, diff --git a/encoder/ixheaace_rom.c b/encoder/ixheaace_rom.c index 532fee9..732e64a 100644 --- a/encoder/ixheaace_rom.c +++ b/encoder/ixheaace_rom.c @@ -1620,6 +1620,7 @@ const ixheaace_temporal_noise_shaping_tables ixheaace_enhaacplus_enc_tns_tab = { {8000, 39, 14, 39, 14, 31, 30}}, /*tns_info_tab[5]*/ +#ifndef AAC_NEW_TABLES {{4000, 12000, {1.2f, 1800, 16000, 0.6f}, @@ -1654,7 +1655,49 @@ const ixheaace_temporal_noise_shaping_tables ixheaace_enhaacplus_enc_tns_tab = { {1.41f, 3750, 16000, 0.3f}, {1.41f, 2500, 16000, 0.5f}, {1.41f, 3750, 16000, 0.3f}}}, +#else + {{4000, + 12000, + {1.2f, 1800, 16000, 0.6f}, + {1.2f, 2500, 16000, 0.6f}, + {1.2f, 1800, 16000, 0.6f}, + {1.2f, 2500, 16000, 0.6f}}, + {12001, + 20000, + {1.41f, 2500, 16000, 0.6f}, + {1.41f, 3750, 16000, 0.6f}, + {1.41f, 2500, 16000, 0.6f}, + {1.41f, 3750, 16000, 0.6f}}, + + {20001, + 28000, + {1.41f, 2500, 16000, 0.5f}, + {1.41f, 3750, 16000, 0.5f}, + {1.41f, 2500, 16000, 0.5f}, + {1.41f, 3750, 16000, 0.5f}}, + + {28001, + 36000, + {1.41f, 2500, 16000, 0.8f}, + {1.41f, 3750, 16000, 0.3f}, + {1.41f, 2500, 16000, 0.5f}, + {1.41f, 3750, 16000, 0.3f}}, + + {36001, + 52000, + {1.41f, 2500, 16000, 0.5f}, + {1.41f, 3750, 16000, 0.1f}, + {1.41f, 2500, 16000, 0.5f}, + {1.41f, 3750, 16000, 0.1f}}, + + {52001, + 576000, + {1.41f, 2500, 16000, 0.3f}, + {1.41f, 3750, 16000, 0.1f}, + {1.41f, 2500, 16000, 0.3f}, + {1.41f, 3750, 16000, 0.1f}}}, +#endif /*tns_coeff_3[8]*/ {-0.98480773f, -0.866025389f, -0.642787576f, -0.342020154f, 0.0f, 0.433883727f, 0.781831503f, diff --git a/encoder/ixheaace_rom.h b/encoder/ixheaace_rom.h index eb9e882..e85b300 100644 --- a/encoder/ixheaace_rom.h +++ b/encoder/ixheaace_rom.h @@ -100,7 +100,7 @@ typedef struct { extern const ixheaace_quant_tables ixheaace_enc_quant_tab; typedef struct { const ixheaace_temporal_noise_shaping_max_table tns_max_bands_table[12]; - const ixheaace_temporal_noise_shaping_info_tab tns_info_tab[5]; + const ixheaace_temporal_noise_shaping_info_tab tns_info_tab[6]; const FLOAT32 tns_coeff_3[8]; const FLOAT32 tns_coeff_3_borders[8]; const FLOAT32 tns_coeff_4[16]; diff --git a/encoder/ixheaace_sbr_env_est.c b/encoder/ixheaace_sbr_env_est.c index a02e0bd..9f78654 100644 --- a/encoder/ixheaace_sbr_env_est.c +++ b/encoder/ixheaace_sbr_env_est.c @@ -2155,7 +2155,7 @@ IA_ERRORCODE ixheaace_extract_sbr_envelope(FLOAT32 *ptr_in_time, FLOAT32 *ptr_co } else if (pstr_sbr_extract_env->time_step == 4) { ixheaace_detect_transient_4_1(pstr_sbr_extract_env->ptr_y_buffer, &pstr_env_ch[ch]->str_sbr_trans_detector, transient_info[ch], - pstr_sbr_extract_env->time_step, pstr_sbr_cfg->sbr_codec); + pstr_sbr_extract_env->time_step); } else { ixheaace_detect_transient(pstr_sbr_extract_env->ptr_y_buffer, &pstr_env_ch[ch]->str_sbr_trans_detector, transient_info[ch], diff --git a/encoder/ixheaace_sbr_env_est.h b/encoder/ixheaace_sbr_env_est.h index ffcee6f..a53a626 100644 --- a/encoder/ixheaace_sbr_env_est.h +++ b/encoder/ixheaace_sbr_env_est.h @@ -47,8 +47,7 @@ ixheaace_create_extract_sbr_envelope(WORD32 ch, ixheaace_pstr_sbr_extract_envelope pstr_sbr_ext_env, WORD32 start_index, WORD32 *ptr_common_buffer2, FLOAT32 *ptr_sbr_env_r_buf, FLOAT32 *ptr_sbr_env_i_buf, - WORD32 is_ld_sbr, WORD32 frame_flag_480, - ixheaace_sbr_codec_type sbr_codec); + WORD32 frame_flag_480, ixheaace_sbr_codec_type sbr_codec); struct ixheaace_str_sbr_config_data; struct ixheaace_str_sbr_bitstream_data; diff --git a/encoder/ixheaace_sbr_env_est_init.c b/encoder/ixheaace_sbr_env_est_init.c index 2f2d8d1..f2dfbf6 100644 --- a/encoder/ixheaace_sbr_env_est_init.c +++ b/encoder/ixheaace_sbr_env_est_init.c @@ -62,8 +62,7 @@ ixheaace_create_extract_sbr_envelope(WORD32 ch, ixheaace_pstr_sbr_extract_envelope pstr_sbr_ext_env, WORD32 start_index, WORD32 *ptr_common_buffer2, FLOAT32 *ptr_sbr_env_r_buf, FLOAT32 *ptr_sbr_env_i_buf, - WORD32 is_ld_sbr, WORD32 frame_flag_480, - ixheaace_sbr_codec_type sbr_codec) { + WORD32 frame_flag_480, ixheaace_sbr_codec_type sbr_codec) { WORD32 i; WORD32 y_buffer_length, r_buffer_length; WORD32 offset = 0; diff --git a/encoder/ixheaace_sbr_freq_scaling.c b/encoder/ixheaace_sbr_freq_scaling.c index 7eec5a9..1f08fbd 100644 --- a/encoder/ixheaace_sbr_freq_scaling.c +++ b/encoder/ixheaace_sbr_freq_scaling.c @@ -231,16 +231,16 @@ static WORD32 ixheaace_get_stop_freq(WORD32 fs, WORD32 stop_freq) { switch (fs) { case 16000: - k1_min = ixheaace_stop_freq_16k[0]; - v_stop_freq = (WORD32 *)&ixheaace_stop_freq_16k[0]; + k1_min = ixheaace_usac_stop_freq_16k[0]; + v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_16k[0]; break; case 22050: - k1_min = ixheaace_stop_freq_22k[0]; - v_stop_freq = (WORD32 *)&ixheaace_stop_freq_22k[0]; + k1_min = ixheaace_usac_stop_freq_22k[0]; + v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_22k[0]; break; case 24000: - k1_min = ixheaace_stop_freq_24k[0]; - v_stop_freq = (WORD32 *)&ixheaace_stop_freq_24k[0]; + k1_min = ixheaace_usac_stop_freq_24k[0]; + v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_24k[0]; break; case 32000: k1_min = 32; @@ -260,6 +260,24 @@ static WORD32 ixheaace_get_stop_freq(WORD32 fs, WORD32 stop_freq) { v_stop_freq = (WORD32 *)vector_stop_freq_48; break; + case 64000: + k1_min = 20; + + v_stop_freq = (WORD32 *)vector_stop_freq_64; + break; + + case 88200: + k1_min = 15; + + v_stop_freq = (WORD32 *)vector_stop_freq_88; + break; + + case 96000: + k1_min = 13; + + v_stop_freq = (WORD32 *)vector_stop_freq_96; + break; + default: v_stop_freq = (WORD32 *)vector_stop_freq_32; k1_min = 21; /* illegal fs */ diff --git a/encoder/ixheaace_sbr_main.c b/encoder/ixheaace_sbr_main.c index 64b6a2f..62928da 100644 --- a/encoder/ixheaace_sbr_main.c +++ b/encoder/ixheaace_sbr_main.c @@ -100,7 +100,7 @@ FLOAT32 *ixheaace_get_hbe_resample_buffer(ixheaace_pstr_sbr_enc pstr_env_enc) { static FLAG ia_enhaacplus_enc_get_sbr_tuning_table_idx( UWORD32 bitrate, UWORD32 num_ch, UWORD32 sample_rate, ixheaace_str_qmf_tabs *pstr_qmf_tab, UWORD32 *ptr_closest_br, WORD32 *ptr_idx_sr, WORD32 *ptr_idx_ch, WORD32 *ptr_idx_entry, - ixheaace_sbr_tuning_tables sbr_tune_table[10][2][10]) { + ixheaace_sbr_tuning_tables sbr_tune_table[10][2][20]) { WORD32 found = 0; WORD32 i_sr, br_closest_lower_idx_sr = -1, br_closest_upper_idx_sr = -1; WORD32 br_closest_lower_idx_ch = -1, br_closest_upper_idx_sch = -1; @@ -262,7 +262,7 @@ static IA_ERRORCODE ixheaace_create_env_channel( } err_code = ixheaace_create_extract_sbr_envelope( ch, &pstr_env->str_sbr_extract_env, start_index, ptr_common_buffer2, ptr_sbr_env_r_buf, - ptr_sbr_env_i_buf, params->is_ld_sbr, params->frame_flag_480, params->sbr_codec); + ptr_sbr_env_i_buf, params->frame_flag_480, params->sbr_codec); if (err_code) { return err_code; } @@ -386,6 +386,7 @@ ixheaace_is_sbr_setting_available(UWORD32 bitrate, UWORD32 num_output_channels, WORD32 idx_ch; WORD32 idx_entry; +#ifndef AAC_NEW_TABLES switch (num_output_channels) { case MONO: if (sample_rate_input < 16000 || sample_rate_input > 48000) { @@ -396,6 +397,7 @@ ixheaace_is_sbr_setting_available(UWORD32 bitrate, UWORD32 num_output_channels, return 0; } } +#endif *ptr_core_sr = sample_rate_input / 2; @@ -965,7 +967,7 @@ ixheaace_env_open(ixheaace_pstr_sbr_enc *pstr_env_encoder, ixheaace_pstr_sbr_cfg pstr_env_enc->str_sbr_cfg.stereo_mode = (params->codec_settings.num_channels == 2) ? params->stereo_mode : IXHEAACE_SBR_MODE_MONO; - if (params->codec_settings.sample_freq <= 24000) { + if (1) { pstr_env_enc->str_sbr_hdr.sample_rate_mode = IXHEAACE_DUAL_RATE; if (params->sbr_codec == USAC_SBR) { pstr_env_enc->str_sbr_cfg.sample_freq = 2 * params->codec_settings.sample_freq; diff --git a/encoder/ixheaace_sbr_noise_floor_est.c b/encoder/ixheaace_sbr_noise_floor_est.c index c5fcd99..344d2b0 100644 --- a/encoder/ixheaace_sbr_noise_floor_est.c +++ b/encoder/ixheaace_sbr_noise_floor_est.c @@ -136,8 +136,10 @@ static VOID ia_enhaacplus_enc_qmf_based_noise_floor_detection( mean_org += ton_org; mean_sbr += ton_sbr; } - mean_org /= (stop_channel - start_channel); - mean_sbr /= (stop_channel - start_channel); + if ((stop_channel - start_channel) > 0) { + mean_org /= (stop_channel - start_channel); + mean_sbr /= (stop_channel - start_channel); + } } if (mean_org < SBR_TON_MEAN_P0009 && mean_sbr < SBR_TON_MEAN_P0009) { diff --git a/encoder/ixheaace_sbr_rom.c b/encoder/ixheaace_sbr_rom.c index 90e94c5..bb52192 100644 --- a/encoder/ixheaace_sbr_rom.c +++ b/encoder/ixheaace_sbr_rom.c @@ -48,6 +48,9 @@ const WORD32 vector_offset_def[] = {0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20, 2 const WORD32 vector_stop_freq_32[14] = {32, 34, 36, 38, 40, 42, 44, 46, 49, 52, 55, 58, 61, 64}; const WORD32 vector_stop_freq_44[14] = {23, 25, 27, 29, 32, 34, 37, 40, 43, 47, 51, 55, 59, 64}; const WORD32 vector_stop_freq_48[14] = {21, 23, 25, 27, 30, 32, 35, 38, 42, 45, 49, 54, 59, 64}; +const WORD32 vector_stop_freq_64[14] = {20, 22, 24, 26, 29, 31, 34, 37, 41, 45, 49, 54, 59, 64}; +const WORD32 vector_stop_freq_88[14] = {15, 17, 19, 21, 23, 26, 29, 33, 37, 41, 46, 51, 57, 64}; +const WORD32 vector_stop_freq_96[14] = {13, 15, 17, 19, 21, 24, 27, 31, 35, 39, 44, 50, 57, 64}; const ixheaace_str_ps_tab ia_enhaacplus_enc_ps_tab = { /*a_hyb_res[3]*/ @@ -621,6 +624,7 @@ const ixheaace_str_qmf_tabs ixheaace_qmf_tab = { {0.05857864376269f, 0.2f, 0.34142135623731f, 0.4f}, {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000}, +#ifndef AAC_NEW_TABLES {{{{8000, 10000, {7, 11}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, {10000, 12000, {11, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, {12000, 48001, {14, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, @@ -738,6 +742,200 @@ const ixheaace_str_qmf_tabs ixheaace_qmf_tab = { {0}}} }, +#else + {{{ + /*** 8000hz 1ch SBR_AAC ***/ + {8000, 10000, {7, 11}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {10000, 12000, {11, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {12000, 16000, {14, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 24000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {24000, 32000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {32000, 48001, {14, 15}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 8000hz 2ch SBR_AAC ***/ + {16000, 24000, {6, 9}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {9, 11}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 36000, {11, 11}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {14, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 128001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 11025hz 1ch SBR_AAC ***/ + {8000, 10000, {5, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {10000, 12000, {8, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {12000, 16000, {12, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 20000, {12, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {20000, 24000, {13, 13}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {24000, 32000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {32000, 48000, {15, 15}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {48000, 66001, {15, 15}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 11025hz 2ch SBR_AAC ***/ + {16000, 24000, {7, 9}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {10, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 36000, {12, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {14, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 132301, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 12000hz 1ch SBR_AAC ***/ + {8000, 10000, {4, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {10000, 12000, {7, 11}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {12000, 16000, {11, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 20000, {11, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {20000, 24000, {12, 12}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {24000, 32000, {13, 13}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {32000, 48000, {14, 14}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {48000, 72001, {15, 15}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 12000hz 2ch SBR_AAC ***/ + {16000, 24000, {6, 9}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {9, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 36000, {11, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {12, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {14, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 144001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 16000hz 1ch SBR_AAC ***/ + {6000, 8000, {0, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {8000, 10000, {1, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {10000, 12000, {2, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {12000, 16000, {4, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 18000, {4, 8}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {18000, 22000, {6, 11}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {22000, 28000, {10, 12}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {28000, 36000, {12, 13}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 44000, {14, 13}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {44000, 96001, {15, 13}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 16000hz 2ch SBR_AAC ***/ + {16000, 24000, {4, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {8, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 36000, {10, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {15, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 192001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 22050hz 1ch SBR_AAC ***/ + {8000, 11369, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {11369, 16000, {3, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 18000, {3, 5}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {18000, 22000, {4, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {22000, 28000, {7, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {28000, 36000, {10, 9}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 44000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {44000, 132151, {13, 12}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 22050hz 2ch SBR_AAC ***/ + {16000, 24000, {2, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {5, 6}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 32000, {5, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {32000, 36000, {7, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {10, 9}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {12, 9}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {13, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 101000, {14, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {101000, 264601, {15, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 24000hz 1ch SBR_AAC ***/ + {8000, 12000, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {12000, 16000, {3, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 18000, {3, 5}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {18000, 22000, {4, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {22000, 28000, {7, 8}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {28000, 36000, {10, 9}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 44000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {44000, 144001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 24000hz 2ch SBR_AAC ***/ + {16000, 24000, {2, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {5, 6}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 36000, {7, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {10, 9}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {12, 9}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {13, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {14, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 288001, {15, 12}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 32000hz 1ch SBR_AAC ***/ + {24000, 36000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 60000, {7, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {60000, 72000, {9, 8}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {72000, 100000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {100000, 192001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 32000hz 2ch SBR_AAC ***/ + {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {80000, 112000, {9, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {112000, 144000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {144000, 384001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 44100hz 1ch SBR_AAC ***/ + {24000, 36000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 60000, {7, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {60000, 72000, {9, 8}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {72000, 100000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {100000, 264601, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 44100hz 2ch SBR_AAC ***/ + {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {80000, 112000, {9, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {112000, 144000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {144000, 529201, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 48000hz 1ch SBR_AAC ***/ + {24000, 36000, {4, 9}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 60000, {7, 10}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {60000, 72000, {9, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {72000, 100000, {11, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {100000, 288001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 48000hz 2ch SBR_AAC ***/ + {32000, 60000, {4, 9}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 80000, {7, 10}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {80000, 112000, {9, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {112000, 144000, {11, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {144000, 576001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}} + + }, +#endif +#ifndef AAC_NEW_TABLES {{{{0}}}, {{{0}}}, @@ -824,7 +1022,146 @@ const ixheaace_str_qmf_tabs ixheaace_qmf_tab = { {144000, 176000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, {176000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, {0}}}} +#else + {{{{0}}}, + {{{0}}}, + + {{ + /*** 12000hz 1ch ***/ + {8000, 32000, {1, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + {0}}}, + + {{ + /*** 16000hz 1ch ***/ + {8000, 10000, {1, 0}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {10000, 12000, {2, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {12000, 16000, {4, 6}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 18000, {4, 9}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {18000, 22000, {7, 12}, 3, {1, 6, 9}, IXHEAACE_SBR_MODE_MONO}, + {22000, 28000, {6, 9}, 3, {2, 3, 6}, IXHEAACE_SBR_MODE_MONO}, + {28000, 36000, {8, 12}, 3, {2, 9, 12}, IXHEAACE_SBR_MODE_MONO}, + {36000, 44000, {10, 12}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {44000, 64001, {11, 13}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 16000hz 2ch ***/ + {16000, 24000, {4, 1}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {8, 10}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 36000, {10, 12}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {13, 13}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {10, 11}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {14, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 128001, {15, 13}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 22050hz 1ch ***/ + {8000, 11369, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {11369, 16000, {1, 3}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 18000, {2, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {18000, 22000, {4, 5}, 3, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {22000, 28000, {5, 6}, 2, {2, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {28000, 36000, {7, 8}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 44000, {9, 9}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {44000, 52000, {12, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {52000, 70000, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {70000, 88001, {14, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 22050hz 2ch ***/ + {16000, 24000, {0, 0}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {3, 5}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 32000, {3, 7}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {32000, 36000, {5, 7}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {5, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {7, 8}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {9, 9}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {10, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 82000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {82000, 128001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 24000hz 1ch ***/ + {8000, 12000, {1, 1}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {12000, 16000, {1, 3}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {16000, 18000, {1, 4}, 3, {1, 0, 6}, IXHEAACE_SBR_MODE_MONO}, + {18000, 22000, {4, 8}, 2, {2, 3, 6}, IXHEAACE_SBR_MODE_MONO}, + {22000, 28000, {3, 8}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {28000, 36000, {4, 8}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 56000, {8, 9}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {56000, 70000, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {70000, 88001, {14, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 24000hz 2ch ***/ + {16000, 24000, {0, 0}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {24000, 28000, {3, 5}, 3, {1, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {28000, 36000, {5, 7}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {36000, 44000, {4, 8}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {44000, 52000, {6, 8}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {52000, 60000, {9, 9}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 76000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {76000, 88000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {88000, 128001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 32000hz 1ch ***/ + {24000, 36000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 60000, {7, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {60000, 72000, {9, 8}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {72000, 100000, {11, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {100000, 160001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 32000hz 2ch ***/ + {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {80000, 112000, {9, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {112000, 144000, {11, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {144000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 44100hz 1ch ***/ + {24000, 36000, {4, 9}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 60000, {8, 6}, 2, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {60000, 72000, {9, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {72000, 100000, {11, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {100000, 160001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 44100hz 2ch ***/ + {32000, 60000, {4, 4}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 80000, {7, 6}, 2, {3, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {80000, 112000, {10, 8}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {112000, 144000, {12, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {144000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}, + + {{ + /*** 48000hz 1ch ***/ + {24000, 36000, {4, 3}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {36000, 60000, {4, 4}, 3, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {60000, 72000, {9, 10}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {72000, 100000, {11, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {100000, 160001, {13, 11}, 1, {2, 0, 3}, IXHEAACE_SBR_MODE_MONO}, + {0}}, + { + /*** 48000hz 2ch ***/ + {32000, 60000, {4, 9}, 3, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {60000, 80000, {7, 10}, 2, {2, 0, -3}, IXHEAACE_SBR_MODE_SWITCH_LRC}, + {80000, 112000, {9, 10}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {112000, 144000, {11, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {144000, 176000, {12, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {176000, 256001, {13, 11}, 1, {3, 0, -3}, IXHEAACE_SBR_MODE_LEFT_RIGHT}, + {0}}}} +#endif }; /*End of QMF Tables*/ diff --git a/encoder/ixheaace_sbr_rom.h b/encoder/ixheaace_sbr_rom.h index c4dc0e6..02ca808 100644 --- a/encoder/ixheaace_sbr_rom.h +++ b/encoder/ixheaace_sbr_rom.h @@ -120,8 +120,8 @@ typedef struct { ixheaace_str_frame_info_sbr frame_480_info4_2048; const FLOAT32 ptr_smooth_filter[4]; UWORD32 supported_sample_rate[9]; - ixheaace_sbr_tuning_tables sbr_tuning_table_lc[10][2][10]; - ixheaace_sbr_tuning_tables sbr_tuning_table_ld[10][2][10]; + ixheaace_sbr_tuning_tables sbr_tuning_table_lc[10][2][20]; + ixheaace_sbr_tuning_tables sbr_tuning_table_ld[10][2][20]; } ixheaace_str_qmf_tabs; typedef struct { @@ -181,6 +181,9 @@ extern const WORD32 vector_offset_def[]; extern const WORD32 vector_stop_freq_32[14]; extern const WORD32 vector_stop_freq_44[14]; extern const WORD32 vector_stop_freq_48[14]; +extern const WORD32 vector_stop_freq_64[14]; +extern const WORD32 vector_stop_freq_88[14]; +extern const WORD32 vector_stop_freq_96[14]; /* Resampler tables */ extern const ixheaace_resampler_table ixheaace_resamp_2_to_1_iir_filt_params; diff --git a/encoder/ixheaace_sbr_tran_det.h b/encoder/ixheaace_sbr_tran_det.h index 20ec440..0d184f8 100644 --- a/encoder/ixheaace_sbr_tran_det.h +++ b/encoder/ixheaace_sbr_tran_det.h @@ -61,8 +61,7 @@ VOID ixheaace_detect_transient(FLOAT32 **ptr_energies, VOID ixheaace_detect_transient_4_1(FLOAT32 **ptr_energies, ixheaace_pstr_sbr_trans_detector pstr_sbr_trans_det, - WORD32 *ptr_tran_vector, WORD32 time_step, - ixheaace_sbr_codec_type sbr_codec); + WORD32 *ptr_tran_vector, WORD32 time_step); VOID ixheaace_detect_transient_eld(FLOAT32 **ptr_energies, ixheaace_pstr_sbr_trans_detector pstr_sbr_trans_det, diff --git a/encoder/ixheaace_sbr_tran_det_hp.c b/encoder/ixheaace_sbr_tran_det_hp.c index 2fb8846..539d620 100644 --- a/encoder/ixheaace_sbr_tran_det_hp.c +++ b/encoder/ixheaace_sbr_tran_det_hp.c @@ -162,8 +162,7 @@ VOID ixheaace_detect_transient(FLOAT32 **ptr_energies, } static VOID ixheaace_calc_thresholds_4_1(FLOAT32 **ptr_energies, WORD32 num_cols, WORD32 num_rows, - FLOAT32 *ptr_thresholds, - ixheaace_sbr_codec_type sbr_codec, WORD32 time_step) { + FLOAT32 *ptr_thresholds, WORD32 time_step) { FLOAT32 mean_val, std_val, thr; FLOAT32 *ptr_energy; FLOAT32 inv_num_cols = 1.0f / (FLOAT32)((num_cols + num_cols / 2) / time_step); @@ -207,7 +206,7 @@ static VOID ixheaace_extract_transient_candidates_4_1(FLOAT32 **ptr_energies, FLOAT32 *ptr_thresholds, FLOAT32 *ptr_transients, WORD32 num_cols, WORD32 start_band, WORD32 stop_band, - WORD32 buf_len, WORD32 time_step) + WORD32 time_step) { WORD32 idx; @@ -233,8 +232,7 @@ static VOID ixheaace_extract_transient_candidates_4_1(FLOAT32 **ptr_energies, VOID ixheaace_detect_transient_4_1(FLOAT32 **ptr_energies, ixheaace_pstr_sbr_trans_detector pstr_sbr_trans_det, - WORD32 *ptr_tran_vector, WORD32 time_step, - ixheaace_sbr_codec_type sbr_codec) { + WORD32 *ptr_tran_vector, WORD32 time_step) { WORD32 i; WORD32 no_cols = pstr_sbr_trans_det->no_cols; WORD32 qmf_start_sample = time_step * 4; @@ -246,12 +244,11 @@ VOID ixheaace_detect_transient_4_1(FLOAT32 **ptr_energies, ixheaace_calc_thresholds_4_1(ptr_energies, pstr_sbr_trans_det->no_cols, pstr_sbr_trans_det->no_rows, pstr_sbr_trans_det->ptr_thresholds, - sbr_codec, time_step); + time_step); ixheaace_extract_transient_candidates_4_1( ptr_energies, pstr_sbr_trans_det->ptr_thresholds, pstr_sbr_trans_det->ptr_transients, - pstr_sbr_trans_det->no_cols, 0, pstr_sbr_trans_det->no_rows, - pstr_sbr_trans_det->buffer_length, time_step); + pstr_sbr_trans_det->no_cols, 0, pstr_sbr_trans_det->no_rows, time_step); for (i = 0; i < no_cols; i++) { if ((ptr_trans[i] < 0.9f * ptr_trans[i - 1]) && (ptr_trans[i - 1] > int_thr)) { diff --git a/encoder/ixheaace_write_adts_adif.c b/encoder/ixheaace_write_adts_adif.c index 2cda5bb..0442ef8 100644 --- a/encoder/ixheaace_write_adts_adif.c +++ b/encoder/ixheaace_write_adts_adif.c @@ -310,7 +310,7 @@ WORD32 ia_enhaacplus_enc_write_ADTS_header(pUWORD8 buffer, WORD32 bytes_used, WO if (write_flag) { /* Fixed ADTS header */ ia_enhaacplus_enc_putbit(pstr_bitstream, 0xFFFF, 12); /* 12 bit Syncword */ - ia_enhaacplus_enc_putbit(pstr_bitstream, 1 /*aacStateStruct->aacConfigSturct.mpegVersion*/, + ia_enhaacplus_enc_putbit(pstr_bitstream, 0 /*aacStateStruct->aacConfigSturct.mpegVersion*/, 1); /* ID == 0 for MPEG4 AAC, 1 for MPEG2 AAC */ ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 2); /* layer == 0 */ ia_enhaacplus_enc_putbit(pstr_bitstream, 1, 1); /* protection absent */ diff --git a/fuzzer/xaac_enc_fuzzer.cpp b/fuzzer/xaac_enc_fuzzer.cpp index 530d6a1..4b11e8e 100644 --- a/fuzzer/xaac_enc_fuzzer.cpp +++ b/fuzzer/xaac_enc_fuzzer.cpp @@ -56,7 +56,10 @@ static VOID ixheaace_read_drc_config_params( WORD32 in_ch) { WORD32 n, g, s, m, ch, p; WORD32 gain_set_channels; - +#ifdef LOUDNESS_LEVELING_SUPPORT + UWORD32 loudness_leveling_extension_present = 0; + UWORD32 config_extension_count = 0; +#endif pstr_enc_params->gain_sequence_present = fuzzed_data->ConsumeBool(); pstr_enc_params->delay_mode = fuzzed_data->ConsumeBool(); pstr_uni_drc_config->sample_rate_present = fuzzed_data->ConsumeBool(); @@ -121,6 +124,13 @@ static VOID ixheaace_read_drc_config_params( pstr_drc_instructions_uni_drc->drc_instructions_type = fuzzed_data->ConsumeIntegral(); pstr_drc_instructions_uni_drc->mae_group_id = fuzzed_data->ConsumeIntegral(); pstr_drc_instructions_uni_drc->mae_group_preset_id = fuzzed_data->ConsumeIntegral(); +#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(); pstr_drc_instructions_uni_drc->mae_group_preset_id = fuzzed_data->ConsumeIntegral(); +#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 } } diff --git a/test/Android.bp b/test/Android.bp index 61a7c83..b534c2d 100644 --- a/test/Android.bp +++ b/test/Android.bp @@ -21,7 +21,8 @@ cc_test { "-DECLIPSE", "-DDRC_ENABLE", "-DMULTICHANNEL_ENABLE", - "-DENABLE_DRC" + "-DENABLE_DRC", + "-DLOUDNESS_LEVELING_SUPPORT", ], include_dirs: [ @@ -50,6 +51,7 @@ cc_test { cflags: [ "-O3", "-D_X86_", + "-DLOUDNESS_LEVELING_SUPPORT", ], include_dirs: [ diff --git a/test/decoder/ixheaacd_main.c b/test/decoder/ixheaacd_main.c index 9d0429d..987baec 100644 --- a/test/decoder/ixheaacd_main.c +++ b/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 is to enable / disable eSBR. Default value is 1\n\n"); #ifdef LOUDNESS_LEVELING_SUPPORT - printf("\n ] is to enable / disable loudness leveling."); + printf("\n 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; diff --git a/test/decoder/xaacdec.cmake b/test/decoder/xaacdec.cmake index f499ea8..f849989 100644 --- a/test/decoder/xaacdec.cmake +++ b/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() diff --git a/test/encoder/impd_drc_config_params.txt b/test/encoder/impd_drc_config_params.txt index a5cb59f..da7e9a1 100644 --- a/test/encoder/impd_drc_config_params.txt +++ b/test/encoder/impd_drc_config_params.txt @@ -1,3 +1,8 @@ +#In order to support DRC AMD-2(ISO/IEC 23003-4:2020/Amd. 2:2023(E)), `leveling_present` and `ducking_only_set` fields are introduced in DRC config file. +#For a given DRC effect, when both `leveling_present` and `ducking_only_set` are set to 1, automatically the next drc instruction is treated as ducking only set. +#For example, if the second DRC effect is marked as 2048/4096 with `leveling_present` is set to 1 and `ducking_only_set` is set to 1, then the third DRC effect will be treated as ducking-only. +#For the last drc instruction, `leveling_present` and `ducking_only_set` fields are ignored and reset to 0. Maximum supported instructions are 8. + #####str_drc_instructions_uni_drc##### drc_instructions_uni_drc_count:0 #####str_drc_coefficients_uni_drc##### @@ -28,10 +33,9 @@ attack:2.0 decay:5.0 #end gain parameters #####str_drc_instructions_uni_drc_v1##### -drc_instructions_uni_drc_count:8 +drc_instructions_uni_drc_count_v1:3 #n=0 downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ drc_set_effect:0x0001 gain_set_channels:8 gain_set_index:0 @@ -45,8 +49,7 @@ gain_set_index:0 num_drc_channel_groups:1 #n=1 downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ -drc_set_effect:0x0002 +drc_set_effect:0x800 gain_set_channels:8 gain_set_index:0 gain_set_index:0 @@ -57,80 +60,13 @@ gain_set_index:0 gain_set_index:0 gain_set_index:0 num_drc_channel_groups:1 +#leveling present flag +leveling_present:1 +#if ducking_only_set is one next drc instruction's set effect is set to 0x800 (ducking/leveling self) +ducking_only_set:1 #n=2 downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ -drc_set_effect:0x0004 -gain_set_channels:8 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -num_drc_channel_groups:1 -#n=3 -downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ -drc_set_effect:0x0008 -gain_set_channels:8 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -num_drc_channel_groups:1 -#n=4 -downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ -drc_set_effect:0x0010 -gain_set_channels:8 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -num_drc_channel_groups:1 -#n=5 -downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ -drc_set_effect:0x0020 -gain_set_channels:8 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -num_drc_channel_groups:1 -#n=6 -downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ -drc_set_effect:0x0040 -gain_set_channels:8 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -gain_set_index:0 -num_drc_channel_groups:1 -#n=7 -downmix_id:0 -#Different drc_effect values are present in impeghe_drc_uni_drc.h file with prefix EFFECT_BIT_ -drc_set_effect:0x0080 +drc_set_effect:0x0800 gain_set_channels:8 gain_set_index:0 gain_set_index:0 diff --git a/test/encoder/impd_drc_user_config.c b/test/encoder/impd_drc_user_config.c index 7f2969f..037d15a 100644 --- a/test/encoder/impd_drc_user_config.c +++ b/test/encoder/impd_drc_user_config.c @@ -92,7 +92,10 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en pstr_uni_drc_config->sample_rate_present = 1; pstr_uni_drc_config->str_drc_coefficients_uni_drc->drc_frame_size_present = 0; pstr_uni_drc_config->loudness_info_set_present = 1; - +#ifdef LOUDNESS_LEVELING_SUPPORT + WORD16 loudness_leveling_extension_present = 0; + UWORD32 config_extension_count = 0; +#endif /*********** str_drc_instructions_uni_drc *************/ pstr_uni_drc_config->drc_instructions_uni_drc_count = impd_drc_get_integer_value(fp); @@ -145,8 +148,15 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en pstr_drc_instructions_uni_drc->drc_instructions_type = 0; pstr_drc_instructions_uni_drc->mae_group_id = 0; pstr_drc_instructions_uni_drc->mae_group_preset_id = 0; - } +#ifdef LOUDNESS_LEVELING_SUPPORT + if (pstr_drc_instructions_uni_drc->drc_set_effect & EFFECT_BIT_DUCK_SELF) { + pstr_drc_instructions_uni_drc->leveling_present = impd_drc_get_integer_value(fp); + pstr_drc_instructions_uni_drc->ducking_only_set_present = impd_drc_get_integer_value(fp); + loudness_leveling_extension_present = 1; + } +#endif // LOUDNESS_LEVELING_SUPPORT + } /*********** str_drc_coefficients_uni_drc *************/ pstr_uni_drc_config->drc_coefficients_uni_drc_count = impd_drc_get_integer_value(fp); @@ -247,7 +257,13 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en pstr_uni_drc_config->uni_drc_config_ext_present = 1; if (pstr_uni_drc_config->uni_drc_config_ext_present) { +#ifdef LOUDNESS_LEVELING_SUPPORT + pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[config_extension_count] = + UNIDRC_CONF_EXT_V1; + config_extension_count++; +#else pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[0] = UNIDRC_CONF_EXT_V1; +#endif pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present = 1; if (pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present) { @@ -420,9 +436,25 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en pstr_drc_instructions_uni_drc->drc_instructions_type = 0; pstr_drc_instructions_uni_drc->mae_group_id = 0; pstr_drc_instructions_uni_drc->mae_group_preset_id = 0; +#ifdef LOUDNESS_LEVELING_SUPPORT + if (pstr_drc_instructions_uni_drc->drc_set_effect & EFFECT_BIT_DUCK_SELF) { + pstr_drc_instructions_uni_drc->leveling_present = impd_drc_get_integer_value(fp); + pstr_drc_instructions_uni_drc->ducking_only_set_present = + impd_drc_get_integer_value(fp); + loudness_leveling_extension_present = 1; + } +#endif // LOUDNESS_LEVELING_SUPPORT } } } + +#ifdef LOUDNESS_LEVELING_SUPPORT + if (loudness_leveling_extension_present) { + pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[config_extension_count] = + UNIDRCCONFEXT_LEVELING; + config_extension_count++; + } +#endif pstr_enc_loudness_info_set->loudness_info_set_ext_present = 0; pstr_enc_gain_extension->uni_drc_gain_ext_present = 0; } diff --git a/test/encoder/ixheaace_testbench.c b/test/encoder/ixheaace_testbench.c index 6260b90..624a9da 100644 --- a/test/encoder/ixheaace_testbench.c +++ b/test/encoder/ixheaace_testbench.c @@ -218,6 +218,7 @@ void ia_enhaacplus_enc_print_usage() { printf("\n[-aot:]"); printf("\n[-esbr:]"); printf("\n[-full_bandwidth:]"); + printf("\n[-bandwidth:]"); printf("\n[-max_out_buffer_per_ch:]"); printf("\n[-tree_cfg:]"); printf("\n[-usac:]"); @@ -269,6 +270,7 @@ void ia_enhaacplus_enc_print_usage() { printf( "\n Enable use of full bandwidth of input. Valid values are " "0(disable full bandwidth) and 1(enable full bandwidth). Default is 0."); + printf("\n specifies the bandwidth for the input (cutoff). Default is 0."); printf("\n 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) { diff --git a/test/encoder/xaacenc.cmake b/test/encoder/xaacenc.cmake index a7930d2..edf6b45 100644 --- a/test/encoder/xaacenc.cmake +++ b/test/encoder/xaacenc.cmake @@ -18,12 +18,12 @@ if (MSVC) xaacenc PROPERTIES COMPILE_FLAGS - "-D_CRT_SECURE_NO_WARNINGS -D_X86_") + "-D_CRT_SECURE_NO_WARNINGS -D_X86_ -DLOUDNESS_LEVELING_SUPPORT") else() set_target_properties( xaacenc PROPERTIES COMPILE_FLAGS - "-D_X86_ -c -O3 -Wall -Wsequence-point -Wunused-function" + "-D_X86_ -c -O3 -Wall -Wsequence-point -Wunused-function -DLOUDNESS_LEVELING_SUPPORT" ) endif()