translate.c File Reference

Translate via the use of pseudo channels. More...

#include "asterisk.h"
#include <sys/time.h>
#include <sys/resource.h>
#include <math.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/translate.h"
#include "asterisk/module.h"
#include "asterisk/frame.h"
#include "asterisk/sched.h"
#include "asterisk/cli.h"
#include "asterisk/term.h"
#include "asterisk/format.h"
#include "asterisk/linkedlists.h"

Include dependency graph for translate.c:

Go to the source code of this file.

Data Structures
struct	translator_path
struct	translators
	the list of translators More...

Macros
#define	format_sample_rate_absdiff(fmt1, fmt2)
#define	GROW_INDEX   16
#define	INIT_INDEX   32
#define	MAX_RECALC   1000

Functions
int	__ast_register_translator (struct ast_translator *t, struct ast_module *mod)
	register codec translator More...
static int	add_codec2index (struct ast_codec *codec)
struct ast_frame *	ast_trans_frameout (struct ast_trans_pvt *pvt, int datalen, int samples)
	generic frameout routine. If samples and datalen are 0, take whatever is in pvt and reset them, otherwise take the values in the caller and leave alone the pvt values. More...
struct ast_frame *	ast_translate (struct ast_trans_pvt *path, struct ast_frame *f, int consume)
	do the actual translation More...
void	ast_translate_available_formats (struct ast_format_cap *dest, struct ast_format_cap *src, struct ast_format_cap *result)
	Find available formats. More...
int	ast_translate_init (void)
	Initialize the translation matrix and index to format conversion table. More...
unsigned int	ast_translate_path_steps (struct ast_format *dst_format, struct ast_format *src_format)
	Returns the number of steps required to convert from 'src' to 'dest'. More...
const char *	ast_translate_path_to_str (struct ast_trans_pvt *p, struct ast_str **str)
	Puts a string representation of the translation path into outbuf. More...
void	ast_translator_activate (struct ast_translator *t)
	Activate a previously deactivated translator. More...
int	ast_translator_best_choice (struct ast_format_cap *dst_cap, struct ast_format_cap *src_cap, struct ast_format **dst_fmt_out, struct ast_format **src_fmt_out)
	Calculate our best translator source format, given costs, and a desired destination. More...
struct ast_trans_pvt *	ast_translator_build_path (struct ast_format *dst, struct ast_format *src)
	Build a chain of translators based upon the given source and dest formats. More...
void	ast_translator_deactivate (struct ast_translator *t)
	Deactivate a translator. More...
void	ast_translator_free_path (struct ast_trans_pvt *p)
	Frees a translator path Frees the given translator path structure. More...
int	ast_unregister_translator (struct ast_translator *t)
	unregister codec translator More...
static void	check_translation_path (struct ast_format_cap *dest, struct ast_format_cap *src, struct ast_format_cap *result, struct ast_format *src_fmt, enum ast_media_type type)
static int	codec2index (struct ast_codec *codec)
static void	codec_append_name (const struct ast_codec *codec, struct ast_str **buf)
static int	codec_to_index (unsigned int id)
static char *	complete_trans_path_choice (const char *word)
static struct ast_frame *	default_frameout (struct ast_trans_pvt *pvt)
static void	destroy (struct ast_trans_pvt *pvt)
static int	format2index (struct ast_format *format)
static int	framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
	framein wrapper, deals with bound checks. More...
static void	generate_computational_cost (struct ast_translator *t, int seconds)
static struct ast_frame *	generate_interpolated_slin (struct ast_trans_pvt *p, struct ast_frame *f)
static int	generate_table_cost (struct ast_codec *src, struct ast_codec *dst)
static char *	handle_cli_core_show_translation (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	handle_cli_recalc (struct ast_cli_args *a)
static char *	handle_show_translation_path (struct ast_cli_args *a, const char *codec_name, unsigned int sample_rate)
static char *	handle_show_translation_table (struct ast_cli_args *a)
static struct ast_codec *	index2codec (int index)
static void	matrix_clear (void)
static struct translator_path *	matrix_get (unsigned int x, unsigned int y)
static void	matrix_rebuild (int samples)
	rebuild a translation matrix. More...
static int	matrix_resize (int init)
static struct ast_trans_pvt *	newpvt (struct ast_translator *t, struct ast_format *explicit_dst)
	Allocate the descriptor, required outbuf space, and possibly desc. More...
static void	translate_shutdown (void)

Variables
static unsigned int *	__indextable
	table for converting index to format values. More...
static struct translator_path **	__matrix
	a matrix that, for any pair of supported formats, indicates the total cost of translation and the first step. The full path can be reconstructed iterating on the matrix until step->dstfmt == desired_format. More...
static struct ast_cli_entry	cli_translate []
static int	cur_max_index
static int	index_size
static ast_rwlock_t	tablelock
static struct translators	translators = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

Detailed Description

Translate via the use of pseudo channels.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file translate.c.

Macro Definition Documentation

format_sample_rate_absdiff

#define format_sample_rate_absdiff	(		fmt1,
			fmt2
	)

Value:

    ({ \
    unsigned int rate1 = ast_format_get_sample_rate(fmt1); \
    unsigned int rate2 = ast_format_get_sample_rate(fmt2); \
    (rate1 > rate2 ? rate1 - rate2 : rate2 - rate1); \
})

Calculate the absolute difference between sample rate of two formats.

Definition at line 1395 of file translate.c.

GROW_INDEX

#define GROW_INDEX   16

Definition at line 92 of file translate.c.

INIT_INDEX

#define INIT_INDEX   32

Definition at line 90 of file translate.c.

MAX_RECALC

#define MAX_RECALC   1000

Todo:

TODO: sample frames for each supported input format. We build this on the fly, by taking an SLIN frame and using the existing converter to play with it.

max sample recalc

Definition at line 54 of file translate.c.

Function Documentation

__ast_register_translator()

int __ast_register_translator	(	struct ast_translator *	t,
		struct ast_module *	mod
	)

register codec translator

Register a translator This registers a codec translator with asterisk.

Definition at line 1237 of file translate.c.

{
    struct ast_translator *u;
    char tmp[80];
    RAII_VAR(struct ast_codec *, src_codec, NULL, ao2_cleanup);
    RAII_VAR(struct ast_codec *, dst_codec, NULL, ao2_cleanup);
 
    src_codec = ast_codec_get(t->src_codec.name, t->src_codec.type, t->src_codec.sample_rate);
    if (!src_codec) {
        ast_assert(0);
        ast_log(LOG_WARNING, "Failed to register translator: unknown source codec %s\n", t->src_codec.name);
        return -1;
    }
 
    dst_codec = ast_codec_get(t->dst_codec.name, t->dst_codec.type, t->dst_codec.sample_rate);
    if (!dst_codec) {
        ast_log(LOG_WARNING, "Failed to register translator: unknown destination codec %s\n", t->dst_codec.name);
        return -1;
    }
 
    if (add_codec2index(src_codec) || add_codec2index(dst_codec)) {
        if (matrix_resize(0)) {
            ast_log(LOG_WARNING, "Translator matrix can not represent any more translators.  Out of resources.\n");
            return -1;
        }
        add_codec2index(src_codec);
        add_codec2index(dst_codec);
    }
 
    if (!mod) {
        ast_log(LOG_WARNING, "Missing module pointer, you need to supply one\n");
        return -1;
    }
 
    if (!t->buf_size) {
        ast_log(LOG_WARNING, "empty buf size, you need to supply one\n");
        return -1;
    }
    if (!t->table_cost && !(t->table_cost = generate_table_cost(src_codec, dst_codec))) {
        ast_log(LOG_WARNING, "Table cost could not be generated for %s, "
            "Please set table_cost variable on translator.\n", t->name);
        return -1;
    }
 
    t->module = mod;
    t->src_fmt_index = codec2index(src_codec);
    t->dst_fmt_index = codec2index(dst_codec);
    t->active = 1;
 
    if (t->src_fmt_index < 0 || t->dst_fmt_index < 0) {
        ast_log(LOG_WARNING, "Invalid translator path: (%s codec is not valid)\n", t->src_fmt_index < 0 ? "starting" : "ending");
        return -1;
    }
    if (t->src_fmt_index >= cur_max_index) {
        ast_log(LOG_WARNING, "Source codec %s is larger than cur_max_index\n", t->src_codec.name);
        return -1;
    }
 
    if (t->dst_fmt_index >= cur_max_index) {
        ast_log(LOG_WARNING, "Destination codec %s is larger than cur_max_index\n", t->dst_codec.name);
        return -1;
    }
 
    if (t->buf_size) {
        /*
         * Align buf_size properly, rounding up to the machine-specific
         * alignment for pointers.
         */
        struct _test_align { void *a, *b; } p;
        int align = (char *)&p.b - (char *)&p.a;
 
        t->buf_size = ((t->buf_size + align - 1) / align) * align;
    }
 
    if (t->frameout == NULL) {
        t->frameout = default_frameout;
    }
 
    generate_computational_cost(t, 1);
 
    ast_verb(5, "Registered translator '%s' from codec %s to %s, table cost, %d, computational cost %d\n",
         term_color(tmp, t->name, COLOR_MAGENTA, COLOR_BLACK, sizeof(tmp)),
         t->src_codec.name, t->dst_codec.name, t->table_cost, t->comp_cost);
 
    AST_RWLIST_WRLOCK(&translators);
 
    /* find any existing translators that provide this same srcfmt/dstfmt,
       and put this one in order based on computational cost */
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&translators, u, list) {
        if ((u->src_fmt_index == t->src_fmt_index) &&
            (u->dst_fmt_index == t->dst_fmt_index) &&
            (u->comp_cost > t->comp_cost)) {
            AST_RWLIST_INSERT_BEFORE_CURRENT(t, list);
            t = NULL;
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    /* if no existing translator was found for this codec combination,
       add it to the beginning of the list */
    if (t) {
        AST_RWLIST_INSERT_HEAD(&translators, t, list);
    }
 
    matrix_rebuild(0);
 
    AST_RWLIST_UNLOCK(&translators);
 
    return 0;
}

References a, ast_translator::active, add_codec2index(), ao2_cleanup, ast_assert, ast_codec_get(), ast_log, AST_RWLIST_INSERT_BEFORE_CURRENT, AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, b, ast_translator::buf_size, codec2index(), COLOR_BLACK, COLOR_MAGENTA, ast_translator::comp_cost, cur_max_index, default_frameout(), ast_translator::dst_codec, ast_translator::dst_fmt_index, ast_translator::frameout, generate_computational_cost(), generate_table_cost(), LOG_WARNING, matrix_rebuild(), matrix_resize(), ast_translator::module, ast_codec::name, ast_translator::name, NULL, RAII_VAR, ast_codec::sample_rate, ast_translator::src_codec, ast_translator::src_fmt_index, ast_translator::table_cost, term_color(), tmp(), and ast_codec::type.

add_codec2index()

static int add_codec2index ( struct ast_codec *  codec )

static

Definition at line 148 of file translate.c.

{
    if (codec2index(codec) != -1) {
        /* format is already already indexed */
        return 0;
    }
 
    ast_rwlock_wrlock(&tablelock);
    if (cur_max_index == (index_size)) {
        ast_rwlock_unlock(&tablelock);
        return -1; /* hit max length */
    }
    __indextable[cur_max_index] = codec->id;
    cur_max_index++;
    ast_rwlock_unlock(&tablelock);
 
    return 0;
}

References __indextable, ast_rwlock_unlock, ast_rwlock_wrlock, codec2index(), cur_max_index, ast_codec::id, index_size, and tablelock.

Referenced by __ast_register_translator().

ast_trans_frameout()

struct ast_frame * ast_trans_frameout	(	struct ast_trans_pvt *	pvt,
		int	datalen,
		int	samples
	)

generic frameout routine. If samples and datalen are 0, take whatever is in pvt and reset them, otherwise take the values in the caller and leave alone the pvt values.

generic frameout function

Definition at line 439 of file translate.c.

{
    struct ast_frame *f = &pvt->f;
 
    if (samples) {
        f->samples = samples;
    } else {
        if (pvt->samples == 0) {
            return NULL;
        }
        f->samples = pvt->samples;
        pvt->samples = 0;
    }
    if (datalen) {
        f->datalen = datalen;
        f->data.ptr = pvt->outbuf.c;
    } else {
        f->datalen = pvt->datalen;
        if (!f->datalen) {
            f->data.ptr = NULL;
        } else {
            f->data.ptr = pvt->outbuf.c;
        }
        pvt->datalen = 0;
    }
 
    return ast_frisolate(f);
}

References ast_frisolate, ast_trans_pvt::c, ast_frame::data, ast_frame::datalen, ast_trans_pvt::datalen, ast_trans_pvt::f, NULL, ast_trans_pvt::outbuf, ast_frame::ptr, ast_frame::samples, and ast_trans_pvt::samples.

Referenced by default_frameout(), lintoadpcm_frameout(), lintocodec2_frameout(), lintogsm_frameout(), lintoilbc_frameout(), lintolpc10_frameout(), and lintospeex_frameout().

ast_translate()

struct ast_frame * ast_translate	(	struct ast_trans_pvt *	path,
		struct ast_frame *	f,
		int	consume
	)

do the actual translation

translates one or more frames Apply an input frame into the translator and receive zero or one output frames. Consume determines whether the original frame should be freed. In case the frame type is AST_FRAME_RTCP, the frame is not translated but passed to the translator codecs via the feedback callback, and a pointer to ast_null_frame is returned after that.

Definition at line 566 of file translate.c.

{
    struct ast_trans_pvt *p = path;
    struct ast_frame *out;
    struct timeval delivery;
    int has_timing_info;
    long ts;
    long len;
    int seqno;
 
    if (f->frametype == AST_FRAME_RTCP) {
        /* Just pass the feedback to the right callback, if it exists.
         * This "translation" does nothing so return a null frame. */
        struct ast_trans_pvt *tp;
        for (tp = p; tp; tp = tp->next) {
            if (tp->t->feedback)
                tp->t->feedback(tp, f);
        }
        return &ast_null_frame;
    }
 
    has_timing_info = ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO);
    ts = f->ts;
    len = f->len;
    seqno = f->seqno;
 
    if (!ast_tvzero(f->delivery)) {
        if (!ast_tvzero(path->nextin)) {
            /* Make sure this is in line with what we were expecting */
            if (!ast_tveq(path->nextin, f->delivery)) {
                /* The time has changed between what we expected and this
                   most recent time on the new packet.  If we have a
                   valid prediction adjust our output time appropriately */
                if (!ast_tvzero(path->nextout)) {
                    path->nextout = ast_tvadd(path->nextout,
                                  ast_tvsub(f->delivery, path->nextin));
                }
                path->nextin = f->delivery;
            }
        } else {
            /* This is our first pass.  Make sure the timing looks good */
            path->nextin = f->delivery;
            path->nextout = f->delivery;
        }
        /* Predict next incoming sample */
        path->nextin = ast_tvadd(path->nextin, ast_samp2tv(
             f->samples, ast_format_get_sample_rate(f->subclass.format)));
    }
    delivery = f->delivery;
    for (out = f; out && p ; p = p->next) {
        struct ast_frame *current = out;
 
        do {
            framein(p, current);
            current = AST_LIST_NEXT(current, frame_list);
        } while (current);
        if (out != f) {
            ast_frfree(out);
        }
        out = p->t->frameout(p);
    }
 
    if (!out) {
        out = generate_interpolated_slin(path, f);
    }
 
    if (out) {
        /* we have a frame, play with times */
        if (!ast_tvzero(delivery)) {
            struct ast_frame *current = out;
 
            do {
                /* Regenerate prediction after a discontinuity */
                if (ast_tvzero(path->nextout)) {
                    path->nextout = ast_tvnow();
                }
 
                /* Use next predicted outgoing timestamp */
                current->delivery = path->nextout;
 
                /* Invalidate prediction if we're entering a silence period */
                if (current->frametype == AST_FRAME_CNG) {
                    path->nextout = ast_tv(0, 0);
                /* Predict next outgoing timestamp from samples in this
                   frame. */
                } else {
                    path->nextout = ast_tvadd(path->nextout, ast_samp2tv(
                        current->samples, ast_format_get_sample_rate(current->subclass.format)));
                }
 
                if (f->samples != current->samples && ast_test_flag(current, AST_FRFLAG_HAS_TIMING_INFO)) {
                    ast_debug(4, "Sample size different %d vs %d\n", f->samples, current->samples);
                    ast_clear_flag(current, AST_FRFLAG_HAS_TIMING_INFO);
                }
                current = AST_LIST_NEXT(current, frame_list);
            } while (current);
        } else {
            out->delivery = ast_tv(0, 0);
            ast_set2_flag(out, has_timing_info, AST_FRFLAG_HAS_TIMING_INFO);
            if (has_timing_info) {
                out->ts = ts;
                out->len = len;
                out->seqno = seqno;
            }
            /* Invalidate prediction if we're entering a silence period */
            if (out->frametype == AST_FRAME_CNG) {
                path->nextout = ast_tv(0, 0);
            }
        }
    }
    if (consume) {
        ast_frfree(f);
    }
    return out;
}

References ast_clear_flag, ast_debug, ast_format_get_sample_rate(), AST_FRAME_CNG, AST_FRAME_RTCP, AST_FRFLAG_HAS_TIMING_INFO, ast_frfree, AST_LIST_NEXT, ast_null_frame, ast_samp2tv(), ast_set2_flag, ast_test_flag, ast_tv(), ast_tvadd(), ast_tveq(), ast_tvnow(), ast_tvsub(), ast_tvzero(), current, ast_frame::delivery, ast_trans_pvt::f, ast_translator::feedback, ast_frame_subclass::format, framein(), ast_translator::frameout, ast_frame::frametype, generate_interpolated_slin(), len(), ast_frame::len, ast_trans_pvt::next, ast_trans_pvt::nextin, ast_trans_pvt::nextout, out, ast_frame::samples, ast_frame::seqno, ast_frame::subclass, ast_trans_pvt::t, and ast_frame::ts.

Referenced by __ast_read(), ast_slinfactory_feed(), ast_write_stream(), ast_writestream(), audiohook_list_translate_to_native(), audiohook_list_translate_to_slin(), audiohook_read_frame_helper(), conf_run(), fax_gateway_framehook(), and softmix_process_write_audio().

ast_translate_available_formats()

void ast_translate_available_formats	(	struct ast_format_cap *	dest,
		struct ast_format_cap *	src,
		struct ast_format_cap *	result
	)

Find available formats.

Parameters

	dest	possible destination formats
	src	source formats
[out]	result	capabilities structure to store available formats in returns the destination formats that are available in the source or translatable

The result will include all formats from 'dest' that are either present in 'src' or translatable from a format present in 'src'.

Note

Only a single audio format and a single video format can be present in 'src', or the function will produce unexpected results.

Definition at line 1616 of file translate.c.

{
    struct ast_format *cur_dest, *cur_src;
    int index;
 
    for (index = 0; index < ast_format_cap_count(dest); ++index) {
        if (!(cur_dest = ast_format_cap_get_format(dest, index))) {
            continue;
        }
 
        /* We give preference to a joint format structure if possible */
        if ((cur_src = ast_format_cap_get_compatible_format(src, cur_dest))) {
            ast_format_cap_append(result, cur_src, 0);
            ao2_ref(cur_src, -1);
        } else {
            /* Otherwise we just use the destination format */
            ast_format_cap_append(result, cur_dest, 0);
        }
        ao2_ref(cur_dest, -1);
    }
 
    /* if we don't have a source format, we just have to try all
       possible destination formats */
    if (!src) {
        return;
    }
 
    for (index = 0; index < ast_format_cap_count(src); ++index) {
        if (!(cur_src = ast_format_cap_get_format(src, index))) {
            continue;
        }
 
        AST_RWLIST_RDLOCK(&translators);
        check_translation_path(dest, src, result,
                       cur_src, AST_MEDIA_TYPE_AUDIO);
        check_translation_path(dest, src, result,
                       cur_src, AST_MEDIA_TYPE_VIDEO);
        AST_RWLIST_UNLOCK(&translators);
        ao2_ref(cur_src, -1);
    }
}

References ao2_ref, ast_format_cap_append, ast_format_cap_count(), ast_format_cap_get_compatible_format(), ast_format_cap_get_format(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, check_translation_path(), and result.

Referenced by ast_rtp_instance_available_formats().

ast_translate_init()

int ast_translate_init

(

void

)

Initialize the translation matrix and index to format conversion table.

Return values

0	on success
-1	on failure

Definition at line 1675 of file translate.c.

{
    int res = 0;
    ast_rwlock_init(&tablelock);
    res = matrix_resize(1);
    res |= ast_cli_register_multiple(cli_translate, ARRAY_LEN(cli_translate));
    ast_register_cleanup(translate_shutdown);
    return res;
}

References ARRAY_LEN, ast_cli_register_multiple, ast_register_cleanup(), ast_rwlock_init, cli_translate, matrix_resize(), tablelock, and translate_shutdown().

Referenced by asterisk_daemon().

ast_translate_path_steps()

unsigned int ast_translate_path_steps	(	struct ast_format *	dest,
		struct ast_format *	src
	)

Returns the number of steps required to convert from 'src' to 'dest'.

Parameters

dest	destination format
src	source format

Returns

the number of translation steps required

Return values

-1	if no path is available

Definition at line 1536 of file translate.c.

{
    unsigned int res = -1;
    /* convert bitwise format numbers into array indices */
    int src = format2index(src_format);
    int dest = format2index(dst_format);
 
    if (src < 0 || dest < 0) {
        ast_log(LOG_WARNING, "No translator path: (%s codec is not valid)\n", src < 0 ? "starting" : "ending");
        return -1;
    }
    AST_RWLIST_RDLOCK(&translators);
 
    if (matrix_get(src, dest)->step) {
        res = matrix_get(src, dest)->multistep + 1;
    }
 
    AST_RWLIST_UNLOCK(&translators);
 
    return res;
}

References ast_log, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, format2index(), LOG_WARNING, matrix_get(), and translator_path::multistep.

Referenced by ast_channel_make_compatible_helper().

ast_translate_path_to_str()

const char * ast_translate_path_to_str	(	struct ast_trans_pvt *	t,
		struct ast_str **	str
	)

Puts a string representation of the translation path into outbuf.

Parameters

t	translator structure containing the translation path
str	ast_str output buffer

Returns

on success pointer to beginning of outbuf

Return values

""	on failure

Definition at line 930 of file translate.c.

{
    if (!p || !p->t) {
        return "";
    }
 
    ast_str_reset(*str);
    codec_append_name(&p->t->src_codec, str);
    while (p) {
        ast_str_append(str, 0, "->");
        codec_append_name(&p->t->dst_codec, str);
        p = p->next;
    }
 
    return ast_str_buffer(*str);
}

References ast_str_append(), ast_str_buffer(), ast_str_reset(), codec_append_name(), ast_translator::dst_codec, ast_trans_pvt::next, ast_translator::src_codec, str, and ast_trans_pvt::t.

Referenced by chan_pjsip_write_stream(), generate_status(), handle_showchan(), and serialize_showchan().

ast_translator_activate()

void ast_translator_activate

(

struct ast_translator *

t

)

Activate a previously deactivated translator.

Parameters

t	translator to activate

Enables the specified translator for use.

Definition at line 1378 of file translate.c.

{
    AST_RWLIST_WRLOCK(&translators);
    t->active = 1;
    matrix_rebuild(0);
    AST_RWLIST_UNLOCK(&translators);
}

References ast_translator::active, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and matrix_rebuild().

ast_translator_best_choice()

int ast_translator_best_choice	(	struct ast_format_cap *	dst_cap,
		struct ast_format_cap *	src_cap,
		struct ast_format **	dst_fmt_out,
		struct ast_format **	src_fmt_out
	)

Calculate our best translator source format, given costs, and a desired destination.

Chooses the best translation path.

Definition at line 1402 of file translate.c.

{
    unsigned int besttablecost = INT_MAX;
    unsigned int beststeps = INT_MAX;
    struct ast_format *fmt;
    struct ast_format *dst;
    struct ast_format *src;
    RAII_VAR(struct ast_format *, best, NULL, ao2_cleanup);
    RAII_VAR(struct ast_format *, bestdst, NULL, ao2_cleanup);
    struct ast_format_cap *joint_cap;
    int i;
    int j;
 
    if (ast_format_cap_empty(dst_cap) || ast_format_cap_empty(src_cap)) {
        ast_log(LOG_ERROR, "Cannot determine best translation path since one capability supports no formats\n");
        return -1;
    }
 
    joint_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!joint_cap) {
        return -1;
    }
    ast_format_cap_get_compatible(dst_cap, src_cap, joint_cap);
 
    for (i = 0; i < ast_format_cap_count(joint_cap); ++i, ao2_cleanup(fmt)) {
        fmt = ast_format_cap_get_format(joint_cap, i);
        if (!fmt
            || ast_format_get_type(fmt) != AST_MEDIA_TYPE_AUDIO) {
            continue;
        }
 
        if (!best
            || ast_format_get_sample_rate(best) < ast_format_get_sample_rate(fmt)) {
            ao2_replace(best, fmt);
        }
    }
    ao2_ref(joint_cap, -1);
 
    if (best) {
        ao2_replace(*dst_fmt_out, best);
        ao2_replace(*src_fmt_out, best);
        return 0;
    }
 
    /* need to translate */
    AST_RWLIST_RDLOCK(&translators);
    for (i = 0; i < ast_format_cap_count(dst_cap); ++i, ao2_cleanup(dst)) {
        dst = ast_format_cap_get_format(dst_cap, i);
        if (!dst
            || ast_format_get_type(dst) != AST_MEDIA_TYPE_AUDIO) {
            continue;
        }
 
        for (j = 0; j < ast_format_cap_count(src_cap); ++j, ao2_cleanup(src)) {
            int x;
            int y;
 
            src = ast_format_cap_get_format(src_cap, j);
            if (!src
                || ast_format_get_type(src) != AST_MEDIA_TYPE_AUDIO) {
                continue;
            }
 
            x = format2index(src);
            y = format2index(dst);
            if (x < 0 || y < 0) {
                continue;
            }
            if (!matrix_get(x, y) || !(matrix_get(x, y)->step)) {
                continue;
            }
            if (matrix_get(x, y)->table_cost < besttablecost
                || matrix_get(x, y)->multistep < beststeps) {
                /* better than what we have so far */
                ao2_replace(best, src);
                ao2_replace(bestdst, dst);
                besttablecost = matrix_get(x, y)->table_cost;
                beststeps = matrix_get(x, y)->multistep;
            } else if (matrix_get(x, y)->table_cost == besttablecost
                    && matrix_get(x, y)->multistep == beststeps) {
                int replace = 0;
                unsigned int gap_selected = format_sample_rate_absdiff(best, bestdst);
                unsigned int gap_current = format_sample_rate_absdiff(src, dst);
 
                if (gap_current < gap_selected) {
                    /* better than what we have so far */
                    replace = 1;
                } else if (gap_current == gap_selected) {
                    int src_quality, best_quality;
                    struct ast_codec *src_codec, *best_codec;
 
                    src_codec = ast_format_get_codec(src);
                    best_codec = ast_format_get_codec(best);
                    src_quality = src_codec->quality;
                    best_quality = best_codec->quality;
 
                    ao2_cleanup(src_codec);
                    ao2_cleanup(best_codec);
 
                    /* We have a tie, so choose the format with the higher quality, if they differ. */
                    if (src_quality > best_quality) {
                        /* Better than what we had before. */
                        replace = 1;
                        ast_debug(2, "Tiebreaker: preferring format %s (%d) to %s (%d)\n", ast_format_get_name(src), src_quality,
                            ast_format_get_name(best), best_quality);
                    } else {
                        /* This isn't necessarily indicative of a problem, but in reality this shouldn't really happen, unless
                         * there are 2 formats that are basically the same. */
                        ast_debug(1, "Completely ambiguous tie between formats %s and %s (quality %d): sticking with %s, but this is arbitrary\n",
                            ast_format_get_name(src), ast_format_get_name(best), best_quality, ast_format_get_name(best));
                    }
                }
                if (replace) {
                    ao2_replace(best, src);
                    ao2_replace(bestdst, dst);
                    besttablecost = matrix_get(x, y)->table_cost;
                    beststeps = matrix_get(x, y)->multistep;
                }
            }
        }
    }
    AST_RWLIST_UNLOCK(&translators);
 
    if (!best) {
        return -1;
    }
    ao2_replace(*dst_fmt_out, bestdst);
    ao2_replace(*src_fmt_out, best);
    return 0;
}

References ao2_cleanup, ao2_ref, ao2_replace, ast_debug, ast_format_cap_alloc, ast_format_cap_count(), ast_format_cap_empty(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_compatible(), ast_format_cap_get_format(), ast_format_get_codec(), ast_format_get_name(), ast_format_get_sample_rate(), ast_format_get_type(), ast_log, AST_MEDIA_TYPE_AUDIO, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, format2index(), format_sample_rate_absdiff, LOG_ERROR, matrix_get(), translator_path::multistep, NULL, ast_codec::quality, RAII_VAR, replace(), and translator_path::table_cost.

Referenced by ast_channel_make_compatible_helper(), ast_speech_new(), iax2_request(), local_request_with_stream_topology(), request_channel(), and set_format().

ast_translator_build_path()

struct ast_trans_pvt * ast_translator_build_path	(	struct ast_format *	dst,
		struct ast_format *	src
	)

Build a chain of translators based upon the given source and dest formats.

Builds a translator path Build a path (possibly NULL) from source to dest.

Definition at line 486 of file translate.c.

{
    struct ast_trans_pvt *head = NULL, *tail = NULL;
    int src_index, dst_index;
 
    src_index = format2index(src);
    dst_index = format2index(dst);
 
    if (src_index < 0 || dst_index < 0) {
        ast_log(LOG_WARNING, "No translator path: (%s codec is not valid)\n", src_index < 0 ? "starting" : "ending");
        return NULL;
    }
 
    AST_RWLIST_RDLOCK(&translators);
 
    while (src_index != dst_index) {
        struct ast_trans_pvt *cur;
        struct ast_format *explicit_dst = NULL;
        struct ast_translator *t = matrix_get(src_index, dst_index)->step;
        if (!t) {
            ast_log(LOG_WARNING, "No translator path from %s to %s\n",
                ast_format_get_name(src), ast_format_get_name(dst));
            AST_RWLIST_UNLOCK(&translators);
            ast_translator_free_path(head);
            return NULL;
        }
        if ((t->dst_codec.sample_rate == ast_format_get_sample_rate(dst)) && (t->dst_codec.type == ast_format_get_type(dst))) {
            explicit_dst = dst;
        }
        if (!(cur = newpvt(t, explicit_dst))) {
            ast_log(LOG_WARNING, "Failed to build translator step from %s to %s\n",
                ast_format_get_name(src), ast_format_get_name(dst));
            ast_translator_free_path(head);
            AST_RWLIST_UNLOCK(&translators);
            return NULL;
        }
        if (!head) {
            head = cur;
        } else {
            tail->next = cur;
        }
        tail = cur;
        cur->nextin = cur->nextout = ast_tv(0, 0);
        /* Keep going if this isn't the final destination */
        src_index = cur->t->dst_fmt_index;
    }
 
    AST_RWLIST_UNLOCK(&translators);
    return head;
}

References ast_format_get_name(), ast_format_get_sample_rate(), ast_format_get_type(), ast_log, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_translator_free_path(), ast_tv(), ast_translator::dst_codec, ast_translator::dst_fmt_index, format2index(), LOG_WARNING, matrix_get(), newpvt(), ast_trans_pvt::next, ast_trans_pvt::nextin, ast_trans_pvt::nextout, NULL, ast_codec::sample_rate, translator_path::step, ast_trans_pvt::t, and ast_codec::type.

Referenced by ast_set_read_format_path(), ast_set_write_format_path(), ast_slinfactory_feed(), ast_writestream(), audiohook_list_translate_to_native(), audiohook_list_translate_to_slin(), audiohook_read_frame_helper(), conf_run(), set_format(), softmix_process_write_audio(), and softmix_translate_helper_change_rate().

ast_translator_deactivate()

void ast_translator_deactivate

(

struct ast_translator *

t

)

Deactivate a translator.

Parameters

t	translator to deactivate

Disables the specified translator from being used.

Definition at line 1386 of file translate.c.

{
    AST_RWLIST_WRLOCK(&translators);
    t->active = 0;
    matrix_rebuild(0);
    AST_RWLIST_UNLOCK(&translators);
}

References ast_translator::active, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and matrix_rebuild().

ast_translator_free_path()

void ast_translator_free_path

(

struct ast_trans_pvt *

tr

)

Frees a translator path Frees the given translator path structure.

Parameters

tr	translator path to get rid of

Definition at line 476 of file translate.c.

{
    struct ast_trans_pvt *pn = p;
    while ( (p = pn) ) {
        pn = p->next;
        destroy(p);
    }
}

References destroy(), and ast_trans_pvt::next.

Referenced by ast_audiohook_destroy(), ast_audiohook_detach_list(), ast_channel_destructor(), ast_set_read_format_path(), ast_set_write_format_path(), ast_slinfactory_destroy(), ast_slinfactory_feed(), ast_slinfactory_flush(), ast_translator_build_path(), ast_writestream(), audiohook_list_translate_to_native(), audiohook_list_translate_to_slin(), audiohook_read_frame_helper(), conf_free(), filestream_destructor(), free_translation(), set_format(), softmix_translate_helper_change_rate(), softmix_translate_helper_cleanup(), and softmix_translate_helper_free_entry().

ast_unregister_translator()

int ast_unregister_translator

(

struct ast_translator *

t

)

unregister codec translator

Unregister a translator Unregisters the given translator.

Definition at line 1350 of file translate.c.

{
    char tmp[80];
    struct ast_translator *u;
    int found = 0;
 
    AST_RWLIST_WRLOCK(&translators);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&translators, u, list) {
        if (u == t) {
            AST_RWLIST_REMOVE_CURRENT(list);
            ast_verb(5, "Unregistered translator '%s' from codec %s to %s\n",
                term_color(tmp, t->name, COLOR_MAGENTA, COLOR_BLACK, sizeof(tmp)),
                t->src_codec.name, t->dst_codec.name);
            found = 1;
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    if (found && !ast_shutting_down()) {
        matrix_rebuild(0);
    }
 
    AST_RWLIST_UNLOCK(&translators);
 
    return (u ? 0 : -1);
}

References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_shutting_down(), ast_verb, COLOR_BLACK, COLOR_MAGENTA, ast_translator::dst_codec, ast_translator::list, matrix_rebuild(), ast_codec::name, ast_translator::name, ast_translator::src_codec, term_color(), and tmp().

Referenced by unload_module(), and unregister_translators().

check_translation_path()

static void check_translation_path ( struct ast_format_cap *  dest, struct ast_format_cap *  src, struct ast_format_cap *  result, struct ast_format *  src_fmt, enum ast_media_type  type  )

static

Definition at line 1558 of file translate.c.

{
    int i;
 
    if (ast_format_get_type(src_fmt) != type) {
        return;
    }
 
    /* For a given source format, traverse the list of
       known formats to determine whether there exists
       a translation path from the source format to the
       destination format. */
    for (i = ast_format_cap_count(result) - 1; 0 <= i; i--) {
        int index, src_index;
        RAII_VAR(struct ast_format *, fmt, ast_format_cap_get_format(result, i), ao2_cleanup);
 
        if (ast_format_get_type(fmt) != type) {
            continue;
        }
 
        /* if this is not a desired format, nothing to do */
        if (ast_format_cap_iscompatible_format(dest, fmt) == AST_FORMAT_CMP_NOT_EQUAL) {
            continue;
        }
 
        /* if the source is supplying this format, then
           we can leave it in the result */
        if (ast_format_cap_iscompatible_format(src, fmt) == AST_FORMAT_CMP_EQUAL) {
            continue;
        }
 
        /* if this is a pass-through format, not in the source,
           we cannot transcode. Therefore, remove it from the result */
        src_index = format2index(src_fmt);
        index = format2index(fmt);
        if (src_index < 0 || index < 0) {
            ast_format_cap_remove(result, fmt);
            continue;
        }
 
        /* if we don't have a translation path from the src
           to this format, remove it from the result */
        if (!matrix_get(src_index, index)->step) {
            ast_format_cap_remove(result, fmt);
            continue;
        }
 
        /* now check the opposite direction */
        if (!matrix_get(index, src_index)->step) {
            ast_format_cap_remove(result, fmt);
        }
    }
 
}

References ao2_cleanup, ast_format_cap_count(), ast_format_cap_get_format(), ast_format_cap_iscompatible_format(), ast_format_cap_remove(), AST_FORMAT_CMP_EQUAL, AST_FORMAT_CMP_NOT_EQUAL, ast_format_get_type(), format2index(), matrix_get(), RAII_VAR, result, and type.

Referenced by ast_translate_available_formats().

codec2index()

static int codec2index ( struct ast_codec *  codec )

static

Definition at line 125 of file translate.c.

{
    return codec_to_index(codec->id);
}

References codec_to_index(), and ast_codec::id.

Referenced by __ast_register_translator(), add_codec2index(), handle_show_translation_path(), and handle_show_translation_table().

codec_append_name()

static void codec_append_name ( const struct ast_codec *  codec, struct ast_str **  buf  )

static

Definition at line 921 of file translate.c.

{
    if (codec) {
        ast_str_append(buf, 0, "(%s@%u)", codec->name, codec->sample_rate);
    } else {
        ast_str_append(buf, 0, "(nothing)");
    }
}

References ast_str_append(), buf, ast_codec::name, and ast_codec::sample_rate.

Referenced by ast_translate_path_to_str(), and handle_show_translation_path().

codec_to_index()

static int codec_to_index ( unsigned int  id )

static

Definition at line 105 of file translate.c.

{
    int x;
 
    ast_rwlock_rdlock(&tablelock);
    for (x = 0; x < cur_max_index; x++) {
        if (__indextable[x] == id) {
            /* format already exists in index2format table */
            ast_rwlock_unlock(&tablelock);
            return x;
        }
    }
    ast_rwlock_unlock(&tablelock);
    return -1; /* not found */
}

References __indextable, ast_rwlock_rdlock, ast_rwlock_unlock, cur_max_index, and tablelock.

Referenced by codec2index(), and format2index().

complete_trans_path_choice()

static char * complete_trans_path_choice ( const char *  word )

static

Definition at line 947 of file translate.c.

{
    int i = 1;
    int wordlen = strlen(word);
    struct ast_codec *codec;
 
    while ((codec = ast_codec_get_by_id(i))) {
        ++i;
        if (codec->type != AST_MEDIA_TYPE_AUDIO) {
            ao2_ref(codec, -1);
            continue;
        }
        if (!strncasecmp(word, codec->name, wordlen)) {
            if (ast_cli_completion_add(ast_strdup(codec->name))) {
                ao2_ref(codec, -1);
                break;
            }
        }
        ao2_ref(codec, -1);
    }
 
    return NULL;
}

References ao2_ref, ast_cli_completion_add(), ast_codec_get_by_id(), AST_MEDIA_TYPE_AUDIO, ast_strdup, ast_codec::name, NULL, and ast_codec::type.

Referenced by handle_cli_core_show_translation().

default_frameout()

static struct ast_frame * default_frameout ( struct ast_trans_pvt *  pvt )

static

Definition at line 469 of file translate.c.

{
    return ast_trans_frameout(pvt, 0, 0);
}

References ast_trans_frameout().

Referenced by __ast_register_translator().

destroy()

static void destroy ( struct ast_trans_pvt *  pvt )

static

Definition at line 292 of file translate.c.

{
    struct ast_translator *t = pvt->t;
 
    if (t->destroy) {
        t->destroy(pvt);
    }
    ao2_cleanup(pvt->f.subclass.format);
    if (pvt->explicit_dst) {
        ao2_ref(pvt->explicit_dst, -1);
        pvt->explicit_dst = NULL;
    }
    ast_free(pvt);
    ast_module_unref(t->module);
}

References ao2_cleanup, ao2_ref, ast_free, ast_module_unref, ast_translator::destroy, ast_trans_pvt::explicit_dst, ast_trans_pvt::f, ast_frame_subclass::format, ast_translator::module, NULL, ast_frame::subclass, and ast_trans_pvt::t.

Referenced by ast_translator_free_path(), generate_computational_cost(), and newpvt().

format2index()

static int format2index ( struct ast_format *  format )

static

Definition at line 134 of file translate.c.

{
    return codec_to_index(ast_format_get_codec_id(format));
}

References ast_format_get_codec_id(), and codec_to_index().

Referenced by ast_translate_path_steps(), ast_translator_best_choice(), ast_translator_build_path(), and check_translation_path().

framein()

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

static

framein wrapper, deals with bound checks.

Definition at line 397 of file translate.c.

{
    /* Copy the last in jb timing info to the pvt */
    ast_copy_flags(&pvt->f, f, AST_FRFLAG_HAS_TIMING_INFO);
    pvt->f.ts = f->ts;
    pvt->f.len = f->len;
    pvt->f.seqno = f->seqno;
 
    if (f->samples == 0) {
        /* Do not log empty audio frame */
        if (!f->src || strcasecmp(f->src, "ast_prod")) {
            ast_log(LOG_WARNING, "no samples for %s\n", pvt->t->name);
        }
    }
    if (pvt->t->buffer_samples) {   /* do not pass empty frames to callback */
        int src_srate = pvt->t->src_codec.sample_rate;
        int dst_srate = pvt->t->dst_codec.sample_rate;
 
        ast_assert(src_srate > 0);
 
        if (f->datalen == 0) { /* perform native PLC if available */
            /* If the codec has native PLC, then do that */
            if (!pvt->t->native_plc)
                return 0;
        }
 
        if (pvt->samples + (f->samples * dst_srate / src_srate) > pvt->t->buffer_samples) {
            ast_log(LOG_WARNING, "Out of buffer space\n");
            return -1;
        }
    }
    /* we require a framein routine, wouldn't know how to do
     * it otherwise.
     */
    return pvt->t->framein(pvt, f);
}

References ast_assert, ast_copy_flags, AST_FRFLAG_HAS_TIMING_INFO, ast_log, ast_translator::buffer_samples, ast_frame::datalen, ast_translator::dst_codec, ast_trans_pvt::f, ast_translator::framein, ast_frame::len, LOG_WARNING, ast_translator::name, ast_translator::native_plc, ast_codec::sample_rate, ast_frame::samples, ast_trans_pvt::samples, ast_frame::seqno, ast_frame::src, ast_translator::src_codec, ast_trans_pvt::t, and ast_frame::ts.

Referenced by ast_translate(), and generate_computational_cost().

generate_computational_cost()

static void generate_computational_cost ( struct ast_translator *  t, int  seconds  )

static

Definition at line 691 of file translate.c.

{
    int num_samples = 0;
    struct ast_trans_pvt *pvt;
    struct rusage start;
    struct rusage end;
    int cost;
    int out_rate = t->dst_codec.sample_rate;
 
    if (!seconds) {
        seconds = 1;
    }
 
    /* If they don't make samples, give them a terrible score */
    if (!t->sample) {
        ast_debug(3, "Translator '%s' does not produce sample frames.\n", t->name);
        t->comp_cost = 999999;
        return;
    }
 
    pvt = newpvt(t, NULL);
    if (!pvt) {
        ast_log(LOG_WARNING, "Translator '%s' appears to be broken and will probably fail.\n", t->name);
        t->comp_cost = 999999;
        return;
    }
 
    getrusage(RUSAGE_SELF, &start);
 
    /* Call the encoder until we've processed the required number of samples */
    while (num_samples < seconds * out_rate) {
        struct ast_frame *f = t->sample();
        if (!f) {
            ast_log(LOG_WARNING, "Translator '%s' failed to produce a sample frame.\n", t->name);
            destroy(pvt);
            t->comp_cost = 999999;
            return;
        }
        framein(pvt, f);
        ast_frfree(f);
        while ((f = t->frameout(pvt))) {
            num_samples += f->samples;
            ast_frfree(f);
        }
    }
 
    getrusage(RUSAGE_SELF, &end);
 
    cost = ((end.ru_utime.tv_sec - start.ru_utime.tv_sec) * 1000000) + end.ru_utime.tv_usec - start.ru_utime.tv_usec;
    cost += ((end.ru_stime.tv_sec - start.ru_stime.tv_sec) * 1000000) + end.ru_stime.tv_usec - start.ru_stime.tv_usec;
 
    destroy(pvt);
 
    t->comp_cost = cost / seconds;
 
    if (!t->comp_cost) {
        t->comp_cost = 1;
    }
}

References ast_debug, ast_frfree, ast_log, ast_translator::comp_cost, destroy(), ast_translator::dst_codec, end, framein(), ast_translator::frameout, LOG_WARNING, ast_translator::name, newpvt(), NULL, ast_trans_pvt::pvt, ast_translator::sample, ast_codec::sample_rate, and ast_frame::samples.

Referenced by __ast_register_translator(), and matrix_rebuild().

generate_interpolated_slin()

static struct ast_frame * generate_interpolated_slin ( struct ast_trans_pvt *  p, struct ast_frame *  f  )

static

Definition at line 537 of file translate.c.

{
    struct ast_frame res = { AST_FRAME_VOICE };
 
    /*
     * If we've gotten here then we should have an interpolated frame that was not handled
     * by the translation codec. So create an interpolated frame in the appropriate format
     * that was going to be written. This frame might be handled later by other resources.
     * For instance, generic plc.
     *
     * Note, generic plc is currently only available for the format type 'slin' (8KHz only -
     * The generic plc code appears to have been based around that). Generic plc is filled
     * in later on frame write.
     */
    if (!ast_opt_generic_plc || f->datalen != 0 ||
        ast_format_cmp(p->explicit_dst, ast_format_slin) == AST_FORMAT_CMP_NOT_EQUAL) {
        return NULL;
    }
 
    res.subclass.format = ast_format_cache_get_slin_by_rate(8000); /* ref bumped on dup */
    res.samples = f->samples;
    res.datalen = 0;
    res.data.ptr = NULL;
    res.offset = AST_FRIENDLY_OFFSET;
 
    return ast_frdup(&res);
}

References ast_format_cache_get_slin_by_rate(), ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, ast_format_slin, AST_FRAME_VOICE, ast_frdup, AST_FRIENDLY_OFFSET, ast_opt_generic_plc, ast_frame::data, ast_frame::datalen, ast_trans_pvt::explicit_dst, ast_frame_subclass::format, NULL, ast_frame::offset, ast_frame::ptr, ast_frame::samples, and ast_frame::subclass.

Referenced by ast_translate().

generate_table_cost()

static int generate_table_cost ( struct ast_codec *  src, struct ast_codec *  dst  )

static

Definition at line 769 of file translate.c.

{
    int src_rate = src->sample_rate;
    int src_ll = 0;
    int dst_rate = dst->sample_rate;
    int dst_ll = 0;
 
    if ((src->type != AST_MEDIA_TYPE_AUDIO) ||
        (dst->type != AST_MEDIA_TYPE_AUDIO)) {
        /* This method of generating table cost is limited to audio.
         * Translators for media other than audio must manually set their
         * table cost. */
        return 0;
    }
 
    src_ll = !strcmp(src->name, "slin");
    dst_ll = !strcmp(dst->name, "slin");
    if (src_ll) {
        if (dst_ll && (src_rate == dst_rate)) {
            return AST_TRANS_COST_LL_LL_ORIGSAMP;
        } else if (!dst_ll && (src_rate == dst_rate)) {
            return AST_TRANS_COST_LL_LY_ORIGSAMP;
        } else if (dst_ll && (src_rate < dst_rate)) {
            return AST_TRANS_COST_LL_LL_UPSAMP;
        } else if (!dst_ll && (src_rate < dst_rate)) {
            return AST_TRANS_COST_LL_LY_UPSAMP;
        } else if (dst_ll && (src_rate > dst_rate)) {
            return AST_TRANS_COST_LL_LL_DOWNSAMP;
        } else if (!dst_ll && (src_rate > dst_rate)) {
            return AST_TRANS_COST_LL_LY_DOWNSAMP;
        } else {
            return AST_TRANS_COST_LL_UNKNOWN;
        }
    } else {
        if (dst_ll && (src_rate == dst_rate)) {
            return AST_TRANS_COST_LY_LL_ORIGSAMP;
        } else if (!dst_ll && (src_rate == dst_rate)) {
            return AST_TRANS_COST_LY_LY_ORIGSAMP;
        } else if (dst_ll && (src_rate < dst_rate)) {
            return AST_TRANS_COST_LY_LL_UPSAMP;
        } else if (!dst_ll && (src_rate < dst_rate)) {
            return AST_TRANS_COST_LY_LY_UPSAMP;
        } else if (dst_ll && (src_rate > dst_rate)) {
            return AST_TRANS_COST_LY_LL_DOWNSAMP;
        } else if (!dst_ll && (src_rate > dst_rate)) {
            return AST_TRANS_COST_LY_LY_DOWNSAMP;
        } else {
            return AST_TRANS_COST_LY_UNKNOWN;
        }
    }
}

References AST_MEDIA_TYPE_AUDIO, AST_TRANS_COST_LL_LL_DOWNSAMP, AST_TRANS_COST_LL_LL_ORIGSAMP, AST_TRANS_COST_LL_LL_UPSAMP, AST_TRANS_COST_LL_LY_DOWNSAMP, AST_TRANS_COST_LL_LY_ORIGSAMP, AST_TRANS_COST_LL_LY_UPSAMP, AST_TRANS_COST_LL_UNKNOWN, AST_TRANS_COST_LY_LL_DOWNSAMP, AST_TRANS_COST_LY_LL_ORIGSAMP, AST_TRANS_COST_LY_LL_UPSAMP, AST_TRANS_COST_LY_LY_DOWNSAMP, AST_TRANS_COST_LY_LY_ORIGSAMP, AST_TRANS_COST_LY_LY_UPSAMP, AST_TRANS_COST_LY_UNKNOWN, ast_codec::name, ast_codec::sample_rate, ast_frame::src, and ast_codec::type.

Referenced by __ast_register_translator().

handle_cli_core_show_translation()

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

static

Definition at line 1175 of file translate.c.

{
    static const char * const option[] = { "recalc", "paths", "comp", NULL };
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show translation";
        e->usage =
            "Usage: 'core show translation' can be used in three ways.\n"
            "       1. 'core show translation [recalc [<recalc seconds>]\n"
            "          Displays known codec translators and the cost associated\n"
            "          with each conversion.  If the argument 'recalc' is supplied along\n"
            "          with optional number of seconds to test a new test will be performed\n"
            "          as the chart is being displayed.\n"
            "       2. 'core show translation paths [codec [sample_rate]]'\n"
            "           This will display all the translation paths associated with a codec.\n"
            "           If a codec has multiple sample rates, the sample rate must be\n"
            "           provided as well.\n"
            "       3. 'core show translation comp [<recalc seconds>]'\n"
            "          Displays known codec translators and the cost associated\n"
            "          with each conversion.  If the argument 'recalc' is supplied along\n"
            "          with optional number of seconds to test a new test will be performed\n"
            "          as the chart is being displayed. The resulting numbers in the table\n"
            "          give the actual computational costs in microseconds.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 3) {
            return ast_cli_complete(a->word, option, -1);
        }
        if (a->pos == 4 && !strcasecmp(a->argv[3], option[1])) {
            return complete_trans_path_choice(a->word);
        }
        /* BUGBUG - add tab completion for sample rates */
        return NULL;
    }
 
    if (a->argc > 6)
        return CLI_SHOWUSAGE;
 
    if (a->argv[3] && !strcasecmp(a->argv[3], option[1]) && a->argc == 5) { /* show paths */
        return handle_show_translation_path(a, a->argv[4], 0);
    } else if (a->argv[3] && !strcasecmp(a->argv[3], option[1]) && a->argc == 6) {
        unsigned int sample_rate;
        if (sscanf(a->argv[5], "%30u", &sample_rate) != 1) {
            ast_cli(a->fd, "Invalid sample rate: %s.\n", a->argv[5]);
            return CLI_FAILURE;
        }
        return handle_show_translation_path(a, a->argv[4], sample_rate);
    } else if (a->argv[3] && (!strcasecmp(a->argv[3], option[0]) || !strcasecmp(a->argv[3], option[2]))) { /* recalc and then fall through to show table */
        handle_cli_recalc(a);
    } else if (a->argc > 3) { /* wrong input */
        return CLI_SHOWUSAGE;
    }
 
    return handle_show_translation_table(a);
}

References a, ast_cli(), ast_cli_complete(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, complete_trans_path_choice(), handle_cli_recalc(), handle_show_translation_path(), handle_show_translation_table(), NULL, ast_codec::sample_rate, and ast_cli_entry::usage.

handle_cli_recalc()

static void handle_cli_recalc ( struct ast_cli_args *  a )

static

Definition at line 971 of file translate.c.

{
    int time = a->argv[4] ? atoi(a->argv[4]) : 1;
 
    if (time <= 0) {
        ast_cli(a->fd, "         Recalc must be greater than 0.  Defaulting to 1.\n");
        time = 1;
    }
 
    if (time > MAX_RECALC) {
        ast_cli(a->fd, "         Maximum limit of recalc exceeded by %d, truncating value to %d\n", time - MAX_RECALC, MAX_RECALC);
        time = MAX_RECALC;
    }
    ast_cli(a->fd, "         Recalculating Codec Translation (number of sample seconds: %d)\n\n", time);
    AST_RWLIST_WRLOCK(&translators);
    matrix_rebuild(time);
    AST_RWLIST_UNLOCK(&translators);
}

References a, ast_cli(), AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, matrix_rebuild(), and MAX_RECALC.

Referenced by handle_cli_core_show_translation().

handle_show_translation_path()

static char * handle_show_translation_path ( struct ast_cli_args *  a, const char *  codec_name, unsigned int  sample_rate  )

static

Definition at line 1110 of file translate.c.

{
    int i = 1;
    struct ast_str *str = ast_str_alloca(1024);
    struct ast_translator *step;
    struct ast_codec *dst_codec;
    struct ast_codec *src_codec = ast_codec_get(codec_name, AST_MEDIA_TYPE_AUDIO, sample_rate);
 
    if (!src_codec) {
        ast_cli(a->fd, "Source codec \"%s\" is not found.\n", codec_name);
        return CLI_FAILURE;
    }
 
    AST_RWLIST_RDLOCK(&translators);
    ast_cli(a->fd, "--- Translation paths SRC Codec \"%s\" sample rate %u ---\n",
        codec_name, src_codec->sample_rate);
 
    while ((dst_codec = ast_codec_get_by_id(i))) {
        int src, dst;
        char src_buffer[64];
        char dst_buffer[64];
 
        ++i;
        if (src_codec == dst_codec ||
            dst_codec->type != AST_MEDIA_TYPE_AUDIO) {
            ao2_ref(dst_codec, -1);
            continue;
        }
 
        dst = codec2index(dst_codec);
        src = codec2index(src_codec);
 
        if (src < 0 || dst < 0) {
            ast_str_set(&str, 0, "No Translation Path");
        } else {
            step = matrix_get(src, dst)->step;
 
            if (step) {
                codec_append_name(&step->src_codec, &str);
                while (src != dst) {
                    src = step->dst_fmt_index;
                    step = matrix_get(src, dst)->step;
                    if (!step) {
                        ast_str_append(&str, 0, "->");
                        codec_append_name(dst_codec, &str);
                        break;
                    }
                    ast_str_append(&str, 0, "->");
                    codec_append_name(&step->src_codec, &str);
                }
            }
        }
 
        snprintf(src_buffer, sizeof(src_buffer), "%s:%u", src_codec->name, src_codec->sample_rate);
        snprintf(dst_buffer, sizeof(dst_buffer), "%s:%u", dst_codec->name, dst_codec->sample_rate);
        ast_cli(a->fd, "\t%-16.16s To %-16.16s: %-60.60s\n",
            src_buffer, dst_buffer, ast_str_buffer(str));
        ast_str_reset(str);
        ao2_ref(dst_codec, -1);
    }
    AST_RWLIST_UNLOCK(&translators);
    ao2_ref(src_codec, -1);
    return CLI_SUCCESS;
}

References a, ao2_ref, ast_cli(), ast_codec_get(), ast_codec_get_by_id(), AST_MEDIA_TYPE_AUDIO, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_reset(), ast_str_set(), CLI_FAILURE, CLI_SUCCESS, codec2index(), codec_append_name(), ast_translator::dst_fmt_index, matrix_get(), ast_codec::name, ast_codec::sample_rate, ast_translator::src_codec, translator_path::step, str, and ast_codec::type.

Referenced by handle_cli_core_show_translation().

handle_show_translation_table()

static char * handle_show_translation_table ( struct ast_cli_args *  a )

static

Definition at line 990 of file translate.c.

{
    int x, y, i, k, compCost;
    int longest = 7; /* slin192 */
    int max_codec_index = 0, curlen = 0;
    struct ast_str *out = ast_str_create(1024);
    struct ast_codec *codec;
 
    /* Get the length of the longest (usable?) codec name,
       so we know how wide the left side should be */
    for (i = 1; (codec = ast_codec_get_by_id(i)); ao2_ref(codec, -1), ++i) {
        ++max_codec_index;
        if (codec->type != AST_MEDIA_TYPE_AUDIO) {
            continue;
        }
        curlen = strlen(codec->name);
        if (curlen > longest) {
            longest = curlen;
        }
    }
 
    AST_RWLIST_RDLOCK(&translators);
    ast_cli(a->fd, "         Translation times between formats (in microseconds) for one second of data\n");
    ast_cli(a->fd, "          Source Format (Rows) Destination Format (Columns)\n\n");
 
    for (i = 0; i <= max_codec_index; i++) {
        struct ast_codec *row = i ? ast_codec_get_by_id(i) : NULL;
 
        x = -1;
        if ((i > 0) && (row->type != AST_MEDIA_TYPE_AUDIO)) {
            ao2_ref(row, -1);
            continue;
        }
 
        if ((i > 0) && (x = codec2index(row)) == -1) {
            ao2_ref(row, -1);
            continue;
        }
 
        ast_str_set(&out, 0, " ");
        for (k = 0; k <= max_codec_index; k++) {
            int adjust = 0;
            struct ast_codec *col = k ? ast_codec_get_by_id(k) : NULL;
 
            y = -1;
            if ((k > 0) && (col->type != AST_MEDIA_TYPE_AUDIO)) {
                ao2_ref(col, -1);
                continue;
            }
 
            if ((k > 0) && (y = codec2index(col)) == -1) {
                ao2_ref(col, -1);
                continue;
            }
 
            if (k > 0) {
                curlen = strlen(col->name);
                if (!strcmp(col->name, "slin") ||
                    !strcmp(col->name, "speex") ||
                    !strcmp(col->name, "silk")) {
                    adjust = log10(col->sample_rate / 1000) + 1;
                    curlen = curlen + adjust;
                }
            }
 
            if (curlen < 5) {
                curlen = 5;
            }
 
            if (x >= 0 && y >= 0 && matrix_get(x, y)->step) {
                /* Actual codec output */
                if (a->argv[3] && !strcasecmp(a->argv[3], "comp")) {
                    compCost = matrix_get(x, y)->comp_cost;
                    if (compCost == 0 || compCost == 999999) {
                        ast_str_append(&out, 0, "%*s", curlen + 1, "-");
                    } else {
                        ast_str_append(&out, 0, "%*u", curlen + 1, compCost);
                    }
                } else {
                    ast_str_append(&out, 0, "%*u", curlen + 1, (matrix_get(x, y)->table_cost / 100));
                }
            } else if (i == 0 && k > 0) {
                /* Top row - use a dynamic size */
                if (!strcmp(col->name, "slin") ||
                    !strcmp(col->name, "speex") ||
                    !strcmp(col->name, "silk")) {
                    ast_str_append(&out, 0, "%*s%u", curlen - adjust + 1,
                        col->name, col->sample_rate / 1000);
                } else {
                    ast_str_append(&out, 0, "%*s", curlen + 1, col->name);
                }
            } else if (k == 0 && i > 0) {
                /* Left column - use a static size. */
                if (!strcmp(row->name, "slin") ||
                    !strcmp(row->name, "speex") ||
                    !strcmp(row->name, "silk")) {
                    int adjust_row = log10(row->sample_rate / 1000) + 1;
                    ast_str_append(&out, 0, "%*s%u", longest - adjust_row,
                        row->name, row->sample_rate / 1000);
                } else {
                    ast_str_append(&out, 0, "%*s", longest, row->name);
                }
            } else if (x >= 0 && y >= 0) {
                /* Codec not supported */
                ast_str_append(&out, 0, "%*s", curlen + 1, "-");
            } else {
                /* Upper left hand corner */
                ast_str_append(&out, 0, "%*s", longest, "");
            }
            ao2_cleanup(col);
        }
        ast_str_append(&out, 0, "\n");
        ast_cli(a->fd, "%s", ast_str_buffer(out));
        ao2_cleanup(row);
    }
    ast_free(out);
    AST_RWLIST_UNLOCK(&translators);
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_ref, ast_cli(), ast_codec_get_by_id(), ast_free, AST_MEDIA_TYPE_AUDIO, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), CLI_SUCCESS, codec2index(), translator_path::comp_cost, matrix_get(), ast_codec::name, NULL, out, ast_codec::sample_rate, and ast_codec::type.

Referenced by handle_cli_core_show_translation().

index2codec()

static struct ast_codec * index2codec ( int  index )

static

Definition at line 171 of file translate.c.

{
    struct ast_codec *codec;
 
    if (index >= cur_max_index) {
        return 0;
    }
    ast_rwlock_rdlock(&tablelock);
    codec = ast_codec_get_by_id(__indextable[index]);
    ast_rwlock_unlock(&tablelock);
 
    return codec;
}

References __indextable, ast_codec_get_by_id(), ast_rwlock_rdlock, ast_rwlock_unlock, cur_max_index, and tablelock.

Referenced by matrix_rebuild().

matrix_clear()

static void matrix_clear ( void  )

static

Definition at line 269 of file translate.c.

{
    int x;
    for (x = 0; x < index_size; x++) {
        memset(__matrix[x], '\0', sizeof(struct translator_path) * (index_size));
    }
}

References __matrix, and index_size.

Referenced by matrix_rebuild().

matrix_get()

static struct translator_path * matrix_get ( unsigned int  x, unsigned int  y  )

static

Definition at line 283 of file translate.c.

{
    return __matrix[x] + y;
}

References __matrix.

Referenced by ast_translate_path_steps(), ast_translator_best_choice(), ast_translator_build_path(), check_translation_path(), handle_show_translation_path(), handle_show_translation_table(), and matrix_rebuild().

matrix_rebuild()

static void matrix_rebuild ( int  samples )

static

rebuild a translation matrix.

Note

This function expects the list of translators to be locked

Definition at line 825 of file translate.c.

{
    struct ast_translator *t;
    int newtablecost;
    int x;      /* source format index */
    int y;      /* intermediate format index */
    int z;      /* destination format index */
 
    ast_debug(1, "Resetting translation matrix\n");
 
    matrix_clear();
 
    /* first, compute all direct costs */
    AST_RWLIST_TRAVERSE(&translators, t, list) {
        if (!t->active) {
            continue;
        }
 
        x = t->src_fmt_index;
        z = t->dst_fmt_index;
 
        if (samples) {
            generate_computational_cost(t, samples);
        }
 
        /* This new translator is the best choice if any of the below are true.
         * 1. no translation path is set between x and z yet.
         * 2. the new table cost is less.
         * 3. the new computational cost is less.  Computational cost is only used
         *    to break a tie between two identical translation paths.
         */
        if (!matrix_get(x, z)->step ||
            (t->table_cost < matrix_get(x, z)->step->table_cost) ||
            (t->comp_cost < matrix_get(x, z)->step->comp_cost)) {
 
            matrix_get(x, z)->step = t;
            matrix_get(x, z)->table_cost = t->table_cost;
            matrix_get(x, z)->comp_cost = t->comp_cost;
        }
    }
 
    /*
     * For each triple x, y, z of distinct formats, check if there is
     * a path from x to z through y which is cheaper than what is
     * currently known, and in case, update the matrix.
     * Repeat until the matrix is stable.
     */
    for (;;) {
        int changed = 0;
        for (x = 0; x < cur_max_index; x++) {      /* source format */
            for (y = 0; y < cur_max_index; y++) {  /* intermediate format */
                if (x == y) {                      /* skip ourselves */
                    continue;
                }
                for (z = 0; z < cur_max_index; z++) {  /* dst format */
                    if ((z == x || z == y) ||        /* skip null conversions */
                        !matrix_get(x, y)->step ||   /* no path from x to y */
                        !matrix_get(y, z)->step) {   /* no path from y to z */
                        continue;
                    }
 
                    /* calculate table cost from x->y->z */
                    newtablecost = matrix_get(x, y)->table_cost + matrix_get(y, z)->table_cost;
 
                    /* if no step already exists between x and z OR the new cost of using the intermediate
                     * step is cheaper, use this step. */
                    if (!matrix_get(x, z)->step || (newtablecost < matrix_get(x, z)->table_cost)) {
                        matrix_get(x, z)->step = matrix_get(x, y)->step;
                        matrix_get(x, z)->table_cost = newtablecost;
                        matrix_get(x, z)->multistep = 1;
                        changed++;
 
                        if (DEBUG_ATLEAST(10)) {
                            struct ast_codec *x_codec = index2codec(x);
                            struct ast_codec *y_codec = index2codec(y);
                            struct ast_codec *z_codec = index2codec(z);
 
                            ast_log(LOG_DEBUG,
                                "Discovered %u cost path from %s to %s, via %s\n",
                                matrix_get(x, z)->table_cost, x_codec->name,
                                y_codec->name, z_codec->name);
 
                            ao2_ref(x_codec, -1);
                            ao2_ref(y_codec, -1);
                            ao2_ref(z_codec, -1);
                        }
                    }
                }
            }
        }
        if (!changed) {
            break;
        }
    }
}

References ast_translator::active, ao2_ref, ast_debug, ast_log, AST_RWLIST_TRAVERSE, ast_translator::comp_cost, translator_path::comp_cost, cur_max_index, DEBUG_ATLEAST, ast_translator::dst_fmt_index, generate_computational_cost(), index2codec(), ast_translator::list, LOG_DEBUG, matrix_clear(), matrix_get(), translator_path::multistep, ast_codec::name, ast_translator::src_fmt_index, translator_path::step, ast_translator::table_cost, and translator_path::table_cost.

Referenced by __ast_register_translator(), ast_translator_activate(), ast_translator_deactivate(), ast_unregister_translator(), handle_cli_recalc(), and matrix_resize().

matrix_resize()

static int matrix_resize ( int  init )

static

Definition at line 195 of file translate.c.

{
    struct translator_path **tmp_matrix = NULL;
    unsigned int *tmp_table = NULL;
    int old_index;
    int x;
 
    AST_RWLIST_WRLOCK(&translators);
    ast_rwlock_wrlock(&tablelock);
 
    old_index = index_size;
    if (init) {
        index_size += INIT_INDEX;
    } else {
        index_size += GROW_INDEX;
    }
 
    /* make new 2d array of translator_path structures */
    if (!(tmp_matrix = ast_calloc(1, sizeof(struct translator_path *) * (index_size)))) {
        goto resize_cleanup;
    }
 
    for (x = 0; x < index_size; x++) {
        if (!(tmp_matrix[x] = ast_calloc(1, sizeof(struct translator_path) * (index_size)))) {
            goto resize_cleanup;
        }
    }
 
    /* make new index table */
    if (!(tmp_table = ast_calloc(1, sizeof(unsigned int) * index_size))) {
        goto resize_cleanup;
    }
 
    /* if everything went well this far, free the old and use the new */
    if (!init) {
        for (x = 0; x < old_index; x++) {
            ast_free(__matrix[x]);
        }
        ast_free(__matrix);
 
        memcpy(tmp_table, __indextable, sizeof(unsigned int) * old_index);
        ast_free(__indextable);
    }
 
    /* now copy them over */
    __matrix = tmp_matrix;
    __indextable = tmp_table;
 
    matrix_rebuild(0);
    ast_rwlock_unlock(&tablelock);
    AST_RWLIST_UNLOCK(&translators);
 
    return 0;
 
resize_cleanup:
    ast_rwlock_unlock(&tablelock);
    AST_RWLIST_UNLOCK(&translators);
    if (tmp_matrix) {
        for (x = 0; x < index_size; x++) {
            ast_free(tmp_matrix[x]);
        }
        ast_free(tmp_matrix);
    }
    ast_free(tmp_table);
 
    return -1;
}

References __indextable, __matrix, ast_calloc, ast_free, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_rwlock_unlock, ast_rwlock_wrlock, GROW_INDEX, index_size, INIT_INDEX, matrix_rebuild(), NULL, and tablelock.

Referenced by __ast_register_translator(), and ast_translate_init().

newpvt()

static struct ast_trans_pvt * newpvt ( struct ast_translator *  t, struct ast_format *  explicit_dst  )

static

Allocate the descriptor, required outbuf space, and possibly desc.

Definition at line 312 of file translate.c.

{
    struct ast_trans_pvt *pvt;
    int len;
    char *ofs;
 
    /*
     * compute the required size adding private descriptor,
     * buffer, AST_FRIENDLY_OFFSET.
     */
    len = sizeof(*pvt) + t->desc_size;
    if (t->buf_size)
        len += AST_FRIENDLY_OFFSET + t->buf_size;
    pvt = ast_calloc(1, len);
    if (!pvt) {
        return NULL;
    }
    pvt->t = t;
    ofs = (char *)(pvt + 1);    /* pointer to data space */
    if (t->desc_size) {     /* first comes the descriptor */
        pvt->pvt = ofs;
        ofs += t->desc_size;
    }
    if (t->buf_size) {/* finally buffer and header */
        pvt->outbuf.c = ofs + AST_FRIENDLY_OFFSET;
    }
    /*
     * If the format has an attribute module, explicit_dst includes the (joined)
     * result of the SDP negotiation. For example with the Opus Codec, the format
     * knows whether both parties want to do forward-error correction (FEC).
     */
    pvt->explicit_dst = ao2_bump(explicit_dst);
 
    ast_module_ref(t->module);
 
    /* call local init routine, if present */
    if (t->newpvt && t->newpvt(pvt)) {
        ast_free(pvt);
        ast_module_unref(t->module);
        return NULL;
    }
 
    /* Setup normal static translation frame. */
    pvt->f.frametype = AST_FRAME_VOICE;
    pvt->f.mallocd = 0;
    pvt->f.offset = AST_FRIENDLY_OFFSET;
    pvt->f.src = pvt->t->name;
    pvt->f.data.ptr = pvt->outbuf.c;
 
    /*
     * If the translator has not provided a format
     * A) use the joined one,
     * B) use the cached one, or
     * C) create one.
     */
    if (!pvt->f.subclass.format) {
        pvt->f.subclass.format = ao2_bump(pvt->explicit_dst);
 
        if (!pvt->f.subclass.format && !ast_strlen_zero(pvt->t->format)) {
            pvt->f.subclass.format = ast_format_cache_get(pvt->t->format);
        }
 
        if (!pvt->f.subclass.format) {
            struct ast_codec *codec = ast_codec_get(t->dst_codec.name,
                t->dst_codec.type, t->dst_codec.sample_rate);
            if (!codec) {
                ast_log(LOG_ERROR, "Unable to get destination codec\n");
                destroy(pvt);
                return NULL;
            }
            pvt->f.subclass.format = ast_format_create(codec);
            ao2_ref(codec, -1);
        }
 
        if (!pvt->f.subclass.format) {
            ast_log(LOG_ERROR, "Unable to create format\n");
            destroy(pvt);
            return NULL;
        }
    }
 
    return pvt;
}

References ao2_bump, ao2_ref, ast_calloc, ast_codec_get(), ast_format_cache_get, ast_format_create(), AST_FRAME_VOICE, ast_free, AST_FRIENDLY_OFFSET, ast_log, ast_module_ref, ast_module_unref, ast_strlen_zero(), ast_translator::buf_size, ast_translator::desc_size, destroy(), ast_translator::dst_codec, ast_trans_pvt::explicit_dst, ast_trans_pvt::f, ast_frame_subclass::format, len(), LOG_ERROR, ast_translator::module, ast_codec::name, ast_translator::newpvt, NULL, ast_trans_pvt::pvt, ast_codec::sample_rate, ast_frame::subclass, ast_trans_pvt::t, and ast_codec::type.

Referenced by ast_translator_build_path(), and generate_computational_cost().

translate_shutdown()

static void translate_shutdown ( void  )

static

Definition at line 1658 of file translate.c.

{
    int x;
    ast_cli_unregister_multiple(cli_translate, ARRAY_LEN(cli_translate));
 
    ast_rwlock_wrlock(&tablelock);
    for (x = 0; x < index_size; x++) {
        ast_free(__matrix[x]);
    }
    ast_free(__matrix);
    __matrix = NULL;
    ast_free(__indextable);
    __indextable = NULL;
    ast_rwlock_unlock(&tablelock);
    ast_rwlock_destroy(&tablelock);
}

References __indextable, __matrix, ARRAY_LEN, ast_cli_unregister_multiple(), ast_free, ast_rwlock_destroy, ast_rwlock_unlock, ast_rwlock_wrlock, cli_translate, index_size, NULL, and tablelock.

Referenced by ast_translate_init().

Variable Documentation

__indextable

unsigned int* __indextable

static

table for converting index to format values.

Note

this table is protected by the table_lock.

Definition at line 84 of file translate.c.

Referenced by add_codec2index(), codec_to_index(), index2codec(), matrix_resize(), and translate_shutdown().

__matrix

struct translator_path** __matrix

static

a matrix that, for any pair of supported formats, indicates the total cost of translation and the first step. The full path can be reconstructed iterating on the matrix until step->dstfmt == desired_format.

Array indexes are 'src' and 'dest', in that order.

Note: the lock in the 'translators' list is also used to protect this structure.

Definition at line 77 of file translate.c.

Referenced by matrix_clear(), matrix_get(), matrix_resize(), and translate_shutdown().

cli_translate

struct ast_cli_entry cli_translate[]

static

Initial value:

= {
    { .handler =  handle_cli_core_show_translation , .summary =  "Display translation matrix" ,}
}

Definition at line 1232 of file translate.c.

Referenced by ast_translate_init(), and translate_shutdown().

cur_max_index

int cur_max_index

static

the current largest index used by the __matrix and __indextable arrays

Definition at line 95 of file translate.c.

Referenced by __ast_register_translator(), add_codec2index(), codec_to_index(), index2codec(), and matrix_rebuild().

index_size

int index_size

static

the largest index that can be used in either the __indextable or __matrix before resize must occur

Definition at line 97 of file translate.c.

Referenced by add_codec2index(), matrix_clear(), matrix_resize(), and translate_shutdown().

tablelock

ast_rwlock_t tablelock

static

protects the __indextable for resizing

Definition at line 87 of file translate.c.

Referenced by add_codec2index(), ast_translate_init(), codec_to_index(), index2codec(), matrix_resize(), and translate_shutdown().

translators

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

static