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