Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:57 2007

Asterisk developer's documentation :: Codename Pineapple

---

translate.c File Reference

---

Detailed Description

Translate via the use of pseudo channels.

Author:

Mark Spencer <markster@digium.com>

Definition in file translate.c.

#include "asterisk.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/logger.h"
#include "asterisk/translate.h"
#include "asterisk/module.h"
#include "asterisk/options.h"
#include "asterisk/frame.h"
#include "asterisk/sched.h"
#include "asterisk/cli.h"
#include "asterisk/term.h"

Include dependency graph for translate.c:

Go to the source code of this file.

Data Structures
struct	translator_path
Defines
#define	MAX_RECALC   200
#define	SHOW_TRANS   13
Functions
int	__ast_register_translator (struct ast_translator *t, struct ast_module *mod)
	Register a translator This registers a codec translator with asterisk.
static	AST_RWLIST_HEAD_STATIC (translators, ast_translator)
	the list of translators
ast_frame *	ast_trans_frameout (struct ast_trans_pvt *pvt, int datalen, int samples)
	generic frameout function
ast_frame *	ast_translate (struct ast_trans_pvt *path, struct ast_frame *f, int consume)
	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
unsigned int	ast_translate_available_formats (unsigned int dest, unsigned int src)
	Mask off unavailable formats from a format bitmask.
unsigned int	ast_translate_path_steps (unsigned int dest, unsigned int src)
	Returns the number of steps required to convert from 'src' to 'dest'.
void	ast_translator_activate (struct ast_translator *t)
	Activate a previously deactivated translator.
int	ast_translator_best_choice (int *dst, int *srcs)
	Chooses the best translation path.
ast_trans_pvt *	ast_translator_build_path (int dest, int source)
	Builds a translator path Build a path (possibly NULL) from source to dest.
void	ast_translator_deactivate (struct ast_translator *t)
	Deactivate a translator.
void	ast_translator_free_path (struct ast_trans_pvt *p)
	Frees a translator path Frees the given translator path structure.
int	ast_unregister_translator (struct ast_translator *t)
	Unregister a translator Unregisters the given tranlator.
static void	calc_cost (struct ast_translator *t, int seconds)
	compute the cost of a single translation step
static struct ast_frame *	default_frameout (struct ast_trans_pvt *pvt)
static void	destroy (struct ast_trans_pvt *pvt)
static int	framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
	framein wrapper, deals with plc and bound checks.
static void *	newpvt (struct ast_translator *t)
	Allocate the descriptor, required outbuf space, and possibly also plc and desc.
static force_inline int	powerof (unsigned int d)
	returns the index of the lowest bit set
static void	rebuild_matrix (int samples)
	rebuild a translation matrix.
static int	show_translation (int fd, int argc, char *argv[])
Variables
static struct ast_cli_entry	cli_translate []
static const char	show_trans_usage []
static struct translator_path	tr_matrix [MAX_FORMAT][MAX_FORMAT]
	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.

---

Define Documentation

#define MAX_RECALC   200

Definition at line 49 of file translate.c. Referenced by show_translation().

#define SHOW_TRANS   13

Referenced by show_translation().

---

Function Documentation

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

Register a translator This registers a codec translator with asterisk. Parameters: t  populated ast_translator structure module  handle to the module that owns this translator Returns: 0 on success, -1 on failure Definition at line 572 of file translate.c. References ast_translator::active, ast_cli_register_multiple(), AST_FORMAT_SLINEAR, ast_getformatname(), 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_verbose(), ast_translator::buf_size, ast_translator::buffer_samples, calc_cost(), cli_translate, COLOR_BLACK, COLOR_MAGENTA, ast_translator::cost, default_frameout(), ast_translator::dstfmt, ast_translator::frameout, LOG_WARNING, MAX_FORMAT, ast_translator::module, ast_translator::name, option_verbose, ast_translator::plc_samples, powerof(), rebuild_matrix(), ast_translator::srcfmt, term_color(), and VERBOSE_PREFIX_2. { static int added_cli = 0; struct ast_translator *u; 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; } t->module = mod; t->srcfmt = powerof(t->srcfmt); t->dstfmt = powerof(t->dstfmt); t->active = 1; if (t->plc_samples) { if (t->buffer_samples < t->plc_samples) { ast_log(LOG_WARNING, "plc_samples %d buffer_samples %d\n", t->plc_samples, t->buffer_samples); return -1; } if (t->dstfmt != AST_FORMAT_SLINEAR) ast_log(LOG_WARNING, "plc_samples %d format %x\n", t->plc_samples, t->dstfmt); } if (t->srcfmt >= MAX_FORMAT) { ast_log(LOG_WARNING, "Source format %s is larger than MAX_FORMAT\n", ast_getformatname(t->srcfmt)); return -1; } if (t->dstfmt >= MAX_FORMAT) { ast_log(LOG_WARNING, "Destination format %s is larger than MAX_FORMAT\n", ast_getformatname(t->dstfmt)); 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; calc_cost(t, 1); if (option_verbose > 1) { char tmp[80]; ast_verbose(VERBOSE_PREFIX_2 "Registered translator '%s' from format %s to %s, cost %d\n", term_color(tmp, t->name, COLOR_MAGENTA, COLOR_BLACK, sizeof(tmp)), ast_getformatname(1 << t->srcfmt), ast_getformatname(1 << t->dstfmt), t->cost); } if (!added_cli) { ast_cli_register_multiple(cli_translate, sizeof(cli_translate) / sizeof(struct ast_cli_entry)); added_cli++; } AST_RWLIST_WRLOCK(&translators); /* find any existing translators that provide this same srcfmt/dstfmt, and put this one in order based on cost */ AST_RWLIST_TRAVERSE_SAFE_BEGIN(&translators, u, list) { if ((u->srcfmt == t->srcfmt) && (u->dstfmt == t->dstfmt) && (u->cost > t->cost)) { AST_RWLIST_INSERT_BEFORE_CURRENT(&translators, t, list); t = NULL; } } AST_RWLIST_TRAVERSE_SAFE_END; /* if no existing translator was found for this format combination, add it to the beginning of the list */ if (t) AST_RWLIST_INSERT_HEAD(&translators, t, list); rebuild_matrix(0); AST_RWLIST_UNLOCK(&translators); return 0; }

static AST_RWLIST_HEAD_STATIC (  translators  , ast_translator  )  [static]

the list of translators

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

generic frameout function Definition at line 207 of file translate.c. References AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_frame::data, ast_frame::datalen, ast_trans_pvt::datalen, ast_translator::dstfmt, ast_trans_pvt::f, ast_frame::frametype, ast_frame::mallocd, ast_translator::name, ast_frame::offset, ast_trans_pvt::outbuf, ast_frame::samples, ast_trans_pvt::samples, ast_frame::src, ast_frame::subclass, and ast_trans_pvt::t. Referenced by default_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; else { f->datalen = pvt->datalen; pvt->datalen = 0; } f->frametype = AST_FRAME_VOICE; f->subclass = 1 << (pvt->t->dstfmt); f->mallocd = 0; f->offset = AST_FRIENDLY_OFFSET; f->src = pvt->t->name; f->data = pvt->outbuf; return f; }

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

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 Parameters: tr  translator structure to use for translation f  frame to translate consume  Whether or not to free the original frame Returns: an ast_frame of the new translation format on success, NULL on failure Definition at line 293 of file translate.c. References ast_tvadd(), ast_tvsub(), ast_frame::delivery, framein(), ast_frame::has_timing_info, len, ast_frame::len, ast_trans_pvt::next, ast_trans_pvt::nextin, ast_trans_pvt::nextout, ast_frame::samples, ast_frame::seqno, and ast_frame::ts. Referenced by __ast_read(), ast_slinfactory_feed(), ast_write(), ast_writestream(), process_ast_dsp(), and queue_frame_to_spies(). { struct ast_trans_pvt *p = path; struct ast_frame *out = f; struct timeval delivery; int has_timing_info; long ts; long len; int seqno; has_timing_info = f->has_timing_info; ts = f->ts; len = f->len; seqno = f->seqno; /* XXX hmmm... check this below */ 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, 8000)); } delivery = f->delivery; for ( ; out && p ; p = p->next) { framein(p, out); out = p->t->frameout(p); } if (consume) ast_frfree(f); if (out == NULL) return NULL; /* we have a frame, play with times */ if (!ast_tvzero(delivery)) { /* Regenerate prediction after a discontinuity */ if (ast_tvzero(path->nextout)) path->nextout = ast_tvnow(); /* Use next predicted outgoing timestamp */ out->delivery = path->nextout; /* Predict next outgoing timestamp from samples in this frame. */ path->nextout = ast_tvadd(path->nextout, ast_samp2tv( out->samples, 8000)); } else { out->delivery = ast_tv(0, 0); out->has_timing_info = 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); return out; }

unsigned int ast_translate_available_formats (  unsigned int  dest, unsigned int  src )

Mask off unavailable formats from a format bitmask. Parameters: dest  possible destination formats src  source formats 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 that 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 777 of file translate.c. References AST_FORMAT_AUDIO_MASK, AST_FORMAT_MAX_AUDIO, AST_FORMAT_VIDEO_MASK, AST_RWLIST_RDLOCK, powerof(), and tr_matrix. Referenced by sip_call(). { unsigned int res = dest; unsigned int x; unsigned int src_audio = src & AST_FORMAT_AUDIO_MASK; unsigned int src_video = src & AST_FORMAT_VIDEO_MASK; /* if we don't have a source format, we just have to try all possible destination formats */ if (!src) return dest; /* If we have a source audio format, get its format index */ if (src_audio) src_audio = powerof(src_audio); /* If we have a source video format, get its format index */ if (src_video) src_video = powerof(src_video); AST_RWLIST_RDLOCK(&translators); /* For a given source audio format, traverse the list of known audio formats to determine whether there exists a translation path from the source format to the destination format. */ for (x = 1; src_audio && x < AST_FORMAT_MAX_AUDIO; x <<= 1) { /* if this is not a desired format, nothing to do */ if (!dest & x) continue; /* if the source is supplying this format, then we can leave it in the result */ if (src & x) continue; /* if we don't have a translation path from the src to this format, remove it from the result */ if (!tr_matrix[src_audio][powerof(x)].step) { res &= ~x; continue; } /* now check the opposite direction */ if (!tr_matrix[powerof(x)][src_audio].step) res &= ~x; } /* For a given source video format, traverse the list of known video formats to determine whether there exists a translation path from the source format to the destination format. */ for (; src_video && x < AST_FORMAT_MAX_VIDEO; x <<= 1) { /* if this is not a desired format, nothing to do */ if (!dest & x) continue; /* if the source is supplying this format, then we can leave it in the result */ if (src & x) continue; /* if we don't have a translation path from the src to this format, remove it from the result */ if (!tr_matrix[src_video][powerof(x)].step) { res &= ~x; continue; } /* now check the opposite direction */ if (!tr_matrix[powerof(x)][src_video].step) res &= ~x; } AST_RWLIST_UNLOCK(&translators); return res; }

unsigned int ast_translate_path_steps (  unsigned int  dest, unsigned int  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 759 of file translate.c. References AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, translator_path::multistep, powerof(), and tr_matrix. Referenced by ast_channel_make_compatible_helper(). { unsigned int res = -1; /* convert bitwise format numbers into array indices */ src = powerof(src); dest = powerof(dest); AST_RWLIST_RDLOCK(&translators); if (tr_matrix[src][dest].step) res = tr_matrix[src][dest].multistep + 1; AST_RWLIST_UNLOCK(&translators); return res; }

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 695 of file translate.c. References ast_translator::active, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and rebuild_matrix(). { AST_RWLIST_WRLOCK(&translators); t->active = 1; rebuild_matrix(0); AST_RWLIST_UNLOCK(&translators); }

int ast_translator_best_choice (  int *  dsts, int *  srcs )

Chooses the best translation path. Given a list of sources, and a designed destination format, which should I choose? Returns: Returns 0 on success, -1 if no path could be found. Note: Modifies dests and srcs in place Definition at line 712 of file translate.c. References MAX_FORMAT. Referenced by ast_channel_make_compatible_helper(), ast_request(), iax2_request(), and set_format(). { int x,y; int best = -1; int bestdst = 0; int cur, cursrc; int besttime = INT_MAX; int beststeps = INT_MAX; int common = (*dst) & (*srcs); /* are there common formats ? */ if (common) { /* yes, pick one and return */ for (cur = 1, y = 0; y < MAX_FORMAT; cur <<= 1, y++) { if (cur & common) /* guaranteed to find one */ break; } /* We are done, this is a common format to both. */ *srcs = *dst = cur; return 0; } else { /* No, we will need to translate */ AST_RWLIST_RDLOCK(&translators); for (cur = 1, y = 0; y < MAX_FORMAT; cur <<= 1, y++) { if (! (cur & *dst)) continue; for (cursrc = 1, x = 0; x < MAX_FORMAT; cursrc <<= 1, x++) { if (!(*srcs & cursrc) || !tr_matrix[x][y].step || tr_matrix[x][y].cost > besttime) continue; /* not existing or no better */ if (tr_matrix[x][y].cost < besttime || tr_matrix[x][y].multistep < beststeps) { /* better than what we have so far */ best = cursrc; bestdst = cur; besttime = tr_matrix[x][y].cost; beststeps = tr_matrix[x][y].multistep; } } } AST_RWLIST_UNLOCK(&translators); if (best > -1) { *srcs = best; *dst = bestdst; best = 0; } return best; } }

struct ast_trans_pvt* ast_translator_build_path (  int  dest, int  source )

Builds a translator path Build a path (possibly NULL) from source to dest. Parameters: dest  destination format source  source format Returns: ast_trans_pvt on success, NULL on failure Definition at line 253 of file translate.c. References ast_getformatname(), ast_log(), AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_translator_free_path(), ast_translator::dstfmt, LOG_WARNING, newpvt(), ast_trans_pvt::next, ast_trans_pvt::nextin, ast_trans_pvt::nextout, powerof(), translator_path::step, ast_trans_pvt::t, and tr_matrix. Referenced by ast_slinfactory_feed(), ast_write(), ast_writestream(), queue_frame_to_spies(), read_config(), and set_format(). { struct ast_trans_pvt *head = NULL, *tail = NULL; source = powerof(source); dest = powerof(dest); AST_RWLIST_RDLOCK(&translators); while (source != dest) { struct ast_trans_pvt *cur; struct ast_translator *t = tr_matrix[source][dest].step; if (!t) { ast_log(LOG_WARNING, "No translator path from %s to %s\n", ast_getformatname(source), ast_getformatname(dest)); AST_RWLIST_UNLOCK(&translators); return NULL; } if (!(cur = newpvt(t))) { ast_log(LOG_WARNING, "Failed to build translator step from %d to %d\n", source, dest); if (head) 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 */ source = cur->t->dstfmt; } AST_RWLIST_UNLOCK(&translators); return head; }

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 703 of file translate.c. References ast_translator::active, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and rebuild_matrix(). { AST_RWLIST_WRLOCK(&translators); t->active = 0; rebuild_matrix(0); AST_RWLIST_UNLOCK(&translators); }

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 243 of file translate.c. References destroy(), and ast_trans_pvt::next. Referenced by ast_channel_free(), ast_channel_whisper_stop(), ast_closestream(), ast_slinfactory_destroy(), ast_slinfactory_feed(), ast_translator_build_path(), ast_write(), ast_writestream(), cl_dequeue_chan(), free_translation(), queue_frame_to_spies(), set_format(), and spy_cleanup(). { struct ast_trans_pvt *pn = p; while ( (p = pn) ) { pn = p->next; destroy(p); } }

int ast_unregister_translator (  struct ast_translator *  t  )

Unregister a translator Unregisters the given tranlator. Parameters: t  translator to unregister Returns: 0 on success, -1 on failure Definition at line 669 of file translate.c. References ast_getformatname(), AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verbose(), COLOR_BLACK, COLOR_MAGENTA, ast_translator::dstfmt, ast_translator::name, option_verbose, rebuild_matrix(), ast_translator::srcfmt, term_color(), and VERBOSE_PREFIX_2. { 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(&translators, list); if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Unregistered translator '%s' from format %s to %s\n", term_color(tmp, t->name, COLOR_MAGENTA, COLOR_BLACK, sizeof(tmp)), ast_getformatname(1 << t->srcfmt), ast_getformatname(1 << t->dstfmt)); found = 1; break; } } AST_RWLIST_TRAVERSE_SAFE_END; if (found) rebuild_matrix(0); AST_RWLIST_UNLOCK(&translators); return (u ? 0 : -1); }

static void calc_cost (  struct ast_translator *  t, int  seconds )  [static]

compute the cost of a single translation step Definition at line 367 of file translate.c. References ast_frfree(), ast_log(), ast_translator::cost, destroy(), framein(), ast_translator::frameout, LOG_WARNING, ast_translator::name, newpvt(), ast_trans_pvt::pvt, ast_translator::sample, and ast_frame::samples. Referenced by __ast_register_translator(), and rebuild_matrix(). { int sofar=0; struct ast_trans_pvt *pvt; struct timeval start; int cost; if (!seconds) seconds = 1; /* If they don't make samples, give them a terrible score */ if (!t->sample) { ast_log(LOG_WARNING, "Translator '%s' does not produce sample frames.\n", t->name); t->cost = 99999; return; } pvt = newpvt(t); if (!pvt) { ast_log(LOG_WARNING, "Translator '%s' appears to be broken and will probably fail.\n", t->name); t->cost = 99999; return; } start = ast_tvnow(); /* Call the encoder until we've processed the required number of samples */ while (sofar < seconds * 8000) { 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->cost = 99999; return; } framein(pvt, f); ast_frfree(f); while ((f = t->frameout(pvt))) { sofar += f->samples; ast_frfree(f); } } cost = ast_tvdiff_ms(ast_tvnow(), start); destroy(pvt); t->cost = cost / seconds; if (!t->cost) t->cost = 1; }

static struct ast_frame* default_frameout (  struct ast_trans_pvt *  pvt  )  [static]

Definition at line 236 of file translate.c. References ast_trans_frameout(). Referenced by __ast_register_translator(). { return ast_trans_frameout(pvt, 0, 0); }

static void destroy (  struct ast_trans_pvt *  pvt  )  [static]

Definition at line 139 of file translate.c. References ast_module_unref(), ast_translator::destroy, free, ast_translator::module, and ast_trans_pvt::t. Referenced by ast_translator_free_path(), and calc_cost(). { struct ast_translator *t = pvt->t; if (t->destroy) t->destroy(pvt); free(pvt); ast_module_unref(t->module); }

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

framein wrapper, deals with plc and bound checks. Definition at line 150 of file translate.c. References ast_log(), ast_translator::buffer_samples, ast_trans_pvt::datalen, ast_frame::datalen, ast_trans_pvt::f, ast_translator::framein, ast_frame::has_timing_info, ast_frame::len, LOG_WARNING, ast_translator::name, ast_trans_pvt::outbuf, ast_trans_pvt::plc, plc_fillin(), plc_rx(), ast_translator::plc_samples, ast_frame::samples, ast_trans_pvt::samples, ast_frame::seqno, ast_trans_pvt::t, and ast_frame::ts. Referenced by ast_translate(), and calc_cost(). { int16_t *dst = (int16_t *)pvt->outbuf; int ret; int samples = pvt->samples; /* initial value */ /* Copy the last in jb timing info to the pvt */ pvt->f.has_timing_info = f->has_timing_info; pvt->f.ts = f->ts; pvt->f.len = f->len; pvt->f.seqno = f->seqno; if (f->samples == 0) { ast_log(LOG_WARNING, "no samples for %s\n", pvt->t->name); } if (pvt->t->buffer_samples) { /* do not pass empty frames to callback */ if (f->datalen == 0) { /* perform PLC with nominal framesize of 20ms/160 samples */ if (pvt->plc) { int l = pvt->t->plc_samples; if (pvt->samples + l > pvt->t->buffer_samples) { ast_log(LOG_WARNING, "Out of buffer space\n"); return -1; } l = plc_fillin(pvt->plc, dst + pvt->samples, l); pvt->samples += l; pvt->datalen = pvt->samples * 2; /* SLIN has 2bytes for 1sample */ } return 0; } if (pvt->samples + f->samples > 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. */ ret = pvt->t->framein(pvt, f); /* possibly store data for plc */ if (!ret && pvt->plc) { int l = pvt->t->plc_samples; if (pvt->samples < l) l = pvt->samples; plc_rx(pvt->plc, dst + pvt->samples - l, l); } /* diagnostic ... */ if (pvt->samples == samples) ast_log(LOG_WARNING, "%s did not update samples %d\n", pvt->t->name, pvt->samples); return ret; }

static void* newpvt (  struct ast_translator *  t  )  [static]

Allocate the descriptor, required outbuf space, and possibly also plc and desc. Definition at line 99 of file translate.c. References ast_calloc, AST_FRIENDLY_OFFSET, ast_translator::buf_size, ast_translator::desc_size, free, len, ast_translator::newpvt, ast_translator::plc_samples, ast_trans_pvt::pvt, ast_trans_pvt::t, and ast_translator::useplc. Referenced by ast_translator_build_path(), and calc_cost(). { struct ast_trans_pvt *pvt; int len; int useplc = t->plc_samples > 0 && t->useplc; /* cache, because it can change on the fly */ char *ofs; /* * compute the required size adding private descriptor, * plc, buffer, AST_FRIENDLY_OFFSET. */ len = sizeof(*pvt) + t->desc_size; if (useplc) len += sizeof(plc_state_t); 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 (useplc) { /* then plc state */ pvt->plc = (plc_state_t *)ofs; ofs += sizeof(plc_state_t); } if (t->buf_size) /* finally buffer and header */ pvt->outbuf = ofs + AST_FRIENDLY_OFFSET; /* call local init routine, if present */ if (t->newpvt && t->newpvt(pvt)) { free(pvt); return NULL; } ast_module_ref(t->module); return pvt; }

static force_inline int powerof (  unsigned int  d  )  [static]

returns the index of the lowest bit set Definition at line 79 of file translate.c. References ast_log(), and LOG_WARNING. Referenced by __ast_register_translator(), agents_show(), ast_translate_available_formats(), ast_translate_path_steps(), and ast_translator_build_path(). { int x = ffs(d); if (x) return x - 1; ast_log(LOG_WARNING, "No bits set? %d\n", d); return -1; }

static void rebuild_matrix (  int  samples  )  [static]

rebuild a translation matrix. Note: This function expects the list of translators to be locked Definition at line 417 of file translate.c. References ast_translator::active, ast_getformatname(), ast_log(), AST_RWLIST_TRAVERSE, calc_cost(), ast_translator::cost, ast_translator::dstfmt, LOG_DEBUG, MAX_FORMAT, option_debug, ast_translator::srcfmt, and tr_matrix. Referenced by __ast_register_translator(), ast_translator_activate(), ast_translator_deactivate(), ast_unregister_translator(), and show_translation(). { struct ast_translator *t; int x; /* source format index */ int y; /* intermediate format index */ int z; /* destination format index */ if (option_debug) ast_log(LOG_DEBUG, "Resetting translation matrix\n"); bzero(tr_matrix, sizeof(tr_matrix)); /* first, compute all direct costs */ AST_RWLIST_TRAVERSE(&translators, t, list) { if (!t->active) continue; x = t->srcfmt; z = t->dstfmt; if (samples) calc_cost(t, samples); if (!tr_matrix[x][z].step || t->cost < tr_matrix[x][z].cost) { tr_matrix[x][z].step = t; tr_matrix[x][z].cost = t->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 < MAX_FORMAT; x++) { /* source format */ for (y=0; y < MAX_FORMAT; y++) { /* intermediate format */ if (x == y) /* skip ourselves */ continue; for (z=0; z<MAX_FORMAT; z++) { /* dst format */ int newcost; if (z == x || z == y) /* skip null conversions */ continue; if (!tr_matrix[x][y].step) /* no path from x to y */ continue; if (!tr_matrix[y][z].step) /* no path from y to z */ continue; newcost = tr_matrix[x][y].cost + tr_matrix[y][z].cost; if (tr_matrix[x][z].step && newcost >= tr_matrix[x][z].cost) continue; /* x->y->z is more expensive than * the existing path */ /* ok, we can get from x to z via y with a cost that is the sum of the transition from x to y and from y to z */ tr_matrix[x][z].step = tr_matrix[x][y].step; tr_matrix[x][z].cost = newcost; tr_matrix[x][z].multistep = 1; if (option_debug) ast_log(LOG_DEBUG, "Discovered %d cost path from %s to %s, via %d\n", tr_matrix[x][z].cost, ast_getformatname(x), ast_getformatname(z), y); changed++; } } } if (!changed) break; } }

static int show_translation (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 490 of file translate.c. References ast_cli(), ast_getformatname(), AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, MAX_RECALC, rebuild_matrix(), RESULT_SHOWUSAGE, and SHOW_TRANS. { #define SHOW_TRANS 13 int x, y, z; int curlen = 0, longest = 0; if (argc > 5) return RESULT_SHOWUSAGE; if (argv[3] && !strcasecmp(argv[3], "recalc")) { z = argv[4] ? atoi(argv[4]) : 1; if (z <= 0) { ast_cli(fd, " C'mon let's be serious here... defaulting to 1.\n"); z = 1; } if (z > MAX_RECALC) { ast_cli(fd, " Maximum limit of recalc exceeded by %d, truncating value to %d\n", z - MAX_RECALC, MAX_RECALC); z = MAX_RECALC; } ast_cli(fd, " Recalculating Codec Translation (number of sample seconds: %d)\n\n", z); AST_RWLIST_WRLOCK(&translators); rebuild_matrix(z); AST_RWLIST_UNLOCK(&translators); } AST_RWLIST_RDLOCK(&translators); ast_cli(fd, " Translation times between formats (in milliseconds) for one second of data\n"); ast_cli(fd, " Source Format (Rows) Destination Format (Columns)\n\n"); /* Get the length of the longest (usable?) codec name, so we know how wide the left side should be */ for (x = 0; x < SHOW_TRANS; x++) { curlen = strlen(ast_getformatname(1 << (x + 1))); if (curlen > longest) longest = curlen; } for (x = -1; x < SHOW_TRANS; x++) { struct ast_str *out = ast_str_alloca(120); ast_str_set(&out, -1, " "); for (y = -1; y < SHOW_TRANS; y++) { curlen = strlen(ast_getformatname(1 << (y))); if (x >= 0 && y >= 0 && tr_matrix[x][y].step) { /* XXX 999 is a little hackish We don't want this number being larger than the shortest (or current) codec For now, that is "gsm" */ ast_str_append(&out, -1, "%*d", curlen + 1, tr_matrix[x][y].cost > 999 ? 0 : tr_matrix[x][y].cost); } else if (x == -1 && y >= 0) { /* Top row - use a dynamic size */ ast_str_append(&out, -1, "%*s", curlen + 1, ast_getformatname(1 << (x + y + 1)) ); } else if (y == -1 && x >= 0) { /* Left column - use a static size. */ ast_str_append(&out, -1, "%*s", longest, ast_getformatname(1 << (x + y + 1)) ); } else if (x >= 0 && y >= 0) { ast_str_append(&out, -1, "%*s", curlen + 1, "-"); } else { ast_str_append(&out, -1, "%*s", longest, ""); } } ast_str_append(&out, -1, "\n"); ast_cli(fd, out->str); } AST_RWLIST_UNLOCK(&translators); return RESULT_SUCCESS; }

---

Variable Documentation

struct ast_cli_entry cli_translate[] [static]

Initial value: { { { "core", "show", "translation", NULL }, show_translation, "Display translation matrix", show_trans_usage, NULL, NULL }, } Definition at line 565 of file translate.c. Referenced by __ast_register_translator().

const char show_trans_usage[] [static]

Definition at line 558 of file translate.c.

struct translator_path tr_matrix[MAX_FORMAT][MAX_FORMAT] [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 70 of file translate.c. Referenced by ast_translate_available_formats(), ast_translate_path_steps(), ast_translator_build_path(), and rebuild_matrix().

---

Asterisk is a trademark for Digium, inc.. | Edvina.net | Asterisk.org | This documentation was generated with Doxygen