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