From 386b7d3366f1359a265da207a9cafa3edf553b64 Mon Sep 17 00:00:00 2001 From: Joshua Bakita Date: Mon, 7 Oct 2019 19:13:39 -0400 Subject: Reorganize and commit all the modified TACLeBench code and run scripts --- all_pairs/source/g723_enc/ChangeLog.txt | 34 ++ all_pairs/source/g723_enc/g723_enc.c | 887 ++++++++++++++++++++++++++++++++ all_pairs/source/g723_enc/license.txt | 23 + 3 files changed, 944 insertions(+) create mode 100644 all_pairs/source/g723_enc/ChangeLog.txt create mode 100644 all_pairs/source/g723_enc/g723_enc.c create mode 100644 all_pairs/source/g723_enc/license.txt (limited to 'all_pairs/source/g723_enc') 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