git.sesse.net Git - ffmpeg/blob - libavformat/rtsp.c

   1 /*
   2  * RTSP/SDP client
   3  * Copyright (c) 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/avassert.h"
  23 #include "libavutil/base64.h"
  24 #include "libavutil/avstring.h"
  25 #include "libavutil/intreadwrite.h"
  26 #include "libavutil/mathematics.h"
  27 #include "libavutil/parseutils.h"
  28 #include "libavutil/random_seed.h"
  29 #include "libavutil/dict.h"
  30 #include "libavutil/opt.h"
  31 #include "libavutil/time.h"
  32 #include "avformat.h"
  33 #include "avio_internal.h"
  34
  35 #if HAVE_POLL_H
  36 #include <poll.h>
  37 #endif
  38 #include "internal.h"
  39 #include "network.h"
  40 #include "os_support.h"
  41 #include "http.h"
  42 #include "rtsp.h"
  43
  44 #include "rtpdec.h"
  45 #include "rtpproto.h"
  46 #include "rdt.h"
  47 #include "rtpdec_formats.h"
  48 #include "rtpenc_chain.h"
  49 #include "url.h"
  50 #include "rtpenc.h"
  51 #include "mpegts.h"
  52
  53 /* Timeout values for socket poll, in ms,
  54  * and read_packet(), in seconds  */
  55 #define POLL_TIMEOUT_MS 100
  56 #define READ_PACKET_TIMEOUT_S 10
  57 #define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS
  58 #define SDP_MAX_SIZE 16384
  59 #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
  60 #define DEFAULT_REORDERING_DELAY 100000
  61
  62 #define OFFSET(x) offsetof(RTSPState, x)
  63 #define DEC AV_OPT_FLAG_DECODING_PARAM
  64 #define ENC AV_OPT_FLAG_ENCODING_PARAM
  65
  66 #define RTSP_FLAG_OPTS(name, longname) \
  67     { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \
  68     { "filter_src", "only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, "rtsp_flags" }
  69
  70 #define RTSP_MEDIATYPE_OPTS(name, longname) \
  71     { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1 }, INT_MIN, INT_MAX, DEC, "allowed_media_types" }, \
  72     { "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \
  73     { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \
  74     { "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" }, \
  75     { "subtitle", "Subtitle", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_SUBTITLE}, 0, 0, DEC, "allowed_media_types" }
  76
  77 #define COMMON_OPTS() \
  78     { "reorder_queue_size", "set number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }, \
  79     { "buffer_size",        "Underlying protocol send/receive buffer size",                  OFFSET(buffer_size),           AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC|ENC } \
  80
  81
  82 const AVOption ff_rtsp_options[] = {
  83     { "initial_pause",  "do not start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC },
  84     FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
  85     { "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, "rtsp_transport" }, \
  86     { "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
  87     { "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
  88     { "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, "rtsp_transport" },
  89     { "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, "rtsp_transport" },
  90     RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),
  91     { "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, "rtsp_flags" },
  92     { "prefer_tcp", "try RTP via TCP first, if available", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_PREFER_TCP}, 0, 0, DEC|ENC, "rtsp_flags" },
  93     RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
  94     { "min_port", "set minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },
  95     { "max_port", "set maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },
  96     { "timeout", "set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen)", OFFSET(initial_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC },
  97     { "stimeout", "set timeout (in microseconds) of socket TCP I/O operations", OFFSET(stimeout), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC },
  98     COMMON_OPTS(),
  99     { "user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },
 100     { NULL },
 101 };
 102
 103 static const AVOption sdp_options[] = {
 104     RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
 105     { "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, "rtsp_flags" },
 106     { "rtcp_to_source", "send RTCP packets to the source address of received packets", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_RTCP_TO_SOURCE}, 0, 0, DEC, "rtsp_flags" },
 107     RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
 108     COMMON_OPTS(),
 109     { NULL },
 110 };
 111
 112 static const AVOption rtp_options[] = {
 113     RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
 114     COMMON_OPTS(),
 115     { NULL },
 116 };
 117
 118
 119 static AVDictionary *map_to_opts(RTSPState *rt)
 120 {
 121     AVDictionary *opts = NULL;
 122     char buf[256];
 123
 124     snprintf(buf, sizeof(buf), "%d", rt->buffer_size);
 125     av_dict_set(&opts, "buffer_size", buf, 0);
 126
 127     return opts;
 128 }
 129
 130 static void get_word_until_chars(char *buf, int buf_size,
 131                                  const char *sep, const char **pp)
 132 {
 133     const char *p;
 134     char *q;
 135
 136     p = *pp;
 137     p += strspn(p, SPACE_CHARS);
 138     q = buf;
 139     while (!strchr(sep, *p) && *p != '\0') {
 140         if ((q - buf) < buf_size - 1)
 141             *q++ = *p;
 142         p++;
 143     }
 144     if (buf_size > 0)
 145         *q = '\0';
 146     *pp = p;
 147 }
 148
 149 static void get_word_sep(char *buf, int buf_size, const char *sep,
 150                          const char **pp)
 151 {
 152     if (**pp == '/') (*pp)++;
 153     get_word_until_chars(buf, buf_size, sep, pp);
 154 }
 155
 156 static void get_word(char *buf, int buf_size, const char **pp)
 157 {
 158     get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
 159 }
 160
 161 /** Parse a string p in the form of Range:npt=xx-xx, and determine the start
 162  *  and end time.
 163  *  Used for seeking in the rtp stream.
 164  */
 165 static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
 166 {
 167     char buf[256];
 168
 169     p += strspn(p, SPACE_CHARS);
 170     if (!av_stristart(p, "npt=", &p))
 171         return;
 172
 173     *start = AV_NOPTS_VALUE;
 174     *end = AV_NOPTS_VALUE;
 175
 176     get_word_sep(buf, sizeof(buf), "-", &p);
 177     if (av_parse_time(start, buf, 1) < 0)
 178         return;
 179     if (*p == '-') {
 180         p++;
 181         get_word_sep(buf, sizeof(buf), "-", &p);
 182         av_parse_time(end, buf, 1);
 183     }
 184 }
 185
 186 static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
 187 {
 188     struct addrinfo hints = { 0 }, *ai = NULL;
 189     hints.ai_flags = AI_NUMERICHOST;
 190     if (getaddrinfo(buf, NULL, &hints, &ai))
 191         return -1;
 192     memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
 193     freeaddrinfo(ai);
 194     return 0;
 195 }
 196
 197 #if CONFIG_RTPDEC
 198 static void init_rtp_handler(RTPDynamicProtocolHandler *handler,
 199                              RTSPStream *rtsp_st, AVStream *st)
 200 {
 201     AVCodecContext *codec = st ? st->codec : NULL;
 202     if (!handler)
 203         return;
 204     if (codec)
 205         codec->codec_id          = handler->codec_id;
 206     rtsp_st->dynamic_handler = handler;
 207     if (st)
 208         st->need_parsing = handler->need_parsing;
 209     if (handler->priv_data_size) {
 210         rtsp_st->dynamic_protocol_context = av_mallocz(handler->priv_data_size);
 211         if (!rtsp_st->dynamic_protocol_context)
 212             rtsp_st->dynamic_handler = NULL;
 213     }
 214 }
 215
 216 static void finalize_rtp_handler_init(AVFormatContext *s, RTSPStream *rtsp_st,
 217                                       AVStream *st)
 218 {
 219     if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init) {
 220         int ret = rtsp_st->dynamic_handler->init(s, st ? st->index : -1,
 221                                                  rtsp_st->dynamic_protocol_context);
 222         if (ret < 0) {
 223             if (rtsp_st->dynamic_protocol_context) {
 224                 if (rtsp_st->dynamic_handler->close)
 225                     rtsp_st->dynamic_handler->close(
 226                         rtsp_st->dynamic_protocol_context);
 227                 av_free(rtsp_st->dynamic_protocol_context);
 228             }
 229             rtsp_st->dynamic_protocol_context = NULL;
 230             rtsp_st->dynamic_handler = NULL;
 231         }
 232     }
 233 }
 234
 235 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
 236 static int sdp_parse_rtpmap(AVFormatContext *s,
 237                             AVStream *st, RTSPStream *rtsp_st,
 238                             int payload_type, const char *p)
 239 {
 240     AVCodecContext *codec = st->codec;
 241     char buf[256];
 242     int i;
 243     AVCodec *c;
 244     const char *c_name;
 245
 246     /* See if we can handle this kind of payload.
 247      * The space should normally not be there but some Real streams or
 248      * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
 249      * have a trailing space. */
 250     get_word_sep(buf, sizeof(buf), "/ ", &p);
 251     if (payload_type < RTP_PT_PRIVATE) {
 252         /* We are in a standard case
 253          * (from http://www.iana.org/assignments/rtp-parameters). */
 254         codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
 255     }
 256
 257     if (codec->codec_id == AV_CODEC_ID_NONE) {
 258         RTPDynamicProtocolHandler *handler =
 259             ff_rtp_handler_find_by_name(buf, codec->codec_type);
 260         init_rtp_handler(handler, rtsp_st, st);
 261         /* If no dynamic handler was found, check with the list of standard
 262          * allocated types, if such a stream for some reason happens to
 263          * use a private payload type. This isn't handled in rtpdec.c, since
 264          * the format name from the rtpmap line never is passed into rtpdec. */
 265         if (!rtsp_st->dynamic_handler)
 266             codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
 267     }
 268
 269     c = avcodec_find_decoder(codec->codec_id);
 270     if (c && c->name)
 271         c_name = c->name;
 272     else
 273         c_name = "(null)";
 274
 275     get_word_sep(buf, sizeof(buf), "/", &p);
 276     i = atoi(buf);
 277     switch (codec->codec_type) {
 278     case AVMEDIA_TYPE_AUDIO:
 279         av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
 280         codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
 281         codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
 282         if (i > 0) {
 283             codec->sample_rate = i;
 284             avpriv_set_pts_info(st, 32, 1, codec->sample_rate);
 285             get_word_sep(buf, sizeof(buf), "/", &p);
 286             i = atoi(buf);
 287             if (i > 0)
 288                 codec->channels = i;
 289         }
 290         av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
 291                codec->sample_rate);
 292         av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
 293                codec->channels);
 294         break;
 295     case AVMEDIA_TYPE_VIDEO:
 296         av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
 297         if (i > 0)
 298             avpriv_set_pts_info(st, 32, 1, i);
 299         break;
 300     default:
 301         break;
 302     }
 303     finalize_rtp_handler_init(s, rtsp_st, st);
 304     return 0;
 305 }
 306
 307 /* parse the attribute line from the fmtp a line of an sdp response. This
 308  * is broken out as a function because it is used in rtp_h264.c, which is
 309  * forthcoming. */
 310 int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
 311                                 char *value, int value_size)
 312 {
 313     *p += strspn(*p, SPACE_CHARS);
 314     if (**p) {
 315         get_word_sep(attr, attr_size, "=", p);
 316         if (**p == '=')
 317             (*p)++;
 318         get_word_sep(value, value_size, ";", p);
 319         if (**p == ';')
 320             (*p)++;
 321         return 1;
 322     }
 323     return 0;
 324 }
 325
 326 typedef struct SDPParseState {
 327     /* SDP only */
 328     struct sockaddr_storage default_ip;
 329     int            default_ttl;
 330     int            skip_media;  ///< set if an unknown m= line occurs
 331     int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */
 332     struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */
 333     int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
 334     struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */
 335     int seen_rtpmap;
 336     int seen_fmtp;
 337     char delayed_fmtp[2048];
 338 } SDPParseState;
 339
 340 static void copy_default_source_addrs(struct RTSPSource **addrs, int count,
 341                                       struct RTSPSource ***dest, int *dest_count)
 342 {
 343     RTSPSource *rtsp_src, *rtsp_src2;
 344     int i;
 345     for (i = 0; i < count; i++) {
 346         rtsp_src = addrs[i];
 347         rtsp_src2 = av_malloc(sizeof(*rtsp_src2));
 348         if (!rtsp_src2)
 349             continue;
 350         memcpy(rtsp_src2, rtsp_src, sizeof(*rtsp_src));
 351         dynarray_add(dest, dest_count, rtsp_src2);
 352     }
 353 }
 354
 355 static void parse_fmtp(AVFormatContext *s, RTSPState *rt,
 356                        int payload_type, const char *line)
 357 {
 358     int i;
 359
 360     for (i = 0; i < rt->nb_rtsp_streams; i++) {
 361         RTSPStream *rtsp_st = rt->rtsp_streams[i];
 362         if (rtsp_st->sdp_payload_type == payload_type &&
 363             rtsp_st->dynamic_handler &&
 364             rtsp_st->dynamic_handler->parse_sdp_a_line) {
 365             rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
 366                 rtsp_st->dynamic_protocol_context, line);
 367         }
 368     }
 369 }
 370
 371 static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
 372                            int letter, const char *buf)
 373 {
 374     RTSPState *rt = s->priv_data;
 375     char buf1[64], st_type[64];
 376     const char *p;
 377     enum AVMediaType codec_type;
 378     int payload_type;
 379     AVStream *st;
 380     RTSPStream *rtsp_st;
 381     RTSPSource *rtsp_src;
 382     struct sockaddr_storage sdp_ip;
 383     int ttl;
 384
 385     av_log(s, AV_LOG_TRACE, "sdp: %c='%s'\n", letter, buf);
 386
 387     p = buf;
 388     if (s1->skip_media && letter != 'm')
 389         return;
 390     switch (letter) {
 391     case 'c':
 392         get_word(buf1, sizeof(buf1), &p);
 393         if (strcmp(buf1, "IN") != 0)
 394             return;
 395         get_word(buf1, sizeof(buf1), &p);
 396         if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
 397             return;
 398         get_word_sep(buf1, sizeof(buf1), "/", &p);
 399         if (get_sockaddr(buf1, &sdp_ip))
 400             return;
 401         ttl = 16;
 402         if (*p == '/') {
 403             p++;
 404             get_word_sep(buf1, sizeof(buf1), "/", &p);
 405             ttl = atoi(buf1);
 406         }
 407         if (s->nb_streams == 0) {
 408             s1->default_ip = sdp_ip;
 409             s1->default_ttl = ttl;
 410         } else {
 411             rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 412             rtsp_st->sdp_ip = sdp_ip;
 413             rtsp_st->sdp_ttl = ttl;
 414         }
 415         break;
 416     case 's':
 417         av_dict_set(&s->metadata, "title", p, 0);
 418         break;
 419     case 'i':
 420         if (s->nb_streams == 0) {
 421             av_dict_set(&s->metadata, "comment", p, 0);
 422             break;
 423         }
 424         break;
 425     case 'm':
 426         /* new stream */
 427         s1->skip_media  = 0;
 428         s1->seen_fmtp   = 0;
 429         s1->seen_rtpmap = 0;
 430         codec_type = AVMEDIA_TYPE_UNKNOWN;
 431         get_word(st_type, sizeof(st_type), &p);
 432         if (!strcmp(st_type, "audio")) {
 433             codec_type = AVMEDIA_TYPE_AUDIO;
 434         } else if (!strcmp(st_type, "video")) {
 435             codec_type = AVMEDIA_TYPE_VIDEO;
 436         } else if (!strcmp(st_type, "application")) {
 437             codec_type = AVMEDIA_TYPE_DATA;
 438         } else if (!strcmp(st_type, "text")) {
 439             codec_type = AVMEDIA_TYPE_SUBTITLE;
 440         }
 441         if (codec_type == AVMEDIA_TYPE_UNKNOWN || !(rt->media_type_mask & (1 << codec_type))) {
 442             s1->skip_media = 1;
 443             return;
 444         }
 445         rtsp_st = av_mallocz(sizeof(RTSPStream));
 446         if (!rtsp_st)
 447             return;
 448         rtsp_st->stream_index = -1;
 449         dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
 450
 451         rtsp_st->sdp_ip = s1->default_ip;
 452         rtsp_st->sdp_ttl = s1->default_ttl;
 453
 454         copy_default_source_addrs(s1->default_include_source_addrs,
 455                                   s1->nb_default_include_source_addrs,
 456                                   &rtsp_st->include_source_addrs,
 457                                   &rtsp_st->nb_include_source_addrs);
 458         copy_default_source_addrs(s1->default_exclude_source_addrs,
 459                                   s1->nb_default_exclude_source_addrs,
 460                                   &rtsp_st->exclude_source_addrs,
 461                                   &rtsp_st->nb_exclude_source_addrs);
 462
 463         get_word(buf1, sizeof(buf1), &p); /* port */
 464         rtsp_st->sdp_port = atoi(buf1);
 465
 466         get_word(buf1, sizeof(buf1), &p); /* protocol */
 467         if (!strcmp(buf1, "udp"))
 468             rt->transport = RTSP_TRANSPORT_RAW;
 469         else if (strstr(buf1, "/AVPF") || strstr(buf1, "/SAVPF"))
 470             rtsp_st->feedback = 1;
 471
 472         /* XXX: handle list of formats */
 473         get_word(buf1, sizeof(buf1), &p); /* format list */
 474         rtsp_st->sdp_payload_type = atoi(buf1);
 475
 476         if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
 477             /* no corresponding stream */
 478             if (rt->transport == RTSP_TRANSPORT_RAW) {
 479                 if (CONFIG_RTPDEC && !rt->ts)
 480                     rt->ts = avpriv_mpegts_parse_open(s);
 481             } else {
 482                 RTPDynamicProtocolHandler *handler;
 483                 handler = ff_rtp_handler_find_by_id(
 484                               rtsp_st->sdp_payload_type, AVMEDIA_TYPE_DATA);
 485                 init_rtp_handler(handler, rtsp_st, NULL);
 486                 finalize_rtp_handler_init(s, rtsp_st, NULL);
 487             }
 488         } else if (rt->server_type == RTSP_SERVER_WMS &&
 489                    codec_type == AVMEDIA_TYPE_DATA) {
 490             /* RTX stream, a stream that carries all the other actual
 491              * audio/video streams. Don't expose this to the callers. */
 492         } else {
 493             st = avformat_new_stream(s, NULL);
 494             if (!st)
 495                 return;
 496             st->id = rt->nb_rtsp_streams - 1;
 497             rtsp_st->stream_index = st->index;
 498             st->codec->codec_type = codec_type;
 499             if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
 500                 RTPDynamicProtocolHandler *handler;
 501                 /* if standard payload type, we can find the codec right now */
 502                 ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
 503                 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
 504                     st->codec->sample_rate > 0)
 505                     avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
 506                 /* Even static payload types may need a custom depacketizer */
 507                 handler = ff_rtp_handler_find_by_id(
 508                               rtsp_st->sdp_payload_type, st->codec->codec_type);
 509                 init_rtp_handler(handler, rtsp_st, st);
 510                 finalize_rtp_handler_init(s, rtsp_st, st);
 511             }
 512             if (rt->default_lang[0])
 513                 av_dict_set(&st->metadata, "language", rt->default_lang, 0);
 514         }
 515         /* put a default control url */
 516         av_strlcpy(rtsp_st->control_url, rt->control_uri,
 517                    sizeof(rtsp_st->control_url));
 518         break;
 519     case 'a':
 520         if (av_strstart(p, "control:", &p)) {
 521             if (s->nb_streams == 0) {
 522                 if (!strncmp(p, "rtsp://", 7))
 523                     av_strlcpy(rt->control_uri, p,
 524                                sizeof(rt->control_uri));
 525             } else {
 526                 char proto[32];
 527                 /* get the control url */
 528                 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 529
 530                 /* XXX: may need to add full url resolution */
 531                 av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
 532                              NULL, NULL, 0, p);
 533                 if (proto[0] == '\0') {
 534                     /* relative control URL */
 535                     if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
 536                     av_strlcat(rtsp_st->control_url, "/",
 537                                sizeof(rtsp_st->control_url));
 538                     av_strlcat(rtsp_st->control_url, p,
 539                                sizeof(rtsp_st->control_url));
 540                 } else
 541                     av_strlcpy(rtsp_st->control_url, p,
 542                                sizeof(rtsp_st->control_url));
 543             }
 544         } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
 545             /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
 546             get_word(buf1, sizeof(buf1), &p);
 547             payload_type = atoi(buf1);
 548             rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 549             if (rtsp_st->stream_index >= 0) {
 550                 st = s->streams[rtsp_st->stream_index];
 551                 sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
 552             }
 553             s1->seen_rtpmap = 1;
 554             if (s1->seen_fmtp) {
 555                 parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);
 556             }
 557         } else if (av_strstart(p, "fmtp:", &p) ||
 558                    av_strstart(p, "framesize:", &p)) {
 559             // let dynamic protocol handlers have a stab at the line.
 560             get_word(buf1, sizeof(buf1), &p);
 561             payload_type = atoi(buf1);
 562             if (s1->seen_rtpmap) {
 563                 parse_fmtp(s, rt, payload_type, buf);
 564             } else {
 565                 s1->seen_fmtp = 1;
 566                 av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp));
 567             }
 568         } else if (av_strstart(p, "range:", &p)) {
 569             int64_t start, end;
 570
 571             // this is so that seeking on a streamed file can work.
 572             rtsp_parse_range_npt(p, &start, &end);
 573             s->start_time = start;
 574             /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
 575             s->duration   = (end == AV_NOPTS_VALUE) ?
 576                             AV_NOPTS_VALUE : end - start;
 577         } else if (av_strstart(p, "lang:", &p)) {
 578             if (s->nb_streams > 0) {
 579                 get_word(buf1, sizeof(buf1), &p);
 580                 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 581                 if (rtsp_st->stream_index >= 0) {
 582                     st = s->streams[rtsp_st->stream_index];
 583                     av_dict_set(&st->metadata, "language", buf1, 0);
 584                 }
 585             } else
 586                 get_word(rt->default_lang, sizeof(rt->default_lang), &p);
 587         } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
 588             if (atoi(p) == 1)
 589                 rt->transport = RTSP_TRANSPORT_RDT;
 590         } else if (av_strstart(p, "SampleRate:integer;", &p) &&
 591                    s->nb_streams > 0) {
 592             st = s->streams[s->nb_streams - 1];
 593             st->codec->sample_rate = atoi(p);
 594         } else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {
 595             // RFC 4568
 596             rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 597             get_word(buf1, sizeof(buf1), &p); // ignore tag
 598             get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);
 599             p += strspn(p, SPACE_CHARS);
 600             if (av_strstart(p, "inline:", &p))
 601                 get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);
 602         } else if (av_strstart(p, "source-filter:", &p)) {
 603             int exclude = 0;
 604             get_word(buf1, sizeof(buf1), &p);
 605             if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))
 606                 return;
 607             exclude = !strcmp(buf1, "excl");
 608
 609             get_word(buf1, sizeof(buf1), &p);
 610             if (strcmp(buf1, "IN") != 0)
 611                 return;
 612             get_word(buf1, sizeof(buf1), &p);
 613             if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))
 614                 return;
 615             // not checking that the destination address actually matches or is wildcard
 616             get_word(buf1, sizeof(buf1), &p);
 617
 618             while (*p != '\0') {
 619                 rtsp_src = av_mallocz(sizeof(*rtsp_src));
 620                 if (!rtsp_src)
 621                     return;
 622                 get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);
 623                 if (exclude) {
 624                     if (s->nb_streams == 0) {
 625                         dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
 626                     } else {
 627                         rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 628                         dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);
 629                     }
 630                 } else {
 631                     if (s->nb_streams == 0) {
 632                         dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
 633                     } else {
 634                         rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 635                         dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);
 636                     }
 637                 }
 638             }
 639         } else {
 640             if (rt->server_type == RTSP_SERVER_WMS)
 641                 ff_wms_parse_sdp_a_line(s, p);
 642             if (s->nb_streams > 0) {
 643                 rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
 644
 645                 if (rt->server_type == RTSP_SERVER_REAL)
 646                     ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p);
 647
 648                 if (rtsp_st->dynamic_handler &&
 649                     rtsp_st->dynamic_handler->parse_sdp_a_line)
 650                     rtsp_st->dynamic_handler->parse_sdp_a_line(s,
 651                         rtsp_st->stream_index,
 652                         rtsp_st->dynamic_protocol_context, buf);
 653             }
 654         }
 655         break;
 656     }
 657 }
 658
 659 int ff_sdp_parse(AVFormatContext *s, const char *content)
 660 {
 661     RTSPState *rt = s->priv_data;
 662     const char *p;
 663     int letter, i;
 664     /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
 665      * contain long SDP lines containing complete ASF Headers (several
 666      * kB) or arrays of MDPR (RM stream descriptor) headers plus
 667      * "rulebooks" describing their properties. Therefore, the SDP line
 668      * buffer is large.
 669      *
 670      * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
 671      * in rtpdec_xiph.c. */
 672     char buf[16384], *q;
 673     SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
 674
 675     p = content;
 676     for (;;) {
 677         p += strspn(p, SPACE_CHARS);
 678         letter = *p;
 679         if (letter == '\0')
 680             break;
 681         p++;
 682         if (*p != '=')
 683             goto next_line;
 684         p++;
 685         /* get the content */
 686         q = buf;
 687         while (*p != '\n' && *p != '\r' && *p != '\0') {
 688             if ((q - buf) < sizeof(buf) - 1)
 689                 *q++ = *p;
 690             p++;
 691         }
 692         *q = '\0';
 693         sdp_parse_line(s, s1, letter, buf);
 694     next_line:
 695         while (*p != '\n' && *p != '\0')
 696             p++;
 697         if (*p == '\n')
 698             p++;
 699     }
 700
 701     for (i = 0; i < s1->nb_default_include_source_addrs; i++)
 702         av_freep(&s1->default_include_source_addrs[i]);
 703     av_freep(&s1->default_include_source_addrs);
 704     for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
 705         av_freep(&s1->default_exclude_source_addrs[i]);
 706     av_freep(&s1->default_exclude_source_addrs);
 707
 708     rt->p = av_malloc_array(rt->nb_rtsp_streams + 1, sizeof(struct pollfd) * 2);
 709     if (!rt->p) return AVERROR(ENOMEM);
 710     return 0;
 711 }
 712 #endif /* CONFIG_RTPDEC */
 713
 714 void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
 715 {
 716     RTSPState *rt = s->priv_data;
 717     int i;
 718
 719     for (i = 0; i < rt->nb_rtsp_streams; i++) {
 720         RTSPStream *rtsp_st = rt->rtsp_streams[i];
 721         if (!rtsp_st)
 722             continue;
 723         if (rtsp_st->transport_priv) {
 724             if (s->oformat) {
 725                 AVFormatContext *rtpctx = rtsp_st->transport_priv;
 726                 av_write_trailer(rtpctx);
 727                 if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
 728                     if (CONFIG_RTSP_MUXER && rtpctx->pb && send_packets)
 729                         ff_rtsp_tcp_write_packet(s, rtsp_st);
 730                     ffio_free_dyn_buf(&rtpctx->pb);
 731                 } else {
 732                     avio_closep(&rtpctx->pb);
 733                 }
 734                 avformat_free_context(rtpctx);
 735             } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
 736                 ff_rdt_parse_close(rtsp_st->transport_priv);
 737             else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)
 738                 ff_rtp_parse_close(rtsp_st->transport_priv);
 739         }
 740         rtsp_st->transport_priv = NULL;
 741         if (rtsp_st->rtp_handle)
 742             ffurl_close(rtsp_st->rtp_handle);
 743         rtsp_st->rtp_handle = NULL;
 744     }
 745 }
 746
 747 /* close and free RTSP streams */
 748 void ff_rtsp_close_streams(AVFormatContext *s)
 749 {
 750     RTSPState *rt = s->priv_data;
 751     int i, j;
 752     RTSPStream *rtsp_st;
 753
 754     ff_rtsp_undo_setup(s, 0);
 755     for (i = 0; i < rt->nb_rtsp_streams; i++) {
 756         rtsp_st = rt->rtsp_streams[i];
 757         if (rtsp_st) {
 758             if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) {
 759                 if (rtsp_st->dynamic_handler->close)
 760                     rtsp_st->dynamic_handler->close(
 761                         rtsp_st->dynamic_protocol_context);
 762                 av_free(rtsp_st->dynamic_protocol_context);
 763             }
 764             for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)
 765                 av_freep(&rtsp_st->include_source_addrs[j]);
 766             av_freep(&rtsp_st->include_source_addrs);
 767             for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)
 768                 av_freep(&rtsp_st->exclude_source_addrs[j]);
 769             av_freep(&rtsp_st->exclude_source_addrs);
 770
 771             av_freep(&rtsp_st);
 772         }
 773     }
 774     av_freep(&rt->rtsp_streams);
 775     if (rt->asf_ctx) {
 776         avformat_close_input(&rt->asf_ctx);
 777     }
 778     if (CONFIG_RTPDEC && rt->ts)
 779         avpriv_mpegts_parse_close(rt->ts);
 780     av_freep(&rt->p);
 781     av_freep(&rt->recvbuf);
 782 }
 783
 784 int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
 785 {
 786     RTSPState *rt = s->priv_data;
 787     AVStream *st = NULL;
 788     int reordering_queue_size = rt->reordering_queue_size;
 789     if (reordering_queue_size < 0) {
 790         if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
 791             reordering_queue_size = 0;
 792         else
 793             reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
 794     }
 795
 796     /* open the RTP context */
 797     if (rtsp_st->stream_index >= 0)
 798         st = s->streams[rtsp_st->stream_index];
 799     if (!st)
 800         s->ctx_flags |= AVFMTCTX_NOHEADER;
 801
 802     if (CONFIG_RTSP_MUXER && s->oformat && st) {
 803         int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,
 804                                         s, st, rtsp_st->rtp_handle,
 805                                         RTSP_TCP_MAX_PACKET_SIZE,
 806                                         rtsp_st->stream_index);
 807         /* Ownership of rtp_handle is passed to the rtp mux context */
 808         rtsp_st->rtp_handle = NULL;
 809         if (ret < 0)
 810             return ret;
 811         st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
 812     } else if (rt->transport == RTSP_TRANSPORT_RAW) {
 813         return 0; // Don't need to open any parser here
 814     } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT && st)
 815         rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
 816                                             rtsp_st->dynamic_protocol_context,
 817                                             rtsp_st->dynamic_handler);
 818     else if (CONFIG_RTPDEC)
 819         rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
 820                                          rtsp_st->sdp_payload_type,
 821                                          reordering_queue_size);
 822
 823     if (!rtsp_st->transport_priv) {
 824          return AVERROR(ENOMEM);
 825     } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) {
 826         if (rtsp_st->dynamic_handler) {
 827             ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
 828                                               rtsp_st->dynamic_protocol_context,
 829                                               rtsp_st->dynamic_handler);
 830         }
 831         if (rtsp_st->crypto_suite[0])
 832             ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
 833                                     rtsp_st->crypto_suite,
 834                                     rtsp_st->crypto_params);
 835     }
 836
 837     return 0;
 838 }
 839
 840 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
 841 static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
 842 {
 843     const char *q;
 844     char *p;
 845     int v;
 846
 847     q = *pp;
 848     q += strspn(q, SPACE_CHARS);
 849     v = strtol(q, &p, 10);
 850     if (*p == '-') {
 851         p++;
 852         *min_ptr = v;
 853         v = strtol(p, &p, 10);
 854         *max_ptr = v;
 855     } else {
 856         *min_ptr = v;
 857         *max_ptr = v;
 858     }
 859     *pp = p;
 860 }
 861
 862 /* XXX: only one transport specification is parsed */
 863 static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
 864 {
 865     char transport_protocol[16];
 866     char profile[16];
 867     char lower_transport[16];
 868     char parameter[16];
 869     RTSPTransportField *th;
 870     char buf[256];
 871
 872     reply->nb_transports = 0;
 873
 874     for (;;) {
 875         p += strspn(p, SPACE_CHARS);
 876         if (*p == '\0')
 877             break;
 878
 879         th = &reply->transports[reply->nb_transports];
 880
 881         get_word_sep(transport_protocol, sizeof(transport_protocol),
 882                      "/", &p);
 883         if (!av_strcasecmp (transport_protocol, "rtp")) {
 884             get_word_sep(profile, sizeof(profile), "/;,", &p);
 885             lower_transport[0] = '\0';
 886             /* rtp/avp/<protocol> */
 887             if (*p == '/') {
 888                 get_word_sep(lower_transport, sizeof(lower_transport),
 889                              ";,", &p);
 890             }
 891             th->transport = RTSP_TRANSPORT_RTP;
 892         } else if (!av_strcasecmp (transport_protocol, "x-pn-tng") ||
 893                    !av_strcasecmp (transport_protocol, "x-real-rdt")) {
 894             /* x-pn-tng/<protocol> */
 895             get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
 896             profile[0] = '\0';
 897             th->transport = RTSP_TRANSPORT_RDT;
 898         } else if (!av_strcasecmp(transport_protocol, "raw")) {
 899             get_word_sep(profile, sizeof(profile), "/;,", &p);
 900             lower_transport[0] = '\0';
 901             /* raw/raw/<protocol> */
 902             if (*p == '/') {
 903                 get_word_sep(lower_transport, sizeof(lower_transport),
 904                              ";,", &p);
 905             }
 906             th->transport = RTSP_TRANSPORT_RAW;
 907         }
 908         if (!av_strcasecmp(lower_transport, "TCP"))
 909             th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
 910         else
 911             th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
 912
 913         if (*p == ';')
 914             p++;
 915         /* get each parameter */
 916         while (*p != '\0' && *p != ',') {
 917             get_word_sep(parameter, sizeof(parameter), "=;,", &p);
 918             if (!strcmp(parameter, "port")) {
 919                 if (*p == '=') {
 920                     p++;
 921                     rtsp_parse_range(&th->port_min, &th->port_max, &p);
 922                 }
 923             } else if (!strcmp(parameter, "client_port")) {
 924                 if (*p == '=') {
 925                     p++;
 926                     rtsp_parse_range(&th->client_port_min,
 927                                      &th->client_port_max, &p);
 928                 }
 929             } else if (!strcmp(parameter, "server_port")) {
 930                 if (*p == '=') {
 931                     p++;
 932                     rtsp_parse_range(&th->server_port_min,
 933                                      &th->server_port_max, &p);
 934                 }
 935             } else if (!strcmp(parameter, "interleaved")) {
 936                 if (*p == '=') {
 937                     p++;
 938                     rtsp_parse_range(&th->interleaved_min,
 939                                      &th->interleaved_max, &p);
 940                 }
 941             } else if (!strcmp(parameter, "multicast")) {
 942                 if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
 943                     th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
 944             } else if (!strcmp(parameter, "ttl")) {
 945                 if (*p == '=') {
 946                     char *end;
 947                     p++;
 948                     th->ttl = strtol(p, &end, 10);
 949                     p = end;
 950                 }
 951             } else if (!strcmp(parameter, "destination")) {
 952                 if (*p == '=') {
 953                     p++;
 954                     get_word_sep(buf, sizeof(buf), ";,", &p);
 955                     get_sockaddr(buf, &th->destination);
 956                 }
 957             } else if (!strcmp(parameter, "source")) {
 958                 if (*p == '=') {
 959                     p++;
 960                     get_word_sep(buf, sizeof(buf), ";,", &p);
 961                     av_strlcpy(th->source, buf, sizeof(th->source));
 962                 }
 963             } else if (!strcmp(parameter, "mode")) {
 964                 if (*p == '=') {
 965                     p++;
 966                     get_word_sep(buf, sizeof(buf), ";, ", &p);
 967                     if (!strcmp(buf, "record") ||
 968                         !strcmp(buf, "receive"))
 969                         th->mode_record = 1;
 970                 }
 971             }
 972
 973             while (*p != ';' && *p != '\0' && *p != ',')
 974                 p++;
 975             if (*p == ';')
 976                 p++;
 977         }
 978         if (*p == ',')
 979             p++;
 980
 981         reply->nb_transports++;
 982         if (reply->nb_transports >= RTSP_MAX_TRANSPORTS)
 983             break;
 984     }
 985 }
 986
 987 static void handle_rtp_info(RTSPState *rt, const char *url,
 988                             uint32_t seq, uint32_t rtptime)
 989 {
 990     int i;
 991     if (!rtptime || !url[0])
 992         return;
 993     if (rt->transport != RTSP_TRANSPORT_RTP)
 994         return;
 995     for (i = 0; i < rt->nb_rtsp_streams; i++) {
 996         RTSPStream *rtsp_st = rt->rtsp_streams[i];
 997         RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
 998         if (!rtpctx)
 999             continue;
1000         if (!strcmp(rtsp_st->control_url, url)) {
1001             rtpctx->base_timestamp = rtptime;
1002             break;
1003         }
1004     }
1005 }
1006
1007 static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
1008 {
1009     int read = 0;
1010     char key[20], value[1024], url[1024] = "";
1011     uint32_t seq = 0, rtptime = 0;
1012
1013     for (;;) {
1014         p += strspn(p, SPACE_CHARS);
1015         if (!*p)
1016             break;
1017         get_word_sep(key, sizeof(key), "=", &p);
1018         if (*p != '=')
1019             break;
1020         p++;
1021         get_word_sep(value, sizeof(value), ";, ", &p);
1022         read++;
1023         if (!strcmp(key, "url"))
1024             av_strlcpy(url, value, sizeof(url));
1025         else if (!strcmp(key, "seq"))
1026             seq = strtoul(value, NULL, 10);
1027         else if (!strcmp(key, "rtptime"))
1028             rtptime = strtoul(value, NULL, 10);
1029         if (*p == ',') {
1030             handle_rtp_info(rt, url, seq, rtptime);
1031             url[0] = '\0';
1032             seq = rtptime = 0;
1033             read = 0;
1034         }
1035         if (*p)
1036             p++;
1037     }
1038     if (read > 0)
1039         handle_rtp_info(rt, url, seq, rtptime);
1040 }
1041
1042 void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
1043                         RTSPState *rt, const char *method)
1044 {
1045     const char *p;
1046
1047     /* NOTE: we do case independent match for broken servers */
1048     p = buf;
1049     if (av_stristart(p, "Session:", &p)) {
1050         int t;
1051         get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
1052         if (av_stristart(p, ";timeout=", &p) &&
1053             (t = strtol(p, NULL, 10)) > 0) {
1054             reply->timeout = t;
1055         }
1056     } else if (av_stristart(p, "Content-Length:", &p)) {
1057         reply->content_length = strtol(p, NULL, 10);
1058     } else if (av_stristart(p, "Transport:", &p)) {
1059         rtsp_parse_transport(reply, p);
1060     } else if (av_stristart(p, "CSeq:", &p)) {
1061         reply->seq = strtol(p, NULL, 10);
1062     } else if (av_stristart(p, "Range:", &p)) {
1063         rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
1064     } else if (av_stristart(p, "RealChallenge1:", &p)) {
1065         p += strspn(p, SPACE_CHARS);
1066         av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
1067     } else if (av_stristart(p, "Server:", &p)) {
1068         p += strspn(p, SPACE_CHARS);
1069         av_strlcpy(reply->server, p, sizeof(reply->server));
1070     } else if (av_stristart(p, "Notice:", &p) ||
1071                av_stristart(p, "X-Notice:", &p)) {
1072         reply->notice = strtol(p, NULL, 10);
1073     } else if (av_stristart(p, "Location:", &p)) {
1074         p += strspn(p, SPACE_CHARS);
1075         av_strlcpy(reply->location, p , sizeof(reply->location));
1076     } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
1077         p += strspn(p, SPACE_CHARS);
1078         ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
1079     } else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
1080         p += strspn(p, SPACE_CHARS);
1081         ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
1082     } else if (av_stristart(p, "Content-Base:", &p) && rt) {
1083         p += strspn(p, SPACE_CHARS);
1084         if (method && !strcmp(method, "DESCRIBE"))
1085             av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
1086     } else if (av_stristart(p, "RTP-Info:", &p) && rt) {
1087         p += strspn(p, SPACE_CHARS);
1088         if (method && !strcmp(method, "PLAY"))
1089             rtsp_parse_rtp_info(rt, p);
1090     } else if (av_stristart(p, "Public:", &p) && rt) {
1091         if (strstr(p, "GET_PARAMETER") &&
1092             method && !strcmp(method, "OPTIONS"))
1093             rt->get_parameter_supported = 1;
1094     } else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
1095         p += strspn(p, SPACE_CHARS);
1096         rt->accept_dynamic_rate = atoi(p);
1097     } else if (av_stristart(p, "Content-Type:", &p)) {
1098         p += strspn(p, SPACE_CHARS);
1099         av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
1100     }
1101 }
1102
1103 /* skip a RTP/TCP interleaved packet */
1104 void ff_rtsp_skip_packet(AVFormatContext *s)
1105 {
1106     RTSPState *rt = s->priv_data;
1107     int ret, len, len1;
1108     uint8_t buf[1024];
1109
1110     ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
1111     if (ret != 3)
1112         return;
1113     len = AV_RB16(buf + 1);
1114
1115     av_log(s, AV_LOG_TRACE, "skipping RTP packet len=%d\n", len);
1116
1117     /* skip payload */
1118     while (len > 0) {
1119         len1 = len;
1120         if (len1 > sizeof(buf))
1121             len1 = sizeof(buf);
1122         ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);
1123         if (ret != len1)
1124             return;
1125         len -= len1;
1126     }
1127 }
1128
1129 int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
1130                        unsigned char **content_ptr,
1131                        int return_on_interleaved_data, const char *method)
1132 {
1133     RTSPState *rt = s->priv_data;
1134     char buf[4096], buf1[1024], *q;
1135     unsigned char ch;
1136     const char *p;
1137     int ret, content_length, line_count = 0, request = 0;
1138     unsigned char *content = NULL;
1139
1140 start:
1141     line_count = 0;
1142     request = 0;
1143     content = NULL;
1144     memset(reply, 0, sizeof(*reply));
1145
1146     /* parse reply (XXX: use buffers) */
1147     rt->last_reply[0] = '\0';
1148     for (;;) {
1149         q = buf;
1150         for (;;) {
1151             ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
1152             av_log(s, AV_LOG_TRACE, "ret=%d c=%02x [%c]\n", ret, ch, ch);
1153             if (ret != 1)
1154                 return AVERROR_EOF;
1155             if (ch == '\n')
1156                 break;
1157             if (ch == '$') {
1158                 /* XXX: only parse it if first char on line ? */
1159                 if (return_on_interleaved_data) {
1160                     return 1;
1161                 } else
1162                     ff_rtsp_skip_packet(s);
1163             } else if (ch != '\r') {
1164                 if ((q - buf) < sizeof(buf) - 1)
1165                     *q++ = ch;
1166             }
1167         }
1168         *q = '\0';
1169
1170         av_log(s, AV_LOG_TRACE, "line='%s'\n", buf);
1171
1172         /* test if last line */
1173         if (buf[0] == '\0')
1174             break;
1175         p = buf;
1176         if (line_count == 0) {
1177             /* get reply code */
1178             get_word(buf1, sizeof(buf1), &p);
1179             if (!strncmp(buf1, "RTSP/", 5)) {
1180                 get_word(buf1, sizeof(buf1), &p);
1181                 reply->status_code = atoi(buf1);
1182                 av_strlcpy(reply->reason, p, sizeof(reply->reason));
1183             } else {
1184                 av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
1185                 get_word(buf1, sizeof(buf1), &p); // object
1186                 request = 1;
1187             }
1188         } else {
1189             ff_rtsp_parse_line(reply, p, rt, method);
1190             av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
1191             av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
1192         }
1193         line_count++;
1194     }
1195
1196     if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
1197         av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
1198
1199     content_length = reply->content_length;
1200     if (content_length > 0) {
1201         /* leave some room for a trailing '\0' (useful for simple parsing) */
1202         content = av_malloc(content_length + 1);
1203         if (!content)
1204             return AVERROR(ENOMEM);
1205         ffurl_read_complete(rt->rtsp_hd, content, content_length);
1206         content[content_length] = '\0';
1207     }
1208     if (content_ptr)
1209         *content_ptr = content;
1210     else
1211         av_freep(&content);
1212
1213     if (request) {
1214         char buf[1024];
1215         char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1216         const char* ptr = buf;
1217
1218         if (!strcmp(reply->reason, "OPTIONS")) {
1219             snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
1220             if (reply->seq)
1221                 av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
1222             if (reply->session_id[0])
1223                 av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
1224                                               reply->session_id);
1225         } else {
1226             snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
1227         }
1228         av_strlcat(buf, "\r\n", sizeof(buf));
1229
1230         if (rt->control_transport == RTSP_MODE_TUNNEL) {
1231             av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1232             ptr = base64buf;
1233         }
1234         ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
1235
1236         rt->last_cmd_time = av_gettime_relative();
1237         /* Even if the request from the server had data, it is not the data
1238          * that the caller wants or expects. The memory could also be leaked
1239          * if the actual following reply has content data. */
1240         if (content_ptr)
1241             av_freep(content_ptr);
1242         /* If method is set, this is called from ff_rtsp_send_cmd,
1243          * where a reply to exactly this request is awaited. For
1244          * callers from within packet receiving, we just want to
1245          * return to the caller and go back to receiving packets. */
1246         if (method)
1247             goto start;
1248         return 0;
1249     }
1250
1251     if (rt->seq != reply->seq) {
1252         av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
1253             rt->seq, reply->seq);
1254     }
1255
1256     /* EOS */
1257     if (reply->notice == 2101 /* End-of-Stream Reached */      ||
1258         reply->notice == 2104 /* Start-of-Stream Reached */    ||
1259         reply->notice == 2306 /* Continuous Feed Terminated */) {
1260         rt->state = RTSP_STATE_IDLE;
1261     } else if (reply->notice >= 4400 && reply->notice < 5500) {
1262         return AVERROR(EIO); /* data or server error */
1263     } else if (reply->notice == 2401 /* Ticket Expired */ ||
1264              (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
1265         return AVERROR(EPERM);
1266
1267     return 0;
1268 }
1269
1270 /**
1271  * Send a command to the RTSP server without waiting for the reply.
1272  *
1273  * @param s RTSP (de)muxer context
1274  * @param method the method for the request
1275  * @param url the target url for the request
1276  * @param headers extra header lines to include in the request
1277  * @param send_content if non-null, the data to send as request body content
1278  * @param send_content_length the length of the send_content data, or 0 if
1279  *                            send_content is null
1280  *
1281  * @return zero if success, nonzero otherwise
1282  */
1283 static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
1284                                             const char *method, const char *url,
1285                                             const char *headers,
1286                                             const unsigned char *send_content,
1287                                             int send_content_length)
1288 {
1289     RTSPState *rt = s->priv_data;
1290     char buf[4096], *out_buf;
1291     char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1292
1293     /* Add in RTSP headers */
1294     out_buf = buf;
1295     rt->seq++;
1296     snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
1297     if (headers)
1298         av_strlcat(buf, headers, sizeof(buf));
1299     av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
1300     av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n",  rt->user_agent);
1301     if (rt->session_id[0] != '\0' && (!headers ||
1302         !strstr(headers, "\nIf-Match:"))) {
1303         av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
1304     }
1305     if (rt->auth[0]) {
1306         char *str = ff_http_auth_create_response(&rt->auth_state,
1307                                                  rt->auth, url, method);
1308         if (str)
1309             av_strlcat(buf, str, sizeof(buf));
1310         av_free(str);
1311     }
1312     if (send_content_length > 0 && send_content)
1313         av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1314     av_strlcat(buf, "\r\n", sizeof(buf));
1315
1316     /* base64 encode rtsp if tunneling */
1317     if (rt->control_transport == RTSP_MODE_TUNNEL) {
1318         av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1319         out_buf = base64buf;
1320     }
1321
1322     av_log(s, AV_LOG_TRACE, "Sending:\n%s--\n", buf);
1323
1324     ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
1325     if (send_content_length > 0 && send_content) {
1326         if (rt->control_transport == RTSP_MODE_TUNNEL) {
1327             av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
1328                                     "with content data not supported\n");
1329             return AVERROR_PATCHWELCOME;
1330         }
1331         ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
1332     }
1333     rt->last_cmd_time = av_gettime_relative();
1334
1335     return 0;
1336 }
1337
1338 int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1339                            const char *url, const char *headers)
1340 {
1341     return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1342 }
1343
1344 int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1345                      const char *headers, RTSPMessageHeader *reply,
1346                      unsigned char **content_ptr)
1347 {
1348     return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1349                                          content_ptr, NULL, 0);
1350 }
1351
1352 int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1353                                   const char *method, const char *url,
1354                                   const char *header,
1355                                   RTSPMessageHeader *reply,
1356                                   unsigned char **content_ptr,
1357                                   const unsigned char *send_content,
1358                                   int send_content_length)
1359 {
1360     RTSPState *rt = s->priv_data;
1361     HTTPAuthType cur_auth_type;
1362     int ret, attempts = 0;
1363
1364 retry:
1365     cur_auth_type = rt->auth_state.auth_type;
1366     if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1367                                                 send_content,
1368                                                 send_content_length)))
1369         return ret;
1370
1371     if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1372         return ret;
1373     attempts++;
1374
1375     if (reply->status_code == 401 &&
1376         (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
1377         rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
1378         goto retry;
1379
1380     if (reply->status_code > 400){
1381         av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
1382                method,
1383                reply->status_code,
1384                reply->reason);
1385         av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1386     }
1387
1388     return 0;
1389 }
1390
1391 int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1392                               int lower_transport, const char *real_challenge)
1393 {
1394     RTSPState *rt = s->priv_data;
1395     int rtx = 0, j, i, err, interleave = 0, port_off;
1396     RTSPStream *rtsp_st;
1397     RTSPMessageHeader reply1, *reply = &reply1;
1398     char cmd[2048];
1399     const char *trans_pref;
1400
1401     if (rt->transport == RTSP_TRANSPORT_RDT)
1402         trans_pref = "x-pn-tng";
1403     else if (rt->transport == RTSP_TRANSPORT_RAW)
1404         trans_pref = "RAW/RAW";
1405     else
1406         trans_pref = "RTP/AVP";
1407
1408     /* default timeout: 1 minute */
1409     rt->timeout = 60;
1410
1411     /* Choose a random starting offset within the first half of the
1412      * port range, to allow for a number of ports to try even if the offset
1413      * happens to be at the end of the random range. */
1414     port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
1415     /* even random offset */
1416     port_off -= port_off & 0x01;
1417
1418     for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1419         char transport[2048];
1420
1421         /*
1422          * WMS serves all UDP data over a single connection, the RTX, which
1423          * isn't necessarily the first in the SDP but has to be the first
1424          * to be set up, else the second/third SETUP will fail with a 461.
1425          */
1426         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1427              rt->server_type == RTSP_SERVER_WMS) {
1428             if (i == 0) {
1429                 /* rtx first */
1430                 for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1431                     int len = strlen(rt->rtsp_streams[rtx]->control_url);
1432                     if (len >= 4 &&
1433                         !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1434                                 "/rtx"))
1435                         break;
1436                 }
1437                 if (rtx == rt->nb_rtsp_streams)
1438                     return -1; /* no RTX found */
1439                 rtsp_st = rt->rtsp_streams[rtx];
1440             } else
1441                 rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1442         } else
1443             rtsp_st = rt->rtsp_streams[i];
1444
1445         /* RTP/UDP */
1446         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1447             char buf[256];
1448
1449             if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1450                 port = reply->transports[0].client_port_min;
1451                 goto have_port;
1452             }
1453
1454             /* first try in specified port range */
1455             while (j <= rt->rtp_port_max) {
1456                 AVDictionary *opts = map_to_opts(rt);
1457
1458                 ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1459                             "?localport=%d", j);
1460                 /* we will use two ports per rtp stream (rtp and rtcp) */
1461                 j += 2;
1462                 err = ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
1463                                  &s->interrupt_callback, &opts);
1464
1465                 av_dict_free(&opts);
1466
1467                 if (!err)
1468                     goto rtp_opened;
1469             }
1470             av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1471             err = AVERROR(EIO);
1472             goto fail;
1473
1474         rtp_opened:
1475             port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1476         have_port:
1477             snprintf(transport, sizeof(transport) - 1,
1478                      "%s/UDP;", trans_pref);
1479             if (rt->server_type != RTSP_SERVER_REAL)
1480                 av_strlcat(transport, "unicast;", sizeof(transport));
1481             av_strlcatf(transport, sizeof(transport),
1482                      "client_port=%d", port);
1483             if (rt->transport == RTSP_TRANSPORT_RTP &&
1484                 !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1485                 av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1486         }
1487
1488         /* RTP/TCP */
1489         else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1490             /* For WMS streams, the application streams are only used for
1491              * UDP. When trying to set it up for TCP streams, the server
1492              * will return an error. Therefore, we skip those streams. */
1493             if (rt->server_type == RTSP_SERVER_WMS &&
1494                 (rtsp_st->stream_index < 0 ||
1495                  s->streams[rtsp_st->stream_index]->codec->codec_type ==
1496                     AVMEDIA_TYPE_DATA))
1497                 continue;
1498             snprintf(transport, sizeof(transport) - 1,
1499                      "%s/TCP;", trans_pref);
1500             if (rt->transport != RTSP_TRANSPORT_RDT)
1501                 av_strlcat(transport, "unicast;", sizeof(transport));
1502             av_strlcatf(transport, sizeof(transport),
1503                         "interleaved=%d-%d",
1504                         interleave, interleave + 1);
1505             interleave += 2;
1506         }
1507
1508         else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1509             snprintf(transport, sizeof(transport) - 1,
1510                      "%s/UDP;multicast", trans_pref);
1511         }
1512         if (s->oformat) {
1513             av_strlcat(transport, ";mode=record", sizeof(transport));
1514         } else if (rt->server_type == RTSP_SERVER_REAL ||
1515                    rt->server_type == RTSP_SERVER_WMS)
1516             av_strlcat(transport, ";mode=play", sizeof(transport));
1517         snprintf(cmd, sizeof(cmd),
1518                  "Transport: %s\r\n",
1519                  transport);
1520         if (rt->accept_dynamic_rate)
1521             av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
1522         if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1523             char real_res[41], real_csum[9];
1524             ff_rdt_calc_response_and_checksum(real_res, real_csum,
1525                                               real_challenge);
1526             av_strlcatf(cmd, sizeof(cmd),
1527                         "If-Match: %s\r\n"
1528                         "RealChallenge2: %s, sd=%s\r\n",
1529                         rt->session_id, real_res, real_csum);
1530         }
1531         ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1532         if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1533             err = 1;
1534             goto fail;
1535         } else if (reply->status_code != RTSP_STATUS_OK ||
1536                    reply->nb_transports != 1) {
1537             err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1538             goto fail;
1539         }
1540
1541         /* XXX: same protocol for all streams is required */
1542         if (i > 0) {
1543             if (reply->transports[0].lower_transport != rt->lower_transport ||
1544                 reply->transports[0].transport != rt->transport) {
1545                 err = AVERROR_INVALIDDATA;
1546                 goto fail;
1547             }
1548         } else {
1549             rt->lower_transport = reply->transports[0].lower_transport;
1550             rt->transport = reply->transports[0].transport;
1551         }
1552
1553         /* Fail if the server responded with another lower transport mode
1554          * than what we requested. */
1555         if (reply->transports[0].lower_transport != lower_transport) {
1556             av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1557             err = AVERROR_INVALIDDATA;
1558             goto fail;
1559         }
1560
1561         switch(reply->transports[0].lower_transport) {
1562         case RTSP_LOWER_TRANSPORT_TCP:
1563             rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1564             rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1565             break;
1566
1567         case RTSP_LOWER_TRANSPORT_UDP: {
1568             char url[1024], options[30] = "";
1569             const char *peer = host;
1570
1571             if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
1572                 av_strlcpy(options, "?connect=1", sizeof(options));
1573             /* Use source address if specified */
1574             if (reply->transports[0].source[0])
1575                 peer = reply->transports[0].source;
1576             ff_url_join(url, sizeof(url), "rtp", NULL, peer,
1577                         reply->transports[0].server_port_min, "%s", options);
1578             if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1579                 ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1580                 err = AVERROR_INVALIDDATA;
1581                 goto fail;
1582             }
1583             break;
1584         }
1585         case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1586             char url[1024], namebuf[50], optbuf[20] = "";
1587             struct sockaddr_storage addr;
1588             int port, ttl;
1589
1590             if (reply->transports[0].destination.ss_family) {
1591                 addr      = reply->transports[0].destination;
1592                 port      = reply->transports[0].port_min;
1593                 ttl       = reply->transports[0].ttl;
1594             } else {
1595                 addr      = rtsp_st->sdp_ip;
1596                 port      = rtsp_st->sdp_port;
1597                 ttl       = rtsp_st->sdp_ttl;
1598             }
1599             if (ttl > 0)
1600                 snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1601             getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1602                         namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1603             ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1604                         port, "%s", optbuf);
1605             if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
1606                            &s->interrupt_callback, NULL) < 0) {
1607                 err = AVERROR_INVALIDDATA;
1608                 goto fail;
1609             }
1610             break;
1611         }
1612         }
1613
1614         if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
1615             goto fail;
1616     }
1617
1618     if (rt->nb_rtsp_streams && reply->timeout > 0)
1619         rt->timeout = reply->timeout;
1620
1621     if (rt->server_type == RTSP_SERVER_REAL)
1622         rt->need_subscription = 1;
1623
1624     return 0;
1625
1626 fail:
1627     ff_rtsp_undo_setup(s, 0);
1628     return err;
1629 }
1630
1631 void ff_rtsp_close_connections(AVFormatContext *s)
1632 {
1633     RTSPState *rt = s->priv_data;
1634     if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out);
1635     ffurl_close(rt->rtsp_hd);
1636     rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1637 }
1638
1639 int ff_rtsp_connect(AVFormatContext *s)
1640 {
1641     RTSPState *rt = s->priv_data;
1642     char proto[128], host[1024], path[1024];
1643     char tcpname[1024], cmd[2048], auth[128];
1644     const char *lower_rtsp_proto = "tcp";
1645     int port, err, tcp_fd;
1646     RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1647     int lower_transport_mask = 0;
1648     int default_port = RTSP_DEFAULT_PORT;
1649     char real_challenge[64] = "";
1650     struct sockaddr_storage peer;
1651     socklen_t peer_len = sizeof(peer);
1652
1653     if (rt->rtp_port_max < rt->rtp_port_min) {
1654         av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1655                                 "than min port %d\n", rt->rtp_port_max,
1656                                                       rt->rtp_port_min);
1657         return AVERROR(EINVAL);
1658     }
1659
1660     if (!ff_network_init())
1661         return AVERROR(EIO);
1662
1663     if (s->max_delay < 0) /* Not set by the caller */
1664         s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
1665
1666     rt->control_transport = RTSP_MODE_PLAIN;
1667     if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) {
1668         rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1669         rt->control_transport = RTSP_MODE_TUNNEL;
1670     }
1671     /* Only pass through valid flags from here */
1672     rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1673
1674 redirect:
1675     /* extract hostname and port */
1676     av_url_split(proto, sizeof(proto), auth, sizeof(auth),
1677                  host, sizeof(host), &port, path, sizeof(path), s->filename);
1678
1679     if (!strcmp(proto, "rtsps")) {
1680         lower_rtsp_proto         = "tls";
1681         default_port             = RTSPS_DEFAULT_PORT;
1682         rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1683     }
1684
1685     if (*auth) {
1686         av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1687     }
1688     if (port < 0)
1689         port = default_port;
1690
1691     lower_transport_mask = rt->lower_transport_mask;
1692
1693     if (!lower_transport_mask)
1694         lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1695
1696     if (s->oformat) {
1697         /* Only UDP or TCP - UDP multicast isn't supported. */
1698         lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1699                                 (1 << RTSP_LOWER_TRANSPORT_TCP);
1700         if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1701             av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1702                                     "only UDP and TCP are supported for output.\n");
1703             err = AVERROR(EINVAL);
1704             goto fail;
1705         }
1706     }
1707
1708     /* Construct the URI used in request; this is similar to s->filename,
1709      * but with authentication credentials removed and RTSP specific options
1710      * stripped out. */
1711     ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
1712                 host, port, "%s", path);
1713
1714     if (rt->control_transport == RTSP_MODE_TUNNEL) {
1715         /* set up initial handshake for tunneling */
1716         char httpname[1024];
1717         char sessioncookie[17];
1718         char headers[1024];
1719
1720         ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1721         snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1722                  av_get_random_seed(), av_get_random_seed());
1723
1724         /* GET requests */
1725         if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
1726                         &s->interrupt_callback) < 0) {
1727             err = AVERROR(EIO);
1728             goto fail;
1729         }
1730
1731         /* generate GET headers */
1732         snprintf(headers, sizeof(headers),
1733                  "x-sessioncookie: %s\r\n"
1734                  "Accept: application/x-rtsp-tunnelled\r\n"
1735                  "Pragma: no-cache\r\n"
1736                  "Cache-Control: no-cache\r\n",
1737                  sessioncookie);
1738         av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
1739
1740         /* complete the connection */
1741         if (ffurl_connect(rt->rtsp_hd, NULL)) {
1742             err = AVERROR(EIO);
1743             goto fail;
1744         }
1745
1746         /* POST requests */
1747         if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
1748                         &s->interrupt_callback) < 0 ) {
1749             err = AVERROR(EIO);
1750             goto fail;
1751         }
1752
1753         /* generate POST headers */
1754         snprintf(headers, sizeof(headers),
1755                  "x-sessioncookie: %s\r\n"
1756                  "Content-Type: application/x-rtsp-tunnelled\r\n"
1757                  "Pragma: no-cache\r\n"
1758                  "Cache-Control: no-cache\r\n"
1759                  "Content-Length: 32767\r\n"
1760                  "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1761                  sessioncookie);
1762         av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
1763         av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
1764
1765         /* Initialize the authentication state for the POST session. The HTTP
1766          * protocol implementation doesn't properly handle multi-pass
1767          * authentication for POST requests, since it would require one of
1768          * the following:
1769          * - implementing Expect: 100-continue, which many HTTP servers
1770          *   don't support anyway, even less the RTSP servers that do HTTP
1771          *   tunneling
1772          * - sending the whole POST data until getting a 401 reply specifying
1773          *   what authentication method to use, then resending all that data
1774          * - waiting for potential 401 replies directly after sending the
1775          *   POST header (waiting for some unspecified time)
1776          * Therefore, we copy the full auth state, which works for both basic
1777          * and digest. (For digest, we would have to synchronize the nonce
1778          * count variable between the two sessions, if we'd do more requests
1779          * with the original session, though.)
1780          */
1781         ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1782
1783         /* complete the connection */
1784         if (ffurl_connect(rt->rtsp_hd_out, NULL)) {
1785             err = AVERROR(EIO);
1786             goto fail;
1787         }
1788     } else {
1789         int ret;
1790         /* open the tcp connection */
1791         ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
1792                     host, port,
1793                     "?timeout=%d", rt->stimeout);
1794         if ((ret = ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
1795                        &s->interrupt_callback, NULL)) < 0) {
1796             err = ret;
1797             goto fail;
1798         }
1799         rt->rtsp_hd_out = rt->rtsp_hd;
1800     }
1801     rt->seq = 0;
1802
1803     tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1804     if (tcp_fd < 0) {
1805         err = tcp_fd;
1806         goto fail;
1807     }
1808     if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1809         getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1810                     NULL, 0, NI_NUMERICHOST);
1811     }
1812
1813     /* request options supported by the server; this also detects server
1814      * type */
1815     for (rt->server_type = RTSP_SERVER_RTP;;) {
1816         cmd[0] = 0;
1817         if (rt->server_type == RTSP_SERVER_REAL)
1818             av_strlcat(cmd,
1819                        /*
1820                         * The following entries are required for proper
1821                         * streaming from a Realmedia server. They are
1822                         * interdependent in some way although we currently
1823                         * don't quite understand how. Values were copied
1824                         * from mplayer SVN r23589.
1825                         *   ClientChallenge is a 16-byte ID in hex
1826                         *   CompanyID is a 16-byte ID in base64
1827                         */
1828                        "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1829                        "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1830                        "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1831                        "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1832                        sizeof(cmd));
1833         ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1834         if (reply->status_code != RTSP_STATUS_OK) {
1835             err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1836             goto fail;
1837         }
1838
1839         /* detect server type if not standard-compliant RTP */
1840         if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1841             rt->server_type = RTSP_SERVER_REAL;
1842             continue;
1843         } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
1844             rt->server_type = RTSP_SERVER_WMS;
1845         } else if (rt->server_type == RTSP_SERVER_REAL)
1846             strcpy(real_challenge, reply->real_challenge);
1847         break;
1848     }
1849
1850     if (CONFIG_RTSP_DEMUXER && s->iformat)
1851         err = ff_rtsp_setup_input_streams(s, reply);
1852     else if (CONFIG_RTSP_MUXER)
1853         err = ff_rtsp_setup_output_streams(s, host);
1854     else
1855         av_assert0(0);
1856     if (err)
1857         goto fail;
1858
1859     do {
1860         int lower_transport = ff_log2_tab[lower_transport_mask &
1861                                   ~(lower_transport_mask - 1)];
1862
1863         if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
1864                 && (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
1865             lower_transport = RTSP_LOWER_TRANSPORT_TCP;
1866
1867         err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
1868                                  rt->server_type == RTSP_SERVER_REAL ?
1869                                      real_challenge : NULL);
1870         if (err < 0)
1871             goto fail;
1872         lower_transport_mask &= ~(1 << lower_transport);
1873         if (lower_transport_mask == 0 && err == 1) {
1874             err = AVERROR(EPROTONOSUPPORT);
1875             goto fail;
1876         }
1877     } while (err);
1878
1879     rt->lower_transport_mask = lower_transport_mask;
1880     av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
1881     rt->state = RTSP_STATE_IDLE;
1882     rt->seek_timestamp = 0; /* default is to start stream at position zero */
1883     return 0;
1884  fail:
1885     ff_rtsp_close_streams(s);
1886     ff_rtsp_close_connections(s);
1887     if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1888         av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1889         rt->session_id[0] = '\0';
1890         av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1891                reply->status_code,
1892                s->filename);
1893         goto redirect;
1894     }
1895     ff_network_close();
1896     return err;
1897 }
1898 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1899
1900 #if CONFIG_RTPDEC
1901 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1902                            uint8_t *buf, int buf_size, int64_t wait_end)
1903 {
1904     RTSPState *rt = s->priv_data;
1905     RTSPStream *rtsp_st;
1906     int n, i, ret, tcp_fd, timeout_cnt = 0;
1907     int max_p = 0;
1908     struct pollfd *p = rt->p;
1909     int *fds = NULL, fdsnum, fdsidx;
1910
1911     for (;;) {
1912         if (ff_check_interrupt(&s->interrupt_callback))
1913             return AVERROR_EXIT;
1914         if (wait_end && wait_end - av_gettime_relative() < 0)
1915             return AVERROR(EAGAIN);
1916         max_p = 0;
1917         if (rt->rtsp_hd) {
1918             tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1919             p[max_p].fd = tcp_fd;
1920             p[max_p++].events = POLLIN;
1921         } else {
1922             tcp_fd = -1;
1923         }
1924         for (i = 0; i < rt->nb_rtsp_streams; i++) {
1925             rtsp_st = rt->rtsp_streams[i];
1926             if (rtsp_st->rtp_handle) {
1927                 if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
1928                                                       &fds, &fdsnum)) {
1929                     av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
1930                     return ret;
1931                 }
1932                 if (fdsnum != 2) {
1933                     av_log(s, AV_LOG_ERROR,
1934                            "Number of fds %d not supported\n", fdsnum);
1935                     return AVERROR_INVALIDDATA;
1936                 }
1937                 for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
1938                     p[max_p].fd       = fds[fdsidx];
1939                     p[max_p++].events = POLLIN;
1940                 }
1941                 av_freep(&fds);
1942             }
1943         }
1944         n = poll(p, max_p, POLL_TIMEOUT_MS);
1945         if (n > 0) {
1946             int j = 1 - (tcp_fd == -1);
1947             timeout_cnt = 0;
1948             for (i = 0; i < rt->nb_rtsp_streams; i++) {
1949                 rtsp_st = rt->rtsp_streams[i];
1950                 if (rtsp_st->rtp_handle) {
1951                     if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1952                         ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
1953                         if (ret > 0) {
1954                             *prtsp_st = rtsp_st;
1955                             return ret;
1956                         }
1957                     }
1958                     j+=2;
1959                 }
1960             }
1961 #if CONFIG_RTSP_DEMUXER
1962             if (tcp_fd != -1 && p[0].revents & POLLIN) {
1963                 if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
1964                     if (rt->state == RTSP_STATE_STREAMING) {
1965                         if (!ff_rtsp_parse_streaming_commands(s))
1966                             return AVERROR_EOF;
1967                         else
1968                             av_log(s, AV_LOG_WARNING,
1969                                    "Unable to answer to TEARDOWN\n");
1970                     } else
1971                         return 0;
1972                 } else {
1973                     RTSPMessageHeader reply;
1974                     ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
1975                     if (ret < 0)
1976                         return ret;
1977                     /* XXX: parse message */
1978                     if (rt->state != RTSP_STATE_STREAMING)
1979                         return 0;
1980                 }
1981             }
1982 #endif
1983         } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1984             return AVERROR(ETIMEDOUT);
1985         } else if (n < 0 && errno != EINTR)
1986             return AVERROR(errno);
1987     }
1988 }
1989
1990 static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
1991                        const uint8_t *buf, int len)
1992 {
1993     RTSPState *rt = s->priv_data;
1994     int i;
1995     if (len < 0)
1996         return len;
1997     if (rt->nb_rtsp_streams == 1) {
1998         *rtsp_st = rt->rtsp_streams[0];
1999         return len;
2000     }
2001     if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
2002         if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
2003             int no_ssrc = 0;
2004             for (i = 0; i < rt->nb_rtsp_streams; i++) {
2005                 RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2006                 if (!rtpctx)
2007                     continue;
2008                 if (rtpctx->ssrc == AV_RB32(&buf[4])) {
2009                     *rtsp_st = rt->rtsp_streams[i];
2010                     return len;
2011                 }
2012                 if (!rtpctx->ssrc)
2013                     no_ssrc = 1;
2014             }
2015             if (no_ssrc) {
2016                 av_log(s, AV_LOG_WARNING,
2017                        "Unable to pick stream for packet - SSRC not known for "
2018                        "all streams\n");
2019                 return AVERROR(EAGAIN);
2020             }
2021         } else {
2022             for (i = 0; i < rt->nb_rtsp_streams; i++) {
2023                 if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
2024                     *rtsp_st = rt->rtsp_streams[i];
2025                     return len;
2026                 }
2027             }
2028         }
2029     }
2030     av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
2031     return AVERROR(EAGAIN);
2032 }
2033
2034 int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
2035 {
2036     RTSPState *rt = s->priv_data;
2037     int ret, len;
2038     RTSPStream *rtsp_st, *first_queue_st = NULL;
2039     int64_t wait_end = 0;
2040
2041     if (rt->nb_byes == rt->nb_rtsp_streams)
2042         return AVERROR_EOF;
2043
2044     /* get next frames from the same RTP packet */
2045     if (rt->cur_transport_priv) {
2046         if (rt->transport == RTSP_TRANSPORT_RDT) {
2047             ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2048         } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2049             ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2050         } else if (CONFIG_RTPDEC && rt->ts) {
2051             ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
2052             if (ret >= 0) {
2053                 rt->recvbuf_pos += ret;
2054                 ret = rt->recvbuf_pos < rt->recvbuf_len;
2055             }
2056         } else
2057             ret = -1;
2058         if (ret == 0) {
2059             rt->cur_transport_priv = NULL;
2060             return 0;
2061         } else if (ret == 1) {
2062             return 0;
2063         } else
2064             rt->cur_transport_priv = NULL;
2065     }
2066
2067 redo:
2068     if (rt->transport == RTSP_TRANSPORT_RTP) {
2069         int i;
2070         int64_t first_queue_time = 0;
2071         for (i = 0; i < rt->nb_rtsp_streams; i++) {
2072             RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2073             int64_t queue_time;
2074             if (!rtpctx)
2075                 continue;
2076             queue_time = ff_rtp_queued_packet_time(rtpctx);
2077             if (queue_time && (queue_time - first_queue_time < 0 ||
2078                                !first_queue_time)) {
2079                 first_queue_time = queue_time;
2080                 first_queue_st   = rt->rtsp_streams[i];
2081             }
2082         }
2083         if (first_queue_time) {
2084             wait_end = first_queue_time + s->max_delay;
2085         } else {
2086             wait_end = 0;
2087             first_queue_st = NULL;
2088         }
2089     }
2090
2091     /* read next RTP packet */
2092     if (!rt->recvbuf) {
2093         rt->recvbuf = av_malloc(RECVBUF_SIZE);
2094         if (!rt->recvbuf)
2095             return AVERROR(ENOMEM);
2096     }
2097
2098     switch(rt->lower_transport) {
2099     default:
2100 #if CONFIG_RTSP_DEMUXER
2101     case RTSP_LOWER_TRANSPORT_TCP:
2102         len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
2103         break;
2104 #endif
2105     case RTSP_LOWER_TRANSPORT_UDP:
2106     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
2107         len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2108         if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2109             ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);
2110         break;
2111     case RTSP_LOWER_TRANSPORT_CUSTOM:
2112         if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2113             wait_end && wait_end < av_gettime_relative())
2114             len = AVERROR(EAGAIN);
2115         else
2116             len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
2117         len = pick_stream(s, &rtsp_st, rt->recvbuf, len);
2118         if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2119             ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len);
2120         break;
2121     }
2122     if (len == AVERROR(EAGAIN) && first_queue_st &&
2123         rt->transport == RTSP_TRANSPORT_RTP) {
2124         rtsp_st = first_queue_st;
2125         ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
2126         goto end;
2127     }
2128     if (len < 0)
2129         return len;
2130     if (len == 0)
2131         return AVERROR_EOF;
2132     if (rt->transport == RTSP_TRANSPORT_RDT) {
2133         ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2134     } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2135         ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2136         if (rtsp_st->feedback) {
2137             AVIOContext *pb = NULL;
2138             if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)
2139                 pb = s->pb;
2140             ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
2141         }
2142         if (ret < 0) {
2143             /* Either bad packet, or a RTCP packet. Check if the
2144              * first_rtcp_ntp_time field was initialized. */
2145             RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
2146             if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
2147                 /* first_rtcp_ntp_time has been initialized for this stream,
2148                  * copy the same value to all other uninitialized streams,
2149                  * in order to map their timestamp origin to the same ntp time
2150                  * as this one. */
2151                 int i;
2152                 AVStream *st = NULL;
2153                 if (rtsp_st->stream_index >= 0)
2154                     st = s->streams[rtsp_st->stream_index];
2155                 for (i = 0; i < rt->nb_rtsp_streams; i++) {
2156                     RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2157                     AVStream *st2 = NULL;
2158                     if (rt->rtsp_streams[i]->stream_index >= 0)
2159                         st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2160                     if (rtpctx2 && st && st2 &&
2161                         rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
2162                         rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2163                         rtpctx2->rtcp_ts_offset = av_rescale_q(
2164                             rtpctx->rtcp_ts_offset, st->time_base,
2165                             st2->time_base);
2166                     }
2167                 }
2168                 // Make real NTP start time available in AVFormatContext
2169                 if (s->start_time_realtime == AV_NOPTS_VALUE) {
2170                     s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32);
2171                     if (rtpctx->st) {
2172                         s->start_time_realtime -=
2173                             av_rescale (rtpctx->rtcp_ts_offset,
2174                                         (uint64_t) rtpctx->st->time_base.num * 1000000,
2175                                                    rtpctx->st->time_base.den);
2176                     }
2177                 }
2178             }
2179             if (ret == -RTCP_BYE) {
2180                 rt->nb_byes++;
2181
2182                 av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2183                        rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2184
2185                 if (rt->nb_byes == rt->nb_rtsp_streams)
2186                     return AVERROR_EOF;
2187             }
2188         }
2189     } else if (CONFIG_RTPDEC && rt->ts) {
2190         ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
2191         if (ret >= 0) {
2192             if (ret < len) {
2193                 rt->recvbuf_len = len;
2194                 rt->recvbuf_pos = ret;
2195                 rt->cur_transport_priv = rt->ts;
2196                 return 1;
2197             } else {
2198                 ret = 0;
2199             }
2200         }
2201     } else {
2202         return AVERROR_INVALIDDATA;
2203     }
2204 end:
2205     if (ret < 0)
2206         goto redo;
2207     if (ret == 1)
2208         /* more packets may follow, so we save the RTP context */
2209         rt->cur_transport_priv = rtsp_st->transport_priv;
2210
2211     return ret;
2212 }
2213 #endif /* CONFIG_RTPDEC */
2214
2215 #if CONFIG_SDP_DEMUXER
2216 static int sdp_probe(AVProbeData *p1)
2217 {
2218     const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2219
2220     /* we look for a line beginning "c=IN IP" */
2221     while (p < p_end && *p != '\0') {
2222         if (sizeof("c=IN IP") - 1 < p_end - p &&
2223             av_strstart(p, "c=IN IP", NULL))
2224             return AVPROBE_SCORE_EXTENSION;
2225
2226         while (p < p_end - 1 && *p != '\n') p++;
2227         if (++p >= p_end)
2228             break;
2229         if (*p == '\r')
2230             p++;
2231     }
2232     return 0;
2233 }
2234
2235 static void append_source_addrs(char *buf, int size, const char *name,
2236                                 int count, struct RTSPSource **addrs)
2237 {
2238     int i;
2239     if (!count)
2240         return;
2241     av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
2242     for (i = 1; i < count; i++)
2243         av_strlcatf(buf, size, ",%s", addrs[i]->addr);
2244 }
2245
2246 static int sdp_read_header(AVFormatContext *s)
2247 {
2248     RTSPState *rt = s->priv_data;
2249     RTSPStream *rtsp_st;
2250     int size, i, err;
2251     char *content;
2252     char url[1024];
2253
2254     if (!ff_network_init())
2255         return AVERROR(EIO);
2256
2257     if (s->max_delay < 0) /* Not set by the caller */
2258         s->max_delay = DEFAULT_REORDERING_DELAY;
2259     if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2260         rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;
2261
2262     /* read the whole sdp file */
2263     /* XXX: better loading */
2264     content = av_malloc(SDP_MAX_SIZE);
2265     if (!content)
2266         return AVERROR(ENOMEM);
2267     size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);
2268     if (size <= 0) {
2269         av_free(content);
2270         return AVERROR_INVALIDDATA;
2271     }
2272     content[size] ='\0';
2273
2274     err = ff_sdp_parse(s, content);
2275     av_freep(&content);
2276     if (err) goto fail;
2277
2278     /* open each RTP stream */
2279     for (i = 0; i < rt->nb_rtsp_streams; i++) {
2280         char namebuf[50];
2281         rtsp_st = rt->rtsp_streams[i];
2282
2283         if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2284             AVDictionary *opts = map_to_opts(rt);
2285
2286             getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
2287                         namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2288             ff_url_join(url, sizeof(url), "rtp", NULL,
2289                         namebuf, rtsp_st->sdp_port,
2290                         "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2291                         rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2292                         rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2293                         rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2294
2295             append_source_addrs(url, sizeof(url), "sources",
2296                                 rtsp_st->nb_include_source_addrs,
2297                                 rtsp_st->include_source_addrs);
2298             append_source_addrs(url, sizeof(url), "block",
2299                                 rtsp_st->nb_exclude_source_addrs,
2300                                 rtsp_st->exclude_source_addrs);
2301             err = ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
2302                            &s->interrupt_callback, &opts);
2303
2304             av_dict_free(&opts);
2305
2306             if (err < 0) {
2307                 err = AVERROR_INVALIDDATA;
2308                 goto fail;
2309             }
2310         }
2311         if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2312             goto fail;
2313     }
2314     return 0;
2315 fail:
2316     ff_rtsp_close_streams(s);
2317     ff_network_close();
2318     return err;
2319 }
2320
2321 static int sdp_read_close(AVFormatContext *s)
2322 {
2323     ff_rtsp_close_streams(s);
2324     ff_network_close();
2325     return 0;
2326 }
2327
2328 static const AVClass sdp_demuxer_class = {
2329     .class_name     = "SDP demuxer",
2330     .item_name      = av_default_item_name,
2331     .option         = sdp_options,
2332     .version        = LIBAVUTIL_VERSION_INT,
2333 };
2334
2335 AVInputFormat ff_sdp_demuxer = {
2336     .name           = "sdp",
2337     .long_name      = NULL_IF_CONFIG_SMALL("SDP"),
2338     .priv_data_size = sizeof(RTSPState),
2339     .read_probe     = sdp_probe,
2340     .read_header    = sdp_read_header,
2341     .read_packet    = ff_rtsp_fetch_packet,
2342     .read_close     = sdp_read_close,
2343     .priv_class     = &sdp_demuxer_class,
2344 };
2345 #endif /* CONFIG_SDP_DEMUXER */
2346
2347 #if CONFIG_RTP_DEMUXER
2348 static int rtp_probe(AVProbeData *p)
2349 {
2350     if (av_strstart(p->filename, "rtp:", NULL))
2351         return AVPROBE_SCORE_MAX;
2352     return 0;
2353 }
2354
2355 static int rtp_read_header(AVFormatContext *s)
2356 {
2357     uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2358     char host[500], sdp[500];
2359     int ret, port;
2360     URLContext* in = NULL;
2361     int payload_type;
2362     AVCodecContext codec = { 0 };
2363     struct sockaddr_storage addr;
2364     AVIOContext pb;
2365     socklen_t addrlen = sizeof(addr);
2366     RTSPState *rt = s->priv_data;
2367
2368     if (!ff_network_init())
2369         return AVERROR(EIO);
2370
2371     ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ,
2372                      &s->interrupt_callback, NULL);
2373     if (ret)
2374         goto fail;
2375
2376     while (1) {
2377         ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2378         if (ret == AVERROR(EAGAIN))
2379             continue;
2380         if (ret < 0)
2381             goto fail;
2382         if (ret < 12) {
2383             av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2384             continue;
2385         }
2386
2387         if ((recvbuf[0] & 0xc0) != 0x80) {
2388             av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2389                                       "received\n");
2390             continue;
2391         }
2392
2393         if (RTP_PT_IS_RTCP(recvbuf[1]))
2394             continue;
2395
2396         payload_type = recvbuf[1] & 0x7f;
2397         break;
2398     }
2399     getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2400     ffurl_close(in);
2401     in = NULL;
2402
2403     if (ff_rtp_get_codec_info(&codec, payload_type)) {
2404         av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2405                                 "without an SDP file describing it\n",
2406                                  payload_type);
2407         goto fail;
2408     }
2409     if (codec.codec_type != AVMEDIA_TYPE_DATA) {
2410         av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2411                                   "properly you need an SDP file "
2412                                   "describing it\n");
2413     }
2414
2415     av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2416                  NULL, 0, s->filename);
2417
2418     snprintf(sdp, sizeof(sdp),
2419              "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2420              addr.ss_family == AF_INET ? 4 : 6, host,
2421              codec.codec_type == AVMEDIA_TYPE_DATA  ? "application" :
2422              codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2423              port, payload_type);
2424     av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
2425
2426     ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);
2427     s->pb = &pb;
2428
2429     /* sdp_read_header initializes this again */
2430     ff_network_close();
2431
2432     rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;
2433
2434     ret = sdp_read_header(s);
2435     s->pb = NULL;
2436     return ret;
2437
2438 fail:
2439     if (in)
2440         ffurl_close(in);
2441     ff_network_close();
2442     return ret;
2443 }
2444
2445 static const AVClass rtp_demuxer_class = {
2446     .class_name     = "RTP demuxer",
2447     .item_name      = av_default_item_name,
2448     .option         = rtp_options,
2449     .version        = LIBAVUTIL_VERSION_INT,
2450 };
2451
2452 AVInputFormat ff_rtp_demuxer = {
2453     .name           = "rtp",
2454     .long_name      = NULL_IF_CONFIG_SMALL("RTP input"),
2455     .priv_data_size = sizeof(RTSPState),
2456     .read_probe     = rtp_probe,
2457     .read_header    = rtp_read_header,
2458     .read_packet    = ff_rtsp_fetch_packet,
2459     .read_close     = sdp_read_close,
2460     .flags          = AVFMT_NOFILE,
2461     .priv_class     = &rtp_demuxer_class,
2462 };
2463 #endif /* CONFIG_RTP_DEMUXER */