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 158579 : 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 1442993 : FOR( b = 0; b < num_bands; b++ )
361 : {
362 1284414 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
363 1284414 : move16();
364 :
365 4282380 : FOR( i = ndm; i < num_ch; i++ )
366 : {
367 21696150 : FOR( j = 0; j < num_ch; j++ )
368 : {
369 18698184 : hMdEnc->mixer_mat_fx[i][j][b] = 0;
370 18698184 : move32();
371 : }
372 : }
373 : }
374 :
375 158579 : return;
376 : }
377 :
378 :
379 : /*-----------------------------------------------------------------------------------------*
380 : * Function ivas_band_mixing()
381 : *
382 : * Band mixing downmix matrix
383 : *-----------------------------------------------------------------------------------------*/
384 :
385 16413 : 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 16413 : red_band_fact = idiv1616( upmixed_bands, num_bands );
396 :
397 34316 : FOR( i = 0; i < nchan_transport; i++ )
398 : {
399 89515 : FOR( j = 0; j < num_ch; j++ )
400 : {
401 319236 : FOR( k = num_bands - 1; k >= 0; k-- )
402 : {
403 820520 : FOR( b = red_band_fact - 1; b >= 0; b-- )
404 : {
405 572896 : hMdEnc->mixer_mat_fx[i][j][red_band_fact * k + b] = hMdEnc->mixer_mat_fx[i][j][k];
406 572896 : move32();
407 : }
408 : }
409 71612 : 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 16413 : return;
418 : }
419 :
420 :
421 : /*-----------------------------------------------------------------------------------------*
422 : * Function write_metadata_buffer()
423 : *
424 : *
425 : *-----------------------------------------------------------------------------------------*/
426 :
427 231329 : 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 231329 : IF( hMetaData->nb_bits_tot > 0 )
436 : {
437 231329 : restore_metadata_buffer_fx( hMetaData, next_ind_start, bit_pos_start );
438 : }
439 :
440 37621901 : FOR( i = 0; i < hMetaData_tmp->nb_ind_tot; i++ )
441 : {
442 37390572 : push_next_indice( hMetaData, hMetaData_tmp->ind_list[i].value, hMetaData_tmp->ind_list[i].nb_bits );
443 : }
444 :
445 231329 : return;
446 : }
447 :
448 : /*-----------------------------------------------------------------------------------------*
449 : * Function ivas_spar_md_enc_process()
450 : *
451 : * SPAR FoA Meta Data generation process
452 : *-----------------------------------------------------------------------------------------*/
453 :
454 157500 : ivas_error ivas_spar_md_enc_process_fx(
455 : ivas_spar_md_enc_state_t *hMdEnc, /* i/o: SPAR MD encoder handle */
456 : const ENCODER_CONFIG_HANDLE hEncoderConfig, /* i : configuration structure */
457 : Word32 *cov_real_fx[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], /*Q(cov_real_q)*/
458 : Word16 *cov_real_q[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
459 : Word32 *cov_dtx_real_fx[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], /*Q(cov_dtx_real_q)*/
460 : Word16 *cov_dtx_real_q[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
461 : BSTR_ENC_HANDLE hMetaData, /* i/o: MetaData handle */
462 : const Word16 dtx_vad,
463 : const Word16 nchan_inp,
464 : const Word16 sba_order, /* i : Ambisonic (SBA) order */
465 : Word32 *prior_mixer[IVAS_MAX_FB_MIXER_OUT_CH][IVAS_MAX_SPAR_FB_MIXER_IN_CH], /* i : prior mixer_matrix Q(q_prior_mixer) */
466 : Word16 *q_prior_mixer, /* i/o : q for prior mixer_matrix */
467 : const Word16 dyn_active_w_flag, /* i : flag to indicate dynamic active W */
468 : const Word16 dirac_mono_flag, /* i : flag to indicate mono only mode in SBA */
469 : const Word16 nchan_out )
470 : {
471 : Word32 pred_coeffs_re_fx[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
472 : Word32 dm_fv_re_fx[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
473 : Word16 q_dm_fv_re;
474 : Word16 i, j, b, qsi, ndm, ndec, num_ch, num_quant_strats;
475 : Word32 pred_coeffs_re_local_fx[IVAS_SPAR_MAX_CH - 1][IVAS_MAX_NUM_BANDS];
476 : Word16 k, bwidth, num_bands, num_bands_full, num_bands_bw;
477 : Word16 active_w, nchan_transport, dmx_switch, strat;
478 157500 : Word16 nB, bands_bw, packed_ok = 0;
479 157500 : move16();
480 : ivas_strats_t cs[MAX_CODING_STRATS];
481 : Word16 code_strat;
482 : Word16 bit_pos_start, next_ind_start;
483 : BSTR_ENC_DATA hMetaData_tmp;
484 : Indice *ind_list_tmp;
485 : Word16 md_indices_allocated;
486 : Word16 max_num_indices_tmp;
487 : Word32 Wscale_fx[IVAS_MAX_NUM_BANDS];
488 : Word16 q_Wscale[IVAS_MAX_NUM_BANDS];
489 :
490 : /*extra 16 bits for arithmetic coder as overshoot check is after a symbol is written*/
491 157500 : md_indices_allocated = add( hMdEnc->spar_md_cfg.max_bits_per_blk, IVAS_SPAR_ARITH_OVERSHOOT_BITS );
492 157500 : IF( ( ind_list_tmp = (Indice *) malloc( sizeof( Indice ) * md_indices_allocated ) ) == NULL )
493 : {
494 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for SPAR MD encoder indices" );
495 : }
496 :
497 157500 : num_quant_strats = hMdEnc->spar_md_cfg.num_quant_strats;
498 157500 : move16();
499 157500 : num_ch = ivas_sba_get_nchan_metadata_fx( sba_order, hEncoderConfig->ivas_total_brate );
500 157500 : test();
501 157500 : active_w = EQ_16( hMdEnc->spar_md_cfg.active_w, 1 ) || EQ_16( dyn_active_w_flag, 1 );
502 157500 : nchan_transport = hMdEnc->spar_md_cfg.nchan_transport;
503 157500 : move16();
504 :
505 157500 : bwidth = ivas_get_bw_idx_from_sample_rate_fx( hEncoderConfig->input_Fs );
506 157500 : bwidth = s_min( bwidth, hEncoderConfig->max_bwidth );
507 : Word16 active_w_vlbr;
508 157500 : IF( LT_32( hEncoderConfig->ivas_total_brate, IVAS_24k4 ) )
509 : {
510 13323 : active_w_vlbr = 1;
511 13323 : move16();
512 : }
513 : ELSE
514 : {
515 144177 : active_w_vlbr = 0;
516 144177 : move16();
517 : }
518 157500 : num_bands = ivas_get_num_bands_from_bw_idx( SPAR_CONFIG_BW );
519 157500 : IF( hMdEnc->spar_hoa_md_flag == 0 )
520 : {
521 135460 : num_bands = s_min( num_bands, SPAR_DIRAC_SPLIT_START_BAND );
522 : }
523 157500 : num_bands_full = num_bands;
524 157500 : move16();
525 157500 : num_bands_bw = ivas_get_num_bands_from_bw_idx( bwidth );
526 :
527 157500 : IF( dtx_vad == 0 )
528 : {
529 16815 : FOR( i = 0; i < nchan_inp; i++ )
530 : {
531 67260 : FOR( j = 0; j < nchan_inp; j++ )
532 : {
533 53808 : cov_real_fx[i][j] = cov_dtx_real_fx[i][j];
534 699504 : FOR( k = 0; k < IVAS_MAX_NUM_BANDS; k++ )
535 : {
536 645696 : cov_real_q[i][j][k] = cov_dtx_real_q[i][j][k];
537 645696 : move16();
538 : }
539 : }
540 : }
541 : }
542 :
543 889700 : FOR( i = 0; i < nchan_inp; i++ )
544 : {
545 4628660 : FOR( j = 0; j < nchan_inp; j++ )
546 : {
547 4584660 : FOR( k = num_bands_bw; k < IVAS_MAX_NUM_BANDS; k++ )
548 : {
549 688200 : cov_real_fx[i][j][k] = 0;
550 688200 : move32();
551 : }
552 : }
553 : }
554 :
555 157500 : test();
556 157500 : if ( EQ_32( hEncoderConfig->ivas_total_brate, BRATE_SPAR_Q_STRAT ) && EQ_16( sba_order, SBA_FOA_ORDER ) )
557 : {
558 : /* make sure that qsi is always 0 (temporary bits are '00') */
559 11580 : num_quant_strats = 1;
560 11580 : move16();
561 : }
562 :
563 157500 : hMetaData_tmp.ind_list = ind_list_tmp;
564 157500 : hMetaData_tmp.nb_bits_tot = 0;
565 157500 : move16();
566 157500 : max_num_indices_tmp = MAX_BITS_METADATA;
567 157500 : move16();
568 157500 : hMetaData_tmp.ivas_max_num_indices = &max_num_indices_tmp;
569 157500 : hMetaData_tmp.ivas_ind_list_zero = (Indice **) ( &hMetaData_tmp.ind_list );
570 157500 : hMetaData_tmp.st_ivas = NULL;
571 :
572 : /* Save state of metadata bitstream buffer */
573 157500 : bit_pos_start = hMetaData->nb_bits_tot;
574 157500 : move16();
575 157500 : next_ind_start = hMetaData->nb_ind_tot;
576 157500 : move16();
577 157500 : dmx_switch = 0;
578 157500 : move16();
579 :
580 157500 : IF( dtx_vad == 0 )
581 : {
582 3363 : nB = SPAR_DTX_BANDS;
583 3363 : move16();
584 3363 : bands_bw = idiv1616( num_bands, nB );
585 :
586 3363 : ivas_band_mixer_fx( cov_real_fx, cov_real_q, num_ch, &num_bands, bands_bw );
587 : }
588 154137 : ELSE IF( LT_32( hEncoderConfig->ivas_total_brate, IVAS_24k4 ) )
589 : {
590 12704 : bands_bw = 2;
591 12704 : move16();
592 12704 : nB = idiv1616( num_bands, bands_bw );
593 :
594 12704 : ivas_band_mixer_fx( cov_real_fx, cov_real_q, num_ch, &num_bands, bands_bw );
595 : }
596 : ELSE
597 : {
598 141433 : nB = num_bands;
599 141433 : move16();
600 141433 : bands_bw = 1;
601 141433 : move16();
602 : }
603 157500 : test();
604 157500 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
605 : {
606 60500 : FOR( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
607 : {
608 193600 : FOR( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
609 : {
610 145200 : pred_coeffs_re_local_fx[i][b] = hMdEnc->spar_md.band_coeffs[b].pred_re_fx[i]; // Q28
611 145200 : move32();
612 : }
613 : }
614 : }
615 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 );
616 :
617 157500 : IF( dirac_mono_flag )
618 : {
619 : Word16 i_ts;
620 0 : Word16 num_md_sub_frames = 1;
621 0 : move16();
622 :
623 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
624 0 : move16();
625 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
626 0 : move16();
627 :
628 0 : FOR( i_ts = 0; i_ts < num_md_sub_frames; i_ts++ )
629 : {
630 0 : FOR( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
631 : {
632 0 : FOR( j = 0; j < ndm + ndec - 1; j++ )
633 : {
634 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].pred_re_fx[j] = 0;
635 0 : move32();
636 : }
637 0 : FOR( j = 0; j < ndec; j++ )
638 : {
639 0 : FOR( k = 0; k < ndm - 1; k++ )
640 : {
641 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].C_re_fx[j][k] = 0;
642 0 : move32();
643 : }
644 : }
645 :
646 0 : FOR( j = 0; j < ndec; j++ )
647 : {
648 0 : hMdEnc->spar_md.band_coeffs[b + i_ts * IVAS_MAX_NUM_BANDS].P_re_fx[j] = 0;
649 0 : move32();
650 : }
651 : }
652 : }
653 : }
654 :
655 157500 : code_strat = 0;
656 157500 : move16();
657 158579 : FOR( qsi = 0; qsi < num_quant_strats; qsi++ )
658 : {
659 1442993 : FOR( b = 0; b < num_bands; b++ )
660 : {
661 1284414 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
662 1284414 : move16();
663 1284414 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
664 1284414 : move16();
665 :
666 1284414 : IF( EQ_16( dtx_vad, 1 ) )
667 : {
668 1277688 : IF( NE_16( ndm, num_ch ) )
669 : {
670 1126328 : 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 );
671 : }
672 1277688 : 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 );
673 1277688 : IF( active_w_vlbr )
674 : {
675 208800 : FOR( i = 0; i < 3; i++ )
676 : {
677 : Word16 i2;
678 156600 : i2 = 0;
679 156600 : move16();
680 156600 : SWITCH( i ) /* PRED (Y,Z,X) and DECD (Y,X,Z) coeffs are in different orders */
681 : {
682 52200 : case 0:
683 52200 : i2 = 0;
684 52200 : move16();
685 52200 : BREAK;
686 52200 : case 1:
687 52200 : i2 = 2;
688 52200 : move16();
689 52200 : BREAK;
690 52200 : case 2:
691 52200 : i2 = 1;
692 52200 : move16();
693 52200 : BREAK;
694 : }
695 156600 : test();
696 156600 : test();
697 156600 : test();
698 156600 : 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 ) )
699 : {
700 : /* bump up the Pred coeff */
701 : Word32 PR_uq;
702 : Word16 PR_step;
703 : ivas_quant_strat_t qs;
704 : Word16 PR_step_e;
705 3068 : qs = hMdEnc->spar_md_cfg.quant_strat[qsi];
706 3068 : PR_uq = hMdEnc->spar_md.band_coeffs[b].pred_re_fx[i]; // Q28
707 3068 : move32();
708 3068 : 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 );
709 3068 : PR_step_e = sub( PR_step_e, Q12 );
710 :
711 : Word16 PR_sign;
712 3068 : PR_sign = sub( extract_l( GT_32( PR_uq, 0 ) ), extract_l( LT_32( PR_uq, 0 ) ) );
713 :
714 3068 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = PR_sign;
715 3068 : move16();
716 :
717 : /* deindex the modified coefficient */
718 3068 : 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
719 3068 : move32();
720 : }
721 : }
722 : }
723 : }
724 : ELSE
725 : {
726 6726 : IF( NE_16( ndm, num_ch ) )
727 : {
728 6726 : 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 );
729 : }
730 :
731 26904 : FOR( i = 0; i < num_ch - 1; i++ )
732 : {
733 20178 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re_fx[i] = 0;
734 20178 : move32();
735 : }
736 6726 : 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 );
737 : }
738 : }
739 736516 : FOR( i = 0; i < num_ch - 1; i++ )
740 : {
741 5657579 : FOR( b = 0; b < num_bands; b++ )
742 : {
743 5079642 : 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
744 5079642 : move32();
745 : }
746 : }
747 :
748 158579 : test();
749 158579 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
750 : {
751 60500 : FOR( b = SPAR_DIRAC_SPLIT_START_BAND; b < num_bands; b++ )
752 : {
753 193600 : FOR( i = 0; i < DIRAC_TO_SPAR_HBR_PRED_CHS; i++ )
754 : {
755 : /* Use the prediction coeffs computed based on DirAC MD to generate mixer matrix */
756 145200 : pred_coeffs_re_fx[i][b] = pred_coeffs_re_local_fx[i][b];
757 145200 : move32();
758 145200 : hMdEnc->spar_md.band_coeffs[b].pred_quant_re_fx[i] = 0;
759 145200 : move32();
760 145200 : hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[i] = 0;
761 145200 : move16();
762 : }
763 : }
764 : }
765 :
766 158579 : 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 );
767 158579 : Word16 Wscale_e = Q31;
768 158579 : move16();
769 : /* Common q for Wscale buffer */
770 1442993 : FOR( b = 0; b < num_bands; b++ )
771 : {
772 1284414 : if ( GT_16( Wscale_e, q_Wscale[b] ) )
773 : {
774 44878 : Wscale_e = q_Wscale[b];
775 44878 : move16();
776 : }
777 : }
778 1442993 : FOR( b = 0; b < num_bands; b++ )
779 : {
780 1284414 : Wscale_fx[b] = L_shr( Wscale_fx[b], sub( q_Wscale[b], Wscale_e ) ); // Q(Wscale_e)
781 1284414 : move32();
782 : }
783 158579 : Wscale_e = sub( Q31, Wscale_e ); // Wscale_e is now exp of Wscale
784 : /*mixer-q adjusted for Wscale multplication below */
785 158579 : hMdEnc->q_mixer_mat_fx = sub( hMdEnc->q_mixer_mat_fx, Wscale_e );
786 158579 : move16();
787 1442993 : FOR( b = 0; b < num_bands; b++ )
788 : {
789 1284414 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[b * bands_bw];
790 1284414 : move16();
791 1284414 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[b * bands_bw];
792 1284414 : move16();
793 :
794 7648470 : FOR( i = 0; i < num_ch; i++ )
795 : {
796 6364056 : hMdEnc->mixer_mat_fx[0][i][b] = Mpy_32_32( hMdEnc->mixer_mat_fx[0][i][b], Wscale_fx[b] );
797 6364056 : move32();
798 37068144 : FOR( j = 1; j < num_ch; j++ )
799 : {
800 30704088 : hMdEnc->mixer_mat_fx[j][i][b] = L_shr( hMdEnc->mixer_mat_fx[j][i][b], Wscale_e ); // Q(hMdEnc->q_mixer_mat_fx)
801 30704088 : move32();
802 : }
803 : }
804 1284414 : test();
805 1284414 : IF( NE_16( ndm, num_ch ) && NE_16( ndm, 1 ) )
806 : {
807 838804 : 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 );
808 :
809 838804 : IF( dirac_mono_flag )
810 : {
811 0 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[0];
812 0 : move16();
813 0 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[0];
814 0 : move16();
815 0 : FOR( j = 0; j < ndec; j++ )
816 : {
817 0 : FOR( k = 0; k < ndm - 1; k++ )
818 : {
819 0 : hMdEnc->spar_md.band_coeffs[b].C_re_fx[j][k] = 0;
820 0 : move32();
821 : }
822 : }
823 : }
824 838804 : ivas_quant_c_per_band_fx( &hMdEnc->spar_md.band_coeffs[b], &hMdEnc->spar_md.band_coeffs_idx[b],
825 838804 : &hMdEnc->spar_md_cfg.quant_strat[qsi], ndec, ndm, hMdEnc->spar_md.band_coeffs[b].q_C_re_fx );
826 : }
827 : }
828 :
829 : /* band limit downmix matrix */
830 158579 : ivas_band_limit_dmx_matrix_fx( hMdEnc, num_ch, num_bands, bands_bw );
831 :
832 : /* band mixing */
833 158579 : IF( GT_16( bands_bw, 1 ) )
834 : {
835 16413 : ivas_band_mixing_fx( hMdEnc, num_ch, num_bands, nchan_transport, num_bands_full );
836 : }
837 :
838 158579 : IF( dtx_vad == 0 )
839 : {
840 3363 : 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 );
841 3363 : BREAK;
842 : }
843 :
844 155216 : ivas_select_next_strat_fx( hMdEnc->spar_md_cfg.prior_strat, cs, dmx_switch, dtx_vad );
845 :
846 392781 : FOR( i = 0; i < MAX_CODING_STRATS; i++ )
847 : {
848 356218 : strat = cs[i];
849 356218 : move16();
850 356218 : IF( NE_16( strat, NO_STRAT ) )
851 : {
852 354319 : reset_indices_enc_fx( &hMetaData_tmp, md_indices_allocated );
853 :
854 354319 : ivas_write_spar_md_bitstream_fx( hMdEnc, num_bands, bands_bw, &hMetaData_tmp, hEncoderConfig->ivas_total_brate, strat, qsi );
855 :
856 : /*write to main buffer if its a valid bitstream*/
857 354319 : IF( hMetaData_tmp.nb_bits_tot > 0 )
858 : {
859 281219 : test();
860 281219 : 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 ) ) )
861 : {
862 231329 : write_metadata_buffer_fx( &hMetaData_tmp, hMetaData, bit_pos_start, next_ind_start );
863 231329 : code_strat = strat;
864 231329 : move16();
865 : }
866 : Word16 add_bit;
867 281219 : test();
868 281219 : IF( ( EQ_32( hEncoderConfig->ivas_total_brate, IVAS_256k ) && EQ_16( sba_order, SBA_FOA_ORDER ) ) )
869 : {
870 13313 : add_bit = 1;
871 13313 : move16();
872 : }
873 : ELSE
874 : {
875 267906 : add_bit = 0;
876 267906 : move16();
877 : }
878 281219 : IF( LE_16( add( sub( hMetaData->nb_bits_tot, bit_pos_start ), add_bit ), hMdEnc->spar_md_cfg.tgt_bits_per_blk ) )
879 : {
880 118653 : packed_ok = 1;
881 118653 : move16();
882 118653 : BREAK;
883 : }
884 : }
885 : }
886 : }
887 :
888 155216 : IF( EQ_16( packed_ok, 1 ) )
889 : {
890 118653 : BREAK;
891 : }
892 :
893 : /*only if valid bitstream was written to main buffer*/
894 36563 : IF( GT_16( hMetaData->nb_bits_tot, bit_pos_start ) )
895 : {
896 : Word16 add_bit;
897 35484 : test();
898 35484 : IF( EQ_32( hEncoderConfig->ivas_total_brate, IVAS_256k ) && EQ_16( sba_order, SBA_FOA_ORDER ) )
899 : {
900 0 : add_bit = 1;
901 0 : move16();
902 : }
903 : ELSE
904 : {
905 35484 : add_bit = 0;
906 35484 : move16();
907 : }
908 35484 : IF( LE_16( add( sub( hMetaData->nb_bits_tot, bit_pos_start ), add_bit ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
909 : {
910 35484 : packed_ok = 1;
911 35484 : move16();
912 35484 : BREAK;
913 : }
914 : }
915 : }
916 157500 : IF( GT_16( hMdEnc->q_mixer_mat_fx, *q_prior_mixer ) )
917 : {
918 85295 : FOR( i = 0; i < num_ch; i++ )
919 : {
920 341180 : FOR( j = 0; j < num_ch; j++ )
921 : {
922 3548272 : FOR( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
923 : {
924 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 ) );
925 3275328 : move32();
926 : }
927 : }
928 : }
929 17059 : hMdEnc->q_mixer_mat_fx = *q_prior_mixer;
930 17059 : move16();
931 : }
932 : ELSE
933 : {
934 508890 : FOR( i = 0; i < nchan_out; i++ )
935 : {
936 2251045 : FOR( j = 0; j < num_ch; j++ )
937 : {
938 24473748 : FOR( b = 0; b < IVAS_MAX_NUM_BANDS; b++ )
939 : {
940 22591152 : prior_mixer[i][j][b] = L_shr( prior_mixer[i][j][b], sub( *q_prior_mixer, hMdEnc->q_mixer_mat_fx ) );
941 22591152 : move32();
942 : }
943 : }
944 : }
945 140441 : *q_prior_mixer = hMdEnc->q_mixer_mat_fx;
946 140441 : move16();
947 : }
948 : /* Reuse mixer matrix values for unsent bands */
949 157500 : test();
950 157500 : IF( ( LT_32( hEncoderConfig->ivas_total_brate, IVAS_24k4 ) ) && GT_16( code_strat, 3 ) )
951 : {
952 36948 : FOR( b = 0; b < num_bands * bands_bw; b += 2 * bands_bw )
953 : {
954 24632 : test();
955 24632 : IF( ( b == 0 ) && ( s_and( code_strat, 1 ) == 0 ) )
956 : {
957 6339 : b = add( b, 2 );
958 : }
959 49264 : FOR( i = 0; i < 1; i++ )
960 : {
961 123160 : FOR( j = 0; j < 4; j++ )
962 : {
963 98528 : hMdEnc->mixer_mat_fx[i][j][b] = prior_mixer[i][j][b];
964 98528 : move32();
965 98528 : hMdEnc->mixer_mat_fx[i][j][b + 1] = prior_mixer[i][j][b + 1];
966 98528 : move32();
967 : }
968 : }
969 : }
970 : }
971 :
972 157500 : ivas_store_prior_coeffs_fx( hMdEnc, num_bands, code_strat, dtx_vad, qsi );
973 :
974 157500 : hMdEnc->spar_md.dtx_vad = dtx_vad;
975 157500 : move16();
976 157500 : hMdEnc->spar_md.num_bands = num_bands;
977 157500 : move16();
978 :
979 157500 : free( ind_list_tmp );
980 :
981 157500 : return IVAS_ERR_OK;
982 : }
983 : /*-----------------------------------------------------------------------------------------*
984 : * Function ivas_band_mixer()
985 : *
986 : * band mixer
987 : *-----------------------------------------------------------------------------------------*/
988 :
989 16067 : static void ivas_band_mixer_fx(
990 : Word32 *cov_real_fx[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH], // Q(cov_real_q)
991 : Word16 *cov_real_q[IVAS_SPAR_MAX_CH][IVAS_SPAR_MAX_CH],
992 : const Word16 num_ch,
993 : Word16 *num_bands,
994 : Word16 red_band_fact )
995 : {
996 : Word16 i, j, k, b, orig_band, rem_band;
997 : Word32 avg_cov;
998 : Word16 avg_cov_e;
999 :
1000 16067 : orig_band = *num_bands;
1001 16067 : move16();
1002 16067 : *num_bands = idiv1616( *num_bands, red_band_fact );
1003 16067 : move16();
1004 16067 : rem_band = sub( orig_band, i_mult( *num_bands, red_band_fact ) );
1005 :
1006 80335 : FOR( i = 0; i < num_ch; i++ )
1007 : {
1008 321340 : FOR( j = 0; j < num_ch; j++ )
1009 : {
1010 920672 : FOR( k = 0; k < *num_bands - 1; k++ )
1011 : {
1012 663600 : avg_cov_e = 0;
1013 663600 : move16();
1014 663600 : avg_cov = 0;
1015 663600 : move32();
1016 2098416 : FOR( b = 0; b < red_band_fact; b++ )
1017 : {
1018 1434816 : 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 );
1019 : }
1020 663600 : cov_real_fx[i][j][k] = avg_cov;
1021 663600 : move32();
1022 663600 : cov_real_q[i][j][k] = sub( Q31, avg_cov_e );
1023 663600 : move16();
1024 : }
1025 :
1026 257072 : avg_cov_e = 0;
1027 257072 : move16();
1028 257072 : avg_cov = 0;
1029 257072 : move32();
1030 878832 : FOR( b = 0; b < red_band_fact + rem_band; b++ )
1031 : {
1032 621760 : 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 );
1033 : }
1034 :
1035 257072 : cov_real_fx[i][j][*num_bands - 1] = avg_cov;
1036 257072 : move32();
1037 257072 : cov_real_q[i][j][*num_bands - 1] = sub( Q31, avg_cov_e );
1038 257072 : move16();
1039 : }
1040 : }
1041 :
1042 16067 : return;
1043 : }
1044 :
1045 : /*-----------------------------------------------------------------------------------------*
1046 : * Function ivas_write_spar_md_bitstream()
1047 : *
1048 : * Write MD parameters into bitstream
1049 : *-----------------------------------------------------------------------------------------*/
1050 354319 : static void ivas_write_spar_md_bitstream_fx(
1051 : ivas_spar_md_enc_state_t *hMdEnc,
1052 : const Word16 nB,
1053 : const Word16 bands_bw,
1054 : BSTR_ENC_HANDLE hMetaData,
1055 : const Word32 ivas_total_brate,
1056 : const Word16 strat,
1057 : const Word16 qsi )
1058 : {
1059 : Word16 no_ec, i;
1060 : Word16 do_diff[IVAS_MAX_NUM_BANDS];
1061 : Word16 entropy_coding_result;
1062 :
1063 354319 : IF( EQ_16( strat, NO_STRAT ) )
1064 : {
1065 0 : return;
1066 : }
1067 :
1068 : /* write quant strat */
1069 354319 : IF( GE_32( ivas_total_brate, BRATE_SPAR_Q_STRAT ) )
1070 : {
1071 43640 : push_next_indice( hMetaData, shr( qsi, 1 ), sub( hMdEnc->spar_md_cfg.quant_strat_bits, 1 ) );
1072 : }
1073 : ELSE
1074 : {
1075 310679 : push_next_indice( hMetaData, qsi, hMdEnc->spar_md_cfg.quant_strat_bits );
1076 : }
1077 :
1078 354319 : no_ec = 0;
1079 354319 : move16();
1080 :
1081 354319 : IF( LT_32( ivas_total_brate, IVAS_24k4 ) )
1082 : {
1083 38416 : SWITCH( strat )
1084 : {
1085 13050 : case BASE:
1086 13050 : push_next_indice( hMetaData, sub( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1087 13050 : BREAK;
1088 13050 : case BASE_NOEC:
1089 13050 : push_next_indice( hMetaData, add( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1090 13050 : no_ec = 1;
1091 13050 : move16();
1092 13050 : BREAK;
1093 12316 : case FOUR_A:
1094 : case FOUR_C:
1095 : case FOUR_B:
1096 : case FOUR_D:
1097 12316 : push_next_indice( hMetaData, strat, SPAR_NUM_CODING_STRAT_BITS );
1098 12316 : BREAK;
1099 : }
1100 : /* for LBR SBA 40MS MD never do time diff */
1101 192080 : FOR( i = 0; i < nB; i++ )
1102 : {
1103 153664 : do_diff[i] = 0;
1104 153664 : move16();
1105 : }
1106 : }
1107 : ELSE
1108 : {
1109 315903 : SWITCH( strat )
1110 : {
1111 142166 : case BASE:
1112 142166 : push_next_indice( hMetaData, sub( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1113 1367654 : FOR( i = 0; i < nB; i++ )
1114 : {
1115 1225488 : do_diff[i] = 0;
1116 1225488 : move16();
1117 : }
1118 142166 : BREAK;
1119 88792 : case BASE_NOEC:
1120 88792 : push_next_indice( hMetaData, add( bands_bw, 1 ), SPAR_NUM_CODING_STRAT_BITS );
1121 799128 : FOR( i = 0; i < nB; i++ )
1122 : {
1123 710336 : do_diff[i] = 0;
1124 710336 : move16();
1125 : }
1126 88792 : no_ec = 1;
1127 88792 : move16();
1128 88792 : BREAK;
1129 23902 : case FOUR_A:
1130 23902 : push_next_indice( hMetaData, 4, SPAR_NUM_CODING_STRAT_BITS );
1131 215118 : FOR( i = 0; i < nB; i++ )
1132 : {
1133 191216 : do_diff[i] = ( ( s_and( ( add( i, 1 ) ), 3 ) ) != 0 );
1134 191216 : move16();
1135 : }
1136 23902 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1137 23902 : BREAK;
1138 21541 : case FOUR_B:
1139 21541 : push_next_indice( hMetaData, 5, SPAR_NUM_CODING_STRAT_BITS );
1140 193869 : FOR( i = 0; i < nB; i++ )
1141 : {
1142 172328 : do_diff[i] = extract_l( NE_16( ( s_and( ( add( i, 1 ) ), 3 ) ), 1 ) );
1143 172328 : move16();
1144 : }
1145 21541 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1146 21541 : BREAK;
1147 20216 : case FOUR_C:
1148 20216 : push_next_indice( hMetaData, 6, SPAR_NUM_CODING_STRAT_BITS );
1149 181944 : FOR( i = 0; i < nB; i++ )
1150 : {
1151 161728 : do_diff[i] = extract_l( NE_16( ( s_and( ( add( i, 1 ) ), 3 ) ), 2 ) );
1152 161728 : move16();
1153 : }
1154 20216 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1155 20216 : BREAK;
1156 19286 : case FOUR_D:
1157 19286 : push_next_indice( hMetaData, 7, SPAR_NUM_CODING_STRAT_BITS );
1158 173574 : FOR( i = 0; i < nB; i++ )
1159 : {
1160 154288 : do_diff[i] = extract_l( NE_16( ( s_and( ( add( i, 1 ) ), 3 ) ), 3 ) );
1161 154288 : move16();
1162 : }
1163 19286 : ivas_map_prior_coeffs_quant( &hMdEnc->spar_md_prior, &hMdEnc->spar_md_cfg, qsi, nB );
1164 19286 : BREAK;
1165 : }
1166 354319 : }
1167 :
1168 354319 : IF( EQ_16( no_ec, 1 ) )
1169 : {
1170 : entropy_coding_result =
1171 101842 : ivas_get_huffman_coded_bs_fx( hMdEnc, hMetaData, nB, qsi,
1172 : bands_bw );
1173 101842 : move16();
1174 : }
1175 : ELSE
1176 : {
1177 : entropy_coding_result =
1178 252477 : ivas_get_arith_coded_bs_fx( hMdEnc, hMetaData, do_diff, bands_bw, nB, qsi,
1179 : strat, ivas_total_brate );
1180 252477 : move16();
1181 : }
1182 :
1183 354319 : if ( entropy_coding_result < 0 )
1184 : {
1185 73100 : hMetaData->nb_bits_tot = 0;
1186 73100 : move16();
1187 : }
1188 :
1189 354319 : return;
1190 : }
1191 :
1192 :
1193 : /*-----------------------------------------------------------------------------------------*
1194 : * Function ivas_get_huffman_coded_bs()
1195 : *
1196 : * Generate huffman coded bitstream
1197 : *-----------------------------------------------------------------------------------------*/
1198 101842 : static Word16 ivas_get_huffman_coded_bs_fx(
1199 : ivas_spar_md_enc_state_t *hMdEnc,
1200 : BSTR_ENC_HANDLE hMetaData,
1201 : const Word16 nB,
1202 : const Word16 qsi,
1203 : const Word16 bands_bw )
1204 : {
1205 : Word16 i, j;
1206 : Word16 pred_coeff_dim, pred_offset;
1207 :
1208 812990 : FOR( i = 0; i < nB; i++ )
1209 : {
1210 : Word16 code, len;
1211 : Word16 ndm, ndec;
1212 755903 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[i * bands_bw];
1213 755903 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[i * bands_bw];
1214 755903 : move16();
1215 755903 : move16();
1216 :
1217 755903 : pred_coeff_dim = sub( add( ndm, ndec ), 1 );
1218 755903 : pred_offset = 0;
1219 755903 : move16();
1220 755903 : test();
1221 755903 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1222 : {
1223 0 : if ( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1224 : {
1225 0 : pred_offset = DIRAC_TO_SPAR_HBR_PRED_CHS;
1226 0 : move16();
1227 : }
1228 : }
1229 :
1230 2986958 : FOR( j = pred_offset; j < pred_coeff_dim; j++ )
1231 : {
1232 2253496 : ivas_huffman_encode_fx( &hMdEnc->huff_coeffs.pred_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j], &code, &len );
1233 2253496 : IF( GT_16( ( add( hMetaData->nb_bits_tot, len ) ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
1234 : {
1235 44755 : return -1;
1236 : }
1237 2231055 : push_next_indice( hMetaData, code, len );
1238 : }
1239 :
1240 733462 : Word16 n = imult1616( ndec, sub( ndm, 1 ) );
1241 1626137 : FOR( j = 0; j < n; j++ )
1242 : {
1243 899471 : ivas_huffman_encode_fx( &hMdEnc->huff_coeffs.drct_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].drct_index_re[j], &code, &len );
1244 899471 : IF( GT_16( ( add( hMetaData->nb_bits_tot, len ) ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
1245 : {
1246 6796 : return -1;
1247 : }
1248 892675 : push_next_indice( hMetaData, code, len );
1249 : }
1250 :
1251 2184959 : FOR( j = 0; j < ndec; j++ )
1252 : {
1253 1473811 : ivas_huffman_encode_fx( &hMdEnc->huff_coeffs.decd_huff_re[qsi], hMdEnc->spar_md.band_coeffs_idx[i].decd_index_re[j], &code, &len );
1254 1473811 : IF( GT_16( ( add( hMetaData->nb_bits_tot, len ) ), hMdEnc->spar_md_cfg.max_bits_per_blk ) )
1255 : {
1256 15518 : return -1;
1257 : }
1258 1458293 : push_next_indice( hMetaData, code, len );
1259 : }
1260 : }
1261 :
1262 57087 : return 0;
1263 : }
1264 :
1265 :
1266 : /*-----------------------------------------------------------------------------------------*
1267 : * Function ivas_get_arith_coded_bs()
1268 : *
1269 : * Generate arithmetic coded bitstream
1270 : *-----------------------------------------------------------------------------------------*/
1271 :
1272 252477 : static Word16 ivas_get_arith_coded_bs_fx(
1273 : ivas_spar_md_enc_state_t *hMdEnc,
1274 : BSTR_ENC_HANDLE hMetaData,
1275 : const Word16 *pDo_diff,
1276 : const Word16 bands_bw,
1277 : const Word16 nB,
1278 : const Word16 qsi,
1279 : const Word16 strat,
1280 : const Word32 ivas_total_brate )
1281 : {
1282 : Word16 i, any_diff;
1283 : Word16 j;
1284 : ivas_cell_dim_t pred_cell_dims[IVAS_MAX_NUM_BANDS];
1285 : ivas_cell_dim_t drct_cell_dims[IVAS_MAX_NUM_BANDS];
1286 : ivas_cell_dim_t decd_cell_dims[IVAS_MAX_NUM_BANDS];
1287 : ivas_cell_dim_t decx_cell_dims[IVAS_MAX_NUM_BANDS];
1288 : Word16 symbol_arr_re[IVAS_MAX_INPUT_LEN];
1289 : Word16 symbol_arr_old_re[IVAS_MAX_INPUT_LEN];
1290 : Word16 arith_result;
1291 :
1292 2258989 : FOR( i = 0; i < nB; i++ )
1293 : {
1294 : Word16 ndm, ndec;
1295 2006512 : ndm = hMdEnc->spar_md_cfg.num_dmx_chans_per_band[bands_bw * i];
1296 2006512 : ndec = hMdEnc->spar_md_cfg.num_decorr_per_band[bands_bw * i];
1297 2006512 : move16();
1298 2006512 : move16();
1299 :
1300 2006512 : test();
1301 2006512 : test();
1302 2006512 : test();
1303 2006512 : test();
1304 2006512 : test();
1305 2006512 : 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 ) ) ) ) )
1306 : {
1307 24632 : pred_cell_dims[i].dim1 = 0;
1308 24632 : pred_cell_dims[i].dim2 = 0;
1309 24632 : drct_cell_dims[i].dim1 = 0;
1310 24632 : drct_cell_dims[i].dim2 = 0;
1311 24632 : decd_cell_dims[i].dim1 = 0;
1312 24632 : decd_cell_dims[i].dim2 = 0;
1313 24632 : decx_cell_dims[i].dim1 = 0;
1314 24632 : decx_cell_dims[i].dim2 = 0;
1315 24632 : move16();
1316 24632 : move16();
1317 24632 : move16();
1318 24632 : move16();
1319 24632 : move16();
1320 24632 : move16();
1321 24632 : move16();
1322 24632 : move16();
1323 : }
1324 : ELSE
1325 : {
1326 1981880 : pred_cell_dims[i].dim1 = sub( add( ndm, ndec ), 1 );
1327 1981880 : move16();
1328 1981880 : test();
1329 1981880 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1330 : {
1331 145200 : IF( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1332 : {
1333 48400 : pred_cell_dims[i].dim1 = sub( pred_cell_dims[i].dim1, ( FOA_CHANNELS - 1 ) );
1334 48400 : move16();
1335 : }
1336 : }
1337 1981880 : pred_cell_dims[i].dim2 = 1;
1338 1981880 : drct_cell_dims[i].dim1 = ndec;
1339 1981880 : drct_cell_dims[i].dim2 = sub( ndm, 1 );
1340 1981880 : decd_cell_dims[i].dim1 = ndec;
1341 1981880 : decd_cell_dims[i].dim2 = 1;
1342 1981880 : decx_cell_dims[i].dim1 = shr( ( imult1616( ndec, sub( ndec, 1 ) ) ), 1 );
1343 1981880 : decx_cell_dims[i].dim2 = 1;
1344 1981880 : move16();
1345 1981880 : move16();
1346 1981880 : move16();
1347 1981880 : move16();
1348 1981880 : move16();
1349 1981880 : move16();
1350 1981880 : move16();
1351 : }
1352 : }
1353 :
1354 252477 : any_diff = 0;
1355 252477 : move16();
1356 1600970 : FOR( i = 0; i < nB; i++ )
1357 : {
1358 1433438 : IF( pDo_diff[i] != 0 )
1359 : {
1360 84945 : any_diff = 1;
1361 84945 : move16();
1362 84945 : BREAK;
1363 : }
1364 : }
1365 :
1366 252477 : test();
1367 252477 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1368 : {
1369 157300 : FOR( i = 0; i < nB; i++ )
1370 : {
1371 145200 : IF( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1372 : {
1373 196960 : FOR( j = 0; j < pred_cell_dims[i].dim1; j++ )
1374 : {
1375 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] =
1376 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1377 148560 : move16();
1378 148560 : IF( EQ_16( any_diff, 1 ) )
1379 : {
1380 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j] =
1381 0 : hMdEnc->spar_md_prior.band_coeffs_idx_mapped[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS];
1382 0 : move16();
1383 : }
1384 : }
1385 : }
1386 : }
1387 : }
1388 252477 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, pred_cell_dims, PRED_COEFF );
1389 :
1390 252477 : IF( EQ_16( any_diff, 1 ) )
1391 : {
1392 84945 : 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 );
1393 : }
1394 :
1395 252477 : 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,
1396 252477 : symbol_arr_re, symbol_arr_old_re, pred_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1397 252477 : move16();
1398 252477 : IF( arith_result < 0 )
1399 : {
1400 947 : return -1;
1401 : }
1402 :
1403 251530 : test();
1404 251530 : IF( hMdEnc->spar_hoa_md_flag && hMdEnc->spar_hoa_dirac2spar_md_flag )
1405 : {
1406 157300 : FOR( i = 0; i < nB; i++ )
1407 : {
1408 145200 : IF( GE_16( i, SPAR_DIRAC_SPLIT_START_BAND ) )
1409 : {
1410 196960 : FOR( j = pred_cell_dims[i].dim1 - 1; j >= 0; j-- )
1411 : {
1412 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j + DIRAC_TO_SPAR_HBR_PRED_CHS] =
1413 148560 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j];
1414 148560 : move16();
1415 : }
1416 193600 : FOR( j = 0; j < DIRAC_TO_SPAR_HBR_PRED_CHS; j++ )
1417 : {
1418 145200 : hMdEnc->spar_md.band_coeffs_idx[i].pred_index_re[j] = 0;
1419 145200 : move16();
1420 : }
1421 : }
1422 : }
1423 : }
1424 :
1425 251530 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, drct_cell_dims, DRCT_COEFF );
1426 :
1427 251530 : IF( EQ_16( any_diff, 1 ) )
1428 : {
1429 84945 : 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 );
1430 : }
1431 :
1432 :
1433 251530 : 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,
1434 251530 : symbol_arr_re, symbol_arr_old_re, drct_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1435 251530 : move16();
1436 :
1437 251530 : IF( arith_result < 0 )
1438 : {
1439 4 : return -1;
1440 : }
1441 :
1442 251526 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decd_cell_dims, DECD_COEFF );
1443 :
1444 251526 : IF( EQ_16( any_diff, 1 ) )
1445 : {
1446 84941 : 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 );
1447 : }
1448 :
1449 251526 : 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,
1450 251526 : symbol_arr_re, symbol_arr_old_re, decd_cell_dims, hMetaData, any_diff, hMdEnc->spar_md_cfg.max_bits_per_blk );
1451 251526 : move16();
1452 :
1453 251526 : IF( arith_result < 0 )
1454 : {
1455 27394 : return -1;
1456 : }
1457 :
1458 224132 : ivas_copy_band_coeffs_idx_to_arr( hMdEnc->spar_md.band_coeffs_idx, nB, symbol_arr_re, decx_cell_dims, DECX_COEFF );
1459 :
1460 224132 : IF( EQ_16( any_diff, 1 ) )
1461 : {
1462 83945 : 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 );
1463 : }
1464 :
1465 224132 : return 0;
1466 : }
1467 :
1468 :
1469 : /*-----------------------------------------------------------------------------------------*
1470 : * Function ivas_select_next_strat()
1471 : *
1472 : * Select next strategy
1473 : *-----------------------------------------------------------------------------------------*/
1474 155216 : static void ivas_select_next_strat_fx(
1475 : ivas_strats_t prior_strat,
1476 : ivas_strats_t cs[MAX_QUANT_STRATS],
1477 : const Word16 dmx_switch,
1478 : const Word16 dtx_vad )
1479 : {
1480 155216 : cs[0] = BASE;
1481 155216 : move16();
1482 155216 : cs[1] = BASE_NOEC;
1483 155216 : move16();
1484 :
1485 155216 : test();
1486 155216 : IF( dmx_switch == 0 && dtx_vad )
1487 : {
1488 155216 : SWITCH( prior_strat )
1489 : {
1490 2446 : case START:
1491 2446 : cs[2] = NO_STRAT;
1492 2446 : move16();
1493 2446 : BREAK;
1494 56215 : case BASE:
1495 56215 : cs[2] = FOUR_A;
1496 56215 : move16();
1497 56215 : BREAK;
1498 0 : case BASE_DIFF:
1499 0 : cs[2] = FOUR_A;
1500 0 : move16();
1501 0 : BREAK;
1502 3006 : case BASE_NOEC:
1503 3006 : cs[2] = FOUR_A;
1504 3006 : move16();
1505 3006 : BREAK;
1506 25290 : case FOUR_A:
1507 25290 : cs[2] = FOUR_B;
1508 25290 : move16();
1509 25290 : BREAK;
1510 23724 : case FOUR_B:
1511 23724 : cs[2] = FOUR_C;
1512 23724 : move16();
1513 23724 : BREAK;
1514 22701 : case FOUR_C:
1515 22701 : cs[2] = FOUR_D;
1516 22701 : move16();
1517 22701 : BREAK;
1518 21834 : case FOUR_D:
1519 21834 : cs[2] = FOUR_A;
1520 21834 : move16();
1521 21834 : BREAK;
1522 0 : default:
1523 0 : assert( !"bad value of prior_strat" );
1524 : }
1525 0 : }
1526 :
1527 155216 : return;
1528 : }
1529 :
1530 : /*-----------------------------------------------------------------------------------------*
1531 : * Function ivas_store_prior_coeffs()
1532 : *
1533 : * Store prior coeffs
1534 : *-----------------------------------------------------------------------------------------*/
1535 157500 : static void ivas_store_prior_coeffs_fx(
1536 : ivas_spar_md_enc_state_t *hMdEnc,
1537 : const Word16 num_bands,
1538 : const Word16 strat,
1539 : const Word16 dtx_vad,
1540 : const Word16 qsi )
1541 : {
1542 : Word16 i, j, b;
1543 157500 : IF( dtx_vad == 0 )
1544 : {
1545 3363 : hMdEnc->spar_md_cfg.prior_strat = START;
1546 3363 : move16();
1547 : }
1548 : ELSE
1549 : {
1550 154137 : hMdEnc->spar_md_cfg.prior_strat = strat;
1551 154137 : move16();
1552 : }
1553 :
1554 157500 : hMdEnc->spar_md_cfg.prev_quant_idx = qsi;
1555 157500 : move16();
1556 :
1557 1434666 : FOR( i = 0; i < num_bands; i++ )
1558 : {
1559 1277166 : b = i;
1560 1277166 : move16();
1561 :
1562 14048826 : FOR( j = 0; j < IVAS_SPAR_MAX_CH - 1; j++ )
1563 : {
1564 12771660 : hMdEnc->spar_md_prior.band_coeffs_idx[i].pred_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].pred_index_re[j];
1565 12771660 : move16();
1566 12771660 : hMdEnc->spar_md_prior.band_coeffs_idx[i].decd_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].decd_index_re[j];
1567 12771660 : move16();
1568 : }
1569 28097652 : FOR( j = 0; j < IVAS_SPAR_MAX_C_COEFF; j++ )
1570 : {
1571 26820486 : hMdEnc->spar_md_prior.band_coeffs_idx[i].drct_index_re[j] = hMdEnc->spar_md.band_coeffs_idx[b].drct_index_re[j];
1572 26820486 : move16();
1573 : }
1574 : }
1575 :
1576 157500 : return;
1577 : }
1578 :
1579 : /*-----------------------------------------------------------------------------------------*
1580 : * Function ivas_spar_quant_pred_coeffs_dtx()
1581 : *
1582 : * Calculate quantization pred coeffs
1583 : *-----------------------------------------------------------------------------------------*/
1584 6726 : static void ivas_spar_quant_pred_coeffs_dtx_fx(
1585 : ivas_spar_md_t *pSpar_md,
1586 : const Word32 *pValues, // Q28
1587 : const Word16 ndm,
1588 : Word16 *pIndex,
1589 : const Word16 dim1,
1590 : Word32 *pQuant // Q28
1591 : )
1592 : {
1593 : Word16 i;
1594 : Word16 q_lvl;
1595 : Word32 pr_min_max[2];
1596 :
1597 6726 : pr_min_max[0] = pSpar_md->min_max_fx[0]; // Q28
1598 6726 : move32();
1599 6726 : pr_min_max[1] = pSpar_md->min_max_fx[1]; // Q28
1600 6726 : move32();
1601 :
1602 26904 : FOR( i = 0; i < dim1; i++ )
1603 : {
1604 20178 : q_lvl = dtx_pr_real_q_levels[ndm - 1][i];
1605 20178 : move16();
1606 20178 : ivas_quantise_real_values_enc_fx( &pValues[i], q_lvl, pr_min_max[0], pr_min_max[1], &pIndex[i], &pQuant[i], 1 );
1607 : }
1608 :
1609 6726 : return;
1610 : }
1611 :
1612 :
1613 : /*-----------------------------------------------------------------------------------------*
1614 : * Function ivas_quant_p_per_band_dtx()
1615 : *
1616 : * Calculate quantization p
1617 : *-----------------------------------------------------------------------------------------*/
1618 6726 : static void ivas_quant_p_per_band_dtx_fx(
1619 : Word32 *pP_mat, // Q28
1620 : const Word16 num_dec,
1621 : const Word16 num_dmx,
1622 : Word16 *ppIdx_pd,
1623 : Word32 *pP_out, // Q28
1624 : const Word16 num_ch )
1625 : {
1626 : Word16 i;
1627 6726 : Word16 dim = sub( num_ch, num_dmx );
1628 :
1629 6726 : IF( EQ_16( num_dec, sub( num_ch, 1 ) ) )
1630 : {
1631 14984 : FOR( i = 0; i < dim; i++ )
1632 : {
1633 11238 : test();
1634 11238 : IF( LT_32( pP_mat[i], pr_boost_range_fx[1] ) && GT_32( pP_mat[i], pr_boost_range_fx[0] ) )
1635 : {
1636 4905 : pP_mat[i] = pr_boost_range_fx[1]; // Q28
1637 4905 : move32();
1638 : }
1639 : }
1640 : }
1641 :
1642 6726 : IF( NE_16( dim, num_dec ) )
1643 : {
1644 0 : assert( !"Not Supported!" );
1645 : }
1646 :
1647 23924 : FOR( i = 0; i < dim; i++ )
1648 : {
1649 17198 : 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 );
1650 : }
1651 :
1652 6726 : return;
1653 : }
1654 : /*-----------------------------------------------------------------------------------------*
1655 : * Function ivas_write_parameter_bitstream_dtx()
1656 : *
1657 : * Write MD DTX parameters into bitstream
1658 : *-----------------------------------------------------------------------------------------*/
1659 :
1660 3363 : static void ivas_write_parameter_bitstream_dtx_fx(
1661 : ivas_spar_md_t *pSpar_md,
1662 : BSTR_ENC_HANDLE hMetaData,
1663 : Word16 *num_dmx,
1664 : Word16 *num_dec,
1665 : const Word16 num_bands )
1666 : {
1667 : Word16 i, j;
1668 : Word32 val;
1669 : Word16 idx;
1670 : Word32 pr_min_max[2];
1671 : Word16 zero_pad_bits, sid_bits_len;
1672 3363 : sid_bits_len = hMetaData->nb_bits_tot;
1673 3363 : move16();
1674 3363 : pr_min_max[0] = pSpar_md->min_max_fx[0];
1675 3363 : move32();
1676 3363 : pr_min_max[1] = pSpar_md->min_max_fx[1];
1677 3363 : move32();
1678 :
1679 10089 : FOR( i = 0; i < num_bands; i++ )
1680 : {
1681 6726 : Word16 ndm = num_dmx[i];
1682 6726 : move16();
1683 6726 : Word16 ndec = num_dec[i];
1684 6726 : move16();
1685 :
1686 26904 : FOR( j = 0; j < FOA_CHANNELS - 1; j++ )
1687 : {
1688 : Word16 pr, pd;
1689 : Word16 pr_q_lvls, pd_q_lvls, pr_pd_bits;
1690 : Word16 pr_idx_1, pr_idx_2, pd_idx_1, pd_idx_2;
1691 : UWord16 value;
1692 :
1693 20178 : pr_idx_1 = pr_pr_idx_pairs[ndm - 1][j][0];
1694 20178 : move16();
1695 20178 : pr_idx_2 = pr_pr_idx_pairs[ndm - 1][j][1];
1696 20178 : move16();
1697 20178 : pd_idx_1 = pr_pd_idx_pairs[ndm - 1][j][0];
1698 20178 : move16();
1699 20178 : pd_idx_2 = pr_pd_idx_pairs[ndm - 1][j][1];
1700 20178 : move16();
1701 :
1702 20178 : test();
1703 20178 : test();
1704 20178 : test();
1705 20178 : IF( pr_idx_1 != 0 || pd_idx_1 != 0 || pr_idx_2 != 0 || pd_idx_2 != 0 )
1706 : {
1707 20178 : pr_q_lvls = dtx_pr_real_q_levels[ndm - 1][pd_idx_1 - 1];
1708 20178 : move16();
1709 20178 : pr = pSpar_md->band_coeffs_idx[i].pred_index_re[pd_idx_1 - 1];
1710 20178 : move16();
1711 :
1712 20178 : IF( GT_16( add( j, 1 ), ndec ) )
1713 : {
1714 2980 : pd_q_lvls = 1;
1715 2980 : move16();
1716 2980 : pd = 0;
1717 2980 : move16();
1718 : }
1719 : ELSE
1720 : {
1721 17198 : pd_q_lvls = dtx_pd_real_q_levels[ndm - 1][pd_idx_2 - 1];
1722 17198 : move16();
1723 17198 : pd = pSpar_md->band_coeffs_idx[i].decd_index_re[pd_idx_2 - 1];
1724 17198 : move16();
1725 : }
1726 20178 : val = dtx_pd_real_min_max_fx[0];
1727 20178 : move32();
1728 20178 : 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 );
1729 :
1730 20178 : pd = sub( pd, idx );
1731 :
1732 20178 : val = pr_min_max[0];
1733 20178 : move32();
1734 20178 : ivas_quantise_real_values_enc_fx( &val, pr_q_lvls, pr_min_max[0], pr_min_max[1], &idx, &val, 1 );
1735 :
1736 20178 : pr = sub( pr, idx );
1737 20178 : pr_pd_bits = ivas_get_bits_to_encode( i_mult( pd_q_lvls, pr_q_lvls ) );
1738 :
1739 20178 : value = (UWord16) ( add( i_mult( pr, pd_q_lvls ), pd ) );
1740 :
1741 20178 : push_next_indice( hMetaData, value, pr_pd_bits );
1742 : }
1743 : }
1744 : }
1745 :
1746 3363 : sid_bits_len = sub( hMetaData->nb_bits_tot, sid_bits_len );
1747 3363 : zero_pad_bits = sub( i_mult( SPAR_DTX_BANDS, SPAR_SID_BITS_TAR_PER_BAND ), sid_bits_len );
1748 3363 : assert( zero_pad_bits >= 0 );
1749 3363 : IF( EQ_16( num_dmx[0], 2 ) )
1750 : {
1751 1490 : zero_pad_bits = sub( zero_pad_bits, 1 );
1752 : }
1753 :
1754 4853 : WHILE( zero_pad_bits > 0 )
1755 : {
1756 1490 : j = s_min( zero_pad_bits, 16 );
1757 1490 : push_next_indice( hMetaData, 0, j );
1758 1490 : zero_pad_bits = sub( zero_pad_bits, j );
1759 : }
1760 :
1761 3363 : return;
1762 : }
1763 :
1764 :
1765 : /*-----------------------------------------------------------------------------------------*
1766 : * Function ivas_quant_pred_coeffs_per_band()
1767 : *
1768 : * Quantization of prediction coefficients
1769 : *-----------------------------------------------------------------------------------------*/
1770 1277688 : static void ivas_quant_pred_coeffs_per_band_fx(
1771 : ivas_band_coeffs_t *pband_coeffs,
1772 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1773 : ivas_quant_strat_t *pQs,
1774 : const Word16 num_ch )
1775 : {
1776 1277688 : 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 ) );
1777 :
1778 1277688 : return;
1779 : }
1780 :
1781 : /*-----------------------------------------------------------------------------------------*
1782 : * Function ivas_quant_c_per_band()
1783 : *
1784 : * Quantization of cross prediction c coeffs for each band
1785 : *-----------------------------------------------------------------------------------------*/
1786 838804 : static void ivas_quant_c_per_band_fx(
1787 : ivas_band_coeffs_t *pband_coeffs,
1788 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1789 : ivas_quant_strat_t *pQs,
1790 : const Word16 ndec,
1791 : const Word16 ndm,
1792 : const Word16 q_C )
1793 : {
1794 : Word16 i;
1795 : Word16 j, k;
1796 : Word32 C_re[IVAS_SPAR_MAX_C_COEFF];
1797 838804 : k = 0;
1798 838804 : move16();
1799 2954020 : FOR( i = 0; i < ndec; i++ )
1800 : {
1801 6943064 : FOR( j = 0; j < ndm - 1; j++ )
1802 : {
1803 4827848 : C_re[k] = pband_coeffs->C_re_fx[i][j];
1804 4827848 : move32();
1805 4827848 : k++;
1806 : }
1807 : }
1808 838804 : 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 );
1809 838804 : k = 0;
1810 838804 : move16();
1811 2954020 : FOR( i = 0; i < ndec; i++ )
1812 : {
1813 6943064 : FOR( j = 0; j < ndm - 1; j++ )
1814 : {
1815 4827848 : pband_coeffs->C_quant_re_fx[i][j] = C_re[k];
1816 4827848 : move32();
1817 4827848 : k++;
1818 : }
1819 : }
1820 :
1821 838804 : return;
1822 : }
1823 :
1824 :
1825 : /*-----------------------------------------------------------------------------------------*
1826 : * Function ivas_quant_p_per_band()
1827 : *
1828 : * Quantization of decorrelation p coeffs for each band
1829 : *-----------------------------------------------------------------------------------------*/
1830 1126328 : static void ivas_quant_p_per_band_fx(
1831 : ivas_band_coeffs_t *pband_coeffs,
1832 : ivas_band_coeffs_ind_t *pBand_coeffs_idx,
1833 : ivas_quant_strat_t *pQs,
1834 : const Word16 num_ch )
1835 : {
1836 1126328 : 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 ) );
1837 :
1838 1126328 : return;
1839 : }
|
