Reorganize and commit all the modified TACLeBench code and run scripts

3 files changed, 944 insertions, 0 deletions

diff --git a/all_pairs/source/g723_enc/ChangeLog.txt b/all_pairs/source/g723_enc/ChangeLog.txt
new file mode 100644
index 0000000..8657026
--- /dev/null
+++ b/all_pairs/source/g723_enc/ChangeLog.txt
@@ -0,0 +1,34 @@
+File: g723_enc.c
+Original provenience: SUN Microsystems
+
+2016-03-02:
+ - Renamed file to g723_enc and removed all g721 dead code
+ - Added TACLeBench header to line 1
+ - Moved SUN license to license.txt
+ - Deleted unused code that was commented out
+ - Renamed functions prepended g723_enc to all function names
+ - Renamed function main to g723_enc_main
+ - Created new function main, calling g723_enc_init, g723_enc_main and
+   returning g723_enc_return
+ - Reordered functions in source code: initialization- and
+   return-value-related functions first, followed by algorithm core
+   functions, followed by main functions
+ - Applied code formatting with astyle as in the example
+
+ 2016-03-09:
+ - Renamed global variables, prepended g723_enc_
+ - Removed static keyword from global variables
+ - Renamed datatype from g723_enc_g72x_state to g723_enc_state
+ - Renamed function g723_enc_g72x_init_state to g723_enc_init_state
+
+ 2016-05-23:
+ - Added initialization with volatile int
+ - Added check_sum and comparison with expected result
+
+2016-05-25
+ - Changed name of struct g723_enc_state to g723_enc_state_t
+ - Changed name of variable state to g723_enc_state
+
+2017-07-10
+ - Fixed undefined behaviour introduced by accessing the result of a pointer
+   type cast.
diff --git a/all_pairs/source/g723_enc/g723_enc.c b/all_pairs/source/g723_enc/g723_enc.c
new file mode 100644
index 0000000..6f31210
--- /dev/null
+++ b/all_pairs/source/g723_enc/g723_enc.c
@@ -0,0 +1,887 @@
+/*
+
+    This program is part of the TACLeBench benchmark suite.
+    Version V 1.x
+
+    Name: g723_enc
+
+    Author: Unknown
+
+    Function: g723 encoder.
+
+    Source: SUN Microsystems
+
+    Changes: The benchmark was changed to use the g723 encoder
+
+    License: "Unrestricted use" (see license.txt)
+
+*/
+
+/*
+  Declaration of data types
+*/
+
+/*
+   The following is the definition of the state structure
+   used by the G.721/G.723 encoder and decoder to preserve their internal
+   state between successive calls.  The meanings of the majority
+   of the state structure fields are explained in detail in the
+   CCITT Recommendation G.721.  The field names are essentially indentical
+   to variable names in the bit level description of the coding algorithm
+   included in this Recommendation.
+*/
+
+#include "../extra.h"
+struct g723_enc_state_t {
+  long yl;  /* Locked or steady state step size multiplier. */
+  short yu; /* Unlocked or non-steady state step size multiplier. */
+  short dms;  /* Short term energy estimate. */
+  short dml;  /* Long term energy estimate. */
+  short ap; /* Linear weighting coefficient of 'yl' and 'yu'. */
+
+  short a[2]; /* Coefficients of pole portion of prediction filter. */
+  short b[6]; /* Coefficients of zero portion of prediction filter. */
+  short pk[2];  /*
+        Signs of previous two samples of a partially
+        reconstructed signal.
+*/
+  short dq[6];  /*
+        Previous 6 samples of the quantized difference
+        signal represented in an internal floating point
+        format.
+*/
+  short sr[2];  /*
+        Previous 2 samples of the quantized difference
+        signal represented in an internal floating point
+        format.
+*/
+  char td;  /* delayed tone detect, new in 1988 version */
+};
+
+
+/*
+  Forward declaration of functions
+*/
+
+int g723_enc_abs( int num );
+void g723_enc_init_state( struct g723_enc_state_t *state_ptr );
+int g723_enc_predictor_zero( struct g723_enc_state_t *state_ptr );
+int g723_enc_fmult( int an, int srn );
+int g723_enc_predictor_pole( struct g723_enc_state_t *state_ptr );
+int g723_enc_step_size( struct g723_enc_state_t *state_ptr );
+int g723_enc_quantize(
+  int   d,  /* Raw difference signal sample */
+  int   y,  /* Step size multiplier */
+  short   *table, /* quantization table */
+  int   size ); /* table size of short integers */
+int g723_enc_reconstruct(
+  int   sign, /* 0 for non-negative value */
+  int   dqln, /* G.72x codeword */
+  int   y );  /* Step size multiplier */
+void g723_enc_update(
+  int   code_size,  /* distinguish 723_40 with others */
+  int   y,    /* quantizer step size */
+  int   wi,   /* scale factor multiplier */
+  int   fi,   /* for long/short term energies */
+  int   dq,   /* quantized prediction difference */
+  int   sr,   /* reconstructed signal */
+  int   dqsez,    /* difference from 2-pole predictor */
+  struct g723_enc_state_t *state_ptr ); /* coder state pointer */
+int g723_enc_quan(
+  int   val,
+  short   *table,
+  int   size );
+int g723_enc_search(
+  int   val,
+  short   *table,
+  int   size );
+int g723_enc_alaw2linear( unsigned char a_val );
+int g723_enc_ulaw2linear( unsigned char u_val );
+int g723_enc_g723_24_encoder(
+  int sample,
+  int in_coding,
+  struct g723_enc_state_t *state_ptr );
+int g723_enc_pack_output(
+  unsigned  char  code,
+  int     bits );
+
+void g723_enc_init();
+int g723_enc_return();
+void g723_enc_main();
+//int main( void );
+
+/*
+  Declaration of global variables
+*/
+
+struct g723_enc_state_t g723_enc_state;
+
+unsigned int g723_enc_INPUT[256] = {
+  51, 17, 31, 53, 95, 17, 70, 22, 49, 12,  8, 39, 28, 37, 99, 54,
+  77, 65, 77, 78, 83, 15, 63, 31, 35, 92, 52, 40, 61, 79, 94, 87,
+  87, 68, 76, 58, 39, 35, 20, 83, 42, 46, 98, 12, 21, 96, 74, 41,
+  78, 76, 96,  2, 32, 76, 24, 59,  4, 96, 32,  5, 44, 92, 57, 12,
+  57, 25, 50, 23, 48, 41, 88, 43, 36, 38,  4, 16, 52, 70,  9, 40,
+  78, 24, 34, 23, 30, 30, 89,  3, 65, 40, 68, 73, 94, 23, 84, 97,
+  78, 43, 68, 81, 16, 28, 13, 87, 75, 21, 14, 29, 81, 22, 56, 72,
+  19, 99, 25, 43, 76, 86, 90, 98, 39, 43, 12, 46, 24, 99, 65, 61,
+  24, 45, 79,  7, 48, 15, 24, 95, 62, 99, 48, 80, 75, 38, 48, 53,
+  9, 60, 35, 14, 78, 71, 45, 71,  9, 97, 55, 74, 58, 64, 78, 18,
+  30, 28, 69, 29, 57, 42, 30, 44, 57, 49, 61, 42, 13, 25,  3, 98,
+  11, 38, 65, 35, 55, 36, 57, 48, 16, 62, 17, 56, 29, 88, 84, 85,
+  90, 60, 54, 16, 66, 69, 26, 10, 82, 19, 42, 35, 84, 13, 26, 17,
+  48, 38, 50, 50, 35, 53, 12, 52, 61, 74, 56, 34, 80, 59, 26, 67,
+  55, 79, 89, 89,  6, 80, 91, 65, 16, 30, 16, 28, 85, 54,  3, 20,
+  2, 36, 62, 52, 55, 15, 83,  3,  2, 38, 62,  2, 63, 92, 37, 73
+};
+
+
+
+unsigned int g723_enc_OUTPUT[256];
+
+short g723_enc_power2[15] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80,
+                    0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000
+                   };
+
+
+/*
+   Maps G.723_24 code word to reconstructed scale factor normalized log
+   magnitude values.
+*/
+
+short g723_enc_qtab_723_24[3] = {8, 218, 331};
+
+/*
+   Maps G.721 code word to reconstructed scale factor normalized log
+   magnitude values.
+*/
+short  g723_enc_dqlntab[16] = { -2048, 4, 135, 213, 273, 323, 373, 425,
+                               425, 373, 323, 273, 213, 135, 4, -2048
+                             };
+
+/* Maps G.721 code word to log of scale factor multiplier. */
+short  g723_enc_witab[16] = { -12, 18, 41, 64, 112, 198, 355, 1122,
+                             1122, 355, 198, 112, 64, 41, 18, -12
+                           };
+/*
+   Maps G.721 code words to a set of values whose long and short
+   term averages are computed and then compared to give an indication
+   how stationary (steady state) the signal is.
+*/
+short g723_enc_fitab[16] = {0, 0, 0, 0x200, 0x200, 0x200, 0x600, 0xE00,
+                            0xE00, 0x600, 0x200, 0x200, 0x200, 0, 0, 0
+                           };
+
+
+/*
+  Declaration of macros
+*/
+
+
+#define AUDIO_ENCODING_ULAW (1) /* ISDN u-law */
+#define AUDIO_ENCODING_ALAW (2) /* ISDN A-law */
+#define AUDIO_ENCODING_LINEAR (3) /* PCM 2's-complement (0-center) */
+
+#define BIAS    (0x84)    /* Bias for linear code. */
+
+#define SIGN_BIT  (0x80)    /* Sign bit for a A-law byte. */
+#define QUANT_MASK  (0xf)   /* Quantization field mask. */
+#define SEG_SHIFT (4)   /* Left shift for segment number. */
+#define SEG_MASK  (0x70)    /* Segment field mask. */
+
+/*
+  Arithmetic math functions
+*/
+
+/*
+   g723_enc_fmult()
+
+   returns the integer product of the 14-bit integer "an" and
+   "floating point" representation (4-bit exponent, 6-bit mantessa) "srn".
+*/
+int g723_enc_fmult(
+  int   an,
+  int   srn )
+{
+  short   anmag, anexp, anmant;
+  short   wanexp, wanmant;
+  short   retval;
+
+  anmag = ( an > 0 ) ? an : ( ( -an ) & 0x1FFF );
+  anexp = g723_enc_quan( anmag, g723_enc_power2, 3 ) - 6;
+  anmant = ( anmag == 0 ) ? 32 :
+           ( anexp >= 0 ) ? anmag >> anexp : anmag << -anexp;
+  wanexp = anexp + ( ( srn >> 6 ) & 0xF ) - 13;
+
+  wanmant = ( anmant * ( srn & 077 ) + 0x30 ) >> 4;
+  retval = ( wanexp >= 0 ) ? ( ( wanmant << wanexp ) & 0x7FFF ) :
+           ( wanmant >> -wanexp );
+
+  return ( ( ( an ^ srn ) < 0 ) ? -retval : retval );
+}
+
+
+/* Manish Verma */
+int g723_enc_abs( int num )
+{
+  return ( num < 0 ) ? -num : num;
+}
+
+
+/*
+  Algorithm core functions
+*/
+
+
+/*
+   g723_enc_quan()
+
+   quantizes the input val against the table of size short integers.
+   It returns i if table[i - 1] <= val < table[i].
+
+   Using linear search for simple coding.
+*/
+int g723_enc_quan(
+  int     val,
+  short   *table,
+  int   size )
+{
+  int i,
+      j = 0,
+      k = 1;
+
+  _Pragma( "loopbound min 3 max 15" )
+  for ( i = 0; i < size; ++i ) {
+
+    if ( k ) {
+      if ( val < *table++ ) {
+        j = i;
+        k = 0;
+      }
+    }
+  }
+
+  return ( j );
+}
+
+
+/*
+   g723_enc_predictor_zero()
+
+   computes the estimated signal from 6-zero predictor.
+
+*/
+int
+g723_enc_predictor_zero(
+  struct g723_enc_state_t *state_ptr )
+{
+  int   i;
+  int   sezi;
+
+  sezi = g723_enc_fmult( state_ptr->b[0] >> 2, state_ptr->dq[0] );
+  _Pragma( "loopbound min 5 max 5" )
+  for ( i = 1; i < 6; i++ )     /* ACCUM */
+    sezi += g723_enc_fmult( state_ptr->b[i] >> 2, state_ptr->dq[i] );
+
+  return ( sezi );
+}
+
+
+/*
+   g723_enc_predictor_pole()
+
+   computes the estimated signal from 2-pole predictor.
+
+*/
+int
+g723_enc_predictor_pole(
+  struct g723_enc_state_t *state_ptr )
+{
+  return ( g723_enc_fmult( state_ptr->a[1] >> 2, state_ptr->sr[1] ) +
+           g723_enc_fmult( state_ptr->a[0] >> 2, state_ptr->sr[0] ) );
+}
+
+/*
+   g723_enc_step_size()
+
+   computes the quantization step size of the adaptive quantizer.
+
+*/
+int
+g723_enc_step_size(
+  struct g723_enc_state_t *state_ptr )
+{
+  int   y;
+  int   dif;
+  int   al;
+
+  if ( state_ptr->ap >= 256 )
+    return ( state_ptr->yu );
+  else {
+    y = state_ptr->yl >> 6;
+    dif = state_ptr->yu - y;
+    al = state_ptr->ap >> 2;
+    if ( dif > 0 )
+      y += ( dif * al ) >> 6;
+    else
+      if ( dif < 0 )
+        y += ( dif * al + 0x3F ) >> 6;
+
+    return ( y );
+  }
+}
+
+/*
+   g723_enc_quantize()
+
+   Given a raw sample, 'd', of the difference signal and a
+   quantization step size scale factor, 'y', this routine returns the
+   ADPCM codeword to which that sample gets quantized.  The step
+   size scale factor division operation is done in the log base 2 domain
+   as a subtraction.
+*/
+int
+g723_enc_quantize(
+  int   d,  /* Raw difference signal sample */
+  int   y,  /* Step size multiplier */
+  short   *table, /* quantization table */
+  int   size )  /* table size of short integers */
+{
+  short   dqm;  /* Magnitude of 'd' */
+  short   exp;  /* Integer part of base 2 log of 'd' */
+  short   mant; /* Fractional part of base 2 log */
+  short   dl; /* Log of magnitude of 'd' */
+  short   dln;  /* Step size scale factor normalized log */
+  int   i;
+
+  /*
+     LOG
+
+     Compute base 2 log of 'd', and store in 'dl'.
+  */
+  dqm = g723_enc_abs( d );
+  exp = g723_enc_quan( dqm >> 1, g723_enc_power2, 15 );
+  mant = ( ( dqm << 7 ) >> exp ) & 0x7F;  /* Fractional portion. */
+  dl = ( exp << 7 ) + mant;
+
+  /*
+     SUBTB
+
+     "Divide" by step size multiplier.
+  */
+  dln = dl - ( y >> 2 );
+
+  /*
+     QUAN
+
+     Obtain codword i for 'd'.
+  */
+  i = g723_enc_quan( dln, table, size );
+
+  if ( d < 0 )      /* take 1's complement of i */
+    return ( ( size << 1 ) + 1 - i );
+  else
+    if ( i == 0 )   /* take 1's complement of 0 */
+      return ( ( size << 1 ) + 1 ); /* new in 1988 */
+    else
+      return ( i );
+}
+/*
+   g723_enc_reconstruct()
+
+   Returns reconstructed difference signal 'dq' obtained from
+   codeword 'i' and quantization step size scale factor 'y'.
+   Multiplication is performed in log base 2 domain as addition.
+*/
+int
+g723_enc_reconstruct(
+  int   sign, /* 0 for non-negative value */
+  int   dqln, /* G.72x codeword */
+  int   y ) /* Step size multiplier */
+{
+  short   dql;  /* Log of 'dq' magnitude */
+  short   dex;  /* Integer part of log */
+  short   dqt;
+  short   dq; /* Reconstructed difference signal sample */
+
+  dql = dqln + ( y >> 2 );  /* ADDA */
+
+  if ( dql < 0 )
+    return ( ( sign ) ? -0x8000 : 0 );
+  else {    /* ANTILOG */
+    dex = ( dql >> 7 ) & 15;
+    dqt = 128 + ( dql & 127 );
+    dq = ( dqt << 7 ) >> ( 14 - dex );
+    return ( ( sign ) ? ( dq - 0x8000 ) : dq );
+  }
+}
+
+
+/*
+   g723_enc_update()
+
+   updates the state variables for each output code
+*/
+void
+g723_enc_update(
+  int   code_size,  /* distinguish 723_40 with others */
+  int   y,    /* quantizer step size */
+  int   wi,   /* scale factor multiplier */
+  int   fi,   /* for long/short term energies */
+  int   dq,   /* quantized prediction difference */
+  int   sr,   /* reconstructed signal */
+  int   dqsez,    /* difference from 2-pole predictor */
+  struct g723_enc_state_t *state_ptr )  /* coder state pointer */
+{
+  int   cnt;
+  short   mag, exp; /* Adaptive predictor, FLOAT A */
+  short   a2p;    /* LIMC */
+  short   a1ul;   /* UPA1 */
+  short   pks1;  /* UPA2 */
+  short   fa1;
+  char    tr;   /* tone/transition detector */
+  short   ylint, thr2, dqthr;
+  short     ylfrac, thr1;
+  short   pk0;
+
+  pk0 = ( dqsez < 0 ) ? 1 : 0;  /* needed in updating predictor poles */
+
+  mag = dq & 0x7FFF;    /* prediction difference magnitude */
+  /* TRANS */
+  ylint = state_ptr->yl >> 15;  /* exponent part of yl */
+  ylfrac = ( state_ptr->yl >> 10 ) & 0x1F;  /* fractional part of yl */
+  thr1 = ( 32 + ylfrac ) << ylint;    /* threshold */
+  thr2 = ( ylint > 9 ) ? 31 << 10 : thr1; /* limit thr2 to 31 << 10 */
+  dqthr = ( thr2 + ( thr2 >> 1 ) ) >> 1;  /* dqthr = 0.75 * thr2 */
+  if ( state_ptr->td == 0 )   /* signal supposed voice */
+    tr = 0;
+  else
+    if ( mag <= dqthr )   /* supposed data, but small mag */
+      tr = 0;     /* treated as voice */
+    else        /* signal is data (modem) */
+      tr = 1;
+
+  /*
+     Quantizer scale factor adaptation.
+  */
+
+  /* FUNCTW & FILTD & DELAY */
+  /* update non-steady state step size multiplier */
+  state_ptr->yu = y + ( ( wi - y ) >> 5 );
+
+  /* LIMB */
+  if ( state_ptr->yu < 544 )  /* 544 <= yu <= 5120 */
+    state_ptr->yu = 544;
+  else
+    if ( state_ptr->yu > 5120 )
+      state_ptr->yu = 5120;
+
+  /* FILTE & DELAY */
+  /* update steady state step size multiplier */
+  state_ptr->yl += state_ptr->yu + ( ( -state_ptr->yl ) >> 6 );
+
+  /*
+     Adaptive predictor coefficients.
+  */
+  if ( tr == 1 ) {      /* reset a's and b's for modem signal */
+    state_ptr->a[0] = 0;
+    state_ptr->a[1] = 0;
+    state_ptr->b[0] = 0;
+    state_ptr->b[1] = 0;
+    state_ptr->b[2] = 0;
+    state_ptr->b[3] = 0;
+    state_ptr->b[4] = 0;
+    state_ptr->b[5] = 0;
+  } else {      /* update a's and b's */
+    pks1 = pk0 ^ state_ptr->pk[0];    /* UPA2 */
+
+    /* update predictor pole a[1] */
+    a2p = state_ptr->a[1] - ( state_ptr->a[1] >> 7 );
+    if ( dqsez != 0 ) {
+      fa1 = ( pks1 ) ? state_ptr->a[0] : -state_ptr->a[0];
+      if ( fa1 < -8191 )  /* a2p = function of fa1 */
+        a2p -= 0x100;
+      else
+        if ( fa1 > 8191 )
+          a2p += 0xFF;
+        else
+          a2p += fa1 >> 5;
+      if ( pk0 ^ state_ptr->pk[1] )
+        /* LIMC */
+        if ( a2p <= -12160 )
+          a2p = -12288;
+        else
+          if ( a2p >= 12416 )
+            a2p = 12288;
+          else
+            a2p -= 0x80;
+      else
+        if ( a2p <= -12416 )
+          a2p = -12288;
+        else
+          if ( a2p >= 12160 )
+            a2p = 12288;
+          else
+            a2p += 0x80;
+
+    }
+
+    /* TRIGB & DELAY */
+    state_ptr->a[1] = a2p;
+
+    /* UPA1 */
+    /* update predictor pole a[0] */
+    state_ptr->a[0] -= state_ptr->a[0] >> 8;
+    if ( dqsez != 0 )  {
+      if ( pks1 == 0 )
+        state_ptr->a[0] += 192;
+      else
+        state_ptr->a[0] -= 192;
+    }
+
+    /* LIMD */
+    a1ul = 15360 - a2p;
+    if ( state_ptr->a[0] < -a1ul )
+      state_ptr->a[0] = -a1ul;
+    else
+      if ( state_ptr->a[0] > a1ul )
+        state_ptr->a[0] = a1ul;
+
+    /* UPB : update predictor zeros b[6] */
+    _Pragma( "loopbound min 6 max 6" )
+    for ( cnt = 0; cnt < 6; cnt++ ) {
+      if ( code_size == 5 )   /* for 40Kbps G.723 */
+        state_ptr->b[cnt] -= state_ptr->b[cnt] >> 9;
+      else      /* for G.721 and 24Kbps G.723 */
+        state_ptr->b[cnt] -= state_ptr->b[cnt] >> 8;
+      if ( dq & 0x7FFF ) {      /* XOR */
+        if ( ( dq ^ state_ptr->dq[cnt] ) >= 0 )
+          state_ptr->b[cnt] += 128;
+        else
+          state_ptr->b[cnt] -= 128;
+      }
+
+    }
+  }
+
+  _Pragma( "loopbound min 5 max 5" )
+  for ( cnt = 5; cnt > 0; cnt-- )
+    state_ptr->dq[cnt] = state_ptr->dq[cnt - 1];
+  /* FLOAT A : convert dq[0] to 4-bit exp, 6-bit mantissa f.p. */
+  if ( mag == 0 )
+    state_ptr->dq[0] = ( dq >= 0 ) ? 0x20 : 0xFC20;
+  else {
+    exp = g723_enc_quan( mag, g723_enc_power2, 15 );
+    state_ptr->dq[0] = ( dq >= 0 ) ?
+                       ( exp << 6 ) + ( ( mag << 6 ) >> exp ) :
+                       ( exp << 6 ) + ( ( mag << 6 ) >> exp ) - 0x400;
+
+  }
+
+  state_ptr->sr[1] = state_ptr->sr[0];
+  /* FLOAT B : convert sr to 4-bit exp., 6-bit mantissa f.p. */
+  if ( sr == 0 )
+    state_ptr->sr[0] = 0x20;
+  else
+    if ( sr > 0 ) {
+      exp = g723_enc_quan( sr, g723_enc_power2, 15 );
+      state_ptr->sr[0] = ( exp << 6 ) + ( ( sr << 6 ) >> exp );
+    } else
+      if ( sr > -32768 ) {
+        mag = -sr;
+        exp = g723_enc_quan( mag, g723_enc_power2, 15 );
+        state_ptr->sr[0] =  ( exp << 6 ) + ( ( mag << 6 ) >> exp ) - 0x400;
+      } else
+        state_ptr->sr[0] = 0xFC20;
+
+  /* DELAY A */
+  state_ptr->pk[1] = state_ptr->pk[0];
+  state_ptr->pk[0] = pk0;
+
+  /* TONE */
+  if ( tr == 1 )    /* this sample has been treated as data */
+    state_ptr->td = 0;  /* next one will be treated as voice */
+  else
+    if ( a2p < -11776 ) /* small sample-to-sample correlation */
+      state_ptr->td = 1;  /* signal may be data */
+    else        /* signal is voice */
+      state_ptr->td = 0;
+
+  /*
+     Adaptation speed control.
+  */
+  state_ptr->dms += ( fi - state_ptr->dms ) >> 5;   /* FILTA */
+  state_ptr->dml += ( ( ( fi << 2 ) - state_ptr->dml ) >> 7 );  /* FILTB */
+
+  if ( tr == 1 )
+    state_ptr->ap = 256;
+  else
+    if ( y < 1536 )         /* SUBTC */
+      state_ptr->ap += ( 0x200 - state_ptr->ap ) >> 4;
+    else
+      if ( state_ptr->td == 1 )
+        state_ptr->ap += ( 0x200 - state_ptr->ap ) >> 4;
+      else
+        if ( g723_enc_abs( ( state_ptr->dms << 2 ) - state_ptr->dml ) >=
+             ( state_ptr->dml >> 3 ) )
+          state_ptr->ap += ( 0x200 - state_ptr->ap ) >> 4;
+        else
+          state_ptr->ap += ( -state_ptr->ap ) >> 4;
+
+}
+
+
+/*
+   g723_enc_alaw2linear() - Convert an A-law value to 16-bit linear PCM
+
+*/
+int
+g723_enc_alaw2linear(
+  unsigned char a_val )
+{
+  int   t;
+  int   seg;
+
+  a_val ^= 0x55;
+
+  t = ( a_val & QUANT_MASK ) << 4;
+  seg = ( ( unsigned )a_val & SEG_MASK ) >> SEG_SHIFT;
+  switch ( seg ) {
+    case 0:
+      t += 8;
+      break;
+    case 1:
+      t += 0x108;
+      break;
+    default:
+      t += 0x108;
+      t <<= seg - 1;
+  }
+  return ( ( a_val & SIGN_BIT ) ? t : -t );
+}
+
+
+/*
+   g723_enc_ulaw2linear() - Convert a u-law value to 16-bit linear PCM
+
+   First, a biased linear code is derived from the code word. An unbiased
+   output can then be obtained by subtracting 33 from the biased code.
+
+   Note that this function expects to be passed the complement of the
+   original code word. This is in keeping with ISDN conventions.
+*/
+int
+g723_enc_ulaw2linear(
+  unsigned char u_val )
+{
+  int   t;
+
+  /* Complement to obtain normal u-law value. */
+  u_val = ~u_val;
+
+  /*
+     Extract and bias the quantization bits. Then
+     shift up by the segment number and subtract out the bias.
+  */
+  t = ( ( u_val & QUANT_MASK ) << 3 ) + BIAS;
+  t <<= ( ( unsigned int )u_val & SEG_MASK ) >> SEG_SHIFT;
+
+  return ( ( u_val & SIGN_BIT ) ? ( BIAS - t ) : ( t - BIAS ) );
+}
+
+
+/*
+   g723_enc_g723_24_encoder()
+
+   Encodes a linear PCM, A-law or u-law input sample and returns its 3-bit code.
+   Returns -1 if invalid input coding value.
+*/
+int
+g723_enc_g723_24_encoder(
+  int   sl,
+  int   in_coding,
+  struct g723_enc_state_t *state_ptr )
+{
+  short   sei, sezi, se, sez; /* ACCUM */
+  short   d;      /* SUBTA */
+  short   y;      /* MIX */
+  short   sr;     /* ADDB */
+  short   dqsez;      /* ADDC */
+  short   dq, i;
+
+  switch ( in_coding ) {  /* linearize input sample to 14-bit PCM */
+    case AUDIO_ENCODING_ALAW:
+      sl = g723_enc_alaw2linear( sl ) >> 2;
+      break;
+    case AUDIO_ENCODING_ULAW:
+      sl = g723_enc_ulaw2linear( sl ) >> 2;
+      break;
+    case AUDIO_ENCODING_LINEAR:
+      sl >>= 2;   /* sl of 14-bit dynamic range */
+      break;
+    default:
+      return ( -1 );
+  }
+
+  sezi = g723_enc_predictor_zero( state_ptr );
+  sez = sezi >> 1;
+  sei = sezi + g723_enc_predictor_pole( state_ptr );
+  se = sei >> 1;      /* se = estimated signal */
+
+  d = sl - se;      /* d = estimation diff. */
+
+  /* quantize prediction difference d */
+  y = g723_enc_step_size( state_ptr ); /* quantizer step size */
+  i = g723_enc_quantize( d, y, g723_enc_qtab_723_24, 3 ); /* i = ADPCM code */
+  dq = g723_enc_reconstruct( i & 4, g723_enc_dqlntab[i], y ); /* quantized diff. */
+
+  sr = ( dq < 0 ) ? se - ( dq & 0x3FFF ) : se + dq; /* reconstructed signal */
+
+  dqsez = sr + sez - se;    /* pole prediction diff. */
+
+  g723_enc_update( 3, y, g723_enc_witab[i], g723_enc_fitab[i], dq, sr, dqsez, state_ptr );
+
+  return ( i );
+}
+
+/*
+   Pack output codes into bytes and write them to stdout.
+   Returns 1 if there is residual output, else returns 0.
+*/
+int
+g723_enc_pack_output(
+  unsigned  char  code,
+  int     bits )
+{
+  static unsigned int out_buffer = 0;
+  static int    out_bits = 0;
+  unsigned char   out_byte;
+  static int              i = 0;
+
+  out_buffer |= ( code << out_bits );
+  out_bits += bits;
+  if ( out_bits >= 8 ) {
+    out_byte = out_buffer & 0xff;
+    out_bits -= 8;
+    out_buffer >>= 8;
+    //fwrite(&out_byte, sizeof (char), 1, fp_out);
+    //fwrite(&out_byte, 1, 1, fp_out);
+    g723_enc_OUTPUT[i] = out_byte;
+    i =  i + 1;
+  }
+
+  return ( out_bits > 0 );
+}
+
+/*
+  Initialization- and return-value-related functions
+*/
+
+/*
+   g723_enc_init_state()
+
+   This routine initializes and/or resets the g72x_state structure
+   pointed to by 'state_ptr'.
+   All the initial state values are specified in the CCITT G.721 document.
+*/
+void
+g723_enc_init_state(
+  struct g723_enc_state_t *state_ptr )
+{
+  int   cnta;
+
+  state_ptr->yl = 34816;
+  state_ptr->yu = 544;
+  state_ptr->dms = 0;
+  state_ptr->dml = 0;
+  state_ptr->ap = 0;
+
+  _Pragma( "loopbound min 2 max 2" )
+  for ( cnta = 0; cnta < 2; cnta++ ) {
+    state_ptr->a[cnta] = 0;
+    state_ptr->pk[cnta] = 0;
+    state_ptr->sr[cnta] = 32;
+  }
+  _Pragma( "loopbound min 6 max 6" )
+  for ( cnta = 0; cnta < 6; cnta++ ) {
+    state_ptr->b[cnta] = 0;
+    state_ptr->dq[cnta] = 32;
+  }
+  state_ptr->td = 0;
+}
+
+
+void g723_enc_init()
+{
+  int i;
+  volatile int x = 0;
+  g723_enc_init_state( &g723_enc_state );
+
+   _Pragma( "loopbound min 256 max 256" )
+  for ( i = 0; i < 256; i++ ) {
+    g723_enc_INPUT[i] += x;
+  }
+}
+
+
+int g723_enc_return()
+{ 
+  int i;
+  int check_sum = 0;
+
+   _Pragma( "loopbound min 256 max 256" )
+  for ( i = 0; i < 256; i++ ) {
+    check_sum += g723_enc_OUTPUT[i];
+  }
+
+  return ( check_sum != 24284 );
+}
+
+/*
+  Main functions
+*/
+
+void _Pragma( "entrypoint" ) g723_enc_main()
+{
+//  struct g72x_state state;
+  short   sample_short; //mv
+  unsigned char   code;
+  int     resid;
+  int     in_coding;
+  short    *in_buf;
+  int     enc_bits;
+  int i = 0;
+
+  enc_bits = 3;
+  in_coding = AUDIO_ENCODING_ALAW;
+  in_buf = &sample_short;
+
+  _Pragma( "loopbound min 256 max 256" )
+  for ( i = 0; i < 256; i++ ) {
+    *in_buf = g723_enc_INPUT[i];
+    code = g723_enc_g723_24_encoder( sample_short, in_coding, &g723_enc_state );
+    resid = g723_enc_pack_output( code, enc_bits );
+  }
+
+  /* Write zero codes until all residual codes are written out */
+  _Pragma( "loopbound min 0 max 0" )
+  while ( resid )
+    resid = g723_enc_pack_output( 0, enc_bits );
+}
+
+
+int main( int argc, char **argv )
+{
+        //SET_UP
+        int jobsComplete;
+        int maxJobs=9;
+        for (jobsComplete=-1; jobsComplete<maxJobs; jobsComplete++){
+        //      START_LOOP
+                g723_enc_init();
+                g723_enc_main();
+        //      STOP_LOOP
+        }
+        //WRITE_TO_FILE
+  return ( g723_enc_return() );
+}
+
diff --git a/all_pairs/source/g723_enc/license.txt b/all_pairs/source/g723_enc/license.txt
new file mode 100644
index 0000000..80cf21f
--- /dev/null
+++ b/all_pairs/source/g723_enc/license.txt
@@ -0,0 +1,23 @@
+This source code is a product of Sun Microsystems, Inc. and is provided
+for unrestricted use.  Users may copy or modify this source code without
+charge.
+
+SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
+THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+
+Sun source code is provided with no support and without any obligation on
+the part of Sun Microsystems, Inc. to assist in its use, correction,
+modification or enhancement.
+
+SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
+OR ANY PART THEREOF.
+
+In no event will Sun Microsystems, Inc. be liable for any lost revenue
+or profits or other special, indirect and consequential damages, even if
+Sun has been advised of the possibility of such damages.
+
+Sun Microsystems, Inc.
+2550 Garcia Avenue
+Mountain View, California  94043
\ No newline at end of file