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

Generated by: LCOV version 1.14