path: root/libavformat/rtsp.c (plain)
blob: 261e970b75a28d69a746db570d0d9452583a7c5d

1	/*
2	* RTSP/SDP client
3	* Copyright (c) 2002 Fabrice Bellard
4	*
5	* This file is part of FFmpeg.
6	*
7	* FFmpeg is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU Lesser General Public
9	* License as published by the Free Software Foundation; either
10	* version 2.1 of the License, or (at your option) any later version.
11	*
12	* FFmpeg is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15	* Lesser General Public License for more details.
16	*
17	* You should have received a copy of the GNU Lesser General Public
18	* License along with FFmpeg; if not, write to the Free Software
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	*/
21
22	#include "libavutil/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"
32	#include "avformat.h"
33	#include "avio_internal.h"
34
35	#if HAVE_POLL_H
36	#include <poll.h>
37	#endif
38	#include "internal.h"
39	#include "network.h"
40	#include "os_support.h"
41	#include "http.h"
42	#include "rtsp.h"
43
44	#include "rtpdec.h"
45	#include "rtpproto.h"
46	#include "rdt.h"
47	#include "rtpdec_formats.h"
48	#include "rtpenc_chain.h"
49	#include "url.h"
50	#include "rtpenc.h"
51	#include "mpegts.h"
52
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
61
62	#define OFFSET(x) offsetof(RTSPState, x)
63	#define DEC AV_OPT_FLAG_DECODING_PARAM
64	#define ENC AV_OPT_FLAG_ENCODING_PARAM
65
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" }
69
70	#define RTSP_MEDIATYPE_OPTS(name, longname) \
71	{ name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_SUBTITLE+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" }, \
75	{ "subtitle", "Subtitle", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_SUBTITLE}, 0, 0, DEC, "allowed_media_types" }
76
77	#define COMMON_OPTS() \
78	{ "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	{ "buffer_size", "Underlying protocol send/receive buffer size", OFFSET(buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC|ENC } \
80
81
82	const AVOption ff_rtsp_options[] = {
83	{ "initial_pause", "do not start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },
84	FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
85	{ "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, "rtsp_transport" }, \
86	{ "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
87	{ "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
88	{ "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, "rtsp_transport" },
89	{ "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, "rtsp_transport" },
90	RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),
91	{ "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, "rtsp_flags" },
92	{ "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" },
93	RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
94	{ "min_port", "set minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },
95	{ "max_port", "set maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },
96	{ "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 },
97	{ "stimeout", "set timeout (in microseconds) of socket TCP I/O operations", OFFSET(stimeout), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC },
98	COMMON_OPTS(),
99	{ "user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },
100	{ NULL },
101	};
102
103	static const AVOption sdp_options[] = {
104	RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
105	{ "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, "rtsp_flags" },
106	{ "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" },
107	RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
108	COMMON_OPTS(),
109	{ NULL },
110	};
111
112	static const AVOption rtp_options[] = {
113	RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
114	COMMON_OPTS(),
115	{ NULL },
116	};
117
118
119	static AVDictionary *map_to_opts(RTSPState *rt)
120	{
121	AVDictionary *opts = NULL;
122	char buf[256];
123
124	snprintf(buf, sizeof(buf), "%d", rt->buffer_size);
125	av_dict_set(&opts, "buffer_size", buf, 0);
126
127	return opts;
128	}
129
130	static void get_word_until_chars(char *buf, int buf_size,
131	const char *sep, const char **pp)
132	{
133	const char *p;
134	char *q;
135
136	p = *pp;
137	p += strspn(p, SPACE_CHARS);
138	q = buf;
139	while (!strchr(sep, *p) && *p != '\0') {
140	if ((q - buf) < buf_size - 1)
141	*q++ = *p;
142	p++;
143	}
144	if (buf_size > 0)
145	*q = '\0';
146	*pp = p;
147	}
148
149	static void get_word_sep(char *buf, int buf_size, const char *sep,
150	const char **pp)
151	{
152	if (**pp == '/') (*pp)++;
153	get_word_until_chars(buf, buf_size, sep, pp);
154	}
155
156	static void get_word(char *buf, int buf_size, const char **pp)
157	{
158	get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
159	}
160
161	/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
162	* and end time.
163	* Used for seeking in the rtp stream.
164	*/
165	static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
166	{
167	char buf[256];
168
169	p += strspn(p, SPACE_CHARS);
170	if (!av_stristart(p, "npt=", &p))
171	return;
172
173	*start = AV_NOPTS_VALUE;
174	*end = AV_NOPTS_VALUE;
175
176	get_word_sep(buf, sizeof(buf), "-", &p);
177	if (av_parse_time(start, buf, 1) < 0)
178	return;
179	if (*p == '-') {
180	p++;
181	get_word_sep(buf, sizeof(buf), "-", &p);
182	if (av_parse_time(end, buf, 1) < 0)
183	av_log(NULL, AV_LOG_DEBUG, "Failed to parse interval end specification '%s'\n", buf);
184	}
185	}
186
187	static int get_sockaddr(AVFormatContext *s,
188	const char *buf, struct sockaddr_storage *sock)
189	{
190	struct addrinfo hints = { 0 }, *ai = NULL;
191	int ret;
192
193	hints.ai_flags = AI_NUMERICHOST;
194	if ((ret = getaddrinfo(buf, NULL, &hints, &ai))) {
195	av_log(s, AV_LOG_ERROR, "getaddrinfo(%s): %s\n",
196	buf,
197	gai_strerror(ret));
198	return -1;
199	}
200	memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
201	freeaddrinfo(ai);
202	return 0;
203	}
204
205	#if CONFIG_RTPDEC
206	static void init_rtp_handler(RTPDynamicProtocolHandler *handler,
207	RTSPStream *rtsp_st, AVStream *st)
208	{
209	AVCodecParameters *par = st ? st->codecpar : NULL;
210	if (!handler)
211	return;
212	if (par)
213	par->codec_id = handler->codec_id;
214	rtsp_st->dynamic_handler = handler;
215	if (st)
216	st->need_parsing = handler->need_parsing;
217	if (handler->priv_data_size) {
218	rtsp_st->dynamic_protocol_context = av_mallocz(handler->priv_data_size);
219	if (!rtsp_st->dynamic_protocol_context)
220	rtsp_st->dynamic_handler = NULL;
221	}
222	}
223
224	static void finalize_rtp_handler_init(AVFormatContext *s, RTSPStream *rtsp_st,
225	AVStream *st)
226	{
227	if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init) {
228	int ret = rtsp_st->dynamic_handler->init(s, st ? st->index : -1,
229	rtsp_st->dynamic_protocol_context);
230	if (ret < 0) {
231	if (rtsp_st->dynamic_protocol_context) {
232	if (rtsp_st->dynamic_handler->close)
233	rtsp_st->dynamic_handler->close(
234	rtsp_st->dynamic_protocol_context);
235	av_free(rtsp_st->dynamic_protocol_context);
236	}
237	rtsp_st->dynamic_protocol_context = NULL;
238	rtsp_st->dynamic_handler = NULL;
239	}
240	}
241	}
242
243	/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
244	static int sdp_parse_rtpmap(AVFormatContext *s,
245	AVStream *st, RTSPStream *rtsp_st,
246	int payload_type, const char *p)
247	{
248	AVCodecParameters *par = st->codecpar;
249	char buf[256];
250	int i;
251	const AVCodecDescriptor *desc;
252	const char *c_name;
253
254	/* See if we can handle this kind of payload.
255	* The space should normally not be there but some Real streams or
256	* particular servers ("RealServer Version 6.1.3.970", see issue 1658)
257	* have a trailing space. */
258	get_word_sep(buf, sizeof(buf), "/ ", &p);
259	if (payload_type < RTP_PT_PRIVATE) {
260	/* We are in a standard case
261	* (from http://www.iana.org/assignments/rtp-parameters). */
262	par->codec_id = ff_rtp_codec_id(buf, par->codec_type);
263	}
264
265	if (par->codec_id == AV_CODEC_ID_NONE) {
266	RTPDynamicProtocolHandler *handler =
267	ff_rtp_handler_find_by_name(buf, par->codec_type);
268	init_rtp_handler(handler, rtsp_st, st);
269	/* If no dynamic handler was found, check with the list of standard
270	* allocated types, if such a stream for some reason happens to
271	* use a private payload type. This isn't handled in rtpdec.c, since
272	* the format name from the rtpmap line never is passed into rtpdec. */
273	if (!rtsp_st->dynamic_handler)
274	par->codec_id = ff_rtp_codec_id(buf, par->codec_type);
275	}
276
277	desc = avcodec_descriptor_get(par->codec_id);
278	if (desc && desc->name)
279	c_name = desc->name;
280	else
281	c_name = "(null)";
282
283	get_word_sep(buf, sizeof(buf), "/", &p);
284	i = atoi(buf);
285	switch (par->codec_type) {
286	case AVMEDIA_TYPE_AUDIO:
287	av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
288	par->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
289	par->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
290	if (i > 0) {
291	par->sample_rate = i;
292	avpriv_set_pts_info(st, 32, 1, par->sample_rate);
293	get_word_sep(buf, sizeof(buf), "/", &p);
294	i = atoi(buf);
295	if (i > 0)
296	par->channels = i;
297	}
298	av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
299	par->sample_rate);
300	av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
301	par->channels);
302	break;
303	case AVMEDIA_TYPE_VIDEO:
304	av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
305	if (i > 0)
306	avpriv_set_pts_info(st, 32, 1, i);
307	break;
308	default:
309	break;
310	}
311	finalize_rtp_handler_init(s, rtsp_st, st);
312	return 0;
313	}
314
315	/* parse the attribute line from the fmtp a line of an sdp response. This
316	* is broken out as a function because it is used in rtp_h264.c, which is
317	* forthcoming. */
318	int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
319	char *value, int value_size)
320	{
321	*p += strspn(*p, SPACE_CHARS);
322	if (**p) {
323	get_word_sep(attr, attr_size, "=", p);
324	if (**p == '=')
325	(*p)++;
326	get_word_sep(value, value_size, ";", p);
327	if (**p == ';')
328	(*p)++;
329	return 1;
330	}
331	return 0;
332	}
333
334	typedef struct SDPParseState {
335	/* SDP only */
336	struct sockaddr_storage default_ip;
337	int default_ttl;
338	int skip_media; ///< set if an unknown m= line occurs
339	int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */
340	struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */
341	int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
342	struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */
343	int seen_rtpmap;
344	int seen_fmtp;
345	char delayed_fmtp[2048];
346	} SDPParseState;
347
348	static void copy_default_source_addrs(struct RTSPSource **addrs, int count,
349	struct RTSPSource ***dest, int *dest_count)
350	{
351	RTSPSource *rtsp_src, *rtsp_src2;
352	int i;
353	for (i = 0; i < count; i++) {
354	rtsp_src = addrs[i];
355	rtsp_src2 = av_malloc(sizeof(*rtsp_src2));
356	if (!rtsp_src2)
357	continue;
358	memcpy(rtsp_src2, rtsp_src, sizeof(*rtsp_src));
359	dynarray_add(dest, dest_count, rtsp_src2);
360	}
361	}
362
363	static void parse_fmtp(AVFormatContext *s, RTSPState *rt,
364	int payload_type, const char *line)
365	{
366	int i;
367
368	for (i = 0; i < rt->nb_rtsp_streams; i++) {
369	RTSPStream *rtsp_st = rt->rtsp_streams[i];
370	if (rtsp_st->sdp_payload_type == payload_type &&
371	rtsp_st->dynamic_handler &&
372	rtsp_st->dynamic_handler->parse_sdp_a_line) {
373	rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
374	rtsp_st->dynamic_protocol_context, line);
375	}
376	}
377	}
378
379	static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
380	int letter, const char *buf)
381	{
382	RTSPState *rt = s->priv_data;
383	char buf1[64], st_type[64];
384	const char *p;
385	enum AVMediaType codec_type;
386	int payload_type;
387	AVStream *st;
388	RTSPStream *rtsp_st;
389	RTSPSource *rtsp_src;
390	struct sockaddr_storage sdp_ip;
391	int ttl;
392
393	av_log(s, AV_LOG_TRACE, "sdp: %c='%s'\n", letter, buf);
394
395	p = buf;
396	if (s1->skip_media && letter != 'm')
397	return;
398	switch (letter) {
399	case 'c':
400	get_word(buf1, sizeof(buf1), &p);
401	if (strcmp(buf1, "IN") != 0)
402	return;
403	get_word(buf1, sizeof(buf1), &p);
404	if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
405	return;
406	get_word_sep(buf1, sizeof(buf1), "/", &p);
407	if (get_sockaddr(s, buf1, &sdp_ip))
408	return;
409	ttl = 16;
410	if (*p == '/') {
411	p++;
412	get_word_sep(buf1, sizeof(buf1), "/", &p);
413	ttl = atoi(buf1);
414	}
415	if (s->nb_streams == 0) {
416	s1->default_ip = sdp_ip;
417	s1->default_ttl = ttl;
418	} else {
419	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
420	rtsp_st->sdp_ip = sdp_ip;
421	rtsp_st->sdp_ttl = ttl;
422	}
423	break;
424	case 's':
425	av_dict_set(&s->metadata, "title", p, 0);
426	break;
427	case 'i':
428	if (s->nb_streams == 0) {
429	av_dict_set(&s->metadata, "comment", p, 0);
430	break;
431	}
432	break;
433	case 'm':
434	/* new stream */
435	s1->skip_media = 0;
436	s1->seen_fmtp = 0;
437	s1->seen_rtpmap = 0;
438	codec_type = AVMEDIA_TYPE_UNKNOWN;
439	get_word(st_type, sizeof(st_type), &p);
440	if (!strcmp(st_type, "audio")) {
441	codec_type = AVMEDIA_TYPE_AUDIO;
442	} else if (!strcmp(st_type, "video")) {
443	codec_type = AVMEDIA_TYPE_VIDEO;
444	} else if (!strcmp(st_type, "application")) {
445	codec_type = AVMEDIA_TYPE_DATA;
446	} else if (!strcmp(st_type, "text")) {
447	codec_type = AVMEDIA_TYPE_SUBTITLE;
448	}
449	if (codec_type == AVMEDIA_TYPE_UNKNOWN || !(rt->media_type_mask & (1 << codec_type))) {
450	s1->skip_media = 1;
451	return;
452	}
453	rtsp_st = av_mallocz(sizeof(RTSPStream));
454	if (!rtsp_st)
455	return;
456	rtsp_st->stream_index = -1;
457	dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
458
459	rtsp_st->sdp_ip = s1->default_ip;
460	rtsp_st->sdp_ttl = s1->default_ttl;
461
462	copy_default_source_addrs(s1->default_include_source_addrs,
463	s1->nb_default_include_source_addrs,
464	&rtsp_st->include_source_addrs,
465	&rtsp_st->nb_include_source_addrs);
466	copy_default_source_addrs(s1->default_exclude_source_addrs,
467	s1->nb_default_exclude_source_addrs,
468	&rtsp_st->exclude_source_addrs,
469	&rtsp_st->nb_exclude_source_addrs);
470
471	get_word(buf1, sizeof(buf1), &p); /* port */
472	rtsp_st->sdp_port = atoi(buf1);
473
474	get_word(buf1, sizeof(buf1), &p); /* protocol */
475	if (!strcmp(buf1, "udp"))
476	rt->transport = RTSP_TRANSPORT_RAW;
477	else if (strstr(buf1, "/AVPF") || strstr(buf1, "/SAVPF"))
478	rtsp_st->feedback = 1;
479
480	/* XXX: handle list of formats */
481	get_word(buf1, sizeof(buf1), &p); /* format list */
482	rtsp_st->sdp_payload_type = atoi(buf1);
483
484	if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
485	/* no corresponding stream */
486	if (rt->transport == RTSP_TRANSPORT_RAW) {
487	if (CONFIG_RTPDEC && !rt->ts)
488	rt->ts = avpriv_mpegts_parse_open(s);
489	} else {
490	RTPDynamicProtocolHandler *handler;
491	handler = ff_rtp_handler_find_by_id(
492	rtsp_st->sdp_payload_type, AVMEDIA_TYPE_DATA);
493	init_rtp_handler(handler, rtsp_st, NULL);
494	finalize_rtp_handler_init(s, rtsp_st, NULL);
495	}
496	} else if (rt->server_type == RTSP_SERVER_WMS &&
497	codec_type == AVMEDIA_TYPE_DATA) {
498	/* RTX stream, a stream that carries all the other actual
499	* audio/video streams. Don't expose this to the callers. */
500	} else {
501	st = avformat_new_stream(s, NULL);
502	if (!st)
503	return;
504	st->id = rt->nb_rtsp_streams - 1;
505	rtsp_st->stream_index = st->index;
506	st->codecpar->codec_type = codec_type;
507	if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
508	RTPDynamicProtocolHandler *handler;
509	/* if standard payload type, we can find the codec right now */
510	ff_rtp_get_codec_info(st->codecpar, rtsp_st->sdp_payload_type);
511	if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
512	st->codecpar->sample_rate > 0)
513	avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
514	/* Even static payload types may need a custom depacketizer */
515	handler = ff_rtp_handler_find_by_id(
516	rtsp_st->sdp_payload_type, st->codecpar->codec_type);
517	init_rtp_handler(handler, rtsp_st, st);
518	finalize_rtp_handler_init(s, rtsp_st, st);
519	}
520	if (rt->default_lang[0])
521	av_dict_set(&st->metadata, "language", rt->default_lang, 0);
522	}
523	/* put a default control url */
524	av_strlcpy(rtsp_st->control_url, rt->control_uri,
525	sizeof(rtsp_st->control_url));
526	break;
527	case 'a':
528	if (av_strstart(p, "control:", &p)) {
529	if (s->nb_streams == 0) {
530	if (!strncmp(p, "rtsp://", 7))
531	av_strlcpy(rt->control_uri, p,
532	sizeof(rt->control_uri));
533	} else {
534	char proto[32];
535	/* get the control url */
536	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
537
538	/* XXX: may need to add full url resolution */
539	av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
540	NULL, NULL, 0, p);
541	if (proto[0] == '\0') {
542	/* relative control URL */
543	if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
544	av_strlcat(rtsp_st->control_url, "/",
545	sizeof(rtsp_st->control_url));
546	av_strlcat(rtsp_st->control_url, p,
547	sizeof(rtsp_st->control_url));
548	} else
549	av_strlcpy(rtsp_st->control_url, p,
550	sizeof(rtsp_st->control_url));
551	}
552	} else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
553	/* NOTE: rtpmap is only supported AFTER the 'm=' tag */
554	get_word(buf1, sizeof(buf1), &p);
555	payload_type = atoi(buf1);
556	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
557	if (rtsp_st->stream_index >= 0) {
558	st = s->streams[rtsp_st->stream_index];
559	sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
560	}
561	s1->seen_rtpmap = 1;
562	if (s1->seen_fmtp) {
563	parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);
564	}
565	} else if (av_strstart(p, "fmtp:", &p) ||
566	av_strstart(p, "framesize:", &p)) {
567	// let dynamic protocol handlers have a stab at the line.
568	get_word(buf1, sizeof(buf1), &p);
569	payload_type = atoi(buf1);
570	if (s1->seen_rtpmap) {
571	parse_fmtp(s, rt, payload_type, buf);
572	} else {
573	s1->seen_fmtp = 1;
574	av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp));
575	}
576	} else if (av_strstart(p, "ssrc:", &p) && s->nb_streams > 0) {
577	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
578	get_word(buf1, sizeof(buf1), &p);
579	rtsp_st->ssrc = strtoll(buf1, NULL, 10);
580	} else if (av_strstart(p, "range:", &p)) {
581	int64_t start, end;
582
583	// this is so that seeking on a streamed file can work.
584	rtsp_parse_range_npt(p, &start, &end);
585	s->start_time = start;
586	/* AV_NOPTS_VALUE means live broadcast (and can't seek) */
587	s->duration = (end == AV_NOPTS_VALUE) ?
588	AV_NOPTS_VALUE : end - start;
589	} else if (av_strstart(p, "lang:", &p)) {
590	if (s->nb_streams > 0) {
591	get_word(buf1, sizeof(buf1), &p);
592	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
593	if (rtsp_st->stream_index >= 0) {
594	st = s->streams[rtsp_st->stream_index];
595	av_dict_set(&st->metadata, "language", buf1, 0);
596	}
597	} else
598	get_word(rt->default_lang, sizeof(rt->default_lang), &p);
599	} else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
600	if (atoi(p) == 1)
601	rt->transport = RTSP_TRANSPORT_RDT;
602	} else if (av_strstart(p, "SampleRate:integer;", &p) &&
603	s->nb_streams > 0) {
604	st = s->streams[s->nb_streams - 1];
605	st->codecpar->sample_rate = atoi(p);
606	} else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {
607	// RFC 4568
608	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
609	get_word(buf1, sizeof(buf1), &p); // ignore tag
610	get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);
611	p += strspn(p, SPACE_CHARS);
612	if (av_strstart(p, "inline:", &p))
613	get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);
614	} else if (av_strstart(p, "source-filter:", &p)) {
615	int exclude = 0;
616	get_word(buf1, sizeof(buf1), &p);
617	if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))
618	return;
619	exclude = !strcmp(buf1, "excl");
620
621	get_word(buf1, sizeof(buf1), &p);
622	if (strcmp(buf1, "IN") != 0)
623	return;
624	get_word(buf1, sizeof(buf1), &p);
625	if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))
626	return;
627	// not checking that the destination address actually matches or is wildcard
628	get_word(buf1, sizeof(buf1), &p);
629
630	while (*p != '\0') {
631	rtsp_src = av_mallocz(sizeof(*rtsp_src));
632	if (!rtsp_src)
633	return;
634	get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);
635	if (exclude) {
636	if (s->nb_streams == 0) {
637	dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
638	} else {
639	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
640	dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);
641	}
642	} else {
643	if (s->nb_streams == 0) {
644	dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
645	} else {
646	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
647	dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);
648	}
649	}
650	}
651	} else {
652	if (rt->server_type == RTSP_SERVER_WMS)
653	ff_wms_parse_sdp_a_line(s, p);
654	if (s->nb_streams > 0) {
655	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
656
657	if (rt->server_type == RTSP_SERVER_REAL)
658	ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p);
659
660	if (rtsp_st->dynamic_handler &&
661	rtsp_st->dynamic_handler->parse_sdp_a_line)
662	rtsp_st->dynamic_handler->parse_sdp_a_line(s,
663	rtsp_st->stream_index,
664	rtsp_st->dynamic_protocol_context, buf);
665	}
666	}
667	break;
668	}
669	}
670
671	int ff_sdp_parse(AVFormatContext *s, const char *content)
672	{
673	RTSPState *rt = s->priv_data;
674	const char *p;
675	int letter, i;
676	/* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
677	* contain long SDP lines containing complete ASF Headers (several
678	* kB) or arrays of MDPR (RM stream descriptor) headers plus
679	* "rulebooks" describing their properties. Therefore, the SDP line
680	* buffer is large.
681	*
682	* The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
683	* in rtpdec_xiph.c. */
684	char buf[16384], *q;
685	SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
686
687	p = content;
688	for (;;) {
689	p += strspn(p, SPACE_CHARS);
690	letter = *p;
691	if (letter == '\0')
692	break;
693	p++;
694	if (*p != '=')
695	goto next_line;
696	p++;
697	/* get the content */
698	q = buf;
699	while (*p != '\n' && *p != '\r' && *p != '\0') {
700	if ((q - buf) < sizeof(buf) - 1)
701	*q++ = *p;
702	p++;
703	}
704	*q = '\0';
705	sdp_parse_line(s, s1, letter, buf);
706	next_line:
707	while (*p != '\n' && *p != '\0')
708	p++;
709	if (*p == '\n')
710	p++;
711	}
712
713	for (i = 0; i < s1->nb_default_include_source_addrs; i++)
714	av_freep(&s1->default_include_source_addrs[i]);
715	av_freep(&s1->default_include_source_addrs);
716	for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
717	av_freep(&s1->default_exclude_source_addrs[i]);
718	av_freep(&s1->default_exclude_source_addrs);
719
720	rt->p = av_malloc_array(rt->nb_rtsp_streams + 1, sizeof(struct pollfd) * 2);
721	if (!rt->p) return AVERROR(ENOMEM);
722	return 0;
723	}
724	#endif /* CONFIG_RTPDEC */
725
726	void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
727	{
728	RTSPState *rt = s->priv_data;
729	int i;
730
731	for (i = 0; i < rt->nb_rtsp_streams; i++) {
732	RTSPStream *rtsp_st = rt->rtsp_streams[i];
733	if (!rtsp_st)
734	continue;
735	if (rtsp_st->transport_priv) {
736	if (s->oformat) {
737	AVFormatContext *rtpctx = rtsp_st->transport_priv;
738	av_write_trailer(rtpctx);
739	if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
740	if (CONFIG_RTSP_MUXER && rtpctx->pb && send_packets)
741	ff_rtsp_tcp_write_packet(s, rtsp_st);
742	ffio_free_dyn_buf(&rtpctx->pb);
743	} else {
744	avio_closep(&rtpctx->pb);
745	}
746	avformat_free_context(rtpctx);
747	} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
748	ff_rdt_parse_close(rtsp_st->transport_priv);
749	else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)
750	ff_rtp_parse_close(rtsp_st->transport_priv);
751	}
752	rtsp_st->transport_priv = NULL;
753	if (rtsp_st->rtp_handle)
754	ffurl_close(rtsp_st->rtp_handle);
755	rtsp_st->rtp_handle = NULL;
756	}
757	}
758
759	/* close and free RTSP streams */
760	void ff_rtsp_close_streams(AVFormatContext *s)
761	{
762	RTSPState *rt = s->priv_data;
763	int i, j;
764	RTSPStream *rtsp_st;
765
766	ff_rtsp_undo_setup(s, 0);
767	for (i = 0; i < rt->nb_rtsp_streams; i++) {
768	rtsp_st = rt->rtsp_streams[i];
769	if (rtsp_st) {
770	if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) {
771	if (rtsp_st->dynamic_handler->close)
772	rtsp_st->dynamic_handler->close(
773	rtsp_st->dynamic_protocol_context);
774	av_free(rtsp_st->dynamic_protocol_context);
775	}
776	for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)
777	av_freep(&rtsp_st->include_source_addrs[j]);
778	av_freep(&rtsp_st->include_source_addrs);
779	for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)
780	av_freep(&rtsp_st->exclude_source_addrs[j]);
781	av_freep(&rtsp_st->exclude_source_addrs);
782
783	av_freep(&rtsp_st);
784	}
785	}
786	av_freep(&rt->rtsp_streams);
787	if (rt->asf_ctx) {
788	avformat_close_input(&rt->asf_ctx);
789	}
790	if (CONFIG_RTPDEC && rt->ts)
791	avpriv_mpegts_parse_close(rt->ts);
792	av_freep(&rt->p);
793	av_freep(&rt->recvbuf);
794	}
795
796	int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
797	{
798	RTSPState *rt = s->priv_data;
799	AVStream *st = NULL;
800	int reordering_queue_size = rt->reordering_queue_size;
801	if (reordering_queue_size < 0) {
802	if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
803	reordering_queue_size = 0;
804	else
805	reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
806	}
807
808	/* open the RTP context */
809	if (rtsp_st->stream_index >= 0)
810	st = s->streams[rtsp_st->stream_index];
811	if (!st)
812	s->ctx_flags |= AVFMTCTX_NOHEADER;
813
814	if (CONFIG_RTSP_MUXER && s->oformat && st) {
815	int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,
816	s, st, rtsp_st->rtp_handle,
817	RTSP_TCP_MAX_PACKET_SIZE,
818	rtsp_st->stream_index);
819	/* Ownership of rtp_handle is passed to the rtp mux context */
820	rtsp_st->rtp_handle = NULL;
821	if (ret < 0)
822	return ret;
823	st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
824	} else if (rt->transport == RTSP_TRANSPORT_RAW) {
825	return 0; // Don't need to open any parser here
826	} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT && st)
827	rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
828	rtsp_st->dynamic_protocol_context,
829	rtsp_st->dynamic_handler);
830	else if (CONFIG_RTPDEC)
831	rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
832	rtsp_st->sdp_payload_type,
833	reordering_queue_size);
834
835	if (!rtsp_st->transport_priv) {
836	return AVERROR(ENOMEM);
837	} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP &&
838	s->iformat) {
839	RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
840	rtpctx->ssrc = rtsp_st->ssrc;
841	if (rtsp_st->dynamic_handler) {
842	ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
843	rtsp_st->dynamic_protocol_context,
844	rtsp_st->dynamic_handler);
845	}
846	if (rtsp_st->crypto_suite[0])
847	ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
848	rtsp_st->crypto_suite,
849	rtsp_st->crypto_params);
850	}
851
852	return 0;
853	}
854
855	#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
856	static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
857	{
858	const char *q;
859	char *p;
860	int v;
861
862	q = *pp;
863	q += strspn(q, SPACE_CHARS);
864	v = strtol(q, &p, 10);
865	if (*p == '-') {
866	p++;
867	*min_ptr = v;
868	v = strtol(p, &p, 10);
869	*max_ptr = v;
870	} else {
871	*min_ptr = v;
872	*max_ptr = v;
873	}
874	*pp = p;
875	}
876
877	/* XXX: only one transport specification is parsed */
878	static void rtsp_parse_transport(AVFormatContext *s,
879	RTSPMessageHeader *reply, const char *p)
880	{
881	char transport_protocol[16];
882	char profile[16];
883	char lower_transport[16];
884	char parameter[16];
885	RTSPTransportField *th;
886	char buf[256];
887
888	reply->nb_transports = 0;
889
890	for (;;) {
891	p += strspn(p, SPACE_CHARS);
892	if (*p == '\0')
893	break;
894
895	th = &reply->transports[reply->nb_transports];
896
897	get_word_sep(transport_protocol, sizeof(transport_protocol),
898	"/", &p);
899	if (!av_strcasecmp (transport_protocol, "rtp")) {
900	get_word_sep(profile, sizeof(profile), "/;,", &p);
901	lower_transport[0] = '\0';
902	/* rtp/avp/<protocol> */
903	if (*p == '/') {
904	get_word_sep(lower_transport, sizeof(lower_transport),
905	";,", &p);
906	}
907	th->transport = RTSP_TRANSPORT_RTP;
908	} else if (!av_strcasecmp (transport_protocol, "x-pn-tng") ||
909	!av_strcasecmp (transport_protocol, "x-real-rdt")) {
910	/* x-pn-tng/<protocol> */
911	get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
912	profile[0] = '\0';
913	th->transport = RTSP_TRANSPORT_RDT;
914	} else if (!av_strcasecmp(transport_protocol, "raw")) {
915	get_word_sep(profile, sizeof(profile), "/;,", &p);
916	lower_transport[0] = '\0';
917	/* raw/raw/<protocol> */
918	if (*p == '/') {
919	get_word_sep(lower_transport, sizeof(lower_transport),
920	";,", &p);
921	}
922	th->transport = RTSP_TRANSPORT_RAW;
923	}
924	if (!av_strcasecmp(lower_transport, "TCP"))
925	th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
926	else
927	th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
928
929	if (*p == ';')
930	p++;
931	/* get each parameter */
932	while (*p != '\0' && *p != ',') {
933	get_word_sep(parameter, sizeof(parameter), "=;,", &p);
934	if (!strcmp(parameter, "port")) {
935	if (*p == '=') {
936	p++;
937	rtsp_parse_range(&th->port_min, &th->port_max, &p);
938	}
939	} else if (!strcmp(parameter, "client_port")) {
940	if (*p == '=') {
941	p++;
942	rtsp_parse_range(&th->client_port_min,
943	&th->client_port_max, &p);
944	}
945	} else if (!strcmp(parameter, "server_port")) {
946	if (*p == '=') {
947	p++;
948	rtsp_parse_range(&th->server_port_min,
949	&th->server_port_max, &p);
950	}
951	} else if (!strcmp(parameter, "interleaved")) {
952	if (*p == '=') {
953	p++;
954	rtsp_parse_range(&th->interleaved_min,
955	&th->interleaved_max, &p);
956	}
957	} else if (!strcmp(parameter, "multicast")) {
958	if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
959	th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
960	} else if (!strcmp(parameter, "ttl")) {
961	if (*p == '=') {
962	char *end;
963	p++;
964	th->ttl = strtol(p, &end, 10);
965	p = end;
966	}
967	} else if (!strcmp(parameter, "destination")) {
968	if (*p == '=') {
969	p++;
970	get_word_sep(buf, sizeof(buf), ";,", &p);
971	get_sockaddr(s, buf, &th->destination);
972	}
973	} else if (!strcmp(parameter, "source")) {
974	if (*p == '=') {
975	p++;
976	get_word_sep(buf, sizeof(buf), ";,", &p);
977	av_strlcpy(th->source, buf, sizeof(th->source));
978	}
979	} else if (!strcmp(parameter, "mode")) {
980	if (*p == '=') {
981	p++;
982	get_word_sep(buf, sizeof(buf), ";, ", &p);
983	if (!strcmp(buf, "record") ||
984	!strcmp(buf, "receive"))
985	th->mode_record = 1;
986	}
987	}
988
989	while (*p != ';' && *p != '\0' && *p != ',')
990	p++;
991	if (*p == ';')
992	p++;
993	}
994	if (*p == ',')
995	p++;
996
997	reply->nb_transports++;
998	if (reply->nb_transports >= RTSP_MAX_TRANSPORTS)
999	break;
1000	}
1001	}
1002
1003	static void handle_rtp_info(RTSPState *rt, const char *url,
1004	uint32_t seq, uint32_t rtptime)
1005	{
1006	int i;
1007	if (!rtptime || !url[0])
1008	return;
1009	if (rt->transport != RTSP_TRANSPORT_RTP)
1010	return;
1011	for (i = 0; i < rt->nb_rtsp_streams; i++) {
1012	RTSPStream *rtsp_st = rt->rtsp_streams[i];
1013	RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1014	if (!rtpctx)
1015	continue;
1016	if (!strcmp(rtsp_st->control_url, url)) {
1017	rtpctx->base_timestamp = rtptime;
1018	break;
1019	}
1020	}
1021	}
1022
1023	static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
1024	{
1025	int read = 0;
1026	char key[20], value[1024], url[1024] = "";
1027	uint32_t seq = 0, rtptime = 0;
1028
1029	for (;;) {
1030	p += strspn(p, SPACE_CHARS);
1031	if (!*p)
1032	break;
1033	get_word_sep(key, sizeof(key), "=", &p);
1034	if (*p != '=')
1035	break;
1036	p++;
1037	get_word_sep(value, sizeof(value), ";, ", &p);
1038	read++;
1039	if (!strcmp(key, "url"))
1040	av_strlcpy(url, value, sizeof(url));
1041	else if (!strcmp(key, "seq"))
1042	seq = strtoul(value, NULL, 10);
1043	else if (!strcmp(key, "rtptime"))
1044	rtptime = strtoul(value, NULL, 10);
1045	if (*p == ',') {
1046	handle_rtp_info(rt, url, seq, rtptime);
1047	url[0] = '\0';
1048	seq = rtptime = 0;
1049	read = 0;
1050	}
1051	if (*p)
1052	p++;
1053	}
1054	if (read > 0)
1055	handle_rtp_info(rt, url, seq, rtptime);
1056	}
1057
1058	void ff_rtsp_parse_line(AVFormatContext *s,
1059	RTSPMessageHeader *reply, const char *buf,
1060	RTSPState *rt, const char *method)
1061	{
1062	const char *p;
1063
1064	/* NOTE: we do case independent match for broken servers */
1065	p = buf;
1066	if (av_stristart(p, "Session:", &p)) {
1067	int t;
1068	get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
1069	if (av_stristart(p, ";timeout=", &p) &&
1070	(t = strtol(p, NULL, 10)) > 0) {
1071	reply->timeout = t;
1072	}
1073	} else if (av_stristart(p, "Content-Length:", &p)) {
1074	reply->content_length = strtol(p, NULL, 10);
1075	} else if (av_stristart(p, "Transport:", &p)) {
1076	rtsp_parse_transport(s, reply, p);
1077	} else if (av_stristart(p, "CSeq:", &p)) {
1078	reply->seq = strtol(p, NULL, 10);
1079	} else if (av_stristart(p, "Range:", &p)) {
1080	rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
1081	} else if (av_stristart(p, "RealChallenge1:", &p)) {
1082	p += strspn(p, SPACE_CHARS);
1083	av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
1084	} else if (av_stristart(p, "Server:", &p)) {
1085	p += strspn(p, SPACE_CHARS);
1086	av_strlcpy(reply->server, p, sizeof(reply->server));
1087	} else if (av_stristart(p, "Notice:", &p) ||
1088	av_stristart(p, "X-Notice:", &p)) {
1089	reply->notice = strtol(p, NULL, 10);
1090	} else if (av_stristart(p, "Location:", &p)) {
1091	p += strspn(p, SPACE_CHARS);
1092	av_strlcpy(reply->location, p , sizeof(reply->location));
1093	} else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
1094	p += strspn(p, SPACE_CHARS);
1095	ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
1096	} else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
1097	p += strspn(p, SPACE_CHARS);
1098	ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
1099	} else if (av_stristart(p, "Content-Base:", &p) && rt) {
1100	p += strspn(p, SPACE_CHARS);
1101	if (method && !strcmp(method, "DESCRIBE"))
1102	av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
1103	} else if (av_stristart(p, "RTP-Info:", &p) && rt) {
1104	p += strspn(p, SPACE_CHARS);
1105	if (method && !strcmp(method, "PLAY"))
1106	rtsp_parse_rtp_info(rt, p);
1107	} else if (av_stristart(p, "Public:", &p) && rt) {
1108	if (strstr(p, "GET_PARAMETER") &&
1109	method && !strcmp(method, "OPTIONS"))
1110	rt->get_parameter_supported = 1;
1111	} else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
1112	p += strspn(p, SPACE_CHARS);
1113	rt->accept_dynamic_rate = atoi(p);
1114	} else if (av_stristart(p, "Content-Type:", &p)) {
1115	p += strspn(p, SPACE_CHARS);
1116	av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
1117	}
1118	}
1119
1120	/* skip a RTP/TCP interleaved packet */
1121	void ff_rtsp_skip_packet(AVFormatContext *s)
1122	{
1123	RTSPState *rt = s->priv_data;
1124	int ret, len, len1;
1125	uint8_t buf[1024];
1126
1127	ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
1128	if (ret != 3)
1129	return;
1130	len = AV_RB16(buf + 1);
1131
1132	av_log(s, AV_LOG_TRACE, "skipping RTP packet len=%d\n", len);
1133
1134	/* skip payload */
1135	while (len > 0) {
1136	len1 = len;
1137	if (len1 > sizeof(buf))
1138	len1 = sizeof(buf);
1139	ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);
1140	if (ret != len1)
1141	return;
1142	len -= len1;
1143	}
1144	}
1145
1146	int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
1147	unsigned char **content_ptr,
1148	int return_on_interleaved_data, const char *method)
1149	{
1150	RTSPState *rt = s->priv_data;
1151	char buf[4096], buf1[1024], *q;
1152	unsigned char ch;
1153	const char *p;
1154	int ret, content_length, line_count = 0, request = 0;
1155	unsigned char *content = NULL;
1156
1157	start:
1158	line_count = 0;
1159	request = 0;
1160	content = NULL;
1161	memset(reply, 0, sizeof(*reply));
1162
1163	/* parse reply (XXX: use buffers) */
1164	rt->last_reply[0] = '\0';
1165	for (;;) {
1166	q = buf;
1167	for (;;) {
1168	ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
1169	av_log(s, AV_LOG_TRACE, "ret=%d c=%02x [%c]\n", ret, ch, ch);
1170	if (ret != 1)
1171	return AVERROR_EOF;
1172	if (ch == '\n')
1173	break;
1174	if (ch == '$' && q == buf) {
1175	if (return_on_interleaved_data) {
1176	return 1;
1177	} else
1178	ff_rtsp_skip_packet(s);
1179	} else if (ch != '\r') {
1180	if ((q - buf) < sizeof(buf) - 1)
1181	*q++ = ch;
1182	}
1183	}
1184	*q = '\0';
1185
1186	av_log(s, AV_LOG_TRACE, "line='%s'\n", buf);
1187
1188	/* test if last line */
1189	if (buf[0] == '\0')
1190	break;
1191	p = buf;
1192	if (line_count == 0) {
1193	/* get reply code */
1194	get_word(buf1, sizeof(buf1), &p);
1195	if (!strncmp(buf1, "RTSP/", 5)) {
1196	get_word(buf1, sizeof(buf1), &p);
1197	reply->status_code = atoi(buf1);
1198	av_strlcpy(reply->reason, p, sizeof(reply->reason));
1199	} else {
1200	av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
1201	get_word(buf1, sizeof(buf1), &p); // object
1202	request = 1;
1203	}
1204	} else {
1205	ff_rtsp_parse_line(s, reply, p, rt, method);
1206	av_strlcat(rt->last_reply, p, sizeof(rt->last_reply));
1207	av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
1208	}
1209	line_count++;
1210	}
1211
1212	if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
1213	av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
1214
1215	content_length = reply->content_length;
1216	if (content_length > 0) {
1217	/* leave some room for a trailing '\0' (useful for simple parsing) */
1218	content = av_malloc(content_length + 1);
1219	if (!content)
1220	return AVERROR(ENOMEM);
1221	ffurl_read_complete(rt->rtsp_hd, content, content_length);
1222	content[content_length] = '\0';
1223	}
1224	if (content_ptr)
1225	*content_ptr = content;
1226	else
1227	av_freep(&content);
1228
1229	if (request) {
1230	char buf[1024];
1231	char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1232	const char* ptr = buf;
1233
1234	if (!strcmp(reply->reason, "OPTIONS")) {
1235	snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
1236	if (reply->seq)
1237	av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
1238	if (reply->session_id[0])
1239	av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
1240	reply->session_id);
1241	} else {
1242	snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
1243	}
1244	av_strlcat(buf, "\r\n", sizeof(buf));
1245
1246	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1247	av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1248	ptr = base64buf;
1249	}
1250	ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
1251
1252	rt->last_cmd_time = av_gettime_relative();
1253	/* Even if the request from the server had data, it is not the data
1254	* that the caller wants or expects. The memory could also be leaked
1255	* if the actual following reply has content data. */
1256	if (content_ptr)
1257	av_freep(content_ptr);
1258	/* If method is set, this is called from ff_rtsp_send_cmd,
1259	* where a reply to exactly this request is awaited. For
1260	* callers from within packet receiving, we just want to
1261	* return to the caller and go back to receiving packets. */
1262	if (method)
1263	goto start;
1264	return 0;
1265	}
1266
1267	if (rt->seq != reply->seq) {
1268	av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
1269	rt->seq, reply->seq);
1270	}
1271
1272	/* EOS */
1273	if (reply->notice == 2101 /* End-of-Stream Reached */ ||
1274	reply->notice == 2104 /* Start-of-Stream Reached */ ||
1275	reply->notice == 2306 /* Continuous Feed Terminated */) {
1276	rt->state = RTSP_STATE_IDLE;
1277	} else if (reply->notice >= 4400 && reply->notice < 5500) {
1278	return AVERROR(EIO); /* data or server error */
1279	} else if (reply->notice == 2401 /* Ticket Expired */ ||
1280	(reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
1281	return AVERROR(EPERM);
1282
1283	return 0;
1284	}
1285
1286	/**
1287	* Send a command to the RTSP server without waiting for the reply.
1288	*
1289	* @param s RTSP (de)muxer context
1290	* @param method the method for the request
1291	* @param url the target url for the request
1292	* @param headers extra header lines to include in the request
1293	* @param send_content if non-null, the data to send as request body content
1294	* @param send_content_length the length of the send_content data, or 0 if
1295	* send_content is null
1296	*
1297	* @return zero if success, nonzero otherwise
1298	*/
1299	static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
1300	const char *method, const char *url,
1301	const char *headers,
1302	const unsigned char *send_content,
1303	int send_content_length)
1304	{
1305	RTSPState *rt = s->priv_data;
1306	char buf[4096], *out_buf;
1307	char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1308
1309	/* Add in RTSP headers */
1310	out_buf = buf;
1311	rt->seq++;
1312	snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
1313	if (headers)
1314	av_strlcat(buf, headers, sizeof(buf));
1315	av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
1316	av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent);
1317	if (rt->session_id[0] != '\0' && (!headers ||
1318	!strstr(headers, "\nIf-Match:"))) {
1319	av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
1320	}
1321	if (rt->auth[0]) {
1322	char *str = ff_http_auth_create_response(&rt->auth_state,
1323	rt->auth, url, method);
1324	if (str)
1325	av_strlcat(buf, str, sizeof(buf));
1326	av_free(str);
1327	}
1328	if (send_content_length > 0 && send_content)
1329	av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1330	av_strlcat(buf, "\r\n", sizeof(buf));
1331
1332	/* base64 encode rtsp if tunneling */
1333	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1334	av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1335	out_buf = base64buf;
1336	}
1337
1338	av_log(s, AV_LOG_TRACE, "Sending:\n%s--\n", buf);
1339
1340	ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
1341	if (send_content_length > 0 && send_content) {
1342	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1343	avpriv_report_missing_feature(s, "Tunneling of RTSP requests with content data");
1344	return AVERROR_PATCHWELCOME;
1345	}
1346	ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
1347	}
1348	rt->last_cmd_time = av_gettime_relative();
1349
1350	return 0;
1351	}
1352
1353	int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1354	const char *url, const char *headers)
1355	{
1356	return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1357	}
1358
1359	int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1360	const char *headers, RTSPMessageHeader *reply,
1361	unsigned char **content_ptr)
1362	{
1363	return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1364	content_ptr, NULL, 0);
1365	}
1366
1367	int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1368	const char *method, const char *url,
1369	const char *header,
1370	RTSPMessageHeader *reply,
1371	unsigned char **content_ptr,
1372	const unsigned char *send_content,
1373	int send_content_length)
1374	{
1375	RTSPState *rt = s->priv_data;
1376	HTTPAuthType cur_auth_type;
1377	int ret, attempts = 0;
1378
1379	retry:
1380	cur_auth_type = rt->auth_state.auth_type;
1381	if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1382	send_content,
1383	send_content_length)))
1384	return ret;
1385
1386	if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1387	return ret;
1388	attempts++;
1389
1390	if (reply->status_code == 401 &&
1391	(cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
1392	rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
1393	goto retry;
1394
1395	if (reply->status_code > 400){
1396	av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
1397	method,
1398	reply->status_code,
1399	reply->reason);
1400	av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1401	}
1402
1403	return 0;
1404	}
1405
1406	int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1407	int lower_transport, const char *real_challenge)
1408	{
1409	RTSPState *rt = s->priv_data;
1410	int rtx = 0, j, i, err, interleave = 0, port_off;
1411	RTSPStream *rtsp_st;
1412	RTSPMessageHeader reply1, *reply = &reply1;
1413	char cmd[2048];
1414	const char *trans_pref;
1415
1416	if (rt->transport == RTSP_TRANSPORT_RDT)
1417	trans_pref = "x-pn-tng";
1418	else if (rt->transport == RTSP_TRANSPORT_RAW)
1419	trans_pref = "RAW/RAW";
1420	else
1421	trans_pref = "RTP/AVP";
1422
1423	/* default timeout: 1 minute */
1424	rt->timeout = 60;
1425
1426	/* Choose a random starting offset within the first half of the
1427	* port range, to allow for a number of ports to try even if the offset
1428	* happens to be at the end of the random range. */
1429	port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
1430	/* even random offset */
1431	port_off -= port_off & 0x01;
1432
1433	for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1434	char transport[2048];
1435
1436	/*
1437	* WMS serves all UDP data over a single connection, the RTX, which
1438	* isn't necessarily the first in the SDP but has to be the first
1439	* to be set up, else the second/third SETUP will fail with a 461.
1440	*/
1441	if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1442	rt->server_type == RTSP_SERVER_WMS) {
1443	if (i == 0) {
1444	/* rtx first */
1445	for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1446	int len = strlen(rt->rtsp_streams[rtx]->control_url);
1447	if (len >= 4 &&
1448	!strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1449	"/rtx"))
1450	break;
1451	}
1452	if (rtx == rt->nb_rtsp_streams)
1453	return -1; /* no RTX found */
1454	rtsp_st = rt->rtsp_streams[rtx];
1455	} else
1456	rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1457	} else
1458	rtsp_st = rt->rtsp_streams[i];
1459
1460	/* RTP/UDP */
1461	if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1462	char buf[256];
1463
1464	if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1465	port = reply->transports[0].client_port_min;
1466	goto have_port;
1467	}
1468
1469	/* first try in specified port range */
1470	while (j <= rt->rtp_port_max) {
1471	AVDictionary *opts = map_to_opts(rt);
1472
1473	ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1474	"?localport=%d", j);
1475	/* we will use two ports per rtp stream (rtp and rtcp) */
1476	j += 2;
1477	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
1478	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
1479
1480	av_dict_free(&opts);
1481
1482	if (!err)
1483	goto rtp_opened;
1484	}
1485	av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1486	err = AVERROR(EIO);
1487	goto fail;
1488
1489	rtp_opened:
1490	port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1491	have_port:
1492	snprintf(transport, sizeof(transport) - 1,
1493	"%s/UDP;", trans_pref);
1494	if (rt->server_type != RTSP_SERVER_REAL)
1495	av_strlcat(transport, "unicast;", sizeof(transport));
1496	av_strlcatf(transport, sizeof(transport),
1497	"client_port=%d", port);
1498	if (rt->transport == RTSP_TRANSPORT_RTP &&
1499	!(rt->server_type == RTSP_SERVER_WMS && i > 0))
1500	av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1501	}
1502
1503	/* RTP/TCP */
1504	else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1505	/* For WMS streams, the application streams are only used for
1506	* UDP. When trying to set it up for TCP streams, the server
1507	* will return an error. Therefore, we skip those streams. */
1508	if (rt->server_type == RTSP_SERVER_WMS &&
1509	(rtsp_st->stream_index < 0 ||
1510	s->streams[rtsp_st->stream_index]->codecpar->codec_type ==
1511	AVMEDIA_TYPE_DATA))
1512	continue;
1513	snprintf(transport, sizeof(transport) - 1,
1514	"%s/TCP;", trans_pref);
1515	if (rt->transport != RTSP_TRANSPORT_RDT)
1516	av_strlcat(transport, "unicast;", sizeof(transport));
1517	av_strlcatf(transport, sizeof(transport),
1518	"interleaved=%d-%d",
1519	interleave, interleave + 1);
1520	interleave += 2;
1521	}
1522
1523	else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1524	snprintf(transport, sizeof(transport) - 1,
1525	"%s/UDP;multicast", trans_pref);
1526	}
1527	if (s->oformat) {
1528	av_strlcat(transport, ";mode=record", sizeof(transport));
1529	} else if (rt->server_type == RTSP_SERVER_REAL ||
1530	rt->server_type == RTSP_SERVER_WMS)
1531	av_strlcat(transport, ";mode=play", sizeof(transport));
1532	snprintf(cmd, sizeof(cmd),
1533	"Transport: %s\r\n",
1534	transport);
1535	if (rt->accept_dynamic_rate)
1536	av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
1537	if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1538	char real_res[41], real_csum[9];
1539	ff_rdt_calc_response_and_checksum(real_res, real_csum,
1540	real_challenge);
1541	av_strlcatf(cmd, sizeof(cmd),
1542	"If-Match: %s\r\n"
1543	"RealChallenge2: %s, sd=%s\r\n",
1544	rt->session_id, real_res, real_csum);
1545	}
1546	ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1547	if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1548	err = 1;
1549	goto fail;
1550	} else if (reply->status_code != RTSP_STATUS_OK ||
1551	reply->nb_transports != 1) {
1552	err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1553	goto fail;
1554	}
1555
1556	/* XXX: same protocol for all streams is required */
1557	if (i > 0) {
1558	if (reply->transports[0].lower_transport != rt->lower_transport ||
1559	reply->transports[0].transport != rt->transport) {
1560	err = AVERROR_INVALIDDATA;
1561	goto fail;
1562	}
1563	} else {
1564	rt->lower_transport = reply->transports[0].lower_transport;
1565	rt->transport = reply->transports[0].transport;
1566	}
1567
1568	/* Fail if the server responded with another lower transport mode
1569	* than what we requested. */
1570	if (reply->transports[0].lower_transport != lower_transport) {
1571	av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1572	err = AVERROR_INVALIDDATA;
1573	goto fail;
1574	}
1575
1576	switch(reply->transports[0].lower_transport) {
1577	case RTSP_LOWER_TRANSPORT_TCP:
1578	rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1579	rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1580	break;
1581
1582	case RTSP_LOWER_TRANSPORT_UDP: {
1583	char url[1024], options[30] = "";
1584	const char *peer = host;
1585
1586	if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
1587	av_strlcpy(options, "?connect=1", sizeof(options));
1588	/* Use source address if specified */
1589	if (reply->transports[0].source[0])
1590	peer = reply->transports[0].source;
1591	ff_url_join(url, sizeof(url), "rtp", NULL, peer,
1592	reply->transports[0].server_port_min, "%s", options);
1593	if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1594	ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1595	err = AVERROR_INVALIDDATA;
1596	goto fail;
1597	}
1598	break;
1599	}
1600	case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1601	char url[1024], namebuf[50], optbuf[20] = "";
1602	struct sockaddr_storage addr;
1603	int port, ttl;
1604
1605	if (reply->transports[0].destination.ss_family) {
1606	addr = reply->transports[0].destination;
1607	port = reply->transports[0].port_min;
1608	ttl = reply->transports[0].ttl;
1609	} else {
1610	addr = rtsp_st->sdp_ip;
1611	port = rtsp_st->sdp_port;
1612	ttl = rtsp_st->sdp_ttl;
1613	}
1614	if (ttl > 0)
1615	snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1616	getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1617	namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1618	ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1619	port, "%s", optbuf);
1620	if (ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
1621	&s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL) < 0) {
1622	err = AVERROR_INVALIDDATA;
1623	goto fail;
1624	}
1625	break;
1626	}
1627	}
1628
1629	if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
1630	goto fail;
1631	}
1632
1633	if (rt->nb_rtsp_streams && reply->timeout > 0)
1634	rt->timeout = reply->timeout;
1635
1636	if (rt->server_type == RTSP_SERVER_REAL)
1637	rt->need_subscription = 1;
1638
1639	return 0;
1640
1641	fail:
1642	ff_rtsp_undo_setup(s, 0);
1643	return err;
1644	}
1645
1646	void ff_rtsp_close_connections(AVFormatContext *s)
1647	{
1648	RTSPState *rt = s->priv_data;
1649	if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out);
1650	ffurl_close(rt->rtsp_hd);
1651	rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1652	}
1653
1654	int ff_rtsp_connect(AVFormatContext *s)
1655	{
1656	RTSPState *rt = s->priv_data;
1657	char proto[128], host[1024], path[1024];
1658	char tcpname[1024], cmd[2048], auth[128];
1659	const char *lower_rtsp_proto = "tcp";
1660	int port, err, tcp_fd;
1661	RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1662	int lower_transport_mask = 0;
1663	int default_port = RTSP_DEFAULT_PORT;
1664	char real_challenge[64] = "";
1665	struct sockaddr_storage peer;
1666	socklen_t peer_len = sizeof(peer);
1667
1668	if (rt->rtp_port_max < rt->rtp_port_min) {
1669	av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1670	"than min port %d\n", rt->rtp_port_max,
1671	rt->rtp_port_min);
1672	return AVERROR(EINVAL);
1673	}
1674
1675	if (!ff_network_init())
1676	return AVERROR(EIO);
1677
1678	if (s->max_delay < 0) /* Not set by the caller */
1679	s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
1680
1681	rt->control_transport = RTSP_MODE_PLAIN;
1682	if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) {
1683	rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1684	rt->control_transport = RTSP_MODE_TUNNEL;
1685	}
1686	/* Only pass through valid flags from here */
1687	rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1688
1689	redirect:
1690	/* extract hostname and port */
1691	av_url_split(proto, sizeof(proto), auth, sizeof(auth),
1692	host, sizeof(host), &port, path, sizeof(path), s->filename);
1693
1694	if (!strcmp(proto, "rtsps")) {
1695	lower_rtsp_proto = "tls";
1696	default_port = RTSPS_DEFAULT_PORT;
1697	rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1698	}
1699
1700	if (*auth) {
1701	av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1702	}
1703	if (port < 0)
1704	port = default_port;
1705
1706	lower_transport_mask = rt->lower_transport_mask;
1707
1708	if (!lower_transport_mask)
1709	lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1710
1711	if (s->oformat) {
1712	/* Only UDP or TCP - UDP multicast isn't supported. */
1713	lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1714	(1 << RTSP_LOWER_TRANSPORT_TCP);
1715	if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1716	av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1717	"only UDP and TCP are supported for output.\n");
1718	err = AVERROR(EINVAL);
1719	goto fail;
1720	}
1721	}
1722
1723	/* Construct the URI used in request; this is similar to s->filename,
1724	* but with authentication credentials removed and RTSP specific options
1725	* stripped out. */
1726	ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
1727	host, port, "%s", path);
1728
1729	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1730	/* set up initial handshake for tunneling */
1731	char httpname[1024];
1732	char sessioncookie[17];
1733	char headers[1024];
1734
1735	ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1736	snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1737	av_get_random_seed(), av_get_random_seed());
1738
1739	/* GET requests */
1740	if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
1741	&s->interrupt_callback) < 0) {
1742	err = AVERROR(EIO);
1743	goto fail;
1744	}
1745
1746	/* generate GET headers */
1747	snprintf(headers, sizeof(headers),
1748	"x-sessioncookie: %s\r\n"
1749	"Accept: application/x-rtsp-tunnelled\r\n"
1750	"Pragma: no-cache\r\n"
1751	"Cache-Control: no-cache\r\n",
1752	sessioncookie);
1753	av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
1754
1755	if (!rt->rtsp_hd->protocol_whitelist && s->protocol_whitelist) {
1756	rt->rtsp_hd->protocol_whitelist = av_strdup(s->protocol_whitelist);
1757	if (!rt->rtsp_hd->protocol_whitelist) {
1758	err = AVERROR(ENOMEM);
1759	goto fail;
1760	}
1761	}
1762
1763	/* complete the connection */
1764	if (ffurl_connect(rt->rtsp_hd, NULL)) {
1765	err = AVERROR(EIO);
1766	goto fail;
1767	}
1768
1769	/* POST requests */
1770	if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
1771	&s->interrupt_callback) < 0 ) {
1772	err = AVERROR(EIO);
1773	goto fail;
1774	}
1775
1776	/* generate POST headers */
1777	snprintf(headers, sizeof(headers),
1778	"x-sessioncookie: %s\r\n"
1779	"Content-Type: application/x-rtsp-tunnelled\r\n"
1780	"Pragma: no-cache\r\n"
1781	"Cache-Control: no-cache\r\n"
1782	"Content-Length: 32767\r\n"
1783	"Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1784	sessioncookie);
1785	av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
1786	av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
1787
1788	/* Initialize the authentication state for the POST session. The HTTP
1789	* protocol implementation doesn't properly handle multi-pass
1790	* authentication for POST requests, since it would require one of
1791	* the following:
1792	* - implementing Expect: 100-continue, which many HTTP servers
1793	* don't support anyway, even less the RTSP servers that do HTTP
1794	* tunneling
1795	* - sending the whole POST data until getting a 401 reply specifying
1796	* what authentication method to use, then resending all that data
1797	* - waiting for potential 401 replies directly after sending the
1798	* POST header (waiting for some unspecified time)
1799	* Therefore, we copy the full auth state, which works for both basic
1800	* and digest. (For digest, we would have to synchronize the nonce
1801	* count variable between the two sessions, if we'd do more requests
1802	* with the original session, though.)
1803	*/
1804	ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1805
1806	/* complete the connection */
1807	if (ffurl_connect(rt->rtsp_hd_out, NULL)) {
1808	err = AVERROR(EIO);
1809	goto fail;
1810	}
1811	} else {
1812	int ret;
1813	/* open the tcp connection */
1814	ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
1815	host, port,
1816	"?timeout=%d", rt->stimeout);
1817	if ((ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
1818	&s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL)) < 0) {
1819	err = ret;
1820	goto fail;
1821	}
1822	rt->rtsp_hd_out = rt->rtsp_hd;
1823	}
1824	rt->seq = 0;
1825
1826	tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1827	if (tcp_fd < 0) {
1828	err = tcp_fd;
1829	goto fail;
1830	}
1831	if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1832	getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1833	NULL, 0, NI_NUMERICHOST);
1834	}
1835
1836	/* request options supported by the server; this also detects server
1837	* type */
1838	for (rt->server_type = RTSP_SERVER_RTP;;) {
1839	cmd[0] = 0;
1840	if (rt->server_type == RTSP_SERVER_REAL)
1841	av_strlcat(cmd,
1842	/*
1843	* The following entries are required for proper
1844	* streaming from a Realmedia server. They are
1845	* interdependent in some way although we currently
1846	* don't quite understand how. Values were copied
1847	* from mplayer SVN r23589.
1848	* ClientChallenge is a 16-byte ID in hex
1849	* CompanyID is a 16-byte ID in base64
1850	*/
1851	"ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1852	"PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1853	"CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1854	"GUID: 00000000-0000-0000-0000-000000000000\r\n",
1855	sizeof(cmd));
1856	ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1857	if (reply->status_code != RTSP_STATUS_OK) {
1858	err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1859	goto fail;
1860	}
1861
1862	/* detect server type if not standard-compliant RTP */
1863	if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1864	rt->server_type = RTSP_SERVER_REAL;
1865	continue;
1866	} else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
1867	rt->server_type = RTSP_SERVER_WMS;
1868	} else if (rt->server_type == RTSP_SERVER_REAL)
1869	strcpy(real_challenge, reply->real_challenge);
1870	break;
1871	}
1872
1873	if (CONFIG_RTSP_DEMUXER && s->iformat)
1874	err = ff_rtsp_setup_input_streams(s, reply);
1875	else if (CONFIG_RTSP_MUXER)
1876	err = ff_rtsp_setup_output_streams(s, host);
1877	else
1878	av_assert0(0);
1879	if (err)
1880	goto fail;
1881
1882	do {
1883	int lower_transport = ff_log2_tab[lower_transport_mask &
1884	~(lower_transport_mask - 1)];
1885
1886	if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
1887	&& (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
1888	lower_transport = RTSP_LOWER_TRANSPORT_TCP;
1889
1890	err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
1891	rt->server_type == RTSP_SERVER_REAL ?
1892	real_challenge : NULL);
1893	if (err < 0)
1894	goto fail;
1895	lower_transport_mask &= ~(1 << lower_transport);
1896	if (lower_transport_mask == 0 && err == 1) {
1897	err = AVERROR(EPROTONOSUPPORT);
1898	goto fail;
1899	}
1900	} while (err);
1901
1902	rt->lower_transport_mask = lower_transport_mask;
1903	av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
1904	rt->state = RTSP_STATE_IDLE;
1905	rt->seek_timestamp = 0; /* default is to start stream at position zero */
1906	return 0;
1907	fail:
1908	ff_rtsp_close_streams(s);
1909	ff_rtsp_close_connections(s);
1910	if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1911	av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1912	rt->session_id[0] = '\0';
1913	av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1914	reply->status_code,
1915	s->filename);
1916	goto redirect;
1917	}
1918	ff_network_close();
1919	return err;
1920	}
1921	#endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1922
1923	#if CONFIG_RTPDEC
1924	static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1925	uint8_t *buf, int buf_size, int64_t wait_end)
1926	{
1927	RTSPState *rt = s->priv_data;
1928	RTSPStream *rtsp_st;
1929	int n, i, ret, tcp_fd, timeout_cnt = 0;
1930	int max_p = 0;
1931	struct pollfd *p = rt->p;
1932	int *fds = NULL, fdsnum, fdsidx;
1933
1934	for (;;) {
1935	if (ff_check_interrupt(&s->interrupt_callback))
1936	return AVERROR_EXIT;
1937	if (wait_end && wait_end - av_gettime_relative() < 0)
1938	return AVERROR(EAGAIN);
1939	max_p = 0;
1940	if (rt->rtsp_hd) {
1941	tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1942	p[max_p].fd = tcp_fd;
1943	p[max_p++].events = POLLIN;
1944	} else {
1945	tcp_fd = -1;
1946	}
1947	for (i = 0; i < rt->nb_rtsp_streams; i++) {
1948	rtsp_st = rt->rtsp_streams[i];
1949	if (rtsp_st->rtp_handle) {
1950	if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
1951	&fds, &fdsnum)) {
1952	av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
1953	return ret;
1954	}
1955	if (fdsnum != 2) {
1956	av_log(s, AV_LOG_ERROR,
1957	"Number of fds %d not supported\n", fdsnum);
1958	return AVERROR_INVALIDDATA;
1959	}
1960	for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
1961	p[max_p].fd = fds[fdsidx];
1962	p[max_p++].events = POLLIN;
1963	}
1964	av_freep(&fds);
1965	}
1966	}
1967	n = poll(p, max_p, POLL_TIMEOUT_MS);
1968	if (n > 0) {
1969	int j = 1 - (tcp_fd == -1);
1970	timeout_cnt = 0;
1971	for (i = 0; i < rt->nb_rtsp_streams; i++) {
1972	rtsp_st = rt->rtsp_streams[i];
1973	if (rtsp_st->rtp_handle) {
1974	if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1975	ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
1976	if (ret > 0) {
1977	*prtsp_st = rtsp_st;
1978	return ret;
1979	}
1980	}
1981	j+=2;
1982	}
1983	}
1984	#if CONFIG_RTSP_DEMUXER
1985	if (tcp_fd != -1 && p[0].revents & POLLIN) {
1986	if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
1987	if (rt->state == RTSP_STATE_STREAMING) {
1988	if (!ff_rtsp_parse_streaming_commands(s))
1989	return AVERROR_EOF;
1990	else
1991	av_log(s, AV_LOG_WARNING,
1992	"Unable to answer to TEARDOWN\n");
1993	} else
1994	return 0;
1995	} else {
1996	RTSPMessageHeader reply;
1997	ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
1998	if (ret < 0)
1999	return ret;
2000	/* XXX: parse message */
2001	if (rt->state != RTSP_STATE_STREAMING)
2002	return 0;
2003	}
2004	}
2005	#endif
2006	} else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
2007	return AVERROR(ETIMEDOUT);
2008	} else if (n < 0 && errno != EINTR)
2009	return AVERROR(errno);
2010	}
2011	}
2012
2013	static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
2014	const uint8_t *buf, int len)
2015	{
2016	RTSPState *rt = s->priv_data;
2017	int i;
2018	if (len < 0)
2019	return len;
2020	if (rt->nb_rtsp_streams == 1) {
2021	*rtsp_st = rt->rtsp_streams[0];
2022	return len;
2023	}
2024	if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
2025	if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
2026	int no_ssrc = 0;
2027	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2028	RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2029	if (!rtpctx)
2030	continue;
2031	if (rtpctx->ssrc == AV_RB32(&buf[4])) {
2032	*rtsp_st = rt->rtsp_streams[i];
2033	return len;
2034	}
2035	if (!rtpctx->ssrc)
2036	no_ssrc = 1;
2037	}
2038	if (no_ssrc) {
2039	av_log(s, AV_LOG_WARNING,
2040	"Unable to pick stream for packet - SSRC not known for "
2041	"all streams\n");
2042	return AVERROR(EAGAIN);
2043	}
2044	} else {
2045	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2046	if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
2047	*rtsp_st = rt->rtsp_streams[i];
2048	return len;
2049	}
2050	}
2051	}
2052	}
2053	av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
2054	return AVERROR(EAGAIN);
2055	}
2056
2057	int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
2058	{
2059	RTSPState *rt = s->priv_data;
2060	int ret, len;
2061	RTSPStream *rtsp_st, *first_queue_st = NULL;
2062	int64_t wait_end = 0;
2063
2064	if (rt->nb_byes == rt->nb_rtsp_streams)
2065	return AVERROR_EOF;
2066
2067	/* get next frames from the same RTP packet */
2068	if (rt->cur_transport_priv) {
2069	if (rt->transport == RTSP_TRANSPORT_RDT) {
2070	ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2071	} else if (rt->transport == RTSP_TRANSPORT_RTP) {
2072	ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2073	} else if (CONFIG_RTPDEC && rt->ts) {
2074	ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
2075	if (ret >= 0) {
2076	rt->recvbuf_pos += ret;
2077	ret = rt->recvbuf_pos < rt->recvbuf_len;
2078	}
2079	} else
2080	ret = -1;
2081	if (ret == 0) {
2082	rt->cur_transport_priv = NULL;
2083	return 0;
2084	} else if (ret == 1) {
2085	return 0;
2086	} else
2087	rt->cur_transport_priv = NULL;
2088	}
2089
2090	redo:
2091	if (rt->transport == RTSP_TRANSPORT_RTP) {
2092	int i;
2093	int64_t first_queue_time = 0;
2094	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2095	RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2096	int64_t queue_time;
2097	if (!rtpctx)
2098	continue;
2099	queue_time = ff_rtp_queued_packet_time(rtpctx);
2100	if (queue_time && (queue_time - first_queue_time < 0 ||
2101	!first_queue_time)) {
2102	first_queue_time = queue_time;
2103	first_queue_st = rt->rtsp_streams[i];
2104	}
2105	}
2106	if (first_queue_time) {
2107	wait_end = first_queue_time + s->max_delay;
2108	} else {
2109	wait_end = 0;
2110	first_queue_st = NULL;
2111	}
2112	}
2113
2114	/* read next RTP packet */
2115	if (!rt->recvbuf) {
2116	rt->recvbuf = av_malloc(RECVBUF_SIZE);
2117	if (!rt->recvbuf)
2118	return AVERROR(ENOMEM);
2119	}
2120
2121	switch(rt->lower_transport) {
2122	default:
2123	#if CONFIG_RTSP_DEMUXER
2124	case RTSP_LOWER_TRANSPORT_TCP:
2125	len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
2126	break;
2127	#endif
2128	case RTSP_LOWER_TRANSPORT_UDP:
2129	case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
2130	len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2131	if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2132	ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);
2133	break;
2134	case RTSP_LOWER_TRANSPORT_CUSTOM:
2135	if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2136	wait_end && wait_end < av_gettime_relative())
2137	len = AVERROR(EAGAIN);
2138	else
2139	len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
2140	len = pick_stream(s, &rtsp_st, rt->recvbuf, len);
2141	if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2142	ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len);
2143	break;
2144	}
2145	if (len == AVERROR(EAGAIN) && first_queue_st &&
2146	rt->transport == RTSP_TRANSPORT_RTP) {
2147	av_log(s, AV_LOG_WARNING,
2148	"max delay reached. need to consume packet\n");
2149	rtsp_st = first_queue_st;
2150	ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
2151	goto end;
2152	}
2153	if (len < 0)
2154	return len;
2155	if (len == 0)
2156	return AVERROR_EOF;
2157	if (rt->transport == RTSP_TRANSPORT_RDT) {
2158	ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2159	} else if (rt->transport == RTSP_TRANSPORT_RTP) {
2160	ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2161	if (rtsp_st->feedback) {
2162	AVIOContext *pb = NULL;
2163	if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)
2164	pb = s->pb;
2165	ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
2166	}
2167	if (ret < 0) {
2168	/* Either bad packet, or a RTCP packet. Check if the
2169	* first_rtcp_ntp_time field was initialized. */
2170	RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
2171	if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
2172	/* first_rtcp_ntp_time has been initialized for this stream,
2173	* copy the same value to all other uninitialized streams,
2174	* in order to map their timestamp origin to the same ntp time
2175	* as this one. */
2176	int i;
2177	AVStream *st = NULL;
2178	if (rtsp_st->stream_index >= 0)
2179	st = s->streams[rtsp_st->stream_index];
2180	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2181	RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2182	AVStream *st2 = NULL;
2183	if (rt->rtsp_streams[i]->stream_index >= 0)
2184	st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2185	if (rtpctx2 && st && st2 &&
2186	rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
2187	rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2188	rtpctx2->rtcp_ts_offset = av_rescale_q(
2189	rtpctx->rtcp_ts_offset, st->time_base,
2190	st2->time_base);
2191	}
2192	}
2193	// Make real NTP start time available in AVFormatContext
2194	if (s->start_time_realtime == AV_NOPTS_VALUE) {
2195	s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32);
2196	if (rtpctx->st) {
2197	s->start_time_realtime -=
2198	av_rescale (rtpctx->rtcp_ts_offset,
2199	(uint64_t) rtpctx->st->time_base.num * 1000000,
2200	rtpctx->st->time_base.den);
2201	}
2202	}
2203	}
2204	if (ret == -RTCP_BYE) {
2205	rt->nb_byes++;
2206
2207	av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2208	rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2209
2210	if (rt->nb_byes == rt->nb_rtsp_streams)
2211	return AVERROR_EOF;
2212	}
2213	}
2214	} else if (CONFIG_RTPDEC && rt->ts) {
2215	ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
2216	if (ret >= 0) {
2217	if (ret < len) {
2218	rt->recvbuf_len = len;
2219	rt->recvbuf_pos = ret;
2220	rt->cur_transport_priv = rt->ts;
2221	return 1;
2222	} else {
2223	ret = 0;
2224	}
2225	}
2226	} else {
2227	return AVERROR_INVALIDDATA;
2228	}
2229	end:
2230	if (ret < 0)
2231	goto redo;
2232	if (ret == 1)
2233	/* more packets may follow, so we save the RTP context */
2234	rt->cur_transport_priv = rtsp_st->transport_priv;
2235
2236	return ret;
2237	}
2238	#endif /* CONFIG_RTPDEC */
2239
2240	#if CONFIG_SDP_DEMUXER
2241	static int sdp_probe(AVProbeData *p1)
2242	{
2243	const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2244
2245	/* we look for a line beginning "c=IN IP" */
2246	while (p < p_end && *p != '\0') {
2247	if (sizeof("c=IN IP") - 1 < p_end - p &&
2248	av_strstart(p, "c=IN IP", NULL))
2249	return AVPROBE_SCORE_EXTENSION;
2250
2251	while (p < p_end - 1 && *p != '\n') p++;
2252	if (++p >= p_end)
2253	break;
2254	if (*p == '\r')
2255	p++;
2256	}
2257	return 0;
2258	}
2259
2260	static void append_source_addrs(char *buf, int size, const char *name,
2261	int count, struct RTSPSource **addrs)
2262	{
2263	int i;
2264	if (!count)
2265	return;
2266	av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
2267	for (i = 1; i < count; i++)
2268	av_strlcatf(buf, size, ",%s", addrs[i]->addr);
2269	}
2270
2271	static int sdp_read_header(AVFormatContext *s)
2272	{
2273	RTSPState *rt = s->priv_data;
2274	RTSPStream *rtsp_st;
2275	int size, i, err;
2276	char *content;
2277	char url[1024];
2278
2279	if (!ff_network_init())
2280	return AVERROR(EIO);
2281
2282	if (s->max_delay < 0) /* Not set by the caller */
2283	s->max_delay = DEFAULT_REORDERING_DELAY;
2284	if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2285	rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;
2286
2287	/* read the whole sdp file */
2288	/* XXX: better loading */
2289	content = av_malloc(SDP_MAX_SIZE);
2290	if (!content)
2291	return AVERROR(ENOMEM);
2292	size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);
2293	if (size <= 0) {
2294	av_free(content);
2295	return AVERROR_INVALIDDATA;
2296	}
2297	content[size] ='\0';
2298
2299	err = ff_sdp_parse(s, content);
2300	av_freep(&content);
2301	if (err) goto fail;
2302
2303	/* open each RTP stream */
2304	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2305	char namebuf[50];
2306	rtsp_st = rt->rtsp_streams[i];
2307
2308	if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2309	AVDictionary *opts = map_to_opts(rt);
2310
2311	err = getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip,
2312	sizeof(rtsp_st->sdp_ip),
2313	namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2314	if (err) {
2315	av_log(s, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(err));
2316	err = AVERROR(EIO);
2317	av_dict_free(&opts);
2318	goto fail;
2319	}
2320	ff_url_join(url, sizeof(url), "rtp", NULL,
2321	namebuf, rtsp_st->sdp_port,
2322	"?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2323	rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2324	rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2325	rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2326
2327	append_source_addrs(url, sizeof(url), "sources",
2328	rtsp_st->nb_include_source_addrs,
2329	rtsp_st->include_source_addrs);
2330	append_source_addrs(url, sizeof(url), "block",
2331	rtsp_st->nb_exclude_source_addrs,
2332	rtsp_st->exclude_source_addrs);
2333	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ,
2334	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
2335
2336	av_dict_free(&opts);
2337
2338	if (err < 0) {
2339	err = AVERROR_INVALIDDATA;
2340	goto fail;
2341	}
2342	}
2343	if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2344	goto fail;
2345	}
2346	return 0;
2347	fail:
2348	ff_rtsp_close_streams(s);
2349	ff_network_close();
2350	return err;
2351	}
2352
2353	static int sdp_read_close(AVFormatContext *s)
2354	{
2355	ff_rtsp_close_streams(s);
2356	ff_network_close();
2357	return 0;
2358	}
2359
2360	static const AVClass sdp_demuxer_class = {
2361	.class_name = "SDP demuxer",
2362	.item_name = av_default_item_name,
2363	.option = sdp_options,
2364	.version = LIBAVUTIL_VERSION_INT,
2365	};
2366
2367	AVInputFormat ff_sdp_demuxer = {
2368	.name = "sdp",
2369	.long_name = NULL_IF_CONFIG_SMALL("SDP"),
2370	.priv_data_size = sizeof(RTSPState),
2371	.read_probe = sdp_probe,
2372	.read_header = sdp_read_header,
2373	.read_packet = ff_rtsp_fetch_packet,
2374	.read_close = sdp_read_close,
2375	.priv_class = &sdp_demuxer_class,
2376	};
2377	#endif /* CONFIG_SDP_DEMUXER */
2378
2379	#if CONFIG_RTP_DEMUXER
2380	static int rtp_probe(AVProbeData *p)
2381	{
2382	if (av_strstart(p->filename, "rtp:", NULL))
2383	return AVPROBE_SCORE_MAX;
2384	return 0;
2385	}
2386
2387	static int rtp_read_header(AVFormatContext *s)
2388	{
2389	uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2390	char host[500], sdp[500];
2391	int ret, port;
2392	URLContext* in = NULL;
2393	int payload_type;
2394	AVCodecParameters *par = NULL;
2395	struct sockaddr_storage addr;
2396	AVIOContext pb;
2397	socklen_t addrlen = sizeof(addr);
2398	RTSPState *rt = s->priv_data;
2399
2400	if (!ff_network_init())
2401	return AVERROR(EIO);
2402
2403	ret = ffurl_open_whitelist(&in, s->filename, AVIO_FLAG_READ,
2404	&s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL);
2405	if (ret)
2406	goto fail;
2407
2408	while (1) {
2409	ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2410	if (ret == AVERROR(EAGAIN))
2411	continue;
2412	if (ret < 0)
2413	goto fail;
2414	if (ret < 12) {
2415	av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2416	continue;
2417	}
2418
2419	if ((recvbuf[0] & 0xc0) != 0x80) {
2420	av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2421	"received\n");
2422	continue;
2423	}
2424
2425	if (RTP_PT_IS_RTCP(recvbuf[1]))
2426	continue;
2427
2428	payload_type = recvbuf[1] & 0x7f;
2429	break;
2430	}
2431	getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2432	ffurl_close(in);
2433	in = NULL;
2434
2435	par = avcodec_parameters_alloc();
2436	if (!par) {
2437	ret = AVERROR(ENOMEM);
2438	goto fail;
2439	}
2440
2441	if (ff_rtp_get_codec_info(par, payload_type)) {
2442	av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2443	"without an SDP file describing it\n",
2444	payload_type);
2445	goto fail;
2446	}
2447	if (par->codec_type != AVMEDIA_TYPE_DATA) {
2448	av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2449	"properly you need an SDP file "
2450	"describing it\n");
2451	}
2452
2453	av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2454	NULL, 0, s->filename);
2455
2456	snprintf(sdp, sizeof(sdp),
2457	"v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2458	addr.ss_family == AF_INET ? 4 : 6, host,
2459	par->codec_type == AVMEDIA_TYPE_DATA ? "application" :
2460	par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2461	port, payload_type);
2462	av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
2463	avcodec_parameters_free(&par);
2464
2465	ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);
2466	s->pb = &pb;
2467
2468	/* sdp_read_header initializes this again */
2469	ff_network_close();
2470
2471	rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;
2472
2473	ret = sdp_read_header(s);
2474	s->pb = NULL;
2475	return ret;
2476
2477	fail:
2478	avcodec_parameters_free(&par);
2479	if (in)
2480	ffurl_close(in);
2481	ff_network_close();
2482	return ret;
2483	}
2484
2485	static const AVClass rtp_demuxer_class = {
2486	.class_name = "RTP demuxer",
2487	.item_name = av_default_item_name,
2488	.option = rtp_options,
2489	.version = LIBAVUTIL_VERSION_INT,
2490	};
2491
2492	AVInputFormat ff_rtp_demuxer = {
2493	.name = "rtp",
2494	.long_name = NULL_IF_CONFIG_SMALL("RTP input"),
2495	.priv_data_size = sizeof(RTSPState),
2496	.read_probe = rtp_probe,
2497	.read_header = rtp_read_header,
2498	.read_packet = ff_rtsp_fetch_packet,
2499	.read_close = sdp_read_close,
2500	.flags = AVFMT_NOFILE,
2501	.priv_class = &rtp_demuxer_class,
2502	};
2503	#endif /* CONFIG_RTP_DEMUXER */
2504