-/*\r
- * config.h\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#ifndef CONFIG_H\r
-#define CONFIG_H\r
-\r
-/*efine SIGHANDLER_T int * signal handlers are void */\r
-/*efine HAS_SYSV_SIGNAL 1 * sigs not blocked/reset? */\r
-\r
-#define HAS_STDLIB_H 1 /* /usr/include/stdlib.h */\r
-/*efine HAS_LIMITS_H 1 * /usr/include/limits.h */\r
-#define HAS_FCNTL_H 1 /* /usr/include/fcntl.h */\r
-/*efine HAS_ERRNO_DECL 1 * errno.h declares errno */\r
-\r
-#define HAS_FSTAT 1 /* fstat syscall */\r
-#define HAS_FCHMOD 1 /* fchmod syscall */\r
-#define HAS_CHMOD 1 /* chmod syscall */\r
-#define HAS_FCHOWN 1 /* fchown syscall */\r
-#define HAS_CHOWN 1 /* chown syscall */\r
-/*efine HAS__FSETMODE 1 * _fsetmode -- set file mode */\r
-\r
-#define HAS_STRING_H 1 /* /usr/include/string.h */\r
-/*efine HAS_STRINGS_H 1 * /usr/include/strings.h */\r
-\r
-#define HAS_UNISTD_H 1 /* /usr/include/unistd.h */\r
-#define HAS_UTIME 1 /* POSIX utime(path, times) */\r
-/*efine HAS_UTIMES 1 * use utimes() syscall instead */\r
-#define HAS_UTIME_H 1 /* UTIME header file */\r
-/*efine HAS_UTIMBUF 1 * struct utimbuf */\r
-/*efine HAS_UTIMEUSEC 1 * microseconds in utimbuf? */\r
-\r
-#endif /* CONFIG_H */\r
+/*
+ * config.h
+ *
+ * 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.
+ */
+
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/*efine SIGHANDLER_T int * signal handlers are void */
+/*efine HAS_SYSV_SIGNAL 1 * sigs not blocked/reset? */
+
+#define HAS_STDLIB_H 1 /* /usr/include/stdlib.h */
+/*efine HAS_LIMITS_H 1 * /usr/include/limits.h */
+#define HAS_FCNTL_H 1 /* /usr/include/fcntl.h */
+/*efine HAS_ERRNO_DECL 1 * errno.h declares errno */
+
+#define HAS_FSTAT 1 /* fstat syscall */
+#define HAS_FCHMOD 1 /* fchmod syscall */
+#define HAS_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 */
+/*efine HAS_UTIMBUF 1 * struct utimbuf */
+/*efine HAS_UTIMEUSEC 1 * microseconds in utimbuf? */
+
+#endif /* CONFIG_H */
-/*\r
- * gsm.h\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#ifndef GSM_H\r
-#define GSM_H\r
-\r
-#ifdef __cplusplus\r
-# define NeedFunctionPrototypes 1\r
-#endif\r
-\r
-#if __STDC__\r
-# define NeedFunctionPrototypes 1\r
-#endif\r
-\r
-#ifdef _NO_PROTO\r
-# undef NeedFunctionPrototypes\r
-#endif\r
-\r
-#ifdef NeedFunctionPrototypes\r
-# include <stdio.h> /* for FILE * */\r
-#endif\r
-\r
-#undef GSM_P\r
-#if NeedFunctionPrototypes\r
-# define GSM_P( protos ) protos\r
-#else\r
-# define GSM_P( protos ) ( /* protos */ )\r
-#endif\r
-\r
-/*\r
- * Interface\r
- */\r
-\r
-typedef struct gsm_state * gsm;\r
-typedef short gsm_signal; /* signed 16 bit */\r
-typedef unsigned char gsm_byte;\r
-typedef gsm_byte gsm_frame[33]; /* 33 * 8 bits */\r
-\r
-#define GSM_MAGIC 0xD /* 13 kbit/s RPE-LTP */\r
-\r
-#define GSM_PATCHLEVEL 10\r
-#define GSM_MINOR 0\r
-#define GSM_MAJOR 1\r
-\r
-#define GSM_OPT_VERBOSE 1\r
-#define GSM_OPT_FAST 2\r
-#define GSM_OPT_LTP_CUT 3\r
-#define GSM_OPT_WAV49 4\r
-#define GSM_OPT_FRAME_INDEX 5\r
-#define GSM_OPT_FRAME_CHAIN 6\r
-\r
-extern gsm gsm_create GSM_P((void));\r
-extern void gsm_destroy GSM_P((gsm)); \r
-\r
-extern int gsm_print GSM_P((FILE *, gsm, gsm_byte *));\r
-extern int gsm_option GSM_P((gsm, int, int *));\r
-\r
-extern void gsm_encode GSM_P((gsm, gsm_signal *, gsm_byte *));\r
-extern int gsm_decode GSM_P((gsm, gsm_byte *, gsm_signal *));\r
-\r
-extern int gsm_explode GSM_P((gsm, gsm_byte *, gsm_signal *));\r
-extern void gsm_implode GSM_P((gsm, gsm_signal *, gsm_byte *));\r
-\r
-#undef GSM_P\r
-\r
-#endif /* GSM_H */\r
+/*
+ * gsm.h
+ *
+ * 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.
+ */
+
+
+#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 <stdio.h> /* 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 10
+#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 */
-/*\r
- * private.h\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#ifndef PRIVATE_H\r
-#define PRIVATE_H\r
-\r
-typedef short word; /* 16 bit signed int */\r
-typedef long longword; /* 32 bit signed int */\r
-\r
-typedef unsigned short uword; /* unsigned word */\r
-typedef unsigned long ulongword; /* unsigned longword */\r
-\r
-struct gsm_state {\r
-\r
- word dp0[ 280 ];\r
-\r
- word z1; /* preprocessing.c, Offset_com. */\r
- longword L_z2; /* Offset_com. */\r
- int mp; /* Preemphasis */\r
-\r
- word u[8]; /* short_term_aly_filter.c */\r
- word LARpp[2][8]; /* */\r
- word j; /* */\r
-\r
- word ltp_cut; /* long_term.c, LTP crosscorr. */\r
- word nrp; /* 40 */ /* long_term.c, synthesis */\r
- word v[9]; /* short_term.c, synthesis */\r
- word msr; /* decoder.c, Postprocessing */\r
-\r
- char verbose; /* only used if !NDEBUG */\r
- char fast; /* only used if FAST */\r
-\r
- char wav_fmt; /* only used if WAV49 defined */\r
- unsigned char frame_index; /* odd/even chaining */\r
- unsigned char frame_chain; /* half-byte to carry forward */\r
-};\r
-\r
-\r
-#define MIN_WORD (-32767 - 1)\r
-#define MAX_WORD 32767\r
-\r
-#define MIN_LONGWORD (-2147483647 - 1)\r
-#define MAX_LONGWORD 2147483647\r
-\r
-#ifdef SASR /* flag: >> is a signed arithmetic shift right */\r
-#undef SASR\r
-#define SASR(x, by) ((x) >> (by))\r
-#else\r
-#define SASR(x, by) ((x) >= 0 ? (x) >> (by) : (~(-((x) + 1) >> (by))))\r
-#endif /* SASR */\r
-\r
-#include "proto.h"\r
-\r
-/*\r
- * Prototypes from add.c\r
- */\r
-extern word gsm_mult P((word a, word b));\r
-extern longword gsm_L_mult P((word a, word b));\r
-extern word gsm_mult_r P((word a, word b));\r
-\r
-extern word gsm_div P((word num, word denum));\r
-\r
-extern word gsm_add P(( word a, word b ));\r
-extern longword gsm_L_add P(( longword a, longword b ));\r
-\r
-extern word gsm_sub P((word a, word b));\r
-extern longword gsm_L_sub P((longword a, longword b));\r
-\r
-extern word gsm_abs P((word a));\r
-\r
-extern word gsm_norm P(( longword a ));\r
-\r
-extern longword gsm_L_asl P((longword a, int n));\r
-extern word gsm_asl P((word a, int n));\r
-\r
-extern longword gsm_L_asr P((longword a, int n));\r
-extern word gsm_asr P((word a, int n));\r
-\r
-/*\r
- * Inlined functions from add.h \r
- */\r
-\r
-/* \r
- * #define GSM_MULT_R(a, b) (* word a, word b, !(a == b == MIN_WORD) *) \\r
- * (0x0FFFF & SASR(((longword)(a) * (longword)(b) + 16384), 15))\r
- */\r
-#define GSM_MULT_R(a, b) /* word a, word b, !(a == b == MIN_WORD) */ \\r
- (SASR( ((longword)(a) * (longword)(b) + 16384), 15 ))\r
-\r
-# define GSM_MULT(a,b) /* word a, word b, !(a == b == MIN_WORD) */ \\r
- (SASR( ((longword)(a) * (longword)(b)), 15 ))\r
-\r
-# define GSM_L_MULT(a, b) /* word a, word b */ \\r
- (((longword)(a) * (longword)(b)) << 1)\r
-\r
-# define GSM_L_ADD(a, b) \\r
- ( (a) < 0 ? ( (b) >= 0 ? (a) + (b) \\r
- : (utmp = (ulongword)-((a) + 1) + (ulongword)-((b) + 1)) \\r
- >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)utmp-2 ) \\r
- : ((b) <= 0 ? (a) + (b) \\r
- : (utmp = (ulongword)(a) + (ulongword)(b)) >= MAX_LONGWORD \\r
- ? MAX_LONGWORD : utmp))\r
-\r
-/*\r
- * # define GSM_ADD(a, b) \\r
- * ((ltmp = (longword)(a) + (longword)(b)) >= MAX_WORD \\r
- * ? MAX_WORD : ltmp <= MIN_WORD ? MIN_WORD : ltmp)\r
- */\r
-/* Nonportable, but faster: */\r
-\r
-#define GSM_ADD(a, b) \\r
- ((ulongword)((ltmp = (longword)(a) + (longword)(b)) - MIN_WORD) > \\r
- MAX_WORD - MIN_WORD ? (ltmp > 0 ? MAX_WORD : MIN_WORD) : ltmp)\r
-\r
-# define GSM_SUB(a, b) \\r
- ((ltmp = (longword)(a) - (longword)(b)) >= MAX_WORD \\r
- ? MAX_WORD : ltmp <= MIN_WORD ? MIN_WORD : ltmp)\r
-\r
-# define GSM_ABS(a) ((a) < 0 ? ((a) == MIN_WORD ? MAX_WORD : -(a)) : (a))\r
-\r
-/* Use these if necessary:\r
-\r
-# define GSM_MULT_R(a, b) gsm_mult_r(a, b)\r
-# define GSM_MULT(a, b) gsm_mult(a, b)\r
-# define GSM_L_MULT(a, b) gsm_L_mult(a, b)\r
-\r
-# define GSM_L_ADD(a, b) gsm_L_add(a, b)\r
-# define GSM_ADD(a, b) gsm_add(a, b)\r
-# define GSM_SUB(a, b) gsm_sub(a, b)\r
-\r
-# define GSM_ABS(a) gsm_abs(a)\r
-\r
-*/\r
-\r
-/*\r
- * More prototypes from implementations..\r
- */\r
-extern void Gsm_Coder P((\r
- struct gsm_state * S,\r
- word * s, /* [0..159] samples IN */\r
- word * LARc, /* [0..7] LAR coefficients OUT */\r
- word * Nc, /* [0..3] LTP lag OUT */\r
- word * bc, /* [0..3] coded LTP gain OUT */\r
- word * Mc, /* [0..3] RPE grid selection OUT */\r
- word * xmaxc,/* [0..3] Coded maximum amplitude OUT */\r
- word * xMc /* [13*4] normalized RPE samples OUT */));\r
-\r
-extern void Gsm_Long_Term_Predictor P(( /* 4x for 160 samples */\r
- struct gsm_state * S,\r
- word * d, /* [0..39] residual signal IN */\r
- word * dp, /* [-120..-1] d' IN */\r
- word * e, /* [0..40] OUT */\r
- word * dpp, /* [0..40] OUT */\r
- word * Nc, /* correlation lag OUT */\r
- word * bc /* gain factor OUT */));\r
-\r
-extern void Gsm_LPC_Analysis P((\r
- struct gsm_state * S,\r
- word * s, /* 0..159 signals IN/OUT */\r
- word * LARc)); /* 0..7 LARc's OUT */\r
-\r
-extern void Gsm_Preprocess P((\r
- struct gsm_state * S,\r
- word * s, word * so));\r
-\r
-extern void Gsm_Encoding P((\r
- struct gsm_state * S,\r
- word * e, \r
- word * ep, \r
- word * xmaxc,\r
- word * Mc, \r
- word * xMc));\r
-\r
-extern void Gsm_Short_Term_Analysis_Filter P((\r
- struct gsm_state * S,\r
- word * LARc, /* coded log area ratio [0..7] IN */\r
- word * d /* st res. signal [0..159] IN/OUT */));\r
-\r
-extern void Gsm_Decoder P((\r
- struct gsm_state * S,\r
- word * LARcr, /* [0..7] IN */\r
- word * Ncr, /* [0..3] IN */\r
- word * bcr, /* [0..3] IN */\r
- word * Mcr, /* [0..3] IN */\r
- word * xmaxcr, /* [0..3] IN */\r
- word * xMcr, /* [0..13*4] IN */\r
- word * s)); /* [0..159] OUT */\r
-\r
-extern void Gsm_Decoding P((\r
- struct gsm_state * S,\r
- word xmaxcr,\r
- word Mcr,\r
- word * xMcr, /* [0..12] IN */\r
- word * erp)); /* [0..39] OUT */\r
-\r
-extern void Gsm_Long_Term_Synthesis_Filtering P((\r
- struct gsm_state* S,\r
- word Ncr,\r
- word bcr,\r
- word * erp, /* [0..39] IN */\r
- word * drp)); /* [-120..-1] IN, [0..40] OUT */\r
-\r
-void Gsm_RPE_Decoding P((\r
- struct gsm_state *S,\r
- word xmaxcr,\r
- word Mcr,\r
- word * xMcr, /* [0..12], 3 bits IN */\r
- word * erp)); /* [0..39] OUT */\r
-\r
-void Gsm_RPE_Encoding P((\r
- struct gsm_state * S,\r
- word * e, /* -5..-1][0..39][40..44 IN/OUT */\r
- word * xmaxc, /* OUT */\r
- word * Mc, /* OUT */\r
- word * xMc)); /* [0..12] OUT */\r
-\r
-extern void Gsm_Short_Term_Synthesis_Filter P((\r
- struct gsm_state * S,\r
- word * LARcr, /* log area ratios [0..7] IN */\r
- word * drp, /* received d [0...39] IN */\r
- word * s)); /* signal s [0..159] OUT */\r
-\r
-extern void Gsm_Update_of_reconstructed_short_time_residual_signal P((\r
- word * dpp, /* [0...39] IN */\r
- word * ep, /* [0...39] IN */\r
- word * dp)); /* [-120...-1] IN/OUT */\r
-\r
-/*\r
- * Tables from table.c\r
- */\r
-#ifndef GSM_TABLE_C\r
-\r
-extern word gsm_A[8], gsm_B[8], gsm_MIC[8], gsm_MAC[8];\r
-extern word gsm_INVA[8];\r
-extern word gsm_DLB[4], gsm_QLB[4];\r
-extern word gsm_H[11];\r
-extern word gsm_NRFAC[8];\r
-extern word gsm_FAC[8];\r
-\r
-#endif /* GSM_TABLE_C */\r
-\r
-/*\r
- * Debugging\r
- */\r
-#ifdef NDEBUG\r
-\r
-# define gsm_debug_words(a, b, c, d) /* nil */\r
-# define gsm_debug_longwords(a, b, c, d) /* nil */\r
-# define gsm_debug_word(a, b) /* nil */\r
-# define gsm_debug_longword(a, b) /* nil */\r
-\r
-#else /* !NDEBUG => DEBUG */\r
-\r
- extern void gsm_debug_words P((char * name, int, int, word *));\r
- extern void gsm_debug_longwords P((char * name, int, int, longword *));\r
- extern void gsm_debug_longword P((char * name, longword));\r
- extern void gsm_debug_word P((char * name, word));\r
-\r
-#endif /* !NDEBUG */\r
-\r
-#include "unproto.h"\r
-\r
-#endif /* PRIVATE_H */\r
+/*
+ * private.h
+ *
+ * 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.
+ */
+
+
+#ifndef PRIVATE_H
+#define PRIVATE_H
+
+typedef short word; /* 16 bit signed int */
+typedef long longword; /* 32 bit signed int */
+
+typedef unsigned short uword; /* unsigned word */
+typedef unsigned long ulongword; /* unsigned longword */
+
+struct gsm_state {
+
+ word dp0[ 280 ];
+
+ word z1; /* preprocessing.c, Offset_com. */
+ longword L_z2; /* Offset_com. */
+ int mp; /* Preemphasis */
+
+ word u[8]; /* short_term_aly_filter.c */
+ word LARpp[2][8]; /* */
+ word j; /* */
+
+ word 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 */
-/*\r
- * proto.h\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#ifndef PROTO_H\r
-#define PROTO_H\r
-\r
-#if __cplusplus\r
-# define NeedFunctionPrototypes 1\r
-#endif\r
-\r
-#if __STDC__\r
-# define NeedFunctionPrototypes 1\r
-#endif\r
-\r
-#ifdef _NO_PROTO\r
-# undef NeedFunctionPrototypes\r
-#endif\r
-\r
-#undef P /* gnu stdio.h actually defines this... */\r
-#undef P0\r
-#undef P1\r
-#undef P2\r
-#undef P3\r
-#undef P4\r
-#undef P5\r
-#undef P6\r
-#undef P7\r
-#undef P8\r
-\r
-#if NeedFunctionPrototypes\r
-\r
-# define P( protos ) protos\r
-\r
-# define P0() (void)\r
-# define P1(x, a) (a)\r
-# define P2(x, a, b) (a, b)\r
-# define P3(x, a, b, c) (a, b, c)\r
-# define P4(x, a, b, c, d) (a, b, c, d) \r
-# define P5(x, a, b, c, d, e) (a, b, c, d, e)\r
-# define P6(x, a, b, c, d, e, f) (a, b, c, d, e, f)\r
-# define P7(x, a, b, c, d, e, f, g) (a, b, c, d, e, f, g)\r
-# define P8(x, a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h)\r
-\r
-#else /* !NeedFunctionPrototypes */\r
-\r
-# define P( protos ) ( /* protos */ )\r
-\r
-# define P0() ()\r
-# define P1(x, a) x a;\r
-# define P2(x, a, b) x a; b;\r
-# define P3(x, a, b, c) x a; b; c;\r
-# define P4(x, a, b, c, d) x a; b; c; d;\r
-# define P5(x, a, b, c, d, e) x a; b; c; d; e;\r
-# define P6(x, a, b, c, d, e, f) x a; b; c; d; e; f;\r
-# define P7(x, a, b, c, d, e, f, g) x a; b; c; d; e; f; g;\r
-# define P8(x, a, b, c, d, e, f, g, h) x a; b; c; d; e; f; g; h;\r
-\r
-#endif /* !NeedFunctionPrototypes */\r
-\r
-#endif /* PROTO_H */\r
+/*
+ * proto.h
+ *
+ * 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.
+ */
+
+
+#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 */
-/*\r
- * unproto.h\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#ifdef PROTO_H /* sic */\r
-#undef PROTO_H\r
-\r
-#undef P\r
-#undef P0\r
-#undef P1\r
-#undef P2\r
-#undef P3\r
-#undef P4\r
-#undef P5\r
-#undef P6\r
-#undef P7\r
-#undef P8\r
-\r
-#endif /* PROTO_H */\r
+/*
+ * unproto.h
+ *
+ * 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.
+ */
+
+
+#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 */
-/*\r
- * add.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-/*\r
- * See private.h for the more commonly used macro versions.\r
- */\r
-\r
-#include <stdio.h>\r
-#include <assert.h>\r
-\r
-#include "private.h"\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-#define saturate(x) \\r
- ((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))\r
-\r
-word gsm_add P2((a,b), word a, word b)\r
-{\r
- longword sum = (longword)a + (longword)b;\r
- return (word) saturate(sum);\r
-}\r
-\r
-word gsm_sub P2((a,b), word a, word b)\r
-{\r
- longword diff = (longword)a - (longword)b;\r
- return (word) saturate(diff);\r
-}\r
-\r
-word gsm_mult P2((a,b), word a, word b)\r
-{\r
- if (a == MIN_WORD && b == MIN_WORD) return MAX_WORD;\r
- else return (word) SASR( (longword)a * (longword)b, 15 );\r
-}\r
-\r
-word gsm_mult_r P2((a,b), word a, word b)\r
-{\r
- if (b == MIN_WORD && a == MIN_WORD) return MAX_WORD;\r
- else {\r
- longword prod = (longword)a * (longword)b + 16384;\r
- prod >>= 15;\r
- return (word) (prod & 0xFFFF);\r
- }\r
-}\r
-\r
-word gsm_abs P1((a), word a)\r
-{\r
- return a < 0 ? (a == MIN_WORD ? MAX_WORD : -a) : a;\r
-}\r
-\r
-longword gsm_L_mult P2((a,b),word a, word b)\r
-{\r
- assert( a != MIN_WORD || b != MIN_WORD );\r
- return ((longword)a * (longword)b) << 1;\r
-}\r
-\r
-longword gsm_L_add P2((a,b), longword a, longword b)\r
-{\r
- if (a < 0) {\r
- if (b >= 0) return a + b;\r
- else {\r
- ulongword A = (ulongword)-(a + 1) + (ulongword)-(b + 1);\r
- return A >= MAX_LONGWORD ? MIN_LONGWORD :-(longword)A-2;\r
- }\r
- }\r
- else if (b <= 0) return a + b;\r
- else {\r
- ulongword A = (ulongword)a + (ulongword)b;\r
- return A > MAX_LONGWORD ? MAX_LONGWORD : A;\r
- }\r
-}\r
-\r
-longword gsm_L_sub P2((a,b), longword a, longword b)\r
-{\r
- if (a >= 0) {\r
- if (b >= 0) return a - b;\r
- else {\r
- /* a>=0, b<0 */\r
-\r
- ulongword A = (ulongword)a + -(b + 1);\r
- return A >= MAX_LONGWORD ? MAX_LONGWORD : (A + 1);\r
- }\r
- }\r
- else if (b <= 0) return a - b;\r
- else {\r
- /* a<0, b>0 */ \r
-\r
- ulongword A = (ulongword)-(a + 1) + b;\r
- return A >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)A - 1;\r
- }\r
-}\r
-\r
-static unsigned char const bitoff[ 256 ] = {\r
- 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,\r
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\r
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\r
-};\r
-\r
-word gsm_norm P1((a), longword a )\r
-/*\r
- * the number of left shifts needed to normalize the 32 bit\r
- * variable L_var1 for positive values on the interval\r
- *\r
- * with minimum of\r
- * minimum of 1073741824 (01000000000000000000000000000000) and \r
- * maximum of 2147483647 (01111111111111111111111111111111)\r
- *\r
- *\r
- * and for negative values on the interval with\r
- * minimum of -2147483648 (-10000000000000000000000000000000) and\r
- * maximum of -1073741824 ( -1000000000000000000000000000000).\r
- *\r
- * in order to normalize the result, the following\r
- * operation must be done: L_norm_var1 = L_var1 << norm( L_var1 );\r
- *\r
- * (That's 'ffs', only from the left, not the right..)\r
- */\r
-{\r
- assert(a != 0);\r
-\r
- if (a < 0) {\r
- if (a <= -1073741824) return 0;\r
- a = ~a;\r
- }\r
-\r
- return a & 0xffff0000 \r
- ? ( a & 0xff000000\r
- ? -1 + bitoff[ 0xFF & (a >> 24) ]\r
- : 7 + bitoff[ 0xFF & (a >> 16) ] )\r
- : ( a & 0xff00\r
- ? 15 + bitoff[ 0xFF & (a >> 8) ]\r
- : 23 + bitoff[ 0xFF & a ] );\r
-}\r
-\r
-longword gsm_L_asl P2((a,n), longword a, int n)\r
-{\r
- if (n >= 32) return 0;\r
- if (n <= -32) return -(a < 0);\r
- if (n < 0) return gsm_L_asr(a, -n);\r
- return a << n;\r
-}\r
-\r
-word gsm_asl P2((a,n), word a, int n)\r
-{\r
- if (n >= 16) return 0;\r
- if (n <= -16) return -(a < 0);\r
- if (n < 0) return gsm_asr(a, -n);\r
- return a << n;\r
-}\r
-\r
-longword gsm_L_asr P2((a,n), longword a, int n)\r
-{\r
- if (n >= 32) return -(a < 0);\r
- if (n <= -32) return 0;\r
- if (n < 0) return a << -n;\r
-\r
-# ifdef SASR\r
- return a >> n;\r
-# else\r
- if (a >= 0) return a >> n;\r
- else return -(longword)( -(ulongword)a >> n );\r
-# endif\r
-}\r
-\r
-word gsm_asr P2((a,n), word a, int n)\r
-{\r
- if (n >= 16) return -(a < 0);\r
- if (n <= -16) return 0;\r
- if (n < 0) return a << -n;\r
-\r
-# ifdef SASR\r
- return a >> n;\r
-# else\r
- if (a >= 0) return a >> n;\r
- else return -(word)( -(uword)a >> n );\r
-# endif\r
-}\r
-\r
-/* \r
- * (From p. 46, end of section 4.2.5)\r
- *\r
- * NOTE: The following lines gives [sic] one correct implementation\r
- * of the div(num, denum) arithmetic operation. Compute div\r
- * which is the integer division of num by denum: with denum\r
- * >= num > 0\r
- */\r
-\r
-word gsm_div P2((num,denum), word num, word denum)\r
-{\r
- longword L_num = num;\r
- longword L_denum = denum;\r
- word div = 0;\r
- int k = 15;\r
-\r
- /* The parameter num sometimes becomes zero.\r
- * Although this is explicitly guarded against in 4.2.5,\r
- * we assume that the result should then be zero as well.\r
- */\r
-\r
- /* assert(num != 0); */\r
-\r
- assert(num >= 0 && denum >= num);\r
- if (num == 0)\r
- return 0;\r
-\r
- while (k--) {\r
- div <<= 1;\r
- L_num <<= 1;\r
-\r
- if (L_num >= L_denum) {\r
- L_num -= L_denum;\r
- div++;\r
- }\r
- }\r
-\r
- return div;\r
-}\r
+/*
+ * add.c
+ *
+ * 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.
+ */
+
+
+/*
+ * See private.h for the more commonly used macro versions.
+ */
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "private.h"
+#include "gsm.h"
+#include "proto.h"
+
+#define saturate(x) ((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))
+
+word gsm_add P2((a,b), word a, word b)
+{
+ longword sum = (longword)a + (longword)b;
+ return (word) saturate(sum);
+}
+
+word gsm_sub P2((a,b), word a, word b)
+{
+ longword diff = (longword)a - (longword)b;
+ return (word) saturate(diff);
+}
+
+word gsm_mult P2((a,b), word a, word b)
+{
+ if (a == MIN_WORD && b == MIN_WORD) return MAX_WORD;
+ else return (word) 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 (word) (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;
+}
-/*\r
- * code.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include "config.h"\r
-\r
-#ifdef HAS_STRING_H\r
-#include <string.h>\r
-#else\r
-#include "proto.h"\r
- extern char * memcpy P((char *, char *, int));\r
-#endif\r
-\r
-#include "private.h"\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-/* \r
- * 4.2 FIXED POINT IMPLEMENTATION OF THE RPE-LTP CODER \r
- */\r
-\r
-void Gsm_Coder P8((S,s,LARc,Nc,bc,Mc,xmaxc,xMc),\r
-\r
- struct gsm_state * S,\r
-\r
- word * s, /* [0..159] samples IN */\r
-\r
-/*\r
- * The RPE-LTD coder works on a frame by frame basis. The length of\r
- * the frame is equal to 160 samples. Some computations are done\r
- * once per frame to produce at the output of the coder the\r
- * LARc[1..8] parameters which are the coded LAR coefficients and \r
- * also to realize the inverse filtering operation for the entire\r
- * frame (160 samples of signal d[0..159]). These parts produce at\r
- * the output of the coder:\r
- */\r
-\r
- word * LARc, /* [0..7] LAR coefficients OUT */\r
-\r
-/*\r
- * Procedure 4.2.11 to 4.2.18 are to be executed four times per\r
- * frame. That means once for each sub-segment RPE-LTP analysis of\r
- * 40 samples. These parts produce at the output of the coder:\r
- */\r
-\r
- word * Nc, /* [0..3] LTP lag OUT */\r
- word * bc, /* [0..3] coded LTP gain OUT */\r
- word * Mc, /* [0..3] RPE grid selection OUT */\r
- word * xmaxc,/* [0..3] Coded maximum amplitude OUT */\r
- word * xMc /* [13*4] normalized RPE samples OUT */\r
-)\r
-{\r
- int k;\r
- word * dp = S->dp0 + 120; /* [ -120...-1 ] */\r
- word * dpp = dp; /* [ 0...39 ] */\r
-\r
- static word e[50];\r
-\r
- word so[160];\r
-\r
- Gsm_Preprocess (S, s, so);\r
- Gsm_LPC_Analysis (S, so, LARc);\r
- Gsm_Short_Term_Analysis_Filter (S, LARc, so);\r
-\r
- for (k = 0; k <= 3; k++, xMc += 13) {\r
-\r
- Gsm_Long_Term_Predictor ( S,\r
- so+k*40, /* d [0..39] IN */\r
- dp, /* dp [-120..-1] IN */\r
- e + 5, /* e [0..39] OUT */\r
- dpp, /* dpp [0..39] OUT */\r
- Nc++,\r
- bc++);\r
-\r
- Gsm_RPE_Encoding ( S,\r
- e + 5, /* e ][0..39][ IN/OUT */\r
- xmaxc++, Mc++, xMc );\r
- /*\r
- * Gsm_Update_of_reconstructed_short_time_residual_signal\r
- * ( dpp, e + 5, dp );\r
- */\r
-\r
- { register int i;\r
- register longword ltmp;\r
- for (i = 0; i <= 39; i++)\r
- dp[ i ] = (word) GSM_ADD( e[5 + i], dpp[i] );\r
- }\r
- dp += 40;\r
- dpp += 40;\r
-\r
- }\r
- (void)memcpy( (char *)S->dp0, (char *)(S->dp0 + 160),\r
- 120 * sizeof(*S->dp0) );\r
-}\r
+/*
+ * code.c
+ *
+ * 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.
+ */
+
+
+#include "config.h"
+
+#ifdef HAS_STRING_H
+#include <string.h>
+#else
+#include "proto.h"
+ extern char * memcpy P((char *, char *, int));
+#endif
+
+#include "private.h"
+#include "gsm.h"
+#include "proto.h"
+
+/*
+ * 4.2 FIXED POINT IMPLEMENTATION OF THE RPE-LTP CODER
+ */
+
+void Gsm_Coder P8((S,s,LARc,Nc,bc,Mc,xmaxc,xMc),
+
+ struct gsm_state * S,
+
+ word * s, /* [0..159] samples IN */
+
+/*
+ * The RPE-LTD coder works on a frame by frame basis. The length of
+ * the frame is equal to 160 samples. Some computations are done
+ * once per frame to produce at the output of the coder the
+ * LARc[1..8] parameters which are the coded LAR coefficients and
+ * also to realize the inverse filtering operation for the entire
+ * frame (160 samples of signal d[0..159]). These parts produce at
+ * the output of the coder:
+ */
+
+ word * LARc, /* [0..7] LAR coefficients OUT */
+
+/*
+ * Procedure 4.2.11 to 4.2.18 are to be executed four times per
+ * frame. That means once for each sub-segment RPE-LTP analysis of
+ * 40 samples. These parts produce at the output of the coder:
+ */
+
+ word * Nc, /* [0..3] LTP lag OUT */
+ word * bc, /* [0..3] coded LTP gain OUT */
+ word * Mc, /* [0..3] RPE grid selection OUT */
+ word * xmaxc,/* [0..3] Coded maximum amplitude OUT */
+ word * xMc /* [13*4] normalized RPE samples OUT */
+)
+{
+ int k;
+ word * dp = S->dp0 + 120; /* [ -120...-1 ] */
+ word * dpp = dp; /* [ 0...39 ] */
+
+ static word e[50];
+
+ word so[160];
+
+ Gsm_Preprocess (S, s, so);
+ Gsm_LPC_Analysis (S, so, LARc);
+ Gsm_Short_Term_Analysis_Filter (S, LARc, so);
+
+ for (k = 0; k <= 3; k++, xMc += 13) {
+
+ Gsm_Long_Term_Predictor ( S,
+ so+k*40, /* d [0..39] IN */
+ dp, /* dp [-120..-1] IN */
+ e + 5, /* e [0..39] OUT */
+ dpp, /* dpp [0..39] OUT */
+ Nc++,
+ bc++);
+
+ Gsm_RPE_Encoding ( S,
+ e + 5, /* e ][0..39][ IN/OUT */
+ xmaxc++, Mc++, xMc );
+ /*
+ * Gsm_Update_of_reconstructed_short_time_residual_signal
+ * ( dpp, e + 5, dp );
+ */
+
+ { register int i;
+ register longword ltmp;
+ for (i = 0; i <= 39; i++)
+ dp[ i ] = (word) GSM_ADD( e[5 + i], dpp[i] );
+ }
+ dp += 40;
+ dpp += 40;
+
+ }
+ (void)memcpy( (char *)S->dp0, (char *)(S->dp0 + 160),
+ 120 * sizeof(*S->dp0) );
+}
-/*\r
- * decode.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include <stdio.h>\r
-\r
-#include "private.h"\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-/*\r
- * 4.3 FIXED POINT IMPLEMENTATION OF THE RPE-LTP DECODER\r
- */\r
-\r
-static void Postprocessing P2((S,s),\r
- struct gsm_state * S,\r
- register word * s)\r
-{\r
- register int k;\r
- register word msr = S->msr;\r
- register longword ltmp; /* for GSM_ADD */\r
- register word tmp;\r
-\r
- for (k = 160; k--; s++) {\r
- tmp = (word) GSM_MULT_R( msr, 28180 );\r
- msr = (word) GSM_ADD(*s, tmp); /* Deemphasis */\r
- *s = (word) GSM_ADD(msr, msr) & 0xFFF8; /* Truncation & Upscaling */\r
- }\r
- S->msr = msr;\r
-}\r
-\r
-void Gsm_Decoder P8((S,LARcr, Ncr,bcr,Mcr,xmaxcr,xMcr,s),\r
- struct gsm_state * S,\r
-\r
- word * LARcr, /* [0..7] IN */\r
-\r
- word * Ncr, /* [0..3] IN */\r
- word * bcr, /* [0..3] IN */\r
- word * Mcr, /* [0..3] IN */\r
- word * xmaxcr, /* [0..3] IN */\r
- word * xMcr, /* [0..13*4] IN */\r
-\r
- word * s) /* [0..159] OUT */\r
-{\r
- int j, k;\r
- word erp[40], wt[160];\r
- word * drp = S->dp0 + 120;\r
-\r
- for (j=0; j <= 3; j++, xmaxcr++, bcr++, Ncr++, Mcr++, xMcr += 13) {\r
-\r
- Gsm_RPE_Decoding( S, *xmaxcr, *Mcr, xMcr, erp );\r
- Gsm_Long_Term_Synthesis_Filtering( S, *Ncr, *bcr, erp, drp );\r
-\r
- for (k = 0; k <= 39; k++) wt[ j * 40 + k ] = drp[ k ];\r
- }\r
-\r
- Gsm_Short_Term_Synthesis_Filter( S, LARcr, wt, s );\r
- Postprocessing(S, s);\r
-}\r
+/*
+ * decode.c
+ *
+ * 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.
+ */
+
+
+#include <stdio.h>
+
+#include "private.h"
+#include "gsm.h"
+#include "proto.h"
+
+/*
+ * 4.3 FIXED POINT IMPLEMENTATION OF THE RPE-LTP DECODER
+ */
+
+static void Postprocessing P2((S,s),
+ struct gsm_state * S,
+ register word * s)
+{
+ register int k;
+ register word msr = S->msr;
+ register longword ltmp; /* for GSM_ADD */
+ register word tmp;
+
+ for (k = 160; k--; s++) {
+ tmp = (word) GSM_MULT_R( msr, 28180 );
+ msr = (word) GSM_ADD(*s, tmp); /* Deemphasis */
+ *s = (word) 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);
+}
-/*\r
- * gsm_create.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include "config.h"\r
-\r
-#ifdef HAS_STRING_H\r
-#include <string.h>\r
-#else\r
-# include "proto.h"\r
- extern char * memset P((char *, int, int));\r
-#endif\r
-\r
-#ifdef HAS_STDLIB_H\r
-# include <stdlib.h>\r
-#else\r
-# ifdef HAS_MALLOC_H\r
-# include <malloc.h>\r
-# else\r
- extern char * malloc();\r
-# endif\r
-#endif\r
-\r
-#include <stdio.h>\r
-\r
-#include "gsm.h"\r
-#include "private.h"\r
-#include "proto.h"\r
-\r
-gsm gsm_create P0()\r
-{\r
- gsm r;\r
-\r
- r = (gsm)malloc(sizeof(struct gsm_state));\r
- if (!r) return r;\r
-\r
- memset((char *)r, 0, sizeof(*r));\r
- r->nrp = 40;\r
-\r
- return r;\r
-}\r
+/*
+ * gsm_create.c
+ *
+ * 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.
+ */
+
+
+#include "config.h"
+
+#ifdef HAS_STRING_H
+#include <string.h>
+#else
+# include "proto.h"
+ extern char * memset P((char *, int, int));
+#endif
+
+#ifdef HAS_STDLIB_H
+# include <stdlib.h>
+#else
+# ifdef HAS_MALLOC_H
+# include <malloc.h>
+# else
+ extern char * malloc();
+# endif
+#endif
+
+#include <stdio.h>
+
+#include "gsm.h"
+#include "private.h"
+#include "proto.h"
+
+gsm gsm_create P0()
+{
+ gsm r;
+
+ r = (gsm)malloc(sizeof(struct gsm_state));
+ if (!r) return r;
+
+ memset((char *)r, 0, sizeof(*r));
+ r->nrp = 40;
+
+ return r;
+}
-/*\r
- * gsm_decode.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include "private.h"\r
-\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-int gsm_decode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)\r
-{\r
- word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];\r
-\r
-#ifdef WAV49\r
- if (s->wav_fmt) {\r
-\r
- uword sr = 0;\r
-\r
- s->frame_index = !s->frame_index;\r
- if (s->frame_index) {\r
-\r
- sr = *c++;\r
- LARc[0] = sr & 0x3f; sr >>= 6;\r
- sr |= (uword)*c++ << 2;\r
- LARc[1] = sr & 0x3f; sr >>= 6;\r
- sr |= (uword)*c++ << 4;\r
- LARc[2] = sr & 0x1f; sr >>= 5;\r
- LARc[3] = sr & 0x1f; sr >>= 5;\r
- sr |= (uword)*c++ << 2;\r
- LARc[4] = sr & 0xf; sr >>= 4;\r
- LARc[5] = sr & 0xf; sr >>= 4;\r
- sr |= (uword)*c++ << 2; /* 5 */\r
- LARc[6] = sr & 0x7; sr >>= 3;\r
- LARc[7] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 4;\r
- Nc[0] = sr & 0x7f; sr >>= 7;\r
- bc[0] = sr & 0x3; sr >>= 2;\r
- Mc[0] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 1;\r
- xmaxc[0] = sr & 0x3f; sr >>= 6;\r
- xmc[0] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[1] = sr & 0x7; sr >>= 3;\r
- xmc[2] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[3] = sr & 0x7; sr >>= 3;\r
- xmc[4] = sr & 0x7; sr >>= 3;\r
- xmc[5] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1; /* 10 */\r
- xmc[6] = sr & 0x7; sr >>= 3;\r
- xmc[7] = sr & 0x7; sr >>= 3;\r
- xmc[8] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[9] = sr & 0x7; sr >>= 3;\r
- xmc[10] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[11] = sr & 0x7; sr >>= 3;\r
- xmc[12] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 4;\r
- Nc[1] = sr & 0x7f; sr >>= 7;\r
- bc[1] = sr & 0x3; sr >>= 2;\r
- Mc[1] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 1;\r
- xmaxc[1] = sr & 0x3f; sr >>= 6;\r
- xmc[13] = sr & 0x7; sr >>= 3;\r
- sr = *c++; /* 15 */\r
- xmc[14] = sr & 0x7; sr >>= 3;\r
- xmc[15] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[16] = sr & 0x7; sr >>= 3;\r
- xmc[17] = sr & 0x7; sr >>= 3;\r
- xmc[18] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[19] = sr & 0x7; sr >>= 3;\r
- xmc[20] = sr & 0x7; sr >>= 3;\r
- xmc[21] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[22] = sr & 0x7; sr >>= 3;\r
- xmc[23] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[24] = sr & 0x7; sr >>= 3;\r
- xmc[25] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 4; /* 20 */\r
- Nc[2] = sr & 0x7f; sr >>= 7;\r
- bc[2] = sr & 0x3; sr >>= 2;\r
- Mc[2] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 1;\r
- xmaxc[2] = sr & 0x3f; sr >>= 6;\r
- xmc[26] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[27] = sr & 0x7; sr >>= 3;\r
- xmc[28] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[29] = sr & 0x7; sr >>= 3;\r
- xmc[30] = sr & 0x7; sr >>= 3;\r
- xmc[31] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[32] = sr & 0x7; sr >>= 3;\r
- xmc[33] = sr & 0x7; sr >>= 3;\r
- xmc[34] = sr & 0x7; sr >>= 3;\r
- sr = *c++; /* 25 */\r
- xmc[35] = sr & 0x7; sr >>= 3;\r
- xmc[36] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[37] = sr & 0x7; sr >>= 3;\r
- xmc[38] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 4;\r
- Nc[3] = sr & 0x7f; sr >>= 7;\r
- bc[3] = sr & 0x3; sr >>= 2;\r
- Mc[3] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 1;\r
- xmaxc[3] = sr & 0x3f; sr >>= 6;\r
- xmc[39] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[40] = sr & 0x7; sr >>= 3;\r
- xmc[41] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2; /* 30 */\r
- xmc[42] = sr & 0x7; sr >>= 3;\r
- xmc[43] = sr & 0x7; sr >>= 3;\r
- xmc[44] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[45] = sr & 0x7; sr >>= 3;\r
- xmc[46] = sr & 0x7; sr >>= 3;\r
- xmc[47] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[48] = sr & 0x7; sr >>= 3;\r
- xmc[49] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[50] = sr & 0x7; sr >>= 3;\r
- xmc[51] = sr & 0x7; sr >>= 3;\r
-\r
- s->frame_chain = sr & 0xf;\r
- }\r
- else {\r
- sr = s->frame_chain;\r
- sr |= (uword)*c++ << 4; /* 1 */\r
- LARc[0] = sr & 0x3f; sr >>= 6;\r
- LARc[1] = sr & 0x3f; sr >>= 6;\r
- sr = *c++;\r
- LARc[2] = sr & 0x1f; sr >>= 5;\r
- sr |= (uword)*c++ << 3;\r
- LARc[3] = sr & 0x1f; sr >>= 5;\r
- LARc[4] = sr & 0xf; sr >>= 4;\r
- sr |= (uword)*c++ << 2;\r
- LARc[5] = sr & 0xf; sr >>= 4;\r
- LARc[6] = sr & 0x7; sr >>= 3;\r
- LARc[7] = sr & 0x7; sr >>= 3;\r
- sr = *c++; /* 5 */\r
- Nc[0] = sr & 0x7f; sr >>= 7;\r
- sr |= (uword)*c++ << 1;\r
- bc[0] = sr & 0x3; sr >>= 2;\r
- Mc[0] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 5;\r
- xmaxc[0] = sr & 0x3f; sr >>= 6;\r
- xmc[0] = sr & 0x7; sr >>= 3;\r
- xmc[1] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[2] = sr & 0x7; sr >>= 3;\r
- xmc[3] = sr & 0x7; sr >>= 3;\r
- xmc[4] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[5] = sr & 0x7; sr >>= 3;\r
- xmc[6] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2; /* 10 */\r
- xmc[7] = sr & 0x7; sr >>= 3;\r
- xmc[8] = sr & 0x7; sr >>= 3;\r
- xmc[9] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[10] = sr & 0x7; sr >>= 3;\r
- xmc[11] = sr & 0x7; sr >>= 3;\r
- xmc[12] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- Nc[1] = sr & 0x7f; sr >>= 7;\r
- sr |= (uword)*c++ << 1;\r
- bc[1] = sr & 0x3; sr >>= 2;\r
- Mc[1] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 5;\r
- xmaxc[1] = sr & 0x3f; sr >>= 6;\r
- xmc[13] = sr & 0x7; sr >>= 3;\r
- xmc[14] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1; /* 15 */\r
- xmc[15] = sr & 0x7; sr >>= 3;\r
- xmc[16] = sr & 0x7; sr >>= 3;\r
- xmc[17] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[18] = sr & 0x7; sr >>= 3;\r
- xmc[19] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[20] = sr & 0x7; sr >>= 3;\r
- xmc[21] = sr & 0x7; sr >>= 3;\r
- xmc[22] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[23] = sr & 0x7; sr >>= 3;\r
- xmc[24] = sr & 0x7; sr >>= 3;\r
- xmc[25] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- Nc[2] = sr & 0x7f; sr >>= 7;\r
- sr |= (uword)*c++ << 1; /* 20 */\r
- bc[2] = sr & 0x3; sr >>= 2;\r
- Mc[2] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 5;\r
- xmaxc[2] = sr & 0x3f; sr >>= 6;\r
- xmc[26] = sr & 0x7; sr >>= 3;\r
- xmc[27] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1; \r
- xmc[28] = sr & 0x7; sr >>= 3;\r
- xmc[29] = sr & 0x7; sr >>= 3;\r
- xmc[30] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- xmc[31] = sr & 0x7; sr >>= 3;\r
- xmc[32] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[33] = sr & 0x7; sr >>= 3;\r
- xmc[34] = sr & 0x7; sr >>= 3;\r
- xmc[35] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1; /* 25 */\r
- xmc[36] = sr & 0x7; sr >>= 3;\r
- xmc[37] = sr & 0x7; sr >>= 3;\r
- xmc[38] = sr & 0x7; sr >>= 3;\r
- sr = *c++;\r
- Nc[3] = sr & 0x7f; sr >>= 7;\r
- sr |= (uword)*c++ << 1; \r
- bc[3] = sr & 0x3; sr >>= 2;\r
- Mc[3] = sr & 0x3; sr >>= 2;\r
- sr |= (uword)*c++ << 5;\r
- xmaxc[3] = sr & 0x3f; sr >>= 6;\r
- xmc[39] = sr & 0x7; sr >>= 3;\r
- xmc[40] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[41] = sr & 0x7; sr >>= 3;\r
- xmc[42] = sr & 0x7; sr >>= 3;\r
- xmc[43] = sr & 0x7; sr >>= 3;\r
- sr = *c++; /* 30 */\r
- xmc[44] = sr & 0x7; sr >>= 3;\r
- xmc[45] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 2;\r
- xmc[46] = sr & 0x7; sr >>= 3;\r
- xmc[47] = sr & 0x7; sr >>= 3;\r
- xmc[48] = sr & 0x7; sr >>= 3;\r
- sr |= (uword)*c++ << 1;\r
- xmc[49] = sr & 0x7; sr >>= 3;\r
- xmc[50] = sr & 0x7; sr >>= 3;\r
- xmc[51] = sr & 0x7; sr >>= 3;\r
- }\r
- }\r
- else\r
-#endif\r
- {\r
- /* GSM_MAGIC = (*c >> 4) & 0xF; */\r
-\r
- if (((*c >> 4) & 0x0F) != GSM_MAGIC) return -1;\r
-\r
- LARc[0] = (*c++ & 0xF) << 2; /* 1 */\r
- LARc[0] |= (*c >> 6) & 0x3;\r
- LARc[1] = *c++ & 0x3F;\r
- LARc[2] = (*c >> 3) & 0x1F;\r
- LARc[3] = (*c++ & 0x7) << 2;\r
- LARc[3] |= (*c >> 6) & 0x3;\r
- LARc[4] = (*c >> 2) & 0xF;\r
- LARc[5] = (*c++ & 0x3) << 2;\r
- LARc[5] |= (*c >> 6) & 0x3;\r
- LARc[6] = (*c >> 3) & 0x7;\r
- LARc[7] = *c++ & 0x7;\r
- Nc[0] = (*c >> 1) & 0x7F;\r
- bc[0] = (*c++ & 0x1) << 1;\r
- bc[0] |= (*c >> 7) & 0x1;\r
- Mc[0] = (*c >> 5) & 0x3;\r
- xmaxc[0] = (*c++ & 0x1F) << 1;\r
- xmaxc[0] |= (*c >> 7) & 0x1;\r
- xmc[0] = (*c >> 4) & 0x7;\r
- xmc[1] = (*c >> 1) & 0x7;\r
- xmc[2] = (*c++ & 0x1) << 2;\r
- xmc[2] |= (*c >> 6) & 0x3;\r
- xmc[3] = (*c >> 3) & 0x7;\r
- xmc[4] = *c++ & 0x7;\r
- xmc[5] = (*c >> 5) & 0x7;\r
- xmc[6] = (*c >> 2) & 0x7;\r
- xmc[7] = (*c++ & 0x3) << 1; /* 10 */\r
- xmc[7] |= (*c >> 7) & 0x1;\r
- xmc[8] = (*c >> 4) & 0x7;\r
- xmc[9] = (*c >> 1) & 0x7;\r
- xmc[10] = (*c++ & 0x1) << 2;\r
- xmc[10] |= (*c >> 6) & 0x3;\r
- xmc[11] = (*c >> 3) & 0x7;\r
- xmc[12] = *c++ & 0x7;\r
- Nc[1] = (*c >> 1) & 0x7F;\r
- bc[1] = (*c++ & 0x1) << 1;\r
- bc[1] |= (*c >> 7) & 0x1;\r
- Mc[1] = (*c >> 5) & 0x3;\r
- xmaxc[1] = (*c++ & 0x1F) << 1;\r
- xmaxc[1] |= (*c >> 7) & 0x1;\r
- xmc[13] = (*c >> 4) & 0x7;\r
- xmc[14] = (*c >> 1) & 0x7;\r
- xmc[15] = (*c++ & 0x1) << 2;\r
- xmc[15] |= (*c >> 6) & 0x3;\r
- xmc[16] = (*c >> 3) & 0x7;\r
- xmc[17] = *c++ & 0x7;\r
- xmc[18] = (*c >> 5) & 0x7;\r
- xmc[19] = (*c >> 2) & 0x7;\r
- xmc[20] = (*c++ & 0x3) << 1;\r
- xmc[20] |= (*c >> 7) & 0x1;\r
- xmc[21] = (*c >> 4) & 0x7;\r
- xmc[22] = (*c >> 1) & 0x7;\r
- xmc[23] = (*c++ & 0x1) << 2;\r
- xmc[23] |= (*c >> 6) & 0x3;\r
- xmc[24] = (*c >> 3) & 0x7;\r
- xmc[25] = *c++ & 0x7;\r
- Nc[2] = (*c >> 1) & 0x7F;\r
- bc[2] = (*c++ & 0x1) << 1; /* 20 */\r
- bc[2] |= (*c >> 7) & 0x1;\r
- Mc[2] = (*c >> 5) & 0x3;\r
- xmaxc[2] = (*c++ & 0x1F) << 1;\r
- xmaxc[2] |= (*c >> 7) & 0x1;\r
- xmc[26] = (*c >> 4) & 0x7;\r
- xmc[27] = (*c >> 1) & 0x7;\r
- xmc[28] = (*c++ & 0x1) << 2;\r
- xmc[28] |= (*c >> 6) & 0x3;\r
- xmc[29] = (*c >> 3) & 0x7;\r
- xmc[30] = *c++ & 0x7;\r
- xmc[31] = (*c >> 5) & 0x7;\r
- xmc[32] = (*c >> 2) & 0x7;\r
- xmc[33] = (*c++ & 0x3) << 1;\r
- xmc[33] |= (*c >> 7) & 0x1;\r
- xmc[34] = (*c >> 4) & 0x7;\r
- xmc[35] = (*c >> 1) & 0x7;\r
- xmc[36] = (*c++ & 0x1) << 2;\r
- xmc[36] |= (*c >> 6) & 0x3;\r
- xmc[37] = (*c >> 3) & 0x7;\r
- xmc[38] = *c++ & 0x7;\r
- Nc[3] = (*c >> 1) & 0x7F;\r
- bc[3] = (*c++ & 0x1) << 1;\r
- bc[3] |= (*c >> 7) & 0x1;\r
- Mc[3] = (*c >> 5) & 0x3;\r
- xmaxc[3] = (*c++ & 0x1F) << 1;\r
- xmaxc[3] |= (*c >> 7) & 0x1;\r
- xmc[39] = (*c >> 4) & 0x7;\r
- xmc[40] = (*c >> 1) & 0x7;\r
- xmc[41] = (*c++ & 0x1) << 2;\r
- xmc[41] |= (*c >> 6) & 0x3;\r
- xmc[42] = (*c >> 3) & 0x7;\r
- xmc[43] = *c++ & 0x7; /* 30 */\r
- xmc[44] = (*c >> 5) & 0x7;\r
- xmc[45] = (*c >> 2) & 0x7;\r
- xmc[46] = (*c++ & 0x3) << 1;\r
- xmc[46] |= (*c >> 7) & 0x1;\r
- xmc[47] = (*c >> 4) & 0x7;\r
- xmc[48] = (*c >> 1) & 0x7;\r
- xmc[49] = (*c++ & 0x1) << 2;\r
- xmc[49] |= (*c >> 6) & 0x3;\r
- xmc[50] = (*c >> 3) & 0x7;\r
- xmc[51] = *c & 0x7; /* 33 */\r
- }\r
-\r
- Gsm_Decoder(s, LARc, Nc, bc, Mc, xmaxc, xmc, target);\r
-\r
- return 0;\r
-}\r
+/*
+ * gsm_decode.c
+ *
+ * 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.
+ */
+
+
+#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;
+}
-/*\r
- * gsm_destroy.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include "gsm.h"\r
-#include "config.h"\r
-#include "proto.h"\r
-\r
-#ifdef HAS_STDLIB_H\r
-# include <stdlib.h>\r
-#else\r
-# ifdef HAS_MALLOC_H\r
-# include <malloc.h>\r
-# else\r
- extern void free();\r
-# endif\r
-#endif\r
-\r
-void gsm_destroy P1((S), gsm S)\r
-{\r
- if (S) free((char *)S);\r
-}\r
+/*
+ * gsm_destroy.c
+ *
+ * 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.
+ */
+
+
+#include "gsm.h"
+#include "config.h"
+#include "proto.h"
+
+#ifdef HAS_STDLIB_H
+# include <stdlib.h>
+#else
+# ifdef HAS_MALLOC_H
+# include <malloc.h>
+# else
+ extern void free();
+# endif
+#endif
+
+void gsm_destroy P1((S), gsm S)
+{
+ if (S) free((char *)S);
+}
-/*\r
- * gsm_encode.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include "private.h"\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-void gsm_encode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)\r
-{\r
- word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];\r
-\r
- Gsm_Coder(s, source, LARc, Nc, bc, Mc, xmaxc, xmc);\r
-\r
-\r
- /* variable size\r
-\r
- GSM_MAGIC 4\r
-\r
- LARc[0] 6\r
- LARc[1] 6\r
- LARc[2] 5\r
- LARc[3] 5\r
- LARc[4] 4\r
- LARc[5] 4\r
- LARc[6] 3\r
- LARc[7] 3\r
-\r
- Nc[0] 7\r
- bc[0] 2\r
- Mc[0] 2\r
- xmaxc[0] 6\r
- xmc[0] 3\r
- xmc[1] 3\r
- xmc[2] 3\r
- xmc[3] 3\r
- xmc[4] 3\r
- xmc[5] 3\r
- xmc[6] 3\r
- xmc[7] 3\r
- xmc[8] 3\r
- xmc[9] 3\r
- xmc[10] 3\r
- xmc[11] 3\r
- xmc[12] 3\r
-\r
- Nc[1] 7\r
- bc[1] 2\r
- Mc[1] 2\r
- xmaxc[1] 6\r
- xmc[13] 3\r
- xmc[14] 3\r
- xmc[15] 3\r
- xmc[16] 3\r
- xmc[17] 3\r
- xmc[18] 3\r
- xmc[19] 3\r
- xmc[20] 3\r
- xmc[21] 3\r
- xmc[22] 3\r
- xmc[23] 3\r
- xmc[24] 3\r
- xmc[25] 3\r
-\r
- Nc[2] 7\r
- bc[2] 2\r
- Mc[2] 2\r
- xmaxc[2] 6\r
- xmc[26] 3\r
- xmc[27] 3\r
- xmc[28] 3\r
- xmc[29] 3\r
- xmc[30] 3\r
- xmc[31] 3\r
- xmc[32] 3\r
- xmc[33] 3\r
- xmc[34] 3\r
- xmc[35] 3\r
- xmc[36] 3\r
- xmc[37] 3\r
- xmc[38] 3\r
-\r
- Nc[3] 7\r
- bc[3] 2\r
- Mc[3] 2\r
- xmaxc[3] 6\r
- xmc[39] 3\r
- xmc[40] 3\r
- xmc[41] 3\r
- xmc[42] 3\r
- xmc[43] 3\r
- xmc[44] 3\r
- xmc[45] 3\r
- xmc[46] 3\r
- xmc[47] 3\r
- xmc[48] 3\r
- xmc[49] 3\r
- xmc[50] 3\r
- xmc[51] 3\r
- */\r
-\r
-#ifdef WAV49\r
-\r
- if (s->wav_fmt) {\r
- s->frame_index = !s->frame_index;\r
- if (s->frame_index) {\r
-\r
- uword sr;\r
-\r
- sr = 0;\r
- sr = sr >> 6 | LARc[0] << 10;\r
- sr = sr >> 6 | LARc[1] << 10;\r
- *c++ = sr >> 4;\r
- sr = sr >> 5 | LARc[2] << 11;\r
- *c++ = sr >> 7;\r
- sr = sr >> 5 | LARc[3] << 11;\r
- sr = sr >> 4 | LARc[4] << 12;\r
- *c++ = sr >> 6;\r
- sr = sr >> 4 | LARc[5] << 12;\r
- sr = sr >> 3 | LARc[6] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | LARc[7] << 13;\r
- sr = sr >> 7 | Nc[0] << 9;\r
- *c++ = sr >> 5;\r
- sr = sr >> 2 | bc[0] << 14;\r
- sr = sr >> 2 | Mc[0] << 14;\r
- sr = sr >> 6 | xmaxc[0] << 10;\r
- *c++ = sr >> 3;\r
- sr = sr >> 3 | xmc[0] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[1] << 13;\r
- sr = sr >> 3 | xmc[2] << 13;\r
- sr = sr >> 3 | xmc[3] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[4] << 13;\r
- sr = sr >> 3 | xmc[5] << 13;\r
- sr = sr >> 3 | xmc[6] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[7] << 13;\r
- sr = sr >> 3 | xmc[8] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[9] << 13;\r
- sr = sr >> 3 | xmc[10] << 13;\r
- sr = sr >> 3 | xmc[11] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[12] << 13;\r
- sr = sr >> 7 | Nc[1] << 9;\r
- *c++ = sr >> 5;\r
- sr = sr >> 2 | bc[1] << 14;\r
- sr = sr >> 2 | Mc[1] << 14;\r
- sr = sr >> 6 | xmaxc[1] << 10;\r
- *c++ = sr >> 3;\r
- sr = sr >> 3 | xmc[13] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[14] << 13;\r
- sr = sr >> 3 | xmc[15] << 13;\r
- sr = sr >> 3 | xmc[16] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[17] << 13;\r
- sr = sr >> 3 | xmc[18] << 13;\r
- sr = sr >> 3 | xmc[19] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[20] << 13;\r
- sr = sr >> 3 | xmc[21] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[22] << 13;\r
- sr = sr >> 3 | xmc[23] << 13;\r
- sr = sr >> 3 | xmc[24] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[25] << 13;\r
- sr = sr >> 7 | Nc[2] << 9;\r
- *c++ = sr >> 5;\r
- sr = sr >> 2 | bc[2] << 14;\r
- sr = sr >> 2 | Mc[2] << 14;\r
- sr = sr >> 6 | xmaxc[2] << 10;\r
- *c++ = sr >> 3;\r
- sr = sr >> 3 | xmc[26] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[27] << 13;\r
- sr = sr >> 3 | xmc[28] << 13;\r
- sr = sr >> 3 | xmc[29] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[30] << 13;\r
- sr = sr >> 3 | xmc[31] << 13;\r
- sr = sr >> 3 | xmc[32] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[33] << 13;\r
- sr = sr >> 3 | xmc[34] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[35] << 13;\r
- sr = sr >> 3 | xmc[36] << 13;\r
- sr = sr >> 3 | xmc[37] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[38] << 13;\r
- sr = sr >> 7 | Nc[3] << 9;\r
- *c++ = sr >> 5;\r
- sr = sr >> 2 | bc[3] << 14;\r
- sr = sr >> 2 | Mc[3] << 14;\r
- sr = sr >> 6 | xmaxc[3] << 10;\r
- *c++ = sr >> 3;\r
- sr = sr >> 3 | xmc[39] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[40] << 13;\r
- sr = sr >> 3 | xmc[41] << 13;\r
- sr = sr >> 3 | xmc[42] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[43] << 13;\r
- sr = sr >> 3 | xmc[44] << 13;\r
- sr = sr >> 3 | xmc[45] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[46] << 13;\r
- sr = sr >> 3 | xmc[47] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[48] << 13;\r
- sr = sr >> 3 | xmc[49] << 13;\r
- sr = sr >> 3 | xmc[50] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[51] << 13;\r
- sr = sr >> 4;\r
- *c = sr >> 8;\r
- s->frame_chain = *c;\r
- }\r
- else {\r
- uword sr;\r
-\r
- sr = 0;\r
- sr = sr >> 4 | s->frame_chain << 12;\r
- sr = sr >> 6 | LARc[0] << 10;\r
- *c++ = sr >> 6;\r
- sr = sr >> 6 | LARc[1] << 10;\r
- *c++ = sr >> 8;\r
- sr = sr >> 5 | LARc[2] << 11;\r
- sr = sr >> 5 | LARc[3] << 11;\r
- *c++ = sr >> 6;\r
- sr = sr >> 4 | LARc[4] << 12;\r
- sr = sr >> 4 | LARc[5] << 12;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | LARc[6] << 13;\r
- sr = sr >> 3 | LARc[7] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 7 | Nc[0] << 9;\r
- sr = sr >> 2 | bc[0] << 14;\r
- *c++ = sr >> 7;\r
- sr = sr >> 2 | Mc[0] << 14;\r
- sr = sr >> 6 | xmaxc[0] << 10;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[0] << 13;\r
- sr = sr >> 3 | xmc[1] << 13;\r
- sr = sr >> 3 | xmc[2] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[3] << 13;\r
- sr = sr >> 3 | xmc[4] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[5] << 13;\r
- sr = sr >> 3 | xmc[6] << 13;\r
- sr = sr >> 3 | xmc[7] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[8] << 13;\r
- sr = sr >> 3 | xmc[9] << 13;\r
- sr = sr >> 3 | xmc[10] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[11] << 13;\r
- sr = sr >> 3 | xmc[12] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 7 | Nc[1] << 9;\r
- sr = sr >> 2 | bc[1] << 14;\r
- *c++ = sr >> 7;\r
- sr = sr >> 2 | Mc[1] << 14;\r
- sr = sr >> 6 | xmaxc[1] << 10;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[13] << 13;\r
- sr = sr >> 3 | xmc[14] << 13;\r
- sr = sr >> 3 | xmc[15] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[16] << 13;\r
- sr = sr >> 3 | xmc[17] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[18] << 13;\r
- sr = sr >> 3 | xmc[19] << 13;\r
- sr = sr >> 3 | xmc[20] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[21] << 13;\r
- sr = sr >> 3 | xmc[22] << 13;\r
- sr = sr >> 3 | xmc[23] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[24] << 13;\r
- sr = sr >> 3 | xmc[25] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 7 | Nc[2] << 9;\r
- sr = sr >> 2 | bc[2] << 14;\r
- *c++ = sr >> 7;\r
- sr = sr >> 2 | Mc[2] << 14;\r
- sr = sr >> 6 | xmaxc[2] << 10;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[26] << 13;\r
- sr = sr >> 3 | xmc[27] << 13;\r
- sr = sr >> 3 | xmc[28] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[29] << 13;\r
- sr = sr >> 3 | xmc[30] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[31] << 13;\r
- sr = sr >> 3 | xmc[32] << 13;\r
- sr = sr >> 3 | xmc[33] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[34] << 13;\r
- sr = sr >> 3 | xmc[35] << 13;\r
- sr = sr >> 3 | xmc[36] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[37] << 13;\r
- sr = sr >> 3 | xmc[38] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 7 | Nc[3] << 9;\r
- sr = sr >> 2 | bc[3] << 14;\r
- *c++ = sr >> 7;\r
- sr = sr >> 2 | Mc[3] << 14;\r
- sr = sr >> 6 | xmaxc[3] << 10;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[39] << 13;\r
- sr = sr >> 3 | xmc[40] << 13;\r
- sr = sr >> 3 | xmc[41] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[42] << 13;\r
- sr = sr >> 3 | xmc[43] << 13;\r
- *c++ = sr >> 8;\r
- sr = sr >> 3 | xmc[44] << 13;\r
- sr = sr >> 3 | xmc[45] << 13;\r
- sr = sr >> 3 | xmc[46] << 13;\r
- *c++ = sr >> 7;\r
- sr = sr >> 3 | xmc[47] << 13;\r
- sr = sr >> 3 | xmc[48] << 13;\r
- sr = sr >> 3 | xmc[49] << 13;\r
- *c++ = sr >> 6;\r
- sr = sr >> 3 | xmc[50] << 13;\r
- sr = sr >> 3 | xmc[51] << 13;\r
- *c++ = sr >> 8;\r
- }\r
- }\r
-\r
- else\r
-\r
-#endif /* WAV49 */\r
- {\r
-\r
- *c++ = ((GSM_MAGIC & 0xF) << 4) /* 1 */\r
- | ((LARc[0] >> 2) & 0xF);\r
- *c++ = ((LARc[0] & 0x3) << 6)\r
- | (LARc[1] & 0x3F);\r
- *c++ = ((LARc[2] & 0x1F) << 3)\r
- | ((LARc[3] >> 2) & 0x7);\r
- *c++ = ((LARc[3] & 0x3) << 6)\r
- | ((LARc[4] & 0xF) << 2)\r
- | ((LARc[5] >> 2) & 0x3);\r
- *c++ = ((LARc[5] & 0x3) << 6)\r
- | ((LARc[6] & 0x7) << 3)\r
- | (LARc[7] & 0x7);\r
- *c++ = ((Nc[0] & 0x7F) << 1)\r
- | ((bc[0] >> 1) & 0x1);\r
- *c++ = ((bc[0] & 0x1) << 7)\r
- | ((Mc[0] & 0x3) << 5)\r
- | ((xmaxc[0] >> 1) & 0x1F);\r
- *c++ = ((xmaxc[0] & 0x1) << 7)\r
- | ((xmc[0] & 0x7) << 4)\r
- | ((xmc[1] & 0x7) << 1)\r
- | ((xmc[2] >> 2) & 0x1);\r
- *c++ = ((xmc[2] & 0x3) << 6)\r
- | ((xmc[3] & 0x7) << 3)\r
- | (xmc[4] & 0x7);\r
- *c++ = ((xmc[5] & 0x7) << 5) /* 10 */\r
- | ((xmc[6] & 0x7) << 2)\r
- | ((xmc[7] >> 1) & 0x3);\r
- *c++ = ((xmc[7] & 0x1) << 7)\r
- | ((xmc[8] & 0x7) << 4)\r
- | ((xmc[9] & 0x7) << 1)\r
- | ((xmc[10] >> 2) & 0x1);\r
- *c++ = ((xmc[10] & 0x3) << 6)\r
- | ((xmc[11] & 0x7) << 3)\r
- | (xmc[12] & 0x7);\r
- *c++ = ((Nc[1] & 0x7F) << 1)\r
- | ((bc[1] >> 1) & 0x1);\r
- *c++ = ((bc[1] & 0x1) << 7)\r
- | ((Mc[1] & 0x3) << 5)\r
- | ((xmaxc[1] >> 1) & 0x1F);\r
- *c++ = ((xmaxc[1] & 0x1) << 7)\r
- | ((xmc[13] & 0x7) << 4)\r
- | ((xmc[14] & 0x7) << 1)\r
- | ((xmc[15] >> 2) & 0x1);\r
- *c++ = ((xmc[15] & 0x3) << 6)\r
- | ((xmc[16] & 0x7) << 3)\r
- | (xmc[17] & 0x7);\r
- *c++ = ((xmc[18] & 0x7) << 5)\r
- | ((xmc[19] & 0x7) << 2)\r
- | ((xmc[20] >> 1) & 0x3);\r
- *c++ = ((xmc[20] & 0x1) << 7)\r
- | ((xmc[21] & 0x7) << 4)\r
- | ((xmc[22] & 0x7) << 1)\r
- | ((xmc[23] >> 2) & 0x1);\r
- *c++ = ((xmc[23] & 0x3) << 6)\r
- | ((xmc[24] & 0x7) << 3)\r
- | (xmc[25] & 0x7);\r
- *c++ = ((Nc[2] & 0x7F) << 1) /* 20 */\r
- | ((bc[2] >> 1) & 0x1);\r
- *c++ = ((bc[2] & 0x1) << 7)\r
- | ((Mc[2] & 0x3) << 5)\r
- | ((xmaxc[2] >> 1) & 0x1F);\r
- *c++ = ((xmaxc[2] & 0x1) << 7)\r
- | ((xmc[26] & 0x7) << 4)\r
- | ((xmc[27] & 0x7) << 1)\r
- | ((xmc[28] >> 2) & 0x1);\r
- *c++ = ((xmc[28] & 0x3) << 6)\r
- | ((xmc[29] & 0x7) << 3)\r
- | (xmc[30] & 0x7);\r
- *c++ = ((xmc[31] & 0x7) << 5)\r
- | ((xmc[32] & 0x7) << 2)\r
- | ((xmc[33] >> 1) & 0x3);\r
- *c++ = ((xmc[33] & 0x1) << 7)\r
- | ((xmc[34] & 0x7) << 4)\r
- | ((xmc[35] & 0x7) << 1)\r
- | ((xmc[36] >> 2) & 0x1);\r
- *c++ = ((xmc[36] & 0x3) << 6)\r
- | ((xmc[37] & 0x7) << 3)\r
- | (xmc[38] & 0x7);\r
- *c++ = ((Nc[3] & 0x7F) << 1)\r
- | ((bc[3] >> 1) & 0x1);\r
- *c++ = ((bc[3] & 0x1) << 7)\r
- | ((Mc[3] & 0x3) << 5)\r
- | ((xmaxc[3] >> 1) & 0x1F);\r
- *c++ = ((xmaxc[3] & 0x1) << 7)\r
- | ((xmc[39] & 0x7) << 4)\r
- | ((xmc[40] & 0x7) << 1)\r
- | ((xmc[41] >> 2) & 0x1);\r
- *c++ = ((xmc[41] & 0x3) << 6) /* 30 */\r
- | ((xmc[42] & 0x7) << 3)\r
- | (xmc[43] & 0x7);\r
- *c++ = ((xmc[44] & 0x7) << 5)\r
- | ((xmc[45] & 0x7) << 2)\r
- | ((xmc[46] >> 1) & 0x3);\r
- *c++ = ((xmc[46] & 0x1) << 7)\r
- | ((xmc[47] & 0x7) << 4)\r
- | ((xmc[48] & 0x7) << 1)\r
- | ((xmc[49] >> 2) & 0x1);\r
- *c++ = ((xmc[49] & 0x3) << 6)\r
- | ((xmc[50] & 0x7) << 3)\r
- | (xmc[51] & 0x7);\r
-\r
- }\r
-}\r
+/*
+ * gsm_encode.c
+ *
+ * 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.
+ */
+
+
+#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);
+
+ }
+}
-/*\r
- * gsm_lpc.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include <stdio.h>\r
-#include <assert.h>\r
-\r
-#include "private.h"\r
-\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-#undef P\r
-\r
-/*\r
- * 4.2.4 .. 4.2.7 LPC ANALYSIS SECTION\r
- */\r
-\r
-/* 4.2.4 */\r
-\r
-\r
-static void Autocorrelation P2((s, L_ACF),\r
- word * s, /* [0..159] IN/OUT */\r
- longword * L_ACF) /* [0..8] OUT */\r
-/*\r
- * The goal is to compute the array L_ACF[k]. The signal s[i] must\r
- * be scaled in order to avoid an overflow situation.\r
- */\r
-{\r
- register int k, i;\r
-\r
- word temp, smax, scalauto;\r
-\r
-#ifdef USE_FLOAT_MUL\r
- float float_s[160];\r
-#endif\r
-\r
- /* Dynamic scaling of the array s[0..159]\r
- */\r
-\r
- /* Search for the maximum.\r
- */\r
- smax = 0;\r
- for (k = 0; k <= 159; k++) {\r
- temp = GSM_ABS( s[k] );\r
- if (temp > smax) smax = temp;\r
- }\r
-\r
- /* Computation of the scaling factor.\r
- */\r
- if (smax == 0) scalauto = 0;\r
- else {\r
- assert(smax > 0);\r
- scalauto = 4 - gsm_norm( (longword)smax << 16 );/* sub(4,..) */\r
- }\r
-\r
- /* Scaling of the array s[0...159]\r
- */\r
-\r
- if (scalauto > 0) {\r
-\r
-# ifdef USE_FLOAT_MUL\r
-# define SCALE(n) \\r
- case n: for (k = 0; k <= 159; k++) \\r
- float_s[k] = (float) \\r
- (s[k] = GSM_MULT_R(s[k], 16384 >> (n-1)));\\r
- break;\r
-# else \r
-# define SCALE(n) \\r
- case n: for (k = 0; k <= 159; k++) \\r
- s[k] = (word) GSM_MULT_R( s[k], 16384 >> (n-1) );\\r
- break;\r
-# endif /* USE_FLOAT_MUL */\r
-\r
- switch (scalauto) {\r
- SCALE(1)\r
- SCALE(2)\r
- SCALE(3)\r
- SCALE(4)\r
- }\r
-# undef SCALE\r
- }\r
-# ifdef USE_FLOAT_MUL\r
- else for (k = 0; k <= 159; k++) float_s[k] = (float) s[k];\r
-# endif\r
-\r
- /* Compute the L_ACF[..].\r
- */\r
- {\r
-# ifdef USE_FLOAT_MUL\r
- register float * sp = float_s;\r
- register float sl = *sp;\r
-\r
-# define STEP(k) L_ACF[k] += (longword)(sl * sp[ -(k) ]);\r
-# else\r
- word * sp = s;\r
- word sl = *sp;\r
-\r
-# define STEP(k) L_ACF[k] += ((longword)sl * sp[ -(k) ]);\r
-# endif\r
-\r
-# define NEXTI sl = *++sp\r
-\r
-\r
- for (k = 9; k--; L_ACF[k] = 0) ;\r
-\r
- STEP (0);\r
- NEXTI;\r
- STEP(0); STEP(1);\r
- NEXTI;\r
- STEP(0); STEP(1); STEP(2);\r
- NEXTI;\r
- STEP(0); STEP(1); STEP(2); STEP(3);\r
- NEXTI;\r
- STEP(0); STEP(1); STEP(2); STEP(3); STEP(4);\r
- NEXTI;\r
- STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5);\r
- NEXTI;\r
- STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5); STEP(6);\r
- NEXTI;\r
- STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5); STEP(6); STEP(7);\r
-\r
- for (i = 8; i <= 159; i++) {\r
-\r
- NEXTI;\r
-\r
- STEP(0);\r
- STEP(1); STEP(2); STEP(3); STEP(4);\r
- STEP(5); STEP(6); STEP(7); STEP(8);\r
- }\r
-\r
- for (k = 9; k--; L_ACF[k] <<= 1) ; \r
-\r
- }\r
- /* Rescaling of the array s[0..159]\r
- */\r
- if (scalauto > 0) {\r
- assert(scalauto <= 4); \r
- for (k = 160; k--; *s++ <<= scalauto) ;\r
- }\r
-}\r
-\r
-#if defined(USE_FLOAT_MUL) && defined(FAST)\r
-\r
-static void Fast_Autocorrelation P2((s, L_ACF),\r
- word * s, /* [0..159] IN/OUT */\r
- longword * L_ACF) /* [0..8] OUT */\r
-{\r
- register int k, i;\r
- float f_L_ACF[9];\r
- float scale;\r
-\r
- float s_f[160];\r
- register float *sf = s_f;\r
-\r
- for (i = 0; i < 160; ++i) sf[i] = s[i];\r
- for (k = 0; k <= 8; k++) {\r
- register float L_temp2 = 0;\r
- register float *sfl = sf - k;\r
- for (i = k; i < 160; ++i) L_temp2 += sf[i] * sfl[i];\r
- f_L_ACF[k] = L_temp2;\r
- }\r
- scale = MAX_LONGWORD / f_L_ACF[0];\r
-\r
- for (k = 0; k <= 8; k++) {\r
- L_ACF[k] = f_L_ACF[k] * scale;\r
- }\r
-}\r
-#endif /* defined (USE_FLOAT_MUL) && defined (FAST) */\r
-\r
-/* 4.2.5 */\r
-\r
-static void Reflection_coefficients P2( (L_ACF, r),\r
- longword * L_ACF, /* 0...8 IN */\r
- register word * r /* 0...7 OUT */\r
-)\r
-{\r
- register int i, m, n;\r
- register word temp;\r
- register longword ltmp;\r
- word ACF[9]; /* 0..8 */\r
- word P[ 9]; /* 0..8 */\r
- word K[ 9]; /* 2..8 */\r
-\r
- /* Schur recursion with 16 bits arithmetic.\r
- */\r
-\r
- if (L_ACF[0] == 0) {\r
- for (i = 8; i--; *r++ = 0) ;\r
- return;\r
- }\r
-\r
- assert( L_ACF[0] != 0 );\r
- temp = gsm_norm( L_ACF[0] );\r
-\r
- assert(temp >= 0 && temp < 32);\r
-\r
- /* ? overflow ? */\r
- for (i = 0; i <= 8; i++) ACF[i] = (word) SASR( L_ACF[i] << temp, 16 );\r
-\r
- /* Initialize array P[..] and K[..] for the recursion.\r
- */\r
-\r
- for (i = 1; i <= 7; i++) K[ i ] = ACF[ i ];\r
- for (i = 0; i <= 8; i++) P[ i ] = ACF[ i ];\r
-\r
- /* Compute reflection coefficients\r
- */\r
- for (n = 1; n <= 8; n++, r++) {\r
-\r
- temp = P[1];\r
- temp = GSM_ABS(temp);\r
- if (P[0] < temp) {\r
- for (i = n; i <= 8; i++) *r++ = 0;\r
- return;\r
- }\r
-\r
- *r = gsm_div( temp, P[0] );\r
-\r
- assert(*r >= 0);\r
- if (P[1] > 0) *r = -*r; /* r[n] = sub(0, r[n]) */\r
- assert (*r != MIN_WORD);\r
- if (n == 8) return; \r
-\r
- /* Schur recursion\r
- */\r
- temp = (word) GSM_MULT_R( P[1], *r );\r
- P[0] = (word) GSM_ADD( P[0], temp );\r
-\r
- for (m = 1; m <= 8 - n; m++) {\r
- temp = (word) GSM_MULT_R( K[ m ], *r );\r
- P[m] = (word) GSM_ADD( P[ m+1 ], temp );\r
-\r
- temp = (word) GSM_MULT_R( P[ m+1 ], *r );\r
- K[m] = (word) GSM_ADD( K[ m ], temp );\r
- }\r
- }\r
-}\r
-\r
-/* 4.2.6 */\r
-\r
-static void Transformation_to_Log_Area_Ratios P1((r),\r
- register word * r /* 0..7 IN/OUT */\r
-)\r
-/*\r
- * The following scaling for r[..] and LAR[..] has been used:\r
- *\r
- * r[..] = integer( real_r[..]*32768. ); -1 <= real_r < 1.\r
- * LAR[..] = integer( real_LAR[..] * 16384 );\r
- * with -1.625 <= real_LAR <= 1.625\r
- */\r
-{\r
- register word temp;\r
- register int i;\r
-\r
-\r
- /* Computation of the LAR[0..7] from the r[0..7]\r
- */\r
- for (i = 1; i <= 8; i++, r++) {\r
-\r
- temp = *r;\r
- temp = GSM_ABS(temp);\r
- assert(temp >= 0);\r
-\r
- if (temp < 22118) {\r
- temp >>= 1;\r
- } else if (temp < 31130) {\r
- assert( temp >= 11059 );\r
- temp -= 11059;\r
- } else {\r
- assert( temp >= 26112 );\r
- temp -= 26112;\r
- temp <<= 2;\r
- }\r
-\r
- *r = *r < 0 ? -temp : temp;\r
- assert( *r != MIN_WORD );\r
- }\r
-}\r
-\r
-/* 4.2.7 */\r
-\r
-static void Quantization_and_coding P1((LAR),\r
- register word * LAR /* [0..7] IN/OUT */\r
-)\r
-{\r
- register word temp;\r
- longword ltmp;\r
-\r
-\r
- /* This procedure needs four tables; the following equations\r
- * give the optimum scaling for the constants:\r
- * \r
- * A[0..7] = integer( real_A[0..7] * 1024 )\r
- * B[0..7] = integer( real_B[0..7] * 512 )\r
- * MAC[0..7] = maximum of the LARc[0..7]\r
- * MIC[0..7] = minimum of the LARc[0..7]\r
- */\r
-\r
-# undef STEP\r
-# define STEP( A, B, MAC, MIC ) \\r
- temp = (word)GSM_MULT( A, *LAR ); \\r
- temp = (word) GSM_ADD( temp, B ); \\r
- temp = (word) GSM_ADD( temp, 256 ); \\r
- temp = (word)SASR( temp, 9 ); \\r
- *LAR = temp>MAC ? MAC - MIC : (temp<MIC ? 0 : temp - MIC); \\r
- LAR++;\r
-\r
- STEP( 20480, 0, 31, -32 );\r
- STEP( 20480, 0, 31, -32 );\r
- STEP( 20480, 2048, 15, -16 );\r
- STEP( 20480, -2560, 15, -16 );\r
-\r
- STEP( 13964, 94, 7, -8 );\r
- STEP( 15360, -1792, 7, -8 );\r
- STEP( 8534, -341, 3, -4 );\r
- STEP( 9036, -1144, 3, -4 );\r
-\r
-# undef STEP\r
-}\r
-\r
-void Gsm_LPC_Analysis P3((S, s,LARc),\r
- struct gsm_state *S,\r
- word * s, /* 0..159 signals IN/OUT */\r
- word * LARc) /* 0..7 LARc's OUT */\r
-{\r
- longword L_ACF[9];\r
-\r
-#if defined(USE_FLOAT_MUL) && defined(FAST)\r
- if (S->fast) Fast_Autocorrelation (s, L_ACF );\r
- else\r
-#endif\r
- Autocorrelation (s, L_ACF );\r
- Reflection_coefficients (L_ACF, LARc );\r
- Transformation_to_Log_Area_Ratios (LARc);\r
- Quantization_and_coding (LARc);\r
-}\r
+/*
+ * gsm_lpc.c
+ *
+ * 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.
+ */
+
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "private.h"
+
+#include "gsm.h"
+#include "proto.h"
+
+#undef P
+
+/*
+ * 4.2.4 .. 4.2.7 LPC ANALYSIS SECTION
+ */
+
+/* 4.2.4 */
+
+
+static void Autocorrelation P2((s, L_ACF),
+ word * s, /* [0..159] IN/OUT */
+ longword * L_ACF) /* [0..8] OUT */
+/*
+ * The goal is to compute the array L_ACF[k]. The signal s[i] must
+ * be scaled in order to avoid an overflow situation.
+ */
+{
+ register int k, i;
+
+ word temp, smax, scalauto;
+
+#ifdef USE_FLOAT_MUL
+ float float_s[160];
+#endif
+
+ /* Dynamic scaling of the array s[0..159]
+ */
+
+ /* Search for the maximum.
+ */
+ smax = 0;
+ for (k = 0; k <= 159; k++) {
+ temp = GSM_ABS( s[k] );
+ if (temp > smax) smax = temp;
+ }
+
+ /* Computation of the scaling factor.
+ */
+ if (smax == 0) scalauto = 0;
+ else {
+ assert(smax > 0);
+ scalauto = 4 - gsm_norm( (longword)smax << 16 );/* sub(4,..) */
+ }
+
+ /* Scaling of the array s[0...159]
+ */
+
+ if (scalauto > 0) {
+
+# ifdef USE_FLOAT_MUL
+# define SCALE(n) \
+ case n: for (k = 0; k <= 159; k++) \
+ float_s[k] = (float) \
+ (s[k] = GSM_MULT_R(s[k], 16384 >> (n-1)));\
+ break;
+# else
+# define SCALE(n) \
+ case n: for (k = 0; k <= 159; k++) \
+ s[k] = (word) 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] = (word) 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 = (word) GSM_MULT_R( P[1], *r );
+ P[0] = (word) GSM_ADD( P[0], temp );
+
+ for (m = 1; m <= 8 - n; m++) {
+ temp = (word) GSM_MULT_R( K[ m ], *r );
+ P[m] = (word) GSM_ADD( P[ m+1 ], temp );
+
+ temp = (word) GSM_MULT_R( P[ m+1 ], *r );
+ K[m] = (word) 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 = (word)GSM_MULT( A, *LAR ); \
+ temp = (word) GSM_ADD( temp, B ); \
+ temp = (word) GSM_ADD( temp, 256 ); \
+ temp = (word)SASR( temp, 9 ); \
+ *LAR = temp>MAC ? MAC - MIC : (temp<MIC ? 0 : temp - MIC); \
+ LAR++;
+
+ STEP( 20480, 0, 31, -32 );
+ STEP( 20480, 0, 31, -32 );
+ STEP( 20480, 2048, 15, -16 );
+ STEP( 20480, -2560, 15, -16 );
+
+ STEP( 13964, 94, 7, -8 );
+ STEP( 15360, -1792, 7, -8 );
+ STEP( 8534, -341, 3, -4 );
+ STEP( 9036, -1144, 3, -4 );
+
+# undef STEP
+}
+
+void Gsm_LPC_Analysis P3((S, s,LARc),
+ struct gsm_state *S,
+ word * s, /* 0..159 signals IN/OUT */
+ word * LARc) /* 0..7 LARc's OUT */
+{
+ longword L_ACF[9];
+
+#if defined(USE_FLOAT_MUL) && defined(FAST)
+ if (S->fast) Fast_Autocorrelation (s, L_ACF );
+ else
+#endif
+ Autocorrelation (s, L_ACF );
+ Reflection_coefficients (L_ACF, LARc );
+ Transformation_to_Log_Area_Ratios (LARc);
+ Quantization_and_coding (LARc);
+}
-/*\r
- * gsm_option.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include "private.h"\r
-\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-int gsm_option P3((r, opt, val), gsm r, int opt, int * val)\r
-{\r
- int result = -1;\r
-\r
- switch (opt) {\r
- case GSM_OPT_LTP_CUT:\r
-#ifdef LTP_CUT\r
- result = r->ltp_cut;\r
- if (val) r->ltp_cut = *val;\r
-#endif\r
- break;\r
-\r
- case GSM_OPT_VERBOSE:\r
-#ifndef NDEBUG\r
- result = r->verbose;\r
- if (val) r->verbose = *val;\r
-#endif\r
- break;\r
-\r
- case GSM_OPT_FAST:\r
-\r
-#if defined(FAST) && defined(USE_FLOAT_MUL)\r
- result = r->fast;\r
- if (val) r->fast = !!*val;\r
-#endif\r
- break;\r
-\r
- case GSM_OPT_FRAME_CHAIN:\r
-\r
-#ifdef WAV49\r
- result = r->frame_chain;\r
- if (val) r->frame_chain = *val;\r
-#endif\r
- break;\r
-\r
- case GSM_OPT_FRAME_INDEX:\r
-\r
-#ifdef WAV49\r
- result = r->frame_index;\r
- if (val) r->frame_index = *val;\r
-#endif\r
- break;\r
-\r
- case GSM_OPT_WAV49:\r
-\r
-#ifdef WAV49 \r
- result = r->wav_fmt;\r
- if (val) r->wav_fmt = !!*val;\r
-#endif\r
- break;\r
-\r
- default:\r
- break;\r
- }\r
- return result;\r
-}\r
+/*
+ * gsm_option.c
+ *
+ * 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.
+ */
+
+
+#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;
+}
-/*\r
- * long_term.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include <stdio.h>\r
-#include <assert.h>\r
-\r
-#include "private.h"\r
-\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-/*\r
- * 4.2.11 .. 4.2.12 LONG TERM PREDICTOR (LTP) SECTION\r
- */\r
-\r
-\r
-/*\r
- * This module computes the LTP gain (bc) and the LTP lag (Nc)\r
- * for the long term analysis filter. This is done by calculating a\r
- * maximum of the cross-correlation function between the current\r
- * sub-segment short term residual signal d[0..39] (output of\r
- * the short term analysis filter; for simplification the index\r
- * of this array begins at 0 and ends at 39 for each sub-segment of the\r
- * RPE-LTP analysis) and the previous reconstructed short term\r
- * residual signal dp[ -120 .. -1 ]. A dynamic scaling must be\r
- * performed to avoid overflow.\r
- */\r
-\r
- /* The next procedure exists in six versions. First two integer\r
- * version (if USE_FLOAT_MUL is not defined); then four floating\r
- * point versions, twice with proper scaling (USE_FLOAT_MUL defined),\r
- * once without (USE_FLOAT_MUL and FAST defined, and fast run-time\r
- * option used). Every pair has first a Cut version (see the -C\r
- * option to toast or the LTP_CUT option to gsm_option()), then the\r
- * uncut one. (For a detailed explanation of why this is altogether\r
- * a bad idea, see Henry Spencer and Geoff Collyer, ``#ifdef Considered\r
- * Harmful''.)\r
- */\r
-\r
-#ifndef USE_FLOAT_MUL\r
-\r
-#ifdef LTP_CUT\r
-\r
-static void Cut_Calculation_of_the_LTP_parameters P5((st, d,dp,bc_out,Nc_out),\r
-\r
- struct gsm_state * st,\r
-\r
- register word * d, /* [0..39] IN */\r
- register word * dp, /* [-120..-1] IN */\r
- word * bc_out, /* OUT */\r
- word * Nc_out /* OUT */\r
-)\r
-{\r
- register int k, lambda;\r
- word Nc, bc;\r
- word wt[40];\r
-\r
- longword L_result;\r
- longword L_max, L_power;\r
- word R, S, dmax, scal, best_k;\r
- word ltp_cut;\r
-\r
- register word temp, wt_k;\r
-\r
- /* Search of the optimum scaling of d[0..39].\r
- */\r
- dmax = 0;\r
- for (k = 0; k <= 39; k++) {\r
- temp = d[k];\r
- temp = GSM_ABS( temp );\r
- if (temp > dmax) {\r
- dmax = temp;\r
- best_k = k;\r
- }\r
- }\r
- temp = 0;\r
- if (dmax == 0) scal = 0;\r
- else {\r
- assert(dmax > 0);\r
- temp = gsm_norm( (longword)dmax << 16 );\r
- }\r
- if (temp > 6) scal = 0;\r
- else scal = 6 - temp;\r
- assert(scal >= 0);\r
-\r
- /* Search for the maximum cross-correlation and coding of the LTP lag\r
- */\r
- L_max = 0;\r
- Nc = 40; /* index for the maximum cross-correlation */\r
- wt_k = SASR(d[best_k], scal);\r
-\r
- for (lambda = 40; lambda <= 120; lambda++) {\r
- L_result = (longword)wt_k * dp[best_k - lambda];\r
- if (L_result > L_max) {\r
- Nc = lambda;\r
- L_max = L_result;\r
- }\r
- }\r
- *Nc_out = Nc;\r
- L_max <<= 1;\r
-\r
- /* Rescaling of L_max\r
- */\r
- assert(scal <= 100 && scal >= -100);\r
- L_max = L_max >> (6 - scal); /* sub(6, scal) */\r
-\r
- assert( Nc <= 120 && Nc >= 40);\r
-\r
- /* Compute the power of the reconstructed short term residual\r
- * signal dp[..]\r
- */\r
- L_power = 0;\r
- for (k = 0; k <= 39; k++) {\r
-\r
- register longword L_temp;\r
-\r
- L_temp = SASR( dp[k - Nc], 3 );\r
- L_power += L_temp * L_temp;\r
- }\r
- L_power <<= 1; /* from L_MULT */\r
-\r
- /* Normalization of L_max and L_power\r
- */\r
-\r
- if (L_max <= 0) {\r
- *bc_out = 0;\r
- return;\r
- }\r
- if (L_max >= L_power) {\r
- *bc_out = 3;\r
- return;\r
- }\r
-\r
- temp = gsm_norm( L_power );\r
-\r
- R = SASR( L_max << temp, 16 );\r
- S = SASR( L_power << temp, 16 );\r
-\r
- /* Coding of the LTP gain\r
- */\r
-\r
- /* Table 4.3a must be used to obtain the level DLB[i] for the\r
- * quantization of the LTP gain b to get the coded version bc.\r
- */\r
- for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;\r
- *bc_out = bc;\r
-}\r
-\r
-#endif /* LTP_CUT */\r
-\r
-static void Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),\r
- register word * d, /* [0..39] IN */\r
- register word * dp, /* [-120..-1] IN */\r
- word * bc_out, /* OUT */\r
- word * Nc_out /* OUT */\r
-)\r
-{\r
- register int k, lambda;\r
- word Nc, bc;\r
- word wt[40];\r
-\r
- longword L_max, L_power;\r
- word R, S, dmax, scal;\r
- register word temp;\r
-\r
- /* Search of the optimum scaling of d[0..39].\r
- */\r
- dmax = 0;\r
-\r
- for (k = 0; k <= 39; k++) {\r
- temp = d[k];\r
- temp = GSM_ABS( temp );\r
- if (temp > dmax) dmax = temp;\r
- }\r
-\r
- temp = 0;\r
- if (dmax == 0) scal = 0;\r
- else {\r
- assert(dmax > 0);\r
- temp = gsm_norm( (longword)dmax << 16 );\r
- }\r
-\r
- if (temp > 6) scal = 0;\r
- else scal = 6 - temp;\r
-\r
- assert(scal >= 0);\r
-\r
- /* Initialization of a working array wt\r
- */\r
-\r
- for (k = 0; k <= 39; k++) wt[k] = SASR( d[k], scal );\r
-\r
- /* Search for the maximum cross-correlation and coding of the LTP lag\r
- */\r
- L_max = 0;\r
- Nc = 40; /* index for the maximum cross-correlation */\r
-\r
- for (lambda = 40; lambda <= 120; lambda++) {\r
-\r
-# undef STEP\r
-# define STEP(k) (longword)wt[k] * dp[k - lambda]\r
-\r
- register longword L_result;\r
-\r
- L_result = STEP(0) ; L_result += STEP(1) ;\r
- L_result += STEP(2) ; L_result += STEP(3) ;\r
- L_result += STEP(4) ; L_result += STEP(5) ;\r
- L_result += STEP(6) ; L_result += STEP(7) ;\r
- L_result += STEP(8) ; L_result += STEP(9) ;\r
- L_result += STEP(10) ; L_result += STEP(11) ;\r
- L_result += STEP(12) ; L_result += STEP(13) ;\r
- L_result += STEP(14) ; L_result += STEP(15) ;\r
- L_result += STEP(16) ; L_result += STEP(17) ;\r
- L_result += STEP(18) ; L_result += STEP(19) ;\r
- L_result += STEP(20) ; L_result += STEP(21) ;\r
- L_result += STEP(22) ; L_result += STEP(23) ;\r
- L_result += STEP(24) ; L_result += STEP(25) ;\r
- L_result += STEP(26) ; L_result += STEP(27) ;\r
- L_result += STEP(28) ; L_result += STEP(29) ;\r
- L_result += STEP(30) ; L_result += STEP(31) ;\r
- L_result += STEP(32) ; L_result += STEP(33) ;\r
- L_result += STEP(34) ; L_result += STEP(35) ;\r
- L_result += STEP(36) ; L_result += STEP(37) ;\r
- L_result += STEP(38) ; L_result += STEP(39) ;\r
-\r
- if (L_result > L_max) {\r
-\r
- Nc = lambda;\r
- L_max = L_result;\r
- }\r
- }\r
-\r
- *Nc_out = Nc;\r
-\r
- L_max <<= 1;\r
-\r
- /* Rescaling of L_max\r
- */\r
- assert(scal <= 100 && scal >= -100);\r
- L_max = L_max >> (6 - scal); /* sub(6, scal) */\r
-\r
- assert( Nc <= 120 && Nc >= 40);\r
-\r
- /* Compute the power of the reconstructed short term residual\r
- * signal dp[..]\r
- */\r
- L_power = 0;\r
- for (k = 0; k <= 39; k++) {\r
-\r
- register longword L_temp;\r
-\r
- L_temp = SASR( dp[k - Nc], 3 );\r
- L_power += L_temp * L_temp;\r
- }\r
- L_power <<= 1; /* from L_MULT */\r
-\r
- /* Normalization of L_max and L_power\r
- */\r
-\r
- if (L_max <= 0) {\r
- *bc_out = 0;\r
- return;\r
- }\r
- if (L_max >= L_power) {\r
- *bc_out = 3;\r
- return;\r
- }\r
-\r
- temp = gsm_norm( L_power );\r
-\r
- R = (word) SASR( L_max << temp, 16 );\r
- S = (word) SASR( L_power << temp, 16 );\r
-\r
- /* Coding of the LTP gain\r
- */\r
-\r
- /* Table 4.3a must be used to obtain the level DLB[i] for the\r
- * quantization of the LTP gain b to get the coded version bc.\r
- */\r
- for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;\r
- *bc_out = bc;\r
-}\r
-\r
-#else /* USE_FLOAT_MUL */\r
-\r
-#ifdef LTP_CUT\r
-\r
-static void Cut_Calculation_of_the_LTP_parameters P5((st, d,dp,bc_out,Nc_out),\r
- struct gsm_state * st, /* IN */\r
- register word * d, /* [0..39] IN */\r
- register word * dp, /* [-120..-1] IN */\r
- word * bc_out, /* OUT */\r
- word * Nc_out /* OUT */\r
-)\r
-{\r
- register int k, lambda;\r
- word Nc, bc;\r
- word ltp_cut;\r
-\r
- float wt_float[40];\r
- float dp_float_base[120], * dp_float = dp_float_base + 120;\r
-\r
- longword L_max, L_power;\r
- word R, S, dmax, scal;\r
- register word temp;\r
-\r
- /* Search of the optimum scaling of d[0..39].\r
- */\r
- dmax = 0;\r
-\r
- for (k = 0; k <= 39; k++) {\r
- temp = d[k];\r
- temp = GSM_ABS( temp );\r
- if (temp > dmax) dmax = temp;\r
- }\r
-\r
- temp = 0;\r
- if (dmax == 0) scal = 0;\r
- else {\r
- assert(dmax > 0);\r
- temp = gsm_norm( (longword)dmax << 16 );\r
- }\r
-\r
- if (temp > 6) scal = 0;\r
- else scal = 6 - temp;\r
-\r
- assert(scal >= 0);\r
- ltp_cut = (longword)SASR(dmax, scal) * st->ltp_cut / 100; \r
-\r
-\r
- /* Initialization of a working array wt\r
- */\r
-\r
- for (k = 0; k < 40; k++) {\r
- register word w = SASR( d[k], scal );\r
- if (w < 0 ? w > -ltp_cut : w < ltp_cut) {\r
- wt_float[k] = 0.0;\r
- }\r
- else {\r
- wt_float[k] = w;\r
- }\r
- }\r
- for (k = -120; k < 0; k++) dp_float[k] = dp[k];\r
-\r
- /* Search for the maximum cross-correlation and coding of the LTP lag\r
- */\r
- L_max = 0;\r
- Nc = 40; /* index for the maximum cross-correlation */\r
-\r
- for (lambda = 40; lambda <= 120; lambda += 9) {\r
-\r
- /* Calculate L_result for l = lambda .. lambda + 9.\r
- */\r
- register float *lp = dp_float - lambda;\r
-\r
- register float W;\r
- register float a = lp[-8], b = lp[-7], c = lp[-6],\r
- d = lp[-5], e = lp[-4], f = lp[-3],\r
- g = lp[-2], h = lp[-1];\r
- register float E; \r
- register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,\r
- S5 = 0, S6 = 0, S7 = 0, S8 = 0;\r
-\r
-# undef STEP\r
-# define STEP(K, a, b, c, d, e, f, g, h) \\r
- if ((W = wt_float[K]) != 0.0) { \\r
- E = W * a; S8 += E; \\r
- E = W * b; S7 += E; \\r
- E = W * c; S6 += E; \\r
- E = W * d; S5 += E; \\r
- E = W * e; S4 += E; \\r
- E = W * f; S3 += E; \\r
- E = W * g; S2 += E; \\r
- E = W * h; S1 += E; \\r
- a = lp[K]; \\r
- E = W * a; S0 += E; } else (a = lp[K])\r
-\r
-# define STEP_A(K) STEP(K, a, b, c, d, e, f, g, h)\r
-# define STEP_B(K) STEP(K, b, c, d, e, f, g, h, a)\r
-# define STEP_C(K) STEP(K, c, d, e, f, g, h, a, b)\r
-# define STEP_D(K) STEP(K, d, e, f, g, h, a, b, c)\r
-# define STEP_E(K) STEP(K, e, f, g, h, a, b, c, d)\r
-# define STEP_F(K) STEP(K, f, g, h, a, b, c, d, e)\r
-# define STEP_G(K) STEP(K, g, h, a, b, c, d, e, f)\r
-# define STEP_H(K) STEP(K, h, a, b, c, d, e, f, g)\r
-\r
- STEP_A( 0); STEP_B( 1); STEP_C( 2); STEP_D( 3);\r
- STEP_E( 4); STEP_F( 5); STEP_G( 6); STEP_H( 7);\r
-\r
- STEP_A( 8); STEP_B( 9); STEP_C(10); STEP_D(11);\r
- STEP_E(12); STEP_F(13); STEP_G(14); STEP_H(15);\r
-\r
- STEP_A(16); STEP_B(17); STEP_C(18); STEP_D(19);\r
- STEP_E(20); STEP_F(21); STEP_G(22); STEP_H(23);\r
-\r
- STEP_A(24); STEP_B(25); STEP_C(26); STEP_D(27);\r
- STEP_E(28); STEP_F(29); STEP_G(30); STEP_H(31);\r
-\r
- STEP_A(32); STEP_B(33); STEP_C(34); STEP_D(35);\r
- STEP_E(36); STEP_F(37); STEP_G(38); STEP_H(39);\r
-\r
- if (S0 > L_max) { L_max = S0; Nc = lambda; }\r
- if (S1 > L_max) { L_max = S1; Nc = lambda + 1; }\r
- if (S2 > L_max) { L_max = S2; Nc = lambda + 2; }\r
- if (S3 > L_max) { L_max = S3; Nc = lambda + 3; }\r
- if (S4 > L_max) { L_max = S4; Nc = lambda + 4; }\r
- if (S5 > L_max) { L_max = S5; Nc = lambda + 5; }\r
- if (S6 > L_max) { L_max = S6; Nc = lambda + 6; }\r
- if (S7 > L_max) { L_max = S7; Nc = lambda + 7; }\r
- if (S8 > L_max) { L_max = S8; Nc = lambda + 8; }\r
-\r
- }\r
- *Nc_out = Nc;\r
-\r
- L_max <<= 1;\r
-\r
- /* Rescaling of L_max\r
- */\r
- assert(scal <= 100 && scal >= -100);\r
- L_max = L_max >> (6 - scal); /* sub(6, scal) */\r
-\r
- assert( Nc <= 120 && Nc >= 40);\r
-\r
- /* Compute the power of the reconstructed short term residual\r
- * signal dp[..]\r
- */\r
- L_power = 0;\r
- for (k = 0; k <= 39; k++) {\r
-\r
- register longword L_temp;\r
-\r
- L_temp = SASR( dp[k - Nc], 3 );\r
- L_power += L_temp * L_temp;\r
- }\r
- L_power <<= 1; /* from L_MULT */\r
-\r
- /* Normalization of L_max and L_power\r
- */\r
-\r
- if (L_max <= 0) {\r
- *bc_out = 0;\r
- return;\r
- }\r
- if (L_max >= L_power) {\r
- *bc_out = 3;\r
- return;\r
- }\r
-\r
- temp = gsm_norm( L_power );\r
-\r
- R = SASR( L_max << temp, 16 );\r
- S = SASR( L_power << temp, 16 );\r
-\r
- /* Coding of the LTP gain\r
- */\r
-\r
- /* Table 4.3a must be used to obtain the level DLB[i] for the\r
- * quantization of the LTP gain b to get the coded version bc.\r
- */\r
- for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;\r
- *bc_out = bc;\r
-}\r
-\r
-#endif /* LTP_CUT */\r
-\r
-static void Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),\r
- register word * d, /* [0..39] IN */\r
- register word * dp, /* [-120..-1] IN */\r
- word * bc_out, /* OUT */\r
- word * Nc_out /* OUT */\r
-)\r
-{\r
- register int k, lambda;\r
- word Nc, bc;\r
-\r
- float wt_float[40];\r
- float dp_float_base[120], * dp_float = dp_float_base + 120;\r
-\r
- longword L_max, L_power;\r
- word R, S, dmax, scal;\r
- register word temp;\r
-\r
- /* Search of the optimum scaling of d[0..39].\r
- */\r
- dmax = 0;\r
-\r
- for (k = 0; k <= 39; k++) {\r
- temp = d[k];\r
- temp = GSM_ABS( temp );\r
- if (temp > dmax) dmax = temp;\r
- }\r
-\r
- temp = 0;\r
- if (dmax == 0) scal = 0;\r
- else {\r
- assert(dmax > 0);\r
- temp = gsm_norm( (longword)dmax << 16 );\r
- }\r
-\r
- if (temp > 6) scal = 0;\r
- else scal = 6 - temp;\r
-\r
- assert(scal >= 0);\r
-\r
- /* Initialization of a working array wt\r
- */\r
-\r
- for (k = 0; k < 40; k++) wt_float[k] = SASR( d[k], scal );\r
- for (k = -120; k < 0; k++) dp_float[k] = dp[k];\r
-\r
- /* Search for the maximum cross-correlation and coding of the LTP lag\r
- */\r
- L_max = 0;\r
- Nc = 40; /* index for the maximum cross-correlation */\r
-\r
- for (lambda = 40; lambda <= 120; lambda += 9) {\r
-\r
- /* Calculate L_result for l = lambda .. lambda + 9.\r
- */\r
- register float *lp = dp_float - lambda;\r
-\r
- register float W;\r
- register float a = lp[-8], b = lp[-7], c = lp[-6],\r
- d = lp[-5], e = lp[-4], f = lp[-3],\r
- g = lp[-2], h = lp[-1];\r
- register float E; \r
- register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,\r
- S5 = 0, S6 = 0, S7 = 0, S8 = 0;\r
-\r
-# undef STEP\r
-# define STEP(K, a, b, c, d, e, f, g, h) \\r
- W = wt_float[K]; \\r
- E = W * a; S8 += E; \\r
- E = W * b; S7 += E; \\r
- E = W * c; S6 += E; \\r
- E = W * d; S5 += E; \\r
- E = W * e; S4 += E; \\r
- E = W * f; S3 += E; \\r
- E = W * g; S2 += E; \\r
- E = W * h; S1 += E; \\r
- a = lp[K]; \\r
- E = W * a; S0 += E\r
-\r
-# define STEP_A(K) STEP(K, a, b, c, d, e, f, g, h)\r
-# define STEP_B(K) STEP(K, b, c, d, e, f, g, h, a)\r
-# define STEP_C(K) STEP(K, c, d, e, f, g, h, a, b)\r
-# define STEP_D(K) STEP(K, d, e, f, g, h, a, b, c)\r
-# define STEP_E(K) STEP(K, e, f, g, h, a, b, c, d)\r
-# define STEP_F(K) STEP(K, f, g, h, a, b, c, d, e)\r
-# define STEP_G(K) STEP(K, g, h, a, b, c, d, e, f)\r
-# define STEP_H(K) STEP(K, h, a, b, c, d, e, f, g)\r
-\r
- STEP_A( 0); STEP_B( 1); STEP_C( 2); STEP_D( 3);\r
- STEP_E( 4); STEP_F( 5); STEP_G( 6); STEP_H( 7);\r
-\r
- STEP_A( 8); STEP_B( 9); STEP_C(10); STEP_D(11);\r
- STEP_E(12); STEP_F(13); STEP_G(14); STEP_H(15);\r
-\r
- STEP_A(16); STEP_B(17); STEP_C(18); STEP_D(19);\r
- STEP_E(20); STEP_F(21); STEP_G(22); STEP_H(23);\r
-\r
- STEP_A(24); STEP_B(25); STEP_C(26); STEP_D(27);\r
- STEP_E(28); STEP_F(29); STEP_G(30); STEP_H(31);\r
-\r
- STEP_A(32); STEP_B(33); STEP_C(34); STEP_D(35);\r
- STEP_E(36); STEP_F(37); STEP_G(38); STEP_H(39);\r
-\r
- if (S0 > L_max) { L_max = S0; Nc = lambda; }\r
- if (S1 > L_max) { L_max = S1; Nc = lambda + 1; }\r
- if (S2 > L_max) { L_max = S2; Nc = lambda + 2; }\r
- if (S3 > L_max) { L_max = S3; Nc = lambda + 3; }\r
- if (S4 > L_max) { L_max = S4; Nc = lambda + 4; }\r
- if (S5 > L_max) { L_max = S5; Nc = lambda + 5; }\r
- if (S6 > L_max) { L_max = S6; Nc = lambda + 6; }\r
- if (S7 > L_max) { L_max = S7; Nc = lambda + 7; }\r
- if (S8 > L_max) { L_max = S8; Nc = lambda + 8; }\r
- }\r
- *Nc_out = Nc;\r
-\r
- L_max <<= 1;\r
-\r
- /* Rescaling of L_max\r
- */\r
- assert(scal <= 100 && scal >= -100);\r
- L_max = L_max >> (6 - scal); /* sub(6, scal) */\r
-\r
- assert( Nc <= 120 && Nc >= 40);\r
-\r
- /* Compute the power of the reconstructed short term residual\r
- * signal dp[..]\r
- */\r
- L_power = 0;\r
- for (k = 0; k <= 39; k++) {\r
-\r
- register longword L_temp;\r
-\r
- L_temp = SASR( dp[k - Nc], 3 );\r
- L_power += L_temp * L_temp;\r
- }\r
- L_power <<= 1; /* from L_MULT */\r
-\r
- /* Normalization of L_max and L_power\r
- */\r
-\r
- if (L_max <= 0) {\r
- *bc_out = 0;\r
- return;\r
- }\r
- if (L_max >= L_power) {\r
- *bc_out = 3;\r
- return;\r
- }\r
-\r
- temp = gsm_norm( L_power );\r
-\r
- R = SASR( L_max << temp, 16 );\r
- S = SASR( L_power << temp, 16 );\r
-\r
- /* Coding of the LTP gain\r
- */\r
-\r
- /* Table 4.3a must be used to obtain the level DLB[i] for the\r
- * quantization of the LTP gain b to get the coded version bc.\r
- */\r
- for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;\r
- *bc_out = bc;\r
-}\r
-\r
-#ifdef FAST\r
-#ifdef LTP_CUT\r
-\r
-static void Cut_Fast_Calculation_of_the_LTP_parameters P5((st,\r
- d,dp,bc_out,Nc_out),\r
- struct gsm_state * st, /* IN */\r
- register word * d, /* [0..39] IN */\r
- register word * dp, /* [-120..-1] IN */\r
- word * bc_out, /* OUT */\r
- word * Nc_out /* OUT */\r
-)\r
-{\r
- register int k, lambda;\r
- register float wt_float;\r
- word Nc, bc;\r
- word wt_max, best_k, ltp_cut;\r
-\r
- float dp_float_base[120], * dp_float = dp_float_base + 120;\r
-\r
- register float L_result, L_max, L_power;\r
-\r
- wt_max = 0;\r
-\r
- for (k = 0; k < 40; ++k) {\r
- if ( d[k] > wt_max) wt_max = d[best_k = k];\r
- else if (-d[k] > wt_max) wt_max = -d[best_k = k];\r
- }\r
-\r
- assert(wt_max >= 0);\r
- wt_float = (float)wt_max;\r
-\r
- for (k = -120; k < 0; ++k) dp_float[k] = (float)dp[k];\r
-\r
- /* Search for the maximum cross-correlation and coding of the LTP lag\r
- */\r
- L_max = 0;\r
- Nc = 40; /* index for the maximum cross-correlation */\r
-\r
- for (lambda = 40; lambda <= 120; lambda++) {\r
- L_result = wt_float * dp_float[best_k - lambda];\r
- if (L_result > L_max) {\r
- Nc = lambda;\r
- L_max = L_result;\r
- }\r
- }\r
-\r
- *Nc_out = Nc;\r
- if (L_max <= 0.) {\r
- *bc_out = 0;\r
- return;\r
- }\r
-\r
- /* Compute the power of the reconstructed short term residual\r
- * signal dp[..]\r
- */\r
- dp_float -= Nc;\r
- L_power = 0;\r
- for (k = 0; k < 40; ++k) {\r
- register float f = dp_float[k];\r
- L_power += f * f;\r
- }\r
-\r
- if (L_max >= L_power) {\r
- *bc_out = 3;\r
- return;\r
- }\r
-\r
- /* Coding of the LTP gain\r
- * Table 4.3a must be used to obtain the level DLB[i] for the\r
- * quantization of the LTP gain b to get the coded version bc.\r
- */\r
- lambda = L_max / L_power * 32768.;\r
- for (bc = 0; bc <= 2; ++bc) if (lambda <= gsm_DLB[bc]) break;\r
- *bc_out = bc;\r
-}\r
-\r
-#endif /* LTP_CUT */\r
-\r
-static void Fast_Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),\r
- register word * d, /* [0..39] IN */\r
- register word * dp, /* [-120..-1] IN */\r
- word * bc_out, /* OUT */\r
- word * Nc_out /* OUT */\r
-)\r
-{\r
- register int k, lambda;\r
- word Nc, bc;\r
-\r
- float wt_float[40];\r
- float dp_float_base[120], * dp_float = dp_float_base + 120;\r
-\r
- register float L_max, L_power;\r
-\r
- for (k = 0; k < 40; ++k) wt_float[k] = (float)d[k];\r
- for (k = -120; k < 0; ++k) dp_float[k] = (float)dp[k];\r
-\r
- /* Search for the maximum cross-correlation and coding of the LTP lag\r
- */\r
- L_max = 0;\r
- Nc = 40; /* index for the maximum cross-correlation */\r
-\r
- for (lambda = 40; lambda <= 120; lambda += 9) {\r
-\r
- /* Calculate L_result for l = lambda .. lambda + 9.\r
- */\r
- register float *lp = dp_float - lambda;\r
-\r
- register float W;\r
- register float a = lp[-8], b = lp[-7], c = lp[-6],\r
- d = lp[-5], e = lp[-4], f = lp[-3],\r
- g = lp[-2], h = lp[-1];\r
- register float E; \r
- register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,\r
- S5 = 0, S6 = 0, S7 = 0, S8 = 0;\r
-\r
-# undef STEP\r
-# define STEP(K, a, b, c, d, e, f, g, h) \\r
- W = wt_float[K]; \\r
- E = W * a; S8 += E; \\r
- E = W * b; S7 += E; \\r
- E = W * c; S6 += E; \\r
- E = W * d; S5 += E; \\r
- E = W * e; S4 += E; \\r
- E = W * f; S3 += E; \\r
- E = W * g; S2 += E; \\r
- E = W * h; S1 += E; \\r
- a = lp[K]; \\r
- E = W * a; S0 += E\r
-\r
-# define STEP_A(K) STEP(K, a, b, c, d, e, f, g, h)\r
-# define STEP_B(K) STEP(K, b, c, d, e, f, g, h, a)\r
-# define STEP_C(K) STEP(K, c, d, e, f, g, h, a, b)\r
-# define STEP_D(K) STEP(K, d, e, f, g, h, a, b, c)\r
-# define STEP_E(K) STEP(K, e, f, g, h, a, b, c, d)\r
-# define STEP_F(K) STEP(K, f, g, h, a, b, c, d, e)\r
-# define STEP_G(K) STEP(K, g, h, a, b, c, d, e, f)\r
-# define STEP_H(K) STEP(K, h, a, b, c, d, e, f, g)\r
-\r
- STEP_A( 0); STEP_B( 1); STEP_C( 2); STEP_D( 3);\r
- STEP_E( 4); STEP_F( 5); STEP_G( 6); STEP_H( 7);\r
-\r
- STEP_A( 8); STEP_B( 9); STEP_C(10); STEP_D(11);\r
- STEP_E(12); STEP_F(13); STEP_G(14); STEP_H(15);\r
-\r
- STEP_A(16); STEP_B(17); STEP_C(18); STEP_D(19);\r
- STEP_E(20); STEP_F(21); STEP_G(22); STEP_H(23);\r
-\r
- STEP_A(24); STEP_B(25); STEP_C(26); STEP_D(27);\r
- STEP_E(28); STEP_F(29); STEP_G(30); STEP_H(31);\r
-\r
- STEP_A(32); STEP_B(33); STEP_C(34); STEP_D(35);\r
- STEP_E(36); STEP_F(37); STEP_G(38); STEP_H(39);\r
-\r
- if (S0 > L_max) { L_max = S0; Nc = lambda; }\r
- if (S1 > L_max) { L_max = S1; Nc = lambda + 1; }\r
- if (S2 > L_max) { L_max = S2; Nc = lambda + 2; }\r
- if (S3 > L_max) { L_max = S3; Nc = lambda + 3; }\r
- if (S4 > L_max) { L_max = S4; Nc = lambda + 4; }\r
- if (S5 > L_max) { L_max = S5; Nc = lambda + 5; }\r
- if (S6 > L_max) { L_max = S6; Nc = lambda + 6; }\r
- if (S7 > L_max) { L_max = S7; Nc = lambda + 7; }\r
- if (S8 > L_max) { L_max = S8; Nc = lambda + 8; }\r
- }\r
- *Nc_out = Nc;\r
-\r
- if (L_max <= 0.) {\r
- *bc_out = 0;\r
- return;\r
- }\r
-\r
- /* Compute the power of the reconstructed short term residual\r
- * signal dp[..]\r
- */\r
- dp_float -= Nc;\r
- L_power = 0;\r
- for (k = 0; k < 40; ++k) {\r
- register float f = dp_float[k];\r
- L_power += f * f;\r
- }\r
-\r
- if (L_max >= L_power) {\r
- *bc_out = 3;\r
- return;\r
- }\r
-\r
- /* Coding of the LTP gain\r
- * Table 4.3a must be used to obtain the level DLB[i] for the\r
- * quantization of the LTP gain b to get the coded version bc.\r
- */\r
- lambda = L_max / L_power * 32768.;\r
- for (bc = 0; bc <= 2; ++bc) if (lambda <= gsm_DLB[bc]) break;\r
- *bc_out = bc;\r
-}\r
-\r
-#endif /* FAST */\r
-#endif /* USE_FLOAT_MUL */\r
-\r
-\r
-/* 4.2.12 */\r
-\r
-static void Long_term_analysis_filtering P6((bc,Nc,dp,d,dpp,e),\r
- word bc, /* IN */\r
- word Nc, /* IN */\r
- register word * dp, /* previous d [-120..-1] IN */\r
- register word * d, /* d [0..39] IN */\r
- register word * dpp, /* estimate [0..39] OUT */\r
- register word * e /* long term res. signal [0..39] OUT */\r
-)\r
-/*\r
- * In this part, we have to decode the bc parameter to compute\r
- * the samples of the estimate dpp[0..39]. The decoding of bc needs the\r
- * use of table 4.3b. The long term residual signal e[0..39]\r
- * is then calculated to be fed to the RPE encoding section.\r
- */\r
-{\r
- register int k;\r
- register longword ltmp;\r
-\r
-# undef STEP\r
-# define STEP(BP) \\r
- for (k = 0; k <= 39; k++) { \\r
- dpp[k] = (word) GSM_MULT_R( BP, dp[k - Nc]); \\r
- e[k] = (word) GSM_SUB( d[k], dpp[k] ); \\r
- }\r
-\r
- switch (bc) {\r
- case 0: STEP( 3277 ); break;\r
- case 1: STEP( 11469 ); break;\r
- case 2: STEP( 21299 ); break;\r
- case 3: STEP( 32767 ); break; \r
- }\r
-}\r
-\r
-void Gsm_Long_Term_Predictor P7((S,d,dp,e,dpp,Nc,bc), /* 4x for 160 samples */\r
-\r
- struct gsm_state * S,\r
-\r
- word * d, /* [0..39] residual signal IN */\r
- word * dp, /* [-120..-1] d' IN */\r
-\r
- word * e, /* [0..39] OUT */\r
- word * dpp, /* [0..39] OUT */\r
- word * Nc, /* correlation lag OUT */\r
- word * bc /* gain factor OUT */\r
-)\r
-{\r
- assert( d ); assert( dp ); assert( e );\r
- assert( dpp); assert( Nc ); assert( bc );\r
-\r
-#if defined(FAST) && defined(USE_FLOAT_MUL)\r
- if (S->fast) \r
-#if defined (LTP_CUT)\r
- if (S->ltp_cut)\r
- Cut_Fast_Calculation_of_the_LTP_parameters(S,\r
- d, dp, bc, Nc);\r
- else\r
-#endif /* LTP_CUT */\r
- Fast_Calculation_of_the_LTP_parameters(d, dp, bc, Nc );\r
- else \r
-#endif /* FAST & USE_FLOAT_MUL */\r
-#ifdef LTP_CUT\r
- if (S->ltp_cut)\r
- Cut_Calculation_of_the_LTP_parameters(S, d, dp, bc, Nc);\r
- else\r
-#endif\r
- Calculation_of_the_LTP_parameters(d, dp, bc, Nc);\r
-\r
- Long_term_analysis_filtering( *bc, *Nc, dp, d, dpp, e );\r
-}\r
-\r
-/* 4.3.2 */\r
-void Gsm_Long_Term_Synthesis_Filtering P5((S,Ncr,bcr,erp,drp),\r
- struct gsm_state * S,\r
-\r
- word Ncr,\r
- word bcr,\r
- register word * erp, /* [0..39] IN */\r
- register word * drp /* [-120..-1] IN, [-120..40] OUT */\r
-)\r
-/*\r
- * This procedure uses the bcr and Ncr parameter to realize the\r
- * long term synthesis filtering. The decoding of bcr needs\r
- * table 4.3b.\r
- */\r
-{\r
- register longword ltmp; /* for ADD */\r
- register int k;\r
- word brp, drpp, Nr;\r
-\r
- /* Check the limits of Nr.\r
- */\r
- Nr = Ncr < 40 || Ncr > 120 ? S->nrp : Ncr;\r
- S->nrp = Nr;\r
- assert(Nr >= 40 && Nr <= 120);\r
-\r
- /* Decoding of the LTP gain bcr\r
- */\r
- brp = gsm_QLB[ bcr ];\r
-\r
- /* Computation of the reconstructed short term residual \r
- * signal drp[0..39]\r
- */\r
- assert(brp != MIN_WORD);\r
-\r
- for (k = 0; k <= 39; k++) {\r
- drpp = (word) GSM_MULT_R( brp, drp[ k - Nr ] );\r
- drp[k] = (word) GSM_ADD( erp[k], drpp );\r
- }\r
-\r
- /*\r
- * Update of the reconstructed short term residual signal\r
- * drp[ -1..-120 ]\r
- */\r
-\r
- for (k = 0; k <= 119; k++) drp[ -120 + k ] = drp[ -80 + k ];\r
-}\r
+/*
+ * long_term.c
+ *
+ * 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.
+ */
+
+
+#include <stdio.h>
+#include <assert.h>
+
+#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 = (word) SASR( L_max << temp, 16 );
+ S = (word) 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] = (word) GSM_MULT_R( BP, dp[k - Nc]); \
+ e[k] = (word) 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 = (word) GSM_MULT_R( brp, drp[ k - Nr ] );
+ drp[k] = (word) 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 ];
+}
-/*\r
- * preprocess.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include <stdio.h>\r
-#include <assert.h>\r
-\r
-#include "private.h"\r
-\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-/* 4.2.0 .. 4.2.3 PREPROCESSING SECTION\r
- * \r
- * After A-law to linear conversion (or directly from the\r
- * Ato D converter) the following scaling is assumed for\r
- * input to the RPE-LTP algorithm:\r
- *\r
- * in: 0.1.....................12\r
- * S.v.v.v.v.v.v.v.v.v.v.v.v.*.*.*\r
- *\r
- * Where S is the sign bit, v a valid bit, and * a "don't care" bit.\r
- * The original signal is called sop[..]\r
- *\r
- * out: 0.1................... 12 \r
- * S.S.v.v.v.v.v.v.v.v.v.v.v.v.0.0\r
- */\r
-\r
-\r
-void Gsm_Preprocess P3((S, s, so),\r
- struct gsm_state * S,\r
- word * s,\r
- word * so ) /* [0..159] IN/OUT */\r
-{\r
-\r
- word z1 = S->z1;\r
- longword L_z2 = S->L_z2;\r
- word mp = S->mp;\r
-\r
- word s1;\r
- longword L_s2;\r
-\r
- longword L_temp;\r
-\r
- word msp, lsp;\r
- word SO;\r
-\r
- longword ltmp; /* for ADD */\r
- ulongword utmp; /* for L_ADD */\r
-\r
- register int k = 160;\r
-\r
- while (k--) {\r
-\r
- /* 4.2.1 Downscaling of the input signal\r
- */\r
- SO = SASR( *s, 3 ) << 2;\r
- s++;\r
-\r
- assert (SO >= -0x4000); /* downscaled by */\r
- assert (SO <= 0x3FFC); /* previous routine. */\r
-\r
-\r
- /* 4.2.2 Offset compensation\r
- * \r
- * This part implements a high-pass filter and requires extended\r
- * arithmetic precision for the recursive part of this filter.\r
- * The input of this procedure is the array so[0...159] and the\r
- * output the array sof[ 0...159 ].\r
- */\r
- /* Compute the non-recursive part\r
- */\r
-\r
- s1 = SO - z1; /* s1 = gsm_sub( *so, z1 ); */\r
- z1 = SO;\r
-\r
- assert(s1 != MIN_WORD);\r
-\r
- /* Compute the recursive part\r
- */\r
- L_s2 = s1;\r
- L_s2 <<= 15;\r
-\r
- /* Execution of a 31 bv 16 bits multiplication\r
- */\r
-\r
- msp = (word) SASR( L_z2, 15 );\r
- lsp = (word) (L_z2-((longword)msp<<15)); /* gsm_L_sub(L_z2,(msp<<15)); */\r
-\r
- L_s2 += GSM_MULT_R( lsp, 32735 );\r
- L_temp = (longword)msp * 32735; /* GSM_L_MULT(msp,32735) >> 1;*/\r
- L_z2 = GSM_L_ADD( L_temp, L_s2 );\r
-\r
- /* Compute sof[k] with rounding\r
- */\r
- L_temp = GSM_L_ADD( L_z2, 16384 );\r
-\r
- /* 4.2.3 Preemphasis\r
- */\r
-\r
- msp = (word) GSM_MULT_R( mp, -28180 );\r
- mp = (word) SASR( L_temp, 15 );\r
- *so++ = (word) GSM_ADD( mp, msp );\r
- }\r
-\r
- S->z1 = z1;\r
- S->L_z2 = L_z2;\r
- S->mp = mp;\r
-}\r
+/*
+ * preprocess.c
+ *
+ * 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.
+ */
+
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "private.h"
+
+#include "gsm.h"
+#include "proto.h"
+
+/* 4.2.0 .. 4.2.3 PREPROCESSING SECTION
+ *
+ * After A-law to linear conversion (or directly from the
+ * Ato D converter) the following scaling is assumed for
+ * input to the RPE-LTP algorithm:
+ *
+ * in: 0.1.....................12
+ * S.v.v.v.v.v.v.v.v.v.v.v.v.*.*.*
+ *
+ * Where S is the sign bit, v a valid bit, and * a "don't care" bit.
+ * The original signal is called sop[..]
+ *
+ * out: 0.1................... 12
+ * S.S.v.v.v.v.v.v.v.v.v.v.v.v.0.0
+ */
+
+
+void Gsm_Preprocess P3((S, s, so),
+ struct gsm_state * S,
+ word * s,
+ word * so ) /* [0..159] IN/OUT */
+{
+
+ word z1 = S->z1;
+ longword L_z2 = S->L_z2;
+ word mp = S->mp;
+
+ word s1;
+ longword L_s2;
+
+ longword L_temp;
+
+ word msp, lsp;
+ word SO;
+
+ longword ltmp; /* for ADD */
+ ulongword utmp; /* for L_ADD */
+
+ register int k = 160;
+
+ while (k--) {
+
+ /* 4.2.1 Downscaling of the input signal
+ */
+ SO = SASR( *s, 3 ) << 2;
+ s++;
+
+ assert (SO >= -0x4000); /* downscaled by */
+ assert (SO <= 0x3FFC); /* previous routine. */
+
+
+ /* 4.2.2 Offset compensation
+ *
+ * This part implements a high-pass filter and requires extended
+ * arithmetic precision for the recursive part of this filter.
+ * The input of this procedure is the array so[0...159] and the
+ * output the array sof[ 0...159 ].
+ */
+ /* Compute the non-recursive part
+ */
+
+ s1 = SO - z1; /* s1 = gsm_sub( *so, z1 ); */
+ z1 = SO;
+
+ assert(s1 != MIN_WORD);
+
+ /* Compute the recursive part
+ */
+ L_s2 = s1;
+ L_s2 <<= 15;
+
+ /* Execution of a 31 bv 16 bits multiplication
+ */
+
+ msp = (word) SASR( L_z2, 15 );
+ lsp = (word) (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 = (word) GSM_MULT_R( mp, -28180 );
+ mp = (word) SASR( L_temp, 15 );
+ *so++ = (word) GSM_ADD( mp, msp );
+ }
+
+ S->z1 = z1;
+ S->L_z2 = L_z2;
+ S->mp = mp;
+}
-/*\r
- * rpe.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include <stdio.h>\r
-#include <assert.h>\r
-\r
-#include "private.h"\r
-\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-/* 4.2.13 .. 4.2.17 RPE ENCODING SECTION\r
- */\r
-\r
-/* 4.2.13 */\r
-\r
-static void Weighting_filter P2((e, x),\r
- register word * e, /* signal [-5..0.39.44] IN */\r
- word * x /* signal [0..39] OUT */\r
-)\r
-/*\r
- * The coefficients of the weighting filter are stored in a table\r
- * (see table 4.4). The following scaling is used:\r
- *\r
- * H[0..10] = integer( real_H[ 0..10] * 8192 ); \r
- */\r
-{\r
- /* word wt[ 50 ]; */\r
-\r
- register longword L_result;\r
- register int k /* , i */ ;\r
-\r
- /* Initialization of a temporary working array wt[0...49]\r
- */\r
-\r
- /* for (k = 0; k <= 4; k++) wt[k] = 0;\r
- * for (k = 5; k <= 44; k++) wt[k] = *e++;\r
- * for (k = 45; k <= 49; k++) wt[k] = 0;\r
- *\r
- * (e[-5..-1] and e[40..44] are allocated by the caller,\r
- * are initially zero and are not written anywhere.)\r
- */\r
- e -= 5;\r
-\r
- /* Compute the signal x[0..39]\r
- */ \r
- for (k = 0; k <= 39; k++) {\r
-\r
- L_result = 8192 >> 1;\r
-\r
- /* for (i = 0; i <= 10; i++) {\r
- * L_temp = GSM_L_MULT( wt[k+i], gsm_H[i] );\r
- * L_result = GSM_L_ADD( L_result, L_temp );\r
- * }\r
- */\r
-\r
-#undef STEP\r
-#define STEP( i, H ) (e[ k + i ] * (longword)H)\r
-\r
- /* Every one of these multiplications is done twice --\r
- * but I don't see an elegant way to optimize this. \r
- * Do you?\r
- */\r
-\r
-#ifdef STUPID_COMPILER\r
- L_result += STEP( 0, -134 ) ;\r
- L_result += STEP( 1, -374 ) ;\r
- /* + STEP( 2, 0 ) */\r
- L_result += STEP( 3, 2054 ) ;\r
- L_result += STEP( 4, 5741 ) ;\r
- L_result += STEP( 5, 8192 ) ;\r
- L_result += STEP( 6, 5741 ) ;\r
- L_result += STEP( 7, 2054 ) ;\r
- /* + STEP( 8, 0 ) */\r
- L_result += STEP( 9, -374 ) ;\r
- L_result += STEP( 10, -134 ) ;\r
-#else\r
- L_result +=\r
- STEP( 0, -134 ) \r
- + STEP( 1, -374 ) \r
- /* + STEP( 2, 0 ) */\r
- + STEP( 3, 2054 ) \r
- + STEP( 4, 5741 ) \r
- + STEP( 5, 8192 ) \r
- + STEP( 6, 5741 ) \r
- + STEP( 7, 2054 ) \r
- /* + STEP( 8, 0 ) */\r
- + STEP( 9, -374 ) \r
- + STEP(10, -134 )\r
- ;\r
-#endif\r
-\r
- /* L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x2) *)\r
- * L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x4) *)\r
- *\r
- * x[k] = SASR( L_result, 16 );\r
- */\r
-\r
- /* 2 adds vs. >>16 => 14, minus one shift to compensate for\r
- * those we lost when replacing L_MULT by '*'.\r
- */\r
-\r
- L_result = SASR( L_result, 13 );\r
- x[k] = (word) (( L_result < MIN_WORD ? MIN_WORD\r
- : (L_result > MAX_WORD ? MAX_WORD : L_result )));\r
- }\r
-}\r
-\r
-/* 4.2.14 */\r
-\r
-static void RPE_grid_selection P3((x,xM,Mc_out),\r
- word * x, /* [0..39] IN */ \r
- word * xM, /* [0..12] OUT */\r
- word * Mc_out /* OUT */\r
-)\r
-/*\r
- * The signal x[0..39] is used to select the RPE grid which is\r
- * represented by Mc.\r
- */\r
-{\r
- /* register word temp1; */\r
- register int /* m, */ i;\r
- register longword L_result, L_temp;\r
- longword EM; /* xxx should be L_EM? */\r
- word Mc;\r
-\r
- longword L_common_0_3;\r
-\r
- EM = 0;\r
- Mc = 0;\r
-\r
- /* for (m = 0; m <= 3; m++) {\r
- * L_result = 0;\r
- *\r
- *\r
- * for (i = 0; i <= 12; i++) {\r
- *\r
- * temp1 = SASR( x[m + 3*i], 2 );\r
- *\r
- * assert(temp1 != MIN_WORD);\r
- *\r
- * L_temp = GSM_L_MULT( temp1, temp1 );\r
- * L_result = GSM_L_ADD( L_temp, L_result );\r
- * }\r
- * \r
- * if (L_result > EM) {\r
- * Mc = m;\r
- * EM = L_result;\r
- * }\r
- * }\r
- */\r
-\r
-#undef STEP\r
-#define STEP( m, i ) L_temp = SASR( x[m + 3 * i], 2 ); \\r
- L_result += L_temp * L_temp;\r
-\r
- /* common part of 0 and 3 */\r
-\r
- L_result = 0;\r
- STEP( 0, 1 ); STEP( 0, 2 ); STEP( 0, 3 ); STEP( 0, 4 );\r
- STEP( 0, 5 ); STEP( 0, 6 ); STEP( 0, 7 ); STEP( 0, 8 );\r
- STEP( 0, 9 ); STEP( 0, 10); STEP( 0, 11); STEP( 0, 12);\r
- L_common_0_3 = L_result;\r
-\r
- /* i = 0 */\r
-\r
- STEP( 0, 0 );\r
- L_result <<= 1; /* implicit in L_MULT */\r
- EM = L_result;\r
-\r
- /* i = 1 */\r
-\r
- L_result = 0;\r
- STEP( 1, 0 );\r
- STEP( 1, 1 ); STEP( 1, 2 ); STEP( 1, 3 ); STEP( 1, 4 );\r
- STEP( 1, 5 ); STEP( 1, 6 ); STEP( 1, 7 ); STEP( 1, 8 );\r
- STEP( 1, 9 ); STEP( 1, 10); STEP( 1, 11); STEP( 1, 12);\r
- L_result <<= 1;\r
- if (L_result > EM) {\r
- Mc = 1;\r
- EM = L_result;\r
- }\r
-\r
- /* i = 2 */\r
-\r
- L_result = 0;\r
- STEP( 2, 0 );\r
- STEP( 2, 1 ); STEP( 2, 2 ); STEP( 2, 3 ); STEP( 2, 4 );\r
- STEP( 2, 5 ); STEP( 2, 6 ); STEP( 2, 7 ); STEP( 2, 8 );\r
- STEP( 2, 9 ); STEP( 2, 10); STEP( 2, 11); STEP( 2, 12);\r
- L_result <<= 1;\r
- if (L_result > EM) {\r
- Mc = 2;\r
- EM = L_result;\r
- }\r
-\r
- /* i = 3 */\r
-\r
- L_result = L_common_0_3;\r
- STEP( 3, 12 );\r
- L_result <<= 1;\r
- if (L_result > EM) {\r
- Mc = 3;\r
- EM = L_result;\r
- }\r
-\r
- /**/\r
-\r
- /* Down-sampling by a factor 3 to get the selected xM[0..12]\r
- * RPE sequence.\r
- */\r
- for (i = 0; i <= 12; i ++) xM[i] = x[Mc + 3*i];\r
- *Mc_out = Mc;\r
-}\r
-\r
-/* 4.12.15 */\r
-\r
-static void APCM_quantization_xmaxc_to_exp_mant P3((xmaxc,exp_out,mant_out),\r
- word xmaxc, /* IN */\r
- word * exp_out, /* OUT */\r
- word * mant_out ) /* OUT */\r
-{\r
- word exp, mant;\r
-\r
- /* Compute exponent and mantissa of the decoded version of xmaxc\r
- */\r
-\r
- exp = 0;\r
- if (xmaxc > 15) exp = SASR(xmaxc, 3) - 1;\r
- mant = xmaxc - (exp << 3);\r
-\r
- if (mant == 0) {\r
- exp = -4;\r
- mant = 7;\r
- }\r
- else {\r
- while (mant <= 7) {\r
- mant = mant << 1 | 1;\r
- exp--;\r
- }\r
- mant -= 8;\r
- }\r
-\r
- assert( exp >= -4 && exp <= 6 );\r
- assert( mant >= 0 && mant <= 7 );\r
-\r
- *exp_out = exp;\r
- *mant_out = mant;\r
-}\r
-\r
-static void APCM_quantization P5((xM,xMc,mant_out,exp_out,xmaxc_out),\r
- word * xM, /* [0..12] IN */\r
-\r
- word * xMc, /* [0..12] OUT */\r
- word * mant_out, /* OUT */\r
- word * exp_out, /* OUT */\r
- word * xmaxc_out /* OUT */\r
-)\r
-{\r
- int i, itest;\r
-\r
- word xmax, xmaxc, temp, temp1, temp2;\r
- word exp, mant;\r
-\r
-\r
- /* Find the maximum absolute value xmax of xM[0..12].\r
- */\r
-\r
- xmax = 0;\r
- for (i = 0; i <= 12; i++) {\r
- temp = xM[i];\r
- temp = GSM_ABS(temp);\r
- if (temp > xmax) xmax = temp;\r
- }\r
-\r
- /* Qantizing and coding of xmax to get xmaxc.\r
- */\r
-\r
- exp = 0;\r
- temp = SASR( xmax, 9 );\r
- itest = 0;\r
-\r
- for (i = 0; i <= 5; i++) {\r
-\r
- itest |= (temp <= 0);\r
- temp = SASR( temp, 1 );\r
-\r
- assert(exp <= 5);\r
- if (itest == 0) exp++; /* exp = add (exp, 1) */\r
- }\r
-\r
- assert(exp <= 6 && exp >= 0);\r
- temp = exp + 5;\r
-\r
- assert(temp <= 11 && temp >= 0);\r
- xmaxc = gsm_add( SASR(xmax, temp), exp << 3 );\r
-\r
- /* Quantizing and coding of the xM[0..12] RPE sequence\r
- * to get the xMc[0..12]\r
- */\r
-\r
- APCM_quantization_xmaxc_to_exp_mant( xmaxc, &exp, &mant );\r
-\r
- /* This computation uses the fact that the decoded version of xmaxc\r
- * can be calculated by using the exponent and the mantissa part of\r
- * xmaxc (logarithmic table).\r
- * So, this method avoids any division and uses only a scaling\r
- * of the RPE samples by a function of the exponent. A direct \r
- * multiplication by the inverse of the mantissa (NRFAC[0..7]\r
- * found in table 4.5) gives the 3 bit coded version xMc[0..12]\r
- * of the RPE samples.\r
- */\r
-\r
-\r
- /* Direct computation of xMc[0..12] using table 4.5\r
- */\r
-\r
- assert( exp <= 4096 && exp >= -4096);\r
- assert( mant >= 0 && mant <= 7 ); \r
-\r
- temp1 = 6 - exp; /* normalization by the exponent */\r
- temp2 = gsm_NRFAC[ mant ]; /* inverse mantissa */\r
-\r
- for (i = 0; i <= 12; i++) {\r
-\r
- assert(temp1 >= 0 && temp1 < 16);\r
-\r
- temp = xM[i] << temp1;\r
- temp = (word) GSM_MULT( temp, temp2 );\r
- temp = SASR(temp, 12);\r
- xMc[i] = temp + 4; /* see note below */\r
- }\r
-\r
- /* NOTE: This equation is used to make all the xMc[i] positive.\r
- */\r
-\r
- *mant_out = mant;\r
- *exp_out = exp;\r
- *xmaxc_out = xmaxc;\r
-}\r
-\r
-/* 4.2.16 */\r
-\r
-static void APCM_inverse_quantization P4((xMc,mant,exp,xMp),\r
- register word * xMc, /* [0..12] IN */\r
- word mant,\r
- word exp,\r
- register word * xMp) /* [0..12] OUT */\r
-/* \r
- * This part is for decoding the RPE sequence of coded xMc[0..12]\r
- * samples to obtain the xMp[0..12] array. Table 4.6 is used to get\r
- * the mantissa of xmaxc (FAC[0..7]).\r
- */\r
-{\r
- int i;\r
- word temp, temp1, temp2, temp3;\r
- longword ltmp;\r
-\r
- assert( mant >= 0 && mant <= 7 ); \r
-\r
- temp1 = gsm_FAC[ mant ]; /* see 4.2-15 for mant */\r
- temp2 = gsm_sub( 6, exp ); /* see 4.2-15 for exp */\r
- temp3 = gsm_asl( 1, gsm_sub( temp2, 1 ));\r
-\r
- for (i = 13; i--;) {\r
-\r
- assert( *xMc <= 7 && *xMc >= 0 ); /* 3 bit unsigned */\r
-\r
- /* temp = gsm_sub( *xMc++ << 1, 7 ); */\r
- temp = (*xMc++ << 1) - 7; /* restore sign */\r
- assert( temp <= 7 && temp >= -7 ); /* 4 bit signed */\r
-\r
- temp <<= 12; /* 16 bit signed */\r
- temp = (word) GSM_MULT_R( temp1, temp );\r
- temp = (word) GSM_ADD( temp, temp3 );\r
- *xMp++ = gsm_asr( temp, temp2 );\r
- }\r
-}\r
-\r
-/* 4.2.17 */\r
-\r
-static void RPE_grid_positioning P3((Mc,xMp,ep),\r
- word Mc, /* grid position IN */\r
- register word * xMp, /* [0..12] IN */\r
- register word * ep /* [0..39] OUT */\r
-)\r
-/*\r
- * This procedure computes the reconstructed long term residual signal\r
- * ep[0..39] for the LTP analysis filter. The inputs are the Mc\r
- * which is the grid position selection and the xMp[0..12] decoded\r
- * RPE samples which are upsampled by a factor of 3 by inserting zero\r
- * values.\r
- */\r
-{\r
- int i = 13;\r
-\r
- assert(0 <= Mc && Mc <= 3);\r
-\r
- switch (Mc) {\r
- case 3: *ep++ = 0;\r
- case 2: do {\r
- *ep++ = 0;\r
- case 1: *ep++ = 0;\r
- case 0: *ep++ = *xMp++;\r
- } while (--i);\r
- }\r
- while (++Mc < 4) *ep++ = 0;\r
-\r
- /*\r
-\r
- int i, k;\r
- for (k = 0; k <= 39; k++) ep[k] = 0;\r
- for (i = 0; i <= 12; i++) {\r
- ep[ Mc + (3*i) ] = xMp[i];\r
- }\r
- */\r
-}\r
-\r
-/* 4.2.18 */\r
-\r
-/* This procedure adds the reconstructed long term residual signal\r
- * ep[0..39] to the estimated signal dpp[0..39] from the long term\r
- * analysis filter to compute the reconstructed short term residual\r
- * signal dp[-40..-1]; also the reconstructed short term residual\r
- * array dp[-120..-41] is updated.\r
- */\r
-\r
-#if 0 /* Has been inlined in code.c */\r
-void Gsm_Update_of_reconstructed_short_time_residual_signal P3((dpp, ep, dp),\r
- word * dpp, /* [0...39] IN */\r
- word * ep, /* [0...39] IN */\r
- word * dp) /* [-120...-1] IN/OUT */\r
-{\r
- int k;\r
-\r
- for (k = 0; k <= 79; k++) \r
- dp[ -120 + k ] = dp[ -80 + k ];\r
-\r
- for (k = 0; k <= 39; k++)\r
- dp[ -40 + k ] = gsm_add( ep[k], dpp[k] );\r
-}\r
-#endif /* Has been inlined in code.c */\r
-\r
-void Gsm_RPE_Encoding P5((S,e,xmaxc,Mc,xMc),\r
-\r
- struct gsm_state * S,\r
-\r
- word * e, /* -5..-1][0..39][40..44 IN/OUT */\r
- word * xmaxc, /* OUT */\r
- word * Mc, /* OUT */\r
- word * xMc) /* [0..12] OUT */\r
-{\r
- word x[40];\r
- word xM[13], xMp[13];\r
- word mant, exp;\r
-\r
- Weighting_filter(e, x);\r
- RPE_grid_selection(x, xM, Mc);\r
-\r
- APCM_quantization( xM, xMc, &mant, &exp, xmaxc);\r
- APCM_inverse_quantization( xMc, mant, exp, xMp);\r
-\r
- RPE_grid_positioning( *Mc, xMp, e );\r
-\r
-}\r
-\r
-void Gsm_RPE_Decoding P5((S, xmaxcr, Mcr, xMcr, erp),\r
- struct gsm_state * S,\r
-\r
- word xmaxcr,\r
- word Mcr,\r
- word * xMcr, /* [0..12], 3 bits IN */\r
- word * erp /* [0..39] OUT */\r
-)\r
-{\r
- word exp, mant;\r
- word xMp[ 13 ];\r
-\r
- APCM_quantization_xmaxc_to_exp_mant( xmaxcr, &exp, &mant );\r
- APCM_inverse_quantization( xMcr, mant, exp, xMp );\r
- RPE_grid_positioning( Mcr, xMp, erp );\r
-\r
-}\r
+/*
+ * rpe.c
+ *
+ * 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.
+ */
+
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "private.h"
+
+#include "gsm.h"
+#include "proto.h"
+
+/* 4.2.13 .. 4.2.17 RPE ENCODING SECTION
+ */
+
+/* 4.2.13 */
+
+static void Weighting_filter P2((e, x),
+ register word * e, /* signal [-5..0.39.44] IN */
+ word * x /* signal [0..39] OUT */
+)
+/*
+ * The coefficients of the weighting filter are stored in a table
+ * (see table 4.4). The following scaling is used:
+ *
+ * H[0..10] = integer( real_H[ 0..10] * 8192 );
+ */
+{
+ /* word wt[ 50 ]; */
+
+ register longword L_result;
+ register int k /* , i */ ;
+
+ /* Initialization of a temporary working array wt[0...49]
+ */
+
+ /* for (k = 0; k <= 4; k++) wt[k] = 0;
+ * for (k = 5; k <= 44; k++) wt[k] = *e++;
+ * for (k = 45; k <= 49; k++) wt[k] = 0;
+ *
+ * (e[-5..-1] and e[40..44] are allocated by the caller,
+ * are initially zero and are not written anywhere.)
+ */
+ e -= 5;
+
+ /* Compute the signal x[0..39]
+ */
+ for (k = 0; k <= 39; k++) {
+
+ L_result = 8192 >> 1;
+
+ /* for (i = 0; i <= 10; i++) {
+ * L_temp = GSM_L_MULT( wt[k+i], gsm_H[i] );
+ * L_result = GSM_L_ADD( L_result, L_temp );
+ * }
+ */
+
+#undef STEP
+#define STEP( i, H ) (e[ k + i ] * (longword)H)
+
+ /* Every one of these multiplications is done twice --
+ * but I don't see an elegant way to optimize this.
+ * Do you?
+ */
+
+#ifdef STUPID_COMPILER
+ L_result += STEP( 0, -134 ) ;
+ L_result += STEP( 1, -374 ) ;
+ /* + STEP( 2, 0 ) */
+ L_result += STEP( 3, 2054 ) ;
+ L_result += STEP( 4, 5741 ) ;
+ L_result += STEP( 5, 8192 ) ;
+ L_result += STEP( 6, 5741 ) ;
+ L_result += STEP( 7, 2054 ) ;
+ /* + STEP( 8, 0 ) */
+ L_result += STEP( 9, -374 ) ;
+ L_result += STEP( 10, -134 ) ;
+#else
+ L_result +=
+ STEP( 0, -134 )
+ + STEP( 1, -374 )
+ /* + STEP( 2, 0 ) */
+ + STEP( 3, 2054 )
+ + STEP( 4, 5741 )
+ + STEP( 5, 8192 )
+ + STEP( 6, 5741 )
+ + STEP( 7, 2054 )
+ /* + STEP( 8, 0 ) */
+ + STEP( 9, -374 )
+ + STEP(10, -134 )
+ ;
+#endif
+
+ /* L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x2) *)
+ * L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x4) *)
+ *
+ * x[k] = SASR( L_result, 16 );
+ */
+
+ /* 2 adds vs. >>16 => 14, minus one shift to compensate for
+ * those we lost when replacing L_MULT by '*'.
+ */
+
+ L_result = SASR( L_result, 13 );
+ x[k] = (word) (( 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 = (word) 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 = (word) GSM_MULT_R( temp1, temp );
+ temp = (word) 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 );
+
+}
-/*\r
- * short_term.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-#include <stdio.h>\r
-#include <assert.h>\r
-\r
-#include "private.h"\r
-\r
-#include "gsm.h"\r
-#include "proto.h"\r
-\r
-/*\r
- * SHORT TERM ANALYSIS FILTERING SECTION\r
- */\r
-\r
-/* 4.2.8 */\r
-\r
-static void Decoding_of_the_coded_Log_Area_Ratios P2((LARc,LARpp),\r
- word * LARc, /* coded log area ratio [0..7] IN */\r
- word * LARpp) /* out: decoded .. */\r
-{\r
- register word temp1 /* , temp2 */;\r
- register long ltmp; /* for GSM_ADD */\r
-\r
- /* This procedure requires for efficient implementation\r
- * two tables.\r
- *\r
- * INVA[1..8] = integer( (32768 * 8) / real_A[1..8])\r
- * MIC[1..8] = minimum value of the LARc[1..8]\r
- */\r
-\r
- /* Compute the LARpp[1..8]\r
- */\r
-\r
- /* for (i = 1; i <= 8; i++, B++, MIC++, INVA++, LARc++, LARpp++) {\r
- *\r
- * temp1 = GSM_ADD( *LARc, *MIC ) << 10;\r
- * temp2 = *B << 1;\r
- * temp1 = GSM_SUB( temp1, temp2 );\r
- *\r
- * assert(*INVA != MIN_WORD);\r
- *\r
- * temp1 = GSM_MULT_R( *INVA, temp1 );\r
- * *LARpp = GSM_ADD( temp1, temp1 );\r
- * }\r
- */\r
-\r
-#undef STEP\r
-#define STEP( B, MIC, INVA ) \\r
- temp1 = (word) GSM_ADD( *LARc++, MIC ) << 10; \\r
- temp1 = (word) GSM_SUB( temp1, B << 1 ); \\r
- temp1 = (word) GSM_MULT_R( INVA, temp1 ); \\r
- *LARpp++ = (word) GSM_ADD( temp1, temp1 );\r
-\r
- STEP( 0, -32, 13107 );\r
- STEP( 0, -32, 13107 );\r
- STEP( 2048, -16, 13107 );\r
- STEP( -2560, -16, 13107 );\r
-\r
- STEP( 94, -8, 19223 );\r
- STEP( -1792, -8, 17476 );\r
- STEP( -341, -4, 31454 );\r
- STEP( -1144, -4, 29708 );\r
-\r
- /* NOTE: the addition of *MIC is used to restore\r
- * the sign of *LARc.\r
- */\r
-}\r
-\r
-/* 4.2.9 */\r
-/* Computation of the quantized reflection coefficients \r
- */\r
-\r
-/* 4.2.9.1 Interpolation of the LARpp[1..8] to get the LARp[1..8]\r
- */\r
-\r
-/*\r
- * Within each frame of 160 analyzed speech samples the short term\r
- * analysis and synthesis filters operate with four different sets of\r
- * coefficients, derived from the previous set of decoded LARs(LARpp(j-1))\r
- * and the actual set of decoded LARs (LARpp(j))\r
- *\r
- * (Initial value: LARpp(j-1)[1..8] = 0.)\r
- */\r
-\r
-static void Coefficients_0_12 P3((LARpp_j_1, LARpp_j, LARp),\r
- register word * LARpp_j_1,\r
- register word * LARpp_j,\r
- register word * LARp)\r
-{\r
- register int i;\r
- register longword ltmp;\r
-\r
- for (i = 1; i <= 8; i++, LARp++, LARpp_j_1++, LARpp_j++) {\r
- *LARp = (word) GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));\r
- *LARp = (word) GSM_ADD( *LARp, SASR( *LARpp_j_1, 1));\r
- }\r
-}\r
-\r
-static void Coefficients_13_26 P3((LARpp_j_1, LARpp_j, LARp),\r
- register word * LARpp_j_1,\r
- register word * LARpp_j,\r
- register word * LARp)\r
-{\r
- register int i;\r
- register longword ltmp;\r
- for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {\r
- *LARp = (word) GSM_ADD( SASR( *LARpp_j_1, 1), SASR( *LARpp_j, 1 ));\r
- }\r
-}\r
-\r
-static void Coefficients_27_39 P3((LARpp_j_1, LARpp_j, LARp),\r
- register word * LARpp_j_1,\r
- register word * LARpp_j,\r
- register word * LARp)\r
-{\r
- register int i;\r
- register longword ltmp;\r
-\r
- for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {\r
- *LARp = (word) GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));\r
- *LARp = (word) GSM_ADD( *LARp, SASR( *LARpp_j, 1 ));\r
- }\r
-}\r
-\r
-\r
-static void Coefficients_40_159 P2((LARpp_j, LARp),\r
- register word * LARpp_j,\r
- register word * LARp)\r
-{\r
- register int i;\r
-\r
- for (i = 1; i <= 8; i++, LARp++, LARpp_j++)\r
- *LARp = *LARpp_j;\r
-}\r
-\r
-/* 4.2.9.2 */\r
-\r
-static void LARp_to_rp P1((LARp),\r
- register word * LARp) /* [0..7] IN/OUT */\r
-/*\r
- * The input of this procedure is the interpolated LARp[0..7] array.\r
- * The reflection coefficients, rp[i], are used in the analysis\r
- * filter and in the synthesis filter.\r
- */\r
-{\r
- register int i;\r
- register word temp;\r
- register longword ltmp;\r
-\r
- for (i = 1; i <= 8; i++, LARp++) {\r
-\r
- /* temp = GSM_ABS( *LARp );\r
- *\r
- * if (temp < 11059) temp <<= 1;\r
- * else if (temp < 20070) temp += 11059;\r
- * else temp = GSM_ADD( temp >> 2, 26112 );\r
- *\r
- * *LARp = *LARp < 0 ? -temp : temp;\r
- */\r
-\r
- if (*LARp < 0) {\r
- temp = *LARp == MIN_WORD ? MAX_WORD : -(*LARp);\r
- *LARp = - ((temp < 11059) ? temp << 1\r
- : ((temp < 20070) ? temp + 11059\r
- : (word) GSM_ADD( temp >> 2, 26112 )));\r
- } else {\r
- temp = *LARp;\r
- *LARp = (temp < 11059) ? temp << 1\r
- : ((temp < 20070) ? temp + 11059\r
- : (word) GSM_ADD( temp >> 2, 26112 ));\r
- }\r
- }\r
-}\r
-\r
-\r
-/* 4.2.10 */\r
-static void Short_term_analysis_filtering P4((S,rp,k_n,s),\r
- struct gsm_state * S,\r
- register word * rp, /* [0..7] IN */\r
- register int k_n, /* k_end - k_start */\r
- register word * s /* [0..n-1] IN/OUT */\r
-)\r
-/*\r
- * This procedure computes the short term residual signal d[..] to be fed\r
- * to the RPE-LTP loop from the s[..] signal and from the local rp[..]\r
- * array (quantized reflection coefficients). As the call of this\r
- * procedure can be done in many ways (see the interpolation of the LAR\r
- * coefficient), it is assumed that the computation begins with index\r
- * k_start (for arrays d[..] and s[..]) and stops with index k_end\r
- * (k_start and k_end are defined in 4.2.9.1). This procedure also\r
- * needs to keep the array u[0..7] in memory for each call.\r
- */\r
-{\r
- register word * u = S->u;\r
- register int i;\r
- register word di, zzz, ui, sav, rpi;\r
- register longword ltmp;\r
-\r
- for (; k_n--; s++) {\r
-\r
- di = sav = *s;\r
-\r
- for (i = 0; i < 8; i++) { /* YYY */\r
-\r
- ui = u[i];\r
- rpi = rp[i];\r
- u[i] = sav;\r
-\r
- zzz = (word) GSM_MULT_R(rpi, di);\r
- sav = (word) GSM_ADD( ui, zzz);\r
-\r
- zzz = (word) GSM_MULT_R(rpi, ui);\r
- di = (word) GSM_ADD( di, zzz );\r
- }\r
-\r
- *s = di;\r
- }\r
-}\r
-\r
-#if defined(USE_FLOAT_MUL) && defined(FAST)\r
-\r
-static void Fast_Short_term_analysis_filtering P4((S,rp,k_n,s),\r
- struct gsm_state * S,\r
- register word * rp, /* [0..7] IN */\r
- register int k_n, /* k_end - k_start */\r
- register word * s /* [0..n-1] IN/OUT */\r
-)\r
-{\r
- register word * u = S->u;\r
- register int i;\r
-\r
- float uf[8],\r
- rpf[8];\r
-\r
- register float scalef = 3.0517578125e-5;\r
- register float sav, di, temp;\r
-\r
- for (i = 0; i < 8; ++i) {\r
- uf[i] = u[i];\r
- rpf[i] = rp[i] * scalef;\r
- }\r
- for (; k_n--; s++) {\r
- sav = di = *s;\r
- for (i = 0; i < 8; ++i) {\r
- register float rpfi = rpf[i];\r
- register float ufi = uf[i];\r
-\r
- uf[i] = sav;\r
- temp = rpfi * di + ufi;\r
- di += rpfi * ufi;\r
- sav = temp;\r
- }\r
- *s = di;\r
- }\r
- for (i = 0; i < 8; ++i) u[i] = uf[i];\r
-}\r
-#endif /* ! (defined (USE_FLOAT_MUL) && defined (FAST)) */\r
-\r
-static void Short_term_synthesis_filtering P5((S,rrp,k,wt,sr),\r
- struct gsm_state * S,\r
- register word * rrp, /* [0..7] IN */\r
- register int k, /* k_end - k_start */\r
- register word * wt, /* [0..k-1] IN */\r
- register word * sr /* [0..k-1] OUT */\r
-)\r
-{\r
- register word * v = S->v;\r
- register int i;\r
- register word sri, tmp1, tmp2;\r
- register longword ltmp; /* for GSM_ADD & GSM_SUB */\r
-\r
- while (k--) {\r
- sri = *wt++;\r
- for (i = 8; i--;) {\r
-\r
- /* sri = GSM_SUB( sri, gsm_mult_r( rrp[i], v[i] ) );\r
- */\r
- tmp1 = rrp[i];\r
- tmp2 = v[i];\r
- tmp2 = (word) ( tmp1 == MIN_WORD && tmp2 == MIN_WORD\r
- ? MAX_WORD\r
- : 0x0FFFF & (( (longword)tmp1 * (longword)tmp2\r
- + 16384) >> 15)) ;\r
-\r
- sri = (word) GSM_SUB( sri, tmp2 );\r
-\r
- /* v[i+1] = GSM_ADD( v[i], gsm_mult_r( rrp[i], sri ) );\r
- */\r
- tmp1 = (word) ( tmp1 == MIN_WORD && sri == MIN_WORD\r
- ? MAX_WORD\r
- : 0x0FFFF & (( (longword)tmp1 * (longword)sri\r
- + 16384) >> 15)) ;\r
-\r
- v[i+1] = (word) GSM_ADD( v[i], tmp1);\r
- }\r
- *sr++ = v[0] = sri;\r
- }\r
-}\r
-\r
-\r
-#if defined(FAST) && defined(USE_FLOAT_MUL)\r
-\r
-static void Fast_Short_term_synthesis_filtering P5((S,rrp,k,wt,sr),\r
- struct gsm_state * S,\r
- register word * rrp, /* [0..7] IN */\r
- register int k, /* k_end - k_start */\r
- register word * wt, /* [0..k-1] IN */\r
- register word * sr /* [0..k-1] OUT */\r
-)\r
-{\r
- register word * v = S->v;\r
- register int i;\r
-\r
- float va[9], rrpa[8];\r
- register float scalef = 3.0517578125e-5, temp;\r
-\r
- for (i = 0; i < 8; ++i) {\r
- va[i] = v[i];\r
- rrpa[i] = (float)rrp[i] * scalef;\r
- }\r
- while (k--) {\r
- register float sri = *wt++;\r
- for (i = 8; i--;) {\r
- sri -= rrpa[i] * va[i];\r
- if (sri < -32768.) sri = -32768.;\r
- else if (sri > 32767.) sri = 32767.;\r
-\r
- temp = va[i] + rrpa[i] * sri;\r
- if (temp < -32768.) temp = -32768.;\r
- else if (temp > 32767.) temp = 32767.;\r
- va[i+1] = temp;\r
- }\r
- *sr++ = va[0] = sri;\r
- }\r
- for (i = 0; i < 9; ++i) v[i] = va[i];\r
-}\r
-\r
-#endif /* defined(FAST) && defined(USE_FLOAT_MUL) */\r
-\r
-void Gsm_Short_Term_Analysis_Filter P3((S,LARc,s),\r
-\r
- struct gsm_state * S,\r
-\r
- word * LARc, /* coded log area ratio [0..7] IN */\r
- word * s /* signal [0..159] IN/OUT */\r
-)\r
-{\r
- word * LARpp_j = S->LARpp[ S->j ];\r
- word * LARpp_j_1 = S->LARpp[ S->j ^= 1 ];\r
-\r
- word LARp[8];\r
-\r
-#undef FILTER\r
-#if defined(FAST) && defined(USE_FLOAT_MUL)\r
-# define FILTER (* (S->fast \\r
- ? Fast_Short_term_analysis_filtering \\r
- : Short_term_analysis_filtering ))\r
-\r
-#else\r
-# define FILTER Short_term_analysis_filtering\r
-#endif\r
-\r
- Decoding_of_the_coded_Log_Area_Ratios( LARc, LARpp_j );\r
-\r
- Coefficients_0_12( LARpp_j_1, LARpp_j, LARp );\r
- LARp_to_rp( LARp );\r
- FILTER( S, LARp, 13, s);\r
-\r
- Coefficients_13_26( LARpp_j_1, LARpp_j, LARp);\r
- LARp_to_rp( LARp );\r
- FILTER( S, LARp, 14, s + 13);\r
-\r
- Coefficients_27_39( LARpp_j_1, LARpp_j, LARp);\r
- LARp_to_rp( LARp );\r
- FILTER( S, LARp, 13, s + 27);\r
-\r
- Coefficients_40_159( LARpp_j, LARp);\r
- LARp_to_rp( LARp );\r
- FILTER( S, LARp, 120, s + 40);\r
-}\r
-\r
-void Gsm_Short_Term_Synthesis_Filter P4((S, LARcr, wt, s),\r
- struct gsm_state * S,\r
-\r
- word * LARcr, /* received log area ratios [0..7] IN */\r
- word * wt, /* received d [0..159] IN */\r
-\r
- word * s /* signal s [0..159] OUT */\r
-)\r
-{\r
- word * LARpp_j = S->LARpp[ S->j ];\r
- word * LARpp_j_1 = S->LARpp[ S->j ^=1 ];\r
-\r
- word LARp[8];\r
-\r
-#undef FILTER\r
-#if defined(FAST) && defined(USE_FLOAT_MUL)\r
-\r
-# define FILTER (* (S->fast \\r
- ? Fast_Short_term_synthesis_filtering \\r
- : Short_term_synthesis_filtering ))\r
-#else\r
-# define FILTER Short_term_synthesis_filtering\r
-#endif\r
-\r
- Decoding_of_the_coded_Log_Area_Ratios( LARcr, LARpp_j );\r
-\r
- Coefficients_0_12( LARpp_j_1, LARpp_j, LARp );\r
- LARp_to_rp( LARp );\r
- FILTER( S, LARp, 13, wt, s );\r
-\r
- Coefficients_13_26( LARpp_j_1, LARpp_j, LARp);\r
- LARp_to_rp( LARp );\r
- FILTER( S, LARp, 14, wt + 13, s + 13 );\r
-\r
- Coefficients_27_39( LARpp_j_1, LARpp_j, LARp);\r
- LARp_to_rp( LARp );\r
- FILTER( S, LARp, 13, wt + 27, s + 27 );\r
-\r
- Coefficients_40_159( LARpp_j, LARp );\r
- LARp_to_rp( LARp );\r
- FILTER(S, LARp, 120, wt + 40, s + 40);\r
-}\r
+/*
+ * short_term.c
+ *
+ * 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.
+ */
+
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "private.h"
+
+#include "gsm.h"
+#include "proto.h"
+
+/*
+ * SHORT TERM ANALYSIS FILTERING SECTION
+ */
+
+/* 4.2.8 */
+
+static void Decoding_of_the_coded_Log_Area_Ratios P2((LARc,LARpp),
+ word * LARc, /* coded log area ratio [0..7] IN */
+ word * LARpp) /* out: decoded .. */
+{
+ register word temp1 /* , temp2 */;
+ register long ltmp; /* for GSM_ADD */
+
+ /* This procedure requires for efficient implementation
+ * two tables.
+ *
+ * INVA[1..8] = integer( (32768 * 8) / real_A[1..8])
+ * MIC[1..8] = minimum value of the LARc[1..8]
+ */
+
+ /* Compute the LARpp[1..8]
+ */
+
+ /* for (i = 1; i <= 8; i++, B++, MIC++, INVA++, LARc++, LARpp++) {
+ *
+ * temp1 = GSM_ADD( *LARc, *MIC ) << 10;
+ * temp2 = *B << 1;
+ * temp1 = GSM_SUB( temp1, temp2 );
+ *
+ * assert(*INVA != MIN_WORD);
+ *
+ * temp1 = GSM_MULT_R( *INVA, temp1 );
+ * *LARpp = GSM_ADD( temp1, temp1 );
+ * }
+ */
+
+#undef STEP
+#define STEP( B, MIC, INVA ) \
+ temp1 = (word) GSM_ADD( *LARc++, MIC ) << 10; \
+ temp1 = (word) GSM_SUB( temp1, B << 1 ); \
+ temp1 = (word) GSM_MULT_R( INVA, temp1 ); \
+ *LARpp++ = (word) GSM_ADD( temp1, temp1 );
+
+ STEP( 0, -32, 13107 );
+ STEP( 0, -32, 13107 );
+ STEP( 2048, -16, 13107 );
+ STEP( -2560, -16, 13107 );
+
+ STEP( 94, -8, 19223 );
+ STEP( -1792, -8, 17476 );
+ STEP( -341, -4, 31454 );
+ STEP( -1144, -4, 29708 );
+
+ /* NOTE: the addition of *MIC is used to restore
+ * the sign of *LARc.
+ */
+}
+
+/* 4.2.9 */
+/* Computation of the quantized reflection coefficients
+ */
+
+/* 4.2.9.1 Interpolation of the LARpp[1..8] to get the LARp[1..8]
+ */
+
+/*
+ * Within each frame of 160 analyzed speech samples the short term
+ * analysis and synthesis filters operate with four different sets of
+ * coefficients, derived from the previous set of decoded LARs(LARpp(j-1))
+ * and the actual set of decoded LARs (LARpp(j))
+ *
+ * (Initial value: LARpp(j-1)[1..8] = 0.)
+ */
+
+static void Coefficients_0_12 P3((LARpp_j_1, LARpp_j, LARp),
+ register word * LARpp_j_1,
+ register word * LARpp_j,
+ register word * LARp)
+{
+ register int i;
+ register longword ltmp;
+
+ for (i = 1; i <= 8; i++, LARp++, LARpp_j_1++, LARpp_j++) {
+ *LARp = (word) GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
+ *LARp = (word) 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 = (word) 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 = (word) GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
+ *LARp = (word) 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
+ : (word) GSM_ADD( temp >> 2, 26112 )));
+ } else {
+ temp = *LARp;
+ *LARp = (temp < 11059) ? temp << 1
+ : ((temp < 20070) ? temp + 11059
+ : (word) 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 = (word) GSM_MULT_R(rpi, di);
+ sav = (word) GSM_ADD( ui, zzz);
+
+ zzz = (word) GSM_MULT_R(rpi, ui);
+ di = (word) 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 = (word) ( tmp1 == MIN_WORD && tmp2 == MIN_WORD
+ ? MAX_WORD
+ : 0x0FFFF & (( (longword)tmp1 * (longword)tmp2
+ + 16384) >> 15)) ;
+
+ sri = (word) GSM_SUB( sri, tmp2 );
+
+ /* v[i+1] = GSM_ADD( v[i], gsm_mult_r( rrp[i], sri ) );
+ */
+ tmp1 = (word) ( tmp1 == MIN_WORD && sri == MIN_WORD
+ ? MAX_WORD
+ : 0x0FFFF & (( (longword)tmp1 * (longword)sri
+ + 16384) >> 15)) ;
+
+ v[i+1] = (word) 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);
+}
-/*\r
- * table.c\r
- *\r
- * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische\r
- * Universitaet Berlin. See the accompanying file "COPYRIGHT" for\r
- * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\r
- */\r
-\r
-\r
-/* Most of these tables are inlined at their point of use.\r
- */\r
-\r
-/* 4.4 TABLES USED IN THE FIXED POINT IMPLEMENTATION OF THE RPE-LTP\r
- * CODER AND DECODER\r
- *\r
- * (Most of them inlined, so watch out.)\r
- */\r
-\r
-#define GSM_TABLE_C\r
-#include "private.h"\r
-#include "gsm.h"\r
-\r
-/* Table 4.1 Quantization of the Log.-Area Ratios\r
- */\r
-/* i 1 2 3 4 5 6 7 8 */\r
-word gsm_A[8] = {20480, 20480, 20480, 20480, 13964, 15360, 8534, 9036};\r
-word gsm_B[8] = { 0, 0, 2048, -2560, 94, -1792, -341, -1144};\r
-word gsm_MIC[8] = { -32, -32, -16, -16, -8, -8, -4, -4 };\r
-word gsm_MAC[8] = { 31, 31, 15, 15, 7, 7, 3, 3 };\r
-\r
-\r
-/* Table 4.2 Tabulation of 1/A[1..8]\r
- */\r
-word gsm_INVA[8]={ 13107, 13107, 13107, 13107, 19223, 17476, 31454, 29708 };\r
-\r
-\r
-/* Table 4.3a Decision level of the LTP gain quantizer\r
- */\r
-/* bc 0 1 2 3 */\r
-word gsm_DLB[4] = { 6554, 16384, 26214, 32767 };\r
-\r
-\r
-/* Table 4.3b Quantization levels of the LTP gain quantizer\r
- */\r
-/* bc 0 1 2 3 */\r
-word gsm_QLB[4] = { 3277, 11469, 21299, 32767 };\r
-\r
-\r
-/* Table 4.4 Coefficients of the weighting filter\r
- */\r
-/* i 0 1 2 3 4 5 6 7 8 9 10 */\r
-word gsm_H[11] = {-134, -374, 0, 2054, 5741, 8192, 5741, 2054, 0, -374, -134 };\r
-\r
-\r
-/* Table 4.5 Normalized inverse mantissa used to compute xM/xmax \r
- */\r
-/* i 0 1 2 3 4 5 6 7 */\r
-word gsm_NRFAC[8] = { 29128, 26215, 23832, 21846, 20165, 18725, 17476, 16384 };\r
-\r
-\r
-/* Table 4.6 Normalized direct mantissa used to compute xM/xmax\r
- */\r
-/* i 0 1 2 3 4 5 6 7 */\r
-word gsm_FAC[8] = { 18431, 20479, 22527, 24575, 26623, 28671, 30719, 32767 };\r
+/*
+ * table.c
+ *
+ * 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.
+ */
+
+
+/* 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 };
projects / thirdparty / freeswitch.git / commitdiff
