From cc8185df42672bc91a79510cebdc4310fd2ba69a Mon Sep 17 00:00:00 2001 From: Packit Date: Sep 21 2020 09:09:44 +0000 Subject: gsm-1.0.17 base --- diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..2abe4ef Binary files /dev/null and b/.DS_Store differ diff --git a/._.DS_Store b/._.DS_Store new file mode 100644 index 0000000..76e2122 Binary files /dev/null and b/._.DS_Store differ diff --git a/._COPYRIGHT b/._COPYRIGHT new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/._COPYRIGHT differ diff --git a/._ChangeLog b/._ChangeLog new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/._ChangeLog differ diff --git a/._INSTALL b/._INSTALL new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/._INSTALL differ diff --git a/._MACHINES b/._MACHINES new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/._MACHINES differ diff --git a/._MANIFEST b/._MANIFEST new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/._MANIFEST differ diff --git a/._Makefile b/._Makefile new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/._Makefile differ diff --git a/._README b/._README new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/._README differ diff --git a/._add-test b/._add-test new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._add-test differ diff --git a/._bin b/._bin new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._bin differ diff --git a/._inc b/._inc new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._inc differ diff --git a/._lib b/._lib new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._lib differ diff --git a/._man b/._man new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._man differ diff --git a/._src b/._src new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._src differ diff --git a/._tls b/._tls new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._tls differ diff --git a/._tst b/._tst new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/._tst differ diff --git a/COPYRIGHT b/COPYRIGHT new file mode 100644 index 0000000..28fbb3c --- /dev/null +++ b/COPYRIGHT @@ -0,0 +1,35 @@ +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 + + oOo + +Since the original terms of 15 years ago maybe do not make our +intentions completely clear given today's refined usage of the legal +terms, we append this additional permission: + + Permission to use, copy, modify, and distribute this software + for any purpose with or without fee is hereby granted, + 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. + +Berkeley/Bremen, 05.04.2009 +Jutta Degener +Carsten Bormann diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..f15352b --- /dev/null +++ b/ChangeLog @@ -0,0 +1,113 @@ +Tue Jun 27 17:59:30 2017 + + * Release 1.0 Patchlevel 17 + New email addresses in the README. + Avoid left-shifting signed integers. + Don't print longwords using %d or %ld, cast them to (long) first. + Don't compare longwords as longs in addtest, we only care for the + lower 32 bits. (The math works, but the test failed.) + +Sat Sep 17 14:50:55 2016 + + * Release 1.0 Patchlevel 16 + New email addresses in the manual pages (patch 16) + Removed a stray .orig file (in patch 15) + +Sun Apr 5 04:53:07 2009 Jutta Degener (jutta@pobox.com) + + * Release 1.0 Patchlevel 13 + COPYRIGHT: exploring the deeper meaning and cultural + history of the word "any". + +Fri Jun 2 06:27:56 2006 Jutta Degener (jutta@pobox.com) + + * Release 1.0 Patchlevel 12 + src/code.c: removed modifiable static storage that made the library + non-reentrant. (Thanks to Paul Gibbs for pointing out the bug.) + +Sat Mar 18 11:48:28 2006 Jutta Degener (jutta@pobox.com) + + * Release 1.0 Patchlevel 11 + src/gsm_implode.c: fix WAV49 implode + move source archive location + +Fri Jul 5 19:26:37 1996 Jutta Degener (jutta@cs.tu-berlin.de) + + * Release 1.0 Patchlevel 10 + src/toast_alaw.c: exchanged A-law tables for something + slightly more A-law. + +Tue Jul 2 12:18:20 1996 Jutta Degener (jutta@cs.tu-berlin.de) + + * Release 1.0 Patchlevel 9 + src/long_term.c: in FLOAT_MUL mode, an array was accessed past its end + src/gsm_option.c: three options related to WAV #49 packing + src/gsm_encode.c: support WAV #49-style encoding. + src/gsm_decode.c: support WAV #49-style decoding. + tls/sour.c: generate the WAV bit shifting code, encode + tls/ginger.c: generate the WAV bit shifting code, decode + The WAV code goes back to an inofficial patch #8 that + Jeff Chilton sent us (hence the jump from 7 to 9). + src/toast.c: add _fsetmode() calls to set stdin/stdout to + binary (from an OS/2 port by Arnd Gronenberg.) + +Tue Mar 7 01:55:10 1995 Jutta Degener (jutta@cs.tu-berlin.de) + + * Release 1.0 Patchlevel 7 + src/long_term.c: Yet another 16-bit overflow + src/toast.c: -C option to toast, cuts LPC time + src/gsm_option.c: corresponding LPC_CUT option to GSM library + +Fri Dec 30 23:33:50 1994 Jutta Degener (jutta@cs.tu-berlin.de) + + * Release 1.0 Patchlevel 6 + src/lpc.c: fixed 16-bit addition overflow in Autocorrelation code + src/add.c: gsm_L_asl should fall back on gsm_L_asr, not gsm_asr + +Mon Nov 28 20:49:57 1994 Jutta Degener (jutta@cs.tu-berlin.de) + + * Release 1.0 Patchlevel 5 + src/toast_audio.c: initialization should return -1 on error + src/gsm_destroy.c: #include configuration header file + src/add.c: gsm_sub should cast its parameters to longword + man/*: bug reports to {jutta,cabo}@cs.tu-berlin.de, not to toast@tub + inc/private.h: longword long by default, not int + inc/toast.h: read/write fopen modes "rb" and "wb", not just "r" + src/toast.c: better (or different, anyway) error handling in process() + +Tue May 10 19:41:34 1994 Jutta Degener (jutta at kugelbus) + + * Release 1.0 Patchlevel 4 + inc/private.h: GSM_ADD should cast to ulongword, not to unsigned. + src/long_term.c: missing cast to longword. + add-test/add_test.c: Test macros too, not only functions, + thanks to Simao Ferraz de Campos Neto, simao@dragon.cpqd.ansp.br + General cleanup: remove unused variables, add function prototypes. + +Tue Jan 25 22:53:40 1994 Jutta Degener (jutta at kugelbus) + + * Release 1.0 Patchlevel 3 + changed rpe.c's STEP macro to work with 16-bit integers, + thanks to Dr Alex Lee (alexlee@solomon.technet.sg); + removed non-fatal bugs from add-test.dta, private.h + and toast_audio.c, thanks to P. Emanuelsson. + +Fri Jan 29 19:02:12 1993 Jutta Degener (jutta at kraftbus) + + * Release 1.0 Patchlevel 2 + fixed L_add(0,-1) in src/add.c and inc/private.h, + thanks to Raphael Trommer at AT&T Bell Laboratories; + various other ANSI C compatibility details + +Fri Oct 30 17:58:54 1992 Jutta Degener (jutta at kraftbus) + + * Release 1.0 Patchlevel 1 + Switched uid/gid in toast's [f]chown calls. + +Wed Oct 28 14:12:35 1992 Carsten Bormann (cabo at kubus) + + * Release 1.0: released + 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. + diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..5850304 --- /dev/null +++ b/INSTALL @@ -0,0 +1,99 @@ +How to get started: + + Edit the Makefile. + + You should configure a few machine-dependencies and what + compiler you want to use. + + The code works both with ANSI and K&R-C. Use + -DNeedFunctionPrototypes to compile with, or + -UNeedFunctionPrototypes to compile without, function + prototypes in the header files. + + Make addtst + + The "add" program that will be compiled and run checks whether + the basic math functions of the gsm library work with your + compiler. If it prints anything to stderr, complain (to us). + + Edit inc/config.h. + + Make + + Local versions of the gsm library and the "compress"-like filters + toast, untoast and tcat will be generated. + + If the compilation aborts because of a missing function, + declaration, or header file, see if there's something in + inc/config.h to work around it. If not, complain. + + Try it + + Grab an audio file from somewhere (raw u-law or Sun .au is fine, + linear 16-bit in host byte order will do), copy it, toast it, + untoast it, and listen to the result. + + The GSM-encoded and -decoded audio should have the quality + of a good phone line. If the resulting audio is noisier than + your original, or if you hear compression artifacts, complain; + that's a bug in our software, not a bug in the GSM encoding + standard itself. + +Installation + + You can install the gsm library interface, or the toast binaries, + or both. + + Edit the Makefile + + Fill in the directories where you want to install the + library, header files, manual pages, and binaries. + + Turn off the installation of one half of the distribution + (i.e., gsm library or toast binaries) by not setting the + corresponding directory root Makefile macro. + + make install + + will install the programs "toast" with two links named + "tcat" and "untoast", and the gsm library "libgsm.a" with + a "gsm.h" header file, and their respective manual pages. + + +Optimizing + + This code was developed on a machine without an integer + multiplication instruction, where we obtained the fastest result by + replacing some of the integer multiplications with floating point + multiplications. + + If your machine does multiply integers fast enough, + leave USE_FLOAT_MUL undefined. The results should be the + same in both cases. + + On machines with fast floating point arithmetic, defining + both USE_FLOAT_MUL and FAST makes a run-time library + option available that will (in a few crucial places) use + ``native'' floating point operations rather than the bit-by-bit + defined ones of the GSM standard. If you use this fast + option, the outcome will not be bitwise identical to the + results prescribed by the standard, but it is compatible with + the standard encoding, and a user is unlikely to notice a + difference. + + +Bug Reports + + Please direct bug reports, questions, and comments to + jutta@cs.tu-berlin.de and cabo@informatik.uni-bremen.de. + + +Good luck, + + Jutta Degener, + Carsten Bormann + +-- +Copyright 1992, 1993, 1994, by Jutta Degener and Carsten Bormann, +Technische Universitaet Berlin. See the accompanying file "COPYRIGHT" +for details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE. diff --git a/MACHINES b/MACHINES new file mode 100644 index 0000000..9f9e69b --- /dev/null +++ b/MACHINES @@ -0,0 +1,11 @@ +The gsm library has been tested successfully on the following platforms: + +- Various Sun4s running SunOS 4.1.2 +- SPARC1 (SunOS 4.1.1) +- Integrated Solutions 68k Optimum running 4.3BSD UNIX with a Green Hills cc +- NeXTstation running NeXT-OS/Mach 3.0 +- No-name AT/386 with Xenix 2.3.2 (using -DSTUPID_COMPILER) +- RS/6000-350 running AIX 3.2.0 +- RS/6000-320 running AIX 3.1.5 +- Alliant FX80 (Concentrix 5.7) +- SGI Indigo XS4000 (IRIX 4.0.5F) diff --git a/MANIFEST b/MANIFEST new file mode 100644 index 0000000..6db3b2a --- /dev/null +++ b/MANIFEST @@ -0,0 +1,59 @@ +gsm-1.0/COPYRIGHT +gsm-1.0/ChangeLog +gsm-1.0/INSTALL +gsm-1.0/MACHINES +gsm-1.0/MANIFEST +gsm-1.0/Makefile +gsm-1.0/README +gsm-1.0/add-test/add_test.c +gsm-1.0/add-test/add_test.dta +gsm-1.0/inc/gsm.h +gsm-1.0/inc/proto.h +gsm-1.0/inc/unproto.h +gsm-1.0/inc/config.h +gsm-1.0/inc/private.h +gsm-1.0/inc/toast.h +gsm-1.0/man/bitter.1 +gsm-1.0/man/gsm.3 +gsm-1.0/man/gsm_explode.3 +gsm-1.0/man/gsm_print.3 +gsm-1.0/man/gsm_option.3 +gsm-1.0/man/toast.1 +gsm-1.0/src/add.c +gsm-1.0/src/code.c +gsm-1.0/src/debug.c +gsm-1.0/src/decode.c +gsm-1.0/src/gsm_destroy.c +gsm-1.0/src/gsm_decode.c +gsm-1.0/src/gsm_encode.c +gsm-1.0/src/gsm_explode.c +gsm-1.0/src/gsm_implode.c +gsm-1.0/src/gsm_create.c +gsm-1.0/src/gsm_print.c +gsm-1.0/src/gsm_option.c +gsm-1.0/src/long_term.c +gsm-1.0/src/lpc.c +gsm-1.0/src/preprocess.c +gsm-1.0/src/rpe.c +gsm-1.0/src/short_term.c +gsm-1.0/src/table.c +gsm-1.0/src/toast.c +gsm-1.0/src/toast_alaw.c +gsm-1.0/src/toast_audio.c +gsm-1.0/src/toast_lin.c +gsm-1.0/src/toast_ulaw.c +gsm-1.0/tls/bitter.c +gsm-1.0/tls/bitter.dta +gsm-1.0/tls/taste.c +gsm-1.0/tls/taste.h +gsm-1.0/tls/sweet.c +gsm-1.0/tls/sour.c +gsm-1.0/tls/sour1.dta +gsm-1.0/tls/sour2.dta +gsm-1.0/tls/ginger.c +gsm-1.0/tst/cod2lin.c +gsm-1.0/tst/cod2txt.c +gsm-1.0/tst/gsm2cod.c +gsm-1.0/tst/lin2cod.c +gsm-1.0/tst/lin2txt.c +gsm-1.0/tst/run diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..d5c0c90 --- /dev/null +++ b/Makefile @@ -0,0 +1,494 @@ +# Copyright 1992-1996 by Jutta Degener and Carsten Bormann, Technische +# Universitaet Berlin. See the accompanying file "COPYRIGHT" for +# details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE. + +# Machine- or installation dependent flags you should configure to port + +SASR = -DSASR +######### Define SASR if >> is a signed arithmetic shift (-1 >> 1 == -1) + +# MULHACK = -DUSE_FLOAT_MUL +######### Define this if your host multiplies floats faster than integers, +######### e.g. on a SPARCstation. + +# FAST = -DFAST +######### Define together with USE_FLOAT_MUL to enable the GSM library's +######### approximation option for incorrect, but good-enough results. + +# LTP_CUT = -DLTP_CUT +LTP_CUT = +######### Define to enable the GSM library's long-term correlation +######### approximation option---faster, but worse; works for +######### both integer and floating point multiplications. +######### This flag is still in the experimental stage. + +WAV49 = -DWAV49 +# WAV49 = +######### Define to enable the GSM library's option to pack GSM frames +######### in the style used by the WAV #49 format. If you want to write +######### a tool that produces .WAV files which contain GSM-encoded data, +######### define this, and read about the GSM_OPT_WAV49 option in the +######### manual page on gsm_option(3). + +# Choose a compiler. The code works both with ANSI and K&R-C. +# Use -DNeedFunctionPrototypes to compile with, -UNeedFunctionPrototypes to +# compile without, function prototypes in the header files. +# +# You can use the -DSTUPID_COMPILER to circumvent some compilers' +# static limits regarding the number of subexpressions in a statement. + +# CC = cc +# CCFLAGS = -c -DSTUPID_COMPILER + +# CC = /usr/lang/acc +# CCFLAGS = -c -O + +CC = gcc -ansi -pedantic +CCFLAGS = -c -O2 -DNeedFunctionPrototypes=1 -Wall -Wno-comment + +LD = $(CC) + +# LD = gcc +# LDFLAGS = + + +# If your compiler needs additional flags/libraries, regardless of +# the source compiled, configure them here. + +# CCINC = -I/usr/gnu/lib/gcc-2.1/gcc-lib/sparc-sun-sunos4.1.2/2.1/include +######### Includes needed by $(CC) + +# LDINC = -L/usr/gnu/lib/gcc-2.1/gcc-lib/sparc-sun-sunos4.1.2/2.1 +######### Library paths needed by $(LD) + +# LDLIB = -lgcc +######### Additional libraries needed by $(LD) + + +# Where do you want to install libraries, binaries, a header file +# and the manual pages? +# +# Leave INSTALL_ROOT empty (or just don't execute "make install") to +# not install gsm and toast outside of this directory. + +INSTALL_ROOT = + +# Where do you want to install the gsm library, header file, and manpages? +# +# Leave GSM_INSTALL_ROOT empty to not install the GSM library outside of +# this directory. + +GSM_INSTALL_ROOT = $(INSTALL_ROOT) +GSM_INSTALL_LIB = $(GSM_INSTALL_ROOT)/lib +GSM_INSTALL_INC = $(GSM_INSTALL_ROOT)/inc +GSM_INSTALL_MAN = $(GSM_INSTALL_ROOT)/man/man3 + + +# Where do you want to install the toast binaries and their manpage? +# +# Leave TOAST_INSTALL_ROOT empty to not install the toast binaries outside +# of this directory. + +TOAST_INSTALL_ROOT = $(INSTALL_ROOT) +TOAST_INSTALL_BIN = $(TOAST_INSTALL_ROOT)/bin +TOAST_INSTALL_MAN = $(TOAST_INSTALL_ROOT)/man/man1 + +# Other tools + +SHELL = /bin/sh +LN = ln +BASENAME = basename +AR = ar +ARFLAGS = cr +RMFLAGS = +FIND = find +COMPRESS = compress +COMPRESSFLAGS = +# RANLIB = true +RANLIB = ranlib + +# +# You shouldn't have to configure below this line if you're porting. +# + + +# Local Directories + +ROOT = . +ADDTST = $(ROOT)/add-test +TST = $(ROOT)/tst +MAN = $(ROOT)/man +BIN = $(ROOT)/bin +SRC = $(ROOT)/src +LIB = $(ROOT)/lib +TLS = $(ROOT)/tls +INC = $(ROOT)/inc + +# Flags + +# DEBUG = -DNDEBUG +######### Remove -DNDEBUG to enable assertions. + +CFLAGS = $(CCFLAGS) $(SASR) $(DEBUG) $(MULHACK) $(FAST) $(LTP_CUT) \ + $(WAV49) $(CCINC) -I$(INC) +######### It's $(CC) $(CFLAGS) + +LFLAGS = $(LDFLAGS) $(LDINC) +######### It's $(LD) $(LFLAGS) + + +# Targets + +LIBGSM = $(LIB)/libgsm.a + +TOAST = $(BIN)/toast +UNTOAST = $(BIN)/untoast +TCAT = $(BIN)/tcat + +# Headers + +GSM_HEADERS = $(INC)/gsm.h + +HEADERS = $(INC)/proto.h \ + $(INC)/unproto.h \ + $(INC)/config.h \ + $(INC)/private.h \ + $(INC)/gsm.h \ + $(INC)/toast.h \ + $(TLS)/taste.h + +# Sources + +GSM_SOURCES = $(SRC)/add.c \ + $(SRC)/code.c \ + $(SRC)/debug.c \ + $(SRC)/decode.c \ + $(SRC)/long_term.c \ + $(SRC)/lpc.c \ + $(SRC)/preprocess.c \ + $(SRC)/rpe.c \ + $(SRC)/gsm_destroy.c \ + $(SRC)/gsm_decode.c \ + $(SRC)/gsm_encode.c \ + $(SRC)/gsm_explode.c \ + $(SRC)/gsm_implode.c \ + $(SRC)/gsm_create.c \ + $(SRC)/gsm_print.c \ + $(SRC)/gsm_option.c \ + $(SRC)/short_term.c \ + $(SRC)/table.c + +TOAST_SOURCES = $(SRC)/toast.c \ + $(SRC)/toast_lin.c \ + $(SRC)/toast_ulaw.c \ + $(SRC)/toast_alaw.c \ + $(SRC)/toast_audio.c + +SOURCES = $(GSM_SOURCES) \ + $(TOAST_SOURCES) \ + $(ADDTST)/add_test.c \ + $(TLS)/sour.c \ + $(TLS)/ginger.c \ + $(TLS)/sour1.dta \ + $(TLS)/sour2.dta \ + $(TLS)/bitter.c \ + $(TLS)/bitter.dta \ + $(TLS)/taste.c \ + $(TLS)/sweet.c \ + $(TST)/cod2lin.c \ + $(TST)/cod2txt.c \ + $(TST)/gsm2cod.c \ + $(TST)/lin2cod.c \ + $(TST)/lin2txt.c + +# Object files + +GSM_OBJECTS = $(SRC)/add.o \ + $(SRC)/code.o \ + $(SRC)/debug.o \ + $(SRC)/decode.o \ + $(SRC)/long_term.o \ + $(SRC)/lpc.o \ + $(SRC)/preprocess.o \ + $(SRC)/rpe.o \ + $(SRC)/gsm_destroy.o \ + $(SRC)/gsm_decode.o \ + $(SRC)/gsm_encode.o \ + $(SRC)/gsm_explode.o \ + $(SRC)/gsm_implode.o \ + $(SRC)/gsm_create.o \ + $(SRC)/gsm_print.o \ + $(SRC)/gsm_option.o \ + $(SRC)/short_term.o \ + $(SRC)/table.o + +TOAST_OBJECTS = $(SRC)/toast.o \ + $(SRC)/toast_lin.o \ + $(SRC)/toast_ulaw.o \ + $(SRC)/toast_alaw.o \ + $(SRC)/toast_audio.o + +OBJECTS = $(GSM_OBJECTS) $(TOAST_OBJECTS) + +# Manuals + +GSM_MANUALS = $(MAN)/gsm.3 \ + $(MAN)/gsm_explode.3 \ + $(MAN)/gsm_option.3 \ + $(MAN)/gsm_print.3 + +TOAST_MANUALS = $(MAN)/toast.1 + +MANUALS = $(GSM_MANUALS) $(TOAST_MANUALS) $(MAN)/bitter.1 + +# Other stuff in the distribution + +STUFF = ChangeLog \ + INSTALL \ + MACHINES \ + MANIFEST \ + Makefile \ + README \ + $(ADDTST)/add_test.dta \ + $(TLS)/bitter.dta \ + $(TST)/run + + +# Install targets + +GSM_INSTALL_TARGETS = \ + $(GSM_INSTALL_LIB)/libgsm.a \ + $(GSM_INSTALL_INC)/gsm.h \ + $(GSM_INSTALL_MAN)/gsm.3 \ + $(GSM_INSTALL_MAN)/gsm_explode.3 \ + $(GSM_INSTALL_MAN)/gsm_option.3 \ + $(GSM_INSTALL_MAN)/gsm_print.3 + +TOAST_INSTALL_TARGETS = \ + $(TOAST_INSTALL_BIN)/toast \ + $(TOAST_INSTALL_BIN)/tcat \ + $(TOAST_INSTALL_BIN)/untoast \ + $(TOAST_INSTALL_MAN)/toast.1 + + +# Default rules + +.c.o: + $(CC) $(CFLAGS) $? + @-mv `$(BASENAME) $@` $@ > /dev/null 2>&1 + +# Target rules + +all: $(LIBGSM) $(TOAST) $(TCAT) $(UNTOAST) + @-echo $(ROOT): Done. + +tst: $(TST)/lin2cod $(TST)/cod2lin $(TOAST) $(TST)/test-result + @-echo tst: Done. + +addtst: $(ADDTST)/add $(ADDTST)/add_test.dta + $(ADDTST)/add < $(ADDTST)/add_test.dta > /dev/null + @-echo addtst: Done. + +misc: $(TLS)/sweet $(TLS)/bitter $(TLS)/sour $(TLS)/ginger \ + $(TST)/lin2txt $(TST)/cod2txt $(TST)/gsm2cod + @-echo misc: Done. + +install: toastinstall gsminstall + @-echo install: Done. + + +# The basic API: libgsm + +$(LIBGSM): $(LIB) $(GSM_OBJECTS) + -rm $(RMFLAGS) $(LIBGSM) + $(AR) $(ARFLAGS) $(LIBGSM) $(GSM_OBJECTS) + $(RANLIB) $(LIBGSM) + + +# Toast, Untoast and Tcat -- the compress-like frontends to gsm. + +$(TOAST): $(BIN) $(TOAST_OBJECTS) $(LIBGSM) + $(LD) $(LFLAGS) -o $(TOAST) $(TOAST_OBJECTS) $(LIBGSM) $(LDLIB) + +$(UNTOAST): $(BIN) $(TOAST) + -rm $(RMFLAGS) $(UNTOAST) + $(LN) $(TOAST) $(UNTOAST) + +$(TCAT): $(BIN) $(TOAST) + -rm $(RMFLAGS) $(TCAT) + $(LN) $(TOAST) $(TCAT) + + +# The local bin and lib directories + +$(BIN): + if [ ! -d $(BIN) ] ; then mkdir $(BIN) ; fi + +$(LIB): + if [ ! -d $(LIB) ] ; then mkdir $(LIB) ; fi + + +# Installation + +gsminstall: + -if [ x"$(GSM_INSTALL_ROOT)" != x ] ; then \ + make $(GSM_INSTALL_TARGETS) ; \ + fi + +toastinstall: + -if [ x"$(TOAST_INSTALL_ROOT)" != x ]; then \ + make $(TOAST_INSTALL_TARGETS); \ + fi + +gsmuninstall: + -if [ x"$(GSM_INSTALL_ROOT)" != x ] ; then \ + rm $(RMFLAGS) $(GSM_INSTALL_TARGETS) ; \ + fi + +toastuninstall: + -if [ x"$(TOAST_INSTALL_ROOT)" != x ] ; then \ + rm $(RMFLAGS) $(TOAST_INSTALL_TARGETS); \ + fi + +$(TOAST_INSTALL_BIN)/toast: $(TOAST) + -rm $@ + cp $(TOAST) $@ + chmod 755 $@ + +$(TOAST_INSTALL_BIN)/untoast: $(TOAST_INSTALL_BIN)/toast + -rm $@ + ln $? $@ + +$(TOAST_INSTALL_BIN)/tcat: $(TOAST_INSTALL_BIN)/toast + -rm $@ + ln $? $@ + +$(TOAST_INSTALL_MAN)/toast.1: $(MAN)/toast.1 + -rm $@ + cp $? $@ + chmod 444 $@ + +$(GSM_INSTALL_MAN)/gsm.3: $(MAN)/gsm.3 + -rm $@ + cp $? $@ + chmod 444 $@ + +$(GSM_INSTALL_MAN)/gsm_option.3: $(MAN)/gsm_option.3 + -rm $@ + cp $? $@ + chmod 444 $@ + +$(GSM_INSTALL_MAN)/gsm_explode.3: $(MAN)/gsm_explode.3 + -rm $@ + cp $? $@ + chmod 444 $@ + +$(GSM_INSTALL_MAN)/gsm_print.3: $(MAN)/gsm_print.3 + -rm $@ + cp $? $@ + chmod 444 $@ + +$(GSM_INSTALL_INC)/gsm.h: $(INC)/gsm.h + -rm $@ + cp $? $@ + chmod 444 $@ + +$(GSM_INSTALL_LIB)/libgsm.a: $(LIBGSM) + -rm $@ + cp $? $@ + chmod 444 $@ + + +# Distribution + +dist: gsm-1.0.tar.Z + @echo dist: Done. + +gsm-1.0.tar.Z: $(STUFF) $(SOURCES) $(HEADERS) $(MANUALS) + ( cd $(ROOT)/..; \ + tar cvf - `cat $(ROOT)/gsm-1.0/MANIFEST \ + | sed '/^#/d'` \ + ) | $(COMPRESS) $(COMPRESSFLAGS) > $(ROOT)/gsm-1.0.tar.Z + +# Clean + +uninstall: toastuninstall gsmuninstall + @-echo uninstall: Done. + +semi-clean: + -rm $(RMFLAGS) */*.o \ + $(TST)/lin2cod $(TST)/lin2txt \ + $(TST)/cod2lin $(TST)/cod2txt \ + $(TST)/gsm2cod \ + $(TST)/*.*.* + -$(FIND) . \( -name core -o -name foo \) \ + -print | xargs rm $(RMFLAGS) + +clean: semi-clean + -rm $(RMFLAGS) $(LIBGSM) $(ADDTST)/add \ + $(TOAST) $(TCAT) $(UNTOAST) \ + $(ROOT)/gsm-1.0.tar.Z + + +# Two tools that helped me generate gsm_encode.c and gsm_decode.c, +# but aren't generally needed to port this. + +$(TLS)/sweet: $(TLS)/sweet.o $(TLS)/taste.o + $(LD) $(LFLAGS) -o $(TLS)/sweet \ + $(TLS)/sweet.o $(TLS)/taste.o $(LDLIB) + +$(TLS)/bitter: $(TLS)/bitter.o $(TLS)/taste.o + $(LD) $(LFLAGS) -o $(TLS)/bitter \ + $(TLS)/bitter.o $(TLS)/taste.o $(LDLIB) + +# A version of the same family that Jeff Chilton used to implement +# the WAV #49 GSM format. + +$(TLS)/ginger: $(TLS)/ginger.o $(TLS)/taste.o + $(LD) $(LFLAGS) -o $(TLS)/ginger \ + $(TLS)/ginger.o $(TLS)/taste.o $(LDLIB) + +$(TLS)/sour: $(TLS)/sour.o $(TLS)/taste.o + $(LD) $(LFLAGS) -o $(TLS)/sour \ + $(TLS)/sour.o $(TLS)/taste.o $(LDLIB) + +# Run $(ADDTST)/add < $(ADDTST)/add_test.dta to make sure the +# basic arithmetic functions work as intended. + +$(ADDTST)/add: $(ADDTST)/add_test.o + $(LD) $(LFLAGS) -o $(ADDTST)/add $(ADDTST)/add_test.o $(LDLIB) + + +# Various conversion programs between linear, text, .gsm and the code +# format used by the tests we ran (.cod). We paid for the test data, +# so I guess we can't just provide them with this package. Still, +# if you happen to have them lying around, here's the code. +# +# You can use gsm2cod | cod2txt independently to look at what's +# coded inside the compressed frames, although this shouldn't be +# hard to roll on your own using the gsm_print() function from +# the API. + + +$(TST)/test-result: $(TST)/lin2cod $(TST)/cod2lin $(TOAST) $(TST)/run + ( cd $(TST); ./run ) + +$(TST)/lin2txt: $(TST)/lin2txt.o $(LIBGSM) + $(LD) $(LFLAGS) -o $(TST)/lin2txt \ + $(TST)/lin2txt.o $(LIBGSM) $(LDLIB) + +$(TST)/lin2cod: $(TST)/lin2cod.o $(LIBGSM) + $(LD) $(LFLAGS) -o $(TST)/lin2cod \ + $(TST)/lin2cod.o $(LIBGSM) $(LDLIB) + +$(TST)/gsm2cod: $(TST)/gsm2cod.o $(LIBGSM) + $(LD) $(LFLAGS) -o $(TST)/gsm2cod \ + $(TST)/gsm2cod.o $(LIBGSM) $(LDLIB) + +$(TST)/cod2txt: $(TST)/cod2txt.o $(LIBGSM) + $(LD) $(LFLAGS) -o $(TST)/cod2txt \ + $(TST)/cod2txt.o $(LIBGSM) $(LDLIB) + +$(TST)/cod2lin: $(TST)/cod2lin.o $(LIBGSM) + $(LD) $(LFLAGS) -o $(TST)/cod2lin \ + $(TST)/cod2lin.o $(LIBGSM) $(LDLIB) diff --git a/README b/README new file mode 100644 index 0000000..82ec0bd --- /dev/null +++ b/README @@ -0,0 +1,37 @@ + +GSM 06.10 13 kbit/s RPE/LTP speech compression available +-------------------------------------------------------- + +The Communications and Operating Systems Research Group (KBS) at the +Technische Universitaet Berlin is currently working on a set of +UNIX-based tools for computer-mediated telecooperation that will be +made freely available. + +As part of this effort we are publishing an implementation of the +European GSM 06.10 provisional standard for full-rate speech +transcoding, prI-ETS 300 036, which uses RPE/LTP (residual pulse +excitation/long term prediction) coding at 13 kbit/s. + +GSM 06.10 compresses frames of 160 13-bit samples (8 kHz sampling +rate, i.e. a frame rate of 50 Hz) into 260 bits; for compatibility +with typical UNIX applications, our implementation turns frames of 160 +16-bit linear samples into 33-byte frames (1650 Bytes/s). +The quality of the algorithm is good enough for reliable speaker +recognition; even music often survives transcoding in recognizable +form (given the bandwidth limitations of 8 kHz sampling rate). + +The interfaces offered are a front end modelled after compress(1), and +a library API. Compression and decompression run faster than realtime +on most SPARCstations. The implementation has been verified against the +ETSI standard test patterns. + +Jutta Degener (then jutta@cs.tu-berlin.de, nowadays jutta@pobox.com) +Carsten Bormann (then cabo@cs.tu-berlin.de, nowadays cabo@tzi.org) + +Communications and Operating Systems Research Group, TU Berlin +Fax: +49.30.31425156, Phone: +49.30.31424315 + +-- +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. diff --git a/add-test/._add_test.c b/add-test/._add_test.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/add-test/._add_test.c differ diff --git a/add-test/._add_test.dta b/add-test/._add_test.dta new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/add-test/._add_test.dta differ diff --git a/add-test/add_test.c b/add-test/add_test.c new file mode 100644 index 0000000..5d128f6 --- /dev/null +++ b/add-test/add_test.c @@ -0,0 +1,353 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/add_test.c,v 1.2 1994/05/10 20:18:17 jutta Exp $ */ + +#include +#include +#include +#include + +#include "gsm.h" + +#include "../src/add.c" + +int interactive = 1; + +char * opname; +longword L_op1, L_op2, L_expect; +word op1, op2, expect; +int do_expect; + +word M_gsm_add P((word op1, word op2)); +word M_gsm_sub P((word op1, word op2)); +word M_gsm_mult P((word op1, word op2)); +word M_gsm_mult_r P((word op1, word op2)); +word M_gsm_abs P((word op1)); +longword M_gsm_L_mult P((word op1, word op2)); +longword M_gsm_L_add P((longword op1, longword op2)); + +void help() +{ +puts( " add a b sub a b mult a b div a b" ); +puts( "L_add A B L_sub A B L_mult A B mult_r a b" ); +puts( "" ); +puts( "abs a norm a >> a b << a b" ); +puts( " L_>> A B L_<< A B" ); +} + +char * strtek P2((str, sep), char * str, char * sep) { + + static char * S = (char *)0; + char * c, * base; + + if (str) S = str; + + if (!S || !*S) return (char *)0; + + /* Skip delimiters. + */ + while (*S) { + for (c = sep; *c && *c != *S; c++) ; + if (*c) *S++ = 0; + else break; + } + + base = S; + + /* Skip non-delimiters. + */ + for (base = S; *S; S++) { + + for (c = sep; *c; c++) + if (*c == *S) { + *S++ = 0; + return base; + } + } + + return base == S ? (char *)0 : base; +} + +long value P1((s), char * s) +{ + switch (*s) { + case '-': switch (s[1]) { + case '\0': return MIN_WORD; + case '-': return MIN_LONGWORD; + default: break; + } + break; + + case '+': switch (s[1]) { + case '\0': return MAX_WORD; + case '+': return MAX_LONGWORD; + default: break; + } + default: break; + } + + return strtol(s, (char **)0, 0); +} + +char * parse P1((buf), char * buf) +{ + char * s, * a; + + if ((a = strchr(buf, '=')) != 0) *a++ = 0; + + opname = s = strtek(buf, " \t("); + if (!s) return (char *)0; + + op1 = op2 = L_op1 = L_op2 = 0; + + if ((s = strtek( (char *)0, "( \t,")) != 0) { + op1 = L_op1 = value(s); + if ((s = strtek( (char *)0, ", \t)")) != 0) + op2 = L_op2 = value(s); + } + + if (a) { + do_expect = 1; + while (*a == ' ' || *a == '\t') a++; + expect = L_expect = value(a); + } + + return opname; +} + +void fprint_word P2((f, w), FILE * f, word w) +{ + if (!w) putc('0', f); + else fprintf(f, "0x%4.4x (%d%s)", + (unsigned int)w, + (int)w, + w == MIN_WORD? "/-" : (w == MAX_WORD ? "/+" : "")); +} + +void print_word P1((w), word w) +{ + fprint_word( stdout, w ); +} + +void fprint_longword P2((f, w), FILE * f, longword w) +{ + if (!w) putc('0', f); + else fprintf(f, "0x%8.8lx (%ld%s)", + (unsigned long)w, (long)w, w == MIN_WORD ? "/-" + : (w == MAX_WORD ? "/+" + : (w == MIN_LONGWORD ? "/--" + : (w == MAX_LONGWORD ? "/++" : "")))); +} + +void print_longword P1((w),longword w) +{ + fprint_longword(stdout, w); +} + +void do_longword P1((w), longword w) +{ + if (interactive) print_longword(w); + if (do_expect) { + if ((w & 0xfffffffful) != (L_expect & 0xfffffffful)) { + if (!interactive) fprint_longword(stderr, w); + fprintf(stderr, " != %s (%ld, %ld) -- expected ", + opname, (long)L_op1, (long)L_op2 ); + fprint_longword(stderr, L_expect); + putc( '\n', stderr ); + } + } else if (interactive) putchar('\n'); +} + +void do_word P1((w), word w ) +{ + if (interactive) print_word(w); + if (do_expect) { + if (w != expect) { + if (!interactive) fprint_word(stderr, w); + fprintf(stderr, " != %s (%ld, %ld) -- expected ", + opname, (long)L_op1, (long)L_op2 ); + fprint_word(stderr, expect); + putc('\n', stderr); + } + } else if (interactive) putchar('\n'); +} + +int main(ac, av) char ** av; +{ + char buf[299]; + char * c; + FILE * in; + + if (ac > 2) { + fprintf(stderr, "Usage: %s [filename]\n", av[0]); +fail: +#ifdef EXIT_FAILURE + exit(EXIT_FAILURE); +#else + exit(1); +#endif + } + if (ac < 2) in = stdin; + else if (!(in = fopen(av[1], "r"))) { + perror(av[1]); + fprintf(stderr, "%s: cannot open file \"%s\" for reading\n", + av[0], av[1]); + goto fail; + } + + interactive = isatty(fileno(in)); + + for (;;) { + if (interactive) fprintf(stderr, "? "); + + if (!fgets(buf, sizeof(buf), in)) exit(0); + if ((c = strchr(buf, '\n')) != 0) *c = 0; + + if (*buf == ';' || *buf == '#') continue; + if (*buf == '\'') { + puts(buf + 1); + continue; + } + if (*buf == '\"') { + fprintf(stderr, "%s\n", buf + 1); + continue; + } + + c = parse(buf); + + if (!c) continue; + if (!strcmp(c, "add")) { + do_word( gsm_add( op1, op2 )); + continue; + } + if (!strcmp(c, "M_add")) { + do_word( M_gsm_add( op1, op2 )); + continue; + } + if (!strcmp(c, "sub")) { + do_word( gsm_sub( op1, op2 )); + continue; + } + if (!strcmp(c, "M_sub")) { + do_word( M_gsm_sub( op1, op2 )); + continue; + } + if (!strcmp(c, "mult")) { + do_word( gsm_mult( op1, op2 )); + continue; + } + if (!strcmp(c, "M_mult")) { + do_word( M_gsm_mult( op1, op2 )); + continue; + } + if (!strcmp(c, "mult_r")) { + do_word( gsm_mult_r(op1, op2)); + continue; + } + if (!strcmp(c, "M_mult_r")) { + do_word( M_gsm_mult_r(op1, op2)); + continue; + } + if (!strcmp(c, "abs" )) { + do_word( gsm_abs(op1) ); + continue; + } + if (!strcmp(c, "M_abs" )) { + do_word( M_gsm_abs(op1) ); + continue; + } + if (!strcmp(c, "div" )) { + do_word( gsm_div( op1, op2 )); + continue; + } + if (!strcmp(c, "norm" )) { + do_word( gsm_norm(L_op1)); + continue; + } + if (!strcmp(c, "<<" )) { + do_word( gsm_asl( op1, op2)); + continue; + } + if (!strcmp(c, ">>" )) { + do_word( gsm_asr( op1, op2 )); + continue; + } + if (!strcmp(c, "L_mult")) { + do_longword( gsm_L_mult( op1, op2 )); + continue; + } + if (!strcmp(c, "M_L_mult")) { + do_longword( M_gsm_L_mult( op1, op2 )); + continue; + } + if (!strcmp(c, "L_add" )) { + do_longword( gsm_L_add( L_op1, L_op2 )); + continue; + } + if (!strcmp(c, "M_L_add" )) { + do_longword( M_gsm_L_add( L_op1, L_op2 )); + continue; + } + if (!strcmp(c, "L_sub" )) { + do_longword( gsm_L_sub( L_op1, L_op2 )); + continue; + } + if (!strcmp(c, "L_<<" )) { + do_longword( gsm_L_asl( L_op1, L_op2 )); + continue; + } + if (!strcmp(c, "L_>>")) { + do_longword( gsm_L_asr( L_op1, L_op2 )); + continue; + } + help(); + } +} + +#include "private.h" + +/* + * Function stubs for macro implementations of commonly used + * math functions + */ +word M_gsm_add P2((op1, op2),word op1, word op2) +{ + longword ltmp; + return GSM_ADD(op1, op2); +} + +word M_gsm_sub P2((op1, op2), word op1, word op2) +{ + longword ltmp; + return GSM_SUB(op1, op2); +} + +word M_gsm_mult P2((op1, op2), word op1, word op2) +{ + return GSM_MULT(op1, op2); +} + +word M_gsm_mult_r P2((op1, op2), word op1, word op2) +{ + return GSM_MULT_R(op1, op2); +} + +word M_gsm_abs P1((op1), word op1) +{ + return GSM_ABS(op1); +} + +longword M_gsm_L_mult P2((op1, op2), word op1, word op2) +{ + return GSM_L_MULT(op1, op2); +} + +longword M_gsm_L_add P2((op1, op2), longword op1, longword op2) +{ + ulongword utmp; + return GSM_L_ADD(op1, op2); +} diff --git a/add-test/add_test.dta b/add-test/add_test.dta new file mode 100644 index 0000000..fe7402d --- /dev/null +++ b/add-test/add_test.dta @@ -0,0 +1,683 @@ +; +; 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. +; +; +; Lines starting with ' (in the first col) are echoed. +; Lines starting with " (in the first col) are echoed to stderr. +; Lines starting with ; or empty lines are ignored. +; +; The part after (including) a trailing '=' is what you expect; +; there will be output if the result is different. +; +; - and + by itself mean MIN_WORD and MAX_WORD, respectively; +; -- and ++ mean MIN_LONGWORD and MAX_LONGWORD. +; + +'test the basic arithmetic operations used for the rpe-ltd filtering. +' +'add ================ +' basic + + add 0 0 = 0 + add 7 4 = 11 + add 4 6 = 10 + add 1 1 = 2 + +' negative operands + + add -7 4 = -3 + add 4 -6 = -2 + add -1 -3 = -4 + add 7 -4 = 3 + add -4 6 = 2 + +' positive overflow +; (max-word = 32767) + add + 1 = + + add + + = + + add -1 + = 32766 + add 32766 2 = + + add 1 32766 = + + +' underflow +; (min-word = 32768) + + add - -1 = - + add - - = - + add 1 - = -32767 + add -32767 -2 = - + add -1 -32766 = -32767 + add -32767 -1 = - + add - + = -1 + add + - = -1 + add 0 - = - + add 0 + = + +' + +'L_add ================ +' basic + + L_add 0 0 = 0 + L_add 7 4 = 11 + L_add 4 6 = 10 + L_add 1 1 = 2 + +' negative operands + + L_add -7 4 = -3 + L_add 4 -6 = -2 + L_add -1 -3 = -4 + L_add 7 -4 = 3 + L_add -4 6 = 2 + L_add 0 -1 = -1 + +' positive overflow +; (max-longword = 2147483647) + L_add ++ 1 = ++ + L_add ++ ++ = ++ + L_add -1 ++ = 2147483646 + L_add 2147483646 2 = ++ + L_add 1 2147483645 = 2147483646 + +' underflow +; (min-longword = -2147483648) + + L_add -- -1 = -- + L_add -- -- = -- + L_add 1 -- = -2147483647 + L_add -2147483647 -2 = -- + L_add -1 -2147483646 = -2147483647 + L_add -2147483647 -1 = -- + L_add -- ++ = -1 + L_add ++ -- = -1 + L_add 0 -- = -- + L_add 0 ++ = ++ +' + +'sub ================ +' basic + + sub 0 0 = 0 + sub 7 4 = 3 + sub 4 6 = -2 + sub 1 0 = 1 + +' negative operands + + sub -7 4 = -11 + sub 4 -6 = 10 + sub -1 -3 = 2 + sub 7 -4 = 11 + sub -4 6 = -10 + +' positive overflow +; (max-word = 32767) + sub 1 - = + + sub + + = 0 + sub + 0 = + + sub + -1 = + + sub + 1 = 32766 + sub 1 + = -32766 + sub 0 + = -32767 + +' underflow +; (min-word = 32768) + + sub - -1 = -32767 + sub - 1 = - + sub - - = 0 + sub - + = - + sub + - = + + sub 1 - = + + sub -1 - = + + sub -32767 2 = - + sub 0 - = + +' + +'L_sub ================ +' basic + + L_sub 0 0 = 0 + L_sub 7 4 = 3 + L_sub 4 6 = -2 + L_sub 1 0 = 1 + +' negative operands + + L_sub -7 4 = -11 + L_sub 4 -6 = 10 + L_sub -1 -3 = 2 + L_sub 7 -4 = 11 + L_sub -4 6 = -10 + +' positive overflow + L_sub 1 -- = ++ + L_sub ++ ++ = 0 + L_sub ++ 0 = ++ + L_sub ++ -1 = ++ + L_sub ++ 1 = 2147483646 + L_sub 1 ++ = -2147483646 + L_sub 0 ++ = -2147483647 + +' underflow + + L_sub -- -1 = -2147483647 + L_sub -- 1 = -- + L_sub -- -- = 0 + L_sub -- ++ = -- + L_sub + -- = ++ + L_sub 1 -- = ++ + L_sub -1 -- = ++ + L_sub -2147483647 2 = -- + L_sub 0 -- = ++ + +' +'abs ================ +' basic + + abs 0 = 0 + abs 2 = 2 + abs -459 = 459 + +' overflow + + abs + = + + abs - = + + abs -32767 = + + abs 32766 = 32766 + abs -32766 = 32766 + +' +'mult ================ +; actually, a * b >> 15 + +' basic + mult 0 0 = 0 + mult 0x100 0x100 = 2 + mult 4711 0x4000 = 2355 + +' negative operands + mult -1 0 = 0 + + mult -0x100 0x100 = -2 + mult 0x100 -0x100 = -2 + mult -0x100 -0x100 = 2 + + mult -4711 0x4000 = -2356 + mult 4711 -0x4000 = -2356 + mult -4711 -0x4000 = 2355 + +' overflow + mult + + = 32766 + mult + 0x4000 = 0x3fff + mult 0x4000 + = 0x3fff + mult + 1 = 0 + mult + 2 = 1 + mult + 3 = 2 + +' underflow + mult - - = + + mult - + = -32767 + mult + - = -32767 + mult - 1 = -1 + mult - 2 = -2 + mult - 3 = -3 + +' +'mult_r ================ +; actually, (a * b + 16384) >> 15 + +' basic + mult_r 0 0 = 0 + mult_r 0x100 0x100 = 2 + mult_r 4711 0x4000 = 2356 + +' negative operands + mult_r -1 0 = 0 + + mult_r -0x100 0x100 = -2 + mult_r 0x100 -0x100 = -2 + mult_r -0x100 -0x100 = 2 + + mult_r -4711 0x4000 = -2355 + mult_r 4711 -0x4000 = -2355 + mult_r -4711 -0x4000 = 2356 + +' overflow + mult_r + + = 32766 + mult_r + 32766 = 32765 + mult_r 32766 + = 32765 + mult_r + 0x4000 = 0x4000 + mult_r 0x4000 + = 0x4000 + mult_r + 0x4001 = 0x4000 + mult_r 0x4001 + = 0x4000 + mult_r + 2 = 2 + mult_r + 1 = 1 + mult_r 1 + = 1 + mult_r + 0 = 0 + mult_r 0 + = 0 + +' underflow + mult_r - - = + + mult_r - + = -32767 + mult_r + - = -32767 + mult_r - 1 = -1 + mult_r - 2 = -2 + mult_r - 3 = -3 + +' +'L_mult ================ +; actually, (a * b) << 1 +; assert (a != MIN_WORD && b != MIN_WORD) + +' basic + L_mult 0 0 = 0 + L_mult 2 3 = 12 + L_mult 4711 5 = 47110 + +' negative operands + + L_mult -2 3 = -12 + L_mult 2 -3 = -12 + L_mult -2 -3 = 12 + L_mult -4711 5 = -47110 + L_mult 4711 -5 = -47110 + L_mult -4711 -5 = 47110 + +' overflow + L_mult + + = 2147352578 + L_mult + -32767 = -2147352578 + L_mult -32767 + = -2147352578 + L_mult + 2 = 131068 + L_mult + 1 = 65534 + L_mult 1 + = 65534 + L_mult + 0 = 0 + L_mult 0 + = 0 + +' +'div ================ +; actually, (32767 * a) / b +; assert (a > 0 && b >= a) + +' basic + div 1 1 = + + div 4711 4711 = + + div 5 10 = 0x4000 + div 5 20 = 0x2000 + div 5 40 = 0x1000 + +' overflow + div + + = + + div 0x4000 + = 0x4000 + div 1 + = 1 + div 1 2 = 0x4000 +' +'norm ================ + +' positive + norm 1 = 30 + norm 2 = 29 + norm 3 = 29 + norm 4 = 28 + norm 5 = 28 +; etc, etc... + norm 0x08000000 = 3 + norm 0x10000000 = 2 + norm 0x20000000 = 1 + norm 0x20000001 = 1 + norm 0x3fffffff = 1 + norm 0x40000000 = 0 + norm 0x40000001 = 0 + norm 0x4ffffffe = 0 + norm ++ = 0 + +' negative + norm -1 = 31 + norm -2 = 30 + norm -3 = 29 + norm -4 = 29 + norm -5 = 28 +; etc, etc... + norm 0x4fffffff = 0 + norm -- = 0 +' +'>> ================ + +' basic + >> 1 1 = 0 + >> 4 2 = 1 + >> 0x1100 5 = 0x88 + +' negative operand + + >> 1 -1 = 2 + >> 1 -2 = 4 + >> 0x88 -5 = 0x1100 + +' overflow + >> -1 4711 = -1 + >> 1 4711 = 0 + >> -4711 4711 = -1 + >> 4711 4711 = 0 + >> + 1 = 16383 + >> - 1 = -16384 +' +'L_>> ================ + +' basic + L_>> 1 1 = 0 + L_>> 4 2 = 1 + L_>> 0x1100 5 = 0x88 + +' negative operand + + L_>> 1 -1 = 2 + L_>> 1 -2 = 4 + L_>> 0x88 -5 = 0x1100 + +' overflow + L_>> -1 4711 = -1 + L_>> 1 4711 = 0 + L_>> -4711 4711 = -1 + L_>> 4711 4711 = 0 + L_>> ++ 1 = 1073741823 + L_>> -- 1 = -1073741824 + +' +'<< ================ + +' basic + << 1 1 = 2 + << 4 2 = 16 + << 0x0088 5 = 0x1100 + +' negative operand + + << 1 -1 = 0 + << 4 -2 = 1 + << 0x1100 -5 = 0x0088 + +' overflow + << -1 4711 = 0 + << 1 4711 = 0 + << -4711 4711 = 0 + << 4711 4711 = 0 + << 4711 -4711 = 0 + << -4711 -4711 = -1 + << + 1 = 0xfffe + << -1 1 = 0xfffe + << - 1 = 0 +' +'L_<< ================ + +' basic + L_<< 1 1 = 2 + L_<< 4 2 = 16 + L_<< 0x0088 5 = 0x1100 + +' negative operand + + L_<< 1 -1 = 0 + L_<< 4 -2 = 1 + L_<< 0x1100 -5 = 0x0088 + +' overflow + L_<< -1 4711 = 0 + L_<< 1 4711 = 0 + L_<< -4711 4711 = 0 + L_<< 4711 4711 = 0 + L_<< 4711 -4711 = 0 + L_<< -4711 -4711 = -1 + L_<< ++ 1 = -2 + L_<< -1 1 = -2 + L_<< -- 1 = 0 + +'macros +' +'add ================ +' basic + + M_add 0 0 = 0 + M_add 7 4 = 11 + M_add 4 6 = 10 + M_add 1 1 = 2 + +' negative operands + + M_add -7 4 = -3 + M_add 4 -6 = -2 + M_add -1 -3 = -4 + M_add 7 -4 = 3 + M_add -4 6 = 2 + +' positive overflow +; (max-word = 32767) + M_add + 1 = + + M_add + + = + + M_add -1 + = 32766 + M_add 32766 2 = + + M_add 1 32766 = + + +' underflow +; (min-word = 32768) + + M_add - -1 = - + M_add - - = - + M_add 1 - = -32767 + M_add -32767 -2 = - + M_add -1 -32766 = -32767 + M_add -32767 -1 = - + M_add - + = -1 + M_add + - = -1 + M_add 0 - = - + M_add 0 + = + +' + +'L_add ================ +' basic + + M_L_add 0 0 = 0 + M_L_add 7 4 = 11 + M_L_add 4 6 = 10 + M_L_add 1 1 = 2 + +' negative operands + + M_L_add -7 4 = -3 + M_L_add 4 -6 = -2 + M_L_add -1 -3 = -4 + M_L_add 7 -4 = 3 + M_L_add -4 6 = 2 + M_L_add 0 -1 = -1 + +' positive overflow +; (max-longword = 2147483647) + M_L_add ++ 1 = ++ + M_L_add ++ ++ = ++ + M_L_add -1 ++ = 2147483646 + M_L_add 2147483646 2 = ++ + M_L_add 1 2147483645 = 2147483646 + +' underflow +; (min-longword = -2147483648) + + M_L_add -- -1 = -- + M_L_add -- -- = -- + M_L_add 1 -- = -2147483647 + M_L_add -2147483647 -2 = -- + M_L_add -1 -2147483646 = -2147483647 + M_L_add -2147483647 -1 = -- + M_L_add -- ++ = -1 + M_L_add ++ -- = -1 + M_L_add 0 -- = -- + M_L_add 0 ++ = ++ +' + +'sub ================ +' basic + + M_sub 0 0 = 0 + M_sub 7 4 = 3 + M_sub 4 6 = -2 + M_sub 1 0 = 1 + +' negative operands + + M_sub -7 4 = -11 + M_sub 4 -6 = 10 + M_sub -1 -3 = 2 + M_sub 7 -4 = 11 + M_sub -4 6 = -10 + +' positive overflow +; (max-word = 32767) + M_sub 1 - = + + M_sub + + = 0 + M_sub + 0 = + + M_sub + -1 = + + M_sub + 1 = 32766 + M_sub 1 + = -32766 + M_sub 0 + = -32767 + +' underflow +; (min-word = 32768) + + M_sub - -1 = -32767 + M_sub - 1 = - + M_sub - - = 0 + M_sub - + = - + M_sub + - = + + M_sub 1 - = + + M_sub -1 - = + + M_sub -32767 2 = - + M_sub 0 - = + +' +' +'abs ================ +' basic + + M_abs 0 = 0 + M_abs 2 = 2 + M_abs -459 = 459 + +' overflow + + M_abs + = + + M_abs - = + + M_abs -32767 = + + M_abs 32766 = 32766 + M_abs -32766 = 32766 + +' +'mult ================ +; actually, a * b >> 15 + +' basic + M_mult 0 0 = 0 + M_mult 0x100 0x100 = 2 + M_mult 4711 0x4000 = 2355 + +' negative operands + M_mult -1 0 = 0 + + M_mult -0x100 0x100 = -2 + M_mult 0x100 -0x100 = -2 + M_mult -0x100 -0x100 = 2 + + M_mult -4711 0x4000 = -2356 + M_mult 4711 -0x4000 = -2356 + M_mult -4711 -0x4000 = 2355 + +' overflow + M_mult + + = 32766 + M_mult + 0x4000 = 0x3fff + M_mult 0x4000 + = 0x3fff + M_mult + 1 = 0 + M_mult + 2 = 1 + M_mult + 3 = 2 + +' underflow +; M_mult - - = + assert !(a == b && b == MIN_WORD) + M_mult - -32767 = + + M_mult -32767 - = + + M_mult - + = -32767 + M_mult + - = -32767 + M_mult - 1 = -1 + M_mult - 2 = -2 + M_mult - 3 = -3 + +' +'mult_r ================ +; actually, (a * b + 16384) >> 15 + +' basic + M_mult_r 0 0 = 0 + M_mult_r 0x100 0x100 = 2 + M_mult_r 4711 0x4000 = 2356 + +' negative operands + M_mult_r -1 0 = 0 + + M_mult_r -0x100 0x100 = -2 + M_mult_r 0x100 -0x100 = -2 + M_mult_r -0x100 -0x100 = 2 + + M_mult_r -4711 0x4000 = -2355 + M_mult_r 4711 -0x4000 = -2355 + M_mult_r -4711 -0x4000 = 2356 + +' overflow + M_mult_r + + = 32766 + M_mult_r + 32766 = 32765 + M_mult_r 32766 + = 32765 + M_mult_r + 0x4000 = 0x4000 + M_mult_r 0x4000 + = 0x4000 + M_mult_r + 0x4001 = 0x4000 + M_mult_r 0x4001 + = 0x4000 + M_mult_r + 2 = 2 + M_mult_r + 1 = 1 + M_mult_r 1 + = 1 + M_mult_r + 0 = 0 + M_mult_r 0 + = 0 + +' underflow +; M_mult_r - - = + assert !(a == b && b == MIN_WORD) + M_mult_r - -32767 = + + M_mult_r -32767 - = + + M_mult_r - + = -32767 + M_mult_r + - = -32767 + M_mult_r - 1 = -1 + M_mult_r - 2 = -2 + M_mult_r - 3 = -3 + +' +'L_mult ================ +; actually, (a * b) << 1 +; assert (a != MIN_WORD && b != MIN_WORD) + +' basic + M_L_mult 0 0 = 0 + M_L_mult 2 3 = 12 + M_L_mult 4711 5 = 47110 + +' negative operands + + M_L_mult -2 3 = -12 + M_L_mult 2 -3 = -12 + M_L_mult -2 -3 = 12 + M_L_mult -4711 5 = -47110 + M_L_mult 4711 -5 = -47110 + M_L_mult -4711 -5 = 47110 + +' overflow + M_L_mult + + = 2147352578 + M_L_mult + -32767 = -2147352578 + M_L_mult -32767 + = -2147352578 + M_L_mult + 2 = 131068 + M_L_mult + 1 = 65534 + M_L_mult 1 + = 65534 + M_L_mult + 0 = 0 + M_L_mult 0 + = 0 + diff --git a/inc/._config.h b/inc/._config.h new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/inc/._config.h differ diff --git a/inc/._gsm.h b/inc/._gsm.h new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/inc/._gsm.h differ diff --git a/inc/._private.h b/inc/._private.h new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/inc/._private.h differ diff --git a/inc/._proto.h b/inc/._proto.h new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/inc/._proto.h differ diff --git a/inc/._toast.h b/inc/._toast.h new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/inc/._toast.h differ diff --git a/inc/._unproto.h b/inc/._unproto.h new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/inc/._unproto.h differ diff --git a/inc/config.h b/inc/config.h new file mode 100644 index 0000000..dfb1ead --- /dev/null +++ b/inc/config.h @@ -0,0 +1,37 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/config.h,v 1.5 1996/07/02 11:26:20 jutta 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 */ +#define HAS_LIMITS_H 1 /* /usr/include/limits.h */ +#define HAS_FCNTL_H 1 /* /usr/include/fcntl.h */ +#define HAS_ERRNO_DECL 1 /* errno.h declares errno */ + +#define HAS_FSTAT 1 /* fstat syscall */ +#define HAS_FCHMOD 1 /* fchmod syscall */ +#define HAS_CHMOD 1 /* chmod syscall */ +#define HAS_FCHOWN 1 /* fchown syscall */ +#define HAS_CHOWN 1 /* chown syscall */ +/*efine HAS__FSETMODE 1 /* _fsetmode -- set file mode */ + +#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 */ +#define HAS_UTIMBUF 1 /* struct utimbuf */ +/*efine HAS_UTIMEUSEC 1 /* microseconds in utimbuf? */ + +#endif /* CONFIG_H */ diff --git a/inc/gsm.h b/inc/gsm.h new file mode 100644 index 0000000..dca1660 --- /dev/null +++ b/inc/gsm.h @@ -0,0 +1,71 @@ +/* + * 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/kbs/jutta/src/gsm/gsm-1.0/inc/RCS/gsm.h,v 1.11 1996/07/05 18:02:56 jutta 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 + +#ifdef NeedFunctionPrototypes +# include /* for FILE * */ +#endif + +#undef GSM_P +#if NeedFunctionPrototypes +# define GSM_P( protos ) protos +#else +# define GSM_P( protos ) ( /* protos */ ) +#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 16 +#define GSM_MINOR 0 +#define GSM_MAJOR 1 + +#define GSM_OPT_VERBOSE 1 +#define GSM_OPT_FAST 2 +#define GSM_OPT_LTP_CUT 3 +#define GSM_OPT_WAV49 4 +#define GSM_OPT_FRAME_INDEX 5 +#define GSM_OPT_FRAME_CHAIN 6 + +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 */ diff --git a/inc/private.h b/inc/private.h new file mode 100644 index 0000000..0c94255 --- /dev/null +++ b/inc/private.h @@ -0,0 +1,269 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/private.h,v 1.6 1996/07/02 10:15:26 jutta 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 e[ 50 ]; /* code.c */ + + 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 ltp_cut; /* long_term.c, LTP crosscorr. */ + 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 */ + + char wav_fmt; /* only used if WAV49 defined */ + unsigned char frame_index; /* odd/even chaining */ + unsigned char frame_chain; /* half-byte to carry forward */ +}; + + +#define MIN_WORD (-32767 - 1) +#define MAX_WORD 32767 + +#define MIN_LONGWORD (-2147483647 - 1) +#define MAX_LONGWORD 2147483647 + +#ifdef SASR /* flag: >> is a signed arithmetic shift right */ +#undef SASR +#define SASR(x, by) ((x) >> (by)) +#else +#define SASR(x, by) ((x) >= 0 ? (x) >> (by) : (~(-((x) + 1) >> (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 */ diff --git a/inc/proto.h b/inc/proto.h new file mode 100644 index 0000000..2851c08 --- /dev/null +++ b/inc/proto.h @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/proto.h,v 1.1 1992/10/28 00:11:08 jutta 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 */ diff --git a/inc/toast.h b/inc/toast.h new file mode 100644 index 0000000..b42d9ae --- /dev/null +++ b/inc/toast.h @@ -0,0 +1,109 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/toast.h,v 1.4 1995/03/07 21:26:16 jutta Exp $ */ + +#ifndef TOAST_H +#define TOAST_H /* Guard against multiple includes */ + +#include "config.h" + +#include +#include + +#include +#include +#include + +#include +#ifndef HAS_ERRNO_DECL + extern int errno; +#endif + +#ifdef HAS_LIMITS_H +#include +#endif + +#ifdef HAS_FCNTL_H +# include +#endif + +#ifdef HAS_UTIME +# ifdef HAS_UTIME_H +# include +# endif +#endif + +#include "gsm.h" + +#ifndef S_ISREG +#define S_ISREG(x) ((x) & S_IFREG) +#endif /* S_ISREG */ + + +# define READ "rb" +# define WRITE "wb" +#ifdef O_BINARY +# define O_WRITE_EXCL O_WRONLY|O_CREAT|O_EXCL|O_BINARY +#else +# define O_WRITE_EXCL O_WRONLY|O_CREAT|O_EXCL +#endif + +#ifndef SIGHANDLER_T +#define SIGHANDLER_T void /* what does a signal handler return? */ +#endif + + +#ifdef HAS_STRING_H +#include +#else +# ifdef HAS_STRINGS_H +# include +# 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 +#else +# include "proto.h" +# ifdef HAS_MALLOC_H +# include +# else + extern char * malloc P((unsigned)); +# endif + extern int exit P((int)); +# include "unproto.h" +#endif + + +#ifdef HAS_UNISTD_H +# include +#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 */ diff --git a/inc/unproto.h b/inc/unproto.h new file mode 100644 index 0000000..eaf866f --- /dev/null +++ b/inc/unproto.h @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/unproto.h,v 1.1 1992/10/28 00:11:08 jutta 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 */ diff --git a/man/._bitter.1 b/man/._bitter.1 new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/man/._bitter.1 differ diff --git a/man/._gsm.3 b/man/._gsm.3 new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/man/._gsm.3 differ diff --git a/man/._gsm_explode.3 b/man/._gsm_explode.3 new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/man/._gsm_explode.3 differ diff --git a/man/._gsm_option.3 b/man/._gsm_option.3 new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/man/._gsm_option.3 differ diff --git a/man/._gsm_print.3 b/man/._gsm_print.3 new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/man/._gsm_print.3 differ diff --git a/man/._toast.1 b/man/._toast.1 new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/man/._toast.1 differ diff --git a/man/bitter.1 b/man/bitter.1 new file mode 100644 index 0000000..72baba1 --- /dev/null +++ b/man/bitter.1 @@ -0,0 +1,70 @@ +.\" +.\" 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. +.\" +.PU +.TH BITTER 1 +.SH NAME +bitter, sweet \(em code-generators for packing bits +.SH SYNOPSIS +bitter < input > output +.br +sweet < input > output +.SH "DESCRIPTION" +Bitter and sweet are two filters which turn a description of the +form +.nf + name number-of-bits + name number-of-bits + ... +.nf +into code. +.PP +Bitter generates code that packs the specified bits from their +variables into an array of unsigned char referenced by an +advancing pointer c. +.PP +Sweet generates code that unpacks the specified bits from an array +of unsigned char referenced by a mutable pointer c into the +named variables. +.\" .SH OPTIONS +.\" .SH "RETURN VALUE" +.\" .SH ERRORS +.SH EXAMPLES +.nf +% cat in +amaretto 1 +banana 2 +cherry 3 +strawberry 4 +vanilla 15 +walnut 15 + +% bitter < in + *c++ = ((amaretto & 0x1) << 7) + | ((banana & 0x3) << 5) + | ((cherry & 0x7) << 2) + | ((strawberry >> 2) & 0x3); + *c++ = ((strawberry & 0x3) << 6) + | ((vanilla >> 9) & 0x3F); + *c++ = ((vanilla >> 1) & 0xFF); + *c++ = ((vanilla & 0x1) << 7) + | ((walnut >> 8) & 0x7F); + *c++ = walnut & 0xFF; + +% sweet < in + amaretto = (*c >> 7) & 0x1; + banana = (*c >> 5) & 0x3; + cherry = (*c >> 2) & 0x7; + strawberry = (*c++ & 0x3) << 2; + strawberry |= (*c >> 6) & 0x3; + vanilla = (*c++ & 0x3F) << 9; + vanilla |= (*c++ & 0xFF) << 1; + vanilla |= (*c >> 7) & 0x1; + walnut = (*c++ & 0x7F) << 8; + walnut |= *c++; +.SH NOTES +This is a quick hack for the gsm_encode() and gsm_decode() routines. +.SH BUGS +Please direct bug reports to jutta@pobox.com and cabo@tzi.org. diff --git a/man/gsm.3 b/man/gsm.3 new file mode 100644 index 0000000..6f24861 --- /dev/null +++ b/man/gsm.3 @@ -0,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. +.\" +.PU +.TH GSM 3 +.SH NAME +gsm_create, gsm_destroy, gsm_encode, gsm_decode \(em GSM\ 06.10 lossy sound compression +.SH SYNOPSIS +.PP +#include "gsm.h" +.PP +gsm gsm_create(); +.PP +void gsm_encode(handle, src, dst) +.br +gsm handle; +.br +gsm_signal src[160]; +.br +gsm_frame dst; +.PP +int gsm_decode(handle, src, dst) +.br +gsm handle; +.br +gsm_frame src; +.br +gsm_signal dst[160]; +.PP +void gsm_destroy(handle) +.br +gsm handle; +.br +.SH "DESCRIPTION" +Gsm is an implementation of the final draft GSM 06.10 +standard for full-rate speech transcoding. +.PP +gsm_create() initializes a gsm pass and returns a 'gsm' object +which can be used as a handle in subsequent calls to gsm_decode(), +gsm_encode() or gsm_destroy(). +.PP +gsm_encode() encodes an array of 160 13-bit samples (given as +gsm_signal's, signed integral values of at least 16 bits) into +a gsm_frame of 33 bytes. +(gsm_frame is a type defined as an array of 33 gsm_bytes in gsm.h.) +.PP +gsm_decode() decodes a gsm_frame into an array of 160 13-bit samples +(given as gsm_signals), which sound rather like what you handed to +gsm_encode() on the other side of the wire. +.PP +gsm_destroy() finishes a gsm pass and frees all storage associated +with it. +.SS "Sample format" +The following scaling is assumed for input to the algorithm: +.br +.nf + 0 1 11 12 + S..v..v..v..v..v..v..v..v..v..v..v..v..*..*..* +.nf +.br +Only the top 13 bits are used as a signed input value. +The output of gsm_decode() has the three lower bits set to zero. +.\" .SH OPTIONS +.SH "RETURN VALUE" +gsm_create() returns an opaque handle object of type gsm, or 0 on error. +gsm_decode() returns -1 if the passed frame is invalid, else 0. +.SH EXAMPLE +.nf +#include "gsm.h" + +gsm handle; +gsm_frame buf; +gsm_signal sample[160]; +int cc, soundfd; + +play() { /* read compressed data from standard input, write to soundfd */ + + if (!(handle = gsm_create())) error... + while (cc = read(0, (char *)buf, sizeof buf)) { + if (cc != sizeof buf) error... + if (gsm_decode(handle, buf, sample) < 0) error... + if (write(soundfd, sample, sizeof sample) != sizeof sample) + error... + } + gsm_destroy(handle); +} + +record() { /* read from soundfd, write compressed to standard output */ + + if (!(handle = gsm_create())) error... + while (cc = read(soundfd, sample, sizeof sample)) { + if (cc != sizeof sample) error... + gsm_encode(handle, sample, buf); + if (write(1, (char *)buf, sizeof buf) != sizeof sample) + error... + } + gsm_destroy(handle); +} +.nf +.SH BUGS +Please direct bug reports to jutta@pobox.com and cabo@tzi.org. +.SH "SEE ALSO" +toast(1), gsm_print(3), gsm_explode(3), gsm_option(3) diff --git a/man/gsm_explode.3 b/man/gsm_explode.3 new file mode 100644 index 0000000..d6c1e45 --- /dev/null +++ b/man/gsm_explode.3 @@ -0,0 +1,47 @@ +.\" +.\" 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. +.\" +.PU +.TH GSM_EXPLODE 3 +.SH NAME +gsm_explode, gsm_implode \(em GSM\ 06.10 supplementary +functions for testing +.SH SYNOPSIS +#include "gsm.h" +.PP +void gsm_explode(g, frame, xframe) +.br +gsm g; +.br +gsm_frame frame; +.br +gsm_signal xframe[ 76 ]; +.PP +void gsm_implode(g, xframe, frame) +.br +gsm g; +.br +gsm_signal xframe[ 76 ]; +.br +gsm_frame frame; +.SH "DESCRIPTION" +Gsm is an implementation of the final draft GSM 06.10 +standard for full-rate speech transcoding. +Test data for implementations of this particular document +can be bought and used to verify an implementation. +.PP +The encoded test data uses a format different from what +one would use to transmit frames with the least number +of bits. +Gsm_explode() and gsm_implode() convert between the +internal, small, 33-byte format and the 76-word format +used by the test data. +.PP +.SH "RETURN VALUE" +gsm_explode() returns -1 if the passed frame is invalid, else 0. +.SH BUGS +Please direct bug reports to jutta@pobox.com and cabo@tzi.org. +.SH "SEE ALSO" +gsm(3) diff --git a/man/gsm_option.3 b/man/gsm_option.3 new file mode 100644 index 0000000..d50f81f --- /dev/null +++ b/man/gsm_option.3 @@ -0,0 +1,183 @@ +.\" +.\" Copyright 1992-1995 by Jutta Degener and Carsten Bormann, Technische +.\" Universitaet Berlin. See the accompanying file "COPYRIGHT" for +.\" details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE. +.\" +.PU +.TH GSM_OPTION 3 +.SH NAME +gsm_option \(em customizing the GSM 06.10 implementation +.SH SYNOPSIS +#include "gsm.h" +.PP +int gsm_option(handle, option, valueP); +.br +gsm handle; +.br +int option; +.br +int * valueP; +.SH "DESCRIPTION" +The gsm library is an implementation of the final draft GSM 06.10 +standard for full-rate speech transcoding, a lossy +speech compression algorithm. +.PP +The gsm_option() function can be used to set and query various +options or flags that are not needed for regular GSM 06.10 encoding +or decoding, but might be of interest in special cases. +.PP +The second argument to gsm_option specifies what parameter +should be changed or queried. +The third argument is either a null pointer, in which case +the current value of that parameter is returned; +or it is a pointer to an integer containing the value +you want to set, in which case the previous value will +be returned. +.PP +The following options are defined: +.PP +.I GSM_OPT_VERBOSE +Verbosity level. +.br +.in+5 +This option is only supported if the library was compiled +with debugging turned on, and may be used by developers of +compression algorithms to aid debugging. +.br +The verbosity level can be changed at any time during encoding or decoding. +.in-5 +.sp +.PP +.I GSM_OPT_FAST +Faster compression algorithm. +.br +.in+5 +This implementation offers a not strictly standard-compliant, but +faster compression algorithm that is compatible with the regular +method and does not noticably degrade audio quality. +.br +The value passed to +.br +.nf + gsm_option(handle, GSM_OPT_FAST, & value) +.fi +.br +functions as a boolean flag; if it is zero, the regular algorithm +will be used, if not, the faster version will be used. +.br +The availability of this option depends on the hardware used; +if it is not available, gsm_option will return -1 on an attempt +to set or query it. +.br +This option can be set any time during encoding or decoding. +.in-5 +.ne 5 +.sp +.PP +.I GSM_OPT_LTP_CUT +Enable, disable, or query the LTP cut-off optimization. +.br +.in+5 +During encoding, the search for the long-term correlation +lag forms the bottleneck of the algorithm. +The ltp-cut option enables an approximation that disregards most +of the samples for purposes of finding that correlation, +and hence speeds up the encoding at a noticable loss in quality. +.br +The value passed to +.br +.nf + gsm_option(handle, GSM_OPT_LTP_CUT, & value) +.fi +.br +turns the optimization on if nonzero, and off if zero. +.br +This option can be set any time during encoding +or decoding; it will only affect the encoding pass, not +the decoding. +.sp +.PP +.I GSM_OPT_WAV49 +WAV-style byte ordering. +.br +.in+5 +A WAV file of type #49 contains GSM 06.10-encoded frames. +Unfortunately, the framing and code ordering of the WAV version +are incompatible with the native ones of this GSM 06.10 library. +The GSM_OPT_WAV49 option turns on a different packing +algorithm that produces alternating frames of 32 and 33 bytes +(or makes it consume alternating frames of 33 and 32 bytes, note +the opposite order of the two numbers) which, when concatenated, +can be used in the body of a WAV #49 frame. +It is up to the user program to write a WAV header, if any; +neither the library itself nor the toast program produce +complete WAV files. +.br +The value passed to +.br +.nf + gsm_option(handle, GSM_OPT_WAV49, & value) +.fi +.br +functions as a boolean flag; if it is zero, the library's native +framing algorithm will be used, if nonzero, WAV-type packing is in effect. +.br +This option should be used before any frames are encoded. +Whether or not it is supported at all depends on a +compile-time switch, WAV49. +Both option and compile time switch are new to the library +as of patchlevel 9, and are considerably less tested than the +well-worn rest of the it. +.br +Thanks to Jeff Chilton for the detective work and first free +implementation of this version of the GSM 06.10 encoding. +.sp +.PP +.I GSM_OPT_FRAME_CHAIN +Query or set the chaining byte. +.br +.in+5 +Between the two frames of a WAV-style encoding, the GSM 06.10 library +must keep track of one half-byte that is technically part of the first +frame, but will be written as the first four bits of the second. +This half-byte are the lowest four bits of the value returned by, +and optionally set by, +.br +.nf + gsm_option(handle, GSM_OPT_FRAME_CHAIN, & value) +.fi +.br +This option can be queried and set at any time. +.sp +.PP +.I GSM_OPT_FRAME_INDEX +Query or set the current frame's index in a format's +alternating list of frames. +.br +.in+5 +The WAV #49 framing uses two alternating types of frames. +Which type the next GSM-coded frame belongs to can be queried, or, +when decoding, announced, using +.br +.nf + gsm_option(handle, GSM_OPT_FRAME_INDEX, & value) +.fi +.br +For WAV-style framing, the value should be 0 or 1; the first frame +of an encoding has an index of 0. +At library initialization, the index is set to zero. +.br +The frame index can be queried and set at any time. +Used in combination with the +.IR GSM_OPT_FRAME_CHAIN , +option, it can be used to position on arbitrary GSM frames +within a format like WAV #49 (not accounting for the lost +internal GSM state). +.in-5 +.SH "RETURN VALUE" +gsm_option() returns -1 if an option is not supported, the +previous value of the option otherwise. +.SH BUGS +Please direct bug reports to jutta@pobox.com and cabo@tzi.org. +.SH "SEE ALSO" +toast(1), gsm(3), gsm_explode(3), gsm_print(3) diff --git a/man/gsm_print.3 b/man/gsm_print.3 new file mode 100644 index 0000000..4769641 --- /dev/null +++ b/man/gsm_print.3 @@ -0,0 +1,52 @@ +.\" +.\" 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. +.\" +.PU +.TH GSM_PRINT 3 +.SH NAME +gsm_print \(em GSM\ 06.10 supplementary function for debugging +.SH SYNOPSIS +#include "gsm.h" +#include + +int gsm_print(f, g, frame); +.br +FILE * f; +.br +gsm g; +.br +gsm_frame frame; +.SH "DESCRIPTION" +Gsm is an implementation of the final draft GSM 06.10 +standard for full-rate speech transcoding, a lossy +speech compression algorithm. +The compressed form involves 76 variables with different numbers +of significant bits packed into 33 bytes. +.PP +If you are interested in investigating the details of this +coding scheme, gsm_print() can be used to dump the contents +of individual gsm_frames to a file pointer provided by +the application. +.PP +.SH "RETURN VALUE" +gsm_print() returns -1 if the frame is invalid, else 0. +.SH EXAMPLE +A single frame looks like this: +.br +.nf +LARc: 29 32 20 11 08 05 06 07 +#1: Nc 0040 bc 0 Mc 1 xmaxc 60 + 06 04 00 03 03 06 04 02 02 04 05 04 01 +#2: Nc 0045 bc 1 Mc 1 xmaxc 48 + 03 07 01 03 04 04 07 01 03 02 04 05 03 +#3: Nc 0091 bc 1 Mc 1 xmaxc 46 + 00 03 03 07 01 06 02 04 05 03 03 02 04 +#4: Nc 0120 bc 0 Mc 1 xmaxc 47 + 07 03 06 00 03 03 06 05 00 03 02 07 04 +.nf +.SH BUGS +Please direct bug reports to jutta@pobox.com and cabo@tzi.org. +.SH "SEE ALSO" +gsm(3), gsm_explode(3) diff --git a/man/toast.1 b/man/toast.1 new file mode 100644 index 0000000..4a2a0f2 --- /dev/null +++ b/man/toast.1 @@ -0,0 +1,156 @@ +.\" +.\" 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. +.\" +.if n .ds mU u +.if t .ds mU \(*m +.\" +.TH TOAST 1 local +.SH NAME +toast \(em GSM\ 06.10 lossy sound compression +.SH SYNOPSIS +.ll +8 +.B toast +[ +.B \-cdfpvhualsFC +] [ +.I "filename...\&" +] +.LP +.B untoast +[ +.B \-cfpvhuaslF +] [ +.I "filename...\&" +] +.LP +.B tcat +[ +.B \-vhuaslF +] [ +.I "filename...\&" +] +.ll -8 +.SH DESCRIPTION +Toast compresses the sound files given on its command line. +Each file is replaced by a file with the extension +.I \&.gsm . +If no files are specified, the compression is applied to the +standard input, and its result is written to standard output. +.PP +Toasted files can be restored to something not quite unlike +their original form by running toast +.I "\-d" +, or +.I untoast +, on the \&.gsm-files or standard input. +.PP +The program +.I tcat +(the same as running +.I "untoast \-c" +) uncompresses its input on standard output, +but leaves the compressed .gsm\-files alone. +.PP +When files are compressed or uncompressed into other files, +the ownership (if run by root), modes, accessed and modified times +are maintained between both versions. +.SH OPTIONS +.TP +.B \-c +(cat) +Write to the standard output; no files are changed. +.TP +.B \-d +(decode) +Decode, rather than encode, the files. +.TP +.B \-f +(force) +Force replacement of output files if they exist. +If \-f is omitted and toast (or untoast) is run interactively from +a terminal, the user is prompted as to whether the file should be replaced. +.TP +.B \-p +(precious) +Do not delete the source files. +Source files are implicitly left alone whenever \-c is +specified or tcat is run. +.TP +.B \-C +(LTP cut-off) +Ignore most sample values when calculating the GSM long-term +correlation lag during encoding. +(The multiplications that do this are a bottleneck +of the algorithm.) +The resulting encoding process will not produce +exactly the same results as GSM 06.10 would, +but remains close enough to be compatible. +.br +The +.B \-C +option applies only to the encoder and is silently +ignored by the decoder. +.TP +.B \-F +(fast) +On systems with a floating point processor, but without +a multiplication instruction, \-F sacrifices standard conformance to +performance and nearly doubles the speed of the algorithm. +.br +The resulting encoding and decoding process will not produce +exactly the same results as GSM 06.10 would, but remains close +enough to be compatible. +.br +The default is standard-conforming operation. +.TP +.B \-v +(version)\ +outputs the version of toast (or untoast or tcat) to stdout and exits. +.TP +.B \-h +(help)\ +prints a short overview of the options. +.PP +Toast, untoast and tcat try to guess the appropriate audio data +format from the file suffix. +Command line options can also specify a format to be used for +all files. +.br +The following formats are supported: +.TP +.B "\-u" +(\(*mU-law) +8 kHz, 8 bit \(*mU-law encoding (file suffix .u) +.TP +.B "\-a" +(A-law) +8 kHz, 8 bit A-law encoding (file suffix .A) +.TP +.B "\-s" +(Sun audio) +8 kHz, 8 bit \(*mU-law encoding with audio header (file suffix .au) +.TP +.B "-l" +(linear) +8 kHz, 16 bit signed linear encoding in host byte order +with 13 significant bits (file suffix .l) +.PP +In absence of options or suffixes to specify a format, +\(*mU-law encoding as forced by \-u is assumed. +.PP +.SH PECULIARITIES +A four bit magic number is prefixed to each 32 1/2-byte GSM frame, +mainly because 32 1/2-bytes are rather clumsy to handle. +.SH WARNING +The compression algorithm used is a lossy compression algorithm +devised especially for speech; on no account should it be used +for text, pictures or any other non-speech-data you consider +valuable. +.SH BUGS +Please direct bug reports to jutta@pobox.com and cabo@tzi.org. +.SH "SEE ALSO" +gsm(3) +.\" +.\" Toast is dedicated to Bill Sienkiewicz, author of "Stray Toasters". diff --git a/src/._add.c b/src/._add.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._add.c differ diff --git a/src/._code.c b/src/._code.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._code.c differ diff --git a/src/._debug.c b/src/._debug.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._debug.c differ diff --git a/src/._decode.c b/src/._decode.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._decode.c differ diff --git a/src/._gsm_create.c b/src/._gsm_create.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_create.c differ diff --git a/src/._gsm_decode.c b/src/._gsm_decode.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_decode.c differ diff --git a/src/._gsm_destroy.c b/src/._gsm_destroy.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_destroy.c differ diff --git a/src/._gsm_encode.c b/src/._gsm_encode.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_encode.c differ diff --git a/src/._gsm_explode.c b/src/._gsm_explode.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_explode.c differ diff --git a/src/._gsm_implode.c b/src/._gsm_implode.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_implode.c differ diff --git a/src/._gsm_option.c b/src/._gsm_option.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_option.c differ diff --git a/src/._gsm_print.c b/src/._gsm_print.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._gsm_print.c differ diff --git a/src/._long_term.c b/src/._long_term.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._long_term.c differ diff --git a/src/._lpc.c b/src/._lpc.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._lpc.c differ diff --git a/src/._preprocess.c b/src/._preprocess.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._preprocess.c differ diff --git a/src/._rpe.c b/src/._rpe.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._rpe.c differ diff --git a/src/._short_term.c b/src/._short_term.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._short_term.c differ diff --git a/src/._table.c b/src/._table.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._table.c differ diff --git a/src/._toast.c b/src/._toast.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._toast.c differ diff --git a/src/._toast_alaw.c b/src/._toast_alaw.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._toast_alaw.c differ diff --git a/src/._toast_audio.c b/src/._toast_audio.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._toast_audio.c differ diff --git a/src/._toast_lin.c b/src/._toast_lin.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._toast_lin.c differ diff --git a/src/._toast_ulaw.c b/src/._toast_ulaw.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/src/._toast_ulaw.c differ diff --git a/src/.debug.c.swp b/src/.debug.c.swp new file mode 100644 index 0000000..42e46c5 Binary files /dev/null and b/src/.debug.c.swp differ diff --git a/src/add.c b/src/add.c new file mode 100644 index 0000000..258a6fc --- /dev/null +++ b/src/add.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/add.c,v 1.6 1996/07/02 09:57:33 jutta Exp $ */ + +/* + * See private.h for the more commonly used macro versions. + */ + +#include +#include + +#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 const 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; +} diff --git a/src/code.c b/src/code.c new file mode 100644 index 0000000..402f614 --- /dev/null +++ b/src/code.c @@ -0,0 +1,97 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/code.c,v 1.3 1996/07/02 09:59:05 jutta Exp $ */ + +#include "config.h" + + +#ifdef HAS_STRING_H +#include +#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 ] */ + + 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 */ + S->e + 5, /* e [0..39] OUT */ + dpp, /* dpp [0..39] OUT */ + Nc++, + bc++); + + Gsm_RPE_Encoding ( S, + S->e + 5,/* e ][0..39][ IN/OUT */ + xmaxc++, Mc++, xMc ); + /* + * Gsm_Update_of_reconstructed_short_time_residual_signal + * ( dpp, S->e + 5, dp ); + */ + + { register int i; + register longword ltmp; + for (i = 0; i <= 39; i++) + dp[ i ] = GSM_ADD( S->e[5 + i], dpp[i] ); + } + dp += 40; + dpp += 40; + + } + (void)memcpy( (char *)S->dp0, (char *)(S->dp0 + 160), + 120 * sizeof(*S->dp0) ); +} diff --git a/src/debug.c b/src/debug.c new file mode 100644 index 0000000..6e42842 --- /dev/null +++ b/src/debug.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/debug.c,v 1.2 1993/01/29 18:22:20 jutta 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 +#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, "%ld ", (long)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: %ld\n", name, (long)value ); +} + +void gsm_debug_word P2( (name, value), + char * name, + word value ) +{ + fprintf(stderr, "%s: %ld\n", name, (long)value); +} + +#endif diff --git a/src/decode.c b/src/decode.c new file mode 100644 index 0000000..d51c54a --- /dev/null +++ b/src/decode.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/decode.c,v 1.1 1992/10/28 00:15:50 jutta Exp $ */ + +#include + +#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); +} diff --git a/src/gsm_create.c b/src/gsm_create.c new file mode 100644 index 0000000..a0bf634 --- /dev/null +++ b/src/gsm_create.c @@ -0,0 +1,45 @@ +/* + * 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 const ident[] = "$Header: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_create.c,v 1.4 1996/07/02 09:59:05 jutta Exp $"; + +#include "config.h" + +#ifdef HAS_STRING_H +#include +#else +# include "proto.h" + extern char * memset P((char *, int, int)); +#endif + +#ifdef HAS_STDLIB_H +# include +#else +# ifdef HAS_MALLOC_H +# include +# else + extern char * malloc(); +# endif +#endif + +#include + +#include "gsm.h" +#include "private.h" +#include "proto.h" + +gsm gsm_create P0() +{ + gsm r; + + r = (gsm)malloc(sizeof(struct gsm_state)); + if (!r) return r; + + memset((char *)r, 0, sizeof(*r)); + r->nrp = 40; + + return r; +} diff --git a/src/gsm_decode.c b/src/gsm_decode.c new file mode 100644 index 0000000..973c08b --- /dev/null +++ b/src/gsm_decode.c @@ -0,0 +1,361 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_decode.c,v 1.2 1996/07/02 09:59:05 jutta 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]; + +#ifdef WAV49 + if (s->wav_fmt) { + + uword sr = 0; + + s->frame_index = !s->frame_index; + if (s->frame_index) { + + sr = *c++; + LARc[0] = sr & 0x3f; sr >>= 6; + sr |= (uword)*c++ << 2; + LARc[1] = sr & 0x3f; sr >>= 6; + sr |= (uword)*c++ << 4; + LARc[2] = sr & 0x1f; sr >>= 5; + LARc[3] = sr & 0x1f; sr >>= 5; + sr |= (uword)*c++ << 2; + LARc[4] = sr & 0xf; sr >>= 4; + LARc[5] = sr & 0xf; sr >>= 4; + sr |= (uword)*c++ << 2; /* 5 */ + LARc[6] = sr & 0x7; sr >>= 3; + LARc[7] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; + Nc[0] = sr & 0x7f; sr >>= 7; + bc[0] = sr & 0x3; sr >>= 2; + Mc[0] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[0] = sr & 0x3f; sr >>= 6; + xmc[0] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[1] = sr & 0x7; sr >>= 3; + xmc[2] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[3] = sr & 0x7; sr >>= 3; + xmc[4] = sr & 0x7; sr >>= 3; + xmc[5] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; /* 10 */ + xmc[6] = sr & 0x7; sr >>= 3; + xmc[7] = sr & 0x7; sr >>= 3; + xmc[8] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[9] = sr & 0x7; sr >>= 3; + xmc[10] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[11] = sr & 0x7; sr >>= 3; + xmc[12] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; + Nc[1] = sr & 0x7f; sr >>= 7; + bc[1] = sr & 0x3; sr >>= 2; + Mc[1] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[1] = sr & 0x3f; sr >>= 6; + xmc[13] = sr & 0x7; sr >>= 3; + sr = *c++; /* 15 */ + xmc[14] = sr & 0x7; sr >>= 3; + xmc[15] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[16] = sr & 0x7; sr >>= 3; + xmc[17] = sr & 0x7; sr >>= 3; + xmc[18] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[19] = sr & 0x7; sr >>= 3; + xmc[20] = sr & 0x7; sr >>= 3; + xmc[21] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[22] = sr & 0x7; sr >>= 3; + xmc[23] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[24] = sr & 0x7; sr >>= 3; + xmc[25] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; /* 20 */ + Nc[2] = sr & 0x7f; sr >>= 7; + bc[2] = sr & 0x3; sr >>= 2; + Mc[2] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[2] = sr & 0x3f; sr >>= 6; + xmc[26] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[27] = sr & 0x7; sr >>= 3; + xmc[28] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[29] = sr & 0x7; sr >>= 3; + xmc[30] = sr & 0x7; sr >>= 3; + xmc[31] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[32] = sr & 0x7; sr >>= 3; + xmc[33] = sr & 0x7; sr >>= 3; + xmc[34] = sr & 0x7; sr >>= 3; + sr = *c++; /* 25 */ + xmc[35] = sr & 0x7; sr >>= 3; + xmc[36] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[37] = sr & 0x7; sr >>= 3; + xmc[38] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; + Nc[3] = sr & 0x7f; sr >>= 7; + bc[3] = sr & 0x3; sr >>= 2; + Mc[3] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[3] = sr & 0x3f; sr >>= 6; + xmc[39] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[40] = sr & 0x7; sr >>= 3; + xmc[41] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; /* 30 */ + xmc[42] = sr & 0x7; sr >>= 3; + xmc[43] = sr & 0x7; sr >>= 3; + xmc[44] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[45] = sr & 0x7; sr >>= 3; + xmc[46] = sr & 0x7; sr >>= 3; + xmc[47] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[48] = sr & 0x7; sr >>= 3; + xmc[49] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[50] = sr & 0x7; sr >>= 3; + xmc[51] = sr & 0x7; sr >>= 3; + + s->frame_chain = sr & 0xf; + } + else { + sr = s->frame_chain; + sr |= (uword)*c++ << 4; /* 1 */ + LARc[0] = sr & 0x3f; sr >>= 6; + LARc[1] = sr & 0x3f; sr >>= 6; + sr = *c++; + LARc[2] = sr & 0x1f; sr >>= 5; + sr |= (uword)*c++ << 3; + LARc[3] = sr & 0x1f; sr >>= 5; + LARc[4] = sr & 0xf; sr >>= 4; + sr |= (uword)*c++ << 2; + LARc[5] = sr & 0xf; sr >>= 4; + LARc[6] = sr & 0x7; sr >>= 3; + LARc[7] = sr & 0x7; sr >>= 3; + sr = *c++; /* 5 */ + Nc[0] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; + bc[0] = sr & 0x3; sr >>= 2; + Mc[0] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[0] = sr & 0x3f; sr >>= 6; + xmc[0] = sr & 0x7; sr >>= 3; + xmc[1] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[2] = sr & 0x7; sr >>= 3; + xmc[3] = sr & 0x7; sr >>= 3; + xmc[4] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[5] = sr & 0x7; sr >>= 3; + xmc[6] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; /* 10 */ + xmc[7] = sr & 0x7; sr >>= 3; + xmc[8] = sr & 0x7; sr >>= 3; + xmc[9] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[10] = sr & 0x7; sr >>= 3; + xmc[11] = sr & 0x7; sr >>= 3; + xmc[12] = sr & 0x7; sr >>= 3; + sr = *c++; + Nc[1] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; + bc[1] = sr & 0x3; sr >>= 2; + Mc[1] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[1] = sr & 0x3f; sr >>= 6; + xmc[13] = sr & 0x7; sr >>= 3; + xmc[14] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; /* 15 */ + xmc[15] = sr & 0x7; sr >>= 3; + xmc[16] = sr & 0x7; sr >>= 3; + xmc[17] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[18] = sr & 0x7; sr >>= 3; + xmc[19] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[20] = sr & 0x7; sr >>= 3; + xmc[21] = sr & 0x7; sr >>= 3; + xmc[22] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[23] = sr & 0x7; sr >>= 3; + xmc[24] = sr & 0x7; sr >>= 3; + xmc[25] = sr & 0x7; sr >>= 3; + sr = *c++; + Nc[2] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; /* 20 */ + bc[2] = sr & 0x3; sr >>= 2; + Mc[2] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[2] = sr & 0x3f; sr >>= 6; + xmc[26] = sr & 0x7; sr >>= 3; + xmc[27] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[28] = sr & 0x7; sr >>= 3; + xmc[29] = sr & 0x7; sr >>= 3; + xmc[30] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[31] = sr & 0x7; sr >>= 3; + xmc[32] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[33] = sr & 0x7; sr >>= 3; + xmc[34] = sr & 0x7; sr >>= 3; + xmc[35] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; /* 25 */ + xmc[36] = sr & 0x7; sr >>= 3; + xmc[37] = sr & 0x7; sr >>= 3; + xmc[38] = sr & 0x7; sr >>= 3; + sr = *c++; + Nc[3] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; + bc[3] = sr & 0x3; sr >>= 2; + Mc[3] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[3] = sr & 0x3f; sr >>= 6; + xmc[39] = sr & 0x7; sr >>= 3; + xmc[40] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[41] = sr & 0x7; sr >>= 3; + xmc[42] = sr & 0x7; sr >>= 3; + xmc[43] = sr & 0x7; sr >>= 3; + sr = *c++; /* 30 */ + xmc[44] = sr & 0x7; sr >>= 3; + xmc[45] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[46] = sr & 0x7; sr >>= 3; + xmc[47] = sr & 0x7; sr >>= 3; + xmc[48] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[49] = sr & 0x7; sr >>= 3; + xmc[50] = sr & 0x7; sr >>= 3; + xmc[51] = sr & 0x7; sr >>= 3; + } + } + else +#endif + { + /* 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; +} diff --git a/src/gsm_destroy.c b/src/gsm_destroy.c new file mode 100644 index 0000000..03c8659 --- /dev/null +++ b/src/gsm_destroy.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_destroy.c,v 1.3 1994/11/28 19:52:25 jutta Exp $ */ + +#include "gsm.h" +#include "config.h" +#include "proto.h" + +#ifdef HAS_STDLIB_H +# include +#else +# ifdef HAS_MALLOC_H +# include +# else + extern void free(); +# endif +#endif + +void gsm_destroy P1((S), gsm S) +{ + if (S) free((char *)S); +} diff --git a/src/gsm_encode.c b/src/gsm_encode.c new file mode 100644 index 0000000..51bc556 --- /dev/null +++ b/src/gsm_encode.c @@ -0,0 +1,451 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_encode.c,v 1.2 1996/07/02 09:59:05 jutta 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 + */ + +#ifdef WAV49 + + if (s->wav_fmt) { + s->frame_index = !s->frame_index; + if (s->frame_index) { + + uword sr; + + sr = 0; + sr = sr >> 6 | LARc[0] << 10; + sr = sr >> 6 | LARc[1] << 10; + *c++ = sr >> 4; + sr = sr >> 5 | LARc[2] << 11; + *c++ = sr >> 7; + sr = sr >> 5 | LARc[3] << 11; + sr = sr >> 4 | LARc[4] << 12; + *c++ = sr >> 6; + sr = sr >> 4 | LARc[5] << 12; + sr = sr >> 3 | LARc[6] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | LARc[7] << 13; + sr = sr >> 7 | Nc[0] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[0] << 14; + sr = sr >> 2 | Mc[0] << 14; + sr = sr >> 6 | xmaxc[0] << 10; + *c++ = sr >> 3; + sr = sr >> 3 | xmc[0] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[1] << 13; + sr = sr >> 3 | xmc[2] << 13; + sr = sr >> 3 | xmc[3] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[4] << 13; + sr = sr >> 3 | xmc[5] << 13; + sr = sr >> 3 | xmc[6] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[7] << 13; + sr = sr >> 3 | xmc[8] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[9] << 13; + sr = sr >> 3 | xmc[10] << 13; + sr = sr >> 3 | xmc[11] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[12] << 13; + sr = sr >> 7 | Nc[1] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[1] << 14; + sr = sr >> 2 | Mc[1] << 14; + sr = sr >> 6 | xmaxc[1] << 10; + *c++ = sr >> 3; + sr = sr >> 3 | xmc[13] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[14] << 13; + sr = sr >> 3 | xmc[15] << 13; + sr = sr >> 3 | xmc[16] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[17] << 13; + sr = sr >> 3 | xmc[18] << 13; + sr = sr >> 3 | xmc[19] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[20] << 13; + sr = sr >> 3 | xmc[21] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[22] << 13; + sr = sr >> 3 | xmc[23] << 13; + sr = sr >> 3 | xmc[24] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[25] << 13; + sr = sr >> 7 | Nc[2] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[2] << 14; + sr = sr >> 2 | Mc[2] << 14; + sr = sr >> 6 | xmaxc[2] << 10; + *c++ = sr >> 3; + sr = sr >> 3 | xmc[26] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[27] << 13; + sr = sr >> 3 | xmc[28] << 13; + sr = sr >> 3 | xmc[29] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[30] << 13; + sr = sr >> 3 | xmc[31] << 13; + sr = sr >> 3 | xmc[32] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[33] << 13; + sr = sr >> 3 | xmc[34] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[35] << 13; + sr = sr >> 3 | xmc[36] << 13; + sr = sr >> 3 | xmc[37] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[38] << 13; + sr = sr >> 7 | Nc[3] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[3] << 14; + sr = sr >> 2 | Mc[3] << 14; + sr = sr >> 6 | xmaxc[3] << 10; + *c++ = sr >> 3; + sr = sr >> 3 | xmc[39] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[40] << 13; + sr = sr >> 3 | xmc[41] << 13; + sr = sr >> 3 | xmc[42] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[43] << 13; + sr = sr >> 3 | xmc[44] << 13; + sr = sr >> 3 | xmc[45] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[46] << 13; + sr = sr >> 3 | xmc[47] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[48] << 13; + sr = sr >> 3 | xmc[49] << 13; + sr = sr >> 3 | xmc[50] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[51] << 13; + sr = sr >> 4; + *c = sr >> 8; + s->frame_chain = *c; + } + else { + uword sr; + + sr = 0; + sr = sr >> 4 | s->frame_chain << 12; + sr = sr >> 6 | LARc[0] << 10; + *c++ = sr >> 6; + sr = sr >> 6 | LARc[1] << 10; + *c++ = sr >> 8; + sr = sr >> 5 | LARc[2] << 11; + sr = sr >> 5 | LARc[3] << 11; + *c++ = sr >> 6; + sr = sr >> 4 | LARc[4] << 12; + sr = sr >> 4 | LARc[5] << 12; + *c++ = sr >> 6; + sr = sr >> 3 | LARc[6] << 13; + sr = sr >> 3 | LARc[7] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[0] << 9; + sr = sr >> 2 | bc[0] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[0] << 14; + sr = sr >> 6 | xmaxc[0] << 10; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[0] << 13; + sr = sr >> 3 | xmc[1] << 13; + sr = sr >> 3 | xmc[2] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[3] << 13; + sr = sr >> 3 | xmc[4] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[5] << 13; + sr = sr >> 3 | xmc[6] << 13; + sr = sr >> 3 | xmc[7] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[8] << 13; + sr = sr >> 3 | xmc[9] << 13; + sr = sr >> 3 | xmc[10] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[11] << 13; + sr = sr >> 3 | xmc[12] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[1] << 9; + sr = sr >> 2 | bc[1] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[1] << 14; + sr = sr >> 6 | xmaxc[1] << 10; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[13] << 13; + sr = sr >> 3 | xmc[14] << 13; + sr = sr >> 3 | xmc[15] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[16] << 13; + sr = sr >> 3 | xmc[17] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[18] << 13; + sr = sr >> 3 | xmc[19] << 13; + sr = sr >> 3 | xmc[20] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[21] << 13; + sr = sr >> 3 | xmc[22] << 13; + sr = sr >> 3 | xmc[23] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[24] << 13; + sr = sr >> 3 | xmc[25] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[2] << 9; + sr = sr >> 2 | bc[2] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[2] << 14; + sr = sr >> 6 | xmaxc[2] << 10; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[26] << 13; + sr = sr >> 3 | xmc[27] << 13; + sr = sr >> 3 | xmc[28] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[29] << 13; + sr = sr >> 3 | xmc[30] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[31] << 13; + sr = sr >> 3 | xmc[32] << 13; + sr = sr >> 3 | xmc[33] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[34] << 13; + sr = sr >> 3 | xmc[35] << 13; + sr = sr >> 3 | xmc[36] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[37] << 13; + sr = sr >> 3 | xmc[38] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[3] << 9; + sr = sr >> 2 | bc[3] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[3] << 14; + sr = sr >> 6 | xmaxc[3] << 10; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[39] << 13; + sr = sr >> 3 | xmc[40] << 13; + sr = sr >> 3 | xmc[41] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[42] << 13; + sr = sr >> 3 | xmc[43] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[44] << 13; + sr = sr >> 3 | xmc[45] << 13; + sr = sr >> 3 | xmc[46] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[47] << 13; + sr = sr >> 3 | xmc[48] << 13; + sr = sr >> 3 | xmc[49] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[50] << 13; + sr = sr >> 3 | xmc[51] << 13; + *c++ = sr >> 8; + } + } + + else + +#endif /* WAV49 */ + { + + *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); + + } +} diff --git a/src/gsm_explode.c b/src/gsm_explode.c new file mode 100644 index 0000000..ca48f9b --- /dev/null +++ b/src/gsm_explode.c @@ -0,0 +1,417 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_explode.c,v 1.2 1996/07/02 14:32:42 jutta Exp jutta $ */ + +#include "private.h" +#include "gsm.h" +#include "proto.h" + +int gsm_explode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target) +{ +# define LARc target +# define Nc *((gsm_signal (*) [17])(target + 8)) +# define bc *((gsm_signal (*) [17])(target + 9)) +# define Mc *((gsm_signal (*) [17])(target + 10)) +# define xmaxc *((gsm_signal (*) [17])(target + 11)) + + +#ifdef WAV49 + if (s->wav_fmt) { + + uword sr = 0; + + if (s->frame_index == 1) { + + sr = *c++; + LARc[0] = sr & 0x3f; sr >>= 6; + sr |= (uword)*c++ << 2; + LARc[1] = sr & 0x3f; sr >>= 6; + sr |= (uword)*c++ << 4; + LARc[2] = sr & 0x1f; sr >>= 5; + LARc[3] = sr & 0x1f; sr >>= 5; + sr |= (uword)*c++ << 2; + LARc[4] = sr & 0xf; sr >>= 4; + LARc[5] = sr & 0xf; sr >>= 4; + sr |= (uword)*c++ << 2; /* 5 */ + LARc[6] = sr & 0x7; sr >>= 3; + LARc[7] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; + Nc[0] = sr & 0x7f; sr >>= 7; + bc[0] = sr & 0x3; sr >>= 2; + Mc[0] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[0] = sr & 0x3f; sr >>= 6; +#undef xmc +#define xmc (target + 12) + xmc[0] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[1] = sr & 0x7; sr >>= 3; + xmc[2] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[3] = sr & 0x7; sr >>= 3; + xmc[4] = sr & 0x7; sr >>= 3; + xmc[5] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; /* 10 */ + xmc[6] = sr & 0x7; sr >>= 3; + xmc[7] = sr & 0x7; sr >>= 3; + xmc[8] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[9] = sr & 0x7; sr >>= 3; + xmc[10] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[11] = sr & 0x7; sr >>= 3; + xmc[12] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; + Nc[1] = sr & 0x7f; sr >>= 7; + bc[1] = sr & 0x3; sr >>= 2; + Mc[1] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[1] = sr & 0x3f; sr >>= 6; +#undef xmc +#define xmc (target + 29 - 13) + + xmc[13] = sr & 0x7; sr >>= 3; + sr = *c++; /* 15 */ + xmc[14] = sr & 0x7; sr >>= 3; + xmc[15] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[16] = sr & 0x7; sr >>= 3; + xmc[17] = sr & 0x7; sr >>= 3; + xmc[18] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[19] = sr & 0x7; sr >>= 3; + xmc[20] = sr & 0x7; sr >>= 3; + xmc[21] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[22] = sr & 0x7; sr >>= 3; + xmc[23] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[24] = sr & 0x7; sr >>= 3; + xmc[25] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; /* 20 */ + Nc[2] = sr & 0x7f; sr >>= 7; + bc[2] = sr & 0x3; sr >>= 2; + Mc[2] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[2] = sr & 0x3f; sr >>= 6; + +#undef xmc +#define xmc (target + 46 - 26) + + xmc[26] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[27] = sr & 0x7; sr >>= 3; + xmc[28] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[29] = sr & 0x7; sr >>= 3; + xmc[30] = sr & 0x7; sr >>= 3; + xmc[31] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[32] = sr & 0x7; sr >>= 3; + xmc[33] = sr & 0x7; sr >>= 3; + xmc[34] = sr & 0x7; sr >>= 3; + sr = *c++; /* 25 */ + xmc[35] = sr & 0x7; sr >>= 3; + xmc[36] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[37] = sr & 0x7; sr >>= 3; + xmc[38] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 4; + Nc[3] = sr & 0x7f; sr >>= 7; + bc[3] = sr & 0x3; sr >>= 2; + Mc[3] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 1; + xmaxc[3] = sr & 0x3f; sr >>= 6; +#undef xmc +#define xmc (target + 63 - 39) + + xmc[39] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[40] = sr & 0x7; sr >>= 3; + xmc[41] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; /* 30 */ + xmc[42] = sr & 0x7; sr >>= 3; + xmc[43] = sr & 0x7; sr >>= 3; + xmc[44] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[45] = sr & 0x7; sr >>= 3; + xmc[46] = sr & 0x7; sr >>= 3; + xmc[47] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[48] = sr & 0x7; sr >>= 3; + xmc[49] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[50] = sr & 0x7; sr >>= 3; + xmc[51] = sr & 0x7; sr >>= 3; + + s->frame_chain = sr & 0xf; + } + else { + sr = s->frame_chain; + sr |= (uword)*c++ << 4; /* 1 */ + LARc[0] = sr & 0x3f; sr >>= 6; + LARc[1] = sr & 0x3f; sr >>= 6; + sr = *c++; + LARc[2] = sr & 0x1f; sr >>= 5; + sr |= (uword)*c++ << 3; + LARc[3] = sr & 0x1f; sr >>= 5; + LARc[4] = sr & 0xf; sr >>= 4; + sr |= (uword)*c++ << 2; + LARc[5] = sr & 0xf; sr >>= 4; + LARc[6] = sr & 0x7; sr >>= 3; + LARc[7] = sr & 0x7; sr >>= 3; + sr = *c++; /* 5 */ + Nc[0] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; + bc[0] = sr & 0x3; sr >>= 2; + Mc[0] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[0] = sr & 0x3f; sr >>= 6; +#undef xmc +#define xmc (target + 12) + xmc[0] = sr & 0x7; sr >>= 3; + xmc[1] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[2] = sr & 0x7; sr >>= 3; + xmc[3] = sr & 0x7; sr >>= 3; + xmc[4] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[5] = sr & 0x7; sr >>= 3; + xmc[6] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; /* 10 */ + xmc[7] = sr & 0x7; sr >>= 3; + xmc[8] = sr & 0x7; sr >>= 3; + xmc[9] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[10] = sr & 0x7; sr >>= 3; + xmc[11] = sr & 0x7; sr >>= 3; + xmc[12] = sr & 0x7; sr >>= 3; + sr = *c++; + Nc[1] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; + bc[1] = sr & 0x3; sr >>= 2; + Mc[1] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[1] = sr & 0x3f; sr >>= 6; +#undef xmc +#define xmc (target + 29 - 13) + + xmc[13] = sr & 0x7; sr >>= 3; + xmc[14] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; /* 15 */ + xmc[15] = sr & 0x7; sr >>= 3; + xmc[16] = sr & 0x7; sr >>= 3; + xmc[17] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[18] = sr & 0x7; sr >>= 3; + xmc[19] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[20] = sr & 0x7; sr >>= 3; + xmc[21] = sr & 0x7; sr >>= 3; + xmc[22] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[23] = sr & 0x7; sr >>= 3; + xmc[24] = sr & 0x7; sr >>= 3; + xmc[25] = sr & 0x7; sr >>= 3; + sr = *c++; + Nc[2] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; /* 20 */ + bc[2] = sr & 0x3; sr >>= 2; + Mc[2] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[2] = sr & 0x3f; sr >>= 6; +#undef xmc +#define xmc (target + 46 - 26) + xmc[26] = sr & 0x7; sr >>= 3; + xmc[27] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[28] = sr & 0x7; sr >>= 3; + xmc[29] = sr & 0x7; sr >>= 3; + xmc[30] = sr & 0x7; sr >>= 3; + sr = *c++; + xmc[31] = sr & 0x7; sr >>= 3; + xmc[32] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[33] = sr & 0x7; sr >>= 3; + xmc[34] = sr & 0x7; sr >>= 3; + xmc[35] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; /* 25 */ + xmc[36] = sr & 0x7; sr >>= 3; + xmc[37] = sr & 0x7; sr >>= 3; + xmc[38] = sr & 0x7; sr >>= 3; + sr = *c++; + Nc[3] = sr & 0x7f; sr >>= 7; + sr |= (uword)*c++ << 1; + bc[3] = sr & 0x3; sr >>= 2; + Mc[3] = sr & 0x3; sr >>= 2; + sr |= (uword)*c++ << 5; + xmaxc[3] = sr & 0x3f; sr >>= 6; + +#undef xmc +#define xmc (target + 63 - 39) + + xmc[39] = sr & 0x7; sr >>= 3; + xmc[40] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[41] = sr & 0x7; sr >>= 3; + xmc[42] = sr & 0x7; sr >>= 3; + xmc[43] = sr & 0x7; sr >>= 3; + sr = *c++; /* 30 */ + xmc[44] = sr & 0x7; sr >>= 3; + xmc[45] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 2; + xmc[46] = sr & 0x7; sr >>= 3; + xmc[47] = sr & 0x7; sr >>= 3; + xmc[48] = sr & 0x7; sr >>= 3; + sr |= (uword)*c++ << 1; + xmc[49] = sr & 0x7; sr >>= 3; + xmc[50] = sr & 0x7; sr >>= 3; + xmc[51] = sr & 0x7; sr >>= 3; + } + } + else +#endif + { + /* 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; + +#undef xmc +#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; + + 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; + +#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; + + 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; + +#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; + + 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; + +#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; +} diff --git a/src/gsm_implode.c b/src/gsm_implode.c new file mode 100644 index 0000000..6c5672b --- /dev/null +++ b/src/gsm_implode.c @@ -0,0 +1,521 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_implode.c,v 1.2 1996/07/02 14:32:43 jutta Exp jutta $ */ + +#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 + */ + + /* There are 76 parameters per frame. The first eight are + * unique. The remaining 68 are four identical subframes of + * 17 parameters each. gsm_implode converts from a representation + * of these parameters as values in one array of signed words + * to the "packed" version of a GSM frame. + */ + +# define LARc source +# define Nc *((gsm_signal (*) [17])(source + 8)) +# define bc *((gsm_signal (*) [17])(source + 9)) +# define Mc *((gsm_signal (*) [17])(source + 10)) +# define xmaxc *((gsm_signal (*) [17])(source + 11)) + +#ifdef WAV49 + if (s->wav_fmt) { + + uword sr = 0; + if (s->frame_index) { + sr = sr >> 6 | LARc[0] << 10; + sr = sr >> 6 | LARc[1] << 10; + *c++ = sr >> 4; + sr = sr >> 5 | LARc[2] << 11; + *c++ = sr >> 7; + sr = sr >> 5 | LARc[3] << 11; + sr = sr >> 4 | LARc[4] << 12; + *c++ = sr >> 6; + sr = sr >> 4 | LARc[5] << 12; + sr = sr >> 3 | LARc[6] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | LARc[7] << 13; + sr = sr >> 7 | Nc[0] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[0] << 14; + sr = sr >> 2 | Mc[0] << 14; + sr = sr >> 6 | xmaxc[0] << 10; + *c++ = sr >> 3; +#undef xmc +#define xmc (source + 12) + + sr = sr >> 3 | xmc[0] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[1] << 13; + sr = sr >> 3 | xmc[2] << 13; + sr = sr >> 3 | xmc[3] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[4] << 13; + sr = sr >> 3 | xmc[5] << 13; + sr = sr >> 3 | xmc[6] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[7] << 13; + sr = sr >> 3 | xmc[8] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[9] << 13; + sr = sr >> 3 | xmc[10] << 13; + sr = sr >> 3 | xmc[11] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[12] << 13; + sr = sr >> 7 | Nc[1] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[1] << 14; + sr = sr >> 2 | Mc[1] << 14; + sr = sr >> 6 | xmaxc[1] << 10; + *c++ = sr >> 3; +#undef xmc +#define xmc (source + 29 - 13) + + sr = sr >> 3 | xmc[13] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[14] << 13; + sr = sr >> 3 | xmc[15] << 13; + sr = sr >> 3 | xmc[16] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[17] << 13; + sr = sr >> 3 | xmc[18] << 13; + sr = sr >> 3 | xmc[19] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[20] << 13; + sr = sr >> 3 | xmc[21] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[22] << 13; + sr = sr >> 3 | xmc[23] << 13; + sr = sr >> 3 | xmc[24] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[25] << 13; + sr = sr >> 7 | Nc[2] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[2] << 14; + sr = sr >> 2 | Mc[2] << 14; + sr = sr >> 6 | xmaxc[2] << 10; + *c++ = sr >> 3; +#undef xmc +#define xmc (source + 46 - 26) + + sr = sr >> 3 | xmc[26] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[27] << 13; + sr = sr >> 3 | xmc[28] << 13; + sr = sr >> 3 | xmc[29] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[30] << 13; + sr = sr >> 3 | xmc[31] << 13; + sr = sr >> 3 | xmc[32] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[33] << 13; + sr = sr >> 3 | xmc[34] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[35] << 13; + sr = sr >> 3 | xmc[36] << 13; + sr = sr >> 3 | xmc[37] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[38] << 13; + sr = sr >> 7 | Nc[3] << 9; + *c++ = sr >> 5; + sr = sr >> 2 | bc[3] << 14; + sr = sr >> 2 | Mc[3] << 14; + sr = sr >> 6 | xmaxc[3] << 10; + *c++ = sr >> 3; +#undef xmc +#define xmc (source + 63 - 39) + + sr = sr >> 3 | xmc[39] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[40] << 13; + sr = sr >> 3 | xmc[41] << 13; + sr = sr >> 3 | xmc[42] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[43] << 13; + sr = sr >> 3 | xmc[44] << 13; + sr = sr >> 3 | xmc[45] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[46] << 13; + sr = sr >> 3 | xmc[47] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[48] << 13; + sr = sr >> 3 | xmc[49] << 13; + sr = sr >> 3 | xmc[50] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[51] << 13; + sr = sr >> 4; + *c = sr >> 8; + s->frame_chain = *c; + } + else { + sr = sr >> 4 | s->frame_chain << 12; + sr = sr >> 6 | LARc[0] << 10; + *c++ = sr >> 6; + sr = sr >> 6 | LARc[1] << 10; + *c++ = sr >> 8; + sr = sr >> 5 | LARc[2] << 11; + sr = sr >> 5 | LARc[3] << 11; + *c++ = sr >> 6; + sr = sr >> 4 | LARc[4] << 12; + sr = sr >> 4 | LARc[5] << 12; + *c++ = sr >> 6; + sr = sr >> 3 | LARc[6] << 13; + sr = sr >> 3 | LARc[7] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[0] << 9; + sr = sr >> 2 | bc[0] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[0] << 14; + sr = sr >> 6 | xmaxc[0] << 10; + *c++ = sr >> 7; +#undef xmc +#define xmc (source + 12) + + sr = sr >> 3 | xmc[0] << 13; + sr = sr >> 3 | xmc[1] << 13; + sr = sr >> 3 | xmc[2] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[3] << 13; + sr = sr >> 3 | xmc[4] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[5] << 13; + sr = sr >> 3 | xmc[6] << 13; + sr = sr >> 3 | xmc[7] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[8] << 13; + sr = sr >> 3 | xmc[9] << 13; + sr = sr >> 3 | xmc[10] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[11] << 13; + sr = sr >> 3 | xmc[12] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[1] << 9; + sr = sr >> 2 | bc[1] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[1] << 14; + sr = sr >> 6 | xmaxc[1] << 10; + *c++ = sr >> 7; +#undef xmc +#define xmc (source + 29 - 13) + + sr = sr >> 3 | xmc[13] << 13; + sr = sr >> 3 | xmc[14] << 13; + sr = sr >> 3 | xmc[15] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[16] << 13; + sr = sr >> 3 | xmc[17] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[18] << 13; + sr = sr >> 3 | xmc[19] << 13; + sr = sr >> 3 | xmc[20] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[21] << 13; + sr = sr >> 3 | xmc[22] << 13; + sr = sr >> 3 | xmc[23] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[24] << 13; + sr = sr >> 3 | xmc[25] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[2] << 9; + sr = sr >> 2 | bc[2] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[2] << 14; + sr = sr >> 6 | xmaxc[2] << 10; + *c++ = sr >> 7; +#undef xmc +#define xmc (source + 46 - 26) + + sr = sr >> 3 | xmc[26] << 13; + sr = sr >> 3 | xmc[27] << 13; + sr = sr >> 3 | xmc[28] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[29] << 13; + sr = sr >> 3 | xmc[30] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[31] << 13; + sr = sr >> 3 | xmc[32] << 13; + sr = sr >> 3 | xmc[33] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[34] << 13; + sr = sr >> 3 | xmc[35] << 13; + sr = sr >> 3 | xmc[36] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[37] << 13; + sr = sr >> 3 | xmc[38] << 13; + *c++ = sr >> 8; + sr = sr >> 7 | Nc[3] << 9; + sr = sr >> 2 | bc[3] << 14; + *c++ = sr >> 7; + sr = sr >> 2 | Mc[3] << 14; + sr = sr >> 6 | xmaxc[3] << 10; + *c++ = sr >> 7; +#undef xmc +#define xmc (source + 63 - 39) + + sr = sr >> 3 | xmc[39] << 13; + sr = sr >> 3 | xmc[40] << 13; + sr = sr >> 3 | xmc[41] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[42] << 13; + sr = sr >> 3 | xmc[43] << 13; + *c++ = sr >> 8; + sr = sr >> 3 | xmc[44] << 13; + sr = sr >> 3 | xmc[45] << 13; + sr = sr >> 3 | xmc[46] << 13; + *c++ = sr >> 7; + sr = sr >> 3 | xmc[47] << 13; + sr = sr >> 3 | xmc[48] << 13; + sr = sr >> 3 | xmc[49] << 13; + *c++ = sr >> 6; + sr = sr >> 3 | xmc[50] << 13; + sr = sr >> 3 | xmc[51] << 13; + *c++ = sr >> 8; + } + } + else +#endif + { + + *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) + +#undef xmc +#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); + + + *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) + +#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); + + + *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) + +#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); + + + *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) + +#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); + } +} diff --git a/src/gsm_option.c b/src/gsm_option.c new file mode 100644 index 0000000..274b7b1 --- /dev/null +++ b/src/gsm_option.c @@ -0,0 +1,69 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_option.c,v 1.3 1996/07/02 09:59:05 jutta 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_LTP_CUT: +#ifdef LTP_CUT + result = r->ltp_cut; + if (val) r->ltp_cut = *val; +#endif + break; + + 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; + + case GSM_OPT_FRAME_CHAIN: + +#ifdef WAV49 + result = r->frame_chain; + if (val) r->frame_chain = *val; +#endif + break; + + case GSM_OPT_FRAME_INDEX: + +#ifdef WAV49 + result = r->frame_index; + if (val) r->frame_index = *val; +#endif + break; + + case GSM_OPT_WAV49: + +#ifdef WAV49 + result = r->wav_fmt; + if (val) r->wav_fmt = !!*val; +#endif + break; + + default: + break; + } + return result; +} diff --git a/src/gsm_print.c b/src/gsm_print.c new file mode 100644 index 0000000..47f753b --- /dev/null +++ b/src/gsm_print.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm_print.c,v 1.1 1992/10/28 00:15:50 jutta Exp $ */ + +#include + +#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; +} diff --git a/src/long_term.c b/src/long_term.c new file mode 100644 index 0000000..b2d2d3f --- /dev/null +++ b/src/long_term.c @@ -0,0 +1,949 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/long_term.c,v 1.6 1996/07/02 12:33:19 jutta Exp $ */ + +#include +#include + +#include "private.h" + +#include "gsm.h" +#include "proto.h" + +/* + * 4.2.11 .. 4.2.12 LONG TERM PREDICTOR (LTP) SECTION + */ + + +/* + * This module 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. + */ + + /* The next procedure exists in six versions. First two integer + * version (if USE_FLOAT_MUL is not defined); then four floating + * point versions, twice with proper scaling (USE_FLOAT_MUL defined), + * once without (USE_FLOAT_MUL and FAST defined, and fast run-time + * option used). Every pair has first a Cut version (see the -C + * option to toast or the LTP_CUT option to gsm_option()), then the + * uncut one. (For a detailed explanation of why this is altogether + * a bad idea, see Henry Spencer and Geoff Collyer, ``#ifdef Considered + * Harmful''.) + */ + +#ifndef USE_FLOAT_MUL + +#ifdef LTP_CUT + +static void Cut_Calculation_of_the_LTP_parameters P5((st, d,dp,bc_out,Nc_out), + + struct gsm_state * st, + + 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_result; + longword L_max, L_power; + word R, S, dmax, scal, best_k; + word ltp_cut; + + register word temp, wt_k; + + /* 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; + best_k = k; + } + } + 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); + + /* Search for the maximum cross-correlation and coding of the LTP lag + */ + L_max = 0; + Nc = 40; /* index for the maximum cross-correlation */ + wt_k = SASR(d[best_k], scal); + + for (lambda = 40; lambda <= 120; lambda++) { + L_result = (longword)wt_k * dp[best_k - lambda]; + 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; +} + +#endif /* LTP_CUT */ + +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 +# define STEP(k) (longword)wt[k] * dp[k - lambda] + + 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 */ + +#ifdef LTP_CUT + +static void Cut_Calculation_of_the_LTP_parameters P5((st, d,dp,bc_out,Nc_out), + struct gsm_state * st, /* IN */ + 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 ltp_cut; + + 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); + ltp_cut = (longword)SASR(dmax, scal) * st->ltp_cut / 100; + + + /* Initialization of a working array wt + */ + + for (k = 0; k < 40; k++) { + register word w = SASR( d[k], scal ); + if (w < 0 ? w > -ltp_cut : w < ltp_cut) { + wt_float[k] = 0.0; + } + else { + wt_float[k] = w; + } + } + 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) \ + if ((W = wt_float[K]) != 0.0) { \ + 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; } else (a = lp[K]) + +# 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; +} + +#endif /* LTP_CUT */ + +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 +#ifdef LTP_CUT + +static void Cut_Fast_Calculation_of_the_LTP_parameters P5((st, + d,dp,bc_out,Nc_out), + struct gsm_state * st, /* IN */ + register word * d, /* [0..39] IN */ + register word * dp, /* [-120..-1] IN */ + word * bc_out, /* OUT */ + word * Nc_out /* OUT */ +) +{ + register int k, lambda; + register float wt_float; + word Nc, bc; + word wt_max, best_k, ltp_cut; + + float dp_float_base[120], * dp_float = dp_float_base + 120; + + register float L_result, L_max, L_power; + + wt_max = 0; + + for (k = 0; k < 40; ++k) { + if ( d[k] > wt_max) wt_max = d[best_k = k]; + else if (-d[k] > wt_max) wt_max = -d[best_k = k]; + } + + assert(wt_max >= 0); + wt_float = (float)wt_max; + + 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++) { + L_result = wt_float * dp_float[best_k - lambda]; + if (L_result > L_max) { + Nc = lambda; + L_max = L_result; + } + } + + *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 /* LTP_CUT */ + +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) +#if defined (LTP_CUT) + if (S->ltp_cut) + Cut_Fast_Calculation_of_the_LTP_parameters(S, + d, dp, bc, Nc); + else +#endif /* LTP_CUT */ + Fast_Calculation_of_the_LTP_parameters(d, dp, bc, Nc ); + else +#endif /* FAST & USE_FLOAT_MUL */ +#ifdef LTP_CUT + if (S->ltp_cut) + Cut_Calculation_of_the_LTP_parameters(S, 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, [-120..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 ]; +} diff --git a/src/lpc.c b/src/lpc.c new file mode 100644 index 0000000..21b9faf --- /dev/null +++ b/src/lpc.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/lpc.c,v 1.5 1994/12/30 23:14:54 jutta Exp $ */ + +#include +#include + +#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 : (tempfast) 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); +} diff --git a/src/preprocess.c b/src/preprocess.c new file mode 100644 index 0000000..fa16efe --- /dev/null +++ b/src/preprocess.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/preprocess.c,v 1.2 1994/05/10 20:18:45 jutta Exp $ */ + +#include +#include + +#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; +} diff --git a/src/rpe.c b/src/rpe.c new file mode 100644 index 0000000..eda4f18 --- /dev/null +++ b/src/rpe.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/rpe.c,v 1.3 1994/05/10 20:18:46 jutta Exp $ */ + +#include +#include + +#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 ); + +} diff --git a/src/short_term.c b/src/short_term.c new file mode 100644 index 0000000..b93ed00 --- /dev/null +++ b/src/short_term.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/short_term.c,v 1.2 1994/05/10 20:18:47 jutta Exp $ */ + +#include +#include + +#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_TIMES_TWO, MIC, INVA ) \ + temp1 = GSM_ADD( *LARc++, MIC ) << 10; \ + temp1 = GSM_SUB( temp1, B_TIMES_TWO ); \ + temp1 = GSM_MULT_R( INVA, temp1 ); \ + *LARpp++ = GSM_ADD( temp1, temp1 ); + + STEP( 0, -32, 13107 ); + STEP( 0, -32, 13107 ); + STEP( 4096, -16, 13107 ); + STEP( -5120, -16, 13107 ); + + STEP( 188, -8, 19223 ); + STEP( -3584, -8, 17476 ); + STEP( -682, -4, 31454 ); + STEP( -2288, -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); +} diff --git a/src/table.c b/src/table.c new file mode 100644 index 0000000..0ed6f70 --- /dev/null +++ b/src/table.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/table.c,v 1.1 1992/10/28 00:15:50 jutta 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 }; diff --git a/src/toast.c b/src/toast.c new file mode 100644 index 0000000..c29baa7 --- /dev/null +++ b/src/toast.c @@ -0,0 +1,797 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/toast.c,v 1.8 1996/07/02 10:41:04 jutta 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; implies -p (-c) */ +int f_force = 0; /* don't ask about replacements (-f) */ +int f_precious = 0; /* avoid deletion of original (-p) */ +int f_fast = 0; /* use faster fpt algorithm (-F) */ +int f_verbose = 0; /* debugging (-V) */ +int f_ltp_cut = 0; /* LTP cut-off margin (-C) */ + +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 . + * The function (*input)() reads one such frame from . + * 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, (int)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)) != 0) 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 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 +#ifdef HAS_CHMOD + 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_CHMOD */ +#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 +#ifdef HAS_CHOWN + (void)chown(outname, instat.st_uid, instat.st_gid); +#endif /* HAS_CHOWN */ +#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 %d other link%s -- unchanged.\n", + progname, name, (int)(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; +#ifdef HAS__FSETMODE + _fsetmode(in, "b"); +#endif + } + 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; +#ifdef HAS__FSETMODE + _fsetmode(out, "b"); +#endif + } + 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); + (void)gsm_option(r, GSM_OPT_LTP_CUT, &f_ltp_cut); + + 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, (int)(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) +{ + 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. + */ +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.8 1996/07/02 10:41:04 jutta Exp $" ); +} + +static void help P0() +{ + printf("Usage: %s [-fcpdhvaulsFC] [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(" -C cutoff Ignore most samples during LTP\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, "fcdpvhuaslVFC:")) != 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; + case 'C': f_ltp_cut = 100; 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 [-fcpdhvuaslFC] [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); +} diff --git a/src/toast_alaw.c b/src/toast_alaw.c new file mode 100644 index 0000000..7799342 --- /dev/null +++ b/src/toast_alaw.c @@ -0,0 +1,334 @@ +/* + * 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/kbs/jutta/src/gsm/gsm-1.0/src/RCS/toast_alaw.c,v 1.2 1996/07/05 17:23:46 jutta 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[] = { + + 60032, 60288, 59520, 59776, 61056, 61312, 60544, 60800, + 57984, 58240, 57472, 57728, 59008, 59264, 58496, 58752, + 62784, 62912, 62528, 62656, 63296, 63424, 63040, 63168, + 61760, 61888, 61504, 61632, 62272, 62400, 62016, 62144, + 43520, 44544, 41472, 42496, 47616, 48640, 45568, 46592, + 35328, 36352, 33280, 34304, 39424, 40448, 37376, 38400, + 54528, 55040, 53504, 54016, 56576, 57088, 55552, 56064, + 50432, 50944, 49408, 49920, 52480, 52992, 51456, 51968, + 65192, 65208, 65160, 65176, 65256, 65272, 65224, 65240, + 65064, 65080, 65032, 65048, 65128, 65144, 65096, 65112, + 65448, 65464, 65416, 65432, 65512, 65528, 65480, 65496, + 65320, 65336, 65288, 65304, 65384, 65400, 65352, 65368, + 64160, 64224, 64032, 64096, 64416, 64480, 64288, 64352, + 63648, 63712, 63520, 63584, 63904, 63968, 63776, 63840, + 64848, 64880, 64784, 64816, 64976, 65008, 64912, 64944, + 64592, 64624, 64528, 64560, 64720, 64752, 64656, 64688, + 5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736, + 7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784, + 2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368, + 3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392, + 22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944, + 30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136, + 11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472, + 15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568, + 344, 328, 376, 360, 280, 264, 312, 296, + 472, 456, 504, 488, 408, 392, 440, 424, + 88, 72, 120, 104, 24, 8, 56, 40, + 216, 200, 248, 232, 152, 136, 184, 168, + 1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184, + 1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696, + 688, 656, 752, 720, 560, 528, 624, 592, + 944, 912, 1008, 976, 816, 784, 880, 848 + +}; + + +static unsigned char s2a[] = { + + 213,212,215,214,209,208,211,210,221,220,223,222,217,216,219,218, + 197,196,199,198,193,192,195,194,205,204,207,206,201,200,203,202, + 245,245,244,244,247,247,246,246,241,241,240,240,243,243,242,242, + 253,253,252,252,255,255,254,254,249,249,248,248,251,251,250,250, + 229,229,229,229,228,228,228,228,231,231,231,231,230,230,230,230, + 225,225,225,225,224,224,224,224,227,227,227,227,226,226,226,226, + 237,237,237,237,236,236,236,236,239,239,239,239,238,238,238,238, + 233,233,233,233,232,232,232,232,235,235,235,235,234,234,234,234, + 149,149,149,149,149,149,149,149,148,148,148,148,148,148,148,148, + 151,151,151,151,151,151,151,151,150,150,150,150,150,150,150,150, + 145,145,145,145,145,145,145,145,144,144,144,144,144,144,144,144, + 147,147,147,147,147,147,147,147,146,146,146,146,146,146,146,146, + 157,157,157,157,157,157,157,157,156,156,156,156,156,156,156,156, + 159,159,159,159,159,159,159,159,158,158,158,158,158,158,158,158, + 153,153,153,153,153,153,153,153,152,152,152,152,152,152,152,152, + 155,155,155,155,155,155,155,155,154,154,154,154,154,154,154,154, + 133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133, + 132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132, + 135,135,135,135,135,135,135,135,135,135,135,135,135,135,135,135, + 134,134,134,134,134,134,134,134,134,134,134,134,134,134,134,134, + 129,129,129,129,129,129,129,129,129,129,129,129,129,129,129,129, + 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, + 131,131,131,131,131,131,131,131,131,131,131,131,131,131,131,131, + 130,130,130,130,130,130,130,130,130,130,130,130,130,130,130,130, + 141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141, + 140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140, + 143,143,143,143,143,143,143,143,143,143,143,143,143,143,143,143, + 142,142,142,142,142,142,142,142,142,142,142,142,142,142,142,142, + 137,137,137,137,137,137,137,137,137,137,137,137,137,137,137,137, + 136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136, + 139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, + 138,138,138,138,138,138,138,138,138,138,138,138,138,138,138,138, + 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, + 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, + 183,183,183,183,183,183,183,183,183,183,183,183,183,183,183,183, + 183,183,183,183,183,183,183,183,183,183,183,183,183,183,183,183, + 182,182,182,182,182,182,182,182,182,182,182,182,182,182,182,182, + 182,182,182,182,182,182,182,182,182,182,182,182,182,182,182,182, + 177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177, + 177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177, + 176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176, + 176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176, + 179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179, + 179,179,179,179,179,179,179,179,179,179,179,179,179,179,179,179, + 178,178,178,178,178,178,178,178,178,178,178,178,178,178,178,178, + 178,178,178,178,178,178,178,178,178,178,178,178,178,178,178,178, + 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, + 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, + 191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191, + 191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191, + 190,190,190,190,190,190,190,190,190,190,190,190,190,190,190,190, + 190,190,190,190,190,190,190,190,190,190,190,190,190,190,190,190, + 185,185,185,185,185,185,185,185,185,185,185,185,185,185,185,185, + 185,185,185,185,185,185,185,185,185,185,185,185,185,185,185,185, + 184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,184, + 184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,184, + 187,187,187,187,187,187,187,187,187,187,187,187,187,187,187,187, + 187,187,187,187,187,187,187,187,187,187,187,187,187,187,187,187, + 186,186,186,186,186,186,186,186,186,186,186,186,186,186,186,186, + 186,186,186,186,186,186,186,186,186,186,186,186,186,186,186,186, + 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, + 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, + 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, + 167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167, + 167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167, + 167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167, + 167,167,167,167,167,167,167,167,167,167,167,167,167,167,167,167, + 166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166, + 166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166, + 166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166, + 166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166, + 161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161, + 161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161, + 161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161, + 161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161, + 160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160, + 160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160, + 160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160, + 160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160, + 163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163, + 163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163, + 163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163, + 163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163, + 162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162, + 162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162, + 162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162, + 162,162,162,162,162,162,162,162,162,162,162,162,162,162,162,162, + 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, + 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, + 172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172, + 172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172, + 172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172, + 172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172, + 175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175, + 175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175, + 175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175, + 175,175,175,175,175,175,175,175,175,175,175,175,175,175,175,175, + 174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174, + 174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174, + 174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174, + 174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174, + 169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169, + 169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169, + 169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169, + 169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169, + 168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168, + 168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168, + 168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168, + 168,168,168,168,168,168,168,168,168,168,168,168,168,168,168,168, + 171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171, + 171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171, + 171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171, + 171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171, + 170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170, + 170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170, + 170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170, + 170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, + 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, + 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, + 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, + 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 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, + 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, + 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, + 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, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 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, + 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, + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, + 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, + 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, + 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, + 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, + 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, + 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, + 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, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, + 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, + 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, + 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, + 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, + 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, + 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, + 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, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, + 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, + 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, + 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, + 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, + 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, + 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, + 106,106,106,106,107,107,107,107,104,104,104,104,105,105,105,105, + 110,110,110,110,111,111,111,111,108,108,108,108,109,109,109,109, + 98, 98, 98, 98, 99, 99, 99, 99, 96, 96, 96, 96, 97, 97, 97, 97, + 102,102,102,102,103,103,103,103,100,100,100,100,101,101,101,101, + 122,122,123,123,120,120,121,121,126,126,127,127,124,124,125,125, + 114,114,115,115,112,112,113,113,118,118,119,119,116,116,117,117, + 74, 75, 72, 73, 78, 79, 76, 77, 66, 67, 64, 65, 70, 71, 68, 69, + 90, 91, 88, 89, 94, 95, 92, 93, 82, 83, 80, 81, 86, 87, 84, 85 +}; + +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; +} + diff --git a/src/toast_audio.c b/src/toast_audio.c new file mode 100644 index 0000000..f090f23 --- /dev/null +++ b/src/toast_audio.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/toast_audio.c,v 1.6 1995/03/07 21:21:24 jutta 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 )) { + 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; + } + + while (len > 4*4) + if (getc(in) == EOF) { + fprintf(stderr, + "%s: EOF in header of Sun audio file \"%s\";\n\ + Try one of -u, -a, -l instead (%s -h for help).\n", + progname, inname ? inname : "stdin", progname); + return -1; + } + else len--; + + 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; +} + diff --git a/src/toast_lin.c b/src/toast_lin.c new file mode 100644 index 0000000..7b5f845 --- /dev/null +++ b/src/toast_lin.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/toast_lin.c,v 1.1 1992/10/28 00:15:50 jutta 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 ); +} diff --git a/src/toast_ulaw.c b/src/toast_ulaw.c new file mode 100644 index 0000000..14ef2d0 --- /dev/null +++ b/src/toast_ulaw.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/toast_ulaw.c,v 1.1 1992/10/28 00:15:50 jutta 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; +} diff --git a/tls/._bitter.c b/tls/._bitter.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._bitter.c differ diff --git a/tls/._bitter.dta b/tls/._bitter.dta new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._bitter.dta differ diff --git a/tls/._ginger.c b/tls/._ginger.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._ginger.c differ diff --git a/tls/._sour.c b/tls/._sour.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._sour.c differ diff --git a/tls/._sour1.dta b/tls/._sour1.dta new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._sour1.dta differ diff --git a/tls/._sour2.dta b/tls/._sour2.dta new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._sour2.dta differ diff --git a/tls/._sweet.c b/tls/._sweet.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._sweet.c differ diff --git a/tls/._taste.c b/tls/._taste.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._taste.c differ diff --git a/tls/._taste.h b/tls/._taste.h new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tls/._taste.h differ diff --git a/tls/bitter.c b/tls/bitter.c new file mode 100644 index 0000000..602d8d6 --- /dev/null +++ b/tls/bitter.c @@ -0,0 +1,66 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/bitter.c,v 1.1 1992/10/28 00:28:39 jutta Exp $*/ + +/* Generate code to pack a bit array from a name:#bits description */ + +#include +#include "taste.h" +#include "proto.h" + +void write_code P2((s_spex, n_spex), struct spex * s_spex, int n_spex) +{ + struct spex * sp = s_spex; + int bits = 8; + int vars; + + if (!n_spex) return; + + vars = sp->varsize; + + while (n_spex) { + + if (bits == 8) printf("\t*c++ = "); + else printf("\t | "); + + if (vars == bits) { + + printf( (bits==8? "%s & 0x%lX;\n" : "(%s & 0x%lX);\n"), + sp->var, + ~(0xfffffffe << (bits - 1))); + if (!-- n_spex) break; + sp++; + + vars = sp->varsize; + bits = 8; + + } else if (vars < bits) { + + printf( "((%s & 0x%lX) << %d)", + sp->var, + ~(0xfffffffe << (vars - 1)), + bits - vars); + bits -= vars; + if (!--n_spex) { + puts(";"); + break; + } + else putchar('\n'); + sp++; + vars = sp->varsize; + + } else { + printf("((%s >> %d) & 0x%X);\n", + sp->var, + vars - bits, + ~(0xfffffffe << (bits - 1))); + + vars -= bits; + bits = 8; + } + } +} diff --git a/tls/bitter.dta b/tls/bitter.dta new file mode 100644 index 0000000..d1c42e4 --- /dev/null +++ b/tls/bitter.dta @@ -0,0 +1,90 @@ +; +; 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. +; +; +; 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 diff --git a/tls/ginger.c b/tls/ginger.c new file mode 100644 index 0000000..d830e20 --- /dev/null +++ b/tls/ginger.c @@ -0,0 +1,54 @@ +/* + * Copyright 1996 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*/ + +/* Generate code to pack a bit array from a name:#bits description */ + +#include +#include "taste.h" +#include "proto.h" +#include + +/* This module is the opposite of sour. Sweet was already taken, + * that's why it's called ginger. (Add one point if that reminds + * you of Gary Larson.) + */ + +#define WORD_BITS 16 /* sizeof(uword) * CHAR_BIT on the + * target architecture---if this isn't 16, + * you're in trouble with this library anyway. + */ + +#define BYTE_BITS 8 /* CHAR_BIT on the target architecture--- + * if this isn't 8, you're in *deep* trouble. + */ + +void write_code P2((s_spex, n_spex), struct spex * s_spex, int n_spex) +{ + struct spex * sp = s_spex; + int n_in = 0; + + printf("uword sr = 0;\n"); + + for (; n_spex > 0; n_spex--, sp++) { + + while (n_in < sp->varsize) { + if (n_in) printf("sr |= (uword)*c++ << %d;\n", n_in); + else printf("sr = *c++;\n"); + n_in += BYTE_BITS; + } + + printf("%s = sr & %#x; sr >>= %d;\n", + sp->var, ~(~0U << sp->varsize), sp->varsize); + + n_in -= sp->varsize; + } + + if (n_in > 0) { + fprintf(stderr, "%d bits left over\n", n_in); + } +} diff --git a/tls/sour.c b/tls/sour.c new file mode 100644 index 0000000..b6932e6 --- /dev/null +++ b/tls/sour.c @@ -0,0 +1,91 @@ +/* + * Copyright 1996 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*/ + +/* Generate code to pack a bit array from a name:#bits description, + * WAV #49 style. + */ + +#include +#include "taste.h" +#include "proto.h" +#include + +/* This module goes back to one Jeff Chilton used for his implementation + * of the #49 WAV GSM format. (In his original patch 8, it replaced + * bitter.c.) + * + * In Microsoft's WAV #49 version of the GSM format, two 32 1/2 + * byte GSM frames are packed together to make one WAV frame, and + * the GSM parameters are packed into bytes right-to-left rather + * than left-to-right. + * + * That is, where toast's GSM format writes + * + * aaaaaabb bbbbcccc cdddddee ... + * ___1____ ___2____ ___3____ + * + * for parameters a (6 bits), b (6 bits), c (5 bits), d (5 bits), e .. + * the WAV format has + * + * bbaaaaaa ccccbbbb eedddddc ... + * ___1____ ___2____ ___3____ + * + * (This format looks a lot prettier if one pictures octets coming + * in through a fifo queue from the left, rather than waiting in the + * right-hand remainder of a C array.) + */ + +#define WORD_BITS 16 /* sizeof(uword) * CHAR_BIT on the + * target architecture---if this isn't 16, + * you're in trouble with this library anyway. + */ + +#define BYTE_BITS 8 /* CHAR_BIT on the target architecture--- + * if this isn't 8, you're in *deep* trouble. + */ + +void write_code P2((s_spex, n_spex), struct spex * s_spex, int n_spex) +{ + struct spex * sp = s_spex; + int n_in = 0; + + printf("uword sr = 0;\n"); + + for (; n_spex > 0; n_spex--, sp++) { + + /* insert old + * new var value unused + * here + * + * [____________xxxxxx**********] + * + * <----- n_in ------> + */ + printf("sr = sr >> %d | %s << %d;\n", + sp->varsize, + sp->var, + WORD_BITS - sp->varsize); + + n_in += sp->varsize; + + while (n_in >= BYTE_BITS) { + printf("*c++ = sr >> %d;\n", + WORD_BITS - n_in); + n_in -= BYTE_BITS; + } + } + + while (n_in >= BYTE_BITS) { + printf("*c++ = sr >> %d;\n", WORD_BITS - n_in); + n_in -= BYTE_BITS; + } + + if (n_in > 0) { + fprintf(stderr, "warning: %d bits left over\n", n_in); + } +} diff --git a/tls/sour1.dta b/tls/sour1.dta new file mode 100644 index 0000000..770b24c --- /dev/null +++ b/tls/sour1.dta @@ -0,0 +1,88 @@ +; +; 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. +; +; +; Variable Size + +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 diff --git a/tls/sour2.dta b/tls/sour2.dta new file mode 100644 index 0000000..f56545c --- /dev/null +++ b/tls/sour2.dta @@ -0,0 +1,90 @@ +; +; 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. +; +; +; Variable Size + +g->chain 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 diff --git a/tls/sweet.c b/tls/sweet.c new file mode 100644 index 0000000..6a6fb29 --- /dev/null +++ b/tls/sweet.c @@ -0,0 +1,66 @@ + /* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/sweet.c,v 1.2 1996/07/02 10:15:53 jutta Exp $*/ + +/* Generate code to unpack a bit array from name:#bits description */ + +#include +#include "taste.h" +#include "proto.h" + +void write_code P2((s_spex, n_spex), struct spex * s_spex, int n_spex) +{ + struct spex * sp = s_spex; + int bits = 8; + int vars; + + if (!n_spex) return; + + vars = sp->varsize; + + while (n_spex) { + + if (vars == sp->varsize) { + printf("\t%s = ", sp->var); + } else printf("\t%s |= ", sp->var); + + if (vars == bits) { + + if (bits == 8) printf( "*c++;\n" ); + else printf( "*c++ & 0x%lX;\n", + ~(0xfffffffe << (bits - 1)) ); + + if (!-- n_spex) break; + sp++; + vars = sp->varsize; + bits = 8; + + } else if (vars < bits) { + + printf( "(*c >> %d) & 0x%lX;\n", + bits - vars, + ~(0xfffffffe << (vars - 1))); + + bits -= vars; + if (!--n_spex) break; + sp++; + vars = sp->varsize; + + } else { + /* vars > bits. We're eating lower-all of c, + * but we must shift it. + */ + printf( "(*c++ & 0x%X) << %d;\n", + ~(0xfffffffe << (bits - 1)), + vars - bits ); + + vars -= bits; + bits = 8; + } + } +} + diff --git a/tls/taste.c b/tls/taste.c new file mode 100644 index 0000000..4bc84ad --- /dev/null +++ b/tls/taste.c @@ -0,0 +1,139 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/taste.c,v 1.1 1992/10/28 00:28:39 jutta Exp $*/ + +#include +#include +#include + +#include "config.h" + +#ifdef HAS_STDLIB_H +# include +#else +#include "proto.h" +# ifdef HAS_MALLOC_H +# include +# else + extern char * malloc P((char *)), * realloc P((char *,int)); +# endif + extern int exit P((int)); +#endif + +#include "proto.h" + +/* + * common code to sweet.c and bitter.c: read the name:#bits description. + */ + +#include "taste.h" + +static struct spex * s_spex; +static int n_spex, m_spex; + +extern void write_code P((struct spex *, int)); + +char * strsave P1((str), char * str) /* strdup() + errors */ +{ + int n = strlen(str) + 1; + char * s = malloc(n); + if (!s) { + fprintf(stderr, "Failed to malloc %d bytes, abort\n", + strlen(str) + 1); + exit(1); + } + return memcpy(s, str, n); +} + +struct spex * new_spex P0() +{ + if (n_spex >= m_spex) { + m_spex += 500; + if (!(s_spex = (struct spex *)(n_spex + ? realloc((char *)s_spex, m_spex * sizeof(*s_spex)) + : malloc( m_spex * sizeof(*s_spex))))) { + fprintf(stderr, "Failed to malloc %d bytes, abort\n", + m_spex * sizeof(*s_spex)); + exit(1); + } + } + return s_spex + n_spex; +} + +char * strtek P2((str, sep), char * str, char * sep) { + + static char * S = (char *)0; + char * c, * base; + + if (str) S = str; + + if (!S || !*S) return (char *)0; + + /* Skip delimiters. + */ + while (*S) { + for (c = sep; *c && *c != *S; c++) ; + if (*c) *S++ = 0; + else break; + } + + base = S; + + /* Skip non-delimiters. + */ + for (base = S; *S; S++) { + + for (c = sep; *c; c++) + if (*c == *S) { + *S++ = 0; + return base; + } + } + + return base == S ? (char *)0 : base; +} + +int read_spex P0() +{ + char buf[200]; + char * s, *t; + struct spex * sp = s_spex; + + while (fgets(buf, sizeof buf, stdin)) { + + char * nl; + + if (nl = strchr(buf, '\n')) + *nl = '\0'; + + if (!*buf || *buf == ';') continue; + s = strtek(buf, " \t"); + if (!s) { + fprintf(stderr, "? %s\n", buf); + continue; + } + sp = new_spex(); + sp->var = strsave(s); + s = strtek((char*)0, " \t"); + if (!s) { + fprintf(stderr, "varsize?\n"); + continue; + } + sp->varsize = strtol(s, (char **)0, 0); + n_spex++; + } + + return sp - s_spex; +} + +int main P0() +{ + read_spex(); + write_code(s_spex, n_spex); + + exit(0); +} diff --git a/tls/taste.h b/tls/taste.h new file mode 100644 index 0000000..2fc85ef --- /dev/null +++ b/tls/taste.h @@ -0,0 +1,20 @@ +/* + * 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. + */ + +/* + * common code to sweet.c and bitter.c + */ + +#ifndef TASTE_H +#define TASTE_H + +struct spex { + + char * var; + int varsize; +} ; + +#endif /* TASTE_H */ diff --git a/tst/._cod2lin.c b/tst/._cod2lin.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tst/._cod2lin.c differ diff --git a/tst/._cod2txt.c b/tst/._cod2txt.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tst/._cod2txt.c differ diff --git a/tst/._gsm2cod.c b/tst/._gsm2cod.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tst/._gsm2cod.c differ diff --git a/tst/._lin2cod.c b/tst/._lin2cod.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tst/._lin2cod.c differ diff --git a/tst/._lin2txt.c b/tst/._lin2txt.c new file mode 100644 index 0000000..82ee29b Binary files /dev/null and b/tst/._lin2txt.c differ diff --git a/tst/._run b/tst/._run new file mode 100755 index 0000000..82ee29b Binary files /dev/null and b/tst/._run differ diff --git a/tst/cod2lin.c b/tst/cod2lin.c new file mode 100644 index 0000000..07a9510 --- /dev/null +++ b/tst/cod2lin.c @@ -0,0 +1,104 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/cod2lin.c,v 1.2 1996/07/02 14:33:10 jutta Exp jutta $*/ + +#include +#include + +#include "gsm.h" +#include "proto.h" + +char * pname; + +int debug = 0; +int verbosity = 0; +int fast = 0; +int wav = 0; +int error = 0; + +usage P0() +{ + fprintf(stderr, "Usage: %s [-vwF] [files...]\n", pname); + exit(1); +} + +void process P2((f, filename), FILE * f, char * filename) +{ + gsm_frame buf; + gsm_signal source[160]; + + int cc; + gsm r; + + (void)memset(source, 0x00, sizeof(source)); + + if (!(r = gsm_create())) { + perror("gsm_create"); + error = 1; + return ; + } + gsm_option(r, GSM_OPT_VERBOSE, &verbosity); + gsm_option(r, GSM_OPT_FAST, &fast); + gsm_option(r, GSM_OPT_WAV49, &wav); + for (;;) { + cc = fread((char *)source, sizeof(*source), 76, f); + if (cc == 0) { + gsm_destroy(r); + return; + } + if (cc != 76) { + error = 1; + fprintf(stderr, + "%s: %s -- %d trailing bytes ignored\n", + pname, filename, cc); + gsm_destroy(r); + return; + } + + gsm_implode(r, source, buf); + gsm_decode(r, buf, source); + + if (write(1, source, sizeof(source)) != sizeof(source)) { + perror("write"); + error = 1; + gsm_destroy(r); + return; + } + } +} + +main P2((ac, av), int ac, char ** av) +{ + int opt; + extern char * optarg; + extern int optind; + + FILE * f; + + if (!(pname = av[0])) pname = "cod2out"; + + while ((opt = getopt(ac, av, "vwF")) != EOF) switch (opt) { + case 'v': verbosity++; break; + case 'w': wav++; break; + case 'F': fast++; break; + default: usage(); + } + + ac -= optind; + av += optind; + + if (!ac) process(stdin, "*stdin*"); + else for (; *av; av++) { + if (!(f = fopen(*av, "r"))) perror(*av); + else { + process(f, *av); + fclose(f); + } + } + + exit(error); +} diff --git a/tst/cod2txt.c b/tst/cod2txt.c new file mode 100644 index 0000000..71c362e --- /dev/null +++ b/tst/cod2txt.c @@ -0,0 +1,94 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/cod2txt.c,v 1.1 1994/10/21 20:52:11 jutta Exp $*/ + +#include +#include + +#include "gsm.h" +#include "proto.h" + +char * pname; + +int debug = 0; +int verbosity = 0; +int error = 0; + +usage P0() +{ + fprintf(stderr, "Usage: %s [files...]\n", pname); + exit(1); +} + +void process P2((f, filename), FILE * f, char * filename) +{ + gsm_frame buf; + gsm_signal source[160]; + + int cc; + gsm r; + int nr=0; + + (void)memset(source, 0, sizeof(source)); + + if (!(r = gsm_create())) { + perror("gsm_create"); + error = 1; + return ; + } + gsm_option(r, GSM_OPT_VERBOSE, &verbosity); + for (;;) { + cc = fread((char *)source, sizeof(*source), 76, f); + if (cc == 0) { + gsm_destroy(r); + return; + } + if (cc != 76) { + error = 1; + fprintf(stderr, + "%s: %s -- %d trailing bytes ignored\n", + pname, filename, cc); + gsm_destroy(r); + return; + } + + gsm_implode(r, source, buf); + printf("[%d] ", ++nr); + if (gsm_print(stdout, r, buf)) { + fprintf(stderr, + "%s: %s: bad magic\n", pname, filename); + gsm_destroy(r); + return; + + } + } +} + +main P2((ac, av), int ac, char ** av) +{ + int opt; + extern char * optarg; + extern int optind; + + FILE * f; + + if (!(pname = av[0])) pname = "cod2txt"; + + ac--; + av++; + + if (!ac) process(stdin, "*stdin*"); + else for (; *av; av++) { + if (!(f = fopen(*av, "r"))) perror(*av); + else { + process(f, *av); + fclose(f); + } + } + + exit(error); +} diff --git a/tst/gsm2cod.c b/tst/gsm2cod.c new file mode 100644 index 0000000..f2e7c2c --- /dev/null +++ b/tst/gsm2cod.c @@ -0,0 +1,93 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/gsm2cod.c,v 1.1 1994/10/21 20:52:11 jutta Exp $*/ + +#include +#include + +#include "gsm.h" +#include "proto.h" + +char * pname; + +int debug = 0; +int verbosity = 0; +int error = 0; + +usage P0() +{ + fprintf(stderr, "Usage: %s [files...]\n", pname); + exit(1); +} + +void process P2((f, filename), FILE * f, char * filename) +{ + gsm_frame buf; + gsm_signal source[76]; + + int cc; + gsm r; + int nr=0; + + (void)memset(source, 0, sizeof(source)); + + if (!(r = gsm_create())) { + perror("gsm_create"); + error = 1; + return ; + } + gsm_option(r, GSM_OPT_VERBOSE, &verbosity); + for (;;) { + cc = fread((char *)buf, sizeof(buf), 1, f); + if (cc == 0) { + gsm_destroy(r); + return; + } + if (cc != 1) { + error = 1; + fprintf(stderr, + "%s: %s -- trailing bytes ignored\n", + pname, filename); + gsm_destroy(r); + return; + } + + gsm_explode(r, buf, source); + if (write(1, (char *)source, sizeof(source))!= sizeof(source)) { + + perror("write"); + error = 1; + gsm_destroy(r); + return; + } + } +} + +main P2((ac, av), int ac, char ** av) +{ + int opt; + extern char * optarg; + extern int optind; + + FILE * f; + + if (!(pname = av[0])) pname = "gsm2cod"; + + ac--; + av++; + + if (!ac) process(stdin, "*stdin*"); + else for (; *av; av++) { + if (!(f = fopen(*av, "r"))) perror(*av); + else { + process(f, *av); + fclose(f); + } + } + + exit(error); +} diff --git a/tst/lin2cod.c b/tst/lin2cod.c new file mode 100644 index 0000000..2c42b10 --- /dev/null +++ b/tst/lin2cod.c @@ -0,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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/lin2cod.c,v 1.2 1996/07/02 14:33:13 jutta Exp jutta $*/ + +#include + +#include "gsm.h" +#include "proto.h" + +char * pname; + +int debug = 0; +int verbosity = 0; +int fast = 0; +int wav = 0; +int error = 0; + +usage P0() +{ + fprintf(stderr, "Usage: %s [-vwF] [files...]\n", pname); + exit(1); +} + +void process P2((f, filename), FILE * f, char * filename) +{ + gsm_frame buf; + short source[160]; + int cc; + gsm r; + + if (!(r = gsm_create())) { + perror("gsm_create"); + error = 1; + return ; + } + gsm_option(r, GSM_OPT_VERBOSE, &verbosity); + gsm_option(r, GSM_OPT_FAST, &fast); + gsm_option(r, GSM_OPT_WAV49, &wav); + for (;;) { + + if ((cc = fread((char *)source, 1, sizeof(source), f)) == 0) { + gsm_destroy(r); +#ifdef COUNT_OVERFLOW + dump_overflow(stderr); +#endif + return; + } + + if (cc != sizeof(source)) { + error = 1; + perror(filename); + fprintf(stderr, "%s: cannot read input from %s\n", + pname, filename); + gsm_destroy(r); + return; + } + + gsm_encode(r, source, buf); + gsm_explode(r, buf, source); /* 76 shorts */ + if (write(1, source, sizeof(*source) * 76) + != sizeof(*source) * 76) { + + perror("write"); + error = 1; + gsm_destroy(r); + return; + } + } +} + +main P2((ac, av), int ac, char ** av) +{ + int opt; + extern char * optarg; + extern int optind; + + FILE * f; + + if (!(pname = av[0])) pname = "inp2cod"; + + while ((opt = getopt(ac, av, "vwF")) != EOF) switch (opt) { + case 'v': verbosity++; break; + case 'w': wav++; break; + case 'F': fast++; break; + default: usage(); + } + + ac -= optind; + av += optind; + + if (!ac) process(stdin, "*stdin*"); + else for (; *av; av++) { + if (!(f = fopen(*av, "r"))) perror(*av); + else { + process(f, *av); + fclose(f); + } + } + + exit(error); +} diff --git a/tst/lin2txt.c b/tst/lin2txt.c new file mode 100644 index 0000000..fb39504 --- /dev/null +++ b/tst/lin2txt.c @@ -0,0 +1,94 @@ +/* + * 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: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/lin2txt.c,v 1.1 1994/10/21 20:52:11 jutta Exp $*/ + +#include + +#include "gsm.h" +#include "proto.h" + +char * pname; + +int debug = 0; +int verbosity = 0; +int error = 0; + +usage P0() +{ + fprintf(stderr, "Usage: %s [-v] [files...]\n", pname); + exit(1); +} + +void process P2((f, filename), FILE * f, char * filename) +{ + short source[160]; + int cc, j, k; + gsm r; + + if (!(r = gsm_create())) { + perror("gsm_create"); + error = 1; + return ; + } + gsm_option(r, GSM_OPT_VERBOSE, &verbosity); + for (;;) { + + if ((cc = fread((char *)source, 1, sizeof(source), f)) == 0) { + gsm_destroy(r); +#ifdef COUNT_OVERFLOW + dump_overflow(stderr); +#endif + return; + } + + printf("{\t"); + for (j = 0; j < 4; j++) { + printf("{\t"); + for (k = 0; k < 40; k++) { + printf("%d", (int)source[ j * 40 + k ]); + if (k < 39) { + printf(", "); + if (k % 4 == 3) printf("\n\t\t"); + } else { + printf("\t}"); + if (j == 3) printf("\t},\n"); + else printf(",\n\t"); + } + } + } + } +} + +main P2((ac, av), int ac, char ** av) +{ + int opt; + extern char * optarg; + extern int optind; + + FILE * f; + + if (!(pname = av[0])) pname = "inp2txt"; + + while ((opt = getopt(ac, av, "v")) != EOF) switch (opt) { + case 'v': verbosity++; break; + default: usage(); + } + + ac -= optind; + av += optind; + + if (!ac) process(stdin, "*stdin*"); + else for (; *av; av++) { + if (!(f = fopen(*av, "r"))) perror(*av); + else { + process(f, *av); + fclose(f); + } + } + + exit(error); +} diff --git a/tst/run b/tst/run new file mode 100755 index 0000000..5eec3b2 --- /dev/null +++ b/tst/run @@ -0,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. +# +if [ ! -f 1.inp ] ; then + echo Sorry, but we cannot provide the test data with this release. + exit +fi + +echo -n 'Linear to code: ' +for i in 1 2 3 4 +do + echo -n $i.. + ./lin2cod < $i.inp | cmp - $i.cod +done +echo "" + +echo -n 'Code to linear: ' +for i in 1 2 3 4 +do + echo -n $i.. + ./cod2lin < $i.cod | cmp - $i.out +done +echo "" + +echo -n 'Toast: ' +for i in 1 2 3 4 +do + echo -n $i.. + ../bin/toast -l < $i.inp | ../bin/toast -dl | cmp - $i.out +done +echo ""