translate.c File Reference

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

Go to the source code of this file.

Data Structures
struct	ast_frame_delivery
struct	ast_trans_pvt
struct	ast_translator_dir
Defines
#define	SHOW_TRANS   11
Functions
void	ast_translator_free_path (struct ast_trans_pvt *p)
	Frees a translator path.
ast_trans_pvt *	ast_translator_build_path (int dest, int source)
	Builds a translator path.
ast_frame *	ast_translate (struct ast_trans_pvt *path, struct ast_frame *f, int consume)
	translates one or more frames
int	ast_register_translator (struct ast_translator *t)
	Register a translator.
int	ast_unregister_translator (struct ast_translator *t)
	Unregister a translator.
int	ast_translator_best_choice (int *dst, int *srcs)
	Chooses the best translation path.

---

Define Documentation

#define SHOW_TRANS   11

---

Function Documentation

int ast_register_translator (  struct ast_translator *  t  )

Register a translator. Parameters: t  populated ast_translator structure This registers a codec translator with asterisk Returns 0 on success, -1 on failure Definition at line 297 of file translate.c. References ast_cli_register(), ast_getformatname(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_verbose(), COLOR_BLACK, COLOR_MAGENTA, ast_translator::cost, ast_translator::dstfmt, LOG_WARNING, MAX_FORMAT, ast_translator::name, ast_translator::next, option_verbose, ast_translator::srcfmt, term_color(), and VERBOSE_PREFIX_2. { char tmp[80]; t->srcfmt = powerof(t->srcfmt); t->dstfmt = powerof(t->dstfmt); if ((t->srcfmt >= MAX_FORMAT) || (t->dstfmt >= MAX_FORMAT)) { ast_log(LOG_WARNING, "Format %s is larger than MAX_FORMAT\n", ast_getformatname(t->srcfmt)); return -1; } calc_cost(t); if (option_verbose > 1) 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); ast_mutex_lock(&list_lock); if (!added_cli) { ast_cli_register(&show_trans); added_cli++; } t->next = list; list = t; rebuild_matrix(); ast_mutex_unlock(&list_lock); return 0; }

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

translates one or more frames Parameters: tr  translator structure to use for translation f  frame to translate consume  Whether or not to free the original frame Apply an input frame into the translator and receive zero or one output frames. Consume determines whether the original frame should be freed Returns an ast_frame of the new translation format on success, NULL on failure Definition at line 136 of file translate.c. References ast_frfree(), ast_log(), ast_translator::framein, LOG_WARNING, and ast_trans_pvt::step. Referenced by ast_read(), ast_write(), and ast_writestream(). { struct ast_trans_pvt *p; struct ast_frame *out; p = path; /* Feed the first frame into the first translator */ p->step->framein(p->state, f); if (consume) ast_frfree(f); while(p) { out = p->step->frameout(p->state); /* If we get nothing out, return NULL */ if (!out) return NULL; /* If there is a next state, feed it in there. If not, return this frame */ if (p->next) p->next->step->framein(p->next->state, out); else return out; p = p->next; } ast_log(LOG_WARNING, "I should never get here...\n"); return NULL; }

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 0 on success, -1 if no path could be found. Modifies dests and srcs in place Definition at line 342 of file translate.c. References ast_mutex_lock, ast_mutex_unlock, ast_translator_dir::cost, MAX_FORMAT, and ast_translator_dir::step. Referenced by ast_channel_make_compatible(), ast_request(), ast_set_read_format(), and ast_set_write_format(). { /* Calculate our best source format, given costs, and a desired destination */ int x,y; int best=-1; int bestdst=0; int cur = 1; int besttime=999999999; ast_mutex_lock(&list_lock); for (y=0;y<MAX_FORMAT;y++) { if ((cur & *dst) && (cur & *srcs)) { /* This is a common format to both. Pick it if we don't have one already */ besttime=0; bestdst = cur; best = cur; break; } if (cur & *dst) for (x=0;x<MAX_FORMAT;x++) { if (tr_matrix[x][y].step && /* There's a step */ (tr_matrix[x][y].cost < besttime) && /* We're better than what exists now */ (*srcs & (1 << x))) /* x is a valid source format */ { best = 1 << x; bestdst = cur; besttime = tr_matrix[x][y].cost; } } cur = cur << 1; } if (best > -1) { *srcs = best; *dst = bestdst; best = 0; } ast_mutex_unlock(&list_lock); return best; }

struct ast_trans_pvt* ast_translator_build_path (  int  dest, int  source )

Builds a translator path. Parameters: dest  destination format source  source format Build a path (possibly NULL) from source to dest Returns ast_trans_pvt on success, NULL on failure Definition at line 90 of file translate.c. References ast_getformatname(), ast_log(), free, LOG_WARNING, malloc, ast_translator::new, and ast_translator_dir::step. Referenced by ast_set_read_format(), ast_set_write_format(), and ast_writestream(). { struct ast_trans_pvt *tmpr = NULL, *tmp = NULL; /* One of the hardest parts: Build a set of translators based upon the given source and destination formats */ source = powerof(source); dest = powerof(dest); while(source != dest) { if (tr_matrix[source][dest].step) { if (tmp) { tmp->next = malloc(sizeof(struct ast_trans_pvt)); tmp = tmp->next; } else tmp = malloc(sizeof(struct ast_trans_pvt)); if (tmp) { tmp->next = NULL; tmp->step = tr_matrix[source][dest].step; tmp->state = tmp->step->new(); if (!tmp->state) { ast_log(LOG_WARNING, "Failed to build translator step from %d to %d\n", source, dest); free(tmp); tmp = NULL; return NULL; } /* Set the root, if it doesn't exist yet... */ if (!tmpr) tmpr = tmp; /* Keep going if this isn't the final destination */ source = tmp->step->dstfmt; } else { /* XXX This could leak XXX */ ast_log(LOG_WARNING, "Out of memory\n"); return NULL; } } else { /* We shouldn't have allocated any memory */ ast_log(LOG_WARNING, "No translator path from %s to %s\n", ast_getformatname(source), ast_getformatname(dest)); return NULL; } } return tmpr; }

void ast_translator_free_path (  struct ast_trans_pvt *  tr  )

Frees a translator path. Parameters: tr  translator path to get rid of Frees the given translator path structure Definition at line 78 of file translate.c. References ast_translator::destroy, free, ast_trans_pvt::next, and ast_trans_pvt::step. Referenced by ast_channel_free(), ast_closestream(), ast_set_read_format(), ast_set_write_format(), and ast_writestream(). { struct ast_trans_pvt *pl; while(p) { pl = p; p = p->next; if (pl->state && pl->step->destroy) pl->step->destroy(pl->state); free(pl); } }

int ast_unregister_translator (  struct ast_translator *  t  )

Unregister a translator. Parameters: t  translator to unregister Unregisters the given tranlator Returns 0 on success, -1 on failure Definition at line 321 of file translate.c. References ast_mutex_lock, ast_mutex_unlock, and ast_translator::next. { struct ast_translator *u, *ul = NULL; ast_mutex_lock(&list_lock); u = list; while(u) { if (u == t) { if (ul) ul->next = u->next; else list = u->next; break; } ul = u; u = u->next; } rebuild_matrix(); ast_mutex_unlock(&list_lock); return (u ? 0 : -1); }

---