Add an RTSP muxer
[ffmpeg.git] / 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 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 (s->oformat) {
586                     AVFormatContext *rtpctx = rtsp_st->transport_priv;
587                     av_write_trailer(rtpctx);
588                     url_fclose(rtpctx->pb);
589                     av_metadata_free(&rtpctx->streams[0]->metadata);
590                     av_metadata_free(&rtpctx->metadata);
591                     av_free(rtpctx->streams[0]);
592                     av_free(rtpctx);
593                 } else if (rt->transport == RTSP_TRANSPORT_RDT)
594                     ff_rdt_parse_close(rtsp_st->transport_priv);
595                 else
596                     rtp_parse_close(rtsp_st->transport_priv);
597             }
598             if (rtsp_st->rtp_handle)
599                 url_close(rtsp_st->rtp_handle);
600             if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context)
601                 rtsp_st->dynamic_handler->close(
602                     rtsp_st->dynamic_protocol_context);
603         }
604     }
605     av_free(rt->rtsp_streams);
606     if (rt->asf_ctx) {
607         av_close_input_stream (rt->asf_ctx);
608         rt->asf_ctx = NULL;
609     }
610     av_freep(&rt->auth_b64);
611 }
612
613 static void *rtsp_rtp_mux_open(AVFormatContext *s, AVStream *st, URLContext *handle) {
614     AVFormatContext *rtpctx;
615     int ret;
616     AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
617
618     if (!rtp_format)
619         return NULL;
620
621     /* Allocate an AVFormatContext for each output stream */
622     rtpctx = avformat_alloc_context();
623     if (!rtpctx)
624         return NULL;
625
626     rtpctx->oformat = rtp_format;
627     if (!av_new_stream(rtpctx, 0)) {
628         av_free(rtpctx);
629         return NULL;
630     }
631     /* Copy the max delay setting; the rtp muxer reads this. */
632     rtpctx->max_delay = s->max_delay;
633     /* Copy other stream parameters. */
634     rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;
635
636     /* Remove the local codec, link to the original codec
637      * context instead, to give the rtp muxer access to
638      * codec parameters. */
639     av_free(rtpctx->streams[0]->codec);
640     rtpctx->streams[0]->codec = st->codec;
641
642     url_fdopen(&rtpctx->pb, handle);
643     ret = av_write_header(rtpctx);
644
645     if (ret) {
646         url_fclose(rtpctx->pb);
647         av_free(rtpctx->streams[0]);
648         av_free(rtpctx);
649         return NULL;
650     }
651
652     /* Copy the RTP AVStream timebase back to the original AVStream */
653     st->time_base = rtpctx->streams[0]->time_base;
654     return rtpctx;
655 }
656
657 static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
658 {
659     RTSPState *rt = s->priv_data;
660     AVStream *st = NULL;
661
662     /* open the RTP context */
663     if (rtsp_st->stream_index >= 0)
664         st = s->streams[rtsp_st->stream_index];
665     if (!st)
666         s->ctx_flags |= AVFMTCTX_NOHEADER;
667
668     if (s->oformat) {
669         rtsp_st->transport_priv = rtsp_rtp_mux_open(s, st, rtsp_st->rtp_handle);
670         /* Ownage of rtp_handle is passed to the rtp mux context */
671         rtsp_st->rtp_handle = NULL;
672     } else if (rt->transport == RTSP_TRANSPORT_RDT)
673         rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
674                                             rtsp_st->dynamic_protocol_context,
675                                             rtsp_st->dynamic_handler);
676     else
677         rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle,
678                                          rtsp_st->sdp_payload_type,
679                                          &rtsp_st->rtp_payload_data);
680
681     if (!rtsp_st->transport_priv) {
682          return AVERROR(ENOMEM);
683     } else if (rt->transport != RTSP_TRANSPORT_RDT) {
684         if (rtsp_st->dynamic_handler) {
685             rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
686                                            rtsp_st->dynamic_protocol_context,
687                                            rtsp_st->dynamic_handler);
688         }
689     }
690
691     return 0;
692 }
693
694 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
695 static int rtsp_probe(AVProbeData *p)
696 {
697     if (av_strstart(p->filename, "rtsp:", NULL))
698         return AVPROBE_SCORE_MAX;
699     return 0;
700 }
701
702 static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
703 {
704     const char *p;
705     int v;
706
707     p = *pp;
708     skip_spaces(&p);
709     v = strtol(p, (char **)&p, 10);
710     if (*p == '-') {
711         p++;
712         *min_ptr = v;
713         v = strtol(p, (char **)&p, 10);
714         *max_ptr = v;
715     } else {
716         *min_ptr = v;
717         *max_ptr = v;
718     }
719     *pp = p;
720 }
721
722 /* XXX: only one transport specification is parsed */
723 static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
724 {
725     char transport_protocol[16];
726     char profile[16];
727     char lower_transport[16];
728     char parameter[16];
729     RTSPTransportField *th;
730     char buf[256];
731
732     reply->nb_transports = 0;
733
734     for (;;) {
735         skip_spaces(&p);
736         if (*p == '\0')
737             break;
738
739         th = &reply->transports[reply->nb_transports];
740
741         get_word_sep(transport_protocol, sizeof(transport_protocol),
742                      "/", &p);
743         if (!strcasecmp (transport_protocol, "rtp")) {
744             get_word_sep(profile, sizeof(profile), "/;,", &p);
745             lower_transport[0] = '\0';
746             /* rtp/avp/<protocol> */
747             if (*p == '/') {
748                 get_word_sep(lower_transport, sizeof(lower_transport),
749                              ";,", &p);
750             }
751             th->transport = RTSP_TRANSPORT_RTP;
752         } else if (!strcasecmp (transport_protocol, "x-pn-tng") ||
753                    !strcasecmp (transport_protocol, "x-real-rdt")) {
754             /* x-pn-tng/<protocol> */
755             get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
756             profile[0] = '\0';
757             th->transport = RTSP_TRANSPORT_RDT;
758         }
759         if (!strcasecmp(lower_transport, "TCP"))
760             th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
761         else
762             th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
763
764         if (*p == ';')
765             p++;
766         /* get each parameter */
767         while (*p != '\0' && *p != ',') {
768             get_word_sep(parameter, sizeof(parameter), "=;,", &p);
769             if (!strcmp(parameter, "port")) {
770                 if (*p == '=') {
771                     p++;
772                     rtsp_parse_range(&th->port_min, &th->port_max, &p);
773                 }
774             } else if (!strcmp(parameter, "client_port")) {
775                 if (*p == '=') {
776                     p++;
777                     rtsp_parse_range(&th->client_port_min,
778                                      &th->client_port_max, &p);
779                 }
780             } else if (!strcmp(parameter, "server_port")) {
781                 if (*p == '=') {
782                     p++;
783                     rtsp_parse_range(&th->server_port_min,
784                                      &th->server_port_max, &p);
785                 }
786             } else if (!strcmp(parameter, "interleaved")) {
787                 if (*p == '=') {
788                     p++;
789                     rtsp_parse_range(&th->interleaved_min,
790                                      &th->interleaved_max, &p);
791                 }
792             } else if (!strcmp(parameter, "multicast")) {
793                 if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
794                     th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
795             } else if (!strcmp(parameter, "ttl")) {
796                 if (*p == '=') {
797                     p++;
798                     th->ttl = strtol(p, (char **)&p, 10);
799                 }
800             } else if (!strcmp(parameter, "destination")) {
801                 struct in_addr ipaddr;
802
803                 if (*p == '=') {
804                     p++;
805                     get_word_sep(buf, sizeof(buf), ";,", &p);
806                     if (inet_aton(buf, &ipaddr))
807                         th->destination = ntohl(ipaddr.s_addr);
808                 }
809             }
810             while (*p != ';' && *p != '\0' && *p != ',')
811                 p++;
812             if (*p == ';')
813                 p++;
814         }
815         if (*p == ',')
816             p++;
817
818         reply->nb_transports++;
819     }
820 }
821
822 void rtsp_parse_line(RTSPMessageHeader *reply, const char *buf)
823 {
824     const char *p;
825
826     /* NOTE: we do case independent match for broken servers */
827     p = buf;
828     if (av_stristart(p, "Session:", &p)) {
829         int t;
830         get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
831         if (av_stristart(p, ";timeout=", &p) &&
832             (t = strtol(p, NULL, 10)) > 0) {
833             reply->timeout = t;
834         }
835     } else if (av_stristart(p, "Content-Length:", &p)) {
836         reply->content_length = strtol(p, NULL, 10);
837     } else if (av_stristart(p, "Transport:", &p)) {
838         rtsp_parse_transport(reply, p);
839     } else if (av_stristart(p, "CSeq:", &p)) {
840         reply->seq = strtol(p, NULL, 10);
841     } else if (av_stristart(p, "Range:", &p)) {
842         rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
843     } else if (av_stristart(p, "RealChallenge1:", &p)) {
844         skip_spaces(&p);
845         av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
846     } else if (av_stristart(p, "Server:", &p)) {
847         skip_spaces(&p);
848         av_strlcpy(reply->server, p, sizeof(reply->server));
849     } else if (av_stristart(p, "Notice:", &p) ||
850                av_stristart(p, "X-Notice:", &p)) {
851         reply->notice = strtol(p, NULL, 10);
852     } else if (av_stristart(p, "Location:", &p)) {
853         skip_spaces(&p);
854         av_strlcpy(reply->location, p , sizeof(reply->location));
855     }
856 }
857
858 /* skip a RTP/TCP interleaved packet */
859 static void rtsp_skip_packet(AVFormatContext *s)
860 {
861     RTSPState *rt = s->priv_data;
862     int ret, len, len1;
863     uint8_t buf[1024];
864
865     ret = url_read_complete(rt->rtsp_hd, buf, 3);
866     if (ret != 3)
867         return;
868     len = AV_RB16(buf + 1);
869
870     dprintf(s, "skipping RTP packet len=%d\n", len);
871
872     /* skip payload */
873     while (len > 0) {
874         len1 = len;
875         if (len1 > sizeof(buf))
876             len1 = sizeof(buf);
877         ret = url_read_complete(rt->rtsp_hd, buf, len1);
878         if (ret != len1)
879             return;
880         len -= len1;
881     }
882 }
883
884 int rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
885                     unsigned char **content_ptr,
886                     int return_on_interleaved_data)
887 {
888     RTSPState *rt = s->priv_data;
889     char buf[4096], buf1[1024], *q;
890     unsigned char ch;
891     const char *p;
892     int ret, content_length, line_count = 0;
893     unsigned char *content = NULL;
894
895     memset(reply, 0, sizeof(*reply));
896
897     /* parse reply (XXX: use buffers) */
898     rt->last_reply[0] = '\0';
899     for (;;) {
900         q = buf;
901         for (;;) {
902             ret = url_read_complete(rt->rtsp_hd, &ch, 1);
903 #ifdef DEBUG_RTP_TCP
904             dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
905 #endif
906             if (ret != 1)
907                 return -1;
908             if (ch == '\n')
909                 break;
910             if (ch == '$') {
911                 /* XXX: only parse it if first char on line ? */
912                 if (return_on_interleaved_data) {
913                     return 1;
914                 } else
915                 rtsp_skip_packet(s);
916             } else if (ch != '\r') {
917                 if ((q - buf) < sizeof(buf) - 1)
918                     *q++ = ch;
919             }
920         }
921         *q = '\0';
922
923         dprintf(s, "line='%s'\n", buf);
924
925         /* test if last line */
926         if (buf[0] == '\0')
927             break;
928         p = buf;
929         if (line_count == 0) {
930             /* get reply code */
931             get_word(buf1, sizeof(buf1), &p);
932             get_word(buf1, sizeof(buf1), &p);
933             reply->status_code = atoi(buf1);
934         } else {
935             rtsp_parse_line(reply, p);
936             av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
937             av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
938         }
939         line_count++;
940     }
941
942     if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0')
943         av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
944
945     content_length = reply->content_length;
946     if (content_length > 0) {
947         /* leave some room for a trailing '\0' (useful for simple parsing) */
948         content = av_malloc(content_length + 1);
949         (void)url_read_complete(rt->rtsp_hd, content, content_length);
950         content[content_length] = '\0';
951     }
952     if (content_ptr)
953         *content_ptr = content;
954     else
955         av_free(content);
956
957     /* EOS */
958     if (reply->notice == 2101 /* End-of-Stream Reached */      ||
959         reply->notice == 2104 /* Start-of-Stream Reached */    ||
960         reply->notice == 2306 /* Continuous Feed Terminated */) {
961         rt->state = RTSP_STATE_IDLE;
962     } else if (reply->notice >= 4400 && reply->notice < 5500) {
963         return AVERROR(EIO); /* data or server error */
964     } else if (reply->notice == 2401 /* Ticket Expired */ ||
965              (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
966         return AVERROR(EPERM);
967
968     return 0;
969 }
970
971 void rtsp_send_cmd_with_content_async(AVFormatContext *s,
972                                       const char *cmd,
973                                       const unsigned char *send_content,
974                                       int send_content_length)
975 {
976     RTSPState *rt = s->priv_data;
977     char buf[4096], buf1[1024];
978
979     rt->seq++;
980     av_strlcpy(buf, cmd, sizeof(buf));
981     snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq);
982     av_strlcat(buf, buf1, sizeof(buf));
983     if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) {
984         snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id);
985         av_strlcat(buf, buf1, sizeof(buf));
986     }
987     if (rt->auth_b64)
988         av_strlcatf(buf, sizeof(buf),
989                     "Authorization: Basic %s\r\n",
990                     rt->auth_b64);
991     if (send_content_length > 0 && send_content)
992         av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
993     av_strlcat(buf, "\r\n", sizeof(buf));
994
995     dprintf(s, "Sending:\n%s--\n", buf);
996
997     url_write(rt->rtsp_hd, buf, strlen(buf));
998     if (send_content_length > 0 && send_content)
999         url_write(rt->rtsp_hd, send_content, send_content_length);
1000     rt->last_cmd_time = av_gettime();
1001 }
1002
1003 void rtsp_send_cmd_async(AVFormatContext *s, const char *cmd)
1004 {
1005     rtsp_send_cmd_with_content_async(s, cmd, NULL, 0);
1006 }
1007
1008 void rtsp_send_cmd(AVFormatContext *s,
1009                    const char *cmd, RTSPMessageHeader *reply,
1010                    unsigned char **content_ptr)
1011 {
1012     rtsp_send_cmd_async(s, cmd);
1013
1014     rtsp_read_reply(s, reply, content_ptr, 0);
1015 }
1016
1017 void rtsp_send_cmd_with_content(AVFormatContext *s,
1018                                 const char *cmd,
1019                                 RTSPMessageHeader *reply,
1020                                 unsigned char **content_ptr,
1021                                 const unsigned char *send_content,
1022                                 int send_content_length)
1023 {
1024     rtsp_send_cmd_with_content_async(s, cmd, send_content, send_content_length);
1025
1026     rtsp_read_reply(s, reply, content_ptr, 0);
1027 }
1028
1029 /**
1030  * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
1031  */
1032 static int make_setup_request(AVFormatContext *s, const char *host, int port,
1033                               int lower_transport, const char *real_challenge)
1034 {
1035     RTSPState *rt = s->priv_data;
1036     int rtx, j, i, err, interleave = 0;
1037     RTSPStream *rtsp_st;
1038     RTSPMessageHeader reply1, *reply = &reply1;
1039     char cmd[2048];
1040     const char *trans_pref;
1041
1042     if (rt->transport == RTSP_TRANSPORT_RDT)
1043         trans_pref = "x-pn-tng";
1044     else
1045         trans_pref = "RTP/AVP";
1046
1047     /* default timeout: 1 minute */
1048     rt->timeout = 60;
1049
1050     /* for each stream, make the setup request */
1051     /* XXX: we assume the same server is used for the control of each
1052      * RTSP stream */
1053
1054     for (j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) {
1055         char transport[2048];
1056
1057         /**
1058          * WMS serves all UDP data over a single connection, the RTX, which
1059          * isn't necessarily the first in the SDP but has to be the first
1060          * to be set up, else the second/third SETUP will fail with a 461.
1061          */
1062         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1063              rt->server_type == RTSP_SERVER_WMS) {
1064             if (i == 0) {
1065                 /* rtx first */
1066                 for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1067                     int len = strlen(rt->rtsp_streams[rtx]->control_url);
1068                     if (len >= 4 &&
1069                         !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1070                                 "/rtx"))
1071                         break;
1072                 }
1073                 if (rtx == rt->nb_rtsp_streams)
1074                     return -1; /* no RTX found */
1075                 rtsp_st = rt->rtsp_streams[rtx];
1076             } else
1077                 rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1078         } else
1079             rtsp_st = rt->rtsp_streams[i];
1080
1081         /* RTP/UDP */
1082         if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1083             char buf[256];
1084
1085             if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1086                 port = reply->transports[0].client_port_min;
1087                 goto have_port;
1088             }
1089
1090             /* first try in specified port range */
1091             if (RTSP_RTP_PORT_MIN != 0) {
1092                 while (j <= RTSP_RTP_PORT_MAX) {
1093                     snprintf(buf, sizeof(buf), "rtp://%s?localport=%d",
1094                              host, j);
1095                     /* we will use two ports per rtp stream (rtp and rtcp) */
1096                     j += 2;
1097                     if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0)
1098                         goto rtp_opened;
1099                 }
1100             }
1101
1102 #if 0
1103             /* then try on any port */
1104             if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
1105                 err = AVERROR_INVALIDDATA;
1106                 goto fail;
1107             }
1108 #endif
1109
1110         rtp_opened:
1111             port = rtp_get_local_port(rtsp_st->rtp_handle);
1112         have_port:
1113             snprintf(transport, sizeof(transport) - 1,
1114                      "%s/UDP;", trans_pref);
1115             if (rt->server_type != RTSP_SERVER_REAL)
1116                 av_strlcat(transport, "unicast;", sizeof(transport));
1117             av_strlcatf(transport, sizeof(transport),
1118                      "client_port=%d", port);
1119             if (rt->transport == RTSP_TRANSPORT_RTP &&
1120                 !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1121                 av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1122         }
1123
1124         /* RTP/TCP */
1125         else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1126             /** For WMS streams, the application streams are only used for
1127              * UDP. When trying to set it up for TCP streams, the server
1128              * will return an error. Therefore, we skip those streams. */
1129             if (rt->server_type == RTSP_SERVER_WMS &&
1130                 s->streams[rtsp_st->stream_index]->codec->codec_type ==
1131                     CODEC_TYPE_DATA)
1132                 continue;
1133             snprintf(transport, sizeof(transport) - 1,
1134                      "%s/TCP;", trans_pref);
1135             if (rt->server_type == RTSP_SERVER_WMS)
1136                 av_strlcat(transport, "unicast;", sizeof(transport));
1137             av_strlcatf(transport, sizeof(transport),
1138                         "interleaved=%d-%d",
1139                         interleave, interleave + 1);
1140             interleave += 2;
1141         }
1142
1143         else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1144             snprintf(transport, sizeof(transport) - 1,
1145                      "%s/UDP;multicast", trans_pref);
1146         }
1147         if (s->oformat) {
1148             av_strlcat(transport, ";mode=receive", sizeof(transport));
1149         } else if (rt->server_type == RTSP_SERVER_REAL ||
1150                    rt->server_type == RTSP_SERVER_WMS)
1151             av_strlcat(transport, ";mode=play", sizeof(transport));
1152         snprintf(cmd, sizeof(cmd),
1153                  "SETUP %s RTSP/1.0\r\n"
1154                  "Transport: %s\r\n",
1155                  rtsp_st->control_url, transport);
1156         if (i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1157             char real_res[41], real_csum[9];
1158             ff_rdt_calc_response_and_checksum(real_res, real_csum,
1159                                               real_challenge);
1160             av_strlcatf(cmd, sizeof(cmd),
1161                         "If-Match: %s\r\n"
1162                         "RealChallenge2: %s, sd=%s\r\n",
1163                         rt->session_id, real_res, real_csum);
1164         }
1165         rtsp_send_cmd(s, cmd, reply, NULL);
1166         if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1167             err = 1;
1168             goto fail;
1169         } else if (reply->status_code != RTSP_STATUS_OK ||
1170                    reply->nb_transports != 1) {
1171             err = AVERROR_INVALIDDATA;
1172             goto fail;
1173         }
1174
1175         /* XXX: same protocol for all streams is required */
1176         if (i > 0) {
1177             if (reply->transports[0].lower_transport != rt->lower_transport ||
1178                 reply->transports[0].transport != rt->transport) {
1179                 err = AVERROR_INVALIDDATA;
1180                 goto fail;
1181             }
1182         } else {
1183             rt->lower_transport = reply->transports[0].lower_transport;
1184             rt->transport = reply->transports[0].transport;
1185         }
1186
1187         /* close RTP connection if not choosen */
1188         if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP &&
1189             (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) {
1190             url_close(rtsp_st->rtp_handle);
1191             rtsp_st->rtp_handle = NULL;
1192         }
1193
1194         switch(reply->transports[0].lower_transport) {
1195         case RTSP_LOWER_TRANSPORT_TCP:
1196             rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1197             rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1198             break;
1199
1200         case RTSP_LOWER_TRANSPORT_UDP: {
1201             char url[1024];
1202
1203             /* XXX: also use address if specified */
1204             snprintf(url, sizeof(url), "rtp://%s:%d",
1205                      host, reply->transports[0].server_port_min);
1206             if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1207                 rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1208                 err = AVERROR_INVALIDDATA;
1209                 goto fail;
1210             }
1211             /* Try to initialize the connection state in a
1212              * potential NAT router by sending dummy packets.
1213              * RTP/RTCP dummy packets are used for RDT, too.
1214              */
1215             if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat)
1216                 rtp_send_punch_packets(rtsp_st->rtp_handle);
1217             break;
1218         }
1219         case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1220             char url[1024];
1221             struct in_addr in;
1222             int port, ttl;
1223
1224             if (reply->transports[0].destination) {
1225                 in.s_addr = htonl(reply->transports[0].destination);
1226                 port      = reply->transports[0].port_min;
1227                 ttl       = reply->transports[0].ttl;
1228             } else {
1229                 in        = rtsp_st->sdp_ip;
1230                 port      = rtsp_st->sdp_port;
1231                 ttl       = rtsp_st->sdp_ttl;
1232             }
1233             snprintf(url, sizeof(url), "rtp://%s:%d?ttl=%d",
1234                      inet_ntoa(in), port, ttl);
1235             if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1236                 err = AVERROR_INVALIDDATA;
1237                 goto fail;
1238             }
1239             break;
1240         }
1241         }
1242
1243         if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1244             goto fail;
1245     }
1246
1247     if (reply->timeout > 0)
1248         rt->timeout = reply->timeout;
1249
1250     if (rt->server_type == RTSP_SERVER_REAL)
1251         rt->need_subscription = 1;
1252
1253     return 0;
1254
1255 fail:
1256     for (i = 0; i < rt->nb_rtsp_streams; i++) {
1257         if (rt->rtsp_streams[i]->rtp_handle) {
1258             url_close(rt->rtsp_streams[i]->rtp_handle);
1259             rt->rtsp_streams[i]->rtp_handle = NULL;
1260         }
1261     }
1262     return err;
1263 }
1264
1265 static int rtsp_read_play(AVFormatContext *s)
1266 {
1267     RTSPState *rt = s->priv_data;
1268     RTSPMessageHeader reply1, *reply = &reply1;
1269     char cmd[1024];
1270
1271     av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state);
1272
1273     if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1274         if (rt->state == RTSP_STATE_PAUSED) {
1275             snprintf(cmd, sizeof(cmd),
1276                      "PLAY %s RTSP/1.0\r\n",
1277                      rt->control_uri);
1278         } else {
1279             snprintf(cmd, sizeof(cmd),
1280                      "PLAY %s RTSP/1.0\r\n"
1281                      "Range: npt=%0.3f-\r\n",
1282                      rt->control_uri,
1283                      (double)rt->seek_timestamp / AV_TIME_BASE);
1284         }
1285         rtsp_send_cmd(s, cmd, reply, NULL);
1286         if (reply->status_code != RTSP_STATUS_OK) {
1287             return -1;
1288         }
1289     }
1290     rt->state = RTSP_STATE_STREAMING;
1291     return 0;
1292 }
1293
1294 static int rtsp_setup_input_streams(AVFormatContext *s)
1295 {
1296     RTSPState *rt = s->priv_data;
1297     RTSPMessageHeader reply1, *reply = &reply1;
1298     char cmd[1024];
1299     unsigned char *content = NULL;
1300     int ret;
1301
1302     /* describe the stream */
1303     snprintf(cmd, sizeof(cmd),
1304              "DESCRIBE %s RTSP/1.0\r\n"
1305              "Accept: application/sdp\r\n",
1306              s->filename);
1307     if (rt->server_type == RTSP_SERVER_REAL) {
1308         /**
1309          * The Require: attribute is needed for proper streaming from
1310          * Realmedia servers.
1311          */
1312         av_strlcat(cmd,
1313                    "Require: com.real.retain-entity-for-setup\r\n",
1314                    sizeof(cmd));
1315     }
1316     rtsp_send_cmd(s, cmd, reply, &content);
1317     if (!content)
1318         return AVERROR_INVALIDDATA;
1319     if (reply->status_code != RTSP_STATUS_OK) {
1320         av_freep(&content);
1321         return AVERROR_INVALIDDATA;
1322     }
1323
1324     /* now we got the SDP description, we parse it */
1325     ret = sdp_parse(s, (const char *)content);
1326     av_freep(&content);
1327     if (ret < 0)
1328         return AVERROR_INVALIDDATA;
1329
1330     return 0;
1331 }
1332
1333 static int rtsp_setup_output_streams(AVFormatContext *s)
1334 {
1335     RTSPState *rt = s->priv_data;
1336     RTSPMessageHeader reply1, *reply = &reply1;
1337     char cmd[1024];
1338     int i;
1339     char *sdp;
1340
1341     /* Announce the stream */
1342     snprintf(cmd, sizeof(cmd),
1343              "ANNOUNCE %s RTSP/1.0\r\n"
1344              "Content-Type: application/sdp\r\n",
1345              s->filename);
1346     sdp = av_mallocz(8192);
1347     if (sdp == NULL)
1348         return AVERROR(ENOMEM);
1349     if (avf_sdp_create(&s, 1, sdp, 8192)) {
1350         av_free(sdp);
1351         return AVERROR_INVALIDDATA;
1352     }
1353     av_log(s, AV_LOG_INFO, "SDP:\n%s\n", sdp);
1354     rtsp_send_cmd_with_content(s, cmd, reply, NULL, sdp, strlen(sdp));
1355     av_free(sdp);
1356     if (reply->status_code != RTSP_STATUS_OK)
1357         return AVERROR_INVALIDDATA;
1358
1359     /* Set up the RTSPStreams for each AVStream */
1360     for (i = 0; i < s->nb_streams; i++) {
1361         RTSPStream *rtsp_st;
1362         AVStream *st = s->streams[i];
1363
1364         rtsp_st = av_mallocz(sizeof(RTSPStream));
1365         if (!rtsp_st)
1366             return AVERROR(ENOMEM);
1367         dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
1368
1369         st->priv_data = rtsp_st;
1370         rtsp_st->stream_index = i;
1371
1372         av_strlcpy(rtsp_st->control_url, s->filename, sizeof(rtsp_st->control_url));
1373         /* Note, this must match the relative uri set in the sdp content */
1374         av_strlcatf(rtsp_st->control_url, sizeof(rtsp_st->control_url),
1375                     "/streamid=%d", i);
1376     }
1377
1378     return 0;
1379 }
1380
1381 int rtsp_connect(AVFormatContext *s)
1382 {
1383     RTSPState *rt = s->priv_data;
1384     char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
1385     char *option_list, *option, *filename;
1386     URLContext *rtsp_hd;
1387     int port, err;
1388     RTSPMessageHeader reply1, *reply = &reply1;
1389     int lower_transport_mask = 0;
1390     char real_challenge[64];
1391 redirect:
1392     /* extract hostname and port */
1393     url_split(NULL, 0, auth, sizeof(auth),
1394               host, sizeof(host), &port, path, sizeof(path), s->filename);
1395     if (*auth) {
1396         int auth_len = strlen(auth), b64_len = ((auth_len + 2) / 3) * 4 + 1;
1397
1398         if (!(rt->auth_b64 = av_malloc(b64_len)))
1399             return AVERROR(ENOMEM);
1400         if (!av_base64_encode(rt->auth_b64, b64_len, auth, auth_len)) {
1401             err = AVERROR(EINVAL);
1402             goto fail;
1403         }
1404     }
1405     if (port < 0)
1406         port = RTSP_DEFAULT_PORT;
1407
1408     /* search for options */
1409     option_list = strchr(path, '?');
1410     if (option_list) {
1411         filename = strchr(s->filename, '?');
1412         while (option_list) {
1413             /* move the option pointer */
1414             option = ++option_list;
1415             option_list = strchr(option_list, '&');
1416             if (option_list)
1417                 *option_list = 0;
1418
1419             /* handle the options */
1420             if (!strcmp(option, "udp")) {
1421                 lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP);
1422             } else if (!strcmp(option, "multicast")) {
1423                 lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
1424             } else if (!strcmp(option, "tcp")) {
1425                 lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP);
1426             } else {
1427                 strcpy(++filename, option);
1428                 filename += strlen(option);
1429                 if (option_list) *filename = '&';
1430             }
1431         }
1432         *filename = 0;
1433     }
1434
1435     if (!lower_transport_mask)
1436         lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1437
1438     if (s->oformat) {
1439         /* Only UDP output is supported at the moment. */
1440         lower_transport_mask &= 1 << RTSP_LOWER_TRANSPORT_UDP;
1441         if (!lower_transport_mask) {
1442             av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1443                                     "only UDP is supported for output.\n");
1444             err = AVERROR(EINVAL);
1445             goto fail;
1446         }
1447     }
1448
1449     /* open the tcp connexion */
1450     snprintf(tcpname, sizeof(tcpname), "tcp://%s:%d", host, port);
1451     if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) {
1452         err = AVERROR(EIO);
1453         goto fail;
1454     }
1455     rt->rtsp_hd = rtsp_hd;
1456     rt->seq = 0;
1457
1458     /* request options supported by the server; this also detects server
1459      * type */
1460     av_strlcpy(rt->control_uri, s->filename,
1461                sizeof(rt->control_uri));
1462     for (rt->server_type = RTSP_SERVER_RTP;;) {
1463         snprintf(cmd, sizeof(cmd),
1464                  "OPTIONS %s RTSP/1.0\r\n", s->filename);
1465         if (rt->server_type == RTSP_SERVER_REAL)
1466             av_strlcat(cmd,
1467                        /**
1468                         * The following entries are required for proper
1469                         * streaming from a Realmedia server. They are
1470                         * interdependent in some way although we currently
1471                         * don't quite understand how. Values were copied
1472                         * from mplayer SVN r23589.
1473                         * @param CompanyID is a 16-byte ID in base64
1474                         * @param ClientChallenge is a 16-byte ID in hex
1475                         */
1476                        "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1477                        "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1478                        "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1479                        "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1480                        sizeof(cmd));
1481         rtsp_send_cmd(s, cmd, reply, NULL);
1482         if (reply->status_code != RTSP_STATUS_OK) {
1483             err = AVERROR_INVALIDDATA;
1484             goto fail;
1485         }
1486
1487         /* detect server type if not standard-compliant RTP */
1488         if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1489             rt->server_type = RTSP_SERVER_REAL;
1490             continue;
1491         } else if (!strncasecmp(reply->server, "WMServer/", 9)) {
1492             rt->server_type = RTSP_SERVER_WMS;
1493         } else if (rt->server_type == RTSP_SERVER_REAL)
1494             strcpy(real_challenge, reply->real_challenge);
1495         break;
1496     }
1497
1498     if (s->iformat)
1499         err = rtsp_setup_input_streams(s);
1500     else
1501         err = rtsp_setup_output_streams(s);
1502     if (err)
1503         goto fail;
1504
1505     do {
1506         int lower_transport = ff_log2_tab[lower_transport_mask &
1507                                   ~(lower_transport_mask - 1)];
1508
1509         err = make_setup_request(s, host, port, lower_transport,
1510                                  rt->server_type == RTSP_SERVER_REAL ?
1511                                      real_challenge : NULL);
1512         if (err < 0)
1513             goto fail;
1514         lower_transport_mask &= ~(1 << lower_transport);
1515         if (lower_transport_mask == 0 && err == 1) {
1516             err = AVERROR(FF_NETERROR(EPROTONOSUPPORT));
1517             goto fail;
1518         }
1519     } while (err);
1520
1521     rt->state = RTSP_STATE_IDLE;
1522     rt->seek_timestamp = 0; /* default is to start stream at position zero */
1523     return 0;
1524  fail:
1525     rtsp_close_streams(s);
1526     url_close(rt->rtsp_hd);
1527     if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1528         av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1529         av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1530                reply->status_code,
1531                s->filename);
1532         goto redirect;
1533     }
1534     return err;
1535 }
1536 #endif
1537
1538 #if CONFIG_RTSP_DEMUXER
1539 static int rtsp_read_header(AVFormatContext *s,
1540                             AVFormatParameters *ap)
1541 {
1542     RTSPState *rt = s->priv_data;
1543     int ret;
1544
1545     ret = rtsp_connect(s);
1546     if (ret)
1547         return ret;
1548
1549     if (ap->initial_pause) {
1550          /* do not start immediately */
1551     } else {
1552          if (rtsp_read_play(s) < 0) {
1553             rtsp_close_streams(s);
1554             url_close(rt->rtsp_hd);
1555             return AVERROR_INVALIDDATA;
1556         }
1557     }
1558
1559     return 0;
1560 }
1561
1562 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1563                            uint8_t *buf, int buf_size)
1564 {
1565     RTSPState *rt = s->priv_data;
1566     RTSPStream *rtsp_st;
1567     fd_set rfds;
1568     int fd, fd_max, n, i, ret, tcp_fd;
1569     struct timeval tv;
1570
1571     for (;;) {
1572         if (url_interrupt_cb())
1573             return AVERROR(EINTR);
1574         FD_ZERO(&rfds);
1575         if (rt->rtsp_hd) {
1576             tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
1577             FD_SET(tcp_fd, &rfds);
1578         } else {
1579             fd_max = 0;
1580             tcp_fd = -1;
1581         }
1582         for (i = 0; i < rt->nb_rtsp_streams; i++) {
1583             rtsp_st = rt->rtsp_streams[i];
1584             if (rtsp_st->rtp_handle) {
1585                 /* currently, we cannot probe RTCP handle because of
1586                  * blocking restrictions */
1587                 fd = url_get_file_handle(rtsp_st->rtp_handle);
1588                 if (fd > fd_max)
1589                     fd_max = fd;
1590                 FD_SET(fd, &rfds);
1591             }
1592         }
1593         tv.tv_sec = 0;
1594         tv.tv_usec = 100 * 1000;
1595         n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
1596         if (n > 0) {
1597             for (i = 0; i < rt->nb_rtsp_streams; i++) {
1598                 rtsp_st = rt->rtsp_streams[i];
1599                 if (rtsp_st->rtp_handle) {
1600                     fd = url_get_file_handle(rtsp_st->rtp_handle);
1601                     if (FD_ISSET(fd, &rfds)) {
1602                         ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
1603                         if (ret > 0) {
1604                             *prtsp_st = rtsp_st;
1605                             return ret;
1606                         }
1607                     }
1608                 }
1609             }
1610 #if CONFIG_RTSP_DEMUXER
1611             if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
1612                 RTSPMessageHeader reply;
1613
1614                 rtsp_read_reply(s, &reply, NULL, 0);
1615                 /* XXX: parse message */
1616                 if (rt->state != RTSP_STATE_STREAMING)
1617                     return 0;
1618             }
1619 #endif
1620         }
1621     }
1622 }
1623
1624 static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1625                            uint8_t *buf, int buf_size)
1626 {
1627     RTSPState *rt = s->priv_data;
1628     int id, len, i, ret;
1629     RTSPStream *rtsp_st;
1630
1631 #ifdef DEBUG_RTP_TCP
1632     dprintf(s, "tcp_read_packet:\n");
1633 #endif
1634 redo:
1635     for (;;) {
1636         RTSPMessageHeader reply;
1637
1638         ret = rtsp_read_reply(s, &reply, NULL, 1);
1639         if (ret == -1)
1640             return -1;
1641         if (ret == 1) /* received '$' */
1642             break;
1643         /* XXX: parse message */
1644         if (rt->state != RTSP_STATE_STREAMING)
1645             return 0;
1646     }
1647     ret = url_read_complete(rt->rtsp_hd, buf, 3);
1648     if (ret != 3)
1649         return -1;
1650     id  = buf[0];
1651     len = AV_RB16(buf + 1);
1652 #ifdef DEBUG_RTP_TCP
1653     dprintf(s, "id=%d len=%d\n", id, len);
1654 #endif
1655     if (len > buf_size || len < 12)
1656         goto redo;
1657     /* get the data */
1658     ret = url_read_complete(rt->rtsp_hd, buf, len);
1659     if (ret != len)
1660         return -1;
1661     if (rt->transport == RTSP_TRANSPORT_RDT &&
1662         ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
1663         return -1;
1664
1665     /* find the matching stream */
1666     for (i = 0; i < rt->nb_rtsp_streams; i++) {
1667         rtsp_st = rt->rtsp_streams[i];
1668         if (id >= rtsp_st->interleaved_min &&
1669             id <= rtsp_st->interleaved_max)
1670             goto found;
1671     }
1672     goto redo;
1673 found:
1674     *prtsp_st = rtsp_st;
1675     return len;
1676 }
1677
1678 static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
1679 {
1680     RTSPState *rt = s->priv_data;
1681     int ret, len;
1682     uint8_t buf[10 * RTP_MAX_PACKET_LENGTH];
1683     RTSPStream *rtsp_st;
1684
1685     /* get next frames from the same RTP packet */
1686     if (rt->cur_transport_priv) {
1687         if (rt->transport == RTSP_TRANSPORT_RDT) {
1688             ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1689         } else
1690             ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
1691         if (ret == 0) {
1692             rt->cur_transport_priv = NULL;
1693             return 0;
1694         } else if (ret == 1) {
1695             return 0;
1696         } else
1697             rt->cur_transport_priv = NULL;
1698     }
1699
1700     /* read next RTP packet */
1701  redo:
1702     switch(rt->lower_transport) {
1703     default:
1704 #if CONFIG_RTSP_DEMUXER
1705     case RTSP_LOWER_TRANSPORT_TCP:
1706         len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1707         break;
1708 #endif
1709     case RTSP_LOWER_TRANSPORT_UDP:
1710     case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
1711         len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf));
1712         if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
1713             rtp_check_and_send_back_rr(rtsp_st->transport_priv, len);
1714         break;
1715     }
1716     if (len < 0)
1717         return len;
1718     if (len == 0)
1719         return AVERROR_EOF;
1720     if (rt->transport == RTSP_TRANSPORT_RDT) {
1721         ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1722     } else
1723         ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len);
1724     if (ret < 0)
1725         goto redo;
1726     if (ret == 1)
1727         /* more packets may follow, so we save the RTP context */
1728         rt->cur_transport_priv = rtsp_st->transport_priv;
1729
1730     return ret;
1731 }
1732
1733 static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
1734 {
1735     RTSPState *rt = s->priv_data;
1736     int ret;
1737     RTSPMessageHeader reply1, *reply = &reply1;
1738     char cmd[1024];
1739
1740     if (rt->server_type == RTSP_SERVER_REAL) {
1741         int i;
1742         enum AVDiscard cache[MAX_STREAMS];
1743
1744         for (i = 0; i < s->nb_streams; i++)
1745             cache[i] = s->streams[i]->discard;
1746
1747         if (!rt->need_subscription) {
1748             if (memcmp (cache, rt->real_setup_cache,
1749                         sizeof(enum AVDiscard) * s->nb_streams)) {
1750                 snprintf(cmd, sizeof(cmd),
1751                          "SET_PARAMETER %s RTSP/1.0\r\n"
1752                          "Unsubscribe: %s\r\n",
1753                          rt->control_uri, rt->last_subscription);
1754                 rtsp_send_cmd(s, cmd, reply, NULL);
1755                 if (reply->status_code != RTSP_STATUS_OK)
1756                     return AVERROR_INVALIDDATA;
1757                 rt->need_subscription = 1;
1758             }
1759         }
1760
1761         if (rt->need_subscription) {
1762             int r, rule_nr, first = 1;
1763
1764             memcpy(rt->real_setup_cache, cache,
1765                    sizeof(enum AVDiscard) * s->nb_streams);
1766             rt->last_subscription[0] = 0;
1767
1768             snprintf(cmd, sizeof(cmd),
1769                      "SET_PARAMETER %s RTSP/1.0\r\n"
1770                      "Subscribe: ",
1771                      rt->control_uri);
1772             for (i = 0; i < rt->nb_rtsp_streams; i++) {
1773                 rule_nr = 0;
1774                 for (r = 0; r < s->nb_streams; r++) {
1775                     if (s->streams[r]->priv_data == rt->rtsp_streams[i]) {
1776                         if (s->streams[r]->discard != AVDISCARD_ALL) {
1777                             if (!first)
1778                                 av_strlcat(rt->last_subscription, ",",
1779                                            sizeof(rt->last_subscription));
1780                             ff_rdt_subscribe_rule(
1781                                 rt->last_subscription,
1782                                 sizeof(rt->last_subscription), i, rule_nr);
1783                             first = 0;
1784                         }
1785                         rule_nr++;
1786                     }
1787                 }
1788             }
1789             av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
1790             rtsp_send_cmd(s, cmd, reply, NULL);
1791             if (reply->status_code != RTSP_STATUS_OK)
1792                 return AVERROR_INVALIDDATA;
1793             rt->need_subscription = 0;
1794
1795             if (rt->state == RTSP_STATE_STREAMING)
1796                 rtsp_read_play (s);
1797         }
1798     }
1799
1800     ret = rtsp_fetch_packet(s, pkt);
1801     if (ret < 0)
1802         return ret;
1803
1804     /* send dummy request to keep TCP connection alive */
1805     if ((rt->server_type == RTSP_SERVER_WMS ||
1806          rt->server_type == RTSP_SERVER_REAL) &&
1807         (av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) {
1808         if (rt->server_type == RTSP_SERVER_WMS) {
1809             snprintf(cmd, sizeof(cmd) - 1,
1810                      "GET_PARAMETER %s RTSP/1.0\r\n",
1811                      rt->control_uri);
1812             rtsp_send_cmd_async(s, cmd);
1813         } else {
1814             rtsp_send_cmd_async(s, "OPTIONS * RTSP/1.0\r\n");
1815         }
1816     }
1817
1818     return 0;
1819 }
1820
1821 /* pause the stream */
1822 static int rtsp_read_pause(AVFormatContext *s)
1823 {
1824     RTSPState *rt = s->priv_data;
1825     RTSPMessageHeader reply1, *reply = &reply1;
1826     char cmd[1024];
1827
1828     rt = s->priv_data;
1829
1830     if (rt->state != RTSP_STATE_STREAMING)
1831         return 0;
1832     else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
1833         snprintf(cmd, sizeof(cmd),
1834                  "PAUSE %s RTSP/1.0\r\n",
1835                  rt->control_uri);
1836         rtsp_send_cmd(s, cmd, reply, NULL);
1837         if (reply->status_code != RTSP_STATUS_OK) {
1838             return -1;
1839         }
1840     }
1841     rt->state = RTSP_STATE_PAUSED;
1842     return 0;
1843 }
1844
1845 static int rtsp_read_seek(AVFormatContext *s, int stream_index,
1846                           int64_t timestamp, int flags)
1847 {
1848     RTSPState *rt = s->priv_data;
1849
1850     rt->seek_timestamp = av_rescale_q(timestamp,
1851                                       s->streams[stream_index]->time_base,
1852                                       AV_TIME_BASE_Q);
1853     switch(rt->state) {
1854     default:
1855     case RTSP_STATE_IDLE:
1856         break;
1857     case RTSP_STATE_STREAMING:
1858         if (rtsp_read_pause(s) != 0)
1859             return -1;
1860         rt->state = RTSP_STATE_SEEKING;
1861         if (rtsp_read_play(s) != 0)
1862             return -1;
1863         break;
1864     case RTSP_STATE_PAUSED:
1865         rt->state = RTSP_STATE_IDLE;
1866         break;
1867     }
1868     return 0;
1869 }
1870
1871 static int rtsp_read_close(AVFormatContext *s)
1872 {
1873     RTSPState *rt = s->priv_data;
1874     char cmd[1024];
1875
1876 #if 0
1877     /* NOTE: it is valid to flush the buffer here */
1878     if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1879         url_fclose(&rt->rtsp_gb);
1880     }
1881 #endif
1882     snprintf(cmd, sizeof(cmd),
1883              "TEARDOWN %s RTSP/1.0\r\n",
1884              s->filename);
1885     rtsp_send_cmd_async(s, cmd);
1886
1887     rtsp_close_streams(s);
1888     url_close(rt->rtsp_hd);
1889     return 0;
1890 }
1891
1892 AVInputFormat rtsp_demuxer = {
1893     "rtsp",
1894     NULL_IF_CONFIG_SMALL("RTSP input format"),
1895     sizeof(RTSPState),
1896     rtsp_probe,
1897     rtsp_read_header,
1898     rtsp_read_packet,
1899     rtsp_read_close,
1900     rtsp_read_seek,
1901     .flags = AVFMT_NOFILE,
1902     .read_play = rtsp_read_play,
1903     .read_pause = rtsp_read_pause,
1904 };
1905 #endif
1906
1907 static int sdp_probe(AVProbeData *p1)
1908 {
1909     const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
1910
1911     /* we look for a line beginning "c=IN IP4" */
1912     while (p < p_end && *p != '\0') {
1913         if (p + sizeof("c=IN IP4") - 1 < p_end &&
1914             av_strstart(p, "c=IN IP4", NULL))
1915             return AVPROBE_SCORE_MAX / 2;
1916
1917         while (p < p_end - 1 && *p != '\n') p++;
1918         if (++p >= p_end)
1919             break;
1920         if (*p == '\r')
1921             p++;
1922     }
1923     return 0;
1924 }
1925
1926 #define SDP_MAX_SIZE 8192
1927
1928 static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
1929 {
1930     RTSPState *rt = s->priv_data;
1931     RTSPStream *rtsp_st;
1932     int size, i, err;
1933     char *content;
1934     char url[1024];
1935
1936     /* read the whole sdp file */
1937     /* XXX: better loading */
1938     content = av_malloc(SDP_MAX_SIZE);
1939     size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1);
1940     if (size <= 0) {
1941         av_free(content);
1942         return AVERROR_INVALIDDATA;
1943     }
1944     content[size] ='\0';
1945
1946     sdp_parse(s, content);
1947     av_free(content);
1948
1949     /* open each RTP stream */
1950     for (i = 0; i < rt->nb_rtsp_streams; i++) {
1951         rtsp_st = rt->rtsp_streams[i];
1952
1953         snprintf(url, sizeof(url), "rtp://%s:%d?localport=%d&ttl=%d",
1954                  inet_ntoa(rtsp_st->sdp_ip),
1955                  rtsp_st->sdp_port,
1956                  rtsp_st->sdp_port,
1957                  rtsp_st->sdp_ttl);
1958         if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) {
1959             err = AVERROR_INVALIDDATA;
1960             goto fail;
1961         }
1962         if ((err = rtsp_open_transport_ctx(s, rtsp_st)))
1963             goto fail;
1964     }
1965     return 0;
1966 fail:
1967     rtsp_close_streams(s);
1968     return err;
1969 }
1970
1971 static int sdp_read_close(AVFormatContext *s)
1972 {
1973     rtsp_close_streams(s);
1974     return 0;
1975 }
1976
1977 AVInputFormat sdp_demuxer = {
1978     "sdp",
1979     NULL_IF_CONFIG_SMALL("SDP"),
1980     sizeof(RTSPState),
1981     sdp_probe,
1982     sdp_read_header,
1983     rtsp_fetch_packet,
1984     sdp_read_close,
1985 };