mirror of http://gerrit.asterisk.org/asterisk
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@196 65c4cc65-6c06-0410-ace0-fbb531ad65f31.0
parent
22e0c573b6
commit
c8640d5486
@ -0,0 +1,791 @@
|
||||
/*
|
||||
* Asterisk -- A telephony toolkit for Linux.
|
||||
*
|
||||
* Use /dev/dsp as a channel, and the console to command it :).
|
||||
*
|
||||
* The full-duplex "simulation" is pretty weak. This is generally a
|
||||
* VERY BADLY WRITTEN DRIVER so please don't use it as a model for
|
||||
* writing a driver.
|
||||
*
|
||||
* Copyright (C) 1999, Mark Spencer
|
||||
*
|
||||
* Mark Spencer <markster@linux-support.net>
|
||||
*
|
||||
* This program is free software, distributed under the terms of
|
||||
* the GNU General Public License
|
||||
*/
|
||||
|
||||
#include <asterisk/frame.h>
|
||||
#include <asterisk/logger.h>
|
||||
#include <asterisk/channel.h>
|
||||
#include <asterisk/module.h>
|
||||
#include <asterisk/channel_pvt.h>
|
||||
#include <asterisk/options.h>
|
||||
#include <asterisk/pbx.h>
|
||||
#include <asterisk/config.h>
|
||||
#include <asterisk/cli.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/time.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <linux/soundcard.h>
|
||||
|
||||
/* Which device to use */
|
||||
#define DEV_DSP "/dev/dsp"
|
||||
|
||||
/* Lets use 160 sample frames, just like GSM. */
|
||||
#define FRAME_SIZE 160
|
||||
|
||||
/* When you set the frame size, you have to come up with
|
||||
the right buffer format as well. */
|
||||
/* 5 64-byte frames = one frame */
|
||||
#define BUFFER_FMT ((buffersize * 5) << 16) | (0x0006);
|
||||
|
||||
/* Don't switch between read/write modes faster than every 300 ms */
|
||||
#define MIN_SWITCH_TIME 600
|
||||
|
||||
static struct timeval lasttime;
|
||||
|
||||
static int usecnt;
|
||||
static int needanswer = 0;
|
||||
static int needhangup = 0;
|
||||
static int silencesuppression = 0;
|
||||
static int silencethreshold = 1000;
|
||||
|
||||
static char digits[80] = "";
|
||||
|
||||
static pthread_mutex_t usecnt_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
static char *type = "Console";
|
||||
static char *desc = "OSS Console Channel Driver";
|
||||
static char *tdesc = "OSS Console Channel Driver";
|
||||
static char *config = "oss.conf";
|
||||
|
||||
static char context[AST_MAX_EXTENSION] = "default";
|
||||
static char exten[AST_MAX_EXTENSION] = "s";
|
||||
|
||||
/* Some pipes to prevent overflow */
|
||||
static int funnel[2];
|
||||
static pthread_mutex_t sound_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pthread_t silly;
|
||||
|
||||
static struct chan_oss_pvt {
|
||||
/* We only have one OSS structure -- near sighted perhaps, but it
|
||||
keeps this driver as simple as possible -- as it should be. */
|
||||
struct ast_channel *owner;
|
||||
char exten[AST_MAX_EXTENSION];
|
||||
char context[AST_MAX_EXTENSION];
|
||||
} oss;
|
||||
|
||||
static int time_has_passed()
|
||||
{
|
||||
struct timeval tv;
|
||||
int ms;
|
||||
gettimeofday(&tv, NULL);
|
||||
ms = (tv.tv_sec - lasttime.tv_sec) * 1000 +
|
||||
(tv.tv_usec - lasttime.tv_usec) / 1000;
|
||||
if (ms > MIN_SWITCH_TIME)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Number of buffers... Each is FRAMESIZE/8 ms long. For example
|
||||
with 160 sample frames, and a buffer size of 3, we have a 60ms buffer,
|
||||
usually plenty. */
|
||||
|
||||
|
||||
#define MAX_BUFFER_SIZE 100
|
||||
static int buffersize = 3;
|
||||
|
||||
static int full_duplex = 0;
|
||||
|
||||
/* Are we reading or writing (simulated full duplex) */
|
||||
static int readmode = 1;
|
||||
|
||||
/* File descriptor for sound device */
|
||||
static int sounddev = -1;
|
||||
|
||||
static int autoanswer = 1;
|
||||
|
||||
static int calc_loudness(short *frame)
|
||||
{
|
||||
int sum = 0;
|
||||
int x;
|
||||
for (x=0;x<FRAME_SIZE;x++) {
|
||||
if (frame[x] < 0)
|
||||
sum -= frame[x];
|
||||
else
|
||||
sum += frame[x];
|
||||
}
|
||||
sum = sum/FRAME_SIZE;
|
||||
return sum;
|
||||
}
|
||||
|
||||
static int silence_suppress(short *buf)
|
||||
{
|
||||
#define SILBUF 3
|
||||
int loudness;
|
||||
static int silentframes = 0;
|
||||
static char silbuf[FRAME_SIZE * 2 * SILBUF];
|
||||
static int silbufcnt=0;
|
||||
if (!silencesuppression)
|
||||
return 0;
|
||||
loudness = calc_loudness((short *)(buf));
|
||||
if (option_debug)
|
||||
ast_log(LOG_DEBUG, "loudness is %d\n", loudness);
|
||||
if (loudness < silencethreshold) {
|
||||
silentframes++;
|
||||
silbufcnt++;
|
||||
/* Keep track of the last few bits of silence so we can play
|
||||
them as lead-in when the time is right */
|
||||
if (silbufcnt >= SILBUF) {
|
||||
/* Make way for more buffer */
|
||||
memmove(silbuf, silbuf + FRAME_SIZE * 2, FRAME_SIZE * 2 * (SILBUF - 1));
|
||||
silbufcnt--;
|
||||
}
|
||||
memcpy(silbuf + FRAME_SIZE * 2 * silbufcnt, buf, FRAME_SIZE * 2);
|
||||
if (silentframes > 10) {
|
||||
/* We've had plenty of silence, so compress it now */
|
||||
return 1;
|
||||
}
|
||||
} else {
|
||||
silentframes=0;
|
||||
/* Write any buffered silence we have, it may have something
|
||||
important */
|
||||
if (silbufcnt) {
|
||||
write(funnel[1], silbuf, silbufcnt * FRAME_SIZE);
|
||||
silbufcnt = 0;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void *silly_thread(void *ignore)
|
||||
{
|
||||
char buf[FRAME_SIZE * 2];
|
||||
int pos=0;
|
||||
int res=0;
|
||||
/* Read from the sound device, and write to the pipe. */
|
||||
for (;;) {
|
||||
/* Give the writer a better shot at the lock */
|
||||
#if 0
|
||||
usleep(1000);
|
||||
#endif
|
||||
pthread_testcancel();
|
||||
pthread_mutex_lock(&sound_lock);
|
||||
res = read(sounddev, buf + pos, FRAME_SIZE * 2 - pos);
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
if (res > 0) {
|
||||
pos += res;
|
||||
if (pos == FRAME_SIZE * 2) {
|
||||
if (needhangup || needanswer || strlen(digits) ||
|
||||
!silence_suppress((short *)buf)) {
|
||||
res = write(funnel[1], buf, sizeof(buf));
|
||||
}
|
||||
pos = 0;
|
||||
}
|
||||
} else {
|
||||
close(funnel[1]);
|
||||
break;
|
||||
}
|
||||
pthread_testcancel();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int setformat(void)
|
||||
{
|
||||
int fmt, desired, res, fd = sounddev;
|
||||
static int warnedalready = 0;
|
||||
static int warnedalready2 = 0;
|
||||
pthread_mutex_lock(&sound_lock);
|
||||
fmt = AFMT_S16_LE;
|
||||
res = ioctl(fd, SNDCTL_DSP_SETFMT, &fmt);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_WARNING, "Unable to set format to 16-bit signed\n");
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
res = ioctl(fd, SNDCTL_DSP_SETDUPLEX, 0);
|
||||
if (res >= 0) {
|
||||
if (option_verbose > 1)
|
||||
ast_verbose(VERBOSE_PREFIX_2 "Console is full duplex\n");
|
||||
full_duplex = -1;
|
||||
}
|
||||
fmt = 0;
|
||||
res = ioctl(fd, SNDCTL_DSP_STEREO, &fmt);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
/* 8000 Hz desired */
|
||||
desired = 8000;
|
||||
fmt = desired;
|
||||
res = ioctl(fd, SNDCTL_DSP_SPEED, &fmt);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
if (fmt != desired) {
|
||||
if (!warnedalready++)
|
||||
ast_log(LOG_WARNING, "Requested %d Hz, got %d Hz -- sound may be choppy\n", desired, fmt);
|
||||
}
|
||||
#if 1
|
||||
fmt = BUFFER_FMT;
|
||||
res = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &fmt);
|
||||
if (res < 0) {
|
||||
if (!warnedalready2++)
|
||||
ast_log(LOG_WARNING, "Unable to set fragment size -- sound may be choppy\n");
|
||||
}
|
||||
#endif
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int soundcard_setoutput(int force)
|
||||
{
|
||||
/* Make sure the soundcard is in output mode. */
|
||||
int fd = sounddev;
|
||||
if (full_duplex || (!readmode && !force))
|
||||
return 0;
|
||||
pthread_mutex_lock(&sound_lock);
|
||||
readmode = 0;
|
||||
if (force || time_has_passed()) {
|
||||
ioctl(sounddev, SNDCTL_DSP_RESET);
|
||||
/* Keep the same fd reserved by closing the sound device and copying stdin at the same
|
||||
time. */
|
||||
/* dup2(0, sound); */
|
||||
close(sounddev);
|
||||
fd = open(DEV_DSP, O_WRONLY);
|
||||
if (fd < 0) {
|
||||
ast_log(LOG_WARNING, "Unable to re-open DSP device: %s\n", strerror(errno));
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
/* dup2 will close the original and make fd be sound */
|
||||
if (dup2(fd, sounddev) < 0) {
|
||||
ast_log(LOG_WARNING, "dup2() failed: %s\n", strerror(errno));
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
if (setformat()) {
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return 0;
|
||||
}
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int soundcard_setinput(int force)
|
||||
{
|
||||
int fd = sounddev;
|
||||
if (full_duplex || (readmode && !force))
|
||||
return 0;
|
||||
pthread_mutex_lock(&sound_lock);
|
||||
readmode = -1;
|
||||
if (force || time_has_passed()) {
|
||||
ioctl(sounddev, SNDCTL_DSP_RESET);
|
||||
close(sounddev);
|
||||
/* dup2(0, sound); */
|
||||
fd = open(DEV_DSP, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
ast_log(LOG_WARNING, "Unable to re-open DSP device: %s\n", strerror(errno));
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
/* dup2 will close the original and make fd be sound */
|
||||
if (dup2(fd, sounddev) < 0) {
|
||||
ast_log(LOG_WARNING, "dup2() failed: %s\n", strerror(errno));
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
if (setformat()) {
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return -1;
|
||||
}
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return 0;
|
||||
}
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int soundcard_init()
|
||||
{
|
||||
/* Assume it's full duplex for starters */
|
||||
int fd = open(DEV_DSP, O_RDWR);
|
||||
if (fd < 0) {
|
||||
ast_log(LOG_ERROR, "Unable to open %s: %s\n", DEV_DSP, strerror(errno));
|
||||
return fd;
|
||||
}
|
||||
gettimeofday(&lasttime, NULL);
|
||||
sounddev = fd;
|
||||
setformat();
|
||||
if (!full_duplex)
|
||||
soundcard_setinput(1);
|
||||
return sounddev;
|
||||
}
|
||||
|
||||
static int oss_digit(struct ast_channel *c, char digit)
|
||||
{
|
||||
ast_verbose( " << Console Received digit %c >> \n", digit);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int oss_call(struct ast_channel *c, char *dest, int timeout)
|
||||
{
|
||||
ast_verbose( " << Call placed to '%s' on console >> \n", dest);
|
||||
if (autoanswer) {
|
||||
ast_verbose( " << Auto-answered >> \n" );
|
||||
needanswer = 1;
|
||||
} else {
|
||||
ast_verbose( " << Type 'answer' to answer, or use 'autoanswer' for future calls >> \n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int oss_answer(struct ast_channel *c)
|
||||
{
|
||||
ast_verbose( " << Console call has been answered >> \n");
|
||||
c->state = AST_STATE_UP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int oss_hangup(struct ast_channel *c)
|
||||
{
|
||||
c->pvt->pvt = NULL;
|
||||
oss.owner = NULL;
|
||||
ast_verbose( " << Hangup on console >> \n");
|
||||
pthread_mutex_lock(&usecnt_lock);
|
||||
usecnt--;
|
||||
pthread_mutex_unlock(&usecnt_lock);
|
||||
needhangup = 0;
|
||||
needanswer = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int soundcard_writeframe(short *data)
|
||||
{
|
||||
/* Write an exactly FRAME_SIZE sized of frame */
|
||||
static int bufcnt = 0;
|
||||
static char buffer[FRAME_SIZE * 2 * MAX_BUFFER_SIZE * 5];
|
||||
struct audio_buf_info info;
|
||||
int res;
|
||||
int fd = sounddev;
|
||||
static int warned=0;
|
||||
pthread_mutex_lock(&sound_lock);
|
||||
if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info)) {
|
||||
if (!warned)
|
||||
ast_log(LOG_WARNING, "Error reading output space\n");
|
||||
bufcnt = buffersize;
|
||||
warned++;
|
||||
}
|
||||
if ((info.fragments >= buffersize * 5) && (bufcnt == buffersize)) {
|
||||
/* We've run out of stuff, buffer again */
|
||||
bufcnt = 0;
|
||||
}
|
||||
if (bufcnt == buffersize) {
|
||||
/* Write sample immediately */
|
||||
res = write(fd, ((void *)data), FRAME_SIZE * 2);
|
||||
} else {
|
||||
/* Copy the data into our buffer */
|
||||
res = FRAME_SIZE * 2;
|
||||
memcpy(buffer + (bufcnt * FRAME_SIZE * 2), data, FRAME_SIZE * 2);
|
||||
bufcnt++;
|
||||
if (bufcnt == buffersize) {
|
||||
res = write(fd, ((void *)buffer), FRAME_SIZE * 2 * buffersize);
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&sound_lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
static int oss_write(struct ast_channel *chan, struct ast_frame *f)
|
||||
{
|
||||
int res;
|
||||
static char sizbuf[8000];
|
||||
static int sizpos = 0;
|
||||
int len = sizpos;
|
||||
int pos;
|
||||
if (!full_duplex && (strlen(digits) || needhangup || needanswer)) {
|
||||
/* If we're half duplex, we have to switch to read mode
|
||||
to honor immediate needs if necessary */
|
||||
res = soundcard_setinput(1);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_WARNING, "Unable to set device to input mode\n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
res = soundcard_setoutput(0);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_WARNING, "Unable to set output device\n");
|
||||
return -1;
|
||||
} else if (res > 0) {
|
||||
/* The device is still in read mode, and it's too soon to change it,
|
||||
so just pretend we wrote it */
|
||||
return 0;
|
||||
}
|
||||
/* We have to digest the frame in 160-byte portions */
|
||||
if (f->datalen > sizeof(sizbuf) - sizpos) {
|
||||
ast_log(LOG_WARNING, "Frame too large\n");
|
||||
return -1;
|
||||
}
|
||||
memcpy(sizbuf + sizpos, f->data, f->datalen);
|
||||
len += f->datalen;
|
||||
pos = 0;
|
||||
while(len - pos > FRAME_SIZE * 2) {
|
||||
soundcard_writeframe((short *)(sizbuf + pos));
|
||||
pos += FRAME_SIZE * 2;
|
||||
}
|
||||
if (len - pos)
|
||||
memmove(sizbuf, sizbuf + pos, len - pos);
|
||||
sizpos = len - pos;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct ast_frame *oss_read(struct ast_channel *chan)
|
||||
{
|
||||
static struct ast_frame f;
|
||||
static char buf[FRAME_SIZE * 2 + AST_FRIENDLY_OFFSET];
|
||||
static int readpos = 0;
|
||||
int res;
|
||||
|
||||
#if 0
|
||||
ast_log(LOG_DEBUG, "oss_read()\n");
|
||||
#endif
|
||||
|
||||
f.frametype = AST_FRAME_NULL;
|
||||
f.subclass = 0;
|
||||
f.timelen = 0;
|
||||
f.datalen = 0;
|
||||
f.data = NULL;
|
||||
f.offset = 0;
|
||||
f.src = type;
|
||||
f.mallocd = 0;
|
||||
|
||||
if (needhangup) {
|
||||
return NULL;
|
||||
}
|
||||
if (strlen(digits)) {
|
||||
f.frametype = AST_FRAME_DTMF;
|
||||
f.subclass = digits[0];
|
||||
for (res=0;res<strlen(digits);res++)
|
||||
digits[res] = digits[res + 1];
|
||||
return &f;
|
||||
}
|
||||
|
||||
if (needanswer) {
|
||||
needanswer = 0;
|
||||
f.frametype = AST_FRAME_CONTROL;
|
||||
f.subclass = AST_CONTROL_ANSWER;
|
||||
chan->state = AST_STATE_UP;
|
||||
return &f;
|
||||
}
|
||||
|
||||
res = soundcard_setinput(0);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_WARNING, "Unable to set input mode\n");
|
||||
return NULL;
|
||||
}
|
||||
if (res > 0) {
|
||||
/* Theoretically shouldn't happen, but anyway, return a NULL frame */
|
||||
return &f;
|
||||
}
|
||||
res = read(funnel[0], buf + AST_FRIENDLY_OFFSET + readpos, FRAME_SIZE * 2 - readpos);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_WARNING, "Error reading from sound device: %s\n", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
readpos += res;
|
||||
|
||||
if (readpos == FRAME_SIZE * 2) {
|
||||
/* A real frame */
|
||||
readpos = 0;
|
||||
f.frametype = AST_FRAME_VOICE;
|
||||
f.subclass = AST_FORMAT_SLINEAR;
|
||||
f.timelen = FRAME_SIZE / 8;
|
||||
f.datalen = FRAME_SIZE * 2;
|
||||
f.data = buf + AST_FRIENDLY_OFFSET;
|
||||
f.offset = AST_FRIENDLY_OFFSET;
|
||||
f.src = type;
|
||||
f.mallocd = 0;
|
||||
}
|
||||
return &f;
|
||||
}
|
||||
|
||||
static struct ast_channel *oss_new(struct chan_oss_pvt *p, int state)
|
||||
{
|
||||
struct ast_channel *tmp;
|
||||
tmp = ast_channel_alloc();
|
||||
if (tmp) {
|
||||
snprintf(tmp->name, sizeof(tmp->name), "OSS/%s", DEV_DSP + 5);
|
||||
tmp->type = type;
|
||||
tmp->fd = funnel[0];
|
||||
tmp->format = AST_FORMAT_SLINEAR;
|
||||
tmp->pvt->pvt = p;
|
||||
tmp->pvt->send_digit = oss_digit;
|
||||
tmp->pvt->hangup = oss_hangup;
|
||||
tmp->pvt->answer = oss_answer;
|
||||
tmp->pvt->read = oss_read;
|
||||
tmp->pvt->write = oss_write;
|
||||
if (strlen(p->context))
|
||||
strncpy(tmp->context, p->context, sizeof(tmp->context));
|
||||
if (strlen(p->exten))
|
||||
strncpy(tmp->exten, p->exten, sizeof(tmp->exten));
|
||||
p->owner = tmp;
|
||||
tmp->state = state;
|
||||
pthread_mutex_lock(&usecnt_lock);
|
||||
usecnt++;
|
||||
pthread_mutex_unlock(&usecnt_lock);
|
||||
ast_update_use_count();
|
||||
if (state != AST_STATE_DOWN) {
|
||||
if (ast_pbx_start(tmp)) {
|
||||
ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
|
||||
ast_hangup(tmp);
|
||||
tmp = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static struct ast_channel *oss_request(char *type, int format, void *data)
|
||||
{
|
||||
int oldformat = format;
|
||||
format &= AST_FORMAT_SLINEAR;
|
||||
if (!format) {
|
||||
ast_log(LOG_NOTICE, "Asked to get a channel of format '%d'\n", oldformat);
|
||||
return NULL;
|
||||
}
|
||||
if (oss.owner) {
|
||||
ast_log(LOG_NOTICE, "Already have a call on the OSS channel\n");
|
||||
return NULL;
|
||||
}
|
||||
return oss_new(&oss, AST_STATE_DOWN);
|
||||
}
|
||||
|
||||
static int console_autoanswer(int fd, int argc, char *argv[])
|
||||
{
|
||||
if ((argc != 1) && (argc != 2))
|
||||
return RESULT_SHOWUSAGE;
|
||||
if (argc == 1) {
|
||||
ast_cli(fd, "Auto answer is %s.\n", autoanswer ? "on" : "off");
|
||||
return RESULT_SUCCESS;
|
||||
} else {
|
||||
if (!strcasecmp(argv[1], "on"))
|
||||
autoanswer = -1;
|
||||
else if (!strcasecmp(argv[1], "off"))
|
||||
autoanswer = 0;
|
||||
else
|
||||
return RESULT_SHOWUSAGE;
|
||||
}
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
static char *autoanswer_complete(char *line, char *word, int pos, int state)
|
||||
{
|
||||
#ifndef MIN
|
||||
#define MIN(a,b) ((a) < (b) ? (a) : (b))
|
||||
#endif
|
||||
switch(state) {
|
||||
case 0:
|
||||
if (strlen(word) && !strncasecmp(word, "on", MIN(strlen(word), 2)))
|
||||
return strdup("on");
|
||||
case 1:
|
||||
if (strlen(word) && !strncasecmp(word, "off", MIN(strlen(word), 3)))
|
||||
return strdup("off");
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static char autoanswer_usage[] =
|
||||
"Usage: autoanswer [on|off]\n"
|
||||
" Enables or disables autoanswer feature. If used without\n"
|
||||
" argument, displays the current on/off status of autoanswer.\n"
|
||||
" The default value of autoanswer is in 'oss.conf'.\n";
|
||||
|
||||
static int console_answer(int fd, int argc, char *argv[])
|
||||
{
|
||||
if (argc != 1)
|
||||
return RESULT_SHOWUSAGE;
|
||||
if (!oss.owner) {
|
||||
ast_cli(fd, "No one is calling us\n");
|
||||
return RESULT_FAILURE;
|
||||
}
|
||||
needanswer++;
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
static char answer_usage[] =
|
||||
"Usage: answer\n"
|
||||
" Answers an incoming call on the console (OSS) channel.\n";
|
||||
|
||||
static int console_hangup(int fd, int argc, char *argv[])
|
||||
{
|
||||
if (argc != 1)
|
||||
return RESULT_SHOWUSAGE;
|
||||
if (!oss.owner) {
|
||||
ast_cli(fd, "No call to hangup up\n");
|
||||
return RESULT_FAILURE;
|
||||
}
|
||||
needhangup++;
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
static char hangup_usage[] =
|
||||
"Usage: hangup\n"
|
||||
" Hangs up any call currently placed on the console.\n";
|
||||
|
||||
|
||||
static int console_dial(int fd, int argc, char *argv[])
|
||||
{
|
||||
char tmp[256], *tmp2;
|
||||
char *mye, *myc;
|
||||
if ((argc != 1) && (argc != 2))
|
||||
return RESULT_SHOWUSAGE;
|
||||
if (oss.owner) {
|
||||
if (argc == 2)
|
||||
strncat(digits, argv[1], sizeof(digits) - strlen(digits));
|
||||
else {
|
||||
ast_cli(fd, "You're already in a call. You can use this only to dial digits until you hangup\n");
|
||||
return RESULT_FAILURE;
|
||||
}
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
mye = exten;
|
||||
myc = context;
|
||||
if (argc == 2) {
|
||||
strncpy(tmp, argv[1], sizeof(tmp));
|
||||
strtok(tmp, "@");
|
||||
tmp2 = strtok(NULL, "@");
|
||||
if (strlen(tmp))
|
||||
mye = tmp;
|
||||
if (tmp2 && strlen(tmp2))
|
||||
myc = tmp2;
|
||||
}
|
||||
if (ast_exists_extension(NULL, myc, mye, 1)) {
|
||||
strncpy(oss.exten, mye, sizeof(oss.exten));
|
||||
strncpy(oss.context, myc, sizeof(oss.context));
|
||||
oss_new(&oss, AST_STATE_UP);
|
||||
} else
|
||||
ast_cli(fd, "No such extension '%s' in context '%s'\n", mye, myc);
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
static char dial_usage[] =
|
||||
"Usage: dial [extension[@context]]\n"
|
||||
" Dials a given extensison (";
|
||||
|
||||
|
||||
static struct ast_cli_entry myclis[] = {
|
||||
{ { "answer", NULL }, console_answer, "Answer an incoming console call", answer_usage },
|
||||
{ { "hangup", NULL }, console_hangup, "Hangup a call on the console", hangup_usage },
|
||||
{ { "dial", NULL }, console_dial, "Dial an extension on the console", dial_usage },
|
||||
{ { "autoanswer", NULL }, console_autoanswer, "Sets/displays autoanswer", autoanswer_usage, autoanswer_complete }
|
||||
};
|
||||
|
||||
int load_module()
|
||||
{
|
||||
int res;
|
||||
int x;
|
||||
int flags;
|
||||
struct ast_config *cfg = ast_load(config);
|
||||
struct ast_variable *v;
|
||||
res = pipe(funnel);
|
||||
if (res) {
|
||||
ast_log(LOG_ERROR, "Unable to create pipe\n");
|
||||
return -1;
|
||||
}
|
||||
/* We make the funnel so that writes to the funnel don't block...
|
||||
Our "silly" thread can read to its heart content, preventing
|
||||
recording overruns */
|
||||
flags = fcntl(funnel[1], F_GETFL);
|
||||
#if 0
|
||||
fcntl(funnel[0], F_SETFL, flags | O_NONBLOCK);
|
||||
#endif
|
||||
fcntl(funnel[1], F_SETFL, flags | O_NONBLOCK);
|
||||
res = soundcard_init();
|
||||
if (res < 0) {
|
||||
close(funnel[1]);
|
||||
close(funnel[0]);
|
||||
return -1;
|
||||
}
|
||||
if (!full_duplex)
|
||||
ast_log(LOG_WARNING, "XXX I don't work right with non-full duplex sound cards XXX\n");
|
||||
pthread_create(&silly, NULL, silly_thread, NULL);
|
||||
res = ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR, oss_request);
|
||||
if (res < 0) {
|
||||
ast_log(LOG_ERROR, "Unable to register channel class '%s'\n", type);
|
||||
return -1;
|
||||
}
|
||||
for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
|
||||
ast_cli_register(myclis + x);
|
||||
if (cfg) {
|
||||
v = ast_variable_browse(cfg, "general");
|
||||
while(v) {
|
||||
if (!strcasecmp(v->name, "autoanswer"))
|
||||
autoanswer = ast_true(v->value);
|
||||
else if (!strcasecmp(v->name, "silencesuppression"))
|
||||
silencesuppression = ast_true(v->value);
|
||||
else if (!strcasecmp(v->name, "silencethreshold"))
|
||||
silencethreshold = atoi(v->value);
|
||||
else if (!strcasecmp(v->name, "context"))
|
||||
strncpy(context, v->value, sizeof(context));
|
||||
else if (!strcasecmp(v->name, "extension"))
|
||||
strncpy(exten, v->value, sizeof(exten));
|
||||
v=v->next;
|
||||
}
|
||||
ast_destroy(cfg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int unload_module()
|
||||
{
|
||||
int x;
|
||||
for (x=0;x<sizeof(myclis)/sizeof(struct ast_cli_entry); x++)
|
||||
ast_cli_unregister(myclis + x);
|
||||
close(sounddev);
|
||||
if (funnel[0] > 0) {
|
||||
close(funnel[0]);
|
||||
close(funnel[1]);
|
||||
}
|
||||
if (silly) {
|
||||
pthread_cancel(silly);
|
||||
pthread_join(silly, NULL);
|
||||
}
|
||||
if (oss.owner)
|
||||
ast_softhangup(oss.owner);
|
||||
if (oss.owner)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
char *description()
|
||||
{
|
||||
return desc;
|
||||
}
|
||||
|
||||
int usecount()
|
||||
{
|
||||
int res;
|
||||
pthread_mutex_lock(&usecnt_lock);
|
||||
res = usecnt;
|
||||
pthread_mutex_unlock(&usecnt_lock);
|
||||
return res;
|
||||
}
|
@ -0,0 +1,23 @@
|
||||
;
|
||||
; Open Sound System Console Driver Configuration File
|
||||
;
|
||||
[general]
|
||||
;
|
||||
; Automatically answer incoming calls on the console? Choose yes if
|
||||
; for example you want to use this as an intercom.
|
||||
;
|
||||
autoanswer=yes
|
||||
;
|
||||
; Default context (is overridden with @context syntax)
|
||||
;
|
||||
;context=local
|
||||
;
|
||||
; Default extension to call
|
||||
;
|
||||
extension=s
|
||||
;
|
||||
; Silence supression can be enabled when sound is over a certain threshold.
|
||||
; The value for the threshold should probably be between 500 and 2000 or so,
|
||||
; but your mileage may vary. Use the echo test to evaluate the best setting.
|
||||
;silencesuppression = yes
|
||||
;silencethreshold = 1000
|
Loading…
Reference in new issue