Make sure other drivers also zero delivery (thanks to steven davies)
[asterisk/asterisk.git] / channels / chan_alsa.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Copyright (C) 2002, Linux Support Services
5  *
6  * By Matthew Fredrickson <creslin@linux-support.net>
7  *
8  * This program is free software, distributed under the terms of
9  * the GNU General Public License
10  */
11
12 #include <asterisk/frame.h>
13 #include <asterisk/logger.h>
14 #include <asterisk/channel.h>
15 #include <asterisk/module.h>
16 #include <asterisk/channel_pvt.h>
17 #include <asterisk/options.h>
18 #include <asterisk/pbx.h>
19 #include <asterisk/config.h>
20 #include <asterisk/cli.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <errno.h>
24 #include <sys/ioctl.h>
25 #include <sys/time.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29
30 #define ALSA_PCM_NEW_HW_PARAMS_API
31 #define ALSA_PCM_NEW_SW_PARAMS_API
32 #include <alsa/asoundlib.h>
33
34 #include "busy.h"
35 #include "ringtone.h"
36 #include "ring10.h"
37 #include "answer.h"
38
39 #ifdef ALSA_MONITOR
40 #include "alsa-monitor.h"
41 #endif
42
43 #define DEBUG 0
44 /* Which device to use */
45 #define ALSA_INDEV "default"
46 #define ALSA_OUTDEV "default"
47 #define DESIRED_RATE 8000
48
49 /* Lets use 160 sample frames, just like GSM.  */
50 #define FRAME_SIZE 160
51 #define PERIOD_FRAMES 80 /* 80 Frames, at 2 bytes each */
52
53 /* When you set the frame size, you have to come up with
54    the right buffer format as well. */
55 /* 5 64-byte frames = one frame */
56 #define BUFFER_FMT ((buffersize * 10) << 16) | (0x0006);
57
58 /* Don't switch between read/write modes faster than every 300 ms */
59 #define MIN_SWITCH_TIME 600
60
61 static snd_pcm_format_t format = SND_PCM_FORMAT_S16_LE;
62 //static int block = O_NONBLOCK;
63 static char indevname[50] = ALSA_INDEV;
64 static char outdevname[50] = ALSA_OUTDEV;
65
66 #if 0
67 static struct timeval lasttime;
68 #endif
69
70 static int usecnt;
71 static int needanswer = 0;
72 static int needringing = 0;
73 static int needhangup = 0;
74 static int silencesuppression = 0;
75 static int silencethreshold = 1000;
76
77 static char digits[80] = "";
78 static char text2send[80] = "";
79
80 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
81
82 static char *type = "Console";
83 static char *desc = "ALSA Console Channel Driver";
84 static char *tdesc = "ALSA Console Channel Driver";
85 static char *config = "alsa.conf";
86
87 static char context[AST_MAX_EXTENSION] = "default";
88 static char language[MAX_LANGUAGE] = "";
89 static char exten[AST_MAX_EXTENSION] = "s";
90
91 /* Command pipe */
92 static int cmd[2];
93
94 int hookstate=0;
95
96 static short silence[FRAME_SIZE] = {0, };
97
98 struct sound {
99         int ind;
100         short *data;
101         int datalen;
102         int samplen;
103         int silencelen;
104         int repeat;
105 };
106
107 static struct sound sounds[] = {
108         { AST_CONTROL_RINGING, ringtone, sizeof(ringtone)/2, 16000, 32000, 1 },
109         { AST_CONTROL_BUSY, busy, sizeof(busy)/2, 4000, 4000, 1 },
110         { AST_CONTROL_CONGESTION, busy, sizeof(busy)/2, 2000, 2000, 1 },
111         { AST_CONTROL_RING, ring10, sizeof(ring10)/2, 16000, 32000, 1 },
112         { AST_CONTROL_ANSWER, answer, sizeof(answer)/2, 2200, 0, 0 },
113 };
114
115 /* Sound command pipe */
116 static int sndcmd[2];
117
118 static struct chan_alsa_pvt {
119         /* We only have one ALSA structure -- near sighted perhaps, but it
120            keeps this driver as simple as possible -- as it should be. */
121         struct ast_channel *owner;
122         char exten[AST_MAX_EXTENSION];
123         char context[AST_MAX_EXTENSION];
124 #if 0
125         snd_pcm_t *card;
126 #endif
127         snd_pcm_t *icard, *ocard;
128         
129 } alsa;
130
131 #if 0
132 static int time_has_passed(void)
133 {
134         struct timeval tv;
135         int ms;
136         gettimeofday(&tv, NULL);
137         ms = (tv.tv_sec - lasttime.tv_sec) * 1000 +
138                         (tv.tv_usec - lasttime.tv_usec) / 1000;
139         if (ms > MIN_SWITCH_TIME)
140                 return -1;
141         return 0;
142 }
143 #endif
144
145 /* Number of buffers...  Each is FRAMESIZE/8 ms long.  For example
146    with 160 sample frames, and a buffer size of 3, we have a 60ms buffer, 
147    usually plenty. */
148
149 pthread_t sthread;
150
151 #define MAX_BUFFER_SIZE 100
152 //static int buffersize = 3;
153
154 //static int full_duplex = 0;
155
156 /* Are we reading or writing (simulated full duplex) */
157 //static int readmode = 1;
158
159 /* File descriptors for sound device */
160 static int readdev = -1;
161 static int writedev = -1;
162
163 static int autoanswer = 1;
164
165 #if 0 
166 static int calc_loudness(short *frame)
167 {
168         int sum = 0;
169         int x;
170         for (x=0;x<FRAME_SIZE;x++) {
171                 if (frame[x] < 0)
172                         sum -= frame[x];
173                 else
174                         sum += frame[x];
175         }
176         sum = sum/FRAME_SIZE;
177         return sum;
178 }
179 #endif
180
181 static int cursound = -1;
182 static int sampsent = 0;
183 static int silencelen=0;
184 static int offset=0;
185 static int nosound=0;
186
187 static int send_sound(void)
188 {
189         short myframe[FRAME_SIZE];
190         int total = FRAME_SIZE;
191         short *frame = NULL;
192         int amt=0;
193         int res;
194         int myoff;
195         snd_pcm_state_t state;
196
197         if (cursound > -1) {
198                 res = total;
199                 if (sampsent < sounds[cursound].samplen) {
200                         myoff=0;
201                         while(total) {
202                                 amt = total;
203                                 if (amt > (sounds[cursound].datalen - offset)) 
204                                         amt = sounds[cursound].datalen - offset;
205                                 memcpy(myframe + myoff, sounds[cursound].data + offset, amt * 2);
206                                 total -= amt;
207                                 offset += amt;
208                                 sampsent += amt;
209                                 myoff += amt;
210                                 if (offset >= sounds[cursound].datalen)
211                                         offset = 0;
212                         }
213                         /* Set it up for silence */
214                         if (sampsent >= sounds[cursound].samplen) 
215                                 silencelen = sounds[cursound].silencelen;
216                         frame = myframe;
217                 } else {
218                         if (silencelen > 0) {
219                                 frame = silence;
220                                 silencelen -= res;
221                         } else {
222                                 if (sounds[cursound].repeat) {
223                                         /* Start over */
224                                         sampsent = 0;
225                                         offset = 0;
226                                 } else {
227                                         cursound = -1;
228                                         nosound = 0;
229                                 }
230                         return 0;
231                         }
232                 }
233                 
234                 if (res == 0 || !frame) {
235                         return 0;
236                 }
237 #ifdef ALSA_MONITOR
238                 alsa_monitor_write((char *)frame, res * 2);
239 #endif          
240                 state = snd_pcm_state(alsa.ocard);
241                 if (state == SND_PCM_STATE_XRUN) {
242                         snd_pcm_prepare(alsa.ocard);
243                 }
244                 res = snd_pcm_writei(alsa.ocard, frame, res);
245                 if (res > 0)
246                         return 0;
247                 return 0;
248         }
249         return 0;
250 }
251
252 static void *sound_thread(void *unused)
253 {
254         fd_set rfds;
255         fd_set wfds;
256         int max;
257         int res;
258         for(;;) {
259                 FD_ZERO(&rfds);
260                 FD_ZERO(&wfds);
261                 max = sndcmd[0];
262                 FD_SET(sndcmd[0], &rfds);
263                 if (cursound > -1) {
264                         FD_SET(writedev, &wfds);
265                         if (writedev > max)
266                                 max = writedev;
267                 }
268 #ifdef ALSA_MONITOR
269                 if (!alsa.owner) {
270                         FD_SET(readdev, &rfds);
271                         if (readdev > max)
272                                 max = readdev;
273                 }
274 #endif
275                 res = ast_select(max + 1, &rfds, &wfds, NULL, NULL);
276                 if (res < 1) {
277                         ast_log(LOG_WARNING, "select failed: %s\n", strerror(errno));
278                         continue;
279                 }
280 #ifdef ALSA_MONITOR
281                 if (FD_ISSET(readdev, &rfds)) {
282                         /* Keep the pipe going with read audio */
283                         snd_pcm_state_t state;
284                         short buf[FRAME_SIZE];
285                         int r;
286                         
287                         state = snd_pcm_state(alsa.ocard);
288                         if (state == SND_PCM_STATE_XRUN) {
289                                 snd_pcm_prepare(alsa.ocard);
290                         }
291                         r = snd_pcm_readi(alsa.icard, buf, FRAME_SIZE);
292                         if (r == -EPIPE) {
293 #if DEBUG
294                                 ast_log(LOG_ERROR, "XRUN read\n");
295 #endif
296                                 snd_pcm_prepare(alsa.icard);
297                         } else if (r == -ESTRPIPE) {
298                                 ast_log(LOG_ERROR, "-ESTRPIPE\n");
299                                 snd_pcm_prepare(alsa.icard);
300                         } else if (r < 0) {
301                                 ast_log(LOG_ERROR, "Read error: %s\n", snd_strerror(r));
302                         } else
303                                 alsa_monitor_read((char *)buf, r * 2);
304                 }               
305 #endif          
306                 if (FD_ISSET(sndcmd[0], &rfds)) {
307                         read(sndcmd[0], &cursound, sizeof(cursound));
308                         silencelen = 0;
309                         offset = 0;
310                         sampsent = 0;
311                 }
312                 if (FD_ISSET(writedev, &wfds))
313                         if (send_sound())
314                                 ast_log(LOG_WARNING, "Failed to write sound\n");
315         }
316         /* Never reached */
317         return NULL;
318 }
319
320 static snd_pcm_t *alsa_card_init(char *dev, snd_pcm_stream_t stream)
321 {
322         int err;
323         int direction;
324         snd_pcm_t *handle = NULL;
325         snd_pcm_hw_params_t *hwparams = NULL;
326         snd_pcm_sw_params_t *swparams = NULL;
327         struct pollfd pfd;
328         snd_pcm_uframes_t period_size = PERIOD_FRAMES * 4;
329         //int period_bytes = 0;
330         snd_pcm_uframes_t buffer_size = 0;
331
332         unsigned int rate = DESIRED_RATE;
333         unsigned int per_min = 1;
334         //unsigned int per_max = 8;
335         snd_pcm_uframes_t start_threshold, stop_threshold;
336
337         err = snd_pcm_open(&handle, dev, stream, O_NONBLOCK);
338         if (err < 0) {
339                 ast_log(LOG_ERROR, "snd_pcm_open failed: %s\n", snd_strerror(err));
340                 return NULL;
341         } else {
342                 ast_log(LOG_DEBUG, "Opening device %s in %s mode\n", dev, (stream == SND_PCM_STREAM_CAPTURE) ? "read" : "write");
343         }
344
345         snd_pcm_hw_params_alloca(&hwparams);
346         snd_pcm_hw_params_any(handle, hwparams);
347
348         err = snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
349         if (err < 0) {
350                 ast_log(LOG_ERROR, "set_access failed: %s\n", snd_strerror(err));
351         }
352
353         err = snd_pcm_hw_params_set_format(handle, hwparams, format);
354         if (err < 0) {
355                 ast_log(LOG_ERROR, "set_format failed: %s\n", snd_strerror(err));
356         }
357
358         err = snd_pcm_hw_params_set_channels(handle, hwparams, 1);
359         if (err < 0) {
360                 ast_log(LOG_ERROR, "set_channels failed: %s\n", snd_strerror(err));
361         }
362
363         direction = 0;
364         err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &rate, &direction);
365         if (rate != DESIRED_RATE) {
366                 ast_log(LOG_WARNING, "Rate not correct, requested %d, got %d\n", DESIRED_RATE, rate);
367         }
368
369         direction = 0;
370         err = snd_pcm_hw_params_set_period_size_near(handle, hwparams, &period_size, &direction);
371         if (err < 0) {
372                 ast_log(LOG_ERROR, "period_size(%ld frames) is bad: %s\n", period_size, snd_strerror(err));
373         } else {
374                 ast_log(LOG_DEBUG, "Period size is %d\n", err);
375         }
376
377         buffer_size = 4096 * 2; //period_size * 16;
378         err = snd_pcm_hw_params_set_buffer_size_near(handle, hwparams, &buffer_size);
379         if (err < 0) {
380                 ast_log(LOG_WARNING, "Problem setting buffer size of %ld: %s\n", buffer_size, snd_strerror(err));
381         } else {
382                 ast_log(LOG_DEBUG, "Buffer size is set to %d frames\n", err);
383         }
384
385 #if 0
386         direction = 0;
387         err = snd_pcm_hw_params_set_periods_min(handle, hwparams, &per_min, &direction);
388         if (err < 0) {
389                 ast_log(LOG_ERROR, "periods_min: %s\n", snd_strerror(err));
390         }
391
392         err = snd_pcm_hw_params_set_periods_max(handle, hwparams, &per_max, 0);
393         if (err < 0) {
394                 ast_log(LOG_ERROR, "periods_max: %s\n", snd_strerror(err));
395         }
396 #endif
397
398         err = snd_pcm_hw_params(handle, hwparams);
399         if (err < 0) {
400                 ast_log(LOG_ERROR, "Couldn't set the new hw params: %s\n", snd_strerror(err));
401         }
402
403         snd_pcm_sw_params_alloca(&swparams);
404         snd_pcm_sw_params_current(handle, swparams);
405
406 #if 1
407         if (stream == SND_PCM_STREAM_PLAYBACK) {
408                 start_threshold = period_size;
409         } else {
410                 start_threshold = 1;
411         }
412
413         err = snd_pcm_sw_params_set_start_threshold(handle, swparams, start_threshold);
414         if (err < 0) {
415                 ast_log(LOG_ERROR, "start threshold: %s\n", snd_strerror(err));
416         }
417 #endif
418
419 #if 1
420         if (stream == SND_PCM_STREAM_PLAYBACK) {
421                 stop_threshold = buffer_size;
422         } else {
423                 stop_threshold = buffer_size;
424         }
425         err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, stop_threshold);
426         if (err < 0) {
427                 ast_log(LOG_ERROR, "stop threshold: %s\n", snd_strerror(err));
428         }
429 #endif
430 #if 0
431         err = snd_pcm_sw_params_set_xfer_align(handle, swparams, PERIOD_FRAMES);
432         if (err < 0) {
433                 ast_log(LOG_ERROR, "Unable to set xfer alignment: %s\n", snd_strerror(err));
434         }
435 #endif
436
437 #if 0
438         err = snd_pcm_sw_params_set_silence_threshold(handle, swparams, silencethreshold);
439         if (err < 0) {
440                 ast_log(LOG_ERROR, "Unable to set silence threshold: %s\n", snd_strerror(err));
441         }
442 #endif
443         err = snd_pcm_sw_params(handle, swparams);
444         if (err < 0) {
445                 ast_log(LOG_ERROR, "sw_params: %s\n", snd_strerror(err));
446         }
447
448         err = snd_pcm_poll_descriptors_count(handle);
449         if (err <= 0) {
450                 ast_log(LOG_ERROR, "Unable to get a poll descriptors count, error is %s\n", snd_strerror(err));
451         }
452
453         if (err != 1) {
454                 ast_log(LOG_DEBUG, "Can't handle more than one device\n");
455         }
456
457         snd_pcm_poll_descriptors(handle, &pfd, err);
458         ast_log(LOG_DEBUG, "Acquired fd %d from the poll descriptor\n", pfd.fd);
459
460         if (stream == SND_PCM_STREAM_CAPTURE)
461                 readdev = pfd.fd;
462         else
463                 writedev = pfd.fd;
464
465         return handle;
466 }
467
468 static int soundcard_init(void)
469 {
470         alsa.icard = alsa_card_init(indevname, SND_PCM_STREAM_CAPTURE);
471         alsa.ocard = alsa_card_init(outdevname, SND_PCM_STREAM_PLAYBACK);
472
473         if (!alsa.icard || !alsa.ocard) {
474                 ast_log(LOG_ERROR, "Problem opening alsa I/O devices\n");
475                 return -1;
476         }
477
478         return readdev;
479 }
480
481 static int alsa_digit(struct ast_channel *c, char digit)
482 {
483         ast_verbose( " << Console Received digit %c >> \n", digit);
484         return 0;
485 }
486
487 static int alsa_text(struct ast_channel *c, char *text)
488 {
489         ast_verbose( " << Console Received text %s >> \n", text);
490         return 0;
491 }
492
493 static int alsa_call(struct ast_channel *c, char *dest, int timeout)
494 {
495         int res = 3;
496         ast_verbose( " << Call placed to '%s' on console >> \n", dest);
497         if (autoanswer) {
498                 ast_verbose( " << Auto-answered >> \n" );
499                 needanswer = 1;
500         } else {
501                 ast_verbose( " << Type 'answer' to answer, or use 'autoanswer' for future calls >> \n");
502                 needringing = 1;
503                 write(sndcmd[1], &res, sizeof(res));
504         }
505         return 0;
506 }
507
508 static void answer_sound(void)
509 {
510         int res;
511         nosound = 1;
512         res = 4;
513         write(sndcmd[1], &res, sizeof(res));
514         
515 }
516
517 static int alsa_answer(struct ast_channel *c)
518 {
519         ast_verbose( " << Console call has been answered >> \n");
520         answer_sound();
521         ast_setstate(c, AST_STATE_UP);
522         cursound = -1;
523         return 0;
524 }
525
526 static int alsa_hangup(struct ast_channel *c)
527 {
528         int res;
529         cursound = -1;
530         c->pvt->pvt = NULL;
531         alsa.owner = NULL;
532         ast_verbose( " << Hangup on console >> \n");
533         ast_mutex_lock(&usecnt_lock);
534         usecnt--;
535         ast_mutex_unlock(&usecnt_lock);
536         needhangup = 0;
537         needanswer = 0;
538         if (hookstate) {
539                 res = 2;
540                 write(sndcmd[1], &res, sizeof(res));
541         }
542         return 0;
543 }
544
545 #if 0
546 static int soundcard_writeframe(short *data)
547 {       
548         /* Write an exactly FRAME_SIZE sized of frame */
549         static int bufcnt = 0;
550         static short buffer[FRAME_SIZE * MAX_BUFFER_SIZE * 5];
551         struct audio_buf_info info;
552         int res;
553         int fd = sounddev;
554         static int warned=0;
555         if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info)) {
556                 if (!warned)
557                         ast_log(LOG_WARNING, "Error reading output space\n");
558                 bufcnt = buffersize;
559                 warned++;
560         }
561         if ((info.fragments >= buffersize * 5) && (bufcnt == buffersize)) {
562                 /* We've run out of stuff, buffer again */
563                 bufcnt = 0;
564         }
565         if (bufcnt == buffersize) {
566                 /* Write sample immediately */
567                 res = write(fd, ((void *)data), FRAME_SIZE * 2);
568         } else {
569                 /* Copy the data into our buffer */
570                 res = FRAME_SIZE * 2;
571                 memcpy(buffer + (bufcnt * FRAME_SIZE), data, FRAME_SIZE * 2);
572                 bufcnt++;
573                 if (bufcnt == buffersize) {
574                         res = write(fd, ((void *)buffer), FRAME_SIZE * 2 * buffersize);
575                 }
576         }
577         return res;
578 }
579 #endif
580
581 static int alsa_write(struct ast_channel *chan, struct ast_frame *f)
582 {
583         int res;
584         static char sizbuf[8000];
585         static int sizpos = 0;
586         int len = sizpos;
587         int pos;
588         //size_t frames = 0;
589         snd_pcm_state_t state;
590         /* Immediately return if no sound is enabled */
591         if (nosound)
592                 return 0;
593         /* Stop any currently playing sound */
594         if (cursound != -1) {
595                 snd_pcm_drop(alsa.ocard);
596                 snd_pcm_prepare(alsa.ocard);
597                 cursound = -1;
598         }
599         
600
601         /* We have to digest the frame in 160-byte portions */
602         if (f->datalen > sizeof(sizbuf) - sizpos) {
603                 ast_log(LOG_WARNING, "Frame too large\n");
604                 return -1;
605         }
606         memcpy(sizbuf + sizpos, f->data, f->datalen);
607         len += f->datalen;
608         pos = 0;
609 #ifdef ALSA_MONITOR
610         alsa_monitor_write(sizbuf, len);
611 #endif
612         state = snd_pcm_state(alsa.ocard);
613         if (state == SND_PCM_STATE_XRUN) {
614                 snd_pcm_prepare(alsa.ocard);
615         }
616         res = snd_pcm_writei(alsa.ocard, sizbuf, len/2);
617         if (res == -EPIPE) {
618 #if DEBUG
619                 ast_log(LOG_DEBUG, "XRUN write\n");
620 #endif
621                 snd_pcm_prepare(alsa.ocard);
622                 res = snd_pcm_writei(alsa.ocard, sizbuf, len/2);
623                 if (res != len/2) {
624                         ast_log(LOG_ERROR, "Write error: %s\n", snd_strerror(res));
625                         return -1;
626                 } else if (res < 0) {
627                         ast_log(LOG_ERROR, "Write error %s\n", snd_strerror(res));
628                         return -1;
629                 }
630         } else {
631                 if (res == -ESTRPIPE) {
632                         ast_log(LOG_ERROR, "You've got some big problems\n");
633                 }
634         }
635
636         return 0;
637 }
638
639
640 static struct ast_frame *alsa_read(struct ast_channel *chan)
641 {
642         static struct ast_frame f;
643         static short __buf[FRAME_SIZE + AST_FRIENDLY_OFFSET/2];
644         short *buf;
645         static int readpos = 0;
646         static int left = FRAME_SIZE;
647         int res;
648         int b;
649         int nonull=0;
650         snd_pcm_state_t state;
651         int r = 0;
652         int off = 0;
653
654         /* Acknowledge any pending cmd */
655         res = read(cmd[0], &b, sizeof(b));
656         if (res > 0)
657                 nonull = 1;
658         
659         f.frametype = AST_FRAME_NULL;
660         f.subclass = 0;
661         f.samples = 0;
662         f.datalen = 0;
663         f.data = NULL;
664         f.offset = 0;
665         f.src = type;
666         f.mallocd = 0;
667         f.delivery.tv_sec = 0;
668         f.delivery.tv_usec = 0;
669
670         
671         if (needringing) {
672                 f.frametype = AST_FRAME_CONTROL;
673                 f.subclass = AST_CONTROL_RINGING;
674                 needringing = 0;
675                 return &f;
676         }
677         
678         if (needhangup) {
679                 needhangup = 0;
680                 return NULL;
681         }
682         if (strlen(text2send)) {
683                 f.frametype = AST_FRAME_TEXT;
684                 f.subclass = 0;
685                 f.data = text2send;
686                 f.datalen = strlen(text2send);
687                 strcpy(text2send,"");
688                 return &f;
689         }
690         if (strlen(digits)) {
691                 f.frametype = AST_FRAME_DTMF;
692                 f.subclass = digits[0];
693                 for (res=0;res<strlen(digits);res++)
694                         digits[res] = digits[res + 1];
695                 return &f;
696         }
697         
698         if (needanswer) {
699                 needanswer = 0;
700                 f.frametype = AST_FRAME_CONTROL;
701                 f.subclass = AST_CONTROL_ANSWER;
702                 ast_setstate(chan, AST_STATE_UP);
703                 return &f;
704         }
705         
706         if (nonull)
707                 return &f;
708                 
709         
710         state = snd_pcm_state(alsa.ocard);
711         if (state == SND_PCM_STATE_XRUN) {
712                 snd_pcm_prepare(alsa.ocard);
713         }
714
715         buf = __buf + AST_FRIENDLY_OFFSET/2;
716
717         r = snd_pcm_readi(alsa.icard, buf + readpos, left);
718         if (r == -EPIPE) {
719 #if DEBUG
720                 ast_log(LOG_ERROR, "XRUN read\n");
721 #endif
722                 snd_pcm_prepare(alsa.icard);
723         } else if (r == -ESTRPIPE) {
724                 ast_log(LOG_ERROR, "-ESTRPIPE\n");
725                 snd_pcm_prepare(alsa.icard);
726         } else if (r < 0) {
727                 ast_log(LOG_ERROR, "Read error: %s\n", snd_strerror(r));
728                 return NULL;
729         } else if (r >= 0) {
730                 off -= r;
731         }
732         /* Update positions */
733         readpos += r;
734         left -= r;
735
736         if (readpos >= FRAME_SIZE) {
737                 /* A real frame */
738                 readpos = 0;
739                 left = FRAME_SIZE;
740                 if (chan->_state != AST_STATE_UP) {
741                         /* Don't transmit unless it's up */
742                         return &f;
743                 }
744                 f.frametype = AST_FRAME_VOICE;
745                 f.subclass = AST_FORMAT_SLINEAR;
746                 f.samples = FRAME_SIZE;
747                 f.datalen = FRAME_SIZE * 2;
748                 f.data = buf;
749                 f.offset = AST_FRIENDLY_OFFSET;
750                 f.src = type;
751                 f.mallocd = 0;
752 #ifdef ALSA_MONITOR
753                 alsa_monitor_read((char *)buf, FRAME_SIZE * 2);
754 #endif          
755
756 #if 0
757                 { static int fd = -1;
758                   if (fd < 0)
759                         fd = open("output.raw", O_RDWR | O_TRUNC | O_CREAT);
760                   write(fd, f.data, f.datalen);
761                 }
762 #endif          
763         }
764         return &f;
765 }
766
767 static int alsa_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
768 {
769         struct chan_alsa_pvt *p = newchan->pvt->pvt;
770         p->owner = newchan;
771         return 0;
772 }
773
774 static int alsa_indicate(struct ast_channel *chan, int cond)
775 {
776         int res;
777         switch(cond) {
778         case AST_CONTROL_BUSY:
779                 res = 1;
780                 break;
781         case AST_CONTROL_CONGESTION:
782                 res = 2;
783                 break;
784         case AST_CONTROL_RINGING:
785                 res = 0;
786                 break;
787         default:
788                 ast_log(LOG_WARNING, "Don't know how to display condition %d on %s\n", cond, chan->name);
789                 return -1;
790         }
791         if (res > -1) {
792                 write(sndcmd[1], &res, sizeof(res));
793         }
794         return 0;       
795 }
796
797 static struct ast_channel *alsa_new(struct chan_alsa_pvt *p, int state)
798 {
799         struct ast_channel *tmp;
800         tmp = ast_channel_alloc(1);
801         if (tmp) {
802                 snprintf(tmp->name, sizeof(tmp->name), "ALSA/%s", indevname);
803                 tmp->type = type;
804                 tmp->fds[0] = readdev;
805                 tmp->fds[1] = cmd[0];
806                 tmp->nativeformats = AST_FORMAT_SLINEAR;
807                 tmp->pvt->pvt = p;
808                 tmp->pvt->send_digit = alsa_digit;
809                 tmp->pvt->send_text = alsa_text;
810                 tmp->pvt->hangup = alsa_hangup;
811                 tmp->pvt->answer = alsa_answer;
812                 tmp->pvt->read = alsa_read;
813                 tmp->pvt->call = alsa_call;
814                 tmp->pvt->write = alsa_write;
815                 tmp->pvt->indicate = alsa_indicate;
816                 tmp->pvt->fixup = alsa_fixup;
817                 if (strlen(p->context))
818                         strncpy(tmp->context, p->context, sizeof(tmp->context)-1);
819                 if (strlen(p->exten))
820                         strncpy(tmp->exten, p->exten, sizeof(tmp->exten)-1);
821                 if (strlen(language))
822                         strncpy(tmp->language, language, sizeof(tmp->language)-1);
823                 p->owner = tmp;
824                 ast_setstate(tmp, state);
825                 ast_mutex_lock(&usecnt_lock);
826                 usecnt++;
827                 ast_mutex_unlock(&usecnt_lock);
828                 ast_update_use_count();
829                 if (state != AST_STATE_DOWN) {
830                         if (ast_pbx_start(tmp)) {
831                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
832                                 ast_hangup(tmp);
833                                 tmp = NULL;
834                         }
835                 }
836         }
837         return tmp;
838 }
839
840 static struct ast_channel *alsa_request(char *type, int format, void *data)
841 {
842         int oldformat = format;
843         struct ast_channel *tmp;
844         format &= AST_FORMAT_SLINEAR;
845         if (!format) {
846                 ast_log(LOG_NOTICE, "Asked to get a channel of format '%d'\n", oldformat);
847                 return NULL;
848         }
849         if (alsa.owner) {
850                 ast_log(LOG_NOTICE, "Already have a call on the ALSA channel\n");
851                 return NULL;
852         }
853         tmp= alsa_new(&alsa, AST_STATE_DOWN);
854         if (!tmp) {
855                 ast_log(LOG_WARNING, "Unable to create new ALSA channel\n");
856         }
857         return tmp;
858 }
859
860 static int console_autoanswer(int fd, int argc, char *argv[])
861 {
862         if ((argc != 1) && (argc != 2))
863                 return RESULT_SHOWUSAGE;
864         if (argc == 1) {
865                 ast_cli(fd, "Auto answer is %s.\n", autoanswer ? "on" : "off");
866                 return RESULT_SUCCESS;
867         } else {
868                 if (!strcasecmp(argv[1], "on"))
869                         autoanswer = -1;
870                 else if (!strcasecmp(argv[1], "off"))
871                         autoanswer = 0;
872                 else
873                         return RESULT_SHOWUSAGE;
874         }
875         return RESULT_SUCCESS;
876 }
877
878 static char *autoanswer_complete(char *line, char *word, int pos, int state)
879 {
880 #ifndef MIN
881 #define MIN(a,b) ((a) < (b) ? (a) : (b))
882 #endif
883         switch(state) {
884         case 0:
885                 if (strlen(word) && !strncasecmp(word, "on", MIN(strlen(word), 2)))
886                         return strdup("on");
887         case 1:
888                 if (strlen(word) && !strncasecmp(word, "off", MIN(strlen(word), 3)))
889                         return strdup("off");
890         default:
891                 return NULL;
892         }
893         return NULL;
894 }
895
896 static char autoanswer_usage[] =
897 "Usage: autoanswer [on|off]\n"
898 "       Enables or disables autoanswer feature.  If used without\n"
899 "       argument, displays the current on/off status of autoanswer.\n"
900 "       The default value of autoanswer is in 'alsa.conf'.\n";
901
902 static int console_answer(int fd, int argc, char *argv[])
903 {
904         if (argc != 1)
905                 return RESULT_SHOWUSAGE;
906         if (!alsa.owner) {
907                 ast_cli(fd, "No one is calling us\n");
908                 return RESULT_FAILURE;
909         }
910         hookstate = 1;
911         cursound = -1;
912         needanswer++;
913         answer_sound();
914         return RESULT_SUCCESS;
915 }
916
917 static char sendtext_usage[] =
918 "Usage: send text <message>\n"
919 "       Sends a text message for display on the remote terminal.\n";
920
921 static int console_sendtext(int fd, int argc, char *argv[])
922 {
923         int tmparg = 2;
924         if (argc < 2)
925                 return RESULT_SHOWUSAGE;
926         if (!alsa.owner) {
927                 ast_cli(fd, "No one is calling us\n");
928                 return RESULT_FAILURE;
929         }
930         if (strlen(text2send))
931                 ast_cli(fd, "Warning: message already waiting to be sent, overwriting\n");
932         strcpy(text2send, "");
933         while(tmparg <= argc) {
934                 strncat(text2send, argv[tmparg++], sizeof(text2send) - strlen(text2send));
935                 strncat(text2send, " ", sizeof(text2send) - strlen(text2send));
936         }
937         needanswer++;
938         return RESULT_SUCCESS;
939 }
940
941 static char answer_usage[] =
942 "Usage: answer\n"
943 "       Answers an incoming call on the console (ALSA) channel.\n";
944
945 static int console_hangup(int fd, int argc, char *argv[])
946 {
947         if (argc != 1)
948                 return RESULT_SHOWUSAGE;
949         cursound = -1;
950         if (!alsa.owner && !hookstate) {
951                 ast_cli(fd, "No call to hangup up\n");
952                 return RESULT_FAILURE;
953         }
954         hookstate = 0;
955         if (alsa.owner) {
956                 ast_queue_hangup(alsa.owner);
957         }
958         return RESULT_SUCCESS;
959 }
960
961 static char hangup_usage[] =
962 "Usage: hangup\n"
963 "       Hangs up any call currently placed on the console.\n";
964
965
966 static int console_dial(int fd, int argc, char *argv[])
967 {
968         char tmp[256], *tmp2;
969         char *mye, *myc;
970         int b = 0;
971         if ((argc != 1) && (argc != 2))
972                 return RESULT_SHOWUSAGE;
973         if (alsa.owner) {
974                 if (argc == 2) {
975                         strncat(digits, argv[1], sizeof(digits) - strlen(digits));
976                         /* Wake up the polling thread */
977                         write(cmd[1], &b, sizeof(b));
978                 } else {
979                         ast_cli(fd, "You're already in a call.  You can use this only to dial digits until you hangup\n");
980                         return RESULT_FAILURE;
981                 }
982                 return RESULT_SUCCESS;
983         }
984         mye = exten;
985         myc = context;
986         if (argc == 2) {
987                 char *stringp=NULL;
988                 strncpy(tmp, argv[1], sizeof(tmp)-1);
989                 stringp=tmp;
990                 strsep(&stringp, "@");
991                 tmp2 = strsep(&stringp, "@");
992                 if (strlen(tmp))
993                         mye = tmp;
994                 if (tmp2 && strlen(tmp2))
995                         myc = tmp2;
996         }
997         if (ast_exists_extension(NULL, myc, mye, 1, NULL)) {
998                 strncpy(alsa.exten, mye, sizeof(alsa.exten)-1);
999                 strncpy(alsa.context, myc, sizeof(alsa.context)-1);
1000                 hookstate = 1;
1001                 alsa_new(&alsa, AST_STATE_RINGING);
1002         } else
1003                 ast_cli(fd, "No such extension '%s' in context '%s'\n", mye, myc);
1004         return RESULT_SUCCESS;
1005 }
1006
1007 static char dial_usage[] =
1008 "Usage: dial [extension[@context]]\n"
1009 "       Dials a given extensison (";
1010
1011
1012 static struct ast_cli_entry myclis[] = {
1013         { { "answer", NULL }, console_answer, "Answer an incoming console call", answer_usage },
1014         { { "hangup", NULL }, console_hangup, "Hangup a call on the console", hangup_usage },
1015         { { "dial", NULL }, console_dial, "Dial an extension on the console", dial_usage },
1016         { { "send", "text", NULL }, console_sendtext, "Send text to the remote device", sendtext_usage },
1017         { { "autoanswer", NULL }, console_autoanswer, "Sets/displays autoanswer", autoanswer_usage, autoanswer_complete }
1018 };
1019
1020 int load_module()
1021 {
1022         int res;
1023         int x;
1024         int flags;
1025         struct ast_config *cfg;
1026         struct ast_variable *v;
1027         res = pipe(cmd);
1028         res = pipe(sndcmd);
1029         if (res) {
1030                 ast_log(LOG_ERROR, "Unable to create pipe\n");
1031                 return -1;
1032         }
1033         flags = fcntl(cmd[0], F_GETFL);
1034         fcntl(cmd[0], F_SETFL, flags | O_NONBLOCK);
1035         flags = fcntl(cmd[1], F_GETFL);
1036         fcntl(cmd[1], F_SETFL, flags | O_NONBLOCK);
1037         res = soundcard_init();
1038         if (res < 0) {
1039                 close(cmd[1]);
1040                 close(cmd[0]);
1041                 if (option_verbose > 1) {
1042                         ast_verbose(VERBOSE_PREFIX_2 "No sound card detected -- console channel will be unavailable\n");
1043                         ast_verbose(VERBOSE_PREFIX_2 "Turn off ALSA support by adding 'noload=chan_alsa.so' in /etc/asterisk/modules.conf\n");
1044                 }
1045                 return 0;
1046         }
1047 #if 0
1048         if (!full_duplex)
1049                 ast_log(LOG_WARNING, "XXX I don't work right with non-full duplex sound cards XXX\n");
1050 #endif
1051         res = ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR, alsa_request);
1052         if (res < 0) {
1053                 ast_log(LOG_ERROR, "Unable to register channel class '%s'\n", type);
1054                 return -1;
1055         }
1056         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
1057                 ast_cli_register(myclis + x);
1058         if ((cfg = ast_load(config))) {
1059                 v = ast_variable_browse(cfg, "general");
1060                 while(v) {
1061                         if (!strcasecmp(v->name, "autoanswer"))
1062                                 autoanswer = ast_true(v->value);
1063                         else if (!strcasecmp(v->name, "silencesuppression"))
1064                                 silencesuppression = ast_true(v->value);
1065                         else if (!strcasecmp(v->name, "silencethreshold"))
1066                                 silencethreshold = atoi(v->value);
1067                         else if (!strcasecmp(v->name, "context"))
1068                                 strncpy(context, v->value, sizeof(context)-1);
1069                         else if (!strcasecmp(v->name, "language"))
1070                                 strncpy(language, v->value, sizeof(language)-1);
1071                         else if (!strcasecmp(v->name, "extension"))
1072                                 strncpy(exten, v->value, sizeof(exten)-1);
1073                         else if (!strcasecmp(v->name, "input_device"))
1074                                 strncpy(indevname, v->value, sizeof(indevname)-1);
1075                         else if (!strcasecmp(v->name, "output_device"))
1076                                 strncpy(outdevname, v->value, sizeof(outdevname)-1);
1077                         v=v->next;
1078                 }
1079                 ast_destroy(cfg);
1080         }
1081         pthread_create(&sthread, NULL, sound_thread, NULL);
1082 #ifdef ALSA_MONITOR
1083         if (alsa_monitor_start()) {
1084                 ast_log(LOG_ERROR, "Problem starting Monitoring\n");
1085         }
1086 #endif   
1087         return 0;
1088 }
1089
1090
1091
1092 int unload_module()
1093 {
1094         int x;
1095         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
1096                 ast_cli_unregister(myclis + x);
1097         close(readdev);
1098         close(writedev);
1099         if (cmd[0] > 0) {
1100                 close(cmd[0]);
1101                 close(cmd[1]);
1102         }
1103         if (sndcmd[0] > 0) {
1104                 close(sndcmd[0]);
1105                 close(sndcmd[1]);
1106         }
1107         if (alsa.owner)
1108                 ast_softhangup(alsa.owner, AST_SOFTHANGUP_APPUNLOAD);
1109         if (alsa.owner)
1110                 return -1;
1111         return 0;
1112 }
1113
1114 char *description()
1115 {
1116         return desc;
1117 }
1118
1119 int usecount()
1120 {
1121         int res;
1122         ast_mutex_lock(&usecnt_lock);
1123         res = usecnt;
1124         ast_mutex_unlock(&usecnt_lock);
1125         return res;
1126 }
1127
1128 char *key()
1129 {
1130         return ASTERISK_GPL_KEY;
1131 }