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