LCOV - code coverage report
Current view: top level - lib_dec - lead_deindexing_fx.c (source / functions) Hit Total Coverage
Test: Coverage on main -- dec/rend @ 633e3f2e309758d10805ef21e0436356fe719b7a Lines: 137 139 98.6 %
Date: 2025-08-23 01:22:27 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     1743322 : 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     1743322 :     move16();
      39     1743322 :     move16();
      40     1743322 :     element_a11 = 0;
      41     1743322 :     element_a12 = 0;
      42     1743322 :     set16_fx( setor_8p_temp_2, 0, 8 );
      43             : 
      44     1743322 :     IF( LT_16( n, 2 ) )
      45             :     {
      46     2094957 :         FOR( i = 0; i < 8; i++ )
      47             :         {
      48     1862184 :             x[i] = 0;
      49     1862184 :             move16();
      50             :         }
      51             :     }
      52             :     ELSE
      53             :     {
      54     1510549 :         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     1510549 :         IF( LE_16( n, 3 ) )
      65             :         {
      66     3190015 :             FOR( i = 1; i < NB_LDQ3; i++ )
      67             :             {
      68     3190013 :                 IF( LT_32( I, II3[i] ) )
      69             :                 {
      70     1171888 :                     BREAK;
      71             :                 }
      72             :             }
      73     1171890 :             ka = AA3[i - 1];
      74     1171890 :             move16();
      75             :         }
      76             :         ELSE
      77             :         {
      78     1318222 :             FOR( i = 1; i < NB_LDQ4; i++ )
      79             :             {
      80     1318222 :                 IF( LT_32( I, II4[i] ) )
      81             :                 {
      82      338659 :                     BREAK;
      83             :                 }
      84             :             }
      85      338659 :             ka = AA4[i - 1];
      86      338659 :             move16();
      87             :         }
      88             : 
      89             :         /*-------------------------------------------------------*
      90             :          * decode
      91             :          *-------------------------------------------------------*/
      92     1510549 :         a1 = vals_a[ka];
      93     1510549 :         move16();
      94     1510549 :         a2 = vals_q[ka];
      95     1510549 :         move16();
      96     1510549 :         k1 = a2[0];
      97     1510549 :         move16();
      98     1510549 :         code_level = a2[1];
      99     1510549 :         move16();
     100             : 
     101     1510549 :         offset = Is[ka];
     102     1510549 :         move16();
     103     1510549 :         code_index = extract_l( L_sub( I, offset ) );
     104             : 
     105     1510549 :         sign_8p = s_and( code_index, sub( shl( 1, k1 ), 1 ) );
     106             : 
     107     1510549 :         code_index = shr( code_index, k1 );
     108             : 
     109     1510549 :         m = 0;
     110     1510549 :         move16();
     111     1510549 :         m1 = 0;
     112     1510549 :         move16();
     113     1510549 :         m2 = 0;
     114     1510549 :         move16();
     115             : 
     116     1510549 :         element_a10 = a1[0];
     117     1510549 :         move16();
     118             : 
     119     1510549 :         SWITCH( code_level )
     120             :         {
     121         835 :             case 4:
     122             : 
     123         835 :                 m2 = 1;
     124         835 :                 move16();
     125         835 :                 i = s_and( code_index, 1 );
     126         835 :                 setor_8p_temp_2[0] = 0;
     127         835 :                 move16();
     128             : 
     129         835 :                 if ( i )
     130             :                 {
     131         194 :                     setor_8p_temp_2[0] = 1;
     132         194 :                     move16();
     133             :                 }
     134         835 :                 code_index = shr( code_index, 1 );
     135             :                 /* FALLTHRU */
     136             : 
     137      141991 :             case 3:
     138             : 
     139      141991 :                 m = a2[2];
     140      141991 :                 move16();
     141      141991 :                 m1 = a2[3];
     142      141991 :                 move16();
     143             : 
     144      141991 :                 l = select_table22[m1][m];
     145      141991 :                 move16();
     146      141991 :                 j = extract_l( L_shr( L_mult0( code_index, mult_avq_tab[l] ), shift_avq_tab[l] ) );
     147      141991 :                 code_index = sub( code_index, extract_l( L_mult0( j, l ) ) );
     148      141991 :                 fcb_decode_pos_fx( code_index, setor_8p_temp_1, m, m1 );
     149             : 
     150      141991 :                 code_index = j;
     151      141991 :                 move16();
     152      141991 :                 element_a12 = a1[2];
     153      141991 :                 move16();
     154             :                 /* FALLTHRU */
     155             : 
     156     1116765 :             case 2:
     157             : 
     158     1116765 :                 m = a2[2];
     159     1116765 :                 move16();
     160     1116765 :                 fcb_decode_pos_fx( code_index, setor_8p_temp, 8, m );
     161     1116765 :                 element_a11 = a1[1];
     162     1116765 :                 move16();
     163             :         }
     164             : 
     165    13594941 :         FOR( i = 0; i < 8; i++ )
     166             :         {
     167    12084392 :             x[i] = element_a10;
     168    12084392 :             move16();
     169             :         }
     170             : 
     171     4222327 :         FOR( i = 0; i < m; i++ )
     172             :         {
     173     2711778 :             x[setor_8p_temp[i]] = element_a11;
     174     2711778 :             move16();
     175             :         }
     176             : 
     177     1664552 :         FOR( i = 0; i < m1; i++ )
     178             :         {
     179      154003 :             x[setor_8p_temp[setor_8p_temp_1[i]]] = element_a12;
     180      154003 :             move16();
     181             :         }
     182             : 
     183     1511384 :         FOR( i = 0; i < m2; i++ )
     184             :         {
     185         835 :             x[setor_8p_temp[setor_8p_temp_1[setor_8p_temp_2[0]]]] = 6;
     186         835 :             move16();
     187             :         }
     188             : 
     189             :         /*--------------------------------------------------------------------*
     190             :          * add the sign of all element ( except the last one in some case )
     191             :          *--------------------------------------------------------------------*/
     192     1510549 :         m1 = sub( k1, 1 );
     193     1510549 :         m2 = 8;
     194     1510549 :         move16();
     195     1510549 :         l = 1;
     196     1510549 :         move16();
     197    13594941 :         FOR( i = 0; i < 8; i++ )
     198             :         {
     199    12084392 :             if ( x[i] == 0 )
     200             :             {
     201     3360333 :                 l = 0;
     202     3360333 :                 move16();
     203             :             }
     204             :         }
     205     1510549 :         test();
     206             :         /* if the signs are constrained and all components are non-zero  */
     207     1510549 :         IF( EQ_16( k1, 7 ) && ( l > 0 ) )
     208             :         {
     209      784056 :             m2 = 7;
     210      784056 :             move16();
     211             :         }
     212    12810885 :         FOR( i = 0; i < m2; i++ )
     213             :         {
     214    11300336 :             IF( x[i] != 0 )
     215             :             {
     216     7940003 :                 IF( s_and( shr( sign_8p, m1 ), 1 ) != 0 )
     217             :                 {
     218     4096718 :                     x[i] = sub( 0, x[i] );
     219     4096718 :                     move16();
     220             :                 }
     221     7940003 :                 m1 = sub( m1, 1 );
     222             :             }
     223             :         }
     224             : 
     225             :         /*--------------------------------------------------------------------*
     226             :          * recover the sign of last element if needed
     227             :          *--------------------------------------------------------------------*/
     228     1510549 :         IF( EQ_16( k1, 7 ) )
     229             :         {
     230      797772 :             m1 = 0;
     231      797772 :             move16();
     232             : 
     233     7179948 :             FOR( i = 0; i < 8; i++ )
     234             :             {
     235     6382176 :                 m1 = add( m1, x[i] );
     236             :             }
     237             : 
     238      797772 :             IF( s_and( m1, 3 ) )
     239             :             {
     240      360668 :                 x[7] = sub( 0, x[7] );
     241      360668 :                 move16();
     242             :             }
     243             :         }
     244             :     }
     245     1743322 : }
     246             : 
     247             : /*-------------------------------------------------------------------*
     248             :  * fcb_decode_pos_fx
     249             :  *
     250             :  * base function for decoding position index
     251             :  *-------------------------------------------------------------------*/
     252     1258756 : 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     1258756 :     k = index;
     264     1258756 :     move16();
     265     1258756 :     l = 0;
     266     1258756 :     move16();
     267     1258756 :     temp1 = pos_num;
     268     1258756 :     move16();
     269     1258756 :     temp2 = add( pulse_num, 1 );
     270             : 
     271     1258756 :     tmp_loop = sub( pos_num, 1 );
     272     2865781 :     FOR( i = 0; i < tmp_loop; i++ )
     273             :     {
     274     1607025 :         select_table23 = select_table22[temp1];
     275     1607025 :         select_table24 = &select_table23[pulse_num - l];
     276             : 
     277     1607025 :         k = sub( *select_table24, k );
     278     4998668 :         WHILE( LE_16( k, *select_table24 ) )
     279             :         {
     280     3391643 :             l = add( l, 1 );
     281     3391643 :             select_table24--;
     282             :         }
     283             : 
     284     1607025 :         k = sub( select_table23[temp2 - l], k );
     285     1607025 :         pos_vector[i] = sub( l, 1 );
     286     1607025 :         move16();
     287     1607025 :         temp1 = sub( temp1, 1 );
     288             :     }
     289     1258756 :     pos_vector[i] = add( l, k );
     290     1258756 :     move16();
     291     1258756 : }

Generated by: LCOV version 1.14