Make meetme operate in linear so as to keep alaw folk happy, minor iax2
[asterisk/asterisk.git] / fskmodem.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * FSK Modulator/Demodulator 
5  * 
6  * Copyright (C) 1999, Mark Spencer
7  *
8  * Mark Spencer <markster@linux-support.net>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License.
12  *
13  * Includes code and algorithms from the Zapata library.
14  *
15  */
16
17 #include <asterisk/fskmodem.h>
18
19 #include <stdio.h>
20
21 #define NBW     2
22 #define BWLIST  {75,800}
23 #define NF      4
24 #define FLIST {1400,1800,1200,2200}
25
26 #define STATE_SEARCH_STARTBIT   0
27 #define STATE_SEARCH_STARTBIT2  1
28 #define STATE_SEARCH_STARTBIT3  2
29 #define STATE_GET_BYTE                  3
30
31 static inline float get_sample(short **buffer, int *len)
32 {
33         float retval;
34         retval = (float) **buffer / 256;
35         (*buffer)++;
36         (*len)--;
37         return retval;
38 }
39
40 #define GET_SAMPLE get_sample(&buffer, len)
41
42 /* Coeficientes para filtros de entrada                                 */
43 /* Tabla de coeficientes, generada a partir del programa "mkfilter"     */
44 /* Formato: coef[IDX_FREC][IDX_BW][IDX_COEF]                            */
45 /* IDX_COEF=0   =>      1/GAIN                                          */
46 /* IDX_COEF=1-6 =>      Coeficientes y[n]                               */
47
48 static double coef_in[NF][NBW][8]={
49 #include "coef_in.h"
50 };
51
52 /* Coeficientes para filtro de salida                                   */
53 /* Tabla de coeficientes, generada a partir del programa "mkfilter"     */
54 /* Formato: coef[IDX_BW][IDX_COEF]                                      */
55 /* IDX_COEF=0   =>      1/GAIN                                          */
56 /* IDX_COEF=1-6 =>      Coeficientes y[n]                               */
57
58 static double coef_out[NBW][8]={
59 #include "coef_out.h"
60 };
61
62
63 /* Filtro pasa-banda para frecuencia de MARCA */
64 static inline float filtroM(fsk_data *fskd,float in)
65 {
66         int i,j;
67         double s;
68         double *pc;
69         
70         pc=&coef_in[fskd->f_mark_idx][fskd->bw][0];
71         fskd->fmxv[(fskd->fmp+6)&7]=in*(*pc++);
72         
73         s=(fskd->fmxv[(fskd->fmp+6)&7] - fskd->fmxv[fskd->fmp]) + 3 * (fskd->fmxv[(fskd->fmp+2)&7] - fskd->fmxv[(fskd->fmp+4)&7]);
74         for (i=0,j=fskd->fmp;i<6;i++,j++) s+=fskd->fmyv[j&7]*(*pc++);
75         fskd->fmyv[j&7]=s;
76         fskd->fmp++; fskd->fmp&=7;
77         return s;
78 }
79
80 /* Filtro pasa-banda para frecuencia de ESPACIO */
81 static inline float filtroS(fsk_data *fskd,float in)
82 {
83         int i,j;
84         double s;
85         double *pc;
86         
87         pc=&coef_in[fskd->f_space_idx][fskd->bw][0];
88         fskd->fsxv[(fskd->fsp+6)&7]=in*(*pc++);
89         
90         s=(fskd->fsxv[(fskd->fsp+6)&7] - fskd->fsxv[fskd->fsp]) + 3 * (fskd->fsxv[(fskd->fsp+2)&7] - fskd->fsxv[(fskd->fsp+4)&7]);
91         for (i=0,j=fskd->fsp;i<6;i++,j++) s+=fskd->fsyv[j&7]*(*pc++);
92         fskd->fsyv[j&7]=s;
93         fskd->fsp++; fskd->fsp&=7;
94         return s;
95 }
96
97 /* Filtro pasa-bajos para datos demodulados */
98 static inline float filtroL(fsk_data *fskd,float in)
99 {
100         int i,j;
101         double s;
102         double *pc;
103         
104         pc=&coef_out[fskd->bw][0];
105         fskd->flxv[(fskd->flp + 6) & 7]=in * (*pc++); 
106         
107         s=     (fskd->flxv[fskd->flp]       + fskd->flxv[(fskd->flp+6)&7]) +
108           6  * (fskd->flxv[(fskd->flp+1)&7] + fskd->flxv[(fskd->flp+5)&7]) +
109           15 * (fskd->flxv[(fskd->flp+2)&7] + fskd->flxv[(fskd->flp+4)&7]) +
110           20 *  fskd->flxv[(fskd->flp+3)&7]; 
111         
112         for (i=0,j=fskd->flp;i<6;i++,j++) s+=fskd->flyv[j&7]*(*pc++);
113         fskd->flyv[j&7]=s;
114         fskd->flp++; fskd->flp&=7;
115         return s;
116 }
117
118 static inline int demodulador(fsk_data *fskd, float *retval, float x)
119 {
120         float xS,xM;
121
122         fskd->cola_in[fskd->pcola]=x;
123         
124         xS=filtroS(fskd,x);
125         xM=filtroM(fskd,x);
126
127         fskd->cola_filtro[fskd->pcola]=xM-xS;
128
129         x=filtroL(fskd,xM*xM - xS*xS);
130         
131         fskd->cola_demod[fskd->pcola++]=x;
132         fskd->pcola &= (NCOLA-1);
133
134         *retval = x;
135         return(0);
136 }
137
138 static int get_bit_raw(fsk_data *fskd, short *buffer, int *len)
139 {
140         /* Esta funcion implementa un DPLL para sincronizarse con los bits */
141         float x,spb,spb2,ds;
142         int f;
143
144         spb=fskd->spb; 
145         if (fskd->spb == 7) spb = 8000.0 / 1200.0;
146         ds=spb/32.;
147         spb2=spb/2.;
148
149         for (f=0;;){
150                 if (demodulador(fskd,&x, GET_SAMPLE)) return(-1);
151                 if ((x*fskd->x0)<0) {   /* Transicion */
152                         if (!f) {
153                                 if (fskd->cont<(spb2)) fskd->cont+=ds; else fskd->cont-=ds;
154                                 f=1;
155                         }
156                 }
157                 fskd->x0=x;
158                 fskd->cont+=1.;
159                 if (fskd->cont>spb) {
160                         fskd->cont-=spb;
161                         break;
162                 }
163         }
164         f=(x>0)?0x80:0;
165         return(f);
166 }
167
168 int fsk_serie(fsk_data *fskd, short *buffer, int *len, int *outbyte)
169 {
170         int a;
171         int i,j,n1,r;
172         int samples=0;
173         int olen;
174         switch(fskd->state) {
175                 /* Pick up where we left off */
176         case STATE_SEARCH_STARTBIT2:
177                 goto search_startbit2;
178         case STATE_SEARCH_STARTBIT3:
179                 goto search_startbit3;
180         case STATE_GET_BYTE:
181                 goto getbyte;
182         }
183         /* Esperamos bit de start       */
184         do {
185 /* this was jesus's nice, reasonable, working (at least with RTTY) code
186 to look for the beginning of the start bit. Unfortunately, since TTY/TDD's
187 just start sending a start bit with nothing preceding it at the beginning
188 of a transmission (what a LOSING design), we cant do it this elegantly */
189 /*
190                 if (demodulador(zap,&x1)) return(-1);
191                 for(;;) {
192                         if (demodulador(zap,&x2)) return(-1);
193                         if (x1>0 && x2<0) break;
194                         x1=x2;
195                 }
196 */
197 /* this is now the imprecise, losing, but functional code to detect the
198 beginning of a start bit in the TDD sceanario. It just looks for sufficient
199 level to maybe, perhaps, guess, maybe that its maybe the beginning of
200 a start bit, perhaps. This whole thing stinks! */
201                 if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1);
202                 samples++;
203                 for(;;)
204                    {
205 search_startbit2:                  
206                         if (!*len) {
207                                 fskd->state = STATE_SEARCH_STARTBIT2;
208                                 return 0;
209                         }
210                         samples++;
211                         if (demodulador(fskd,&fskd->x2,GET_SAMPLE)) return(-1);
212 #if 0
213                         printf("x2 = %5.5f ", fskd->x2);
214 #endif                  
215                         if (fskd->x2 < -0.5) break; 
216                    }
217 search_startbit3:                  
218                 /* Esperamos 0.5 bits antes de usar DPLL */
219                 i=fskd->spb/2;
220                 if (*len < i) {
221                         fskd->state = STATE_SEARCH_STARTBIT3;
222                         return 0;
223                 }
224                 for(;i;i--) { if (demodulador(fskd,&fskd->x1,GET_SAMPLE)) return(-1); 
225 #if 0
226                         printf("x1 = %5.5f ", fskd->x1);
227 #endif                  
228         samples++; }
229
230                 /* x1 debe ser negativo (confirmaciĆ³n del bit de start) */
231
232         } while (fskd->x1>0);
233         fskd->state = STATE_GET_BYTE;
234
235 getbyte:
236
237         /* Need at least 80 samples (for 1200) or
238                 1320 (for 45.5) to be sure we'll have a byte */
239         if (fskd->nbit < 8) {
240                 if (*len < 1320)
241                         return 0;
242         } else {
243                 if (*len < 80)
244                         return 0;
245         }
246         /* Leemos ahora los bits de datos */
247         j=fskd->nbit;
248         for (a=n1=0;j;j--) {
249                 olen = *len;
250                 i=get_bit_raw(fskd, buffer, len);
251                 buffer += (olen - *len);
252                 if (i == -1) return(-1);
253                 if (i) n1++;
254                 a>>=1; a|=i;
255         }
256         j=8-fskd->nbit;
257         a>>=j;
258
259         /* Leemos bit de paridad (si existe) y la comprobamos */
260         if (fskd->paridad) {
261                 olen = *len;
262                 i=get_bit_raw(fskd, buffer, len); 
263                 buffer += (olen - *len);
264                 if (i == -1) return(-1);
265                 if (i) n1++;
266                 if (fskd->paridad==1) { /* paridad=1 (par) */
267                         if (n1&1) a|=0x100;             /* error */
268                 } else {                        /* paridad=2 (impar) */
269                         if (!(n1&1)) a|=0x100;  /* error */
270                 }
271         }
272         
273         /* Leemos bits de STOP. Todos deben ser 1 */
274         
275         for (j=fskd->nstop;j;j--) {
276                 r = get_bit_raw(fskd, buffer, len);
277                 if (r == -1) return(-1);
278                 if (!r) a|=0x200;
279         }
280
281         /* Por fin retornamos  */
282         /* Bit 8 : Error de paridad */
283         /* Bit 9 : Error de Framming */
284
285         *outbyte = a;
286         fskd->state = STATE_SEARCH_STARTBIT;
287         return 1;
288 }