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