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