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 "options.h"
34 : #include "ivas_cnst.h"
35 : #include "ivas_prot.h"
36 : #include "ivas_prot_rend.h"
37 : #include "ivas_rom_com.h"
38 : #include "ivas_stat_enc.h"
39 : #include "prot.h"
40 : #include <assert.h>
41 : #include <math.h>
42 : #include <stdint.h>
43 : #ifdef DEBUGGING
44 : #include "debug.h"
45 : #endif
46 : #include "wmc_auto.h"
47 :
48 :
49 : /*-------------------------------------------------------------------*
50 : * Local function prototypes
51 : *-------------------------------------------------------------------*/
52 :
53 : static ivas_error ivas_read_format( Decoder_Struct *st_ivas, int16_t *num_bits_read );
54 :
55 : static ivas_error doSanityChecks_IVAS( Decoder_Struct *st_ivas );
56 :
57 :
58 : /*-------------------------------------------------------------------*
59 : * ivas_set_audio_config_from_sba_order()
60 : *
61 : *
62 : *-------------------------------------------------------------------*/
63 :
64 : /*! r: audio configuration */
65 20 : static AUDIO_CONFIG ivas_set_audio_config_from_sba_order(
66 : const int16_t sba_order /* i : Ambisonic (SBA) order */
67 : )
68 : {
69 : AUDIO_CONFIG output_config;
70 :
71 20 : output_config = IVAS_AUDIO_CONFIG_HOA3;
72 :
73 20 : switch ( sba_order )
74 : {
75 8 : case SBA_FOA_ORDER:
76 8 : output_config = IVAS_AUDIO_CONFIG_FOA;
77 8 : break;
78 4 : case SBA_HOA2_ORDER:
79 4 : output_config = IVAS_AUDIO_CONFIG_HOA2;
80 4 : break;
81 8 : case SBA_HOA3_ORDER:
82 8 : output_config = IVAS_AUDIO_CONFIG_HOA3;
83 8 : break;
84 0 : default:
85 0 : output_config = IVAS_AUDIO_CONFIG_INVALID;
86 0 : break;
87 : }
88 :
89 20 : return output_config;
90 : }
91 :
92 :
93 : /*---------------------------------------------------------------------*
94 : * ivas_dec_get_format( )
95 : *
96 : * Read main parameters from the bitstream to set-up the decoder:
97 : * - IVAS format
98 : * - IVAS format specific signaling
99 : *---------------------------------------------------------------------*/
100 :
101 690755 : ivas_error ivas_dec_get_format(
102 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
103 : )
104 : {
105 : int16_t k, idx, num_bits_read;
106 : int16_t nchan_ism, element_mode_flag;
107 : int16_t sba_order, sba_planar, sba_analysis_order;
108 : int32_t ivas_total_brate;
109 : int16_t Opt_tsm;
110 : uint16_t *bit_stream_orig;
111 : AUDIO_CONFIG signaled_config;
112 : ivas_error error;
113 :
114 690755 : num_bits_read = 0;
115 690755 : element_mode_flag = 0;
116 :
117 690755 : ivas_total_brate = st_ivas->hDecoderConfig->ivas_total_brate;
118 690755 : Opt_tsm = st_ivas->hDecoderConfig->Opt_tsm;
119 690755 : bit_stream_orig = st_ivas->bit_stream;
120 :
121 : /*-------------------------------------------------------------------*
122 : * Read IVAS format
123 : *-------------------------------------------------------------------*/
124 :
125 690755 : if ( ( error = ivas_read_format( st_ivas, &num_bits_read ) ) != IVAS_ERR_OK )
126 : {
127 0 : return error;
128 : }
129 :
130 690755 : if ( st_ivas->ini_frame > 0 && st_ivas->ivas_format != st_ivas->last_ivas_format &&
131 4132 : !( st_ivas->ivas_format == MASA_FORMAT && st_ivas->last_ivas_format == MASA_ISM_FORMAT ) &&
132 2063 : !( st_ivas->ivas_format == MASA_ISM_FORMAT && st_ivas->last_ivas_format == MASA_FORMAT ) )
133 : {
134 0 : if ( Opt_tsm )
135 : {
136 0 : st_ivas->restartNeeded = 1;
137 :
138 0 : return IVAS_ERR_OK;
139 : }
140 : else
141 : {
142 : #ifdef DEBUGGING
143 : fprintf( stderr, "\nError: Changing the number of ISMs is not supported!\n" );
144 : #endif
145 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong number of objects signalled!" );
146 : }
147 : }
148 :
149 : /*-------------------------------------------------------------------*
150 : * Read other signaling (ISM/MC mode, number of channels, etc.)
151 : *-------------------------------------------------------------------*/
152 :
153 690755 : if ( is_DTXrate( ivas_total_brate ) == 0 )
154 : {
155 : /*-------------------------------------------------------------------*
156 : * Read IVAS format related signaling:
157 : * - in ISM : read number of objects
158 : * - in SBA : read SBA planar flag and SBA order
159 : * - in MASA : read number of TC
160 : * - in MC : read LS setup
161 : *-------------------------------------------------------------------*/
162 :
163 674056 : if ( st_ivas->ivas_format == STEREO_FORMAT )
164 : {
165 59964 : element_mode_flag = 1;
166 : }
167 614092 : else if ( st_ivas->ivas_format == ISM_FORMAT )
168 : {
169 : /* read the number of objects */
170 110431 : nchan_ism = 1;
171 110431 : k = (int16_t) ( ( ivas_total_brate / FRAMES_PER_SEC ) - 1 );
172 334543 : while ( st_ivas->bit_stream[k] && nchan_ism < MAX_NUM_OBJECTS )
173 : {
174 224112 : nchan_ism++;
175 224112 : k--;
176 : }
177 :
178 110431 : if ( st_ivas->ini_frame > 0 && nchan_ism != st_ivas->nchan_ism )
179 : {
180 0 : if ( Opt_tsm )
181 : {
182 0 : st_ivas->restartNeeded = 1;
183 :
184 0 : return IVAS_ERR_OK;
185 : }
186 : else
187 : {
188 : #ifdef DEBUGGING
189 : fprintf( stderr, "\nError: Changing the number of ISMs is not supported!\n" );
190 : #endif
191 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong number of objects signalled!" );
192 : }
193 : }
194 :
195 110431 : st_ivas->nchan_ism = nchan_ism;
196 110431 : st_ivas->ism_mode = ivas_ism_mode_select( nchan_ism, ivas_total_brate );
197 :
198 110431 : st_ivas->nchan_transport = nchan_ism;
199 110431 : if ( st_ivas->ism_mode == ISM_MODE_PARAM )
200 : {
201 20243 : st_ivas->nchan_transport = MAX_PARAM_ISM_WAVE;
202 : }
203 : }
204 503661 : else if ( st_ivas->ivas_format == SBA_FORMAT )
205 : {
206 : /* read Ambisonic (SBA) planar flag */
207 161470 : sba_planar = st_ivas->bit_stream[num_bits_read];
208 161470 : num_bits_read += SBA_PLANAR_BITS;
209 :
210 161470 : if ( st_ivas->ini_frame > 0 && sba_planar != st_ivas->sba_planar )
211 : {
212 0 : if ( Opt_tsm )
213 : {
214 0 : st_ivas->restartNeeded = 1;
215 0 : return IVAS_ERR_OK;
216 : }
217 : else
218 : {
219 : #ifdef DEBUGGING
220 : fprintf( stderr, "\nError: Changing the SBA planar/3D layout is not supported!\n" );
221 : #endif
222 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong SBA planar flag signalled!" );
223 : }
224 : }
225 :
226 : /* read Ambisonic (SBA) order */
227 161470 : sba_order = st_ivas->bit_stream[num_bits_read + 1];
228 161470 : sba_order += 2 * st_ivas->bit_stream[num_bits_read];
229 :
230 161470 : if ( st_ivas->ini_frame > 0 && sba_order != st_ivas->sba_order )
231 : {
232 0 : if ( Opt_tsm )
233 : {
234 0 : st_ivas->restartNeeded = 1;
235 :
236 0 : return IVAS_ERR_OK;
237 : }
238 : else
239 : {
240 : #ifdef DEBUGGING
241 : fprintf( stderr, "\nError: Changing the SBA order is not supported!\n" );
242 : #endif
243 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong SBA order signalled!" );
244 : }
245 : }
246 :
247 161470 : sba_analysis_order = ivas_sba_get_analysis_order( ivas_total_brate, sba_order );
248 161470 : st_ivas->nchan_transport = ivas_get_sba_num_TCs( ivas_total_brate, sba_analysis_order );
249 : }
250 342191 : else if ( st_ivas->ivas_format == MASA_FORMAT )
251 : {
252 108849 : uint8_t masaRestartCandidate = 0;
253 :
254 : /* read number of MASA transport channels */
255 108849 : if ( st_ivas->bit_stream[( ivas_total_brate / FRAMES_PER_SEC ) - 1] )
256 : {
257 52718 : if ( st_ivas->nchan_transport == 1 && Opt_tsm )
258 : {
259 0 : masaRestartCandidate = 1;
260 : }
261 :
262 52718 : st_ivas->nchan_transport = 2;
263 52718 : element_mode_flag = 1;
264 : }
265 : else
266 : {
267 56131 : if ( st_ivas->nchan_transport == 2 && Opt_tsm )
268 : {
269 6510 : masaRestartCandidate = 1;
270 : }
271 :
272 56131 : st_ivas->nchan_transport = 1;
273 : }
274 :
275 : /* this should be non-zero if original input format was MASA_ISM_FORMAT */
276 108849 : st_ivas->ism_mode = ISM_MODE_NONE;
277 108849 : nchan_ism = st_ivas->bit_stream[( ivas_total_brate / FRAMES_PER_SEC ) - 3] + 2 * st_ivas->bit_stream[( ivas_total_brate / FRAMES_PER_SEC ) - 2];
278 :
279 108849 : if ( nchan_ism > 0 )
280 : {
281 : /* the input_ivas_format should be MASA_ISM_FORMAT, but we cannot initialize it now */
282 : /* info about the number of objects:
283 : '00' - MASA format at the encoder
284 : '01' - MASA_ISM_FORMAT at the encoder, with 4 objects
285 : '10' - MASA_ISM_FORMAT at the encoder, with 3 objects
286 : '11' - MASA_ISM_FORMAT at the encoder, with 1 or 2 objects
287 : reading if 1 or 2 objects is performed later
288 : */
289 18124 : nchan_ism = 5 - nchan_ism;
290 18124 : if ( st_ivas->nchan_transport == 1 && nchan_ism == 2 )
291 : {
292 6433 : nchan_ism = 1;
293 : }
294 :
295 : /* for MASA_ISM_FORMAT at input the number of MASA transport channels is always 2 and the corresponding bit is not used here*/
296 18124 : st_ivas->nchan_transport = 2;
297 18124 : element_mode_flag = 1;
298 : }
299 90725 : else if ( masaRestartCandidate > 0 )
300 : {
301 0 : st_ivas->restartNeeded = 1;
302 :
303 0 : return IVAS_ERR_OK;
304 : }
305 :
306 108849 : if ( st_ivas->ini_frame > 0 && nchan_ism != st_ivas->nchan_ism )
307 : {
308 0 : if ( Opt_tsm )
309 : {
310 0 : st_ivas->restartNeeded = 1;
311 :
312 0 : return IVAS_ERR_OK;
313 : }
314 : else
315 : {
316 : #ifdef DEBUGGING
317 : fprintf( stderr, "\nError: Changing the number of ISMs is not supported!\n" );
318 : #endif
319 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong number of objects signalled!" );
320 : }
321 : }
322 :
323 108849 : st_ivas->nchan_ism = nchan_ism;
324 : }
325 233342 : else if ( st_ivas->ivas_format == MASA_ISM_FORMAT )
326 : {
327 60637 : st_ivas->nchan_transport = 2; /* always 2 MASA transport channels */
328 :
329 : /* the number of objects are written at the end of the bitstream */
330 60637 : nchan_ism = 2 * st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 1] + st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 2] + 1;
331 60637 : st_ivas->ism_mode = ivas_omasa_ism_mode_select( ivas_total_brate, nchan_ism );
332 :
333 60637 : if ( st_ivas->ini_frame > 0 && nchan_ism != st_ivas->nchan_ism )
334 : {
335 0 : if ( Opt_tsm )
336 : {
337 0 : st_ivas->restartNeeded = 1;
338 :
339 0 : return IVAS_ERR_OK;
340 : }
341 : else
342 : {
343 : #ifdef DEBUGGING
344 : fprintf( stderr, "\nError: Changing the number of ISMs is not supported!\n" );
345 : #endif
346 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong number of objects signalled!" );
347 : }
348 : }
349 :
350 60637 : st_ivas->nchan_ism = nchan_ism;
351 : }
352 172705 : else if ( st_ivas->ivas_format == SBA_ISM_FORMAT )
353 : {
354 : /* the number of objects is written at the end of the bitstream, in the SBA metadata */
355 70716 : nchan_ism = 2 * st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 1] + st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 2] + 1;
356 :
357 70716 : if ( st_ivas->ini_frame > 0 && nchan_ism != st_ivas->nchan_ism )
358 : {
359 0 : if ( Opt_tsm )
360 : {
361 0 : st_ivas->restartNeeded = 1;
362 :
363 0 : return IVAS_ERR_OK;
364 : }
365 : else
366 : {
367 : #ifdef DEBUGGING
368 : fprintf( stderr, "\nError: Changing the number of ISMs is not supported!\n" );
369 : #endif
370 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong number of objects signalled!" );
371 : }
372 : }
373 :
374 70716 : st_ivas->nchan_ism = nchan_ism;
375 :
376 : /* read Ambisonic (SBA) planar flag */
377 : /*sba_planar = st_ivas->bit_stream[num_bits_read];*/
378 70716 : num_bits_read += SBA_PLANAR_BITS;
379 :
380 : /* read Ambisonic (SBA) order (0 for signaling OSBA format at low bitrates)*/
381 70716 : sba_order = st_ivas->bit_stream[num_bits_read + 1];
382 70716 : sba_order += 2 * st_ivas->bit_stream[num_bits_read];
383 70716 : num_bits_read += SBA_ORDER_BITS;
384 :
385 : /* read the real Ambisonic order when the above bits are used to signal OSBA format */
386 70716 : if ( ivas_total_brate < IVAS_24k4 )
387 : {
388 3079 : sba_order = st_ivas->bit_stream[num_bits_read + 1];
389 3079 : sba_order += 2 * st_ivas->bit_stream[num_bits_read];
390 3079 : num_bits_read += SBA_ORDER_BITS;
391 : }
392 :
393 70716 : if ( st_ivas->ini_frame > 0 && sba_order != st_ivas->sba_order )
394 : {
395 0 : if ( Opt_tsm )
396 : {
397 0 : st_ivas->restartNeeded = 1;
398 :
399 0 : return IVAS_ERR_OK;
400 : }
401 : else
402 : {
403 : #ifdef DEBUGGING
404 : fprintf( stderr, "\nError: Changing the SBA order is not supported!\n" );
405 : #endif
406 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong SBA order signalled!" );
407 : }
408 : }
409 :
410 70716 : st_ivas->ism_mode = ivas_osba_ism_mode_select( ivas_total_brate, st_ivas->nchan_ism );
411 :
412 70716 : sba_analysis_order = ivas_sba_get_analysis_order( ivas_total_brate, sba_order );
413 70716 : st_ivas->nchan_transport = ivas_get_sba_num_TCs( ivas_total_brate, sba_analysis_order );
414 : }
415 101989 : else if ( st_ivas->ivas_format == MC_FORMAT )
416 : {
417 : /* read MC configuration */
418 101989 : idx = 0;
419 407956 : for ( k = 0; k < MC_LS_SETUP_BITS; k++ )
420 : {
421 305967 : if ( st_ivas->bit_stream[num_bits_read + k] )
422 : {
423 21901 : idx += 1 << ( MC_LS_SETUP_BITS - 1 - k );
424 : }
425 : }
426 101989 : num_bits_read += MC_LS_SETUP_BITS;
427 :
428 101989 : signaled_config = ivas_mc_map_ls_setup_to_output_config( idx );
429 :
430 101989 : if ( st_ivas->ini_frame > 0 && st_ivas->transport_config != signaled_config )
431 : {
432 0 : if ( Opt_tsm )
433 : {
434 0 : st_ivas->restartNeeded = 1;
435 :
436 0 : return IVAS_ERR_OK;
437 : }
438 : else
439 : {
440 : #ifdef DEBUGGING
441 : fprintf( stderr, "\nError: Switching of MC configurations is not supported!\n" );
442 : #endif
443 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "wrong MC configuration signalled!" );
444 : }
445 : }
446 :
447 101989 : st_ivas->mc_mode = ivas_mc_mode_select( ivas_mc_map_output_config_to_mc_ls_setup( signaled_config ), st_ivas->hDecoderConfig->ivas_total_brate );
448 101989 : st_ivas->transport_config = signaled_config;
449 : }
450 :
451 : /*-------------------------------------------------------------------*
452 : * Read element mode
453 : *-------------------------------------------------------------------*/
454 :
455 674056 : if ( st_ivas->ini_frame == 0 && element_mode_flag )
456 : {
457 : /* read stereo technology info */
458 260 : if ( ivas_total_brate < MIN_BRATE_MDCT_STEREO )
459 : {
460 : /* 1 bit */
461 183 : if ( st_ivas->bit_stream[num_bits_read] )
462 : {
463 0 : st_ivas->element_mode_init = 1 + IVAS_CPE_DFT;
464 : }
465 : else
466 : {
467 183 : st_ivas->element_mode_init = 0 + IVAS_CPE_DFT;
468 : }
469 : }
470 : else
471 : {
472 77 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
473 : }
474 : }
475 : }
476 16699 : else if ( ivas_total_brate == IVAS_SID_5k2 )
477 : {
478 2717 : switch ( st_ivas->sid_format )
479 : {
480 1355 : case SID_DFT_STEREO:
481 1355 : st_ivas->element_mode_init = IVAS_CPE_DFT;
482 1355 : break;
483 401 : case SID_MDCT_STEREO:
484 401 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
485 401 : break;
486 542 : case SID_ISM:
487 542 : st_ivas->element_mode_init = IVAS_SCE;
488 542 : break;
489 131 : case SID_MASA_1TC:
490 131 : st_ivas->element_mode_init = IVAS_SCE;
491 131 : st_ivas->nchan_transport = 1;
492 131 : break;
493 74 : case SID_MASA_2TC:
494 74 : if ( st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 1 - SID_FORMAT_NBITS] == 1 )
495 : {
496 0 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
497 : }
498 : else
499 : {
500 74 : st_ivas->element_mode_init = IVAS_CPE_DFT;
501 : }
502 74 : st_ivas->nchan_transport = 2;
503 74 : break;
504 113 : case SID_SBA_1TC:
505 113 : st_ivas->element_mode_init = IVAS_SCE;
506 113 : break;
507 101 : case SID_SBA_2TC:
508 101 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
509 101 : break;
510 : }
511 :
512 2717 : if ( st_ivas->ivas_format == ISM_FORMAT )
513 : {
514 : /* read the number of objects */
515 542 : nchan_ism = 1;
516 542 : k = (int16_t) ( ( ivas_total_brate / FRAMES_PER_SEC ) - 1 - SID_FORMAT_NBITS );
517 1799 : while ( st_ivas->bit_stream[k] && nchan_ism < MAX_NUM_OBJECTS )
518 : {
519 1257 : nchan_ism++;
520 1257 : k--;
521 : }
522 542 : k--;
523 :
524 542 : if ( st_ivas->ini_frame > 0 && nchan_ism != st_ivas->nchan_ism )
525 : {
526 0 : if ( Opt_tsm )
527 : {
528 0 : st_ivas->restartNeeded = 1;
529 :
530 0 : return IVAS_ERR_OK;
531 : }
532 : else
533 : {
534 : #ifdef DEBUGGING
535 : fprintf( stderr, "\nError: Changing the number of ISMs is not supported!\n" );
536 : #endif
537 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Wrong number of objects signalled!" );
538 : }
539 : }
540 :
541 542 : st_ivas->nchan_ism = nchan_ism;
542 :
543 : /* read ism_mode */
544 542 : st_ivas->ism_mode = ISM_MODE_DISC;
545 542 : if ( nchan_ism > 2 )
546 : {
547 382 : k -= nchan_ism; /* SID metadata flags */
548 382 : idx = st_ivas->bit_stream[k];
549 382 : st_ivas->ism_mode = (ISM_MODE) ( idx + 1 );
550 : }
551 :
552 542 : st_ivas->nchan_transport = nchan_ism;
553 542 : if ( st_ivas->ism_mode == ISM_MODE_PARAM )
554 : {
555 107 : st_ivas->nchan_transport = MAX_PARAM_ISM_WAVE;
556 : }
557 : }
558 : }
559 :
560 690755 : st_ivas->bit_stream = bit_stream_orig;
561 :
562 690755 : return IVAS_ERR_OK;
563 : }
564 :
565 :
566 : /*-------------------------------------------------------------------*
567 : * ivas_dec_setup()
568 : *
569 : * IVAS decoder setup
570 : *-------------------------------------------------------------------*/
571 :
572 691776 : ivas_error ivas_dec_setup(
573 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
574 : )
575 : {
576 : int16_t k, idx, num_bits_read;
577 : int16_t nchan_ism, element_mode_flag;
578 : Decoder_State *st;
579 : int32_t ivas_total_brate;
580 : ivas_error error;
581 :
582 691776 : error = IVAS_ERR_OK;
583 :
584 691776 : num_bits_read = 0;
585 691776 : element_mode_flag = 0;
586 :
587 691776 : ivas_total_brate = st_ivas->hDecoderConfig->ivas_total_brate;
588 :
589 : /*-------------------------------------------------------------------*
590 : * Read IVAS format
591 : *-------------------------------------------------------------------*/
592 :
593 691776 : if ( ( error = ivas_read_format( st_ivas, &num_bits_read ) ) != IVAS_ERR_OK )
594 : {
595 0 : return error;
596 : }
597 :
598 : /*-------------------------------------------------------------------*
599 : * Read other signaling (ISM/MC mode, number of channels, etc.)
600 : *-------------------------------------------------------------------*/
601 :
602 691776 : if ( is_DTXrate( ivas_total_brate ) == 0 )
603 : {
604 : /*-------------------------------------------------------------------*
605 : * Read IVAS format related signaling:
606 : * - in ISM : read number of objects
607 : * - in SBA : read SBA planar flag and SBA order
608 : * - in MASA : read number of TC
609 : * - in MC : read LS setup
610 : *-------------------------------------------------------------------*/
611 :
612 674056 : if ( st_ivas->ivas_format == STEREO_FORMAT )
613 : {
614 59964 : element_mode_flag = 1;
615 : }
616 614092 : else if ( st_ivas->ivas_format == ISM_FORMAT )
617 : {
618 : /* read the number of objects */
619 110431 : st_ivas->nchan_transport = 1;
620 110431 : nchan_ism = 1;
621 110431 : k = (int16_t) ( ( ivas_total_brate / FRAMES_PER_SEC ) - 1 );
622 334543 : while ( st_ivas->bit_stream[k] && nchan_ism < MAX_NUM_OBJECTS )
623 : {
624 224112 : nchan_ism++;
625 224112 : k--;
626 : }
627 :
628 110431 : st_ivas->nchan_ism = nchan_ism;
629 :
630 110431 : if ( ( error = ivas_ism_dec_config( st_ivas, st_ivas->ism_mode ) ) != IVAS_ERR_OK )
631 : {
632 0 : return error;
633 : }
634 : }
635 503661 : else if ( st_ivas->ivas_format == SBA_FORMAT )
636 : {
637 : /* read Ambisonic (SBA) planar flag */
638 161470 : st_ivas->sba_planar = st_ivas->bit_stream[num_bits_read];
639 161470 : num_bits_read += SBA_PLANAR_BITS;
640 :
641 : /* read Ambisonic (SBA) order */
642 161470 : st_ivas->sba_order = st_ivas->bit_stream[num_bits_read + 1];
643 161470 : st_ivas->sba_order += 2 * st_ivas->bit_stream[num_bits_read];
644 :
645 161470 : num_bits_read += SBA_ORDER_BITS;
646 161470 : if ( st_ivas->ini_frame > 0 && ivas_total_brate != st_ivas->last_active_ivas_total_brate && ivas_total_brate > IVAS_SID_5k2 )
647 : {
648 1128 : if ( ( error = ivas_sba_dec_reconfigure( st_ivas ) ) != IVAS_ERR_OK )
649 : {
650 0 : return error;
651 : }
652 : }
653 : else
654 : {
655 : /* set Ambisonic (SBA) order used for analysis and coding */
656 160342 : st_ivas->sba_analysis_order = ivas_sba_get_analysis_order( ivas_total_brate, st_ivas->sba_order );
657 :
658 160342 : ivas_sba_config( ivas_total_brate, st_ivas->sba_analysis_order, -1, &( st_ivas->nchan_transport ), st_ivas->sba_planar, &st_ivas->nSCE, &st_ivas->nCPE, &st_ivas->element_mode_init );
659 : }
660 : }
661 342191 : else if ( st_ivas->ivas_format == MASA_FORMAT )
662 : {
663 : /* read number of MASA transport channels */
664 108849 : if ( st_ivas->bit_stream[( ivas_total_brate / FRAMES_PER_SEC ) - 1] )
665 : {
666 52718 : st_ivas->nchan_transport = 2;
667 52718 : element_mode_flag = 1;
668 : }
669 : else
670 : {
671 56131 : st_ivas->nchan_transport = 1;
672 : }
673 :
674 : /* this should be non-zero if original input format was MASA_ISM_FORMAT */
675 108849 : st_ivas->ism_mode = ISM_MODE_NONE;
676 108849 : st_ivas->nchan_ism = st_ivas->bit_stream[( ivas_total_brate / FRAMES_PER_SEC ) - 3] + 2 * st_ivas->bit_stream[( ivas_total_brate / FRAMES_PER_SEC ) - 2];
677 :
678 108849 : if ( st_ivas->nchan_ism > 0 )
679 : {
680 : /* the input_ivas_format should be MASA_ISM_FORMAT, but we cannot initialize it now */
681 : /* info about the number of objects:
682 : '00' - MASA format at the encoder
683 : '01' - MASA_ISM_FORMAT at the encoder, with 4 objects
684 : '10' - MASA_ISM_FORMAT at the encoder, with 3 objects
685 : '11' - MASA_ISM_FORMAT at the encoder, with 1 or 2 objects
686 : reading if 1 or 2 objects is performed later
687 : */
688 18124 : st_ivas->nchan_ism = 5 - st_ivas->nchan_ism;
689 18124 : if ( st_ivas->nchan_transport == 1 && st_ivas->nchan_ism == 2 )
690 : {
691 6433 : st_ivas->nchan_ism = 1;
692 : }
693 :
694 : /* for MASA_ISM_FORMAT at input the number of MASA transport channels is always 2 and the corresponding bit is not used here*/
695 18124 : st_ivas->nchan_transport = 2;
696 18124 : element_mode_flag = 1;
697 : }
698 :
699 108849 : if ( st_ivas->ini_frame > 0 )
700 : {
701 : /* reconfigure in case a change of operation mode is detected */
702 108560 : if ( ( ivas_total_brate > IVAS_SID_5k2 && ivas_total_brate != st_ivas->hDecoderConfig->last_ivas_total_brate ) || ( st_ivas->ini_active_frame == 0 ) )
703 : {
704 3717 : if ( st_ivas->last_ivas_format == MASA_FORMAT )
705 : {
706 1648 : if ( st_ivas->ini_active_frame == 0 && ivas_total_brate != FRAME_NO_DATA && ivas_total_brate < MASA_STEREO_MIN_BITRATE && st_ivas->nCPE == 1 )
707 : {
708 0 : st_ivas->hCPE[0]->nchan_out = 1;
709 : }
710 : else
711 : {
712 1648 : if ( ( error = ivas_masa_dec_reconfigure( st_ivas ) ) != IVAS_ERR_OK )
713 : {
714 0 : return error;
715 : }
716 : }
717 : }
718 : else
719 : {
720 2069 : if ( ( error = ivas_omasa_dec_config( st_ivas ) ) != IVAS_ERR_OK )
721 : {
722 0 : return error;
723 : }
724 : }
725 : }
726 : }
727 : }
728 233342 : else if ( st_ivas->ivas_format == MASA_ISM_FORMAT )
729 : {
730 60637 : st_ivas->nchan_transport = 2; /* always 2 MASA transport channels */
731 :
732 : /* for the DISC mode the number of objects are written at the end of the bitstream, in the MASA metadata */
733 60637 : st_ivas->nchan_ism = 2 * st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 1] + st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 2] + 1;
734 60637 : st_ivas->ism_mode = ivas_omasa_ism_mode_select( ivas_total_brate, st_ivas->nchan_ism );
735 :
736 60637 : if ( st_ivas->ini_frame > 0 )
737 : {
738 : /* reconfigure in case a change of operation mode is detected */
739 60393 : if ( ( ivas_total_brate > IVAS_SID_5k2 && ivas_total_brate != st_ivas->hDecoderConfig->last_ivas_total_brate ) || ( st_ivas->ini_active_frame == 0 ) )
740 : {
741 5489 : if ( ( error = ivas_omasa_dec_config( st_ivas ) ) != IVAS_ERR_OK )
742 : {
743 0 : return error;
744 : }
745 : }
746 : }
747 : }
748 172705 : else if ( st_ivas->ivas_format == SBA_ISM_FORMAT )
749 : {
750 : /* the number of objects is written at the end of the bitstream, in the SBA metadata */
751 70716 : st_ivas->nchan_ism = 2 * st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 1] + st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 2] + 1;
752 :
753 : /* read Ambisonic (SBA) planar flag */
754 70716 : st_ivas->sba_planar = st_ivas->bit_stream[num_bits_read];
755 70716 : num_bits_read += SBA_PLANAR_BITS;
756 :
757 : /* read Ambisonic (SBA) order (0 for signaling OSBA format at low bitrates)*/
758 70716 : st_ivas->sba_order = st_ivas->bit_stream[num_bits_read + 1];
759 70716 : st_ivas->sba_order += 2 * st_ivas->bit_stream[num_bits_read];
760 70716 : num_bits_read += SBA_ORDER_BITS;
761 :
762 : /* read the real Ambisonic order when the above bits are used to signal OSBA format */
763 70716 : if ( ivas_total_brate < IVAS_24k4 )
764 : {
765 3079 : st_ivas->sba_order = st_ivas->bit_stream[num_bits_read + 1];
766 3079 : st_ivas->sba_order += 2 * st_ivas->bit_stream[num_bits_read];
767 3079 : num_bits_read += SBA_ORDER_BITS;
768 : }
769 :
770 70716 : if ( st_ivas->ini_frame > 0 && ivas_total_brate != st_ivas->last_active_ivas_total_brate )
771 : {
772 744 : if ( ( error = ivas_sba_dec_reconfigure( st_ivas ) ) != IVAS_ERR_OK )
773 : {
774 0 : return error;
775 : }
776 : }
777 : else
778 : {
779 : /* set Ambisonic (SBA) order used for analysis and coding */
780 69972 : st_ivas->sba_analysis_order = ivas_sba_get_analysis_order( ivas_total_brate, st_ivas->sba_order );
781 :
782 69972 : ivas_sba_config( ivas_total_brate, st_ivas->sba_analysis_order, -1, &( st_ivas->nchan_transport ), st_ivas->sba_planar, &st_ivas->nSCE, &st_ivas->nCPE, &st_ivas->element_mode_init );
783 :
784 : /*correct number of CPEs for discrete ISM coding*/
785 69972 : if ( st_ivas->ini_frame > 0 && st_ivas->ism_mode == ISM_SBA_MODE_DISC )
786 : {
787 : {
788 : int16_t n;
789 :
790 54874 : n = st_ivas->nchan_transport + st_ivas->nchan_ism;
791 54874 : st_ivas->nCPE = ( n + 1 ) >> 1;
792 : }
793 : }
794 : }
795 70716 : if ( ivas_osba_ism_mode_select( ivas_total_brate, st_ivas->nchan_ism ) == ISM_SBA_MODE_DISC )
796 : {
797 55320 : st_ivas->ism_mode = ISM_SBA_MODE_DISC;
798 : }
799 : else
800 : {
801 15396 : st_ivas->ism_mode = ISM_MODE_NONE;
802 : }
803 : }
804 101989 : else if ( st_ivas->ivas_format == MC_FORMAT )
805 : {
806 : /* read MC configuration */
807 101989 : idx = 0;
808 407956 : for ( k = 0; k < MC_LS_SETUP_BITS; k++ )
809 : {
810 305967 : if ( st_ivas->bit_stream[num_bits_read + k] )
811 : {
812 21901 : idx += 1 << ( MC_LS_SETUP_BITS - 1 - k );
813 : }
814 : }
815 101989 : num_bits_read += MC_LS_SETUP_BITS;
816 :
817 : /* select MC format mode; reconfigure the MC format decoder */
818 101989 : if ( ( error = ivas_mc_dec_config( st_ivas, idx ) ) != IVAS_ERR_OK )
819 : {
820 0 : return error;
821 : }
822 : }
823 :
824 : /*-------------------------------------------------------------------*
825 : * Read element mode
826 : *-------------------------------------------------------------------*/
827 :
828 674056 : if ( st_ivas->ini_frame == 0 && element_mode_flag )
829 : {
830 : /* read stereo technology info */
831 260 : if ( ivas_total_brate < MIN_BRATE_MDCT_STEREO )
832 : {
833 : /* 1 bit */
834 183 : if ( st_ivas->bit_stream[num_bits_read] )
835 : {
836 0 : st_ivas->element_mode_init = 1 + IVAS_CPE_DFT;
837 : }
838 : else
839 : {
840 183 : st_ivas->element_mode_init = 0 + IVAS_CPE_DFT;
841 : }
842 : }
843 : else
844 : {
845 77 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
846 : }
847 : }
848 : }
849 17720 : else if ( ivas_total_brate == IVAS_SID_5k2 )
850 : {
851 2717 : switch ( st_ivas->sid_format )
852 : {
853 1355 : case SID_DFT_STEREO:
854 1355 : st_ivas->element_mode_init = IVAS_CPE_DFT;
855 1355 : break;
856 401 : case SID_MDCT_STEREO:
857 401 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
858 401 : break;
859 542 : case SID_ISM:
860 542 : st_ivas->element_mode_init = IVAS_SCE;
861 542 : break;
862 131 : case SID_MASA_1TC:
863 131 : st_ivas->element_mode_init = IVAS_SCE;
864 131 : st_ivas->nchan_transport = 1;
865 131 : break;
866 74 : case SID_MASA_2TC:
867 74 : if ( st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 1 - SID_FORMAT_NBITS] == 1 )
868 : {
869 0 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
870 : }
871 : else
872 : {
873 74 : st_ivas->element_mode_init = IVAS_CPE_DFT;
874 : }
875 74 : st_ivas->nchan_transport = 2;
876 74 : break;
877 113 : case SID_SBA_1TC:
878 113 : st_ivas->element_mode_init = IVAS_SCE;
879 113 : break;
880 101 : case SID_SBA_2TC:
881 101 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
882 101 : break;
883 : }
884 :
885 2717 : if ( st_ivas->ini_frame > 0 && st_ivas->ivas_format == SBA_FORMAT )
886 : {
887 : int16_t nchan_transport_old, nchan_transport;
888 214 : nchan_transport_old = st_ivas->nchan_transport;
889 214 : nchan_transport = ( st_ivas->sid_format == SID_SBA_2TC ) ? 2 : 1;
890 :
891 214 : if ( ( nchan_transport_old != nchan_transport ) )
892 : {
893 : /*Setting the default bitrate for the reconfig function*/
894 0 : if ( st_ivas->sid_format == SID_SBA_2TC )
895 : {
896 0 : st_ivas->hDecoderConfig->ivas_total_brate = IVAS_48k;
897 : }
898 : else
899 : {
900 0 : st_ivas->hDecoderConfig->ivas_total_brate = IVAS_24k4;
901 : }
902 :
903 0 : if ( ( error = ivas_sba_dec_reconfigure( st_ivas ) ) != IVAS_ERR_OK )
904 : {
905 0 : return error;
906 : }
907 :
908 0 : st_ivas->last_active_ivas_total_brate = st_ivas->hDecoderConfig->ivas_total_brate;
909 0 : st_ivas->hDecoderConfig->ivas_total_brate = ivas_total_brate;
910 : }
911 : }
912 :
913 2717 : if ( st_ivas->ini_frame > 0 && st_ivas->ivas_format == MASA_FORMAT )
914 : {
915 205 : st_ivas->nchan_ism = 0;
916 205 : st_ivas->ism_mode = ISM_MODE_NONE;
917 : }
918 :
919 2717 : if ( st_ivas->ivas_format == ISM_FORMAT )
920 : {
921 542 : ISM_MODE last_ism_mode = st_ivas->ism_mode;
922 :
923 : /* read the number of objects */
924 542 : st_ivas->nchan_transport = 1;
925 542 : nchan_ism = 1;
926 542 : k = (int16_t) ( ( ivas_total_brate / FRAMES_PER_SEC ) - 1 ) - SID_FORMAT_NBITS;
927 1799 : while ( st_ivas->bit_stream[k] && nchan_ism < MAX_NUM_OBJECTS )
928 : {
929 1257 : nchan_ism++;
930 1257 : k--;
931 : }
932 542 : k--;
933 :
934 542 : if ( st_ivas->ini_frame > 0 && nchan_ism != st_ivas->nchan_ism )
935 : {
936 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "wrong number of objects signalled!" );
937 : }
938 :
939 542 : st_ivas->nchan_ism = nchan_ism;
940 :
941 : /* read ism_mode */
942 542 : st_ivas->ism_mode = ISM_MODE_DISC;
943 542 : if ( nchan_ism > 2 )
944 : {
945 382 : k -= nchan_ism; /* SID metadata flags */
946 382 : idx = st_ivas->bit_stream[k];
947 382 : st_ivas->ism_mode = (ISM_MODE) ( idx + 1 );
948 : }
949 :
950 542 : if ( st_ivas->ini_frame == 0 )
951 : {
952 0 : last_ism_mode = st_ivas->ism_mode;
953 : }
954 :
955 542 : if ( ( error = ivas_ism_dec_config( st_ivas, last_ism_mode ) ) != IVAS_ERR_OK )
956 : {
957 0 : return error;
958 : }
959 : }
960 : }
961 :
962 : /*-------------------------------------------------------------------*
963 : * Initialize decoder in the first good frame based on IVAS format
964 : * and number of transport channels
965 : *-------------------------------------------------------------------*/
966 :
967 691776 : if ( st_ivas->ini_frame == 0 && st_ivas->ivas_format != UNDEFINED_FORMAT )
968 : {
969 1666 : if ( ( error = doSanityChecks_IVAS( st_ivas ) ) != IVAS_ERR_OK )
970 : {
971 0 : return IVAS_ERROR( error, "Sanity checks failed" );
972 : }
973 :
974 1666 : if ( ( error = ivas_init_decoder( st_ivas ) ) != IVAS_ERR_OK )
975 : {
976 0 : return error;
977 : }
978 : }
979 :
980 : /*----------------------------------------------------------------*
981 : * Reset bitstream pointers
982 : *----------------------------------------------------------------*/
983 :
984 691776 : ivas_set_bitstream_pointers( st_ivas );
985 :
986 691776 : reset_elements( st_ivas );
987 :
988 : /* update bitstream buffer pointer -> take into account already read bits */
989 691776 : if ( ( st_ivas->nSCE > 0 ) || ( st_ivas->nCPE > 0 ) )
990 : {
991 691776 : st = ( st_ivas->nSCE > 0 ) ? st_ivas->hSCE[0]->hCoreCoder[0] : st_ivas->hCPE[0]->hCoreCoder[0];
992 691776 : st->next_bit_pos = num_bits_read;
993 691776 : st->total_brate = ACELP_8k00; /* only temporary initialization - this is needed for get_next_indice() in the frame following NO_DATA frame */
994 : }
995 :
996 691776 : return error;
997 : }
998 :
999 :
1000 : /*-------------------------------------------------------------------*
1001 : * ivas_read_format()
1002 : *
1003 : * Read IVAS format signaling
1004 : *-------------------------------------------------------------------*/
1005 :
1006 1382531 : static ivas_error ivas_read_format(
1007 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder structure */
1008 : int16_t *num_bits_read /* o : number of IVAS signaling bits read from the bitstream */
1009 : )
1010 : {
1011 : int16_t k, idx;
1012 : int32_t ivas_total_brate;
1013 : ivas_error error;
1014 :
1015 1382531 : error = IVAS_ERR_OK;
1016 :
1017 1382531 : ivas_total_brate = st_ivas->hDecoderConfig->ivas_total_brate;
1018 :
1019 1382531 : *num_bits_read = 0;
1020 :
1021 1382531 : if ( !st_ivas->bfi && is_DTXrate( ivas_total_brate ) == 0 )
1022 : {
1023 : /* read IVAS format */
1024 1348112 : k = 0;
1025 1348112 : if ( st_ivas->bit_stream[*num_bits_read] )
1026 : {
1027 1024206 : k = 1;
1028 : }
1029 1348112 : k <<= 1;
1030 1348112 : ( *num_bits_read )++;
1031 :
1032 1348112 : if ( st_ivas->bit_stream[*num_bits_read] )
1033 : {
1034 750774 : k += 1;
1035 : }
1036 1348112 : ( *num_bits_read )++;
1037 :
1038 1348112 : switch ( k )
1039 : {
1040 119928 : case 0:
1041 119928 : st_ivas->ivas_format = STEREO_FORMAT;
1042 119928 : break;
1043 203978 : case 1:
1044 203978 : st_ivas->ivas_format = MC_FORMAT;
1045 203978 : break;
1046 477410 : case 2:
1047 477410 : st_ivas->ivas_format = ISM_FORMAT;
1048 :
1049 477410 : if ( ivas_total_brate >= IVAS_24k4 )
1050 : {
1051 460764 : if ( st_ivas->bit_stream[*num_bits_read] )
1052 : {
1053 256548 : ( *num_bits_read )++;
1054 256548 : if ( st_ivas->bit_stream[*num_bits_read] )
1055 : {
1056 135274 : st_ivas->ivas_format = SBA_ISM_FORMAT;
1057 : }
1058 : else
1059 : {
1060 121274 : st_ivas->ivas_format = MASA_ISM_FORMAT;
1061 : }
1062 : }
1063 460764 : ( *num_bits_read )++;
1064 : }
1065 477410 : break;
1066 546796 : case 3:
1067 546796 : if ( st_ivas->bit_stream[*num_bits_read] )
1068 : {
1069 217698 : st_ivas->ivas_format = MASA_FORMAT;
1070 : }
1071 : else
1072 : {
1073 329098 : st_ivas->ivas_format = SBA_FORMAT;
1074 : /* read Ambisonic (SBA) planar flag */
1075 329098 : st_ivas->sba_planar = st_ivas->bit_stream[( *num_bits_read ) + 1];
1076 :
1077 : /* read Ambisonic (SBA) order */
1078 329098 : st_ivas->sba_order = st_ivas->bit_stream[( *num_bits_read ) + 2 + SBA_PLANAR_BITS];
1079 329098 : st_ivas->sba_order += 2 * st_ivas->bit_stream[( *num_bits_read ) + 1 + SBA_PLANAR_BITS];
1080 329098 : if ( st_ivas->sba_order == 0 )
1081 : {
1082 6158 : st_ivas->ivas_format = SBA_ISM_FORMAT;
1083 :
1084 : /* read the real Ambisonic order when the above bits are used to signal OSBA format */
1085 6158 : if ( ivas_total_brate < IVAS_24k4 )
1086 : {
1087 6158 : st_ivas->sba_order = st_ivas->bit_stream[*num_bits_read + 2 + SBA_PLANAR_BITS + SBA_ORDER_BITS];
1088 6158 : st_ivas->sba_order += 2 * st_ivas->bit_stream[*num_bits_read + 1 + SBA_PLANAR_BITS + SBA_ORDER_BITS];
1089 : }
1090 : }
1091 : }
1092 546796 : ( *num_bits_read )++;
1093 :
1094 546796 : break;
1095 : }
1096 1348112 : }
1097 34419 : else if ( !st_ivas->bfi && ivas_total_brate == IVAS_SID_5k2 )
1098 : {
1099 : /* read IVAS format in SID frame */
1100 5434 : idx = 0;
1101 21736 : for ( k = 0; k < SID_FORMAT_NBITS; k++ )
1102 : {
1103 16302 : idx += st_ivas->bit_stream[k] << ( SID_FORMAT_NBITS - 1 - k );
1104 : }
1105 :
1106 5434 : ( *num_bits_read ) += SID_FORMAT_NBITS;
1107 5434 : st_ivas->sid_format = idx;
1108 :
1109 5434 : switch ( idx )
1110 : {
1111 3512 : case SID_DFT_STEREO:
1112 : case SID_MDCT_STEREO:
1113 3512 : st_ivas->ivas_format = STEREO_FORMAT;
1114 3512 : break;
1115 1084 : case SID_ISM:
1116 1084 : st_ivas->ivas_format = ISM_FORMAT;
1117 1084 : break;
1118 226 : case SID_SBA_1TC:
1119 226 : st_ivas->ivas_format = SBA_FORMAT;
1120 226 : st_ivas->element_mode_init = IVAS_SCE;
1121 226 : break;
1122 202 : case SID_SBA_2TC:
1123 202 : st_ivas->ivas_format = SBA_FORMAT;
1124 202 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
1125 202 : break;
1126 262 : case SID_MASA_1TC:
1127 262 : st_ivas->ivas_format = MASA_FORMAT;
1128 262 : st_ivas->element_mode_init = IVAS_SCE;
1129 262 : break;
1130 148 : case SID_MASA_2TC:
1131 148 : st_ivas->ivas_format = MASA_FORMAT;
1132 148 : if ( st_ivas->bit_stream[ivas_total_brate / FRAMES_PER_SEC - 1] == 1 )
1133 : {
1134 0 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
1135 : }
1136 : else
1137 : {
1138 148 : st_ivas->element_mode_init = IVAS_CPE_DFT;
1139 : }
1140 148 : break;
1141 0 : default:
1142 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Invalid value %c found in SID format field.", st_ivas->sid_format );
1143 : }
1144 :
1145 5434 : if ( st_ivas->ivas_format == SBA_FORMAT )
1146 : {
1147 : /* read Ambisonic (SBA) planar flag */
1148 428 : st_ivas->sba_planar = st_ivas->bit_stream[*num_bits_read];
1149 428 : *num_bits_read += SBA_PLANAR_BITS;
1150 :
1151 : /* read Ambisonic (SBA) order */
1152 428 : st_ivas->sba_order = st_ivas->bit_stream[*num_bits_read + 1];
1153 428 : st_ivas->sba_order += 2 * st_ivas->bit_stream[*num_bits_read];
1154 428 : *num_bits_read += SBA_ORDER_BITS;
1155 428 : if ( st_ivas->sba_analysis_order == 0 )
1156 : {
1157 0 : st_ivas->sba_analysis_order = SBA_FOA_ORDER;
1158 : }
1159 : }
1160 :
1161 : /* reset bitstream handle to avoid BER detection after reading the 2400 kbps for ch0 */
1162 5434 : st_ivas->bit_stream += ( *num_bits_read );
1163 5434 : ( *num_bits_read ) = 0;
1164 : }
1165 : else
1166 : {
1167 : /* In SID/NO_DATA frames, use the previous frame IVAS format */
1168 : }
1169 :
1170 1382531 : return error;
1171 : }
1172 :
1173 :
1174 : /*-------------------------------------------------------------------*
1175 : * getNumChanSynthesis()
1176 : *
1177 : * get number of output channels used for synthesis/decoding
1178 : * (often different from number of output channels!)
1179 : *-------------------------------------------------------------------*/
1180 :
1181 : /*! r: number of channels to be synthesised */
1182 814590 : int16_t getNumChanSynthesis(
1183 : Decoder_Struct *st_ivas /* i : IVAS decoder structure */
1184 : )
1185 : {
1186 : int16_t n;
1187 :
1188 814590 : n = st_ivas->nSCE + CPE_CHANNELS * st_ivas->nCPE;
1189 :
1190 814590 : if ( st_ivas->sba_dirac_stereo_flag )
1191 : {
1192 13020 : n = CPE_CHANNELS;
1193 : }
1194 801570 : else if ( ( st_ivas->hMCT != NULL || st_ivas->ivas_format == SBA_FORMAT ) && st_ivas->ivas_format != SBA_ISM_FORMAT )
1195 : {
1196 7411 : n = st_ivas->nchan_transport;
1197 : }
1198 794159 : else if ( st_ivas->ivas_format == SBA_ISM_FORMAT )
1199 : {
1200 458938 : if ( st_ivas->ism_mode == ISM_SBA_MODE_DISC )
1201 : {
1202 422701 : n = st_ivas->nchan_transport + st_ivas->nchan_ism;
1203 : }
1204 : else
1205 : {
1206 36237 : n = st_ivas->nchan_transport;
1207 : }
1208 : }
1209 :
1210 814590 : return n;
1211 : }
1212 :
1213 :
1214 : /*-------------------------------------------------------------------*
1215 : * copy_decoder_config()
1216 : *
1217 : * Copy IVAS configuration structure to the CoreCoder state structure
1218 : *-------------------------------------------------------------------*/
1219 :
1220 19096 : void copy_decoder_config(
1221 : Decoder_Struct *st_ivas, /* i : IVAS decoder structure */
1222 : Decoder_State *st /* o : decoder state structure */
1223 : )
1224 : {
1225 19096 : st->output_Fs = st_ivas->hDecoderConfig->output_Fs;
1226 19096 : st->Opt_AMR_WB = st_ivas->hDecoderConfig->Opt_AMR_WB;
1227 19096 : st->codec_mode = st_ivas->codec_mode;
1228 19096 : st->ini_frame = st_ivas->ini_frame;
1229 :
1230 19096 : st->bfi = st_ivas->bfi;
1231 :
1232 19096 : st->writeFECoffset = st_ivas->writeFECoffset;
1233 :
1234 19096 : st->element_mode = st_ivas->element_mode_init;
1235 :
1236 19096 : return;
1237 : }
1238 :
1239 :
1240 : /*-------------------------------------------------------------------*
1241 : * ivas_init_decoder_front()
1242 : *
1243 : * Set decoder parameters to initial values
1244 : *-------------------------------------------------------------------*/
1245 :
1246 1678 : ivas_error ivas_init_decoder_front(
1247 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
1248 : )
1249 : {
1250 : ivas_error error;
1251 :
1252 1678 : error = IVAS_ERR_OK;
1253 :
1254 : /*-----------------------------------------------------------------*
1255 : * Resets
1256 : *-----------------------------------------------------------------*/
1257 :
1258 1678 : st_ivas->nSCE = 0;
1259 1678 : st_ivas->nCPE = 0;
1260 1678 : st_ivas->nchan_ism = 0;
1261 1678 : st_ivas->nchan_transport = -1;
1262 :
1263 1678 : st_ivas->ism_mode = ISM_MODE_NONE;
1264 1678 : st_ivas->mc_mode = MC_MODE_NONE;
1265 :
1266 1678 : st_ivas->sid_format = SID_FORMAT_NONE;
1267 1678 : st_ivas->sba_dirac_stereo_flag = 0;
1268 :
1269 : /* HRTF binauralization latency in ns */
1270 1678 : st_ivas->binaural_latency_ns = 0;
1271 :
1272 : #ifdef DEBUGGING
1273 : st_ivas->noClipping = 0;
1274 : #endif
1275 : /*-------------------------------------------------------------------*
1276 : * Allocate and initialize Custom loudspeaker layout handle
1277 : *--------------------------------------------------------------------*/
1278 :
1279 1678 : if ( st_ivas->hDecoderConfig->Opt_LsCustom )
1280 : {
1281 3 : if ( ( error = ivas_ls_custom_open( &( st_ivas->hLsSetupCustom ) ) ) != IVAS_ERR_OK )
1282 : {
1283 0 : return error;
1284 : }
1285 : }
1286 :
1287 : /*-------------------------------------------------------------------*
1288 : * Allocate and initialize Head-Tracking handle
1289 : *--------------------------------------------------------------------*/
1290 :
1291 1678 : if ( st_ivas->hDecoderConfig->Opt_Headrotation )
1292 : {
1293 1115 : if ( ( error = ivas_headTrack_open( &( st_ivas->hHeadTrackData ) ) ) != IVAS_ERR_OK )
1294 : {
1295 0 : return error;
1296 : }
1297 1115 : if ( ( error = ivas_orient_trk_SetTrackingType( st_ivas->hHeadTrackData->OrientationTracker, st_ivas->hDecoderConfig->orientation_tracking ) ) != IVAS_ERR_OK )
1298 : {
1299 0 : return error;
1300 : }
1301 : }
1302 :
1303 : /*-------------------------------------------------------------------*
1304 : * Allocate and initialize external orientation handle
1305 : *--------------------------------------------------------------------*/
1306 :
1307 1678 : if ( st_ivas->hDecoderConfig->Opt_ExternalOrientation )
1308 : {
1309 31 : if ( ( error = ivas_external_orientation_open( &( st_ivas->hExtOrientationData ), st_ivas->hDecoderConfig->render_framesize ) ) != IVAS_ERR_OK )
1310 : {
1311 0 : return error;
1312 : }
1313 : }
1314 :
1315 : /*-------------------------------------------------------------------*
1316 : * Allocate and initialize combined orientation handle
1317 : *--------------------------------------------------------------------*/
1318 :
1319 1678 : if ( st_ivas->hDecoderConfig->Opt_Headrotation || st_ivas->hDecoderConfig->Opt_ExternalOrientation )
1320 : {
1321 1115 : if ( ( error = ivas_combined_orientation_open( &( st_ivas->hCombinedOrientationData ), st_ivas->hDecoderConfig->output_Fs, st_ivas->hDecoderConfig->render_framesize ) ) != IVAS_ERR_OK )
1322 : {
1323 0 : return error;
1324 : }
1325 : }
1326 :
1327 : /*-------------------------------------------------------------------*
1328 : * Allocate and initialize Binaural Renderer configuration handle
1329 : *--------------------------------------------------------------------*/
1330 :
1331 1678 : if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM ||
1332 425 : ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_STEREO && st_ivas->hDecoderConfig->Opt_non_diegetic_pan ) )
1333 : {
1334 1255 : if ( ( error = ivas_render_config_open( &( st_ivas->hRenderConfig ) ) ) != IVAS_ERR_OK )
1335 : {
1336 0 : return error;
1337 : }
1338 :
1339 1255 : if ( ( error = ivas_render_config_init_from_rom( &st_ivas->hRenderConfig ) ) != IVAS_ERR_OK )
1340 : {
1341 0 : return error;
1342 : }
1343 : }
1344 :
1345 : #ifdef TMP_1342_WORKAROUND_DEC_FLUSH_BROKEN_IN_SR
1346 1678 : st_ivas->flushing = 0;
1347 : #endif
1348 :
1349 1678 : return error;
1350 : }
1351 :
1352 :
1353 : /*-------------------------------------------------------------------*
1354 : * ivas_init_decoder()
1355 : *
1356 : * Initialize IVAS decoder state structure
1357 : *-------------------------------------------------------------------*/
1358 :
1359 1671 : ivas_error ivas_init_decoder(
1360 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
1361 : )
1362 : {
1363 : int16_t i, n, k;
1364 : int16_t sce_id, cpe_id;
1365 : int16_t numCldfbAnalyses, numCldfbSyntheses;
1366 : int16_t granularity, n_channels_transport_jbm;
1367 : int16_t nchan_out_buff;
1368 : int32_t output_Fs, ivas_total_brate;
1369 : int32_t delay_ns;
1370 : AUDIO_CONFIG output_config;
1371 : DECODER_CONFIG_HANDLE hDecoderConfig;
1372 : ivas_error error;
1373 : int32_t ism_total_brate;
1374 :
1375 1671 : error = IVAS_ERR_OK;
1376 :
1377 1671 : output_Fs = st_ivas->hDecoderConfig->output_Fs;
1378 1671 : hDecoderConfig = st_ivas->hDecoderConfig;
1379 1671 : output_config = hDecoderConfig->output_config;
1380 1671 : ivas_total_brate = hDecoderConfig->ivas_total_brate;
1381 :
1382 1671 : hDecoderConfig->last_ivas_total_brate = ivas_total_brate;
1383 1671 : st_ivas->last_active_ivas_total_brate = ivas_total_brate;
1384 :
1385 : /*-----------------------------------------------------------------*
1386 : * Set number of output channels for EXTERNAL output config.
1387 : *-----------------------------------------------------------------*/
1388 :
1389 1671 : if ( output_config == IVAS_AUDIO_CONFIG_EXTERNAL )
1390 : {
1391 52 : if ( st_ivas->ivas_format == MONO_FORMAT )
1392 : {
1393 0 : hDecoderConfig->nchan_out = 1;
1394 : }
1395 52 : else if ( st_ivas->ivas_format == STEREO_FORMAT )
1396 : {
1397 2 : hDecoderConfig->nchan_out = CPE_CHANNELS;
1398 : }
1399 50 : else if ( st_ivas->ivas_format == MC_FORMAT )
1400 : {
1401 4 : hDecoderConfig->nchan_out = audioCfg2channels( st_ivas->transport_config );
1402 : }
1403 46 : else if ( st_ivas->ivas_format == SBA_ISM_FORMAT || st_ivas->ivas_format == SBA_FORMAT )
1404 : {
1405 10 : hDecoderConfig->nchan_out = audioCfg2channels( ivas_set_audio_config_from_sba_order( st_ivas->sba_order ) );
1406 10 : hDecoderConfig->nchan_out += st_ivas->nchan_ism;
1407 : }
1408 36 : else if ( st_ivas->ivas_format == MASA_ISM_FORMAT || st_ivas->ivas_format == MASA_FORMAT )
1409 : {
1410 21 : hDecoderConfig->nchan_out = st_ivas->nchan_transport + st_ivas->nchan_ism;
1411 : }
1412 15 : else if ( !( st_ivas->ism_mode == ISM_MODE_PARAM ) )
1413 : {
1414 13 : hDecoderConfig->nchan_out = st_ivas->nchan_transport;
1415 : }
1416 :
1417 52 : st_ivas->hOutSetup.nchan_out_woLFE = hDecoderConfig->nchan_out;
1418 : }
1419 :
1420 : /*-----------------------------------------------------------------*
1421 : * Set output and intern setup & renderer selection
1422 : *-----------------------------------------------------------------*/
1423 :
1424 1671 : st_ivas->intern_config = output_config;
1425 :
1426 1671 : if ( output_config == IVAS_AUDIO_CONFIG_EXTERNAL && st_ivas->ivas_format == MC_FORMAT )
1427 : {
1428 4 : ivas_output_init( &( st_ivas->hOutSetup ), st_ivas->transport_config );
1429 4 : st_ivas->intern_config = st_ivas->transport_config;
1430 : }
1431 1667 : else if ( output_config == IVAS_AUDIO_CONFIG_EXTERNAL && ( st_ivas->ivas_format == SBA_ISM_FORMAT || st_ivas->ivas_format == SBA_FORMAT ) )
1432 : {
1433 10 : st_ivas->intern_config = ivas_set_audio_config_from_sba_order( st_ivas->sba_order );
1434 10 : ivas_output_init( &( st_ivas->hOutSetup ), st_ivas->intern_config );
1435 : }
1436 : else
1437 : {
1438 1657 : ivas_output_init( &( st_ivas->hOutSetup ), output_config );
1439 : }
1440 :
1441 1671 : if ( st_ivas->ivas_format == SBA_ISM_FORMAT && output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR )
1442 : {
1443 4 : st_ivas->hOutSetup.ambisonics_order = SBA_HOA3_ORDER;
1444 4 : st_ivas->intern_config = IVAS_AUDIO_CONFIG_7_1_4;
1445 4 : st_ivas->hOutSetup.output_config = st_ivas->intern_config;
1446 4 : st_ivas->hOutSetup.nchan_out_woLFE = audioCfg2channels( st_ivas->intern_config );
1447 : }
1448 :
1449 : /* Only initialize transport setup if it is used */
1450 1671 : if ( st_ivas->transport_config != IVAS_AUDIO_CONFIG_INVALID )
1451 : {
1452 457 : ivas_output_init( &( st_ivas->hTransSetup ), st_ivas->transport_config );
1453 : }
1454 :
1455 1671 : if ( st_ivas->ivas_format == MC_FORMAT && st_ivas->mc_mode == MC_MODE_MCMASA )
1456 : {
1457 32 : ivas_mcmasa_setNumTransportChannels( &( st_ivas->nchan_transport ), &( st_ivas->element_mode_init ), ivas_total_brate );
1458 :
1459 32 : ivas_mcmasa_set_separate_channel_mode( &( st_ivas->hOutSetup.separateChannelEnabled ), &( st_ivas->hOutSetup.separateChannelIndex ), ivas_total_brate );
1460 : }
1461 :
1462 1671 : ivas_renderer_select( st_ivas );
1463 :
1464 1671 : if ( output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM )
1465 : {
1466 3 : if ( ( error = ivas_ls_custom_output_init( st_ivas ) ) != IVAS_ERR_OK )
1467 : {
1468 0 : return error;
1469 : }
1470 : }
1471 :
1472 1671 : ivas_output_init( &( st_ivas->hIntSetup ), st_ivas->intern_config );
1473 :
1474 1671 : if ( st_ivas->ivas_format == MC_FORMAT && st_ivas->mc_mode == MC_MODE_MCMASA )
1475 : {
1476 32 : ivas_mcmasa_set_separate_channel_mode( &( st_ivas->hIntSetup.separateChannelEnabled ), &( st_ivas->hIntSetup.separateChannelIndex ), ivas_total_brate );
1477 :
1478 32 : if ( st_ivas->hOutSetup.output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM && st_ivas->hOutSetup.separateChannelEnabled )
1479 : {
1480 0 : st_ivas->hLsSetupCustom->separate_ch_found = 0;
1481 0 : if ( st_ivas->hOutSetup.nchan_out_woLFE >= MCMASA_MIN_SPEAKERS_SEPARATE_CENTER )
1482 : {
1483 : /* check for a speaker at (0, 0) if minimum speaker count is available */
1484 0 : for ( i = 0; i < st_ivas->hOutSetup.nchan_out_woLFE; i++ )
1485 : {
1486 0 : if ( st_ivas->hOutSetup.ls_azimuth[i] == 0.0f && st_ivas->hOutSetup.ls_elevation[i] == 0.0f )
1487 : {
1488 0 : st_ivas->hIntSetup.separateChannelIndex = i;
1489 0 : st_ivas->hLsSetupCustom->separate_ch_found = 1;
1490 0 : break;
1491 : }
1492 : }
1493 : }
1494 : }
1495 : }
1496 :
1497 : /*--------------------------------------------------------------------------*
1498 : * Allocate and initialize HRTF Statistics handle, get default reverb values
1499 : *--------------------------------------------------------------------------*/
1500 :
1501 1671 : if ( st_ivas->hOutSetup.output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
1502 : {
1503 : /* Init HRTF statistics */
1504 51 : if ( ( error = ivas_HRTF_statistics_init( &st_ivas->hHrtfStatistics, output_Fs ) ) != IVAS_ERR_OK )
1505 : {
1506 0 : return error;
1507 : }
1508 :
1509 : /* Get default reverb values based on format, if custom values were not given */
1510 51 : if ( st_ivas->hDecoderConfig->Opt_RendConfigCustom == 0 )
1511 : {
1512 : IVAS_DefaultReverbSize defaultReverbSize;
1513 22 : switch ( st_ivas->hDecoderConfig->room_size )
1514 : {
1515 22 : case IVAS_ROOM_SIZE_AUTO:
1516 22 : switch ( st_ivas->ivas_format )
1517 : {
1518 1 : case ISM_FORMAT:
1519 1 : defaultReverbSize = DEFAULT_REVERB_LARGE;
1520 1 : break;
1521 5 : case SBA_FORMAT:
1522 5 : defaultReverbSize = DEFAULT_REVERB_SMALL;
1523 5 : break;
1524 3 : case MASA_FORMAT:
1525 3 : defaultReverbSize = DEFAULT_REVERB_SMALL;
1526 3 : break;
1527 6 : case MC_FORMAT:
1528 6 : defaultReverbSize = DEFAULT_REVERB_MEDIUM;
1529 6 : break;
1530 2 : case MASA_ISM_FORMAT:
1531 2 : defaultReverbSize = DEFAULT_REVERB_MEDIUM;
1532 2 : break;
1533 5 : case SBA_ISM_FORMAT:
1534 5 : defaultReverbSize = DEFAULT_REVERB_MEDIUM;
1535 5 : break;
1536 0 : default:
1537 0 : defaultReverbSize = DEFAULT_REVERB_LARGE;
1538 : }
1539 22 : break;
1540 0 : case IVAS_ROOM_SIZE_SMALL:
1541 0 : defaultReverbSize = DEFAULT_REVERB_SMALL;
1542 0 : break;
1543 0 : case IVAS_ROOM_SIZE_MEDIUM:
1544 0 : defaultReverbSize = DEFAULT_REVERB_MEDIUM;
1545 0 : break;
1546 0 : case IVAS_ROOM_SIZE_LARGE:
1547 : default:
1548 0 : defaultReverbSize = DEFAULT_REVERB_LARGE;
1549 0 : break;
1550 : }
1551 22 : if ( ( error = ivas_render_config_change_defaults( st_ivas->hRenderConfig, defaultReverbSize ) ) != IVAS_ERR_OK )
1552 : {
1553 0 : return error;
1554 : }
1555 : }
1556 : }
1557 :
1558 : /*-----------------------------------------------------------------*
1559 : * Allocate and initialize SCE/CPE and other handles
1560 : *-----------------------------------------------------------------*/
1561 :
1562 1671 : if ( st_ivas->ivas_format == MONO_FORMAT )
1563 : {
1564 5 : st_ivas->nSCE = 1; /* in mono, there is always only one SCE */
1565 5 : st_ivas->nCPE = 0;
1566 5 : st_ivas->nchan_transport = 1;
1567 5 : sce_id = 0;
1568 :
1569 5 : if ( ( error = create_sce_dec( st_ivas, sce_id, ivas_total_brate ) ) != IVAS_ERR_OK )
1570 : {
1571 0 : return error;
1572 : }
1573 :
1574 5 : reset_indices_dec( st_ivas->hSCE[sce_id]->hCoreCoder[0] );
1575 : }
1576 1666 : else if ( st_ivas->ivas_format == STEREO_FORMAT )
1577 : {
1578 70 : st_ivas->nchan_transport = CPE_CHANNELS;
1579 70 : st_ivas->intern_config = IVAS_AUDIO_CONFIG_STEREO;
1580 :
1581 70 : st_ivas->nSCE = 0;
1582 70 : st_ivas->nCPE = 1; /* in stereo, there is always only one CPE */
1583 70 : cpe_id = 0;
1584 :
1585 70 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ivas_total_brate ) ) != IVAS_ERR_OK )
1586 : {
1587 0 : return error;
1588 : }
1589 :
1590 210 : for ( n = 0; n < st_ivas->nchan_transport; n++ )
1591 : {
1592 140 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
1593 : }
1594 :
1595 : /* init EFAP for custom LS output and set hTransSetup */
1596 70 : if ( output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM )
1597 : {
1598 0 : if ( ( error = efap_init_data( &( st_ivas->hEFAPdata ), st_ivas->hOutSetup.ls_azimuth, st_ivas->hOutSetup.ls_elevation, st_ivas->hOutSetup.nchan_out_woLFE, EFAP_MODE_EFAP ) ) != IVAS_ERR_OK )
1599 : {
1600 0 : return error;
1601 : }
1602 :
1603 0 : ivas_output_init( &( st_ivas->hTransSetup ), IVAS_AUDIO_CONFIG_STEREO );
1604 : }
1605 : }
1606 1596 : else if ( st_ivas->ivas_format == ISM_FORMAT )
1607 : {
1608 : int32_t element_brate_tmp[MAX_NUM_OBJECTS];
1609 :
1610 111 : st_ivas->nSCE = st_ivas->nchan_transport; /* "st_ivas->nchan_transport" is known from ivas_dec_setup */
1611 111 : st_ivas->nCPE = 0;
1612 111 : st_ivas->ism_extmeta_active = -1;
1613 111 : st_ivas->ism_extmeta_cnt = 0;
1614 :
1615 111 : if ( st_ivas->ism_mode == ISM_MODE_PARAM )
1616 : {
1617 18 : st_ivas->nchan_transport = MAX_PARAM_ISM_WAVE;
1618 18 : st_ivas->nSCE = MAX_PARAM_ISM_WAVE;
1619 :
1620 18 : if ( ( error = ivas_param_ism_dec_open( st_ivas ) ) != IVAS_ERR_OK )
1621 : {
1622 0 : return error;
1623 : }
1624 : }
1625 :
1626 111 : if ( ( error = ivas_ism_metadata_dec_create( st_ivas, st_ivas->nchan_ism, element_brate_tmp ) ) != IVAS_ERR_OK )
1627 : {
1628 0 : return error;
1629 : }
1630 :
1631 444 : for ( sce_id = 0; sce_id < st_ivas->nSCE; sce_id++ )
1632 : {
1633 333 : if ( ( error = create_sce_dec( st_ivas, sce_id, element_brate_tmp[sce_id] ) ) != IVAS_ERR_OK )
1634 : {
1635 0 : return error;
1636 : }
1637 :
1638 333 : reset_indices_dec( st_ivas->hSCE[sce_id]->hCoreCoder[0] );
1639 :
1640 333 : st_ivas->hSCE[sce_id]->hCoreCoder[0]->is_ism_format = 1;
1641 : }
1642 :
1643 111 : st_ivas->hISMDTX.sce_id_dtx = 0;
1644 :
1645 111 : if ( st_ivas->ism_mode == ISM_MODE_PARAM )
1646 : {
1647 18 : st_ivas->hSCE[0]->hCoreCoder[0]->hFdCngDec->hFdCngCom->seed2 = st_ivas->hSCE[0]->hCoreCoder[0]->hFdCngDec->hFdCngCom->seed3;
1648 :
1649 18 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC_ROOM )
1650 : {
1651 : /* reusing OMASA function for allocating and initializing MASA_ISM rendering handle (even though not in OMASA) */
1652 9 : if ( ( error = ivas_omasa_data_open( st_ivas ) ) != IVAS_ERR_OK )
1653 : {
1654 0 : return error;
1655 : }
1656 : }
1657 : }
1658 93 : else if ( st_ivas->ism_mode == ISM_MODE_DISC )
1659 : {
1660 390 : for ( sce_id = 0; sce_id < st_ivas->nSCE; ++sce_id )
1661 : {
1662 297 : st_ivas->hSCE[sce_id]->hCoreCoder[0]->hFdCngDec->hFdCngCom->seed2 = 2 + sce_id;
1663 : }
1664 : }
1665 : }
1666 1485 : else if ( st_ivas->ivas_format == SBA_FORMAT )
1667 : {
1668 437 : if ( ( error = ivas_qmetadata_open( &( st_ivas->hQMetaData ) ) ) != IVAS_ERR_OK )
1669 : {
1670 0 : return error;
1671 : }
1672 :
1673 437 : if ( ( error = ivas_spar_dec_open( st_ivas, 0 ) ) != IVAS_ERR_OK )
1674 : {
1675 0 : return error;
1676 : }
1677 :
1678 437 : if ( ( error = ivas_dirac_sba_config( st_ivas->hQMetaData, &st_ivas->element_mode_init, ivas_total_brate, st_ivas->sba_analysis_order,
1679 437 : ivas_get_hodirac_flag( ivas_total_brate, st_ivas->sba_analysis_order ) ? IVAS_MAX_NUM_BANDS : ( IVAS_MAX_NUM_BANDS - SPAR_DIRAC_SPLIT_START_BAND ),
1680 : st_ivas->ivas_format ) ) != IVAS_ERR_OK )
1681 : {
1682 0 : return error;
1683 : }
1684 :
1685 437 : if ( output_config != IVAS_AUDIO_CONFIG_FOA && output_config != IVAS_AUDIO_CONFIG_STEREO && output_config != IVAS_AUDIO_CONFIG_MONO && !( output_config == IVAS_AUDIO_CONFIG_EXTERNAL && st_ivas->intern_config == IVAS_AUDIO_CONFIG_FOA ) )
1686 : {
1687 271 : if ( ( error = ivas_dirac_dec_config( st_ivas, DIRAC_OPEN ) ) != IVAS_ERR_OK )
1688 : {
1689 0 : return error;
1690 : }
1691 :
1692 271 : st_ivas->hSpar->enc_param_start_band = st_ivas->hDirAC->hConfig->enc_param_start_band;
1693 : }
1694 : else
1695 : {
1696 : int16_t band_grouping[IVAS_MAX_NUM_BANDS + 1];
1697 :
1698 166 : st_ivas->hSpar->enc_param_start_band = min( IVAS_MAX_NUM_BANDS, SPAR_DIRAC_SPLIT_START_BAND );
1699 166 : if ( ivas_get_hodirac_flag( ivas_total_brate, st_ivas->sba_analysis_order ) )
1700 : {
1701 1 : st_ivas->hSpar->enc_param_start_band = 0;
1702 :
1703 1 : set_c( (int8_t *) st_ivas->hQMetaData->twoDirBands, (int8_t) 1, st_ivas->hQMetaData->q_direction[0].cfg.nbands );
1704 1 : st_ivas->hQMetaData->numTwoDirBands = (uint8_t) st_ivas->hQMetaData->q_direction[0].cfg.nbands;
1705 : }
1706 :
1707 166 : ivas_dirac_config_bands( band_grouping, IVAS_MAX_NUM_BANDS, (int16_t) ( output_Fs * INV_CLDFB_BANDWIDTH + 0.5f ),
1708 166 : st_ivas->hSpar->dirac_to_spar_md_bands, st_ivas->hQMetaData->useLowerBandRes, st_ivas->hSpar->enc_param_start_band, 0, 1 );
1709 : }
1710 437 : st_ivas->sba_dirac_stereo_flag = ivas_get_sba_dirac_stereo_flag( st_ivas );
1711 :
1712 537 : for ( sce_id = 0; sce_id < st_ivas->nSCE; sce_id++ )
1713 : {
1714 100 : if ( ( error = create_sce_dec( st_ivas, sce_id, ivas_total_brate / st_ivas->nchan_transport ) ) != IVAS_ERR_OK )
1715 : {
1716 0 : return error;
1717 : }
1718 :
1719 100 : reset_indices_dec( st_ivas->hSCE[sce_id]->hCoreCoder[0] );
1720 : }
1721 :
1722 980 : for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ )
1723 : {
1724 543 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ( ivas_total_brate / st_ivas->nchan_transport ) * CPE_CHANNELS ) ) != IVAS_ERR_OK )
1725 : {
1726 0 : return error;
1727 : }
1728 :
1729 1629 : for ( n = 0; n < CPE_CHANNELS; n++ )
1730 : {
1731 1086 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
1732 : }
1733 : }
1734 :
1735 : /* create CPE element for DFT Stereo like upmix */
1736 437 : if ( st_ivas->sba_dirac_stereo_flag && st_ivas->nCPE == 0 )
1737 : {
1738 5 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ivas_total_brate / ( st_ivas->nSCE + st_ivas->nCPE ) ) ) != IVAS_ERR_OK )
1739 : {
1740 0 : return error;
1741 : }
1742 :
1743 5 : st_ivas->hCPE[0]->hCoreCoder[0] = st_ivas->hSCE[0]->hCoreCoder[0]; /* don't allocate unnecessary core coder, simply point to core coder of SCE element */
1744 5 : st_ivas->hCPE[0]->hCoreCoder[1] = NULL;
1745 : }
1746 :
1747 437 : if ( st_ivas->nCPE > 1 )
1748 : {
1749 206 : if ( ( error = create_mct_dec( st_ivas ) ) != IVAS_ERR_OK )
1750 : {
1751 0 : return error;
1752 : }
1753 : }
1754 :
1755 : /* set CNA/CNG flags */
1756 437 : ivas_sba_set_cna_cng_flag( st_ivas );
1757 : }
1758 1048 : else if ( st_ivas->ivas_format == MASA_FORMAT )
1759 : {
1760 : /* if we start in ISM_MODE_NONE in MASA_ISM, that appears as normal MASA, but we may change to a mode with ISMs */
1761 289 : st_ivas->ism_extmeta_active = -1;
1762 289 : st_ivas->ism_extmeta_cnt = 0;
1763 289 : if ( ( error = ivas_qmetadata_open( &( st_ivas->hQMetaData ) ) ) != IVAS_ERR_OK )
1764 : {
1765 0 : return error;
1766 : }
1767 :
1768 289 : if ( ( error = ivas_masa_dec_open( st_ivas ) ) != IVAS_ERR_OK )
1769 : {
1770 0 : return error;
1771 : }
1772 :
1773 289 : if ( st_ivas->renderer_type == RENDERER_DIRAC || st_ivas->renderer_type == RENDERER_STEREO_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC_ROOM )
1774 : {
1775 268 : if ( ( error = ivas_dirac_dec_config( st_ivas, DIRAC_OPEN ) ) != IVAS_ERR_OK )
1776 : {
1777 0 : return error;
1778 : }
1779 : }
1780 :
1781 388 : for ( sce_id = 0; sce_id < st_ivas->nSCE; sce_id++ )
1782 : {
1783 99 : if ( ( error = create_sce_dec( st_ivas, sce_id, ivas_total_brate / st_ivas->nchan_transport ) ) != IVAS_ERR_OK )
1784 : {
1785 0 : return error;
1786 : }
1787 :
1788 99 : reset_indices_dec( st_ivas->hSCE[sce_id]->hCoreCoder[0] );
1789 : }
1790 :
1791 479 : for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ )
1792 : {
1793 190 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ( ivas_total_brate / st_ivas->nchan_transport ) * CPE_CHANNELS ) ) != IVAS_ERR_OK )
1794 : {
1795 0 : return error;
1796 : }
1797 :
1798 570 : for ( n = 0; n < CPE_CHANNELS; n++ )
1799 : {
1800 380 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
1801 : }
1802 : }
1803 :
1804 : /* set CNA/CNG flags */
1805 289 : ivas_sba_set_cna_cng_flag( st_ivas );
1806 : }
1807 759 : else if ( st_ivas->ivas_format == SBA_ISM_FORMAT )
1808 : {
1809 : int32_t temp_brate[MAX_SCE];
1810 174 : st_ivas->ism_extmeta_active = -1;
1811 174 : st_ivas->ism_extmeta_cnt = 0;
1812 :
1813 174 : st_ivas->sba_dirac_stereo_flag = ivas_get_sba_dirac_stereo_flag( st_ivas );
1814 :
1815 174 : if ( ( error = ivas_qmetadata_open( &( st_ivas->hQMetaData ) ) ) != IVAS_ERR_OK )
1816 : {
1817 0 : return error;
1818 : }
1819 :
1820 174 : if ( ( error = ivas_spar_dec_open( st_ivas, 0 ) ) != IVAS_ERR_OK )
1821 : {
1822 0 : return error;
1823 : }
1824 :
1825 174 : if ( ( error = ivas_dirac_sba_config( st_ivas->hQMetaData, &st_ivas->element_mode_init, ivas_total_brate, st_ivas->sba_analysis_order,
1826 174 : ivas_get_hodirac_flag( ivas_total_brate, st_ivas->sba_analysis_order ) ? IVAS_MAX_NUM_BANDS : ( IVAS_MAX_NUM_BANDS - SPAR_DIRAC_SPLIT_START_BAND ),
1827 : st_ivas->ivas_format ) ) != IVAS_ERR_OK )
1828 : {
1829 0 : return error;
1830 : }
1831 :
1832 174 : if ( output_config != IVAS_AUDIO_CONFIG_FOA && output_config != IVAS_AUDIO_CONFIG_STEREO && output_config != IVAS_AUDIO_CONFIG_MONO )
1833 : {
1834 167 : if ( ( error = ivas_dirac_dec_config( st_ivas, DIRAC_OPEN ) ) != IVAS_ERR_OK )
1835 : {
1836 0 : return error;
1837 : }
1838 :
1839 167 : st_ivas->hSpar->enc_param_start_band = st_ivas->hDirAC->hConfig->enc_param_start_band;
1840 : }
1841 : else
1842 : {
1843 : int16_t band_grouping[IVAS_MAX_NUM_BANDS + 1];
1844 :
1845 7 : st_ivas->hSpar->enc_param_start_band = min( IVAS_MAX_NUM_BANDS, SPAR_DIRAC_SPLIT_START_BAND );
1846 7 : if ( ivas_get_hodirac_flag( ivas_total_brate, st_ivas->sba_analysis_order ) )
1847 : {
1848 1 : st_ivas->hSpar->enc_param_start_band = 0;
1849 :
1850 1 : set_c( (int8_t *) st_ivas->hQMetaData->twoDirBands, (int8_t) 1, st_ivas->hQMetaData->q_direction[0].cfg.nbands );
1851 1 : st_ivas->hQMetaData->numTwoDirBands = (uint8_t) st_ivas->hQMetaData->q_direction[0].cfg.nbands;
1852 : }
1853 :
1854 7 : ivas_dirac_config_bands( band_grouping, IVAS_MAX_NUM_BANDS, (int16_t) ( output_Fs * INV_CLDFB_BANDWIDTH + 0.5f ),
1855 7 : st_ivas->hSpar->dirac_to_spar_md_bands, st_ivas->hQMetaData->useLowerBandRes, st_ivas->hSpar->enc_param_start_band, 0, 1 );
1856 : }
1857 :
1858 187 : for ( sce_id = 0; sce_id < st_ivas->nSCE; sce_id++ )
1859 : {
1860 13 : if ( ( error = create_sce_dec( st_ivas, sce_id, ivas_total_brate / st_ivas->nchan_transport ) ) != IVAS_ERR_OK )
1861 : {
1862 0 : return error;
1863 : }
1864 :
1865 13 : reset_indices_dec( st_ivas->hSCE[sce_id]->hCoreCoder[0] );
1866 : }
1867 :
1868 174 : if ( st_ivas->ism_mode == ISM_SBA_MODE_DISC )
1869 : {
1870 : {
1871 : int16_t n_all;
1872 :
1873 155 : n_all = st_ivas->nchan_transport + st_ivas->nchan_ism;
1874 155 : st_ivas->nCPE = ( n_all + 1 ) >> 1;
1875 : }
1876 155 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
1877 : }
1878 :
1879 724 : for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ )
1880 : {
1881 550 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ( ivas_total_brate / st_ivas->nchan_transport ) * CPE_CHANNELS ) ) != IVAS_ERR_OK )
1882 : {
1883 0 : return error;
1884 : }
1885 :
1886 1650 : for ( n = 0; n < CPE_CHANNELS; n++ )
1887 : {
1888 1100 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
1889 : }
1890 : }
1891 :
1892 : /* create CPE element for DFT Stereo like upmix */
1893 174 : if ( st_ivas->sba_dirac_stereo_flag && st_ivas->nCPE == 0 )
1894 : {
1895 1 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ivas_total_brate / ( st_ivas->nSCE + st_ivas->nCPE ) ) ) != IVAS_ERR_OK )
1896 : {
1897 0 : return error;
1898 : }
1899 :
1900 1 : st_ivas->hCPE[0]->hCoreCoder[0] = st_ivas->hSCE[0]->hCoreCoder[0]; /* don't allocate unnecessary core coder, simply point to core coder of SCE element */
1901 1 : st_ivas->hCPE[0]->hCoreCoder[1] = NULL;
1902 : }
1903 :
1904 174 : if ( st_ivas->nCPE > 1 )
1905 : {
1906 156 : if ( ( error = create_mct_dec( st_ivas ) ) != IVAS_ERR_OK )
1907 : {
1908 0 : return error;
1909 : }
1910 : }
1911 :
1912 174 : if ( st_ivas->ism_mode == ISM_SBA_MODE_DISC )
1913 : {
1914 155 : if ( ( error = ivas_ism_metadata_dec_create( st_ivas, st_ivas->nchan_ism, temp_brate ) ) != IVAS_ERR_OK )
1915 : {
1916 0 : return error;
1917 : }
1918 :
1919 155 : if ( ( error = ivas_osba_data_open( st_ivas ) ) != IVAS_ERR_OK )
1920 : {
1921 0 : return error;
1922 : }
1923 : }
1924 :
1925 : /* set CNA/CNG flags */
1926 174 : ivas_sba_set_cna_cng_flag( st_ivas );
1927 : }
1928 585 : else if ( st_ivas->ivas_format == MASA_ISM_FORMAT )
1929 : {
1930 244 : st_ivas->ism_extmeta_active = -1;
1931 244 : st_ivas->ism_extmeta_cnt = 0;
1932 :
1933 244 : if ( ( error = ivas_qmetadata_open( &( st_ivas->hQMetaData ) ) ) != IVAS_ERR_OK )
1934 : {
1935 0 : return error;
1936 : }
1937 :
1938 244 : k = 0;
1939 244 : ism_total_brate = 0;
1940 2479 : while ( k < SIZE_IVAS_BRATE_TBL && ivas_total_brate != ivas_brate_tbl[k] )
1941 : {
1942 2235 : k++;
1943 : }
1944 :
1945 244 : if ( st_ivas->ism_mode == ISM_MASA_MODE_MASA_ONE_OBJ || st_ivas->ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ )
1946 : {
1947 : /* one separated object */
1948 88 : st_ivas->nSCE = 1;
1949 :
1950 88 : ism_total_brate = sep_object_brate[k - 2][0];
1951 88 : if ( ( error = create_sce_dec( st_ivas, 0, ism_total_brate ) ) != IVAS_ERR_OK )
1952 : {
1953 0 : return error;
1954 : }
1955 :
1956 88 : reset_indices_dec( st_ivas->hSCE[0]->hCoreCoder[0] );
1957 :
1958 88 : if ( ( error = ivas_ism_metadata_dec_create( st_ivas, st_ivas->nchan_ism, NULL ) ) != IVAS_ERR_OK )
1959 : {
1960 0 : return error;
1961 : }
1962 : }
1963 156 : else if ( st_ivas->ism_mode == ISM_MASA_MODE_DISC )
1964 : {
1965 : int32_t temp_brate[MAX_SCE];
1966 156 : st_ivas->nSCE = st_ivas->nchan_ism; /* number of objects */
1967 :
1968 452 : for ( sce_id = 0; sce_id < st_ivas->nSCE; sce_id++ )
1969 : {
1970 296 : temp_brate[sce_id] = sep_object_brate[k - 2][st_ivas->nSCE - 1];
1971 296 : ism_total_brate += temp_brate[sce_id];
1972 :
1973 296 : if ( ( error = create_sce_dec( st_ivas, sce_id, temp_brate[sce_id] ) ) != IVAS_ERR_OK )
1974 : {
1975 0 : return error;
1976 : }
1977 :
1978 296 : reset_indices_dec( st_ivas->hSCE[sce_id]->hCoreCoder[0] );
1979 : }
1980 :
1981 156 : if ( ( error = ivas_ism_metadata_dec_create( st_ivas, st_ivas->nchan_ism, temp_brate ) ) != IVAS_ERR_OK )
1982 : {
1983 0 : return error;
1984 : }
1985 : }
1986 :
1987 244 : if ( ( error = ivas_masa_dec_open( st_ivas ) ) != IVAS_ERR_OK )
1988 : {
1989 0 : return error;
1990 : }
1991 :
1992 244 : if ( ( error = ivas_omasa_data_open( st_ivas ) ) != IVAS_ERR_OK )
1993 : {
1994 0 : return error;
1995 : }
1996 :
1997 244 : if ( st_ivas->renderer_type == RENDERER_DIRAC || st_ivas->renderer_type == RENDERER_STEREO_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC_ROOM )
1998 : {
1999 235 : if ( ( error = ivas_dirac_dec_config( st_ivas, DIRAC_OPEN ) ) != IVAS_ERR_OK )
2000 : {
2001 0 : return error;
2002 : }
2003 : }
2004 :
2005 244 : if ( ( error = create_cpe_dec( st_ivas, 0, ivas_total_brate - ism_total_brate ) ) != IVAS_ERR_OK )
2006 : {
2007 0 : return error;
2008 : }
2009 :
2010 732 : for ( n = 0; n < CPE_CHANNELS; n++ )
2011 : {
2012 488 : reset_indices_dec( st_ivas->hCPE[0]->hCoreCoder[n] );
2013 : }
2014 : }
2015 341 : else if ( st_ivas->ivas_format == MC_FORMAT )
2016 : {
2017 341 : if ( st_ivas->mc_mode == MC_MODE_MCT )
2018 : {
2019 : /* init EFAP for custom LS setup */
2020 226 : if ( output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM )
2021 : {
2022 1 : if ( ( error = efap_init_data( &( st_ivas->hEFAPdata ), st_ivas->hLsSetupCustom->ls_azimuth, st_ivas->hLsSetupCustom->ls_elevation, st_ivas->hLsSetupCustom->num_spk, EFAP_MODE_EFAP ) ) != IVAS_ERR_OK )
2023 : {
2024 0 : return error;
2025 : }
2026 : }
2027 :
2028 226 : st_ivas->nchan_transport = ivas_mc_ls_setup_get_num_channels( ivas_mc_map_output_config_to_mc_ls_setup( st_ivas->transport_config ) );
2029 226 : st_ivas->nSCE = 0;
2030 226 : st_ivas->nCPE = st_ivas->nchan_transport / CPE_CHANNELS;
2031 :
2032 226 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
2033 :
2034 1049 : for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ )
2035 : {
2036 823 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ( ivas_total_brate / ( st_ivas->nchan_transport - 1 ) * CPE_CHANNELS ) ) ) != IVAS_ERR_OK )
2037 : {
2038 0 : return error;
2039 : }
2040 :
2041 2469 : for ( n = 0; n < CPE_CHANNELS; n++ )
2042 : {
2043 1646 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
2044 : }
2045 : }
2046 :
2047 226 : if ( ( error = create_mct_dec( st_ivas ) ) != IVAS_ERR_OK )
2048 : {
2049 0 : return error;
2050 : }
2051 : }
2052 115 : else if ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX )
2053 : {
2054 : /* init EFAP for custom LS setup */
2055 39 : if ( output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM )
2056 : {
2057 0 : if ( ( error = efap_init_data( &( st_ivas->hEFAPdata ), st_ivas->hLsSetupCustom->ls_azimuth, st_ivas->hLsSetupCustom->ls_elevation, st_ivas->hLsSetupCustom->num_spk, EFAP_MODE_EFAP ) ) != IVAS_ERR_OK )
2058 : {
2059 0 : return error;
2060 : }
2061 : }
2062 :
2063 39 : st_ivas->nSCE = 0;
2064 39 : st_ivas->nCPE = MC_PARAMUPMIX_MAX_TRANSPORT_CHANS / CPE_CHANNELS;
2065 39 : st_ivas->nchan_transport = MC_PARAMUPMIX_MAX_TRANSPORT_CHANS;
2066 :
2067 39 : if ( ( error = ivas_mc_paramupmix_dec_open( st_ivas ) ) != IVAS_ERR_OK )
2068 : {
2069 0 : return error;
2070 : }
2071 :
2072 39 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
2073 :
2074 195 : for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ )
2075 : {
2076 156 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ( ivas_total_brate / ( st_ivas->nchan_transport - 1 ) * CPE_CHANNELS ) ) ) != IVAS_ERR_OK )
2077 : {
2078 0 : return error;
2079 : }
2080 :
2081 468 : for ( n = 0; n < CPE_CHANNELS; n++ )
2082 : {
2083 312 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
2084 : }
2085 : }
2086 :
2087 39 : if ( ( error = create_mct_dec( st_ivas ) ) != IVAS_ERR_OK )
2088 : {
2089 0 : return error;
2090 : }
2091 : }
2092 76 : else if ( st_ivas->mc_mode == MC_MODE_PARAMMC )
2093 : {
2094 : /* init EFAP for custom LS setup */
2095 44 : if ( output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM )
2096 : {
2097 0 : if ( ( error = efap_init_data( &( st_ivas->hEFAPdata ), st_ivas->hLsSetupCustom->ls_azimuth, st_ivas->hLsSetupCustom->ls_elevation, st_ivas->hLsSetupCustom->num_spk, EFAP_MODE_EFAP ) ) != IVAS_ERR_OK )
2098 : {
2099 0 : return error;
2100 : }
2101 : }
2102 :
2103 44 : if ( ( error = ivas_param_mc_dec_open( st_ivas ) ) != IVAS_ERR_OK )
2104 : {
2105 0 : return error;
2106 : }
2107 :
2108 122 : for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ )
2109 : {
2110 78 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ivas_total_brate / ( st_ivas->nSCE + st_ivas->nCPE ) ) ) != IVAS_ERR_OK )
2111 : {
2112 0 : return error;
2113 : }
2114 :
2115 234 : for ( n = 0; n < CPE_CHANNELS; n++ )
2116 : {
2117 156 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
2118 : }
2119 : }
2120 :
2121 44 : if ( st_ivas->nCPE > 1 )
2122 : {
2123 34 : if ( ( error = create_mct_dec( st_ivas ) ) != IVAS_ERR_OK )
2124 : {
2125 0 : return error;
2126 : }
2127 : }
2128 : }
2129 32 : else if ( st_ivas->mc_mode == MC_MODE_MCMASA )
2130 : {
2131 : int32_t brate_sce, brate_cpe;
2132 :
2133 32 : ivas_mcmasa_setNumTransportChannels( &( st_ivas->nchan_transport ), &( st_ivas->element_mode_init ), ivas_total_brate );
2134 :
2135 32 : if ( ( error = ivas_qmetadata_open( &( st_ivas->hQMetaData ) ) ) != IVAS_ERR_OK )
2136 : {
2137 0 : return error;
2138 : }
2139 :
2140 32 : if ( ( error = ivas_masa_dec_open( st_ivas ) ) != IVAS_ERR_OK )
2141 : {
2142 0 : return error;
2143 : }
2144 :
2145 32 : st_ivas->sba_dirac_stereo_flag = ivas_get_sba_dirac_stereo_flag( st_ivas );
2146 :
2147 32 : if ( st_ivas->renderer_type != RENDERER_DISABLE && st_ivas->renderer_type != RENDERER_MCMASA_MONO_STEREO )
2148 : {
2149 25 : if ( ( error = ivas_dirac_dec_config( st_ivas, DIRAC_OPEN ) ) != IVAS_ERR_OK )
2150 : {
2151 0 : return error;
2152 : }
2153 : }
2154 :
2155 32 : if ( st_ivas->hOutSetup.output_config == IVAS_AUDIO_CONFIG_LS_CUSTOM && st_ivas->hOutSetup.separateChannelEnabled && !st_ivas->hLsSetupCustom->separate_ch_found )
2156 : {
2157 : /* If no speaker matching the separated channel, compute panning gains for the separated channel. */
2158 0 : if ( st_ivas->hVBAPdata == NULL )
2159 : {
2160 : /* Distribute signal to all channels if VBAP is not properly initialized. */
2161 0 : set_f( st_ivas->hLsSetupCustom->separate_ch_gains, inv_sqrt( st_ivas->hLsSetupCustom->num_spk ), st_ivas->hLsSetupCustom->num_spk );
2162 : }
2163 : else
2164 : {
2165 0 : vbap_determine_gains( st_ivas->hVBAPdata, st_ivas->hLsSetupCustom->separate_ch_gains, 0, 0, 0 );
2166 : }
2167 : }
2168 :
2169 32 : ivas_mcmasa_split_brate( st_ivas->hOutSetup.separateChannelEnabled, ivas_total_brate, st_ivas->nSCE, st_ivas->nCPE, &brate_sce, &brate_cpe );
2170 :
2171 62 : for ( sce_id = 0; sce_id < st_ivas->nSCE; sce_id++ )
2172 : {
2173 30 : if ( ( error = create_sce_dec( st_ivas, sce_id, brate_sce ) ) != IVAS_ERR_OK )
2174 : {
2175 0 : return error;
2176 : }
2177 :
2178 30 : reset_indices_dec( st_ivas->hSCE[sce_id]->hCoreCoder[0] );
2179 : }
2180 :
2181 37 : for ( cpe_id = 0; cpe_id < st_ivas->nCPE; cpe_id++ )
2182 : {
2183 5 : st_ivas->element_mode_init = IVAS_CPE_MDCT; /* element_mode_init was IVAS_SCE for SCE initialization */
2184 :
2185 5 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, brate_cpe ) ) != IVAS_ERR_OK )
2186 : {
2187 0 : return error;
2188 : }
2189 :
2190 15 : for ( n = 0; n < CPE_CHANNELS; n++ )
2191 : {
2192 10 : reset_indices_dec( st_ivas->hCPE[cpe_id]->hCoreCoder[n] );
2193 : }
2194 : }
2195 :
2196 : /* create CPE element for DFT Stereo like upmix */
2197 32 : if ( st_ivas->sba_dirac_stereo_flag )
2198 : {
2199 3 : if ( ( error = create_cpe_dec( st_ivas, cpe_id, ivas_total_brate / ( st_ivas->nSCE + st_ivas->nCPE ) ) ) != IVAS_ERR_OK )
2200 : {
2201 0 : return error;
2202 : }
2203 :
2204 3 : st_ivas->hCPE[0]->hCoreCoder[0] = st_ivas->hSCE[0]->hCoreCoder[0]; /* don't allocate unnecessary core coder, simply point to core coder of SCE element */
2205 3 : st_ivas->hCPE[0]->hCoreCoder[1] = NULL;
2206 : }
2207 :
2208 : /* set CNA/CNG flags */
2209 32 : if ( st_ivas->nchan_transport == 1 && ( ( st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC_ROOM ) ) )
2210 : {
2211 15 : st_ivas->hSCE[0]->hCoreCoder[0]->cna_dirac_flag = 1;
2212 15 : st_ivas->hSCE[0]->hCoreCoder[0]->cng_sba_flag = 1;
2213 : }
2214 : }
2215 : }
2216 : #ifdef DEBUGGING
2217 : else
2218 : {
2219 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: Invalid IVAS format. Exiting,\n" );
2220 : }
2221 : #endif
2222 :
2223 :
2224 : /*-----------------------------------------------------------------*
2225 : * Allocate and initialize HP20 filter memories
2226 : *-----------------------------------------------------------------*/
2227 :
2228 : /* set number of output channels used for synthesis/decoding */
2229 1671 : n = getNumChanSynthesis( st_ivas );
2230 :
2231 1671 : if ( n > 0 )
2232 : {
2233 1671 : if ( ( st_ivas->mem_hp20_out = (float **) malloc( n * sizeof( float * ) ) ) == NULL )
2234 : {
2235 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HP20 filter memory\n" ) );
2236 : }
2237 : }
2238 : else
2239 : {
2240 0 : st_ivas->mem_hp20_out = NULL;
2241 : }
2242 :
2243 7805 : for ( i = 0; i < n; i++ )
2244 : {
2245 6134 : if ( ( st_ivas->mem_hp20_out[i] = (float *) malloc( L_HP20_MEM * sizeof( float ) ) ) == NULL )
2246 : {
2247 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HP20 filter memory\n" ) );
2248 : }
2249 :
2250 6134 : set_f( st_ivas->mem_hp20_out[i], 0.0f, L_HP20_MEM );
2251 : }
2252 :
2253 : /*-------------------------------------------------------------------*
2254 : * Allocate and initialize rendering handles
2255 : *--------------------------------------------------------------------*/
2256 :
2257 1671 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
2258 : {
2259 :
2260 366 : if ( ( error = ivas_binRenderer_open( st_ivas ) ) != IVAS_ERR_OK )
2261 : {
2262 0 : return error;
2263 : }
2264 : }
2265 :
2266 : /* ParamISM is handled separately from other common config */
2267 1305 : else if ( st_ivas->ivas_format == ISM_FORMAT && st_ivas->ism_mode == ISM_MODE_PARAM && ( st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC_ROOM || st_ivas->renderer_type == RENDERER_STEREO_PARAMETRIC ) )
2268 : {
2269 9 : if ( st_ivas->renderer_type != RENDERER_STEREO_PARAMETRIC )
2270 : {
2271 9 : if ( ( error = ivas_dirac_dec_binaural_copy_hrtfs( &st_ivas->hHrtfParambin ) ) != IVAS_ERR_OK )
2272 : {
2273 0 : return error;
2274 : }
2275 : }
2276 :
2277 9 : if ( ( error = ivas_dirac_dec_init_binaural_data( st_ivas, &( st_ivas->hHrtfParambin ) ) ) != IVAS_ERR_OK )
2278 : {
2279 0 : return error;
2280 : }
2281 : }
2282 1296 : else if ( st_ivas->renderer_type == RENDERER_BINAURAL_OBJECTS_TD )
2283 : {
2284 216 : if ( ( error = ivas_td_binaural_open( st_ivas ) ) != IVAS_ERR_OK )
2285 : {
2286 0 : return error;
2287 : }
2288 :
2289 216 : if ( st_ivas->hOutSetup.output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
2290 : {
2291 3 : if ( ( error = ivas_reverb_open( &st_ivas->hReverb, st_ivas->hHrtfStatistics, st_ivas->hRenderConfig, output_Fs ) ) != IVAS_ERR_OK )
2292 : {
2293 0 : return error;
2294 : }
2295 : }
2296 : }
2297 1080 : else if ( st_ivas->renderer_type == RENDERER_MC )
2298 : {
2299 6 : if ( ( error = ivas_ls_setup_conversion_open( st_ivas ) ) != IVAS_ERR_OK )
2300 : {
2301 0 : return error;
2302 : }
2303 : }
2304 1074 : else if ( st_ivas->renderer_type == RENDERER_MONO_DOWNMIX )
2305 : {
2306 9 : if ( ( error = ivas_mono_dmx_renderer_open( st_ivas ) ) != IVAS_ERR_OK )
2307 : {
2308 0 : return error;
2309 : }
2310 : }
2311 1065 : else if ( st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV || st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV_ROOM )
2312 : {
2313 66 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV_ROOM && st_ivas->ivas_format == MC_FORMAT && ( st_ivas->hDecoderConfig->Opt_Headrotation || st_ivas->hDecoderConfig->Opt_ExternalOrientation || st_ivas->hCombinedOrientationData ) )
2314 : {
2315 4 : if ( ( error = efap_init_data( &( st_ivas->hEFAPdata ), st_ivas->hIntSetup.ls_azimuth, st_ivas->hIntSetup.ls_elevation, st_ivas->hIntSetup.nchan_out_woLFE, EFAP_MODE_EFAP ) ) != IVAS_ERR_OK )
2316 : {
2317 0 : return error;
2318 : }
2319 : }
2320 :
2321 66 : if ( ( error = ivas_rend_openCrend( &( st_ivas->hCrendWrapper ), st_ivas->intern_config, output_config,
2322 66 : st_ivas->hRenderConfig, st_ivas->hHrtfCrend, st_ivas->hHrtfStatistics, output_Fs, 0, ( st_ivas->hSplitBinRend == NULL ) ? 1 : st_ivas->hSplitBinRend->splitrend.multiBinPoseData.num_poses ) ) != IVAS_ERR_OK )
2323 : {
2324 0 : return error;
2325 : }
2326 :
2327 66 : st_ivas->binaural_latency_ns = st_ivas->hCrendWrapper->binaural_latency_ns;
2328 : }
2329 :
2330 1671 : if ( st_ivas->ivas_format == MASA_ISM_FORMAT )
2331 : {
2332 244 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC && st_ivas->ism_mode == ISM_MASA_MODE_DISC )
2333 : {
2334 : /* Allocate TD renderer for the objects in DISC mode */
2335 142 : if ( ( error = ivas_td_binaural_open( st_ivas ) ) != IVAS_ERR_OK )
2336 : {
2337 0 : return error;
2338 : }
2339 :
2340 142 : if ( st_ivas->hOutSetup.output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
2341 : {
2342 0 : if ( ( error = ivas_reverb_open( &st_ivas->hReverb, st_ivas->hHrtfStatistics, st_ivas->hRenderConfig, output_Fs ) ) != IVAS_ERR_OK )
2343 : {
2344 0 : return error;
2345 : }
2346 : }
2347 :
2348 : /* Allocate memory for delay buffer within 'hMasaIsmData' */
2349 142 : if ( ( error = ivas_omasa_objects_delay_open( st_ivas ) ) != IVAS_ERR_OK )
2350 : {
2351 0 : return error;
2352 : }
2353 : }
2354 :
2355 244 : if ( ( st_ivas->renderer_type == RENDERER_DIRAC ) &&
2356 10 : ( st_ivas->ism_mode == ISM_MASA_MODE_MASA_ONE_OBJ || st_ivas->ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ || st_ivas->ism_mode == ISM_MASA_MODE_DISC ) )
2357 : {
2358 : /* Allocate 'hIsmRendererData' handle and memory for delay buffer within 'hMasaIsmData' */
2359 10 : if ( ( error = ivas_omasa_objects_delay_open( st_ivas ) ) != IVAS_ERR_OK )
2360 : {
2361 0 : return error;
2362 : }
2363 10 : if ( ( error = ivas_omasa_separate_object_renderer_open( st_ivas ) ) != IVAS_ERR_OK )
2364 : {
2365 0 : return error;
2366 : }
2367 : }
2368 :
2369 244 : if ( st_ivas->renderer_type == RENDERER_OMASA_OBJECT_EXT )
2370 : {
2371 : /* Allocate 'hIsmRendererData' handle and memory for delay buffer within 'hMasaIsmData' */
2372 1 : if ( ( error = ivas_omasa_objects_delay_open( st_ivas ) ) != IVAS_ERR_OK )
2373 : {
2374 0 : return error;
2375 : }
2376 :
2377 1 : if ( ( error = ivas_spat_hSpatParamRendCom_config( &st_ivas->hSpatParamRendCom, DIRAC_OPEN, 0,
2378 : st_ivas->ivas_format, st_ivas->mc_mode, output_Fs, 0, 0 ) ) != IVAS_ERR_OK )
2379 : {
2380 0 : return error;
2381 : }
2382 : }
2383 :
2384 244 : if ( st_ivas->renderer_type == RENDERER_OMASA_MIX_EXT )
2385 : {
2386 : /* Allocate 'hIsmRendererData' handle */
2387 0 : if ( ( error = ivas_omasa_combine_separate_ism_with_masa_open( st_ivas ) ) != IVAS_ERR_OK )
2388 : {
2389 0 : return error;
2390 : }
2391 : }
2392 : }
2393 :
2394 1671 : if ( ( st_ivas->ivas_format == ISM_FORMAT || st_ivas->ivas_format == SBA_ISM_FORMAT ) &&
2395 285 : ( st_ivas->ism_mode == ISM_MODE_DISC || st_ivas->ism_mode == ISM_SBA_MODE_DISC ) &&
2396 248 : ( st_ivas->renderer_type == RENDERER_TD_PANNING ||
2397 241 : st_ivas->renderer_type == RENDERER_NON_DIEGETIC_DOWNMIX ||
2398 240 : st_ivas->renderer_type == RENDERER_SBA_LINEAR_ENC ||
2399 236 : st_ivas->renderer_type == RENDERER_OSBA_STEREO ||
2400 235 : st_ivas->renderer_type == RENDERER_OSBA_AMBI ||
2401 233 : st_ivas->renderer_type == RENDERER_OSBA_LS ||
2402 231 : st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV ||
2403 88 : st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM ||
2404 84 : st_ivas->renderer_type == RENDERER_BINAURAL_MIXER_CONV_ROOM ) )
2405 : {
2406 171 : if ( ( error = ivas_ism_renderer_open( st_ivas ) ) != IVAS_ERR_OK )
2407 : {
2408 0 : return error;
2409 : }
2410 : }
2411 :
2412 1671 : if ( st_ivas->ivas_format == SBA_ISM_FORMAT )
2413 : {
2414 174 : if ( ( st_ivas->renderer_type == RENDERER_BINAURAL_PARAMETRIC || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV ) && st_ivas->ism_mode == ISM_SBA_MODE_DISC )
2415 : {
2416 : /* Allocate TD renderer for the objects in DISC mode */
2417 143 : if ( ( error = ivas_td_binaural_open( st_ivas ) ) != IVAS_ERR_OK )
2418 : {
2419 0 : return error;
2420 : }
2421 :
2422 143 : if ( st_ivas->hOutSetup.output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
2423 : {
2424 2 : if ( ( error = ivas_reverb_open( &st_ivas->hReverb, st_ivas->hHrtfStatistics, st_ivas->hRenderConfig, output_Fs ) ) != IVAS_ERR_OK )
2425 : {
2426 0 : return error;
2427 : }
2428 : }
2429 : }
2430 : }
2431 :
2432 : /*-----------------------------------------------------------------*
2433 : * CLDFB handles for rendering
2434 : *-----------------------------------------------------------------*/
2435 :
2436 1671 : ivas_init_dec_get_num_cldfb_instances( st_ivas, &numCldfbAnalyses, &numCldfbSyntheses );
2437 :
2438 6865 : for ( i = 0; i < numCldfbAnalyses; i++ )
2439 : {
2440 5194 : if ( ( error = openCldfb( &( st_ivas->cldfbAnaDec[i] ), CLDFB_ANALYSIS, output_Fs, CLDFB_PROTOTYPE_5_00MS ) ) != IVAS_ERR_OK )
2441 : {
2442 0 : return error;
2443 : }
2444 : }
2445 23213 : for ( ; i < MAX_INTERN_CHANNELS; i++ )
2446 : {
2447 21542 : st_ivas->cldfbAnaDec[i] = NULL;
2448 : }
2449 :
2450 9450 : for ( i = 0; i < numCldfbSyntheses; i++ )
2451 : {
2452 7779 : if ( ( error = openCldfb( &( st_ivas->cldfbSynDec[i] ), CLDFB_SYNTHESIS, output_Fs, CLDFB_PROTOTYPE_5_00MS ) ) != IVAS_ERR_OK )
2453 : {
2454 0 : return error;
2455 : }
2456 : }
2457 20628 : for ( ; i < MAX_OUTPUT_CHANNELS; i++ )
2458 : {
2459 18957 : st_ivas->cldfbSynDec[i] = NULL;
2460 : }
2461 :
2462 : /* CLDFB Interpolation weights */
2463 1671 : if ( ( st_ivas->ivas_format == SBA_FORMAT || st_ivas->ivas_format == SBA_ISM_FORMAT ) && !st_ivas->sba_dirac_stereo_flag && st_ivas->hDecoderConfig->nchan_out != 1 )
2464 : {
2465 597 : ivas_spar_get_cldfb_gains( st_ivas->hSpar, st_ivas->cldfbAnaDec[0], st_ivas->cldfbSynDec[0], hDecoderConfig );
2466 : }
2467 :
2468 : /*-----------------------------------------------------------------*
2469 : * LFE handles for rendering after rendering to adjust LFE delay to
2470 : * filter delay
2471 : *-----------------------------------------------------------------*/
2472 :
2473 1671 : if ( st_ivas->mc_mode == MC_MODE_MCT || st_ivas->mc_mode == MC_MODE_PARAMUPMIX )
2474 : {
2475 265 : if ( st_ivas->hIntSetup.index_lfe[0] != -1 )
2476 : {
2477 191 : delay_ns = st_ivas->binaural_latency_ns;
2478 : }
2479 : else
2480 : {
2481 74 : delay_ns = 0;
2482 : }
2483 :
2484 265 : if ( st_ivas->hBinRenderer != NULL )
2485 : {
2486 38 : if ( st_ivas->hBinRenderer->render_lfe )
2487 : {
2488 1 : if ( output_config != IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED && output_config != IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM )
2489 : {
2490 : /* Account for filterbank delay */
2491 1 : delay_ns += IVAS_FB_DEC_DELAY_NS;
2492 : }
2493 : }
2494 : else
2495 : {
2496 37 : delay_ns = 0;
2497 : }
2498 : }
2499 : else
2500 : {
2501 227 : if ( ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX ) && ( st_ivas->cldfbSynDec[0] != NULL ) )
2502 : {
2503 1 : delay_ns += IVAS_FB_DEC_DELAY_NS;
2504 : }
2505 : }
2506 :
2507 265 : if ( ( error = ivas_create_lfe_dec( &st_ivas->hLFE, output_Fs, delay_ns ) ) != IVAS_ERR_OK )
2508 : {
2509 0 : return error;
2510 : }
2511 :
2512 265 : set_zero( st_ivas->hLFE->prevsynth_buf, LFE_PLC_BUFLEN );
2513 265 : set_zero( st_ivas->hLFE->prior_out_buffer, L_FRAME48k );
2514 : }
2515 :
2516 : /*-----------------------------------------------------------------*
2517 : * Allocate and initialize limiter struct
2518 : *-----------------------------------------------------------------*/
2519 :
2520 1671 : if ( ( error = ivas_limiter_open( &st_ivas->hLimiter, hDecoderConfig->nchan_out, output_Fs ) ) != IVAS_ERR_OK )
2521 : {
2522 0 : return error;
2523 : }
2524 :
2525 : /*-----------------------------------------------------------------*
2526 : * Allocate and initialize JBM struct + buffer
2527 : *-----------------------------------------------------------------*/
2528 :
2529 1671 : if ( st_ivas->hTcBuffer == NULL )
2530 : {
2531 : /* no module has yet open the TC buffer, open a default one */
2532 422 : granularity = ivas_jbm_dec_get_render_granularity( st_ivas->renderer_type, ivas_renderer_secondary_select( st_ivas ), output_Fs );
2533 422 : n_channels_transport_jbm = ivas_jbm_dec_get_num_tc_channels( st_ivas );
2534 :
2535 422 : if ( ( error = ivas_jbm_dec_tc_buffer_open( st_ivas, ivas_jbm_dec_get_tc_buffer_mode( st_ivas ), n_channels_transport_jbm, n_channels_transport_jbm, n_channels_transport_jbm, granularity ) ) != IVAS_ERR_OK )
2536 : {
2537 0 : return error;
2538 : }
2539 : }
2540 :
2541 1671 : if ( ( st_ivas->ivas_format == MASA_FORMAT || st_ivas->ivas_format == MASA_ISM_FORMAT ) && hDecoderConfig->Opt_tsm )
2542 : {
2543 226 : if ( output_config == IVAS_AUDIO_CONFIG_EXTERNAL )
2544 : {
2545 3 : if ( ( error = ivas_jbm_dec_metadata_open( st_ivas ) ) != IVAS_ERR_OK )
2546 : {
2547 0 : return error;
2548 : }
2549 : }
2550 : }
2551 :
2552 : /*-----------------------------------------------------------------*
2553 : * Allocate floating-point output audio buffers
2554 : *-----------------------------------------------------------------*/
2555 :
2556 1671 : nchan_out_buff = ivas_get_nchan_buffers_dec( st_ivas, st_ivas->sba_analysis_order, ivas_total_brate );
2557 1671 : if ( ( error = ivas_output_buff_dec( st_ivas->p_output_f, nchan_out_buff, hDecoderConfig->Opt_tsm, st_ivas->hTcBuffer ) ) != IVAS_ERR_OK )
2558 : {
2559 0 : return error;
2560 : }
2561 :
2562 1671 : return IVAS_ERR_OK;
2563 : }
2564 :
2565 :
2566 : /*-------------------------------------------------------------------------
2567 : * destroy_core_dec()
2568 : *
2569 : * Close core decoder handles
2570 : *-------------------------------------------------------------------------*/
2571 :
2572 19096 : void destroy_core_dec(
2573 : DEC_CORE_HANDLE hCoreCoder /* i/o: core decoder structure */
2574 : )
2575 : {
2576 19096 : destroy_cldfb_decoder( hCoreCoder );
2577 :
2578 19096 : if ( hCoreCoder->hGSCDec != NULL )
2579 : {
2580 8869 : free( hCoreCoder->hGSCDec );
2581 8869 : hCoreCoder->hGSCDec = NULL;
2582 : }
2583 :
2584 19096 : if ( hCoreCoder->hPFstat != NULL )
2585 : {
2586 8869 : free( hCoreCoder->hPFstat );
2587 8869 : hCoreCoder->hPFstat = NULL;
2588 : }
2589 :
2590 19096 : if ( hCoreCoder->hMusicPF != NULL )
2591 : {
2592 8869 : free( hCoreCoder->hMusicPF );
2593 8869 : hCoreCoder->hMusicPF = NULL;
2594 : }
2595 :
2596 19096 : if ( hCoreCoder->hBPF != NULL )
2597 : {
2598 8869 : free( hCoreCoder->hBPF );
2599 8869 : hCoreCoder->hBPF = NULL;
2600 : }
2601 :
2602 19096 : if ( hCoreCoder->hBWE_zero != NULL )
2603 : {
2604 8869 : free( hCoreCoder->hBWE_zero );
2605 8869 : hCoreCoder->hBWE_zero = NULL;
2606 : }
2607 :
2608 19096 : if ( hCoreCoder->hTdCngDec != NULL )
2609 : {
2610 3707 : free( hCoreCoder->hTdCngDec );
2611 3707 : hCoreCoder->hTdCngDec = NULL;
2612 : }
2613 :
2614 19096 : if ( hCoreCoder->hSC_VBR != NULL )
2615 : {
2616 5 : free( hCoreCoder->hSC_VBR );
2617 5 : hCoreCoder->hSC_VBR = NULL;
2618 : }
2619 :
2620 19096 : if ( hCoreCoder->hAmrwb_IO != NULL )
2621 : {
2622 5 : free( hCoreCoder->hAmrwb_IO );
2623 5 : hCoreCoder->hAmrwb_IO = NULL;
2624 : }
2625 :
2626 19096 : if ( hCoreCoder->hBWE_TD != NULL )
2627 : {
2628 8920 : free( hCoreCoder->hBWE_TD );
2629 8920 : hCoreCoder->hBWE_TD = NULL;
2630 : }
2631 :
2632 19096 : if ( hCoreCoder->hBWE_FD != NULL )
2633 : {
2634 8920 : free( hCoreCoder->hBWE_FD );
2635 8920 : hCoreCoder->hBWE_FD = NULL;
2636 : }
2637 :
2638 19096 : if ( hCoreCoder->hBWE_FD_HR != NULL )
2639 : {
2640 5 : free( hCoreCoder->hBWE_FD_HR );
2641 5 : hCoreCoder->hBWE_FD_HR = NULL;
2642 : }
2643 :
2644 19096 : if ( hCoreCoder->hWIDec != NULL )
2645 : {
2646 0 : free( hCoreCoder->hWIDec );
2647 0 : hCoreCoder->hWIDec = NULL;
2648 : }
2649 :
2650 19096 : if ( hCoreCoder->hTECDec != NULL )
2651 : {
2652 5 : free( hCoreCoder->hTECDec );
2653 5 : hCoreCoder->hTECDec = NULL;
2654 : }
2655 :
2656 19096 : if ( hCoreCoder->hTcxLtpDec != NULL )
2657 : {
2658 18840 : free( hCoreCoder->hTcxLtpDec );
2659 18840 : hCoreCoder->hTcxLtpDec = NULL;
2660 : }
2661 :
2662 19096 : if ( hCoreCoder->hTcxDec != NULL )
2663 : {
2664 18840 : free( hCoreCoder->hTcxDec );
2665 18840 : hCoreCoder->hTcxDec = NULL;
2666 : }
2667 :
2668 19096 : if ( hCoreCoder->hTcxCfg != NULL )
2669 : {
2670 18840 : free( hCoreCoder->hTcxCfg );
2671 18840 : hCoreCoder->hTcxCfg = NULL;
2672 : }
2673 :
2674 19096 : if ( hCoreCoder->hTonalMDCTConc != NULL )
2675 : {
2676 18840 : free( hCoreCoder->hTonalMDCTConc );
2677 18840 : hCoreCoder->hTonalMDCTConc = NULL;
2678 : }
2679 :
2680 19096 : if ( hCoreCoder->hIGFDec != NULL )
2681 : {
2682 18840 : free( hCoreCoder->hIGFDec );
2683 18840 : hCoreCoder->hIGFDec = NULL;
2684 : }
2685 :
2686 19096 : if ( hCoreCoder->hPlcInfo != NULL )
2687 : {
2688 5 : free( hCoreCoder->hPlcInfo );
2689 5 : hCoreCoder->hPlcInfo = NULL;
2690 : }
2691 :
2692 19096 : if ( hCoreCoder->hHQ_core != NULL )
2693 : {
2694 18840 : free( hCoreCoder->hHQ_core );
2695 18840 : hCoreCoder->hHQ_core = NULL;
2696 : }
2697 :
2698 19096 : if ( hCoreCoder->hHQ_nbfec != NULL )
2699 : {
2700 5 : free( hCoreCoder->hHQ_nbfec );
2701 5 : hCoreCoder->hHQ_nbfec = NULL;
2702 : }
2703 :
2704 19096 : return;
2705 : }
2706 :
2707 :
2708 : /*-------------------------------------------------------------------------
2709 : * ivas_initialize_handles_dec()
2710 : *
2711 : * NULL initialization of handles
2712 : *-------------------------------------------------------------------------*/
2713 :
2714 1678 : void ivas_initialize_handles_dec(
2715 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
2716 : )
2717 : {
2718 : int16_t i;
2719 :
2720 28526 : for ( i = 0; i < MAX_INTERN_CHANNELS; i++ )
2721 : {
2722 26848 : st_ivas->cldfbAnaDec[i] = NULL;
2723 : }
2724 :
2725 28526 : for ( i = 0; i < MAX_OUTPUT_CHANNELS; i++ )
2726 : {
2727 26848 : st_ivas->cldfbSynDec[i] = NULL;
2728 : }
2729 :
2730 : /* SCE handles */
2731 8390 : for ( i = 0; i < MAX_SCE; i++ )
2732 : {
2733 6712 : st_ivas->hSCE[i] = NULL;
2734 : }
2735 :
2736 : /* CPE handles */
2737 11746 : for ( i = 0; i < MAX_CPE; i++ )
2738 : {
2739 10068 : st_ivas->hCPE[i] = NULL;
2740 : }
2741 :
2742 1678 : st_ivas->bit_stream = NULL;
2743 1678 : st_ivas->mem_hp20_out = NULL;
2744 1678 : st_ivas->hLimiter = NULL;
2745 :
2746 : /* ISM metadata handles */
2747 8390 : for ( i = 0; i < MAX_NUM_OBJECTS; i++ )
2748 : {
2749 6712 : st_ivas->hIsmMetaData[i] = NULL;
2750 : }
2751 :
2752 : /* spatial coding handles */
2753 1678 : st_ivas->hDirAC = NULL;
2754 1678 : st_ivas->hParamIsmDec = NULL;
2755 1678 : st_ivas->hSpar = NULL;
2756 1678 : st_ivas->hMasa = NULL;
2757 1678 : st_ivas->hQMetaData = NULL;
2758 1678 : st_ivas->hMCT = NULL;
2759 1678 : st_ivas->hMCParamUpmix = NULL;
2760 1678 : st_ivas->hParamMC = NULL;
2761 1678 : st_ivas->hLFE = NULL;
2762 :
2763 : /* rendering handles */
2764 1678 : st_ivas->hBinRenderer = NULL;
2765 15102 : for ( i = 0; i < MAX_HEAD_ROT_POSES; i++ )
2766 : {
2767 13424 : st_ivas->hDiracDecBin[i] = NULL;
2768 : }
2769 1678 : st_ivas->hDirACRend = NULL;
2770 1678 : st_ivas->hSpatParamRendCom = NULL;
2771 1678 : st_ivas->hLsSetUpConversion = NULL;
2772 1678 : st_ivas->hEFAPdata = NULL;
2773 1678 : st_ivas->hVBAPdata = NULL;
2774 1678 : st_ivas->hIsmRendererData = NULL;
2775 1678 : st_ivas->hBinRendererTd = NULL;
2776 1678 : st_ivas->hMonoDmxRenderer = NULL;
2777 1678 : st_ivas->hCrendWrapper = NULL;
2778 1678 : st_ivas->hReverb = NULL;
2779 1678 : st_ivas->hHrtfCrend = NULL;
2780 1678 : st_ivas->hHrtfFastConv = NULL;
2781 1678 : st_ivas->hHrtfParambin = NULL;
2782 1678 : st_ivas->hHrtfStatistics = NULL;
2783 1678 : st_ivas->hoa_dec_mtx = NULL;
2784 1678 : st_ivas->hMasaIsmData = NULL;
2785 1678 : st_ivas->hSbaIsmData = NULL;
2786 :
2787 1678 : st_ivas->hHeadTrackData = NULL;
2788 1678 : st_ivas->hHrtfTD = NULL;
2789 1678 : st_ivas->hLsSetupCustom = NULL;
2790 1678 : st_ivas->hRenderConfig = NULL;
2791 1678 : st_ivas->hExtOrientationData = NULL;
2792 1678 : st_ivas->hCombinedOrientationData = NULL;
2793 1678 : st_ivas->acousticEnvironmentsCount = 0;
2794 1678 : st_ivas->pAcousticEnvironments = NULL;
2795 :
2796 1678 : st_ivas->hSplitBinRend = NULL;
2797 13424 : for ( i = 0; i < MAX_HEAD_ROT_POSES - 1; ++i )
2798 : {
2799 11746 : st_ivas->hTdRendHandles[i] = NULL;
2800 : }
2801 :
2802 : /* JBM handles */
2803 1678 : st_ivas->hTcBuffer = NULL;
2804 1678 : st_ivas->hJbmMetadata = NULL;
2805 :
2806 : /* floating-point output audio buffers */
2807 35238 : for ( i = 0; i < MAX_OUTPUT_CHANNELS + MAX_NUM_OBJECTS; i++ )
2808 : {
2809 33560 : st_ivas->p_output_f[i] = NULL;
2810 : }
2811 :
2812 1678 : return;
2813 : }
2814 :
2815 :
2816 : /*-------------------------------------------------------------------------
2817 : * ivas_destroy_dec()
2818 : *
2819 : * Close IVAS decoder handles
2820 : *-------------------------------------------------------------------------*/
2821 :
2822 1678 : void ivas_destroy_dec(
2823 : Decoder_Struct *st_ivas /* i/o: IVAS decoder handle */
2824 : )
2825 : {
2826 : int16_t i;
2827 :
2828 : /* CLDFB handles */
2829 28526 : for ( i = 0; i < MAX_INTERN_CHANNELS; i++ )
2830 : {
2831 26848 : if ( st_ivas->cldfbAnaDec[i] != NULL )
2832 : {
2833 5210 : deleteCldfb( &( st_ivas->cldfbAnaDec[i] ) );
2834 : }
2835 : }
2836 :
2837 28526 : for ( i = 0; i < MAX_OUTPUT_CHANNELS; i++ )
2838 : {
2839 26848 : if ( st_ivas->cldfbSynDec[i] != NULL )
2840 : {
2841 7786 : deleteCldfb( &( st_ivas->cldfbSynDec[i] ) );
2842 : }
2843 : }
2844 :
2845 : /* SCE handles */
2846 8390 : for ( i = 0; i < MAX_SCE; i++ )
2847 : {
2848 6712 : if ( st_ivas->hSCE[i] != NULL )
2849 : {
2850 919 : destroy_sce_dec( st_ivas->hSCE[i] );
2851 919 : st_ivas->hSCE[i] = NULL;
2852 : }
2853 : }
2854 :
2855 : /* CPE handles */
2856 11746 : for ( i = 0; i < MAX_CPE; i++ )
2857 : {
2858 10068 : if ( st_ivas->hCPE[i] != NULL )
2859 : {
2860 : /* set pointer to NULL as core coder already deallocated in destroy_sce_dec() */
2861 2776 : if ( st_ivas->sba_dirac_stereo_flag && st_ivas->nchan_transport == 1 )
2862 : {
2863 5 : st_ivas->hCPE[i]->hCoreCoder[0] = NULL;
2864 5 : st_ivas->hCPE[i]->hCoreCoder[1] = NULL;
2865 : }
2866 2776 : destroy_cpe_dec( st_ivas->hCPE[i] );
2867 2776 : st_ivas->hCPE[i] = NULL;
2868 : }
2869 : }
2870 :
2871 : /* HP20 filter handles */
2872 1678 : if ( st_ivas->mem_hp20_out != NULL )
2873 : {
2874 7970 : for ( i = 0; i < getNumChanSynthesis( st_ivas ); i++ )
2875 : {
2876 6299 : free( st_ivas->mem_hp20_out[i] );
2877 6299 : st_ivas->mem_hp20_out[i] = NULL;
2878 : }
2879 1671 : free( st_ivas->mem_hp20_out );
2880 1671 : st_ivas->mem_hp20_out = NULL;
2881 : }
2882 :
2883 : /* ISM metadata handles */
2884 1678 : ivas_ism_metadata_close( st_ivas->hIsmMetaData, 0 );
2885 :
2886 : /* ISM renderer handle */
2887 1678 : ivas_ism_renderer_close( &( st_ivas->hIsmRendererData ) );
2888 :
2889 : /* DirAC handle */
2890 1678 : if ( st_ivas->ivas_format == ISM_FORMAT )
2891 : {
2892 111 : ivas_param_ism_dec_close( &( st_ivas->hParamIsmDec ), &( st_ivas->hSpatParamRendCom ), st_ivas->hDecoderConfig->output_config );
2893 : }
2894 : else
2895 : {
2896 1567 : ivas_dirac_rend_close( &( st_ivas->hDirACRend ) );
2897 1567 : ivas_spat_hSpatParamRendCom_close( &( st_ivas->hSpatParamRendCom ) );
2898 1567 : ivas_dirac_dec_close( &( st_ivas->hDirAC ) );
2899 : }
2900 :
2901 : /* SPAR handle */
2902 1678 : ivas_spar_dec_close( &( st_ivas->hSpar ), st_ivas->hDecoderConfig->output_Fs, 0 );
2903 :
2904 : /* HOA decoder matrix */
2905 1678 : if ( st_ivas->hoa_dec_mtx != NULL )
2906 : {
2907 28 : free( st_ivas->hoa_dec_mtx );
2908 28 : st_ivas->hoa_dec_mtx = NULL;
2909 : }
2910 :
2911 : /* MASA decoder structure */
2912 1678 : ivas_masa_dec_close( &( st_ivas->hMasa ) );
2913 :
2914 : /* Qmetadata handle */
2915 1678 : ivas_qmetadata_close( &st_ivas->hQMetaData );
2916 :
2917 : /* MCT handle */
2918 1678 : ivas_mct_dec_close( &st_ivas->hMCT );
2919 :
2920 : /* LFE handle */
2921 1678 : ivas_lfe_dec_close( &( st_ivas->hLFE ) );
2922 :
2923 : /* Param-Upmix MC handle */
2924 1678 : ivas_mc_paramupmix_dec_close( &( st_ivas->hMCParamUpmix ) );
2925 :
2926 : /* Parametric MC handle */
2927 1678 : ivas_param_mc_dec_close( &st_ivas->hParamMC );
2928 :
2929 : /* EFAP handle */
2930 1678 : efap_free_data( &st_ivas->hEFAPdata );
2931 :
2932 : /* VBAP handle */
2933 1678 : vbap_free_data( &( st_ivas->hVBAPdata ) );
2934 :
2935 : /* Fastconv binaural renderer handle */
2936 1678 : ivas_binRenderer_close( &st_ivas->hBinRenderer );
2937 :
2938 : /* TD binaural renderer handles */
2939 13424 : for ( i = 0; i < MAX_HEAD_ROT_POSES - 1; ++i )
2940 : {
2941 11746 : if ( st_ivas->hTdRendHandles[i] != NULL )
2942 : {
2943 1300 : st_ivas->hTdRendHandles[i]->HrFiltSet_p = NULL;
2944 1300 : ivas_td_binaural_close( &st_ivas->hTdRendHandles[i] );
2945 : }
2946 : }
2947 :
2948 : /* Parametric binaural renderer handle */
2949 1678 : ivas_dirac_dec_close_binaural_data( st_ivas->hDiracDecBin );
2950 :
2951 : /* Crend handle */
2952 1678 : ivas_rend_closeCrend( &( st_ivas->hCrendWrapper ) );
2953 :
2954 : /* Reverb handle */
2955 1678 : ivas_reverb_close( &st_ivas->hReverb );
2956 :
2957 : /* LS config converter handle */
2958 1678 : ivas_ls_setup_conversion_close( &st_ivas->hLsSetUpConversion );
2959 :
2960 : /* Custom LS configuration handle */
2961 1678 : if ( st_ivas->hLsSetupCustom != NULL )
2962 : {
2963 3 : free( st_ivas->hLsSetupCustom );
2964 3 : st_ivas->hLsSetupCustom = NULL;
2965 : }
2966 :
2967 : /* Mono downmix structure */
2968 1678 : ivas_mono_dmx_renderer_close( &st_ivas->hMonoDmxRenderer );
2969 :
2970 : /* OSBA structure */
2971 1678 : ivas_osba_data_close( &st_ivas->hSbaIsmData );
2972 :
2973 : /* OMASA structure */
2974 1678 : ivas_omasa_data_close( &st_ivas->hMasaIsmData );
2975 :
2976 : /* Head track data handle */
2977 1678 : ivas_headTrack_close( &st_ivas->hHeadTrackData );
2978 :
2979 : /* External orientation data handle */
2980 1678 : ivas_external_orientation_close( &st_ivas->hExtOrientationData );
2981 :
2982 : /* Combined orientation data handle */
2983 1678 : ivas_combined_orientation_close( &st_ivas->hCombinedOrientationData );
2984 :
2985 : /* Time Domain binaural renderer handle */
2986 1678 : if ( st_ivas->hBinRendererTd != NULL )
2987 : {
2988 504 : ivas_td_binaural_close( &st_ivas->hBinRendererTd );
2989 : }
2990 :
2991 1678 : if ( st_ivas->hHrtfTD != NULL )
2992 : {
2993 0 : BSplineModelEvalDealloc( &st_ivas->hHrtfTD->ModelParams, &st_ivas->hHrtfTD->ModelEval );
2994 :
2995 0 : ivas_HRTF_binary_close( &st_ivas->hHrtfTD );
2996 : }
2997 :
2998 : /* CRend binaural renderer handle */
2999 1678 : ivas_HRTF_CRend_binary_close( &st_ivas->hHrtfCrend );
3000 :
3001 : /* Fastconv HRTF memories */
3002 1678 : ivas_binaural_hrtf_close( &st_ivas->hHrtfFastConv );
3003 :
3004 : /* Fastconv HRTF filters */
3005 1678 : ivas_HRTF_fastconv_binary_close( &st_ivas->hHrtfFastConv );
3006 :
3007 : /* Parametric binauralizer HRTF filters */
3008 1678 : ivas_HRTF_parambin_binary_close( &st_ivas->hHrtfParambin );
3009 :
3010 : /* HRTF statistics */
3011 1678 : ivas_HRTF_statistics_close( &st_ivas->hHrtfStatistics );
3012 :
3013 : /* Config. Renderer */
3014 1678 : ivas_render_config_close( &( st_ivas->hRenderConfig ) );
3015 :
3016 : /* Acoustic environments */
3017 1678 : if ( st_ivas->pAcousticEnvironments != NULL )
3018 : {
3019 29 : free( st_ivas->pAcousticEnvironments );
3020 29 : st_ivas->pAcousticEnvironments = NULL;
3021 : }
3022 :
3023 : /* Limiter struct */
3024 1678 : ivas_limiter_close( &( st_ivas->hLimiter ) );
3025 :
3026 : /* Decoder configuration structure */
3027 1678 : if ( st_ivas->hDecoderConfig != NULL )
3028 : {
3029 1678 : free( st_ivas->hDecoderConfig );
3030 1678 : st_ivas->hDecoderConfig = NULL;
3031 : }
3032 :
3033 : /* JBM TC buffer structure */
3034 1678 : ivas_jbm_dec_tc_buffer_close( &st_ivas->hTcBuffer );
3035 :
3036 1678 : if ( st_ivas->hJbmMetadata != NULL )
3037 : {
3038 3 : free( st_ivas->hJbmMetadata );
3039 3 : st_ivas->hJbmMetadata = NULL;
3040 : }
3041 :
3042 : /* floating-point output audio buffers */
3043 35238 : for ( i = 0; i < MAX_OUTPUT_CHANNELS + MAX_NUM_OBJECTS; i++ )
3044 : {
3045 33560 : st_ivas->p_output_f[i] = NULL;
3046 : }
3047 :
3048 : /* main IVAS handle */
3049 1678 : free( st_ivas );
3050 :
3051 1678 : return;
3052 : }
3053 :
3054 :
3055 : /*-------------------------------------------------------------------*
3056 : * ivas_init_dec_get_num_cldfb_instances()
3057 : *
3058 : * Return number of CLDFB analysis & synthesis instances
3059 : *-------------------------------------------------------------------*/
3060 :
3061 : /*! r: number of cldfb instances */
3062 36827 : void ivas_init_dec_get_num_cldfb_instances(
3063 : Decoder_Struct *st_ivas, /* i : IVAS decoder structure */
3064 : int16_t *numCldfbAnalyses, /* o : number of needed CLDFB analysis instances */
3065 : int16_t *numCldfbSyntheses /* o : number of needed CLDFB synthesis instances */
3066 : )
3067 : {
3068 : IVAS_FORMAT ivas_format;
3069 36827 : *numCldfbAnalyses = st_ivas->nchan_transport;
3070 36827 : *numCldfbSyntheses = st_ivas->hDecoderConfig->nchan_out;
3071 :
3072 36827 : ivas_format = ( st_ivas->ivas_format == SBA_ISM_FORMAT && st_ivas->ism_mode == ISM_MODE_NONE ) ? SBA_FORMAT : st_ivas->ivas_format; /* treat ISM_SBA_MODE_NONE just like SBA_FORMAT */
3073 :
3074 36827 : switch ( st_ivas->renderer_type )
3075 : {
3076 17093 : case RENDERER_BINAURAL_PARAMETRIC:
3077 : case RENDERER_BINAURAL_PARAMETRIC_ROOM:
3078 : case RENDERER_STEREO_PARAMETRIC:
3079 17093 : if ( st_ivas->nchan_transport == 1 )
3080 : {
3081 1535 : *numCldfbAnalyses = st_ivas->nchan_transport + 1;
3082 : }
3083 :
3084 17093 : if ( st_ivas->mc_mode == MC_MODE_MCMASA && st_ivas->hOutSetup.separateChannelEnabled )
3085 : {
3086 16 : *numCldfbAnalyses = st_ivas->nchan_transport + 1;
3087 : }
3088 :
3089 17093 : if ( ivas_format == SBA_ISM_FORMAT )
3090 : {
3091 0 : if ( st_ivas->ism_mode == ISM_SBA_MODE_DISC )
3092 : {
3093 0 : *numCldfbAnalyses += st_ivas->nchan_ism;
3094 : }
3095 : }
3096 :
3097 17093 : if ( ivas_format == MASA_ISM_FORMAT )
3098 : {
3099 9605 : if ( st_ivas->ism_mode == ISM_MASA_MODE_DISC )
3100 : {
3101 3887 : *numCldfbAnalyses += st_ivas->nchan_ism;
3102 : }
3103 5718 : else if ( st_ivas->ism_mode == ISM_MASA_MODE_MASA_ONE_OBJ || st_ivas->ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ )
3104 : {
3105 5718 : *numCldfbAnalyses = st_ivas->nchan_transport + 1;
3106 : }
3107 : }
3108 :
3109 17093 : if ( st_ivas->hDiracDecBin[0]->useTdDecorr )
3110 : {
3111 4220 : *numCldfbAnalyses += 2;
3112 : }
3113 17093 : break;
3114 2189 : case RENDERER_NON_DIEGETIC_DOWNMIX:
3115 : case RENDERER_MONO_DOWNMIX:
3116 2189 : if ( ivas_format == ISM_FORMAT || ivas_format == MASA_ISM_FORMAT || ivas_format == SBA_ISM_FORMAT )
3117 : {
3118 : /* CLDFB not used in rendering */
3119 1951 : *numCldfbAnalyses = 0;
3120 1951 : *numCldfbSyntheses = 0;
3121 : }
3122 2189 : break;
3123 7216 : case RENDERER_DIRAC:
3124 7216 : if ( ivas_format == SBA_FORMAT )
3125 : {
3126 186 : *numCldfbAnalyses = st_ivas->hSpar->hFbMixer->fb_cfg->num_in_chans;
3127 :
3128 186 : if ( st_ivas->hOutSetup.is_loudspeaker_setup && st_ivas->renderer_type == RENDERER_DIRAC )
3129 : {
3130 186 : *numCldfbSyntheses = st_ivas->hOutSetup.nchan_out_woLFE;
3131 : }
3132 0 : else if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_FOA )
3133 : {
3134 0 : *numCldfbSyntheses = st_ivas->hSpar->hFbMixer->fb_cfg->num_out_chans;
3135 : }
3136 : else
3137 : {
3138 0 : *numCldfbSyntheses = MAX_OUTPUT_CHANNELS;
3139 : }
3140 : }
3141 7216 : if ( ivas_format != SBA_FORMAT )
3142 : {
3143 7030 : if ( st_ivas->nchan_transport > 2 && st_ivas->sba_planar )
3144 : {
3145 0 : *numCldfbAnalyses = st_ivas->nchan_transport + 1;
3146 : }
3147 7030 : else if ( st_ivas->nchan_transport == 1 && st_ivas->hDirACRend->synthesisConf == DIRAC_SYNTHESIS_GAIN_SHD )
3148 : {
3149 379 : *numCldfbAnalyses = st_ivas->nchan_transport + 1;
3150 : }
3151 : }
3152 7216 : break;
3153 174 : case RENDERER_MC_PARAMMC:
3154 174 : if ( st_ivas->hDecoderConfig->nchan_out <= 2 )
3155 : {
3156 : /* CLDFB not used in rendering */
3157 4 : *numCldfbAnalyses = 0;
3158 4 : *numCldfbSyntheses = 0;
3159 : }
3160 : else
3161 : {
3162 170 : *numCldfbSyntheses = param_mc_get_num_cldfb_syntheses( st_ivas );
3163 : }
3164 174 : break;
3165 107 : case RENDERER_PARAM_ISM:
3166 : /* Already correct with no exception */
3167 107 : break;
3168 3007 : case RENDERER_DISABLE:
3169 : /* CLDFB not used */
3170 3007 : *numCldfbAnalyses = 0;
3171 3007 : *numCldfbSyntheses = 0;
3172 3007 : break;
3173 5626 : case RENDERER_MC:
3174 : case RENDERER_SBA_LINEAR_DEC:
3175 : case RENDERER_TD_PANNING:
3176 : case RENDERER_BINAURAL_OBJECTS_TD:
3177 : case RENDERER_MCMASA_MONO_STEREO:
3178 : case RENDERER_BINAURAL_MIXER_CONV:
3179 : case RENDERER_BINAURAL_MIXER_CONV_ROOM:
3180 : case RENDERER_BINAURAL_FASTCONV:
3181 : case RENDERER_BINAURAL_FASTCONV_ROOM:
3182 : case RENDERER_OSBA_STEREO:
3183 : case RENDERER_OSBA_AMBI:
3184 : case RENDERER_OSBA_LS:
3185 5626 : if ( ivas_format == SBA_FORMAT || ivas_format == SBA_ISM_FORMAT )
3186 : {
3187 2813 : if ( st_ivas->sba_dirac_stereo_flag )
3188 : {
3189 72 : *numCldfbAnalyses = 0;
3190 72 : *numCldfbSyntheses = 0;
3191 : }
3192 : else
3193 : {
3194 2741 : *numCldfbAnalyses = st_ivas->hSpar->hFbMixer->fb_cfg->num_in_chans;
3195 :
3196 2741 : if ( st_ivas->hOutSetup.is_loudspeaker_setup && st_ivas->renderer_type == RENDERER_DIRAC )
3197 : {
3198 0 : *numCldfbSyntheses = st_ivas->hOutSetup.nchan_out_woLFE;
3199 : }
3200 2741 : else if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_FOA )
3201 : {
3202 740 : *numCldfbSyntheses = st_ivas->hSpar->hFbMixer->fb_cfg->num_out_chans;
3203 : }
3204 : else
3205 : {
3206 2001 : *numCldfbSyntheses = MAX_OUTPUT_CHANNELS;
3207 : }
3208 :
3209 2741 : if ( st_ivas->ivas_format == SBA_ISM_FORMAT && st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
3210 : {
3211 4 : *numCldfbAnalyses = st_ivas->nchan_ism + st_ivas->hSpar->hFbMixer->fb_cfg->num_in_chans;
3212 : }
3213 : }
3214 : }
3215 2813 : else if ( st_ivas->mc_mode == MC_MODE_PARAMMC )
3216 : {
3217 : /* do nothing for ParamMC */
3218 : }
3219 : else
3220 : {
3221 : /* CLDFB not used in rendering */
3222 2284 : *numCldfbAnalyses = 0;
3223 2284 : *numCldfbSyntheses = 0;
3224 : }
3225 5626 : break;
3226 662 : case RENDERER_SBA_LINEAR_ENC:
3227 662 : if ( st_ivas->mc_mode == MC_MODE_PARAMMC )
3228 : {
3229 144 : *numCldfbSyntheses = param_mc_get_num_cldfb_syntheses( st_ivas );
3230 : }
3231 518 : else if ( st_ivas->ism_mode == ISM_MODE_PARAM )
3232 : {
3233 45 : *numCldfbSyntheses = st_ivas->hIntSetup.nchan_out_woLFE + st_ivas->hIntSetup.num_lfe;
3234 : }
3235 473 : else if ( st_ivas->mc_mode == MC_MODE_MCMASA )
3236 : {
3237 116 : *numCldfbAnalyses = st_ivas->nchan_transport;
3238 116 : *numCldfbSyntheses = st_ivas->hIntSetup.nchan_out_woLFE + st_ivas->hIntSetup.num_lfe;
3239 : }
3240 : else
3241 : {
3242 : /* CLDFB not used in rendering */
3243 357 : *numCldfbAnalyses = 0;
3244 357 : *numCldfbSyntheses = 0;
3245 : }
3246 662 : break;
3247 378 : case RENDERER_OMASA_OBJECT_EXT:
3248 378 : *numCldfbAnalyses = st_ivas->nchan_transport;
3249 378 : *numCldfbSyntheses = st_ivas->hDecoderConfig->nchan_out;
3250 378 : break;
3251 375 : case RENDERER_OMASA_MIX_EXT:
3252 375 : *numCldfbAnalyses = st_ivas->nchan_transport + 1;
3253 375 : *numCldfbSyntheses = 0;
3254 375 : break;
3255 0 : default:
3256 0 : assert( 0 && "Renderer not handled for CLDFB reservation." );
3257 : }
3258 :
3259 36827 : if ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX && st_ivas->hDecoderConfig->output_config != IVAS_AUDIO_CONFIG_MONO && st_ivas->hDecoderConfig->output_config != IVAS_AUDIO_CONFIG_STEREO )
3260 : {
3261 48 : if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV || st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM || st_ivas->renderer_type == RENDERER_STEREO_PARAMETRIC )
3262 : {
3263 41 : *numCldfbAnalyses = max( MC_PARAMUPMIX_MAX_INPUT_CHANS, *numCldfbAnalyses );
3264 : }
3265 : else
3266 : {
3267 7 : *numCldfbAnalyses = max( MC_PARAMUPMIX_MIN_CLDFB, *numCldfbAnalyses );
3268 : }
3269 48 : *numCldfbSyntheses = max( MC_PARAMUPMIX_MIN_CLDFB, *numCldfbSyntheses );
3270 : }
3271 :
3272 36827 : return;
3273 : }
3274 :
3275 :
3276 : /*---------------------------------------------------------------------*
3277 : * doSanityChecks_IVAS()
3278 : *
3279 : * Sanity checks - verify if the decoder set-up parameters are
3280 : * not in conflict with the IVAS format
3281 : *---------------------------------------------------------------------*/
3282 :
3283 1666 : static ivas_error doSanityChecks_IVAS(
3284 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
3285 : )
3286 : {
3287 : int32_t output_Fs;
3288 : AUDIO_CONFIG output_config;
3289 :
3290 1666 : output_Fs = st_ivas->hDecoderConfig->output_Fs;
3291 1666 : output_config = st_ivas->hDecoderConfig->output_config;
3292 :
3293 : /*-----------------------------------------------------------------*
3294 : * Sanity checks
3295 : *-----------------------------------------------------------------*/
3296 :
3297 1666 : if ( output_Fs == 8000 )
3298 : {
3299 0 : return IVAS_ERROR( IVAS_ERR_INVALID_SAMPLING_RATE, "8kHz output sampling rate is not supported in IVAS." );
3300 : }
3301 :
3302 1666 : assert( st_ivas->ivas_format != UNDEFINED_FORMAT && "\n IVAS format undefined" );
3303 1666 : assert( st_ivas->ivas_format != MONO_FORMAT && "\n Wrong IVAS format: MONO" );
3304 :
3305 : /* Verify output configuration compatible with non-diegetic panning */
3306 1666 : if ( st_ivas->hDecoderConfig->Opt_non_diegetic_pan && ( st_ivas->ivas_format != MONO_FORMAT ) && ( st_ivas->transport_config != IVAS_AUDIO_CONFIG_ISM1 ) )
3307 : {
3308 0 : return IVAS_ERROR( IVAS_ERR_INVALID_OUTPUT_FORMAT, "Error: Non-diegetic panning not supported in this IVAS format" );
3309 : }
3310 :
3311 1666 : if ( output_config == IVAS_AUDIO_CONFIG_INVALID ||
3312 1666 : output_config == IVAS_AUDIO_CONFIG_ISM1 ||
3313 1666 : output_config == IVAS_AUDIO_CONFIG_ISM2 ||
3314 1666 : output_config == IVAS_AUDIO_CONFIG_ISM3 ||
3315 1666 : output_config == IVAS_AUDIO_CONFIG_ISM4 ||
3316 1666 : output_config == IVAS_AUDIO_CONFIG_MASA1 ||
3317 : output_config == IVAS_AUDIO_CONFIG_MASA2 )
3318 : {
3319 0 : return IVAS_ERROR( IVAS_ERR_INVALID_OUTPUT_FORMAT, "Incorrect output configuration specified!" );
3320 : }
3321 1666 : if ( ( st_ivas->ivas_format == MONO_FORMAT || st_ivas->ivas_format == STEREO_FORMAT ) &&
3322 70 : ( output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM ) )
3323 : {
3324 0 : return IVAS_ERROR( IVAS_ERR_INVALID_OUTPUT_FORMAT, "Incorrect output configuration specified!" );
3325 : }
3326 :
3327 1666 : if ( ( output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM ) && output_Fs != 48000 )
3328 : {
3329 0 : return IVAS_ERROR( IVAS_ERR_INVALID_SAMPLING_RATE, "Error: Only 48kHz output sampling rate is supported for split rendering." );
3330 : }
3331 :
3332 1666 : if ( st_ivas->hDecoderConfig->Opt_Headrotation )
3333 : {
3334 1115 : if ( !( output_config == IVAS_AUDIO_CONFIG_BINAURAL || output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR || output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB || output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM ) )
3335 : {
3336 0 : return IVAS_ERROR( IVAS_ERR_HEAD_ROTATION_NOT_SUPPORTED, "Wrong set-up: Head-rotation not supported in this configuration" );
3337 : }
3338 : }
3339 :
3340 1666 : if ( st_ivas->hDecoderConfig->Opt_ExternalOrientation )
3341 : {
3342 31 : if ( !( output_config == IVAS_AUDIO_CONFIG_BINAURAL || output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR || output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB ) )
3343 : {
3344 0 : return IVAS_ERROR( IVAS_ERR_EXT_ORIENTATION_NOT_SUPPORTED, "Wrong set-up: External orientation not supported in this configuration" );
3345 : }
3346 : }
3347 :
3348 1666 : if ( st_ivas->hDecoderConfig->Opt_dpid_on )
3349 : {
3350 2 : if ( !( output_config == IVAS_AUDIO_CONFIG_BINAURAL || output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB ) )
3351 : {
3352 0 : return IVAS_ERROR( IVAS_ERR_DIRECTIVITY_NOT_SUPPORTED, "Wrong set-up: Directivity is not supported in this output configuration." );
3353 : }
3354 : }
3355 :
3356 1666 : if ( st_ivas->hDecoderConfig->Opt_aeid_on )
3357 : {
3358 4 : if ( output_config != IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
3359 : {
3360 0 : return IVAS_ERROR( IVAS_ERR_ACOUSTIC_ENVIRONMENT_NOT_SUPPORTED, "Wrong set-up: Acoustic environment is not supported in this output configuration." );
3361 : }
3362 : }
3363 :
3364 1666 : if ( st_ivas->hDecoderConfig->Opt_ObjEdit_on )
3365 : {
3366 13 : if ( !( st_ivas->ivas_format == ISM_FORMAT || st_ivas->ivas_format == SBA_ISM_FORMAT || st_ivas->ivas_format == MASA_ISM_FORMAT || ( st_ivas->ivas_format == MASA_FORMAT && st_ivas->nchan_ism > 0 ) ) )
3367 : {
3368 0 : return IVAS_ERROR( IVAS_ERR_OBJECTS_EDITING_NOT_SUPPORTED, "Wrong set-up: Object editing is not supported in this IVAS format." );
3369 : }
3370 : }
3371 :
3372 1666 : if ( st_ivas->hDecoderConfig->Opt_ObjEdit_on && st_ivas->hDecoderConfig->Opt_non_diegetic_pan )
3373 : {
3374 0 : return IVAS_ERROR( IVAS_ERR_OBJECTS_EDITING_AND_PANNING_NOT_SUPPORTED, "Wrong set-up: Only object editing or Non-diegetic panning can be used." );
3375 : }
3376 :
3377 1666 : return IVAS_ERR_OK;
3378 : }
|
