Merge "res_pjsip/res_pjsip_callerid: NULL check on caller id name string"
[asterisk/asterisk.git] / res / res_pjsip_sdp_rtp.c
index c97c0cb..97e365c 100644 (file)
 #include <pjmedia.h>
 #include <pjlib.h>
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
-
+#include "asterisk/utils.h"
 #include "asterisk/module.h"
+#include "asterisk/format.h"
+#include "asterisk/format_cap.h"
 #include "asterisk/rtp_engine.h"
 #include "asterisk/netsock2.h"
 #include "asterisk/channel.h"
@@ -48,6 +49,8 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include "asterisk/sched.h"
 #include "asterisk/acl.h"
 #include "asterisk/sdp_srtp.h"
+#include "asterisk/dsp.h"
+#include "asterisk/linkedlists.h"       /* for AST_LIST_NEXT */
 
 #include "asterisk/res_pjsip.h"
 #include "asterisk/res_pjsip_session.h"
@@ -55,11 +58,8 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 /*! \brief Scheduler for RTCP purposes */
 static struct ast_sched_context *sched;
 
-/*! \brief Address for IPv4 RTP */
-static struct ast_sockaddr address_ipv4;
-
-/*! \brief Address for IPv6 RTP */
-static struct ast_sockaddr address_ipv6;
+/*! \brief Address for RTP */
+static struct ast_sockaddr address_rtp;
 
 static const char STR_AUDIO[] = "audio";
 static const int FD_AUDIO = 0;
@@ -68,73 +68,193 @@ static const char STR_VIDEO[] = "video";
 static const int FD_VIDEO = 2;
 
 /*! \brief Retrieves an ast_format_type based on the given stream_type */
-static enum ast_format_type stream_to_media_type(const char *stream_type)
+static enum ast_media_type stream_to_media_type(const char *stream_type)
 {
        if (!strcasecmp(stream_type, STR_AUDIO)) {
-               return AST_FORMAT_TYPE_AUDIO;
+               return AST_MEDIA_TYPE_AUDIO;
        } else if (!strcasecmp(stream_type, STR_VIDEO)) {
-               return AST_FORMAT_TYPE_VIDEO;
+               return AST_MEDIA_TYPE_VIDEO;
        }
 
        return 0;
 }
 
 /*! \brief Get the starting descriptor for a media type */
-static int media_type_to_fdno(enum ast_format_type media_type)
+static int media_type_to_fdno(enum ast_media_type media_type)
 {
        switch (media_type) {
-       case AST_FORMAT_TYPE_AUDIO: return FD_AUDIO;
-       case AST_FORMAT_TYPE_VIDEO: return FD_VIDEO;
-       case AST_FORMAT_TYPE_TEXT:
-       case AST_FORMAT_TYPE_IMAGE: break;
+       case AST_MEDIA_TYPE_AUDIO: return FD_AUDIO;
+       case AST_MEDIA_TYPE_VIDEO: return FD_VIDEO;
+       case AST_MEDIA_TYPE_TEXT:
+       case AST_MEDIA_TYPE_UNKNOWN:
+       case AST_MEDIA_TYPE_IMAGE:
+       case AST_MEDIA_TYPE_END: break;
        }
        return -1;
 }
 
 /*! \brief Remove all other cap types but the one given */
-static void format_cap_only_type(struct ast_format_cap *caps, enum ast_format_type media_type)
+static void format_cap_only_type(struct ast_format_cap *caps, enum ast_media_type media_type)
 {
-       int i = AST_FORMAT_INC;
-       while (i <= AST_FORMAT_TYPE_TEXT) {
-               if (i != media_type) {
-                       ast_format_cap_remove_bytype(caps, i);
+       int i = 0;
+       while (i <= AST_MEDIA_TYPE_TEXT) {
+               if (i != media_type && i != AST_MEDIA_TYPE_UNKNOWN) {
+                       ast_format_cap_remove_by_type(caps, i);
                }
-               i += AST_FORMAT_INC;
+               i += 1;
+       }
+}
+
+static int send_keepalive(const void *data)
+{
+       struct ast_sip_session_media *session_media = (struct ast_sip_session_media *) data;
+       struct ast_rtp_instance *rtp = session_media->rtp;
+       int keepalive;
+       time_t interval;
+       int send_keepalive;
+
+       if (!rtp) {
+               return 0;
+       }
+
+       keepalive = ast_rtp_instance_get_keepalive(rtp);
+
+       if (!ast_sockaddr_isnull(&session_media->direct_media_addr)) {
+               ast_debug(3, "Not sending RTP keepalive on RTP instance %p since direct media is in use\n", rtp);
+               return keepalive * 1000;
+       }
+
+       interval = time(NULL) - ast_rtp_instance_get_last_tx(rtp);
+       send_keepalive = interval >= keepalive;
+
+       ast_debug(3, "It has been %d seconds since RTP was last sent on instance %p. %sending keepalive\n",
+                       (int) interval, rtp, send_keepalive ? "S" : "Not s");
+
+       if (send_keepalive) {
+               ast_rtp_instance_sendcng(rtp, 0);
+               return keepalive * 1000;
+       }
+
+       return (keepalive - interval) * 1000;
+}
+
+/*! \brief Check whether RTP is being received or not */
+static int rtp_check_timeout(const void *data)
+{
+       struct ast_sip_session_media *session_media = (struct ast_sip_session_media *)data;
+       struct ast_rtp_instance *rtp = session_media->rtp;
+       int elapsed;
+       struct ast_channel *chan;
+
+       if (!rtp) {
+               return 0;
+       }
+
+       elapsed = time(NULL) - ast_rtp_instance_get_last_rx(rtp);
+       if (elapsed < ast_rtp_instance_get_timeout(rtp)) {
+               return (ast_rtp_instance_get_timeout(rtp) - elapsed) * 1000;
+       }
+
+       chan = ast_channel_get_by_name(ast_rtp_instance_get_channel_id(rtp));
+       if (!chan) {
+               return 0;
+       }
+
+       ast_log(LOG_NOTICE, "Disconnecting channel '%s' for lack of RTP activity in %d seconds\n",
+               ast_channel_name(chan), elapsed);
+
+       ast_channel_lock(chan);
+       ast_channel_hangupcause_set(chan, AST_CAUSE_REQUESTED_CHAN_UNAVAIL);
+       ast_channel_unlock(chan);
+
+       ast_softhangup(chan, AST_SOFTHANGUP_DEV);
+       ast_channel_unref(chan);
+
+       return 0;
+}
+
+/*!
+ * \brief Enable RTCP on an RTP session.
+ */
+static void enable_rtcp(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
+       const struct pjmedia_sdp_media *remote_media)
+{
+       enum ast_rtp_instance_rtcp rtcp_type;
+
+       if (session->endpoint->media.rtcp_mux && session_media->remote_rtcp_mux) {
+               rtcp_type = AST_RTP_INSTANCE_RTCP_MUX;
+       } else {
+               rtcp_type = AST_RTP_INSTANCE_RTCP_STANDARD;
        }
+
+       ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_RTCP, rtcp_type);
 }
 
 /*! \brief Internal function which creates an RTP instance */
-static int create_rtp(struct ast_sip_session *session, struct ast_sip_session_media *session_media, unsigned int ipv6)
+static int create_rtp(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
 {
        struct ast_rtp_engine_ice *ice;
+       struct ast_sockaddr temp_media_address;
+       struct ast_sockaddr *media_address =  &address_rtp;
+
+       if (session->endpoint->media.bind_rtp_to_media_address && !ast_strlen_zero(session->endpoint->media.address)) {
+               if (ast_sockaddr_parse(&temp_media_address, session->endpoint->media.address, 0)) {
+                       ast_debug(1, "Endpoint %s: Binding RTP media to %s\n",
+                               ast_sorcery_object_get_id(session->endpoint),
+                               session->endpoint->media.address);
+                       media_address = &temp_media_address;
+               } else {
+                       ast_debug(1, "Endpoint %s: RTP media address invalid: %s\n",
+                               ast_sorcery_object_get_id(session->endpoint),
+                               session->endpoint->media.address);
+               }
+       } else {
+               struct ast_sip_transport *transport;
+
+               transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport",
+                       session->endpoint->transport);
+               if (transport) {
+                       struct ast_sip_transport_state *trans_state;
+
+                       trans_state = ast_sip_get_transport_state(ast_sorcery_object_get_id(transport));
+                       if (trans_state) {
+                               char hoststr[PJ_INET6_ADDRSTRLEN];
+
+                               pj_sockaddr_print(&trans_state->host, hoststr, sizeof(hoststr), 0);
+                               if (ast_sockaddr_parse(&temp_media_address, hoststr, 0)) {
+                                       ast_debug(1, "Transport %s bound to %s: Using it for RTP media.\n",
+                                               session->endpoint->transport, hoststr);
+                                       media_address = &temp_media_address;
+                               } else {
+                                       ast_debug(1, "Transport %s bound to %s: Invalid for RTP media.\n",
+                                               session->endpoint->transport, hoststr);
+                               }
+                               ao2_ref(trans_state, -1);
+                       }
+                       ao2_ref(transport, -1);
+               }
+       }
 
-       if (!(session_media->rtp = ast_rtp_instance_new(session->endpoint->media.rtp.engine, sched, ipv6 ? &address_ipv6 : &address_ipv4, NULL))) {
+       if (!(session_media->rtp = ast_rtp_instance_new(session->endpoint->media.rtp.engine, sched, media_address, NULL))) {
                ast_log(LOG_ERROR, "Unable to create RTP instance using RTP engine '%s'\n", session->endpoint->media.rtp.engine);
                return -1;
        }
 
-       ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_RTCP, 1);
        ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_NAT, session->endpoint->media.rtp.symmetric);
 
-       ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(session_media->rtp),
-                                        session_media->rtp, &session->endpoint->media.prefs);
-
-       if (session->endpoint->dtmf == AST_SIP_DTMF_INBAND) {
-               ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_INBAND);
-       }
-
        if (!session->endpoint->media.rtp.ice_support && (ice = ast_rtp_instance_get_ice(session_media->rtp))) {
                ice->stop(session_media->rtp);
        }
 
-       if (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733) {
+       if (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733 || session->endpoint->dtmf == AST_SIP_DTMF_AUTO) {
                ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_RFC2833);
+               ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_DTMF, 1);
        } else if (session->endpoint->dtmf == AST_SIP_DTMF_INBAND) {
                ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_INBAND);
        }
 
        if (!strcmp(session_media->stream_type, STR_AUDIO) &&
-                       (session->endpoint->media.tos_audio || session->endpoint->media.cos_video)) {
+                       (session->endpoint->media.tos_audio || session->endpoint->media.cos_audio)) {
                ast_rtp_instance_set_qos(session_media->rtp, session->endpoint->media.tos_audio,
                                session->endpoint->media.cos_audio, "SIP RTP Audio");
        } else if (!strcmp(session_media->stream_type, STR_VIDEO) &&
@@ -143,19 +263,24 @@ static int create_rtp(struct ast_sip_session *session, struct ast_sip_session_me
                                session->endpoint->media.cos_video, "SIP RTP Video");
        }
 
+       ast_rtp_instance_set_last_rx(session_media->rtp, time(NULL));
+
        return 0;
 }
 
-static void get_codecs(struct ast_sip_session *session, const struct pjmedia_sdp_media *stream, struct ast_rtp_codecs *codecs)
+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;
+       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);
 
@@ -174,106 +299,182 @@ static void get_codecs(struct ast_sip_session *session, const struct pjmedia_sdp
                }
 
                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, 0, rtpmap->clock_rate);
+               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) {
-                       sscanf(pj_strbuf(&fmtp.fmt), "%d", &num);
+                       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));
-                               ast_format_sdp_parse(format, 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);
+               }
+       }
 }
 
-static int set_caps(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
-                   const struct pjmedia_sdp_media *stream)
+static int set_caps(struct ast_sip_session *session,
+       struct ast_sip_session_media *session_media,
+       const struct pjmedia_sdp_media *stream,
+       int is_offer)
 {
-       RAII_VAR(struct ast_format_cap *, caps, NULL, ast_format_cap_destroy);
-       RAII_VAR(struct ast_format_cap *, peer, NULL, ast_format_cap_destroy);
-       RAII_VAR(struct ast_format_cap *, joint, NULL, ast_format_cap_destroy);
-       enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
-       struct ast_rtp_codecs codecs;
-       struct ast_format fmt;
+       RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_format_cap *, peer, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_format_cap *, joint, NULL, ao2_cleanup);
+       enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
+       struct ast_rtp_codecs codecs = AST_RTP_CODECS_NULL_INIT;
        int fmts = 0;
        int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
-               !ast_format_cap_is_empty(session->direct_media_cap);
+               ast_format_cap_count(session->direct_media_cap);
+       int dsp_features = 0;
 
-       if (!(caps = ast_format_cap_alloc_nolock()) ||
-           !(peer = ast_format_cap_alloc_nolock())) {
+       if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
+           !(peer = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
+           !(joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
                ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
                return -1;
        }
 
        /* get the endpoint capabilities */
        if (direct_media_enabled) {
-               ast_format_cap_joint_copy(session->endpoint->media.codecs, session->direct_media_cap, caps);
+               ast_format_cap_get_compatible(session->endpoint->media.codecs, session->direct_media_cap, caps);
+               format_cap_only_type(caps, media_type);
        } else {
-               ast_format_cap_copy(caps, session->endpoint->media.codecs);
+               ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, media_type);
        }
-       format_cap_only_type(caps, media_type);
 
        /* get the capabilities on the peer */
-       get_codecs(session, stream, &codecs);
+       get_codecs(session, stream, &codecs,  session_media);
        ast_rtp_codecs_payload_formats(&codecs, peer, &fmts);
 
        /* get the joint capabilities between peer and endpoint */
-       if (!(joint = ast_format_cap_joint(caps, peer))) {
-               char usbuf[64], thembuf[64];
+       ast_format_cap_get_compatible(caps, peer, joint);
+       if (!ast_format_cap_count(joint)) {
+               struct ast_str *usbuf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
+               struct ast_str *thembuf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
                ast_rtp_codecs_payloads_destroy(&codecs);
-
-               ast_getformatname_multiple(usbuf, sizeof(usbuf), caps);
-               ast_getformatname_multiple(thembuf, sizeof(thembuf), peer);
-               ast_log(LOG_WARNING, "No joint capabilities between our configuration(%s) and incoming SDP(%s)\n", usbuf, thembuf);
+               ast_log(LOG_NOTICE, "No joint capabilities for '%s' media stream between our configuration(%s) and incoming SDP(%s)\n",
+                       session_media->stream_type,
+                       ast_format_cap_get_names(caps, &usbuf),
+                       ast_format_cap_get_names(peer, &thembuf));
                return -1;
        }
 
+       if (is_offer) {
+               /*
+                * Setup rx payload type mapping to prefer the mapping
+                * from the peer that the RFC says we SHOULD use.
+                */
+               ast_rtp_codecs_payloads_xover(&codecs, &codecs, NULL);
+       }
        ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(session_media->rtp),
-                                    session_media->rtp);
+               session_media->rtp);
 
-       ast_format_cap_copy(caps, session->req_caps);
-       ast_format_cap_remove_bytype(caps, media_type);
-       ast_format_cap_append(caps, joint);
-       ast_format_cap_append(session->req_caps, caps);
+       ast_format_cap_append_from_cap(session->req_caps, joint, AST_MEDIA_TYPE_UNKNOWN);
 
        if (session->channel) {
-               ast_format_cap_copy(caps, ast_channel_nativeformats(session->channel));
-               ast_format_cap_remove_bytype(caps, media_type);
-               ast_codec_choose(&session->endpoint->media.prefs, joint, 1, &fmt);
-               ast_format_cap_add(caps, &fmt);
+               ast_channel_lock(session->channel);
+               ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_UNKNOWN);
+               ast_format_cap_append_from_cap(caps, ast_channel_nativeformats(session->channel),
+                       AST_MEDIA_TYPE_UNKNOWN);
+               ast_format_cap_remove_by_type(caps, media_type);
+               if (session->endpoint->preferred_codec_only){
+                       struct ast_format *preferred_fmt = ast_format_cap_get_format(joint, 0);
+                       ast_format_cap_append(caps, preferred_fmt, 0);
+                       ao2_ref(preferred_fmt, -1);
+               } else {
+                       ast_format_cap_append_from_cap(caps, joint, media_type);
+               }
+               /*
+                * Apply the new formats to the channel, potentially changing
+                * raw read/write formats and translation path while doing so.
+                */
+               ast_channel_nativeformats_set(session->channel, caps);
+               if (media_type == AST_MEDIA_TYPE_AUDIO) {
+                       ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
+                       ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
+               }
+               if ((session->endpoint->dtmf == AST_SIP_DTMF_AUTO)
+                   && (ast_rtp_instance_dtmf_mode_get(session_media->rtp) == AST_RTP_DTMF_MODE_RFC2833)
+                   && (session->dsp)) {
+                       dsp_features = ast_dsp_get_features(session->dsp);
+                       dsp_features &= ~DSP_FEATURE_DIGIT_DETECT;
+                       if (dsp_features) {
+                               ast_dsp_set_features(session->dsp, dsp_features);
+                       } else {
+                               ast_dsp_free(session->dsp);
+                               session->dsp = NULL;
+                       }
+               }
 
-               /* Apply the new formats to the channel, potentially changing read/write formats while doing so */
-               ast_format_cap_copy(ast_channel_nativeformats(session->channel), caps);
-               ast_format_copy(ast_channel_rawwriteformat(session->channel), &fmt);
-               ast_format_copy(ast_channel_rawreadformat(session->channel), &fmt);
-               ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
-               ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
+               if (ast_channel_is_bridged(session->channel)) {
+                       ast_channel_set_unbridged_nolock(session->channel, 1);
+               }
+
+               ast_channel_unlock(session->channel);
        }
 
        ast_rtp_codecs_payloads_destroy(&codecs);
-       return 1;
+       return 0;
 }
 
-static pjmedia_sdp_attr* generate_rtpmap_attr(pjmedia_sdp_media *media, pj_pool_t *pool, int rtp_code,
-                                             int asterisk_format, struct ast_format *format, int code)
+static pjmedia_sdp_attr* generate_rtpmap_attr(struct ast_sip_session *session, pjmedia_sdp_media *media, pj_pool_t *pool,
+                                             int rtp_code, int asterisk_format, struct ast_format *format, int code)
 {
+       extern pj_bool_t pjsip_use_compact_form;
        pjmedia_sdp_rtpmap rtpmap;
        pjmedia_sdp_attr *attr = NULL;
        char tmp[64];
+       enum ast_rtp_options options = session->endpoint->media.g726_non_standard ?
+               AST_RTP_OPT_G726_NONSTANDARD : 0;
 
        snprintf(tmp, sizeof(tmp), "%d", rtp_code);
        pj_strdup2(pool, &media->desc.fmt[media->desc.fmt_count++], tmp);
+
+       if (rtp_code <= AST_RTP_PT_LAST_STATIC && pjsip_use_compact_form) {
+               return NULL;
+       }
+
        rtpmap.pt = media->desc.fmt[media->desc.fmt_count - 1];
        rtpmap.clock_rate = ast_rtp_lookup_sample_rate2(asterisk_format, format, code);
-       pj_strdup2(pool, &rtpmap.enc_name, ast_rtp_lookup_mime_subtype2(asterisk_format, format, code, 0));
-       rtpmap.param.slen = 0;
+       pj_strdup2(pool, &rtpmap.enc_name, ast_rtp_lookup_mime_subtype2(asterisk_format, format, code, options));
+       if (!pj_stricmp2(&rtpmap.enc_name, "opus")) {
+               pj_cstr(&rtpmap.param, "2");
+       } else {
+               pj_cstr(&rtpmap.param, NULL);
+       }
 
        pjmedia_sdp_rtpmap_to_attr(pool, &rtpmap, &attr);
 
@@ -287,7 +488,7 @@ static pjmedia_sdp_attr* generate_fmtp_attr(pj_pool_t *pool, struct ast_format *
        pjmedia_sdp_attr *attr = NULL;
        char *tmp;
 
-       ast_format_sdp_generate(format, rtp_code, &fmtp0);
+       ast_format_generate_sdp_fmtp(format, rtp_code, &fmtp0);
        if (ast_str_strlen(fmtp0)) {
                tmp = ast_str_buffer(fmtp0) + ast_str_strlen(fmtp0) - 1;
                /* remove any carriage return line feeds */
@@ -295,7 +496,7 @@ static pjmedia_sdp_attr* generate_fmtp_attr(pj_pool_t *pool, struct ast_format *
                *++tmp = '\0';
                /* ast...generate gives us everything, just need value */
                tmp = strchr(ast_str_buffer(fmtp0), ':');
-               if (tmp && tmp + 1) {
+               if (tmp && tmp[1] != '\0') {
                        fmtp1 = pj_str(tmp + 1);
                } else {
                        fmtp1 = pj_str(ast_str_buffer(fmtp0));
@@ -305,18 +506,6 @@ static pjmedia_sdp_attr* generate_fmtp_attr(pj_pool_t *pool, struct ast_format *
        return attr;
 }
 
-static int codec_pref_has_type(struct ast_codec_pref *prefs, enum ast_format_type media_type)
-{
-       int i;
-       struct ast_format fmt;
-       for (i = 0; ast_codec_pref_index(prefs, i, &fmt); ++i) {
-               if (AST_FORMAT_GET_TYPE(fmt.id) == media_type) {
-                       return 1;
-               }
-       }
-       return 0;
-}
-
 /*! \brief Function which adds ICE attributes to a media stream */
 static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media, pj_pool_t *pool, pjmedia_sdp_media *media)
 {
@@ -347,8 +536,8 @@ static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_se
        for (; (candidate = ao2_iterator_next(&it_candidates)); ao2_ref(candidate, -1)) {
                struct ast_str *attr_candidate = ast_str_create(128);
 
-               ast_str_set(&attr_candidate, -1, "%s %d %s %d %s ", candidate->foundation, candidate->id, candidate->transport,
-                                       candidate->priority, ast_sockaddr_stringify_host(&candidate->address));
+               ast_str_set(&attr_candidate, -1, "%s %u %s %d %s ", candidate->foundation, candidate->id, candidate->transport,
+                                       candidate->priority, ast_sockaddr_stringify_addr_remote(&candidate->address));
                ast_str_append(&attr_candidate, -1, "%s typ ", ast_sockaddr_stringify_port(&candidate->address));
 
                switch (candidate->type) {
@@ -364,7 +553,7 @@ static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_se
                }
 
                if (!ast_sockaddr_isnull(&candidate->relay_address)) {
-                       ast_str_append(&attr_candidate, -1, " raddr %s rport ", ast_sockaddr_stringify_host(&candidate->relay_address));
+                       ast_str_append(&attr_candidate, -1, " raddr %s rport", ast_sockaddr_stringify_addr_remote(&candidate->relay_address));
                        ast_str_append(&attr_candidate, -1, " %s", ast_sockaddr_stringify_port(&candidate->relay_address));
                }
 
@@ -375,6 +564,7 @@ static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_se
        }
 
        ao2_iterator_destroy(&it_candidates);
+       ao2_ref(candidates, -1);
 }
 
 /*! \brief Function which processes ICE attributes in an audio stream */
@@ -391,14 +581,26 @@ static void process_ice_attributes(struct ast_sip_session *session, struct ast_s
                return;
        }
 
-       if ((attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-ufrag", NULL))) {
+       attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-ufrag", NULL);
+       if (!attr) {
+               attr = pjmedia_sdp_attr_find2(remote->attr_count, remote->attr, "ice-ufrag", NULL);
+       }
+       if (attr) {
                ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
                ice->set_authentication(session_media->rtp, attr_value, NULL);
+       } else {
+               return;
        }
 
-       if ((attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-pwd", NULL))) {
+       attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-pwd", NULL);
+       if (!attr) {
+               attr = pjmedia_sdp_attr_find2(remote->attr_count, remote->attr, "ice-pwd", NULL);
+       }
+       if (attr) {
                ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
                ice->set_authentication(session_media->rtp, NULL, attr_value);
+       } else {
+               return;
        }
 
        if (pjmedia_sdp_media_find_attr2(remote_stream, "ice-lite", NULL)) {
@@ -408,7 +610,7 @@ static void process_ice_attributes(struct ast_sip_session *session, struct ast_s
        /* Find all of the candidates */
        for (attr_i = 0; attr_i < remote_stream->attr_count; ++attr_i) {
                char foundation[32], transport[32], address[PJ_INET6_ADDRSTRLEN + 1], cand_type[6], relay_address[PJ_INET6_ADDRSTRLEN + 1] = "";
-               int port, relay_port = 0;
+               unsigned int port, relay_port = 0;
                struct ast_rtp_engine_ice_candidate candidate = { 0, };
 
                attr = remote_stream->attr[attr_i];
@@ -421,11 +623,18 @@ static void process_ice_attributes(struct ast_sip_session *session, struct ast_s
                ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
 
                if (sscanf(attr_value, "%31s %30u %31s %30u %46s %30u typ %5s %*s %23s %*s %30u", foundation, &candidate.id, transport,
-                       &candidate.priority, address, &port, cand_type, relay_address, &relay_port) < 7) {
+                       (unsigned *)&candidate.priority, address, &port, cand_type, relay_address, &relay_port) < 7) {
                        /* Candidate did not parse properly */
                        continue;
                }
 
+               if (session->endpoint->media.rtcp_mux && session_media->remote_rtcp_mux && candidate.id > 1) {
+                       /* Remote side may have offered RTP and RTCP candidates. However, if we're using RTCP MUX,
+                        * then we should ignore RTCP candidates.
+                        */
+                       continue;
+               }
+
                candidate.foundation = foundation;
                candidate.transport = transport;
 
@@ -453,49 +662,49 @@ static void process_ice_attributes(struct ast_sip_session *session, struct ast_s
                ice->add_remote_candidate(session_media->rtp, &candidate);
        }
 
+       ice->set_role(session_media->rtp, pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_TRUE ?
+               AST_RTP_ICE_ROLE_CONTROLLING : AST_RTP_ICE_ROLE_CONTROLLED);
        ice->start(session_media->rtp);
 }
 
-static void apply_packetization(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
-                        const struct pjmedia_sdp_media *remote_stream)
+/*! \brief figure out if media stream has crypto lines for sdes */
+static int media_stream_has_crypto(const struct pjmedia_sdp_media *stream)
 {
-       pjmedia_sdp_attr *attr;
-       pj_str_t value;
-       unsigned long framing;
-       int codec;
-       struct ast_codec_pref *pref = &ast_rtp_instance_get_codecs(session_media->rtp)->pref;
-
-       /* Apply packetization if available and configured to do so */
-       if (!session->endpoint->media.rtp.use_ptime || !(attr = pjmedia_sdp_media_find_attr2(remote_stream, "ptime", NULL))) {
-               return;
-       }
-
-       value = attr->value;
-       framing = pj_strtoul(pj_strltrim(&value));
+       int i;
 
-       for (codec = 0; codec < AST_RTP_MAX_PT; codec++) {
-               struct ast_rtp_payload_type format = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(
-                                                                                          session_media->rtp), codec);
+       for (i = 0; i < stream->attr_count; i++) {
+               pjmedia_sdp_attr *attr;
 
-               if (!format.asterisk_format) {
+               /* check the stream for the required crypto attribute */
+               attr = stream->attr[i];
+               if (pj_strcmp2(&attr->name, "crypto")) {
                        continue;
                }
 
-               ast_codec_pref_setsize(pref, &format.format, framing);
+               return 1;
        }
 
-       ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(session_media->rtp),
-                                        session_media->rtp, pref);
+       return 0;
 }
 
 /*! \brief figure out media transport encryption type from the media transport string */
-static enum ast_sip_session_media_encryption get_media_encryption_type(pj_str_t transport)
+static enum ast_sip_session_media_encryption get_media_encryption_type(pj_str_t transport,
+       const struct pjmedia_sdp_media *stream, unsigned int *optimistic)
 {
        RAII_VAR(char *, transport_str, ast_strndup(transport.ptr, transport.slen), ast_free);
+
+       *optimistic = 0;
+
+       if (!transport_str) {
+               return AST_SIP_MEDIA_TRANSPORT_INVALID;
+       }
        if (strstr(transport_str, "UDP/TLS")) {
                return AST_SIP_MEDIA_ENCRYPT_DTLS;
        } else if (strstr(transport_str, "SAVP")) {
                return AST_SIP_MEDIA_ENCRYPT_SDES;
+       } else if (media_stream_has_crypto(stream)) {
+               *optimistic = 1;
+               return AST_SIP_MEDIA_ENCRYPT_SDES;
        } else {
                return AST_SIP_MEDIA_ENCRYPT_NONE;
        }
@@ -516,20 +725,32 @@ static enum ast_sip_session_media_encryption check_endpoint_media_transport(
        const struct pjmedia_sdp_media *stream)
 {
        enum ast_sip_session_media_encryption incoming_encryption;
+       char transport_end = stream->desc.transport.ptr[stream->desc.transport.slen - 1];
+       unsigned int optimistic;
 
-       if (endpoint->media.rtp.use_avpf) {
-               char transport_end = stream->desc.transport.ptr[stream->desc.transport.slen - 1];
-               if (transport_end != 'F') {
-                       return AST_SIP_MEDIA_TRANSPORT_INVALID;
-               }
+       if ((transport_end == 'F' && !endpoint->media.rtp.use_avpf)
+               || (transport_end != 'F' && endpoint->media.rtp.use_avpf)) {
+               return AST_SIP_MEDIA_TRANSPORT_INVALID;
        }
 
-       incoming_encryption = get_media_encryption_type(stream->desc.transport);
+       incoming_encryption = get_media_encryption_type(stream->desc.transport, stream, &optimistic);
 
        if (incoming_encryption == endpoint->media.rtp.encryption) {
                return incoming_encryption;
        }
 
+       if (endpoint->media.rtp.force_avp ||
+               endpoint->media.rtp.encryption_optimistic) {
+               return incoming_encryption;
+       }
+
+       /* If an optimistic offer has been made but encryption is not enabled consider it as having
+        * no offer of crypto at all instead of invalid so the session proceeds.
+        */
+       if (optimistic) {
+               return AST_SIP_MEDIA_ENCRYPT_NONE;
+       }
+
        return AST_SIP_MEDIA_TRANSPORT_INVALID;
 }
 
@@ -579,57 +800,69 @@ static int setup_dtls_srtp(struct ast_sip_session *session,
        return 0;
 }
 
-static int parse_dtls_attrib(struct ast_sip_session_media *session_media,
-       const struct pjmedia_sdp_media *stream)
+static void apply_dtls_attrib(struct ast_sip_session_media *session_media,
+       pjmedia_sdp_attr *attr)
 {
-       int i;
        struct ast_rtp_engine_dtls *dtls = ast_rtp_instance_get_dtls(session_media->rtp);
+       pj_str_t *value;
 
-       for (i = 0; i < stream->attr_count; i++) {
-               pjmedia_sdp_attr *attr = stream->attr[i];
-               pj_str_t *value;
+       if (!attr->value.ptr || !dtls) {
+               return;
+       }
 
-               if (!attr->value.ptr) {
-                       continue;
-               }
+       value = pj_strtrim(&attr->value);
 
-               value = pj_strtrim(&attr->value);
-
-               if (!pj_strcmp2(&attr->name, "setup")) {
-                       if (!pj_stricmp2(value, "active")) {
-                               dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTIVE);
-                       } else if (!pj_stricmp2(value, "passive")) {
-                               dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_PASSIVE);
-                       } else if (!pj_stricmp2(value, "actpass")) {
-                               dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTPASS);
-                       } else if (!pj_stricmp2(value, "holdconn")) {
-                               dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_HOLDCONN);
-                       } else {
-                               ast_log(LOG_WARNING, "Unsupported setup attribute value '%*s'\n", (int)value->slen, value->ptr);
-                       }
-               } else if (!pj_strcmp2(&attr->name, "connection")) {
-                       if (!pj_stricmp2(value, "new")) {
-                               dtls->reset(session_media->rtp);
-                       } else if (!pj_stricmp2(value, "existing")) {
-                               /* Do nothing */
+       if (!pj_strcmp2(&attr->name, "setup")) {
+               if (!pj_stricmp2(value, "active")) {
+                       dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTIVE);
+               } else if (!pj_stricmp2(value, "passive")) {
+                       dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_PASSIVE);
+               } else if (!pj_stricmp2(value, "actpass")) {
+                       dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTPASS);
+               } else if (!pj_stricmp2(value, "holdconn")) {
+                       dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_HOLDCONN);
+               } else {
+                       ast_log(LOG_WARNING, "Unsupported setup attribute value '%*s'\n", (int)value->slen, value->ptr);
+               }
+       } else if (!pj_strcmp2(&attr->name, "connection")) {
+               if (!pj_stricmp2(value, "new")) {
+                       dtls->reset(session_media->rtp);
+               } else if (!pj_stricmp2(value, "existing")) {
+                       /* Do nothing */
+               } else {
+                       ast_log(LOG_WARNING, "Unsupported connection attribute value '%*s'\n", (int)value->slen, value->ptr);
+               }
+       } else if (!pj_strcmp2(&attr->name, "fingerprint")) {
+               char hash_value[256], hash[32];
+               char fingerprint_text[value->slen + 1];
+               ast_copy_pj_str(fingerprint_text, value, sizeof(fingerprint_text));
+                       if (sscanf(fingerprint_text, "%31s %255s", hash, hash_value) == 2) {
+                       if (!strcasecmp(hash, "sha-1")) {
+                               dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA1, hash_value);
+                       } else if (!strcasecmp(hash, "sha-256")) {
+                               dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA256, hash_value);
                        } else {
-                               ast_log(LOG_WARNING, "Unsupported connection attribute value '%*s'\n", (int)value->slen, value->ptr);
-                       }
-               } else if (!pj_strcmp2(&attr->name, "fingerprint")) {
-                       char hash_value[256], hash[6];
-                       char fingerprint_text[value->slen + 1];
-                       ast_copy_pj_str(fingerprint_text, value, sizeof(fingerprint_text));
-
-                       if (sscanf(fingerprint_text, "%5s %255s", hash, hash_value) == 2) {
-                               if (!strcasecmp(hash, "sha-1")) {
-                                       dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA1, hash_value);
-                               } else {
-                                       ast_log(LOG_WARNING, "Unsupported fingerprint hash type '%s'\n",
-                                       hash);
-                               }
+                               ast_log(LOG_WARNING, "Unsupported fingerprint hash type '%s'\n",
+                               hash);
                        }
                }
        }
+}
+
+static int parse_dtls_attrib(struct ast_sip_session_media *session_media,
+       const struct pjmedia_sdp_session *sdp,
+       const struct pjmedia_sdp_media *stream)
+{
+       int i;
+
+       for (i = 0; i < sdp->attr_count; i++) {
+               apply_dtls_attrib(session_media, sdp->attr[i]);
+       }
+
+       for (i = 0; i < stream->attr_count; i++) {
+               apply_dtls_attrib(session_media, stream->attr[i]);
+       }
+
        ast_set_flag(session_media->srtp, AST_SRTP_CRYPTO_OFFER_OK);
 
        return 0;
@@ -673,9 +906,10 @@ static int setup_sdes_srtp(struct ast_sip_session_media *session_media,
 
 static int setup_media_encryption(struct ast_sip_session *session,
        struct ast_sip_session_media *session_media,
+       const struct pjmedia_sdp_session *sdp,
        const struct pjmedia_sdp_media *stream)
 {
-       switch (session->endpoint->media.rtp.encryption) {
+       switch (session_media->encryption) {
        case AST_SIP_MEDIA_ENCRYPT_SDES:
                if (setup_sdes_srtp(session_media, stream)) {
                        return -1;
@@ -685,7 +919,7 @@ static int setup_media_encryption(struct ast_sip_session *session,
                if (setup_dtls_srtp(session, session_media)) {
                        return -1;
                }
-               if (parse_dtls_attrib(session_media, stream)) {
+               if (parse_dtls_attrib(session_media, sdp, stream)) {
                        return -1;
                }
                break;
@@ -697,22 +931,55 @@ static int setup_media_encryption(struct ast_sip_session *session,
        return 0;
 }
 
+static void set_ice_components(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
+{
+       struct ast_rtp_engine_ice *ice;
+
+       ast_assert(session_media->rtp != NULL);
+
+       ice = ast_rtp_instance_get_ice(session_media->rtp);
+       if (!session->endpoint->media.rtp.ice_support || !ice) {
+               return;
+       }
+
+       if (session->endpoint->media.rtcp_mux && session_media->remote_rtcp_mux) {
+               /* We both support RTCP mux. Only one ICE component necessary */
+               ice->change_components(session_media->rtp, 1);
+       } else {
+               /* They either don't support RTCP mux or we don't know if they do yet. */
+               ice->change_components(session_media->rtp, 2);
+       }
+}
+
 /*! \brief Function which negotiates an incoming media stream */
 static int negotiate_incoming_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
                                         const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
 {
        char host[NI_MAXHOST];
-       RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
-       enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
+       RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free);
+       enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
+       enum ast_sip_session_media_encryption encryption = AST_SIP_MEDIA_ENCRYPT_NONE;
+       int res;
+
+       /* If port is 0, ignore this media stream */
+       if (!stream->desc.port) {
+               ast_debug(3, "Media stream '%s' is already declined\n", session_media->stream_type);
+               return 0;
+       }
 
        /* If no type formats have been configured reject this stream */
        if (!ast_format_cap_has_type(session->endpoint->media.codecs, media_type)) {
+               ast_debug(3, "Endpoint has no codecs for media type '%s', declining stream\n", session_media->stream_type);
                return 0;
        }
 
        /* Ensure incoming transport is compatible with the endpoint's configuration */
-       if (check_endpoint_media_transport(session->endpoint, stream) == AST_SIP_MEDIA_TRANSPORT_INVALID) {
-               return -1;
+       if (!session->endpoint->media.rtp.use_received_transport) {
+               encryption = check_endpoint_media_transport(session->endpoint, stream);
+
+               if (encryption == AST_SIP_MEDIA_TRANSPORT_INVALID) {
+                       return -1;
+               }
        }
 
        ast_copy_pj_str(host, stream->conn ? &stream->conn->addr : &sdp->conn->addr, sizeof(host));
@@ -724,15 +991,43 @@ static int negotiate_incoming_sdp_stream(struct ast_sip_session *session, struct
        }
 
        /* Using the connection information create an appropriate RTP instance */
-       if (!session_media->rtp && create_rtp(session, session_media, ast_sockaddr_is_ipv6(addrs))) {
+       if (!session_media->rtp && create_rtp(session, session_media)) {
                return -1;
        }
 
-       if (setup_media_encryption(session, session_media, stream)) {
-               return -1;
-       }
+       session_media->remote_rtcp_mux = (pjmedia_sdp_media_find_attr2(stream, "rtcp-mux", NULL) != NULL);
+       set_ice_components(session, session_media);
+
+       enable_rtcp(session, session_media, stream);
 
-       return set_caps(session, session_media, stream);
+       res = setup_media_encryption(session, session_media, sdp, stream);
+       if (res) {
+               if (!session->endpoint->media.rtp.encryption_optimistic ||
+                       !pj_strncmp2(&stream->desc.transport, "RTP/SAVP", 8)) {
+                       /* If optimistic encryption is disabled and crypto should have been enabled
+                        * but was not this session must fail. This must also fail if crypto was
+                        * required in the offer but could not be set up.
+                        */
+                       return -1;
+               }
+               /* There is no encryption, sad. */
+               session_media->encryption = AST_SIP_MEDIA_ENCRYPT_NONE;
+       }
+
+       /* If we've been explicitly configured to use the received transport OR if
+        * encryption is on and crypto is present use the received transport.
+        * This is done in case of optimistic because it may come in as RTP/AVP or RTP/SAVP depending
+        * on the configuration of the remote endpoint (optimistic themselves or mandatory).
+        */
+       if ((session->endpoint->media.rtp.use_received_transport) ||
+               ((encryption == AST_SIP_MEDIA_ENCRYPT_SDES) && !res)) {
+               pj_strdup(session->inv_session->pool, &session_media->transport, &stream->desc.transport);
+       }
+
+       if (set_caps(session, session_media, stream, 1)) {
+               return 0;
+       }
+       return 1;
 }
 
 static int add_crypto_to_stream(struct ast_sip_session *session,
@@ -741,8 +1036,10 @@ static int add_crypto_to_stream(struct ast_sip_session *session,
 {
        pj_str_t stmp;
        pjmedia_sdp_attr *attr;
+       enum ast_rtp_dtls_hash hash;
        const char *crypto_attribute;
        struct ast_rtp_engine_dtls *dtls;
+       struct ast_sdp_srtp *tmp;
        static const pj_str_t STR_NEW = { "new", 3 };
        static const pj_str_t STR_EXISTING = { "existing", 8 };
        static const pj_str_t STR_ACTIVE = { "active", 6 };
@@ -750,7 +1047,7 @@ static int add_crypto_to_stream(struct ast_sip_session *session,
        static const pj_str_t STR_ACTPASS = { "actpass", 7 };
        static const pj_str_t STR_HOLDCONN = { "holdconn", 8 };
 
-       switch (session->endpoint->media.rtp.encryption) {
+       switch (session_media->encryption) {
        case AST_SIP_MEDIA_ENCRYPT_NONE:
        case AST_SIP_MEDIA_TRANSPORT_INVALID:
                break;
@@ -762,16 +1059,22 @@ static int add_crypto_to_stream(struct ast_sip_session *session,
                        }
                }
 
-               crypto_attribute = ast_sdp_srtp_get_attrib(session_media->srtp,
-                       0 /* DTLS running? No */,
-                       session->endpoint->media.rtp.srtp_tag_32 /* 32 byte tag length? */);
-               if (!crypto_attribute) {
-                       /* No crypto attribute to add, bad news */
-                       return -1;
-               }
+               tmp = session_media->srtp;
+
+               do {
+                       crypto_attribute = ast_sdp_srtp_get_attrib(tmp,
+                               0 /* DTLS running? No */,
+                               session->endpoint->media.rtp.srtp_tag_32 /* 32 byte tag length? */);
+                       if (!crypto_attribute) {
+                               /* No crypto attribute to add, bad news */
+                               return -1;
+                       }
+
+                       attr = pjmedia_sdp_attr_create(pool, "crypto",
+                               pj_cstr(&stmp, crypto_attribute));
+                       media->attr[media->attr_count++] = attr;
+               } while ((tmp = AST_LIST_NEXT(tmp, sdp_srtp_list)));
 
-               attr = pjmedia_sdp_attr_create(pool, "crypto", pj_cstr(&stmp, crypto_attribute));
-               media->attr[media->attr_count++] = attr;
                break;
        case AST_SIP_MEDIA_ENCRYPT_DTLS:
                if (setup_dtls_srtp(session, session_media)) {
@@ -817,13 +1120,19 @@ static int add_crypto_to_stream(struct ast_sip_session *session,
                        break;
                }
 
-               if ((crypto_attribute = dtls->get_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA1))) {
+               hash = dtls->get_fingerprint_hash(session_media->rtp);
+               crypto_attribute = dtls->get_fingerprint(session_media->rtp);
+               if (crypto_attribute && (hash == AST_RTP_DTLS_HASH_SHA1 || hash == AST_RTP_DTLS_HASH_SHA256)) {
                        RAII_VAR(struct ast_str *, fingerprint, ast_str_create(64), ast_free);
                        if (!fingerprint) {
                                return -1;
                        }
 
-                       ast_str_set(&fingerprint, 0, "SHA-1 %s", crypto_attribute);
+                       if (hash == AST_RTP_DTLS_HASH_SHA1) {
+                               ast_str_set(&fingerprint, 0, "SHA-1 %s", crypto_attribute);
+                       } else {
+                               ast_str_set(&fingerprint, 0, "SHA-256 %s", crypto_attribute);
+                       }
 
                        attr = pjmedia_sdp_attr_create(pool, "fingerprint", pj_cstr(&stmp, ast_str_buffer(fingerprint)));
                        media->attr[media->attr_count++] = attr;
@@ -843,33 +1152,35 @@ static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct as
        static const pj_str_t STR_IP4 = { "IP4", 3};
        static const pj_str_t STR_IP6 = { "IP6", 3};
        static const pj_str_t STR_SENDRECV = { "sendrecv", 8 };
+       static const pj_str_t STR_SENDONLY = { "sendonly", 8 };
        pjmedia_sdp_media *media;
-       char hostip[PJ_INET6_ADDRSTRLEN+2];
+       const char *hostip = NULL;
        struct ast_sockaddr addr;
        char tmp[512];
        pj_str_t stmp;
        pjmedia_sdp_attr *attr;
-       int index = 0, min_packet_size = 0, noncodec = (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733) ? AST_RTP_DTMF : 0;
+       int index = 0;
+       int noncodec = (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733 || session->endpoint->dtmf == AST_SIP_DTMF_AUTO) ? AST_RTP_DTMF : 0;
+       int min_packet_size = 0, max_packet_size = 0;
        int rtp_code;
-       struct ast_format format;
-       RAII_VAR(struct ast_format_cap *, caps, NULL, ast_format_cap_destroy);
-       enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
+       RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
+       enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
+       int use_override_prefs = ast_format_cap_count(session->req_caps);
 
        int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
-               !ast_format_cap_is_empty(session->direct_media_cap);
+               ast_format_cap_count(session->direct_media_cap);
 
-       int use_override_prefs = session->override_prefs.formats[0].id;
-       struct ast_codec_pref *prefs = use_override_prefs ?
-               &session->override_prefs : &session->endpoint->media.prefs;
-
-       if ((use_override_prefs && !codec_pref_has_type(&session->override_prefs, media_type)) ||
+       if ((use_override_prefs && !ast_format_cap_has_type(session->req_caps, media_type)) ||
            (!use_override_prefs && !ast_format_cap_has_type(session->endpoint->media.codecs, media_type))) {
                /* If no type formats are configured don't add a stream */
                return 0;
-       } else if (!session_media->rtp && create_rtp(session, session_media, session->endpoint->media.rtp.ipv6)) {
+       } else if (!session_media->rtp && create_rtp(session, session_media)) {
                return -1;
        }
 
+       set_ice_components(session, session_media);
+       enable_rtcp(session, session_media, NULL);
+
        if (!(media = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_media))) ||
                !(media->conn = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_conn)))) {
                return -1;
@@ -880,27 +1191,46 @@ static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct as
        }
 
        media->desc.media = pj_str(session_media->stream_type);
-       media->desc.transport = pj_str(ast_sdp_get_rtp_profile(
-               session->endpoint->media.rtp.encryption == AST_SIP_MEDIA_ENCRYPT_SDES,
-               session_media->rtp, session->endpoint->media.rtp.use_avpf));
+       if (pj_strlen(&session_media->transport)) {
+               /* If a transport has already been specified use it */
+               media->desc.transport = session_media->transport;
+       } else {
+               media->desc.transport = pj_str(ast_sdp_get_rtp_profile(
+                       /* Optimistic encryption places crypto in the normal RTP/AVP profile */
+                       !session->endpoint->media.rtp.encryption_optimistic &&
+                               (session_media->encryption == AST_SIP_MEDIA_ENCRYPT_SDES),
+                       session_media->rtp, session->endpoint->media.rtp.use_avpf,
+                       session->endpoint->media.rtp.force_avp));
+       }
 
        /* Add connection level details */
        if (direct_media_enabled) {
-               ast_copy_string(hostip, ast_sockaddr_stringify_fmt(&session_media->direct_media_addr, AST_SOCKADDR_STR_ADDR), sizeof(hostip));
-       } else if (ast_strlen_zero(session->endpoint->media.external_address)) {
-               pj_sockaddr localaddr;
-
-               if (pj_gethostip(session->endpoint->media.rtp.ipv6 ? pj_AF_INET6() : pj_AF_INET(), &localaddr)) {
-                       return -1;
-               }
-               pj_sockaddr_print(&localaddr, hostip, sizeof(hostip), 2);
+               hostip = ast_sockaddr_stringify_fmt(&session_media->direct_media_addr, AST_SOCKADDR_STR_ADDR);
+       } else if (ast_strlen_zero(session->endpoint->media.address)) {
+               hostip = ast_sip_get_host_ip_string(session->endpoint->media.rtp.ipv6 ? pj_AF_INET6() : pj_AF_INET());
        } else {
-               ast_copy_string(hostip, session->endpoint->media.external_address, sizeof(hostip));
+               hostip = session->endpoint->media.address;
+       }
+
+       if (ast_strlen_zero(hostip)) {
+               ast_log(LOG_ERROR, "No local host IP available for stream %s\n", session_media->stream_type);
+               return -1;
        }
 
        media->conn->net_type = STR_IN;
-       media->conn->addr_type = session->endpoint->media.rtp.ipv6 ? STR_IP6 : STR_IP4;
+       /* Assume that the connection will use IPv4 until proven otherwise */
+       media->conn->addr_type = STR_IP4;
        pj_strdup2(pool, &media->conn->addr, hostip);
+
+       if (!ast_strlen_zero(session->endpoint->media.address)) {
+               pj_sockaddr ip;
+
+               if ((pj_sockaddr_parse(pj_AF_UNSPEC(), 0, &media->conn->addr, &ip) == PJ_SUCCESS) &&
+                       (ip.addr.sa_family == pj_AF_INET6())) {
+                       media->conn->addr_type = STR_IP6;
+               }
+       }
+
        ast_rtp_instance_get_local_address(session_media->rtp, &addr);
        media->desc.port = direct_media_enabled ? ast_sockaddr_port(&session_media->direct_media_addr) : (pj_uint16_t) ast_sockaddr_port(&addr);
        media->desc.port_count = 1;
@@ -908,86 +1238,114 @@ static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct as
        /* Add ICE attributes and candidates */
        add_ice_to_stream(session, session_media, pool, media);
 
-       if (!(caps = ast_format_cap_alloc_nolock())) {
+       if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
                ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
                return -1;
        }
 
        if (direct_media_enabled) {
-               ast_format_cap_joint_copy(session->endpoint->media.codecs, session->direct_media_cap, caps);
-       } else if (ast_format_cap_is_empty(session->req_caps) || !ast_format_cap_has_joint(session->req_caps, session->endpoint->media.codecs)) {
-               ast_format_cap_copy(caps, session->endpoint->media.codecs);
+               ast_format_cap_get_compatible(session->endpoint->media.codecs, session->direct_media_cap, caps);
+       } else if (!ast_format_cap_count(session->req_caps) ||
+               !ast_format_cap_iscompatible(session->req_caps, session->endpoint->media.codecs)) {
+               ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, media_type);
        } else {
-               ast_format_cap_copy(caps, session->req_caps);
+               ast_format_cap_append_from_cap(caps, session->req_caps, media_type);
        }
 
-       for (index = 0; ast_codec_pref_index(prefs, index, &format); ++index) {
-               struct ast_codec_pref *pref = &ast_rtp_instance_get_codecs(session_media->rtp)->pref;
+       for (index = 0; index < ast_format_cap_count(caps); ++index) {
+               struct ast_format *format = ast_format_cap_get_format(caps, index);
 
-               if (AST_FORMAT_GET_TYPE(format.id) != media_type) {
+               if (ast_format_get_type(format) != media_type) {
+                       ao2_ref(format, -1);
                        continue;
                }
 
-               if (!use_override_prefs && !ast_format_cap_get_compatible_format(caps, &format, &format)) {
+               if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(session_media->rtp), 1, format, 0)) == -1) {
+                       ast_log(LOG_WARNING,"Unable to get rtp codec payload code for %s\n", ast_format_get_name(format));
+                       ao2_ref(format, -1);
                        continue;
                }
 
-               if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(session_media->rtp), 1, &format, 0)) == -1) {
-                       return -1;
+               if ((attr = generate_rtpmap_attr(session, media, pool, rtp_code, 1, format, 0))) {
+                       media->attr[media->attr_count++] = attr;
                }
 
-               if (!(attr = generate_rtpmap_attr(media, pool, rtp_code, 1, &format, 0))) {
-                       continue;
+               if ((attr = generate_fmtp_attr(pool, format, rtp_code))) {
+                       media->attr[media->attr_count++] = attr;
                }
 
-               media->attr[media->attr_count++] = attr;
-
-               if ((attr = generate_fmtp_attr(pool, &format, rtp_code))) {
-                       media->attr[media->attr_count++] = attr;
+               if (ast_format_get_maximum_ms(format) &&
+                       ((ast_format_get_maximum_ms(format) < max_packet_size) || !max_packet_size)) {
+                       max_packet_size = ast_format_get_maximum_ms(format);
                }
+               ao2_ref(format, -1);
 
-               if (pref && media_type != AST_FORMAT_TYPE_VIDEO) {
-                       struct ast_format_list fmt = ast_codec_pref_getsize(pref, &format);
-                       if (fmt.cur_ms && ((fmt.cur_ms < min_packet_size) || !min_packet_size)) {
-                               min_packet_size = fmt.cur_ms;
-                       }
+               if (media->desc.fmt_count == PJMEDIA_MAX_SDP_FMT) {
+                       break;
                }
        }
 
        /* Add non-codec formats */
-       if (media_type != AST_FORMAT_TYPE_VIDEO) {
+       if (media_type != AST_MEDIA_TYPE_VIDEO && media->desc.fmt_count < PJMEDIA_MAX_SDP_FMT) {
                for (index = 1LL; index <= AST_RTP_MAX; index <<= 1) {
-                       if (!(noncodec & index) || (rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(session_media->rtp),
-                                                                                          0, NULL, index)) == -1) {
+                       if (!(noncodec & index)) {
                                continue;
                        }
-
-                       if (!(attr = generate_rtpmap_attr(media, pool, rtp_code, 0, NULL, index))) {
+                       rtp_code = ast_rtp_codecs_payload_code(
+                               ast_rtp_instance_get_codecs(session_media->rtp), 0, NULL, index);
+                       if (rtp_code == -1) {
                                continue;
                        }
 
-                       media->attr[media->attr_count++] = attr;
+                       if ((attr = generate_rtpmap_attr(session, media, pool, rtp_code, 0, NULL, index))) {
+                               media->attr[media->attr_count++] = attr;
+                       }
 
                        if (index == AST_RTP_DTMF) {
                                snprintf(tmp, sizeof(tmp), "%d 0-16", rtp_code);
                                attr = pjmedia_sdp_attr_create(pool, "fmtp", pj_cstr(&stmp, tmp));
                                media->attr[media->attr_count++] = attr;
                        }
+
+                       if (media->desc.fmt_count == PJMEDIA_MAX_SDP_FMT) {
+                               break;
+                       }
                }
        }
 
+       /* If no formats were actually added to the media stream don't add it to the SDP */
+       if (!media->desc.fmt_count) {
+               return 1;
+       }
+
        /* If ptime is set add it as an attribute */
+       min_packet_size = ast_rtp_codecs_get_framing(ast_rtp_instance_get_codecs(session_media->rtp));
+       if (!min_packet_size) {
+               min_packet_size = ast_format_cap_get_framing(caps);
+       }
        if (min_packet_size) {
                snprintf(tmp, sizeof(tmp), "%d", min_packet_size);
                attr = pjmedia_sdp_attr_create(pool, "ptime", pj_cstr(&stmp, tmp));
                media->attr[media->attr_count++] = attr;
        }
 
+       if (max_packet_size) {
+               snprintf(tmp, sizeof(tmp), "%d", max_packet_size);
+               attr = pjmedia_sdp_attr_create(pool, "maxptime", pj_cstr(&stmp, tmp));
+               media->attr[media->attr_count++] = attr;
+       }
+
        /* Add the sendrecv attribute - we purposely don't keep track because pjmedia-sdp will automatically change our offer for us */
        attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
-       attr->name = STR_SENDRECV;
+       attr->name = !session_media->locally_held ? STR_SENDRECV : STR_SENDONLY;
        media->attr[media->attr_count++] = attr;
 
+       /* If we've got rtcp-mux enabled, just unconditionally offer it in all SDPs */
+       if (session->endpoint->media.rtcp_mux) {
+               attr = pjmedia_sdp_attr_create(pool, "rtcp-mux", NULL);
+               pjmedia_sdp_attr_add(&media->attr_count, media->attr, attr);
+       }
+
        /* Add the media stream to the SDP */
        sdp->media[sdp->media_count++] = media;
 
@@ -998,29 +1356,47 @@ static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct a
                                       const struct pjmedia_sdp_session *local, const struct pjmedia_sdp_media *local_stream,
                                       const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
 {
-       RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
-       enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
+       RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free);
+       enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
        char host[NI_MAXHOST];
-       int fdno;
+       int fdno, res;
 
        if (!session->channel) {
                return 1;
        }
 
+       if (!local_stream->desc.port || !remote_stream->desc.port) {
+               return 1;
+       }
+
        /* Ensure incoming transport is compatible with the endpoint's configuration */
-       if (check_endpoint_media_transport(session->endpoint, remote_stream) == AST_SIP_MEDIA_TRANSPORT_INVALID) {
+       if (!session->endpoint->media.rtp.use_received_transport &&
+               check_endpoint_media_transport(session->endpoint, remote_stream) == AST_SIP_MEDIA_TRANSPORT_INVALID) {
                return -1;
        }
 
        /* Create an RTP instance if need be */
-       if (!session_media->rtp && create_rtp(session, session_media, session->endpoint->media.rtp.ipv6)) {
+       if (!session_media->rtp && create_rtp(session, session_media)) {
                return -1;
        }
 
-       if (setup_media_encryption(session, session_media, remote_stream)) {
+       session_media->remote_rtcp_mux = (pjmedia_sdp_media_find_attr2(remote_stream, "rtcp-mux", NULL) != NULL);
+       set_ice_components(session, session_media);
+
+       enable_rtcp(session, session_media, remote_stream);
+
+       res = setup_media_encryption(session, session_media, remote, remote_stream);
+       if (!session->endpoint->media.rtp.encryption_optimistic && res) {
+               /* If optimistic encryption is disabled and crypto should have been enabled but was not
+                * this session must fail.
+                */
                return -1;
        }
 
+       if (!remote_stream->conn && !remote->conn) {
+               return 1;
+       }
+
        ast_copy_pj_str(host, remote_stream->conn ? &remote_stream->conn->addr : &remote->conn->addr, sizeof(host));
 
        /* Ensure that the address provided is valid */
@@ -1032,48 +1408,89 @@ static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct a
        /* Apply connection information to the RTP instance */
        ast_sockaddr_set_port(addrs, remote_stream->desc.port);
        ast_rtp_instance_set_remote_address(session_media->rtp, addrs);
-
-       if (set_caps(session, session_media, local_stream) < 1) {
-               return -1;
-       }
-
-       if (media_type == AST_FORMAT_TYPE_AUDIO) {
-               apply_packetization(session, session_media, remote_stream);
+       if (set_caps(session, session_media, remote_stream, 0)) {
+               return 1;
        }
 
        if ((fdno = media_type_to_fdno(media_type)) < 0) {
                return -1;
        }
        ast_channel_set_fd(session->channel, fdno, ast_rtp_instance_fd(session_media->rtp, 0));
-       ast_channel_set_fd(session->channel, fdno + 1, ast_rtp_instance_fd(session_media->rtp, 1));
+       if (!session->endpoint->media.rtcp_mux || !session_media->remote_rtcp_mux) {
+               ast_channel_set_fd(session->channel, fdno + 1, ast_rtp_instance_fd(session_media->rtp, 1));
+       }
 
        /* If ICE support is enabled find all the needed attributes */
        process_ice_attributes(session, session_media, remote, remote_stream);
 
+       /* Ensure the RTP instance is active */
+       ast_rtp_instance_activate(session_media->rtp);
+
        /* audio stream handles music on hold */
-       if (media_type != AST_FORMAT_TYPE_AUDIO) {
+       if (media_type != AST_MEDIA_TYPE_AUDIO) {
+               if ((pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_FALSE)
+                       && (session->inv_session->state == PJSIP_INV_STATE_CONFIRMED)) {
+                       ast_queue_control(session->channel, AST_CONTROL_UPDATE_RTP_PEER);
+               }
                return 1;
        }
 
-       /* Music on hold for audio streams only */
-       if (session_media->held &&
-           (!ast_sockaddr_isnull(addrs) ||
-            !pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL))) {
+       if (ast_sockaddr_isnull(addrs) ||
+               ast_sockaddr_is_any(addrs) ||
+               pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL) ||
+               pjmedia_sdp_media_find_attr2(remote_stream, "inactive", NULL)) {
+               if (!session_media->remotely_held) {
+                       /* The remote side has put us on hold */
+                       ast_queue_hold(session->channel, session->endpoint->mohsuggest);
+                       ast_rtp_instance_stop(session_media->rtp);
+                       ast_queue_frame(session->channel, &ast_null_frame);
+                       session_media->remotely_held = 1;
+               }
+       } else if (session_media->remotely_held) {
                /* The remote side has taken us off hold */
                ast_queue_unhold(session->channel);
                ast_queue_frame(session->channel, &ast_null_frame);
-               session_media->held = 0;
-       } else if (ast_sockaddr_isnull(addrs) ||
-                  ast_sockaddr_is_any(addrs) ||
-                  pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL)) {
-               /* The remote side has put us on hold */
-               ast_queue_hold(session->channel, session->endpoint->mohsuggest);
-               ast_rtp_instance_stop(session_media->rtp);
-               ast_queue_frame(session->channel, &ast_null_frame);
-               session_media->held = 1;
-       } else {
-               /* The remote side has not changed state, but make sure the instance is active */
-               ast_rtp_instance_activate(session_media->rtp);
+               session_media->remotely_held = 0;
+       } else if ((pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_FALSE)
+               && (session->inv_session->state == PJSIP_INV_STATE_CONFIRMED)) {
+               ast_queue_control(session->channel, AST_CONTROL_UPDATE_RTP_PEER);
+       }
+
+       /* This purposely resets the encryption to the configured in case it gets added later */
+       session_media->encryption = session->endpoint->media.rtp.encryption;
+
+       if (session->endpoint->media.rtp.keepalive > 0 &&
+                       stream_to_media_type(session_media->stream_type) == AST_MEDIA_TYPE_AUDIO) {
+               ast_rtp_instance_set_keepalive(session_media->rtp, session->endpoint->media.rtp.keepalive);
+               /* Schedule the initial keepalive early in case this is being used to punch holes through
+                * a NAT. This way there won't be an awkward delay before media starts flowing in some
+                * scenarios.
+                */
+               AST_SCHED_DEL(sched, session_media->keepalive_sched_id);
+               session_media->keepalive_sched_id = ast_sched_add_variable(sched, 500, send_keepalive,
+                       session_media, 1);
+       }
+
+       /* As the channel lock is not held during this process the scheduled item won't block if
+        * it is hanging up the channel at the same point we are applying this negotiated SDP.
+        */
+       AST_SCHED_DEL(sched, session_media->timeout_sched_id);
+
+       /* Due to the fact that we only ever have one scheduled timeout item for when we are both
+        * off hold and on hold we don't need to store the two timeouts differently on the RTP
+        * instance itself.
+        */
+       ast_rtp_instance_set_timeout(session_media->rtp, 0);
+       if (session->endpoint->media.rtp.timeout && !session_media->remotely_held) {
+               ast_rtp_instance_set_timeout(session_media->rtp, session->endpoint->media.rtp.timeout);
+       } else if (session->endpoint->media.rtp.timeout_hold && session_media->remotely_held) {
+               ast_rtp_instance_set_timeout(session_media->rtp, session->endpoint->media.rtp.timeout_hold);
+       }
+
+       if (ast_rtp_instance_get_timeout(session_media->rtp)) {
+               session_media->timeout_sched_id = ast_sched_add_variable(sched,
+                       ast_rtp_instance_get_timeout(session_media->rtp) * 1000, rtp_check_timeout,
+                       session_media, 1);
        }
 
        return 1;
@@ -1082,27 +1499,47 @@ static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct a
 /*! \brief Function which updates the media stream with external media address, if applicable */
 static void change_outgoing_sdp_stream_media_address(pjsip_tx_data *tdata, struct pjmedia_sdp_media *stream, struct ast_sip_transport *transport)
 {
+       RAII_VAR(struct ast_sip_transport_state *, transport_state, ast_sip_get_transport_state(ast_sorcery_object_get_id(transport)), ao2_cleanup);
        char host[NI_MAXHOST];
        struct ast_sockaddr addr = { { 0, } };
 
+       /* If the stream has been rejected there will be no connection line */
+       if (!stream->conn || !transport_state) {
+               return;
+       }
+
        ast_copy_pj_str(host, &stream->conn->addr, sizeof(host));
        ast_sockaddr_parse(&addr, host, PARSE_PORT_FORBID);
 
        /* Is the address within the SDP inside the same network? */
-       if (ast_apply_ha(transport->localnet, &addr) == AST_SENSE_ALLOW) {
+       if (transport_state->localnet
+               && ast_apply_ha(transport_state->localnet, &addr) == AST_SENSE_ALLOW) {
                return;
        }
-
+       ast_debug(5, "Setting media address to %s\n", transport->external_media_address);
        pj_strdup2(tdata->pool, &stream->conn->addr, transport->external_media_address);
 }
 
+/*! \brief Function which stops the RTP instance */
+static void stream_stop(struct ast_sip_session_media *session_media)
+{
+       if (!session_media->rtp) {
+               return;
+       }
+
+       AST_SCHED_DEL(sched, session_media->keepalive_sched_id);
+       AST_SCHED_DEL(sched, session_media->timeout_sched_id);
+       ast_rtp_instance_stop(session_media->rtp);
+}
+
 /*! \brief Function which destroys the RTP instance when session ends */
 static void stream_destroy(struct ast_sip_session_media *session_media)
 {
        if (session_media->rtp) {
-               ast_rtp_instance_stop(session_media->rtp);
+               stream_stop(session_media);
                ast_rtp_instance_destroy(session_media->rtp);
        }
+       session_media->rtp = NULL;
 }
 
 /*! \brief SDP handler for 'audio' media stream */
@@ -1112,6 +1549,7 @@ static struct ast_sip_session_sdp_handler audio_sdp_handler = {
        .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
        .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
        .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
+       .stream_stop = stream_stop,
        .stream_destroy = stream_destroy,
 };
 
@@ -1122,20 +1560,24 @@ static struct ast_sip_session_sdp_handler video_sdp_handler = {
        .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
        .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
        .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
+       .stream_stop = stream_stop,
        .stream_destroy = stream_destroy,
 };
 
 static int video_info_incoming_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
 {
-       struct pjsip_transaction *tsx = pjsip_rdata_get_tsx(rdata);
+       struct pjsip_transaction *tsx;
        pjsip_tx_data *tdata;
 
-       if (!ast_sip_is_content_type(&rdata->msg_info.msg->body->content_type,
-                                    "application",
-                                    "media_control+xml")) {
+       if (!session->channel
+               || !ast_sip_is_content_type(&rdata->msg_info.msg->body->content_type,
+                       "application",
+                       "media_control+xml")) {
                return 0;
        }
 
+       tsx = pjsip_rdata_get_tsx(rdata);
+
        ast_queue_control(session->channel, AST_CONTROL_VIDUPDATE);
 
        if (pjsip_dlg_create_response(session->inv_session->dlg, rdata, 200, NULL, &tdata) == PJ_SUCCESS) {
@@ -1176,8 +1618,13 @@ static int unload_module(void)
  */
 static int load_module(void)
 {
-       ast_sockaddr_parse(&address_ipv4, "0.0.0.0", 0);
-       ast_sockaddr_parse(&address_ipv6, "::", 0);
+       CHECK_PJSIP_SESSION_MODULE_LOADED();
+
+       if (ast_check_ipv6()) {
+               ast_sockaddr_parse(&address_rtp, "::", 0);
+       } else {
+               ast_sockaddr_parse(&address_rtp, "0.0.0.0", 0);
+       }
 
        if (!(sched = ast_sched_context_create())) {
                ast_log(LOG_ERROR, "Unable to create scheduler context.\n");
@@ -1205,11 +1652,12 @@ static int load_module(void)
 end:
        unload_module();
 
-       return AST_MODULE_LOAD_FAILURE;
+       return AST_MODULE_LOAD_DECLINE;
 }
 
 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP SDP RTP/AVP stream handler",
-               .load = load_module,
-               .unload = unload_module,
-               .load_pri = AST_MODPRI_CHANNEL_DRIVER,
-       );
+       .support_level = AST_MODULE_SUPPORT_CORE,
+       .load = load_module,
+       .unload = unload_module,
+       .load_pri = AST_MODPRI_CHANNEL_DRIVER,
+);