Bug # 1108: chan_alsa fixes
[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 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
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         
366         if (rate != DESIRED_RATE) {
367                 ast_log(LOG_WARNING, "Rate not correct, requested %d, got %d\n", DESIRED_RATE, rate);
368         }
369
370         direction = 0;
371         err = snd_pcm_hw_params_set_period_size_near(handle, hwparams, &period_size, &direction);
372         if (err < 0) {
373                 ast_log(LOG_ERROR, "period_size(%ld frames) is bad: %s\n", period_size, snd_strerror(err));
374         } else {
375                 ast_log(LOG_DEBUG, "Period size is %d\n", err);
376         }
377
378         buffer_size = 4096 * 2; //period_size * 16;
379         err = snd_pcm_hw_params_set_buffer_size_near(handle, hwparams, &buffer_size);   
380         if (err < 0) {
381                 ast_log(LOG_WARNING, "Problem setting buffer size of %ld: %s\n", buffer_size, snd_strerror(err));
382         } else {
383                 ast_log(LOG_DEBUG, "Buffer size is set to %d frames\n", err);
384         }
385
386 #if 0
387         direction = 0;
388         err = snd_pcm_hw_params_set_periods_min(handle,hwparams, &per_min, &direction);
389         if (err < 0) {
390                 ast_log(LOG_ERROR, "periods_min: %s\n", snd_strerror(err));
391         }
392
393         err = snd_pcm_hw_params_set_periods_max(handle, hwparams, &per_max, 0);
394         if (err < 0) {
395                 ast_log(LOG_ERROR, "periods_max: %s\n", snd_strerror(err));
396         }
397 #endif
398
399         err = snd_pcm_hw_params(handle, hwparams);
400         if (err < 0) {
401                 ast_log(LOG_ERROR, "Couldn't set the new hw params: %s\n", snd_strerror(err));
402         }
403
404         snd_pcm_sw_params_alloca(&swparams);
405         snd_pcm_sw_params_current(handle, swparams);
406
407 #if 1
408         if (stream == SND_PCM_STREAM_PLAYBACK) {
409                 start_threshold = period_size;
410         } else {
411                 start_threshold = 1;
412         }
413
414         err = snd_pcm_sw_params_set_start_threshold(handle, swparams, start_threshold);
415         if (err < 0) {
416                 ast_log(LOG_ERROR, "start threshold: %s\n", snd_strerror(err));
417         }
418 #endif
419
420 #if 1
421         if (stream == SND_PCM_STREAM_PLAYBACK) {
422                 stop_threshold = buffer_size;
423         } else {
424                 stop_threshold = buffer_size;
425         }
426         err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, stop_threshold);
427         if (err < 0) {
428                 ast_log(LOG_ERROR, "stop threshold: %s\n", snd_strerror(err));
429         }
430 #endif
431 #if 0
432         err = snd_pcm_sw_params_set_xfer_align(handle, swparams, PERIOD_FRAMES);
433         if (err < 0) {
434                 ast_log(LOG_ERROR, "Unable to set xfer alignment: %s\n", snd_strerror(err));
435         }
436 #endif
437
438 #if 0
439         err = snd_pcm_sw_params_set_silence_threshold(handle, swparams, silencethreshold);
440         if (err < 0) {
441                 ast_log(LOG_ERROR, "Unable to set silence threshold: %s\n", snd_strerror(err));
442         }
443 #endif
444         err = snd_pcm_sw_params(handle, swparams);
445         if (err < 0) {
446                 ast_log(LOG_ERROR, "sw_params: %s\n", snd_strerror(err));
447         }
448
449         err = snd_pcm_poll_descriptors_count(handle);
450         if (err <= 0) {
451                 ast_log(LOG_ERROR, "Unable to get a poll descriptors count, error is %s\n", snd_strerror(err));
452         }
453
454         if (err != 1) {
455                 ast_log(LOG_DEBUG, "Can't handle more than one device\n");
456         }
457
458         snd_pcm_poll_descriptors(handle, &pfd, err);
459         ast_log(LOG_DEBUG, "Acquired fd %d from the poll descriptor\n", pfd.fd);
460
461         if (stream == SND_PCM_STREAM_CAPTURE)
462                 readdev = pfd.fd;
463         else
464                 writedev = pfd.fd;
465
466         return handle;
467 }
468
469 static int soundcard_init(void)
470 {
471         alsa.icard = alsa_card_init(indevname, SND_PCM_STREAM_CAPTURE);
472         alsa.ocard = alsa_card_init(outdevname, SND_PCM_STREAM_PLAYBACK);
473
474         if (!alsa.icard || !alsa.ocard) {
475                 ast_log(LOG_ERROR, "Problem opening alsa I/O devices\n");
476                 return -1;
477         }
478
479         return readdev;
480 }
481
482 static int alsa_digit(struct ast_channel *c, char digit)
483 {
484         ast_verbose( " << Console Received digit %c >> \n", digit);
485         return 0;
486 }
487
488 static int alsa_text(struct ast_channel *c, char *text)
489 {
490         ast_verbose( " << Console Received text %s >> \n", text);
491         return 0;
492 }
493
494 static int alsa_call(struct ast_channel *c, char *dest, int timeout)
495 {
496         int res = 3;
497         ast_verbose( " << Call placed to '%s' on console >> \n", dest);
498         if (autoanswer) {
499                 ast_verbose( " << Auto-answered >> \n" );
500                 needanswer = 1;
501         } else {
502                 ast_verbose( " << Type 'answer' to answer, or use 'autoanswer' for future calls >> \n");
503                 needringing = 1;
504                 write(sndcmd[1], &res, sizeof(res));
505         }
506         return 0;
507 }
508
509 static void answer_sound(void)
510 {
511         int res;
512         nosound = 1;
513         res = 4;
514         write(sndcmd[1], &res, sizeof(res));
515         
516 }
517
518 static int alsa_answer(struct ast_channel *c)
519 {
520         ast_verbose( " << Console call has been answered >> \n");
521         answer_sound();
522         ast_setstate(c, AST_STATE_UP);
523         cursound = -1;
524         return 0;
525 }
526
527 static int alsa_hangup(struct ast_channel *c)
528 {
529         int res;
530         cursound = -1;
531         c->pvt->pvt = NULL;
532         alsa.owner = NULL;
533         ast_verbose( " << Hangup on console >> \n");
534         ast_mutex_lock(&usecnt_lock);
535         usecnt--;
536         ast_mutex_unlock(&usecnt_lock);
537         needhangup = 0;
538         needanswer = 0;
539         if (hookstate) {
540                 res = 2;
541                 write(sndcmd[1], &res, sizeof(res));
542         }
543         return 0;
544 }
545
546 #if 0
547 static int soundcard_writeframe(short *data)
548 {       
549         /* Write an exactly FRAME_SIZE sized of frame */
550         static int bufcnt = 0;
551         static short buffer[FRAME_SIZE * MAX_BUFFER_SIZE * 5];
552         struct audio_buf_info info;
553         int res;
554         int fd = sounddev;
555         static int warned=0;
556         if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info)) {
557                 if (!warned)
558                         ast_log(LOG_WARNING, "Error reading output space\n");
559                 bufcnt = buffersize;
560                 warned++;
561         }
562         if ((info.fragments >= buffersize * 5) && (bufcnt == buffersize)) {
563                 /* We've run out of stuff, buffer again */
564                 bufcnt = 0;
565         }
566         if (bufcnt == buffersize) {
567                 /* Write sample immediately */
568                 res = write(fd, ((void *)data), FRAME_SIZE * 2);
569         } else {
570                 /* Copy the data into our buffer */
571                 res = FRAME_SIZE * 2;
572                 memcpy(buffer + (bufcnt * FRAME_SIZE), data, FRAME_SIZE * 2);
573                 bufcnt++;
574                 if (bufcnt == buffersize) {
575                         res = write(fd, ((void *)buffer), FRAME_SIZE * 2 * buffersize);
576                 }
577         }
578         return res;
579 }
580 #endif
581
582 static int alsa_write(struct ast_channel *chan, struct ast_frame *f)
583 {
584         int res;
585         static char sizbuf[8000];
586         static int sizpos = 0;
587         int len = sizpos;
588         int pos;
589         //size_t frames = 0;
590         snd_pcm_state_t state;
591         /* Immediately return if no sound is enabled */
592         if (nosound)
593                 return 0;
594         /* Stop any currently playing sound */
595         if (cursound != -1) {
596                 snd_pcm_drop(alsa.ocard);
597                 snd_pcm_prepare(alsa.ocard);
598                 cursound = -1;
599         }
600         
601
602         /* We have to digest the frame in 160-byte portions */
603         if (f->datalen > sizeof(sizbuf) - sizpos) {
604                 ast_log(LOG_WARNING, "Frame too large\n");
605                 return -1;
606         }
607         memcpy(sizbuf + sizpos, f->data, f->datalen);
608         len += f->datalen;
609         pos = 0;
610 #ifdef ALSA_MONITOR
611         alsa_monitor_write(sizbuf, len);
612 #endif
613         state = snd_pcm_state(alsa.ocard);
614         if (state == SND_PCM_STATE_XRUN) {
615                 snd_pcm_prepare(alsa.ocard);
616         }
617         res = snd_pcm_writei(alsa.ocard, sizbuf, len/2);
618         if (res == -EPIPE) {
619 #if DEBUG
620                 ast_log(LOG_DEBUG, "XRUN write\n");
621 #endif
622                 snd_pcm_prepare(alsa.ocard);
623                 res = snd_pcm_writei(alsa.ocard, sizbuf, len/2);
624                 if (res != len/2) {
625                         ast_log(LOG_ERROR, "Write error: %s\n", snd_strerror(res));
626                         return -1;
627                 } else if (res < 0) {
628                         ast_log(LOG_ERROR, "Write error %s\n", snd_strerror(res));
629                         return -1;
630                 }
631         } else {
632                 if (res == -ESTRPIPE) {
633                         ast_log(LOG_ERROR, "You've got some big problems\n");
634                 }
635         }
636
637         return 0;
638 }
639
640
641 static struct ast_frame *alsa_read(struct ast_channel *chan)
642 {
643         static struct ast_frame f;
644         static short __buf[FRAME_SIZE + AST_FRIENDLY_OFFSET/2];
645         short *buf;
646         static int readpos = 0;
647         static int left = FRAME_SIZE;
648         int res;
649         int b;
650         int nonull=0;
651         snd_pcm_state_t state;
652         int r = 0;
653         int off = 0;
654
655         /* Acknowledge any pending cmd */
656         res = read(cmd[0], &b, sizeof(b));
657         if (res > 0)
658                 nonull = 1;
659         
660         f.frametype = AST_FRAME_NULL;
661         f.subclass = 0;
662         f.samples = 0;
663         f.datalen = 0;
664         f.data = NULL;
665         f.offset = 0;
666         f.src = type;
667         f.mallocd = 0;
668         
669         if (needringing) {
670                 f.frametype = AST_FRAME_CONTROL;
671                 f.subclass = AST_CONTROL_RINGING;
672                 needringing = 0;
673                 return &f;
674         }
675         
676         if (needhangup) {
677                 needhangup = 0;
678                 return NULL;
679         }
680         if (strlen(text2send)) {
681                 f.frametype = AST_FRAME_TEXT;
682                 f.subclass = 0;
683                 f.data = text2send;
684                 f.datalen = strlen(text2send);
685                 strcpy(text2send,"");
686                 return &f;
687         }
688         if (strlen(digits)) {
689                 f.frametype = AST_FRAME_DTMF;
690                 f.subclass = digits[0];
691                 for (res=0;res<strlen(digits);res++)
692                         digits[res] = digits[res + 1];
693                 return &f;
694         }
695         
696         if (needanswer) {
697                 needanswer = 0;
698                 f.frametype = AST_FRAME_CONTROL;
699                 f.subclass = AST_CONTROL_ANSWER;
700                 ast_setstate(chan, AST_STATE_UP);
701                 return &f;
702         }
703         
704         if (nonull)
705                 return &f;
706                 
707         
708         state = snd_pcm_state(alsa.ocard);
709         if (state == SND_PCM_STATE_XRUN) {
710                 snd_pcm_prepare(alsa.ocard);
711         }
712
713         buf = __buf + AST_FRIENDLY_OFFSET/2;
714
715         r = snd_pcm_readi(alsa.icard, buf + readpos, left);
716         if (r == -EPIPE) {
717 #if DEBUG
718                 ast_log(LOG_ERROR, "XRUN read\n");
719 #endif
720                 snd_pcm_prepare(alsa.icard);
721         } else if (r == -ESTRPIPE) {
722                 ast_log(LOG_ERROR, "-ESTRPIPE\n");
723                 snd_pcm_prepare(alsa.icard);
724         } else if (r < 0) {
725                 ast_log(LOG_ERROR, "Read error: %s\n", snd_strerror(r));
726                 return NULL;
727         } else if (r >= 0) {
728                 off -= r;
729         }
730         /* Update positions */
731         readpos += r;
732         left -= r;
733
734         if (readpos >= FRAME_SIZE) {
735                 /* A real frame */
736                 readpos = 0;
737                 left = FRAME_SIZE;
738                 if (chan->_state != AST_STATE_UP) {
739                         /* Don't transmit unless it's up */
740                         return &f;
741                 }
742                 f.frametype = AST_FRAME_VOICE;
743                 f.subclass = AST_FORMAT_SLINEAR;
744                 f.samples = FRAME_SIZE;
745                 f.datalen = FRAME_SIZE * 2;
746                 f.data = buf;
747                 f.offset = AST_FRIENDLY_OFFSET;
748                 f.src = type;
749                 f.mallocd = 0;
750 #ifdef ALSA_MONITOR
751                 alsa_monitor_read((char *)buf, FRAME_SIZE * 2);
752 #endif          
753
754 #if 0
755                 { static int fd = -1;
756                   if (fd < 0)
757                         fd = open("output.raw", O_RDWR | O_TRUNC | O_CREAT);
758                   write(fd, f.data, f.datalen);
759                 }
760 #endif          
761         }
762         return &f;
763 }
764
765 static int alsa_fixup(struct ast_channel *oldchan, struct ast_channel *newchan, int needlock)
766 {
767         struct chan_alsa_pvt *p = newchan->pvt->pvt;
768         p->owner = newchan;
769         return 0;
770 }
771
772 static int alsa_indicate(struct ast_channel *chan, int cond)
773 {
774         int res;
775         switch(cond) {
776         case AST_CONTROL_BUSY:
777                 res = 1;
778                 break;
779         case AST_CONTROL_CONGESTION:
780                 res = 2;
781                 break;
782         case AST_CONTROL_RINGING:
783                 res = 0;
784                 break;
785         default:
786                 ast_log(LOG_WARNING, "Don't know how to display condition %d on %s\n", cond, chan->name);
787                 return -1;
788         }
789         if (res > -1) {
790                 write(sndcmd[1], &res, sizeof(res));
791         }
792         return 0;       
793 }
794
795 static struct ast_channel *alsa_new(struct chan_alsa_pvt *p, int state)
796 {
797         struct ast_channel *tmp;
798         tmp = ast_channel_alloc(1);
799         if (tmp) {
800                 snprintf(tmp->name, sizeof(tmp->name), "ALSA/%s", indevname);
801                 tmp->type = type;
802                 tmp->fds[0] = readdev;
803                 tmp->fds[1] = cmd[0];
804                 tmp->nativeformats = AST_FORMAT_SLINEAR;
805                 tmp->pvt->pvt = p;
806                 tmp->pvt->send_digit = alsa_digit;
807                 tmp->pvt->send_text = alsa_text;
808                 tmp->pvt->hangup = alsa_hangup;
809                 tmp->pvt->answer = alsa_answer;
810                 tmp->pvt->read = alsa_read;
811                 tmp->pvt->call = alsa_call;
812                 tmp->pvt->write = alsa_write;
813                 tmp->pvt->indicate = alsa_indicate;
814                 tmp->pvt->fixup = alsa_fixup;
815                 if (strlen(p->context))
816                         strncpy(tmp->context, p->context, sizeof(tmp->context)-1);
817                 if (strlen(p->exten))
818                         strncpy(tmp->exten, p->exten, sizeof(tmp->exten)-1);
819                 if (strlen(language))
820                         strncpy(tmp->language, language, sizeof(tmp->language)-1);
821                 p->owner = tmp;
822                 ast_setstate(tmp, state);
823                 ast_mutex_lock(&usecnt_lock);
824                 usecnt++;
825                 ast_mutex_unlock(&usecnt_lock);
826                 ast_update_use_count();
827                 if (state != AST_STATE_DOWN) {
828                         if (ast_pbx_start(tmp)) {
829                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
830                                 ast_hangup(tmp);
831                                 tmp = NULL;
832                         }
833                 }
834         }
835         return tmp;
836 }
837
838 static struct ast_channel *alsa_request(char *type, int format, void *data)
839 {
840         int oldformat = format;
841         struct ast_channel *tmp;
842         format &= AST_FORMAT_SLINEAR;
843         if (!format) {
844                 ast_log(LOG_NOTICE, "Asked to get a channel of format '%d'\n", oldformat);
845                 return NULL;
846         }
847         if (alsa.owner) {
848                 ast_log(LOG_NOTICE, "Already have a call on the ALSA channel\n");
849                 return NULL;
850         }
851         tmp= alsa_new(&alsa, AST_STATE_DOWN);
852         if (!tmp) {
853                 ast_log(LOG_WARNING, "Unable to create new ALSA channel\n");
854         }
855         return tmp;
856 }
857
858 static int console_autoanswer(int fd, int argc, char *argv[])
859 {
860         if ((argc != 1) && (argc != 2))
861                 return RESULT_SHOWUSAGE;
862         if (argc == 1) {
863                 ast_cli(fd, "Auto answer is %s.\n", autoanswer ? "on" : "off");
864                 return RESULT_SUCCESS;
865         } else {
866                 if (!strcasecmp(argv[1], "on"))
867                         autoanswer = -1;
868                 else if (!strcasecmp(argv[1], "off"))
869                         autoanswer = 0;
870                 else
871                         return RESULT_SHOWUSAGE;
872         }
873         return RESULT_SUCCESS;
874 }
875
876 static char *autoanswer_complete(char *line, char *word, int pos, int state)
877 {
878 #ifndef MIN
879 #define MIN(a,b) ((a) < (b) ? (a) : (b))
880 #endif
881         switch(state) {
882         case 0:
883                 if (strlen(word) && !strncasecmp(word, "on", MIN(strlen(word), 2)))
884                         return strdup("on");
885         case 1:
886                 if (strlen(word) && !strncasecmp(word, "off", MIN(strlen(word), 3)))
887                         return strdup("off");
888         default:
889                 return NULL;
890         }
891         return NULL;
892 }
893
894 static char autoanswer_usage[] =
895 "Usage: autoanswer [on|off]\n"
896 "       Enables or disables autoanswer feature.  If used without\n"
897 "       argument, displays the current on/off status of autoanswer.\n"
898 "       The default value of autoanswer is in 'alsa.conf'.\n";
899
900 static int console_answer(int fd, int argc, char *argv[])
901 {
902         if (argc != 1)
903                 return RESULT_SHOWUSAGE;
904         if (!alsa.owner) {
905                 ast_cli(fd, "No one is calling us\n");
906                 return RESULT_FAILURE;
907         }
908         hookstate = 1;
909         cursound = -1;
910         needanswer++;
911         answer_sound();
912         return RESULT_SUCCESS;
913 }
914
915 static char sendtext_usage[] =
916 "Usage: send text <message>\n"
917 "       Sends a text message for display on the remote terminal.\n";
918
919 static int console_sendtext(int fd, int argc, char *argv[])
920 {
921         int tmparg = 2;
922         if (argc < 2)
923                 return RESULT_SHOWUSAGE;
924         if (!alsa.owner) {
925                 ast_cli(fd, "No one is calling us\n");
926                 return RESULT_FAILURE;
927         }
928         if (strlen(text2send))
929                 ast_cli(fd, "Warning: message already waiting to be sent, overwriting\n");
930         strcpy(text2send, "");
931         while(tmparg <= argc) {
932                 strncat(text2send, argv[tmparg++], sizeof(text2send) - strlen(text2send));
933                 strncat(text2send, " ", sizeof(text2send) - strlen(text2send));
934         }
935         needanswer++;
936         return RESULT_SUCCESS;
937 }
938
939 static char answer_usage[] =
940 "Usage: answer\n"
941 "       Answers an incoming call on the console (ALSA) channel.\n";
942
943 static int console_hangup(int fd, int argc, char *argv[])
944 {
945         if (argc != 1)
946                 return RESULT_SHOWUSAGE;
947         cursound = -1;
948         if (!alsa.owner && !hookstate) {
949                 ast_cli(fd, "No call to hangup up\n");
950                 return RESULT_FAILURE;
951         }
952         hookstate = 0;
953         if (alsa.owner) {
954                 ast_queue_hangup(alsa.owner, 1);
955         }
956         return RESULT_SUCCESS;
957 }
958
959 static char hangup_usage[] =
960 "Usage: hangup\n"
961 "       Hangs up any call currently placed on the console.\n";
962
963
964 static int console_dial(int fd, int argc, char *argv[])
965 {
966         char tmp[256], *tmp2;
967         char *mye, *myc;
968         int b = 0;
969         if ((argc != 1) && (argc != 2))
970                 return RESULT_SHOWUSAGE;
971         if (alsa.owner) {
972                 if (argc == 2) {
973                         strncat(digits, argv[1], sizeof(digits) - strlen(digits));
974                         /* Wake up the polling thread */
975                         write(cmd[1], &b, sizeof(b));
976                 } else {
977                         ast_cli(fd, "You're already in a call.  You can use this only to dial digits until you hangup\n");
978                         return RESULT_FAILURE;
979                 }
980                 return RESULT_SUCCESS;
981         }
982         mye = exten;
983         myc = context;
984         if (argc == 2) {
985                 char *stringp=NULL;
986                 strncpy(tmp, argv[1], sizeof(tmp)-1);
987                 stringp=tmp;
988                 strsep(&stringp, "@");
989                 tmp2 = strsep(&stringp, "@");
990                 if (strlen(tmp))
991                         mye = tmp;
992                 if (tmp2 && strlen(tmp2))
993                         myc = tmp2;
994         }
995         if (ast_exists_extension(NULL, myc, mye, 1, NULL)) {
996                 strncpy(alsa.exten, mye, sizeof(alsa.exten)-1);
997                 strncpy(alsa.context, myc, sizeof(alsa.context)-1);
998                 hookstate = 1;
999                 alsa_new(&alsa, AST_STATE_RINGING);
1000         } else
1001                 ast_cli(fd, "No such extension '%s' in context '%s'\n", mye, myc);
1002         return RESULT_SUCCESS;
1003 }
1004
1005 static char dial_usage[] =
1006 "Usage: dial [extension[@context]]\n"
1007 "       Dials a given extensison (";
1008
1009
1010 static struct ast_cli_entry myclis[] = {
1011         { { "answer", NULL }, console_answer, "Answer an incoming console call", answer_usage },
1012         { { "hangup", NULL }, console_hangup, "Hangup a call on the console", hangup_usage },
1013         { { "dial", NULL }, console_dial, "Dial an extension on the console", dial_usage },
1014         { { "send", "text", NULL }, console_sendtext, "Send text to the remote device", sendtext_usage },
1015         { { "autoanswer", NULL }, console_autoanswer, "Sets/displays autoanswer", autoanswer_usage, autoanswer_complete }
1016 };
1017
1018 int load_module()
1019 {
1020         int res;
1021         int x;
1022         int flags;
1023         struct ast_config *cfg;
1024         struct ast_variable *v;
1025         res = pipe(cmd);
1026         res = pipe(sndcmd);
1027         if (res) {
1028                 ast_log(LOG_ERROR, "Unable to create pipe\n");
1029                 return -1;
1030         }
1031         flags = fcntl(cmd[0], F_GETFL);
1032         fcntl(cmd[0], F_SETFL, flags | O_NONBLOCK);
1033         flags = fcntl(cmd[1], F_GETFL);
1034         fcntl(cmd[1], F_SETFL, flags | O_NONBLOCK);
1035         res = soundcard_init();
1036         if (res < 0) {
1037                 close(cmd[1]);
1038                 close(cmd[0]);
1039                 if (option_verbose > 1) {
1040                         ast_verbose(VERBOSE_PREFIX_2 "No sound card detected -- console channel will be unavailable\n");
1041                         ast_verbose(VERBOSE_PREFIX_2 "Turn off ALSA support by adding 'noload=chan_alsa.so' in /etc/asterisk/modules.conf\n");
1042                 }
1043                 return 0;
1044         }
1045 #if 0
1046         if (!full_duplex)
1047                 ast_log(LOG_WARNING, "XXX I don't work right with non-full duplex sound cards XXX\n");
1048 #endif
1049         res = ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR, alsa_request);
1050         if (res < 0) {
1051                 ast_log(LOG_ERROR, "Unable to register channel class '%s'\n", type);
1052                 return -1;
1053         }
1054         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
1055                 ast_cli_register(myclis + x);
1056         if ((cfg = ast_load(config))) {
1057                 v = ast_variable_browse(cfg, "general");
1058                 while(v) {
1059                         if (!strcasecmp(v->name, "autoanswer"))
1060                                 autoanswer = ast_true(v->value);
1061                         else if (!strcasecmp(v->name, "silencesuppression"))
1062                                 silencesuppression = ast_true(v->value);
1063                         else if (!strcasecmp(v->name, "silencethreshold"))
1064                                 silencethreshold = atoi(v->value);
1065                         else if (!strcasecmp(v->name, "context"))
1066                                 strncpy(context, v->value, sizeof(context)-1);
1067                         else if (!strcasecmp(v->name, "language"))
1068                                 strncpy(language, v->value, sizeof(language)-1);
1069                         else if (!strcasecmp(v->name, "extension"))
1070                                 strncpy(exten, v->value, sizeof(exten)-1);
1071                         else if (!strcasecmp(v->name, "input_device"))
1072                                 strncpy(indevname, v->value, sizeof(indevname)-1);
1073                         else if (!strcasecmp(v->name, "output_device"))
1074                                 strncpy(outdevname, v->value, sizeof(outdevname)-1);
1075                         v=v->next;
1076                 }
1077                 ast_destroy(cfg);
1078         }
1079         pthread_create(&sthread, NULL, sound_thread, NULL);
1080 #ifdef ALSA_MONITOR
1081         if (alsa_monitor_start()) {
1082                 ast_log(LOG_ERROR, "Problem starting Monitoring\n");
1083         }
1084 #endif   
1085         return 0;
1086 }
1087
1088
1089
1090 int unload_module()
1091 {
1092         int x;
1093         for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
1094                 ast_cli_unregister(myclis + x);
1095         close(readdev);
1096         close(writedev);
1097         if (cmd[0] > 0) {
1098                 close(cmd[0]);
1099                 close(cmd[1]);
1100         }
1101         if (sndcmd[0] > 0) {
1102                 close(sndcmd[0]);
1103                 close(sndcmd[1]);
1104         }
1105         if (alsa.owner)
1106                 ast_softhangup(alsa.owner, AST_SOFTHANGUP_APPUNLOAD);
1107         if (alsa.owner)
1108                 return -1;
1109         return 0;
1110 }
1111
1112 char *description()
1113 {
1114         return desc;
1115 }
1116
1117 int usecount()
1118 {
1119         int res;
1120         ast_mutex_lock(&usecnt_lock);
1121         res = usecnt;
1122         ast_mutex_unlock(&usecnt_lock);
1123         return res;
1124 }
1125
1126 char *key()
1127 {
1128         return ASTERISK_GPL_KEY;
1129 }