2006-06-23 16:33:17 +00:00
|
|
|
/*
|
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
2008-06-12 17:27:55 +00:00
|
|
|
* DAHDI native transcoding support
|
2006-06-23 16:33:17 +00:00
|
|
|
*
|
2008-08-07 20:54:52 +00:00
|
|
|
* Copyright (C) 1999 - 2008, Digium, Inc.
|
2006-06-23 16:33:17 +00:00
|
|
|
*
|
|
|
|
* Mark Spencer <markster@digium.com>
|
|
|
|
* Kevin P. Fleming <kpfleming@digium.com>
|
|
|
|
*
|
|
|
|
* See http://www.asterisk.org for more information about
|
|
|
|
* the Asterisk project. Please do not directly contact
|
|
|
|
* any of the maintainers of this project for assistance;
|
|
|
|
* the project provides a web site, mailing lists and IRC
|
|
|
|
* channels for your use.
|
|
|
|
*
|
|
|
|
* This program is free software, distributed under the terms of
|
|
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
|
|
* at the top of the source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*! \file
|
|
|
|
*
|
2008-06-12 17:27:55 +00:00
|
|
|
* \brief Translate between various formats natively through DAHDI transcoding
|
2006-06-23 16:33:17 +00:00
|
|
|
*
|
|
|
|
* \ingroup codecs
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*** MODULEINFO
|
2008-06-12 17:27:55 +00:00
|
|
|
<depend>dahdi</depend>
|
2006-06-23 16:33:17 +00:00
|
|
|
***/
|
|
|
|
|
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/mman.h>
|
2009-02-17 22:28:41 +00:00
|
|
|
#include <sys/poll.h>
|
2008-06-25 23:05:28 +00:00
|
|
|
#include <dahdi/user.h>
|
|
|
|
|
2006-06-23 16:33:17 +00:00
|
|
|
#include "asterisk/lock.h"
|
|
|
|
#include "asterisk/translate.h"
|
|
|
|
#include "asterisk/config.h"
|
|
|
|
#include "asterisk/module.h"
|
2007-08-31 15:58:31 +00:00
|
|
|
#include "asterisk/cli.h"
|
2006-06-23 16:33:17 +00:00
|
|
|
#include "asterisk/channel.h"
|
|
|
|
#include "asterisk/utils.h"
|
|
|
|
#include "asterisk/linkedlists.h"
|
2009-02-17 22:28:41 +00:00
|
|
|
#include "asterisk/ulaw.h"
|
|
|
|
|
|
|
|
#define BUFFER_SIZE 8000
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
#define G723_SAMPLES 240
|
|
|
|
#define G729_SAMPLES 160
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2007-08-31 15:58:31 +00:00
|
|
|
static struct channel_usage {
|
|
|
|
int total;
|
|
|
|
int encoders;
|
|
|
|
int decoders;
|
|
|
|
} channels;
|
|
|
|
|
2007-10-19 18:01:00 +00:00
|
|
|
static char *handle_cli_transcoder_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
|
2007-08-31 15:58:31 +00:00
|
|
|
|
|
|
|
static struct ast_cli_entry cli[] = {
|
2008-06-12 17:27:55 +00:00
|
|
|
AST_CLI_DEFINE(handle_cli_transcoder_show, "Display DAHDI transcoder utilization.")
|
2007-08-31 15:58:31 +00:00
|
|
|
};
|
|
|
|
|
2006-06-23 16:33:17 +00:00
|
|
|
struct format_map {
|
|
|
|
unsigned int map[32][32];
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct format_map global_format_map = { { { 0 } } };
|
|
|
|
|
|
|
|
struct translator {
|
|
|
|
struct ast_translator t;
|
|
|
|
AST_LIST_ENTRY(translator) entry;
|
|
|
|
};
|
|
|
|
|
2007-03-06 22:15:02 +00:00
|
|
|
static AST_LIST_HEAD_STATIC(translators, translator);
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
struct codec_dahdi_pvt {
|
2006-06-23 16:33:17 +00:00
|
|
|
int fd;
|
2008-08-07 20:54:52 +00:00
|
|
|
struct dahdi_transcoder_formats fmts;
|
2009-02-17 22:28:41 +00:00
|
|
|
unsigned int softslin:1;
|
|
|
|
unsigned int fake:2;
|
|
|
|
uint16_t required_samples;
|
|
|
|
uint16_t samples_in_buffer;
|
|
|
|
uint8_t ulaw_buffer[1024];
|
2006-06-23 16:33:17 +00:00
|
|
|
};
|
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
/* Only used by a decoder */
|
|
|
|
static int ulawtolin(struct ast_trans_pvt *pvt)
|
|
|
|
{
|
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
|
|
|
int i = dahdip->required_samples;
|
|
|
|
uint8_t *src = &dahdip->ulaw_buffer[0];
|
|
|
|
int16_t *dst = pvt->outbuf.i16 + pvt->datalen;
|
|
|
|
|
|
|
|
/* convert and copy in outbuf */
|
|
|
|
while (i--) {
|
|
|
|
*dst++ = AST_MULAW(*src++);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only used by an encoder. */
|
|
|
|
static int lintoulaw(struct ast_trans_pvt *pvt, struct ast_frame *f)
|
|
|
|
{
|
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
|
|
|
int i = f->samples;
|
|
|
|
uint8_t *dst = &dahdip->ulaw_buffer[dahdip->samples_in_buffer];
|
|
|
|
int16_t *src = f->data.ptr;
|
|
|
|
|
|
|
|
if (dahdip->samples_in_buffer + i > sizeof(dahdip->ulaw_buffer)) {
|
|
|
|
ast_log(LOG_ERROR, "Out of buffer space!\n");
|
|
|
|
return -i;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (i--) {
|
|
|
|
*dst++ = AST_LIN2MU(*src++);
|
|
|
|
}
|
|
|
|
|
|
|
|
dahdip->samples_in_buffer += f->samples;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-19 18:01:00 +00:00
|
|
|
static char *handle_cli_transcoder_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2007-08-31 15:58:31 +00:00
|
|
|
{
|
|
|
|
struct channel_usage copy;
|
|
|
|
|
2007-10-19 18:01:00 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
|
|
|
e->command = "transcoder show";
|
|
|
|
e->usage =
|
|
|
|
"Usage: transcoder show\n"
|
2008-06-12 17:27:55 +00:00
|
|
|
" Displays channel utilization of DAHDI transcoder(s).\n";
|
2007-10-19 18:01:00 +00:00
|
|
|
return NULL;
|
|
|
|
case CLI_GENERATE:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a->argc != 2)
|
|
|
|
return CLI_SHOWUSAGE;
|
|
|
|
|
2007-08-31 15:58:31 +00:00
|
|
|
copy = channels;
|
|
|
|
|
|
|
|
if (copy.total == 0)
|
2008-06-12 17:27:55 +00:00
|
|
|
ast_cli(a->fd, "No DAHDI transcoders found.\n");
|
2007-08-31 15:58:31 +00:00
|
|
|
else
|
2007-10-19 18:01:00 +00:00
|
|
|
ast_cli(a->fd, "%d/%d encoders/decoders of %d channels are in use.\n", copy.encoders, copy.decoders, copy.total);
|
2007-08-31 15:58:31 +00:00
|
|
|
|
2007-10-19 18:01:00 +00:00
|
|
|
return CLI_SUCCESS;
|
2007-08-31 15:58:31 +00:00
|
|
|
}
|
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
static void dahdi_write_frame(struct codec_dahdi_pvt *dahdip, const uint8_t *buffer, const ssize_t count)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2008-08-07 20:54:52 +00:00
|
|
|
int res;
|
2009-02-17 22:28:41 +00:00
|
|
|
struct pollfd p = {0};
|
|
|
|
if (!count) return;
|
|
|
|
res = write(dahdip->fd, buffer, count);
|
|
|
|
if (option_verbose > 10) {
|
2008-08-07 20:54:52 +00:00
|
|
|
if (-1 == res) {
|
2009-02-17 22:28:41 +00:00
|
|
|
ast_log(LOG_ERROR, "Failed to write to transcoder: %s\n", strerror(errno));
|
2008-08-07 20:54:52 +00:00
|
|
|
}
|
2009-02-17 22:28:41 +00:00
|
|
|
if (count != res) {
|
|
|
|
ast_log(LOG_ERROR, "Requested write of %zd bytes, but only wrote %d bytes.\n", count, res);
|
2008-08-07 20:54:52 +00:00
|
|
|
}
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
2009-02-17 22:28:41 +00:00
|
|
|
p.fd = dahdip->fd;
|
|
|
|
p.events = POLLOUT;
|
|
|
|
res = poll(&p, 1, 50);
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
static int dahdi_encoder_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2009-02-17 22:28:41 +00:00
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2009-11-04 14:05:12 +00:00
|
|
|
if (!f->subclass.codec) {
|
2009-02-17 22:28:41 +00:00
|
|
|
/* We're just faking a return for calculation purposes. */
|
|
|
|
dahdip->fake = 2;
|
|
|
|
pvt->samples = f->samples;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Buffer up the packets and send them to the hardware if we
|
|
|
|
* have enough samples set up. */
|
|
|
|
if (dahdip->softslin) {
|
|
|
|
if (lintoulaw(pvt, f)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* NOTE: If softslin support is not needed, and the sample
|
|
|
|
* size is equal to the required sample size, we wouldn't
|
|
|
|
* need this copy operation. But at the time this was
|
|
|
|
* written, only softslin is supported. */
|
|
|
|
if (dahdip->samples_in_buffer + f->samples > sizeof(dahdip->ulaw_buffer)) {
|
|
|
|
ast_log(LOG_ERROR, "Out of buffer space.\n");
|
|
|
|
return -1;
|
2008-08-07 20:54:52 +00:00
|
|
|
}
|
2009-02-17 22:28:41 +00:00
|
|
|
memcpy(&dahdip->ulaw_buffer[dahdip->samples_in_buffer], f->data.ptr, f->samples);
|
|
|
|
dahdip->samples_in_buffer += f->samples;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (dahdip->samples_in_buffer > dahdip->required_samples) {
|
|
|
|
dahdi_write_frame(dahdip, dahdip->ulaw_buffer, dahdip->required_samples);
|
|
|
|
dahdip->samples_in_buffer -= dahdip->required_samples;
|
|
|
|
if (dahdip->samples_in_buffer) {
|
|
|
|
/* Shift any remaining bytes down. */
|
|
|
|
memmove(dahdip->ulaw_buffer, &dahdip->ulaw_buffer[dahdip->required_samples],
|
|
|
|
dahdip->samples_in_buffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pvt->samples += f->samples;
|
|
|
|
pvt->datalen = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
2008-08-07 20:54:52 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
static struct ast_frame *dahdi_encoder_frameout(struct ast_trans_pvt *pvt)
|
|
|
|
{
|
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
|
|
|
int res;
|
2008-08-07 20:54:52 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
if (2 == dahdip->fake) {
|
2008-06-12 17:27:55 +00:00
|
|
|
dahdip->fake = 1;
|
Merged revisions 98943 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r98943 | russell | 2008-01-15 17:26:52 -0600 (Tue, 15 Jan 2008) | 25 lines
Commit a fix for some memory access errors pointed out by the valgrind2.txt
output on issue #11698.
The issue here is that it is possible for an instance of a translator to get
destroyed while the frame allocated as a part of the translator is still being
processed. Specifically, this is possible anywhere between a call to ast_read()
and ast_frame_free(), which is _a lot_ of places in the code. The reason this
happens is that the channel might get masqueraded during this time. During a
masquerade, existing translation paths get destroyed.
So, this patch fixes the issue in an API and ABI compatible way. (This one is
for you, paravoid!)
It changes an int in ast_frame to be used as flag bits. The 1 bit is still used
to indicate that the frame contains timing information. Also, a second flag has
been added to indicate that the frame came from a translator. When a frame with
this flag gets released and has this flag, a function is called in translate.c to
let it know that this frame is doing being processed. At this point, the flag gets
cleared. Also, if the translator was requested to be destroyed while its internal
frame still had this flag set, its destruction has been deffered until it finds out
that the frame is no longer being processed.
Admittedly, this feels like a hack. But, it does fix the issue, and I was not able
to think of a better solution ...
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@98944 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2008-01-15 23:31:53 +00:00
|
|
|
pvt->f.frametype = AST_FRAME_VOICE;
|
2009-11-04 14:05:12 +00:00
|
|
|
pvt->f.subclass.codec = 0;
|
2009-02-17 22:28:41 +00:00
|
|
|
pvt->f.samples = dahdip->required_samples;
|
2008-05-22 16:29:54 +00:00
|
|
|
pvt->f.data.ptr = NULL;
|
Merged revisions 98943 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r98943 | russell | 2008-01-15 17:26:52 -0600 (Tue, 15 Jan 2008) | 25 lines
Commit a fix for some memory access errors pointed out by the valgrind2.txt
output on issue #11698.
The issue here is that it is possible for an instance of a translator to get
destroyed while the frame allocated as a part of the translator is still being
processed. Specifically, this is possible anywhere between a call to ast_read()
and ast_frame_free(), which is _a lot_ of places in the code. The reason this
happens is that the channel might get masqueraded during this time. During a
masquerade, existing translation paths get destroyed.
So, this patch fixes the issue in an API and ABI compatible way. (This one is
for you, paravoid!)
It changes an int in ast_frame to be used as flag bits. The 1 bit is still used
to indicate that the frame contains timing information. Also, a second flag has
been added to indicate that the frame came from a translator. When a frame with
this flag gets released and has this flag, a function is called in translate.c to
let it know that this frame is doing being processed. At this point, the flag gets
cleared. Also, if the translator was requested to be destroyed while its internal
frame still had this flag set, its destruction has been deffered until it finds out
that the frame is no longer being processed.
Admittedly, this feels like a hack. But, it does fix the issue, and I was not able
to think of a better solution ...
........
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@98944 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2008-01-15 23:31:53 +00:00
|
|
|
pvt->f.offset = 0;
|
|
|
|
pvt->f.datalen = 0;
|
|
|
|
pvt->f.mallocd = 0;
|
2006-06-23 16:33:17 +00:00
|
|
|
pvt->samples = 0;
|
2008-08-07 20:54:52 +00:00
|
|
|
|
2009-10-21 03:09:04 +00:00
|
|
|
return ast_frisolate(&pvt->f);
|
2008-08-07 20:54:52 +00:00
|
|
|
|
|
|
|
} else if (1 == dahdip->fake) {
|
2009-02-17 22:28:41 +00:00
|
|
|
dahdip->fake = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
res = read(dahdip->fd, pvt->outbuf.c + pvt->datalen, pvt->t->buf_size - pvt->datalen);
|
|
|
|
if (-1 == res) {
|
|
|
|
if (EWOULDBLOCK == errno) {
|
|
|
|
/* Nothing waiting... */
|
|
|
|
return NULL;
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_ERROR, "Failed to read from transcoder: %s\n", strerror(errno));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pvt->f.datalen = res;
|
|
|
|
pvt->f.samples = dahdip->required_samples;
|
|
|
|
pvt->f.frametype = AST_FRAME_VOICE;
|
2009-11-04 14:05:12 +00:00
|
|
|
pvt->f.subclass.codec = 1 << (pvt->t->dstfmt);
|
2009-02-17 22:28:41 +00:00
|
|
|
pvt->f.mallocd = 0;
|
|
|
|
pvt->f.offset = AST_FRIENDLY_OFFSET;
|
|
|
|
pvt->f.src = pvt->t->name;
|
|
|
|
pvt->f.data.ptr = pvt->outbuf.c;
|
|
|
|
|
|
|
|
pvt->samples = 0;
|
|
|
|
pvt->datalen = 0;
|
2009-10-21 03:09:04 +00:00
|
|
|
return ast_frisolate(&pvt->f);
|
2009-02-17 22:28:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Shouldn't get here... */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dahdi_decoder_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
|
|
|
|
{
|
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
|
|
|
|
2009-11-04 14:05:12 +00:00
|
|
|
if (!f->subclass.codec) {
|
2009-02-17 22:28:41 +00:00
|
|
|
/* We're just faking a return for calculation purposes. */
|
|
|
|
dahdip->fake = 2;
|
|
|
|
pvt->samples = f->samples;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f->datalen) {
|
|
|
|
if (f->samples != dahdip->required_samples) {
|
|
|
|
ast_log(LOG_ERROR, "%d != %d %d\n", f->samples, dahdip->required_samples, f->datalen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dahdi_write_frame(dahdip, f->data.ptr, f->datalen);
|
|
|
|
pvt->samples += f->samples;
|
|
|
|
pvt->datalen = 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ast_frame *dahdi_decoder_frameout(struct ast_trans_pvt *pvt)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
2008-08-07 20:54:52 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
if (2 == dahdip->fake) {
|
|
|
|
dahdip->fake = 1;
|
|
|
|
pvt->f.frametype = AST_FRAME_VOICE;
|
2009-11-04 14:05:12 +00:00
|
|
|
pvt->f.subclass.codec = 0;
|
2009-02-17 22:28:41 +00:00
|
|
|
pvt->f.samples = dahdip->required_samples;
|
|
|
|
pvt->f.data.ptr = NULL;
|
|
|
|
pvt->f.offset = 0;
|
|
|
|
pvt->f.datalen = 0;
|
|
|
|
pvt->f.mallocd = 0;
|
|
|
|
pvt->samples = 0;
|
2009-10-21 03:09:04 +00:00
|
|
|
return ast_frisolate(&pvt->f);
|
2009-02-17 22:28:41 +00:00
|
|
|
} else if (1 == dahdip->fake) {
|
|
|
|
pvt->samples = 0;
|
|
|
|
dahdip->fake = 0;
|
2006-06-23 16:33:17 +00:00
|
|
|
return NULL;
|
2009-02-17 22:28:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Let's check to see if there is a new frame for us.... */
|
|
|
|
if (dahdip->softslin) {
|
|
|
|
res = read(dahdip->fd, dahdip->ulaw_buffer, sizeof(dahdip->ulaw_buffer));
|
|
|
|
} else {
|
|
|
|
res = read(dahdip->fd, pvt->outbuf.c + pvt->datalen, pvt->t->buf_size - pvt->datalen);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (-1 == res) {
|
|
|
|
if (EWOULDBLOCK == errno) {
|
|
|
|
/* Nothing waiting... */
|
|
|
|
return NULL;
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_ERROR, "Failed to read from transcoder: %s\n", strerror(errno));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (dahdip->softslin) {
|
|
|
|
ulawtolin(pvt);
|
|
|
|
pvt->f.datalen = res * 2;
|
|
|
|
} else {
|
|
|
|
pvt->f.datalen = res;
|
|
|
|
}
|
|
|
|
pvt->datalen = 0;
|
|
|
|
pvt->f.frametype = AST_FRAME_VOICE;
|
2009-11-04 14:05:12 +00:00
|
|
|
pvt->f.subclass.codec = 1 << (pvt->t->dstfmt);
|
2009-02-17 22:28:41 +00:00
|
|
|
pvt->f.mallocd = 0;
|
|
|
|
pvt->f.offset = AST_FRIENDLY_OFFSET;
|
|
|
|
pvt->f.src = pvt->t->name;
|
|
|
|
pvt->f.data.ptr = pvt->outbuf.c;
|
|
|
|
pvt->f.samples = dahdip->required_samples;
|
|
|
|
pvt->samples = 0;
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2009-10-21 03:09:04 +00:00
|
|
|
return ast_frisolate(&pvt->f);
|
2008-08-07 20:54:52 +00:00
|
|
|
}
|
2009-02-17 22:28:41 +00:00
|
|
|
|
2008-08-07 20:54:52 +00:00
|
|
|
/* Shouldn't get here... */
|
|
|
|
return NULL;
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
|
2008-06-12 17:27:55 +00:00
|
|
|
static void dahdi_destroy(struct ast_trans_pvt *pvt)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2009-02-17 22:28:41 +00:00
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
2007-10-18 15:57:30 +00:00
|
|
|
|
2008-08-07 20:54:52 +00:00
|
|
|
switch (dahdip->fmts.dstfmt) {
|
2007-08-31 15:58:31 +00:00
|
|
|
case AST_FORMAT_G729A:
|
|
|
|
case AST_FORMAT_G723_1:
|
|
|
|
ast_atomic_fetchadd_int(&channels.encoders, -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ast_atomic_fetchadd_int(&channels.decoders, -1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-12 17:27:55 +00:00
|
|
|
close(dahdip->fd);
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 17:27:55 +00:00
|
|
|
static int dahdi_translate(struct ast_trans_pvt *pvt, int dest, int source)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2008-08-07 20:54:52 +00:00
|
|
|
/* Request translation through zap if possible */
|
2006-06-23 16:33:17 +00:00
|
|
|
int fd;
|
2009-02-17 22:28:41 +00:00
|
|
|
struct codec_dahdi_pvt *dahdip = pvt->pvt;
|
2006-08-30 03:20:54 +00:00
|
|
|
int flags;
|
2009-02-17 22:28:41 +00:00
|
|
|
int tried_once = 0;
|
|
|
|
const char *dev_filename = "/dev/dahdi/transcode";
|
|
|
|
|
|
|
|
if ((fd = open(dev_filename, O_RDWR)) < 0) {
|
|
|
|
ast_log(LOG_ERROR, "Failed to open %s: %s\n", dev_filename, strerror(errno));
|
2006-06-24 19:43:31 +00:00
|
|
|
return -1;
|
2006-08-30 03:20:54 +00:00
|
|
|
}
|
2009-02-17 22:28:41 +00:00
|
|
|
|
2008-08-07 20:54:52 +00:00
|
|
|
dahdip->fmts.srcfmt = (1 << source);
|
|
|
|
dahdip->fmts.dstfmt = (1 << dest);
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2009-07-15 16:00:24 +00:00
|
|
|
ast_debug(1, "Opening transcoder channel from %d to %d.\n", source, dest);
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
retry:
|
2008-08-07 20:54:52 +00:00
|
|
|
if (ioctl(fd, DAHDI_TC_ALLOCATE, &dahdip->fmts)) {
|
2009-02-17 22:28:41 +00:00
|
|
|
if ((ENODEV == errno) && !tried_once) {
|
|
|
|
/* We requested to translate to/from an unsupported
|
|
|
|
* format. Most likely this is because signed linear
|
|
|
|
* was not supported by any hardware devices even
|
|
|
|
* though this module always registers signed linear
|
|
|
|
* support. In this case we'll retry, requesting
|
|
|
|
* support for ULAW instead of signed linear and then
|
|
|
|
* we'll just convert from ulaw to signed linear in
|
|
|
|
* software. */
|
|
|
|
if (AST_FORMAT_SLINEAR == dahdip->fmts.srcfmt) {
|
2009-07-15 16:00:24 +00:00
|
|
|
ast_debug(1, "Using soft_slin support on source\n");
|
2009-02-17 22:28:41 +00:00
|
|
|
dahdip->softslin = 1;
|
|
|
|
dahdip->fmts.srcfmt = AST_FORMAT_ULAW;
|
|
|
|
} else if (AST_FORMAT_SLINEAR == dahdip->fmts.dstfmt) {
|
2009-07-15 16:00:24 +00:00
|
|
|
ast_debug(1, "Using soft_slin support on destination\n");
|
2009-02-17 22:28:41 +00:00
|
|
|
dahdip->softslin = 1;
|
|
|
|
dahdip->fmts.dstfmt = AST_FORMAT_ULAW;
|
|
|
|
}
|
|
|
|
tried_once = 1;
|
|
|
|
goto retry;
|
|
|
|
}
|
2008-08-07 20:54:52 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to attach to transcoder: %s\n", strerror(errno));
|
2006-06-23 16:33:17 +00:00
|
|
|
close(fd);
|
|
|
|
|
2006-06-24 19:43:31 +00:00
|
|
|
return -1;
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2008-08-07 20:54:52 +00:00
|
|
|
flags = fcntl(fd, F_GETFL);
|
|
|
|
if (flags > - 1) {
|
|
|
|
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK))
|
|
|
|
ast_log(LOG_WARNING, "Could not set non-block mode!\n");
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 17:27:55 +00:00
|
|
|
dahdip->fd = fd;
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
dahdip->required_samples = ((dahdip->fmts.dstfmt|dahdip->fmts.srcfmt)&AST_FORMAT_G723_1) ? G723_SAMPLES : G729_SAMPLES;
|
|
|
|
|
2008-08-07 20:54:52 +00:00
|
|
|
switch (dahdip->fmts.dstfmt) {
|
2007-08-31 15:58:31 +00:00
|
|
|
case AST_FORMAT_G729A:
|
2009-02-17 22:28:41 +00:00
|
|
|
ast_atomic_fetchadd_int(&channels.encoders, +1);
|
2008-08-20 19:57:22 +00:00
|
|
|
break;
|
2007-08-31 15:58:31 +00:00
|
|
|
case AST_FORMAT_G723_1:
|
|
|
|
ast_atomic_fetchadd_int(&channels.encoders, +1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ast_atomic_fetchadd_int(&channels.decoders, +1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-06-24 19:43:31 +00:00
|
|
|
return 0;
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 17:27:55 +00:00
|
|
|
static int dahdi_new(struct ast_trans_pvt *pvt)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2008-06-12 17:27:55 +00:00
|
|
|
return dahdi_translate(pvt, pvt->t->dstfmt, pvt->t->srcfmt);
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2006-12-12 19:55:39 +00:00
|
|
|
static struct ast_frame *fakesrc_sample(void)
|
2006-11-13 22:01:43 +00:00
|
|
|
{
|
|
|
|
/* Don't bother really trying to test hardware ones. */
|
|
|
|
static struct ast_frame f = {
|
|
|
|
.frametype = AST_FRAME_VOICE,
|
2007-03-06 22:15:02 +00:00
|
|
|
.samples = 160,
|
2006-11-13 22:01:43 +00:00
|
|
|
.src = __PRETTY_FUNCTION__
|
|
|
|
};
|
|
|
|
|
|
|
|
return &f;
|
|
|
|
}
|
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
static int is_encoder(struct translator *zt)
|
|
|
|
{
|
|
|
|
if (zt->t.srcfmt&(AST_FORMAT_ULAW|AST_FORMAT_ALAW|AST_FORMAT_SLINEAR)) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
static int register_translator(int dst, int src)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2009-02-17 22:28:41 +00:00
|
|
|
struct translator *zt;
|
2006-06-23 16:33:17 +00:00
|
|
|
int res;
|
2006-12-12 19:55:39 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
if (!(zt = ast_calloc(1, sizeof(*zt)))) {
|
2006-12-12 19:55:39 +00:00
|
|
|
return -1;
|
2009-02-17 22:28:41 +00:00
|
|
|
}
|
2007-03-06 22:15:02 +00:00
|
|
|
|
2009-02-17 22:28:41 +00:00
|
|
|
snprintf((char *) (zt->t.name), sizeof(zt->t.name), "zap%sto%s",
|
2006-12-12 19:55:39 +00:00
|
|
|
ast_getformatname((1 << src)), ast_getformatname((1 << dst)));
|
2009-02-17 22:28:41 +00:00
|
|
|
zt->t.srcfmt = (1 << src);
|
|
|
|
zt->t.dstfmt = (1 << dst);
|
|
|
|
zt->t.buf_size = BUFFER_SIZE;
|
|
|
|
if (is_encoder(zt)) {
|
|
|
|
zt->t.framein = dahdi_encoder_framein;
|
|
|
|
zt->t.frameout = dahdi_encoder_frameout;
|
|
|
|
} else {
|
|
|
|
zt->t.framein = dahdi_decoder_framein;
|
|
|
|
zt->t.frameout = dahdi_decoder_frameout;
|
|
|
|
}
|
|
|
|
zt->t.destroy = dahdi_destroy;
|
|
|
|
zt->t.buffer_samples = 0;
|
|
|
|
zt->t.newpvt = dahdi_new;
|
|
|
|
zt->t.sample = fakesrc_sample;
|
|
|
|
zt->t.native_plc = 0;
|
|
|
|
|
|
|
|
zt->t.desc_size = sizeof(struct codec_dahdi_pvt);
|
|
|
|
if ((res = ast_register_translator(&zt->t))) {
|
|
|
|
ast_free(zt);
|
2006-06-23 16:33:17 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2006-12-12 19:55:39 +00:00
|
|
|
|
2007-03-06 22:15:02 +00:00
|
|
|
AST_LIST_LOCK(&translators);
|
2009-02-17 22:28:41 +00:00
|
|
|
AST_LIST_INSERT_HEAD(&translators, zt, entry);
|
2007-03-06 22:15:02 +00:00
|
|
|
AST_LIST_UNLOCK(&translators);
|
2006-12-12 19:55:39 +00:00
|
|
|
|
|
|
|
global_format_map.map[dst][src] = 1;
|
|
|
|
|
|
|
|
return res;
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void drop_translator(int dst, int src)
|
|
|
|
{
|
|
|
|
struct translator *cur;
|
|
|
|
|
2007-03-06 22:15:02 +00:00
|
|
|
AST_LIST_LOCK(&translators);
|
|
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&translators, cur, entry) {
|
2006-06-23 16:33:17 +00:00
|
|
|
if (cur->t.srcfmt != src)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (cur->t.dstfmt != dst)
|
|
|
|
continue;
|
|
|
|
|
2007-11-08 05:28:47 +00:00
|
|
|
AST_LIST_REMOVE_CURRENT(entry);
|
2006-06-23 16:33:17 +00:00
|
|
|
ast_unregister_translator(&cur->t);
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(cur);
|
2006-06-23 16:33:17 +00:00
|
|
|
global_format_map.map[dst][src] = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
2007-03-06 22:15:02 +00:00
|
|
|
AST_LIST_UNLOCK(&translators);
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void unregister_translators(void)
|
|
|
|
{
|
2009-02-17 22:28:41 +00:00
|
|
|
struct translator *cur;
|
2006-06-23 16:33:17 +00:00
|
|
|
|
2007-03-06 22:15:02 +00:00
|
|
|
AST_LIST_LOCK(&translators);
|
2009-02-17 22:28:41 +00:00
|
|
|
while ((cur = AST_LIST_REMOVE_HEAD(&translators, entry))) {
|
|
|
|
ast_unregister_translator(&cur->t);
|
|
|
|
ast_free(cur);
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
2007-03-06 22:15:02 +00:00
|
|
|
AST_LIST_UNLOCK(&translators);
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2007-03-06 22:15:02 +00:00
|
|
|
static void build_translators(struct format_map *map, unsigned int dstfmts, unsigned int srcfmts)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
|
|
|
unsigned int src, dst;
|
|
|
|
|
|
|
|
for (src = 0; src < 32; src++) {
|
|
|
|
for (dst = 0; dst < 32; dst++) {
|
|
|
|
if (!(srcfmts & (1 << src)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!(dstfmts & (1 << dst)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (global_format_map.map[dst][src])
|
|
|
|
continue;
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
if (!register_translator(dst, src))
|
2006-06-23 16:33:17 +00:00
|
|
|
map->map[dst][src] = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
static int find_transcoders(void)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2008-08-07 20:54:52 +00:00
|
|
|
struct dahdi_transcoder_info info = { 0, };
|
2006-06-23 16:33:17 +00:00
|
|
|
struct format_map map = { { { 0 } } };
|
|
|
|
int fd, res;
|
|
|
|
unsigned int x, y;
|
|
|
|
|
2008-06-12 17:27:55 +00:00
|
|
|
if ((fd = open("/dev/dahdi/transcode", O_RDWR)) < 0) {
|
2008-08-07 20:54:52 +00:00
|
|
|
ast_log(LOG_ERROR, "Failed to open /dev/dahdi/transcode: %s\n", strerror(errno));
|
2006-06-23 16:33:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-09 17:30:13 +00:00
|
|
|
|
2008-08-07 20:54:52 +00:00
|
|
|
for (info.tcnum = 0; !(res = ioctl(fd, DAHDI_TC_GETINFO, &info)); info.tcnum++) {
|
|
|
|
if (option_verbose > 1)
|
|
|
|
ast_verbose(VERBOSE_PREFIX_2 "Found transcoder '%s'.\n", info.name);
|
2009-02-17 22:28:41 +00:00
|
|
|
|
|
|
|
/* Complex codecs need to support signed linear. If the
|
|
|
|
* hardware transcoder does not natively support signed linear
|
|
|
|
* format, we will emulate it in software directly in this
|
|
|
|
* module. Also, do not allow direct ulaw/alaw to complex
|
|
|
|
* codec translation, since that will prevent the generic PLC
|
|
|
|
* functions from working. */
|
|
|
|
if (info.dstfmts & (AST_FORMAT_ULAW | AST_FORMAT_ALAW)) {
|
|
|
|
info.dstfmts |= AST_FORMAT_SLINEAR;
|
|
|
|
info.dstfmts &= ~(AST_FORMAT_ULAW | AST_FORMAT_ALAW);
|
|
|
|
}
|
|
|
|
if (info.srcfmts & (AST_FORMAT_ULAW | AST_FORMAT_ALAW)) {
|
|
|
|
info.srcfmts |= AST_FORMAT_SLINEAR;
|
|
|
|
info.srcfmts &= ~(AST_FORMAT_ULAW | AST_FORMAT_ALAW);
|
|
|
|
}
|
|
|
|
|
2007-03-06 22:15:02 +00:00
|
|
|
build_translators(&map, info.dstfmts, info.srcfmts);
|
2007-11-06 19:10:18 +00:00
|
|
|
ast_atomic_fetchadd_int(&channels.total, info.numchannels / 2);
|
2009-02-17 22:28:41 +00:00
|
|
|
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
2008-01-09 17:30:13 +00:00
|
|
|
|
2006-06-23 16:33:17 +00:00
|
|
|
close(fd);
|
|
|
|
|
2008-08-07 20:54:52 +00:00
|
|
|
if (!info.tcnum && (option_verbose > 1))
|
|
|
|
ast_verbose(VERBOSE_PREFIX_2 "No hardware transcoders found.\n");
|
2006-06-23 16:33:17 +00:00
|
|
|
|
|
|
|
for (x = 0; x < 32; x++) {
|
|
|
|
for (y = 0; y < 32; y++) {
|
|
|
|
if (!map.map[x][y] && global_format_map.map[x][y])
|
|
|
|
drop_translator(x, y);
|
|
|
|
}
|
|
|
|
}
|
2007-03-06 22:15:02 +00:00
|
|
|
|
2006-06-23 16:33:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
static int reload(void)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2007-10-31 19:24:29 +00:00
|
|
|
return AST_MODULE_LOAD_SUCCESS;
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
static int unload_module(void)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2008-07-11 18:09:35 +00:00
|
|
|
ast_cli_unregister_multiple(cli, ARRAY_LEN(cli));
|
2006-06-23 16:33:17 +00:00
|
|
|
unregister_translators();
|
2007-03-06 22:15:02 +00:00
|
|
|
|
2006-06-23 16:33:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-21 02:11:39 +00:00
|
|
|
static int load_module(void)
|
2006-06-23 16:33:17 +00:00
|
|
|
{
|
2009-02-17 22:28:41 +00:00
|
|
|
ast_ulaw_init();
|
2006-12-11 21:04:41 +00:00
|
|
|
find_transcoders();
|
2008-07-11 18:09:35 +00:00
|
|
|
ast_cli_register_multiple(cli, ARRAY_LEN(cli));
|
2007-10-31 19:24:29 +00:00
|
|
|
return AST_MODULE_LOAD_SUCCESS;
|
2006-06-23 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 17:27:55 +00:00
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Generic DAHDI Transcoder Codec Translator",
|
2006-08-21 02:11:39 +00:00
|
|
|
.load = load_module,
|
|
|
|
.unload = unload_module,
|
|
|
|
.reload = reload,
|
2009-02-17 22:28:41 +00:00
|
|
|
);
|