/* 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