00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "asterisk.h"
00027
00028 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 269977 $")
00029
00030 #include "asterisk/_private.h"
00031 #include "asterisk/lock.h"
00032 #include "asterisk/frame.h"
00033 #include "asterisk/channel.h"
00034 #include "asterisk/cli.h"
00035 #include "asterisk/term.h"
00036 #include "asterisk/utils.h"
00037 #include "asterisk/threadstorage.h"
00038 #include "asterisk/linkedlists.h"
00039 #include "asterisk/translate.h"
00040 #include "asterisk/dsp.h"
00041 #include "asterisk/file.h"
00042
00043 #if !defined(LOW_MEMORY)
00044 static void frame_cache_cleanup(void *data);
00045
00046
00047 AST_THREADSTORAGE_CUSTOM(frame_cache, NULL, frame_cache_cleanup);
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058 #define FRAME_CACHE_MAX_SIZE 10
00059
00060
00061
00062 AST_LIST_HEAD_NOLOCK(ast_frames, ast_frame);
00063
00064 struct ast_frame_cache {
00065 struct ast_frames list;
00066 size_t size;
00067 };
00068 #endif
00069
00070 #define SMOOTHER_SIZE 8000
00071
00072 enum frame_type {
00073 TYPE_HIGH,
00074 TYPE_LOW,
00075 TYPE_SILENCE,
00076 TYPE_DONTSEND
00077 };
00078
00079 #define TYPE_MASK 0x3
00080
00081 struct ast_smoother {
00082 int size;
00083 int format;
00084 int flags;
00085 float samplesperbyte;
00086 unsigned int opt_needs_swap:1;
00087 struct ast_frame f;
00088 struct timeval delivery;
00089 char data[SMOOTHER_SIZE];
00090 char framedata[SMOOTHER_SIZE + AST_FRIENDLY_OFFSET];
00091 struct ast_frame *opt;
00092 int len;
00093 };
00094
00095
00096 static const struct ast_format_list AST_FORMAT_LIST[] = {
00097 { AST_FORMAT_G723_1 , "g723", 8000, "G.723.1", 20, 30, 300, 30, 30 },
00098 { AST_FORMAT_GSM, "gsm", 8000, "GSM", 33, 20, 300, 20, 20 },
00099 { AST_FORMAT_ULAW, "ulaw", 8000, "G.711 u-law", 80, 10, 150, 10, 20 },
00100 { AST_FORMAT_ALAW, "alaw", 8000, "G.711 A-law", 80, 10, 150, 10, 20 },
00101 { AST_FORMAT_G726, "g726", 8000, "G.726 RFC3551", 40, 10, 300, 10, 20 },
00102 { AST_FORMAT_ADPCM, "adpcm" , 8000, "ADPCM", 40, 10, 300, 10, 20 },
00103 { AST_FORMAT_SLINEAR, "slin", 8000, "16 bit Signed Linear PCM", 160, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE },
00104 { AST_FORMAT_LPC10, "lpc10", 8000, "LPC10", 7, 20, 20, 20, 20 },
00105 { AST_FORMAT_G729A, "g729", 8000, "G.729A", 10, 10, 230, 10, 20, AST_SMOOTHER_FLAG_G729 },
00106 { AST_FORMAT_SPEEX, "speex", 8000, "SpeeX", 10, 10, 60, 10, 20 },
00107 { AST_FORMAT_ILBC, "ilbc", 8000, "iLBC", 50, 30, 30, 30, 30 },
00108 { AST_FORMAT_G726_AAL2, "g726aal2", 8000, "G.726 AAL2", 40, 10, 300, 10, 20 },
00109 { AST_FORMAT_G722, "g722", 16000, "G722", 80, 10, 150, 10, 20 },
00110 { AST_FORMAT_SLINEAR16, "slin16", 16000, "16 bit Signed Linear PCM (16kHz)", 320, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE },
00111 { AST_FORMAT_JPEG, "jpeg", 0, "JPEG image"},
00112 { AST_FORMAT_PNG, "png", 0, "PNG image"},
00113 { AST_FORMAT_H261, "h261", 0, "H.261 Video" },
00114 { AST_FORMAT_H263, "h263", 0, "H.263 Video" },
00115 { AST_FORMAT_H263_PLUS, "h263p", 0, "H.263+ Video" },
00116 { AST_FORMAT_H264, "h264", 0, "H.264 Video" },
00117 { AST_FORMAT_MP4_VIDEO, "mpeg4", 0, "MPEG4 Video" },
00118 { AST_FORMAT_T140RED, "red", 1, "T.140 Realtime Text with redundancy"},
00119 { AST_FORMAT_T140, "t140", 0, "Passthrough T.140 Realtime Text" },
00120 { AST_FORMAT_SIREN7, "siren7", 16000, "ITU G.722.1 (Siren7, licensed from Polycom)", 80, 20, 80, 20, 20 },
00121 { AST_FORMAT_SIREN14, "siren14", 32000, "ITU G.722.1 Annex C, (Siren14, licensed from Polycom)", 120, 20, 80, 20, 20 },
00122 };
00123
00124 struct ast_frame ast_null_frame = { AST_FRAME_NULL, };
00125
00126 static int smoother_frame_feed(struct ast_smoother *s, struct ast_frame *f, int swap)
00127 {
00128 if (s->flags & AST_SMOOTHER_FLAG_G729) {
00129 if (s->len % 10) {
00130 ast_log(LOG_NOTICE, "Dropping extra frame of G.729 since we already have a VAD frame at the end\n");
00131 return 0;
00132 }
00133 }
00134 if (swap) {
00135 ast_swapcopy_samples(s->data + s->len, f->data.ptr, f->samples);
00136 } else {
00137 memcpy(s->data + s->len, f->data.ptr, f->datalen);
00138 }
00139
00140 if (!s->len || ast_tvzero(f->delivery) || ast_tvzero(s->delivery)) {
00141 s->delivery = f->delivery;
00142 }
00143 s->len += f->datalen;
00144
00145 return 0;
00146 }
00147
00148 void ast_smoother_reset(struct ast_smoother *s, int bytes)
00149 {
00150 memset(s, 0, sizeof(*s));
00151 s->size = bytes;
00152 }
00153
00154 void ast_smoother_reconfigure(struct ast_smoother *s, int bytes)
00155 {
00156
00157 if (s->size == bytes) {
00158 return;
00159 }
00160
00161 s->size = bytes;
00162
00163
00164
00165 if (!s->opt) {
00166 return;
00167 }
00168
00169
00170
00171
00172 smoother_frame_feed(s, s->opt, s->opt_needs_swap);
00173 s->opt = NULL;
00174 }
00175
00176 struct ast_smoother *ast_smoother_new(int size)
00177 {
00178 struct ast_smoother *s;
00179 if (size < 1)
00180 return NULL;
00181 if ((s = ast_malloc(sizeof(*s))))
00182 ast_smoother_reset(s, size);
00183 return s;
00184 }
00185
00186 int ast_smoother_get_flags(struct ast_smoother *s)
00187 {
00188 return s->flags;
00189 }
00190
00191 void ast_smoother_set_flags(struct ast_smoother *s, int flags)
00192 {
00193 s->flags = flags;
00194 }
00195
00196 int ast_smoother_test_flag(struct ast_smoother *s, int flag)
00197 {
00198 return (s->flags & flag);
00199 }
00200
00201 int __ast_smoother_feed(struct ast_smoother *s, struct ast_frame *f, int swap)
00202 {
00203 if (f->frametype != AST_FRAME_VOICE) {
00204 ast_log(LOG_WARNING, "Huh? Can't smooth a non-voice frame!\n");
00205 return -1;
00206 }
00207 if (!s->format) {
00208 s->format = f->subclass;
00209 s->samplesperbyte = (float)f->samples / (float)f->datalen;
00210 } else if (s->format != f->subclass) {
00211 ast_log(LOG_WARNING, "Smoother was working on %d format frames, now trying to feed %d?\n", s->format, f->subclass);
00212 return -1;
00213 }
00214 if (s->len + f->datalen > SMOOTHER_SIZE) {
00215 ast_log(LOG_WARNING, "Out of smoother space\n");
00216 return -1;
00217 }
00218 if (((f->datalen == s->size) ||
00219 ((f->datalen < 10) && (s->flags & AST_SMOOTHER_FLAG_G729))) &&
00220 !s->opt &&
00221 !s->len &&
00222 (f->offset >= AST_MIN_OFFSET)) {
00223
00224
00225
00226 if (swap)
00227 ast_swapcopy_samples(f->data.ptr, f->data.ptr, f->samples);
00228 s->opt = f;
00229 s->opt_needs_swap = swap ? 1 : 0;
00230 return 0;
00231 }
00232
00233 return smoother_frame_feed(s, f, swap);
00234 }
00235
00236 struct ast_frame *ast_smoother_read(struct ast_smoother *s)
00237 {
00238 struct ast_frame *opt;
00239 int len;
00240
00241
00242 if (s->opt) {
00243 if (s->opt->offset < AST_FRIENDLY_OFFSET)
00244 ast_log(LOG_WARNING, "Returning a frame of inappropriate offset (%d).\n",
00245 s->opt->offset);
00246 opt = s->opt;
00247 s->opt = NULL;
00248 return opt;
00249 }
00250
00251
00252 if (s->len < s->size) {
00253
00254 if (!((s->flags & AST_SMOOTHER_FLAG_G729) && (s->len % 10)))
00255 return NULL;
00256 }
00257 len = s->size;
00258 if (len > s->len)
00259 len = s->len;
00260
00261 s->f.frametype = AST_FRAME_VOICE;
00262 s->f.subclass = s->format;
00263 s->f.data.ptr = s->framedata + AST_FRIENDLY_OFFSET;
00264 s->f.offset = AST_FRIENDLY_OFFSET;
00265 s->f.datalen = len;
00266
00267 s->f.samples = len * s->samplesperbyte;
00268 s->f.delivery = s->delivery;
00269
00270 memcpy(s->f.data.ptr, s->data, len);
00271 s->len -= len;
00272
00273 if (s->len) {
00274
00275
00276 memmove(s->data, s->data + len, s->len);
00277 if (!ast_tvzero(s->delivery)) {
00278
00279 s->delivery = ast_tvadd(s->delivery, ast_samp2tv(s->f.samples, ast_format_rate(s->format)));
00280 }
00281 }
00282
00283 return &s->f;
00284 }
00285
00286 void ast_smoother_free(struct ast_smoother *s)
00287 {
00288 ast_free(s);
00289 }
00290
00291 static struct ast_frame *ast_frame_header_new(void)
00292 {
00293 struct ast_frame *f;
00294
00295 #if !defined(LOW_MEMORY)
00296 struct ast_frame_cache *frames;
00297
00298 if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
00299 if ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list))) {
00300 size_t mallocd_len = f->mallocd_hdr_len;
00301 memset(f, 0, sizeof(*f));
00302 f->mallocd_hdr_len = mallocd_len;
00303 f->mallocd = AST_MALLOCD_HDR;
00304 frames->size--;
00305 return f;
00306 }
00307 }
00308 if (!(f = ast_calloc_cache(1, sizeof(*f))))
00309 return NULL;
00310 #else
00311 if (!(f = ast_calloc(1, sizeof(*f))))
00312 return NULL;
00313 #endif
00314
00315 f->mallocd_hdr_len = sizeof(*f);
00316
00317 return f;
00318 }
00319
00320 #if !defined(LOW_MEMORY)
00321 static void frame_cache_cleanup(void *data)
00322 {
00323 struct ast_frame_cache *frames = data;
00324 struct ast_frame *f;
00325
00326 while ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list)))
00327 ast_free(f);
00328
00329 ast_free(frames);
00330 }
00331 #endif
00332
00333 static void __frame_free(struct ast_frame *fr, int cache)
00334 {
00335 if (ast_test_flag(fr, AST_FRFLAG_FROM_TRANSLATOR)) {
00336 ast_translate_frame_freed(fr);
00337 } else if (ast_test_flag(fr, AST_FRFLAG_FROM_DSP)) {
00338 ast_dsp_frame_freed(fr);
00339 }
00340
00341 if (!fr->mallocd)
00342 return;
00343
00344 #if !defined(LOW_MEMORY)
00345 if (cache && fr->mallocd == AST_MALLOCD_HDR) {
00346
00347
00348 struct ast_frame_cache *frames;
00349
00350 if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames))) &&
00351 (frames->size < FRAME_CACHE_MAX_SIZE)) {
00352 AST_LIST_INSERT_HEAD(&frames->list, fr, frame_list);
00353 frames->size++;
00354 return;
00355 }
00356 }
00357 #endif
00358
00359 if (fr->mallocd & AST_MALLOCD_DATA) {
00360 if (fr->data.ptr)
00361 ast_free(fr->data.ptr - fr->offset);
00362 }
00363 if (fr->mallocd & AST_MALLOCD_SRC) {
00364 if (fr->src)
00365 ast_free((void *) fr->src);
00366 }
00367 if (fr->mallocd & AST_MALLOCD_HDR) {
00368 ast_free(fr);
00369 }
00370 }
00371
00372
00373 void ast_frame_free(struct ast_frame *frame, int cache)
00374 {
00375 struct ast_frame *next;
00376
00377 for (next = AST_LIST_NEXT(frame, frame_list);
00378 frame;
00379 frame = next, next = frame ? AST_LIST_NEXT(frame, frame_list) : NULL) {
00380 __frame_free(frame, cache);
00381 }
00382 }
00383
00384
00385
00386
00387
00388
00389 struct ast_frame *ast_frisolate(struct ast_frame *fr)
00390 {
00391 struct ast_frame *out;
00392 void *newdata;
00393
00394
00395
00396
00397 if (fr->mallocd == 0) {
00398 return ast_frdup(fr);
00399 }
00400
00401
00402 if ((fr->mallocd & (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) ==
00403 (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) {
00404 return fr;
00405 }
00406
00407 if (!(fr->mallocd & AST_MALLOCD_HDR)) {
00408
00409 if (!(out = ast_frame_header_new())) {
00410 return NULL;
00411 }
00412 out->frametype = fr->frametype;
00413 out->subclass = fr->subclass;
00414 out->datalen = fr->datalen;
00415 out->samples = fr->samples;
00416 out->offset = fr->offset;
00417
00418 ast_copy_flags(out, fr, AST_FRFLAG_HAS_TIMING_INFO);
00419 if (ast_test_flag(fr, AST_FRFLAG_HAS_TIMING_INFO)) {
00420 out->ts = fr->ts;
00421 out->len = fr->len;
00422 out->seqno = fr->seqno;
00423 }
00424 } else {
00425 ast_clear_flag(fr, AST_FRFLAG_FROM_TRANSLATOR);
00426 ast_clear_flag(fr, AST_FRFLAG_FROM_DSP);
00427 out = fr;
00428 }
00429
00430 if (!(fr->mallocd & AST_MALLOCD_SRC) && fr->src) {
00431 if (!(out->src = ast_strdup(fr->src))) {
00432 if (out != fr) {
00433 ast_free(out);
00434 }
00435 return NULL;
00436 }
00437 } else {
00438 out->src = fr->src;
00439 fr->src = NULL;
00440 fr->mallocd &= ~AST_MALLOCD_SRC;
00441 }
00442
00443 if (!(fr->mallocd & AST_MALLOCD_DATA)) {
00444 if (!fr->datalen) {
00445 out->data.uint32 = fr->data.uint32;
00446 out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC;
00447 return out;
00448 }
00449 if (!(newdata = ast_malloc(fr->datalen + AST_FRIENDLY_OFFSET))) {
00450 if (out->src != fr->src) {
00451 ast_free((void *) out->src);
00452 }
00453 if (out != fr) {
00454 ast_free(out);
00455 }
00456 return NULL;
00457 }
00458 newdata += AST_FRIENDLY_OFFSET;
00459 out->offset = AST_FRIENDLY_OFFSET;
00460 out->datalen = fr->datalen;
00461 memcpy(newdata, fr->data.ptr, fr->datalen);
00462 out->data.ptr = newdata;
00463 } else {
00464 out->data = fr->data;
00465 memset(&fr->data, 0, sizeof(fr->data));
00466 fr->mallocd &= ~AST_MALLOCD_DATA;
00467 }
00468
00469 out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
00470
00471 return out;
00472 }
00473
00474 struct ast_frame *ast_frdup(const struct ast_frame *f)
00475 {
00476 struct ast_frame *out = NULL;
00477 int len, srclen = 0;
00478 void *buf = NULL;
00479
00480 #if !defined(LOW_MEMORY)
00481 struct ast_frame_cache *frames;
00482 #endif
00483
00484
00485 len = sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
00486
00487
00488
00489
00490
00491 if (f->src)
00492 srclen = strlen(f->src);
00493 if (srclen > 0)
00494 len += srclen + 1;
00495
00496 #if !defined(LOW_MEMORY)
00497 if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
00498 AST_LIST_TRAVERSE_SAFE_BEGIN(&frames->list, out, frame_list) {
00499 if (out->mallocd_hdr_len >= len) {
00500 size_t mallocd_len = out->mallocd_hdr_len;
00501
00502 AST_LIST_REMOVE_CURRENT(frame_list);
00503 memset(out, 0, sizeof(*out));
00504 out->mallocd_hdr_len = mallocd_len;
00505 buf = out;
00506 frames->size--;
00507 break;
00508 }
00509 }
00510 AST_LIST_TRAVERSE_SAFE_END;
00511 }
00512 #endif
00513
00514 if (!buf) {
00515 if (!(buf = ast_calloc_cache(1, len)))
00516 return NULL;
00517 out = buf;
00518 out->mallocd_hdr_len = len;
00519 }
00520
00521 out->frametype = f->frametype;
00522 out->subclass = f->subclass;
00523 out->datalen = f->datalen;
00524 out->samples = f->samples;
00525 out->delivery = f->delivery;
00526
00527
00528 out->mallocd = AST_MALLOCD_HDR;
00529 out->offset = AST_FRIENDLY_OFFSET;
00530 if (out->datalen) {
00531 out->data.ptr = buf + sizeof(*out) + AST_FRIENDLY_OFFSET;
00532 memcpy(out->data.ptr, f->data.ptr, out->datalen);
00533 } else {
00534 out->data.uint32 = f->data.uint32;
00535 }
00536 if (srclen > 0) {
00537
00538 char *src;
00539 out->src = buf + sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
00540 src = (char *) out->src;
00541
00542 strcpy(src, f->src);
00543 }
00544 ast_copy_flags(out, f, AST_FRFLAG_HAS_TIMING_INFO);
00545 out->ts = f->ts;
00546 out->len = f->len;
00547 out->seqno = f->seqno;
00548 return out;
00549 }
00550
00551 void ast_swapcopy_samples(void *dst, const void *src, int samples)
00552 {
00553 int i;
00554 unsigned short *dst_s = dst;
00555 const unsigned short *src_s = src;
00556
00557 for (i = 0; i < samples; i++)
00558 dst_s[i] = (src_s[i]<<8) | (src_s[i]>>8);
00559 }
00560
00561
00562 const struct ast_format_list *ast_get_format_list_index(int idx)
00563 {
00564 return &AST_FORMAT_LIST[idx];
00565 }
00566
00567 const struct ast_format_list *ast_get_format_list(size_t *size)
00568 {
00569 *size = ARRAY_LEN(AST_FORMAT_LIST);
00570 return AST_FORMAT_LIST;
00571 }
00572
00573 char* ast_getformatname(int format)
00574 {
00575 int x;
00576 char *ret = "unknown";
00577 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
00578 if (AST_FORMAT_LIST[x].bits == format) {
00579 ret = AST_FORMAT_LIST[x].name;
00580 break;
00581 }
00582 }
00583 return ret;
00584 }
00585
00586 char *ast_getformatname_multiple(char *buf, size_t size, int format)
00587 {
00588 int x;
00589 unsigned len;
00590 char *start, *end = buf;
00591
00592 if (!size)
00593 return buf;
00594 snprintf(end, size, "0x%x (", format);
00595 len = strlen(end);
00596 end += len;
00597 size -= len;
00598 start = end;
00599 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
00600 if (AST_FORMAT_LIST[x].bits & format) {
00601 snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name);
00602 len = strlen(end);
00603 end += len;
00604 size -= len;
00605 }
00606 }
00607 if (start == end)
00608 ast_copy_string(start, "nothing)", size);
00609 else if (size > 1)
00610 *(end -1) = ')';
00611 return buf;
00612 }
00613
00614 static struct ast_codec_alias_table {
00615 char *alias;
00616 char *realname;
00617 } ast_codec_alias_table[] = {
00618 { "slinear", "slin"},
00619 { "slinear16", "slin16"},
00620 { "g723.1", "g723"},
00621 { "g722.1", "siren7"},
00622 { "g722.1c", "siren14"},
00623 };
00624
00625 static const char *ast_expand_codec_alias(const char *in)
00626 {
00627 int x;
00628
00629 for (x = 0; x < ARRAY_LEN(ast_codec_alias_table); x++) {
00630 if (!strcmp(in,ast_codec_alias_table[x].alias))
00631 return ast_codec_alias_table[x].realname;
00632 }
00633 return in;
00634 }
00635
00636 int ast_getformatbyname(const char *name)
00637 {
00638 int x, all, format = 0;
00639
00640 all = strcasecmp(name, "all") ? 0 : 1;
00641 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
00642 if (all ||
00643 !strcasecmp(AST_FORMAT_LIST[x].name,name) ||
00644 !strcasecmp(AST_FORMAT_LIST[x].name, ast_expand_codec_alias(name))) {
00645 format |= AST_FORMAT_LIST[x].bits;
00646 if (!all)
00647 break;
00648 }
00649 }
00650
00651 return format;
00652 }
00653
00654 char *ast_codec2str(int codec)
00655 {
00656 int x;
00657 char *ret = "unknown";
00658 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
00659 if (AST_FORMAT_LIST[x].bits == codec) {
00660 ret = AST_FORMAT_LIST[x].desc;
00661 break;
00662 }
00663 }
00664 return ret;
00665 }
00666
00667 static char *show_codecs(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
00668 {
00669 int i, found=0;
00670 char hex[25];
00671
00672 switch (cmd) {
00673 case CLI_INIT:
00674 e->command = "core show codecs [audio|video|image]";
00675 e->usage =
00676 "Usage: core show codecs [audio|video|image]\n"
00677 " Displays codec mapping\n";
00678 return NULL;
00679 case CLI_GENERATE:
00680 return NULL;
00681 }
00682
00683 if ((a->argc < 3) || (a->argc > 4))
00684 return CLI_SHOWUSAGE;
00685
00686 if (!ast_opt_dont_warn)
00687 ast_cli(a->fd, "Disclaimer: this command is for informational purposes only.\n"
00688 "\tIt does not indicate anything about your configuration.\n");
00689
00690 ast_cli(a->fd, "%11s %9s %10s TYPE %8s %s\n","INT","BINARY","HEX","NAME","DESC");
00691 ast_cli(a->fd, "--------------------------------------------------------------------------------\n");
00692 if ((a->argc == 3) || (!strcasecmp(a->argv[3],"audio"))) {
00693 found = 1;
00694 for (i=0;i<13;i++) {
00695 snprintf(hex,25,"(0x%x)",1<<i);
00696 ast_cli(a->fd, "%11u (1 << %2d) %10s audio %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00697 }
00698 }
00699
00700 if ((a->argc == 3) || (!strcasecmp(a->argv[3],"image"))) {
00701 found = 1;
00702 for (i=16;i<18;i++) {
00703 snprintf(hex,25,"(0x%x)",1<<i);
00704 ast_cli(a->fd, "%11u (1 << %2d) %10s image %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00705 }
00706 }
00707
00708 if ((a->argc == 3) || (!strcasecmp(a->argv[3],"video"))) {
00709 found = 1;
00710 for (i=18;i<22;i++) {
00711 snprintf(hex,25,"(0x%x)",1<<i);
00712 ast_cli(a->fd, "%11u (1 << %2d) %10s video %8s (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00713 }
00714 }
00715
00716 if (!found)
00717 return CLI_SHOWUSAGE;
00718 else
00719 return CLI_SUCCESS;
00720 }
00721
00722 static char *show_codec_n(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
00723 {
00724 int codec, i, found=0;
00725
00726 switch (cmd) {
00727 case CLI_INIT:
00728 e->command = "core show codec";
00729 e->usage =
00730 "Usage: core show codec <number>\n"
00731 " Displays codec mapping\n";
00732 return NULL;
00733 case CLI_GENERATE:
00734 return NULL;
00735 }
00736
00737 if (a->argc != 4)
00738 return CLI_SHOWUSAGE;
00739
00740 if (sscanf(a->argv[3], "%30d", &codec) != 1)
00741 return CLI_SHOWUSAGE;
00742
00743 for (i = 0; i < 32; i++)
00744 if (codec & (1 << i)) {
00745 found = 1;
00746 ast_cli(a->fd, "%11u (1 << %2d) %s\n",1 << i,i,ast_codec2str(1<<i));
00747 }
00748
00749 if (!found)
00750 ast_cli(a->fd, "Codec %d not found\n", codec);
00751
00752 return CLI_SUCCESS;
00753 }
00754
00755
00756 void ast_frame_dump(const char *name, struct ast_frame *f, char *prefix)
00757 {
00758 const char noname[] = "unknown";
00759 char ftype[40] = "Unknown Frametype";
00760 char cft[80];
00761 char subclass[40] = "Unknown Subclass";
00762 char csub[80];
00763 char moreinfo[40] = "";
00764 char cn[60];
00765 char cp[40];
00766 char cmn[40];
00767 const char *message = "Unknown";
00768
00769 if (!name)
00770 name = noname;
00771
00772
00773 if (!f) {
00774 ast_verbose("%s [ %s (NULL) ] [%s]\n",
00775 term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00776 term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00777 term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00778 return;
00779 }
00780
00781 if (f->frametype == AST_FRAME_VOICE)
00782 return;
00783 if (f->frametype == AST_FRAME_VIDEO)
00784 return;
00785 switch(f->frametype) {
00786 case AST_FRAME_DTMF_BEGIN:
00787 strcpy(ftype, "DTMF Begin");
00788 subclass[0] = f->subclass;
00789 subclass[1] = '\0';
00790 break;
00791 case AST_FRAME_DTMF_END:
00792 strcpy(ftype, "DTMF End");
00793 subclass[0] = f->subclass;
00794 subclass[1] = '\0';
00795 break;
00796 case AST_FRAME_CONTROL:
00797 strcpy(ftype, "Control");
00798 switch(f->subclass) {
00799 case AST_CONTROL_HANGUP:
00800 strcpy(subclass, "Hangup");
00801 break;
00802 case AST_CONTROL_RING:
00803 strcpy(subclass, "Ring");
00804 break;
00805 case AST_CONTROL_RINGING:
00806 strcpy(subclass, "Ringing");
00807 break;
00808 case AST_CONTROL_ANSWER:
00809 strcpy(subclass, "Answer");
00810 break;
00811 case AST_CONTROL_BUSY:
00812 strcpy(subclass, "Busy");
00813 break;
00814 case AST_CONTROL_TAKEOFFHOOK:
00815 strcpy(subclass, "Take Off Hook");
00816 break;
00817 case AST_CONTROL_OFFHOOK:
00818 strcpy(subclass, "Line Off Hook");
00819 break;
00820 case AST_CONTROL_CONGESTION:
00821 strcpy(subclass, "Congestion");
00822 break;
00823 case AST_CONTROL_FLASH:
00824 strcpy(subclass, "Flash");
00825 break;
00826 case AST_CONTROL_WINK:
00827 strcpy(subclass, "Wink");
00828 break;
00829 case AST_CONTROL_OPTION:
00830 strcpy(subclass, "Option");
00831 break;
00832 case AST_CONTROL_RADIO_KEY:
00833 strcpy(subclass, "Key Radio");
00834 break;
00835 case AST_CONTROL_RADIO_UNKEY:
00836 strcpy(subclass, "Unkey Radio");
00837 break;
00838 case AST_CONTROL_HOLD:
00839 strcpy(subclass, "Hold");
00840 break;
00841 case AST_CONTROL_UNHOLD:
00842 strcpy(subclass, "Unhold");
00843 break;
00844 case AST_CONTROL_T38_PARAMETERS:
00845 if (f->datalen != sizeof(struct ast_control_t38_parameters)) {
00846 message = "Invalid";
00847 } else {
00848 struct ast_control_t38_parameters *parameters = f->data.ptr;
00849 enum ast_control_t38 state = parameters->request_response;
00850 if (state == AST_T38_REQUEST_NEGOTIATE)
00851 message = "Negotiation Requested";
00852 else if (state == AST_T38_REQUEST_TERMINATE)
00853 message = "Negotiation Request Terminated";
00854 else if (state == AST_T38_NEGOTIATED)
00855 message = "Negotiated";
00856 else if (state == AST_T38_TERMINATED)
00857 message = "Terminated";
00858 else if (state == AST_T38_REFUSED)
00859 message = "Refused";
00860 }
00861 snprintf(subclass, sizeof(subclass), "T38_Parameters/%s", message);
00862 break;
00863 case -1:
00864 strcpy(subclass, "Stop generators");
00865 break;
00866 default:
00867 snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass);
00868 }
00869 break;
00870 case AST_FRAME_NULL:
00871 strcpy(ftype, "Null Frame");
00872 strcpy(subclass, "N/A");
00873 break;
00874 case AST_FRAME_IAX:
00875
00876 strcpy(ftype, "IAX Specific");
00877 snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass);
00878 break;
00879 case AST_FRAME_TEXT:
00880 strcpy(ftype, "Text");
00881 strcpy(subclass, "N/A");
00882 ast_copy_string(moreinfo, f->data.ptr, sizeof(moreinfo));
00883 break;
00884 case AST_FRAME_IMAGE:
00885 strcpy(ftype, "Image");
00886 snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass));
00887 break;
00888 case AST_FRAME_HTML:
00889 strcpy(ftype, "HTML");
00890 switch(f->subclass) {
00891 case AST_HTML_URL:
00892 strcpy(subclass, "URL");
00893 ast_copy_string(moreinfo, f->data.ptr, sizeof(moreinfo));
00894 break;
00895 case AST_HTML_DATA:
00896 strcpy(subclass, "Data");
00897 break;
00898 case AST_HTML_BEGIN:
00899 strcpy(subclass, "Begin");
00900 break;
00901 case AST_HTML_END:
00902 strcpy(subclass, "End");
00903 break;
00904 case AST_HTML_LDCOMPLETE:
00905 strcpy(subclass, "Load Complete");
00906 break;
00907 case AST_HTML_NOSUPPORT:
00908 strcpy(subclass, "No Support");
00909 break;
00910 case AST_HTML_LINKURL:
00911 strcpy(subclass, "Link URL");
00912 ast_copy_string(moreinfo, f->data.ptr, sizeof(moreinfo));
00913 break;
00914 case AST_HTML_UNLINK:
00915 strcpy(subclass, "Unlink");
00916 break;
00917 case AST_HTML_LINKREJECT:
00918 strcpy(subclass, "Link Reject");
00919 break;
00920 default:
00921 snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass);
00922 break;
00923 }
00924 break;
00925 case AST_FRAME_MODEM:
00926 strcpy(ftype, "Modem");
00927 switch (f->subclass) {
00928 case AST_MODEM_T38:
00929 strcpy(subclass, "T.38");
00930 break;
00931 case AST_MODEM_V150:
00932 strcpy(subclass, "V.150");
00933 break;
00934 default:
00935 snprintf(subclass, sizeof(subclass), "Unknown MODEM frame '%d'\n", f->subclass);
00936 break;
00937 }
00938 break;
00939 default:
00940 snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype);
00941 }
00942 if (!ast_strlen_zero(moreinfo))
00943 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n",
00944 term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00945 term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00946 f->frametype,
00947 term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00948 f->subclass,
00949 term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)),
00950 term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00951 else
00952 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n",
00953 term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00954 term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00955 f->frametype,
00956 term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00957 f->subclass,
00958 term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00959 }
00960
00961
00962
00963 static struct ast_cli_entry my_clis[] = {
00964 AST_CLI_DEFINE(show_codecs, "Displays a list of codecs"),
00965 AST_CLI_DEFINE(show_codec_n, "Shows a specific codec"),
00966 };
00967
00968 int init_framer(void)
00969 {
00970 ast_cli_register_multiple(my_clis, ARRAY_LEN(my_clis));
00971 return 0;
00972 }
00973
00974 void ast_codec_pref_convert(struct ast_codec_pref *pref, char *buf, size_t size, int right)
00975 {
00976 int x, differential = (int) 'A', mem;
00977 char *from, *to;
00978
00979 if (right) {
00980 from = pref->order;
00981 to = buf;
00982 mem = size;
00983 } else {
00984 to = pref->order;
00985 from = buf;
00986 mem = 32;
00987 }
00988
00989 memset(to, 0, mem);
00990 for (x = 0; x < 32 ; x++) {
00991 if (!from[x])
00992 break;
00993 to[x] = right ? (from[x] + differential) : (from[x] - differential);
00994 }
00995 }
00996
00997 int ast_codec_pref_string(struct ast_codec_pref *pref, char *buf, size_t size)
00998 {
00999 int x, codec;
01000 size_t total_len, slen;
01001 char *formatname;
01002
01003 memset(buf,0,size);
01004 total_len = size;
01005 buf[0] = '(';
01006 total_len--;
01007 for(x = 0; x < 32 ; x++) {
01008 if (total_len <= 0)
01009 break;
01010 if (!(codec = ast_codec_pref_index(pref,x)))
01011 break;
01012 if ((formatname = ast_getformatname(codec))) {
01013 slen = strlen(formatname);
01014 if (slen > total_len)
01015 break;
01016 strncat(buf, formatname, total_len - 1);
01017 total_len -= slen;
01018 }
01019 if (total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) {
01020 strncat(buf, "|", total_len - 1);
01021 total_len--;
01022 }
01023 }
01024 if (total_len) {
01025 strncat(buf, ")", total_len - 1);
01026 total_len--;
01027 }
01028
01029 return size - total_len;
01030 }
01031
01032 int ast_codec_pref_index(struct ast_codec_pref *pref, int idx)
01033 {
01034 int slot = 0;
01035
01036 if ((idx >= 0) && (idx < sizeof(pref->order))) {
01037 slot = pref->order[idx];
01038 }
01039
01040 return slot ? AST_FORMAT_LIST[slot - 1].bits : 0;
01041 }
01042
01043
01044 void ast_codec_pref_remove(struct ast_codec_pref *pref, int format)
01045 {
01046 struct ast_codec_pref oldorder;
01047 int x, y = 0;
01048 int slot;
01049 int size;
01050
01051 if (!pref->order[0])
01052 return;
01053
01054 memcpy(&oldorder, pref, sizeof(oldorder));
01055 memset(pref, 0, sizeof(*pref));
01056
01057 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01058 slot = oldorder.order[x];
01059 size = oldorder.framing[x];
01060 if (! slot)
01061 break;
01062 if (AST_FORMAT_LIST[slot-1].bits != format) {
01063 pref->order[y] = slot;
01064 pref->framing[y++] = size;
01065 }
01066 }
01067
01068 }
01069
01070
01071 int ast_codec_pref_append(struct ast_codec_pref *pref, int format)
01072 {
01073 int x, newindex = 0;
01074
01075 ast_codec_pref_remove(pref, format);
01076
01077 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01078 if (AST_FORMAT_LIST[x].bits == format) {
01079 newindex = x + 1;
01080 break;
01081 }
01082 }
01083
01084 if (newindex) {
01085 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01086 if (!pref->order[x]) {
01087 pref->order[x] = newindex;
01088 break;
01089 }
01090 }
01091 }
01092
01093 return x;
01094 }
01095
01096
01097 void ast_codec_pref_prepend(struct ast_codec_pref *pref, int format, int only_if_existing)
01098 {
01099 int x, newindex = 0;
01100
01101
01102 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01103 if (AST_FORMAT_LIST[x].bits == format) {
01104 newindex = x + 1;
01105 break;
01106 }
01107 }
01108
01109 if (!newindex)
01110 return;
01111
01112
01113 for (x = 0; x < 32; x++) {
01114 if (!pref->order[x] || pref->order[x] == newindex)
01115 break;
01116 }
01117
01118 if (only_if_existing && !pref->order[x])
01119 return;
01120
01121
01122
01123 for (; x > 0; x--) {
01124 pref->order[x] = pref->order[x - 1];
01125 pref->framing[x] = pref->framing[x - 1];
01126 }
01127
01128
01129 pref->order[0] = newindex;
01130 pref->framing[0] = 0;
01131 }
01132
01133
01134 int ast_codec_pref_setsize(struct ast_codec_pref *pref, int format, int framems)
01135 {
01136 int x, idx = -1;
01137
01138 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01139 if (AST_FORMAT_LIST[x].bits == format) {
01140 idx = x;
01141 break;
01142 }
01143 }
01144
01145 if (idx < 0)
01146 return -1;
01147
01148
01149 if (!framems)
01150 framems = AST_FORMAT_LIST[idx].def_ms;
01151
01152 if (AST_FORMAT_LIST[idx].inc_ms && framems % AST_FORMAT_LIST[idx].inc_ms)
01153 framems -= framems % AST_FORMAT_LIST[idx].inc_ms;
01154
01155 if (framems < AST_FORMAT_LIST[idx].min_ms)
01156 framems = AST_FORMAT_LIST[idx].min_ms;
01157
01158 if (framems > AST_FORMAT_LIST[idx].max_ms)
01159 framems = AST_FORMAT_LIST[idx].max_ms;
01160
01161 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01162 if (pref->order[x] == (idx + 1)) {
01163 pref->framing[x] = framems;
01164 break;
01165 }
01166 }
01167
01168 return x;
01169 }
01170
01171
01172 struct ast_format_list ast_codec_pref_getsize(struct ast_codec_pref *pref, int format)
01173 {
01174 int x, idx = -1, framems = 0;
01175 struct ast_format_list fmt = { 0, };
01176
01177 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01178 if (AST_FORMAT_LIST[x].bits == format) {
01179 fmt = AST_FORMAT_LIST[x];
01180 idx = x;
01181 break;
01182 }
01183 }
01184
01185 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01186 if (pref->order[x] == (idx + 1)) {
01187 framems = pref->framing[x];
01188 break;
01189 }
01190 }
01191
01192
01193 if (!framems)
01194 framems = AST_FORMAT_LIST[idx].def_ms;
01195
01196 if (AST_FORMAT_LIST[idx].inc_ms && framems % AST_FORMAT_LIST[idx].inc_ms)
01197 framems -= framems % AST_FORMAT_LIST[idx].inc_ms;
01198
01199 if (framems < AST_FORMAT_LIST[idx].min_ms)
01200 framems = AST_FORMAT_LIST[idx].min_ms;
01201
01202 if (framems > AST_FORMAT_LIST[idx].max_ms)
01203 framems = AST_FORMAT_LIST[idx].max_ms;
01204
01205 fmt.cur_ms = framems;
01206
01207 return fmt;
01208 }
01209
01210
01211 int ast_codec_choose(struct ast_codec_pref *pref, int formats, int find_best)
01212 {
01213 int x, ret = 0, slot;
01214
01215 for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01216 slot = pref->order[x];
01217
01218 if (!slot)
01219 break;
01220 if (formats & AST_FORMAT_LIST[slot-1].bits) {
01221 ret = AST_FORMAT_LIST[slot-1].bits;
01222 break;
01223 }
01224 }
01225 if (ret & AST_FORMAT_AUDIO_MASK)
01226 return ret;
01227
01228 ast_debug(4, "Could not find preferred codec - %s\n", find_best ? "Going for the best codec" : "Returning zero codec");
01229
01230 return find_best ? ast_best_codec(formats) : 0;
01231 }
01232
01233 int ast_parse_allow_disallow(struct ast_codec_pref *pref, int *mask, const char *list, int allowing)
01234 {
01235 int errors = 0;
01236 char *parse = NULL, *this = NULL, *psize = NULL;
01237 int format = 0, framems = 0;
01238
01239 parse = ast_strdupa(list);
01240 while ((this = strsep(&parse, ","))) {
01241 framems = 0;
01242 if ((psize = strrchr(this, ':'))) {
01243 *psize++ = '\0';
01244 ast_debug(1, "Packetization for codec: %s is %s\n", this, psize);
01245 framems = atoi(psize);
01246 if (framems < 0) {
01247 framems = 0;
01248 errors++;
01249 ast_log(LOG_WARNING, "Bad packetization value for codec %s\n", this);
01250 }
01251 }
01252 if (!(format = ast_getformatbyname(this))) {
01253 ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", this);
01254 errors++;
01255 continue;
01256 }
01257
01258 if (mask) {
01259 if (allowing)
01260 *mask |= format;
01261 else
01262 *mask &= ~format;
01263 }
01264
01265
01266
01267
01268 if (pref && (format & AST_FORMAT_AUDIO_MASK)) {
01269 if (strcasecmp(this, "all")) {
01270 if (allowing) {
01271 ast_codec_pref_append(pref, format);
01272 ast_codec_pref_setsize(pref, format, framems);
01273 }
01274 else
01275 ast_codec_pref_remove(pref, format);
01276 } else if (!allowing) {
01277 memset(pref, 0, sizeof(*pref));
01278 }
01279 }
01280 }
01281 return errors;
01282 }
01283
01284 static int g723_len(unsigned char buf)
01285 {
01286 enum frame_type type = buf & TYPE_MASK;
01287
01288 switch(type) {
01289 case TYPE_DONTSEND:
01290 return 0;
01291 break;
01292 case TYPE_SILENCE:
01293 return 4;
01294 break;
01295 case TYPE_HIGH:
01296 return 24;
01297 break;
01298 case TYPE_LOW:
01299 return 20;
01300 break;
01301 default:
01302 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", type);
01303 }
01304 return -1;
01305 }
01306
01307 static int g723_samples(unsigned char *buf, int maxlen)
01308 {
01309 int pos = 0;
01310 int samples = 0;
01311 int res;
01312 while(pos < maxlen) {
01313 res = g723_len(buf[pos]);
01314 if (res <= 0)
01315 break;
01316 samples += 240;
01317 pos += res;
01318 }
01319 return samples;
01320 }
01321
01322 static unsigned char get_n_bits_at(unsigned char *data, int n, int bit)
01323 {
01324 int byte = bit / 8;
01325 int rem = 8 - (bit % 8);
01326 unsigned char ret = 0;
01327
01328 if (n <= 0 || n > 8)
01329 return 0;
01330
01331 if (rem < n) {
01332 ret = (data[byte] << (n - rem));
01333 ret |= (data[byte + 1] >> (8 - n + rem));
01334 } else {
01335 ret = (data[byte] >> (rem - n));
01336 }
01337
01338 return (ret & (0xff >> (8 - n)));
01339 }
01340
01341 static int speex_get_wb_sz_at(unsigned char *data, int len, int bit)
01342 {
01343 static int SpeexWBSubModeSz[] = {
01344 0, 36, 112, 192,
01345 352, 0, 0, 0 };
01346 int off = bit;
01347 unsigned char c;
01348
01349
01350 if (((len * 8 - off) >= 5) &&
01351 get_n_bits_at(data, 1, off)) {
01352 c = get_n_bits_at(data, 3, off + 1);
01353 off += SpeexWBSubModeSz[c];
01354
01355 if (((len * 8 - off) >= 5) &&
01356 get_n_bits_at(data, 1, off)) {
01357 c = get_n_bits_at(data, 3, off + 1);
01358 off += SpeexWBSubModeSz[c];
01359
01360 if (((len * 8 - off) >= 5) &&
01361 get_n_bits_at(data, 1, off)) {
01362 ast_log(LOG_WARNING, "Encountered corrupt speex frame; too many wideband frames in a row.\n");
01363 return -1;
01364 }
01365 }
01366
01367 }
01368 return off - bit;
01369 }
01370
01371 static int speex_samples(unsigned char *data, int len)
01372 {
01373 static int SpeexSubModeSz[] = {
01374 5, 43, 119, 160,
01375 220, 300, 364, 492,
01376 79, 0, 0, 0,
01377 0, 0, 0, 0 };
01378 static int SpeexInBandSz[] = {
01379 1, 1, 4, 4,
01380 4, 4, 4, 4,
01381 8, 8, 16, 16,
01382 32, 32, 64, 64 };
01383 int bit = 0;
01384 int cnt = 0;
01385 int off;
01386 unsigned char c;
01387
01388 while ((len * 8 - bit) >= 5) {
01389
01390 off = speex_get_wb_sz_at(data, len, bit);
01391 if (off < 0) {
01392 ast_log(LOG_WARNING, "Had error while reading wideband frames for speex samples\n");
01393 break;
01394 }
01395 bit += off;
01396
01397 if ((len * 8 - bit) == 0) {
01398 break;
01399 } else if ((len * 8 - bit) < 5) {
01400 ast_log(LOG_WARNING, "Not enough bits remaining after wide band for speex samples.\n");
01401 break;
01402 }
01403
01404
01405 c = get_n_bits_at(data, 5, bit);
01406 bit += 5;
01407
01408 if (c == 15) {
01409
01410 break;
01411 } else if (c == 14) {
01412
01413 c = get_n_bits_at(data, 4, bit);
01414 bit += 4;
01415 bit += SpeexInBandSz[c];
01416 } else if (c == 13) {
01417
01418 c = get_n_bits_at(data, 5, bit);
01419 bit += 5;
01420 bit += c * 8;
01421 } else if (c > 8) {
01422
01423 break;
01424 } else {
01425
01426 bit += SpeexSubModeSz[c] - 5;
01427 cnt += 160;
01428 }
01429 }
01430 return cnt;
01431 }
01432
01433 int ast_codec_get_samples(struct ast_frame *f)
01434 {
01435 int samples = 0;
01436
01437 switch(f->subclass) {
01438 case AST_FORMAT_SPEEX:
01439 samples = speex_samples(f->data.ptr, f->datalen);
01440 break;
01441 case AST_FORMAT_G723_1:
01442 samples = g723_samples(f->data.ptr, f->datalen);
01443 break;
01444 case AST_FORMAT_ILBC:
01445 samples = 240 * (f->datalen / 50);
01446 break;
01447 case AST_FORMAT_GSM:
01448 samples = 160 * (f->datalen / 33);
01449 break;
01450 case AST_FORMAT_G729A:
01451 samples = f->datalen * 8;
01452 break;
01453 case AST_FORMAT_SLINEAR:
01454 case AST_FORMAT_SLINEAR16:
01455 samples = f->datalen / 2;
01456 break;
01457 case AST_FORMAT_LPC10:
01458
01459 samples = 22 * 8;
01460 samples += (((char *)(f->data.ptr))[7] & 0x1) * 8;
01461 break;
01462 case AST_FORMAT_ULAW:
01463 case AST_FORMAT_ALAW:
01464 samples = f->datalen;
01465 break;
01466 case AST_FORMAT_G722:
01467 case AST_FORMAT_ADPCM:
01468 case AST_FORMAT_G726:
01469 case AST_FORMAT_G726_AAL2:
01470 samples = f->datalen * 2;
01471 break;
01472 case AST_FORMAT_SIREN7:
01473
01474 samples = f->datalen * (16000 / 4000);
01475 break;
01476 case AST_FORMAT_SIREN14:
01477
01478 samples = (int) f->datalen * ((float) 32000 / 6000);
01479 break;
01480 default:
01481 ast_log(LOG_WARNING, "Unable to calculate samples for format %s\n", ast_getformatname(f->subclass));
01482 }
01483 return samples;
01484 }
01485
01486 int ast_codec_get_len(int format, int samples)
01487 {
01488 int len = 0;
01489
01490
01491 switch(format) {
01492 case AST_FORMAT_G723_1:
01493 len = (samples / 240) * 20;
01494 break;
01495 case AST_FORMAT_ILBC:
01496 len = (samples / 240) * 50;
01497 break;
01498 case AST_FORMAT_GSM:
01499 len = (samples / 160) * 33;
01500 break;
01501 case AST_FORMAT_G729A:
01502 len = samples / 8;
01503 break;
01504 case AST_FORMAT_SLINEAR:
01505 case AST_FORMAT_SLINEAR16:
01506 len = samples * 2;
01507 break;
01508 case AST_FORMAT_ULAW:
01509 case AST_FORMAT_ALAW:
01510 len = samples;
01511 break;
01512 case AST_FORMAT_G722:
01513 case AST_FORMAT_ADPCM:
01514 case AST_FORMAT_G726:
01515 case AST_FORMAT_G726_AAL2:
01516 len = samples / 2;
01517 break;
01518 case AST_FORMAT_SIREN7:
01519
01520 len = samples / (16000 / 4000);
01521 break;
01522 case AST_FORMAT_SIREN14:
01523
01524 len = (int) samples / ((float) 32000 / 6000);
01525 break;
01526 default:
01527 ast_log(LOG_WARNING, "Unable to calculate sample length for format %s\n", ast_getformatname(format));
01528 }
01529
01530 return len;
01531 }
01532
01533 int ast_frame_adjust_volume(struct ast_frame *f, int adjustment)
01534 {
01535 int count;
01536 short *fdata = f->data.ptr;
01537 short adjust_value = abs(adjustment);
01538
01539 if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
01540 return -1;
01541
01542 if (!adjustment)
01543 return 0;
01544
01545 for (count = 0; count < f->samples; count++) {
01546 if (adjustment > 0) {
01547 ast_slinear_saturated_multiply(&fdata[count], &adjust_value);
01548 } else if (adjustment < 0) {
01549 ast_slinear_saturated_divide(&fdata[count], &adjust_value);
01550 }
01551 }
01552
01553 return 0;
01554 }
01555
01556 int ast_frame_slinear_sum(struct ast_frame *f1, struct ast_frame *f2)
01557 {
01558 int count;
01559 short *data1, *data2;
01560
01561 if ((f1->frametype != AST_FRAME_VOICE) || (f1->subclass != AST_FORMAT_SLINEAR))
01562 return -1;
01563
01564 if ((f2->frametype != AST_FRAME_VOICE) || (f2->subclass != AST_FORMAT_SLINEAR))
01565 return -1;
01566
01567 if (f1->samples != f2->samples)
01568 return -1;
01569
01570 for (count = 0, data1 = f1->data.ptr, data2 = f2->data.ptr;
01571 count < f1->samples;
01572 count++, data1++, data2++)
01573 ast_slinear_saturated_add(data1, data2);
01574
01575 return 0;
01576 }