LCOV - code coverage report
Current view: top level - lib_com - bitstream.c (source / functions) Hit Total Coverage
Test: Coverage on main -- short test vectors @ 8834b716eb6d7dfb881d5c69dd21cb18e1692722 Lines: 662 958 69.1 %
Date: 2025-07-09 08:36:12 Functions: 35 43 81.4 %

          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             : }

Generated by: LCOV version 1.14