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

Generated by: LCOV version 1.14