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 (!rt
->ts
&& CONFIG_RTPDEC
)
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 (rt
->transport
== RTSP_TRANSPORT_RDT
&& CONFIG_RTPDEC
)
691 ff_rdt_parse_close(rtsp_st
->transport_priv
);
692 else if (rt
->transport
== RTSP_TRANSPORT_RTP
&& CONFIG_RTPDEC
)
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 (rt
->ts
&& CONFIG_RTPDEC
)
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 (s
->oformat
&& CONFIG_RTSP_MUXER
) {
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 (rt
->transport
== RTSP_TRANSPORT_RDT
&& CONFIG_RTPDEC
)
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 (rt
->transport
== RTSP_TRANSPORT_RTP
&& CONFIG_RTPDEC
) {
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);
1153 ffurl_read_complete(rt
->rtsp_hd
, content
, content_length
);
1154 content
[content_length
] = '\0';
1157 *content_ptr
= content
;
1163 char base64buf
[AV_BASE64_SIZE(sizeof(buf
))];
1164 const char* ptr
= buf
;
1166 if (!strcmp(reply
->reason
, "OPTIONS")) {
1167 snprintf(buf
, sizeof(buf
), "RTSP/1.0 200 OK\r\n");
1169 av_strlcatf(buf
, sizeof(buf
), "CSeq: %d\r\n", reply
->seq
);
1170 if (reply
->session_id
[0])
1171 av_strlcatf(buf
, sizeof(buf
), "Session: %s\r\n",
1174 snprintf(buf
, sizeof(buf
), "RTSP/1.0 501 Not Implemented\r\n");
1176 av_strlcat(buf
, "\r\n", sizeof(buf
));
1178 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1179 av_base64_encode(base64buf
, sizeof(base64buf
), buf
, strlen(buf
));
1182 ffurl_write(rt
->rtsp_hd_out
, ptr
, strlen(ptr
));
1184 rt
->last_cmd_time
= av_gettime();
1185 /* Even if the request from the server had data, it is not the data
1186 * that the caller wants or expects. The memory could also be leaked
1187 * if the actual following reply has content data. */
1189 av_freep(content_ptr
);
1190 /* If method is set, this is called from ff_rtsp_send_cmd,
1191 * where a reply to exactly this request is awaited. For
1192 * callers from within packet receiving, we just want to
1193 * return to the caller and go back to receiving packets. */
1199 if (rt
->seq
!= reply
->seq
) {
1200 av_log(s
, AV_LOG_WARNING
, "CSeq %d expected, %d received.\n",
1201 rt
->seq
, reply
->seq
);
1205 if (reply
->notice
== 2101 /* End-of-Stream Reached */ ||
1206 reply
->notice
== 2104 /* Start-of-Stream Reached */ ||
1207 reply
->notice
== 2306 /* Continuous Feed Terminated */) {
1208 rt
->state
= RTSP_STATE_IDLE
;
1209 } else if (reply
->notice
>= 4400 && reply
->notice
< 5500) {
1210 return AVERROR(EIO
); /* data or server error */
1211 } else if (reply
->notice
== 2401 /* Ticket Expired */ ||
1212 (reply
->notice
>= 5500 && reply
->notice
< 5600) /* end of term */ )
1213 return AVERROR(EPERM
);
1219 * Send a command to the RTSP server without waiting for the reply.
1221 * @param s RTSP (de)muxer context
1222 * @param method the method for the request
1223 * @param url the target url for the request
1224 * @param headers extra header lines to include in the request
1225 * @param send_content if non-null, the data to send as request body content
1226 * @param send_content_length the length of the send_content data, or 0 if
1227 * send_content is null
1229 * @return zero if success, nonzero otherwise
1231 static int rtsp_send_cmd_with_content_async(AVFormatContext
*s
,
1232 const char *method
, const char *url
,
1233 const char *headers
,
1234 const unsigned char *send_content
,
1235 int send_content_length
)
1237 RTSPState
*rt
= s
->priv_data
;
1238 char buf
[4096], *out_buf
;
1239 char base64buf
[AV_BASE64_SIZE(sizeof(buf
))];
1241 /* Add in RTSP headers */
1244 snprintf(buf
, sizeof(buf
), "%s %s RTSP/1.0\r\n", method
, url
);
1246 av_strlcat(buf
, headers
, sizeof(buf
));
1247 av_strlcatf(buf
, sizeof(buf
), "CSeq: %d\r\n", rt
->seq
);
1248 av_strlcatf(buf
, sizeof(buf
), "User-Agent: %s\r\n", rt
->user_agent
);
1249 if (rt
->session_id
[0] != '\0' && (!headers
||
1250 !strstr(headers
, "\nIf-Match:"))) {
1251 av_strlcatf(buf
, sizeof(buf
), "Session: %s\r\n", rt
->session_id
);
1254 char *str
= ff_http_auth_create_response(&rt
->auth_state
,
1255 rt
->auth
, url
, method
);
1257 av_strlcat(buf
, str
, sizeof(buf
));
1260 if (send_content_length
> 0 && send_content
)
1261 av_strlcatf(buf
, sizeof(buf
), "Content-Length: %d\r\n", send_content_length
);
1262 av_strlcat(buf
, "\r\n", sizeof(buf
));
1264 /* base64 encode rtsp if tunneling */
1265 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1266 av_base64_encode(base64buf
, sizeof(base64buf
), buf
, strlen(buf
));
1267 out_buf
= base64buf
;
1270 av_dlog(s
, "Sending:\n%s--\n", buf
);
1272 ffurl_write(rt
->rtsp_hd_out
, out_buf
, strlen(out_buf
));
1273 if (send_content_length
> 0 && send_content
) {
1274 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1275 av_log(s
, AV_LOG_ERROR
, "tunneling of RTSP requests "
1276 "with content data not supported\n");
1277 return AVERROR_PATCHWELCOME
;
1279 ffurl_write(rt
->rtsp_hd_out
, send_content
, send_content_length
);
1281 rt
->last_cmd_time
= av_gettime();
1286 int ff_rtsp_send_cmd_async(AVFormatContext
*s
, const char *method
,
1287 const char *url
, const char *headers
)
1289 return rtsp_send_cmd_with_content_async(s
, method
, url
, headers
, NULL
, 0);
1292 int ff_rtsp_send_cmd(AVFormatContext
*s
, const char *method
, const char *url
,
1293 const char *headers
, RTSPMessageHeader
*reply
,
1294 unsigned char **content_ptr
)
1296 return ff_rtsp_send_cmd_with_content(s
, method
, url
, headers
, reply
,
1297 content_ptr
, NULL
, 0);
1300 int ff_rtsp_send_cmd_with_content(AVFormatContext
*s
,
1301 const char *method
, const char *url
,
1303 RTSPMessageHeader
*reply
,
1304 unsigned char **content_ptr
,
1305 const unsigned char *send_content
,
1306 int send_content_length
)
1308 RTSPState
*rt
= s
->priv_data
;
1309 HTTPAuthType cur_auth_type
;
1310 int ret
, attempts
= 0;
1313 cur_auth_type
= rt
->auth_state
.auth_type
;
1314 if ((ret
= rtsp_send_cmd_with_content_async(s
, method
, url
, header
,
1316 send_content_length
)))
1319 if ((ret
= ff_rtsp_read_reply(s
, reply
, content_ptr
, 0, method
) ) < 0)
1323 if (reply
->status_code
== 401 &&
1324 (cur_auth_type
== HTTP_AUTH_NONE
|| rt
->auth_state
.stale
) &&
1325 rt
->auth_state
.auth_type
!= HTTP_AUTH_NONE
&& attempts
< 2)
1328 if (reply
->status_code
> 400){
1329 av_log(s
, AV_LOG_ERROR
, "method %s failed: %d%s\n",
1333 av_log(s
, AV_LOG_DEBUG
, "%s\n", rt
->last_reply
);
1339 int ff_rtsp_make_setup_request(AVFormatContext
*s
, const char *host
, int port
,
1340 int lower_transport
, const char *real_challenge
)
1342 RTSPState
*rt
= s
->priv_data
;
1343 int rtx
= 0, j
, i
, err
, interleave
= 0, port_off
;
1344 RTSPStream
*rtsp_st
;
1345 RTSPMessageHeader reply1
, *reply
= &reply1
;
1347 const char *trans_pref
;
1349 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
1350 trans_pref
= "x-pn-tng";
1351 else if (rt
->transport
== RTSP_TRANSPORT_RAW
)
1352 trans_pref
= "RAW/RAW";
1354 trans_pref
= "RTP/AVP";
1356 /* default timeout: 1 minute */
1359 /* Choose a random starting offset within the first half of the
1360 * port range, to allow for a number of ports to try even if the offset
1361 * happens to be at the end of the random range. */
1362 port_off
= av_get_random_seed() % ((rt
->rtp_port_max
- rt
->rtp_port_min
)/2);
1363 /* even random offset */
1364 port_off
-= port_off
& 0x01;
1366 for (j
= rt
->rtp_port_min
+ port_off
, i
= 0; i
< rt
->nb_rtsp_streams
; ++i
) {
1367 char transport
[2048];
1370 * WMS serves all UDP data over a single connection, the RTX, which
1371 * isn't necessarily the first in the SDP but has to be the first
1372 * to be set up, else the second/third SETUP will fail with a 461.
1374 if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
&&
1375 rt
->server_type
== RTSP_SERVER_WMS
) {
1378 for (rtx
= 0; rtx
< rt
->nb_rtsp_streams
; rtx
++) {
1379 int len
= strlen(rt
->rtsp_streams
[rtx
]->control_url
);
1381 !strcmp(rt
->rtsp_streams
[rtx
]->control_url
+ len
- 4,
1385 if (rtx
== rt
->nb_rtsp_streams
)
1386 return -1; /* no RTX found */
1387 rtsp_st
= rt
->rtsp_streams
[rtx
];
1389 rtsp_st
= rt
->rtsp_streams
[i
> rtx
? i
: i
- 1];
1391 rtsp_st
= rt
->rtsp_streams
[i
];
1394 if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
) {
1397 if (rt
->server_type
== RTSP_SERVER_WMS
&& i
> 1) {
1398 port
= reply
->transports
[0].client_port_min
;
1402 /* first try in specified port range */
1403 while (j
<= rt
->rtp_port_max
) {
1404 ff_url_join(buf
, sizeof(buf
), "rtp", NULL
, host
, -1,
1405 "?localport=%d", j
);
1406 /* we will use two ports per rtp stream (rtp and rtcp) */
1408 if (!ffurl_open(&rtsp_st
->rtp_handle
, buf
, AVIO_FLAG_READ_WRITE
,
1409 &s
->interrupt_callback
, NULL
))
1412 av_log(s
, AV_LOG_ERROR
, "Unable to open an input RTP port\n");
1417 port
= ff_rtp_get_local_rtp_port(rtsp_st
->rtp_handle
);
1419 snprintf(transport
, sizeof(transport
) - 1,
1420 "%s/UDP;", trans_pref
);
1421 if (rt
->server_type
!= RTSP_SERVER_REAL
)
1422 av_strlcat(transport
, "unicast;", sizeof(transport
));
1423 av_strlcatf(transport
, sizeof(transport
),
1424 "client_port=%d", port
);
1425 if (rt
->transport
== RTSP_TRANSPORT_RTP
&&
1426 !(rt
->server_type
== RTSP_SERVER_WMS
&& i
> 0))
1427 av_strlcatf(transport
, sizeof(transport
), "-%d", port
+ 1);
1431 else if (lower_transport
== RTSP_LOWER_TRANSPORT_TCP
) {
1432 /* For WMS streams, the application streams are only used for
1433 * UDP. When trying to set it up for TCP streams, the server
1434 * will return an error. Therefore, we skip those streams. */
1435 if (rt
->server_type
== RTSP_SERVER_WMS
&&
1436 (rtsp_st
->stream_index
< 0 ||
1437 s
->streams
[rtsp_st
->stream_index
]->codec
->codec_type
==
1440 snprintf(transport
, sizeof(transport
) - 1,
1441 "%s/TCP;", trans_pref
);
1442 if (rt
->transport
!= RTSP_TRANSPORT_RDT
)
1443 av_strlcat(transport
, "unicast;", sizeof(transport
));
1444 av_strlcatf(transport
, sizeof(transport
),
1445 "interleaved=%d-%d",
1446 interleave
, interleave
+ 1);
1450 else if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP_MULTICAST
) {
1451 snprintf(transport
, sizeof(transport
) - 1,
1452 "%s/UDP;multicast", trans_pref
);
1455 av_strlcat(transport
, ";mode=record", sizeof(transport
));
1456 } else if (rt
->server_type
== RTSP_SERVER_REAL
||
1457 rt
->server_type
== RTSP_SERVER_WMS
)
1458 av_strlcat(transport
, ";mode=play", sizeof(transport
));
1459 snprintf(cmd
, sizeof(cmd
),
1460 "Transport: %s\r\n",
1462 if (rt
->accept_dynamic_rate
)
1463 av_strlcat(cmd
, "x-Dynamic-Rate: 0\r\n", sizeof(cmd
));
1464 if (i
== 0 && rt
->server_type
== RTSP_SERVER_REAL
&& CONFIG_RTPDEC
) {
1465 char real_res
[41], real_csum
[9];
1466 ff_rdt_calc_response_and_checksum(real_res
, real_csum
,
1468 av_strlcatf(cmd
, sizeof(cmd
),
1470 "RealChallenge2: %s, sd=%s\r\n",
1471 rt
->session_id
, real_res
, real_csum
);
1473 ff_rtsp_send_cmd(s
, "SETUP", rtsp_st
->control_url
, cmd
, reply
, NULL
);
1474 if (reply
->status_code
== 461 /* Unsupported protocol */ && i
== 0) {
1477 } else if (reply
->status_code
!= RTSP_STATUS_OK
||
1478 reply
->nb_transports
!= 1) {
1479 err
= AVERROR_INVALIDDATA
;
1483 /* XXX: same protocol for all streams is required */
1485 if (reply
->transports
[0].lower_transport
!= rt
->lower_transport
||
1486 reply
->transports
[0].transport
!= rt
->transport
) {
1487 err
= AVERROR_INVALIDDATA
;
1491 rt
->lower_transport
= reply
->transports
[0].lower_transport
;
1492 rt
->transport
= reply
->transports
[0].transport
;
1495 /* Fail if the server responded with another lower transport mode
1496 * than what we requested. */
1497 if (reply
->transports
[0].lower_transport
!= lower_transport
) {
1498 av_log(s
, AV_LOG_ERROR
, "Nonmatching transport in server reply\n");
1499 err
= AVERROR_INVALIDDATA
;
1503 switch(reply
->transports
[0].lower_transport
) {
1504 case RTSP_LOWER_TRANSPORT_TCP
:
1505 rtsp_st
->interleaved_min
= reply
->transports
[0].interleaved_min
;
1506 rtsp_st
->interleaved_max
= reply
->transports
[0].interleaved_max
;
1509 case RTSP_LOWER_TRANSPORT_UDP
: {
1510 char url
[1024], options
[30] = "";
1511 const char *peer
= host
;
1513 if (rt
->rtsp_flags
& RTSP_FLAG_FILTER_SRC
)
1514 av_strlcpy(options
, "?connect=1", sizeof(options
));
1515 /* Use source address if specified */
1516 if (reply
->transports
[0].source
[0])
1517 peer
= reply
->transports
[0].source
;
1518 ff_url_join(url
, sizeof(url
), "rtp", NULL
, peer
,
1519 reply
->transports
[0].server_port_min
, "%s", options
);
1520 if (!(rt
->server_type
== RTSP_SERVER_WMS
&& i
> 1) &&
1521 ff_rtp_set_remote_url(rtsp_st
->rtp_handle
, url
) < 0) {
1522 err
= AVERROR_INVALIDDATA
;
1525 /* Try to initialize the connection state in a
1526 * potential NAT router by sending dummy packets.
1527 * RTP/RTCP dummy packets are used for RDT, too.
1529 if (!(rt
->server_type
== RTSP_SERVER_WMS
&& i
> 1) && s
->iformat
&&
1531 ff_rtp_send_punch_packets(rtsp_st
->rtp_handle
);
1534 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
: {
1535 char url
[1024], namebuf
[50], optbuf
[20] = "";
1536 struct sockaddr_storage addr
;
1539 if (reply
->transports
[0].destination
.ss_family
) {
1540 addr
= reply
->transports
[0].destination
;
1541 port
= reply
->transports
[0].port_min
;
1542 ttl
= reply
->transports
[0].ttl
;
1544 addr
= rtsp_st
->sdp_ip
;
1545 port
= rtsp_st
->sdp_port
;
1546 ttl
= rtsp_st
->sdp_ttl
;
1549 snprintf(optbuf
, sizeof(optbuf
), "?ttl=%d", ttl
);
1550 getnameinfo((struct sockaddr
*) &addr
, sizeof(addr
),
1551 namebuf
, sizeof(namebuf
), NULL
, 0, NI_NUMERICHOST
);
1552 ff_url_join(url
, sizeof(url
), "rtp", NULL
, namebuf
,
1553 port
, "%s", optbuf
);
1554 if (ffurl_open(&rtsp_st
->rtp_handle
, url
, AVIO_FLAG_READ_WRITE
,
1555 &s
->interrupt_callback
, NULL
) < 0) {
1556 err
= AVERROR_INVALIDDATA
;
1563 if ((err
= ff_rtsp_open_transport_ctx(s
, rtsp_st
)))
1567 if (rt
->nb_rtsp_streams
&& reply
->timeout
> 0)
1568 rt
->timeout
= reply
->timeout
;
1570 if (rt
->server_type
== RTSP_SERVER_REAL
)
1571 rt
->need_subscription
= 1;
1576 ff_rtsp_undo_setup(s
, 0);
1580 void ff_rtsp_close_connections(AVFormatContext
*s
)
1582 RTSPState
*rt
= s
->priv_data
;
1583 if (rt
->rtsp_hd_out
!= rt
->rtsp_hd
) ffurl_close(rt
->rtsp_hd_out
);
1584 ffurl_close(rt
->rtsp_hd
);
1585 rt
->rtsp_hd
= rt
->rtsp_hd_out
= NULL
;
1588 int ff_rtsp_connect(AVFormatContext
*s
)
1590 RTSPState
*rt
= s
->priv_data
;
1591 char host
[1024], path
[1024], tcpname
[1024], cmd
[2048], auth
[128];
1592 int port
, err
, tcp_fd
;
1593 RTSPMessageHeader reply1
= {0}, *reply
= &reply1
;
1594 int lower_transport_mask
= 0;
1595 char real_challenge
[64] = "";
1596 struct sockaddr_storage peer
;
1597 socklen_t peer_len
= sizeof(peer
);
1599 if (rt
->rtp_port_max
< rt
->rtp_port_min
) {
1600 av_log(s
, AV_LOG_ERROR
, "Invalid UDP port range, max port %d less "
1601 "than min port %d\n", rt
->rtp_port_max
,
1603 return AVERROR(EINVAL
);
1606 if (!ff_network_init())
1607 return AVERROR(EIO
);
1609 if (s
->max_delay
< 0) /* Not set by the caller */
1610 s
->max_delay
= s
->iformat
? DEFAULT_REORDERING_DELAY
: 0;
1612 rt
->control_transport
= RTSP_MODE_PLAIN
;
1613 if (rt
->lower_transport_mask
& (1 << RTSP_LOWER_TRANSPORT_HTTP
)) {
1614 rt
->lower_transport_mask
= 1 << RTSP_LOWER_TRANSPORT_TCP
;
1615 rt
->control_transport
= RTSP_MODE_TUNNEL
;
1617 /* Only pass through valid flags from here */
1618 rt
->lower_transport_mask
&= (1 << RTSP_LOWER_TRANSPORT_NB
) - 1;
1621 lower_transport_mask
= rt
->lower_transport_mask
;
1622 /* extract hostname and port */
1623 av_url_split(NULL
, 0, auth
, sizeof(auth
),
1624 host
, sizeof(host
), &port
, path
, sizeof(path
), s
->filename
);
1626 av_strlcpy(rt
->auth
, auth
, sizeof(rt
->auth
));
1629 port
= RTSP_DEFAULT_PORT
;
1631 if (!lower_transport_mask
)
1632 lower_transport_mask
= (1 << RTSP_LOWER_TRANSPORT_NB
) - 1;
1635 /* Only UDP or TCP - UDP multicast isn't supported. */
1636 lower_transport_mask
&= (1 << RTSP_LOWER_TRANSPORT_UDP
) |
1637 (1 << RTSP_LOWER_TRANSPORT_TCP
);
1638 if (!lower_transport_mask
|| rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1639 av_log(s
, AV_LOG_ERROR
, "Unsupported lower transport method, "
1640 "only UDP and TCP are supported for output.\n");
1641 err
= AVERROR(EINVAL
);
1646 /* Construct the URI used in request; this is similar to s->filename,
1647 * but with authentication credentials removed and RTSP specific options
1649 ff_url_join(rt
->control_uri
, sizeof(rt
->control_uri
), "rtsp", NULL
,
1650 host
, port
, "%s", path
);
1652 if (rt
->control_transport
== RTSP_MODE_TUNNEL
) {
1653 /* set up initial handshake for tunneling */
1654 char httpname
[1024];
1655 char sessioncookie
[17];
1658 ff_url_join(httpname
, sizeof(httpname
), "http", auth
, host
, port
, "%s", path
);
1659 snprintf(sessioncookie
, sizeof(sessioncookie
), "%08x%08x",
1660 av_get_random_seed(), av_get_random_seed());
1663 if (ffurl_alloc(&rt
->rtsp_hd
, httpname
, AVIO_FLAG_READ
,
1664 &s
->interrupt_callback
) < 0) {
1669 /* generate GET headers */
1670 snprintf(headers
, sizeof(headers
),
1671 "x-sessioncookie: %s\r\n"
1672 "Accept: application/x-rtsp-tunnelled\r\n"
1673 "Pragma: no-cache\r\n"
1674 "Cache-Control: no-cache\r\n",
1676 av_opt_set(rt
->rtsp_hd
->priv_data
, "headers", headers
, 0);
1678 /* complete the connection */
1679 if (ffurl_connect(rt
->rtsp_hd
, NULL
)) {
1685 if (ffurl_alloc(&rt
->rtsp_hd_out
, httpname
, AVIO_FLAG_WRITE
,
1686 &s
->interrupt_callback
) < 0 ) {
1691 /* generate POST headers */
1692 snprintf(headers
, sizeof(headers
),
1693 "x-sessioncookie: %s\r\n"
1694 "Content-Type: application/x-rtsp-tunnelled\r\n"
1695 "Pragma: no-cache\r\n"
1696 "Cache-Control: no-cache\r\n"
1697 "Content-Length: 32767\r\n"
1698 "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1700 av_opt_set(rt
->rtsp_hd_out
->priv_data
, "headers", headers
, 0);
1701 av_opt_set(rt
->rtsp_hd_out
->priv_data
, "chunked_post", "0", 0);
1703 /* Initialize the authentication state for the POST session. The HTTP
1704 * protocol implementation doesn't properly handle multi-pass
1705 * authentication for POST requests, since it would require one of
1707 * - implementing Expect: 100-continue, which many HTTP servers
1708 * don't support anyway, even less the RTSP servers that do HTTP
1710 * - sending the whole POST data until getting a 401 reply specifying
1711 * what authentication method to use, then resending all that data
1712 * - waiting for potential 401 replies directly after sending the
1713 * POST header (waiting for some unspecified time)
1714 * Therefore, we copy the full auth state, which works for both basic
1715 * and digest. (For digest, we would have to synchronize the nonce
1716 * count variable between the two sessions, if we'd do more requests
1717 * with the original session, though.)
1719 ff_http_init_auth_state(rt
->rtsp_hd_out
, rt
->rtsp_hd
);
1721 /* complete the connection */
1722 if (ffurl_connect(rt
->rtsp_hd_out
, NULL
)) {
1727 /* open the tcp connection */
1728 ff_url_join(tcpname
, sizeof(tcpname
), "tcp", NULL
, host
, port
,
1729 "?timeout=%d", rt
->stimeout
);
1730 if (ffurl_open(&rt
->rtsp_hd
, tcpname
, AVIO_FLAG_READ_WRITE
,
1731 &s
->interrupt_callback
, NULL
) < 0) {
1735 rt
->rtsp_hd_out
= rt
->rtsp_hd
;
1739 tcp_fd
= ffurl_get_file_handle(rt
->rtsp_hd
);
1740 if (!getpeername(tcp_fd
, (struct sockaddr
*) &peer
, &peer_len
)) {
1741 getnameinfo((struct sockaddr
*) &peer
, peer_len
, host
, sizeof(host
),
1742 NULL
, 0, NI_NUMERICHOST
);
1745 /* request options supported by the server; this also detects server
1747 for (rt
->server_type
= RTSP_SERVER_RTP
;;) {
1749 if (rt
->server_type
== RTSP_SERVER_REAL
)
1752 * The following entries are required for proper
1753 * streaming from a Realmedia server. They are
1754 * interdependent in some way although we currently
1755 * don't quite understand how. Values were copied
1756 * from mplayer SVN r23589.
1757 * ClientChallenge is a 16-byte ID in hex
1758 * CompanyID is a 16-byte ID in base64
1760 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1761 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1762 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1763 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1765 ff_rtsp_send_cmd(s
, "OPTIONS", rt
->control_uri
, cmd
, reply
, NULL
);
1766 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1767 err
= AVERROR_INVALIDDATA
;
1771 /* detect server type if not standard-compliant RTP */
1772 if (rt
->server_type
!= RTSP_SERVER_REAL
&& reply
->real_challenge
[0]) {
1773 rt
->server_type
= RTSP_SERVER_REAL
;
1775 } else if (!av_strncasecmp(reply
->server
, "WMServer/", 9)) {
1776 rt
->server_type
= RTSP_SERVER_WMS
;
1777 } else if (rt
->server_type
== RTSP_SERVER_REAL
)
1778 strcpy(real_challenge
, reply
->real_challenge
);
1782 if (s
->iformat
&& CONFIG_RTSP_DEMUXER
)
1783 err
= ff_rtsp_setup_input_streams(s
, reply
);
1784 else if (CONFIG_RTSP_MUXER
)
1785 err
= ff_rtsp_setup_output_streams(s
, host
);
1790 int lower_transport
= ff_log2_tab
[lower_transport_mask
&
1791 ~(lower_transport_mask
- 1)];
1793 if ((lower_transport_mask
& (1 << RTSP_LOWER_TRANSPORT_TCP
))
1794 && (rt
->rtsp_flags
& RTSP_FLAG_PREFER_TCP
))
1795 lower_transport
= RTSP_LOWER_TRANSPORT_TCP
;
1797 err
= ff_rtsp_make_setup_request(s
, host
, port
, lower_transport
,
1798 rt
->server_type
== RTSP_SERVER_REAL
?
1799 real_challenge
: NULL
);
1802 lower_transport_mask
&= ~(1 << lower_transport
);
1803 if (lower_transport_mask
== 0 && err
== 1) {
1804 err
= AVERROR(EPROTONOSUPPORT
);
1809 rt
->lower_transport_mask
= lower_transport_mask
;
1810 av_strlcpy(rt
->real_challenge
, real_challenge
, sizeof(rt
->real_challenge
));
1811 rt
->state
= RTSP_STATE_IDLE
;
1812 rt
->seek_timestamp
= 0; /* default is to start stream at position zero */
1815 ff_rtsp_close_streams(s
);
1816 ff_rtsp_close_connections(s
);
1817 if (reply
->status_code
>=300 && reply
->status_code
< 400 && s
->iformat
) {
1818 av_strlcpy(s
->filename
, reply
->location
, sizeof(s
->filename
));
1819 av_log(s
, AV_LOG_INFO
, "Status %d: Redirecting to %s\n",
1827 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1830 static int udp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1831 uint8_t *buf
, int buf_size
, int64_t wait_end
)
1833 RTSPState
*rt
= s
->priv_data
;
1834 RTSPStream
*rtsp_st
;
1835 int n
, i
, ret
, tcp_fd
, timeout_cnt
= 0;
1837 struct pollfd
*p
= rt
->p
;
1838 int *fds
= NULL
, fdsnum
, fdsidx
;
1841 if (ff_check_interrupt(&s
->interrupt_callback
))
1842 return AVERROR_EXIT
;
1843 if (wait_end
&& wait_end
- av_gettime() < 0)
1844 return AVERROR(EAGAIN
);
1847 tcp_fd
= ffurl_get_file_handle(rt
->rtsp_hd
);
1848 p
[max_p
].fd
= tcp_fd
;
1849 p
[max_p
++].events
= POLLIN
;
1853 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1854 rtsp_st
= rt
->rtsp_streams
[i
];
1855 if (rtsp_st
->rtp_handle
) {
1856 if (ret
= ffurl_get_multi_file_handle(rtsp_st
->rtp_handle
,
1858 av_log(s
, AV_LOG_ERROR
, "Unable to recover rtp ports\n");
1862 av_log(s
, AV_LOG_ERROR
,
1863 "Number of fds %d not supported\n", fdsnum
);
1864 return AVERROR_INVALIDDATA
;
1866 for (fdsidx
= 0; fdsidx
< fdsnum
; fdsidx
++) {
1867 p
[max_p
].fd
= fds
[fdsidx
];
1868 p
[max_p
++].events
= POLLIN
;
1873 n
= poll(p
, max_p
, POLL_TIMEOUT_MS
);
1875 int j
= 1 - (tcp_fd
== -1);
1877 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1878 rtsp_st
= rt
->rtsp_streams
[i
];
1879 if (rtsp_st
->rtp_handle
) {
1880 if (p
[j
].revents
& POLLIN
|| p
[j
+1].revents
& POLLIN
) {
1881 ret
= ffurl_read(rtsp_st
->rtp_handle
, buf
, buf_size
);
1883 *prtsp_st
= rtsp_st
;
1890 #if CONFIG_RTSP_DEMUXER
1891 if (tcp_fd
!= -1 && p
[0].revents
& POLLIN
) {
1892 if (rt
->rtsp_flags
& RTSP_FLAG_LISTEN
) {
1893 if (rt
->state
== RTSP_STATE_STREAMING
) {
1894 if (!ff_rtsp_parse_streaming_commands(s
))
1897 av_log(s
, AV_LOG_WARNING
,
1898 "Unable to answer to TEARDOWN\n");
1902 RTSPMessageHeader reply
;
1903 ret
= ff_rtsp_read_reply(s
, &reply
, NULL
, 0, NULL
);
1906 /* XXX: parse message */
1907 if (rt
->state
!= RTSP_STATE_STREAMING
)
1912 } else if (n
== 0 && ++timeout_cnt
>= MAX_TIMEOUTS
) {
1913 return AVERROR(ETIMEDOUT
);
1914 } else if (n
< 0 && errno
!= EINTR
)
1915 return AVERROR(errno
);
1919 static int pick_stream(AVFormatContext
*s
, RTSPStream
**rtsp_st
,
1920 const uint8_t *buf
, int len
)
1922 RTSPState
*rt
= s
->priv_data
;
1926 if (rt
->nb_rtsp_streams
== 1) {
1927 *rtsp_st
= rt
->rtsp_streams
[0];
1930 if (len
>= 8 && rt
->transport
== RTSP_TRANSPORT_RTP
) {
1931 if (RTP_PT_IS_RTCP(rt
->recvbuf
[1])) {
1933 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1934 RTPDemuxContext
*rtpctx
= rt
->rtsp_streams
[i
]->transport_priv
;
1937 if (rtpctx
->ssrc
== AV_RB32(&buf
[4])) {
1938 *rtsp_st
= rt
->rtsp_streams
[i
];
1945 av_log(s
, AV_LOG_WARNING
,
1946 "Unable to pick stream for packet - SSRC not known for "
1948 return AVERROR(EAGAIN
);
1951 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1952 if ((buf
[1] & 0x7f) == rt
->rtsp_streams
[i
]->sdp_payload_type
) {
1953 *rtsp_st
= rt
->rtsp_streams
[i
];
1959 av_log(s
, AV_LOG_WARNING
, "Unable to pick stream for packet\n");
1960 return AVERROR(EAGAIN
);
1963 int ff_rtsp_fetch_packet(AVFormatContext
*s
, AVPacket
*pkt
)
1965 RTSPState
*rt
= s
->priv_data
;
1967 RTSPStream
*rtsp_st
, *first_queue_st
= NULL
;
1968 int64_t wait_end
= 0;
1970 if (rt
->nb_byes
== rt
->nb_rtsp_streams
)
1973 /* get next frames from the same RTP packet */
1974 if (rt
->cur_transport_priv
) {
1975 if (rt
->transport
== RTSP_TRANSPORT_RDT
) {
1976 ret
= ff_rdt_parse_packet(rt
->cur_transport_priv
, pkt
, NULL
, 0);
1977 } else if (rt
->transport
== RTSP_TRANSPORT_RTP
) {
1978 ret
= ff_rtp_parse_packet(rt
->cur_transport_priv
, pkt
, NULL
, 0);
1979 } else if (rt
->ts
&& CONFIG_RTPDEC
) {
1980 ret
= avpriv_mpegts_parse_packet(rt
->ts
, pkt
, rt
->recvbuf
+ rt
->recvbuf_pos
, rt
->recvbuf_len
- rt
->recvbuf_pos
);
1982 rt
->recvbuf_pos
+= ret
;
1983 ret
= rt
->recvbuf_pos
< rt
->recvbuf_len
;
1988 rt
->cur_transport_priv
= NULL
;
1990 } else if (ret
== 1) {
1993 rt
->cur_transport_priv
= NULL
;
1997 if (rt
->transport
== RTSP_TRANSPORT_RTP
) {
1999 int64_t first_queue_time
= 0;
2000 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
2001 RTPDemuxContext
*rtpctx
= rt
->rtsp_streams
[i
]->transport_priv
;
2005 queue_time
= ff_rtp_queued_packet_time(rtpctx
);
2006 if (queue_time
&& (queue_time
- first_queue_time
< 0 ||
2007 !first_queue_time
)) {
2008 first_queue_time
= queue_time
;
2009 first_queue_st
= rt
->rtsp_streams
[i
];
2012 if (first_queue_time
) {
2013 wait_end
= first_queue_time
+ s
->max_delay
;
2016 first_queue_st
= NULL
;
2020 /* read next RTP packet */
2022 rt
->recvbuf
= av_malloc(RECVBUF_SIZE
);
2024 return AVERROR(ENOMEM
);
2027 switch(rt
->lower_transport
) {
2029 #if CONFIG_RTSP_DEMUXER
2030 case RTSP_LOWER_TRANSPORT_TCP
:
2031 len
= ff_rtsp_tcp_read_packet(s
, &rtsp_st
, rt
->recvbuf
, RECVBUF_SIZE
);
2034 case RTSP_LOWER_TRANSPORT_UDP
:
2035 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
:
2036 len
= udp_read_packet(s
, &rtsp_st
, rt
->recvbuf
, RECVBUF_SIZE
, wait_end
);
2037 if (len
> 0 && rtsp_st
->transport_priv
&& rt
->transport
== RTSP_TRANSPORT_RTP
)
2038 ff_rtp_check_and_send_back_rr(rtsp_st
->transport_priv
, rtsp_st
->rtp_handle
, NULL
, len
);
2040 case RTSP_LOWER_TRANSPORT_CUSTOM
:
2041 if (first_queue_st
&& rt
->transport
== RTSP_TRANSPORT_RTP
&&
2042 wait_end
&& wait_end
< av_gettime())
2043 len
= AVERROR(EAGAIN
);
2045 len
= ffio_read_partial(s
->pb
, rt
->recvbuf
, RECVBUF_SIZE
);
2046 len
= pick_stream(s
, &rtsp_st
, rt
->recvbuf
, len
);
2047 if (len
> 0 && rtsp_st
->transport_priv
&& rt
->transport
== RTSP_TRANSPORT_RTP
)
2048 ff_rtp_check_and_send_back_rr(rtsp_st
->transport_priv
, NULL
, s
->pb
, len
);
2051 if (len
== AVERROR(EAGAIN
) && first_queue_st
&&
2052 rt
->transport
== RTSP_TRANSPORT_RTP
) {
2053 rtsp_st
= first_queue_st
;
2054 ret
= ff_rtp_parse_packet(rtsp_st
->transport_priv
, pkt
, NULL
, 0);
2061 if (rt
->transport
== RTSP_TRANSPORT_RDT
) {
2062 ret
= ff_rdt_parse_packet(rtsp_st
->transport_priv
, pkt
, &rt
->recvbuf
, len
);
2063 } else if (rt
->transport
== RTSP_TRANSPORT_RTP
) {
2064 ret
= ff_rtp_parse_packet(rtsp_st
->transport_priv
, pkt
, &rt
->recvbuf
, len
);
2065 if (rtsp_st
->feedback
) {
2066 AVIOContext
*pb
= NULL
;
2067 if (rt
->lower_transport
== RTSP_LOWER_TRANSPORT_CUSTOM
)
2069 ff_rtp_send_rtcp_feedback(rtsp_st
->transport_priv
, rtsp_st
->rtp_handle
, pb
);
2072 /* Either bad packet, or a RTCP packet. Check if the
2073 * first_rtcp_ntp_time field was initialized. */
2074 RTPDemuxContext
*rtpctx
= rtsp_st
->transport_priv
;
2075 if (rtpctx
->first_rtcp_ntp_time
!= AV_NOPTS_VALUE
) {
2076 /* first_rtcp_ntp_time has been initialized for this stream,
2077 * copy the same value to all other uninitialized streams,
2078 * in order to map their timestamp origin to the same ntp time
2081 AVStream
*st
= NULL
;
2082 if (rtsp_st
->stream_index
>= 0)
2083 st
= s
->streams
[rtsp_st
->stream_index
];
2084 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
2085 RTPDemuxContext
*rtpctx2
= rt
->rtsp_streams
[i
]->transport_priv
;
2086 AVStream
*st2
= NULL
;
2087 if (rt
->rtsp_streams
[i
]->stream_index
>= 0)
2088 st2
= s
->streams
[rt
->rtsp_streams
[i
]->stream_index
];
2089 if (rtpctx2
&& st
&& st2
&&
2090 rtpctx2
->first_rtcp_ntp_time
== AV_NOPTS_VALUE
) {
2091 rtpctx2
->first_rtcp_ntp_time
= rtpctx
->first_rtcp_ntp_time
;
2092 rtpctx2
->rtcp_ts_offset
= av_rescale_q(
2093 rtpctx
->rtcp_ts_offset
, st
->time_base
,
2097 // Make real NTP start time available in AVFormatContext
2098 if (s
->start_time_realtime
== AV_NOPTS_VALUE
) {
2099 s
->start_time_realtime
= av_rescale (rtpctx
->first_rtcp_ntp_time
- (NTP_OFFSET
<< 32), 1000000, 1LL << 32);
2101 s
->start_time_realtime
-=
2102 av_rescale (rtpctx
->rtcp_ts_offset
,
2103 (uint64_t) rtpctx
->st
->time_base
.num
* 1000000,
2104 rtpctx
->st
->time_base
.den
);
2108 if (ret
== -RTCP_BYE
) {
2111 av_log(s
, AV_LOG_DEBUG
, "Received BYE for stream %d (%d/%d)\n",
2112 rtsp_st
->stream_index
, rt
->nb_byes
, rt
->nb_rtsp_streams
);
2114 if (rt
->nb_byes
== rt
->nb_rtsp_streams
)
2118 } else if (rt
->ts
&& CONFIG_RTPDEC
) {
2119 ret
= avpriv_mpegts_parse_packet(rt
->ts
, pkt
, rt
->recvbuf
, len
);
2122 rt
->recvbuf_len
= len
;
2123 rt
->recvbuf_pos
= ret
;
2124 rt
->cur_transport_priv
= rt
->ts
;
2131 return AVERROR_INVALIDDATA
;
2137 /* more packets may follow, so we save the RTP context */
2138 rt
->cur_transport_priv
= rtsp_st
->transport_priv
;
2142 #endif /* CONFIG_RTPDEC */
2144 #if CONFIG_SDP_DEMUXER
2145 static int sdp_probe(AVProbeData
*p1
)
2147 const char *p
= p1
->buf
, *p_end
= p1
->buf
+ p1
->buf_size
;
2149 /* we look for a line beginning "c=IN IP" */
2150 while (p
< p_end
&& *p
!= '\0') {
2151 if (p
+ sizeof("c=IN IP") - 1 < p_end
&&
2152 av_strstart(p
, "c=IN IP", NULL
))
2153 return AVPROBE_SCORE_EXTENSION
;
2155 while (p
< p_end
- 1 && *p
!= '\n') p
++;
2164 static void append_source_addrs(char *buf
, int size
, const char *name
,
2165 int count
, struct RTSPSource
**addrs
)
2170 av_strlcatf(buf
, size
, "&%s=%s", name
, addrs
[0]->addr
);
2171 for (i
= 1; i
< count
; i
++)
2172 av_strlcatf(buf
, size
, ",%s", addrs
[i
]->addr
);
2175 static int sdp_read_header(AVFormatContext
*s
)
2177 RTSPState
*rt
= s
->priv_data
;
2178 RTSPStream
*rtsp_st
;
2183 if (!ff_network_init())
2184 return AVERROR(EIO
);
2186 if (s
->max_delay
< 0) /* Not set by the caller */
2187 s
->max_delay
= DEFAULT_REORDERING_DELAY
;
2188 if (rt
->rtsp_flags
& RTSP_FLAG_CUSTOM_IO
)
2189 rt
->lower_transport
= RTSP_LOWER_TRANSPORT_CUSTOM
;
2191 /* read the whole sdp file */
2192 /* XXX: better loading */
2193 content
= av_malloc(SDP_MAX_SIZE
);
2194 size
= avio_read(s
->pb
, content
, SDP_MAX_SIZE
- 1);
2197 return AVERROR_INVALIDDATA
;
2199 content
[size
] ='\0';
2201 err
= ff_sdp_parse(s
, content
);
2205 /* open each RTP stream */
2206 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
2208 rtsp_st
= rt
->rtsp_streams
[i
];
2210 if (!(rt
->rtsp_flags
& RTSP_FLAG_CUSTOM_IO
)) {
2211 getnameinfo((struct sockaddr
*) &rtsp_st
->sdp_ip
, sizeof(rtsp_st
->sdp_ip
),
2212 namebuf
, sizeof(namebuf
), NULL
, 0, NI_NUMERICHOST
);
2213 ff_url_join(url
, sizeof(url
), "rtp", NULL
,
2214 namebuf
, rtsp_st
->sdp_port
,
2215 "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2216 rtsp_st
->sdp_port
, rtsp_st
->sdp_ttl
,
2217 rt
->rtsp_flags
& RTSP_FLAG_FILTER_SRC
? 1 : 0,
2218 rt
->rtsp_flags
& RTSP_FLAG_RTCP_TO_SOURCE
? 1 : 0);
2220 append_source_addrs(url
, sizeof(url
), "sources",
2221 rtsp_st
->nb_include_source_addrs
,
2222 rtsp_st
->include_source_addrs
);
2223 append_source_addrs(url
, sizeof(url
), "block",
2224 rtsp_st
->nb_exclude_source_addrs
,
2225 rtsp_st
->exclude_source_addrs
);
2226 if (ffurl_open(&rtsp_st
->rtp_handle
, url
, AVIO_FLAG_READ_WRITE
,
2227 &s
->interrupt_callback
, NULL
) < 0) {
2228 err
= AVERROR_INVALIDDATA
;
2232 if ((err
= ff_rtsp_open_transport_ctx(s
, rtsp_st
)))
2237 ff_rtsp_close_streams(s
);
2242 static int sdp_read_close(AVFormatContext
*s
)
2244 ff_rtsp_close_streams(s
);
2249 static const AVClass sdp_demuxer_class
= {
2250 .class_name
= "SDP demuxer",
2251 .item_name
= av_default_item_name
,
2252 .option
= sdp_options
,
2253 .version
= LIBAVUTIL_VERSION_INT
,
2256 AVInputFormat ff_sdp_demuxer
= {
2258 .long_name
= NULL_IF_CONFIG_SMALL("SDP"),
2259 .priv_data_size
= sizeof(RTSPState
),
2260 .read_probe
= sdp_probe
,
2261 .read_header
= sdp_read_header
,
2262 .read_packet
= ff_rtsp_fetch_packet
,
2263 .read_close
= sdp_read_close
,
2264 .priv_class
= &sdp_demuxer_class
,
2266 #endif /* CONFIG_SDP_DEMUXER */
2268 #if CONFIG_RTP_DEMUXER
2269 static int rtp_probe(AVProbeData
*p
)
2271 if (av_strstart(p
->filename
, "rtp:", NULL
))
2272 return AVPROBE_SCORE_MAX
;
2276 static int rtp_read_header(AVFormatContext
*s
)
2278 uint8_t recvbuf
[RTP_MAX_PACKET_LENGTH
];
2279 char host
[500], sdp
[500];
2281 URLContext
* in
= NULL
;
2283 AVCodecContext codec
= { 0 };
2284 struct sockaddr_storage addr
;
2286 socklen_t addrlen
= sizeof(addr
);
2287 RTSPState
*rt
= s
->priv_data
;
2289 if (!ff_network_init())
2290 return AVERROR(EIO
);
2292 ret
= ffurl_open(&in
, s
->filename
, AVIO_FLAG_READ
,
2293 &s
->interrupt_callback
, NULL
);
2298 ret
= ffurl_read(in
, recvbuf
, sizeof(recvbuf
));
2299 if (ret
== AVERROR(EAGAIN
))
2304 av_log(s
, AV_LOG_WARNING
, "Received too short packet\n");
2308 if ((recvbuf
[0] & 0xc0) != 0x80) {
2309 av_log(s
, AV_LOG_WARNING
, "Unsupported RTP version packet "
2314 if (RTP_PT_IS_RTCP(recvbuf
[1]))
2317 payload_type
= recvbuf
[1] & 0x7f;
2320 getsockname(ffurl_get_file_handle(in
), (struct sockaddr
*) &addr
, &addrlen
);
2324 if (ff_rtp_get_codec_info(&codec
, payload_type
)) {
2325 av_log(s
, AV_LOG_ERROR
, "Unable to receive RTP payload type %d "
2326 "without an SDP file describing it\n",
2330 if (codec
.codec_type
!= AVMEDIA_TYPE_DATA
) {
2331 av_log(s
, AV_LOG_WARNING
, "Guessing on RTP content - if not received "
2332 "properly you need an SDP file "
2336 av_url_split(NULL
, 0, NULL
, 0, host
, sizeof(host
), &port
,
2337 NULL
, 0, s
->filename
);
2339 snprintf(sdp
, sizeof(sdp
),
2340 "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2341 addr
.ss_family
== AF_INET
? 4 : 6, host
,
2342 codec
.codec_type
== AVMEDIA_TYPE_DATA
? "application" :
2343 codec
.codec_type
== AVMEDIA_TYPE_VIDEO
? "video" : "audio",
2344 port
, payload_type
);
2345 av_log(s
, AV_LOG_VERBOSE
, "SDP:\n%s\n", sdp
);
2347 ffio_init_context(&pb
, sdp
, strlen(sdp
), 0, NULL
, NULL
, NULL
, NULL
);
2350 /* sdp_read_header initializes this again */
2353 rt
->media_type_mask
= (1 << (AVMEDIA_TYPE_DATA
+1)) - 1;
2355 ret
= sdp_read_header(s
);
2366 static const AVClass rtp_demuxer_class
= {
2367 .class_name
= "RTP demuxer",
2368 .item_name
= av_default_item_name
,
2369 .option
= rtp_options
,
2370 .version
= LIBAVUTIL_VERSION_INT
,
2373 AVInputFormat ff_rtp_demuxer
= {
2375 .long_name
= NULL_IF_CONFIG_SMALL("RTP input"),
2376 .priv_data_size
= sizeof(RTSPState
),
2377 .read_probe
= rtp_probe
,
2378 .read_header
= rtp_read_header
,
2379 .read_packet
= ff_rtsp_fetch_packet
,
2380 .read_close
= sdp_read_close
,
2381 .flags
= AVFMT_NOFILE
,
2382 .priv_class
= &rtp_demuxer_class
,
2384 #endif /* CONFIG_RTP_DEMUXER */