FreeCalypso > hg > gsm-codec-lib

changeset 323:dfd5f159574b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
libtwamr: integrate c8_31pf.c
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 18 Apr 2024 19:47:13 +0000
parents fc82b113977f
children dc3b7caa59c4
files libtwamr/Makefile libtwamr/c8_31pf.c libtwamr/c8_31pf.h libtwamr/namespace.h
diffstat 4 files changed, 393 insertions(+), 2 deletions(-) [+]
line wrap: on
line diff
--- a/libtwamr/Makefile	Thu Apr 18 19:41:41 2024 +0000
+++ b/libtwamr/Makefile	Thu Apr 18 19:47:13 2024 +0000
@@ -2,8 +2,8 @@
 CFLAGS=	-O2
 OBJS=	a_refl.o agc.o autocorr.o az_lsp.o b_cn_cod.o basicop2.o bgnscd.o \
 	bitno.o bits2prm.o c1035pf.o c2_11pf.o c2_9pf.o c3_14pf.o c4_17pf.o \
-	cor_h.o gmed_n.o graytab.o inv_sqrt.o oper_32b.o prmno.o s10_8pf.o \
-	set_sign.o sqrt_l.o tls_flags.o window.o
+	c8_31pf.o cor_h.o gmed_n.o graytab.o inv_sqrt.o oper_32b.o prmno.o \
+	s10_8pf.o set_sign.o sqrt_l.o tls_flags.o window.o
 LIB=	libtwamr.a
 
 INSTALL_PREFIX=	/usr/local
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libtwamr/c8_31pf.c	Thu Apr 18 19:47:13 2024 +0000
@@ -0,0 +1,343 @@
+/*
+********************************************************************************
+*
+*      GSM AMR-NB speech codec   R98   Version 7.6.0   December 12, 2001
+*                                R99   Version 3.3.0                
+*                                REL-4 Version 4.1.0                
+*
+********************************************************************************
+*
+*      File             : c8_31pf.c
+*      Purpose          : Searches a 31 bit algebraic codebook containing 
+*                       : 8 pulses in a frame of 40 samples.
+*                       : in the same manner as GSM-EFR
+*
+********************************************************************************
+*/
+/*
+********************************************************************************
+*                         MODULE INCLUDE FILE AND VERSION ID
+********************************************************************************
+*/
+#include "namespace.h"
+#include "c8_31pf.h"
+/*
+********************************************************************************
+*                         INCLUDE FILES
+********************************************************************************
+*/
+#include "typedef.h"
+#include "basic_op.h"
+#include "no_count.h"
+#include "cnst.h"
+#include "inv_sqrt.h"
+#include "cor_h.h"
+#include "set_sign.h"
+#include "s10_8pf.h"
+
+/*
+********************************************************************************
+*                         LOCAL VARIABLES AND TABLES
+********************************************************************************
+*/
+#define NB_PULSE 8
+
+/* define values/representation for output codevector and sign */
+#define POS_CODE  8191 
+#define NEG_CODE  8191 
+#define POS_SIGN  32767
+#define NEG_SIGN  (Word16) (-32768L) 
+
+/*
+********************************************************************************
+*                         LOCAL PROGRAM CODE
+********************************************************************************
+*/
+
+/*************************************************************************
+ *
+ *  FUNCTION:  build_code()
+ *
+ *  PURPOSE: Builds the codeword, the filtered codeword and a 
+ *   linear uncombined version of  the index of the
+ *           codevector, based on the signs and positions of 8  pulses.
+ *
+ *************************************************************************/
+
+static void build_code (
+    Word16 codvec[],    /* i : position of pulses                           */
+    Word16 sign[],      /* i : sign of d[n]                                 */
+    Word16 cod[],       /* o : innovative code vector                       */
+    Word16 h[],         /* i : impulse response of weighted synthesis filter*/
+    Word16 y[],         /* o : filtered innovative code                     */
+    Word16 sign_indx[], /* o : signs of 4  pulses (signs only)              */
+    Word16 pos_indx[]   /* o : position index of 8 pulses(position only)    */
+)
+{
+    Word16 i, j, k, track, sign_index, pos_index, _sign[NB_PULSE];
+    Word16 *p0, *p1, *p2, *p3, *p4, *p5, *p6, *p7;
+    Word32 s;
+
+    for (i = 0; i < L_CODE; i++)
+    {
+        cod[i] = 0;                              move16 (); 
+    }
+    for (i = 0; i < NB_TRACK_MR102; i++)
+    {
+        pos_indx[i] = -1;                            move16 (); 
+        sign_indx[i] = -1;                            move16 (); 
+    }
+    
+    for (k = 0; k < NB_PULSE; k++)
+    {
+       /* read pulse position */            
+       i = codvec[k];                           move16 ();
+       /* read sign           */        
+       j = sign[i];                             move16 (); 
+       
+       pos_index = shr(i, 2);                      /* index = pos/4 */
+       track = i & 3;             logic16 ();      /* track = pos%4 */
+       
+       test (); 
+       if (j > 0)
+       {
+          cod[i] = add (cod[i], POS_CODE);         move16 ();
+          _sign[k] = POS_SIGN;                     move16 (); 
+          sign_index = 0;  /* bit=0 -> positive pulse */  move16 (); 
+       }
+       else
+       {
+          cod[i] = sub (cod[i], NEG_CODE);         move16 ();
+          _sign[k] = NEG_SIGN;                     move16 (); 
+          sign_index = 1;     move16 (); /* bit=1 => negative pulse */ 
+          /* index = add (index, 8); 1 = negative  old code */
+       }
+       
+       test (); move16 ();
+       if (pos_indx[track] < 0)
+       {   /* first set first NB_TRACK pulses  */
+          pos_indx[track] = pos_index;                 move16 (); 
+          sign_indx[track] = sign_index;              move16 (); 
+       }
+       else
+       {   /* 2nd row of pulses , test if positions needs to be switched */
+          test (); logic16 (); logic16 (); 
+          if (((sign_index ^ sign_indx[track]) & 1) == 0)
+          {
+             /* sign of 1st pulse == sign of 2nd pulse */
+             
+             test (); 
+             if (sub (pos_indx[track], pos_index) <= 0)
+             {   /* no swap */
+                pos_indx[track + NB_TRACK_MR102] = pos_index;     move16 (); 
+             }
+             else
+             {   /* swap*/
+                pos_indx[track + NB_TRACK_MR102] = pos_indx[track];
+                move16 (); 
+                
+                pos_indx[track] = pos_index;         move16 ();
+                sign_indx[track] = sign_index;       move16 ();
+             }
+          }
+          else
+          {
+             /* sign of 1st pulse != sign of 2nd pulse */
+             
+             test (); 
+             if (sub (pos_indx[track], pos_index) <= 0)
+             {  /*swap*/
+                pos_indx[track + NB_TRACK_MR102] = pos_indx[track];
+                move16 (); 
+                
+                pos_indx[track] = pos_index;         move16 (); 
+                sign_indx[track] = sign_index;       move16 (); 
+             }
+             else
+             {   /*no swap */
+                pos_indx[track + NB_TRACK_MR102] = pos_index;     move16 (); 
+             }
+          }
+       }
+    }
+    
+    p0 = h - codvec[0];                          move16 (); 
+    p1 = h - codvec[1];                          move16 (); 
+    p2 = h - codvec[2];                          move16 (); 
+    p3 = h - codvec[3];                          move16 (); 
+    p4 = h - codvec[4];                          move16 (); 
+    p5 = h - codvec[5];                          move16 (); 
+    p6 = h - codvec[6];                          move16 (); 
+    p7 = h - codvec[7];                          move16 (); 
+    
+    for (i = 0; i < L_CODE; i++)
+    {
+       s = 0;                                   move32 (); 
+       s = L_mac (s, *p0++, _sign[0]);
+       s = L_mac (s, *p1++, _sign[1]);
+       s = L_mac (s, *p2++, _sign[2]);
+       s = L_mac (s, *p3++, _sign[3]);
+       s = L_mac (s, *p4++, _sign[4]);
+       s = L_mac (s, *p5++, _sign[5]);
+       s = L_mac (s, *p6++, _sign[6]);
+       s = L_mac (s, *p7++, _sign[7]);
+       y[i] = round (s);                        move16 (); 
+    }
+}
+
+/*************************************************************************
+ *
+ *  FUNCTION:  compress_code()
+ *
+ *  PURPOSE: compression of three indeces [0..9] to one 10 bit index   
+ *           minimizing the phase shift of a bit error.
+ *
+ *************************************************************************/
+
+
+static Word16 compress10 (
+       Word16 pos_indxA, /* i : signs of 4 pulses (signs only)             */
+       Word16 pos_indxB,  /* i : position index of 8 pulses (pos only)     */
+       Word16 pos_indxC) /* i : position and sign of 8 pulses (compressed) */
+{
+   Word16 indx, ia,ib,ic;
+
+   ia = shr(pos_indxA, 1);
+   ib = extract_l(L_shr(L_mult(shr(pos_indxB, 1), 5), 1));
+   ic = extract_l(L_shr(L_mult(shr(pos_indxC, 1), 25), 1));            
+   indx = shl(add(ia, add(ib, ic)), 3);
+   ia = pos_indxA & 1;                                logic16 ();
+   ib = shl((pos_indxB & 1), 1);                      logic16 ();
+   ic = shl((pos_indxC & 1), 2);                      logic16 ();
+   indx = add(indx , add(ia, add(ib, ic)));  
+   
+   return indx;
+
+}
+
+/*************************************************************************
+ *
+ *  FUNCTION:  compress_code()
+ *
+ *  PURPOSE: compression of the linear codewords to 4+three indeces  
+ *           one bit from each pulse is made robust to errors by 
+ *           minimizing the phase shift of a bit error.
+ *           4 signs (one for each track) 
+ *           i0,i4,i1 => one index (7+3) bits, 3   LSBs more robust
+ *           i2,i6,i5 => one index (7+3) bits, 3   LSBs more robust
+ *           i3,i7    => one index (5+2) bits, 2-3 LSbs more robust
+ *
+ *************************************************************************/
+
+
+static void compress_code (
+    Word16 sign_indx[], /* i : signs of 4 pulses (signs only)             */
+    Word16 pos_indx[],  /* i : position index of 8 pulses (position only) */
+    Word16 indx[])      /* o : position and sign of 8 pulses (compressed) */
+{
+   Word16 i, ia, ib, ic;
+
+   for (i = 0; i < NB_TRACK_MR102; i++)
+   {
+      indx[i] = sign_indx[i];                            move16 (); 
+   }
+    
+    /* First index 
+      indx[NB_TRACK] = (ia/2+(ib/2)*5 +(ic/2)*25)*8 + ia%2 + (ib%2)*2 + (ic%2)*4; */
+   move16 (); 
+   indx[NB_TRACK_MR102] = compress10(pos_indx[0],pos_indx[4],pos_indx[1]);
+
+    /* Second index       
+      indx[NB_TRACK+1] = (ia/2+(ib/2)*5 +(ic/2)*25)*8 + ia%2 + (ib%2)*2 + (ic%2)*4; */
+    
+   move16 (); 
+   indx[NB_TRACK_MR102+1]= compress10(pos_indx[2],pos_indx[6],pos_indx[5]);
+    
+    /*
+      Third index      
+      if ((ib/2)%2 == 1)
+        indx[NB_TRACK+2] = ((((4-ia/2) + (ib/2)*5)*32+12)/25)*4 + ia%2 + (ib%2)*2;
+      else   
+        indx[NB_TRACK+2] = ((((ia/2) +   (ib/2)*5)*32+12)/25)*4 + ia%2 + (ib%2)*2;
+        */
+    
+    ib = shr(pos_indx[7], 1) & 1;                        logic16 ();
+    test ();
+    if (sub(ib, 1) == 0)
+       ia = sub(4, shr(pos_indx[3], 1));
+    else
+       ia = shr(pos_indx[3], 1);
+
+    ib = extract_l(L_shr(L_mult(shr(pos_indx[7], 1), 5), 1));       
+    ib = add(shl(add(ia, ib), 5), 12);
+    ic = shl(mult(ib, 1311), 2);
+    ia = pos_indx[3] & 1;                             logic16 ();
+    ib = shl((pos_indx[7] & 1), 1);                   logic16 ();
+    indx[NB_TRACK_MR102+2] = add(ia, add(ib, ic));
+}
+
+
+/*
+********************************************************************************
+*                         PUBLIC PROGRAM CODE
+********************************************************************************
+*/
+/*************************************************************************
+ *
+ *  FUNCTION:  code_8i40_31bits()
+ *
+ *  PURPOSE:  Searches a 31 bit algebraic codebook containing 8 pulses
+ *            in a frame of 40 samples.
+ *
+ *  DESCRIPTION:
+ *    The code contains 8 nonzero pulses: i0...i7.
+ *    All pulses can have two possible amplitudes: +1 or -1.
+ *    The 40 positions in a subframe are divided into 4 tracks of
+ *    interleaved positions. Each track contains two pulses.
+ *    The pulses can have the following possible positions:
+ *
+ *       i0, i4 :  0, 4, 8,  12, 16, 20, 24, 28, 32, 36
+ *       i1, i5 :  1, 5, 9,  13, 17, 21, 25, 29, 33, 37
+ *       i2, i6 :  2, 6, 10, 14, 18, 22, 26, 30, 34, 38
+ *       i3, i7 :  3, 7, 11, 15, 19, 23, 27, 31, 35, 39
+ *
+ *    Each pair of pulses require 1 bit for their signs. The positions 
+ *    are encoded together 3,3 and 2 resulting in   
+ *    (7+3) + (7+3) + (5+2) bits for their
+ *    positions. This results in a 31 (4 sign and 27 pos) bit codebook.
+ *    The function determines the optimal pulse signs and positions, builds
+ *    the codevector, and computes the filtered codevector.
+ *
+ *************************************************************************/
+
+void code_8i40_31bits (
+   Word16 x[],        /* i : target vector                                  */
+   Word16 cn[],       /* i : residual after long term prediction            */
+   Word16 h[],        /* i : impulse response of weighted synthesis
+                             filter                                         */
+   Word16 cod[],      /* o : algebraic (fixed) codebook excitation          */
+   Word16 y[],        /* o : filtered fixed codebook excitation             */
+   Word16 indx[]      /* o : 7 Word16, index of 8 pulses (signs+positions)  */
+)
+{
+   Word16 ipos[NB_PULSE], pos_max[NB_TRACK_MR102], codvec[NB_PULSE];
+   Word16 dn[L_CODE], sign[L_CODE];
+   Word16 rr[L_CODE][L_CODE];
+   Word16 linear_signs[NB_TRACK_MR102];
+   Word16 linear_codewords[NB_PULSE];
+
+   cor_h_x2 (h, x, dn, 2, NB_TRACK_MR102, STEP_MR102);
+   /* 2 = use GSMEFR scaling */
+
+   set_sign12k2 (dn, cn, sign, pos_max, NB_TRACK_MR102, ipos, STEP_MR102);
+   /* same setsign alg as GSM-EFR new constants though*/
+   
+   cor_h (h, sign, rr);
+   search_10and8i40 (NB_PULSE, STEP_MR102, NB_TRACK_MR102,
+                     dn, rr, ipos, pos_max, codvec);
+   
+   build_code (codvec, sign, cod, h, y, linear_signs, linear_codewords);
+   compress_code (linear_signs, linear_codewords, indx);
+   
+   return;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libtwamr/c8_31pf.h	Thu Apr 18 19:47:13 2024 +0000
@@ -0,0 +1,47 @@
+/*
+********************************************************************************
+*
+*      GSM AMR-NB speech codec   R98   Version 7.6.0   December 12, 2001
+*                                R99   Version 3.3.0                
+*                                REL-4 Version 4.1.0                
+*
+********************************************************************************
+*
+*      File             : c8_31pf.h
+*      Purpose          : Searches a 31 bit algebraic codebook containing 
+*                       : 8 pulses in a frame of 40 samples.
+*
+********************************************************************************
+*/
+#ifndef c8_31pf_h
+#define c8_31pf_h "$Id $"
+ 
+/*
+********************************************************************************
+*                         INCLUDE FILES
+********************************************************************************
+*/
+#include "typedef.h"
+ 
+/*
+********************************************************************************
+*                         DEFINITION OF DATA TYPES
+********************************************************************************
+*/
+ 
+/*
+********************************************************************************
+*                         DECLARATION OF PROTOTYPES
+********************************************************************************
+*/
+void code_8i40_31bits (
+    Word16 x[],        /* i : target vector                                  */
+    Word16 cn[],       /* i : residual after long term prediction            */
+    Word16 h[],        /* i : impulse response of weighted synthesis
+                              filter                                         */
+    Word16 cod[],      /* o : algebraic (fixed) codebook excitation          */
+    Word16 y[],        /* o : filtered fixed codebook excitation             */
+    Word16 indx[]      /* o : 7 Word16, index of 8 pulses (signs+positions)  */
+    );
+ 
+#endif
--- a/libtwamr/namespace.h	Thu Apr 18 19:41:41 2024 +0000
+++ b/libtwamr/namespace.h	Thu Apr 18 19:47:13 2024 +0000
@@ -94,6 +94,7 @@
 #define	code_2i40_11bits	AMR__code_2i40_11bits
 #define	code_3i40_14bits	AMR__code_3i40_14bits
 #define	code_4i40_17bits	AMR__code_4i40_17bits
+#define	code_8i40_31bits	AMR__code_8i10_31bits
 #define	code_10i40_35bits	AMR__code_10i40_35bits
 #define	search_10and8i40	AMR__search_10and8i40