LCOV - code coverage report
Current view: top level - lib_enc - lead_indexing_fx.c (source / functions) Hit Total Coverage
Test: Coverage on main @ e95243e9e67ddeb69dddf129509de1b3d95b402e Lines: 82 82 100.0 %
Date: 2025-09-14 03:13:15 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     1760772 : 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     1760772 :     a1 = vals_a[ka]; /* Q0 */
      39     1760772 :     move16();
      40     1760772 :     a2 = vals_q[ka]; /* Q0 */
      41     1760772 :     move16();
      42             : 
      43             :     /* the sign process */
      44             : 
      45     1760772 :     sign_8p = 0;
      46     1760772 :     move16();
      47     1760772 :     m = 0;
      48     1760772 :     move16();
      49     1760772 :     code_index = 0;
      50     1760772 :     move16();
      51     1760772 :     k1 = a2[0]; /* Q0 */
      52     1760772 :     move16();
      53             : 
      54     1760772 :     test();
      55     1760772 :     test();
      56     1760772 :     IF( EQ_16( a2[1], 2 ) && s_xor( a1[0], 1 ) && sub( ka, 5 ) )
      57             :     {
      58     5546070 :         FOR( i = 0; i < 8; i++ )
      59             :         {
      60     4929840 :             IF( x[i] != 0 )
      61             :             {
      62     1710784 :                 sign_8p = shl( sign_8p, 1 ); /* Q0 */
      63     1710784 :                 setor_8p_temp[m] = i;
      64     1710784 :                 move16();
      65     1710784 :                 m++;
      66             :             }
      67             : 
      68     4929840 :             if ( x[i] < 0 )
      69             :             {
      70      823088 :                 sign_8p = add( sign_8p, 1 ); /* Q0 */
      71             :             }
      72             :         }
      73             : 
      74      616230 :         code_index = fcb_encode_pos_fx( setor_8p_temp, 8, m );
      75      616230 :         code_index = add( shl( code_index, k1 ), sign_8p );
      76             : 
      77      616230 :         offset = Is[ka];
      78      616230 :         move16();
      79             : 
      80      616230 :         *I = extract_l( L_add( offset, (Word32) code_index ) );
      81      616230 :         move16();
      82             :     }
      83             :     ELSE
      84             :     {
      85    10300878 :         FOR( i = 0; i < 8; i++ )
      86             :         {
      87     9156336 :             setor_8p[i] = abs_s( x[i] ); /* Q0 */
      88     9156336 :             move16();
      89             : 
      90     9156336 :             IF( x[i] != 0 )
      91             :             {
      92     8471841 :                 sign_8p = shl( sign_8p, 1 ); /* Q0 */
      93     8471841 :                 m++;
      94             :             }
      95             : 
      96     9156336 :             if ( x[i] < 0 )
      97             :             {
      98     3888673 :                 sign_8p = add( sign_8p, 1 ); /* Q0 */
      99             :             }
     100             :         }
     101             : 
     102     1144542 :         if ( NE_16( k1, m ) )
     103             :         {
     104      910957 :             sign_8p = shr( sign_8p, 1 ); /* Q0 */
     105             :         }
     106             : 
     107             :         /* code level by level */
     108             : 
     109     1144542 :         code_level = sub( a2[1], 1 ); /* Q0 */
     110     1144542 :         code_area = 8;
     111     1144542 :         move16();
     112             : 
     113     1144542 :         IF( NE_16( a2[2], 1 ) )
     114             :         {
     115     1504531 :             FOR( j = 0; j < code_level; j++ )
     116             :             {
     117      592086 :                 m = 0;
     118      592086 :                 move16();
     119             : 
     120     4548798 :                 FOR( i = 0; i < code_area; i++ )
     121             :                 {
     122     3956712 :                     IF( NE_16( setor_8p[i], a1[j] ) )
     123             :                     {
     124     1342988 :                         setor_8p_temp[m] = i; /* Q0 */
     125     1342988 :                         move16();
     126     1342988 :                         setor_8p[m] = setor_8p[i]; /* Q0 */
     127     1342988 :                         move16();
     128     1342988 :                         m++;
     129             :                     }
     130             :                 }
     131      592086 :                 code_index = extract_l( L_mult0( code_index, select_table22[m][code_area] ) );    /* Q0 */
     132      592086 :                 code_index = add( code_index, fcb_encode_pos_fx( setor_8p_temp, code_area, m ) ); /* Q0 */
     133      592086 :                 code_area = m;
     134      592086 :                 move16();
     135             :             }
     136             :         }
     137             :         ELSE
     138             :         {
     139     2088873 :             FOR( i = 0; i < code_area; i++ )
     140             :             {
     141     1856776 :                 if ( EQ_16( setor_8p[i], a1[1] ) )
     142             :                 {
     143      232097 :                     code_index = add( code_index, i ); /* Q0 */
     144             :                 }
     145             :             }
     146             :         }
     147             : 
     148     1144542 :         code_index = add( shl( code_index, k1 ), sign_8p );
     149     1144542 :         offset = Is[ka]; /* Q0 */
     150     1144542 :         move16();
     151             : 
     152     1144542 :         *I = extract_l( L_add( offset, (Word32) code_index ) ); /* Q0 */
     153     1144542 :         move16();
     154             :     }
     155     1760772 : }
     156             : 
     157             : /*-------------------------------------------------------------------*
     158             :  * fcb_encode_pos_fx:
     159             :  *
     160             :  * Base function to compute base index for RE8
     161             :  *-------------------------------------------------------------------*/
     162     1208316 : 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     1208316 :     temp = sub( pulse_num, 1 );
     176             : 
     177     1208316 :     select_table23 = select_table22[pos_num]; /* Q0 */
     178     1208316 :     move16();
     179             : 
     180     1208316 :     code_index = sub( select_table23[pulse_num], select_table23[( pulse_num - pos_vector[0] )] ); /* Q0 */
     181             : 
     182     1208316 :     j = 1;
     183     1208316 :     move16();
     184             : 
     185     1208316 :     Iters = sub( pos_num, 1 );
     186     3053772 :     FOR( i = 0; i < Iters; i++ )
     187             :     {
     188     1845456 :         temp1 = sub( pos_num, j );
     189             : 
     190     1845456 :         select_table23 = select_table22[temp1]; /* Q0 */
     191     1845456 :         move16();
     192             : 
     193     1845456 :         code_index = add( code_index, sub( select_table23[( temp - pos_vector[i] )], select_table23[( pulse_num - pos_vector[j] )] ) ); /* Q0 */
     194             : 
     195     1845456 :         j++;
     196             :     }
     197             : 
     198     1208316 :     return code_index;
     199             : }

Generated by: LCOV version 1.14