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 : #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 37661350 : push_next_indice( hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
456 : #endif
457 : }
458 :
459 233535 : return;
460 : }
461 :
462 :
463 : /*-----------------------------------------------------------------------------------------*
464 : * Function ivas_spar_md_enc_process()
465 : *
466 : * SPAR FoA Meta Data generation process
467 : *-----------------------------------------------------------------------------------------*/
468 :
469 159500 : 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 159500 : 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 159500 : md_indices_allocated = hMdEnc->spar_md_cfg.max_bits_per_blk + IVAS_SPAR_ARITH_OVERSHOOT_BITS;
502 159500 : 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 159500 : num_quant_strats = hMdEnc->spar_md_cfg.num_quant_strats;
508 159500 : num_ch = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
509 159500 : active_w = ( hMdEnc->spar_md_cfg.active_w == 1 ) || ( dyn_active_w_flag == 1 );
510 159500 : nchan_transport = hMdEnc->spar_md_cfg.nchan_transport;
511 :
512 159500 : bwidth = ivas_get_bw_idx_from_sample_rate( hEncoderConfig->input_Fs );
513 159500 : bwidth = min( bwidth, hEncoderConfig->max_bwidth );
514 : int16_t active_w_vlbr;
515 159500 : active_w_vlbr = ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) ? 1 : 0;
516 159500 : num_bands = ivas_get_num_bands_from_bw_idx( SPAR_CONFIG_BW );
517 159500 : if ( hMdEnc->spar_hoa_md_flag == 0 )
518 : {
519 137460 : num_bands = min( num_bands, SPAR_DIRAC_SPLIT_START_BAND );
520 : }
521 159500 : num_bands_full = num_bands;
522 159500 : num_bands_bw = ivas_get_num_bands_from_bw_idx( bwidth );
523 :
524 159500 : if ( dtx_vad == 0 )
525 : {
526 19135 : for ( i = 0; i < nchan_inp; i++ )
527 : {
528 76540 : for ( j = 0; j < nchan_inp; j++ )
529 : {
530 61232 : cov_real[i][j] = cov_dtx_real[i][j];
531 : }
532 : }
533 : }
534 :
535 899700 : for ( i = 0; i < nchan_inp; i++ )
536 : {
537 4668660 : for ( j = 0; j < nchan_inp; j++ )
538 : {
539 4638420 : for ( k = num_bands_bw; k < IVAS_MAX_NUM_BANDS; k++ )
540 : {
541 709960 : cov_real[i][j][k] = 0;
542 : }
543 : }
544 : }
545 :
546 159500 : 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 11620 : num_quant_strats = 1;
550 : }
551 :
552 159500 : hMetaData_tmp.ind_list = ind_list_tmp;
553 159500 : hMetaData_tmp.nb_bits_tot = 0;
554 159500 : max_num_indices_tmp = MAX_BITS_METADATA;
555 159500 : hMetaData_tmp.ivas_max_num_indices = &max_num_indices_tmp;
556 159500 : hMetaData_tmp.ivas_ind_list_zero = (Indice **) ( &hMetaData_tmp.ind_list );
557 159500 : hMetaData_tmp.st_ivas = NULL;
558 :
559 : /* Save state of metadata bitstream buffer */
560 159500 : bit_pos_start = hMetaData->nb_bits_tot;
561 159500 : next_ind_start = hMetaData->nb_ind_tot;
562 :
563 159500 : dmx_switch = 0;
564 :
565 159500 : if ( dtx_vad == 0 )
566 : {
567 3827 : nB = SPAR_DTX_BANDS;
568 3827 : bands_bw = num_bands / nB;
569 :
570 3827 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
571 : }
572 155673 : else if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
573 : {
574 12661 : bands_bw = 2;
575 12661 : nB = num_bands / bands_bw;
576 :
577 12661 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
578 : }
579 : else
580 : {
581 143012 : nB = num_bands;
582 143012 : bands_bw = 1;
583 : }
584 159500 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
585 : {
586 60500 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
587 : {
588 193600 : for ( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
589 : {
590 145200 : pred_coeffs_re_local[i][b] = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
591 : }
592 : }
593 : }
594 :
595 159500 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
596 : {
597 121977 : for ( b = 0; b < num_bands * bands_bw; b++ )
598 : {
599 108424 : mvr2r( hMdEnc->spar_md.band_coeffs[b].P_quant_re, P_quant_re_prior[b], FOA_CHANNELS - 1 );
600 : }
601 : }
602 :
603 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 );
604 :
605 159500 : if ( dirac_mono_flag )
606 : {
607 : int16_t i_ts;
608 0 : int16_t num_md_sub_frames = 1;
609 :
610 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
611 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
612 :
613 0 : for ( i_ts = 0; i_ts < num_md_sub_frames; i_ts++ )
614 : {
615 0 : for ( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
616 : {
617 0 : for ( j = 0; j < ndm + ndec - 1; j++ )
618 : {
619 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].pred_re[j] = 0.0f;
620 : }
621 0 : for ( j = 0; j < ndec; j++ )
622 : {
623 0 : for ( k = 0; k < ndm - 1; k++ )
624 : {
625 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].C_re[j][k] = 0.0f;
626 : }
627 : }
628 :
629 0 : for ( j = 0; j < ndec; j++ )
630 : {
631 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].P_re[j] = 0.0f;
632 : }
633 : }
634 : }
635 : }
636 :
637 899700 : for ( i = 0; i < num_ch; i++ )
638 : {
639 4668660 : for ( j = 0; j < num_ch; j++ )
640 : {
641 41094844 : for ( b = 0; b < num_bands; b++ )
642 : {
643 37166384 : 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 159500 : 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 160553 : 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 1457983 : for ( b = 0; b < num_bands; b++ )
664 : {
665 1297430 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
666 1297430 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
667 :
668 1297430 : if ( dtx_vad == 1 )
669 : {
670 1289776 : if ( ndm != num_ch )
671 : {
672 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 );
673 : }
674 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 );
675 1289776 : if ( active_w_vlbr )
676 : {
677 208768 : for ( i = 0; i < 3; i++ )
678 : {
679 : int16_t i2;
680 156576 : i2 = 0;
681 156576 : switch ( i ) /* PRED (Y,Z,X) and DECD (Y,X,Z) coeffs are in different orders */
682 : {
683 52192 : case 0:
684 52192 : i2 = 0;
685 52192 : break;
686 52192 : case 1:
687 52192 : i2 = 2;
688 52192 : break;
689 52192 : case 2:
690 52192 : i2 = 1;
691 52192 : break;
692 : }
693 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 ) )
694 : {
695 : /* bump up the Pred coeff */
696 : float PR_uq, PR_step;
697 : ivas_quant_strat_t qs;
698 3094 : qs = hMdEnc->spar_md_cfg.quant_strat[qsi];
699 3094 : PR_uq = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
700 3094 : PR_step = ( qs.PR.max - qs.PR.min ) / ( qs.PR.q_levels[0] - 1 );
701 :
702 : int16_t PR_sign;
703 3094 : PR_sign = ( PR_uq > 0 ) - ( PR_uq < 0 );
704 :
705 3094 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = PR_sign;
706 :
707 : /* deindex the modified coefficient */
708 3094 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = PR_sign * PR_step;
709 : }
710 : }
711 : }
712 : }
713 : else
714 : {
715 7654 : if ( ndm != num_ch )
716 : {
717 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 );
718 : }
719 :
720 30616 : for ( i = 0; i < num_ch - 1; i++ )
721 : {
722 22962 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
723 : }
724 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 );
725 : }
726 : }
727 :
728 744412 : for ( i = 0; i < num_ch - 1; i++ )
729 : {
730 5702549 : for ( b = 0; b < num_bands; b++ )
731 : {
732 5118690 : pred_coeffs_re[i][b] = Wscale[b] * hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i];
733 : }
734 : }
735 :
736 160553 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
737 : {
738 60500 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
739 : {
740 193600 : 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 145200 : pred_coeffs_re[i][b] = pred_coeffs_re_local[i][b];
744 145200 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
745 145200 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = 0;
746 : }
747 : }
748 : }
749 :
750 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 );
751 :
752 1457983 : for ( b = 0; b < num_bands; b++ )
753 : {
754 1297430 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
755 1297430 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
756 :
757 7713550 : for ( i = 0; i < num_ch; i++ )
758 : {
759 6416120 : hMdEnc->mixer_mat[0][i][b] *= Wscale[b];
760 : }
761 :
762 1297430 : if ( ( ndm != num_ch ) && ( ndm != 1 ) )
763 : {
764 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 );
765 :
766 848624 : if ( dirac_mono_flag )
767 : {
768 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
769 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
770 0 : for ( j = 0; j < ndec; j++ )
771 : {
772 0 : for ( k = 0; k < ndm - 1; k++ )
773 : {
774 0 : 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 848624 : ivas_quant_c_per_band( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b],
793 848624 : &hMdEnc->spar_md_cfg.quant_strat[qsi], ndec, ndm );
794 : }
795 : }
796 :
797 : /* band limit downmix matrix */
798 160553 : ivas_band_limit_dmx_matrix( hMdEnc, num_ch, num_bands, bands_bw );
799 :
800 : /* band mixing */
801 160553 : if ( bands_bw > 1 )
802 : {
803 16875 : ivas_band_mixing( hMdEnc, num_ch, num_bands, nchan_transport, num_bands_full );
804 : }
805 :
806 160553 : if ( dtx_vad == 0 )
807 : {
808 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 );
809 3827 : break;
810 : }
811 :
812 156726 : ivas_select_next_strat( hMdEnc->spar_md_cfg.prior_strat, cs, dmx_switch, dtx_vad );
813 :
814 391736 : for ( i = 0; i < MAX_CODING_STRATS; i++ )
815 : {
816 357419 : strat = cs[i];
817 357419 : if ( strat != NO_STRAT )
818 : {
819 355397 : reset_indices_enc( &hMetaData_tmp, md_indices_allocated );
820 :
821 355397 : 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 355397 : if ( hMetaData_tmp.nb_bits_tot > 0 )
825 : {
826 285486 : if ( hMetaData->nb_bits_tot == bit_pos_start || hMetaData_tmp.nb_bits_tot < ( hMetaData->nb_bits_tot - bit_pos_start ) )
827 : {
828 233535 : write_metadata_buffer( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start );
829 233535 : code_strat = strat;
830 : }
831 :
832 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 )
833 : {
834 122409 : packed_ok = 1;
835 122409 : break;
836 : }
837 : }
838 : }
839 : }
840 :
841 156726 : if ( packed_ok == 1 )
842 : {
843 122409 : break;
844 : }
845 :
846 : /*only if valid bitstream was written to main buffer*/
847 34317 : if ( hMetaData->nb_bits_tot > bit_pos_start )
848 : {
849 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 )
850 : {
851 33264 : packed_ok = 1;
852 33264 : 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 159500 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
870 : {
871 65981 : for ( k = num_bands - 1; k >= 0; k-- )
872 : {
873 160852 : for ( b = bands_bw - 1; b >= 0; b-- )
874 : {
875 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 );
876 : }
877 : }
878 : }
879 :
880 159500 : if ( ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) && ( code_strat > 3 ) )
881 : {
882 36729 : for ( b = 0; b < num_bands * bands_bw; b += 2 * bands_bw )
883 : {
884 24486 : if ( ( b == 0 ) && ( code_strat % 2 == 0 ) )
885 : {
886 6323 : b += 2;
887 : }
888 48972 : for ( i = 0; i < 1; i++ )
889 : {
890 122430 : for ( j = 0; j < 4; j++ )
891 : {
892 97944 : hMdEnc->mixer_mat[i][j][b] = prior_mixer[i][j][b];
893 97944 : hMdEnc->mixer_mat[i][j][b + 1] = prior_mixer[i][j][b + 1];
894 : }
895 : }
896 :
897 24486 : mvr2r( P_quant_re_prior[b], hMdEnc->spar_md.band_coeffs[b].P_quant_re, FOA_CHANNELS - 1 );
898 24486 : 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 159500 : ivas_store_prior_coeffs( hMdEnc, num_bands, code_strat, dtx_vad, qsi );
1108 :
1109 159500 : hMdEnc->spar_md.dtx_vad = dtx_vad;
1110 159500 : hMdEnc->spar_md.num_bands = num_bands;
1111 :
1112 159500 : free( ind_list_tmp );
1113 :
1114 159500 : return IVAS_ERR_OK;
1115 : }
1116 :
1117 :
1118 : /*-----------------------------------------------------------------------------------------*
1119 : * Function ivas_band_mixer()
1120 : *
1121 : * band mixer
1122 : *-----------------------------------------------------------------------------------------*/
1123 :
1124 16488 : 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 16488 : orig_band = *num_bands;
1134 16488 : *num_bands /= red_band_fact;
1135 16488 : rem_band = orig_band - ( *num_bands * red_band_fact );
1136 :
1137 82440 : for ( i = 0; i < num_ch; i++ )
1138 : {
1139 329760 : for ( j = 0; j < num_ch; j++ )
1140 : {
1141 932768 : for ( k = 0; k < *num_bands - 1; k++ )
1142 : {
1143 668960 : avg_cov = 0.0f;
1144 2129344 : for ( b = 0; b < red_band_fact; b++ )
1145 : {
1146 1460384 : avg_cov += cov_real[i][j][red_band_fact * k + b];
1147 : }
1148 668960 : cov_real[i][j][k] = avg_cov;
1149 : }
1150 :
1151 263808 : avg_cov = 0.0f;
1152 913888 : for ( b = 0; b < red_band_fact + rem_band; b++ )
1153 : {
1154 650080 : avg_cov += cov_real[i][j][red_band_fact * ( *num_bands - 1 ) + b];
1155 : }
1156 :
1157 263808 : cov_real[i][j][*num_bands - 1] = avg_cov;
1158 : }
1159 : }
1160 :
1161 16488 : return;
1162 : }
1163 :
1164 :
1165 : /*-----------------------------------------------------------------------------------------*
1166 : * Function ivas_write_spar_md_bitstream()
1167 : *
1168 : * Write MD parameters into bitstream
1169 : *-----------------------------------------------------------------------------------------*/
1170 :
1171 355397 : 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 355397 : if ( strat == NO_STRAT )
1185 : {
1186 0 : return;
1187 : }
1188 :
1189 : /* write quant strat */
1190 355397 : if ( ivas_total_brate >= BRATE_SPAR_Q_STRAT )
1191 : {
1192 43707 : push_next_indice( hMetaData, qsi >> 1, hMdEnc->spar_md_cfg.quant_strat_bits - 1 );
1193 : }
1194 : else
1195 : {
1196 311690 : push_next_indice( hMetaData, qsi, hMdEnc->spar_md_cfg.quant_strat_bits );
1197 : }
1198 :
1199 355397 : no_ec = 0;
1200 :
1201 355397 : if ( ivas_total_brate < IVAS_24k4 )
1202 : {
1203 38339 : switch ( strat )
1204 : {
1205 13048 : case BASE:
1206 13048 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1207 13048 : break;
1208 13048 : case BASE_NOEC:
1209 13048 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1210 13048 : no_ec = 1;
1211 13048 : break;
1212 12243 : case FOUR_A:
1213 : case FOUR_C:
1214 : case FOUR_B:
1215 : case FOUR_D:
1216 12243 : push_next_indice( hMetaData, strat, SPAR_NUM_CODING_STRAT_BITS );
1217 12243 : break;
1218 : }
1219 : /* for LBR SBA 40MS MD never do time diff */
1220 191695 : for ( i = 0; i < nB; i++ )
1221 : {
1222 153356 : do_diff[i] = 0;
1223 : }
1224 : }
1225 : else
1226 : {
1227 317058 : switch ( strat )
1228 : {
1229 143678 : case BASE:
1230 143678 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1231 1381262 : for ( i = 0; i < nB; i++ )
1232 : {
1233 1237584 : do_diff[i] = 0;
1234 : }
1235 143678 : break;
1236 88567 : case BASE_NOEC:
1237 88567 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1238 797103 : for ( i = 0; i < nB; i++ )
1239 : {
1240 708536 : do_diff[i] = 0;
1241 : }
1242 88567 : no_ec = 1;
1243 88567 : break;
1244 23983 : case FOUR_A:
1245 23983 : push_next_indice( hMetaData, 4, SPAR_NUM_CODING_STRAT_BITS );
1246 215847 : for ( i = 0; i < nB; i++ )
1247 : {
1248 191864 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 0 );
1249 : }
1250 23983 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1251 23983 : break;
1252 21535 : case FOUR_B:
1253 21535 : push_next_indice( hMetaData, 5, SPAR_NUM_CODING_STRAT_BITS );
1254 193815 : for ( i = 0; i < nB; i++ )
1255 : {
1256 172280 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 1 );
1257 : }
1258 21535 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1259 21535 : break;
1260 20151 : case FOUR_C:
1261 20151 : push_next_indice( hMetaData, 6, SPAR_NUM_CODING_STRAT_BITS );
1262 181359 : for ( i = 0; i < nB; i++ )
1263 : {
1264 161208 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 2 );
1265 : }
1266 20151 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1267 20151 : break;
1268 19144 : case FOUR_D:
1269 19144 : push_next_indice( hMetaData, 7, SPAR_NUM_CODING_STRAT_BITS );
1270 172296 : for ( i = 0; i < nB; i++ )
1271 : {
1272 153152 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 3 );
1273 : }
1274 19144 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1275 19144 : break;
1276 : }
1277 355397 : }
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 355397 : if ( no_ec == 1 )
1286 : {
1287 : entropy_coding_result =
1288 101615 : ivas_get_huffman_coded_bs( hMdEnc, hMetaData, nB, qsi,
1289 : bands_bw );
1290 : }
1291 : else
1292 : {
1293 : entropy_coding_result =
1294 253782 : ivas_get_arith_coded_bs( hMdEnc, hMetaData, do_diff, bands_bw, nB, qsi,
1295 : strat, ivas_total_brate );
1296 : }
1297 :
1298 355397 : if ( entropy_coding_result < 0 )
1299 : {
1300 69911 : hMetaData->nb_bits_tot = 0;
1301 : }
1302 :
1303 355397 : return;
1304 : }
1305 :
1306 :
1307 : /*-----------------------------------------------------------------------------------------*
1308 : * Function ivas_get_huffman_coded_bs()
1309 : *
1310 : * Generate huffman coded bitstream
1311 : *-----------------------------------------------------------------------------------------*/
1312 101615 : 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 813402 : for ( i = 0; i < nB; i++ )
1323 : {
1324 : int16_t code, len;
1325 : int16_t ndm, ndec;
1326 754280 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i * bands_bw];
1327 754280 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[i * bands_bw];
1328 :
1329 754280 : pred_coeff_dim = ndm + ndec - 1;
1330 754280 : pred_offset = 0;
1331 754280 : 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 2982295 : for ( j = pred_offset; j < pred_coeff_dim; j++ )
1340 : {
1341 2249035 : ivas_huffman_encode( &hMdEnc->huff_coeffs.pred_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j], &code, &len );
1342 2249035 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1343 : {
1344 42493 : return -1;
1345 : }
1346 2228015 : push_next_indice( hMetaData, code, len );
1347 : }
1348 :
1349 1628693 : for ( j = 0; j < ndec * ( ndm - 1 ); j++ )
1350 : {
1351 902449 : ivas_huffman_encode( &hMdEnc->huff_coeffs.drct_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].drct_index_re[j], &code, &len );
1352 902449 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1353 : {
1354 7016 : return -1;
1355 : }
1356 895433 : push_next_indice( hMetaData, code, len );
1357 : }
1358 :
1359 2193285 : for ( j = 0; j < ndec; j++ )
1360 : {
1361 1481498 : ivas_huffman_encode( &hMdEnc->huff_coeffs.decd_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].decd_index_re[j], &code, &len );
1362 1481498 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1363 : {
1364 14457 : return -1;
1365 : }
1366 1467041 : push_next_indice( hMetaData, code, len );
1367 : }
1368 : }
1369 :
1370 59122 : return 0;
1371 : }
1372 :
1373 :
1374 : /*-----------------------------------------------------------------------------------------*
1375 : * Function ivas_get_arith_coded_bs()
1376 : *
1377 : * Generate arithmetic coded bitstream
1378 : *-----------------------------------------------------------------------------------------*/
1379 253782 : 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 2271034 : for ( i = 0; i < nB; i++ )
1400 : {
1401 : int16_t ndm, ndec;
1402 2017252 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[bands_bw * i];
1403 2017252 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[bands_bw * i];
1404 :
1405 2017252 : if ( ( ivas_total_brate < IVAS_24k4 ) && ( strat > 3 ) && ( ( ( i % 2 == 1 ) && ( strat % 2 == 0 ) ) || ( ( i % 2 == 0 ) && ( strat % 2 == 1 ) ) ) )
1406 : {
1407 24486 : pred_cell_dims[i].dim1 = 0;
1408 24486 : pred_cell_dims[i].dim2 = 0;
1409 24486 : drct_cell_dims[i].dim1 = 0;
1410 24486 : drct_cell_dims[i].dim2 = 0;
1411 24486 : decd_cell_dims[i].dim1 = 0;
1412 24486 : decd_cell_dims[i].dim2 = 0;
1413 24486 : decx_cell_dims[i].dim1 = 0;
1414 24486 : decx_cell_dims[i].dim2 = 0;
1415 : }
1416 : else
1417 : {
1418 1992766 : pred_cell_dims[i].dim1 = ndm + ndec - 1;
1419 1992766 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1420 : {
1421 145200 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1422 : {
1423 48400 : pred_cell_dims[i].dim1 -= ( FOA_CHANNELS - 1 );
1424 : }
1425 : }
1426 1992766 : pred_cell_dims[i].dim2 = 1;
1427 1992766 : drct_cell_dims[i].dim1 = ndec;
1428 1992766 : drct_cell_dims[i].dim2 = ndm - 1;
1429 1992766 : decd_cell_dims[i].dim1 = ndec;
1430 1992766 : decd_cell_dims[i].dim2 = 1;
1431 1992766 : decx_cell_dims[i].dim1 = ( ndec * ( ndec - 1 ) ) >> 1;
1432 1992766 : decx_cell_dims[i].dim2 = 1;
1433 : }
1434 : }
1435 :
1436 253782 : any_diff = 0;
1437 1614065 : for ( i = 0; i < nB; i++ )
1438 : {
1439 1445096 : if ( pDo_diff[i] != 0 )
1440 : {
1441 84813 : any_diff = 1;
1442 84813 : break;
1443 : }
1444 : }
1445 253782 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1446 : {
1447 157300 : for ( i = 0; i < nB; i++ )
1448 : {
1449 145200 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1450 : {
1451 196960 : for ( j = 0; j < pred_cell_dims[i].dim1; j++ )
1452 : {
1453 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] =
1454 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1455 :
1456 148560 : 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 253782 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, pred_cell_dims, PRED_COEFF );
1466 :
1467 253782 : if ( any_diff == 1 )
1468 : {
1469 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 );
1470 : }
1471 :
1472 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,
1473 253782 : symbol_arr_re, symbol_arr_old_re, pred_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1474 253782 : if ( arith_result < 0 )
1475 : {
1476 969 : return -1;
1477 : }
1478 :
1479 252813 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1480 : {
1481 157300 : for ( i = 0; i < nB; i++ )
1482 : {
1483 145200 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1484 : {
1485 196960 : for ( j = pred_cell_dims[i].dim1 - 1; j >= 0; j-- )
1486 : {
1487 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS] =
1488 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j];
1489 : }
1490 193600 : for ( j = 0; j < DIRAC_TO_SPAR_HBR_PRED_CHS; j++ )
1491 : {
1492 145200 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] = 0;
1493 : }
1494 : }
1495 : }
1496 : }
1497 :
1498 252813 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, drct_cell_dims, DRCT_COEFF );
1499 :
1500 252813 : if ( any_diff == 1 )
1501 : {
1502 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 );
1503 : }
1504 :
1505 :
1506 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,
1507 252813 : symbol_arr_re, symbol_arr_old_re, drct_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1508 252813 : if ( arith_result < 0 )
1509 : {
1510 4 : return -1;
1511 : }
1512 :
1513 252809 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decd_cell_dims, DECD_COEFF );
1514 :
1515 252809 : if ( any_diff == 1 )
1516 : {
1517 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 );
1518 : }
1519 :
1520 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,
1521 252809 : symbol_arr_re, symbol_arr_old_re, decd_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1522 252809 : if ( arith_result < 0 )
1523 : {
1524 26445 : return -1;
1525 : }
1526 :
1527 226364 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decx_cell_dims, DECX_COEFF );
1528 :
1529 226364 : if ( any_diff == 1 )
1530 : {
1531 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 );
1532 : }
1533 :
1534 226364 : return 0;
1535 : }
1536 :
1537 :
1538 : /*-----------------------------------------------------------------------------------------*
1539 : * Function ivas_select_next_strat()
1540 : *
1541 : * Select next strategy
1542 : *-----------------------------------------------------------------------------------------*/
1543 :
1544 156726 : 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 156726 : cs[0] = BASE;
1551 156726 : cs[1] = BASE_NOEC;
1552 156726 : if ( dmx_switch == 0 && dtx_vad )
1553 : {
1554 156726 : switch ( prior_strat )
1555 : {
1556 2607 : case START:
1557 2607 : cs[2] = NO_STRAT;
1558 2607 : break;
1559 58087 : case BASE:
1560 58087 : cs[2] = FOUR_A;
1561 58087 : break;
1562 0 : case BASE_DIFF:
1563 0 : cs[2] = FOUR_A;
1564 0 : break;
1565 2877 : case BASE_NOEC:
1566 2877 : cs[2] = FOUR_A;
1567 2877 : break;
1568 25276 : case FOUR_A:
1569 25276 : cs[2] = FOUR_B;
1570 25276 : break;
1571 23629 : case FOUR_B:
1572 23629 : cs[2] = FOUR_C;
1573 23629 : break;
1574 22567 : case FOUR_C:
1575 22567 : cs[2] = FOUR_D;
1576 22567 : break;
1577 21683 : case FOUR_D:
1578 21683 : cs[2] = FOUR_A;
1579 21683 : break;
1580 0 : default:
1581 0 : assert( !"bad value of prior_strat" );
1582 : }
1583 0 : }
1584 :
1585 156726 : return;
1586 : }
1587 :
1588 :
1589 : /*-----------------------------------------------------------------------------------------*
1590 : * Function ivas_store_prior_coeffs()
1591 : *
1592 : * Store prior coeffs
1593 : *-----------------------------------------------------------------------------------------*/
1594 :
1595 159500 : 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 159500 : if ( dtx_vad == 0 )
1604 : {
1605 3827 : hMdEnc->spar_md_cfg.prior_strat = START;
1606 : }
1607 : else
1608 : {
1609 155673 : hMdEnc->spar_md_cfg.prior_strat = strat;
1610 : }
1611 :
1612 159500 : hMdEnc->spar_md_cfg.prev_quant_idx = qsi;
1613 :
1614 1450054 : for ( i = 0; i < num_bands; i++ )
1615 : {
1616 1290554 : b = i;
1617 :
1618 14196094 : for ( j = 0; j < IVAS_SPAR_MAX_CH - 1; j++ )
1619 : {
1620 12905540 : hMdEnc->spar_md_prior.band_coeffs_idx[i].pred_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[j];
1621 12905540 : 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 28392188 : for ( j = 0; j < IVAS_SPAR_MAX_C_COEFF; j++ )
1624 : {
1625 27101634 : 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 159500 : return;
1630 : }
1631 :
1632 :
1633 : /*-----------------------------------------------------------------------------------------*
1634 : * Function ivas_spar_quant_pred_coeffs_dtx()
1635 : *
1636 : * Calculate quantization pred coeffs
1637 : *-----------------------------------------------------------------------------------------*/
1638 :
1639 7654 : 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 7654 : pr_min_max[0] = pSpar_md->min_max[0];
1652 7654 : pr_min_max[1] = pSpar_md->min_max[1];
1653 :
1654 30616 : for ( i = 0; i < dim1; i++ )
1655 : {
1656 22962 : q_lvl = dtx_pr_real_q_levels[ndm - 1][i];
1657 22962 : ivas_quantise_real_values( &pValues[i], q_lvl, pr_min_max[0], pr_min_max[1], &pIndex[i], &pQuant[i], 1 );
1658 : }
1659 :
1660 7654 : return;
1661 : }
1662 :
1663 :
1664 : /*-----------------------------------------------------------------------------------------*
1665 : * Function ivas_quant_p_per_band_dtx()
1666 : *
1667 : * Calculate quantization p
1668 : *-----------------------------------------------------------------------------------------*/
1669 :
1670 7654 : 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 7654 : int16_t dim = num_ch - num_dmx;
1680 :
1681 7654 : if ( num_dec == num_ch - 1 )
1682 : {
1683 17144 : for ( i = 0; i < dim; i++ )
1684 : {
1685 12858 : if ( pP_mat[i] < pr_boost_range[1] && pP_mat[i] > pr_boost_range[0] )
1686 : {
1687 5565 : pP_mat[i] = pr_boost_range[1];
1688 : }
1689 : }
1690 : }
1691 :
1692 7654 : if ( dim != num_dec )
1693 : {
1694 0 : assert( !"Not Supported!" );
1695 : }
1696 :
1697 27248 : for ( i = 0; i < dim; i++ )
1698 : {
1699 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 );
1700 : }
1701 :
1702 7654 : return;
1703 : }
1704 :
1705 : /*-----------------------------------------------------------------------------------------*
1706 : * Function ivas_write_parameter_bitstream_dtx()
1707 : *
1708 : * Write MD DTX parameters into bitstream
1709 : *-----------------------------------------------------------------------------------------*/
1710 :
1711 3827 : 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 3827 : sid_bits_len = hMetaData->nb_bits_tot;
1726 3827 : pr_min_max[0] = pSpar_md->min_max[0];
1727 3827 : pr_min_max[1] = pSpar_md->min_max[1];
1728 :
1729 11481 : for ( i = 0; i < num_bands; i++ )
1730 : {
1731 7654 : int16_t ndm = num_dmx[i];
1732 7654 : int16_t ndec = num_dec[i];
1733 :
1734 30616 : 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 22962 : pr_idx_1 = pr_pr_idx_pairs[ndm - 1][j][0];
1742 22962 : pr_idx_2 = pr_pr_idx_pairs[ndm - 1][j][1];
1743 22962 : pd_idx_1 = pr_pd_idx_pairs[ndm - 1][j][0];
1744 22962 : pd_idx_2 = pr_pd_idx_pairs[ndm - 1][j][1];
1745 :
1746 22962 : if ( pr_idx_1 != 0 || pd_idx_1 != 0 || pr_idx_2 != 0 || pd_idx_2 != 0 )
1747 : {
1748 22962 : pr_q_lvls = dtx_pr_real_q_levels[ndm - 1][pd_idx_1 - 1];
1749 22962 : pr = pSpar_md->band_coeffs_idx[i].pred_index_re[pd_idx_1 - 1];
1750 :
1751 22962 : if ( ( j + 1 ) > ndec )
1752 : {
1753 3368 : pd_q_lvls = 1;
1754 3368 : pd = 0;
1755 : }
1756 : else
1757 : {
1758 19594 : pd_q_lvls = dtx_pd_real_q_levels[ndm - 1][pd_idx_2 - 1];
1759 19594 : pd = pSpar_md->band_coeffs_idx[i].decd_index_re[pd_idx_2 - 1];
1760 : }
1761 22962 : val = dtx_pd_real_min_max[0];
1762 22962 : 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 22962 : pd -= idx;
1765 :
1766 22962 : val = pr_min_max[0];
1767 22962 : ivas_quantise_real_values( &val, pr_q_lvls, pr_min_max[0], pr_min_max[1], &idx, &val, 1 );
1768 :
1769 22962 : pr -= idx;
1770 22962 : pr_pd_bits = ivas_get_bits_to_encode( pd_q_lvls * pr_q_lvls );
1771 :
1772 22962 : value = (uint16_t) ( pr * pd_q_lvls + pd );
1773 :
1774 22962 : push_next_indice( hMetaData, value, pr_pd_bits );
1775 : }
1776 : }
1777 : }
1778 :
1779 3827 : sid_bits_len = hMetaData->nb_bits_tot - sid_bits_len;
1780 3827 : sba_spar_bitlen = ivas_sba_spar_sid_bitlen( num_dmx[0] );
1781 3827 : zero_pad_bits = sba_spar_bitlen - sid_bits_len;
1782 :
1783 3827 : assert( zero_pad_bits >= 0 );
1784 3827 : if ( num_dmx[0] == 2 )
1785 : {
1786 1684 : zero_pad_bits -= 1;
1787 : }
1788 :
1789 5511 : while ( zero_pad_bits > 0 )
1790 : {
1791 1684 : j = min( zero_pad_bits, 16 );
1792 1684 : push_next_indice( hMetaData, 0, j );
1793 1684 : zero_pad_bits -= j;
1794 : }
1795 :
1796 3827 : return;
1797 : }
1798 :
1799 :
1800 : /*-----------------------------------------------------------------------------------------*
1801 : * Function ivas_quant_pred_coeffs_per_band()
1802 : *
1803 : * Quantization of prediction coefficients
1804 : *-----------------------------------------------------------------------------------------*/
1805 :
1806 1289776 : 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 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 ) );
1813 :
1814 1289776 : 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 848624 : 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 848624 : k = 0;
1835 2981400 : for ( i = 0; i < ndec; i++ )
1836 : {
1837 6980264 : for ( j = 0; j < ndm - 1; j++ )
1838 : {
1839 4847488 : C_re[k] = pband_coeffs->C_re[i][j];
1840 4847488 : k++;
1841 : }
1842 : }
1843 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 ) );
1844 848624 : k = 0;
1845 2981400 : for ( i = 0; i < ndec; i++ )
1846 : {
1847 6980264 : for ( j = 0; j < ndm - 1; j++ )
1848 : {
1849 4847488 : pband_coeffs->C_quant_re[i][j] = C_re[k];
1850 4847488 : k++;
1851 : }
1852 : }
1853 :
1854 848624 : 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 1136736 : 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 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 );
1871 :
1872 1136736 : return;
1873 : }
|
