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/base64.h"
  23 #include "libavutil/avstring.h"
  24 #include "libavutil/intreadwrite.h"
  25 #include "libavutil/random_seed.h"
  26 #include "avformat.h"
  27
  28 #include <sys/time.h>
  29 #if HAVE_SYS_SELECT_H
  30 #include <sys/select.h>
  31 #endif
  32 #include <strings.h>
  33 #include "internal.h"
  34 #include "network.h"
  35 #include "os_support.h"
  36 #include "http.h"
  37 #include "rtsp.h"
  38
  39 #include "rtpdec.h"
  40 #include "rdt.h"
  41 #include "rtpdec_formats.h"
  42
  43 //#define DEBUG
  44 //#define DEBUG_RTP_TCP
  45
  46 #if LIBAVFORMAT_VERSION_INT < (53 << 16)
  47 int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP);
  48 #endif
  49
  50 /* Timeout values for socket select, in ms,
  51  * and read_packet(), in seconds  */
  52 #define SELECT_TIMEOUT_MS 100
  53 #define READ_PACKET_TIMEOUT_S 10
  54 #define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / SELECT_TIMEOUT_MS
  55 #define SDP_MAX_SIZE 16384
  56
  57 static void get_word_until_chars(char *buf, int buf_size,
  58                                  const char *sep, const char **pp)
  59 {
  60     const char *p;
  61     char *q;
  62
  63     p = *pp;
  64     p += strspn(p, SPACE_CHARS);
  65     q = buf;
  66     while (!strchr(sep, *p) && *p != '\0') {
  67         if ((q - buf) < buf_size - 1)
  68             *q++ = *p;
  69         p++;
  70     }
  71     if (buf_size > 0)
  72         *q = '\0';
  73     *pp = p;
  74 }
  75
  76 static void get_word_sep(char *buf, int buf_size, const char *sep,
  77                          const char **pp)
  78 {
  79     if (**pp == '/') (*pp)++;
  80     get_word_until_chars(buf, buf_size, sep, pp);
  81 }
  82
  83 static void get_word(char *buf, int buf_size, const char **pp)
  84 {
  85     get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
  86 }
  87
  88 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
  89 static int sdp_parse_rtpmap(AVFormatContext *s,
  90                             AVCodecContext *codec, RTSPStream *rtsp_st,
  91                             int payload_type, const char *p)
  92 {
  93     char buf[256];
  94     int i;
  95     AVCodec *c;
  96     const char *c_name;
  97
  98     /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
  99      * see if we can handle this kind of payload.
 100      * The space should normally not be there but some Real streams or
 101      * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
 102      * have a trailing space. */
 103     get_word_sep(buf, sizeof(buf), "/ ", &p);
 104     if (payload_type >= RTP_PT_PRIVATE) {
 105         RTPDynamicProtocolHandler *handler;
 106         for (handler = RTPFirstDynamicPayloadHandler;
 107              handler; handler = handler->next) {
 108             if (!strcasecmp(buf, handler->enc_name) &&
 109                 codec->codec_type == handler->codec_type) {
 110                 codec->codec_id          = handler->codec_id;
 111                 rtsp_st->dynamic_handler = handler;
 112                 if (handler->open)
 113                     rtsp_st->dynamic_protocol_context = handler->open();
 114                 break;
 115             }
 116         }
 117     } else {
 118         /* We are in a standard case
 119          * (from http://www.iana.org/assignments/rtp-parameters). */
 120         /* search into AVRtpPayloadTypes[] */
 121         codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
 122     }
 123
 124     c = avcodec_find_decoder(codec->codec_id);
 125     if (c && c->name)
 126         c_name = c->name;
 127     else
 128         c_name = "(null)";
 129
 130     get_word_sep(buf, sizeof(buf), "/", &p);
 131     i = atoi(buf);
 132     switch (codec->codec_type) {
 133     case AVMEDIA_TYPE_AUDIO:
 134         av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
 135         codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
 136         codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
 137         if (i > 0) {
 138             codec->sample_rate = i;
 139             get_word_sep(buf, sizeof(buf), "/", &p);
 140             i = atoi(buf);
 141             if (i > 0)
 142                 codec->channels = i;
 143             // TODO: there is a bug here; if it is a mono stream, and
 144             // less than 22000Hz, faad upconverts to stereo and twice
 145             // the frequency.  No problem, but the sample rate is being
 146             // set here by the sdp line. Patch on its way. (rdm)
 147         }
 148         av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
 149                codec->sample_rate);
 150         av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
 151                codec->channels);
 152         break;
 153     case AVMEDIA_TYPE_VIDEO:
 154         av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
 155         break;
 156     default:
 157         break;
 158     }
 159     return 0;
 160 }
 161
 162 /* parse the attribute line from the fmtp a line of an sdp response. This
 163  * is broken out as a function because it is used in rtp_h264.c, which is
 164  * forthcoming. */
 165 int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
 166                                 char *value, int value_size)
 167 {
 168     *p += strspn(*p, SPACE_CHARS);
 169     if (**p) {
 170         get_word_sep(attr, attr_size, "=", p);
 171         if (**p == '=')
 172             (*p)++;
 173         get_word_sep(value, value_size, ";", p);
 174         if (**p == ';')
 175             (*p)++;
 176         return 1;
 177     }
 178     return 0;
 179 }
 180
 181 /** Parse a string p in the form of Range:npt=xx-xx, and determine the start
 182  *  and end time.
 183  *  Used for seeking in the rtp stream.
 184  */
 185 static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
 186 {
 187     char buf[256];
 188
 189     p += strspn(p, SPACE_CHARS);
 190     if (!av_stristart(p, "npt=", &p))
 191         return;
 192
 193     *start = AV_NOPTS_VALUE;
 194     *end = AV_NOPTS_VALUE;
 195
 196     get_word_sep(buf, sizeof(buf), "-", &p);
 197     *start = parse_date(buf, 1);
 198     if (*p == '-') {
 199         p++;
 200         get_word_sep(buf, sizeof(buf), "-", &p);
 201         *end = parse_date(buf, 1);
 202     }
 203 //    av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
 204 //    av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
 205 }
 206
 207 static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
 208 {
 209     struct addrinfo hints, *ai = NULL;
 210     memset(&hints, 0, sizeof(hints));
 211     hints.ai_flags = AI_NUMERICHOST;
 212     if (getaddrinfo(buf, NULL, &hints, &ai))
 213         return -1;
 214     memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
 215     freeaddrinfo(ai);
 216     return 0;
 217 }
 218
 219 typedef struct SDPParseState {
 220     /* SDP only */
 221     struct sockaddr_storage default_ip;
 222     int            default_ttl;
 223     int            skip_media;  ///< set if an unknown m= line occurs
 224 } SDPParseState;
 225
 226 static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
 227                            int letter, const char *buf)
 228 {
 229     RTSPState *rt = s->priv_data;
 230     char buf1[64], st_type[64];
 231     const char *p;
 232     enum AVMediaType codec_type;
 233     int payload_type, i;
 234     AVStream *st;
 235     RTSPStream *rtsp_st;
 236     struct sockaddr_storage sdp_ip;
 237     int ttl;
 238
 239     dprintf(s, "sdp: %c='%s'\n", letter, buf);
 240
 241     p = buf;
 242     if (s1->skip_media && letter != 'm')
 243         return;
 244     switch (letter) {
 245     case 'c':
 246         get_word(buf1, sizeof(buf1), &p);
 247         if (strcmp(buf1, "IN") != 0)
 248             return;
 249         get_word(buf1, sizeof(buf1), &p);
 250         if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
 251             return;
 252         get_word_sep(buf1, sizeof(buf1), "/", &p);
 253         if (get_sockaddr(buf1, &sdp_ip))
 254             return;
 255         ttl = 16;
 256         if (*p == '/') {
 257             p++;
 258             get_word_sep(buf1, sizeof(buf1), "/", &p);
 259             ttl = atoi(buf1);
 260         }
 261         if (s->nb_streams == 0) {
 262             s1->default_ip = sdp_ip;
 263             s1->default_ttl = ttl;
 264         } else {
 265             st = s->streams[s->nb_streams - 1];
 266             rtsp_st = st->priv_data;
 267             rtsp_st->sdp_ip = sdp_ip;
 268             rtsp_st->sdp_ttl = ttl;
 269         }
 270         break;
 271     case 's':
 272         av_metadata_set2(&s->metadata, "title", p, 0);
 273         break;
 274     case 'i':
 275         if (s->nb_streams == 0) {
 276             av_metadata_set2(&s->metadata, "comment", p, 0);
 277             break;
 278         }
 279         break;
 280     case 'm':
 281         /* new stream */
 282         s1->skip_media = 0;
 283         get_word(st_type, sizeof(st_type), &p);
 284         if (!strcmp(st_type, "audio")) {
 285             codec_type = AVMEDIA_TYPE_AUDIO;
 286         } else if (!strcmp(st_type, "video")) {
 287             codec_type = AVMEDIA_TYPE_VIDEO;
 288         } else if (!strcmp(st_type, "application")) {
 289             codec_type = AVMEDIA_TYPE_DATA;
 290         } else {
 291             s1->skip_media = 1;
 292             return;
 293         }
 294         rtsp_st = av_mallocz(sizeof(RTSPStream));
 295         if (!rtsp_st)
 296             return;
 297         rtsp_st->stream_index = -1;
 298         dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
 299
 300         rtsp_st->sdp_ip = s1->default_ip;
 301         rtsp_st->sdp_ttl = s1->default_ttl;
 302
 303         get_word(buf1, sizeof(buf1), &p); /* port */
 304         rtsp_st->sdp_port = atoi(buf1);
 305
 306         get_word(buf1, sizeof(buf1), &p); /* protocol (ignored) */
 307
 308         /* XXX: handle list of formats */
 309         get_word(buf1, sizeof(buf1), &p); /* format list */
 310         rtsp_st->sdp_payload_type = atoi(buf1);
 311
 312         if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
 313             /* no corresponding stream */
 314         } else {
 315             st = av_new_stream(s, 0);
 316             if (!st)
 317                 return;
 318             st->priv_data = rtsp_st;
 319             rtsp_st->stream_index = st->index;
 320             st->codec->codec_type = codec_type;
 321             if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
 322                 /* if standard payload type, we can find the codec right now */
 323                 ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
 324             }
 325         }
 326         /* put a default control url */
 327         av_strlcpy(rtsp_st->control_url, rt->control_uri,
 328                    sizeof(rtsp_st->control_url));
 329         break;
 330     case 'a':
 331         if (av_strstart(p, "control:", &p)) {
 332             if (s->nb_streams == 0) {
 333                 if (!strncmp(p, "rtsp://", 7))
 334                     av_strlcpy(rt->control_uri, p,
 335                                sizeof(rt->control_uri));
 336             } else {
 337             char proto[32];
 338             /* get the control url */
 339             st = s->streams[s->nb_streams - 1];
 340             rtsp_st = st->priv_data;
 341
 342             /* XXX: may need to add full url resolution */
 343             av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
 344                          NULL, NULL, 0, p);
 345             if (proto[0] == '\0') {
 346                 /* relative control URL */
 347                 if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
 348                 av_strlcat(rtsp_st->control_url, "/",
 349                            sizeof(rtsp_st->control_url));
 350                 av_strlcat(rtsp_st->control_url, p,
 351                            sizeof(rtsp_st->control_url));
 352             } else
 353                 av_strlcpy(rtsp_st->control_url, p,
 354                            sizeof(rtsp_st->control_url));
 355             }
 356         } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
 357             /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
 358             get_word(buf1, sizeof(buf1), &p);
 359             payload_type = atoi(buf1);
 360             st = s->streams[s->nb_streams - 1];
 361             rtsp_st = st->priv_data;
 362             sdp_parse_rtpmap(s, st->codec, rtsp_st, payload_type, p);
 363         } else if (av_strstart(p, "fmtp:", &p) ||
 364                    av_strstart(p, "framesize:", &p)) {
 365             /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
 366             // let dynamic protocol handlers have a stab at the line.
 367             get_word(buf1, sizeof(buf1), &p);
 368             payload_type = atoi(buf1);
 369             for (i = 0; i < s->nb_streams; i++) {
 370                 st      = s->streams[i];
 371                 rtsp_st = st->priv_data;
 372                 if (rtsp_st->sdp_payload_type == payload_type &&
 373                     rtsp_st->dynamic_handler &&
 374                     rtsp_st->dynamic_handler->parse_sdp_a_line)
 375                     rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
 376                         rtsp_st->dynamic_protocol_context, buf);
 377             }
 378         } else if (av_strstart(p, "range:", &p)) {
 379             int64_t start, end;
 380
 381             // this is so that seeking on a streamed file can work.
 382             rtsp_parse_range_npt(p, &start, &end);
 383             s->start_time = start;
 384             /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
 385             s->duration   = (end == AV_NOPTS_VALUE) ?
 386                             AV_NOPTS_VALUE : end - start;
 387         } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
 388             if (atoi(p) == 1)
 389                 rt->transport = RTSP_TRANSPORT_RDT;
 390         } else {
 391             if (rt->server_type == RTSP_SERVER_WMS)
 392                 ff_wms_parse_sdp_a_line(s, p);
 393             if (s->nb_streams > 0) {
 394                 if (rt->server_type == RTSP_SERVER_REAL)
 395                     ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p);
 396
 397                 rtsp_st = s->streams[s->nb_streams - 1]->priv_data;
 398                 if (rtsp_st->dynamic_handler &&
 399                     rtsp_st->dynamic_handler->parse_sdp_a_line)
 400                     rtsp_st->dynamic_handler->parse_sdp_a_line(s,
 401                         s->nb_streams - 1,
 402                         rtsp_st->dynamic_protocol_context, buf);
 403             }
 404         }
 405         break;
 406     }
 407 }
 408
 409 static int sdp_parse(AVFormatContext *s, const char *content)
 410 {
 411     const char *p;
 412     int letter;
 413     /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
 414      * contain long SDP lines containing complete ASF Headers (several
 415      * kB) or arrays of MDPR (RM stream descriptor) headers plus
 416      * "rulebooks" describing their properties. Therefore, the SDP line
 417      * buffer is large.
 418      *
 419      * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
 420      * in rtpdec_xiph.c. */
 421     char buf[16384], *q;
 422     SDPParseState sdp_parse_state, *s1 = &sdp_parse_state;
 423
 424     memset(s1, 0, sizeof(SDPParseState));
 425     p = content;
 426     for (;;) {
 427         p += strspn(p, SPACE_CHARS);
 428         letter = *p;
 429         if (letter == '\0')
 430             break;
 431         p++;
 432         if (*p != '=')
 433             goto next_line;
 434         p++;
 435         /* get the content */
 436         q = buf;
 437         while (*p != '\n' && *p != '\r' && *p != '\0') {
 438             if ((q - buf) < sizeof(buf) - 1)
 439                 *q++ = *p;
 440             p++;
 441         }
 442         *q = '\0';
 443         sdp_parse_line(s, s1, letter, buf);
 444     next_line:
 445         while (*p != '\n' && *p != '\0')
 446             p++;
 447         if (*p == '\n')
 448             p++;
 449     }
 450     return 0;
 451 }
 452
 453 /* close and free RTSP streams */
 454 void ff_rtsp_close_streams(AVFormatContext *s)
 455 {
 456     RTSPState *rt = s->priv_data;
 457     int i;
 458     RTSPStream *rtsp_st;
 459
 460     for (i = 0; i < rt->nb_rtsp_streams; i++) {
 461         rtsp_st = rt->rtsp_streams[i];
 462         if (rtsp_st) {
 463             if (rtsp_st->transport_priv) {
 464                 if (s->oformat) {
 465                     AVFormatContext *rtpctx = rtsp_st->transport_priv;
 466                     av_write_trailer(rtpctx);
 467                     if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
 468                         uint8_t *ptr;
 469                         url_close_dyn_buf(rtpctx->pb, &ptr);
 470                         av_free(ptr);
 471                     } else {
 472                         url_fclose(rtpctx->pb);
 473                     }
 474                     av_metadata_free(&rtpctx->streams[0]->metadata);
 475                     av_metadata_free(&rtpctx->metadata);
 476                     av_free(rtpctx->streams[0]);
 477                     av_free(rtpctx);
 478                 } else if (rt->transport == RTSP_TRANSPORT_RDT)
 479                     ff_rdt_parse_close(rtsp_st->transport_priv);
 480                 else
 481                     rtp_parse_close(rtsp_st->transport_priv);
 482             }
 483             if (rtsp_st->rtp_handle)
 484                 url_close(rtsp_st->rtp_handle);
 485             if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
 486                 rtsp_st->dynamic_handler->close(
 487                     rtsp_st->dynamic_protocol_context);
 488         }
 489     }
 490     av_free(rt->rtsp_streams);
 491     if (rt->asf_ctx) {
 492         av_close_input_stream (rt->asf_ctx);
 493         rt->asf_ctx = NULL;
 494     }
 495 }
 496
 497 static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st,
 498                                URLContext *handle)
 499 {
 500     RTSPState *rt = s->priv_data;
 501     AVFormatContext *rtpctx;
 502     int ret;
 503     AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
 504
 505     if (!rtp_format)
 506         return NULL;
 507
 508     /* Allocate an AVFormatContext for each output stream */
 509     rtpctx = avformat_alloc_context();
 510     if (!rtpctx)
 511         return NULL;
 512
 513     rtpctx->oformat = rtp_format;
 514     if (!av_new_stream(rtpctx, 0)) {
 515         av_free(rtpctx);
 516         return NULL;
 517     }
 518     /* Copy the max delay setting; the rtp muxer reads this. */
 519     rtpctx->max_delay = s->max_delay;
 520     /* Copy other stream parameters. */
 521     rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;
 522
 523     /* Set the synchronized start time. */
 524     rtpctx->start_time_realtime = rt->start_time;
 525
 526     /* Remove the local codec, link to the original codec
 527      * context instead, to give the rtp muxer access to
 528      * codec parameters. */
 529     av_free(rtpctx->streams[0]->codec);
 530     rtpctx->streams[0]->codec = st->codec;
 531
 532     if (handle) {
 533         url_fdopen(&rtpctx->pb, handle);
 534     } else
 535         url_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
 536     ret = av_write_header(rtpctx);
 537
 538     if (ret) {
 539         if (handle) {
 540             url_fclose(rtpctx->pb);
 541         } else {
 542             uint8_t *ptr;
 543             url_close_dyn_buf(rtpctx->pb, &ptr);
 544             av_free(ptr);
 545         }
 546         av_free(rtpctx->streams[0]);
 547         av_free(rtpctx);
 548         return NULL;
 549     }
 550
 551     /* Copy the RTP AVStream timebase back to the original AVStream */
 552     st->time_base = rtpctx->streams[0]->time_base;
 553     return rtpctx;
 554 }
 555
 556 static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
 557 {
 558     RTSPState *rt = s->priv_data;
 559     AVStream *st = NULL;
 560
 561     /* open the RTP context */
 562     if (rtsp_st->stream_index >= 0)
 563         st = s->streams[rtsp_st->stream_index];
 564     if (!st)
 565         s->ctx_flags |= AVFMTCTX_NOHEADER;
 566
 567     if (s->oformat) {
 568         rtsp_st->transport_priv = rtsp_rtp_mux_open(s, st, rtsp_st->rtp_handle);
 569         /* Ownership of rtp_handle is passed to the rtp mux context */
 570         rtsp_st->rtp_handle = NULL;
 571     } else if (rt->transport == RTSP_TRANSPORT_RDT)
 572         rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
 573                                             rtsp_st->dynamic_protocol_context,
 574                                             rtsp_st->dynamic_handler);
 575     else
 576         rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
 577                                          rtsp_st->sdp_payload_type);
 578
 579     if (!rtsp_st->transport_priv) {
 580          return AVERROR(ENOMEM);
 581     } else if (rt->transport != RTSP_TRANSPORT_RDT) {
 582         if (rtsp_st->dynamic_handler) {
 583             rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
 584                                            rtsp_st->dynamic_protocol_context,
 585                                            rtsp_st->dynamic_handler);
 586         }
 587     }
 588
 589     return 0;
 590 }
 591
 592 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
 593 static int rtsp_probe(AVProbeData *p)
 594 {
 595     if (av_strstart(p->filename, "rtsp:", NULL))
 596         return AVPROBE_SCORE_MAX;
 597     return 0;
 598 }
 599
 600 static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
 601 {
 602     const char *p;
 603     int v;
 604
 605     p = *pp;
 606     p += strspn(p, SPACE_CHARS);
 607     v = strtol(p, (char **)&p, 10);
 608     if (*p == '-') {
 609         p++;
 610         *min_ptr = v;
 611         v = strtol(p, (char **)&p, 10);
 612         *max_ptr = v;
 613     } else {
 614         *min_ptr = v;
 615         *max_ptr = v;
 616     }
 617     *pp = p;
 618 }
 619
 620 /* XXX: only one transport specification is parsed */
 621 static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
 622 {
 623     char transport_protocol[16];
 624     char profile[16];
 625     char lower_transport[16];
 626     char parameter[16];
 627     RTSPTransportField *th;
 628     char buf[256];
 629
 630     reply->nb_transports = 0;
 631
 632     for (;;) {
 633         p += strspn(p, SPACE_CHARS);
 634         if (*p == '\0')
 635             break;
 636
 637         th = &reply->transports[reply->nb_transports];
 638
 639         get_word_sep(transport_protocol, sizeof(transport_protocol),
 640                      "/", &p);
 641         if (!strcasecmp (transport_protocol, "rtp")) {
 642             get_word_sep(profile, sizeof(profile), "/;,", &p);
 643             lower_transport[0] = '\0';
 644             /* rtp/avp/<protocol> */
 645             if (*p == '/') {
 646                 get_word_sep(lower_transport, sizeof(lower_transport),
 647                              ";,", &p);
 648             }
 649             th->transport = RTSP_TRANSPORT_RTP;
 650         } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
 651                    !strcasecmp (transport_protocol, "x-real-rdt")) {
 652             /* x-pn-tng/<protocol> */
 653             get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
 654             profile[0] = '\0';
 655             th->transport = RTSP_TRANSPORT_RDT;
 656         }
 657         if (!strcasecmp(lower_transport, "TCP"))
 658             th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
 659         else
 660             th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
 661
 662         if (*p == ';')
 663             p++;
 664         /* get each parameter */
 665         while (*p != '\0' && *p != ',') {
 666             get_word_sep(parameter, sizeof(parameter), "=;,", &p);
 667             if (!strcmp(parameter, "port")) {
 668                 if (*p == '=') {
 669                     p++;
 670                     rtsp_parse_range(&th->port_min, &th->port_max, &p);
 671                 }
 672             } else if (!strcmp(parameter, "client_port")) {
 673                 if (*p == '=') {
 674                     p++;
 675                     rtsp_parse_range(&th->client_port_min,
 676                                      &th->client_port_max, &p);
 677                 }
 678             } else if (!strcmp(parameter, "server_port")) {
 679                 if (*p == '=') {
 680                     p++;
 681                     rtsp_parse_range(&th->server_port_min,
 682                                      &th->server_port_max, &p);
 683                 }
 684             } else if (!strcmp(parameter, "interleaved")) {
 685                 if (*p == '=') {
 686                     p++;
 687                     rtsp_parse_range(&th->interleaved_min,
 688                                      &th->interleaved_max, &p);
 689                 }
 690             } else if (!strcmp(parameter, "multicast")) {
 691                 if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
 692                     th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
 693             } else if (!strcmp(parameter, "ttl")) {
 694                 if (*p == '=') {
 695                     p++;
 696                     th->ttl = strtol(p, (char **)&p, 10);
 697                 }
 698             } else if (!strcmp(parameter, "destination")) {
 699                 if (*p == '=') {
 700                     p++;
 701                     get_word_sep(buf, sizeof(buf), ";,", &p);
 702                     get_sockaddr(buf, &th->destination);
 703                 }
 704             }
 705             while (*p != ';' && *p != '\0' && *p != ',')
 706                 p++;
 707             if (*p == ';')
 708                 p++;
 709         }
 710         if (*p == ',')
 711             p++;
 712
 713         reply->nb_transports++;
 714     }
 715 }
 716
 717 void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
 718                         HTTPAuthState *auth_state)
 719 {
 720     const char *p;
 721
 722     /* NOTE: we do case independent match for broken servers */
 723     p = buf;
 724     if (av_stristart(p, "Session:", &p)) {
 725         int t;
 726         get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
 727         if (av_stristart(p, ";timeout=", &p) &&
 728             (t = strtol(p, NULL, 10)) > 0) {
 729             reply->timeout = t;
 730         }
 731     } else if (av_stristart(p, "Content-Length:", &p)) {
 732         reply->content_length = strtol(p, NULL, 10);
 733     } else if (av_stristart(p, "Transport:", &p)) {
 734         rtsp_parse_transport(reply, p);
 735     } else if (av_stristart(p, "CSeq:", &p)) {
 736         reply->seq = strtol(p, NULL, 10);
 737     } else if (av_stristart(p, "Range:", &p)) {
 738         rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
 739     } else if (av_stristart(p, "RealChallenge1:", &p)) {
 740         p += strspn(p, SPACE_CHARS);
 741         av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
 742     } else if (av_stristart(p, "Server:", &p)) {
 743         p += strspn(p, SPACE_CHARS);
 744         av_strlcpy(reply->server, p, sizeof(reply->server));
 745     } else if (av_stristart(p, "Notice:", &p) ||
 746                av_stristart(p, "X-Notice:", &p)) {
 747         reply->notice = strtol(p, NULL, 10);
 748     } else if (av_stristart(p, "Location:", &p)) {
 749         p += strspn(p, SPACE_CHARS);
 750         av_strlcpy(reply->location, p , sizeof(reply->location));
 751     } else if (av_stristart(p, "WWW-Authenticate:", &p) && auth_state) {
 752         p += strspn(p, SPACE_CHARS);
 753         ff_http_auth_handle_header(auth_state, "WWW-Authenticate", p);
 754     } else if (av_stristart(p, "Authentication-Info:", &p) && auth_state) {
 755         p += strspn(p, SPACE_CHARS);
 756         ff_http_auth_handle_header(auth_state, "Authentication-Info", p);
 757     }
 758 }
 759
 760 /* skip a RTP/TCP interleaved packet */
 761 void ff_rtsp_skip_packet(AVFormatContext *s)
 762 {
 763     RTSPState *rt = s->priv_data;
 764     int ret, len, len1;
 765     uint8_t buf[1024];
 766
 767     ret = url_read_complete(rt->rtsp_hd, buf, 3);
 768     if (ret != 3)
 769         return;
 770     len = AV_RB16(buf + 1);
 771
 772     dprintf(s, "skipping RTP packet len=%d\n", len);
 773
 774     /* skip payload */
 775     while (len > 0) {
 776         len1 = len;
 777         if (len1 > sizeof(buf))
 778             len1 = sizeof(buf);
 779         ret = url_read_complete(rt->rtsp_hd, buf, len1);
 780         if (ret != len1)
 781             return;
 782         len -= len1;
 783     }
 784 }
 785
 786 int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
 787                        unsigned char **content_ptr,
 788                        int return_on_interleaved_data)
 789 {
 790     RTSPState *rt = s->priv_data;
 791     char buf[4096], buf1[1024], *q;
 792     unsigned char ch;
 793     const char *p;
 794     int ret, content_length, line_count = 0;
 795     unsigned char *content = NULL;
 796
 797     memset(reply, 0, sizeof(*reply));
 798
 799     /* parse reply (XXX: use buffers) */
 800     rt->last_reply[0] = '\0';
 801     for (;;) {
 802         q = buf;
 803         for (;;) {
 804             ret = url_read_complete(rt->rtsp_hd, &ch, 1);
 805 #ifdef DEBUG_RTP_TCP
 806             dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
 807 #endif
 808             if (ret != 1)
 809                 return AVERROR_EOF;
 810             if (ch == '\n')
 811                 break;
 812             if (ch == '$') {
 813                 /* XXX: only parse it if first char on line ? */
 814                 if (return_on_interleaved_data) {
 815                     return 1;
 816                 } else
 817                     ff_rtsp_skip_packet(s);
 818             } else if (ch != '\r') {
 819                 if ((q - buf) < sizeof(buf) - 1)
 820                     *q++ = ch;
 821             }
 822         }
 823         *q = '\0';
 824
 825         dprintf(s, "line='%s'\n", buf);
 826
 827         /* test if last line */
 828         if (buf[0] == '\0')
 829             break;
 830         p = buf;
 831         if (line_count == 0) {
 832             /* get reply code */
 833             get_word(buf1, sizeof(buf1), &p);
 834             get_word(buf1, sizeof(buf1), &p);
 835             reply->status_code = atoi(buf1);
 836             av_strlcpy(reply->reason, p, sizeof(reply->reason));
 837         } else {
 838             ff_rtsp_parse_line(reply, p, &rt->auth_state);
 839             av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
 840             av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
 841         }
 842         line_count++;
 843     }
 844
 845     if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
 846         av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
 847
 848     content_length = reply->content_length;
 849     if (content_length > 0) {
 850         /* leave some room for a trailing '\0' (useful for simple parsing) */
 851         content = av_malloc(content_length + 1);
 852         (void)url_read_complete(rt->rtsp_hd, content, content_length);
 853         content[content_length] = '\0';
 854     }
 855     if (content_ptr)
 856         *content_ptr = content;
 857     else
 858         av_free(content);
 859
 860     if (rt->seq != reply->seq) {
 861         av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
 862             rt->seq, reply->seq);
 863     }
 864
 865     /* EOS */
 866     if (reply->notice == 2101 /* End-of-Stream Reached */      ||
 867         reply->notice == 2104 /* Start-of-Stream Reached */    ||
 868         reply->notice == 2306 /* Continuous Feed Terminated */) {
 869         rt->state = RTSP_STATE_IDLE;
 870     } else if (reply->notice >= 4400 && reply->notice < 5500) {
 871         return AVERROR(EIO); /* data or server error */
 872     } else if (reply->notice == 2401 /* Ticket Expired */ ||
 873              (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
 874         return AVERROR(EPERM);
 875
 876     return 0;
 877 }
 878
 879 int ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
 880                                         const char *method, const char *url,
 881                                         const char *headers,
 882                                         const unsigned char *send_content,
 883                                         int send_content_length)
 884 {
 885     RTSPState *rt = s->priv_data;
 886     char buf[4096], *out_buf;
 887     char base64buf[AV_BASE64_SIZE(sizeof(buf))];
 888
 889     /* Add in RTSP headers */
 890     out_buf = buf;
 891     rt->seq++;
 892     snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
 893     if (headers)
 894         av_strlcat(buf, headers, sizeof(buf));
 895     av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
 896     if (rt->session_id[0] != '\0' && (!headers ||
 897         !strstr(headers, "\nIf-Match:"))) {
 898         av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
 899     }
 900     if (rt->auth[0]) {
 901         char *str = ff_http_auth_create_response(&rt->auth_state,
 902                                                  rt->auth, url, method);
 903         if (str)
 904             av_strlcat(buf, str, sizeof(buf));
 905         av_free(str);
 906     }
 907     if (send_content_length > 0 && send_content)
 908         av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
 909     av_strlcat(buf, "\r\n", sizeof(buf));
 910
 911     /* base64 encode rtsp if tunneling */
 912     if (rt->control_transport == RTSP_MODE_TUNNEL) {
 913         av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
 914         out_buf = base64buf;
 915     }
 916
 917     dprintf(s, "Sending:\n%s--\n", buf);
 918
 919     url_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
 920     if (send_content_length > 0 && send_content) {
 921         if (rt->control_transport == RTSP_MODE_TUNNEL) {
 922             av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
 923                                     "with content data not supported\n");
 924             return AVERROR_PATCHWELCOME;
 925         }
 926         url_write(rt->rtsp_hd_out, send_content, send_content_length);
 927     }
 928     rt->last_cmd_time = av_gettime();
 929
 930     return 0;
 931 }
 932
 933 int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
 934                            const char *url, const char *headers)
 935 {
 936     return ff_rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
 937 }
 938
 939 int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
 940                      const char *headers, RTSPMessageHeader *reply,
 941                      unsigned char **content_ptr)
 942 {
 943     return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
 944                                          content_ptr, NULL, 0);
 945 }
 946
 947 int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
 948                                   const char *method, const char *url,
 949                                   const char *header,
 950                                   RTSPMessageHeader *reply,
 951                                   unsigned char **content_ptr,
 952                                   const unsigned char *send_content,
 953                                   int send_content_length)
 954 {
 955     RTSPState *rt = s->priv_data;
 956     HTTPAuthType cur_auth_type;
 957     int ret;
 958
 959 retry:
 960     cur_auth_type = rt->auth_state.auth_type;
 961     if ((ret = ff_rtsp_send_cmd_with_content_async(s, method, url, header,
 962                                                    send_content,
 963                                                    send_content_length)))
 964         return ret;
 965
 966     if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0) ) < 0)
 967         return ret;
 968
 969     if (reply->status_code == 401 && cur_auth_type == HTTP_AUTH_NONE &&
 970         rt->auth_state.auth_type != HTTP_AUTH_NONE)
 971         goto retry;
 972
 973     if (reply->status_code > 400){
 974         av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
 975                method,
 976                reply->status_code,
 977                reply->reason);
 978         av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
 979     }
 980
 981     return 0;
 982 }
 983
 984 /**
 985  * @return 0 on success, <0 on error, 1 if protocol is unavailable.
 986  */
 987 static int make_setup_request(AVFormatContext *s, const char *host, int port,
 988                               int lower_transport, const char *real_challenge)
 989 {
 990     RTSPState *rt = s->priv_data;
 991     int rtx, j, i, err, interleave = 0;
 992     RTSPStream *rtsp_st;
 993     RTSPMessageHeader reply1, *reply = &reply1;
 994     char cmd[2048];
 995     const char *trans_pref;
 996
 997     if (rt->transport == RTSP_TRANSPORT_RDT)
 998         trans_pref = "x-pn-tng";
 999     else
1000         trans_pref = "RTP/AVP";
1001
1002     /* default timeout: 1 minute */
1003     rt->timeout = 60;
1004
1005     /* for each stream, make the setup request */
1006     /* XXX: we assume the same server is used for the control of each
1007      * RTSP stream */
1008
1009     for (j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) {
1010         char transport[2048];
1011
1012         /**
1013          * WMS serves all UDP data over a single connection, the RTX, which
1014          * isn't necessarily the first in the SDP but has to be the first
1015          * to be set up, else the second/third SETUP will fail with a 461.
1016          */
1017         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1018              rt->server_type == RTSP_SERVER_WMS) {
1019             if (i == 0) {
1020                 /* rtx first */
1021                 for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1022                     int len = strlen(rt->rtsp_streams[rtx]->control_url);
1023                     if (len >= 4 &&
1024                         !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1025                                 "/rtx"))
1026                         break;
1027                 }
1028                 if (rtx == rt->nb_rtsp_streams)
1029                     return -1; /* no RTX found */
1030                 rtsp_st = rt->rtsp_streams[rtx];
1031             } else
1032                 rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1033         } else
1034             rtsp_st = rt->rtsp_streams[i];
1035
1036         /* RTP/UDP */
1037         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1038             char buf[256];
1039
1040             if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1041                 port = reply->transports[0].client_port_min;
1042                 goto have_port;
1043             }
1044
1045             /* first try in specified port range */
1046             if (RTSP_RTP_PORT_MIN != 0) {
1047                 while (j <= RTSP_RTP_PORT_MAX) {
1048                     ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1049                                 "?localport=%d", j);
1050                     /* we will use two ports per rtp stream (rtp and rtcp) */
1051                     j += 2;
1052                     if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0)
1053                         goto rtp_opened;
1054                 }
1055             }
1056
1057 #if 0
1058             /* then try on any port */
1059             if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
1060                 err = AVERROR_INVALIDDATA;
1061                 goto fail;
1062             }
1063 #endif
1064
1065         rtp_opened:
1066             port = rtp_get_local_port(rtsp_st->rtp_handle);
1067         have_port:
1068             snprintf(transport, sizeof(transport) - 1,
1069                      "%s/UDP;", trans_pref);
1070             if (rt->server_type != RTSP_SERVER_REAL)
1071                 av_strlcat(transport, "unicast;", sizeof(transport));
1072             av_strlcatf(transport, sizeof(transport),
1073                      "client_port=%d", port);
1074             if (rt->transport == RTSP_TRANSPORT_RTP &&
1075                 !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1076                 av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1077         }
1078
1079         /* RTP/TCP */
1080         else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1081             /** For WMS streams, the application streams are only used for
1082              * UDP. When trying to set it up for TCP streams, the server
1083              * will return an error. Therefore, we skip those streams. */
1084             if (rt->server_type == RTSP_SERVER_WMS &&
1085                 s->streams[rtsp_st->stream_index]->codec->codec_type ==
1086                     AVMEDIA_TYPE_DATA)
1087                 continue;
1088             snprintf(transport, sizeof(transport) - 1,
1089                      "%s/TCP;", trans_pref);
1090             if (rt->server_type == RTSP_SERVER_WMS)
1091                 av_strlcat(transport, "unicast;", sizeof(transport));
1092             av_strlcatf(transport, sizeof(transport),
1093                         "interleaved=%d-%d",
1094                         interleave, interleave + 1);
1095             interleave += 2;
1096         }
1097
1098         else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1099             snprintf(transport, sizeof(transport) - 1,
1100                      "%s/UDP;multicast", trans_pref);
1101         }
1102         if (s->oformat) {
1103             av_strlcat(transport, ";mode=receive", sizeof(transport));
1104         } else if (rt->server_type == RTSP_SERVER_REAL ||
1105                    rt->server_type == RTSP_SERVER_WMS)
1106             av_strlcat(transport, ";mode=play", sizeof(transport));
1107         snprintf(cmd, sizeof(cmd),
1108                  "Transport: %s\r\n",
1109                  transport);
1110         if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1111             char real_res[41], real_csum[9];
1112             ff_rdt_calc_response_and_checksum(real_res, real_csum,
1113                                               real_challenge);
1114             av_strlcatf(cmd, sizeof(cmd),
1115                         "If-Match: %s\r\n"
1116                         "RealChallenge2: %s, sd=%s\r\n",
1117                         rt->session_id, real_res, real_csum);
1118         }
1119         ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1120         if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1121             err = 1;
1122             goto fail;
1123         } else if (reply->status_code != RTSP_STATUS_OK ||
1124                    reply->nb_transports != 1) {
1125             err = AVERROR_INVALIDDATA;
1126             goto fail;
1127         }
1128
1129         /* XXX: same protocol for all streams is required */
1130         if (i > 0) {
1131             if (reply->transports[0].lower_transport != rt->lower_transport ||
1132                 reply->transports[0].transport != rt->transport) {
1133                 err = AVERROR_INVALIDDATA;
1134                 goto fail;
1135             }
1136         } else {
1137             rt->lower_transport = reply->transports[0].lower_transport;
1138             rt->transport = reply->transports[0].transport;
1139         }
1140
1141         /* close RTP connection if not chosen */
1142         if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1143             (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1144             url_close(rtsp_st->rtp_handle);
1145             rtsp_st->rtp_handle = NULL;
1146         }
1147
1148         switch(reply->transports[0].lower_transport) {
1149         case RTSP_LOWER_TRANSPORT_TCP:
1150             rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1151             rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1152             break;
1153
1154         case RTSP_LOWER_TRANSPORT_UDP: {
1155             char url[1024];
1156
1157             /* XXX: also use address if specified */
1158             ff_url_join(url, sizeof(url), "rtp", NULL, host,
1159                         reply->transports[0].server_port_min, NULL);
1160             if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1161                 rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1162                 err = AVERROR_INVALIDDATA;
1163                 goto fail;
1164             }
1165             /* Try to initialize the connection state in a
1166              * potential NAT router by sending dummy packets.
1167              * RTP/RTCP dummy packets are used for RDT, too.
1168              */
1169             if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1170                 rtp_send_punch_packets(rtsp_st->rtp_handle);
1171             break;
1172         }
1173         case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1174             char url[1024], namebuf[50];
1175             struct sockaddr_storage addr;
1176             int port, ttl;
1177
1178             if (reply->transports[0].destination.ss_family) {
1179                 addr      = reply->transports[0].destination;
1180                 port      = reply->transports[0].port_min;
1181                 ttl       = reply->transports[0].ttl;
1182             } else {
1183                 addr      = rtsp_st->sdp_ip;
1184                 port      = rtsp_st->sdp_port;
1185                 ttl       = rtsp_st->sdp_ttl;
1186             }
1187             getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1188                         namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1189             ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1190                         port, "?ttl=%d", ttl);
1191             if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1192                 err = AVERROR_INVALIDDATA;
1193                 goto fail;
1194             }
1195             break;
1196         }
1197         }
1198
1199         if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1200             goto fail;
1201     }
1202
1203     if (reply->timeout > 0)
1204         rt->timeout = reply->timeout;
1205
1206     if (rt->server_type == RTSP_SERVER_REAL)
1207         rt->need_subscription = 1;
1208
1209     return 0;
1210
1211 fail:
1212     for (i = 0; i < rt->nb_rtsp_streams; i++) {
1213         if (rt->rtsp_streams[i]->rtp_handle) {
1214             url_close(rt->rtsp_streams[i]->rtp_handle);
1215             rt->rtsp_streams[i]->rtp_handle = NULL;
1216         }
1217     }
1218     return err;
1219 }
1220
1221 static int rtsp_read_play(AVFormatContext *s)
1222 {
1223     RTSPState *rt = s->priv_data;
1224     RTSPMessageHeader reply1, *reply = &reply1;
1225     int i;
1226     char cmd[1024];
1227
1228     av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state);
1229     rt->nb_byes = 0;
1230
1231     if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1232         if (rt->state == RTSP_STATE_PAUSED) {
1233             cmd[0] = 0;
1234         } else {
1235             snprintf(cmd, sizeof(cmd),
1236                      "Range: npt=%0.3f-\r\n",
1237                      (double)rt->seek_timestamp / AV_TIME_BASE);
1238         }
1239         ff_rtsp_send_cmd(s, "PLAY", rt->control_uri, cmd, reply, NULL);
1240         if (reply->status_code != RTSP_STATUS_OK) {
1241             return -1;
1242         }
1243         if (reply->range_start != AV_NOPTS_VALUE &&
1244             rt->transport == RTSP_TRANSPORT_RTP) {
1245             for (i = 0; i < rt->nb_rtsp_streams; i++) {
1246                 RTSPStream *rtsp_st = rt->rtsp_streams[i];
1247                 RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1248                 AVStream *st = NULL;
1249                 if (!rtpctx)
1250                     continue;
1251                 if (rtsp_st->stream_index >= 0)
1252                     st = s->streams[rtsp_st->stream_index];
1253                 rtpctx->last_rtcp_ntp_time  = AV_NOPTS_VALUE;
1254                 rtpctx->first_rtcp_ntp_time = AV_NOPTS_VALUE;
1255                 if (st)
1256                     rtpctx->range_start_offset = av_rescale_q(reply->range_start,
1257                                                               AV_TIME_BASE_Q,
1258                                                               st->time_base);
1259             }
1260         }
1261     }
1262     rt->state = RTSP_STATE_STREAMING;
1263     return 0;
1264 }
1265
1266 static int rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
1267 {
1268     RTSPState *rt = s->priv_data;
1269     char cmd[1024];
1270     unsigned char *content = NULL;
1271     int ret;
1272
1273     /* describe the stream */
1274     snprintf(cmd, sizeof(cmd),
1275              "Accept: application/sdp\r\n");
1276     if (rt->server_type == RTSP_SERVER_REAL) {
1277         /**
1278          * The Require: attribute is needed for proper streaming from
1279          * Realmedia servers.
1280          */
1281         av_strlcat(cmd,
1282                    "Require: com.real.retain-entity-for-setup\r\n",
1283                    sizeof(cmd));
1284     }
1285     ff_rtsp_send_cmd(s, "DESCRIBE", rt->control_uri, cmd, reply, &content);
1286     if (!content)
1287         return AVERROR_INVALIDDATA;
1288     if (reply->status_code != RTSP_STATUS_OK) {
1289         av_freep(&content);
1290         return AVERROR_INVALIDDATA;
1291     }
1292
1293     /* now we got the SDP description, we parse it */
1294     ret = sdp_parse(s, (const char *)content);
1295     av_freep(&content);
1296     if (ret < 0)
1297         return AVERROR_INVALIDDATA;
1298
1299     return 0;
1300 }
1301
1302 static int rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
1303 {
1304     RTSPState *rt = s->priv_data;
1305     RTSPMessageHeader reply1, *reply = &reply1;
1306     int i;
1307     char *sdp;
1308     AVFormatContext sdp_ctx, *ctx_array[1];
1309
1310     rt->start_time = av_gettime();
1311
1312     /* Announce the stream */
1313     sdp = av_mallocz(SDP_MAX_SIZE);
1314     if (sdp == NULL)
1315         return AVERROR(ENOMEM);
1316     /* We create the SDP based on the RTSP AVFormatContext where we
1317      * aren't allowed to change the filename field. (We create the SDP
1318      * based on the RTSP context since the contexts for the RTP streams
1319      * don't exist yet.) In order to specify a custom URL with the actual
1320      * peer IP instead of the originally specified hostname, we create
1321      * a temporary copy of the AVFormatContext, where the custom URL is set.
1322      *
1323      * FIXME: Create the SDP without copying the AVFormatContext.
1324      * This either requires setting up the RTP stream AVFormatContexts
1325      * already here (complicating things immensely) or getting a more
1326      * flexible SDP creation interface.
1327      */
1328     sdp_ctx = *s;
1329     ff_url_join(sdp_ctx.filename, sizeof(sdp_ctx.filename),
1330                 "rtsp", NULL, addr, -1, NULL);
1331     ctx_array[0] = &sdp_ctx;
1332     if (avf_sdp_create(ctx_array, 1, sdp, SDP_MAX_SIZE)) {
1333         av_free(sdp);
1334         return AVERROR_INVALIDDATA;
1335     }
1336     av_log(s, AV_LOG_INFO, "SDP:\n%s\n", sdp);
1337     ff_rtsp_send_cmd_with_content(s, "ANNOUNCE", rt->control_uri,
1338                                   "Content-Type: application/sdp\r\n",
1339                                   reply, NULL, sdp, strlen(sdp));
1340     av_free(sdp);
1341     if (reply->status_code != RTSP_STATUS_OK)
1342         return AVERROR_INVALIDDATA;
1343
1344     /* Set up the RTSPStreams for each AVStream */
1345     for (i = 0; i < s->nb_streams; i++) {
1346         RTSPStream *rtsp_st;
1347         AVStream *st = s->streams[i];
1348
1349         rtsp_st = av_mallocz(sizeof(RTSPStream));
1350         if (!rtsp_st)
1351             return AVERROR(ENOMEM);
1352         dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1353
1354         st->priv_data = rtsp_st;
1355         rtsp_st->stream_index = i;
1356
1357         av_strlcpy(rtsp_st->control_url, rt->control_uri, sizeof(rtsp_st->control_url));
1358         /* Note, this must match the relative uri set in the sdp content */
1359         av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1360                     "/streamid=%d", i);
1361     }
1362
1363     return 0;
1364 }
1365
1366 void ff_rtsp_close_connections(AVFormatContext *s)
1367 {
1368     RTSPState *rt = s->priv_data;
1369     if (rt->rtsp_hd_out != rt->rtsp_hd) url_close(rt->rtsp_hd_out);
1370     url_close(rt->rtsp_hd);
1371     rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1372 }
1373
1374 int ff_rtsp_connect(AVFormatContext *s)
1375 {
1376     RTSPState *rt = s->priv_data;
1377     char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1378     char *option_list, *option, *filename;
1379     int port, err, tcp_fd;
1380     RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1381     int lower_transport_mask = 0;
1382     char real_challenge[64];
1383     struct sockaddr_storage peer;
1384     socklen_t peer_len = sizeof(peer);
1385
1386     if (!ff_network_init())
1387         return AVERROR(EIO);
1388 redirect:
1389     rt->control_transport = RTSP_MODE_PLAIN;
1390     /* extract hostname and port */
1391     av_url_split(NULL, 0, auth, sizeof(auth),
1392                  host, sizeof(host), &port, path, sizeof(path), s->filename);
1393     if (*auth) {
1394         av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1395     }
1396     if (port < 0)
1397         port = RTSP_DEFAULT_PORT;
1398
1399     /* search for options */
1400     option_list = strrchr(path, '?');
1401     if (option_list) {
1402         /* Strip out the RTSP specific options, write out the rest of
1403          * the options back into the same string. */
1404         filename = option_list;
1405         while (option_list) {
1406             /* move the option pointer */
1407             option = ++option_list;
1408             option_list = strchr(option_list, '&');
1409             if (option_list)
1410                 *option_list = 0;
1411
1412             /* handle the options */
1413             if (!strcmp(option, "udp")) {
1414                 lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP);
1415             } else if (!strcmp(option, "multicast")) {
1416                 lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1417             } else if (!strcmp(option, "tcp")) {
1418                 lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1419             } else if(!strcmp(option, "http")) {
1420                 lower_transport_mask |= (1<< RTSP_LOWER_TRANSPORT_TCP);
1421                 rt->control_transport = RTSP_MODE_TUNNEL;
1422             } else {
1423                 /* Write options back into the buffer, using memmove instead
1424                  * of strcpy since the strings may overlap. */
1425                 int len = strlen(option);
1426                 memmove(++filename, option, len);
1427                 filename += len;
1428                 if (option_list) *filename = '&';
1429             }
1430         }
1431         *filename = 0;
1432     }
1433
1434     if (!lower_transport_mask)
1435         lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1436
1437     if (s->oformat) {
1438         /* Only UDP or TCP - UDP multicast isn't supported. */
1439         lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1440                                 (1 << RTSP_LOWER_TRANSPORT_TCP);
1441         if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1442             av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1443                                     "only UDP and TCP are supported for output.\n");
1444             err = AVERROR(EINVAL);
1445             goto fail;
1446         }
1447     }
1448
1449     /* Construct the URI used in request; this is similar to s->filename,
1450      * but with authentication credentials removed and RTSP specific options
1451      * stripped out. */
1452     ff_url_join(rt->control_uri, sizeof(rt->control_uri), "rtsp", NULL,
1453                 host, port, "%s", path);
1454
1455     if (rt->control_transport == RTSP_MODE_TUNNEL) {
1456         /* set up initial handshake for tunneling */
1457         char httpname[1024];
1458         char sessioncookie[17];
1459         char headers[1024];
1460
1461         ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1462         snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1463                  av_get_random_seed(), av_get_random_seed());
1464
1465         /* GET requests */
1466         if (url_alloc(&rt->rtsp_hd, httpname, URL_RDONLY) < 0) {
1467             err = AVERROR(EIO);
1468             goto fail;
1469         }
1470
1471         /* generate GET headers */
1472         snprintf(headers, sizeof(headers),
1473                  "x-sessioncookie: %s\r\n"
1474                  "Accept: application/x-rtsp-tunnelled\r\n"
1475                  "Pragma: no-cache\r\n"
1476                  "Cache-Control: no-cache\r\n",
1477                  sessioncookie);
1478         ff_http_set_headers(rt->rtsp_hd, headers);
1479
1480         /* complete the connection */
1481         if (url_connect(rt->rtsp_hd)) {
1482             err = AVERROR(EIO);
1483             goto fail;
1484         }
1485
1486         /* POST requests */
1487         if (url_alloc(&rt->rtsp_hd_out, httpname, URL_WRONLY) < 0 ) {
1488             err = AVERROR(EIO);
1489             goto fail;
1490         }
1491
1492         /* generate POST headers */
1493         snprintf(headers, sizeof(headers),
1494                  "x-sessioncookie: %s\r\n"
1495                  "Content-Type: application/x-rtsp-tunnelled\r\n"
1496                  "Pragma: no-cache\r\n"
1497                  "Cache-Control: no-cache\r\n"
1498                  "Content-Length: 32767\r\n"
1499                  "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1500                  sessioncookie);
1501         ff_http_set_headers(rt->rtsp_hd_out, headers);
1502         ff_http_set_chunked_transfer_encoding(rt->rtsp_hd_out, 0);
1503
1504         /* Initialize the authentication state for the POST session. The HTTP
1505          * protocol implementation doesn't properly handle multi-pass
1506          * authentication for POST requests, since it would require one of
1507          * the following:
1508          * - implementing Expect: 100-continue, which many HTTP servers
1509          *   don't support anyway, even less the RTSP servers that do HTTP
1510          *   tunneling
1511          * - sending the whole POST data until getting a 401 reply specifying
1512          *   what authentication method to use, then resending all that data
1513          * - waiting for potential 401 replies directly after sending the
1514          *   POST header (waiting for some unspecified time)
1515          * Therefore, we copy the full auth state, which works for both basic
1516          * and digest. (For digest, we would have to synchronize the nonce
1517          * count variable between the two sessions, if we'd do more requests
1518          * with the original session, though.)
1519          */
1520         ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1521
1522         /* complete the connection */
1523         if (url_connect(rt->rtsp_hd_out)) {
1524             err = AVERROR(EIO);
1525             goto fail;
1526         }
1527     } else {
1528         /* open the tcp connection */
1529         ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
1530         if (url_open(&rt->rtsp_hd, tcpname, URL_RDWR) < 0) {
1531             err = AVERROR(EIO);
1532             goto fail;
1533         }
1534         rt->rtsp_hd_out = rt->rtsp_hd;
1535     }
1536     rt->seq = 0;
1537
1538     tcp_fd = url_get_file_handle(rt->rtsp_hd);
1539     if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1540         getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1541                     NULL, 0, NI_NUMERICHOST);
1542     }
1543
1544     /* request options supported by the server; this also detects server
1545      * type */
1546     for (rt->server_type = RTSP_SERVER_RTP;;) {
1547         cmd[0] = 0;
1548         if (rt->server_type == RTSP_SERVER_REAL)
1549             av_strlcat(cmd,
1550                        /**
1551                         * The following entries are required for proper
1552                         * streaming from a Realmedia server. They are
1553                         * interdependent in some way although we currently
1554                         * don't quite understand how. Values were copied
1555                         * from mplayer SVN r23589.
1556                         * @param CompanyID is a 16-byte ID in base64
1557                         * @param ClientChallenge is a 16-byte ID in hex
1558                         */
1559                        "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1560                        "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1561                        "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1562                        "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1563                        sizeof(cmd));
1564         ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1565         if (reply->status_code != RTSP_STATUS_OK) {
1566             err = AVERROR_INVALIDDATA;
1567             goto fail;
1568         }
1569
1570         /* detect server type if not standard-compliant RTP */
1571         if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1572             rt->server_type = RTSP_SERVER_REAL;
1573             continue;
1574         } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1575             rt->server_type = RTSP_SERVER_WMS;
1576         } else if (rt->server_type == RTSP_SERVER_REAL)
1577             strcpy(real_challenge, reply->real_challenge);
1578         break;
1579     }
1580
1581     if (s->iformat)
1582         err = rtsp_setup_input_streams(s, reply);
1583     else
1584         err = rtsp_setup_output_streams(s, host);
1585     if (err)
1586         goto fail;
1587
1588     do {
1589         int lower_transport = ff_log2_tab[lower_transport_mask &
1590                                   ~(lower_transport_mask - 1)];
1591
1592         err = make_setup_request(s, host, port, lower_transport,
1593                                  rt->server_type == RTSP_SERVER_REAL ?
1594                                      real_challenge : NULL);
1595         if (err < 0)
1596             goto fail;
1597         lower_transport_mask &= ~(1 << lower_transport);
1598         if (lower_transport_mask == 0 && err == 1) {
1599             err = FF_NETERROR(EPROTONOSUPPORT);
1600             goto fail;
1601         }
1602     } while (err);
1603
1604     rt->state = RTSP_STATE_IDLE;
1605     rt->seek_timestamp = 0; /* default is to start stream at position zero */
1606     return 0;
1607  fail:
1608     ff_rtsp_close_streams(s);
1609     ff_rtsp_close_connections(s);
1610     if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1611         av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1612         av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1613                reply->status_code,
1614                s->filename);
1615         goto redirect;
1616     }
1617     ff_network_close();
1618     return err;
1619 }
1620 #endif
1621
1622 #if CONFIG_RTSP_DEMUXER
1623 static int rtsp_read_header(AVFormatContext *s,
1624                             AVFormatParameters *ap)
1625 {
1626     RTSPState *rt = s->priv_data;
1627     int ret;
1628
1629     ret = ff_rtsp_connect(s);
1630     if (ret)
1631         return ret;
1632
1633     rt->real_setup_cache = av_mallocz(2 * s->nb_streams * sizeof(*rt->real_setup_cache));
1634     if (!rt->real_setup_cache)
1635         return AVERROR(ENOMEM);
1636     rt->real_setup = rt->real_setup_cache + s->nb_streams * sizeof(*rt->real_setup);
1637
1638     if (ap->initial_pause) {
1639          /* do not start immediately */
1640     } else {
1641          if (rtsp_read_play(s) < 0) {
1642             ff_rtsp_close_streams(s);
1643             ff_rtsp_close_connections(s);
1644             return AVERROR_INVALIDDATA;
1645         }
1646     }
1647
1648     return 0;
1649 }
1650
1651 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1652                            uint8_t *buf, int buf_size)
1653 {
1654     RTSPState *rt = s->priv_data;
1655     RTSPStream *rtsp_st;
1656     fd_set rfds;
1657     int fd, fd_rtcp, fd_max, n, i, ret, tcp_fd, timeout_cnt = 0;
1658     struct timeval tv;
1659
1660     for (;;) {
1661         if (url_interrupt_cb())
1662             return AVERROR(EINTR);
1663         FD_ZERO(&rfds);
1664         if (rt->rtsp_hd) {
1665             tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1666             FD_SET(tcp_fd, &rfds);
1667         } else {
1668             fd_max = 0;
1669             tcp_fd = -1;
1670         }
1671         for (i = 0; i < rt->nb_rtsp_streams; i++) {
1672             rtsp_st = rt->rtsp_streams[i];
1673             if (rtsp_st->rtp_handle) {
1674                 fd = url_get_file_handle(rtsp_st->rtp_handle);
1675                 fd_rtcp = rtp_get_rtcp_file_handle(rtsp_st->rtp_handle);
1676                 if (FFMAX(fd, fd_rtcp) > fd_max)
1677                     fd_max = FFMAX(fd, fd_rtcp);
1678                 FD_SET(fd, &rfds);
1679                 FD_SET(fd_rtcp, &rfds);
1680             }
1681         }
1682         tv.tv_sec = 0;
1683         tv.tv_usec = SELECT_TIMEOUT_MS * 1000;
1684         n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1685         if (n > 0) {
1686             timeout_cnt = 0;
1687             for (i = 0; i < rt->nb_rtsp_streams; i++) {
1688                 rtsp_st = rt->rtsp_streams[i];
1689                 if (rtsp_st->rtp_handle) {
1690                     fd = url_get_file_handle(rtsp_st->rtp_handle);
1691                     fd_rtcp = rtp_get_rtcp_file_handle(rtsp_st->rtp_handle);
1692                     if (FD_ISSET(fd_rtcp, &rfds) || FD_ISSET(fd, &rfds)) {
1693                         ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1694                         if (ret > 0) {
1695                             *prtsp_st = rtsp_st;
1696                             return ret;
1697                         }
1698                     }
1699                 }
1700             }
1701 #if CONFIG_RTSP_DEMUXER
1702             if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1703                 RTSPMessageHeader reply;
1704
1705                 ret = ff_rtsp_read_reply(s, &reply, NULL, 0);
1706                 if (ret < 0)
1707                     return ret;
1708                 /* XXX: parse message */
1709                 if (rt->state != RTSP_STATE_STREAMING)
1710                     return 0;
1711             }
1712 #endif
1713         } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1714             return FF_NETERROR(ETIMEDOUT);
1715         } else if (n < 0 && errno != EINTR)
1716             return AVERROR(errno);
1717     }
1718 }
1719
1720 static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1721                            uint8_t *buf, int buf_size)
1722 {
1723     RTSPState *rt = s->priv_data;
1724     int id, len, i, ret;
1725     RTSPStream *rtsp_st;
1726
1727 #ifdef DEBUG_RTP_TCP
1728     dprintf(s, "tcp_read_packet:\n");
1729 #endif
1730 redo:
1731     for (;;) {
1732         RTSPMessageHeader reply;
1733
1734         ret = ff_rtsp_read_reply(s, &reply, NULL, 1);
1735         if (ret < 0)
1736             return ret;
1737         if (ret == 1) /* received '$' */
1738             break;
1739         /* XXX: parse message */
1740         if (rt->state != RTSP_STATE_STREAMING)
1741             return 0;
1742     }
1743     ret = url_read_complete(rt->rtsp_hd, buf, 3);
1744     if (ret != 3)
1745         return -1;
1746     id  = buf[0];
1747     len = AV_RB16(buf + 1);
1748 #ifdef DEBUG_RTP_TCP
1749     dprintf(s, "id=%d len=%d\n", id, len);
1750 #endif
1751     if (len > buf_size || len < 12)
1752         goto redo;
1753     /* get the data */
1754     ret = url_read_complete(rt->rtsp_hd, buf, len);
1755     if (ret != len)
1756         return -1;
1757     if (rt->transport == RTSP_TRANSPORT_RDT &&
1758         ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1759         return -1;
1760
1761     /* find the matching stream */
1762     for (i = 0; i < rt->nb_rtsp_streams; i++) {
1763         rtsp_st = rt->rtsp_streams[i];
1764         if (id >= rtsp_st->interleaved_min &&
1765             id <= rtsp_st->interleaved_max)
1766             goto found;
1767     }
1768     goto redo;
1769 found:
1770     *prtsp_st = rtsp_st;
1771     return len;
1772 }
1773
1774 static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1775 {
1776     RTSPState *rt = s->priv_data;
1777     int ret, len;
1778     uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1779     RTSPStream *rtsp_st;
1780
1781     if (rt->nb_byes == rt->nb_rtsp_streams)
1782         return AVERROR_EOF;
1783
1784     /* get next frames from the same RTP packet */
1785     if (rt->cur_transport_priv) {
1786         if (rt->transport == RTSP_TRANSPORT_RDT) {
1787             ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1788         } else
1789             ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1790         if (ret == 0) {
1791             rt->cur_transport_priv = NULL;
1792             return 0;
1793         } else if (ret == 1) {
1794             return 0;
1795         } else
1796             rt->cur_transport_priv = NULL;
1797     }
1798
1799     /* read next RTP packet */
1800  redo:
1801     switch(rt->lower_transport) {
1802     default:
1803 #if CONFIG_RTSP_DEMUXER
1804     case RTSP_LOWER_TRANSPORT_TCP:
1805         len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1806         break;
1807 #endif
1808     case RTSP_LOWER_TRANSPORT_UDP:
1809     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1810         len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1811         if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1812             rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1813         break;
1814     }
1815     if (len < 0)
1816         return len;
1817     if (len == 0)
1818         return AVERROR_EOF;
1819     if (rt->transport == RTSP_TRANSPORT_RDT) {
1820         ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1821     } else {
1822         ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1823         if (ret < 0) {
1824             /* Either bad packet, or a RTCP packet. Check if the
1825              * first_rtcp_ntp_time field was initialized. */
1826             RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1827             if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
1828                 /* first_rtcp_ntp_time has been initialized for this stream,
1829                  * copy the same value to all other uninitialized streams,
1830                  * in order to map their timestamp origin to the same ntp time
1831                  * as this one. */
1832                 int i;
1833                 for (i = 0; i < rt->nb_rtsp_streams; i++) {
1834                     RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
1835                     if (rtpctx2 &&
1836                         rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE)
1837                         rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
1838                 }
1839             }
1840             if (ret == -RTCP_BYE) {
1841                 rt->nb_byes++;
1842
1843                 av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
1844                        rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
1845
1846                 if (rt->nb_byes == rt->nb_rtsp_streams)
1847                     return AVERROR_EOF;
1848             }
1849         }
1850     }
1851     if (ret < 0)
1852         goto redo;
1853     if (ret == 1)
1854         /* more packets may follow, so we save the RTP context */
1855         rt->cur_transport_priv = rtsp_st->transport_priv;
1856
1857     return ret;
1858 }
1859
1860 static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1861 {
1862     RTSPState *rt = s->priv_data;
1863     int ret;
1864     RTSPMessageHeader reply1, *reply = &reply1;
1865     char cmd[1024];
1866
1867     if (rt->server_type == RTSP_SERVER_REAL) {
1868         int i;
1869
1870         for (i = 0; i < s->nb_streams; i++)
1871             rt->real_setup[i] = s->streams[i]->discard;
1872
1873         if (!rt->need_subscription) {
1874             if (memcmp (rt->real_setup, rt->real_setup_cache,
1875                         sizeof(enum AVDiscard) * s->nb_streams)) {
1876                 snprintf(cmd, sizeof(cmd),
1877                          "Unsubscribe: %s\r\n",
1878                          rt->last_subscription);
1879                 ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1880                                  cmd, reply, NULL);
1881                 if (reply->status_code != RTSP_STATUS_OK)
1882                     return AVERROR_INVALIDDATA;
1883                 rt->need_subscription = 1;
1884             }
1885         }
1886
1887         if (rt->need_subscription) {
1888             int r, rule_nr, first = 1;
1889
1890             memcpy(rt->real_setup_cache, rt->real_setup,
1891                    sizeof(enum AVDiscard) * s->nb_streams);
1892             rt->last_subscription[0] = 0;
1893
1894             snprintf(cmd, sizeof(cmd),
1895                      "Subscribe: ");
1896             for (i = 0; i < rt->nb_rtsp_streams; i++) {
1897                 rule_nr = 0;
1898                 for (r = 0; r < s->nb_streams; r++) {
1899                     if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1900                         if (s->streams[r]->discard != AVDISCARD_ALL) {
1901                             if (!first)
1902                                 av_strlcat(rt->last_subscription, ",",
1903                                            sizeof(rt->last_subscription));
1904                             ff_rdt_subscribe_rule(
1905                                 rt->last_subscription,
1906                                 sizeof(rt->last_subscription), i, rule_nr);
1907                             first = 0;
1908                         }
1909                         rule_nr++;
1910                     }
1911                 }
1912             }
1913             av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1914             ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
1915                              cmd, reply, NULL);
1916             if (reply->status_code != RTSP_STATUS_OK)
1917                 return AVERROR_INVALIDDATA;
1918             rt->need_subscription = 0;
1919
1920             if (rt->state == RTSP_STATE_STREAMING)
1921                 rtsp_read_play (s);
1922         }
1923     }
1924
1925     ret = rtsp_fetch_packet(s, pkt);
1926     if (ret < 0)
1927         return ret;
1928
1929     /* send dummy request to keep TCP connection alive */
1930     if ((av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1931         if (rt->server_type == RTSP_SERVER_WMS) {
1932             ff_rtsp_send_cmd_async(s, "GET_PARAMETER", rt->control_uri, NULL);
1933         } else {
1934             ff_rtsp_send_cmd_async(s, "OPTIONS", "*", NULL);
1935         }
1936     }
1937
1938     return 0;
1939 }
1940
1941 /* pause the stream */
1942 static int rtsp_read_pause(AVFormatContext *s)
1943 {
1944     RTSPState *rt = s->priv_data;
1945     RTSPMessageHeader reply1, *reply = &reply1;
1946
1947     if (rt->state != RTSP_STATE_STREAMING)
1948         return 0;
1949     else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1950         ff_rtsp_send_cmd(s, "PAUSE", rt->control_uri, NULL, reply, NULL);
1951         if (reply->status_code != RTSP_STATUS_OK) {
1952             return -1;
1953         }
1954     }
1955     rt->state = RTSP_STATE_PAUSED;
1956     return 0;
1957 }
1958
1959 static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1960                           int64_t timestamp, int flags)
1961 {
1962     RTSPState *rt = s->priv_data;
1963
1964     rt->seek_timestamp = av_rescale_q(timestamp,
1965                                       s->streams[stream_index]->time_base,
1966                                       AV_TIME_BASE_Q);
1967     switch(rt->state) {
1968     default:
1969     case RTSP_STATE_IDLE:
1970         break;
1971     case RTSP_STATE_STREAMING:
1972         if (rtsp_read_pause(s) != 0)
1973             return -1;
1974         rt->state = RTSP_STATE_SEEKING;
1975         if (rtsp_read_play(s) != 0)
1976             return -1;
1977         break;
1978     case RTSP_STATE_PAUSED:
1979         rt->state = RTSP_STATE_IDLE;
1980         break;
1981     }
1982     return 0;
1983 }
1984
1985 static int rtsp_read_close(AVFormatContext *s)
1986 {
1987     RTSPState *rt = s->priv_data;
1988
1989 #if 0
1990     /* NOTE: it is valid to flush the buffer here */
1991     if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1992         url_fclose(&rt->rtsp_gb);
1993     }
1994 #endif
1995     ff_rtsp_send_cmd_async(s, "TEARDOWN", rt->control_uri, NULL);
1996
1997     ff_rtsp_close_streams(s);
1998     ff_rtsp_close_connections(s);
1999     ff_network_close();
2000     rt->real_setup = NULL;
2001     av_freep(&rt->real_setup_cache);
2002     return 0;
2003 }
2004
2005 AVInputFormat rtsp_demuxer = {
2006     "rtsp",
2007     NULL_IF_CONFIG_SMALL("RTSP input format"),
2008     sizeof(RTSPState),
2009     rtsp_probe,
2010     rtsp_read_header,
2011     rtsp_read_packet,
2012     rtsp_read_close,
2013     rtsp_read_seek,
2014     .flags = AVFMT_NOFILE,
2015     .read_play = rtsp_read_play,
2016     .read_pause = rtsp_read_pause,
2017 };
2018 #endif
2019
2020 static int sdp_probe(AVProbeData *p1)
2021 {
2022     const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2023
2024     /* we look for a line beginning "c=IN IP" */
2025     while (p < p_end && *p != '\0') {
2026         if (p + sizeof("c=IN IP") - 1 < p_end &&
2027             av_strstart(p, "c=IN IP", NULL))
2028             return AVPROBE_SCORE_MAX / 2;
2029
2030         while (p < p_end - 1 && *p != '\n') p++;
2031         if (++p >= p_end)
2032             break;
2033         if (*p == '\r')
2034             p++;
2035     }
2036     return 0;
2037 }
2038
2039 static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
2040 {
2041     RTSPState *rt = s->priv_data;
2042     RTSPStream *rtsp_st;
2043     int size, i, err;
2044     char *content;
2045     char url[1024];
2046
2047     if (!ff_network_init())
2048         return AVERROR(EIO);
2049
2050     /* read the whole sdp file */
2051     /* XXX: better loading */
2052     content = av_malloc(SDP_MAX_SIZE);
2053     size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
2054     if (size <= 0) {
2055         av_free(content);
2056         return AVERROR_INVALIDDATA;
2057     }
2058     content[size] ='\0';
2059
2060     sdp_parse(s, content);
2061     av_free(content);
2062
2063     /* open each RTP stream */
2064     for (i = 0; i < rt->nb_rtsp_streams; i++) {
2065         char namebuf[50];
2066         rtsp_st = rt->rtsp_streams[i];
2067
2068         getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
2069                     namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2070         ff_url_join(url, sizeof(url), "rtp", NULL,
2071                     namebuf, rtsp_st->sdp_port,
2072                     "?localport=%d&ttl=%d", rtsp_st->sdp_port,
2073                     rtsp_st->sdp_ttl);
2074         if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
2075             err = AVERROR_INVALIDDATA;
2076             goto fail;
2077         }
2078         if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
2079             goto fail;
2080     }
2081     return 0;
2082 fail:
2083     ff_rtsp_close_streams(s);
2084     ff_network_close();
2085     return err;
2086 }
2087
2088 static int sdp_read_close(AVFormatContext *s)
2089 {
2090     ff_rtsp_close_streams(s);
2091     ff_network_close();
2092     return 0;
2093 }
2094
2095 AVInputFormat sdp_demuxer = {
2096     "sdp",
2097     NULL_IF_CONFIG_SMALL("SDP"),
2098     sizeof(RTSPState),
2099     sdp_probe,
2100     sdp_read_header,
2101     rtsp_fetch_packet,
2102     sdp_read_close,
2103 };