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 reconstricted 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 1378 of file translate.c.

Referenced by ast_translator_best_choice().

GROW_INDEX

#define GROW_INDEX   16

Definition at line 91 of file translate.c.

Referenced by matrix_resize().

INIT_INDEX

#define INIT_INDEX   32

Definition at line 89 of file translate.c.

Referenced by matrix_resize().

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.

Referenced by handle_cli_recalc().

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 1220 of file translate.c.

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.

{
   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(2, "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;
}

add_codec2index()

static int add_codec2index ( struct ast_codec *  codec )

static

Definition at line 147 of file translate.c.

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

Referenced by __ast_register_translator().

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

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 438 of file translate.c.

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().

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

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 565 of file translate.c.

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(), ast_frame::delivery, ast_translator::feedback, ast_frame_subclass::format, framein(), ast_frame::frametype, generate_interpolated_slin(), ast_frame::len, 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().

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

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
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 1571 of file translate.c.

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, and check_translation_path().

Referenced by ast_rtp_instance_available_formats().

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

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 1630 of file translate.c.

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

Referenced by asterisk_daemon().

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

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, or -1 if no path is available

Definition at line 1491 of file translate.c.

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

Referenced by ast_channel_make_compatible_helper().

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

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

Return values

on	success pointer to beginning of outbuf. on failure "".

Definition at line 928 of file translate.c.

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, and ast_trans_pvt::t.

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

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

ast_translator_activate()

void ast_translator_activate

(

struct ast_translator *

t

)

Activate a previously deactivated translator.

Parameters

t	translator to activate

Returns

nothing

Enables the specified translator for use.

Definition at line 1361 of file translate.c.

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

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

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 1385 of file translate.c.

References ao2_cleanup, ao2_ref, ao2_replace, 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_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, RAII_VAR, translator_path::step, and translator_path::table_cost.

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

{
   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) {
            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 */
               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;
}

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 485 of file translate.c.

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().

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

ast_translator_deactivate()

void ast_translator_deactivate

(

struct ast_translator *

t

)

Deactivate a translator.

Parameters

t	translator to deactivate

Returns

nothing

Disables the specified translator from being used.

Definition at line 1369 of file translate.c.

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

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

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 475 of file translate.c.

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().

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

ast_unregister_translator()

int ast_unregister_translator

(

struct ast_translator *

t

)

unregister codec translator

Unregister a translator Unregisters the given tranlator.

Definition at line 1333 of file translate.c.

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().

{
   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(2, "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);
}

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 1513 of file translate.c.

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, and translator_path::step.

Referenced by ast_translate_available_formats().

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

}

codec2index()

static int codec2index ( struct ast_codec *  codec )

static

Definition at line 124 of file translate.c.

References codec_to_index(), and ast_codec::id.

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

{
   return codec_to_index(codec->id);
}

codec_append_name()

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

static

Definition at line 919 of file translate.c.

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

Referenced by ast_translate_path_to_str(), and handle_show_translation_path().

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

codec_to_index()

static int codec_to_index ( unsigned int  id )

static

Definition at line 104 of file translate.c.

References __indextable, ast_rwlock_rdlock, ast_rwlock_unlock, and cur_max_index.

Referenced by codec2index(), and format2index().

{
   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 */
}

complete_trans_path_choice()

static char* complete_trans_path_choice ( const char *  word )

static

Definition at line 945 of file translate.c.

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().

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

default_frameout()

static struct ast_frame* default_frameout ( struct ast_trans_pvt *  pvt )

static

Definition at line 468 of file translate.c.

References ast_trans_frameout().

Referenced by __ast_register_translator().

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

destroy()

static void destroy ( struct ast_trans_pvt *  pvt )

static

Definition at line 291 of file translate.c.

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(), newpvt(), and rtp_ioqueue_thread_remove().

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

format2index()

static int format2index ( struct ast_format *  format )

static

Definition at line 133 of file translate.c.

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().

{
   return codec_to_index(ast_format_get_codec_id(format));
}

framein()

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

static

framein wrapper, deals with bound checks.

Definition at line 396 of file translate.c.

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().

{
   /* 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);
}

generate_computational_cost()

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

static

Definition at line 690 of file translate.c.

References ast_debug, ast_frfree, ast_log, ast_translator::comp_cost, destroy(), ast_translator::dst_codec, 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().

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

generate_interpolated_slin()

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

static

Definition at line 536 of file translate.c.

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().

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

generate_table_cost()

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

static

Definition at line 768 of file translate.c.

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, and ast_codec::type.

Referenced by __ast_register_translator().

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

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 1164 of file translate.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_cli_complete(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, complete_trans_path_choice(), ast_cli_args::fd, handle_cli_recalc(), handle_show_translation_path(), handle_show_translation_table(), NULL, ast_cli_args::pos, ast_codec::sample_rate, ast_cli_entry::usage, and ast_cli_args::word.

{
   static const char * const option[] = { "recalc", "paths", NULL };

   switch (cmd) {
   case CLI_INIT:
      e->command = "core show translation";
      e->usage =
         "Usage: 'core show translation' can be used in two 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";
      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])) { /* 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);
}

handle_cli_recalc()

static void handle_cli_recalc ( struct ast_cli_args *  a )

static

Definition at line 969 of file translate.c.

References ast_cli_args::argv, ast_cli(), AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_cli_args::fd, matrix_rebuild(), and MAX_RECALC.

Referenced by handle_cli_core_show_translation().

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

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 1099 of file translate.c.

References 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, ast_cli_args::fd, 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().

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

handle_show_translation_table()

static char* handle_show_translation_table ( struct ast_cli_args *  a )

static

Definition at line 988 of file translate.c.

References 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(), ast_cli_args::fd, matrix_get(), ast_codec::name, NULL, out, ast_codec::sample_rate, translator_path::step, translator_path::table_cost, and ast_codec::type.

Referenced by handle_cli_core_show_translation().

{
   int x, y, i, k;
   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 */
            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;
}

index2codec()

static struct ast_codec* index2codec ( int  index )

static

Definition at line 170 of file translate.c.

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

Referenced by matrix_rebuild().

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

matrix_clear()

static void matrix_clear ( void  )

static

Definition at line 268 of file translate.c.

References index_size.

Referenced by matrix_rebuild().

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

matrix_get()

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

static

Definition at line 282 of file translate.c.

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().

{
   return __matrix[x] + y;
}

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 824 of file translate.c.

References ast_translator::active, ao2_ref, ast_debug, ast_log, AST_RWLIST_TRAVERSE, ast_translator::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, translator_path::table_cost, and ast_translator::table_cost.

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

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

   /*
    * 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;
      }
   }
}

matrix_resize()

static int matrix_resize ( int  init )

static

Definition at line 194 of file translate.c.

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

Referenced by __ast_register_translator(), and ast_translate_init().

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

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 311 of file translate.c.

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_trans_pvt::c, ast_frame::data, ast_translator::desc_size, destroy(), ast_translator::dst_codec, ast_trans_pvt::explicit_dst, ast_trans_pvt::f, ast_translator::format, ast_frame_subclass::format, ast_frame::frametype, len(), LOG_ERROR, ast_frame::mallocd, ast_translator::module, ast_codec::name, ast_translator::name, ast_translator::newpvt, NULL, ast_frame::offset, ast_trans_pvt::outbuf, ast_frame::ptr, ast_trans_pvt::pvt, ast_codec::sample_rate, ast_frame::src, ast_frame::subclass, ast_trans_pvt::t, and ast_codec::type.

Referenced by ast_translator_build_path(), and generate_computational_cost().

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

translate_shutdown()

static void translate_shutdown ( void  )

static

Definition at line 1613 of file translate.c.

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

Referenced by ast_translate_init().

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

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 83 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 reconstricted 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 76 of file translate.c.

cli_translate

struct ast_cli_entry cli_translate[]

static

Initial value:

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

Definition at line 1215 of file translate.c.

cur_max_index

int cur_max_index

static

the current largest index used by the __matrix and __indextable arrays

Definition at line 94 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 96 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 86 of file translate.c.

translators

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

static