#include "asterisk.h"
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include "asterisk/lock.h"
#include "asterisk/frame.h"
#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/channel.h"
#include "asterisk/cli.h"
#include "asterisk/term.h"
#include "asterisk/utils.h"
#include "asterisk/threadstorage.h"
#include "asterisk/linkedlists.h"
#include "asterisk/translate.h"
#include "asterisk/dsp.h"
#include "asterisk/file.h"
Go to the source code of this file.
Data Structures | |
struct | ast_codec_alias_table |
struct | ast_frame_cache |
struct | ast_frames |
This is just so ast_frames, a list head struct for holding a list of ast_frame structures, is defined. More... | |
struct | ast_smoother |
Defines | |
#define | FRAME_CACHE_MAX_SIZE 10 |
Maximum ast_frame cache size. | |
#define | SMOOTHER_SIZE 8000 |
#define | TYPE_MASK 0x3 |
Enumerations | |
enum | frame_type { TYPE_HIGH, TYPE_LOW, TYPE_SILENCE, TYPE_DONTSEND } |
Functions | |
int | __ast_smoother_feed (struct ast_smoother *s, struct ast_frame *f, int swap) |
static void | __frame_free (struct ast_frame *fr, int cache) |
char * | ast_codec2str (int codec) |
Get a name from a format Gets a name from a format. | |
int | ast_codec_choose (struct ast_codec_pref *pref, int formats, int find_best) |
Select the best audio format according to preference list from supplied options. If "find_best" is non-zero then if nothing is found, the "Best" format of the format list is selected, otherwise 0 is returned. | |
int | ast_codec_get_len (int format, int samples) |
Returns the number of bytes for the number of samples of the given format. | |
int | ast_codec_get_samples (struct ast_frame *f) |
Returns the number of samples contained in the frame. | |
int | ast_codec_pref_append (struct ast_codec_pref *pref, int format) |
Append a audio codec to a preference list, removing it first if it was already there. | |
void | ast_codec_pref_convert (struct ast_codec_pref *pref, char *buf, size_t size, int right) |
Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string. | |
ast_format_list | ast_codec_pref_getsize (struct ast_codec_pref *pref, int format) |
Get packet size for codec. | |
int | ast_codec_pref_index (struct ast_codec_pref *pref, int index) |
Codec located at a particular place in the preference index See Audio Codec Preferences. | |
void | ast_codec_pref_prepend (struct ast_codec_pref *pref, int format, int only_if_existing) |
Prepend an audio codec to a preference list, removing it first if it was already there. | |
void | ast_codec_pref_remove (struct ast_codec_pref *pref, int format) |
Remove audio a codec from a preference list. | |
int | ast_codec_pref_setsize (struct ast_codec_pref *pref, int format, int framems) |
Set packet size for codec. | |
int | ast_codec_pref_string (struct ast_codec_pref *pref, char *buf, size_t size) |
Dump audio codec preference list into a string. | |
static const char * | ast_expand_codec_alias (const char *in) |
int | ast_frame_adjust_volume (struct ast_frame *f, int adjustment) |
Adjusts the volume of the audio samples contained in a frame. | |
void | ast_frame_dump (const char *name, struct ast_frame *f, char *prefix) |
void | ast_frame_free (struct ast_frame *frame, int cache) |
Requests a frame to be allocated Frees a frame or list of frames. | |
static struct ast_frame * | ast_frame_header_new (void) |
int | ast_frame_slinear_sum (struct ast_frame *f1, struct ast_frame *f2) |
Sums two frames of audio samples. | |
ast_frame * | ast_frdup (const struct ast_frame *f) |
Copies a frame. | |
ast_frame * | ast_frisolate (struct ast_frame *fr) |
Makes a frame independent of any static storage. | |
ast_format_list * | ast_get_format_list (size_t *size) |
ast_format_list * | ast_get_format_list_index (int index) |
int | ast_getformatbyname (const char *name) |
Gets a format from a name. | |
char * | ast_getformatname (int format) |
Get the name of a format. | |
char * | ast_getformatname_multiple (char *buf, size_t size, int format) |
Get the names of a set of formats. | |
void | ast_parse_allow_disallow (struct ast_codec_pref *pref, int *mask, const char *list, int allowing) |
Parse an "allow" or "deny" line in a channel or device configuration and update the capabilities mask and pref if provided. Video codecs are not added to codec preference lists, since we can not transcode. | |
void | ast_smoother_free (struct ast_smoother *s) |
int | ast_smoother_get_flags (struct ast_smoother *s) |
ast_smoother * | ast_smoother_new (int size) |
ast_frame * | ast_smoother_read (struct ast_smoother *s) |
void | ast_smoother_reconfigure (struct ast_smoother *s, int bytes) |
Reconfigure an existing smoother to output a different number of bytes per frame. | |
void | ast_smoother_reset (struct ast_smoother *s, int bytes) |
void | ast_smoother_set_flags (struct ast_smoother *s, int flags) |
int | ast_smoother_test_flag (struct ast_smoother *s, int flag) |
void | ast_swapcopy_samples (void *dst, const void *src, int samples) |
static void | frame_cache_cleanup (void *data) |
static void | frame_cache_init (void) |
A per-thread cache of frame headers. | |
static int | g723_len (unsigned char buf) |
static int | g723_samples (unsigned char *buf, int maxlen) |
static unsigned char | get_n_bits_at (unsigned char *data, int n, int bit) |
int | init_framer (void) |
static int | show_codec_n (int fd, int argc, char *argv[]) |
static int | show_codec_n_deprecated (int fd, int argc, char *argv[]) |
static int | show_codecs (int fd, int argc, char *argv[]) |
static int | show_codecs_deprecated (int fd, int argc, char *argv[]) |
static int | smoother_frame_feed (struct ast_smoother *s, struct ast_frame *f, int swap) |
static int | speex_get_wb_sz_at (unsigned char *data, int len, int bit) |
static int | speex_samples (unsigned char *data, int len) |
Variables | |
static struct ast_format_list | AST_FORMAT_LIST [] |
Definition of supported media formats (codecs). | |
ast_frame | ast_null_frame = { AST_FRAME_NULL, } |
static struct ast_cli_entry | cli_show_audio_codecs |
static struct ast_cli_entry | cli_show_codec |
static struct ast_cli_entry | cli_show_codecs |
static struct ast_cli_entry | cli_show_image_codecs |
static struct ast_cli_entry | cli_show_video_codecs |
static struct ast_threadstorage | frame_cache = { .once = PTHREAD_ONCE_INIT , .key_init = frame_cache_init , } |
static char | frame_show_codec_n_usage [] |
static char | frame_show_codecs_usage [] |
static struct ast_cli_entry | my_clis [] |
Definition in file frame.c.
#define FRAME_CACHE_MAX_SIZE 10 |
Maximum ast_frame cache size.
In most cases where the frame header cache will be useful, the size of the cache will stay very small. However, it is not always the case that the same thread that allocates the frame will be the one freeing them, so sometimes a thread will never have any frames in its cache, or the cache will never be pulled from. For the latter case, we limit the maximum size.
Definition at line 65 of file frame.c.
Referenced by __frame_free(), and iax_frame_free().
#define SMOOTHER_SIZE 8000 |
#define TYPE_MASK 0x3 |
enum frame_type |
Definition at line 79 of file frame.c.
00079 { 00080 TYPE_HIGH, /* 0x0 */ 00081 TYPE_LOW, /* 0x1 */ 00082 TYPE_SILENCE, /* 0x2 */ 00083 TYPE_DONTSEND /* 0x3 */ 00084 };
int __ast_smoother_feed | ( | struct ast_smoother * | s, | |
struct ast_frame * | f, | |||
int | swap | |||
) |
Definition at line 211 of file frame.c.
References AST_FRAME_VOICE, ast_log(), AST_MIN_OFFSET, AST_SMOOTHER_FLAG_G729, ast_swapcopy_samples(), f, LOG_WARNING, s, smoother_frame_feed(), and SMOOTHER_SIZE.
00212 { 00213 if (f->frametype != AST_FRAME_VOICE) { 00214 ast_log(LOG_WARNING, "Huh? Can't smooth a non-voice frame!\n"); 00215 return -1; 00216 } 00217 if (!s->format) { 00218 s->format = f->subclass; 00219 s->samplesperbyte = (float)f->samples / (float)f->datalen; 00220 } else if (s->format != f->subclass) { 00221 ast_log(LOG_WARNING, "Smoother was working on %d format frames, now trying to feed %d?\n", s->format, f->subclass); 00222 return -1; 00223 } 00224 if (s->len + f->datalen > SMOOTHER_SIZE) { 00225 ast_log(LOG_WARNING, "Out of smoother space\n"); 00226 return -1; 00227 } 00228 if (((f->datalen == s->size) || 00229 ((f->datalen < 10) && (s->flags & AST_SMOOTHER_FLAG_G729))) && 00230 !s->opt && 00231 !s->len && 00232 (f->offset >= AST_MIN_OFFSET)) { 00233 /* Optimize by sending the frame we just got 00234 on the next read, thus eliminating the douple 00235 copy */ 00236 if (swap) 00237 ast_swapcopy_samples(f->data, f->data, f->samples); 00238 s->opt = f; 00239 s->opt_needs_swap = swap ? 1 : 0; 00240 return 0; 00241 } 00242 00243 return smoother_frame_feed(s, f, swap); 00244 }
static void __frame_free | ( | struct ast_frame * | fr, | |
int | cache | |||
) | [static] |
Definition at line 343 of file frame.c.
References AST_LIST_INSERT_HEAD, AST_MALLOCD_DATA, AST_MALLOCD_HDR, AST_MALLOCD_SRC, ast_threadstorage_get(), ast_frame::data, frame_cache, FRAME_CACHE_MAX_SIZE, frames, free, ast_frame::mallocd, ast_frame::offset, and ast_frame::src.
Referenced by ast_frame_free().
00344 { 00345 if (!fr->mallocd) 00346 return; 00347 00348 #if !defined(LOW_MEMORY) 00349 if (cache && fr->mallocd == AST_MALLOCD_HDR) { 00350 /* Cool, only the header is malloc'd, let's just cache those for now 00351 * to keep things simple... */ 00352 struct ast_frame_cache *frames; 00353 00354 if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames))) && 00355 (frames->size < FRAME_CACHE_MAX_SIZE)) { 00356 AST_LIST_INSERT_HEAD(&frames->list, fr, frame_list); 00357 frames->size++; 00358 return; 00359 } 00360 } 00361 #endif 00362 00363 if (fr->mallocd & AST_MALLOCD_DATA) { 00364 if (fr->data) 00365 free(fr->data - fr->offset); 00366 } 00367 if (fr->mallocd & AST_MALLOCD_SRC) { 00368 if (fr->src) 00369 free((void *) fr->src); 00370 } 00371 if (fr->mallocd & AST_MALLOCD_HDR) { 00372 free(fr); 00373 } 00374 }
char* ast_codec2str | ( | int | codec | ) |
Get a name from a format Gets a name from a format.
codec | codec number (1,2,4,8,16,etc.) |
Definition at line 645 of file frame.c.
References AST_FORMAT_LIST, and desc.
Referenced by moh_alloc(), show_codec_n(), show_codec_n_deprecated(), show_codecs(), and show_codecs_deprecated().
00646 { 00647 int x; 00648 char *ret = "unknown"; 00649 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 00650 if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == codec) { 00651 ret = AST_FORMAT_LIST[x].desc; 00652 break; 00653 } 00654 } 00655 return ret; 00656 }
int ast_codec_choose | ( | struct ast_codec_pref * | pref, | |
int | formats, | |||
int | find_best | |||
) |
Select the best audio format according to preference list from supplied options. If "find_best" is non-zero then if nothing is found, the "Best" format of the format list is selected, otherwise 0 is returned.
Definition at line 1284 of file frame.c.
References ast_best_codec(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_LIST, ast_log(), ast_format_list::bits, LOG_DEBUG, option_debug, and ast_codec_pref::order.
Referenced by __oh323_new(), gtalk_new(), process_sdp(), sip_new(), and socket_process().
01285 { 01286 int x, ret = 0, slot; 01287 01288 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01289 slot = pref->order[x]; 01290 01291 if (!slot) 01292 break; 01293 if (formats & AST_FORMAT_LIST[slot-1].bits) { 01294 ret = AST_FORMAT_LIST[slot-1].bits; 01295 break; 01296 } 01297 } 01298 if(ret & AST_FORMAT_AUDIO_MASK) 01299 return ret; 01300 01301 if (option_debug > 3) 01302 ast_log(LOG_DEBUG, "Could not find preferred codec - %s\n", find_best ? "Going for the best codec" : "Returning zero codec"); 01303 01304 return find_best ? ast_best_codec(formats) : 0; 01305 }
int ast_codec_get_len | ( | int | format, | |
int | samples | |||
) |
Returns the number of bytes for the number of samples of the given format.
Definition at line 1545 of file frame.c.
References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G722, AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_SLINEAR, AST_FORMAT_ULAW, ast_getformatname(), ast_log(), len(), and LOG_WARNING.
Referenced by moh_generate(), and monmp3thread().
01546 { 01547 int len = 0; 01548 01549 /* XXX Still need speex, g723, and lpc10 XXX */ 01550 switch(format) { 01551 case AST_FORMAT_ILBC: 01552 len = (samples / 240) * 50; 01553 break; 01554 case AST_FORMAT_GSM: 01555 len = (samples / 160) * 33; 01556 break; 01557 case AST_FORMAT_G729A: 01558 len = samples / 8; 01559 break; 01560 case AST_FORMAT_SLINEAR: 01561 len = samples * 2; 01562 break; 01563 case AST_FORMAT_ULAW: 01564 case AST_FORMAT_ALAW: 01565 len = samples; 01566 break; 01567 case AST_FORMAT_G722: 01568 case AST_FORMAT_ADPCM: 01569 case AST_FORMAT_G726: 01570 case AST_FORMAT_G726_AAL2: 01571 len = samples / 2; 01572 break; 01573 default: 01574 ast_log(LOG_WARNING, "Unable to calculate sample length for format %s\n", ast_getformatname(format)); 01575 } 01576 01577 return len; 01578 }
int ast_codec_get_samples | ( | struct ast_frame * | f | ) |
Returns the number of samples contained in the frame.
Definition at line 1502 of file frame.c.
References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G722, AST_FORMAT_G723_1, AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_LPC10, AST_FORMAT_SLINEAR, AST_FORMAT_SPEEX, AST_FORMAT_ULAW, ast_getformatname(), ast_log(), f, g723_samples(), LOG_WARNING, and speex_samples().
Referenced by ast_rtp_read(), isAnsweringMachine(), moh_generate(), schedule_delivery(), and socket_process().
01503 { 01504 int samples=0; 01505 switch(f->subclass) { 01506 case AST_FORMAT_SPEEX: 01507 samples = speex_samples(f->data, f->datalen); 01508 break; 01509 case AST_FORMAT_G723_1: 01510 samples = g723_samples(f->data, f->datalen); 01511 break; 01512 case AST_FORMAT_ILBC: 01513 samples = 240 * (f->datalen / 50); 01514 break; 01515 case AST_FORMAT_GSM: 01516 samples = 160 * (f->datalen / 33); 01517 break; 01518 case AST_FORMAT_G729A: 01519 samples = f->datalen * 8; 01520 break; 01521 case AST_FORMAT_SLINEAR: 01522 samples = f->datalen / 2; 01523 break; 01524 case AST_FORMAT_LPC10: 01525 /* assumes that the RTP packet contains one LPC10 frame */ 01526 samples = 22 * 8; 01527 samples += (((char *)(f->data))[7] & 0x1) * 8; 01528 break; 01529 case AST_FORMAT_ULAW: 01530 case AST_FORMAT_ALAW: 01531 samples = f->datalen; 01532 break; 01533 case AST_FORMAT_G722: 01534 case AST_FORMAT_ADPCM: 01535 case AST_FORMAT_G726: 01536 case AST_FORMAT_G726_AAL2: 01537 samples = f->datalen * 2; 01538 break; 01539 default: 01540 ast_log(LOG_WARNING, "Unable to calculate samples for format %s\n", ast_getformatname(f->subclass)); 01541 } 01542 return samples; 01543 }
int ast_codec_pref_append | ( | struct ast_codec_pref * | pref, | |
int | format | |||
) |
Append a audio codec to a preference list, removing it first if it was already there.
Definition at line 1143 of file frame.c.
References ast_codec_pref_remove(), AST_FORMAT_LIST, and ast_codec_pref::order.
Referenced by ast_parse_allow_disallow().
01144 { 01145 int x, newindex = 0; 01146 01147 ast_codec_pref_remove(pref, format); 01148 01149 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01150 if(AST_FORMAT_LIST[x].bits == format) { 01151 newindex = x + 1; 01152 break; 01153 } 01154 } 01155 01156 if(newindex) { 01157 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01158 if(!pref->order[x]) { 01159 pref->order[x] = newindex; 01160 break; 01161 } 01162 } 01163 } 01164 01165 return x; 01166 }
void ast_codec_pref_convert | ( | struct ast_codec_pref * | pref, | |
char * | buf, | |||
size_t | size, | |||
int | right | |||
) |
Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string.
pref | A codec preference list structure | |
buf | A string denoting codec preference, appropriate for use in line transmission | |
size | Size of buf | |
right | Boolean: if 0, convert from buf to pref; if 1, convert from pref to buf. |
Definition at line 1045 of file frame.c.
References ast_codec_pref::order.
Referenced by check_access(), create_addr(), dump_prefs(), and socket_process().
01046 { 01047 int x, differential = (int) 'A', mem; 01048 char *from, *to; 01049 01050 if(right) { 01051 from = pref->order; 01052 to = buf; 01053 mem = size; 01054 } else { 01055 to = pref->order; 01056 from = buf; 01057 mem = 32; 01058 } 01059 01060 memset(to, 0, mem); 01061 for (x = 0; x < 32 ; x++) { 01062 if(!from[x]) 01063 break; 01064 to[x] = right ? (from[x] + differential) : (from[x] - differential); 01065 } 01066 }
struct ast_format_list ast_codec_pref_getsize | ( | struct ast_codec_pref * | pref, | |
int | format | |||
) |
Get packet size for codec.
Definition at line 1245 of file frame.c.
References AST_FORMAT_LIST, ast_format_list::bits, and format.
Referenced by add_codec_to_sdp(), ast_rtp_bridge(), ast_rtp_codec_setpref(), ast_rtp_write(), handle_open_receive_channel_ack_message(), and transmit_connect().
01246 { 01247 int x, index = -1, framems = 0; 01248 struct ast_format_list fmt = {0}; 01249 01250 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01251 if(AST_FORMAT_LIST[x].bits == format) { 01252 fmt = AST_FORMAT_LIST[x]; 01253 index = x; 01254 break; 01255 } 01256 } 01257 01258 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01259 if(pref->order[x] == (index + 1)) { 01260 framems = pref->framing[x]; 01261 break; 01262 } 01263 } 01264 01265 /* size validation */ 01266 if(!framems) 01267 framems = AST_FORMAT_LIST[index].def_ms; 01268 01269 if(AST_FORMAT_LIST[index].inc_ms && framems % AST_FORMAT_LIST[index].inc_ms) /* avoid division by zero */ 01270 framems -= framems % AST_FORMAT_LIST[index].inc_ms; 01271 01272 if(framems < AST_FORMAT_LIST[index].min_ms) 01273 framems = AST_FORMAT_LIST[index].min_ms; 01274 01275 if(framems > AST_FORMAT_LIST[index].max_ms) 01276 framems = AST_FORMAT_LIST[index].max_ms; 01277 01278 fmt.cur_ms = framems; 01279 01280 return fmt; 01281 }
int ast_codec_pref_index | ( | struct ast_codec_pref * | pref, | |
int | index | |||
) |
Codec located at a particular place in the preference index See Audio Codec Preferences.
Definition at line 1103 of file frame.c.
References AST_FORMAT_LIST, ast_format_list::bits, and ast_codec_pref::order.
Referenced by _sip_show_peer(), add_sdp(), ast_codec_pref_string(), function_iaxpeer(), function_sippeer(), gtalk_invite(), iax2_show_peer(), print_codec_to_cli(), and socket_process().
01104 { 01105 int slot = 0; 01106 01107 01108 if((index >= 0) && (index < sizeof(pref->order))) { 01109 slot = pref->order[index]; 01110 } 01111 01112 return slot ? AST_FORMAT_LIST[slot-1].bits : 0; 01113 }
void ast_codec_pref_prepend | ( | struct ast_codec_pref * | pref, | |
int | format, | |||
int | only_if_existing | |||
) |
Prepend an audio codec to a preference list, removing it first if it was already there.
Definition at line 1169 of file frame.c.
References ARRAY_LEN, AST_FORMAT_LIST, ast_codec_pref::framing, and ast_codec_pref::order.
Referenced by create_addr().
01170 { 01171 int x, newindex = 0; 01172 01173 /* First step is to get the codecs "index number" */ 01174 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) { 01175 if (AST_FORMAT_LIST[x].bits == format) { 01176 newindex = x + 1; 01177 break; 01178 } 01179 } 01180 /* Done if its unknown */ 01181 if (!newindex) 01182 return; 01183 01184 /* Now find any existing occurrence, or the end */ 01185 for (x = 0; x < 32; x++) { 01186 if (!pref->order[x] || pref->order[x] == newindex) 01187 break; 01188 } 01189 01190 if (only_if_existing && !pref->order[x]) 01191 return; 01192 01193 /* Move down to make space to insert - either all the way to the end, 01194 or as far as the existing location (which will be overwritten) */ 01195 for (; x > 0; x--) { 01196 pref->order[x] = pref->order[x - 1]; 01197 pref->framing[x] = pref->framing[x - 1]; 01198 } 01199 01200 /* And insert the new entry */ 01201 pref->order[0] = newindex; 01202 pref->framing[0] = 0; /* ? */ 01203 }
void ast_codec_pref_remove | ( | struct ast_codec_pref * | pref, | |
int | format | |||
) |
Remove audio a codec from a preference list.
Definition at line 1116 of file frame.c.
References AST_FORMAT_LIST, and ast_codec_pref::order.
Referenced by ast_codec_pref_append(), and ast_parse_allow_disallow().
01117 { 01118 struct ast_codec_pref oldorder; 01119 int x, y = 0; 01120 int slot; 01121 int size; 01122 01123 if(!pref->order[0]) 01124 return; 01125 01126 memcpy(&oldorder, pref, sizeof(oldorder)); 01127 memset(pref, 0, sizeof(*pref)); 01128 01129 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01130 slot = oldorder.order[x]; 01131 size = oldorder.framing[x]; 01132 if(! slot) 01133 break; 01134 if(AST_FORMAT_LIST[slot-1].bits != format) { 01135 pref->order[y] = slot; 01136 pref->framing[y++] = size; 01137 } 01138 } 01139 01140 }
int ast_codec_pref_setsize | ( | struct ast_codec_pref * | pref, | |
int | format, | |||
int | framems | |||
) |
Set packet size for codec.
Definition at line 1206 of file frame.c.
References AST_FORMAT_LIST, ast_codec_pref::framing, and ast_codec_pref::order.
Referenced by ast_parse_allow_disallow(), and process_sdp_a_audio().
01207 { 01208 int x, index = -1; 01209 01210 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01211 if(AST_FORMAT_LIST[x].bits == format) { 01212 index = x; 01213 break; 01214 } 01215 } 01216 01217 if(index < 0) 01218 return -1; 01219 01220 /* size validation */ 01221 if(!framems) 01222 framems = AST_FORMAT_LIST[index].def_ms; 01223 01224 if(AST_FORMAT_LIST[index].inc_ms && framems % AST_FORMAT_LIST[index].inc_ms) /* avoid division by zero */ 01225 framems -= framems % AST_FORMAT_LIST[index].inc_ms; 01226 01227 if(framems < AST_FORMAT_LIST[index].min_ms) 01228 framems = AST_FORMAT_LIST[index].min_ms; 01229 01230 if(framems > AST_FORMAT_LIST[index].max_ms) 01231 framems = AST_FORMAT_LIST[index].max_ms; 01232 01233 01234 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 01235 if(pref->order[x] == (index + 1)) { 01236 pref->framing[x] = framems; 01237 break; 01238 } 01239 } 01240 01241 return x; 01242 }
int ast_codec_pref_string | ( | struct ast_codec_pref * | pref, | |
char * | buf, | |||
size_t | size | |||
) |
Dump audio codec preference list into a string.
Definition at line 1068 of file frame.c.
References ast_codec_pref_index(), and ast_getformatname().
Referenced by dump_prefs(), and socket_process().
01069 { 01070 int x, codec; 01071 size_t total_len, slen; 01072 char *formatname; 01073 01074 memset(buf,0,size); 01075 total_len = size; 01076 buf[0] = '('; 01077 total_len--; 01078 for(x = 0; x < 32 ; x++) { 01079 if(total_len <= 0) 01080 break; 01081 if(!(codec = ast_codec_pref_index(pref,x))) 01082 break; 01083 if((formatname = ast_getformatname(codec))) { 01084 slen = strlen(formatname); 01085 if(slen > total_len) 01086 break; 01087 strncat(buf, formatname, total_len - 1); /* safe */ 01088 total_len -= slen; 01089 } 01090 if(total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) { 01091 strncat(buf, "|", total_len - 1); /* safe */ 01092 total_len--; 01093 } 01094 } 01095 if(total_len) { 01096 strncat(buf, ")", total_len - 1); /* safe */ 01097 total_len--; 01098 } 01099 01100 return size - total_len; 01101 }
static const char* ast_expand_codec_alias | ( | const char * | in | ) | [static] |
Definition at line 616 of file frame.c.
Referenced by ast_getformatbyname().
00617 { 00618 int x; 00619 00620 for (x = 0; x < sizeof(ast_codec_alias_table) / sizeof(ast_codec_alias_table[0]); x++) { 00621 if(!strcmp(in,ast_codec_alias_table[x].alias)) 00622 return ast_codec_alias_table[x].realname; 00623 } 00624 return in; 00625 }
int ast_frame_adjust_volume | ( | struct ast_frame * | f, | |
int | adjustment | |||
) |
Adjusts the volume of the audio samples contained in a frame.
f | The frame containing the samples (must be AST_FRAME_VOICE and AST_FORMAT_SLINEAR) | |
adjustment | The number of dB to adjust up or down. |
Definition at line 1580 of file frame.c.
References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_slinear_saturated_divide(), ast_slinear_saturated_multiply(), and f.
Referenced by audiohook_read_frame_single(), and conf_run().
01581 { 01582 int count; 01583 short *fdata = f->data; 01584 short adjust_value = abs(adjustment); 01585 01586 if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR)) 01587 return -1; 01588 01589 if (!adjustment) 01590 return 0; 01591 01592 for (count = 0; count < f->samples; count++) { 01593 if (adjustment > 0) { 01594 ast_slinear_saturated_multiply(&fdata[count], &adjust_value); 01595 } else if (adjustment < 0) { 01596 ast_slinear_saturated_divide(&fdata[count], &adjust_value); 01597 } 01598 } 01599 01600 return 0; 01601 }
void ast_frame_dump | ( | const char * | name, | |
struct ast_frame * | f, | |||
char * | prefix | |||
) |
Dump a frame for debugging purposes
Definition at line 799 of file frame.c.
References AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_OFFHOOK, AST_CONTROL_OPTION, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_UNHOLD, AST_CONTROL_WINK, ast_copy_string(), AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_HTML, AST_FRAME_IAX, AST_FRAME_IMAGE, AST_FRAME_MODEM, AST_FRAME_NULL, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_getformatname(), AST_HTML_BEGIN, AST_HTML_DATA, AST_HTML_END, AST_HTML_LDCOMPLETE, AST_HTML_LINKREJECT, AST_HTML_LINKURL, AST_HTML_NOSUPPORT, AST_HTML_UNLINK, AST_HTML_URL, AST_MODEM_T38, AST_MODEM_V150, ast_strlen_zero(), ast_verbose(), COLOR_BLACK, COLOR_BRCYAN, COLOR_BRGREEN, COLOR_BRMAGENTA, COLOR_BRRED, COLOR_YELLOW, f, and term_color().
Referenced by __ast_read(), and ast_write().
00800 { 00801 const char noname[] = "unknown"; 00802 char ftype[40] = "Unknown Frametype"; 00803 char cft[80]; 00804 char subclass[40] = "Unknown Subclass"; 00805 char csub[80]; 00806 char moreinfo[40] = ""; 00807 char cn[60]; 00808 char cp[40]; 00809 char cmn[40]; 00810 00811 if (!name) 00812 name = noname; 00813 00814 00815 if (!f) { 00816 ast_verbose("%s [ %s (NULL) ] [%s]\n", 00817 term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)), 00818 term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 00819 term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn))); 00820 return; 00821 } 00822 /* XXX We should probably print one each of voice and video when the format changes XXX */ 00823 if (f->frametype == AST_FRAME_VOICE) 00824 return; 00825 if (f->frametype == AST_FRAME_VIDEO) 00826 return; 00827 switch(f->frametype) { 00828 case AST_FRAME_DTMF_BEGIN: 00829 strcpy(ftype, "DTMF Begin"); 00830 subclass[0] = f->subclass; 00831 subclass[1] = '\0'; 00832 break; 00833 case AST_FRAME_DTMF_END: 00834 strcpy(ftype, "DTMF End"); 00835 subclass[0] = f->subclass; 00836 subclass[1] = '\0'; 00837 break; 00838 case AST_FRAME_CONTROL: 00839 strcpy(ftype, "Control"); 00840 switch(f->subclass) { 00841 case AST_CONTROL_HANGUP: 00842 strcpy(subclass, "Hangup"); 00843 break; 00844 case AST_CONTROL_RING: 00845 strcpy(subclass, "Ring"); 00846 break; 00847 case AST_CONTROL_RINGING: 00848 strcpy(subclass, "Ringing"); 00849 break; 00850 case AST_CONTROL_ANSWER: 00851 strcpy(subclass, "Answer"); 00852 break; 00853 case AST_CONTROL_BUSY: 00854 strcpy(subclass, "Busy"); 00855 break; 00856 case AST_CONTROL_TAKEOFFHOOK: 00857 strcpy(subclass, "Take Off Hook"); 00858 break; 00859 case AST_CONTROL_OFFHOOK: 00860 strcpy(subclass, "Line Off Hook"); 00861 break; 00862 case AST_CONTROL_CONGESTION: 00863 strcpy(subclass, "Congestion"); 00864 break; 00865 case AST_CONTROL_FLASH: 00866 strcpy(subclass, "Flash"); 00867 break; 00868 case AST_CONTROL_WINK: 00869 strcpy(subclass, "Wink"); 00870 break; 00871 case AST_CONTROL_OPTION: 00872 strcpy(subclass, "Option"); 00873 break; 00874 case AST_CONTROL_RADIO_KEY: 00875 strcpy(subclass, "Key Radio"); 00876 break; 00877 case AST_CONTROL_RADIO_UNKEY: 00878 strcpy(subclass, "Unkey Radio"); 00879 break; 00880 case AST_CONTROL_PROGRESS: 00881 strcpy(subclass, "Call Progress"); 00882 break; 00883 case AST_CONTROL_PROCEEDING: 00884 strcpy(subclass, "Proceeding"); 00885 break; 00886 case AST_CONTROL_HOLD: 00887 strcpy(subclass, "Hold"); 00888 break; 00889 case AST_CONTROL_UNHOLD: 00890 strcpy(subclass, "UnHold"); 00891 break; 00892 case -1: 00893 strcpy(subclass, "Stop generators"); 00894 break; 00895 default: 00896 snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass); 00897 } 00898 break; 00899 case AST_FRAME_NULL: 00900 strcpy(ftype, "Null Frame"); 00901 strcpy(subclass, "N/A"); 00902 break; 00903 case AST_FRAME_IAX: 00904 /* Should never happen */ 00905 strcpy(ftype, "IAX Specific"); 00906 snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass); 00907 break; 00908 case AST_FRAME_TEXT: 00909 strcpy(ftype, "Text"); 00910 strcpy(subclass, "N/A"); 00911 ast_copy_string(moreinfo, f->data, sizeof(moreinfo)); 00912 break; 00913 case AST_FRAME_IMAGE: 00914 strcpy(ftype, "Image"); 00915 snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass)); 00916 break; 00917 case AST_FRAME_HTML: 00918 strcpy(ftype, "HTML"); 00919 switch(f->subclass) { 00920 case AST_HTML_URL: 00921 strcpy(subclass, "URL"); 00922 ast_copy_string(moreinfo, f->data, sizeof(moreinfo)); 00923 break; 00924 case AST_HTML_DATA: 00925 strcpy(subclass, "Data"); 00926 break; 00927 case AST_HTML_BEGIN: 00928 strcpy(subclass, "Begin"); 00929 break; 00930 case AST_HTML_END: 00931 strcpy(subclass, "End"); 00932 break; 00933 case AST_HTML_LDCOMPLETE: 00934 strcpy(subclass, "Load Complete"); 00935 break; 00936 case AST_HTML_NOSUPPORT: 00937 strcpy(subclass, "No Support"); 00938 break; 00939 case AST_HTML_LINKURL: 00940 strcpy(subclass, "Link URL"); 00941 ast_copy_string(moreinfo, f->data, sizeof(moreinfo)); 00942 break; 00943 case AST_HTML_UNLINK: 00944 strcpy(subclass, "Unlink"); 00945 break; 00946 case AST_HTML_LINKREJECT: 00947 strcpy(subclass, "Link Reject"); 00948 break; 00949 default: 00950 snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass); 00951 break; 00952 } 00953 break; 00954 case AST_FRAME_MODEM: 00955 strcpy(ftype, "Modem"); 00956 switch (f->subclass) { 00957 case AST_MODEM_T38: 00958 strcpy(subclass, "T.38"); 00959 break; 00960 case AST_MODEM_V150: 00961 strcpy(subclass, "V.150"); 00962 break; 00963 default: 00964 snprintf(subclass, sizeof(subclass), "Unknown MODEM frame '%d'\n", f->subclass); 00965 break; 00966 } 00967 break; 00968 default: 00969 snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype); 00970 } 00971 if (!ast_strlen_zero(moreinfo)) 00972 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n", 00973 term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)), 00974 term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 00975 f->frametype, 00976 term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)), 00977 f->subclass, 00978 term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)), 00979 term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn))); 00980 else 00981 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n", 00982 term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)), 00983 term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 00984 f->frametype, 00985 term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)), 00986 f->subclass, 00987 term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn))); 00988 }
void ast_frame_free | ( | struct ast_frame * | fr, | |
int | cache | |||
) |
Requests a frame to be allocated Frees a frame or list of frames.
fr | Frame to free, or head of list to free | |
cache | Whether to consider this frame for frame caching |
Definition at line 377 of file frame.c.
References __frame_free(), AST_LIST_NEXT, and ast_frame::next.
Referenced by mixmonitor_thread().
00378 { 00379 struct ast_frame *next; 00380 00381 for (next = AST_LIST_NEXT(frame, frame_list); 00382 frame; 00383 frame = next, next = frame ? AST_LIST_NEXT(frame, frame_list) : NULL) { 00384 __frame_free(frame, cache); 00385 } 00386 }
static struct ast_frame* ast_frame_header_new | ( | void | ) | [static] |
Definition at line 301 of file frame.c.
References ast_calloc, ast_calloc_cache, AST_LIST_REMOVE_HEAD, AST_MALLOCD_HDR, ast_threadstorage_get(), f, frame_cache, and frames.
Referenced by ast_frisolate().
00302 { 00303 struct ast_frame *f; 00304 00305 #if !defined(LOW_MEMORY) 00306 struct ast_frame_cache *frames; 00307 00308 if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) { 00309 if ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list))) { 00310 size_t mallocd_len = f->mallocd_hdr_len; 00311 memset(f, 0, sizeof(*f)); 00312 f->mallocd_hdr_len = mallocd_len; 00313 f->mallocd = AST_MALLOCD_HDR; 00314 frames->size--; 00315 return f; 00316 } 00317 } 00318 if (!(f = ast_calloc_cache(1, sizeof(*f)))) 00319 return NULL; 00320 #else 00321 if (!(f = ast_calloc(1, sizeof(*f)))) 00322 return NULL; 00323 #endif 00324 00325 f->mallocd_hdr_len = sizeof(*f); 00326 00327 return f; 00328 }
Sums two frames of audio samples.
f1 | The first frame (which will contain the result) | |
f2 | The second frame |
Definition at line 1603 of file frame.c.
References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_slinear_saturated_add(), ast_frame::data, ast_frame::frametype, ast_frame::samples, and ast_frame::subclass.
01604 { 01605 int count; 01606 short *data1, *data2; 01607 01608 if ((f1->frametype != AST_FRAME_VOICE) || (f1->subclass != AST_FORMAT_SLINEAR)) 01609 return -1; 01610 01611 if ((f2->frametype != AST_FRAME_VOICE) || (f2->subclass != AST_FORMAT_SLINEAR)) 01612 return -1; 01613 01614 if (f1->samples != f2->samples) 01615 return -1; 01616 01617 for (count = 0, data1 = f1->data, data2 = f2->data; 01618 count < f1->samples; 01619 count++, data1++, data2++) 01620 ast_slinear_saturated_add(data1, data2); 01621 01622 return 0; 01623 }
Copies a frame.
fr | frame to copy Duplicates a frame -- should only rarely be used, typically frisolate is good enough |
Definition at line 471 of file frame.c.
References ast_calloc_cache, ast_copy_flags, AST_FRFLAG_HAS_TIMING_INFO, AST_FRIENDLY_OFFSET, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_MALLOCD_HDR, ast_threadstorage_get(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, f, frame_cache, frames, ast_frame::frametype, len(), ast_frame::len, ast_frame::mallocd, ast_frame::mallocd_hdr_len, ast_frame::offset, ast_frame::samples, ast_frame::seqno, ast_frame::src, ast_frame::subclass, and ast_frame::ts.
Referenced by __ast_queue_frame(), ast_frisolate(), ast_jb_put(), ast_rtp_write(), ast_slinfactory_feed(), audiohook_read_frame_single(), autoservice_run(), process_rfc2833(), recordthread(), and rpt().
00472 { 00473 struct ast_frame *out = NULL; 00474 int len, srclen = 0; 00475 void *buf = NULL; 00476 00477 #if !defined(LOW_MEMORY) 00478 struct ast_frame_cache *frames; 00479 #endif 00480 00481 /* Start with standard stuff */ 00482 len = sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen; 00483 /* If we have a source, add space for it */ 00484 /* 00485 * XXX Watch out here - if we receive a src which is not terminated 00486 * properly, we can be easily attacked. Should limit the size we deal with. 00487 */ 00488 if (f->src) 00489 srclen = strlen(f->src); 00490 if (srclen > 0) 00491 len += srclen + 1; 00492 00493 #if !defined(LOW_MEMORY) 00494 if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) { 00495 AST_LIST_TRAVERSE_SAFE_BEGIN(&frames->list, out, frame_list) { 00496 if (out->mallocd_hdr_len >= len) { 00497 size_t mallocd_len = out->mallocd_hdr_len; 00498 AST_LIST_REMOVE_CURRENT(&frames->list, frame_list); 00499 memset(out, 0, sizeof(*out)); 00500 out->mallocd_hdr_len = mallocd_len; 00501 buf = out; 00502 frames->size--; 00503 break; 00504 } 00505 } 00506 AST_LIST_TRAVERSE_SAFE_END; 00507 } 00508 #endif 00509 00510 if (!buf) { 00511 if (!(buf = ast_calloc_cache(1, len))) 00512 return NULL; 00513 out = buf; 00514 out->mallocd_hdr_len = len; 00515 } 00516 00517 out->frametype = f->frametype; 00518 out->subclass = f->subclass; 00519 out->datalen = f->datalen; 00520 out->samples = f->samples; 00521 out->delivery = f->delivery; 00522 /* Set us as having malloc'd header only, so it will eventually 00523 get freed. */ 00524 out->mallocd = AST_MALLOCD_HDR; 00525 out->offset = AST_FRIENDLY_OFFSET; 00526 if (out->datalen) { 00527 out->data = buf + sizeof(*out) + AST_FRIENDLY_OFFSET; 00528 memcpy(out->data, f->data, out->datalen); 00529 } 00530 if (srclen > 0) { 00531 /* This may seem a little strange, but it's to avoid a gcc (4.2.4) compiler warning */ 00532 char *src; 00533 out->src = buf + sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen; 00534 src = (char *) out->src; 00535 /* Must have space since we allocated for it */ 00536 strcpy(src, f->src); 00537 } 00538 ast_copy_flags(out, f, AST_FRFLAG_HAS_TIMING_INFO); 00539 out->ts = f->ts; 00540 out->len = f->len; 00541 out->seqno = f->seqno; 00542 return out; 00543 }
Makes a frame independent of any static storage.
fr | frame to act upon Take a frame, and if it's not been malloc'd, make a malloc'd copy and if the data hasn't been malloced then make the data malloc'd. If you need to store frames, say for queueing, then you should call this function. |
Definition at line 393 of file frame.c.
References ast_copy_flags, ast_frame_header_new(), ast_frdup(), AST_FRFLAG_HAS_TIMING_INFO, AST_FRIENDLY_OFFSET, ast_malloc, AST_MALLOCD_DATA, AST_MALLOCD_HDR, AST_MALLOCD_SRC, ast_strdup, ast_test_flag, ast_frame::data, ast_frame::datalen, ast_frame::frametype, free, ast_frame::len, ast_frame::mallocd, ast_frame::offset, ast_frame::samples, ast_frame::seqno, ast_frame::src, ast_frame::subclass, and ast_frame::ts.
Referenced by ast_dsp_process(), ast_rtp_read(), ast_safe_sleep_conditional(), ast_slinfactory_feed(), ast_trans_frameout(), ast_write(), autoservice_run(), dahdi_decoder_frameout(), dahdi_encoder_frameout(), feature_request_and_dial(), jpeg_read_image(), and read_frame().
00394 { 00395 struct ast_frame *out; 00396 void *newdata; 00397 00398 /* if none of the existing frame is malloc'd, let ast_frdup() do it 00399 since it is more efficient 00400 */ 00401 if (fr->mallocd == 0) { 00402 return ast_frdup(fr); 00403 } 00404 00405 /* if everything is already malloc'd, we are done */ 00406 if ((fr->mallocd & (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) == 00407 (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) { 00408 return fr; 00409 } 00410 00411 if (!(fr->mallocd & AST_MALLOCD_HDR)) { 00412 /* Allocate a new header if needed */ 00413 if (!(out = ast_frame_header_new())) { 00414 return NULL; 00415 } 00416 out->frametype = fr->frametype; 00417 out->subclass = fr->subclass; 00418 out->datalen = fr->datalen; 00419 out->samples = fr->samples; 00420 out->offset = fr->offset; 00421 /* Copy the timing data */ 00422 ast_copy_flags(out, fr, AST_FRFLAG_HAS_TIMING_INFO); 00423 if (ast_test_flag(fr, AST_FRFLAG_HAS_TIMING_INFO)) { 00424 out->ts = fr->ts; 00425 out->len = fr->len; 00426 out->seqno = fr->seqno; 00427 } 00428 } else { 00429 out = fr; 00430 } 00431 00432 if (!(fr->mallocd & AST_MALLOCD_SRC) && fr->src) { 00433 if (!(out->src = ast_strdup(fr->src))) { 00434 if (out != fr) { 00435 free(out); 00436 } 00437 return NULL; 00438 } 00439 } else { 00440 out->src = fr->src; 00441 fr->src = NULL; 00442 fr->mallocd &= ~AST_MALLOCD_SRC; 00443 } 00444 00445 if (!(fr->mallocd & AST_MALLOCD_DATA)) { 00446 if (!(newdata = ast_malloc(fr->datalen + AST_FRIENDLY_OFFSET))) { 00447 if (out->src != fr->src) { 00448 free((void *) out->src); 00449 } 00450 if (out != fr) { 00451 free(out); 00452 } 00453 return NULL; 00454 } 00455 newdata += AST_FRIENDLY_OFFSET; 00456 out->offset = AST_FRIENDLY_OFFSET; 00457 out->datalen = fr->datalen; 00458 memcpy(newdata, fr->data, fr->datalen); 00459 out->data = newdata; 00460 } else { 00461 out->data = fr->data; 00462 fr->data = NULL; 00463 fr->mallocd &= ~AST_MALLOCD_DATA; 00464 } 00465 00466 out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA; 00467 00468 return out; 00469 }
struct ast_format_list* ast_get_format_list | ( | size_t * | size | ) |
Definition at line 561 of file frame.c.
References AST_FORMAT_LIST.
00562 { 00563 *size = (sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0])); 00564 return AST_FORMAT_LIST; 00565 }
struct ast_format_list* ast_get_format_list_index | ( | int | index | ) |
Definition at line 556 of file frame.c.
References AST_FORMAT_LIST.
00557 { 00558 return &AST_FORMAT_LIST[index]; 00559 }
int ast_getformatbyname | ( | const char * | name | ) |
Gets a format from a name.
name | string of format |
Definition at line 627 of file frame.c.
References ast_expand_codec_alias(), AST_FORMAT_LIST, and format.
Referenced by ast_parse_allow_disallow(), iax_template_parse(), reload_config(), and try_suggested_sip_codec().
00628 { 00629 int x, all, format = 0; 00630 00631 all = strcasecmp(name, "all") ? 0 : 1; 00632 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 00633 if(AST_FORMAT_LIST[x].visible && (all || 00634 !strcasecmp(AST_FORMAT_LIST[x].name,name) || 00635 !strcasecmp(AST_FORMAT_LIST[x].name,ast_expand_codec_alias(name)))) { 00636 format |= AST_FORMAT_LIST[x].bits; 00637 if(!all) 00638 break; 00639 } 00640 } 00641 00642 return format; 00643 }
char* ast_getformatname | ( | int | format | ) |
Get the name of a format.
format | id of format |
Definition at line 567 of file frame.c.
References AST_FORMAT_LIST, ast_format_list::bits, name, and ast_format_list::visible.
Referenced by __ast_play_and_record(), __ast_read(), __ast_register_translator(), __login_exec(), _sip_show_peer(), add_codec_to_answer(), add_codec_to_sdp(), agent_call(), ast_codec_get_len(), ast_codec_get_samples(), ast_codec_pref_string(), ast_dsp_process(), ast_frame_dump(), ast_openvstream(), ast_rtp_write(), ast_slinfactory_feed(), ast_streamfile(), ast_translator_build_path(), ast_unregister_translator(), ast_writestream(), background_detect_exec(), dahdi_read(), do_waiting(), eagi_exec(), func_channel_read(), function_iaxpeer(), function_sippeer(), gtalk_show_channels(), iax2_request(), iax2_show_channels(), iax2_show_peer(), iax_show_provisioning(), moh_classes_show(), moh_release(), oh323_rtp_read(), phone_setup(), print_codec_to_cli(), rebuild_matrix(), register_translator(), set_format(), set_local_capabilities(), set_peer_capabilities(), show_codecs(), show_codecs_deprecated(), show_file_formats(), show_file_formats_deprecated(), show_image_formats(), show_image_formats_deprecated(), show_translation(), show_translation_deprecated(), sip_request_call(), sip_rtp_read(), and socket_process().
00568 { 00569 int x; 00570 char *ret = "unknown"; 00571 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 00572 if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == format) { 00573 ret = AST_FORMAT_LIST[x].name; 00574 break; 00575 } 00576 } 00577 return ret; 00578 }
char* ast_getformatname_multiple | ( | char * | buf, | |
size_t | size, | |||
int | format | |||
) |
Get the names of a set of formats.
buf | a buffer for the output string | |
size | size of buf (bytes) | |
format | the format (combined IDs of codecs) Prints a list of readable codec names corresponding to "format". ex: for format=AST_FORMAT_GSM|AST_FORMAT_SPEEX|AST_FORMAT_ILBC it will return "0x602 (GSM|SPEEX|ILBC)" |
Definition at line 580 of file frame.c.
References AST_FORMAT_LIST, ast_format_list::bits, len(), name, and ast_format_list::visible.
Referenced by __ast_read(), __sip_show_channels(), _sip_show_peer(), add_sdp(), ast_streamfile(), function_iaxpeer(), function_sippeer(), gtalk_is_answered(), gtalk_newcall(), handle_showchan(), handle_showchan_deprecated(), iax2_show_peer(), process_sdp(), serialize_showchan(), set_format(), sip_new(), sip_request_call(), sip_show_channel(), sip_show_settings(), and sip_write().
00581 { 00582 int x; 00583 unsigned len; 00584 char *start, *end = buf; 00585 00586 if (!size) 00587 return buf; 00588 snprintf(end, size, "0x%x (", format); 00589 len = strlen(end); 00590 end += len; 00591 size -= len; 00592 start = end; 00593 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) { 00594 if (AST_FORMAT_LIST[x].visible && (AST_FORMAT_LIST[x].bits & format)) { 00595 snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name); 00596 len = strlen(end); 00597 end += len; 00598 size -= len; 00599 } 00600 } 00601 if (start == end) 00602 snprintf(start, size, "nothing)"); 00603 else if (size > 1) 00604 *(end -1) = ')'; 00605 return buf; 00606 }
void ast_parse_allow_disallow | ( | struct ast_codec_pref * | pref, | |
int * | mask, | |||
const char * | list, | |||
int | allowing | |||
) |
Parse an "allow" or "deny" line in a channel or device configuration and update the capabilities mask and pref if provided. Video codecs are not added to codec preference lists, since we can not transcode.
Definition at line 1307 of file frame.c.
References ast_codec_pref_append(), ast_codec_pref_remove(), ast_codec_pref_setsize(), AST_FORMAT_AUDIO_MASK, ast_getformatbyname(), ast_log(), ast_strdupa, format, LOG_DEBUG, LOG_WARNING, option_debug, and parse().
Referenced by action_originate(), apply_outgoing(), build_device(), build_peer(), build_user(), gtalk_create_member(), gtalk_load_config(), reload_config(), set_config(), and update_common_options().
01308 { 01309 char *parse = NULL, *this = NULL, *psize = NULL; 01310 int format = 0, framems = 0; 01311 01312 parse = ast_strdupa(list); 01313 while ((this = strsep(&parse, ","))) { 01314 framems = 0; 01315 if ((psize = strrchr(this, ':'))) { 01316 *psize++ = '\0'; 01317 if (option_debug) 01318 ast_log(LOG_DEBUG,"Packetization for codec: %s is %s\n", this, psize); 01319 framems = atoi(psize); 01320 if (framems < 0) 01321 framems = 0; 01322 } 01323 if (!(format = ast_getformatbyname(this))) { 01324 ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", this); 01325 continue; 01326 } 01327 01328 if (mask) { 01329 if (allowing) 01330 *mask |= format; 01331 else 01332 *mask &= ~format; 01333 } 01334 01335 /* Set up a preference list for audio. Do not include video in preferences 01336 since we can not transcode video and have to use whatever is offered 01337 */ 01338 if (pref && (format & AST_FORMAT_AUDIO_MASK)) { 01339 if (strcasecmp(this, "all")) { 01340 if (allowing) { 01341 ast_codec_pref_append(pref, format); 01342 ast_codec_pref_setsize(pref, format, framems); 01343 } 01344 else 01345 ast_codec_pref_remove(pref, format); 01346 } else if (!allowing) { 01347 memset(pref, 0, sizeof(*pref)); 01348 } 01349 } 01350 } 01351 }
void ast_smoother_free | ( | struct ast_smoother * | s | ) |
int ast_smoother_get_flags | ( | struct ast_smoother * | s | ) |
struct ast_smoother* ast_smoother_new | ( | int | size | ) |
Definition at line 186 of file frame.c.
References ast_malloc, ast_smoother_reset(), and s.
Referenced by ast_rtp_codec_setpref(), and ast_rtp_write().
00187 { 00188 struct ast_smoother *s; 00189 if (size < 1) 00190 return NULL; 00191 if ((s = ast_malloc(sizeof(*s)))) 00192 ast_smoother_reset(s, size); 00193 return s; 00194 }
struct ast_frame* ast_smoother_read | ( | struct ast_smoother * | s | ) |
Definition at line 246 of file frame.c.
References AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_samp2tv(), AST_SMOOTHER_FLAG_G729, ast_tvadd(), ast_tvzero(), len(), LOG_WARNING, and s.
Referenced by ast_rtp_write().
00247 { 00248 struct ast_frame *opt; 00249 int len; 00250 00251 /* IF we have an optimization frame, send it */ 00252 if (s->opt) { 00253 if (s->opt->offset < AST_FRIENDLY_OFFSET) 00254 ast_log(LOG_WARNING, "Returning a frame of inappropriate offset (%d).\n", 00255 s->opt->offset); 00256 opt = s->opt; 00257 s->opt = NULL; 00258 return opt; 00259 } 00260 00261 /* Make sure we have enough data */ 00262 if (s->len < s->size) { 00263 /* Or, if this is a G.729 frame with VAD on it, send it immediately anyway */ 00264 if (!((s->flags & AST_SMOOTHER_FLAG_G729) && (s->len % 10))) 00265 return NULL; 00266 } 00267 len = s->size; 00268 if (len > s->len) 00269 len = s->len; 00270 /* Make frame */ 00271 s->f.frametype = AST_FRAME_VOICE; 00272 s->f.subclass = s->format; 00273 s->f.data = s->framedata + AST_FRIENDLY_OFFSET; 00274 s->f.offset = AST_FRIENDLY_OFFSET; 00275 s->f.datalen = len; 00276 /* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */ 00277 s->f.samples = len * s->samplesperbyte; /* XXX rounding */ 00278 s->f.delivery = s->delivery; 00279 /* Fill Data */ 00280 memcpy(s->f.data, s->data, len); 00281 s->len -= len; 00282 /* Move remaining data to the front if applicable */ 00283 if (s->len) { 00284 /* In principle this should all be fine because if we are sending 00285 G.729 VAD, the next timestamp will take over anyawy */ 00286 memmove(s->data, s->data + len, s->len); 00287 if (!ast_tvzero(s->delivery)) { 00288 /* If we have delivery time, increment it, otherwise, leave it at 0 */ 00289 s->delivery = ast_tvadd(s->delivery, ast_samp2tv(s->f.samples, 8000)); 00290 } 00291 } 00292 /* Return frame */ 00293 return &s->f; 00294 }
void ast_smoother_reconfigure | ( | struct ast_smoother * | s, | |
int | bytes | |||
) |
Reconfigure an existing smoother to output a different number of bytes per frame.
s | the smoother to reconfigure | |
bytes | the desired number of bytes per output frame |
Definition at line 164 of file frame.c.
References s, and smoother_frame_feed().
Referenced by ast_rtp_codec_setpref().
00165 { 00166 /* if there is no change, then nothing to do */ 00167 if (s->size == bytes) { 00168 return; 00169 } 00170 /* set the new desired output size */ 00171 s->size = bytes; 00172 /* if there is no 'optimized' frame in the smoother, 00173 * then there is nothing left to do 00174 */ 00175 if (!s->opt) { 00176 return; 00177 } 00178 /* there is an 'optimized' frame here at the old size, 00179 * but it must now be put into the buffer so the data 00180 * can be extracted at the new size 00181 */ 00182 smoother_frame_feed(s, s->opt, s->opt_needs_swap); 00183 s->opt = NULL; 00184 }
void ast_smoother_reset | ( | struct ast_smoother * | s, | |
int | bytes | |||
) |
Definition at line 158 of file frame.c.
References s.
Referenced by ast_smoother_new().
00159 { 00160 memset(s, 0, sizeof(*s)); 00161 s->size = bytes; 00162 }
void ast_smoother_set_flags | ( | struct ast_smoother * | s, | |
int | flags | |||
) |
Definition at line 201 of file frame.c.
References s.
Referenced by ast_rtp_codec_setpref(), and ast_rtp_write().
int ast_smoother_test_flag | ( | struct ast_smoother * | s, | |
int | flag | |||
) |
Definition at line 206 of file frame.c.
References s.
Referenced by ast_rtp_write().
00207 { 00208 return (s->flags & flag); 00209 }
void ast_swapcopy_samples | ( | void * | dst, | |
const void * | src, | |||
int | samples | |||
) |
Definition at line 545 of file frame.c.
Referenced by __ast_smoother_feed(), iax_frame_wrap(), phone_write_buf(), and smoother_frame_feed().
00546 { 00547 int i; 00548 unsigned short *dst_s = dst; 00549 const unsigned short *src_s = src; 00550 00551 for (i = 0; i < samples; i++) 00552 dst_s[i] = (src_s[i]<<8) | (src_s[i]>>8); 00553 }
static void frame_cache_cleanup | ( | void * | data | ) | [static] |
Definition at line 331 of file frame.c.
References AST_LIST_REMOVE_HEAD, f, frames, and free.
00332 { 00333 struct ast_frame_cache *frames = data; 00334 struct ast_frame *f; 00335 00336 while ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list))) 00337 free(f); 00338 00339 free(frames); 00340 }
static void frame_cache_init | ( | void | ) | [static] |
static int g723_len | ( | unsigned char | buf | ) | [static] |
Definition at line 1353 of file frame.c.
References ast_log(), LOG_WARNING, type, TYPE_DONTSEND, TYPE_HIGH, TYPE_LOW, TYPE_MASK, and TYPE_SILENCE.
Referenced by g723_samples().
01354 { 01355 enum frame_type type = buf & TYPE_MASK; 01356 01357 switch(type) { 01358 case TYPE_DONTSEND: 01359 return 0; 01360 break; 01361 case TYPE_SILENCE: 01362 return 4; 01363 break; 01364 case TYPE_HIGH: 01365 return 24; 01366 break; 01367 case TYPE_LOW: 01368 return 20; 01369 break; 01370 default: 01371 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", type); 01372 } 01373 return -1; 01374 }
static int g723_samples | ( | unsigned char * | buf, | |
int | maxlen | |||
) | [static] |
Definition at line 1376 of file frame.c.
References g723_len().
Referenced by ast_codec_get_samples().
01377 { 01378 int pos = 0; 01379 int samples = 0; 01380 int res; 01381 while(pos < maxlen) { 01382 res = g723_len(buf[pos]); 01383 if (res <= 0) 01384 break; 01385 samples += 240; 01386 pos += res; 01387 } 01388 return samples; 01389 }
static unsigned char get_n_bits_at | ( | unsigned char * | data, | |
int | n, | |||
int | bit | |||
) | [static] |
Definition at line 1391 of file frame.c.
Referenced by speex_get_wb_sz_at(), and speex_samples().
01392 { 01393 int byte = bit / 8; /* byte containing first bit */ 01394 int rem = 8 - (bit % 8); /* remaining bits in first byte */ 01395 unsigned char ret = 0; 01396 01397 if (n <= 0 || n > 8) 01398 return 0; 01399 01400 if (rem < n) { 01401 ret = (data[byte] << (n - rem)); 01402 ret |= (data[byte + 1] >> (8 - n + rem)); 01403 } else { 01404 ret = (data[byte] >> (rem - n)); 01405 } 01406 01407 return (ret & (0xff >> (8 - n))); 01408 }
int init_framer | ( | void | ) |
Provided by frame.c
Definition at line 1039 of file frame.c.
References ast_cli_register_multiple(), and my_clis.
Referenced by main().
01040 { 01041 ast_cli_register_multiple(my_clis, sizeof(my_clis) / sizeof(struct ast_cli_entry)); 01042 return 0; 01043 }
static int show_codec_n | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
Definition at line 772 of file frame.c.
References ast_cli(), ast_codec2str(), RESULT_SHOWUSAGE, and RESULT_SUCCESS.
00773 { 00774 int codec, i, found=0; 00775 00776 if (argc != 4) 00777 return RESULT_SHOWUSAGE; 00778 00779 if (sscanf(argv[3],"%30d",&codec) != 1) 00780 return RESULT_SHOWUSAGE; 00781 00782 for (i = 0; i < 32; i++) 00783 if (codec & (1 << i)) { 00784 found = 1; 00785 ast_cli(fd, "%11u (1 << %2d) %s\n",1 << i,i,ast_codec2str(1<<i)); 00786 } 00787 00788 if (!found) 00789 ast_cli(fd, "Codec %d not found\n", codec); 00790 00791 return RESULT_SUCCESS; 00792 }
static int show_codec_n_deprecated | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
Definition at line 750 of file frame.c.
References ast_cli(), ast_codec2str(), RESULT_SHOWUSAGE, and RESULT_SUCCESS.
00751 { 00752 int codec, i, found=0; 00753 00754 if (argc != 3) 00755 return RESULT_SHOWUSAGE; 00756 00757 if (sscanf(argv[2],"%30d",&codec) != 1) 00758 return RESULT_SHOWUSAGE; 00759 00760 for (i = 0; i < 32; i++) 00761 if (codec & (1 << i)) { 00762 found = 1; 00763 ast_cli(fd, "%11u (1 << %2d) %s\n",1 << i,i,ast_codec2str(1<<i)); 00764 } 00765 00766 if (!found) 00767 ast_cli(fd, "Codec %d not found\n", codec); 00768 00769 return RESULT_SUCCESS; 00770 }
static int show_codecs | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
Definition at line 702 of file frame.c.
References ast_cli(), ast_codec2str(), ast_getformatname(), ast_opt_dont_warn, RESULT_SHOWUSAGE, and RESULT_SUCCESS.
00703 { 00704 int i, found=0; 00705 char hex[25]; 00706 00707 if ((argc < 3) || (argc > 4)) 00708 return RESULT_SHOWUSAGE; 00709 00710 if (!ast_opt_dont_warn) 00711 ast_cli(fd, "Disclaimer: this command is for informational purposes only.\n" 00712 "\tIt does not indicate anything about your configuration.\n"); 00713 00714 ast_cli(fd, "%11s %9s %10s TYPE %8s %s\n","INT","BINARY","HEX","NAME","DESC"); 00715 ast_cli(fd, "--------------------------------------------------------------------------------\n"); 00716 if ((argc == 3) || (!strcasecmp(argv[3],"audio"))) { 00717 found = 1; 00718 for (i=0;i<13;i++) { 00719 snprintf(hex,25,"(0x%x)",1<<i); 00720 ast_cli(fd, "%11u (1 << %2d) %10s audio %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i)); 00721 } 00722 } 00723 00724 if ((argc == 3) || (!strcasecmp(argv[3],"image"))) { 00725 found = 1; 00726 for (i=16;i<18;i++) { 00727 snprintf(hex,25,"(0x%x)",1<<i); 00728 ast_cli(fd, "%11u (1 << %2d) %10s image %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i)); 00729 } 00730 } 00731 00732 if ((argc == 3) || (!strcasecmp(argv[3],"video"))) { 00733 found = 1; 00734 for (i=18;i<22;i++) { 00735 snprintf(hex,25,"(0x%x)",1<<i); 00736 ast_cli(fd, "%11u (1 << %2d) %10s video %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i)); 00737 } 00738 } 00739 00740 if (! found) 00741 return RESULT_SHOWUSAGE; 00742 else 00743 return RESULT_SUCCESS; 00744 }
static int show_codecs_deprecated | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
Definition at line 658 of file frame.c.
References ast_cli(), ast_codec2str(), ast_getformatname(), ast_opt_dont_warn, RESULT_SHOWUSAGE, and RESULT_SUCCESS.
00659 { 00660 int i, found=0; 00661 char hex[25]; 00662 00663 if ((argc < 2) || (argc > 3)) 00664 return RESULT_SHOWUSAGE; 00665 00666 if (!ast_opt_dont_warn) 00667 ast_cli(fd, "Disclaimer: this command is for informational purposes only.\n" 00668 "\tIt does not indicate anything about your configuration.\n"); 00669 00670 ast_cli(fd, "%11s %9s %10s TYPE %8s %s\n","INT","BINARY","HEX","NAME","DESC"); 00671 ast_cli(fd, "--------------------------------------------------------------------------------\n"); 00672 if ((argc == 2) || (!strcasecmp(argv[1],"audio"))) { 00673 found = 1; 00674 for (i=0;i<13;i++) { 00675 snprintf(hex,25,"(0x%x)",1<<i); 00676 ast_cli(fd, "%11u (1 << %2d) %10s audio %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i)); 00677 } 00678 } 00679 00680 if ((argc == 2) || (!strcasecmp(argv[1],"image"))) { 00681 found = 1; 00682 for (i=16;i<18;i++) { 00683 snprintf(hex,25,"(0x%x)",1<<i); 00684 ast_cli(fd, "%11u (1 << %2d) %10s image %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i)); 00685 } 00686 } 00687 00688 if ((argc == 2) || (!strcasecmp(argv[1],"video"))) { 00689 found = 1; 00690 for (i=18;i<22;i++) { 00691 snprintf(hex,25,"(0x%x)",1<<i); 00692 ast_cli(fd, "%11u (1 << %2d) %10s video %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i)); 00693 } 00694 } 00695 00696 if (! found) 00697 return RESULT_SHOWUSAGE; 00698 else 00699 return RESULT_SUCCESS; 00700 }
static int smoother_frame_feed | ( | struct ast_smoother * | s, | |
struct ast_frame * | f, | |||
int | swap | |||
) | [static] |
Definition at line 136 of file frame.c.
References ast_log(), AST_SMOOTHER_FLAG_G729, ast_swapcopy_samples(), ast_tvzero(), f, LOG_NOTICE, and s.
Referenced by __ast_smoother_feed(), and ast_smoother_reconfigure().
00137 { 00138 if (s->flags & AST_SMOOTHER_FLAG_G729) { 00139 if (s->len % 10) { 00140 ast_log(LOG_NOTICE, "Dropping extra frame of G.729 since we already have a VAD frame at the end\n"); 00141 return 0; 00142 } 00143 } 00144 if (swap) { 00145 ast_swapcopy_samples(s->data + s->len, f->data, f->samples); 00146 } else { 00147 memcpy(s->data + s->len, f->data, f->datalen); 00148 } 00149 /* If either side is empty, reset the delivery time */ 00150 if (!s->len || ast_tvzero(f->delivery) || ast_tvzero(s->delivery)) { /* XXX really ? */ 00151 s->delivery = f->delivery; 00152 } 00153 s->len += f->datalen; 00154 00155 return 0; 00156 }
static int speex_get_wb_sz_at | ( | unsigned char * | data, | |
int | len, | |||
int | bit | |||
) | [static] |
Definition at line 1410 of file frame.c.
References ast_log(), get_n_bits_at(), and LOG_WARNING.
Referenced by speex_samples().
01411 { 01412 static int SpeexWBSubModeSz[] = { 01413 0, 36, 112, 192, 01414 352, 0, 0, 0 }; 01415 int off = bit; 01416 unsigned char c; 01417 01418 /* skip up to two wideband frames */ 01419 if (((len * 8 - off) >= 5) && 01420 get_n_bits_at(data, 1, off)) { 01421 c = get_n_bits_at(data, 3, off + 1); 01422 off += SpeexWBSubModeSz[c]; 01423 01424 if (((len * 8 - off) >= 5) && 01425 get_n_bits_at(data, 1, off)) { 01426 c = get_n_bits_at(data, 3, off + 1); 01427 off += SpeexWBSubModeSz[c]; 01428 01429 if (((len * 8 - off) >= 5) && 01430 get_n_bits_at(data, 1, off)) { 01431 ast_log(LOG_WARNING, "Encountered corrupt speex frame; too many wideband frames in a row.\n"); 01432 return -1; 01433 } 01434 } 01435 01436 } 01437 return off - bit; 01438 }
static int speex_samples | ( | unsigned char * | data, | |
int | len | |||
) | [static] |
Definition at line 1440 of file frame.c.
References ast_log(), get_n_bits_at(), LOG_WARNING, and speex_get_wb_sz_at().
Referenced by ast_codec_get_samples().
01441 { 01442 static int SpeexSubModeSz[] = { 01443 5, 43, 119, 160, 01444 220, 300, 364, 492, 01445 79, 0, 0, 0, 01446 0, 0, 0, 0 }; 01447 static int SpeexInBandSz[] = { 01448 1, 1, 4, 4, 01449 4, 4, 4, 4, 01450 8, 8, 16, 16, 01451 32, 32, 64, 64 }; 01452 int bit = 0; 01453 int cnt = 0; 01454 int off; 01455 unsigned char c; 01456 01457 while ((len * 8 - bit) >= 5) { 01458 /* skip wideband frames */ 01459 off = speex_get_wb_sz_at(data, len, bit); 01460 if (off < 0) { 01461 ast_log(LOG_WARNING, "Had error while reading wideband frames for speex samples\n"); 01462 break; 01463 } 01464 bit += off; 01465 01466 if ((len * 8 - bit) == 0) { 01467 break; 01468 } else if ((len * 8 - bit) < 5) { 01469 ast_log(LOG_WARNING, "Not enough bits remaining after wide band for speex samples.\n"); 01470 break; 01471 } 01472 01473 /* get control bits */ 01474 c = get_n_bits_at(data, 5, bit); 01475 bit += 5; 01476 01477 if (c == 15) { 01478 /* terminator */ 01479 break; 01480 } else if (c == 14) { 01481 /* in-band signal; next 4 bits contain signal id */ 01482 c = get_n_bits_at(data, 4, bit); 01483 bit += 4; 01484 bit += SpeexInBandSz[c]; 01485 } else if (c == 13) { 01486 /* user in-band; next 5 bits contain msg len */ 01487 c = get_n_bits_at(data, 5, bit); 01488 bit += 5; 01489 bit += c * 8; 01490 } else if (c > 8) { 01491 /* unknown */ 01492 break; 01493 } else { 01494 /* skip number bits for submode (less the 5 control bits) */ 01495 bit += SpeexSubModeSz[c] - 5; 01496 cnt += 160; /* new frame */ 01497 } 01498 } 01499 return cnt; 01500 }
struct ast_format_list AST_FORMAT_LIST[] [static] |
Definition of supported media formats (codecs).
Definition at line 103 of file frame.c.
Referenced by ast_codec2str(), ast_codec_choose(), ast_codec_pref_append(), ast_codec_pref_getsize(), ast_codec_pref_index(), ast_codec_pref_prepend(), ast_codec_pref_remove(), ast_codec_pref_setsize(), ast_get_format_list(), ast_get_format_list_index(), ast_getformatbyname(), ast_getformatname(), and ast_getformatname_multiple().
struct ast_frame ast_null_frame = { AST_FRAME_NULL, } |
Queueing a null frame is fairly common, so we declare a global null frame object for this purpose instead of having to declare one on the stack
Definition at line 134 of file frame.c.
Referenced by __ast_read(), __oh323_rtp_create(), __oh323_update_info(), agent_read(), agent_request(), ast_channel_masquerade(), ast_channel_setwhentohangup(), ast_do_masquerade(), ast_rtcp_read(), ast_rtp_read(), ast_softhangup_nolock(), ast_udptl_read(), conf_run(), create_dtmf_frame(), dahdi_handle_event(), features_read(), gtalk_rtp_read(), handle_request_invite(), handle_response_invite(), local_read(), mgcp_rtp_read(), oh323_read(), oh323_rtp_read(), process_sdp(), sip_read(), sip_rtp_read(), skinny_rtp_read(), and wakeup_sub().
struct ast_cli_entry cli_show_audio_codecs [static] |
Initial value:
{ { "show", "audio", "codecs", NULL }, show_codecs_deprecated, NULL, NULL }
struct ast_cli_entry cli_show_codec [static] |
Initial value:
{ { "show", "codec", NULL }, show_codec_n_deprecated, NULL, NULL }
struct ast_cli_entry cli_show_codecs [static] |
Initial value:
{ { "show", "codecs", NULL }, show_codecs_deprecated, NULL, NULL }
struct ast_cli_entry cli_show_image_codecs [static] |
Initial value:
{ { "show", "image", "codecs", NULL }, show_codecs_deprecated, NULL, NULL }
struct ast_cli_entry cli_show_video_codecs [static] |
Initial value:
{ { "show", "video", "codecs", NULL }, show_codecs_deprecated, NULL, NULL }
struct ast_threadstorage frame_cache = { .once = PTHREAD_ONCE_INIT , .key_init = frame_cache_init , } [static] |
Definition at line 54 of file frame.c.
Referenced by __frame_free(), ast_frame_header_new(), ast_frdup(), iax_frame_free(), and iax_frame_new().
char frame_show_codec_n_usage[] [static] |
char frame_show_codecs_usage[] [static] |
struct ast_cli_entry my_clis[] [static] |