LCOV - code coverage report
Current view: top level - lib_enc - lead_indexing_fx.c (source / functions) Hit Total Coverage
Test: Coverage on main enc/dec/rend @ 3b2f07138c61dcf997bbf4165d0882f794b2995f Lines: 82 82 100.0 %
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             : #include <stdint.h>
       5             : #include "options.h" /* Compilation switches                   */
       6             : #include "cnst.h"
       7             : //#include "prot_fx.h"
       8             : #include "rom_com_fx.h"
       9             : #include "rom_com.h"
      10             : #include "prot_fx.h"     /* Function prototypes                    */
      11             : #include "prot_fx_enc.h" /* Function prototypes                    */
      12             : 
      13             : /*-------------------------------------------------------------------*
      14             :  * Local function prototypes
      15             :  *-------------------------------------------------------------------*/
      16             : static Word16 fcb_encode_pos_fx( const Word16 pos_vector[], const Word16 pulse_num, const Word16 pos_num );
      17             : 
      18             : /*-------------------------------------------------------------------*
      19             :  * re8_compute_base_index_fx:
      20             :  *
      21             :  * Compute base index for RE8
      22             :  *-------------------------------------------------------------------*/
      23     1706808 : void re8_compute_base_index_fx(
      24             :     const Word16 *x, /* i  : Elemen of Q2, Q3 or Q4                          */
      25             :     const Word16 ka, /* i  : Identifier of the absolute leader related to x  Q0*/
      26             :     UWord16 *I       /* o  : index                                           Q0*/
      27             : )
      28             : {
      29             :     Word16 i, j, k1, m;
      30             :     Word16 setor_8p[8], setor_8p_temp[8];
      31             :     Word16 sign_8p;
      32             :     Word16 code_level, code_area;
      33             : 
      34             :     const Word16 *a1, *a2;
      35             :     Word16 code_index;
      36             :     UWord16 offset;
      37             : 
      38     1706808 :     a1 = vals_a[ka]; /* Q0 */
      39     1706808 :     move16();
      40     1706808 :     a2 = vals_q[ka]; /* Q0 */
      41     1706808 :     move16();
      42             : 
      43             :     /* the sign process */
      44             : 
      45     1706808 :     sign_8p = 0;
      46     1706808 :     move16();
      47     1706808 :     m = 0;
      48     1706808 :     move16();
      49     1706808 :     code_index = 0;
      50     1706808 :     move16();
      51     1706808 :     k1 = a2[0]; /* Q0 */
      52     1706808 :     move16();
      53             : 
      54     1706808 :     test();
      55     1706808 :     test();
      56     1706808 :     IF( EQ_16( a2[1], 2 ) && s_xor( a1[0], 1 ) && sub( ka, 5 ) )
      57             :     {
      58     5384619 :         FOR( i = 0; i < 8; i++ )
      59             :         {
      60     4786328 :             IF( x[i] != 0 )
      61             :             {
      62     1657427 :                 sign_8p = shl( sign_8p, 1 ); /* Q0 */
      63     1657427 :                 setor_8p_temp[m] = i;
      64     1657427 :                 move16();
      65     1657427 :                 m++;
      66             :             }
      67             : 
      68     4786328 :             if ( x[i] < 0 )
      69             :             {
      70      795094 :                 sign_8p = add( sign_8p, 1 ); /* Q0 */
      71             :             }
      72             :         }
      73             : 
      74      598291 :         code_index = fcb_encode_pos_fx( setor_8p_temp, 8, m );
      75      598291 :         code_index = add( shl( code_index, k1 ), sign_8p );
      76             : 
      77      598291 :         offset = Is[ka];
      78      598291 :         move16();
      79             : 
      80      598291 :         *I = extract_l( L_add( offset, (Word32) code_index ) );
      81      598291 :         move16();
      82             :     }
      83             :     ELSE
      84             :     {
      85     9976653 :         FOR( i = 0; i < 8; i++ )
      86             :         {
      87     8868136 :             setor_8p[i] = abs_s( x[i] ); /* Q0 */
      88     8868136 :             move16();
      89             : 
      90     8868136 :             IF( x[i] != 0 )
      91             :             {
      92     8207362 :                 sign_8p = shl( sign_8p, 1 ); /* Q0 */
      93     8207362 :                 m++;
      94             :             }
      95             : 
      96     8868136 :             if ( x[i] < 0 )
      97             :             {
      98     3758439 :                 sign_8p = add( sign_8p, 1 ); /* Q0 */
      99             :             }
     100             :         }
     101             : 
     102     1108517 :         if ( NE_16( k1, m ) )
     103             :         {
     104      882794 :             sign_8p = shr( sign_8p, 1 ); /* Q0 */
     105             :         }
     106             : 
     107             :         /* code level by level */
     108             : 
     109     1108517 :         code_level = sub( a2[1], 1 ); /* Q0 */
     110     1108517 :         code_area = 8;
     111     1108517 :         move16();
     112             : 
     113     1108517 :         IF( NE_16( a2[2], 1 ) )
     114             :         {
     115     1455641 :             FOR( j = 0; j < code_level; j++ )
     116             :             {
     117      570800 :                 m = 0;
     118      570800 :                 move16();
     119             : 
     120     4385597 :                 FOR( i = 0; i < code_area; i++ )
     121             :                 {
     122     3814797 :                     IF( NE_16( setor_8p[i], a1[j] ) )
     123             :                     {
     124     1294866 :                         setor_8p_temp[m] = i; /* Q0 */
     125     1294866 :                         move16();
     126     1294866 :                         setor_8p[m] = setor_8p[i]; /* Q0 */
     127     1294866 :                         move16();
     128     1294866 :                         m++;
     129             :                     }
     130             :                 }
     131      570800 :                 code_index = extract_l( L_mult0( code_index, select_table22[m][code_area] ) );    /* Q0 */
     132      570800 :                 code_index = add( code_index, fcb_encode_pos_fx( setor_8p_temp, code_area, m ) ); /* Q0 */
     133      570800 :                 code_area = m;
     134      570800 :                 move16();
     135             :             }
     136             :         }
     137             :         ELSE
     138             :         {
     139     2013084 :             FOR( i = 0; i < code_area; i++ )
     140             :             {
     141     1789408 :                 if ( EQ_16( setor_8p[i], a1[1] ) )
     142             :                 {
     143      223676 :                     code_index = add( code_index, i ); /* Q0 */
     144             :                 }
     145             :             }
     146             :         }
     147             : 
     148     1108517 :         code_index = add( shl( code_index, k1 ), sign_8p );
     149     1108517 :         offset = Is[ka]; /* Q0 */
     150     1108517 :         move16();
     151             : 
     152     1108517 :         *I = extract_l( L_add( offset, (Word32) code_index ) ); /* Q0 */
     153     1108517 :         move16();
     154             :     }
     155     1706808 : }
     156             : 
     157             : /*-------------------------------------------------------------------*
     158             :  * fcb_encode_pos_fx:
     159             :  *
     160             :  * Base function to compute base index for RE8
     161             :  *-------------------------------------------------------------------*/
     162     1169091 : static Word16 fcb_encode_pos_fx(                            /* o  : Code index              Q0*/
     163             :                                  const Word16 pos_vector[], /* i  : Position vectort        Q0*/
     164             :                                  const Word16 pulse_num,    /* i  : Pulse number            Q0*/
     165             :                                  const Word16 pos_num       /* i  : Position number         Q0*/
     166             : )
     167             : {
     168             :     Word16 i, j;
     169             :     Word16 code_index;
     170             :     Word16 temp, temp1;
     171             :     Word16 Iters;
     172             : 
     173             :     const Word16 *select_table23;
     174             : 
     175     1169091 :     temp = sub( pulse_num, 1 );
     176             : 
     177     1169091 :     select_table23 = select_table22[pos_num]; /* Q0 */
     178     1169091 :     move16();
     179             : 
     180     1169091 :     code_index = sub( select_table23[pulse_num], select_table23[( pulse_num - pos_vector[0] )] ); /* Q0 */
     181             : 
     182     1169091 :     j = 1;
     183     1169091 :     move16();
     184             : 
     185     1169091 :     Iters = sub( pos_num, 1 );
     186     2952293 :     FOR( i = 0; i < Iters; i++ )
     187             :     {
     188     1783202 :         temp1 = sub( pos_num, j );
     189             : 
     190     1783202 :         select_table23 = select_table22[temp1]; /* Q0 */
     191     1783202 :         move16();
     192             : 
     193     1783202 :         code_index = add( code_index, sub( select_table23[( temp - pos_vector[i] )], select_table23[( pulse_num - pos_vector[j] )] ) ); /* Q0 */
     194             : 
     195     1783202 :         j++;
     196             :     }
     197             : 
     198     1169091 :     return code_index;
     199             : }

Generated by: LCOV version 1.14