codec_dahdi.c File Reference

Translate between various formats natively through DAHDI transcoding. More...

#include "asterisk.h"
#include <stdbool.h>
#include <poll.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <dahdi/user.h>
#include "asterisk/lock.h"
#include "asterisk/translate.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/channel.h"
#include "asterisk/utils.h"
#include "asterisk/linkedlists.h"
#include "asterisk/ulaw.h"
#include "asterisk/format_compatibility.h"

Include dependency graph for codec_dahdi.c:

Go to the source code of this file.

Data Structures
struct	channel_usage
struct	codec_dahdi_pvt
struct	translator
struct	translators
	the list of translators More...

Macros
#define	BUFFER_SIZE   8000
#define	container_of(ptr, type, member)    ((type *)((char *)(ptr) - offsetof(type, member)))
#define	DAHDI_FORMAT_ADPCM   (1 << 5)
#define	DAHDI_FORMAT_ALAW   (1 << 3)
#define	DAHDI_FORMAT_G723_1   (1 << 0)
#define	DAHDI_FORMAT_G726   (1 << 4)
#define	DAHDI_FORMAT_G729A   (1 << 8)
#define	DAHDI_FORMAT_GSM   (1 << 1)
#define	DAHDI_FORMAT_ILBC   (1 << 10)
#define	DAHDI_FORMAT_LPC10   (1 << 7)
#define	DAHDI_FORMAT_SLINEAR   (1 << 6)
#define	DAHDI_FORMAT_SPEEX   (1 << 9)
#define	DAHDI_FORMAT_ULAW   (1 << 2)
#define	G723_SAMPLES   240
#define	G729_SAMPLES   160
#define	ULAW_SAMPLES   160

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	build_translators (uint32_t dstfmts, uint32_t srcfmts)
static int	dahdi_decoder_framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
static struct ast_frame *	dahdi_decoder_frameout (struct ast_trans_pvt *pvt)
static void	dahdi_destroy (struct ast_trans_pvt *pvt)
static int	dahdi_encoder_framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
static struct ast_frame *	dahdi_encoder_frameout (struct ast_trans_pvt *pvt)
static struct ast_format *	dahdi_format_to_cached (int format)
static int	dahdi_new (struct ast_trans_pvt *pvt)
static int	dahdi_translate (struct ast_trans_pvt *pvt, uint32_t dst_dahdi_fmt, uint32_t src_dahdi_fmt)
static void	dahdi_wait_for_packet (int fd)
static void	dahdi_write_frame (struct codec_dahdi_pvt *dahdip, const uint8_t *buffer, const ssize_t count)
static struct ast_frame *	fakesrc_sample (void)
static int	find_transcoders (void)
static const struct ast_codec *	get_dahdi_codec (uint32_t dahdi_fmt)
static char *	handle_cli_transcoder_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static bool	is_already_registered (uint32_t dstfmt, uint32_t srcfmt)
static bool	is_encoder (uint32_t src_dahdi_fmt)
static int	lintoulaw (struct ast_trans_pvt *pvt, struct ast_frame *f)
static int	load_module (void)
static int	register_translator (uint32_t dst_dahdi_fmt, uint32_t src_dahdi_fmt)
static int	reload (void)
static int	ulawtolin (struct ast_trans_pvt *pvt, int samples)
static int	unload_module (void)
static void	unregister_translators (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Generic DAHDI Transcoder Codec Translator" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct channel_usage	channels
static struct ast_cli_entry	cli []
static struct translators	translators = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

Detailed Description

Translate between various formats natively through DAHDI transcoding.

Definition in file codec_dahdi.c.

Macro Definition Documentation

BUFFER_SIZE

#define BUFFER_SIZE   8000

Definition at line 55 of file codec_dahdi.c.

container_of

#define container_of	(		ptr,
			type,
			member
	)		((type *)((char *)(ptr) - offsetof(type, member)))

Definition at line 277 of file codec_dahdi.c.

DAHDI_FORMAT_ADPCM

#define DAHDI_FORMAT_ADPCM   (1 << 5)

ADPCM (IMA)

Definition at line 74 of file codec_dahdi.c.

DAHDI_FORMAT_ALAW

#define DAHDI_FORMAT_ALAW   (1 << 3)

Raw A-law data (G.711)

Definition at line 70 of file codec_dahdi.c.

DAHDI_FORMAT_G723_1

#define DAHDI_FORMAT_G723_1   (1 << 0)

G.723.1 compression

Definition at line 64 of file codec_dahdi.c.

DAHDI_FORMAT_G726

#define DAHDI_FORMAT_G726   (1 << 4)

ADPCM (G.726, 32kbps)

Definition at line 72 of file codec_dahdi.c.

DAHDI_FORMAT_G729A

#define DAHDI_FORMAT_G729A   (1 << 8)

G.729A audio

Definition at line 80 of file codec_dahdi.c.

DAHDI_FORMAT_GSM

#define DAHDI_FORMAT_GSM   (1 << 1)

GSM compression

Definition at line 66 of file codec_dahdi.c.

DAHDI_FORMAT_ILBC

#define DAHDI_FORMAT_ILBC   (1 << 10)

iLBC Free Compression

Definition at line 84 of file codec_dahdi.c.

DAHDI_FORMAT_LPC10

#define DAHDI_FORMAT_LPC10   (1 << 7)

LPC10, 180 samples/frame

Definition at line 78 of file codec_dahdi.c.

DAHDI_FORMAT_SLINEAR

#define DAHDI_FORMAT_SLINEAR   (1 << 6)

Raw 16-bit Signed Linear (8000 Hz) PCM

Definition at line 76 of file codec_dahdi.c.

DAHDI_FORMAT_SPEEX

#define DAHDI_FORMAT_SPEEX   (1 << 9)

SpeeX Free Compression

Definition at line 82 of file codec_dahdi.c.

DAHDI_FORMAT_ULAW

#define DAHDI_FORMAT_ULAW   (1 << 2)

Raw mu-law data (G.711)

Definition at line 68 of file codec_dahdi.c.

G723_SAMPLES

#define G723_SAMPLES   240

Definition at line 57 of file codec_dahdi.c.

G729_SAMPLES

#define G729_SAMPLES   160

Definition at line 58 of file codec_dahdi.c.

ULAW_SAMPLES

#define ULAW_SAMPLES   160

Definition at line 59 of file codec_dahdi.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 873 of file codec_dahdi.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 873 of file codec_dahdi.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 873 of file codec_dahdi.c.

build_translators()

static void build_translators ( uint32_t  dstfmts, uint32_t  srcfmts  )

static

Definition at line 785 of file codec_dahdi.c.

{
    uint32_t srcfmt;
    uint32_t dstfmt;
 
    AST_LIST_LOCK(&translators);
 
    for (srcfmt = 1; srcfmt != 0; srcfmt <<= 1) {
        for (dstfmt = 1; dstfmt != 0; dstfmt <<= 1) {
            if (!(dstfmts & dstfmt) || !(srcfmts & srcfmt)) {
                continue;
            }
            if (is_already_registered(dstfmt, srcfmt)) {
                continue;
            }
            register_translator(dstfmt, srcfmt);
        }
    }
 
    AST_LIST_UNLOCK(&translators);
}

References AST_LIST_LOCK, AST_LIST_UNLOCK, is_already_registered(), and register_translator().

Referenced by find_transcoders().

dahdi_decoder_framein()

static int dahdi_decoder_framein ( struct ast_trans_pvt *  pvt, struct ast_frame *  f  )

static

Definition at line 476 of file codec_dahdi.c.

{
    struct codec_dahdi_pvt *dahdip = pvt->pvt;
 
    if (!f->subclass.format) {
        /* 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);
    dahdip->samples_written_to_hardware += f->samples;
    pvt->samples += f->samples;
    pvt->datalen = 0;
    return -1;
}

References ast_log, dahdi_write_frame(), ast_frame::data, ast_frame::datalen, ast_trans_pvt::datalen, codec_dahdi_pvt::fake, ast_frame_subclass::format, LOG_ERROR, ast_frame::ptr, ast_trans_pvt::pvt, codec_dahdi_pvt::required_samples, ast_frame::samples, ast_trans_pvt::samples, codec_dahdi_pvt::samples_written_to_hardware, and ast_frame::subclass.

Referenced by register_translator().

dahdi_decoder_frameout()

static struct ast_frame * dahdi_decoder_frameout ( struct ast_trans_pvt *  pvt )

static

Definition at line 499 of file codec_dahdi.c.

{
    int res;
    struct codec_dahdi_pvt *dahdip = pvt->pvt;
 
    if (2 == dahdip->fake) {
        struct ast_frame frm = {
            .frametype = AST_FRAME_VOICE,
            .samples = dahdip->required_samples,
            .src = pvt->t->name,
        };
 
        dahdip->fake = 1;
        pvt->samples = 0;
 
        return ast_frisolate(&frm);
    } else if (1 == dahdip->fake) {
        pvt->samples = 0;
        dahdip->fake = 0;
        return NULL;
    }
 
    if (dahdip->samples_written_to_hardware >= ULAW_SAMPLES) {
        dahdi_wait_for_packet(dahdip->fd);
    }
 
    /* 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, res);
            pvt->f.datalen = res * 2;
        } else {
            pvt->f.datalen = res;
        }
        pvt->datalen = 0;
        pvt->f.samples = res;
        pvt->samples = 0;
        dahdip->samples_written_to_hardware =
            (dahdip->samples_written_to_hardware >= res) ?
                    dahdip->samples_written_to_hardware - res : 0;
 
        return ast_frisolate(&pvt->f);
    }
 
    /* Shouldn't get here... */
    return NULL;
}

References AST_FRAME_VOICE, ast_frisolate, ast_log, ast_translator::buf_size, ast_trans_pvt::c, dahdi_wait_for_packet(), ast_frame::datalen, ast_trans_pvt::datalen, errno, ast_trans_pvt::f, codec_dahdi_pvt::fake, codec_dahdi_pvt::fd, ast_frame::frametype, LOG_ERROR, ast_translator::name, NULL, ast_trans_pvt::outbuf, ast_trans_pvt::pvt, codec_dahdi_pvt::required_samples, ast_frame::samples, ast_trans_pvt::samples, codec_dahdi_pvt::samples_written_to_hardware, codec_dahdi_pvt::softslin, ast_trans_pvt::t, codec_dahdi_pvt::ulaw_buffer, ULAW_SAMPLES, and ulawtolin().

Referenced by register_translator().

dahdi_destroy()

static void dahdi_destroy ( struct ast_trans_pvt *  pvt )

static

Definition at line 562 of file codec_dahdi.c.

{
    struct codec_dahdi_pvt *dahdip = pvt->pvt;
 
    switch (dahdip->fmts.dstfmt) {
    case DAHDI_FORMAT_G729A:
    case DAHDI_FORMAT_G723_1:
        ast_atomic_fetchadd_int(&channels.encoders, -1);
        break;
    default:
        ast_atomic_fetchadd_int(&channels.decoders, -1);
        break;
    }
 
    close(dahdip->fd);
}

References ast_atomic_fetchadd_int(), channels, DAHDI_FORMAT_G723_1, DAHDI_FORMAT_G729A, channel_usage::decoders, channel_usage::encoders, codec_dahdi_pvt::fd, codec_dahdi_pvt::fmts, and ast_trans_pvt::pvt.

Referenced by register_translator().

dahdi_encoder_framein()

static int dahdi_encoder_framein ( struct ast_trans_pvt *  pvt, struct ast_frame *  f  )

static

Definition at line 372 of file codec_dahdi.c.

{
    struct codec_dahdi_pvt *dahdip = pvt->pvt;
 
    if (!f->subclass.format) {
        /* 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;
        }
        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_written_to_hardware += 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;
}

References ast_log, dahdi_write_frame(), ast_frame::data, ast_trans_pvt::datalen, codec_dahdi_pvt::fake, ast_frame_subclass::format, lintoulaw(), LOG_ERROR, ast_frame::ptr, ast_trans_pvt::pvt, codec_dahdi_pvt::required_samples, ast_frame::samples, ast_trans_pvt::samples, codec_dahdi_pvt::samples_in_buffer, codec_dahdi_pvt::samples_written_to_hardware, codec_dahdi_pvt::softslin, ast_frame::subclass, and codec_dahdi_pvt::ulaw_buffer.

Referenced by register_translator().

dahdi_encoder_frameout()

static struct ast_frame * dahdi_encoder_frameout ( struct ast_trans_pvt *  pvt )

static

Definition at line 425 of file codec_dahdi.c.

{
    struct codec_dahdi_pvt *dahdip = pvt->pvt;
    int res;
 
    if (2 == dahdip->fake) {
        struct ast_frame frm = {
            .frametype = AST_FRAME_VOICE,
            .samples = dahdip->required_samples,
            .src = pvt->t->name,
        };
 
        dahdip->fake = 1;
        pvt->samples = 0;
 
        return ast_frisolate(&frm);
    } else if (1 == dahdip->fake) {
        dahdip->fake = 0;
        return NULL;
    }
 
    if (dahdip->samples_written_to_hardware >= dahdip->required_samples) {
        dahdi_wait_for_packet(dahdip->fd);
    }
 
    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 = ast_codec_samples_count(&pvt->f);
 
        dahdip->samples_written_to_hardware =
          (dahdip->samples_written_to_hardware >= pvt->f.samples) ?
             dahdip->samples_written_to_hardware - pvt->f.samples : 0;
 
        pvt->samples = 0;
        pvt->datalen = 0;
        return ast_frisolate(&pvt->f);
    }
 
    /* Shouldn't get here... */
    return NULL;
}

References ast_codec_samples_count(), AST_FRAME_VOICE, ast_frisolate, ast_log, ast_translator::buf_size, ast_trans_pvt::c, dahdi_wait_for_packet(), ast_frame::datalen, ast_trans_pvt::datalen, errno, ast_trans_pvt::f, codec_dahdi_pvt::fake, codec_dahdi_pvt::fd, ast_frame::frametype, LOG_ERROR, ast_translator::name, NULL, ast_trans_pvt::outbuf, ast_trans_pvt::pvt, codec_dahdi_pvt::required_samples, ast_frame::samples, ast_trans_pvt::samples, codec_dahdi_pvt::samples_written_to_hardware, and ast_trans_pvt::t.

Referenced by register_translator().

dahdi_format_to_cached()

static struct ast_format * dahdi_format_to_cached ( int  format )

static

Definition at line 579 of file codec_dahdi.c.

{
    switch (format) {
    case DAHDI_FORMAT_G723_1:
        return ast_format_g723;
    case DAHDI_FORMAT_GSM:
        return ast_format_gsm;
    case DAHDI_FORMAT_ULAW:
        return ast_format_ulaw;
    case DAHDI_FORMAT_ALAW:
        return ast_format_alaw;
    case DAHDI_FORMAT_G726:
        return ast_format_g726;
    case DAHDI_FORMAT_ADPCM:
        return ast_format_adpcm;
    case DAHDI_FORMAT_SLINEAR:
        return ast_format_slin;
    case DAHDI_FORMAT_LPC10:
        return ast_format_lpc10;
    case DAHDI_FORMAT_G729A:
        return ast_format_g729;
    case DAHDI_FORMAT_SPEEX:
        return ast_format_speex;
    case DAHDI_FORMAT_ILBC:
        return ast_format_ilbc;
    }
 
    /* This will never be reached */
    ast_assert(0);
    return NULL;
}

References ast_assert, ast_format_adpcm, ast_format_alaw, ast_format_g723, ast_format_g726, ast_format_g729, ast_format_gsm, ast_format_ilbc, ast_format_lpc10, ast_format_slin, ast_format_speex, ast_format_ulaw, DAHDI_FORMAT_ADPCM, DAHDI_FORMAT_ALAW, DAHDI_FORMAT_G723_1, DAHDI_FORMAT_G726, DAHDI_FORMAT_G729A, DAHDI_FORMAT_GSM, DAHDI_FORMAT_ILBC, DAHDI_FORMAT_LPC10, DAHDI_FORMAT_SLINEAR, DAHDI_FORMAT_SPEEX, DAHDI_FORMAT_ULAW, and NULL.

Referenced by dahdi_translate().

dahdi_new()

static int dahdi_new ( struct ast_trans_pvt *  pvt )

static

Definition at line 682 of file codec_dahdi.c.

{
    struct translator *zt = container_of(pvt->t, struct translator, t);
 
    return dahdi_translate(pvt, zt->dst_dahdi_fmt, zt->src_dahdi_fmt);
}

References container_of, dahdi_translate(), translator::dst_dahdi_fmt, translator::src_dahdi_fmt, translator::t, and ast_trans_pvt::t.

Referenced by register_translator().

dahdi_translate()

static int dahdi_translate ( struct ast_trans_pvt *  pvt, uint32_t  dst_dahdi_fmt, uint32_t  src_dahdi_fmt  )

static

Definition at line 611 of file codec_dahdi.c.

{
    /* Request translation through zap if possible */
    int fd;
    struct codec_dahdi_pvt *dahdip = pvt->pvt;
    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));
        return -1;
    }
 
    dahdip->fmts.srcfmt = src_dahdi_fmt;
    dahdip->fmts.dstfmt = dst_dahdi_fmt;
 
    ast_assert(pvt->f.subclass.format == NULL);
    pvt->f.subclass.format = ao2_bump(dahdi_format_to_cached(dahdip->fmts.dstfmt));
 
    ast_debug(1, "Opening transcoder channel from %s to %s.\n", pvt->t->src_codec.name, pvt->t->dst_codec.name);
 
retry:
    if (ioctl(fd, DAHDI_TC_ALLOCATE, &dahdip->fmts)) {
        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 (dahdip->fmts.srcfmt == DAHDI_FORMAT_SLINEAR) {
                ast_debug(1, "Using soft_slin support on source\n");
                dahdip->softslin = 1;
                dahdip->fmts.srcfmt = DAHDI_FORMAT_ULAW;
            } else if (dahdip->fmts.dstfmt == DAHDI_FORMAT_SLINEAR) {
                ast_debug(1, "Using soft_slin support on destination\n");
                dahdip->softslin = 1;
                dahdip->fmts.dstfmt = DAHDI_FORMAT_ULAW;
            }
            tried_once = 1;
            goto retry;
        }
        ast_log(LOG_ERROR, "Unable to attach to transcoder: %s\n", strerror(errno));
        close(fd);
 
        return -1;
    }
 
    ast_fd_set_flags(fd, O_NONBLOCK);
 
    dahdip->fd = fd;
 
    dahdip->required_samples = ((dahdip->fmts.dstfmt|dahdip->fmts.srcfmt) & (DAHDI_FORMAT_G723_1)) ? G723_SAMPLES : G729_SAMPLES;
 
    switch (dahdip->fmts.dstfmt) {
    case DAHDI_FORMAT_G729A:
        ast_atomic_fetchadd_int(&channels.encoders, +1);
        break;
    case DAHDI_FORMAT_G723_1:
        ast_atomic_fetchadd_int(&channels.encoders, +1);
        break;
    default:
        ast_atomic_fetchadd_int(&channels.decoders, +1);
        break;
    }
 
    return 0;
}

References ao2_bump, ast_assert, ast_atomic_fetchadd_int(), ast_debug, ast_fd_set_flags, ast_log, channels, DAHDI_FORMAT_G723_1, DAHDI_FORMAT_G729A, DAHDI_FORMAT_SLINEAR, dahdi_format_to_cached(), DAHDI_FORMAT_ULAW, channel_usage::decoders, ast_translator::dst_codec, channel_usage::encoders, errno, ast_trans_pvt::f, codec_dahdi_pvt::fd, codec_dahdi_pvt::fmts, ast_frame_subclass::format, G723_SAMPLES, G729_SAMPLES, LOG_ERROR, ast_codec::name, NULL, ast_trans_pvt::pvt, codec_dahdi_pvt::required_samples, codec_dahdi_pvt::softslin, ast_translator::src_codec, ast_frame::subclass, and ast_trans_pvt::t.

Referenced by dahdi_new().

dahdi_wait_for_packet()

static void dahdi_wait_for_packet ( int  fd )

static

Definition at line 417 of file codec_dahdi.c.

{
    struct pollfd p = {0};
    p.fd = fd;
    p.events = POLLIN;
    poll(&p, 1, 10);
}

Referenced by dahdi_decoder_frameout(), and dahdi_encoder_frameout().

dahdi_write_frame()

static void dahdi_write_frame ( struct codec_dahdi_pvt *  dahdip, const uint8_t *  buffer, const ssize_t  count  )

static

Definition at line 359 of file codec_dahdi.c.

{
    int res;
    if (!count) return;
    res = write(dahdip->fd, buffer, count);
    if (-1 == res) {
        ast_log(LOG_ERROR, "Failed to write to transcoder: %s\n", strerror(errno));
    }
    if (count != res) {
        ast_log(LOG_ERROR, "Requested write of %zd bytes, but only wrote %d bytes.\n", count, res);
    }
}

References ast_log, errno, codec_dahdi_pvt::fd, and LOG_ERROR.

Referenced by dahdi_decoder_framein(), and dahdi_encoder_framein().

fakesrc_sample()

static struct ast_frame * fakesrc_sample ( void  )

static

Definition at line 689 of file codec_dahdi.c.

{
    /* Don't bother really trying to test hardware ones. */
    static struct ast_frame f = {
        .frametype = AST_FRAME_VOICE,
        .samples = 160,
        .src = __PRETTY_FUNCTION__
    };
 
    return &f;
}

References AST_FRAME_VOICE, and ast_frame::frametype.

Referenced by register_translator().

find_transcoders()

static int find_transcoders ( void  )

static

Definition at line 807 of file codec_dahdi.c.

{
    struct dahdi_transcoder_info info = { 0, };
    int fd;
 
    if ((fd = open("/dev/dahdi/transcode", O_RDWR)) < 0) {
        ast_log(LOG_ERROR, "Failed to open /dev/dahdi/transcode: %s\n", strerror(errno));
        return 0;
    }
 
    for (info.tcnum = 0; !ioctl(fd, DAHDI_TC_GETINFO, &info); info.tcnum++) {
        ast_verb(2, "Found transcoder '%s'.\n", info.name);
 
        /* 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 & (DAHDI_FORMAT_ULAW | DAHDI_FORMAT_ALAW)) {
            info.dstfmts |= DAHDI_FORMAT_SLINEAR;
            info.dstfmts &= ~(DAHDI_FORMAT_ULAW | DAHDI_FORMAT_ALAW);
        }
        if (info.srcfmts & (DAHDI_FORMAT_ULAW | DAHDI_FORMAT_ALAW)) {
            info.srcfmts |= DAHDI_FORMAT_SLINEAR;
            info.srcfmts &= ~(DAHDI_FORMAT_ULAW | DAHDI_FORMAT_ALAW);
        }
 
        build_translators(info.dstfmts, info.srcfmts);
        ast_atomic_fetchadd_int(&channels.total, info.numchannels / 2);
    }
 
    close(fd);
 
    if (!info.tcnum) {
        ast_verb(2, "No hardware transcoders found.\n");
    }
 
    return 0;
}

References ast_atomic_fetchadd_int(), ast_log, ast_verb, build_translators(), channels, DAHDI_FORMAT_ALAW, DAHDI_FORMAT_SLINEAR, DAHDI_FORMAT_ULAW, errno, sip_to_pjsip::info(), LOG_ERROR, and channel_usage::total.

Referenced by load_module().

get_dahdi_codec()

static const struct ast_codec * get_dahdi_codec ( uint32_t  dahdi_fmt )

static

Definition at line 161 of file codec_dahdi.c.

{
    const struct ast_codec *codec;
 
    static const struct ast_codec dahdi_g723_1 = {
        .name = "g723",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_gsm = {
        .name = "gsm",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_ulaw = {
        .name = "ulaw",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_alaw = {
        .name = "alaw",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_g726 = {
        .name = "g726",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_adpcm = {
        .name = "adpcm",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_slinear = {
        .name = "slin",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_lpc10 = {
        .name = "lpc10",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_g729a = {
        .name = "g729",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_speex = {
        .name = "speex",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
    static const struct ast_codec dahdi_ilbc = {
        .name = "ilbc",
        .type = AST_MEDIA_TYPE_AUDIO,
        .sample_rate = 8000,
    };
 
    switch (dahdi_fmt) {
    case DAHDI_FORMAT_G723_1:
        codec = &dahdi_g723_1;
        break;
    case DAHDI_FORMAT_GSM:
        codec = &dahdi_gsm;
        break;
    case DAHDI_FORMAT_ULAW:
        codec = &dahdi_ulaw;
        break;
    case DAHDI_FORMAT_ALAW:
        codec = &dahdi_alaw;
        break;
    case DAHDI_FORMAT_G726:
        codec = &dahdi_g726;
        break;
    case DAHDI_FORMAT_ADPCM:
        codec = &dahdi_adpcm;
        break;
    case DAHDI_FORMAT_SLINEAR:
        codec = &dahdi_slinear;
        break;
    case DAHDI_FORMAT_LPC10:
        codec = &dahdi_lpc10;
        break;
    case DAHDI_FORMAT_G729A:
        codec = &dahdi_g729a;
        break;
    case DAHDI_FORMAT_SPEEX:
        codec = &dahdi_speex;
        break;
    case DAHDI_FORMAT_ILBC:
        codec = &dahdi_ilbc;
        break;
    default:
        codec = NULL;
        break;
    }
 
    return codec;
}

References AST_MEDIA_TYPE_AUDIO, DAHDI_FORMAT_ADPCM, DAHDI_FORMAT_ALAW, DAHDI_FORMAT_G723_1, DAHDI_FORMAT_G726, DAHDI_FORMAT_G729A, DAHDI_FORMAT_GSM, DAHDI_FORMAT_ILBC, DAHDI_FORMAT_LPC10, DAHDI_FORMAT_SLINEAR, DAHDI_FORMAT_SPEEX, DAHDI_FORMAT_ULAW, ast_codec::name, and NULL.

Referenced by register_translator().

handle_cli_transcoder_show()

static char * handle_cli_transcoder_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 331 of file codec_dahdi.c.

{
    struct channel_usage copy;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "transcoder show";
        e->usage =
            "Usage: transcoder show\n"
            "       Displays channel utilization of DAHDI transcoder(s).\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 2)
        return CLI_SHOWUSAGE;
 
    copy = channels;
 
    if (copy.total == 0)
        ast_cli(a->fd, "No DAHDI transcoders found.\n");
    else
        ast_cli(a->fd, "%d/%d encoders/decoders of %d channels are in use.\n", copy.encoders, copy.decoders, copy.total);
 
    return CLI_SUCCESS;
}

References a, ast_cli(), channels, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, copy(), NULL, and ast_cli_entry::usage.

is_already_registered()

static bool is_already_registered ( uint32_t  dstfmt, uint32_t  srcfmt  )

static

Definition at line 770 of file codec_dahdi.c.

{
    bool res = false;
    const struct translator *zt;
 
    AST_LIST_TRAVERSE(&translators, zt, entry) {
        if ((zt->src_dahdi_fmt == srcfmt) && (zt->dst_dahdi_fmt == dstfmt)) {
            res = true;
            break;
        }
    }
 
    return res;
}

References AST_LIST_TRAVERSE, translator::dst_dahdi_fmt, and translator::src_dahdi_fmt.

Referenced by build_translators().

is_encoder()

static bool is_encoder ( uint32_t  src_dahdi_fmt )

static

Definition at line 701 of file codec_dahdi.c.

{
    return ((src_dahdi_fmt & (DAHDI_FORMAT_ULAW | DAHDI_FORMAT_ALAW | DAHDI_FORMAT_SLINEAR)) > 0);
}

References DAHDI_FORMAT_ALAW, DAHDI_FORMAT_SLINEAR, and DAHDI_FORMAT_ULAW.

Referenced by register_translator().

lintoulaw()

static int lintoulaw ( struct ast_trans_pvt *  pvt, struct ast_frame *  f  )

static

Definition at line 311 of file codec_dahdi.c.

{
    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;
}

References AST_LIN2MU, ast_log, ast_frame::data, LOG_ERROR, ast_frame::ptr, ast_trans_pvt::pvt, ast_frame::samples, codec_dahdi_pvt::samples_in_buffer, and codec_dahdi_pvt::ulaw_buffer.

Referenced by dahdi_encoder_framein().

load_module()

static int load_module ( void  )

static

Definition at line 861 of file codec_dahdi.c.

{
    find_transcoders();
    ast_cli_register_multiple(cli, ARRAY_LEN(cli));
    return AST_MODULE_LOAD_SUCCESS;
}

References ARRAY_LEN, ast_cli_register_multiple, AST_MODULE_LOAD_SUCCESS, cli, and find_transcoders().

register_translator()

static int register_translator ( uint32_t  dst_dahdi_fmt, uint32_t  src_dahdi_fmt  )

static

Definition at line 707 of file codec_dahdi.c.

{
    const struct ast_codec *dst_codec;
    const struct ast_codec *src_codec;
    struct translator *zt;
    int res;
 
    dst_codec = get_dahdi_codec(dst_dahdi_fmt);
    src_codec = get_dahdi_codec(src_dahdi_fmt);
    if (!dst_codec || !src_codec) {
        return -1;
    }
 
    if (!(zt = ast_calloc(1, sizeof(*zt)))) {
        return -1;
    }
 
    zt->src_dahdi_fmt = src_dahdi_fmt;
    zt->dst_dahdi_fmt = dst_dahdi_fmt;
 
    snprintf(zt->t.name, sizeof(zt->t.name), "dahdi_%s_to_%s",
        src_codec->name, dst_codec->name);
 
    memcpy(&zt->t.src_codec, src_codec, sizeof(*src_codec));
    memcpy(&zt->t.dst_codec, dst_codec, sizeof(*dst_codec));
    zt->t.buf_size = BUFFER_SIZE;
    if (is_encoder(src_dahdi_fmt)) {
        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);
        return -1;
    }
 
    AST_LIST_INSERT_HEAD(&translators, zt, entry);
 
    return res;
}

References ast_calloc, ast_free, AST_LIST_INSERT_HEAD, ast_register_translator, ast_translator::buf_size, ast_translator::buffer_samples, BUFFER_SIZE, dahdi_decoder_framein(), dahdi_decoder_frameout(), dahdi_destroy(), dahdi_encoder_framein(), dahdi_encoder_frameout(), dahdi_new(), ast_translator::desc_size, ast_translator::destroy, ast_translator::dst_codec, translator::dst_dahdi_fmt, fakesrc_sample(), ast_translator::framein, ast_translator::frameout, get_dahdi_codec(), is_encoder(), ast_codec::name, ast_translator::name, ast_translator::native_plc, ast_translator::newpvt, ast_translator::sample, ast_translator::src_codec, translator::src_dahdi_fmt, and translator::t.

Referenced by build_translators().

reload()

static int reload ( void  )

static

Definition at line 848 of file codec_dahdi.c.

{
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS.

ulawtolin()

static int ulawtolin ( struct ast_trans_pvt *  pvt, int  samples  )

static

Definition at line 295 of file codec_dahdi.c.

{
    struct codec_dahdi_pvt *dahdip = pvt->pvt;
    int i = 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;
}

References AST_MULAW, ast_trans_pvt::datalen, ast_trans_pvt::i16, ast_trans_pvt::outbuf, ast_trans_pvt::pvt, and codec_dahdi_pvt::ulaw_buffer.

Referenced by dahdi_decoder_frameout().

unload_module()

static int unload_module ( void  )

static

Definition at line 853 of file codec_dahdi.c.

{
    ast_cli_unregister_multiple(cli, ARRAY_LEN(cli));
    unregister_translators();
 
    return 0;
}

References ARRAY_LEN, ast_cli_unregister_multiple(), cli, and unregister_translators().

unregister_translators()

static void unregister_translators ( void  )

static

Definition at line 757 of file codec_dahdi.c.

{
    struct translator *cur;
 
    AST_LIST_LOCK(&translators);
    while ((cur = AST_LIST_REMOVE_HEAD(&translators, entry))) {
        ast_unregister_translator(&cur->t);
        ast_free(cur);
    }
    AST_LIST_UNLOCK(&translators);
}

References ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_unregister_translator(), and translator::t.

Referenced by unload_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Generic DAHDI Transcoder Codec Translator" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, }

static

Definition at line 873 of file codec_dahdi.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 873 of file codec_dahdi.c.

channels

struct channel_usage channels

static

Referenced by action_coreshowchannels(), action_dahdishowchannels(), action_status(), app_to_json(), ast_bridge_peers(), ast_bridge_peers_nolock(), ast_bridge_transfer_attended(), ast_bridge_transfer_blind(), broadcast_exec(), channels_scrape_cb(), check_header(), control_list_create(), dahdi_destroy(), dahdi_translate(), do_broadcast(), find_transcoders(), get_transferee(), handle_chanlist(), handle_cli_transcoder_show(), main(), manage_calls(), set_transfer_variables_all(), stasis_app_to_cli(), and two_bridge_attended_transfer().

cli

struct ast_cli_entry cli[]

static

Initial value:

= {
    { .handler =  handle_cli_transcoder_show , .summary =  "Display DAHDI transcoder utilization." ,}
}

Definition at line 265 of file codec_dahdi.c.

Referenced by cli_complete_subscription_callid(), cli_complete_subscription_common(), cli_list_subscriptions_detail(), cli_list_subscriptions_inout(), cli_show_subscription_common(), cli_show_subscription_inout(), cli_show_subscriptions_detail(), cli_show_subscriptions_inout(), load_module(), and unload_module().

translators

struct translators translators = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static