[llvm-commits] CVS: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/COPYRIGHT Makefile add.c code.c config.h debug.c decode.c gsm.h gsm_create.c gsm_decode.c gsm_destroy.c gsm_encode.c gsm_explode.c gsm_implode.c gsm_option.c gsm_print.c long_term.c lpc.c preprocess.c private.h proto.h rpe.c short_term.c table.c toast.c toast.h toast_alaw.c toast_audio.c toast_lin.c toast_ulaw.c unproto.h
Dinakar Dhurjati
dhurjati at cs.uiuc.edu
Tue Jan 11 10:05:45 PST 2005
Changes in directory llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast:
COPYRIGHT added (r1.1)
Makefile added (r1.1)
add.c added (r1.1)
code.c added (r1.1)
config.h added (r1.1)
debug.c added (r1.1)
decode.c added (r1.1)
gsm.h added (r1.1)
gsm_create.c added (r1.1)
gsm_decode.c added (r1.1)
gsm_destroy.c added (r1.1)
gsm_encode.c added (r1.1)
gsm_explode.c added (r1.1)
gsm_implode.c added (r1.1)
gsm_option.c added (r1.1)
gsm_print.c added (r1.1)
long_term.c added (r1.1)
lpc.c added (r1.1)
preprocess.c added (r1.1)
private.h added (r1.1)
proto.h added (r1.1)
rpe.c added (r1.1)
short_term.c added (r1.1)
table.c added (r1.1)
toast.c added (r1.1)
toast.h added (r1.1)
toast_alaw.c added (r1.1)
toast_audio.c added (r1.1)
toast_lin.c added (r1.1)
toast_ulaw.c added (r1.1)
unproto.h added (r1.1)
---
Log message:
Added media bench to llvm-test
---
Diffs of the changes: (+6063 -0)
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/COPYRIGHT
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/COPYRIGHT:1.1
*** /dev/null Tue Jan 11 12:05:43 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/COPYRIGHT Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,16 ----
+ Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
+ Technische Universitaet Berlin
+
+ Any use of this software is permitted provided that this notice is not
+ removed and that neither the authors nor the Technische Universitaet Berlin
+ are deemed to have made any representations as to the suitability of this
+ software for any purpose nor are held responsible for any defects of
+ this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+
+ As a matter of courtesy, the authors request to be informed about uses
+ this software has found, about bugs in this software, and about any
+ improvements that may be of general interest.
+
+ Berlin, 28.11.1994
+ Jutta Degener
+ Carsten Bormann
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/Makefile
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/Makefile:1.1
*** /dev/null Tue Jan 11 12:05:44 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/Makefile Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,16 ----
+ LEVEL = ../../../../..
+ RUN_OPTIONS = -cpl $(SourceDir)/../data/clinton.pcm
+ PROG = toast
+ CPPFLAGS += -DNeedFunctionPrototypes=1 -DSASR
+
+ Source = add.c gsm_decode.c gsm_option.c rpe.c toast.c \
+ code.c gsm_destroy.c gsm_print.c short_term.c toast_lin.c\
+ debug.c gsm_encode.c long_term.c table.c toast_ulaw.c\
+ decode.c gsm_explode.c lpc.c toast_alaw.c \
+ gsm_create.c gsm_implode.c preprocess.c toast_audio.c
+
+
+ include $(LEVEL)/MultiSource/Makefile.multisrc
+
+
+
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/add.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/add.c:1.1
*** /dev/null Tue Jan 11 12:05:44 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/add.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,235 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/add.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ /*
+ * See private.h for the more commonly used macro versions.
+ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ #define saturate(x) \
+ ((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))
+
+ word gsm_add P2((a,b), word a, word b)
+ {
+ longword sum = (longword)a + (longword)b;
+ return saturate(sum);
+ }
+
+ word gsm_sub P2((a,b), word a, word b)
+ {
+ longword diff = (longword)a - (longword)b;
+ return saturate(diff);
+ }
+
+ word gsm_mult P2((a,b), word a, word b)
+ {
+ if (a == MIN_WORD && b == MIN_WORD) return MAX_WORD;
+ else return SASR( (longword)a * (longword)b, 15 );
+ }
+
+ word gsm_mult_r P2((a,b), word a, word b)
+ {
+ if (b == MIN_WORD && a == MIN_WORD) return MAX_WORD;
+ else {
+ longword prod = (longword)a * (longword)b + 16384;
+ prod >>= 15;
+ return prod & 0xFFFF;
+ }
+ }
+
+ word gsm_abs P1((a), word a)
+ {
+ return a < 0 ? (a == MIN_WORD ? MAX_WORD : -a) : a;
+ }
+
+ longword gsm_L_mult P2((a,b),word a, word b)
+ {
+ assert( a != MIN_WORD || b != MIN_WORD );
+ return ((longword)a * (longword)b) << 1;
+ }
+
+ longword gsm_L_add P2((a,b), longword a, longword b)
+ {
+ if (a < 0) {
+ if (b >= 0) return a + b;
+ else {
+ ulongword A = (ulongword)-(a + 1) + (ulongword)-(b + 1);
+ return A >= MAX_LONGWORD ? MIN_LONGWORD :-(longword)A-2;
+ }
+ }
+ else if (b <= 0) return a + b;
+ else {
+ ulongword A = (ulongword)a + (ulongword)b;
+ return A > MAX_LONGWORD ? MAX_LONGWORD : A;
+ }
+ }
+
+ longword gsm_L_sub P2((a,b), longword a, longword b)
+ {
+ if (a >= 0) {
+ if (b >= 0) return a - b;
+ else {
+ /* a>=0, b<0 */
+
+ ulongword A = (ulongword)a + -(b + 1);
+ return A >= MAX_LONGWORD ? MAX_LONGWORD : (A + 1);
+ }
+ }
+ else if (b <= 0) return a - b;
+ else {
+ /* a<0, b>0 */
+
+ ulongword A = (ulongword)-(a + 1) + b;
+ return A >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)A - 1;
+ }
+ }
+
+ static unsigned char bitoff[ 256 ] = {
+ 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ };
+
+ word gsm_norm P1((a), longword a )
+ /*
+ * the number of left shifts needed to normalize the 32 bit
+ * variable L_var1 for positive values on the interval
+ *
+ * with minimum of
+ * minimum of 1073741824 (01000000000000000000000000000000) and
+ * maximum of 2147483647 (01111111111111111111111111111111)
+ *
+ *
+ * and for negative values on the interval with
+ * minimum of -2147483648 (-10000000000000000000000000000000) and
+ * maximum of -1073741824 ( -1000000000000000000000000000000).
+ *
+ * in order to normalize the result, the following
+ * operation must be done: L_norm_var1 = L_var1 << norm( L_var1 );
+ *
+ * (That's 'ffs', only from the left, not the right..)
+ */
+ {
+ assert(a != 0);
+
+ if (a < 0) {
+ if (a <= -1073741824) return 0;
+ a = ~a;
+ }
+
+ return a & 0xffff0000
+ ? ( a & 0xff000000
+ ? -1 + bitoff[ 0xFF & (a >> 24) ]
+ : 7 + bitoff[ 0xFF & (a >> 16) ] )
+ : ( a & 0xff00
+ ? 15 + bitoff[ 0xFF & (a >> 8) ]
+ : 23 + bitoff[ 0xFF & a ] );
+ }
+
+ longword gsm_L_asl P2((a,n), longword a, int n)
+ {
+ if (n >= 32) return 0;
+ if (n <= -32) return -(a < 0);
+ if (n < 0) return gsm_L_asr(a, -n);
+ return a << n;
+ }
+
+ word gsm_asl P2((a,n), word a, int n)
+ {
+ if (n >= 16) return 0;
+ if (n <= -16) return -(a < 0);
+ if (n < 0) return gsm_asr(a, -n);
+ return a << n;
+ }
+
+ longword gsm_L_asr P2((a,n), longword a, int n)
+ {
+ if (n >= 32) return -(a < 0);
+ if (n <= -32) return 0;
+ if (n < 0) return a << -n;
+
+ # ifdef SASR
+ return a >> n;
+ # else
+ if (a >= 0) return a >> n;
+ else return -(longword)( -(ulongword)a >> n );
+ # endif
+ }
+
+ word gsm_asr P2((a,n), word a, int n)
+ {
+ if (n >= 16) return -(a < 0);
+ if (n <= -16) return 0;
+ if (n < 0) return a << -n;
+
+ # ifdef SASR
+ return a >> n;
+ # else
+ if (a >= 0) return a >> n;
+ else return -(word)( -(uword)a >> n );
+ # endif
+ }
+
+ /*
+ * (From p. 46, end of section 4.2.5)
+ *
+ * NOTE: The following lines gives [sic] one correct implementation
+ * of the div(num, denum) arithmetic operation. Compute div
+ * which is the integer division of num by denum: with denum
+ * >= num > 0
+ */
+
+ word gsm_div P2((num,denum), word num, word denum)
+ {
+ longword L_num = num;
+ longword L_denum = denum;
+ word div = 0;
+ int k = 15;
+
+ /* The parameter num sometimes becomes zero.
+ * Although this is explicitly guarded against in 4.2.5,
+ * we assume that the result should then be zero as well.
+ */
+
+ /* assert(num != 0); */
+
+ assert(num >= 0 && denum >= num);
+ if (num == 0)
+ return 0;
+
+ while (k--) {
+ div <<= 1;
+ L_num <<= 1;
+
+ if (L_num >= L_denum) {
+ L_num -= L_denum;
+ div++;
+ }
+ }
+
+ return div;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/code.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/code.c:1.1
*** /dev/null Tue Jan 11 12:05:44 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/code.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,99 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/code.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "config.h"
+
+
+ #ifdef HAS_STDLIB_H
+ #include <stdlib.h>
+ #else
+ # include "proto.h"
+ extern char * memcpy P((char *, char *, int));
+ #endif
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ /*
+ * 4.2 FIXED POINT IMPLEMENTATION OF THE RPE-LTP CODER
+ */
+
+ void Gsm_Coder P8((S,s,LARc,Nc,bc,Mc,xmaxc,xMc),
+
+ struct gsm_state * S,
+
+ word * s, /* [0..159] samples IN */
+
+ /*
+ * The RPE-LTD coder works on a frame by frame basis. The length of
+ * the frame is equal to 160 samples. Some computations are done
+ * once per frame to produce at the output of the coder the
+ * LARc[1..8] parameters which are the coded LAR coefficients and
+ * also to realize the inverse filtering operation for the entire
+ * frame (160 samples of signal d[0..159]). These parts produce at
+ * the output of the coder:
+ */
+
+ word * LARc, /* [0..7] LAR coefficients OUT */
+
+ /*
+ * Procedure 4.2.11 to 4.2.18 are to be executed four times per
+ * frame. That means once for each sub-segment RPE-LTP analysis of
+ * 40 samples. These parts produce at the output of the coder:
+ */
+
+ word * Nc, /* [0..3] LTP lag OUT */
+ word * bc, /* [0..3] coded LTP gain OUT */
+ word * Mc, /* [0..3] RPE grid selection OUT */
+ word * xmaxc,/* [0..3] Coded maximum amplitude OUT */
+ word * xMc /* [13*4] normalized RPE samples OUT */
+ )
+ {
+ int k;
+ word * dp = S->dp0 + 120; /* [ -120...-1 ] */
+ word * dpp = dp; /* [ 0...39 ] */
+
+ static word e [50] = {0};
+
+ word so[160];
+
+ Gsm_Preprocess (S, s, so);
+ Gsm_LPC_Analysis (S, so, LARc);
+ Gsm_Short_Term_Analysis_Filter (S, LARc, so);
+
+ for (k = 0; k <= 3; k++, xMc += 13) {
+
+ Gsm_Long_Term_Predictor ( S,
+ so+k*40, /* d [0..39] IN */
+ dp, /* dp [-120..-1] IN */
+ e + 5, /* e [0..39] OUT */
+ dpp, /* dpp [0..39] OUT */
+ Nc++,
+ bc++);
+
+ Gsm_RPE_Encoding ( S,
+ e + 5, /* e ][0..39][ IN/OUT */
+ xmaxc++, Mc++, xMc );
+ /*
+ * Gsm_Update_of_reconstructed_short_time_residual_signal
+ * ( dpp, e + 5, dp );
+ */
+
+ { register int i;
+ register longword ltmp;
+ for (i = 0; i <= 39; i++)
+ dp[ i ] = GSM_ADD( e[5 + i], dpp[i] );
+ }
+ dp += 40;
+ dpp += 40;
+
+ }
+ (void)memcpy( (char *)S->dp0, (char *)(S->dp0 + 160),
+ 120 * sizeof(*S->dp0) );
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/config.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/config.h:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/config.h Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,34 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/config.h,v 1.1 2005/01/11 18:05:00 dhurjati Exp $*/
+
+ #ifndef CONFIG_H
+ #define CONFIG_H
+
+ /*efine SIGHANDLER_T int /* signal handlers are void */
+ /*efine HAS_SYSV_SIGNAL 1 /* sigs not blocked/reset? */
+
+ #define HAS_STDLIB_H 1 /* /usr/include/stdlib.h */
+ /*efine HAS_LIMITS_H 1 /* /usr/include/limits.h */
+ #define HAS_FCNTL_H 1 /* /usr/include/fcntl.h */
+ /*efine HAS_ERRNO_DECL 1 /* errno.h declares errno */
+
+ #define HAS_FSTAT 1 /* fstat syscall */
+ #define HAS_FCHMOD 1 /* fchmod syscall */
+ #define HAS_FCHOWN 1 /* fchown syscall */
+
+ #define HAS_STRING_H 1 /* /usr/include/string.h */
+ /*efine HAS_STRINGS_H 1 /* /usr/include/strings.h */
+
+ #define HAS_UNISTD_H 1 /* /usr/include/unistd.h */
+ #define HAS_UTIME 1 /* POSIX utime(path, times) */
+ /*efine HAS_UTIMES 1 /* use utimes() syscall instead */
+ #define HAS_UTIME_H 1 /* UTIME header file */
+ /*efine HAS_UTIMBUF 1 /* struct utimbuf */
+ /*efine HAS_UTIMEUSEC 1 /* microseconds in utimbuf? */
+
+ #endif /* CONFIG_H */
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/debug.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/debug.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/debug.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,76 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/debug.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "private.h"
+
+ #ifndef NDEBUG
+
+ /* If NDEBUG _is_ defined and no debugging should be performed,
+ * calls to functions in this module are #defined to nothing
+ * in private.h.
+ */
+
+ #include <stdio.h>
+ #include "proto.h"
+
+ void gsm_debug_words P4( (name, from, to, ptr),
+ char * name,
+ int from,
+ int to,
+ word * ptr)
+ {
+ int nprinted = 0;
+
+ fprintf( stderr, "%s [%d .. %d]: ", name, from, to );
+ while (from <= to) {
+ fprintf(stderr, "%d ", ptr[ from ] );
+ from++;
+ if (nprinted++ >= 7) {
+ nprinted = 0;
+ if (from < to) putc('\n', stderr);
+ }
+ }
+ putc('\n', stderr);
+ }
+
+ void gsm_debug_longwords P4( (name, from, to, ptr),
+ char * name,
+ int from,
+ int to,
+ longword * ptr)
+ {
+ int nprinted = 0;
+
+ fprintf( stderr, "%s [%d .. %d]: ", name, from, to );
+ while (from <= to) {
+
+ fprintf(stderr, "%d ", ptr[ from ] );
+ from++;
+ if (nprinted++ >= 7) {
+ nprinted = 0;
+ if (from < to) putc('\n', stderr);
+ }
+ }
+ putc('\n', stderr);
+ }
+
+ void gsm_debug_longword P2( (name, value),
+ char * name,
+ longword value )
+ {
+ fprintf(stderr, "%s: %d\n", name, (long)value );
+ }
+
+ void gsm_debug_word P2( (name, value),
+ char * name,
+ word value )
+ {
+ fprintf(stderr, "%s: %d\n", name, (long)value);
+ }
+
+ #endif
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/decode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/decode.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/decode.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,63 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/decode.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include <stdio.h>
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ /*
+ * 4.3 FIXED POINT IMPLEMENTATION OF THE RPE-LTP DECODER
+ */
+
+ static void Postprocessing P2((S,s),
+ struct gsm_state * S,
+ register word * s)
+ {
+ register int k;
+ register word msr = S->msr;
+ register longword ltmp; /* for GSM_ADD */
+ register word tmp;
+
+ for (k = 160; k--; s++) {
+ tmp = GSM_MULT_R( msr, 28180 );
+ msr = GSM_ADD(*s, tmp); /* Deemphasis */
+ *s = GSM_ADD(msr, msr) & 0xFFF8; /* Truncation & Upscaling */
+ }
+ S->msr = msr;
+ }
+
+ void Gsm_Decoder P8((S,LARcr, Ncr,bcr,Mcr,xmaxcr,xMcr,s),
+ struct gsm_state * S,
+
+ word * LARcr, /* [0..7] IN */
+
+ word * Ncr, /* [0..3] IN */
+ word * bcr, /* [0..3] IN */
+ word * Mcr, /* [0..3] IN */
+ word * xmaxcr, /* [0..3] IN */
+ word * xMcr, /* [0..13*4] IN */
+
+ word * s) /* [0..159] OUT */
+ {
+ int j, k;
+ word erp[40], wt[160];
+ word * drp = S->dp0 + 120;
+
+ for (j=0; j <= 3; j++, xmaxcr++, bcr++, Ncr++, Mcr++, xMcr += 13) {
+
+ Gsm_RPE_Decoding( S, *xmaxcr, *Mcr, xMcr, erp );
+ Gsm_Long_Term_Synthesis_Filtering( S, *Ncr, *bcr, erp, drp );
+
+ for (k = 0; k <= 39; k++) wt[ j * 40 + k ] = drp[ k ];
+ }
+
+ Gsm_Short_Term_Synthesis_Filter( S, LARcr, wt, s );
+ Postprocessing(S, s);
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm.h:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm.h Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,68 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm.h,v 1.1 2005/01/11 18:05:00 dhurjati Exp $*/
+
+ #ifndef GSM_H
+ #define GSM_H
+
+ #ifdef __cplusplus
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #if __STDC__
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #ifdef _NO_PROTO
+ # undef NeedFunctionPrototypes
+ #endif
+
+ #undef GSM_P /* gnu stdio.h actually defines this... */
+
+ #if NeedFunctionPrototypes
+ # define GSM_P( protos ) protos
+ #else
+ # define GSM_P( protos ) ( /* protos */ )
+ #endif
+
+ #ifdef NeedFunctionPrototypes
+ # include <stdio.h> /* for FILE * */
+ #endif
+
+ /*
+ * Interface
+ */
+
+ typedef struct gsm_state * gsm;
+ typedef short gsm_signal; /* signed 16 bit */
+ typedef unsigned char gsm_byte;
+ typedef gsm_byte gsm_frame[33]; /* 33 * 8 bits */
+
+ #define GSM_MAGIC 0xD /* 13 kbit/s RPE-LTP */
+
+ #define GSM_PATCHLEVEL 6
+ #define GSM_MINOR 0
+ #define GSM_MAJOR 1
+
+ #define GSM_OPT_VERBOSE 1
+ #define GSM_OPT_FAST 2
+
+ extern gsm gsm_create GSM_P((void));
+ extern void gsm_destroy GSM_P((gsm));
+
+ extern int gsm_print GSM_P((FILE *, gsm, gsm_byte *));
+ extern int gsm_option GSM_P((gsm, int, int *));
+
+ extern void gsm_encode GSM_P((gsm, gsm_signal *, gsm_byte *));
+ extern int gsm_decode GSM_P((gsm, gsm_byte *, gsm_signal *));
+
+ extern int gsm_explode GSM_P((gsm, gsm_byte *, gsm_signal *));
+ extern void gsm_implode GSM_P((gsm, gsm_signal *, gsm_byte *));
+
+ #undef GSM_P
+
+ #endif /* GSM_H */
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_create.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_create.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_create.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,55 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ static char ident[] = "$Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_create.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $";
+
+ #include "config.h"
+
+ #ifdef HAS_STRING_H
+ #include <string.h>
+ #else
+ # include "proto.h"
+ extern char * memset P((char *, int, int));
+ #endif
+
+ #ifdef HAS_STDLIB_H
+ # include <stdlib.h>
+ #else
+ # ifdef HAS_MALLOC_H
+ # include <malloc.h>
+ # else
+ extern char * malloc();
+ # endif
+ #endif
+
+ #include <stdio.h>
+
+ #include "gsm.h"
+ #include "private.h"
+ #include "proto.h"
+
+ gsm gsm_create P0()
+ {
+ gsm r;
+
+ #ifdef USE_TABLE_MUL
+
+ static int mul_init = 0;
+ if (!mul_init) {
+ mul_init = 1;
+ init_umul_table();
+ }
+
+ #endif
+
+ r = (gsm)malloc(sizeof(struct gsm_state));
+ if (!r) return r;
+
+ memset((char *)r, 0, sizeof(*r));
+ r->nrp = 40;
+
+ return r;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_decode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_decode.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_decode.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,125 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_decode.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_decode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
+ {
+ word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
+
+ /* GSM_MAGIC = (*c >> 4) & 0xF; */
+
+ if (((*c >> 4) & 0x0F) != GSM_MAGIC) return -1;
+
+ LARc[0] = (*c++ & 0xF) << 2; /* 1 */
+ LARc[0] |= (*c >> 6) & 0x3;
+ LARc[1] = *c++ & 0x3F;
+ LARc[2] = (*c >> 3) & 0x1F;
+ LARc[3] = (*c++ & 0x7) << 2;
+ LARc[3] |= (*c >> 6) & 0x3;
+ LARc[4] = (*c >> 2) & 0xF;
+ LARc[5] = (*c++ & 0x3) << 2;
+ LARc[5] |= (*c >> 6) & 0x3;
+ LARc[6] = (*c >> 3) & 0x7;
+ LARc[7] = *c++ & 0x7;
+ Nc[0] = (*c >> 1) & 0x7F;
+ bc[0] = (*c++ & 0x1) << 1;
+ bc[0] |= (*c >> 7) & 0x1;
+ Mc[0] = (*c >> 5) & 0x3;
+ xmaxc[0] = (*c++ & 0x1F) << 1;
+ xmaxc[0] |= (*c >> 7) & 0x1;
+ xmc[0] = (*c >> 4) & 0x7;
+ xmc[1] = (*c >> 1) & 0x7;
+ xmc[2] = (*c++ & 0x1) << 2;
+ xmc[2] |= (*c >> 6) & 0x3;
+ xmc[3] = (*c >> 3) & 0x7;
+ xmc[4] = *c++ & 0x7;
+ xmc[5] = (*c >> 5) & 0x7;
+ xmc[6] = (*c >> 2) & 0x7;
+ xmc[7] = (*c++ & 0x3) << 1; /* 10 */
+ xmc[7] |= (*c >> 7) & 0x1;
+ xmc[8] = (*c >> 4) & 0x7;
+ xmc[9] = (*c >> 1) & 0x7;
+ xmc[10] = (*c++ & 0x1) << 2;
+ xmc[10] |= (*c >> 6) & 0x3;
+ xmc[11] = (*c >> 3) & 0x7;
+ xmc[12] = *c++ & 0x7;
+ Nc[1] = (*c >> 1) & 0x7F;
+ bc[1] = (*c++ & 0x1) << 1;
+ bc[1] |= (*c >> 7) & 0x1;
+ Mc[1] = (*c >> 5) & 0x3;
+ xmaxc[1] = (*c++ & 0x1F) << 1;
+ xmaxc[1] |= (*c >> 7) & 0x1;
+ xmc[13] = (*c >> 4) & 0x7;
+ xmc[14] = (*c >> 1) & 0x7;
+ xmc[15] = (*c++ & 0x1) << 2;
+ xmc[15] |= (*c >> 6) & 0x3;
+ xmc[16] = (*c >> 3) & 0x7;
+ xmc[17] = *c++ & 0x7;
+ xmc[18] = (*c >> 5) & 0x7;
+ xmc[19] = (*c >> 2) & 0x7;
+ xmc[20] = (*c++ & 0x3) << 1;
+ xmc[20] |= (*c >> 7) & 0x1;
+ xmc[21] = (*c >> 4) & 0x7;
+ xmc[22] = (*c >> 1) & 0x7;
+ xmc[23] = (*c++ & 0x1) << 2;
+ xmc[23] |= (*c >> 6) & 0x3;
+ xmc[24] = (*c >> 3) & 0x7;
+ xmc[25] = *c++ & 0x7;
+ Nc[2] = (*c >> 1) & 0x7F;
+ bc[2] = (*c++ & 0x1) << 1; /* 20 */
+ bc[2] |= (*c >> 7) & 0x1;
+ Mc[2] = (*c >> 5) & 0x3;
+ xmaxc[2] = (*c++ & 0x1F) << 1;
+ xmaxc[2] |= (*c >> 7) & 0x1;
+ xmc[26] = (*c >> 4) & 0x7;
+ xmc[27] = (*c >> 1) & 0x7;
+ xmc[28] = (*c++ & 0x1) << 2;
+ xmc[28] |= (*c >> 6) & 0x3;
+ xmc[29] = (*c >> 3) & 0x7;
+ xmc[30] = *c++ & 0x7;
+ xmc[31] = (*c >> 5) & 0x7;
+ xmc[32] = (*c >> 2) & 0x7;
+ xmc[33] = (*c++ & 0x3) << 1;
+ xmc[33] |= (*c >> 7) & 0x1;
+ xmc[34] = (*c >> 4) & 0x7;
+ xmc[35] = (*c >> 1) & 0x7;
+ xmc[36] = (*c++ & 0x1) << 2;
+ xmc[36] |= (*c >> 6) & 0x3;
+ xmc[37] = (*c >> 3) & 0x7;
+ xmc[38] = *c++ & 0x7;
+ Nc[3] = (*c >> 1) & 0x7F;
+ bc[3] = (*c++ & 0x1) << 1;
+ bc[3] |= (*c >> 7) & 0x1;
+ Mc[3] = (*c >> 5) & 0x3;
+ xmaxc[3] = (*c++ & 0x1F) << 1;
+ xmaxc[3] |= (*c >> 7) & 0x1;
+ xmc[39] = (*c >> 4) & 0x7;
+ xmc[40] = (*c >> 1) & 0x7;
+ xmc[41] = (*c++ & 0x1) << 2;
+ xmc[41] |= (*c >> 6) & 0x3;
+ xmc[42] = (*c >> 3) & 0x7;
+ xmc[43] = *c++ & 0x7; /* 30 */
+ xmc[44] = (*c >> 5) & 0x7;
+ xmc[45] = (*c >> 2) & 0x7;
+ xmc[46] = (*c++ & 0x3) << 1;
+ xmc[46] |= (*c >> 7) & 0x1;
+ xmc[47] = (*c >> 4) & 0x7;
+ xmc[48] = (*c >> 1) & 0x7;
+ xmc[49] = (*c++ & 0x1) << 2;
+ xmc[49] |= (*c >> 6) & 0x3;
+ xmc[50] = (*c >> 3) & 0x7;
+ xmc[51] = *c & 0x7; /* 33 */
+
+ Gsm_Decoder(s, LARc, Nc, bc, Mc, xmaxc, xmc, target);
+
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_destroy.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_destroy.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_destroy.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,26 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_destroy.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "gsm.h"
+ #include "config.h"
+ #include "proto.h"
+
+ #ifdef HAS_STDLIB_H
+ # include <stdlib.h>
+ #else
+ # ifdef HAS_MALLOC_H
+ # include <malloc.h>
+ # else
+ extern void free();
+ # endif
+ #endif
+
+ void gsm_destroy P1((S), gsm S)
+ {
+ if (S) free((char *)S);
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_encode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_encode.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_encode.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,207 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_encode.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ void gsm_encode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)
+ {
+ word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
+
+ Gsm_Coder(s, source, LARc, Nc, bc, Mc, xmaxc, xmc);
+
+
+ /* variable size
+
+ GSM_MAGIC 4
+
+ LARc[0] 6
+ LARc[1] 6
+ LARc[2] 5
+ LARc[3] 5
+ LARc[4] 4
+ LARc[5] 4
+ LARc[6] 3
+ LARc[7] 3
+
+ Nc[0] 7
+ bc[0] 2
+ Mc[0] 2
+ xmaxc[0] 6
+ xmc[0] 3
+ xmc[1] 3
+ xmc[2] 3
+ xmc[3] 3
+ xmc[4] 3
+ xmc[5] 3
+ xmc[6] 3
+ xmc[7] 3
+ xmc[8] 3
+ xmc[9] 3
+ xmc[10] 3
+ xmc[11] 3
+ xmc[12] 3
+
+ Nc[1] 7
+ bc[1] 2
+ Mc[1] 2
+ xmaxc[1] 6
+ xmc[13] 3
+ xmc[14] 3
+ xmc[15] 3
+ xmc[16] 3
+ xmc[17] 3
+ xmc[18] 3
+ xmc[19] 3
+ xmc[20] 3
+ xmc[21] 3
+ xmc[22] 3
+ xmc[23] 3
+ xmc[24] 3
+ xmc[25] 3
+
+ Nc[2] 7
+ bc[2] 2
+ Mc[2] 2
+ xmaxc[2] 6
+ xmc[26] 3
+ xmc[27] 3
+ xmc[28] 3
+ xmc[29] 3
+ xmc[30] 3
+ xmc[31] 3
+ xmc[32] 3
+ xmc[33] 3
+ xmc[34] 3
+ xmc[35] 3
+ xmc[36] 3
+ xmc[37] 3
+ xmc[38] 3
+
+ Nc[3] 7
+ bc[3] 2
+ Mc[3] 2
+ xmaxc[3] 6
+ xmc[39] 3
+ xmc[40] 3
+ xmc[41] 3
+ xmc[42] 3
+ xmc[43] 3
+ xmc[44] 3
+ xmc[45] 3
+ xmc[46] 3
+ xmc[47] 3
+ xmc[48] 3
+ xmc[49] 3
+ xmc[50] 3
+ xmc[51] 3
+ */
+
+
+ *c++ = ((GSM_MAGIC & 0xF) << 4) /* 1 */
+ | ((LARc[0] >> 2) & 0xF);
+ *c++ = ((LARc[0] & 0x3) << 6)
+ | (LARc[1] & 0x3F);
+ *c++ = ((LARc[2] & 0x1F) << 3)
+ | ((LARc[3] >> 2) & 0x7);
+ *c++ = ((LARc[3] & 0x3) << 6)
+ | ((LARc[4] & 0xF) << 2)
+ | ((LARc[5] >> 2) & 0x3);
+ *c++ = ((LARc[5] & 0x3) << 6)
+ | ((LARc[6] & 0x7) << 3)
+ | (LARc[7] & 0x7);
+ *c++ = ((Nc[0] & 0x7F) << 1)
+ | ((bc[0] >> 1) & 0x1);
+ *c++ = ((bc[0] & 0x1) << 7)
+ | ((Mc[0] & 0x3) << 5)
+ | ((xmaxc[0] >> 1) & 0x1F);
+ *c++ = ((xmaxc[0] & 0x1) << 7)
+ | ((xmc[0] & 0x7) << 4)
+ | ((xmc[1] & 0x7) << 1)
+ | ((xmc[2] >> 2) & 0x1);
+ *c++ = ((xmc[2] & 0x3) << 6)
+ | ((xmc[3] & 0x7) << 3)
+ | (xmc[4] & 0x7);
+ *c++ = ((xmc[5] & 0x7) << 5) /* 10 */
+ | ((xmc[6] & 0x7) << 2)
+ | ((xmc[7] >> 1) & 0x3);
+ *c++ = ((xmc[7] & 0x1) << 7)
+ | ((xmc[8] & 0x7) << 4)
+ | ((xmc[9] & 0x7) << 1)
+ | ((xmc[10] >> 2) & 0x1);
+ *c++ = ((xmc[10] & 0x3) << 6)
+ | ((xmc[11] & 0x7) << 3)
+ | (xmc[12] & 0x7);
+ *c++ = ((Nc[1] & 0x7F) << 1)
+ | ((bc[1] >> 1) & 0x1);
+ *c++ = ((bc[1] & 0x1) << 7)
+ | ((Mc[1] & 0x3) << 5)
+ | ((xmaxc[1] >> 1) & 0x1F);
+ *c++ = ((xmaxc[1] & 0x1) << 7)
+ | ((xmc[13] & 0x7) << 4)
+ | ((xmc[14] & 0x7) << 1)
+ | ((xmc[15] >> 2) & 0x1);
+ *c++ = ((xmc[15] & 0x3) << 6)
+ | ((xmc[16] & 0x7) << 3)
+ | (xmc[17] & 0x7);
+ *c++ = ((xmc[18] & 0x7) << 5)
+ | ((xmc[19] & 0x7) << 2)
+ | ((xmc[20] >> 1) & 0x3);
+ *c++ = ((xmc[20] & 0x1) << 7)
+ | ((xmc[21] & 0x7) << 4)
+ | ((xmc[22] & 0x7) << 1)
+ | ((xmc[23] >> 2) & 0x1);
+ *c++ = ((xmc[23] & 0x3) << 6)
+ | ((xmc[24] & 0x7) << 3)
+ | (xmc[25] & 0x7);
+ *c++ = ((Nc[2] & 0x7F) << 1) /* 20 */
+ | ((bc[2] >> 1) & 0x1);
+ *c++ = ((bc[2] & 0x1) << 7)
+ | ((Mc[2] & 0x3) << 5)
+ | ((xmaxc[2] >> 1) & 0x1F);
+ *c++ = ((xmaxc[2] & 0x1) << 7)
+ | ((xmc[26] & 0x7) << 4)
+ | ((xmc[27] & 0x7) << 1)
+ | ((xmc[28] >> 2) & 0x1);
+ *c++ = ((xmc[28] & 0x3) << 6)
+ | ((xmc[29] & 0x7) << 3)
+ | (xmc[30] & 0x7);
+ *c++ = ((xmc[31] & 0x7) << 5)
+ | ((xmc[32] & 0x7) << 2)
+ | ((xmc[33] >> 1) & 0x3);
+ *c++ = ((xmc[33] & 0x1) << 7)
+ | ((xmc[34] & 0x7) << 4)
+ | ((xmc[35] & 0x7) << 1)
+ | ((xmc[36] >> 2) & 0x1);
+ *c++ = ((xmc[36] & 0x3) << 6)
+ | ((xmc[37] & 0x7) << 3)
+ | (xmc[38] & 0x7);
+ *c++ = ((Nc[3] & 0x7F) << 1)
+ | ((bc[3] >> 1) & 0x1);
+ *c++ = ((bc[3] & 0x1) << 7)
+ | ((Mc[3] & 0x3) << 5)
+ | ((xmaxc[3] >> 1) & 0x1F);
+ *c++ = ((xmaxc[3] & 0x1) << 7)
+ | ((xmc[39] & 0x7) << 4)
+ | ((xmc[40] & 0x7) << 1)
+ | ((xmc[41] >> 2) & 0x1);
+ *c++ = ((xmc[41] & 0x3) << 6) /* 30 */
+ | ((xmc[42] & 0x7) << 3)
+ | (xmc[43] & 0x7);
+ *c++ = ((xmc[44] & 0x7) << 5)
+ | ((xmc[45] & 0x7) << 2)
+ | ((xmc[46] >> 1) & 0x3);
+ *c++ = ((xmc[46] & 0x1) << 7)
+ | ((xmc[47] & 0x7) << 4)
+ | ((xmc[48] & 0x7) << 1)
+ | ((xmc[49] >> 2) & 0x1);
+ *c++ = ((xmc[49] & 0x3) << 6)
+ | ((xmc[50] & 0x7) << 3)
+ | (xmc[51] & 0x7);
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_explode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_explode.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_explode.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,197 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_explode.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_explode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
+ {
+ /* GSM_MAGIC = (*c >> 4) & 0xF; */
+
+ if (((*c >> 4) & 0x0F) != GSM_MAGIC) return -1;
+
+ #define LARc target
+
+ LARc[0] = (*c++ & 0xF) << 2; /* 1 */
+ LARc[0] |= (*c >> 6) & 0x3;
+ LARc[1] = *c++ & 0x3F;
+ LARc[2] = (*c >> 3) & 0x1F;
+ LARc[3] = (*c++ & 0x7) << 2;
+ LARc[3] |= (*c >> 6) & 0x3;
+ LARc[4] = (*c >> 2) & 0xF;
+ LARc[5] = (*c++ & 0x3) << 2;
+ LARc[5] |= (*c >> 6) & 0x3;
+ LARc[6] = (*c >> 3) & 0x7;
+ LARc[7] = *c++ & 0x7;
+
+ #define Nc (target + 8)
+
+ Nc[0] = (*c >> 1) & 0x7F;
+
+ #define bc (target + 9)
+
+ bc[0] = (*c++ & 0x1) << 1;
+ bc[0] |= (*c >> 7) & 0x1;
+
+ #define Mc (target + 10)
+
+ Mc[0] = (*c >> 5) & 0x3;
+
+ #define xmaxc (target + 11)
+
+ xmaxc[0] = (*c++ & 0x1F) << 1;
+ xmaxc[0] |= (*c >> 7) & 0x1;
+
+ #define xmc (target + 12)
+
+ xmc[0] = (*c >> 4) & 0x7;
+ xmc[1] = (*c >> 1) & 0x7;
+ xmc[2] = (*c++ & 0x1) << 2;
+ xmc[2] |= (*c >> 6) & 0x3;
+ xmc[3] = (*c >> 3) & 0x7;
+ xmc[4] = *c++ & 0x7;
+ xmc[5] = (*c >> 5) & 0x7;
+ xmc[6] = (*c >> 2) & 0x7;
+ xmc[7] = (*c++ & 0x3) << 1; /* 10 */
+ xmc[7] |= (*c >> 7) & 0x1;
+ xmc[8] = (*c >> 4) & 0x7;
+ xmc[9] = (*c >> 1) & 0x7;
+ xmc[10] = (*c++ & 0x1) << 2;
+ xmc[10] |= (*c >> 6) & 0x3;
+ xmc[11] = (*c >> 3) & 0x7;
+ xmc[12] = *c++ & 0x7;
+
+ #undef Nc
+ #define Nc (target + 25 - 1)
+
+ Nc[1] = (*c >> 1) & 0x7F;
+
+ #undef bc
+ #define bc (target + 26 - 1)
+
+ bc[1] = (*c++ & 0x1) << 1;
+ bc[1] |= (*c >> 7) & 0x1;
+
+ #undef Mc
+ #define Mc (target + 27 - 1)
+
+ Mc[1] = (*c >> 5) & 0x3;
+
+ #undef xmaxc
+ #define xmaxc (target + 28 - 1)
+
+ xmaxc[1] = (*c++ & 0x1F) << 1;
+ xmaxc[1] |= (*c >> 7) & 0x1;
+
+ #undef xmc
+ #define xmc (target + 29 - 13)
+
+ xmc[13] = (*c >> 4) & 0x7;
+ xmc[14] = (*c >> 1) & 0x7;
+ xmc[15] = (*c++ & 0x1) << 2;
+ xmc[15] |= (*c >> 6) & 0x3;
+ xmc[16] = (*c >> 3) & 0x7;
+ xmc[17] = *c++ & 0x7;
+ xmc[18] = (*c >> 5) & 0x7;
+ xmc[19] = (*c >> 2) & 0x7;
+ xmc[20] = (*c++ & 0x3) << 1;
+ xmc[20] |= (*c >> 7) & 0x1;
+ xmc[21] = (*c >> 4) & 0x7;
+ xmc[22] = (*c >> 1) & 0x7;
+ xmc[23] = (*c++ & 0x1) << 2;
+ xmc[23] |= (*c >> 6) & 0x3;
+ xmc[24] = (*c >> 3) & 0x7;
+ xmc[25] = *c++ & 0x7;
+
+ #undef Nc
+ #define Nc (target + 42 - 2)
+
+ Nc[2] = (*c >> 1) & 0x7F;
+
+ #undef bc
+ #define bc (target + 43 - 2)
+
+ bc[2] = (*c++ & 0x1) << 1; /* 20 */
+ bc[2] |= (*c >> 7) & 0x1;
+
+ #undef Mc
+ #define Mc (target + 44 - 2)
+
+ Mc[2] = (*c >> 5) & 0x3;
+
+ #undef xmaxc
+ #define xmaxc (target + 45 - 2)
+
+ xmaxc[2] = (*c++ & 0x1F) << 1;
+ xmaxc[2] |= (*c >> 7) & 0x1;
+
+ #undef xmc
+ #define xmc (target + 46 - 26)
+
+ xmc[26] = (*c >> 4) & 0x7;
+ xmc[27] = (*c >> 1) & 0x7;
+ xmc[28] = (*c++ & 0x1) << 2;
+ xmc[28] |= (*c >> 6) & 0x3;
+ xmc[29] = (*c >> 3) & 0x7;
+ xmc[30] = *c++ & 0x7;
+ xmc[31] = (*c >> 5) & 0x7;
+ xmc[32] = (*c >> 2) & 0x7;
+ xmc[33] = (*c++ & 0x3) << 1;
+ xmc[33] |= (*c >> 7) & 0x1;
+ xmc[34] = (*c >> 4) & 0x7;
+ xmc[35] = (*c >> 1) & 0x7;
+ xmc[36] = (*c++ & 0x1) << 2;
+ xmc[36] |= (*c >> 6) & 0x3;
+ xmc[37] = (*c >> 3) & 0x7;
+ xmc[38] = *c++ & 0x7;
+
+ #undef Nc
+ #define Nc (target + 59 - 3)
+
+ Nc[3] = (*c >> 1) & 0x7F;
+
+ #undef bc
+ #define bc (target + 60 - 3)
+
+ bc[3] = (*c++ & 0x1) << 1;
+ bc[3] |= (*c >> 7) & 0x1;
+
+ #undef Mc
+ #define Mc (target + 61 - 3)
+
+ Mc[3] = (*c >> 5) & 0x3;
+
+ #undef xmaxc
+ #define xmaxc (target + 62 - 3)
+
+ xmaxc[3] = (*c++ & 0x1F) << 1;
+ xmaxc[3] |= (*c >> 7) & 0x1;
+
+ #undef xmc
+ #define xmc (target + 63 - 39)
+
+ xmc[39] = (*c >> 4) & 0x7;
+ xmc[40] = (*c >> 1) & 0x7;
+ xmc[41] = (*c++ & 0x1) << 2;
+ xmc[41] |= (*c >> 6) & 0x3;
+ xmc[42] = (*c >> 3) & 0x7;
+ xmc[43] = *c++ & 0x7; /* 30 */
+ xmc[44] = (*c >> 5) & 0x7;
+ xmc[45] = (*c >> 2) & 0x7;
+ xmc[46] = (*c++ & 0x3) << 1;
+ xmc[46] |= (*c >> 7) & 0x1;
+ xmc[47] = (*c >> 4) & 0x7;
+ xmc[48] = (*c >> 1) & 0x7;
+ xmc[49] = (*c++ & 0x1) << 2;
+ xmc[49] |= (*c >> 6) & 0x3;
+ xmc[50] = (*c >> 3) & 0x7;
+ xmc[51] = *c & 0x7; /* 33 */
+
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_implode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_implode.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_implode.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,280 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_implode.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ void gsm_implode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)
+ {
+ /* variable size index
+
+ GSM_MAGIC 4 -
+
+ LARc[0] 6 0
+ LARc[1] 6 1
+ LARc[2] 5 2
+ LARc[3] 5 3
+ LARc[4] 4 4
+ LARc[5] 4 5
+ LARc[6] 3 6
+ LARc[7] 3 7
+
+ Nc[0] 7 8
+ bc[0] 2 9
+ Mc[0] 2 10
+ xmaxc[0] 6 11
+ xmc[0] 3 12
+ xmc[1] 3 13
+ xmc[2] 3 14
+ xmc[3] 3 15
+ xmc[4] 3 16
+ xmc[5] 3 17
+ xmc[6] 3 18
+ xmc[7] 3 19
+ xmc[8] 3 20
+ xmc[9] 3 21
+ xmc[10] 3 22
+ xmc[11] 3 23
+ xmc[12] 3 24
+
+ Nc[1] 7 25
+ bc[1] 2 26
+ Mc[1] 2 27
+ xmaxc[1] 6 28
+ xmc[13] 3 29
+ xmc[14] 3 30
+ xmc[15] 3 31
+ xmc[16] 3 32
+ xmc[17] 3 33
+ xmc[18] 3 34
+ xmc[19] 3 35
+ xmc[20] 3 36
+ xmc[21] 3 37
+ xmc[22] 3 38
+ xmc[23] 3 39
+ xmc[24] 3 40
+ xmc[25] 3 41
+
+ Nc[2] 7 42
+ bc[2] 2 43
+ Mc[2] 2 44
+ xmaxc[2] 6 45
+ xmc[26] 3 46
+ xmc[27] 3 47
+ xmc[28] 3 48
+ xmc[29] 3 49
+ xmc[30] 3 50
+ xmc[31] 3 51
+ xmc[32] 3 52
+ xmc[33] 3 53
+ xmc[34] 3 54
+ xmc[35] 3 55
+ xmc[36] 3 56
+ xmc[37] 3 57
+ xmc[38] 3 58
+
+ Nc[3] 7 59
+ bc[3] 2 60
+ Mc[3] 2 61
+ xmaxc[3] 6 62
+ xmc[39] 3 63
+ xmc[40] 3 64
+ xmc[41] 3 65
+ xmc[42] 3 66
+ xmc[43] 3 67
+ xmc[44] 3 68
+ xmc[45] 3 69
+ xmc[46] 3 70
+ xmc[47] 3 71
+ xmc[48] 3 72
+ xmc[49] 3 73
+ xmc[50] 3 74
+ xmc[51] 3 75
+ */
+
+
+ #define LARc source
+
+ *c++ = ((GSM_MAGIC & 0xF) << 4) /* 1 */
+ | ((LARc[0] >> 2) & 0xF);
+ *c++ = ((LARc[0] & 0x3) << 6)
+ | (LARc[1] & 0x3F);
+ *c++ = ((LARc[2] & 0x1F) << 3)
+ | ((LARc[3] >> 2) & 0x7);
+ *c++ = ((LARc[3] & 0x3) << 6)
+ | ((LARc[4] & 0xF) << 2)
+ | ((LARc[5] >> 2) & 0x3);
+ *c++ = ((LARc[5] & 0x3) << 6)
+ | ((LARc[6] & 0x7) << 3)
+ | (LARc[7] & 0x7);
+
+ #define Nc (source + 8)
+
+ *c++ = ((Nc[0] & 0x7F) << 1)
+
+ #define bc (source + 9)
+
+ | ((bc[0] >> 1) & 0x1);
+ *c++ = ((bc[0] & 0x1) << 7)
+
+ #define Mc (source + 10)
+
+ | ((Mc[0] & 0x3) << 5)
+
+ #define xmaxc (source + 11)
+
+ | ((xmaxc[0] >> 1) & 0x1F);
+ *c++ = ((xmaxc[0] & 0x1) << 7)
+
+ #define xmc (source + 12)
+
+ | ((xmc[0] & 0x7) << 4)
+ | ((xmc[1] & 0x7) << 1)
+ | ((xmc[2] >> 2) & 0x1);
+ *c++ = ((xmc[2] & 0x3) << 6)
+ | ((xmc[3] & 0x7) << 3)
+ | (xmc[4] & 0x7);
+ *c++ = ((xmc[5] & 0x7) << 5) /* 10 */
+ | ((xmc[6] & 0x7) << 2)
+ | ((xmc[7] >> 1) & 0x3);
+ *c++ = ((xmc[7] & 0x1) << 7)
+ | ((xmc[8] & 0x7) << 4)
+ | ((xmc[9] & 0x7) << 1)
+ | ((xmc[10] >> 2) & 0x1);
+ *c++ = ((xmc[10] & 0x3) << 6)
+ | ((xmc[11] & 0x7) << 3)
+ | (xmc[12] & 0x7);
+
+ #undef Nc
+ #define Nc (source + 25 - 1)
+
+ *c++ = ((Nc[1] & 0x7F) << 1)
+
+ #undef bc
+ #define bc (source + 26 - 1)
+
+ | ((bc[1] >> 1) & 0x1);
+ *c++ = ((bc[1] & 0x1) << 7)
+
+ #undef Mc
+ #define Mc (source + 27 - 1)
+
+ | ((Mc[1] & 0x3) << 5)
+
+ #undef xmaxc
+ #define xmaxc (source + 28 - 1)
+
+ | ((xmaxc[1] >> 1) & 0x1F);
+ *c++ = ((xmaxc[1] & 0x1) << 7)
+
+ #undef xmc
+ #define xmc (source + 29 - 13)
+
+ | ((xmc[13] & 0x7) << 4)
+ | ((xmc[14] & 0x7) << 1)
+ | ((xmc[15] >> 2) & 0x1);
+ *c++ = ((xmc[15] & 0x3) << 6)
+ | ((xmc[16] & 0x7) << 3)
+ | (xmc[17] & 0x7);
+ *c++ = ((xmc[18] & 0x7) << 5)
+ | ((xmc[19] & 0x7) << 2)
+ | ((xmc[20] >> 1) & 0x3);
+ *c++ = ((xmc[20] & 0x1) << 7)
+ | ((xmc[21] & 0x7) << 4)
+ | ((xmc[22] & 0x7) << 1)
+ | ((xmc[23] >> 2) & 0x1);
+ *c++ = ((xmc[23] & 0x3) << 6)
+ | ((xmc[24] & 0x7) << 3)
+ | (xmc[25] & 0x7);
+
+ #undef Nc
+ #define Nc (source + 42 - 2)
+
+ *c++ = ((Nc[2] & 0x7F) << 1) /* 20 */
+
+ #undef bc
+ #define bc (source + 43 - 2)
+
+ | ((bc[2] >> 1) & 0x1);
+ *c++ = ((bc[2] & 0x1) << 7)
+
+ #undef Mc
+ #define Mc (source + 44 - 2)
+
+ | ((Mc[2] & 0x3) << 5)
+
+ #undef xmaxc
+ #define xmaxc (source + 45 - 2)
+
+ | ((xmaxc[2] >> 1) & 0x1F);
+ *c++ = ((xmaxc[2] & 0x1) << 7)
+
+ #undef xmc
+ #define xmc (source + 46 - 26)
+
+ | ((xmc[26] & 0x7) << 4)
+ | ((xmc[27] & 0x7) << 1)
+ | ((xmc[28] >> 2) & 0x1);
+ *c++ = ((xmc[28] & 0x3) << 6)
+ | ((xmc[29] & 0x7) << 3)
+ | (xmc[30] & 0x7);
+ *c++ = ((xmc[31] & 0x7) << 5)
+ | ((xmc[32] & 0x7) << 2)
+ | ((xmc[33] >> 1) & 0x3);
+ *c++ = ((xmc[33] & 0x1) << 7)
+ | ((xmc[34] & 0x7) << 4)
+ | ((xmc[35] & 0x7) << 1)
+ | ((xmc[36] >> 2) & 0x1);
+ *c++ = ((xmc[36] & 0x3) << 6)
+ | ((xmc[37] & 0x7) << 3)
+ | (xmc[38] & 0x7);
+
+ #undef Nc
+ #define Nc (source + 59 - 3)
+
+ *c++ = ((Nc[3] & 0x7F) << 1)
+
+ #undef bc
+ #define bc (source + 60 - 3)
+
+ | ((bc[3] >> 1) & 0x1);
+ *c++ = ((bc[3] & 0x1) << 7)
+
+ #undef Mc
+ #define Mc (source + 61 - 3)
+
+ | ((Mc[3] & 0x3) << 5)
+
+ #undef xmaxc
+ #define xmaxc (source + 62 - 3)
+
+ | ((xmaxc[3] >> 1) & 0x1F);
+ *c++ = ((xmaxc[3] & 0x1) << 7)
+
+ #undef xmc
+ #define xmc (source + 63 - 39)
+
+ | ((xmc[39] & 0x7) << 4)
+ | ((xmc[40] & 0x7) << 1)
+ | ((xmc[41] >> 2) & 0x1);
+ *c++ = ((xmc[41] & 0x3) << 6) /* 30 */
+ | ((xmc[42] & 0x7) << 3)
+ | (xmc[43] & 0x7);
+ *c++ = ((xmc[44] & 0x7) << 5)
+ | ((xmc[45] & 0x7) << 2)
+ | ((xmc[46] >> 1) & 0x3);
+ *c++ = ((xmc[46] & 0x1) << 7)
+ | ((xmc[47] & 0x7) << 4)
+ | ((xmc[48] & 0x7) << 1)
+ | ((xmc[49] >> 2) & 0x1);
+ *c++ = ((xmc[49] & 0x3) << 6)
+ | ((xmc[50] & 0x7) << 3)
+ | (xmc[51] & 0x7);
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_option.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_option.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_option.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,38 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_option.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_option P3((r, opt, val), gsm r, int opt, int * val)
+ {
+ int result = -1;
+
+ switch (opt) {
+ case GSM_OPT_VERBOSE:
+ #ifndef NDEBUG
+ result = r->verbose;
+ if (val) r->verbose = *val;
+ #endif
+ break;
+
+ case GSM_OPT_FAST:
+
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+ result = r->fast;
+ if (val) r->fast = !!*val;
+ #endif
+ break;
+
+ default:
+ break;
+ }
+ return result;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_print.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_print.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_print.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,167 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/gsm_print.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include <stdio.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_print P3((f, s, c), FILE * f, gsm s, gsm_byte * c)
+ {
+ word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
+
+ /* GSM_MAGIC = (*c >> 4) & 0xF; */
+
+ if (((*c >> 4) & 0x0F) != GSM_MAGIC) return -1;
+
+ LARc[0] = (*c++ & 0xF) << 2; /* 1 */
+ LARc[0] |= (*c >> 6) & 0x3;
+ LARc[1] = *c++ & 0x3F;
+ LARc[2] = (*c >> 3) & 0x1F;
+ LARc[3] = (*c++ & 0x7) << 2;
+ LARc[3] |= (*c >> 6) & 0x3;
+ LARc[4] = (*c >> 2) & 0xF;
+ LARc[5] = (*c++ & 0x3) << 2;
+ LARc[5] |= (*c >> 6) & 0x3;
+ LARc[6] = (*c >> 3) & 0x7;
+ LARc[7] = *c++ & 0x7;
+
+
+ Nc[0] = (*c >> 1) & 0x7F;
+ bc[0] = (*c++ & 0x1) << 1;
+ bc[0] |= (*c >> 7) & 0x1;
+ Mc[0] = (*c >> 5) & 0x3;
+ xmaxc[0] = (*c++ & 0x1F) << 1;
+ xmaxc[0] |= (*c >> 7) & 0x1;
+ xmc[0] = (*c >> 4) & 0x7;
+ xmc[1] = (*c >> 1) & 0x7;
+ xmc[2] = (*c++ & 0x1) << 2;
+ xmc[2] |= (*c >> 6) & 0x3;
+ xmc[3] = (*c >> 3) & 0x7;
+ xmc[4] = *c++ & 0x7;
+ xmc[5] = (*c >> 5) & 0x7;
+ xmc[6] = (*c >> 2) & 0x7;
+ xmc[7] = (*c++ & 0x3) << 1; /* 10 */
+ xmc[7] |= (*c >> 7) & 0x1;
+ xmc[8] = (*c >> 4) & 0x7;
+ xmc[9] = (*c >> 1) & 0x7;
+ xmc[10] = (*c++ & 0x1) << 2;
+ xmc[10] |= (*c >> 6) & 0x3;
+ xmc[11] = (*c >> 3) & 0x7;
+ xmc[12] = *c++ & 0x7;
+
+ Nc[1] = (*c >> 1) & 0x7F;
+ bc[1] = (*c++ & 0x1) << 1;
+ bc[1] |= (*c >> 7) & 0x1;
+ Mc[1] = (*c >> 5) & 0x3;
+ xmaxc[1] = (*c++ & 0x1F) << 1;
+ xmaxc[1] |= (*c >> 7) & 0x1;
+ xmc[13] = (*c >> 4) & 0x7;
+ xmc[14] = (*c >> 1) & 0x7;
+ xmc[15] = (*c++ & 0x1) << 2;
+ xmc[15] |= (*c >> 6) & 0x3;
+ xmc[16] = (*c >> 3) & 0x7;
+ xmc[17] = *c++ & 0x7;
+ xmc[18] = (*c >> 5) & 0x7;
+ xmc[19] = (*c >> 2) & 0x7;
+ xmc[20] = (*c++ & 0x3) << 1;
+ xmc[20] |= (*c >> 7) & 0x1;
+ xmc[21] = (*c >> 4) & 0x7;
+ xmc[22] = (*c >> 1) & 0x7;
+ xmc[23] = (*c++ & 0x1) << 2;
+ xmc[23] |= (*c >> 6) & 0x3;
+ xmc[24] = (*c >> 3) & 0x7;
+ xmc[25] = *c++ & 0x7;
+
+
+ Nc[2] = (*c >> 1) & 0x7F;
+ bc[2] = (*c++ & 0x1) << 1; /* 20 */
+ bc[2] |= (*c >> 7) & 0x1;
+ Mc[2] = (*c >> 5) & 0x3;
+ xmaxc[2] = (*c++ & 0x1F) << 1;
+ xmaxc[2] |= (*c >> 7) & 0x1;
+ xmc[26] = (*c >> 4) & 0x7;
+ xmc[27] = (*c >> 1) & 0x7;
+ xmc[28] = (*c++ & 0x1) << 2;
+ xmc[28] |= (*c >> 6) & 0x3;
+ xmc[29] = (*c >> 3) & 0x7;
+ xmc[30] = *c++ & 0x7;
+ xmc[31] = (*c >> 5) & 0x7;
+ xmc[32] = (*c >> 2) & 0x7;
+ xmc[33] = (*c++ & 0x3) << 1;
+ xmc[33] |= (*c >> 7) & 0x1;
+ xmc[34] = (*c >> 4) & 0x7;
+ xmc[35] = (*c >> 1) & 0x7;
+ xmc[36] = (*c++ & 0x1) << 2;
+ xmc[36] |= (*c >> 6) & 0x3;
+ xmc[37] = (*c >> 3) & 0x7;
+ xmc[38] = *c++ & 0x7;
+
+ Nc[3] = (*c >> 1) & 0x7F;
+ bc[3] = (*c++ & 0x1) << 1;
+ bc[3] |= (*c >> 7) & 0x1;
+ Mc[3] = (*c >> 5) & 0x3;
+ xmaxc[3] = (*c++ & 0x1F) << 1;
+ xmaxc[3] |= (*c >> 7) & 0x1;
+
+ xmc[39] = (*c >> 4) & 0x7;
+ xmc[40] = (*c >> 1) & 0x7;
+ xmc[41] = (*c++ & 0x1) << 2;
+ xmc[41] |= (*c >> 6) & 0x3;
+ xmc[42] = (*c >> 3) & 0x7;
+ xmc[43] = *c++ & 0x7; /* 30 */
+ xmc[44] = (*c >> 5) & 0x7;
+ xmc[45] = (*c >> 2) & 0x7;
+ xmc[46] = (*c++ & 0x3) << 1;
+ xmc[46] |= (*c >> 7) & 0x1;
+ xmc[47] = (*c >> 4) & 0x7;
+ xmc[48] = (*c >> 1) & 0x7;
+ xmc[49] = (*c++ & 0x1) << 2;
+ xmc[49] |= (*c >> 6) & 0x3;
+ xmc[50] = (*c >> 3) & 0x7;
+ xmc[51] = *c & 0x7; /* 33 */
+
+ fprintf(f,
+ "LARc:\t%2.2d %2.2d %2.2d %2.2d %2.2d %2.2d %2.2d %2.2d\n",
+ LARc[0],LARc[1],LARc[2],LARc[3],LARc[4],LARc[5],LARc[6],LARc[7]);
+
+ fprintf(f, "#1: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[0], bc[0], Mc[0], xmaxc[0]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[0],xmc[1],xmc[2],xmc[3],xmc[4],xmc[5],xmc[6],
+ xmc[7],xmc[8],xmc[9],xmc[10],xmc[11],xmc[12] );
+
+ fprintf(f, "#2: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[1], bc[1], Mc[1], xmaxc[1]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[13+0],xmc[13+1],xmc[13+2],xmc[13+3],xmc[13+4],xmc[13+5],
+ xmc[13+6], xmc[13+7],xmc[13+8],xmc[13+9],xmc[13+10],xmc[13+11],
+ xmc[13+12] );
+
+ fprintf(f, "#3: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[2], bc[2], Mc[2], xmaxc[2]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[26+0],xmc[26+1],xmc[26+2],xmc[26+3],xmc[26+4],xmc[26+5],
+ xmc[26+6], xmc[26+7],xmc[26+8],xmc[26+9],xmc[26+10],xmc[26+11],
+ xmc[26+12] );
+
+ fprintf(f, "#4: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[3], bc[3], Mc[3], xmaxc[3]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[39+0],xmc[39+1],xmc[39+2],xmc[39+3],xmc[39+4],xmc[39+5],
+ xmc[39+6], xmc[39+7],xmc[39+8],xmc[39+9],xmc[39+10],xmc[39+11],
+ xmc[39+12] );
+
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/long_term.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/long_term.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/long_term.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,603 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/long_term.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+
+ #ifdef USE_TABLE_MUL
+
+ unsigned int umul_table[ 513 ][ 256 ];
+
+ init_umul_table()
+ {
+ int i, j;
+ int n;
+ unsigned int * p = &umul_table[0][0];
+
+ for (i = 0; i < 513; i++) {
+ n = 0;
+ for (j = 0; j < 256; j++) {
+ *p++ = n;
+ n += i;
+ }
+ }
+ }
+
+ # define umul(x9, x15) \
+ ((int)(umul_table[x9][x15 & 0x0FF] + (umul_table[x9][ x15 >> 8 ] << 8)))
+
+ # define table_mul(a, b) \
+ ( (a < 0) ? ((b < 0) ? umul(-a, -b) : -umul(-a, b)) \
+ : ((b < 0) ? -umul(a, -b) : umul(a, b)))
+
+ #endif /* USE_TABLE_MUL */
+
+
+
+ /*
+ * 4.2.11 .. 4.2.12 LONG TERM PREDICTOR (LTP) SECTION
+ */
+
+
+ /*
+ * This procedure computes the LTP gain (bc) and the LTP lag (Nc)
+ * for the long term analysis filter. This is done by calculating a
+ * maximum of the cross-correlation function between the current
+ * sub-segment short term residual signal d[0..39] (output of
+ * the short term analysis filter; for simplification the index
+ * of this array begins at 0 and ends at 39 for each sub-segment of the
+ * RPE-LTP analysis) and the previous reconstructed short term
+ * residual signal dp[ -120 .. -1 ]. A dynamic scaling must be
+ * performed to avoid overflow.
+ */
+
+ /* This procedure exists in four versions. First, the two integer
+ * versions with or without table-multiplication (as one function);
+ * then, the two floating point versions (as another function), with
+ * or without scaling.
+ */
+
+ #ifndef USE_FLOAT_MUL
+
+ static void Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
+ register word * d, /* [0..39] IN */
+ register word * dp, /* [-120..-1] IN */
+ word * bc_out, /* OUT */
+ word * Nc_out /* OUT */
+ )
+ {
+ register int k, lambda;
+ word Nc, bc;
+ word wt[40];
+
+ longword L_max, L_power;
+ word R, S, dmax, scal;
+ register word temp;
+
+ /* Search of the optimum scaling of d[0..39].
+ */
+ dmax = 0;
+
+ for (k = 0; k <= 39; k++) {
+ temp = d[k];
+ temp = GSM_ABS( temp );
+ if (temp > dmax) dmax = temp;
+ }
+
+ temp = 0;
+ if (dmax == 0) scal = 0;
+ else {
+ assert(dmax > 0);
+ temp = gsm_norm( (longword)dmax << 16 );
+ }
+
+ if (temp > 6) scal = 0;
+ else scal = 6 - temp;
+
+ assert(scal >= 0);
+
+ /* Initialization of a working array wt
+ */
+
+ for (k = 0; k <= 39; k++) wt[k] = SASR( d[k], scal );
+
+ /* Search for the maximum cross-correlation and coding of the LTP lag
+ */
+ L_max = 0;
+ Nc = 40; /* index for the maximum cross-correlation */
+
+ for (lambda = 40; lambda <= 120; lambda++) {
+
+ # undef STEP
+ # ifdef USE_TABLE_MUL
+ # define STEP(k) (table_mul(wt[k], dp[k - lambda]))
+ # else
+ # define STEP(k) (wt[k] * dp[k - lambda])
+ # endif
+
+ register longword L_result;
+
+ L_result = STEP(0) ; L_result += STEP(1) ;
+ L_result += STEP(2) ; L_result += STEP(3) ;
+ L_result += STEP(4) ; L_result += STEP(5) ;
+ L_result += STEP(6) ; L_result += STEP(7) ;
+ L_result += STEP(8) ; L_result += STEP(9) ;
+ L_result += STEP(10) ; L_result += STEP(11) ;
+ L_result += STEP(12) ; L_result += STEP(13) ;
+ L_result += STEP(14) ; L_result += STEP(15) ;
+ L_result += STEP(16) ; L_result += STEP(17) ;
+ L_result += STEP(18) ; L_result += STEP(19) ;
+ L_result += STEP(20) ; L_result += STEP(21) ;
+ L_result += STEP(22) ; L_result += STEP(23) ;
+ L_result += STEP(24) ; L_result += STEP(25) ;
+ L_result += STEP(26) ; L_result += STEP(27) ;
+ L_result += STEP(28) ; L_result += STEP(29) ;
+ L_result += STEP(30) ; L_result += STEP(31) ;
+ L_result += STEP(32) ; L_result += STEP(33) ;
+ L_result += STEP(34) ; L_result += STEP(35) ;
+ L_result += STEP(36) ; L_result += STEP(37) ;
+ L_result += STEP(38) ; L_result += STEP(39) ;
+
+ if (L_result > L_max) {
+
+ Nc = lambda;
+ L_max = L_result;
+ }
+ }
+
+ *Nc_out = Nc;
+
+ L_max <<= 1;
+
+ /* Rescaling of L_max
+ */
+ assert(scal <= 100 && scal >= -100);
+ L_max = L_max >> (6 - scal); /* sub(6, scal) */
+
+ assert( Nc <= 120 && Nc >= 40);
+
+ /* Compute the power of the reconstructed short term residual
+ * signal dp[..]
+ */
+ L_power = 0;
+ for (k = 0; k <= 39; k++) {
+
+ register longword L_temp;
+
+ L_temp = SASR( dp[k - Nc], 3 );
+ L_power += L_temp * L_temp;
+ }
+ L_power <<= 1; /* from L_MULT */
+
+ /* Normalization of L_max and L_power
+ */
+
+ if (L_max <= 0) {
+ *bc_out = 0;
+ return;
+ }
+ if (L_max >= L_power) {
+ *bc_out = 3;
+ return;
+ }
+
+ temp = gsm_norm( L_power );
+
+ R = SASR( L_max << temp, 16 );
+ S = SASR( L_power << temp, 16 );
+
+ /* Coding of the LTP gain
+ */
+
+ /* Table 4.3a must be used to obtain the level DLB[i] for the
+ * quantization of the LTP gain b to get the coded version bc.
+ */
+ for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;
+ *bc_out = bc;
+ }
+
+ #else /* USE_FLOAT_MUL */
+
+ static void Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
+ register word * d, /* [0..39] IN */
+ register word * dp, /* [-120..-1] IN */
+ word * bc_out, /* OUT */
+ word * Nc_out /* OUT */
+ )
+ {
+ register int k, lambda;
+ word Nc, bc;
+
+ float wt_float[40];
+ float dp_float_base[120], * dp_float = dp_float_base + 120;
+
+ longword L_max, L_power;
+ word R, S, dmax, scal;
+ register word temp;
+
+ /* Search of the optimum scaling of d[0..39].
+ */
+ dmax = 0;
+
+ for (k = 0; k <= 39; k++) {
+ temp = d[k];
+ temp = GSM_ABS( temp );
+ if (temp > dmax) dmax = temp;
+ }
+
+ temp = 0;
+ if (dmax == 0) scal = 0;
+ else {
+ assert(dmax > 0);
+ temp = gsm_norm( (longword)dmax << 16 );
+ }
+
+ if (temp > 6) scal = 0;
+ else scal = 6 - temp;
+
+ assert(scal >= 0);
+
+ /* Initialization of a working array wt
+ */
+
+ for (k = 0; k < 40; k++) wt_float[k] = SASR( d[k], scal );
+ for (k = -120; k < 0; k++) dp_float[k] = dp[k];
+
+ /* Search for the maximum cross-correlation and coding of the LTP lag
+ */
+ L_max = 0;
+ Nc = 40; /* index for the maximum cross-correlation */
+
+ for (lambda = 40; lambda <= 120; lambda += 9) {
+
+ /* Calculate L_result for l = lambda .. lambda + 9.
+ */
+ register float *lp = dp_float - lambda;
+
+ register float W;
+ register float a = lp[-8], b = lp[-7], c = lp[-6],
+ d = lp[-5], e = lp[-4], f = lp[-3],
+ g = lp[-2], h = lp[-1];
+ register float E;
+ register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,
+ S5 = 0, S6 = 0, S7 = 0, S8 = 0;
+
+ # undef STEP
+ # define STEP(K, a, b, c, d, e, f, g, h) \
+ W = wt_float[K]; \
+ E = W * a; S8 += E; \
+ E = W * b; S7 += E; \
+ E = W * c; S6 += E; \
+ E = W * d; S5 += E; \
+ E = W * e; S4 += E; \
+ E = W * f; S3 += E; \
+ E = W * g; S2 += E; \
+ E = W * h; S1 += E; \
+ a = lp[K]; \
+ E = W * a; S0 += E
+
+ # define STEP_A(K) STEP(K, a, b, c, d, e, f, g, h)
+ # define STEP_B(K) STEP(K, b, c, d, e, f, g, h, a)
+ # define STEP_C(K) STEP(K, c, d, e, f, g, h, a, b)
+ # define STEP_D(K) STEP(K, d, e, f, g, h, a, b, c)
+ # define STEP_E(K) STEP(K, e, f, g, h, a, b, c, d)
+ # define STEP_F(K) STEP(K, f, g, h, a, b, c, d, e)
+ # define STEP_G(K) STEP(K, g, h, a, b, c, d, e, f)
+ # define STEP_H(K) STEP(K, h, a, b, c, d, e, f, g)
+
+ STEP_A( 0); STEP_B( 1); STEP_C( 2); STEP_D( 3);
+ STEP_E( 4); STEP_F( 5); STEP_G( 6); STEP_H( 7);
+
+ STEP_A( 8); STEP_B( 9); STEP_C(10); STEP_D(11);
+ STEP_E(12); STEP_F(13); STEP_G(14); STEP_H(15);
+
+ STEP_A(16); STEP_B(17); STEP_C(18); STEP_D(19);
+ STEP_E(20); STEP_F(21); STEP_G(22); STEP_H(23);
+
+ STEP_A(24); STEP_B(25); STEP_C(26); STEP_D(27);
+ STEP_E(28); STEP_F(29); STEP_G(30); STEP_H(31);
+
+ STEP_A(32); STEP_B(33); STEP_C(34); STEP_D(35);
+ STEP_E(36); STEP_F(37); STEP_G(38); STEP_H(39);
+
+ if (S0 > L_max) { L_max = S0; Nc = lambda; }
+ if (S1 > L_max) { L_max = S1; Nc = lambda + 1; }
+ if (S2 > L_max) { L_max = S2; Nc = lambda + 2; }
+ if (S3 > L_max) { L_max = S3; Nc = lambda + 3; }
+ if (S4 > L_max) { L_max = S4; Nc = lambda + 4; }
+ if (S5 > L_max) { L_max = S5; Nc = lambda + 5; }
+ if (S6 > L_max) { L_max = S6; Nc = lambda + 6; }
+ if (S7 > L_max) { L_max = S7; Nc = lambda + 7; }
+ if (S8 > L_max) { L_max = S8; Nc = lambda + 8; }
+ }
+ *Nc_out = Nc;
+
+ L_max <<= 1;
+
+ /* Rescaling of L_max
+ */
+ assert(scal <= 100 && scal >= -100);
+ L_max = L_max >> (6 - scal); /* sub(6, scal) */
+
+ assert( Nc <= 120 && Nc >= 40);
+
+ /* Compute the power of the reconstructed short term residual
+ * signal dp[..]
+ */
+ L_power = 0;
+ for (k = 0; k <= 39; k++) {
+
+ register longword L_temp;
+
+ L_temp = SASR( dp[k - Nc], 3 );
+ L_power += L_temp * L_temp;
+ }
+ L_power <<= 1; /* from L_MULT */
+
+ /* Normalization of L_max and L_power
+ */
+
+ if (L_max <= 0) {
+ *bc_out = 0;
+ return;
+ }
+ if (L_max >= L_power) {
+ *bc_out = 3;
+ return;
+ }
+
+ temp = gsm_norm( L_power );
+
+ R = SASR( L_max << temp, 16 );
+ S = SASR( L_power << temp, 16 );
+
+ /* Coding of the LTP gain
+ */
+
+ /* Table 4.3a must be used to obtain the level DLB[i] for the
+ * quantization of the LTP gain b to get the coded version bc.
+ */
+ for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;
+ *bc_out = bc;
+ }
+
+ #ifdef FAST
+
+ static void Fast_Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
+ register word * d, /* [0..39] IN */
+ register word * dp, /* [-120..-1] IN */
+ word * bc_out, /* OUT */
+ word * Nc_out /* OUT */
+ )
+ {
+ register int k, lambda;
+ word Nc, bc;
+
+ float wt_float[40];
+ float dp_float_base[120], * dp_float = dp_float_base + 120;
+
+ register float L_max, L_power;
+
+ for (k = 0; k < 40; ++k) wt_float[k] = (float)d[k];
+ for (k = -120; k <= 0; ++k) dp_float[k] = (float)dp[k];
+
+ /* Search for the maximum cross-correlation and coding of the LTP lag
+ */
+ L_max = 0;
+ Nc = 40; /* index for the maximum cross-correlation */
+
+ for (lambda = 40; lambda <= 120; lambda += 9) {
+
+ /* Calculate L_result for l = lambda .. lambda + 9.
+ */
+ register float *lp = dp_float - lambda;
+
+ register float W;
+ register float a = lp[-8], b = lp[-7], c = lp[-6],
+ d = lp[-5], e = lp[-4], f = lp[-3],
+ g = lp[-2], h = lp[-1];
+ register float E;
+ register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,
+ S5 = 0, S6 = 0, S7 = 0, S8 = 0;
+
+ # undef STEP
+ # define STEP(K, a, b, c, d, e, f, g, h) \
+ W = wt_float[K]; \
+ E = W * a; S8 += E; \
+ E = W * b; S7 += E; \
+ E = W * c; S6 += E; \
+ E = W * d; S5 += E; \
+ E = W * e; S4 += E; \
+ E = W * f; S3 += E; \
+ E = W * g; S2 += E; \
+ E = W * h; S1 += E; \
+ a = lp[K]; \
+ E = W * a; S0 += E
+
+ # define STEP_A(K) STEP(K, a, b, c, d, e, f, g, h)
+ # define STEP_B(K) STEP(K, b, c, d, e, f, g, h, a)
+ # define STEP_C(K) STEP(K, c, d, e, f, g, h, a, b)
+ # define STEP_D(K) STEP(K, d, e, f, g, h, a, b, c)
+ # define STEP_E(K) STEP(K, e, f, g, h, a, b, c, d)
+ # define STEP_F(K) STEP(K, f, g, h, a, b, c, d, e)
+ # define STEP_G(K) STEP(K, g, h, a, b, c, d, e, f)
+ # define STEP_H(K) STEP(K, h, a, b, c, d, e, f, g)
+
+ STEP_A( 0); STEP_B( 1); STEP_C( 2); STEP_D( 3);
+ STEP_E( 4); STEP_F( 5); STEP_G( 6); STEP_H( 7);
+
+ STEP_A( 8); STEP_B( 9); STEP_C(10); STEP_D(11);
+ STEP_E(12); STEP_F(13); STEP_G(14); STEP_H(15);
+
+ STEP_A(16); STEP_B(17); STEP_C(18); STEP_D(19);
+ STEP_E(20); STEP_F(21); STEP_G(22); STEP_H(23);
+
+ STEP_A(24); STEP_B(25); STEP_C(26); STEP_D(27);
+ STEP_E(28); STEP_F(29); STEP_G(30); STEP_H(31);
+
+ STEP_A(32); STEP_B(33); STEP_C(34); STEP_D(35);
+ STEP_E(36); STEP_F(37); STEP_G(38); STEP_H(39);
+
+ if (S0 > L_max) { L_max = S0; Nc = lambda; }
+ if (S1 > L_max) { L_max = S1; Nc = lambda + 1; }
+ if (S2 > L_max) { L_max = S2; Nc = lambda + 2; }
+ if (S3 > L_max) { L_max = S3; Nc = lambda + 3; }
+ if (S4 > L_max) { L_max = S4; Nc = lambda + 4; }
+ if (S5 > L_max) { L_max = S5; Nc = lambda + 5; }
+ if (S6 > L_max) { L_max = S6; Nc = lambda + 6; }
+ if (S7 > L_max) { L_max = S7; Nc = lambda + 7; }
+ if (S8 > L_max) { L_max = S8; Nc = lambda + 8; }
+ }
+ *Nc_out = Nc;
+
+ if (L_max <= 0.) {
+ *bc_out = 0;
+ return;
+ }
+
+ /* Compute the power of the reconstructed short term residual
+ * signal dp[..]
+ */
+ dp_float -= Nc;
+ L_power = 0;
+ for (k = 0; k < 40; ++k) {
+ register float f = dp_float[k];
+ L_power += f * f;
+ }
+
+ if (L_max >= L_power) {
+ *bc_out = 3;
+ return;
+ }
+
+ /* Coding of the LTP gain
+ * Table 4.3a must be used to obtain the level DLB[i] for the
+ * quantization of the LTP gain b to get the coded version bc.
+ */
+ lambda = L_max / L_power * 32768.;
+ for (bc = 0; bc <= 2; ++bc) if (lambda <= gsm_DLB[bc]) break;
+ *bc_out = bc;
+ }
+
+ #endif /* FAST */
+ #endif /* USE_FLOAT_MUL */
+
+
+ /* 4.2.12 */
+
+ static void Long_term_analysis_filtering P6((bc,Nc,dp,d,dpp,e),
+ word bc, /* IN */
+ word Nc, /* IN */
+ register word * dp, /* previous d [-120..-1] IN */
+ register word * d, /* d [0..39] IN */
+ register word * dpp, /* estimate [0..39] OUT */
+ register word * e /* long term res. signal [0..39] OUT */
+ )
+ /*
+ * In this part, we have to decode the bc parameter to compute
+ * the samples of the estimate dpp[0..39]. The decoding of bc needs the
+ * use of table 4.3b. The long term residual signal e[0..39]
+ * is then calculated to be fed to the RPE encoding section.
+ */
+ {
+ register int k;
+ register longword ltmp;
+
+ # undef STEP
+ # define STEP(BP) \
+ for (k = 0; k <= 39; k++) { \
+ dpp[k] = GSM_MULT_R( BP, dp[k - Nc]); \
+ e[k] = GSM_SUB( d[k], dpp[k] ); \
+ }
+
+ switch (bc) {
+ case 0: STEP( 3277 ); break;
+ case 1: STEP( 11469 ); break;
+ case 2: STEP( 21299 ); break;
+ case 3: STEP( 32767 ); break;
+ }
+ }
+
+ void Gsm_Long_Term_Predictor P7((S,d,dp,e,dpp,Nc,bc), /* 4x for 160 samples */
+
+ struct gsm_state * S,
+
+ word * d, /* [0..39] residual signal IN */
+ word * dp, /* [-120..-1] d' IN */
+
+ word * e, /* [0..39] OUT */
+ word * dpp, /* [0..39] OUT */
+ word * Nc, /* correlation lag OUT */
+ word * bc /* gain factor OUT */
+ )
+ {
+ assert( d ); assert( dp ); assert( e );
+ assert( dpp); assert( Nc ); assert( bc );
+
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+ if (S->fast)
+ Fast_Calculation_of_the_LTP_parameters( d, dp, bc, Nc );
+ else
+ #endif
+ Calculation_of_the_LTP_parameters( d, dp, bc, Nc );
+
+ Long_term_analysis_filtering( *bc, *Nc, dp, d, dpp, e );
+ }
+
+ /* 4.3.2 */
+ void Gsm_Long_Term_Synthesis_Filtering P5((S,Ncr,bcr,erp,drp),
+ struct gsm_state * S,
+
+ word Ncr,
+ word bcr,
+ register word * erp, /* [0..39] IN */
+ register word * drp /* [-120..-1] IN, [0..40] OUT */
+ )
+ /*
+ * This procedure uses the bcr and Ncr parameter to realize the
+ * long term synthesis filtering. The decoding of bcr needs
+ * table 4.3b.
+ */
+ {
+ register longword ltmp; /* for ADD */
+ register int k;
+ word brp, drpp, Nr;
+
+ /* Check the limits of Nr.
+ */
+ Nr = Ncr < 40 || Ncr > 120 ? S->nrp : Ncr;
+ S->nrp = Nr;
+ assert(Nr >= 40 && Nr <= 120);
+
+ /* Decoding of the LTP gain bcr
+ */
+ brp = gsm_QLB[ bcr ];
+
+ /* Computation of the reconstructed short term residual
+ * signal drp[0..39]
+ */
+ assert(brp != MIN_WORD);
+
+ for (k = 0; k <= 39; k++) {
+ drpp = GSM_MULT_R( brp, drp[ k - Nr ] );
+ drp[k] = GSM_ADD( erp[k], drpp );
+ }
+
+ /*
+ * Update of the reconstructed short term residual signal
+ * drp[ -1..-120 ]
+ */
+
+ for (k = 0; k <= 119; k++) drp[ -120 + k ] = drp[ -80 + k ];
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/lpc.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/lpc.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/lpc.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,341 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/lpc.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ #undef P
+
+ /*
+ * 4.2.4 .. 4.2.7 LPC ANALYSIS SECTION
+ */
+
+ /* 4.2.4 */
+
+
+ static void Autocorrelation P2((s, L_ACF),
+ word * s, /* [0..159] IN/OUT */
+ longword * L_ACF) /* [0..8] OUT */
+ /*
+ * The goal is to compute the array L_ACF[k]. The signal s[i] must
+ * be scaled in order to avoid an overflow situation.
+ */
+ {
+ register int k, i;
+
+ word temp, smax, scalauto;
+
+ #ifdef USE_FLOAT_MUL
+ float float_s[160];
+ #endif
+
+ /* Dynamic scaling of the array s[0..159]
+ */
+
+ /* Search for the maximum.
+ */
+ smax = 0;
+ for (k = 0; k <= 159; k++) {
+ temp = GSM_ABS( s[k] );
+ if (temp > smax) smax = temp;
+ }
+
+ /* Computation of the scaling factor.
+ */
+ if (smax == 0) scalauto = 0;
+ else {
+ assert(smax > 0);
+ scalauto = 4 - gsm_norm( (longword)smax << 16 );/* sub(4,..) */
+ }
+
+ /* Scaling of the array s[0...159]
+ */
+
+ if (scalauto > 0) {
+
+ # ifdef USE_FLOAT_MUL
+ # define SCALE(n) \
+ case n: for (k = 0; k <= 159; k++) \
+ float_s[k] = (float) \
+ (s[k] = GSM_MULT_R(s[k], 16384 >> (n-1)));\
+ break;
+ # else
+ # define SCALE(n) \
+ case n: for (k = 0; k <= 159; k++) \
+ s[k] = GSM_MULT_R( s[k], 16384 >> (n-1) );\
+ break;
+ # endif /* USE_FLOAT_MUL */
+
+ switch (scalauto) {
+ SCALE(1)
+ SCALE(2)
+ SCALE(3)
+ SCALE(4)
+ }
+ # undef SCALE
+ }
+ # ifdef USE_FLOAT_MUL
+ else for (k = 0; k <= 159; k++) float_s[k] = (float) s[k];
+ # endif
+
+ /* Compute the L_ACF[..].
+ */
+ {
+ # ifdef USE_FLOAT_MUL
+ register float * sp = float_s;
+ register float sl = *sp;
+
+ # define STEP(k) L_ACF[k] += (longword)(sl * sp[ -(k) ]);
+ # else
+ word * sp = s;
+ word sl = *sp;
+
+ # define STEP(k) L_ACF[k] += ((longword)sl * sp[ -(k) ]);
+ # endif
+
+ # define NEXTI sl = *++sp
+
+
+ for (k = 9; k--; L_ACF[k] = 0) ;
+
+ STEP (0);
+ NEXTI;
+ STEP(0); STEP(1);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5); STEP(6);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5); STEP(6); STEP(7);
+
+ for (i = 8; i <= 159; i++) {
+
+ NEXTI;
+
+ STEP(0);
+ STEP(1); STEP(2); STEP(3); STEP(4);
+ STEP(5); STEP(6); STEP(7); STEP(8);
+ }
+
+ for (k = 9; k--; L_ACF[k] <<= 1) ;
+
+ }
+ /* Rescaling of the array s[0..159]
+ */
+ if (scalauto > 0) {
+ assert(scalauto <= 4);
+ for (k = 160; k--; *s++ <<= scalauto) ;
+ }
+ }
+
+ #if defined(USE_FLOAT_MUL) && defined(FAST)
+
+ static void Fast_Autocorrelation P2((s, L_ACF),
+ word * s, /* [0..159] IN/OUT */
+ longword * L_ACF) /* [0..8] OUT */
+ {
+ register int k, i;
+ float f_L_ACF[9];
+ float scale;
+
+ float s_f[160];
+ register float *sf = s_f;
+
+ for (i = 0; i < 160; ++i) sf[i] = s[i];
+ for (k = 0; k <= 8; k++) {
+ register float L_temp2 = 0;
+ register float *sfl = sf - k;
+ for (i = k; i < 160; ++i) L_temp2 += sf[i] * sfl[i];
+ f_L_ACF[k] = L_temp2;
+ }
+ scale = MAX_LONGWORD / f_L_ACF[0];
+
+ for (k = 0; k <= 8; k++) {
+ L_ACF[k] = f_L_ACF[k] * scale;
+ }
+ }
+ #endif /* defined (USE_FLOAT_MUL) && defined (FAST) */
+
+ /* 4.2.5 */
+
+ static void Reflection_coefficients P2( (L_ACF, r),
+ longword * L_ACF, /* 0...8 IN */
+ register word * r /* 0...7 OUT */
+ )
+ {
+ register int i, m, n;
+ register word temp;
+ register longword ltmp;
+ word ACF[9]; /* 0..8 */
+ word P[ 9]; /* 0..8 */
+ word K[ 9]; /* 2..8 */
+
+ /* Schur recursion with 16 bits arithmetic.
+ */
+
+ if (L_ACF[0] == 0) {
+ for (i = 8; i--; *r++ = 0) ;
+ return;
+ }
+
+ assert( L_ACF[0] != 0 );
+ temp = gsm_norm( L_ACF[0] );
+
+ assert(temp >= 0 && temp < 32);
+
+ /* ? overflow ? */
+ for (i = 0; i <= 8; i++) ACF[i] = SASR( L_ACF[i] << temp, 16 );
+
+ /* Initialize array P[..] and K[..] for the recursion.
+ */
+
+ for (i = 1; i <= 7; i++) K[ i ] = ACF[ i ];
+ for (i = 0; i <= 8; i++) P[ i ] = ACF[ i ];
+
+ /* Compute reflection coefficients
+ */
+ for (n = 1; n <= 8; n++, r++) {
+
+ temp = P[1];
+ temp = GSM_ABS(temp);
+ if (P[0] < temp) {
+ for (i = n; i <= 8; i++) *r++ = 0;
+ return;
+ }
+
+ *r = gsm_div( temp, P[0] );
+
+ assert(*r >= 0);
+ if (P[1] > 0) *r = -*r; /* r[n] = sub(0, r[n]) */
+ assert (*r != MIN_WORD);
+ if (n == 8) return;
+
+ /* Schur recursion
+ */
+ temp = GSM_MULT_R( P[1], *r );
+ P[0] = GSM_ADD( P[0], temp );
+
+ for (m = 1; m <= 8 - n; m++) {
+ temp = GSM_MULT_R( K[ m ], *r );
+ P[m] = GSM_ADD( P[ m+1 ], temp );
+
+ temp = GSM_MULT_R( P[ m+1 ], *r );
+ K[m] = GSM_ADD( K[ m ], temp );
+ }
+ }
+ }
+
+ /* 4.2.6 */
+
+ static void Transformation_to_Log_Area_Ratios P1((r),
+ register word * r /* 0..7 IN/OUT */
+ )
+ /*
+ * The following scaling for r[..] and LAR[..] has been used:
+ *
+ * r[..] = integer( real_r[..]*32768. ); -1 <= real_r < 1.
+ * LAR[..] = integer( real_LAR[..] * 16384 );
+ * with -1.625 <= real_LAR <= 1.625
+ */
+ {
+ register word temp;
+ register int i;
+
+
+ /* Computation of the LAR[0..7] from the r[0..7]
+ */
+ for (i = 1; i <= 8; i++, r++) {
+
+ temp = *r;
+ temp = GSM_ABS(temp);
+ assert(temp >= 0);
+
+ if (temp < 22118) {
+ temp >>= 1;
+ } else if (temp < 31130) {
+ assert( temp >= 11059 );
+ temp -= 11059;
+ } else {
+ assert( temp >= 26112 );
+ temp -= 26112;
+ temp <<= 2;
+ }
+
+ *r = *r < 0 ? -temp : temp;
+ assert( *r != MIN_WORD );
+ }
+ }
+
+ /* 4.2.7 */
+
+ static void Quantization_and_coding P1((LAR),
+ register word * LAR /* [0..7] IN/OUT */
+ )
+ {
+ register word temp;
+ longword ltmp;
+
+
+ /* This procedure needs four tables; the following equations
+ * give the optimum scaling for the constants:
+ *
+ * A[0..7] = integer( real_A[0..7] * 1024 )
+ * B[0..7] = integer( real_B[0..7] * 512 )
+ * MAC[0..7] = maximum of the LARc[0..7]
+ * MIC[0..7] = minimum of the LARc[0..7]
+ */
+
+ # undef STEP
+ # define STEP( A, B, MAC, MIC ) \
+ temp = GSM_MULT( A, *LAR ); \
+ temp = GSM_ADD( temp, B ); \
+ temp = GSM_ADD( temp, 256 ); \
+ temp = SASR( temp, 9 ); \
+ *LAR = temp>MAC ? MAC - MIC : (temp<MIC ? 0 : temp - MIC); \
+ LAR++;
+
+ STEP( 20480, 0, 31, -32 );
+ STEP( 20480, 0, 31, -32 );
+ STEP( 20480, 2048, 15, -16 );
+ STEP( 20480, -2560, 15, -16 );
+
+ STEP( 13964, 94, 7, -8 );
+ STEP( 15360, -1792, 7, -8 );
+ STEP( 8534, -341, 3, -4 );
+ STEP( 9036, -1144, 3, -4 );
+
+ # undef STEP
+ }
+
+ void Gsm_LPC_Analysis P3((S, s,LARc),
+ struct gsm_state *S,
+ word * s, /* 0..159 signals IN/OUT */
+ word * LARc) /* 0..7 LARc's OUT */
+ {
+ longword L_ACF[9];
+
+ #if defined(USE_FLOAT_MUL) && defined(FAST)
+ if (S->fast) Fast_Autocorrelation (s, L_ACF );
+ else
+ #endif
+ Autocorrelation (s, L_ACF );
+ Reflection_coefficients (L_ACF, LARc );
+ Transformation_to_Log_Area_Ratios (LARc);
+ Quantization_and_coding (LARc);
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/preprocess.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/preprocess.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/preprocess.c Tue Jan 11 12:05:00 2005
***************
*** 0 ****
--- 1,113 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/preprocess.c,v 1.1 2005/01/11 18:05:00 dhurjati Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ /* 4.2.0 .. 4.2.3 PREPROCESSING SECTION
+ *
+ * After A-law to linear conversion (or directly from the
+ * Ato D converter) the following scaling is assumed for
+ * input to the RPE-LTP algorithm:
+ *
+ * in: 0.1.....................12
+ * S.v.v.v.v.v.v.v.v.v.v.v.v.*.*.*
+ *
+ * Where S is the sign bit, v a valid bit, and * a "don't care" bit.
+ * The original signal is called sop[..]
+ *
+ * out: 0.1................... 12
+ * S.S.v.v.v.v.v.v.v.v.v.v.v.v.0.0
+ */
+
+
+ void Gsm_Preprocess P3((S, s, so),
+ struct gsm_state * S,
+ word * s,
+ word * so ) /* [0..159] IN/OUT */
+ {
+
+ word z1 = S->z1;
+ longword L_z2 = S->L_z2;
+ word mp = S->mp;
+
+ word s1;
+ longword L_s2;
+
+ longword L_temp;
+
+ word msp, lsp;
+ word SO;
+
+ longword ltmp; /* for ADD */
+ ulongword utmp; /* for L_ADD */
+
+ register int k = 160;
+
+ while (k--) {
+
+ /* 4.2.1 Downscaling of the input signal
+ */
+ SO = SASR( *s, 3 ) << 2;
+ s++;
+
+ assert (SO >= -0x4000); /* downscaled by */
+ assert (SO <= 0x3FFC); /* previous routine. */
+
+
+ /* 4.2.2 Offset compensation
+ *
+ * This part implements a high-pass filter and requires extended
+ * arithmetic precision for the recursive part of this filter.
+ * The input of this procedure is the array so[0...159] and the
+ * output the array sof[ 0...159 ].
+ */
+ /* Compute the non-recursive part
+ */
+
+ s1 = SO - z1; /* s1 = gsm_sub( *so, z1 ); */
+ z1 = SO;
+
+ assert(s1 != MIN_WORD);
+
+ /* Compute the recursive part
+ */
+ L_s2 = s1;
+ L_s2 <<= 15;
+
+ /* Execution of a 31 bv 16 bits multiplication
+ */
+
+ msp = SASR( L_z2, 15 );
+ lsp = L_z2-((longword)msp<<15); /* gsm_L_sub(L_z2,(msp<<15)); */
+
+ L_s2 += GSM_MULT_R( lsp, 32735 );
+ L_temp = (longword)msp * 32735; /* GSM_L_MULT(msp,32735) >> 1;*/
+ L_z2 = GSM_L_ADD( L_temp, L_s2 );
+
+ /* Compute sof[k] with rounding
+ */
+ L_temp = GSM_L_ADD( L_z2, 16384 );
+
+ /* 4.2.3 Preemphasis
+ */
+
+ msp = GSM_MULT_R( mp, -28180 );
+ mp = SASR( L_temp, 15 );
+ *so++ = GSM_ADD( mp, msp );
+ }
+
+ S->z1 = z1;
+ S->L_z2 = L_z2;
+ S->mp = mp;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/private.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/private.h:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/private.h Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,263 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/private.h,v 1.1 2005/01/11 18:05:01 dhurjati Exp $*/
+
+ #ifndef PRIVATE_H
+ #define PRIVATE_H
+
+ typedef short word; /* 16 bit signed int */
+ typedef long longword; /* 32 bit signed int */
+
+ typedef unsigned short uword; /* unsigned word */
+ typedef unsigned long ulongword; /* unsigned longword */
+
+ struct gsm_state {
+
+ word dp0[ 280 ];
+
+ word z1; /* preprocessing.c, Offset_com. */
+ longword L_z2; /* Offset_com. */
+ int mp; /* Preemphasis */
+
+ word u[8]; /* short_term_aly_filter.c */
+ word LARpp[2][8]; /* */
+ word j; /* */
+
+ word nrp; /* 40 */ /* long_term.c, synthesis */
+ word v[9]; /* short_term.c, synthesis */
+ word msr; /* decoder.c, Postprocessing */
+
+ char verbose; /* only used if !NDEBUG */
+ char fast; /* only used if FAST */
+
+ };
+
+
+ #define MIN_WORD ((-32767)-1)
+ #define MAX_WORD ( 32767)
+
+ #define MIN_LONGWORD ((-2147483647)-1)
+ #define MAX_LONGWORD ( 2147483647)
+
+ #ifdef SASR /* >> is a signed arithmetic shift right */
+ #undef SASR
+ #define SASR(x, by) ((x) >> (by))
+ #endif /* SASR */
+
+
+ #include "proto.h"
+
+ /*
+ * Prototypes from add.c
+ */
+ extern word gsm_mult P((word a, word b));
+ extern longword gsm_L_mult P((word a, word b));
+ extern word gsm_mult_r P((word a, word b));
+
+ extern word gsm_div P((word num, word denum));
+
+ extern word gsm_add P(( word a, word b ));
+ extern longword gsm_L_add P(( longword a, longword b ));
+
+ extern word gsm_sub P((word a, word b));
+ extern longword gsm_L_sub P((longword a, longword b));
+
+ extern word gsm_abs P((word a));
+
+ extern word gsm_norm P(( longword a ));
+
+ extern longword gsm_L_asl P((longword a, int n));
+ extern word gsm_asl P((word a, int n));
+
+ extern longword gsm_L_asr P((longword a, int n));
+ extern word gsm_asr P((word a, int n));
+
+ /*
+ * Inlined functions from add.h
+ */
+
+ /*
+ * #define GSM_MULT_R(a, b) (* word a, word b, !(a == b == MIN_WORD) *) \
+ * (0x0FFFF & SASR(((longword)(a) * (longword)(b) + 16384), 15))
+ */
+ #define GSM_MULT_R(a, b) /* word a, word b, !(a == b == MIN_WORD) */ \
+ (SASR( ((longword)(a) * (longword)(b) + 16384), 15 ))
+
+ # define GSM_MULT(a,b) /* word a, word b, !(a == b == MIN_WORD) */ \
+ (SASR( ((longword)(a) * (longword)(b)), 15 ))
+
+ # define GSM_L_MULT(a, b) /* word a, word b */ \
+ (((longword)(a) * (longword)(b)) << 1)
+
+ # define GSM_L_ADD(a, b) \
+ ( (a) < 0 ? ( (b) >= 0 ? (a) + (b) \
+ : (utmp = (ulongword)-((a) + 1) + (ulongword)-((b) + 1)) \
+ >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)utmp-2 ) \
+ : ((b) <= 0 ? (a) + (b) \
+ : (utmp = (ulongword)(a) + (ulongword)(b)) >= MAX_LONGWORD \
+ ? MAX_LONGWORD : utmp))
+
+ /*
+ * # define GSM_ADD(a, b) \
+ * ((ltmp = (longword)(a) + (longword)(b)) >= MAX_WORD \
+ * ? MAX_WORD : ltmp <= MIN_WORD ? MIN_WORD : ltmp)
+ */
+ /* Nonportable, but faster: */
+
+ #define GSM_ADD(a, b) \
+ ((ulongword)((ltmp = (longword)(a) + (longword)(b)) - MIN_WORD) > \
+ MAX_WORD - MIN_WORD ? (ltmp > 0 ? MAX_WORD : MIN_WORD) : ltmp)
+
+ # define GSM_SUB(a, b) \
+ ((ltmp = (longword)(a) - (longword)(b)) >= MAX_WORD \
+ ? MAX_WORD : ltmp <= MIN_WORD ? MIN_WORD : ltmp)
+
+ # define GSM_ABS(a) ((a) < 0 ? ((a) == MIN_WORD ? MAX_WORD : -(a)) : (a))
+
+ /* Use these if necessary:
+
+ # define GSM_MULT_R(a, b) gsm_mult_r(a, b)
+ # define GSM_MULT(a, b) gsm_mult(a, b)
+ # define GSM_L_MULT(a, b) gsm_L_mult(a, b)
+
+ # define GSM_L_ADD(a, b) gsm_L_add(a, b)
+ # define GSM_ADD(a, b) gsm_add(a, b)
+ # define GSM_SUB(a, b) gsm_sub(a, b)
+
+ # define GSM_ABS(a) gsm_abs(a)
+
+ */
+
+ /*
+ * More prototypes from implementations..
+ */
+ extern void Gsm_Coder P((
+ struct gsm_state * S,
+ word * s, /* [0..159] samples IN */
+ word * LARc, /* [0..7] LAR coefficients OUT */
+ word * Nc, /* [0..3] LTP lag OUT */
+ word * bc, /* [0..3] coded LTP gain OUT */
+ word * Mc, /* [0..3] RPE grid selection OUT */
+ word * xmaxc,/* [0..3] Coded maximum amplitude OUT */
+ word * xMc /* [13*4] normalized RPE samples OUT */));
+
+ extern void Gsm_Long_Term_Predictor P(( /* 4x for 160 samples */
+ struct gsm_state * S,
+ word * d, /* [0..39] residual signal IN */
+ word * dp, /* [-120..-1] d' IN */
+ word * e, /* [0..40] OUT */
+ word * dpp, /* [0..40] OUT */
+ word * Nc, /* correlation lag OUT */
+ word * bc /* gain factor OUT */));
+
+ extern void Gsm_LPC_Analysis P((
+ struct gsm_state * S,
+ word * s, /* 0..159 signals IN/OUT */
+ word * LARc)); /* 0..7 LARc's OUT */
+
+ extern void Gsm_Preprocess P((
+ struct gsm_state * S,
+ word * s, word * so));
+
+ extern void Gsm_Encoding P((
+ struct gsm_state * S,
+ word * e,
+ word * ep,
+ word * xmaxc,
+ word * Mc,
+ word * xMc));
+
+ extern void Gsm_Short_Term_Analysis_Filter P((
+ struct gsm_state * S,
+ word * LARc, /* coded log area ratio [0..7] IN */
+ word * d /* st res. signal [0..159] IN/OUT */));
+
+ extern void Gsm_Decoder P((
+ struct gsm_state * S,
+ word * LARcr, /* [0..7] IN */
+ word * Ncr, /* [0..3] IN */
+ word * bcr, /* [0..3] IN */
+ word * Mcr, /* [0..3] IN */
+ word * xmaxcr, /* [0..3] IN */
+ word * xMcr, /* [0..13*4] IN */
+ word * s)); /* [0..159] OUT */
+
+ extern void Gsm_Decoding P((
+ struct gsm_state * S,
+ word xmaxcr,
+ word Mcr,
+ word * xMcr, /* [0..12] IN */
+ word * erp)); /* [0..39] OUT */
+
+ extern void Gsm_Long_Term_Synthesis_Filtering P((
+ struct gsm_state* S,
+ word Ncr,
+ word bcr,
+ word * erp, /* [0..39] IN */
+ word * drp)); /* [-120..-1] IN, [0..40] OUT */
+
+ void Gsm_RPE_Decoding P((
+ struct gsm_state *S,
+ word xmaxcr,
+ word Mcr,
+ word * xMcr, /* [0..12], 3 bits IN */
+ word * erp)); /* [0..39] OUT */
+
+ void Gsm_RPE_Encoding P((
+ struct gsm_state * S,
+ word * e, /* -5..-1][0..39][40..44 IN/OUT */
+ word * xmaxc, /* OUT */
+ word * Mc, /* OUT */
+ word * xMc)); /* [0..12] OUT */
+
+ extern void Gsm_Short_Term_Synthesis_Filter P((
+ struct gsm_state * S,
+ word * LARcr, /* log area ratios [0..7] IN */
+ word * drp, /* received d [0...39] IN */
+ word * s)); /* signal s [0..159] OUT */
+
+ extern void Gsm_Update_of_reconstructed_short_time_residual_signal P((
+ word * dpp, /* [0...39] IN */
+ word * ep, /* [0...39] IN */
+ word * dp)); /* [-120...-1] IN/OUT */
+
+ /*
+ * Tables from table.c
+ */
+ #ifndef GSM_TABLE_C
+
+ extern word gsm_A[8], gsm_B[8], gsm_MIC[8], gsm_MAC[8];
+ extern word gsm_INVA[8];
+ extern word gsm_DLB[4], gsm_QLB[4];
+ extern word gsm_H[11];
+ extern word gsm_NRFAC[8];
+ extern word gsm_FAC[8];
+
+ #endif /* GSM_TABLE_C */
+
+ /*
+ * Debugging
+ */
+ #ifdef NDEBUG
+
+ # define gsm_debug_words(a, b, c, d) /* nil */
+ # define gsm_debug_longwords(a, b, c, d) /* nil */
+ # define gsm_debug_word(a, b) /* nil */
+ # define gsm_debug_longword(a, b) /* nil */
+
+ #else /* !NDEBUG => DEBUG */
+
+ extern void gsm_debug_words P((char * name, int, int, word *));
+ extern void gsm_debug_longwords P((char * name, int, int, longword *));
+ extern void gsm_debug_longword P((char * name, longword));
+ extern void gsm_debug_word P((char * name, word));
+
+ #endif /* !NDEBUG */
+
+ #include "unproto.h"
+
+ #endif /* PRIVATE_H */
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/proto.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/proto.h:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/proto.h Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,65 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/proto.h,v 1.1 2005/01/11 18:05:01 dhurjati Exp $*/
+
+ #ifndef PROTO_H
+ #define PROTO_H
+
+ #if __cplusplus
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #if __STDC__
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #ifdef _NO_PROTO
+ # undef NeedFunctionPrototypes
+ #endif
+
+ #undef P /* gnu stdio.h actually defines this... */
+ #undef P0
+ #undef P1
+ #undef P2
+ #undef P3
+ #undef P4
+ #undef P5
+ #undef P6
+ #undef P7
+ #undef P8
+
+ #if NeedFunctionPrototypes
+
+ # define P( protos ) protos
+
+ # define P0() (void)
+ # define P1(x, a) (a)
+ # define P2(x, a, b) (a, b)
+ # define P3(x, a, b, c) (a, b, c)
+ # define P4(x, a, b, c, d) (a, b, c, d)
+ # define P5(x, a, b, c, d, e) (a, b, c, d, e)
+ # define P6(x, a, b, c, d, e, f) (a, b, c, d, e, f)
+ # define P7(x, a, b, c, d, e, f, g) (a, b, c, d, e, f, g)
+ # define P8(x, a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h)
+
+ #else /* !NeedFunctionPrototypes */
+
+ # define P( protos ) ( /* protos */ )
+
+ # define P0() ()
+ # define P1(x, a) x a;
+ # define P2(x, a, b) x a; b;
+ # define P3(x, a, b, c) x a; b; c;
+ # define P4(x, a, b, c, d) x a; b; c; d;
+ # define P5(x, a, b, c, d, e) x a; b; c; d; e;
+ # define P6(x, a, b, c, d, e, f) x a; b; c; d; e; f;
+ # define P7(x, a, b, c, d, e, f, g) x a; b; c; d; e; f; g;
+ # define P8(x, a, b, c, d, e, f, g, h) x a; b; c; d; e; f; g; h;
+
+ #endif /* !NeedFunctionPrototypes */
+
+ #endif /* PROTO_H */
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/rpe.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/rpe.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/rpe.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,488 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/rpe.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ /* 4.2.13 .. 4.2.17 RPE ENCODING SECTION
+ */
+
+ /* 4.2.13 */
+
+ static void Weighting_filter P2((e, x),
+ register word * e, /* signal [-5..0.39.44] IN */
+ word * x /* signal [0..39] OUT */
+ )
+ /*
+ * The coefficients of the weighting filter are stored in a table
+ * (see table 4.4). The following scaling is used:
+ *
+ * H[0..10] = integer( real_H[ 0..10] * 8192 );
+ */
+ {
+ /* word wt[ 50 ]; */
+
+ register longword L_result;
+ register int k /* , i */ ;
+
+ /* Initialization of a temporary working array wt[0...49]
+ */
+
+ /* for (k = 0; k <= 4; k++) wt[k] = 0;
+ * for (k = 5; k <= 44; k++) wt[k] = *e++;
+ * for (k = 45; k <= 49; k++) wt[k] = 0;
+ *
+ * (e[-5..-1] and e[40..44] are allocated by the caller,
+ * are initially zero and are not written anywhere.)
+ */
+ e -= 5;
+
+ /* Compute the signal x[0..39]
+ */
+ for (k = 0; k <= 39; k++) {
+
+ L_result = 8192 >> 1;
+
+ /* for (i = 0; i <= 10; i++) {
+ * L_temp = GSM_L_MULT( wt[k+i], gsm_H[i] );
+ * L_result = GSM_L_ADD( L_result, L_temp );
+ * }
+ */
+
+ #undef STEP
+ #define STEP( i, H ) (e[ k + i ] * (longword)H)
+
+ /* Every one of these multiplications is done twice --
+ * but I don't see an elegant way to optimize this.
+ * Do you?
+ */
+
+ #ifdef STUPID_COMPILER
+ L_result += STEP( 0, -134 ) ;
+ L_result += STEP( 1, -374 ) ;
+ /* + STEP( 2, 0 ) */
+ L_result += STEP( 3, 2054 ) ;
+ L_result += STEP( 4, 5741 ) ;
+ L_result += STEP( 5, 8192 ) ;
+ L_result += STEP( 6, 5741 ) ;
+ L_result += STEP( 7, 2054 ) ;
+ /* + STEP( 8, 0 ) */
+ L_result += STEP( 9, -374 ) ;
+ L_result += STEP( 10, -134 ) ;
+ #else
+ L_result +=
+ STEP( 0, -134 )
+ + STEP( 1, -374 )
+ /* + STEP( 2, 0 ) */
+ + STEP( 3, 2054 )
+ + STEP( 4, 5741 )
+ + STEP( 5, 8192 )
+ + STEP( 6, 5741 )
+ + STEP( 7, 2054 )
+ /* + STEP( 8, 0 ) */
+ + STEP( 9, -374 )
+ + STEP(10, -134 )
+ ;
+ #endif
+
+ /* L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x2) *)
+ * L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x4) *)
+ *
+ * x[k] = SASR( L_result, 16 );
+ */
+
+ /* 2 adds vs. >>16 => 14, minus one shift to compensate for
+ * those we lost when replacing L_MULT by '*'.
+ */
+
+ L_result = SASR( L_result, 13 );
+ x[k] = ( L_result < MIN_WORD ? MIN_WORD
+ : (L_result > MAX_WORD ? MAX_WORD : L_result ));
+ }
+ }
+
+ /* 4.2.14 */
+
+ static void RPE_grid_selection P3((x,xM,Mc_out),
+ word * x, /* [0..39] IN */
+ word * xM, /* [0..12] OUT */
+ word * Mc_out /* OUT */
+ )
+ /*
+ * The signal x[0..39] is used to select the RPE grid which is
+ * represented by Mc.
+ */
+ {
+ /* register word temp1; */
+ register int /* m, */ i;
+ register longword L_result, L_temp;
+ longword EM; /* xxx should be L_EM? */
+ word Mc;
+
+ longword L_common_0_3;
+
+ EM = 0;
+ Mc = 0;
+
+ /* for (m = 0; m <= 3; m++) {
+ * L_result = 0;
+ *
+ *
+ * for (i = 0; i <= 12; i++) {
+ *
+ * temp1 = SASR( x[m + 3*i], 2 );
+ *
+ * assert(temp1 != MIN_WORD);
+ *
+ * L_temp = GSM_L_MULT( temp1, temp1 );
+ * L_result = GSM_L_ADD( L_temp, L_result );
+ * }
+ *
+ * if (L_result > EM) {
+ * Mc = m;
+ * EM = L_result;
+ * }
+ * }
+ */
+
+ #undef STEP
+ #define STEP( m, i ) L_temp = SASR( x[m + 3 * i], 2 ); \
+ L_result += L_temp * L_temp;
+
+ /* common part of 0 and 3 */
+
+ L_result = 0;
+ STEP( 0, 1 ); STEP( 0, 2 ); STEP( 0, 3 ); STEP( 0, 4 );
+ STEP( 0, 5 ); STEP( 0, 6 ); STEP( 0, 7 ); STEP( 0, 8 );
+ STEP( 0, 9 ); STEP( 0, 10); STEP( 0, 11); STEP( 0, 12);
+ L_common_0_3 = L_result;
+
+ /* i = 0 */
+
+ STEP( 0, 0 );
+ L_result <<= 1; /* implicit in L_MULT */
+ EM = L_result;
+
+ /* i = 1 */
+
+ L_result = 0;
+ STEP( 1, 0 );
+ STEP( 1, 1 ); STEP( 1, 2 ); STEP( 1, 3 ); STEP( 1, 4 );
+ STEP( 1, 5 ); STEP( 1, 6 ); STEP( 1, 7 ); STEP( 1, 8 );
+ STEP( 1, 9 ); STEP( 1, 10); STEP( 1, 11); STEP( 1, 12);
+ L_result <<= 1;
+ if (L_result > EM) {
+ Mc = 1;
+ EM = L_result;
+ }
+
+ /* i = 2 */
+
+ L_result = 0;
+ STEP( 2, 0 );
+ STEP( 2, 1 ); STEP( 2, 2 ); STEP( 2, 3 ); STEP( 2, 4 );
+ STEP( 2, 5 ); STEP( 2, 6 ); STEP( 2, 7 ); STEP( 2, 8 );
+ STEP( 2, 9 ); STEP( 2, 10); STEP( 2, 11); STEP( 2, 12);
+ L_result <<= 1;
+ if (L_result > EM) {
+ Mc = 2;
+ EM = L_result;
+ }
+
+ /* i = 3 */
+
+ L_result = L_common_0_3;
+ STEP( 3, 12 );
+ L_result <<= 1;
+ if (L_result > EM) {
+ Mc = 3;
+ EM = L_result;
+ }
+
+ /**/
+
+ /* Down-sampling by a factor 3 to get the selected xM[0..12]
+ * RPE sequence.
+ */
+ for (i = 0; i <= 12; i ++) xM[i] = x[Mc + 3*i];
+ *Mc_out = Mc;
+ }
+
+ /* 4.12.15 */
+
+ static void APCM_quantization_xmaxc_to_exp_mant P3((xmaxc,exp_out,mant_out),
+ word xmaxc, /* IN */
+ word * exp_out, /* OUT */
+ word * mant_out ) /* OUT */
+ {
+ word exp, mant;
+
+ /* Compute exponent and mantissa of the decoded version of xmaxc
+ */
+
+ exp = 0;
+ if (xmaxc > 15) exp = SASR(xmaxc, 3) - 1;
+ mant = xmaxc - (exp << 3);
+
+ if (mant == 0) {
+ exp = -4;
+ mant = 7;
+ }
+ else {
+ while (mant <= 7) {
+ mant = mant << 1 | 1;
+ exp--;
+ }
+ mant -= 8;
+ }
+
+ assert( exp >= -4 && exp <= 6 );
+ assert( mant >= 0 && mant <= 7 );
+
+ *exp_out = exp;
+ *mant_out = mant;
+ }
+
+ static void APCM_quantization P5((xM,xMc,mant_out,exp_out,xmaxc_out),
+ word * xM, /* [0..12] IN */
+
+ word * xMc, /* [0..12] OUT */
+ word * mant_out, /* OUT */
+ word * exp_out, /* OUT */
+ word * xmaxc_out /* OUT */
+ )
+ {
+ int i, itest;
+
+ word xmax, xmaxc, temp, temp1, temp2;
+ word exp, mant;
+
+
+ /* Find the maximum absolute value xmax of xM[0..12].
+ */
+
+ xmax = 0;
+ for (i = 0; i <= 12; i++) {
+ temp = xM[i];
+ temp = GSM_ABS(temp);
+ if (temp > xmax) xmax = temp;
+ }
+
+ /* Qantizing and coding of xmax to get xmaxc.
+ */
+
+ exp = 0;
+ temp = SASR( xmax, 9 );
+ itest = 0;
+
+ for (i = 0; i <= 5; i++) {
+
+ itest |= (temp <= 0);
+ temp = SASR( temp, 1 );
+
+ assert(exp <= 5);
+ if (itest == 0) exp++; /* exp = add (exp, 1) */
+ }
+
+ assert(exp <= 6 && exp >= 0);
+ temp = exp + 5;
+
+ assert(temp <= 11 && temp >= 0);
+ xmaxc = gsm_add( SASR(xmax, temp), exp << 3 );
+
+ /* Quantizing and coding of the xM[0..12] RPE sequence
+ * to get the xMc[0..12]
+ */
+
+ APCM_quantization_xmaxc_to_exp_mant( xmaxc, &exp, &mant );
+
+ /* This computation uses the fact that the decoded version of xmaxc
+ * can be calculated by using the exponent and the mantissa part of
+ * xmaxc (logarithmic table).
+ * So, this method avoids any division and uses only a scaling
+ * of the RPE samples by a function of the exponent. A direct
+ * multiplication by the inverse of the mantissa (NRFAC[0..7]
+ * found in table 4.5) gives the 3 bit coded version xMc[0..12]
+ * of the RPE samples.
+ */
+
+
+ /* Direct computation of xMc[0..12] using table 4.5
+ */
+
+ assert( exp <= 4096 && exp >= -4096);
+ assert( mant >= 0 && mant <= 7 );
+
+ temp1 = 6 - exp; /* normalization by the exponent */
+ temp2 = gsm_NRFAC[ mant ]; /* inverse mantissa */
+
+ for (i = 0; i <= 12; i++) {
+
+ assert(temp1 >= 0 && temp1 < 16);
+
+ temp = xM[i] << temp1;
+ temp = GSM_MULT( temp, temp2 );
+ temp = SASR(temp, 12);
+ xMc[i] = temp + 4; /* see note below */
+ }
+
+ /* NOTE: This equation is used to make all the xMc[i] positive.
+ */
+
+ *mant_out = mant;
+ *exp_out = exp;
+ *xmaxc_out = xmaxc;
+ }
+
+ /* 4.2.16 */
+
+ static void APCM_inverse_quantization P4((xMc,mant,exp,xMp),
+ register word * xMc, /* [0..12] IN */
+ word mant,
+ word exp,
+ register word * xMp) /* [0..12] OUT */
+ /*
+ * This part is for decoding the RPE sequence of coded xMc[0..12]
+ * samples to obtain the xMp[0..12] array. Table 4.6 is used to get
+ * the mantissa of xmaxc (FAC[0..7]).
+ */
+ {
+ int i;
+ word temp, temp1, temp2, temp3;
+ longword ltmp;
+
+ assert( mant >= 0 && mant <= 7 );
+
+ temp1 = gsm_FAC[ mant ]; /* see 4.2-15 for mant */
+ temp2 = gsm_sub( 6, exp ); /* see 4.2-15 for exp */
+ temp3 = gsm_asl( 1, gsm_sub( temp2, 1 ));
+
+ for (i = 13; i--;) {
+
+ assert( *xMc <= 7 && *xMc >= 0 ); /* 3 bit unsigned */
+
+ /* temp = gsm_sub( *xMc++ << 1, 7 ); */
+ temp = (*xMc++ << 1) - 7; /* restore sign */
+ assert( temp <= 7 && temp >= -7 ); /* 4 bit signed */
+
+ temp <<= 12; /* 16 bit signed */
+ temp = GSM_MULT_R( temp1, temp );
+ temp = GSM_ADD( temp, temp3 );
+ *xMp++ = gsm_asr( temp, temp2 );
+ }
+ }
+
+ /* 4.2.17 */
+
+ static void RPE_grid_positioning P3((Mc,xMp,ep),
+ word Mc, /* grid position IN */
+ register word * xMp, /* [0..12] IN */
+ register word * ep /* [0..39] OUT */
+ )
+ /*
+ * This procedure computes the reconstructed long term residual signal
+ * ep[0..39] for the LTP analysis filter. The inputs are the Mc
+ * which is the grid position selection and the xMp[0..12] decoded
+ * RPE samples which are upsampled by a factor of 3 by inserting zero
+ * values.
+ */
+ {
+ int i = 13;
+
+ assert(0 <= Mc && Mc <= 3);
+
+ switch (Mc) {
+ case 3: *ep++ = 0;
+ case 2: do {
+ *ep++ = 0;
+ case 1: *ep++ = 0;
+ case 0: *ep++ = *xMp++;
+ } while (--i);
+ }
+ while (++Mc < 4) *ep++ = 0;
+
+ /*
+
+ int i, k;
+ for (k = 0; k <= 39; k++) ep[k] = 0;
+ for (i = 0; i <= 12; i++) {
+ ep[ Mc + (3*i) ] = xMp[i];
+ }
+ */
+ }
+
+ /* 4.2.18 */
+
+ /* This procedure adds the reconstructed long term residual signal
+ * ep[0..39] to the estimated signal dpp[0..39] from the long term
+ * analysis filter to compute the reconstructed short term residual
+ * signal dp[-40..-1]; also the reconstructed short term residual
+ * array dp[-120..-41] is updated.
+ */
+
+ #if 0 /* Has been inlined in code.c */
+ void Gsm_Update_of_reconstructed_short_time_residual_signal P3((dpp, ep, dp),
+ word * dpp, /* [0...39] IN */
+ word * ep, /* [0...39] IN */
+ word * dp) /* [-120...-1] IN/OUT */
+ {
+ int k;
+
+ for (k = 0; k <= 79; k++)
+ dp[ -120 + k ] = dp[ -80 + k ];
+
+ for (k = 0; k <= 39; k++)
+ dp[ -40 + k ] = gsm_add( ep[k], dpp[k] );
+ }
+ #endif /* Has been inlined in code.c */
+
+ void Gsm_RPE_Encoding P5((S,e,xmaxc,Mc,xMc),
+
+ struct gsm_state * S,
+
+ word * e, /* -5..-1][0..39][40..44 IN/OUT */
+ word * xmaxc, /* OUT */
+ word * Mc, /* OUT */
+ word * xMc) /* [0..12] OUT */
+ {
+ word x[40];
+ word xM[13], xMp[13];
+ word mant, exp;
+
+ Weighting_filter(e, x);
+ RPE_grid_selection(x, xM, Mc);
+
+ APCM_quantization( xM, xMc, &mant, &exp, xmaxc);
+ APCM_inverse_quantization( xMc, mant, exp, xMp);
+
+ RPE_grid_positioning( *Mc, xMp, e );
+
+ }
+
+ void Gsm_RPE_Decoding P5((S, xmaxcr, Mcr, xMcr, erp),
+ struct gsm_state * S,
+
+ word xmaxcr,
+ word Mcr,
+ word * xMcr, /* [0..12], 3 bits IN */
+ word * erp /* [0..39] OUT */
+ )
+ {
+ word exp, mant;
+ word xMp[ 13 ];
+
+ APCM_quantization_xmaxc_to_exp_mant( xmaxcr, &exp, &mant );
+ APCM_inverse_quantization( xMcr, mant, exp, xMp );
+ RPE_grid_positioning( Mcr, xMp, erp );
+
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/short_term.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/short_term.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/short_term.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,429 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/short_term.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ /*
+ * SHORT TERM ANALYSIS FILTERING SECTION
+ */
+
+ /* 4.2.8 */
+
+ static void Decoding_of_the_coded_Log_Area_Ratios P2((LARc,LARpp),
+ word * LARc, /* coded log area ratio [0..7] IN */
+ word * LARpp) /* out: decoded .. */
+ {
+ register word temp1 /* , temp2 */;
+ register long ltmp; /* for GSM_ADD */
+
+ /* This procedure requires for efficient implementation
+ * two tables.
+ *
+ * INVA[1..8] = integer( (32768 * 8) / real_A[1..8])
+ * MIC[1..8] = minimum value of the LARc[1..8]
+ */
+
+ /* Compute the LARpp[1..8]
+ */
+
+ /* for (i = 1; i <= 8; i++, B++, MIC++, INVA++, LARc++, LARpp++) {
+ *
+ * temp1 = GSM_ADD( *LARc, *MIC ) << 10;
+ * temp2 = *B << 1;
+ * temp1 = GSM_SUB( temp1, temp2 );
+ *
+ * assert(*INVA != MIN_WORD);
+ *
+ * temp1 = GSM_MULT_R( *INVA, temp1 );
+ * *LARpp = GSM_ADD( temp1, temp1 );
+ * }
+ */
+
+ #undef STEP
+ #define STEP( B, MIC, INVA ) \
+ temp1 = GSM_ADD( *LARc++, MIC ) << 10; \
+ temp1 = GSM_SUB( temp1, B << 1 ); \
+ temp1 = GSM_MULT_R( INVA, temp1 ); \
+ *LARpp++ = GSM_ADD( temp1, temp1 );
+
+ STEP( 0, -32, 13107 );
+ STEP( 0, -32, 13107 );
+ STEP( 2048, -16, 13107 );
+ STEP( -2560, -16, 13107 );
+
+ STEP( 94, -8, 19223 );
+ STEP( -1792, -8, 17476 );
+ STEP( -341, -4, 31454 );
+ STEP( -1144, -4, 29708 );
+
+ /* NOTE: the addition of *MIC is used to restore
+ * the sign of *LARc.
+ */
+ }
+
+ /* 4.2.9 */
+ /* Computation of the quantized reflection coefficients
+ */
+
+ /* 4.2.9.1 Interpolation of the LARpp[1..8] to get the LARp[1..8]
+ */
+
+ /*
+ * Within each frame of 160 analyzed speech samples the short term
+ * analysis and synthesis filters operate with four different sets of
+ * coefficients, derived from the previous set of decoded LARs(LARpp(j-1))
+ * and the actual set of decoded LARs (LARpp(j))
+ *
+ * (Initial value: LARpp(j-1)[1..8] = 0.)
+ */
+
+ static void Coefficients_0_12 P3((LARpp_j_1, LARpp_j, LARp),
+ register word * LARpp_j_1,
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+ register longword ltmp;
+
+ for (i = 1; i <= 8; i++, LARp++, LARpp_j_1++, LARpp_j++) {
+ *LARp = GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
+ *LARp = GSM_ADD( *LARp, SASR( *LARpp_j_1, 1));
+ }
+ }
+
+ static void Coefficients_13_26 P3((LARpp_j_1, LARpp_j, LARp),
+ register word * LARpp_j_1,
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+ register longword ltmp;
+ for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {
+ *LARp = GSM_ADD( SASR( *LARpp_j_1, 1), SASR( *LARpp_j, 1 ));
+ }
+ }
+
+ static void Coefficients_27_39 P3((LARpp_j_1, LARpp_j, LARp),
+ register word * LARpp_j_1,
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+ register longword ltmp;
+
+ for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {
+ *LARp = GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
+ *LARp = GSM_ADD( *LARp, SASR( *LARpp_j, 1 ));
+ }
+ }
+
+
+ static void Coefficients_40_159 P2((LARpp_j, LARp),
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+
+ for (i = 1; i <= 8; i++, LARp++, LARpp_j++)
+ *LARp = *LARpp_j;
+ }
+
+ /* 4.2.9.2 */
+
+ static void LARp_to_rp P1((LARp),
+ register word * LARp) /* [0..7] IN/OUT */
+ /*
+ * The input of this procedure is the interpolated LARp[0..7] array.
+ * The reflection coefficients, rp[i], are used in the analysis
+ * filter and in the synthesis filter.
+ */
+ {
+ register int i;
+ register word temp;
+ register longword ltmp;
+
+ for (i = 1; i <= 8; i++, LARp++) {
+
+ /* temp = GSM_ABS( *LARp );
+ *
+ * if (temp < 11059) temp <<= 1;
+ * else if (temp < 20070) temp += 11059;
+ * else temp = GSM_ADD( temp >> 2, 26112 );
+ *
+ * *LARp = *LARp < 0 ? -temp : temp;
+ */
+
+ if (*LARp < 0) {
+ temp = *LARp == MIN_WORD ? MAX_WORD : -(*LARp);
+ *LARp = - ((temp < 11059) ? temp << 1
+ : ((temp < 20070) ? temp + 11059
+ : GSM_ADD( temp >> 2, 26112 )));
+ } else {
+ temp = *LARp;
+ *LARp = (temp < 11059) ? temp << 1
+ : ((temp < 20070) ? temp + 11059
+ : GSM_ADD( temp >> 2, 26112 ));
+ }
+ }
+ }
+
+
+ /* 4.2.10 */
+ static void Short_term_analysis_filtering P4((S,rp,k_n,s),
+ struct gsm_state * S,
+ register word * rp, /* [0..7] IN */
+ register int k_n, /* k_end - k_start */
+ register word * s /* [0..n-1] IN/OUT */
+ )
+ /*
+ * This procedure computes the short term residual signal d[..] to be fed
+ * to the RPE-LTP loop from the s[..] signal and from the local rp[..]
+ * array (quantized reflection coefficients). As the call of this
+ * procedure can be done in many ways (see the interpolation of the LAR
+ * coefficient), it is assumed that the computation begins with index
+ * k_start (for arrays d[..] and s[..]) and stops with index k_end
+ * (k_start and k_end are defined in 4.2.9.1). This procedure also
+ * needs to keep the array u[0..7] in memory for each call.
+ */
+ {
+ register word * u = S->u;
+ register int i;
+ register word di, zzz, ui, sav, rpi;
+ register longword ltmp;
+
+ for (; k_n--; s++) {
+
+ di = sav = *s;
+
+ for (i = 0; i < 8; i++) { /* YYY */
+
+ ui = u[i];
+ rpi = rp[i];
+ u[i] = sav;
+
+ zzz = GSM_MULT_R(rpi, di);
+ sav = GSM_ADD( ui, zzz);
+
+ zzz = GSM_MULT_R(rpi, ui);
+ di = GSM_ADD( di, zzz );
+ }
+
+ *s = di;
+ }
+ }
+
+ #if defined(USE_FLOAT_MUL) && defined(FAST)
+
+ static void Fast_Short_term_analysis_filtering P4((S,rp,k_n,s),
+ struct gsm_state * S,
+ register word * rp, /* [0..7] IN */
+ register int k_n, /* k_end - k_start */
+ register word * s /* [0..n-1] IN/OUT */
+ )
+ {
+ register word * u = S->u;
+ register int i;
+
+ float uf[8],
+ rpf[8];
+
+ register float scalef = 3.0517578125e-5;
+ register float sav, di, temp;
+
+ for (i = 0; i < 8; ++i) {
+ uf[i] = u[i];
+ rpf[i] = rp[i] * scalef;
+ }
+ for (; k_n--; s++) {
+ sav = di = *s;
+ for (i = 0; i < 8; ++i) {
+ register float rpfi = rpf[i];
+ register float ufi = uf[i];
+
+ uf[i] = sav;
+ temp = rpfi * di + ufi;
+ di += rpfi * ufi;
+ sav = temp;
+ }
+ *s = di;
+ }
+ for (i = 0; i < 8; ++i) u[i] = uf[i];
+ }
+ #endif /* ! (defined (USE_FLOAT_MUL) && defined (FAST)) */
+
+ static void Short_term_synthesis_filtering P5((S,rrp,k,wt,sr),
+ struct gsm_state * S,
+ register word * rrp, /* [0..7] IN */
+ register int k, /* k_end - k_start */
+ register word * wt, /* [0..k-1] IN */
+ register word * sr /* [0..k-1] OUT */
+ )
+ {
+ register word * v = S->v;
+ register int i;
+ register word sri, tmp1, tmp2;
+ register longword ltmp; /* for GSM_ADD & GSM_SUB */
+
+ while (k--) {
+ sri = *wt++;
+ for (i = 8; i--;) {
+
+ /* sri = GSM_SUB( sri, gsm_mult_r( rrp[i], v[i] ) );
+ */
+ tmp1 = rrp[i];
+ tmp2 = v[i];
+ tmp2 = ( tmp1 == MIN_WORD && tmp2 == MIN_WORD
+ ? MAX_WORD
+ : 0x0FFFF & (( (longword)tmp1 * (longword)tmp2
+ + 16384) >> 15)) ;
+
+ sri = GSM_SUB( sri, tmp2 );
+
+ /* v[i+1] = GSM_ADD( v[i], gsm_mult_r( rrp[i], sri ) );
+ */
+ tmp1 = ( tmp1 == MIN_WORD && sri == MIN_WORD
+ ? MAX_WORD
+ : 0x0FFFF & (( (longword)tmp1 * (longword)sri
+ + 16384) >> 15)) ;
+
+ v[i+1] = GSM_ADD( v[i], tmp1);
+ }
+ *sr++ = v[0] = sri;
+ }
+ }
+
+
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+
+ static void Fast_Short_term_synthesis_filtering P5((S,rrp,k,wt,sr),
+ struct gsm_state * S,
+ register word * rrp, /* [0..7] IN */
+ register int k, /* k_end - k_start */
+ register word * wt, /* [0..k-1] IN */
+ register word * sr /* [0..k-1] OUT */
+ )
+ {
+ register word * v = S->v;
+ register int i;
+
+ float va[9], rrpa[8];
+ register float scalef = 3.0517578125e-5, temp;
+
+ for (i = 0; i < 8; ++i) {
+ va[i] = v[i];
+ rrpa[i] = (float)rrp[i] * scalef;
+ }
+ while (k--) {
+ register float sri = *wt++;
+ for (i = 8; i--;) {
+ sri -= rrpa[i] * va[i];
+ if (sri < -32768.) sri = -32768.;
+ else if (sri > 32767.) sri = 32767.;
+
+ temp = va[i] + rrpa[i] * sri;
+ if (temp < -32768.) temp = -32768.;
+ else if (temp > 32767.) temp = 32767.;
+ va[i+1] = temp;
+ }
+ *sr++ = va[0] = sri;
+ }
+ for (i = 0; i < 9; ++i) v[i] = va[i];
+ }
+
+ #endif /* defined(FAST) && defined(USE_FLOAT_MUL) */
+
+ void Gsm_Short_Term_Analysis_Filter P3((S,LARc,s),
+
+ struct gsm_state * S,
+
+ word * LARc, /* coded log area ratio [0..7] IN */
+ word * s /* signal [0..159] IN/OUT */
+ )
+ {
+ word * LARpp_j = S->LARpp[ S->j ];
+ word * LARpp_j_1 = S->LARpp[ S->j ^= 1 ];
+
+ word LARp[8];
+
+ #undef FILTER
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+ # define FILTER (* (S->fast \
+ ? Fast_Short_term_analysis_filtering \
+ : Short_term_analysis_filtering ))
+
+ #else
+ # define FILTER Short_term_analysis_filtering
+ #endif
+
+ Decoding_of_the_coded_Log_Area_Ratios( LARc, LARpp_j );
+
+ Coefficients_0_12( LARpp_j_1, LARpp_j, LARp );
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, s);
+
+ Coefficients_13_26( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 14, s + 13);
+
+ Coefficients_27_39( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, s + 27);
+
+ Coefficients_40_159( LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 120, s + 40);
+ }
+
+ void Gsm_Short_Term_Synthesis_Filter P4((S, LARcr, wt, s),
+ struct gsm_state * S,
+
+ word * LARcr, /* received log area ratios [0..7] IN */
+ word * wt, /* received d [0..159] IN */
+
+ word * s /* signal s [0..159] OUT */
+ )
+ {
+ word * LARpp_j = S->LARpp[ S->j ];
+ word * LARpp_j_1 = S->LARpp[ S->j ^=1 ];
+
+ word LARp[8];
+
+ #undef FILTER
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+
+ # define FILTER (* (S->fast \
+ ? Fast_Short_term_synthesis_filtering \
+ : Short_term_synthesis_filtering ))
+ #else
+ # define FILTER Short_term_synthesis_filtering
+ #endif
+
+ Decoding_of_the_coded_Log_Area_Ratios( LARcr, LARpp_j );
+
+ Coefficients_0_12( LARpp_j_1, LARpp_j, LARp );
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, wt, s );
+
+ Coefficients_13_26( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 14, wt + 13, s + 13 );
+
+ Coefficients_27_39( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, wt + 27, s + 27 );
+
+ Coefficients_40_159( LARpp_j, LARp );
+ LARp_to_rp( LARp );
+ FILTER(S, LARp, 120, wt + 40, s + 40);
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/table.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/table.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/table.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,63 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/table.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ /* Most of these tables are inlined at their point of use.
+ */
+
+ /* 4.4 TABLES USED IN THE FIXED POINT IMPLEMENTATION OF THE RPE-LTP
+ * CODER AND DECODER
+ *
+ * (Most of them inlined, so watch out.)
+ */
+
+ #define GSM_TABLE_C
+ #include "private.h"
+ #include "gsm.h"
+
+ /* Table 4.1 Quantization of the Log.-Area Ratios
+ */
+ /* i 1 2 3 4 5 6 7 8 */
+ word gsm_A[8] = {20480, 20480, 20480, 20480, 13964, 15360, 8534, 9036};
+ word gsm_B[8] = { 0, 0, 2048, -2560, 94, -1792, -341, -1144};
+ word gsm_MIC[8] = { -32, -32, -16, -16, -8, -8, -4, -4 };
+ word gsm_MAC[8] = { 31, 31, 15, 15, 7, 7, 3, 3 };
+
+
+ /* Table 4.2 Tabulation of 1/A[1..8]
+ */
+ word gsm_INVA[8]={ 13107, 13107, 13107, 13107, 19223, 17476, 31454, 29708 };
+
+
+ /* Table 4.3a Decision level of the LTP gain quantizer
+ */
+ /* bc 0 1 2 3 */
+ word gsm_DLB[4] = { 6554, 16384, 26214, 32767 };
+
+
+ /* Table 4.3b Quantization levels of the LTP gain quantizer
+ */
+ /* bc 0 1 2 3 */
+ word gsm_QLB[4] = { 3277, 11469, 21299, 32767 };
+
+
+ /* Table 4.4 Coefficients of the weighting filter
+ */
+ /* i 0 1 2 3 4 5 6 7 8 9 10 */
+ word gsm_H[11] = {-134, -374, 0, 2054, 5741, 8192, 5741, 2054, 0, -374, -134 };
+
+
+ /* Table 4.5 Normalized inverse mantissa used to compute xM/xmax
+ */
+ /* i 0 1 2 3 4 5 6 7 */
+ word gsm_NRFAC[8] = { 29128, 26215, 23832, 21846, 20165, 18725, 17476, 16384 };
+
+
+ /* Table 4.6 Normalized direct mantissa used to compute xM/xmax
+ */
+ /* i 0 1 2 3 4 5 6 7 */
+ word gsm_FAC[8] = { 18431, 20479, 22527, 24575, 26623, 28671, 30719, 32767 };
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,787 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #include "toast.h"
+
+ /* toast -- lossy sound compression using the gsm library.
+ */
+
+ char * progname;
+
+ int f_decode = 0; /* decode rather than encode (-d) */
+ int f_cat = 0; /* write to stdout, not foo.gsm (-c) */
+ int f_force = 0; /* force deletion (-f) */
+ int f_precious = 0; /* avoid deletion (-p) */
+ int f_fast = 0; /* use faster fpt algorithm (-F) */
+ int f_verbose = 0; /* debugging (-V) */
+
+ struct stat instat; /* stat (inname) */
+
+ FILE *in, *out;
+ char *inname, *outname;
+
+ /*
+ * The function (*output)() writes a frame of 160 samples given as
+ * 160 signed 16 bit values (gsm_signals) to <out>.
+ * The function (*input)() reads one such frame from <in>.
+ * The function (*init_output)() begins output (e.g. writes a header).,
+ * The function (*init_input)() begins input (e.g. skips a header).
+ *
+ * There are different versions of input, output, init_input and init_output
+ * for different formats understood by toast; which ones are used
+ * depends on the command line arguments and, in their absence, the
+ * filename; the fallback is #defined in toast.h
+ *
+ * The specific implementations of input, output, init_input and init_output
+ * for a format `foo' live in toast_foo.c.
+ */
+
+ int (*output ) P((gsm_signal *)),
+ (*input ) P((gsm_signal *));
+ int (*init_input) P((void)),
+ (*init_output) P((void));
+
+ static int generic_init P0() { return 0; } /* NOP */
+
+ struct fmtdesc {
+
+ char * name, * longname, * suffix;
+
+ int (* init_input ) P((void)),
+ (* init_output) P((void));
+
+ int (* input ) P((gsm_signal * )),
+ (* output) P((gsm_signal * ));
+
+ } f_audio = {
+ "audio",
+ "8 kHz, 8 bit u-law encoding with Sun audio header", ".au",
+ audio_init_input,
+ audio_init_output,
+ ulaw_input,
+ ulaw_output
+ }, f_ulaw = {
+ "u-law", "plain 8 kHz, 8 bit u-law encoding", ".u",
+ generic_init,
+ generic_init,
+ ulaw_input,
+ ulaw_output
+
+ }, f_alaw = {
+ "A-law", "8 kHz, 8 bit A-law encoding", ".A",
+ generic_init,
+ generic_init,
+ alaw_input,
+ alaw_output
+
+ }, f_linear = {
+ "linear",
+ "16 bit (13 significant) signed 8 kHz signal", ".l",
+ generic_init,
+ generic_init,
+ linear_input,
+ linear_output
+ };
+
+ struct fmtdesc * alldescs[] = {
+ &f_audio,
+ &f_alaw,
+ &f_ulaw,
+ &f_linear,
+ (struct fmtdesc *)NULL
+ };
+
+ #define DEFAULT_FORMAT f_ulaw /* default audio format, others */
+ /* are: f_alaw,f_audio,f_linear */
+ struct fmtdesc * f_format = 0;
+
+ /*
+ * basename + suffix of a pathname
+ */
+ static char * endname P1((name), char * name)
+ {
+ if (name) {
+ char * s = strrchr(name, '/');
+ if (s && s[1]) name = s + 1;
+ }
+ return name;
+
+ }
+
+ /*
+ * Try to figure out what we're supposed to do from the argv[0], if
+ * any, and set the parameters accordingly.
+ */
+ static void parse_argv0 P1((av0), char * av0 )
+ {
+ int l;
+
+ progname = av0 = endname(av0 ? av0 : "toast");
+
+ /* If the name starts with `un', we want to decode, not code.
+ * If the name ends in `cat', we want to write to stdout,
+ * and decode as well.
+ */
+
+ if (!strncmp(av0, "un", 2)) f_decode = 1;
+ if ( (l = strlen(av0)) >= 3 /* strlen("cat") */
+ && !strcmp( av0 + l - 3, "cat" )) f_cat = f_decode = 1;
+ }
+
+
+ /*
+ * Check whether the name (possibly generated by appending
+ * .gsm to something else) is short enough for this system.
+ */
+ static int length_okay P1((name), char * name)
+ {
+ long max_filename_length = 0;
+ char * end;
+
+ /* If our _pathname_ is too long, we'll usually not be
+ * able to open the file at all -- don't worry about that.
+ *
+ * But if the _filename_ is too long, there is danger of
+ * silent truncation on some systems, which results
+ * in the target replacing the source!
+ */
+
+ if (!name) return 0;
+ end = endname(name);
+
+ #ifdef NAME_MAX
+ max_filename_length = NAME_MAX;
+ #else
+ #ifdef _PC_NAME_MAX
+ #ifdef USE_PATHCONF
+ { char * s, tmp;
+
+ /* s = dirname(name)
+ */
+ if ((s = end) > name) {
+ if (s > name + 1) s--;
+ tmp = s;
+ *s = 0;
+ }
+
+ errno = 0;
+ max_filename_length = pathconf(s > name ? name : ".",
+ _PC_NAME_MAX);
+ if (max_filename_length == -1 && errno) {
+ perror( s > name ? name : "." );
+ fprintf(stderr,
+ "%s: cannot get dynamic filename length limit for %s.\n",
+ progname, s > name ? name : ".");
+ return 0;
+ }
+ if (s > name) *s = tmp;
+ }
+ #endif /* USE_PATHCONF */
+ #endif /* _PC_NAME_MAX */
+ #endif /* !NAME_MAX */
+
+ if (max_filename_length > 0 && strlen(end) > max_filename_length) {
+ fprintf(stderr,
+ "%s: filename \"%s\" is too long (maximum is %ld)\n",
+ progname, endname(name), max_filename_length );
+ return 0;
+ }
+
+ return 1;
+ }
+
+ /*
+ * Return a pointer the suffix of a string, if any.
+ * A suffix alone has no suffix, an empty suffix can not be had.
+ */
+ static char * suffix P2((name, suf), char *name, char * suf)
+ {
+ size_t nlen = strlen(name);
+ size_t slen = strlen(suf);
+
+ if (!slen || nlen <= slen) return (char *)0;
+ name += nlen - slen;
+ return memcmp(name, suf, slen) ? (char *)0 : name;
+ }
+
+
+ static void catch_signals P1((fun), SIGHANDLER_T (*fun) ())
+ {
+ #ifdef SIGHUP
+ signal( SIGHUP, fun );
+ #endif
+ #ifdef SIGINT
+ signal( SIGINT, fun );
+ #endif
+ #ifdef SIGPIPE
+ signal( SIGPIPE, fun );
+ #endif
+ #ifdef SIGTERM
+ signal( SIGTERM, fun );
+ #endif
+ #ifdef SIGXFSZ
+ signal( SIGXFSZ, fun );
+ #endif
+ }
+
+ static SIGHANDLER_T onintr P0()
+ {
+ char * tmp = outname;
+
+ #ifdef HAS_SYSV_SIGNALS
+ catch_signals( SIG_IGN );
+ #endif
+
+ outname = (char *)0;
+ if (tmp) (void)unlink(tmp);
+
+ exit(1);
+ }
+
+ /*
+ * Allocate some memory and complain if it fails.
+ */
+ static char * emalloc P1((len), size_t len)
+ {
+ char * s;
+ if (!(s = malloc(len))) {
+ fprintf(stderr, "%s: failed to malloc %d bytes -- abort\n",
+ progname, len);
+ onintr();
+ exit(1);
+ }
+ return s;
+ }
+
+ static char* normalname P3((name, want, cut), char *name, char *want,char *cut)
+ {
+ size_t maxlen;
+ char * s, * p;
+
+ p = (char *)0;
+ if (!name) return p;
+
+ maxlen = strlen(name) + 1 + strlen(want) + strlen(cut);
+ p = strcpy(emalloc(maxlen), name);
+
+ if (s = suffix(p, cut)) strcpy(s, want);
+ else if (*want && !suffix(p, want)) strcat(p, want);
+
+ return p;
+ }
+
+ /*
+ * Generate a `plain' (non-encoded) name from a given name.
+ */
+ static char * plainname P1((name), char *name)
+ {
+ return normalname(name, "", SUFFIX_TOASTED );
+ }
+
+ /*
+ * Generate a `code' name (foo.Z) from a given name.
+ */
+ static char * codename P1((name), char *name)
+ {
+ return normalname( name, SUFFIX_TOASTED, "" );
+ }
+
+ /*
+ * If we're supposed to ask (fileno (stderr) is a tty, and f_force not
+ * set), ask the user whether to overwrite a file or not.
+ */
+ static int ok_to_replace P1(( name ), char * name)
+ {
+ int reply, c;
+
+ if (f_force) return 1; /* YES, do replace */
+ if (!isatty(fileno(stderr))) return 0; /* NO, don't replace */
+
+ fprintf(stderr,
+ "%s already exists; do you wish to overwrite %s (y or n)? ",
+ name, name);
+ fflush(stderr);
+
+ for (c = reply = getchar(); c != '\n' && c != EOF; c = getchar()) ;
+ if (reply == 'y') return 1;
+
+ fprintf(stderr, "\tnot overwritten\n");
+ return 0;
+ }
+
+ static void update_mode P0()
+ {
+ if (!instat.st_nlink) return; /* couldn't stat in */
+
+ #ifdef HAS_FCHMOD
+ if (fchmod(fileno(out), instat.st_mode & 07777)) {
+ perror(outname);
+ fprintf(stderr, "%s: could not change file mode of \"%s\"\n",
+ progname, outname);
+ }
+ #else
+ if (outname && chmod(outname, instat.st_mode & 07777)) {
+ perror(outname);
+ fprintf(stderr, "%s: could not change file mode of \"%s\"\n",
+ progname, outname);
+ }
+ #endif /* HAS_FCHMOD */
+ }
+
+ static void update_own P0()
+ {
+ if (!instat.st_nlink) return; /* couldn't stat in */
+ #ifdef HAS_FCHOWN
+ (void)fchown(fileno(out), instat.st_uid, instat.st_gid);
+ #else
+ (void)chown(outname, instat.st_uid, instat.st_gid);
+ #endif /* HAS_FCHOWN */
+ }
+
+ static void update_times P0()
+ {
+ if (!instat.st_nlink) return; /* couldn't stat in */
+
+ #ifdef HAS_UTIMES
+ if (outname) {
+ struct timeval tv[2];
+
+ tv[0].tv_sec = instat.st_atime;
+ tv[1].tv_sec = instat.st_mtime;
+ tv[0].tv_usec = tv[1].tv_usec = 0;
+ (void) utimes(outname, tv);
+ }
+ #else
+ #ifdef HAS_UTIME
+
+ if (outname) {
+
+ #ifdef HAS_UTIMBUF
+ struct utimbuf ut;
+
+ ut.actime = instat.st_atime;
+ ut.modtime = instat.st_mtime;
+
+ # ifdef HAS_UTIMEUSEC
+ ut.acusec = instat.st_ausec;
+ ut.modusec = instat.st_musec;
+ # endif /* HAS_UTIMEUSEC */
+
+ (void) utime(outname, &ut);
+
+ #else /* UTIMBUF */
+
+ time_t ut[2];
+
+ ut[0] = instat.st_atime;
+ ut[1] = instat.st_mtime;
+
+ (void) utime(outname, ut);
+
+ #endif /* UTIMBUF */
+ }
+ #endif /* HAS_UTIME */
+ #endif /* HAS_UTIMES */
+ }
+
+
+ static int okay_as_input P3((name,f,st), char* name, FILE* f, struct stat * st)
+ {
+ # ifdef HAS_FSTAT
+ if (fstat(fileno(f), st) < 0)
+ # else
+ if (stat(name, st) < 0)
+ # endif
+ {
+ perror(name);
+ fprintf(stderr, "%s: cannot stat \"%s\"\n", progname, name);
+ return 0;
+ }
+
+ if (!S_ISREG(st->st_mode)) {
+ fprintf(stderr,
+ "%s: \"%s\" is not a regular file -- unchanged.\n",
+ progname, name);
+ return 0;
+ }
+ if (st->st_nlink > 1 && !f_cat && !f_precious) {
+ fprintf(stderr,
+ "%s: \"%s\" has %s other link%s -- unchanged.\n",
+ progname,name,st->st_nlink - 1,"s" + (st->st_nlink<=2));
+ return 0;
+ }
+ return 1;
+ }
+
+ static void prepare_io P1(( desc), struct fmtdesc * desc)
+ {
+ output = desc->output;
+ input = desc->input;
+
+ init_input = desc->init_input;
+ init_output = desc->init_output;
+ }
+
+ static struct fmtdesc * grok_format P1((name), char * name)
+ {
+ char * c;
+ struct fmtdesc ** f;
+
+ if (name) {
+ c = plainname(name);
+
+ for (f = alldescs; *f; f++)
+ if ( (*f)->suffix
+ && *(*f)->suffix
+ && suffix(c, (*f)->suffix)) {
+
+ free(c);
+ return *f;
+ }
+
+ free(c);
+ }
+ return (struct fmtdesc *)0;
+ }
+
+ static int open_input P2((name, st), char * name, struct stat * st)
+ {
+ struct fmtdesc * f = f_format;
+
+ st->st_nlink = 0; /* indicates `undefined' value */
+ if (!name) {
+ inname = (char *)NULL;
+ in = stdin;
+ }
+ else {
+ if (f_decode) inname = codename(name);
+ else {
+ if (!f_cat && suffix(name, SUFFIX_TOASTED)) {
+ fprintf(stderr,
+ "%s: %s already has \"%s\" suffix -- unchanged.\n",
+ progname, name, SUFFIX_TOASTED );
+ return 0;
+ }
+ inname = strcpy(emalloc(strlen(name)+1), name);
+ }
+ if (!(in = fopen(inname, READ))) {
+ perror(inname); /* not guaranteed to be valid here */
+ fprintf(stderr, "%s: cannot open \"%s\" for reading\n",
+ progname, inname);
+ return 0;
+ }
+ if (!okay_as_input(inname, in, st)) return 0;
+ if (!f) f = grok_format(inname);
+ }
+ prepare_io( f ? f : & DEFAULT_FORMAT );
+ return 1;
+ }
+
+ static int open_output P1((name), char *name)
+ {
+ if (!name || f_cat) {
+ out = stdout;
+ outname = (char *)NULL;
+ }
+ else {
+ int outfd = -1;
+ char * o;
+
+ o = (*(f_decode ? plainname : codename))(name);
+ if (!length_okay(o)) return 0;
+ if ((outfd = open(o, O_WRITE_EXCL, 0666)) >= 0)
+ out = fdopen(outfd, WRITE);
+ else if (errno != EEXIST) out = (FILE *)NULL;
+ else if (ok_to_replace(o)) out = fopen(o, WRITE);
+ else return 0;
+
+ if (!out) {
+ perror(o);
+ fprintf(stderr,
+ "%s: can't open \"%s\" for writing\n",
+ progname, o);
+ if (outfd >= 0) (void)close(outfd);
+ return 0;
+ }
+
+ outname = o;
+ }
+ return 1;
+ }
+
+ static int process_encode P0()
+ {
+ gsm r;
+ gsm_signal s[ 160 ];
+ gsm_frame d;
+
+ int cc;
+
+ if (!(r = gsm_create())) {
+ perror(progname);
+ return -1;
+ }
+ (void)gsm_option(r, GSM_OPT_FAST, &f_fast);
+ (void)gsm_option(r, GSM_OPT_VERBOSE, &f_verbose);
+
+ while ((cc = (*input)(s)) > 0) {
+ if (cc < sizeof(s) / sizeof(*s))
+ memset((char *)(s+cc), 0, sizeof(s)-(cc * sizeof(*s)));
+ gsm_encode(r, s, d);
+ if (fwrite((char *)d, sizeof(d), 1, out) != 1) {
+ perror(outname ? outname : "stdout");
+ fprintf(stderr, "%s: error writing to %s\n",
+ progname, outname ? outname : "stdout");
+ gsm_destroy(r);
+ return -1;
+ }
+ }
+ if (cc < 0) {
+ perror(inname ? inname : "stdin");
+ fprintf(stderr, "%s: error reading from %s\n",
+ progname, inname ? inname : "stdin");
+ gsm_destroy(r);
+ return -1;
+ }
+ gsm_destroy(r);
+
+ return 0;
+ }
+
+ static int process_decode P0()
+ {
+ gsm r;
+ gsm_frame s;
+ gsm_signal d[ 160 ];
+
+ int cc;
+
+ if (!(r = gsm_create())) { /* malloc failed */
+ perror(progname);
+ return -1;
+ }
+ (void)gsm_option(r, GSM_OPT_FAST, &f_fast);
+ (void)gsm_option(r, GSM_OPT_VERBOSE, &f_verbose);
+
+ while ((cc = fread(s, 1, sizeof(s), in)) > 0) {
+
+ if (cc != sizeof(s)) {
+ if (cc >= 0) fprintf(stderr,
+ "%s: incomplete frame (%d byte%s missing) from %s\n",
+ progname, sizeof(s) - cc,
+ "s" + (sizeof(s) - cc == 1),
+ inname ? inname : "stdin" );
+ gsm_destroy(r);
+ errno = 0;
+ return -1;
+ }
+ if (gsm_decode(r, s, d)) {
+ fprintf(stderr, "%s: bad frame in %s\n",
+ progname, inname ? inname : "stdin");
+ gsm_destroy(r);
+ errno = 0;
+ return -1;
+ }
+
+ if ((*output)(d) < 0) {
+ perror(outname);
+ fprintf(stderr, "%s: error writing to %s\n",
+ progname, outname);
+ gsm_destroy(r);
+ return -1;
+ }
+ }
+
+ if (cc < 0) {
+ perror(inname ? inname : "stdin" );
+ fprintf(stderr, "%s: error reading from %s\n", progname,
+ inname ? inname : "stdin");
+ gsm_destroy(r);
+ return -1;
+ }
+
+ gsm_destroy(r);
+ return 0;
+ }
+
+ static int process P1((name), char * name)
+ {
+ int step = 0;
+
+ out = (FILE *)0;
+ in = (FILE *)0;
+
+ outname = (char *)0;
+ inname = (char *)0;
+
+ if (!open_input(name, &instat) || !open_output(name))
+ goto err;
+
+ if ((*(f_decode ? init_output : init_input))()) {
+ fprintf(stderr, "%s: error %s %s\n",
+ progname,
+ f_decode ? "writing header to" : "reading header from",
+ f_decode ? (outname ? outname : "stdout")
+ : (inname ? inname : "stdin"));
+ goto err;
+ }
+
+ if ((*(f_decode ? process_decode : process_encode))())
+ goto err;
+
+ if (fflush(out) < 0 || ferror(out)) {
+ perror(outname ? outname : "stdout");
+ fprintf(stderr, "%s: error writing \"%s\"\n", progname,
+ outname ? outname:"stdout");
+ goto err;
+ }
+
+ if (out != stdout) {
+
+ update_times();
+ update_mode ();
+ update_own ();
+
+ if (fclose(out) < 0) {
+ perror(outname);
+ fprintf(stderr, "%s: error writing \"%s\"\n",
+ progname, outname);
+ goto err;
+ }
+ if (outname != name) free(outname);
+ outname = (char *)0;
+ }
+ out = (FILE *)0;
+ if (in != stdin) {
+ (void)fclose(in), in = (FILE *)0;
+ if (!f_cat && !f_precious) {
+ if (unlink(inname) < 0) {
+ perror(inname);
+ fprintf(stderr,
+ "%s: source \"%s\" not deleted.\n",
+ progname, inname);
+ }
+ goto err;
+ }
+ if (inname != name) free(inname);
+ inname = (char *)0;
+ }
+ return 0;
+
+ /*
+ * Error handling and cleanup:
+ * - error out: close out, unlink it, close in, free the names.
+ * -
+ */
+ err:
+ if (out && out != stdout) {
+ (void)fclose(out), out = (FILE *)0;
+ if (unlink(outname) < 0 && errno != ENOENT && errno != EINTR) {
+ perror(outname);
+ fprintf(stderr, "%s: could not unlink \"%s\"\n",
+ progname, outname);
+ }
+ }
+ if (in && in != stdin) (void)fclose(in), in = (FILE *)0;
+
+ if (inname && inname != name) free(inname);
+ if (outname && outname != name) free(outname);
+
+ return -1;
+ }
+
+ static void version P0()
+ {
+ printf( "%s 1.0, version %s\n",
+ progname,
+ "$Id: toast.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $" );
+ }
+
+ static void help P0()
+ {
+ printf("Usage: %s [-fcpdhvaulsF] [files...]\n", progname);
+ printf("\n");
+
+ printf(" -f force Replace existing files without asking\n");
+ printf(" -c cat Write to stdout, do not remove source files\n");
+ printf(" -d decode Decode data (default is encode)\n");
+ printf(" -p precious Do not delete the source\n");
+ printf("\n");
+
+ printf(" -u u-law Force 8 kHz/8 bit u-law in/output format\n");
+ printf(" -s sun .au Force Sun .au u-law in/output format\n");
+ printf(" -a A-law Force 8 kHz/8 bit A-law in/output format\n");
+ printf(" -l linear Force 16 bit linear in/output format\n");
+ printf("\n");
+
+ printf(" -F fast Sacrifice conformance to performance\n");
+ printf(" -v version Show version information\n");
+ printf(" -h help Print this text\n");
+ printf("\n");
+ }
+
+
+ static void set_format P1((f), struct fmtdesc * f)
+ {
+ if (f_format && f_format != f) {
+ fprintf( stderr,
+ "%s: only one of -[uals] is possible (%s -h for help)\n",
+ progname, progname);
+ exit(1);
+ }
+
+ f_format = f;
+ }
+
+ int main P2((ac, av), int ac, char **av)
+ {
+ int opt;
+ extern int optind;
+
+ parse_argv0( *av );
+
+ while ((opt = getopt(ac, av, "fcdpvhuaslVF")) != EOF)
+ switch (opt) {
+
+ case 'd': f_decode = 1; break;
+ case 'f': f_force = 1; break;
+ case 'c': f_cat = 1; break;
+ case 'p': f_precious = 1; break;
+ case 'F': f_fast = 1; break;
+
+ #ifndef NDEBUG
+ case 'V': f_verbose = 1; break; /* undocumented */
+ #endif
+
+ case 'u': set_format( &f_ulaw ); break;
+ case 'l': set_format( &f_linear ); break;
+ case 'a': set_format( &f_alaw ); break;
+ case 's': set_format( &f_audio ); break;
+
+ case 'v': version(); exit(0);
+ case 'h': help(); exit(0);
+
+ default:
+ fprintf(stderr,
+ "Usage: %s [-fcpdhvuaslF] [files...] (-h for help)\n",
+ progname);
+ exit(1);
+ }
+
+ f_precious |= f_cat;
+
+ av += optind;
+ ac -= optind;
+
+ catch_signals(onintr);
+
+ if (ac <= 0) process( (char *)0 );
+ else while (ac--) process( *av++ );
+
+ exit(0);
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.h:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.h Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,105 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast.h,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #ifndef TOAST_H
+ #define TOAST_H /* Guard against multiple includes */
+
+ #include "config.h"
+
+ #include <sys/types.h>
+ #include <sys/stat.h>
+
+ #include <stdio.h>
+ #include <ctype.h>
+ #include <signal.h>
+
+ #include <errno.h>
+ #ifndef HAS_ERRNO_DECL
+ extern int errno;
+ #endif
+
+ #ifdef HAS_LIMITS_H
+ #include <limits.h>
+ #endif
+
+ #ifdef HAS_FCNTL_H
+ # include <fcntl.h>
+ #endif
+
+ #ifdef HAS_UTIME
+ # ifdef HAS_UTIME_H
+ # include <utime.h>
+ # endif
+ #endif
+
+ #include "gsm.h"
+
+ #ifndef S_ISREG
+ #define S_ISREG(x) ((x) & S_IFREG)
+ #endif /* S_ISREG */
+
+
+ # define READ "rb"
+ # define WRITE "wb"
+ # define O_WRITE_EXCL O_WRONLY|O_CREAT|O_EXCL
+
+ #ifndef SIGHANDLER_T
+ #define SIGHANDLER_T void /* what does a signal handler return? */
+ #endif
+
+
+ #ifdef HAS_STRING_H
+ #include <string.h>
+ #else
+ # ifdef HAS_STRINGS_H
+ # include <strings.h>
+ # else
+ # include "proto.h"
+
+ extern int strlen P((char *));
+ extern char * strcpy P((char *, char *));
+ extern char * strcat P((char *, char *));
+ extern char * strrchr P((char *, int));
+
+ # include "unproto.h"
+ # endif
+ #endif
+
+
+ #ifdef HAS_STDLIB_H
+ #include <stdlib.h>
+ #else
+ # include "proto.h"
+ # ifdef HAS_MALLOC_H
+ # include <malloc.h>
+ # else
+ extern char * malloc P((unsigned));
+ # endif
+ extern int exit P((int));
+ # include "unproto.h"
+ #endif
+
+
+ #ifdef HAS_UNISTD_H
+ # include <unistd.h>
+ #endif
+
+ /*
+ * This suffix is tacked onto/removed from filenames
+ * similar to the way freeze and compress do it.
+ */
+ #define SUFFIX_TOASTED ".gsm"
+
+ #include "proto.h"
+
+ extern int audio_init_input P((void)), audio_init_output P((void));
+ extern int ulaw_input P((gsm_signal*)), ulaw_output P((gsm_signal *));
+ extern int alaw_input P((gsm_signal*)), alaw_output P((gsm_signal *));
+ extern int linear_input P((gsm_signal*)), linear_output P((gsm_signal *));
+
+ #endif /* TOAST_H */
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_alaw.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_alaw.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_alaw.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,333 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_alaw.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #include "toast.h"
+
+ /* toast_alaw.c -- manipulate A-law encoded sound.
+ */
+
+ extern FILE * in, * out;
+
+ #define A2S(x) (a2s[ (unsigned char )(x) ])
+ #define S2A(x) (s2a[ ((unsigned short)(x)) >> 4 ])
+
+ static unsigned short a2s[] = {
+
+ 5120,60160, 320,65200,20480,44032, 1280,64192,
+ 2560,62848, 64,65456,10240,54784, 640,64864,
+ 7168,58112, 448,65072,28672,35840, 1792,63680,
+ 3584,61824, 192,65328,14336,50688, 896,64608,
+ 4096,61184, 256,65264,16384,48128, 1024,64448,
+ 2048,63360, 0,65520, 8192,56832, 512,64992,
+ 6144,59136, 384,65136,24576,39936, 1536,63936,
+ 3072,62336, 128,65392,12288,52736, 768,64736,
+ 5632,59648, 352,65168,22528,41984, 1408,64064,
+ 2816,62592, 96,65424,11264,53760, 704,64800,
+ 7680,57600, 480,65040,30720,33792, 1920,63552,
+ 3840,61568, 224,65296,15360,49664, 960,64544,
+ 4608,60672, 288,65232,18432,46080, 1152,64320,
+ 2304,63104, 32,65488, 9216,55808, 576,64928,
+ 6656,58624, 416,65104,26624,37888, 1664,63808,
+ 3328,62080, 160,65360,13312,51712, 832,64672,
+ 5376,59904, 336,65184,21504,43008, 1344,64128,
+ 2688,62720, 80,65440,10752,54272, 672,64832,
+ 7424,57856, 464,65056,29696,34816, 1856,63616,
+ 3712,61696, 208,65312,14848,50176, 928,64576,
+ 4352,60928, 272,65248,17408,47104, 1088,64384,
+ 2176,63232, 16,65504, 8704,56320, 544,64960,
+ 6400,58880, 400,65120,25600,38912, 1600,63872,
+ 3200,62208, 144,65376,12800,52224, 800,64704,
+ 5888,59392, 368,65152,23552,40960, 1472,64000,
+ 2944,62464, 112,65408,11776,53248, 736,64768,
+ 7936,57344, 496,65024,31744,32768, 1984,63488,
+ 3968,61440, 240,65280,15872,49152, 992,64512,
+ 4864,60416, 304,65216,19456,45056, 1216,64256,
+ 2432,62976, 48,65472, 9728,55296, 608,64896,
+ 6912,58368, 432,65088,27648,36864, 1728,63744,
+ 3456,61952, 176,65344,13824,51200, 864,64640
+ };
+
+
+ static unsigned char s2a[] = {
+
+ 170, 42,234,106,138, 10,202, 74,186, 58,250,122,154, 26,218, 90,
+ 162, 34,226, 98,130, 2,194, 66,178, 50,242,114,146, 18,210, 82,
+ 174, 46, 46,238,238,110,110,142,142, 14, 14,206,206, 78, 78,190,
+ 190, 62, 62,254,254,126,126,158,158, 30, 30,222,222, 94, 94,166,
+ 166, 38, 38, 38, 38,230,230,230,230,102,102,102,102,134,134,134,
+ 134, 6, 6, 6, 6,198,198,198,198, 70, 70, 70, 70,182,182,182,
+ 182, 54, 54, 54, 54,246,246,246,246,118,118,118,118,150,150,150,
+ 150, 22, 22, 22, 22,214,214,214,214, 86, 86, 86, 86,168,168,168,
+ 168, 40, 40, 40, 40, 40, 40, 40, 40,232,232,232,232,232,232,232,
+ 232,104,104,104,104,104,104,104,104,136,136,136,136,136,136,136,
+ 136, 8, 8, 8, 8, 8, 8, 8, 8,200,200,200,200,200,200,200,
+ 200, 72, 72, 72, 72, 72, 72, 72, 72,184,184,184,184,184,184,184,
+ 184, 56, 56, 56, 56, 56, 56, 56, 56,248,248,248,248,248,248,248,
+ 248,120,120,120,120,120,120,120,120,152,152,152,152,152,152,152,
+ 152, 24, 24, 24, 24, 24, 24, 24, 24,216,216,216,216,216,216,216,
+ 216, 88, 88, 88, 88, 88, 88, 88, 88,160,160,160,160,160,160,160,
+ 160, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+ 32,224,224,224,224,224,224,224,224,224,224,224,224,224,224,224,
+ 224, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
+ 96,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
+ 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,
+ 192, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,
+ 176, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
+ 48,240,240,240,240,240,240,240,240,240,240,240,240,240,240,240,
+ 240,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,
+ 112,144,144,144,144,144,144,144,144,144,144,144,144,144,144,144,
+ 144, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16,208,208,208,208,208,208,208,208,208,208,208,208,208,208,208,
+ 208, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
+ 80,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,
+ 172, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
+ 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
+ 44,236,236,236,236,236,236,236,236,236,236,236,236,236,236,236,
+ 236,236,236,236,236,236,236,236,236,236,236,236,236,236,236,236,
+ 236,108,108,108,108,108,108,108,108,108,108,108,108,108,108,108,
+ 108,108,108,108,108,108,108,108,108,108,108,108,108,108,108,108,
+ 108,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,
+ 140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,
+ 140, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,
+ 204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,
+ 204, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+ 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+ 76,188,188,188,188,188,188,188,188,188,188,188,188,188,188,188,
+ 188,188,188,188,188,188,188,188,188,188,188,188,188,188,188,188,
+ 188, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
+ 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
+ 60,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,
+ 252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,
+ 252,124,124,124,124,124,124,124,124,124,124,124,124,124,124,124,
+ 124,124,124,124,124,124,124,124,124,124,124,124,124,124,124,124,
+ 124,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,
+ 156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,
+ 156, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+ 28,220,220,220,220,220,220,220,220,220,220,220,220,220,220,220,
+ 220,220,220,220,220,220,220,220,220,220,220,220,220,220,220,220,
+ 220, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
+ 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
+ 92,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,
+ 164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,
+ 164, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93,221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
+ 221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
+ 221, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29,157,157,157,157,157,157,157,157,157,157,157,157,157,157,157,
+ 157,157,157,157,157,157,157,157,157,157,157,157,157,157,157,157,
+ 157,125,125,125,125,125,125,125,125,125,125,125,125,125,125,125,
+ 125,125,125,125,125,125,125,125,125,125,125,125,125,125,125,125,
+ 125,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,
+ 253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,
+ 253, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
+ 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
+ 61,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,
+ 189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,
+ 189, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+ 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+ 77,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,
+ 205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,
+ 205, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+ 13,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,
+ 141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,
+ 141,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+ 109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+ 109,237,237,237,237,237,237,237,237,237,237,237,237,237,237,237,
+ 237,237,237,237,237,237,237,237,237,237,237,237,237,237,237,237,
+ 237, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+ 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+ 45,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,
+ 173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,
+ 173, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
+ 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
+ 81,209,209,209,209,209,209,209,209,209,209,209,209,209,209,209,
+ 209, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 17,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,
+ 145,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,
+ 113,241,241,241,241,241,241,241,241,241,241,241,241,241,241,241,
+ 241, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
+ 49,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,
+ 177, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+ 65,193,193,193,193,193,193,193,193,193,193,193,193,193,193,193,
+ 193, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1,129,129,129,129,129,129,129,129,129,129,129,129,129,129,129,
+ 129, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97,225,225,225,225,225,225,225,225,225,225,225,225,225,225,225,
+ 225, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,
+ 161, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+ 89,217,217,217,217,217,217,217,217, 25, 25, 25, 25, 25, 25, 25,
+ 25,153,153,153,153,153,153,153,153,121,121,121,121,121,121,121,
+ 121,249,249,249,249,249,249,249,249, 57, 57, 57, 57, 57, 57, 57,
+ 57,185,185,185,185,185,185,185,185, 73, 73, 73, 73, 73, 73, 73,
+ 73,201,201,201,201,201,201,201,201, 9, 9, 9, 9, 9, 9, 9,
+ 9,137,137,137,137,137,137,137,137,105,105,105,105,105,105,105,
+ 105,233,233,233,233,233,233,233,233, 41, 41, 41, 41, 41, 41, 41,
+ 41,169,169,169,169,169,169,169,169, 87, 87, 87, 87, 87, 87, 87,
+ 87,215,215,215,215, 23, 23, 23, 23,151,151,151,151,119,119,119,
+ 119,247,247,247,247, 55, 55, 55, 55,183,183,183,183, 71, 71, 71,
+ 71,199,199,199,199, 7, 7, 7, 7,135,135,135,135,103,103,103,
+ 103,231,231,231,231, 39, 39, 39, 39,167,167,167,167, 95, 95, 95,
+ 95,223,223, 31, 31,159,159,127,127,255,255, 63, 63,191,191, 79,
+ 79,207,207, 15, 15,143,143,111,111,239,239, 47, 47,175,175, 83,
+ 83,211, 19,147,115,243, 51,179, 67,195, 3,131, 99,227, 35,163,
+ 91,219, 27,155,123,251, 59,187, 75,203, 11,139,107,235, 43,171
+ };
+
+ int alaw_input P1((buf), gsm_signal * buf)
+ {
+ int i, c;
+
+ for (i = 0; i < 160 && (c = fgetc(in)) != EOF; i++) buf[i] = A2S( c );
+ if (c == EOF && ferror(in)) return -1;
+ return i;
+ }
+
+ int alaw_output P1((buf), gsm_signal * buf)
+ {
+ int i;
+
+ for (i = 0; i < 160; i++, buf++)
+ if (fputc( S2A( *buf ), out) == EOF) return -1;
+ return 0;
+ }
+
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_audio.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_audio.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_audio.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,103 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_audio.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #include "toast.h"
+
+ /* toast_audio -- functions to manipulate SunOS audio files.
+ *
+ * This is reverse engineered from our present soundfiles
+ * and in no way portable, durable or aesthetically pleasing.
+ */
+
+ extern FILE * in, * out;
+ extern char * inname;
+ extern char * progname;
+
+ extern int (*output) P((gsm_signal *)),
+ (*input ) P((gsm_signal *));
+
+ extern int alaw_input P((gsm_signal *)),
+ ulaw_input P((gsm_signal *)),
+ linear_input P((gsm_signal *));
+
+ extern int ulaw_output P((gsm_signal *));
+
+ static int put_u32 P2((f, u), FILE * f, unsigned long u)
+ {
+ /* Write a 32-bit unsigned value msb first.
+ */
+ if ( putc( (char)((u>>24) & 0x0FF), f) == EOF
+ || putc( (char)((u>>16) & 0x0FF), f) == EOF
+ || putc( (char)((u>> 8) & 0x0FF), f) == EOF
+ || putc( (char)( u & 0x0FF), f) == EOF) return -1;
+
+ return 0;
+ }
+
+ static int get_u32 P2((f, up), FILE * f, unsigned long * up)
+ {
+ /* Read a 32-bit unsigned value msb first.
+ */
+ int i;
+ unsigned long u;
+
+ if ( (i = getc(f)) == EOF
+ || ((u = (unsigned char)i), (i = getc(f)) == EOF)
+ || ((u = (u<<8)|(unsigned char)i), (i = getc(f)) == EOF)
+ || ((u = (u<<8)|(unsigned char)i), (i = getc(f)) == EOF)) return -1;
+ *up = (u<<8)|(unsigned char)i;
+ return 0;
+ }
+
+ int audio_init_input P0()
+ {
+ unsigned long len, enc; /* unsigned 32 bits */
+
+ if ( fgetc(in) != '.'
+ || fgetc(in) != 's'
+ || fgetc(in) != 'n'
+ || fgetc(in) != 'd'
+ || get_u32( in, &len )
+ || get_u32( in, &enc ) /* skip this */
+ || get_u32( in, &enc )
+ || fseek(in, (long)(len - 4*4), 1) < 0) {
+ fprintf(stderr,
+ "%s: bad (missing?) header in Sun audio file \"%s\";\n\
+ Try one of -u, -a, -l instead (%s -h for help).\n",
+ progname, inname ? inname : "stdin", progname);
+ return -1;
+ }
+
+ switch (enc) {
+ case 1: input = ulaw_input; break;
+ case 2: input = alaw_input; break;
+ case 3: input = linear_input; break;
+ default:
+ fprintf(stderr,
+ "%s: warning: file format #%lu for %s not implemented, defaulting to u-law.\n",
+ progname, enc, inname);
+ input = ulaw_input;
+ break;
+ }
+ return 0;
+ }
+
+ int audio_init_output P0()
+ {
+ if ( fputs(".snd", out) == EOF
+ || put_u32(out, 32)
+ || put_u32(out, ~(unsigned long)0)
+ || put_u32(out, 1)
+ || put_u32(out, 8000)
+ || put_u32(out, 1)
+ || put_u32(out, 0)
+ || put_u32(out, 0)) return -1;
+
+ return 0;
+ }
+
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_lin.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_lin.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_lin.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,24 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_lin.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #include "toast.h"
+
+ /* toast_linear.c -- read and write 16 bit linear sound in host byte order.
+ */
+
+ extern FILE *in, *out;
+
+ int linear_input (buf) gsm_signal * buf;
+ {
+ return fread( (char *)buf, sizeof(*buf), 160, in );
+ }
+
+ int linear_output P1((buf), gsm_signal * buf)
+ {
+ return -( fwrite( (char *)buf, sizeof(*buf), 160, out ) != 160 );
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_ulaw.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_ulaw.c:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_ulaw.c Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,621 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/toast_ulaw.c,v 1.1 2005/01/11 18:05:01 dhurjati Exp $ */
+
+ #include "toast.h"
+
+ /* toast_ulaw -- functions to manipulate u-law encoded sound.
+ */
+
+ extern FILE *in, *out;
+
+ #define U2S(x) (u2s[ (unsigned char)(x) ])
+ #define S2U(x) (s2u[ ((unsigned short)(x)) >> 3 ])
+
+ static unsigned short u2s[] = {
+ 33280, 34308, 35336, 36364, 37393, 38421, 39449, 40477,
+ 41505, 42534, 43562, 44590, 45618, 46647, 47675, 48703,
+ 49474, 49988, 50503, 51017, 51531, 52045, 52559, 53073,
+ 53587, 54101, 54616, 55130, 55644, 56158, 56672, 57186,
+ 57572, 57829, 58086, 58343, 58600, 58857, 59114, 59371,
+ 59628, 59885, 60142, 60399, 60656, 60913, 61171, 61428,
+ 61620, 61749, 61877, 62006, 62134, 62263, 62392, 62520,
+ 62649, 62777, 62906, 63034, 63163, 63291, 63420, 63548,
+ 63645, 63709, 63773, 63838, 63902, 63966, 64030, 64095,
+ 64159, 64223, 64287, 64352, 64416, 64480, 64544, 64609,
+ 64657, 64689, 64721, 64753, 64785, 64818, 64850, 64882,
+ 64914, 64946, 64978, 65010, 65042, 65075, 65107, 65139,
+ 65163, 65179, 65195, 65211, 65227, 65243, 65259, 65275,
+ 65291, 65308, 65324, 65340, 65356, 65372, 65388, 65404,
+ 65416, 65424, 65432, 65440, 65448, 65456, 65464, 65472,
+ 65480, 65488, 65496, 65504, 65512, 65520, 65528, 0,
+ 32256, 31228, 30200, 29172, 28143, 27115, 26087, 25059,
+ 24031, 23002, 21974, 20946, 19918, 18889, 17861, 16833,
+ 16062, 15548, 15033, 14519, 14005, 13491, 12977, 12463,
+ 11949, 11435, 10920, 10406, 9892, 9378, 8864, 8350,
+ 7964, 7707, 7450, 7193, 6936, 6679, 6422, 6165,
+ 5908, 5651, 5394, 5137, 4880, 4623, 4365, 4108,
+ 3916, 3787, 3659, 3530, 3402, 3273, 3144, 3016,
+ 2887, 2759, 2630, 2502, 2373, 2245, 2116, 1988,
+ 1891, 1827, 1763, 1698, 1634, 1570, 1506, 1441,
+ 1377, 1313, 1249, 1184, 1120, 1056, 992, 927,
+ 879, 847, 815, 783, 751, 718, 686, 654,
+ 622, 590, 558, 526, 494, 461, 429, 397,
+ 373, 357, 341, 325, 309, 293, 277, 261,
+ 245, 228, 212, 196, 180, 164, 148, 132,
+ 120, 112, 104, 96, 88, 80, 72, 64,
+ 56, 48, 40, 32, 24, 16, 8, 0
+ };
+
+ static unsigned char s2u[] = {
+ 0377,0376,0375,0374,0373,0372,0371,0370,0367,0366,0365,0364,0363,0362,0361,
+ 0360,0357,0357,0356,0356,0355,0355,0354,0354,0353,0353,0352,0352,0351,0351,
+ 0350,0350,0347,0347,0346,0346,0345,0345,0344,0344,0343,0343,0342,0342,0341,
+ 0341,0340,0340,0337,0337,0337,0337,0336,0336,0336,0336,0335,0335,0335,0335,
+ 0334,0334,0334,0334,0333,0333,0333,0333,0332,0332,0332,0332,0331,0331,0331,
+ 0331,0330,0330,0330,0330,0327,0327,0327,0327,0326,0326,0326,0326,0325,0325,
+ 0325,0325,0324,0324,0324,0324,0323,0323,0323,0323,0322,0322,0322,0322,0321,
+ 0321,0321,0321,0320,0320,0320,0320,0317,0317,0317,0317,0317,0317,0317,0317,
+ 0316,0316,0316,0316,0316,0316,0316,0316,0315,0315,0315,0315,0315,0315,0315,
+ 0315,0314,0314,0314,0314,0314,0314,0314,0314,0313,0313,0313,0313,0313,0313,
+ 0313,0313,0312,0312,0312,0312,0312,0312,0312,0312,0311,0311,0311,0311,0311,
+ 0311,0311,0311,0310,0310,0310,0310,0310,0310,0310,0310,0307,0307,0307,0307,
+ 0307,0307,0307,0307,0306,0306,0306,0306,0306,0306,0306,0306,0305,0305,0305,
+ 0305,0305,0305,0305,0305,0304,0304,0304,0304,0304,0304,0304,0304,0303,0303,
+ 0303,0303,0303,0303,0303,0303,0303,0302,0302,0302,0302,0302,0302,0302,0302,
+ 0301,0301,0301,0301,0301,0301,0301,0301,0300,0300,0300,0300,0300,0300,0300,
+ 0300,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,
+ 0277,0277,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,
+ 0276,0276,0276,0275,0275,0275,0275,0275,0275,0275,0275,0275,0275,0275,0275,
+ 0275,0275,0275,0275,0274,0274,0274,0274,0274,0274,0274,0274,0274,0274,0274,
+ 0274,0274,0274,0274,0274,0273,0273,0273,0273,0273,0273,0273,0273,0273,0273,
+ 0273,0273,0273,0273,0273,0273,0272,0272,0272,0272,0272,0272,0272,0272,0272,
+ 0272,0272,0272,0272,0272,0272,0272,0271,0271,0271,0271,0271,0271,0271,0271,
+ 0271,0271,0271,0271,0271,0271,0271,0271,0270,0270,0270,0270,0270,0270,0270,
+ 0270,0270,0270,0270,0270,0270,0270,0270,0270,0267,0267,0267,0267,0267,0267,
+ 0267,0267,0267,0267,0267,0267,0267,0267,0267,0267,0266,0266,0266,0266,0266,
+ 0266,0266,0266,0266,0266,0266,0266,0266,0266,0266,0266,0265,0265,0265,0265,
+ 0265,0265,0265,0265,0265,0265,0265,0265,0265,0265,0265,0265,0264,0264,0264,
+ 0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0263,0263,
+ 0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0262,
+ 0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,
+ 0262,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,
+ 0261,0261,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,
+ 0260,0260,0260,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,
+ 0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,
+ 0257,0257,0257,0257,0257,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,
+ 0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,
+ 0256,0256,0256,0256,0256,0256,0256,0255,0255,0255,0255,0255,0255,0255,0255,
+ 0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,
+ 0255,0255,0255,0255,0255,0255,0255,0255,0255,0254,0254,0254,0254,0254,0254,
+ 0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,
+ 0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0253,0253,0253,0253,
+ 0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,
+ 0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0252,0252,
+ 0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,
+ 0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,
+ 0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,
+ 0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,
+ 0251,0251,0251,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,
+ 0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,
+ 0250,0250,0250,0250,0250,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,
+ 0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,
+ 0247,0247,0247,0247,0247,0247,0247,0246,0246,0246,0246,0246,0246,0246,0246,
+ 0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,
+ 0246,0246,0246,0246,0246,0246,0246,0246,0246,0245,0245,0245,0245,0245,0245,
+ 0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,
+ 0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0244,0244,0244,0244,
+ 0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,
+ 0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0243,0243,
+ 0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,
+ 0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,
+ 0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,
+ 0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,
+ 0242,0242,0242,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,
+ 0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,
+ 0241,0241,0241,0241,0241,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,
+ 0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,
+ 0240,0240,0240,0240,0240,0240,0240,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0040,0040,0040,0040,0040,
+ 0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,
+ 0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0041,0041,
+ 0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,
+ 0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,
+ 0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,
+ 0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,
+ 0042,0042,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,
+ 0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,
+ 0043,0043,0043,0043,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,
+ 0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,
+ 0044,0044,0044,0044,0044,0044,0045,0045,0045,0045,0045,0045,0045,0045,0045,
+ 0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,
+ 0045,0045,0045,0045,0045,0045,0045,0045,0046,0046,0046,0046,0046,0046,0046,
+ 0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,
+ 0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0047,0047,0047,0047,0047,
+ 0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,
+ 0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0050,0050,
+ 0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,
+ 0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,
+ 0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,
+ 0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,
+ 0051,0051,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,
+ 0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,
+ 0052,0052,0052,0052,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,
+ 0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,
+ 0053,0053,0053,0053,0053,0053,0054,0054,0054,0054,0054,0054,0054,0054,0054,
+ 0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,
+ 0054,0054,0054,0054,0054,0054,0054,0054,0055,0055,0055,0055,0055,0055,0055,
+ 0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,
+ 0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0056,0056,0056,0056,0056,
+ 0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,
+ 0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0057,0057,0057,
+ 0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,
+ 0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,
+ 0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,
+ 0060,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,
+ 0061,0061,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,
+ 0062,0062,0062,0063,0063,0063,0063,0063,0063,0063,0063,0063,0063,0063,0063,
+ 0063,0063,0063,0063,0064,0064,0064,0064,0064,0064,0064,0064,0064,0064,0064,
+ 0064,0064,0064,0064,0064,0065,0065,0065,0065,0065,0065,0065,0065,0065,0065,
+ 0065,0065,0065,0065,0065,0065,0066,0066,0066,0066,0066,0066,0066,0066,0066,
+ 0066,0066,0066,0066,0066,0066,0066,0067,0067,0067,0067,0067,0067,0067,0067,
+ 0067,0067,0067,0067,0067,0067,0067,0067,0070,0070,0070,0070,0070,0070,0070,
+ 0070,0070,0070,0070,0070,0070,0070,0070,0070,0071,0071,0071,0071,0071,0071,
+ 0071,0071,0071,0071,0071,0071,0071,0071,0071,0071,0072,0072,0072,0072,0072,
+ 0072,0072,0072,0072,0072,0072,0072,0072,0072,0072,0072,0073,0073,0073,0073,
+ 0073,0073,0073,0073,0073,0073,0073,0073,0073,0073,0073,0073,0074,0074,0074,
+ 0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0075,0075,
+ 0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,
+ 0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,
+ 0076,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,
+ 0077,0077,0100,0100,0100,0100,0100,0100,0100,0100,0101,0101,0101,0101,0101,
+ 0101,0101,0101,0102,0102,0102,0102,0102,0102,0102,0102,0103,0103,0103,0103,
+ 0103,0103,0103,0103,0104,0104,0104,0104,0104,0104,0104,0104,0105,0105,0105,
+ 0105,0105,0105,0105,0105,0106,0106,0106,0106,0106,0106,0106,0106,0107,0107,
+ 0107,0107,0107,0107,0107,0107,0110,0110,0110,0110,0110,0110,0110,0110,0111,
+ 0111,0111,0111,0111,0111,0111,0111,0112,0112,0112,0112,0112,0112,0112,0112,
+ 0113,0113,0113,0113,0113,0113,0113,0113,0114,0114,0114,0114,0114,0114,0114,
+ 0114,0115,0115,0115,0115,0115,0115,0115,0115,0116,0116,0116,0116,0116,0116,
+ 0116,0116,0117,0117,0117,0117,0117,0117,0117,0117,0120,0120,0120,0120,0121,
+ 0121,0121,0121,0122,0122,0122,0122,0123,0123,0123,0123,0124,0124,0124,0124,
+ 0125,0125,0125,0125,0126,0126,0126,0126,0127,0127,0127,0127,0130,0130,0130,
+ 0130,0131,0131,0131,0131,0132,0132,0132,0132,0133,0133,0133,0133,0134,0134,
+ 0134,0134,0135,0135,0135,0135,0136,0136,0136,0136,0137,0137,0137,0137,0140,
+ 0140,0141,0141,0142,0142,0143,0143,0144,0144,0145,0145,0146,0146,0147,0147,
+ 0150,0150,0150,0151,0151,0152,0152,0153,0153,0154,0154,0155,0155,0156,0156,
+ 0157,0157,0160,0161,0162,0163,0164,0165,0166,0167,0170,0171,0172,0173,0174,
+ 0175,0176
+ };
+
+ int ulaw_input P1((buf), gsm_signal * buf)
+ {
+ int i, c;
+
+ for (i = 0; i < 160 && (c = fgetc(in)) != EOF; i++) buf[i] = U2S(c);
+ if (c == EOF && ferror(in)) return -1;
+ return i;
+ }
+
+ int ulaw_output P1((buf), gsm_signal * buf)
+ {
+ int i;
+
+ for(i = 0; i < 160; i++, buf++)
+ if (fputc( (char)S2U( (unsigned short)*buf ), out) == EOF)
+ return -1;
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/unproto.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/unproto.h:1.1
*** /dev/null Tue Jan 11 12:05:45 2005
--- llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/unproto.h Tue Jan 11 12:05:01 2005
***************
*** 0 ****
--- 1,23 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /home/vadve/shared/PublicCVS/llvm-test/MultiSource/Benchmarks/mediabench/gsm/toast/unproto.h,v 1.1 2005/01/11 18:05:01 dhurjati Exp $*/
+
+ #ifdef PROTO_H /* sic */
+ #undef PROTO_H
+
+ #undef P
+ #undef P0
+ #undef P1
+ #undef P2
+ #undef P3
+ #undef P4
+ #undef P5
+ #undef P6
+ #undef P7
+ #undef P8
+
+ #endif /* PROTO_H */
More information about the llvm-commits
mailing list