wrapper/libxaac-mirror
1
0
Fork 0
mirror of https://github.com/ittiam-systems/libxaac.git synced 2026-04-02 20:30:47 +07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Support to configure user preferred loudness configuration through DRC (#100)

Browse source 
* Support to configure user preferred loudness configuration through DRC

Significance:
=============
- Added support to configure User defined program loudness through DRC, which takes
  precedence over loudness measured by the encoder
- Minor bug fixes

Testing:
========
- smoke-tested on x86, x86_64, Mac, armv7, armv8 and MSVS

* Addressed minor nits in the documentation

---------

Co-authored-by: Akshay Ragir <100833@ittiam.com>
This commit is contained in:
akshayragir833 2025-08-07 15:19:36 +05:30 • committed by GitHub
parent 1f798f1cc5
commit 388435c8f8
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 749 additions and 241 deletions
Download patch file Download diff file Expand all files Collapse all files

1
README_enc.md
View file

@ -105,6 +105,7 @@ where,
<inter_tes_enc_flag> Valid values are 0 (disable inter-TES encoding) and 1 (enable inter-TES encoding). Default is 0.
<random access interval in ms> is the time interval between audio preroll frames in ms. It is applicable only for AOT 42. Valid values are -1 (Audio preroll sent only at beginning of file) and greater than 1000 ms. Default is -1.
<stream identifier> It is the stream id used to uniquely identify configuration of a stream within a set of associated streams. It is applicable only for AOT 42. Valid values are 0 to 65535. Any value outside this range is type-casted to a value of unsigned short type. Default is 0.
<delay adjustment> is used to discard algorithmic delay from the decoded file. It is applicable only for AOT 42. Valid values are 0 and 1. Default is 1."
```
Sample CLI:

BIN
docs/LIBXAAC-Enc-API.pdf
View file

Binary file not shown.

BIN
docs/LIBXAAC-Enc-GSG.pdf
View file

Binary file not shown.

98
encoder/drc_src/impd_drc_api.c
View file

@ -417,6 +417,90 @@ IA_ERRORCODE impd_drc_validate_config_params(ia_drc_input_config *pstr_inp_confi
}
}
}
if (pstr_enc_loudness_info_set->loudness_info_set_ext_present) {
ia_drc_loudness_info_set_ext_eq_struct *pstr_enc_loudness_info_set_ext =
&pstr_enc_loudness_info_set->str_loudness_info_set_extension.str_loudness_info_set_ext_eq;
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->loudness_info_v1_count, 0,
MAX_LOUDNESS_INFO_COUNT);
for (i = 0; i < pstr_enc_loudness_info_set_ext->loudness_info_v1_count; i++) {
IMPD_DRC_BOUND_CHECK(
pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].sample_peak_level,
MIN_SAMPLE_PEAK_LEVEL, MAX_SAMPLE_PEAK_LEVEL);
IMPD_DRC_BOUND_CHECK(
pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].true_peak_level,
MIN_TRUE_PEAK_LEVEL, MAX_TRUE_PEAK_LEVEL);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.true_peak_level_measurement_system,
0, MAX_MEASUREMENT_SYSTEM_TYPE);
IMPD_DRC_BOUND_CHECK(
pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].true_peak_level_reliability, 0,
MAX_RELIABILITY_TYPE);
IMPD_DRC_BOUND_CHECK(
pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].measurement_count, 0,
MAX_MEASUREMENT_COUNT);
for (j = 0; j < pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].measurement_count;
j++) {
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.method_definition,
0, MAX_METHOD_DEFINITION_TYPE);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.method_value,
MIN_METHOD_VALUE, MAX_METHOD_VALUE);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.measurement_system,
0, MAX_MEASUREMENT_SYSTEM_TYPE);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.reliability,
0, MAX_RELIABILITY_TYPE);
}
}
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->loudness_info_v1_album_count, 0,
MAX_LOUDNESS_INFO_COUNT);
for (i = 0; i < pstr_enc_loudness_info_set_ext->loudness_info_v1_album_count; i++) {
IMPD_DRC_BOUND_CHECK(
pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].sample_peak_level,
MIN_SAMPLE_PEAK_LEVEL, MAX_SAMPLE_PEAK_LEVEL);
IMPD_DRC_BOUND_CHECK(
pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].true_peak_level,
MIN_TRUE_PEAK_LEVEL, MAX_TRUE_PEAK_LEVEL);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.true_peak_level_measurement_system,
0, MAX_MEASUREMENT_SYSTEM_TYPE);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.true_peak_level_reliability,
0, MAX_RELIABILITY_TYPE);
IMPD_DRC_BOUND_CHECK(
pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].measurement_count, 0,
MAX_MEASUREMENT_COUNT);
for (j = 0;
j < pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].measurement_count;
j++) {
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.method_definition,
0, MAX_METHOD_DEFINITION_TYPE);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.method_value,
MIN_METHOD_VALUE, MAX_METHOD_VALUE);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.measurement_system,
0, MAX_MEASUREMENT_SYSTEM_TYPE);
IMPD_DRC_BOUND_CHECK(pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.reliability,
0, MAX_RELIABILITY_TYPE);
}
}
}
return IA_NO_ERROR;
}
@ -539,7 +623,7 @@ 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) {
@ -550,16 +634,6 @@ IA_ERRORCODE impd_drc_enc_init(VOID *pstr_drc_state, VOID *ptr_drc_scratch,
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;
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;
}
#endif
err_code = impd_drc_write_uni_drc_config(pstr_drc_state_local, &bit_count, 1);
if (err_code & IA_FATAL_ERROR) {
@ -571,6 +645,8 @@ IA_ERRORCODE impd_drc_enc_init(VOID *pstr_drc_state, VOID *ptr_drc_scratch,
if (pstr_drc_state_local->str_gain_enc.str_uni_drc_config.loudness_info_set_present == 1) {
bit_count = 0;
iusace_reset_bit_buffer(&pstr_drc_state_local->str_bit_buf_cfg_ext);
memset(pstr_drc_state_local->bit_buf_base_cfg_ext, 0,
sizeof(MAX_DRC_PAYLOAD_BYTES * sizeof(pstr_drc_state_local->bit_buf_base_cfg_ext[0])));
err_code = impd_drc_write_loudness_info_set(
pstr_drc_state, &pstr_drc_state_local->str_bit_buf_cfg_ext, &bit_count, 1);
if (err_code & IA_FATAL_ERROR) {

65
encoder/drc_src/impd_drc_mux.c
View file

@ -1123,32 +1123,25 @@ static WORD32 write_loudness_leveling_extension(ia_bit_buf_struct *it_bit_buf,
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);
}
if (i > 0 && pstr_uni_drc_config->str_drc_instructions_uni_drc[i - 1].leveling_present &&
pstr_uni_drc_config->str_drc_instructions_uni_drc[i - 1].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;
}
}
}
@ -1156,31 +1149,27 @@ static WORD32 write_loudness_leveling_extension(ia_bit_buf_struct *it_bit_buf,
// 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);
}
if (i > 0 &&
pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_instructions_uni_drc_v1[i - 1]
.leveling_present &&
pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_instructions_uni_drc_v1[i - 1]
.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;
}
}
}
@ -3002,10 +2991,10 @@ IA_ERRORCODE impd_drc_write_loudness_info_set_extension(
}
break;
}
counter++;
bit_cnt_local += iusace_write_bits_buf(
it_bit_buf, pstr_loudness_info_set_extension->loudness_info_set_ext_type[counter], 4);
counter++;
}
*ptr_bit_cnt += bit_cnt_local;
@ -3101,9 +3090,17 @@ IA_ERRORCODE impd_drc_write_uni_drc_config(ia_drc_enc_state *pstr_drc_state, WOR
bit_cnt_local +=
iusace_write_bits_buf(it_bit_buf, pstr_uni_drc_config->drc_coefficients_uni_drc_count, 3);
#ifdef LOUDNESS_LEVELING_SUPPORT
UWORD32 num_ducking_only_drc_sets =
get_num_ducking_only_drc_sets(pstr_uni_drc_config->str_drc_instructions_uni_drc,
pstr_uni_drc_config->drc_instructions_uni_drc_count);
bit_cnt_local += iusace_write_bits_buf(
it_bit_buf, pstr_uni_drc_config->drc_instructions_uni_drc_count - num_ducking_only_drc_sets,
6);
#else
bit_cnt_local +=
iusace_write_bits_buf(it_bit_buf, pstr_uni_drc_config->drc_instructions_uni_drc_count, 6);
#endif
bit_cnt_local +=
iusace_write_bits_buf(it_bit_buf, pstr_uni_drc_config->str_channel_layout.base_ch_count, 7);
bit_cnt_local += iusace_write_bits_buf(
@ -3138,6 +3135,12 @@ IA_ERRORCODE impd_drc_write_uni_drc_config(ia_drc_enc_state *pstr_drc_state, WOR
}
for (idx = 0; idx < pstr_uni_drc_config->drc_instructions_uni_drc_count; idx++) {
#ifdef LOUDNESS_LEVELING_SUPPORT
if (idx > 0 &&
pstr_uni_drc_config->str_drc_instructions_uni_drc[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->str_drc_instructions_uni_drc[idx]), ptr_scratch, &bit_cnt_local);

1
encoder/iusace_cnst.h
View file

@ -211,3 +211,4 @@
#define CC_NUM_PREROLL_FRAMES (1)
#define USAC_FIRST_FRAME_FLAG_DEFAULT_VALUE (1)
#define USAC_DEFAULT_DELAY_ADJUSTMENT_VALUE (1)
#define USAC_DEFAULT_MEASURED_LOUDNESS_FLAG_VALUE (1)

3
encoder/iusace_config.h
View file

@ -283,10 +283,9 @@ typedef struct {
WORD32 is_ipf;
WORD32 preroll_frame;
WORD32 is_first_frame;
ia_drc_internal_config str_internal_drc_cfg;
WORD32 use_measured_loudness;
UWORD16 stream_id;
FLAG use_delay_adjustment;
FLAG is_loudness_configured;
} ia_usac_encoder_config_struct;
typedef struct {

156
encoder/ixheaace_api.c
View file

@ -544,6 +544,7 @@ static VOID ixheaace_set_default_config(ixheaace_api_struct *pstr_api_struct,
pstr_usac_config->num_preroll_frames = CC_NUM_PREROLL_FRAMES;
pstr_usac_config->stream_id = USAC_DEFAULT_STREAM_ID_VALUE;
pstr_usac_config->use_delay_adjustment = USAC_DEFAULT_DELAY_ADJUSTMENT_VALUE;
pstr_usac_config->is_loudness_configured = USAC_DEFAULT_MEASURED_LOUDNESS_FLAG_VALUE;
}
/* Initialize table pointers */
ia_enhaacplus_enc_init_aac_tabs(&(pstr_api_struct->pstr_aac_tabs));
@ -1060,6 +1061,21 @@ static IA_ERRORCODE ixheaace_set_config_params(ixheaace_api_struct *pstr_api_str
pstr_usac_config->str_drc_cfg.str_uni_drc_config.str_drc_coefficients_uni_drc
->drc_frame_size = pstr_usac_config->drc_frame_size;
pstr_input_config->drc_frame_size = pstr_usac_config->drc_frame_size;
ia_drc_loudness_info_set_struct *pstr_enc_loudness_info_set =
&pstr_usac_config->str_drc_cfg.str_enc_loudness_info_set;
if ((pstr_usac_config->use_drc_element &&
((pstr_enc_loudness_info_set->loudness_info_count != 0) ||
(pstr_enc_loudness_info_set->loudness_info_album_count != 0) ||
(pstr_enc_loudness_info_set->str_loudness_info_set_extension
.str_loudness_info_set_ext_eq.loudness_info_v1_count != 0) ||
(pstr_enc_loudness_info_set->str_loudness_info_set_extension
.str_loudness_info_set_ext_eq.loudness_info_v1_album_count != 0)))) {
pstr_usac_config->is_loudness_configured = 1;
} else {
pstr_usac_config->is_loudness_configured = 0;
}
}
} else {
if ((pstr_input_config->i_channels > MAX_NUM_CORE_CODER_CHANNELS)) {
@ -3514,82 +3530,43 @@ IA_ERRORCODE ixheaace_get_lib_id_strings(pVOID pv_output) {
return err_code;
}
static void ixheaace_config_drc_parameters(ixheaace_api_struct *pstr_api_struct,
ixheaace_input_config *pstr_input_config) {
ia_drc_input_config *pstr_drc_cfg;
pstr_drc_cfg = (ia_drc_input_config *)pstr_input_config->pv_drc_cfg;
ia_drc_internal_config *pstr_internal_drc_cfg =
&pstr_api_struct->config[0].usac_config.str_internal_drc_cfg;
ia_drc_loudness_info_set_struct *pstr_enc_loudness_info_set =
&pstr_drc_cfg->str_enc_loudness_info_set;
ia_drc_loudness_info_set_struct *pstr_enc_internal_loudness_info_set =
&pstr_internal_drc_cfg->str_enc_loudness_info_set;
WORD32 n;
pstr_enc_loudness_info_set->loudness_info_count =
MIN(pstr_enc_internal_loudness_info_set->loudness_info_count, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_count; n++) {
memcpy(&pstr_enc_loudness_info_set->str_loudness_info[n],
&pstr_enc_internal_loudness_info_set->str_loudness_info[n],
sizeof(ia_drc_loudness_info_struct));
}
pstr_enc_loudness_info_set->loudness_info_album_count = MIN(
pstr_enc_internal_loudness_info_set->loudness_info_album_count, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_album_count; n++) {
memcpy(&pstr_enc_loudness_info_set->str_loudness_info_album[n],
&pstr_enc_internal_loudness_info_set->str_loudness_info_album[n],
sizeof(ia_drc_loudness_info_struct));
}
}
static void ixheaace_get_measured_loudness_info(ixheaace_api_struct *pstr_api_struct,
ixheaace_input_config *pstr_input_config) {
ia_drc_input_config *pstr_internal_drc_cfg;
if (!pstr_input_config->use_measured_loudness) {
pstr_internal_drc_cfg =
(ia_drc_input_config *)&pstr_api_struct->config[0].usac_config.str_internal_drc_cfg;
} else {
pstr_internal_drc_cfg = &pstr_api_struct->config[0].usac_config.str_drc_cfg;
}
memset(pstr_internal_drc_cfg, 0, sizeof(ia_drc_input_config));
ia_drc_uni_drc_config_struct *pstr_uni_drc_config = &pstr_internal_drc_cfg->str_uni_drc_config;
ia_drc_loudness_info_set_struct *pstr_enc_loudness_info_set =
&pstr_internal_drc_cfg->str_enc_loudness_info_set;
{
WORD32 n, m;
pstr_uni_drc_config->sample_rate_present = 1;
pstr_uni_drc_config->loudness_info_set_present = 1;
pstr_enc_loudness_info_set->loudness_info_count = 1;
pstr_enc_loudness_info_set->loudness_info_count =
MIN(pstr_enc_loudness_info_set->loudness_info_count, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_count; n++) {
pstr_enc_loudness_info_set->str_loudness_info[n].drc_set_id = 0;
pstr_enc_loudness_info_set->str_loudness_info[n].downmix_id = 0;
pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level_present = 1;
pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level =
pstr_input_config->sample_peak_level;
pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_present = 0;
pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count = 1;
pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count =
MIN(pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count,
MAX_MEASUREMENT_COUNT);
ia_drc_uni_drc_config_struct *pstr_uni_drc_config;
ia_drc_loudness_info_set_struct *pstr_enc_loudness_info_set;
WORD32 n, m;
for (m = 0; m < pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count; m++) {
pstr_enc_loudness_info_set->str_loudness_info[n]
.str_loudness_measure[m]
.method_definition = pstr_input_config->method_def;
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].method_value =
(FLOAT32)pstr_input_config->measured_loudness;
pstr_enc_loudness_info_set->str_loudness_info[n]
.str_loudness_measure[m]
.measurement_system = pstr_input_config->measurement_system;
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].reliability = 3;
}
pstr_internal_drc_cfg =
(ia_drc_input_config *)&pstr_api_struct->config[0].usac_config.str_drc_cfg;
if (pstr_input_config->use_drc_element == 0) {
memset(pstr_internal_drc_cfg, 0, sizeof(ia_drc_input_config));
}
pstr_uni_drc_config = &pstr_internal_drc_cfg->str_uni_drc_config;
pstr_enc_loudness_info_set = &pstr_internal_drc_cfg->str_enc_loudness_info_set;
pstr_uni_drc_config->sample_rate_present = 1;
pstr_uni_drc_config->loudness_info_set_present = 1;
pstr_enc_loudness_info_set->loudness_info_count = 1;
for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_count; n++) {
pstr_enc_loudness_info_set->str_loudness_info[n].drc_set_id = 0;
pstr_enc_loudness_info_set->str_loudness_info[n].downmix_id = 0;
pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level_present = 1;
pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level =
pstr_input_config->sample_peak_level;
pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_present = 0;
pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count = 1;
for (m = 0; m < pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count; m++) {
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].method_definition =
pstr_input_config->method_def;
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].method_value =
(FLOAT32)pstr_input_config->measured_loudness;
pstr_enc_loudness_info_set->str_loudness_info[n]
.str_loudness_measure[m]
.measurement_system = pstr_input_config->measurement_system;
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].reliability = 3;
}
}
}
@ -3629,23 +3606,6 @@ IA_ERRORCODE ixheaace_allocate(pVOID pv_input, pVOID pv_output) {
pstr_api_struct = (ixheaace_api_struct *)pstr_output_config->pv_ia_process_api_obj;
memset(pstr_api_struct, 0, sizeof(*pstr_api_struct));
if (pstr_input_config->aot == AOT_USAC) {
if (pstr_input_config->use_drc_element == 0) {
pstr_input_config->use_measured_loudness = 1;
} else {
pstr_input_config->use_measured_loudness = 0;
}
ixheaace_get_measured_loudness_info(pstr_api_struct, pstr_input_config);
if (!pstr_input_config->use_measured_loudness)
ixheaace_config_drc_parameters(pstr_api_struct, pstr_input_config);
if (pstr_input_config->use_measured_loudness) {
memcpy(pstr_input_config->pv_drc_cfg, &pstr_api_struct->config[0].usac_config.str_drc_cfg,
sizeof(ia_drc_input_config));
}
}
ixheaace_set_default_config(pstr_api_struct, pstr_input_config);
err_code = ixheaace_set_config_params(pstr_api_struct, pstr_input_config);
@ -3653,6 +3613,14 @@ IA_ERRORCODE ixheaace_allocate(pVOID pv_input, pVOID pv_output) {
return err_code;
}
if (pstr_input_config->aot == AOT_USAC) {
if (pstr_api_struct->config[0].usac_config.is_loudness_configured == 0) {
ixheaace_get_measured_loudness_info(pstr_api_struct, pstr_input_config);
memcpy(pstr_input_config->pv_drc_cfg, &pstr_api_struct->config[0].usac_config.str_drc_cfg,
sizeof(ia_drc_input_config));
}
}
pstr_output_config->ui_proc_mem_tabs_size =
(sizeof(ixheaace_mem_info_struct) + sizeof(pVOID *)) * 4;
pstr_output_config->arr_alloc_memory[pstr_output_config->malloc_count] =
@ -3681,12 +3649,6 @@ IA_ERRORCODE ixheaace_allocate(pVOID pv_input, pVOID pv_output) {
pstr_output_config->malloc_count++;
if (pstr_input_config->aot == AOT_USAC) {
if (pstr_input_config->use_measured_loudness) {
pstr_api_struct->config[0].usac_config.use_measured_loudness = 1;
}
}
ixheaace_fill_mem_tabs(pstr_api_struct, pstr_input_config->aot);
err_code =
@ -3694,6 +3656,10 @@ IA_ERRORCODE ixheaace_allocate(pVOID pv_input, pVOID pv_output) {
if (err_code) {
return err_code;
}
pstr_output_config->is_loudness_configured =
pstr_api_struct->config[0].usac_config.is_loudness_configured;
return err_code;
}

2
encoder/ixheaace_api.h
View file

@ -110,7 +110,6 @@ typedef struct {
ixheaace_aac_enc_config aac_config;
WORD32 random_access_interval;
UWORD32 method_def;
FLAG use_measured_loudness;
FLOAT64 measured_loudness;
UWORD32 measurement_system;
FLOAT32 sample_peak_level;
@ -142,6 +141,7 @@ typedef struct {
WORD32 audio_profile;
FLOAT32 down_sampling_ratio;
WORD32 expected_frame_count;
FLAG is_loudness_configured;
} ixheaace_output_config;
typedef struct {

96
fuzzer/xaac_enc_fuzzer.cpp
View file

@ -530,6 +530,102 @@ static VOID ixheaace_read_drc_config_params(
}
#endif
}
if (pstr_enc_loudness_info_set->loudness_info_set_ext_present) {
ia_drc_loudness_info_set_ext_eq_struct *pstr_loudness_info_set_ext_eq =
&pstr_enc_loudness_info_set->str_loudness_info_set_extension.str_loudness_info_set_ext_eq;
pstr_enc_loudness_info_set->str_loudness_info_set_extension.loudness_info_set_ext_type[0] =
UNIDRC_LOUD_EXT_EQ;
/********************* loudness_info_v1_album *********************/
pstr_loudness_info_set_ext_eq->loudness_info_v1_album_count =
fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_loudness_info_set_ext_eq->loudness_info_v1_album_count; n++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].drc_set_id =
fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].downmix_id =
fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].sample_peak_level_present =
fuzzed_data->ConsumeBool();
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.sample_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].sample_peak_level =
fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level_present =
fuzzed_data->ConsumeBool();
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level =
fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.true_peak_level_measurement_system = fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level_reliability =
fuzzed_data->ConsumeIntegral<WORD8>();
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].measurement_count =
fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_MEASUREMENT_COUNT);
for (m = 0;
m < pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].measurement_count;
m++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.method_definition = fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.method_value = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.measurement_system = fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.reliability = fuzzed_data->ConsumeIntegral<WORD8>();
}
}
/********************* loudness_info_v1 *********************/
pstr_loudness_info_set_ext_eq->loudness_info_v1_count =
fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_loudness_info_set_ext_eq->loudness_info_v1_count; n++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].drc_set_id =
fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].downmix_id =
fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].sample_peak_level_present =
fuzzed_data->ConsumeBool();
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].sample_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].sample_peak_level =
fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level_present =
fuzzed_data->ConsumeBool();
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level =
fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.true_peak_level_measurement_system = fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level_reliability =
fuzzed_data->ConsumeIntegral<WORD8>();
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].measurement_count =
fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_MEASUREMENT_COUNT);
for (m = 0; m < pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].measurement_count;
m++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.method_definition = fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.method_value = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.measurement_system = fuzzed_data->ConsumeIntegral<WORD8>();
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.reliability = fuzzed_data->ConsumeIntegral<WORD8>();
}
}
}
}
static VOID ixheaace_fuzzer_flag(ixheaace_input_config *pstr_in_cfg,

33
test/encoder/impd_drc_config_params.txt
View file

@ -63,7 +63,7 @@ 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
ducking_only_set_present:1
#n=2
downmix_id:0
drc_set_effect:0x0800
@ -76,4 +76,33 @@ gain_set_index:0
gain_set_index:0
gain_set_index:0
gain_set_index:0
num_drc_channel_groups:1
num_drc_channel_groups:1
leveling_present:0
ducking_only_set_present:0
#loudness info parameters
loudness_info_count:1
#n=0
drc_set_id:1
downmix_id:0
sample_peak_level_present:1
sample_peak_level:0.0
true_peak_level_present:1
true_peak_level:1.0
true_peak_level_measurement_system:2
true_peak_level_reliability:3
measurement_count:1
#m=0
method_definition:1
method_value:-16.0
measurement_system:2
reliability:3
#end loudness info parameters
#loudness info album parameters
loudness_info_album_count:0
#end of loudness info album parameters
#####loudness info set extension#####
loudness_info_set_ext_present:0
# end of loudness info set extension

197
test/encoder/impd_drc_user_config.c
View file

@ -455,6 +455,201 @@ VOID ixheaace_read_drc_config_params(FILE *fp, ia_drc_enc_params_struct *pstr_en
config_extension_count++;
}
#endif
pstr_enc_loudness_info_set->loudness_info_set_ext_present = 0;
/********************* str_loudness_info *********************/
pstr_enc_loudness_info_set->loudness_info_count = impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->loudness_info_count =
MIN(pstr_enc_loudness_info_set->loudness_info_count, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_count; n++) {
pstr_enc_loudness_info_set->str_loudness_info[n].drc_set_id = impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n].downmix_id = impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level_present =
impd_drc_get_integer_value(fp);
if (1 == pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level_present) {
pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level =
impd_drc_get_float_value(fp);
}
pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_present =
impd_drc_get_integer_value(fp);
if (1 == pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_present) {
pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level =
impd_drc_get_float_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_measurement_system =
impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_reliability =
impd_drc_get_integer_value(fp);
}
pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count =
impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count =
MIN(pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count,
MAX_MEASUREMENT_COUNT);
for (m = 0; m < pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count; m++) {
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].method_definition =
impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].method_value =
impd_drc_get_float_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n]
.str_loudness_measure[m]
.measurement_system = impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].reliability =
impd_drc_get_integer_value(fp);
}
}
pstr_enc_loudness_info_set->loudness_info_album_count = impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->loudness_info_album_count =
MIN(pstr_enc_loudness_info_set->loudness_info_album_count, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_album_count; n++) {
pstr_enc_loudness_info_set->str_loudness_info_album[n].drc_set_id =
impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n].downmix_id =
impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n].sample_peak_level_present =
impd_drc_get_integer_value(fp);
if (1 == pstr_enc_loudness_info_set->str_loudness_info_album[n].sample_peak_level_present) {
pstr_enc_loudness_info_set->str_loudness_info_album[n].sample_peak_level =
impd_drc_get_float_value(fp);
}
pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_present =
impd_drc_get_integer_value(fp);
if (1 == pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_present) {
pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level =
impd_drc_get_float_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_measurement_system =
impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_reliability =
impd_drc_get_integer_value(fp);
}
pstr_enc_loudness_info_set->str_loudness_info_album[n].measurement_count =
impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n].measurement_count =
MIN(pstr_enc_loudness_info_set->str_loudness_info_album[n].measurement_count,
MAX_MEASUREMENT_COUNT);
for (m = 0; m < pstr_enc_loudness_info_set->str_loudness_info_album[n].measurement_count;
m++) {
pstr_enc_loudness_info_set->str_loudness_info_album[n]
.str_loudness_measure[m]
.method_definition = impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n]
.str_loudness_measure[m]
.method_value = impd_drc_get_float_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n]
.str_loudness_measure[m]
.measurement_system = impd_drc_get_integer_value(fp);
pstr_enc_loudness_info_set->str_loudness_info_album[n].str_loudness_measure[m].reliability =
impd_drc_get_integer_value(fp);
}
}
/********************* loudness info set extension *********************/
pstr_enc_loudness_info_set->loudness_info_set_ext_present = impd_drc_get_integer_value(fp);
if (pstr_enc_loudness_info_set->loudness_info_set_ext_present) {
ia_drc_loudness_info_set_ext_eq_struct *pstr_loudness_info_set_ext_eq =
&pstr_enc_loudness_info_set->str_loudness_info_set_extension.str_loudness_info_set_ext_eq;
pstr_enc_loudness_info_set->str_loudness_info_set_extension.loudness_info_set_ext_type[0] =
UNIDRC_LOUD_EXT_EQ;
/********************* loudness_info_v1_album *********************/
pstr_loudness_info_set_ext_eq->loudness_info_v1_album_count = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->loudness_info_v1_album_count =
MIN(pstr_loudness_info_set_ext_eq->loudness_info_v1_album_count, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_loudness_info_set_ext_eq->loudness_info_v1_album_count; n++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].drc_set_id =
impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].downmix_id =
impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].sample_peak_level_present =
impd_drc_get_integer_value(fp);
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.sample_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].sample_peak_level =
impd_drc_get_float_value(fp);
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level_present =
impd_drc_get_integer_value(fp);
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level =
impd_drc_get_float_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.true_peak_level_measurement_system = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].true_peak_level_reliability =
impd_drc_get_integer_value(fp);
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].measurement_count =
impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].measurement_count =
MIN(pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].measurement_count,
MAX_MEASUREMENT_COUNT);
for (m = 0;
m < pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n].measurement_count;
m++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.method_definition = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.method_value = impd_drc_get_float_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.measurement_system = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1_album[n]
.str_loudness_measure[m]
.reliability = impd_drc_get_integer_value(fp);
}
}
/********************* loudness_info_v1 *********************/
pstr_loudness_info_set_ext_eq->loudness_info_v1_count = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->loudness_info_v1_count =
MIN(pstr_loudness_info_set_ext_eq->loudness_info_v1_count, MAX_LOUDNESS_INFO_COUNT);
for (n = 0; n < pstr_loudness_info_set_ext_eq->loudness_info_v1_count; n++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].drc_set_id =
impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].downmix_id =
impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].sample_peak_level_present =
impd_drc_get_integer_value(fp);
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].sample_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].sample_peak_level =
impd_drc_get_float_value(fp);
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level_present =
impd_drc_get_integer_value(fp);
if (pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level_present) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level =
impd_drc_get_float_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.true_peak_level_measurement_system = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].true_peak_level_reliability =
impd_drc_get_integer_value(fp);
}
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].measurement_count =
impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].measurement_count =
MIN(pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].measurement_count,
MAX_MEASUREMENT_COUNT);
for (m = 0; m < pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n].measurement_count;
m++) {
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.method_definition = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.method_value = impd_drc_get_float_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.measurement_system = impd_drc_get_integer_value(fp);
pstr_loudness_info_set_ext_eq->str_loudness_info_v1[n]
.str_loudness_measure[m]
.reliability = impd_drc_get_integer_value(fp);
}
}
}
pstr_enc_gain_extension->uni_drc_gain_ext_present = 0;
}

338
test/encoder/ixheaace_testbench.c
View file

@ -319,9 +319,8 @@ void ia_enhaacplus_enc_print_usage() {
"stream within a set of associated streams."
"\n It is applicable only for AOT 42. Valid values are 0 to 65535. Default is 0.");
printf(
"\n <delay adjustment> is used to discard delay on the decoded file using pre-roll frames"
"on encoder."
"\n It is applicable only for AOT 42. Valid values are 0 and 1. Default is 0.");
"\n <delay adjustment> is used to discard algorithmic delay from the decoded file."
"\n It is applicable only for AOT 42. Valid values are 0 and 1. Default is 1.");
exit(1);
}
@ -498,7 +497,8 @@ static VOID iaace_aac_set_default_config(ixheaace_aac_enc_config *config) {
}
static VOID ixheaace_print_drc_config_params(ixheaace_input_config *pstr_input_config,
ixheaace_input_config *pstr_input_config_user) {
ixheaace_input_config *pstr_input_config_user,
ixheaace_output_config *pstr_output_config) {
WORD32 flag = 0, i, j, k;
ia_drc_input_config *drc_cfg = (ia_drc_input_config *)(pstr_input_config->pv_drc_cfg);
ia_drc_input_config *drc_cfg_user = (ia_drc_input_config *)(pstr_input_config_user->pv_drc_cfg);
@ -510,6 +510,12 @@ static VOID ixheaace_print_drc_config_params(ixheaace_input_config *pstr_input_c
&drc_cfg->str_enc_loudness_info_set;
ia_drc_loudness_info_set_struct *pstr_enc_loudness_info_set_user =
&drc_cfg_user->str_enc_loudness_info_set;
ia_drc_loudness_info_set_ext_eq_struct *pstr_enc_loudness_info_set_ext =
&drc_cfg->str_enc_loudness_info_set.str_loudness_info_set_extension
.str_loudness_info_set_ext_eq;
ia_drc_loudness_info_set_ext_eq_struct *pstr_enc_loudness_info_set_ext_user =
&drc_cfg_user->str_enc_loudness_info_set.str_loudness_info_set_extension
.str_loudness_info_set_ext_eq;
for (i = 0; i < pstr_uni_drc_config->drc_instructions_uni_drc_count; i++) {
if (pstr_uni_drc_config->str_drc_instructions_uni_drc[i].additional_downmix_id_count !=
@ -694,123 +700,258 @@ static VOID ixheaace_print_drc_config_params(ixheaace_input_config *pstr_input_c
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) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i].true_peak_level !=
pstr_enc_loudness_info_set_user->str_loudness_info[i].true_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i].true_peak_level_measurement_system !=
pstr_enc_loudness_info_set_user->str_loudness_info[i]
.true_peak_level_measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i].true_peak_level_reliability !=
pstr_enc_loudness_info_set_user->str_loudness_info[i].true_peak_level_reliability) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i].measurement_count !=
pstr_enc_loudness_info_set_user->str_loudness_info[i].measurement_count) {
flag = 1;
}
for (j = 0; j < pstr_enc_loudness_info_set->str_loudness_info[i].measurement_count; j++) {
if (pstr_enc_loudness_info_set->str_loudness_info[i]
.str_loudness_measure[j]
.method_definition != pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.method_definition) {
if (pstr_output_config->is_loudness_configured) {
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) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i].str_loudness_measure[j].method_value !=
if (pstr_enc_loudness_info_set->str_loudness_info[i].true_peak_level !=
pstr_enc_loudness_info_set_user->str_loudness_info[i].true_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i].true_peak_level_measurement_system !=
pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.method_value) {
.true_peak_level_measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i]
.str_loudness_measure[j]
.measurement_system != pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.measurement_system) {
if (pstr_enc_loudness_info_set->str_loudness_info[i].true_peak_level_reliability !=
pstr_enc_loudness_info_set_user->str_loudness_info[i].true_peak_level_reliability) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i].str_loudness_measure[j].reliability !=
pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.reliability) {
if (pstr_enc_loudness_info_set->str_loudness_info[i].measurement_count !=
pstr_enc_loudness_info_set_user->str_loudness_info[i].measurement_count) {
flag = 1;
}
for (j = 0; j < pstr_enc_loudness_info_set->str_loudness_info[i].measurement_count; j++) {
if (pstr_enc_loudness_info_set->str_loudness_info[i]
.str_loudness_measure[j]
.method_definition != pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.method_definition) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i]
.str_loudness_measure[j]
.method_value != pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.method_value) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i]
.str_loudness_measure[j]
.measurement_system != pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info[i]
.str_loudness_measure[j]
.reliability != pstr_enc_loudness_info_set_user->str_loudness_info[i]
.str_loudness_measure[j]
.reliability) {
flag = 1;
}
}
}
}
if (flag == 1) {
printf("\nDRC : Invalid config str_loudness_info");
flag = 0;
}
for (i = 0; i < pstr_enc_loudness_info_set->loudness_info_album_count; i++) {
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].sample_peak_level !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i].sample_peak_level) {
flag = 1;
if (flag == 1) {
printf("\nDRC : Invalid config str_loudness_info");
flag = 0;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].true_peak_level !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i].true_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.true_peak_level_measurement_system !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.true_peak_level_measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].true_peak_level_reliability !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i].true_peak_level_reliability) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].measurement_count !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i].measurement_count) {
flag = 1;
}
for (j = 0; j < pstr_enc_loudness_info_set->str_loudness_info_album[i].measurement_count;
j++) {
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_definition != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_definition) {
for (i = 0; i < pstr_enc_loudness_info_set->loudness_info_album_count; i++) {
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].sample_peak_level !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i].sample_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].true_peak_level !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i].true_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_value != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_value) {
.true_peak_level_measurement_system !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.true_peak_level_measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.measurement_system != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.measurement_system) {
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].true_peak_level_reliability !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.true_peak_level_reliability) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.reliability != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.reliability) {
if (pstr_enc_loudness_info_set->str_loudness_info_album[i].measurement_count !=
pstr_enc_loudness_info_set_user->str_loudness_info_album[i].measurement_count) {
flag = 1;
}
for (j = 0; j < pstr_enc_loudness_info_set->str_loudness_info_album[i].measurement_count;
j++) {
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_definition != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_definition) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_value != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.method_value) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.measurement_system != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set->str_loudness_info_album[i]
.str_loudness_measure[j]
.reliability != pstr_enc_loudness_info_set_user->str_loudness_info_album[i]
.str_loudness_measure[j]
.reliability) {
flag = 1;
}
}
}
if (flag == 1) {
printf("\nDRC : Invalid config str_loudness_info_album");
}
for (i = 0; i < pstr_enc_loudness_info_set_ext->loudness_info_v1_count; i++) {
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].sample_peak_level !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i].sample_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].true_peak_level !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i].true_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.true_peak_level_measurement_system !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i]
.true_peak_level_measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].true_peak_level_reliability !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i]
.true_peak_level_reliability) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].measurement_count !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i].measurement_count) {
flag = 1;
}
for (j = 0; j < pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i].measurement_count;
j++) {
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.method_definition != pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i]
.str_loudness_measure[j]
.method_definition) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.method_value != pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i]
.str_loudness_measure[j]
.method_value) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.measurement_system !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i]
.str_loudness_measure[j]
.measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1[i]
.str_loudness_measure[j]
.reliability != pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1[i]
.str_loudness_measure[j]
.reliability) {
flag = 1;
}
}
}
if (flag == 1) {
printf("\nDRC : Invalid config str_loudness_info_v1");
flag = 0;
}
for (i = 0; i < pstr_enc_loudness_info_set_ext->loudness_info_v1_album_count; i++) {
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].sample_peak_level !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i].sample_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].true_peak_level !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i].true_peak_level) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.true_peak_level_measurement_system !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i]
.true_peak_level_measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.true_peak_level_reliability !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i]
.true_peak_level_reliability) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].measurement_count !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i].measurement_count) {
flag = 1;
}
for (j = 0;
j < pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i].measurement_count;
j++) {
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.method_definition !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.method_definition) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.method_value !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.method_value) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.measurement_system !=
pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.measurement_system) {
flag = 1;
}
if (pstr_enc_loudness_info_set_ext->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.reliability != pstr_enc_loudness_info_set_ext_user->str_loudness_info_v1_album[i]
.str_loudness_measure[j]
.reliability) {
flag = 1;
}
}
}
if (flag == 1) {
printf("\nDRC : Invalid config str_loudness_info_v1_album");
}
}
if (flag == 1) {
printf("\nDRC : Invalid config str_loudness_info_album");
}
}
static VOID ixheaace_print_config_params(ixheaace_input_config *pstr_input_config,
ixheaace_input_config *pstr_input_config_user) {
ixheaace_input_config *pstr_input_config_user,
ixheaace_output_config *pstr_output_config) {
printf(
"\n*************************************************************************************"
"***********\n");
@ -1014,7 +1155,8 @@ static VOID ixheaace_print_config_params(ixheaace_input_config *pstr_input_confi
}
if (pstr_input_config->use_drc_element) {
printf("\nDRC : 1");
ixheaace_print_drc_config_params(pstr_input_config, pstr_input_config_user);
ixheaace_print_drc_config_params(pstr_input_config, pstr_input_config_user,
pstr_output_config);
}
if (pstr_input_config->random_access_interval !=
@ -1370,7 +1512,7 @@ IA_ERRORCODE ia_enhaacplus_enc_main_process(ixheaace_app_context *pstr_context,
pb_inp_buf = (pWORD8)pstr_out_cfg->mem_info_table[IA_MEMTYPE_INPUT].mem_ptr;
pb_out_buf = (pWORD8)pstr_out_cfg->mem_info_table[IA_MEMTYPE_OUTPUT].mem_ptr;
ixheaace_print_config_params(pstr_in_cfg, &pstr_in_cfg_user);
ixheaace_print_config_params(pstr_in_cfg, &pstr_in_cfg_user, pstr_out_cfg);
if (pstr_drc_cfg_user) {
free_global(pstr_drc_cfg_user);