3 * Copyright (c) 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/avassert.h"
23 #include "libavutil/base64.h"
24 #include "libavutil/avstring.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/parseutils.h"
28 #include "libavutil/random_seed.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/time.h"
33 #include "avio_internal.h"
40 #include "os_support.h"
47 #include "rtpdec_formats.h"
48 #include "rtpenc_chain.h"
53 /* Timeout values for socket poll, in ms,
54 * and read_packet(), in seconds */
55 #define POLL_TIMEOUT_MS 100
56 #define READ_PACKET_TIMEOUT_S 10
57 #define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS
58 #define SDP_MAX_SIZE 16384
59 #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
60 #define DEFAULT_REORDERING_DELAY 100000
62 #define OFFSET(x) offsetof(RTSPState, x)
63 #define DEC AV_OPT_FLAG_DECODING_PARAM
64 #define ENC AV_OPT_FLAG_ENCODING_PARAM
66 #define RTSP_FLAG_OPTS(name, longname) \
67 { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \
68 { "filter_src", "only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, "rtsp_flags" }
70 #define RTSP_MEDIATYPE_OPTS(name, longname) \
71 { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_DATA+1)) - 1 }, INT_MIN, INT_MAX, DEC, "allowed_media_types" }, \
72 { "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \
73 { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \
74 { "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" }
76 #define RTSP_REORDERING_OPTS() \
77 { "reorder_queue_size", "set number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }
79 const AVOption ff_rtsp_options
[] = {
80 { "initial_pause", "do not start playing the stream immediately", OFFSET(initial_pause
), AV_OPT_TYPE_INT
, {.i64
= 0}, 0, 1, DEC
},
81 FF_RTP_FLAG_OPTS(RTSPState
, rtp_muxer_flags
),
82 { "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask
), AV_OPT_TYPE_FLAGS
, {.i64
= 0}, INT_MIN
, INT_MAX
, DEC
|ENC
, "rtsp_transport" }, \
83 { "udp", "UDP", 0, AV_OPT_TYPE_CONST
, {.i64
= 1 << RTSP_LOWER_TRANSPORT_UDP
}, 0, 0, DEC
|ENC
, "rtsp_transport" }, \
84 { "tcp", "TCP", 0, AV_OPT_TYPE_CONST
, {.i64
= 1 << RTSP_LOWER_TRANSPORT_TCP
}, 0, 0, DEC
|ENC
, "rtsp_transport" }, \
85 { "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST
, {.i64
= 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST
}, 0, 0, DEC
, "rtsp_transport" },
86 { "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST
, {.i64
= (1 << RTSP_LOWER_TRANSPORT_HTTP
)}, 0, 0, DEC
, "rtsp_transport" },
87 RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),
88 { "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST
, {.i64
= RTSP_FLAG_LISTEN
}, 0, 0, DEC
, "rtsp_flags" },
89 { "prefer_tcp", "try RTP via TCP first, if available", 0, AV_OPT_TYPE_CONST
, {.i64
= RTSP_FLAG_PREFER_TCP
}, 0, 0, DEC
|ENC
, "rtsp_flags" },
90 RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
91 { "min_port", "set minimum local UDP port", OFFSET(rtp_port_min
), AV_OPT_TYPE_INT
, {.i64
= RTSP_RTP_PORT_MIN
}, 0, 65535, DEC
|ENC
},
92 { "max_port", "set maximum local UDP port", OFFSET(rtp_port_max
), AV_OPT_TYPE_INT
, {.i64
= RTSP_RTP_PORT_MAX
}, 0, 65535, DEC
|ENC
},
93 { "timeout", "set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen)", OFFSET(initial_timeout
), AV_OPT_TYPE_INT
, {.i64
= -1}, INT_MIN
, INT_MAX
, DEC
},
94 { "stimeout", "set timeout (in microseconds) of socket TCP I/O operations", OFFSET(stimeout
), AV_OPT_TYPE_INT
, {.i64
= 0}, INT_MIN
, INT_MAX
, DEC
},
95 RTSP_REORDERING_OPTS(),
96 { "user-agent", "override User-Agent header", OFFSET(user_agent
), AV_OPT_TYPE_STRING
, {.str
= LIBAVFORMAT_IDENT
}, 0, 0, DEC
},
100 static const AVOption sdp_options
[] = {
101 RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
102 { "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST
, {.i64
= RTSP_FLAG_CUSTOM_IO
}, 0, 0, DEC
, "rtsp_flags" },
103 { "rtcp_to_source", "send RTCP packets to the source address of received packets", 0, AV_OPT_TYPE_CONST
, {.i64
= RTSP_FLAG_RTCP_TO_SOURCE
}, 0, 0, DEC
, "rtsp_flags" },
104 RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
105 RTSP_REORDERING_OPTS(),
109 static const AVOption rtp_options
[] = {
110 RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
111 RTSP_REORDERING_OPTS(),
115 static void get_word_until_chars(char *buf
, int buf_size
,
116 const char *sep
, const char **pp
)
122 p
+= strspn(p
, SPACE_CHARS
);
124 while (!strchr(sep
, *p
) && *p
!= '\0') {
125 if ((q
- buf
) < buf_size
- 1)
134 static void get_word_sep(char *buf
, int buf_size
, const char *sep
,
137 if (**pp
== '/') (*pp
)++;
138 get_word_until_chars(buf
, buf_size
, sep
, pp
);
141 static void get_word(char *buf
, int buf_size
, const char **pp
)
143 get_word_until_chars(buf
, buf_size
, SPACE_CHARS
, pp
);
146 /** Parse a string p in the form of Range:npt=xx-xx, and determine the start
148 * Used for seeking in the rtp stream.
150 static void rtsp_parse_range_npt(const char *p
, int64_t *start
, int64_t *end
)
154 p
+= strspn(p
, SPACE_CHARS
);
155 if (!av_stristart(p
, "npt=", &p
))
158 *start
= AV_NOPTS_VALUE
;
159 *end
= AV_NOPTS_VALUE
;
161 get_word_sep(buf
, sizeof(buf
), "-", &p
);
162 av_parse_time(start
, buf
, 1);
165 get_word_sep(buf
, sizeof(buf
), "-", &p
);
166 av_parse_time(end
, buf
, 1);
170 static int get_sockaddr(const char *buf
, struct sockaddr_storage
*sock
)
172 struct addrinfo hints
= { 0 }, *ai
= NULL
;
173 hints
.ai_flags
= AI_NUMERICHOST
;
174 if (getaddrinfo(buf
, NULL
, &hints
, &ai
))
176 memcpy(sock
, ai
->ai_addr
, FFMIN(sizeof(*sock
), ai
->ai_addrlen
));
182 static void init_rtp_handler(RTPDynamicProtocolHandler
*handler
,
183 RTSPStream
*rtsp_st
, AVCodecContext
*codec
)
188 codec
->codec_id
= handler
->codec_id
;
189 rtsp_st
->dynamic_handler
= handler
;
190 if (handler
->alloc
) {
191 rtsp_st
->dynamic_protocol_context
= handler
->alloc();
192 if (!rtsp_st
->dynamic_protocol_context
)
193 rtsp_st
->dynamic_handler
= NULL
;
197 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
198 static int sdp_parse_rtpmap(AVFormatContext
*s
,
199 AVStream
*st
, RTSPStream
*rtsp_st
,
200 int payload_type
, const char *p
)
202 AVCodecContext
*codec
= st
->codec
;
208 /* See if we can handle this kind of payload.
209 * The space should normally not be there but some Real streams or
210 * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
211 * have a trailing space. */
212 get_word_sep(buf
, sizeof(buf
), "/ ", &p
);
213 if (payload_type
< RTP_PT_PRIVATE
) {
214 /* We are in a standard case
215 * (from http://www.iana.org/assignments/rtp-parameters). */
216 codec
->codec_id
= ff_rtp_codec_id(buf
, codec
->codec_type
);
219 if (codec
->codec_id
== AV_CODEC_ID_NONE
) {
220 RTPDynamicProtocolHandler
*handler
=
221 ff_rtp_handler_find_by_name(buf
, codec
->codec_type
);
222 init_rtp_handler(handler
, rtsp_st
, codec
);
223 /* If no dynamic handler was found, check with the list of standard
224 * allocated types, if such a stream for some reason happens to
225 * use a private payload type. This isn't handled in rtpdec.c, since
226 * the format name from the rtpmap line never is passed into rtpdec. */
227 if (!rtsp_st
->dynamic_handler
)
228 codec
->codec_id
= ff_rtp_codec_id(buf
, codec
->codec_type
);
231 c
= avcodec_find_decoder(codec
->codec_id
);
237 get_word_sep(buf
, sizeof(buf
), "/", &p
);
239 switch (codec
->codec_type
) {
240 case AVMEDIA_TYPE_AUDIO
:
241 av_log(s
, AV_LOG_DEBUG
, "audio codec set to: %s\n", c_name
);
242 codec
->sample_rate
= RTSP_DEFAULT_AUDIO_SAMPLERATE
;
243 codec
->channels
= RTSP_DEFAULT_NB_AUDIO_CHANNELS
;
245 codec
->sample_rate
= i
;
246 avpriv_set_pts_info(st
, 32, 1, codec
->sample_rate
);
247 get_word_sep(buf
, sizeof(buf
), "/", &p
);
252 av_log(s
, AV_LOG_DEBUG
, "audio samplerate set to: %i\n",
254 av_log(s
, AV_LOG_DEBUG
, "audio channels set to: %i\n",
257 case AVMEDIA_TYPE_VIDEO
:
258 av_log(s
, AV_LOG_DEBUG
, "video codec set to: %s\n", c_name
);
260 avpriv_set_pts_info(st
, 32, 1, i
);
265 if (rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_handler
->init
)
266 rtsp_st
->dynamic_handler
->init(s
, st
->index
,
267 rtsp_st
->dynamic_protocol_context
);
271 /* parse the attribute line from the fmtp a line of an sdp response. This
272 * is broken out as a function because it is used in rtp_h264.c, which is
274 int ff_rtsp_next_attr_and_value(const char **p
, char *attr
, int attr_size
,
275 char *value
, int value_size
)
277 *p
+= strspn(*p
, SPACE_CHARS
);
279 get_word_sep(attr
, attr_size
, "=", p
);
282 get_word_sep(value
, value_size
, ";", p
);
290 typedef struct SDPParseState
{
292 struct sockaddr_storage default_ip
;
294 int skip_media
; ///< set if an unknown m= line occurs
295 int nb_default_include_source_addrs
; /**< Number of source-specific multicast include source IP address (from SDP content) */
296 struct RTSPSource
**default_include_source_addrs
; /**< Source-specific multicast include source IP address (from SDP content) */
297 int nb_default_exclude_source_addrs
; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
298 struct RTSPSource
**default_exclude_source_addrs
; /**< Source-specific multicast exclude source IP address (from SDP content) */
301 char delayed_fmtp
[2048];
304 static void copy_default_source_addrs(struct RTSPSource
**addrs
, int count
,
305 struct RTSPSource
***dest
, int *dest_count
)
307 RTSPSource
*rtsp_src
, *rtsp_src2
;
309 for (i
= 0; i
< count
; i
++) {
311 rtsp_src2
= av_malloc(sizeof(*rtsp_src2
));
314 memcpy(rtsp_src2
, rtsp_src
, sizeof(*rtsp_src
));
315 dynarray_add(dest
, dest_count
, rtsp_src2
);
319 static void parse_fmtp(AVFormatContext
*s
, RTSPState
*rt
,
320 int payload_type
, const char *line
)
324 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
325 RTSPStream
*rtsp_st
= rt
->rtsp_streams
[i
];
326 if (rtsp_st
->sdp_payload_type
== payload_type
&&
327 rtsp_st
->dynamic_handler
&&
328 rtsp_st
->dynamic_handler
->parse_sdp_a_line
) {
329 rtsp_st
->dynamic_handler
->parse_sdp_a_line(s
, i
,
330 rtsp_st
->dynamic_protocol_context
, line
);
335 static void sdp_parse_line(AVFormatContext
*s
, SDPParseState
*s1
,
336 int letter
, const char *buf
)
338 RTSPState
*rt
= s
->priv_data
;
339 char buf1
[64], st_type
[64];
341 enum AVMediaType codec_type
;
345 RTSPSource
*rtsp_src
;
346 struct sockaddr_storage sdp_ip
;
349 av_dlog(s
, "sdp: %c='%s'\n", letter
, buf
);
352 if (s1
->skip_media
&& letter
!= 'm')
356 get_word(buf1
, sizeof(buf1
), &p
);
357 if (strcmp(buf1
, "IN") != 0)
359 get_word(buf1
, sizeof(buf1
), &p
);
360 if (strcmp(buf1
, "IP4") && strcmp(buf1
, "IP6"))
362 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
363 if (get_sockaddr(buf1
, &sdp_ip
))
368 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
371 if (s
->nb_streams
== 0) {
372 s1
->default_ip
= sdp_ip
;
373 s1
->default_ttl
= ttl
;
375 rtsp_st
= rt
->rtsp_streams
[rt
->nb_rtsp_streams
- 1];
376 rtsp_st
->sdp_ip
= sdp_ip
;
377 rtsp_st
->sdp_ttl
= ttl
;
381 av_dict_set(&s
->metadata
, "title", p
, 0);
384 if (s
->nb_streams
== 0) {
385 av_dict_set(&s
->metadata
, "comment", p
, 0);
394 codec_type
= AVMEDIA_TYPE_UNKNOWN
;
395 get_word(st_type
, sizeof(st_type
), &p
);
396 if (!strcmp(st_type
, "audio")) {
397 codec_type
= AVMEDIA_TYPE_AUDIO
;
398 } else if (!strcmp(st_type
, "video")) {
399 codec_type
= AVMEDIA_TYPE_VIDEO
;
400 } else if (!strcmp(st_type
, "application")) {
401 codec_type
= AVMEDIA_TYPE_DATA
;
403 if (codec_type
== AVMEDIA_TYPE_UNKNOWN
|| !(rt
->media_type_mask
& (1 << codec_type
))) {
407 rtsp_st
= av_mallocz(sizeof(RTSPStream
));
410 rtsp_st
->stream_index
= -1;
411 dynarray_add(&rt
->rtsp_streams
, &rt
->nb_rtsp_streams
, rtsp_st
);
413 rtsp_st
->sdp_ip
= s1
->default_ip
;
414 rtsp_st
->sdp_ttl
= s1
->default_ttl
;
416 copy_default_source_addrs(s1
->default_include_source_addrs
,
417 s1
->nb_default_include_source_addrs
,
418 &rtsp_st
->include_source_addrs
,
419 &rtsp_st
->nb_include_source_addrs
);
420 copy_default_source_addrs(s1
->default_exclude_source_addrs
,
421 s1
->nb_default_exclude_source_addrs
,
422 &rtsp_st
->exclude_source_addrs
,
423 &rtsp_st
->nb_exclude_source_addrs
);
425 get_word(buf1
, sizeof(buf1
), &p
); /* port */
426 rtsp_st
->sdp_port
= atoi(buf1
);
428 get_word(buf1
, sizeof(buf1
), &p
); /* protocol */
429 if (!strcmp(buf1
, "udp"))
430 rt
->transport
= RTSP_TRANSPORT_RAW
;
431 else if (strstr(buf1
, "/AVPF") || strstr(buf1
, "/SAVPF"))
432 rtsp_st
->feedback
= 1;
434 /* XXX: handle list of formats */
435 get_word(buf1
, sizeof(buf1
), &p
); /* format list */
436 rtsp_st
->sdp_payload_type
= atoi(buf1
);
438 if (!strcmp(ff_rtp_enc_name(rtsp_st
->sdp_payload_type
), "MP2T")) {
439 /* no corresponding stream */
440 if (rt
->transport
== RTSP_TRANSPORT_RAW
) {
441 if (CONFIG_RTPDEC
&& !rt
->ts
)
442 rt
->ts
= avpriv_mpegts_parse_open(s
);
444 RTPDynamicProtocolHandler
*handler
;
445 handler
= ff_rtp_handler_find_by_id(
446 rtsp_st
->sdp_payload_type
, AVMEDIA_TYPE_DATA
);
447 init_rtp_handler(handler
, rtsp_st
, NULL
);
448 if (handler
&& handler
->init
)
449 handler
->init(s
, -1, rtsp_st
->dynamic_protocol_context
);
451 } else if (rt
->server_type
== RTSP_SERVER_WMS
&&
452 codec_type
== AVMEDIA_TYPE_DATA
) {
453 /* RTX stream, a stream that carries all the other actual
454 * audio/video streams. Don't expose this to the callers. */
456 st
= avformat_new_stream(s
, NULL
);
459 st
->id
= rt
->nb_rtsp_streams
- 1;
460 rtsp_st
->stream_index
= st
->index
;
461 st
->codec
->codec_type
= codec_type
;
462 if (rtsp_st
->sdp_payload_type
< RTP_PT_PRIVATE
) {
463 RTPDynamicProtocolHandler
*handler
;
464 /* if standard payload type, we can find the codec right now */
465 ff_rtp_get_codec_info(st
->codec
, rtsp_st
->sdp_payload_type
);
466 if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
&&
467 st
->codec
->sample_rate
> 0)
468 avpriv_set_pts_info(st
, 32, 1, st
->codec
->sample_rate
);
469 /* Even static payload types may need a custom depacketizer */
470 handler
= ff_rtp_handler_find_by_id(
471 rtsp_st
->sdp_payload_type
, st
->codec
->codec_type
);
472 init_rtp_handler(handler
, rtsp_st
, st
->codec
);
473 if (handler
&& handler
->init
)
474 handler
->init(s
, st
->index
,
475 rtsp_st
->dynamic_protocol_context
);
478 /* put a default control url */
479 av_strlcpy(rtsp_st
->control_url
, rt
->control_uri
,
480 sizeof(rtsp_st
->control_url
));
483 if (av_strstart(p
, "control:", &p
)) {
484 if (s
->nb_streams
== 0) {
485 if (!strncmp(p
, "rtsp://", 7))
486 av_strlcpy(rt
->control_uri
, p
,
487 sizeof(rt
->control_uri
));
490 /* get the control url */
491 rtsp_st
= rt
->rtsp_streams
[rt
->nb_rtsp_streams
- 1];
493 /* XXX: may need to add full url resolution */
494 av_url_split(proto
, sizeof(proto
), NULL
, 0, NULL
, 0,
496 if (proto
[0] == '\0') {
497 /* relative control URL */
498 if (rtsp_st
->control_url
[strlen(rtsp_st
->control_url
)-1]!='/')
499 av_strlcat(rtsp_st
->control_url
, "/",
500 sizeof(rtsp_st
->control_url
));
501 av_strlcat(rtsp_st
->control_url
, p
,
502 sizeof(rtsp_st
->control_url
));
504 av_strlcpy(rtsp_st
->control_url
, p
,
505 sizeof(rtsp_st
->control_url
));
507 } else if (av_strstart(p
, "rtpmap:", &p
) && s
->nb_streams
> 0) {
508 /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
509 get_word(buf1
, sizeof(buf1
), &p
);
510 payload_type
= atoi(buf1
);
511 rtsp_st
= rt
->rtsp_streams
[rt
->nb_rtsp_streams
- 1];
512 if (rtsp_st
->stream_index
>= 0) {
513 st
= s
->streams
[rtsp_st
->stream_index
];
514 sdp_parse_rtpmap(s
, st
, rtsp_st
, payload_type
, p
);
518 parse_fmtp(s
, rt
, payload_type
, s1
->delayed_fmtp
);
520 } else if (av_strstart(p
, "fmtp:", &p
) ||
521 av_strstart(p
, "framesize:", &p
)) {
522 // let dynamic protocol handlers have a stab at the line.
523 get_word(buf1
, sizeof(buf1
), &p
);
524 payload_type
= atoi(buf1
);
525 if (s1
->seen_rtpmap
) {
526 parse_fmtp(s
, rt
, payload_type
, buf
);
529 av_strlcpy(s1
->delayed_fmtp
, buf
, sizeof(s1
->delayed_fmtp
));
531 } else if (av_strstart(p
, "range:", &p
)) {
534 // this is so that seeking on a streamed file can work.
535 rtsp_parse_range_npt(p
, &start
, &end
);
536 s
->start_time
= start
;
537 /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
538 s
->duration
= (end
== AV_NOPTS_VALUE
) ?
539 AV_NOPTS_VALUE
: end
- start
;
540 } else if (av_strstart(p
, "IsRealDataType:integer;",&p
)) {
542 rt
->transport
= RTSP_TRANSPORT_RDT
;
543 } else if (av_strstart(p
, "SampleRate:integer;", &p
) &&
545 st
= s
->streams
[s
->nb_streams
- 1];
546 st
->codec
->sample_rate
= atoi(p
);
547 } else if (av_strstart(p
, "crypto:", &p
) && s
->nb_streams
> 0) {
549 rtsp_st
= rt
->rtsp_streams
[rt
->nb_rtsp_streams
- 1];
550 get_word(buf1
, sizeof(buf1
), &p
); // ignore tag
551 get_word(rtsp_st
->crypto_suite
, sizeof(rtsp_st
->crypto_suite
), &p
);
552 p
+= strspn(p
, SPACE_CHARS
);
553 if (av_strstart(p
, "inline:", &p
))
554 get_word(rtsp_st
->crypto_params
, sizeof(rtsp_st
->crypto_params
), &p
);
555 } else if (av_strstart(p
, "source-filter:", &p
)) {
557 get_word(buf1
, sizeof(buf1
), &p
);
558 if (strcmp(buf1
, "incl") && strcmp(buf1
, "excl"))
560 exclude
= !strcmp(buf1
, "excl");
562 get_word(buf1
, sizeof(buf1
), &p
);
563 if (strcmp(buf1
, "IN") != 0)
565 get_word(buf1
, sizeof(buf1
), &p
);
566 if (strcmp(buf1
, "IP4") && strcmp(buf1
, "IP6") && strcmp(buf1
, "*"))
568 // not checking that the destination address actually matches or is wildcard
569 get_word(buf1
, sizeof(buf1
), &p
);
572 rtsp_src
= av_mallocz(sizeof(*rtsp_src
));
575 get_word(rtsp_src
->addr
, sizeof(rtsp_src
->addr
), &p
);
577 if (s
->nb_streams
== 0) {
578 dynarray_add(&s1
->default_exclude_source_addrs
, &s1
->nb_default_exclude_source_addrs
, rtsp_src
);
580 rtsp_st
= rt
->rtsp_streams
[rt
->nb_rtsp_streams
- 1];
581 dynarray_add(&rtsp_st
->exclude_source_addrs
, &rtsp_st
->nb_exclude_source_addrs
, rtsp_src
);
584 if (s
->nb_streams
== 0) {
585 dynarray_add(&s1
->default_include_source_addrs
, &s1
->nb_default_include_source_addrs
, rtsp_src
);
587 rtsp_st
= rt
->rtsp_streams
[rt
->nb_rtsp_streams
- 1];
588 dynarray_add(&rtsp_st
->include_source_addrs
, &rtsp_st
->nb_include_source_addrs
, rtsp_src
);
593 if (rt
->server_type
== RTSP_SERVER_WMS
)
594 ff_wms_parse_sdp_a_line(s
, p
);
595 if (s
->nb_streams
> 0) {
596 rtsp_st
= rt
->rtsp_streams
[rt
->nb_rtsp_streams
- 1];
598 if (rt
->server_type
== RTSP_SERVER_REAL
)
599 ff_real_parse_sdp_a_line(s
, rtsp_st
->stream_index
, p
);
601 if (rtsp_st
->dynamic_handler
&&
602 rtsp_st
->dynamic_handler
->parse_sdp_a_line
)
603 rtsp_st
->dynamic_handler
->parse_sdp_a_line(s
,
604 rtsp_st
->stream_index
,
605 rtsp_st
->dynamic_protocol_context
, buf
);
612 int ff_sdp_parse(AVFormatContext
*s
, const char *content
)
614 RTSPState
*rt
= s
->priv_data
;
617 /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
618 * contain long SDP lines containing complete ASF Headers (several
619 * kB) or arrays of MDPR (RM stream descriptor) headers plus
620 * "rulebooks" describing their properties. Therefore, the SDP line
623 * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
624 * in rtpdec_xiph.c. */
626 SDPParseState sdp_parse_state
= { { 0 } }, *s1
= &sdp_parse_state
;
630 p
+= strspn(p
, SPACE_CHARS
);
638 /* get the content */
640 while (*p
!= '\n' && *p
!= '\r' && *p
!= '\0') {
641 if ((q
- buf
) < sizeof(buf
) - 1)
646 sdp_parse_line(s
, s1
, letter
, buf
);
648 while (*p
!= '\n' && *p
!= '\0')
654 for (i
= 0; i
< s1
->nb_default_include_source_addrs
; i
++)
655 av_free(s1
->default_include_source_addrs
[i
]);
656 av_freep(&s1
->default_include_source_addrs
);
657 for (i
= 0; i
< s1
->nb_default_exclude_source_addrs
; i
++)
658 av_free(s1
->default_exclude_source_addrs
[i
]);
659 av_freep(&s1
->default_exclude_source_addrs
);
661 rt
->p
= av_malloc_array(rt
->nb_rtsp_streams
+ 1, sizeof(struct pollfd
) * 2);
662 if (!rt
->p
) return AVERROR(ENOMEM
);
665 #endif /* CONFIG_RTPDEC */
667 void ff_rtsp_undo_setup(AVFormatContext
*s
, int send_packets
)
669 RTSPState
*rt
= s
->priv_data
;
672 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
673 RTSPStream
*rtsp_st
= rt
->rtsp_streams
[i
];
676 if (rtsp_st
->transport_priv
) {
678 AVFormatContext
*rtpctx
= rtsp_st
->transport_priv
;
679 av_write_trailer(rtpctx
);
680 if (rt
->lower_transport
== RTSP_LOWER_TRANSPORT_TCP
) {
682 if (CONFIG_RTSP_MUXER
&& rtpctx
->pb
&& send_packets
)
683 ff_rtsp_tcp_write_packet(s
, rtsp_st
);
684 avio_close_dyn_buf(rtpctx
->pb
, &ptr
);
687 avio_close(rtpctx
->pb
);
689 avformat_free_context(rtpctx
);
690 } else if (CONFIG_RTPDEC
&& rt
->transport
== RTSP_TRANSPORT_RDT
)
691 ff_rdt_parse_close(rtsp_st
->transport_priv
);
692 else if (CONFIG_RTPDEC
&& rt
->transport
== RTSP_TRANSPORT_RTP
)
693 ff_rtp_parse_close(rtsp_st
->transport_priv
);
695 rtsp_st
->transport_priv
= NULL
;
696 if (rtsp_st
->rtp_handle
)
697 ffurl_close(rtsp_st
->rtp_handle
);
698 rtsp_st
->rtp_handle
= NULL
;
702 /* close and free RTSP streams */
703 void ff_rtsp_close_streams(AVFormatContext
*s
)
705 RTSPState
*rt
= s
->priv_data
;
709 ff_rtsp_undo_setup(s
, 0);
710 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
711 rtsp_st
= rt
->rtsp_streams
[i
];
713 if (rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_protocol_context
)
714 rtsp_st
->dynamic_handler
->free(
715 rtsp_st
->dynamic_protocol_context
);
716 for (j
= 0; j
< rtsp_st
->nb_include_source_addrs
; j
++)
717 av_free(rtsp_st
->include_source_addrs
[j
]);
718 av_freep(&rtsp_st
->include_source_addrs
);
719 for (j
= 0; j
< rtsp_st
->nb_exclude_source_addrs
; j
++)
720 av_free(rtsp_st
->exclude_source_addrs
[j
]);
721 av_freep(&rtsp_st
->exclude_source_addrs
);
726 av_free(rt
->rtsp_streams
);
728 avformat_close_input(&rt
->asf_ctx
);
730 if (CONFIG_RTPDEC
&& rt
->ts
)
731 avpriv_mpegts_parse_close(rt
->ts
);
733 av_free(rt
->recvbuf
);
736 int ff_rtsp_open_transport_ctx(AVFormatContext
*s
, RTSPStream
*rtsp_st
)
738 RTSPState
*rt
= s
->priv_data
;
740 int reordering_queue_size
= rt
->reordering_queue_size
;
741 if (reordering_queue_size
< 0) {
742 if (rt
->lower_transport
== RTSP_LOWER_TRANSPORT_TCP
|| !s
->max_delay
)
743 reordering_queue_size
= 0;
745 reordering_queue_size
= RTP_REORDER_QUEUE_DEFAULT_SIZE
;
748 /* open the RTP context */
749 if (rtsp_st
->stream_index
>= 0)
750 st
= s
->streams
[rtsp_st
->stream_index
];
752 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
754 if (CONFIG_RTSP_MUXER
&& s
->oformat
) {
755 int ret
= ff_rtp_chain_mux_open((AVFormatContext
**)&rtsp_st
->transport_priv
,
756 s
, st
, rtsp_st
->rtp_handle
,
757 RTSP_TCP_MAX_PACKET_SIZE
,
758 rtsp_st
->stream_index
);
759 /* Ownership of rtp_handle is passed to the rtp mux context */
760 rtsp_st
->rtp_handle
= NULL
;
763 st
->time_base
= ((AVFormatContext
*)rtsp_st
->transport_priv
)->streams
[0]->time_base
;
764 } else if (rt
->transport
== RTSP_TRANSPORT_RAW
) {
765 return 0; // Don't need to open any parser here
766 } else if (CONFIG_RTPDEC
&& rt
->transport
== RTSP_TRANSPORT_RDT
)
767 rtsp_st
->transport_priv
= ff_rdt_parse_open(s
, st
->index
,
768 rtsp_st
->dynamic_protocol_context
,
769 rtsp_st
->dynamic_handler
);
770 else if (CONFIG_RTPDEC
)
771 rtsp_st
->transport_priv
= ff_rtp_parse_open(s
, st
,
772 rtsp_st
->sdp_payload_type
,
773 reordering_queue_size
);
775 if (!rtsp_st
->transport_priv
) {
776 return AVERROR(ENOMEM
);
777 } else if (CONFIG_RTPDEC
&& rt
->transport
== RTSP_TRANSPORT_RTP
) {
778 if (rtsp_st
->dynamic_handler
) {
779 ff_rtp_parse_set_dynamic_protocol(rtsp_st
->transport_priv
,
780 rtsp_st
->dynamic_protocol_context
,
781 rtsp_st
->dynamic_handler
);
783 if (rtsp_st
->crypto_suite
[0])
784 ff_rtp_parse_set_crypto(rtsp_st
->transport_priv
,
785 rtsp_st
->crypto_suite
,
786 rtsp_st
->crypto_params
);
792 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
793 static void rtsp_parse_range(int *min_ptr
, int *max_ptr
, const char **pp
)
800 q
+= strspn(q
, SPACE_CHARS
);
801 v
= strtol(q
, &p
, 10);
805 v
= strtol(p
, &p
, 10);
814 /* XXX: only one transport specification is parsed */
815 static void rtsp_parse_transport(RTSPMessageHeader
*reply
, const char *p
)
817 char transport_protocol
[16];
819 char lower_transport
[16];
821 RTSPTransportField
*th
;
824 reply
->nb_transports
= 0;
827 p
+= strspn(p
, SPACE_CHARS
);
831 th
= &reply
->transports
[reply
->nb_transports
];
833 get_word_sep(transport_protocol
, sizeof(transport_protocol
),
835 if (!av_strcasecmp (transport_protocol
, "rtp")) {
836 get_word_sep(profile
, sizeof(profile
), "/;,", &p
);
837 lower_transport
[0] = '\0';
838 /* rtp/avp/<protocol> */
840 get_word_sep(lower_transport
, sizeof(lower_transport
),
843 th
->transport
= RTSP_TRANSPORT_RTP
;
844 } else if (!av_strcasecmp (transport_protocol
, "x-pn-tng") ||
845 !av_strcasecmp (transport_protocol
, "x-real-rdt")) {
846 /* x-pn-tng/<protocol> */
847 get_word_sep(lower_transport
, sizeof(lower_transport
), "/;,", &p
);
849 th
->transport
= RTSP_TRANSPORT_RDT
;
850 } else if (!av_strcasecmp(transport_protocol
, "raw")) {
851 get_word_sep(profile
, sizeof(profile
), "/;,", &p
);
852 lower_transport
[0] = '\0';
853 /* raw/raw/<protocol> */
855 get_word_sep(lower_transport
, sizeof(lower_transport
),
858 th
->transport
= RTSP_TRANSPORT_RAW
;
860 if (!av_strcasecmp(lower_transport
, "TCP"))
861 th
->lower_transport
= RTSP_LOWER_TRANSPORT_TCP
;
863 th
->lower_transport
= RTSP_LOWER_TRANSPORT_UDP
;
867 /* get each parameter */
868 while (*p
!= '\0' && *p
!= ',') {
869 get_word_sep(parameter
, sizeof(parameter
), "=;,", &p
);
870 if (!strcmp(parameter
, "port")) {
873 rtsp_parse_range(&th
->port_min
, &th
->port_max
, &p
);
875 } else if (!strcmp(parameter
, "client_port")) {
878 rtsp_parse_range(&th
->client_port_min
,
879 &th
->client_port_max
, &p
);
881 } else if (!strcmp(parameter
, "server_port")) {
884 rtsp_parse_range(&th
->server_port_min
,
885 &th
->server_port_max
, &p
);
887 } else if (!strcmp(parameter
, "interleaved")) {
890 rtsp_parse_range(&th
->interleaved_min
,
891 &th
->interleaved_max
, &p
);
893 } else if (!strcmp(parameter
, "multicast")) {
894 if (th
->lower_transport
== RTSP_LOWER_TRANSPORT_UDP
)
895 th
->lower_transport
= RTSP_LOWER_TRANSPORT_UDP_MULTICAST
;
896 } else if (!strcmp(parameter
, "ttl")) {
900 th
->ttl
= strtol(p
, &end
, 10);
903 } else if (!strcmp(parameter
, "destination")) {
906 get_word_sep(buf
, sizeof(buf
), ";,", &p
);
907 get_sockaddr(buf
, &th
->destination
);
909 } else if (!strcmp(parameter
, "source")) {
912 get_word_sep(buf
, sizeof(buf
), ";,", &p
);
913 av_strlcpy(th
->source
, buf
, sizeof(th
->source
));
915 } else if (!strcmp(parameter
, "mode")) {
918 get_word_sep(buf
, sizeof(buf
), ";, ", &p
);
919 if (!strcmp(buf
, "record") ||
920 !strcmp(buf
, "receive"))
925 while (*p
!= ';' && *p
!= '\0' && *p
!= ',')
933 reply
->nb_transports
++;
937 static void handle_rtp_info(RTSPState
*rt
, const char *url
,
938 uint32_t seq
, uint32_t rtptime
)
941 if (!rtptime
|| !url
[0])
943 if (rt
->transport
!= RTSP_TRANSPORT_RTP
)
945 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
946 RTSPStream
*rtsp_st
= rt
->rtsp_streams
[i
];
947 RTPDemuxContext
*rtpctx
= rtsp_st
->transport_priv
;
950 if (!strcmp(rtsp_st
->control_url
, url
)) {
951 rtpctx
->base_timestamp
= rtptime
;
957 static void rtsp_parse_rtp_info(RTSPState
*rt
, const char *p
)
960 char key
[20], value
[1024], url
[1024] = "";
961 uint32_t seq
= 0, rtptime
= 0;
964 p
+= strspn(p
, SPACE_CHARS
);
967 get_word_sep(key
, sizeof(key
), "=", &p
);
971 get_word_sep(value
, sizeof(value
), ";, ", &p
);
973 if (!strcmp(key
, "url"))
974 av_strlcpy(url
, value
, sizeof(url
));
975 else if (!strcmp(key
, "seq"))
976 seq
= strtoul(value
, NULL
, 10);
977 else if (!strcmp(key
, "rtptime"))
978 rtptime
= strtoul(value
, NULL
, 10);
980 handle_rtp_info(rt
, url
, seq
, rtptime
);
989 handle_rtp_info(rt
, url
, seq
, rtptime
);
992 void ff_rtsp_parse_line(RTSPMessageHeader
*reply
, const char *buf
,
993 RTSPState
*rt
, const char *method
)
997 /* NOTE: we do case independent match for broken servers */
999 if (av_stristart(p
, "Session:", &p
)) {
1001 get_word_sep(reply
->session_id
, sizeof(reply
->session_id
), ";", &p
);
1002 if (av_stristart(p
, ";timeout=", &p
) &&
1003 (t
= strtol(p
, NULL
, 10)) > 0) {
1006 } else if (av_stristart(p
, "Content-Length:", &p
)) {
1007 reply
->content_length
= strtol(p
, NULL
, 10);
1008 } else if (av_stristart(p
, "Transport:", &p
)) {
1009 rtsp_parse_transport(reply
, p
);
1010 } else if (av_stristart(p
, "CSeq:", &p
)) {
1011 reply
->seq
= strtol(p
, NULL
, 10);
1012 } else if (av_stristart(p
, "Range:", &p
)) {
1013 rtsp_parse_range_npt(p
, &reply
->range_start
, &reply
->range_end
);
1014 } else if (av_stristart(p
, "RealChallenge1:", &p
)) {
1015 p
+= strspn(p
, SPACE_CHARS
);
1016 av_strlcpy(reply
->real_challenge
, p
, sizeof(reply
->real_challenge
));
1017 } else if (av_stristart(p
, "Server:", &p
)) {
1018 p
+= strspn(p
, SPACE_CHARS
);
1019 av_strlcpy(reply
->server
, p
, sizeof(reply
->server
));
1020 } else if (av_stristart(p
, "Notice:", &p
) ||
1021 av_stristart(p
, "X-Notice:", &p
)) {
1022 reply
->notice
= strtol(p
, NULL
, 10);
1023 } else if (av_stristart(p
, "Location:", &p
)) {
1024 p
+= strspn(p
, SPACE_CHARS
);
1025 av_strlcpy(reply
->location
, p
, sizeof(reply
->location
));
1026 } else if (av_stristart(p
, "WWW-Authenticate:", &p
) && rt
) {
1027 p
+= strspn(p
, SPACE_CHARS
);
1028 ff_http_auth_handle_header(&rt
->auth_state
, "WWW-Authenticate", p
);
1029 } else if (av_stristart(p
, "Authentication-Info:", &p
) && rt
) {
1030 p
+= strspn(p
, SPACE_CHARS
);
1031 ff_http_auth_handle_header(&rt
->auth_state
, "Authentication-Info", p
);
1032 } else if (av_stristart(p
, "Content-Base:", &p
) && rt
) {
1033 p
+= strspn(p
, SPACE_CHARS
);
1034 if (method
&& !strcmp(method
, "DESCRIBE"))
1035 av_strlcpy(rt
->control_uri
, p
, sizeof(rt
->control_uri
));
1036 } else if (av_stristart(p
, "RTP-Info:", &p
) && rt
) {
1037 p
+= strspn(p
, SPACE_CHARS
);
1038 if (method
&& !strcmp(method
, "PLAY"))
1039 rtsp_parse_rtp_info(rt
, p
);
1040 } else if (av_stristart(p
, "Public:", &p
) && rt
) {
1041 if (strstr(p
, "GET_PARAMETER") &&
1042 method
&& !strcmp(method
, "OPTIONS"))
1043 rt
->get_parameter_supported
= 1;
1044 } else if (av_stristart(p
, "x-Accept-Dynamic-Rate:", &p
) && rt
) {
1045 p
+= strspn(p
, SPACE_CHARS
);
1046 rt
->accept_dynamic_rate
= atoi(p
);
1047 } else if (av_stristart(p
, "Content-Type:", &p
)) {
1048 p
+= strspn(p
, SPACE_CHARS
);
1049 av_strlcpy(reply
->content_type
, p
, sizeof(reply
->content_type
));
1053 /* skip a RTP/TCP interleaved packet */
1054 void ff_rtsp_skip_packet(AVFormatContext
*s
)
1056 RTSPState
*rt
= s
->priv_data
;
1060 ret
= ffurl_read_complete(rt
->rtsp_hd
, buf
, 3);
1063 len
= AV_RB16(buf
+ 1);
1065 av_dlog(s
, "skipping RTP packet len=%d\n", len
);
1070 if (len1
> sizeof(buf
))
1072 ret
= ffurl_read_complete(rt
->rtsp_hd
, buf
, len1
);
1079 int ff_rtsp_read_reply(AVFormatContext
*s
, RTSPMessageHeader
*reply
,
1080 unsigned char **content_ptr
,
1081 int return_on_interleaved_data
, const char *method
)
1083 RTSPState
*rt
= s
->priv_data
;
1084 char buf
[4096], buf1
[1024], *q
;
1087 int ret
, content_length
, line_count
= 0, request
= 0;
1088 unsigned char *content
= NULL
;
1094 memset(reply
, 0, sizeof(*reply
));
1096 /* parse reply (XXX: use buffers) */
1097 rt
->last_reply
[0] = '\0';
1101 ret
= ffurl_read_complete(rt
->rtsp_hd
, &ch
, 1);
1102 av_dlog(s
, "ret=%d c=%02x [%c]\n", ret
, ch
, ch
);
1108 /* XXX: only parse it if first char on line ? */
1109 if (return_on_interleaved_data
) {
1112 ff_rtsp_skip_packet(s
);
1113 } else if (ch
!= '\r') {
1114 if ((q
- buf
) < sizeof(buf
) - 1)
1120 av_dlog(s
, "line='%s'\n", buf
);
1122 /* test if last line */
1126 if (line_count
== 0) {
1127 /* get reply code */
1128 get_word(buf1
, sizeof(buf1
), &p
);
1129 if (!strncmp(buf1
, "RTSP/", 5)) {
1130 get_word(buf1
, sizeof(buf1
), &p
);
1131 reply
->status_code
= atoi(buf1
);
1132 av_strlcpy(reply
->reason
, p
, sizeof(reply
->reason
));
1134 av_strlcpy(reply
->reason
, buf1
, sizeof(reply
->reason
)); // method
1135 get_word(buf1
, sizeof(buf1
), &p
); // object
1139 ff_rtsp_parse_line(reply
, p
, rt
, method
);
1140 av_strlcat(rt
->last_reply
, p
, sizeof(rt
->last_reply
));
1141 av_strlcat(rt
->last_reply
, "\n", sizeof(rt
->last_reply
));
1146 if (rt
->session_id
[0] == '\0' && reply
->session_id
[0] != '\0' && !request
)
1147 av_strlcpy(rt
->session_id
, reply
->session_id
, sizeof(rt
->session_id
));
1149 content_length
= reply
->content_length
;
1150 if (content_length
> 0) {
1151 /* leave some room for a trailing '\0' (useful for simple parsing) */
1152 content
= av_malloc(content_length
+ 1);
1154 return AVERROR(ENOMEM
);
1155 ffurl_read_complete(rt
->rtsp_hd
, content
, content_length
);
1156 content
[content_length
] = '\0';
1159 *content_ptr
= content
;
1165 char base64buf
[AV_BASE64_SIZE(sizeof(buf
))];
1166 const char* ptr
= buf
;
1168 if (!strcmp(reply
->reason
, "OPTIONS")) {
1169 snprintf(buf
, sizeof(buf
), "RTSP/1.0 200 OK\r\n");
1171 av_strlcatf(buf
, sizeof(buf
), "CSeq: %d\r\n", reply
->seq
);
1172 if (reply
->session_id
[0])
1173 av_strlcatf(buf
, sizeof(buf
), "Session: %s\r\n",
1176 snprintf(buf
, sizeof(buf
), "RTSP/1.0 501 Not Implemented\r\n");
1178 av_strlcat(buf
, "\r\n", sizeof(buf
));
1180 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1181 av_base64_encode(base64buf
, sizeof(base64buf
), buf
, strlen(buf
));
1184 ffurl_write(rt
->rtsp_hd_out
, ptr
, strlen(ptr
));
1186 rt
->last_cmd_time
= av_gettime_relative();
1187 /* Even if the request from the server had data, it is not the data
1188 * that the caller wants or expects. The memory could also be leaked
1189 * if the actual following reply has content data. */
1191 av_freep(content_ptr
);
1192 /* If method is set, this is called from ff_rtsp_send_cmd,
1193 * where a reply to exactly this request is awaited. For
1194 * callers from within packet receiving, we just want to
1195 * return to the caller and go back to receiving packets. */
1201 if (rt
->seq
!= reply
->seq
) {
1202 av_log(s
, AV_LOG_WARNING
, "CSeq %d expected, %d received.\n",
1203 rt
->seq
, reply
->seq
);
1207 if (reply
->notice
== 2101 /* End-of-Stream Reached */ ||
1208 reply
->notice
== 2104 /* Start-of-Stream Reached */ ||
1209 reply
->notice
== 2306 /* Continuous Feed Terminated */) {
1210 rt
->state
= RTSP_STATE_IDLE
;
1211 } else if (reply
->notice
>= 4400 && reply
->notice
< 5500) {
1212 return AVERROR(EIO
); /* data or server error */
1213 } else if (reply
->notice
== 2401 /* Ticket Expired */ ||
1214 (reply
->notice
>= 5500 && reply
->notice
< 5600) /* end of term */ )
1215 return AVERROR(EPERM
);
1221 * Send a command to the RTSP server without waiting for the reply.
1223 * @param s RTSP (de)muxer context
1224 * @param method the method for the request
1225 * @param url the target url for the request
1226 * @param headers extra header lines to include in the request
1227 * @param send_content if non-null, the data to send as request body content
1228 * @param send_content_length the length of the send_content data, or 0 if
1229 * send_content is null
1231 * @return zero if success, nonzero otherwise
1233 static int rtsp_send_cmd_with_content_async(AVFormatContext
*s
,
1234 const char *method
, const char *url
,
1235 const char *headers
,
1236 const unsigned char *send_content
,
1237 int send_content_length
)
1239 RTSPState
*rt
= s
->priv_data
;
1240 char buf
[4096], *out_buf
;
1241 char base64buf
[AV_BASE64_SIZE(sizeof(buf
))];
1243 /* Add in RTSP headers */
1246 snprintf(buf
, sizeof(buf
), "%s %s RTSP/1.0\r\n", method
, url
);
1248 av_strlcat(buf
, headers
, sizeof(buf
));
1249 av_strlcatf(buf
, sizeof(buf
), "CSeq: %d\r\n", rt
->seq
);
1250 av_strlcatf(buf
, sizeof(buf
), "User-Agent: %s\r\n", rt
->user_agent
);
1251 if (rt
->session_id
[0] != '\0' && (!headers
||
1252 !strstr(headers
, "\nIf-Match:"))) {
1253 av_strlcatf(buf
, sizeof(buf
), "Session: %s\r\n", rt
->session_id
);
1256 char *str
= ff_http_auth_create_response(&rt
->auth_state
,
1257 rt
->auth
, url
, method
);
1259 av_strlcat(buf
, str
, sizeof(buf
));
1262 if (send_content_length
> 0 && send_content
)
1263 av_strlcatf(buf
, sizeof(buf
), "Content-Length: %d\r\n", send_content_length
);
1264 av_strlcat(buf
, "\r\n", sizeof(buf
));
1266 /* base64 encode rtsp if tunneling */
1267 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1268 av_base64_encode(base64buf
, sizeof(base64buf
), buf
, strlen(buf
));
1269 out_buf
= base64buf
;
1272 av_dlog(s
, "Sending:\n%s--\n", buf
);
1274 ffurl_write(rt
->rtsp_hd_out
, out_buf
, strlen(out_buf
));
1275 if (send_content_length
> 0 && send_content
) {
1276 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1277 av_log(s
, AV_LOG_ERROR
, "tunneling of RTSP requests "
1278 "with content data not supported\n");
1279 return AVERROR_PATCHWELCOME
;
1281 ffurl_write(rt
->rtsp_hd_out
, send_content
, send_content_length
);
1283 rt
->last_cmd_time
= av_gettime_relative();
1288 int ff_rtsp_send_cmd_async(AVFormatContext
*s
, const char *method
,
1289 const char *url
, const char *headers
)
1291 return rtsp_send_cmd_with_content_async(s
, method
, url
, headers
, NULL
, 0);
1294 int ff_rtsp_send_cmd(AVFormatContext
*s
, const char *method
, const char *url
,
1295 const char *headers
, RTSPMessageHeader
*reply
,
1296 unsigned char **content_ptr
)
1298 return ff_rtsp_send_cmd_with_content(s
, method
, url
, headers
, reply
,
1299 content_ptr
, NULL
, 0);
1302 int ff_rtsp_send_cmd_with_content(AVFormatContext
*s
,
1303 const char *method
, const char *url
,
1305 RTSPMessageHeader
*reply
,
1306 unsigned char **content_ptr
,
1307 const unsigned char *send_content
,
1308 int send_content_length
)
1310 RTSPState
*rt
= s
->priv_data
;
1311 HTTPAuthType cur_auth_type
;
1312 int ret
, attempts
= 0;
1315 cur_auth_type
= rt
->auth_state
.auth_type
;
1316 if ((ret
= rtsp_send_cmd_with_content_async(s
, method
, url
, header
,
1318 send_content_length
)))
1321 if ((ret
= ff_rtsp_read_reply(s
, reply
, content_ptr
, 0, method
) ) < 0)
1325 if (reply
->status_code
== 401 &&
1326 (cur_auth_type
== HTTP_AUTH_NONE
|| rt
->auth_state
.stale
) &&
1327 rt
->auth_state
.auth_type
!= HTTP_AUTH_NONE
&& attempts
< 2)
1330 if (reply
->status_code
> 400){
1331 av_log(s
, AV_LOG_ERROR
, "method %s failed: %d%s\n",
1335 av_log(s
, AV_LOG_DEBUG
, "%s\n", rt
->last_reply
);
1341 int ff_rtsp_make_setup_request(AVFormatContext
*s
, const char *host
, int port
,
1342 int lower_transport
, const char *real_challenge
)
1344 RTSPState
*rt
= s
->priv_data
;
1345 int rtx
= 0, j
, i
, err
, interleave
= 0, port_off
;
1346 RTSPStream
*rtsp_st
;
1347 RTSPMessageHeader reply1
, *reply
= &reply1
;
1349 const char *trans_pref
;
1351 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
1352 trans_pref
= "x-pn-tng";
1353 else if (rt
->transport
== RTSP_TRANSPORT_RAW
)
1354 trans_pref
= "RAW/RAW";
1356 trans_pref
= "RTP/AVP";
1358 /* default timeout: 1 minute */
1361 /* Choose a random starting offset within the first half of the
1362 * port range, to allow for a number of ports to try even if the offset
1363 * happens to be at the end of the random range. */
1364 port_off
= av_get_random_seed() % ((rt
->rtp_port_max
- rt
->rtp_port_min
)/2);
1365 /* even random offset */
1366 port_off
-= port_off
& 0x01;
1368 for (j
= rt
->rtp_port_min
+ port_off
, i
= 0; i
< rt
->nb_rtsp_streams
; ++i
) {
1369 char transport
[2048];
1372 * WMS serves all UDP data over a single connection, the RTX, which
1373 * isn't necessarily the first in the SDP but has to be the first
1374 * to be set up, else the second/third SETUP will fail with a 461.
1376 if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
&&
1377 rt
->server_type
== RTSP_SERVER_WMS
) {
1380 for (rtx
= 0; rtx
< rt
->nb_rtsp_streams
; rtx
++) {
1381 int len
= strlen(rt
->rtsp_streams
[rtx
]->control_url
);
1383 !strcmp(rt
->rtsp_streams
[rtx
]->control_url
+ len
- 4,
1387 if (rtx
== rt
->nb_rtsp_streams
)
1388 return -1; /* no RTX found */
1389 rtsp_st
= rt
->rtsp_streams
[rtx
];
1391 rtsp_st
= rt
->rtsp_streams
[i
> rtx
? i
: i
- 1];
1393 rtsp_st
= rt
->rtsp_streams
[i
];
1396 if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
) {
1399 if (rt
->server_type
== RTSP_SERVER_WMS
&& i
> 1) {
1400 port
= reply
->transports
[0].client_port_min
;
1404 /* first try in specified port range */
1405 while (j
<= rt
->rtp_port_max
) {
1406 ff_url_join(buf
, sizeof(buf
), "rtp", NULL
, host
, -1,
1407 "?localport=%d", j
);
1408 /* we will use two ports per rtp stream (rtp and rtcp) */
1410 if (!ffurl_open(&rtsp_st
->rtp_handle
, buf
, AVIO_FLAG_READ_WRITE
,
1411 &s
->interrupt_callback
, NULL
))
1414 av_log(s
, AV_LOG_ERROR
, "Unable to open an input RTP port\n");
1419 port
= ff_rtp_get_local_rtp_port(rtsp_st
->rtp_handle
);
1421 snprintf(transport
, sizeof(transport
) - 1,
1422 "%s/UDP;", trans_pref
);
1423 if (rt
->server_type
!= RTSP_SERVER_REAL
)
1424 av_strlcat(transport
, "unicast;", sizeof(transport
));
1425 av_strlcatf(transport
, sizeof(transport
),
1426 "client_port=%d", port
);
1427 if (rt
->transport
== RTSP_TRANSPORT_RTP
&&
1428 !(rt
->server_type
== RTSP_SERVER_WMS
&& i
> 0))
1429 av_strlcatf(transport
, sizeof(transport
), "-%d", port
+ 1);
1433 else if (lower_transport
== RTSP_LOWER_TRANSPORT_TCP
) {
1434 /* For WMS streams, the application streams are only used for
1435 * UDP. When trying to set it up for TCP streams, the server
1436 * will return an error. Therefore, we skip those streams. */
1437 if (rt
->server_type
== RTSP_SERVER_WMS
&&
1438 (rtsp_st
->stream_index
< 0 ||
1439 s
->streams
[rtsp_st
->stream_index
]->codec
->codec_type
==
1442 snprintf(transport
, sizeof(transport
) - 1,
1443 "%s/TCP;", trans_pref
);
1444 if (rt
->transport
!= RTSP_TRANSPORT_RDT
)
1445 av_strlcat(transport
, "unicast;", sizeof(transport
));
1446 av_strlcatf(transport
, sizeof(transport
),
1447 "interleaved=%d-%d",
1448 interleave
, interleave
+ 1);
1452 else if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP_MULTICAST
) {
1453 snprintf(transport
, sizeof(transport
) - 1,
1454 "%s/UDP;multicast", trans_pref
);
1457 av_strlcat(transport
, ";mode=record", sizeof(transport
));
1458 } else if (rt
->server_type
== RTSP_SERVER_REAL
||
1459 rt
->server_type
== RTSP_SERVER_WMS
)
1460 av_strlcat(transport
, ";mode=play", sizeof(transport
));
1461 snprintf(cmd
, sizeof(cmd
),
1462 "Transport: %s\r\n",
1464 if (rt
->accept_dynamic_rate
)
1465 av_strlcat(cmd
, "x-Dynamic-Rate: 0\r\n", sizeof(cmd
));
1466 if (CONFIG_RTPDEC
&& i
== 0 && rt
->server_type
== RTSP_SERVER_REAL
) {
1467 char real_res
[41], real_csum
[9];
1468 ff_rdt_calc_response_and_checksum(real_res
, real_csum
,
1470 av_strlcatf(cmd
, sizeof(cmd
),
1472 "RealChallenge2: %s, sd=%s\r\n",
1473 rt
->session_id
, real_res
, real_csum
);
1475 ff_rtsp_send_cmd(s
, "SETUP", rtsp_st
->control_url
, cmd
, reply
, NULL
);
1476 if (reply
->status_code
== 461 /* Unsupported protocol */ && i
== 0) {
1479 } else if (reply
->status_code
!= RTSP_STATUS_OK
||
1480 reply
->nb_transports
!= 1) {
1481 err
= ff_rtsp_averror(reply
->status_code
, AVERROR_INVALIDDATA
);
1485 /* XXX: same protocol for all streams is required */
1487 if (reply
->transports
[0].lower_transport
!= rt
->lower_transport
||
1488 reply
->transports
[0].transport
!= rt
->transport
) {
1489 err
= AVERROR_INVALIDDATA
;
1493 rt
->lower_transport
= reply
->transports
[0].lower_transport
;
1494 rt
->transport
= reply
->transports
[0].transport
;
1497 /* Fail if the server responded with another lower transport mode
1498 * than what we requested. */
1499 if (reply
->transports
[0].lower_transport
!= lower_transport
) {
1500 av_log(s
, AV_LOG_ERROR
, "Nonmatching transport in server reply\n");
1501 err
= AVERROR_INVALIDDATA
;
1505 switch(reply
->transports
[0].lower_transport
) {
1506 case RTSP_LOWER_TRANSPORT_TCP
:
1507 rtsp_st
->interleaved_min
= reply
->transports
[0].interleaved_min
;
1508 rtsp_st
->interleaved_max
= reply
->transports
[0].interleaved_max
;
1511 case RTSP_LOWER_TRANSPORT_UDP
: {
1512 char url
[1024], options
[30] = "";
1513 const char *peer
= host
;
1515 if (rt
->rtsp_flags
& RTSP_FLAG_FILTER_SRC
)
1516 av_strlcpy(options
, "?connect=1", sizeof(options
));
1517 /* Use source address if specified */
1518 if (reply
->transports
[0].source
[0])
1519 peer
= reply
->transports
[0].source
;
1520 ff_url_join(url
, sizeof(url
), "rtp", NULL
, peer
,
1521 reply
->transports
[0].server_port_min
, "%s", options
);
1522 if (!(rt
->server_type
== RTSP_SERVER_WMS
&& i
> 1) &&
1523 ff_rtp_set_remote_url(rtsp_st
->rtp_handle
, url
) < 0) {
1524 err
= AVERROR_INVALIDDATA
;
1527 /* Try to initialize the connection state in a
1528 * potential NAT router by sending dummy packets.
1529 * RTP/RTCP dummy packets are used for RDT, too.
1531 if (CONFIG_RTPDEC
&&
1532 !(rt
->server_type
== RTSP_SERVER_WMS
&& i
> 1) && s
->iformat
)
1533 ff_rtp_send_punch_packets(rtsp_st
->rtp_handle
);
1536 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
: {
1537 char url
[1024], namebuf
[50], optbuf
[20] = "";
1538 struct sockaddr_storage addr
;
1541 if (reply
->transports
[0].destination
.ss_family
) {
1542 addr
= reply
->transports
[0].destination
;
1543 port
= reply
->transports
[0].port_min
;
1544 ttl
= reply
->transports
[0].ttl
;
1546 addr
= rtsp_st
->sdp_ip
;
1547 port
= rtsp_st
->sdp_port
;
1548 ttl
= rtsp_st
->sdp_ttl
;
1551 snprintf(optbuf
, sizeof(optbuf
), "?ttl=%d", ttl
);
1552 getnameinfo((struct sockaddr
*) &addr
, sizeof(addr
),
1553 namebuf
, sizeof(namebuf
), NULL
, 0, NI_NUMERICHOST
);
1554 ff_url_join(url
, sizeof(url
), "rtp", NULL
, namebuf
,
1555 port
, "%s", optbuf
);
1556 if (ffurl_open(&rtsp_st
->rtp_handle
, url
, AVIO_FLAG_READ_WRITE
,
1557 &s
->interrupt_callback
, NULL
) < 0) {
1558 err
= AVERROR_INVALIDDATA
;
1565 if ((err
= ff_rtsp_open_transport_ctx(s
, rtsp_st
)))
1569 if (rt
->nb_rtsp_streams
&& reply
->timeout
> 0)
1570 rt
->timeout
= reply
->timeout
;
1572 if (rt
->server_type
== RTSP_SERVER_REAL
)
1573 rt
->need_subscription
= 1;
1578 ff_rtsp_undo_setup(s
, 0);
1582 void ff_rtsp_close_connections(AVFormatContext
*s
)
1584 RTSPState
*rt
= s
->priv_data
;
1585 if (rt
->rtsp_hd_out
!= rt
->rtsp_hd
) ffurl_close(rt
->rtsp_hd_out
);
1586 ffurl_close(rt
->rtsp_hd
);
1587 rt
->rtsp_hd
= rt
->rtsp_hd_out
= NULL
;
1590 int ff_rtsp_connect(AVFormatContext
*s
)
1592 RTSPState
*rt
= s
->priv_data
;
1593 char proto
[128], host
[1024], path
[1024];
1594 char tcpname
[1024], cmd
[2048], auth
[128];
1595 const char *lower_rtsp_proto
= "tcp";
1596 int port
, err
, tcp_fd
;
1597 RTSPMessageHeader reply1
= {0}, *reply
= &reply1
;
1598 int lower_transport_mask
= 0;
1599 int default_port
= RTSP_DEFAULT_PORT
;
1600 char real_challenge
[64] = "";
1601 struct sockaddr_storage peer
;
1602 socklen_t peer_len
= sizeof(peer
);
1604 if (rt
->rtp_port_max
< rt
->rtp_port_min
) {
1605 av_log(s
, AV_LOG_ERROR
, "Invalid UDP port range, max port %d less "
1606 "than min port %d\n", rt
->rtp_port_max
,
1608 return AVERROR(EINVAL
);
1611 if (!ff_network_init())
1612 return AVERROR(EIO
);
1614 if (s
->max_delay
< 0) /* Not set by the caller */
1615 s
->max_delay
= s
->iformat
? DEFAULT_REORDERING_DELAY
: 0;
1617 rt
->control_transport
= RTSP_MODE_PLAIN
;
1618 if (rt
->lower_transport_mask
& (1 << RTSP_LOWER_TRANSPORT_HTTP
)) {
1619 rt
->lower_transport_mask
= 1 << RTSP_LOWER_TRANSPORT_TCP
;
1620 rt
->control_transport
= RTSP_MODE_TUNNEL
;
1622 /* Only pass through valid flags from here */
1623 rt
->lower_transport_mask
&= (1 << RTSP_LOWER_TRANSPORT_NB
) - 1;
1626 /* extract hostname and port */
1627 av_url_split(proto
, sizeof(proto
), auth
, sizeof(auth
),
1628 host
, sizeof(host
), &port
, path
, sizeof(path
), s
->filename
);
1630 if (!strcmp(proto
, "rtsps")) {
1631 lower_rtsp_proto
= "tls";
1632 default_port
= RTSPS_DEFAULT_PORT
;
1633 rt
->lower_transport_mask
= 1 << RTSP_LOWER_TRANSPORT_TCP
;
1637 av_strlcpy(rt
->auth
, auth
, sizeof(rt
->auth
));
1640 port
= default_port
;
1642 lower_transport_mask
= rt
->lower_transport_mask
;
1644 if (!lower_transport_mask
)
1645 lower_transport_mask
= (1 << RTSP_LOWER_TRANSPORT_NB
) - 1;
1648 /* Only UDP or TCP - UDP multicast isn't supported. */
1649 lower_transport_mask
&= (1 << RTSP_LOWER_TRANSPORT_UDP
) |
1650 (1 << RTSP_LOWER_TRANSPORT_TCP
);
1651 if (!lower_transport_mask
|| rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1652 av_log(s
, AV_LOG_ERROR
, "Unsupported lower transport method, "
1653 "only UDP and TCP are supported for output.\n");
1654 err
= AVERROR(EINVAL
);
1659 /* Construct the URI used in request; this is similar to s->filename,
1660 * but with authentication credentials removed and RTSP specific options
1662 ff_url_join(rt
->control_uri
, sizeof(rt
->control_uri
), proto
, NULL
,
1663 host
, port
, "%s", path
);
1665 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1666 /* set up initial handshake for tunneling */
1667 char httpname
[1024];
1668 char sessioncookie
[17];
1671 ff_url_join(httpname
, sizeof(httpname
), "http", auth
, host
, port
, "%s", path
);
1672 snprintf(sessioncookie
, sizeof(sessioncookie
), "%08x%08x",
1673 av_get_random_seed(), av_get_random_seed());
1676 if (ffurl_alloc(&rt
->rtsp_hd
, httpname
, AVIO_FLAG_READ
,
1677 &s
->interrupt_callback
) < 0) {
1682 /* generate GET headers */
1683 snprintf(headers
, sizeof(headers
),
1684 "x-sessioncookie: %s\r\n"
1685 "Accept: application/x-rtsp-tunnelled\r\n"
1686 "Pragma: no-cache\r\n"
1687 "Cache-Control: no-cache\r\n",
1689 av_opt_set(rt
->rtsp_hd
->priv_data
, "headers", headers
, 0);
1691 /* complete the connection */
1692 if (ffurl_connect(rt
->rtsp_hd
, NULL
)) {
1698 if (ffurl_alloc(&rt
->rtsp_hd_out
, httpname
, AVIO_FLAG_WRITE
,
1699 &s
->interrupt_callback
) < 0 ) {
1704 /* generate POST headers */
1705 snprintf(headers
, sizeof(headers
),
1706 "x-sessioncookie: %s\r\n"
1707 "Content-Type: application/x-rtsp-tunnelled\r\n"
1708 "Pragma: no-cache\r\n"
1709 "Cache-Control: no-cache\r\n"
1710 "Content-Length: 32767\r\n"
1711 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1713 av_opt_set(rt
->rtsp_hd_out
->priv_data
, "headers", headers
, 0);
1714 av_opt_set(rt
->rtsp_hd_out
->priv_data
, "chunked_post", "0", 0);
1716 /* Initialize the authentication state for the POST session. The HTTP
1717 * protocol implementation doesn't properly handle multi-pass
1718 * authentication for POST requests, since it would require one of
1720 * - implementing Expect: 100-continue, which many HTTP servers
1721 * don't support anyway, even less the RTSP servers that do HTTP
1723 * - sending the whole POST data until getting a 401 reply specifying
1724 * what authentication method to use, then resending all that data
1725 * - waiting for potential 401 replies directly after sending the
1726 * POST header (waiting for some unspecified time)
1727 * Therefore, we copy the full auth state, which works for both basic
1728 * and digest. (For digest, we would have to synchronize the nonce
1729 * count variable between the two sessions, if we'd do more requests
1730 * with the original session, though.)
1732 ff_http_init_auth_state(rt
->rtsp_hd_out
, rt
->rtsp_hd
);
1734 /* complete the connection */
1735 if (ffurl_connect(rt
->rtsp_hd_out
, NULL
)) {
1741 /* open the tcp connection */
1742 ff_url_join(tcpname
, sizeof(tcpname
), lower_rtsp_proto
, NULL
,
1744 "?timeout=%d", rt
->stimeout
);
1745 if ((ret
= ffurl_open(&rt
->rtsp_hd
, tcpname
, AVIO_FLAG_READ_WRITE
,
1746 &s
->interrupt_callback
, NULL
)) < 0) {
1750 rt
->rtsp_hd_out
= rt
->rtsp_hd
;
1754 tcp_fd
= ffurl_get_file_handle(rt
->rtsp_hd
);
1755 if (!getpeername(tcp_fd
, (struct sockaddr
*) &peer
, &peer_len
)) {
1756 getnameinfo((struct sockaddr
*) &peer
, peer_len
, host
, sizeof(host
),
1757 NULL
, 0, NI_NUMERICHOST
);
1760 /* request options supported by the server; this also detects server
1762 for (rt
->server_type
= RTSP_SERVER_RTP
;;) {
1764 if (rt
->server_type
== RTSP_SERVER_REAL
)
1767 * The following entries are required for proper
1768 * streaming from a Realmedia server. They are
1769 * interdependent in some way although we currently
1770 * don't quite understand how. Values were copied
1771 * from mplayer SVN r23589.
1772 * ClientChallenge is a 16-byte ID in hex
1773 * CompanyID is a 16-byte ID in base64
1775 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1776 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1777 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1778 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1780 ff_rtsp_send_cmd(s
, "OPTIONS", rt
->control_uri
, cmd
, reply
, NULL
);
1781 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1782 err
= ff_rtsp_averror(reply
->status_code
, AVERROR_INVALIDDATA
);
1786 /* detect server type if not standard-compliant RTP */
1787 if (rt
->server_type
!= RTSP_SERVER_REAL
&& reply
->real_challenge
[0]) {
1788 rt
->server_type
= RTSP_SERVER_REAL
;
1790 } else if (!av_strncasecmp(reply
->server
, "WMServer/", 9)) {
1791 rt
->server_type
= RTSP_SERVER_WMS
;
1792 } else if (rt
->server_type
== RTSP_SERVER_REAL
)
1793 strcpy(real_challenge
, reply
->real_challenge
);
1797 if (CONFIG_RTSP_DEMUXER
&& s
->iformat
)
1798 err
= ff_rtsp_setup_input_streams(s
, reply
);
1799 else if (CONFIG_RTSP_MUXER
)
1800 err
= ff_rtsp_setup_output_streams(s
, host
);
1807 int lower_transport
= ff_log2_tab
[lower_transport_mask
&
1808 ~(lower_transport_mask
- 1)];
1810 if ((lower_transport_mask
& (1 << RTSP_LOWER_TRANSPORT_TCP
))
1811 && (rt
->rtsp_flags
& RTSP_FLAG_PREFER_TCP
))
1812 lower_transport
= RTSP_LOWER_TRANSPORT_TCP
;
1814 err
= ff_rtsp_make_setup_request(s
, host
, port
, lower_transport
,
1815 rt
->server_type
== RTSP_SERVER_REAL
?
1816 real_challenge
: NULL
);
1819 lower_transport_mask
&= ~(1 << lower_transport
);
1820 if (lower_transport_mask
== 0 && err
== 1) {
1821 err
= AVERROR(EPROTONOSUPPORT
);
1826 rt
->lower_transport_mask
= lower_transport_mask
;
1827 av_strlcpy(rt
->real_challenge
, real_challenge
, sizeof(rt
->real_challenge
));
1828 rt
->state
= RTSP_STATE_IDLE
;
1829 rt
->seek_timestamp
= 0; /* default is to start stream at position zero */
1832 ff_rtsp_close_streams(s
);
1833 ff_rtsp_close_connections(s
);
1834 if (reply
->status_code
>=300 && reply
->status_code
< 400 && s
->iformat
) {
1835 av_strlcpy(s
->filename
, reply
->location
, sizeof(s
->filename
));
1836 rt
->session_id
[0] = '\0';
1837 av_log(s
, AV_LOG_INFO
, "Status %d: Redirecting to %s\n",
1845 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1848 static int udp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1849 uint8_t *buf
, int buf_size
, int64_t wait_end
)
1851 RTSPState
*rt
= s
->priv_data
;
1852 RTSPStream
*rtsp_st
;
1853 int n
, i
, ret
, tcp_fd
, timeout_cnt
= 0;
1855 struct pollfd
*p
= rt
->p
;
1856 int *fds
= NULL
, fdsnum
, fdsidx
;
1859 if (ff_check_interrupt(&s
->interrupt_callback
))
1860 return AVERROR_EXIT
;
1861 if (wait_end
&& wait_end
- av_gettime_relative() < 0)
1862 return AVERROR(EAGAIN
);
1865 tcp_fd
= ffurl_get_file_handle(rt
->rtsp_hd
);
1866 p
[max_p
].fd
= tcp_fd
;
1867 p
[max_p
++].events
= POLLIN
;
1871 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1872 rtsp_st
= rt
->rtsp_streams
[i
];
1873 if (rtsp_st
->rtp_handle
) {
1874 if (ret
= ffurl_get_multi_file_handle(rtsp_st
->rtp_handle
,
1876 av_log(s
, AV_LOG_ERROR
, "Unable to recover rtp ports\n");
1880 av_log(s
, AV_LOG_ERROR
,
1881 "Number of fds %d not supported\n", fdsnum
);
1882 return AVERROR_INVALIDDATA
;
1884 for (fdsidx
= 0; fdsidx
< fdsnum
; fdsidx
++) {
1885 p
[max_p
].fd
= fds
[fdsidx
];
1886 p
[max_p
++].events
= POLLIN
;
1891 n
= poll(p
, max_p
, POLL_TIMEOUT_MS
);
1893 int j
= 1 - (tcp_fd
== -1);
1895 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1896 rtsp_st
= rt
->rtsp_streams
[i
];
1897 if (rtsp_st
->rtp_handle
) {
1898 if (p
[j
].revents
& POLLIN
|| p
[j
+1].revents
& POLLIN
) {
1899 ret
= ffurl_read(rtsp_st
->rtp_handle
, buf
, buf_size
);
1901 *prtsp_st
= rtsp_st
;
1908 #if CONFIG_RTSP_DEMUXER
1909 if (tcp_fd
!= -1 && p
[0].revents
& POLLIN
) {
1910 if (rt
->rtsp_flags
& RTSP_FLAG_LISTEN
) {
1911 if (rt
->state
== RTSP_STATE_STREAMING
) {
1912 if (!ff_rtsp_parse_streaming_commands(s
))
1915 av_log(s
, AV_LOG_WARNING
,
1916 "Unable to answer to TEARDOWN\n");
1920 RTSPMessageHeader reply
;
1921 ret
= ff_rtsp_read_reply(s
, &reply
, NULL
, 0, NULL
);
1924 /* XXX: parse message */
1925 if (rt
->state
!= RTSP_STATE_STREAMING
)
1930 } else if (n
== 0 && ++timeout_cnt
>= MAX_TIMEOUTS
) {
1931 return AVERROR(ETIMEDOUT
);
1932 } else if (n
< 0 && errno
!= EINTR
)
1933 return AVERROR(errno
);
1937 static int pick_stream(AVFormatContext
*s
, RTSPStream
**rtsp_st
,
1938 const uint8_t *buf
, int len
)
1940 RTSPState
*rt
= s
->priv_data
;
1944 if (rt
->nb_rtsp_streams
== 1) {
1945 *rtsp_st
= rt
->rtsp_streams
[0];
1948 if (len
>= 8 && rt
->transport
== RTSP_TRANSPORT_RTP
) {
1949 if (RTP_PT_IS_RTCP(rt
->recvbuf
[1])) {
1951 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1952 RTPDemuxContext
*rtpctx
= rt
->rtsp_streams
[i
]->transport_priv
;
1955 if (rtpctx
->ssrc
== AV_RB32(&buf
[4])) {
1956 *rtsp_st
= rt
->rtsp_streams
[i
];
1963 av_log(s
, AV_LOG_WARNING
,
1964 "Unable to pick stream for packet - SSRC not known for "
1966 return AVERROR(EAGAIN
);
1969 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1970 if ((buf
[1] & 0x7f) == rt
->rtsp_streams
[i
]->sdp_payload_type
) {
1971 *rtsp_st
= rt
->rtsp_streams
[i
];
1977 av_log(s
, AV_LOG_WARNING
, "Unable to pick stream for packet\n");
1978 return AVERROR(EAGAIN
);
1981 int ff_rtsp_fetch_packet(AVFormatContext
*s
, AVPacket
*pkt
)
1983 RTSPState
*rt
= s
->priv_data
;
1985 RTSPStream
*rtsp_st
, *first_queue_st
= NULL
;
1986 int64_t wait_end
= 0;
1988 if (rt
->nb_byes
== rt
->nb_rtsp_streams
)
1991 /* get next frames from the same RTP packet */
1992 if (rt
->cur_transport_priv
) {
1993 if (rt
->transport
== RTSP_TRANSPORT_RDT
) {
1994 ret
= ff_rdt_parse_packet(rt
->cur_transport_priv
, pkt
, NULL
, 0);
1995 } else if (rt
->transport
== RTSP_TRANSPORT_RTP
) {
1996 ret
= ff_rtp_parse_packet(rt
->cur_transport_priv
, pkt
, NULL
, 0);
1997 } else if (CONFIG_RTPDEC
&& rt
->ts
) {
1998 ret
= avpriv_mpegts_parse_packet(rt
->ts
, pkt
, rt
->recvbuf
+ rt
->recvbuf_pos
, rt
->recvbuf_len
- rt
->recvbuf_pos
);
2000 rt
->recvbuf_pos
+= ret
;
2001 ret
= rt
->recvbuf_pos
< rt
->recvbuf_len
;
2006 rt
->cur_transport_priv
= NULL
;
2008 } else if (ret
== 1) {
2011 rt
->cur_transport_priv
= NULL
;
2015 if (rt
->transport
== RTSP_TRANSPORT_RTP
) {
2017 int64_t first_queue_time
= 0;
2018 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
2019 RTPDemuxContext
*rtpctx
= rt
->rtsp_streams
[i
]->transport_priv
;
2023 queue_time
= ff_rtp_queued_packet_time(rtpctx
);
2024 if (queue_time
&& (queue_time
- first_queue_time
< 0 ||
2025 !first_queue_time
)) {
2026 first_queue_time
= queue_time
;
2027 first_queue_st
= rt
->rtsp_streams
[i
];
2030 if (first_queue_time
) {
2031 wait_end
= first_queue_time
+ s
->max_delay
;
2034 first_queue_st
= NULL
;
2038 /* read next RTP packet */
2040 rt
->recvbuf
= av_malloc(RECVBUF_SIZE
);
2042 return AVERROR(ENOMEM
);
2045 switch(rt
->lower_transport
) {
2047 #if CONFIG_RTSP_DEMUXER
2048 case RTSP_LOWER_TRANSPORT_TCP
:
2049 len
= ff_rtsp_tcp_read_packet(s
, &rtsp_st
, rt
->recvbuf
, RECVBUF_SIZE
);
2052 case RTSP_LOWER_TRANSPORT_UDP
:
2053 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
:
2054 len
= udp_read_packet(s
, &rtsp_st
, rt
->recvbuf
, RECVBUF_SIZE
, wait_end
);
2055 if (len
> 0 && rtsp_st
->transport_priv
&& rt
->transport
== RTSP_TRANSPORT_RTP
)
2056 ff_rtp_check_and_send_back_rr(rtsp_st
->transport_priv
, rtsp_st
->rtp_handle
, NULL
, len
);
2058 case RTSP_LOWER_TRANSPORT_CUSTOM
:
2059 if (first_queue_st
&& rt
->transport
== RTSP_TRANSPORT_RTP
&&
2060 wait_end
&& wait_end
< av_gettime_relative())
2061 len
= AVERROR(EAGAIN
);
2063 len
= ffio_read_partial(s
->pb
, rt
->recvbuf
, RECVBUF_SIZE
);
2064 len
= pick_stream(s
, &rtsp_st
, rt
->recvbuf
, len
);
2065 if (len
> 0 && rtsp_st
->transport_priv
&& rt
->transport
== RTSP_TRANSPORT_RTP
)
2066 ff_rtp_check_and_send_back_rr(rtsp_st
->transport_priv
, NULL
, s
->pb
, len
);
2069 if (len
== AVERROR(EAGAIN
) && first_queue_st
&&
2070 rt
->transport
== RTSP_TRANSPORT_RTP
) {
2071 rtsp_st
= first_queue_st
;
2072 ret
= ff_rtp_parse_packet(rtsp_st
->transport_priv
, pkt
, NULL
, 0);
2079 if (rt
->transport
== RTSP_TRANSPORT_RDT
) {
2080 ret
= ff_rdt_parse_packet(rtsp_st
->transport_priv
, pkt
, &rt
->recvbuf
, len
);
2081 } else if (rt
->transport
== RTSP_TRANSPORT_RTP
) {
2082 ret
= ff_rtp_parse_packet(rtsp_st
->transport_priv
, pkt
, &rt
->recvbuf
, len
);
2083 if (rtsp_st
->feedback
) {
2084 AVIOContext
*pb
= NULL
;
2085 if (rt
->lower_transport
== RTSP_LOWER_TRANSPORT_CUSTOM
)
2087 ff_rtp_send_rtcp_feedback(rtsp_st
->transport_priv
, rtsp_st
->rtp_handle
, pb
);
2090 /* Either bad packet, or a RTCP packet. Check if the
2091 * first_rtcp_ntp_time field was initialized. */
2092 RTPDemuxContext
*rtpctx
= rtsp_st
->transport_priv
;
2093 if (rtpctx
->first_rtcp_ntp_time
!= AV_NOPTS_VALUE
) {
2094 /* first_rtcp_ntp_time has been initialized for this stream,
2095 * copy the same value to all other uninitialized streams,
2096 * in order to map their timestamp origin to the same ntp time
2099 AVStream
*st
= NULL
;
2100 if (rtsp_st
->stream_index
>= 0)
2101 st
= s
->streams
[rtsp_st
->stream_index
];
2102 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
2103 RTPDemuxContext
*rtpctx2
= rt
->rtsp_streams
[i
]->transport_priv
;
2104 AVStream
*st2
= NULL
;
2105 if (rt
->rtsp_streams
[i
]->stream_index
>= 0)
2106 st2
= s
->streams
[rt
->rtsp_streams
[i
]->stream_index
];
2107 if (rtpctx2
&& st
&& st2
&&
2108 rtpctx2
->first_rtcp_ntp_time
== AV_NOPTS_VALUE
) {
2109 rtpctx2
->first_rtcp_ntp_time
= rtpctx
->first_rtcp_ntp_time
;
2110 rtpctx2
->rtcp_ts_offset
= av_rescale_q(
2111 rtpctx
->rtcp_ts_offset
, st
->time_base
,
2115 // Make real NTP start time available in AVFormatContext
2116 if (s
->start_time_realtime
== AV_NOPTS_VALUE
) {
2117 s
->start_time_realtime
= av_rescale (rtpctx
->first_rtcp_ntp_time
- (NTP_OFFSET
<< 32), 1000000, 1LL << 32);
2119 s
->start_time_realtime
-=
2120 av_rescale (rtpctx
->rtcp_ts_offset
,
2121 (uint64_t) rtpctx
->st
->time_base
.num
* 1000000,
2122 rtpctx
->st
->time_base
.den
);
2126 if (ret
== -RTCP_BYE
) {
2129 av_log(s
, AV_LOG_DEBUG
, "Received BYE for stream %d (%d/%d)\n",
2130 rtsp_st
->stream_index
, rt
->nb_byes
, rt
->nb_rtsp_streams
);
2132 if (rt
->nb_byes
== rt
->nb_rtsp_streams
)
2136 } else if (CONFIG_RTPDEC
&& rt
->ts
) {
2137 ret
= avpriv_mpegts_parse_packet(rt
->ts
, pkt
, rt
->recvbuf
, len
);
2140 rt
->recvbuf_len
= len
;
2141 rt
->recvbuf_pos
= ret
;
2142 rt
->cur_transport_priv
= rt
->ts
;
2149 return AVERROR_INVALIDDATA
;
2155 /* more packets may follow, so we save the RTP context */
2156 rt
->cur_transport_priv
= rtsp_st
->transport_priv
;
2160 #endif /* CONFIG_RTPDEC */
2162 #if CONFIG_SDP_DEMUXER
2163 static int sdp_probe(AVProbeData
*p1
)
2165 const char *p
= p1
->buf
, *p_end
= p1
->buf
+ p1
->buf_size
;
2167 /* we look for a line beginning "c=IN IP" */
2168 while (p
< p_end
&& *p
!= '\0') {
2169 if (p
+ sizeof("c=IN IP") - 1 < p_end
&&
2170 av_strstart(p
, "c=IN IP", NULL
))
2171 return AVPROBE_SCORE_EXTENSION
;
2173 while (p
< p_end
- 1 && *p
!= '\n') p
++;
2182 static void append_source_addrs(char *buf
, int size
, const char *name
,
2183 int count
, struct RTSPSource
**addrs
)
2188 av_strlcatf(buf
, size
, "&%s=%s", name
, addrs
[0]->addr
);
2189 for (i
= 1; i
< count
; i
++)
2190 av_strlcatf(buf
, size
, ",%s", addrs
[i
]->addr
);
2193 static int sdp_read_header(AVFormatContext
*s
)
2195 RTSPState
*rt
= s
->priv_data
;
2196 RTSPStream
*rtsp_st
;
2201 if (!ff_network_init())
2202 return AVERROR(EIO
);
2204 if (s
->max_delay
< 0) /* Not set by the caller */
2205 s
->max_delay
= DEFAULT_REORDERING_DELAY
;
2206 if (rt
->rtsp_flags
& RTSP_FLAG_CUSTOM_IO
)
2207 rt
->lower_transport
= RTSP_LOWER_TRANSPORT_CUSTOM
;
2209 /* read the whole sdp file */
2210 /* XXX: better loading */
2211 content
= av_malloc(SDP_MAX_SIZE
);
2212 size
= avio_read(s
->pb
, content
, SDP_MAX_SIZE
- 1);
2215 return AVERROR_INVALIDDATA
;
2217 content
[size
] ='\0';
2219 err
= ff_sdp_parse(s
, content
);
2223 /* open each RTP stream */
2224 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
2226 rtsp_st
= rt
->rtsp_streams
[i
];
2228 if (!(rt
->rtsp_flags
& RTSP_FLAG_CUSTOM_IO
)) {
2229 getnameinfo((struct sockaddr
*) &rtsp_st
->sdp_ip
, sizeof(rtsp_st
->sdp_ip
),
2230 namebuf
, sizeof(namebuf
), NULL
, 0, NI_NUMERICHOST
);
2231 ff_url_join(url
, sizeof(url
), "rtp", NULL
,
2232 namebuf
, rtsp_st
->sdp_port
,
2233 "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2234 rtsp_st
->sdp_port
, rtsp_st
->sdp_ttl
,
2235 rt
->rtsp_flags
& RTSP_FLAG_FILTER_SRC
? 1 : 0,
2236 rt
->rtsp_flags
& RTSP_FLAG_RTCP_TO_SOURCE
? 1 : 0);
2238 append_source_addrs(url
, sizeof(url
), "sources",
2239 rtsp_st
->nb_include_source_addrs
,
2240 rtsp_st
->include_source_addrs
);
2241 append_source_addrs(url
, sizeof(url
), "block",
2242 rtsp_st
->nb_exclude_source_addrs
,
2243 rtsp_st
->exclude_source_addrs
);
2244 if (ffurl_open(&rtsp_st
->rtp_handle
, url
, AVIO_FLAG_READ_WRITE
,
2245 &s
->interrupt_callback
, NULL
) < 0) {
2246 err
= AVERROR_INVALIDDATA
;
2250 if ((err
= ff_rtsp_open_transport_ctx(s
, rtsp_st
)))
2255 ff_rtsp_close_streams(s
);
2260 static int sdp_read_close(AVFormatContext
*s
)
2262 ff_rtsp_close_streams(s
);
2267 static const AVClass sdp_demuxer_class
= {
2268 .class_name
= "SDP demuxer",
2269 .item_name
= av_default_item_name
,
2270 .option
= sdp_options
,
2271 .version
= LIBAVUTIL_VERSION_INT
,
2274 AVInputFormat ff_sdp_demuxer
= {
2276 .long_name
= NULL_IF_CONFIG_SMALL("SDP"),
2277 .priv_data_size
= sizeof(RTSPState
),
2278 .read_probe
= sdp_probe
,
2279 .read_header
= sdp_read_header
,
2280 .read_packet
= ff_rtsp_fetch_packet
,
2281 .read_close
= sdp_read_close
,
2282 .priv_class
= &sdp_demuxer_class
,
2284 #endif /* CONFIG_SDP_DEMUXER */
2286 #if CONFIG_RTP_DEMUXER
2287 static int rtp_probe(AVProbeData
*p
)
2289 if (av_strstart(p
->filename
, "rtp:", NULL
))
2290 return AVPROBE_SCORE_MAX
;
2294 static int rtp_read_header(AVFormatContext
*s
)
2296 uint8_t recvbuf
[RTP_MAX_PACKET_LENGTH
];
2297 char host
[500], sdp
[500];
2299 URLContext
* in
= NULL
;
2301 AVCodecContext codec
= { 0 };
2302 struct sockaddr_storage addr
;
2304 socklen_t addrlen
= sizeof(addr
);
2305 RTSPState
*rt
= s
->priv_data
;
2307 if (!ff_network_init())
2308 return AVERROR(EIO
);
2310 ret
= ffurl_open(&in
, s
->filename
, AVIO_FLAG_READ
,
2311 &s
->interrupt_callback
, NULL
);
2316 ret
= ffurl_read(in
, recvbuf
, sizeof(recvbuf
));
2317 if (ret
== AVERROR(EAGAIN
))
2322 av_log(s
, AV_LOG_WARNING
, "Received too short packet\n");
2326 if ((recvbuf
[0] & 0xc0) != 0x80) {
2327 av_log(s
, AV_LOG_WARNING
, "Unsupported RTP version packet "
2332 if (RTP_PT_IS_RTCP(recvbuf
[1]))
2335 payload_type
= recvbuf
[1] & 0x7f;
2338 getsockname(ffurl_get_file_handle(in
), (struct sockaddr
*) &addr
, &addrlen
);
2342 if (ff_rtp_get_codec_info(&codec
, payload_type
)) {
2343 av_log(s
, AV_LOG_ERROR
, "Unable to receive RTP payload type %d "
2344 "without an SDP file describing it\n",
2348 if (codec
.codec_type
!= AVMEDIA_TYPE_DATA
) {
2349 av_log(s
, AV_LOG_WARNING
, "Guessing on RTP content - if not received "
2350 "properly you need an SDP file "
2354 av_url_split(NULL
, 0, NULL
, 0, host
, sizeof(host
), &port
,
2355 NULL
, 0, s
->filename
);
2357 snprintf(sdp
, sizeof(sdp
),
2358 "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2359 addr
.ss_family
== AF_INET
? 4 : 6, host
,
2360 codec
.codec_type
== AVMEDIA_TYPE_DATA
? "application" :
2361 codec
.codec_type
== AVMEDIA_TYPE_VIDEO
? "video" : "audio",
2362 port
, payload_type
);
2363 av_log(s
, AV_LOG_VERBOSE
, "SDP:\n%s\n", sdp
);
2365 ffio_init_context(&pb
, sdp
, strlen(sdp
), 0, NULL
, NULL
, NULL
, NULL
);
2368 /* sdp_read_header initializes this again */
2371 rt
->media_type_mask
= (1 << (AVMEDIA_TYPE_DATA
+1)) - 1;
2373 ret
= sdp_read_header(s
);
2384 static const AVClass rtp_demuxer_class
= {
2385 .class_name
= "RTP demuxer",
2386 .item_name
= av_default_item_name
,
2387 .option
= rtp_options
,
2388 .version
= LIBAVUTIL_VERSION_INT
,
2391 AVInputFormat ff_rtp_demuxer
= {
2393 .long_name
= NULL_IF_CONFIG_SMALL("RTP input"),
2394 .priv_data_size
= sizeof(RTSPState
),
2395 .read_probe
= rtp_probe
,
2396 .read_header
= rtp_read_header
,
2397 .read_packet
= ff_rtsp_fetch_packet
,
2398 .read_close
= sdp_read_close
,
2399 .flags
= AVFMT_NOFILE
,
2400 .priv_class
= &rtp_demuxer_class
,
2402 #endif /* CONFIG_RTP_DEMUXER */