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 : /*====================================================================================
34 : EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
35 : ====================================================================================*/
36 :
37 : #include <assert.h>
38 : #include <stdint.h>
39 : #include "options.h"
40 : #ifdef DEBUGGING
41 : #include "debug.h"
42 : #endif
43 : #include "cnst.h"
44 : #include "prot.h"
45 : #include "stat_enc.h"
46 : #include "stat_dec.h"
47 : #include "rom_com.h"
48 : #include "mime.h"
49 : #include "ivas_prot.h"
50 : #include "ivas_cnst.h"
51 : #include "ivas_rom_com.h"
52 : #include "wmc_auto.h"
53 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
54 : #include <string.h>
55 : #endif
56 :
57 : #ifdef DEBUGGING
58 :
59 : #define FEC_SEED 12558
60 :
61 : /*-------------------------------------------------------------------*
62 : * Global variables
63 : *--------------------------------------------------------------------*/
64 :
65 : FILE *FEC_pattern = NULL; /* FEC pattern file (for simulation of FEC) */
66 : #endif
67 :
68 : #define STEP_MAX_NUM_INDICES 100 /* increase the maximum number of allowed indices in the list by this amount */
69 :
70 :
71 : /*-------------------------------------------------------------------*
72 : * rate2AMRWB_IOmode()
73 : *
74 : * lookup AMRWB IO mode
75 : *-------------------------------------------------------------------*/
76 :
77 9300 : static Word16 rate2AMRWB_IOmode(
78 : Word32 brate /* i : bitrate */
79 : )
80 : {
81 9300 : switch ( brate )
82 : {
83 : /* EVS AMR-WB IO modes */
84 0 : case SID_1k75:
85 0 : return AMRWB_IO_SID;
86 0 : case ACELP_6k60:
87 0 : return AMRWB_IO_6600;
88 0 : case ACELP_8k85:
89 0 : return AMRWB_IO_8850;
90 0 : case ACELP_12k65:
91 0 : return AMRWB_IO_1265;
92 0 : case ACELP_14k25:
93 0 : return AMRWB_IO_1425;
94 0 : case ACELP_15k85:
95 0 : return AMRWB_IO_1585;
96 0 : case ACELP_18k25:
97 0 : return AMRWB_IO_1825;
98 0 : case ACELP_19k85:
99 0 : return AMRWB_IO_1985;
100 0 : case ACELP_23k05:
101 0 : return AMRWB_IO_2305;
102 0 : case ACELP_23k85:
103 0 : return AMRWB_IO_2385;
104 9300 : default:
105 9300 : break;
106 : }
107 :
108 9300 : return -1;
109 : }
110 :
111 : /*-------------------------------------------------------------------*
112 : * rate2EVSmode()
113 : *
114 : * lookup EVS mode
115 : *-------------------------------------------------------------------*/
116 9300 : Word16 rate2EVSmode(
117 : const Word32 brate, /* i : bitrate */
118 : int16_t *is_amr_wb /* o : (flag) does the bitrate belong to AMR-WB? Can be NULL */
119 : )
120 : {
121 9300 : if ( is_amr_wb != NULL )
122 : {
123 0 : *is_amr_wb = 0;
124 : }
125 :
126 9300 : switch ( brate )
127 : {
128 : /* EVS Primary modes */
129 0 : case FRAME_NO_DATA:
130 0 : return NO_DATA_RECEIVED;
131 0 : case SID_2k40:
132 0 : return PRIMARY_SID;
133 0 : case PPP_NELP_2k80:
134 0 : return PRIMARY_2800;
135 0 : case ACELP_7k20:
136 0 : return PRIMARY_7200;
137 0 : case ACELP_8k00:
138 0 : return PRIMARY_8000;
139 0 : case ACELP_9k60:
140 0 : return PRIMARY_9600;
141 3150 : case ACELP_13k20:
142 3150 : return PRIMARY_13200;
143 0 : case ACELP_16k40:
144 0 : return PRIMARY_16400;
145 3150 : case ACELP_24k40:
146 3150 : return PRIMARY_24400;
147 0 : case ACELP_32k:
148 0 : return PRIMARY_32000;
149 0 : case ACELP_48k:
150 0 : return PRIMARY_48000;
151 3000 : case ACELP_64k:
152 3000 : return PRIMARY_64000;
153 0 : case HQ_96k:
154 0 : return PRIMARY_96000;
155 0 : case HQ_128k:
156 0 : return PRIMARY_128000;
157 0 : default:
158 0 : break;
159 : }
160 :
161 0 : if ( is_amr_wb != NULL )
162 : {
163 0 : *is_amr_wb = 1;
164 : }
165 :
166 0 : return rate2AMRWB_IOmode( brate );
167 : }
168 :
169 : /*-------------------------------------------------------------------*
170 : * ind_list_realloc()
171 : *
172 : * Re-allocate the list of indices
173 : *-------------------------------------------------------------------*/
174 :
175 0 : ivas_error ind_list_realloc(
176 : INDICE_HANDLE old_ind_list, /* i : pointer to the beginning of the old buffer of indices */
177 : const int16_t max_num_indices, /* i : new maximum number of allowed indices in the list */
178 : Encoder_Struct *st_ivas /* i : IVAS encoder structure */
179 : )
180 : {
181 : int16_t i, n, ch, n_channels, ind_list_pos, is_metadata, ivas_max_num_indices;
182 : INDICE_HANDLE new_ind_list;
183 : BSTR_ENC_HANDLE hBstr;
184 :
185 0 : if ( st_ivas == NULL )
186 : {
187 0 : return IVAS_ERR_OK;
188 : }
189 :
190 : /* get the pointer to the beginning of the old buffer of indices (either metadata or core coders) */
191 0 : if ( old_ind_list == st_ivas->ind_list_metadata )
192 : {
193 0 : is_metadata = 1;
194 0 : ivas_max_num_indices = st_ivas->ivas_max_num_indices_metadata;
195 : }
196 : else
197 : {
198 0 : is_metadata = 0;
199 0 : ivas_max_num_indices = st_ivas->ivas_max_num_indices;
200 : }
201 :
202 : /* allocate new buffer of indices */
203 0 : if ( ( new_ind_list = (INDICE_HANDLE) malloc( max_num_indices * sizeof( Indice ) ) ) == NULL )
204 : {
205 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for buffer of indices!\n" ) );
206 : }
207 :
208 : /* move indices from the old list to the new list */
209 0 : for ( i = 0; i < min( max_num_indices, ivas_max_num_indices ); i++ )
210 : {
211 0 : if ( old_ind_list[i].nb_bits > -1 )
212 : {
213 0 : new_ind_list[i].id = old_ind_list[i].id;
214 0 : new_ind_list[i].value = old_ind_list[i].value;
215 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
216 : strncpy( new_ind_list[i].function_name, old_ind_list[i].function_name, 100 );
217 : #endif
218 : }
219 0 : new_ind_list[i].nb_bits = old_ind_list[i].nb_bits;
220 : }
221 :
222 : /* reset nb_bits of all other indices to -1 */
223 0 : for ( ; i < max_num_indices; i++ )
224 : {
225 0 : new_ind_list[i].nb_bits = -1;
226 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
227 : sprintf( new_ind_list[i].function_name, "RESET in ind_list_realloc" );
228 : #endif
229 : }
230 :
231 : /* update parameters in all SCE elements */
232 0 : for ( n = 0; n < st_ivas->nSCE; n++ )
233 : {
234 : /* get the pointer to hBstr */
235 0 : if ( is_metadata )
236 : {
237 0 : hBstr = st_ivas->hSCE[n]->hMetaData;
238 : }
239 : else
240 : {
241 0 : hBstr = st_ivas->hSCE[n]->hCoreCoder[0]->hBstr;
242 : }
243 :
244 0 : if ( hBstr != NULL )
245 : {
246 : /* get the current position inside the old list */
247 0 : ind_list_pos = (int16_t) ( hBstr->ind_list - old_ind_list );
248 :
249 : /* set pointers in the new list */
250 0 : *( hBstr->ivas_ind_list_zero ) = new_ind_list;
251 0 : hBstr->ind_list = &new_ind_list[ind_list_pos];
252 :
253 : /* set the new maximum number of indices */
254 0 : *( hBstr->ivas_max_num_indices ) = max_num_indices;
255 : }
256 : }
257 :
258 : /* update parameters in all CPE elements */
259 0 : for ( n = 0; n < st_ivas->nCPE; n++ )
260 : {
261 : /* get the pointer to hBstr */
262 0 : if ( is_metadata )
263 : {
264 0 : n_channels = 1;
265 : }
266 : else
267 : {
268 0 : n_channels = CPE_CHANNELS;
269 : }
270 :
271 0 : for ( ch = 0; ch < n_channels; ch++ )
272 : {
273 0 : if ( is_metadata )
274 : {
275 0 : hBstr = st_ivas->hCPE[n]->hMetaData;
276 : }
277 : else
278 : {
279 0 : hBstr = st_ivas->hCPE[n]->hCoreCoder[ch]->hBstr;
280 : }
281 :
282 0 : if ( hBstr != NULL )
283 : {
284 : /* get the current position inside the old list */
285 0 : ind_list_pos = (int16_t) ( hBstr->ind_list - old_ind_list );
286 :
287 : /* set pointers in the new list */
288 0 : *( hBstr->ivas_ind_list_zero ) = new_ind_list;
289 0 : hBstr->ind_list = &new_ind_list[ind_list_pos];
290 :
291 : /* set the new maximum number of indices */
292 0 : *( hBstr->ivas_max_num_indices ) = max_num_indices;
293 : }
294 : }
295 : }
296 :
297 : /* free the old list */
298 0 : free( old_ind_list );
299 :
300 0 : return IVAS_ERR_OK;
301 : }
302 :
303 :
304 : /*-----------------------------------------------------------------------*
305 : * get_ivas_max_num_indices()
306 : *
307 : * Get the maximum allowed number of indices in the encoder
308 : *-----------------------------------------------------------------------*/
309 :
310 : /*! r: maximum number of indices */
311 7530 : int16_t get_ivas_max_num_indices(
312 : const IVAS_FORMAT ivas_format, /* i : IVAS format */
313 : const int32_t ivas_total_brate /* i : IVAS total bitrate */
314 : )
315 : {
316 7530 : if ( ivas_format == STEREO_FORMAT )
317 : {
318 370 : if ( ivas_total_brate <= IVAS_16k4 )
319 : {
320 88 : return 300;
321 : }
322 282 : else if ( ivas_total_brate <= IVAS_24k4 )
323 : {
324 43 : return 400;
325 : }
326 239 : else if ( ivas_total_brate <= IVAS_32k )
327 : {
328 54 : return 450;
329 : }
330 185 : else if ( ivas_total_brate <= IVAS_48k )
331 : {
332 38 : return 650;
333 : }
334 147 : else if ( ivas_total_brate <= IVAS_80k )
335 : {
336 73 : return 750;
337 : }
338 74 : else if ( ivas_total_brate <= IVAS_128k )
339 : {
340 74 : return 850;
341 : }
342 0 : else if ( ivas_total_brate <= IVAS_192k )
343 : {
344 0 : return 950;
345 : }
346 0 : else if ( ivas_total_brate <= IVAS_256k )
347 : {
348 0 : return 1350;
349 : }
350 : else
351 : {
352 0 : return 1650;
353 : }
354 : }
355 7160 : else if ( ivas_format == ISM_FORMAT || ivas_format == MONO_FORMAT )
356 : {
357 1024 : if ( ivas_total_brate <= IVAS_16k4 )
358 : {
359 30 : return 250;
360 : }
361 994 : else if ( ivas_total_brate <= IVAS_24k4 )
362 : {
363 63 : return 350;
364 : }
365 931 : else if ( ivas_total_brate <= IVAS_32k )
366 : {
367 294 : return 450;
368 : }
369 637 : else if ( ivas_total_brate <= IVAS_48k )
370 : {
371 267 : return 550;
372 : }
373 370 : else if ( ivas_total_brate <= IVAS_64k )
374 : {
375 59 : return 620;
376 : }
377 311 : else if ( ivas_total_brate <= IVAS_80k )
378 : {
379 68 : return 670;
380 : }
381 243 : else if ( ivas_total_brate <= IVAS_96k )
382 : {
383 59 : return 780;
384 : }
385 184 : else if ( ivas_total_brate <= IVAS_128k )
386 : {
387 53 : return 880;
388 : }
389 131 : else if ( ivas_total_brate <= IVAS_192k )
390 : {
391 80 : return 950;
392 : }
393 51 : else if ( ivas_total_brate <= IVAS_256k )
394 : {
395 48 : return 1100;
396 : }
397 3 : else if ( ivas_total_brate <= IVAS_384k )
398 : {
399 2 : return 1300;
400 : }
401 : else
402 : {
403 1 : return 1650;
404 : }
405 : }
406 6136 : else if ( ivas_format == SBA_FORMAT || ivas_format == SBA_ISM_FORMAT )
407 : {
408 1954 : if ( ivas_total_brate <= IVAS_16k4 )
409 : {
410 396 : return 250;
411 : }
412 1558 : else if ( ivas_total_brate <= IVAS_24k4 )
413 : {
414 148 : return 350;
415 : }
416 1410 : else if ( ivas_total_brate <= IVAS_32k )
417 : {
418 167 : return 400;
419 : }
420 1243 : else if ( ivas_total_brate <= IVAS_48k )
421 : {
422 84 : return 650;
423 : }
424 1159 : else if ( ivas_total_brate <= IVAS_80k )
425 : {
426 301 : return 750;
427 : }
428 858 : else if ( ivas_total_brate <= IVAS_128k )
429 : {
430 259 : return 1020;
431 : }
432 599 : else if ( ivas_total_brate <= IVAS_160k )
433 : {
434 85 : return 1160;
435 : }
436 514 : else if ( ivas_total_brate <= IVAS_192k )
437 : {
438 160 : return 1220;
439 : }
440 354 : else if ( ivas_total_brate <= IVAS_256k )
441 : {
442 110 : return 1300;
443 : }
444 244 : else if ( ivas_total_brate <= IVAS_384k )
445 : {
446 119 : return 1720;
447 : }
448 : else
449 : {
450 125 : return 2000;
451 : }
452 : }
453 4182 : else if ( ivas_format == MASA_FORMAT )
454 : {
455 1344 : if ( ivas_total_brate <= IVAS_16k4 )
456 : {
457 311 : return 300;
458 : }
459 1033 : else if ( ivas_total_brate <= IVAS_32k )
460 : {
461 241 : return 400;
462 : }
463 792 : else if ( ivas_total_brate <= IVAS_48k )
464 : {
465 82 : return 650;
466 : }
467 710 : else if ( ivas_total_brate <= IVAS_80k )
468 : {
469 254 : return 750;
470 : }
471 456 : else if ( ivas_total_brate <= IVAS_160k )
472 : {
473 260 : return 850;
474 : }
475 196 : else if ( ivas_total_brate <= IVAS_192k )
476 : {
477 60 : return 950;
478 : }
479 136 : else if ( ivas_total_brate <= IVAS_256k )
480 : {
481 31 : return 1150;
482 : }
483 105 : else if ( ivas_total_brate <= IVAS_384k )
484 : {
485 53 : return 1450;
486 : }
487 : else
488 : {
489 52 : return 1650;
490 : }
491 : }
492 2838 : else if ( ivas_format == MASA_ISM_FORMAT )
493 : {
494 1678 : if ( ivas_total_brate <= IVAS_16k4 )
495 : {
496 319 : return 300;
497 : }
498 1359 : else if ( ivas_total_brate <= IVAS_32k )
499 : {
500 375 : return 400;
501 : }
502 984 : else if ( ivas_total_brate <= IVAS_48k )
503 : {
504 186 : return 650;
505 : }
506 798 : else if ( ivas_total_brate <= IVAS_80k )
507 : {
508 327 : return 750;
509 : }
510 471 : else if ( ivas_total_brate <= IVAS_160k )
511 : {
512 229 : return 1150;
513 : }
514 242 : else if ( ivas_total_brate <= IVAS_192k )
515 : {
516 65 : return 1250;
517 : }
518 177 : else if ( ivas_total_brate <= IVAS_256k )
519 : {
520 67 : return 1400;
521 : }
522 110 : else if ( ivas_total_brate <= IVAS_384k )
523 : {
524 59 : return 1650;
525 : }
526 : else
527 : {
528 51 : return 1850;
529 : }
530 : }
531 1160 : else if ( ivas_format == MC_FORMAT )
532 : {
533 1160 : if ( ivas_total_brate <= IVAS_16k4 )
534 : {
535 130 : return 250;
536 : }
537 1030 : else if ( ivas_total_brate <= IVAS_24k4 )
538 : {
539 67 : return 350;
540 : }
541 963 : else if ( ivas_total_brate <= IVAS_32k )
542 : {
543 49 : return 400;
544 : }
545 914 : else if ( ivas_total_brate <= IVAS_48k )
546 : {
547 195 : return 650;
548 : }
549 719 : else if ( ivas_total_brate <= IVAS_64k )
550 : {
551 103 : return 750;
552 : }
553 616 : else if ( ivas_total_brate <= IVAS_80k )
554 : {
555 76 : return 850;
556 : }
557 540 : else if ( ivas_total_brate <= IVAS_128k )
558 : {
559 175 : return 1150;
560 : }
561 365 : else if ( ivas_total_brate <= IVAS_160k )
562 : {
563 101 : return 1420;
564 : }
565 264 : else if ( ivas_total_brate <= IVAS_256k )
566 : {
567 161 : return 2120;
568 : }
569 103 : else if ( ivas_total_brate <= IVAS_384k )
570 : {
571 48 : return 2250;
572 : }
573 : else
574 : {
575 55 : return 2450;
576 : }
577 : }
578 :
579 0 : return 2450;
580 : }
581 :
582 :
583 : /*-----------------------------------------------------------------------*
584 : * get_BWE_max_num_indices()
585 : *
586 : * Get the maximum number of indices in the BWE
587 : *-----------------------------------------------------------------------*/
588 :
589 : /*! r: maximum number of indices */
590 3791 : int16_t get_BWE_max_num_indices(
591 : const int32_t extl_brate /* i : extensiona layer bitrate */
592 : )
593 : {
594 : /* set the maximum number of indices in the BWE */
595 3791 : if ( extl_brate < SWB_BWE_16k )
596 : {
597 3791 : return 30;
598 : }
599 : else
600 : {
601 0 : return 150;
602 : }
603 : }
604 :
605 :
606 : /*-----------------------------------------------------------------------*
607 : * get_ivas_max_num_indices_metadata()
608 : *
609 : * Set the maximum allowed number of metadata indices in the list
610 : *-----------------------------------------------------------------------*/
611 :
612 : /*! r: maximum number of indices */
613 7530 : int16_t get_ivas_max_num_indices_metadata(
614 : const IVAS_FORMAT ivas_format, /* i : IVAS format */
615 : const int32_t ivas_total_brate /* i : IVAS total bitrate */
616 : )
617 : {
618 : /* set the maximum required number of metadata indices */
619 7530 : if ( ivas_format == MONO_FORMAT )
620 : {
621 3 : return 0;
622 : }
623 7527 : else if ( ivas_format == STEREO_FORMAT )
624 : {
625 370 : if ( ivas_total_brate <= IVAS_16k4 )
626 : {
627 88 : return 60;
628 : }
629 : else
630 : {
631 282 : return 80;
632 : }
633 : }
634 7157 : else if ( ivas_format == ISM_FORMAT )
635 : {
636 1021 : if ( ivas_total_brate <= IVAS_16k4 )
637 : {
638 29 : return 20;
639 : }
640 992 : else if ( ivas_total_brate <= IVAS_32k )
641 : {
642 356 : return 65;
643 : }
644 : else
645 : {
646 636 : return 80;
647 : }
648 : }
649 6136 : else if ( ivas_format == SBA_FORMAT || ivas_format == SBA_ISM_FORMAT )
650 : {
651 1954 : if ( ivas_total_brate <= IVAS_16k4 )
652 : {
653 396 : return 100;
654 : }
655 1558 : else if ( ivas_total_brate <= IVAS_24k4 )
656 : {
657 148 : return 200;
658 : }
659 1410 : else if ( ivas_total_brate <= IVAS_32k )
660 : {
661 167 : return 300;
662 : }
663 1243 : else if ( ivas_total_brate <= IVAS_192k )
664 : {
665 889 : return 500;
666 : }
667 354 : else if ( ivas_total_brate <= IVAS_256k )
668 : {
669 110 : return 1050;
670 : }
671 244 : else if ( ivas_total_brate <= IVAS_384k )
672 : {
673 119 : return 2000;
674 : }
675 : else
676 : {
677 125 : return 2500;
678 : }
679 : }
680 4182 : else if ( ivas_format == MASA_FORMAT )
681 : {
682 1344 : if ( ivas_total_brate <= IVAS_16k4 )
683 : {
684 311 : return 80;
685 : }
686 1033 : else if ( ivas_total_brate <= IVAS_32k )
687 : {
688 241 : return 125;
689 : }
690 792 : else if ( ivas_total_brate <= IVAS_48k )
691 : {
692 82 : return 205;
693 : }
694 710 : else if ( ivas_total_brate <= IVAS_96k )
695 : {
696 375 : return 240;
697 : }
698 335 : else if ( ivas_total_brate <= IVAS_128k )
699 : {
700 113 : return 305;
701 : }
702 222 : else if ( ivas_total_brate <= IVAS_160k )
703 : {
704 26 : return 425;
705 : }
706 196 : else if ( ivas_total_brate <= IVAS_192k )
707 : {
708 60 : return 630;
709 : }
710 136 : else if ( ivas_total_brate <= IVAS_256k )
711 : {
712 31 : return 850;
713 : }
714 105 : else if ( ivas_total_brate <= IVAS_384k )
715 : {
716 53 : return 1000;
717 : }
718 : else
719 : {
720 52 : return 1750;
721 : }
722 : }
723 2838 : else if ( ivas_format == MASA_ISM_FORMAT )
724 : {
725 1678 : if ( ivas_total_brate <= IVAS_16k4 )
726 : {
727 319 : return 80;
728 : }
729 1359 : else if ( ivas_total_brate <= IVAS_32k )
730 : {
731 375 : return 125 + 100;
732 : }
733 984 : else if ( ivas_total_brate <= IVAS_48k )
734 : {
735 186 : return 205 + 100;
736 : }
737 798 : else if ( ivas_total_brate <= IVAS_96k )
738 : {
739 420 : return 240 + 150;
740 : }
741 378 : else if ( ivas_total_brate <= IVAS_128k )
742 : {
743 71 : return 305 + 30;
744 : }
745 307 : else if ( ivas_total_brate <= IVAS_160k )
746 : {
747 65 : return 425 + 30;
748 : }
749 242 : else if ( ivas_total_brate <= IVAS_192k )
750 : {
751 65 : return 630 + 30;
752 : }
753 177 : else if ( ivas_total_brate <= IVAS_256k )
754 : {
755 67 : return 850 + 30;
756 : }
757 110 : else if ( ivas_total_brate <= IVAS_384k )
758 : {
759 59 : return 1000 + 30;
760 : }
761 : else
762 : {
763 51 : return 1750 + 30;
764 : }
765 : }
766 1160 : else if ( ivas_format == MC_FORMAT )
767 : {
768 1160 : if ( ivas_total_brate <= IVAS_13k2 )
769 : {
770 67 : return 80;
771 : }
772 1093 : else if ( ivas_total_brate <= IVAS_24k4 )
773 : {
774 130 : return 100;
775 : }
776 963 : else if ( ivas_total_brate <= IVAS_64k )
777 : {
778 347 : return 210;
779 : }
780 616 : else if ( ivas_total_brate <= IVAS_96k )
781 : {
782 142 : return 220;
783 : }
784 : else
785 : {
786 474 : return 300;
787 : }
788 : }
789 :
790 0 : return 50;
791 : }
792 :
793 : /*-------------------------------------------------------------------*
794 : * move_indices()
795 : *
796 : * Move indices inside the buffer or among two buffers
797 : *-------------------------------------------------------------------*/
798 :
799 3791 : void move_indices(
800 : INDICE_HANDLE old_ind_list, /* i/o: old location of indices */
801 : INDICE_HANDLE new_ind_list, /* i/o: new location of indices */
802 : const int16_t nb_indices /* i : number of moved indices */
803 : )
804 : {
805 : int16_t i;
806 :
807 3791 : if ( new_ind_list < old_ind_list )
808 : {
809 15354 : for ( i = 0; i < nb_indices; i++ )
810 : {
811 11610 : new_ind_list[i].id = old_ind_list[i].id;
812 11610 : new_ind_list[i].value = old_ind_list[i].value;
813 11610 : new_ind_list[i].nb_bits = old_ind_list[i].nb_bits;
814 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
815 : strncpy( new_ind_list[i].function_name, old_ind_list[i].function_name, 100 );
816 : #endif
817 :
818 11610 : old_ind_list[i].nb_bits = -1;
819 : }
820 : }
821 47 : else if ( new_ind_list > old_ind_list )
822 : {
823 188 : for ( i = nb_indices - 1; i >= 0; i-- )
824 : {
825 141 : new_ind_list[i].id = old_ind_list[i].id;
826 141 : new_ind_list[i].value = old_ind_list[i].value;
827 141 : new_ind_list[i].nb_bits = old_ind_list[i].nb_bits;
828 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
829 : strncpy( new_ind_list[i].function_name, old_ind_list[i].function_name, 100 );
830 : #endif
831 :
832 141 : old_ind_list[i].nb_bits = -1;
833 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
834 : sprintf( old_ind_list[i].function_name, "RESET in move_indices" );
835 : #endif
836 : }
837 : }
838 :
839 3791 : return;
840 : }
841 :
842 :
843 : /*-------------------------------------------------------------------*
844 : * check_ind_list_limits()
845 : *
846 : * Check, if the maximum number of indices has been reached -> reallocate
847 : * Check, if we will not overwrite an existing indice -> adjust the location
848 : *-------------------------------------------------------------------*/
849 :
850 247677615 : ivas_error check_ind_list_limits(
851 : BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */
852 : )
853 : {
854 : Indice *ivas_ind_list_zero, *ivas_ind_list_last;
855 : ivas_error error;
856 :
857 247677615 : error = IVAS_ERR_OK;
858 247677615 : ivas_ind_list_zero = *( hBstr->ivas_ind_list_zero );
859 :
860 : /* check, if the maximum number of indices has been reached and re-allocate the buffer */
861 : /* the re-allocation can be avoided by increasing the limits in get_ivas_max_num_indices() or get_ivas_max_num_indices_metadata() */
862 247677615 : if ( ( &hBstr->ind_list[hBstr->nb_ind_tot] - ivas_ind_list_zero ) >= *( hBstr->ivas_max_num_indices ) )
863 : {
864 : #ifdef DEBUGGING
865 : fprintf( stderr, "Warning: The maximum number of indices %d has been exceeded in frame %d! Increase the limits in get_ivas_max_num_indices() or get_max_num_indices_metadata().\n", *( hBstr->ivas_max_num_indices ), frame );
866 : #endif
867 :
868 : /* reallocate the buffer of indices with increased limit */
869 0 : if ( ( error = ind_list_realloc( *hBstr->ivas_ind_list_zero, *( hBstr->ivas_max_num_indices ) + STEP_MAX_NUM_INDICES, hBstr->st_ivas ) ) != IVAS_ERR_OK )
870 : {
871 0 : return error;
872 : }
873 : }
874 :
875 : /* check, if we will not overwrite an existing indice */
876 247677615 : if ( hBstr->ind_list[hBstr->nb_ind_tot].nb_bits > 0 )
877 : {
878 0 : if ( hBstr->nb_ind_tot == 0 )
879 : {
880 : #ifdef DEBUGGING
881 : fprintf( stderr, "Warning: Trying to overwrite an existing indice ID = %d in frame %d!\n", hBstr->ind_list[hBstr->nb_ind_tot].id, frame );
882 : #endif
883 : /* move the pointer to the next available empty slot */
884 0 : ivas_ind_list_last = &ivas_ind_list_zero[*( hBstr->ivas_max_num_indices )];
885 0 : while ( hBstr->ind_list[0].nb_bits > 0 && hBstr->ind_list < ivas_ind_list_last )
886 : {
887 0 : hBstr->ind_list++;
888 : }
889 :
890 0 : if ( hBstr->ind_list >= ivas_ind_list_last )
891 : {
892 : #ifdef DEBUGGING
893 : fprintf( stderr, "Warning: The maximum number of indices %d has been exceeded in frame %d! Increase the limits in get_ivas_max_num_indices() or get_max_num_indices_metadata().\n", *( hBstr->ivas_max_num_indices ), frame );
894 : #endif
895 :
896 : /* no available empty slot -> need to re-allocate the buffer */
897 0 : if ( ( error = ind_list_realloc( *hBstr->ivas_ind_list_zero, *( hBstr->ivas_max_num_indices ) + STEP_MAX_NUM_INDICES, hBstr->st_ivas ) ) != IVAS_ERR_OK )
898 : {
899 0 : return error;
900 : }
901 : }
902 : }
903 : else
904 : {
905 : #ifdef DEBUGGING
906 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Buffer of indices corrupted in frame %d! Attempt to overwrite indice ID = %d (value: %d, bits: %d)!\n", frame, hBstr->ind_list[hBstr->nb_ind_tot].id, hBstr->ind_list[hBstr->nb_ind_tot].value, hBstr->ind_list[hBstr->nb_ind_tot].nb_bits );
907 : #else
908 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Buffer of indices corrupted! Attempt to overwrite indice ID = %d (value: %d, bits: %d)!\n", hBstr->ind_list[hBstr->nb_ind_tot].id, hBstr->ind_list[hBstr->nb_ind_tot].value, hBstr->ind_list[hBstr->nb_ind_tot].nb_bits );
909 : #endif
910 : }
911 : }
912 :
913 247677615 : return error;
914 : }
915 :
916 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
917 : const char *named_indices_table[] = {
918 : "IND_IVAS_FORMAT",
919 : "IND_SMODE_OMASA",
920 : "IND_SMODE",
921 : "IND_SID_TYPE",
922 : "IND_BWIDTH",
923 : "IND_CORE",
924 : "IND_PPP_NELP_MODE",
925 : "IND_ACELP_16KHZ",
926 : "IND_ACELP_SIGNALLING",
927 : "IND_SHARP_FLAG",
928 : "IND_MDCT_CORE",
929 : "IND_TCX_CORE",
930 : "IND_BWE_FLAG",
931 : "IND_HQ_SWITCHING_FLG",
932 : "IND_LAST_L_FRAME",
933 : "IND_VAD_FLAG",
934 : "IND_HQ_BWIDTH",
935 : "IND_TC_SUBFR",
936 : "IND_TC_SUBFR",
937 : "IND_TC_SUBFR",
938 : "IND_TC_SUBFR",
939 : "IND_GSC_IVAS_SP",
940 : "IND_LSF_PREDICTOR_SELECT_BIT",
941 : "IND_LSF",
942 : "IND_LSF",
943 : "IND_LSF",
944 : "IND_LSF",
945 : "IND_LSF",
946 : "IND_LSF",
947 : "IND_LSF",
948 : "IND_LSF",
949 : "IND_LSF",
950 : "IND_LSF",
951 : "IND_LSF",
952 : "IND_LSF",
953 : "IND_LSF",
954 : "IND_LSF",
955 : "IND_LSF",
956 : "IND_LSF",
957 : "IND_LSF",
958 : "IND_MID_FRAME_LSF_INDEX",
959 : "IND_ISF_0_0",
960 : "IND_ISF_0_1",
961 : "IND_ISF_0_2",
962 : "IND_ISF_0_3",
963 : "IND_ISF_0_4",
964 : "IND_ISF_1_0",
965 : "IND_ISF_1_1",
966 : "IND_ISF_1_2",
967 : "IND_ISF_1_3",
968 : "IND_ISF_1_4",
969 : "IND_IC_LSF_PRED",
970 : "IND_GSC_ATTACK",
971 : "IND_GSC_SWB_SPEECH",
972 : "IND_NOISE_LEVEL",
973 : "IND_HF_NOISE",
974 : "IND_PIT_CONTR_IDX",
975 : "IND_FEC_CLAS",
976 : "IND_FEC_ENR",
977 : "IND_FEC_POS",
978 : "IND_ES_PRED",
979 : "IND_HARM_FLAG_ACELP",
980 : "IND_ALG_CDBK_4T64_2_24KBIT",
981 : "IND_ALG_CDBK_4T64_2_24KBIT",
982 : "IND_ALG_CDBK_4T64_2_24KBIT",
983 : "IND_ALG_CDBK_4T64_2_24KBIT",
984 : "IND_ALG_CDBK_4T64_2_24KBIT",
985 : "IND_ALG_CDBK_4T64_2_24KBIT",
986 : "IND_ALG_CDBK_4T64_2_24KBIT",
987 : "IND_ALG_CDBK_4T64_2_24KBIT",
988 : "IND_ALG_CDBK_4T64_2_24KBIT",
989 : "IND_ALG_CDBK_4T64_2_24KBIT",
990 : "IND_ALG_CDBK_4T64_2_24KBIT",
991 : "IND_ALG_CDBK_4T64_2_24KBIT",
992 : "IND_ALG_CDBK_4T64_2_24KBIT",
993 : "IND_ALG_CDBK_4T64_2_24KBIT",
994 : "IND_ALG_CDBK_4T64_2_24KBIT",
995 : "IND_ALG_CDBK_4T64_2_24KBIT",
996 : "IND_ALG_CDBK_4T64_2_24KBIT",
997 : "IND_ALG_CDBK_4T64_2_24KBIT",
998 : "IND_ALG_CDBK_4T64_2_24KBIT",
999 : "IND_ALG_CDBK_4T64_2_24KBIT",
1000 : "IND_ALG_CDBK_4T64_2_24KBIT",
1001 : "IND_ALG_CDBK_4T64_2_24KBIT",
1002 : "IND_ALG_CDBK_4T64_2_24KBIT",
1003 : "IND_ALG_CDBK_4T64_2_24KBIT",
1004 : "IND_ALG_CDBK_4T64_2_24KBIT",
1005 : "IND_ALG_CDBK_4T64_2_24KBIT",
1006 : "IND_ALG_CDBK_4T64_2_24KBIT",
1007 : "IND_ALG_CDBK_4T64_2_24KBIT",
1008 : "IND_ALG_CDBK_4T64_2_24KBIT",
1009 : "IND_ALG_CDBK_4T64_2_24KBIT",
1010 : "IND_ALG_CDBK_4T64_2_24KBIT",
1011 : "IND_ALG_CDBK_4T64_2_24KBIT",
1012 : "IND_ALG_CDBK_4T64_2_24KBIT",
1013 : "IND_ALG_CDBK_4T64_2_24KBIT",
1014 : "IND_ALG_CDBK_4T64_2_24KBIT",
1015 : "IND_ALG_CDBK_4T64_2_24KBIT",
1016 : "IND_ALG_CDBK_4T64_2_24KBIT",
1017 : "IND_ALG_CDBK_4T64_2_24KBIT",
1018 : "IND_ALG_CDBK_4T64_2_24KBIT",
1019 : "IND_ALG_CDBK_4T64_2_24KBIT",
1020 : "TAG_ALG_CDBK_4T64_24KBIT_END",
1021 : "IND_HF_GAIN_MODIFICATION",
1022 : "IND_HF_GAIN_MODIFICATION",
1023 : "IND_HF_GAIN_MODIFICATION",
1024 : "IND_HF_GAIN_MODIFICATION",
1025 : "IND_HF_GAIN_MODIFICATION",
1026 : "IND_HF_GAIN_MODIFICATION",
1027 : "IND_HF_GAIN_MODIFICATION",
1028 : "IND_HF_GAIN_MODIFICATION",
1029 : "IND_HF_GAIN_MODIFICATION",
1030 : "IND_HF_GAIN_MODIFICATION",
1031 : "IND_HF_GAIN_MODIFICATION",
1032 : "IND_HF_GAIN_MODIFICATION",
1033 : "IND_HF_GAIN_MODIFICATION",
1034 : "IND_HF_GAIN_MODIFICATION",
1035 : "IND_HF_GAIN_MODIFICATION",
1036 : "IND_HF_GAIN_MODIFICATION",
1037 : "IND_HF_GAIN_MODIFICATION",
1038 : "IND_HF_GAIN_MODIFICATION",
1039 : "IND_HF_GAIN_MODIFICATION",
1040 : "IND_HF_GAIN_MODIFICATION",
1041 : "IND_HF_GAIN_MODIFICATION",
1042 : "IND_HF_GAIN_MODIFICATION",
1043 : "IND_HF_GAIN_MODIFICATION",
1044 : "IND_HF_GAIN_MODIFICATION",
1045 : "IND_HF_GAIN_MODIFICATION",
1046 : "IND_HF_GAIN_MODIFICATION",
1047 : "IND_HF_GAIN_MODIFICATION",
1048 : "IND_HF_GAIN_MODIFICATION",
1049 : "IND_HF_GAIN_MODIFICATION",
1050 : "IND_HF_GAIN_MODIFICATION",
1051 : "IND_HF_GAIN_MODIFICATION",
1052 : "IND_HF_GAIN_MODIFICATION",
1053 : "IND_HF_GAIN_MODIFICATION",
1054 : "IND_HF_GAIN_MODIFICATION",
1055 : "IND_HF_GAIN_MODIFICATION",
1056 : "IND_HF_GAIN_MODIFICATION",
1057 : "IND_HF_GAIN_MODIFICATION",
1058 : "IND_HF_GAIN_MODIFICATION",
1059 : "IND_HF_GAIN_MODIFICATION",
1060 : "IND_HF_GAIN_MODIFICATION",
1061 : "IND_HF_GAIN_MODIFICATION",
1062 : "IND_HF_GAIN_MODIFICATION",
1063 : "IND_HF_GAIN_MODIFICATION",
1064 : "IND_HF_GAIN_MODIFICATION",
1065 : "IND_HF_GAIN_MODIFICATION",
1066 : "IND_HF_GAIN_MODIFICATION",
1067 : "IND_HF_GAIN_MODIFICATION",
1068 : "IND_HF_GAIN_MODIFICATION",
1069 : "IND_HF_GAIN_MODIFICATION",
1070 : "IND_HF_GAIN_MODIFICATION",
1071 : "IND_HF_GAIN_MODIFICATION",
1072 : "IND_HF_GAIN_MODIFICATION",
1073 : "IND_HF_GAIN_MODIFICATION",
1074 : "IND_HF_GAIN_MODIFICATION",
1075 : "IND_HF_GAIN_MODIFICATION",
1076 : "IND_HF_GAIN_MODIFICATION",
1077 : "IND_HF_GAIN_MODIFICATION",
1078 : "IND_HF_GAIN_MODIFICATION",
1079 : "IND_HF_GAIN_MODIFICATION",
1080 : "IND_HF_GAIN_MODIFICATION",
1081 : "IND_HF_GAIN_MODIFICATION",
1082 : "IND_HF_GAIN_MODIFICATION",
1083 : "IND_HF_GAIN_MODIFICATION",
1084 : "IND_HF_GAIN_MODIFICATION",
1085 : "IND_HF_GAIN_MODIFICATION",
1086 : "IND_HF_GAIN_MODIFICATION",
1087 : "IND_HF_GAIN_MODIFICATION",
1088 : "IND_HF_GAIN_MODIFICATION",
1089 : "IND_HF_GAIN_MODIFICATION",
1090 : "IND_HF_GAIN_MODIFICATION",
1091 : "IND_HF_GAIN_MODIFICATION",
1092 : "IND_HF_GAIN_MODIFICATION",
1093 : "IND_HF_GAIN_MODIFICATION",
1094 : "IND_HF_GAIN_MODIFICATION",
1095 : "IND_HF_GAIN_MODIFICATION",
1096 : "IND_HF_GAIN_MODIFICATION",
1097 : "IND_HF_GAIN_MODIFICATION",
1098 : "IND_HF_GAIN_MODIFICATION",
1099 : "IND_HF_GAIN_MODIFICATION",
1100 : "IND_HF_GAIN_MODIFICATION",
1101 : "IND_HF_GAIN_MODIFICATION",
1102 : "IND_HF_GAIN_MODIFICATION",
1103 : "IND_HF_GAIN_MODIFICATION",
1104 : "IND_HF_GAIN_MODIFICATION",
1105 : "IND_HF_GAIN_MODIFICATION",
1106 : "IND_HF_GAIN_MODIFICATION",
1107 : "IND_HF_GAIN_MODIFICATION",
1108 : "IND_HF_GAIN_MODIFICATION",
1109 : "IND_HF_GAIN_MODIFICATION",
1110 : "IND_HF_GAIN_MODIFICATION",
1111 : "IND_HF_GAIN_MODIFICATION",
1112 : "IND_HF_GAIN_MODIFICATION",
1113 : "IND_HF_GAIN_MODIFICATION",
1114 : "IND_HF_GAIN_MODIFICATION",
1115 : "IND_HF_GAIN_MODIFICATION",
1116 : "IND_HF_GAIN_MODIFICATION",
1117 : "IND_HF_GAIN_MODIFICATION",
1118 : "IND_HF_GAIN_MODIFICATION",
1119 : "IND_HF_GAIN_MODIFICATION",
1120 : "IND_HF_GAIN_MODIFICATION",
1121 : "IND_HF_GAIN_MODIFICATION",
1122 : "IND_HF_GAIN_MODIFICATION",
1123 : "IND_HF_GAIN_MODIFICATION",
1124 : "IND_HF_GAIN_MODIFICATION",
1125 : "IND_HF_GAIN_MODIFICATION",
1126 : "IND_HF_GAIN_MODIFICATION",
1127 : "IND_HF_GAIN_MODIFICATION",
1128 : "IND_HF_GAIN_MODIFICATION",
1129 : "IND_HF_GAIN_MODIFICATION",
1130 : "IND_HF_GAIN_MODIFICATION",
1131 : "IND_HF_GAIN_MODIFICATION",
1132 : "IND_HF_GAIN_MODIFICATION",
1133 : "IND_HF_GAIN_MODIFICATION",
1134 : "IND_HF_GAIN_MODIFICATION",
1135 : "IND_HF_GAIN_MODIFICATION",
1136 : "IND_HF_GAIN_MODIFICATION",
1137 : "IND_HF_GAIN_MODIFICATION",
1138 : "IND_HF_GAIN_MODIFICATION",
1139 : "IND_HF_GAIN_MODIFICATION",
1140 : "IND_HF_GAIN_MODIFICATION",
1141 : "IND_HF_GAIN_MODIFICATION",
1142 : "IND_HF_GAIN_MODIFICATION",
1143 : "IND_HF_GAIN_MODIFICATION",
1144 : "IND_HF_GAIN_MODIFICATION",
1145 : "IND_HF_GAIN_MODIFICATION",
1146 : "IND_HF_GAIN_MODIFICATION",
1147 : "IND_HF_GAIN_MODIFICATION",
1148 : "IND_HF_GAIN_MODIFICATION",
1149 : "IND_HF_GAIN_MODIFICATION",
1150 : "IND_HF_GAIN_MODIFICATION",
1151 : "IND_HF_GAIN_MODIFICATION",
1152 : "IND_HF_GAIN_MODIFICATION",
1153 : "IND_HF_GAIN_MODIFICATION",
1154 : "IND_HF_GAIN_MODIFICATION",
1155 : "IND_HF_GAIN_MODIFICATION",
1156 : "IND_HF_GAIN_MODIFICATION",
1157 : "IND_HF_GAIN_MODIFICATION",
1158 : "IND_HF_GAIN_MODIFICATION",
1159 : "IND_HF_GAIN_MODIFICATION",
1160 : "IND_HF_GAIN_MODIFICATION",
1161 : "IND_HF_GAIN_MODIFICATION",
1162 : "IND_HF_GAIN_MODIFICATION",
1163 : "IND_HF_GAIN_MODIFICATION",
1164 : "IND_HF_GAIN_MODIFICATION",
1165 : "IND_HF_GAIN_MODIFICATION",
1166 : "IND_HF_GAIN_MODIFICATION",
1167 : "IND_HF_GAIN_MODIFICATION",
1168 : "IND_HF_GAIN_MODIFICATION",
1169 : "IND_HF_GAIN_MODIFICATION",
1170 : "IND_HF_GAIN_MODIFICATION",
1171 : "IND_HF_GAIN_MODIFICATION",
1172 : "IND_HF_GAIN_MODIFICATION",
1173 : "IND_HF_GAIN_MODIFICATION",
1174 : "IND_HF_GAIN_MODIFICATION",
1175 : "IND_HF_GAIN_MODIFICATION",
1176 : "IND_HF_GAIN_MODIFICATION",
1177 : "IND_HF_GAIN_MODIFICATION",
1178 : "IND_HF_GAIN_MODIFICATION",
1179 : "IND_HF_GAIN_MODIFICATION",
1180 : "IND_HF_GAIN_MODIFICATION",
1181 : "IND_HF_GAIN_MODIFICATION",
1182 : "IND_HF_GAIN_MODIFICATION",
1183 : "IND_HF_GAIN_MODIFICATION",
1184 : "IND_HF_GAIN_MODIFICATION",
1185 : "IND_HF_GAIN_MODIFICATION",
1186 : "IND_HF_GAIN_MODIFICATION",
1187 : "IND_HF_GAIN_MODIFICATION",
1188 : "IND_HF_GAIN_MODIFICATION",
1189 : "IND_HF_GAIN_MODIFICATION",
1190 : "IND_HF_GAIN_MODIFICATION",
1191 : "IND_HF_GAIN_MODIFICATION",
1192 : "IND_HF_GAIN_MODIFICATION",
1193 : "IND_HF_GAIN_MODIFICATION",
1194 : "IND_HF_GAIN_MODIFICATION",
1195 : "IND_HF_GAIN_MODIFICATION",
1196 : "IND_HF_GAIN_MODIFICATION",
1197 : "IND_HF_GAIN_MODIFICATION",
1198 : "IND_HF_GAIN_MODIFICATION",
1199 : "IND_HF_GAIN_MODIFICATION",
1200 : "IND_HF_GAIN_MODIFICATION",
1201 : "IND_HF_GAIN_MODIFICATION",
1202 : "IND_HF_GAIN_MODIFICATION",
1203 : "IND_HF_GAIN_MODIFICATION",
1204 : "IND_HF_GAIN_MODIFICATION",
1205 : "IND_HF_GAIN_MODIFICATION",
1206 : "IND_HF_GAIN_MODIFICATION",
1207 : "IND_HF_GAIN_MODIFICATION",
1208 : "IND_HF_GAIN_MODIFICATION",
1209 : "IND_HF_GAIN_MODIFICATION",
1210 : "IND_HF_GAIN_MODIFICATION",
1211 : "IND_HF_GAIN_MODIFICATION",
1212 : "IND_HF_GAIN_MODIFICATION",
1213 : "IND_HF_GAIN_MODIFICATION",
1214 : "IND_HF_GAIN_MODIFICATION",
1215 : "IND_HF_GAIN_MODIFICATION",
1216 : "IND_HF_GAIN_MODIFICATION",
1217 : "IND_HF_GAIN_MODIFICATION",
1218 : "IND_HF_GAIN_MODIFICATION",
1219 : "IND_HF_GAIN_MODIFICATION",
1220 : "IND_HF_GAIN_MODIFICATION",
1221 : "IND_HF_GAIN_MODIFICATION",
1222 : "IND_HF_GAIN_MODIFICATION",
1223 : "IND_HF_GAIN_MODIFICATION",
1224 : "IND_HF_GAIN_MODIFICATION",
1225 : "IND_HF_GAIN_MODIFICATION",
1226 : "IND_HF_GAIN_MODIFICATION",
1227 : "IND_HF_GAIN_MODIFICATION",
1228 : "IND_HF_GAIN_MODIFICATION",
1229 : "IND_HF_GAIN_MODIFICATION",
1230 : "IND_HF_GAIN_MODIFICATION",
1231 : "IND_HF_GAIN_MODIFICATION",
1232 : "IND_HF_GAIN_MODIFICATION",
1233 : "IND_HF_GAIN_MODIFICATION",
1234 : "IND_HF_GAIN_MODIFICATION",
1235 : "IND_HF_GAIN_MODIFICATION",
1236 : "IND_HF_GAIN_MODIFICATION",
1237 : "IND_HF_GAIN_MODIFICATION",
1238 : "IND_HF_GAIN_MODIFICATION",
1239 : "IND_HF_GAIN_MODIFICATION",
1240 : "IND_HF_GAIN_MODIFICATION",
1241 : "IND_HF_GAIN_MODIFICATION",
1242 : "IND_HF_GAIN_MODIFICATION",
1243 : "IND_HF_GAIN_MODIFICATION",
1244 : "IND_HF_GAIN_MODIFICATION",
1245 : "IND_HF_GAIN_MODIFICATION",
1246 : "IND_HF_GAIN_MODIFICATION",
1247 : "IND_HF_GAIN_MODIFICATION",
1248 : "IND_HF_GAIN_MODIFICATION",
1249 : "IND_HF_GAIN_MODIFICATION",
1250 : "IND_HF_GAIN_MODIFICATION",
1251 : "IND_HF_GAIN_MODIFICATION",
1252 : "IND_HF_GAIN_MODIFICATION",
1253 : "IND_HF_GAIN_MODIFICATION",
1254 : "IND_HF_GAIN_MODIFICATION",
1255 : "IND_HF_GAIN_MODIFICATION",
1256 : "IND_HF_GAIN_MODIFICATION",
1257 : "IND_HF_GAIN_MODIFICATION",
1258 : "IND_HF_GAIN_MODIFICATION",
1259 : "IND_HF_GAIN_MODIFICATION",
1260 : "IND_HF_GAIN_MODIFICATION",
1261 : "IND_HF_GAIN_MODIFICATION",
1262 : "IND_HF_GAIN_MODIFICATION",
1263 : "IND_HF_GAIN_MODIFICATION",
1264 : "IND_HF_GAIN_MODIFICATION",
1265 : "IND_HF_GAIN_MODIFICATION",
1266 : "IND_HF_GAIN_MODIFICATION",
1267 : "IND_HF_GAIN_MODIFICATION",
1268 : "IND_HF_GAIN_MODIFICATION",
1269 : "IND_HF_GAIN_MODIFICATION",
1270 : "IND_HF_GAIN_MODIFICATION",
1271 : "IND_HF_GAIN_MODIFICATION",
1272 : "IND_HF_GAIN_MODIFICATION",
1273 : "IND_HF_GAIN_MODIFICATION",
1274 : "IND_HF_GAIN_MODIFICATION",
1275 : "IND_HF_GAIN_MODIFICATION",
1276 : "IND_HF_GAIN_MODIFICATION",
1277 : "IND_HF_GAIN_MODIFICATION",
1278 : "IND_HF_GAIN_MODIFICATION",
1279 : "IND_HF_GAIN_MODIFICATION",
1280 : "IND_HF_GAIN_MODIFICATION",
1281 : "IND_HF_GAIN_MODIFICATION",
1282 : "IND_HF_GAIN_MODIFICATION",
1283 : "IND_HF_GAIN_MODIFICATION",
1284 : "IND_HF_GAIN_MODIFICATION",
1285 : "IND_HF_GAIN_MODIFICATION",
1286 : "IND_HF_GAIN_MODIFICATION",
1287 : "IND_HF_GAIN_MODIFICATION",
1288 : "IND_HF_GAIN_MODIFICATION",
1289 : "IND_HF_GAIN_MODIFICATION",
1290 : "IND_HF_GAIN_MODIFICATION",
1291 : "IND_HF_GAIN_MODIFICATION",
1292 : "IND_HF_GAIN_MODIFICATION",
1293 : "IND_HF_GAIN_MODIFICATION",
1294 : "IND_HF_GAIN_MODIFICATION",
1295 : "IND_HF_GAIN_MODIFICATION",
1296 : "IND_HF_GAIN_MODIFICATION",
1297 : "IND_HF_GAIN_MODIFICATION",
1298 : "IND_HF_GAIN_MODIFICATION",
1299 : "IND_HF_GAIN_MODIFICATION",
1300 : "IND_HF_GAIN_MODIFICATION",
1301 : "IND_HF_GAIN_MODIFICATION",
1302 : "IND_HF_GAIN_MODIFICATION",
1303 : "IND_HF_GAIN_MODIFICATION",
1304 : "IND_HF_GAIN_MODIFICATION",
1305 : "IND_HF_GAIN_MODIFICATION",
1306 : "IND_HF_GAIN_MODIFICATION",
1307 : "IND_HF_GAIN_MODIFICATION",
1308 : "IND_HF_GAIN_MODIFICATION",
1309 : "IND_HF_GAIN_MODIFICATION",
1310 : "IND_HF_GAIN_MODIFICATION",
1311 : "IND_HF_GAIN_MODIFICATION",
1312 : "IND_HF_GAIN_MODIFICATION",
1313 : "IND_HF_GAIN_MODIFICATION",
1314 : "IND_HF_GAIN_MODIFICATION",
1315 : "IND_HF_GAIN_MODIFICATION",
1316 : "IND_HF_GAIN_MODIFICATION",
1317 : "IND_HF_GAIN_MODIFICATION",
1318 : "IND_HF_GAIN_MODIFICATION",
1319 : "IND_HF_GAIN_MODIFICATION",
1320 : "IND_HF_GAIN_MODIFICATION",
1321 : "TAG_ACELP_SUBFR_LOOP_END",
1322 : "IND_MEAN_GAIN2",
1323 : "IND_MEAN_GAIN2",
1324 : "IND_MEAN_GAIN2",
1325 : "IND_MEAN_GAIN2",
1326 : "IND_MEAN_GAIN2",
1327 : "IND_MEAN_GAIN2",
1328 : "IND_MEAN_GAIN2",
1329 : "IND_MEAN_GAIN2",
1330 : "IND_MEAN_GAIN2",
1331 : "IND_MEAN_GAIN2",
1332 : "IND_MEAN_GAIN2",
1333 : "IND_MEAN_GAIN2",
1334 : "IND_MEAN_GAIN2",
1335 : "IND_MEAN_GAIN2",
1336 : "IND_MEAN_GAIN2",
1337 : "IND_MEAN_GAIN2",
1338 : "IND_MEAN_GAIN2",
1339 : "IND_MEAN_GAIN2",
1340 : "IND_MEAN_GAIN2",
1341 : "IND_MEAN_GAIN2",
1342 : "IND_MEAN_GAIN2",
1343 : "IND_MEAN_GAIN2",
1344 : "IND_MEAN_GAIN2",
1345 : "IND_MEAN_GAIN2",
1346 : "IND_MEAN_GAIN2",
1347 : "IND_MEAN_GAIN2",
1348 : "IND_MEAN_GAIN2",
1349 : "IND_MEAN_GAIN2",
1350 : "IND_MEAN_GAIN2",
1351 : "IND_MEAN_GAIN2",
1352 : "IND_MEAN_GAIN2",
1353 : "IND_MEAN_GAIN2",
1354 : "IND_Y_GAIN_TMP",
1355 : "IND_Y_GAIN_TMP",
1356 : "IND_Y_GAIN_TMP",
1357 : "IND_Y_GAIN_TMP",
1358 : "IND_Y_GAIN_TMP",
1359 : "IND_Y_GAIN_TMP",
1360 : "IND_Y_GAIN_TMP",
1361 : "IND_Y_GAIN_TMP",
1362 : "IND_Y_GAIN_TMP",
1363 : "IND_Y_GAIN_TMP",
1364 : "IND_Y_GAIN_TMP",
1365 : "IND_Y_GAIN_TMP",
1366 : "IND_Y_GAIN_TMP",
1367 : "IND_Y_GAIN_TMP",
1368 : "IND_Y_GAIN_TMP",
1369 : "IND_Y_GAIN_TMP",
1370 : "IND_Y_GAIN_TMP",
1371 : "IND_Y_GAIN_TMP",
1372 : "IND_Y_GAIN_TMP",
1373 : "IND_Y_GAIN_TMP",
1374 : "IND_Y_GAIN_TMP",
1375 : "IND_Y_GAIN_TMP",
1376 : "IND_Y_GAIN_TMP",
1377 : "IND_Y_GAIN_TMP",
1378 : "IND_Y_GAIN_TMP",
1379 : "IND_Y_GAIN_TMP",
1380 : "IND_Y_GAIN_TMP",
1381 : "IND_Y_GAIN_TMP",
1382 : "IND_Y_GAIN_TMP",
1383 : "IND_Y_GAIN_TMP",
1384 : "IND_Y_GAIN_TMP",
1385 : "IND_Y_GAIN_TMP",
1386 : "IND_Y_GAIN_HF",
1387 : "IND_HQ_VOICING_FLAG",
1388 : "IND_HQ_SWB_CLAS",
1389 : "IND_NF_IDX",
1390 : "IND_LC_MODE",
1391 : "IND_YNRM",
1392 : "IND_YNRM",
1393 : "IND_YNRM",
1394 : "IND_YNRM",
1395 : "IND_YNRM",
1396 : "IND_YNRM",
1397 : "IND_YNRM",
1398 : "IND_YNRM",
1399 : "IND_YNRM",
1400 : "IND_YNRM",
1401 : "IND_YNRM",
1402 : "IND_YNRM",
1403 : "IND_YNRM",
1404 : "IND_YNRM",
1405 : "IND_YNRM",
1406 : "IND_YNRM",
1407 : "IND_YNRM",
1408 : "IND_YNRM",
1409 : "IND_YNRM",
1410 : "IND_YNRM",
1411 : "IND_YNRM",
1412 : "IND_YNRM",
1413 : "IND_YNRM",
1414 : "IND_YNRM",
1415 : "IND_YNRM",
1416 : "IND_YNRM",
1417 : "IND_YNRM",
1418 : "IND_YNRM",
1419 : "IND_YNRM",
1420 : "IND_YNRM",
1421 : "IND_YNRM",
1422 : "IND_YNRM",
1423 : "IND_YNRM",
1424 : "IND_YNRM",
1425 : "IND_YNRM",
1426 : "IND_YNRM",
1427 : "IND_YNRM",
1428 : "IND_YNRM",
1429 : "IND_YNRM",
1430 : "IND_YNRM",
1431 : "IND_YNRM",
1432 : "IND_YNRM",
1433 : "IND_YNRM",
1434 : "IND_YNRM",
1435 : "IND_SWB_FENV_HQ",
1436 : "IND_SWB_FENV_HQ",
1437 : "IND_SWB_FENV_HQ",
1438 : "IND_SWB_FENV_HQ",
1439 : "IND_SWB_FENV_HQ",
1440 : "IND_FB_FENV_HQ",
1441 : "IND_FB_FENV_HQ",
1442 : "IND_FB_FENV_HQ",
1443 : "IND_FB_FENV_HQ",
1444 : "IND_FB_FENV_HQ",
1445 : "IND_DELTA_ENV_HQ",
1446 : "IND_HVQ_BWE_NL",
1447 : "IND_HVQ_BWE_NL",
1448 : "IND_NUM_PEAKS",
1449 : "IND_POS_IDX",
1450 : "IND_POS_IDX",
1451 : "IND_POS_IDX",
1452 : "IND_POS_IDX",
1453 : "IND_POS_IDX",
1454 : "IND_POS_IDX",
1455 : "IND_POS_IDX",
1456 : "IND_POS_IDX",
1457 : "IND_POS_IDX",
1458 : "IND_POS_IDX",
1459 : "IND_POS_IDX",
1460 : "IND_POS_IDX",
1461 : "IND_POS_IDX",
1462 : "IND_POS_IDX",
1463 : "IND_POS_IDX",
1464 : "IND_POS_IDX",
1465 : "IND_POS_IDX",
1466 : "IND_POS_IDX",
1467 : "IND_POS_IDX",
1468 : "IND_POS_IDX",
1469 : "IND_POS_IDX",
1470 : "IND_POS_IDX",
1471 : "IND_POS_IDX",
1472 : "IND_POS_IDX",
1473 : "IND_POS_IDX",
1474 : "IND_POS_IDX",
1475 : "IND_POS_IDX",
1476 : "IND_POS_IDX",
1477 : "IND_POS_IDX",
1478 : "IND_POS_IDX",
1479 : "IND_POS_IDX",
1480 : "IND_POS_IDX",
1481 : "IND_POS_IDX",
1482 : "IND_POS_IDX",
1483 : "IND_POS_IDX",
1484 : "IND_POS_IDX",
1485 : "IND_POS_IDX",
1486 : "IND_POS_IDX",
1487 : "IND_POS_IDX",
1488 : "IND_POS_IDX",
1489 : "IND_POS_IDX",
1490 : "IND_POS_IDX",
1491 : "IND_POS_IDX",
1492 : "IND_POS_IDX",
1493 : "IND_POS_IDX",
1494 : "IND_POS_IDX",
1495 : "IND_POS_IDX",
1496 : "IND_POS_IDX",
1497 : "IND_POS_IDX",
1498 : "IND_POS_IDX",
1499 : "IND_POS_IDX",
1500 : "IND_POS_IDX",
1501 : "IND_POS_IDX",
1502 : "IND_POS_IDX",
1503 : "IND_POS_IDX",
1504 : "IND_POS_IDX",
1505 : "IND_POS_IDX",
1506 : "IND_POS_IDX",
1507 : "IND_POS_IDX",
1508 : "IND_POS_IDX",
1509 : "IND_POS_IDX",
1510 : "IND_POS_IDX",
1511 : "IND_POS_IDX",
1512 : "IND_POS_IDX",
1513 : "IND_POS_IDX",
1514 : "IND_POS_IDX",
1515 : "IND_POS_IDX",
1516 : "IND_POS_IDX",
1517 : "IND_POS_IDX",
1518 : "IND_POS_IDX",
1519 : "IND_POS_IDX",
1520 : "IND_POS_IDX",
1521 : "IND_POS_IDX",
1522 : "IND_POS_IDX",
1523 : "IND_POS_IDX",
1524 : "IND_POS_IDX",
1525 : "IND_POS_IDX",
1526 : "IND_POS_IDX",
1527 : "IND_POS_IDX",
1528 : "IND_POS_IDX",
1529 : "IND_POS_IDX",
1530 : "IND_POS_IDX",
1531 : "IND_POS_IDX",
1532 : "IND_POS_IDX",
1533 : "IND_POS_IDX",
1534 : "IND_POS_IDX",
1535 : "IND_POS_IDX",
1536 : "IND_POS_IDX",
1537 : "IND_POS_IDX",
1538 : "IND_POS_IDX",
1539 : "IND_POS_IDX",
1540 : "IND_POS_IDX",
1541 : "IND_POS_IDX",
1542 : "IND_POS_IDX",
1543 : "IND_POS_IDX",
1544 : "IND_POS_IDX",
1545 : "IND_POS_IDX",
1546 : "IND_POS_IDX",
1547 : "IND_POS_IDX",
1548 : "IND_POS_IDX",
1549 : "IND_POS_IDX",
1550 : "IND_POS_IDX",
1551 : "IND_POS_IDX",
1552 : "IND_POS_IDX",
1553 : "IND_POS_IDX",
1554 : "IND_POS_IDX",
1555 : "IND_POS_IDX",
1556 : "IND_POS_IDX",
1557 : "IND_POS_IDX",
1558 : "IND_POS_IDX",
1559 : "IND_POS_IDX",
1560 : "IND_POS_IDX",
1561 : "IND_POS_IDX",
1562 : "IND_POS_IDX",
1563 : "IND_POS_IDX",
1564 : "IND_POS_IDX",
1565 : "IND_POS_IDX",
1566 : "IND_POS_IDX",
1567 : "IND_POS_IDX",
1568 : "IND_POS_IDX",
1569 : "IND_POS_IDX",
1570 : "IND_POS_IDX",
1571 : "IND_POS_IDX",
1572 : "IND_POS_IDX",
1573 : "IND_POS_IDX",
1574 : "IND_POS_IDX",
1575 : "IND_POS_IDX",
1576 : "IND_POS_IDX",
1577 : "IND_POS_IDX",
1578 : "IND_POS_IDX",
1579 : "IND_POS_IDX",
1580 : "IND_POS_IDX",
1581 : "IND_POS_IDX",
1582 : "IND_POS_IDX",
1583 : "IND_POS_IDX",
1584 : "IND_POS_IDX",
1585 : "IND_POS_IDX",
1586 : "IND_POS_IDX",
1587 : "IND_POS_IDX",
1588 : "IND_POS_IDX",
1589 : "IND_POS_IDX",
1590 : "IND_POS_IDX",
1591 : "IND_POS_IDX",
1592 : "IND_POS_IDX",
1593 : "IND_POS_IDX",
1594 : "IND_POS_IDX",
1595 : "IND_POS_IDX",
1596 : "IND_POS_IDX",
1597 : "IND_POS_IDX",
1598 : "IND_POS_IDX",
1599 : "IND_POS_IDX",
1600 : "IND_POS_IDX",
1601 : "IND_POS_IDX",
1602 : "IND_POS_IDX",
1603 : "IND_POS_IDX",
1604 : "IND_POS_IDX",
1605 : "IND_POS_IDX",
1606 : "IND_POS_IDX",
1607 : "IND_POS_IDX",
1608 : "IND_POS_IDX",
1609 : "IND_POS_IDX",
1610 : "IND_POS_IDX",
1611 : "IND_POS_IDX",
1612 : "IND_POS_IDX",
1613 : "IND_POS_IDX",
1614 : "IND_POS_IDX",
1615 : "IND_POS_IDX",
1616 : "IND_POS_IDX",
1617 : "IND_POS_IDX",
1618 : "IND_POS_IDX",
1619 : "IND_POS_IDX",
1620 : "IND_POS_IDX",
1621 : "IND_POS_IDX",
1622 : "IND_POS_IDX",
1623 : "IND_POS_IDX",
1624 : "IND_POS_IDX",
1625 : "IND_POS_IDX",
1626 : "IND_POS_IDX",
1627 : "IND_POS_IDX",
1628 : "IND_POS_IDX",
1629 : "IND_POS_IDX",
1630 : "IND_POS_IDX",
1631 : "IND_POS_IDX",
1632 : "IND_POS_IDX",
1633 : "IND_POS_IDX",
1634 : "IND_POS_IDX",
1635 : "IND_POS_IDX",
1636 : "IND_POS_IDX",
1637 : "IND_POS_IDX",
1638 : "IND_POS_IDX",
1639 : "IND_POS_IDX",
1640 : "IND_POS_IDX",
1641 : "IND_POS_IDX",
1642 : "IND_POS_IDX",
1643 : "IND_POS_IDX",
1644 : "IND_POS_IDX",
1645 : "IND_POS_IDX",
1646 : "IND_POS_IDX",
1647 : "IND_POS_IDX",
1648 : "IND_POS_IDX",
1649 : "IND_POS_IDX",
1650 : "IND_POS_IDX",
1651 : "IND_POS_IDX",
1652 : "IND_POS_IDX",
1653 : "IND_POS_IDX",
1654 : "IND_POS_IDX",
1655 : "IND_POS_IDX",
1656 : "IND_POS_IDX",
1657 : "IND_POS_IDX",
1658 : "IND_POS_IDX",
1659 : "IND_POS_IDX",
1660 : "IND_POS_IDX",
1661 : "IND_POS_IDX",
1662 : "IND_POS_IDX",
1663 : "IND_POS_IDX",
1664 : "IND_POS_IDX",
1665 : "IND_POS_IDX",
1666 : "IND_POS_IDX",
1667 : "IND_POS_IDX",
1668 : "IND_POS_IDX",
1669 : "IND_POS_IDX",
1670 : "IND_POS_IDX",
1671 : "IND_POS_IDX",
1672 : "IND_POS_IDX",
1673 : "IND_POS_IDX",
1674 : "IND_POS_IDX",
1675 : "IND_POS_IDX",
1676 : "IND_POS_IDX",
1677 : "IND_POS_IDX",
1678 : "IND_POS_IDX",
1679 : "IND_POS_IDX",
1680 : "IND_POS_IDX",
1681 : "IND_POS_IDX",
1682 : "IND_POS_IDX",
1683 : "IND_POS_IDX",
1684 : "IND_POS_IDX",
1685 : "IND_POS_IDX",
1686 : "IND_POS_IDX",
1687 : "IND_POS_IDX",
1688 : "IND_POS_IDX",
1689 : "IND_POS_IDX",
1690 : "IND_POS_IDX",
1691 : "IND_POS_IDX",
1692 : "IND_POS_IDX",
1693 : "IND_POS_IDX",
1694 : "IND_POS_IDX",
1695 : "IND_POS_IDX",
1696 : "IND_POS_IDX",
1697 : "IND_POS_IDX",
1698 : "IND_POS_IDX",
1699 : "IND_POS_IDX",
1700 : "IND_POS_IDX",
1701 : "IND_POS_IDX",
1702 : "IND_POS_IDX",
1703 : "IND_POS_IDX",
1704 : "IND_POS_IDX",
1705 : "IND_POS_IDX",
1706 : "IND_POS_IDX",
1707 : "IND_POS_IDX",
1708 : "IND_POS_IDX",
1709 : "IND_POS_IDX",
1710 : "IND_POS_IDX",
1711 : "IND_POS_IDX",
1712 : "IND_POS_IDX",
1713 : "IND_POS_IDX",
1714 : "IND_POS_IDX",
1715 : "IND_POS_IDX",
1716 : "IND_POS_IDX",
1717 : "IND_POS_IDX",
1718 : "IND_POS_IDX",
1719 : "IND_POS_IDX",
1720 : "IND_POS_IDX",
1721 : "IND_POS_IDX",
1722 : "IND_POS_IDX",
1723 : "IND_POS_IDX",
1724 : "IND_POS_IDX",
1725 : "IND_POS_IDX",
1726 : "IND_POS_IDX",
1727 : "IND_POS_IDX",
1728 : "IND_POS_IDX",
1729 : "IND_FLAGN",
1730 : "IND_PG_IDX",
1731 : "IND_PG_IDX",
1732 : "IND_PG_IDX",
1733 : "IND_PG_IDX",
1734 : "IND_PG_IDX",
1735 : "IND_PG_IDX",
1736 : "IND_PG_IDX",
1737 : "IND_PG_IDX",
1738 : "IND_PG_IDX",
1739 : "IND_PG_IDX",
1740 : "IND_PG_IDX",
1741 : "IND_PG_IDX",
1742 : "IND_PG_IDX",
1743 : "IND_PG_IDX",
1744 : "IND_PG_IDX",
1745 : "IND_PG_IDX",
1746 : "IND_PG_IDX",
1747 : "IND_PG_IDX",
1748 : "IND_PG_IDX",
1749 : "IND_PG_IDX",
1750 : "IND_PG_IDX",
1751 : "IND_PG_IDX",
1752 : "IND_PG_IDX",
1753 : "IND_PG_IDX",
1754 : "IND_PG_IDX",
1755 : "IND_PG_IDX",
1756 : "IND_PG_IDX",
1757 : "IND_PG_IDX",
1758 : "IND_PG_IDX",
1759 : "IND_PG_IDX",
1760 : "IND_PG_IDX",
1761 : "IND_PG_IDX",
1762 : "IND_PG_IDX",
1763 : "IND_PG_IDX",
1764 : "IND_PG_IDX",
1765 : "IND_HVQ_PEAKS",
1766 : "IND_HVQ_PEAKS",
1767 : "IND_HVQ_PEAKS",
1768 : "IND_HVQ_PEAKS",
1769 : "IND_HVQ_PEAKS",
1770 : "IND_HVQ_PEAKS",
1771 : "IND_HVQ_PEAKS",
1772 : "IND_HVQ_PEAKS",
1773 : "IND_HVQ_PEAKS",
1774 : "IND_HVQ_PEAKS",
1775 : "IND_HVQ_PEAKS",
1776 : "IND_HVQ_PEAKS",
1777 : "IND_HVQ_PEAKS",
1778 : "IND_HVQ_PEAKS",
1779 : "IND_HVQ_PEAKS",
1780 : "IND_HVQ_PEAKS",
1781 : "IND_HVQ_PEAKS",
1782 : "IND_HVQ_PEAKS",
1783 : "IND_HVQ_PEAKS",
1784 : "IND_HVQ_PEAKS",
1785 : "IND_HVQ_PEAKS",
1786 : "IND_HVQ_PEAKS",
1787 : "IND_HVQ_PEAKS",
1788 : "IND_HVQ_PEAKS",
1789 : "IND_HVQ_PEAKS",
1790 : "IND_HVQ_PEAKS",
1791 : "IND_HVQ_PEAKS",
1792 : "IND_HVQ_PEAKS",
1793 : "IND_HVQ_PEAKS",
1794 : "IND_HVQ_PEAKS",
1795 : "IND_HVQ_PEAKS",
1796 : "IND_HVQ_PEAKS",
1797 : "IND_HVQ_PEAKS",
1798 : "IND_HVQ_PEAKS",
1799 : "IND_HVQ_PEAKS",
1800 : "IND_HVQ_PEAKS",
1801 : "IND_HVQ_PEAKS",
1802 : "IND_HVQ_PEAKS",
1803 : "IND_HVQ_PEAKS",
1804 : "IND_HVQ_PEAKS",
1805 : "IND_HVQ_PEAKS",
1806 : "IND_HVQ_PEAKS",
1807 : "IND_HVQ_PEAKS",
1808 : "IND_HVQ_PEAKS",
1809 : "IND_HVQ_PEAKS",
1810 : "IND_HVQ_PEAKS",
1811 : "IND_HVQ_PEAKS",
1812 : "IND_HVQ_PEAKS",
1813 : "IND_HVQ_PEAKS",
1814 : "IND_HVQ_PEAKS",
1815 : "IND_HVQ_PEAKS",
1816 : "IND_HVQ_PEAKS",
1817 : "IND_HVQ_PEAKS",
1818 : "IND_HVQ_PEAKS",
1819 : "IND_HVQ_PEAKS",
1820 : "IND_HVQ_PEAKS",
1821 : "IND_HVQ_PEAKS",
1822 : "IND_HVQ_PEAKS",
1823 : "IND_HVQ_PEAKS",
1824 : "IND_HVQ_PEAKS",
1825 : "IND_HVQ_PEAKS",
1826 : "IND_HVQ_PEAKS",
1827 : "IND_HVQ_PEAKS",
1828 : "IND_HVQ_PEAKS",
1829 : "IND_HVQ_PEAKS",
1830 : "IND_HVQ_PEAKS",
1831 : "IND_HVQ_PEAKS",
1832 : "IND_HVQ_PEAKS",
1833 : "IND_HVQ_PEAKS",
1834 : "IND_HVQ_PEAKS",
1835 : "IND_HVQ_NF_GAIN",
1836 : "IND_HVQ_NF_GAIN",
1837 : "IND_HQ2_SWB_CLAS",
1838 : "IND_HQ2_DENG_MODE",
1839 : "IND_HQ2_DENG_8SMODE",
1840 : "IND_HQ2_DENG_8SMODE_N0",
1841 : "IND_HQ2_DENG_8SMODE_N1",
1842 : "IND_HQ2_DENG_8SPOS",
1843 : "IND_HQ2_DENG_8SDEPTH",
1844 : "IND_HQ2_DENG_HMODE",
1845 : "IND_HQ2_DIFF_ENERGY",
1846 : "IND_HQ2_DIFF_ENERGY",
1847 : "IND_HQ2_DIFF_ENERGY",
1848 : "IND_HQ2_DIFF_ENERGY",
1849 : "IND_HQ2_DIFF_ENERGY",
1850 : "IND_HQ2_DIFF_ENERGY",
1851 : "IND_HQ2_DIFF_ENERGY",
1852 : "IND_HQ2_DIFF_ENERGY",
1853 : "IND_HQ2_DIFF_ENERGY",
1854 : "IND_HQ2_DIFF_ENERGY",
1855 : "IND_HQ2_DIFF_ENERGY",
1856 : "IND_HQ2_DIFF_ENERGY",
1857 : "IND_HQ2_DIFF_ENERGY",
1858 : "IND_HQ2_DIFF_ENERGY",
1859 : "IND_HQ2_DIFF_ENERGY",
1860 : "IND_HQ2_DIFF_ENERGY",
1861 : "IND_HQ2_DIFF_ENERGY",
1862 : "IND_HQ2_DIFF_ENERGY",
1863 : "IND_HQ2_DIFF_ENERGY",
1864 : "IND_HQ2_DIFF_ENERGY",
1865 : "IND_HQ2_DIFF_ENERGY",
1866 : "IND_HQ2_DIFF_ENERGY",
1867 : "IND_HQ2_DIFF_ENERGY",
1868 : "IND_HQ2_DIFF_ENERGY",
1869 : "IND_HQ2_DIFF_ENERGY",
1870 : "IND_HQ2_DIFF_ENERGY",
1871 : "IND_HQ2_DIFF_ENERGY",
1872 : "IND_HQ2_DIFF_ENERGY",
1873 : "IND_HQ2_DIFF_ENERGY",
1874 : "IND_HQ2_DIFF_ENERGY",
1875 : "IND_HQ2_DIFF_ENERGY",
1876 : "IND_HQ2_DIFF_ENERGY",
1877 : "IND_HQ2_DIFF_ENERGY",
1878 : "IND_HQ2_DIFF_ENERGY",
1879 : "IND_HQ2_DIFF_ENERGY",
1880 : "IND_HQ2_DIFF_ENERGY",
1881 : "IND_HQ2_DIFF_ENERGY",
1882 : "IND_HQ2_DIFF_ENERGY",
1883 : "IND_HQ2_DIFF_ENERGY",
1884 : "IND_HQ2_DIFF_ENERGY",
1885 : "IND_HQ2_DIFF_ENERGY",
1886 : "IND_HQ2_DIFF_ENERGY",
1887 : "IND_HQ2_DIFF_ENERGY",
1888 : "IND_HQ2_DIFF_ENERGY",
1889 : "IND_HQ2_DIFF_ENERGY",
1890 : "IND_HQ2_DIFF_ENERGY",
1891 : "IND_HQ2_DIFF_ENERGY",
1892 : "IND_HQ2_DIFF_ENERGY",
1893 : "IND_HQ2_DIFF_ENERGY",
1894 : "IND_HQ2_DIFF_ENERGY",
1895 : "IND_HQ2_DIFF_ENERGY",
1896 : "IND_HQ2_DIFF_ENERGY",
1897 : "IND_HQ2_DIFF_ENERGY",
1898 : "IND_HQ2_DIFF_ENERGY",
1899 : "IND_HQ2_DIFF_ENERGY",
1900 : "IND_HQ2_DIFF_ENERGY",
1901 : "IND_HQ2_DIFF_ENERGY",
1902 : "IND_HQ2_DIFF_ENERGY",
1903 : "IND_HQ2_DIFF_ENERGY",
1904 : "IND_HQ2_DIFF_ENERGY",
1905 : "IND_HQ2_DIFF_ENERGY",
1906 : "IND_HQ2_DIFF_ENERGY",
1907 : "IND_HQ2_DIFF_ENERGY",
1908 : "IND_HQ2_DIFF_ENERGY",
1909 : "IND_HQ2_DIFF_ENERGY",
1910 : "IND_HQ2_DIFF_ENERGY",
1911 : "IND_HQ2_DIFF_ENERGY",
1912 : "IND_HQ2_DIFF_ENERGY",
1913 : "IND_HQ2_DIFF_ENERGY",
1914 : "IND_HQ2_DIFF_ENERGY",
1915 : "IND_HQ2_DIFF_ENERGY",
1916 : "IND_HQ2_DIFF_ENERGY",
1917 : "IND_HQ2_DIFF_ENERGY",
1918 : "IND_HQ2_DIFF_ENERGY",
1919 : "IND_HQ2_DIFF_ENERGY",
1920 : "IND_HQ2_DIFF_ENERGY",
1921 : "IND_HQ2_DIFF_ENERGY",
1922 : "IND_HQ2_DIFF_ENERGY",
1923 : "IND_HQ2_DIFF_ENERGY",
1924 : "IND_HQ2_DIFF_ENERGY",
1925 : "IND_HQ2_DIFF_ENERGY",
1926 : "IND_HQ2_DIFF_ENERGY",
1927 : "IND_HQ2_DIFF_ENERGY",
1928 : "IND_HQ2_DIFF_ENERGY",
1929 : "IND_HQ2_DIFF_ENERGY",
1930 : "IND_HQ2_DIFF_ENERGY",
1931 : "IND_HQ2_DIFF_ENERGY",
1932 : "IND_HQ2_DIFF_ENERGY",
1933 : "IND_HQ2_DIFF_ENERGY",
1934 : "IND_HQ2_DIFF_ENERGY",
1935 : "IND_HQ2_DIFF_ENERGY",
1936 : "IND_HQ2_DIFF_ENERGY",
1937 : "IND_HQ2_DIFF_ENERGY",
1938 : "IND_HQ2_DIFF_ENERGY",
1939 : "IND_HQ2_DIFF_ENERGY",
1940 : "IND_HQ2_DIFF_ENERGY",
1941 : "IND_HQ2_DIFF_ENERGY",
1942 : "IND_HQ2_DIFF_ENERGY",
1943 : "IND_HQ2_DIFF_ENERGY",
1944 : "IND_HQ2_DIFF_ENERGY",
1945 : "IND_HQ2_P2A_FLAGS",
1946 : "IND_HQ2_P2A_FLAGS",
1947 : "IND_HQ2_P2A_FLAGS",
1948 : "IND_HQ2_P2A_FLAGS",
1949 : "IND_HQ2_P2A_FLAGS",
1950 : "IND_HQ2_P2A_FLAGS",
1951 : "IND_HQ2_P2A_FLAGS",
1952 : "IND_HQ2_P2A_FLAGS",
1953 : "IND_HQ2_P2A_FLAGS",
1954 : "IND_HQ2_P2A_FLAGS",
1955 : "IND_HQ2_P2A_FLAGS",
1956 : "IND_HQ2_P2A_FLAGS",
1957 : "IND_HQ2_P2A_FLAGS",
1958 : "IND_HQ2_P2A_FLAGS",
1959 : "IND_HQ2_P2A_FLAGS",
1960 : "IND_HQ2_P2A_FLAGS",
1961 : "IND_HQ2_P2A_FLAGS",
1962 : "IND_HQ2_P2A_FLAGS",
1963 : "IND_HQ2_P2A_FLAGS",
1964 : "IND_HQ2_P2A_FLAGS",
1965 : "IND_HQ2_P2A_FLAGS",
1966 : "IND_HQ2_P2A_FLAGS",
1967 : "IND_HQ2_P2A_FLAGS",
1968 : "IND_HQ2_P2A_FLAGS",
1969 : "IND_HQ2_P2A_FLAGS",
1970 : "IND_HQ2_P2A_FLAGS",
1971 : "IND_HQ2_P2A_FLAGS",
1972 : "IND_HQ2_P2A_FLAGS",
1973 : "IND_HQ2_P2A_FLAGS",
1974 : "IND_HQ2_P2A_FLAGS",
1975 : "IND_HQ2_P2A_FLAGS",
1976 : "IND_HQ2_P2A_FLAGS",
1977 : "IND_HQ2_P2A_FLAGS",
1978 : "IND_HQ2_P2A_FLAGS",
1979 : "IND_HQ2_P2A_FLAGS",
1980 : "IND_HQ2_P2A_FLAGS",
1981 : "IND_HQ2_P2A_FLAGS",
1982 : "IND_HQ2_P2A_FLAGS",
1983 : "IND_HQ2_P2A_FLAGS",
1984 : "IND_HQ2_P2A_FLAGS",
1985 : "IND_HQ2_P2A_FLAGS",
1986 : "IND_HQ2_P2A_FLAGS",
1987 : "IND_HQ2_P2A_FLAGS",
1988 : "IND_HQ2_P2A_FLAGS",
1989 : "IND_HQ2_P2A_FLAGS",
1990 : "IND_HQ2_P2A_FLAGS",
1991 : "IND_HQ2_P2A_FLAGS",
1992 : "IND_HQ2_P2A_FLAGS",
1993 : "IND_HQ2_P2A_FLAGS",
1994 : "IND_HQ2_P2A_FLAGS",
1995 : "IND_HQ2_P2A_FLAGS",
1996 : "IND_HQ2_P2A_FLAGS",
1997 : "IND_HQ2_P2A_FLAGS",
1998 : "IND_HQ2_P2A_FLAGS",
1999 : "IND_HQ2_P2A_FLAGS",
2000 : "IND_HQ2_P2A_FLAGS",
2001 : "IND_HQ2_P2A_FLAGS",
2002 : "IND_HQ2_P2A_FLAGS",
2003 : "IND_HQ2_P2A_FLAGS",
2004 : "IND_HQ2_P2A_FLAGS",
2005 : "IND_HQ2_LAST_BA_MAX_BAND",
2006 : "IND_HQ2_LAST_BA_MAX_BAND",
2007 : "IND_RC_START",
2008 : "IND_RC_START",
2009 : "IND_RC_START",
2010 : "IND_RC_START",
2011 : "IND_RC_START",
2012 : "IND_RC_START",
2013 : "IND_RC_START",
2014 : "IND_RC_START",
2015 : "IND_RC_START",
2016 : "IND_RC_START",
2017 : "IND_RC_START",
2018 : "IND_RC_START",
2019 : "IND_RC_START",
2020 : "IND_RC_START",
2021 : "IND_RC_START",
2022 : "IND_RC_START",
2023 : "IND_RC_START",
2024 : "IND_RC_START",
2025 : "IND_RC_START",
2026 : "IND_RC_START",
2027 : "IND_RC_START",
2028 : "IND_RC_START",
2029 : "IND_RC_START",
2030 : "IND_RC_START",
2031 : "IND_RC_START",
2032 : "IND_RC_START",
2033 : "IND_RC_START",
2034 : "IND_RC_START",
2035 : "IND_RC_START",
2036 : "IND_RC_START",
2037 : "IND_RC_START",
2038 : "IND_RC_START",
2039 : "IND_RC_START",
2040 : "IND_RC_START",
2041 : "IND_RC_START",
2042 : "IND_RC_START",
2043 : "IND_RC_START",
2044 : "IND_RC_START",
2045 : "IND_RC_START",
2046 : "IND_RC_START",
2047 : "IND_RC_START",
2048 : "IND_RC_START",
2049 : "IND_RC_START",
2050 : "IND_RC_START",
2051 : "IND_RC_START",
2052 : "IND_RC_START",
2053 : "IND_RC_START",
2054 : "IND_RC_START",
2055 : "IND_RC_START",
2056 : "IND_RC_START",
2057 : "IND_RC_START",
2058 : "IND_RC_START",
2059 : "IND_RC_START",
2060 : "IND_RC_START",
2061 : "IND_RC_START",
2062 : "IND_RC_START",
2063 : "IND_RC_START",
2064 : "IND_RC_START",
2065 : "IND_RC_START",
2066 : "IND_RC_START",
2067 : "IND_RC_START",
2068 : "IND_RC_START",
2069 : "IND_RC_START",
2070 : "IND_RC_START",
2071 : "IND_RC_START",
2072 : "IND_RC_START",
2073 : "IND_RC_START",
2074 : "IND_RC_START",
2075 : "IND_RC_START",
2076 : "IND_RC_START",
2077 : "IND_RC_START",
2078 : "IND_RC_START",
2079 : "IND_RC_START",
2080 : "IND_RC_START",
2081 : "IND_RC_START",
2082 : "IND_RC_START",
2083 : "IND_RC_START",
2084 : "IND_RC_START",
2085 : "IND_RC_START",
2086 : "IND_RC_START",
2087 : "IND_RC_START",
2088 : "IND_RC_START",
2089 : "IND_RC_START",
2090 : "IND_RC_START",
2091 : "IND_RC_START",
2092 : "IND_RC_START",
2093 : "IND_RC_START",
2094 : "IND_RC_START",
2095 : "IND_RC_START",
2096 : "IND_RC_START",
2097 : "IND_RC_START",
2098 : "IND_RC_START",
2099 : "IND_RC_START",
2100 : "IND_RC_START",
2101 : "IND_RC_START",
2102 : "IND_RC_START",
2103 : "IND_RC_START",
2104 : "IND_RC_START",
2105 : "IND_RC_START",
2106 : "IND_RC_START",
2107 : "IND_RC_START",
2108 : "IND_RC_START",
2109 : "IND_RC_START",
2110 : "IND_RC_START",
2111 : "IND_RC_START",
2112 : "IND_RC_START",
2113 : "IND_RC_START",
2114 : "IND_RC_START",
2115 : "IND_RC_START",
2116 : "IND_RC_START",
2117 : "IND_RC_START",
2118 : "IND_RC_START",
2119 : "IND_RC_START",
2120 : "IND_RC_START",
2121 : "IND_RC_START",
2122 : "IND_RC_START",
2123 : "IND_RC_START",
2124 : "IND_RC_START",
2125 : "IND_RC_START",
2126 : "IND_RC_START",
2127 : "IND_RC_START",
2128 : "IND_RC_START",
2129 : "IND_RC_START",
2130 : "IND_RC_START",
2131 : "IND_RC_START",
2132 : "IND_RC_START",
2133 : "IND_RC_START",
2134 : "IND_RC_START",
2135 : "IND_RC_START",
2136 : "IND_RC_START",
2137 : "IND_RC_START",
2138 : "IND_RC_START",
2139 : "IND_RC_START",
2140 : "IND_RC_START",
2141 : "IND_RC_START",
2142 : "IND_RC_START",
2143 : "IND_RC_START",
2144 : "IND_RC_START",
2145 : "IND_RC_START",
2146 : "IND_RC_START",
2147 : "IND_RC_START",
2148 : "IND_RC_START",
2149 : "IND_RC_START",
2150 : "IND_RC_START",
2151 : "IND_RC_START",
2152 : "IND_RC_START",
2153 : "IND_RC_START",
2154 : "IND_RC_START",
2155 : "IND_RC_START",
2156 : "IND_RC_START",
2157 : "IND_RC_START",
2158 : "IND_RC_START",
2159 : "IND_RC_START",
2160 : "IND_RC_START",
2161 : "IND_RC_START",
2162 : "IND_RC_START",
2163 : "IND_RC_START",
2164 : "IND_RC_START",
2165 : "IND_RC_START",
2166 : "IND_RC_START",
2167 : "IND_RC_START",
2168 : "IND_RC_START",
2169 : "IND_RC_START",
2170 : "IND_RC_START",
2171 : "IND_RC_START",
2172 : "IND_RC_START",
2173 : "IND_RC_START",
2174 : "IND_RC_START",
2175 : "IND_RC_START",
2176 : "IND_RC_START",
2177 : "IND_RC_START",
2178 : "IND_RC_START",
2179 : "IND_RC_START",
2180 : "IND_RC_START",
2181 : "IND_RC_START",
2182 : "IND_RC_START",
2183 : "IND_RC_START",
2184 : "IND_RC_START",
2185 : "IND_RC_START",
2186 : "IND_RC_START",
2187 : "IND_RC_START",
2188 : "IND_RC_START",
2189 : "IND_RC_START",
2190 : "IND_RC_START",
2191 : "IND_RC_START",
2192 : "IND_RC_START",
2193 : "IND_RC_START",
2194 : "IND_RC_START",
2195 : "IND_RC_START",
2196 : "IND_RC_START",
2197 : "IND_RC_START",
2198 : "IND_RC_START",
2199 : "IND_RC_START",
2200 : "IND_RC_START",
2201 : "IND_RC_START",
2202 : "IND_RC_START",
2203 : "IND_RC_START",
2204 : "IND_RC_START",
2205 : "IND_RC_START",
2206 : "IND_RC_START",
2207 : "IND_RC_START",
2208 : "IND_RC_START",
2209 : "IND_RC_START",
2210 : "IND_RC_START",
2211 : "IND_RC_START",
2212 : "IND_RC_START",
2213 : "IND_RC_START",
2214 : "IND_RC_START",
2215 : "IND_RC_START",
2216 : "IND_RC_START",
2217 : "IND_RC_START",
2218 : "IND_RC_START",
2219 : "IND_RC_START",
2220 : "IND_RC_START",
2221 : "IND_RC_START",
2222 : "IND_RC_START",
2223 : "IND_RC_START",
2224 : "IND_RC_START",
2225 : "IND_RC_START",
2226 : "IND_RC_START",
2227 : "IND_RC_START",
2228 : "IND_RC_START",
2229 : "IND_RC_START",
2230 : "IND_RC_START",
2231 : "IND_RC_START",
2232 : "IND_RC_START",
2233 : "IND_RC_START",
2234 : "IND_RC_START",
2235 : "IND_RC_START",
2236 : "IND_RC_START",
2237 : "IND_RC_START",
2238 : "IND_RC_START",
2239 : "IND_RC_START",
2240 : "IND_RC_START",
2241 : "IND_RC_START",
2242 : "IND_RC_START",
2243 : "IND_RC_START",
2244 : "IND_RC_START",
2245 : "IND_RC_START",
2246 : "IND_RC_START",
2247 : "IND_RC_START",
2248 : "IND_RC_START",
2249 : "IND_RC_START",
2250 : "IND_RC_START",
2251 : "IND_RC_START",
2252 : "IND_RC_START",
2253 : "IND_RC_START",
2254 : "IND_RC_START",
2255 : "IND_RC_START",
2256 : "IND_RC_START",
2257 : "IND_RC_START",
2258 : "IND_RC_START",
2259 : "IND_RC_START",
2260 : "IND_RC_START",
2261 : "IND_RC_START",
2262 : "IND_RC_START",
2263 : "IND_RC_START",
2264 : "IND_RC_START",
2265 : "IND_RC_START",
2266 : "IND_RC_START",
2267 : "IND_RC_START",
2268 : "IND_RC_START",
2269 : "IND_RC_START",
2270 : "IND_RC_START",
2271 : "IND_RC_START",
2272 : "IND_RC_START",
2273 : "IND_RC_START",
2274 : "IND_RC_START",
2275 : "IND_RC_START",
2276 : "IND_RC_START",
2277 : "IND_RC_START",
2278 : "IND_RC_START",
2279 : "IND_RC_START",
2280 : "IND_RC_START",
2281 : "IND_RC_START",
2282 : "IND_RC_START",
2283 : "IND_RC_START",
2284 : "IND_RC_START",
2285 : "IND_RC_START",
2286 : "IND_RC_START",
2287 : "IND_RC_START",
2288 : "IND_RC_START",
2289 : "IND_RC_START",
2290 : "IND_RC_START",
2291 : "IND_RC_START",
2292 : "IND_RC_START",
2293 : "IND_RC_START",
2294 : "IND_RC_START",
2295 : "IND_RC_START",
2296 : "IND_RC_START",
2297 : "IND_RC_START",
2298 : "IND_RC_START",
2299 : "IND_RC_START",
2300 : "IND_RC_START",
2301 : "IND_RC_START",
2302 : "IND_RC_START",
2303 : "IND_RC_START",
2304 : "IND_RC_START",
2305 : "IND_RC_START",
2306 : "IND_RC_START",
2307 : "IND_RC_START",
2308 : "IND_RC_START",
2309 : "IND_RC_START",
2310 : "IND_RC_START",
2311 : "IND_RC_START",
2312 : "IND_RC_START",
2313 : "IND_RC_START",
2314 : "IND_RC_START",
2315 : "IND_RC_START",
2316 : "IND_RC_START",
2317 : "IND_RC_START",
2318 : "IND_RC_START",
2319 : "IND_RC_START",
2320 : "IND_RC_START",
2321 : "IND_RC_START",
2322 : "IND_RC_START",
2323 : "IND_RC_START",
2324 : "IND_RC_START",
2325 : "IND_RC_START",
2326 : "IND_RC_START",
2327 : "IND_RC_END",
2328 : "IND_HVQ_PVQ_GAIN",
2329 : "IND_HVQ_PVQ_GAIN",
2330 : "IND_HVQ_PVQ_GAIN",
2331 : "IND_HVQ_PVQ_GAIN",
2332 : "IND_HVQ_PVQ_GAIN",
2333 : "IND_HVQ_PVQ_GAIN",
2334 : "IND_HVQ_PVQ_GAIN",
2335 : "IND_HVQ_PVQ_GAIN",
2336 : "IND_NOISINESS",
2337 : "IND_ENERGY",
2338 : "IND_CNG_HO",
2339 : "IND_SID_BW",
2340 : "IND_CNG_ENV1",
2341 : "IND_WB_FENV",
2342 : "IND_WB_CLASS",
2343 : "IND_IG1",
2344 : "IND_IG2A",
2345 : "IND_IG2B",
2346 : "IND_NELP_FID",
2347 : "IND_DELTALAG",
2348 : "IND_POWER",
2349 : "IND_AMP0",
2350 : "IND_AMP1",
2351 : "IND_GLOBAL_ALIGNMENT",
2352 : "IND_PVQ_FINE_GAIN",
2353 : "IND_UV_FLAG",
2354 : "IND_UV_FLAG",
2355 : "IND_UV_FLAG",
2356 : "IND_UV_FLAG",
2357 : "IND_UV_FLAG",
2358 : "IND_UV_FLAG",
2359 : "IND_UV_FLAG",
2360 : "IND_UV_FLAG",
2361 : "IND_UV_FLAG",
2362 : "IND_UV_FLAG",
2363 : "IND_UV_FLAG",
2364 : "IND_UV_FLAG",
2365 : "IND_UV_FLAG",
2366 : "IND_UV_FLAG",
2367 : "IND_UV_FLAG",
2368 : "IND_UV_FLAG",
2369 : "IND_UV_FLAG",
2370 : "IND_UV_FLAG",
2371 : "IND_UV_FLAG",
2372 : "IND_UV_FLAG",
2373 : "IND_UV_FLAG",
2374 : "IND_UV_FLAG",
2375 : "IND_UV_FLAG",
2376 : "IND_UV_FLAG",
2377 : "IND_UV_FLAG",
2378 : "IND_UV_FLAG",
2379 : "IND_UV_FLAG",
2380 : "IND_UV_FLAG",
2381 : "IND_UV_FLAG",
2382 : "IND_UV_FLAG",
2383 : "IND_UV_FLAG",
2384 : "IND_UV_FLAG",
2385 : "IND_UV_FLAG",
2386 : "IND_UV_FLAG",
2387 : "IND_UV_FLAG",
2388 : "IND_UV_FLAG",
2389 : "IND_UV_FLAG",
2390 : "IND_UV_FLAG",
2391 : "IND_UV_FLAG",
2392 : "IND_UV_FLAG",
2393 : "IND_UV_FLAG",
2394 : "IND_UV_FLAG",
2395 : "IND_UV_FLAG",
2396 : "IND_SHB_SUBGAIN",
2397 : "IND_SHB_FRAMEGAIN",
2398 : "IND_STEREO_ICBWE_MSFLAG",
2399 : "IND_SHB_ENER_SF",
2400 : "IND_SHB_RES_GS",
2401 : "IND_SHB_RES_GS",
2402 : "IND_SHB_RES_GS",
2403 : "IND_SHB_RES_GS",
2404 : "IND_SHB_RES_GS",
2405 : "IND_SHB_VF",
2406 : "IND_SHB_LSF",
2407 : "IND_SHB_LSF",
2408 : "IND_SHB_LSF",
2409 : "IND_SHB_LSF",
2410 : "IND_SHB_LSF",
2411 : "IND_SHB_MIRROR",
2412 : "IND_SHB_GRID",
2413 : "IND_SWB_CLASS",
2414 : "IND_SWB_TENV",
2415 : "IND_SWB_TENV",
2416 : "IND_SWB_TENV",
2417 : "IND_SWB_TENV",
2418 : "IND_SWB_FENV",
2419 : "IND_SWB_FENV",
2420 : "IND_SWB_FENV",
2421 : "IND_SWB_FENV",
2422 : "IND_SHB_CNG_GAIN",
2423 : "IND_DITHERING",
2424 : "IND_FB_SLOPE",
2425 : "IND_HQ2_SPT_SHORTEN",
2426 : "IND_HQ2_SUBBAND_TCQ",
2427 : "IND_HQ2_SUBBAND_TCQ",
2428 : "IND_HQ2_SUBBAND_TCQ",
2429 : "IND_HQ2_SUBBAND_TCQ",
2430 : "IND_HQ2_SUBBAND_TCQ",
2431 : "IND_HQ2_SUBBAND_TCQ",
2432 : "IND_HQ2_SUBBAND_TCQ",
2433 : "IND_HQ2_SUBBAND_TCQ",
2434 : "IND_HQ2_SUBBAND_TCQ",
2435 : "IND_HQ2_SUBBAND_TCQ",
2436 : "IND_HQ2_SUBBAND_TCQ",
2437 : "IND_HQ2_SUBBAND_TCQ",
2438 : "IND_HQ2_SUBBAND_TCQ",
2439 : "IND_HQ2_SUBBAND_TCQ",
2440 : "IND_HQ2_SUBBAND_TCQ",
2441 : "IND_HQ2_SUBBAND_TCQ",
2442 : "IND_HQ2_SUBBAND_TCQ",
2443 : "IND_HQ2_SUBBAND_TCQ",
2444 : "IND_HQ2_SUBBAND_TCQ",
2445 : "IND_HQ2_SUBBAND_TCQ",
2446 : "IND_HQ2_SUBBAND_TCQ",
2447 : "IND_HQ2_SUBBAND_TCQ",
2448 : "IND_HQ2_SUBBAND_TCQ",
2449 : "IND_HQ2_SUBBAND_TCQ",
2450 : "IND_HQ2_SUBBAND_TCQ",
2451 : "IND_HQ2_SUBBAND_TCQ",
2452 : "IND_HQ2_SUBBAND_TCQ",
2453 : "IND_HQ2_SUBBAND_TCQ",
2454 : "IND_HQ2_SUBBAND_TCQ",
2455 : "IND_HQ2_SUBBAND_TCQ",
2456 : "IND_HQ2_SUBBAND_TCQ",
2457 : "IND_HQ2_SUBBAND_TCQ",
2458 : "IND_HQ2_SUBBAND_TCQ",
2459 : "IND_HQ2_SUBBAND_TCQ",
2460 : "IND_HQ2_SUBBAND_TCQ",
2461 : "IND_HQ2_SUBBAND_TCQ",
2462 : "IND_HQ2_SUBBAND_TCQ",
2463 : "IND_HQ2_SUBBAND_TCQ",
2464 : "IND_HQ2_SUBBAND_TCQ",
2465 : "IND_HQ2_SUBBAND_TCQ",
2466 : "IND_HQ2_SUBBAND_TCQ",
2467 : "IND_HQ2_SUBBAND_TCQ",
2468 : "IND_HQ2_SUBBAND_TCQ",
2469 : "IND_HQ2_SUBBAND_TCQ",
2470 : "IND_HQ2_SUBBAND_TCQ",
2471 : "IND_HQ2_SUBBAND_TCQ",
2472 : "IND_HQ2_SUBBAND_TCQ",
2473 : "IND_HQ2_SUBBAND_TCQ",
2474 : "IND_HQ2_SUBBAND_TCQ",
2475 : "IND_HQ2_SUBBAND_TCQ",
2476 : "IND_HQ2_SUBBAND_TCQ",
2477 : "IND_HQ2_SUBBAND_TCQ",
2478 : "IND_HQ2_SUBBAND_TCQ",
2479 : "IND_HQ2_SUBBAND_TCQ",
2480 : "IND_HQ2_SUBBAND_TCQ",
2481 : "IND_HQ2_SUBBAND_TCQ",
2482 : "IND_HQ2_SUBBAND_TCQ",
2483 : "IND_HQ2_SUBBAND_TCQ",
2484 : "IND_HQ2_SUBBAND_TCQ",
2485 : "IND_HQ2_SUBBAND_TCQ",
2486 : "IND_HQ2_SUBBAND_TCQ",
2487 : "IND_HQ2_SUBBAND_TCQ",
2488 : "IND_HQ2_SUBBAND_TCQ",
2489 : "IND_HQ2_SUBBAND_TCQ",
2490 : "IND_HQ2_SUBBAND_TCQ",
2491 : "IND_HQ2_SUBBAND_TCQ",
2492 : "IND_HQ2_SUBBAND_TCQ",
2493 : "IND_HQ2_SUBBAND_TCQ",
2494 : "IND_HQ2_SUBBAND_TCQ",
2495 : "IND_HQ2_SUBBAND_TCQ",
2496 : "IND_HQ2_SUBBAND_TCQ",
2497 : "IND_HQ2_SUBBAND_TCQ",
2498 : "IND_HQ2_SUBBAND_TCQ",
2499 : "IND_HQ2_SUBBAND_TCQ",
2500 : "IND_HQ2_SUBBAND_TCQ",
2501 : "IND_HQ2_SUBBAND_TCQ",
2502 : "IND_HQ2_SUBBAND_TCQ",
2503 : "IND_HQ2_SUBBAND_TCQ",
2504 : "IND_HQ2_SUBBAND_TCQ",
2505 : "IND_HQ2_SUBBAND_TCQ",
2506 : "IND_HQ2_SUBBAND_TCQ",
2507 : "IND_HQ2_SUBBAND_TCQ",
2508 : "IND_HQ2_SUBBAND_TCQ",
2509 : "IND_HQ2_SUBBAND_TCQ",
2510 : "IND_HQ2_SUBBAND_TCQ",
2511 : "IND_HQ2_SUBBAND_TCQ",
2512 : "IND_HQ2_SUBBAND_TCQ",
2513 : "IND_HQ2_SUBBAND_TCQ",
2514 : "IND_HQ2_SUBBAND_TCQ",
2515 : "IND_HQ2_SUBBAND_TCQ",
2516 : "IND_HQ2_SUBBAND_TCQ",
2517 : "IND_HQ2_SUBBAND_TCQ",
2518 : "IND_HQ2_SUBBAND_TCQ",
2519 : "IND_HQ2_SUBBAND_TCQ",
2520 : "IND_HQ2_SUBBAND_TCQ",
2521 : "IND_HQ2_SUBBAND_TCQ",
2522 : "IND_HQ2_SUBBAND_TCQ",
2523 : "IND_HQ2_SUBBAND_TCQ",
2524 : "IND_HQ2_SUBBAND_TCQ",
2525 : "IND_HQ2_SUBBAND_TCQ",
2526 : "IND_HQ2_SUBBAND_GAIN",
2527 : "IND_HQ2_SUBBAND_GAIN",
2528 : "IND_HQ2_SUBBAND_GAIN",
2529 : "IND_HQ2_SUBBAND_GAIN",
2530 : "IND_HQ2_SUBBAND_GAIN",
2531 : "IND_HQ2_SUBBAND_GAIN",
2532 : "IND_HQ2_SUBBAND_GAIN",
2533 : "IND_HQ2_SUBBAND_GAIN",
2534 : "IND_HQ2_SUBBAND_GAIN",
2535 : "IND_HQ2_SUBBAND_GAIN",
2536 : "IND_HQ2_SUBBAND_GAIN",
2537 : "IND_HQ2_SUBBAND_GAIN",
2538 : "IND_HQ2_SUBBAND_GAIN",
2539 : "IND_HQ2_SUBBAND_GAIN",
2540 : "IND_HQ2_SUBBAND_GAIN",
2541 : "IND_HQ2_SUBBAND_GAIN",
2542 : "IND_HQ2_SUBBAND_GAIN",
2543 : "IND_HQ2_SUBBAND_GAIN",
2544 : "IND_HQ2_SUBBAND_GAIN",
2545 : "IND_HQ2_SUBBAND_GAIN",
2546 : "IND_HQ2_DUMMY",
2547 : "IND_LAGINDICES",
2548 : "IND_NOISEG",
2549 : "IND_AUDIO_GAIN",
2550 : "IND_AUDIO_DELAY",
2551 : "IND_AUDIO_DELAY",
2552 : "IND_AUDIO_DELAY",
2553 : "IND_AUDIO_DELAY",
2554 : "IND_NQ2",
2555 : "IND_NQ2",
2556 : "IND_NQ2",
2557 : "IND_NQ2",
2558 : "IND_NQ2",
2559 : "IND_NQ2",
2560 : "IND_NQ2",
2561 : "IND_NQ2",
2562 : "IND_NQ2",
2563 : "IND_NQ2",
2564 : "IND_NQ2",
2565 : "IND_NQ2",
2566 : "IND_NQ2",
2567 : "IND_NQ2",
2568 : "IND_NQ2",
2569 : "IND_NQ2",
2570 : "IND_NQ2",
2571 : "IND_NQ2",
2572 : "IND_NQ2",
2573 : "IND_NQ2",
2574 : "IND_NQ2",
2575 : "IND_NQ2",
2576 : "IND_NQ2",
2577 : "IND_NQ2",
2578 : "IND_NQ2",
2579 : "IND_NQ2",
2580 : "IND_NQ2",
2581 : "IND_NQ2",
2582 : "IND_NQ2",
2583 : "IND_NQ2",
2584 : "IND_NQ2",
2585 : "IND_NQ2",
2586 : "IND_NQ2",
2587 : "IND_NQ2",
2588 : "IND_NQ2",
2589 : "IND_NQ2",
2590 : "IND_NQ2",
2591 : "IND_NQ2",
2592 : "IND_NQ2",
2593 : "IND_NQ2",
2594 : "IND_NQ2",
2595 : "IND_NQ2",
2596 : "IND_NQ2",
2597 : "IND_NQ2",
2598 : "IND_NQ2",
2599 : "IND_NQ2",
2600 : "IND_NQ2",
2601 : "IND_NQ2",
2602 : "IND_NQ2",
2603 : "IND_NQ2",
2604 : "IND_NQ2",
2605 : "IND_NQ2",
2606 : "IND_NQ2",
2607 : "IND_NQ2",
2608 : "IND_NQ2",
2609 : "IND_NQ2",
2610 : "IND_NQ2",
2611 : "IND_NQ2",
2612 : "IND_NQ2",
2613 : "IND_NQ2",
2614 : "IND_NQ2",
2615 : "IND_NQ2",
2616 : "IND_NQ2",
2617 : "IND_NQ2",
2618 : "IND_NQ2",
2619 : "IND_NQ2",
2620 : "IND_NQ2",
2621 : "IND_NQ2",
2622 : "IND_NQ2",
2623 : "IND_NQ2",
2624 : "IND_NQ2",
2625 : "IND_NQ2",
2626 : "IND_NQ2",
2627 : "IND_NQ2",
2628 : "IND_NQ2",
2629 : "IND_NQ2",
2630 : "IND_NQ2",
2631 : "IND_NQ2",
2632 : "IND_NQ2",
2633 : "IND_NQ2",
2634 : "IND_NQ2",
2635 : "IND_NQ2",
2636 : "IND_NQ2",
2637 : "IND_NQ2",
2638 : "IND_NQ2",
2639 : "IND_NQ2",
2640 : "IND_NQ2",
2641 : "IND_NQ2",
2642 : "IND_NQ2",
2643 : "IND_NQ2",
2644 : "IND_NQ2",
2645 : "IND_NQ2",
2646 : "IND_NQ2",
2647 : "IND_NQ2",
2648 : "IND_NQ2",
2649 : "IND_NQ2",
2650 : "IND_NQ2",
2651 : "IND_NQ2",
2652 : "IND_NQ2",
2653 : "IND_NQ2",
2654 : "IND_NQ2",
2655 : "IND_NQ2",
2656 : "IND_NQ2",
2657 : "IND_NQ2",
2658 : "IND_NQ2",
2659 : "IND_NQ2",
2660 : "IND_NQ2",
2661 : "IND_NQ2",
2662 : "IND_NQ2",
2663 : "IND_NQ2",
2664 : "IND_NQ2",
2665 : "IND_NQ2",
2666 : "IND_NQ2",
2667 : "IND_NQ2",
2668 : "IND_NQ2",
2669 : "IND_NQ2",
2670 : "IND_NQ2",
2671 : "IND_NQ2",
2672 : "IND_NQ2",
2673 : "IND_NQ2",
2674 : "IND_NQ2",
2675 : "IND_NQ2",
2676 : "IND_NQ2",
2677 : "IND_NQ2",
2678 : "IND_NQ2",
2679 : "IND_NQ2",
2680 : "IND_NQ2",
2681 : "IND_NQ2",
2682 : "IND_NQ2",
2683 : "IND_NQ2",
2684 : "IND_NQ2",
2685 : "IND_NQ2",
2686 : "IND_NQ2",
2687 : "IND_NQ2",
2688 : "IND_NQ2",
2689 : "IND_NQ2",
2690 : "IND_NQ2",
2691 : "IND_NQ2",
2692 : "IND_NQ2",
2693 : "IND_NQ2",
2694 : "IND_NQ2",
2695 : "IND_NQ2",
2696 : "IND_NQ2",
2697 : "IND_NQ2",
2698 : "IND_NQ2",
2699 : "IND_NQ2",
2700 : "IND_NQ2",
2701 : "IND_NQ2",
2702 : "IND_NQ2",
2703 : "IND_NQ2",
2704 : "IND_NQ2",
2705 : "IND_NQ2",
2706 : "IND_NQ2",
2707 : "IND_NQ2",
2708 : "IND_NQ2",
2709 : "IND_NQ2",
2710 : "IND_NQ2",
2711 : "IND_NQ2",
2712 : "IND_NQ2",
2713 : "IND_NQ2",
2714 : "IND_NQ2",
2715 : "IND_NQ2",
2716 : "IND_NQ2",
2717 : "IND_NQ2",
2718 : "IND_NQ2",
2719 : "IND_NQ2",
2720 : "IND_NQ2",
2721 : "IND_NQ2",
2722 : "IND_NQ2",
2723 : "IND_NQ2",
2724 : "IND_NQ2",
2725 : "IND_NQ2",
2726 : "IND_NQ2",
2727 : "IND_NQ2",
2728 : "IND_NQ2",
2729 : "IND_NQ2",
2730 : "IND_NQ2",
2731 : "IND_NQ2",
2732 : "IND_NQ2",
2733 : "IND_NQ2",
2734 : "IND_NQ2",
2735 : "IND_NQ2",
2736 : "IND_NQ2",
2737 : "IND_NQ2",
2738 : "IND_NQ2",
2739 : "IND_NQ2",
2740 : "IND_NQ2",
2741 : "IND_NQ2",
2742 : "IND_NQ2",
2743 : "IND_NQ2",
2744 : "IND_NQ2",
2745 : "IND_NQ2",
2746 : "IND_NQ2",
2747 : "IND_NQ2",
2748 : "IND_NQ2",
2749 : "IND_NQ2",
2750 : "IND_NQ2",
2751 : "IND_NQ2",
2752 : "IND_NQ2",
2753 : "IND_NQ2",
2754 : "TAG_HR_BWE_LOOP_END",
2755 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2756 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2757 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2758 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2759 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2760 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2761 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2762 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2763 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2764 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2765 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2766 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2767 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2768 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2769 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2770 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2771 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2772 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2773 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2774 : "IND_CORE_SWITCHING_CELP_SUBFRAME",
2775 : "IND_CORE_SWITCHING_AUDIO_DELAY",
2776 : "IND_CORE_SWITCHING_AUDIO_GAIN",
2777 : "IND_STEREO_ICBWE_REF",
2778 : "IND_STEREO_ICBWE_SP",
2779 : "IND_STEREO_ICBWE_GS",
2780 : "IND_STEREO_REFCHAN",
2781 : "IND_STEREO_CORRSTATS",
2782 : "IND_STEREO_GD",
2783 : "IND_STEREO_LRTD_FLAG",
2784 : "IND_STEREO_LPC_REUSE",
2785 : "IND_STEREO_TD_ALPHA",
2786 : "IND_STEREO_2ND_CODER_T",
2787 : "IND_UNUSED"
2788 : };
2789 : #endif
2790 :
2791 : /*-------------------------------------------------------------------*
2792 : * push_indice()
2793 : *
2794 : * Push a new indice into the buffer
2795 : *-------------------------------------------------------------------*/
2796 :
2797 : #ifdef DEBUG_BS_READ_WRITE
2798 : ivas_error push_indice_(
2799 : #else
2800 15670642 : ivas_error push_indice(
2801 : #endif
2802 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
2803 : int16_t id, /* i : ID of the indice */
2804 : uint16_t value, /* i : value of the quantized indice */
2805 : int16_t nb_bits /* i : number of bits used to quantize the indice */
2806 : #ifdef DEBUG_BS_READ_WRITE
2807 : ,
2808 : int16_t line,
2809 : const char *func
2810 : #endif
2811 : )
2812 : {
2813 : int16_t i;
2814 : int16_t j;
2815 : ivas_error error;
2816 :
2817 15670642 : error = IVAS_ERR_OK;
2818 :
2819 : #ifdef DEBUG_BS_READ_WRITE
2820 : printf( "%s: %d: %d: %d\n", func, line, nb_bits, value );
2821 : #endif
2822 : #ifdef DEBUGGING
2823 : if ( nb_bits < ( 32 - 1 ) && ( value >> nb_bits ) > 0 )
2824 : {
2825 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice ID = %d with value %d exceeds the range of %d bits (frame %d) !\n", id, value, nb_bits, frame );
2826 : }
2827 :
2828 : if ( nb_bits > 16 )
2829 : {
2830 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice ID = %d with value %d is trying to allocate %d bits which exceeds 16 bits (frame %d) !\n", id, value, nb_bits, frame );
2831 : }
2832 :
2833 : #endif
2834 :
2835 : /* check the limits of the list of indices */
2836 15670642 : if ( ( error = check_ind_list_limits( hBstr ) ) != IVAS_ERR_OK )
2837 : {
2838 : #ifdef DEBUGGING
2839 : return IVAS_ERROR( error, "Error occured in push_indice() while re-allocating the list of indices (frame %d) !\n", frame );
2840 : #else
2841 0 : return IVAS_ERROR( error, "Error occured in push_indice() while re-allocating the list of indices!\n" );
2842 : #endif
2843 : }
2844 :
2845 : /* find the location in the list of indices based on ID */
2846 15670642 : i = hBstr->nb_ind_tot;
2847 54943315 : while ( i > 0 && id < hBstr->ind_list[i - 1].id )
2848 : {
2849 39272673 : i--;
2850 : }
2851 :
2852 : /* shift indices, if the new ID is to be written somewhere inside the list */
2853 15670642 : if ( i < hBstr->nb_ind_tot )
2854 : {
2855 41943382 : for ( j = hBstr->nb_ind_tot; j > i; j-- )
2856 : {
2857 39272673 : hBstr->ind_list[j].id = hBstr->ind_list[j - 1].id;
2858 39272673 : hBstr->ind_list[j].nb_bits = hBstr->ind_list[j - 1].nb_bits;
2859 39272673 : hBstr->ind_list[j].value = hBstr->ind_list[j - 1].value;
2860 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
2861 : strncpy( hBstr->ind_list[j].function_name, hBstr->ind_list[j - 1].function_name, 100 );
2862 : #endif
2863 : }
2864 : }
2865 :
2866 :
2867 : /* store the new indice in the list */
2868 15670642 : hBstr->ind_list[i].id = id;
2869 15670642 : hBstr->ind_list[i].value = value;
2870 15670642 : hBstr->ind_list[i].nb_bits = nb_bits;
2871 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
2872 : strncpy( hBstr->ind_list[i].function_name, named_indices_table[id], 100 );
2873 : #endif
2874 :
2875 : /* updates */
2876 15670642 : hBstr->nb_ind_tot++;
2877 15670642 : hBstr->nb_bits_tot += nb_bits;
2878 :
2879 15670642 : return error;
2880 : }
2881 :
2882 : /*-------------------------------------------------------------------*
2883 : * push_next_indice()
2884 : *
2885 : * Push a new indice into the buffer at the next position
2886 : *-------------------------------------------------------------------*/
2887 :
2888 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
2889 : ivas_error push_next_indice_(
2890 : const char *caller,
2891 : #else
2892 204351974 : ivas_error push_next_indice(
2893 : #endif
2894 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
2895 : uint16_t value, /* i : value of the quantized indice */
2896 : int16_t nb_bits /* i : number of bits used to quantize the indice */
2897 : )
2898 : {
2899 : int16_t prev_id;
2900 : ivas_error error;
2901 :
2902 204351974 : error = IVAS_ERR_OK;
2903 :
2904 : #ifdef DEBUGGING
2905 : if ( nb_bits < ( 32 - 1 ) && ( value >> nb_bits ) > 0 )
2906 : {
2907 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice with value %d exceeds the range of %d bits (frame %d) !\n", value, nb_bits, frame );
2908 : }
2909 :
2910 : if ( nb_bits > 16 )
2911 : {
2912 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Indice with value %d is trying to allocate %d bits which exceeds 16 bits !\n", value, nb_bits );
2913 : }
2914 :
2915 : #endif
2916 :
2917 : /* check the limits of the list of indices */
2918 204351974 : if ( ( error = check_ind_list_limits( hBstr ) ) != IVAS_ERR_OK )
2919 : {
2920 0 : return error;
2921 : }
2922 :
2923 : /* get the id of the previous indice -> it will be re-used */
2924 204351974 : if ( hBstr->nb_ind_tot > 0 )
2925 : {
2926 203352868 : prev_id = hBstr->ind_list[hBstr->nb_ind_tot - 1].id;
2927 : }
2928 : else
2929 : {
2930 999106 : prev_id = 0;
2931 : }
2932 :
2933 : /* store the values in the list */
2934 204351974 : hBstr->ind_list[hBstr->nb_ind_tot].id = prev_id;
2935 204351974 : hBstr->ind_list[hBstr->nb_ind_tot].value = value;
2936 204351974 : hBstr->ind_list[hBstr->nb_ind_tot].nb_bits = nb_bits;
2937 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
2938 : strncpy( hBstr->ind_list[hBstr->nb_ind_tot].function_name, caller, 100 );
2939 : #endif
2940 :
2941 : /* updates */
2942 204351974 : hBstr->nb_ind_tot++;
2943 204351974 : hBstr->nb_bits_tot += nb_bits;
2944 :
2945 204351974 : return error;
2946 : }
2947 :
2948 :
2949 : /*-------------------------------------------------------------------*
2950 : * push_next_bits()
2951 : * Push a bit buffer into the buffer at the next position
2952 : *-------------------------------------------------------------------*/
2953 :
2954 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
2955 : ivas_error push_next_bits_(
2956 : const char *caller,
2957 : #else
2958 1777019 : ivas_error push_next_bits(
2959 : #endif
2960 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
2961 : const uint16_t bits[], /* i : bit buffer to pack, sequence of single bits */
2962 : const int16_t nb_bits /* i : number of bits to pack */
2963 : )
2964 : {
2965 : uint16_t code;
2966 : int16_t i, nb_bits_m15;
2967 : Indice *ptr;
2968 : int16_t prev_id;
2969 : ivas_error error;
2970 :
2971 1777019 : error = IVAS_ERR_OK;
2972 :
2973 1777019 : ptr = &hBstr->ind_list[hBstr->nb_ind_tot];
2974 :
2975 : /* get the id of the previous indice -> will be re-used */
2976 1777019 : if ( hBstr->nb_ind_tot > 0 )
2977 : {
2978 1765979 : prev_id = hBstr->ind_list[hBstr->nb_ind_tot - 1].id;
2979 : }
2980 : else
2981 : {
2982 11040 : prev_id = 0;
2983 : }
2984 1777019 : nb_bits_m15 = nb_bits - 15;
2985 :
2986 16108649 : for ( i = 0; i < nb_bits_m15; i += 16 )
2987 : {
2988 14331630 : code = (uint16_t) ( ( bits[i] << 15 ) | ( ( bits[i + 1] << 14 ) | ( ( bits[i + 2] << 13 ) | ( ( bits[i + 3] << 12 ) | ( ( bits[i + 4] << 11 ) | ( ( bits[i + 5] << 10 ) | ( ( bits[i + 6] << 9 ) | ( ( bits[i + 7] << 8 ) | ( ( bits[i + 8] << 7 ) | ( ( bits[i + 9] << 6 ) | ( ( bits[i + 10] << 5 ) | ( ( bits[i + 11] << 4 ) | ( ( bits[i + 12] << 3 ) | ( ( bits[i + 13] << 2 ) | ( ( bits[i + 14] << 1 ) | bits[i + 15] ) ) ) ) ) ) ) ) ) ) ) ) ) ) );
2989 :
2990 : /* check the limits of the list of indices */
2991 14331630 : if ( ( error = check_ind_list_limits( hBstr ) ) != IVAS_ERR_OK )
2992 : {
2993 : #ifdef DEBUGGING
2994 : return IVAS_ERROR( error, "Error occured in push_next_bits() while re-allocating the list of indices (frame %d) !\n", frame );
2995 : #else
2996 0 : return IVAS_ERROR( error, "Error occured in push_next_bits() while re-allocating the list of indices!\n" );
2997 : #endif
2998 : }
2999 14331630 : ptr = &hBstr->ind_list[hBstr->nb_ind_tot];
3000 :
3001 14331630 : ptr->value = code;
3002 14331630 : ptr->nb_bits = 16;
3003 14331630 : ptr->id = prev_id;
3004 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
3005 : strncpy( ptr->function_name, caller, 100 );
3006 : #endif
3007 14331630 : hBstr->nb_ind_tot++;
3008 14331630 : ++ptr;
3009 : }
3010 :
3011 15100388 : for ( ; i < nb_bits; ++i )
3012 : {
3013 : /* check the limits of the list of indices */
3014 13323369 : if ( ( error = check_ind_list_limits( hBstr ) ) != IVAS_ERR_OK )
3015 : {
3016 : #ifdef DEBUGGING
3017 : return IVAS_ERROR( error, "Error occured in push_next_bits() while re-allocating the list of indices (frame %d) !\n", frame );
3018 : #else
3019 0 : return IVAS_ERROR( error, "Error occured in push_next_bits() while re-allocating the list of indices!\n" );
3020 : #endif
3021 : }
3022 13323369 : ptr = &hBstr->ind_list[hBstr->nb_ind_tot];
3023 :
3024 13323369 : ptr->value = bits[i];
3025 13323369 : ptr->nb_bits = 1;
3026 13323369 : ptr->id = prev_id;
3027 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
3028 : strncpy( ptr->function_name, caller, 100 );
3029 : #endif
3030 13323369 : hBstr->nb_ind_tot++;
3031 13323369 : ++ptr;
3032 : }
3033 :
3034 1777019 : hBstr->nb_bits_tot = hBstr->nb_bits_tot + nb_bits;
3035 :
3036 1777019 : return error;
3037 : }
3038 :
3039 :
3040 : /*-------------------------------------------------------------------*
3041 : * find_indice()
3042 : *
3043 : * Find indice based on its id
3044 : *-------------------------------------------------------------------*/
3045 :
3046 : /*! r: result: index of the indice in the list, -1 if not found */
3047 25 : int16_t find_indice(
3048 : BSTR_ENC_HANDLE hBstr, /* i : encoder bitstream handle */
3049 : const int16_t id, /* i : ID of the indice */
3050 : uint16_t *value, /* o : value of the quantized indice */
3051 : int16_t *nb_bits /* o : number of bits used to quantize the indice */
3052 : )
3053 : {
3054 : int16_t i;
3055 :
3056 153 : for ( i = 0; i < hBstr->nb_ind_tot; i++ )
3057 : {
3058 153 : if ( hBstr->ind_list[i].id == id && hBstr->ind_list[i].nb_bits > 0 )
3059 : {
3060 25 : *value = hBstr->ind_list[i].value;
3061 25 : *nb_bits = hBstr->ind_list[i].nb_bits;
3062 25 : return i;
3063 : }
3064 : }
3065 :
3066 0 : return -1;
3067 : }
3068 :
3069 :
3070 : /*-------------------------------------------------------------------*
3071 : * delete_indice()
3072 : *
3073 : * Delete indice based on its id (note, that nb_ind_tot and nb_bits_tot are updated)
3074 : *-------------------------------------------------------------------*/
3075 :
3076 : /*! r: number of deleted indices */
3077 675300 : uint16_t delete_indice(
3078 : BSTR_ENC_HANDLE hBstr, /* i : encoder bitstream handle */
3079 : const int16_t id /* i : ID of the indice */
3080 : )
3081 : {
3082 : int16_t i, j;
3083 :
3084 675300 : j = 0;
3085 9697592 : for ( i = 0; i < hBstr->nb_ind_tot; i++ )
3086 : {
3087 9022292 : if ( hBstr->ind_list[i].id == id )
3088 : {
3089 6125 : hBstr->nb_bits_tot -= hBstr->ind_list[i].nb_bits;
3090 6125 : continue;
3091 : }
3092 :
3093 9016167 : if ( j < i )
3094 : {
3095 : /* shift the indice left */
3096 3862 : hBstr->ind_list[j].id = hBstr->ind_list[i].id;
3097 3862 : hBstr->ind_list[j].value = hBstr->ind_list[i].value;
3098 3862 : hBstr->ind_list[j].nb_bits = hBstr->ind_list[i].nb_bits;
3099 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
3100 : strncpy( hBstr->ind_list[j].function_name, hBstr->ind_list[i].function_name, 100 );
3101 : #endif
3102 : }
3103 :
3104 9016167 : j++;
3105 : }
3106 :
3107 675300 : hBstr->nb_ind_tot = j;
3108 :
3109 681425 : for ( ; j < i; j++ )
3110 : {
3111 : /* reset the shifted indices at the end of the list */
3112 6125 : hBstr->ind_list[j].nb_bits = -1;
3113 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
3114 : sprintf( hBstr->ind_list[j].function_name, "RESET in delete_indice" );
3115 : #endif
3116 : }
3117 :
3118 675300 : return i - j;
3119 : }
3120 :
3121 :
3122 : /*-------------------------------------------------------------------*
3123 : * get_next_indice()
3124 : *
3125 : * Get the next indice from the buffer
3126 : *-------------------------------------------------------------------*/
3127 :
3128 : /*! r: value of the indice */
3129 : #ifdef DEBUG_BS_READ_WRITE
3130 : uint16_t get_next_indice_(
3131 : #else
3132 129018690 : uint16_t get_next_indice(
3133 : #endif
3134 : Decoder_State *st, /* i/o: decoder state structure */
3135 : int16_t nb_bits /* i : number of bits that were used to quantize the indice */
3136 : #ifdef DEBUG_BS_READ_WRITE
3137 : ,
3138 : int16_t line,
3139 : const char *func
3140 : #endif
3141 : )
3142 : {
3143 : uint16_t value;
3144 : int16_t i;
3145 : int32_t nbits_total;
3146 :
3147 129018690 : assert( nb_bits <= 16 );
3148 :
3149 129018690 : nbits_total = st->total_brate / FRAMES_PER_SEC;
3150 : /* detect corrupted bitstream */
3151 129018690 : if ( st->next_bit_pos + nb_bits > nbits_total )
3152 : {
3153 0 : st->BER_detect = 1;
3154 0 : return ( 0 );
3155 : }
3156 :
3157 129018690 : value = 0;
3158 598890396 : for ( i = 0; i < nb_bits; i++ )
3159 : {
3160 469871706 : value <<= 1;
3161 469871706 : value += st->bit_stream[st->next_bit_pos + i];
3162 : }
3163 : #ifdef DEBUG_BS_READ_WRITE
3164 : printf( "%s: %d: %d: %d\n", func, line, nb_bits, value );
3165 : #endif
3166 :
3167 : /* update the position in the bitstream */
3168 129018690 : st->next_bit_pos += nb_bits;
3169 :
3170 129018690 : return value;
3171 : }
3172 :
3173 : /*-------------------------------------------------------------------*
3174 : * get_next_indice_1()
3175 : *
3176 : * Get the next 1-bit indice from the buffer
3177 : *-------------------------------------------------------------------*/
3178 :
3179 : /*! r: value of the indice */
3180 560911155 : uint16_t get_next_indice_1(
3181 : Decoder_State *st /* i/o: decoder state structure */
3182 : )
3183 : {
3184 : int32_t nbits_total;
3185 560911155 : nbits_total = st->total_brate / FRAMES_PER_SEC;
3186 : /* detect corrupted bitstream */
3187 560911155 : if ( ( st->next_bit_pos + 1 > nbits_total && st->codec_mode == MODE1 ) ||
3188 560911155 : ( ( st->next_bit_pos + 1 > nbits_total + ( 2 * 8 ) ) && st->codec_mode == MODE2 ) /* add two zero bytes for arithmetic coder flush */
3189 : )
3190 : {
3191 0 : st->BER_detect = 1;
3192 0 : return ( 0 );
3193 : }
3194 :
3195 560911155 : return st->bit_stream[st->next_bit_pos++];
3196 : }
3197 :
3198 : /*-------------------------------------------------------------------*
3199 : * get_next_indice_tmp()
3200 : *
3201 : * update the total number of bits and the position in the bitstream
3202 : *-------------------------------------------------------------------*/
3203 :
3204 6133494 : void get_next_indice_tmp(
3205 : Decoder_State *st, /* o : decoder state structure */
3206 : int16_t nb_bits /* i : number of bits that were used to quantize the indice */
3207 : )
3208 : {
3209 : /* update the position in the bitstream */
3210 6133494 : st->next_bit_pos += nb_bits;
3211 :
3212 6133494 : return;
3213 : }
3214 :
3215 : /*-------------------------------------------------------------------*
3216 : * get_indice()
3217 : *
3218 : * Get indice at specific position in the buffer
3219 : *-------------------------------------------------------------------*/
3220 :
3221 : /*! r: value of the indice */
3222 : #ifdef DEBUG_BS_READ_WRITE
3223 : uint16_t get_indice_(
3224 : #else
3225 1726299 : uint16_t get_indice(
3226 : #endif
3227 : Decoder_State *st, /* i/o: decoder state structure */
3228 : int16_t pos, /* i : absolute position in the bitstream (update after the read) */
3229 : int16_t nb_bits /* i : number of bits that were used to quantize the indice */
3230 : #ifdef DEBUG_BS_READ_WRITE
3231 : ,
3232 : int16_t line,
3233 : const char *func
3234 : #endif
3235 : )
3236 : {
3237 : uint16_t value;
3238 : int16_t i;
3239 : int32_t nbits_total;
3240 :
3241 1726299 : assert( nb_bits <= 16 );
3242 :
3243 1726299 : nbits_total = st->total_brate / FRAMES_PER_SEC;
3244 :
3245 : /* detect corrupted bitstream */
3246 1726299 : if ( pos + nb_bits > nbits_total )
3247 : {
3248 0 : st->BER_detect = 1;
3249 0 : return ( 0 );
3250 : }
3251 :
3252 1726299 : value = 0;
3253 10880556 : for ( i = 0; i < nb_bits; i++ )
3254 : {
3255 9154257 : value <<= 1;
3256 9154257 : value += st->bit_stream[pos + i];
3257 : }
3258 : #ifdef DEBUG_BS_READ_WRITE
3259 : printf( "%s: %d: %d: %d\n", func, line, nb_bits, value );
3260 : #endif
3261 1726299 : return value;
3262 : }
3263 :
3264 : /*-------------------------------------------------------------------*
3265 : * get_indice_st()
3266 : *
3267 : * Get indice at specific position in the buffer
3268 : *-------------------------------------------------------------------*/
3269 :
3270 : /*! r: value of the indice */
3271 57324 : uint16_t get_indice_st(
3272 : Decoder_State *st, /* i/o: decoder state structure */
3273 : const int32_t element_brate, /* i : element bitrate */
3274 : const int16_t pos, /* i : absolute position in the bitstream */
3275 : const int16_t nb_bits /* i : number of bits to quantize the indice */
3276 : )
3277 : {
3278 : uint16_t value;
3279 : int16_t i;
3280 :
3281 57324 : assert( nb_bits <= 16 );
3282 :
3283 : /* detect corrupted bitstream */
3284 57324 : if ( pos + nb_bits > element_brate / FRAMES_PER_SEC )
3285 : {
3286 0 : st->BER_detect = 1;
3287 0 : return ( 0 );
3288 : }
3289 :
3290 57324 : value = 0;
3291 186180 : for ( i = 0; i < nb_bits; i++ )
3292 : {
3293 128856 : value <<= 1;
3294 128856 : value += st->bit_stream[pos + i];
3295 : }
3296 :
3297 57324 : return value;
3298 : }
3299 :
3300 : /*-------------------------------------------------------------------*
3301 : * get_indice_1()
3302 : *
3303 : * Get a 1-bit indice at specific position in the buffer
3304 : *-------------------------------------------------------------------*/
3305 :
3306 : /*! r: value of the indice */
3307 208642077 : uint16_t get_indice_1(
3308 : Decoder_State *st, /* i/o: decoder state structure */
3309 : int16_t pos /* i : absolute position in the bitstream (update after the read) */
3310 : )
3311 : {
3312 : int32_t nbits_total;
3313 208642077 : nbits_total = st->total_brate / FRAMES_PER_SEC;
3314 : /* detect corrupted bitstream */
3315 208642077 : if ( pos + 1 > nbits_total )
3316 : {
3317 0 : st->BER_detect = 1;
3318 0 : return ( 0 );
3319 : }
3320 :
3321 208642077 : return st->bit_stream[pos];
3322 : }
3323 :
3324 :
3325 : /*-------------------------------------------------------------------*
3326 : * reset_indices_enc()
3327 : *
3328 : * Reset the buffer of encoder indices
3329 : *-------------------------------------------------------------------*/
3330 :
3331 1983856 : void reset_indices_enc(
3332 : BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
3333 : const int16_t max_num_indices /* i : max number of indices */
3334 : )
3335 : {
3336 : int16_t i;
3337 :
3338 1983856 : hBstr->nb_bits_tot = 0;
3339 1983856 : hBstr->nb_ind_tot = 0;
3340 :
3341 283057720 : for ( i = 0; i < max_num_indices; i++ )
3342 : {
3343 281073864 : hBstr->ind_list[i].nb_bits = -1;
3344 : }
3345 :
3346 1983856 : return;
3347 : }
3348 :
3349 : /*-------------------------------------------------------------------*
3350 : * reset_indices_dec()
3351 : *
3352 : * Reset the buffer of decoder indices
3353 : *-------------------------------------------------------------------*/
3354 :
3355 7076178 : void reset_indices_dec(
3356 : Decoder_State *st )
3357 : {
3358 7076178 : st->next_bit_pos = 0;
3359 :
3360 7076178 : return;
3361 : }
3362 :
3363 :
3364 : /*-------------------------------------------------------------------*
3365 : * write_indices_to_stream()
3366 : *
3367 : * writing forward or backward to a serial stream
3368 : *-------------------------------------------------------------------*/
3369 :
3370 1500441 : static int16_t write_indices_to_stream(
3371 : Indice *ind_list,
3372 : uint16_t **pt_stream,
3373 : const int16_t inc,
3374 : const int16_t num_indices )
3375 : {
3376 : int16_t i, k;
3377 : int16_t value, nb_bits;
3378 : uint16_t mask;
3379 : #ifdef ENABLE_BITRATE_VERIFICATION
3380 : int16_t total_nb_bits = 0;
3381 : #endif
3382 :
3383 192004491 : for ( i = 0; i < num_indices; i++ )
3384 : {
3385 190504050 : value = ind_list[i].value;
3386 190504050 : nb_bits = ind_list[i].nb_bits;
3387 :
3388 190504050 : if ( nb_bits > 0 )
3389 : {
3390 : #ifdef ENABLE_BITRATE_VERIFICATION
3391 : total_nb_bits += nb_bits;
3392 : #endif
3393 : /* mask from MSB to LSB */
3394 190406187 : mask = 1 << ( nb_bits - 1 );
3395 :
3396 : /* write bit by bit */
3397 1178550163 : for ( k = 0; k < nb_bits; k++ )
3398 : {
3399 988143976 : if ( value & mask )
3400 : {
3401 477136556 : **pt_stream = 1;
3402 477136556 : *pt_stream += inc;
3403 : }
3404 : else
3405 : {
3406 511007420 : **pt_stream = 0;
3407 511007420 : *pt_stream += inc;
3408 : }
3409 :
3410 988143976 : mask >>= 1;
3411 : }
3412 : }
3413 : #ifdef DEBUGGING
3414 : else if ( nb_bits == 0 )
3415 : {
3416 : /* fprintf( stderr, "Warning: %s: nb_bits == 0!\n", __func__ ); */
3417 : }
3418 : else
3419 : {
3420 : /* fprintf( stderr, "Warning: %s: nb_bits == %d!\n", __func__, nb_bits ); */
3421 : }
3422 : #endif
3423 : }
3424 : #ifdef ENABLE_BITRATE_VERIFICATION
3425 : return total_nb_bits;
3426 : #else
3427 1500441 : return 0;
3428 : #endif
3429 : }
3430 :
3431 : /*-------------------------------------------------------------------*
3432 : * write_indices_element()
3433 : *
3434 : * Bitstream writing function of one element (one SCE or one CPE)
3435 : *-------------------------------------------------------------------*/
3436 :
3437 774868 : static ivas_error write_indices_element(
3438 : Encoder_Struct *st_ivas, /* i/o: IVAS encoder structure */
3439 : uint16_t **pt_stream, /* i : pointer to bitstream buffer */
3440 : const int16_t is_SCE, /* i : flag to distingusih SCE and CPE */
3441 : const int16_t element_id /* i : id of the SCE or CPE */
3442 : )
3443 : {
3444 : int16_t ch;
3445 774868 : Encoder_State **sts = NULL;
3446 : uint16_t *pt_stream_loc;
3447 : uint16_t *pt_stream_backup;
3448 : uint16_t *pt_stream_end;
3449 : int16_t nb_bits_tot_metadata;
3450 : int16_t nb_ind_tot_metadata;
3451 :
3452 : Indice *ind_list_metadata;
3453 : int16_t n, n_channels;
3454 : #ifdef ENABLE_BITRATE_VERIFICATION
3455 : int16_t total_nb_bits;
3456 : #endif
3457 : ivas_error error;
3458 :
3459 774868 : error = IVAS_ERR_OK;
3460 :
3461 774868 : ind_list_metadata = NULL;
3462 774868 : nb_ind_tot_metadata = 0;
3463 :
3464 774868 : if ( st_ivas->hEncoderConfig->ivas_format == MONO_FORMAT )
3465 : {
3466 3100 : sts = st_ivas->hSCE[0]->hCoreCoder;
3467 3100 : nb_bits_tot_metadata = 0;
3468 : }
3469 : else
3470 : {
3471 771768 : nb_bits_tot_metadata = 0;
3472 771768 : if ( is_SCE && st_ivas->hSCE[element_id] != NULL )
3473 : {
3474 350913 : sts = st_ivas->hSCE[element_id]->hCoreCoder;
3475 :
3476 350913 : if ( st_ivas->hSCE[element_id]->hMetaData != NULL )
3477 : {
3478 180485 : nb_bits_tot_metadata = st_ivas->hSCE[element_id]->hMetaData->nb_bits_tot;
3479 180485 : ind_list_metadata = st_ivas->hSCE[element_id]->hMetaData->ind_list;
3480 180485 : nb_ind_tot_metadata = st_ivas->hSCE[element_id]->hMetaData->nb_ind_tot;
3481 : }
3482 : }
3483 420855 : else if ( !is_SCE && st_ivas->hCPE[element_id] != NULL )
3484 : {
3485 420855 : sts = st_ivas->hCPE[element_id]->hCoreCoder;
3486 :
3487 420855 : if ( st_ivas->hCPE[element_id]->hMetaData != NULL )
3488 : {
3489 251486 : nb_bits_tot_metadata = st_ivas->hCPE[element_id]->hMetaData->nb_bits_tot;
3490 251486 : ind_list_metadata = st_ivas->hCPE[element_id]->hMetaData->ind_list;
3491 251486 : nb_ind_tot_metadata = st_ivas->hCPE[element_id]->hMetaData->nb_ind_tot;
3492 : }
3493 : }
3494 : #ifdef DEBUGGING
3495 : else
3496 : {
3497 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: Bitstream writing error in frame %d. Exiting!\n", frame );
3498 : }
3499 : #endif
3500 : }
3501 :
3502 774868 : n_channels = 1;
3503 774868 : if ( sts[0]->element_mode > IVAS_CPE_DFT )
3504 : {
3505 361176 : n_channels = CPE_CHANNELS;
3506 : }
3507 :
3508 : /*----------------------------------------------------------------*
3509 : * Bitstream packing (conversion of individual indices into a serial stream)
3510 : *----------------------------------------------------------------*/
3511 :
3512 774868 : pt_stream_loc = *pt_stream;
3513 774868 : pt_stream_end = pt_stream_loc;
3514 :
3515 1910912 : for ( n = 0; n < n_channels; n++ )
3516 : {
3517 : /* write the metadata buffer */
3518 1136044 : if ( n == 0 && nb_bits_tot_metadata != 0 )
3519 : {
3520 364397 : pt_stream_backup = pt_stream_loc;
3521 :
3522 868459 : for ( ch = 0; ch < n_channels; ch++ )
3523 : {
3524 504062 : pt_stream_loc += sts[ch]->hBstr->nb_bits_tot;
3525 : }
3526 364397 : pt_stream_loc += nb_bits_tot_metadata - 1;
3527 364397 : pt_stream_end = pt_stream_loc + 1;
3528 :
3529 : #ifdef ENABLE_BITRATE_VERIFICATION
3530 : total_nb_bits =
3531 : #endif
3532 364397 : write_indices_to_stream( ind_list_metadata, &pt_stream_loc, -1,
3533 : nb_ind_tot_metadata );
3534 :
3535 : #ifdef ENABLE_BITRATE_VERIFICATION
3536 : if ( total_nb_bits != nb_bits_tot_metadata )
3537 : {
3538 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Bitstream write size mismatch! Written bits: %d vs. Reference bits: %d\n", total_nb_bits, nb_bits_tot_metadata );
3539 : }
3540 : #endif
3541 : /* restore previous pointer position */
3542 364397 : pt_stream_loc = pt_stream_backup;
3543 : }
3544 : #ifdef ENABLE_BITRATE_VERIFICATION
3545 : total_nb_bits =
3546 : #endif
3547 1136044 : write_indices_to_stream( sts[n]->hBstr->ind_list, &pt_stream_loc, 1,
3548 1136044 : sts[n]->hBstr->nb_ind_tot );
3549 :
3550 : #ifdef ENABLE_BITRATE_VERIFICATION
3551 : if ( total_nb_bits != sts[n]->hBstr->nb_bits_tot )
3552 : {
3553 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Bitstream write size mismatch! Written bits: %d vs. Reference bits: %d\n", total_nb_bits, sts[n]->hBstr->nb_bits_tot );
3554 : }
3555 : #endif
3556 1136044 : if ( pt_stream_loc > pt_stream_end )
3557 : {
3558 581060 : pt_stream_end = pt_stream_loc;
3559 : }
3560 : }
3561 :
3562 : #if defined( DEBUGGING ) && defined( DBG_BITSTREAM_ANALYSIS )
3563 : if ( is_SCE ) /* EVS and SCE */
3564 : {
3565 : static FILE *f1 = 0;
3566 :
3567 : if ( f1 == 0 )
3568 : f1 = fopen( "bitstream_text", "w" );
3569 :
3570 : for ( int16_t i = 0; i < sts[0]->hBstr->nb_ind_tot; i++ )
3571 : {
3572 : Indice *ind_list = sts[0]->hBstr->ind_list;
3573 : int16_t value = ind_list[i].value;
3574 : int16_t nb_bits = ind_list[i].nb_bits;
3575 : char *function_name = ind_list[i].function_name;
3576 :
3577 : fprintf( f1, "%d %d %d %s %d %d\n", frame, element_id, i, function_name, nb_bits, value );
3578 : }
3579 :
3580 : if ( st_ivas->hSCE[element_id]->hMetaData != NULL )
3581 : {
3582 : for ( int16_t i = 0; i < st_ivas->hSCE[element_id]->hMetaData->nb_ind_tot; i++ )
3583 : {
3584 : Indice *ind_list = st_ivas->hSCE[element_id]->hMetaData->ind_list;
3585 : int16_t value = ind_list[i].value;
3586 : int16_t nb_bits = ind_list[i].nb_bits;
3587 : char *function_name = ind_list[i].function_name;
3588 :
3589 : fprintf( f1, "%d %d %d %s %d %d\n", frame, element_id, i, function_name, nb_bits, value );
3590 : }
3591 : }
3592 : }
3593 : else
3594 : {
3595 : static FILE *f1 = 0;
3596 :
3597 : if ( f1 == 0 )
3598 : f1 = fopen( "bitstream_text", "w" );
3599 :
3600 :
3601 : for ( n = 0; n < n_channels; n++ )
3602 : {
3603 : for ( int16_t i = 0; i < sts[n]->hBstr->nb_ind_tot; i++ )
3604 : {
3605 : Indice *ind_list = sts[n]->hBstr->ind_list;
3606 : int16_t value = ind_list[i].value;
3607 : int16_t nb_bits = ind_list[i].nb_bits;
3608 : char *function_name = ind_list[i].function_name;
3609 :
3610 : fprintf( f1, "%d %d %d %d %s %d %d\n", frame, element_id, n, i, function_name, nb_bits, value );
3611 : }
3612 : }
3613 :
3614 : if ( st_ivas->hCPE[element_id]->hMetaData != NULL )
3615 : {
3616 : for ( int16_t i = 0; i < st_ivas->hCPE[element_id]->hMetaData->nb_ind_tot; i++ )
3617 : {
3618 : Indice *ind_list = st_ivas->hCPE[element_id]->hMetaData->ind_list;
3619 : int16_t value = ind_list[i].value;
3620 : int16_t nb_bits = ind_list[i].nb_bits;
3621 : char *function_name = ind_list[i].function_name;
3622 :
3623 : fprintf( f1, "%d %d %d %d %s %d %d\n", frame, element_id, -1, i, function_name, nb_bits, value );
3624 : }
3625 : }
3626 : }
3627 : #endif
3628 :
3629 : /*----------------------------------------------------------------*
3630 : * Clearing of indices
3631 : * Reset index pointers
3632 : *----------------------------------------------------------------*/
3633 :
3634 774868 : if ( is_SCE ) /* EVS and SCE */
3635 : {
3636 354013 : if ( st_ivas->hSCE[element_id]->hMetaData != NULL )
3637 : {
3638 180485 : reset_indices_enc( st_ivas->hSCE[element_id]->hMetaData, st_ivas->hSCE[element_id]->hMetaData->nb_ind_tot );
3639 : }
3640 :
3641 354013 : reset_indices_enc( sts[0]->hBstr, sts[0]->hBstr->nb_ind_tot );
3642 : }
3643 : else
3644 : {
3645 420855 : if ( st_ivas->hCPE[element_id]->hMetaData != NULL )
3646 : {
3647 251486 : reset_indices_enc( st_ivas->hCPE[element_id]->hMetaData, st_ivas->hCPE[element_id]->hMetaData->nb_ind_tot );
3648 : }
3649 :
3650 1202886 : for ( n = 0; n < n_channels; n++ )
3651 : {
3652 782031 : reset_indices_enc( sts[n]->hBstr, sts[n]->hBstr->nb_ind_tot );
3653 : }
3654 : }
3655 :
3656 : /* update pointer */
3657 774868 : *pt_stream = pt_stream_end;
3658 :
3659 774868 : return error;
3660 : }
3661 :
3662 : /*-------------------------------------------------------------------*
3663 : * write_indices_ivas()
3664 : *
3665 : * Write the buffer of indices to a serial bitstream buffer,
3666 : * each bit represented as a uint16_t of value 0 or 1
3667 : *-------------------------------------------------------------------*/
3668 :
3669 427388 : ivas_error write_indices_ivas(
3670 : Encoder_Struct *st_ivas, /* i/o: encoder state structure */
3671 : uint16_t *bit_stream, /* i/o: output bitstream */
3672 : uint16_t *num_bits /* i : number of indices written to output */
3673 : )
3674 : {
3675 : int16_t i, n;
3676 : uint16_t *pt_stream;
3677 : #ifdef ENABLE_BITRATE_VERIFICATION
3678 : Encoder_State **sts;
3679 : int32_t ivas_total_brate;
3680 : int16_t ch;
3681 : #endif
3682 : ivas_error error;
3683 :
3684 427388 : error = IVAS_ERR_OK;
3685 :
3686 427388 : pt_stream = bit_stream;
3687 4376880508 : for ( i = 0; i < MAX_BITS_PER_FRAME; ++i )
3688 : {
3689 4376453120 : bit_stream[i] = 0;
3690 : }
3691 :
3692 : #ifdef ENABLE_BITRATE_VERIFICATION
3693 : i = 0;
3694 :
3695 : for ( n = 0; n < st_ivas->nSCE; n++ )
3696 : {
3697 : sts = st_ivas->hSCE[n]->hCoreCoder;
3698 : i += sts[0]->hBstr->nb_bits_tot;
3699 :
3700 : if ( st_ivas->hSCE[n]->hMetaData != NULL )
3701 : {
3702 : i += st_ivas->hSCE[n]->hMetaData->nb_bits_tot;
3703 : }
3704 : }
3705 :
3706 : for ( n = 0; n < st_ivas->nCPE; n++ )
3707 : {
3708 : sts = st_ivas->hCPE[n]->hCoreCoder;
3709 : for ( ch = 0; ch < CPE_CHANNELS; ch++ )
3710 : {
3711 : i += sts[ch]->hBstr->nb_bits_tot;
3712 : }
3713 :
3714 : if ( st_ivas->hCPE[n]->hMetaData != NULL )
3715 : {
3716 : i += st_ivas->hCPE[n]->hMetaData->nb_bits_tot;
3717 : }
3718 : }
3719 :
3720 : ivas_total_brate = st_ivas->hEncoderConfig->ivas_total_brate;
3721 : if ( st_ivas->hEncoderConfig->Opt_SC_VBR )
3722 : {
3723 : ivas_total_brate = st_ivas->hSCE[0]->hCoreCoder[0]->total_brate;
3724 : }
3725 :
3726 : if ( i * FRAMES_PER_SEC != ivas_total_brate && i >= ACELP_11k60 / FRAMES_PER_SEC )
3727 : {
3728 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Bitstream write size mismatch! Actual bitrate: %ld vs. Reference bitrate: %d\n", i * 50L, ivas_total_brate );
3729 : }
3730 : #endif
3731 :
3732 : /*-----------------------------------------------------------------*
3733 : * Encode Payload
3734 : *-----------------------------------------------------------------*/
3735 :
3736 781401 : for ( n = 0; n < st_ivas->nSCE; n++ )
3737 : {
3738 354013 : write_indices_element( st_ivas, &pt_stream, 1, n );
3739 : }
3740 :
3741 848243 : for ( n = 0; n < st_ivas->nCPE; n++ )
3742 : {
3743 420855 : write_indices_element( st_ivas, &pt_stream, 0, n );
3744 : }
3745 :
3746 427388 : *num_bits = (uint16_t) ( pt_stream - bit_stream );
3747 :
3748 427388 : return error;
3749 : }
3750 :
3751 :
3752 : /*---------------------------------------------------------------------*
3753 : * convertSerialToBytestream( )
3754 : *
3755 : * convert 16-bit short serial streams with 0x0000 and 0x0001 to a bytstream
3756 : *---------------------------------------------------------------------*/
3757 :
3758 0 : void convertSerialToBytestream(
3759 : const uint16_t *const serial, /* i : input serial bitstream with values 0 and 1 */
3760 : const uint16_t num_bits, /* i : number of bits in the input bitstream */
3761 : uint8_t *const bytestream /* o : output compact bitstream (bytestream) */
3762 : )
3763 : {
3764 : uint32_t i;
3765 : uint8_t bit, bitinbyte;
3766 :
3767 0 : for ( i = 0; i < num_bits; ++i )
3768 : {
3769 0 : bit = ( serial[i] == 0x0001 ) ? 1 : 0;
3770 0 : bitinbyte = bit << ( 7 - ( i & 0x7 ) );
3771 0 : if ( !( i & 0x7 ) )
3772 : {
3773 0 : bytestream[i >> 3] = 0;
3774 : }
3775 0 : bytestream[i >> 3] |= bitinbyte;
3776 : }
3777 :
3778 0 : return;
3779 : }
3780 :
3781 : /*---------------------------------------------------------------------*
3782 : * convertBytestreamToSerial( )
3783 : *
3784 : * convert bytestream to 16-bit short serial streams with 0x0000 and 0x0001
3785 : *---------------------------------------------------------------------*/
3786 :
3787 0 : void convertBytestreamToSerial(
3788 : const uint8_t *const bytestream, /* i : input compact bitstream (bytestream) */
3789 : const uint16_t num_bits, /* i : number of bits in the input bitstream */
3790 : uint16_t *const serial /* o : output serial bitstream with values 0 and 1 */
3791 : )
3792 : {
3793 : uint32_t i;
3794 :
3795 0 : for ( i = 0; i < num_bits; ++i )
3796 : {
3797 0 : serial[i] = ( bytestream[( i >> 3 )] >> ( 7 - ( i & 7 ) ) ) & 0x1;
3798 : }
3799 0 : }
3800 :
3801 :
3802 : /*-------------------------------------------------------------------*
3803 : * decoder_selectCodec()
3804 : *
3805 : *
3806 : *-------------------------------------------------------------------*/
3807 :
3808 9300 : static void decoder_selectCodec(
3809 : Decoder_State *st, /* i/o: decoder state structure */
3810 : const int32_t total_brate, /* i : total bitrate */
3811 : const int16_t bit0 /* i : first bit */
3812 : )
3813 : {
3814 : /* set the AMR-WB IO flag */
3815 9300 : if ( rate2AMRWB_IOmode( total_brate ) != -1 )
3816 : {
3817 0 : st->Opt_AMR_WB = 1;
3818 : }
3819 9300 : else if ( total_brate != FRAME_NO_DATA )
3820 : {
3821 9300 : st->Opt_AMR_WB = 0;
3822 : }
3823 :
3824 9300 : if ( st->Opt_AMR_WB )
3825 : {
3826 0 : st->codec_mode = MODE1;
3827 : }
3828 : else
3829 : {
3830 9300 : st->codec_mode = get_codec_mode( total_brate );
3831 :
3832 9300 : if ( st->codec_mode == -1 )
3833 : {
3834 0 : switch ( total_brate )
3835 : {
3836 0 : case 0:
3837 0 : st->codec_mode = st->last_codec_mode;
3838 0 : break;
3839 0 : case 2400:
3840 0 : st->codec_mode = st->last_codec_mode;
3841 0 : break;
3842 0 : case 2800:
3843 0 : st->codec_mode = MODE1;
3844 0 : break;
3845 0 : default: /* validate that total_brate (derived from RTP packet or a file header) is one of the defined bitrates */
3846 : #ifdef DEBUGGING
3847 : IVAS_ERROR( IVAS_ERR_INTERNAL, "Error illegal total bitrate (= %d) \n", total_brate );
3848 : #endif
3849 0 : st->codec_mode = st->last_codec_mode;
3850 0 : st->bfi = 1;
3851 0 : break;
3852 : }
3853 9300 : }
3854 : }
3855 :
3856 9300 : if ( st->ini_frame == 0 )
3857 : {
3858 9 : if ( st->codec_mode == -1 )
3859 : {
3860 0 : st->codec_mode = MODE1;
3861 : }
3862 9 : st->last_codec_mode = st->codec_mode;
3863 : }
3864 :
3865 : /* set SID/CNG type */
3866 9300 : if ( total_brate == SID_2k40 )
3867 : {
3868 0 : if ( bit0 == 0 )
3869 : {
3870 0 : st->cng_type = LP_CNG;
3871 :
3872 : /* force MODE1 when selecting LP_CNG */
3873 0 : st->codec_mode = MODE1;
3874 : }
3875 0 : else if ( bit0 == 1 )
3876 : {
3877 0 : st->cng_type = FD_CNG;
3878 0 : if ( st->last_codec_mode == MODE2 && st->last_total_brate == ACELP_13k20 )
3879 : {
3880 0 : st->codec_mode = MODE1;
3881 : }
3882 : }
3883 : }
3884 :
3885 9300 : return;
3886 : }
3887 :
3888 : /*-------------------------------------------------------------------*
3889 : * dec_prm_core()
3890 : *
3891 : *
3892 : *-------------------------------------------------------------------*/
3893 :
3894 3150 : static void dec_prm_core(
3895 : Decoder_State *st )
3896 : {
3897 3150 : int16_t n, frame_size_index = -1;
3898 :
3899 3150 : st->core = -1;
3900 :
3901 3150 : if ( st->total_brate == FRAME_NO_DATA )
3902 : {
3903 0 : st->m_frame_type = ZERO_FRAME;
3904 : }
3905 3150 : else if ( st->total_brate == SID_2k40 )
3906 : {
3907 0 : st->m_frame_type = SID_FRAME;
3908 : }
3909 : else
3910 : {
3911 3150 : st->m_frame_type = ACTIVE_FRAME;
3912 25200 : for ( n = 0; n < FRAME_SIZE_NB; ++n )
3913 : {
3914 25200 : if ( FrameSizeConfig[n].frame_bits == st->total_brate / FRAMES_PER_SEC )
3915 : {
3916 3150 : frame_size_index = n;
3917 3150 : break;
3918 : }
3919 : }
3920 : #ifdef DEBUGGING
3921 : if ( n == FRAME_SIZE_NB )
3922 : {
3923 : assert( !"Bitrate not supported: not part of EVS" );
3924 : }
3925 : #endif
3926 :
3927 : /* Get audio bandwidth info */
3928 3150 : st->bwidth = get_next_indice( st, FrameSizeConfig[frame_size_index].bandwidth_bits );
3929 3150 : st->bwidth += FrameSizeConfig[frame_size_index].bandwidth_min;
3930 3150 : if ( st->bwidth > FB )
3931 : {
3932 0 : st->bwidth = FB;
3933 0 : st->BER_detect = 1;
3934 : }
3935 :
3936 3150 : if ( st->bwidth > SWB && st->total_brate < ACELP_16k40 )
3937 : {
3938 0 : st->bwidth = SWB;
3939 0 : st->BER_detect = 1;
3940 : }
3941 : /* Skip reserved bit */
3942 3150 : get_next_indice_tmp( st, FrameSizeConfig[frame_size_index].reserved_bits );
3943 :
3944 3150 : if ( get_next_indice_1( st ) ) /* TCX */
3945 : {
3946 1338 : if ( get_next_indice_1( st ) )
3947 : {
3948 225 : st->core = HQ_CORE;
3949 : }
3950 : else
3951 : {
3952 1113 : st->core = TCX_20_CORE;
3953 : }
3954 : }
3955 : else /* ACELP */
3956 : {
3957 1812 : st->core = ACELP_CORE;
3958 : }
3959 : }
3960 :
3961 3150 : return;
3962 : }
3963 :
3964 : /*-----------------------------------------------------------------*
3965 : * decision_matrix_core_dec()
3966 : *
3967 : * Read core signaling bits from the bitstream
3968 : * Set st->core, and st->bwidth if signalled together with the core.
3969 : *-----------------------------------------------------------------*/
3970 :
3971 3150 : static void decision_matrix_core_dec(
3972 : Decoder_State *st /* i/o: decoder state structure */
3973 : )
3974 : {
3975 : int16_t start_idx;
3976 : int32_t ind;
3977 : int16_t nBits;
3978 :
3979 3150 : assert( st->bfi != 1 );
3980 :
3981 3150 : st->core = -1;
3982 3150 : st->bwidth = -1;
3983 :
3984 3150 : if ( st->total_brate == FRAME_NO_DATA || st->total_brate == SID_2k40 )
3985 : {
3986 0 : st->core = ACELP_CORE;
3987 : }
3988 : /* SC-VBR */
3989 3150 : else if ( st->total_brate == PPP_NELP_2k80 )
3990 : {
3991 0 : st->core = ACELP_CORE;
3992 0 : return;
3993 : }
3994 :
3995 : /*---------------------------------------------------------------------*
3996 : * ACELP/HQ core selection
3997 : *---------------------------------------------------------------------*/
3998 :
3999 3150 : if ( st->total_brate < ACELP_24k40 )
4000 : {
4001 3150 : st->core = ACELP_CORE;
4002 : }
4003 0 : else if ( st->total_brate >= ACELP_24k40 && st->total_brate <= ACELP_64k )
4004 : {
4005 : /* read the ACELP/HQ core selection bit */
4006 0 : st->core = get_next_indice( st, 1 ) * HQ_CORE;
4007 : }
4008 : else
4009 : {
4010 0 : st->core = HQ_CORE;
4011 : }
4012 :
4013 : /*-----------------------------------------------------------------*
4014 : * Read ACELP signaling bits from the bitstream
4015 : *-----------------------------------------------------------------*/
4016 :
4017 3150 : if ( st->core == ACELP_CORE )
4018 : {
4019 : /* find the section in the ACELP signaling table corresponding to bitrate */
4020 3150 : start_idx = 0;
4021 110250 : while ( acelp_sig_tbl[start_idx] != st->total_brate )
4022 : {
4023 107100 : start_idx++;
4024 : #ifdef DEBUGGING
4025 : assert( ( start_idx < 194 ) && "ERROR: start_idx larger than acelp_sig_tbl[].\n" );
4026 : #endif
4027 : }
4028 :
4029 : /* skip the bitrate */
4030 3150 : start_idx += 1;
4031 :
4032 : /* retrieve the number of bits */
4033 3150 : nBits = (int16_t) acelp_sig_tbl[start_idx++];
4034 :
4035 : /* retrieve the signaling indice */
4036 3150 : ind = acelp_sig_tbl[start_idx + get_next_indice( st, nBits )];
4037 3150 : st->bwidth = ( ind >> 3 ) & 0x7;
4038 :
4039 : /* convert signaling indice into signaling information */
4040 3150 : if ( ( ind & 0x7 ) == LR_MDCT )
4041 : {
4042 927 : st->core = HQ_CORE;
4043 : }
4044 : }
4045 :
4046 : /*-----------------------------------------------------------------*
4047 : * Read HQ signaling bits from the bitstream
4048 : * Set HQ core type
4049 : *-----------------------------------------------------------------*/
4050 :
4051 3150 : if ( st->core == HQ_CORE )
4052 : {
4053 : /* read the HQ/TCX core switching flag */
4054 927 : if ( get_next_indice( st, 1 ) )
4055 : {
4056 825 : st->core = TCX_20_CORE;
4057 : }
4058 :
4059 : /* For TCX: read/set band-width (needed for different I/O sampling rate support) */
4060 927 : if ( st->core == TCX_20_CORE && st->total_brate > ACELP_16k40 )
4061 : {
4062 0 : ind = get_next_indice( st, 2 );
4063 :
4064 0 : if ( ind == 0 )
4065 : {
4066 0 : st->bwidth = NB;
4067 : }
4068 0 : else if ( ind == 1 )
4069 : {
4070 0 : st->bwidth = WB;
4071 : }
4072 0 : else if ( ind == 2 )
4073 : {
4074 0 : st->bwidth = SWB;
4075 : }
4076 : else
4077 : {
4078 0 : st->bwidth = FB;
4079 : }
4080 : }
4081 : }
4082 :
4083 3150 : return;
4084 : }
4085 :
4086 : /*-------------------------------------------------------------------*
4087 : * mdct_switching_dec()
4088 : *
4089 : * Set up MDCT core switching if indicated in the bitstream
4090 : *-------------------------------------------------------------------*/
4091 :
4092 9300 : void mdct_switching_dec(
4093 : Decoder_State *st /* i/o: decoder state structure */
4094 : )
4095 : {
4096 9300 : if ( !st->bfi )
4097 : {
4098 :
4099 9300 : if ( st->Opt_AMR_WB )
4100 : {
4101 0 : return;
4102 : }
4103 :
4104 :
4105 9300 : if ( st->total_brate == ACELP_13k20 || st->total_brate == ACELP_32k )
4106 : {
4107 3150 : st->mdct_sw_enable = MODE1;
4108 : }
4109 6150 : else if ( ACELP_16k40 <= st->total_brate && st->total_brate <= ACELP_24k40 )
4110 : {
4111 3150 : st->mdct_sw_enable = MODE2;
4112 : }
4113 :
4114 9300 : if ( st->codec_mode == MODE1 && st->mdct_sw_enable == MODE1 )
4115 3150 : {
4116 : /* Read ahead core signaling */
4117 3150 : int16_t next_bit_pos_save = st->next_bit_pos;
4118 3150 : int16_t core_save = st->core;
4119 3150 : int16_t bwidth_save = st->bwidth;
4120 :
4121 3150 : decision_matrix_core_dec( st ); /* sets st->core */
4122 :
4123 3150 : if ( st->core == TCX_20_CORE )
4124 : {
4125 : /* Trigger TCX */
4126 825 : st->codec_mode = MODE2;
4127 825 : st->mdct_sw = MODE1;
4128 : }
4129 : else
4130 : {
4131 : /* Rewind bitstream */
4132 2325 : st->next_bit_pos = next_bit_pos_save;
4133 2325 : if ( st->bfi )
4134 : {
4135 0 : st->core = core_save;
4136 0 : st->bwidth = bwidth_save;
4137 : }
4138 : }
4139 : }
4140 6150 : else if ( st->codec_mode == MODE2 && st->mdct_sw_enable == MODE2 )
4141 : {
4142 : /* Read ahead core signaling */
4143 3150 : int16_t next_bit_pos_save = st->next_bit_pos;
4144 3150 : int16_t core_save = st->core;
4145 3150 : int16_t bwidth_save = st->bwidth;
4146 :
4147 3150 : dec_prm_core( st ); /* sets st->core */
4148 :
4149 3150 : if ( st->core == HQ_CORE )
4150 : {
4151 : /* Trigger HQ_CORE */
4152 225 : st->codec_mode = MODE1;
4153 225 : st->mdct_sw = MODE2;
4154 : }
4155 : else
4156 : {
4157 : /* Rewind bitstream */
4158 2925 : st->next_bit_pos = next_bit_pos_save;
4159 2925 : if ( st->bfi )
4160 : {
4161 0 : st->core = core_save;
4162 : }
4163 : /* always reset bwidth, to not interfere with BER logic */
4164 2925 : st->bwidth = bwidth_save;
4165 : }
4166 : }
4167 : }
4168 :
4169 9300 : return;
4170 : }
4171 :
4172 : #ifdef DEBUGGING
4173 : #ifdef ALLOW_BYTE_EP
4174 : /*-------------------------------------------------------------------*
4175 : * ep_type_check()
4176 : *
4177 : *
4178 : *-------------------------------------------------------------------*/
4179 : static Word16 ep_type_check()
4180 : {
4181 : static int16_t ep_type = -1; /* 0=G192 (0x6b21 or 0x6b20), 1=byte(0x21 or 0x20) ,
4182 : 2=ascii "0xa30" or "0xa31" , 3=short( 0x0000 or 0x0001) */
4183 : int16_t tmp;
4184 :
4185 : if ( ep_type < 0 )
4186 : {
4187 : tmp = 0;
4188 :
4189 : if ( fread( &tmp, sizeof( int16_t ), 1, FEC_pattern ) != 1 )
4190 : {
4191 : IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error reading first two bytes from the FEC pattern file !" );
4192 : }
4193 : else
4194 : {
4195 : switch ( tmp )
4196 : {
4197 : case G192_SYNC_BAD_FRAME:
4198 : case G192_SYNC_GOOD_FRAME:
4199 : ep_type = 0; /* G192 */
4200 : break;
4201 : case 0x2020: /* BAD,BAD */
4202 : case 0x2021: /* BAD,SYNC */
4203 : case 0x2120: /* SYNC,BAD */
4204 : case 0x2121: /* SYNC,SYNC */
4205 : ep_type = 1; /* byte */
4206 : break;
4207 : case 0xa31:
4208 : case 0xa30:
4209 : ep_type = 2; /* ascii */
4210 : break;
4211 : case 0x0000:
4212 : case 0x0001:
4213 : ep_type = 3; /* short */
4214 : break;
4215 : default:
4216 : IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error reading the FEC pattern file :: illegal format of the first two byte word=0x%02x ", tmp );
4217 : IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Allowed formats are G192(0x6b20,0x6b21), byte(0x20,0x21), ASCII(\"0\n\" \"1\n\") or short(0x0000, 0x0001) \n" );
4218 : break;
4219 : }
4220 :
4221 : fseek( FEC_pattern, 0L, SEEK_SET ); /* rewind */
4222 : }
4223 : }
4224 : return ep_type;
4225 : }
4226 :
4227 : /*-------------------------------------------------------------------*
4228 : * ep_flag_check_apply()
4229 : *
4230 : *
4231 : *-------------------------------------------------------------------*/
4232 :
4233 : static Word16 ep_flag_check_apply(
4234 : Word16 ep_type,
4235 : Word16 tmp,
4236 : Word16 bfi_so_far )
4237 : {
4238 : if ( ep_type == 0 && ( tmp == G192_SYNC_GOOD_FRAME || tmp == G192_SYNC_BAD_FRAME ) )
4239 : { /* g192 validity check */
4240 : if ( tmp == G192_SYNC_BAD_FRAME )
4241 : {
4242 : return 1;
4243 : }
4244 : }
4245 : else if ( ep_type == 1 && ( tmp == 0x0021 || tmp == 0x0020 ) )
4246 : { /* byte validity check*/
4247 : if ( tmp == 0x0020 )
4248 : {
4249 : return 1;
4250 : }
4251 : }
4252 : else if ( ep_type == 2 && ( tmp == 0x0a31 || tmp == 0x0a30 ) )
4253 : { /* ascii validity check */
4254 : if ( tmp == 0x0a31 )
4255 : {
4256 : return 1;
4257 : }
4258 : }
4259 : else if ( ep_type == 3 && ( tmp == 0 || tmp == 1 ) )
4260 : { /* short validity check */
4261 : if ( tmp == 0x0001 )
4262 : {
4263 : return 1;
4264 : }
4265 : }
4266 : else
4267 : {
4268 : IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error reading the FEC pattern flag 0x%02x from the type %d FEC pattern file , frame=%d", tmp, ep_type, frame );
4269 : }
4270 :
4271 : return bfi_so_far; /* no change */
4272 : }
4273 :
4274 : /*-------------------------------------------------------------------*
4275 : * read_error_flag ( )
4276 : *
4277 : *
4278 : *-------------------------------------------------------------------*/
4279 :
4280 : static Word16 read_error_flag(
4281 : Word16 bfi_so_far )
4282 : {
4283 : Word16 tmp;
4284 : Word16 ep_type;
4285 : Word16 wrap;
4286 : wrap = 0;
4287 :
4288 : ep_type = ep_type_check();
4289 : tmp = 0;
4290 :
4291 : if ( ( ep_type == 1 ) ? ( fread( &tmp, sizeof( int8_t ), 1, FEC_pattern ) != 1 ) /* read byte directly stored in short variable */
4292 : : ( fread( &tmp, sizeof( int16_t ), 1, FEC_pattern ) != 1 ) )
4293 : {
4294 : if ( feof( FEC_pattern ) != 0 )
4295 : {
4296 : wrap = 1; /* wrap event flag */
4297 : fseek( FEC_pattern, 0L, SEEK_SET );
4298 : #ifndef WRAP_AS_EIDXOR
4299 : /* good frame injected in wrap event */
4300 : switch ( ep_type )
4301 : {
4302 : case 0:
4303 : tmp = SYNC_GOOD_FRAME;
4304 : break;
4305 : case 1:
4306 : tmp = 0x21;
4307 : break;
4308 : case 2:
4309 : tmp = 0x0a30;
4310 : break;
4311 : default:
4312 : tmp = 0;
4313 : break; /* 4: short */
4314 : }
4315 : #endif
4316 : }
4317 : else
4318 : {
4319 : IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error reading the FEC pattern file !" );
4320 : }
4321 : }
4322 : #ifdef WRAP_AS_EIDXOR
4323 : if ( wrap != 0 ) /* wrap file and read again, try to get the next flag , */
4324 : {
4325 : tmp = 0; /* needed for byte re-reading */
4326 : if ( ( ep_type == 1 ) ? ( fread( &tmp, sizeof( int8_t ), 1, FEC_pattern ) != 1 ) /* read byte directly stored in short variable */
4327 : : ( fread( &tmp, sizeof( int16_t ), 1, FEC_pattern ) != 1 ) )
4328 : {
4329 : IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error reading the wrapped FEC pattern file !" );
4330 : }
4331 : }
4332 :
4333 : return ep_flag_check_apply( ep_type, tmp, bfi_so_far );
4334 : #else
4335 : if ( wrap == 0 )
4336 : {
4337 : return ep_flag_check_apply( ep_type, tmp, bfi_so_far );
4338 : }
4339 : else
4340 : {
4341 : return bfi_so_far;
4342 : }
4343 : #endif
4344 : }
4345 : #endif
4346 : #endif
4347 :
4348 :
4349 : #ifdef DEBUGGING
4350 : /*-------------------------------------------------------------------*
4351 : * file_read_FECpattern()
4352 : *
4353 : * Simulate packet losses by reading FEC pattern from external file
4354 : *-------------------------------------------------------------------*/
4355 :
4356 : static ivas_error file_read_FECpattern(
4357 : int16_t *bfi )
4358 : {
4359 : ivas_error error;
4360 :
4361 : error = IVAS_ERR_OK;
4362 : *bfi = 0;
4363 :
4364 : /* FEC pattern file provided */
4365 : if ( FEC_pattern != NULL )
4366 : {
4367 : int16_t tmp = 0;
4368 : if ( fread( &tmp, sizeof( int16_t ), 1, FEC_pattern ) != 1 )
4369 : {
4370 : if ( feof( FEC_pattern ) != 0 )
4371 : {
4372 : #ifdef WRAP_AS_EIDXOR
4373 : fseek( FEC_pattern, 0L, SEEK_SET );
4374 : fread( &tmp, sizeof( int16_t ), 1, FEC_pattern );
4375 : #else
4376 : tmp = 0;
4377 : fseek( FEC_pattern, 0L, SEEK_SET );
4378 : #endif
4379 : }
4380 : else
4381 : {
4382 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error reading the FEC pattern file !" );
4383 : }
4384 : }
4385 :
4386 : if ( tmp == 2609 || tmp == 1 || tmp == (uint16_t) 0x6B20 /* == G192_SYNC_BAD_FRAME */ )
4387 : {
4388 : *bfi = 1;
4389 : }
4390 : else
4391 : {
4392 : *bfi = 0;
4393 : }
4394 : }
4395 :
4396 : return error;
4397 : }
4398 : #endif
4399 :
4400 :
4401 : /*-------------------------------------------------------------------*
4402 : * reset_elements()
4403 : *
4404 : * Simulate packet losses by reading FEC pattern from external file
4405 : *-------------------------------------------------------------------*/
4406 :
4407 2507985 : Decoder_State **reset_elements(
4408 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
4409 : )
4410 : {
4411 : int16_t k, n;
4412 2507985 : Decoder_State **sts = NULL; /* to avoid compilation warning */
4413 :
4414 4588977 : for ( k = 0; k < st_ivas->nSCE; k++ )
4415 : {
4416 2080992 : sts = st_ivas->hSCE[k]->hCoreCoder;
4417 :
4418 2080992 : sts[0]->bfi = 0;
4419 2080992 : sts[0]->BER_detect = 0;
4420 2080992 : sts[0]->mdct_sw_enable = 0;
4421 2080992 : sts[0]->mdct_sw = 0;
4422 :
4423 2080992 : reset_indices_dec( sts[0] );
4424 : }
4425 :
4426 5003022 : for ( k = 0; k < st_ivas->nCPE; k++ )
4427 : {
4428 2495037 : sts = st_ivas->hCPE[k]->hCoreCoder;
4429 :
4430 7485111 : for ( n = 0; n < CPE_CHANNELS; n++ )
4431 : {
4432 4990074 : sts[n]->bfi = 0;
4433 4990074 : sts[n]->BER_detect = 0;
4434 4990074 : sts[n]->mdct_sw_enable = 0;
4435 4990074 : sts[n]->mdct_sw = 0;
4436 :
4437 4990074 : reset_indices_dec( sts[n] );
4438 : }
4439 : }
4440 :
4441 2507985 : return sts; /* return last decoder state */
4442 : }
4443 :
4444 :
4445 : /*-------------------------------------------------------------------*
4446 : * ivas_set_bitstream_pointers()
4447 : *
4448 : * Set bitstream pointers for every SCE/CPE Core-Decoder
4449 : *-------------------------------------------------------------------*/
4450 :
4451 1242267 : void ivas_set_bitstream_pointers(
4452 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
4453 : )
4454 : {
4455 : int16_t k, num_bits;
4456 : Decoder_State **sts;
4457 :
4458 1242267 : num_bits = 0;
4459 :
4460 : /* set bitstream pointers for SCEs */
4461 2277375 : for ( k = 0; k < st_ivas->nSCE; k++ )
4462 : {
4463 1035108 : sts = st_ivas->hSCE[k]->hCoreCoder;
4464 1035108 : sts[0]->bit_stream = st_ivas->bit_stream + num_bits;
4465 1035108 : num_bits += (int16_t) ( st_ivas->hSCE[k]->element_brate / FRAMES_PER_SEC );
4466 : }
4467 :
4468 : /* set bitstream pointers for CPEs */
4469 2478390 : for ( k = 0; k < st_ivas->nCPE; k++ )
4470 : {
4471 1236123 : sts = st_ivas->hCPE[k]->hCoreCoder;
4472 1236123 : sts[0]->bit_stream = st_ivas->bit_stream + num_bits;
4473 1236123 : num_bits += (int16_t) ( st_ivas->hCPE[k]->element_brate / FRAMES_PER_SEC );
4474 : }
4475 :
4476 1242267 : return;
4477 : }
4478 :
4479 : #ifdef DEBUGGING
4480 :
4481 : /*-------------------------------------------------------------------*
4482 : * preview_indices()
4483 : *
4484 : * Read indices from serial bitstream to the buffer to print out info
4485 : * about technologies.
4486 : *
4487 : * !!The read parmeters are temporary only and not used for decoding!!
4488 : *-------------------------------------------------------------------*/
4489 :
4490 : ivas_error preview_indices(
4491 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder structure */
4492 : uint16_t bit_stream[], /* i : bitstream buffer */
4493 : UWord16 num_bits /* i : number of bits in bitstream */
4494 : )
4495 : {
4496 : int16_t k, idx;
4497 : int32_t total_brate;
4498 : ivas_error error;
4499 :
4500 : error = IVAS_ERR_OK;
4501 :
4502 : /* convert the frame length to total bitrate */
4503 : total_brate = (int32_t) ( num_bits * FRAMES_PER_SEC );
4504 :
4505 : if ( st_ivas->ivas_format != MONO_FORMAT && is_DTXrate( total_brate ) == 0 )
4506 : {
4507 : /* read IVAS format */
4508 : k = 0;
4509 : if ( bit_stream[0] == 1 )
4510 : {
4511 : k = 1;
4512 : }
4513 : k <<= 1;
4514 : if ( bit_stream[1] == 1 )
4515 : {
4516 : k += 1;
4517 : }
4518 :
4519 : switch ( k )
4520 : {
4521 : case 0:
4522 : st_ivas->ivas_format = STEREO_FORMAT;
4523 : break;
4524 : case 1:
4525 : st_ivas->ivas_format = MC_FORMAT;
4526 : break;
4527 : case 2:
4528 : st_ivas->ivas_format = ISM_FORMAT;
4529 :
4530 : if ( total_brate >= IVAS_24k4 )
4531 : {
4532 : if ( bit_stream[2] )
4533 : {
4534 : if ( bit_stream[3] )
4535 : {
4536 : st_ivas->ivas_format = SBA_ISM_FORMAT;
4537 : }
4538 : else
4539 : {
4540 : st_ivas->ivas_format = MASA_ISM_FORMAT;
4541 : }
4542 : }
4543 : }
4544 : break;
4545 : case 3:
4546 : if ( bit_stream[2] == 0 )
4547 : {
4548 : st_ivas->ivas_format = SBA_FORMAT;
4549 : }
4550 : else
4551 : {
4552 : st_ivas->ivas_format = MASA_FORMAT;
4553 : }
4554 : break;
4555 : }
4556 : }
4557 : else if ( total_brate == IVAS_SID_5k2 )
4558 : {
4559 : /* read SID format */
4560 : st_ivas->sid_format = 0;
4561 : if ( bit_stream[0] == 1 )
4562 : {
4563 : st_ivas->sid_format += 4;
4564 : }
4565 : if ( bit_stream[1] == 1 )
4566 : {
4567 : st_ivas->sid_format += 2;
4568 : }
4569 : if ( bit_stream[2] == 1 )
4570 : {
4571 : st_ivas->sid_format += 1;
4572 : }
4573 :
4574 : switch ( st_ivas->sid_format )
4575 : {
4576 : case SID_DFT_STEREO:
4577 : st_ivas->element_mode_init = IVAS_CPE_DFT;
4578 : st_ivas->ivas_format = STEREO_FORMAT;
4579 : break;
4580 : case SID_MDCT_STEREO:
4581 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
4582 : st_ivas->ivas_format = STEREO_FORMAT;
4583 : break;
4584 : case SID_ISM:
4585 : st_ivas->ivas_format = ISM_FORMAT;
4586 : break;
4587 : case SID_SBA_1TC:
4588 : st_ivas->ivas_format = SBA_FORMAT;
4589 : st_ivas->element_mode_init = IVAS_SCE;
4590 : break;
4591 : case SID_SBA_2TC:
4592 : st_ivas->ivas_format = SBA_FORMAT;
4593 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
4594 : break;
4595 : case SID_MASA_1TC:
4596 : st_ivas->ivas_format = MASA_FORMAT;
4597 : st_ivas->element_mode_init = IVAS_SCE;
4598 : break;
4599 : case SID_MASA_2TC:
4600 : st_ivas->ivas_format = MASA_FORMAT;
4601 : if ( bit_stream[total_brate / FRAMES_PER_SEC - 1] == 1 )
4602 : {
4603 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
4604 : }
4605 : else
4606 : {
4607 : st_ivas->element_mode_init = IVAS_CPE_DFT;
4608 : }
4609 : break;
4610 : default:
4611 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Invalid value %c found in SID format field.", st_ivas->sid_format );
4612 : }
4613 : }
4614 :
4615 : /* only read element mode from active frames */
4616 : if ( is_DTXrate( total_brate ) == 0 )
4617 : {
4618 : /* read element_mode - needed in init_decoder() */
4619 : if ( st_ivas->ivas_format == STEREO_FORMAT || st_ivas->ivas_format == MC_FORMAT || st_ivas->ivas_format == MASA_FORMAT )
4620 : {
4621 : if ( st_ivas->ivas_format == MASA_FORMAT )
4622 : {
4623 : /* read number of MASA transport channels */
4624 : if ( bit_stream[num_bits - 1] == 1 )
4625 : {
4626 : st_ivas->nchan_transport = 2;
4627 : }
4628 : else
4629 : {
4630 : st_ivas->nchan_transport = 1;
4631 : }
4632 : }
4633 :
4634 : if ( st_ivas->ivas_format == MC_FORMAT )
4635 : {
4636 : /* read MC configuration */
4637 : idx = 0;
4638 : for ( k = 0; k < MC_LS_SETUP_BITS; k++ )
4639 : {
4640 : if ( bit_stream[IVAS_FORMAT_SIGNALING_NBITS + k] == 1 )
4641 : {
4642 : idx += ( 1 << ( MC_LS_SETUP_BITS - 1 - k ) );
4643 : }
4644 : }
4645 : st_ivas->transport_config = ivas_mc_map_ls_setup_to_output_config( (MC_LS_SETUP) idx );
4646 : }
4647 :
4648 : if ( !( st_ivas->ivas_format == MASA_FORMAT && st_ivas->nchan_transport == 1 ) && st_ivas->ivas_format != MC_FORMAT )
4649 : {
4650 : /* read stereo technology info */
4651 : k = IVAS_FORMAT_SIGNALING_NBITS;
4652 : if ( st_ivas->ivas_format == MASA_FORMAT )
4653 : {
4654 : k = IVAS_FORMAT_SIGNALING_NBITS_EXTENDED;
4655 : }
4656 :
4657 : if ( total_brate < MIN_BRATE_MDCT_STEREO )
4658 : {
4659 : /* 1 bit */
4660 : if ( bit_stream[k] == 1 )
4661 : {
4662 : st_ivas->element_mode_init = 1 + IVAS_CPE_DFT;
4663 : }
4664 : else
4665 : {
4666 : st_ivas->element_mode_init = 0 + IVAS_CPE_DFT;
4667 : }
4668 : }
4669 : else
4670 : {
4671 : st_ivas->element_mode_init = IVAS_CPE_MDCT;
4672 : }
4673 : }
4674 : }
4675 : else if ( st_ivas->ivas_format == ISM_FORMAT )
4676 : {
4677 : /* read number of objects from the bitstream */
4678 : st_ivas->nchan_transport = 1;
4679 :
4680 : k = (int16_t) ( ( total_brate / FRAMES_PER_SEC ) - 1 );
4681 : while ( bit_stream[k] == 1 && st_ivas->nchan_transport < MAX_NUM_OBJECTS )
4682 : {
4683 : st_ivas->nchan_transport++;
4684 : k--;
4685 : }
4686 : st_ivas->transport_config = IVAS_AUDIO_CONFIG_EXTERNAL + st_ivas->nchan_transport;
4687 :
4688 : st_ivas->ism_mode = ivas_ism_mode_select( st_ivas->nchan_transport, total_brate );
4689 : st_ivas->nSCE = st_ivas->nchan_transport;
4690 : }
4691 : else if ( st_ivas->ivas_format == SBA_FORMAT )
4692 : {
4693 : /* Read SBA planar flag and SBA order */
4694 : st_ivas->sba_planar = ( bit_stream[IVAS_FORMAT_SIGNALING_NBITS_EXTENDED] == 1 );
4695 : st_ivas->sba_order = ( bit_stream[IVAS_FORMAT_SIGNALING_NBITS_EXTENDED + 2] == 1 );
4696 : st_ivas->sba_order += 2 * ( bit_stream[IVAS_FORMAT_SIGNALING_NBITS_EXTENDED + 1] == 1 );
4697 :
4698 : st_ivas->sba_analysis_order = ivas_sba_get_analysis_order( total_brate, st_ivas->sba_order );
4699 :
4700 : ivas_sba_config( 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 ) );
4701 : }
4702 : else if ( st_ivas->ivas_format == SBA_ISM_FORMAT )
4703 : {
4704 : /* read number of objects from the bitstream */
4705 : if ( total_brate != SID_2k40 && total_brate != FRAME_NO_DATA )
4706 : {
4707 : st_ivas->nchan_ism = 2 * bit_stream[total_brate / FRAMES_PER_SEC - 1] + bit_stream[total_brate / FRAMES_PER_SEC - 2] + 1;
4708 : st_ivas->ism_mode = ISM_SBA_MODE_DISC;
4709 : }
4710 :
4711 : /* Read SBA planar flag and SBA order */
4712 : st_ivas->sba_planar = ( bit_stream[IVAS_FORMAT_SIGNALING_NBITS_EXTENDED + IVAS_COMBINED_FORMAT_SIGNALLING_BITS] == 1 );
4713 :
4714 : if ( total_brate >= IVAS_256k )
4715 : {
4716 : st_ivas->sba_order = ( bit_stream[IVAS_FORMAT_SIGNALING_NBITS_EXTENDED + IVAS_COMBINED_FORMAT_SIGNALLING_BITS + 2] == 1 );
4717 : st_ivas->sba_order += 2 * ( bit_stream[IVAS_FORMAT_SIGNALING_NBITS_EXTENDED + IVAS_COMBINED_FORMAT_SIGNALLING_BITS + 1] == 1 );
4718 : }
4719 : else
4720 : {
4721 : st_ivas->sba_order = 3;
4722 : }
4723 :
4724 : st_ivas->sba_analysis_order = ivas_sba_get_analysis_order( total_brate, st_ivas->sba_order );
4725 :
4726 : ivas_sba_config( 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 ) );
4727 : }
4728 : else if ( st_ivas->ivas_format == MASA_ISM_FORMAT )
4729 : {
4730 : /* read number of objects from the bitstream */
4731 : st_ivas->nchan_transport = 2; /* always 2 MASA transport channels */
4732 : st_ivas->nchan_ism = 0;
4733 :
4734 : if ( total_brate != SID_2k40 && total_brate != FRAME_NO_DATA )
4735 : {
4736 : st_ivas->nchan_ism = 2 * bit_stream[total_brate / FRAMES_PER_SEC - 1] + bit_stream[total_brate / FRAMES_PER_SEC - 2] + 1;
4737 : st_ivas->ism_mode = ivas_omasa_ism_mode_select( total_brate, st_ivas->nchan_ism );
4738 : }
4739 : }
4740 : }
4741 :
4742 : st_ivas->hDecoderConfig->ivas_total_brate = total_brate;
4743 :
4744 : return error;
4745 : }
4746 :
4747 : #endif
4748 :
4749 : /*-------------------------------------------------------------------*
4750 : * read_indices()
4751 : *
4752 : * Detect SID, NO_DATA, BFI, etc. and set bitstream pointers
4753 : * Set ivas_total_brate
4754 : * Note: each bit is represented in bitsream buffer as a uint16_t of value 0 or 1
4755 : *-------------------------------------------------------------------*/
4756 :
4757 : /*! r: 1 = reading OK, 0 = problem */
4758 1275018 : ivas_error read_indices(
4759 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder structure */
4760 : uint16_t bit_stream[], /* i : bitstream buffer */
4761 : UWord16 num_bits, /* i : number of bits in bitstream */
4762 : int16_t *prev_ft_speech,
4763 : int16_t *CNG,
4764 : int16_t bfi /* i : bad frame indicator */
4765 : )
4766 : {
4767 : int16_t k;
4768 : Decoder_State **sts;
4769 1275018 : int32_t total_brate = 0;
4770 : int16_t curr_ft_good_sp, curr_ft_bad_sp;
4771 : int16_t g192_sid_first, sid_upd_bad, sid_update;
4772 : int16_t speech_bad, speech_lost;
4773 : int16_t n;
4774 : ivas_error error;
4775 :
4776 1275018 : error = IVAS_ERR_OK;
4777 :
4778 1275018 : st_ivas->BER_detect = 0;
4779 1275018 : sts = reset_elements( st_ivas );
4780 :
4781 : #ifdef DEBUGGING
4782 : file_read_FECpattern( &st_ivas->bfi );
4783 : st_ivas->bfi |= bfi;
4784 :
4785 : if ( bfi == FRAMEMODE_MISSING )
4786 : {
4787 : for ( k = 0; k < num_bits; k++ )
4788 : {
4789 : bit_stream[k] = 0;
4790 : }
4791 : }
4792 : #else
4793 1275018 : st_ivas->bfi = bfi;
4794 : #endif
4795 :
4796 : /* convert the frame length to total bitrate */
4797 1275018 : total_brate = (int32_t) ( num_bits * FRAMES_PER_SEC );
4798 :
4799 : /* verify that a valid num bits value is present */
4800 : /* only AMRWB, EVS or IVAS bitrates or 0(NO DATA) are allowed */
4801 1275018 : if ( st_ivas->ivas_format != MONO_FORMAT )
4802 : {
4803 1265718 : k = 0;
4804 10741422 : while ( k < SIZE_IVAS_BRATE_TBL && total_brate != ivas_brate_tbl[k] )
4805 : {
4806 9475704 : k++;
4807 : }
4808 :
4809 1265718 : if ( st_ivas->ivas_format == ISM_FORMAT && ( k < SIZE_IVAS_BRATE_TBL || total_brate <= SID_2k40 ) )
4810 : {
4811 311289 : st_ivas->element_mode_init = IVAS_SCE;
4812 : }
4813 954429 : else if ( ( st_ivas->ivas_format == SBA_FORMAT || st_ivas->ivas_format == MASA_FORMAT ) && ( total_brate <= SID_2k40 ) )
4814 : {
4815 11817 : st_ivas->element_mode_init = IVAS_SCE;
4816 : }
4817 942612 : else if ( k == SIZE_IVAS_BRATE_TBL )
4818 : {
4819 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error, illegal bitrate (%d) detected! Exiting ! \n", total_brate );
4820 : }
4821 : else
4822 : {
4823 942612 : st_ivas->element_mode_init = -1;
4824 : }
4825 : }
4826 : else /* AMRWB or EVS */
4827 : {
4828 9300 : st_ivas->element_mode_init = EVS_MONO;
4829 :
4830 9300 : if ( rate2EVSmode( total_brate, NULL ) < 0 ) /* negative value means that a valid rate was not found */
4831 : {
4832 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error, illegal bitrate (%d) detected! Exiting ! \n", total_brate );
4833 : }
4834 : }
4835 :
4836 : /* RX DTX handler*/
4837 : /* handle SID_FIRST, SID_BAD, SPEECH_LOST, NO_DATA */
4838 : /* (total_brate, bfi , st_CNG) = rx_handler(received frame type, [previous frame type], past CNG state, past core) */
4839 1275018 : curr_ft_good_sp = 0;
4840 1275018 : curr_ft_bad_sp = 0;
4841 :
4842 1275018 : if ( is_DTXrate( total_brate ) == 0 )
4843 : {
4844 1214403 : if ( st_ivas->bfi == 0 )
4845 : {
4846 1186335 : curr_ft_good_sp = 1;
4847 : }
4848 : else
4849 : {
4850 28068 : curr_ft_bad_sp = 1;
4851 : }
4852 : }
4853 :
4854 1275018 : sid_update = 0;
4855 1275018 : sid_upd_bad = 0;
4856 1275018 : if ( is_SIDrate( total_brate ) == 1 )
4857 : {
4858 8940 : if ( st_ivas->bfi == 0 )
4859 : {
4860 8481 : sid_update = 1;
4861 : }
4862 : else
4863 : {
4864 459 : sid_upd_bad = 1; /* this frame type may happen in ETSI/3GPP CS cases, a corrupt SID frames */
4865 : }
4866 : }
4867 :
4868 : /* all zero indices/bits iSP AMRWB SID_update results in a valid LP filter with extremely high LP-filter-gain */
4869 : /* all zero indices/bits may be a result of CS bit errors and/or erroneously injected by gateways or by a bad dejitter handlers */
4870 1275018 : if ( total_brate == SID_1k75 && sid_update == 1 )
4871 : {
4872 : /* valid sid_update received, check for very risky but formally valid content */
4873 0 : int16_t sum = 0;
4874 0 : for ( k = 0; k < num_bits; ++k )
4875 : {
4876 0 : sum += ( bit_stream[k] == 1 ); /* check of 35 zeroes */
4877 : }
4878 0 : if ( sum == 0 )
4879 : { /* all zeros */
4880 0 : sid_upd_bad = 1; /* initial signal as corrupt (BER likely) */
4881 : }
4882 : }
4883 :
4884 : /* AMRWB 26.173 G.192 file reader (read_serial) does not declare/use SID_BAD ft,
4885 : it declares every bad synch marked frame initially as a lost_speech frame,
4886 : and then the RXDTX handler CNG state decides the decoding mode CNG/SPEECH.
4887 : While In the AMRWB ETSI/3GPP format eid a CRC error in a detected SID_UPDATE frames triggers SID_BAD.
4888 :
4889 : Here we inhibit use of the SID-length info, even though it is available in the G.192 file format after STL/EID-XOR .
4890 : */
4891 1275018 : if ( sid_upd_bad )
4892 : {
4893 459 : sid_upd_bad = 0;
4894 459 : total_brate = FRAME_NO_DATA; /* treat SID_BAD as a stolen signaling frame --> SPEECH LOST */
4895 : }
4896 :
4897 1275018 : g192_sid_first = 0;
4898 1275018 : if ( st_ivas->ivas_format == MONO_FORMAT && sts[0]->core == AMR_WB_CORE && *prev_ft_speech && total_brate == FRAME_NO_DATA && st_ivas->bfi == 0 )
4899 : {
4900 0 : g192_sid_first = 1; /* SID_FIRST detected for previous AMRWB/AMRWBIO active frames only */
4901 : /* It is not possible to perfectly simulate rate switching conditions EVS->AMRWBIO where:
4902 : the very first SID_FIRST detection is based on a past EVS active frame
4903 : and a good length 0 "SID_FIRST"(NO_DATA) frame is sent in AMRWBIO,
4904 : due to the one frame state memory in the AMRWB legacy G.192 SID_FIRST encoding
4905 : */
4906 : }
4907 :
4908 1275018 : speech_bad = 0;
4909 1275018 : if ( st_ivas->bfi != 0 && ( is_DTXrate( total_brate ) == 0 ) )
4910 : {
4911 28068 : speech_bad = 1; /* initial ft assumption, CNG_state decides what to do */
4912 : }
4913 :
4914 1275018 : speech_lost = 0;
4915 1275018 : if ( total_brate == FRAME_NO_DATA && st_ivas->bfi != 0 ) /* unsent NO_DATA or stolen NO_DATA/signaling frame */
4916 : {
4917 8775 : speech_lost = 1; /* initial ft assumption, CNG_state decides what to do */
4918 : }
4919 :
4920 : /* Do not allow decoder to enter CNG-synthesis for any instantly received GOOD+LENGTH==0 frame
4921 : as this frame was never transmitted, one can not know it is good and has a a length of zero ) */
4922 1275018 : if ( *CNG != 0 )
4923 : {
4924 : /* We were in CNG synthesis */
4925 55704 : if ( curr_ft_good_sp != 0 )
4926 : {
4927 : /* only a good speech frame makes you leave CNG synthesis */
4928 2832 : *CNG = 0;
4929 : }
4930 : }
4931 : else
4932 : {
4933 : /* We were in SPEECH synthesis */
4934 : /* only a received/detected SID frame can make the decoder enter into CNG synthsis */
4935 1219314 : if ( g192_sid_first || sid_update || sid_upd_bad )
4936 : {
4937 3060 : *CNG = 1;
4938 : }
4939 : }
4940 :
4941 : /* set bfi, total_brate pair for proper decoding */
4942 : /* handle the G.192 _simulated_ untransmitted NO_DATA frame, setting for decoder SPEECH synthesis */
4943 1275018 : if ( *CNG == 0 && total_brate == FRAME_NO_DATA && st_ivas->bfi == 0 )
4944 : {
4945 498 : st_ivas->bfi = 1; /* SPEECH PLC code will now become active as in a real system */
4946 : /* total_brate= 0 */
4947 : }
4948 :
4949 : /* handle bad/lost speech frame(and CS bad SID frame) in the decoders CNG synthesis settings pair (total_brate, bfi) */
4950 1275018 : if ( (
4951 1275018 : bfi != FRAMEMODE_FUTURE &&
4952 1275018 : ( *CNG != 0 ) && ( ( speech_bad != 0 ) || ( speech_lost != 0 ) ) ) || /* SP_BAD or SPEECH_LOST) --> stay in CNG */
4953 : ( sid_upd_bad != 0 ) ) /* SID_UPD_BAD --> start CNG */
4954 : {
4955 4590 : st_ivas->bfi = 0; /* bfi=0 needed to activate CNG code */
4956 4590 : total_brate = FRAME_NO_DATA;
4957 : }
4958 :
4959 : /* update for next frame's G.192 file format's odd SID_FIRST detection (primarily for AMRWBIO) */
4960 1275018 : *prev_ft_speech = ( ( curr_ft_good_sp != 0 ) || ( curr_ft_bad_sp != 0 ) );
4961 :
4962 : /* st->total brate= total_brate; updated in a good frame below */
4963 :
4964 2533932 : for ( k = 0; k < st_ivas->nCPE; k++ )
4965 : {
4966 1258914 : sts = st_ivas->hCPE[k]->hCoreCoder;
4967 3776742 : for ( n = 0; n < CPE_CHANNELS; n++ )
4968 : {
4969 2517828 : sts[n]->bfi = st_ivas->bfi;
4970 : }
4971 : }
4972 :
4973 2330202 : for ( k = 0; k < st_ivas->nSCE; k++ )
4974 : {
4975 1055184 : sts = st_ivas->hSCE[k]->hCoreCoder;
4976 1055184 : sts[0]->bfi = st_ivas->bfi;
4977 : }
4978 :
4979 1275018 : if ( st_ivas->bfi == 0 )
4980 : {
4981 : /* select Mode 1 or Mode 2 */
4982 1242267 : if ( st_ivas->ivas_format == MONO_FORMAT ) /* EVS mono */
4983 : {
4984 9300 : decoder_selectCodec( sts[0], total_brate, bit_stream[0] );
4985 9300 : st_ivas->hDecoderConfig->Opt_AMR_WB = sts[0]->Opt_AMR_WB;
4986 : }
4987 : else /* IVAS */
4988 : {
4989 1232967 : st_ivas->codec_mode = MODE1;
4990 1232967 : st_ivas->hDecoderConfig->Opt_AMR_WB = 0;
4991 : }
4992 : }
4993 :
4994 : /* GOOD frame */
4995 1275018 : if ( st_ivas->bfi == 0 || st_ivas->bfi == FRAMEMODE_FUTURE )
4996 : {
4997 1242267 : st_ivas->hDecoderConfig->ivas_total_brate = total_brate;
4998 : }
4999 :
5000 1275018 : st_ivas->bit_stream = bit_stream;
5001 :
5002 1275018 : if ( st_ivas->ivas_format == MONO_FORMAT )
5003 : {
5004 9300 : ivas_set_bitstream_pointers( st_ivas );
5005 : }
5006 :
5007 1275018 : return error;
5008 : }
5009 :
5010 :
5011 : /*-------------------------------------------------------------------*
5012 : * get_rfFrameType()
5013 : *
5014 : * Extract the RF frame type
5015 : *-------------------------------------------------------------------*/
5016 :
5017 9300 : static void get_rfFrameType(
5018 : Decoder_State *st, /* i : decoder state structure */
5019 : int16_t *rf_frame_type /* o : RF frame type */
5020 : )
5021 : {
5022 : int16_t num_bits;
5023 9300 : num_bits = (int16_t) ( st->total_brate / FRAMES_PER_SEC );
5024 9300 : if ( st->rf_flag == 1 )
5025 : {
5026 : /* the last three bits in a packet is the RF frame type */
5027 0 : *rf_frame_type = get_indice( st, num_bits - 3, 3 );
5028 : }
5029 : else
5030 : {
5031 9300 : *rf_frame_type = 0;
5032 : }
5033 :
5034 9300 : return;
5035 : }
5036 :
5037 : /*-------------------------------------------------------------------*
5038 : * get_rfFlag()
5039 : *
5040 : * Check if RF flag is present in the bitstream
5041 : *-------------------------------------------------------------------*/
5042 :
5043 9300 : static void get_rfFlag(
5044 : Decoder_State *st, /* i : decoder state structure */
5045 : int16_t *rf_flag, /* o : check for the RF flag */
5046 : int16_t *nBits,
5047 : int32_t *ind )
5048 : {
5049 : int16_t start_idx, nBits_tmp;
5050 : int32_t ind_tmp;
5051 :
5052 : /* Init */
5053 9300 : *rf_flag = 0;
5054 :
5055 : /* check for rf_flag in the packet and extract the rf_frame_type and rf_fec_offset */
5056 9300 : if ( st->total_brate == ACELP_13k20 && ( st->bfi == FRAMEMODE_NORMAL || st->bfi == FRAMEMODE_FUTURE ) )
5057 : {
5058 : /* find the section in the ACELP signaling table corresponding to bitrate */
5059 3150 : start_idx = 0;
5060 110250 : while ( acelp_sig_tbl[start_idx] != st->total_brate )
5061 : {
5062 107100 : start_idx++;
5063 107100 : assert( ( start_idx < MAX_ACELP_SIG ) && "ERROR: start_idx larger than acelp_sig_tbl[].\n" );
5064 : }
5065 :
5066 : /* skip the bitrate */
5067 3150 : start_idx += 1;
5068 :
5069 : /* retrieve the number of bits */
5070 3150 : nBits_tmp = (int16_t) acelp_sig_tbl[start_idx++];
5071 :
5072 : /* retrieve the signaling indice */
5073 3150 : ind_tmp = acelp_sig_tbl[start_idx + get_indice( st, 0, nBits_tmp )];
5074 :
5075 : /* convert signaling indice into RF flag. */
5076 3150 : *rf_flag = ( ind_tmp >> 7 ) & 0x1;
5077 :
5078 3150 : if ( ind )
5079 : {
5080 3150 : *ind = ind_tmp;
5081 : }
5082 :
5083 3150 : if ( nBits )
5084 : {
5085 3150 : *nBits = nBits_tmp;
5086 : }
5087 : }
5088 :
5089 9300 : return;
5090 : }
5091 :
5092 : /*-------------------------------------------------------------------*
5093 : * get_rf_fec_offset()
5094 : *
5095 : * Extract the FEC offset
5096 : *-------------------------------------------------------------------*/
5097 :
5098 9300 : static void get_rf_fec_offset(
5099 : Decoder_State *st, /* i : decoder state structure */
5100 : int16_t *rf_fec_offset /* o : RF FEC offset */
5101 : )
5102 : {
5103 : int16_t num_bits, tmp;
5104 9300 : num_bits = (int16_t) ( st->total_brate / FRAMES_PER_SEC );
5105 9300 : if ( st->rf_flag == 1 )
5106 : {
5107 : /* the two bits before the RF frame type contains the FEC offset */
5108 0 : tmp = get_indice( st, num_bits - 5, 2 );
5109 :
5110 0 : if ( tmp == 0 )
5111 : {
5112 0 : *rf_fec_offset = 2;
5113 : }
5114 : else
5115 : {
5116 0 : *rf_fec_offset = 2 * tmp + 1;
5117 : }
5118 : }
5119 : else
5120 : {
5121 9300 : *rf_fec_offset = 0;
5122 : }
5123 :
5124 9300 : return;
5125 : }
5126 :
5127 : /*-------------------------------------------------------------------*
5128 : * get_rfTargetBits()
5129 : *
5130 : * Return the number of RF target bits
5131 : *-------------------------------------------------------------------*/
5132 :
5133 0 : static void get_rfTargetBits(
5134 : int16_t rf_frame_type, /* i : RF frame type */
5135 : int16_t *rf_target_bits /* o : Number of RF target bits */
5136 : )
5137 : {
5138 : /* Number of RF bits for different RF coder types */
5139 :
5140 0 : switch ( rf_frame_type )
5141 : {
5142 0 : case RF_NO_DATA:
5143 0 : *rf_target_bits = 5;
5144 0 : break;
5145 0 : case RF_TCXFD:
5146 0 : *rf_target_bits = 27;
5147 0 : break;
5148 0 : case RF_TCXTD1:
5149 0 : *rf_target_bits = 16;
5150 0 : break;
5151 0 : case RF_TCXTD2:
5152 0 : *rf_target_bits = 16;
5153 0 : break;
5154 0 : case RF_ALLPRED:
5155 : /* Es_pred bits 3 bits, LTF: 1, pitch: 8,5,5,5, FCB: 0, gain: 7,0,7,0, Diff GFr: 4*/
5156 0 : *rf_target_bits = 63;
5157 0 : break;
5158 0 : case RF_NOPRED:
5159 : /* Es_pred bits 3 bits, LTF: 0, pitch: 0, FCB: 7,7,7,7, gain: 6,0,6,0, Diff GFr: 2*/
5160 0 : *rf_target_bits = 66;
5161 0 : break;
5162 0 : case RF_GENPRED:
5163 : /* Es_pred bits 3 bits, LTF: 1, pitch: 8,0,8,0, FCB: 6,7,5,5, gain: 5,0,5,0, Diff GFr: 0*/
5164 0 : *rf_target_bits = 70;
5165 0 : break;
5166 0 : case RF_NELP:
5167 : /* gain: 19, Diff GFr: 5 */
5168 0 : *rf_target_bits = 45;
5169 0 : break;
5170 : }
5171 :
5172 0 : return;
5173 : }
5174 :
5175 : /*-------------------------------------------------------------------*
5176 : * berCheck()
5177 : *
5178 : * Check for bit errors in channel aware signaling.
5179 : *-------------------------------------------------------------------*/
5180 :
5181 0 : static void berCheck(
5182 : Decoder_State *st /* i/o: decoder state structure */
5183 : )
5184 : {
5185 : /* In case of RF flag = 1, and valid RF packet with primary and partial copy */
5186 0 : if ( st->bwidth == NB || st->bwidth == FB || st->coder_type >= TRANSITION )
5187 : {
5188 0 : if ( st->use_partial_copy == 1 )
5189 : {
5190 0 : st->use_partial_copy = 0;
5191 : }
5192 :
5193 0 : st->bfi = 1;
5194 0 : st->bwidth = st->last_bwidth;
5195 0 : st->BER_detect = 1;
5196 0 : st->coder_type = GENERIC;
5197 : }
5198 :
5199 0 : return;
5200 : }
5201 :
5202 : /*-------------------------------------------------------------------*
5203 : * getPartialCopyInfo()
5204 : *
5205 : * Check if the frame includes a partial copy for channel aware processing.
5206 : *-------------------------------------------------------------------*/
5207 :
5208 9300 : void getPartialCopyInfo(
5209 : Decoder_State *st, /* i/o: decoder state structure */
5210 : int16_t *sharpFlag )
5211 : {
5212 9300 : int16_t nBits = 0;
5213 9300 : int32_t ind = 0;
5214 :
5215 : /* check the RF flag in the packet */
5216 9300 : get_rfFlag( st, &( st->rf_flag ), &nBits, &ind );
5217 :
5218 : /* get RF frame type info */
5219 9300 : get_rfFrameType( st, &( st->rf_frame_type ) );
5220 :
5221 : /* Get the FEC offset info */
5222 9300 : get_rf_fec_offset( st, &( st->rf_fec_offset ) );
5223 :
5224 : /* reset number of target bits in case of rate switching */
5225 9300 : st->rf_target_bits = 0;
5226 :
5227 : /* Get the number of bits used for RF*/
5228 9300 : if ( st->rf_flag == 1 )
5229 : {
5230 0 : st->coder_type = ind & 0x7;
5231 0 : st->bwidth = ( ind >> 3 ) & 0x7;
5232 0 : *sharpFlag = ( ind >> 6 ) & 0x1;
5233 0 : st->codec_mode = MODE2;
5234 0 : get_rfTargetBits( st->rf_frame_type, &( st->rf_target_bits ) );
5235 :
5236 0 : if ( st->bfi == FRAMEMODE_FUTURE )
5237 : {
5238 0 : st->use_partial_copy = 1;
5239 : /* now set the frame mode to normal mode */
5240 0 : if ( st->rf_frame_type >= RF_TCXFD && st->rf_frame_type <= RF_TCXTD2 )
5241 : {
5242 0 : st->bfi = 1;
5243 0 : st->core = TCX_20_CORE;
5244 : }
5245 : else
5246 : {
5247 0 : st->bfi = FRAMEMODE_NORMAL;
5248 0 : st->core = ACELP_CORE;
5249 : }
5250 : }
5251 :
5252 : /* check for bit errors */
5253 0 : berCheck( st );
5254 :
5255 0 : get_next_indice_tmp( st, nBits );
5256 : }
5257 :
5258 9300 : return;
5259 : }
5260 :
5261 : /*-------------------------------------------------------------------*
5262 : * get_NextCoderType()
5263 : *
5264 : * Extract the coder type of next frame
5265 : *-------------------------------------------------------------------*/
5266 :
5267 0 : void get_NextCoderType(
5268 : uint8_t *bitstream, /* i : bitstream */
5269 : int16_t *next_coder_type /* o : next coder type */
5270 : )
5271 : {
5272 : int16_t k;
5273 : int16_t start_idx;
5274 : int8_t bit_stream[ACELP_13k20 / FRAMES_PER_SEC];
5275 : int32_t tmp;
5276 : int16_t nBits_tmp;
5277 :
5278 :
5279 0 : for ( k = 0; k < ACELP_13k20 / FRAMES_PER_SEC; k++ )
5280 : {
5281 0 : bit_stream[k] = ( bitstream[k / 8] >> ( 7 - ( k % 8 ) ) ) & 0x1;
5282 : }
5283 0 : start_idx = 0;
5284 0 : while ( acelp_sig_tbl[start_idx] != ACELP_13k20 )
5285 : {
5286 0 : start_idx++;
5287 0 : assert( ( start_idx < MAX_ACELP_SIG ) && "ERROR: start_idx larger than acelp_sig_tbl[].\n" );
5288 : }
5289 :
5290 : /* skip the bitrate */
5291 0 : start_idx += 1;
5292 :
5293 0 : tmp = 0;
5294 0 : nBits_tmp = (int16_t) acelp_sig_tbl[start_idx++];
5295 0 : for ( k = 0; k < nBits_tmp; k++ )
5296 : {
5297 0 : tmp <<= 1;
5298 0 : tmp += bit_stream[k];
5299 : }
5300 :
5301 : /* retrieve the signaling indice */
5302 0 : *next_coder_type = acelp_sig_tbl[start_idx + tmp] & 0x7;
5303 :
5304 0 : return;
5305 : }
5306 :
5307 :
5308 : /*-------------------------------------------------------------------*
5309 : * get_indice_preview()
5310 : *
5311 : * Indices preview to parse for the presence of partial copy
5312 : *-------------------------------------------------------------------*/
5313 :
5314 0 : static uint16_t get_indice_preview(
5315 : uint8_t *bitstream,
5316 : const int16_t bitstreamSize,
5317 : const int16_t pos,
5318 : const int16_t nb_bits )
5319 : {
5320 : uint16_t value;
5321 : int16_t i;
5322 : uint16_t bitstreamShort[MAX_BITS_PER_FRAME + 16];
5323 : uint16_t *bitstreamShortPtr;
5324 :
5325 : /* convert bitstream from compact bytes to short values */
5326 0 : bitstreamShortPtr = bitstreamShort;
5327 0 : for ( i = 0; i < bitstreamSize; i++ )
5328 : {
5329 0 : *bitstreamShortPtr++ = ( bitstream[i / 8] >> ( 7 - ( i % 8 ) ) ) & 0x1;
5330 : }
5331 :
5332 0 : assert( nb_bits <= 16 );
5333 0 : value = 0;
5334 0 : for ( i = 0; i < nb_bits; i++ )
5335 : {
5336 0 : value <<= 1;
5337 0 : value += bitstreamShort[pos + i];
5338 : }
5339 0 : return value;
5340 : }
5341 :
5342 :
5343 : /*-------------------------------------------------------------------*
5344 : * evs_dec_previewFrame()
5345 : *
5346 : * Signalling index preview for JBM
5347 : *-------------------------------------------------------------------*/
5348 :
5349 0 : void evs_dec_previewFrame(
5350 : uint8_t *bitstream,
5351 : int16_t bitstreamSize,
5352 : int16_t *partialCopyFrameType,
5353 : int16_t *partialCopyOffset )
5354 : {
5355 : int32_t total_brate;
5356 : int16_t start_idx, nBits;
5357 : int32_t ind;
5358 : int16_t rf_flag;
5359 :
5360 0 : rf_flag = 0;
5361 0 : *partialCopyFrameType = 0;
5362 0 : *partialCopyOffset = 0;
5363 0 : total_brate = bitstreamSize * FRAMES_PER_SEC;
5364 :
5365 0 : if ( total_brate == ACELP_13k20 )
5366 : {
5367 : /* find the section in the ACELP signaling table corresponding to bitrate */
5368 0 : start_idx = 0;
5369 0 : while ( acelp_sig_tbl[start_idx] != total_brate )
5370 : {
5371 0 : start_idx++;
5372 0 : assert( ( start_idx < MAX_ACELP_SIG ) && "ERROR: start_idx larger than acelp_sig_tbl[].\n" );
5373 : }
5374 :
5375 : /* skip the bitrate */
5376 0 : start_idx += 1;
5377 : /* retrieve the number of bits */
5378 0 : nBits = (int16_t) acelp_sig_tbl[start_idx++];
5379 :
5380 : /* retrieve the signaling indice */
5381 0 : ind = acelp_sig_tbl[start_idx + get_indice_preview( bitstream, bitstreamSize, 0, nBits )];
5382 :
5383 : /* convert signaling indice into RF flag. */
5384 0 : rf_flag = ( ind >> 7 ) & 0x1;
5385 0 : if ( rf_flag != 0 )
5386 : {
5387 : /* read the FEC offset at which the partial copy is received */
5388 0 : ind = get_indice_preview( bitstream, bitstreamSize, ( bitstreamSize - 5 ), 2 );
5389 0 : if ( ind == 0 )
5390 : {
5391 0 : *partialCopyOffset = 2;
5392 : }
5393 0 : else if ( ind == 1 )
5394 : {
5395 0 : *partialCopyOffset = 3;
5396 : }
5397 0 : else if ( ind == 2 )
5398 : {
5399 0 : *partialCopyOffset = 5;
5400 : }
5401 0 : else if ( ind == 3 )
5402 : {
5403 0 : *partialCopyOffset = 7;
5404 : }
5405 : /* the last three bits in a packet is the RF frame type */
5406 0 : *partialCopyFrameType = get_indice_preview( bitstream, bitstreamSize, bitstreamSize - 3, 3 );
5407 : }
5408 : }
5409 :
5410 0 : return;
5411 : }
5412 :
5413 :
5414 1203 : void dtx_read_padding_bits(
5415 : DEC_CORE_HANDLE st,
5416 : const int16_t num_bits )
5417 : {
5418 : /* TODO: temporary hack, need to decide what to do with core-coder bitrate */
5419 : int32_t tmp;
5420 :
5421 1203 : tmp = st->total_brate;
5422 1203 : st->total_brate = st->total_brate + num_bits * FRAMES_PER_SEC;
5423 1203 : get_next_indice( st, num_bits );
5424 1203 : st->total_brate = tmp;
5425 :
5426 1203 : return;
5427 : }
|
