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