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 4141 : 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 4141 : error = IVAS_ERR_OK;
112 :
113 4141 : 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 4141 : num_channels = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
119 :
120 4141 : 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 4141 : 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 24452 : for ( i = 0; i < num_channels; i++ )
129 : {
130 20311 : 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 137032 : for ( j = 0; j < num_channels; j++ )
135 : {
136 116721 : 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 4141 : 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 24452 : for ( i = 0; i < num_channels; i++ )
148 : {
149 20311 : 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 137032 : for ( j = 0; j < num_channels; j++ )
154 : {
155 116721 : 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 4141 : if ( ( error = ivas_spar_md_enc_init( hMdEnc, hEncoderConfig, sba_order ) ) != IVAS_ERR_OK )
163 : {
164 0 : return error;
165 : }
166 :
167 4141 : *hMdEnc_in = hMdEnc;
168 :
169 4141 : return error;
170 : }
171 :
172 :
173 : /*-------------------------------------------------------------------------
174 : * ivas_spar_md_enc_close()
175 : *
176 : * Deallocate SPAR MD encoder handle
177 : *------------------------------------------------------------------------*/
178 :
179 4141 : 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 4141 : if ( hMdEnc_in == NULL || *hMdEnc_in == NULL )
187 : {
188 0 : return;
189 : }
190 :
191 4141 : hMdEnc = *hMdEnc_in;
192 4141 : num_channels = hMdEnc->num_umx_ch;
193 :
194 4141 : if ( hMdEnc->spar_md.band_coeffs != NULL )
195 : {
196 4141 : free( hMdEnc->spar_md.band_coeffs );
197 4141 : hMdEnc->spar_md.band_coeffs = NULL;
198 : }
199 4141 : if ( hMdEnc->mixer_mat != NULL )
200 : {
201 24452 : for ( i = 0; i < num_channels; i++ )
202 : {
203 137032 : for ( j = 0; j < num_channels; j++ )
204 : {
205 116721 : free( hMdEnc->mixer_mat[i][j] );
206 : }
207 20311 : free( hMdEnc->mixer_mat[i] );
208 : }
209 4141 : free( hMdEnc->mixer_mat );
210 : }
211 :
212 4141 : if ( hMdEnc->mixer_mat_local != NULL )
213 : {
214 24452 : for ( i = 0; i < num_channels; i++ )
215 : {
216 :
217 137032 : for ( j = 0; j < num_channels; j++ )
218 : {
219 116721 : free( hMdEnc->mixer_mat_local[i][j] );
220 : }
221 20311 : free( hMdEnc->mixer_mat_local[i] );
222 : }
223 4141 : free( hMdEnc->mixer_mat_local );
224 : }
225 :
226 4141 : free( *hMdEnc_in );
227 4141 : *hMdEnc_in = NULL;
228 :
229 4141 : return;
230 : }
231 :
232 :
233 : /*-----------------------------------------------------------------------------------------*
234 : * Function ivas_spar_md_enc_init()
235 : *
236 : * SPAR MD encoder initialization
237 : *-----------------------------------------------------------------------------------------*/
238 :
239 4489 : 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 4489 : 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 4489 : num_channels = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
252 4489 : ivas_sba_get_spar_hoa_ch_ind( num_channels, hEncoderConfig->ivas_total_brate, hMdEnc->HOA_md_ind );
253 4489 : table_idx = ivas_get_spar_table_idx( hEncoderConfig->ivas_total_brate, sba_order, SPAR_CONFIG_BW, NULL, NULL );
254 :
255 4489 : hMdEnc->spar_md.prior_dyn_active_w_flag = 0;
256 :
257 : #ifndef DEBUG_AGC_ENCODER_CMD_OPTION
258 4489 : 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 4489 : 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 58357 : for ( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
267 : {
268 53868 : pFC[i] = ivas_fb_fcs_12band_1ms[i] * hEncoderConfig->input_Fs * 0.5f;
269 : }
270 :
271 4489 : 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 4489 : 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 4489 : ivas_spar_arith_coeffs_com_init( &hMdEnc->arith_coeffs, &hMdEnc->spar_md_cfg, table_idx, ENC );
279 4489 : ivas_spar_huff_coeffs_com_init( &hMdEnc->huff_coeffs, NULL, table_idx, ENC );
280 :
281 4489 : if ( hEncoderConfig->Opt_DTX_ON == 1 )
282 : {
283 : /* DTX quant init */
284 346 : PR_minmax[0] = hMdEnc->spar_md_cfg.quant_strat[0].PR.min;
285 346 : PR_minmax[1] = hMdEnc->spar_md_cfg.quant_strat[0].PR.max;
286 346 : ivas_spar_quant_dtx_init( &hMdEnc->spar_md, PR_minmax );
287 : }
288 :
289 4489 : hMdEnc->spar_md_cfg.prior_strat = START;
290 4489 : hMdEnc->spar_md_cfg.prev_quant_idx = -1;
291 :
292 26192 : for ( i = 0; i < num_channels; i++ )
293 : {
294 143992 : for ( j = 0; j < num_channels; j++ )
295 : {
296 1589757 : for ( k = 0; k < IVAS_MAX_NUM_BANDS; k++ )
297 : {
298 1467468 : hMdEnc->mixer_mat[i][j][k] = 0;
299 : }
300 : }
301 : }
302 :
303 4489 : ivas_clear_band_coeffs( hMdEnc->spar_md.band_coeffs, IVAS_MAX_NUM_BANDS );
304 4489 : ivas_clear_band_coeff_idx( hMdEnc->spar_md.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
305 4489 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
306 4489 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, IVAS_MAX_NUM_BANDS );
307 :
308 4489 : 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 4489 : 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 15689 : for ( i = 0; i < nchan_transport; i++ )
329 : {
330 11200 : if ( max_freq_per_chan != NULL )
331 : {
332 11200 : 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 4489 : hMdEnc->num_umx_ch = nchan_inp;
340 4489 : hMdEnc->num_decorr = nchan_inp - 1;
341 :
342 58357 : for ( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
343 : {
344 53868 : tmp_dmx_ch = 0;
345 188268 : for ( j = 0; j < nchan_transport; j++ )
346 : {
347 134400 : if ( pFC[i] < hMdEnc->spar_md_cfg.max_freq_per_chan[j] )
348 : {
349 134400 : tmp_dmx_ch += 1;
350 : }
351 : }
352 :
353 53868 : hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i] = tmp_dmx_ch;
354 53868 : hMdEnc->spar_md_cfg.num_decorr_per_band[i] = hMdEnc->num_umx_ch - tmp_dmx_ch;
355 : }
356 :
357 4489 : return;
358 : }
359 :
360 :
361 : /*-----------------------------------------------------------------------------------------*
362 : * Function ivas_band_limit_dmx_matrix()
363 : *
364 : * Band limit downmix matrix
365 : *-----------------------------------------------------------------------------------------*/
366 :
367 353174 : 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 3310436 : for ( b = 0; b < num_bands; b++ )
376 : {
377 2957262 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
378 :
379 10215472 : for ( i = ndm; i < num_ch; i++ )
380 : {
381 60395210 : for ( j = 0; j < num_ch; j++ )
382 : {
383 53137000 : hMdEnc->mixer_mat[i][j][b] = 0;
384 : }
385 : }
386 : }
387 :
388 353174 : return;
389 : }
390 :
391 :
392 : /*-----------------------------------------------------------------------------------------*
393 : * Function ivas_band_mixing()
394 : *
395 : * Band mixing downmix matrix
396 : *-----------------------------------------------------------------------------------------*/
397 :
398 31392 : 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 31392 : red_band_fact = upmixed_bands / num_bands;
409 :
410 64660 : for ( i = 0; i < nchan_transport; i++ )
411 : {
412 166340 : for ( j = 0; j < num_ch; j++ )
413 : {
414 617384 : for ( k = num_bands - 1; k >= 0; k-- )
415 : {
416 1548888 : for ( b = red_band_fact - 1; b >= 0; b-- )
417 : {
418 1064576 : hMdEnc->mixer_mat[i][j][red_band_fact * k + b] = hMdEnc->mixer_mat[i][j][k];
419 : }
420 : }
421 133072 : 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 31392 : return;
428 : }
429 :
430 :
431 : /*-----------------------------------------------------------------------------------------*
432 : * Function write_metadata_buffer()
433 : *
434 : *
435 : *-----------------------------------------------------------------------------------------*/
436 :
437 485248 : 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 485248 : if ( hMetaData->nb_bits_tot > 0 )
446 : {
447 485248 : restore_metadata_buffer( hMetaData, next_ind_start, bit_pos_start );
448 : }
449 :
450 92687063 : 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 92201815 : push_next_indice( hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
456 : #endif
457 : }
458 :
459 485248 : return;
460 : }
461 :
462 :
463 : /*-----------------------------------------------------------------------------------------*
464 : * Function ivas_spar_md_enc_process()
465 : *
466 : * SPAR FoA Meta Data generation process
467 : *-----------------------------------------------------------------------------------------*/
468 :
469 351475 : 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 351475 : 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 351475 : md_indices_allocated = hMdEnc->spar_md_cfg.max_bits_per_blk + IVAS_SPAR_ARITH_OVERSHOOT_BITS;
502 351475 : 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 351475 : num_quant_strats = hMdEnc->spar_md_cfg.num_quant_strats;
508 351475 : num_ch = ivas_sba_get_nchan_metadata( sba_order, hEncoderConfig->ivas_total_brate );
509 351475 : active_w = ( hMdEnc->spar_md_cfg.active_w == 1 ) || ( dyn_active_w_flag == 1 );
510 351475 : nchan_transport = hMdEnc->spar_md_cfg.nchan_transport;
511 :
512 351475 : bwidth = ivas_get_bw_idx_from_sample_rate( hEncoderConfig->input_Fs );
513 351475 : bwidth = min( bwidth, hEncoderConfig->max_bwidth );
514 : int16_t active_w_vlbr;
515 351475 : active_w_vlbr = ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) ? 1 : 0;
516 351475 : num_bands = ivas_get_num_bands_from_bw_idx( SPAR_CONFIG_BW );
517 351475 : if ( hMdEnc->spar_hoa_md_flag == 0 )
518 : {
519 285055 : num_bands = min( num_bands, SPAR_DIRAC_SPLIT_START_BAND );
520 : }
521 351475 : num_bands_full = num_bands;
522 351475 : num_bands_bw = ivas_get_num_bands_from_bw_idx( bwidth );
523 :
524 351475 : if ( dtx_vad == 0 )
525 : {
526 20605 : for ( i = 0; i < nchan_inp; i++ )
527 : {
528 82420 : for ( j = 0; j < nchan_inp; j++ )
529 : {
530 65936 : cov_real[i][j] = cov_dtx_real[i][j];
531 : }
532 : }
533 : }
534 :
535 2100875 : for ( i = 0; i < nchan_inp; i++ )
536 : {
537 12129680 : for ( j = 0; j < nchan_inp; j++ )
538 : {
539 12206240 : for ( k = num_bands_bw; k < IVAS_MAX_NUM_BANDS; k++ )
540 : {
541 1825960 : cov_real[i][j][k] = 0;
542 : }
543 : }
544 : }
545 :
546 351475 : 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 40320 : num_quant_strats = 1;
550 : }
551 :
552 351475 : hMetaData_tmp.ind_list = ind_list_tmp;
553 351475 : hMetaData_tmp.nb_bits_tot = 0;
554 351475 : max_num_indices_tmp = MAX_BITS_METADATA;
555 351475 : hMetaData_tmp.ivas_max_num_indices = &max_num_indices_tmp;
556 351475 : hMetaData_tmp.ivas_ind_list_zero = (Indice **) ( &hMetaData_tmp.ind_list );
557 351475 : hMetaData_tmp.st_ivas = NULL;
558 :
559 : /* Save state of metadata bitstream buffer */
560 351475 : bit_pos_start = hMetaData->nb_bits_tot;
561 351475 : next_ind_start = hMetaData->nb_ind_tot;
562 :
563 351475 : dmx_switch = 0;
564 :
565 351475 : if ( dtx_vad == 0 )
566 : {
567 4121 : nB = SPAR_DTX_BANDS;
568 4121 : bands_bw = num_bands / nB;
569 :
570 4121 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
571 : }
572 347354 : else if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
573 : {
574 26424 : bands_bw = 2;
575 26424 : nB = num_bands / bands_bw;
576 :
577 26424 : ivas_band_mixer( cov_real, num_ch, &num_bands, bands_bw );
578 : }
579 : else
580 : {
581 320930 : nB = num_bands;
582 320930 : bands_bw = 1;
583 : }
584 351475 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
585 : {
586 154900 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
587 : {
588 495680 : for ( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
589 : {
590 371760 : pred_coeffs_re_local[i][b] = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
591 : }
592 : }
593 : }
594 :
595 351475 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
596 : {
597 246762 : for ( b = 0; b < num_bands * bands_bw; b++ )
598 : {
599 219344 : mvr2r( hMdEnc->spar_md.band_coeffs[b].P_quant_re, P_quant_re_prior[b], FOA_CHANNELS - 1 );
600 : }
601 : }
602 :
603 351475 : 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 351475 : if ( dirac_mono_flag )
606 : {
607 : int16_t i_ts;
608 64 : int16_t num_md_sub_frames = 1;
609 :
610 64 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
611 64 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
612 :
613 128 : for ( i_ts = 0; i_ts < num_md_sub_frames; i_ts++ )
614 : {
615 832 : for ( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
616 : {
617 3072 : for ( j = 0; j < ndm + ndec - 1; j++ )
618 : {
619 2304 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].pred_re[j] = 0.0f;
620 : }
621 1536 : for ( j = 0; j < ndec; j++ )
622 : {
623 2304 : for ( k = 0; k < ndm - 1; k++ )
624 : {
625 1536 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].C_re[j][k] = 0.0f;
626 : }
627 : }
628 :
629 1536 : for ( j = 0; j < ndec; j++ )
630 : {
631 768 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].P_re[j] = 0.0f;
632 : }
633 : }
634 : }
635 : }
636 :
637 2100875 : for ( i = 0; i < num_ch; i++ )
638 : {
639 12129680 : for ( j = 0; j < num_ch; j++ )
640 : {
641 114613368 : for ( b = 0; b < num_bands; b++ )
642 : {
643 104233088 : 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 351475 : 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 353174 : 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 3310436 : for ( b = 0; b < num_bands; b++ )
664 : {
665 2957262 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
666 2957262 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
667 :
668 2957262 : if ( dtx_vad == 1 )
669 : {
670 2949020 : if ( ndm != num_ch )
671 : {
672 2353180 : 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 2949020 : 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 2949020 : if ( active_w_vlbr )
676 : {
677 436336 : for ( i = 0; i < 3; i++ )
678 : {
679 : int16_t i2;
680 327252 : i2 = 0;
681 327252 : switch ( i ) /* PRED (Y,Z,X) and DECD (Y,X,Z) coeffs are in different orders */
682 : {
683 109084 : case 0:
684 109084 : i2 = 0;
685 109084 : break;
686 109084 : case 1:
687 109084 : i2 = 2;
688 109084 : break;
689 109084 : case 2:
690 109084 : i2 = 1;
691 109084 : break;
692 : }
693 327252 : 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 17875 : qs = hMdEnc->spar_md_cfg.quant_strat[qsi];
699 17875 : PR_uq = hMdEnc->spar_md.band_coeffs[b].pred_re[i];
700 17875 : PR_step = ( qs.PR.max - qs.PR.min ) / ( qs.PR.q_levels[0] - 1 );
701 :
702 : int16_t PR_sign;
703 17875 : PR_sign = ( PR_uq > 0 ) - ( PR_uq < 0 );
704 :
705 17875 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = PR_sign;
706 :
707 : /* deindex the modified coefficient */
708 17875 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = PR_sign * PR_step;
709 : }
710 : }
711 : }
712 : }
713 : else
714 : {
715 8242 : if ( ndm != num_ch )
716 : {
717 8242 : 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 32968 : for ( i = 0; i < num_ch - 1; i++ )
721 : {
722 24726 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
723 : }
724 8242 : 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 1756196 : for ( i = 0; i < num_ch - 1; i++ )
729 : {
730 14396808 : for ( b = 0; b < num_bands; b++ )
731 : {
732 12993786 : pred_coeffs_re[i][b] = Wscale[b] * hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i];
733 : }
734 : }
735 :
736 353174 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
737 : {
738 154900 : for ( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
739 : {
740 495680 : 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 371760 : pred_coeffs_re[i][b] = pred_coeffs_re_local[i][b];
744 371760 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re[i] = 0;
745 371760 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = 0;
746 : }
747 : }
748 : }
749 :
750 353174 : 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 3310436 : for ( b = 0; b < num_bands; b++ )
753 : {
754 2957262 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
755 2957262 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
756 :
757 18908310 : for ( i = 0; i < num_ch; i++ )
758 : {
759 15951048 : hMdEnc->mixer_mat[0][i][b] *= Wscale[b];
760 : }
761 :
762 2957262 : if ( ( ndm != num_ch ) && ( ndm != 1 ) )
763 : {
764 1903744 : 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 1903744 : if ( dirac_mono_flag )
767 : {
768 512 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
769 512 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
770 1024 : for ( j = 0; j < ndec; j++ )
771 : {
772 1536 : for ( k = 0; k < ndm - 1; k++ )
773 : {
774 1024 : hMdEnc->spar_md.band_coeffs[b].C_re[j][k] = 0.0f;
775 : }
776 : }
777 : }
778 : #ifdef SPAR_HOA_DBG
779 : /*fprintf(stderr, "\n\n C coefficients: band %d\n", b);
780 :
781 : for (i = 0; i < num_ch - ndm; i++)
782 : {
783 : for (j = 0; j < ndm - 1; j++)
784 : {
785 : fprintf(stderr, "%f, ", hMdEnc->spar_md.band_coeffs[b].C_re[i][j]);
786 : }
787 : fprintf(stderr, "\n");
788 : }
789 : fprintf(stderr, "\n\n"); */
790 : #endif
791 :
792 1903744 : ivas_quant_c_per_band( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b],
793 1903744 : &hMdEnc->spar_md_cfg.quant_strat[qsi], ndec, ndm );
794 : }
795 : }
796 :
797 : /* band limit downmix matrix */
798 353174 : ivas_band_limit_dmx_matrix( hMdEnc, num_ch, num_bands, bands_bw );
799 :
800 : /* band mixing */
801 353174 : if ( bands_bw > 1 )
802 : {
803 31392 : ivas_band_mixing( hMdEnc, num_ch, num_bands, nchan_transport, num_bands_full );
804 : }
805 :
806 353174 : if ( dtx_vad == 0 )
807 : {
808 4121 : 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 4121 : break;
810 : }
811 :
812 349053 : ivas_select_next_strat( hMdEnc->spar_md_cfg.prior_strat, cs, dmx_switch, dtx_vad );
813 :
814 768425 : for ( i = 0; i < MAX_CODING_STRATS; i++ )
815 : {
816 709439 : strat = cs[i];
817 709439 : if ( strat != NO_STRAT )
818 : {
819 705473 : reset_indices_enc( &hMetaData_tmp, md_indices_allocated );
820 :
821 705473 : 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 705473 : if ( hMetaData_tmp.nb_bits_tot > 0 )
825 : {
826 579903 : if ( hMetaData->nb_bits_tot == bit_pos_start || hMetaData_tmp.nb_bits_tot < ( hMetaData->nb_bits_tot - bit_pos_start ) )
827 : {
828 485248 : write_metadata_buffer( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start );
829 485248 : code_strat = strat;
830 : }
831 :
832 579903 : 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 290067 : packed_ok = 1;
835 290067 : break;
836 : }
837 : }
838 : }
839 : }
840 :
841 349053 : if ( packed_ok == 1 )
842 : {
843 290067 : break;
844 : }
845 :
846 : /*only if valid bitstream was written to main buffer*/
847 58986 : if ( hMetaData->nb_bits_tot > bit_pos_start )
848 : {
849 57287 : 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 57287 : packed_ok = 1;
852 57287 : 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 351475 : if ( hEncoderConfig->ivas_total_brate < IVAS_24k4 )
870 : {
871 135102 : for ( k = num_bands - 1; k >= 0; k-- )
872 : {
873 327028 : for ( b = bands_bw - 1; b >= 0; b-- )
874 : {
875 219344 : 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 351475 : if ( ( hEncoderConfig->ivas_total_brate < IVAS_24k4 ) && ( code_strat > 3 ) )
881 : {
882 76734 : for ( b = 0; b < num_bands * bands_bw; b += 2 * bands_bw )
883 : {
884 51156 : if ( ( b == 0 ) && ( code_strat % 2 == 0 ) )
885 : {
886 13204 : b += 2;
887 : }
888 102312 : for ( i = 0; i < 1; i++ )
889 : {
890 255780 : for ( j = 0; j < 4; j++ )
891 : {
892 204624 : hMdEnc->mixer_mat[i][j][b] = prior_mixer[i][j][b];
893 204624 : hMdEnc->mixer_mat[i][j][b + 1] = prior_mixer[i][j][b + 1];
894 : }
895 : }
896 :
897 51156 : mvr2r( P_quant_re_prior[b], hMdEnc->spar_md.band_coeffs[b].P_quant_re, FOA_CHANNELS - 1 );
898 51156 : 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 351475 : ivas_store_prior_coeffs( hMdEnc, num_bands, code_strat, dtx_vad, qsi );
1108 :
1109 351475 : hMdEnc->spar_md.dtx_vad = dtx_vad;
1110 351475 : hMdEnc->spar_md.num_bands = num_bands;
1111 :
1112 351475 : free( ind_list_tmp );
1113 :
1114 351475 : return IVAS_ERR_OK;
1115 : }
1116 :
1117 :
1118 : /*-----------------------------------------------------------------------------------------*
1119 : * Function ivas_band_mixer()
1120 : *
1121 : * band mixer
1122 : *-----------------------------------------------------------------------------------------*/
1123 :
1124 30545 : 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 30545 : orig_band = *num_bands;
1134 30545 : *num_bands /= red_band_fact;
1135 30545 : rem_band = orig_band - ( *num_bands * red_band_fact );
1136 :
1137 152725 : for ( i = 0; i < num_ch; i++ )
1138 : {
1139 610900 : for ( j = 0; j < num_ch; j++ )
1140 : {
1141 1823008 : for ( k = 0; k < *num_bands - 1; k++ )
1142 : {
1143 1334288 : avg_cov = 0.0f;
1144 4134736 : for ( b = 0; b < red_band_fact; b++ )
1145 : {
1146 2800448 : avg_cov += cov_real[i][j][red_band_fact * k + b];
1147 : }
1148 1334288 : cov_real[i][j][k] = avg_cov;
1149 : }
1150 :
1151 488720 : avg_cov = 0.0f;
1152 1598032 : for ( b = 0; b < red_band_fact + rem_band; b++ )
1153 : {
1154 1109312 : avg_cov += cov_real[i][j][red_band_fact * ( *num_bands - 1 ) + b];
1155 : }
1156 :
1157 488720 : cov_real[i][j][*num_bands - 1] = avg_cov;
1158 : }
1159 : }
1160 :
1161 30545 : return;
1162 : }
1163 :
1164 :
1165 : /*-----------------------------------------------------------------------------------------*
1166 : * Function ivas_write_spar_md_bitstream()
1167 : *
1168 : * Write MD parameters into bitstream
1169 : *-----------------------------------------------------------------------------------------*/
1170 :
1171 705473 : 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 705473 : if ( strat == NO_STRAT )
1185 : {
1186 0 : return;
1187 : }
1188 :
1189 : /* write quant strat */
1190 705473 : if ( ivas_total_brate >= BRATE_SPAR_Q_STRAT )
1191 : {
1192 152474 : push_next_indice( hMetaData, qsi >> 1, hMdEnc->spar_md_cfg.quant_strat_bits - 1 );
1193 : }
1194 : else
1195 : {
1196 552999 : push_next_indice( hMetaData, qsi, hMdEnc->spar_md_cfg.quant_strat_bits );
1197 : }
1198 :
1199 705473 : no_ec = 0;
1200 :
1201 705473 : if ( ivas_total_brate < IVAS_24k4 )
1202 : {
1203 80120 : switch ( strat )
1204 : {
1205 27271 : case BASE:
1206 27271 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1207 27271 : break;
1208 27271 : case BASE_NOEC:
1209 27271 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1210 27271 : no_ec = 1;
1211 27271 : break;
1212 25578 : case FOUR_A:
1213 : case FOUR_C:
1214 : case FOUR_B:
1215 : case FOUR_D:
1216 25578 : push_next_indice( hMetaData, strat, SPAR_NUM_CODING_STRAT_BITS );
1217 25578 : break;
1218 : }
1219 : /* for LBR SBA 40MS MD never do time diff */
1220 400600 : for ( i = 0; i < nB; i++ )
1221 : {
1222 320480 : do_diff[i] = 0;
1223 : }
1224 : }
1225 : else
1226 : {
1227 625353 : switch ( strat )
1228 : {
1229 321782 : case BASE:
1230 321782 : push_next_indice( hMetaData, bands_bw - 1, SPAR_NUM_CODING_STRAT_BITS );
1231 3161718 : for ( i = 0; i < nB; i++ )
1232 : {
1233 2839936 : do_diff[i] = 0;
1234 : }
1235 321782 : break;
1236 158709 : case BASE_NOEC:
1237 158709 : push_next_indice( hMetaData, bands_bw + 1, SPAR_NUM_CODING_STRAT_BITS );
1238 1428381 : for ( i = 0; i < nB; i++ )
1239 : {
1240 1269672 : do_diff[i] = 0;
1241 : }
1242 158709 : no_ec = 1;
1243 158709 : break;
1244 40297 : case FOUR_A:
1245 40297 : push_next_indice( hMetaData, 4, SPAR_NUM_CODING_STRAT_BITS );
1246 362673 : for ( i = 0; i < nB; i++ )
1247 : {
1248 322376 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 0 );
1249 : }
1250 40297 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1251 40297 : break;
1252 36540 : case FOUR_B:
1253 36540 : push_next_indice( hMetaData, 5, SPAR_NUM_CODING_STRAT_BITS );
1254 328860 : for ( i = 0; i < nB; i++ )
1255 : {
1256 292320 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 1 );
1257 : }
1258 36540 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1259 36540 : break;
1260 34691 : case FOUR_C:
1261 34691 : push_next_indice( hMetaData, 6, SPAR_NUM_CODING_STRAT_BITS );
1262 312219 : for ( i = 0; i < nB; i++ )
1263 : {
1264 277528 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 2 );
1265 : }
1266 34691 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1267 34691 : break;
1268 33334 : case FOUR_D:
1269 33334 : push_next_indice( hMetaData, 7, SPAR_NUM_CODING_STRAT_BITS );
1270 300006 : for ( i = 0; i < nB; i++ )
1271 : {
1272 266672 : do_diff[i] = ( ( ( i + 1 ) & 3 ) != 3 );
1273 : }
1274 33334 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1275 33334 : break;
1276 : }
1277 705473 : }
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 705473 : if ( no_ec == 1 )
1286 : {
1287 : entropy_coding_result =
1288 185980 : ivas_get_huffman_coded_bs( hMdEnc, hMetaData, nB, qsi,
1289 : bands_bw );
1290 : }
1291 : else
1292 : {
1293 : entropy_coding_result =
1294 519493 : ivas_get_arith_coded_bs( hMdEnc, hMetaData, do_diff, bands_bw, nB, qsi,
1295 : strat, ivas_total_brate );
1296 : }
1297 :
1298 705473 : if ( entropy_coding_result < 0 )
1299 : {
1300 125570 : hMetaData->nb_bits_tot = 0;
1301 : }
1302 :
1303 705473 : return;
1304 : }
1305 :
1306 :
1307 : /*-----------------------------------------------------------------------------------------*
1308 : * Function ivas_get_huffman_coded_bs()
1309 : *
1310 : * Generate huffman coded bitstream
1311 : *-----------------------------------------------------------------------------------------*/
1312 185980 : 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 1480682 : for ( i = 0; i < nB; i++ )
1323 : {
1324 : int16_t code, len;
1325 : int16_t ndm, ndec;
1326 1367402 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i * bands_bw];
1327 1367402 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[i * bands_bw];
1328 :
1329 1367402 : pred_coeff_dim = ndm + ndec - 1;
1330 1367402 : pred_offset = 0;
1331 1367402 : 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 5405701 : for ( j = pred_offset; j < pred_coeff_dim; j++ )
1340 : {
1341 4076380 : ivas_huffman_encode( &hMdEnc->huff_coeffs.pred_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j], &code, &len );
1342 4076380 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1343 : {
1344 72700 : return -1;
1345 : }
1346 4038299 : push_next_indice( hMetaData, code, len );
1347 : }
1348 :
1349 2983790 : for ( j = 0; j < ndec * ( ndm - 1 ); j++ )
1350 : {
1351 1664617 : ivas_huffman_encode( &hMdEnc->huff_coeffs.drct_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].drct_index_re[j], &code, &len );
1352 1664617 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1353 : {
1354 10148 : return -1;
1355 : }
1356 1654469 : push_next_indice( hMetaData, code, len );
1357 : }
1358 :
1359 3847514 : for ( j = 0; j < ndec; j++ )
1360 : {
1361 2552812 : ivas_huffman_encode( &hMdEnc->huff_coeffs.decd_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].decd_index_re[j], &code, &len );
1362 2552812 : if ( ( hMetaData->nb_bits_tot + len ) > hMdEnc->spar_md_cfg.max_bits_per_blk )
1363 : {
1364 24471 : return -1;
1365 : }
1366 2528341 : push_next_indice( hMetaData, code, len );
1367 : }
1368 : }
1369 :
1370 113280 : return 0;
1371 : }
1372 :
1373 :
1374 : /*-----------------------------------------------------------------------------------------*
1375 : * Function ivas_get_arith_coded_bs()
1376 : *
1377 : * Generate arithmetic coded bitstream
1378 : *-----------------------------------------------------------------------------------------*/
1379 519493 : 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 4729721 : for ( i = 0; i < nB; i++ )
1400 : {
1401 : int16_t ndm, ndec;
1402 4210228 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[bands_bw * i];
1403 4210228 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[bands_bw * i];
1404 :
1405 4210228 : if ( ( ivas_total_brate < IVAS_24k4 ) && ( strat > 3 ) && ( ( ( i % 2 == 1 ) && ( strat % 2 == 0 ) ) || ( ( i % 2 == 0 ) && ( strat % 2 == 1 ) ) ) )
1406 : {
1407 51156 : pred_cell_dims[i].dim1 = 0;
1408 51156 : pred_cell_dims[i].dim2 = 0;
1409 51156 : drct_cell_dims[i].dim1 = 0;
1410 51156 : drct_cell_dims[i].dim2 = 0;
1411 51156 : decd_cell_dims[i].dim1 = 0;
1412 51156 : decd_cell_dims[i].dim2 = 0;
1413 51156 : decx_cell_dims[i].dim1 = 0;
1414 51156 : decx_cell_dims[i].dim2 = 0;
1415 : }
1416 : else
1417 : {
1418 4159072 : pred_cell_dims[i].dim1 = ndm + ndec - 1;
1419 4159072 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1420 : {
1421 371760 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1422 : {
1423 123920 : pred_cell_dims[i].dim1 -= ( FOA_CHANNELS - 1 );
1424 : }
1425 : }
1426 4159072 : pred_cell_dims[i].dim2 = 1;
1427 4159072 : drct_cell_dims[i].dim1 = ndec;
1428 4159072 : drct_cell_dims[i].dim2 = ndm - 1;
1429 4159072 : decd_cell_dims[i].dim1 = ndec;
1430 4159072 : decd_cell_dims[i].dim2 = 1;
1431 4159072 : decx_cell_dims[i].dim1 = ( ndec * ( ndec - 1 ) ) >> 1;
1432 4159072 : decx_cell_dims[i].dim2 = 1;
1433 : }
1434 : }
1435 :
1436 519493 : any_diff = 0;
1437 3607365 : for ( i = 0; i < nB; i++ )
1438 : {
1439 3232734 : if ( pDo_diff[i] != 0 )
1440 : {
1441 144862 : any_diff = 1;
1442 144862 : break;
1443 : }
1444 : }
1445 519493 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1446 : {
1447 402740 : for ( i = 0; i < nB; i++ )
1448 : {
1449 371760 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1450 : {
1451 540640 : for ( j = 0; j < pred_cell_dims[i].dim1; j++ )
1452 : {
1453 416720 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] =
1454 416720 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1455 :
1456 416720 : 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 519493 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, pred_cell_dims, PRED_COEFF );
1466 :
1467 519493 : if ( any_diff == 1 )
1468 : {
1469 144862 : 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 519493 : 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 519493 : symbol_arr_re, symbol_arr_old_re, pred_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1474 519493 : if ( arith_result < 0 )
1475 : {
1476 5268 : return -1;
1477 : }
1478 :
1479 514225 : if ( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1480 : {
1481 402740 : for ( i = 0; i < nB; i++ )
1482 : {
1483 371760 : if ( i >= SPAR_DIRAC_SPLIT_START_BAND )
1484 : {
1485 540640 : for ( j = pred_cell_dims[i].dim1 - 1; j >= 0; j-- )
1486 : {
1487 416720 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS] =
1488 416720 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j];
1489 : }
1490 495680 : for ( j = 0; j < DIRAC_TO_SPAR_HBR_PRED_CHS; j++ )
1491 : {
1492 371760 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] = 0;
1493 : }
1494 : }
1495 : }
1496 : }
1497 :
1498 514225 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, drct_cell_dims, DRCT_COEFF );
1499 :
1500 514225 : if ( any_diff == 1 )
1501 : {
1502 144862 : 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 514225 : 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 514225 : symbol_arr_re, symbol_arr_old_re, drct_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1508 514225 : if ( arith_result < 0 )
1509 : {
1510 4 : return -1;
1511 : }
1512 :
1513 514221 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decd_cell_dims, DECD_COEFF );
1514 :
1515 514221 : if ( any_diff == 1 )
1516 : {
1517 144858 : 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 514221 : 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 514221 : symbol_arr_re, symbol_arr_old_re, decd_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1522 514221 : if ( arith_result < 0 )
1523 : {
1524 47598 : return -1;
1525 : }
1526 :
1527 466623 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decx_cell_dims, DECX_COEFF );
1528 :
1529 466623 : if ( any_diff == 1 )
1530 : {
1531 143750 : 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 466623 : return 0;
1535 : }
1536 :
1537 :
1538 : /*-----------------------------------------------------------------------------------------*
1539 : * Function ivas_select_next_strat()
1540 : *
1541 : * Select next strategy
1542 : *-----------------------------------------------------------------------------------------*/
1543 :
1544 349053 : 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 349053 : cs[0] = BASE;
1551 349053 : cs[1] = BASE_NOEC;
1552 349053 : if ( dmx_switch == 0 && dtx_vad )
1553 : {
1554 349053 : switch ( prior_strat )
1555 : {
1556 5766 : case START:
1557 5766 : cs[2] = NO_STRAT;
1558 5766 : break;
1559 166673 : case BASE:
1560 166673 : cs[2] = FOUR_A;
1561 166673 : break;
1562 0 : case BASE_DIFF:
1563 0 : cs[2] = FOUR_A;
1564 0 : break;
1565 12127 : case BASE_NOEC:
1566 12127 : cs[2] = FOUR_A;
1567 12127 : break;
1568 43841 : case FOUR_A:
1569 43841 : cs[2] = FOUR_B;
1570 43841 : break;
1571 41570 : case FOUR_B:
1572 41570 : cs[2] = FOUR_C;
1573 41570 : break;
1574 40206 : case FOUR_C:
1575 40206 : cs[2] = FOUR_D;
1576 40206 : break;
1577 38870 : case FOUR_D:
1578 38870 : cs[2] = FOUR_A;
1579 38870 : break;
1580 0 : default:
1581 0 : assert( !"bad value of prior_strat" );
1582 : }
1583 : }
1584 :
1585 349053 : return;
1586 : }
1587 :
1588 :
1589 : /*-----------------------------------------------------------------------------------------*
1590 : * Function ivas_store_prior_coeffs()
1591 : *
1592 : * Store prior coeffs
1593 : *-----------------------------------------------------------------------------------------*/
1594 :
1595 351475 : 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 351475 : if ( dtx_vad == 0 )
1604 : {
1605 4121 : hMdEnc->spar_md_cfg.prior_strat = START;
1606 : }
1607 : else
1608 : {
1609 347354 : hMdEnc->spar_md_cfg.prior_strat = strat;
1610 : }
1611 :
1612 351475 : hMdEnc->spar_md_cfg.prev_quant_idx = qsi;
1613 :
1614 3298533 : for ( i = 0; i < num_bands; i++ )
1615 : {
1616 2947058 : b = i;
1617 :
1618 32417638 : for ( j = 0; j < IVAS_SPAR_MAX_CH - 1; j++ )
1619 : {
1620 29470580 : hMdEnc->spar_md_prior.band_coeffs_idx[i].pred_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[j];
1621 29470580 : 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 64835276 : for ( j = 0; j < IVAS_SPAR_MAX_C_COEFF; j++ )
1624 : {
1625 61888218 : 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 351475 : return;
1630 : }
1631 :
1632 :
1633 : /*-----------------------------------------------------------------------------------------*
1634 : * Function ivas_spar_quant_pred_coeffs_dtx()
1635 : *
1636 : * Calculate quantization pred coeffs
1637 : *-----------------------------------------------------------------------------------------*/
1638 :
1639 8242 : 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 8242 : pr_min_max[0] = pSpar_md->min_max[0];
1652 8242 : pr_min_max[1] = pSpar_md->min_max[1];
1653 :
1654 32968 : for ( i = 0; i < dim1; i++ )
1655 : {
1656 24726 : q_lvl = dtx_pr_real_q_levels[ndm - 1][i];
1657 24726 : ivas_quantise_real_values( &pValues[i], q_lvl, pr_min_max[0], pr_min_max[1], &pIndex[i], &pQuant[i], 1 );
1658 : }
1659 :
1660 8242 : return;
1661 : }
1662 :
1663 :
1664 : /*-----------------------------------------------------------------------------------------*
1665 : * Function ivas_quant_p_per_band_dtx()
1666 : *
1667 : * Calculate quantization p
1668 : *-----------------------------------------------------------------------------------------*/
1669 :
1670 8242 : 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 8242 : int16_t dim = num_ch - num_dmx;
1680 :
1681 8242 : if ( num_dec == num_ch - 1 )
1682 : {
1683 17960 : for ( i = 0; i < dim; i++ )
1684 : {
1685 13470 : if ( pP_mat[i] < pr_boost_range[1] && pP_mat[i] > pr_boost_range[0] )
1686 : {
1687 5848 : pP_mat[i] = pr_boost_range[1];
1688 : }
1689 : }
1690 : }
1691 :
1692 8242 : if ( dim != num_dec )
1693 : {
1694 0 : assert( !"Not Supported!" );
1695 : }
1696 :
1697 29216 : for ( i = 0; i < dim; i++ )
1698 : {
1699 20974 : 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 8242 : return;
1703 : }
1704 :
1705 : /*-----------------------------------------------------------------------------------------*
1706 : * Function ivas_write_parameter_bitstream_dtx()
1707 : *
1708 : * Write MD DTX parameters into bitstream
1709 : *-----------------------------------------------------------------------------------------*/
1710 :
1711 4121 : 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 4121 : sid_bits_len = hMetaData->nb_bits_tot;
1726 4121 : pr_min_max[0] = pSpar_md->min_max[0];
1727 4121 : pr_min_max[1] = pSpar_md->min_max[1];
1728 :
1729 12363 : for ( i = 0; i < num_bands; i++ )
1730 : {
1731 8242 : int16_t ndm = num_dmx[i];
1732 8242 : int16_t ndec = num_dec[i];
1733 :
1734 32968 : 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 24726 : pr_idx_1 = pr_pr_idx_pairs[ndm - 1][j][0];
1742 24726 : pr_idx_2 = pr_pr_idx_pairs[ndm - 1][j][1];
1743 24726 : pd_idx_1 = pr_pd_idx_pairs[ndm - 1][j][0];
1744 24726 : pd_idx_2 = pr_pd_idx_pairs[ndm - 1][j][1];
1745 :
1746 24726 : if ( pr_idx_1 != 0 || pd_idx_1 != 0 || pr_idx_2 != 0 || pd_idx_2 != 0 )
1747 : {
1748 24726 : pr_q_lvls = dtx_pr_real_q_levels[ndm - 1][pd_idx_1 - 1];
1749 24726 : pr = pSpar_md->band_coeffs_idx[i].pred_index_re[pd_idx_1 - 1];
1750 :
1751 24726 : if ( ( j + 1 ) > ndec )
1752 : {
1753 3752 : pd_q_lvls = 1;
1754 3752 : pd = 0;
1755 : }
1756 : else
1757 : {
1758 20974 : pd_q_lvls = dtx_pd_real_q_levels[ndm - 1][pd_idx_2 - 1];
1759 20974 : pd = pSpar_md->band_coeffs_idx[i].decd_index_re[pd_idx_2 - 1];
1760 : }
1761 24726 : val = dtx_pd_real_min_max[0];
1762 24726 : 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 24726 : pd -= idx;
1765 :
1766 24726 : val = pr_min_max[0];
1767 24726 : ivas_quantise_real_values( &val, pr_q_lvls, pr_min_max[0], pr_min_max[1], &idx, &val, 1 );
1768 :
1769 24726 : pr -= idx;
1770 24726 : pr_pd_bits = ivas_get_bits_to_encode( pd_q_lvls * pr_q_lvls );
1771 :
1772 24726 : value = (uint16_t) ( pr * pd_q_lvls + pd );
1773 :
1774 24726 : push_next_indice( hMetaData, value, pr_pd_bits );
1775 : }
1776 : }
1777 : }
1778 :
1779 4121 : sid_bits_len = hMetaData->nb_bits_tot - sid_bits_len;
1780 4121 : sba_spar_bitlen = ivas_sba_spar_sid_bitlen( num_dmx[0] );
1781 4121 : zero_pad_bits = sba_spar_bitlen - sid_bits_len;
1782 :
1783 4121 : assert( zero_pad_bits >= 0 );
1784 4121 : if ( num_dmx[0] == 2 )
1785 : {
1786 1876 : zero_pad_bits -= 1;
1787 : }
1788 :
1789 5997 : while ( zero_pad_bits > 0 )
1790 : {
1791 1876 : j = min( zero_pad_bits, 16 );
1792 1876 : push_next_indice( hMetaData, 0, j );
1793 1876 : zero_pad_bits -= j;
1794 : }
1795 :
1796 4121 : return;
1797 : }
1798 :
1799 :
1800 : /*-----------------------------------------------------------------------------------------*
1801 : * Function ivas_quant_pred_coeffs_per_band()
1802 : *
1803 : * Quantization of prediction coefficients
1804 : *-----------------------------------------------------------------------------------------*/
1805 :
1806 2949020 : 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 2949020 : 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 2949020 : 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 1903744 : 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 1903744 : k = 0;
1835 7788920 : for ( i = 0; i < ndec; i++ )
1836 : {
1837 20464584 : for ( j = 0; j < ndm - 1; j++ )
1838 : {
1839 14579408 : C_re[k] = pband_coeffs->C_re[i][j];
1840 14579408 : k++;
1841 : }
1842 : }
1843 1903744 : 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 1903744 : k = 0;
1845 7788920 : for ( i = 0; i < ndec; i++ )
1846 : {
1847 20464584 : for ( j = 0; j < ndm - 1; j++ )
1848 : {
1849 14579408 : pband_coeffs->C_quant_re[i][j] = C_re[k];
1850 14579408 : k++;
1851 : }
1852 : }
1853 :
1854 1903744 : 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 2353180 : 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 2353180 : 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 2353180 : return;
1873 : }
|
