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
00027
00028
00029
00030 #include "asterisk.h"
00031
00032 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 369001 $")
00033
00034 #include <math.h>
00035
00036 #include "asterisk/channel.h"
00037 #include "asterisk/frame.h"
00038 #include "asterisk/module.h"
00039 #include "asterisk/rtp_engine.h"
00040 #include "asterisk/manager.h"
00041 #include "asterisk/options.h"
00042 #include "asterisk/astobj2.h"
00043 #include "asterisk/pbx.h"
00044 #include "asterisk/translate.h"
00045 #include "asterisk/netsock2.h"
00046 #include "asterisk/framehook.h"
00047
00048 struct ast_srtp_res *res_srtp = NULL;
00049 struct ast_srtp_policy_res *res_srtp_policy = NULL;
00050
00051
00052 struct ast_rtp_instance {
00053
00054 struct ast_rtp_engine *engine;
00055
00056 void *data;
00057
00058 int properties[AST_RTP_PROPERTY_MAX];
00059
00060 struct ast_sockaddr local_address;
00061
00062 struct ast_sockaddr remote_address;
00063
00064 struct ast_sockaddr alt_remote_address;
00065
00066 struct ast_rtp_instance *bridged;
00067
00068 struct ast_rtp_codecs codecs;
00069
00070 int timeout;
00071
00072 int holdtimeout;
00073
00074 int keepalive;
00075
00076 struct ast_rtp_glue *glue;
00077
00078 struct ast_channel *chan;
00079
00080 struct ast_srtp *srtp;
00081 };
00082
00083
00084 static AST_RWLIST_HEAD_STATIC(engines, ast_rtp_engine);
00085
00086
00087 static AST_RWLIST_HEAD_STATIC(glues, ast_rtp_glue);
00088
00089
00090
00091 static const struct ast_rtp_mime_type {
00092 struct ast_rtp_payload_type payload_type;
00093 char *type;
00094 char *subtype;
00095 unsigned int sample_rate;
00096 } ast_rtp_mime_types[] = {
00097 {{1, AST_FORMAT_G723_1}, "audio", "G723", 8000},
00098 {{1, AST_FORMAT_GSM}, "audio", "GSM", 8000},
00099 {{1, AST_FORMAT_ULAW}, "audio", "PCMU", 8000},
00100 {{1, AST_FORMAT_ULAW}, "audio", "G711U", 8000},
00101 {{1, AST_FORMAT_ALAW}, "audio", "PCMA", 8000},
00102 {{1, AST_FORMAT_ALAW}, "audio", "G711A", 8000},
00103 {{1, AST_FORMAT_G726}, "audio", "G726-32", 8000},
00104 {{1, AST_FORMAT_ADPCM}, "audio", "DVI4", 8000},
00105 {{1, AST_FORMAT_SLINEAR}, "audio", "L16", 8000},
00106 {{1, AST_FORMAT_SLINEAR16}, "audio", "L16", 16000},
00107 {{1, AST_FORMAT_SLINEAR16}, "audio", "L16-256", 16000},
00108 {{1, AST_FORMAT_LPC10}, "audio", "LPC", 8000},
00109 {{1, AST_FORMAT_G729A}, "audio", "G729", 8000},
00110 {{1, AST_FORMAT_G729A}, "audio", "G729A", 8000},
00111 {{1, AST_FORMAT_G729A}, "audio", "G.729", 8000},
00112 {{1, AST_FORMAT_SPEEX}, "audio", "speex", 8000},
00113 {{1, AST_FORMAT_SPEEX16}, "audio", "speex", 16000},
00114 {{1, AST_FORMAT_ILBC}, "audio", "iLBC", 8000},
00115
00116
00117
00118 {{1, AST_FORMAT_G722}, "audio", "G722", 8000},
00119 {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32", 8000},
00120 {{0, AST_RTP_DTMF}, "audio", "telephone-event", 8000},
00121 {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event", 8000},
00122 {{0, AST_RTP_CN}, "audio", "CN", 8000},
00123 {{1, AST_FORMAT_JPEG}, "video", "JPEG", 90000},
00124 {{1, AST_FORMAT_PNG}, "video", "PNG", 90000},
00125 {{1, AST_FORMAT_H261}, "video", "H261", 90000},
00126 {{1, AST_FORMAT_H263}, "video", "H263", 90000},
00127 {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998", 90000},
00128 {{1, AST_FORMAT_H264}, "video", "H264", 90000},
00129 {{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES", 90000},
00130 {{1, AST_FORMAT_T140RED}, "text", "RED", 1000},
00131 {{1, AST_FORMAT_T140}, "text", "T140", 1000},
00132 {{1, AST_FORMAT_SIREN7}, "audio", "G7221", 16000},
00133 {{1, AST_FORMAT_SIREN14}, "audio", "G7221", 32000},
00134 {{1, AST_FORMAT_G719}, "audio", "G719", 48000},
00135 };
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147 static const struct ast_rtp_payload_type static_RTP_PT[AST_RTP_MAX_PT] = {
00148 [0] = {1, AST_FORMAT_ULAW},
00149 #ifdef USE_DEPRECATED_G726
00150 [2] = {1, AST_FORMAT_G726},
00151 #endif
00152 [3] = {1, AST_FORMAT_GSM},
00153 [4] = {1, AST_FORMAT_G723_1},
00154 [5] = {1, AST_FORMAT_ADPCM},
00155 [6] = {1, AST_FORMAT_ADPCM},
00156 [7] = {1, AST_FORMAT_LPC10},
00157 [8] = {1, AST_FORMAT_ALAW},
00158 [9] = {1, AST_FORMAT_G722},
00159 [10] = {1, AST_FORMAT_SLINEAR},
00160 [11] = {1, AST_FORMAT_SLINEAR},
00161 [13] = {0, AST_RTP_CN},
00162 [16] = {1, AST_FORMAT_ADPCM},
00163 [17] = {1, AST_FORMAT_ADPCM},
00164 [18] = {1, AST_FORMAT_G729A},
00165 [19] = {0, AST_RTP_CN},
00166 [26] = {1, AST_FORMAT_JPEG},
00167 [31] = {1, AST_FORMAT_H261},
00168 [34] = {1, AST_FORMAT_H263},
00169 [97] = {1, AST_FORMAT_ILBC},
00170 [98] = {1, AST_FORMAT_H263_PLUS},
00171 [99] = {1, AST_FORMAT_H264},
00172 [101] = {0, AST_RTP_DTMF},
00173 [102] = {1, AST_FORMAT_SIREN7},
00174 [103] = {1, AST_FORMAT_H263_PLUS},
00175 [104] = {1, AST_FORMAT_MP4_VIDEO},
00176 [105] = {1, AST_FORMAT_T140RED},
00177 [106] = {1, AST_FORMAT_T140},
00178 [110] = {1, AST_FORMAT_SPEEX},
00179 [111] = {1, AST_FORMAT_G726},
00180 [112] = {1, AST_FORMAT_G726_AAL2},
00181 [115] = {1, AST_FORMAT_SIREN14},
00182 [116] = {1, AST_FORMAT_G719},
00183 [117] = {1, AST_FORMAT_SPEEX16},
00184 [118] = {1, AST_FORMAT_SLINEAR16},
00185 [121] = {0, AST_RTP_CISCO_DTMF},
00186 };
00187
00188 int ast_rtp_engine_register2(struct ast_rtp_engine *engine, struct ast_module *module)
00189 {
00190 struct ast_rtp_engine *current_engine;
00191
00192
00193 if (ast_strlen_zero(engine->name) || !engine->new || !engine->destroy || !engine->write || !engine->read) {
00194 ast_log(LOG_WARNING, "RTP Engine '%s' failed sanity check so it was not registered.\n", !ast_strlen_zero(engine->name) ? engine->name : "Unknown");
00195 return -1;
00196 }
00197
00198
00199 engine->mod = module;
00200
00201 AST_RWLIST_WRLOCK(&engines);
00202
00203
00204 AST_RWLIST_TRAVERSE(&engines, current_engine, entry) {
00205 if (!strcmp(current_engine->name, engine->name)) {
00206 ast_log(LOG_WARNING, "An RTP engine with the name '%s' has already been registered.\n", engine->name);
00207 AST_RWLIST_UNLOCK(&engines);
00208 return -1;
00209 }
00210 }
00211
00212
00213 AST_RWLIST_INSERT_TAIL(&engines, engine, entry);
00214
00215 AST_RWLIST_UNLOCK(&engines);
00216
00217 ast_verb(2, "Registered RTP engine '%s'\n", engine->name);
00218
00219 return 0;
00220 }
00221
00222 int ast_rtp_engine_unregister(struct ast_rtp_engine *engine)
00223 {
00224 struct ast_rtp_engine *current_engine = NULL;
00225
00226 AST_RWLIST_WRLOCK(&engines);
00227
00228 if ((current_engine = AST_RWLIST_REMOVE(&engines, engine, entry))) {
00229 ast_verb(2, "Unregistered RTP engine '%s'\n", engine->name);
00230 }
00231
00232 AST_RWLIST_UNLOCK(&engines);
00233
00234 return current_engine ? 0 : -1;
00235 }
00236
00237 int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module)
00238 {
00239 struct ast_rtp_glue *current_glue = NULL;
00240
00241 if (ast_strlen_zero(glue->type)) {
00242 return -1;
00243 }
00244
00245 glue->mod = module;
00246
00247 AST_RWLIST_WRLOCK(&glues);
00248
00249 AST_RWLIST_TRAVERSE(&glues, current_glue, entry) {
00250 if (!strcasecmp(current_glue->type, glue->type)) {
00251 ast_log(LOG_WARNING, "RTP glue with the name '%s' has already been registered.\n", glue->type);
00252 AST_RWLIST_UNLOCK(&glues);
00253 return -1;
00254 }
00255 }
00256
00257 AST_RWLIST_INSERT_TAIL(&glues, glue, entry);
00258
00259 AST_RWLIST_UNLOCK(&glues);
00260
00261 ast_verb(2, "Registered RTP glue '%s'\n", glue->type);
00262
00263 return 0;
00264 }
00265
00266 int ast_rtp_glue_unregister(struct ast_rtp_glue *glue)
00267 {
00268 struct ast_rtp_glue *current_glue = NULL;
00269
00270 AST_RWLIST_WRLOCK(&glues);
00271
00272 if ((current_glue = AST_RWLIST_REMOVE(&glues, glue, entry))) {
00273 ast_verb(2, "Unregistered RTP glue '%s'\n", glue->type);
00274 }
00275
00276 AST_RWLIST_UNLOCK(&glues);
00277
00278 return current_glue ? 0 : -1;
00279 }
00280
00281 static void instance_destructor(void *obj)
00282 {
00283 struct ast_rtp_instance *instance = obj;
00284
00285
00286 if (instance->data && instance->engine->destroy(instance)) {
00287 ast_debug(1, "Engine '%s' failed to destroy RTP instance '%p'\n", instance->engine->name, instance);
00288 return;
00289 }
00290
00291 if (instance->srtp) {
00292 res_srtp->destroy(instance->srtp);
00293 }
00294
00295
00296 ast_module_unref(instance->engine->mod);
00297
00298 ast_debug(1, "Destroyed RTP instance '%p'\n", instance);
00299 }
00300
00301 int ast_rtp_instance_destroy(struct ast_rtp_instance *instance)
00302 {
00303 ao2_ref(instance, -1);
00304
00305 return 0;
00306 }
00307
00308 struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name,
00309 struct sched_context *sched, const struct ast_sockaddr *sa,
00310 void *data)
00311 {
00312 struct ast_sockaddr address = {{0,}};
00313 struct ast_rtp_instance *instance = NULL;
00314 struct ast_rtp_engine *engine = NULL;
00315
00316 AST_RWLIST_RDLOCK(&engines);
00317
00318
00319 if (!ast_strlen_zero(engine_name)) {
00320 AST_RWLIST_TRAVERSE(&engines, engine, entry) {
00321 if (!strcmp(engine->name, engine_name)) {
00322 break;
00323 }
00324 }
00325 } else {
00326 engine = AST_RWLIST_FIRST(&engines);
00327 }
00328
00329
00330 if (!engine) {
00331 ast_log(LOG_ERROR, "No RTP engine was found. Do you have one loaded?\n");
00332 AST_RWLIST_UNLOCK(&engines);
00333 return NULL;
00334 }
00335
00336
00337 ast_module_ref(engine->mod);
00338
00339 AST_RWLIST_UNLOCK(&engines);
00340
00341
00342 if (!(instance = ao2_alloc(sizeof(*instance), instance_destructor))) {
00343 ast_module_unref(engine->mod);
00344 return NULL;
00345 }
00346 instance->engine = engine;
00347 ast_sockaddr_copy(&instance->local_address, sa);
00348 ast_sockaddr_copy(&address, sa);
00349
00350 ast_debug(1, "Using engine '%s' for RTP instance '%p'\n", engine->name, instance);
00351
00352
00353 if (instance->engine->new(instance, sched, &address, data)) {
00354 ast_debug(1, "Engine '%s' failed to setup RTP instance '%p'\n", engine->name, instance);
00355 ao2_ref(instance, -1);
00356 return NULL;
00357 }
00358
00359 ast_debug(1, "RTP instance '%p' is setup and ready to go\n", instance);
00360
00361 return instance;
00362 }
00363
00364 void ast_rtp_instance_set_data(struct ast_rtp_instance *instance, void *data)
00365 {
00366 instance->data = data;
00367 }
00368
00369 void *ast_rtp_instance_get_data(struct ast_rtp_instance *instance)
00370 {
00371 return instance->data;
00372 }
00373
00374 int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
00375 {
00376 return instance->engine->write(instance, frame);
00377 }
00378
00379 struct ast_frame *ast_rtp_instance_read(struct ast_rtp_instance *instance, int rtcp)
00380 {
00381 return instance->engine->read(instance, rtcp);
00382 }
00383
00384 int ast_rtp_instance_set_local_address(struct ast_rtp_instance *instance,
00385 const struct ast_sockaddr *address)
00386 {
00387 ast_sockaddr_copy(&instance->local_address, address);
00388 return 0;
00389 }
00390
00391 int ast_rtp_instance_set_remote_address(struct ast_rtp_instance *instance,
00392 const struct ast_sockaddr *address)
00393 {
00394 ast_sockaddr_copy(&instance->remote_address, address);
00395
00396
00397
00398 if (instance->engine->remote_address_set) {
00399 instance->engine->remote_address_set(instance, &instance->remote_address);
00400 }
00401
00402 return 0;
00403 }
00404
00405 int ast_rtp_instance_set_alt_remote_address(struct ast_rtp_instance *instance,
00406 const struct ast_sockaddr *address)
00407 {
00408 ast_sockaddr_copy(&instance->alt_remote_address, address);
00409
00410
00411
00412 if (instance->engine->alt_remote_address_set) {
00413 instance->engine->alt_remote_address_set(instance, &instance->alt_remote_address);
00414 }
00415
00416 return 0;
00417 }
00418
00419 int ast_rtp_instance_get_and_cmp_local_address(struct ast_rtp_instance *instance,
00420 struct ast_sockaddr *address)
00421 {
00422 if (ast_sockaddr_cmp(address, &instance->local_address) != 0) {
00423 ast_sockaddr_copy(address, &instance->local_address);
00424 return 1;
00425 }
00426
00427 return 0;
00428 }
00429
00430 void ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance,
00431 struct ast_sockaddr *address)
00432 {
00433 ast_sockaddr_copy(address, &instance->local_address);
00434 }
00435
00436 int ast_rtp_instance_get_and_cmp_remote_address(struct ast_rtp_instance *instance,
00437 struct ast_sockaddr *address)
00438 {
00439 if (ast_sockaddr_cmp(address, &instance->remote_address) != 0) {
00440 ast_sockaddr_copy(address, &instance->remote_address);
00441 return 1;
00442 }
00443
00444 return 0;
00445 }
00446
00447 void ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance,
00448 struct ast_sockaddr *address)
00449 {
00450 ast_sockaddr_copy(address, &instance->remote_address);
00451 }
00452
00453 void ast_rtp_instance_set_extended_prop(struct ast_rtp_instance *instance, int property, void *value)
00454 {
00455 if (instance->engine->extended_prop_set) {
00456 instance->engine->extended_prop_set(instance, property, value);
00457 }
00458 }
00459
00460 void *ast_rtp_instance_get_extended_prop(struct ast_rtp_instance *instance, int property)
00461 {
00462 if (instance->engine->extended_prop_get) {
00463 return instance->engine->extended_prop_get(instance, property);
00464 }
00465
00466 return NULL;
00467 }
00468
00469 void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
00470 {
00471 instance->properties[property] = value;
00472
00473 if (instance->engine->prop_set) {
00474 instance->engine->prop_set(instance, property, value);
00475 }
00476 }
00477
00478 int ast_rtp_instance_get_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property)
00479 {
00480 return instance->properties[property];
00481 }
00482
00483 struct ast_rtp_codecs *ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance)
00484 {
00485 return &instance->codecs;
00486 }
00487
00488 void ast_rtp_codecs_payloads_clear(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance)
00489 {
00490 int i;
00491
00492 for (i = 0; i < AST_RTP_MAX_PT; i++) {
00493 codecs->payloads[i].asterisk_format = 0;
00494 codecs->payloads[i].code = 0;
00495 if (instance && instance->engine && instance->engine->payload_set) {
00496 instance->engine->payload_set(instance, i, 0, 0);
00497 }
00498 }
00499 }
00500
00501 void ast_rtp_codecs_payloads_default(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance)
00502 {
00503 int i;
00504
00505 for (i = 0; i < AST_RTP_MAX_PT; i++) {
00506 if (static_RTP_PT[i].code) {
00507 codecs->payloads[i].asterisk_format = static_RTP_PT[i].asterisk_format;
00508 codecs->payloads[i].code = static_RTP_PT[i].code;
00509 if (instance && instance->engine && instance->engine->payload_set) {
00510 instance->engine->payload_set(instance, i, codecs->payloads[i].asterisk_format, codecs->payloads[i].code);
00511 }
00512 }
00513 }
00514 }
00515
00516 void ast_rtp_codecs_payloads_copy(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
00517 {
00518 int i;
00519
00520 for (i = 0; i < AST_RTP_MAX_PT; i++) {
00521 if (src->payloads[i].code) {
00522 ast_debug(2, "Copying payload %d from %p to %p\n", i, src, dest);
00523 dest->payloads[i].asterisk_format = src->payloads[i].asterisk_format;
00524 dest->payloads[i].code = src->payloads[i].code;
00525 if (instance && instance->engine && instance->engine->payload_set) {
00526 instance->engine->payload_set(instance, i, dest->payloads[i].asterisk_format, dest->payloads[i].code);
00527 }
00528 }
00529 }
00530 }
00531
00532 void ast_rtp_codecs_payloads_set_m_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
00533 {
00534 if (payload < 0 || payload >= AST_RTP_MAX_PT || !static_RTP_PT[payload].code) {
00535 return;
00536 }
00537
00538 codecs->payloads[payload].asterisk_format = static_RTP_PT[payload].asterisk_format;
00539 codecs->payloads[payload].code = static_RTP_PT[payload].code;
00540
00541 ast_debug(1, "Setting payload %d based on m type on %p\n", payload, codecs);
00542
00543 if (instance && instance->engine && instance->engine->payload_set) {
00544 instance->engine->payload_set(instance, payload, codecs->payloads[payload].asterisk_format, codecs->payloads[payload].code);
00545 }
00546 }
00547
00548 int ast_rtp_codecs_payloads_set_rtpmap_type_rate(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int pt,
00549 char *mimetype, char *mimesubtype,
00550 enum ast_rtp_options options,
00551 unsigned int sample_rate)
00552 {
00553 unsigned int i;
00554 int found = 0;
00555
00556 if (pt < 0 || pt >= AST_RTP_MAX_PT)
00557 return -1;
00558
00559 for (i = 0; i < ARRAY_LEN(ast_rtp_mime_types); ++i) {
00560 const struct ast_rtp_mime_type *t = &ast_rtp_mime_types[i];
00561
00562 if (strcasecmp(mimesubtype, t->subtype)) {
00563 continue;
00564 }
00565
00566 if (strcasecmp(mimetype, t->type)) {
00567 continue;
00568 }
00569
00570
00571
00572
00573 if (sample_rate && t->sample_rate &&
00574 (sample_rate != t->sample_rate)) {
00575 continue;
00576 }
00577
00578 found = 1;
00579 codecs->payloads[pt] = t->payload_type;
00580
00581 if ((t->payload_type.code == AST_FORMAT_G726) &&
00582 t->payload_type.asterisk_format &&
00583 (options & AST_RTP_OPT_G726_NONSTANDARD)) {
00584 codecs->payloads[pt].code = AST_FORMAT_G726_AAL2;
00585 }
00586
00587 if (instance && instance->engine && instance->engine->payload_set) {
00588 instance->engine->payload_set(instance, pt, codecs->payloads[i].asterisk_format, codecs->payloads[i].code);
00589 }
00590
00591 break;
00592 }
00593
00594 return (found ? 0 : -2);
00595 }
00596
00597 int ast_rtp_codecs_payloads_set_rtpmap_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload, char *mimetype, char *mimesubtype, enum ast_rtp_options options)
00598 {
00599 return ast_rtp_codecs_payloads_set_rtpmap_type_rate(codecs, instance, payload, mimetype, mimesubtype, options, 0);
00600 }
00601
00602 void ast_rtp_codecs_payloads_unset(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
00603 {
00604 if (payload < 0 || payload >= AST_RTP_MAX_PT) {
00605 return;
00606 }
00607
00608 ast_debug(2, "Unsetting payload %d on %p\n", payload, codecs);
00609
00610 codecs->payloads[payload].asterisk_format = 0;
00611 codecs->payloads[payload].code = 0;
00612
00613 if (instance && instance->engine && instance->engine->payload_set) {
00614 instance->engine->payload_set(instance, payload, 0, 0);
00615 }
00616 }
00617
00618 struct ast_rtp_payload_type ast_rtp_codecs_payload_lookup(struct ast_rtp_codecs *codecs, int payload)
00619 {
00620 struct ast_rtp_payload_type result = { .asterisk_format = 0, };
00621
00622 if (payload < 0 || payload >= AST_RTP_MAX_PT) {
00623 return result;
00624 }
00625
00626 result.asterisk_format = codecs->payloads[payload].asterisk_format;
00627 result.code = codecs->payloads[payload].code;
00628
00629 if (!result.code) {
00630 result = static_RTP_PT[payload];
00631 }
00632
00633 return result;
00634 }
00635
00636 void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, format_t *astformats, int *nonastformats)
00637 {
00638 int i;
00639
00640 *astformats = *nonastformats = 0;
00641
00642 for (i = 0; i < AST_RTP_MAX_PT; i++) {
00643 if (codecs->payloads[i].code) {
00644 ast_debug(1, "Incorporating payload %d on %p\n", i, codecs);
00645 }
00646 if (codecs->payloads[i].asterisk_format) {
00647 *astformats |= codecs->payloads[i].code;
00648 } else {
00649 *nonastformats |= codecs->payloads[i].code;
00650 }
00651 }
00652 }
00653
00654 int ast_rtp_codecs_payload_code(struct ast_rtp_codecs *codecs, const int asterisk_format, const format_t code)
00655 {
00656 int i;
00657
00658 for (i = 0; i < AST_RTP_MAX_PT; i++) {
00659 if (codecs->payloads[i].asterisk_format == asterisk_format && codecs->payloads[i].code == code) {
00660 return i;
00661 }
00662 }
00663
00664 for (i = 0; i < AST_RTP_MAX_PT; i++) {
00665 if (static_RTP_PT[i].asterisk_format == asterisk_format && static_RTP_PT[i].code == code) {
00666 return i;
00667 }
00668 }
00669
00670 return -1;
00671 }
00672
00673 const char *ast_rtp_lookup_mime_subtype2(const int asterisk_format, const format_t code, enum ast_rtp_options options)
00674 {
00675 int i;
00676
00677 for (i = 0; i < ARRAY_LEN(ast_rtp_mime_types); i++) {
00678 if (ast_rtp_mime_types[i].payload_type.code == code && ast_rtp_mime_types[i].payload_type.asterisk_format == asterisk_format) {
00679 if (asterisk_format && (code == AST_FORMAT_G726_AAL2) && (options & AST_RTP_OPT_G726_NONSTANDARD)) {
00680 return "G726-32";
00681 } else {
00682 return ast_rtp_mime_types[i].subtype;
00683 }
00684 }
00685 }
00686
00687 return "";
00688 }
00689
00690 unsigned int ast_rtp_lookup_sample_rate2(int asterisk_format, format_t code)
00691 {
00692 unsigned int i;
00693
00694 for (i = 0; i < ARRAY_LEN(ast_rtp_mime_types); ++i) {
00695 if ((ast_rtp_mime_types[i].payload_type.code == code) && (ast_rtp_mime_types[i].payload_type.asterisk_format == asterisk_format)) {
00696 return ast_rtp_mime_types[i].sample_rate;
00697 }
00698 }
00699
00700 return 0;
00701 }
00702
00703 char *ast_rtp_lookup_mime_multiple2(struct ast_str *buf, const format_t capability, const int asterisk_format, enum ast_rtp_options options)
00704 {
00705 format_t format;
00706 int found = 0;
00707
00708 if (!buf) {
00709 return NULL;
00710 }
00711
00712 ast_str_append(&buf, 0, "0x%llx (", (unsigned long long) capability);
00713
00714 for (format = 1; format < AST_RTP_MAX; format <<= 1) {
00715 if (capability & format) {
00716 const char *name = ast_rtp_lookup_mime_subtype2(asterisk_format, format, options);
00717 ast_str_append(&buf, 0, "%s|", name);
00718 found = 1;
00719 }
00720 }
00721
00722 ast_str_append(&buf, 0, "%s", found ? ")" : "nothing)");
00723
00724 return ast_str_buffer(buf);
00725 }
00726
00727 void ast_rtp_codecs_packetization_set(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, struct ast_codec_pref *prefs)
00728 {
00729 codecs->pref = *prefs;
00730
00731 if (instance && instance->engine->packetization_set) {
00732 instance->engine->packetization_set(instance, &instance->codecs.pref);
00733 }
00734 }
00735
00736 int ast_rtp_instance_dtmf_begin(struct ast_rtp_instance *instance, char digit)
00737 {
00738 return instance->engine->dtmf_begin ? instance->engine->dtmf_begin(instance, digit) : -1;
00739 }
00740
00741 int ast_rtp_instance_dtmf_end(struct ast_rtp_instance *instance, char digit)
00742 {
00743 return instance->engine->dtmf_end ? instance->engine->dtmf_end(instance, digit) : -1;
00744 }
00745 int ast_rtp_instance_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration)
00746 {
00747 return instance->engine->dtmf_end_with_duration ? instance->engine->dtmf_end_with_duration(instance, digit, duration) : -1;
00748 }
00749
00750 int ast_rtp_instance_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
00751 {
00752 return (!instance->engine->dtmf_mode_set || instance->engine->dtmf_mode_set(instance, dtmf_mode)) ? -1 : 0;
00753 }
00754
00755 enum ast_rtp_dtmf_mode ast_rtp_instance_dtmf_mode_get(struct ast_rtp_instance *instance)
00756 {
00757 return instance->engine->dtmf_mode_get ? instance->engine->dtmf_mode_get(instance) : 0;
00758 }
00759
00760 void ast_rtp_instance_update_source(struct ast_rtp_instance *instance)
00761 {
00762 if (instance->engine->update_source) {
00763 instance->engine->update_source(instance);
00764 }
00765 }
00766
00767 void ast_rtp_instance_change_source(struct ast_rtp_instance *instance)
00768 {
00769 if (instance->engine->change_source) {
00770 instance->engine->change_source(instance);
00771 }
00772 }
00773
00774 int ast_rtp_instance_set_qos(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
00775 {
00776 return instance->engine->qos ? instance->engine->qos(instance, tos, cos, desc) : -1;
00777 }
00778
00779 void ast_rtp_instance_stop(struct ast_rtp_instance *instance)
00780 {
00781 if (instance->engine->stop) {
00782 instance->engine->stop(instance);
00783 }
00784 }
00785
00786 int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp)
00787 {
00788 return instance->engine->fd ? instance->engine->fd(instance, rtcp) : -1;
00789 }
00790
00791 struct ast_rtp_glue *ast_rtp_instance_get_glue(const char *type)
00792 {
00793 struct ast_rtp_glue *glue = NULL;
00794
00795 AST_RWLIST_RDLOCK(&glues);
00796
00797 AST_RWLIST_TRAVERSE(&glues, glue, entry) {
00798 if (!strcasecmp(glue->type, type)) {
00799 break;
00800 }
00801 }
00802
00803 AST_RWLIST_UNLOCK(&glues);
00804
00805 return glue;
00806 }
00807
00808 static enum ast_bridge_result local_bridge_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
00809 {
00810 enum ast_bridge_result res = AST_BRIDGE_FAILED;
00811 struct ast_channel *who = NULL, *other = NULL, *cs[3] = { NULL, };
00812 struct ast_frame *fr = NULL;
00813
00814
00815 if (instance0->engine->local_bridge && instance0->engine->local_bridge(instance0, instance1)) {
00816 ast_debug(1, "Failed to locally bridge %s to %s, backing out.\n", c0->name, c1->name);
00817 ast_channel_unlock(c0);
00818 ast_channel_unlock(c1);
00819 return AST_BRIDGE_FAILED_NOWARN;
00820 }
00821 if (instance1->engine->local_bridge && instance1->engine->local_bridge(instance1, instance0)) {
00822 ast_debug(1, "Failed to locally bridge %s to %s, backing out.\n", c1->name, c0->name);
00823 if (instance0->engine->local_bridge) {
00824 instance0->engine->local_bridge(instance0, NULL);
00825 }
00826 ast_channel_unlock(c0);
00827 ast_channel_unlock(c1);
00828 return AST_BRIDGE_FAILED_NOWARN;
00829 }
00830
00831 ast_channel_unlock(c0);
00832 ast_channel_unlock(c1);
00833
00834 instance0->bridged = instance1;
00835 instance1->bridged = instance0;
00836
00837 ast_poll_channel_add(c0, c1);
00838
00839
00840 cs[0] = c0;
00841 cs[1] = c1;
00842 cs[2] = NULL;
00843 for (;;) {
00844
00845 if ((c0->rawreadformat != c1->rawwriteformat) || (c1->rawreadformat != c0->rawwriteformat)) {
00846 ast_debug(1, "rtp-engine-local-bridge: Oooh, formats changed, backing out\n");
00847 res = AST_BRIDGE_FAILED_NOWARN;
00848 break;
00849 }
00850
00851 if ((c0->tech_pvt != pvt0) ||
00852 (c1->tech_pvt != pvt1) ||
00853 (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
00854 (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks) ||
00855 (!ast_framehook_list_is_empty(c0->framehooks) || !ast_framehook_list_is_empty(c1->framehooks))) {
00856 ast_debug(1, "rtp-engine-local-bridge: Oooh, something is weird, backing out\n");
00857
00858 if ((c0->masq || c0->masqr) && (fr = ast_read(c0))) {
00859 ast_frfree(fr);
00860 }
00861 if ((c1->masq || c1->masqr) && (fr = ast_read(c1))) {
00862 ast_frfree(fr);
00863 }
00864 res = AST_BRIDGE_RETRY;
00865 break;
00866 }
00867
00868 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
00869 if (!timeoutms) {
00870 res = AST_BRIDGE_RETRY;
00871 break;
00872 }
00873 ast_debug(2, "rtp-engine-local-bridge: Ooh, empty read...\n");
00874 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
00875 break;
00876 }
00877 continue;
00878 }
00879
00880 fr = ast_read(who);
00881 other = (who == c0) ? c1 : c0;
00882
00883 if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
00884 ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
00885 ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
00886
00887 *fo = fr;
00888 *rc = who;
00889 ast_debug(1, "rtp-engine-local-bridge: Ooh, got a %s\n", fr ? "digit" : "hangup");
00890 res = AST_BRIDGE_COMPLETE;
00891 break;
00892 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
00893 if ((fr->subclass.integer == AST_CONTROL_HOLD) ||
00894 (fr->subclass.integer == AST_CONTROL_UNHOLD) ||
00895 (fr->subclass.integer == AST_CONTROL_VIDUPDATE) ||
00896 (fr->subclass.integer == AST_CONTROL_SRCUPDATE) ||
00897 (fr->subclass.integer == AST_CONTROL_T38_PARAMETERS) ||
00898 (fr->subclass.integer == AST_CONTROL_UPDATE_RTP_PEER)) {
00899
00900 if (fr->subclass.integer == AST_CONTROL_HOLD) {
00901 if (instance0->engine->local_bridge) {
00902 instance0->engine->local_bridge(instance0, NULL);
00903 }
00904 if (instance1->engine->local_bridge) {
00905 instance1->engine->local_bridge(instance1, NULL);
00906 }
00907 instance0->bridged = NULL;
00908 instance1->bridged = NULL;
00909 } else if (fr->subclass.integer == AST_CONTROL_UNHOLD) {
00910 if (instance0->engine->local_bridge) {
00911 instance0->engine->local_bridge(instance0, instance1);
00912 }
00913 if (instance1->engine->local_bridge) {
00914 instance1->engine->local_bridge(instance1, instance0);
00915 }
00916 instance0->bridged = instance1;
00917 instance1->bridged = instance0;
00918 }
00919
00920 if (fr->subclass.integer != AST_CONTROL_UPDATE_RTP_PEER) {
00921 ast_indicate_data(other, fr->subclass.integer, fr->data.ptr, fr->datalen);
00922 }
00923 ast_frfree(fr);
00924 } else if (fr->subclass.integer == AST_CONTROL_CONNECTED_LINE) {
00925 if (ast_channel_connected_line_macro(who, other, fr, other == c0, 1)) {
00926 ast_indicate_data(other, fr->subclass.integer, fr->data.ptr, fr->datalen);
00927 }
00928 ast_frfree(fr);
00929 } else if (fr->subclass.integer == AST_CONTROL_REDIRECTING) {
00930 if (ast_channel_redirecting_macro(who, other, fr, other == c0, 1)) {
00931 ast_indicate_data(other, fr->subclass.integer, fr->data.ptr, fr->datalen);
00932 }
00933 ast_frfree(fr);
00934 } else {
00935 *fo = fr;
00936 *rc = who;
00937 ast_debug(1, "rtp-engine-local-bridge: Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass.integer, who->name);
00938 res = AST_BRIDGE_COMPLETE;
00939 break;
00940 }
00941 } else {
00942 if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
00943 (fr->frametype == AST_FRAME_DTMF_END) ||
00944 (fr->frametype == AST_FRAME_VOICE) ||
00945 (fr->frametype == AST_FRAME_VIDEO) ||
00946 (fr->frametype == AST_FRAME_IMAGE) ||
00947 (fr->frametype == AST_FRAME_HTML) ||
00948 (fr->frametype == AST_FRAME_MODEM) ||
00949 (fr->frametype == AST_FRAME_TEXT)) {
00950 ast_write(other, fr);
00951 }
00952
00953 ast_frfree(fr);
00954 }
00955
00956 cs[2] = cs[0];
00957 cs[0] = cs[1];
00958 cs[1] = cs[2];
00959 }
00960
00961
00962 if (instance0->engine->local_bridge) {
00963 instance0->engine->local_bridge(instance0, NULL);
00964 }
00965 if (instance1->engine->local_bridge) {
00966 instance1->engine->local_bridge(instance1, NULL);
00967 }
00968
00969 instance0->bridged = NULL;
00970 instance1->bridged = NULL;
00971
00972 ast_poll_channel_del(c0, c1);
00973
00974 return res;
00975 }
00976
00977 static enum ast_bridge_result remote_bridge_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1,
00978 struct ast_rtp_instance *vinstance0, struct ast_rtp_instance *vinstance1, struct ast_rtp_instance *tinstance0,
00979 struct ast_rtp_instance *tinstance1, struct ast_rtp_glue *glue0, struct ast_rtp_glue *glue1, format_t codec0, format_t codec1, int timeoutms,
00980 int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
00981 {
00982 enum ast_bridge_result res = AST_BRIDGE_FAILED;
00983 struct ast_channel *who = NULL, *other = NULL, *cs[3] = { NULL, };
00984 format_t oldcodec0 = codec0, oldcodec1 = codec1;
00985 struct ast_sockaddr ac1 = {{0,}}, vac1 = {{0,}}, tac1 = {{0,}}, ac0 = {{0,}}, vac0 = {{0,}}, tac0 = {{0,}};
00986 struct ast_sockaddr t1 = {{0,}}, vt1 = {{0,}}, tt1 = {{0,}}, t0 = {{0,}}, vt0 = {{0,}}, tt0 = {{0,}};
00987 struct ast_frame *fr = NULL;
00988
00989
00990 if (!(glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0))) {
00991 ast_rtp_instance_get_remote_address(instance1, &ac1);
00992 if (vinstance1) {
00993 ast_rtp_instance_get_remote_address(vinstance1, &vac1);
00994 }
00995 if (tinstance1) {
00996 ast_rtp_instance_get_remote_address(tinstance1, &tac1);
00997 }
00998 } else {
00999 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
01000 }
01001
01002
01003 if (!(glue1->update_peer(c1, instance0, vinstance0, tinstance0, codec0, 0))) {
01004 ast_rtp_instance_get_remote_address(instance0, &ac0);
01005 if (vinstance0) {
01006 ast_rtp_instance_get_remote_address(instance0, &vac0);
01007 }
01008 if (tinstance0) {
01009 ast_rtp_instance_get_remote_address(instance0, &tac0);
01010 }
01011 } else {
01012 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
01013 }
01014
01015 ast_channel_unlock(c0);
01016 ast_channel_unlock(c1);
01017
01018 instance0->bridged = instance1;
01019 instance1->bridged = instance0;
01020
01021 ast_poll_channel_add(c0, c1);
01022
01023
01024 cs[0] = c0;
01025 cs[1] = c1;
01026 cs[2] = NULL;
01027 for (;;) {
01028
01029 if ((c0->tech_pvt != pvt0) ||
01030 (c1->tech_pvt != pvt1) ||
01031 (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
01032 (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks) ||
01033 (!ast_framehook_list_is_empty(c0->framehooks) || !ast_framehook_list_is_empty(c1->framehooks))) {
01034 ast_debug(1, "Oooh, something is weird, backing out\n");
01035 res = AST_BRIDGE_RETRY;
01036 break;
01037 }
01038
01039
01040 ast_rtp_instance_get_remote_address(instance1, &t1);
01041 if (vinstance1) {
01042 ast_rtp_instance_get_remote_address(vinstance1, &vt1);
01043 }
01044 if (tinstance1) {
01045 ast_rtp_instance_get_remote_address(tinstance1, &tt1);
01046 }
01047 if (glue1->get_codec) {
01048 codec1 = glue1->get_codec(c1);
01049 }
01050
01051 ast_rtp_instance_get_remote_address(instance0, &t0);
01052 if (vinstance0) {
01053 ast_rtp_instance_get_remote_address(vinstance0, &vt0);
01054 }
01055 if (tinstance0) {
01056 ast_rtp_instance_get_remote_address(tinstance0, &tt0);
01057 }
01058 if (glue0->get_codec) {
01059 codec0 = glue0->get_codec(c0);
01060 }
01061
01062 if ((ast_sockaddr_cmp(&t1, &ac1)) ||
01063 (vinstance1 && ast_sockaddr_cmp(&vt1, &vac1)) ||
01064 (tinstance1 && ast_sockaddr_cmp(&tt1, &tac1)) ||
01065 (codec1 != oldcodec1)) {
01066 ast_debug(1, "Oooh, '%s' changed end address to %s (format %s)\n",
01067 c1->name, ast_sockaddr_stringify(&t1),
01068 ast_getformatname(codec1));
01069 ast_debug(1, "Oooh, '%s' changed end vaddress to %s (format %s)\n",
01070 c1->name, ast_sockaddr_stringify(&vt1),
01071 ast_getformatname(codec1));
01072 ast_debug(1, "Oooh, '%s' changed end taddress to %s (format %s)\n",
01073 c1->name, ast_sockaddr_stringify(&tt1),
01074 ast_getformatname(codec1));
01075 ast_debug(1, "Oooh, '%s' was %s/(format %s)\n",
01076 c1->name, ast_sockaddr_stringify(&ac1),
01077 ast_getformatname(oldcodec1));
01078 ast_debug(1, "Oooh, '%s' was %s/(format %s)\n",
01079 c1->name, ast_sockaddr_stringify(&vac1),
01080 ast_getformatname(oldcodec1));
01081 ast_debug(1, "Oooh, '%s' was %s/(format %s)\n",
01082 c1->name, ast_sockaddr_stringify(&tac1),
01083 ast_getformatname(oldcodec1));
01084 if (glue0->update_peer(c0,
01085 ast_sockaddr_isnull(&t1) ? NULL : instance1,
01086 ast_sockaddr_isnull(&vt1) ? NULL : vinstance1,
01087 ast_sockaddr_isnull(&tt1) ? NULL : tinstance1,
01088 codec1, 0)) {
01089 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
01090 }
01091 ast_sockaddr_copy(&ac1, &t1);
01092 ast_sockaddr_copy(&vac1, &vt1);
01093 ast_sockaddr_copy(&tac1, &tt1);
01094 oldcodec1 = codec1;
01095 }
01096 if ((ast_sockaddr_cmp(&t0, &ac0)) ||
01097 (vinstance0 && ast_sockaddr_cmp(&vt0, &vac0)) ||
01098 (tinstance0 && ast_sockaddr_cmp(&tt0, &tac0)) ||
01099 (codec0 != oldcodec0)) {
01100 ast_debug(1, "Oooh, '%s' changed end address to %s (format %s)\n",
01101 c0->name, ast_sockaddr_stringify(&t0),
01102 ast_getformatname(codec0));
01103 ast_debug(1, "Oooh, '%s' was %s/(format %s)\n",
01104 c0->name, ast_sockaddr_stringify(&ac0),
01105 ast_getformatname(oldcodec0));
01106 if (glue1->update_peer(c1, t0.len ? instance0 : NULL,
01107 vt0.len ? vinstance0 : NULL,
01108 tt0.len ? tinstance0 : NULL,
01109 codec0, 0)) {
01110 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
01111 }
01112 ast_sockaddr_copy(&ac0, &t0);
01113 ast_sockaddr_copy(&vac0, &vt0);
01114 ast_sockaddr_copy(&tac0, &tt0);
01115 oldcodec0 = codec0;
01116 }
01117
01118
01119 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
01120 if (!timeoutms) {
01121 res = AST_BRIDGE_RETRY;
01122 break;
01123 }
01124 ast_debug(1, "Ooh, empty read...\n");
01125 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
01126 break;
01127 }
01128 continue;
01129 }
01130 fr = ast_read(who);
01131 other = (who == c0) ? c1 : c0;
01132 if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
01133 (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
01134 ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
01135
01136 *fo = fr;
01137 *rc = who;
01138 ast_debug(1, "Oooh, got a %s\n", fr ? "digit" : "hangup");
01139 res = AST_BRIDGE_COMPLETE;
01140 break;
01141 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
01142 if ((fr->subclass.integer == AST_CONTROL_HOLD) ||
01143 (fr->subclass.integer == AST_CONTROL_UNHOLD) ||
01144 (fr->subclass.integer == AST_CONTROL_VIDUPDATE) ||
01145 (fr->subclass.integer == AST_CONTROL_SRCUPDATE) ||
01146 (fr->subclass.integer == AST_CONTROL_T38_PARAMETERS) ||
01147 (fr->subclass.integer == AST_CONTROL_UPDATE_RTP_PEER)) {
01148 if (fr->subclass.integer == AST_CONTROL_HOLD) {
01149
01150 if (who == c0) {
01151 glue1->update_peer(c1, NULL, NULL, NULL, 0, 0);
01152 } else {
01153 glue0->update_peer(c0, NULL, NULL, NULL, 0, 0);
01154 }
01155 } else if (fr->subclass.integer == AST_CONTROL_UNHOLD ||
01156 fr->subclass.integer == AST_CONTROL_UPDATE_RTP_PEER) {
01157
01158
01159 if (who == c0) {
01160 glue1->update_peer(c1, instance0, vinstance0, tinstance0, codec0, 0);
01161 } else {
01162 glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0);
01163 }
01164 }
01165
01166 ast_rtp_instance_get_remote_address(instance0, &t0);
01167 ast_sockaddr_copy(&ac0, &t0);
01168 ast_rtp_instance_get_remote_address(instance1, &t1);
01169 ast_sockaddr_copy(&ac1, &t1);
01170
01171 if (glue0->get_codec && c0->tech_pvt) {
01172 oldcodec0 = codec0 = glue0->get_codec(c0);
01173 }
01174 if (glue1->get_codec && c1->tech_pvt) {
01175 oldcodec1 = codec1 = glue1->get_codec(c1);
01176 }
01177
01178 if (fr->subclass.integer != AST_CONTROL_UPDATE_RTP_PEER) {
01179 ast_indicate_data(other, fr->subclass.integer, fr->data.ptr, fr->datalen);
01180 }
01181 ast_frfree(fr);
01182 } else if (fr->subclass.integer == AST_CONTROL_CONNECTED_LINE) {
01183 if (ast_channel_connected_line_macro(who, other, fr, other == c0, 1)) {
01184 ast_indicate_data(other, fr->subclass.integer, fr->data.ptr, fr->datalen);
01185 }
01186 ast_frfree(fr);
01187 } else if (fr->subclass.integer == AST_CONTROL_REDIRECTING) {
01188 if (ast_channel_redirecting_macro(who, other, fr, other == c0, 1)) {
01189 ast_indicate_data(other, fr->subclass.integer, fr->data.ptr, fr->datalen);
01190 }
01191 ast_frfree(fr);
01192 } else {
01193 *fo = fr;
01194 *rc = who;
01195 ast_debug(1, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass.integer, who->name);
01196 return AST_BRIDGE_COMPLETE;
01197 }
01198 } else {
01199 if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
01200 (fr->frametype == AST_FRAME_DTMF_END) ||
01201 (fr->frametype == AST_FRAME_VOICE) ||
01202 (fr->frametype == AST_FRAME_VIDEO) ||
01203 (fr->frametype == AST_FRAME_IMAGE) ||
01204 (fr->frametype == AST_FRAME_HTML) ||
01205 (fr->frametype == AST_FRAME_MODEM) ||
01206 (fr->frametype == AST_FRAME_TEXT)) {
01207 ast_write(other, fr);
01208 }
01209 ast_frfree(fr);
01210 }
01211
01212 cs[2] = cs[0];
01213 cs[0] = cs[1];
01214 cs[1] = cs[2];
01215 }
01216
01217 if (ast_test_flag(c0, AST_FLAG_ZOMBIE)) {
01218 ast_debug(1, "Channel '%s' Zombie cleardown from bridge\n", c0->name);
01219 } else if (c0->tech_pvt != pvt0) {
01220 ast_debug(1, "Channel c0->'%s' pvt changed, in bridge with c1->'%s'\n", c0->name, c1->name);
01221 } else if (glue0 != ast_rtp_instance_get_glue(c0->tech->type)) {
01222 ast_debug(1, "Channel c0->'%s' technology changed, in bridge with c1->'%s'\n", c0->name, c1->name);
01223 } else if (glue0->update_peer(c0, NULL, NULL, NULL, 0, 0)) {
01224 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
01225 }
01226 if (ast_test_flag(c1, AST_FLAG_ZOMBIE)) {
01227 ast_debug(1, "Channel '%s' Zombie cleardown from bridge\n", c1->name);
01228 } else if (c1->tech_pvt != pvt1) {
01229 ast_debug(1, "Channel c1->'%s' pvt changed, in bridge with c0->'%s'\n", c1->name, c0->name);
01230 } else if (glue1 != ast_rtp_instance_get_glue(c1->tech->type)) {
01231 ast_debug(1, "Channel c1->'%s' technology changed, in bridge with c0->'%s'\n", c1->name, c0->name);
01232 } else if (glue1->update_peer(c1, NULL, NULL, NULL, 0, 0)) {
01233 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
01234 }
01235
01236 instance0->bridged = NULL;
01237 instance1->bridged = NULL;
01238
01239 ast_poll_channel_del(c0, c1);
01240
01241 return res;
01242 }
01243
01244
01245
01246
01247 static void unref_instance_cond(struct ast_rtp_instance **instance)
01248 {
01249 if (*instance) {
01250 ao2_ref(*instance, -1);
01251 *instance = NULL;
01252 }
01253 }
01254
01255 enum ast_bridge_result ast_rtp_instance_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
01256 {
01257 struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
01258 *vinstance0 = NULL, *vinstance1 = NULL,
01259 *tinstance0 = NULL, *tinstance1 = NULL;
01260 struct ast_rtp_glue *glue0, *glue1;
01261 struct ast_sockaddr addr1 = { {0, }, }, addr2 = { {0, }, };
01262 enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
01263 enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
01264 enum ast_bridge_result res = AST_BRIDGE_FAILED;
01265 enum ast_rtp_dtmf_mode dmode;
01266 format_t codec0 = 0, codec1 = 0;
01267 int unlock_chans = 1;
01268
01269
01270 ast_channel_lock(c0);
01271 while (ast_channel_trylock(c1)) {
01272 ast_channel_unlock(c0);
01273 usleep(1);
01274 ast_channel_lock(c0);
01275 }
01276
01277
01278 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
01279 ast_log(LOG_WARNING, "Got hangup while attempting to bridge '%s' and '%s'\n", c0->name, c1->name);
01280 goto done;
01281 }
01282
01283
01284 if (!(glue0 = ast_rtp_instance_get_glue(c0->tech->type)) || !(glue1 = ast_rtp_instance_get_glue(c1->tech->type))) {
01285 ast_debug(1, "Can't find native functions for channel '%s'\n", glue0 ? c1->name : c0->name);
01286 goto done;
01287 }
01288
01289 audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
01290 video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
01291
01292 audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
01293 video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
01294
01295
01296 if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
01297 audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
01298 }
01299 if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
01300 audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
01301 }
01302
01303
01304 if (audio_glue0_res == AST_RTP_GLUE_RESULT_FORBID || audio_glue1_res == AST_RTP_GLUE_RESULT_FORBID) {
01305 res = AST_BRIDGE_FAILED_NOWARN;
01306 goto done;
01307 }
01308
01309
01310
01311 ast_rtp_instance_get_remote_address(instance0, &addr1);
01312 ast_rtp_instance_get_remote_address(instance1, &addr2);
01313
01314 if (addr1.ss.ss_family != addr2.ss.ss_family ||
01315 (ast_sockaddr_is_ipv4_mapped(&addr1) != ast_sockaddr_is_ipv4_mapped(&addr2))) {
01316 audio_glue0_res = AST_RTP_GLUE_RESULT_LOCAL;
01317 audio_glue1_res = AST_RTP_GLUE_RESULT_LOCAL;
01318 }
01319
01320
01321 dmode = ast_rtp_instance_dtmf_mode_get(instance0);
01322 if ((flags & AST_BRIDGE_DTMF_CHANNEL_0) && dmode) {
01323 res = AST_BRIDGE_FAILED_NOWARN;
01324 goto done;
01325 }
01326 dmode = ast_rtp_instance_dtmf_mode_get(instance1);
01327 if ((flags & AST_BRIDGE_DTMF_CHANNEL_1) && dmode) {
01328 res = AST_BRIDGE_FAILED_NOWARN;
01329 goto done;
01330 }
01331
01332
01333 if ((audio_glue0_res == AST_RTP_GLUE_RESULT_LOCAL || audio_glue1_res == AST_RTP_GLUE_RESULT_LOCAL) && ((instance0->engine->local_bridge != instance1->engine->local_bridge) || (instance0->engine->dtmf_compatible && !instance0->engine->dtmf_compatible(c0, instance0, c1, instance1)))) {
01334 res = AST_BRIDGE_FAILED_NOWARN;
01335 goto done;
01336 }
01337
01338
01339 codec0 = glue0->get_codec ? glue0->get_codec(c0) : 0;
01340 codec1 = glue1->get_codec ? glue1->get_codec(c1) : 0;
01341 if (codec0 && codec1 && !(codec0 & codec1)) {
01342 ast_debug(1, "Channel codec0 = %s is not codec1 = %s, cannot native bridge in RTP.\n", ast_getformatname(codec0), ast_getformatname(codec1));
01343 res = AST_BRIDGE_FAILED_NOWARN;
01344 goto done;
01345 }
01346
01347 instance0->glue = glue0;
01348 instance1->glue = glue1;
01349 instance0->chan = c0;
01350 instance1->chan = c1;
01351
01352
01353 if (audio_glue0_res == AST_RTP_GLUE_RESULT_LOCAL || audio_glue1_res == AST_RTP_GLUE_RESULT_LOCAL) {
01354 ast_verb(3, "Locally bridging %s and %s\n", c0->name, c1->name);
01355 res = local_bridge_loop(c0, c1, instance0, instance1, timeoutms, flags, fo, rc, c0->tech_pvt, c1->tech_pvt);
01356 } else {
01357 ast_verb(3, "Remotely bridging %s and %s\n", c0->name, c1->name);
01358 res = remote_bridge_loop(c0, c1, instance0, instance1, vinstance0, vinstance1,
01359 tinstance0, tinstance1, glue0, glue1, codec0, codec1, timeoutms, flags,
01360 fo, rc, c0->tech_pvt, c1->tech_pvt);
01361 }
01362
01363 instance0->glue = NULL;
01364 instance1->glue = NULL;
01365 instance0->chan = NULL;
01366 instance1->chan = NULL;
01367
01368 unlock_chans = 0;
01369
01370 done:
01371 if (unlock_chans) {
01372 ast_channel_unlock(c0);
01373 ast_channel_unlock(c1);
01374 }
01375
01376 unref_instance_cond(&instance0);
01377 unref_instance_cond(&instance1);
01378 unref_instance_cond(&vinstance0);
01379 unref_instance_cond(&vinstance1);
01380 unref_instance_cond(&tinstance0);
01381 unref_instance_cond(&tinstance1);
01382
01383 return res;
01384 }
01385
01386 struct ast_rtp_instance *ast_rtp_instance_get_bridged(struct ast_rtp_instance *instance)
01387 {
01388 return instance->bridged;
01389 }
01390
01391 void ast_rtp_instance_early_bridge_make_compatible(struct ast_channel *c0, struct ast_channel *c1)
01392 {
01393 struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
01394 *vinstance0 = NULL, *vinstance1 = NULL,
01395 *tinstance0 = NULL, *tinstance1 = NULL;
01396 struct ast_rtp_glue *glue0, *glue1;
01397 enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
01398 enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
01399 format_t codec0 = 0, codec1 = 0;
01400 int res = 0;
01401
01402
01403 ast_channel_lock(c0);
01404 while (ast_channel_trylock(c1)) {
01405 ast_channel_unlock(c0);
01406 usleep(1);
01407 ast_channel_lock(c0);
01408 }
01409
01410
01411 if (!(glue0 = ast_rtp_instance_get_glue(c0->tech->type)) || !(glue1 = ast_rtp_instance_get_glue(c1->tech->type))) {
01412 ast_debug(1, "Can't find native functions for channel '%s'\n", glue0 ? c1->name : c0->name);
01413 goto done;
01414 }
01415
01416 audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
01417 video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
01418
01419 audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
01420 video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
01421
01422
01423 if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
01424 audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
01425 }
01426 if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
01427 audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
01428 }
01429 if (audio_glue0_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue0_res == AST_RTP_GLUE_RESULT_FORBID || video_glue0_res == AST_RTP_GLUE_RESULT_REMOTE) && glue0->get_codec) {
01430 codec0 = glue0->get_codec(c0);
01431 }
01432 if (audio_glue1_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue1_res == AST_RTP_GLUE_RESULT_FORBID || video_glue1_res == AST_RTP_GLUE_RESULT_REMOTE) && glue1->get_codec) {
01433 codec1 = glue1->get_codec(c1);
01434 }
01435
01436
01437 if (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE) {
01438 goto done;
01439 }
01440
01441
01442 if (!(codec0 & codec1)) {
01443 goto done;
01444 }
01445
01446 ast_rtp_codecs_payloads_copy(&instance0->codecs, &instance1->codecs, instance1);
01447
01448 if (vinstance0 && vinstance1) {
01449 ast_rtp_codecs_payloads_copy(&vinstance0->codecs, &vinstance1->codecs, vinstance1);
01450 }
01451 if (tinstance0 && tinstance1) {
01452 ast_rtp_codecs_payloads_copy(&tinstance0->codecs, &tinstance1->codecs, tinstance1);
01453 }
01454
01455 if (glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0)) {
01456 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
01457 }
01458
01459 res = 0;
01460
01461 done:
01462 ast_channel_unlock(c0);
01463 ast_channel_unlock(c1);
01464
01465 unref_instance_cond(&instance0);
01466 unref_instance_cond(&instance1);
01467 unref_instance_cond(&vinstance0);
01468 unref_instance_cond(&vinstance1);
01469 unref_instance_cond(&tinstance0);
01470 unref_instance_cond(&tinstance1);
01471
01472 if (!res) {
01473 ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
01474 }
01475 }
01476
01477 int ast_rtp_instance_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
01478 {
01479 struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
01480 *vinstance0 = NULL, *vinstance1 = NULL,
01481 *tinstance0 = NULL, *tinstance1 = NULL;
01482 struct ast_rtp_glue *glue0, *glue1;
01483 enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
01484 enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
01485 format_t codec0 = 0, codec1 = 0;
01486 int res = 0;
01487
01488
01489 if (!c1) {
01490 return -1;
01491 }
01492
01493
01494 ast_channel_lock(c0);
01495 while (ast_channel_trylock(c1)) {
01496 ast_channel_unlock(c0);
01497 usleep(1);
01498 ast_channel_lock(c0);
01499 }
01500
01501
01502 if (!(glue0 = ast_rtp_instance_get_glue(c0->tech->type)) || !(glue1 = ast_rtp_instance_get_glue(c1->tech->type))) {
01503 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", glue0 ? c1->name : c0->name);
01504 goto done;
01505 }
01506
01507 audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
01508 video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
01509
01510 audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
01511 video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
01512
01513
01514 if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
01515 audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
01516 }
01517 if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
01518 audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
01519 }
01520 if (audio_glue0_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue0_res == AST_RTP_GLUE_RESULT_FORBID || video_glue0_res == AST_RTP_GLUE_RESULT_REMOTE) && glue0->get_codec(c0)) {
01521 codec0 = glue0->get_codec(c0);
01522 }
01523 if (audio_glue1_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue1_res == AST_RTP_GLUE_RESULT_FORBID || video_glue1_res == AST_RTP_GLUE_RESULT_REMOTE) && glue1->get_codec(c1)) {
01524 codec1 = glue1->get_codec(c1);
01525 }
01526
01527
01528 if (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE) {
01529 goto done;
01530 }
01531
01532
01533 if (!(codec0 & codec1)) {
01534 goto done;
01535 }
01536
01537
01538 if (glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0)) {
01539 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
01540 }
01541
01542 res = 0;
01543
01544 done:
01545 ast_channel_unlock(c0);
01546 ast_channel_unlock(c1);
01547
01548 unref_instance_cond(&instance0);
01549 unref_instance_cond(&instance1);
01550 unref_instance_cond(&vinstance0);
01551 unref_instance_cond(&vinstance1);
01552 unref_instance_cond(&tinstance0);
01553 unref_instance_cond(&tinstance1);
01554
01555 if (!res) {
01556 ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
01557 }
01558
01559 return res;
01560 }
01561
01562 int ast_rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
01563 {
01564 return instance->engine->red_init ? instance->engine->red_init(instance, buffer_time, payloads, generations) : -1;
01565 }
01566
01567 int ast_rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
01568 {
01569 return instance->engine->red_buffer ? instance->engine->red_buffer(instance, frame) : -1;
01570 }
01571
01572 int ast_rtp_instance_get_stats(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
01573 {
01574 return instance->engine->get_stat ? instance->engine->get_stat(instance, stats, stat) : -1;
01575 }
01576
01577 char *ast_rtp_instance_get_quality(struct ast_rtp_instance *instance, enum ast_rtp_instance_stat_field field, char *buf, size_t size)
01578 {
01579 struct ast_rtp_instance_stats stats = { 0, };
01580 enum ast_rtp_instance_stat stat;
01581
01582
01583 if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY) {
01584 stat = AST_RTP_INSTANCE_STAT_ALL;
01585 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
01586 stat = AST_RTP_INSTANCE_STAT_COMBINED_JITTER;
01587 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
01588 stat = AST_RTP_INSTANCE_STAT_COMBINED_LOSS;
01589 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
01590 stat = AST_RTP_INSTANCE_STAT_COMBINED_RTT;
01591 } else {
01592 return NULL;
01593 }
01594
01595
01596 if (ast_rtp_instance_get_stats(instance, &stats, stat)) {
01597 return NULL;
01598 }
01599
01600
01601 if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY) {
01602 snprintf(buf, size, "ssrc=%i;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f",
01603 stats.local_ssrc, stats.remote_ssrc, stats.rxploss, stats.txjitter, stats.rxcount, stats.rxjitter, stats.txcount, stats.txploss, stats.rtt);
01604 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
01605 snprintf(buf, size, "minrxjitter=%f;maxrxjitter=%f;avgrxjitter=%f;stdevrxjitter=%f;reported_minjitter=%f;reported_maxjitter=%f;reported_avgjitter=%f;reported_stdevjitter=%f;",
01606 stats.local_minjitter, stats.local_maxjitter, stats.local_normdevjitter, sqrt(stats.local_stdevjitter), stats.remote_minjitter, stats.remote_maxjitter, stats.remote_normdevjitter, sqrt(stats.remote_stdevjitter));
01607 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
01608 snprintf(buf, size, "minrxlost=%f;maxrxlost=%f;avgrxlost=%f;stdevrxlost=%f;reported_minlost=%f;reported_maxlost=%f;reported_avglost=%f;reported_stdevlost=%f;",
01609 stats.local_minrxploss, stats.local_maxrxploss, stats.local_normdevrxploss, sqrt(stats.local_stdevrxploss), stats.remote_minrxploss, stats.remote_maxrxploss, stats.remote_normdevrxploss, sqrt(stats.remote_stdevrxploss));
01610 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
01611 snprintf(buf, size, "minrtt=%f;maxrtt=%f;avgrtt=%f;stdevrtt=%f;", stats.minrtt, stats.maxrtt, stats.normdevrtt, stats.stdevrtt);
01612 }
01613
01614 return buf;
01615 }
01616
01617 void ast_rtp_instance_set_stats_vars(struct ast_channel *chan, struct ast_rtp_instance *instance)
01618 {
01619 char quality_buf[AST_MAX_USER_FIELD], *quality;
01620 struct ast_channel *bridge = ast_bridged_channel(chan);
01621
01622 if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
01623 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOS", quality);
01624 if (bridge) {
01625 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSBRIDGED", quality);
01626 }
01627 }
01628
01629 if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER, quality_buf, sizeof(quality_buf)))) {
01630 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSJITTER", quality);
01631 if (bridge) {
01632 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSJITTERBRIDGED", quality);
01633 }
01634 }
01635
01636 if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS, quality_buf, sizeof(quality_buf)))) {
01637 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSLOSS", quality);
01638 if (bridge) {
01639 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSLOSSBRIDGED", quality);
01640 }
01641 }
01642
01643 if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT, quality_buf, sizeof(quality_buf)))) {
01644 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSRTT", quality);
01645 if (bridge) {
01646 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSRTTBRIDGED", quality);
01647 }
01648 }
01649 }
01650
01651 int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, format_t format)
01652 {
01653 return instance->engine->set_read_format ? instance->engine->set_read_format(instance, format) : -1;
01654 }
01655
01656 int ast_rtp_instance_set_write_format(struct ast_rtp_instance *instance, format_t format)
01657 {
01658 return instance->engine->set_write_format ? instance->engine->set_write_format(instance, format) : -1;
01659 }
01660
01661 int ast_rtp_instance_make_compatible(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_channel *peer)
01662 {
01663 struct ast_rtp_glue *glue;
01664 struct ast_rtp_instance *peer_instance = NULL;
01665 int res = -1;
01666
01667 if (!instance->engine->make_compatible) {
01668 return -1;
01669 }
01670
01671 ast_channel_lock(peer);
01672
01673 if (!(glue = ast_rtp_instance_get_glue(peer->tech->type))) {
01674 ast_channel_unlock(peer);
01675 return -1;
01676 }
01677
01678 glue->get_rtp_info(peer, &peer_instance);
01679
01680 if (!peer_instance || peer_instance->engine != instance->engine) {
01681 ast_channel_unlock(peer);
01682 ao2_ref(peer_instance, -1);
01683 peer_instance = NULL;
01684 return -1;
01685 }
01686
01687 res = instance->engine->make_compatible(chan, instance, peer, peer_instance);
01688
01689 ast_channel_unlock(peer);
01690
01691 ao2_ref(peer_instance, -1);
01692 peer_instance = NULL;
01693
01694 return res;
01695 }
01696
01697 format_t ast_rtp_instance_available_formats(struct ast_rtp_instance *instance, format_t to_endpoint, format_t to_asterisk)
01698 {
01699 format_t formats;
01700
01701 if (instance->engine->available_formats && (formats = instance->engine->available_formats(instance, to_endpoint, to_asterisk))) {
01702 return formats;
01703 }
01704
01705 return ast_translate_available_formats(to_endpoint, to_asterisk);
01706 }
01707
01708 int ast_rtp_instance_activate(struct ast_rtp_instance *instance)
01709 {
01710 return instance->engine->activate ? instance->engine->activate(instance) : 0;
01711 }
01712
01713 void ast_rtp_instance_stun_request(struct ast_rtp_instance *instance,
01714 struct ast_sockaddr *suggestion,
01715 const char *username)
01716 {
01717 if (instance->engine->stun_request) {
01718 instance->engine->stun_request(instance, suggestion, username);
01719 }
01720 }
01721
01722 void ast_rtp_instance_set_timeout(struct ast_rtp_instance *instance, int timeout)
01723 {
01724 instance->timeout = timeout;
01725 }
01726
01727 void ast_rtp_instance_set_hold_timeout(struct ast_rtp_instance *instance, int timeout)
01728 {
01729 instance->holdtimeout = timeout;
01730 }
01731
01732 void ast_rtp_instance_set_keepalive(struct ast_rtp_instance *instance, int interval)
01733 {
01734 instance->keepalive = interval;
01735 }
01736
01737 int ast_rtp_instance_get_timeout(struct ast_rtp_instance *instance)
01738 {
01739 return instance->timeout;
01740 }
01741
01742 int ast_rtp_instance_get_hold_timeout(struct ast_rtp_instance *instance)
01743 {
01744 return instance->holdtimeout;
01745 }
01746
01747 int ast_rtp_instance_get_keepalive(struct ast_rtp_instance *instance)
01748 {
01749 return instance->keepalive;
01750 }
01751
01752 struct ast_rtp_engine *ast_rtp_instance_get_engine(struct ast_rtp_instance *instance)
01753 {
01754 return instance->engine;
01755 }
01756
01757 struct ast_rtp_glue *ast_rtp_instance_get_active_glue(struct ast_rtp_instance *instance)
01758 {
01759 return instance->glue;
01760 }
01761
01762 struct ast_channel *ast_rtp_instance_get_chan(struct ast_rtp_instance *instance)
01763 {
01764 return instance->chan;
01765 }
01766
01767 int ast_rtp_engine_register_srtp(struct ast_srtp_res *srtp_res, struct ast_srtp_policy_res *policy_res)
01768 {
01769 if (res_srtp || res_srtp_policy) {
01770 return -1;
01771 }
01772 if (!srtp_res || !policy_res) {
01773 return -1;
01774 }
01775
01776 res_srtp = srtp_res;
01777 res_srtp_policy = policy_res;
01778
01779 return 0;
01780 }
01781
01782 void ast_rtp_engine_unregister_srtp(void)
01783 {
01784 res_srtp = NULL;
01785 res_srtp_policy = NULL;
01786 }
01787
01788 int ast_rtp_engine_srtp_is_registered(void)
01789 {
01790 return res_srtp && res_srtp_policy;
01791 }
01792
01793 int ast_rtp_instance_add_srtp_policy(struct ast_rtp_instance *instance, struct ast_srtp_policy *remote_policy, struct ast_srtp_policy *local_policy)
01794 {
01795 int res = 0;
01796
01797 if (!res_srtp) {
01798 return -1;
01799 }
01800
01801 if (!instance->srtp) {
01802 res = res_srtp->create(&instance->srtp, instance, remote_policy);
01803 } else {
01804 res = res_srtp->replace(&instance->srtp, instance, remote_policy);
01805 }
01806 if (!res) {
01807 res = res_srtp->add_stream(instance->srtp, local_policy);
01808 }
01809
01810 return res;
01811 }
01812
01813 struct ast_srtp *ast_rtp_instance_get_srtp(struct ast_rtp_instance *instance)
01814 {
01815 return instance->srtp;
01816 }
01817
01818 int ast_rtp_instance_sendcng(struct ast_rtp_instance *instance, int level)
01819 {
01820 if (instance->engine->sendcng) {
01821 return instance->engine->sendcng(instance, level);
01822 }
01823
01824 return -1;
01825 }