/*
* Parse address
*/
PJ_DEF(pj_status_t) pj_sockaddr_parse( int af, unsigned options,
const pj_str_t *str,
pj_sockaddr *addr)
{
pj_str_t hostpart;
pj_uint16_t port;
pj_status_t status;
PJ_ASSERT_RETURN(addr, PJ_EINVAL);
PJ_ASSERT_RETURN(af==PJ_AF_UNSPEC ||
af==PJ_AF_INET ||
af==PJ_AF_INET6, PJ_EINVAL);
PJ_ASSERT_RETURN(options == 0, PJ_EINVAL);
status = pj_sockaddr_parse2(af, options, str, &hostpart, &port, &af);
if (status != PJ_SUCCESS)
return status;
#if !defined(PJ_HAS_IPV6) || !PJ_HAS_IPV6
if (af==PJ_AF_INET6)
return PJ_EIPV6NOTSUP;
#endif
status = pj_sockaddr_init(af, addr, &hostpart, port);
#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6
if (status != PJ_SUCCESS && af == PJ_AF_INET6) {
/* Parsing does not yield valid address. Try to treat the last
* portion after the colon as port number.
*/
const char *last_colon_pos=NULL, *p;
const char *end = str->ptr + str->slen;
unsigned long long_port;
pj_str_t port_part;
int i;
/* Parse as IPv6:port */
for (p=str->ptr; p!=end; ++p) {
if (*p == ':')
last_colon_pos = p;
}
if (last_colon_pos == NULL)
return status;
hostpart.ptr = (char*)str->ptr;
hostpart.slen = last_colon_pos - str->ptr;
port_part.ptr = (char*)last_colon_pos + 1;
port_part.slen = end - port_part.ptr;
/* Make sure port number is valid */
for (i=0; i<port_part.slen; ++i) {
if (!pj_isdigit(port_part.ptr[i]))
return status;
}
long_port = pj_strtoul(&port_part);
if (long_port > 65535)
return status;
port = (pj_uint16_t)long_port;
status = pj_sockaddr_init(PJ_AF_INET6, addr, &hostpart, port);
}
#endif
return status;
}
/* Update single local media description to after receiving answer
* from remote.
*/
static pj_status_t process_m_answer( pj_pool_t *pool,
pjmedia_sdp_media *offer,
pjmedia_sdp_media *answer,
pj_bool_t allow_asym)
{
unsigned i;
/* Check that the media type match our offer. */
if (pj_strcmp(&answer->desc.media, &offer->desc.media)!=0) {
/* The media type in the answer is different than the offer! */
return PJMEDIA_SDPNEG_EINVANSMEDIA;
}
/* Check that transport in the answer match our offer. */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
if (pjmedia_sdp_transport_cmp(&answer->desc.transport,
&offer->desc.transport)
!= PJ_SUCCESS)
{
return PJMEDIA_SDPNEG_EINVANSTP;
}
/* Check if remote has rejected our offer */
if (answer->desc.port == 0) {
/* Remote has rejected our offer.
* Deactivate our media too.
*/
pjmedia_sdp_media_deactivate(pool, offer);
/* Don't need to proceed */
return PJ_SUCCESS;
}
/* Ticket #1148: check if remote answer does not set port to zero when
* offered with port zero. Let's just tolerate it.
*/
if (offer->desc.port == 0) {
/* Don't need to proceed */
return PJ_SUCCESS;
}
/* Process direction attributes */
update_media_direction(pool, answer, offer);
/* If asymetric media is allowed, then just check that remote answer has
* codecs that are within the offer.
*
* Otherwise if asymetric media is not allowed, then we will choose only
* one codec in our initial offer to match the answer.
*/
if (allow_asym) {
for (i=0; i<answer->desc.fmt_count; ++i) {
unsigned j;
pj_str_t *rem_fmt = &answer->desc.fmt[i];
for (j=0; j<offer->desc.fmt_count; ++j) {
if (pj_strcmp(rem_fmt, &answer->desc.fmt[j])==0)
break;
}
if (j != offer->desc.fmt_count) {
/* Found at least one common codec. */
break;
}
}
if (i == answer->desc.fmt_count) {
/* No common codec in the answer! */
return PJMEDIA_SDPNEG_EANSNOMEDIA;
}
PJ_TODO(CHECK_SDP_NEGOTIATION_WHEN_ASYMETRIC_MEDIA_IS_ALLOWED);
} else {
/* Offer format priority based on answer format index/priority */
unsigned offer_fmt_prior[PJMEDIA_MAX_SDP_FMT];
/* Remove all format in the offer that has no matching answer */
for (i=0; i<offer->desc.fmt_count;) {
unsigned pt;
pj_uint32_t j;
pj_str_t *fmt = &offer->desc.fmt[i];
/* Find matching answer */
pt = pj_strtoul(fmt);
if (pt < 96) {
for (j=0; j<answer->desc.fmt_count; ++j) {
if (pj_strcmp(fmt, &answer->desc.fmt[j])==0)
break;
}
} else {
/* This is dynamic payload type.
* For dynamic payload type, we must look the rtpmap and
* compare the encoding name.
*/
const pjmedia_sdp_attr *a;
pjmedia_sdp_rtpmap or_;
/* Get the rtpmap for the payload type in the offer. */
a = pjmedia_sdp_media_find_attr2(offer, "rtpmap", fmt);
if (!a) {
pj_assert(!"Bug! Offer should have been validated");
return PJ_EBUG;
}
pjmedia_sdp_attr_get_rtpmap(a, &or_);
/* Find paylaod in answer SDP with matching
* encoding name and clock rate.
*/
for (j=0; j<answer->desc.fmt_count; ++j) {
a = pjmedia_sdp_media_find_attr2(answer, "rtpmap",
&answer->desc.fmt[j]);
if (a) {
pjmedia_sdp_rtpmap ar;
pjmedia_sdp_attr_get_rtpmap(a, &ar);
/* See if encoding name, clock rate, and channel
* count match
*/
if (!pj_stricmp(&or_.enc_name, &ar.enc_name) &&
or_.clock_rate == ar.clock_rate &&
(pj_stricmp(&or_.param, &ar.param)==0 ||
(ar.param.slen==1 && *ar.param.ptr=='1')))
{
/* Call custom format matching callbacks */
if (custom_fmt_match(pool, &or_.enc_name,
offer, i, answer, j, 0) ==
PJ_SUCCESS)
{
/* Match! */
break;
}
}
}
}
}
if (j == answer->desc.fmt_count) {
/* This format has no matching answer.
* Remove it from our offer.
*/
pjmedia_sdp_attr *a;
/* Remove rtpmap associated with this format */
a = pjmedia_sdp_media_find_attr2(offer, "rtpmap", fmt);
if (a)
pjmedia_sdp_media_remove_attr(offer, a);
/* Remove fmtp associated with this format */
a = pjmedia_sdp_media_find_attr2(offer, "fmtp", fmt);
if (a)
pjmedia_sdp_media_remove_attr(offer, a);
/* Remove this format from offer's array */
pj_array_erase(offer->desc.fmt, sizeof(offer->desc.fmt[0]),
offer->desc.fmt_count, i);
--offer->desc.fmt_count;
} else {
offer_fmt_prior[i] = j;
++i;
}
}
if (0 == offer->desc.fmt_count) {
/* No common codec in the answer! */
return PJMEDIA_SDPNEG_EANSNOMEDIA;
}
/* Post process:
* - Resort offer formats so the order match to the answer.
* - Remove answer formats that unmatches to the offer.
*/
/* Resort offer formats */
for (i=0; i<offer->desc.fmt_count; ++i) {
unsigned j;
for (j=i+1; j<offer->desc.fmt_count; ++j) {
if (offer_fmt_prior[i] > offer_fmt_prior[j]) {
unsigned tmp = offer_fmt_prior[i];
offer_fmt_prior[i] = offer_fmt_prior[j];
offer_fmt_prior[j] = tmp;
str_swap(&offer->desc.fmt[i], &offer->desc.fmt[j]);
}
}
}
/* Remove unmatched answer formats */
{
unsigned del_cnt = 0;
for (i=0; i<answer->desc.fmt_count;) {
/* The offer is ordered now, also the offer_fmt_prior */
if (i >= offer->desc.fmt_count ||
offer_fmt_prior[i]-del_cnt != i)
{
pj_str_t *fmt = &answer->desc.fmt[i];
pjmedia_sdp_attr *a;
/* Remove rtpmap associated with this format */
a = pjmedia_sdp_media_find_attr2(answer, "rtpmap", fmt);
if (a)
pjmedia_sdp_media_remove_attr(answer, a);
/* Remove fmtp associated with this format */
a = pjmedia_sdp_media_find_attr2(answer, "fmtp", fmt);
if (a)
pjmedia_sdp_media_remove_attr(answer, a);
/* Remove this format from answer's array */
pj_array_erase(answer->desc.fmt,
sizeof(answer->desc.fmt[0]),
answer->desc.fmt_count, i);
--answer->desc.fmt_count;
++del_cnt;
} else {
++i;
}
}
}
}
/* Looks okay */
return PJ_SUCCESS;
}
/*
* Internal function for collecting codec info and param from the SDP media.
*/
static pj_status_t get_video_codec_info_param(pjmedia_vid_stream_info *si,
pj_pool_t *pool,
pjmedia_vid_codec_mgr *mgr,
const pjmedia_sdp_media *local_m,
const pjmedia_sdp_media *rem_m)
{
unsigned pt = 0;
const pjmedia_vid_codec_info *p_info;
pj_status_t status;
pt = pj_strtoul(&local_m->desc.fmt[0]);
/* Get payload type for receiving direction */
si->rx_pt = pt;
/* Get codec info and payload type for transmitting direction. */
if (pt < 96) {
/* For static payload types, get the codec info from codec manager. */
status = pjmedia_vid_codec_mgr_get_codec_info(mgr, pt, &p_info);
if (status != PJ_SUCCESS)
return status;
si->codec_info = *p_info;
/* Get payload type for transmitting direction.
* For static payload type, pt's are symetric.
*/
si->tx_pt = pt;
} else {
const pjmedia_sdp_attr *attr;
pjmedia_sdp_rtpmap *rtpmap;
pjmedia_codec_id codec_id;
pj_str_t codec_id_st;
unsigned i;
/* Determine payload type for outgoing channel, by finding
* dynamic payload type in remote SDP that matches the answer.
*/
si->tx_pt = 0xFFFF;
for (i=0; i<rem_m->desc.fmt_count; ++i) {
if (pjmedia_sdp_neg_fmt_match(NULL,
(pjmedia_sdp_media*)local_m, 0,
(pjmedia_sdp_media*)rem_m, i, 0) ==
PJ_SUCCESS)
{
/* Found matched codec. */
si->tx_pt = pj_strtoul(&rem_m->desc.fmt[i]);
break;
}
}
if (si->tx_pt == 0xFFFF)
return PJMEDIA_EMISSINGRTPMAP;
/* For dynamic payload types, get codec name from the rtpmap */
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[0]);
if (attr == NULL)
return PJMEDIA_EMISSINGRTPMAP;
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
return status;
/* Then get the codec info from the codec manager */
pj_ansi_snprintf(codec_id, sizeof(codec_id), "%.*s/",
(int)rtpmap->enc_name.slen, rtpmap->enc_name.ptr);
codec_id_st = pj_str(codec_id);
i = 1;
status = pjmedia_vid_codec_mgr_find_codecs_by_id(mgr, &codec_id_st,
&i, &p_info, NULL);
if (status != PJ_SUCCESS)
return status;
si->codec_info = *p_info;
}
/* Request for codec with the correct packing for streaming */
si->codec_info.packings = PJMEDIA_VID_PACKING_PACKETS;
/* Now that we have codec info, get the codec param. */
si->codec_param = PJ_POOL_ALLOC_T(pool, pjmedia_vid_codec_param);
status = pjmedia_vid_codec_mgr_get_default_param(mgr,
&si->codec_info,
si->codec_param);
/* Adjust encoding bitrate, if higher than remote preference. The remote
* bitrate preference is read from SDP "b=TIAS" line in media level.
*/
if ((si->dir & PJMEDIA_DIR_ENCODING) && rem_m->bandw_count) {
unsigned i, bandw = 0;
for (i = 0; i < rem_m->bandw_count; ++i) {
const pj_str_t STR_BANDW_MODIFIER_TIAS = { "TIAS", 4 };
if (!pj_stricmp(&rem_m->bandw[i]->modifier,
&STR_BANDW_MODIFIER_TIAS))
{
bandw = rem_m->bandw[i]->value;
break;
}
}
if (bandw) {
pjmedia_video_format_detail *enc_vfd;
enc_vfd = pjmedia_format_get_video_format_detail(
&si->codec_param->enc_fmt, PJ_TRUE);
if (!enc_vfd->avg_bps || enc_vfd->avg_bps > bandw)
enc_vfd->avg_bps = bandw * 3 / 4;
if (!enc_vfd->max_bps || enc_vfd->max_bps > bandw)
enc_vfd->max_bps = bandw;
}
}
/* Get remote fmtp for our encoder. */
pjmedia_stream_info_parse_fmtp(pool, rem_m, si->tx_pt,
&si->codec_param->enc_fmtp);
/* Get local fmtp for our decoder. */
pjmedia_stream_info_parse_fmtp(pool, local_m, si->rx_pt,
&si->codec_param->dec_fmtp);
/* When direction is NONE (it means SDP negotiation has failed) we don't
* need to return a failure here, as returning failure will cause
* the whole SDP to be rejected. See ticket #:
* http://
*
* Thanks Alain Totouom
*/
if (status != PJ_SUCCESS && si->dir != PJMEDIA_DIR_NONE)
return status;
return PJ_SUCCESS;
}
/*
* Parse address
*/
PJ_DEF(pj_status_t) pj_sockaddr_parse2(int af, unsigned options,
const pj_str_t *str,
pj_str_t *p_hostpart,
pj_uint16_t *p_port,
int *raf)
{
const char *end = str->ptr + str->slen;
const char *last_colon_pos = NULL;
unsigned colon_cnt = 0;
const char *p;
PJ_ASSERT_RETURN((af==PJ_AF_INET || af==PJ_AF_INET6 || af==PJ_AF_UNSPEC) &&
options==0 &&
str!=NULL, PJ_EINVAL);
/* Special handling for empty input */
if (str->slen==0 || str->ptr==NULL) {
if (p_hostpart)
p_hostpart->slen = 0;
if (p_port)
*p_port = 0;
if (raf)
*raf = PJ_AF_INET;
return PJ_SUCCESS;
}
/* Count the colon and get the last colon */
for (p=str->ptr; p!=end; ++p) {
if (*p == ':') {
++colon_cnt;
last_colon_pos = p;
}
}
/* Deduce address family if it's not given */
if (af == PJ_AF_UNSPEC) {
if (colon_cnt > 1)
af = PJ_AF_INET6;
else
af = PJ_AF_INET;
} else if (af == PJ_AF_INET && colon_cnt > 1)
return PJ_EINVAL;
if (raf)
*raf = af;
if (af == PJ_AF_INET) {
/* Parse as IPv4. Supported formats:
* - "10.0.0.1:80"
* - "10.0.0.1"
* - "10.0.0.1:"
* - ":80"
* - ":"
*/
pj_str_t hostpart;
unsigned long port;
hostpart.ptr = (char*)str->ptr;
if (last_colon_pos) {
pj_str_t port_part;
int i;
hostpart.slen = last_colon_pos - str->ptr;
port_part.ptr = (char*)last_colon_pos + 1;
port_part.slen = end - port_part.ptr;
/* Make sure port number is valid */
for (i=0; i<port_part.slen; ++i) {
if (!pj_isdigit(port_part.ptr[i]))
return PJ_EINVAL;
}
port = pj_strtoul(&port_part);
if (port > 65535)
return PJ_EINVAL;
} else {
hostpart.slen = str->slen;
port = 0;
}
if (p_hostpart)
*p_hostpart = hostpart;
if (p_port)
*p_port = (pj_uint16_t)port;
return PJ_SUCCESS;
} else if (af == PJ_AF_INET6) {
/* Parse as IPv6. Supported formats:
* - "fe::01:80" ==> note: port number is zero in this case, not 80!
* - "[fe::01]:80"
* - "fe::01"
* - "fe::01:"
* - "[fe::01]"
* - "[fe::01]:"
* - "[::]:80"
* - ":::80"
* - "[::]"
* - "[::]:"
* - ":::"
* - "::"
*/
pj_str_t hostpart, port_part;
if (*str->ptr == '[') {
char *end_bracket;
int i;
unsigned long port;
if (last_colon_pos == NULL)
return PJ_EINVAL;
end_bracket = pj_strchr(str, ']');
if (end_bracket == NULL)
return PJ_EINVAL;
hostpart.ptr = (char*)str->ptr + 1;
hostpart.slen = end_bracket - hostpart.ptr;
if (last_colon_pos < end_bracket) {
port_part.ptr = NULL;
port_part.slen = 0;
} else {
port_part.ptr = (char*)last_colon_pos + 1;
port_part.slen = end - port_part.ptr;
}
/* Make sure port number is valid */
for (i=0; i<port_part.slen; ++i) {
if (!pj_isdigit(port_part.ptr[i]))
return PJ_EINVAL;
}
port = pj_strtoul(&port_part);
if (port > 65535)
return PJ_EINVAL;
if (p_hostpart)
*p_hostpart = hostpart;
if (p_port)
*p_port = (pj_uint16_t)port;
return PJ_SUCCESS;
} else {
/* Treat everything as part of the IPv6 IP address */
if (p_hostpart)
*p_hostpart = *str;
if (p_port)
*p_port = 0;
return PJ_SUCCESS;
}
} else {
return PJ_EAFNOTSUP;
}
}
/*
* Create PRACK request for the incoming reliable provisional response.
*/
PJ_DEF(pj_status_t) pjsip_100rel_create_prack( pjsip_inv_session *inv,
pjsip_rx_data *rdata,
pjsip_tx_data **p_tdata)
{
dlg_data *dd;
uac_state_t *uac_state = NULL;
const pj_str_t *to_tag = &rdata->msg_info.to->tag;
pjsip_transaction *tsx;
pjsip_msg *msg;
pjsip_generic_string_hdr *rseq_hdr;
pjsip_generic_string_hdr *rack_hdr;
unsigned rseq;
pj_str_t rack;
char rack_buf[80];
pjsip_tx_data *tdata;
pj_status_t status;
*p_tdata = NULL;
dd = (dlg_data*) inv->dlg->mod_data[mod_100rel.mod.id];
PJ_ASSERT_RETURN(dd != NULL, PJSIP_ENOTINITIALIZED);
tsx = pjsip_rdata_get_tsx(rdata);
msg = rdata->msg_info.msg;
/* Check our assumptions */
pj_assert( tsx->role == PJSIP_ROLE_UAC &&
tsx->method.id == PJSIP_INVITE_METHOD &&
msg->line.status.code > 100 &&
msg->line.status.code < 200);
/* Get the RSeq header */
rseq_hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(msg, &RSEQ, NULL);
if (rseq_hdr == NULL) {
PJ_LOG(4,(dd->inv->dlg->obj_name,
"Ignoring 100rel response with no RSeq header"));
return PJSIP_EMISSINGHDR;
}
rseq = (pj_uint32_t) pj_strtoul(&rseq_hdr->hvalue);
/* Find UAC state for the specified call leg */
uac_state = dd->uac_state_list;
while (uac_state) {
if (pj_stricmp(&uac_state->tag, to_tag)==0)
break;
uac_state = uac_state->next;
}
/* Create new UAC state if we don't have one */
if (uac_state == NULL) {
uac_state = PJ_POOL_ZALLOC_T(dd->inv->dlg->pool, uac_state_t);
uac_state->cseq = rdata->msg_info.cseq->cseq;
uac_state->rseq = rseq - 1;
pj_strdup(dd->inv->dlg->pool, &uac_state->tag, to_tag);
uac_state->next = dd->uac_state_list;
dd->uac_state_list = uac_state;
}
/* If this is from new INVITE transaction, reset UAC state. */
if (rdata->msg_info.cseq->cseq != uac_state->cseq) {
uac_state->cseq = rdata->msg_info.cseq->cseq;
uac_state->rseq = rseq - 1;
}
/* Ignore provisional response retransmission */
if (rseq <= uac_state->rseq) {
/* This should have been handled before */
return PJ_EIGNORED;
/* Ignore provisional response with out-of-order RSeq */
} else if (rseq != uac_state->rseq + 1) {
PJ_LOG(4,(dd->inv->dlg->obj_name,
"Ignoring 100rel response because RSeq jump "
"(expecting %u, got %u)",
uac_state->rseq+1, rseq));
return PJ_EIGNORED;
}
/* Update our RSeq */
uac_state->rseq = rseq;
/* Create PRACK */
status = pjsip_dlg_create_request(dd->inv->dlg, &pjsip_prack_method,
-1, &tdata);
if (status != PJ_SUCCESS)
return status;
/* If this response is a forked response from a different call-leg,
* update the req URI (https://trac.pjsip.org/repos/ticket/1364)
*/
if (pj_stricmp(&uac_state->tag, &dd->inv->dlg->remote.info->tag)) {
const pjsip_contact_hdr *mhdr;
mhdr = (const pjsip_contact_hdr*)
pjsip_msg_find_hdr(rdata->msg_info.msg,
PJSIP_H_CONTACT, NULL);
if (!mhdr || !mhdr->uri) {
PJ_LOG(4,(dd->inv->dlg->obj_name,
"Ignoring 100rel response with no or "
"invalid Contact header"));
pjsip_tx_data_dec_ref(tdata);
return PJ_EIGNORED;
}
tdata->msg->line.req.uri = (pjsip_uri*)
pjsip_uri_clone(tdata->pool, mhdr->uri);
}
/* Create RAck header */
rack.ptr = rack_buf;
rack.slen = pj_ansi_snprintf(rack.ptr, sizeof(rack_buf),
"%u %u %.*s",
rseq, rdata->msg_info.cseq->cseq,
(int)tsx->method.name.slen,
tsx->method.name.ptr);
if (rack.slen < 1 || rack.slen >= (int)sizeof(rack_buf)) {
return PJ_ETOOSMALL;
}
rack_hdr = pjsip_generic_string_hdr_create(tdata->pool, &RACK, &rack);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) rack_hdr);
/* Done */
*p_tdata = tdata;
return PJ_SUCCESS;
}
/*
* Create stream info from SDP media line.
*/
PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_endpt *endpt,
const pjmedia_sdp_session *local,
const pjmedia_sdp_session *remote,
unsigned stream_idx)
{
pjmedia_codec_mgr *mgr;
const pjmedia_sdp_attr *attr;
const pjmedia_sdp_media *local_m;
const pjmedia_sdp_media *rem_m;
const pjmedia_sdp_conn *local_conn;
const pjmedia_sdp_conn *rem_conn;
int rem_af, local_af;
pj_sockaddr local_addr;
pjmedia_sdp_rtpmap *rtpmap;
unsigned i, pt, fmti;
pj_status_t status;
/* Validate arguments: */
PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
/* Get codec manager. */
mgr = pjmedia_endpt_get_codec_mgr(endpt);
/* Keep SDP shortcuts */
local_m = local->media[stream_idx];
rem_m = remote->media[stream_idx];
local_conn = local_m->conn ? local_m->conn : local->conn;
if (local_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
if (rem_conn == NULL)
return PJMEDIA_SDP_EMISSINGCONN;
/* Reset: */
pj_bzero(si, sizeof(*si));
#if PJMEDIA_HAS_RTCP_XR && PJMEDIA_STREAM_ENABLE_XR
/* Set default RTCP XR enabled/disabled */
si->rtcp_xr_enabled = PJ_TRUE;
#endif
/* Media type: */
if (pj_stricmp(&local_m->desc.media, &ID_AUDIO) == 0) {
si->type = PJMEDIA_TYPE_AUDIO;
} else if (pj_stricmp(&local_m->desc.media, &ID_VIDEO) == 0) {
si->type = PJMEDIA_TYPE_VIDEO;
} else {
si->type = PJMEDIA_TYPE_UNKNOWN;
/* Avoid rejecting call because of unrecognized media,
* just return PJ_SUCCESS, this media will be deactivated later.
*/
//return PJMEDIA_EINVALIMEDIATYPE;
return PJ_SUCCESS;
}
/* Transport protocol */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport,
&local_m->desc.transport);
if (status != PJ_SUCCESS)
return PJMEDIA_SDPNEG_EINVANSTP;
if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
} else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
} else {
si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
return PJ_SUCCESS;
}
/* Check address family in remote SDP */
rem_af = pj_AF_UNSPEC();
if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
rem_af = pj_AF_INET();
} else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
rem_af = pj_AF_INET6();
}
}
if (rem_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_EAFNOTSUP;
}
/* Set remote address: */
status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr,
rem_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Check address family of local info */
local_af = pj_AF_UNSPEC();
if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
local_af = pj_AF_INET();
} else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
local_af = pj_AF_INET6();
}
}
if (local_af==pj_AF_UNSPEC()) {
/* Unsupported address family */
return PJ_SUCCESS;
}
/* Set remote address: */
status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr,
local_m->desc.port);
if (status != PJ_SUCCESS) {
/* Invalid IP address. */
return PJMEDIA_EINVALIDIP;
}
/* Local and remote address family must match */
if (local_af != rem_af)
return PJ_EAFNOTSUP;
/* Media direction: */
if (local_m->desc.port == 0 ||
pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
{
/* Inactive stream. */
si->dir = PJMEDIA_DIR_NONE;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
/* Send only stream. */
si->dir = PJMEDIA_DIR_ENCODING;
} else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
/* Recv only stream. */
si->dir = PJMEDIA_DIR_DECODING;
} else {
/* Send and receive stream. */
si->dir = PJMEDIA_DIR_ENCODING_DECODING;
}
/* No need to do anything else if stream is rejected */
if (local_m->desc.port == 0) {
return PJ_SUCCESS;
}
/* If "rtcp" attribute is present in the SDP, set the RTCP address
* from that attribute. Otherwise, calculate from RTP address.
*/
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"rtcp", NULL);
if (attr) {
pjmedia_sdp_rtcp_attr rtcp;
status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
if (status == PJ_SUCCESS) {
if (rtcp.addr.slen) {
status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
(pj_uint16_t)rtcp.port);
} else {
pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL,
(pj_uint16_t)rtcp.port);
pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
pj_sockaddr_get_addr(&si->rem_addr),
pj_sockaddr_get_addr_len(&si->rem_addr));
}
}
}
if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
int rtcp_port;
pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
}
/* Get the payload number for receive channel. */
/*
Previously we used to rely on fmt[0] being the selected codec,
but some UA sends telephone-event as fmt[0] and this would
cause assert failure below.
Thanks Chris Hamilton <chamilton .at. cs.dal.ca> for this patch.
// And codec must be numeric!
if (!pj_isdigit(*local_m->desc.fmt[0].ptr) ||
!pj_isdigit(*rem_m->desc.fmt[0].ptr))
{
return PJMEDIA_EINVALIDPT;
}
pt = pj_strtoul(&local_m->desc.fmt[0]);
pj_assert(PJMEDIA_RTP_PT_TELEPHONE_EVENTS==0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS);
*/
/* This is to suppress MSVC warning about uninitialized var */
pt = 0;
/* Find the first codec which is not telephone-event */
for ( fmti = 0; fmti < local_m->desc.fmt_count; ++fmti ) {
if ( !pj_isdigit(*local_m->desc.fmt[fmti].ptr) )
return PJMEDIA_EINVALIDPT;
pt = pj_strtoul(&local_m->desc.fmt[fmti]);
if ( PJMEDIA_RTP_PT_TELEPHONE_EVENTS == 0 ||
pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS )
break;
}
if ( fmti >= local_m->desc.fmt_count )
return PJMEDIA_EINVALIDPT;
/* Get codec info.
* For static payload types, get the info from codec manager.
* For dynamic payload types, MUST get the rtpmap.
*/
if (pt < 96) {
pj_bool_t has_rtpmap;
rtpmap = NULL;
has_rtpmap = PJ_TRUE;
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL) {
has_rtpmap = PJ_FALSE;
}
if (attr != NULL) {
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
has_rtpmap = PJ_FALSE;
}
/* Build codec format info: */
if (has_rtpmap) {
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
si->fmt.clock_rate = rtpmap->clock_rate;
#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG != 0)
/* The session info should have the actual clock rate, because
* this info is used for calculationg buffer size, etc in stream
*/
if (si->fmt.pt == PJMEDIA_RTP_PT_G722)
si->fmt.clock_rate = 16000;
#endif
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
} else {
const pjmedia_codec_info *p_info;
status = pjmedia_codec_mgr_get_codec_info( mgr, pt, &p_info);
if (status != PJ_SUCCESS)
return status;
pj_memcpy(&si->fmt, p_info, sizeof(pjmedia_codec_info));
}
/* For static payload type, pt's are symetric */
si->tx_pt = pt;
} else {
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL)
return PJMEDIA_EMISSINGRTPMAP;
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
return status;
/* Build codec format info: */
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
si->fmt.clock_rate = rtpmap->clock_rate;
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
/* Determine payload type for outgoing channel, by finding
* dynamic payload type in remote SDP that matches the answer.
*/
si->tx_pt = 0xFFFF;
for (i=0; i<rem_m->desc.fmt_count; ++i) {
unsigned rpt;
pjmedia_sdp_attr *r_attr;
pjmedia_sdp_rtpmap r_rtpmap;
rpt = pj_strtoul(&rem_m->desc.fmt[i]);
if (rpt < 96)
continue;
r_attr = pjmedia_sdp_media_find_attr(rem_m, &ID_RTPMAP,
&rem_m->desc.fmt[i]);
if (!r_attr)
continue;
if (pjmedia_sdp_attr_get_rtpmap(r_attr, &r_rtpmap) != PJ_SUCCESS)
continue;
if (!pj_stricmp(&rtpmap->enc_name, &r_rtpmap.enc_name) &&
rtpmap->clock_rate == r_rtpmap.clock_rate)
{
/* Found matched codec. */
si->tx_pt = rpt;
break;
}
}
if (si->tx_pt == 0xFFFF)
return PJMEDIA_EMISSINGRTPMAP;
}
/* Now that we have codec info, get the codec param. */
si->param = PJ_POOL_ALLOC_T(pool, pjmedia_codec_param);
status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt, si->param);
/* Get remote fmtp for our encoder. */
parse_fmtp(pool, rem_m, si->tx_pt, &si->param->setting.enc_fmtp);
/* Get local fmtp for our decoder. */
parse_fmtp(pool, local_m, si->fmt.pt, &si->param->setting.dec_fmtp);
/* Get remote maxptime for our encoder. */
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"maxptime", NULL);
if (attr) {
pj_str_t tmp_val = attr->value;
pj_strltrim(&tmp_val);
si->tx_maxptime = pj_strtoul(&tmp_val);
}
/* When direction is NONE (it means SDP negotiation has failed) we don't
* need to return a failure here, as returning failure will cause
* the whole SDP to be rejected. See ticket #:
* http://
*
* Thanks Alain Totouom
*/
if (status != PJ_SUCCESS && si->dir != PJMEDIA_DIR_NONE)
return status;
/* Get incomming payload type for telephone-events */
si->rx_event_pt = -1;
for (i=0; i<local_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = local_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->rx_event_pt = pj_strtoul(&r.pt);
break;
}
}
/* Get outgoing payload type for telephone-events */
si->tx_event_pt = -1;
for (i=0; i<rem_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = rem_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->tx_event_pt = pj_strtoul(&r.pt);
break;
}
}
/* Leave SSRC to random. */
si->ssrc = pj_rand();
/* Set default jitter buffer parameter. */
si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
return PJ_SUCCESS;
}
static void get_codecs(struct ast_sip_session *session, const struct pjmedia_sdp_media *stream, struct ast_rtp_codecs *codecs,
struct ast_sip_session_media *session_media)
{
pjmedia_sdp_attr *attr;
pjmedia_sdp_rtpmap *rtpmap;
pjmedia_sdp_fmtp fmtp;
struct ast_format *format;
int i, num = 0, tel_event = 0;
char name[256];
char media[20];
char fmt_param[256];
enum ast_rtp_options options = session->endpoint->media.g726_non_standard ?
AST_RTP_OPT_G726_NONSTANDARD : 0;
ast_rtp_codecs_payloads_initialize(codecs);
/* Iterate through provided formats */
for (i = 0; i < stream->desc.fmt_count; ++i) {
/* The payload is kept as a string for things like t38 but for video it is always numerical */
ast_rtp_codecs_payloads_set_m_type(codecs, NULL, pj_strtoul(&stream->desc.fmt[i]));
/* Look for the optional rtpmap attribute */
if (!(attr = pjmedia_sdp_media_find_attr2(stream, "rtpmap", &stream->desc.fmt[i]))) {
continue;
}
/* Interpret the attribute as an rtpmap */
if ((pjmedia_sdp_attr_to_rtpmap(session->inv_session->pool_prov, attr, &rtpmap)) != PJ_SUCCESS) {
continue;
}
ast_copy_pj_str(name, &rtpmap->enc_name, sizeof(name));
if (strcmp(name, "telephone-event") == 0) {
tel_event++;
}
ast_copy_pj_str(media, (pj_str_t*)&stream->desc.media, sizeof(media));
ast_rtp_codecs_payloads_set_rtpmap_type_rate(codecs, NULL,
pj_strtoul(&stream->desc.fmt[i]), media, name, options, rtpmap->clock_rate);
/* Look for an optional associated fmtp attribute */
if (!(attr = pjmedia_sdp_media_find_attr2(stream, "fmtp", &rtpmap->pt))) {
continue;
}
if ((pjmedia_sdp_attr_get_fmtp(attr, &fmtp)) == PJ_SUCCESS) {
ast_copy_pj_str(fmt_param, &fmtp.fmt, sizeof(fmt_param));
if (sscanf(fmt_param, "%30d", &num) != 1) {
continue;
}
if ((format = ast_rtp_codecs_get_payload_format(codecs, num))) {
struct ast_format *format_parsed;
ast_copy_pj_str(fmt_param, &fmtp.fmt_param, sizeof(fmt_param));
format_parsed = ast_format_parse_sdp_fmtp(format, fmt_param);
if (format_parsed) {
ast_rtp_codecs_payload_replace_format(codecs, num, format_parsed);
ao2_ref(format_parsed, -1);
}
ao2_ref(format, -1);
}
}
}
if (!tel_event && (session->endpoint->dtmf == AST_SIP_DTMF_AUTO)) {
ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_INBAND);
}
/* Get the packetization, if it exists */
if ((attr = pjmedia_sdp_media_find_attr2(stream, "ptime", NULL))) {
unsigned long framing = pj_strtoul(pj_strltrim(&attr->value));
if (framing && session->endpoint->media.rtp.use_ptime) {
ast_rtp_codecs_set_framing(codecs, framing);
}
}
}
/*
* Internal function for collecting codec info and param from the SDP media.
*/
static pj_status_t get_audio_codec_info_param(pjmedia_stream_info *si,
pj_pool_t *pool,
pjmedia_codec_mgr *mgr,
const pjmedia_sdp_media *local_m,
const pjmedia_sdp_media *rem_m)
{
const pjmedia_sdp_attr *attr;
pjmedia_sdp_rtpmap *rtpmap;
unsigned i, fmti, pt = 0;
pj_status_t status;
/* Find the first codec which is not telephone-event */
for ( fmti = 0; fmti < local_m->desc.fmt_count; ++fmti ) {
pjmedia_sdp_rtpmap r;
if ( !pj_isdigit(*local_m->desc.fmt[fmti].ptr) )
return PJMEDIA_EINVALIDPT;
pt = pj_strtoul(&local_m->desc.fmt[fmti]);
if (pt < 96) {
/* This is known static PT. Skip rtpmap checking because it is
* optional. */
break;
}
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL)
continue;
status = pjmedia_sdp_attr_get_rtpmap(attr, &r);
if (status != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) != 0)
break;
}
if ( fmti >= local_m->desc.fmt_count )
return PJMEDIA_EINVALIDPT;
/* Get payload type for receiving direction */
si->rx_pt = pt;
/* Get codec info.
* For static payload types, get the info from codec manager.
* For dynamic payload types, MUST get the rtpmap.
*/
if (pt < 96) {
pj_bool_t has_rtpmap;
rtpmap = NULL;
has_rtpmap = PJ_TRUE;
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL) {
has_rtpmap = PJ_FALSE;
}
if (attr != NULL) {
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
has_rtpmap = PJ_FALSE;
}
/* Build codec format info: */
if (has_rtpmap) {
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
si->fmt.clock_rate = rtpmap->clock_rate;
#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG != 0)
/* The session info should have the actual clock rate, because
* this info is used for calculationg buffer size, etc in stream
*/
if (si->fmt.pt == PJMEDIA_RTP_PT_G722)
si->fmt.clock_rate = 16000;
#endif
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
} else {
const pjmedia_codec_info *p_info;
status = pjmedia_codec_mgr_get_codec_info( mgr, pt, &p_info);
if (status != PJ_SUCCESS)
return status;
pj_memcpy(&si->fmt, p_info, sizeof(pjmedia_codec_info));
}
/* For static payload type, pt's are symetric */
si->tx_pt = pt;
} else {
pjmedia_codec_id codec_id;
pj_str_t codec_id_st;
const pjmedia_codec_info *p_info;
attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP,
&local_m->desc.fmt[fmti]);
if (attr == NULL)
return PJMEDIA_EMISSINGRTPMAP;
status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
if (status != PJ_SUCCESS)
return status;
/* Build codec format info: */
si->fmt.type = si->type;
si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
si->fmt.encoding_name = rtpmap->enc_name;
si->fmt.clock_rate = rtpmap->clock_rate;
/* For audio codecs, rtpmap parameters denotes the number of
* channels.
*/
if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
} else {
si->fmt.channel_cnt = 1;
}
/* Normalize the codec info from codec manager. Note that the
* payload type will be resetted to its default (it might have
* been rewritten by the SDP negotiator to match to the remote
* offer), this is intentional as currently some components may
* prefer (or even require) the default PT in codec info.
*/
pjmedia_codec_info_to_id(&si->fmt, codec_id, sizeof(codec_id));
i = 1;
codec_id_st = pj_str(codec_id);
status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id_st,
&i, &p_info, NULL);
if (status != PJ_SUCCESS)
return status;
pj_memcpy(&si->fmt, p_info, sizeof(pjmedia_codec_info));
/* Determine payload type for outgoing channel, by finding
* dynamic payload type in remote SDP that matches the answer.
*/
si->tx_pt = 0xFFFF;
for (i=0; i<rem_m->desc.fmt_count; ++i) {
if (pjmedia_sdp_neg_fmt_match(pool,
(pjmedia_sdp_media*)local_m, fmti,
(pjmedia_sdp_media*)rem_m, i, 0) ==
PJ_SUCCESS)
{
/* Found matched codec. */
si->tx_pt = pj_strtoul(&rem_m->desc.fmt[i]);
break;
}
}
if (si->tx_pt == 0xFFFF)
return PJMEDIA_EMISSINGRTPMAP;
}
/* Now that we have codec info, get the codec param. */
si->param = PJ_POOL_ALLOC_T(pool, pjmedia_codec_param);
status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt,
si->param);
/* Get remote fmtp for our encoder. */
pjmedia_stream_info_parse_fmtp(pool, rem_m, si->tx_pt,
&si->param->setting.enc_fmtp);
/* Get local fmtp for our decoder. */
pjmedia_stream_info_parse_fmtp(pool, local_m, si->rx_pt,
&si->param->setting.dec_fmtp);
if (!pj_stricmp2(&si->fmt.encoding_name, "opus")) {
get_opus_channels_and_clock_rate(&si->param->setting.enc_fmtp,
&si->param->setting.dec_fmtp,
&si->fmt.channel_cnt,
&si->fmt.clock_rate);
}
/* Get the remote ptime for our encoder. */
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"ptime", NULL);
if (attr) {
pj_str_t tmp_val = attr->value;
unsigned frm_per_pkt;
pj_strltrim(&tmp_val);
/* Round up ptime when the specified is not multiple of frm_ptime */
frm_per_pkt = (pj_strtoul(&tmp_val) +
si->param->info.frm_ptime/2) /
si->param->info.frm_ptime;
if (frm_per_pkt != 0) {
si->param->setting.frm_per_pkt = (pj_uint8_t)frm_per_pkt;
}
}
/* Get remote maxptime for our encoder. */
attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
"maxptime", NULL);
if (attr) {
pj_str_t tmp_val = attr->value;
pj_strltrim(&tmp_val);
si->tx_maxptime = pj_strtoul(&tmp_val);
}
/* When direction is NONE (it means SDP negotiation has failed) we don't
* need to return a failure here, as returning failure will cause
* the whole SDP to be rejected. See ticket #:
* http://
*
* Thanks Alain Totouom
*/
if (status != PJ_SUCCESS && si->dir != PJMEDIA_DIR_NONE)
return status;
/* Get incomming payload type for telephone-events */
si->rx_event_pt = -1;
for (i=0; i<local_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = local_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->rx_event_pt = pj_strtoul(&r.pt);
break;
}
}
/* Get outgoing payload type for telephone-events */
si->tx_event_pt = -1;
for (i=0; i<rem_m->attr_count; ++i) {
pjmedia_sdp_rtpmap r;
attr = rem_m->attr[i];
if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
continue;
if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
continue;
if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
si->tx_event_pt = pj_strtoul(&r.pt);
break;
}
}
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pjmedia_sdp_attr_get_rtpmap( const pjmedia_sdp_attr *attr,
pjmedia_sdp_rtpmap *rtpmap)
{
pj_scanner scanner;
pj_str_t token;
pj_status_t status = -1;
char term = 0;
PJ_USE_EXCEPTION;
PJ_ASSERT_RETURN(pj_strcmp2(&attr->name, "rtpmap")==0, PJ_EINVALIDOP);
PJ_ASSERT_RETURN(attr->value.slen != 0, PJMEDIA_SDP_EINATTR);
init_sdp_parser();
/* Check if input is null terminated, and null terminate if
* necessary. Unfortunately this may crash the application if
* attribute was allocated from a read-only memory location.
* But this shouldn't happen as attribute's value normally is
* null terminated.
*/
if (attr->value.ptr[attr->value.slen] != 0 &&
attr->value.ptr[attr->value.slen] != '\r' &&
attr->value.ptr[attr->value.slen] != '\n')
{
pj_assert(!"Shouldn't happen");
term = attr->value.ptr[attr->value.slen];
attr->value.ptr[attr->value.slen] = '\0';
}
pj_scan_init(&scanner, (char*)attr->value.ptr, attr->value.slen,
PJ_SCAN_AUTOSKIP_WS, &on_scanner_error);
/* rtpmap sample:
* a=rtpmap:98 L16/16000/2.
*/
/* Init */
rtpmap->pt.slen = rtpmap->param.slen = rtpmap->enc_name.slen = 0;
rtpmap->clock_rate = 0;
/* Parse */
PJ_TRY {
/* Get payload type. */
pj_scan_get(&scanner, &cs_token, &rtpmap->pt);
/* Get encoding name. */
pj_scan_get(&scanner, &cs_token, &rtpmap->enc_name);
/* Expecting '/' after encoding name. */
if (pj_scan_get_char(&scanner) != '/') {
status = PJMEDIA_SDP_EINRTPMAP;
goto on_return;
}
/* Get the clock rate. */
pj_scan_get(&scanner, &cs_digit, &token);
rtpmap->clock_rate = pj_strtoul(&token);
/* Expecting either '/' or EOF */
if (*scanner.curptr == '/') {
pj_scan_get_char(&scanner);
rtpmap->param.ptr = scanner.curptr;
rtpmap->param.slen = scanner.end - scanner.curptr;
} else {
rtpmap->param.slen = 0;
}
status = PJ_SUCCESS;
}
PJ_CATCH_ANY {
status = PJMEDIA_SDP_EINRTPMAP;
}
PJ_END;
on_return:
pj_scan_fini(&scanner);
if (term) {
attr->value.ptr[attr->value.slen] = term;
}
return status;
}
/*
* Open codec.
*/
static pj_status_t silk_codec_open(pjmedia_codec *codec,
pjmedia_codec_param *attr )
{
silk_private *silk;
silk_param *sp;
SKP_int st_size, err;
pj_bool_t enc_use_fec;
unsigned enc_bitrate, i;
PJ_ASSERT_RETURN(codec && attr, PJ_EINVAL);
silk = (silk_private*)codec->codec_data;
sp = &silk_factory.silk_param[silk->mode];
/* Already opened? */
if (silk->enc_ready || silk->dec_ready)
return PJ_SUCCESS;
/* Allocate and initialize encoder */
err = SKP_Silk_SDK_Get_Encoder_Size(&st_size);
if (err) {
PJ_LOG(3,(THIS_FILE, "Failed to get encoder state size (err=%d)",
err));
return PJMEDIA_CODEC_EFAILED;
}
silk->enc_st = pj_pool_zalloc(silk->pool, st_size);
err = SKP_Silk_SDK_InitEncoder(silk->enc_st, &silk->enc_ctl);
if (err) {
PJ_LOG(3,(THIS_FILE, "Failed to init encoder (err=%d)", err));
return PJMEDIA_CODEC_EFAILED;
}
/* Check fmtp params */
enc_use_fec = PJ_TRUE;
enc_bitrate = sp->bitrate;
for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
pjmedia_codec_fmtp *fmtp = &attr->setting.enc_fmtp;
const pj_str_t STR_USEINBANDFEC = {"useinbandfec", 12};
const pj_str_t STR_MAXAVERAGEBITRATE = {"maxaveragebitrate", 17};
if (!pj_stricmp(&fmtp->param[i].name, &STR_USEINBANDFEC)) {
enc_use_fec = pj_strtoul(&fmtp->param[i].val) != 0;
} else if (!pj_stricmp(&fmtp->param[i].name, &STR_MAXAVERAGEBITRATE)) {
enc_bitrate = pj_strtoul(&fmtp->param[i].val);
if (enc_bitrate > sp->max_bitrate) {
enc_bitrate = sp->max_bitrate;
}
}
}
/* Setup encoder control for encoding process */
silk->enc_ready = PJ_TRUE;
silk->samples_per_frame = FRAME_LENGTH_MS *
attr->info.clock_rate / 1000;
silk->pcm_bytes_per_sample = attr->info.pcm_bits_per_sample / 8;
silk->enc_ctl.API_sampleRate = attr->info.clock_rate;
silk->enc_ctl.maxInternalSampleRate = attr->info.clock_rate;
silk->enc_ctl.packetSize = attr->setting.frm_per_pkt *
silk->samples_per_frame;
/* For useInBandFEC setting to be useful, we need to set
* packetLossPercentage greater than LBRR_LOSS_THRES (1)
*/
silk->enc_ctl.packetLossPercentage = SILK_ENC_CTL_PACKET_LOSS_PCT;
silk->enc_ctl.useInBandFEC = enc_use_fec;
silk->enc_ctl.useDTX = attr->setting.vad;
silk->enc_ctl.complexity = sp->complexity;
silk->enc_ctl.bitRate = enc_bitrate;
/* Allocate and initialize decoder */
err = SKP_Silk_SDK_Get_Decoder_Size(&st_size);
if (err) {
PJ_LOG(3,(THIS_FILE, "Failed to get decoder state size (err=%d)",
err));
return PJMEDIA_CODEC_EFAILED;
}
silk->dec_st = pj_pool_zalloc(silk->pool, st_size);
err = SKP_Silk_SDK_InitDecoder(silk->dec_st);
if (err) {
PJ_LOG(3,(THIS_FILE, "Failed to init decoder (err=%d)", err));
return PJMEDIA_CODEC_EFAILED;
}
/* Setup decoder control for decoding process */
silk->dec_ctl.API_sampleRate = attr->info.clock_rate;
silk->dec_ctl.framesPerPacket = 1; /* for proper PLC at start */
silk->dec_ready = PJ_TRUE;
silk->dec_buf_sz = attr->info.clock_rate * attr->info.channel_cnt *
attr->info.frm_ptime / 1000 *
silk->pcm_bytes_per_sample;
/* Inform the stream to prepare a larger buffer since we cannot parse
* SILK packets and split it into individual frames.
*/
attr->info.max_rx_frame_size = attr->info.max_bps *
attr->info.frm_ptime / 8 / 1000;
if ((attr->info.max_bps * attr->info.frm_ptime) % 8000 != 0)
{
++attr->info.max_rx_frame_size;
}
attr->info.max_rx_frame_size *= SILK_MAX_FRAMES_PER_PACKET;
return PJ_SUCCESS;
}
/* Validate SDP session descriptor. */
PJ_DEF(pj_status_t) pjmedia_sdp_validate2(const pjmedia_sdp_session *sdp,
pj_bool_t strict)
{
unsigned i;
const pj_str_t STR_RTPMAP = { "rtpmap", 6 };
CHECK( sdp != NULL, PJ_EINVAL);
/* Validate origin line. */
CHECK( sdp->origin.user.slen != 0, PJMEDIA_SDP_EINORIGIN);
CHECK( pj_strcmp2(&sdp->origin.net_type, "IN")==0,
PJMEDIA_SDP_EINORIGIN);
CHECK( pj_strcmp2(&sdp->origin.addr_type, "IP4")==0 ||
pj_strcmp2(&sdp->origin.addr_type, "IP6")==0,
PJMEDIA_SDP_EINORIGIN);
CHECK( sdp->origin.addr.slen != 0, PJMEDIA_SDP_EINORIGIN);
/* Validate subject line. */
CHECK( sdp->name.slen != 0, PJMEDIA_SDP_EINNAME);
/* Ignore start and stop time. */
/* If session level connection info is present, validate it. */
if (sdp->conn) {
pj_status_t status = validate_sdp_conn(sdp->conn);
if (status != PJ_SUCCESS)
return status;
}
/* Validate each media. */
for (i=0; i<sdp->media_count; ++i) {
const pjmedia_sdp_media *m = sdp->media[i];
unsigned j;
/* Validate the m= line. */
CHECK( m->desc.media.slen != 0, PJMEDIA_SDP_EINMEDIA);
CHECK( m->desc.transport.slen != 0, PJMEDIA_SDP_EINMEDIA);
CHECK( m->desc.fmt_count != 0 || m->desc.port==0, PJMEDIA_SDP_ENOFMT);
/* If media level connection info is present, validate it. */
if (m->conn) {
pj_status_t status = validate_sdp_conn(m->conn);
if (status != PJ_SUCCESS)
return status;
}
/* If media doesn't have connection info, then connection info
* must be present in the session.
*/
if (m->conn == NULL) {
if (sdp->conn == NULL)
if (strict || m->desc.port != 0)
return PJMEDIA_SDP_EMISSINGCONN;
}
/* Verify payload type. */
for (j=0; j<m->desc.fmt_count; ++j) {
/* Arrgh noo!! Payload type can be non-numeric!!
* RTC based programs sends "null" for instant messaging!
*/
if (pj_isdigit(*m->desc.fmt[j].ptr)) {
unsigned pt = pj_strtoul(&m->desc.fmt[j]);
/* Payload type is between 0 and 127.
*/
CHECK( pt <= 127, PJMEDIA_SDP_EINPT);
/* If port is not zero, then for each dynamic payload type, an
* rtpmap attribute must be specified.
*/
if (m->desc.port != 0 && pt >= 96) {
const pjmedia_sdp_attr *a;
a = pjmedia_sdp_media_find_attr(m, &STR_RTPMAP,
&m->desc.fmt[j]);
CHECK( a != NULL, PJMEDIA_SDP_EMISSINGRTPMAP);
}
}
}
}
/* Looks good. */
return PJ_SUCCESS;
}
static void parse_media(pj_scanner *scanner, pjmedia_sdp_media *med,
parse_context *ctx)
{
pj_str_t str;
ctx->last_error = PJMEDIA_SDP_EINMEDIA;
/* check the equal sign */
if (*(scanner->curptr+1) != '=') {
on_scanner_error(scanner);
return;
}
/* m= */
pj_scan_advance_n(scanner, 2, SKIP_WS);
/* type */
pj_scan_get_until_ch(scanner, ' ', &med->desc.media);
pj_scan_get_char(scanner);
/* port */
pj_scan_get(scanner, &cs_token, &str);
med->desc.port = (unsigned short)pj_strtoul(&str);
if (*scanner->curptr == '/') {
/* port count */
pj_scan_get_char(scanner);
pj_scan_get(scanner, &cs_token, &str);
med->desc.port_count = pj_strtoul(&str);
} else {
med->desc.port_count = 0;
}
if (pj_scan_get_char(scanner) != ' ') {
PJ_THROW(SYNTAX_ERROR);
}
/* transport */
pj_scan_get_until_chr(scanner, " \t\r\n", &med->desc.transport);
/* format list */
med->desc.fmt_count = 0;
while (*scanner->curptr == ' ') {
pj_str_t fmt;
pj_scan_get_char(scanner);
/* Check again for the end of the line */
if ((*scanner->curptr == '\r') || (*scanner->curptr == '\n'))
break;
pj_scan_get(scanner, &cs_token, &fmt);
if (med->desc.fmt_count < PJMEDIA_MAX_SDP_FMT)
med->desc.fmt[med->desc.fmt_count++] = fmt;
else
PJ_PERROR(2,(THIS_FILE, PJ_ETOOMANY,
"Error adding SDP media format %.*s, "
"format is ignored",
(int)fmt.slen, fmt.ptr));
}
/* We've got what we're looking for, skip anything until newline */
pj_scan_skip_line(scanner);
}
/* API: Init factory */
static pj_status_t android_init(pjmedia_aud_dev_factory *f)
{
int mic_source;
int state = 0;
jthrowable exc;
PJ_UNUSED_ARG(f);
PJ_LOG(4,(THIS_FILE, "Android sound library initialized"));
PJ_LOG(4,(THIS_FILE, "Sound device count=%d", android_get_dev_count(f)));
JNIEnv *jni_env = 0;
ATTACH_JVM(jni_env);
jmethodID constructor_method = 0, method_id = 0;
g_record_class = (jclass)jni_env->NewGlobalRef(jni_env->FindClass("android/media/AudioRecord"));
if (g_record_class == 0)
{
PJ_LOG(2, (THIS_FILE, "zzc Not able to find audio record class"));
goto on_error;
}
//Get pointer to the constructor
constructor_method = jni_env->GetMethodID(g_record_class,"<init>", "(IIIII)V");
if (constructor_method == 0)
{
PJ_LOG(2, (THIS_FILE, "zzc Not able to find audio record class constructor"));
goto on_error;
}
mic_source = on_set_micro_source_wrapper();
if(mic_source == 0)
{
mic_source = 1;
char sdk_version[PROP_VALUE_MAX];
__system_property_get("ro.build.version.sdk", sdk_version);
pj_str_t pj_sdk_version = pj_str(sdk_version);
int sdk_v = pj_strtoul(&pj_sdk_version);
if(sdk_v >= 10)
{
mic_source = 7;
}
}
PJ_LOG(3, (THIS_FILE, "zzc Use micro source : %d", mic_source));
g_audio_record = jni_env->NewObject(g_record_class, constructor_method,
1, // Mic input source: 1 = MIC / 7 = VOICE_COMMUNICATION
16000,
//2, // CHANNEL_CONFIGURATION_MONO
16, // lxd CHANNEL_IN_MONO
2,
//6144
16000//lxd
);
if (g_audio_record == 0)
{
PJ_LOG(1, (THIS_FILE, "zzc Not able to instantiate record class"));
goto on_error;
}
exc = jni_env->ExceptionOccurred();
if (exc)
{
jni_env->ExceptionDescribe();
jni_env->ExceptionClear();
PJ_LOG(2, (THIS_FILE, "zzc The micro source was probably not valid"));
// Try to fallback on MIC source -- lazy failure
if(mic_source != 1)
{
PJ_LOG(4, (THIS_FILE, "zzc Try default source"));
g_audio_record = jni_env->NewObject(g_record_class, constructor_method,
1, // Mic input source: 1 = MIC / 7 = VOICE_COMMUNICATION
16000,
//2, // CHANNEL_CONFIGURATION_MONO
16, // lxd CHANNEL_IN_MONO
2,
//6144
16000//lxd
);
if (g_audio_record == 0)
{
PJ_LOG(1, (THIS_FILE, "zzc Not able to instantiate record class"));
goto on_error;
}
}
else
{
PJ_LOG(1, (THIS_FILE, "zzc Not able to instantiate record class"));
goto on_error;
}
}
// Check state
method_id = jni_env->GetMethodID(g_record_class,"getState", "()I");
state = jni_env->CallIntMethod(g_audio_record, method_id);
if(state == 0){ /* STATE_UNINITIALIZED */
// Try to fallback on MIC source -- lazy failure
if(mic_source != 1){
PJ_LOG(4, (THIS_FILE, "Try default source"));
g_audio_record = jni_env->NewObject(g_record_class, constructor_method,
1, // Mic input source: 1 = MIC / 7 = VOICE_COMMUNICATION
16000,
//2, // CHANNEL_CONFIGURATION_MONO
16, // lxd CHANNEL_IN_MONO
2,
//6144
16000//lxd
);
if (g_audio_record == 0) {
PJ_LOG(1, (THIS_FILE, "Not able to instantiate record class"));
goto on_error;
}
}else{
PJ_LOG(1, (THIS_FILE, "Not able to instantiate record class"));
goto on_error;
}
}
g_audio_record = jni_env->NewGlobalRef(g_audio_record);
return PJ_SUCCESS;
on_error:
on_teardown_audio_wrapper();
DETACH_JVM(jni_env);
return PJMEDIA_ESNDINDEVID;
}
/* API: create stream */
static pj_status_t android_create_stream(pjmedia_aud_dev_factory *f,
const pjmedia_aud_param *param,
pjmedia_aud_rec_cb rec_cb,
pjmedia_aud_play_cb play_cb,
void *user_data,
pjmedia_aud_stream **p_aud_strm)
{
struct android_aud_factory *pa = (struct android_aud_factory*)f;
pj_pool_t *pool;
struct android_aud_stream *stream;
pj_status_t status = PJ_SUCCESS;
int state = 0;
int buffSize, inputBuffSizePlay, inputBuffSizeRec;
int channelInCfg, channelOutCfg, sampleFormat;
jmethodID constructor_method=0, bufsize_method = 0;
jmethodID method_id = 0;
jclass jcl;
JNIEnv *jni_env = 0;
pj_bool_t attached;
PJ_ASSERT_RETURN(param->channel_count >= 1 && param->channel_count <= 2,
PJ_EINVAL);
PJ_ASSERT_RETURN(param->bits_per_sample==8 || param->bits_per_sample==16,
PJ_EINVAL);
PJ_ASSERT_RETURN(play_cb && rec_cb && p_aud_strm, PJ_EINVAL);
pool = pj_pool_create(pa->pf, "jnistrm", 1024, 1024, NULL);
if (!pool)
return PJ_ENOMEM;
PJ_LOG(4, (THIS_FILE, "Creating Android JNI stream"));
stream = PJ_POOL_ZALLOC_T(pool, struct android_aud_stream);
stream->pool = pool;
pj_strdup2_with_null(pool, &stream->name, "JNI stream");
stream->dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
pj_memcpy(&stream->param, param, sizeof(*param));
stream->user_data = user_data;
stream->rec_cb = rec_cb;
stream->play_cb = play_cb;
buffSize = stream->param.samples_per_frame*stream->param.bits_per_sample/8;
stream->rec_buf_size = stream->play_buf_size = buffSize;
channelInCfg = (param->channel_count == 1)? 16 /*CHANNEL_IN_MONO*/:
12 /*CHANNEL_IN_STEREO*/;
channelOutCfg = (param->channel_count == 1)? 4 /*CHANNEL_OUT_MONO*/:
12 /*CHANNEL_OUT_STEREO*/;
sampleFormat = (param->bits_per_sample == 8)? 3 /*ENCODING_PCM_8BIT*/:
2 /*ENCODING_PCM_16BIT*/;
attached = attach_jvm(&jni_env);
if (stream->dir & PJMEDIA_DIR_CAPTURE) {
/* Find audio record class and create global ref */
jcl = (*jni_env)->FindClass(jni_env, "android/media/AudioRecord");
if (jcl == NULL) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio record class"));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
stream->record_class = (jclass)(*jni_env)->NewGlobalRef(jni_env, jcl);
(*jni_env)->DeleteLocalRef(jni_env, jcl);
if (stream->record_class == 0) {
status = PJ_ENOMEM;
goto on_error;
}
/* Get the min buffer size function */
bufsize_method = (*jni_env)->GetStaticMethodID(jni_env,
stream->record_class,
"getMinBufferSize",
"(III)I");
if (bufsize_method == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio record "
"getMinBufferSize() method"));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
inputBuffSizeRec = (*jni_env)->CallStaticIntMethod(jni_env,
stream->record_class,
bufsize_method,
param->clock_rate,
channelInCfg,
sampleFormat);
if (inputBuffSizeRec <= 0) {
PJ_LOG(3, (THIS_FILE, "Unsupported audio record params"));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
}
if (stream->dir & PJMEDIA_DIR_PLAYBACK) {
/* Find audio track class and create global ref */
jcl = (*jni_env)->FindClass(jni_env, "android/media/AudioTrack");
if (jcl == NULL) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio track class"));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
stream->track_class = (jclass)(*jni_env)->NewGlobalRef(jni_env, jcl);
(*jni_env)->DeleteLocalRef(jni_env, jcl);
if (stream->track_class == 0) {
status = PJ_ENOMEM;
goto on_error;
}
/* Get the min buffer size function */
bufsize_method = (*jni_env)->GetStaticMethodID(jni_env,
stream->track_class,
"getMinBufferSize",
"(III)I");
if (bufsize_method == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio track "
"getMinBufferSize() method"));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
inputBuffSizePlay = (*jni_env)->CallStaticIntMethod(jni_env,
stream->track_class,
bufsize_method,
param->clock_rate,
channelOutCfg,
sampleFormat);
if (inputBuffSizePlay <= 0) {
PJ_LOG(3, (THIS_FILE, "Unsupported audio track params"));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
}
if (stream->dir & PJMEDIA_DIR_CAPTURE) {
jthrowable exc;
int mic_source = 0; /* DEFAULT: default audio source */
/* Get pointer to the constructor */
constructor_method = (*jni_env)->GetMethodID(jni_env,
stream->record_class,
"<init>", "(IIIII)V");
if (constructor_method == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio record's constructor"));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
if (mic_source == 0) {
char sdk_version[PROP_VALUE_MAX];
pj_str_t pj_sdk_version;
int sdk_v;
__system_property_get("ro.build.version.sdk", sdk_version);
pj_sdk_version = pj_str(sdk_version);
sdk_v = pj_strtoul(&pj_sdk_version);
if (sdk_v > 10)
mic_source = 7; /* VOICE_COMMUNICATION */
}
PJ_LOG(4, (THIS_FILE, "Using audio input source : %d", mic_source));
do {
stream->record = (*jni_env)->NewObject(jni_env,
stream->record_class,
constructor_method,
mic_source,
param->clock_rate,
channelInCfg,
sampleFormat,
inputBuffSizeRec);
if (stream->record == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to create audio record object"));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
exc = (*jni_env)->ExceptionOccurred(jni_env);
if (exc) {
(*jni_env)->ExceptionDescribe(jni_env);
(*jni_env)->ExceptionClear(jni_env);
PJ_LOG(3, (THIS_FILE, "Failure in audio record's constructor"));
if (mic_source == 0) {
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
mic_source = 0;
PJ_LOG(4, (THIS_FILE, "Trying the default audio source."));
continue;
}
/* Check state */
method_id = (*jni_env)->GetMethodID(jni_env, stream->record_class,
"getState", "()I");
if (method_id == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio record getState() "
"method"));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
state = (*jni_env)->CallIntMethod(jni_env, stream->record,
method_id);
if (state == 0) { /* STATE_UNINITIALIZED */
PJ_LOG(3, (THIS_FILE, "Failure in initializing audio record."));
if (mic_source == 0) {
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
mic_source = 0;
PJ_LOG(4, (THIS_FILE, "Trying the default audio source."));
}
} while (state == 0);
stream->record = (*jni_env)->NewGlobalRef(jni_env, stream->record);
if (stream->record == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to create audio record global ref."));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
status = pj_sem_create(stream->pool, NULL, 0, 1, &stream->rec_sem);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_thread_create(stream->pool, "android_recorder",
AndroidRecorderCallback, stream, 0, 0,
&stream->rec_thread);
if (status != PJ_SUCCESS)
goto on_error;
PJ_LOG(4, (THIS_FILE, "Audio record initialized successfully."));
}
if (stream->dir & PJMEDIA_DIR_PLAYBACK) {
jthrowable exc;
/* Get pointer to the constructor */
constructor_method = (*jni_env)->GetMethodID(jni_env,
stream->track_class,
"<init>", "(IIIIII)V");
if (constructor_method == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio track's constructor."));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
stream->track = (*jni_env)->NewObject(jni_env,
stream->track_class,
constructor_method,
0, /* STREAM_VOICE_CALL */
param->clock_rate,
channelOutCfg,
sampleFormat,
inputBuffSizePlay,
1 /* MODE_STREAM */);
if (stream->track == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to create audio track object."));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
exc = (*jni_env)->ExceptionOccurred(jni_env);
if (exc) {
(*jni_env)->ExceptionDescribe(jni_env);
(*jni_env)->ExceptionClear(jni_env);
PJ_LOG(3, (THIS_FILE, "Failure in audio track's constructor"));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
stream->track = (*jni_env)->NewGlobalRef(jni_env, stream->track);
if (stream->track == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to create audio track's global ref"));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
/* Check state */
method_id = (*jni_env)->GetMethodID(jni_env, stream->track_class,
"getState", "()I");
if (method_id == 0) {
PJ_LOG(3, (THIS_FILE, "Unable to find audio track getState() "
"method"));
status = PJMEDIA_EAUD_SYSERR;
goto on_error;
}
state = (*jni_env)->CallIntMethod(jni_env, stream->track,
method_id);
if (state == 0) { /* STATE_UNINITIALIZED */
PJ_LOG(3, (THIS_FILE, "Failure in initializing audio track."));
status = PJMEDIA_EAUD_INIT;
goto on_error;
}
status = pj_sem_create(stream->pool, NULL, 0, 1, &stream->play_sem);
if (status != PJ_SUCCESS)
goto on_error;
status = pj_thread_create(stream->pool, "android_track",
AndroidTrackCallback, stream, 0, 0,
&stream->play_thread);
if (status != PJ_SUCCESS)
goto on_error;
PJ_LOG(4, (THIS_FILE, "Audio track initialized successfully."));
}
if (param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING) {
strm_set_cap(&stream->base, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING,
¶m->output_vol);
}
/* Done */
stream->base.op = &android_strm_op;
*p_aud_strm = &stream->base;
detach_jvm(attached);
return PJ_SUCCESS;
on_error:
detach_jvm(attached);
strm_destroy(&stream->base);
return status;
}
/*
* Open codec.
*/
static pj_status_t amr_codec_open( pjmedia_codec *codec,
pjmedia_codec_param *attr )
{
struct amr_data *amr_data = (struct amr_data*) codec->codec_data;
pjmedia_codec_amr_pack_setting *setting;
unsigned i;
pj_uint8_t octet_align = 0;
pj_int8_t enc_mode;
const pj_str_t STR_FMTP_OCTET_ALIGN = {"octet-align", 11};
PJ_ASSERT_RETURN(codec && attr, PJ_EINVAL);
PJ_ASSERT_RETURN(amr_data != NULL, PJ_EINVALIDOP);
enc_mode = pjmedia_codec_amr_get_mode(attr->info.avg_bps);
pj_assert(enc_mode >= 0 && enc_mode <= 7);
/* Check octet-align */
for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name,
&STR_FMTP_OCTET_ALIGN) == 0)
{
octet_align = (pj_uint8_t)
(pj_strtoul(&attr->setting.dec_fmtp.param[i].val));
break;
}
}
/* Check mode-set */
for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
const pj_str_t STR_FMTP_MODE_SET = {"mode-set", 8};
if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name,
&STR_FMTP_MODE_SET) == 0)
{
const char *p;
pj_size_t l;
pj_int8_t diff = 99;
/* Encoding mode is chosen based on local default mode setting:
* - if local default mode is included in the mode-set, use it
* - otherwise, find the closest mode to local default mode;
* if there are two closest modes, prefer to use the higher
* one, e.g: local default mode is 4, the mode-set param
* contains '2,3,5,6', then 5 will be chosen.
*/
p = pj_strbuf(&attr->setting.enc_fmtp.param[i].val);
l = pj_strlen(&attr->setting.enc_fmtp.param[i].val);
while (l--) {
if (*p>='0' && *p<='7') {
pj_int8_t tmp = *p - '0' - enc_mode;
if (PJ_ABS(diff) > PJ_ABS(tmp) ||
(PJ_ABS(diff) == PJ_ABS(tmp) && tmp > diff))
{
diff = tmp;
if (diff == 0) break;
}
}
++p;
}
PJ_ASSERT_RETURN(diff != 99, PJMEDIA_CODEC_EFAILED);
enc_mode = enc_mode + diff;
break;
}
}
amr_data->vad_enabled = (attr->setting.vad != 0);
amr_data->plc_enabled = (attr->setting.plc != 0);
amr_data->enc_mode = enc_mode;
amr_data->encoder = Encoder_Interface_init(amr_data, amr_data->vad_enabled);
if (amr_data->encoder == NULL) {
TRACE_((THIS_FILE, "Encoder_Interface_init() failed"));
amr_codec_close(codec);
return PJMEDIA_CODEC_EFAILED;
}
setting = &amr_data->enc_setting;
pj_bzero(setting, sizeof(pjmedia_codec_amr_pack_setting));
setting->amr_nb = 1;
setting->reorder = 0;
setting->octet_aligned = octet_align;
setting->cmr = 15;
amr_data->decoder = Decoder_Interface_init(amr_data);
if (amr_data->decoder == NULL) {
TRACE_((THIS_FILE, "Decoder_Interface_init() failed"));
amr_codec_close(codec);
return PJMEDIA_CODEC_EFAILED;
}
setting = &amr_data->dec_setting;
pj_bzero(setting, sizeof(pjmedia_codec_amr_pack_setting));
setting->amr_nb = 1;
setting->reorder = 0;
setting->octet_aligned = octet_align;
TRACE_((THIS_FILE, "AMR-NB codec allocated: vad=%d, plc=%d, bitrate=%d",
amr_data->vad_enabled, amr_data->plc_enabled,
pjmedia_codec_amrnb_bitrates[amr_data->enc_mode]));
return PJ_SUCCESS;
}
/* Update single local media description to after receiving answer
* from remote.
*/
static pj_status_t process_m_answer( pj_pool_t *pool,
pjmedia_sdp_media *offer,
pjmedia_sdp_media *answer,
pj_bool_t allow_asym)
{
unsigned i;
/* Check that the media type match our offer. */
if (pj_strcmp(&answer->desc.media, &offer->desc.media)!=0) {
/* The media type in the answer is different than the offer! */
return PJMEDIA_SDPNEG_EINVANSMEDIA;
}
/* Check that transport in the answer match our offer. */
/* At this point, transport type must be compatible,
* the transport instance will do more validation later.
*/
if (pjmedia_sdp_transport_cmp(&answer->desc.transport,
&offer->desc.transport)
!= PJ_SUCCESS)
{
return PJMEDIA_SDPNEG_EINVANSTP;
}
/* Check if remote has rejected our offer */
if (answer->desc.port == 0) {
/* Remote has rejected our offer.
* Set our port to zero too in active SDP.
*/
offer->desc.port = 0;
}
/* Process direction attributes */
update_media_direction(pool, answer, offer);
/* If asymetric media is allowed, then just check that remote answer has
* codecs that are within the offer.
*
* Otherwise if asymetric media is not allowed, then we will choose only
* one codec in our initial offer to match the answer.
*/
if (allow_asym) {
for (i=0; i<answer->desc.fmt_count; ++i) {
unsigned j;
pj_str_t *rem_fmt = &answer->desc.fmt[i];
for (j=0; j<offer->desc.fmt_count; ++j) {
if (pj_strcmp(rem_fmt, &answer->desc.fmt[j])==0)
break;
}
if (j != offer->desc.fmt_count) {
/* Found at least one common codec. */
break;
}
}
if (i == answer->desc.fmt_count) {
/* No common codec in the answer! */
return PJMEDIA_SDPNEG_EANSNOMEDIA;
}
PJ_TODO(CHECK_SDP_NEGOTIATION_WHEN_ASYMETRIC_MEDIA_IS_ALLOWED);
} else {
/* Remove all format in the offer that has no matching answer */
for (i=0; i<offer->desc.fmt_count;) {
unsigned pt;
pj_uint32_t j;
pj_str_t *fmt = &offer->desc.fmt[i];
/* Find matching answer */
pt = pj_strtoul(fmt);
if (pt < 96) {
for (j=0; j<answer->desc.fmt_count; ++j) {
if (pj_strcmp(fmt, &answer->desc.fmt[j])==0)
break;
}
} else {
/* This is dynamic payload type.
* For dynamic payload type, we must look the rtpmap and
* compare the encoding name.
*/
const pjmedia_sdp_attr *a;
pjmedia_sdp_rtpmap or_;
/* Get the rtpmap for the payload type in the offer. */
a = pjmedia_sdp_media_find_attr2(offer, "rtpmap", fmt);
if (!a) {
pj_assert(!"Bug! Offer should have been validated");
return PJ_EBUG;
}
pjmedia_sdp_attr_get_rtpmap(a, &or_);
/* Find paylaod in answer SDP with matching
* encoding name and clock rate.
*/
for (j=0; j<answer->desc.fmt_count; ++j) {
a = pjmedia_sdp_media_find_attr2(answer, "rtpmap",
&answer->desc.fmt[j]);
if (a) {
pjmedia_sdp_rtpmap ar;
pjmedia_sdp_attr_get_rtpmap(a, &ar);
/* See if encoding name, clock rate, and channel
* count match
*/
if (!pj_stricmp(&or_.enc_name, &ar.enc_name) &&
or_.clock_rate == ar.clock_rate &&
(pj_stricmp(&or_.param, &ar.param)==0 ||
(ar.param.slen==1 && *ar.param.ptr=='1')))
{
/* Further check for G7221, negotiate bitrate. */
if (pj_strcmp2(&or_.enc_name, "G7221") == 0) {
if (match_g7221(offer, i, answer, j))
break;
} else
/* Further check for AMR, negotiate fmtp. */
if (pj_strcmp2(&or_.enc_name, "AMR") == 0) {
if (match_amr(offer, i, answer, j, PJ_FALSE,
NULL))
break;
} else {
/* Match! */
break;
}
}
}
}
}
if (j == answer->desc.fmt_count) {
/* This format has no matching answer.
* Remove it from our offer.
*/
pjmedia_sdp_attr *a;
/* Remove rtpmap associated with this format */
a = pjmedia_sdp_media_find_attr2(offer, "rtpmap", fmt);
if (a)
pjmedia_sdp_media_remove_attr(offer, a);
/* Remove fmtp associated with this format */
a = pjmedia_sdp_media_find_attr2(offer, "fmtp", fmt);
if (a)
pjmedia_sdp_media_remove_attr(offer, a);
/* Remove this format from offer's array */
pj_array_erase(offer->desc.fmt, sizeof(offer->desc.fmt[0]),
offer->desc.fmt_count, i);
--offer->desc.fmt_count;
} else {
++i;
}
}
/* Arrange format in the offer so the order match the priority
* in the answer
*/
for (i=0; i<answer->desc.fmt_count; ++i) {
unsigned j;
pj_str_t *fmt = &answer->desc.fmt[i];
for (j=i; j<offer->desc.fmt_count; ++j) {
if (pj_strcmp(fmt, &offer->desc.fmt[j])==0) {
str_swap(&offer->desc.fmt[i], &offer->desc.fmt[j]);
break;
}
}
}
}
/* Looks okay */
return PJ_SUCCESS;
}
/*
* Open codec.
*/
static pj_status_t ilbc_codec_open(pjmedia_codec *codec,
pjmedia_codec_param *attr )
{
struct ilbc_codec *ilbc_codec = (struct ilbc_codec*)codec;
pj_status_t status;
unsigned i, dec_fmtp_mode = 0, enc_fmtp_mode = 0;
pj_assert(ilbc_codec != NULL);
pj_assert(ilbc_codec->enc_ready == PJ_FALSE &&
ilbc_codec->dec_ready == PJ_FALSE);
/* Get decoder mode */
for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name, &STR_MODE) == 0)
{
dec_fmtp_mode = (unsigned)
pj_strtoul(&attr->setting.dec_fmtp.param[i].val);
break;
}
}
/* Decoder mode must be set */
PJ_ASSERT_RETURN(dec_fmtp_mode == 20 || dec_fmtp_mode == 30,
PJMEDIA_CODEC_EINMODE);
/* Get encoder mode */
for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name, &STR_MODE) == 0)
{
enc_fmtp_mode = (unsigned)
pj_strtoul(&attr->setting.enc_fmtp.param[i].val);
break;
}
}
/* The enc mode must be set in the attribute
* (from the mode parameter in fmtp attribute in the SDP
* received from remote)
*/
if (enc_fmtp_mode == 0)
enc_fmtp_mode = dec_fmtp_mode;
PJ_ASSERT_RETURN(enc_fmtp_mode==20 ||
enc_fmtp_mode==30, PJMEDIA_CODEC_EINMODE);
/* Update enc_ptime in the param */
if (enc_fmtp_mode != dec_fmtp_mode) {
attr->info.enc_ptime = (pj_uint16_t)enc_fmtp_mode;
} else {
attr->info.enc_ptime = 0;
}
/* Create enc */
ilbc_codec->enc_frame_size = initEncode(&ilbc_codec->enc, enc_fmtp_mode);
ilbc_codec->enc_samples_per_frame = CLOCK_RATE * enc_fmtp_mode / 1000;
ilbc_codec->enc_ready = PJ_TRUE;
/* Create decoder */
ilbc_codec->dec_samples_per_frame = initDecode(&ilbc_codec->dec,
dec_fmtp_mode,
attr->setting.penh);
if (dec_fmtp_mode == 20)
ilbc_codec->dec_frame_size = 38;
else if (dec_fmtp_mode == 30)
ilbc_codec->dec_frame_size = 50;
else {
pj_assert(!"Invalid iLBC mode");
ilbc_codec->dec_frame_size = ilbc_codec->enc_frame_size;
}
ilbc_codec->dec_ready = PJ_TRUE;
/* Save plc flags */
ilbc_codec->plc_enabled = (attr->setting.plc != 0);
/* Create silence detector. */
ilbc_codec->vad_enabled = (attr->setting.vad != 0);
status = pjmedia_silence_det_create(ilbc_codec->pool, CLOCK_RATE,
ilbc_codec->enc_samples_per_frame,
&ilbc_codec->vad);
if (status != PJ_SUCCESS)
return status;
/* Init last_tx (not necessary because of zalloc, but better
* be safe in case someone remove zalloc later.
*/
pj_set_timestamp32(&ilbc_codec->last_tx, 0, 0);
PJ_LOG(5,(ilbc_codec->obj_name,
"iLBC codec opened, encoder mode=%d, decoder mode=%d",
enc_fmtp_mode, dec_fmtp_mode));
return PJ_SUCCESS;
}
/*! \brief Parse a T.38 image stream and store the attribute information */
static void t38_interpret_sdp(struct t38_state *state, struct ast_sip_session *session, struct ast_sip_session_media *session_media,
const struct pjmedia_sdp_media *stream)
{
unsigned int attr_i;
for (attr_i = 0; attr_i < stream->attr_count; attr_i++) {
pjmedia_sdp_attr *attr = stream->attr[attr_i];
if (!pj_stricmp2(&attr->name, "t38faxmaxbuffer")) {
/* This is purposely left empty, it is unused */
} else if (!pj_stricmp2(&attr->name, "t38maxbitrate") || !pj_stricmp2(&attr->name, "t38faxmaxrate")) {
switch (pj_strtoul(&attr->value)) {
case 14400:
state->their_parms.rate = AST_T38_RATE_14400;
break;
case 12000:
state->their_parms.rate = AST_T38_RATE_12000;
break;
case 9600:
state->their_parms.rate = AST_T38_RATE_9600;
break;
case 7200:
state->their_parms.rate = AST_T38_RATE_7200;
break;
case 4800:
state->their_parms.rate = AST_T38_RATE_4800;
break;
case 2400:
state->their_parms.rate = AST_T38_RATE_2400;
break;
}
} else if (!pj_stricmp2(&attr->name, "t38faxversion")) {
state->their_parms.version = pj_strtoul(&attr->value);
} else if (!pj_stricmp2(&attr->name, "t38faxmaxdatagram") || !pj_stricmp2(&attr->name, "t38maxdatagram")) {
if (!session->endpoint->media.t38.maxdatagram) {
ast_udptl_set_far_max_datagram(session_media->udptl, pj_strtoul(&attr->value));
}
} else if (!pj_stricmp2(&attr->name, "t38faxfillbitremoval")) {
state->their_parms.fill_bit_removal = 1;
} else if (!pj_stricmp2(&attr->name, "t38faxtranscodingmmr")) {
state->their_parms.transcoding_mmr = 1;
} else if (!pj_stricmp2(&attr->name, "t38faxtranscodingjbig")) {
state->their_parms.transcoding_jbig = 1;
} else if (!pj_stricmp2(&attr->name, "t38faxratemanagement")) {
if (!pj_stricmp2(&attr->value, "localTCF")) {
state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_LOCAL_TCF;
} else if (!pj_stricmp2(&attr->value, "transferredTCF")) {
state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF;
}
} else if (!pj_stricmp2(&attr->name, "t38faxudpec")) {
if (!pj_stricmp2(&attr->value, "t38UDPRedundancy")) {
ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
} else if (!pj_stricmp2(&attr->value, "t38UDPFEC")) {
ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_FEC);
} else {
ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_NONE);
}
}
}
}
static int my_atoi(const char *s)
{
pj_str_t ss = pj_str((char*)s);
return pj_strtoul(&ss);
}
/*
* Open codec.
*/
static pj_status_t ilbc_codec_open(pjmedia_codec *codec,
pjmedia_codec_param *attr )
{
struct ilbc_codec *ilbc_codec = (struct ilbc_codec*)codec;
pj_status_t status;
unsigned i;
pj_uint16_t dec_fmtp_mode = DEFAULT_MODE,
enc_fmtp_mode = DEFAULT_MODE;
#if defined(PJMEDIA_ILBC_CODEC_USE_COREAUDIO)&& PJMEDIA_ILBC_CODEC_USE_COREAUDIO
AudioStreamBasicDescription srcFormat, dstFormat;
UInt32 size;
srcFormat.mSampleRate = attr->info.clock_rate;
srcFormat.mFormatID = kAudioFormatLinearPCM;
srcFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
| kLinearPCMFormatFlagIsPacked;
srcFormat.mBitsPerChannel = attr->info.pcm_bits_per_sample;
srcFormat.mChannelsPerFrame = attr->info.channel_cnt;
srcFormat.mBytesPerFrame = srcFormat.mChannelsPerFrame
* srcFormat.mBitsPerChannel >> 3;
srcFormat.mFramesPerPacket = 1;
srcFormat.mBytesPerPacket = srcFormat.mBytesPerFrame *
srcFormat.mFramesPerPacket;
memset(&dstFormat, 0, sizeof(dstFormat));
dstFormat.mSampleRate = attr->info.clock_rate;
dstFormat.mFormatID = kAudioFormatiLBC;
dstFormat.mChannelsPerFrame = attr->info.channel_cnt;
#endif
pj_assert(ilbc_codec != NULL);
pj_assert(ilbc_codec->enc_ready == PJ_FALSE &&
ilbc_codec->dec_ready == PJ_FALSE);
/* Get decoder mode */
for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name, &STR_MODE) == 0)
{
dec_fmtp_mode = (pj_uint16_t)
pj_strtoul(&attr->setting.dec_fmtp.param[i].val);
break;
}
}
/* Decoder mode must be set */
PJ_ASSERT_RETURN(dec_fmtp_mode == 20 || dec_fmtp_mode == 30,
PJMEDIA_CODEC_EINMODE);
/* Get encoder mode */
for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name, &STR_MODE) == 0)
{
enc_fmtp_mode = (pj_uint16_t)
pj_strtoul(&attr->setting.enc_fmtp.param[i].val);
break;
}
}
PJ_ASSERT_RETURN(enc_fmtp_mode==20 || enc_fmtp_mode==30,
PJMEDIA_CODEC_EINMODE);
/* Both sides of a bi-directional session MUST use the same "mode" value.
* In this point, possible values are only 20 or 30, so when encoder and
* decoder modes are not same, just use the default mode, it is 30.
*/
if (enc_fmtp_mode != dec_fmtp_mode) {
enc_fmtp_mode = dec_fmtp_mode = DEFAULT_MODE;
PJ_LOG(4,(ilbc_codec->obj_name,
"Normalized iLBC encoder and decoder modes to %d",
DEFAULT_MODE));
}
/* Update some attributes based on negotiated mode. */
attr->info.avg_bps = (dec_fmtp_mode == 30? 13333 : 15200);
attr->info.frm_ptime = dec_fmtp_mode;
/* Create encoder */
#if defined(PJMEDIA_ILBC_CODEC_USE_COREAUDIO)&& PJMEDIA_ILBC_CODEC_USE_COREAUDIO
dstFormat.mFramesPerPacket = CLOCK_RATE * enc_fmtp_mode / 1000;
dstFormat.mBytesPerPacket = (enc_fmtp_mode == 20? 38 : 50);
/* Use AudioFormat API to fill out the rest of the description */
size = sizeof(dstFormat);
AudioFormatGetProperty(kAudioFormatProperty_FormatInfo,
0, NULL, &size, &dstFormat);
if (AudioConverterNew(&srcFormat, &dstFormat, &ilbc_codec->enc) != noErr)
return PJMEDIA_CODEC_EFAILED;
ilbc_codec->enc_frame_size = (enc_fmtp_mode == 20? 38 : 50);
#else
ilbc_codec->enc_frame_size = initEncode(&ilbc_codec->enc, enc_fmtp_mode);
#endif
ilbc_codec->enc_samples_per_frame = CLOCK_RATE * enc_fmtp_mode / 1000;
ilbc_codec->enc_ready = PJ_TRUE;
/* Create decoder */
#if defined(PJMEDIA_ILBC_CODEC_USE_COREAUDIO)&& PJMEDIA_ILBC_CODEC_USE_COREAUDIO
if (AudioConverterNew(&dstFormat, &srcFormat, &ilbc_codec->dec) != noErr)
return PJMEDIA_CODEC_EFAILED;
ilbc_codec->dec_samples_per_frame = CLOCK_RATE * dec_fmtp_mode / 1000;
#else
ilbc_codec->dec_samples_per_frame = initDecode(&ilbc_codec->dec,
dec_fmtp_mode,
attr->setting.penh);
#endif
ilbc_codec->dec_frame_size = (dec_fmtp_mode == 20? 38 : 50);
ilbc_codec->dec_ready = PJ_TRUE;
/* Save plc flags */
ilbc_codec->plc_enabled = (attr->setting.plc != 0);
/* Create silence detector. */
ilbc_codec->vad_enabled = (attr->setting.vad != 0);
status = pjmedia_silence_det_create(ilbc_codec->pool, CLOCK_RATE,
ilbc_codec->enc_samples_per_frame,
&ilbc_codec->vad);
if (status != PJ_SUCCESS)
return status;
/* Init last_tx (not necessary because of zalloc, but better
* be safe in case someone remove zalloc later.
*/
pj_set_timestamp32(&ilbc_codec->last_tx, 0, 0);
PJ_LOG(4,(ilbc_codec->obj_name,
"iLBC codec opened, mode=%d", dec_fmtp_mode));
return PJ_SUCCESS;
}
/* API: create stream */
static pj_status_t opensl_create_stream(pjmedia_aud_dev_factory *f,
const pjmedia_aud_param *param,
pjmedia_aud_rec_cb rec_cb,
pjmedia_aud_play_cb play_cb,
void *user_data,
pjmedia_aud_stream **p_aud_strm)
{
/* Audio sink for recorder and audio source for player */
#ifdef __ANDROID__
SLDataLocator_AndroidSimpleBufferQueue loc_bq =
{ SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, NUM_BUFFERS };
#else
SLDataLocator_BufferQueue loc_bq = { SL_DATALOCATOR_BUFFERQUEUE, NUM_BUFFERS };
#endif
struct opensl_aud_factory *pa = (struct opensl_aud_factory*)f;
pj_pool_t *pool;
struct opensl_aud_stream *stream;
pj_status_t status = PJ_SUCCESS;
int i, bufferSize;
SLresult result;
SLDataFormat_PCM format_pcm;
/* Only supports for mono channel for now */
PJ_ASSERT_RETURN(param->channel_count == 1, PJ_EINVAL);
PJ_ASSERT_RETURN(play_cb && rec_cb && p_aud_strm, PJ_EINVAL);
PJ_LOG(4,(THIS_FILE, "Creating OpenSL stream"));
pool = pj_pool_create(pa->pf, "openslstrm", 1024, 1024, NULL);
if (!pool)
return PJ_ENOMEM;
stream = PJ_POOL_ZALLOC_T(pool, struct opensl_aud_stream);
stream->pool = pool;
pj_strdup2_with_null(pool, &stream->name, "OpenSL");
stream->dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
pj_memcpy(&stream->param, param, sizeof(*param));
stream->user_data = user_data;
stream->rec_cb = rec_cb;
stream->play_cb = play_cb;
bufferSize = param->samples_per_frame * param->bits_per_sample / 8;
/* Configure audio PCM format */
format_pcm.formatType = SL_DATAFORMAT_PCM;
format_pcm.numChannels = param->channel_count;
/* Here samples per sec should be supported else we will get an error */
format_pcm.samplesPerSec = (SLuint32) param->clock_rate * 1000;
format_pcm.bitsPerSample = (SLuint16) param->bits_per_sample;
format_pcm.containerSize = (SLuint16) param->bits_per_sample;
format_pcm.channelMask = SL_SPEAKER_FRONT_CENTER;
format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
status = on_validate_audio_clock_rate_wrapper(param->clock_rate);
if(status != PJ_SUCCESS){
return PJMEDIA_EAUD_INVOP;
}
on_setup_audio_wrapper(PJ_TRUE);
if (stream->dir & PJMEDIA_DIR_PLAYBACK) {
/* Audio source */
SLDataSource audioSrc = {&loc_bq, &format_pcm};
/* Audio sink */
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX,
pa->outputMixObject};
SLDataSink audioSnk = {&loc_outmix, NULL};
/* Audio interface */
#ifdef __ANDROID__
int numIface = 3;
const SLInterfaceID ids[3] = {W_SL_IID_BUFFERQUEUE,
SL_IID_VOLUME,
SL_IID_ANDROIDCONFIGURATION};
const SLboolean req[3] = {SL_BOOLEAN_TRUE,
SL_BOOLEAN_TRUE,
SL_BOOLEAN_TRUE};
SLAndroidConfigurationItf playerConfig;
SLint32 streamType = SL_ANDROID_STREAM_VOICE;
#else
const SLInterfaceID ids[2] = {W_SL_IID_BUFFERQUEUE,
SL_IID_VOLUME};
const SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
int numIface = 2;
#endif
/* Create audio player */
result = (*pa->engineEngine)->CreateAudioPlayer(pa->engineEngine,
&stream->playerObj,
&audioSrc, &audioSnk,
numIface, ids, req);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot create audio player: %d", result));
goto on_error;
}
#ifdef __ANDROID__
/* Set Android configuration */
result = (*stream->playerObj)->GetInterface(stream->playerObj,
SL_IID_ANDROIDCONFIGURATION,
&playerConfig);
if (result == SL_RESULT_SUCCESS && playerConfig) {
result = (*playerConfig)->SetConfiguration(
playerConfig, SL_ANDROID_KEY_STREAM_TYPE,
&streamType, sizeof(SLint32));
}
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(4, (THIS_FILE, "Warning: Unable to set android "
"player configuration"));
}
#endif
/* Realize the player */
result = (*stream->playerObj)->Realize(stream->playerObj,
SL_BOOLEAN_FALSE);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot realize player : %d", result));
goto on_error;
}
/* Get the play interface */
result = (*stream->playerObj)->GetInterface(stream->playerObj,
SL_IID_PLAY,
&stream->playerPlay);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot get play interface"));
goto on_error;
}
/* Get the buffer queue interface */
result = (*stream->playerObj)->GetInterface(stream->playerObj,
W_SL_IID_BUFFERQUEUE,
&stream->playerBufQ);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot get buffer queue interface"));
goto on_error;
}
/* Get the volume interface */
result = (*stream->playerObj)->GetInterface(stream->playerObj,
SL_IID_VOLUME,
&stream->playerVol);
/* Register callback on the buffer queue */
result = (*stream->playerBufQ)->RegisterCallback(stream->playerBufQ,
bqPlayerCallback,
(void *)stream);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot register player callback"));
goto on_error;
}
stream->playerBufferSize = bufferSize;
for (i = 0; i < NUM_BUFFERS; i++) {
stream->playerBuffer[i] = (char *)
pj_pool_alloc(stream->pool,
stream->playerBufferSize);
}
}
if (stream->dir & PJMEDIA_DIR_CAPTURE) {
/* Audio source */
SLDataLocator_IODevice loc_dev = {SL_DATALOCATOR_IODEVICE,
SL_IODEVICE_AUDIOINPUT,
SL_DEFAULTDEVICEID_AUDIOINPUT,
NULL};
SLDataSource audioSrc = {&loc_dev, NULL};
/* Audio sink */
SLDataSink audioSnk = {&loc_bq, &format_pcm};
/* Audio interface */
#ifdef __ANDROID__
int numIface = 2;
const SLInterfaceID ids[2] = {W_SL_IID_BUFFERQUEUE,
SL_IID_ANDROIDCONFIGURATION};
const SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
SLAndroidConfigurationItf recorderConfig;
#else
int numIface = 1;
const SLInterfaceID ids[1] = {W_SL_IID_BUFFERQUEUE};
const SLboolean req[1] = {SL_BOOLEAN_TRUE};
#endif
/* Create audio recorder
* (requires the RECORD_AUDIO permission)
*/
result = (*pa->engineEngine)->CreateAudioRecorder(pa->engineEngine,
&stream->recordObj,
&audioSrc, &audioSnk,
numIface, ids, req);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot create recorder: %d", result));
goto on_error;
}
#ifdef __ANDROID__
/* Set Android configuration */
result = (*stream->recordObj)->GetInterface(stream->recordObj,
SL_IID_ANDROIDCONFIGURATION,
&recorderConfig);
if (result == SL_RESULT_SUCCESS) {
SLint32 streamType = SL_ANDROID_RECORDING_PRESET_GENERIC;
#if __ANDROID_API__ >= 14
char sdk_version[PROP_VALUE_MAX];
pj_str_t pj_sdk_version;
int sdk_v;
__system_property_get("ro.build.version.sdk", sdk_version);
pj_sdk_version = pj_str(sdk_version);
sdk_v = pj_strtoul(&pj_sdk_version);
if (sdk_v >= 14)
streamType = SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;
PJ_LOG(4, (THIS_FILE, "Recording stream type %d, SDK : %d",
streamType, sdk_v));
#endif
result = (*recorderConfig)->SetConfiguration(
recorderConfig, SL_ANDROID_KEY_RECORDING_PRESET,
&streamType, sizeof(SLint32));
}
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(4, (THIS_FILE, "Warning: Unable to set android "
"recorder configuration"));
}
#endif
/* Realize the recorder */
result = (*stream->recordObj)->Realize(stream->recordObj,
SL_BOOLEAN_FALSE);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot realize recorder : %d", result));
goto on_error;
}
/* Get the record interface */
result = (*stream->recordObj)->GetInterface(stream->recordObj,
SL_IID_RECORD,
&stream->recordRecord);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot get record interface"));
goto on_error;
}
/* Get the buffer queue interface */
result = (*stream->recordObj)->GetInterface(
stream->recordObj, W_SL_IID_BUFFERQUEUE,
&stream->recordBufQ);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot get recorder buffer queue iface"));
goto on_error;
}
/* Register callback on the buffer queue */
result = (*stream->recordBufQ)->RegisterCallback(stream->recordBufQ,
bqRecorderCallback,
(void *) stream);
if (result != SL_RESULT_SUCCESS) {
PJ_LOG(3, (THIS_FILE, "Cannot register recorder callback"));
goto on_error;
}
stream->recordBufferSize = bufferSize;
for (i = 0; i < NUM_BUFFERS; i++) {
stream->recordBuffer[i] = (char *)
pj_pool_alloc(stream->pool,
stream->recordBufferSize);
}
}
if (param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING) {
strm_set_cap(&stream->base, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING,
¶m->output_vol);
}
/* Done */
stream->base.op = &opensl_strm_op;
*p_aud_strm = &stream->base;
return PJ_SUCCESS;
on_error:
strm_destroy(&stream->base);
return PJMEDIA_EAUD_INVOP;
}
/* Try to match offer with answer. */
static pj_status_t match_offer(pj_pool_t *pool,
pj_bool_t prefer_remote_codec_order,
const pjmedia_sdp_media *offer,
const pjmedia_sdp_media *preanswer,
pjmedia_sdp_media **p_answer)
{
unsigned i;
pj_bool_t master_has_codec = 0,
master_has_telephone_event = 0,
master_has_other = 0,
found_matching_codec = 0,
found_matching_telephone_event = 0,
found_matching_other = 0;
unsigned pt_answer_count = 0;
pj_str_t pt_answer[PJMEDIA_MAX_SDP_FMT];
pjmedia_sdp_media *answer;
const pjmedia_sdp_media *master, *slave;
pj_str_t pt_amr_need_adapt = {NULL, 0};
/* If offer has zero port, just clone the offer */
if (offer->desc.port == 0) {
answer = pjmedia_sdp_media_clone_deactivate(pool, offer);
*p_answer = answer;
return PJ_SUCCESS;
}
/* Set master/slave negotiator based on prefer_remote_codec_order. */
if (prefer_remote_codec_order) {
master = offer;
slave = preanswer;
} else {
master = preanswer;
slave = offer;
}
/* With the addition of telephone-event and dodgy MS RTC SDP,
* the answer generation algorithm looks really shitty...
*/
for (i=0; i<master->desc.fmt_count; ++i) {
unsigned j;
if (pj_isdigit(*master->desc.fmt[i].ptr)) {
/* This is normal/standard payload type, where it's identified
* by payload number.
*/
unsigned pt;
pt = pj_strtoul(&master->desc.fmt[i]);
if (pt < 96) {
/* For static payload type, it's enough to compare just
* the payload number.
*/
master_has_codec = 1;
/* We just need to select one codec.
* Continue if we have selected matching codec for previous
* payload.
*/
if (found_matching_codec)
continue;
/* Find matching codec in local descriptor. */
for (j=0; j<slave->desc.fmt_count; ++j) {
unsigned p;
p = pj_strtoul(&slave->desc.fmt[j]);
if (p == pt && pj_isdigit(*slave->desc.fmt[j].ptr)) {
found_matching_codec = 1;
pt_answer[pt_answer_count++] = slave->desc.fmt[j];
break;
}
}
} else {
/* This is dynamic payload type.
* For dynamic payload type, we must look the rtpmap and
* compare the encoding name.
*/
const pjmedia_sdp_attr *a;
pjmedia_sdp_rtpmap or_;
pj_bool_t is_codec;
/* Get the rtpmap for the payload type in the master. */
a = pjmedia_sdp_media_find_attr2(master, "rtpmap",
&master->desc.fmt[i]);
if (!a) {
pj_assert(!"Bug! Offer should have been validated");
return PJMEDIA_SDP_EMISSINGRTPMAP;
}
pjmedia_sdp_attr_get_rtpmap(a, &or_);
if (!pj_stricmp2(&or_.enc_name, "telephone-event")) {
master_has_telephone_event = 1;
if (found_matching_telephone_event)
continue;
is_codec = 0;
} else {
master_has_codec = 1;
if (found_matching_codec)
continue;
is_codec = 1;
}
/* Find paylaod in our initial SDP with matching
* encoding name and clock rate.
*/
for (j=0; j<slave->desc.fmt_count; ++j) {
a = pjmedia_sdp_media_find_attr2(slave, "rtpmap",
&slave->desc.fmt[j]);
if (a) {
pjmedia_sdp_rtpmap lr;
pjmedia_sdp_attr_get_rtpmap(a, &lr);
/* See if encoding name, clock rate, and
* channel count match
*/
if (!pj_stricmp(&or_.enc_name, &lr.enc_name) &&
or_.clock_rate == lr.clock_rate &&
(pj_stricmp(&or_.param, &lr.param)==0 ||
(lr.param.slen==0 && or_.param.slen==1 &&
*or_.param.ptr=='1') ||
(or_.param.slen==0 && lr.param.slen==1 &&
*lr.param.ptr=='1')))
{
/* Match! */
if (is_codec) {
/* Further check for G7221, negotiate bitrate */
if (pj_stricmp2(&or_.enc_name, "G7221") == 0 &&
!match_g7221(master, i, slave, j))
{
continue;
} else
/* Further check for AMR, negotiate fmtp */
if (pj_stricmp2(&or_.enc_name, "AMR")==0 ||
pj_stricmp2(&or_.enc_name, "AMR-WB")==0)
{
unsigned o_med_idx, a_med_idx;
o_med_idx = prefer_remote_codec_order? i:j;
a_med_idx = prefer_remote_codec_order? j:i;
if (!match_amr(offer, o_med_idx,
preanswer, a_med_idx,
PJ_TRUE, &pt_amr_need_adapt))
continue;
}
found_matching_codec = 1;
} else {
found_matching_telephone_event = 1;
}
pt_answer[pt_answer_count++] =
prefer_remote_codec_order?
preanswer->desc.fmt[j]:
preanswer->desc.fmt[i];
break;
}
}
}
}
} else {
/* This is a non-standard, brain damaged SDP where the payload
* type is non-numeric. It exists e.g. in Microsoft RTC based
* UA, to indicate instant messaging capability.
* Example:
* - m=x-ms-message 5060 sip null
*/
master_has_other = 1;
if (found_matching_other)
continue;
for (j=0; j<slave->desc.fmt_count; ++j) {
if (!pj_strcmp(&master->desc.fmt[i], &slave->desc.fmt[j])) {
/* Match */
found_matching_other = 1;
pt_answer[pt_answer_count++] = prefer_remote_codec_order?
preanswer->desc.fmt[j]:
preanswer->desc.fmt[i];
break;
}
}
}
}
/* See if all types of master can be matched. */
if (master_has_codec && !found_matching_codec) {
return PJMEDIA_SDPNEG_NOANSCODEC;
}
/* If this comment is removed, negotiation will fail if remote has offered
telephone-event and local is not configured with telephone-event
if (offer_has_telephone_event && !found_matching_telephone_event) {
return PJMEDIA_SDPNEG_NOANSTELEVENT;
}
*/
if (master_has_other && !found_matching_other) {
return PJMEDIA_SDPNEG_NOANSUNKNOWN;
}
/* Seems like everything is in order.
* Build the answer by cloning from preanswer, but rearrange the payload
* to suit the offer.
*/
answer = pjmedia_sdp_media_clone(pool, preanswer);
for (i=0; i<pt_answer_count; ++i) {
unsigned j;
for (j=i; j<answer->desc.fmt_count; ++j) {
if (!pj_strcmp(&answer->desc.fmt[j], &pt_answer[i]))
break;
}
pj_assert(j != answer->desc.fmt_count);
str_swap(&answer->desc.fmt[i], &answer->desc.fmt[j]);
/* For AMR/AMRWB format, adapt octet-align setting if required. */
if (!pj_strcmp(&pt_amr_need_adapt, &pt_answer[i]))
amr_toggle_octet_align(pool, answer, i);
}
/* Remove unwanted local formats. */
for (i=pt_answer_count; i<answer->desc.fmt_count; ++i) {
pjmedia_sdp_attr *a;
/* Remove rtpmap for this format */
a = pjmedia_sdp_media_find_attr2(answer, "rtpmap",
&answer->desc.fmt[i]);
if (a) {
pjmedia_sdp_media_remove_attr(answer, a);
}
/* Remove fmtp for this format */
a = pjmedia_sdp_media_find_attr2(answer, "fmtp",
&answer->desc.fmt[i]);
if (a) {
pjmedia_sdp_media_remove_attr(answer, a);
}
}
answer->desc.fmt_count = pt_answer_count;
/* Update media direction. */
update_media_direction(pool, offer, answer);
*p_answer = answer;
return PJ_SUCCESS;
}
int string_test(void)
{
const pj_str_t hello_world = { HELLO_WORLD, HELLO_WORLD_LEN };
const pj_str_t just_hello = { JUST_HELLO, JUST_HELLO_LEN };
pj_str_t s1, s2, s3, s4, s5;
enum { RCOUNT = 10, RLEN = 16 };
pj_str_t random[RCOUNT];
pj_pool_t *pool;
int i;
pool = pj_pool_create(mem, SNULL, 4096, 0, SNULL);
if (!pool) return -5;
/*
* pj_str(), pj_strcmp(), pj_stricmp(), pj_strlen(),
* pj_strncmp(), pj_strchr()
*/
s1 = pj_str(HELLO_WORLD);
if (pj_strcmp(&s1, &hello_world) != 0)
return -10;
if (pj_stricmp(&s1, &hello_world) != 0)
return -20;
if (pj_strcmp(&s1, &just_hello) <= 0)
return -30;
if (pj_stricmp(&s1, &just_hello) <= 0)
return -40;
if (pj_strlen(&s1) != strlen(HELLO_WORLD))
return -50;
if (pj_strncmp(&s1, &hello_world, 5) != 0)
return -60;
if (pj_strnicmp(&s1, &hello_world, 5) != 0)
return -70;
if (pj_strchr(&s1, HELLO_WORLD[1]) != s1.ptr+1)
return -80;
/*
* pj_strdup()
*/
if (!pj_strdup(pool, &s2, &s1))
return -100;
if (pj_strcmp(&s1, &s2) != 0)
return -110;
/*
* pj_strcpy(), pj_strcat()
*/
s3.ptr = (char*) pj_pool_alloc(pool, 256);
if (!s3.ptr)
return -200;
pj_strcpy(&s3, &s2);
pj_strcat(&s3, &just_hello);
if (pj_strcmp2(&s3, HELLO_WORLD JUST_HELLO) != 0)
return -210;
/*
* pj_strdup2(), pj_strtrim().
*/
pj_strdup2(pool, &s4, " " HELLO_WORLD "\t ");
pj_strtrim(&s4);
if (pj_strcmp2(&s4, HELLO_WORLD) != 0)
return -250;
/*
* pj_utoa()
*/
s5.ptr = (char*) pj_pool_alloc(pool, 16);
if (!s5.ptr)
return -270;
s5.slen = pj_utoa(UL_VALUE, s5.ptr);
/*
* pj_strtoul()
*/
if (pj_strtoul(&s5) != UL_VALUE)
return -280;
/*
* pj_strtoul2()
*/
s5 = pj_str("123456");
pj_strtoul2(&s5, SNULL, 10); /* Crash test */
if (pj_strtoul2(&s5, &s4, 10) != 123456UL)
return -290;
if (s4.slen != 0)
return -291;
if (pj_strtoul2(&s5, &s4, 16) != 0x123456UL)
return -292;
s5 = pj_str("0123ABCD");
if (pj_strtoul2(&s5, &s4, 10) != 123)
return -293;
if (s4.slen != 4)
return -294;
if (s4.ptr == SNULL || *s4.ptr != 'A')
return -295;
if (pj_strtoul2(&s5, &s4, 16) != 0x123ABCDUL)
return -296;
if (s4.slen != 0)
return -297;
/*
* pj_create_random_string()
* Check that no duplicate strings are returned.
*/
for (i=0; i<RCOUNT; ++i) {
int j;
random[i].ptr = (char*) pj_pool_alloc(pool, RLEN);
if (!random[i].ptr)
return -320;
random[i].slen = RLEN;
pj_create_random_string(random[i].ptr, RLEN);
for (j=0; j<i; ++j) {
if (pj_strcmp(&random[i], &random[j])==0)
return -330;
}
}
/* Done. */
pj_pool_release(pool);
/* Case sensitive comparison test. */
i = strcmp_test();
if (i != 0)
return i;
/* Caseless comparison test. */
i = stricmp_test();
if (i != 0)
return i;
return 0;
}