diff --git a/.gitignore b/.gitignore index c87c691a4af7f6c50a681db4a373b100e84c7558..52512506d7ea2d862997249c9557810148623e3a 100644 --- a/.gitignore +++ b/.gitignore @@ -72,3 +72,15 @@ Externals/ # coan output files that are created when cleaning out switches coan_out_* +/COMPLEXITY +/res +/tv +/wmops +/Workspace_msvc/renderer.args.json +/Workspace_msvc/encoder.args.json +/Workspace_msvc/decoder.args.json +/scripts/mem_analysis_enc_VBR_5k9.csv +/scripts/mem_analysis_enc_STEREO_sw.png +/scripts/mem_analysis_enc_STEREO_sw.csv +/scripts/mem_analysis_enc_STEREO_16k4_DTX.csv +*.pwv diff --git a/lib_com/bitstream.c b/lib_com/bitstream.c index 886509b5ac96d65923b4f13872021fd74414c2f2..86e1615d5a5a549ba4f4d7e59112b51cf7c195bc 100644 --- a/lib_com/bitstream.c +++ b/lib_com/bitstream.c @@ -62,6 +62,11 @@ FILE *FEC_pattern = NULL; /* FEC pattern file (for simulation of FEC) */ #endif +#ifdef IND_LIST_DYN +#define STEP_MAX_NUM_INDICES 100 /* increase the maximum number of allowed indices in the list by this amount */ +#endif + +#ifndef IND_LIST_DYN /*-------------------------------------------------------------------* * pack_bit() * @@ -113,106 +118,855 @@ static Word16 unpack_bit( ( *pt )++; } - return bit; + return bit; +} +#endif + +/*-------------------------------------------------------------------* + * rate2AMRWB_IOmode() + * + * lookup AMRWB IO mode + *-------------------------------------------------------------------*/ + +static Word16 rate2AMRWB_IOmode( + Word32 brate /* i : bitrate */ +) +{ + switch ( brate ) + { + /* EVS AMR-WB IO modes */ + case SID_1k75: + return AMRWB_IO_SID; + case ACELP_6k60: + return AMRWB_IO_6600; + case ACELP_8k85: + return AMRWB_IO_8850; + case ACELP_12k65: + return AMRWB_IO_1265; + case ACELP_14k25: + return AMRWB_IO_1425; + case ACELP_15k85: + return AMRWB_IO_1585; + case ACELP_18k25: + return AMRWB_IO_1825; + case ACELP_19k85: + return AMRWB_IO_1985; + case ACELP_23k05: + return AMRWB_IO_2305; + case ACELP_23k85: + return AMRWB_IO_2385; + default: + break; + } + + return -1; +} + +/*-------------------------------------------------------------------* + * rate2EVSmode() + * + * lookup EVS mode + *-------------------------------------------------------------------*/ +Word16 rate2EVSmode( + const Word32 brate, /* i : bitrate */ + int16_t *is_amr_wb /* o : (flag) does the bitrate belong to AMR-WB? Can be NULL */ +) +{ + if ( is_amr_wb != NULL ) + { + *is_amr_wb = 0; + } + + switch ( brate ) + { + /* EVS Primary modes */ + case FRAME_NO_DATA: + return NO_DATA_RECEIVED; + case SID_2k40: + return PRIMARY_SID; + case PPP_NELP_2k80: + return PRIMARY_2800; + case ACELP_7k20: + return PRIMARY_7200; + case ACELP_8k00: + return PRIMARY_8000; + case ACELP_9k60: + return PRIMARY_9600; + case ACELP_13k20: + return PRIMARY_13200; + case ACELP_16k40: + return PRIMARY_16400; + case ACELP_24k40: + return PRIMARY_24400; + case ACELP_32k: + return PRIMARY_32000; + case ACELP_48k: + return PRIMARY_48000; + case ACELP_64k: + return PRIMARY_64000; + case HQ_96k: + return PRIMARY_96000; + case HQ_128k: + return PRIMARY_128000; + default: + break; + } + + if ( is_amr_wb != NULL ) + { + *is_amr_wb = 1; + } + + return rate2AMRWB_IOmode( brate ); +} + +#ifdef IND_LIST_DYN +/*-------------------------------------------------------------------* + * ind_list_realloc() + * + * Re-allocate the list of indices + *-------------------------------------------------------------------*/ + +ivas_error ind_list_realloc( + BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */ + int16_t max_num_indices /* i : new maximum number of allowed indices in the list */ +) +{ + int16_t i, ind_list_pos; + INDICE_HANDLE new_ind_list; + + /* allocate new buffer of indices */ + if ( ( new_ind_list = (INDICE_HANDLE) malloc( max_num_indices * sizeof( Indice ) ) ) == NULL ) + { + return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for buffer of indices!\n" ) ); + } + + /* move indices from the old list to the new list */ + for ( i = 0; i < min( max_num_indices, *( hBstr->ivas_max_num_indices ) ); i++ ) + { + if ( ( *hBstr->ivas_ind_list_zero )[i].nb_bits > -1 ) + { + new_ind_list[i].id = ( *hBstr->ivas_ind_list_zero )[i].id; + new_ind_list[i].value = ( *hBstr->ivas_ind_list_zero )[i].value; + } + new_ind_list[i].nb_bits = ( *hBstr->ivas_ind_list_zero )[i].nb_bits; + } + + /* reset nb_bits of all other indices to -1 */ + for ( ; i < max_num_indices; i++ ) + { + new_ind_list[i].nb_bits = -1; + } + + /* get the current position inside the old list */ + ind_list_pos = (int16_t) ( hBstr->ind_list - ( *hBstr->ivas_ind_list_zero ) ); + + /* free the old list */ + free( ( *hBstr->ivas_ind_list_zero ) ); + + /* set pointers in the new list */ + hBstr->ind_list = &new_ind_list[ind_list_pos]; + *( hBstr->ivas_ind_list_zero ) = new_ind_list; + + /* set the new maximum number of indices */ + *( hBstr->ivas_max_num_indices ) = max_num_indices; + + return IVAS_ERR_OK; +} + + +/*-----------------------------------------------------------------------* + * get_ivas_max_num_indices() + * + * Get the maximum allowed number of indices in the encoder + *-----------------------------------------------------------------------*/ + +int16_t get_ivas_max_num_indices( /* o : maximum number of indices */ + const IVAS_FORMAT ivas_format, /* i : IVAS format */ + const int32_t ivas_total_brate /* i : IVAS total bitrate */ +) +{ + if ( ivas_format == STEREO_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 300; + } + else if ( ivas_total_brate <= IVAS_24k4 ) + { + return 400; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 450; + } + else if ( ivas_total_brate <= IVAS_48k ) + { + return 650; + } + else if ( ivas_total_brate <= IVAS_80k ) + { + return 750; + } + else if ( ivas_total_brate <= IVAS_128k ) + { + return 850; + } + else if ( ivas_total_brate <= IVAS_192k ) + { + return 950; + } + else if ( ivas_total_brate <= IVAS_256k ) + { + return 1350; + } + else + { + return 1650; + } + } + else if ( ivas_format == ISM_FORMAT || ivas_format == MONO_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 250; + } + else if ( ivas_total_brate <= IVAS_24k4 ) + { + return 350; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 450; + } + else if ( ivas_total_brate <= IVAS_48k ) + { + return 550; + } + else if ( ivas_total_brate <= IVAS_64k ) + { + return 620; + } + else if ( ivas_total_brate <= IVAS_80k ) + { + return 670; + } + else if ( ivas_total_brate <= IVAS_96k ) + { + return 780; + } + else if ( ivas_total_brate <= IVAS_128k ) + { + return 880; + } + else if ( ivas_total_brate <= IVAS_192k ) + { + return 950; + } + else if ( ivas_total_brate <= IVAS_256k ) + { + return 1100; + } + else if ( ivas_total_brate <= IVAS_384k ) + { + return 1300; + } + else + { + return 1650; + } + } + else if ( ivas_format == SBA_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 250; + } + else if ( ivas_total_brate <= IVAS_24k4 ) + { + return 350; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 400; + } + else if ( ivas_total_brate <= IVAS_48k ) + { + return 650; + } + else if ( ivas_total_brate <= IVAS_80k ) + { + return 750; + } + else if ( ivas_total_brate <= IVAS_128k ) + { + return 1020; + } + else if ( ivas_total_brate <= IVAS_160k ) + { + return 1160; + } + else if ( ivas_total_brate <= IVAS_192k ) + { + return 1220; + } + else if ( ivas_total_brate <= IVAS_256k ) + { + return 1300; + } + else if ( ivas_total_brate <= IVAS_384k ) + { + return 1720; + } + else + { + return 2000; + } + } + else if ( ivas_format == MASA_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 300; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 400; + } + else if ( ivas_total_brate <= IVAS_48k ) + { + return 650; + } + else if ( ivas_total_brate <= IVAS_80k ) + { + return 750; + } + else if ( ivas_total_brate <= IVAS_160k ) + { + return 850; + } + else if ( ivas_total_brate <= IVAS_192k ) + { + return 950; + } + else if ( ivas_total_brate <= IVAS_256k ) + { + return 1150; + } + else if ( ivas_total_brate <= IVAS_384k ) + { + return 1450; + } + else + { + return 1650; + } + } + else if ( ivas_format == MC_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 250; + } + else if ( ivas_total_brate <= IVAS_24k4 ) + { + return 350; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 400; + } + else if ( ivas_total_brate <= IVAS_48k ) + { + return 650; + } + else if ( ivas_total_brate <= IVAS_64k ) + { + return 750; + } + else if ( ivas_total_brate <= IVAS_80k ) + { + return 850; + } + else if ( ivas_total_brate <= IVAS_128k ) + { + return 1150; + } + else if ( ivas_total_brate <= IVAS_160k ) + { + return 1420; + } + else if ( ivas_total_brate <= IVAS_256k ) + { + return 2120; + } + else if ( ivas_total_brate <= IVAS_384k ) + { + return 2250; + } + else + { + return 2450; + } + } + + return 2450; +} + +/*-----------------------------------------------------------------------* + * get_core_max_num_indices() + * + * Get the maximum allowed number of indices in the core coder + *-----------------------------------------------------------------------*/ + +int16_t get_core_max_num_indices( /* o : maximum number of indices */ + const int16_t core, /* i : core */ + const int32_t total_brate /* i : total bitrate */ +) +{ + /* set the maximum number of indices in the core coder */ + if ( core == ACELP_CORE || core == AMR_WB_CORE ) + { + if ( total_brate <= 9600 ) + { + return 60; + } + else if ( total_brate <= IVAS_13k2 ) + { + return 70; + } + else if ( total_brate <= IVAS_16k4 ) + { + return 80; + } + else if ( total_brate <= IVAS_24k4 ) + { + return 100; + } + else if ( total_brate <= IVAS_32k ) + { + return 180; + } + else if ( total_brate <= IVAS_48k ) + { + return 340; + } + else if ( total_brate <= IVAS_80k ) + { + return 450; + } + else if ( total_brate <= IVAS_96k ) + { + return 500; + } + else if ( total_brate <= IVAS_128k ) + { + return 550; + } + else if ( total_brate <= IVAS_160k ) + { + return 600; + } + else if ( total_brate <= IVAS_192k ) + { + return 650; + } + else if ( total_brate <= IVAS_256k ) + { + return 700; + } + else + { + return 800; + } + } + else if ( core == TCX_20_CORE || core == TCX_10_CORE ) + { + if ( total_brate <= 9600 ) + { + return 100; + } + else if ( total_brate <= IVAS_13k2 ) + { + return 150; + } + else if ( total_brate <= IVAS_16k4 ) + { + return 200; + } + else if ( total_brate <= IVAS_24k4 ) + { + return 310; + } + else if ( total_brate <= IVAS_32k ) + { + return 330; + } + else if ( total_brate <= IVAS_48k ) + { + return 340; + } + else if ( total_brate <= IVAS_80k ) + { + return 380; + } + else if ( total_brate <= IVAS_96k ) + { + return 400; + } + else if ( total_brate <= IVAS_128k ) + { + return 460; + } + else if ( total_brate <= IVAS_160k ) + { + return 470; + } + else if ( total_brate <= IVAS_192k ) + { + return 570; + } + else if ( total_brate <= IVAS_256k ) + { + return 680; + } + else + { + return 800; + } + } + else if ( core == HQ_CORE ) + { + if ( total_brate <= 9600 ) + { + return 100; + } + else if ( total_brate <= IVAS_16k4 ) + { + return 200; + } + else if ( total_brate <= IVAS_24k4 ) + { + return 240; + } + else if ( total_brate <= IVAS_32k ) + { + return 300; + } + else if ( total_brate <= IVAS_48k ) + { + return 380; + } + else if ( total_brate <= IVAS_96k ) + { + return 400; + } + else if ( total_brate <= IVAS_128k ) + { + return 450; + } + else if ( total_brate <= IVAS_160k ) + { + return 550; + } + else if ( total_brate <= IVAS_192k ) + { + return 600; + } + else if ( total_brate <= IVAS_256k ) + { + return 700; + } + else + { + return 800; + } + } + else + { + return 50; + } +} + +/*-----------------------------------------------------------------------* + * get_BWE_max_num_indices() + * + * Get the maximum number of indices in the BWE + *-----------------------------------------------------------------------*/ + +int16_t get_BWE_max_num_indices( /* o : maximum number of indices */ + const int32_t extl_brate /* i : extensiona layer bitrate */ +) +{ + /* set the maximum number of indices in the BWE */ + if ( extl_brate < SWB_BWE_16k ) + { + return 30; + } + else + { + return 150; + } +} + + +/*-----------------------------------------------------------------------* + * get_ivas_max_num_indices_metadata() + * + * Set the maximum allowed number of metadata indices in the list + *-----------------------------------------------------------------------*/ + +int16_t get_ivas_max_num_indices_metadata( /* o : maximum number of indices */ + const IVAS_FORMAT ivas_format, /* i : IVAS format */ + const int32_t ivas_total_brate /* i : IVAS total bitrate */ +) +{ + /* set the maximum required number of metadata indices */ + if ( ivas_format == MONO_FORMAT ) + { + return 0; + } + else if ( ivas_format == STEREO_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 60; + } + else + { + return 80; + } + } + else if ( ivas_format == ISM_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 20; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 65; + } + else + { + return 80; + } + } + else if ( ivas_format == SBA_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 100; + } + else if ( ivas_total_brate <= IVAS_24k4 ) + { + return 200; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 300; + } + else if ( ivas_total_brate <= IVAS_192k ) + { + return 500; + } + else if ( ivas_total_brate <= IVAS_256k ) + { + return 1000; + } + else if ( ivas_total_brate <= IVAS_384k ) + { + return 1500; + } + else + { + return 2000; + } + } + else if ( ivas_format == MASA_FORMAT ) + { + if ( ivas_total_brate <= IVAS_16k4 ) + { + return 80; + } + else if ( ivas_total_brate <= IVAS_32k ) + { + return 110; + } + else if ( ivas_total_brate <= IVAS_48k ) + { + return 180; + } + else if ( ivas_total_brate <= IVAS_96k ) + { + return 200; + } + else if ( ivas_total_brate <= IVAS_128k ) + { + return 250; + } + else if ( ivas_total_brate <= IVAS_160k ) + { + return 320; + } + else if ( ivas_total_brate <= IVAS_192k ) + { + return 430; + } + else if ( ivas_total_brate <= IVAS_256k ) + { + return 600; + } + else if ( ivas_total_brate <= IVAS_384k ) + { + return 1000; + } + else + { + return 1500; + } + } + else if ( ivas_format == MC_FORMAT ) + { + if ( ivas_total_brate <= IVAS_13k2 ) + { + return 80; + } + else if ( ivas_total_brate <= IVAS_24k4 ) + { + return 100; + } + else if ( ivas_total_brate <= IVAS_64k ) + { + return 200; + } + else if ( ivas_total_brate <= IVAS_96k ) + { + return 220; + } + else + { + return 300; + } + } + + return 50; } /*-------------------------------------------------------------------* - * rate2AMRWB_IOmode() + * move_indices() * - * lookup AMRWB IO mode + * Move indices inside the buffer or among two buffers *-------------------------------------------------------------------*/ -static Word16 rate2AMRWB_IOmode( - Word32 brate /* i : bitrate */ +ivas_error move_indices( + INDICE_HANDLE old_ind_list, /* i/o: old location of indices */ + INDICE_HANDLE new_ind_list, /* i/o: new location of indices */ + const int16_t nb_indices /* i : number of moved indices */ ) { - switch ( brate ) + int16_t i; + ivas_error error; + + error = IVAS_ERR_OK; + + if ( new_ind_list < old_ind_list ) { - /* EVS AMR-WB IO modes */ - case SID_1k75: - return AMRWB_IO_SID; - case ACELP_6k60: - return AMRWB_IO_6600; - case ACELP_8k85: - return AMRWB_IO_8850; - case ACELP_12k65: - return AMRWB_IO_1265; - case ACELP_14k25: - return AMRWB_IO_1425; - case ACELP_15k85: - return AMRWB_IO_1585; - case ACELP_18k25: - return AMRWB_IO_1825; - case ACELP_19k85: - return AMRWB_IO_1985; - case ACELP_23k05: - return AMRWB_IO_2305; - case ACELP_23k85: - return AMRWB_IO_2385; - default: - break; + for ( i = 0; i < nb_indices; i++ ) + { + new_ind_list[i].id = old_ind_list[i].id; + new_ind_list[i].value = old_ind_list[i].value; + new_ind_list[i].nb_bits = old_ind_list[i].nb_bits; + + old_ind_list[i].nb_bits = -1; + } } + else if ( new_ind_list > old_ind_list ) + { + for ( i = nb_indices - 1; i >= 0; i-- ) + { + new_ind_list[i].id = old_ind_list[i].id; + new_ind_list[i].value = old_ind_list[i].value; + new_ind_list[i].nb_bits = old_ind_list[i].nb_bits; - return -1; + old_ind_list[i].nb_bits = -1; + } + } + + return error; } +#endif + +#ifdef IND_LIST_DYN /*-------------------------------------------------------------------* - * rate2EVSmode() + * check_ind_list_limits() * - * lookup EVS mode + * Check, if the maximum number of indices has been reached -> reallocate + * Check, if we will not overwrite an existing indice -> adjust the location *-------------------------------------------------------------------*/ -Word16 rate2EVSmode( - const Word32 brate, /* i : bitrate */ - int16_t *is_amr_wb /* o : (flag) does the bitrate belong to AMR-WB? Can be NULL */ + +ivas_error check_ind_list_limits( + BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */ ) { - if ( is_amr_wb != NULL ) - { - *is_amr_wb = 0; - } + Indice *ivas_ind_list_zero, *ivas_ind_list_last; + ivas_error error; - switch ( brate ) + error = IVAS_ERR_OK; + ivas_ind_list_zero = *( hBstr->ivas_ind_list_zero ); + + /* check, if the maximum number of indices has been reached and re-allocate the buffer */ + /* the re-allocation can be avoided by increasing the limits in get_ivas_max_num_indices() or get_ivas_max_num_indices_metadata() */ + if ( ( &hBstr->ind_list[hBstr->nb_ind_tot] - ivas_ind_list_zero ) >= *( hBstr->ivas_max_num_indices ) ) { - /* EVS Primary modes */ - case FRAME_NO_DATA: - return NO_DATA_RECEIVED; - case SID_2k40: - return PRIMARY_SID; - case PPP_NELP_2k80: - return PRIMARY_2800; - case ACELP_7k20: - return PRIMARY_7200; - case ACELP_8k00: - return PRIMARY_8000; - case ACELP_9k60: - return PRIMARY_9600; - case ACELP_13k20: - return PRIMARY_13200; - case ACELP_16k40: - return PRIMARY_16400; - case ACELP_24k40: - return PRIMARY_24400; - case ACELP_32k: - return PRIMARY_32000; - case ACELP_48k: - return PRIMARY_48000; - case ACELP_64k: - return PRIMARY_64000; - case HQ_96k: - return PRIMARY_96000; - case HQ_128k: - return PRIMARY_128000; - default: - break; +#ifdef DEBUGGING + /* TODO: replace with the warning message below before the finalization of the IVAS codec */ + /* fprintf( stderr, "Warning: The maximum number of indices %d has been exceeded in frame %d! Increase the limits in get_ivas_max_num_indices() or get_max_num_indices_metadata().\n", *( hBstr->ivas_max_num_indices ), frame ); */ + assert( 0 && "The maximum number of indices has been exceeded! Increase the limits in get_ivas_max_num_indices() or get_max_num_indices_metadata()." ); +#endif + + /* reallocate the buffer of indices with increased limit */ + ind_list_realloc( hBstr, *( hBstr->ivas_max_num_indices ) + STEP_MAX_NUM_INDICES ); } - if ( is_amr_wb != NULL ) + /* check, if we will not overwrite an existing indice */ + if ( hBstr->ind_list[hBstr->nb_ind_tot].nb_bits > 0 ) { - *is_amr_wb = 1; + if ( hBstr->nb_ind_tot == 0 ) + { +#ifdef DEBUGGING + fprintf( stderr, "Warning: Trying to overwrite an existing indice ID = %d in frame %d!\n", hBstr->ind_list[hBstr->nb_ind_tot].id, frame ); +#endif + /* move the pointer to the next available empty slot */ + ivas_ind_list_last = &ivas_ind_list_zero[*( hBstr->ivas_max_num_indices )]; + while ( hBstr->ind_list[0].nb_bits > 0 && hBstr->ind_list < ivas_ind_list_last ) + { + hBstr->ind_list++; + } + + if ( hBstr->ind_list >= ivas_ind_list_last ) + { +#ifdef DEBUGGING + /* TODO: replace with the warning message below before the finalization of the IVAS codec */ + /* fprintf( stderr, "Warning: The maximum number of indices %d has been exceeded in frame %d! Increase the limits in get_ivas_max_num_indices() or get_max_num_indices_metadata().\n", *( hBstr->ivas_max_num_indices ), frame ); */ + assert( 0 && "The maximum number of indices has been exceeded! Increase the limits in get_ivas_max_num_indices() or get_max_num_indices_metadata()." ); +#endif + + /* no available empty slot -> need to re-allocate the buffer */ + ind_list_realloc( hBstr, *( hBstr->ivas_max_num_indices ) + STEP_MAX_NUM_INDICES ); + } + } + else + { + return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Buffer of indices corrupted in frame %d! Attempt to overwrite indice ID = %d (value: %d, bits: %d)!\n", frame, hBstr->ind_list[hBstr->nb_ind_tot].id, hBstr->ind_list[hBstr->nb_ind_tot].value, hBstr->ind_list[hBstr->nb_ind_tot].nb_bits ); + } } - return rate2AMRWB_IOmode( brate ); + return error; } +#endif + /*-------------------------------------------------------------------* * push_indice() @@ -237,6 +991,9 @@ ivas_error push_indice( ) { int16_t i; +#ifdef IND_LIST_DYN + int16_t j; +#endif ivas_error error; error = IVAS_ERR_OK; @@ -250,6 +1007,7 @@ ivas_error push_indice( return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice ID = %d with value %d exceeds the range of %d bits (frame %d) !\n", id, value, nb_bits, frame ); } +#ifndef IND_LIST_DYN #if 0 /* mul, 2020-11-19: to be de-activated until proper solution found */ if ( nb_bits < 1 ) @@ -257,18 +1015,45 @@ ivas_error push_indice( return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, " Trying to push indice ID = %d with value %d that has %d bits (frame %d) !\n", id, value, nb_bits, frame ); } else +#endif #endif if ( nb_bits > 16 ) { return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice ID = %d with value %d is trying to allocate %d bits which exceeds 16 bits (frame %d) !\n", id, value, nb_bits, frame ); } +#ifndef IND_LIST_DYN if ( id >= MAX_NUM_INDICES ) { return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice ID = %d exceeds the total number of indices: %d (frame %d) !\n", id, MAX_NUM_INDICES, frame ); } #endif +#endif + +#ifdef IND_LIST_DYN + /* check the limits of the list of indices */ + error = check_ind_list_limits( hBstr ); +#endif + +#ifdef IND_LIST_DYN + /* find the location in the list of indices based on ID */ + i = hBstr->nb_ind_tot; + while ( i > 0 && id < hBstr->ind_list[i - 1].id ) + { + i--; + } + /* shift indices, if the new ID is to be written somewhere inside the list */ + if ( i < hBstr->nb_ind_tot ) + { + for ( j = hBstr->nb_ind_tot; j > i; j-- ) + { + hBstr->ind_list[j].id = hBstr->ind_list[j - 1].id; + hBstr->ind_list[j].nb_bits = hBstr->ind_list[j - 1].nb_bits; + hBstr->ind_list[j].value = hBstr->ind_list[j - 1].value; + } + } +#else if ( hBstr->last_ind == id ) { /* indice with the same name as the previous one */ @@ -283,21 +1068,31 @@ ivas_error push_indice( i++; } } +#endif +#ifndef IND_LIST_DYN #ifdef DEBUGGING if ( hBstr->ind_list[i].nb_bits > 0 ) { return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice ID = %d with value %d is trying to re-write an existing indice (frame %d) !\n", id, value, frame ); } +#endif #endif /* store the new indice in the list */ +#ifdef IND_LIST_DYN + hBstr->ind_list[i].id = id; +#endif hBstr->ind_list[i].value = value; hBstr->ind_list[i].nb_bits = nb_bits; /* updates */ +#ifdef IND_LIST_DYN + hBstr->nb_ind_tot++; +#else hBstr->next_ind = i + 1; hBstr->last_ind = id; +#endif hBstr->nb_bits_tot += nb_bits; return error; @@ -324,6 +1119,9 @@ ivas_error push_next_indice( #endif ) { +#ifdef IND_LIST_DYN + int16_t prev_id; +#endif ivas_error error; error = IVAS_ERR_OK; @@ -342,6 +1140,7 @@ ivas_error push_next_indice( return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice with value %d is trying to allocate %d bits which exceeds 16 bits !\n", value, nb_bits ); } +#ifndef IND_LIST_DYN if ( hBstr->next_ind >= MAX_NUM_INDICES ) { return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Total number of indices exceeded: %d !\n", MAX_NUM_INDICES ); @@ -352,16 +1151,43 @@ ivas_error push_next_indice( return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice with value %d is trying to re-write an existing indice (frame %d) !\n", value, frame ); } #endif +#endif + +#ifdef IND_LIST_DYN + /* check the limits of the list of indices */ + error = check_ind_list_limits( hBstr ); +#endif + +#ifdef IND_LIST_DYN + /* get the id of the previous indice -> it will be re-used */ + if ( hBstr->nb_ind_tot > 0 ) + { + prev_id = hBstr->ind_list[hBstr->nb_ind_tot - 1].id; + } + else + { + prev_id = 0; + } +#endif /* store the values in the list */ +#ifdef IND_LIST_DYN + hBstr->ind_list[hBstr->nb_ind_tot].id = prev_id; + hBstr->ind_list[hBstr->nb_ind_tot].value = value; + hBstr->ind_list[hBstr->nb_ind_tot].nb_bits = nb_bits; +#else hBstr->ind_list[hBstr->next_ind].value = value; hBstr->ind_list[hBstr->next_ind].nb_bits = nb_bits; - hBstr->next_ind++; +#endif - /* update the total number of bits already written */ + /* updates */ +#ifdef IND_LIST_DYN + hBstr->nb_ind_tot++; +#else + hBstr->next_ind++; +#endif hBstr->nb_bits_tot += nb_bits; - return error; } @@ -389,39 +1215,161 @@ void push_next_bits( uint16_t code; int16_t i, nb_bits_m15; Indice *ptr; +#ifdef IND_LIST_DYN + int16_t prev_id; +#endif #ifdef DEBUG_BS_READ_WRITE printf( "%s: %d: %d\n", func, line, nb_bits ); #endif + +#ifdef IND_LIST_DYN + ptr = &hBstr->ind_list[hBstr->nb_ind_tot]; + + /* get the id of the previous indice -> will be re-used */ + if ( hBstr->nb_ind_tot > 0 ) + { + prev_id = hBstr->ind_list[hBstr->nb_ind_tot - 1].id; + } + else + { + prev_id = 0; + } +#else ptr = &hBstr->ind_list[hBstr->next_ind]; +#endif nb_bits_m15 = nb_bits - 15; for ( i = 0; i < nb_bits_m15; i += 16 ) { code = (uint16_t) ( ( bits[i] << 15 ) | ( ( bits[i + 1] << 14 ) | ( ( bits[i + 2] << 13 ) | ( ( bits[i + 3] << 12 ) | ( ( bits[i + 4] << 11 ) | ( ( bits[i + 5] << 10 ) | ( ( bits[i + 6] << 9 ) | ( ( bits[i + 7] << 8 ) | ( ( bits[i + 8] << 7 ) | ( ( bits[i + 9] << 6 ) | ( ( bits[i + 10] << 5 ) | ( ( bits[i + 11] << 4 ) | ( ( bits[i + 12] << 3 ) | ( ( bits[i + 13] << 2 ) | ( ( bits[i + 14] << 1 ) | bits[i + 15] ) ) ) ) ) ) ) ) ) ) ) ) ) ) ); +#ifdef IND_LIST_DYN + /* check the limits of the list of indices */ + check_ind_list_limits( hBstr ); + ptr = &hBstr->ind_list[hBstr->nb_ind_tot]; +#endif + ptr->value = code; #ifdef DEBUG_BS_READ_WRITE printf( "code: %d\n", code ); #endif ptr->nb_bits = 16; +#ifdef IND_LIST_DYN + ptr->id = prev_id; + hBstr->nb_ind_tot++; +#endif ++ptr; } + for ( ; i < nb_bits; ++i ) { +#ifdef IND_LIST_DYN + /* check the limits of the list of indices */ + check_ind_list_limits( hBstr ); + ptr = &hBstr->ind_list[hBstr->nb_ind_tot]; +#endif + ptr->value = bits[i]; #ifdef DEBUG_BS_READ_WRITE printf( "value: %d\n", ptr->value ); #endif ptr->nb_bits = 1; +#ifdef IND_LIST_DYN + ptr->id = prev_id; + hBstr->nb_ind_tot++; +#endif ++ptr; } + +#ifndef IND_LIST_DYN hBstr->next_ind = (int16_t) ( ptr - hBstr->ind_list ); +#endif hBstr->nb_bits_tot = hBstr->nb_bits_tot + nb_bits; return; } +#ifdef IND_LIST_DYN +/*-------------------------------------------------------------------* + * find_indice() + * + * Find indice based on its id + *-------------------------------------------------------------------*/ + +/*! r: result: index of the indice in the list, -1 if not found */ +int16_t find_indice( + BSTR_ENC_HANDLE hBstr, /* i : encoder bitstream handle */ + int16_t id, /* i : ID of the indice */ + uint16_t *value, /* o : value of the quantized indice */ + int16_t *nb_bits /* o : number of bits used to quantize the indice */ +) +{ + int16_t i; + + for ( i = 0; i < hBstr->nb_ind_tot; i++ ) + { + if ( hBstr->ind_list[i].id == id && hBstr->ind_list[i].nb_bits > 0 ) + { + *value = hBstr->ind_list[i].value; + *nb_bits = hBstr->ind_list[i].nb_bits; + return i; + } + } + + return -1; +} + +/*-------------------------------------------------------------------* + * delete_indice() + * + * Delete indice based on its id (note, that nb_ind_tot and nb_bits_tot are updated) + *-------------------------------------------------------------------*/ + +/*! r: number of deleted indices */ +uint16_t delete_indice( + BSTR_ENC_HANDLE hBstr, /* i : encoder bitstream handle */ + int16_t id /* i : ID of the indice */ +) +{ + int16_t i, j; + + j = 0; + for ( i = 0; i < hBstr->nb_ind_tot; i++ ) + { + if ( hBstr->ind_list[i].id == id ) + { + hBstr->nb_bits_tot -= hBstr->ind_list[i].nb_bits; + continue; + } + + if ( j < i ) + { + /* shift the indice left */ + hBstr->ind_list[j].id = hBstr->ind_list[i].id; + hBstr->ind_list[j].value = hBstr->ind_list[i].value; + hBstr->ind_list[j].nb_bits = hBstr->ind_list[i].nb_bits; + } + + j++; + } + + hBstr->nb_ind_tot = j; +#ifndef IND_LIST_DYN + hBstr->next_ind = j; +#endif + + for ( ; j < i; j++ ) + { + /* reset the shifted indices at the end of the list */ + hBstr->ind_list[j].nb_bits = -1; + } + + return i - j; +} +#endif + + /*-------------------------------------------------------------------* * get_next_indice() * @@ -638,8 +1586,12 @@ void reset_indices_enc( int16_t i; hBstr->nb_bits_tot = 0; +#ifdef IND_LIST_DYN + hBstr->nb_ind_tot = 0; +#else hBstr->next_ind = 0; hBstr->last_ind = -1; +#endif for ( i = 0; i < max_num_indices; i++ ) { @@ -670,7 +1622,11 @@ void reset_indices_dec( *-------------------------------------------------------------------*/ static int16_t write_indices_to_stream( +#ifdef IND_LIST_DYN + Indice *ind_list, +#else Indice *ind_list_metadata, +#endif uint16_t **pt_stream, const int16_t inc, const int16_t num_indices ) @@ -684,8 +1640,13 @@ static int16_t write_indices_to_stream( for ( i = 0; i < num_indices; i++ ) { +#ifdef IND_LIST_DYN + value = ind_list[i].value; + nb_bits = ind_list[i].nb_bits; +#else value = ind_list_metadata[i].value; nb_bits = ind_list_metadata[i].nb_bits; +#endif if ( nb_bits > 0 ) { @@ -717,6 +1678,10 @@ static int16_t write_indices_to_stream( { /* fprintf( stderr, "Warning: %s: nb_bits == 0!\n", __func__ ); */ } + else + { + /* fprintf( stderr, "Warning: %s: nb_bits == %d!\n", __func__, nb_bits ); */ + } #endif } #ifdef ENABLE_BITRATE_VERIFICATION @@ -745,6 +1710,10 @@ static ivas_error write_indices_element( uint16_t *pt_stream_backup; uint16_t *pt_stream_end; int16_t nb_bits_tot_metadata; +#ifdef IND_LIST_DYN + int16_t nb_ind_tot_metadata; +#endif + Indice *ind_list_metadata; int16_t n, n_channels; #ifdef ENABLE_BITRATE_VERIFICATION @@ -755,6 +1724,9 @@ static ivas_error write_indices_element( error = IVAS_ERR_OK; ind_list_metadata = NULL; +#ifdef IND_LIST_DYN + nb_ind_tot_metadata = 0; +#endif if ( st_ivas->hEncoderConfig->ivas_format == MONO_FORMAT ) { @@ -772,6 +1744,9 @@ static ivas_error write_indices_element( { nb_bits_tot_metadata = st_ivas->hSCE[element_id]->hMetaData->nb_bits_tot; ind_list_metadata = st_ivas->hSCE[element_id]->hMetaData->ind_list; +#ifdef IND_LIST_DYN + nb_ind_tot_metadata = st_ivas->hSCE[element_id]->hMetaData->nb_ind_tot; +#endif } } else if ( !is_SCE && st_ivas->hCPE[element_id] != NULL ) @@ -782,6 +1757,9 @@ static ivas_error write_indices_element( { nb_bits_tot_metadata = st_ivas->hCPE[element_id]->hMetaData->nb_bits_tot; ind_list_metadata = st_ivas->hCPE[element_id]->hMetaData->ind_list; +#ifdef IND_LIST_DYN + nb_ind_tot_metadata = st_ivas->hCPE[element_id]->hMetaData->nb_ind_tot; +#endif } } #ifdef DEBUGGING @@ -822,7 +1800,13 @@ static ivas_error write_indices_element( #ifdef ENABLE_BITRATE_VERIFICATION total_nb_bits = #endif - write_indices_to_stream( ind_list_metadata, &pt_stream_loc, -1, MAX_BITS_METADATA ); + write_indices_to_stream( ind_list_metadata, &pt_stream_loc, -1, +#ifdef IND_LIST_DYN + nb_ind_tot_metadata +#else + MAX_BITS_METADATA +#endif + ); #ifdef ENABLE_BITRATE_VERIFICATION if ( total_nb_bits != nb_bits_tot_metadata ) @@ -836,7 +1820,13 @@ static ivas_error write_indices_element( #ifdef ENABLE_BITRATE_VERIFICATION total_nb_bits = #endif - write_indices_to_stream( sts[n]->hBstr->ind_list, &pt_stream_loc, 1, MAX_NUM_INDICES ); + write_indices_to_stream( sts[n]->hBstr->ind_list, &pt_stream_loc, 1, +#ifdef IND_LIST_DYN + sts[n]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); #ifdef ENABLE_BITRATE_VERIFICATION if ( total_nb_bits != sts[n]->hBstr->nb_bits_tot ) @@ -859,21 +1849,41 @@ static ivas_error write_indices_element( { if ( st_ivas->hSCE[element_id]->hMetaData != NULL ) { +#ifdef IND_LIST_DYN + reset_indices_enc( st_ivas->hSCE[element_id]->hMetaData, st_ivas->hSCE[element_id]->hMetaData->nb_ind_tot ); +#else reset_indices_enc( st_ivas->hSCE[element_id]->hMetaData, MAX_BITS_METADATA ); +#endif } - reset_indices_enc( sts[0]->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( sts[0]->hBstr, +#ifdef IND_LIST_DYN + sts[0]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); } else { if ( st_ivas->hCPE[element_id]->hMetaData != NULL ) { +#ifdef IND_LIST_DYN + reset_indices_enc( st_ivas->hCPE[element_id]->hMetaData, st_ivas->hCPE[element_id]->hMetaData->nb_ind_tot ); +#else reset_indices_enc( st_ivas->hCPE[element_id]->hMetaData, MAX_BITS_METADATA ); +#endif } for ( n = 0; n < n_channels; n++ ) { - reset_indices_enc( sts[n]->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( sts[n]->hBstr, +#ifdef IND_LIST_DYN + sts[n]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); } } @@ -920,6 +1930,7 @@ ivas_error write_indices_ivas( { sts = st_ivas->hSCE[n]->hCoreCoder; i += sts[0]->hBstr->nb_bits_tot; + if ( st_ivas->hSCE[n]->hMetaData != NULL ) { i += st_ivas->hSCE[n]->hMetaData->nb_bits_tot; @@ -933,6 +1944,7 @@ ivas_error write_indices_ivas( { i += sts[ch]->hBstr->nb_bits_tot; } + if ( st_ivas->hCPE[n]->hMetaData != NULL ) { i += st_ivas->hCPE[n]->hMetaData->nb_bits_tot; @@ -950,6 +1962,7 @@ ivas_error write_indices_ivas( return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Bitstream write size mismatch! Actual bitrate: %ld vs. Reference bitrate: %d\n", i * 50L, ivas_total_brate ); } #endif + /*-----------------------------------------------------------------* * Encode Payload *-----------------------------------------------------------------*/ @@ -969,7 +1982,7 @@ ivas_error write_indices_ivas( return error; } - +#ifndef IND_LIST_DYN /*-------------------------------------------------------------------* * indices_to_serial_generic() * @@ -1019,6 +2032,7 @@ void indices_to_serial_generic( return; } +#endif /*---------------------------------------------------------------------* * convertSerialToBytestream( ) diff --git a/lib_com/cnst.h b/lib_com/cnst.h index cd3aa07c48a2d43d95ae7c88e0bb1ee667dacc59..a32d202419ea1b4bcf2d5957bba44fab39b6c330 100644 --- a/lib_com/cnst.h +++ b/lib_com/cnst.h @@ -447,7 +447,9 @@ enum IND_STEREO_2ND_CODER_T, IND_UNUSED, +#ifndef IND_LIST_DYN MAX_NUM_INDICES = IND_UNUSED + 772 /* Total 2640 in line with MAX_BITS_METADATA */ +#endif }; /*----------------------------------------------------------------------------------* diff --git a/lib_com/ivas_cnst.h b/lib_com/ivas_cnst.h index 3a13e67b56ffc6230cd31f400dfe75795f95da74..5757b0c53d7e6d924080b4d6002efb44d3948846 100755 --- a/lib_com/ivas_cnst.h +++ b/lib_com/ivas_cnst.h @@ -192,8 +192,15 @@ typedef enum #define MAX_CPE ( MAX_TRANSPORT_CHANNELS / CPE_CHANNELS ) /* max. number of CPEs */ #define MAX_BITS_METADATA 2640 /* max. bit-budget of metadata, one channel */ /* IVAS_fmToDo: to be confirmed for final value once mature */ +#ifndef IND_LIST_DYN #define MAX_NUM_METADATA max( 2, MAX_NUM_OBJECTS ) /* number of max. metadata (now only 2 for DirAC) */ - +#endif +#ifdef IND_LIST_DYN +#define MIN_NUM_IND 10 /* minimum number of indices in the core coder */ +#define MAX_NUM_IND_LFE 100 /* maximum number of indices in the LFE encoder */ +#define MAX_NUM_IND_TEMP_LIST 10 /* maximum number of indices in the temporary list */ +#define MAX_IND_TDM_TMP 10 /* maximum number of indices in the temporary list of TD stereo spatial parameters */ +#endif #define IVAS_ENC_DELAY_NS ACELP_LOOK_NS #define IVAS_DEC_DELAY_NS 3250000L /* 3.25 ms: IVAS decoder delay (without renderer delay) */ diff --git a/lib_com/ivas_prot.h b/lib_com/ivas_prot.h index 5d4faf0eb0e247cba971677498011e6e9755ebdc..27790e039d8c01ff3af41748f5c63e96da594cde 100644 --- a/lib_com/ivas_prot.h +++ b/lib_com/ivas_prot.h @@ -275,9 +275,11 @@ void ivas_initialize_handles_enc( ); ivas_error ivas_init_encoder( - Encoder_Struct *st_ivas, /* i/o: IVAS encoder structure */ - Indice ind_list[][MAX_NUM_INDICES], /* i : indices list */ - Indice ind_list_metadata[][MAX_BITS_METADATA] /* i : indices list metadata */ + Encoder_Struct *st_ivas /* i/o: IVAS encoder structure */ +#ifndef IND_LIST_DYN + ,Indice ind_list[][MAX_NUM_INDICES] /* i : indices list */ + ,Indice ind_list_metadata[][MAX_BITS_METADATA] /* i : indices list metadata */ +#endif ); void destroy_core_enc( @@ -3235,7 +3237,9 @@ void ivas_qmetadata_close( void restore_metadata_buffer( BSTR_ENC_HANDLE hMetaData, const int16_t next_ind_start, +#ifndef IND_LIST_DYN const int16_t last_ind_start, +#endif const int16_t bit_pos_start ); diff --git a/lib_com/options.h b/lib_com/options.h index 366b45ccd5c453c9d757f29705429e2f4af9e883..cbbccd5ec33efd4a7df54f53589a6fa44c233142 100644 --- a/lib_com/options.h +++ b/lib_com/options.h @@ -134,7 +134,11 @@ /* ################# Start DEVELOPMENT switches ######################## */ #define BASOP_NOGLOB /* Disable global symbols in BASOPs, Overflow/Carry in BASOPs disabled, additional BASOPs in case of Overflow */ +#define IND_LIST_DYN /* VA: Issue 18: Dynamic allocation of ind_list[] and ind_list_metadata[] based on # of transport channels */ + +#ifndef IND_LIST_DYN #define BITSTREAM_INDICES_MEMORY /* Don't count memory for bitstream Indice at the encoder - it is a temporary solution for development only */ +#endif #define DISABLE_ADAP_RES_COD_TMP /* temporary fix for IVAS-403, disables adaptive residual coding */ /*#define FIX_I4_OL_PITCH*/ /* fix open-loop pitch used for EVS core switching */ diff --git a/lib_com/prot.h b/lib_com/prot.h index 8c6fdd674f7cc674b1059abde2f0205c9f949bce..6d3d0fd744585ba84ed17fb2e299074d8d89d411 100644 --- a/lib_com/prot.h +++ b/lib_com/prot.h @@ -519,6 +519,54 @@ void push_next_bits( #endif ); +#ifdef IND_LIST_DYN +int16_t get_ivas_max_num_indices( /* o : maximum number of indices */ + const IVAS_FORMAT ivas_format, /* i : IVAS format */ + const int32_t ivas_total_brate /* i : IVAS total bitrate */ +); + +int16_t get_core_max_num_indices( /* o : maximum number of indices */ + const int16_t core, /* i : core */ + const int32_t total_brate /* i : total bitrate */ +); + +int16_t get_BWE_max_num_indices( /* o : maximum number of indices */ + const int32_t extl_brate /* i : extensiona layer bitrate */ +); + +int16_t get_ivas_max_num_indices_metadata( /* o : maximum number of indices for metadata */ + const IVAS_FORMAT ivas_format, /* i : IVAS format */ + const int32_t ivas_total_brate /* i : IVAS total bitrate */ +); + +ivas_error ind_list_realloc( + BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */ + int16_t max_num_indices /* i : new maximum number of allowed indices in the list */ +); + +ivas_error check_ind_list_limits( + BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */ +); + +ivas_error move_indices( + INDICE_HANDLE old_ind_list, /* i/o: old location of indices */ + INDICE_HANDLE new_ind_list, /* i/o: new location of indices */ + const int16_t nb_indices /* i : number of moved indices */ +); + +int16_t find_indice( /* o : index of the indice in the list, -1 if not found */ + BSTR_ENC_HANDLE hBstr, /* i : encoder bitstream handle */ + int16_t id, /* i : ID of the indice */ + uint16_t *value, /* o : value of the quantized indice */ + int16_t *nb_bits /* o : number of bits used to quantize the indice */ +); + +uint16_t delete_indice( /* o : number of deleted indices */ + BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */ + int16_t id /* i : ID of the indice */ +); +#endif + /*! r: value of the indice */ #ifdef DEBUG_BS_READ_WRITE #define get_next_indice( ... ) get_next_indice_( __VA_ARGS__, __LINE__, __func__ ) @@ -617,12 +665,14 @@ Decoder_State **reset_elements( ); +#ifndef IND_LIST_DYN void indices_to_serial_generic( const Indice *ind_list, /* i : indices list */ const Word16 num_indices, /* i : number of indices to write */ UWord8 *pFrame, /* o : byte array with bit packet and byte aligned coded speech data */ Word16 *pFrame_size /* o : size of the binary encoded access unit [bits] */ ); +#endif void convertSerialToBytestream( const uint16_t *const serial, /* i : input serial bitstream with values 0 and 1 */ @@ -2223,8 +2273,12 @@ void read_next_force( int32_t *force_profile_cnt /* i/o: counter of frames for force switching profile file */ ); #endif + ivas_error init_encoder( - Encoder_State *st, /* i/o: state structure */ + Encoder_State *st, /* i/o: state structure */ +#ifdef IND_LIST_DYN + Encoder_Struct *st_ivas, /* i/o: encoder state structure */ +#endif const int16_t idchan, /* i : channel ID */ const int16_t var_SID_rate_flag, /* i : flag for variable SID update rate */ const int16_t interval_SID, /* i : interval for SID update */ diff --git a/lib_enc/acelp_core_switch_enc.c b/lib_enc/acelp_core_switch_enc.c index f573649d3ce1ef95580e7f1a0e438f49e093cd1e..0fa3ba313061ef4ef7b4df962e3a2f7d1f6f50f4 100644 --- a/lib_enc/acelp_core_switch_enc.c +++ b/lib_enc/acelp_core_switch_enc.c @@ -73,6 +73,10 @@ void acelp_core_switch_enc( const float *inp; int32_t cbrate; float Aq[2 * ( M + 1 )]; +#ifdef IND_LIST_DYN + uint16_t value; + int16_t nb_bits; +#endif BSTR_ENC_HANDLE hBstr = st->hBstr; /* initializations */ @@ -159,12 +163,25 @@ void acelp_core_switch_enc( * Manipulate ACELP subframe indices (move them to their proper place) *----------------------------------------------------------------*/ +#ifdef IND_LIST_DYN + i = find_indice( hBstr, TAG_ACELP_SUBFR_LOOP_START, &value, &nb_bits ); +#ifdef DEBUGGING + assert( i >= 0 && "Internal error in ACELP core switching - unable to find ACELP subframe indices!" ); +#endif + while ( hBstr->ind_list[i].id == TAG_ACELP_SUBFR_LOOP_START ) + { + push_indice( hBstr, IND_CORE_SWITCHING_CELP_SUBFRAME, hBstr->ind_list[i].value, hBstr->ind_list[i].nb_bits ); + i++; + } + delete_indice( hBstr, TAG_ACELP_SUBFR_LOOP_START ); +#else for ( i = 0; i < 20; i++ ) { hBstr->ind_list[IND_CORE_SWITCHING_CELP_SUBFRAME + i].value = hBstr->ind_list[TAG_ACELP_SUBFR_LOOP_START + i].value; hBstr->ind_list[IND_CORE_SWITCHING_CELP_SUBFRAME + i].nb_bits = hBstr->ind_list[TAG_ACELP_SUBFR_LOOP_START + i].nb_bits; hBstr->ind_list[TAG_ACELP_SUBFR_LOOP_START + i].nb_bits = -1; } +#endif /*----------------------------------------------------------------* * BWE encoding diff --git a/lib_enc/cng_enc.c b/lib_enc/cng_enc.c index 14eef260b465b5b7354e7bb06820257f4c2cd160..6d49d9c8863d9c98ded4ccaf0ffeffcd4e9e0c84 100644 --- a/lib_enc/cng_enc.c +++ b/lib_enc/cng_enc.c @@ -881,8 +881,12 @@ void swb_CNG_enc( else if ( st->element_mode == IVAS_CPE_DFT && st->core_brate == SID_2k40 ) { /* LF-boost not used in DFT-stereo, instead the bandwidth is transmitted */ +#ifdef IND_LIST_DYN + delete_indice( st->hBstr, IND_CNG_ENV1 ); +#else st->hBstr->nb_bits_tot = st->hBstr->nb_bits_tot - st->hBstr->ind_list[IND_CNG_ENV1].nb_bits; st->hBstr->ind_list[IND_CNG_ENV1].nb_bits = -1; +#endif push_indice( st->hBstr, IND_BWIDTH, st->bwidth, 2 ); push_indice( st->hBstr, IND_UNUSED, 0, 4 ); push_indice( st->hBstr, IND_SID_BW, 1, 1 ); @@ -958,8 +962,12 @@ static void shb_CNG_encod( push_indice( hBstr, IND_SHB_CNG_GAIN, idx_ener, 4 ); push_indice( hBstr, IND_SID_BW, 1, 1 ); +#ifdef IND_LIST_DYN + delete_indice( hBstr, IND_CNG_ENV1 ); +#else hBstr->nb_bits_tot = hBstr->nb_bits_tot - hBstr->ind_list[IND_CNG_ENV1].nb_bits; hBstr->ind_list[IND_CNG_ENV1].nb_bits = -1; +#endif if ( st->element_mode == IVAS_CPE_DFT ) { push_indice( st->hBstr, IND_BWIDTH, st->bwidth, 2 ); diff --git a/lib_enc/dtx.c b/lib_enc/dtx.c index 08d4316750868e4b72df31b8bf6ec6a11e393a84..df6ffe6b8f7e0e68b510b1dd5c3721d3da45896e 100644 --- a/lib_enc/dtx.c +++ b/lib_enc/dtx.c @@ -263,7 +263,13 @@ void dtx( /* reset the bitstream (IVAS format signaling was already written) */ if ( st->element_mode != IVAS_CPE_MDCT && st->hBstr != NULL ) { - reset_indices_enc( st->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( st->hBstr, +#ifdef IND_LIST_DYN + st->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); } } diff --git a/lib_enc/enc_ppp.c b/lib_enc/enc_ppp.c index 823d6cf3cdb244a96f0f894df172f66aafbf0b7d..328c1d5b5215d500452fcb61e3e6a76f71597a95 100644 --- a/lib_enc/enc_ppp.c +++ b/lib_enc/enc_ppp.c @@ -169,7 +169,14 @@ ivas_error encod_ppp( } /* delete previous indices */ - reset_indices_enc( hBstr, MAX_NUM_INDICES ); + reset_indices_enc( hBstr, +#ifdef IND_LIST_DYN + hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); + /* signaling matrix (writing of signaling bits) */ signaling_enc( st ); diff --git a/lib_enc/eval_pit_contr.c b/lib_enc/eval_pit_contr.c index 5dd310177230d29c68fe414a5eaa9db3e7ce91cd..76bf54b0254641fe7d8ce3aa6c3761c991cd6835 100644 --- a/lib_enc/eval_pit_contr.c +++ b/lib_enc/eval_pit_contr.c @@ -326,18 +326,26 @@ int16_t Pit_exc_contribution_len( /* pitch contribution useless - delete all previously written indices belonging to pitch contribution */ for ( i = TAG_ACELP_SUBFR_LOOP_START; i < TAG_ACELP_SUBFR_LOOP_END; i++ ) { +#ifdef IND_LIST_DYN + delete_indice( hBstr, i ); +#else if ( hBstr->ind_list[i].nb_bits != -1 ) { hBstr->nb_bits_tot -= hBstr->ind_list[i].nb_bits; hBstr->ind_list[i].nb_bits = -1; } +#endif } +#ifdef IND_LIST_DYN + delete_indice( hBstr, IND_ES_PRED ); +#else if ( hBstr->ind_list[IND_ES_PRED].nb_bits != -1 ) { hBstr->nb_bits_tot -= hBstr->ind_list[IND_ES_PRED].nb_bits; hBstr->ind_list[IND_ES_PRED].nb_bits = -1; } +#endif } if ( st->core_brate < CFREQ_BITRATE ) diff --git a/lib_enc/evs_enc.c b/lib_enc/evs_enc.c index da0556dd7215497b3c2151a963a9b0569d306435..c45bb444f3aac3fd061469feb5ec6a3b816a3d43 100644 --- a/lib_enc/evs_enc.c +++ b/lib_enc/evs_enc.c @@ -103,6 +103,7 @@ ivas_error evs_enc( error = IVAS_ERR_OK; push_wmops( "evs_enc" ); + /*------------------------------------------------------------------* * Initialization *-----------------------------------------------------------------*/ diff --git a/lib_enc/fd_cng_enc.c b/lib_enc/fd_cng_enc.c index d71c24d45c0c8a1d04170f0f884658ab2cccbbcf..3ac5b8d6908fc3756e7d4a403ad6fd118a65f726 100644 --- a/lib_enc/fd_cng_enc.c +++ b/lib_enc/fd_cng_enc.c @@ -923,8 +923,21 @@ void stereoFdCngCoherence( else if ( sts[0]->core_brate <= SID_2k40 && sts[1]->core_brate <= SID_2k40 ) { /* case: no VAD for both channels -> INACTIVE FRAME */ - reset_indices_enc( sts[0]->hBstr, MAX_NUM_INDICES ); - reset_indices_enc( sts[1]->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( sts[0]->hBstr, +#ifdef IND_LIST_DYN + sts[0]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); + + reset_indices_enc( sts[1]->hBstr, +#ifdef IND_LIST_DYN + sts[1]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); /* synchronize SID sending for variable SID rate */ if ( sts[0]->core_brate != sts[1]->core_brate ) @@ -1174,12 +1187,14 @@ void FdCngEncodeMDCTStereoSID( /* ---- Write SID bitstream ---- */ +#ifndef IND_LIST_DYN /* side info */ push_indice( sts[0]->hBstr, IND_SID_TYPE, 1, 1 ); push_indice( sts[0]->hBstr, IND_BWIDTH, sts[0]->bwidth, 2 ); push_indice( sts[0]->hBstr, IND_ACELP_16KHZ, sts[0]->L_frame == L_FRAME16k ? 1 : 0, 1 ); push_indice( sts[1]->hBstr, IND_SID_TYPE, coh_idx, 4 ); push_indice( sts[1]->hBstr, IND_SID_TYPE, no_side_flag, 1 ); +#endif /* noise shapes and channel gains */ for ( ch = 0; ch < CPE_CHANNELS; ch++ ) @@ -1187,10 +1202,23 @@ void FdCngEncodeMDCTStereoSID( if ( ch ) { stages = FD_CNG_JOINT_stages_25bits; +#ifdef IND_LIST_DYN + sts[ch]->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + + /* side info */ + push_indice( sts[ch]->hBstr, IND_SID_TYPE, coh_idx, 4 ); + push_indice( sts[ch]->hBstr, IND_SID_TYPE, no_side_flag, 1 ); +#endif } else { stages = FD_CNG_stages_37bits; +#ifdef IND_LIST_DYN + /* side info */ + push_indice( sts[ch]->hBstr, IND_SID_TYPE, 1, 1 ); + push_indice( sts[ch]->hBstr, IND_BWIDTH, sts[0]->bwidth, 2 ); + push_indice( sts[ch]->hBstr, IND_ACELP_16KHZ, sts[0]->L_frame == L_FRAME16k ? 1 : 0, 1 ); +#endif } for ( int16_t i = 0; i < stages; i++ ) diff --git a/lib_enc/igf_enc.c b/lib_enc/igf_enc.c index 9c68e3fcc760981ad66e0da3ec77b7ebd427ce18..677bc1639e39dca3ff9e3686b0d156ab99eaa31f 100644 --- a/lib_enc/igf_enc.c +++ b/lib_enc/igf_enc.c @@ -1707,6 +1707,41 @@ void IGFEncSetMode( return; } +#ifdef IND_LIST_DYN + +/*-------------------------------------------------------------------* + * pack_bit() + * + * insert a bit into packed octet + *-------------------------------------------------------------------*/ + +static void pack_bit( + const int16_t bit, /* i : bit to be packed */ + uint8_t **pt, /* i/o: pointer to octet array into which bit will be placed */ + uint8_t *omask /* i/o: output mask to indicate where in the octet the bit is to be written */ +) +{ + if ( *omask == 0x80 ) + { + **pt = 0; + } + + if ( bit != 0 ) + { + **pt = **pt | *omask; + } + + *omask >>= 1; + if ( *omask == 0 ) + { + *omask = 0x80; + ( *pt )++; + } + + return; +} + +#endif /*-------------------------------------------------------------------* * IGFEncConcatenateBitstream() @@ -1722,10 +1757,56 @@ void IGFEncConcatenateBitstream( { int16_t i; IGF_ENC_PRIVATE_DATA_HANDLE hPrivateData; +#ifdef IND_LIST_DYN + Indice *ind_list; + uint8_t *pFrame; /* byte array with bit packet and byte aligned coded speech data */ + int16_t *pFrame_size; /* number of bits in the binary encoded access unit [bits] */ + int16_t k, nb_bits_written; + int32_t imask; + uint8_t omask; +#endif hPrivateData = &hIGFEnc->igfData; +#ifndef IND_LIST_DYN hBstr->next_ind -= bsBits; +#endif + +#ifdef IND_LIST_DYN + ind_list = &hBstr->ind_list[hBstr->nb_ind_tot - bsBits]; /* here, we assume that each bit has been written as a single indice */ + pFrame = hPrivateData->igfBitstream; + pFrame_size = &hPrivateData->igfBitstreamBits; + nb_bits_written = 0; + + omask = ( 0x80 >> ( *pFrame_size & 0x7 ) ); + pFrame += *pFrame_size >> 3; + + /* bitstream packing (conversion of individual indices into a serial stream) */ + for ( i = 0; i < bsBits; i++ ) + { + if ( ind_list[i].nb_bits > 0 ) + { + /* mask from MSB to LSB */ + imask = 1 << ( ind_list[i].nb_bits - 1 ); + /* write bit by bit */ + for ( k = 0; k < ind_list[i].nb_bits; k++ ) + { + pack_bit( ind_list[i].value & imask, &pFrame, &omask ); + imask >>= 1; + } + nb_bits_written += ind_list[i].nb_bits; + + /* delete the indice */ + ind_list[i].nb_bits = -1; + } + } + + *pFrame_size += nb_bits_written; + + /* update list of indices */ + hBstr->nb_ind_tot -= bsBits; + hBstr->nb_bits_tot -= nb_bits_written; +#else indices_to_serial_generic( &hBstr->ind_list[hBstr->next_ind], bsBits, hPrivateData->igfBitstream, &hPrivateData->igfBitstreamBits ); /* make sure there are no leftovers from the temporary bitstream writing */ @@ -1735,6 +1816,7 @@ void IGFEncConcatenateBitstream( } hBstr->nb_bits_tot -= hIGFEnc->infoTotalBitsPerFrameWritten; +#endif return; } diff --git a/lib_enc/init_enc.c b/lib_enc/init_enc.c index 9efd3c7f166be25a773de9962c4ace5d943ae60e..42b4e8957d92ab0290e02ad72d9101b03aca4e72 100644 --- a/lib_enc/init_enc.c +++ b/lib_enc/init_enc.c @@ -54,7 +54,10 @@ *-----------------------------------------------------------------------*/ ivas_error init_encoder( - Encoder_State *st, /* i/o: state structure */ + Encoder_State *st, /* i/o: state structure */ +#ifdef IND_LIST_DYN + Encoder_Struct *st_ivas, /* i/o: encoder state structure */ +#endif const int16_t idchan, /* i : channel ID */ const int16_t var_SID_rate_flag, /* i : flag for variable SID update rate */ const int16_t interval_SID, /* i : interval for SID update */ @@ -112,6 +115,15 @@ ivas_error init_encoder( { return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Bitstream structure\n" ) ); } + +#ifdef IND_LIST_DYN + /* set pointer to the buffer of indices */ + st->hBstr->ind_list = st_ivas->ind_list; + st->hBstr->ivas_ind_list_zero = &st_ivas->ind_list; + st->hBstr->ivas_max_num_indices = &st_ivas->ivas_max_num_indices; + st->hBstr->nb_ind_tot = 0; + st->hBstr->nb_bits_tot = 0; +#endif } else { diff --git a/lib_enc/ivas_core_enc.c b/lib_enc/ivas_core_enc.c index c2627b923bed0d309efd02e639da02d21a894147..6536ee333eb4f1b071af67c0fe64eac4b3124fc8 100644 --- a/lib_enc/ivas_core_enc.c +++ b/lib_enc/ivas_core_enc.c @@ -103,6 +103,9 @@ ivas_error ivas_core_enc( int16_t last_element_mode, tdm_Pitch_reuse_flag; int32_t element_brate, last_element_brate, input_Fs; ivas_error error; +#ifdef IND_LIST_DYN + int16_t max_num_indices_BWE; +#endif push_wmops( "ivas_core_enc" ); @@ -195,6 +198,23 @@ ivas_error ivas_core_enc( { st = sts[n]; +#ifdef IND_LIST_DYN + /* update pointer to the buffer of indices of the second channel */ + if ( n == 1 && st->element_mode == IVAS_CPE_TD ) + { + /* adjust the pointer to the buffer of indices of the secondary channel (make space for BWE indices) */ + max_num_indices_BWE = get_BWE_max_num_indices( sts[0]->extl_brate ); + st->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot + max_num_indices_BWE; + + /* write TD stereo spatial parameters */ + move_indices( hStereoTD->tdm_hBstr_tmp.ind_list, st->hBstr->ind_list, hStereoTD->tdm_hBstr_tmp.nb_ind_tot ); + st->hBstr->nb_ind_tot += hStereoTD->tdm_hBstr_tmp.nb_ind_tot; + st->hBstr->nb_bits_tot += hStereoTD->tdm_hBstr_tmp.nb_bits_tot; + + reset_indices_enc( &hStereoTD->tdm_hBstr_tmp, MAX_IND_TDM_TMP ); + } +#endif + /*---------------------------------------------------------------------* * Write signaling info into the bitstream *---------------------------------------------------------------------*/ @@ -406,7 +426,6 @@ ivas_error ivas_core_enc( } } - #ifdef DEBUG_MODE_INFO for ( n = 0; n < n_CoreChannels; n++ ) { diff --git a/lib_enc/ivas_corecoder_enc_reconfig.c b/lib_enc/ivas_corecoder_enc_reconfig.c index fcafb7110cc0cade4a863816450425245c612022..f838fe36d399832e7afb26411dae40cb88a28770 100644 --- a/lib_enc/ivas_corecoder_enc_reconfig.c +++ b/lib_enc/ivas_corecoder_enc_reconfig.c @@ -41,7 +41,6 @@ #endif #include "wmc_auto.h" - /*-------------------------------------------------------------------* * ivas_corecoder_enc_reconfig() * @@ -61,9 +60,24 @@ ivas_error ivas_corecoder_enc_reconfig( int16_t n, sce_id, cpe_id; int16_t len_inp_memory, n_CoreCoder_existing, nSCE_existing, nCPE_existing; float input_buff[MCT_MAX_BLOCKS][L_FRAME48k + NS2SA( 48000, IVAS_FB_ENC_DELAY_NS )]; - BSTR_ENC_HANDLE hBstr, hMetaData; - Indice *ind_list, *ind_list_metadata; - int16_t nb_bits_tot, next_ind, last_ind; + BSTR_ENC_HANDLE hBstr; +#ifndef IND_LIST_DYN + Indice *ind_list; +#endif +#ifndef IND_LIST_DYN + Indice *ind_list_metadata; + BSTR_ENC_HANDLE hMetaData; +#endif +#ifdef IND_LIST_DYN + int16_t i, nb_bits; + Indice temp_ind_list[MAX_NUM_IND_TEMP_LIST]; +#endif + int16_t nb_bits_tot; +#ifndef IND_LIST_DYN + int16_t last_ind; + int16_t next_ind; +#endif + ENCODER_CONFIG_HANDLE hEncoderConfig; ivas_error error; @@ -133,21 +147,29 @@ ivas_error ivas_corecoder_enc_reconfig( } /* something in transport changes */ +#ifndef IND_LIST_DYN ind_list = NULL; ind_list_metadata = NULL; +#endif hBstr = NULL; +#ifndef IND_LIST_DYN hMetaData = NULL; +#endif /* get the index list pointers */ if ( nSCE_old ) { hBstr = st_ivas->hSCE[0]->hCoreCoder[0]->hBstr; +#ifndef IND_LIST_DYN hMetaData = st_ivas->hSCE[0]->hMetaData; +#endif } else if ( nCPE_old ) { hBstr = st_ivas->hCPE[0]->hCoreCoder[0]->hBstr; +#ifndef IND_LIST_DYN hMetaData = st_ivas->hCPE[nCPE_old - 1]->hMetaData; +#endif } #ifdef DEBUGGING else @@ -157,11 +179,45 @@ ivas_error ivas_corecoder_enc_reconfig( #endif /* save bitstream information */ - ind_list = hBstr->ind_list; /* pointer to the beginning of the global list */ nb_bits_tot = hBstr->nb_bits_tot; +#ifndef IND_LIST_DYN + ind_list = hBstr->ind_list; /* pointer to the beginning of the global list */ next_ind = hBstr->next_ind; last_ind = hBstr->last_ind; +#endif +#ifdef IND_LIST_DYN + i = 0; + nb_bits = 0; + while ( nb_bits < nb_bits_tot && i < MAX_NUM_IND_TEMP_LIST ) + { + if ( hBstr->ind_list[i].nb_bits > 0 ) + { + temp_ind_list[i].id = hBstr->ind_list[i].id; + temp_ind_list[i].value = hBstr->ind_list[i].value; + temp_ind_list[i].nb_bits = hBstr->ind_list[i].nb_bits; + hBstr->ind_list[i].nb_bits = -1; + } + + hBstr->nb_bits_tot = 0; + hBstr->nb_ind_tot = 0; + + nb_bits += temp_ind_list[i].nb_bits; + i++; + } + + for ( ; i < MAX_NUM_IND_TEMP_LIST; i++ ) + { + /* reset nb_bits of all other indices to -1 */ + temp_ind_list[i].nb_bits = -1; + } + +#ifdef DEBUGGING + assert( ( nb_bits == nb_bits_tot ) && "Error saving bitstream information during core-coder reconfiguration!\n" ); +#endif +#endif +#ifndef IND_LIST_DYN ind_list_metadata = hMetaData->ind_list; /* pointer to the beginning of the global list */ +#endif if ( hEncoderConfig->ivas_format == MC_FORMAT && last_mc_mode == MC_MODE_MCMASA && st_ivas->mc_mode == MC_MODE_MCMASA ) { @@ -256,23 +312,35 @@ ivas_error ivas_corecoder_enc_reconfig( mvr2r( input_buff[sce_id], st_ivas->hSCE[sce_id]->hCoreCoder[0]->input_buff, len_inp_memory ); } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN + /* allocate buffer of indices */ st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->ind_list = ind_list + sce_id * MAX_NUM_INDICES; +#endif /* only reset indices if it is not the first index list, this already contains the IVAS format bits */ if ( sce_id > 0 ) { - reset_indices_enc( st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr, +#ifdef IND_LIST_DYN + st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); } else { - st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->last_ind = last_ind; +#ifndef IND_LIST_DYN st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->nb_bits_tot = nb_bits_tot; + st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->last_ind = last_ind; st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->next_ind = next_ind; +#endif } +#ifndef IND_LIST_DYN st_ivas->hSCE[sce_id]->hMetaData->ind_list = ind_list_metadata + sce_id * MAX_BITS_METADATA; reset_indices_enc( st_ivas->hSCE[sce_id]->hMetaData, MAX_BITS_METADATA ); +#endif } } @@ -284,22 +352,32 @@ ivas_error ivas_corecoder_enc_reconfig( { st_ivas->hCPE[cpe_id]->element_brate = brate_CPE; - /* prepare bitstream buffers */ + /* allocate buffer of indices */ for ( n = 0; n < CPE_CHANNELS; n++ ) { copy_encoder_config( st_ivas, st_ivas->hCPE[cpe_id]->hCoreCoder[n], 0 ); st_ivas->hCPE[cpe_id]->hCoreCoder[n]->total_brate = st_ivas->hCPE[cpe_id]->element_brate / ( st_ivas->nCPE > 1 ? 1 : CPE_CHANNELS ); /* dummy initialization for getting right pointers initialization of input buffers in init_coder_ace_plus() */ +#ifndef IND_LIST_DYN st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->ind_list = ind_list + ( cpe_id * CPE_CHANNELS + n + st_ivas->nSCE ) * MAX_NUM_INDICES; +#endif if ( cpe_id * CPE_CHANNELS + n > 0 || ( st_ivas->mc_mode == MC_MODE_MCMASA && st_ivas->nSCE > 0 ) ) { - reset_indices_enc( st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr, +#ifdef IND_LIST_DYN + st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); } else { - st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->last_ind = last_ind; +#ifndef IND_LIST_DYN st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->nb_bits_tot = nb_bits_tot; + st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->last_ind = last_ind; st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->next_ind = next_ind; +#endif } } } @@ -329,19 +407,29 @@ ivas_error ivas_corecoder_enc_reconfig( } } - /* prepare bitstream buffers */ for ( n = 0; n < CPE_CHANNELS; n++ ) { +#ifndef IND_LIST_DYN st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->ind_list = ind_list + ( cpe_id * CPE_CHANNELS + n + st_ivas->nSCE ) * MAX_NUM_INDICES; +#endif + /* only reset indices if it is not the first index list, this already contains the IVAS format bits */ if ( cpe_id * CPE_CHANNELS + n > 0 || ( st_ivas->mc_mode == MC_MODE_MCMASA && st_ivas->nSCE > 0 ) ) { - reset_indices_enc( st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr, +#ifdef IND_LIST_DYN + st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); } else { - st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->last_ind = last_ind; +#ifndef IND_LIST_DYN st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->nb_bits_tot = nb_bits_tot; + st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->last_ind = last_ind; st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->next_ind = next_ind; +#endif } if ( hEncoderConfig->Opt_DTX_ON ) @@ -352,6 +440,51 @@ ivas_error ivas_corecoder_enc_reconfig( } } +#ifdef IND_LIST_DYN + /* restore bitstream - IVAS format bits should be written in the first core channel of the first SCE/CPE */ + i = 0; + nb_bits = 0; + if ( st_ivas->nSCE > 0 ) + { + while ( nb_bits < nb_bits_tot && i < MAX_NUM_IND_TEMP_LIST ) + { + if ( temp_ind_list[i].nb_bits > 0 ) + { + st_ivas->hSCE[0]->hCoreCoder[0]->hBstr->ind_list[i].id = temp_ind_list[i].id; + st_ivas->hSCE[0]->hCoreCoder[0]->hBstr->ind_list[i].value = temp_ind_list[i].value; + st_ivas->hSCE[0]->hCoreCoder[0]->hBstr->ind_list[i].nb_bits = temp_ind_list[i].nb_bits; + } + + nb_bits += temp_ind_list[i].nb_bits; + i++; + } + st_ivas->hSCE[0]->hCoreCoder[0]->hBstr->nb_ind_tot = i; + st_ivas->hSCE[0]->hCoreCoder[0]->hBstr->nb_bits_tot = nb_bits_tot; + } + else if ( st_ivas->nCPE > 0 ) + { + while ( nb_bits < nb_bits_tot && i < MAX_NUM_IND_TEMP_LIST ) + { + if ( temp_ind_list[i].nb_bits > 0 ) + { + st_ivas->hCPE[0]->hCoreCoder[0]->hBstr->ind_list[i].id = temp_ind_list[i].id; + st_ivas->hCPE[0]->hCoreCoder[0]->hBstr->ind_list[i].value = temp_ind_list[i].value; + st_ivas->hCPE[0]->hCoreCoder[0]->hBstr->ind_list[i].nb_bits = temp_ind_list[i].nb_bits; + } + + nb_bits += temp_ind_list[i].nb_bits; + i++; + } + st_ivas->hCPE[0]->hCoreCoder[0]->hBstr->nb_ind_tot = i; + st_ivas->hCPE[0]->hCoreCoder[0]->hBstr->nb_bits_tot = nb_bits_tot; + } + +#ifdef DEBUGGING + assert( ( nb_bits == nb_bits_tot ) && "Error restoring bitstream information during core-coder reconfiguration!\n" ); +#endif +#endif + + if ( last_mc_mode == MC_MODE_MCMASA && st_ivas->mc_mode == MC_MODE_MCMASA ) { /* restore modified transport signal */ @@ -376,7 +509,6 @@ ivas_error ivas_corecoder_enc_reconfig( for ( n = 0; n < CPE_CHANNELS; n++ ) { st_ivas->hCPE[0]->hCoreCoder[n]->total_brate = st_ivas->hCPE[0]->element_brate; - st_ivas->hCPE[0]->hCoreCoder[n]->bits_frame_nominal = (int16_t) ( st_ivas->hCPE[0]->element_brate / FRAMES_PER_SEC ); st_ivas->hCPE[0]->hCoreCoder[n]->igf = getIgfPresent( st_ivas->hCPE[0]->hCoreCoder[n]->element_mode, st_ivas->hCPE[0]->hCoreCoder[n]->bits_frame_nominal * FRAMES_PER_SEC, @@ -407,7 +539,7 @@ ivas_error ivas_corecoder_enc_reconfig( } } - /* metadata handling for CPEs */ + /* alllocate buffer for metadata indices */ if ( st_ivas->nCPE > 0 ) { if ( st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData == NULL ) @@ -416,10 +548,23 @@ ivas_error ivas_corecoder_enc_reconfig( { return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for MetaData structure\n" ) ); } + +#ifdef IND_LIST_DYN + /* set pointer to the buffer of metadata indices */ + st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData->ind_list = st_ivas->ind_list_metadata; + st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData->ivas_ind_list_zero = &st_ivas->ind_list_metadata; + st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData->ivas_max_num_indices = &st_ivas->ivas_max_num_indices_metadata; + st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData->nb_ind_tot = 0; + st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData->nb_bits_tot = 0; +#endif } +#ifdef IND_LIST_DYN + reset_indices_enc( st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData, st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData->nb_ind_tot ); +#else st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData->ind_list = ind_list_metadata + st_ivas->nSCE * MAX_NUM_INDICES; reset_indices_enc( st_ivas->hCPE[st_ivas->nCPE - 1]->hMetaData, MAX_BITS_METADATA ); +#endif for ( cpe_id = 0; cpe_id < st_ivas->nCPE - 1; cpe_id++ ) { @@ -443,7 +588,6 @@ ivas_error ivas_corecoder_enc_reconfig( for ( n = 0; n < CPE_CHANNELS; n++ ) { st_ivas->hCPE[0]->hCoreCoder[n]->total_brate = st_ivas->hCPE[0]->element_brate; - st_ivas->hCPE[0]->hCoreCoder[n]->bits_frame_nominal = (int16_t) ( st_ivas->hCPE[0]->element_brate / FRAMES_PER_SEC ); st_ivas->hCPE[0]->hCoreCoder[n]->igf = getIgfPresent( st_ivas->hCPE[0]->hCoreCoder[n]->element_mode, st_ivas->hCPE[0]->hCoreCoder[n]->bits_frame_nominal * FRAMES_PER_SEC, diff --git a/lib_enc/ivas_cpe_enc.c b/lib_enc/ivas_cpe_enc.c index 522cfb885de6f90d12fb2fa4b9389cba04a1c121..ab4a36cb5f90bf42798d70b08adeea7a4269107e 100644 --- a/lib_enc/ivas_cpe_enc.c +++ b/lib_enc/ivas_cpe_enc.c @@ -817,6 +817,14 @@ ivas_error create_cpe_enc( { return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for MetaData structure\n" ) ); } + +#ifdef IND_LIST_DYN + /* set pointer to the buffer of metadata indices */ + hCPE->hMetaData->ind_list = st_ivas->ind_list_metadata; + hCPE->hMetaData->ivas_ind_list_zero = &st_ivas->ind_list_metadata; + hCPE->hMetaData->ivas_max_num_indices = &st_ivas->ivas_max_num_indices_metadata; + reset_indices_enc( hCPE->hMetaData, st_ivas->ivas_max_num_indices_metadata ); +#endif } /*-----------------------------------------------------------------* @@ -833,7 +841,11 @@ ivas_error create_cpe_enc( copy_encoder_config( st_ivas, st, 1 ); st->total_brate = hCPE->element_brate / ( st_ivas->nCPE > 1 ? 1 : CPE_CHANNELS ); /* dummy initialization for getting right pointers initialization of input buffers in init_coder_ace_plus() */ st->mct_chan_mode = MCT_CHAN_MODE_REGULAR; - if ( ( error = init_encoder( st, n, hEncoderConfig->var_SID_rate_flag, hEncoderConfig->interval_SID, 0, st_ivas->ism_mode ) ) != IVAS_ERR_OK ) + if ( ( error = init_encoder( st, +#ifdef IND_LIST_DYN + st_ivas, +#endif + n, hEncoderConfig->var_SID_rate_flag, hEncoderConfig->interval_SID, 0, st_ivas->ism_mode ) ) != IVAS_ERR_OK ) { return error; } diff --git a/lib_enc/ivas_enc.c b/lib_enc/ivas_enc.c index 6121bd588f83b350d7a127c33a79b355f61ea1c8..0faa86af3a2792f929308f45542d6ad796e3498d 100644 --- a/lib_enc/ivas_enc.c +++ b/lib_enc/ivas_enc.c @@ -297,6 +297,7 @@ ivas_error ivas_enc( if ( st_ivas->mc_mode == MC_MODE_MCT ) { st_ivas->hLFE->hBstr = ( st_ivas->nSCE > 0 ) ? st_ivas->hSCE[0]->hCoreCoder[0]->hBstr : st_ivas->hCPE[0]->hCoreCoder[0]->hBstr; + ivas_lfe_enc( st_ivas->hLFE, data_f[LFE_CHANNEL], input_frame, st_ivas->hLFE->hBstr ); } @@ -364,6 +365,10 @@ ivas_error ivas_enc( return error; } +#ifdef IND_LIST_DYN + st_ivas->hCPE[0]->hCoreCoder[0]->hBstr->ind_list = st_ivas->hSCE[0]->hCoreCoder[0]->hBstr->ind_list + st_ivas->hSCE[0]->hCoreCoder[0]->hBstr->nb_ind_tot; +#endif + if ( ( error = ivas_cpe_enc( st_ivas, 0, data_f[0], data_f[1], input_frame, hMetaData->nb_bits_tot ) ) != IVAS_ERR_OK ) { return error; diff --git a/lib_enc/ivas_init_enc.c b/lib_enc/ivas_init_enc.c index e858074445b286935945a97ae7f9c5f0168d8d03..1a53481270220d7e9b08669c7353f11c111e661c 100644 --- a/lib_enc/ivas_init_enc.c +++ b/lib_enc/ivas_init_enc.c @@ -343,9 +343,15 @@ void ivas_initialize_handles_enc( *-------------------------------------------------------------------*/ ivas_error ivas_init_encoder( - Encoder_Struct *st_ivas, /* i/o: IVAS encoder structure */ - Indice ind_list[][MAX_NUM_INDICES], /* o : bitstream indices */ + Encoder_Struct *st_ivas /* i/o: IVAS encoder structure */ +#ifndef IND_LIST_DYN + , + Indice ind_list[][MAX_NUM_INDICES] /* o : bitstream indices */ +#endif +#ifndef IND_LIST_DYN + , Indice ind_list_metadata[][MAX_BITS_METADATA] /* o : bitstream indices metadata */ +#endif ) { int16_t i, n; @@ -375,6 +381,50 @@ ivas_error ivas_init_encoder( st_ivas->sba_mode = SBA_MODE_NONE; st_ivas->nchan_transport = -1; + +#ifdef IND_LIST_DYN + /*-----------------------------------------------------------------* + * Allocate and initialize buffer of indices + *-----------------------------------------------------------------*/ + + /* set the maximum allowed number of indices in the list */ + st_ivas->ivas_max_num_indices = get_ivas_max_num_indices( ivas_format, ivas_total_brate ); + + /* allocate buffer of indices */ + if ( ( st_ivas->ind_list = (INDICE_HANDLE) malloc( st_ivas->ivas_max_num_indices * sizeof( Indice ) ) ) == NULL ) + { + return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for buffer of indices!\n" ) ); + } + + /* reset the list of indices */ + for ( i = 0; i < st_ivas->ivas_max_num_indices; i++ ) + { + st_ivas->ind_list[i].nb_bits = -1; + } + + /* set the maximum allowed number of metadata indices in the list */ + st_ivas->ivas_max_num_indices_metadata = get_ivas_max_num_indices_metadata( st_ivas->hEncoderConfig->ivas_format, st_ivas->hEncoderConfig->ivas_total_brate ); + + /* allocate buffer of metadata indices */ + if ( st_ivas->ivas_max_num_indices_metadata > 0 ) + { + if ( ( st_ivas->ind_list_metadata = (INDICE_HANDLE) malloc( st_ivas->ivas_max_num_indices_metadata * sizeof( Indice ) ) ) == NULL ) + { + return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for buffer of metadata indices!\n" ) ); + } + + /* reset the list of metadata indices */ + for ( i = 0; i < st_ivas->ivas_max_num_indices_metadata; i++ ) + { + st_ivas->ind_list_metadata[i].nb_bits = -1; + } + } + else + { + st_ivas->ind_list_metadata = NULL; + } +#endif + /*-----------------------------------------------------------------* * Allocate and initialize SCE/CPE and other handles *-----------------------------------------------------------------*/ @@ -391,9 +441,10 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->ind_list = ind_list[sce_id]; reset_indices_enc( st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr, MAX_NUM_INDICES ); +#endif /* prepare stereo downmix for EVS */ if ( hEncoderConfig->stereo_dmx_evs == 1 ) @@ -416,7 +467,8 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN + /* allocate buffer of indices */ for ( n = 0; n < CPE_CHANNELS; n++ ) { st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->ind_list = ind_list[n]; @@ -426,6 +478,7 @@ ivas_error ivas_init_encoder( /* MetaData for DFT stereo */ st_ivas->hCPE[cpe_id]->hMetaData->ind_list = ind_list_metadata[0]; reset_indices_enc( st_ivas->hCPE[cpe_id]->hMetaData, MAX_BITS_METADATA ); +#endif } else if ( ivas_format == ISM_FORMAT ) { @@ -445,12 +498,14 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN + /* MetaData for ISMs */ st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->ind_list = ind_list[sce_id]; reset_indices_enc( st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr, MAX_NUM_INDICES ); st_ivas->hSCE[sce_id]->hMetaData->ind_list = ind_list_metadata[sce_id]; reset_indices_enc( st_ivas->hSCE[sce_id]->hMetaData, MAX_BITS_METADATA ); +#endif } if ( st_ivas->ism_mode == ISM_MODE_PARAM ) @@ -510,12 +565,14 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN + /* MetaData for SBA */ st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->ind_list = ind_list[sce_id]; reset_indices_enc( st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr, MAX_NUM_INDICES ); st_ivas->hSCE[sce_id]->hMetaData->ind_list = ind_list_metadata[sce_id]; reset_indices_enc( st_ivas->hSCE[sce_id]->hMetaData, MAX_BITS_METADATA ); +#endif if ( st_ivas->sba_mode == SBA_MODE_SPAR && st_ivas->hEncoderConfig->Opt_DTX_ON ) { @@ -530,11 +587,12 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ for ( n = 0; n < CPE_CHANNELS; n++ ) { +#ifndef IND_LIST_DYN st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->ind_list = ind_list[cpe_id * CPE_CHANNELS + n]; reset_indices_enc( st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr, MAX_NUM_INDICES ); +#endif if ( hEncoderConfig->Opt_DTX_ON ) { @@ -542,12 +600,14 @@ ivas_error ivas_init_encoder( } } +#ifndef IND_LIST_DYN /* Metadata only initialized for the last CPE index */ if ( cpe_id == st_ivas->nCPE - 1 ) { st_ivas->hCPE[cpe_id]->hMetaData->ind_list = ind_list_metadata[st_ivas->nSCE]; reset_indices_enc( st_ivas->hCPE[cpe_id]->hMetaData, MAX_BITS_METADATA ); } +#endif } if ( st_ivas->nCPE > 1 ) @@ -576,6 +636,8 @@ ivas_error ivas_init_encoder( return error; } +#ifndef IND_LIST_DYN + /* allocate buffer of indices */ for ( n = 0; n < CPE_CHANNELS; n++ ) { /* we need the correct bitstream also for the LFE channel since it might become a proper coded channel when @@ -590,6 +652,7 @@ ivas_error ivas_init_encoder( st_ivas->hCPE[cpe_id]->hMetaData->ind_list = ind_list_metadata[st_ivas->nSCE]; reset_indices_enc( st_ivas->hCPE[cpe_id]->hMetaData, MAX_BITS_METADATA ); } +#endif } if ( ( error = create_mct_enc( st_ivas ) ) != IVAS_ERR_OK ) @@ -623,6 +686,7 @@ ivas_error ivas_init_encoder( return error; } +#ifndef IND_LIST_DYN for ( n = 0; n < CPE_CHANNELS; n++ ) { /* we need the correct bitstream also for the LFE channel since it might become a proper coded channel when @@ -636,6 +700,7 @@ ivas_error ivas_init_encoder( st_ivas->hCPE[cpe_id]->hMetaData->ind_list = ind_list_metadata[st_ivas->nSCE]; reset_indices_enc( st_ivas->hCPE[cpe_id]->hMetaData, MAX_BITS_METADATA ); } +#endif } if ( ( error = create_mct_enc( st_ivas ) ) != IVAS_ERR_OK ) @@ -663,7 +728,8 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN + /* allocate buffer of indices */ for ( n = 0; n < CPE_CHANNELS; n++ ) { st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->ind_list = ind_list[cpe_id * CPE_CHANNELS + n]; @@ -676,6 +742,7 @@ ivas_error ivas_init_encoder( st_ivas->hCPE[cpe_id]->hMetaData->ind_list = ind_list_metadata[st_ivas->nSCE]; reset_indices_enc( st_ivas->hCPE[cpe_id]->hMetaData, MAX_BITS_METADATA ); } +#endif } if ( st_ivas->nCPE > 1 ) @@ -716,12 +783,14 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN + /* allocate buffer of indices */ st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr->ind_list = ind_list[sce_id]; reset_indices_enc( st_ivas->hSCE[sce_id]->hCoreCoder[0]->hBstr, MAX_NUM_INDICES ); st_ivas->hSCE[sce_id]->hMetaData->ind_list = ind_list_metadata[sce_id]; reset_indices_enc( st_ivas->hSCE[sce_id]->hMetaData, MAX_BITS_METADATA ); +#endif } for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ ) @@ -733,7 +802,8 @@ ivas_error ivas_init_encoder( return error; } - /* prepare bitstream buffers */ +#ifndef IND_LIST_DYN + /* allocate buffer of indices */ for ( n = 0; n < CPE_CHANNELS; n++ ) { st_ivas->hCPE[cpe_id]->hCoreCoder[n]->hBstr->ind_list = ind_list[cpe_id * CPE_CHANNELS + n + st_ivas->nSCE]; @@ -746,6 +816,7 @@ ivas_error ivas_init_encoder( st_ivas->hCPE[cpe_id]->hMetaData->ind_list = ind_list_metadata[st_ivas->nSCE]; reset_indices_enc( st_ivas->hCPE[cpe_id]->hMetaData, MAX_BITS_METADATA ); } +#endif } } } @@ -799,6 +870,10 @@ void destroy_core_enc( ENC_CORE_HANDLE hCoreCoder /* i/o: core encoder structure */ ) { +#ifdef IND_LIST_DYN + int16_t i; +#endif + destroy_cldfb_encoder( hCoreCoder ); if ( hCoreCoder->hSignalBuf != NULL ) @@ -809,6 +884,13 @@ void destroy_core_enc( if ( hCoreCoder->hBstr != NULL ) { +#ifdef IND_LIST_DYN + /* reset buffer of indices */ + for ( i = 0; i < hCoreCoder->hBstr->nb_ind_tot; i++ ) + { + hCoreCoder->hBstr->ind_list[i].nb_bits = -1; + } +#endif free( hCoreCoder->hBstr ); hCoreCoder->hBstr = NULL; } @@ -1045,6 +1127,19 @@ void ivas_destroy_enc( st_ivas->hEncoderConfig = NULL; } +#ifdef IND_LIST_DYN + /* Buffer of indices */ + if ( st_ivas->ind_list != NULL ) + { + free( st_ivas->ind_list ); + } + + if ( st_ivas->ind_list_metadata != NULL ) + { + free( st_ivas->ind_list_metadata ); + } +#endif + /* main IVAS handle */ free( st_ivas ); diff --git a/lib_enc/ivas_ism_dtx_enc.c b/lib_enc/ivas_ism_dtx_enc.c index 3a216b6164f2f335f41d921e73a4c80d9638584b..8f856ff07e8d1cf674ca9b12f0965c8b2282b5e5 100644 --- a/lib_enc/ivas_ism_dtx_enc.c +++ b/lib_enc/ivas_ism_dtx_enc.c @@ -167,7 +167,14 @@ int16_t ivas_ism_dtx_enc( if ( dtx_flag ) { /* reset the bitstream (IVAS format signaling was already written) */ - reset_indices_enc( hSCE[0]->hCoreCoder[0]->hBstr, MAX_NUM_INDICES ); + reset_indices_enc( hSCE[0]->hCoreCoder[0]->hBstr, + +#ifdef IND_LIST_DYN + hSCE[0]->hCoreCoder[0]->hBstr->nb_ind_tot +#else + MAX_NUM_INDICES +#endif + ); } /*------------------------------------------------------------------* diff --git a/lib_enc/ivas_ism_enc.c b/lib_enc/ivas_ism_enc.c index 5c310ac30fcb3a66be6e666712db0a70fd870d67..bfa1342bb57400cee47cd58112384a41707c12c4 100644 --- a/lib_enc/ivas_ism_enc.c +++ b/lib_enc/ivas_ism_enc.c @@ -87,6 +87,9 @@ ivas_error ivas_ism_enc( int16_t localVAD_HE_SAD[1]; /* local HE VAD */ int16_t nchan_ism, dtx_flag, sid_flag, flag_noisy_speech; int16_t md_diff_flag[MAX_NUM_OBJECTS]; +#ifdef IND_LIST_DYN + Encoder_State *prev_st = NULL; +#endif ivas_error error; push_wmops( "ivas_ism_enc" ); @@ -256,6 +259,14 @@ ivas_error ivas_ism_enc( hSCE = st_ivas->hSCE[sce_id]; st = hSCE->hCoreCoder[0]; +#ifdef IND_LIST_DYN + /* update pointer to the buffer of indices of the next channel */ + if ( sce_id > 0 ) + { + st->hBstr->ind_list = prev_st->hBstr->ind_list + prev_st->hBstr->nb_ind_tot; + } +#endif + if ( st->low_rate_mode ) { st->bwidth = WB; @@ -303,6 +314,10 @@ ivas_error ivas_ism_enc( /* Store previous attack detection flag */ st->hTranDet->transientDetector.prev_bIsAttackPresent = st->hTranDet->transientDetector.bIsAttackPresent; + +#ifdef IND_LIST_DYN + prev_st = st; +#endif } if ( dtx_flag ) diff --git a/lib_enc/ivas_ism_metadata_enc.c b/lib_enc/ivas_ism_metadata_enc.c index 732ffec21b7a2cf68d889caec204e9a9da3b0811..36d15266d26272e82485d1ebadf9936b57cdfc59 100644 --- a/lib_enc/ivas_ism_metadata_enc.c +++ b/lib_enc/ivas_ism_metadata_enc.c @@ -625,7 +625,11 @@ ivas_error ivas_ism_metadata_enc( /* write metadata only in active frames */ if ( hSCE[0]->hCoreCoder[0]->core_brate > SID_2k40 ) { +#ifdef IND_LIST_DYN + reset_indices_enc( hSCE[ch]->hMetaData, hSCE[ch]->hMetaData->nb_ind_tot ); +#else reset_indices_enc( hSCE[ch]->hMetaData, MAX_BITS_METADATA ); +#endif } } diff --git a/lib_enc/ivas_lfe_enc.c b/lib_enc/ivas_lfe_enc.c index a14424774ffec7ed5270d26f8d46926c9568e53e..9a5b7549420355b92f1219f695e7f9205e2831b0 100644 --- a/lib_enc/ivas_lfe_enc.c +++ b/lib_enc/ivas_lfe_enc.c @@ -98,7 +98,11 @@ static void ivas_lfe_enc_quant( BSTR_ENC_HANDLE hBstr ) { int16_t bits_written; +#ifdef IND_LIST_DYN + int16_t nb_ind_tot; +#else int16_t next_ind_pos; +#endif uint16_t quant_strategy, write_bit; int16_t num_quant_strategies; int16_t shift_bits; @@ -117,7 +121,11 @@ static void ivas_lfe_enc_quant( num_quant_strategies = IVAS_MAX_NUM_QUANT_STRATS; shift_bits = IVAS_LFE_SHIFT_BITS; bits_written = hBstr->nb_bits_tot; +#ifdef IND_LIST_DYN + nb_ind_tot = hBstr->nb_ind_tot; +#else next_ind_pos = hBstr->next_ind; +#endif for ( quant_strategy = 0; quant_strategy < num_quant_strategies; quant_strategy++ ) @@ -243,7 +251,11 @@ static void ivas_lfe_enc_quant( } bits_written_arith_enc = hBstr->nb_bits_tot; +#ifdef IND_LIST_DYN + next_ind_pos_arith_enc = hBstr->nb_ind_tot; +#else next_ind_pos_arith_enc = hBstr->next_ind; +#endif push_next_indice( hBstr, coding_strategy, 1 ); base2_num_bits_tot = hBstr->nb_bits_tot - bits_written; @@ -259,13 +271,24 @@ static void ivas_lfe_enc_quant( { if ( quant_strategy == ( num_quant_strategies - 1 ) || ( ( target_bits + IVAS_LFE_ID_BITS ) >= base2_num_bits_tot ) ) { +#ifdef IND_LIST_DYN + /* reset bits buffer and code the indices with base 2 coding */ + for ( j = hBstr->nb_ind_tot - 1; j >= next_ind_pos_arith_enc; j-- ) + { + hBstr->ind_list[j].nb_bits = -1; + } + hBstr->nb_ind_tot = next_ind_pos_arith_enc; +#else /* reset bits buffer and code the indices with base 2 coding */ for ( j = hBstr->next_ind - 1; j >= next_ind_pos_arith_enc; j-- ) { hBstr->ind_list[j].nb_bits = -1; } +#endif hBstr->nb_bits_tot = bits_written_arith_enc; +#ifndef IND_LIST_DYN hBstr->next_ind = next_ind_pos_arith_enc; +#endif coding_strategy = 1; push_next_indice( hBstr, coding_strategy, 1 ); @@ -298,13 +321,21 @@ static void ivas_lfe_enc_quant( if ( quant_strategy < ( num_quant_strategies - 1 ) ) { /* reset all indices that were already written - TODO: maybe better store them temporarily first and write at the very end? */ +#ifdef IND_LIST_DYN + for ( j = hBstr->nb_ind_tot - 1; j >= nb_ind_tot; j-- ) +#else for ( j = hBstr->next_ind - 1; j >= next_ind_pos; j-- ) +#endif { hBstr->ind_list[j].nb_bits = -1; } hBstr->nb_bits_tot = bits_written; +#ifdef IND_LIST_DYN + hBstr->nb_ind_tot = nb_ind_tot; +#else hBstr->next_ind = next_ind_pos; +#endif } } } diff --git a/lib_enc/ivas_mct_core_enc.c b/lib_enc/ivas_mct_core_enc.c index d1f47bcee301d0879caedf5377967cae0d38e021..1d57a61e91d399a0db3b2ff3636505d789eb52f2 100644 --- a/lib_enc/ivas_mct_core_enc.c +++ b/lib_enc/ivas_mct_core_enc.c @@ -410,6 +410,14 @@ void ivas_mct_core_enc( for ( ch = 0; ch < nChannels; ch++ ) { st = sts[ch]; + +#ifdef IND_LIST_DYN + /* update the pointer to the buffer of indices of the second channel */ + if ( ch > 0 ) + { + st->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } +#endif if ( sts[ch]->mct_chan_mode == MCT_CHAN_MODE_IGNORE ) { diff --git a/lib_enc/ivas_mct_enc.c b/lib_enc/ivas_mct_enc.c index 393c60f49eada48a8d03d7d4c1baa127fb8df467..b9f55e25e1219fb9304527089275119b9e73382b 100644 --- a/lib_enc/ivas_mct_enc.c +++ b/lib_enc/ivas_mct_enc.c @@ -260,6 +260,12 @@ ivas_error ivas_mct_enc( { hCPE = st_ivas->hCPE[cpe_id]; +#ifdef IND_LIST_DYN + if ( cpe_id > 0 ) + { + hCPE->hCoreCoder[0]->hBstr->ind_list = st_ivas->hCPE[cpe_id - 1]->hCoreCoder[1]->hBstr->ind_list + st_ivas->hCPE[cpe_id - 1]->hCoreCoder[1]->hBstr->nb_ind_tot; + } +#endif ivas_mdct_quant_coder( hCPE, hMCT->tnsBits[cpe_id], hMCT->tnsSize[cpe_id], hMCT->p_param[cpe_id], 1 ); diff --git a/lib_enc/ivas_mct_enc_mct.c b/lib_enc/ivas_mct_enc_mct.c index 7ab6206a29169407d4f8a3b2a6c57d7175684b36..228f48b305453884a1c4a8fef64abc9b2a22190b 100644 --- a/lib_enc/ivas_mct_enc_mct.c +++ b/lib_enc/ivas_mct_enc_mct.c @@ -851,6 +851,18 @@ void mctStereoIGF_enc( p_st[0] = sts[ch1]; p_st[1] = sts[ch2]; +#ifdef IND_LIST_DYN + if ( ch1 > 0 ) + { + sts[ch1]->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } + + if ( ch2 > 0 ) + { + sts[ch2]->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } +#endif + p_powerSpec[0] = powerSpec[ch1]; p_powerSpec[1] = powerSpec[ch2]; @@ -900,6 +912,13 @@ void mctStereoIGF_enc( continue; } +#ifdef IND_LIST_DYN + if ( ch > 0 ) + { + st->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } +#endif + nSubframes = st->hTcxEnc->tcxMode == TCX_20 ? 1 : NB_DIV; for ( n = 0; n < nSubframes; n++ ) { diff --git a/lib_enc/ivas_mdct_core_enc.c b/lib_enc/ivas_mdct_core_enc.c index 8135390f5a9006e9d9fe02039d0837689ac58e99..b3f76cc4ab7c611a04e97e8f99cb7c09ae231181 100644 --- a/lib_enc/ivas_mdct_core_enc.c +++ b/lib_enc/ivas_mdct_core_enc.c @@ -1422,6 +1422,13 @@ void ivas_mdct_quant_coder( { st = sts[ch]; +#ifdef IND_LIST_DYN + /* update the pointer to the buffer of indices of the second channel */ + if ( ch > 0 ) + { + st->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } +#endif if ( st->mct_chan_mode == MCT_CHAN_MODE_IGNORE ) { /*Enable appropriate upadte of tcx_curr_overlap_mode even for uncoded channel index 1*/ diff --git a/lib_enc/ivas_qmetadata_enc.c b/lib_enc/ivas_qmetadata_enc.c index 64d5b8e6aa86c91574a962280fcfff859334f420..909871f8fdcf55281b25422792283e5de4ce096b 100644 --- a/lib_enc/ivas_qmetadata_enc.c +++ b/lib_enc/ivas_qmetadata_enc.c @@ -169,7 +169,10 @@ ivas_error ivas_qmetadata_enc_encode( ) { int16_t i, bit_pos_start, bit_pos_start_coh; - int16_t next_ind_start, last_ind_start; + int16_t next_ind_start; +#ifndef IND_LIST_DYN + int16_t last_ind_start; +#endif uint16_t diffuseness_index_max_ec_frame; uint16_t diffuseness_index_max_ec_frame_pre[QMETADATA_MAX_NO_DIRECTIONS]; int16_t bits_dir_raw_pre[QMETADATA_MAX_NO_DIRECTIONS]; @@ -464,8 +467,12 @@ ivas_error ivas_qmetadata_enc_encode( /* Save state of metadata bitstream buffer after writing energy ratios, number of dirs and save space for coherence*/ bit_pos_start = hMetaData->nb_bits_tot; +#ifdef IND_LIST_DYN + next_ind_start = hMetaData->nb_ind_tot; +#else next_ind_start = hMetaData->next_ind; last_ind_start = hMetaData->last_ind; +#endif /* Encode quantized directions with EC frame-wise*/ if ( total_bits_1dir + bits_surround_coh <= hQMetaData->qmetadata_max_bit_req ) @@ -474,7 +481,11 @@ ivas_error ivas_qmetadata_enc_encode( bits_signaling[d]++; } +#ifdef IND_LIST_DYN + next_ind_raw_flag = hMetaData->nb_ind_tot; +#else next_ind_raw_flag = hMetaData->next_ind; +#endif push_next_indice( hMetaData, 0, 1 ); /* Raw coding flag*/ bits_dir_bands[0] = ivas_qmetadata_raw_encode_dir( NULL, q_direction, q_direction->cfg.nbands, q_direction->cfg.start_band ); @@ -511,7 +522,11 @@ ivas_error ivas_qmetadata_enc_encode( /* Encode quantized directions with EC band-wise */ if ( ( total_bits_1dir + bits_surround_coh <= hQMetaData->qmetadata_max_bit_req ) && ( bits_dir[d] + bits_diff[d] + bits_coherence[d] + bits_signaling[d] > total_bits_1dir ) && q_direction->cfg.nblocks > 1 ) { - restore_metadata_buffer( hMetaData, next_ind_start, last_ind_start, bit_pos_start ); + restore_metadata_buffer( hMetaData, next_ind_start, +#ifndef IND_LIST_DYN + last_ind_start, +#endif + bit_pos_start ); /* Write signaling */ push_next_indice( hMetaData, 1, 1 ); /*Write 1 bit to signal no EC frame-wise (EC1)*/ @@ -519,7 +534,11 @@ ivas_error ivas_qmetadata_enc_encode( bits_signaling[d] = 3; /* Write raw flags */ +#ifdef IND_LIST_DYN + next_ind_raw_flag = hMetaData->nb_ind_tot; +#else next_ind_raw_flag = hMetaData->next_ind; +#endif for ( i = start_band; i < nbands; i++ ) { push_next_indice( hMetaData, 0, 1 ); /* Raw coding flag*/ @@ -593,7 +612,11 @@ ivas_error ivas_qmetadata_enc_encode( /*Bit budget exceeded, bit reduction strategy?*/ extra_bits = 0; - restore_metadata_buffer( hMetaData, next_ind_start, last_ind_start, bit_pos_start ); + restore_metadata_buffer( hMetaData, next_ind_start, +#ifndef IND_LIST_DYN + last_ind_start, +#endif + bit_pos_start ); push_next_indice( hMetaData, 1, 1 ); /*Write 1 bit to signal no EC frame-wise (EC1)*/ if ( nblocks > 1 ) @@ -1216,15 +1239,19 @@ void ivas_qmetadata_enc_sid_encode( void reset_metadata_spatial( const IVAS_FORMAT ivas_format, /* i : IVAS format */ - BSTR_ENC_HANDLE hMetaData, /* i/o: Metadata bitstream handle */ + BSTR_ENC_HANDLE hMetaData, /* i/o: metadata bitstream handle */ const int32_t element_brate, /* i : element bitrate */ int32_t *total_brate, /* o : total bitrate */ const int32_t core_brate, /* i : core bitrate */ - const int16_t nb_bits_metadata, /* i : number of meatdata bits */ + const int16_t nb_bits_metadata, /* i : number of metadata bits */ const SBA_MODE sba_mode /* i : SBA mode */ ) { int16_t i, next_ind_sid, last_ind_sid; +#ifdef IND_LIST_DYN + int16_t j; +#endif + int16_t metadata_sid_bits; if ( core_brate == SID_2k40 || core_brate == FRAME_NO_DATA ) @@ -1233,7 +1260,9 @@ void reset_metadata_spatial( { if ( sba_mode == SBA_MODE_SPAR ) { +#ifdef DEBUGGING assert( hMetaData->ind_list[0].nb_bits == 1 ); +#endif hMetaData->ind_list[0].value = 1; metadata_sid_bits = (int16_t) ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS; while ( hMetaData->nb_bits_tot < metadata_sid_bits ) @@ -1244,15 +1273,22 @@ void reset_metadata_spatial( else { /* Reset metadata and keep only SID metadata*/ +#ifdef IND_LIST_DYN + last_ind_sid = hMetaData->nb_ind_tot; + next_ind_sid = hMetaData->nb_ind_tot; +#else last_ind_sid = hMetaData->next_ind; next_ind_sid = hMetaData->next_ind; +#endif while ( hMetaData->nb_bits_tot > nb_bits_metadata ) { next_ind_sid--; hMetaData->nb_bits_tot -= hMetaData->ind_list[next_ind_sid].nb_bits; } +#ifndef IND_LIST_DYN hMetaData->next_ind = 0; +#endif hMetaData->nb_bits_tot = 0; for ( i = 0; i < next_ind_sid; i++ ) @@ -1260,6 +1296,17 @@ void reset_metadata_spatial( hMetaData->ind_list[i].nb_bits = -1; } +#ifdef IND_LIST_DYN + for ( j = 0, i = next_ind_sid; i < last_ind_sid; i++, j++ ) + { + hMetaData->ind_list[j].value = hMetaData->ind_list[i].value; + hMetaData->ind_list[j].nb_bits = hMetaData->ind_list[i].nb_bits; + hMetaData->nb_bits_tot += hMetaData->ind_list[j].nb_bits; + hMetaData->ind_list[i].nb_bits = -1; + } + + hMetaData->nb_ind_tot = j; +#else for ( i = next_ind_sid; i < last_ind_sid; i++ ) { hMetaData->ind_list[hMetaData->next_ind].value = hMetaData->ind_list[i].value; @@ -1268,13 +1315,20 @@ void reset_metadata_spatial( hMetaData->next_ind++; hMetaData->ind_list[i].nb_bits = -1; } + hMetaData->last_ind = hMetaData->next_ind; +#endif +#ifdef DEBUGGING assert( ( hMetaData->nb_bits_tot == ( IVAS_SID_5k2 - SID_2k40 ) / FRAMES_PER_SEC - SID_FORMAT_NBITS ) && "Problem of SID metadata in SCE" ); +#endif } } else { /*Reset metadata*/ +#ifdef IND_LIST_DYN + reset_indices_enc( hMetaData, hMetaData->nb_ind_tot ); +#else for ( i = 0; i < hMetaData->next_ind; i++ ) { hMetaData->ind_list[i].nb_bits = -1; @@ -1282,6 +1336,7 @@ void reset_metadata_spatial( hMetaData->nb_bits_tot = 0; hMetaData->next_ind = 0; hMetaData->last_ind = 0; +#endif } *total_brate = element_brate; @@ -1291,12 +1346,22 @@ void reset_metadata_spatial( /* Reset SID metadata bits*/ while ( hMetaData->nb_bits_tot > nb_bits_metadata ) { +#ifdef IND_LIST_DYN + hMetaData->nb_ind_tot--; + hMetaData->nb_bits_tot -= hMetaData->ind_list[hMetaData->nb_ind_tot].nb_bits; + hMetaData->ind_list[hMetaData->nb_ind_tot].nb_bits = -1; +#else hMetaData->next_ind--; hMetaData->nb_bits_tot -= hMetaData->ind_list[hMetaData->next_ind].nb_bits; hMetaData->ind_list[hMetaData->next_ind].nb_bits = -1; +#endif } +#ifdef DEBUGGING assert( hMetaData->nb_bits_tot == nb_bits_metadata && "Problem in metadata for SCE" ); +#endif +#ifndef IND_LIST_DYN hMetaData->last_ind = hMetaData->next_ind; +#endif } return; @@ -2155,24 +2220,34 @@ static int16_t ivas_qmetadata_entropy_encode_df_ratio( /*------------------------------------------------------------------------- * restore_metadata_buffer() * - * Reset metadata buffer + * Restore metadata buffer *------------------------------------------------------------------------*/ void restore_metadata_buffer( BSTR_ENC_HANDLE hMetaData, const int16_t next_ind_start, +#ifndef IND_LIST_DYN const int16_t last_ind_start, +#endif const int16_t bit_pos_start ) { int16_t i; +#ifdef IND_LIST_DYN + for ( i = next_ind_start; i <= hMetaData->nb_ind_tot; i++ ) +#else for ( i = next_ind_start; i <= hMetaData->next_ind; i++ ) +#endif { hMetaData->ind_list[i].nb_bits = -1; } hMetaData->nb_bits_tot = bit_pos_start; +#ifdef IND_LIST_DYN + hMetaData->nb_ind_tot = next_ind_start; +#else hMetaData->next_ind = next_ind_start; hMetaData->last_ind = last_ind_start; +#endif return; } @@ -5775,7 +5850,11 @@ static int16_t ivas_qmetadata_quantize_coherence( else { /* write dummy data now and save the position */ +#ifdef IND_LIST_DYN + *indice_coherence = hMetaData->nb_ind_tot; +#else *indice_coherence = hMetaData->next_ind; +#endif k = nbits; while ( k > 0 ) { diff --git a/lib_enc/ivas_sce_enc.c b/lib_enc/ivas_sce_enc.c index c8577a85bae41f124907bdd60809cca4d529b7d6..1b3eac4f1af5e9203a536f9660c0c3b2c6141536 100644 --- a/lib_enc/ivas_sce_enc.c +++ b/lib_enc/ivas_sce_enc.c @@ -312,6 +312,14 @@ ivas_error create_sce_enc( { return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for MetaData structure\n" ) ); } + +#ifdef IND_LIST_DYN + /* set pointer to the buffer of metadata indices */ + hSCE->hMetaData->ind_list = st_ivas->ind_list_metadata; + hSCE->hMetaData->ivas_ind_list_zero = &st_ivas->ind_list_metadata; + hSCE->hMetaData->ivas_max_num_indices = &st_ivas->ivas_max_num_indices_metadata; + reset_indices_enc( hSCE->hMetaData, st_ivas->ivas_max_num_indices_metadata ); +#endif } else { @@ -332,7 +340,11 @@ ivas_error create_sce_enc( st->total_brate = hSCE->element_brate; /* dummy initialization for getting right pointers initialization of input buffers in init_coder_ace_plus() */ st->mct_chan_mode = MCT_CHAN_MODE_REGULAR; - if ( ( error = init_encoder( st, 0, st_ivas->hEncoderConfig->var_SID_rate_flag, st_ivas->hEncoderConfig->interval_SID, 0, st_ivas->ism_mode ) ) != IVAS_ERR_OK ) + if ( ( error = init_encoder( st, +#ifdef IND_LIST_DYN + st_ivas, +#endif + 0, st_ivas->hEncoderConfig->var_SID_rate_flag, st_ivas->hEncoderConfig->interval_SID, 0, st_ivas->ism_mode ) ) != IVAS_ERR_OK ) { return error; } diff --git a/lib_enc/ivas_spar_encoder.c b/lib_enc/ivas_spar_encoder.c index a7c359b7c96b6eaade81cf7fe35b58d88d154781..4837fcbb8a4030a92457ff494be61c2fe1f2b27c 100644 --- a/lib_enc/ivas_spar_encoder.c +++ b/lib_enc/ivas_spar_encoder.c @@ -235,7 +235,11 @@ ivas_error ivas_spar_enc_open( hSpar->hCoreCoderVAD->total_brate = hEncoderConfig->ivas_total_brate; /* dummy initialization for getting right pointers initialization of input buffers in init_coder_ace_plus() */ hSpar->hCoreCoderVAD->mct_chan_mode = MCT_CHAN_MODE_IGNORE; - if ( ( error = init_encoder( hSpar->hCoreCoderVAD, 0, hEncoderConfig->var_SID_rate_flag, hEncoderConfig->interval_SID, 1, st_ivas->ism_mode ) ) != IVAS_ERR_OK ) + if ( ( error = init_encoder( hSpar->hCoreCoderVAD, +#ifdef IND_LIST_DYN + st_ivas, +#endif + 0, hEncoderConfig->var_SID_rate_flag, hEncoderConfig->interval_SID, 1, st_ivas->ism_mode ) ) != IVAS_ERR_OK ) { return error; } diff --git a/lib_enc/ivas_spar_md_enc.c b/lib_enc/ivas_spar_md_enc.c index 4f9882cd245d9c9ed51aed8ffc0121292c0ba4d2..d96526375f11a80bc98d1b66c42f0a5553301c3c 100644 --- a/lib_enc/ivas_spar_md_enc.c +++ b/lib_enc/ivas_spar_md_enc.c @@ -526,17 +526,29 @@ static void write_metadata_buffer( BSTR_ENC_HANDLE hMetaData_tmp, BSTR_ENC_HANDLE hMetaData, const int16_t bit_pos_start, - const int16_t next_ind_start, - const int16_t last_ind_start ) + const int16_t next_ind_start +#ifndef IND_LIST_DYN + , + const int16_t last_ind_start +#endif +) { int16_t i; if ( hMetaData->nb_bits_tot > 0 ) { - restore_metadata_buffer( hMetaData, next_ind_start, last_ind_start, bit_pos_start ); + restore_metadata_buffer( hMetaData, next_ind_start, +#ifndef IND_LIST_DYN + last_ind_start, +#endif + bit_pos_start ); } +#ifdef IND_LIST_DYN + for ( i = 0; i < hMetaData_tmp->nb_ind_tot; i++ ) +#else for ( i = 0; i < hMetaData_tmp->next_ind; i++ ) +#endif { push_next_indice( hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits ); } @@ -574,9 +586,15 @@ ivas_error ivas_spar_md_enc_process( int16_t nB, bands_bw, packed_ok = 0; ivas_strats_t cs[MAX_CODING_STRATS]; int16_t code_strat; - int16_t bit_pos_start, next_ind_start, last_ind_start; + int16_t bit_pos_start, next_ind_start; +#ifndef IND_LIST_DYN + int16_t last_ind_start; +#endif BSTR_ENC_DATA hMetaData_tmp; Indice ind_list_tmp[MAX_BITS_METADATA]; // IVAS_fmToDo: size to be optimized +#ifdef IND_LIST_DYN + int16_t max_num_indices_tmp; +#endif float Wscale[IVAS_MAX_NUM_BANDS]; num_quant_strats = hMdEnc->spar_md_cfg.num_quant_strats; @@ -630,11 +648,20 @@ ivas_error ivas_spar_md_enc_process( } hMetaData_tmp.ind_list = ind_list_tmp; +#ifdef IND_LIST_DYN + max_num_indices_tmp = MAX_BITS_METADATA; + hMetaData_tmp.ivas_max_num_indices = &max_num_indices_tmp; + hMetaData_tmp.ivas_ind_list_zero = (Indice **) ( &hMetaData_tmp.ind_list ); +#endif /* Save state of metadata bitstream buffer */ bit_pos_start = hMetaData->nb_bits_tot; +#ifdef IND_LIST_DYN + next_ind_start = hMetaData->nb_ind_tot; +#else next_ind_start = hMetaData->next_ind; last_ind_start = hMetaData->last_ind; +#endif dmx_switch = 0; @@ -953,7 +980,12 @@ ivas_error ivas_spar_md_enc_process( if ( hMetaData->nb_bits_tot == bit_pos_start || hMetaData_tmp.nb_bits_tot < ( hMetaData->nb_bits_tot - bit_pos_start ) ) { - write_metadata_buffer( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start, last_ind_start ); + write_metadata_buffer( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start +#ifndef IND_LIST_DYN + , + last_ind_start +#endif + ); code_strat = strat; } if ( hMetaData->nb_bits_tot - bit_pos_start + ( ( ( hEncoderConfig->ivas_total_brate == IVAS_256k ) && ( sba_order == SBA_FOA_ORDER ) ) ? 1 : 0 ) <= hMdEnc->spar_md_cfg.tgt_bits_per_blk ) diff --git a/lib_enc/ivas_stat_enc.h b/lib_enc/ivas_stat_enc.h index 07cdae30b7dc7736a356ce047eb569abc38eb584..35ff4b483f2e1cc2e881c24eabd2e453a84aa416 100644 --- a/lib_enc/ivas_stat_enc.h +++ b/lib_enc/ivas_stat_enc.h @@ -319,6 +319,12 @@ typedef struct stereo_mdct_enc_data_structure typedef struct stereo_td_enc_data_structure { +#ifdef IND_LIST_DYN + BSTR_ENC_DATA tdm_hBstr_tmp; /* temporary bitstream structure holding TD stereo spatial parameters */ + Indice tdm_ind_list_tmp[MAX_IND_TDM_TMP]; /* temporary list of indices holding TD stereo spatial parameters */ + int16_t max_ind_tdm_tmp; /* maximum number of indices in the temporary list of indices holding TD stereo spatial parameters */ +#endif + int16_t tdm_lp_reuse_flag; /* Flag that indicate if it is possible to reuse the LP coefficient from the primary channel or not */ int16_t tdm_low_rate_mode; /* secondary channel low rate mode flag */ float tdm_Pri_pitch_buf[NB_SUBFR]; @@ -1092,6 +1098,13 @@ typedef struct { ENCODER_CONFIG_HANDLE hEncoderConfig; /* Encoder configuration structure */ +#ifdef IND_LIST_DYN + Indice *ind_list; /* List of indices */ + int16_t ivas_max_num_indices; /* Maximum allowed number of indices in the list */ + Indice *ind_list_metadata; /* List of indices for metadata */ + int16_t ivas_max_num_indices_metadata; /* Maximum allowed number of indices in the list of metadata */ +#endif + /* high-level encoder parameters */ int16_t nchan_transport; /* number of transport channels */ int16_t sba_analysis_order; /* Ambisonic (SBA) order used for analysis and coding */ diff --git a/lib_enc/ivas_stereo_mdct_core_enc.c b/lib_enc/ivas_stereo_mdct_core_enc.c index 2e739cc90651f43dc4f4d7d9adb4e733425e15fd..03fcad485a8493450e60aa5f673c257d11a2444c 100644 --- a/lib_enc/ivas_stereo_mdct_core_enc.c +++ b/lib_enc/ivas_stereo_mdct_core_enc.c @@ -362,7 +362,13 @@ void stereo_mdct_core_enc( for ( ch = 0; ch < CPE_CHANNELS; ch++ ) { st = sts[ch]; - +#ifdef IND_LIST_DYN + /* update the pointer to the buffer of indices of the second channel */ + if ( ch == 1 ) + { + st->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } +#endif ProcessIGF( st, st->hTcxEnc->spectrum[n], orig_spectrum[ch][n], &powerSpec[ch][n * L_subframeTCX], st->core == TCX_20_CORE, n, hCPE->hCoreCoder[0]->sp_aud_decision0, 0 ); } } @@ -373,6 +379,13 @@ void stereo_mdct_core_enc( for ( ch = 0; ch < CPE_CHANNELS; ch++ ) { st = sts[ch]; +#ifdef IND_LIST_DYN + /* update the pointer to the buffer of indices of the second channel */ + if ( ch == 1 ) + { + st->hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } +#endif nSubframes = ( st->hTcxEnc->tcxMode == TCX_20 ) ? 1 : NB_DIV; if ( st->igf ) { diff --git a/lib_enc/ivas_stereo_td_enc.c b/lib_enc/ivas_stereo_td_enc.c index 3857795dceadc5a1f43a07939971f77ac20dcd90..2357e307c56bb49cd1b862f7dd57ee15b8220433 100644 --- a/lib_enc/ivas_stereo_td_enc.c +++ b/lib_enc/ivas_stereo_td_enc.c @@ -124,6 +124,14 @@ void stereo_td_init_enc( hStereoTD->tdm_prev_desired_idx = LRTD_STEREO_LEFT_IS_PRIM; } +#ifdef IND_LIST_DYN + hStereoTD->tdm_hBstr_tmp.ind_list = hStereoTD->tdm_ind_list_tmp; + hStereoTD->tdm_hBstr_tmp.ivas_ind_list_zero = (Indice **) ( &hStereoTD->tdm_hBstr_tmp.ind_list ); + hStereoTD->max_ind_tdm_tmp = MAX_IND_TDM_TMP; + hStereoTD->tdm_hBstr_tmp.ivas_max_num_indices = &hStereoTD->max_ind_tdm_tmp; + reset_indices_enc( &hStereoTD->tdm_hBstr_tmp, MAX_IND_TDM_TMP ); +#endif + return; } @@ -314,12 +322,16 @@ void tdm_configure_enc( int16_t tdm_ratio_bit_alloc_idx, mod_ct; STEREO_TD_ENC_DATA_HANDLE hStereoTD; Encoder_State **sts; +#ifndef IND_LIST_DYN BSTR_ENC_HANDLE hBstr; +#endif int16_t loc_coder_tyape_raw0; hStereoTD = hCPE->hStereoTD; sts = hCPE->hCoreCoder; +#ifndef IND_LIST_DYN hBstr = sts[1]->hBstr; +#endif loc_coder_tyape_raw0 = sts[0]->coder_type_raw; /*----------------------------------------------------------------* @@ -475,6 +487,46 @@ void tdm_configure_enc( * Bitstream writing *----------------------------------------------------------------*/ +#ifdef IND_LIST_DYN + /* transmit the ratio index */ + if ( tdm_SM_or_LRTD_Pri && hStereoTD->tdm_LRTD_flag == 0 ) + { + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_TD_ALPHA, tdm_ratio_idx_SM, TDM_RATIO_BITS ); + } + else + { + if ( hStereoTD->tdm_LRTD_flag == 1 ) + { + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_TD_ALPHA, hStereoTD->tdm_inst_ratio_idx, TDM_RATIO_BITS ); + } + else + { + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_TD_ALPHA, tdm_ratio_idx, TDM_RATIO_BITS ); + } + } + + /* LPC reuse flag */ + if ( sts[1]->coder_type == INACTIVE && tdm_ratio_idx < 29 && tdm_ratio_idx > 1 ) + { + /* normal TD, tdm_lp_reuse_flag always on, tdm_use_IAWB_Ave_lpc varies tdm_ratio_idx<29 && tdm_ratio_idx> 1*/ + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_LPC_REUSE, hStereoTD->tdm_use_IAWB_Ave_lpc, TDM_LP_REUSE_BITS ); + } + else + { + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_LPC_REUSE, hStereoTD->tdm_lp_reuse_flag, TDM_LP_REUSE_BITS ); + } + + /* LRTD flag */ + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_LRTD_FLAG, hStereoTD->tdm_LRTD_flag, TDM_LR_CONTENT_BITS ); + + /* Stereo ICA parameters */ + if ( hStereoTD->tdm_LRTD_flag == 0 ) + { + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_REFCHAN, hCPE->hStereoTCA->refChanIndx, STEREO_BITS_TCA_CHAN ); + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_CORRSTATS, hCPE->hStereoTCA->indx_ica_NCShift, STEREO_BITS_TCA_CORRSTATS ); + push_indice( &hStereoTD->tdm_hBstr_tmp, IND_STEREO_GD, hCPE->hStereoTCA->indx_ica_gD, STEREO_BITS_TCA_GD ); + } +#else /* transmit the ratio index */ if ( tdm_SM_or_LRTD_Pri && hStereoTD->tdm_LRTD_flag == 0 ) { @@ -513,12 +565,14 @@ void tdm_configure_enc( push_indice( hBstr, IND_STEREO_CORRSTATS, hCPE->hStereoTCA->indx_ica_NCShift, STEREO_BITS_TCA_CORRSTATS ); push_indice( hBstr, IND_STEREO_GD, hCPE->hStereoTCA->indx_ica_gD, STEREO_BITS_TCA_GD ); } +#endif #ifdef DEBUG_MODE_TD dbgwrite( &hStereoTD->tdm_low_rate_mode, 2, 1, 320, "res/tdm_low_rate_mode" ); dbgwrite( &hStereoTD->tdm_lp_reuse_flag, 2, 1, 320, "res/tdm_lp_reuse_flag" ); dbgwrite( &mod_ct, 2, 1, 320, "res/mod_ct.enx" ); #endif + /*----------------------------------------------------------------* * Updates *----------------------------------------------------------------*/ diff --git a/lib_enc/lib_enc.c b/lib_enc/lib_enc.c index c0c23b8dd9cf7a725e55b22a37dd78d140bcc8a7..3da409f6aed9736df3c61e2e3abf3f51bf9d915e 100755 --- a/lib_enc/lib_enc.c +++ b/lib_enc/lib_enc.c @@ -35,11 +35,13 @@ #include "prot.h" #include #include +#include #include #ifdef DEBUGGING #include "debug.h" #endif #include "wmc_auto.h" +#include "options.h" /*---------------------------------------------------------------------* * Local struct @@ -48,8 +50,12 @@ struct IVAS_ENC { Encoder_Struct *st_ivas; - Indice ind_list[MAX_NUM_DATA][MAX_NUM_INDICES]; /* list of indices */ +#ifndef IND_LIST_DYN + Indice ind_list[MAX_NUM_DATA][MAX_NUM_INDICES]; /* list of indices */ +#endif +#ifndef IND_LIST_DYN Indice ind_list_metadata[MAX_NUM_METADATA][MAX_BITS_METADATA]; /* list of indices for metadata */ +#endif ENC_CORE_HANDLE hCoreCoder; bool isConfigured; #ifdef DEBUGGING @@ -100,7 +106,9 @@ ivas_error IVAS_ENC_Open( ) { Encoder_Struct *st_ivas; +#ifndef IND_LIST_DYN int16_t i, j; +#endif if ( phIvasEnc == NULL ) { @@ -135,6 +143,7 @@ ivas_error IVAS_ENC_Open( * Initialize indices *-----------------------------------------------------------------*/ +#ifndef IND_LIST_DYN for ( i = 0; i < MAX_NUM_DATA; ++i ) { for ( j = 0; j < MAX_NUM_INDICES; ++j ) @@ -143,7 +152,9 @@ ivas_error IVAS_ENC_Open( ( *phIvasEnc )->ind_list[i][j].value = 0; } } +#endif +#ifndef IND_LIST_DYN for ( i = 0; i < MAX_NUM_METADATA; ++i ) { for ( j = 0; j < MAX_BITS_METADATA; ++j ) @@ -152,6 +163,7 @@ ivas_error IVAS_ENC_Open( ( *phIvasEnc )->ind_list_metadata[i][j].value = 0; } } +#endif /*-----------------------------------------------------------------* * Allocate IVAS-codec encoder state @@ -179,6 +191,11 @@ ivas_error IVAS_ENC_Open( /* initialize pointers to handles to NULL */ ivas_initialize_handles_enc( st_ivas ); +#ifdef IND_LIST_DYN + st_ivas->ind_list = NULL; + st_ivas->ind_list_metadata = NULL; +#endif + /* set high-level parameters */ st_ivas->mc_mode = MC_MODE_NONE; st_ivas->ism_mode = ISM_MODE_NONE; @@ -912,7 +929,16 @@ static ivas_error configureEncoder( * Finalize initialization *-----------------------------------------------------------------*/ - if ( ( error = ivas_init_encoder( st_ivas, hIvasEnc->ind_list, hIvasEnc->ind_list_metadata ) ) != IVAS_ERR_OK ) + if ( ( error = ivas_init_encoder( st_ivas +#ifndef IND_LIST_DYN + , + hIvasEnc->ind_list +#endif +#ifndef IND_LIST_DYN + , + hIvasEnc->ind_list_metadata +#endif + ) ) != IVAS_ERR_OK ) { return error; } @@ -1053,6 +1079,9 @@ ivas_error IVAS_ENC_EncodeFrameToSerial( ENCODER_CONFIG_HANDLE hEncoderConfig; ENC_CORE_HANDLE hCoreCoder; int16_t i; +#ifdef IND_LIST_DYN + int16_t n, ch; +#endif ivas_error error; error = IVAS_ERR_OK; @@ -1120,6 +1149,89 @@ ivas_error IVAS_ENC_EncodeFrameToSerial( hIvasEnc->switchingActive = true; } +#ifdef IND_LIST_DYN + /*-----------------------------------------------------------------* + * Re-allocate and re-initialize buffer of indices if IVAS total bitrate has changed + *-----------------------------------------------------------------*/ + + if ( hEncoderConfig->ivas_total_brate != hEncoderConfig->last_ivas_total_brate ) + { + /* de-allocate old buffer of indices */ + free( st_ivas->ind_list ); + + /* set the maximum allowed number of indices in the list */ + st_ivas->ivas_max_num_indices = get_ivas_max_num_indices( hEncoderConfig->ivas_format, hEncoderConfig->ivas_total_brate ); + + /* allocate new buffer of indices */ + if ( ( st_ivas->ind_list = (INDICE_HANDLE) malloc( st_ivas->ivas_max_num_indices * sizeof( Indice ) ) ) == NULL ) + { + return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for buffer of indices!\n" ) ); + } + + /* reset the list of indices */ + for ( i = 0; i < st_ivas->ivas_max_num_indices; i++ ) + { + st_ivas->ind_list[i].nb_bits = -1; + } + + /* de-allocate old buffer of metadata indices */ + if ( st_ivas->ind_list_metadata != NULL ) + { + free( st_ivas->ind_list_metadata ); + } + + /* set the maximum allowed number of metadata indices in the list */ + st_ivas->ivas_max_num_indices_metadata = get_ivas_max_num_indices_metadata( hEncoderConfig->ivas_format, hEncoderConfig->ivas_total_brate ); + + if ( st_ivas->ivas_max_num_indices_metadata > 0 ) + { + /* allocate new buffer of metadata indices */ + if ( ( st_ivas->ind_list_metadata = (INDICE_HANDLE) malloc( st_ivas->ivas_max_num_indices_metadata * sizeof( Indice ) ) ) == NULL ) + { + return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for buffer of metadata indices!\n" ) ); + } + + /* reset the list of metadata indices */ + for ( i = 0; i < st_ivas->ivas_max_num_indices_metadata; i++ ) + { + st_ivas->ind_list_metadata[i].nb_bits = -1; + } + } + else + { + st_ivas->ind_list_metadata = NULL; + } + + /* set pointers to the new buffers of indices in each element */ + for ( n = 0; n < st_ivas->nSCE; n++ ) + { + st_ivas->hSCE[n]->hCoreCoder[0]->hBstr->ind_list = st_ivas->ind_list; + st_ivas->hSCE[n]->hCoreCoder[0]->hBstr->ivas_ind_list_zero = &st_ivas->ind_list; + + if ( st_ivas->hSCE[n]->hMetaData != NULL ) + { + st_ivas->hSCE[n]->hMetaData->ind_list = st_ivas->ind_list_metadata; + st_ivas->hSCE[n]->hMetaData->ivas_ind_list_zero = &st_ivas->ind_list_metadata; + } + } + + for ( n = 0; n < st_ivas->nCPE; n++ ) + { + for ( ch = 0; ch < CPE_CHANNELS; ch++ ) + { + st_ivas->hCPE[n]->hCoreCoder[ch]->hBstr->ind_list = st_ivas->ind_list; + st_ivas->hCPE[n]->hCoreCoder[ch]->hBstr->ivas_ind_list_zero = &st_ivas->ind_list; + } + + if ( st_ivas->hCPE[n]->hMetaData != NULL ) + { + st_ivas->hCPE[n]->hMetaData->ind_list = st_ivas->ind_list_metadata; + st_ivas->hCPE[n]->hMetaData->ivas_ind_list_zero = &st_ivas->ind_list_metadata; + } + } + } +#endif + if ( hIvasEnc->switchingActive && hEncoderConfig->ivas_format == MONO_FORMAT ) { copy_encoder_config( st_ivas, hCoreCoder, 0 ); diff --git a/lib_enc/stat_enc.h b/lib_enc/stat_enc.h index ec7fb594d1a9d6c326de1f3964f895fd1c7ba01b..77c0ea3d34eb98386bb3a23a3128044af9cc7859 100644 --- a/lib_enc/stat_enc.h +++ b/lib_enc/stat_enc.h @@ -51,11 +51,20 @@ * Indice *------------------------------------------------------------------------------------------*/ +#ifdef IND_LIST_DYN +typedef struct +{ + int16_t id; /* id of the indice */ + uint16_t value; /* value of the quantized indice */ + int16_t nb_bits; /* number of bits used for the quantization of the indice */ +} Indice, *INDICE_HANDLE; +#else typedef struct { uint16_t value; /* value of the quantized indice */ int16_t nb_bits; /* number of bits used for the quantization of the indice */ } Indice; +#endif /*----------------------------------------------------------------------------------* * Bitstream structure @@ -63,11 +72,19 @@ typedef struct typedef struct bitstream_enc_data_structure { +#ifdef IND_LIST_DYN + int16_t nb_ind_tot; /* total number of indices already written */ +#endif int16_t nb_bits_tot; /* total number of bits already written */ Indice *ind_list; /* list of indices */ - int16_t next_ind; /* pointer to the next empty slot in the list of indices */ - int16_t last_ind; /* last written indice */ - +#ifndef IND_LIST_DYN + int16_t next_ind; /* pointer to the next empty slot in the list of indices */ + int16_t last_ind; /* last written indice */ +#endif +#ifdef IND_LIST_DYN + int16_t *ivas_max_num_indices; /* maximum total number of indices in the list */ + Indice **ivas_ind_list_zero; /* beginning of the buffer of indices */ +#endif } BSTR_ENC_DATA, *BSTR_ENC_HANDLE; /*----------------------------------------------------------------------------------* diff --git a/lib_enc/tcx_utils_enc.c b/lib_enc/tcx_utils_enc.c index ba709f0158fee7c34847204f8e5984c5a50b61c9..8099b8cb073c000dc45f5458f172bde8db18e26b 100644 --- a/lib_enc/tcx_utils_enc.c +++ b/lib_enc/tcx_utils_enc.c @@ -1486,11 +1486,19 @@ void ProcessIGF( } else { +#ifdef IND_LIST_DYN + pBsStart = hBstr->nb_ind_tot; +#else pBsStart = hBstr->next_ind; +#endif IGFEncWriteBitstream( hIGFEnc, hBstr, &hIGFEnc->infoTotalBitsPerFrameWritten, igfGridIdx, isIndepFlag ); +#ifdef IND_LIST_DYN + bsBits = hBstr->nb_ind_tot - pBsStart; +#else bsBits = hBstr->next_ind - pBsStart; +#endif IGFEncConcatenateBitstream( hIGFEnc, bsBits, hBstr ); } @@ -1570,11 +1578,24 @@ void ProcessStereoIGF( else { hBstr = sts[ch]->hBstr; +#ifdef IND_LIST_DYN + pBsStart = hBstr->nb_ind_tot; +#else pBsStart = hBstr->next_ind; - +#endif +#ifdef IND_LIST_DYN + if ( ch > 0 ) + { + hBstr->ind_list = sts[0]->hBstr->ind_list + sts[0]->hBstr->nb_ind_tot; + } +#endif IGFEncWriteBitstream( hIGFEnc[ch], hBstr, &hIGFEnc[ch]->infoTotalBitsPerFrameWritten, igfGridIdx, isIndepFlag ); +#ifdef IND_LIST_DYN + bsBits = hBstr->nb_ind_tot - pBsStart; +#else bsBits = hBstr->next_ind - pBsStart; +#endif IGFEncConcatenateBitstream( hIGFEnc[ch], bsBits, hBstr ); } }