static void check_telev(struct audio *a, struct autx *tx)
{
const struct sdp_format *fmt;
bool marker = false;
int err;
tx->mb->pos = tx->mb->end = STREAM_PRESZ;
err = telev_poll(a->telev, &marker, tx->mb);
if (err)
return;
if (marker)
tx->ts_tel = tx->ts;
fmt = sdp_media_rformat(stream_sdpmedia(audio_strm(a)), telev_rtpfmt);
if (!fmt)
return;
tx->mb->pos = STREAM_PRESZ;
err = stream_send(a->strm, marker, fmt->pt, tx->ts_tel, tx->mb);
if (err) {
DEBUG_WARNING("telev: stream_send %m\n", err);
}
}
/**
* Check if the current call has an active audio stream
*
* @param call Call object
*
* @return True if active stream, otherwise false
*/
bool call_has_audio(const struct call *call)
{
if (!call)
return false;
return sdp_media_has_media(stream_sdpmedia(audio_strm(call->audio)));
}
static int update_media(struct call *call)
{
const struct sdp_format *sc;
struct le *le;
int err = 0;
/* media attributes */
audio_sdp_attr_decode(call->audio);
#ifdef USE_VIDEO
if (call->video)
video_sdp_attr_decode(call->video);
#endif
/* Update each stream */
FOREACH_STREAM {
stream_update(le->data);
}
if (call->acc->mnat && call->acc->mnat->updateh && call->mnats)
err = call->acc->mnat->updateh(call->mnats);
sc = sdp_media_rformat(stream_sdpmedia(audio_strm(call->audio)), NULL);
if (sc) {
struct aucodec *ac = sc->data;
if (ac) {
err = audio_decoder_set(call->audio, sc->data,
sc->pt, sc->params);
err |= audio_encoder_set(call->audio, sc->data,
sc->pt, sc->params);
}
else {
info("no common audio-codecs..\n");
}
}
else {
info("audio stream is disabled..\n");
}
#ifdef USE_VIDEO
sc = sdp_media_rformat(stream_sdpmedia(video_strm(call->video)), NULL);
if (sc) {
err = video_encoder_set(call->video, sc->data,
sc->pt, sc->params);
if (err) {
warning("call: video stream error: %m\n", err);
}
}
else if (call->video) {
info("video stream is disabled..\n");
}
#endif
return err;
}
static bool have_common_audio_codecs(const struct call *call)
{
const struct sdp_format *sc;
struct aucodec *ac;
sc = sdp_media_rformat(stream_sdpmedia(audio_strm(call->audio)), NULL);
if (!sc)
return false;
ac = sc->data; /* note: this will exclude telephone-event */
return ac != NULL;
}
static bool have_common_audio_codecs(const struct call *call)
{
const struct sdp_format *sc;
struct aucodec *ac;
sc = sdp_media_rformat(stream_sdpmedia(audio_strm(call->audio)), NULL);
if (!sc)
return false;
ac = sc->data;
return ac != NULL;
}
static int add_telev_codec(struct audio *a)
{
struct sdp_media *m = stream_sdpmedia(audio_strm(a));
struct sdp_format *sf;
int err;
/* Use payload-type 101 if available, for CiscoGW interop */
err = sdp_format_add(&sf, m, false, (!sdp_media_lformat(m, 101)) ? "101" : NULL, telev_rtpfmt, TELEV_SRATE, 1, NULL, NULL, NULL, false, "0-15");
if (err) return err;
a->rx.pt_tel = sf->pt;
return err;
}
/**
* Use the next audio encoder in the local list of negotiated codecs
*
* @param audio Audio object
*/
void audio_encoder_cycle(struct audio *audio)
{
const struct sdp_format *rc = NULL;
if (!audio)
return;
rc = sdp_media_format_cycle(stream_sdpmedia(audio_strm(audio)));
if (!rc) {
info("audio: encoder cycle: no remote codec found\n");
return;
}
(void)audio_encoder_set(audio, rc->data, rc->pt, rc->params);
}
int call_accept(struct call *call, struct sipsess_sock *sess_sock,
const struct sip_msg *msg)
{
bool got_offer;
int err;
if (!call || !msg)
return EINVAL;
call->outgoing = false;
got_offer = (mbuf_get_left(msg->mb) > 0);
err = pl_strdup(&call->peer_uri, &msg->from.auri);
if (err)
return err;
if (pl_isset(&msg->from.dname)) {
err = pl_strdup(&call->peer_name, &msg->from.dname);
if (err)
return err;
}
if (got_offer) {
struct sdp_media *m;
const struct sa *raddr;
err = sdp_decode(call->sdp, msg->mb, true);
if (err)
return err;
call->got_offer = true;
/*
* Each media description in the SDP answer MUST
* use the same network type as the corresponding
* media description in the offer.
*
* See RFC 6157
*/
m = stream_sdpmedia(audio_strm(call->audio));
raddr = sdp_media_raddr(m);
if (sa_af(raddr) != call->af) {
info("call: incompatible address-family"
" (local=%s, remote=%s)\n",
net_af2name(call->af),
net_af2name(sa_af(raddr)));
sip_treply(NULL, uag_sip(), msg,
488, "Not Acceptable Here");
call_event_handler(call, CALL_EVENT_CLOSED,
"Wrong address family");
return 0;
}
/* Check if we have any common audio codecs, after
* the SDP offer has been parsed
*/
if (!have_common_audio_codecs(call)) {
info("call: no common audio codecs - rejected\n");
sip_treply(NULL, uag_sip(), msg,
488, "Not Acceptable Here");
call_event_handler(call, CALL_EVENT_CLOSED,
"No audio codecs");
return 0;
}
}
err = sipsess_accept(&call->sess, sess_sock, msg, 180, "Ringing",
ua_cuser(call->ua), "application/sdp", NULL,
auth_handler, call->acc, true,
sipsess_offer_handler, sipsess_answer_handler,
sipsess_estab_handler, sipsess_info_handler,
sipsess_refer_handler, sipsess_close_handler,
call, "Allow: %s\r\n", uag_allowed_methods());
if (err) {
warning("call: sipsess_accept: %m\n", err);
return err;
}
set_state(call, STATE_INCOMING);
/* New call */
tmr_start(&call->tmr_inv, LOCAL_TIMEOUT*1000, invite_timeout, call);
if (!call->acc->mnat)
call_event_handler(call, CALL_EVENT_INCOMING, call->peer_uri);
return err;
}
static void call_stream_start(struct call *call, bool active)
{
const struct sdp_format *sc;
int err;
/* Audio Stream */
sc = sdp_media_rformat(stream_sdpmedia(audio_strm(call->audio)), NULL);
if (sc) {
struct aucodec *ac = sc->data;
if (ac) {
err = audio_encoder_set(call->audio, sc->data,
sc->pt, sc->params);
err |= audio_decoder_set(call->audio, sc->data,
sc->pt, sc->params);
if (!err) {
err = audio_start(call->audio);
}
if (err) {
warning("call: audio stream error: %m\n", err);
}
}
else {
info("call: no common audio-codecs..\n");
}
}
else {
info("call: audio stream is disabled..\n");
}
#ifdef USE_VIDEO
/* Video Stream */
sc = sdp_media_rformat(stream_sdpmedia(video_strm(call->video)), NULL);
if (sc) {
err = video_encoder_set(call->video, sc->data, sc->pt,
sc->params);
err |= video_decoder_set(call->video, sc->data, sc->pt,
sc->rparams);
if (!err) {
err = video_start(call->video, call->peer_uri);
}
if (err) {
warning("call: video stream error: %m\n", err);
}
}
else if (call->video) {
info("call: video stream is disabled..\n");
}
if (call->bfcp) {
err = bfcp_start(call->bfcp);
if (err) {
warning("call: could not start BFCP: %m\n", err);
}
}
#endif
if (active) {
struct le *le;
tmr_cancel(&call->tmr_inv);
call->time_start = time(NULL);
FOREACH_STREAM {
stream_reset(le->data);
}
}
}
