Version 0.3.0 from FTP
[asterisk/asterisk.git] / formats / format_vox.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Flat, binary, ADPCM vox file format.
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  
14 #include <asterisk/lock.h>
15 #include <asterisk/channel.h>
16 #include <asterisk/file.h>
17 #include <asterisk/logger.h>
18 #include <asterisk/sched.h>
19 #include <asterisk/module.h>
20 #include <arpa/inet.h>
21 #include <stdlib.h>
22 #include <sys/time.h>
23 #include <stdio.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <string.h>
27 #include <pthread.h>
28 #include <endian.h>
29
30 #define BUF_SIZE 80             /* 160 samples */
31
32 struct ast_filestream {
33         void *reserved[AST_RESERVED_POINTERS];
34         /* Believe it or not, we must decode/recode to account for the
35            weird MS format */
36         /* This is what a filestream means to us */
37         int fd; /* Descriptor */
38         struct ast_channel *owner;
39         struct ast_frame fr;                            /* Frame information */
40         char waste[AST_FRIENDLY_OFFSET];        /* Buffer for sending frames, etc */
41         char empty;                                                     /* Empty character */
42         unsigned char buf[BUF_SIZE + 3];                                /* Output Buffer */
43         int lasttimeout;
44         struct timeval last;
45         int adj;
46         short signal;                                           /* Signal level (file side) */
47         short ssindex;                                          /* Signal ssindex (file side) */
48         struct ast_filestream *next;
49 };
50
51
52 static struct ast_filestream *glist = NULL;
53 static pthread_mutex_t vox_lock = AST_MUTEX_INITIALIZER;
54 static int glistcnt = 0;
55
56 static char *name = "vox";
57 static char *desc = "Dialogic VOX (ADPCM) File Format";
58 static char *exts = "vox";
59
60 /*
61  * Step size index shift table 
62  */
63
64 static short indsft[8] = { -1, -1, -1, -1, 2, 4, 6, 8 };
65
66 /*
67  * Step size table, where stpsz[i]=floor[16*(11/10)^i]
68  */
69
70 static short stpsz[49] = {
71   16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73,
72   80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279,
73   307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963,
74   1060, 1166, 1282, 1411, 1552
75 };
76
77 /* 
78  * Nibble to bit map
79  */
80
81 static short nbl2bit[16][4] = {
82   {1, 0, 0, 0}, {1, 0, 0, 1}, {1, 0, 1, 0}, {1, 0, 1, 1},
83   {1, 1, 0, 0}, {1, 1, 0, 1}, {1, 1, 1, 0}, {1, 1, 1, 1},
84   {-1, 0, 0, 0}, {-1, 0, 0, 1}, {-1, 0, 1, 0}, {-1, 0, 1, 1},
85   {-1, 1, 0, 0}, {-1, 1, 0, 1}, {-1, 1, 1, 0}, {-1, 1, 1, 1}
86 };
87
88 /*
89  * Decode(encoded)
90  *  Decodes the encoded nibble from the adpcm file.
91  *
92  * Results:
93  *  Returns the encoded difference.
94  *
95  * Side effects:
96  *  Sets the index to the step size table for the next encode.
97  */
98
99 static inline short
100 decode (unsigned char encoded, short *ssindex)
101 {
102   short diff, step;
103   step = stpsz[*ssindex];
104   diff = nbl2bit[encoded][0] * (step * nbl2bit[encoded][1] +
105                                 (step >> 1) * nbl2bit[encoded][2] +
106                                 (step >> 2) * nbl2bit[encoded][3] +
107                                 (step >> 3));
108   *ssindex = *ssindex + indsft[(encoded & 7)];
109   if (*ssindex < 0)
110     *ssindex = 0;
111   else if (*ssindex > 48)
112     *ssindex = 48;
113   return (diff);
114 }
115
116 /*
117  * Adpcm
118  *  Takes a signed linear signal and encodes it as ADPCM
119  *  For more information see http://support.dialogic.com/appnotes/adpcm.pdf
120  *
121  * Results:
122  *  Foo.
123  *
124  * Side effects:
125  *  signal gets updated with each pass.
126  */
127
128 static inline unsigned char
129 adpcm (short csig, short *ssindex, short *signal)
130 {
131   short diff, step;
132   unsigned char encoded;
133   step = stpsz[*ssindex];
134   /* 
135    * Clip csig if too large or too small
136    */
137    
138   csig >>= 4;
139
140   diff = csig - *signal;
141   
142   if (diff < 0)
143     {
144       encoded = 8;
145       diff = -diff;
146     }
147   else
148     encoded = 0;
149   if (diff >= step)
150     {
151       encoded |= 4;
152       diff -= step;
153     }
154   step >>= 1;
155   if (diff >= step)
156     {
157       encoded |= 2;
158       diff -= step;
159     }
160   step >>= 1;
161   if (diff >= step)
162     encoded |= 1;
163     
164   *signal += decode (encoded, ssindex);
165   return (encoded);
166 }
167
168 static struct ast_filestream *vox_open(int fd)
169 {
170         /* We don't have any header to read or anything really, but
171            if we did, it would go here.  We also might want to check
172            and be sure it's a valid file.  */
173         struct ast_filestream *tmp;
174         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
175                 memset(tmp, 0, sizeof(struct ast_filestream));
176                 if (ast_pthread_mutex_lock(&vox_lock)) {
177                         ast_log(LOG_WARNING, "Unable to lock vox list\n");
178                         free(tmp);
179                         return NULL;
180                 }
181                 tmp->next = glist;
182                 glist = tmp;
183                 tmp->fd = fd;
184                 tmp->owner = NULL;
185                 tmp->fr.data = tmp->buf;
186                 tmp->fr.frametype = AST_FRAME_VOICE;
187                 tmp->fr.subclass = AST_FORMAT_ADPCM;
188                 /* datalen will vary for each frame */
189                 tmp->fr.src = name;
190                 tmp->fr.mallocd = 0;
191                 tmp->lasttimeout = -1;
192                 glistcnt++;
193                 ast_pthread_mutex_unlock(&vox_lock);
194                 ast_update_use_count();
195         }
196         return tmp;
197 }
198
199 static struct ast_filestream *vox_rewrite(int fd, char *comment)
200 {
201         /* We don't have any header to read or anything really, but
202            if we did, it would go here.  We also might want to check
203            and be sure it's a valid file.  */
204         struct ast_filestream *tmp;
205         if ((tmp = malloc(sizeof(struct ast_filestream)))) {
206                 memset(tmp, 0, sizeof(struct ast_filestream));
207                 if (ast_pthread_mutex_lock(&vox_lock)) {
208                         ast_log(LOG_WARNING, "Unable to lock vox list\n");
209                         free(tmp);
210                         return NULL;
211                 }
212                 tmp->next = glist;
213                 glist = tmp;
214                 tmp->fd = fd;
215                 tmp->owner = NULL;
216                 tmp->lasttimeout = -1;
217                 glistcnt++;
218                 ast_pthread_mutex_unlock(&vox_lock);
219                 ast_update_use_count();
220         } else
221                 ast_log(LOG_WARNING, "Out of memory\n");
222         return tmp;
223 }
224
225 static struct ast_frame *vox_read(struct ast_filestream *s)
226 {
227         return NULL;
228 }
229
230 static void vox_close(struct ast_filestream *s)
231 {
232         struct ast_filestream *tmp, *tmpl = NULL;
233         if (ast_pthread_mutex_lock(&vox_lock)) {
234                 ast_log(LOG_WARNING, "Unable to lock vox list\n");
235                 return;
236         }
237         tmp = glist;
238         while(tmp) {
239                 if (tmp == s) {
240                         if (tmpl)
241                                 tmpl->next = tmp->next;
242                         else
243                                 glist = tmp->next;
244                         break;
245                 }
246                 tmpl = tmp;
247                 tmp = tmp->next;
248         }
249         glistcnt--;
250         if (s->owner) {
251                 s->owner->stream = NULL;
252                 if (s->owner->streamid > -1)
253                         ast_sched_del(s->owner->sched, s->owner->streamid);
254                 s->owner->streamid = -1;
255         }
256         ast_pthread_mutex_unlock(&vox_lock);
257         ast_update_use_count();
258         if (!tmp) 
259                 ast_log(LOG_WARNING, "Freeing a filestream we don't seem to own\n");
260         close(s->fd);
261         free(s);
262         s = NULL;
263 }
264
265 static int ast_read_callback(void *data)
266 {
267         int retval = 0;
268         int res;
269         int delay;
270         struct ast_filestream *s = data;
271         struct timeval tv;
272         int x;
273         /* Send a frame from the file to the appropriate channel */
274
275         s->fr.frametype = AST_FRAME_VOICE;
276         s->fr.subclass = AST_FORMAT_ADPCM;
277         s->fr.offset = AST_FRIENDLY_OFFSET;
278         s->fr.mallocd = 0;
279         s->fr.data = s->buf;
280         if ((res = read(s->fd, s->buf + 3, BUF_SIZE)) < 1) {
281                 if (res)
282                         ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
283                 s->owner->streamid = -1;
284                 return 0;
285         }
286         /* Store index, then signal */
287         s->buf[0] = s->ssindex & 0xff;
288         s->buf[1] = (s->signal >> 8) & 0xff;
289         s->buf[2] = s->signal & 0xff;
290         /* Do the decoder to be sure we get the right stuff in the signal and index fields. */
291         for (x=3;x<res+3;x++) {
292                 s->signal += decode(s->buf[x] >> 4, &s->ssindex);
293                 s->signal += decode(s->buf[x] & 0xf, &s->ssindex);
294         }
295         s->fr.samples = res * 2;
296         s->fr.datalen = res + 3;
297         delay = s->fr.samples / 8;
298         /* Lastly, process the frame */
299         if (ast_write(s->owner, &s->fr)) {
300                 ast_log(LOG_WARNING, "Failed to write frame\n");
301                 s->owner->streamid = -1;
302                 return 0;
303         }
304         if (s->last.tv_usec || s->last.tv_usec) {
305                 int ms;
306                 gettimeofday(&tv, NULL);
307                 ms = 1000 * (tv.tv_sec - s->last.tv_sec) + 
308                         (tv.tv_usec - s->last.tv_usec) / 1000;
309                 s->last.tv_sec = tv.tv_sec;
310                 s->last.tv_usec = tv.tv_usec;
311                 if ((ms - delay) * (ms - delay) > 4) {
312                         /* Compensate if we're more than 2 ms off */
313                         s->adj -= (ms - delay);
314                 }
315 #if 0
316                 fprintf(stdout, "Delay is %d, adjustment is %d, last was %d\n", delay, s->adj, ms);
317 #endif
318                 delay += s->adj;
319                 if (delay < 1)
320                         delay = 1;
321         } else
322                 gettimeofday(&s->last, NULL);
323         if (s->lasttimeout != delay) {
324                 /* We'll install the next timeout now. */
325                 s->owner->streamid = ast_sched_add(s->owner->sched,
326                                 delay, ast_read_callback, s); 
327                 s->lasttimeout = delay;
328         } else {
329                 /* Just come back again at the same time */
330                 retval = -1;
331         }
332         return retval;
333 }
334
335 static int vox_apply(struct ast_channel *c, struct ast_filestream *s)
336 {
337         /* Select our owner for this stream, and get the ball rolling. */
338         s->owner = c;
339         return 0;
340 }
341
342 static int vox_play(struct ast_filestream *s)
343 {
344         ast_read_callback(s);
345         return 0;
346 }
347
348 static int vox_write(struct ast_filestream *fs, struct ast_frame *f)
349 {
350         int res;
351         if (f->frametype != AST_FRAME_VOICE) {
352                 ast_log(LOG_WARNING, "Asked to write non-voice frame!\n");
353                 return -1;
354         }
355         if (f->subclass != AST_FORMAT_ADPCM) {
356                 ast_log(LOG_WARNING, "Asked to write non-ADPCM frame (%d)!\n", f->subclass);
357                 return -1;
358         }
359         if (f->datalen < 3) {
360                 ast_log(LOG_WARNING, "Invalid frame of data (< 3 bytes long) from %s\n", f->src);
361                 return -1;
362         }
363         if ((res = write(fs->fd, f->data + 3, f->datalen)) != f->datalen) {
364                         ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
365                         return -1;
366         }
367         return 0;
368 }
369
370 static char *vox_getcomment(struct ast_filestream *s)
371 {
372         return NULL;
373 }
374
375 static int vox_seek(struct ast_filestream *fs, long sample_offset, int whence)
376 {
377         return -1;
378 }
379
380 static int vox_trunc(struct ast_filestream *fs)
381 {
382         return -1;
383 }
384
385 static long vox_tell(struct ast_filestream *fs)
386 {
387         return -1;
388 }
389
390 int load_module()
391 {
392         return ast_format_register(name, exts, AST_FORMAT_ADPCM,
393                                                                 vox_open,
394                                                                 vox_rewrite,
395                                                                 vox_apply,
396                                                                 vox_play,
397                                                                 vox_write,
398                                                                 vox_seek,
399                                                                 vox_trunc,
400                                                                 vox_tell,
401                                                                 vox_read,
402                                                                 vox_close,
403                                                                 vox_getcomment);
404                                                                 
405                                                                 
406 }
407
408 int unload_module()
409 {
410         struct ast_filestream *tmp, *tmpl;
411         if (ast_pthread_mutex_lock(&vox_lock)) {
412                 ast_log(LOG_WARNING, "Unable to lock vox list\n");
413                 return -1;
414         }
415         tmp = glist;
416         while(tmp) {
417                 if (tmp->owner)
418                         ast_softhangup(tmp->owner, AST_SOFTHANGUP_APPUNLOAD);
419                 tmpl = tmp;
420                 tmp = tmp->next;
421                 free(tmpl);
422         }
423         ast_pthread_mutex_unlock(&vox_lock);
424         return ast_format_unregister(name);
425 }       
426
427 int usecount()
428 {
429         int res;
430         if (ast_pthread_mutex_lock(&vox_lock)) {
431                 ast_log(LOG_WARNING, "Unable to lock vox list\n");
432                 return -1;
433         }
434         res = glistcnt;
435         ast_pthread_mutex_unlock(&vox_lock);
436         return res;
437 }
438
439 char *description()
440 {
441         return desc;
442 }
443
444
445 char *key()
446 {
447         return ASTERISK_GPL_KEY;
448 }