Asterisk
/
asterisk
mirror of https://github.com/asterisk/asterisk
1
0
Fork 0
Code Issues Releases Wiki Activity

chan_pjsip: Update media translation paths when new SDP negotiated.

Browse Source 
On a SIP reinvite that changes media strams, the PJSIP channel driver was
flooding the log with "Asked to transmit frame type %s, while native
formats is %s" warnings.

* Fixes PJSIP not setting up translation paths when the formats change on
a reinvite.  AFS-63 was effectively reintroduced because of the media
formats work.  res_pjsip_sdp_rtp.c:set_caps()

* Improved the unexpected frame format WARNING message to include more
information.

* Added protective locking while altering formats on a channel.  Reworked
set_format() to simplify and protect the formats under manipulation.

* Restored some code that got lost in the media_formats work.
(channel.c:set_format() and res_pjsip_sdp_rtp.c:set_caps())

AFS-137 #close
Reported by: Mark Michelson

Review: https://reviewboard.asterisk.org/r/3906/
........

Merged revisions 421645 from http://svn.asterisk.org/svn/asterisk/branches/13


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@421646 65c4cc65-6c06-0410-ace0-fbb531ad65f3
changes/42/42/1
Richard Mudgett 11 years ago
parent 4672c139dd
commit b7f98c3da4
6 changed files with 109 additions and 76 deletions
Show Stats Download Patch File Download Diff File

14
channels/chan_pjsip.c
Unescape View File

@ -58,6 +58,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/stasis_channels.h" #include "asterisk/stasis_channels.h"
#include "asterisk/indications.h" #include "asterisk/indications.h"
#include "asterisk/format_cache.h" #include "asterisk/format_cache.h"
#include "asterisk/translate.h"
#include "asterisk/threadstorage.h" #include "asterisk/threadstorage.h"
#include "asterisk/features_config.h" #include "asterisk/features_config.h"
#include "asterisk/pickup.h" #include "asterisk/pickup.h"
@ -654,14 +655,21 @@ static int chan_pjsip_write(struct ast_channel *ast, struct ast_frame *frame)
return 0; return 0;
} }
if (ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), frame->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL) { if (ast_format_cap_iscompatible_format(ast_channel_nativeformats(ast), frame->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL) {
struct ast_str *cap_buf = ast_str_alloca(64); struct ast_str *cap_buf = ast_str_alloca(128);
struct ast_str *write_transpath = ast_str_alloca(256);
struct ast_str *read_transpath = ast_str_alloca(256);
ast_log(LOG_WARNING, ast_log(LOG_WARNING,
"Asked to transmit frame type %s, while native formats is %s (read/write = %s/%s)\n", "Channel %s asked to send %s frame when native formats are %s (rd:%s->%s;%s wr:%s->%s;%s)\n",
ast_channel_name(ast),
ast_format_get_name(frame->subclass.format), ast_format_get_name(frame->subclass.format),
ast_format_cap_get_names(ast_channel_nativeformats(ast), &cap_buf), ast_format_cap_get_names(ast_channel_nativeformats(ast), &cap_buf),
ast_format_get_name(ast_channel_rawreadformat(ast)),
ast_format_get_name(ast_channel_readformat(ast)), ast_format_get_name(ast_channel_readformat(ast)),
ast_format_get_name(ast_channel_writeformat(ast))); ast_translate_path_to_str(ast_channel_readtrans(ast), &read_transpath),
ast_format_get_name(ast_channel_writeformat(ast)),
ast_format_get_name(ast_channel_rawwriteformat(ast)),
ast_translate_path_to_str(ast_channel_writetrans(ast), &write_transpath));
return 0; return 0;
} }
if (media->rtp) { if (media->rtp) {

10
main/bridge.c
Unescape View File

@ -939,12 +939,14 @@ int ast_bridge_destroy(struct ast_bridge *bridge, int cause)
static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
{ {
struct ast_str *codec_buf = ast_str_alloca(64); struct ast_str *codec_buf = ast_str_alloca(64);
struct ast_format *read_format;
struct ast_format *write_format;
struct ast_format *best_format; struct ast_format *best_format;
RAII_VAR(struct ast_format *, read_format, NULL, ao2_cleanup);
RAII_VAR(struct ast_format *, write_format, NULL, ao2_cleanup);
read_format = ast_channel_readformat(bridge_channel->chan); ast_channel_lock(bridge_channel->chan);
write_format = ast_channel_writeformat(bridge_channel->chan); read_format = ao2_bump(ast_channel_readformat(bridge_channel->chan));
write_format = ao2_bump(ast_channel_writeformat(bridge_channel->chan));
ast_channel_unlock(bridge_channel->chan);
/* Are the formats currently in use something this bridge can handle? */ /* Are the formats currently in use something this bridge can handle? */
if (ast_format_cap_iscompatible_format(bridge->technology->format_capabilities, read_format) == AST_FORMAT_CMP_NOT_EQUAL) { if (ast_format_cap_iscompatible_format(bridge->technology->format_capabilities, read_format) == AST_FORMAT_CMP_NOT_EQUAL) {

11
main/bridge_channel.c
Unescape View File

@ -323,6 +323,8 @@ void ast_bridge_channel_restore_formats(struct ast_bridge_channel *bridge_channe
ast_assert(bridge_channel->read_format != NULL); ast_assert(bridge_channel->read_format != NULL);
ast_assert(bridge_channel->write_format != NULL); ast_assert(bridge_channel->write_format != NULL);
ast_channel_lock(bridge_channel->chan);
/* Restore original formats of the channel as they came in */ /* Restore original formats of the channel as they came in */
if (ast_format_cmp(ast_channel_readformat(bridge_channel->chan), bridge_channel->read_format) == AST_FORMAT_CMP_NOT_EQUAL) { if (ast_format_cmp(ast_channel_readformat(bridge_channel->chan), bridge_channel->read_format) == AST_FORMAT_CMP_NOT_EQUAL) {
ast_debug(1, "Bridge is returning %p(%s) to read format %s\n", ast_debug(1, "Bridge is returning %p(%s) to read format %s\n",
@ -344,6 +346,8 @@ void ast_bridge_channel_restore_formats(struct ast_bridge_channel *bridge_channe
ast_format_get_name(bridge_channel->write_format)); ast_format_get_name(bridge_channel->write_format));
} }
} }
ast_channel_unlock(bridge_channel->chan);
} }
struct ast_bridge *ast_bridge_channel_merge_inhibit(struct ast_bridge_channel *bridge_channel, int request) struct ast_bridge *ast_bridge_channel_merge_inhibit(struct ast_bridge_channel *bridge_channel, int request)
@ -2354,9 +2358,6 @@ int bridge_channel_internal_join(struct ast_bridge_channel *bridge_channel)
int res = 0; int res = 0;
struct ast_bridge_features *channel_features; struct ast_bridge_features *channel_features;
bridge_channel->read_format = ao2_bump(ast_channel_readformat(bridge_channel->chan));
bridge_channel->write_format = ao2_bump(ast_channel_writeformat(bridge_channel->chan));
ast_debug(1, "Bridge %s: %p(%s) is joining\n", ast_debug(1, "Bridge %s: %p(%s) is joining\n",
bridge_channel->bridge->uniqueid, bridge_channel->bridge->uniqueid,
bridge_channel, ast_channel_name(bridge_channel->chan)); bridge_channel, ast_channel_name(bridge_channel->chan));
@ -2368,6 +2369,10 @@ int bridge_channel_internal_join(struct ast_bridge_channel *bridge_channel)
ast_bridge_lock(bridge_channel->bridge); ast_bridge_lock(bridge_channel->bridge);
ast_channel_lock(bridge_channel->chan); ast_channel_lock(bridge_channel->chan);
bridge_channel->read_format = ao2_bump(ast_channel_readformat(bridge_channel->chan));
bridge_channel->write_format = ao2_bump(ast_channel_writeformat(bridge_channel->chan));
/* Make sure we're still good to be put into a bridge */ /* Make sure we're still good to be put into a bridge */
if (ast_channel_internal_bridge(bridge_channel->chan) if (ast_channel_internal_bridge(bridge_channel->chan)
|| ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_ZOMBIE)) { || ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_ZOMBIE)) {

137
main/channel.c
Unescape View File

@ -5229,54 +5229,86 @@ done:
return res; return res;
} }
struct set_format_trans_access { struct set_format_access {
struct ast_trans_pvt *(*get)(const struct ast_channel *chan); const char *direction;
void (*set)(struct ast_channel *chan, struct ast_trans_pvt *value); struct ast_trans_pvt *(*get_trans)(const struct ast_channel *chan);
void (*set_trans)(struct ast_channel *chan, struct ast_trans_pvt *value);
struct ast_format *(*get_format)(struct ast_channel *chan);
void (*set_format)(struct ast_channel *chan, struct ast_format *format);
struct ast_format *(*get_rawformat)(struct ast_channel *chan);
void (*set_rawformat)(struct ast_channel *chan, struct ast_format *format);
int setoption;
}; };
static const struct set_format_trans_access set_format_readtrans = { static const struct set_format_access set_format_access_read = {
.get = ast_channel_readtrans, .direction = "read",
.set = ast_channel_readtrans_set, .get_trans = ast_channel_readtrans,
.set_trans = ast_channel_readtrans_set,
.get_format = ast_channel_readformat,
.set_format = ast_channel_set_readformat,
.get_rawformat = ast_channel_rawreadformat,
.set_rawformat = ast_channel_set_rawreadformat,
.setoption = AST_OPTION_FORMAT_READ,
}; };
static const struct set_format_trans_access set_format_writetrans = { static const struct set_format_access set_format_access_write = {
.get = ast_channel_writetrans, .direction = "write",
.set = ast_channel_writetrans_set, .get_trans = ast_channel_writetrans,
.set_trans = ast_channel_writetrans_set,
.get_format = ast_channel_writeformat,
.set_format = ast_channel_set_writeformat,
.get_rawformat = ast_channel_rawwriteformat,
.set_rawformat = ast_channel_set_rawwriteformat,
.setoption = AST_OPTION_FORMAT_WRITE,
}; };
static int set_format(struct ast_channel *chan, static int set_format(struct ast_channel *chan, struct ast_format_cap *cap_set, const int direction)
struct ast_format_cap *cap_set,
struct ast_format *rawformat,
struct ast_format *format,
const struct set_format_trans_access *trans,
const int direction)
{ {
struct ast_trans_pvt *trans_pvt; struct ast_trans_pvt *trans_pvt;
struct ast_format_cap *cap_native; struct ast_format_cap *cap_native;
RAII_VAR(struct ast_format *, best_set_fmt, ast_format_cap_get_format(cap_set, 0), ao2_cleanup); const struct set_format_access *access;
struct ast_format *rawformat;
struct ast_format *format;
RAII_VAR(struct ast_format *, best_set_fmt, NULL, ao2_cleanup);
RAII_VAR(struct ast_format *, best_native_fmt, NULL, ao2_cleanup); RAII_VAR(struct ast_format *, best_native_fmt, NULL, ao2_cleanup);
int res; int res;
ast_assert(format != NULL); if (!direction) {
ast_assert(rawformat != NULL); /* reading */
access = &set_format_access_read;
} else {
/* writing */
access = &set_format_access_write;
}
best_set_fmt = ast_format_cap_get_format(cap_set, 0);
/* See if the underlying channel driver is capable of performing transcoding for us */ /* See if the underlying channel driver is capable of performing transcoding for us */
if (!ast_channel_setoption(chan, direction ? AST_OPTION_FORMAT_WRITE : AST_OPTION_FORMAT_READ, &best_set_fmt, sizeof(best_set_fmt), 0)) { res = ast_channel_setoption(chan, access->setoption,
ast_debug(1, "Channel driver natively set channel %s to %s format %s\n", ast_channel_name(chan), &best_set_fmt, sizeof(best_set_fmt), 0);
direction ? "write" : "read", ast_format_get_name(best_set_fmt)); if (!res) {
ast_debug(1, "Channel driver natively set channel %s to %s format %s\n",
ast_channel_name(chan), access->direction, ast_format_get_name(best_set_fmt));
ast_channel_lock(chan); ast_channel_lock(chan);
cap_native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT); cap_native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
ast_format_cap_append(cap_native, best_set_fmt, 0); if (!cap_native
|| ast_format_cap_append(cap_native, best_set_fmt, 0)) {
ast_channel_unlock(chan);
ao2_cleanup(cap_native);
return -1;
}
ast_channel_nativeformats_set(chan, cap_native); ast_channel_nativeformats_set(chan, cap_native);
ao2_cleanup(cap_native); ao2_cleanup(cap_native);
ast_channel_unlock(chan); access->set_format(chan, best_set_fmt);
access->set_rawformat(chan, best_set_fmt);
trans_pvt = trans->get(chan); trans_pvt = access->get_trans(chan);
if (trans_pvt) { if (trans_pvt) {
ast_translator_free_path(trans_pvt); ast_translator_free_path(trans_pvt);
trans->set(chan, NULL); access->set_trans(chan, NULL);
} }
ast_channel_unlock(chan);
/* If there is a generator on the channel, it needs to know about this /* If there is a generator on the channel, it needs to know about this
* change if it is the write format. */ * change if it is the write format. */
@ -5288,6 +5320,12 @@ static int set_format(struct ast_channel *chan,
} }
ast_channel_lock(chan); ast_channel_lock(chan);
format = access->get_format(chan);
rawformat = access->get_rawformat(chan);
ast_assert(format != NULL);
ast_assert(rawformat != NULL);
cap_native = ast_channel_nativeformats(chan); cap_native = ast_channel_nativeformats(chan);
/* Find a translation path from the native format to one of the desired formats */ /* Find a translation path from the native format to one of the desired formats */
@ -5314,17 +5352,17 @@ static int set_format(struct ast_channel *chan,
/* Now we have a good choice for both. */ /* Now we have a good choice for both. */
if ((ast_format_cmp(rawformat, best_native_fmt) != AST_FORMAT_CMP_NOT_EQUAL) && if ((ast_format_cmp(rawformat, best_native_fmt) != AST_FORMAT_CMP_NOT_EQUAL) &&
(ast_format_cmp(format, best_set_fmt) != AST_FORMAT_CMP_NOT_EQUAL) && (ast_format_cmp(format, best_set_fmt) != AST_FORMAT_CMP_NOT_EQUAL) &&
((ast_format_cmp(rawformat, format) != AST_FORMAT_CMP_NOT_EQUAL) || trans->get(chan))) { ((ast_format_cmp(rawformat, format) != AST_FORMAT_CMP_NOT_EQUAL) || access->get_trans(chan))) {
/* the channel is already in these formats, so nothing to do */ /* the channel is already in these formats, so nothing to do */
ast_channel_unlock(chan); ast_channel_unlock(chan);
return 0; return 0;
} }
/* Free any translation we have right now */ /* Free any translation we have right now */
trans_pvt = trans->get(chan); trans_pvt = access->get_trans(chan);
if (trans_pvt) { if (trans_pvt) {
ast_translator_free_path(trans_pvt); ast_translator_free_path(trans_pvt);
trans->set(chan, NULL); access->set_trans(chan, NULL);
} }
/* Build a translation path from the raw format to the desired format */ /* Build a translation path from the raw format to the desired format */
@ -5343,24 +5381,17 @@ static int set_format(struct ast_channel *chan,
/* writing */ /* writing */
trans_pvt = ast_translator_build_path(best_native_fmt, best_set_fmt); trans_pvt = ast_translator_build_path(best_native_fmt, best_set_fmt);
} }
trans->set(chan, trans_pvt); access->set_trans(chan, trans_pvt);
res = trans_pvt ? 0 : -1; res = trans_pvt ? 0 : -1;
} }
if (!res) { if (!res) {
if (!direction) { access->set_format(chan, best_set_fmt);
/* reading */ access->set_rawformat(chan, best_native_fmt);
ast_channel_set_readformat(chan, best_set_fmt);
ast_channel_set_rawreadformat(chan, best_native_fmt);
} else {
/* writing */
ast_channel_set_writeformat(chan, best_set_fmt);
ast_channel_set_rawwriteformat(chan, best_native_fmt);
}
ast_debug(1, "Set channel %s to %s format %s\n", ast_debug(1, "Set channel %s to %s format %s\n",
ast_channel_name(chan), ast_channel_name(chan),
direction ? "write" : "read", access->direction,
ast_format_get_name(best_set_fmt)); ast_format_get_name(best_set_fmt));
} }
@ -5387,12 +5418,7 @@ int ast_set_read_format(struct ast_channel *chan, struct ast_format *format)
} }
ast_format_cap_append(cap, format, 0); ast_format_cap_append(cap, format, 0);
res = set_format(chan, res = set_format(chan, cap, 0);
cap,
ast_channel_rawreadformat(chan),
ast_channel_readformat(chan),
&set_format_readtrans,
0);
ao2_cleanup(cap); ao2_cleanup(cap);
return res; return res;
@ -5400,12 +5426,7 @@ int ast_set_read_format(struct ast_channel *chan, struct ast_format *format)
int ast_set_read_format_from_cap(struct ast_channel *chan, struct ast_format_cap *cap) int ast_set_read_format_from_cap(struct ast_channel *chan, struct ast_format_cap *cap)
{ {
return set_format(chan, return set_format(chan, cap, 0);
cap,
ast_channel_rawreadformat(chan),
ast_channel_readformat(chan),
&set_format_readtrans,
0);
} }
int ast_set_write_format(struct ast_channel *chan, struct ast_format *format) int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
@ -5420,12 +5441,7 @@ int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
} }
ast_format_cap_append(cap, format, 0); ast_format_cap_append(cap, format, 0);
res = set_format(chan, res = set_format(chan, cap, 1);
cap,
ast_channel_rawwriteformat(chan),
ast_channel_writeformat(chan),
&set_format_writetrans,
1);
ao2_cleanup(cap); ao2_cleanup(cap);
return res; return res;
@ -5433,12 +5449,7 @@ int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
int ast_set_write_format_from_cap(struct ast_channel *chan, struct ast_format_cap *cap) int ast_set_write_format_from_cap(struct ast_channel *chan, struct ast_format_cap *cap)
{ {
return set_format(chan, return set_format(chan, cap, 1);
cap,
ast_channel_rawwriteformat(chan),
ast_channel_writeformat(chan),
&set_format_writetrans,
1);
} }
const char *ast_channel_reason2str(int reason) const char *ast_channel_reason2str(int reason)

2
main/file.c
Unescape View File

@ -777,9 +777,11 @@ struct ast_filestream *ast_openstream_full(struct ast_channel *chan, const char
} }
/* Set the channel to a format we can work with and save off the previous format. */ /* Set the channel to a format we can work with and save off the previous format. */
ast_channel_lock(chan);
ast_channel_set_oldwriteformat(chan, ast_channel_writeformat(chan)); ast_channel_set_oldwriteformat(chan, ast_channel_writeformat(chan));
/* Set the channel to the best format that exists for the file. */ /* Set the channel to the best format that exists for the file. */
res = ast_set_write_format_from_cap(chan, file_fmt_cap); res = ast_set_write_format_from_cap(chan, file_fmt_cap);
ast_channel_unlock(chan);
/* don't need this anymore now that the channel's write format is set. */ /* don't need this anymore now that the channel's write format is set. */
ao2_ref(file_fmt_cap, -1); ao2_ref(file_fmt_cap, -1);

11
res/res_pjsip_sdp_rtp.c
Unescape View File

@ -265,15 +265,20 @@ static int set_caps(struct ast_sip_session *session, struct ast_sip_session_medi
if (session->channel) { if (session->channel) {
struct ast_format *fmt; struct ast_format *fmt;
ast_channel_lock(session->channel);
ast_format_cap_append_from_cap(caps, ast_channel_nativeformats(session->channel), AST_MEDIA_TYPE_UNKNOWN); ast_format_cap_append_from_cap(caps, ast_channel_nativeformats(session->channel), AST_MEDIA_TYPE_UNKNOWN);
ast_format_cap_remove_by_type(caps, media_type); ast_format_cap_remove_by_type(caps, media_type);
fmt = ast_format_cap_get_format(joint, 0); fmt = ast_format_cap_get_format(joint, 0);
ast_format_cap_append(caps, fmt, 0); ast_format_cap_append(caps, fmt, 0);
/* Apply the new formats to the channel, potentially changing read/write formats while doing so */ /*
* Apply the new formats to the channel, potentially changing
* raw read/write formats and translation path while doing so.
*/
ast_channel_nativeformats_set(session->channel, caps); ast_channel_nativeformats_set(session->channel, caps);
ast_channel_set_rawwriteformat(session->channel, fmt); ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
ast_channel_set_rawreadformat(session->channel, fmt); ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
ast_channel_unlock(session->channel);
ao2_ref(fmt, -1); ao2_ref(fmt, -1);
} }

Write Preview
Loading…
Cancel
Save