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