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 <stdint.h>
34 : #include "options.h"
35 : #include "prot.h"
36 : #include "ivas_prot.h"
37 : #ifdef DEBUGGING
38 : #include "debug.h"
39 : #endif
40 : #include "math.h"
41 : #include "ivas_rom_com.h"
42 : #include <assert.h>
43 : #include "wmc_auto.h"
44 :
45 : /*------------------------------------------------------------------------------------------*
46 : * PreProcessor
47 : *------------------------------------------------------------------------------------------*/
48 :
49 : static const float pr_boost_range[2] = { 0.1f, 0.4f };
50 :
51 : typedef enum ivas_strats_t
52 : {
53 : START,
54 : BASE,
55 : BASE_DIFF,
56 : BASE_NOEC,
57 : FOUR_A,
58 : FOUR_B,
59 : FOUR_C,
60 : FOUR_D,
61 : NO_STRAT
62 : } ivas_strats_t;
63 :
64 :
65 : /*------------------------------------------------------------------------------------------*
66 : * Static functions declaration
67 : *------------------------------------------------------------------------------------------*/
68 :
69 : static void ivas_band_mixer( float *cov_re[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], const int16_t num_ch, int16_t *num_bands, int16_t red_band_fact );
70 :
71 : static int16_t ivas_get_huffman_coded_bs( ivas_spar_md_enc_state_t *hMdEnc, BSTR_ENC_HANDLE hMetaData, const int16_t nB, const int16_t qsi, const int16_t bands_bw );
72 :
73 : static int16_t ivas_get_arith_coded_bs( ivas_spar_md_enc_state_t *hMdEnc, BSTR_ENC_HANDLE hMetaData, const int16_t *pDo_diff, const int16_t bands_bw, const int16_t nB, const int16_t qsi, const int16_t strat, const int32_t ivas_total_brate );
74 :
75 : static void ivas_spar_set_enc_config( ivas_spar_md_enc_state_t *hMdEnc, int16_t *max_freq_per_chan, const int16_t nchan_transport, float *pFC, const int16_t nchan_inp );
76 :
77 : static void ivas_select_next_strat( ivas_strats_t prior_strat, ivas_strats_t cs[MAX_QUANT_STRATS], const int16_t dmx_switch, const int16_t dtx_vad );
78 :
79 : static void ivas_store_prior_coeffs( ivas_spar_md_enc_state_t *hMdEnc, const int16_t num_bands, const int16_t strat, const int16_t dtx_vad, const int16_t qsi );
80 :
81 : static void ivas_write_spar_md_bitstream( ivas_spar_md_enc_state_t *hMdEnc, const int16_t nB, const int16_t bands_bw, BSTR_ENC_HANDLE hMetaData, const int32_t ivas_total_brate, const int16_t strat, const int16_t qsi );
82 :
83 : static void ivas_spar_quant_pred_coeffs_dtx( ivas_spar_md_t *pSpar_md, const float *pValues, const int16_t ndm, int16_t *pIndex, const int16_t dim1, float *pQuant );
84 :
85 : static void ivas_quant_p_per_band_dtx( float *pP_mat, const int16_t num_dec, const int16_t num_dmx, int16_t *ppIdx_pd, float *pP_out, const int16_t num_ch );
86 :
87 : static void ivas_write_parameter_bitstream_dtx( ivas_spar_md_t *pSpar_md, BSTR_ENC_HANDLE hMetaData, int16_t *num_dmx, int16_t *num_dec, const int16_t num_bands );
88 :
89 : static void ivas_quant_p_per_band( ivas_band_coeffs_t *pband_coeffs, ivas_band_coeffs_ind_t *pBand_coeffs_idx, ivas_quant_strat_t *pQs, const int16_t num_ch );
90 :
91 : static void ivas_quant_c_per_band( ivas_band_coeffs_t *pband_coeffs, ivas_band_coeffs_ind_t *pBand_coeffs_idx, ivas_quant_strat_t *pQs, const int16_t ndec, const int16_t ndm );
92 :
93 : static void ivas_quant_pred_coeffs_per_band( ivas_band_coeffs_t *pband_coeffs, ivas_band_coeffs_ind_t *pBand_coeffs_idx, ivas_quant_strat_t *pQs, const int16_t num_ch );
94 :
95 :
96 : /*-------------------------------------------------------------------------
97 : * ivas_spar_md_enc_open()
98 : *
99 : * Allocate and initialize SPAR MD encoder handle
100 : *------------------------------------------------------------------------*/
101 :
102 15788 : ivas_error ivas_spar_md_enc_open(
103 : ivas_spar_md_enc_state_t **hMdEnc_in, /* i/o: SPAR MD encoder handle */
104 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
105 : const int16_t sba_order /* i : Ambisonic (SBA) order */
106 : )
107 : {
108 : ivas_spar_md_enc_state_t *hMdEnc;
109 : ivas_error error;
110 : int16_t num_channels, i, j;
111 15788 : error = IVAS_ERR_OK;
112 :
113 15788 : if ( ( hMdEnc = (ivas_spar_md_enc_state_t *) malloc( sizeof( ivas_spar_md_enc_state_t ) ) ) == NULL )
114 : {
115 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD encoder" );
116 : }
117 :
118 15788 : num_channels = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
119 :
120 15788 : if ( ( hMdEnc->spar_md.band_coeffs = (ivas_band_coeffs_t *) malloc( IVAS_MAX_NUM_BANDS * sizeof( ivas_band_coeffs_t ) ) ) == NULL )
121 : {
122 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for band_coeffs in SPAR MD" );
123 : }
124 15788 : if ( ( hMdEnc->mixer_mat = (float ***) malloc( num_channels * sizeof( float ** ) ) ) == NULL )
125 : {
126 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
127 : }
128 91127 : for ( i = 0; i < num_channels; i++ )
129 : {
130 75339 : if ( ( hMdEnc->mixer_mat[i] = (float **) malloc( num_channels * sizeof( float * ) ) ) == NULL )
131 : {
132 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
133 : }
134 489188 : for ( j = 0; j < num_channels; j++ )
135 : {
136 413849 : if ( ( hMdEnc->mixer_mat[i][j] = (float *) malloc( IVAS_MAX_NUM_BANDS * sizeof( float ) ) ) == NULL )
137 : {
138 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
139 : }
140 : }
141 : }
142 :
143 15788 : if ( ( hMdEnc->mixer_mat_local = (float ***) malloc( num_channels * sizeof( float ** ) ) ) == NULL )
144 : {
145 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
146 : }
147 91127 : for ( i = 0; i < num_channels; i++ )
148 : {
149 75339 : if ( ( hMdEnc->mixer_mat_local[i] = (float **) malloc( num_channels * sizeof( float * ) ) ) == NULL )
150 : {
151 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
152 : }
153 489188 : for ( j = 0; j < num_channels; j++ )
154 : {
155 413849 : if ( ( hMdEnc->mixer_mat_local[i][j] = (float *) malloc( IVAS_MAX_NUM_BANDS * sizeof( float ) ) ) == NULL )
156 : {
157 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
158 : }
159 : }
160 : }
161 :
162 15788 : if ( ( error = ivas_spar_md_enc_init( hMdEnc, hEncoderConfig, sba_order ) ) != IVAS_ERR_OK )
163 : {
164 0 : return error;
165 : }
166 :
167 15788 : *hMdEnc_in = hMdEnc;
168 :
169 15788 : return error;
170 : }
171 :
172 :
173 : /*-------------------------------------------------------------------------
174 : * ivas_spar_md_enc_close()
175 : *
176 : * Deallocate SPAR MD encoder handle
177 : *------------------------------------------------------------------------*/
178 :
179 15788 : void ivas_spar_md_enc_close(
180 : ivas_spar_md_enc_state_t **hMdEnc_in /* i/o: SPAR MD encoder handle */
181 : )
182 : {
183 : int16_t num_channels, i, j;
184 : ivas_spar_md_enc_state_t *hMdEnc;
185 :
186 15788 : if ( hMdEnc_in == NULL || *hMdEnc_in == NULL )
187 : {
188 0 : return;
189 : }
190 :
191 15788 : hMdEnc = *hMdEnc_in;
192 15788 : num_channels = hMdEnc->num_umx_ch;
193 :
194 15788 : if ( hMdEnc->spar_md.band_coeffs != NULL )
195 : {
196 15788 : free( hMdEnc->spar_md.band_coeffs );
197 15788 : hMdEnc->spar_md.band_coeffs = NULL;
198 : }
199 15788 : if ( hMdEnc->mixer_mat != NULL )
200 : {
201 91127 : for ( i = 0; i < num_channels; i++ )
202 : {
203 489188 : for ( j = 0; j < num_channels; j++ )
204 : {
205 413849 : free( hMdEnc->mixer_mat[i][j] );
206 : }
207 75339 : free( hMdEnc->mixer_mat[i] );
208 : }
209 15788 : free( hMdEnc->mixer_mat );
210 : }
211 :
212 15788 : if ( hMdEnc->mixer_mat_local != NULL )
213 : {
214 91127 : for ( i = 0; i < num_channels; i++ )
215 : {
216 :
217 489188 : for ( j = 0; j < num_channels; j++ )
218 : {
219 413849 : free( hMdEnc->mixer_mat_local[i][j] );
220 : }
221 75339 : free( hMdEnc->mixer_mat_local[i] );
222 : }
223 15788 : free( hMdEnc->mixer_mat_local );
224 : }
225 :
226 15788 : free( *hMdEnc_in );
227 15788 : *hMdEnc_in = NULL;
228 :
229 15788 : return;
230 : }
231 :
232 :
233 : /*-----------------------------------------------------------------------------------------*
234 : * Function ivas_spar_md_enc_init()
235 : *
236 : * SPAR MD encoder initialization
237 : *-----------------------------------------------------------------------------------------*/
238 :
239 19638 : ivas_error ivas_spar_md_enc_init(
240 : ivas_spar_md_enc_state_t *hMdEnc, /* o : MD encoder handle */
241 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
242 : const int16_t sba_order /* i : Ambisonic (SBA) order */
243 : )
244 : {
245 : float pFC[IVAS_MAX_NUM_BANDS];
246 : int16_t table_idx;
247 : float PR_minmax[2];
248 : int16_t num_channels, i, j, k;
249 :
250 19638 : ivas_sba_get_spar_hoa_md_flag( sba_order, hEncoderConfig->ivas_total_brate, &hMdEnc->spar_hoa_md_flag, &hMdEnc->spar_hoa_dirac2spar_md_flag );
251 19638 : num_channels = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
252 19638 : ivas_sba_get_spar_hoa_ch_ind( num_channels, hEncoderConfig->ivas_total_brate, hMdEnc->HOA_md_ind );
253 19638 : table_idx = ivas_get_spar_table_idx( hEncoderConfig->ivas_total_brate, sba_order, SPAR_CONFIG_BW, NULL, NULL );
254 :
255 19638 : hMdEnc->spar_md.prior_dyn_active_w_flag = 0;
256 :
257 : #ifndef DEBUG_AGC_ENCODER_CMD_OPTION
258 19638 : ivas_spar_set_bitrate_config( &hMdEnc->spar_md_cfg, table_idx, ( hMdEnc->spar_hoa_md_flag ) ? IVAS_MAX_NUM_BANDS : SPAR_DIRAC_SPLIT_START_BAND,
259 19638 : hMdEnc->spar_hoa_dirac2spar_md_flag, 1, hEncoderConfig->Opt_PCA_ON, ivas_agc_enc_get_flag( ivas_spar_br_table_consts[table_idx].nchan_transport ) );
260 : #else
261 : ivas_spar_set_bitrate_config( &hMdEnc->spar_md_cfg, table_idx, ( hMdEnc->spar_hoa_md_flag ) ? IVAS_MAX_NUM_BANDS : SPAR_DIRAC_SPLIT_START_BAND,
262 : hMdEnc->spar_hoa_dirac2spar_md_flag, 1, hEncoderConfig->Opt_PCA_ON, ivas_agc_enc_get_flag( hEncoderConfig->Opt_AGC_ON, ivas_spar_br_table_consts[table_idx].nchan_transport ) );
263 : #endif
264 :
265 : /* get FB coefficients */
266 255294 : for ( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
267 : {
268 235656 : pFC[i] = ivas_fb_fcs_12band_1ms[i] * hEncoderConfig->input_Fs * 0.5f;
269 : }
270 :
271 19638 : ivas_spar_set_enc_config( hMdEnc, hMdEnc->spar_md_cfg.max_freq_per_chan, hMdEnc->spar_md_cfg.nchan_transport, pFC, num_channels );
272 :
273 19638 : if ( hMdEnc->spar_md_cfg.nchan_transport != 2 && ( ( hMdEnc->spar_md_cfg.remix_unmix_order == 1 ) || ( hMdEnc->spar_md_cfg.remix_unmix_order == 2 ) ) )
274 : {
275 0 : return IVAS_ERR_INTERNAL;
276 : }
277 :
278 19638 : ivas_spar_arith_coeffs_com_init( &hMdEnc->arith_coeffs, &hMdEnc->spar_md_cfg, table_idx, ENC );
279 19638 : ivas_spar_huff_coeffs_com_init( &hMdEnc->huff_coeffs, NULL, table_idx, ENC );
280 :
281 19638 : if ( hEncoderConfig->Opt_DTX_ON == 1 )
282 : {
283 : /* DTX quant init */
284 2920 : PR_minmax[0] = hMdEnc->spar_md_cfg.quant_strat[0].PR.min;
285 2920 : PR_minmax[1] = hMdEnc->spar_md_cfg.quant_strat[0].PR.max;
286 2920 : ivas_spar_quant_dtx_init( &hMdEnc->spar_md, PR_minmax );
287 : }
288 :
289 19638 : hMdEnc->spar_md_cfg.prior_strat = START;
290 19638 : hMdEnc->spar_md_cfg.prev_quant_idx = -1;
291 :
292 110671 : for ( i = 0; i < num_channels; i++ )
293 : {
294 569926 : for ( j = 0; j < num_channels; j++ )
295 : {
296 6225609 : for ( k = 0; k < IVAS_MAX_NUM_BANDS; k++ )
297 : {
298 5746716 : hMdEnc->mixer_mat[i][j][k] = 0;
299 : }
300 : }
301 : }
302 :
303 19638 : ivas_clear_band_coeffs( hMdEnc->spar_md.band_coeffs, IVAS_MAX_NUM_BANDS );
304 19638 : ivas_clear_band_coeff_idx( hMdEnc->spar_md.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
305 19638 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
306 19638 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, IVAS_MAX_NUM_BANDS );
307 :
308 19638 : return IVAS_ERR_OK;
309 : }
310 :
311 :
312 : /*-----------------------------------------------------------------------------------------*
313 : * Function ivas_spar_set_enc_config()
314 : *
315 : * Set configuration for SPAR MD encoder
316 : *-----------------------------------------------------------------------------------------*/
317 :
318 19638 : static void ivas_spar_set_enc_config(
319 : ivas_spar_md_enc_state_t *hMdEnc,
320 : int16_t *max_freq_per_chan,
321 : const int16_t nchan_transport,
322 : float *pFC,
323 : const int16_t nchan_inp )
324 : {
325 : int16_t i, j;
326 : int16_t tmp_dmx_ch;
327 :
328 65347 : for ( i = 0; i < nchan_transport; i++ )
329 : {
330 45709 : if ( max_freq_per_chan != NULL )
331 : {
332 45709 : hMdEnc->spar_md_cfg.max_freq_per_chan[i] = ( max_freq_per_chan[i] != 0 ) ? max_freq_per_chan[i] : max_freq_per_chan[0];
333 : }
334 : else
335 : {
336 0 : hMdEnc->spar_md_cfg.max_freq_per_chan[i] = IVAS_SPAR_FOA_DFLT_FREQ_PER_CHAN;
337 : }
338 : }
339 19638 : hMdEnc->num_umx_ch = nchan_inp;
340 19638 : hMdEnc->num_decorr = nchan_inp - 1;
341 :
342 255294 : for ( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
343 : {
344 235656 : tmp_dmx_ch = 0;
345 784164 : for ( j = 0; j < nchan_transport; j++ )
346 : {
347 548508 : if ( pFC[i] < hMdEnc->spar_md_cfg.max_freq_per_chan[j] )
348 : {
349 548508 : tmp_dmx_ch += 1;
350 : }
351 : }
352 :
353 235656 : hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i] = tmp_dmx_ch;
354 235656 : hMdEnc->spar_md_cfg.num_decorr_per_band[i] = hMdEnc->num_umx_ch - tmp_dmx_ch;
355 : }
356 :
357 19638 : return;
358 : }
359 :
360 :
361 : /*-----------------------------------------------------------------------------------------*
362 : * Function ivas_band_limit_dmx_matrix()
363 : *
364 : * Band limit downmix matrix
365 : *-----------------------------------------------------------------------------------------*/
366 :
367 2523413 : static void ivas_band_limit_dmx_matrix(
368 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
369 : const int16_t num_ch,
370 : const int16_t num_bands,
371 : const int16_t bands_bw )
372 : {
373 : int16_t i, j, b, ndm;
374 :
375 22722579 : for ( b = 0; b < num_bands; b++ )
376 : {
377 20199166 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
378 :
379 63669192 : for ( i = ndm; i < num_ch; i++ )
380 : {
381 280619374 : for ( j = 0; j < num_ch; j++ )
382 : {
383 237149348 : hMdEnc->mixer_mat[i][j][b] = 0;
384 : }
385 : }
386 : }
387 :
388 2523413 : return;
389 : }
390 :
391 :
392 : /*-----------------------------------------------------------------------------------------*
393 : * Function ivas_band_mixing()
394 : *
395 : * Band mixing downmix matrix
396 : *-----------------------------------------------------------------------------------------*/
397 :
398 199311 : static void ivas_band_mixing(
399 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
400 : const int16_t num_ch,
401 : const int16_t num_bands,
402 : const int16_t nchan_transport,
403 : const int16_t upmixed_bands )
404 : {
405 : int16_t i, j, k, b;
406 : int16_t red_band_fact;
407 :
408 199311 : red_band_fact = upmixed_bands / num_bands;
409 :
410 404154 : for ( i = 0; i < nchan_transport; i++ )
411 : {
412 1024215 : for ( j = 0; j < num_ch; j++ )
413 : {
414 3939732 : for ( k = num_bands - 1; k >= 0; k-- )
415 : {
416 9675336 : for ( b = red_band_fact - 1; b >= 0; b-- )
417 : {
418 6554976 : hMdEnc->mixer_mat[i][j][red_band_fact * k + b] = hMdEnc->mixer_mat[i][j][k];
419 : }
420 : }
421 819372 : for ( k = red_band_fact * num_bands; k < upmixed_bands; k++ )
422 : {
423 0 : hMdEnc->mixer_mat[i][j][k] = hMdEnc->mixer_mat[i][j][( red_band_fact * num_bands ) - 1];
424 : }
425 : }
426 : }
427 199311 : return;
428 : }
429 :
430 :
431 : /*-----------------------------------------------------------------------------------------*
432 : * Function write_metadata_buffer()
433 : *
434 : *
435 : *-----------------------------------------------------------------------------------------*/
436 :
437 3959147 : static void write_metadata_buffer(
438 : BSTR_ENC_HANDLE hMetaData_tmp,
439 : BSTR_ENC_HANDLE hMetaData,
440 : const int16_t bit_pos_start,
441 : const int16_t next_ind_start )
442 : {
443 : int16_t i;
444 :
445 3959147 : if ( hMetaData->nb_bits_tot > 0 )
446 : {
447 3959147 : restore_metadata_buffer( hMetaData, next_ind_start, bit_pos_start );
448 : }
449 :
450 547688299 : for ( i = 0; i < hMetaData_tmp->nb_ind_tot; i++ )
451 : {
452 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
453 : push_next_indice_( hMetaData_tmp->ind_list[i].function_name, hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
454 : #else
455 543729152 : push_next_indice( hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
456 : #endif
457 : }
458 :
459 3959147 : return;
460 : }
461 :
462 :
463 : /*-----------------------------------------------------------------------------------------*
464 : * Function ivas_spar_md_enc_process()
465 : *
466 : * SPAR FoA Meta Data generation process
467 : *-----------------------------------------------------------------------------------------*/
468 :
469 2511926 : ivas_error ivas_spar_md_enc_process(
470 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
471 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
472 : float *cov_real[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
473 : float *cov_dtx_real[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
474 : BSTR_ENC_HANDLE hMetaData, /* i/o: MetaData handle */
475 : const int16_t dtx_vad,
476 : const int16_t nchan_inp,
477 : const int16_t sba_order, /* i : Ambisonic (SBA) order */
478 : float *prior_mixer[IVAS_MAX_FB_MIXER_OUT_CH][IVAS_MAX_SPAR_FB_MIXER_IN_CH], /* i : prior mixer_matrix */
479 : const int16_t dyn_active_w_flag, /* i : flag to indicate dynamic active W */
480 : const int16_t dirac_mono_flag /* i : flag to indicate mono only mode in SBA */
481 : )
482 : {
483 : float pred_coeffs_re[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
484 : float dm_fv_re[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
485 : int16_t i, j, b, qsi, ndm, ndec, num_ch, num_quant_strats;
486 : float pred_coeffs_re_local[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
487 : int16_t k, bwidth, num_bands, num_bands_full, num_bands_bw;
488 : int16_t active_w, nchan_transport, dmx_switch, strat;
489 2511926 : int16_t nB, bands_bw, packed_ok = 0;
490 : ivas_strats_t cs[MAX_CODING_STRATS];
491 : int16_t code_strat;
492 : int16_t bit_pos_start, next_ind_start;
493 : BSTR_ENC_DATA hMetaData_tmp;
494 : Indice *ind_list_tmp;
495 : int16_t md_indices_allocated;
496 : int16_t max_num_indices_tmp;
497 : float Wscale[IVAS_MAX_NUM_BANDS];
498 : float P_quant_re_prior[SPAR_DIRAC_SPLIT_START_BAND][FOA_CHANNELS - 1];
499 :
500 : /*extra 16 bits for arithmetic coder as overshoot check is after a symbol is written*/
501 2511926 : md_indices_allocated = hMdEnc->spar_md_cfg.max_bits_per_blk + IVAS_SPAR_ARITH_OVERSHOOT_BITS;
502 2511926 : if ( ( ind_list_tmp = (Indice *) malloc( sizeof( Indice ) * md_indices_allocated ) ) == NULL )
503 : {
504 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD encoder indices" );
505 : }
506 :
507 2511926 : num_quant_strats = hMdEnc->spar_md_cfg.num_quant_strats;
508 2511926 : num_ch = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
509 2511926 : active_w = ( hMdEnc->spar_md_cfg.active_w == 1 ) || ( dyn_active_w_flag == 1 );
510 2511926 : nchan_transport = hMdEnc->spar_md_cfg.nchan_transport;
511 :
512 2511926 : bwidth = ivas_get_bw_idx_from_sample_rate( hEncoderConfig->input_Fs );
513 2511926 : bwidth = min( bwidth, hEncoderConfig->max_bwidth );
514 : int16_t active_w_vlbr;
515 2511926 : active_w_vlbr = ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) ? 1 : 0;
516 2511926 : num_bands = ivas_get_num_bands_from_bw_idx( SPAR_CONFIG_BW );
517 2511926 : if ( hMdEnc->spar_hoa_md_flag == 0 )
518 : {
519 2302595 : num_bands = min( num_bands, SPAR_DIRAC_SPLIT_START_BAND );
520 : }
521 2511926 : num_bands_full = num_bands;
522 2511926 : num_bands_bw = ivas_get_num_bands_from_bw_idx( bwidth );
523 :
524 2511926 : if ( dtx_vad == 0 )
525 : {
526 70545 : for ( i = 0; i < nchan_inp; i++ )
527 : {
528 282180 : for ( j = 0; j < nchan_inp; j++ )
529 : {
530 225744 : cov_real[i][j] = cov_dtx_real[i][j];
531 : }
532 : }
533 : }
534 :
535 13526749 : for ( i = 0; i < nchan_inp; i++ )
536 : {
537 64215028 : for ( j = 0; j < nchan_inp; j++ )
538 : {
539 71431933 : for ( k = num_bands_bw; k < IVAS_MAX_NUM_BANDS; k++ )
540 : {
541 18231728 : cov_real[i][j][k] = 0;
542 : }
543 : }
544 : }
545 :
546 2511926 : if ( hEncoderConfig->ivas_total_brate == BRATE_SPAR_Q_STRAT && sba_order == SBA_FOA_ORDER )
547 : {
548 : /* make sure that qsi is always 0 (temporary bits are '00') */
549 219368 : num_quant_strats = 1;
550 : }
551 :
552 2511926 : hMetaData_tmp.ind_list = ind_list_tmp;
553 2511926 : hMetaData_tmp.nb_bits_tot = 0;
554 2511926 : max_num_indices_tmp = MAX_BITS_METADATA;
555 2511926 : hMetaData_tmp.ivas_max_num_indices = &max_num_indices_tmp;
556 2511926 : hMetaData_tmp.ivas_ind_list_zero = (Indice **) ( &hMetaData_tmp.ind_list );
557 2511926 : hMetaData_tmp.st_ivas = NULL;
558 :
559 : /* Save state of metadata bitstream buffer */
560 2511926 : bit_pos_start = hMetaData->nb_bits_tot;
561 2511926 : next_ind_start = hMetaData->nb_ind_tot;
562 :
563 2511926 : dmx_switch = 0;
564 :
565 2511926 : if ( dtx_vad == 0 )
566 : {
567 14109 : nB = SPAR_DTX_BANDS;
568 14109 : bands_bw = num_bands / nB;
569 :
570 14109 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
571 : }
572 2497817 : else if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
573 : {
574 181741 : bands_bw = 2;
575 181741 : nB = num_bands / bands_bw;
576 :
577 181741 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
578 : }
579 : else
580 : {
581 2316076 : nB = num_bands;
582 2316076 : bands_bw = 1;
583 : }
584 2511926 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
585 : {
586 575390 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
587 : {
588 1841248 : for ( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
589 : {
590 1380936 : pred_coeffs_re_local[i][b] = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
591 : }
592 : }
593 : }
594 :
595 2511926 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
596 : {
597 1658043 : for ( b = 0; b < num_bands * bands_bw; b++ )
598 : {
599 1473816 : mvr2r( hMdEnc->spar_md.band_coeffs[b].P_quant_re, P_quant_re_prior[b], FOA_CHANNELS - 1 );
600 : }
601 : }
602 :
603 2511926 : ivas_compute_spar_params( cov_real, dm_fv_re, 0, hMdEnc->mixer_mat, 0, nB, dtx_vad, num_ch, bands_bw, active_w, active_w_vlbr, &hMdEnc->spar_md_cfg, &hMdEnc->spar_md, Wscale, 0, dyn_active_w_flag );
604 :
605 2511926 : if ( dirac_mono_flag )
606 : {
607 : int16_t i_ts;
608 64 : int16_t num_md_sub_frames = 1;
609 :
610 64 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
611 64 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
612 :
613 128 : for ( i_ts = 0; i_ts < num_md_sub_frames; i_ts++ )
614 : {
615 832 : for ( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
616 : {
617 3072 : for ( j = 0; j < ndm + ndec - 1; j++ )
618 : {
619 2304 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].pred_re[j] = 0.0f;
620 : }
621 1536 : for ( j = 0; j < ndec; j++ )
622 : {
623 2304 : for ( k = 0; k < ndm - 1; k++ )
624 : {
625 1536 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].C_re[j][k] = 0.0f;
626 : }
627 : }
628 :
629 1536 : for ( j = 0; j < ndec; j++ )
630 : {
631 768 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].P_re[j] = 0.0f;
632 : }
633 : }
634 : }
635 : }
636 :
637 13526749 : for ( i = 0; i < num_ch; i++ )
638 : {
639 64215028 : for ( j = 0; j < num_ch; j++ )
640 : {
641 531250697 : for ( b = 0; b < num_bands; b++ )
642 : {
643 478050492 : hMdEnc->mixer_mat_local[i][j][b] = hMdEnc->mixer_mat[i][j][b];
644 : }
645 : }
646 : }
647 : #ifdef DEBUG_LBR_SBA
648 : float dirac_md_kbps = (float) ( hMetaData->nb_bits_tot ) * 50 / 1000;
649 : #endif
650 2511926 : code_strat = 0;
651 : #ifdef DEBUG_SBA_MD_DUMP
652 : ndec = -1;
653 : #endif
654 : #ifdef DEBUG_SPAR_MD_TARGET_TUNING
655 : for ( qsi = 0; qsi < 1; qsi++ )
656 : #else
657 2523413 : for ( qsi = 0; qsi < num_quant_strats; qsi++ )
658 : #endif
659 : {
660 : #ifdef SPAR_HOA_DBG
661 : fprintf( stdout, "qsi = %d\n", qsi );
662 : #endif
663 22722579 : for ( b = 0; b < num_bands; b++ )
664 : {
665 20199166 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
666 20199166 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
667 :
668 20199166 : if ( dtx_vad == 1 )
669 : {
670 20170948 : if ( ndm != num_ch )
671 : {
672 17242244 : ivas_quant_p_per_band( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b], &hMdEnc->spar_md_cfg.quant_strat[qsi], num_ch );
673 : }
674 20170948 : ivas_quant_pred_coeffs_per_band( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b], &hMdEnc->spar_md_cfg.quant_strat[qsi], num_ch );
675 20170948 : if ( active_w_vlbr )
676 : {
677 2963232 : for ( i = 0; i < 3; i++ )
678 : {
679 : int16_t i2;
680 2222424 : i2 = 0;
681 2222424 : switch ( i ) /* PRED (Y,Z,X) and DECD (Y,X,Z) coeffs are in different orders */
682 : {
683 740808 : case 0:
684 740808 : i2 = 0;
685 740808 : break;
686 740808 : case 1:
687 740808 : i2 = 2;
688 740808 : break;
689 740808 : case 2:
690 740808 : i2 = 1;
691 740808 : break;
692 : }
693 2222424 : if ( ( hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] == 0 ) && ( hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[i2] == 0 ) && ( hMdEnc->spar_md.band_coeffs[b].pred_re[i] != 0.0f ) && ( cov_real[i + 1][i + 1][b] != 0.0f ) )
694 : {
695 : /* bump up the Pred coeff */
696 : float PR_uq, PR_step;
697 : ivas_quant_strat_t qs;
698 92030 : qs = hMdEnc->spar_md_cfg.quant_strat[qsi];
699 92030 : PR_uq = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
700 92030 : PR_step = ( qs.PR.max - qs.PR.min ) / ( qs.PR.q_levels[0] - 1 );
701 :
702 : int16_t PR_sign;
703 92030 : PR_sign = ( PR_uq > 0 ) - ( PR_uq < 0 );
704 :
705 92030 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = PR_sign;
706 :
707 : /* deindex the modified coefficient */
708 92030 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = PR_sign * PR_step;
709 : }
710 : }
711 : }
712 : }
713 : else
714 : {
715 28218 : if ( ndm != num_ch )
716 : {
717 28218 : ivas_quant_p_per_band_dtx( hMdEnc->spar_md.band_coeffs[b].P_re, ndec, ndm, &hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[0], hMdEnc->spar_md.band_coeffs[b].P_quant_re, num_ch );
718 : }
719 :
720 112872 : for ( i = 0; i < num_ch - 1; i++ )
721 : {
722 84654 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
723 : }
724 28218 : ivas_spar_quant_pred_coeffs_dtx( &hMdEnc->spar_md, hMdEnc->spar_md.band_coeffs[b].pred_re, ndm, hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re, num_ch - 1, hMdEnc->spar_md.band_coeffs[b].pred_quant_re );
725 : }
726 : }
727 :
728 11060771 : for ( i = 0; i < num_ch - 1; i++ )
729 : {
730 80740284 : for ( b = 0; b < num_bands; b++ )
731 : {
732 72202926 : pred_coeffs_re[i][b] = Wscale[b] * hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i];
733 : }
734 : }
735 :
736 2523413 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
737 : {
738 575390 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
739 : {
740 1841248 : for ( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
741 : {
742 : /* Use the prediction coeffs computed based on DirAC MD to generate mixer matrix */
743 1380936 : pred_coeffs_re[i][b] = pred_coeffs_re_local[i][b];
744 1380936 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
745 1380936 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = 0;
746 : }
747 : }
748 : }
749 :
750 2523413 : ivas_create_fullr_dmx_mat( pred_coeffs_re, dm_fv_re, hMdEnc->mixer_mat, num_ch, 0, num_bands, active_w, &hMdEnc->spar_md_cfg );
751 :
752 22722579 : for ( b = 0; b < num_bands; b++ )
753 : {
754 20199166 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
755 20199166 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
756 :
757 112601258 : for ( i = 0; i < num_ch; i++ )
758 : {
759 92402092 : hMdEnc->mixer_mat[0][i][b] *= Wscale[b];
760 : }
761 :
762 20199166 : if ( ( ndm != num_ch ) && ( ndm != 1 ) )
763 : {
764 11270028 : ivas_calc_c_p_coeffs( &hMdEnc->spar_md, cov_real, 0, hMdEnc->mixer_mat, num_ch, ndm, b, dtx_vad, 0, dyn_active_w_flag );
765 :
766 11270028 : if ( dirac_mono_flag )
767 : {
768 512 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
769 512 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
770 1024 : for ( j = 0; j < ndec; j++ )
771 : {
772 1536 : for ( k = 0; k < ndm - 1; k++ )
773 : {
774 1024 : hMdEnc->spar_md.band_coeffs[b].C_re[j][k] = 0.0f;
775 : }
776 : }
777 : }
778 : #ifdef SPAR_HOA_DBG
779 : /*fprintf(stderr, "\n\n C coefficients: band %d\n", b);
780 :
781 : for (i = 0; i < num_ch - ndm; i++)
782 : {
783 : for (j = 0; j < ndm - 1; j++)
784 : {
785 : fprintf(stderr, "%f, ", hMdEnc->spar_md.band_coeffs[b].C_re[i][j]);
786 : }
787 : fprintf(stderr, "\n");
788 : }
789 : fprintf(stderr, "\n\n"); */
790 : #endif
791 :
792 11270028 : ivas_quant_c_per_band( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b],
793 11270028 : &hMdEnc->spar_md_cfg.quant_strat[qsi], ndec, ndm );
794 : }
795 : }
796 :
797 : /* band limit downmix matrix */
798 2523413 : ivas_band_limit_dmx_matrix( hMdEnc, num_ch, num_bands, bands_bw );
799 :
800 : /* band mixing */
801 2523413 : if ( bands_bw > 1 )
802 : {
803 199311 : ivas_band_mixing( hMdEnc, num_ch, num_bands, nchan_transport, num_bands_full );
804 : }
805 :
806 2523413 : if ( dtx_vad == 0 )
807 : {
808 14109 : ivas_write_parameter_bitstream_dtx( &hMdEnc->spar_md, hMetaData, hMdEnc->spar_md_cfg.num_dmx_chans_per_band, hMdEnc->spar_md_cfg.num_decorr_per_band, num_bands );
809 14109 : break;
810 : }
811 :
812 2509304 : ivas_select_next_strat( hMdEnc->spar_md_cfg.prior_strat, cs, dmx_switch, dtx_vad );
813 :
814 6548547 : for ( i = 0; i < MAX_CODING_STRATS; i++ )
815 : {
816 6050683 : strat = cs[i];
817 6050683 : if ( strat != NO_STRAT )
818 : {
819 6030517 : reset_indices_enc( &hMetaData_tmp, md_indices_allocated );
820 :
821 6030517 : ivas_write_spar_md_bitstream( hMdEnc, num_bands, bands_bw, &hMetaData_tmp, hEncoderConfig->ivas_total_brate, strat, qsi );
822 :
823 : /*write to main buffer if its a valid bitstream*/
824 6030517 : if ( hMetaData_tmp.nb_bits_tot > 0 )
825 : {
826 4889843 : if ( hMetaData->nb_bits_tot == bit_pos_start || hMetaData_tmp.nb_bits_tot < ( hMetaData->nb_bits_tot - bit_pos_start ) )
827 : {
828 3959147 : write_metadata_buffer( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start );
829 3959147 : code_strat = strat;
830 : }
831 :
832 4889843 : if ( hMetaData->nb_bits_tot - bit_pos_start + ( ( ( hEncoderConfig->ivas_total_brate == IVAS_256k ) && ( sba_order == SBA_FOA_ORDER ) ) ? 1 : 0 ) <= hMdEnc->spar_md_cfg.tgt_bits_per_blk )
833 : {
834 2011440 : packed_ok = 1;
835 2011440 : break;
836 : }
837 : }
838 : }
839 : }
840 :
841 2509304 : if ( packed_ok == 1 )
842 : {
843 2011440 : break;
844 : }
845 :
846 : /*only if valid bitstream was written to main buffer*/
847 497864 : if ( hMetaData->nb_bits_tot > bit_pos_start )
848 : {
849 486377 : if ( hMetaData->nb_bits_tot - bit_pos_start + ( ( ( hEncoderConfig->ivas_total_brate == IVAS_256k ) && ( sba_order == SBA_FOA_ORDER ) ) ? 1 : 0 ) <= hMdEnc->spar_md_cfg.max_bits_per_blk )
850 : {
851 486377 : packed_ok = 1;
852 486377 : break;
853 : }
854 : }
855 : }
856 :
857 : #ifdef DEBUGGING
858 : if ( dtx_vad == 1 )
859 : {
860 : assert( packed_ok == 1 );
861 : }
862 : if ( hEncoderConfig->ivas_total_brate >= IVAS_256k )
863 : {
864 : assert( qsi == 0 );
865 : }
866 : #endif
867 :
868 : /* Reuse mixer matrix values for unsent bands */
869 2511926 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
870 : {
871 916163 : for ( k = num_bands - 1; k >= 0; k-- )
872 : {
873 2205752 : for ( b = bands_bw - 1; b >= 0; b-- )
874 : {
875 1473816 : mvr2r( hMdEnc->spar_md.band_coeffs[k].P_quant_re, hMdEnc->spar_md.band_coeffs[bands_bw * k + b].P_quant_re, FOA_CHANNELS - 1 );
876 : }
877 : }
878 : }
879 :
880 2511926 : if ( ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) && ( code_strat > 3 ) )
881 : {
882 534465 : for ( b = 0; b < num_bands * bands_bw; b += 2 * bands_bw )
883 : {
884 356310 : if ( ( b == 0 ) && ( code_strat % 2 == 0 ) )
885 : {
886 90819 : b += 2;
887 : }
888 712620 : for ( i = 0; i < 1; i++ )
889 : {
890 1781550 : for ( j = 0; j < 4; j++ )
891 : {
892 1425240 : hMdEnc->mixer_mat[i][j][b] = prior_mixer[i][j][b];
893 1425240 : hMdEnc->mixer_mat[i][j][b + 1] = prior_mixer[i][j][b + 1];
894 : }
895 : }
896 :
897 356310 : mvr2r( P_quant_re_prior[b], hMdEnc->spar_md.band_coeffs[b].P_quant_re, FOA_CHANNELS - 1 );
898 356310 : mvr2r( P_quant_re_prior[b + 1], hMdEnc->spar_md.band_coeffs[b + 1].P_quant_re, FOA_CHANNELS - 1 );
899 : }
900 : }
901 : #ifdef DEBUG_LBR_SBA
902 : char f_name[100];
903 : int16_t nbands = 1;
904 : int16_t num_subframes = 1;
905 : int16_t num_elements = 6;
906 : int16_t num_block_group = 1;
907 : int16_t byte_size = sizeof( float );
908 :
909 : float sba_md_kbps = (float) hMetaData->nb_bits_tot * 50 / 1000;
910 : float spar_md_kbps = sba_md_kbps - dirac_md_kbps;
911 : float corebr_kbps = (float) hEncoderConfig->ivas_total_brate / 1000 - sba_md_kbps;
912 :
913 : sprintf( f_name, "SBA_MD_bitrate.bin" );
914 : ( frame == 0 ) ? dbgwrite( &nbands, sizeof( nbands ), 1, 1, f_name ) : false;
915 : ( frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
916 : ( frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
917 : ( frame == 0 ) ? dbgwrite( &num_block_group, sizeof( num_block_group ), 1, 1, f_name ) : false;
918 : ( frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
919 :
920 : for ( b = 0; b < nbands; b++ )
921 : {
922 : for ( int16_t sf = 0; sf < num_subframes; sf++ )
923 : {
924 : for ( int16_t bl = 0; bl < num_block_group; bl++ )
925 : {
926 : float fqsi = (float) qsi;
927 : float fcode = (float) code_strat;
928 :
929 : dbgwrite( &dirac_md_kbps, byte_size, 1, 1, f_name );
930 : dbgwrite( &spar_md_kbps, byte_size, 1, 1, f_name );
931 : dbgwrite( &sba_md_kbps, byte_size, 1, 1, f_name );
932 : dbgwrite( &fqsi, byte_size, 1, 1, f_name );
933 : dbgwrite( &fcode, byte_size, 1, 1, f_name );
934 : dbgwrite( &corebr_kbps, byte_size, 1, 1, f_name );
935 : // fprintf(stdout, "%f\t%f\t%f\t%d\t%d\n", dirac_md_kbps, spar_md_kbps, sba_md_kbps, qsi, code_strat );
936 : }
937 : }
938 : }
939 : #endif
940 : #ifdef SPAR_HOA_DBG
941 : /*if ( strat >= 4 )
942 : {
943 : for ( b = 0; b < nB; b++ )
944 : {
945 : b = 0;
946 : fprintf( stdout, "\n\nMETADATA PR: band %d, qsi %d\n\n", b, qsi );
947 : for ( i = 0; i < num_ch - 1; i++ )
948 : {
949 : fprintf( stdout, "i: %d -- %f\t %d\t %d\n", i, //hMdEnc->spar_md.band_coeffs[b].pred_re[i],
950 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i],
951 : hMdEnc->spar_md_prior.band_coeffs_idx[b].pred_index_re[i],
952 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] );
953 : }
954 : fprintf( stdout, "\n\n METADATA C: band %d\n\n", b );
955 : int16_t k = 0;
956 : for ( i = 0; i < ndec; i++ )
957 : {
958 : for ( j = 0; j < ( ndm - 1 ); j++ )
959 : {
960 : fprintf( stdout, "i: %d -- %f\t %d\t %d\n", i, // hMdEnc->spar_md.band_coeffs[b].C_re[i][j],
961 : hMdEnc->spar_md.band_coeffs[b].C_quant_re[i][j],
962 : hMdEnc->spar_md_prior.band_coeffs_idx[b].drct_index_re[k],
963 : hMdEnc->spar_md.band_coeffs_idx[b].drct_index_re[k] );
964 : k++;
965 : }
966 : }
967 : fprintf( stdout, "\n\n METADATA Pd: band %d\n\n", b );
968 : for ( i = 0; i < num_ch - ndm; i++ )
969 : {
970 : fprintf( stdout, "i: %d -- %f\t %d\t %d\n", i, //hMdEnc->spar_md.band_coeffs[b].P_re[i][i],
971 : hMdEnc->spar_md.band_coeffs[b].P_quant_re[i][i],
972 : hMdEnc->spar_md_prior.band_coeffs_idx[b].decd_index_re[i],
973 : hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[i] );
974 : }
975 : fprintf( stdout, "\n\n" );
976 : }
977 : }*/
978 : b = 0;
979 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
980 :
981 : fprintf( stdout, "\n\n Metadata PR (15x1), C(15x15), P(15x15): band %d\n", b );
982 : for ( i = 0; i < num_ch - 1; i++ )
983 : {
984 : fprintf( stdout, "i: %d -- %.2f\t|\t", i, hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] );
985 : if ( i < num_ch - ndm )
986 : {
987 : for ( j = 0; j < ndm - 1; j++ )
988 : {
989 : fprintf( stdout, "%.2f\t", hMdEnc->spar_md.band_coeffs[b].C_quant_re[i][j] );
990 : }
991 : fprintf( stdout, "|\t" );
992 : for ( j = 0; j < num_ch - ndm; j++ )
993 : {
994 : fprintf( stdout, "%.2f\t", hMdEnc->spar_md.band_coeffs[b].P_quant_re[j] );
995 : }
996 : }
997 : fprintf( stdout, "\n" );
998 : }
999 : fprintf( stdout, "\n" );
1000 : #endif
1001 : #ifdef DEBUG_SBA_MD_DUMP
1002 : {
1003 : char f_name[100];
1004 : int16_t n_bands = 1, num_subframes = 1, num_block_groups = 1, num_elements = 1, byte_size = sizeof( int16_t );
1005 : sprintf( f_name, "spar_qsi.bin" );
1006 : ( frame == 0 ) ? dbgwrite( &n_bands, sizeof( nB ), 1, 1, f_name ) : false;
1007 : ( frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1008 : ( frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1009 : ( frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1010 : ( frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1011 : dbgwrite( &qsi, sizeof( int16_t ), 1, 1, f_name );
1012 : sprintf( f_name, "spar_strat.bin" );
1013 : ( frame == 0 ) ? dbgwrite( &n_bands, sizeof( nB ), 1, 1, f_name ) : false;
1014 : ( frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1015 : ( frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1016 : ( frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1017 : ( frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1018 : dbgwrite( &strat, sizeof( int16_t ), 1, 1, f_name );
1019 : byte_size = sizeof( float );
1020 : for ( b = 0; b < nB; b++ )
1021 : {
1022 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
1023 :
1024 : sprintf( f_name, "spar_band_pred_coeffs.bin" );
1025 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1026 : num_elements = num_ch - 1;
1027 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1028 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1029 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1030 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1031 : for ( i = 0; i < num_ch - 1; i++ )
1032 : {
1033 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].pred_re[i], sizeof( float ), 1, 1, f_name );
1034 : }
1035 : sprintf( f_name, "spar_band_C_coeffs.bin" );
1036 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1037 : num_elements = ndec * ( ndm - 1 );
1038 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1039 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1040 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1041 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1042 : for ( i = 0; i < ndec; i++ )
1043 : {
1044 : for ( j = 0; j < ( ndm - 1 ); j++ )
1045 : {
1046 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].C_re[i][j], sizeof( float ), 1, 1, f_name );
1047 : }
1048 : }
1049 : sprintf( f_name, "spar_band_P_coeffs.bin" );
1050 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1051 : num_elements = num_ch - ndm;
1052 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1053 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1054 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1055 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1056 : for ( i = 0; i < num_ch - ndm; i++ )
1057 : {
1058 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].P_re[i], sizeof( float ), 1, 1, f_name );
1059 : }
1060 : sprintf( f_name, "spar_band_pred_coeffs_quant.bin" );
1061 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1062 : num_elements = num_ch - 1;
1063 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1064 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1065 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1066 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1067 : for ( i = 0; i < num_ch - 1; i++ )
1068 : {
1069 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i], sizeof( float ), 1, 1, f_name );
1070 : }
1071 : sprintf( f_name, "spar_band_C_coeffs_quant.bin" );
1072 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1073 : num_elements = ndec * ( ndm - 1 );
1074 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1075 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1076 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1077 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1078 : for ( i = 0; i < ndec; i++ )
1079 : {
1080 : for ( j = 0; j < ( ndm - 1 ); j++ )
1081 : {
1082 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].C_quant_re[i][j], sizeof( float ), 1, 1, f_name );
1083 : }
1084 : }
1085 : sprintf( f_name, "spar_band_P_coeffs_quant.bin" );
1086 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1087 : num_elements = num_ch - ndm;
1088 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1089 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1090 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1091 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1092 : for ( i = 0; i < num_ch - ndm; i++ )
1093 : {
1094 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].P_quant_re[i], sizeof( float ), 1, 1, f_name );
1095 : }
1096 : }
1097 : }
1098 : #endif
1099 : #ifdef DEBUG_SPAR_MD_TARGET_TUNING
1100 : int16_t md_bits = hMetaData->nb_bits_tot - bit_pos_start + ( ( ( hEncoderConfig->ivas_total_brate == IVAS_256k ) && ( sba_order == SBA_FOA_ORDER ) ) ? 1 : 0 );
1101 : FILE *fp = fopen( "spar_md_bitrate.txt", "a" );
1102 :
1103 : fprintf( fp, "%d\t %d \t %d\n", md_bits, qsi, code_strat );
1104 : fclose( fp );
1105 : #endif
1106 :
1107 2511926 : ivas_store_prior_coeffs( hMdEnc, num_bands, code_strat, dtx_vad, qsi );
1108 :
1109 2511926 : hMdEnc->spar_md.dtx_vad = dtx_vad;
1110 2511926 : hMdEnc->spar_md.num_bands = num_bands;
1111 :
1112 2511926 : free( ind_list_tmp );
1113 :
1114 2511926 : return IVAS_ERR_OK;
1115 : }
1116 :
1117 :
1118 : /*-----------------------------------------------------------------------------------------*
1119 : * Function ivas_band_mixer()
1120 : *
1121 : * band mixer
1122 : *-----------------------------------------------------------------------------------------*/
1123 :
1124 195850 : static void ivas_band_mixer(
1125 : float *cov_real[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
1126 : const int16_t num_ch,
1127 : int16_t *num_bands,
1128 : int16_t red_band_fact )
1129 : {
1130 : int16_t i, j, k, b, orig_band, rem_band;
1131 : float avg_cov;
1132 :
1133 195850 : orig_band = *num_bands;
1134 195850 : *num_bands /= red_band_fact;
1135 195850 : rem_band = orig_band - ( *num_bands * red_band_fact );
1136 :
1137 979250 : for ( i = 0; i < num_ch; i++ )
1138 : {
1139 3917000 : for ( j = 0; j < num_ch; j++ )
1140 : {
1141 12082912 : for ( k = 0; k < *num_bands - 1; k++ )
1142 : {
1143 8949312 : avg_cov = 0.0f;
1144 27299424 : for ( b = 0; b < red_band_fact; b++ )
1145 : {
1146 18350112 : avg_cov += cov_real[i][j][red_band_fact * k + b];
1147 : }
1148 8949312 : cov_real[i][j][k] = avg_cov;
1149 : }
1150 :
1151 3133600 : avg_cov = 0.0f;
1152 9852288 : for ( b = 0; b < red_band_fact + rem_band; b++ )
1153 : {
1154 6718688 : avg_cov += cov_real[i][j][red_band_fact * ( *num_bands - 1 ) + b];
1155 : }
1156 :
1157 3133600 : cov_real[i][j][*num_bands - 1] = avg_cov;
1158 : }
1159 : }
1160 :
1161 195850 : return;
1162 : }
1163 :
1164 :
1165 : /*-----------------------------------------------------------------------------------------*
1166 : * Function ivas_write_spar_md_bitstream()
1167 : *
1168 : * Write MD parameters into bitstream
1169 : *-----------------------------------------------------------------------------------------*/
1170 :
1171 6030517 : static void ivas_write_spar_md_bitstream(
1172 : ivas_spar_md_enc_state_t *hMdEnc,
1173 : const int16_t nB,
1174 : const int16_t bands_bw,
1175 : BSTR_ENC_HANDLE hMetaData,
1176 : const int32_t ivas_total_brate,
1177 : const int16_t strat,
1178 : const int16_t qsi )
1179 : {
1180 : int16_t no_ec, i;
1181 : int16_t do_diff[IVAS_MAX_NUM_BANDS];
1182 : int16_t entropy_coding_result;
1183 :
1184 6030517 : if ( strat == NO_STRAT )
1185 : {
1186 0 : return;
1187 : }
1188 :
1189 : /* write quant strat */
1190 6030517 : if ( ivas_total_brate >= BRATE_SPAR_Q_STRAT )
1191 : {
1192 628452 : push_next_indice( hMetaData, qsi >> 1, hMdEnc->spar_md_cfg.quant_strat_bits - 1 );
1193 : }
1194 : else
1195 : {
1196 5402065 : push_next_indice( hMetaData, qsi, hMdEnc->spar_md_cfg.quant_strat_bits );
1197 : }
1198 :
1199 6030517 : no_ec = 0;
1200 :
1201 6030517 : if ( ivas_total_brate < IVAS_24k4 )
1202 : {
1203 548559 : switch ( strat )
1204 : {
1205 185202 : case BASE:
1206 185202 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1207 185202 : break;
1208 185202 : case BASE_NOEC:
1209 185202 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1210 185202 : no_ec = 1;
1211 185202 : break;
1212 178155 : case FOUR_A:
1213 : case FOUR_C:
1214 : case FOUR_B:
1215 : case FOUR_D:
1216 178155 : push_next_indice( hMetaData, strat, SPAR_NUM_CODING_STRAT_BITS );
1217 178155 : break;
1218 : }
1219 : /* for LBR SBA 40MS MD never do time diff */
1220 2742795 : for ( i = 0; i < nB; i++ )
1221 : {
1222 2194236 : do_diff[i] = 0;
1223 : }
1224 : }
1225 : else
1226 : {
1227 5481958 : switch ( strat )
1228 : {
1229 2324102 : case BASE:
1230 2324102 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1231 21754242 : for ( i = 0; i < nB; i++ )
1232 : {
1233 19430140 : do_diff[i] = 0;
1234 : }
1235 2324102 : break;
1236 1612009 : case BASE_NOEC:
1237 1612009 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1238 14508081 : for ( i = 0; i < nB; i++ )
1239 : {
1240 12896072 : do_diff[i] = 0;
1241 : }
1242 1612009 : no_ec = 1;
1243 1612009 : break;
1244 426201 : case FOUR_A:
1245 426201 : push_next_indice( hMetaData, 4, SPAR_NUM_CODING_STRAT_BITS );
1246 3835809 : for ( i = 0; i < nB; i++ )
1247 : {
1248 3409608 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 0 );
1249 : }
1250 426201 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1251 426201 : break;
1252 390851 : case FOUR_B:
1253 390851 : push_next_indice( hMetaData, 5, SPAR_NUM_CODING_STRAT_BITS );
1254 3517659 : for ( i = 0; i < nB; i++ )
1255 : {
1256 3126808 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 1 );
1257 : }
1258 390851 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1259 390851 : break;
1260 371729 : case FOUR_C:
1261 371729 : push_next_indice( hMetaData, 6, SPAR_NUM_CODING_STRAT_BITS );
1262 3345561 : for ( i = 0; i < nB; i++ )
1263 : {
1264 2973832 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 2 );
1265 : }
1266 371729 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1267 371729 : break;
1268 357066 : case FOUR_D:
1269 357066 : push_next_indice( hMetaData, 7, SPAR_NUM_CODING_STRAT_BITS );
1270 3213594 : for ( i = 0; i < nB; i++ )
1271 : {
1272 2856528 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 3 );
1273 : }
1274 357066 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1275 357066 : break;
1276 : }
1277 6030517 : }
1278 :
1279 : #ifdef SPAR_HOA_DBG
1280 : if ( strat < 2 )
1281 : fprintf( stdout, "\n\n no_ec = %d, strat = %d\n", no_ec, strat - 1 );
1282 : else
1283 : fprintf( stdout, "\n\n no_ec = %d, strat = %d\n", no_ec, strat );
1284 : #endif
1285 6030517 : if ( no_ec == 1 )
1286 : {
1287 : entropy_coding_result =
1288 1797211 : ivas_get_huffman_coded_bs( hMdEnc, hMetaData, nB, qsi,
1289 : bands_bw );
1290 : }
1291 : else
1292 : {
1293 : entropy_coding_result =
1294 4233306 : ivas_get_arith_coded_bs( hMdEnc, hMetaData, do_diff, bands_bw, nB, qsi,
1295 : strat, ivas_total_brate );
1296 : }
1297 :
1298 6030517 : if ( entropy_coding_result < 0 )
1299 : {
1300 1140674 : hMetaData->nb_bits_tot = 0;
1301 : }
1302 :
1303 6030517 : return;
1304 : }
1305 :
1306 :
1307 : /*-----------------------------------------------------------------------------------------*
1308 : * Function ivas_get_huffman_coded_bs()
1309 : *
1310 : * Generate huffman coded bitstream
1311 : *-----------------------------------------------------------------------------------------*/
1312 1797211 : static int16_t ivas_get_huffman_coded_bs(
1313 : ivas_spar_md_enc_state_t *hMdEnc,
1314 : BSTR_ENC_HANDLE hMetaData,
1315 : const int16_t nB,
1316 : const int16_t qsi,
1317 : const int16_t bands_bw )
1318 : {
1319 : int16_t i, j;
1320 : int16_t pred_coeff_dim, pred_offset;
1321 :
1322 14586451 : for ( i = 0; i < nB; i++ )
1323 : {
1324 : int16_t code, len;
1325 : int16_t ndm, ndec;
1326 13522513 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i * bands_bw];
1327 13522513 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[i * bands_bw];
1328 :
1329 13522513 : pred_coeff_dim = ndm + ndec - 1;
1330 13522513 : pred_offset = 0;
1331 13522513 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1332 : {
1333 0 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1334 : {
1335 0 : pred_offset = DIRAC_TO_SPAR_HBR_PRED_CHS;
1336 : }
1337 : }
1338 :
1339 53473247 : for ( j = pred_offset; j < pred_coeff_dim; j++ )
1340 : {
1341 40310596 : ivas_huffman_encode( &hMdEnc->huff_coeffs.pred_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j], &code, &len );
1342 40310596 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1343 : {
1344 733273 : return -1;
1345 : }
1346 39950734 : push_next_indice( hMetaData, code, len );
1347 : }
1348 :
1349 27483852 : for ( j = 0; j < ndec * ( ndm - 1 ); j++ )
1350 : {
1351 14409007 : ivas_huffman_encode( &hMdEnc->huff_coeffs.drct_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].drct_index_re[j], &code, &len );
1352 14409007 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1353 : {
1354 87806 : return -1;
1355 : }
1356 14321201 : push_next_indice( hMetaData, code, len );
1357 : }
1358 :
1359 40638075 : for ( j = 0; j < ndec; j++ )
1360 : {
1361 27848835 : ivas_huffman_encode( &hMdEnc->huff_coeffs.decd_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].decd_index_re[j], &code, &len );
1362 27848835 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1363 : {
1364 285605 : return -1;
1365 : }
1366 27563230 : push_next_indice( hMetaData, code, len );
1367 : }
1368 : }
1369 :
1370 1063938 : return 0;
1371 : }
1372 :
1373 :
1374 : /*-----------------------------------------------------------------------------------------*
1375 : * Function ivas_get_arith_coded_bs()
1376 : *
1377 : * Generate arithmetic coded bitstream
1378 : *-----------------------------------------------------------------------------------------*/
1379 4233306 : static int16_t ivas_get_arith_coded_bs(
1380 : ivas_spar_md_enc_state_t *hMdEnc,
1381 : BSTR_ENC_HANDLE hMetaData,
1382 : const int16_t *pDo_diff,
1383 : const int16_t bands_bw,
1384 : const int16_t nB,
1385 : const int16_t qsi,
1386 : const int16_t strat,
1387 : const int32_t ivas_total_brate )
1388 : {
1389 : int16_t i, any_diff;
1390 : int16_t j;
1391 : ivas_cell_dim_t pred_cell_dims[IVAS_MAX_NUM_BANDS];
1392 : ivas_cell_dim_t drct_cell_dims[IVAS_MAX_NUM_BANDS];
1393 : ivas_cell_dim_t decd_cell_dims[IVAS_MAX_NUM_BANDS];
1394 : ivas_cell_dim_t decx_cell_dims[IVAS_MAX_NUM_BANDS];
1395 : int16_t symbol_arr_re[IVAS_MAX_INPUT_LEN];
1396 : int16_t symbol_arr_old_re[IVAS_MAX_INPUT_LEN];
1397 : int16_t arith_result;
1398 :
1399 37483650 : for ( i = 0; i < nB; i++ )
1400 : {
1401 : int16_t ndm, ndec;
1402 33250344 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[bands_bw * i];
1403 33250344 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[bands_bw * i];
1404 :
1405 33250344 : if ( ( ivas_total_brate < IVAS_24k4 ) && ( strat > 3 ) && ( ( ( i % 2 == 1 ) && ( strat % 2 == 0 ) ) || ( ( i % 2 == 0 ) && ( strat % 2 == 1 ) ) ) )
1406 : {
1407 356310 : pred_cell_dims[i].dim1 = 0;
1408 356310 : pred_cell_dims[i].dim2 = 0;
1409 356310 : drct_cell_dims[i].dim1 = 0;
1410 356310 : drct_cell_dims[i].dim2 = 0;
1411 356310 : decd_cell_dims[i].dim1 = 0;
1412 356310 : decd_cell_dims[i].dim2 = 0;
1413 356310 : decx_cell_dims[i].dim1 = 0;
1414 356310 : decx_cell_dims[i].dim2 = 0;
1415 : }
1416 : else
1417 : {
1418 32894034 : pred_cell_dims[i].dim1 = ndm + ndec - 1;
1419 32894034 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1420 : {
1421 1380936 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1422 : {
1423 460312 : pred_cell_dims[i].dim1 -= ( FOA_CHANNELS - 1 );
1424 : }
1425 : }
1426 32894034 : pred_cell_dims[i].dim2 = 1;
1427 32894034 : drct_cell_dims[i].dim1 = ndec;
1428 32894034 : drct_cell_dims[i].dim2 = ndm - 1;
1429 32894034 : decd_cell_dims[i].dim1 = ndec;
1430 32894034 : decd_cell_dims[i].dim2 = 1;
1431 32894034 : decx_cell_dims[i].dim1 = ( ndec * ( ndec - 1 ) ) >> 1;
1432 32894034 : decx_cell_dims[i].dim2 = 1;
1433 : }
1434 : }
1435 :
1436 4233306 : any_diff = 0;
1437 25507725 : for ( i = 0; i < nB; i++ )
1438 : {
1439 22820266 : if ( pDo_diff[i] != 0 )
1440 : {
1441 1545847 : any_diff = 1;
1442 1545847 : break;
1443 : }
1444 : }
1445 4233306 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1446 : {
1447 1496014 : for ( i = 0; i < nB; i++ )
1448 : {
1449 1380936 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1450 : {
1451 1869320 : for ( j = 0; j < pred_cell_dims[i].dim1; j++ )
1452 : {
1453 1409008 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] =
1454 1409008 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1455 :
1456 1409008 : if ( any_diff == 1 )
1457 : {
1458 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j] =
1459 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1460 : }
1461 : }
1462 : }
1463 : }
1464 : }
1465 4233306 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, pred_cell_dims, PRED_COEFF );
1466 :
1467 4233306 : if ( any_diff == 1 )
1468 : {
1469 1545847 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, nB, symbol_arr_old_re, pred_cell_dims, PRED_COEFF );
1470 : }
1471 :
1472 4233306 : arith_result = ivas_arith_encode_cmplx_cell_array( &hMdEnc->arith_coeffs.pred_arith_re[qsi], &hMdEnc->arith_coeffs.pred_arith_re_diff[qsi], pDo_diff, nB,
1473 4233306 : symbol_arr_re, symbol_arr_old_re, pred_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1474 4233306 : if ( arith_result < 0 )
1475 : {
1476 20982 : return -1;
1477 : }
1478 :
1479 4212324 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1480 : {
1481 1496014 : for ( i = 0; i < nB; i++ )
1482 : {
1483 1380936 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1484 : {
1485 1869320 : for ( j = pred_cell_dims[i].dim1 - 1; j >= 0; j-- )
1486 : {
1487 1409008 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS] =
1488 1409008 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j];
1489 : }
1490 1841248 : for ( j = 0; j < DIRAC_TO_SPAR_HBR_PRED_CHS; j++ )
1491 : {
1492 1380936 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] = 0;
1493 : }
1494 : }
1495 : }
1496 : }
1497 :
1498 4212324 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, drct_cell_dims, DRCT_COEFF );
1499 :
1500 4212324 : if ( any_diff == 1 )
1501 : {
1502 1545847 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, nB, symbol_arr_old_re, drct_cell_dims, DRCT_COEFF );
1503 : }
1504 :
1505 :
1506 4212324 : arith_result = ivas_arith_encode_cmplx_cell_array( &hMdEnc->arith_coeffs.drct_arith_re[qsi], &hMdEnc->arith_coeffs.drct_arith_re_diff[qsi], pDo_diff, nB,
1507 4212324 : symbol_arr_re, symbol_arr_old_re, drct_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1508 4212324 : if ( arith_result < 0 )
1509 : {
1510 146 : return -1;
1511 : }
1512 :
1513 4212178 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decd_cell_dims, DECD_COEFF );
1514 :
1515 4212178 : if ( any_diff == 1 )
1516 : {
1517 1545701 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, nB, symbol_arr_old_re, decd_cell_dims, DECD_COEFF );
1518 : }
1519 :
1520 4212178 : arith_result = ivas_arith_encode_cmplx_cell_array( &hMdEnc->arith_coeffs.decd_arith_re[qsi], &hMdEnc->arith_coeffs.decd_arith_re_diff[qsi], pDo_diff, nB,
1521 4212178 : symbol_arr_re, symbol_arr_old_re, decd_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1522 4212178 : if ( arith_result < 0 )
1523 : {
1524 386273 : return -1;
1525 : }
1526 :
1527 3825905 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decx_cell_dims, DECX_COEFF );
1528 :
1529 3825905 : if ( any_diff == 1 )
1530 : {
1531 1531985 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, nB, symbol_arr_old_re, decx_cell_dims, DECX_COEFF );
1532 : }
1533 :
1534 3825905 : return 0;
1535 : }
1536 :
1537 :
1538 : /*-----------------------------------------------------------------------------------------*
1539 : * Function ivas_select_next_strat()
1540 : *
1541 : * Select next strategy
1542 : *-----------------------------------------------------------------------------------------*/
1543 :
1544 2509304 : static void ivas_select_next_strat(
1545 : ivas_strats_t prior_strat,
1546 : ivas_strats_t cs[MAX_QUANT_STRATS],
1547 : const int16_t dmx_switch,
1548 : const int16_t dtx_vad )
1549 : {
1550 2509304 : cs[0] = BASE;
1551 2509304 : cs[1] = BASE_NOEC;
1552 2509304 : if ( dmx_switch == 0 && dtx_vad )
1553 : {
1554 2509304 : switch ( prior_strat )
1555 : {
1556 25874 : case START:
1557 25874 : cs[2] = NO_STRAT;
1558 25874 : break;
1559 754984 : case BASE:
1560 754984 : cs[2] = FOUR_A;
1561 754984 : break;
1562 0 : case BASE_DIFF:
1563 0 : cs[2] = FOUR_A;
1564 0 : break;
1565 56177 : case BASE_NOEC:
1566 56177 : cs[2] = FOUR_A;
1567 56177 : break;
1568 447681 : case FOUR_A:
1569 447681 : cs[2] = FOUR_B;
1570 447681 : break;
1571 423621 : case FOUR_B:
1572 423621 : cs[2] = FOUR_C;
1573 423621 : break;
1574 406204 : case FOUR_C:
1575 406204 : cs[2] = FOUR_D;
1576 406204 : break;
1577 394763 : case FOUR_D:
1578 394763 : cs[2] = FOUR_A;
1579 394763 : break;
1580 0 : default:
1581 0 : assert( !"bad value of prior_strat" );
1582 : }
1583 0 : }
1584 :
1585 2509304 : return;
1586 : }
1587 :
1588 :
1589 : /*-----------------------------------------------------------------------------------------*
1590 : * Function ivas_store_prior_coeffs()
1591 : *
1592 : * Store prior coeffs
1593 : *-----------------------------------------------------------------------------------------*/
1594 :
1595 2511926 : static void ivas_store_prior_coeffs(
1596 : ivas_spar_md_enc_state_t *hMdEnc,
1597 : const int16_t num_bands,
1598 : const int16_t strat,
1599 : const int16_t dtx_vad,
1600 : const int16_t qsi )
1601 : {
1602 : int16_t i, j, b;
1603 2511926 : if ( dtx_vad == 0 )
1604 : {
1605 14109 : hMdEnc->spar_md_cfg.prior_strat = START;
1606 : }
1607 : else
1608 : {
1609 2497817 : hMdEnc->spar_md_cfg.prior_strat = strat;
1610 : }
1611 :
1612 2511926 : hMdEnc->spar_md_cfg.prev_quant_idx = qsi;
1613 :
1614 22633040 : for ( i = 0; i < num_bands; i++ )
1615 : {
1616 20121114 : b = i;
1617 :
1618 221332254 : for ( j = 0; j < IVAS_SPAR_MAX_CH - 1; j++ )
1619 : {
1620 201211140 : hMdEnc->spar_md_prior.band_coeffs_idx[i].pred_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[j];
1621 201211140 : hMdEnc->spar_md_prior.band_coeffs_idx[i].decd_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[j];
1622 : }
1623 442664508 : for ( j = 0; j < IVAS_SPAR_MAX_C_COEFF; j++ )
1624 : {
1625 422543394 : hMdEnc->spar_md_prior.band_coeffs_idx[i].drct_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].drct_index_re[j];
1626 : }
1627 : }
1628 :
1629 2511926 : return;
1630 : }
1631 :
1632 :
1633 : /*-----------------------------------------------------------------------------------------*
1634 : * Function ivas_spar_quant_pred_coeffs_dtx()
1635 : *
1636 : * Calculate quantization pred coeffs
1637 : *-----------------------------------------------------------------------------------------*/
1638 :
1639 28218 : static void ivas_spar_quant_pred_coeffs_dtx(
1640 : ivas_spar_md_t *pSpar_md,
1641 : const float *pValues,
1642 : const int16_t ndm,
1643 : int16_t *pIndex,
1644 : const int16_t dim1,
1645 : float *pQuant )
1646 : {
1647 : int16_t i;
1648 : int16_t q_lvl;
1649 : float pr_min_max[2];
1650 :
1651 28218 : pr_min_max[0] = pSpar_md->min_max[0];
1652 28218 : pr_min_max[1] = pSpar_md->min_max[1];
1653 :
1654 112872 : for ( i = 0; i < dim1; i++ )
1655 : {
1656 84654 : q_lvl = dtx_pr_real_q_levels[ndm - 1][i];
1657 84654 : ivas_quantise_real_values( &pValues[i], q_lvl, pr_min_max[0], pr_min_max[1], &pIndex[i], &pQuant[i], 1 );
1658 : }
1659 :
1660 28218 : return;
1661 : }
1662 :
1663 :
1664 : /*-----------------------------------------------------------------------------------------*
1665 : * Function ivas_quant_p_per_band_dtx()
1666 : *
1667 : * Calculate quantization p
1668 : *-----------------------------------------------------------------------------------------*/
1669 :
1670 28218 : static void ivas_quant_p_per_band_dtx(
1671 : float *pP_mat,
1672 : const int16_t num_dec,
1673 : const int16_t num_dmx,
1674 : int16_t *ppIdx_pd,
1675 : float *pP_out,
1676 : const int16_t num_ch )
1677 : {
1678 : int16_t i;
1679 28218 : int16_t dim = num_ch - num_dmx;
1680 :
1681 28218 : if ( num_dec == num_ch - 1 )
1682 : {
1683 68616 : for ( i = 0; i < dim; i++ )
1684 : {
1685 51462 : if ( pP_mat[i] < pr_boost_range[1] && pP_mat[i] > pr_boost_range[0] )
1686 : {
1687 14698 : pP_mat[i] = pr_boost_range[1];
1688 : }
1689 : }
1690 : }
1691 :
1692 28218 : if ( dim != num_dec )
1693 : {
1694 0 : assert( !"Not Supported!" );
1695 : }
1696 :
1697 101808 : for ( i = 0; i < dim; i++ )
1698 : {
1699 73590 : ivas_quantise_real_values( &pP_mat[i], dtx_pd_real_q_levels[num_ch - num_dec - 1][i], dtx_pd_real_min_max[0], dtx_pd_real_min_max[1], &ppIdx_pd[i], &pP_out[i], 1 );
1700 : }
1701 :
1702 28218 : return;
1703 : }
1704 :
1705 : /*-----------------------------------------------------------------------------------------*
1706 : * Function ivas_write_parameter_bitstream_dtx()
1707 : *
1708 : * Write MD DTX parameters into bitstream
1709 : *-----------------------------------------------------------------------------------------*/
1710 :
1711 14109 : static void ivas_write_parameter_bitstream_dtx(
1712 : ivas_spar_md_t *pSpar_md,
1713 : BSTR_ENC_HANDLE hMetaData,
1714 : int16_t *num_dmx,
1715 : int16_t *num_dec,
1716 : const int16_t num_bands )
1717 : {
1718 : int16_t i, j;
1719 : float val;
1720 : int16_t idx;
1721 : float pr_min_max[2];
1722 : int16_t zero_pad_bits, sid_bits_len;
1723 : int16_t sba_spar_bitlen;
1724 :
1725 14109 : sid_bits_len = hMetaData->nb_bits_tot;
1726 14109 : pr_min_max[0] = pSpar_md->min_max[0];
1727 14109 : pr_min_max[1] = pSpar_md->min_max[1];
1728 :
1729 42327 : for ( i = 0; i < num_bands; i++ )
1730 : {
1731 28218 : int16_t ndm = num_dmx[i];
1732 28218 : int16_t ndec = num_dec[i];
1733 :
1734 112872 : for ( j = 0; j < FOA_CHANNELS - 1; j++ )
1735 : {
1736 : int16_t pr, pd;
1737 : int16_t pr_q_lvls, pd_q_lvls, pr_pd_bits;
1738 : int16_t pr_idx_1, pr_idx_2, pd_idx_1, pd_idx_2;
1739 : uint16_t value;
1740 :
1741 84654 : pr_idx_1 = pr_pr_idx_pairs[ndm - 1][j][0];
1742 84654 : pr_idx_2 = pr_pr_idx_pairs[ndm - 1][j][1];
1743 84654 : pd_idx_1 = pr_pd_idx_pairs[ndm - 1][j][0];
1744 84654 : pd_idx_2 = pr_pd_idx_pairs[ndm - 1][j][1];
1745 :
1746 84654 : if ( pr_idx_1 != 0 || pd_idx_1 != 0 || pr_idx_2 != 0 || pd_idx_2 != 0 )
1747 : {
1748 84654 : pr_q_lvls = dtx_pr_real_q_levels[ndm - 1][pd_idx_1 - 1];
1749 84654 : pr = pSpar_md->band_coeffs_idx[i].pred_index_re[pd_idx_1 - 1];
1750 :
1751 84654 : if ( ( j + 1 ) > ndec )
1752 : {
1753 11064 : pd_q_lvls = 1;
1754 11064 : pd = 0;
1755 : }
1756 : else
1757 : {
1758 73590 : pd_q_lvls = dtx_pd_real_q_levels[ndm - 1][pd_idx_2 - 1];
1759 73590 : pd = pSpar_md->band_coeffs_idx[i].decd_index_re[pd_idx_2 - 1];
1760 : }
1761 84654 : val = dtx_pd_real_min_max[0];
1762 84654 : ivas_quantise_real_values( &val, pd_q_lvls, dtx_pd_real_min_max[0], dtx_pd_real_min_max[1], &idx, &val, 1 );
1763 :
1764 84654 : pd -= idx;
1765 :
1766 84654 : val = pr_min_max[0];
1767 84654 : ivas_quantise_real_values( &val, pr_q_lvls, pr_min_max[0], pr_min_max[1], &idx, &val, 1 );
1768 :
1769 84654 : pr -= idx;
1770 84654 : pr_pd_bits = ivas_get_bits_to_encode( pd_q_lvls * pr_q_lvls );
1771 :
1772 84654 : value = (uint16_t) ( pr * pd_q_lvls + pd );
1773 :
1774 84654 : push_next_indice( hMetaData, value, pr_pd_bits );
1775 : }
1776 : }
1777 : }
1778 :
1779 14109 : sid_bits_len = hMetaData->nb_bits_tot - sid_bits_len;
1780 14109 : sba_spar_bitlen = ivas_sba_spar_sid_bitlen( num_dmx[0] );
1781 14109 : zero_pad_bits = sba_spar_bitlen - sid_bits_len;
1782 :
1783 14109 : assert( zero_pad_bits >= 0 );
1784 14109 : if ( num_dmx[0] == 2 )
1785 : {
1786 5532 : zero_pad_bits -= 1;
1787 : }
1788 :
1789 19641 : while ( zero_pad_bits > 0 )
1790 : {
1791 5532 : j = min( zero_pad_bits, 16 );
1792 5532 : push_next_indice( hMetaData, 0, j );
1793 5532 : zero_pad_bits -= j;
1794 : }
1795 :
1796 14109 : return;
1797 : }
1798 :
1799 :
1800 : /*-----------------------------------------------------------------------------------------*
1801 : * Function ivas_quant_pred_coeffs_per_band()
1802 : *
1803 : * Quantization of prediction coefficients
1804 : *-----------------------------------------------------------------------------------------*/
1805 :
1806 20170948 : static void ivas_quant_pred_coeffs_per_band(
1807 : ivas_band_coeffs_t *pband_coeffs,
1808 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1809 : ivas_quant_strat_t *pQs,
1810 : const int16_t num_ch )
1811 : {
1812 20170948 : ivas_quantise_real_values( pband_coeffs->pred_re, pQs->PR.q_levels[0], pQs->PR.min, pQs->PR.max, pBand_coeffs_idx->pred_index_re, pband_coeffs->pred_quant_re, ( num_ch - 1 ) );
1813 :
1814 20170948 : return;
1815 : }
1816 :
1817 :
1818 : /*-----------------------------------------------------------------------------------------*
1819 : * Function ivas_quant_c_per_band()
1820 : *
1821 : * Quantization of cross prediction c coeffs for each band
1822 : *-----------------------------------------------------------------------------------------*/
1823 :
1824 11270028 : static void ivas_quant_c_per_band(
1825 : ivas_band_coeffs_t *pband_coeffs,
1826 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1827 : ivas_quant_strat_t *pQs,
1828 : const int16_t ndec,
1829 : const int16_t ndm )
1830 : {
1831 : int16_t i;
1832 : int16_t j, k;
1833 : float C_re[IVAS_SPAR_MAX_C_COEFF];
1834 11270028 : k = 0;
1835 36738752 : for ( i = 0; i < ndec; i++ )
1836 : {
1837 77801120 : for ( j = 0; j < ndm - 1; j++ )
1838 : {
1839 52332396 : C_re[k] = pband_coeffs->C_re[i][j];
1840 52332396 : k++;
1841 : }
1842 : }
1843 11270028 : ivas_quantise_real_values( C_re, pQs->C.q_levels[0], pQs->C.min, pQs->C.max, pBand_coeffs_idx->drct_index_re, C_re, ndec * ( ndm - 1 ) );
1844 11270028 : k = 0;
1845 36738752 : for ( i = 0; i < ndec; i++ )
1846 : {
1847 77801120 : for ( j = 0; j < ndm - 1; j++ )
1848 : {
1849 52332396 : pband_coeffs->C_quant_re[i][j] = C_re[k];
1850 52332396 : k++;
1851 : }
1852 : }
1853 :
1854 11270028 : return;
1855 : }
1856 :
1857 :
1858 : /*-----------------------------------------------------------------------------------------*
1859 : * Function ivas_quant_p_per_band()
1860 : *
1861 : * Quantization of decorrelation p coeffs for each band
1862 : *-----------------------------------------------------------------------------------------*/
1863 :
1864 17242244 : static void ivas_quant_p_per_band(
1865 : ivas_band_coeffs_t *pband_coeffs,
1866 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1867 : ivas_quant_strat_t *pQs,
1868 : const int16_t num_ch )
1869 : {
1870 17242244 : ivas_quantise_real_values( pband_coeffs->P_re, pQs->P_r.q_levels[0], pQs->P_r.min, pQs->P_r.max, pBand_coeffs_idx->decd_index_re, pband_coeffs->P_quant_re, num_ch - 1 );
1871 :
1872 17242244 : return;
1873 : }
|
