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 <string.h>
35 : #include "options.h"
36 : #include "prot_fx.h"
37 : #include "ivas_prot_fx.h"
38 : #include "math.h"
39 : #include "ivas_rom_com.h"
40 : #include "ivas_rom_com_fx.h"
41 : #include <assert.h>
42 : #include "wmc_auto.h"
43 :
44 : /*------------------------------------------------------------------------------------------*
45 : * PreProcessor
46 : *------------------------------------------------------------------------------------------*/
47 : /*Q28*/
48 : static const Word32 pr_boost_range_fx[2] = { 26843546 /*.1f in Q28*/, 107374182 /*.4f in Q28*/ };
49 :
50 : typedef enum ivas_strats_t
51 : {
52 : START,
53 : BASE,
54 : BASE_DIFF,
55 : BASE_NOEC,
56 : FOUR_A,
57 : FOUR_B,
58 : FOUR_C,
59 : FOUR_D,
60 : NO_STRAT
61 : } ivas_strats_t;
62 :
63 :
64 : /*------------------------------------------------------------------------------------------*
65 : * Static functions declaration
66 : *------------------------------------------------------------------------------------------*/
67 : static void ivas_band_mixer_fx( Word32 *cov_re[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], Word16 *cov_real_q[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], const Word16 num_ch, Word16 *num_bands, Word16 red_band_fact );
68 :
69 : static Word16 ivas_get_huffman_coded_bs_fx( ivas_spar_md_enc_state_t *hMdEnc, BSTR_ENC_HANDLE hMetaData, const Word16 nB, const Word16 qsi, const Word16 bands_bw );
70 :
71 :
72 : static Word16 ivas_get_arith_coded_bs_fx( ivas_spar_md_enc_state_t *hMdEnc, BSTR_ENC_HANDLE hMetaData, const Word16 *pDo_diff, const Word16 bands_bw, const Word16 nB, const Word16 qsi, const Word16 strat, const Word32 ivas_total_brate );
73 :
74 :
75 : static void ivas_spar_set_enc_config_fx( ivas_spar_md_enc_state_t *hMdEnc, Word16 *max_freq_per_chan, const Word16 nchan_transport, Word32 *pFC, const Word16 nchan_inp );
76 :
77 : static void ivas_select_next_strat_fx( ivas_strats_t prior_strat, ivas_strats_t cs[MAX_QUANT_STRATS], const Word16 dmx_switch, const Word16 dtx_vad );
78 :
79 : static void ivas_store_prior_coeffs_fx( ivas_spar_md_enc_state_t *hMdEnc, const Word16 num_bands, const Word16 strat, const Word16 dtx_vad, const Word16 qsi );
80 :
81 : static void ivas_write_spar_md_bitstream_fx( ivas_spar_md_enc_state_t *hMdEnc, const Word16 nB, const Word16 bands_bw, BSTR_ENC_HANDLE hMetaData, const Word32 ivas_total_brate, const Word16 strat, const Word16 qsi );
82 :
83 :
84 : static void ivas_spar_quant_pred_coeffs_dtx_fx( ivas_spar_md_t *pSpar_md, const Word32 *pValues, const Word16 ndm, Word16 *pIndex, const Word16 dim1, Word32 *pQuant );
85 : static void ivas_quant_p_per_band_dtx_fx( Word32 *pP_mat, const Word16 num_dec, const Word16 num_dmx, Word16 *ppIdx_pd, Word32 *pP_out, const Word16 num_ch );
86 : static void ivas_write_parameter_bitstream_dtx_fx( ivas_spar_md_t *pSpar_md, BSTR_ENC_HANDLE hMetaData, Word16 *num_dmx, Word16 *num_dec, const Word16 num_bands );
87 :
88 : static void ivas_quant_p_per_band_fx( ivas_band_coeffs_t *pband_coeffs, ivas_band_coeffs_ind_t *pBand_coeffs_idx, ivas_quant_strat_t *pQs, const Word16 num_ch );
89 : static void ivas_quant_c_per_band_fx( ivas_band_coeffs_t *pband_coeffs, ivas_band_coeffs_ind_t *pBand_coeffs_idx, ivas_quant_strat_t *pQs, const Word16 ndec, const Word16 ndm, const Word16 q_C );
90 : static void ivas_quant_pred_coeffs_per_band_fx( ivas_band_coeffs_t *pband_coeffs, ivas_band_coeffs_ind_t *pBand_coeffs_idx, ivas_quant_strat_t *pQs, const Word16 num_ch );
91 :
92 : /*-------------------------------------------------------------------------
93 : * ivas_spar_md_enc_open()
94 : *
95 : * Allocate and initialize SPAR MD encoder handle
96 : *------------------------------------------------------------------------*/
97 :
98 1558 : ivas_error ivas_spar_md_enc_open_fx(
99 : ivas_spar_md_enc_state_t **hMdEnc_in, /* i/o: SPAR MD encoder handle */
100 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
101 : const Word16 sba_order /* i : Ambisonic (SBA) order */
102 : )
103 : {
104 : ivas_spar_md_enc_state_t *hMdEnc;
105 : ivas_error error;
106 : Word16 num_channels, i, j;
107 1558 : error = IVAS_ERR_OK;
108 1558 : move32();
109 1558 : IF( ( hMdEnc = (ivas_spar_md_enc_state_t *) malloc( sizeof( ivas_spar_md_enc_state_t ) ) ) == NULL )
110 : {
111 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD encoder" );
112 : }
113 :
114 1558 : num_channels = ivas_sba_get_nchan_metadata_fx( sba_order, hEncoderConfig->ivas_total_brate );
115 :
116 1558 : IF( ( hMdEnc->spar_md.band_coeffs = (ivas_band_coeffs_t *) malloc( IVAS_MAX_NUM_BANDS * sizeof( ivas_band_coeffs_t ) ) ) == NULL )
117 : {
118 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for band_coeffs in SPAR MD" );
119 : }
120 1558 : memset( hMdEnc->spar_md.band_coeffs, 0, IVAS_MAX_NUM_BANDS * sizeof( ivas_band_coeffs_t ) );
121 :
122 1558 : IF( ( hMdEnc->mixer_mat_fx = (Word32 ***) malloc( num_channels * sizeof( Word32 ** ) ) ) == NULL )
123 : {
124 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
125 : }
126 8965 : FOR( i = 0; i < num_channels; i++ )
127 : {
128 7407 : IF( ( hMdEnc->mixer_mat_fx[i] = (Word32 **) malloc( num_channels * sizeof( Word32 * ) ) ) == NULL )
129 : {
130 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
131 : }
132 47850 : FOR( j = 0; j < num_channels; j++ )
133 : {
134 40443 : IF( ( hMdEnc->mixer_mat_fx[i][j] = (Word32 *) malloc( IVAS_MAX_NUM_BANDS * sizeof( Word32 ) ) ) == NULL )
135 : {
136 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD matrix" );
137 : }
138 : }
139 : }
140 1558 : hMdEnc->q_mixer_mat_fx = 0;
141 1558 : move16();
142 1558 : IF( NE_32( ( error = ivas_spar_md_enc_init_fx( hMdEnc, hEncoderConfig, sba_order ) ), IVAS_ERR_OK ) )
143 : {
144 0 : return error;
145 : }
146 :
147 1558 : *hMdEnc_in = hMdEnc;
148 :
149 1558 : return error;
150 : }
151 : /*-------------------------------------------------------------------------
152 : * ivas_spar_md_enc_close()
153 : *
154 : * Deallocate SPAR MD encoder handle
155 : *------------------------------------------------------------------------*/
156 :
157 1558 : void ivas_spar_md_enc_close_fx(
158 : ivas_spar_md_enc_state_t **hMdEnc_in /* i/o: SPAR MD encoder handle */
159 : )
160 : {
161 : Word16 num_channels, i, j;
162 : ivas_spar_md_enc_state_t *hMdEnc;
163 :
164 1558 : test();
165 1558 : IF( hMdEnc_in == NULL || *hMdEnc_in == NULL )
166 : {
167 0 : return;
168 : }
169 :
170 1558 : hMdEnc = *hMdEnc_in;
171 1558 : num_channels = hMdEnc->num_umx_ch;
172 1558 : move16();
173 :
174 1558 : IF( hMdEnc->spar_md.band_coeffs != NULL )
175 : {
176 1558 : free( hMdEnc->spar_md.band_coeffs );
177 1558 : hMdEnc->spar_md.band_coeffs = NULL;
178 : }
179 1558 : IF( hMdEnc->mixer_mat_fx != NULL )
180 : {
181 8965 : FOR( i = 0; i < num_channels; i++ )
182 : {
183 47850 : FOR( j = 0; j < num_channels; j++ )
184 : {
185 40443 : free( hMdEnc->mixer_mat_fx[i][j] );
186 : }
187 7407 : free( hMdEnc->mixer_mat_fx[i] );
188 : }
189 1558 : free( hMdEnc->mixer_mat_fx );
190 : }
191 :
192 1558 : free( *hMdEnc_in );
193 1558 : *hMdEnc_in = NULL;
194 :
195 1558 : return;
196 : }
197 :
198 :
199 : /*-----------------------------------------------------------------------------------------*
200 : * Function ivas_spar_md_enc_init()
201 : *
202 : * SPAR MD encoder initialization
203 : *-----------------------------------------------------------------------------------------*/
204 :
205 1861 : ivas_error ivas_spar_md_enc_init_fx(
206 : ivas_spar_md_enc_state_t *hMdEnc, /* o : MD encoder handle */
207 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
208 : const Word16 sba_order /* i : Ambisonic (SBA) order */
209 : )
210 : {
211 : Word32 pFC[IVAS_MAX_NUM_BANDS];
212 : Word16 table_idx;
213 : Word16 num_channels, i, j, k;
214 : Word32 PR_minmax_fx[2];
215 1861 : ivas_sba_get_spar_hoa_md_flag_fx( sba_order, hEncoderConfig->ivas_total_brate, &hMdEnc->spar_hoa_md_flag, &hMdEnc->spar_hoa_dirac2spar_md_flag );
216 1861 : num_channels = ivas_sba_get_nchan_metadata_fx( sba_order, hEncoderConfig->ivas_total_brate );
217 1861 : ivas_sba_get_spar_hoa_ch_ind_fx( num_channels, hEncoderConfig->ivas_total_brate, hMdEnc->HOA_md_ind );
218 1861 : table_idx = ivas_get_spar_table_idx_fx( hEncoderConfig->ivas_total_brate, sba_order, SPAR_CONFIG_BW, NULL, NULL );
219 :
220 1861 : hMdEnc->spar_md.prior_dyn_active_w_flag = 0;
221 1861 : move16();
222 : Word16 num_bands;
223 1861 : IF( hMdEnc->spar_hoa_md_flag != 0 )
224 : {
225 259 : num_bands = IVAS_MAX_NUM_BANDS;
226 259 : move16();
227 : }
228 : ELSE
229 : {
230 1602 : num_bands = SPAR_DIRAC_SPLIT_START_BAND;
231 1602 : move16();
232 : }
233 :
234 1861 : ivas_spar_set_bitrate_config_fx( &hMdEnc->spar_md_cfg, table_idx, num_bands,
235 1861 : 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 ) ); // TODO: some log operations pending.
236 : /* get FB coefficients */
237 24193 : FOR( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
238 : {
239 22332 : pFC[i] = L_shr( Mpy_32_32( ivas_fb_fcs_12band_1ms_fx[i], hEncoderConfig->input_Fs ), 1 ); // Q0
240 22332 : move32();
241 : }
242 :
243 1861 : ivas_spar_set_enc_config_fx( hMdEnc, hMdEnc->spar_md_cfg.max_freq_per_chan, hMdEnc->spar_md_cfg.nchan_transport, pFC, num_channels );
244 1861 : test();
245 1861 : test();
246 1861 : IF( NE_16( hMdEnc->spar_md_cfg.nchan_transport, 2 ) && ( EQ_16( hMdEnc->spar_md_cfg.remix_unmix_order, 1 ) || EQ_16( hMdEnc->spar_md_cfg.remix_unmix_order, 2 ) ) )
247 : {
248 0 : return IVAS_ERR_INTERNAL;
249 : }
250 :
251 1861 : ivas_spar_arith_coeffs_com_init_fx( &hMdEnc->arith_coeffs, &hMdEnc->spar_md_cfg, table_idx, ENC );
252 1861 : ivas_spar_huff_coeffs_com_init_fx( &hMdEnc->huff_coeffs, NULL, table_idx, ENC );
253 1861 : IF( EQ_16( hEncoderConfig->Opt_DTX_ON, 1 ) )
254 : {
255 : /* DTX quant init */
256 143 : PR_minmax_fx[0] = hMdEnc->spar_md_cfg.quant_strat[0].PR.min_fx;
257 143 : move32();
258 143 : PR_minmax_fx[1] = hMdEnc->spar_md_cfg.quant_strat[0].PR.max_fx;
259 143 : move32();
260 143 : ivas_spar_quant_dtx_init_fx( &hMdEnc->spar_md, PR_minmax_fx );
261 : }
262 1861 : hMdEnc->spar_md_cfg.prior_strat = START;
263 1861 : move16();
264 1861 : hMdEnc->spar_md_cfg.prev_quant_idx = -1;
265 1861 : move16();
266 10480 : FOR( i = 0; i < num_channels; i++ )
267 : {
268 53910 : FOR( j = 0; j < num_channels; j++ )
269 : {
270 588783 : FOR( k = 0; k < IVAS_MAX_NUM_BANDS; k++ )
271 : {
272 543492 : hMdEnc->mixer_mat_fx[i][j][k] = 0;
273 543492 : move32();
274 : }
275 : }
276 : }
277 1861 : hMdEnc->q_mixer_mat_fx = 0;
278 1861 : move16();
279 1861 : ivas_clear_band_coeffs_fx( hMdEnc->spar_md.band_coeffs, IVAS_MAX_NUM_BANDS );
280 1861 : ivas_clear_band_coeff_idx( hMdEnc->spar_md.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
281 1861 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx, IVAS_MAX_NUM_BANDS );
282 1861 : ivas_clear_band_coeff_idx( hMdEnc->spar_md_prior.band_coeffs_idx_mapped, IVAS_MAX_NUM_BANDS );
283 :
284 1861 : return IVAS_ERR_OK;
285 : }
286 : /*-----------------------------------------------------------------------------------------*
287 : * Function ivas_spar_set_enc_config()
288 : *
289 : * Set configuration for SPAR MD encoder
290 : *-----------------------------------------------------------------------------------------*/
291 :
292 1861 : static void ivas_spar_set_enc_config_fx(
293 : ivas_spar_md_enc_state_t *hMdEnc,
294 : Word16 *max_freq_per_chan,
295 : const Word16 nchan_transport,
296 : Word32 *pFC, // Input Q0
297 : const Word16 nchan_inp )
298 : {
299 : Word16 i, j;
300 : Word16 tmp_dmx_ch;
301 :
302 6058 : FOR( i = 0; i < nchan_transport; i++ )
303 : {
304 4197 : IF( max_freq_per_chan != NULL )
305 : {
306 4197 : IF( max_freq_per_chan[i] != 0 )
307 : {
308 4197 : hMdEnc->spar_md_cfg.max_freq_per_chan[i] = max_freq_per_chan[i];
309 : }
310 : ELSE
311 : {
312 0 : hMdEnc->spar_md_cfg.max_freq_per_chan[i] = max_freq_per_chan[0];
313 : }
314 4197 : move16();
315 : }
316 : ELSE
317 : {
318 0 : hMdEnc->spar_md_cfg.max_freq_per_chan[i] = IVAS_SPAR_FOA_DFLT_FREQ_PER_CHAN;
319 0 : move16();
320 : }
321 : }
322 1861 : hMdEnc->num_umx_ch = nchan_inp;
323 1861 : move16();
324 1861 : hMdEnc->num_decorr = sub( nchan_inp, 1 );
325 1861 : move16();
326 24193 : FOR( i = 0; i < IVAS_MAX_NUM_BANDS; i++ )
327 : {
328 22332 : tmp_dmx_ch = 0;
329 22332 : move16();
330 72696 : FOR( j = 0; j < nchan_transport; j++ )
331 : {
332 50364 : IF( LT_32( pFC[i], hMdEnc->spar_md_cfg.max_freq_per_chan[j] ) )
333 : {
334 50364 : tmp_dmx_ch = add( tmp_dmx_ch, 1 );
335 : }
336 : }
337 :
338 22332 : hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i] = tmp_dmx_ch;
339 22332 : move16();
340 22332 : hMdEnc->spar_md_cfg.num_decorr_per_band[i] = sub( hMdEnc->num_umx_ch, tmp_dmx_ch );
341 22332 : move16();
342 : }
343 :
344 1861 : return;
345 : }
346 : /*-----------------------------------------------------------------------------------------*
347 : * Function ivas_band_limit_dmx_matrix()
348 : *
349 : * Band limit downmix matrix
350 : *-----------------------------------------------------------------------------------------*/
351 :
352 158582 : static void ivas_band_limit_dmx_matrix_fx(
353 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
354 : const Word16 num_ch,
355 : const Word16 num_bands,
356 : const Word16 bands_bw )
357 : {
358 : Word16 i, j, b, ndm;
359 :
360 1451812 : FOR( b = 0; b < num_bands; b++ )
361 : {
362 1293230 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
363 1293230 : move16();
364 :
365 4313282 : FOR( i = ndm; i < num_ch; i++ )
366 : {
367 21806580 : FOR( j = 0; j < num_ch; j++ )
368 : {
369 18786528 : hMdEnc->mixer_mat_fx[i][j][b] = 0;
370 18786528 : move32();
371 : }
372 : }
373 : }
374 :
375 158582 : return;
376 : }
377 :
378 :
379 : /*-----------------------------------------------------------------------------------------*
380 : * Function ivas_band_mixing()
381 : *
382 : * Band mixing downmix matrix
383 : *-----------------------------------------------------------------------------------------*/
384 :
385 15094 : static void ivas_band_mixing_fx(
386 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
387 : const Word16 num_ch,
388 : const Word16 num_bands,
389 : const Word16 nchan_transport,
390 : const Word16 upmixed_bands )
391 : {
392 : Word16 i, j, k, b;
393 : Word16 red_band_fact;
394 :
395 15094 : red_band_fact = idiv1616( upmixed_bands, num_bands );
396 :
397 30951 : FOR( i = 0; i < nchan_transport; i++ )
398 : {
399 79285 : FOR( j = 0; j < num_ch; j++ )
400 : {
401 298196 : FOR( k = num_bands - 1; k >= 0; k-- )
402 : {
403 742192 : FOR( b = red_band_fact - 1; b >= 0; b-- )
404 : {
405 507424 : hMdEnc->mixer_mat_fx[i][j][red_band_fact * k + b] = hMdEnc->mixer_mat_fx[i][j][k];
406 507424 : move32();
407 : }
408 : }
409 63428 : FOR( k = red_band_fact * num_bands; k < upmixed_bands; k++ )
410 : {
411 0 : hMdEnc->mixer_mat_fx[i][j][k] = hMdEnc->mixer_mat_fx[i][j][( red_band_fact * num_bands ) - 1];
412 0 : move32();
413 : }
414 : }
415 : }
416 :
417 15094 : return;
418 : }
419 :
420 :
421 : /*-----------------------------------------------------------------------------------------*
422 : * Function write_metadata_buffer()
423 : *
424 : *
425 : *-----------------------------------------------------------------------------------------*/
426 :
427 234150 : static void write_metadata_buffer_fx(
428 : BSTR_ENC_HANDLE hMetaData_tmp,
429 : BSTR_ENC_HANDLE hMetaData,
430 : const Word16 bit_pos_start,
431 : const Word16 next_ind_start )
432 : {
433 : Word16 i;
434 :
435 234150 : IF( hMetaData->nb_bits_tot > 0 )
436 : {
437 234150 : restore_metadata_buffer_fx( hMetaData, next_ind_start, bit_pos_start );
438 : }
439 :
440 37870671 : FOR( i = 0; i < hMetaData_tmp->nb_ind_tot; i++ )
441 : {
442 : #ifdef DBG_BITSTREAM_ANALYSIS
443 : push_next_indice_( hMetaData_tmp->ind_list[i].function_name, hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
444 : #else
445 37636521 : push_next_indice( hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
446 : #endif
447 : }
448 :
449 234150 : return;
450 : }
451 :
452 : /*-----------------------------------------------------------------------------------------*
453 : * Function ivas_spar_md_enc_process()
454 : *
455 : * SPAR FoA Meta Data generation process
456 : *-----------------------------------------------------------------------------------------*/
457 :
458 157500 : ivas_error ivas_spar_md_enc_process_fx(
459 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
460 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
461 : Word32 *cov_real_fx[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], /*Q(cov_real_q)*/
462 : Word16 *cov_real_q[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
463 : Word32 *cov_dtx_real_fx[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], /*Q(cov_dtx_real_q)*/
464 : Word16 *cov_dtx_real_q[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
465 : BSTR_ENC_HANDLE hMetaData, /* i/o: MetaData handle */
466 : const Word16 dtx_vad,
467 : const Word16 nchan_inp,
468 : const Word16 sba_order, /* i : Ambisonic (SBA) order */
469 : Word32 *prior_mixer[IVAS_MAX_FB_MIXER_OUT_CH][IVAS_MAX_SPAR_FB_MIXER_IN_CH], /* i : prior mixer_matrix Q(q_prior_mixer) */
470 : Word16 *q_prior_mixer, /* i/o : q for prior mixer_matrix */
471 : const Word16 dyn_active_w_flag, /* i : flag to indicate dynamic active W */
472 : const Word16 dirac_mono_flag, /* i : flag to indicate mono only mode in SBA */
473 : const Word16 nchan_out )
474 : {
475 : Word32 pred_coeffs_re_fx[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
476 : Word32 dm_fv_re_fx[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
477 : Word16 q_dm_fv_re;
478 : Word16 i, j, b, qsi, ndm, ndec, num_ch, num_quant_strats;
479 : Word32 pred_coeffs_re_local_fx[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
480 : Word16 k, bwidth, num_bands, num_bands_full, num_bands_bw;
481 : Word16 active_w, nchan_transport, dmx_switch, strat;
482 157500 : Word16 nB, bands_bw, packed_ok = 0;
483 157500 : move16();
484 : ivas_strats_t cs[MAX_CODING_STRATS];
485 : Word16 code_strat;
486 : Word16 bit_pos_start, next_ind_start;
487 : BSTR_ENC_DATA hMetaData_tmp;
488 : Indice *ind_list_tmp;
489 : Word16 md_indices_allocated;
490 : Word16 max_num_indices_tmp;
491 : Word32 Wscale_fx[IVAS_MAX_NUM_BANDS];
492 : Word16 q_Wscale[IVAS_MAX_NUM_BANDS];
493 :
494 : /*extra 16 bits for arithmetic coder as overshoot check is after a symbol is written*/
495 157500 : md_indices_allocated = add( hMdEnc->spar_md_cfg.max_bits_per_blk, IVAS_SPAR_ARITH_OVERSHOOT_BITS );
496 157500 : IF( ( ind_list_tmp = (Indice *) malloc( sizeof( Indice ) * md_indices_allocated ) ) == NULL )
497 : {
498 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD encoder indices" );
499 : }
500 :
501 157500 : num_quant_strats = hMdEnc->spar_md_cfg.num_quant_strats;
502 157500 : move16();
503 157500 : num_ch = ivas_sba_get_nchan_metadata_fx( sba_order, hEncoderConfig->ivas_total_brate );
504 157500 : test();
505 157500 : active_w = EQ_16( hMdEnc->spar_md_cfg.active_w, 1 ) || EQ_16( dyn_active_w_flag, 1 );
506 157500 : nchan_transport = hMdEnc->spar_md_cfg.nchan_transport;
507 157500 : move16();
508 :
509 157500 : bwidth = ivas_get_bw_idx_from_sample_rate_fx( hEncoderConfig->input_Fs );
510 157500 : bwidth = s_min( bwidth, hEncoderConfig->max_bwidth );
511 : Word16 active_w_vlbr;
512 157500 : IF( LT_32( hEncoderConfig->ivas_total_brate, IVAS_24k4 ) )
513 : {
514 13323 : active_w_vlbr = 1;
515 13323 : move16();
516 : }
517 : ELSE
518 : {
519 144177 : active_w_vlbr = 0;
520 144177 : move16();
521 : }
522 157500 : num_bands = ivas_get_num_bands_from_bw_idx( SPAR_CONFIG_BW );
523 157500 : IF( hMdEnc->spar_hoa_md_flag == 0 )
524 : {
525 135460 : num_bands = s_min( num_bands, SPAR_DIRAC_SPLIT_START_BAND );
526 : }
527 157500 : num_bands_full = num_bands;
528 157500 : move16();
529 157500 : num_bands_bw = ivas_get_num_bands_from_bw_idx( bwidth );
530 :
531 157500 : IF( dtx_vad == 0 )
532 : {
533 8025 : FOR( i = 0; i < nchan_inp; i++ )
534 : {
535 32100 : FOR( j = 0; j < nchan_inp; j++ )
536 : {
537 25680 : cov_real_fx[i][j] = cov_dtx_real_fx[i][j];
538 333840 : FOR( k = 0; k < IVAS_MAX_NUM_BANDS; k++ )
539 : {
540 308160 : cov_real_q[i][j][k] = cov_dtx_real_q[i][j][k];
541 308160 : move16();
542 : }
543 : }
544 : }
545 : }
546 :
547 889700 : FOR( i = 0; i < nchan_inp; i++ )
548 : {
549 4628660 : FOR( j = 0; j < nchan_inp; j++ )
550 : {
551 4584660 : FOR( k = num_bands_bw; k < IVAS_MAX_NUM_BANDS; k++ )
552 : {
553 688200 : cov_real_fx[i][j][k] = 0;
554 688200 : move32();
555 : }
556 : }
557 : }
558 :
559 157500 : test();
560 157500 : if ( EQ_32( hEncoderConfig->ivas_total_brate, BRATE_SPAR_Q_STRAT ) && EQ_16( sba_order, SBA_FOA_ORDER ) )
561 : {
562 : /* make sure that qsi is always 0 (temporary bits are '00') */
563 11580 : num_quant_strats = 1;
564 11580 : move16();
565 : }
566 :
567 157500 : hMetaData_tmp.ind_list = ind_list_tmp;
568 157500 : hMetaData_tmp.nb_bits_tot = 0;
569 157500 : move16();
570 157500 : max_num_indices_tmp = MAX_BITS_METADATA;
571 157500 : move16();
572 157500 : hMetaData_tmp.ivas_max_num_indices = &max_num_indices_tmp;
573 157500 : hMetaData_tmp.ivas_ind_list_zero = (Indice **) ( &hMetaData_tmp.ind_list );
574 157500 : hMetaData_tmp.st_ivas = NULL;
575 :
576 : /* Save state of metadata bitstream buffer */
577 157500 : bit_pos_start = hMetaData->nb_bits_tot;
578 157500 : move16();
579 157500 : next_ind_start = hMetaData->nb_ind_tot;
580 157500 : move16();
581 157500 : dmx_switch = 0;
582 157500 : move16();
583 :
584 157500 : IF( dtx_vad == 0 )
585 : {
586 1605 : nB = SPAR_DTX_BANDS;
587 1605 : move16();
588 1605 : bands_bw = idiv1616( num_bands, nB );
589 :
590 1605 : ivas_band_mixer_fx( cov_real_fx, cov_real_q, num_ch, &num_bands, bands_bw );
591 : }
592 155895 : ELSE IF( LT_32( hEncoderConfig->ivas_total_brate, IVAS_24k4 ) )
593 : {
594 13139 : bands_bw = 2;
595 13139 : move16();
596 13139 : nB = idiv1616( num_bands, bands_bw );
597 :
598 13139 : ivas_band_mixer_fx( cov_real_fx, cov_real_q, num_ch, &num_bands, bands_bw );
599 : }
600 : ELSE
601 : {
602 142756 : nB = num_bands;
603 142756 : move16();
604 142756 : bands_bw = 1;
605 142756 : move16();
606 : }
607 157500 : test();
608 157500 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
609 : {
610 60500 : FOR( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
611 : {
612 193600 : FOR( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
613 : {
614 145200 : pred_coeffs_re_local_fx[i][b] = hMdEnc->spar_md.band_coeffs[b].pred_re_fx[i]; // Q28
615 145200 : move32();
616 : }
617 : }
618 : }
619 157500 : ivas_compute_spar_params_enc_fx( cov_real_fx, cov_real_q, dm_fv_re_fx, &q_dm_fv_re, 0, hMdEnc->mixer_mat_fx, &hMdEnc->q_mixer_mat_fx, 0, nB, dtx_vad, num_ch, bands_bw, active_w, active_w_vlbr, &hMdEnc->spar_md_cfg, &hMdEnc->spar_md, Wscale_fx, q_Wscale, 0, dyn_active_w_flag );
620 :
621 157500 : IF( dirac_mono_flag )
622 : {
623 : Word16 i_ts;
624 0 : Word16 num_md_sub_frames = 1;
625 0 : move16();
626 :
627 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
628 0 : move16();
629 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
630 0 : move16();
631 :
632 0 : FOR( i_ts = 0; i_ts < num_md_sub_frames; i_ts++ )
633 : {
634 0 : FOR( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
635 : {
636 0 : FOR( j = 0; j < ndm + ndec - 1; j++ )
637 : {
638 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].pred_re_fx[j] = 0;
639 0 : move32();
640 : }
641 0 : FOR( j = 0; j < ndec; j++ )
642 : {
643 0 : FOR( k = 0; k < ndm - 1; k++ )
644 : {
645 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].C_re_fx[j][k] = 0;
646 0 : move32();
647 : }
648 : }
649 :
650 0 : FOR( j = 0; j < ndec; j++ )
651 : {
652 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].P_re_fx[j] = 0;
653 0 : move32();
654 : }
655 : }
656 : }
657 : }
658 :
659 157500 : code_strat = 0;
660 157500 : move16();
661 158582 : FOR( qsi = 0; qsi < num_quant_strats; qsi++ )
662 : {
663 1451812 : FOR( b = 0; b < num_bands; b++ )
664 : {
665 1293230 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
666 1293230 : move16();
667 1293230 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
668 1293230 : move16();
669 :
670 1293230 : IF( EQ_16( dtx_vad, 1 ) )
671 : {
672 1290020 : IF( NE_16( ndm, num_ch ) )
673 : {
674 1138660 : ivas_quant_p_per_band_fx( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b], &hMdEnc->spar_md_cfg.quant_strat[qsi], num_ch );
675 : }
676 1290020 : ivas_quant_pred_coeffs_per_band_fx( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b], &hMdEnc->spar_md_cfg.quant_strat[qsi], num_ch );
677 1290020 : IF( active_w_vlbr )
678 : {
679 215824 : FOR( i = 0; i < 3; i++ )
680 : {
681 : Word16 i2;
682 161868 : i2 = 0;
683 161868 : move16();
684 161868 : SWITCH( i ) /* PRED (Y,Z,X) and DECD (Y,X,Z) coeffs are in different orders */
685 : {
686 53956 : case 0:
687 53956 : i2 = 0;
688 53956 : move16();
689 53956 : BREAK;
690 53956 : case 1:
691 53956 : i2 = 2;
692 53956 : move16();
693 53956 : BREAK;
694 53956 : case 2:
695 53956 : i2 = 1;
696 53956 : move16();
697 53956 : BREAK;
698 : }
699 161868 : test();
700 161868 : test();
701 161868 : test();
702 161868 : 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_fx[i] != 0 ) && ( cov_real_fx[i + 1][i + 1][b] != 0 ) )
703 : {
704 : /* bump up the Pred coeff */
705 : Word32 PR_uq;
706 : Word16 PR_step;
707 : ivas_quant_strat_t qs;
708 : Word16 PR_step_e;
709 3496 : qs = hMdEnc->spar_md_cfg.quant_strat[qsi];
710 3496 : PR_uq = hMdEnc->spar_md.band_coeffs[b].pred_re_fx[i]; // Q28
711 3496 : move32();
712 3496 : PR_step = BASOP_Util_Divide3216_Scale( L_sub( qs.PR.max_fx, qs.PR.min_fx ), sub( qs.PR.q_levels[0], 1 ), &PR_step_e );
713 3496 : PR_step_e = sub( PR_step_e, Q12 );
714 :
715 : Word16 PR_sign;
716 3496 : PR_sign = sub( extract_l( GT_32( PR_uq, 0 ) ), extract_l( LT_32( PR_uq, 0 ) ) );
717 :
718 3496 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = PR_sign;
719 3496 : move16();
720 :
721 : /* deindex the modified coefficient */
722 3496 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re_fx[i] = L_shl( L_mult0( PR_sign, PR_step ), add( Q13, PR_step_e ) ); // Q28
723 3496 : move32();
724 : }
725 : }
726 : }
727 : }
728 : ELSE
729 : {
730 3210 : IF( NE_16( ndm, num_ch ) )
731 : {
732 3210 : ivas_quant_p_per_band_dtx_fx( hMdEnc->spar_md.band_coeffs[b].P_re_fx, ndec, ndm, &hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[0], hMdEnc->spar_md.band_coeffs[b].P_quant_re_fx, num_ch );
733 : }
734 :
735 12840 : FOR( i = 0; i < num_ch - 1; i++ )
736 : {
737 9630 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re_fx[i] = 0;
738 9630 : move32();
739 : }
740 3210 : ivas_spar_quant_pred_coeffs_dtx_fx( &hMdEnc->spar_md, hMdEnc->spar_md.band_coeffs[b].pred_re_fx, ndm, hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re, sub( num_ch, 1 ), hMdEnc->spar_md.band_coeffs[b].pred_quant_re_fx );
741 : }
742 : }
743 736528 : FOR( i = 0; i < num_ch - 1; i++ )
744 : {
745 5684036 : FOR( b = 0; b < num_bands; b++ )
746 : {
747 5106090 : pred_coeffs_re_fx[i][b] = L_shl( Mpy_32_32( Wscale_fx[b], hMdEnc->spar_md.band_coeffs[b].pred_quant_re_fx[i] ), sub( Q31, q_Wscale[b] ) ); // Q28
748 5106090 : move32();
749 : }
750 : }
751 :
752 158582 : test();
753 158582 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
754 : {
755 60500 : FOR( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
756 : {
757 193600 : FOR( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
758 : {
759 : /* Use the prediction coeffs computed based on DirAC MD to generate mixer matrix */
760 145200 : pred_coeffs_re_fx[i][b] = pred_coeffs_re_local_fx[i][b];
761 145200 : move32();
762 145200 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re_fx[i] = 0;
763 145200 : move32();
764 145200 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = 0;
765 145200 : move16();
766 : }
767 : }
768 : }
769 :
770 158582 : ivas_create_fullr_dmx_mat_fx( pred_coeffs_re_fx, Q28, dm_fv_re_fx, q_dm_fv_re, hMdEnc->mixer_mat_fx, &hMdEnc->q_mixer_mat_fx, num_ch, 0, num_bands, active_w, &hMdEnc->spar_md_cfg );
771 158582 : Word16 Wscale_e = Q31;
772 158582 : move16();
773 : /* Common q for Wscale buffer */
774 1451812 : FOR( b = 0; b < num_bands; b++ )
775 : {
776 1293230 : if ( GT_16( Wscale_e, q_Wscale[b] ) )
777 : {
778 44880 : Wscale_e = q_Wscale[b];
779 44880 : move16();
780 : }
781 : }
782 1451812 : FOR( b = 0; b < num_bands; b++ )
783 : {
784 1293230 : Wscale_fx[b] = L_shr( Wscale_fx[b], sub( q_Wscale[b], Wscale_e ) ); // Q(Wscale_e)
785 1293230 : move32();
786 : }
787 158582 : Wscale_e = sub( Q31, Wscale_e ); // Wscale_e is now exp of Wscale
788 : /*mixer-q adjusted for Wscale multplication below */
789 158582 : hMdEnc->q_mixer_mat_fx = sub( hMdEnc->q_mixer_mat_fx, Wscale_e );
790 158582 : move16();
791 1451812 : FOR( b = 0; b < num_bands; b++ )
792 : {
793 1293230 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
794 1293230 : move16();
795 1293230 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
796 1293230 : move16();
797 :
798 7692550 : FOR( i = 0; i < num_ch; i++ )
799 : {
800 6399320 : hMdEnc->mixer_mat_fx[0][i][b] = Mpy_32_32( hMdEnc->mixer_mat_fx[0][i][b], Wscale_fx[b] );
801 6399320 : move32();
802 37209200 : FOR( j = 1; j < num_ch; j++ )
803 : {
804 30809880 : hMdEnc->mixer_mat_fx[j][i][b] = L_shr( hMdEnc->mixer_mat_fx[j][i][b], Wscale_e ); // Q(hMdEnc->q_mixer_mat_fx)
805 30809880 : move32();
806 : }
807 : }
808 1293230 : test();
809 1293230 : IF( NE_16( ndm, num_ch ) && NE_16( ndm, 1 ) )
810 : {
811 843166 : ivas_calc_c_p_coeffs_enc_fx( &hMdEnc->spar_md, cov_real_fx, cov_real_q, 0, hMdEnc->mixer_mat_fx, hMdEnc->q_mixer_mat_fx, num_ch, ndm, b, dtx_vad, 0, dyn_active_w_flag );
812 :
813 843166 : IF( dirac_mono_flag )
814 : {
815 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
816 0 : move16();
817 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
818 0 : move16();
819 0 : FOR( j = 0; j < ndec; j++ )
820 : {
821 0 : FOR( k = 0; k < ndm - 1; k++ )
822 : {
823 0 : hMdEnc->spar_md.band_coeffs[b].C_re_fx[j][k] = 0;
824 0 : move32();
825 : }
826 : }
827 : }
828 843166 : ivas_quant_c_per_band_fx( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b],
829 843166 : &hMdEnc->spar_md_cfg.quant_strat[qsi], ndec, ndm, hMdEnc->spar_md.band_coeffs[b].q_C_re_fx );
830 : }
831 : }
832 :
833 : /* band limit downmix matrix */
834 158582 : ivas_band_limit_dmx_matrix_fx( hMdEnc, num_ch, num_bands, bands_bw );
835 :
836 : /* band mixing */
837 158582 : IF( GT_16( bands_bw, 1 ) )
838 : {
839 15094 : ivas_band_mixing_fx( hMdEnc, num_ch, num_bands, nchan_transport, num_bands_full );
840 : }
841 :
842 158582 : IF( dtx_vad == 0 )
843 : {
844 1605 : ivas_write_parameter_bitstream_dtx_fx( &hMdEnc->spar_md, hMetaData, hMdEnc->spar_md_cfg.num_dmx_chans_per_band, hMdEnc->spar_md_cfg.num_decorr_per_band, num_bands );
845 1605 : BREAK;
846 : }
847 :
848 156977 : ivas_select_next_strat_fx( hMdEnc->spar_md_cfg.prior_strat, cs, dmx_switch, dtx_vad );
849 :
850 397253 : FOR( i = 0; i < MAX_CODING_STRATS; i++ )
851 : {
852 360439 : strat = cs[i];
853 360439 : move16();
854 360439 : IF( NE_16( strat, NO_STRAT ) )
855 : {
856 358513 : reset_indices_enc_fx( &hMetaData_tmp, md_indices_allocated );
857 :
858 358513 : ivas_write_spar_md_bitstream_fx( hMdEnc, num_bands, bands_bw, &hMetaData_tmp, hEncoderConfig->ivas_total_brate, strat, qsi );
859 :
860 : /*write to main buffer if its a valid bitstream*/
861 358513 : IF( hMetaData_tmp.nb_bits_tot > 0 )
862 : {
863 284379 : test();
864 284379 : IF( EQ_16( hMetaData->nb_bits_tot, bit_pos_start ) || LT_16( hMetaData_tmp.nb_bits_tot, sub( hMetaData->nb_bits_tot, bit_pos_start ) ) )
865 : {
866 234150 : write_metadata_buffer_fx( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start );
867 234150 : code_strat = strat;
868 234150 : move16();
869 : }
870 : Word16 add_bit;
871 284379 : test();
872 284379 : IF( ( EQ_32( hEncoderConfig->ivas_total_brate, IVAS_256k ) && EQ_16( sba_order, SBA_FOA_ORDER ) ) )
873 : {
874 13313 : add_bit = 1;
875 13313 : move16();
876 : }
877 : ELSE
878 : {
879 271066 : add_bit = 0;
880 271066 : move16();
881 : }
882 284379 : IF( LE_16( add( sub( hMetaData->nb_bits_tot, bit_pos_start ), add_bit ), hMdEnc->spar_md_cfg.tgt_bits_per_blk ) )
883 : {
884 120163 : packed_ok = 1;
885 120163 : move16();
886 120163 : BREAK;
887 : }
888 : }
889 : }
890 : }
891 :
892 156977 : IF( EQ_16( packed_ok, 1 ) )
893 : {
894 120163 : BREAK;
895 : }
896 :
897 : /*only if valid bitstream was written to main buffer*/
898 36814 : IF( GT_16( hMetaData->nb_bits_tot, bit_pos_start ) )
899 : {
900 : Word16 add_bit;
901 35732 : test();
902 35732 : IF( EQ_32( hEncoderConfig->ivas_total_brate, IVAS_256k ) && EQ_16( sba_order, SBA_FOA_ORDER ) )
903 : {
904 0 : add_bit = 1;
905 0 : move16();
906 : }
907 : ELSE
908 : {
909 35732 : add_bit = 0;
910 35732 : move16();
911 : }
912 35732 : IF( LE_16( add( sub( hMetaData->nb_bits_tot, bit_pos_start ), add_bit ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
913 : {
914 35732 : packed_ok = 1;
915 35732 : move16();
916 35732 : BREAK;
917 : }
918 : }
919 : }
920 157500 : IF( GT_16( hMdEnc->q_mixer_mat_fx, *q_prior_mixer ) )
921 : {
922 85295 : FOR( i = 0; i < num_ch; i++ )
923 : {
924 341180 : FOR( j = 0; j < num_ch; j++ )
925 : {
926 3548272 : FOR( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
927 : {
928 3275328 : hMdEnc->mixer_mat_fx[i][j][b] = L_shr( hMdEnc->mixer_mat_fx[i][j][b], sub( hMdEnc->q_mixer_mat_fx, *q_prior_mixer ) );
929 3275328 : move32();
930 : }
931 : }
932 : }
933 17059 : hMdEnc->q_mixer_mat_fx = *q_prior_mixer;
934 17059 : move16();
935 : }
936 : ELSE
937 : {
938 508890 : FOR( i = 0; i < nchan_out; i++ )
939 : {
940 2251045 : FOR( j = 0; j < num_ch; j++ )
941 : {
942 24473748 : FOR( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
943 : {
944 22591152 : prior_mixer[i][j][b] = L_shr( prior_mixer[i][j][b], sub( *q_prior_mixer, hMdEnc->q_mixer_mat_fx ) );
945 22591152 : move32();
946 : }
947 : }
948 : }
949 140441 : *q_prior_mixer = hMdEnc->q_mixer_mat_fx;
950 140441 : move16();
951 : }
952 : /* Reuse mixer matrix values for unsent bands */
953 157500 : test();
954 157500 : IF( ( LT_32( hEncoderConfig->ivas_total_brate, IVAS_24k4 ) ) && GT_16( code_strat, 3 ) )
955 : {
956 38235 : FOR( b = 0; b < num_bands * bands_bw; b += 2 * bands_bw )
957 : {
958 25490 : test();
959 25490 : IF( ( b == 0 ) && ( s_and( code_strat, 1 ) == 0 ) )
960 : {
961 6560 : b = add( b, 2 );
962 : }
963 50980 : FOR( i = 0; i < 1; i++ )
964 : {
965 127450 : FOR( j = 0; j < 4; j++ )
966 : {
967 101960 : hMdEnc->mixer_mat_fx[i][j][b] = prior_mixer[i][j][b];
968 101960 : move32();
969 101960 : hMdEnc->mixer_mat_fx[i][j][b + 1] = prior_mixer[i][j][b + 1];
970 101960 : move32();
971 : }
972 : }
973 : }
974 : }
975 :
976 157500 : ivas_store_prior_coeffs_fx( hMdEnc, num_bands, code_strat, dtx_vad, qsi );
977 :
978 157500 : hMdEnc->spar_md.dtx_vad = dtx_vad;
979 157500 : move16();
980 157500 : hMdEnc->spar_md.num_bands = num_bands;
981 157500 : move16();
982 :
983 157500 : free( ind_list_tmp );
984 :
985 157500 : return IVAS_ERR_OK;
986 : }
987 : /*-----------------------------------------------------------------------------------------*
988 : * Function ivas_band_mixer()
989 : *
990 : * band mixer
991 : *-----------------------------------------------------------------------------------------*/
992 :
993 14744 : static void ivas_band_mixer_fx(
994 : Word32 *cov_real_fx[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], // Q(cov_real_q)
995 : Word16 *cov_real_q[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
996 : const Word16 num_ch,
997 : Word16 *num_bands,
998 : Word16 red_band_fact )
999 : {
1000 : Word16 i, j, k, b, orig_band, rem_band;
1001 : Word32 avg_cov;
1002 : Word16 avg_cov_e;
1003 :
1004 14744 : orig_band = *num_bands;
1005 14744 : move16();
1006 14744 : *num_bands = idiv1616( *num_bands, red_band_fact );
1007 14744 : move16();
1008 14744 : rem_band = sub( orig_band, i_mult( *num_bands, red_band_fact ) );
1009 :
1010 73720 : FOR( i = 0; i < num_ch; i++ )
1011 : {
1012 294880 : FOR( j = 0; j < num_ch; j++ )
1013 : {
1014 892256 : FOR( k = 0; k < *num_bands - 1; k++ )
1015 : {
1016 656352 : avg_cov_e = 0;
1017 656352 : move16();
1018 656352 : avg_cov = 0;
1019 656352 : move32();
1020 2020416 : FOR( b = 0; b < red_band_fact; b++ )
1021 : {
1022 1364064 : avg_cov = BASOP_Util_Add_Mant32Exp( avg_cov, avg_cov_e, cov_real_fx[i][j][red_band_fact * k + b], sub( Q31, cov_real_q[i][j][red_band_fact * k + b] ), &avg_cov_e );
1023 : }
1024 656352 : cov_real_fx[i][j][k] = avg_cov;
1025 656352 : move32();
1026 656352 : cov_real_q[i][j][k] = sub( Q31, avg_cov_e );
1027 656352 : move16();
1028 : }
1029 :
1030 235904 : avg_cov_e = 0;
1031 235904 : move16();
1032 235904 : avg_cov = 0;
1033 235904 : move32();
1034 759072 : FOR( b = 0; b < red_band_fact + rem_band; b++ )
1035 : {
1036 523168 : avg_cov = BASOP_Util_Add_Mant32Exp( avg_cov, avg_cov_e, cov_real_fx[i][j][red_band_fact * ( *num_bands - 1 ) + b], sub( Q31, cov_real_q[i][j][red_band_fact * ( *num_bands - 1 ) + b] ), &avg_cov_e );
1037 : }
1038 :
1039 235904 : cov_real_fx[i][j][*num_bands - 1] = avg_cov;
1040 235904 : move32();
1041 235904 : cov_real_q[i][j][*num_bands - 1] = sub( Q31, avg_cov_e );
1042 235904 : move16();
1043 : }
1044 : }
1045 :
1046 14744 : return;
1047 : }
1048 :
1049 : /*-----------------------------------------------------------------------------------------*
1050 : * Function ivas_write_spar_md_bitstream()
1051 : *
1052 : * Write MD parameters into bitstream
1053 : *-----------------------------------------------------------------------------------------*/
1054 358513 : static void ivas_write_spar_md_bitstream_fx(
1055 : ivas_spar_md_enc_state_t *hMdEnc,
1056 : const Word16 nB,
1057 : const Word16 bands_bw,
1058 : BSTR_ENC_HANDLE hMetaData,
1059 : const Word32 ivas_total_brate,
1060 : const Word16 strat,
1061 : const Word16 qsi )
1062 : {
1063 : Word16 no_ec, i;
1064 : Word16 do_diff[IVAS_MAX_NUM_BANDS];
1065 : Word16 entropy_coding_result;
1066 :
1067 358513 : IF( EQ_16( strat, NO_STRAT ) )
1068 : {
1069 0 : return;
1070 : }
1071 :
1072 : /* write quant strat */
1073 358513 : IF( GE_32( ivas_total_brate, BRATE_SPAR_Q_STRAT ) )
1074 : {
1075 43640 : push_next_indice( hMetaData, shr( qsi, 1 ), sub( hMdEnc->spar_md_cfg.quant_strat_bits, 1 ) );
1076 : }
1077 : ELSE
1078 : {
1079 314873 : push_next_indice( hMetaData, qsi, hMdEnc->spar_md_cfg.quant_strat_bits );
1080 : }
1081 :
1082 358513 : no_ec = 0;
1083 358513 : move16();
1084 :
1085 358513 : IF( LT_32( ivas_total_brate, IVAS_24k4 ) )
1086 : {
1087 39723 : SWITCH( strat )
1088 : {
1089 13489 : case BASE:
1090 13489 : push_next_indice( hMetaData, sub( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1091 13489 : BREAK;
1092 13489 : case BASE_NOEC:
1093 13489 : push_next_indice( hMetaData, add( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1094 13489 : no_ec = 1;
1095 13489 : move16();
1096 13489 : BREAK;
1097 12745 : case FOUR_A:
1098 : case FOUR_C:
1099 : case FOUR_B:
1100 : case FOUR_D:
1101 12745 : push_next_indice( hMetaData, strat, SPAR_NUM_CODING_STRAT_BITS );
1102 12745 : BREAK;
1103 : }
1104 : /* for LBR SBA 40MS MD never do time diff */
1105 198615 : FOR( i = 0; i < nB; i++ )
1106 : {
1107 158892 : do_diff[i] = 0;
1108 158892 : move16();
1109 : }
1110 : }
1111 : ELSE
1112 : {
1113 318790 : SWITCH( strat )
1114 : {
1115 143488 : case BASE:
1116 143488 : push_next_indice( hMetaData, sub( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1117 1379552 : FOR( i = 0; i < nB; i++ )
1118 : {
1119 1236064 : do_diff[i] = 0;
1120 1236064 : move16();
1121 : }
1122 143488 : BREAK;
1123 89583 : case BASE_NOEC:
1124 89583 : push_next_indice( hMetaData, add( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1125 806247 : FOR( i = 0; i < nB; i++ )
1126 : {
1127 716664 : do_diff[i] = 0;
1128 716664 : move16();
1129 : }
1130 89583 : no_ec = 1;
1131 89583 : move16();
1132 89583 : BREAK;
1133 24186 : case FOUR_A:
1134 24186 : push_next_indice( hMetaData, 4, SPAR_NUM_CODING_STRAT_BITS );
1135 217674 : FOR( i = 0; i < nB; i++ )
1136 : {
1137 193488 : do_diff[i] = ( ( s_and( ( add( i, 1 ) ), 3 ) ) != 0 );
1138 193488 : move16();
1139 : }
1140 24186 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1141 24186 : BREAK;
1142 21733 : case FOUR_B:
1143 21733 : push_next_indice( hMetaData, 5, SPAR_NUM_CODING_STRAT_BITS );
1144 195597 : FOR( i = 0; i < nB; i++ )
1145 : {
1146 173864 : do_diff[i] = extract_l( NE_16( ( s_and( ( add( i, 1 ) ), 3 ) ), 1 ) );
1147 173864 : move16();
1148 : }
1149 21733 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1150 21733 : BREAK;
1151 20376 : case FOUR_C:
1152 20376 : push_next_indice( hMetaData, 6, SPAR_NUM_CODING_STRAT_BITS );
1153 183384 : FOR( i = 0; i < nB; i++ )
1154 : {
1155 163008 : do_diff[i] = extract_l( NE_16( ( s_and( ( add( i, 1 ) ), 3 ) ), 2 ) );
1156 163008 : move16();
1157 : }
1158 20376 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1159 20376 : BREAK;
1160 19424 : case FOUR_D:
1161 19424 : push_next_indice( hMetaData, 7, SPAR_NUM_CODING_STRAT_BITS );
1162 174816 : FOR( i = 0; i < nB; i++ )
1163 : {
1164 155392 : do_diff[i] = extract_l( NE_16( ( s_and( ( add( i, 1 ) ), 3 ) ), 3 ) );
1165 155392 : move16();
1166 : }
1167 19424 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1168 19424 : BREAK;
1169 : }
1170 358513 : }
1171 :
1172 358513 : IF( EQ_16( no_ec, 1 ) )
1173 : {
1174 : entropy_coding_result =
1175 103072 : ivas_get_huffman_coded_bs_fx( hMdEnc, hMetaData, nB, qsi,
1176 : bands_bw );
1177 103072 : move16();
1178 : }
1179 : ELSE
1180 : {
1181 : entropy_coding_result =
1182 255441 : ivas_get_arith_coded_bs_fx( hMdEnc, hMetaData, do_diff, bands_bw, nB, qsi,
1183 : strat, ivas_total_brate );
1184 255441 : move16();
1185 : }
1186 :
1187 358513 : if ( entropy_coding_result < 0 )
1188 : {
1189 74134 : hMetaData->nb_bits_tot = 0;
1190 74134 : move16();
1191 : }
1192 :
1193 358513 : return;
1194 : }
1195 :
1196 :
1197 : /*-----------------------------------------------------------------------------------------*
1198 : * Function ivas_get_huffman_coded_bs()
1199 : *
1200 : * Generate huffman coded bitstream
1201 : *-----------------------------------------------------------------------------------------*/
1202 103072 : static Word16 ivas_get_huffman_coded_bs_fx(
1203 : ivas_spar_md_enc_state_t *hMdEnc,
1204 : BSTR_ENC_HANDLE hMetaData,
1205 : const Word16 nB,
1206 : const Word16 qsi,
1207 : const Word16 bands_bw )
1208 : {
1209 : Word16 i, j;
1210 : Word16 pred_coeff_dim, pred_offset;
1211 :
1212 821292 : FOR( i = 0; i < nB; i++ )
1213 : {
1214 : Word16 code, len;
1215 : Word16 ndm, ndec;
1216 763908 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i * bands_bw];
1217 763908 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[i * bands_bw];
1218 763908 : move16();
1219 763908 : move16();
1220 :
1221 763908 : pred_coeff_dim = sub( add( ndm, ndec ), 1 );
1222 763908 : pred_offset = 0;
1223 763908 : move16();
1224 763908 : test();
1225 763908 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1226 : {
1227 0 : if ( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1228 : {
1229 0 : pred_offset = DIRAC_TO_SPAR_HBR_PRED_CHS;
1230 0 : move16();
1231 : }
1232 : }
1233 :
1234 3018395 : FOR( j = pred_offset; j < pred_coeff_dim; j++ )
1235 : {
1236 2277337 : ivas_huffman_encode_fx( &hMdEnc->huff_coeffs.pred_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j], &code, &len );
1237 2277337 : IF( GT_16( ( add( hMetaData->nb_bits_tot, len ) ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
1238 : {
1239 45688 : return -1;
1240 : }
1241 2254487 : push_next_indice( hMetaData, code, len );
1242 : }
1243 :
1244 741058 : Word16 n = imult1616( ndec, sub( ndm, 1 ) );
1245 1638192 : FOR( j = 0; j < n; j++ )
1246 : {
1247 903970 : ivas_huffman_encode_fx( &hMdEnc->huff_coeffs.drct_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].drct_index_re[j], &code, &len );
1248 903970 : IF( GT_16( ( add( hMetaData->nb_bits_tot, len ) ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
1249 : {
1250 6836 : return -1;
1251 : }
1252 897134 : push_next_indice( hMetaData, code, len );
1253 : }
1254 :
1255 2211961 : FOR( j = 0; j < ndec; j++ )
1256 : {
1257 1493741 : ivas_huffman_encode_fx( &hMdEnc->huff_coeffs.decd_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].decd_index_re[j], &code, &len );
1258 1493741 : IF( GT_16( ( add( hMetaData->nb_bits_tot, len ) ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
1259 : {
1260 16002 : return -1;
1261 : }
1262 1477739 : push_next_indice( hMetaData, code, len );
1263 : }
1264 : }
1265 :
1266 57384 : return 0;
1267 : }
1268 :
1269 :
1270 : /*-----------------------------------------------------------------------------------------*
1271 : * Function ivas_get_arith_coded_bs()
1272 : *
1273 : * Generate arithmetic coded bitstream
1274 : *-----------------------------------------------------------------------------------------*/
1275 :
1276 255441 : static Word16 ivas_get_arith_coded_bs_fx(
1277 : ivas_spar_md_enc_state_t *hMdEnc,
1278 : BSTR_ENC_HANDLE hMetaData,
1279 : const Word16 *pDo_diff,
1280 : const Word16 bands_bw,
1281 : const Word16 nB,
1282 : const Word16 qsi,
1283 : const Word16 strat,
1284 : const Word32 ivas_total_brate )
1285 : {
1286 : Word16 i, any_diff;
1287 : Word16 j;
1288 : ivas_cell_dim_t pred_cell_dims[IVAS_MAX_NUM_BANDS];
1289 : ivas_cell_dim_t drct_cell_dims[IVAS_MAX_NUM_BANDS];
1290 : ivas_cell_dim_t decd_cell_dims[IVAS_MAX_NUM_BANDS];
1291 : ivas_cell_dim_t decx_cell_dims[IVAS_MAX_NUM_BANDS];
1292 : Word16 symbol_arr_re[IVAS_MAX_INPUT_LEN];
1293 : Word16 symbol_arr_old_re[IVAS_MAX_INPUT_LEN];
1294 : Word16 arith_result;
1295 :
1296 2282193 : FOR( i = 0; i < nB; i++ )
1297 : {
1298 : Word16 ndm, ndec;
1299 2026752 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[bands_bw * i];
1300 2026752 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[bands_bw * i];
1301 2026752 : move16();
1302 2026752 : move16();
1303 :
1304 2026752 : test();
1305 2026752 : test();
1306 2026752 : test();
1307 2026752 : test();
1308 2026752 : test();
1309 2026752 : IF( ( LT_32( ivas_total_brate, IVAS_24k4 ) ) && ( GT_16( strat, 3 ) ) && ( ( ( EQ_16( i % 2, 1 ) ) && ( strat % 2 == 0 ) ) || ( ( i % 2 == 0 ) && ( EQ_16( strat % 2, 1 ) ) ) ) )
1310 : {
1311 25490 : pred_cell_dims[i].dim1 = 0;
1312 25490 : pred_cell_dims[i].dim2 = 0;
1313 25490 : drct_cell_dims[i].dim1 = 0;
1314 25490 : drct_cell_dims[i].dim2 = 0;
1315 25490 : decd_cell_dims[i].dim1 = 0;
1316 25490 : decd_cell_dims[i].dim2 = 0;
1317 25490 : decx_cell_dims[i].dim1 = 0;
1318 25490 : decx_cell_dims[i].dim2 = 0;
1319 25490 : move16();
1320 25490 : move16();
1321 25490 : move16();
1322 25490 : move16();
1323 25490 : move16();
1324 25490 : move16();
1325 25490 : move16();
1326 25490 : move16();
1327 : }
1328 : ELSE
1329 : {
1330 2001262 : pred_cell_dims[i].dim1 = sub( add( ndm, ndec ), 1 );
1331 2001262 : move16();
1332 2001262 : test();
1333 2001262 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1334 : {
1335 145200 : IF( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1336 : {
1337 48400 : pred_cell_dims[i].dim1 = sub( pred_cell_dims[i].dim1, ( FOA_CHANNELS - 1 ) );
1338 48400 : move16();
1339 : }
1340 : }
1341 2001262 : pred_cell_dims[i].dim2 = 1;
1342 2001262 : drct_cell_dims[i].dim1 = ndec;
1343 2001262 : drct_cell_dims[i].dim2 = sub( ndm, 1 );
1344 2001262 : decd_cell_dims[i].dim1 = ndec;
1345 2001262 : decd_cell_dims[i].dim2 = 1;
1346 2001262 : decx_cell_dims[i].dim1 = shr( ( imult1616( ndec, sub( ndec, 1 ) ) ), 1 );
1347 2001262 : decx_cell_dims[i].dim2 = 1;
1348 2001262 : move16();
1349 2001262 : move16();
1350 2001262 : move16();
1351 2001262 : move16();
1352 2001262 : move16();
1353 2001262 : move16();
1354 2001262 : move16();
1355 : }
1356 : }
1357 :
1358 255441 : any_diff = 0;
1359 255441 : move16();
1360 1618174 : FOR( i = 0; i < nB; i++ )
1361 : {
1362 1448452 : IF( pDo_diff[i] != 0 )
1363 : {
1364 85719 : any_diff = 1;
1365 85719 : move16();
1366 85719 : BREAK;
1367 : }
1368 : }
1369 :
1370 255441 : test();
1371 255441 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1372 : {
1373 157300 : FOR( i = 0; i < nB; i++ )
1374 : {
1375 145200 : IF( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1376 : {
1377 196960 : FOR( j = 0; j < pred_cell_dims[i].dim1; j++ )
1378 : {
1379 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] =
1380 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1381 148560 : move16();
1382 148560 : IF( EQ_16( any_diff, 1 ) )
1383 : {
1384 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j] =
1385 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1386 0 : move16();
1387 : }
1388 : }
1389 : }
1390 : }
1391 : }
1392 255441 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, pred_cell_dims, PRED_COEFF );
1393 :
1394 255441 : IF( EQ_16( any_diff, 1 ) )
1395 : {
1396 85719 : 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 );
1397 : }
1398 :
1399 255441 : arith_result = ivas_arith_encode_cmplx_cell_array_fx( &hMdEnc->arith_coeffs.pred_arith_re[qsi], &hMdEnc->arith_coeffs.pred_arith_re_diff[qsi], pDo_diff, nB,
1400 255441 : symbol_arr_re, symbol_arr_old_re, pred_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1401 255441 : move16();
1402 255441 : IF( arith_result < 0 )
1403 : {
1404 947 : return -1;
1405 : }
1406 :
1407 254494 : test();
1408 254494 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1409 : {
1410 157300 : FOR( i = 0; i < nB; i++ )
1411 : {
1412 145200 : IF( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1413 : {
1414 196960 : FOR( j = pred_cell_dims[i].dim1 - 1; j >= 0; j-- )
1415 : {
1416 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS] =
1417 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j];
1418 148560 : move16();
1419 : }
1420 193600 : FOR( j = 0; j < DIRAC_TO_SPAR_HBR_PRED_CHS; j++ )
1421 : {
1422 145200 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] = 0;
1423 145200 : move16();
1424 : }
1425 : }
1426 : }
1427 : }
1428 :
1429 254494 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, drct_cell_dims, DRCT_COEFF );
1430 :
1431 254494 : IF( EQ_16( any_diff, 1 ) )
1432 : {
1433 85719 : 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 );
1434 : }
1435 :
1436 :
1437 254494 : arith_result = ivas_arith_encode_cmplx_cell_array_fx( &hMdEnc->arith_coeffs.drct_arith_re[qsi], &hMdEnc->arith_coeffs.drct_arith_re_diff[qsi], pDo_diff, nB,
1438 254494 : symbol_arr_re, symbol_arr_old_re, drct_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1439 254494 : move16();
1440 :
1441 254494 : IF( arith_result < 0 )
1442 : {
1443 4 : return -1;
1444 : }
1445 :
1446 254490 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decd_cell_dims, DECD_COEFF );
1447 :
1448 254490 : IF( EQ_16( any_diff, 1 ) )
1449 : {
1450 85715 : 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 );
1451 : }
1452 :
1453 254490 : arith_result = ivas_arith_encode_cmplx_cell_array_fx( &hMdEnc->arith_coeffs.decd_arith_re[qsi], &hMdEnc->arith_coeffs.decd_arith_re_diff[qsi], pDo_diff, nB,
1454 254490 : symbol_arr_re, symbol_arr_old_re, decd_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1455 254490 : move16();
1456 :
1457 254490 : IF( arith_result < 0 )
1458 : {
1459 27495 : return -1;
1460 : }
1461 :
1462 226995 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decx_cell_dims, DECX_COEFF );
1463 :
1464 226995 : IF( EQ_16( any_diff, 1 ) )
1465 : {
1466 84718 : 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 );
1467 : }
1468 :
1469 226995 : return 0;
1470 : }
1471 :
1472 :
1473 : /*-----------------------------------------------------------------------------------------*
1474 : * Function ivas_select_next_strat()
1475 : *
1476 : * Select next strategy
1477 : *-----------------------------------------------------------------------------------------*/
1478 156977 : static void ivas_select_next_strat_fx(
1479 : ivas_strats_t prior_strat,
1480 : ivas_strats_t cs[MAX_QUANT_STRATS],
1481 : const Word16 dmx_switch,
1482 : const Word16 dtx_vad )
1483 : {
1484 156977 : cs[0] = BASE;
1485 156977 : move16();
1486 156977 : cs[1] = BASE_NOEC;
1487 156977 : move16();
1488 :
1489 156977 : test();
1490 156977 : IF( dmx_switch == 0 && dtx_vad )
1491 : {
1492 156977 : SWITCH( prior_strat )
1493 : {
1494 2476 : case START:
1495 2476 : cs[2] = NO_STRAT;
1496 2476 : move16();
1497 2476 : BREAK;
1498 56818 : case BASE:
1499 56818 : cs[2] = FOUR_A;
1500 56818 : move16();
1501 56818 : BREAK;
1502 0 : case BASE_DIFF:
1503 0 : cs[2] = FOUR_A;
1504 0 : move16();
1505 0 : BREAK;
1506 3006 : case BASE_NOEC:
1507 3006 : cs[2] = FOUR_A;
1508 3006 : move16();
1509 3006 : BREAK;
1510 25641 : case FOUR_A:
1511 25641 : cs[2] = FOUR_B;
1512 25641 : move16();
1513 25641 : BREAK;
1514 24002 : case FOUR_B:
1515 24002 : cs[2] = FOUR_C;
1516 24002 : move16();
1517 24002 : BREAK;
1518 22968 : case FOUR_C:
1519 22968 : cs[2] = FOUR_D;
1520 22968 : move16();
1521 22968 : BREAK;
1522 22066 : case FOUR_D:
1523 22066 : cs[2] = FOUR_A;
1524 22066 : move16();
1525 22066 : BREAK;
1526 0 : default:
1527 0 : assert( !"bad value of prior_strat" );
1528 : }
1529 0 : }
1530 :
1531 156977 : return;
1532 : }
1533 :
1534 : /*-----------------------------------------------------------------------------------------*
1535 : * Function ivas_store_prior_coeffs()
1536 : *
1537 : * Store prior coeffs
1538 : *-----------------------------------------------------------------------------------------*/
1539 157500 : static void ivas_store_prior_coeffs_fx(
1540 : ivas_spar_md_enc_state_t *hMdEnc,
1541 : const Word16 num_bands,
1542 : const Word16 strat,
1543 : const Word16 dtx_vad,
1544 : const Word16 qsi )
1545 : {
1546 : Word16 i, j, b;
1547 157500 : IF( dtx_vad == 0 )
1548 : {
1549 1605 : hMdEnc->spar_md_cfg.prior_strat = START;
1550 1605 : move16();
1551 : }
1552 : ELSE
1553 : {
1554 155895 : hMdEnc->spar_md_cfg.prior_strat = strat;
1555 155895 : move16();
1556 : }
1557 :
1558 157500 : hMdEnc->spar_md_cfg.prev_quant_idx = qsi;
1559 157500 : move16();
1560 :
1561 1443474 : FOR( i = 0; i < num_bands; i++ )
1562 : {
1563 1285974 : b = i;
1564 1285974 : move16();
1565 :
1566 14145714 : FOR( j = 0; j < IVAS_SPAR_MAX_CH - 1; j++ )
1567 : {
1568 12859740 : hMdEnc->spar_md_prior.band_coeffs_idx[i].pred_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[j];
1569 12859740 : move16();
1570 12859740 : hMdEnc->spar_md_prior.band_coeffs_idx[i].decd_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[j];
1571 12859740 : move16();
1572 : }
1573 28291428 : FOR( j = 0; j < IVAS_SPAR_MAX_C_COEFF; j++ )
1574 : {
1575 27005454 : hMdEnc->spar_md_prior.band_coeffs_idx[i].drct_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].drct_index_re[j];
1576 27005454 : move16();
1577 : }
1578 : }
1579 :
1580 157500 : return;
1581 : }
1582 :
1583 : /*-----------------------------------------------------------------------------------------*
1584 : * Function ivas_spar_quant_pred_coeffs_dtx()
1585 : *
1586 : * Calculate quantization pred coeffs
1587 : *-----------------------------------------------------------------------------------------*/
1588 3210 : static void ivas_spar_quant_pred_coeffs_dtx_fx(
1589 : ivas_spar_md_t *pSpar_md,
1590 : const Word32 *pValues, // Q28
1591 : const Word16 ndm,
1592 : Word16 *pIndex,
1593 : const Word16 dim1,
1594 : Word32 *pQuant // Q28
1595 : )
1596 : {
1597 : Word16 i;
1598 : Word16 q_lvl;
1599 : Word32 pr_min_max[2];
1600 :
1601 3210 : pr_min_max[0] = pSpar_md->min_max_fx[0]; // Q28
1602 3210 : move32();
1603 3210 : pr_min_max[1] = pSpar_md->min_max_fx[1]; // Q28
1604 3210 : move32();
1605 :
1606 12840 : FOR( i = 0; i < dim1; i++ )
1607 : {
1608 9630 : q_lvl = dtx_pr_real_q_levels[ndm - 1][i];
1609 9630 : move16();
1610 9630 : ivas_quantise_real_values_enc_fx( &pValues[i], q_lvl, pr_min_max[0], pr_min_max[1], &pIndex[i], &pQuant[i], 1 );
1611 : }
1612 :
1613 3210 : return;
1614 : }
1615 :
1616 :
1617 : /*-----------------------------------------------------------------------------------------*
1618 : * Function ivas_quant_p_per_band_dtx()
1619 : *
1620 : * Calculate quantization p
1621 : *-----------------------------------------------------------------------------------------*/
1622 3210 : static void ivas_quant_p_per_band_dtx_fx(
1623 : Word32 *pP_mat, // Q28
1624 : const Word16 num_dec,
1625 : const Word16 num_dmx,
1626 : Word16 *ppIdx_pd,
1627 : Word32 *pP_out, // Q28
1628 : const Word16 num_ch )
1629 : {
1630 : Word16 i;
1631 3210 : Word16 dim = sub( num_ch, num_dmx );
1632 :
1633 3210 : IF( EQ_16( num_dec, sub( num_ch, 1 ) ) )
1634 : {
1635 6736 : FOR( i = 0; i < dim; i++ )
1636 : {
1637 5052 : test();
1638 5052 : IF( LT_32( pP_mat[i], pr_boost_range_fx[1] ) && GT_32( pP_mat[i], pr_boost_range_fx[0] ) )
1639 : {
1640 1912 : pP_mat[i] = pr_boost_range_fx[1]; // Q28
1641 1912 : move32();
1642 : }
1643 : }
1644 : }
1645 :
1646 3210 : IF( NE_16( dim, num_dec ) )
1647 : {
1648 0 : assert( !"Not Supported!" );
1649 : }
1650 :
1651 11314 : FOR( i = 0; i < dim; i++ )
1652 : {
1653 8104 : ivas_quantise_real_values_enc_fx( &pP_mat[i], dtx_pd_real_q_levels[num_ch - num_dec - 1][i], dtx_pd_real_min_max_fx[0], dtx_pd_real_min_max_fx[1], &ppIdx_pd[i], &pP_out[i], 1 );
1654 : }
1655 :
1656 3210 : return;
1657 : }
1658 : /*-----------------------------------------------------------------------------------------*
1659 : * Function ivas_write_parameter_bitstream_dtx()
1660 : *
1661 : * Write MD DTX parameters into bitstream
1662 : *-----------------------------------------------------------------------------------------*/
1663 :
1664 1605 : static void ivas_write_parameter_bitstream_dtx_fx(
1665 : ivas_spar_md_t *pSpar_md,
1666 : BSTR_ENC_HANDLE hMetaData,
1667 : Word16 *num_dmx,
1668 : Word16 *num_dec,
1669 : const Word16 num_bands )
1670 : {
1671 : Word16 i, j;
1672 : Word32 val;
1673 : Word16 idx;
1674 : Word32 pr_min_max[2];
1675 : Word16 zero_pad_bits, sid_bits_len;
1676 1605 : sid_bits_len = hMetaData->nb_bits_tot;
1677 1605 : move16();
1678 1605 : pr_min_max[0] = pSpar_md->min_max_fx[0];
1679 1605 : move32();
1680 1605 : pr_min_max[1] = pSpar_md->min_max_fx[1];
1681 1605 : move32();
1682 :
1683 4815 : FOR( i = 0; i < num_bands; i++ )
1684 : {
1685 3210 : Word16 ndm = num_dmx[i];
1686 3210 : move16();
1687 3210 : Word16 ndec = num_dec[i];
1688 3210 : move16();
1689 :
1690 12840 : FOR( j = 0; j < FOA_CHANNELS - 1; j++ )
1691 : {
1692 : Word16 pr, pd;
1693 : Word16 pr_q_lvls, pd_q_lvls, pr_pd_bits;
1694 : Word16 pr_idx_1, pr_idx_2, pd_idx_1, pd_idx_2;
1695 : UWord16 value;
1696 :
1697 9630 : pr_idx_1 = pr_pr_idx_pairs[ndm - 1][j][0];
1698 9630 : move16();
1699 9630 : pr_idx_2 = pr_pr_idx_pairs[ndm - 1][j][1];
1700 9630 : move16();
1701 9630 : pd_idx_1 = pr_pd_idx_pairs[ndm - 1][j][0];
1702 9630 : move16();
1703 9630 : pd_idx_2 = pr_pd_idx_pairs[ndm - 1][j][1];
1704 9630 : move16();
1705 :
1706 9630 : test();
1707 9630 : test();
1708 9630 : test();
1709 9630 : IF( pr_idx_1 != 0 || pd_idx_1 != 0 || pr_idx_2 != 0 || pd_idx_2 != 0 )
1710 : {
1711 9630 : pr_q_lvls = dtx_pr_real_q_levels[ndm - 1][pd_idx_1 - 1];
1712 9630 : move16();
1713 9630 : pr = pSpar_md->band_coeffs_idx[i].pred_index_re[pd_idx_1 - 1];
1714 9630 : move16();
1715 :
1716 9630 : IF( GT_16( add( j, 1 ), ndec ) )
1717 : {
1718 1526 : pd_q_lvls = 1;
1719 1526 : move16();
1720 1526 : pd = 0;
1721 1526 : move16();
1722 : }
1723 : ELSE
1724 : {
1725 8104 : pd_q_lvls = dtx_pd_real_q_levels[ndm - 1][pd_idx_2 - 1];
1726 8104 : move16();
1727 8104 : pd = pSpar_md->band_coeffs_idx[i].decd_index_re[pd_idx_2 - 1];
1728 8104 : move16();
1729 : }
1730 9630 : val = dtx_pd_real_min_max_fx[0];
1731 9630 : move32();
1732 9630 : ivas_quantise_real_values_enc_fx( &val, pd_q_lvls, dtx_pd_real_min_max_fx[0], dtx_pd_real_min_max_fx[1], &idx, &val, 1 );
1733 :
1734 9630 : pd = sub( pd, idx );
1735 :
1736 9630 : val = pr_min_max[0];
1737 9630 : move32();
1738 9630 : ivas_quantise_real_values_enc_fx( &val, pr_q_lvls, pr_min_max[0], pr_min_max[1], &idx, &val, 1 );
1739 :
1740 9630 : pr = sub( pr, idx );
1741 9630 : pr_pd_bits = ivas_get_bits_to_encode( i_mult( pd_q_lvls, pr_q_lvls ) );
1742 :
1743 9630 : value = (UWord16) ( add( i_mult( pr, pd_q_lvls ), pd ) );
1744 :
1745 9630 : push_next_indice( hMetaData, value, pr_pd_bits );
1746 : }
1747 : }
1748 : }
1749 :
1750 1605 : sid_bits_len = sub( hMetaData->nb_bits_tot, sid_bits_len );
1751 1605 : zero_pad_bits = sub( i_mult( SPAR_DTX_BANDS, SPAR_SID_BITS_TAR_PER_BAND ), sid_bits_len );
1752 1605 : assert( zero_pad_bits >= 0 );
1753 1605 : IF( EQ_16( num_dmx[0], 2 ) )
1754 : {
1755 763 : zero_pad_bits = sub( zero_pad_bits, 1 );
1756 : }
1757 :
1758 2368 : WHILE( zero_pad_bits > 0 )
1759 : {
1760 763 : j = s_min( zero_pad_bits, 16 );
1761 763 : push_next_indice( hMetaData, 0, j );
1762 763 : zero_pad_bits = sub( zero_pad_bits, j );
1763 : }
1764 :
1765 1605 : return;
1766 : }
1767 :
1768 :
1769 : /*-----------------------------------------------------------------------------------------*
1770 : * Function ivas_quant_pred_coeffs_per_band()
1771 : *
1772 : * Quantization of prediction coefficients
1773 : *-----------------------------------------------------------------------------------------*/
1774 1290020 : static void ivas_quant_pred_coeffs_per_band_fx(
1775 : ivas_band_coeffs_t *pband_coeffs,
1776 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1777 : ivas_quant_strat_t *pQs,
1778 : const Word16 num_ch )
1779 : {
1780 1290020 : ivas_quantise_real_values_enc_fx( pband_coeffs->pred_re_fx, pQs->PR.q_levels[0], pQs->PR.min_fx, pQs->PR.max_fx, pBand_coeffs_idx->pred_index_re, pband_coeffs->pred_quant_re_fx, sub( num_ch, 1 ) );
1781 :
1782 1290020 : return;
1783 : }
1784 :
1785 : /*-----------------------------------------------------------------------------------------*
1786 : * Function ivas_quant_c_per_band()
1787 : *
1788 : * Quantization of cross prediction c coeffs for each band
1789 : *-----------------------------------------------------------------------------------------*/
1790 843166 : static void ivas_quant_c_per_band_fx(
1791 : ivas_band_coeffs_t *pband_coeffs,
1792 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1793 : ivas_quant_strat_t *pQs,
1794 : const Word16 ndec,
1795 : const Word16 ndm,
1796 : const Word16 q_C )
1797 : {
1798 : Word16 i;
1799 : Word16 j, k;
1800 : Word32 C_re[IVAS_SPAR_MAX_C_COEFF];
1801 843166 : k = 0;
1802 843166 : move16();
1803 2967106 : FOR( i = 0; i < ndec; i++ )
1804 : {
1805 6960512 : FOR( j = 0; j < ndm - 1; j++ )
1806 : {
1807 4836572 : C_re[k] = pband_coeffs->C_re_fx[i][j];
1808 4836572 : move32();
1809 4836572 : k++;
1810 : }
1811 : }
1812 843166 : ivas_quantise_real_values_enc_fx_varq( C_re, pQs->C.q_levels[0], pQs->C.min_fx, pQs->C.max_fx, pBand_coeffs_idx->drct_index_re, C_re, ndec * ( ndm - 1 ), q_C );
1813 843166 : k = 0;
1814 843166 : move16();
1815 2967106 : FOR( i = 0; i < ndec; i++ )
1816 : {
1817 6960512 : FOR( j = 0; j < ndm - 1; j++ )
1818 : {
1819 4836572 : pband_coeffs->C_quant_re_fx[i][j] = C_re[k];
1820 4836572 : move32();
1821 4836572 : k++;
1822 : }
1823 : }
1824 :
1825 843166 : return;
1826 : }
1827 :
1828 :
1829 : /*-----------------------------------------------------------------------------------------*
1830 : * Function ivas_quant_p_per_band()
1831 : *
1832 : * Quantization of decorrelation p coeffs for each band
1833 : *-----------------------------------------------------------------------------------------*/
1834 1138660 : static void ivas_quant_p_per_band_fx(
1835 : ivas_band_coeffs_t *pband_coeffs,
1836 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1837 : ivas_quant_strat_t *pQs,
1838 : const Word16 num_ch )
1839 : {
1840 1138660 : ivas_quantise_real_values_enc_fx( pband_coeffs->P_re_fx, pQs->P_r.q_levels[0], pQs->P_r.min_fx, pQs->P_r.max_fx, pBand_coeffs_idx->decd_index_re, pband_coeffs->P_quant_re_fx, sub( num_ch, 1 ) );
1841 :
1842 1138660 : return;
1843 : }
|
