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 1636 : 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 1636 : error = IVAS_ERR_OK;
112 :
113 1636 : 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 1636 : num_channels = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
119 :
120 1636 : 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 1636 : 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 9355 : for ( i = 0; i < num_channels; i++ )
129 : {
130 7719 : 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 49410 : for ( j = 0; j < num_channels; j++ )
135 : {
136 41691 : 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 1636 : 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 9355 : for ( i = 0; i < num_channels; i++ )
148 : {
149 7719 : 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 49410 : for ( j = 0; j < num_channels; j++ )
154 : {
155 41691 : 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 1636 : if ( ( error = ivas_spar_md_enc_init( hMdEnc, hEncoderConfig, sba_order ) ) != IVAS_ERR_OK )
163 : {
164 0 : return error;
165 : }
166 :
167 1636 : *hMdEnc_in = hMdEnc;
168 :
169 1636 : return error;
170 : }
171 :
172 :
173 : /*-------------------------------------------------------------------------
174 : * ivas_spar_md_enc_close()
175 : *
176 : * Deallocate SPAR MD encoder handle
177 : *------------------------------------------------------------------------*/
178 :
179 1636 : 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 1636 : if ( hMdEnc_in == NULL || *hMdEnc_in == NULL )
187 : {
188 0 : return;
189 : }
190 :
191 1636 : hMdEnc = *hMdEnc_in;
192 1636 : num_channels = hMdEnc->num_umx_ch;
193 :
194 1636 : if ( hMdEnc->spar_md.band_coeffs != NULL )
195 : {
196 1636 : free( hMdEnc->spar_md.band_coeffs );
197 1636 : hMdEnc->spar_md.band_coeffs = NULL;
198 : }
199 1636 : if ( hMdEnc->mixer_mat != NULL )
200 : {
201 9355 : for ( i = 0; i < num_channels; i++ )
202 : {
203 49410 : for ( j = 0; j < num_channels; j++ )
204 : {
205 41691 : free( hMdEnc->mixer_mat[i][j] );
206 : }
207 7719 : free( hMdEnc->mixer_mat[i] );
208 : }
209 1636 : free( hMdEnc->mixer_mat );
210 : }
211 :
212 1636 : if ( hMdEnc->mixer_mat_local != NULL )
213 : {
214 9355 : for ( i = 0; i < num_channels; i++ )
215 : {
216 :
217 49410 : for ( j = 0; j < num_channels; j++ )
218 : {
219 41691 : free( hMdEnc->mixer_mat_local[i][j] );
220 : }
221 7719 : free( hMdEnc->mixer_mat_local[i] );
222 : }
223 1636 : free( hMdEnc->mixer_mat_local );
224 : }
225 :
226 1636 : free( *hMdEnc_in );
227 1636 : *hMdEnc_in = NULL;
228 :
229 1636 : return;
230 : }
231 :
232 :
233 : /*-----------------------------------------------------------------------------------------*
234 : * Function ivas_spar_md_enc_init()
235 : *
236 : * SPAR MD encoder initialization
237 : *-----------------------------------------------------------------------------------------*/
238 :
239 1954 : 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 1954 : 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 1954 : num_channels = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
252 1954 : ivas_sba_get_spar_hoa_ch_ind( num_channels, hEncoderConfig->ivas_total_brate, hMdEnc->HOA_md_ind );
253 1954 : table_idx = ivas_get_spar_table_idx( hEncoderConfig->ivas_total_brate, sba_order, SPAR_CONFIG_BW, NULL, NULL );
254 :
255 1954 : hMdEnc->spar_md.prior_dyn_active_w_flag = 0;
256 :
257 : #ifndef DEBUG_AGC_ENCODER_CMD_OPTION
258 1954 : 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 1954 : 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 25402 : for ( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
267 : {
268 23448 : pFC[i] = ivas_fb_fcs_12band_1ms[i] * hEncoderConfig->input_Fs * 0.5f;
269 : }
270 :
271 1954 : 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 1954 : 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 1954 : ivas_spar_arith_coeffs_com_init( &hMdEnc->arith_coeffs, &hMdEnc->spar_md_cfg, table_idx, ENC );
279 1954 : ivas_spar_huff_coeffs_com_init( &hMdEnc->huff_coeffs, NULL, table_idx, ENC );
280 :
281 1954 : if ( hEncoderConfig->Opt_DTX_ON == 1 )
282 : {
283 : /* DTX quant init */
284 143 : PR_minmax[0] = hMdEnc->spar_md_cfg.quant_strat[0].PR.min;
285 143 : PR_minmax[1] = hMdEnc->spar_md_cfg.quant_strat[0].PR.max;
286 143 : ivas_spar_quant_dtx_init( &hMdEnc->spar_md, PR_minmax );
287 : }
288 :
289 1954 : hMdEnc->spar_md_cfg.prior_strat = START;
290 1954 : hMdEnc->spar_md_cfg.prev_quant_idx = -1;
291 :
292 10945 : for ( i = 0; i < num_channels; i++ )
293 : {
294 55770 : for ( j = 0; j < num_channels; j++ )
295 : {
296 608127 : for ( k = 0; k < IVAS_MAX_NUM_BANDS; k++ )
297 : {
298 561348 : hMdEnc->mixer_mat[i][j][k] = 0;
299 : }
300 : }
301 : }
302 :
303 1954 : ivas_clear_band_coeffs( hMdEnc->spar_md.band_coeffs, IVAS_MAX_NUM_BANDS );
304 1954 : ivas_clear_band_coeff_idx( hMdEnc->spar_md.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
305 1954 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
306 1954 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, IVAS_MAX_NUM_BANDS );
307 :
308 1954 : 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 1954 : 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 6363 : for ( i = 0; i < nchan_transport; i++ )
329 : {
330 4409 : if ( max_freq_per_chan != NULL )
331 : {
332 4409 : 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 1954 : hMdEnc->num_umx_ch = nchan_inp;
340 1954 : hMdEnc->num_decorr = nchan_inp - 1;
341 :
342 25402 : for ( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
343 : {
344 23448 : tmp_dmx_ch = 0;
345 76356 : for ( j = 0; j < nchan_transport; j++ )
346 : {
347 52908 : if ( pFC[i] < hMdEnc->spar_md_cfg.max_freq_per_chan[j] )
348 : {
349 52908 : tmp_dmx_ch += 1;
350 : }
351 : }
352 :
353 23448 : hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i] = tmp_dmx_ch;
354 23448 : hMdEnc->spar_md_cfg.num_decorr_per_band[i] = hMdEnc->num_umx_ch - tmp_dmx_ch;
355 : }
356 :
357 1954 : return;
358 : }
359 :
360 :
361 : /*-----------------------------------------------------------------------------------------*
362 : * Function ivas_band_limit_dmx_matrix()
363 : *
364 : * Band limit downmix matrix
365 : *-----------------------------------------------------------------------------------------*/
366 :
367 160553 : 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 1457983 : for ( b = 0; b < num_bands; b++ )
376 : {
377 1297430 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
378 :
379 4317504 : for ( i = ndm; i < num_ch; i++ )
380 : {
381 21806690 : for ( j = 0; j < num_ch; j++ )
382 : {
383 18786616 : hMdEnc->mixer_mat[i][j][b] = 0;
384 : }
385 : }
386 : }
387 :
388 160553 : return;
389 : }
390 :
391 :
392 : /*-----------------------------------------------------------------------------------------*
393 : * Function ivas_band_mixing()
394 : *
395 : * Band mixing downmix matrix
396 : *-----------------------------------------------------------------------------------------*/
397 :
398 16875 : 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 16875 : red_band_fact = upmixed_bands / num_bands;
409 :
410 35434 : for ( i = 0; i < nchan_transport; i++ )
411 : {
412 92795 : for ( j = 0; j < num_ch; j++ )
413 : {
414 327092 : for ( k = num_bands - 1; k >= 0; k-- )
415 : {
416 846744 : for ( b = red_band_fact - 1; b >= 0; b-- )
417 : {
418 593888 : hMdEnc->mixer_mat[i][j][red_band_fact * k + b] = hMdEnc->mixer_mat[i][j][k];
419 : }
420 : }
421 74236 : 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 16875 : return;
428 : }
429 :
430 :
431 : /*-----------------------------------------------------------------------------------------*
432 : * Function write_metadata_buffer()
433 : *
434 : *
435 : *-----------------------------------------------------------------------------------------*/
436 :
437 233535 : 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 233535 : if ( hMetaData->nb_bits_tot > 0 )
446 : {
447 233535 : restore_metadata_buffer( hMetaData, next_ind_start, bit_pos_start );
448 : }
449 :
450 37894885 : for ( i = 0; i < hMetaData_tmp->nb_ind_tot; i++ )
451 : {
452 37661350 : push_next_indice( hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
453 : }
454 :
455 233535 : return;
456 : }
457 :
458 :
459 : /*-----------------------------------------------------------------------------------------*
460 : * Function ivas_spar_md_enc_process()
461 : *
462 : * SPAR FoA Meta Data generation process
463 : *-----------------------------------------------------------------------------------------*/
464 :
465 159500 : ivas_error ivas_spar_md_enc_process(
466 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
467 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
468 : float *cov_real[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
469 : float *cov_dtx_real[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
470 : BSTR_ENC_HANDLE hMetaData, /* i/o: MetaData handle */
471 : const int16_t dtx_vad,
472 : const int16_t nchan_inp,
473 : const int16_t sba_order, /* i : Ambisonic (SBA) order */
474 : float *prior_mixer[IVAS_MAX_FB_MIXER_OUT_CH][IVAS_MAX_SPAR_FB_MIXER_IN_CH], /* i : prior mixer_matrix */
475 : const int16_t dyn_active_w_flag, /* i : flag to indicate dynamic active W */
476 : const int16_t dirac_mono_flag /* i : flag to indicate mono only mode in SBA */
477 : )
478 : {
479 : float pred_coeffs_re[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
480 : float dm_fv_re[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
481 : int16_t i, j, b, qsi, ndm, ndec, num_ch, num_quant_strats;
482 : float pred_coeffs_re_local[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
483 : int16_t k, bwidth, num_bands, num_bands_full, num_bands_bw;
484 : int16_t active_w, nchan_transport, dmx_switch, strat;
485 159500 : int16_t nB, bands_bw, packed_ok = 0;
486 : ivas_strats_t cs[MAX_CODING_STRATS];
487 : int16_t code_strat;
488 : int16_t bit_pos_start, next_ind_start;
489 : BSTR_ENC_DATA hMetaData_tmp;
490 : Indice *ind_list_tmp;
491 : int16_t md_indices_allocated;
492 : int16_t max_num_indices_tmp;
493 : float Wscale[IVAS_MAX_NUM_BANDS];
494 : float P_quant_re_prior[SPAR_DIRAC_SPLIT_START_BAND][FOA_CHANNELS - 1];
495 :
496 : /*extra 16 bits for arithmetic coder as overshoot check is after a symbol is written*/
497 159500 : md_indices_allocated = hMdEnc->spar_md_cfg.max_bits_per_blk + IVAS_SPAR_ARITH_OVERSHOOT_BITS;
498 159500 : if ( ( ind_list_tmp = (Indice *) malloc( sizeof( Indice ) * md_indices_allocated ) ) == NULL )
499 : {
500 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD encoder indices" );
501 : }
502 :
503 159500 : num_quant_strats = hMdEnc->spar_md_cfg.num_quant_strats;
504 159500 : num_ch = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
505 159500 : active_w = ( hMdEnc->spar_md_cfg.active_w == 1 ) || ( dyn_active_w_flag == 1 );
506 159500 : nchan_transport = hMdEnc->spar_md_cfg.nchan_transport;
507 :
508 159500 : bwidth = ivas_get_bw_idx_from_sample_rate( hEncoderConfig->input_Fs );
509 159500 : bwidth = min( bwidth, hEncoderConfig->max_bwidth );
510 : int16_t active_w_vlbr;
511 159500 : active_w_vlbr = ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) ? 1 : 0;
512 159500 : num_bands = ivas_get_num_bands_from_bw_idx( SPAR_CONFIG_BW );
513 159500 : if ( hMdEnc->spar_hoa_md_flag == 0 )
514 : {
515 137460 : num_bands = min( num_bands, SPAR_DIRAC_SPLIT_START_BAND );
516 : }
517 159500 : num_bands_full = num_bands;
518 159500 : num_bands_bw = ivas_get_num_bands_from_bw_idx( bwidth );
519 :
520 159500 : if ( dtx_vad == 0 )
521 : {
522 19135 : for ( i = 0; i < nchan_inp; i++ )
523 : {
524 76540 : for ( j = 0; j < nchan_inp; j++ )
525 : {
526 61232 : cov_real[i][j] = cov_dtx_real[i][j];
527 : }
528 : }
529 : }
530 :
531 899700 : for ( i = 0; i < nchan_inp; i++ )
532 : {
533 4668660 : for ( j = 0; j < nchan_inp; j++ )
534 : {
535 4638420 : for ( k = num_bands_bw; k < IVAS_MAX_NUM_BANDS; k++ )
536 : {
537 709960 : cov_real[i][j][k] = 0;
538 : }
539 : }
540 : }
541 :
542 159500 : if ( hEncoderConfig->ivas_total_brate == BRATE_SPAR_Q_STRAT && sba_order == SBA_FOA_ORDER )
543 : {
544 : /* make sure that qsi is always 0 (temporary bits are '00') */
545 11620 : num_quant_strats = 1;
546 : }
547 :
548 159500 : hMetaData_tmp.ind_list = ind_list_tmp;
549 159500 : hMetaData_tmp.nb_bits_tot = 0;
550 159500 : max_num_indices_tmp = MAX_BITS_METADATA;
551 159500 : hMetaData_tmp.ivas_max_num_indices = &max_num_indices_tmp;
552 159500 : hMetaData_tmp.ivas_ind_list_zero = (Indice **) ( &hMetaData_tmp.ind_list );
553 159500 : hMetaData_tmp.st_ivas = NULL;
554 :
555 : /* Save state of metadata bitstream buffer */
556 159500 : bit_pos_start = hMetaData->nb_bits_tot;
557 159500 : next_ind_start = hMetaData->nb_ind_tot;
558 :
559 159500 : dmx_switch = 0;
560 :
561 159500 : if ( dtx_vad == 0 )
562 : {
563 3827 : nB = SPAR_DTX_BANDS;
564 3827 : bands_bw = num_bands / nB;
565 :
566 3827 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
567 : }
568 155673 : else if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
569 : {
570 12661 : bands_bw = 2;
571 12661 : nB = num_bands / bands_bw;
572 :
573 12661 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
574 : }
575 : else
576 : {
577 143012 : nB = num_bands;
578 143012 : bands_bw = 1;
579 : }
580 159500 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
581 : {
582 60500 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
583 : {
584 193600 : for ( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
585 : {
586 145200 : pred_coeffs_re_local[i][b] = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
587 : }
588 : }
589 : }
590 :
591 159500 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
592 : {
593 121977 : for ( b = 0; b < num_bands * bands_bw; b++ )
594 : {
595 108424 : mvr2r( hMdEnc->spar_md.band_coeffs[b].P_quant_re, P_quant_re_prior[b], FOA_CHANNELS - 1 );
596 : }
597 : }
598 :
599 159500 : 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 );
600 :
601 159500 : if ( dirac_mono_flag )
602 : {
603 : int16_t i_ts;
604 0 : int16_t num_md_sub_frames = 1;
605 :
606 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
607 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
608 :
609 0 : for ( i_ts = 0; i_ts < num_md_sub_frames; i_ts++ )
610 : {
611 0 : for ( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
612 : {
613 0 : for ( j = 0; j < ndm + ndec - 1; j++ )
614 : {
615 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].pred_re[j] = 0.0f;
616 : }
617 0 : for ( j = 0; j < ndec; j++ )
618 : {
619 0 : for ( k = 0; k < ndm - 1; k++ )
620 : {
621 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].C_re[j][k] = 0.0f;
622 : }
623 : }
624 :
625 0 : for ( j = 0; j < ndec; j++ )
626 : {
627 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].P_re[j] = 0.0f;
628 : }
629 : }
630 : }
631 : }
632 :
633 899700 : for ( i = 0; i < num_ch; i++ )
634 : {
635 4668660 : for ( j = 0; j < num_ch; j++ )
636 : {
637 41094844 : for ( b = 0; b < num_bands; b++ )
638 : {
639 37166384 : hMdEnc->mixer_mat_local[i][j][b] = hMdEnc->mixer_mat[i][j][b];
640 : }
641 : }
642 : }
643 : #ifdef DEBUG_LBR_SBA
644 : float dirac_md_kbps = (float) ( hMetaData->nb_bits_tot ) * 50 / 1000;
645 : #endif
646 159500 : code_strat = 0;
647 : #ifdef DEBUG_SBA_MD_DUMP
648 : ndec = -1;
649 : #endif
650 : #ifdef DEBUG_SPAR_MD_TARGET_TUNING
651 : for ( qsi = 0; qsi < 1; qsi++ )
652 : #else
653 160553 : for ( qsi = 0; qsi < num_quant_strats; qsi++ )
654 : #endif
655 : {
656 : #ifdef SPAR_HOA_DBG
657 : fprintf( stdout, "qsi = %d\n", qsi );
658 : #endif
659 1457983 : for ( b = 0; b < num_bands; b++ )
660 : {
661 1297430 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
662 1297430 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
663 :
664 1297430 : if ( dtx_vad == 1 )
665 : {
666 1289776 : if ( ndm != num_ch )
667 : {
668 1136736 : 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 );
669 : }
670 1289776 : 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 );
671 1289776 : if ( active_w_vlbr )
672 : {
673 208768 : for ( i = 0; i < 3; i++ )
674 : {
675 : int16_t i2;
676 156576 : i2 = 0;
677 156576 : switch ( i ) /* PRED (Y,Z,X) and DECD (Y,X,Z) coeffs are in different orders */
678 : {
679 52192 : case 0:
680 52192 : i2 = 0;
681 52192 : break;
682 52192 : case 1:
683 52192 : i2 = 2;
684 52192 : break;
685 52192 : case 2:
686 52192 : i2 = 1;
687 52192 : break;
688 : }
689 156576 : 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 ) )
690 : {
691 : /* bump up the Pred coeff */
692 : float PR_uq, PR_step;
693 : ivas_quant_strat_t qs;
694 3094 : qs = hMdEnc->spar_md_cfg.quant_strat[qsi];
695 3094 : PR_uq = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
696 3094 : PR_step = ( qs.PR.max - qs.PR.min ) / ( qs.PR.q_levels[0] - 1 );
697 :
698 : int16_t PR_sign;
699 3094 : PR_sign = ( PR_uq > 0 ) - ( PR_uq < 0 );
700 :
701 3094 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = PR_sign;
702 :
703 : /* deindex the modified coefficient */
704 3094 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = PR_sign * PR_step;
705 : }
706 : }
707 : }
708 : }
709 : else
710 : {
711 7654 : if ( ndm != num_ch )
712 : {
713 7654 : 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 );
714 : }
715 :
716 30616 : for ( i = 0; i < num_ch - 1; i++ )
717 : {
718 22962 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
719 : }
720 7654 : 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 );
721 : }
722 : }
723 :
724 744412 : for ( i = 0; i < num_ch - 1; i++ )
725 : {
726 5702549 : for ( b = 0; b < num_bands; b++ )
727 : {
728 5118690 : pred_coeffs_re[i][b] = Wscale[b] * hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i];
729 : }
730 : }
731 :
732 160553 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
733 : {
734 60500 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
735 : {
736 193600 : for ( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
737 : {
738 : /* Use the prediction coeffs computed based on DirAC MD to generate mixer matrix */
739 145200 : pred_coeffs_re[i][b] = pred_coeffs_re_local[i][b];
740 145200 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
741 145200 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = 0;
742 : }
743 : }
744 : }
745 :
746 160553 : 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 );
747 :
748 1457983 : for ( b = 0; b < num_bands; b++ )
749 : {
750 1297430 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
751 1297430 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
752 :
753 7713550 : for ( i = 0; i < num_ch; i++ )
754 : {
755 6416120 : hMdEnc->mixer_mat[0][i][b] *= Wscale[b];
756 : }
757 :
758 1297430 : if ( ( ndm != num_ch ) && ( ndm != 1 ) )
759 : {
760 848624 : 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 );
761 :
762 848624 : if ( dirac_mono_flag )
763 : {
764 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
765 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
766 0 : for ( j = 0; j < ndec; j++ )
767 : {
768 0 : for ( k = 0; k < ndm - 1; k++ )
769 : {
770 0 : hMdEnc->spar_md.band_coeffs[b].C_re[j][k] = 0.0f;
771 : }
772 : }
773 : }
774 : #ifdef SPAR_HOA_DBG
775 : /*fprintf(stderr, "\n\n C coefficients: band %d\n", b);
776 :
777 : for (i = 0; i < num_ch - ndm; i++)
778 : {
779 : for (j = 0; j < ndm - 1; j++)
780 : {
781 : fprintf(stderr, "%f, ", hMdEnc->spar_md.band_coeffs[b].C_re[i][j]);
782 : }
783 : fprintf(stderr, "\n");
784 : }
785 : fprintf(stderr, "\n\n"); */
786 : #endif
787 :
788 848624 : ivas_quant_c_per_band( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b],
789 848624 : &hMdEnc->spar_md_cfg.quant_strat[qsi], ndec, ndm );
790 : }
791 : }
792 :
793 : /* band limit downmix matrix */
794 160553 : ivas_band_limit_dmx_matrix( hMdEnc, num_ch, num_bands, bands_bw );
795 :
796 : /* band mixing */
797 160553 : if ( bands_bw > 1 )
798 : {
799 16875 : ivas_band_mixing( hMdEnc, num_ch, num_bands, nchan_transport, num_bands_full );
800 : }
801 :
802 160553 : if ( dtx_vad == 0 )
803 : {
804 3827 : 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 );
805 3827 : break;
806 : }
807 :
808 156726 : ivas_select_next_strat( hMdEnc->spar_md_cfg.prior_strat, cs, dmx_switch, dtx_vad );
809 :
810 391736 : for ( i = 0; i < MAX_CODING_STRATS; i++ )
811 : {
812 357419 : strat = cs[i];
813 357419 : if ( strat != NO_STRAT )
814 : {
815 355397 : reset_indices_enc( &hMetaData_tmp, md_indices_allocated );
816 :
817 355397 : ivas_write_spar_md_bitstream( hMdEnc, num_bands, bands_bw, &hMetaData_tmp, hEncoderConfig->ivas_total_brate, strat, qsi );
818 :
819 : /*write to main buffer if its a valid bitstream*/
820 355397 : if ( hMetaData_tmp.nb_bits_tot > 0 )
821 : {
822 285486 : if ( hMetaData->nb_bits_tot == bit_pos_start || hMetaData_tmp.nb_bits_tot < ( hMetaData->nb_bits_tot - bit_pos_start ) )
823 : {
824 233535 : write_metadata_buffer( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start );
825 233535 : code_strat = strat;
826 : }
827 :
828 285486 : 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 )
829 : {
830 122409 : packed_ok = 1;
831 122409 : break;
832 : }
833 : }
834 : }
835 : }
836 :
837 156726 : if ( packed_ok == 1 )
838 : {
839 122409 : break;
840 : }
841 :
842 : /*only if valid bitstream was written to main buffer*/
843 34317 : if ( hMetaData->nb_bits_tot > bit_pos_start )
844 : {
845 33264 : 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 )
846 : {
847 33264 : packed_ok = 1;
848 33264 : break;
849 : }
850 : }
851 : }
852 :
853 : #ifdef DEBUGGING
854 : if ( dtx_vad == 1 )
855 : {
856 : assert( packed_ok == 1 );
857 : }
858 : if ( hEncoderConfig->ivas_total_brate >= IVAS_256k )
859 : {
860 : assert( qsi == 0 );
861 : }
862 : #endif
863 :
864 : /* Reuse mixer matrix values for unsent bands */
865 159500 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
866 : {
867 65981 : for ( k = num_bands - 1; k >= 0; k-- )
868 : {
869 160852 : for ( b = bands_bw - 1; b >= 0; b-- )
870 : {
871 108424 : 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 );
872 : }
873 : }
874 : }
875 :
876 159500 : if ( ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) && ( code_strat > 3 ) )
877 : {
878 36729 : for ( b = 0; b < num_bands * bands_bw; b += 2 * bands_bw )
879 : {
880 24486 : if ( ( b == 0 ) && ( code_strat % 2 == 0 ) )
881 : {
882 6323 : b += 2;
883 : }
884 48972 : for ( i = 0; i < 1; i++ )
885 : {
886 122430 : for ( j = 0; j < 4; j++ )
887 : {
888 97944 : hMdEnc->mixer_mat[i][j][b] = prior_mixer[i][j][b];
889 97944 : hMdEnc->mixer_mat[i][j][b + 1] = prior_mixer[i][j][b + 1];
890 : }
891 : }
892 :
893 24486 : mvr2r( P_quant_re_prior[b], hMdEnc->spar_md.band_coeffs[b].P_quant_re, FOA_CHANNELS - 1 );
894 24486 : mvr2r( P_quant_re_prior[b + 1], hMdEnc->spar_md.band_coeffs[b + 1].P_quant_re, FOA_CHANNELS - 1 );
895 : }
896 : }
897 : #ifdef DEBUG_LBR_SBA
898 : char f_name[100];
899 : int16_t nbands = 1;
900 : int16_t num_subframes = 1;
901 : int16_t num_elements = 6;
902 : int16_t num_block_group = 1;
903 : int16_t byte_size = sizeof( float );
904 :
905 : float sba_md_kbps = (float) hMetaData->nb_bits_tot * 50 / 1000;
906 : float spar_md_kbps = sba_md_kbps - dirac_md_kbps;
907 : float corebr_kbps = (float) hEncoderConfig->ivas_total_brate / 1000 - sba_md_kbps;
908 :
909 : sprintf( f_name, "SBA_MD_bitrate.bin" );
910 : ( frame == 0 ) ? dbgwrite( &nbands, sizeof( nbands ), 1, 1, f_name ) : false;
911 : ( frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
912 : ( frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
913 : ( frame == 0 ) ? dbgwrite( &num_block_group, sizeof( num_block_group ), 1, 1, f_name ) : false;
914 : ( frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
915 :
916 : for ( b = 0; b < nbands; b++ )
917 : {
918 : for ( int16_t sf = 0; sf < num_subframes; sf++ )
919 : {
920 : for ( int16_t bl = 0; bl < num_block_group; bl++ )
921 : {
922 : float fqsi = (float) qsi;
923 : float fcode = (float) code_strat;
924 :
925 : dbgwrite( &dirac_md_kbps, byte_size, 1, 1, f_name );
926 : dbgwrite( &spar_md_kbps, byte_size, 1, 1, f_name );
927 : dbgwrite( &sba_md_kbps, byte_size, 1, 1, f_name );
928 : dbgwrite( &fqsi, byte_size, 1, 1, f_name );
929 : dbgwrite( &fcode, byte_size, 1, 1, f_name );
930 : dbgwrite( &corebr_kbps, byte_size, 1, 1, f_name );
931 : // fprintf(stdout, "%f\t%f\t%f\t%d\t%d\n", dirac_md_kbps, spar_md_kbps, sba_md_kbps, qsi, code_strat );
932 : }
933 : }
934 : }
935 : #endif
936 : #ifdef SPAR_HOA_DBG
937 : /*if ( strat >= 4 )
938 : {
939 : for ( b = 0; b < nB; b++ )
940 : {
941 : b = 0;
942 : fprintf( stdout, "\n\nMETADATA PR: band %d, qsi %d\n\n", b, qsi );
943 : for ( i = 0; i < num_ch - 1; i++ )
944 : {
945 : fprintf( stdout, "i: %d -- %f\t %d\t %d\n", i, //hMdEnc->spar_md.band_coeffs[b].pred_re[i],
946 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i],
947 : hMdEnc->spar_md_prior.band_coeffs_idx[b].pred_index_re[i],
948 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] );
949 : }
950 : fprintf( stdout, "\n\n METADATA C: band %d\n\n", b );
951 : int16_t k = 0;
952 : for ( i = 0; i < ndec; i++ )
953 : {
954 : for ( j = 0; j < ( ndm - 1 ); j++ )
955 : {
956 : fprintf( stdout, "i: %d -- %f\t %d\t %d\n", i, // hMdEnc->spar_md.band_coeffs[b].C_re[i][j],
957 : hMdEnc->spar_md.band_coeffs[b].C_quant_re[i][j],
958 : hMdEnc->spar_md_prior.band_coeffs_idx[b].drct_index_re[k],
959 : hMdEnc->spar_md.band_coeffs_idx[b].drct_index_re[k] );
960 : k++;
961 : }
962 : }
963 : fprintf( stdout, "\n\n METADATA Pd: band %d\n\n", b );
964 : for ( i = 0; i < num_ch - ndm; i++ )
965 : {
966 : fprintf( stdout, "i: %d -- %f\t %d\t %d\n", i, //hMdEnc->spar_md.band_coeffs[b].P_re[i][i],
967 : hMdEnc->spar_md.band_coeffs[b].P_quant_re[i][i],
968 : hMdEnc->spar_md_prior.band_coeffs_idx[b].decd_index_re[i],
969 : hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[i] );
970 : }
971 : fprintf( stdout, "\n\n" );
972 : }
973 : }*/
974 : b = 0;
975 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
976 :
977 : fprintf( stdout, "\n\n Metadata PR (15x1), C(15x15), P(15x15): band %d\n", b );
978 : for ( i = 0; i < num_ch - 1; i++ )
979 : {
980 : fprintf( stdout, "i: %d -- %.2f\t|\t", i, hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] );
981 : if ( i < num_ch - ndm )
982 : {
983 : for ( j = 0; j < ndm - 1; j++ )
984 : {
985 : fprintf( stdout, "%.2f\t", hMdEnc->spar_md.band_coeffs[b].C_quant_re[i][j] );
986 : }
987 : fprintf( stdout, "|\t" );
988 : for ( j = 0; j < num_ch - ndm; j++ )
989 : {
990 : fprintf( stdout, "%.2f\t", hMdEnc->spar_md.band_coeffs[b].P_quant_re[j] );
991 : }
992 : }
993 : fprintf( stdout, "\n" );
994 : }
995 : fprintf( stdout, "\n" );
996 : #endif
997 : #ifdef DEBUG_SBA_MD_DUMP
998 : {
999 : char f_name[100];
1000 : int16_t n_bands = 1, num_subframes = 1, num_block_groups = 1, num_elements = 1, byte_size = sizeof( int16_t );
1001 : sprintf( f_name, "spar_qsi.bin" );
1002 : ( frame == 0 ) ? dbgwrite( &n_bands, sizeof( nB ), 1, 1, f_name ) : false;
1003 : ( frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1004 : ( frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1005 : ( frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1006 : ( frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1007 : dbgwrite( &qsi, sizeof( int16_t ), 1, 1, f_name );
1008 : sprintf( f_name, "spar_strat.bin" );
1009 : ( frame == 0 ) ? dbgwrite( &n_bands, sizeof( nB ), 1, 1, f_name ) : false;
1010 : ( frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1011 : ( frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1012 : ( frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1013 : ( frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1014 : dbgwrite( &strat, sizeof( int16_t ), 1, 1, f_name );
1015 : byte_size = sizeof( float );
1016 : for ( b = 0; b < nB; b++ )
1017 : {
1018 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
1019 :
1020 : sprintf( f_name, "spar_band_pred_coeffs.bin" );
1021 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1022 : num_elements = num_ch - 1;
1023 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1024 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1025 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1026 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1027 : for ( i = 0; i < num_ch - 1; i++ )
1028 : {
1029 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].pred_re[i], sizeof( float ), 1, 1, f_name );
1030 : }
1031 : sprintf( f_name, "spar_band_C_coeffs.bin" );
1032 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1033 : num_elements = ndec * ( ndm - 1 );
1034 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1035 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1036 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1037 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1038 : for ( i = 0; i < ndec; i++ )
1039 : {
1040 : for ( j = 0; j < ( ndm - 1 ); j++ )
1041 : {
1042 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].C_re[i][j], sizeof( float ), 1, 1, f_name );
1043 : }
1044 : }
1045 : sprintf( f_name, "spar_band_P_coeffs.bin" );
1046 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1047 : num_elements = num_ch - ndm;
1048 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1049 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1050 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1051 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1052 : for ( i = 0; i < num_ch - ndm; i++ )
1053 : {
1054 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].P_re[i], sizeof( float ), 1, 1, f_name );
1055 : }
1056 : sprintf( f_name, "spar_band_pred_coeffs_quant.bin" );
1057 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1058 : num_elements = num_ch - 1;
1059 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1060 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1061 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1062 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1063 : for ( i = 0; i < num_ch - 1; i++ )
1064 : {
1065 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i], sizeof( float ), 1, 1, f_name );
1066 : }
1067 : sprintf( f_name, "spar_band_C_coeffs_quant.bin" );
1068 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1069 : num_elements = ndec * ( ndm - 1 );
1070 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1071 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1072 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1073 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1074 : for ( i = 0; i < ndec; i++ )
1075 : {
1076 : for ( j = 0; j < ( ndm - 1 ); j++ )
1077 : {
1078 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].C_quant_re[i][j], sizeof( float ), 1, 1, f_name );
1079 : }
1080 : }
1081 : sprintf( f_name, "spar_band_P_coeffs_quant.bin" );
1082 : ( b == 0 && frame == 0 ) ? dbgwrite( &nB, sizeof( nB ), 1, 1, f_name ) : false;
1083 : num_elements = num_ch - ndm;
1084 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_elements, sizeof( num_elements ), 1, 1, f_name ) : false;
1085 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_subframes, sizeof( num_subframes ), 1, 1, f_name ) : false;
1086 : ( b == 0 && frame == 0 ) ? dbgwrite( &num_block_groups, sizeof( num_block_groups ), 1, 1, f_name ) : false;
1087 : ( b == 0 && frame == 0 ) ? dbgwrite( &byte_size, sizeof( byte_size ), 1, 1, f_name ) : false;
1088 : for ( i = 0; i < num_ch - ndm; i++ )
1089 : {
1090 : dbgwrite( &hMdEnc->spar_md.band_coeffs[b].P_quant_re[i], sizeof( float ), 1, 1, f_name );
1091 : }
1092 : }
1093 : }
1094 : #endif
1095 : #ifdef DEBUG_SPAR_MD_TARGET_TUNING
1096 : int16_t md_bits = hMetaData->nb_bits_tot - bit_pos_start + ( ( ( hEncoderConfig->ivas_total_brate == IVAS_256k ) && ( sba_order == SBA_FOA_ORDER ) ) ? 1 : 0 );
1097 : FILE *fp = fopen( "spar_md_bitrate.txt", "a" );
1098 :
1099 : fprintf( fp, "%d\t %d \t %d\n", md_bits, qsi, code_strat );
1100 : fclose( fp );
1101 : #endif
1102 :
1103 159500 : ivas_store_prior_coeffs( hMdEnc, num_bands, code_strat, dtx_vad, qsi );
1104 :
1105 159500 : hMdEnc->spar_md.dtx_vad = dtx_vad;
1106 159500 : hMdEnc->spar_md.num_bands = num_bands;
1107 :
1108 159500 : free( ind_list_tmp );
1109 :
1110 159500 : return IVAS_ERR_OK;
1111 : }
1112 :
1113 :
1114 : /*-----------------------------------------------------------------------------------------*
1115 : * Function ivas_band_mixer()
1116 : *
1117 : * band mixer
1118 : *-----------------------------------------------------------------------------------------*/
1119 :
1120 16488 : static void ivas_band_mixer(
1121 : float *cov_real[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
1122 : const int16_t num_ch,
1123 : int16_t *num_bands,
1124 : int16_t red_band_fact )
1125 : {
1126 : int16_t i, j, k, b, orig_band, rem_band;
1127 : float avg_cov;
1128 :
1129 16488 : orig_band = *num_bands;
1130 16488 : *num_bands /= red_band_fact;
1131 16488 : rem_band = orig_band - ( *num_bands * red_band_fact );
1132 :
1133 82440 : for ( i = 0; i < num_ch; i++ )
1134 : {
1135 329760 : for ( j = 0; j < num_ch; j++ )
1136 : {
1137 932768 : for ( k = 0; k < *num_bands - 1; k++ )
1138 : {
1139 668960 : avg_cov = 0.0f;
1140 2129344 : for ( b = 0; b < red_band_fact; b++ )
1141 : {
1142 1460384 : avg_cov += cov_real[i][j][red_band_fact * k + b];
1143 : }
1144 668960 : cov_real[i][j][k] = avg_cov;
1145 : }
1146 :
1147 263808 : avg_cov = 0.0f;
1148 913888 : for ( b = 0; b < red_band_fact + rem_band; b++ )
1149 : {
1150 650080 : avg_cov += cov_real[i][j][red_band_fact * ( *num_bands - 1 ) + b];
1151 : }
1152 :
1153 263808 : cov_real[i][j][*num_bands - 1] = avg_cov;
1154 : }
1155 : }
1156 :
1157 16488 : return;
1158 : }
1159 :
1160 :
1161 : /*-----------------------------------------------------------------------------------------*
1162 : * Function ivas_write_spar_md_bitstream()
1163 : *
1164 : * Write MD parameters into bitstream
1165 : *-----------------------------------------------------------------------------------------*/
1166 :
1167 355397 : static void ivas_write_spar_md_bitstream(
1168 : ivas_spar_md_enc_state_t *hMdEnc,
1169 : const int16_t nB,
1170 : const int16_t bands_bw,
1171 : BSTR_ENC_HANDLE hMetaData,
1172 : const int32_t ivas_total_brate,
1173 : const int16_t strat,
1174 : const int16_t qsi )
1175 : {
1176 : int16_t no_ec, i;
1177 : int16_t do_diff[IVAS_MAX_NUM_BANDS];
1178 : int16_t entropy_coding_result;
1179 :
1180 355397 : if ( strat == NO_STRAT )
1181 : {
1182 0 : return;
1183 : }
1184 :
1185 : /* write quant strat */
1186 355397 : if ( ivas_total_brate >= BRATE_SPAR_Q_STRAT )
1187 : {
1188 43707 : push_next_indice( hMetaData, qsi >> 1, hMdEnc->spar_md_cfg.quant_strat_bits - 1 );
1189 : }
1190 : else
1191 : {
1192 311690 : push_next_indice( hMetaData, qsi, hMdEnc->spar_md_cfg.quant_strat_bits );
1193 : }
1194 :
1195 355397 : no_ec = 0;
1196 :
1197 355397 : if ( ivas_total_brate < IVAS_24k4 )
1198 : {
1199 38339 : switch ( strat )
1200 : {
1201 13048 : case BASE:
1202 13048 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1203 13048 : break;
1204 13048 : case BASE_NOEC:
1205 13048 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1206 13048 : no_ec = 1;
1207 13048 : break;
1208 12243 : case FOUR_A:
1209 : case FOUR_C:
1210 : case FOUR_B:
1211 : case FOUR_D:
1212 12243 : push_next_indice( hMetaData, strat, SPAR_NUM_CODING_STRAT_BITS );
1213 12243 : break;
1214 : }
1215 : /* for LBR SBA 40MS MD never do time diff */
1216 191695 : for ( i = 0; i < nB; i++ )
1217 : {
1218 153356 : do_diff[i] = 0;
1219 : }
1220 : }
1221 : else
1222 : {
1223 317058 : switch ( strat )
1224 : {
1225 143678 : case BASE:
1226 143678 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1227 1381262 : for ( i = 0; i < nB; i++ )
1228 : {
1229 1237584 : do_diff[i] = 0;
1230 : }
1231 143678 : break;
1232 88567 : case BASE_NOEC:
1233 88567 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1234 797103 : for ( i = 0; i < nB; i++ )
1235 : {
1236 708536 : do_diff[i] = 0;
1237 : }
1238 88567 : no_ec = 1;
1239 88567 : break;
1240 23983 : case FOUR_A:
1241 23983 : push_next_indice( hMetaData, 4, SPAR_NUM_CODING_STRAT_BITS );
1242 215847 : for ( i = 0; i < nB; i++ )
1243 : {
1244 191864 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 0 );
1245 : }
1246 23983 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1247 23983 : break;
1248 21535 : case FOUR_B:
1249 21535 : push_next_indice( hMetaData, 5, SPAR_NUM_CODING_STRAT_BITS );
1250 193815 : for ( i = 0; i < nB; i++ )
1251 : {
1252 172280 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 1 );
1253 : }
1254 21535 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1255 21535 : break;
1256 20151 : case FOUR_C:
1257 20151 : push_next_indice( hMetaData, 6, SPAR_NUM_CODING_STRAT_BITS );
1258 181359 : for ( i = 0; i < nB; i++ )
1259 : {
1260 161208 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 2 );
1261 : }
1262 20151 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1263 20151 : break;
1264 19144 : case FOUR_D:
1265 19144 : push_next_indice( hMetaData, 7, SPAR_NUM_CODING_STRAT_BITS );
1266 172296 : for ( i = 0; i < nB; i++ )
1267 : {
1268 153152 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 3 );
1269 : }
1270 19144 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1271 19144 : break;
1272 : }
1273 355397 : }
1274 :
1275 : #ifdef SPAR_HOA_DBG
1276 : if ( strat < 2 )
1277 : fprintf( stdout, "\n\n no_ec = %d, strat = %d\n", no_ec, strat - 1 );
1278 : else
1279 : fprintf( stdout, "\n\n no_ec = %d, strat = %d\n", no_ec, strat );
1280 : #endif
1281 355397 : if ( no_ec == 1 )
1282 : {
1283 : entropy_coding_result =
1284 101615 : ivas_get_huffman_coded_bs( hMdEnc, hMetaData, nB, qsi,
1285 : bands_bw );
1286 : }
1287 : else
1288 : {
1289 : entropy_coding_result =
1290 253782 : ivas_get_arith_coded_bs( hMdEnc, hMetaData, do_diff, bands_bw, nB, qsi,
1291 : strat, ivas_total_brate );
1292 : }
1293 :
1294 355397 : if ( entropy_coding_result < 0 )
1295 : {
1296 69911 : hMetaData->nb_bits_tot = 0;
1297 : }
1298 :
1299 355397 : return;
1300 : }
1301 :
1302 :
1303 : /*-----------------------------------------------------------------------------------------*
1304 : * Function ivas_get_huffman_coded_bs()
1305 : *
1306 : * Generate huffman coded bitstream
1307 : *-----------------------------------------------------------------------------------------*/
1308 101615 : static int16_t ivas_get_huffman_coded_bs(
1309 : ivas_spar_md_enc_state_t *hMdEnc,
1310 : BSTR_ENC_HANDLE hMetaData,
1311 : const int16_t nB,
1312 : const int16_t qsi,
1313 : const int16_t bands_bw )
1314 : {
1315 : int16_t i, j;
1316 : int16_t pred_coeff_dim, pred_offset;
1317 :
1318 813402 : for ( i = 0; i < nB; i++ )
1319 : {
1320 : int16_t code, len;
1321 : int16_t ndm, ndec;
1322 754280 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i * bands_bw];
1323 754280 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[i * bands_bw];
1324 :
1325 754280 : pred_coeff_dim = ndm + ndec - 1;
1326 754280 : pred_offset = 0;
1327 754280 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1328 : {
1329 0 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1330 : {
1331 0 : pred_offset = DIRAC_TO_SPAR_HBR_PRED_CHS;
1332 : }
1333 : }
1334 :
1335 2982295 : for ( j = pred_offset; j < pred_coeff_dim; j++ )
1336 : {
1337 2249035 : ivas_huffman_encode( &hMdEnc->huff_coeffs.pred_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j], &code, &len );
1338 2249035 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1339 : {
1340 42493 : return -1;
1341 : }
1342 2228015 : push_next_indice( hMetaData, code, len );
1343 : }
1344 :
1345 1628693 : for ( j = 0; j < ndec * ( ndm - 1 ); j++ )
1346 : {
1347 902449 : ivas_huffman_encode( &hMdEnc->huff_coeffs.drct_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].drct_index_re[j], &code, &len );
1348 902449 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1349 : {
1350 7016 : return -1;
1351 : }
1352 895433 : push_next_indice( hMetaData, code, len );
1353 : }
1354 :
1355 2193285 : for ( j = 0; j < ndec; j++ )
1356 : {
1357 1481498 : ivas_huffman_encode( &hMdEnc->huff_coeffs.decd_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].decd_index_re[j], &code, &len );
1358 1481498 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1359 : {
1360 14457 : return -1;
1361 : }
1362 1467041 : push_next_indice( hMetaData, code, len );
1363 : }
1364 : }
1365 :
1366 59122 : return 0;
1367 : }
1368 :
1369 :
1370 : /*-----------------------------------------------------------------------------------------*
1371 : * Function ivas_get_arith_coded_bs()
1372 : *
1373 : * Generate arithmetic coded bitstream
1374 : *-----------------------------------------------------------------------------------------*/
1375 253782 : static int16_t ivas_get_arith_coded_bs(
1376 : ivas_spar_md_enc_state_t *hMdEnc,
1377 : BSTR_ENC_HANDLE hMetaData,
1378 : const int16_t *pDo_diff,
1379 : const int16_t bands_bw,
1380 : const int16_t nB,
1381 : const int16_t qsi,
1382 : const int16_t strat,
1383 : const int32_t ivas_total_brate )
1384 : {
1385 : int16_t i, any_diff;
1386 : int16_t j;
1387 : ivas_cell_dim_t pred_cell_dims[IVAS_MAX_NUM_BANDS];
1388 : ivas_cell_dim_t drct_cell_dims[IVAS_MAX_NUM_BANDS];
1389 : ivas_cell_dim_t decd_cell_dims[IVAS_MAX_NUM_BANDS];
1390 : ivas_cell_dim_t decx_cell_dims[IVAS_MAX_NUM_BANDS];
1391 : int16_t symbol_arr_re[IVAS_MAX_INPUT_LEN];
1392 : int16_t symbol_arr_old_re[IVAS_MAX_INPUT_LEN];
1393 : int16_t arith_result;
1394 :
1395 2271034 : for ( i = 0; i < nB; i++ )
1396 : {
1397 : int16_t ndm, ndec;
1398 2017252 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[bands_bw * i];
1399 2017252 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[bands_bw * i];
1400 :
1401 2017252 : if ( ( ivas_total_brate < IVAS_24k4 ) && ( strat > 3 ) && ( ( ( i % 2 == 1 ) && ( strat % 2 == 0 ) ) || ( ( i % 2 == 0 ) && ( strat % 2 == 1 ) ) ) )
1402 : {
1403 24486 : pred_cell_dims[i].dim1 = 0;
1404 24486 : pred_cell_dims[i].dim2 = 0;
1405 24486 : drct_cell_dims[i].dim1 = 0;
1406 24486 : drct_cell_dims[i].dim2 = 0;
1407 24486 : decd_cell_dims[i].dim1 = 0;
1408 24486 : decd_cell_dims[i].dim2 = 0;
1409 24486 : decx_cell_dims[i].dim1 = 0;
1410 24486 : decx_cell_dims[i].dim2 = 0;
1411 : }
1412 : else
1413 : {
1414 1992766 : pred_cell_dims[i].dim1 = ndm + ndec - 1;
1415 1992766 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1416 : {
1417 145200 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1418 : {
1419 48400 : pred_cell_dims[i].dim1 -= ( FOA_CHANNELS - 1 );
1420 : }
1421 : }
1422 1992766 : pred_cell_dims[i].dim2 = 1;
1423 1992766 : drct_cell_dims[i].dim1 = ndec;
1424 1992766 : drct_cell_dims[i].dim2 = ndm - 1;
1425 1992766 : decd_cell_dims[i].dim1 = ndec;
1426 1992766 : decd_cell_dims[i].dim2 = 1;
1427 1992766 : decx_cell_dims[i].dim1 = ( ndec * ( ndec - 1 ) ) >> 1;
1428 1992766 : decx_cell_dims[i].dim2 = 1;
1429 : }
1430 : }
1431 :
1432 253782 : any_diff = 0;
1433 1614065 : for ( i = 0; i < nB; i++ )
1434 : {
1435 1445096 : if ( pDo_diff[i] != 0 )
1436 : {
1437 84813 : any_diff = 1;
1438 84813 : break;
1439 : }
1440 : }
1441 253782 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1442 : {
1443 157300 : for ( i = 0; i < nB; i++ )
1444 : {
1445 145200 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1446 : {
1447 196960 : for ( j = 0; j < pred_cell_dims[i].dim1; j++ )
1448 : {
1449 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] =
1450 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1451 :
1452 148560 : if ( any_diff == 1 )
1453 : {
1454 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j] =
1455 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1456 : }
1457 : }
1458 : }
1459 : }
1460 : }
1461 253782 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, pred_cell_dims, PRED_COEFF );
1462 :
1463 253782 : if ( any_diff == 1 )
1464 : {
1465 84813 : 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 );
1466 : }
1467 :
1468 253782 : 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,
1469 253782 : symbol_arr_re, symbol_arr_old_re, pred_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1470 253782 : if ( arith_result < 0 )
1471 : {
1472 969 : return -1;
1473 : }
1474 :
1475 252813 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1476 : {
1477 157300 : for ( i = 0; i < nB; i++ )
1478 : {
1479 145200 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1480 : {
1481 196960 : for ( j = pred_cell_dims[i].dim1 - 1; j >= 0; j-- )
1482 : {
1483 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS] =
1484 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j];
1485 : }
1486 193600 : for ( j = 0; j < DIRAC_TO_SPAR_HBR_PRED_CHS; j++ )
1487 : {
1488 145200 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] = 0;
1489 : }
1490 : }
1491 : }
1492 : }
1493 :
1494 252813 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, drct_cell_dims, DRCT_COEFF );
1495 :
1496 252813 : if ( any_diff == 1 )
1497 : {
1498 84813 : 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 );
1499 : }
1500 :
1501 :
1502 252813 : 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,
1503 252813 : symbol_arr_re, symbol_arr_old_re, drct_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1504 252813 : if ( arith_result < 0 )
1505 : {
1506 4 : return -1;
1507 : }
1508 :
1509 252809 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decd_cell_dims, DECD_COEFF );
1510 :
1511 252809 : if ( any_diff == 1 )
1512 : {
1513 84809 : 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 );
1514 : }
1515 :
1516 252809 : 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,
1517 252809 : symbol_arr_re, symbol_arr_old_re, decd_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1518 252809 : if ( arith_result < 0 )
1519 : {
1520 26445 : return -1;
1521 : }
1522 :
1523 226364 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decx_cell_dims, DECX_COEFF );
1524 :
1525 226364 : if ( any_diff == 1 )
1526 : {
1527 83873 : 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 );
1528 : }
1529 :
1530 226364 : return 0;
1531 : }
1532 :
1533 :
1534 : /*-----------------------------------------------------------------------------------------*
1535 : * Function ivas_select_next_strat()
1536 : *
1537 : * Select next strategy
1538 : *-----------------------------------------------------------------------------------------*/
1539 :
1540 156726 : static void ivas_select_next_strat(
1541 : ivas_strats_t prior_strat,
1542 : ivas_strats_t cs[MAX_QUANT_STRATS],
1543 : const int16_t dmx_switch,
1544 : const int16_t dtx_vad )
1545 : {
1546 156726 : cs[0] = BASE;
1547 156726 : cs[1] = BASE_NOEC;
1548 156726 : if ( dmx_switch == 0 && dtx_vad )
1549 : {
1550 156726 : switch ( prior_strat )
1551 : {
1552 2607 : case START:
1553 2607 : cs[2] = NO_STRAT;
1554 2607 : break;
1555 58087 : case BASE:
1556 58087 : cs[2] = FOUR_A;
1557 58087 : break;
1558 0 : case BASE_DIFF:
1559 0 : cs[2] = FOUR_A;
1560 0 : break;
1561 2877 : case BASE_NOEC:
1562 2877 : cs[2] = FOUR_A;
1563 2877 : break;
1564 25276 : case FOUR_A:
1565 25276 : cs[2] = FOUR_B;
1566 25276 : break;
1567 23629 : case FOUR_B:
1568 23629 : cs[2] = FOUR_C;
1569 23629 : break;
1570 22567 : case FOUR_C:
1571 22567 : cs[2] = FOUR_D;
1572 22567 : break;
1573 21683 : case FOUR_D:
1574 21683 : cs[2] = FOUR_A;
1575 21683 : break;
1576 0 : default:
1577 0 : assert( !"bad value of prior_strat" );
1578 : }
1579 0 : }
1580 :
1581 156726 : return;
1582 : }
1583 :
1584 :
1585 : /*-----------------------------------------------------------------------------------------*
1586 : * Function ivas_store_prior_coeffs()
1587 : *
1588 : * Store prior coeffs
1589 : *-----------------------------------------------------------------------------------------*/
1590 :
1591 159500 : static void ivas_store_prior_coeffs(
1592 : ivas_spar_md_enc_state_t *hMdEnc,
1593 : const int16_t num_bands,
1594 : const int16_t strat,
1595 : const int16_t dtx_vad,
1596 : const int16_t qsi )
1597 : {
1598 : int16_t i, j, b;
1599 159500 : if ( dtx_vad == 0 )
1600 : {
1601 3827 : hMdEnc->spar_md_cfg.prior_strat = START;
1602 : }
1603 : else
1604 : {
1605 155673 : hMdEnc->spar_md_cfg.prior_strat = strat;
1606 : }
1607 :
1608 159500 : hMdEnc->spar_md_cfg.prev_quant_idx = qsi;
1609 :
1610 1450054 : for ( i = 0; i < num_bands; i++ )
1611 : {
1612 1290554 : b = i;
1613 :
1614 14196094 : for ( j = 0; j < IVAS_SPAR_MAX_CH - 1; j++ )
1615 : {
1616 12905540 : hMdEnc->spar_md_prior.band_coeffs_idx[i].pred_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[j];
1617 12905540 : hMdEnc->spar_md_prior.band_coeffs_idx[i].decd_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[j];
1618 : }
1619 28392188 : for ( j = 0; j < IVAS_SPAR_MAX_C_COEFF; j++ )
1620 : {
1621 27101634 : hMdEnc->spar_md_prior.band_coeffs_idx[i].drct_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].drct_index_re[j];
1622 : }
1623 : }
1624 :
1625 159500 : return;
1626 : }
1627 :
1628 :
1629 : /*-----------------------------------------------------------------------------------------*
1630 : * Function ivas_spar_quant_pred_coeffs_dtx()
1631 : *
1632 : * Calculate quantization pred coeffs
1633 : *-----------------------------------------------------------------------------------------*/
1634 :
1635 7654 : static void ivas_spar_quant_pred_coeffs_dtx(
1636 : ivas_spar_md_t *pSpar_md,
1637 : const float *pValues,
1638 : const int16_t ndm,
1639 : int16_t *pIndex,
1640 : const int16_t dim1,
1641 : float *pQuant )
1642 : {
1643 : int16_t i;
1644 : int16_t q_lvl;
1645 : float pr_min_max[2];
1646 :
1647 7654 : pr_min_max[0] = pSpar_md->min_max[0];
1648 7654 : pr_min_max[1] = pSpar_md->min_max[1];
1649 :
1650 30616 : for ( i = 0; i < dim1; i++ )
1651 : {
1652 22962 : q_lvl = dtx_pr_real_q_levels[ndm - 1][i];
1653 22962 : ivas_quantise_real_values( &pValues[i], q_lvl, pr_min_max[0], pr_min_max[1], &pIndex[i], &pQuant[i], 1 );
1654 : }
1655 :
1656 7654 : return;
1657 : }
1658 :
1659 :
1660 : /*-----------------------------------------------------------------------------------------*
1661 : * Function ivas_quant_p_per_band_dtx()
1662 : *
1663 : * Calculate quantization p
1664 : *-----------------------------------------------------------------------------------------*/
1665 :
1666 7654 : static void ivas_quant_p_per_band_dtx(
1667 : float *pP_mat,
1668 : const int16_t num_dec,
1669 : const int16_t num_dmx,
1670 : int16_t *ppIdx_pd,
1671 : float *pP_out,
1672 : const int16_t num_ch )
1673 : {
1674 : int16_t i;
1675 7654 : int16_t dim = num_ch - num_dmx;
1676 :
1677 7654 : if ( num_dec == num_ch - 1 )
1678 : {
1679 17144 : for ( i = 0; i < dim; i++ )
1680 : {
1681 12858 : if ( pP_mat[i] < pr_boost_range[1] && pP_mat[i] > pr_boost_range[0] )
1682 : {
1683 5565 : pP_mat[i] = pr_boost_range[1];
1684 : }
1685 : }
1686 : }
1687 :
1688 7654 : if ( dim != num_dec )
1689 : {
1690 0 : assert( !"Not Supported!" );
1691 : }
1692 :
1693 27248 : for ( i = 0; i < dim; i++ )
1694 : {
1695 19594 : 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 );
1696 : }
1697 :
1698 7654 : return;
1699 : }
1700 :
1701 : /*-----------------------------------------------------------------------------------------*
1702 : * Function ivas_write_parameter_bitstream_dtx()
1703 : *
1704 : * Write MD DTX parameters into bitstream
1705 : *-----------------------------------------------------------------------------------------*/
1706 :
1707 3827 : static void ivas_write_parameter_bitstream_dtx(
1708 : ivas_spar_md_t *pSpar_md,
1709 : BSTR_ENC_HANDLE hMetaData,
1710 : int16_t *num_dmx,
1711 : int16_t *num_dec,
1712 : const int16_t num_bands )
1713 : {
1714 : int16_t i, j;
1715 : float val;
1716 : int16_t idx;
1717 : float pr_min_max[2];
1718 : int16_t zero_pad_bits, sid_bits_len;
1719 : int16_t sba_spar_bitlen;
1720 :
1721 3827 : sid_bits_len = hMetaData->nb_bits_tot;
1722 3827 : pr_min_max[0] = pSpar_md->min_max[0];
1723 3827 : pr_min_max[1] = pSpar_md->min_max[1];
1724 :
1725 11481 : for ( i = 0; i < num_bands; i++ )
1726 : {
1727 7654 : int16_t ndm = num_dmx[i];
1728 7654 : int16_t ndec = num_dec[i];
1729 :
1730 30616 : for ( j = 0; j < FOA_CHANNELS - 1; j++ )
1731 : {
1732 : int16_t pr, pd;
1733 : int16_t pr_q_lvls, pd_q_lvls, pr_pd_bits;
1734 : int16_t pr_idx_1, pr_idx_2, pd_idx_1, pd_idx_2;
1735 : uint16_t value;
1736 :
1737 22962 : pr_idx_1 = pr_pr_idx_pairs[ndm - 1][j][0];
1738 22962 : pr_idx_2 = pr_pr_idx_pairs[ndm - 1][j][1];
1739 22962 : pd_idx_1 = pr_pd_idx_pairs[ndm - 1][j][0];
1740 22962 : pd_idx_2 = pr_pd_idx_pairs[ndm - 1][j][1];
1741 :
1742 22962 : if ( pr_idx_1 != 0 || pd_idx_1 != 0 || pr_idx_2 != 0 || pd_idx_2 != 0 )
1743 : {
1744 22962 : pr_q_lvls = dtx_pr_real_q_levels[ndm - 1][pd_idx_1 - 1];
1745 22962 : pr = pSpar_md->band_coeffs_idx[i].pred_index_re[pd_idx_1 - 1];
1746 :
1747 22962 : if ( ( j + 1 ) > ndec )
1748 : {
1749 3368 : pd_q_lvls = 1;
1750 3368 : pd = 0;
1751 : }
1752 : else
1753 : {
1754 19594 : pd_q_lvls = dtx_pd_real_q_levels[ndm - 1][pd_idx_2 - 1];
1755 19594 : pd = pSpar_md->band_coeffs_idx[i].decd_index_re[pd_idx_2 - 1];
1756 : }
1757 22962 : val = dtx_pd_real_min_max[0];
1758 22962 : ivas_quantise_real_values( &val, pd_q_lvls, dtx_pd_real_min_max[0], dtx_pd_real_min_max[1], &idx, &val, 1 );
1759 :
1760 22962 : pd -= idx;
1761 :
1762 22962 : val = pr_min_max[0];
1763 22962 : ivas_quantise_real_values( &val, pr_q_lvls, pr_min_max[0], pr_min_max[1], &idx, &val, 1 );
1764 :
1765 22962 : pr -= idx;
1766 22962 : pr_pd_bits = ivas_get_bits_to_encode( pd_q_lvls * pr_q_lvls );
1767 :
1768 22962 : value = (uint16_t) ( pr * pd_q_lvls + pd );
1769 :
1770 22962 : push_next_indice( hMetaData, value, pr_pd_bits );
1771 : }
1772 : }
1773 : }
1774 :
1775 3827 : sid_bits_len = hMetaData->nb_bits_tot - sid_bits_len;
1776 3827 : sba_spar_bitlen = ivas_sba_spar_sid_bitlen( num_dmx[0] );
1777 3827 : zero_pad_bits = sba_spar_bitlen - sid_bits_len;
1778 :
1779 3827 : assert( zero_pad_bits >= 0 );
1780 3827 : if ( num_dmx[0] == 2 )
1781 : {
1782 1684 : zero_pad_bits -= 1;
1783 : }
1784 :
1785 5511 : while ( zero_pad_bits > 0 )
1786 : {
1787 1684 : j = min( zero_pad_bits, 16 );
1788 1684 : push_next_indice( hMetaData, 0, j );
1789 1684 : zero_pad_bits -= j;
1790 : }
1791 :
1792 3827 : return;
1793 : }
1794 :
1795 :
1796 : /*-----------------------------------------------------------------------------------------*
1797 : * Function ivas_quant_pred_coeffs_per_band()
1798 : *
1799 : * Quantization of prediction coefficients
1800 : *-----------------------------------------------------------------------------------------*/
1801 :
1802 1289776 : static void ivas_quant_pred_coeffs_per_band(
1803 : ivas_band_coeffs_t *pband_coeffs,
1804 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1805 : ivas_quant_strat_t *pQs,
1806 : const int16_t num_ch )
1807 : {
1808 1289776 : 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 ) );
1809 :
1810 1289776 : return;
1811 : }
1812 :
1813 :
1814 : /*-----------------------------------------------------------------------------------------*
1815 : * Function ivas_quant_c_per_band()
1816 : *
1817 : * Quantization of cross prediction c coeffs for each band
1818 : *-----------------------------------------------------------------------------------------*/
1819 :
1820 848624 : static void ivas_quant_c_per_band(
1821 : ivas_band_coeffs_t *pband_coeffs,
1822 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1823 : ivas_quant_strat_t *pQs,
1824 : const int16_t ndec,
1825 : const int16_t ndm )
1826 : {
1827 : int16_t i;
1828 : int16_t j, k;
1829 : float C_re[IVAS_SPAR_MAX_C_COEFF];
1830 848624 : k = 0;
1831 2981400 : for ( i = 0; i < ndec; i++ )
1832 : {
1833 6980264 : for ( j = 0; j < ndm - 1; j++ )
1834 : {
1835 4847488 : C_re[k] = pband_coeffs->C_re[i][j];
1836 4847488 : k++;
1837 : }
1838 : }
1839 848624 : 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 ) );
1840 848624 : k = 0;
1841 2981400 : for ( i = 0; i < ndec; i++ )
1842 : {
1843 6980264 : for ( j = 0; j < ndm - 1; j++ )
1844 : {
1845 4847488 : pband_coeffs->C_quant_re[i][j] = C_re[k];
1846 4847488 : k++;
1847 : }
1848 : }
1849 :
1850 848624 : return;
1851 : }
1852 :
1853 :
1854 : /*-----------------------------------------------------------------------------------------*
1855 : * Function ivas_quant_p_per_band()
1856 : *
1857 : * Quantization of decorrelation p coeffs for each band
1858 : *-----------------------------------------------------------------------------------------*/
1859 :
1860 1136736 : static void ivas_quant_p_per_band(
1861 : ivas_band_coeffs_t *pband_coeffs,
1862 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1863 : ivas_quant_strat_t *pQs,
1864 : const int16_t num_ch )
1865 : {
1866 1136736 : 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 );
1867 :
1868 1136736 : return;
1869 : }
|
