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

chan_iax2: Several media format fixes.

Browse Source 
* Fixed the iax.conf bandwidth option.  This is the root cause of
ASTERISK-24150.

* Added checks in iax2_request() to ensure that there are actual formats
requested for the new channel to prevent any more fracks from issues like
ASTERISK-24150.  This is a consequence of the iax.conf bandwidth option
not working.

* Fixed struct iax2_codec_pref.order member size mismatch issue when
converting to and from the codec preference order list passed over the
wire.  In addition the values sent over the wire are now compatible with
previous Asterisk versions.

* Fixed several issues dealing with the struct iax2_codec_pref members.
Off-by-one, array limit errors, and the order/framing members always need
to be updated together.

* Made iax2_request() setup the channel's native format preference order
according to the user's wishes.  The new media format strategy needs the
order specified earler.

* Fixed usage of ast_format_compatibility_bitfield2format().  The function
can return NULL if the bitfield was not associated with a function.

* Deleted dead code iax2_codec_pref_getsize() and
iax2_codec_pref_setsize().

* Made iax2_parse_allow_disallow() and iax2_codec_pref_string() call
iax2_codec_pref_to_cap() instead of inlining it.

* Made IAX_CAPABILITY_MEDBANDWIDTH, IAX_CAPABILITY_LOWBANDWIDTH, and
IAX_CAPABILITY_LOWFREE constants again as they were in Asterisk v1.8.

* Renamed prefs to prefs_global so it won't get confused with the local
pref versions.

* Fixed too small buffer in handle_cli_iax2_show_peer().

* Fixed ast_cli() calls in handle_cli_iax2_show_peer() to output complete
lines.

* Changed struct create_addr_info.prefs to be struct iax2_codec_pref as an
optimization so iax2_request() and iax2_call() do less work.

* Fixed a potential deadlock in ast_iax2_new() on an off-nominal path when
the pbx could not get started.

* Made set_config() setup a local prefs list along side the local
capability format bitfield.  Once the config is loaded, then the local
copies are put into the global versions.

* Fix unininialized codec_buf in function_iaxpeer().

ASTERISK-24150 #close
Reported by: Scott Griepentrog

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


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@420364 65c4cc65-6c06-0410-ace0-fbb531ad65f3
changes/97/197/1
Richard Mudgett 11 years ago
parent 0ac7f96057
commit ea7d4ab09e
7 changed files with 532 additions and 253 deletions
Show Stats Download Patch File Download Diff File

268
channels/chan_iax2.c
Unescape View File

@ -285,7 +285,7 @@ static int nochecksums = 0;
/* Sample over last 100 units to determine historic jitter */
#define GAMMA (0.01)
static struct iax2_codec_pref prefs;
static struct iax2_codec_pref prefs_global;
static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
@ -353,22 +353,22 @@ static int (*iax2_regfunk)(const char *username, int onoff) = NULL;
#define IAX_CAPABILITY_FULLBANDWIDTH 0xFFFF
/* T1, maybe ISDN */
#define IAX_CAPABILITY_MEDBANDWIDTH (IAX_CAPABILITY_FULLBANDWIDTH & \
~ast_format_compatibility_format2bitfield(ast_format_slin) & \
~ast_format_compatibility_format2bitfield(ast_format_slin16) & \
~ast_format_compatibility_format2bitfield(ast_format_siren7) & \
~ast_format_compatibility_format2bitfield(ast_format_siren14) & \
~ast_format_compatibility_format2bitfield(ast_format_g719) & \
~ast_format_compatibility_format2bitfield(ast_format_ulaw) & \
~ast_format_compatibility_format2bitfield(ast_format_alaw) & \
~ast_format_compatibility_format2bitfield(ast_format_g722))
~AST_FORMAT_SLIN & \
~AST_FORMAT_SLIN16 & \
~AST_FORMAT_SIREN7 & \
~AST_FORMAT_SIREN14 & \
~AST_FORMAT_G719 & \
~AST_FORMAT_ULAW & \
~AST_FORMAT_ALAW & \
~AST_FORMAT_G722)
/* A modem */
#define IAX_CAPABILITY_LOWBANDWIDTH (IAX_CAPABILITY_MEDBANDWIDTH & \
~ast_format_compatibility_format2bitfield(ast_format_g726) & \
~ast_format_compatibility_format2bitfield(ast_format_g726_aal2) & \
~ast_format_compatibility_format2bitfield(ast_format_adpcm))
~AST_FORMAT_G726 & \
~AST_FORMAT_G726_AAL2 & \
~AST_FORMAT_ADPCM)
#define IAX_CAPABILITY_LOWFREE (IAX_CAPABILITY_LOWBANDWIDTH & \
~ast_format_compatibility_format2bitfield(ast_format_g723))
~AST_FORMAT_G723)
#define DEFAULT_MAXMS 2000 /* Must be faster than 2 seconds by default */
@ -1820,16 +1820,20 @@ static struct ast_format *codec_choose_from_prefs(struct iax2_codec_pref *pref,
int x;
struct ast_format *found_format = NULL;
for (x = 0; x < IAX2_CODEC_PREF_SIZE; x++) {
for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
struct ast_format *pref_format;
uint64_t pref_as_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
uint64_t pref_bitfield;
if (!pref_as_bitfield) {
pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
if (!pref_bitfield) {
break;
}
pref_format = ast_format_compatibility_bitfield2format(pref_as_bitfield);
pref_format = ast_format_compatibility_bitfield2format(pref_bitfield);
if (!pref_format) {
/* The bitfield is not associated with any format. */
continue;
}
found_format = ast_format_cap_get_compatible_format(cap, pref_format);
if (found_format) {
break;
@ -1867,61 +1871,6 @@ static iax2_format iax2_codec_choose(struct iax2_codec_pref *pref, iax2_format f
return format;
}
static iax2_format iax2_best_codec(iax2_format formats)
{
/* This just our opinion, expressed in code. We are asked to choose
the best codec to use, given no information */
static const iax2_format prefs[] =
{
/*! Okay, ulaw is used by all telephony equipment, so start with it */
AST_FORMAT_ULAW,
/*! Unless of course, you're a silly European, so then prefer ALAW */
AST_FORMAT_ALAW,
AST_FORMAT_G719,
AST_FORMAT_SIREN14,
AST_FORMAT_SIREN7,
AST_FORMAT_TESTLAW,
/*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
AST_FORMAT_G722,
/*! Okay, well, signed linear is easy to translate into other stuff */
AST_FORMAT_SLIN16,
AST_FORMAT_SLIN,
/*! G.726 is standard ADPCM, in RFC3551 packing order */
AST_FORMAT_G726,
/*! G.726 is standard ADPCM, in AAL2 packing order */
AST_FORMAT_G726_AAL2,
/*! ADPCM has great sound quality and is still pretty easy to translate */
AST_FORMAT_ADPCM,
/*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
translate and sounds pretty good */
AST_FORMAT_GSM,
/*! iLBC is not too bad */
AST_FORMAT_ILBC,
/*! Speex is free, but computationally more expensive than GSM */
AST_FORMAT_SPEEX16,
AST_FORMAT_SPEEX,
/*! Opus */
AST_FORMAT_OPUS,
/*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
to use it */
AST_FORMAT_LPC10,
/*! G.729a is faster than 723 and slightly less expensive */
AST_FORMAT_G729,
/*! Down to G.723.1 which is proprietary but at least designed for voice */
AST_FORMAT_G723,
};
int x;
/* Find the first preferred codec in the format given */
for (x = 0; x < ARRAY_LEN(prefs); x++) {
if (formats & prefs[x]) {
return prefs[x];
}
}
return 0;
}
const char *iax2_getformatname(iax2_format format)
{
struct ast_format *tmpfmt;
@ -1951,33 +1900,24 @@ static const char *iax2_getformatname_multiple(iax2_format format, struct ast_st
static int iax2_parse_allow_disallow(struct iax2_codec_pref *pref, iax2_format *formats, const char *list, int allowing)
{
int res, i;
struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!cap) {
return 1;
}
struct ast_format_cap *cap;
/* We want to add the formats to the cap in the preferred order */
for (i = 0; i < IAX2_CODEC_PREF_SIZE; i++) {
uint64_t pref_as_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[i]);
if (!pref_as_bitfield) {
break;
}
if (iax2_format_compatibility_bitfield2cap(pref_as_bitfield, cap)) {
ao2_ref(cap, -1);
return 1;
}
cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!cap || iax2_codec_pref_to_cap(pref, cap)) {
ao2_cleanup(cap);
return 1;
}
res = ast_format_cap_update_by_allow_disallow(cap, list, allowing);
*formats = iax2_format_compatibility_cap2bitfield(cap);
/* Adjust formats bitfield and pref list to match. */
*formats = iax2_format_compatibility_cap2bitfield(cap);
iax2_codec_pref_remove_missing(pref, *formats);
for (i = 0; i < ast_format_cap_count(cap); i++) {
struct ast_format *fmt = ast_format_cap_get_format(cap, i);
iax2_codec_pref_append(pref, fmt, ast_format_cap_get_format_framing(cap, fmt));
ao2_ref(fmt, -1);
}
@ -2283,7 +2223,7 @@ static struct chan_iax2_pvt *new_iax(struct ast_sockaddr *addr, const char *host
return NULL;
}
tmp->prefs = prefs;
tmp->prefs = prefs_global;
tmp->pingid = -1;
tmp->lagid = -1;
tmp->autoid = -1;
@ -3844,7 +3784,7 @@ static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct
char status[30];
char cbuf[256];
struct iax2_peer *peer;
struct ast_str *codec_buf = ast_str_alloca(64);
struct ast_str *codec_buf = ast_str_alloca(256);
struct ast_str *encmethods = ast_str_alloca(256);
int load_realtime = 0;
@ -3895,17 +3835,15 @@ static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct
ast_cli(a->fd, " Addr->IP : %s Port %s\n", str_addr ? str_addr : "(Unspecified)", str_port);
ast_cli(a->fd, " Defaddr->IP : %s Port %s\n", str_defaddr, str_defport);
ast_cli(a->fd, " Username : %s\n", peer->username);
ast_cli(a->fd, " Codecs : ");
ast_cli(a->fd, "%s\n", iax2_getformatname_multiple(peer->capability, &codec_buf));
ast_cli(a->fd, " Codecs : %s\n", iax2_getformatname_multiple(peer->capability, &codec_buf));
ast_cli(a->fd, " Codec Order : ");
if (iax2_codec_pref_string(&peer->prefs, cbuf, sizeof(cbuf)) != -1) {
ast_cli(a->fd, "%s\n", cbuf);
if (iax2_codec_pref_string(&peer->prefs, cbuf, sizeof(cbuf)) < 0) {
strcpy(cbuf, "Error"); /* Safe */
}
ast_cli(a->fd, " Codec Order : %s\n", cbuf);
ast_cli(a->fd, " Status : ");
peer_status(peer, status, sizeof(status));
ast_cli(a->fd, "%s\n",status);
ast_cli(a->fd, " Status : %s\n", status);
ast_cli(a->fd, " Qualify : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
ast_cli(a->fd, "\n");
peer_unref(peer);
@ -4654,6 +4592,7 @@ static void realtime_update_peer(const char *peername, struct ast_sockaddr *sock
struct create_addr_info {
iax2_format capability;
uint64_t flags;
struct iax2_codec_pref prefs;
int maxtime;
int encmethods;
int found;
@ -4663,7 +4602,6 @@ struct create_addr_info {
char secret[80];
char outkey[80];
char timezone[80];
char prefs[32];
char cid_num[80];
char cid_name[80];
char context[AST_MAX_CONTEXT];
@ -4676,7 +4614,6 @@ static int create_addr(const char *peername, struct ast_channel *c, struct ast_s
{
struct iax2_peer *peer;
int res = -1;
struct iax2_codec_pref ourprefs;
ast_clear_flag64(cai, IAX_SENDANI | IAX_TRUNK);
cai->sockfd = defaultsockfd;
@ -4697,20 +4634,24 @@ static int create_addr(const char *peername, struct ast_channel *c, struct ast_s
}
ast_sockaddr_copy(addr, &peer_addr);
/* use global iax prefs for unknown peer/user */
/* But move the calling channel's native codec to the top of the preference list */
memcpy(&ourprefs, &prefs, sizeof(ourprefs));
/*
* Use The global iax prefs for unknown peer/user.
* However, move the calling channel's native codec to
* the top of the preference list.
*/
cai->prefs = prefs_global;
if (c) {
int i;
for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
struct ast_format *format = ast_format_cap_get_format(
ast_channel_nativeformats(c), i);
iax2_codec_pref_prepend(&ourprefs, format, ast_format_cap_get_format_framing(ast_channel_nativeformats(c), format), 1);
iax2_codec_pref_prepend(&cai->prefs, format,
ast_format_cap_get_format_framing(ast_channel_nativeformats(c), format),
1);
ao2_ref(format, -1);
}
}
iax2_codec_pref_convert(&ourprefs, cai->prefs, sizeof(cai->prefs), 1);
return 0;
}
@ -4731,7 +4672,7 @@ static int create_addr(const char *peername, struct ast_channel *c, struct ast_s
cai->encmethods = peer->encmethods;
cai->sockfd = peer->sockfd;
cai->adsi = peer->adsi;
memcpy(&ourprefs, &peer->prefs, sizeof(ourprefs));
cai->prefs = peer->prefs;
/* Move the calling channel's native codec to the top of the preference list */
if (c) {
int i;
@ -4739,11 +4680,12 @@ static int create_addr(const char *peername, struct ast_channel *c, struct ast_s
for (i = 0; i < ast_format_cap_count(ast_channel_nativeformats(c)); i++) {
struct ast_format *tmpfmt = ast_format_cap_get_format(
ast_channel_nativeformats(c), i);
iax2_codec_pref_prepend(&ourprefs, tmpfmt, ast_format_cap_get_format_framing(ast_channel_nativeformats(c), tmpfmt), 1);
iax2_codec_pref_prepend(&cai->prefs, tmpfmt,
ast_format_cap_get_format_framing(ast_channel_nativeformats(c), tmpfmt),
1);
ao2_ref(tmpfmt, -1);
}
}
iax2_codec_pref_convert(&ourprefs, cai->prefs, sizeof(cai->prefs), 1);
ast_copy_string(cai->context, peer->context, sizeof(cai->context));
ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
ast_copy_string(cai->username, peer->username, sizeof(cai->username));
@ -5150,6 +5092,7 @@ static int iax2_call(struct ast_channel *c, const char *dest, int timeout)
unsigned char osp_block_index;
unsigned int osp_block_length;
unsigned char osp_buffer[256];
char encoded_prefs[32];
iax2_format iax2_tmpfmt;
if ((ast_channel_state(c) != AST_STATE_DOWN) && (ast_channel_state(c) != AST_STATE_RESERVED)) {
@ -5218,7 +5161,8 @@ static int iax2_call(struct ast_channel *c, const char *dest, int timeout)
}
/* WARNING: this breaks down at 190 bits! */
iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
iax2_codec_pref_convert(&cai.prefs, encoded_prefs, sizeof(encoded_prefs), 1);
iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, encoded_prefs);
if (l) {
iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
@ -5877,7 +5821,9 @@ static int iax2_getpeertrunk(struct ast_sockaddr addr)
}
/*! \brief Create new call, interface with the PBX core */
static struct ast_channel *ast_iax2_new(int callno, int state, iax2_format capability, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, unsigned int cachable)
static struct ast_channel *ast_iax2_new(int callno, int state, iax2_format capability,
struct iax2_codec_pref *prefs, const struct ast_assigned_ids *assignedids,
const struct ast_channel *requestor, unsigned int cachable)
{
struct ast_channel *tmp = NULL;
struct chan_iax2_pvt *i;
@ -5893,10 +5839,22 @@ static struct ast_channel *ast_iax2_new(int callno, int state, iax2_format capab
return NULL;
}
if (!capability) {
ast_log(LOG_WARNING, "No formats specified for call to: IAX2/%s-%d\n",
i->host, i->callno);
return NULL;
}
native = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!native) {
return NULL;
}
if (iax2_codec_pref_best_bitfield2cap(capability, prefs, native)
|| !ast_format_cap_count(native)) {
ast_log(LOG_WARNING, "No requested formats available for call to: IAX2/%s-%d\n",
i->host, i->callno);
ao2_ref(native, -1);
return NULL;
}
if (!ast_strlen_zero(i->peer)) {
peer_name = ast_strdupa(i->peer);
@ -5910,13 +5868,17 @@ static struct ast_channel *ast_iax2_new(int callno, int state, iax2_format capab
if (!ast_strlen_zero(peer_name)) {
peer = find_peer(peer_name, 1);
if (peer && peer->endpoint) {
tmp = ast_channel_alloc_with_endpoint(1, state, i->cid_num, i->cid_name, i->accountcode, i->exten, i->context, assignedids, requestor, i->amaflags, peer->endpoint, "IAX2/%s-%d", i->host, i->callno);
tmp = ast_channel_alloc_with_endpoint(1, state, i->cid_num, i->cid_name,
i->accountcode, i->exten, i->context, assignedids, requestor,
i->amaflags, peer->endpoint, "IAX2/%s-%d", i->host, i->callno);
}
ao2_cleanup(peer);
}
if (!tmp) {
tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode, i->exten, i->context, assignedids, requestor, i->amaflags, "IAX2/%s-%d", i->host, i->callno);
tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode,
i->exten, i->context, assignedids, requestor, i->amaflags, "IAX2/%s-%d",
i->host, i->callno);
}
ast_mutex_lock(&iaxsl[callno]);
@ -5945,9 +5907,8 @@ static struct ast_channel *ast_iax2_new(int callno, int state, iax2_format capab
ast_channel_tech_set(tmp, &iax2_tech);
/* We can support any format by default, until we get restricted */
iax2_format_compatibility_bitfield2cap(capability, native);
ast_channel_nativeformats_set(tmp, native);
tmpfmt = ast_format_cap_get_format(ast_channel_nativeformats(tmp), 0);
tmpfmt = ast_format_cap_get_format(native, 0);
ast_channel_set_readformat(tmp, tmpfmt);
ast_channel_set_rawreadformat(tmp, tmpfmt);
@ -6046,8 +6007,10 @@ static struct ast_channel *ast_iax2_new(int callno, int state, iax2_format capab
if (state != AST_STATE_DOWN) {
if (ast_pbx_start(tmp)) {
ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ast_channel_name(tmp));
/* unlock and relock iaxsl[callno] to preserve locking order */
ast_mutex_unlock(&iaxsl[callno]);
ast_hangup(tmp);
i->owner = NULL;
ast_mutex_lock(&iaxsl[callno]);
return NULL;
}
}
@ -7907,8 +7870,10 @@ static int check_access(int callno, struct ast_sockaddr *addr, struct iax_ies *i
/* Use provided preferences until told otherwise for actual preferences */
if (ies->codec_prefs) {
iax2_codec_pref_convert(&iaxs[callno]->rprefs, ies->codec_prefs, 32, 0);
iax2_codec_pref_convert(&iaxs[callno]->prefs, ies->codec_prefs, 32, 0);
} else {
memset(&iaxs[callno]->rprefs, 0, sizeof(iaxs[callno]->rprefs));
}
iaxs[callno]->prefs = iaxs[callno]->rprefs;
if (!gotcapability) {
iaxs[callno]->peercapability = iaxs[callno]->peerformat;
@ -10556,8 +10521,9 @@ static int socket_process_helper(struct iax2_thread *thread)
(f.frametype == AST_FRAME_IAX)) {
if (ast_test_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART)) {
ast_clear_flag64(iaxs[fr->callno], IAX_DELAYPBXSTART);
if (!ast_iax2_new(fr->callno, AST_STATE_RING, iaxs[fr->callno]->chosenformat, NULL, NULL,
ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED))) {
if (!ast_iax2_new(fr->callno, AST_STATE_RING,
iaxs[fr->callno]->chosenformat, &iaxs[fr->callno]->rprefs, NULL, NULL,
ast_test_flag(&iaxs[fr->callno]->state, IAX_STATE_AUTHENTICATED))) {
ast_variables_destroy(ies.vars);
ast_mutex_unlock(&iaxsl[fr->callno]);
return 1;
@ -10893,7 +10859,7 @@ static int socket_process_helper(struct iax2_thread *thread)
if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
memset(&pref, 0, sizeof(pref));
format = iax2_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
strcpy(caller_pref_buf,"disabled");
strcpy(host_pref_buf,"disabled");
} else {
@ -10909,7 +10875,7 @@ static int socket_process_helper(struct iax2_thread *thread)
}
format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
} else /* if no codec_prefs IE do it the old way */
format = iax2_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
}
}
@ -11111,7 +11077,9 @@ static int socket_process_helper(struct iax2_thread *thread)
struct ast_str *cap_buf = ast_str_alloca(64);
/* Switch us to use a compatible format */
iax2_format_compatibility_bitfield2cap(iaxs[fr->callno]->peerformat, native);
iax2_codec_pref_best_bitfield2cap(
iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
native);
ast_channel_nativeformats_set(iaxs[fr->callno]->owner, native);
ast_verb(3, "Format for call is %s\n", ast_format_cap_get_names(ast_channel_nativeformats(iaxs[fr->callno]->owner), &cap_buf));
@ -11351,8 +11319,9 @@ static int socket_process_helper(struct iax2_thread *thread)
if(ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOPREFS)) {
using_prefs = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ? "reqonly" : "disabled";
memset(&pref, 0, sizeof(pref));
format = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP) ?
iaxs[fr->callno]->peerformat : iax2_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
format = ast_test_flag64(iaxs[fr->callno], IAX_CODEC_NOCAP)
? iaxs[fr->callno]->peerformat
: iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
strcpy(caller_pref_buf,"disabled");
strcpy(host_pref_buf,"disabled");
} else {
@ -11368,7 +11337,7 @@ static int socket_process_helper(struct iax2_thread *thread)
}
format = iax2_codec_choose(&pref, iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
} else /* if no codec_prefs IE do it the old way */
format = iax2_best_codec(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
format = iax2_format_compatibility_best(iaxs[fr->callno]->peercapability & iaxs[fr->callno]->capability);
}
}
if (!format) {
@ -11429,9 +11398,11 @@ static int socket_process_helper(struct iax2_thread *thread)
using_prefs);
ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
if (!(c = ast_iax2_new(fr->callno, AST_STATE_RING, format, NULL, NULL, 1)))
c = ast_iax2_new(fr->callno, AST_STATE_RING, format,
&iaxs[fr->callno]->rprefs, NULL, NULL, 1);
if (!c) {
iax2_destroy(fr->callno);
else if (ies.vars) {
} else if (ies.vars) {
struct ast_datastore *variablestore;
struct ast_variable *var, *prev = NULL;
AST_LIST_HEAD(, ast_var_t) *varlist;
@ -11503,9 +11474,12 @@ immediatedial:
iax2_getformatname_multiple(iaxs[fr->callno]->peerformat, &cap_buf));
ast_set_flag(&iaxs[fr->callno]->state, IAX_STATE_STARTED);
send_command(iaxs[fr->callno], AST_FRAME_CONTROL, AST_CONTROL_PROGRESS, 0, NULL, 0, -1);
if (!(c = ast_iax2_new(fr->callno, AST_STATE_RING, iaxs[fr->callno]->peerformat, NULL, NULL, 1)))
c = ast_iax2_new(fr->callno, AST_STATE_RING,
iaxs[fr->callno]->peerformat, &iaxs[fr->callno]->rprefs,
NULL, NULL, 1);
if (!c) {
iax2_destroy(fr->callno);
else if (ies.vars) {
} else if (ies.vars) {
struct ast_datastore *variablestore;
struct ast_variable *var, *prev = NULL;
AST_LIST_HEAD(, ast_var_t) *varlist;
@ -12528,7 +12502,8 @@ static struct ast_channel *iax2_request(const char *type, struct ast_format_cap
ast_string_field_set(iaxs[callno], host, pds.peer);
}
c = ast_iax2_new(callno, AST_STATE_DOWN, cai.capability, assignedids, requestor, cai.found);
c = ast_iax2_new(callno, AST_STATE_DOWN, cai.capability, &cai.prefs, assignedids,
requestor, cai.found);
ast_mutex_unlock(&iaxsl[callno]);
@ -12840,7 +12815,7 @@ static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, st
ast_sockaddr_set_port(&peer->addr, IAX_DEFAULT_PORTNO);
peer->expiry = min_reg_expire;
}
peer->prefs = prefs;
peer->prefs = prefs_global;
peer->capability = iax2_capability;
peer->smoothing = 0;
peer->pokefreqok = DEFAULT_FREQ_OK;
@ -13157,7 +13132,7 @@ static struct iax2_user *build_user(const char *name, struct ast_variable *v, st
}
user->maxauthreq = maxauthreq;
user->curauthreq = oldcurauthreq;
user->prefs = prefs;
user->prefs = prefs_global;
user->capability = iax2_capability;
user->encmethods = iax2_encryption;
user->adsi = adsi;
@ -13470,7 +13445,7 @@ static void set_config_destroy(void)
static int set_config(const char *config_file, int reload, int forced)
{
struct ast_config *cfg, *ucfg;
iax2_format capability = iax2_capability;
iax2_format capability;
struct ast_variable *v;
char *cat;
const char *utype;
@ -13485,9 +13460,7 @@ static int set_config(const char *config_file, int reload, int forced)
struct ast_netsock *ns;
struct ast_flags config_flags = { (reload && !forced) ? CONFIG_FLAG_FILEUNCHANGED : 0 };
struct ast_sockaddr bindaddr;
#if 0
static unsigned short int last_port=0;
#endif
struct iax2_codec_pref prefs_new;
cfg = ast_config_load(config_file, config_flags);
@ -13528,8 +13501,8 @@ static int set_config(const char *config_file, int reload, int forced)
ast_sockaddr_parse(&bindaddr, "0.0.0.0:0", 0);
/* Reset global codec prefs */
memset(&prefs, 0 , sizeof(struct iax2_codec_pref));
/* Setup new codec prefs */
capability = iax2_codec_pref_from_bitfield(&prefs_new, IAX_CAPABILITY_FULLBANDWIDTH);
/* Reset Global Flags */
memset(&globalflags, 0, sizeof(globalflags));
@ -13754,17 +13727,21 @@ static int set_config(const char *config_file, int reload, int forced)
}
} else if (!strcasecmp(v->name, "bandwidth")) {
if (!strcasecmp(v->value, "low")) {
capability = IAX_CAPABILITY_LOWBANDWIDTH;
capability = iax2_codec_pref_from_bitfield(&prefs_new,
IAX_CAPABILITY_LOWBANDWIDTH);
} else if (!strcasecmp(v->value, "medium")) {
capability = IAX_CAPABILITY_MEDBANDWIDTH;
capability = iax2_codec_pref_from_bitfield(&prefs_new,
IAX_CAPABILITY_MEDBANDWIDTH);
} else if (!strcasecmp(v->value, "high")) {
capability = IAX_CAPABILITY_FULLBANDWIDTH;
} else
capability = iax2_codec_pref_from_bitfield(&prefs_new,
IAX_CAPABILITY_FULLBANDWIDTH);
} else {
ast_log(LOG_WARNING, "bandwidth must be either low, medium, or high\n");
}
} else if (!strcasecmp(v->name, "allow")) {
iax2_parse_allow_disallow(&prefs, &capability, v->value, 1);
iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 1);
} else if (!strcasecmp(v->name, "disallow")) {
iax2_parse_allow_disallow(&prefs, &capability, v->value, 0);
iax2_parse_allow_disallow(&prefs_new, &capability, v->value, 0);
} else if (!strcasecmp(v->name, "register")) {
iax2_register(v->value, v->lineno);
} else if (!strcasecmp(v->name, "iaxcompat")) {
@ -13882,6 +13859,7 @@ static int set_config(const char *config_file, int reload, int forced)
min_reg_expire, max_reg_expire, max_reg_expire);
min_reg_expire = max_reg_expire;
}
prefs_global = prefs_new;
iax2_capability = capability;
if (ucfg) {
@ -14408,7 +14386,7 @@ static int function_iaxpeer(struct ast_channel *chan, const char *cmd, char *dat
} else if (!strcasecmp(colname, "callerid_num")) {
ast_copy_string(buf, peer->cid_num, len);
} else if (!strcasecmp(colname, "codecs")) {
struct ast_str *codec_buf;
struct ast_str *codec_buf = ast_str_alloca(256);
iax2_getformatname_multiple(peer->capability, &codec_buf);
ast_copy_string(buf, ast_str_buffer(codec_buf), len);

369
channels/iax2/codec_pref.c
Unescape View File

@ -38,6 +38,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/format_compatibility.h"
#include "asterisk/format_cache.h"
#include "asterisk/format_cap.h"
#include "asterisk/utils.h"
#include "include/codec_pref.h"
#include "include/format_compatibility.h"
@ -48,7 +49,8 @@ void iax2_codec_pref_convert(struct iax2_codec_pref *pref, char *buf, size_t siz
int x;
if (right) {
for (x = 0; x < IAX2_CODEC_PREF_SIZE && x < size; x++) {
--size;/* Save room for the nul string terminator. */
for (x = 0; x < ARRAY_LEN(pref->order) && x < size; ++x) {
if (!pref->order[x]) {
break;
}
@ -58,24 +60,29 @@ void iax2_codec_pref_convert(struct iax2_codec_pref *pref, char *buf, size_t siz
buf[x] = '\0';
} else {
for (x = 0; x < IAX2_CODEC_PREF_SIZE && x < size; x++) {
for (x = 0; x < ARRAY_LEN(pref->order) && x < size; ++x) {
if (buf[x] == '\0') {
break;
}
pref->order[x] = buf[x] - differential;
pref->framing[x] = 0;
}
if (x < size) {
if (x < ARRAY_LEN(pref->order)) {
pref->order[x] = 0;
pref->framing[x] = 0;
}
}
}
struct ast_format *iax2_codec_pref_index(struct iax2_codec_pref *pref, int idx, struct ast_format **result)
{
if ((idx >= 0) && (idx < sizeof(pref->order)) && pref->order[idx]) {
*result = ast_format_compatibility_bitfield2format(pref->order[idx]);
if (0 <= idx && idx < ARRAY_LEN(pref->order) && pref->order[idx]) {
uint64_t pref_bitfield;
pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[idx]);
*result = ast_format_compatibility_bitfield2format(pref_bitfield);
} else {
*result = NULL;
}
@ -83,50 +90,117 @@ struct ast_format *iax2_codec_pref_index(struct iax2_codec_pref *pref, int idx,
return *result;
}
void iax2_codec_pref_to_cap(struct iax2_codec_pref *pref, struct ast_format_cap *cap)
int iax2_codec_pref_to_cap(struct iax2_codec_pref *pref, struct ast_format_cap *cap)
{
int idx;
for (idx = 0; idx < sizeof(pref->order); idx++) {
if (!pref->order[idx]) {
for (idx = 0; idx < ARRAY_LEN(pref->order); ++idx) {
uint64_t pref_bitfield;
struct ast_format *pref_format;
pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[idx]);
if (!pref_bitfield) {
break;
}
pref_format = ast_format_compatibility_bitfield2format(pref_bitfield);
if (pref_format && ast_format_cap_append(cap, pref_format, pref->framing[idx])) {
return -1;
}
}
return 0;
}
int iax2_codec_pref_best_bitfield2cap(uint64_t bitfield, struct iax2_codec_pref *prefs, struct ast_format_cap *cap)
{
uint64_t best_bitfield;
struct ast_format *format;
/* Add any user preferred codecs first. */
if (prefs) {
int idx;
for (idx = 0; bitfield && idx < ARRAY_LEN(prefs->order); ++idx) {
best_bitfield = iax2_codec_pref_order_value_to_format_bitfield(prefs->order[idx]);
if (!best_bitfield) {
break;
}
if (best_bitfield & bitfield) {
format = ast_format_compatibility_bitfield2format(best_bitfield);
if (format && ast_format_cap_append(cap, format, prefs->framing[idx])) {
return -1;
}
/* Remove just added codec. */
bitfield &= ~best_bitfield;
}
}
}
/* Add the hard coded "best" codecs. */
while (bitfield) {
best_bitfield = iax2_format_compatibility_best(bitfield);
if (!best_bitfield) {
/* No more codecs considered best. */
break;
}
ast_format_cap_append(cap, ast_format_compatibility_bitfield2format(pref->order[idx]), pref->framing[idx]);
format = ast_format_compatibility_bitfield2format(best_bitfield);
/* The best_bitfield should always be convertible to a format. */
ast_assert(format != NULL);
if (ast_format_cap_append(cap, format, 0)) {
return -1;
}
/* Remove just added "best" codec to find the next "best". */
bitfield &= ~best_bitfield;
}
/* Add any remaining codecs. */
if (bitfield) {
int bit;
for (bit = 0; bit < 64; ++bit) {
uint64_t mask = (1ULL << bit);
if (mask & bitfield) {
format = ast_format_compatibility_bitfield2format(mask);
if (format && ast_format_cap_append(cap, format, 0)) {
return -1;
}
}
}
}
return 0;
}
int iax2_codec_pref_string(struct iax2_codec_pref *pref, char *buf, size_t size)
{
int x;
struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
struct ast_format_cap *cap;
size_t total_len;
char *cur;
if (!cap) {
return -1;
}
/* This function is useless if you have less than a 6 character buffer.
* '(...)' is six characters. */
if (size < 6) {
return -1;
}
/* Convert the preferences into a format cap so that we can read the formst names */
for (x = 0; x < IAX2_CODEC_PREF_SIZE; x++) {
uint64_t bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
if (!bitfield) {
break;
}
iax2_format_compatibility_bitfield2cap(bitfield, cap);
/* Convert the preferences into a format cap so that we can read the format names */
cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!cap || iax2_codec_pref_to_cap(pref, cap)) {
strcpy(buf, "(...)"); /* Safe */
ao2_cleanup(cap);
return -1;
}
/* We know that at a minimum, 3 characters are used - (, ), and \0 */
total_len = size - 3;
memset(buf, 0, size);
/* This character has already been accounted for total_len purposes */
buf[0] = '(';
cur = buf + 1;
@ -173,12 +247,20 @@ int iax2_codec_pref_string(struct iax2_codec_pref *pref, char *buf, size_t size)
static void codec_pref_remove_index(struct iax2_codec_pref *pref, int codec_pref_index)
{
int x;
int idx;
for (x = codec_pref_index; x < IAX2_CODEC_PREF_SIZE; x++) {
pref->order[x] = pref->order[x + 1];
pref->framing[x] = pref->framing[x + 1];
if (!pref->order[x]) {
idx = codec_pref_index;
if (idx == ARRAY_LEN(pref->order) - 1) {
/* Remove from last array entry. */
pref->order[idx] = 0;
pref->framing[idx] = 0;
return;
}
for (; idx < ARRAY_LEN(pref->order); ++idx) {
pref->order[idx] = pref->order[idx + 1];
pref->framing[idx] = pref->framing[idx + 1];
if (!pref->order[idx]) {
return;
}
}
@ -193,7 +275,7 @@ static void codec_pref_remove(struct iax2_codec_pref *pref, int format_index)
return;
}
for (x = 0; x < IAX2_CODEC_PREF_SIZE; x++) {
for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
if (!pref->order[x]) {
break;
}
@ -207,86 +289,181 @@ static void codec_pref_remove(struct iax2_codec_pref *pref, int format_index)
void iax2_codec_pref_remove_missing(struct iax2_codec_pref *pref, uint64_t bitfield)
{
int x;
int idx;
if (!pref->order[0]) {
return;
}
for (x = 0; x < IAX2_CODEC_PREF_SIZE; x++) {
uint64_t format_as_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
if (!pref->order[x]) {
break;
/*
* Work from the end of the list so we always deal with
* unmodified entries in case we have to remove a pref.
*/
for (idx = ARRAY_LEN(pref->order); idx--;) {
uint64_t pref_bitfield;
pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[idx]);
if (!pref_bitfield) {
continue;
}
/* If this format isn't in the bitfield, remove it from the prefs. */
if (!(format_as_bitfield & bitfield)) {
codec_pref_remove_index(pref, x);
if (!(pref_bitfield & bitfield)) {
codec_pref_remove_index(pref, idx);
}
}
}
uint64_t iax2_codec_pref_order_value_to_format_bitfield(uint64_t order_value)
/*!
* \brief Formats supported by IAX2.
*
* \note All AST_FORMAT_xxx compatibility bit defines must be
* represented here.
*
* \note The order is important because the array index+1 values
* go out over the wire.
*/
static const uint64_t iax2_supported_formats[] = {
AST_FORMAT_G723,
AST_FORMAT_GSM,
AST_FORMAT_ULAW,
AST_FORMAT_ALAW,
AST_FORMAT_G726,
AST_FORMAT_ADPCM,
AST_FORMAT_SLIN,
AST_FORMAT_LPC10,
AST_FORMAT_G729,
AST_FORMAT_SPEEX,
AST_FORMAT_SPEEX16,
AST_FORMAT_ILBC,
AST_FORMAT_G726_AAL2,
AST_FORMAT_G722,
AST_FORMAT_SLIN16,
AST_FORMAT_JPEG,
AST_FORMAT_PNG,
AST_FORMAT_H261,
AST_FORMAT_H263,
AST_FORMAT_H263P,
AST_FORMAT_H264,
AST_FORMAT_MP4,
AST_FORMAT_T140_RED,
AST_FORMAT_T140,
AST_FORMAT_SIREN7,
AST_FORMAT_SIREN14,
AST_FORMAT_TESTLAW,
AST_FORMAT_G719,
0, /* Place holder */
0, /* Place holder */
0, /* Place holder */
0, /* Place holder */
0, /* Place holder */
0, /* Place holder */
0, /* Place holder */
0, /* Place holder */
AST_FORMAT_OPUS,
AST_FORMAT_VP8,
/* ONLY ADD TO THE END OF THIS LIST */
/* XXX Use up the place holder slots first. */
};
uint64_t iax2_codec_pref_order_value_to_format_bitfield(int order_value)
{
if (!order_value) {
if (order_value < 1 || ARRAY_LEN(iax2_supported_formats) < order_value) {
return 0;
}
return 1 << (order_value - 1);
return iax2_supported_formats[order_value - 1];
}
uint64_t iax2_codec_pref_format_bitfield_to_order_value(uint64_t bitfield)
int iax2_codec_pref_format_bitfield_to_order_value(uint64_t bitfield)
{
int format_index = 1;
if (!bitfield) {
return 0;
}
int idx;
while (bitfield > 1) {
bitfield = bitfield >> 1;
format_index++;
if (bitfield) {
for (idx = 0; idx < ARRAY_LEN(iax2_supported_formats); ++idx) {
if (iax2_supported_formats[idx] == bitfield) {
return idx + 1;
}
}
}
return format_index;
return 0;
}
/*! \brief Append codec to list */
int iax2_codec_pref_append(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing)
/*!
* \internal
* \brief Append the bitfield format to the codec preference list.
* \since 13.0.0
*
* \param pref Codec preference list to append the given bitfield.
* \param bitfield Format bitfield to append.
* \param framing Framing size of the codec.
*
* \return Nothing
*/
static void iax2_codec_pref_append_bitfield(struct iax2_codec_pref *pref, uint64_t bitfield, unsigned int framing)
{
uint64_t bitfield = ast_format_compatibility_format2bitfield(format);
int format_index = iax2_codec_pref_format_bitfield_to_order_value(bitfield);
int format_index;
int x;
format_index = iax2_codec_pref_format_bitfield_to_order_value(bitfield);
if (!format_index) {
return;
}
codec_pref_remove(pref, format_index);
for (x = 0; x < IAX2_CODEC_PREF_SIZE; x++) {
for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
if (!pref->order[x]) {
pref->order[x] = format_index;
pref->framing[x] = framing;
break;
}
}
}
void iax2_codec_pref_append(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing)
{
uint64_t bitfield;
bitfield = ast_format_compatibility_format2bitfield(format);
if (!bitfield) {
return;
}
return x;
iax2_codec_pref_append_bitfield(pref, bitfield, framing);
}
/*! \brief Prepend codec to list */
void iax2_codec_pref_prepend(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing,
int only_if_existing)
{
uint64_t bitfield = ast_format_compatibility_format2bitfield(format);
uint64_t bitfield;
int format_index;
int x;
bitfield = ast_format_compatibility_format2bitfield(format);
if (!bitfield) {
return;
}
format_index = iax2_codec_pref_format_bitfield_to_order_value(bitfield);
if (!format_index) {
return;
}
/* Now find any existing occurrence, or the end */
for (x = 0; x < IAX2_CODEC_PREF_SIZE; x++) {
if (!pref->order[x] || pref->order[x] == bitfield)
for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
if (!pref->order[x] || pref->order[x] == format_index)
break;
}
/* If we failed to find any occurrence, set to the end */
if (x == IAX2_CODEC_PREF_SIZE) {
--x;
/*
* The array can never be full without format_index
* also being in the array.
*/
ast_assert(x < ARRAY_LEN(pref->order));
/* If we failed to find any occurrence, set to the end for safety. */
if (ARRAY_LEN(pref->order) <= x) {
x = ARRAY_LEN(pref->order) - 1;
}
if (only_if_existing && !pref->order[x]) {
@ -295,39 +472,63 @@ void iax2_codec_pref_prepend(struct iax2_codec_pref *pref, struct ast_format *fo
/* Move down to make space to insert - either all the way to the end,
or as far as the existing location (which will be overwritten) */
for (; x > 0; x--) {
for (; x > 0; --x) {
pref->order[x] = pref->order[x - 1];
pref->framing[x] = pref->framing[x - 1];
}
/* And insert the new entry */
pref->order[0] = bitfield;
pref->order[0] = format_index;
pref->framing[0] = framing;
}
unsigned int iax2_codec_pref_getsize(struct iax2_codec_pref *pref, int idx)
uint64_t iax2_codec_pref_from_bitfield(struct iax2_codec_pref *pref, uint64_t bitfield)
{
if ((idx >= 0) && (idx < sizeof(pref->order)) && pref->order[idx]) {
return pref->framing[idx];
} else {
return 0;
}
}
int bit;
uint64_t working_bitfield;
uint64_t best_bitfield;
struct ast_format *format;
int iax2_codec_pref_setsize(struct iax2_codec_pref *pref, struct ast_format *format, int framems)
{
int idx;
/* Init the preference list. */
memset(pref, 0, sizeof(*pref));
for (idx = 0; idx < sizeof(pref->order); idx++) {
if (!pref->order[idx]) {
working_bitfield = bitfield;
/* Add the "best" codecs first. */
while (working_bitfield) {
best_bitfield = iax2_format_compatibility_best(working_bitfield);
if (!best_bitfield) {
/* No more codecs considered best. */
break;
} else if (ast_format_cmp(ast_format_compatibility_bitfield2format(pref->order[idx]),
format) != AST_FORMAT_CMP_EQUAL) {
continue;
}
pref->framing[idx] = framems;
return 0;
/* Remove current "best" codec to find the next "best". */
working_bitfield &= ~best_bitfield;
format = ast_format_compatibility_bitfield2format(best_bitfield);
/* The best_bitfield should always be convertible to a format. */
ast_assert(format != NULL);
iax2_codec_pref_append_bitfield(pref, best_bitfield, 0);
}
/* Add any remaining codecs. */
if (working_bitfield) {
for (bit = 0; bit < 64; ++bit) {
uint64_t mask = (1ULL << bit);
if (mask & working_bitfield) {
format = ast_format_compatibility_bitfield2format(mask);
if (!format) {
/* The bit is not associated with any format. */
bitfield &= ~mask;
continue;
}
iax2_codec_pref_append_bitfield(pref, mask, 0);
}
}
}
return -1;
return bitfield;
}

73
channels/iax2/format_compatibility.c
Unescape View File

@ -38,6 +38,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/format_compatibility.h"
#include "asterisk/format_cache.h"
#include "asterisk/format_cap.h"
#include "asterisk/utils.h"
#include "include/format_compatibility.h"
@ -59,13 +60,75 @@ uint64_t iax2_format_compatibility_cap2bitfield(const struct ast_format_cap *cap
int iax2_format_compatibility_bitfield2cap(uint64_t bitfield, struct ast_format_cap *cap)
{
int x;
int bit;
for (bit = 0; bit < 64; ++bit) {
uint64_t mask = (1ULL << bit);
if (mask & bitfield) {
struct ast_format *format;
format = ast_format_compatibility_bitfield2format(mask);
if (format && ast_format_cap_append(cap, format, 0)) {
return -1;
}
}
}
for (x = 0; x < 64; x++) {
uint64_t tmp = (1ULL << x);
return 0;
}
uint64_t iax2_format_compatibility_best(uint64_t formats)
{
/*
* This just our opinion, expressed in code. We are
* asked to choose the best codec to use, given no
* information.
*/
static const uint64_t best[] = {
/*! Okay, ulaw is used by all telephony equipment, so start with it */
AST_FORMAT_ULAW,
/*! Unless of course, you're a silly European, so then prefer ALAW */
AST_FORMAT_ALAW,
AST_FORMAT_G719,
AST_FORMAT_SIREN14,
AST_FORMAT_SIREN7,
AST_FORMAT_TESTLAW,
/*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
AST_FORMAT_G722,
/*! Okay, well, signed linear is easy to translate into other stuff */
AST_FORMAT_SLIN16,
AST_FORMAT_SLIN,
/*! G.726 is standard ADPCM, in RFC3551 packing order */
AST_FORMAT_G726,
/*! G.726 is standard ADPCM, in AAL2 packing order */
AST_FORMAT_G726_AAL2,
/*! ADPCM has great sound quality and is still pretty easy to translate */
AST_FORMAT_ADPCM,
/*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
translate and sounds pretty good */
AST_FORMAT_GSM,
/*! iLBC is not too bad */
AST_FORMAT_ILBC,
/*! Speex is free, but computationally more expensive than GSM */
AST_FORMAT_SPEEX16,
AST_FORMAT_SPEEX,
/*! Opus */
AST_FORMAT_OPUS,
/*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
to use it */
AST_FORMAT_LPC10,
/*! G.729a is faster than 723 and slightly less expensive */
AST_FORMAT_G729,
/*! Down to G.723.1 which is proprietary but at least designed for voice */
AST_FORMAT_G723,
};
int idx;
if ((tmp & bitfield) && ast_format_cap_append(cap, ast_format_compatibility_bitfield2format(tmp), 0)) {
return -1;
/* Find the first preferred codec in the format given */
for (idx = 0; idx < ARRAY_LEN(best); ++idx) {
if (formats & best[idx]) {
return best[idx];
}
}

57
channels/iax2/include/codec_pref.h
Unescape View File

@ -32,8 +32,8 @@ struct ast_format_cap;
#define IAX2_CODEC_PREF_SIZE 64
struct iax2_codec_pref {
/*! This array is ordered by preference and contains the codec bitfield. */
uint64_t order[IAX2_CODEC_PREF_SIZE];
/*! Array is ordered by preference. Contains the iax2_supported_formats[] index + 1. */
char order[IAX2_CODEC_PREF_SIZE];
/*! Framing size of the codec */
unsigned int framing[IAX2_CODEC_PREF_SIZE];
};
@ -45,7 +45,7 @@ struct iax2_codec_pref {
*
* \return the bitfield value of the order_value format
*/
uint64_t iax2_codec_pref_order_value_to_format_bitfield(uint64_t order_value);
uint64_t iax2_codec_pref_order_value_to_format_bitfield(int order_value);
/*!
* \brief Convert a format bitfield into an iax2_codec_pref order value
@ -59,7 +59,7 @@ uint64_t iax2_codec_pref_order_value_to_format_bitfield(uint64_t order_value);
* It will work with multiformat bitfields, but it can only return the
* index of the most significant one if that is the case.
*/
uint64_t iax2_codec_pref_format_bitfield_to_order_value(uint64_t bitfield);
int iax2_codec_pref_format_bitfield_to_order_value(uint64_t bitfield);
/*!
* \brief Codec located at a particular place in the preference index.
@ -70,8 +70,32 @@ uint64_t iax2_codec_pref_format_bitfield_to_order_value(uint64_t bitfield);
*/
struct ast_format *iax2_codec_pref_index(struct iax2_codec_pref *pref, int index, struct ast_format **result);
/*! \brief Convert a preference structure to a capabilities structure */
void iax2_codec_pref_to_cap(struct iax2_codec_pref *pref, struct ast_format_cap *cap);
/*!
* \brief Convert a preference structure to a capabilities structure.
*
* \param pref Formats in preference order to build the capabilities.
* \param cap Capabilities structure to place formats into
*
* \retval 0 on success.
* \retval -1 on error.
*
* \note If failure occurs the capabilities structure may contain a partial set of formats
*/
int iax2_codec_pref_to_cap(struct iax2_codec_pref *pref, struct ast_format_cap *cap);
/*!
* \brief Convert a bitfield to a format capabilities structure in the "best" order.
*
* \param bitfield The bitfield for the media formats
* \param prefs Format preference order to use as a guide. (May be NULL)
* \param cap Capabilities structure to place formats into
*
* \retval 0 on success.
* \retval -1 on error.
*
* \note If failure occurs the capabilities structure may contain a partial set of formats
*/
int iax2_codec_pref_best_bitfield2cap(uint64_t bitfield, struct iax2_codec_pref *prefs, struct ast_format_cap *cap);
/*! \brief Removes format from the pref list that aren't in the bitfield */
void iax2_codec_pref_remove_missing(struct iax2_codec_pref *pref, uint64_t bitfield);
@ -94,21 +118,13 @@ int iax2_codec_pref_string(struct iax2_codec_pref *pref, char *buf, size_t size)
/*! \brief Append a audio codec to a preference list, removing it first if it was already there
*/
int iax2_codec_pref_append(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing);
void iax2_codec_pref_append(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing);
/*! \brief Prepend an audio codec to a preference list, removing it first if it was already there
*/
void iax2_codec_pref_prepend(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing,
int only_if_existing);
/*! \brief Get packet size for codec
*/
unsigned int iax2_codec_pref_getsize(struct iax2_codec_pref *pref, int index);
/*! \brief Set packet size for codec
*/
int iax2_codec_pref_setsize(struct iax2_codec_pref *pref, struct ast_format *format, int framems);
/*! \brief Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string
* \note Due to a misunderstanding in how codec preferences are stored, this
* list starts at 'B', not 'A'. For backwards compatibility reasons, this
@ -120,4 +136,15 @@ int iax2_codec_pref_setsize(struct iax2_codec_pref *pref, struct ast_format *for
*/
void iax2_codec_pref_convert(struct iax2_codec_pref *pref, char *buf, size_t size, int right);
/*!
* \brief Create codec preference list from the given bitfield formats.
* \since 13.0.0
*
* \param pref Codec preference list to setup from the given bitfield.
* \param bitfield Format bitfield to guide preference list creation.
*
* \return Updated bitfield with any bits not mapped to a format cleared.
*/
uint64_t iax2_codec_pref_from_bitfield(struct iax2_codec_pref *pref, uint64_t bitfield);
#endif /* _IAX2_CODEC_PREF_H_ */

14
channels/iax2/include/format_compatibility.h
Unescape View File

@ -45,11 +45,21 @@ uint64_t iax2_format_compatibility_cap2bitfield(const struct ast_format_cap *cap
* \param bitfield The bitfield for the media formats
* \param cap Capabilities structure to place formats into
*
* \retval non-NULL success
* \retval NULL failure
* \retval 0 on success.
* \retval -1 on error.
*
* \note If failure occurs the capabilities structure may contain a partial set of formats
*/
int iax2_format_compatibility_bitfield2cap(uint64_t bitfield, struct ast_format_cap *cap);
/*!
* \brief Pick the best format from the given bitfield formats.
*
* \param formats The bitfield for the media formats
*
* \retval non-zero Best format out of the given formats.
* \retval zero No formats present or no formats considered best.
*/
uint64_t iax2_format_compatibility_best(uint64_t formats);
#endif /* _IAX2_FORMAT_COMPATIBILITY_H */

2
include/asterisk/format_compatibility.h
Unescape View File

@ -120,7 +120,7 @@ uint64_t ast_format_compatibility_codec2bitfield(const struct ast_codec *codec);
* \param bitfield The bitfield for the media format
*
* \retval non-NULL success
* \retval NULL failure
* \retval NULL failure (The format bitfield value is not supported)
*
* \note The reference count of the returned format is NOT incremented
*/

2
main/format_compatibility.c
Unescape View File

@ -269,6 +269,6 @@ struct ast_format *ast_format_compatibility_bitfield2format(uint64_t bitfield)
case AST_FORMAT_T140:
return ast_format_t140_red;
}
return 0;
return NULL;
}

Write Preview
Loading…
Cancel
Save