Replace all occurrences of AVERROR_IO with AVERROR(EIO).
[ffmpeg.git] / libavformat / rtsp.c
index b17c652..d6f8e39 100644 (file)
  */
 #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"
-#endif
+#include <unistd.h> /* for select() prototype */
+#include "network.h"
+#include "avstring.h"
+
+#include "rtp_internal.h"
 
 //#define DEBUG
 //#define DEBUG_RTP_TCP
@@ -69,6 +66,9 @@ typedef struct RTSPStream {
     int sdp_ttl;  /* IP TTL (from SDP content - not used in RTSP) */
     int sdp_payload_type; /* payload type - only used in SDP */
     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)
 } RTSPStream;
 
 static int rtsp_read_play(AVFormatContext *s);
@@ -78,11 +78,9 @@ static int rtsp_read_play(AVFormatContext *s);
 
 int rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_UDP);
 
-FFRTSPCallback *ff_rtsp_callback = NULL;
-
 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;
 }
@@ -142,7 +140,7 @@ static void get_word(char *buf, int buf_size, const char **pp)
 
 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other
    params>] */
-static int sdp_parse_rtpmap(AVCodecContext *codec, int payload_type, const char *p)
+static int sdp_parse_rtpmap(AVCodecContext *codec, RTSPStream *rtsp_st, int payload_type, const char *p)
 {
     char buf[256];
     int i;
@@ -153,12 +151,18 @@ static int sdp_parse_rtpmap(AVCodecContext *codec, int payload_type, const char
        see if we can handle this kind of payload */
     get_word_sep(buf, sizeof(buf), "/", &p);
     if (payload_type >= RTP_PT_PRIVATE) {
-        /* We are in dynmaic payload type case ... search into AVRtpDynamicPayloadTypes[] */
-        for (i = 0; AVRtpDynamicPayloadTypes[i].codec_id != CODEC_ID_NONE; ++i)
-            if (!strcmp(buf, AVRtpDynamicPayloadTypes[i].enc_name) && (codec->codec_type == AVRtpDynamicPayloadTypes[i].codec_type)) {
-                codec->codec_id = AVRtpDynamicPayloadTypes[i].codec_id;
+        RTPDynamicProtocolHandler *handler= RTPFirstDynamicPayloadHandler;
+        while(handler) {
+            if (!strcmp(buf, handler->enc_name) && (codec->codec_type == handler->codec_type)) {
+                codec->codec_id = handler->codec_id;
+                rtsp_st->dynamic_handler= handler;
+                if(handler->open) {
+                    rtsp_st->dynamic_protocol_context= handler->open();
+                }
                 break;
             }
+            handler= handler->next;
+        }
     } else {
         /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
         /* search into AVRtpPayloadTypes[] */
@@ -189,6 +193,8 @@ static int sdp_parse_rtpmap(AVCodecContext *codec, int payload_type, const char
                     i = atoi(buf);
                     if (i > 0)
                         codec->channels = i;
+                    // TODO: there is a bug here; if it is a mono stream, and less than 22000Hz, faad upconverts to stereo and twice the
+                    //  frequency.  No problem, but the sample rate is being set here by the sdp line.  Upcoming patch forthcoming. (rdm)
                 }
                 av_log(codec, AV_LOG_DEBUG, " audio samplerate set to : %i\n", codec->sample_rate);
                 av_log(codec, AV_LOG_DEBUG, " audio channels set to : %i\n", codec->channels);
@@ -238,7 +244,7 @@ static void sdp_parse_fmtp_config(AVCodecContext *codec, char *attr, char *value
 {
     switch (codec->codec_id) {
         case CODEC_ID_MPEG4:
-        case CODEC_ID_MPEG4AAC:
+        case CODEC_ID_AAC:
             if (!strcmp(attr, "config")) {
                 /* decode the hexa encoded parameter */
                 int len = hex_to_data(NULL, value);
@@ -276,6 +282,25 @@ static attrname_map_t attr_names[]=
     {NULL, -1, -1},
 };
 
+/** parse the attribute line from the fmtp a line of an sdp resonse.  This is broken out as a function
+* because it is used in rtp_h264.c, which is forthcoming.
+*/
+int rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
+{
+    skip_spaces(p);
+    if(**p)
+    {
+        get_word_sep(attr, attr_size, "=", p);
+        if (**p == '=')
+            (*p)++;
+        get_word_sep(value, value_size, ";", p);
+        if (**p == ';')
+            (*p)++;
+        return 1;
+    }
+    return 0;
+}
+
 /* parse a SDP line and save stream attributes */
 static void sdp_parse_fmtp(AVStream *st, const char *p)
 {
@@ -288,16 +313,8 @@ static void sdp_parse_fmtp(AVStream *st, const char *p)
     rtp_payload_data_t *rtp_payload_data = &rtsp_st->rtp_payload_data;
 
     /* 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 */
@@ -312,6 +329,32 @@ static void sdp_parse_fmtp(AVStream *st, const char *p)
     }
 }
 
+/** Parse a string \p in the form of Range:npt=xx-xx, and determine the start
+ *  and end time.
+ *  Used for seeking in the rtp stream.
+ */
+static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
+{
+    char buf[256];
+
+    skip_spaces(&p);
+    if (!av_stristart(p, "npt=", &p))
+        return;
+
+    *start = AV_NOPTS_VALUE;
+    *end = AV_NOPTS_VALUE;
+
+    get_word_sep(buf, sizeof(buf), "-", &p);
+    *start = parse_date(buf, 1);
+    if (*p == '-') {
+        p++;
+        get_word_sep(buf, sizeof(buf), "-", &p);
+        *end = parse_date(buf, 1);
+    }
+//    av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
+//    av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
+}
+
 typedef struct SDPParseState {
     /* SDP only */
     struct in_addr default_ip;
@@ -363,11 +406,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;
@@ -414,10 +457,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];
@@ -427,12 +470,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);
@@ -440,10 +483,10 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
                 st = s->streams[i];
                 rtsp_st = st->priv_data;
                 if (rtsp_st->sdp_payload_type == payload_type) {
-                    sdp_parse_rtpmap(st->codec, payload_type, p);
+                    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);
@@ -451,9 +494,35 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
                 st = s->streams[i];
                 rtsp_st = st->priv_data;
                 if (rtsp_st->sdp_payload_type == payload_type) {
-                    sdp_parse_fmtp(st, p);
+                    if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) {
+                        if(!rtsp_st->dynamic_handler->parse_sdp_a_line(st, rtsp_st->dynamic_protocol_context, buf)) {
+                            sdp_parse_fmtp(st, p);
+                        }
+                    } else {
+                        sdp_parse_fmtp(st, 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);
+            for(i = 0; i < s->nb_streams;i++) {
+                st = s->streams[i];
+                rtsp_st = st->priv_data;
+                if (rtsp_st->sdp_payload_type == payload_type) {
+                    if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) {
+                        rtsp_st->dynamic_handler->parse_sdp_a_line(st, rtsp_st->dynamic_protocol_context, buf);
+                    }
                 }
             }
+        } 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)
         }
         break;
     }
@@ -608,42 +677,22 @@ static void rtsp_parse_transport(RTSPHeader *reply, const char *p)
     }
 }
 
-static void rtsp_parse_range_npt(RTSPHeader *reply, const char *p)
-{
-    char buf[256];
-
-    skip_spaces(&p);
-    if (!stristart(p, "npt=", &p))
-        return;
-
-    reply->range_start = AV_NOPTS_VALUE;
-    reply->range_end = AV_NOPTS_VALUE;
-
-    get_word_sep(buf, sizeof(buf), "-", &p);
-    reply->range_start = parse_date(buf, 1);
-    if (*p == '-') {
-        p++;
-        get_word_sep(buf, sizeof(buf), "-", &p);
-        reply->range_end = parse_date(buf, 1);
-    }
-}
-
 void rtsp_parse_line(RTSPHeader *reply, const char *buf)
 {
     const char *p;
 
     /* 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)) {
-        rtsp_parse_range_npt(reply, p);
+    } else if (av_stristart(p, "Range:", &p)) {
+        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
     }
 }
 
@@ -671,7 +720,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
@@ -701,14 +750,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
@@ -747,14 +796,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) {
@@ -765,13 +814,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);
 }
 
 
@@ -788,6 +832,8 @@ static void rtsp_close_streams(RTSPState *rt)
                 rtp_parse_close(rtsp_st->rtp_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);
     }
@@ -798,13 +844,13 @@ static int rtsp_read_header(AVFormatContext *s,
                             AVFormatParameters *ap)
 {
     RTSPState *rt = s->priv_data;
-    char host[1024], path[1024], tcpname[1024], cmd[2048];
+    char host[1024], path[1024], tcpname[1024], cmd[2048], *option_list, *option;
     URLContext *rtsp_hd;
     int port, i, j, ret, err;
     RTSPHeader reply1, *reply = &reply1;
     unsigned char *content = NULL;
     RTSPStream *rtsp_st;
-    int protocol_mask;
+    int protocol_mask = 0;
     AVStream *st;
 
     /* extract hostname and port */
@@ -813,10 +859,34 @@ static int rtsp_read_header(AVFormatContext *s,
     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)
+                protocol_mask = (1<< RTSP_PROTOCOL_RTP_UDP);
+            else if (strcmp(option, "multicast") == 0)
+                protocol_mask = (1<< RTSP_PROTOCOL_RTP_UDP_MULTICAST);
+            else if (strcmp(option, "tcp") == 0)
+                protocol_mask = (1<< RTSP_PROTOCOL_RTP_TCP);
+        }
+    }
+
+    if (!protocol_mask)
+        protocol_mask = rtsp_default_protocols;
+
     /* 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;
+        return AVERROR(EIO);
     rt->rtsp_hd = rtsp_hd;
     rt->seq = 0;
 
@@ -843,8 +913,6 @@ static int rtsp_read_header(AVFormatContext *s,
         goto fail;
     }
 
-    protocol_mask = rtsp_default_protocols;
-
     /* for each stream, make the setup request */
     /* XXX: we assume the same server is used for the control of each
        RTSP stream */
@@ -865,7 +933,7 @@ static int rtsp_read_header(AVFormatContext *s,
             if (RTSP_RTP_PORT_MIN != 0) {
                 while(j <= RTSP_RTP_PORT_MAX) {
                     snprintf(buf, sizeof(buf), "rtp://?localport=%d", j);
-                    if (url_open(&rtsp_st->rtp_handle, buf, URL_RDONLY) == 0) {
+                    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;
                     }
@@ -882,7 +950,7 @@ 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), ",");
+                av_strlcat(transport, ",", sizeof(transport));
             snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1,
                      "RTP/AVP/UDP;unicast;client_port=%d-%d",
                      port, port + 1);
@@ -891,14 +959,14 @@ static int rtsp_read_header(AVFormatContext *s,
         /* RTP/TCP */
         else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_TCP)) {
             if (transport[0] != '\0')
-                pstrcat(transport, sizeof(transport), ",");
+                av_strlcat(transport, ",", sizeof(transport));
             snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1,
                      "RTP/AVP/TCP");
         }
 
         else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP_MULTICAST)) {
             if (transport[0] != '\0')
-                pstrcat(transport, sizeof(transport), ",");
+                av_strlcat(transport, ",", sizeof(transport));
             snprintf(transport + strlen(transport),
                      sizeof(transport) - strlen(transport) - 1,
                      "RTP/AVP/UDP;multicast");
@@ -953,16 +1021,14 @@ static int rtsp_read_header(AVFormatContext *s,
         case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
             {
                 char url[1024];
-                int ttl;
+                struct in_addr in;
 
-                ttl = reply->transports[0].ttl;
-                if (!ttl)
-                    ttl = 16;
+                in.s_addr = htonl(reply->transports[0].destination);
                 snprintf(url, sizeof(url), "rtp://%s:%d?multicast=1&ttl=%d",
-                         host,
-                         reply->transports[0].server_port_min,
-                         ttl);
-                if (url_open(&rtsp_st->rtp_handle, url, URL_RDONLY) < 0) {
+                         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;
                 }
@@ -975,24 +1041,19 @@ static int rtsp_read_header(AVFormatContext *s,
             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->sdp_payload_type, &rtsp_st->rtp_payload_data);
+        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;
-            goto fail;
-        }
-    }
-
-    /* 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) {
-            err = AVERROR_INVALIDDATA;
+            err = AVERROR(ENOMEM);
             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;
+            }
         }
     }
 
-
     rt->state = RTSP_STATE_IDLE;
     rt->seek_timestamp = 0; /* default is to start stream at position
                                zero */
@@ -1037,7 +1098,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
@@ -1133,10 +1194,12 @@ static int rtsp_read_packet(AVFormatContext *s,
     case RTSP_PROTOCOL_RTP_UDP:
     case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
         len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
+        if (len >=0 && rtsp_st->rtp_ctx)
+            rtp_check_and_send_back_rr(rtsp_st->rtp_ctx, len);
         break;
     }
     if (len < 0)
-        return AVERROR_IO;
+        return AVERROR(EIO);
     ret = rtp_parse_packet(rtsp_st->rtp_ctx, pkt, buf, len);
     if (ret < 0)
         goto redo;
@@ -1237,16 +1300,12 @@ 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",
@@ -1260,6 +1319,7 @@ AVInputFormat rtsp_demuxer = {
     .read_play = rtsp_read_play,
     .read_pause = rtsp_read_pause,
 };
+#endif
 
 static int sdp_probe(AVProbeData *p1)
 {
@@ -1267,7 +1327,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++;
@@ -1312,7 +1372,7 @@ static int sdp_read_header(AVFormatContext *s,
                  inet_ntoa(rtsp_st->sdp_ip),
                  rtsp_st->sdp_port,
                  rtsp_st->sdp_ttl);
-        if (url_open(&rtsp_st->rtp_handle, url, URL_RDONLY) < 0) {
+        if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
             err = AVERROR_INVALIDDATA;
             goto fail;
         }
@@ -1322,10 +1382,15 @@ static int sdp_read_header(AVFormatContext *s,
             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->sdp_payload_type, &rtsp_st->rtp_payload_data);
+        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;
+            err = AVERROR(ENOMEM);
             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;
@@ -1359,6 +1424,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)
 {
@@ -1366,8 +1432,8 @@ 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;
 }
@@ -1407,7 +1473,7 @@ int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f)
     }
     *ic_ptr = ic;
     if (!ic)
-        return AVERROR_IO;
+        return AVERROR(EIO);
     else
         return 0;
 }
@@ -1421,3 +1487,4 @@ AVInputFormat redir_demuxer = {
     NULL,
     NULL,
 };
+#endif