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