dom mar 16 23:37:23 CET 2003
[asterisk/asterisk.git] / codecs / lpc10 / lpc10.h
1 /*
2
3 $Log$
4 Revision 1.15  2003/03/16 22:37:30  matteo
5 dom mar 16 23:37:23 CET 2003
6
7 Revision 1.1.1.2  2003/03/16 22:37:30  matteo
8 dom mar 16 23:37:23 CET 2003
9
10 Revision 1.2  2003/03/16 16:09:48  markster
11 Mere James's cleanups for fewer build warnings
12
13 Revision 1.1  2000/01/05 00:20:06  markster
14 Add broken lpc10 code...  It's not too far from working I don't think...
15
16  * Revision 1.1  1996/08/19  22:47:31  jaf
17  * Initial revision
18  *
19
20 */
21
22 #ifndef __LPC10_H__
23 #define __LPC10_H__
24
25 #define LPC10_SAMPLES_PER_FRAME 180
26 #define LPC10_BITS_IN_COMPRESSED_FRAME 54
27
28
29 /*
30
31   The "#if defined"'s in this file are by no means intended to be
32   complete.  They are what Nautilus uses, which has been successfully
33   compiled under DOS with the Microsoft C compiler, and under a few
34   versions of Unix with the GNU C compiler.
35
36  */
37
38 #if defined(unix)
39 typedef short           INT16;
40 typedef int             INT32;
41 #endif
42
43
44 #if defined(__MSDOS__) || defined(MSDOS)
45 typedef int             INT16;
46 typedef long            INT32;
47 #endif
48
49
50
51 /* The initial values for every member of this structure is 0, except
52    where noted in comments. */
53
54 /* These two lines are copied from f2c.h.  There should be a more
55    elegant way of doing this than having the same declarations in two
56    files. */
57
58 typedef float real;
59 typedef INT32 integer;
60 typedef INT32 logical;
61 typedef INT16 shortint;
62
63 struct lpc10_encoder_state {
64     /* State used only by function hp100 */
65     real z11;
66     real z21;
67     real z12;
68     real z22;
69     
70     /* State used by function analys */
71     real inbuf[540], pebuf[540];
72     real lpbuf[696], ivbuf[312];
73     real bias;
74     integer osbuf[10];  /* no initial value necessary */
75     integer osptr;     /* initial value 1 */
76     integer obound[3];
77     integer vwin[6]     /* was [2][3] */;   /* initial value vwin[4] = 307; vwin[5] = 462; */
78     integer awin[6]     /* was [2][3] */;   /* initial value awin[4] = 307; awin[5] = 462; */
79     integer voibuf[8]   /* was [2][4] */;
80     real rmsbuf[3];
81     real rcbuf[30]      /* was [10][3] */;
82     real zpre;
83
84
85     /* State used by function onset */
86     real n;
87     real d__;   /* initial value 1.f */
88     real fpc;   /* no initial value necessary */
89     real l2buf[16];
90     real l2sum1;
91     integer l2ptr1;   /* initial value 1 */
92     integer l2ptr2;   /* initial value 9 */
93     integer lasti;    /* no initial value necessary */
94     logical hyst;   /* initial value FALSE_ */
95
96     /* State used by function voicin */
97     real dither;   /* initial value 20.f */
98     real snr;
99     real maxmin;
100     real voice[6]       /* was [2][3] */;   /* initial value is probably unnecessary */
101     integer lbve, lbue, fbve, fbue;
102     integer ofbue, sfbue;
103     integer olbue, slbue;
104     /* Initial values:
105         lbve = 3000;
106         fbve = 3000;
107         fbue = 187;
108         ofbue = 187;
109         sfbue = 187;
110         lbue = 93;
111         olbue = 93;
112         slbue = 93;
113         snr = (real) (fbve / fbue << 6);
114         */
115
116     /* State used by function dyptrk */
117     real s[60];
118     integer p[120]      /* was [60][2] */;
119     integer ipoint;
120     real alphax;
121
122     /* State used by function chanwr */
123     integer isync;
124
125 };
126
127
128 struct lpc10_decoder_state {
129
130     /* State used by function decode */
131     integer iptold;   /* initial value 60 */
132     logical first;   /* initial value TRUE_ */
133     integer ivp2h;
134     integer iovoic;
135     integer iavgp;   /* initial value 60 */
136     integer erate;
137     integer drc[30]     /* was [3][10] */;
138     integer dpit[3];
139     integer drms[3];
140
141     /* State used by function synths */
142     real buf[360];
143     integer buflen;   /* initial value 180 */
144
145     /* State used by function pitsyn */
146     integer ivoico;   /* no initial value necessary as long as first_pitsyn is initially TRUE_ */
147     integer ipito;   /* no initial value necessary as long as first_pitsyn is initially TRUE_ */
148     real rmso;   /* initial value 1.f */
149     real rco[10];   /* no initial value necessary as long as first_pitsyn is initially TRUE_ */
150     integer jsamp;   /* no initial value necessary as long as first_pitsyn is initially TRUE_ */
151     logical first_pitsyn;   /* initial value TRUE_ */
152
153     /* State used by function bsynz */
154     integer ipo;
155     real exc[166];
156     real exc2[166];
157     real lpi1;
158     real lpi2;
159     real lpi3;
160     real hpi1;
161     real hpi2;
162     real hpi3;
163     real rmso_bsynz;
164
165     /* State used by function random */
166     integer j;   /* initial value 2 */
167     integer k;   /* initial value 5 */
168     shortint y[5];  /* initial value { -21161,-8478,30892,-10216,16950 } */
169
170     /* State used by function deemp */
171     real dei1;
172     real dei2;
173     real deo1;
174     real deo2;
175     real deo3;
176
177 };
178
179
180
181 /*
182
183   Calling sequence:
184
185   Call create_lpc10_encoder_state(), which returns a pointer to an
186   already initialized lpc10_encoder_state structure.
187
188   lpc10_encode reads indices 0 through (LPC10_SAMPLES_PER_FRAME-1) of
189   array speech[], and writes indices 0 through
190   (LPC10_BITS_IN_COMPRESSED_FRAME-1) of array bits[], and both reads
191   and writes the lpc10_encoder_state structure contents.  The
192   lpc10_encoder_state structure should *not* be initialized for every
193   frame of encoded speech.  Once at the beginning of execution, done
194   automatically for you by create_lpc10_encoder_state(), is enough.
195
196   init_lpc10_encoder_state() reinitializes the lpc10_encoder_state
197   structure.  This might be useful if you are finished processing one
198   sound sample, and want to reuse the same lpc10_encoder_state
199   structure to process another sound sample.  There might be other
200   uses as well.
201
202   Note that the comments in the lpc10/lpcenc.c file imply that indices
203   1 through 180 of array speech[] are read.  These comments were
204   written for the Fortran version of the code, before it was
205   automatically converted to C by the conversion program f2c.  f2c
206   seems to use the convention that the pointers to arrays passed as
207   function arguments point to the first index used in the Fortran
208   code, whatever index that might be (usually 1), and then it modifies
209   the pointer inside of the function, like so:
210
211   if (speech) {
212       --speech;
213   }
214
215   So that the code can access the first value at index 1 and the last
216   at index 180.  This makes the translated C code "closer" to the
217   original Fortran code.
218
219   The calling sequence for the decoder is similar to the encoder.  The
220   only significant difference is that the array bits[] is read
221   (indices 0 through (LPC10_BITS_IN_COMPRESSED_FRAME-1)), and the
222   array speech[] is written (indices 0 through
223   (LPC10_SAMPLES_PER_FRAME-1)).
224   
225   */
226
227 struct lpc10_encoder_state * create_lpc10_encoder_state (void);
228 void init_lpc10_encoder_state (struct lpc10_encoder_state *st);
229 int lpc10_encode (real *speech, INT32 *bits, struct lpc10_encoder_state *st);
230
231 struct lpc10_decoder_state * create_lpc10_decoder_state (void);
232 void init_lpc10_decoder_state (struct lpc10_decoder_state *st);
233 int lpc10_decode (INT32 *bits, real *speech, struct lpc10_decoder_state *st);
234
235 #endif /* __LPC10_H__ */