LCOV - code coverage report
Current view: top level - lib_dec - lead_deindexing_fx.c (source / functions) Hit Total Coverage
Test: Coverage on main enc/dec/rend @ 3b2f07138c61dcf997bbf4165d0882f794b2995f Lines: 137 139 98.6 %
Date: 2025-05-03 01:55:50 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /*====================================================================================
       2             :     EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
       3             :   ====================================================================================*/
       4             : 
       5             : #include <stdint.h>
       6             : #include "options.h" /* Compilation switches                   */
       7             : #include "cnst.h"
       8             : #include "rom_com.h"
       9             : #include "rom_dec.h"
      10             : #include "prot_fx.h"
      11             : /*-------------------------------------------------------------------*
      12             :  * Local function prototype
      13             :  *-------------------------------------------------------------------*/
      14             : static void fcb_decode_pos_fx( const Word16 index, Word16 pos_vector[], const Word16 pulse_num, const Word16 pos_num );
      15             : 
      16             : /*-------------------------------------------------------------------*
      17             :  * re8_decode_base_index_fx
      18             :  *
      19             :  * Decode RE8 base index
      20             :  *-------------------------------------------------------------------*/
      21     1637882 : void re8_decode_base_index_fx(
      22             :     const Word16 n, /* i  : codebook number (*n is an integer defined in {0,2,3,4,..,n_max}) */
      23             :     UWord16 I,      /* i  : index of c (pointer to unsigned 16-bit word)                     */
      24             :     Word16 *x       /* o  : point in RE8 (8-dimensional integer vector)                      */
      25             : )
      26             : {
      27             :     Word16 i, j, k1, l, m, m1, m2;
      28             :     Word16 setor_8p_temp[8], setor_8p_temp_1[8], setor_8p_temp_2[8];
      29             :     Word16 sign_8p;
      30             :     Word16 code_level;
      31             :     const Word16 *a1, *a2;
      32             : 
      33             :     Word16 ka;
      34             :     UWord16 offset;
      35             :     Word16 code_index;
      36             : 
      37             :     Word16 element_a10, element_a11, element_a12;
      38     1637882 :     move16();
      39     1637882 :     move16();
      40     1637882 :     element_a11 = 0;
      41     1637882 :     element_a12 = 0;
      42     1637882 :     set16_fx( setor_8p_temp_2, 0, 8 );
      43             : 
      44     1637882 :     IF( LT_16( n, 2 ) )
      45             :     {
      46     1972062 :         FOR( i = 0; i < 8; i++ )
      47             :         {
      48     1752944 :             x[i] = 0;
      49     1752944 :             move16();
      50             :         }
      51             :     }
      52             :     ELSE
      53             :     {
      54     1418764 :         if ( GT_32( I, 65519 ) )
      55             :         {
      56           0 :             I = 0;
      57           0 :             move16();
      58             :         }
      59             : 
      60             :         /*-------------------------------------------------------------------*
      61             :          * search for the identifier ka of the absolute leader (table-lookup)
      62             :          * Q2 is a subset of Q3 - the two cases are considered in the same branch
      63             :          *-------------------------------------------------------------------*/
      64     1418764 :         IF( LE_16( n, 3 ) )
      65             :         {
      66     2993840 :             FOR( i = 1; i < NB_LDQ3; i++ )
      67             :             {
      68     2993838 :                 IF( LT_32( I, II3[i] ) )
      69             :                 {
      70     1100688 :                     BREAK;
      71             :                 }
      72             :             }
      73     1100690 :             ka = AA3[i - 1];
      74     1100690 :             move16();
      75             :         }
      76             :         ELSE
      77             :         {
      78     1241707 :             FOR( i = 1; i < NB_LDQ4; i++ )
      79             :             {
      80     1241707 :                 IF( LT_32( I, II4[i] ) )
      81             :                 {
      82      318074 :                     BREAK;
      83             :                 }
      84             :             }
      85      318074 :             ka = AA4[i - 1];
      86      318074 :             move16();
      87             :         }
      88             : 
      89             :         /*-------------------------------------------------------*
      90             :          * decode
      91             :          *-------------------------------------------------------*/
      92     1418764 :         a1 = vals_a[ka];
      93     1418764 :         move16();
      94     1418764 :         a2 = vals_q[ka];
      95     1418764 :         move16();
      96     1418764 :         k1 = a2[0];
      97     1418764 :         move16();
      98     1418764 :         code_level = a2[1];
      99     1418764 :         move16();
     100             : 
     101     1418764 :         offset = Is[ka];
     102     1418764 :         move16();
     103     1418764 :         code_index = extract_l( L_sub( I, offset ) );
     104             : 
     105     1418764 :         sign_8p = s_and( code_index, sub( shl( 1, k1 ), 1 ) );
     106             : 
     107     1418764 :         code_index = shr( code_index, k1 );
     108             : 
     109     1418764 :         m = 0;
     110     1418764 :         move16();
     111     1418764 :         m1 = 0;
     112     1418764 :         move16();
     113     1418764 :         m2 = 0;
     114     1418764 :         move16();
     115             : 
     116     1418764 :         element_a10 = a1[0];
     117     1418764 :         move16();
     118             : 
     119     1418764 :         SWITCH( code_level )
     120             :         {
     121         826 :             case 4:
     122             : 
     123         826 :                 m2 = 1;
     124         826 :                 move16();
     125         826 :                 i = s_and( code_index, 1 );
     126         826 :                 setor_8p_temp_2[0] = 0;
     127         826 :                 move16();
     128             : 
     129         826 :                 if ( i )
     130             :                 {
     131         194 :                     setor_8p_temp_2[0] = 1;
     132         194 :                     move16();
     133             :                 }
     134         826 :                 code_index = shr( code_index, 1 );
     135             :                 /* FALLTHRU */
     136             : 
     137      133698 :             case 3:
     138             : 
     139      133698 :                 m = a2[2];
     140      133698 :                 move16();
     141      133698 :                 m1 = a2[3];
     142      133698 :                 move16();
     143             : 
     144      133698 :                 l = select_table22[m1][m];
     145      133698 :                 move16();
     146      133698 :                 j = extract_l( L_shr( L_mult0( code_index, mult_avq_tab[l] ), shift_avq_tab[l] ) );
     147      133698 :                 code_index = sub( code_index, extract_l( L_mult0( j, l ) ) );
     148      133698 :                 fcb_decode_pos_fx( code_index, setor_8p_temp_1, m, m1 );
     149             : 
     150      133698 :                 code_index = j;
     151      133698 :                 move16();
     152      133698 :                 element_a12 = a1[2];
     153      133698 :                 move16();
     154             :                 /* FALLTHRU */
     155             : 
     156     1048421 :             case 2:
     157             : 
     158     1048421 :                 m = a2[2];
     159     1048421 :                 move16();
     160     1048421 :                 fcb_decode_pos_fx( code_index, setor_8p_temp, 8, m );
     161     1048421 :                 element_a11 = a1[1];
     162     1048421 :                 move16();
     163             :         }
     164             : 
     165    12768876 :         FOR( i = 0; i < 8; i++ )
     166             :         {
     167    11350112 :             x[i] = element_a10;
     168    11350112 :             move16();
     169             :         }
     170             : 
     171     3964186 :         FOR( i = 0; i < m; i++ )
     172             :         {
     173     2545422 :             x[setor_8p_temp[i]] = element_a11;
     174     2545422 :             move16();
     175             :         }
     176             : 
     177     1563890 :         FOR( i = 0; i < m1; i++ )
     178             :         {
     179      145126 :             x[setor_8p_temp[setor_8p_temp_1[i]]] = element_a12;
     180      145126 :             move16();
     181             :         }
     182             : 
     183     1419590 :         FOR( i = 0; i < m2; i++ )
     184             :         {
     185         826 :             x[setor_8p_temp[setor_8p_temp_1[setor_8p_temp_2[0]]]] = 6;
     186         826 :             move16();
     187             :         }
     188             : 
     189             :         /*--------------------------------------------------------------------*
     190             :          * add the sign of all element ( except the last one in some case )
     191             :          *--------------------------------------------------------------------*/
     192     1418764 :         m1 = sub( k1, 1 );
     193     1418764 :         m2 = 8;
     194     1418764 :         move16();
     195     1418764 :         l = 1;
     196     1418764 :         move16();
     197    12768876 :         FOR( i = 0; i < 8; i++ )
     198             :         {
     199    11350112 :             if ( x[i] == 0 )
     200             :             {
     201     3157792 :                 l = 0;
     202     3157792 :                 move16();
     203             :             }
     204             :         }
     205     1418764 :         test();
     206             :         /* if the signs are constrained and all components are non-zero  */
     207     1418764 :         IF( EQ_16( k1, 7 ) && ( l > 0 ) )
     208             :         {
     209      736362 :             m2 = 7;
     210      736362 :             move16();
     211             :         }
     212    12032514 :         FOR( i = 0; i < m2; i++ )
     213             :         {
     214    10613750 :             IF( x[i] != 0 )
     215             :             {
     216     7455958 :                 IF( s_and( shr( sign_8p, m1 ), 1 ) != 0 )
     217             :                 {
     218     3846951 :                     x[i] = sub( 0, x[i] );
     219     3846951 :                     move16();
     220             :                 }
     221     7455958 :                 m1 = sub( m1, 1 );
     222             :             }
     223             :         }
     224             : 
     225             :         /*--------------------------------------------------------------------*
     226             :          * recover the sign of last element if needed
     227             :          *--------------------------------------------------------------------*/
     228     1418764 :         IF( EQ_16( k1, 7 ) )
     229             :         {
     230      749198 :             m1 = 0;
     231      749198 :             move16();
     232             : 
     233     6742782 :             FOR( i = 0; i < 8; i++ )
     234             :             {
     235     5993584 :                 m1 = add( m1, x[i] );
     236             :             }
     237             : 
     238      749198 :             IF( s_and( m1, 3 ) )
     239             :             {
     240      338088 :                 x[7] = sub( 0, x[7] );
     241      338088 :                 move16();
     242             :             }
     243             :         }
     244             :     }
     245     1637882 : }
     246             : 
     247             : /*-------------------------------------------------------------------*
     248             :  * fcb_decode_pos_fx
     249             :  *
     250             :  * base function for decoding position index
     251             :  *-------------------------------------------------------------------*/
     252     1182119 : static void fcb_decode_pos_fx(
     253             :     const Word16 index,     /* i  : Index to decoder    */
     254             :     Word16 pos_vector[],    /* o  : Position vector     */
     255             :     const Word16 pulse_num, /* i  : Number of pulses    */
     256             :     const Word16 pos_num    /* i  : Number of positions */
     257             : )
     258             : {
     259             :     Word16 i, k, l;
     260             :     Word16 temp1, temp2, tmp_loop;
     261             :     const Word16 *select_table23, *select_table24;
     262             : 
     263     1182119 :     k = index;
     264     1182119 :     move16();
     265     1182119 :     l = 0;
     266     1182119 :     move16();
     267     1182119 :     temp1 = pos_num;
     268     1182119 :     move16();
     269     1182119 :     temp2 = add( pulse_num, 1 );
     270             : 
     271     1182119 :     tmp_loop = sub( pos_num, 1 );
     272     2690548 :     FOR( i = 0; i < tmp_loop; i++ )
     273             :     {
     274     1508429 :         select_table23 = select_table22[temp1];
     275     1508429 :         select_table24 = &select_table23[pulse_num - l];
     276             : 
     277     1508429 :         k = sub( *select_table24, k );
     278     4694134 :         WHILE( LE_16( k, *select_table24 ) )
     279             :         {
     280     3185705 :             l = add( l, 1 );
     281     3185705 :             select_table24--;
     282             :         }
     283             : 
     284     1508429 :         k = sub( select_table23[temp2 - l], k );
     285     1508429 :         pos_vector[i] = sub( l, 1 );
     286     1508429 :         move16();
     287     1508429 :         temp1 = sub( temp1, 1 );
     288             :     }
     289     1182119 :     pos_vector[i] = add( l, k );
     290     1182119 :     move16();
     291     1182119 : }

Generated by: LCOV version 1.14