Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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_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" } | |
75 | ||
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 } | |
78 | ||
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 }, | |
97 | { NULL }, | |
98 | }; | |
99 | ||
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(), | |
106 | { NULL }, | |
107 | }; | |
108 | ||
109 | static const AVOption rtp_options[] = { | |
110 | RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"), | |
111 | RTSP_REORDERING_OPTS(), | |
112 | { NULL }, | |
113 | }; | |
114 | ||
115 | static void get_word_until_chars(char *buf, int buf_size, | |
116 | const char *sep, const char **pp) | |
117 | { | |
118 | const char *p; | |
119 | char *q; | |
120 | ||
121 | p = *pp; | |
122 | p += strspn(p, SPACE_CHARS); | |
123 | q = buf; | |
124 | while (!strchr(sep, *p) && *p != '\0') { | |
125 | if ((q - buf) < buf_size - 1) | |
126 | *q++ = *p; | |
127 | p++; | |
128 | } | |
129 | if (buf_size > 0) | |
130 | *q = '\0'; | |
131 | *pp = p; | |
132 | } | |
133 | ||
134 | static void get_word_sep(char *buf, int buf_size, const char *sep, | |
135 | const char **pp) | |
136 | { | |
137 | if (**pp == '/') (*pp)++; | |
138 | get_word_until_chars(buf, buf_size, sep, pp); | |
139 | } | |
140 | ||
141 | static void get_word(char *buf, int buf_size, const char **pp) | |
142 | { | |
143 | get_word_until_chars(buf, buf_size, SPACE_CHARS, pp); | |
144 | } | |
145 | ||
146 | /** Parse a string p in the form of Range:npt=xx-xx, and determine the start | |
147 | * and end time. | |
148 | * Used for seeking in the rtp stream. | |
149 | */ | |
150 | static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end) | |
151 | { | |
152 | char buf[256]; | |
153 | ||
154 | p += strspn(p, SPACE_CHARS); | |
155 | if (!av_stristart(p, "npt=", &p)) | |
156 | return; | |
157 | ||
158 | *start = AV_NOPTS_VALUE; | |
159 | *end = AV_NOPTS_VALUE; | |
160 | ||
161 | get_word_sep(buf, sizeof(buf), "-", &p); | |
162 | av_parse_time(start, buf, 1); | |
163 | if (*p == '-') { | |
164 | p++; | |
165 | get_word_sep(buf, sizeof(buf), "-", &p); | |
166 | av_parse_time(end, buf, 1); | |
167 | } | |
168 | } | |
169 | ||
170 | static int get_sockaddr(const char *buf, struct sockaddr_storage *sock) | |
171 | { | |
172 | struct addrinfo hints = { 0 }, *ai = NULL; | |
173 | hints.ai_flags = AI_NUMERICHOST; | |
174 | if (getaddrinfo(buf, NULL, &hints, &ai)) | |
175 | return -1; | |
176 | memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen)); | |
177 | freeaddrinfo(ai); | |
178 | return 0; | |
179 | } | |
180 | ||
181 | #if CONFIG_RTPDEC | |
182 | static void init_rtp_handler(RTPDynamicProtocolHandler *handler, | |
183 | RTSPStream *rtsp_st, AVCodecContext *codec) | |
184 | { | |
185 | if (!handler) | |
186 | return; | |
187 | if (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; | |
194 | } | |
195 | } | |
196 | ||
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) | |
201 | { | |
202 | AVCodecContext *codec = st->codec; | |
203 | char buf[256]; | |
204 | int i; | |
205 | AVCodec *c; | |
206 | const char *c_name; | |
207 | ||
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); | |
217 | } | |
218 | ||
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); | |
229 | } | |
230 | ||
231 | c = avcodec_find_decoder(codec->codec_id); | |
232 | if (c && c->name) | |
233 | c_name = c->name; | |
234 | else | |
235 | c_name = "(null)"; | |
236 | ||
237 | get_word_sep(buf, sizeof(buf), "/", &p); | |
238 | i = atoi(buf); | |
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; | |
244 | if (i > 0) { | |
245 | codec->sample_rate = i; | |
246 | avpriv_set_pts_info(st, 32, 1, codec->sample_rate); | |
247 | get_word_sep(buf, sizeof(buf), "/", &p); | |
248 | i = atoi(buf); | |
249 | if (i > 0) | |
250 | codec->channels = i; | |
251 | } | |
252 | av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n", | |
253 | codec->sample_rate); | |
254 | av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n", | |
255 | codec->channels); | |
256 | break; | |
257 | case AVMEDIA_TYPE_VIDEO: | |
258 | av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name); | |
259 | if (i > 0) | |
260 | avpriv_set_pts_info(st, 32, 1, i); | |
261 | break; | |
262 | default: | |
263 | break; | |
264 | } | |
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); | |
268 | return 0; | |
269 | } | |
270 | ||
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 | |
273 | * forthcoming. */ | |
274 | int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, | |
275 | char *value, int value_size) | |
276 | { | |
277 | *p += strspn(*p, SPACE_CHARS); | |
278 | if (**p) { | |
279 | get_word_sep(attr, attr_size, "=", p); | |
280 | if (**p == '=') | |
281 | (*p)++; | |
282 | get_word_sep(value, value_size, ";", p); | |
283 | if (**p == ';') | |
284 | (*p)++; | |
285 | return 1; | |
286 | } | |
287 | return 0; | |
288 | } | |
289 | ||
290 | typedef struct SDPParseState { | |
291 | /* SDP only */ | |
292 | struct sockaddr_storage default_ip; | |
293 | int default_ttl; | |
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) */ | |
299 | int seen_rtpmap; | |
300 | int seen_fmtp; | |
301 | char delayed_fmtp[2048]; | |
302 | } SDPParseState; | |
303 | ||
304 | static void copy_default_source_addrs(struct RTSPSource **addrs, int count, | |
305 | struct RTSPSource ***dest, int *dest_count) | |
306 | { | |
307 | RTSPSource *rtsp_src, *rtsp_src2; | |
308 | int i; | |
309 | for (i = 0; i < count; i++) { | |
310 | rtsp_src = addrs[i]; | |
311 | rtsp_src2 = av_malloc(sizeof(*rtsp_src2)); | |
312 | if (!rtsp_src2) | |
313 | continue; | |
314 | memcpy(rtsp_src2, rtsp_src, sizeof(*rtsp_src)); | |
315 | dynarray_add(dest, dest_count, rtsp_src2); | |
316 | } | |
317 | } | |
318 | ||
319 | static void parse_fmtp(AVFormatContext *s, RTSPState *rt, | |
320 | int payload_type, const char *line) | |
321 | { | |
322 | int i; | |
323 | ||
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); | |
331 | } | |
332 | } | |
333 | } | |
334 | ||
335 | static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1, | |
336 | int letter, const char *buf) | |
337 | { | |
338 | RTSPState *rt = s->priv_data; | |
339 | char buf1[64], st_type[64]; | |
340 | const char *p; | |
341 | enum AVMediaType codec_type; | |
342 | int payload_type; | |
343 | AVStream *st; | |
344 | RTSPStream *rtsp_st; | |
345 | RTSPSource *rtsp_src; | |
346 | struct sockaddr_storage sdp_ip; | |
347 | int ttl; | |
348 | ||
349 | av_dlog(s, "sdp: %c='%s'\n", letter, buf); | |
350 | ||
351 | p = buf; | |
352 | if (s1->skip_media && letter != 'm') | |
353 | return; | |
354 | switch (letter) { | |
355 | case 'c': | |
356 | get_word(buf1, sizeof(buf1), &p); | |
357 | if (strcmp(buf1, "IN") != 0) | |
358 | return; | |
359 | get_word(buf1, sizeof(buf1), &p); | |
360 | if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6")) | |
361 | return; | |
362 | get_word_sep(buf1, sizeof(buf1), "/", &p); | |
363 | if (get_sockaddr(buf1, &sdp_ip)) | |
364 | return; | |
365 | ttl = 16; | |
366 | if (*p == '/') { | |
367 | p++; | |
368 | get_word_sep(buf1, sizeof(buf1), "/", &p); | |
369 | ttl = atoi(buf1); | |
370 | } | |
371 | if (s->nb_streams == 0) { | |
372 | s1->default_ip = sdp_ip; | |
373 | s1->default_ttl = ttl; | |
374 | } else { | |
375 | rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1]; | |
376 | rtsp_st->sdp_ip = sdp_ip; | |
377 | rtsp_st->sdp_ttl = ttl; | |
378 | } | |
379 | break; | |
380 | case 's': | |
381 | av_dict_set(&s->metadata, "title", p, 0); | |
382 | break; | |
383 | case 'i': | |
384 | if (s->nb_streams == 0) { | |
385 | av_dict_set(&s->metadata, "comment", p, 0); | |
386 | break; | |
387 | } | |
388 | break; | |
389 | case 'm': | |
390 | /* new stream */ | |
391 | s1->skip_media = 0; | |
392 | s1->seen_fmtp = 0; | |
393 | s1->seen_rtpmap = 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; | |
402 | } | |
403 | if (codec_type == AVMEDIA_TYPE_UNKNOWN || !(rt->media_type_mask & (1 << codec_type))) { | |
404 | s1->skip_media = 1; | |
405 | return; | |
406 | } | |
407 | rtsp_st = av_mallocz(sizeof(RTSPStream)); | |
408 | if (!rtsp_st) | |
409 | return; | |
410 | rtsp_st->stream_index = -1; | |
411 | dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st); | |
412 | ||
413 | rtsp_st->sdp_ip = s1->default_ip; | |
414 | rtsp_st->sdp_ttl = s1->default_ttl; | |
415 | ||
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); | |
424 | ||
425 | get_word(buf1, sizeof(buf1), &p); /* port */ | |
426 | rtsp_st->sdp_port = atoi(buf1); | |
427 | ||
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; | |
433 | ||
434 | /* XXX: handle list of formats */ | |
435 | get_word(buf1, sizeof(buf1), &p); /* format list */ | |
436 | rtsp_st->sdp_payload_type = atoi(buf1); | |
437 | ||
438 | if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) { | |
439 | /* no corresponding stream */ | |
440 | if (rt->transport == RTSP_TRANSPORT_RAW) { | |
f6fa7814 | 441 | if (CONFIG_RTPDEC && !rt->ts) |
2ba45a60 DM |
442 | rt->ts = avpriv_mpegts_parse_open(s); |
443 | } else { | |
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); | |
450 | } | |
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. */ | |
455 | } else { | |
456 | st = avformat_new_stream(s, NULL); | |
457 | if (!st) | |
458 | return; | |
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); | |
476 | } | |
477 | } | |
478 | /* put a default control url */ | |
479 | av_strlcpy(rtsp_st->control_url, rt->control_uri, | |
480 | sizeof(rtsp_st->control_url)); | |
481 | break; | |
482 | case 'a': | |
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)); | |
488 | } else { | |
489 | char proto[32]; | |
490 | /* get the control url */ | |
491 | rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1]; | |
492 | ||
493 | /* XXX: may need to add full url resolution */ | |
494 | av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0, | |
495 | NULL, NULL, 0, p); | |
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)); | |
503 | } else | |
504 | av_strlcpy(rtsp_st->control_url, p, | |
505 | sizeof(rtsp_st->control_url)); | |
506 | } | |
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); | |
515 | } | |
516 | s1->seen_rtpmap = 1; | |
517 | if (s1->seen_fmtp) { | |
518 | parse_fmtp(s, rt, payload_type, s1->delayed_fmtp); | |
519 | } | |
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); | |
527 | } else { | |
528 | s1->seen_fmtp = 1; | |
529 | av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp)); | |
530 | } | |
531 | } else if (av_strstart(p, "range:", &p)) { | |
532 | int64_t start, end; | |
533 | ||
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)) { | |
541 | if (atoi(p) == 1) | |
542 | rt->transport = RTSP_TRANSPORT_RDT; | |
543 | } else if (av_strstart(p, "SampleRate:integer;", &p) && | |
544 | s->nb_streams > 0) { | |
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) { | |
548 | // RFC 4568 | |
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)) { | |
556 | int exclude = 0; | |
557 | get_word(buf1, sizeof(buf1), &p); | |
558 | if (strcmp(buf1, "incl") && strcmp(buf1, "excl")) | |
559 | return; | |
560 | exclude = !strcmp(buf1, "excl"); | |
561 | ||
562 | get_word(buf1, sizeof(buf1), &p); | |
563 | if (strcmp(buf1, "IN") != 0) | |
564 | return; | |
565 | get_word(buf1, sizeof(buf1), &p); | |
566 | if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*")) | |
567 | return; | |
568 | // not checking that the destination address actually matches or is wildcard | |
569 | get_word(buf1, sizeof(buf1), &p); | |
570 | ||
571 | while (*p != '\0') { | |
572 | rtsp_src = av_mallocz(sizeof(*rtsp_src)); | |
573 | if (!rtsp_src) | |
574 | return; | |
575 | get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p); | |
576 | if (exclude) { | |
577 | if (s->nb_streams == 0) { | |
578 | dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src); | |
579 | } else { | |
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); | |
582 | } | |
583 | } else { | |
584 | if (s->nb_streams == 0) { | |
585 | dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src); | |
586 | } else { | |
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); | |
589 | } | |
590 | } | |
591 | } | |
592 | } else { | |
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]; | |
597 | ||
598 | if (rt->server_type == RTSP_SERVER_REAL) | |
599 | ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p); | |
600 | ||
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); | |
606 | } | |
607 | } | |
608 | break; | |
609 | } | |
610 | } | |
611 | ||
612 | int ff_sdp_parse(AVFormatContext *s, const char *content) | |
613 | { | |
614 | RTSPState *rt = s->priv_data; | |
615 | const char *p; | |
616 | int letter, i; | |
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 | |
621 | * buffer is large. | |
622 | * | |
623 | * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line | |
624 | * in rtpdec_xiph.c. */ | |
625 | char buf[16384], *q; | |
626 | SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state; | |
627 | ||
628 | p = content; | |
629 | for (;;) { | |
630 | p += strspn(p, SPACE_CHARS); | |
631 | letter = *p; | |
632 | if (letter == '\0') | |
633 | break; | |
634 | p++; | |
635 | if (*p != '=') | |
636 | goto next_line; | |
637 | p++; | |
638 | /* get the content */ | |
639 | q = buf; | |
640 | while (*p != '\n' && *p != '\r' && *p != '\0') { | |
641 | if ((q - buf) < sizeof(buf) - 1) | |
642 | *q++ = *p; | |
643 | p++; | |
644 | } | |
645 | *q = '\0'; | |
646 | sdp_parse_line(s, s1, letter, buf); | |
647 | next_line: | |
648 | while (*p != '\n' && *p != '\0') | |
649 | p++; | |
650 | if (*p == '\n') | |
651 | p++; | |
652 | } | |
653 | ||
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); | |
660 | ||
661 | rt->p = av_malloc_array(rt->nb_rtsp_streams + 1, sizeof(struct pollfd) * 2); | |
662 | if (!rt->p) return AVERROR(ENOMEM); | |
663 | return 0; | |
664 | } | |
665 | #endif /* CONFIG_RTPDEC */ | |
666 | ||
667 | void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets) | |
668 | { | |
669 | RTSPState *rt = s->priv_data; | |
670 | int i; | |
671 | ||
672 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
673 | RTSPStream *rtsp_st = rt->rtsp_streams[i]; | |
674 | if (!rtsp_st) | |
675 | continue; | |
676 | if (rtsp_st->transport_priv) { | |
677 | if (s->oformat) { | |
678 | AVFormatContext *rtpctx = rtsp_st->transport_priv; | |
679 | av_write_trailer(rtpctx); | |
680 | if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) { | |
681 | uint8_t *ptr; | |
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); | |
685 | av_free(ptr); | |
686 | } else { | |
687 | avio_close(rtpctx->pb); | |
688 | } | |
689 | avformat_free_context(rtpctx); | |
f6fa7814 | 690 | } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT) |
2ba45a60 | 691 | ff_rdt_parse_close(rtsp_st->transport_priv); |
f6fa7814 | 692 | else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) |
2ba45a60 DM |
693 | ff_rtp_parse_close(rtsp_st->transport_priv); |
694 | } | |
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; | |
699 | } | |
700 | } | |
701 | ||
702 | /* close and free RTSP streams */ | |
703 | void ff_rtsp_close_streams(AVFormatContext *s) | |
704 | { | |
705 | RTSPState *rt = s->priv_data; | |
706 | int i, j; | |
707 | RTSPStream *rtsp_st; | |
708 | ||
709 | ff_rtsp_undo_setup(s, 0); | |
710 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
711 | rtsp_st = rt->rtsp_streams[i]; | |
712 | if (rtsp_st) { | |
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); | |
722 | ||
723 | av_free(rtsp_st); | |
724 | } | |
725 | } | |
726 | av_free(rt->rtsp_streams); | |
727 | if (rt->asf_ctx) { | |
728 | avformat_close_input(&rt->asf_ctx); | |
729 | } | |
f6fa7814 | 730 | if (CONFIG_RTPDEC && rt->ts) |
2ba45a60 DM |
731 | avpriv_mpegts_parse_close(rt->ts); |
732 | av_free(rt->p); | |
733 | av_free(rt->recvbuf); | |
734 | } | |
735 | ||
736 | int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st) | |
737 | { | |
738 | RTSPState *rt = s->priv_data; | |
739 | AVStream *st = NULL; | |
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; | |
744 | else | |
745 | reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE; | |
746 | } | |
747 | ||
748 | /* open the RTP context */ | |
749 | if (rtsp_st->stream_index >= 0) | |
750 | st = s->streams[rtsp_st->stream_index]; | |
751 | if (!st) | |
752 | s->ctx_flags |= AVFMTCTX_NOHEADER; | |
753 | ||
f6fa7814 | 754 | if (CONFIG_RTSP_MUXER && s->oformat) { |
2ba45a60 DM |
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; | |
761 | if (ret < 0) | |
762 | return ret; | |
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 | |
f6fa7814 | 766 | } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT) |
2ba45a60 DM |
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); | |
774 | ||
775 | if (!rtsp_st->transport_priv) { | |
776 | return AVERROR(ENOMEM); | |
f6fa7814 | 777 | } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) { |
2ba45a60 DM |
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); | |
782 | } | |
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); | |
787 | } | |
788 | ||
789 | return 0; | |
790 | } | |
791 | ||
792 | #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER | |
793 | static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp) | |
794 | { | |
795 | const char *q; | |
796 | char *p; | |
797 | int v; | |
798 | ||
799 | q = *pp; | |
800 | q += strspn(q, SPACE_CHARS); | |
801 | v = strtol(q, &p, 10); | |
802 | if (*p == '-') { | |
803 | p++; | |
804 | *min_ptr = v; | |
805 | v = strtol(p, &p, 10); | |
806 | *max_ptr = v; | |
807 | } else { | |
808 | *min_ptr = v; | |
809 | *max_ptr = v; | |
810 | } | |
811 | *pp = p; | |
812 | } | |
813 | ||
814 | /* XXX: only one transport specification is parsed */ | |
815 | static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p) | |
816 | { | |
817 | char transport_protocol[16]; | |
818 | char profile[16]; | |
819 | char lower_transport[16]; | |
820 | char parameter[16]; | |
821 | RTSPTransportField *th; | |
822 | char buf[256]; | |
823 | ||
824 | reply->nb_transports = 0; | |
825 | ||
826 | for (;;) { | |
827 | p += strspn(p, SPACE_CHARS); | |
828 | if (*p == '\0') | |
829 | break; | |
830 | ||
831 | th = &reply->transports[reply->nb_transports]; | |
832 | ||
833 | get_word_sep(transport_protocol, sizeof(transport_protocol), | |
834 | "/", &p); | |
835 | if (!av_strcasecmp (transport_protocol, "rtp")) { | |
836 | get_word_sep(profile, sizeof(profile), "/;,", &p); | |
837 | lower_transport[0] = '\0'; | |
838 | /* rtp/avp/<protocol> */ | |
839 | if (*p == '/') { | |
840 | get_word_sep(lower_transport, sizeof(lower_transport), | |
841 | ";,", &p); | |
842 | } | |
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); | |
848 | profile[0] = '\0'; | |
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> */ | |
854 | if (*p == '/') { | |
855 | get_word_sep(lower_transport, sizeof(lower_transport), | |
856 | ";,", &p); | |
857 | } | |
858 | th->transport = RTSP_TRANSPORT_RAW; | |
859 | } | |
860 | if (!av_strcasecmp(lower_transport, "TCP")) | |
861 | th->lower_transport = RTSP_LOWER_TRANSPORT_TCP; | |
862 | else | |
863 | th->lower_transport = RTSP_LOWER_TRANSPORT_UDP; | |
864 | ||
865 | if (*p == ';') | |
866 | p++; | |
867 | /* get each parameter */ | |
868 | while (*p != '\0' && *p != ',') { | |
869 | get_word_sep(parameter, sizeof(parameter), "=;,", &p); | |
870 | if (!strcmp(parameter, "port")) { | |
871 | if (*p == '=') { | |
872 | p++; | |
873 | rtsp_parse_range(&th->port_min, &th->port_max, &p); | |
874 | } | |
875 | } else if (!strcmp(parameter, "client_port")) { | |
876 | if (*p == '=') { | |
877 | p++; | |
878 | rtsp_parse_range(&th->client_port_min, | |
879 | &th->client_port_max, &p); | |
880 | } | |
881 | } else if (!strcmp(parameter, "server_port")) { | |
882 | if (*p == '=') { | |
883 | p++; | |
884 | rtsp_parse_range(&th->server_port_min, | |
885 | &th->server_port_max, &p); | |
886 | } | |
887 | } else if (!strcmp(parameter, "interleaved")) { | |
888 | if (*p == '=') { | |
889 | p++; | |
890 | rtsp_parse_range(&th->interleaved_min, | |
891 | &th->interleaved_max, &p); | |
892 | } | |
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")) { | |
897 | if (*p == '=') { | |
898 | char *end; | |
899 | p++; | |
900 | th->ttl = strtol(p, &end, 10); | |
901 | p = end; | |
902 | } | |
903 | } else if (!strcmp(parameter, "destination")) { | |
904 | if (*p == '=') { | |
905 | p++; | |
906 | get_word_sep(buf, sizeof(buf), ";,", &p); | |
907 | get_sockaddr(buf, &th->destination); | |
908 | } | |
909 | } else if (!strcmp(parameter, "source")) { | |
910 | if (*p == '=') { | |
911 | p++; | |
912 | get_word_sep(buf, sizeof(buf), ";,", &p); | |
913 | av_strlcpy(th->source, buf, sizeof(th->source)); | |
914 | } | |
915 | } else if (!strcmp(parameter, "mode")) { | |
916 | if (*p == '=') { | |
917 | p++; | |
918 | get_word_sep(buf, sizeof(buf), ";, ", &p); | |
919 | if (!strcmp(buf, "record") || | |
920 | !strcmp(buf, "receive")) | |
921 | th->mode_record = 1; | |
922 | } | |
923 | } | |
924 | ||
925 | while (*p != ';' && *p != '\0' && *p != ',') | |
926 | p++; | |
927 | if (*p == ';') | |
928 | p++; | |
929 | } | |
930 | if (*p == ',') | |
931 | p++; | |
932 | ||
933 | reply->nb_transports++; | |
934 | } | |
935 | } | |
936 | ||
937 | static void handle_rtp_info(RTSPState *rt, const char *url, | |
938 | uint32_t seq, uint32_t rtptime) | |
939 | { | |
940 | int i; | |
941 | if (!rtptime || !url[0]) | |
942 | return; | |
943 | if (rt->transport != RTSP_TRANSPORT_RTP) | |
944 | return; | |
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; | |
948 | if (!rtpctx) | |
949 | continue; | |
950 | if (!strcmp(rtsp_st->control_url, url)) { | |
951 | rtpctx->base_timestamp = rtptime; | |
952 | break; | |
953 | } | |
954 | } | |
955 | } | |
956 | ||
957 | static void rtsp_parse_rtp_info(RTSPState *rt, const char *p) | |
958 | { | |
959 | int read = 0; | |
960 | char key[20], value[1024], url[1024] = ""; | |
961 | uint32_t seq = 0, rtptime = 0; | |
962 | ||
963 | for (;;) { | |
964 | p += strspn(p, SPACE_CHARS); | |
965 | if (!*p) | |
966 | break; | |
967 | get_word_sep(key, sizeof(key), "=", &p); | |
968 | if (*p != '=') | |
969 | break; | |
970 | p++; | |
971 | get_word_sep(value, sizeof(value), ";, ", &p); | |
972 | read++; | |
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); | |
979 | if (*p == ',') { | |
980 | handle_rtp_info(rt, url, seq, rtptime); | |
981 | url[0] = '\0'; | |
982 | seq = rtptime = 0; | |
983 | read = 0; | |
984 | } | |
985 | if (*p) | |
986 | p++; | |
987 | } | |
988 | if (read > 0) | |
989 | handle_rtp_info(rt, url, seq, rtptime); | |
990 | } | |
991 | ||
992 | void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf, | |
993 | RTSPState *rt, const char *method) | |
994 | { | |
995 | const char *p; | |
996 | ||
997 | /* NOTE: we do case independent match for broken servers */ | |
998 | p = buf; | |
999 | if (av_stristart(p, "Session:", &p)) { | |
1000 | int t; | |
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) { | |
1004 | reply->timeout = t; | |
1005 | } | |
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)); | |
1050 | } | |
1051 | } | |
1052 | ||
1053 | /* skip a RTP/TCP interleaved packet */ | |
1054 | void ff_rtsp_skip_packet(AVFormatContext *s) | |
1055 | { | |
1056 | RTSPState *rt = s->priv_data; | |
1057 | int ret, len, len1; | |
1058 | uint8_t buf[1024]; | |
1059 | ||
1060 | ret = ffurl_read_complete(rt->rtsp_hd, buf, 3); | |
1061 | if (ret != 3) | |
1062 | return; | |
1063 | len = AV_RB16(buf + 1); | |
1064 | ||
1065 | av_dlog(s, "skipping RTP packet len=%d\n", len); | |
1066 | ||
1067 | /* skip payload */ | |
1068 | while (len > 0) { | |
1069 | len1 = len; | |
1070 | if (len1 > sizeof(buf)) | |
1071 | len1 = sizeof(buf); | |
1072 | ret = ffurl_read_complete(rt->rtsp_hd, buf, len1); | |
1073 | if (ret != len1) | |
1074 | return; | |
1075 | len -= len1; | |
1076 | } | |
1077 | } | |
1078 | ||
1079 | int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply, | |
1080 | unsigned char **content_ptr, | |
1081 | int return_on_interleaved_data, const char *method) | |
1082 | { | |
1083 | RTSPState *rt = s->priv_data; | |
1084 | char buf[4096], buf1[1024], *q; | |
1085 | unsigned char ch; | |
1086 | const char *p; | |
1087 | int ret, content_length, line_count = 0, request = 0; | |
1088 | unsigned char *content = NULL; | |
1089 | ||
1090 | start: | |
1091 | line_count = 0; | |
1092 | request = 0; | |
1093 | content = NULL; | |
1094 | memset(reply, 0, sizeof(*reply)); | |
1095 | ||
1096 | /* parse reply (XXX: use buffers) */ | |
1097 | rt->last_reply[0] = '\0'; | |
1098 | for (;;) { | |
1099 | q = buf; | |
1100 | for (;;) { | |
1101 | ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1); | |
1102 | av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch); | |
1103 | if (ret != 1) | |
1104 | return AVERROR_EOF; | |
1105 | if (ch == '\n') | |
1106 | break; | |
1107 | if (ch == '$') { | |
1108 | /* XXX: only parse it if first char on line ? */ | |
1109 | if (return_on_interleaved_data) { | |
1110 | return 1; | |
1111 | } else | |
1112 | ff_rtsp_skip_packet(s); | |
1113 | } else if (ch != '\r') { | |
1114 | if ((q - buf) < sizeof(buf) - 1) | |
1115 | *q++ = ch; | |
1116 | } | |
1117 | } | |
1118 | *q = '\0'; | |
1119 | ||
1120 | av_dlog(s, "line='%s'\n", buf); | |
1121 | ||
1122 | /* test if last line */ | |
1123 | if (buf[0] == '\0') | |
1124 | break; | |
1125 | p = buf; | |
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)); | |
1133 | } else { | |
1134 | av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method | |
1135 | get_word(buf1, sizeof(buf1), &p); // object | |
1136 | request = 1; | |
1137 | } | |
1138 | } else { | |
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)); | |
1142 | } | |
1143 | line_count++; | |
1144 | } | |
1145 | ||
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)); | |
1148 | ||
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); | |
f6fa7814 DM |
1153 | if (!content) |
1154 | return AVERROR(ENOMEM); | |
2ba45a60 DM |
1155 | ffurl_read_complete(rt->rtsp_hd, content, content_length); |
1156 | content[content_length] = '\0'; | |
1157 | } | |
1158 | if (content_ptr) | |
1159 | *content_ptr = content; | |
1160 | else | |
1161 | av_free(content); | |
1162 | ||
1163 | if (request) { | |
1164 | char buf[1024]; | |
1165 | char base64buf[AV_BASE64_SIZE(sizeof(buf))]; | |
1166 | const char* ptr = buf; | |
1167 | ||
1168 | if (!strcmp(reply->reason, "OPTIONS")) { | |
1169 | snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n"); | |
1170 | if (reply->seq) | |
1171 | av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq); | |
1172 | if (reply->session_id[0]) | |
1173 | av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", | |
1174 | reply->session_id); | |
1175 | } else { | |
1176 | snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n"); | |
1177 | } | |
1178 | av_strlcat(buf, "\r\n", sizeof(buf)); | |
1179 | ||
1180 | if (rt->control_transport == RTSP_MODE_TUNNEL) { | |
1181 | av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf)); | |
1182 | ptr = base64buf; | |
1183 | } | |
1184 | ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr)); | |
1185 | ||
f6fa7814 | 1186 | rt->last_cmd_time = av_gettime_relative(); |
2ba45a60 DM |
1187 | /* Even if the request from the server had data, it is not the data |
1188 | * that the caller wants or expects. The memory could also be leaked | |
1189 | * if the actual following reply has content data. */ | |
1190 | if (content_ptr) | |
1191 | av_freep(content_ptr); | |
1192 | /* If method is set, this is called from ff_rtsp_send_cmd, | |
1193 | * where a reply to exactly this request is awaited. For | |
1194 | * callers from within packet receiving, we just want to | |
1195 | * return to the caller and go back to receiving packets. */ | |
1196 | if (method) | |
1197 | goto start; | |
1198 | return 0; | |
1199 | } | |
1200 | ||
1201 | if (rt->seq != reply->seq) { | |
1202 | av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n", | |
1203 | rt->seq, reply->seq); | |
1204 | } | |
1205 | ||
1206 | /* EOS */ | |
1207 | if (reply->notice == 2101 /* End-of-Stream Reached */ || | |
1208 | reply->notice == 2104 /* Start-of-Stream Reached */ || | |
1209 | reply->notice == 2306 /* Continuous Feed Terminated */) { | |
1210 | rt->state = RTSP_STATE_IDLE; | |
1211 | } else if (reply->notice >= 4400 && reply->notice < 5500) { | |
1212 | return AVERROR(EIO); /* data or server error */ | |
1213 | } else if (reply->notice == 2401 /* Ticket Expired */ || | |
1214 | (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ ) | |
1215 | return AVERROR(EPERM); | |
1216 | ||
1217 | return 0; | |
1218 | } | |
1219 | ||
1220 | /** | |
1221 | * Send a command to the RTSP server without waiting for the reply. | |
1222 | * | |
1223 | * @param s RTSP (de)muxer context | |
1224 | * @param method the method for the request | |
1225 | * @param url the target url for the request | |
1226 | * @param headers extra header lines to include in the request | |
1227 | * @param send_content if non-null, the data to send as request body content | |
1228 | * @param send_content_length the length of the send_content data, or 0 if | |
1229 | * send_content is null | |
1230 | * | |
1231 | * @return zero if success, nonzero otherwise | |
1232 | */ | |
1233 | static int rtsp_send_cmd_with_content_async(AVFormatContext *s, | |
1234 | const char *method, const char *url, | |
1235 | const char *headers, | |
1236 | const unsigned char *send_content, | |
1237 | int send_content_length) | |
1238 | { | |
1239 | RTSPState *rt = s->priv_data; | |
1240 | char buf[4096], *out_buf; | |
1241 | char base64buf[AV_BASE64_SIZE(sizeof(buf))]; | |
1242 | ||
1243 | /* Add in RTSP headers */ | |
1244 | out_buf = buf; | |
1245 | rt->seq++; | |
1246 | snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url); | |
1247 | if (headers) | |
1248 | av_strlcat(buf, headers, sizeof(buf)); | |
1249 | av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq); | |
1250 | av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent); | |
1251 | if (rt->session_id[0] != '\0' && (!headers || | |
1252 | !strstr(headers, "\nIf-Match:"))) { | |
1253 | av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id); | |
1254 | } | |
1255 | if (rt->auth[0]) { | |
1256 | char *str = ff_http_auth_create_response(&rt->auth_state, | |
1257 | rt->auth, url, method); | |
1258 | if (str) | |
1259 | av_strlcat(buf, str, sizeof(buf)); | |
1260 | av_free(str); | |
1261 | } | |
1262 | if (send_content_length > 0 && send_content) | |
1263 | av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length); | |
1264 | av_strlcat(buf, "\r\n", sizeof(buf)); | |
1265 | ||
1266 | /* base64 encode rtsp if tunneling */ | |
1267 | if (rt->control_transport == RTSP_MODE_TUNNEL) { | |
1268 | av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf)); | |
1269 | out_buf = base64buf; | |
1270 | } | |
1271 | ||
1272 | av_dlog(s, "Sending:\n%s--\n", buf); | |
1273 | ||
1274 | ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf)); | |
1275 | if (send_content_length > 0 && send_content) { | |
1276 | if (rt->control_transport == RTSP_MODE_TUNNEL) { | |
1277 | av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests " | |
1278 | "with content data not supported\n"); | |
1279 | return AVERROR_PATCHWELCOME; | |
1280 | } | |
1281 | ffurl_write(rt->rtsp_hd_out, send_content, send_content_length); | |
1282 | } | |
f6fa7814 | 1283 | rt->last_cmd_time = av_gettime_relative(); |
2ba45a60 DM |
1284 | |
1285 | return 0; | |
1286 | } | |
1287 | ||
1288 | int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method, | |
1289 | const char *url, const char *headers) | |
1290 | { | |
1291 | return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0); | |
1292 | } | |
1293 | ||
1294 | int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url, | |
1295 | const char *headers, RTSPMessageHeader *reply, | |
1296 | unsigned char **content_ptr) | |
1297 | { | |
1298 | return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply, | |
1299 | content_ptr, NULL, 0); | |
1300 | } | |
1301 | ||
1302 | int ff_rtsp_send_cmd_with_content(AVFormatContext *s, | |
1303 | const char *method, const char *url, | |
1304 | const char *header, | |
1305 | RTSPMessageHeader *reply, | |
1306 | unsigned char **content_ptr, | |
1307 | const unsigned char *send_content, | |
1308 | int send_content_length) | |
1309 | { | |
1310 | RTSPState *rt = s->priv_data; | |
1311 | HTTPAuthType cur_auth_type; | |
1312 | int ret, attempts = 0; | |
1313 | ||
1314 | retry: | |
1315 | cur_auth_type = rt->auth_state.auth_type; | |
1316 | if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header, | |
1317 | send_content, | |
1318 | send_content_length))) | |
1319 | return ret; | |
1320 | ||
1321 | if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0) | |
1322 | return ret; | |
1323 | attempts++; | |
1324 | ||
1325 | if (reply->status_code == 401 && | |
1326 | (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) && | |
1327 | rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2) | |
1328 | goto retry; | |
1329 | ||
1330 | if (reply->status_code > 400){ | |
1331 | av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n", | |
1332 | method, | |
1333 | reply->status_code, | |
1334 | reply->reason); | |
1335 | av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply); | |
1336 | } | |
1337 | ||
1338 | return 0; | |
1339 | } | |
1340 | ||
1341 | int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port, | |
1342 | int lower_transport, const char *real_challenge) | |
1343 | { | |
1344 | RTSPState *rt = s->priv_data; | |
1345 | int rtx = 0, j, i, err, interleave = 0, port_off; | |
1346 | RTSPStream *rtsp_st; | |
1347 | RTSPMessageHeader reply1, *reply = &reply1; | |
1348 | char cmd[2048]; | |
1349 | const char *trans_pref; | |
1350 | ||
1351 | if (rt->transport == RTSP_TRANSPORT_RDT) | |
1352 | trans_pref = "x-pn-tng"; | |
1353 | else if (rt->transport == RTSP_TRANSPORT_RAW) | |
1354 | trans_pref = "RAW/RAW"; | |
1355 | else | |
1356 | trans_pref = "RTP/AVP"; | |
1357 | ||
1358 | /* default timeout: 1 minute */ | |
1359 | rt->timeout = 60; | |
1360 | ||
1361 | /* Choose a random starting offset within the first half of the | |
1362 | * port range, to allow for a number of ports to try even if the offset | |
1363 | * happens to be at the end of the random range. */ | |
1364 | port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2); | |
1365 | /* even random offset */ | |
1366 | port_off -= port_off & 0x01; | |
1367 | ||
1368 | for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) { | |
1369 | char transport[2048]; | |
1370 | ||
1371 | /* | |
1372 | * WMS serves all UDP data over a single connection, the RTX, which | |
1373 | * isn't necessarily the first in the SDP but has to be the first | |
1374 | * to be set up, else the second/third SETUP will fail with a 461. | |
1375 | */ | |
1376 | if (lower_transport == RTSP_LOWER_TRANSPORT_UDP && | |
1377 | rt->server_type == RTSP_SERVER_WMS) { | |
1378 | if (i == 0) { | |
1379 | /* rtx first */ | |
1380 | for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) { | |
1381 | int len = strlen(rt->rtsp_streams[rtx]->control_url); | |
1382 | if (len >= 4 && | |
1383 | !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4, | |
1384 | "/rtx")) | |
1385 | break; | |
1386 | } | |
1387 | if (rtx == rt->nb_rtsp_streams) | |
1388 | return -1; /* no RTX found */ | |
1389 | rtsp_st = rt->rtsp_streams[rtx]; | |
1390 | } else | |
1391 | rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1]; | |
1392 | } else | |
1393 | rtsp_st = rt->rtsp_streams[i]; | |
1394 | ||
1395 | /* RTP/UDP */ | |
1396 | if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) { | |
1397 | char buf[256]; | |
1398 | ||
1399 | if (rt->server_type == RTSP_SERVER_WMS && i > 1) { | |
1400 | port = reply->transports[0].client_port_min; | |
1401 | goto have_port; | |
1402 | } | |
1403 | ||
1404 | /* first try in specified port range */ | |
1405 | while (j <= rt->rtp_port_max) { | |
1406 | ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1, | |
1407 | "?localport=%d", j); | |
1408 | /* we will use two ports per rtp stream (rtp and rtcp) */ | |
1409 | j += 2; | |
1410 | if (!ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE, | |
1411 | &s->interrupt_callback, NULL)) | |
1412 | goto rtp_opened; | |
1413 | } | |
1414 | av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n"); | |
1415 | err = AVERROR(EIO); | |
1416 | goto fail; | |
1417 | ||
1418 | rtp_opened: | |
1419 | port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle); | |
1420 | have_port: | |
1421 | snprintf(transport, sizeof(transport) - 1, | |
1422 | "%s/UDP;", trans_pref); | |
1423 | if (rt->server_type != RTSP_SERVER_REAL) | |
1424 | av_strlcat(transport, "unicast;", sizeof(transport)); | |
1425 | av_strlcatf(transport, sizeof(transport), | |
1426 | "client_port=%d", port); | |
1427 | if (rt->transport == RTSP_TRANSPORT_RTP && | |
1428 | !(rt->server_type == RTSP_SERVER_WMS && i > 0)) | |
1429 | av_strlcatf(transport, sizeof(transport), "-%d", port + 1); | |
1430 | } | |
1431 | ||
1432 | /* RTP/TCP */ | |
1433 | else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) { | |
1434 | /* For WMS streams, the application streams are only used for | |
1435 | * UDP. When trying to set it up for TCP streams, the server | |
1436 | * will return an error. Therefore, we skip those streams. */ | |
1437 | if (rt->server_type == RTSP_SERVER_WMS && | |
1438 | (rtsp_st->stream_index < 0 || | |
1439 | s->streams[rtsp_st->stream_index]->codec->codec_type == | |
1440 | AVMEDIA_TYPE_DATA)) | |
1441 | continue; | |
1442 | snprintf(transport, sizeof(transport) - 1, | |
1443 | "%s/TCP;", trans_pref); | |
1444 | if (rt->transport != RTSP_TRANSPORT_RDT) | |
1445 | av_strlcat(transport, "unicast;", sizeof(transport)); | |
1446 | av_strlcatf(transport, sizeof(transport), | |
1447 | "interleaved=%d-%d", | |
1448 | interleave, interleave + 1); | |
1449 | interleave += 2; | |
1450 | } | |
1451 | ||
1452 | else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) { | |
1453 | snprintf(transport, sizeof(transport) - 1, | |
1454 | "%s/UDP;multicast", trans_pref); | |
1455 | } | |
1456 | if (s->oformat) { | |
1457 | av_strlcat(transport, ";mode=record", sizeof(transport)); | |
1458 | } else if (rt->server_type == RTSP_SERVER_REAL || | |
1459 | rt->server_type == RTSP_SERVER_WMS) | |
1460 | av_strlcat(transport, ";mode=play", sizeof(transport)); | |
1461 | snprintf(cmd, sizeof(cmd), | |
1462 | "Transport: %s\r\n", | |
1463 | transport); | |
1464 | if (rt->accept_dynamic_rate) | |
1465 | av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd)); | |
f6fa7814 | 1466 | if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) { |
2ba45a60 DM |
1467 | char real_res[41], real_csum[9]; |
1468 | ff_rdt_calc_response_and_checksum(real_res, real_csum, | |
1469 | real_challenge); | |
1470 | av_strlcatf(cmd, sizeof(cmd), | |
1471 | "If-Match: %s\r\n" | |
1472 | "RealChallenge2: %s, sd=%s\r\n", | |
1473 | rt->session_id, real_res, real_csum); | |
1474 | } | |
1475 | ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL); | |
1476 | if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) { | |
1477 | err = 1; | |
1478 | goto fail; | |
1479 | } else if (reply->status_code != RTSP_STATUS_OK || | |
1480 | reply->nb_transports != 1) { | |
f6fa7814 | 1481 | err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA); |
2ba45a60 DM |
1482 | goto fail; |
1483 | } | |
1484 | ||
1485 | /* XXX: same protocol for all streams is required */ | |
1486 | if (i > 0) { | |
1487 | if (reply->transports[0].lower_transport != rt->lower_transport || | |
1488 | reply->transports[0].transport != rt->transport) { | |
1489 | err = AVERROR_INVALIDDATA; | |
1490 | goto fail; | |
1491 | } | |
1492 | } else { | |
1493 | rt->lower_transport = reply->transports[0].lower_transport; | |
1494 | rt->transport = reply->transports[0].transport; | |
1495 | } | |
1496 | ||
1497 | /* Fail if the server responded with another lower transport mode | |
1498 | * than what we requested. */ | |
1499 | if (reply->transports[0].lower_transport != lower_transport) { | |
1500 | av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n"); | |
1501 | err = AVERROR_INVALIDDATA; | |
1502 | goto fail; | |
1503 | } | |
1504 | ||
1505 | switch(reply->transports[0].lower_transport) { | |
1506 | case RTSP_LOWER_TRANSPORT_TCP: | |
1507 | rtsp_st->interleaved_min = reply->transports[0].interleaved_min; | |
1508 | rtsp_st->interleaved_max = reply->transports[0].interleaved_max; | |
1509 | break; | |
1510 | ||
1511 | case RTSP_LOWER_TRANSPORT_UDP: { | |
1512 | char url[1024], options[30] = ""; | |
1513 | const char *peer = host; | |
1514 | ||
1515 | if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC) | |
1516 | av_strlcpy(options, "?connect=1", sizeof(options)); | |
1517 | /* Use source address if specified */ | |
1518 | if (reply->transports[0].source[0]) | |
1519 | peer = reply->transports[0].source; | |
1520 | ff_url_join(url, sizeof(url), "rtp", NULL, peer, | |
1521 | reply->transports[0].server_port_min, "%s", options); | |
1522 | if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && | |
1523 | ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) { | |
1524 | err = AVERROR_INVALIDDATA; | |
1525 | goto fail; | |
1526 | } | |
1527 | /* Try to initialize the connection state in a | |
1528 | * potential NAT router by sending dummy packets. | |
1529 | * RTP/RTCP dummy packets are used for RDT, too. | |
1530 | */ | |
f6fa7814 DM |
1531 | if (CONFIG_RTPDEC && |
1532 | !(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat) | |
2ba45a60 DM |
1533 | ff_rtp_send_punch_packets(rtsp_st->rtp_handle); |
1534 | break; | |
1535 | } | |
1536 | case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: { | |
1537 | char url[1024], namebuf[50], optbuf[20] = ""; | |
1538 | struct sockaddr_storage addr; | |
1539 | int port, ttl; | |
1540 | ||
1541 | if (reply->transports[0].destination.ss_family) { | |
1542 | addr = reply->transports[0].destination; | |
1543 | port = reply->transports[0].port_min; | |
1544 | ttl = reply->transports[0].ttl; | |
1545 | } else { | |
1546 | addr = rtsp_st->sdp_ip; | |
1547 | port = rtsp_st->sdp_port; | |
1548 | ttl = rtsp_st->sdp_ttl; | |
1549 | } | |
1550 | if (ttl > 0) | |
1551 | snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl); | |
1552 | getnameinfo((struct sockaddr*) &addr, sizeof(addr), | |
1553 | namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST); | |
1554 | ff_url_join(url, sizeof(url), "rtp", NULL, namebuf, | |
1555 | port, "%s", optbuf); | |
1556 | if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE, | |
1557 | &s->interrupt_callback, NULL) < 0) { | |
1558 | err = AVERROR_INVALIDDATA; | |
1559 | goto fail; | |
1560 | } | |
1561 | break; | |
1562 | } | |
1563 | } | |
1564 | ||
1565 | if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st))) | |
1566 | goto fail; | |
1567 | } | |
1568 | ||
1569 | if (rt->nb_rtsp_streams && reply->timeout > 0) | |
1570 | rt->timeout = reply->timeout; | |
1571 | ||
1572 | if (rt->server_type == RTSP_SERVER_REAL) | |
1573 | rt->need_subscription = 1; | |
1574 | ||
1575 | return 0; | |
1576 | ||
1577 | fail: | |
1578 | ff_rtsp_undo_setup(s, 0); | |
1579 | return err; | |
1580 | } | |
1581 | ||
1582 | void ff_rtsp_close_connections(AVFormatContext *s) | |
1583 | { | |
1584 | RTSPState *rt = s->priv_data; | |
1585 | if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out); | |
1586 | ffurl_close(rt->rtsp_hd); | |
1587 | rt->rtsp_hd = rt->rtsp_hd_out = NULL; | |
1588 | } | |
1589 | ||
1590 | int ff_rtsp_connect(AVFormatContext *s) | |
1591 | { | |
1592 | RTSPState *rt = s->priv_data; | |
f6fa7814 DM |
1593 | char proto[128], host[1024], path[1024]; |
1594 | char tcpname[1024], cmd[2048], auth[128]; | |
1595 | const char *lower_rtsp_proto = "tcp"; | |
2ba45a60 DM |
1596 | int port, err, tcp_fd; |
1597 | RTSPMessageHeader reply1 = {0}, *reply = &reply1; | |
1598 | int lower_transport_mask = 0; | |
f6fa7814 | 1599 | int default_port = RTSP_DEFAULT_PORT; |
2ba45a60 DM |
1600 | char real_challenge[64] = ""; |
1601 | struct sockaddr_storage peer; | |
1602 | socklen_t peer_len = sizeof(peer); | |
1603 | ||
1604 | if (rt->rtp_port_max < rt->rtp_port_min) { | |
1605 | av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less " | |
1606 | "than min port %d\n", rt->rtp_port_max, | |
1607 | rt->rtp_port_min); | |
1608 | return AVERROR(EINVAL); | |
1609 | } | |
1610 | ||
1611 | if (!ff_network_init()) | |
1612 | return AVERROR(EIO); | |
1613 | ||
1614 | if (s->max_delay < 0) /* Not set by the caller */ | |
1615 | s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0; | |
1616 | ||
1617 | rt->control_transport = RTSP_MODE_PLAIN; | |
1618 | if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) { | |
1619 | rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP; | |
1620 | rt->control_transport = RTSP_MODE_TUNNEL; | |
1621 | } | |
1622 | /* Only pass through valid flags from here */ | |
1623 | rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1; | |
1624 | ||
1625 | redirect: | |
2ba45a60 | 1626 | /* extract hostname and port */ |
f6fa7814 | 1627 | av_url_split(proto, sizeof(proto), auth, sizeof(auth), |
2ba45a60 | 1628 | host, sizeof(host), &port, path, sizeof(path), s->filename); |
f6fa7814 DM |
1629 | |
1630 | if (!strcmp(proto, "rtsps")) { | |
1631 | lower_rtsp_proto = "tls"; | |
1632 | default_port = RTSPS_DEFAULT_PORT; | |
1633 | rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP; | |
1634 | } | |
1635 | ||
2ba45a60 DM |
1636 | if (*auth) { |
1637 | av_strlcpy(rt->auth, auth, sizeof(rt->auth)); | |
1638 | } | |
1639 | if (port < 0) | |
f6fa7814 DM |
1640 | port = default_port; |
1641 | ||
1642 | lower_transport_mask = rt->lower_transport_mask; | |
2ba45a60 DM |
1643 | |
1644 | if (!lower_transport_mask) | |
1645 | lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1; | |
1646 | ||
1647 | if (s->oformat) { | |
1648 | /* Only UDP or TCP - UDP multicast isn't supported. */ | |
1649 | lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) | | |
1650 | (1 << RTSP_LOWER_TRANSPORT_TCP); | |
1651 | if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) { | |
1652 | av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, " | |
1653 | "only UDP and TCP are supported for output.\n"); | |
1654 | err = AVERROR(EINVAL); | |
1655 | goto fail; | |
1656 | } | |
1657 | } | |
1658 | ||
1659 | /* Construct the URI used in request; this is similar to s->filename, | |
1660 | * but with authentication credentials removed and RTSP specific options | |
1661 | * stripped out. */ | |
f6fa7814 | 1662 | ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL, |
2ba45a60 DM |
1663 | host, port, "%s", path); |
1664 | ||
1665 | if (rt->control_transport == RTSP_MODE_TUNNEL) { | |
1666 | /* set up initial handshake for tunneling */ | |
1667 | char httpname[1024]; | |
1668 | char sessioncookie[17]; | |
1669 | char headers[1024]; | |
1670 | ||
1671 | ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path); | |
1672 | snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x", | |
1673 | av_get_random_seed(), av_get_random_seed()); | |
1674 | ||
1675 | /* GET requests */ | |
1676 | if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ, | |
1677 | &s->interrupt_callback) < 0) { | |
1678 | err = AVERROR(EIO); | |
1679 | goto fail; | |
1680 | } | |
1681 | ||
1682 | /* generate GET headers */ | |
1683 | snprintf(headers, sizeof(headers), | |
1684 | "x-sessioncookie: %s\r\n" | |
1685 | "Accept: application/x-rtsp-tunnelled\r\n" | |
1686 | "Pragma: no-cache\r\n" | |
1687 | "Cache-Control: no-cache\r\n", | |
1688 | sessioncookie); | |
1689 | av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0); | |
1690 | ||
1691 | /* complete the connection */ | |
1692 | if (ffurl_connect(rt->rtsp_hd, NULL)) { | |
1693 | err = AVERROR(EIO); | |
1694 | goto fail; | |
1695 | } | |
1696 | ||
1697 | /* POST requests */ | |
1698 | if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE, | |
1699 | &s->interrupt_callback) < 0 ) { | |
1700 | err = AVERROR(EIO); | |
1701 | goto fail; | |
1702 | } | |
1703 | ||
1704 | /* generate POST headers */ | |
1705 | snprintf(headers, sizeof(headers), | |
1706 | "x-sessioncookie: %s\r\n" | |
1707 | "Content-Type: application/x-rtsp-tunnelled\r\n" | |
1708 | "Pragma: no-cache\r\n" | |
1709 | "Cache-Control: no-cache\r\n" | |
1710 | "Content-Length: 32767\r\n" | |
1711 | "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n", | |
1712 | sessioncookie); | |
1713 | av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0); | |
1714 | av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0); | |
1715 | ||
1716 | /* Initialize the authentication state for the POST session. The HTTP | |
1717 | * protocol implementation doesn't properly handle multi-pass | |
1718 | * authentication for POST requests, since it would require one of | |
1719 | * the following: | |
1720 | * - implementing Expect: 100-continue, which many HTTP servers | |
1721 | * don't support anyway, even less the RTSP servers that do HTTP | |
1722 | * tunneling | |
1723 | * - sending the whole POST data until getting a 401 reply specifying | |
1724 | * what authentication method to use, then resending all that data | |
1725 | * - waiting for potential 401 replies directly after sending the | |
1726 | * POST header (waiting for some unspecified time) | |
1727 | * Therefore, we copy the full auth state, which works for both basic | |
1728 | * and digest. (For digest, we would have to synchronize the nonce | |
1729 | * count variable between the two sessions, if we'd do more requests | |
1730 | * with the original session, though.) | |
1731 | */ | |
1732 | ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd); | |
1733 | ||
1734 | /* complete the connection */ | |
1735 | if (ffurl_connect(rt->rtsp_hd_out, NULL)) { | |
1736 | err = AVERROR(EIO); | |
1737 | goto fail; | |
1738 | } | |
1739 | } else { | |
f6fa7814 | 1740 | int ret; |
2ba45a60 | 1741 | /* open the tcp connection */ |
f6fa7814 DM |
1742 | ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL, |
1743 | host, port, | |
2ba45a60 | 1744 | "?timeout=%d", rt->stimeout); |
f6fa7814 DM |
1745 | if ((ret = ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE, |
1746 | &s->interrupt_callback, NULL)) < 0) { | |
1747 | err = ret; | |
2ba45a60 DM |
1748 | goto fail; |
1749 | } | |
1750 | rt->rtsp_hd_out = rt->rtsp_hd; | |
1751 | } | |
1752 | rt->seq = 0; | |
1753 | ||
1754 | tcp_fd = ffurl_get_file_handle(rt->rtsp_hd); | |
1755 | if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) { | |
1756 | getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host), | |
1757 | NULL, 0, NI_NUMERICHOST); | |
1758 | } | |
1759 | ||
1760 | /* request options supported by the server; this also detects server | |
1761 | * type */ | |
1762 | for (rt->server_type = RTSP_SERVER_RTP;;) { | |
1763 | cmd[0] = 0; | |
1764 | if (rt->server_type == RTSP_SERVER_REAL) | |
1765 | av_strlcat(cmd, | |
1766 | /* | |
1767 | * The following entries are required for proper | |
1768 | * streaming from a Realmedia server. They are | |
1769 | * interdependent in some way although we currently | |
1770 | * don't quite understand how. Values were copied | |
1771 | * from mplayer SVN r23589. | |
1772 | * ClientChallenge is a 16-byte ID in hex | |
1773 | * CompanyID is a 16-byte ID in base64 | |
1774 | */ | |
1775 | "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n" | |
1776 | "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n" | |
1777 | "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n" | |
1778 | "GUID: 00000000-0000-0000-0000-000000000000\r\n", | |
1779 | sizeof(cmd)); | |
1780 | ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL); | |
1781 | if (reply->status_code != RTSP_STATUS_OK) { | |
f6fa7814 | 1782 | err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA); |
2ba45a60 DM |
1783 | goto fail; |
1784 | } | |
1785 | ||
1786 | /* detect server type if not standard-compliant RTP */ | |
1787 | if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) { | |
1788 | rt->server_type = RTSP_SERVER_REAL; | |
1789 | continue; | |
1790 | } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) { | |
1791 | rt->server_type = RTSP_SERVER_WMS; | |
1792 | } else if (rt->server_type == RTSP_SERVER_REAL) | |
1793 | strcpy(real_challenge, reply->real_challenge); | |
1794 | break; | |
1795 | } | |
1796 | ||
f6fa7814 | 1797 | if (CONFIG_RTSP_DEMUXER && s->iformat) |
2ba45a60 DM |
1798 | err = ff_rtsp_setup_input_streams(s, reply); |
1799 | else if (CONFIG_RTSP_MUXER) | |
1800 | err = ff_rtsp_setup_output_streams(s, host); | |
f6fa7814 DM |
1801 | else |
1802 | av_assert0(0); | |
2ba45a60 DM |
1803 | if (err) |
1804 | goto fail; | |
1805 | ||
1806 | do { | |
1807 | int lower_transport = ff_log2_tab[lower_transport_mask & | |
1808 | ~(lower_transport_mask - 1)]; | |
1809 | ||
1810 | if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP)) | |
1811 | && (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP)) | |
1812 | lower_transport = RTSP_LOWER_TRANSPORT_TCP; | |
1813 | ||
1814 | err = ff_rtsp_make_setup_request(s, host, port, lower_transport, | |
1815 | rt->server_type == RTSP_SERVER_REAL ? | |
1816 | real_challenge : NULL); | |
1817 | if (err < 0) | |
1818 | goto fail; | |
1819 | lower_transport_mask &= ~(1 << lower_transport); | |
1820 | if (lower_transport_mask == 0 && err == 1) { | |
1821 | err = AVERROR(EPROTONOSUPPORT); | |
1822 | goto fail; | |
1823 | } | |
1824 | } while (err); | |
1825 | ||
1826 | rt->lower_transport_mask = lower_transport_mask; | |
1827 | av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge)); | |
1828 | rt->state = RTSP_STATE_IDLE; | |
1829 | rt->seek_timestamp = 0; /* default is to start stream at position zero */ | |
1830 | return 0; | |
1831 | fail: | |
1832 | ff_rtsp_close_streams(s); | |
1833 | ff_rtsp_close_connections(s); | |
1834 | if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) { | |
1835 | av_strlcpy(s->filename, reply->location, sizeof(s->filename)); | |
f6fa7814 | 1836 | rt->session_id[0] = '\0'; |
2ba45a60 DM |
1837 | av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n", |
1838 | reply->status_code, | |
1839 | s->filename); | |
1840 | goto redirect; | |
1841 | } | |
1842 | ff_network_close(); | |
1843 | return err; | |
1844 | } | |
1845 | #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */ | |
1846 | ||
1847 | #if CONFIG_RTPDEC | |
1848 | static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, | |
1849 | uint8_t *buf, int buf_size, int64_t wait_end) | |
1850 | { | |
1851 | RTSPState *rt = s->priv_data; | |
1852 | RTSPStream *rtsp_st; | |
1853 | int n, i, ret, tcp_fd, timeout_cnt = 0; | |
1854 | int max_p = 0; | |
1855 | struct pollfd *p = rt->p; | |
1856 | int *fds = NULL, fdsnum, fdsidx; | |
1857 | ||
1858 | for (;;) { | |
1859 | if (ff_check_interrupt(&s->interrupt_callback)) | |
1860 | return AVERROR_EXIT; | |
f6fa7814 | 1861 | if (wait_end && wait_end - av_gettime_relative() < 0) |
2ba45a60 DM |
1862 | return AVERROR(EAGAIN); |
1863 | max_p = 0; | |
1864 | if (rt->rtsp_hd) { | |
1865 | tcp_fd = ffurl_get_file_handle(rt->rtsp_hd); | |
1866 | p[max_p].fd = tcp_fd; | |
1867 | p[max_p++].events = POLLIN; | |
1868 | } else { | |
1869 | tcp_fd = -1; | |
1870 | } | |
1871 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
1872 | rtsp_st = rt->rtsp_streams[i]; | |
1873 | if (rtsp_st->rtp_handle) { | |
1874 | if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle, | |
1875 | &fds, &fdsnum)) { | |
1876 | av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n"); | |
1877 | return ret; | |
1878 | } | |
1879 | if (fdsnum != 2) { | |
1880 | av_log(s, AV_LOG_ERROR, | |
1881 | "Number of fds %d not supported\n", fdsnum); | |
1882 | return AVERROR_INVALIDDATA; | |
1883 | } | |
1884 | for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) { | |
1885 | p[max_p].fd = fds[fdsidx]; | |
1886 | p[max_p++].events = POLLIN; | |
1887 | } | |
1888 | av_free(fds); | |
1889 | } | |
1890 | } | |
1891 | n = poll(p, max_p, POLL_TIMEOUT_MS); | |
1892 | if (n > 0) { | |
1893 | int j = 1 - (tcp_fd == -1); | |
1894 | timeout_cnt = 0; | |
1895 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
1896 | rtsp_st = rt->rtsp_streams[i]; | |
1897 | if (rtsp_st->rtp_handle) { | |
1898 | if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) { | |
1899 | ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size); | |
1900 | if (ret > 0) { | |
1901 | *prtsp_st = rtsp_st; | |
1902 | return ret; | |
1903 | } | |
1904 | } | |
1905 | j+=2; | |
1906 | } | |
1907 | } | |
1908 | #if CONFIG_RTSP_DEMUXER | |
1909 | if (tcp_fd != -1 && p[0].revents & POLLIN) { | |
1910 | if (rt->rtsp_flags & RTSP_FLAG_LISTEN) { | |
1911 | if (rt->state == RTSP_STATE_STREAMING) { | |
1912 | if (!ff_rtsp_parse_streaming_commands(s)) | |
1913 | return AVERROR_EOF; | |
1914 | else | |
1915 | av_log(s, AV_LOG_WARNING, | |
1916 | "Unable to answer to TEARDOWN\n"); | |
1917 | } else | |
1918 | return 0; | |
1919 | } else { | |
1920 | RTSPMessageHeader reply; | |
1921 | ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL); | |
1922 | if (ret < 0) | |
1923 | return ret; | |
1924 | /* XXX: parse message */ | |
1925 | if (rt->state != RTSP_STATE_STREAMING) | |
1926 | return 0; | |
1927 | } | |
1928 | } | |
1929 | #endif | |
1930 | } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) { | |
1931 | return AVERROR(ETIMEDOUT); | |
1932 | } else if (n < 0 && errno != EINTR) | |
1933 | return AVERROR(errno); | |
1934 | } | |
1935 | } | |
1936 | ||
1937 | static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st, | |
1938 | const uint8_t *buf, int len) | |
1939 | { | |
1940 | RTSPState *rt = s->priv_data; | |
1941 | int i; | |
1942 | if (len < 0) | |
1943 | return len; | |
1944 | if (rt->nb_rtsp_streams == 1) { | |
1945 | *rtsp_st = rt->rtsp_streams[0]; | |
1946 | return len; | |
1947 | } | |
1948 | if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) { | |
1949 | if (RTP_PT_IS_RTCP(rt->recvbuf[1])) { | |
1950 | int no_ssrc = 0; | |
1951 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
1952 | RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv; | |
1953 | if (!rtpctx) | |
1954 | continue; | |
1955 | if (rtpctx->ssrc == AV_RB32(&buf[4])) { | |
1956 | *rtsp_st = rt->rtsp_streams[i]; | |
1957 | return len; | |
1958 | } | |
1959 | if (!rtpctx->ssrc) | |
1960 | no_ssrc = 1; | |
1961 | } | |
1962 | if (no_ssrc) { | |
1963 | av_log(s, AV_LOG_WARNING, | |
1964 | "Unable to pick stream for packet - SSRC not known for " | |
1965 | "all streams\n"); | |
1966 | return AVERROR(EAGAIN); | |
1967 | } | |
1968 | } else { | |
1969 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
1970 | if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) { | |
1971 | *rtsp_st = rt->rtsp_streams[i]; | |
1972 | return len; | |
1973 | } | |
1974 | } | |
1975 | } | |
1976 | } | |
1977 | av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n"); | |
1978 | return AVERROR(EAGAIN); | |
1979 | } | |
1980 | ||
1981 | int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt) | |
1982 | { | |
1983 | RTSPState *rt = s->priv_data; | |
1984 | int ret, len; | |
1985 | RTSPStream *rtsp_st, *first_queue_st = NULL; | |
1986 | int64_t wait_end = 0; | |
1987 | ||
1988 | if (rt->nb_byes == rt->nb_rtsp_streams) | |
1989 | return AVERROR_EOF; | |
1990 | ||
1991 | /* get next frames from the same RTP packet */ | |
1992 | if (rt->cur_transport_priv) { | |
1993 | if (rt->transport == RTSP_TRANSPORT_RDT) { | |
1994 | ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0); | |
1995 | } else if (rt->transport == RTSP_TRANSPORT_RTP) { | |
1996 | ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0); | |
f6fa7814 | 1997 | } else if (CONFIG_RTPDEC && rt->ts) { |
2ba45a60 DM |
1998 | ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos); |
1999 | if (ret >= 0) { | |
2000 | rt->recvbuf_pos += ret; | |
2001 | ret = rt->recvbuf_pos < rt->recvbuf_len; | |
2002 | } | |
2003 | } else | |
2004 | ret = -1; | |
2005 | if (ret == 0) { | |
2006 | rt->cur_transport_priv = NULL; | |
2007 | return 0; | |
2008 | } else if (ret == 1) { | |
2009 | return 0; | |
2010 | } else | |
2011 | rt->cur_transport_priv = NULL; | |
2012 | } | |
2013 | ||
2014 | redo: | |
2015 | if (rt->transport == RTSP_TRANSPORT_RTP) { | |
2016 | int i; | |
2017 | int64_t first_queue_time = 0; | |
2018 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
2019 | RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv; | |
2020 | int64_t queue_time; | |
2021 | if (!rtpctx) | |
2022 | continue; | |
2023 | queue_time = ff_rtp_queued_packet_time(rtpctx); | |
2024 | if (queue_time && (queue_time - first_queue_time < 0 || | |
2025 | !first_queue_time)) { | |
2026 | first_queue_time = queue_time; | |
2027 | first_queue_st = rt->rtsp_streams[i]; | |
2028 | } | |
2029 | } | |
2030 | if (first_queue_time) { | |
2031 | wait_end = first_queue_time + s->max_delay; | |
2032 | } else { | |
2033 | wait_end = 0; | |
2034 | first_queue_st = NULL; | |
2035 | } | |
2036 | } | |
2037 | ||
2038 | /* read next RTP packet */ | |
2039 | if (!rt->recvbuf) { | |
2040 | rt->recvbuf = av_malloc(RECVBUF_SIZE); | |
2041 | if (!rt->recvbuf) | |
2042 | return AVERROR(ENOMEM); | |
2043 | } | |
2044 | ||
2045 | switch(rt->lower_transport) { | |
2046 | default: | |
2047 | #if CONFIG_RTSP_DEMUXER | |
2048 | case RTSP_LOWER_TRANSPORT_TCP: | |
2049 | len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE); | |
2050 | break; | |
2051 | #endif | |
2052 | case RTSP_LOWER_TRANSPORT_UDP: | |
2053 | case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: | |
2054 | len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end); | |
2055 | if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP) | |
2056 | ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len); | |
2057 | break; | |
2058 | case RTSP_LOWER_TRANSPORT_CUSTOM: | |
2059 | if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP && | |
f6fa7814 | 2060 | wait_end && wait_end < av_gettime_relative()) |
2ba45a60 DM |
2061 | len = AVERROR(EAGAIN); |
2062 | else | |
2063 | len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE); | |
2064 | len = pick_stream(s, &rtsp_st, rt->recvbuf, len); | |
2065 | if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP) | |
2066 | ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len); | |
2067 | break; | |
2068 | } | |
2069 | if (len == AVERROR(EAGAIN) && first_queue_st && | |
2070 | rt->transport == RTSP_TRANSPORT_RTP) { | |
2071 | rtsp_st = first_queue_st; | |
2072 | ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0); | |
2073 | goto end; | |
2074 | } | |
2075 | if (len < 0) | |
2076 | return len; | |
2077 | if (len == 0) | |
2078 | return AVERROR_EOF; | |
2079 | if (rt->transport == RTSP_TRANSPORT_RDT) { | |
2080 | ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len); | |
2081 | } else if (rt->transport == RTSP_TRANSPORT_RTP) { | |
2082 | ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len); | |
2083 | if (rtsp_st->feedback) { | |
2084 | AVIOContext *pb = NULL; | |
2085 | if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM) | |
2086 | pb = s->pb; | |
2087 | ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb); | |
2088 | } | |
2089 | if (ret < 0) { | |
2090 | /* Either bad packet, or a RTCP packet. Check if the | |
2091 | * first_rtcp_ntp_time field was initialized. */ | |
2092 | RTPDemuxContext *rtpctx = rtsp_st->transport_priv; | |
2093 | if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) { | |
2094 | /* first_rtcp_ntp_time has been initialized for this stream, | |
2095 | * copy the same value to all other uninitialized streams, | |
2096 | * in order to map their timestamp origin to the same ntp time | |
2097 | * as this one. */ | |
2098 | int i; | |
2099 | AVStream *st = NULL; | |
2100 | if (rtsp_st->stream_index >= 0) | |
2101 | st = s->streams[rtsp_st->stream_index]; | |
2102 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
2103 | RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv; | |
2104 | AVStream *st2 = NULL; | |
2105 | if (rt->rtsp_streams[i]->stream_index >= 0) | |
2106 | st2 = s->streams[rt->rtsp_streams[i]->stream_index]; | |
2107 | if (rtpctx2 && st && st2 && | |
2108 | rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) { | |
2109 | rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time; | |
2110 | rtpctx2->rtcp_ts_offset = av_rescale_q( | |
2111 | rtpctx->rtcp_ts_offset, st->time_base, | |
2112 | st2->time_base); | |
2113 | } | |
2114 | } | |
2115 | // Make real NTP start time available in AVFormatContext | |
2116 | if (s->start_time_realtime == AV_NOPTS_VALUE) { | |
2117 | s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32); | |
2118 | if (rtpctx->st) { | |
2119 | s->start_time_realtime -= | |
2120 | av_rescale (rtpctx->rtcp_ts_offset, | |
2121 | (uint64_t) rtpctx->st->time_base.num * 1000000, | |
2122 | rtpctx->st->time_base.den); | |
2123 | } | |
2124 | } | |
2125 | } | |
2126 | if (ret == -RTCP_BYE) { | |
2127 | rt->nb_byes++; | |
2128 | ||
2129 | av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n", | |
2130 | rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams); | |
2131 | ||
2132 | if (rt->nb_byes == rt->nb_rtsp_streams) | |
2133 | return AVERROR_EOF; | |
2134 | } | |
2135 | } | |
f6fa7814 | 2136 | } else if (CONFIG_RTPDEC && rt->ts) { |
2ba45a60 DM |
2137 | ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len); |
2138 | if (ret >= 0) { | |
2139 | if (ret < len) { | |
2140 | rt->recvbuf_len = len; | |
2141 | rt->recvbuf_pos = ret; | |
2142 | rt->cur_transport_priv = rt->ts; | |
2143 | return 1; | |
2144 | } else { | |
2145 | ret = 0; | |
2146 | } | |
2147 | } | |
2148 | } else { | |
2149 | return AVERROR_INVALIDDATA; | |
2150 | } | |
2151 | end: | |
2152 | if (ret < 0) | |
2153 | goto redo; | |
2154 | if (ret == 1) | |
2155 | /* more packets may follow, so we save the RTP context */ | |
2156 | rt->cur_transport_priv = rtsp_st->transport_priv; | |
2157 | ||
2158 | return ret; | |
2159 | } | |
2160 | #endif /* CONFIG_RTPDEC */ | |
2161 | ||
2162 | #if CONFIG_SDP_DEMUXER | |
2163 | static int sdp_probe(AVProbeData *p1) | |
2164 | { | |
2165 | const char *p = p1->buf, *p_end = p1->buf + p1->buf_size; | |
2166 | ||
2167 | /* we look for a line beginning "c=IN IP" */ | |
2168 | while (p < p_end && *p != '\0') { | |
2169 | if (p + sizeof("c=IN IP") - 1 < p_end && | |
2170 | av_strstart(p, "c=IN IP", NULL)) | |
2171 | return AVPROBE_SCORE_EXTENSION; | |
2172 | ||
2173 | while (p < p_end - 1 && *p != '\n') p++; | |
2174 | if (++p >= p_end) | |
2175 | break; | |
2176 | if (*p == '\r') | |
2177 | p++; | |
2178 | } | |
2179 | return 0; | |
2180 | } | |
2181 | ||
2182 | static void append_source_addrs(char *buf, int size, const char *name, | |
2183 | int count, struct RTSPSource **addrs) | |
2184 | { | |
2185 | int i; | |
2186 | if (!count) | |
2187 | return; | |
2188 | av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr); | |
2189 | for (i = 1; i < count; i++) | |
2190 | av_strlcatf(buf, size, ",%s", addrs[i]->addr); | |
2191 | } | |
2192 | ||
2193 | static int sdp_read_header(AVFormatContext *s) | |
2194 | { | |
2195 | RTSPState *rt = s->priv_data; | |
2196 | RTSPStream *rtsp_st; | |
2197 | int size, i, err; | |
2198 | char *content; | |
2199 | char url[1024]; | |
2200 | ||
2201 | if (!ff_network_init()) | |
2202 | return AVERROR(EIO); | |
2203 | ||
2204 | if (s->max_delay < 0) /* Not set by the caller */ | |
2205 | s->max_delay = DEFAULT_REORDERING_DELAY; | |
2206 | if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO) | |
2207 | rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM; | |
2208 | ||
2209 | /* read the whole sdp file */ | |
2210 | /* XXX: better loading */ | |
2211 | content = av_malloc(SDP_MAX_SIZE); | |
2212 | size = avio_read(s->pb, content, SDP_MAX_SIZE - 1); | |
2213 | if (size <= 0) { | |
2214 | av_free(content); | |
2215 | return AVERROR_INVALIDDATA; | |
2216 | } | |
2217 | content[size] ='\0'; | |
2218 | ||
2219 | err = ff_sdp_parse(s, content); | |
2220 | av_free(content); | |
2221 | if (err) goto fail; | |
2222 | ||
2223 | /* open each RTP stream */ | |
2224 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
2225 | char namebuf[50]; | |
2226 | rtsp_st = rt->rtsp_streams[i]; | |
2227 | ||
2228 | if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) { | |
2229 | getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip), | |
2230 | namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST); | |
2231 | ff_url_join(url, sizeof(url), "rtp", NULL, | |
2232 | namebuf, rtsp_st->sdp_port, | |
2233 | "?localport=%d&ttl=%d&connect=%d&write_to_source=%d", | |
2234 | rtsp_st->sdp_port, rtsp_st->sdp_ttl, | |
2235 | rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0, | |
2236 | rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0); | |
2237 | ||
2238 | append_source_addrs(url, sizeof(url), "sources", | |
2239 | rtsp_st->nb_include_source_addrs, | |
2240 | rtsp_st->include_source_addrs); | |
2241 | append_source_addrs(url, sizeof(url), "block", | |
2242 | rtsp_st->nb_exclude_source_addrs, | |
2243 | rtsp_st->exclude_source_addrs); | |
2244 | if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE, | |
2245 | &s->interrupt_callback, NULL) < 0) { | |
2246 | err = AVERROR_INVALIDDATA; | |
2247 | goto fail; | |
2248 | } | |
2249 | } | |
2250 | if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st))) | |
2251 | goto fail; | |
2252 | } | |
2253 | return 0; | |
2254 | fail: | |
2255 | ff_rtsp_close_streams(s); | |
2256 | ff_network_close(); | |
2257 | return err; | |
2258 | } | |
2259 | ||
2260 | static int sdp_read_close(AVFormatContext *s) | |
2261 | { | |
2262 | ff_rtsp_close_streams(s); | |
2263 | ff_network_close(); | |
2264 | return 0; | |
2265 | } | |
2266 | ||
2267 | static const AVClass sdp_demuxer_class = { | |
2268 | .class_name = "SDP demuxer", | |
2269 | .item_name = av_default_item_name, | |
2270 | .option = sdp_options, | |
2271 | .version = LIBAVUTIL_VERSION_INT, | |
2272 | }; | |
2273 | ||
2274 | AVInputFormat ff_sdp_demuxer = { | |
2275 | .name = "sdp", | |
2276 | .long_name = NULL_IF_CONFIG_SMALL("SDP"), | |
2277 | .priv_data_size = sizeof(RTSPState), | |
2278 | .read_probe = sdp_probe, | |
2279 | .read_header = sdp_read_header, | |
2280 | .read_packet = ff_rtsp_fetch_packet, | |
2281 | .read_close = sdp_read_close, | |
2282 | .priv_class = &sdp_demuxer_class, | |
2283 | }; | |
2284 | #endif /* CONFIG_SDP_DEMUXER */ | |
2285 | ||
2286 | #if CONFIG_RTP_DEMUXER | |
2287 | static int rtp_probe(AVProbeData *p) | |
2288 | { | |
2289 | if (av_strstart(p->filename, "rtp:", NULL)) | |
2290 | return AVPROBE_SCORE_MAX; | |
2291 | return 0; | |
2292 | } | |
2293 | ||
2294 | static int rtp_read_header(AVFormatContext *s) | |
2295 | { | |
2296 | uint8_t recvbuf[RTP_MAX_PACKET_LENGTH]; | |
2297 | char host[500], sdp[500]; | |
2298 | int ret, port; | |
2299 | URLContext* in = NULL; | |
2300 | int payload_type; | |
2301 | AVCodecContext codec = { 0 }; | |
2302 | struct sockaddr_storage addr; | |
2303 | AVIOContext pb; | |
2304 | socklen_t addrlen = sizeof(addr); | |
2305 | RTSPState *rt = s->priv_data; | |
2306 | ||
2307 | if (!ff_network_init()) | |
2308 | return AVERROR(EIO); | |
2309 | ||
2310 | ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ, | |
2311 | &s->interrupt_callback, NULL); | |
2312 | if (ret) | |
2313 | goto fail; | |
2314 | ||
2315 | while (1) { | |
2316 | ret = ffurl_read(in, recvbuf, sizeof(recvbuf)); | |
2317 | if (ret == AVERROR(EAGAIN)) | |
2318 | continue; | |
2319 | if (ret < 0) | |
2320 | goto fail; | |
2321 | if (ret < 12) { | |
2322 | av_log(s, AV_LOG_WARNING, "Received too short packet\n"); | |
2323 | continue; | |
2324 | } | |
2325 | ||
2326 | if ((recvbuf[0] & 0xc0) != 0x80) { | |
2327 | av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet " | |
2328 | "received\n"); | |
2329 | continue; | |
2330 | } | |
2331 | ||
2332 | if (RTP_PT_IS_RTCP(recvbuf[1])) | |
2333 | continue; | |
2334 | ||
2335 | payload_type = recvbuf[1] & 0x7f; | |
2336 | break; | |
2337 | } | |
2338 | getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen); | |
2339 | ffurl_close(in); | |
2340 | in = NULL; | |
2341 | ||
2342 | if (ff_rtp_get_codec_info(&codec, payload_type)) { | |
2343 | av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d " | |
2344 | "without an SDP file describing it\n", | |
2345 | payload_type); | |
2346 | goto fail; | |
2347 | } | |
2348 | if (codec.codec_type != AVMEDIA_TYPE_DATA) { | |
2349 | av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received " | |
2350 | "properly you need an SDP file " | |
2351 | "describing it\n"); | |
2352 | } | |
2353 | ||
2354 | av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port, | |
2355 | NULL, 0, s->filename); | |
2356 | ||
2357 | snprintf(sdp, sizeof(sdp), | |
2358 | "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n", | |
2359 | addr.ss_family == AF_INET ? 4 : 6, host, | |
2360 | codec.codec_type == AVMEDIA_TYPE_DATA ? "application" : | |
2361 | codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio", | |
2362 | port, payload_type); | |
2363 | av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp); | |
2364 | ||
2365 | ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL); | |
2366 | s->pb = &pb; | |
2367 | ||
2368 | /* sdp_read_header initializes this again */ | |
2369 | ff_network_close(); | |
2370 | ||
2371 | rt->media_type_mask = (1 << (AVMEDIA_TYPE_DATA+1)) - 1; | |
2372 | ||
2373 | ret = sdp_read_header(s); | |
2374 | s->pb = NULL; | |
2375 | return ret; | |
2376 | ||
2377 | fail: | |
2378 | if (in) | |
2379 | ffurl_close(in); | |
2380 | ff_network_close(); | |
2381 | return ret; | |
2382 | } | |
2383 | ||
2384 | static const AVClass rtp_demuxer_class = { | |
2385 | .class_name = "RTP demuxer", | |
2386 | .item_name = av_default_item_name, | |
2387 | .option = rtp_options, | |
2388 | .version = LIBAVUTIL_VERSION_INT, | |
2389 | }; | |
2390 | ||
2391 | AVInputFormat ff_rtp_demuxer = { | |
2392 | .name = "rtp", | |
2393 | .long_name = NULL_IF_CONFIG_SMALL("RTP input"), | |
2394 | .priv_data_size = sizeof(RTSPState), | |
2395 | .read_probe = rtp_probe, | |
2396 | .read_header = rtp_read_header, | |
2397 | .read_packet = ff_rtsp_fetch_packet, | |
2398 | .read_close = sdp_read_close, | |
2399 | .flags = AVFMT_NOFILE, | |
2400 | .priv_class = &rtp_demuxer_class, | |
2401 | }; | |
2402 | #endif /* CONFIG_RTP_DEMUXER */ |