Do not access s->gb directly in functions that have a local copy of that
[libav.git] / libavformat / rtsp.c
index 4c99a17..33f0e55 100644 (file)
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
+
+/* needed by inet_aton() */
+#define _SVID_SOURCE
+
+#include "libavutil/avstring.h"
 #include "avformat.h"
 
-#include <unistd.h> /* for select() prototype */
 #include <sys/time.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#ifndef __BEOS__
-# include <arpa/inet.h>
-#else
-# include "barpainet.h"
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
 #endif
+#include <strings.h>
+#include "network.h"
+#include "rtsp.h"
 
 #include "rtp_internal.h"
+#include "rdt.h"
 
 //#define DEBUG
 //#define DEBUG_RTP_TCP
@@ -41,6 +45,18 @@ enum RTSPClientState {
     RTSP_STATE_PAUSED,
 };
 
+enum RTSPServerType {
+    RTSP_SERVER_RTP,  /*< Standard-compliant RTP-server */
+    RTSP_SERVER_REAL, /*< Realmedia-style server */
+    RTSP_SERVER_LAST
+};
+
+enum RTSPTransport {
+    RTSP_TRANSPORT_RTP,
+    RTSP_TRANSPORT_RDT,
+    RTSP_TRANSPORT_LAST
+};
+
 typedef struct RTSPState {
     URLContext *rtsp_hd; /* RTSP TCP connexion handle */
     int nb_rtsp_streams;
@@ -53,14 +69,17 @@ typedef struct RTSPState {
     //    ByteIOContext rtsp_gb;
     int seq;        /* RTSP command sequence number */
     char session_id[512];
-    enum RTSPProtocol protocol;
+    enum RTSPTransport transport;
+    enum RTSPLowerTransport lower_transport;
+    enum RTSPServerType server_type;
     char last_reply[2048]; /* XXX: allocate ? */
-    RTPDemuxContext *cur_rtp;
+    void *cur_tx;
+    int need_subscription;
 } RTSPState;
 
 typedef struct RTSPStream {
     URLContext *rtp_handle; /* RTP stream handle */
-    RTPDemuxContext *rtp_ctx; /* RTP parse context */
+    void *tx_ctx; /* RTP/RDT parse context */
 
     int stream_index; /* corresponding stream index, if any. -1 if none (MPEG2TS case) */
     int interleaved_min, interleaved_max;  /* interleave ids, if TCP transport */
@@ -73,7 +92,7 @@ typedef struct RTSPStream {
     rtp_payload_data_t rtp_payload_data; /* rtp payload parsing infos from SDP */
 
     RTPDynamicProtocolHandler *dynamic_handler; ///< Only valid if it's a dynamic protocol. (This is the handler structure)
-    void *dynamic_protocol_context; ///< Only valid if it's a dynamic protocol. (This is any private data associated with the dynamic protocol)
+    PayloadContext *dynamic_protocol_context; ///< Only valid if it's a dynamic protocol. (This is any private data associated with the dynamic protocol)
 } RTSPStream;
 
 static int rtsp_read_play(AVFormatContext *s);
@@ -81,20 +100,20 @@ static int rtsp_read_play(AVFormatContext *s);
 /* XXX: currently, the only way to change the protocols consists in
    changing this variable */
 
-int rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_UDP);
-
-FFRTSPCallback *ff_rtsp_callback = NULL;
+#if LIBAVFORMAT_VERSION_INT < (53 << 16)
+int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP);
+#endif
 
 static int rtsp_probe(AVProbeData *p)
 {
-    if (strstart(p->filename, "rtsp:", NULL))
+    if (av_strstart(p->filename, "rtsp:", NULL))
         return AVPROBE_SCORE_MAX;
     return 0;
 }
 
 static int redir_isspace(int c)
 {
-    return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
+    return c == ' ' || c == '\t' || c == '\n' || c == '\r';
 }
 
 static void skip_spaces(const char **pp)
@@ -173,11 +192,7 @@ static int sdp_parse_rtpmap(AVCodecContext *codec, RTSPStream *rtsp_st, int payl
     } else {
         /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
         /* search into AVRtpPayloadTypes[] */
-        for (i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
-            if (!strcmp(buf, AVRtpPayloadTypes[i].enc_name) && (codec->codec_type == AVRtpPayloadTypes[i].codec_type)){
-                codec->codec_id = AVRtpPayloadTypes[i].codec_id;
-                break;
-            }
+        codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
     }
 
     c = avcodec_find_decoder(codec->codec_id);
@@ -278,7 +293,7 @@ typedef struct attrname_map
 /* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
 #define ATTR_NAME_TYPE_INT 0
 #define ATTR_NAME_TYPE_STR 1
-static attrname_map_t attr_names[]=
+static const attrname_map_t attr_names[]=
 {
     {"SizeLength",       ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, sizelength)},
     {"IndexLength",      ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, indexlength)},
@@ -319,18 +334,9 @@ static void sdp_parse_fmtp(AVStream *st, const char *p)
     AVCodecContext *codec = st->codec;
     rtp_payload_data_t *rtp_payload_data = &rtsp_st->rtp_payload_data;
 
-    // TODO (Replace with rtsp_next_attr_and_value)
     /* loop on each attribute */
-    for(;;) {
-        skip_spaces(&p);
-        if (*p == '\0')
-            break;
-        get_word_sep(attr, sizeof(attr), "=", &p);
-        if (*p == '=')
-            p++;
-        get_word_sep(value, sizeof(value), ";", &p);
-        if (*p == ';')
-            p++;
+    while(rtsp_next_attr_and_value(&p, attr, sizeof(attr), value, sizeof(value)))
+    {
         /* grab the codec extra_data from the config parameter of the fmtp line */
         sdp_parse_fmtp_config(codec, attr, value);
         /* Looking for a known attribute */
@@ -354,7 +360,7 @@ static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
     char buf[256];
 
     skip_spaces(&p);
-    if (!stristart(p, "npt=", &p))
+    if (!av_stristart(p, "npt=", &p))
         return;
 
     *start = AV_NOPTS_VALUE;
@@ -383,7 +389,8 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
     RTSPState *rt = s->priv_data;
     char buf1[64], st_type[64];
     const char *p;
-    int codec_type, payload_type, i;
+    enum CodecType codec_type;
+    int payload_type, i;
     AVStream *st;
     RTSPStream *rtsp_st;
     struct in_addr sdp_ip;
@@ -422,11 +429,11 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
         }
         break;
     case 's':
-        pstrcpy(s->title, sizeof(s->title), p);
+        av_strlcpy(s->title, p, sizeof(s->title));
         break;
     case 'i':
         if (s->nb_streams == 0) {
-            pstrcpy(s->comment, sizeof(s->comment), p);
+            av_strlcpy(s->comment, p, sizeof(s->comment));
             break;
         }
         break;
@@ -458,7 +465,7 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
         get_word(buf1, sizeof(buf1), &p); /* format list */
         rtsp_st->sdp_payload_type = atoi(buf1);
 
-        if (!strcmp(AVRtpPayloadTypes[rtsp_st->sdp_payload_type].enc_name, "MP2T")) {
+        if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
             /* no corresponding stream */
         } else {
             st = av_new_stream(s, 0);
@@ -473,10 +480,10 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
             }
         }
         /* put a default control url */
-        pstrcpy(rtsp_st->control_url, sizeof(rtsp_st->control_url), s->filename);
+        av_strlcpy(rtsp_st->control_url, s->filename, sizeof(rtsp_st->control_url));
         break;
     case 'a':
-        if (strstart(p, "control:", &p) && s->nb_streams > 0) {
+        if (av_strstart(p, "control:", &p) && s->nb_streams > 0) {
             char proto[32];
             /* get the control url */
             st = s->streams[s->nb_streams - 1];
@@ -486,12 +493,12 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
             url_split(proto, sizeof(proto), NULL, 0, NULL, 0, NULL, NULL, 0, p);
             if (proto[0] == '\0') {
                 /* relative control URL */
-                pstrcat(rtsp_st->control_url, sizeof(rtsp_st->control_url), "/");
-                pstrcat(rtsp_st->control_url, sizeof(rtsp_st->control_url), p);
+                av_strlcat(rtsp_st->control_url, "/", sizeof(rtsp_st->control_url));
+                av_strlcat(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
             } else {
-                pstrcpy(rtsp_st->control_url, sizeof(rtsp_st->control_url), p);
+                av_strlcpy(rtsp_st->control_url, p,   sizeof(rtsp_st->control_url));
             }
-        } else if (strstart(p, "rtpmap:", &p)) {
+        } else if (av_strstart(p, "rtpmap:", &p)) {
             /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
             get_word(buf1, sizeof(buf1), &p);
             payload_type = atoi(buf1);
@@ -502,7 +509,7 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
                     sdp_parse_rtpmap(st->codec, rtsp_st, payload_type, p);
                 }
             }
-        } else if (strstart(p, "fmtp:", &p)) {
+        } else if (av_strstart(p, "fmtp:", &p)) {
             /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
             get_word(buf1, sizeof(buf1), &p);
             payload_type = atoi(buf1);
@@ -519,7 +526,7 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
                     }
                 }
             }
-        } else if(strstart(p, "framesize:", &p)) {
+        } else if(av_strstart(p, "framesize:", &p)) {
             // let dynamic protocol handlers have a stab at the line.
             get_word(buf1, sizeof(buf1), &p);
             payload_type = atoi(buf1);
@@ -532,13 +539,22 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
                     }
                 }
             }
-        } else if(strstart(p, "range:", &p)) {
+        } else if(av_strstart(p, "range:", &p)) {
             int64_t start, end;
 
             // this is so that seeking on a streamed file can work.
             rtsp_parse_range_npt(p, &start, &end);
             s->start_time= start;
             s->duration= (end==AV_NOPTS_VALUE)?AV_NOPTS_VALUE:end-start; // AV_NOPTS_VALUE means live broadcast (and can't seek)
+        } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
+            if (atoi(p) == 1)
+                rt->transport = RTSP_TRANSPORT_RDT;
+        } else if (s->nb_streams > 0) {
+            rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
+            if (rtsp_st->dynamic_handler &&
+                rtsp_st->dynamic_handler->parse_sdp_a_line)
+                rtsp_st->dynamic_handler->parse_sdp_a_line(s->streams[s->nb_streams - 1],
+                    rtsp_st->dynamic_protocol_context, buf);
         }
         break;
     }
@@ -548,7 +564,7 @@ static int sdp_parse(AVFormatContext *s, const char *content)
 {
     const char *p;
     int letter;
-    char buf[1024], *q;
+    char buf[2048], *q;
     SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
 
     memset(s1, 0, sizeof(SDPParseState));
@@ -623,17 +639,27 @@ static void rtsp_parse_transport(RTSPHeader *reply, const char *p)
                      "/", &p);
         if (*p == '/')
             p++;
-        get_word_sep(profile, sizeof(profile), "/;,", &p);
-        lower_transport[0] = '\0';
-        if (*p == '/') {
-            p++;
-            get_word_sep(lower_transport, sizeof(lower_transport),
-                         ";,", &p);
+        if (!strcasecmp (transport_protocol, "rtp")) {
+            get_word_sep(profile, sizeof(profile), "/;,", &p);
+            lower_transport[0] = '\0';
+            /* rtp/avp/<protocol> */
+            if (*p == '/') {
+                p++;
+                get_word_sep(lower_transport, sizeof(lower_transport),
+                             ";,", &p);
+            }
+            th->transport = RTSP_TRANSPORT_RTP;
+        } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
+                   !strcasecmp (transport_protocol, "x-real-rdt")) {
+            /* x-pn-tng/<protocol> */
+            get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
+            profile[0] = '\0';
+            th->transport = RTSP_TRANSPORT_RDT;
         }
         if (!strcasecmp(lower_transport, "TCP"))
-            th->protocol = RTSP_PROTOCOL_RTP_TCP;
+            th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
         else
-            th->protocol = RTSP_PROTOCOL_RTP_UDP;
+            th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
 
         if (*p == ';')
             p++;
@@ -664,8 +690,8 @@ static void rtsp_parse_transport(RTSPHeader *reply, const char *p)
                                      &th->interleaved_max, &p);
                 }
             } else if (!strcmp(parameter, "multicast")) {
-                if (th->protocol == RTSP_PROTOCOL_RTP_UDP)
-                    th->protocol = RTSP_PROTOCOL_RTP_UDP_MULTICAST;
+                if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
+                    th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
             } else if (!strcmp(parameter, "ttl")) {
                 if (*p == '=') {
                     p++;
@@ -699,16 +725,19 @@ void rtsp_parse_line(RTSPHeader *reply, const char *buf)
 
     /* NOTE: we do case independent match for broken servers */
     p = buf;
-    if (stristart(p, "Session:", &p)) {
+    if (av_stristart(p, "Session:", &p)) {
         get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
-    } else if (stristart(p, "Content-Length:", &p)) {
+    } else if (av_stristart(p, "Content-Length:", &p)) {
         reply->content_length = strtol(p, NULL, 10);
-    } else if (stristart(p, "Transport:", &p)) {
+    } else if (av_stristart(p, "Transport:", &p)) {
         rtsp_parse_transport(reply, p);
-    } else if (stristart(p, "CSeq:", &p)) {
+    } else if (av_stristart(p, "CSeq:", &p)) {
         reply->seq = strtol(p, NULL, 10);
-    } else if (stristart(p, "Range:", &p)) {
+    } else if (av_stristart(p, "Range:", &p)) {
         rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
+    } else if (av_stristart(p, "RealChallenge1:", &p)) {
+        skip_spaces(&p);
+        av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
     }
 }
 
@@ -736,7 +765,7 @@ static void rtsp_skip_packet(AVFormatContext *s)
     ret = url_readbuf(rt->rtsp_hd, buf, 3);
     if (ret != 3)
         return;
-    len = (buf[1] << 8) | buf[2];
+    len = AV_RB16(buf + 1);
 #ifdef DEBUG
     printf("skipping RTP packet len=%d\n", len);
 #endif
@@ -766,14 +795,14 @@ static void rtsp_send_cmd(AVFormatContext *s,
     memset(reply, 0, sizeof(RTSPHeader));
 
     rt->seq++;
-    pstrcpy(buf, sizeof(buf), cmd);
+    av_strlcpy(buf, cmd, sizeof(buf));
     snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
-    pstrcat(buf, sizeof(buf), buf1);
+    av_strlcat(buf, buf1, sizeof(buf));
     if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
         snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
-        pstrcat(buf, sizeof(buf), buf1);
+        av_strlcat(buf, buf1, sizeof(buf));
     }
-    pstrcat(buf, sizeof(buf), "\r\n");
+    av_strlcat(buf, "\r\n", sizeof(buf));
 #ifdef DEBUG
     printf("Sending:\n%s--\n", buf);
 #endif
@@ -812,14 +841,14 @@ static void rtsp_send_cmd(AVFormatContext *s,
             reply->status_code = atoi(buf1);
         } else {
             rtsp_parse_line(reply, p);
-            pstrcat(rt->last_reply, sizeof(rt->last_reply), p);
-            pstrcat(rt->last_reply, sizeof(rt->last_reply), "\n");
+            av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
+            av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
         }
         line_count++;
     }
 
     if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
-        pstrcpy(rt->session_id, sizeof(rt->session_id), reply->session_id);
+        av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
 
     content_length = reply->content_length;
     if (content_length > 0) {
@@ -830,13 +859,8 @@ static void rtsp_send_cmd(AVFormatContext *s,
     }
     if (content_ptr)
         *content_ptr = content;
-}
-
-/* useful for modules: set RTSP callback function */
-
-void rtsp_set_callback(FFRTSPCallback *rtsp_cb)
-{
-    ff_rtsp_callback = rtsp_cb;
+    else
+        av_free(content);
 }
 
 
@@ -849,68 +873,73 @@ static void rtsp_close_streams(RTSPState *rt)
     for(i=0;i<rt->nb_rtsp_streams;i++) {
         rtsp_st = rt->rtsp_streams[i];
         if (rtsp_st) {
-            if (rtsp_st->rtp_ctx)
-                rtp_parse_close(rtsp_st->rtp_ctx);
+            if (rtsp_st->tx_ctx) {
+                if (rt->transport == RTSP_TRANSPORT_RDT)
+                    ff_rdt_parse_close(rtsp_st->tx_ctx);
+                else
+                    rtp_parse_close(rtsp_st->tx_ctx);
+            }
             if (rtsp_st->rtp_handle)
                 url_close(rtsp_st->rtp_handle);
             if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
                 rtsp_st->dynamic_handler->close(rtsp_st->dynamic_protocol_context);
         }
-        av_free(rtsp_st);
     }
     av_free(rt->rtsp_streams);
 }
 
-static int rtsp_read_header(AVFormatContext *s,
-                            AVFormatParameters *ap)
+static int
+rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
 {
     RTSPState *rt = s->priv_data;
-    char host[1024], path[1024], tcpname[1024], cmd[2048];
-    URLContext *rtsp_hd;
-    int port, i, j, ret, err;
-    RTSPHeader reply1, *reply = &reply1;
-    unsigned char *content = NULL;
-    RTSPStream *rtsp_st;
-    int protocol_mask;
-    AVStream *st;
-
-    /* extract hostname and port */
-    url_split(NULL, 0, NULL, 0,
-              host, sizeof(host), &port, path, sizeof(path), s->filename);
-    if (port < 0)
-        port = RTSP_DEFAULT_PORT;
-
-    /* open the tcp connexion */
-    snprintf(tcpname, sizeof(tcpname), "tcp://%s:%d", host, port);
-    if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0)
-        return AVERROR_IO;
-    rt->rtsp_hd = rtsp_hd;
-    rt->seq = 0;
-
-    /* describe the stream */
-    snprintf(cmd, sizeof(cmd),
-             "DESCRIBE %s RTSP/1.0\r\n"
-             "Accept: application/sdp\r\n",
-             s->filename);
-    rtsp_send_cmd(s, cmd, reply, &content);
-    if (!content) {
-        err = AVERROR_INVALIDDATA;
-        goto fail;
-    }
-    if (reply->status_code != RTSP_STATUS_OK) {
-        err = AVERROR_INVALIDDATA;
-        goto fail;
+    AVStream *st = NULL;
+
+    /* open the RTP context */
+    if (rtsp_st->stream_index >= 0)
+        st = s->streams[rtsp_st->stream_index];
+    if (!st)
+        s->ctx_flags |= AVFMTCTX_NOHEADER;
+
+    if (rt->transport == RTSP_TRANSPORT_RDT)
+        rtsp_st->tx_ctx = ff_rdt_parse_open(s, st->index,
+                                            rtsp_st->dynamic_protocol_context,
+                                            rtsp_st->dynamic_handler);
+    else
+        rtsp_st->tx_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle,
+                                         rtsp_st->sdp_payload_type,
+                                         &rtsp_st->rtp_payload_data);
+
+    if (!rtsp_st->tx_ctx) {
+         return AVERROR(ENOMEM);
+    } else if (rt->transport != RTSP_TRANSPORT_RDT) {
+        if(rtsp_st->dynamic_handler) {
+            rtp_parse_set_dynamic_protocol(rtsp_st->tx_ctx,
+                                           rtsp_st->dynamic_protocol_context,
+                                           rtsp_st->dynamic_handler);
+        }
     }
 
-    /* now we got the SDP description, we parse it */
-    ret = sdp_parse(s, (const char *)content);
-    av_freep(&content);
-    if (ret < 0) {
-        err = AVERROR_INVALIDDATA;
-        goto fail;
-    }
+    return 0;
+}
+
+/**
+ * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
+ */
+static int
+make_setup_request (AVFormatContext *s, const char *host, int port,
+                    int lower_transport, const char *real_challenge)
+{
+    RTSPState *rt = s->priv_data;
+    int j, i, err;
+    RTSPStream *rtsp_st;
+    RTSPHeader reply1, *reply = &reply1;
+    char cmd[2048];
+    const char *trans_pref;
 
-    protocol_mask = rtsp_default_protocols;
+    if (rt->transport == RTSP_TRANSPORT_RDT)
+        trans_pref = "x-pn-tng";
+    else
+        trans_pref = "RTP/AVP";
 
     /* for each stream, make the setup request */
     /* XXX: we assume the same server is used for the control of each
@@ -921,19 +950,16 @@ static int rtsp_read_header(AVFormatContext *s,
 
         rtsp_st = rt->rtsp_streams[i];
 
-        /* compute available transports */
-        transport[0] = '\0';
-
         /* RTP/UDP */
-        if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP)) {
+        if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
             char buf[256];
 
             /* first try in specified port range */
             if (RTSP_RTP_PORT_MIN != 0) {
                 while(j <= RTSP_RTP_PORT_MAX) {
-                    snprintf(buf, sizeof(buf), "rtp://?localport=%d", j);
+                    snprintf(buf, sizeof(buf), "rtp://%s?localport=%d", host, j);
+                    j += 2; /* we will use two port by rtp stream (rtp and rtcp) */
                     if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0) {
-                        j += 2; /* we will use two port by rtp stream (rtp and rtcp) */
                         goto rtp_opened;
                     }
                 }
@@ -948,63 +974,77 @@ static int rtsp_read_header(AVFormatContext *s,
 
         rtp_opened:
             port = rtp_get_local_port(rtsp_st->rtp_handle);
-            if (transport[0] != '\0')
-                pstrcat(transport, sizeof(transport), ",");
-            snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1,
-                     "RTP/AVP/UDP;unicast;client_port=%d-%d",
-                     port, port + 1);
+            snprintf(transport, sizeof(transport) - 1,
+                     "%s/UDP;", trans_pref);
+            if (rt->server_type != RTSP_SERVER_REAL)
+                av_strlcat(transport, "unicast;", sizeof(transport));
+            av_strlcatf(transport, sizeof(transport),
+                     "client_port=%d", port);
+            if (rt->transport == RTSP_TRANSPORT_RTP)
+                av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
         }
 
         /* RTP/TCP */
-        else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_TCP)) {
-            if (transport[0] != '\0')
-                pstrcat(transport, sizeof(transport), ",");
-            snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1,
-                     "RTP/AVP/TCP");
+        else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
+            snprintf(transport, sizeof(transport) - 1,
+                     "%s/TCP", trans_pref);
         }
 
-        else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP_MULTICAST)) {
-            if (transport[0] != '\0')
-                pstrcat(transport, sizeof(transport), ",");
-            snprintf(transport + strlen(transport),
-                     sizeof(transport) - strlen(transport) - 1,
-                     "RTP/AVP/UDP;multicast");
+        else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
+            snprintf(transport, sizeof(transport) - 1,
+                     "%s/UDP;multicast", trans_pref);
         }
+        if (rt->server_type == RTSP_SERVER_REAL)
+            av_strlcat(transport, ";mode=play", sizeof(transport));
         snprintf(cmd, sizeof(cmd),
                  "SETUP %s RTSP/1.0\r\n"
                  "Transport: %s\r\n",
                  rtsp_st->control_url, transport);
+        if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
+            char real_res[41], real_csum[9];
+            ff_rdt_calc_response_and_checksum(real_res, real_csum,
+                                              real_challenge);
+            av_strlcatf(cmd, sizeof(cmd),
+                        "If-Match: %s\r\n"
+                        "RealChallenge2: %s, sd=%s\r\n",
+                        rt->session_id, real_res, real_csum);
+        }
         rtsp_send_cmd(s, cmd, reply, NULL);
-        if (reply->status_code != RTSP_STATUS_OK ||
-            reply->nb_transports != 1) {
+        if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
+            err = 1;
+            goto fail;
+        } else if (reply->status_code != RTSP_STATUS_OK ||
+                   reply->nb_transports != 1) {
             err = AVERROR_INVALIDDATA;
             goto fail;
         }
 
         /* XXX: same protocol for all streams is required */
         if (i > 0) {
-            if (reply->transports[0].protocol != rt->protocol) {
+            if (reply->transports[0].lower_transport != rt->lower_transport ||
+                reply->transports[0].transport != rt->transport) {
                 err = AVERROR_INVALIDDATA;
                 goto fail;
             }
         } else {
-            rt->protocol = reply->transports[0].protocol;
+            rt->lower_transport = reply->transports[0].lower_transport;
+            rt->transport = reply->transports[0].transport;
         }
 
         /* close RTP connection if not choosen */
-        if (reply->transports[0].protocol != RTSP_PROTOCOL_RTP_UDP &&
-            (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP))) {
+        if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
+            (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
             url_close(rtsp_st->rtp_handle);
             rtsp_st->rtp_handle = NULL;
         }
 
-        switch(reply->transports[0].protocol) {
-        case RTSP_PROTOCOL_RTP_TCP:
+        switch(reply->transports[0].lower_transport) {
+        case RTSP_LOWER_TRANSPORT_TCP:
             rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
             rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
             break;
 
-        case RTSP_PROTOCOL_RTP_UDP:
+        case RTSP_LOWER_TRANSPORT_UDP:
             {
                 char url[1024];
 
@@ -1017,18 +1057,16 @@ static int rtsp_read_header(AVFormatContext *s,
                 }
             }
             break;
-        case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
+        case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
             {
                 char url[1024];
-                int ttl;
-
-                ttl = reply->transports[0].ttl;
-                if (!ttl)
-                    ttl = 16;
-                snprintf(url, sizeof(url), "rtp://%s:%d?multicast=1&ttl=%d",
-                         host,
-                         reply->transports[0].server_port_min,
-                         ttl);
+                struct in_addr in;
+
+                in.s_addr = htonl(reply->transports[0].destination);
+                snprintf(url, sizeof(url), "rtp://%s:%d?ttl=%d",
+                         inet_ntoa(in),
+                         reply->transports[0].port_min,
+                         reply->transports[0].ttl);
                 if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
                     err = AVERROR_INVALIDDATA;
                     goto fail;
@@ -1036,34 +1074,157 @@ static int rtsp_read_header(AVFormatContext *s,
             }
             break;
         }
-        /* open the RTP context */
-        st = NULL;
-        if (rtsp_st->stream_index >= 0)
-            st = s->streams[rtsp_st->stream_index];
-        if (!st)
-            s->ctx_flags |= AVFMTCTX_NOHEADER;
-        rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data);
-
-        if (!rtsp_st->rtp_ctx) {
-            err = AVERROR_NOMEM;
+
+        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
             goto fail;
-        } else {
-            if(rtsp_st->dynamic_handler) {
-                rtsp_st->rtp_ctx->dynamic_protocol_context= rtsp_st->dynamic_protocol_context;
-                rtsp_st->rtp_ctx->parse_packet= rtsp_st->dynamic_handler->parse_packet;
-            }
+    }
+
+    if (rt->server_type == RTSP_SERVER_REAL)
+        rt->need_subscription = 1;
+
+    return 0;
+
+fail:
+    for (i=0; i<rt->nb_rtsp_streams; i++) {
+        if (rt->rtsp_streams[i]->rtp_handle) {
+            url_close(rt->rtsp_streams[i]->rtp_handle);
+            rt->rtsp_streams[i]->rtp_handle = NULL;
         }
     }
+    return err;
+}
 
-    /* use callback if available to extend setup */
-    if (ff_rtsp_callback) {
-        if (ff_rtsp_callback(RTSP_ACTION_CLIENT_SETUP, rt->session_id,
-                             NULL, 0, rt->last_reply) < 0) {
+static int rtsp_read_header(AVFormatContext *s,
+                            AVFormatParameters *ap)
+{
+    RTSPState *rt = s->priv_data;
+    char host[1024], path[1024], tcpname[1024], cmd[2048], *option_list, *option;
+    URLContext *rtsp_hd;
+    int port, ret, err;
+    RTSPHeader reply1, *reply = &reply1;
+    unsigned char *content = NULL;
+    int lower_transport_mask = 0;
+    char real_challenge[64];
+
+    /* extract hostname and port */
+    url_split(NULL, 0, NULL, 0,
+              host, sizeof(host), &port, path, sizeof(path), s->filename);
+    if (port < 0)
+        port = RTSP_DEFAULT_PORT;
+
+    /* search for options */
+    option_list = strchr(path, '?');
+    if (option_list) {
+        /* remove the options from the path */
+        *option_list++ = 0;
+        while(option_list) {
+            /* move the option pointer */
+            option = option_list;
+            option_list = strchr(option_list, '&');
+            if (option_list)
+                *(option_list++) = 0;
+            /* handle the options */
+            if (strcmp(option, "udp") == 0)
+                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP);
+            else if (strcmp(option, "multicast") == 0)
+                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
+            else if (strcmp(option, "tcp") == 0)
+                lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP);
+        }
+    }
+
+    if (!lower_transport_mask)
+        lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_LAST) - 1;
+
+    /* open the tcp connexion */
+    snprintf(tcpname, sizeof(tcpname), "tcp://%s:%d", host, port);
+    if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0)
+        return AVERROR(EIO);
+    rt->rtsp_hd = rtsp_hd;
+    rt->seq = 0;
+
+    /* request options supported by the server; this also detects server type */
+    for (rt->server_type = RTSP_SERVER_RTP;;) {
+        snprintf(cmd, sizeof(cmd),
+                 "OPTIONS %s RTSP/1.0\r\n", s->filename);
+        if (rt->server_type == RTSP_SERVER_REAL)
+            av_strlcat(cmd,
+                       /**
+                        * The following entries are required for proper
+                        * streaming from a Realmedia server. They are
+                        * interdependent in some way although we currently
+                        * don't quite understand how. Values were copied
+                        * from mplayer SVN r23589.
+                        * @param CompanyID is a 16-byte ID in base64
+                        * @param ClientChallenge is a 16-byte ID in hex
+                        */
+                       "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
+                       "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
+                       "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
+                       "GUID: 00000000-0000-0000-0000-000000000000\r\n",
+                       sizeof(cmd));
+        rtsp_send_cmd(s, cmd, reply, NULL);
+        if (reply->status_code != RTSP_STATUS_OK) {
             err = AVERROR_INVALIDDATA;
             goto fail;
         }
+
+        /* detect server type if not standard-compliant RTP */
+        if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
+            rt->server_type = RTSP_SERVER_REAL;
+            continue;
+        } else if (rt->server_type == RTSP_SERVER_REAL) {
+            strcpy(real_challenge, reply->real_challenge);
+        }
+        break;
+    }
+
+    /* describe the stream */
+    snprintf(cmd, sizeof(cmd),
+             "DESCRIBE %s RTSP/1.0\r\n"
+             "Accept: application/sdp\r\n",
+             s->filename);
+    if (rt->server_type == RTSP_SERVER_REAL) {
+        /**
+         * The Require: attribute is needed for proper streaming from
+         * Realmedia servers.
+         */
+        av_strlcat(cmd,
+                   "Require: com.real.retain-entity-for-setup\r\n",
+                   sizeof(cmd));
+    }
+    rtsp_send_cmd(s, cmd, reply, &content);
+    if (!content) {
+        err = AVERROR_INVALIDDATA;
+        goto fail;
+    }
+    if (reply->status_code != RTSP_STATUS_OK) {
+        err = AVERROR_INVALIDDATA;
+        goto fail;
+    }
+
+    /* now we got the SDP description, we parse it */
+    ret = sdp_parse(s, (const char *)content);
+    av_freep(&content);
+    if (ret < 0) {
+        err = AVERROR_INVALIDDATA;
+        goto fail;
     }
 
+    do {
+        int lower_transport = ff_log2_tab[lower_transport_mask & ~(lower_transport_mask - 1)];
+
+        err = make_setup_request(s, host, port, lower_transport,
+                                 rt->server_type == RTSP_SERVER_REAL ?
+                                     real_challenge : NULL);
+        if (err < 0)
+            goto fail;
+        lower_transport_mask &= ~(1 << lower_transport);
+        if (lower_transport_mask == 0 && err == 1) {
+            err = AVERROR(FF_NETERROR(EPROTONOSUPPORT));
+            goto fail;
+        }
+    } while (err);
 
     rt->state = RTSP_STATE_IDLE;
     rt->seek_timestamp = 0; /* default is to start stream at position
@@ -1109,7 +1270,7 @@ static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
     if (ret != 3)
         return -1;
     id = buf[0];
-    len = (buf[1] << 8) | buf[2];
+    len = AV_RB16(buf + 1);
 #ifdef DEBUG_RTP_TCP
     printf("id=%d len=%d\n", id, len);
 #endif
@@ -1119,6 +1280,9 @@ static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
     ret = url_readbuf(rt->rtsp_hd, buf, len);
     if (ret != len)
         return -1;
+    if (rt->transport == RTSP_TRANSPORT_RDT &&
+        ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
+        return -1;
 
     /* find the matching stream */
     for(i = 0; i < rt->nb_rtsp_streams; i++) {
@@ -1144,7 +1308,7 @@ static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
 
     for(;;) {
         if (url_interrupt_cb())
-            return -1;
+            return AVERROR(EINTR);
         FD_ZERO(&rfds);
         fd_max = -1;
         for(i = 0; i < rt->nb_rtsp_streams; i++) {
@@ -1182,41 +1346,74 @@ static int rtsp_read_packet(AVFormatContext *s,
     int ret, len;
     uint8_t buf[RTP_MAX_PACKET_LENGTH];
 
+    if (rt->server_type == RTSP_SERVER_REAL && rt->need_subscription) {
+        int i;
+        RTSPHeader reply1, *reply = &reply1;
+        char cmd[1024];
+
+        snprintf(cmd, sizeof(cmd),
+                 "SET_PARAMETER %s RTSP/1.0\r\n"
+                 "Subscribe: ",
+                 s->filename);
+        for (i = 0; i < rt->nb_rtsp_streams; i++) {
+            if (i != 0) av_strlcat(cmd, ",", sizeof(cmd));
+            ff_rdt_subscribe_rule(cmd, sizeof(cmd), i, 0);
+            if (rt->transport == RTSP_TRANSPORT_RDT)
+                ff_rdt_subscribe_rule2(
+                    rt->rtsp_streams[i]->tx_ctx,
+                    cmd, sizeof(cmd), i, 0);
+        }
+        av_strlcat(cmd, "\r\n", sizeof(cmd));
+        rtsp_send_cmd(s, cmd, reply, NULL);
+        if (reply->status_code != RTSP_STATUS_OK)
+            return AVERROR_INVALIDDATA;
+        rt->need_subscription = 0;
+
+        if (rt->state == RTSP_STATE_PLAYING)
+            rtsp_read_play (s);
+    }
+
     /* get next frames from the same RTP packet */
-    if (rt->cur_rtp) {
-        ret = rtp_parse_packet(rt->cur_rtp, pkt, NULL, 0);
+    if (rt->cur_tx) {
+        if (rt->transport == RTSP_TRANSPORT_RDT)
+            ret = ff_rdt_parse_packet(rt->cur_tx, pkt, NULL, 0);
+        else
+            ret = rtp_parse_packet(rt->cur_tx, pkt, NULL, 0);
         if (ret == 0) {
-            rt->cur_rtp = NULL;
+            rt->cur_tx = NULL;
             return 0;
         } else if (ret == 1) {
             return 0;
         } else {
-            rt->cur_rtp = NULL;
+            rt->cur_tx = NULL;
         }
     }
 
     /* read next RTP packet */
  redo:
-    switch(rt->protocol) {
+    switch(rt->lower_transport) {
     default:
-    case RTSP_PROTOCOL_RTP_TCP:
+    case RTSP_LOWER_TRANSPORT_TCP:
         len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
         break;
-    case RTSP_PROTOCOL_RTP_UDP:
-    case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
+    case RTSP_LOWER_TRANSPORT_UDP:
+    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
         len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
-        if (rtsp_st->rtp_ctx)
-            rtp_check_and_send_back_rr(rtsp_st->rtp_ctx, len);
+        if (len >=0 && rtsp_st->tx_ctx && rt->transport == RTSP_TRANSPORT_RTP)
+            rtp_check_and_send_back_rr(rtsp_st->tx_ctx, len);
         break;
     }
     if (len < 0)
-        return AVERROR_IO;
-    ret = rtp_parse_packet(rtsp_st->rtp_ctx, pkt, buf, len);
+        return len;
+    if (rt->transport == RTSP_TRANSPORT_RDT)
+        ret = ff_rdt_parse_packet(rtsp_st->tx_ctx, pkt, buf, len);
+    else
+        ret = rtp_parse_packet(rtsp_st->tx_ctx, pkt, buf, len);
     if (ret < 0)
         goto redo;
     if (ret == 1) {
         /* more packets may follow, so we save the RTP context */
-        rt->cur_rtp = rtsp_st->rtp_ctx;
+        rt->cur_tx = rtsp_st->tx_ctx;
     }
     return 0;
 }
@@ -1229,24 +1426,25 @@ static int rtsp_read_play(AVFormatContext *s)
 
     av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state);
 
-    if (rt->state == RTSP_STATE_PAUSED) {
-        snprintf(cmd, sizeof(cmd),
-                 "PLAY %s RTSP/1.0\r\n",
-                 s->filename);
-    } else {
-        snprintf(cmd, sizeof(cmd),
-                 "PLAY %s RTSP/1.0\r\n"
-                 "Range: npt=%0.3f-\r\n",
-                 s->filename,
-                 (double)rt->seek_timestamp / AV_TIME_BASE);
-    }
-    rtsp_send_cmd(s, cmd, reply, NULL);
-    if (reply->status_code != RTSP_STATUS_OK) {
-        return -1;
-    } else {
-        rt->state = RTSP_STATE_PLAYING;
-        return 0;
+    if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
+        if (rt->state == RTSP_STATE_PAUSED) {
+            snprintf(cmd, sizeof(cmd),
+                     "PLAY %s RTSP/1.0\r\n",
+                     s->filename);
+        } else {
+            snprintf(cmd, sizeof(cmd),
+                     "PLAY %s RTSP/1.0\r\n"
+                     "Range: npt=%0.3f-\r\n",
+                     s->filename,
+                     (double)rt->seek_timestamp / AV_TIME_BASE);
+        }
+        rtsp_send_cmd(s, cmd, reply, NULL);
+        if (reply->status_code != RTSP_STATUS_OK) {
+            return -1;
+        }
     }
+    rt->state = RTSP_STATE_PLAYING;
+    return 0;
 }
 
 /* pause the stream */
@@ -1260,17 +1458,17 @@ static int rtsp_read_pause(AVFormatContext *s)
 
     if (rt->state != RTSP_STATE_PLAYING)
         return 0;
-
-    snprintf(cmd, sizeof(cmd),
-             "PAUSE %s RTSP/1.0\r\n",
-             s->filename);
-    rtsp_send_cmd(s, cmd, reply, NULL);
-    if (reply->status_code != RTSP_STATUS_OK) {
-        return -1;
-    } else {
-        rt->state = RTSP_STATE_PAUSED;
-        return 0;
+    else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
+        snprintf(cmd, sizeof(cmd),
+                 "PAUSE %s RTSP/1.0\r\n",
+                 s->filename);
+        rtsp_send_cmd(s, cmd, reply, NULL);
+        if (reply->status_code != RTSP_STATUS_OK) {
+            return -1;
+        }
     }
+    rt->state = RTSP_STATE_PAUSED;
+    return 0;
 }
 
 static int rtsp_read_seek(AVFormatContext *s, int stream_index,
@@ -1278,7 +1476,7 @@ static int rtsp_read_seek(AVFormatContext *s, int stream_index,
 {
     RTSPState *rt = s->priv_data;
 
-    rt->seek_timestamp = timestamp;
+    rt->seek_timestamp = av_rescale_q(timestamp, s->streams[stream_index]->time_base, AV_TIME_BASE_Q);
     switch(rt->state) {
     default:
     case RTSP_STATE_IDLE:
@@ -1302,7 +1500,7 @@ static int rtsp_read_close(AVFormatContext *s)
 
 #if 0
     /* NOTE: it is valid to flush the buffer here */
-    if (rt->protocol == RTSP_PROTOCOL_RTP_TCP) {
+    if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
         url_fclose(&rt->rtsp_gb);
     }
 #endif
@@ -1311,19 +1509,15 @@ static int rtsp_read_close(AVFormatContext *s)
              s->filename);
     rtsp_send_cmd(s, cmd, reply, NULL);
 
-    if (ff_rtsp_callback) {
-        ff_rtsp_callback(RTSP_ACTION_CLIENT_TEARDOWN, rt->session_id,
-                         NULL, 0, NULL);
-    }
-
     rtsp_close_streams(rt);
     url_close(rt->rtsp_hd);
     return 0;
 }
 
+#ifdef CONFIG_RTSP_DEMUXER
 AVInputFormat rtsp_demuxer = {
     "rtsp",
-    "RTSP input format",
+    NULL_IF_CONFIG_SMALL("RTSP input format"),
     sizeof(RTSPState),
     rtsp_probe,
     rtsp_read_header,
@@ -1334,6 +1528,7 @@ AVInputFormat rtsp_demuxer = {
     .read_play = rtsp_read_play,
     .read_pause = rtsp_read_pause,
 };
+#endif
 
 static int sdp_probe(AVProbeData *p1)
 {
@@ -1341,7 +1536,7 @@ static int sdp_probe(AVProbeData *p1)
 
     /* we look for a line beginning "c=IN IP4" */
     while (p < p_end && *p != '\0') {
-        if (p + sizeof("c=IN IP4") - 1 < p_end && strstart(p, "c=IN IP4", NULL))
+        if (p + sizeof("c=IN IP4") - 1 < p_end && av_strstart(p, "c=IN IP4", NULL))
             return AVPROBE_SCORE_MAX / 2;
 
         while(p < p_end - 1 && *p != '\n') p++;
@@ -1363,12 +1558,11 @@ static int sdp_read_header(AVFormatContext *s,
     int size, i, err;
     char *content;
     char url[1024];
-    AVStream *st;
 
     /* read the whole sdp file */
     /* XXX: better loading */
     content = av_malloc(SDP_MAX_SIZE);
-    size = get_buffer(&s->pb, content, SDP_MAX_SIZE - 1);
+    size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
     if (size <= 0) {
         av_free(content);
         return AVERROR_INVALIDDATA;
@@ -1382,30 +1576,17 @@ static int sdp_read_header(AVFormatContext *s,
     for(i=0;i<rt->nb_rtsp_streams;i++) {
         rtsp_st = rt->rtsp_streams[i];
 
-        snprintf(url, sizeof(url), "rtp://%s:%d?multicast=1&ttl=%d",
+        snprintf(url, sizeof(url), "rtp://%s:%d?localport=%d&ttl=%d",
                  inet_ntoa(rtsp_st->sdp_ip),
                  rtsp_st->sdp_port,
+                 rtsp_st->sdp_port,
                  rtsp_st->sdp_ttl);
         if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
             err = AVERROR_INVALIDDATA;
             goto fail;
         }
-        /* open the RTP context */
-        st = NULL;
-        if (rtsp_st->stream_index >= 0)
-            st = s->streams[rtsp_st->stream_index];
-        if (!st)
-            s->ctx_flags |= AVFMTCTX_NOHEADER;
-        rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data);
-        if (!rtsp_st->rtp_ctx) {
-            err = AVERROR_NOMEM;
+        if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
             goto fail;
-        } else {
-            if(rtsp_st->dynamic_handler) {
-                rtsp_st->rtp_ctx->dynamic_protocol_context= rtsp_st->dynamic_protocol_context;
-                rtsp_st->rtp_ctx->parse_packet= rtsp_st->dynamic_handler->parse_packet;
-            }
-        }
     }
     return 0;
  fail:
@@ -1429,7 +1610,7 @@ static int sdp_read_close(AVFormatContext *s)
 #ifdef CONFIG_SDP_DEMUXER
 AVInputFormat sdp_demuxer = {
     "sdp",
-    "SDP",
+    NULL_IF_CONFIG_SMALL("SDP"),
     sizeof(RTSPState),
     sdp_probe,
     sdp_read_header,
@@ -1438,6 +1619,7 @@ AVInputFormat sdp_demuxer = {
 };
 #endif
 
+#ifdef CONFIG_REDIR_DEMUXER
 /* dummy redirector format (used directly in av_open_input_file now) */
 static int redir_probe(AVProbeData *pd)
 {
@@ -1445,18 +1627,18 @@ static int redir_probe(AVProbeData *pd)
     p = pd->buf;
     while (redir_isspace(*p))
         p++;
-    if (strstart(p, "http://", NULL) ||
-        strstart(p, "rtsp://", NULL))
+    if (av_strstart(p, "http://", NULL) ||
+        av_strstart(p, "rtsp://", NULL))
         return AVPROBE_SCORE_MAX;
     return 0;
 }
 
-/* called from utils.c */
-int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f)
+static int redir_read_header(AVFormatContext *s, AVFormatParameters *ap)
 {
     char buf[4096], *q;
     int c;
     AVFormatContext *ic = NULL;
+    ByteIOContext *f = s->pb;
 
     /* parse each URL and try to open it */
     c = url_fgetc(f);
@@ -1484,19 +1666,22 @@ int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f)
         if (av_open_input_file(&ic, buf, NULL, 0, NULL) == 0)
             break;
     }
-    *ic_ptr = ic;
     if (!ic)
-        return AVERROR_IO;
-    else
-        return 0;
+        return AVERROR(EIO);
+
+    *s = *ic;
+    url_fclose(f);
+
+    return 0;
 }
 
 AVInputFormat redir_demuxer = {
     "redir",
-    "Redirector format",
+    NULL_IF_CONFIG_SMALL("Redirector format"),
     0,
     redir_probe,
-    NULL,
+    redir_read_header,
     NULL,
     NULL,
 };
+#endif