Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : #include <assert.h>
34 : #include "options.h"
35 : #include <stdint.h>
36 : #include "cnst.h"
37 : #include "rom_enc.h"
38 : #include "rom_com.h"
39 : #include "prot.h"
40 : #include "ivas_prot.h"
41 : #include "ivas_prot_rend.h"
42 : #include "ivas_cnst.h"
43 : #include "ivas_rom_com.h"
44 : #include "ivas_rom_dec.h"
45 : #include "math.h"
46 : #ifdef DEBUGGING
47 : #include "debug.h"
48 : #endif
49 : #ifdef DEBUG_PLOT
50 : #include "deb_out.h"
51 : #endif
52 : #include "wmc_auto.h"
53 : #include "rom_dec.h"
54 :
55 : /*-----------------------------------------------------------------------*
56 : * Local constants
57 : *-----------------------------------------------------------------------*/
58 :
59 : #define PARAM_MC_LOCAL_SZ_LFE_MAP 5
60 :
61 : /*-----------------------------------------------------------------------*
62 : * Local typedefs
63 : *-----------------------------------------------------------------------*/
64 :
65 : typedef struct parameter_band_mapping_struct
66 : {
67 : int16_t n_source_bands[20];
68 : int16_t source_band_idx[20][4];
69 : float source_band_factor[20][4];
70 :
71 : } PARAM_MC_PARAMETER_BAND_MAPPING;
72 :
73 : /*-----------------------------------------------------------------------*
74 : * Local function prototypes
75 : *-----------------------------------------------------------------------*/
76 :
77 : static void ivas_param_mc_dec_init( PARAM_MC_DEC_HANDLE hParamMC, const int16_t nchan_in, const int16_t nchan_out );
78 :
79 : static void param_mc_protoSignalComputation( float *RealBuffer, float *ImagBuffer, float *proto_frame_f, const PARAM_MC_DIFF_PROTO_INFO *diff_proto_info, const int16_t num_freq_bands );
80 :
81 : static void ivas_param_mc_dec_copy_diffuse_proto( PARAM_MC_DEC_HANDLE hParamMC, float Cldfb_buffer_real[MAX_LS_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], float Cldfb_buffer_imag[MAX_LS_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], const int16_t nY, const int16_t slot_idx );
82 :
83 : static int16_t ivas_param_mc_range_decoder_LC( uint16_t *bit_buffer, int16_t *x, int16_t *BER_detect, const int16_t sz_seq, const int16_t sz_alphabet, const uint16_t *cft, const uint16_t *sft, const int16_t tot_shift, const int16_t nbbits );
84 :
85 : static int16_t ivas_param_mc_uniform_decoder( float *seq, const int16_t sz_seq, const float *alphabet, const int16_t N, uint16_t bit_buffer[PARAM_MC_MAX_BITS] );
86 :
87 : static void ivas_param_mc_dequantize_cov( PARAM_MC_DEC_HANDLE hDirAC, float *ild_q, float *icc_q, const int16_t param_band_index, const int16_t nY_int, const PARAM_MC_SYNTHESIS_CONF synth_conf, const int16_t nY, const int16_t nX, float *Cx_state, float *Cproto, float *Cy_state );
88 :
89 : static void ivas_param_mc_get_mixing_matrices( PARAM_MC_DEC_HANDLE hParamMC, IVAS_OUTPUT_SETUP *hSynthesisOutputSetup, float Cx_in[PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS], const int16_t param_band_idx, float *mixing_matrix[], float *mixing_matrix_res[], const int16_t nY_int, const PARAM_MC_SYNTHESIS_CONF synth_conf, const int16_t nX, const int16_t nY );
90 :
91 : static void param_mc_update_mixing_matrices( PARAM_MC_DEC_HANDLE hParamMC, float *mixing_matrix[], float *mixing_matrix_res[], const uint16_t nX, const uint16_t nY );
92 :
93 : static void ivas_param_mc_dec_compute_interpolator( const uint16_t bAttackPresent, const uint16_t attackPos, const uint16_t interp_length, float *interpolator );
94 :
95 : static void param_mc_set_num_synth_bands( const int32_t output_Fs, PARAM_MC_DEC_HANDLE hParamMC );
96 :
97 : static ivas_error param_mc_get_diff_proto_info( const float *proto_mtx, const uint16_t nchan_transport, const uint16_t nchan_out_cov, PARAM_MC_DIFF_PROTO_INFO *p_diff_proto_info );
98 :
99 : static void ivas_param_mc_get_param_band_mapping( const int16_t n_target_bands, const int16_t *target_band_grouping, const int16_t n_source_bands, const int16_t *source_band_grouping, PARAM_MC_PARAMETER_BAND_MAPPING *parameter_band_mapping );
100 :
101 : static void ivas_param_mc_bs_decode_parameter_values( uint16_t bit_buffer[], int16_t *bit_pos, const int16_t max_bits, int16_t *BER_detect, HANDLE_IVAS_PARAM_MC_METADATA hMetadataPMC, HANDLE_PARAM_MC_PARAMETER_CODING_INFO hParamCodingInfo, const int16_t map_size_wo_lfe, const int16_t map_size, const int16_t num_lfe_bands, const int16_t band_step, const int16_t num_param_bands, float *value_buffer );
102 :
103 : /*-------------------------------------------------------------------------
104 : * ivas_param_mc_dec_open()
105 : *
106 : * Open Parametric MC decoder handle
107 : *-------------------------------------------------------------------------*/
108 :
109 5665 : ivas_error ivas_param_mc_dec_open(
110 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
111 : )
112 : {
113 : int16_t k, nchan_transport;
114 : PARAM_MC_DEC_HANDLE hParamMC;
115 : int16_t nchan_out_transport;
116 : int16_t nchan_out_cov;
117 : float proto_matrix[MAX_LS_CHANNELS * PARAM_MC_MAX_TRANSPORT_CHANS];
118 : float proto_mtx_norm;
119 : int16_t max_param_band_residual;
120 : uint16_t config_index;
121 : MC_LS_SETUP mc_ls_setup;
122 : float frequency_axis[CLDFB_NO_CHANNELS_MAX];
123 : AUDIO_CONFIG output_config;
124 : int32_t output_Fs, ivas_total_brate;
125 : ivas_error error;
126 :
127 5665 : error = IVAS_ERR_OK;
128 :
129 : /*-----------------------------------------------------------------*
130 : * prepare library opening
131 : *-----------------------------------------------------------------*/
132 :
133 5665 : if ( ( hParamMC = (PARAM_MC_DEC_HANDLE) malloc( sizeof( PARAM_MC_DEC_DATA ) ) ) == NULL )
134 : {
135 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
136 : }
137 :
138 5665 : if ( ( hParamMC->hMetadataPMC = (HANDLE_IVAS_PARAM_MC_METADATA) malloc( sizeof( IVAS_PARAM_MC_METADATA ) ) ) == NULL )
139 : {
140 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC metadata \n" ) );
141 : }
142 :
143 5665 : output_Fs = st_ivas->hDecoderConfig->output_Fs;
144 5665 : output_config = st_ivas->hDecoderConfig->output_config;
145 5665 : ivas_total_brate = st_ivas->hDecoderConfig->ivas_total_brate;
146 5665 : mc_ls_setup = ivas_mc_map_output_config_to_mc_ls_setup( st_ivas->transport_config );
147 5665 : nchan_out_transport = st_ivas->hTransSetup.nchan_out_woLFE + st_ivas->hTransSetup.num_lfe;
148 5665 : hParamMC->hoa_encoder = NULL;
149 :
150 : /* determine the synthesis config */
151 5665 : if ( st_ivas->renderer_type == RENDERER_SBA_LINEAR_ENC || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM || st_ivas->renderer_type == RENDERER_BINAURAL_OBJECTS_TD || st_ivas->transport_config == output_config || output_config == IVAS_AUDIO_CONFIG_EXTERNAL )
152 : {
153 4472 : hParamMC->synthesis_conf = PARAM_MC_SYNTH_DIRECT;
154 : }
155 1193 : else if ( output_config == IVAS_AUDIO_CONFIG_MONO || output_config == IVAS_AUDIO_CONFIG_STEREO )
156 : {
157 256 : hParamMC->synthesis_conf = PARAM_MC_SYNTH_MONO_STEREO;
158 : }
159 937 : else if ( st_ivas->transport_config != output_config )
160 : {
161 937 : if ( ( output_config != IVAS_AUDIO_CONFIG_LS_CUSTOM && nchan_out_transport > audioCfg2channels( output_config ) ) || ( output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM && nchan_out_transport > st_ivas->hOutSetup.nchan_out_woLFE ) )
162 : {
163 112 : hParamMC->synthesis_conf = PARAM_MC_SYNTH_LS_CONV_COV;
164 : /* need to reset the intern config */
165 112 : st_ivas->intern_config = output_config;
166 112 : ivas_output_init( &( st_ivas->hIntSetup ), st_ivas->intern_config );
167 112 : if ( output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM )
168 : {
169 0 : st_ivas->hIntSetup.nchan_out_woLFE = st_ivas->hLsSetupCustom->num_spk;
170 0 : st_ivas->hIntSetup.ls_azimuth = st_ivas->hLsSetupCustom->ls_azimuth;
171 0 : st_ivas->hIntSetup.ls_elevation = st_ivas->hLsSetupCustom->ls_elevation;
172 : }
173 : }
174 : else
175 : {
176 825 : hParamMC->synthesis_conf = PARAM_MC_SYNTH_LS_CONV_CLDFB;
177 : }
178 : }
179 :
180 5665 : hParamMC->ls_conv_dmx_matrix = NULL;
181 :
182 5665 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
183 : {
184 368 : nchan_out_cov = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
185 : }
186 : else
187 : {
188 5297 : nchan_out_cov = nchan_out_transport;
189 : }
190 :
191 5665 : st_ivas->nchan_transport = ivas_param_mc_getNumTransportChannels( ivas_total_brate, mc_ls_setup );
192 5665 : config_index = ivas_param_mc_get_configuration_index( mc_ls_setup, ivas_total_brate );
193 5665 : nchan_transport = st_ivas->nchan_transport;
194 :
195 5665 : switch ( nchan_transport )
196 : {
197 1530 : case 4:
198 : case 3:
199 1530 : st_ivas->nCPE = 2;
200 1530 : st_ivas->nSCE = 0;
201 1530 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
202 1530 : break;
203 4135 : case 2:
204 4135 : st_ivas->nCPE = 1;
205 4135 : st_ivas->nSCE = 0;
206 4135 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
207 :
208 4135 : break;
209 : #ifdef DEBUGGING
210 : default:
211 : assert( 0 && "Number of TC not supported for Parametric MC!" );
212 : #endif
213 : }
214 :
215 : /*-----------------------------------------------------------------*
216 : * set input parameters
217 : *-----------------------------------------------------------------*/
218 :
219 5665 : hParamMC->slot_size = (int16_t) ( output_Fs / FRAMES_PER_SEC ) / CLDFB_NO_COL_MAX;
220 5665 : set_s( hParamMC->subframe_nbslots, 0, MAX_JBM_SUBFRAMES_5MS );
221 5665 : set_s( hParamMC->subframe_nbslots, PARAM_MC_MAX_NSLOTS_IN_SUBFRAME, DEFAULT_JBM_SUBFRAMES_5MS );
222 5665 : hParamMC->nb_subframes = DEFAULT_JBM_SUBFRAMES_5MS;
223 :
224 5665 : hParamMC->num_freq_bands = (int16_t) ( output_Fs * INV_CLDFB_BANDWIDTH + 0.5f );
225 5665 : hParamMC->max_band_energy_compensation = hParamMC->num_freq_bands;
226 5665 : ivas_param_mc_metadata_open( mc_ls_setup, ivas_total_brate, hParamMC->hMetadataPMC );
227 :
228 : /* init arrays for quantized parameters */
229 5665 : if ( ( hParamMC->icc_q = (float *) malloc( hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->icc_mapping_conf->icc_map_size_lfe * sizeof( float ) ) ) == NULL )
230 : {
231 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
232 : }
233 5665 : if ( ( hParamMC->icld_q = (float *) malloc( hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->ild_mapping_conf->ild_map_size_lfe * sizeof( float ) ) ) == NULL )
234 : {
235 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
236 : }
237 5665 : set_f( hParamMC->icld_q, PARAM_MC_DEFAULT_MIN_ILD, hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->ild_mapping_conf->ild_map_size_lfe );
238 5665 : set_f( hParamMC->icc_q, 0.0f, hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->icc_mapping_conf->icc_map_size_lfe );
239 :
240 5665 : param_mc_set_num_synth_bands( output_Fs, hParamMC );
241 :
242 : /* Band Grouping */
243 5665 : if ( hParamMC->hMetadataPMC->num_parameter_bands == 20 )
244 : {
245 593 : mvs2s( param_mc_band_grouping_20, hParamMC->band_grouping, 20 + 1 );
246 : }
247 5072 : else if ( hParamMC->hMetadataPMC->num_parameter_bands == 14 )
248 : {
249 2986 : mvs2s( param_mc_band_grouping_14, hParamMC->band_grouping, 14 + 1 );
250 : }
251 2086 : else if ( hParamMC->hMetadataPMC->num_parameter_bands == 10 )
252 : {
253 2086 : mvs2s( param_mc_band_grouping_10, hParamMC->band_grouping, 10 + 1 );
254 : }
255 : else
256 : {
257 0 : assert( 0 && "nbands must be 20, 14, or 10!" );
258 : }
259 :
260 : /* set max parameter band for abs cov */
261 5665 : k = 0;
262 53664 : while ( hParamMC->band_grouping[k] <= PARAM_MC_MAX_BAND_ABS_COV_DEC )
263 : {
264 47999 : hParamMC->max_param_band_abs_cov = ( k++ );
265 : }
266 :
267 : /*-----------------------------------------------------------------*
268 : * open sub-modules
269 : *-----------------------------------------------------------------*/
270 :
271 : /* prototype signal computation */
272 :
273 5665 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_CLDFB || hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
274 : {
275 1193 : if ( ( error = ivas_ls_setup_conversion_open( st_ivas ) ) != IVAS_ERR_OK )
276 : {
277 0 : return error;
278 : }
279 :
280 : /* convert the ls conv dmx matrix into column order matrix format (nchan_out_cldfb x nchan_out) */
281 1193 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
282 : {
283 368 : if ( ( hParamMC->ls_conv_dmx_matrix = (float *) malloc( nchan_out_transport * nchan_out_cov * sizeof( float ) ) ) == NULL )
284 : {
285 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
286 : }
287 :
288 3856 : for ( k = 0; k < nchan_out_transport; k++ )
289 : {
290 3488 : mvr2r( st_ivas->hLsSetUpConversion->dmxMtx[k], &hParamMC->ls_conv_dmx_matrix[k * nchan_out_cov], nchan_out_cov );
291 : }
292 :
293 : /* convert ParamMC parameter bands to SFB */
294 368 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
295 : {
296 256 : st_ivas->hLsSetUpConversion->sfbCnt = hParamMC->num_param_bands_synth;
297 3820 : for ( k = 0; k <= hParamMC->num_param_bands_synth; k++ )
298 : {
299 3564 : st_ivas->hLsSetUpConversion->sfbOffset[k] = PARAM_MC_BAND_TO_MDCT_BAND_RATIO * hParamMC->band_grouping[k];
300 : }
301 : }
302 : else
303 : {
304 : /* close the ls conversion handle immediately, it was only needed to get the DMX matrix in case of DMX in the covariance domain */
305 112 : ivas_ls_setup_conversion_close( &st_ivas->hLsSetUpConversion );
306 : }
307 : }
308 : }
309 :
310 5665 : if ( ( hParamMC->proto_matrix_int = (float *) malloc( nchan_out_transport * nchan_transport * sizeof( float ) ) ) == NULL )
311 : {
312 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
313 : }
314 5665 : mvr2r( ivas_param_mc_conf[config_index].dmx_fac, hParamMC->proto_matrix_int, nchan_transport * nchan_out_transport );
315 :
316 5665 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
317 : {
318 368 : matrix_product( hParamMC->ls_conv_dmx_matrix, nchan_out_cov, nchan_out_transport, 0, ivas_param_mc_conf[config_index].dmx_fac, nchan_out_transport, nchan_transport, 0, proto_matrix );
319 :
320 368 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
321 : {
322 256 : proto_mtx_norm = 1.f;
323 1378 : for ( k = 0; k < nchan_transport * nchan_out_cov; k++ )
324 : {
325 1122 : proto_mtx_norm = max( fabsf( proto_mtx_norm ), fabsf( proto_matrix[k] ) );
326 : }
327 256 : proto_mtx_norm = 1.f / proto_mtx_norm;
328 :
329 : /* transfer flattened proto_matrix to 2D in hLsSetupConversion->dmxMtx */
330 916 : for ( k = 0; k < nchan_transport; k++ )
331 : {
332 1782 : for ( int16_t i = 0; i < nchan_out_cov; i++ )
333 : {
334 1122 : st_ivas->hLsSetUpConversion->dmxMtx[k][i] = proto_matrix[k * nchan_out_cov + i] * proto_mtx_norm;
335 : }
336 : }
337 : }
338 : }
339 : else
340 : {
341 5297 : mvr2r( ivas_param_mc_conf[config_index].dmx_fac, proto_matrix, nchan_out_transport * nchan_transport );
342 : }
343 :
344 5665 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
345 : {
346 256 : hParamMC->num_outputs_diff = 0;
347 256 : hParamMC->diff_proto_info = NULL;
348 256 : hParamMC->h_output_synthesis_params.use_onset_filters = 0;
349 256 : hParamMC->max_band_decorr = 0;
350 256 : hParamMC->h_freq_domain_decorr_ap_params = NULL;
351 256 : hParamMC->h_freq_domain_decorr_ap_state = NULL;
352 : }
353 : else
354 : {
355 5409 : hParamMC->num_outputs_diff = nchan_out_cov;
356 5409 : if ( ( hParamMC->diff_proto_info = (PARAM_MC_DIFF_PROTO_INFO *) malloc( sizeof( PARAM_MC_DIFF_PROTO_INFO ) ) ) == NULL )
357 : {
358 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
359 : }
360 :
361 5409 : if ( ( error = param_mc_get_diff_proto_info( proto_matrix, nchan_transport, nchan_out_cov, hParamMC->diff_proto_info ) ) != IVAS_ERR_OK )
362 : {
363 0 : return error;
364 : }
365 :
366 : /* decorrelation */
367 5409 : hParamMC->h_freq_domain_decorr_ap_params = NULL;
368 5409 : hParamMC->h_freq_domain_decorr_ap_state = NULL;
369 :
370 5409 : ivas_dirac_dec_get_frequency_axis( frequency_axis, output_Fs, hParamMC->num_freq_bands );
371 :
372 5409 : if ( ( error = ivas_dirac_dec_decorr_open( &( hParamMC->h_freq_domain_decorr_ap_params ), &( hParamMC->h_freq_domain_decorr_ap_state ), hParamMC->num_freq_bands, hParamMC->num_outputs_diff, hParamMC->diff_proto_info->num_protos_diff,
373 : DIRAC_SYNTHESIS_COV_MC_LS, frequency_axis, nchan_transport, output_Fs ) ) != IVAS_ERR_OK )
374 : {
375 0 : return error;
376 : }
377 :
378 5409 : hParamMC->h_output_synthesis_params.use_onset_filters = 0;
379 5409 : hParamMC->max_band_decorr = hParamMC->h_freq_domain_decorr_ap_params->max_band_decorr;
380 : }
381 5665 : hParamMC->max_band_energy_compensation = hParamMC->band_grouping[hParamMC->hMetadataPMC->nbands_coded];
382 5665 : max_param_band_residual = 0;
383 :
384 25169 : for ( k = hParamMC->hMetadataPMC->num_parameter_bands; k >= 0; k-- )
385 : {
386 25169 : if ( hParamMC->band_grouping[k] <= hParamMC->max_band_decorr )
387 : {
388 5665 : max_param_band_residual = k;
389 5665 : assert( hParamMC->band_grouping[k] == hParamMC->max_band_decorr );
390 5665 : break;
391 : }
392 : }
393 :
394 : /* output synthesis */
395 5665 : if ( ( error = ivas_dirac_dec_output_synthesis_cov_open( &( hParamMC->h_output_synthesis_params ), &( hParamMC->h_output_synthesis_cov_state ), hParamMC->max_band_decorr, PARAM_MC_MAX_NSLOTS,
396 5665 : hParamMC->hMetadataPMC->num_parameter_bands, max_param_band_residual, nchan_transport, nchan_out_cov, proto_matrix ) ) != IVAS_ERR_OK )
397 : {
398 0 : return error;
399 : }
400 :
401 5665 : ivas_param_mc_dec_compute_interpolator( 0, 0, DEFAULT_JBM_CLDFB_TIMESLOTS, hParamMC->h_output_synthesis_params.interpolator );
402 :
403 : /* Head or external rotation */
404 5665 : if ( ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM ) && ( st_ivas->hDecoderConfig->Opt_Headrotation || st_ivas->hDecoderConfig->Opt_ExternalOrientation ) )
405 : {
406 449 : if ( ( hParamMC->hoa_encoder = (float *) malloc( st_ivas->hTransSetup.nchan_out_woLFE * MAX_INTERN_CHANNELS * sizeof( float ) ) ) == NULL )
407 : {
408 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
409 : }
410 449 : compute_hoa_encoder_mtx( st_ivas->hTransSetup.ls_azimuth, st_ivas->hTransSetup.ls_elevation, hParamMC->hoa_encoder, st_ivas->hTransSetup.nchan_out_woLFE, HEAD_ROTATION_HOA_ORDER );
411 : }
412 :
413 : /*-----------------------------------------------------------------*
414 : * memory allocation
415 : *-----------------------------------------------------------------*/
416 :
417 5665 : if ( hParamMC->max_band_decorr > 0 )
418 : {
419 5409 : if ( ( hParamMC->proto_frame_f = (float *) malloc( 2 * hParamMC->diff_proto_info->num_protos_diff * hParamMC->num_freq_bands * sizeof( float ) ) ) == NULL )
420 : {
421 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
422 : }
423 :
424 5409 : if ( ( hParamMC->proto_frame_dec_f = (float *) malloc( 2 * nchan_out_cov * hParamMC->num_freq_bands * sizeof( float ) ) ) == NULL )
425 : {
426 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
427 : }
428 : }
429 : else
430 : {
431 256 : hParamMC->proto_frame_f = NULL;
432 256 : hParamMC->proto_frame_dec_f = NULL;
433 : }
434 :
435 5665 : ivas_param_mc_dec_init( hParamMC, nchan_transport, nchan_out_cov );
436 :
437 5665 : if ( hParamMC->synthesis_conf != PARAM_MC_SYNTH_MONO_STEREO )
438 : {
439 : int16_t n_cldfb_slots;
440 : int16_t granularity;
441 :
442 5409 : n_cldfb_slots = DEFAULT_JBM_CLDFB_TIMESLOTS;
443 5409 : if ( st_ivas->hDecoderConfig->Opt_tsm )
444 : {
445 772 : n_cldfb_slots = MAX_JBM_CLDFB_TIMESLOTS;
446 : }
447 :
448 5409 : if ( ( hParamMC->Cldfb_RealBuffer_tc = (float *) malloc( n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands * sizeof( float ) ) ) == NULL )
449 : {
450 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC JBM\n" ) );
451 : }
452 5409 : set_zero( hParamMC->Cldfb_RealBuffer_tc, n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands );
453 :
454 5409 : if ( ( hParamMC->Cldfb_ImagBuffer_tc = (float *) malloc( n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands * sizeof( float ) ) ) == NULL )
455 : {
456 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC JBM\n" ) );
457 : }
458 5409 : set_zero( hParamMC->Cldfb_ImagBuffer_tc, n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands );
459 :
460 5409 : if ( st_ivas->hTcBuffer == NULL )
461 : {
462 1180 : granularity = ivas_jbm_dec_get_render_granularity( st_ivas->renderer_type, RENDERER_DISABLE, output_Fs );
463 :
464 1180 : if ( ( error = ivas_jbm_dec_tc_buffer_open( st_ivas, TC_BUFFER_MODE_RENDERER, nchan_transport, nchan_transport, 0, granularity ) ) != IVAS_ERR_OK )
465 : {
466 0 : return error;
467 : }
468 : }
469 : }
470 : else
471 : {
472 256 : hParamMC->Cldfb_RealBuffer_tc = NULL;
473 256 : hParamMC->Cldfb_ImagBuffer_tc = NULL;
474 : }
475 :
476 5665 : hParamMC->subframes_rendered = 0;
477 5665 : hParamMC->slots_rendered = 0;
478 :
479 5665 : st_ivas->hParamMC = hParamMC;
480 :
481 5665 : return error;
482 : }
483 :
484 :
485 : /*-------------------------------------------------------------------------
486 : * ivas_param_mc_get_param_band_mapping()
487 : *
488 : *
489 : *-------------------------------------------------------------------------*/
490 :
491 1024 : static void ivas_param_mc_get_param_band_mapping(
492 : const int16_t n_target_bands,
493 : const int16_t *target_band_grouping,
494 : const int16_t n_source_bands,
495 : const int16_t *source_band_grouping,
496 : PARAM_MC_PARAMETER_BAND_MAPPING *parameter_band_mapping )
497 : {
498 : int16_t target_band_idx;
499 1024 : int16_t source_band_idx = 0;
500 : int16_t source_band_cnt_total;
501 :
502 14400 : for ( target_band_idx = 0; target_band_idx < n_target_bands; target_band_idx++ )
503 : {
504 13376 : int16_t upper = target_band_grouping[target_band_idx + 1];
505 13376 : int16_t lower = target_band_grouping[target_band_idx];
506 13376 : int16_t source_band_in_target_band_cnt = 0;
507 13376 : float norm_fac = 1.0f;
508 13376 : source_band_cnt_total = 0;
509 81750 : for ( source_band_idx = 0; source_band_idx < n_source_bands; source_band_idx++ )
510 : {
511 : /* find lowest corresponding source band*/
512 81750 : if ( source_band_grouping[source_band_idx] <= lower && source_band_grouping[source_band_idx + 1] >= lower )
513 : {
514 : do
515 : {
516 33688 : int16_t source_bands_in_target_band = min( source_band_grouping[source_band_idx + 1], upper ) - max( source_band_grouping[source_band_idx], lower );
517 33688 : if ( source_bands_in_target_band )
518 : {
519 17540 : source_band_cnt_total += source_bands_in_target_band;
520 17540 : parameter_band_mapping->source_band_idx[target_band_idx][source_band_in_target_band_cnt] = source_band_idx;
521 17540 : parameter_band_mapping->source_band_factor[target_band_idx][source_band_in_target_band_cnt++] = (float) source_bands_in_target_band;
522 : }
523 33688 : source_band_idx++;
524 33688 : } while ( source_band_grouping[source_band_idx] <= upper && source_band_idx < n_source_bands );
525 13376 : break;
526 : }
527 : }
528 13376 : norm_fac = 1.0f / ( (float) source_band_cnt_total );
529 30916 : for ( source_band_idx = 0; source_band_idx < source_band_in_target_band_cnt; source_band_idx++ )
530 : {
531 :
532 17540 : parameter_band_mapping->source_band_factor[target_band_idx][source_band_idx] *= norm_fac;
533 : }
534 13376 : parameter_band_mapping->n_source_bands[target_band_idx] = source_band_in_target_band_cnt;
535 : }
536 :
537 1024 : return;
538 : }
539 :
540 :
541 : /*-------------------------------------------------------------------------
542 : * ivas_param_mc_dec_reconfig()
543 : *
544 : * Reconfiguration of ParamMC decoder
545 : *-------------------------------------------------------------------------*/
546 :
547 1024 : ivas_error ivas_param_mc_dec_reconfig(
548 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
549 : )
550 : {
551 : int16_t k, nchan_transport;
552 : PARAM_MC_DEC_HANDLE hParamMC;
553 : int16_t nchan_out_transport;
554 : int16_t nchan_out_cov;
555 : float proto_matrix[MAX_LS_CHANNELS * PARAM_MC_MAX_TRANSPORT_CHANS];
556 : float proto_mtx_norm;
557 : int16_t max_param_band_residual;
558 : uint16_t config_index;
559 : MC_LS_SETUP mc_ls_setup;
560 : float frequency_axis[CLDFB_NO_CHANNELS_MAX];
561 : int32_t output_Fs, ivas_total_brate;
562 : ivas_error error;
563 : int16_t nchan_transport_old;
564 : int16_t num_param_bands_old;
565 : PARAM_MC_PARAMETER_BAND_MAPPING parameter_band_mapping;
566 : int16_t band_grouping_old[20 + 1];
567 :
568 1024 : error = IVAS_ERR_OK;
569 1024 : hParamMC = st_ivas->hParamMC;
570 :
571 : /* save important config information from the previous state */
572 1024 : nchan_transport_old = st_ivas->nchan_transport;
573 1024 : num_param_bands_old = hParamMC->hMetadataPMC->num_parameter_bands;
574 :
575 : /*-----------------------------------------------------------------*
576 : * prepare library opening
577 : *-----------------------------------------------------------------*/
578 :
579 1024 : output_Fs = st_ivas->hDecoderConfig->output_Fs;
580 1024 : ivas_total_brate = st_ivas->hDecoderConfig->ivas_total_brate;
581 1024 : mc_ls_setup = ivas_mc_map_output_config_to_mc_ls_setup( st_ivas->transport_config );
582 1024 : nchan_out_transport = st_ivas->hTransSetup.nchan_out_woLFE + st_ivas->hTransSetup.num_lfe;
583 :
584 1024 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
585 : {
586 0 : nchan_out_cov = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
587 : }
588 : else
589 : {
590 1024 : nchan_out_cov = nchan_out_transport;
591 : }
592 :
593 1024 : st_ivas->nchan_transport = ivas_param_mc_getNumTransportChannels( ivas_total_brate, mc_ls_setup );
594 1024 : config_index = ivas_param_mc_get_configuration_index( mc_ls_setup, ivas_total_brate );
595 1024 : nchan_transport = st_ivas->nchan_transport;
596 :
597 1024 : switch ( nchan_transport )
598 : {
599 107 : case 4:
600 : case 3:
601 107 : st_ivas->nCPE = 2;
602 107 : st_ivas->nSCE = 0;
603 107 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
604 107 : break;
605 917 : case 2:
606 917 : st_ivas->nCPE = 1;
607 917 : st_ivas->nSCE = 0;
608 917 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
609 :
610 917 : break;
611 : #ifdef DEBUGGING
612 : default:
613 : assert( 0 && "Number of TC not supported for Parametric MC!" );
614 : #endif
615 : }
616 :
617 : /*-----------------------------------------------------------------*
618 : * set input parameters
619 : *-----------------------------------------------------------------*/
620 :
621 1024 : hParamMC->num_freq_bands = (int16_t) ( output_Fs * INV_CLDFB_BANDWIDTH + 0.5f );
622 1024 : hParamMC->max_band_energy_compensation = hParamMC->num_freq_bands;
623 :
624 1024 : mvs2s( hParamMC->band_grouping, band_grouping_old, hParamMC->hMetadataPMC->num_parameter_bands + 1 );
625 :
626 1024 : ivas_param_mc_metadata_open( mc_ls_setup, ivas_total_brate, hParamMC->hMetadataPMC );
627 :
628 : /* Band Grouping */
629 1024 : if ( hParamMC->hMetadataPMC->num_parameter_bands == 20 )
630 : {
631 102 : mvs2s( param_mc_band_grouping_20, hParamMC->band_grouping, 20 + 1 );
632 : }
633 922 : else if ( hParamMC->hMetadataPMC->num_parameter_bands == 14 )
634 : {
635 529 : mvs2s( param_mc_band_grouping_14, hParamMC->band_grouping, 14 + 1 );
636 : }
637 393 : else if ( hParamMC->hMetadataPMC->num_parameter_bands == 10 )
638 : {
639 393 : mvs2s( param_mc_band_grouping_10, hParamMC->band_grouping, 10 + 1 );
640 : }
641 : else
642 : {
643 0 : assert( 0 && "nbands must be 20, 14, or 10!" );
644 : }
645 :
646 1024 : ivas_param_mc_get_param_band_mapping( hParamMC->hMetadataPMC->num_parameter_bands, hParamMC->band_grouping, num_param_bands_old, band_grouping_old, ¶meter_band_mapping );
647 :
648 1024 : if ( nchan_transport_old != nchan_transport || num_param_bands_old != hParamMC->hMetadataPMC->num_parameter_bands )
649 : {
650 967 : float *ild_q_old = hParamMC->icld_q;
651 967 : float *icc_q_old = hParamMC->icc_q;
652 :
653 :
654 : /* init arrays for the quantized parameters */
655 967 : if ( ( hParamMC->icc_q = (float *) malloc( hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->icc_mapping_conf->icc_map_size_lfe * sizeof( float ) ) ) == NULL )
656 : {
657 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
658 : }
659 967 : if ( ( hParamMC->icld_q = (float *) malloc( hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->ild_mapping_conf->ild_map_size_lfe * sizeof( float ) ) ) == NULL )
660 : {
661 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
662 : }
663 967 : set_f( hParamMC->icld_q, PARAM_MC_DEFAULT_MIN_ILD, hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->ild_mapping_conf->ild_map_size_lfe );
664 967 : set_f( hParamMC->icc_q, 0.0f, hParamMC->hMetadataPMC->num_parameter_bands * hParamMC->hMetadataPMC->icc_mapping_conf->icc_map_size_lfe );
665 :
666 : /* map old to new parameter banding, only for same number of TCs, needs some more thought for a changing number of TCs */
667 967 : if ( num_param_bands_old != hParamMC->hMetadataPMC->num_parameter_bands && nchan_transport_old == nchan_transport )
668 : {
669 : int16_t new_param_band_idx, param_idx, source_param_idx;
670 : int16_t num_param_lfe;
671 768 : float *p_icc_new = hParamMC->icc_q;
672 768 : float *p_ild_new = hParamMC->icld_q;
673 :
674 : /* ICC */
675 768 : num_param_lfe = hParamMC->hMetadataPMC->icc_mapping_conf->icc_map_size_lfe;
676 10086 : for ( new_param_band_idx = 0; new_param_band_idx < hParamMC->hMetadataPMC->num_parameter_bands; new_param_band_idx++ )
677 : {
678 59596 : for ( param_idx = 0; param_idx < num_param_lfe; param_idx++ )
679 : {
680 50278 : *p_icc_new = 0.0f;
681 116954 : for ( source_param_idx = 0; source_param_idx < parameter_band_mapping.n_source_bands[new_param_band_idx]; source_param_idx++ )
682 : {
683 66676 : *p_icc_new += icc_q_old[parameter_band_mapping.source_band_idx[new_param_band_idx][source_param_idx] * num_param_lfe + param_idx] * parameter_band_mapping.source_band_factor[new_param_band_idx][source_param_idx];
684 : }
685 50278 : p_icc_new++;
686 : }
687 : }
688 :
689 : /* ILD */
690 768 : num_param_lfe = hParamMC->hMetadataPMC->ild_mapping_conf->ild_map_size_lfe;
691 10086 : for ( new_param_band_idx = 0; new_param_band_idx < hParamMC->hMetadataPMC->num_parameter_bands; new_param_band_idx++ )
692 : {
693 68914 : for ( param_idx = 0; param_idx < num_param_lfe; param_idx++ )
694 : {
695 59596 : *p_ild_new = 0.0f;
696 138644 : for ( source_param_idx = 0; source_param_idx < parameter_band_mapping.n_source_bands[new_param_band_idx]; source_param_idx++ )
697 : {
698 79048 : *p_ild_new += powf( 10.0f, ild_q_old[parameter_band_mapping.source_band_idx[new_param_band_idx][source_param_idx] * num_param_lfe + param_idx] / 10.0f ) * parameter_band_mapping.source_band_factor[new_param_band_idx][source_param_idx];
699 : }
700 59596 : *p_ild_new = 10.0f * log10f( *p_ild_new );
701 59596 : p_ild_new++;
702 : }
703 : }
704 : }
705 967 : free( ild_q_old );
706 967 : free( icc_q_old );
707 : }
708 :
709 1024 : param_mc_set_num_synth_bands( output_Fs, hParamMC );
710 :
711 : /* set max parameter band for abs cov */
712 1024 : k = 0;
713 9658 : while ( hParamMC->band_grouping[k] <= PARAM_MC_MAX_BAND_ABS_COV_DEC )
714 : {
715 8634 : hParamMC->max_param_band_abs_cov = ( k++ );
716 : }
717 :
718 : /*-----------------------------------------------------------------*
719 : * open sub-modules
720 : *-----------------------------------------------------------------*/
721 :
722 : /* prototype signal computation */
723 :
724 1024 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
725 : {
726 0 : if ( nchan_transport_old != nchan_transport )
727 : {
728 0 : if ( st_ivas->hLsSetUpConversion != NULL )
729 : {
730 0 : ivas_ls_setup_conversion_close( &st_ivas->hLsSetUpConversion );
731 : }
732 :
733 0 : if ( ( error = ivas_ls_setup_conversion_open( st_ivas ) ) != IVAS_ERR_OK )
734 : {
735 0 : return error;
736 : }
737 :
738 : /* convert the ls conv dmx matrix into column order matrix format (nchan_out_cldfb x nchan_out) */
739 0 : free( hParamMC->ls_conv_dmx_matrix );
740 0 : if ( ( hParamMC->ls_conv_dmx_matrix = (float *) malloc( nchan_out_transport * nchan_out_cov * sizeof( float ) ) ) == NULL )
741 : {
742 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
743 : }
744 0 : for ( k = 0; k < nchan_out_transport; k++ )
745 : {
746 0 : mvr2r( st_ivas->hLsSetUpConversion->dmxMtx[k], &hParamMC->ls_conv_dmx_matrix[k * nchan_out_cov], nchan_out_cov );
747 : }
748 : }
749 : /* convert ParamMC parameter bands to SFB */
750 :
751 0 : st_ivas->hLsSetUpConversion->sfbCnt = hParamMC->num_param_bands_synth;
752 0 : for ( k = 0; k <= hParamMC->num_param_bands_synth; k++ )
753 : {
754 0 : st_ivas->hLsSetUpConversion->sfbOffset[k] = PARAM_MC_BAND_TO_MDCT_BAND_RATIO * hParamMC->band_grouping[k];
755 : }
756 0 : for ( ; k < MAX_SFB + 2; k++ )
757 : {
758 0 : st_ivas->hLsSetUpConversion->sfbOffset[k] = 0;
759 : }
760 : }
761 :
762 1024 : if ( nchan_transport_old != nchan_transport )
763 : {
764 199 : free( hParamMC->proto_matrix_int );
765 199 : if ( ( hParamMC->proto_matrix_int = (float *) malloc( nchan_out_transport * nchan_transport * sizeof( float ) ) ) == NULL )
766 : {
767 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
768 : }
769 199 : mvr2r( ivas_param_mc_conf[config_index].dmx_fac, hParamMC->proto_matrix_int, nchan_transport * nchan_out_transport );
770 : }
771 :
772 1024 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
773 : {
774 0 : matrix_product( hParamMC->ls_conv_dmx_matrix, nchan_out_cov, nchan_out_transport, 0,
775 : ivas_param_mc_conf[config_index].dmx_fac, nchan_out_transport, nchan_transport, 0,
776 : proto_matrix );
777 :
778 0 : if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
779 : {
780 0 : proto_mtx_norm = 1.f;
781 0 : for ( k = 0; k < nchan_transport * nchan_out_cov; k++ )
782 : {
783 0 : proto_mtx_norm = max( fabsf( proto_mtx_norm ), fabsf( proto_matrix[k] ) );
784 : }
785 0 : proto_mtx_norm = 1.f / proto_mtx_norm;
786 :
787 : /* transfer flattened proto_matrix to 2D in hLsSetupConversion->dmxMtx */
788 0 : for ( k = 0; k < nchan_transport; k++ )
789 : {
790 0 : for ( int16_t i = 0; i < nchan_out_cov; i++ )
791 : {
792 0 : st_ivas->hLsSetUpConversion->dmxMtx[k][i] = proto_matrix[k * nchan_out_cov + i] * proto_mtx_norm;
793 : }
794 : }
795 : }
796 : }
797 : else
798 : {
799 1024 : mvr2r( ivas_param_mc_conf[config_index].dmx_fac, proto_matrix, nchan_out_transport * nchan_transport );
800 : }
801 :
802 1024 : if ( nchan_transport_old != nchan_transport && hParamMC->synthesis_conf != PARAM_MC_SYNTH_MONO_STEREO )
803 : {
804 : int16_t i;
805 : int16_t len;
806 :
807 : /* close decorrelator */
808 199 : ivas_dirac_dec_decorr_close( &hParamMC->h_freq_domain_decorr_ap_params, &hParamMC->h_freq_domain_decorr_ap_state );
809 :
810 : /* deallocate diffuse prototype info */
811 199 : if ( hParamMC->diff_proto_info )
812 : {
813 796 : for ( i = 0; i < hParamMC->diff_proto_info->num_protos_diff; i++ )
814 : {
815 597 : free( hParamMC->diff_proto_info->source_chan_idx[i] );
816 597 : hParamMC->diff_proto_info->source_chan_idx[i] = NULL;
817 :
818 597 : free( hParamMC->diff_proto_info->proto_fac[i] );
819 597 : hParamMC->diff_proto_info->proto_fac[i] = NULL;
820 : }
821 :
822 199 : free( hParamMC->diff_proto_info->source_chan_idx );
823 199 : hParamMC->diff_proto_info->source_chan_idx = NULL;
824 :
825 199 : free( hParamMC->diff_proto_info->proto_fac );
826 199 : hParamMC->diff_proto_info->proto_fac = NULL;
827 :
828 199 : free( hParamMC->diff_proto_info->proto_index_diff );
829 199 : hParamMC->diff_proto_info->proto_index_diff = NULL;
830 :
831 199 : free( hParamMC->diff_proto_info->num_source_chan_diff );
832 199 : hParamMC->diff_proto_info->num_source_chan_diff = NULL;
833 :
834 199 : free( hParamMC->diff_proto_info );
835 199 : hParamMC->diff_proto_info = NULL;
836 : }
837 :
838 199 : hParamMC->num_outputs_diff = nchan_out_cov;
839 199 : if ( ( hParamMC->diff_proto_info = (PARAM_MC_DIFF_PROTO_INFO *) malloc( sizeof( PARAM_MC_DIFF_PROTO_INFO ) ) ) == NULL )
840 : {
841 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
842 : }
843 :
844 199 : if ( ( param_mc_get_diff_proto_info( proto_matrix, nchan_transport, nchan_out_cov, hParamMC->diff_proto_info ) ) != IVAS_ERR_OK )
845 : {
846 0 : return error;
847 : }
848 :
849 : /* decorrelation */
850 199 : hParamMC->h_freq_domain_decorr_ap_params = NULL;
851 199 : hParamMC->h_freq_domain_decorr_ap_state = NULL;
852 :
853 199 : ivas_dirac_dec_get_frequency_axis( frequency_axis, output_Fs, hParamMC->num_freq_bands );
854 :
855 199 : if ( ( error = ivas_dirac_dec_decorr_open( &( hParamMC->h_freq_domain_decorr_ap_params ), &( hParamMC->h_freq_domain_decorr_ap_state ), hParamMC->num_freq_bands, hParamMC->num_outputs_diff,
856 199 : hParamMC->diff_proto_info->num_protos_diff, DIRAC_SYNTHESIS_COV_MC_LS, frequency_axis, nchan_transport, output_Fs ) ) != IVAS_ERR_OK )
857 : {
858 0 : return error;
859 : }
860 :
861 199 : hParamMC->h_output_synthesis_params.use_onset_filters = 0;
862 199 : hParamMC->max_band_decorr = hParamMC->h_freq_domain_decorr_ap_params->max_band_decorr;
863 : /* init decorrelation */
864 199 : if ( hParamMC->max_band_decorr > 0 )
865 : {
866 :
867 199 : len = hParamMC->diff_proto_info->num_protos_diff * hParamMC->h_freq_domain_decorr_ap_params->h_onset_detection_power_params.max_band_decorr;
868 :
869 : /* init onsetDetectionPower */
870 199 : set_zero( hParamMC->h_freq_domain_decorr_ap_state->h_onset_detection_power_state.onset_detector_1, len );
871 199 : set_zero( hParamMC->h_freq_domain_decorr_ap_state->h_onset_detection_power_state.onset_detector_2, len );
872 : }
873 : }
874 1024 : hParamMC->max_band_energy_compensation = hParamMC->band_grouping[hParamMC->hMetadataPMC->nbands_coded];
875 1024 : max_param_band_residual = 0;
876 :
877 4009 : for ( k = hParamMC->hMetadataPMC->num_parameter_bands; k >= 0; k-- )
878 : {
879 4009 : if ( hParamMC->band_grouping[k] <= hParamMC->max_band_decorr )
880 : {
881 1024 : max_param_band_residual = k;
882 1024 : assert( hParamMC->band_grouping[k] == hParamMC->max_band_decorr );
883 1024 : break;
884 : }
885 : }
886 :
887 1024 : if ( nchan_transport_old != nchan_transport || num_param_bands_old != hParamMC->hMetadataPMC->num_parameter_bands )
888 : {
889 967 : DIRAC_OUTPUT_SYNTHESIS_COV_STATE cov_state_old = hParamMC->h_output_synthesis_cov_state;
890 967 : DIRAC_OUTPUT_SYNTHESIS_PARAMS params_old = hParamMC->h_output_synthesis_params;
891 : float tmp_buf[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
892 :
893 967 : set_zero( tmp_buf, MAX_LS_CHANNELS * MAX_LS_CHANNELS );
894 :
895 : /* output synthesis */
896 967 : if ( ( error = ivas_dirac_dec_output_synthesis_cov_open( &( hParamMC->h_output_synthesis_params ), &( hParamMC->h_output_synthesis_cov_state ), hParamMC->max_band_decorr, PARAM_MC_MAX_NSLOTS,
897 967 : hParamMC->hMetadataPMC->num_parameter_bands, max_param_band_residual, nchan_transport, nchan_out_cov, proto_matrix ) ) != IVAS_ERR_OK )
898 : {
899 0 : return error;
900 : }
901 :
902 967 : ivas_param_mc_dec_compute_interpolator( 0, 0, DEFAULT_JBM_CLDFB_TIMESLOTS, hParamMC->h_output_synthesis_params.interpolator );
903 :
904 967 : ivas_dirac_dec_output_synthesis_cov_init( &( hParamMC->h_output_synthesis_cov_state ), nchan_transport, nchan_out_cov, hParamMC->hMetadataPMC->num_parameter_bands, max_param_band_residual );
905 :
906 : /* map old to new parameter banding, only for same number of TCs, needs some more thought for changing number of TCs */
907 967 : if ( num_param_bands_old != hParamMC->hMetadataPMC->num_parameter_bands && nchan_transport_old == nchan_transport )
908 : {
909 : int16_t new_param_band_idx, source_param_idx;
910 :
911 :
912 10086 : for ( new_param_band_idx = 0; new_param_band_idx < hParamMC->hMetadataPMC->num_parameter_bands; new_param_band_idx++ )
913 : {
914 21690 : for ( source_param_idx = 0; source_param_idx < parameter_band_mapping.n_source_bands[new_param_band_idx]; source_param_idx++ )
915 : {
916 : /* Cx */
917 12372 : v_multc( cov_state_old.cx_old[parameter_band_mapping.source_band_idx[new_param_band_idx][source_param_idx]], parameter_band_mapping.source_band_factor[new_param_band_idx][source_param_idx], tmp_buf, nchan_transport_old * nchan_transport_old );
918 12372 : v_add( tmp_buf, hParamMC->h_output_synthesis_cov_state.cx_old[new_param_band_idx], hParamMC->h_output_synthesis_cov_state.cx_old[new_param_band_idx], nchan_transport_old * nchan_transport_old );
919 : /* Cy */
920 12372 : v_multc( cov_state_old.cy_old[parameter_band_mapping.source_band_idx[new_param_band_idx][source_param_idx]], parameter_band_mapping.source_band_factor[new_param_band_idx][source_param_idx], tmp_buf, nchan_out_cov * nchan_out_cov );
921 12372 : v_add( tmp_buf, hParamMC->h_output_synthesis_cov_state.cy_old[new_param_band_idx], hParamMC->h_output_synthesis_cov_state.cy_old[new_param_band_idx], nchan_out_cov * nchan_out_cov );
922 : /* mixing matrix*/
923 12372 : v_multc( cov_state_old.mixing_matrix_old[parameter_band_mapping.source_band_idx[new_param_band_idx][source_param_idx]], parameter_band_mapping.source_band_factor[new_param_band_idx][source_param_idx], tmp_buf, nchan_transport_old * nchan_out_cov );
924 12372 : v_add( tmp_buf, hParamMC->h_output_synthesis_cov_state.mixing_matrix_old[new_param_band_idx], hParamMC->h_output_synthesis_cov_state.mixing_matrix_old[new_param_band_idx], nchan_transport_old * nchan_out_cov );
925 : }
926 : }
927 8130 : for ( new_param_band_idx = 0; new_param_band_idx < max_param_band_residual; new_param_band_idx++ )
928 : {
929 17382 : for ( source_param_idx = 0; source_param_idx < parameter_band_mapping.n_source_bands[new_param_band_idx]; source_param_idx++ )
930 : {
931 : /* residual mixing matrix*/
932 10020 : v_multc( cov_state_old.mixing_matrix_res_old[parameter_band_mapping.source_band_idx[new_param_band_idx][source_param_idx]], parameter_band_mapping.source_band_factor[new_param_band_idx][source_param_idx], tmp_buf, nchan_out_cov * nchan_out_cov );
933 10020 : v_add( tmp_buf, hParamMC->h_output_synthesis_cov_state.mixing_matrix_res_old[new_param_band_idx], hParamMC->h_output_synthesis_cov_state.mixing_matrix_res_old[new_param_band_idx], nchan_out_cov * nchan_out_cov );
934 : }
935 : }
936 : }
937 :
938 967 : ivas_dirac_dec_output_synthesis_cov_close( ¶ms_old, &cov_state_old );
939 : }
940 :
941 : /*-----------------------------------------------------------------*
942 : * memory allocation
943 : *-----------------------------------------------------------------*/
944 :
945 1024 : if ( hParamMC->max_band_decorr > 0 && nchan_transport_old != nchan_transport )
946 : {
947 199 : free( hParamMC->proto_frame_f );
948 199 : if ( ( hParamMC->proto_frame_f = (float *) malloc( 2 * hParamMC->diff_proto_info->num_protos_diff * hParamMC->num_freq_bands * sizeof( float ) ) ) == NULL )
949 : {
950 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
951 : }
952 199 : set_zero( hParamMC->proto_frame_f, 2 * hParamMC->diff_proto_info->num_protos_diff * hParamMC->num_freq_bands );
953 : }
954 :
955 :
956 1024 : if ( nchan_transport_old != nchan_transport )
957 : {
958 199 : if ( hParamMC->synthesis_conf != PARAM_MC_SYNTH_MONO_STEREO )
959 : {
960 : int16_t n_cldfb_slots;
961 :
962 199 : if ( hParamMC->Cldfb_RealBuffer_tc != NULL )
963 : {
964 199 : free( hParamMC->Cldfb_RealBuffer_tc );
965 199 : hParamMC->Cldfb_RealBuffer_tc = NULL;
966 : }
967 199 : if ( hParamMC->Cldfb_ImagBuffer_tc != NULL )
968 : {
969 199 : free( hParamMC->Cldfb_ImagBuffer_tc );
970 199 : hParamMC->Cldfb_ImagBuffer_tc = NULL;
971 : }
972 :
973 199 : n_cldfb_slots = DEFAULT_JBM_CLDFB_TIMESLOTS;
974 199 : if ( st_ivas->hDecoderConfig->Opt_tsm )
975 : {
976 41 : n_cldfb_slots = MAX_JBM_CLDFB_TIMESLOTS;
977 : }
978 199 : if ( ( hParamMC->Cldfb_RealBuffer_tc = (float *) malloc( n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands * sizeof( float ) ) ) == NULL )
979 : {
980 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC JBM\n" ) );
981 : }
982 199 : set_zero( hParamMC->Cldfb_RealBuffer_tc, n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands );
983 :
984 199 : if ( ( hParamMC->Cldfb_ImagBuffer_tc = (float *) malloc( n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands * sizeof( float ) ) ) == NULL )
985 : {
986 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC JBM\n" ) );
987 : }
988 199 : set_zero( hParamMC->Cldfb_ImagBuffer_tc, n_cldfb_slots * nchan_transport * hParamMC->num_freq_bands );
989 : }
990 : else
991 : {
992 0 : if ( hParamMC->Cldfb_RealBuffer_tc != NULL )
993 : {
994 0 : free( hParamMC->Cldfb_RealBuffer_tc );
995 0 : hParamMC->Cldfb_RealBuffer_tc = NULL;
996 : }
997 0 : if ( hParamMC->Cldfb_ImagBuffer_tc != NULL )
998 : {
999 0 : free( hParamMC->Cldfb_ImagBuffer_tc );
1000 0 : hParamMC->Cldfb_ImagBuffer_tc = NULL;
1001 : }
1002 : }
1003 : }
1004 1024 : return error;
1005 : }
1006 :
1007 :
1008 : /*-------------------------------------------------------------------------
1009 : * param_mc_get_num_cldfb_syntheses()
1010 : *
1011 : * calculate the necessary number of CLDFB synthesis instances
1012 : *------------------------------------------------------------------------*/
1013 :
1014 : /*! r: number of cldfb synthesis instances */
1015 5888 : int16_t param_mc_get_num_cldfb_syntheses(
1016 : Decoder_Struct *st_ivas /* i : Parametric MC handle */
1017 : )
1018 : {
1019 : int16_t num_cldfb_syntheses;
1020 :
1021 5888 : num_cldfb_syntheses = 0;
1022 :
1023 : /* sanity check*/
1024 5888 : if ( st_ivas->hParamMC == NULL )
1025 : {
1026 0 : assert( 0 && "ParamMC handle does not exist!\n" );
1027 : }
1028 :
1029 5888 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
1030 : {
1031 0 : num_cldfb_syntheses = 2;
1032 : }
1033 5888 : else if ( st_ivas->renderer_type == RENDERER_SBA_LINEAR_ENC )
1034 : {
1035 2100 : num_cldfb_syntheses = st_ivas->hTransSetup.nchan_out_woLFE + st_ivas->hTransSetup.num_lfe;
1036 : }
1037 3788 : else if ( st_ivas->renderer_type == RENDERER_MC_PARAMMC )
1038 : {
1039 3788 : num_cldfb_syntheses = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
1040 : }
1041 : #ifdef DEBUGGING
1042 : else
1043 : {
1044 : assert( 0 && "Renderer settings not valid for ParamMC!\n" );
1045 : }
1046 : #endif
1047 :
1048 5888 : return num_cldfb_syntheses;
1049 : }
1050 :
1051 :
1052 : /*-------------------------------------------------------------------------
1053 : * ivas_param_mc_dec_close()
1054 : *
1055 : * Close Parametric MC memories
1056 : *------------------------------------------------------------------------*/
1057 :
1058 88951 : void ivas_param_mc_dec_close(
1059 : PARAM_MC_DEC_HANDLE *hParamMC_out /* i/o: Parametric MC decoder handle */
1060 : )
1061 : {
1062 : uint16_t i;
1063 : PARAM_MC_DEC_HANDLE hParamMC;
1064 :
1065 88951 : if ( hParamMC_out == NULL || *hParamMC_out == NULL )
1066 : {
1067 83286 : return;
1068 : }
1069 :
1070 5665 : hParamMC = *hParamMC_out;
1071 :
1072 : /* close sub-modules */
1073 5665 : ivas_dirac_dec_output_synthesis_cov_close( &hParamMC->h_output_synthesis_params, &hParamMC->h_output_synthesis_cov_state );
1074 :
1075 5665 : if ( hParamMC->h_freq_domain_decorr_ap_params != NULL || hParamMC->h_freq_domain_decorr_ap_state != NULL )
1076 : {
1077 5409 : ivas_dirac_dec_decorr_close( &hParamMC->h_freq_domain_decorr_ap_params, &hParamMC->h_freq_domain_decorr_ap_state );
1078 : }
1079 :
1080 : /* parameter decoding */
1081 5665 : if ( hParamMC->hMetadataPMC != NULL )
1082 : {
1083 5665 : free( hParamMC->hMetadataPMC );
1084 5665 : hParamMC->hMetadataPMC = NULL;
1085 : }
1086 :
1087 5665 : if ( hParamMC->icc_q != NULL )
1088 : {
1089 5665 : free( hParamMC->icc_q );
1090 5665 : hParamMC->icc_q = NULL;
1091 : }
1092 :
1093 5665 : if ( hParamMC->icld_q != NULL )
1094 : {
1095 5665 : free( hParamMC->icld_q );
1096 5665 : hParamMC->icld_q = NULL;
1097 : }
1098 :
1099 : /* diffuse prototype info */
1100 5665 : if ( hParamMC->diff_proto_info )
1101 : {
1102 21860 : for ( i = 0; i < hParamMC->diff_proto_info->num_protos_diff; i++ )
1103 : {
1104 16451 : free( hParamMC->diff_proto_info->source_chan_idx[i] );
1105 16451 : hParamMC->diff_proto_info->source_chan_idx[i] = NULL;
1106 :
1107 16451 : free( hParamMC->diff_proto_info->proto_fac[i] );
1108 16451 : hParamMC->diff_proto_info->proto_fac[i] = NULL;
1109 : }
1110 :
1111 5409 : free( hParamMC->diff_proto_info->source_chan_idx );
1112 5409 : hParamMC->diff_proto_info->source_chan_idx = NULL;
1113 :
1114 5409 : free( hParamMC->diff_proto_info->proto_fac );
1115 5409 : hParamMC->diff_proto_info->proto_fac = NULL;
1116 :
1117 5409 : free( hParamMC->diff_proto_info->proto_index_diff );
1118 5409 : hParamMC->diff_proto_info->proto_index_diff = NULL;
1119 :
1120 5409 : free( hParamMC->diff_proto_info->num_source_chan_diff );
1121 5409 : hParamMC->diff_proto_info->num_source_chan_diff = NULL;
1122 :
1123 5409 : free( hParamMC->diff_proto_info );
1124 5409 : hParamMC->diff_proto_info = NULL;
1125 : }
1126 :
1127 : /* States */
1128 : /* free prototype signal buffers */
1129 5665 : if ( hParamMC->proto_frame_f != NULL )
1130 : {
1131 5409 : free( hParamMC->proto_frame_f );
1132 5409 : hParamMC->proto_frame_f = NULL;
1133 : }
1134 :
1135 5665 : if ( hParamMC->proto_frame_dec_f != NULL )
1136 : {
1137 5409 : free( hParamMC->proto_frame_dec_f );
1138 5409 : hParamMC->proto_frame_dec_f = NULL;
1139 : }
1140 :
1141 5665 : if ( hParamMC->ls_conv_dmx_matrix != NULL )
1142 : {
1143 368 : free( hParamMC->ls_conv_dmx_matrix );
1144 368 : hParamMC->ls_conv_dmx_matrix = NULL;
1145 : }
1146 :
1147 5665 : if ( hParamMC->proto_matrix_int != NULL )
1148 : {
1149 5665 : free( hParamMC->proto_matrix_int );
1150 5665 : hParamMC->proto_matrix_int = NULL;
1151 : }
1152 :
1153 5665 : if ( hParamMC->hoa_encoder != NULL )
1154 : {
1155 449 : free( hParamMC->hoa_encoder );
1156 449 : hParamMC->hoa_encoder = NULL;
1157 : }
1158 :
1159 5665 : if ( hParamMC->Cldfb_RealBuffer_tc != NULL )
1160 : {
1161 5409 : free( hParamMC->Cldfb_RealBuffer_tc );
1162 5409 : hParamMC->Cldfb_RealBuffer_tc = NULL;
1163 : }
1164 5665 : if ( hParamMC->Cldfb_ImagBuffer_tc != NULL )
1165 : {
1166 5409 : free( hParamMC->Cldfb_ImagBuffer_tc );
1167 5409 : hParamMC->Cldfb_ImagBuffer_tc = NULL;
1168 : }
1169 :
1170 5665 : free( *hParamMC_out );
1171 5665 : *hParamMC_out = NULL;
1172 :
1173 5665 : return;
1174 : }
1175 :
1176 :
1177 : /*-------------------------------------------------------------------------
1178 : * ivas_param_mc_dec_read_BS()
1179 : *
1180 : * Read the Parametric MC metadata
1181 : *------------------------------------------------------------------------*/
1182 :
1183 208879 : void ivas_param_mc_dec_read_BS(
1184 : const int32_t ivas_total_brate, /* i : IVAS total bitrate */
1185 : Decoder_State *st, /* i/o: decoder state structure */
1186 : PARAM_MC_DEC_HANDLE hParamMC, /* i/o: decoder ParamMC handle */
1187 : int16_t *nb_bits /* o : number of bits written */
1188 : )
1189 : {
1190 : int16_t param_frame_idx;
1191 : int16_t band_step;
1192 : uint16_t bit_buffer[PARAM_MC_MAX_BITS];
1193 : int16_t bits_to_copy;
1194 : int16_t bit_pos;
1195 : int16_t num_lfe_bands;
1196 : int16_t num_param_bands;
1197 : int16_t metadata_bit_pos;
1198 : int16_t i, j, k;
1199 : int16_t icc_map_size;
1200 : int16_t icc_map_size_wo_lfe;
1201 : int16_t ild_map_size;
1202 : int16_t ild_map_size_wo_lfe;
1203 : HANDLE_IVAS_PARAM_MC_METADATA hMetadataPMC;
1204 :
1205 208879 : push_wmops( "param_mc_read_bs" );
1206 :
1207 : /* Inits */
1208 208879 : *nb_bits = 0;
1209 208879 : hMetadataPMC = hParamMC->hMetadataPMC;
1210 208879 : icc_map_size = hMetadataPMC->icc_mapping_conf->icc_map_size_lfe;
1211 208879 : icc_map_size_wo_lfe = hMetadataPMC->icc_mapping_conf->icc_map_size_wo_lfe;
1212 208879 : ild_map_size = hMetadataPMC->ild_mapping_conf->ild_map_size_lfe;
1213 208879 : ild_map_size_wo_lfe = hMetadataPMC->ild_mapping_conf->ild_map_size_wo_lfe;
1214 :
1215 208879 : if ( !st->bfi )
1216 : {
1217 201286 : metadata_bit_pos = (int16_t) ( ivas_total_brate / FRAMES_PER_SEC - 1 );
1218 201286 : bits_to_copy = (int16_t) min( ivas_total_brate / FRAMES_PER_SEC, PARAM_MC_MAX_BITS );
1219 :
1220 : /* copy and reverse metadata */
1221 203977862 : for ( bit_pos = 0; bit_pos < bits_to_copy; bit_pos++ )
1222 : {
1223 203776576 : bit_buffer[bit_pos] = st->bit_stream[metadata_bit_pos--];
1224 : }
1225 :
1226 201286 : bit_pos = 0;
1227 :
1228 : /* read reserved bit */
1229 201286 : hMetadataPMC->lfe_on = bit_buffer[bit_pos++];
1230 :
1231 : /* get coded bwidth */
1232 : {
1233 : int16_t pos;
1234 201286 : int16_t bw = 0;
1235 603858 : for ( pos = 0; pos < 2; pos++ )
1236 : {
1237 402572 : bw += ( bit_buffer[bit_pos++] << pos );
1238 : }
1239 201286 : hMetadataPMC->coded_bwidth = bw;
1240 : }
1241 :
1242 : /* set tables if coded band width differs from last frame */
1243 201286 : if ( hMetadataPMC->coded_bwidth != hMetadataPMC->last_coded_bwidth )
1244 : {
1245 6616 : ivas_param_mc_set_coded_bands( hMetadataPMC );
1246 6616 : param_mc_set_num_synth_bands( st->output_Fs, hParamMC );
1247 6616 : hParamMC->max_band_energy_compensation = hParamMC->band_grouping[hParamMC->num_param_bands_synth];
1248 : }
1249 :
1250 201286 : param_frame_idx = bit_buffer[bit_pos++];
1251 201286 : hMetadataPMC->param_frame_idx = param_frame_idx;
1252 201286 : num_param_bands = hMetadataPMC->nbands_in_param_frame[param_frame_idx];
1253 :
1254 201286 : hMetadataPMC->bAttackPresent = bit_buffer[bit_pos++];
1255 201286 : hMetadataPMC->attackIndex = 0;
1256 201286 : band_step = 1;
1257 201286 : num_lfe_bands = 0;
1258 :
1259 201286 : if ( hMetadataPMC->bAttackPresent )
1260 : {
1261 48044 : for ( i = 2; i >= 0; i-- )
1262 : {
1263 36033 : hMetadataPMC->attackIndex += ( bit_buffer[bit_pos++] << i );
1264 : }
1265 :
1266 12011 : band_step = PARAM_MC_TRANSIENT_BAND_STEP;
1267 12011 : num_lfe_bands = PARAM_MC_MAX_BAND_LFE / band_step + ( PARAM_MC_MAX_BAND_LFE % band_step ) ? 1 : 0;
1268 12011 : num_param_bands = hMetadataPMC->nbands_coded / band_step + ( ( hMetadataPMC->nbands_coded % band_step ) ? 1 : 0 );
1269 : }
1270 : else
1271 : {
1272 378550 : for ( j = 0; j < PARAM_MC_MAX_BAND_LFE; j += band_step )
1273 : {
1274 189275 : if ( param_frame_idx == hMetadataPMC->coding_band_mapping[j] )
1275 : {
1276 : /* LFE ICC is always the last ICC in coding band 0 */
1277 94203 : num_lfe_bands++;
1278 : }
1279 : }
1280 : }
1281 :
1282 201286 : if ( !hMetadataPMC->lfe_on )
1283 : {
1284 40809 : num_lfe_bands = 0;
1285 : }
1286 :
1287 201286 : ivas_param_mc_bs_decode_parameter_values( bit_buffer, &bit_pos, bits_to_copy, &st->BER_detect, hMetadataPMC, &hMetadataPMC->icc_coding,
1288 : icc_map_size_wo_lfe, icc_map_size, num_lfe_bands, band_step, num_param_bands, hParamMC->icc_q );
1289 201286 : if ( !st->BER_detect )
1290 : {
1291 201286 : ivas_param_mc_bs_decode_parameter_values( bit_buffer, &bit_pos, bits_to_copy, &st->BER_detect, hMetadataPMC, &hMetadataPMC->ild_coding,
1292 : ild_map_size_wo_lfe, ild_map_size, num_lfe_bands, band_step, num_param_bands, hParamMC->icld_q );
1293 : }
1294 : /* set LFE ILD and ICC to zero above PARAM_MC_MAX_BAND_LFE for attack frames */
1295 201286 : if ( hMetadataPMC->bAttackPresent )
1296 : {
1297 22707 : for ( k = PARAM_MC_MAX_BAND_LFE; k < band_step * num_lfe_bands; k++ )
1298 : {
1299 10696 : hParamMC->icc_q[( k + 1 ) * icc_map_size - 1] = 1.0f;
1300 10696 : hParamMC->icld_q[( k + 1 ) * ild_map_size - 1] = PARAM_MC_DEFAULT_MIN_ILD;
1301 : }
1302 : }
1303 :
1304 201286 : *nb_bits = bit_pos;
1305 :
1306 : } /* if ( !st->bfi ) */
1307 :
1308 208879 : if ( st->bfi )
1309 : {
1310 : /* for PLC, use the saved ILDs and ICCs from the past and set the transient flag and transient position to zero */
1311 7593 : hMetadataPMC->bAttackPresent = 0;
1312 7593 : hMetadataPMC->attackIndex = 0;
1313 : }
1314 :
1315 208879 : pop_wmops();
1316 :
1317 208879 : return;
1318 : }
1319 :
1320 :
1321 : /*-------------------------------------------------------------------------
1322 : * ivas_param_mc_dec_digest_tc()
1323 : *
1324 : *
1325 : *------------------------------------------------------------------------*/
1326 :
1327 199607 : void ivas_param_mc_dec_digest_tc(
1328 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder handle */
1329 : const uint8_t nCldfbSlots, /* i : number of CLDFB slots in transport channels */
1330 : float *p_data_f[] /* i/o: synthesized core-coder transport channels/DirAC output */
1331 : )
1332 : {
1333 : int16_t ch, num_freq_bands, slot_idx, cldfb_ch, n_ch_cldfb;
1334 : float *cldfb_real_buffer, *cldfb_imag_buffer;
1335 :
1336 : /* Initialization */
1337 199607 : num_freq_bands = st_ivas->hParamMC->num_freq_bands;
1338 199607 : n_ch_cldfb = st_ivas->hTcBuffer->nchan_transport_jbm - st_ivas->hTcBuffer->nchan_buffer_full;
1339 :
1340 199607 : cldfb_real_buffer = st_ivas->hParamMC->Cldfb_RealBuffer_tc;
1341 199607 : cldfb_imag_buffer = st_ivas->hParamMC->Cldfb_ImagBuffer_tc;
1342 :
1343 : /* CLDFB Analysis */
1344 627916 : for ( ch = 0, cldfb_ch = 0; cldfb_ch < n_ch_cldfb; cldfb_ch++, ch++ )
1345 : {
1346 7281272 : for ( slot_idx = 0; slot_idx < nCldfbSlots; slot_idx++ )
1347 : {
1348 6852963 : cldfbAnalysis_ts( &( p_data_f[ch][num_freq_bands * slot_idx] ),
1349 6852963 : &cldfb_real_buffer[slot_idx * num_freq_bands * n_ch_cldfb + cldfb_ch * num_freq_bands],
1350 6852963 : &cldfb_imag_buffer[slot_idx * num_freq_bands * n_ch_cldfb + cldfb_ch * num_freq_bands],
1351 : num_freq_bands, st_ivas->cldfbAnaDec[cldfb_ch] );
1352 : }
1353 : }
1354 :
1355 199607 : return;
1356 : }
1357 :
1358 :
1359 : /*-------------------------------------------------------------------------
1360 : * ivas_param_mc_dec_prepare_renderer()
1361 : *
1362 : *
1363 : *------------------------------------------------------------------------*/
1364 :
1365 199607 : void ivas_param_mc_dec_prepare_renderer(
1366 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder handle */
1367 : const uint8_t nCldfbSlots /* i : number of CLDFB slots in transport channels */
1368 : )
1369 : {
1370 : PARAM_MC_DEC_HANDLE hParamMC;
1371 : int16_t i;
1372 : int16_t is_next_band, skip_next_band;
1373 : int16_t slot_idx, param_band_idx;
1374 : int16_t nchan_transport, nchan_out_transport, nchan_out_cldfb;
1375 : int16_t nchan_out_cov;
1376 : /*CLDFB*/
1377 : float *pCx, *pCx_imag;
1378 : float cx[PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS];
1379 : float cx_imag[PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS];
1380 : float cx_next_band[PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS];
1381 : float cx_imag_next_band[PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS];
1382 : float real_part, imag_part;
1383 : /* format converter */
1384 : int16_t channel_active[MAX_OUTPUT_CHANNELS];
1385 : IVAS_OUTPUT_SETUP *hSynthesisOutputSetup;
1386 :
1387 199607 : hParamMC = st_ivas->hParamMC;
1388 199607 : assert( hParamMC );
1389 :
1390 199607 : push_wmops( "param_mc_dec_digest_tc" );
1391 :
1392 199607 : set_s( channel_active, 0, MAX_LS_CHANNELS );
1393 199607 : nchan_transport = st_ivas->nchan_transport;
1394 199607 : nchan_out_transport = st_ivas->hTransSetup.nchan_out_woLFE + st_ivas->hTransSetup.num_lfe;
1395 :
1396 199607 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
1397 : {
1398 124909 : nchan_out_cldfb = BINAURAL_CHANNELS;
1399 124909 : set_s( channel_active, 1, nchan_out_cldfb );
1400 124909 : nchan_out_cov = st_ivas->hTransSetup.nchan_out_woLFE + st_ivas->hTransSetup.num_lfe;
1401 124909 : hSynthesisOutputSetup = &st_ivas->hTransSetup;
1402 : }
1403 74698 : else if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_CLDFB )
1404 : {
1405 15021 : nchan_out_cov = nchan_out_transport;
1406 15021 : nchan_out_cldfb = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
1407 15021 : hSynthesisOutputSetup = &st_ivas->hTransSetup;
1408 : }
1409 59677 : else if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
1410 : {
1411 13772 : nchan_out_cov = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
1412 13772 : nchan_out_cldfb = nchan_out_cov;
1413 13772 : set_s( channel_active, 1, nchan_out_cov );
1414 13772 : hSynthesisOutputSetup = &st_ivas->hOutSetup;
1415 : }
1416 : else
1417 : {
1418 45905 : nchan_out_cov = nchan_out_transport;
1419 45905 : nchan_out_cldfb = nchan_out_transport;
1420 45905 : set_s( channel_active, 1, nchan_out_cov );
1421 45905 : hSynthesisOutputSetup = &st_ivas->hTransSetup;
1422 : }
1423 :
1424 : /* adapt transient position */
1425 199607 : if ( hParamMC->hMetadataPMC->bAttackPresent )
1426 : {
1427 11269 : hParamMC->hMetadataPMC->attackIndex = (int16_t) max( 0, hParamMC->hMetadataPMC->attackIndex + ( ( nCldfbSlots - DEFAULT_JBM_CLDFB_TIMESLOTS ) / 2 ) );
1428 : }
1429 : /* adapt subframes */
1430 199607 : hParamMC->num_slots = nCldfbSlots;
1431 199607 : hParamMC->slots_rendered = 0;
1432 199607 : hParamMC->subframes_rendered = 0;
1433 199607 : ivas_jbm_dec_get_adapted_subframes( nCldfbSlots, hParamMC->subframe_nbslots, &hParamMC->nb_subframes );
1434 199607 : st_ivas->hTcBuffer->nb_subframes = hParamMC->nb_subframes;
1435 199607 : mvs2s( hParamMC->subframe_nbslots, st_ivas->hTcBuffer->subframe_nbslots, hParamMC->nb_subframes );
1436 :
1437 199607 : ivas_param_mc_dec_compute_interpolator( hParamMC->hMetadataPMC->bAttackPresent, hParamMC->hMetadataPMC->attackIndex, nCldfbSlots, hParamMC->h_output_synthesis_params.interpolator );
1438 :
1439 : /* loop over two bands at a time */
1440 1527354 : for ( param_band_idx = 0; param_band_idx < hParamMC->num_param_bands_synth; param_band_idx += 2 )
1441 : {
1442 : /* don't process next band if it exceeds the limit */
1443 1327747 : skip_next_band = ( ( param_band_idx + 1 ) == hParamMC->num_param_bands_synth ) ? 1 : 0;
1444 :
1445 1327747 : set_zero( cx, PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS );
1446 1327747 : set_zero( cx_imag, PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS );
1447 1327747 : set_zero( cx_next_band, PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS );
1448 1327747 : set_zero( cx_imag_next_band, PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS );
1449 :
1450 : /* slot loop for gathering the input data */
1451 22571740 : for ( slot_idx = 0; slot_idx < nCldfbSlots; slot_idx++ )
1452 : {
1453 21243993 : if ( slot_idx >= 2 * hParamMC->hMetadataPMC->attackIndex )
1454 : {
1455 62476527 : for ( is_next_band = 0; is_next_band < 2; is_next_band++ )
1456 : {
1457 41651018 : if ( is_next_band && skip_next_band )
1458 : {
1459 762230 : continue;
1460 : }
1461 :
1462 40888788 : ivas_dirac_dec_output_synthesis_cov_param_mc_collect_slot( &hParamMC->Cldfb_RealBuffer_tc[slot_idx * hParamMC->num_freq_bands * nchan_transport],
1463 40888788 : &hParamMC->Cldfb_ImagBuffer_tc[slot_idx * hParamMC->num_freq_bands * nchan_transport],
1464 : is_next_band ? cx_next_band : cx,
1465 : is_next_band ? cx_imag_next_band : cx_imag,
1466 40888788 : param_band_idx + is_next_band,
1467 : hParamMC,
1468 : nchan_transport );
1469 : }
1470 : }
1471 : }
1472 :
1473 : /* map from complex input covariance to real values */
1474 3983241 : for ( is_next_band = 0; is_next_band < 2; is_next_band++ )
1475 : {
1476 2655494 : if ( is_next_band && skip_next_band )
1477 : {
1478 48711 : continue;
1479 : }
1480 : /* Cx for transport channels */
1481 2606783 : pCx = is_next_band ? &cx_next_band[0] : &cx[0];
1482 2606783 : pCx_imag = is_next_band ? &cx_imag_next_band[0] : &cx_imag[0];
1483 15290405 : for ( i = 0; i < nchan_transport * nchan_transport; i++ )
1484 : {
1485 12683622 : real_part = pCx[i];
1486 12683622 : imag_part = pCx_imag[i];
1487 :
1488 : /* (a-ib)(c+id) = ac + bd + i(ad-bc) */
1489 12683622 : if ( param_band_idx < hParamMC->max_param_band_abs_cov )
1490 : {
1491 7556026 : pCx[i] = sqrtf( real_part * real_part + imag_part * imag_part );
1492 : }
1493 : else
1494 : {
1495 5127596 : pCx[i] = real_part;
1496 : }
1497 : }
1498 : }
1499 :
1500 : /* we have to do it similar to the encoder in case of attacks (i.e. accumulate two bands) to ensure correct DMX of the target covariance*/
1501 1327747 : if ( hParamMC->hMetadataPMC->bAttackPresent && ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO ) )
1502 : {
1503 5617 : v_add( cx, cx_next_band, cx, nchan_transport * nchan_transport );
1504 5617 : mvr2r( cx, cx_next_band, nchan_transport * nchan_transport );
1505 : }
1506 :
1507 :
1508 3983241 : for ( is_next_band = 0; is_next_band < 2; is_next_band++ )
1509 : {
1510 2655494 : if ( is_next_band && skip_next_band )
1511 : {
1512 48711 : continue;
1513 : }
1514 :
1515 : /* generate mixing matrices */
1516 2606783 : ivas_param_mc_get_mixing_matrices( hParamMC,
1517 : hSynthesisOutputSetup,
1518 : is_next_band ? cx_next_band : cx,
1519 2606783 : param_band_idx + is_next_band,
1520 2606783 : hParamMC->h_output_synthesis_cov_state.mixing_matrix,
1521 2606783 : hParamMC->h_output_synthesis_cov_state.mixing_matrix_res,
1522 : nchan_out_transport,
1523 : hParamMC->synthesis_conf,
1524 : nchan_transport,
1525 : nchan_out_cov );
1526 : }
1527 : }
1528 :
1529 199607 : pop_wmops();
1530 :
1531 199607 : return;
1532 : }
1533 :
1534 :
1535 : /*-------------------------------------------------------------------------
1536 : * ivas_param_mc_dec_render()
1537 : *
1538 : * Parametric MC rendering process
1539 : *------------------------------------------------------------------------*/
1540 :
1541 243549 : void ivas_param_mc_dec_render(
1542 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder handle */
1543 : const uint16_t nSamplesAsked, /* i : number of CLDFB slots requested */
1544 : uint16_t *nSamplesRendered, /* o : number of CLDFB slots rendered */
1545 : uint16_t *nSamplesAvailableNext, /* o : number of CLDFB slots still to render */
1546 : float *output_f[] /* o : rendered time signal */
1547 : )
1548 : {
1549 : PARAM_MC_DEC_HANDLE hParamMC;
1550 : int16_t i, ch;
1551 : int16_t subframe_idx;
1552 : int16_t slot_idx, slot_idx_start, slot_idx_start_cldfb_synth, first_sf, last_sf, slots_to_render;
1553 : int16_t nchan_transport, nchan_out_transport, nchan_out_cldfb;
1554 : int16_t nchan_out_cov;
1555 : /*CLDFB*/
1556 : float Cldfb_RealBuffer[MAX_INTERN_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX];
1557 : float Cldfb_ImagBuffer[MAX_INTERN_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX];
1558 : float Cldfb_RealBuffer_Binaural[MAX_HEAD_ROT_POSES][BINAURAL_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX];
1559 : float Cldfb_ImagBuffer_Binaural[MAX_HEAD_ROT_POSES][BINAURAL_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX];
1560 : /*Decorrelator*/
1561 : float onset_filter[MAX_LS_CHANNELS * CLDFB_NO_CHANNELS_MAX];
1562 : /* format converter */
1563 : int16_t channel_active[MAX_OUTPUT_CHANNELS];
1564 : uint16_t nband_synth, nbands_to_zero;
1565 : uint16_t nchan_out_init;
1566 : uint32_t output_Fs;
1567 :
1568 243549 : hParamMC = st_ivas->hParamMC;
1569 243549 : assert( hParamMC );
1570 :
1571 243549 : push_wmops( "param_mc_dec_render" );
1572 :
1573 243549 : set_s( channel_active, 0, MAX_LS_CHANNELS );
1574 243549 : nchan_transport = st_ivas->nchan_transport;
1575 243549 : nchan_out_transport = st_ivas->hTransSetup.nchan_out_woLFE + st_ivas->hTransSetup.num_lfe;
1576 243549 : nchan_out_init = nchan_out_transport;
1577 243549 : output_Fs = st_ivas->hDecoderConfig->output_Fs;
1578 :
1579 243549 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
1580 : {
1581 161455 : nchan_out_cldfb = BINAURAL_CHANNELS;
1582 161455 : set_s( channel_active, 1, nchan_out_cldfb );
1583 161455 : if ( st_ivas->hCombinedOrientationData )
1584 : {
1585 94375 : nchan_out_init = MAX_INTERN_CHANNELS;
1586 : }
1587 161455 : nchan_out_cov = st_ivas->hTransSetup.nchan_out_woLFE + st_ivas->hTransSetup.num_lfe;
1588 : }
1589 82094 : else if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_CLDFB )
1590 : {
1591 16381 : nchan_out_cov = nchan_out_transport;
1592 16381 : nchan_out_cldfb = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
1593 : }
1594 65713 : else if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_COV || hParamMC->synthesis_conf == PARAM_MC_SYNTH_MONO_STEREO )
1595 : {
1596 14372 : nchan_out_cov = st_ivas->hOutSetup.nchan_out_woLFE + st_ivas->hOutSetup.num_lfe;
1597 14372 : nchan_out_cldfb = nchan_out_cov;
1598 14372 : set_s( channel_active, 1, nchan_out_cov );
1599 : }
1600 : else
1601 : {
1602 51341 : nchan_out_cov = nchan_out_transport;
1603 51341 : nchan_out_cldfb = nchan_out_transport;
1604 51341 : set_s( channel_active, 1, nchan_out_cov );
1605 : }
1606 :
1607 : /* set everything to zero that will not be decoded */
1608 243549 : nband_synth = hParamMC->band_grouping[hParamMC->num_param_bands_synth];
1609 243549 : nbands_to_zero = hParamMC->num_freq_bands - nband_synth;
1610 2829805 : for ( ch = 0; ch < nchan_out_init; ch++ )
1611 : {
1612 12931280 : for ( slot_idx = 0; slot_idx < JBM_CLDFB_SLOTS_IN_SUBFRAME; slot_idx++ )
1613 : {
1614 10345024 : set_zero( &( Cldfb_RealBuffer[ch][slot_idx][nband_synth] ), nbands_to_zero );
1615 10345024 : set_zero( &( Cldfb_ImagBuffer[ch][slot_idx][nband_synth] ), nbands_to_zero );
1616 : }
1617 : }
1618 :
1619 : /* loop for synthesis, assume we always have to render in multiples of 5ms subframes with spills */
1620 243549 : slots_to_render = min( hParamMC->num_slots - hParamMC->slots_rendered, nSamplesAsked / NS2SA( output_Fs, CLDFB_SLOT_NS ) );
1621 243549 : *nSamplesRendered = slots_to_render * NS2SA( output_Fs, CLDFB_SLOT_NS );
1622 243549 : first_sf = hParamMC->subframes_rendered;
1623 243549 : last_sf = first_sf;
1624 1045548 : while ( slots_to_render > 0 )
1625 : {
1626 801999 : slots_to_render -= hParamMC->subframe_nbslots[last_sf];
1627 801999 : last_sf++;
1628 : }
1629 : #ifdef DEBUGGING
1630 : assert( slots_to_render == 0 );
1631 : #endif
1632 243549 : if ( st_ivas->renderer_type == RENDERER_SBA_LINEAR_ENC )
1633 : {
1634 88385 : for ( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
1635 : {
1636 69556 : slots_to_render += hParamMC->subframe_nbslots[subframe_idx];
1637 : }
1638 : }
1639 243549 : slot_idx_start = hParamMC->slots_rendered;
1640 243549 : slot_idx_start_cldfb_synth = 0;
1641 1045548 : for ( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
1642 : {
1643 3995722 : for ( slot_idx = 0; slot_idx < hParamMC->subframe_nbslots[subframe_idx]; slot_idx++, hParamMC->slots_rendered++ )
1644 : {
1645 :
1646 3193723 : if ( hParamMC->max_band_decorr > 0 )
1647 : {
1648 : /*-----------------------------------------------------------------*
1649 : * protoype signal computation
1650 : *-----------------------------------------------------------------*/
1651 :
1652 3193723 : param_mc_protoSignalComputation( &hParamMC->Cldfb_RealBuffer_tc[hParamMC->slots_rendered * nchan_transport * hParamMC->num_freq_bands],
1653 3193723 : &hParamMC->Cldfb_ImagBuffer_tc[hParamMC->slots_rendered * nchan_transport * hParamMC->num_freq_bands],
1654 3193723 : hParamMC->proto_frame_f, hParamMC->diff_proto_info,
1655 3193723 : hParamMC->num_freq_bands );
1656 :
1657 : /*-----------------------------------------------------------------*
1658 : * frequency domain decorrelation
1659 : *-----------------------------------------------------------------*/
1660 :
1661 : /* decorrelate prototype frame */
1662 3193723 : ivas_dirac_dec_decorr_process( hParamMC->num_freq_bands,
1663 3193723 : hParamMC->num_outputs_diff,
1664 3193723 : hParamMC->diff_proto_info->num_protos_diff,
1665 : DIRAC_SYNTHESIS_COV_MC_LS,
1666 : nchan_transport,
1667 3193723 : hParamMC->proto_frame_f,
1668 3193723 : hParamMC->diff_proto_info->num_protos_diff,
1669 3193723 : hParamMC->diff_proto_info->proto_index_diff,
1670 : hParamMC->proto_frame_dec_f,
1671 : onset_filter,
1672 : hParamMC->h_freq_domain_decorr_ap_params,
1673 : hParamMC->h_freq_domain_decorr_ap_state );
1674 :
1675 : /* copy decorrelated frame directly to output CLDFB buffer, acts also as intermediate */
1676 : /* memory for the decorrelated signal */
1677 3193723 : ivas_param_mc_dec_copy_diffuse_proto( hParamMC, Cldfb_RealBuffer, Cldfb_ImagBuffer, nchan_out_cov, slot_idx );
1678 : }
1679 :
1680 : /*-----------------------------------------------------------------*
1681 : * output synthesis
1682 : *-----------------------------------------------------------------*/
1683 :
1684 3193723 : ivas_dirac_dec_output_synthesis_cov_param_mc_synthesise_slot( &hParamMC->Cldfb_RealBuffer_tc[hParamMC->slots_rendered * nchan_transport * hParamMC->num_freq_bands],
1685 3193723 : &hParamMC->Cldfb_ImagBuffer_tc[hParamMC->slots_rendered * nchan_transport * hParamMC->num_freq_bands],
1686 : Cldfb_RealBuffer, Cldfb_ImagBuffer,
1687 3193723 : hParamMC->h_output_synthesis_cov_state.mixing_matrix, hParamMC->h_output_synthesis_cov_state.mixing_matrix_res, slot_idx, slot_idx + slot_idx_start,
1688 : nchan_transport, nchan_out_cov, hParamMC );
1689 :
1690 3193723 : if ( ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM ) )
1691 : {
1692 1998555 : if (
1693 1998555 : st_ivas->hCombinedOrientationData && st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV )
1694 : {
1695 762523 : ivas_param_mc_mc2sba_cldfb( st_ivas->hTransSetup, hParamMC->hoa_encoder, slot_idx, Cldfb_RealBuffer, Cldfb_ImagBuffer, nband_synth, GAIN_LFE );
1696 : }
1697 : else
1698 : {
1699 : /* remove LFE */
1700 : uint16_t idx_out;
1701 : uint16_t idx_lfe;
1702 : IVAS_OUTPUT_SETUP hLsSetup;
1703 :
1704 1236032 : hLsSetup = st_ivas->hTransSetup;
1705 :
1706 : /* If LFE should be rendered, add it to other channels before removing */
1707 1236032 : if ( st_ivas->hBinRenderer->render_lfe )
1708 : {
1709 2472064 : for ( idx_lfe = 0; idx_lfe < hLsSetup.num_lfe; idx_lfe++ )
1710 : {
1711 : /* Copy just the first band of LFE*/
1712 1236032 : v_multc( Cldfb_RealBuffer[hLsSetup.index_lfe[idx_lfe]][slot_idx], ( GAIN_LFE / hLsSetup.nchan_out_woLFE ), Cldfb_RealBuffer[hLsSetup.index_lfe[idx_lfe]][slot_idx], 1 );
1713 1236032 : v_multc( Cldfb_ImagBuffer[hLsSetup.index_lfe[idx_lfe]][slot_idx], ( GAIN_LFE / hLsSetup.nchan_out_woLFE ), Cldfb_ImagBuffer[hLsSetup.index_lfe[idx_lfe]][slot_idx], 1 );
1714 :
1715 9460384 : for ( ch = 0; ch < ( hLsSetup.nchan_out_woLFE + hLsSetup.num_lfe ); ch++ )
1716 : {
1717 8224352 : if ( hLsSetup.index_lfe[idx_lfe] != ch )
1718 : {
1719 6988320 : v_add( Cldfb_RealBuffer[ch][slot_idx], Cldfb_RealBuffer[hLsSetup.index_lfe[idx_lfe]][slot_idx], Cldfb_RealBuffer[ch][slot_idx], 1 );
1720 6988320 : v_add( Cldfb_ImagBuffer[ch][slot_idx], Cldfb_ImagBuffer[hLsSetup.index_lfe[idx_lfe]][slot_idx], Cldfb_ImagBuffer[ch][slot_idx], 1 );
1721 : }
1722 : }
1723 : }
1724 : }
1725 :
1726 1236032 : idx_out = 0;
1727 1236032 : idx_lfe = 0;
1728 :
1729 9460384 : for ( ch = 0; ch < ( hLsSetup.nchan_out_woLFE + hLsSetup.num_lfe ); ch++ )
1730 : {
1731 8224352 : if ( ( hLsSetup.num_lfe > 0 ) && ( hLsSetup.index_lfe[idx_lfe] == ch ) )
1732 : {
1733 1236032 : if ( idx_lfe < ( hLsSetup.num_lfe - 1 ) )
1734 : {
1735 0 : idx_lfe++;
1736 : }
1737 : }
1738 6988320 : else if ( ch != idx_out )
1739 : {
1740 3280224 : mvr2r( Cldfb_RealBuffer[ch][slot_idx], Cldfb_RealBuffer[idx_out][slot_idx], nband_synth );
1741 3280224 : mvr2r( Cldfb_ImagBuffer[ch][slot_idx], Cldfb_ImagBuffer[idx_out][slot_idx], nband_synth );
1742 3280224 : idx_out++;
1743 : }
1744 : else
1745 : {
1746 3708096 : idx_out++;
1747 : }
1748 : }
1749 : }
1750 : }
1751 : }
1752 :
1753 801999 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
1754 : {
1755 503207 : if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM )
1756 : {
1757 0 : if ( st_ivas->hSplitBinRend->hCldfbDataOut != NULL )
1758 : {
1759 0 : for ( slot_idx = 0; slot_idx < MAX_PARAM_SPATIAL_SUBFRAMES; slot_idx++ )
1760 : {
1761 0 : for ( ch = 0; ch < ( st_ivas->hIntSetup.nchan_out_woLFE + st_ivas->hIntSetup.num_lfe ); ch++ )
1762 : {
1763 0 : mvr2r( Cldfb_RealBuffer[ch][slot_idx], st_ivas->hSplitBinRend->hCldfbDataOut->Cldfb_RealBuffer[ch][slot_idx_start + slot_idx], hParamMC->num_freq_bands );
1764 0 : mvr2r( Cldfb_ImagBuffer[ch][slot_idx], st_ivas->hSplitBinRend->hCldfbDataOut->Cldfb_ImagBuffer[ch][slot_idx_start + slot_idx], hParamMC->num_freq_bands );
1765 : }
1766 : }
1767 0 : st_ivas->hSplitBinRend->hCldfbDataOut->config = st_ivas->hIntSetup.output_config;
1768 : }
1769 : }
1770 :
1771 503207 : ivas_binRenderer( st_ivas->hBinRenderer,
1772 0 : ( st_ivas->hSplitBinRend == NULL ) ? NULL : &st_ivas->hSplitBinRend->splitrend.multiBinPoseData,
1773 : #ifdef SPLIT_REND_WITH_HEAD_ROT_DEBUG
1774 : NULL,
1775 : #endif
1776 : st_ivas->hCombinedOrientationData,
1777 503207 : hParamMC->subframe_nbslots[subframe_idx],
1778 : Cldfb_RealBuffer_Binaural, Cldfb_ImagBuffer_Binaural, Cldfb_RealBuffer, Cldfb_ImagBuffer );
1779 :
1780 503207 : if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM )
1781 : {
1782 : int16_t pos_idx;
1783 0 : for ( pos_idx = 0; pos_idx < st_ivas->hBinRenderer->numPoses; pos_idx++ )
1784 : {
1785 0 : for ( slot_idx = 0; slot_idx < hParamMC->subframe_nbslots[subframe_idx]; slot_idx++ )
1786 : {
1787 0 : for ( ch = 0; ch < nchan_out_cldfb; ch++ )
1788 : {
1789 0 : mvr2r( Cldfb_RealBuffer_Binaural[pos_idx][ch][slot_idx], st_ivas->hSplitBinRend->hMultiBinCldfbData->Cldfb_RealBuffer_Binaural[( pos_idx * BINAURAL_CHANNELS ) + ch][slot_idx_start + slot_idx], hParamMC->num_freq_bands );
1790 0 : mvr2r( Cldfb_ImagBuffer_Binaural[pos_idx][ch][slot_idx], st_ivas->hSplitBinRend->hMultiBinCldfbData->Cldfb_ImagBuffer_Binaural[( pos_idx * BINAURAL_CHANNELS ) + ch][slot_idx_start + slot_idx], hParamMC->num_freq_bands );
1791 : }
1792 : }
1793 : }
1794 : }
1795 :
1796 : /* update combined orientation access index */
1797 503207 : ivas_combined_orientation_update_index( st_ivas->hCombinedOrientationData, hParamMC->num_freq_bands * hParamMC->subframe_nbslots[subframe_idx] );
1798 : }
1799 298792 : else if ( hParamMC->synthesis_conf == PARAM_MC_SYNTH_LS_CONV_CLDFB )
1800 : {
1801 : /* format conversion*/
1802 60084 : ivas_lssetupconversion_process_param_mc( st_ivas, hParamMC->subframe_nbslots[subframe_idx], Cldfb_RealBuffer, Cldfb_ImagBuffer, channel_active );
1803 : }
1804 :
1805 : /* CLDFB synthesis */
1806 4191253 : for ( ch = 0; ch < nchan_out_cldfb; ch++ )
1807 : {
1808 : float *RealBuffer[16];
1809 : float *ImagBuffer[16];
1810 :
1811 3389254 : if ( channel_active[ch] )
1812 : {
1813 : /* open CLDFB buffer up to CLDFB_NO_CHANNELS_MAX bands for 48kHz */
1814 15768604 : for ( i = 0; i < hParamMC->subframe_nbslots[subframe_idx]; i++ )
1815 : {
1816 12609174 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
1817 : {
1818 3997110 : RealBuffer[i] = Cldfb_RealBuffer_Binaural[0][ch][i];
1819 3997110 : ImagBuffer[i] = Cldfb_ImagBuffer_Binaural[0][ch][i];
1820 : }
1821 : else
1822 : {
1823 8612064 : RealBuffer[i] = Cldfb_RealBuffer[ch][i];
1824 8612064 : ImagBuffer[i] = Cldfb_ImagBuffer[ch][i];
1825 : }
1826 : }
1827 :
1828 3159430 : cldfbSynthesis( RealBuffer, ImagBuffer, &( output_f[ch][slot_idx_start_cldfb_synth * hParamMC->num_freq_bands] ),
1829 3159430 : hParamMC->num_freq_bands * hParamMC->subframe_nbslots[subframe_idx], st_ivas->cldfbSynDec[ch] );
1830 : }
1831 : else
1832 : {
1833 229824 : set_f( &( output_f[ch][slot_idx_start_cldfb_synth * hParamMC->num_freq_bands] ), 0.0f, hParamMC->num_freq_bands * hParamMC->subframe_nbslots[subframe_idx] );
1834 : }
1835 : }
1836 801999 : slot_idx_start += hParamMC->subframe_nbslots[subframe_idx];
1837 801999 : slot_idx_start_cldfb_synth += hParamMC->subframe_nbslots[subframe_idx];
1838 : }
1839 :
1840 243549 : if ( st_ivas->renderer_type == RENDERER_SBA_LINEAR_ENC )
1841 : {
1842 18829 : ivas_mc2sba( st_ivas->hIntSetup, output_f, output_f, hParamMC->num_freq_bands * slots_to_render, st_ivas->hOutSetup.ambisonics_order, 0.f );
1843 : }
1844 :
1845 : /* update */
1846 243549 : if ( hParamMC->slots_rendered == hParamMC->num_slots )
1847 : {
1848 199607 : hParamMC->hMetadataPMC->last_coded_bwidth = hParamMC->hMetadataPMC->coded_bwidth;
1849 199607 : param_mc_update_mixing_matrices( hParamMC, hParamMC->h_output_synthesis_cov_state.mixing_matrix, hParamMC->h_output_synthesis_cov_state.mixing_matrix_res, nchan_transport, nchan_out_cov );
1850 : }
1851 243549 : hParamMC->subframes_rendered = last_sf;
1852 243549 : *nSamplesAvailableNext = ( hParamMC->num_slots - hParamMC->slots_rendered ) * NS2SA( output_Fs, CLDFB_SLOT_NS );
1853 243549 : pop_wmops();
1854 :
1855 243549 : return;
1856 : }
1857 :
1858 :
1859 : /*-------------------------------------------------------------------------
1860 : * param_mc_dec_init()
1861 : *
1862 : * Parametric MC decoding initialization
1863 : *------------------------------------------------------------------------*/
1864 :
1865 5665 : static void ivas_param_mc_dec_init(
1866 : PARAM_MC_DEC_HANDLE hParamMC, /* i/o: decoder DirAC handle */
1867 : const int16_t nchan_transport, /* i : number of input (transport) channels */
1868 : const int16_t nchan_cov ) /* i : number of cov synthesis channels */
1869 : {
1870 : int16_t k;
1871 : uint16_t max_param_band_residual;
1872 : int16_t len;
1873 :
1874 : /*-----------------------------------------------------------------*
1875 : * init sub-modules
1876 : *-----------------------------------------------------------------*/
1877 :
1878 : /* decorrelation */
1879 5665 : if ( hParamMC->max_band_decorr > 0 )
1880 : {
1881 5409 : len = hParamMC->diff_proto_info->num_protos_diff * hParamMC->h_freq_domain_decorr_ap_params->h_onset_detection_power_params.max_band_decorr;
1882 :
1883 : /* init onsetDetectionPower */
1884 5409 : set_zero( hParamMC->h_freq_domain_decorr_ap_state->h_onset_detection_power_state.onset_detector_1, len );
1885 5409 : set_zero( hParamMC->h_freq_domain_decorr_ap_state->h_onset_detection_power_state.onset_detector_2, len );
1886 : }
1887 :
1888 5665 : max_param_band_residual = 0;
1889 :
1890 : /* output synthesis */
1891 25169 : for ( k = hParamMC->hMetadataPMC->num_parameter_bands; k >= 0; k-- )
1892 : {
1893 25169 : if ( hParamMC->band_grouping[k] <= hParamMC->max_band_decorr )
1894 : {
1895 5665 : max_param_band_residual = k;
1896 : #ifdef DEBUGGING
1897 : assert( hParamMC->band_grouping[k] == hParamMC->max_band_decorr );
1898 : #endif
1899 5665 : break;
1900 : }
1901 : }
1902 :
1903 5665 : ivas_dirac_dec_output_synthesis_cov_init( &( hParamMC->h_output_synthesis_cov_state ), nchan_transport, nchan_cov, hParamMC->hMetadataPMC->num_parameter_bands, max_param_band_residual );
1904 :
1905 : /*-----------------------------------------------------------------*
1906 : * init proto frames
1907 : *-----------------------------------------------------------------*/
1908 :
1909 5665 : if ( hParamMC->max_band_decorr > 0 )
1910 : {
1911 5409 : set_zero( hParamMC->proto_frame_f, 2 * hParamMC->diff_proto_info->num_protos_diff * hParamMC->num_freq_bands );
1912 5409 : set_zero( hParamMC->proto_frame_dec_f, 2 * nchan_cov * hParamMC->num_freq_bands );
1913 : }
1914 :
1915 5665 : return;
1916 : }
1917 :
1918 :
1919 : /*-------------------------------------------------------------------------
1920 : * Local functions
1921 : *-------------------------------------------------------------------------*/
1922 :
1923 :
1924 : /*-------------------------------------------------------------------------
1925 : * ivas_param_mc_dec_compute_diffuse_proto()
1926 : *
1927 : * Compute prototypes for decorrelation
1928 : *------------------------------------------------------------------------*/
1929 :
1930 3193723 : static void param_mc_protoSignalComputation(
1931 : float *RealBuffer, /* i : CLDFB samples of the transport channels (real part) */
1932 : float *ImagBuffer, /* i : CLDFB samples of the transport channels (imaginary part) */
1933 : float *proto_frame_f, /* o : interleaved complex prototype CLDFB samples */
1934 : const PARAM_MC_DIFF_PROTO_INFO *diff_proto_info, /* i : prototype generation information */
1935 : const int16_t num_freq_bands /* i : number of frequency bands for the prototypes */
1936 : )
1937 : {
1938 : int16_t band;
1939 : int16_t proto_ch_idx, source_ch_cnt;
1940 : float *p_proto_frame;
1941 : float *p_real_buffer;
1942 : float *p_imag_buffer;
1943 :
1944 3193723 : set_zero( proto_frame_f, 2 * num_freq_bands * diff_proto_info->num_protos_diff );
1945 :
1946 13215596 : for ( proto_ch_idx = 0; proto_ch_idx < diff_proto_info->num_protos_diff; proto_ch_idx++ )
1947 : {
1948 10021873 : int16_t num_source_ch = diff_proto_info->num_source_chan_diff[proto_ch_idx];
1949 :
1950 22762448 : for ( source_ch_cnt = 0; source_ch_cnt < num_source_ch; source_ch_cnt++ )
1951 : {
1952 12740575 : float fac = diff_proto_info->proto_fac[proto_ch_idx][source_ch_cnt];
1953 12740575 : int16_t source_ch_idx = diff_proto_info->source_chan_idx[proto_ch_idx][source_ch_cnt];
1954 :
1955 12740575 : p_proto_frame = &proto_frame_f[proto_ch_idx * num_freq_bands * 2];
1956 12740575 : p_real_buffer = &RealBuffer[source_ch_idx * num_freq_bands];
1957 12740575 : p_imag_buffer = &ImagBuffer[source_ch_idx * num_freq_bands];
1958 :
1959 666964355 : for ( band = 0; band < num_freq_bands; band++ )
1960 : {
1961 654223780 : *( p_proto_frame++ ) += fac * ( *( p_real_buffer++ ) );
1962 654223780 : *( p_proto_frame++ ) += fac * ( *( p_imag_buffer++ ) );
1963 : }
1964 : }
1965 : }
1966 :
1967 3193723 : return;
1968 : }
1969 :
1970 :
1971 : /*-------------------------------------------------------------------------
1972 : * ivas_param_mc_dec_compute_diffuse_proto()
1973 : *
1974 : * Transfer decorrelated signals back from the decorrelator buffer to
1975 : * the buffers used in the final synthesis
1976 : *------------------------------------------------------------------------*/
1977 :
1978 3193723 : static void ivas_param_mc_dec_copy_diffuse_proto(
1979 : PARAM_MC_DEC_HANDLE hParamMC, /* i : Parametric MC handle */
1980 : float Cldfb_buffer_real[MAX_LS_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], /* o : CLDFB buffer used in the final synthesis (real part) */
1981 : float Cldfb_buffer_imag[MAX_LS_CHANNELS][PARAM_MC_MAX_NSLOTS_IN_SUBFRAME][CLDFB_NO_CHANNELS_MAX], /* o : CLDFB buffer used in the final synthesis (imaginary part) */
1982 : const int16_t nY, /* i : number of decorrelated channels */
1983 : const int16_t slot_idx /* i : current time slot index */
1984 : )
1985 : {
1986 : int16_t k, l;
1987 : int16_t num_freq_bands, num_freq_bands_diff;
1988 : float *p_proto_diff;
1989 :
1990 3193723 : num_freq_bands = hParamMC->num_freq_bands;
1991 3193723 : num_freq_bands_diff = hParamMC->h_output_synthesis_params.max_band_decorr;
1992 :
1993 25229383 : for ( k = 0; k < nY; k++ )
1994 : {
1995 22035660 : p_proto_diff = hParamMC->proto_frame_dec_f + k * 2 * num_freq_bands;
1996 462748860 : for ( l = 0; l < num_freq_bands_diff; l++ )
1997 : {
1998 440713200 : Cldfb_buffer_real[k][slot_idx][l] = *( p_proto_diff++ );
1999 440713200 : Cldfb_buffer_imag[k][slot_idx][l] = *( p_proto_diff++ );
2000 : }
2001 : }
2002 :
2003 3193723 : return;
2004 : }
2005 :
2006 :
2007 : /*-------------------------------------------------------------------------
2008 : * ivas_param_mc_bin2dec()
2009 : *
2010 : * decode a number of bits to an integer
2011 : *------------------------------------------------------------------------*/
2012 : /* r : decoded integer */
2013 529868 : static int16_t ivas_param_mc_bin2dec(
2014 : uint16_t bits[PARAM_MC_MAX_BITS], /* i : bit buffer */
2015 : const int16_t N /* i : number of bits to decode */
2016 : )
2017 : {
2018 : int16_t i;
2019 : int16_t out;
2020 :
2021 529868 : assert( N <= 16 );
2022 529868 : out = 0;
2023 2119508 : for ( i = 0; i < N; i++ )
2024 : {
2025 1589640 : out += ( bits[i] << ( N - 1 - i ) );
2026 : }
2027 :
2028 529868 : return out;
2029 : }
2030 :
2031 :
2032 : /*-------------------------------------------------------------------------
2033 : * ivas_param_mc_uniform_decoder()
2034 : *
2035 : * decode a uniformily coded sequence of float values
2036 : *------------------------------------------------------------------------*/
2037 :
2038 17220 : static int16_t ivas_param_mc_uniform_decoder(
2039 : float *seq, /* o : decoded sequence of float values */
2040 : const int16_t sz_seq, /* i : number of values to decode */
2041 : const float *alphabet, /* i : codebook */
2042 : const int16_t N, /* i : number of bits per coded index */
2043 : uint16_t bit_buffer[PARAM_MC_MAX_BITS] /* i : bit buffer to decode */
2044 : )
2045 : {
2046 : int16_t i;
2047 : int16_t idx;
2048 : int16_t n_bits;
2049 :
2050 17220 : n_bits = 0;
2051 17220 : assert( N * sz_seq < PARAM_MC_MAX_BITS );
2052 :
2053 547088 : for ( i = 0; i < sz_seq; ++i )
2054 : {
2055 529868 : idx = ivas_param_mc_bin2dec( &bit_buffer[i * N], N );
2056 529868 : seq[i] = alphabet[idx];
2057 : }
2058 :
2059 17220 : n_bits = N * sz_seq;
2060 :
2061 17220 : return n_bits;
2062 : }
2063 :
2064 :
2065 : /*-------------------------------------------------------------------------
2066 : * ivas_param_mc_range_decoder_LC()
2067 : *
2068 : * decode a sequency of inidices coded with a range coder
2069 : *------------------------------------------------------------------------*/
2070 :
2071 385352 : static int16_t ivas_param_mc_range_decoder_LC(
2072 : uint16_t *bit_buffer, /* i : bit buffer to read from */
2073 : int16_t *x, /* o : decoded indices */
2074 : int16_t *BER_detect, /* o : flag for indicating a bit error */
2075 : const int16_t sz_seq, /* i : size of the sequence to be decoded */
2076 : const int16_t sz_alphabet, /* i : size of the alphabet */
2077 : const uint16_t *cft, /* i : cumulative frequency table */
2078 : const uint16_t *sft, /* i : symbol frequency table */
2079 : const int16_t tot_shift, /* i : total frequency as a power of 2 */
2080 : const int16_t nbbits /* i : maximum bit budget */
2081 : )
2082 : {
2083 : RangeUniDecState rc_st_dec; /* State of the range decoder */
2084 : int16_t cur_bit_pos;
2085 : int16_t k;
2086 : int16_t r;
2087 :
2088 : /* Start Decoding */
2089 : /* Initialize range decoder */
2090 385352 : cur_bit_pos = 0;
2091 385352 : rc_uni_dec_init( &rc_st_dec, bit_buffer, nbbits - 32 ); /* (nbbits + 30) entries are read by the decoder */
2092 :
2093 : /* Main Loop through the indices */
2094 14887242 : for ( k = 0; k < sz_seq; k++ )
2095 : {
2096 14501890 : r = rc_uni_dec_read_symbol_fastS( &rc_st_dec, cft, sft, sz_alphabet, tot_shift ); /*Alphabet size = 17 (2^4 = 16 MSB symbols + 1 ESC symbol) */
2097 : /* r is the symbol read, the possible values are {0,1,....alphabet_size - 1} */
2098 :
2099 : /* Update bitstream pointer */
2100 14501890 : cur_bit_pos = rc_uni_dec_virtual_finish( &rc_st_dec );
2101 :
2102 : /* Confirm that there is no overflow */
2103 14501890 : if ( cur_bit_pos > nbbits )
2104 : {
2105 0 : *BER_detect |= 1;
2106 : }
2107 :
2108 14501890 : x[k] = r;
2109 : }
2110 :
2111 : /* We don't need to finish because virtual_finish() already does the same */
2112 : /*st->next_bit_pos = rc_uni_dec_finish(&rc_st_dec);*/
2113 :
2114 : /* Check for bitstream errors */
2115 385352 : if ( rc_st_dec.bit_error_detected != 0 )
2116 : {
2117 0 : *BER_detect |= 1;
2118 : }
2119 :
2120 385352 : return cur_bit_pos;
2121 : }
2122 :
2123 :
2124 : /*-------------------------------------------------------------------------
2125 : * param_mc_compute_interpolator()
2126 : *
2127 : * compute the interpolator used in the final synthesis
2128 : *------------------------------------------------------------------------*/
2129 :
2130 206239 : static void ivas_param_mc_dec_compute_interpolator(
2131 : const uint16_t bAttackPresent, /* i : flag indicating if we have a transient in the current frame */
2132 : const uint16_t attackPos, /* i : position of the transient */
2133 : const uint16_t interp_length, /* i : number of interpolation values to be calculated */
2134 : float *interpolator /* o : interpolator */
2135 : )
2136 : {
2137 : int16_t idx;
2138 :
2139 206239 : if ( bAttackPresent )
2140 : {
2141 74607 : for ( idx = 0; idx < 2 * attackPos; idx++ )
2142 : {
2143 63338 : interpolator[idx] = 0.0f;
2144 : }
2145 128235 : for ( ; idx < interp_length; idx++ )
2146 : {
2147 116966 : interpolator[idx] = 1.0f;
2148 : }
2149 : }
2150 : else
2151 : {
2152 194970 : ivas_jbm_dec_get_adapted_linear_interpolator( DEFAULT_JBM_CLDFB_TIMESLOTS, interp_length, interpolator );
2153 : }
2154 :
2155 206239 : return;
2156 : }
2157 :
2158 :
2159 : /*-------------------------------------------------------------------------
2160 : * remove_lfe_from_cy()
2161 : *
2162 : * remove all LFE related values from a covariance matrix
2163 : *------------------------------------------------------------------------*/
2164 :
2165 2447812 : static void remove_lfe_from_cy(
2166 : const int16_t nY, /* i : dimension of the covariance matrix */
2167 : int16_t lfe_indices[PARAM_MC_LOCAL_SZ_LFE_MAP], /* i : LFE index */
2168 : int16_t num_lfe, /* i : number of LFEs */
2169 : float *cy, /* i : covariance matrix */
2170 : float *cy_woLFE ) /* o : covariance matrix with LFE removed */
2171 : {
2172 : int16_t ch_idx1, ch_idx2;
2173 : int16_t lfe_idx1, lfe_idx2;
2174 : float *ptrCy;
2175 : float *ptrCy_out;
2176 :
2177 2447812 : ptrCy = cy;
2178 2447812 : ptrCy_out = cy_woLFE;
2179 :
2180 7343436 : for ( lfe_idx1 = 0; lfe_idx1 < num_lfe + 1; lfe_idx1++ )
2181 : {
2182 19385280 : for ( ch_idx1 = lfe_indices[lfe_idx1] + 1; ch_idx1 < lfe_indices[lfe_idx1 + 1]; ch_idx1++ )
2183 : {
2184 43468968 : for ( lfe_idx2 = 0; lfe_idx2 < num_lfe + 1; lfe_idx2++ )
2185 : {
2186 120027196 : for ( ch_idx2 = lfe_indices[lfe_idx2] + 1; ch_idx2 < lfe_indices[lfe_idx2 + 1]; ch_idx2++ )
2187 : {
2188 91047884 : *( ptrCy_out++ ) = *( ptrCy++ );
2189 : }
2190 28979312 : ptrCy++;
2191 : }
2192 14489656 : ptrCy--;
2193 : }
2194 4895624 : ptrCy += nY;
2195 : }
2196 :
2197 2447812 : return;
2198 : }
2199 :
2200 :
2201 : /*-------------------------------------------------------------------------
2202 : * ivas_param_mc_get_mixing_matrices()
2203 : *
2204 : * calculate the direct and residual mixing matrices
2205 : * using the covariance method
2206 : *------------------------------------------------------------------------*/
2207 :
2208 2606783 : static void ivas_param_mc_get_mixing_matrices(
2209 : PARAM_MC_DEC_HANDLE hParamMC, /* i : Parametric MC handle */
2210 : IVAS_OUTPUT_SETUP *hSynthesisOutputSetup,
2211 : float Cx_in[PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS], /* i : input covariance for all parameter bands */
2212 : const int16_t param_band_idx, /* i : parameter band index */
2213 : float *mixing_matrix[], /* o : direct mixing matrices for all parameter bands */
2214 : float *mixing_matrix_res[], /* o : residual mixing matrices for all parameter bands */
2215 : const int16_t nY_intern, /* i : number of channels in the transported format */
2216 : const PARAM_MC_SYNTHESIS_CONF synth_config, /* i : Parametric MC synthesis config */
2217 : const int16_t nX, /* i : number of transport channels */
2218 : const int16_t nY_cov /* i : number of covariance synthesis output channels */
2219 : )
2220 : {
2221 : float Cx[PARAM_MC_MAX_TRANSPORT_CHANS * PARAM_MC_MAX_TRANSPORT_CHANS];
2222 : float Cy[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2223 : float Cy_diag[MAX_LS_CHANNELS];
2224 : float Cr[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2225 : float Cproto_diag[MAX_LS_CHANNELS];
2226 : float Cproto[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2227 : float mat_mult_buffer1[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2228 : float *Cx_state;
2229 : float *Cx_old_state;
2230 : float Cy_state[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2231 : float *Cy_old_state;
2232 : int16_t nY_band;
2233 : float proto_matrix_noLFE[PARAM_MC_MAX_TRANSPORT_CHANS * MAX_LS_CHANNELS];
2234 : float *proto_matrix_ptr;
2235 : int16_t num_lfe_bands;
2236 : int16_t brange[2];
2237 : uint16_t i;
2238 : int16_t ch_idx1, ch_idx2, lfe_idx1, lfe_idx2;
2239 : float *ptrMM;
2240 : float *ptrMM_out;
2241 : float Cy_full[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2242 : float mixing_matrix_local[MAX_LS_CHANNELS * PARAM_MC_MAX_TRANSPORT_CHANS];
2243 : float mixing_matrix_res_local[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2244 : int16_t remove_lfe;
2245 : int16_t lfe_indices[PARAM_MC_LOCAL_SZ_LFE_MAP];
2246 :
2247 2606783 : set_zero( Cproto, MAX_LS_CHANNELS * MAX_LS_CHANNELS );
2248 2606783 : set_zero( mat_mult_buffer1, MAX_LS_CHANNELS * MAX_LS_CHANNELS );
2249 2606783 : set_zero( proto_matrix_noLFE, PARAM_MC_MAX_TRANSPORT_CHANS * MAX_LS_CHANNELS );
2250 :
2251 2606783 : nY_band = nY_cov;
2252 2606783 : num_lfe_bands = 0;
2253 2606783 : remove_lfe = 0;
2254 :
2255 2606783 : set_s( lfe_indices, -1, PARAM_MC_LOCAL_SZ_LFE_MAP );
2256 2606783 : if ( hSynthesisOutputSetup->num_lfe )
2257 : {
2258 : float *proto_matrix_ptr_in;
2259 : #ifdef DEBUGGING
2260 : assert( ( nY_cov == ( hSynthesisOutputSetup->nchan_out_woLFE + hSynthesisOutputSetup->num_lfe ) ) && "Number of channels do not match!" );
2261 : #endif
2262 5213566 : for ( lfe_idx1 = 0; lfe_idx1 < hSynthesisOutputSetup->num_lfe; lfe_idx1++ )
2263 : {
2264 2606783 : lfe_indices[lfe_idx1 + 1] = hSynthesisOutputSetup->index_lfe[lfe_idx1];
2265 : }
2266 2606783 : lfe_indices[hSynthesisOutputSetup->num_lfe + 1] = nY_cov;
2267 2606783 : proto_matrix_ptr = &proto_matrix_noLFE[0];
2268 2606783 : proto_matrix_ptr_in = &hParamMC->h_output_synthesis_params.proto_matrix[0];
2269 2606783 : set_zero( proto_matrix_noLFE, PARAM_MC_MAX_TRANSPORT_CHANS * MAX_LS_CHANNELS );
2270 :
2271 8271647 : for ( ch_idx1 = 0; ch_idx1 < nX; ch_idx1++ )
2272 : {
2273 16994592 : for ( lfe_idx1 = 0; lfe_idx1 < hSynthesisOutputSetup->num_lfe + 1; lfe_idx1++ )
2274 : {
2275 45958364 : for ( ch_idx2 = lfe_indices[lfe_idx1] + 1; ch_idx2 < lfe_indices[lfe_idx1 + 1]; ch_idx2++ )
2276 : {
2277 34628636 : *( proto_matrix_ptr++ ) = *( proto_matrix_ptr_in++ );
2278 : }
2279 11329728 : proto_matrix_ptr_in++;
2280 : }
2281 5664864 : proto_matrix_ptr_in--;
2282 : }
2283 : }
2284 :
2285 2606783 : if ( hParamMC->hMetadataPMC->lfe_on )
2286 : {
2287 2097902 : num_lfe_bands = PARAM_MC_MAX_BAND_LFE;
2288 : }
2289 :
2290 2606783 : if ( hSynthesisOutputSetup->num_lfe > 0 && param_band_idx >= num_lfe_bands )
2291 : {
2292 2447812 : remove_lfe = 1;
2293 2447812 : nY_band = nY_cov - hSynthesisOutputSetup->num_lfe;
2294 2447812 : proto_matrix_ptr = proto_matrix_noLFE;
2295 : }
2296 : else
2297 : {
2298 158971 : proto_matrix_ptr = hParamMC->h_output_synthesis_params.proto_matrix;
2299 : }
2300 :
2301 2606783 : brange[0] = hParamMC->band_grouping[param_band_idx];
2302 2606783 : brange[1] = hParamMC->band_grouping[param_band_idx + 1];
2303 :
2304 2606783 : Cx_state = Cx_in;
2305 2606783 : Cx_old_state = hParamMC->h_output_synthesis_cov_state.cx_old[param_band_idx];
2306 2606783 : Cy_old_state = hParamMC->h_output_synthesis_cov_state.cy_old[param_band_idx];
2307 :
2308 : /* Getting mixing mtx */
2309 : /* estimate target cov from input cov and proto_matrix */
2310 2606783 : matrix_product( hParamMC->proto_matrix_int, nY_intern, nX, 0, Cx_state, nX, nX, 0, mat_mult_buffer1 );
2311 :
2312 2606783 : matrix_product( mat_mult_buffer1, nY_intern, nX, 0, hParamMC->proto_matrix_int, nY_intern, nX, 1, Cproto );
2313 :
2314 21105669 : for ( ch_idx1 = 0; ch_idx1 < nY_intern; ch_idx1++ )
2315 : {
2316 18498886 : if ( Cproto[ch_idx1 + ch_idx1 * nY_intern] < 0.0f )
2317 : {
2318 0 : Cproto[ch_idx1 + ch_idx1 * nY_intern] = 0.0f;
2319 : }
2320 : }
2321 :
2322 2606783 : ivas_param_mc_dequantize_cov( hParamMC,
2323 2606783 : hParamMC->icld_q + param_band_idx * hParamMC->hMetadataPMC->ild_mapping_conf->ild_map_size_lfe,
2324 2606783 : hParamMC->icc_q + param_band_idx * hParamMC->hMetadataPMC->icc_mapping_conf->icc_map_size_lfe,
2325 : param_band_idx, nY_cov,
2326 : synth_config,
2327 : nY_intern,
2328 : nX, Cx_state, Cproto, Cy_state );
2329 :
2330 : /* Smoothing: Sum over two buffers */
2331 2606783 : if ( hParamMC->hMetadataPMC->bAttackPresent )
2332 : {
2333 : /* no smoothing on attacks */
2334 148224 : mvr2r( Cx_state, Cx, nX * nX );
2335 148224 : mvr2r( Cy_state, Cy_full, nY_cov * nY_cov );
2336 : }
2337 : else
2338 : {
2339 : /* smoothing gains are now identical to one, simply add up */
2340 2458559 : v_add( Cx_state, Cx_old_state, Cx, nX * nX );
2341 2458559 : v_add( Cy_state, Cy_old_state, Cy_full, nY_cov * nY_cov );
2342 : }
2343 :
2344 : /* cov buffer update */
2345 2606783 : mvr2r( Cx_state, Cx_old_state, nX * nX );
2346 2606783 : mvr2r( Cy_state, Cy_old_state, nY_cov * nY_cov );
2347 :
2348 : /* remove LFE if necessary */
2349 2606783 : if ( remove_lfe )
2350 : {
2351 2447812 : remove_lfe_from_cy( nY_cov, lfe_indices, hSynthesisOutputSetup->num_lfe, Cy_full, Cy );
2352 : }
2353 : else
2354 : {
2355 158971 : mvr2r( Cy_full, Cy, nY_band * nY_band );
2356 : }
2357 :
2358 2606783 : matrix_product( proto_matrix_ptr, nY_band, nX, 0, Cx, nX, nX, 0, mat_mult_buffer1 );
2359 :
2360 2606783 : matrix_product_diag( mat_mult_buffer1, nY_band, nX, 0, proto_matrix_ptr, nY_band, nX, 1, Cproto_diag );
2361 :
2362 : /* make sure we have no negative entries in Cproto_diag due to rounding errors */
2363 18229077 : for ( ch_idx1 = 0; ch_idx1 < nY_band; ch_idx1++ )
2364 : {
2365 15622294 : if ( Cproto_diag[ch_idx1] < 0.0f )
2366 : {
2367 0 : Cproto_diag[ch_idx1] = 0.0f;
2368 : }
2369 : }
2370 :
2371 : /* Computing the mixing matrices */
2372 :
2373 : /* bands with decorr */
2374 2606783 : if ( brange[0] < hParamMC->h_output_synthesis_params.max_band_decorr )
2375 : {
2376 2135059 : computeMixingMatrices( nX, nY_band, Cx, Cy, proto_matrix_ptr, 0, PARAM_MC_REG_SX, PARAM_MC_REG_GHAT, mixing_matrix_local, Cr );
2377 :
2378 : /* Compute mixing matrix for residual */
2379 2135059 : computeMixingMatricesResidual( nY_band, Cproto_diag, Cr, PARAM_MC_REG_SX, PARAM_MC_REG_GHAT, mixing_matrix_res_local );
2380 :
2381 2135059 : if ( remove_lfe )
2382 : {
2383 1976088 : set_zero( mixing_matrix_res[param_band_idx], nY_cov * nY_cov );
2384 :
2385 1976088 : ptrMM = mixing_matrix_res_local;
2386 1976088 : ptrMM_out = mixing_matrix_res[param_band_idx];
2387 5928264 : for ( lfe_idx1 = 0; lfe_idx1 < hSynthesisOutputSetup->num_lfe + 1; lfe_idx1++ )
2388 : {
2389 15679192 : for ( ch_idx1 = lfe_indices[lfe_idx1] + 1; ch_idx1 < lfe_indices[lfe_idx1 + 1]; ch_idx1++ )
2390 : {
2391 35181048 : for ( lfe_idx2 = 0; lfe_idx2 < hSynthesisOutputSetup->num_lfe + 1; lfe_idx2++ )
2392 : {
2393 97316272 : for ( ch_idx2 = lfe_indices[lfe_idx2] + 1; ch_idx2 < lfe_indices[lfe_idx2 + 1]; ch_idx2++ )
2394 : {
2395 73862240 : *( ptrMM_out++ ) = *( ptrMM++ );
2396 : }
2397 23454032 : ptrMM_out++;
2398 : }
2399 11727016 : ptrMM_out--;
2400 : }
2401 3952176 : ptrMM_out += nY_cov;
2402 : }
2403 : }
2404 : else
2405 : {
2406 158971 : mvr2r( mixing_matrix_res_local, mixing_matrix_res[param_band_idx], nY_cov * nY_cov );
2407 : }
2408 : }
2409 471724 : else if ( brange[0] < hParamMC->max_band_energy_compensation )
2410 : {
2411 : /* Compute mixing matrices (energy compensation only) */
2412 471724 : computeMixingMatrices( nX, nY_band, Cx, Cy, proto_matrix_ptr, 1, PARAM_MC_REG_SX, PARAM_MC_REG_GHAT, mixing_matrix_local, Cr );
2413 : }
2414 : else
2415 : {
2416 : /*if neither decorrelation nor energy compensation is applied*/
2417 0 : for ( i = 0; i < nY_band; i++ )
2418 : {
2419 0 : Cy_diag[i] = Cy[i + nY_band * i];
2420 0 : Cy_diag[i] = sqrtf( Cy_diag[i] / ( Cproto_diag[i] + EPSILON ) );
2421 : }
2422 :
2423 0 : diag_matrix_product( Cy_diag, nY_band, proto_matrix_ptr, nY_band, nX, 0, mixing_matrix_local );
2424 : }
2425 2606783 : if ( remove_lfe )
2426 : {
2427 2447812 : set_zero( mixing_matrix[param_band_idx], nX * nY_cov );
2428 :
2429 2447812 : ptrMM = mixing_matrix_local;
2430 2447812 : ptrMM_out = mixing_matrix[param_band_idx];
2431 7765787 : for ( ch_idx1 = 0; ch_idx1 < nX; ch_idx1++ )
2432 : {
2433 15953925 : for ( lfe_idx1 = 0; lfe_idx1 < hSynthesisOutputSetup->num_lfe + 1; lfe_idx1++ )
2434 : {
2435 43075759 : for ( ch_idx2 = lfe_indices[lfe_idx1] + 1; ch_idx2 < lfe_indices[lfe_idx1 + 1]; ch_idx2++ )
2436 : {
2437 32439809 : *( ptrMM_out++ ) = *( ptrMM++ );
2438 : }
2439 10635950 : ptrMM_out++;
2440 : }
2441 5317975 : ptrMM_out--;
2442 : }
2443 : }
2444 : else
2445 : {
2446 158971 : mvr2r( mixing_matrix_local, mixing_matrix[param_band_idx], nY_cov * nX );
2447 : }
2448 :
2449 2606783 : return;
2450 : }
2451 :
2452 :
2453 : /*-------------------------------------------------------------------------
2454 : * param_mc_update_mixing_matrices()
2455 : *
2456 : * update mixing matrix buffers
2457 : *------------------------------------------------------------------------*/
2458 :
2459 199607 : static void param_mc_update_mixing_matrices(
2460 : PARAM_MC_DEC_HANDLE hParamMC, /* i/o: Parametric MC handle */
2461 : float *mixing_matrix[], /* i : direct mixing matrices for the frame just processed */
2462 : float *mixing_matrix_res[], /* i : residual mixing matrices for the frame just processed */
2463 : const uint16_t nX, /* i : number of transport channels */
2464 : const uint16_t nY ) /* i : number of synthesis channels */
2465 : {
2466 : uint16_t param_band_idx;
2467 :
2468 2851977 : for ( param_band_idx = 0; param_band_idx < hParamMC->hMetadataPMC->nbands_coded; param_band_idx++ )
2469 : {
2470 : int16_t brange[2];
2471 :
2472 2652370 : brange[0] = hParamMC->band_grouping[param_band_idx];
2473 2652370 : brange[1] = hParamMC->band_grouping[param_band_idx + 1];
2474 :
2475 2652370 : mvr2r( mixing_matrix[param_band_idx], hParamMC->h_output_synthesis_cov_state.mixing_matrix_old[param_band_idx], nX * nY );
2476 :
2477 2652370 : if ( brange[0] < hParamMC->h_output_synthesis_params.max_band_decorr )
2478 : {
2479 2135059 : mvr2r( mixing_matrix_res[param_band_idx], hParamMC->h_output_synthesis_cov_state.mixing_matrix_res_old[param_band_idx], nY * nY );
2480 : }
2481 : }
2482 :
2483 199607 : return;
2484 : }
2485 :
2486 :
2487 : /*-------------------------------------------------------------------------
2488 : * ivas_param_mc_dequantize_cov()
2489 : *
2490 : * generate the target covariance matrix
2491 : *------------------------------------------------------------------------*/
2492 :
2493 2606783 : static void ivas_param_mc_dequantize_cov(
2494 : PARAM_MC_DEC_HANDLE hParamMC, /* i : Parametric MC handle */
2495 : float *ild_q, /* i : sequence of dequantized ILD values */
2496 : float *icc_q, /* i : sequence of dequantized ICC values */
2497 : const int16_t param_band_index, /* i : current parameter band */
2498 : const int16_t nY_cov, /* i : number of output channels in the covariance synthesis */
2499 : const PARAM_MC_SYNTHESIS_CONF synth_conf, /* i : Parametric MC synthesis configuration */
2500 : const int16_t nY_int, /* i : number of channels in the transported format */
2501 : const int16_t nX, /* i : number of transport channels */
2502 : float *Cx_state, /* i : transport channel covariance matrix */
2503 : float *Cproto, /* i : prototype matrix */
2504 : float *Cy_state /* o : target covariance matrix */
2505 : )
2506 : {
2507 : float Nrqq[MAX_OUTPUT_CHANNELS];
2508 : float a[MAX_OUTPUT_CHANNELS];
2509 : int16_t k;
2510 : int16_t l;
2511 : float *Cyp;
2512 : float ap;
2513 : const PARAM_MC_ILD_MAPPING *h_ild_mapping;
2514 : float Cy_state_int[MAX_OUTPUT_CHANNELS * MAX_OUTPUT_CHANNELS];
2515 :
2516 2606783 : set_zero( Nrqq, MAX_OUTPUT_CHANNELS );
2517 2606783 : h_ild_mapping = hParamMC->hMetadataPMC->ild_mapping_conf;
2518 :
2519 : /*get back Nrg*/
2520 21105669 : for ( k = 0; k < nY_int; k++ )
2521 : {
2522 18498886 : float ref_ener = 0.0f;
2523 : int16_t ref_channel_cnt;
2524 : int16_t ref_channel_idx;
2525 :
2526 41308742 : for ( ref_channel_cnt = 0; ref_channel_cnt < h_ild_mapping->num_ref_channels[k]; ref_channel_cnt++ )
2527 : {
2528 22809856 : ref_channel_idx = h_ild_mapping->ref_channel_idx[k][ref_channel_cnt];
2529 22809856 : ref_ener += Cx_state[ref_channel_idx + ref_channel_idx * nX];
2530 : }
2531 18498886 : Nrqq[h_ild_mapping->ild_index[k]] = powf( 10.0f, ild_q[k] / 10.0f ) * hParamMC->hMetadataPMC->ild_factors[k] * ref_ener;
2532 : }
2533 :
2534 : /* estimate ICCs from estimated Cproto */
2535 21105669 : for ( k = 0; k < nY_int; k++ )
2536 : {
2537 18498886 : a[k] = 1.f / ( sqrtf( Cproto[k + nY_int * k] ) + EPSILON );
2538 :
2539 18498886 : v_multc( Cproto + k * nY_int, a[k], Cy_state_int + k * nY_int, nY_int );
2540 : }
2541 :
2542 21105669 : for ( k = 0; k < nY_int; k++ )
2543 : {
2544 18498886 : Cyp = Cy_state_int + k;
2545 18498886 : ap = a[k];
2546 155967914 : for ( l = 0; l < nY_int; l++ )
2547 : {
2548 137469028 : ( *Cyp ) *= ap;
2549 137469028 : Cyp += nY_int;
2550 : }
2551 : }
2552 :
2553 : /* replace some estimated ICCs with transmitted values */
2554 18498886 : for ( k = 0; k < hParamMC->hMetadataPMC->icc_mapping_conf->icc_map_size_lfe; k++ )
2555 : {
2556 15892103 : Cy_state_int[hParamMC->hMetadataPMC->icc_mapping_conf->icc_mapping[k][0] + nY_int * hParamMC->hMetadataPMC->icc_mapping_conf->icc_mapping[k][1]] = icc_q[k];
2557 15892103 : Cy_state_int[hParamMC->hMetadataPMC->icc_mapping_conf->icc_mapping[k][1] + nY_int * hParamMC->hMetadataPMC->icc_mapping_conf->icc_mapping[k][0]] = icc_q[k];
2558 : }
2559 :
2560 2606783 : if ( param_band_index >= PARAM_MC_MAX_BAND_LFE || !hParamMC->hMetadataPMC->lfe_on )
2561 : {
2562 19783080 : for ( k = 0; k < nY_int; k++ )
2563 : {
2564 17335268 : Cy_state_int[k + 3 * nY_int] = 1.0f;
2565 17335268 : Cy_state_int[3 + k * nY_int] = 1.0f;
2566 : }
2567 2447812 : Nrqq[3] = 0.0f;
2568 : }
2569 :
2570 : /* Generate back Covariance Mtx */
2571 21105669 : for ( k = 0; k < nY_int; k++ )
2572 : {
2573 18498886 : a[k] = sqrtf( Nrqq[k] );
2574 18498886 : v_multc( Cy_state_int + k * nY_int, a[k], Cy_state_int + k * nY_int, nY_int );
2575 : }
2576 :
2577 21105669 : for ( k = 0; k < nY_int; k++ )
2578 : {
2579 18498886 : Cyp = Cy_state_int + k;
2580 18498886 : ap = a[k];
2581 :
2582 155967914 : for ( l = 0; l < nY_int; l++ )
2583 : {
2584 137469028 : ( *Cyp ) *= ap;
2585 137469028 : Cyp += nY_int;
2586 : }
2587 : }
2588 :
2589 2606783 : if ( synth_conf == PARAM_MC_SYNTH_LS_CONV_COV )
2590 : {
2591 : /* Cy = dmx*Cy*dmx' */
2592 : float mat_mult_buffer1[MAX_LS_CHANNELS * MAX_LS_CHANNELS];
2593 : float target_ch_ener[MAX_LS_CHANNELS];
2594 : float dmx_ch_ener[MAX_LS_CHANNELS];
2595 :
2596 190432 : set_zero( target_ch_ener, MAX_LS_CHANNELS );
2597 190432 : set_zero( dmx_ch_ener, MAX_LS_CHANNELS );
2598 :
2599 190432 : matrix_product( hParamMC->ls_conv_dmx_matrix, nY_cov, nY_int, 0,
2600 : Cy_state_int, nY_int, nY_int, 0,
2601 : mat_mult_buffer1 );
2602 :
2603 190432 : matrix_product( mat_mult_buffer1, nY_cov, nY_int, 0,
2604 190432 : hParamMC->ls_conv_dmx_matrix, nY_cov, nY_int, 1,
2605 : Cy_state );
2606 :
2607 1398760 : for ( k = 0; k < nY_cov; k++ )
2608 : {
2609 11748528 : for ( l = 0; l < nY_int; l++ )
2610 : {
2611 10540200 : target_ch_ener[k] += hParamMC->ls_conv_dmx_matrix[k + l * nY_cov] * Nrqq[l];
2612 : }
2613 :
2614 1208328 : dmx_ch_ener[k] = Cy_state[k + nY_cov * k];
2615 :
2616 1208328 : if ( dmx_ch_ener[k] < 0.0f )
2617 : {
2618 0 : Cy_state[k + nY_cov * k] *= -1.0f;
2619 0 : dmx_ch_ener[k] *= -1.0f;
2620 : }
2621 :
2622 1208328 : target_ch_ener[k] = sqrtf( target_ch_ener[k] / ( dmx_ch_ener[k] + EPSILON ) );
2623 :
2624 1208328 : v_multc( Cy_state + k * nY_cov, target_ch_ener[k], Cy_state + k * nY_cov, nY_cov );
2625 :
2626 1208328 : Cyp = Cy_state + k;
2627 1208328 : ap = target_ch_ener[k];
2628 9014280 : for ( l = 0; l < nY_cov; l++ )
2629 : {
2630 7805952 : ( *Cyp ) *= ap;
2631 7805952 : Cyp += nY_cov;
2632 : }
2633 : }
2634 : }
2635 : else
2636 : {
2637 2416351 : mvr2r( Cy_state_int, Cy_state, nY_int * nY_int );
2638 : }
2639 :
2640 2606783 : return;
2641 : }
2642 :
2643 :
2644 : /*-------------------------------------------------------------------------*
2645 : * param_mc_set_num_synth_bands()
2646 : *
2647 : * set the number of frequency bands to be synthesized
2648 : *-------------------------------------------------------------------------*/
2649 :
2650 13305 : static void param_mc_set_num_synth_bands(
2651 : const int32_t output_Fs, /* i : output sampling frequency */
2652 : PARAM_MC_DEC_HANDLE hParamMC /* i/o: Parametric MC handle */
2653 : )
2654 : {
2655 : uint16_t max_param_band_synth;
2656 : const int16_t *param_mc_bands_coded;
2657 :
2658 13305 : switch ( hParamMC->hMetadataPMC->num_parameter_bands )
2659 : {
2660 1913 : case 20:
2661 1913 : param_mc_bands_coded = param_mc_bands_coded_20;
2662 1913 : break;
2663 4206 : case 10:
2664 4206 : param_mc_bands_coded = param_mc_bands_coded_10;
2665 4206 : break;
2666 7186 : case 14:
2667 : default:
2668 7186 : param_mc_bands_coded = param_mc_bands_coded_14;
2669 7186 : break;
2670 : }
2671 :
2672 13305 : switch ( output_Fs )
2673 : {
2674 0 : case 8000:
2675 0 : max_param_band_synth = param_mc_bands_coded[NB];
2676 0 : break;
2677 4528 : case 16000:
2678 4528 : max_param_band_synth = param_mc_bands_coded[WB];
2679 4528 : break;
2680 3739 : case 32000:
2681 3739 : max_param_band_synth = param_mc_bands_coded[SWB];
2682 3739 : break;
2683 5038 : case 48000:
2684 : default:
2685 5038 : max_param_band_synth = param_mc_bands_coded[FB];
2686 5038 : break;
2687 : }
2688 :
2689 13305 : hParamMC->num_param_bands_synth = min( hParamMC->hMetadataPMC->nbands_coded, max_param_band_synth );
2690 :
2691 13305 : return;
2692 : }
2693 :
2694 :
2695 : /*-------------------------------------------------------------------------*
2696 : * param_mc_get_diff_proto_info()
2697 : *
2698 : * calculated the diffuse prototype information
2699 : *-------------------------------------------------------------------------*/
2700 :
2701 5608 : static ivas_error param_mc_get_diff_proto_info(
2702 : const float *proto_mtx, /* i : protoype matrix for the synthesis */
2703 : const uint16_t nchan_transport, /* i : number of transport channels */
2704 : const uint16_t nchan_out_cov, /* i : number if output channels of the covariance synthesis */
2705 : PARAM_MC_DIFF_PROTO_INFO *p_diff_proto_info /* o : generated diffuse prototype info */
2706 : )
2707 : {
2708 : float proto_fac[MAX_LS_CHANNELS * PARAM_MC_MAX_TRANSPORT_CHANS];
2709 : uint16_t cur_out_ch;
2710 : uint16_t cur_diff_proto;
2711 : uint16_t cur_transport_ch;
2712 : uint16_t max_num_src_chan;
2713 :
2714 : /* Initializations */
2715 5608 : max_num_src_chan = 0;
2716 5608 : set_zero( proto_fac, MAX_LS_CHANNELS * PARAM_MC_MAX_TRANSPORT_CHANS );
2717 5608 : if ( ( p_diff_proto_info->proto_index_diff = (int16_t *) malloc( nchan_out_cov * sizeof( int16_t ) ) ) == NULL )
2718 : {
2719 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
2720 : }
2721 5608 : set_s( p_diff_proto_info->proto_index_diff, 0, nchan_out_cov );
2722 :
2723 5608 : if ( ( p_diff_proto_info->num_source_chan_diff = (int16_t *) malloc( nchan_out_cov * sizeof( int16_t ) ) ) == NULL )
2724 : {
2725 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
2726 : }
2727 5608 : set_s( p_diff_proto_info->num_source_chan_diff, 0, nchan_out_cov );
2728 :
2729 : /* we have at least one prototype, copy the first one */
2730 5608 : p_diff_proto_info->num_protos_diff = 1;
2731 5608 : mvr2r_inc( proto_mtx, nchan_out_cov, proto_fac, nchan_out_cov, nchan_transport );
2732 5608 : p_diff_proto_info->proto_index_diff[0] = 0;
2733 :
2734 : /* search for distinct prototypes */
2735 42098 : for ( cur_out_ch = 1; cur_out_ch < nchan_out_cov; cur_out_ch++ )
2736 : {
2737 36490 : uint16_t found = 0;
2738 :
2739 75191 : for ( cur_diff_proto = 0; cur_diff_proto < p_diff_proto_info->num_protos_diff; cur_diff_proto++ )
2740 : {
2741 63751 : float diff = 0;
2742 63751 : float *proto_fac_ptr = proto_fac + cur_diff_proto;
2743 63751 : const float *proto_mtx_ptr = proto_mtx + cur_out_ch;
2744 :
2745 214044 : for ( cur_transport_ch = 0; cur_transport_ch < nchan_transport; cur_transport_ch++ )
2746 : {
2747 150293 : diff += fabsf( *proto_fac_ptr - *proto_mtx_ptr );
2748 150293 : proto_fac_ptr += nchan_out_cov;
2749 150293 : proto_mtx_ptr += nchan_out_cov;
2750 : }
2751 :
2752 : /* we already have this prototype, save the index */
2753 63751 : if ( diff < 0.1f )
2754 : {
2755 25050 : found = 1;
2756 25050 : p_diff_proto_info->proto_index_diff[cur_out_ch] = cur_diff_proto;
2757 25050 : break;
2758 : }
2759 : }
2760 :
2761 : /* new distinct prototype, add it */
2762 36490 : if ( found == 0 )
2763 : {
2764 11440 : const float *proto_mtx_ptr = proto_mtx + cur_out_ch;
2765 : int16_t cur_num_src_chan;
2766 :
2767 11440 : cur_num_src_chan = 0;
2768 37418 : for ( cur_transport_ch = 0; cur_transport_ch < nchan_transport; cur_transport_ch++ )
2769 : {
2770 25978 : if ( *proto_mtx_ptr > EPSILON )
2771 : {
2772 15559 : cur_num_src_chan++;
2773 : }
2774 25978 : proto_mtx_ptr += nchan_out_cov;
2775 : }
2776 :
2777 11440 : mvr2r_inc( proto_mtx + cur_out_ch, nchan_out_cov, proto_fac + p_diff_proto_info->num_protos_diff, nchan_out_cov, nchan_transport );
2778 :
2779 11440 : p_diff_proto_info->proto_index_diff[cur_out_ch] = p_diff_proto_info->num_protos_diff;
2780 11440 : p_diff_proto_info->num_protos_diff++;
2781 11440 : max_num_src_chan = max( max_num_src_chan, cur_num_src_chan );
2782 : }
2783 : }
2784 :
2785 : /* set up the prototype info struct */
2786 5608 : if ( ( p_diff_proto_info->source_chan_idx = (int16_t **) malloc( p_diff_proto_info->num_protos_diff * sizeof( int16_t * ) ) ) == NULL )
2787 : {
2788 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
2789 : }
2790 5608 : if ( ( p_diff_proto_info->proto_fac = (float **) malloc( p_diff_proto_info->num_protos_diff * sizeof( float * ) ) ) == NULL )
2791 : {
2792 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
2793 : }
2794 :
2795 22656 : for ( cur_diff_proto = 0; cur_diff_proto < p_diff_proto_info->num_protos_diff; cur_diff_proto++ )
2796 : {
2797 : float *proto_fac_ptr;
2798 :
2799 17048 : if ( ( p_diff_proto_info->source_chan_idx[cur_diff_proto] = (int16_t *) malloc( max_num_src_chan * sizeof( int16_t ) ) ) == NULL )
2800 : {
2801 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
2802 : }
2803 17048 : if ( ( p_diff_proto_info->proto_fac[cur_diff_proto] = (float *) malloc( max_num_src_chan * sizeof( float ) ) ) == NULL )
2804 : {
2805 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Parametric MC\n" ) );
2806 : }
2807 :
2808 17048 : proto_fac_ptr = proto_fac + cur_diff_proto;
2809 55719 : for ( cur_transport_ch = 0; cur_transport_ch < nchan_transport; cur_transport_ch++ )
2810 : {
2811 38671 : if ( *proto_fac_ptr > EPSILON )
2812 : {
2813 21167 : p_diff_proto_info->source_chan_idx[cur_diff_proto][p_diff_proto_info->num_source_chan_diff[cur_diff_proto]] = cur_transport_ch;
2814 21167 : p_diff_proto_info->proto_fac[cur_diff_proto][p_diff_proto_info->num_source_chan_diff[cur_diff_proto]] = *proto_fac_ptr;
2815 21167 : p_diff_proto_info->num_source_chan_diff[cur_diff_proto]++;
2816 : }
2817 38671 : proto_fac_ptr += nchan_out_cov;
2818 : }
2819 : }
2820 :
2821 5608 : return IVAS_ERR_OK;
2822 : }
2823 :
2824 :
2825 : /*-------------------------------------------------------------------------*
2826 : * ivas_param_mc_bs_decode_parameter_values()
2827 : *
2828 : * reads and decodes a sequence of Parametric MC parameters from the bitstream
2829 : *-------------------------------------------------------------------------*/
2830 :
2831 402572 : static void ivas_param_mc_bs_decode_parameter_values(
2832 : uint16_t bit_buffer[], /* i : bitstream buffer */
2833 : int16_t *bit_pos, /* i/o: current bitstream buffer position */
2834 : const int16_t max_bits, /* i : maximum available bits in the buffer */
2835 : int16_t *BER_detect, /* i/o: bit error detection flag */
2836 : HANDLE_IVAS_PARAM_MC_METADATA hMetadataPMC, /* i : Parametric MC metadata information */
2837 : HANDLE_PARAM_MC_PARAMETER_CODING_INFO hParamCodingInfo, /* i : Parametric MC parameter quantization and coding tables */
2838 : const int16_t map_size_wo_lfe, /* i : number of parameters per band (w/o LFEs) */
2839 : const int16_t map_size, /* i : number of parameters per band (total) */
2840 : const int16_t num_lfe_bands, /* i : number of parameter bands with coded LFE */
2841 : const int16_t band_step, /* i : parameter band step */
2842 : const int16_t num_param_bands, /* i : number of parameter bands to decode */
2843 : float *value_buffer /* o : output buffer for decoded parameter values */
2844 : )
2845 : {
2846 : int16_t range_coding;
2847 : int16_t sz_seq;
2848 : int16_t delta_coding;
2849 : int16_t delta_idx[PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE];
2850 : int16_t idx[PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE];
2851 : int16_t idx_prev;
2852 : int16_t idx_offset;
2853 : int16_t sz_alphabet;
2854 : int16_t i, j, k;
2855 : float dequant_seq[PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE];
2856 : float dequant_ordered[PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE];
2857 : int16_t n_lfe_idx;
2858 :
2859 402572 : range_coding = bit_buffer[( *bit_pos )++];
2860 :
2861 : /* Decoding the sequence */
2862 402572 : n_lfe_idx = map_size - map_size_wo_lfe;
2863 402572 : sz_seq = num_param_bands * ( map_size_wo_lfe ) + num_lfe_bands * n_lfe_idx;
2864 :
2865 402572 : set_s( idx, 0, PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE );
2866 402572 : set_zero( dequant_ordered, PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE );
2867 402572 : set_zero( dequant_seq, PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE );
2868 :
2869 402572 : if ( range_coding )
2870 : {
2871 385352 : delta_coding = bit_buffer[( *bit_pos )++];
2872 :
2873 385352 : if ( delta_coding )
2874 : {
2875 378665 : idx_prev = hParamCodingInfo->quantizer_size / 2 + hParamCodingInfo->quantizer_size % 2 - 1;
2876 378665 : sz_alphabet = 2 * hParamCodingInfo->quantizer_size - 1;
2877 378665 : idx_offset = hParamCodingInfo->quantizer_size - 1;
2878 :
2879 : /* read range coded delta ICC indices */
2880 757330 : *bit_pos += ivas_param_mc_range_decoder_LC( &bit_buffer[*bit_pos], delta_idx, BER_detect, sz_seq, sz_alphabet,
2881 378665 : hParamCodingInfo->cum_freq_delta, hParamCodingInfo->sym_freq_delta, PARAM_MC_RANGE_CODER_TOT_SHIFT, max_bits - *bit_pos );
2882 :
2883 : /* delta index to absolute index */
2884 14640083 : for ( j = 0; j < sz_seq; j++ )
2885 : {
2886 14261418 : idx[j] = idx_prev + delta_idx[j] - idx_offset;
2887 14261418 : idx_prev = idx[j];
2888 : }
2889 : }
2890 : else
2891 : {
2892 : /* read range coded absolute ICC indices */
2893 6687 : sz_alphabet = hParamCodingInfo->quantizer_size;
2894 6687 : *bit_pos += ivas_param_mc_range_decoder_LC( &bit_buffer[*bit_pos], idx, BER_detect, sz_seq, sz_alphabet,
2895 6687 : hParamCodingInfo->cum_freq, hParamCodingInfo->sym_freq, PARAM_MC_RANGE_CODER_TOT_SHIFT, max_bits - *bit_pos );
2896 : }
2897 :
2898 : /* dequantize */
2899 14887242 : for ( j = 0; j < sz_seq; j++ )
2900 : {
2901 14501890 : dequant_seq[j] = hParamCodingInfo->quantizer[idx[j]];
2902 : }
2903 : }
2904 : else
2905 : {
2906 17220 : set_zero( dequant_seq, PARAM_MC_MAX_PARAMETER_BANDS * PARAM_MC_MAX_VAL_MAP_SIZE );
2907 :
2908 : /* read uniformly coded ICCs */
2909 17220 : *bit_pos += ivas_param_mc_uniform_decoder( dequant_seq, sz_seq, hParamCodingInfo->quantizer, hParamCodingInfo->uni_bits, &bit_buffer[*bit_pos] );
2910 : }
2911 :
2912 : /* reorder from sequential to parameter-band-wise */
2913 402572 : k = 0;
2914 2622509 : for ( j = 0; j < map_size_wo_lfe; ++j )
2915 : {
2916 17064470 : for ( i = 0; i < num_param_bands; ++i )
2917 : {
2918 14844533 : dequant_ordered[j + i * map_size] = dequant_seq[k++];
2919 : }
2920 : }
2921 :
2922 573172 : for ( i = 0; i < num_lfe_bands; i++ )
2923 : {
2924 357825 : for ( j = 0; j < n_lfe_idx; j++ )
2925 : {
2926 187225 : dequant_ordered[map_size - n_lfe_idx + j + i * map_size] = dequant_seq[k++];
2927 : }
2928 : }
2929 :
2930 402572 : if ( !( *BER_detect ) )
2931 : {
2932 402572 : j = 0;
2933 5596266 : for ( k = 0; k < hMetadataPMC->nbands_coded; k += band_step )
2934 : {
2935 5193694 : if ( hMetadataPMC->bAttackPresent || hMetadataPMC->param_frame_idx == hMetadataPMC->coding_band_mapping[k] )
2936 : {
2937 2678146 : mvr2r( dequant_ordered + j * map_size, value_buffer + k * map_size, map_size );
2938 2678146 : j++;
2939 : }
2940 5193694 : if ( hMetadataPMC->bAttackPresent && k + 1 < hMetadataPMC->nbands_coded )
2941 : {
2942 159692 : mvr2r( value_buffer + k * map_size, value_buffer + ( k + 1 ) * map_size, map_size );
2943 : }
2944 : }
2945 : }
2946 :
2947 402572 : return;
2948 : }
|
