Commit | Line | Data |
---|---|---|
1617ad97 | 1 | /* |
93ced3e8 | 2 | * RTSP/SDP client |
406792e7 | 3 | * Copyright (c) 2002 Fabrice Bellard |
1617ad97 | 4 | * |
2912e87a | 5 | * This file is part of Libav. |
b78e7197 | 6 | * |
2912e87a | 7 | * Libav is free software; you can redistribute it and/or |
1617ad97 FB |
8 | * modify it under the terms of the GNU Lesser General Public |
9 | * License as published by the Free Software Foundation; either | |
b78e7197 | 10 | * version 2.1 of the License, or (at your option) any later version. |
1617ad97 | 11 | * |
2912e87a | 12 | * Libav is distributed in the hope that it will be useful, |
1617ad97 FB |
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 | |
2912e87a | 18 | * License along with Libav; if not, write to the Free Software |
5509bffa | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1617ad97 | 20 | */ |
245976da | 21 | |
f9337897 | 22 | #include "libavutil/base64.h" |
245976da | 23 | #include "libavutil/avstring.h" |
6a5d31ac | 24 | #include "libavutil/intreadwrite.h" |
0ebcdf5c | 25 | #include "libavutil/mathematics.h" |
9fcae973 | 26 | #include "libavutil/parseutils.h" |
f5d33f52 | 27 | #include "libavutil/random_seed.h" |
d2d67e42 | 28 | #include "libavutil/dict.h" |
d450cc4f | 29 | #include "libavutil/opt.h" |
1617ad97 | 30 | #include "avformat.h" |
e731b8d8 | 31 | #include "avio_internal.h" |
1617ad97 | 32 | |
db0ed93e | 33 | #include <sys/time.h> |
a8475bbd LB |
34 | #if HAVE_POLL_H |
35 | #include <poll.h> | |
6ad1c9c9 | 36 | #endif |
e4a9e3cc | 37 | #include "internal.h" |
42572ef5 | 38 | #include "network.h" |
cbfa66d0 | 39 | #include "os_support.h" |
f5d33f52 | 40 | #include "http.h" |
c971ff19 | 41 | #include "rtsp.h" |
1617ad97 | 42 | |
302879cb | 43 | #include "rtpdec.h" |
e9dea59f | 44 | #include "rdt.h" |
965a3ddb | 45 | #include "rtpdec_formats.h" |
a493f80a | 46 | #include "rtpenc_chain.h" |
5652bb94 | 47 | #include "url.h" |
17fff881 | 48 | #include "rtpenc.h" |
4934884a | 49 | |
1617ad97 FB |
50 | //#define DEBUG |
51 | ||
a8475bbd | 52 | /* Timeout values for socket poll, in ms, |
9cba6f5f | 53 | * and read_packet(), in seconds */ |
a8475bbd | 54 | #define POLL_TIMEOUT_MS 100 |
9cba6f5f | 55 | #define READ_PACKET_TIMEOUT_S 10 |
a8475bbd | 56 | #define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS |
91af5601 | 57 | #define SDP_MAX_SIZE 16384 |
96a7c975 | 58 | #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH |
9cba6f5f | 59 | |
2c9aa024 MS |
60 | #define OFFSET(x) offsetof(RTSPState, x) |
61 | #define DEC AV_OPT_FLAG_DECODING_PARAM | |
eca4850c | 62 | #define ENC AV_OPT_FLAG_ENCODING_PARAM |
3a6765fb MS |
63 | |
64 | #define RTSP_FLAG_OPTS(name, longname) \ | |
65 | { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \ | |
66 | { "filter_src", "Only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, "rtsp_flags" } | |
67 | ||
f011fcd6 JB |
68 | #define RTSP_MEDIATYPE_OPTS(name, longname) \ |
69 | { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { (1 << (AVMEDIA_TYPE_DATA+1)) - 1 }, INT_MIN, INT_MAX, DEC, "allowed_media_types" }, \ | |
70 | { "video", "Video", 0, AV_OPT_TYPE_CONST, {1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \ | |
71 | { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \ | |
72 | { "data", "Data", 0, AV_OPT_TYPE_CONST, {1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" } | |
73 | ||
17fff881 | 74 | const AVOption ff_rtsp_options[] = { |
2c9aa024 | 75 | { "initial_pause", "Don't start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_INT, {0}, 0, 1, DEC }, |
c2ff63e3 | 76 | FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags) |
eca4850c MS |
77 | { "rtsp_transport", "RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {0}, INT_MIN, INT_MAX, DEC|ENC, "rtsp_transport" }, \ |
78 | { "udp", "UDP", 0, AV_OPT_TYPE_CONST, {1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \ | |
79 | { "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, "rtsp_transport" }, \ | |
80 | { "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, "rtsp_transport" }, | |
81 | { "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {(1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, "rtsp_transport" }, | |
3a6765fb | 82 | RTSP_FLAG_OPTS("rtsp_flags", "RTSP flags"), |
f011fcd6 | 83 | RTSP_MEDIATYPE_OPTS("allowed_media_types", "Media types to accept from the server"), |
dbb06b8c MS |
84 | { "min_port", "Minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC }, |
85 | { "max_port", "Maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC }, | |
17fff881 MS |
86 | { NULL }, |
87 | }; | |
88 | ||
51369f28 MS |
89 | static const AVOption sdp_options[] = { |
90 | RTSP_FLAG_OPTS("sdp_flags", "SDP flags"), | |
f011fcd6 | 91 | RTSP_MEDIATYPE_OPTS("allowed_media_types", "Media types to accept from the server"), |
51369f28 MS |
92 | { NULL }, |
93 | }; | |
94 | ||
95 | static const AVOption rtp_options[] = { | |
96 | RTSP_FLAG_OPTS("rtp_flags", "RTP flags"), | |
97 | { NULL }, | |
98 | }; | |
99 | ||
1ef36a70 RB |
100 | static void get_word_until_chars(char *buf, int buf_size, |
101 | const char *sep, const char **pp) | |
1617ad97 FB |
102 | { |
103 | const char *p; | |
104 | char *q; | |
105 | ||
106 | p = *pp; | |
30619e6e | 107 | p += strspn(p, SPACE_CHARS); |
1617ad97 FB |
108 | q = buf; |
109 | while (!strchr(sep, *p) && *p != '\0') { | |
110 | if ((q - buf) < buf_size - 1) | |
111 | *q++ = *p; | |
112 | p++; | |
113 | } | |
114 | if (buf_size > 0) | |
115 | *q = '\0'; | |
116 | *pp = p; | |
117 | } | |
118 | ||
1ef36a70 RB |
119 | static void get_word_sep(char *buf, int buf_size, const char *sep, |
120 | const char **pp) | |
1617ad97 | 121 | { |
1ef36a70 RB |
122 | if (**pp == '/') (*pp)++; |
123 | get_word_until_chars(buf, buf_size, sep, pp); | |
124 | } | |
1617ad97 | 125 | |
1ef36a70 RB |
126 | static void get_word(char *buf, int buf_size, const char **pp) |
127 | { | |
128 | get_word_until_chars(buf, buf_size, SPACE_CHARS, pp); | |
1617ad97 FB |
129 | } |
130 | ||
8bf0f969 MS |
131 | /** Parse a string p in the form of Range:npt=xx-xx, and determine the start |
132 | * and end time. | |
133 | * Used for seeking in the rtp stream. | |
134 | */ | |
135 | static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end) | |
136 | { | |
137 | char buf[256]; | |
138 | ||
139 | p += strspn(p, SPACE_CHARS); | |
140 | if (!av_stristart(p, "npt=", &p)) | |
141 | return; | |
142 | ||
143 | *start = AV_NOPTS_VALUE; | |
144 | *end = AV_NOPTS_VALUE; | |
145 | ||
146 | get_word_sep(buf, sizeof(buf), "-", &p); | |
9fcae973 | 147 | av_parse_time(start, buf, 1); |
8bf0f969 MS |
148 | if (*p == '-') { |
149 | p++; | |
150 | get_word_sep(buf, sizeof(buf), "-", &p); | |
9fcae973 | 151 | av_parse_time(end, buf, 1); |
8bf0f969 MS |
152 | } |
153 | // av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start); | |
154 | // av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end); | |
155 | } | |
156 | ||
157 | static int get_sockaddr(const char *buf, struct sockaddr_storage *sock) | |
158 | { | |
159 | struct addrinfo hints, *ai = NULL; | |
160 | memset(&hints, 0, sizeof(hints)); | |
161 | hints.ai_flags = AI_NUMERICHOST; | |
162 | if (getaddrinfo(buf, NULL, &hints, &ai)) | |
163 | return -1; | |
164 | memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen)); | |
165 | freeaddrinfo(ai); | |
166 | return 0; | |
167 | } | |
168 | ||
44b70ce5 | 169 | #if CONFIG_RTPDEC |
003eb642 MS |
170 | static void init_rtp_handler(RTPDynamicProtocolHandler *handler, |
171 | RTSPStream *rtsp_st, AVCodecContext *codec) | |
172 | { | |
173 | if (!handler) | |
174 | return; | |
175 | codec->codec_id = handler->codec_id; | |
176 | rtsp_st->dynamic_handler = handler; | |
4b3dc857 | 177 | if (handler->alloc) { |
9261e6cf | 178 | rtsp_st->dynamic_protocol_context = handler->alloc(); |
4b3dc857 MS |
179 | if (!rtsp_st->dynamic_protocol_context) |
180 | rtsp_st->dynamic_handler = NULL; | |
181 | } | |
003eb642 MS |
182 | } |
183 | ||
c8965800 | 184 | /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */ |
8f3c87f3 | 185 | static int sdp_parse_rtpmap(AVFormatContext *s, |
86b6e387 | 186 | AVStream *st, RTSPStream *rtsp_st, |
c8965800 | 187 | int payload_type, const char *p) |
93ced3e8 | 188 | { |
86b6e387 | 189 | AVCodecContext *codec = st->codec; |
93ced3e8 | 190 | char buf[256]; |
d1ccf0e0 RD |
191 | int i; |
192 | AVCodec *c; | |
7b49ce2e | 193 | const char *c_name; |
93ced3e8 | 194 | |
d1ccf0e0 | 195 | /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and |
9d50d396 RB |
196 | * see if we can handle this kind of payload. |
197 | * The space should normally not be there but some Real streams or | |
198 | * particular servers ("RealServer Version 6.1.3.970", see issue 1658) | |
199 | * have a trailing space. */ | |
200 | get_word_sep(buf, sizeof(buf), "/ ", &p); | |
d1ccf0e0 | 201 | if (payload_type >= RTP_PT_PRIVATE) { |
003eb642 MS |
202 | RTPDynamicProtocolHandler *handler = |
203 | ff_rtp_handler_find_by_name(buf, codec->codec_type); | |
204 | init_rtp_handler(handler, rtsp_st, codec); | |
160918d5 MS |
205 | /* If no dynamic handler was found, check with the list of standard |
206 | * allocated types, if such a stream for some reason happens to | |
207 | * use a private payload type. This isn't handled in rtpdec.c, since | |
208 | * the format name from the rtpmap line never is passed into rtpdec. */ | |
209 | if (!rtsp_st->dynamic_handler) | |
210 | codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type); | |
93ced3e8 | 211 | } else { |
c8965800 RB |
212 | /* We are in a standard case |
213 | * (from http://www.iana.org/assignments/rtp-parameters). */ | |
d1ccf0e0 | 214 | /* search into AVRtpPayloadTypes[] */ |
7ed19d7f | 215 | codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type); |
d1ccf0e0 RD |
216 | } |
217 | ||
218 | c = avcodec_find_decoder(codec->codec_id); | |
219 | if (c && c->name) | |
7b49ce2e | 220 | c_name = c->name; |
d1ccf0e0 | 221 | else |
170870b7 | 222 | c_name = "(null)"; |
d1ccf0e0 | 223 | |
7515ed0c RB |
224 | get_word_sep(buf, sizeof(buf), "/", &p); |
225 | i = atoi(buf); | |
226 | switch (codec->codec_type) { | |
72415b2a | 227 | case AVMEDIA_TYPE_AUDIO: |
7515ed0c RB |
228 | av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name); |
229 | codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE; | |
230 | codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS; | |
231 | if (i > 0) { | |
232 | codec->sample_rate = i; | |
c3f9ebf7 | 233 | avpriv_set_pts_info(st, 32, 1, codec->sample_rate); |
7515ed0c RB |
234 | get_word_sep(buf, sizeof(buf), "/", &p); |
235 | i = atoi(buf); | |
236 | if (i > 0) | |
237 | codec->channels = i; | |
238 | // TODO: there is a bug here; if it is a mono stream, and | |
239 | // less than 22000Hz, faad upconverts to stereo and twice | |
240 | // the frequency. No problem, but the sample rate is being | |
241 | // set here by the sdp line. Patch on its way. (rdm) | |
d1ccf0e0 | 242 | } |
7515ed0c RB |
243 | av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n", |
244 | codec->sample_rate); | |
245 | av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n", | |
246 | codec->channels); | |
247 | break; | |
72415b2a | 248 | case AVMEDIA_TYPE_VIDEO: |
7515ed0c | 249 | av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name); |
86b6e387 | 250 | if (i > 0) |
c3f9ebf7 | 251 | avpriv_set_pts_info(st, 32, 1, i); |
7515ed0c RB |
252 | break; |
253 | default: | |
254 | break; | |
255 | } | |
25836606 MS |
256 | if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init) |
257 | rtsp_st->dynamic_handler->init(s, st->index, | |
258 | rtsp_st->dynamic_protocol_context); | |
7515ed0c | 259 | return 0; |
93ced3e8 FB |
260 | } |
261 | ||
c2bfd816 | 262 | /* parse the attribute line from the fmtp a line of an sdp response. This |
c8965800 RB |
263 | * is broken out as a function because it is used in rtp_h264.c, which is |
264 | * forthcoming. */ | |
3307e6ea | 265 | int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, |
93993933 | 266 | char *value, int value_size) |
d0deedcb | 267 | { |
30619e6e | 268 | *p += strspn(*p, SPACE_CHARS); |
c8965800 | 269 | if (**p) { |
d0deedcb RM |
270 | get_word_sep(attr, attr_size, "=", p); |
271 | if (**p == '=') | |
272 | (*p)++; | |
273 | get_word_sep(value, value_size, ";", p); | |
274 | if (**p == ';') | |
275 | (*p)++; | |
276 | return 1; | |
277 | } | |
278 | return 0; | |
279 | } | |
280 | ||
93ced3e8 FB |
281 | typedef struct SDPParseState { |
282 | /* SDP only */ | |
3fbd12d1 | 283 | struct sockaddr_storage default_ip; |
c8965800 RB |
284 | int default_ttl; |
285 | int skip_media; ///< set if an unknown m= line occurs | |
93ced3e8 FB |
286 | } SDPParseState; |
287 | ||
288 | static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1, | |
1617ad97 FB |
289 | int letter, const char *buf) |
290 | { | |
8b1ab7bf | 291 | RTSPState *rt = s->priv_data; |
1617ad97 FB |
292 | char buf1[64], st_type[64]; |
293 | const char *p; | |
72415b2a | 294 | enum AVMediaType codec_type; |
fb65d2ca | 295 | int payload_type, i; |
1617ad97 FB |
296 | AVStream *st; |
297 | RTSPStream *rtsp_st; | |
3fbd12d1 | 298 | struct sockaddr_storage sdp_ip; |
93ced3e8 FB |
299 | int ttl; |
300 | ||
dfd2a005 | 301 | av_dlog(s, "sdp: %c='%s'\n", letter, buf); |
1617ad97 FB |
302 | |
303 | p = buf; | |
cb760a47 RB |
304 | if (s1->skip_media && letter != 'm') |
305 | return; | |
c8965800 | 306 | switch (letter) { |
93ced3e8 FB |
307 | case 'c': |
308 | get_word(buf1, sizeof(buf1), &p); | |
309 | if (strcmp(buf1, "IN") != 0) | |
310 | return; | |
311 | get_word(buf1, sizeof(buf1), &p); | |
3fbd12d1 | 312 | if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6")) |
93ced3e8 FB |
313 | return; |
314 | get_word_sep(buf1, sizeof(buf1), "/", &p); | |
3fbd12d1 | 315 | if (get_sockaddr(buf1, &sdp_ip)) |
93ced3e8 FB |
316 | return; |
317 | ttl = 16; | |
318 | if (*p == '/') { | |
319 | p++; | |
320 | get_word_sep(buf1, sizeof(buf1), "/", &p); | |
321 | ttl = atoi(buf1); | |
322 | } | |
323 | if (s->nb_streams == 0) { | |
324 | s1->default_ip = sdp_ip; | |
325 | s1->default_ttl = ttl; | |
326 | } else { | |
d9c0510e | 327 | rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1]; |
93ced3e8 FB |
328 | rtsp_st->sdp_ip = sdp_ip; |
329 | rtsp_st->sdp_ttl = ttl; | |
330 | } | |
331 | break; | |
1617ad97 | 332 | case 's': |
d2d67e42 | 333 | av_dict_set(&s->metadata, "title", p, 0); |
1617ad97 FB |
334 | break; |
335 | case 'i': | |
336 | if (s->nb_streams == 0) { | |
d2d67e42 | 337 | av_dict_set(&s->metadata, "comment", p, 0); |
1617ad97 FB |
338 | break; |
339 | } | |
340 | break; | |
341 | case 'm': | |
342 | /* new stream */ | |
cb760a47 | 343 | s1->skip_media = 0; |
f011fcd6 | 344 | codec_type = AVMEDIA_TYPE_UNKNOWN; |
1617ad97 FB |
345 | get_word(st_type, sizeof(st_type), &p); |
346 | if (!strcmp(st_type, "audio")) { | |
72415b2a | 347 | codec_type = AVMEDIA_TYPE_AUDIO; |
1617ad97 | 348 | } else if (!strcmp(st_type, "video")) { |
72415b2a | 349 | codec_type = AVMEDIA_TYPE_VIDEO; |
090438cc | 350 | } else if (!strcmp(st_type, "application")) { |
72415b2a | 351 | codec_type = AVMEDIA_TYPE_DATA; |
f011fcd6 JB |
352 | } |
353 | if (codec_type == AVMEDIA_TYPE_UNKNOWN || !(rt->media_type_mask & (1 << codec_type))) { | |
cb760a47 | 354 | s1->skip_media = 1; |
1617ad97 FB |
355 | return; |
356 | } | |
1617ad97 FB |
357 | rtsp_st = av_mallocz(sizeof(RTSPStream)); |
358 | if (!rtsp_st) | |
359 | return; | |
8b1ab7bf FB |
360 | rtsp_st->stream_index = -1; |
361 | dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st); | |
93ced3e8 FB |
362 | |
363 | rtsp_st->sdp_ip = s1->default_ip; | |
364 | rtsp_st->sdp_ttl = s1->default_ttl; | |
365 | ||
93ced3e8 FB |
366 | get_word(buf1, sizeof(buf1), &p); /* port */ |
367 | rtsp_st->sdp_port = atoi(buf1); | |
368 | ||
369 | get_word(buf1, sizeof(buf1), &p); /* protocol (ignored) */ | |
115329f1 | 370 | |
93ced3e8 FB |
371 | /* XXX: handle list of formats */ |
372 | get_word(buf1, sizeof(buf1), &p); /* format list */ | |
373 | rtsp_st->sdp_payload_type = atoi(buf1); | |
93ced3e8 | 374 | |
7ed19d7f | 375 | if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) { |
8b1ab7bf FB |
376 | /* no corresponding stream */ |
377 | } else { | |
84ad31ff | 378 | st = avformat_new_stream(s, NULL); |
8b1ab7bf FB |
379 | if (!st) |
380 | return; | |
84ad31ff | 381 | st->id = rt->nb_rtsp_streams - 1; |
8b1ab7bf | 382 | rtsp_st->stream_index = st->index; |
01f4895c | 383 | st->codec->codec_type = codec_type; |
d1ccf0e0 | 384 | if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) { |
6a7e31a9 | 385 | RTPDynamicProtocolHandler *handler; |
8b1ab7bf | 386 | /* if standard payload type, we can find the codec right now */ |
bf6d9818 | 387 | ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type); |
bbd8f547 MS |
388 | if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && |
389 | st->codec->sample_rate > 0) | |
c3f9ebf7 | 390 | avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate); |
6a7e31a9 MS |
391 | /* Even static payload types may need a custom depacketizer */ |
392 | handler = ff_rtp_handler_find_by_id( | |
393 | rtsp_st->sdp_payload_type, st->codec->codec_type); | |
394 | init_rtp_handler(handler, rtsp_st, st->codec); | |
25836606 MS |
395 | if (handler && handler->init) |
396 | handler->init(s, st->index, | |
397 | rtsp_st->dynamic_protocol_context); | |
8b1ab7bf FB |
398 | } |
399 | } | |
1617ad97 | 400 | /* put a default control url */ |
00eb13e0 | 401 | av_strlcpy(rtsp_st->control_url, rt->control_uri, |
c8965800 | 402 | sizeof(rtsp_st->control_url)); |
1617ad97 FB |
403 | break; |
404 | case 'a': | |
00eb13e0 AS |
405 | if (av_strstart(p, "control:", &p)) { |
406 | if (s->nb_streams == 0) { | |
407 | if (!strncmp(p, "rtsp://", 7)) | |
408 | av_strlcpy(rt->control_uri, p, | |
409 | sizeof(rt->control_uri)); | |
410 | } else { | |
0b6a7ff4 MS |
411 | char proto[32]; |
412 | /* get the control url */ | |
d9c0510e | 413 | rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1]; |
115329f1 | 414 | |
0b6a7ff4 MS |
415 | /* XXX: may need to add full url resolution */ |
416 | av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0, | |
417 | NULL, NULL, 0, p); | |
418 | if (proto[0] == '\0') { | |
419 | /* relative control URL */ | |
420 | if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/') | |
421 | av_strlcat(rtsp_st->control_url, "/", | |
422 | sizeof(rtsp_st->control_url)); | |
423 | av_strlcat(rtsp_st->control_url, p, | |
424 | sizeof(rtsp_st->control_url)); | |
425 | } else | |
426 | av_strlcpy(rtsp_st->control_url, p, | |
427 | sizeof(rtsp_st->control_url)); | |
00eb13e0 | 428 | } |
83d14c85 | 429 | } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) { |
93ced3e8 | 430 | /* NOTE: rtpmap is only supported AFTER the 'm=' tag */ |
115329f1 | 431 | get_word(buf1, sizeof(buf1), &p); |
93ced3e8 | 432 | payload_type = atoi(buf1); |
83d14c85 | 433 | st = s->streams[s->nb_streams - 1]; |
d9c0510e | 434 | rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1]; |
86b6e387 | 435 | sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p); |
7fc8ac7f JA |
436 | } else if (av_strstart(p, "fmtp:", &p) || |
437 | av_strstart(p, "framesize:", &p)) { | |
93ced3e8 | 438 | /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */ |
d0deedcb RM |
439 | // let dynamic protocol handlers have a stab at the line. |
440 | get_word(buf1, sizeof(buf1), &p); | |
441 | payload_type = atoi(buf1); | |
d9c0510e MS |
442 | for (i = 0; i < rt->nb_rtsp_streams; i++) { |
443 | rtsp_st = rt->rtsp_streams[i]; | |
c8965800 RB |
444 | if (rtsp_st->sdp_payload_type == payload_type && |
445 | rtsp_st->dynamic_handler && | |
446 | rtsp_st->dynamic_handler->parse_sdp_a_line) | |
447 | rtsp_st->dynamic_handler->parse_sdp_a_line(s, i, | |
448 | rtsp_st->dynamic_protocol_context, buf); | |
d0deedcb | 449 | } |
c8965800 | 450 | } else if (av_strstart(p, "range:", &p)) { |
31693e00 RM |
451 | int64_t start, end; |
452 | ||
453 | // this is so that seeking on a streamed file can work. | |
454 | rtsp_parse_range_npt(p, &start, &end); | |
c8965800 RB |
455 | s->start_time = start; |
456 | /* AV_NOPTS_VALUE means live broadcast (and can't seek) */ | |
457 | s->duration = (end == AV_NOPTS_VALUE) ? | |
458 | AV_NOPTS_VALUE : end - start; | |
119b4668 RB |
459 | } else if (av_strstart(p, "IsRealDataType:integer;",&p)) { |
460 | if (atoi(p) == 1) | |
461 | rt->transport = RTSP_TRANSPORT_RDT; | |
bb776f3b MS |
462 | } else if (av_strstart(p, "SampleRate:integer;", &p) && |
463 | s->nb_streams > 0) { | |
464 | st = s->streams[s->nb_streams - 1]; | |
465 | st->codec->sample_rate = atoi(p); | |
1a30d541 RB |
466 | } else { |
467 | if (rt->server_type == RTSP_SERVER_WMS) | |
468 | ff_wms_parse_sdp_a_line(s, p); | |
469 | if (s->nb_streams > 0) { | |
c4a3d032 RB |
470 | if (rt->server_type == RTSP_SERVER_REAL) |
471 | ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p); | |
472 | ||
d9c0510e | 473 | rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1]; |
c4a3d032 RB |
474 | if (rtsp_st->dynamic_handler && |
475 | rtsp_st->dynamic_handler->parse_sdp_a_line) | |
c8965800 RB |
476 | rtsp_st->dynamic_handler->parse_sdp_a_line(s, |
477 | s->nb_streams - 1, | |
c4a3d032 | 478 | rtsp_st->dynamic_protocol_context, buf); |
1a30d541 | 479 | } |
1617ad97 FB |
480 | } |
481 | break; | |
482 | } | |
483 | } | |
484 | ||
0526c6f7 | 485 | int ff_sdp_parse(AVFormatContext *s, const char *content) |
1617ad97 | 486 | { |
a8475bbd | 487 | RTSPState *rt = s->priv_data; |
1617ad97 FB |
488 | const char *p; |
489 | int letter; | |
9211bcdd RB |
490 | /* Some SDP lines, particularly for Realmedia or ASF RTSP streams, |
491 | * contain long SDP lines containing complete ASF Headers (several | |
492 | * kB) or arrays of MDPR (RM stream descriptor) headers plus | |
493 | * "rulebooks" describing their properties. Therefore, the SDP line | |
373afbaf RB |
494 | * buffer is large. |
495 | * | |
afcea58c JA |
496 | * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line |
497 | * in rtpdec_xiph.c. */ | |
373afbaf | 498 | char buf[16384], *q; |
93ced3e8 | 499 | SDPParseState sdp_parse_state, *s1 = &sdp_parse_state; |
115329f1 | 500 | |
93ced3e8 | 501 | memset(s1, 0, sizeof(SDPParseState)); |
1617ad97 | 502 | p = content; |
c8965800 | 503 | for (;;) { |
30619e6e | 504 | p += strspn(p, SPACE_CHARS); |
1617ad97 FB |
505 | letter = *p; |
506 | if (letter == '\0') | |
507 | break; | |
508 | p++; | |
509 | if (*p != '=') | |
510 | goto next_line; | |
511 | p++; | |
512 | /* get the content */ | |
513 | q = buf; | |
b6892136 | 514 | while (*p != '\n' && *p != '\r' && *p != '\0') { |
1617ad97 FB |
515 | if ((q - buf) < sizeof(buf) - 1) |
516 | *q++ = *p; | |
517 | p++; | |
518 | } | |
519 | *q = '\0'; | |
93ced3e8 | 520 | sdp_parse_line(s, s1, letter, buf); |
1617ad97 FB |
521 | next_line: |
522 | while (*p != '\n' && *p != '\0') | |
523 | p++; | |
524 | if (*p == '\n') | |
525 | p++; | |
526 | } | |
a8475bbd LB |
527 | rt->p = av_malloc(sizeof(struct pollfd)*2*(rt->nb_rtsp_streams+1)); |
528 | if (!rt->p) return AVERROR(ENOMEM); | |
1617ad97 FB |
529 | return 0; |
530 | } | |
44b70ce5 | 531 | #endif /* CONFIG_RTPDEC */ |
1617ad97 | 532 | |
93e7490e MS |
533 | void ff_rtsp_undo_setup(AVFormatContext *s) |
534 | { | |
535 | RTSPState *rt = s->priv_data; | |
536 | int i; | |
537 | ||
538 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
539 | RTSPStream *rtsp_st = rt->rtsp_streams[i]; | |
540 | if (!rtsp_st) | |
541 | continue; | |
542 | if (rtsp_st->transport_priv) { | |
543 | if (s->oformat) { | |
544 | AVFormatContext *rtpctx = rtsp_st->transport_priv; | |
545 | av_write_trailer(rtpctx); | |
546 | if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) { | |
547 | uint8_t *ptr; | |
6dc7d80d | 548 | avio_close_dyn_buf(rtpctx->pb, &ptr); |
93e7490e MS |
549 | av_free(ptr); |
550 | } else { | |
22a3212e | 551 | avio_close(rtpctx->pb); |
93e7490e | 552 | } |
b22dbb29 | 553 | avformat_free_context(rtpctx); |
93e7490e MS |
554 | } else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC) |
555 | ff_rdt_parse_close(rtsp_st->transport_priv); | |
556 | else if (CONFIG_RTPDEC) | |
bfc6db44 | 557 | ff_rtp_parse_close(rtsp_st->transport_priv); |
93e7490e MS |
558 | } |
559 | rtsp_st->transport_priv = NULL; | |
560 | if (rtsp_st->rtp_handle) | |
e52a9145 | 561 | ffurl_close(rtsp_st->rtp_handle); |
93e7490e MS |
562 | rtsp_st->rtp_handle = NULL; |
563 | } | |
564 | } | |
565 | ||
1ced9da3 | 566 | /* close and free RTSP streams */ |
3307e6ea | 567 | void ff_rtsp_close_streams(AVFormatContext *s) |
1ced9da3 | 568 | { |
52aa4338 | 569 | RTSPState *rt = s->priv_data; |
1ced9da3 LA |
570 | int i; |
571 | RTSPStream *rtsp_st; | |
572 | ||
93e7490e | 573 | ff_rtsp_undo_setup(s); |
c8965800 | 574 | for (i = 0; i < rt->nb_rtsp_streams; i++) { |
1ced9da3 LA |
575 | rtsp_st = rt->rtsp_streams[i]; |
576 | if (rtsp_st) { | |
1ced9da3 | 577 | if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) |
9261e6cf | 578 | rtsp_st->dynamic_handler->free( |
c8965800 | 579 | rtsp_st->dynamic_protocol_context); |
ea7f0807 | 580 | av_free(rtsp_st); |
1ced9da3 LA |
581 | } |
582 | } | |
583 | av_free(rt->rtsp_streams); | |
584 | if (rt->asf_ctx) { | |
cd3716b9 | 585 | avformat_close_input(&rt->asf_ctx); |
1ced9da3 | 586 | } |
a8475bbd | 587 | av_free(rt->p); |
96a7c975 | 588 | av_free(rt->recvbuf); |
1ced9da3 LA |
589 | } |
590 | ||
c8965800 | 591 | static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st) |
1ced9da3 LA |
592 | { |
593 | RTSPState *rt = s->priv_data; | |
594 | AVStream *st = NULL; | |
595 | ||
596 | /* open the RTP context */ | |
597 | if (rtsp_st->stream_index >= 0) | |
598 | st = s->streams[rtsp_st->stream_index]; | |
599 | if (!st) | |
600 | s->ctx_flags |= AVFMTCTX_NOHEADER; | |
601 | ||
44b70ce5 | 602 | if (s->oformat && CONFIG_RTSP_MUXER) { |
a493f80a MS |
603 | rtsp_st->transport_priv = ff_rtp_chain_mux_open(s, st, |
604 | rtsp_st->rtp_handle, | |
605 | RTSP_TCP_MAX_PACKET_SIZE); | |
c2bfd816 | 606 | /* Ownership of rtp_handle is passed to the rtp mux context */ |
fd450a51 | 607 | rtsp_st->rtp_handle = NULL; |
44b70ce5 | 608 | } else if (rt->transport == RTSP_TRANSPORT_RDT && CONFIG_RTPDEC) |
1ced9da3 LA |
609 | rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index, |
610 | rtsp_st->dynamic_protocol_context, | |
611 | rtsp_st->dynamic_handler); | |
44b70ce5 | 612 | else if (CONFIG_RTPDEC) |
bfc6db44 | 613 | rtsp_st->transport_priv = ff_rtp_parse_open(s, st, rtsp_st->rtp_handle, |
58ee0991 MS |
614 | rtsp_st->sdp_payload_type, |
615 | (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay) | |
616 | ? 0 : RTP_REORDER_QUEUE_DEFAULT_SIZE); | |
1ced9da3 LA |
617 | |
618 | if (!rtsp_st->transport_priv) { | |
619 | return AVERROR(ENOMEM); | |
44b70ce5 | 620 | } else if (rt->transport != RTSP_TRANSPORT_RDT && CONFIG_RTPDEC) { |
c8965800 | 621 | if (rtsp_st->dynamic_handler) { |
bfc6db44 MS |
622 | ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv, |
623 | rtsp_st->dynamic_protocol_context, | |
624 | rtsp_st->dynamic_handler); | |
1ced9da3 LA |
625 | } |
626 | } | |
627 | ||
628 | return 0; | |
629 | } | |
630 | ||
6f5a3d0a | 631 | #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER |
1617ad97 FB |
632 | static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp) |
633 | { | |
634 | const char *p; | |
635 | int v; | |
636 | ||
637 | p = *pp; | |
30619e6e | 638 | p += strspn(p, SPACE_CHARS); |
1617ad97 FB |
639 | v = strtol(p, (char **)&p, 10); |
640 | if (*p == '-') { | |
641 | p++; | |
642 | *min_ptr = v; | |
643 | v = strtol(p, (char **)&p, 10); | |
644 | *max_ptr = v; | |
645 | } else { | |
646 | *min_ptr = v; | |
647 | *max_ptr = v; | |
648 | } | |
649 | *pp = p; | |
650 | } | |
651 | ||
652 | /* XXX: only one transport specification is parsed */ | |
a9e534d5 | 653 | static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p) |
1617ad97 FB |
654 | { |
655 | char transport_protocol[16]; | |
656 | char profile[16]; | |
657 | char lower_transport[16]; | |
658 | char parameter[16]; | |
659 | RTSPTransportField *th; | |
660 | char buf[256]; | |
115329f1 | 661 | |
1617ad97 | 662 | reply->nb_transports = 0; |
115329f1 | 663 | |
c8965800 | 664 | for (;;) { |
30619e6e | 665 | p += strspn(p, SPACE_CHARS); |
1617ad97 FB |
666 | if (*p == '\0') |
667 | break; | |
668 | ||
669 | th = &reply->transports[reply->nb_transports]; | |
670 | ||
115329f1 | 671 | get_word_sep(transport_protocol, sizeof(transport_protocol), |
1617ad97 | 672 | "/", &p); |
bb3244de | 673 | if (!av_strcasecmp (transport_protocol, "rtp")) { |
7ecc634e LB |
674 | get_word_sep(profile, sizeof(profile), "/;,", &p); |
675 | lower_transport[0] = '\0'; | |
676 | /* rtp/avp/<protocol> */ | |
677 | if (*p == '/') { | |
7ecc634e LB |
678 | get_word_sep(lower_transport, sizeof(lower_transport), |
679 | ";,", &p); | |
119b4668 RB |
680 | } |
681 | th->transport = RTSP_TRANSPORT_RTP; | |
bb3244de RD |
682 | } else if (!av_strcasecmp (transport_protocol, "x-pn-tng") || |
683 | !av_strcasecmp (transport_protocol, "x-real-rdt")) { | |
7ecc634e | 684 | /* x-pn-tng/<protocol> */ |
e1502118 LB |
685 | get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p); |
686 | profile[0] = '\0'; | |
119b4668 | 687 | th->transport = RTSP_TRANSPORT_RDT; |
1617ad97 | 688 | } |
bb3244de | 689 | if (!av_strcasecmp(lower_transport, "TCP")) |
90abbdba | 690 | th->lower_transport = RTSP_LOWER_TRANSPORT_TCP; |
1617ad97 | 691 | else |
90abbdba | 692 | th->lower_transport = RTSP_LOWER_TRANSPORT_UDP; |
115329f1 | 693 | |
1617ad97 FB |
694 | if (*p == ';') |
695 | p++; | |
696 | /* get each parameter */ | |
697 | while (*p != '\0' && *p != ',') { | |
698 | get_word_sep(parameter, sizeof(parameter), "=;,", &p); | |
699 | if (!strcmp(parameter, "port")) { | |
700 | if (*p == '=') { | |
701 | p++; | |
702 | rtsp_parse_range(&th->port_min, &th->port_max, &p); | |
703 | } | |
704 | } else if (!strcmp(parameter, "client_port")) { | |
705 | if (*p == '=') { | |
706 | p++; | |
115329f1 | 707 | rtsp_parse_range(&th->client_port_min, |
1617ad97 FB |
708 | &th->client_port_max, &p); |
709 | } | |
710 | } else if (!strcmp(parameter, "server_port")) { | |
711 | if (*p == '=') { | |
712 | p++; | |
115329f1 | 713 | rtsp_parse_range(&th->server_port_min, |
1617ad97 FB |
714 | &th->server_port_max, &p); |
715 | } | |
716 | } else if (!strcmp(parameter, "interleaved")) { | |
717 | if (*p == '=') { | |
718 | p++; | |
115329f1 | 719 | rtsp_parse_range(&th->interleaved_min, |
1617ad97 FB |
720 | &th->interleaved_max, &p); |
721 | } | |
722 | } else if (!strcmp(parameter, "multicast")) { | |
90abbdba RB |
723 | if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP) |
724 | th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST; | |
1617ad97 FB |
725 | } else if (!strcmp(parameter, "ttl")) { |
726 | if (*p == '=') { | |
727 | p++; | |
728 | th->ttl = strtol(p, (char **)&p, 10); | |
729 | } | |
730 | } else if (!strcmp(parameter, "destination")) { | |
1617ad97 FB |
731 | if (*p == '=') { |
732 | p++; | |
733 | get_word_sep(buf, sizeof(buf), ";,", &p); | |
7934b15d | 734 | get_sockaddr(buf, &th->destination); |
1617ad97 | 735 | } |
619298a8 JW |
736 | } else if (!strcmp(parameter, "source")) { |
737 | if (*p == '=') { | |
738 | p++; | |
739 | get_word_sep(buf, sizeof(buf), ";,", &p); | |
740 | av_strlcpy(th->source, buf, sizeof(th->source)); | |
741 | } | |
1617ad97 | 742 | } |
619298a8 | 743 | |
1617ad97 FB |
744 | while (*p != ';' && *p != '\0' && *p != ',') |
745 | p++; | |
746 | if (*p == ';') | |
747 | p++; | |
748 | } | |
749 | if (*p == ',') | |
750 | p++; | |
751 | ||
752 | reply->nb_transports++; | |
753 | } | |
754 | } | |
755 | ||
29db7c3a MS |
756 | static void handle_rtp_info(RTSPState *rt, const char *url, |
757 | uint32_t seq, uint32_t rtptime) | |
758 | { | |
759 | int i; | |
760 | if (!rtptime || !url[0]) | |
761 | return; | |
762 | if (rt->transport != RTSP_TRANSPORT_RTP) | |
763 | return; | |
764 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
765 | RTSPStream *rtsp_st = rt->rtsp_streams[i]; | |
766 | RTPDemuxContext *rtpctx = rtsp_st->transport_priv; | |
767 | if (!rtpctx) | |
768 | continue; | |
769 | if (!strcmp(rtsp_st->control_url, url)) { | |
770 | rtpctx->base_timestamp = rtptime; | |
771 | break; | |
772 | } | |
773 | } | |
774 | } | |
775 | ||
776 | static void rtsp_parse_rtp_info(RTSPState *rt, const char *p) | |
777 | { | |
778 | int read = 0; | |
779 | char key[20], value[1024], url[1024] = ""; | |
780 | uint32_t seq = 0, rtptime = 0; | |
781 | ||
782 | for (;;) { | |
783 | p += strspn(p, SPACE_CHARS); | |
784 | if (!*p) | |
785 | break; | |
786 | get_word_sep(key, sizeof(key), "=", &p); | |
787 | if (*p != '=') | |
788 | break; | |
789 | p++; | |
790 | get_word_sep(value, sizeof(value), ";, ", &p); | |
791 | read++; | |
792 | if (!strcmp(key, "url")) | |
793 | av_strlcpy(url, value, sizeof(url)); | |
794 | else if (!strcmp(key, "seq")) | |
4515f9b5 | 795 | seq = strtoul(value, NULL, 10); |
29db7c3a | 796 | else if (!strcmp(key, "rtptime")) |
4515f9b5 | 797 | rtptime = strtoul(value, NULL, 10); |
29db7c3a MS |
798 | if (*p == ',') { |
799 | handle_rtp_info(rt, url, seq, rtptime); | |
800 | url[0] = '\0'; | |
801 | seq = rtptime = 0; | |
802 | read = 0; | |
803 | } | |
804 | if (*p) | |
805 | p++; | |
806 | } | |
807 | if (read > 0) | |
808 | handle_rtp_info(rt, url, seq, rtptime); | |
809 | } | |
810 | ||
2626308a | 811 | void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf, |
77223c53 | 812 | RTSPState *rt, const char *method) |
1617ad97 FB |
813 | { |
814 | const char *p; | |
815 | ||
816 | /* NOTE: we do case independent match for broken servers */ | |
817 | p = buf; | |
f7d78f36 | 818 | if (av_stristart(p, "Session:", &p)) { |
30e79845 | 819 | int t; |
1617ad97 | 820 | get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p); |
30e79845 RB |
821 | if (av_stristart(p, ";timeout=", &p) && |
822 | (t = strtol(p, NULL, 10)) > 0) { | |
823 | reply->timeout = t; | |
824 | } | |
f7d78f36 | 825 | } else if (av_stristart(p, "Content-Length:", &p)) { |
1617ad97 | 826 | reply->content_length = strtol(p, NULL, 10); |
f7d78f36 | 827 | } else if (av_stristart(p, "Transport:", &p)) { |
1617ad97 | 828 | rtsp_parse_transport(reply, p); |
f7d78f36 | 829 | } else if (av_stristart(p, "CSeq:", &p)) { |
1617ad97 | 830 | reply->seq = strtol(p, NULL, 10); |
f7d78f36 | 831 | } else if (av_stristart(p, "Range:", &p)) { |
31693e00 | 832 | rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end); |
30aa6aed | 833 | } else if (av_stristart(p, "RealChallenge1:", &p)) { |
30619e6e | 834 | p += strspn(p, SPACE_CHARS); |
30aa6aed | 835 | av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge)); |
7a86bafa | 836 | } else if (av_stristart(p, "Server:", &p)) { |
30619e6e | 837 | p += strspn(p, SPACE_CHARS); |
7a86bafa | 838 | av_strlcpy(reply->server, p, sizeof(reply->server)); |
fccb1770 RB |
839 | } else if (av_stristart(p, "Notice:", &p) || |
840 | av_stristart(p, "X-Notice:", &p)) { | |
841 | reply->notice = strtol(p, NULL, 10); | |
d243ba30 | 842 | } else if (av_stristart(p, "Location:", &p)) { |
30619e6e | 843 | p += strspn(p, SPACE_CHARS); |
d243ba30 | 844 | av_strlcpy(reply->location, p , sizeof(reply->location)); |
acc9ed14 | 845 | } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) { |
30619e6e | 846 | p += strspn(p, SPACE_CHARS); |
acc9ed14 MS |
847 | ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p); |
848 | } else if (av_stristart(p, "Authentication-Info:", &p) && rt) { | |
30619e6e | 849 | p += strspn(p, SPACE_CHARS); |
acc9ed14 | 850 | ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p); |
d2995eb9 | 851 | } else if (av_stristart(p, "Content-Base:", &p) && rt) { |
dd22cfb1 | 852 | p += strspn(p, SPACE_CHARS); |
d2995eb9 MS |
853 | if (method && !strcmp(method, "DESCRIBE")) |
854 | av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri)); | |
29db7c3a MS |
855 | } else if (av_stristart(p, "RTP-Info:", &p) && rt) { |
856 | p += strspn(p, SPACE_CHARS); | |
857 | if (method && !strcmp(method, "PLAY")) | |
858 | rtsp_parse_rtp_info(rt, p); | |
0b4949b5 MS |
859 | } else if (av_stristart(p, "Public:", &p) && rt) { |
860 | if (strstr(p, "GET_PARAMETER") && | |
861 | method && !strcmp(method, "OPTIONS")) | |
862 | rt->get_parameter_supported = 1; | |
30eae325 MS |
863 | } else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) { |
864 | p += strspn(p, SPACE_CHARS); | |
865 | rt->accept_dynamic_rate = atoi(p); | |
1617ad97 FB |
866 | } |
867 | } | |
868 | ||
b7b8fc34 | 869 | /* skip a RTP/TCP interleaved packet */ |
ec55edba | 870 | void ff_rtsp_skip_packet(AVFormatContext *s) |
b7b8fc34 FB |
871 | { |
872 | RTSPState *rt = s->priv_data; | |
873 | int ret, len, len1; | |
874 | uint8_t buf[1024]; | |
875 | ||
dce37564 | 876 | ret = ffurl_read_complete(rt->rtsp_hd, buf, 3); |
b7b8fc34 FB |
877 | if (ret != 3) |
878 | return; | |
80fb8234 | 879 | len = AV_RB16(buf + 1); |
67c9cd69 | 880 | |
dfd2a005 | 881 | av_dlog(s, "skipping RTP packet len=%d\n", len); |
67c9cd69 | 882 | |
b7b8fc34 FB |
883 | /* skip payload */ |
884 | while (len > 0) { | |
885 | len1 = len; | |
886 | if (len1 > sizeof(buf)) | |
887 | len1 = sizeof(buf); | |
dce37564 | 888 | ret = ffurl_read_complete(rt->rtsp_hd, buf, len1); |
b7b8fc34 FB |
889 | if (ret != len1) |
890 | return; | |
891 | len -= len1; | |
892 | } | |
893 | } | |
1617ad97 | 894 | |
3307e6ea | 895 | int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply, |
93993933 | 896 | unsigned char **content_ptr, |
3df54c6b | 897 | int return_on_interleaved_data, const char *method) |
1617ad97 FB |
898 | { |
899 | RTSPState *rt = s->priv_data; | |
900 | char buf[4096], buf1[1024], *q; | |
901 | unsigned char ch; | |
902 | const char *p; | |
1a6b9a98 | 903 | int ret, content_length, line_count = 0, request = 0; |
1617ad97 FB |
904 | unsigned char *content = NULL; |
905 | ||
1a6b9a98 TW |
906 | start: |
907 | line_count = 0; | |
908 | request = 0; | |
909 | content = NULL; | |
d541a7d2 | 910 | memset(reply, 0, sizeof(*reply)); |
1617ad97 | 911 | |
1617ad97 | 912 | /* parse reply (XXX: use buffers) */ |
1617ad97 | 913 | rt->last_reply[0] = '\0'; |
c8965800 | 914 | for (;;) { |
1617ad97 | 915 | q = buf; |
c8965800 | 916 | for (;;) { |
dce37564 | 917 | ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1); |
dfd2a005 | 918 | av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch); |
7e726132 | 919 | if (ret != 1) |
2401660d | 920 | return AVERROR_EOF; |
1617ad97 FB |
921 | if (ch == '\n') |
922 | break; | |
b7b8fc34 FB |
923 | if (ch == '$') { |
924 | /* XXX: only parse it if first char on line ? */ | |
7e726132 RB |
925 | if (return_on_interleaved_data) { |
926 | return 1; | |
927 | } else | |
ec55edba | 928 | ff_rtsp_skip_packet(s); |
b7b8fc34 | 929 | } else if (ch != '\r') { |
1617ad97 FB |
930 | if ((q - buf) < sizeof(buf) - 1) |
931 | *q++ = ch; | |
932 | } | |
933 | } | |
934 | *q = '\0'; | |
67c9cd69 | 935 | |
dfd2a005 | 936 | av_dlog(s, "line='%s'\n", buf); |
67c9cd69 | 937 | |
1617ad97 FB |
938 | /* test if last line */ |
939 | if (buf[0] == '\0') | |
940 | break; | |
941 | p = buf; | |
942 | if (line_count == 0) { | |
943 | /* get reply code */ | |
944 | get_word(buf1, sizeof(buf1), &p); | |
1a6b9a98 TW |
945 | if (!strncmp(buf1, "RTSP/", 5)) { |
946 | get_word(buf1, sizeof(buf1), &p); | |
947 | reply->status_code = atoi(buf1); | |
948 | av_strlcpy(reply->reason, p, sizeof(reply->reason)); | |
949 | } else { | |
950 | av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method | |
951 | get_word(buf1, sizeof(buf1), &p); // object | |
952 | request = 1; | |
953 | } | |
1617ad97 | 954 | } else { |
77223c53 | 955 | ff_rtsp_parse_line(reply, p, rt, method); |
75e61b0e MR |
956 | av_strlcat(rt->last_reply, p, sizeof(rt->last_reply)); |
957 | av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply)); | |
1617ad97 FB |
958 | } |
959 | line_count++; | |
960 | } | |
115329f1 | 961 | |
1a6b9a98 | 962 | if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request) |
75e61b0e | 963 | av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id)); |
115329f1 | 964 | |
1617ad97 FB |
965 | content_length = reply->content_length; |
966 | if (content_length > 0) { | |
967 | /* leave some room for a trailing '\0' (useful for simple parsing) */ | |
968 | content = av_malloc(content_length + 1); | |
dce37564 | 969 | ffurl_read_complete(rt->rtsp_hd, content, content_length); |
1617ad97 FB |
970 | content[content_length] = '\0'; |
971 | } | |
972 | if (content_ptr) | |
973 | *content_ptr = content; | |
e2e2e7dd AB |
974 | else |
975 | av_free(content); | |
7e726132 | 976 | |
1a6b9a98 TW |
977 | if (request) { |
978 | char buf[1024]; | |
979 | char base64buf[AV_BASE64_SIZE(sizeof(buf))]; | |
980 | const char* ptr = buf; | |
981 | ||
982 | if (!strcmp(reply->reason, "OPTIONS")) { | |
983 | snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n"); | |
984 | if (reply->seq) | |
985 | av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq); | |
986 | if (reply->session_id[0]) | |
987 | av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", | |
988 | reply->session_id); | |
989 | } else { | |
990 | snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n"); | |
991 | } | |
992 | av_strlcat(buf, "\r\n", sizeof(buf)); | |
993 | ||
994 | if (rt->control_transport == RTSP_MODE_TUNNEL) { | |
995 | av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf)); | |
996 | ptr = base64buf; | |
997 | } | |
998 | ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr)); | |
999 | ||
1000 | rt->last_cmd_time = av_gettime(); | |
1001 | /* Even if the request from the server had data, it is not the data | |
1002 | * that the caller wants or expects. The memory could also be leaked | |
1003 | * if the actual following reply has content data. */ | |
1004 | if (content_ptr) | |
1005 | av_freep(content_ptr); | |
1006 | /* If method is set, this is called from ff_rtsp_send_cmd, | |
1007 | * where a reply to exactly this request is awaited. For | |
705eeb5e | 1008 | * callers from within packet receiving, we just want to |
1a6b9a98 TW |
1009 | * return to the caller and go back to receiving packets. */ |
1010 | if (method) | |
1011 | goto start; | |
1012 | return 0; | |
1013 | } | |
1014 | ||
7ed8211b LB |
1015 | if (rt->seq != reply->seq) { |
1016 | av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n", | |
1017 | rt->seq, reply->seq); | |
1018 | } | |
1019 | ||
fccb1770 RB |
1020 | /* EOS */ |
1021 | if (reply->notice == 2101 /* End-of-Stream Reached */ || | |
1022 | reply->notice == 2104 /* Start-of-Stream Reached */ || | |
c8965800 | 1023 | reply->notice == 2306 /* Continuous Feed Terminated */) { |
fccb1770 | 1024 | rt->state = RTSP_STATE_IDLE; |
c8965800 | 1025 | } else if (reply->notice >= 4400 && reply->notice < 5500) { |
fccb1770 | 1026 | return AVERROR(EIO); /* data or server error */ |
c8965800 | 1027 | } else if (reply->notice == 2401 /* Ticket Expired */ || |
fccb1770 RB |
1028 | (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ ) |
1029 | return AVERROR(EPERM); | |
1030 | ||
7e726132 | 1031 | return 0; |
1617ad97 FB |
1032 | } |
1033 | ||
57c4d01e DEP |
1034 | /** |
1035 | * Send a command to the RTSP server without waiting for the reply. | |
1036 | * | |
1037 | * @param s RTSP (de)muxer context | |
1038 | * @param method the method for the request | |
1039 | * @param url the target url for the request | |
1040 | * @param headers extra header lines to include in the request | |
1041 | * @param send_content if non-null, the data to send as request body content | |
1042 | * @param send_content_length the length of the send_content data, or 0 if | |
1043 | * send_content is null | |
1044 | * | |
1045 | * @return zero if success, nonzero otherwise | |
1046 | */ | |
1047 | static int ff_rtsp_send_cmd_with_content_async(AVFormatContext *s, | |
1048 | const char *method, const char *url, | |
1049 | const char *headers, | |
1050 | const unsigned char *send_content, | |
1051 | int send_content_length) | |
29b9f58b RB |
1052 | { |
1053 | RTSPState *rt = s->priv_data; | |
f5d33f52 JA |
1054 | char buf[4096], *out_buf; |
1055 | char base64buf[AV_BASE64_SIZE(sizeof(buf))]; | |
29b9f58b | 1056 | |
f5d33f52 JA |
1057 | /* Add in RTSP headers */ |
1058 | out_buf = buf; | |
29b9f58b | 1059 | rt->seq++; |
b17d11c6 MS |
1060 | snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url); |
1061 | if (headers) | |
1062 | av_strlcat(buf, headers, sizeof(buf)); | |
7b4a3645 | 1063 | av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq); |
b17d11c6 MS |
1064 | if (rt->session_id[0] != '\0' && (!headers || |
1065 | !strstr(headers, "\nIf-Match:"))) { | |
7b4a3645 | 1066 | av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id); |
29b9f58b | 1067 | } |
aa8bf2fb MS |
1068 | if (rt->auth[0]) { |
1069 | char *str = ff_http_auth_create_response(&rt->auth_state, | |
1070 | rt->auth, url, method); | |
1071 | if (str) | |
1072 | av_strlcat(buf, str, sizeof(buf)); | |
1073 | av_free(str); | |
1074 | } | |
dfd017bf MS |
1075 | if (send_content_length > 0 && send_content) |
1076 | av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length); | |
29b9f58b | 1077 | av_strlcat(buf, "\r\n", sizeof(buf)); |
67c9cd69 | 1078 | |
f5d33f52 JA |
1079 | /* base64 encode rtsp if tunneling */ |
1080 | if (rt->control_transport == RTSP_MODE_TUNNEL) { | |
1081 | av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf)); | |
1082 | out_buf = base64buf; | |
1083 | } | |
1084 | ||
dfd2a005 | 1085 | av_dlog(s, "Sending:\n%s--\n", buf); |
67c9cd69 | 1086 | |
925e908b | 1087 | ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf)); |
f5d33f52 JA |
1088 | if (send_content_length > 0 && send_content) { |
1089 | if (rt->control_transport == RTSP_MODE_TUNNEL) { | |
1090 | av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests " | |
1091 | "with content data not supported\n"); | |
1092 | return AVERROR_PATCHWELCOME; | |
1093 | } | |
925e908b | 1094 | ffurl_write(rt->rtsp_hd_out, send_content, send_content_length); |
f5d33f52 | 1095 | } |
30e79845 | 1096 | rt->last_cmd_time = av_gettime(); |
d0382374 JA |
1097 | |
1098 | return 0; | |
30e79845 RB |
1099 | } |
1100 | ||
d0382374 | 1101 | int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method, |
fc490fcf | 1102 | const char *url, const char *headers) |
dfd017bf | 1103 | { |
d0382374 | 1104 | return ff_rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0); |
dfd017bf MS |
1105 | } |
1106 | ||
d0382374 | 1107 | int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url, |
fc490fcf MS |
1108 | const char *headers, RTSPMessageHeader *reply, |
1109 | unsigned char **content_ptr) | |
30e79845 | 1110 | { |
d0382374 | 1111 | return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply, |
fc490fcf | 1112 | content_ptr, NULL, 0); |
29b9f58b RB |
1113 | } |
1114 | ||
d0382374 | 1115 | int ff_rtsp_send_cmd_with_content(AVFormatContext *s, |
fc490fcf MS |
1116 | const char *method, const char *url, |
1117 | const char *header, | |
1118 | RTSPMessageHeader *reply, | |
1119 | unsigned char **content_ptr, | |
1120 | const unsigned char *send_content, | |
1121 | int send_content_length) | |
dfd017bf | 1122 | { |
30af0779 MS |
1123 | RTSPState *rt = s->priv_data; |
1124 | HTTPAuthType cur_auth_type; | |
2f96cc1f | 1125 | int ret, attempts = 0; |
30af0779 MS |
1126 | |
1127 | retry: | |
1128 | cur_auth_type = rt->auth_state.auth_type; | |
d0382374 | 1129 | if ((ret = ff_rtsp_send_cmd_with_content_async(s, method, url, header, |
fc490fcf MS |
1130 | send_content, |
1131 | send_content_length))) | |
d0382374 | 1132 | return ret; |
dfd017bf | 1133 | |
3df54c6b | 1134 | if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0) |
d0382374 | 1135 | return ret; |
2f96cc1f | 1136 | attempts++; |
30af0779 | 1137 | |
2f96cc1f MS |
1138 | if (reply->status_code == 401 && |
1139 | (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) && | |
1140 | rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2) | |
30af0779 | 1141 | goto retry; |
d0382374 | 1142 | |
bf55cf19 | 1143 | if (reply->status_code > 400){ |
d93fdcbf | 1144 | av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n", |
bf55cf19 | 1145 | method, |
d93fdcbf LB |
1146 | reply->status_code, |
1147 | reply->reason); | |
bf55cf19 LB |
1148 | av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply); |
1149 | } | |
1150 | ||
d0382374 | 1151 | return 0; |
dfd017bf MS |
1152 | } |
1153 | ||
fef5649a | 1154 | int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port, |
c8965800 | 1155 | int lower_transport, const char *real_challenge) |
1617ad97 FB |
1156 | { |
1157 | RTSPState *rt = s->priv_data; | |
58f09785 | 1158 | int rtx = 0, j, i, err, interleave = 0, port_off; |
1617ad97 | 1159 | RTSPStream *rtsp_st; |
a9e534d5 | 1160 | RTSPMessageHeader reply1, *reply = &reply1; |
53620bba | 1161 | char cmd[2048]; |
e9dea59f RB |
1162 | const char *trans_pref; |
1163 | ||
119b4668 | 1164 | if (rt->transport == RTSP_TRANSPORT_RDT) |
e9dea59f RB |
1165 | trans_pref = "x-pn-tng"; |
1166 | else | |
1167 | trans_pref = "RTP/AVP"; | |
115329f1 | 1168 | |
30e79845 RB |
1169 | /* default timeout: 1 minute */ |
1170 | rt->timeout = 60; | |
1171 | ||
1617ad97 FB |
1172 | /* for each stream, make the setup request */ |
1173 | /* XXX: we assume the same server is used for the control of each | |
c8965800 | 1174 | * RTSP stream */ |
d1ccf0e0 | 1175 | |
58f09785 DV |
1176 | /* Choose a random starting offset within the first half of the |
1177 | * port range, to allow for a number of ports to try even if the offset | |
1178 | * happens to be at the end of the random range. */ | |
1179 | port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2); | |
1180 | /* even random offset */ | |
1181 | port_off -= port_off & 0x01; | |
1182 | ||
1183 | for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) { | |
1617ad97 FB |
1184 | char transport[2048]; |
1185 | ||
f75e3da5 | 1186 | /* |
f830c9a4 RB |
1187 | * WMS serves all UDP data over a single connection, the RTX, which |
1188 | * isn't necessarily the first in the SDP but has to be the first | |
1189 | * to be set up, else the second/third SETUP will fail with a 461. | |
1190 | */ | |
1191 | if (lower_transport == RTSP_LOWER_TRANSPORT_UDP && | |
1192 | rt->server_type == RTSP_SERVER_WMS) { | |
1193 | if (i == 0) { | |
1194 | /* rtx first */ | |
1195 | for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) { | |
1196 | int len = strlen(rt->rtsp_streams[rtx]->control_url); | |
1197 | if (len >= 4 && | |
c8965800 RB |
1198 | !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4, |
1199 | "/rtx")) | |
f830c9a4 RB |
1200 | break; |
1201 | } | |
1202 | if (rtx == rt->nb_rtsp_streams) | |
1203 | return -1; /* no RTX found */ | |
1204 | rtsp_st = rt->rtsp_streams[rtx]; | |
1205 | } else | |
1206 | rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1]; | |
1207 | } else | |
2fea9650 | 1208 | rtsp_st = rt->rtsp_streams[i]; |
1617ad97 | 1209 | |
1617ad97 | 1210 | /* RTP/UDP */ |
90abbdba | 1211 | if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) { |
85fb7b34 | 1212 | char buf[256]; |
85fb7b34 | 1213 | |
f830c9a4 RB |
1214 | if (rt->server_type == RTSP_SERVER_WMS && i > 1) { |
1215 | port = reply->transports[0].client_port_min; | |
1216 | goto have_port; | |
1217 | } | |
1218 | ||
85fb7b34 | 1219 | /* first try in specified port range */ |
dbb06b8c | 1220 | while (j <= rt->rtp_port_max) { |
bc495bad DV |
1221 | ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1, |
1222 | "?localport=%d", j); | |
1223 | /* we will use two ports per rtp stream (rtp and rtcp) */ | |
1224 | j += 2; | |
1225 | if (!ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE, | |
1226 | &s->interrupt_callback, NULL)) | |
1227 | goto rtp_opened; | |
1617ad97 | 1228 | } |
85fb7b34 | 1229 | |
a3b058b7 MS |
1230 | av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n"); |
1231 | err = AVERROR(EIO); | |
1232 | goto fail; | |
85fb7b34 FB |
1233 | |
1234 | rtp_opened: | |
bfc6db44 | 1235 | port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle); |
f830c9a4 | 1236 | have_port: |
0ad306bc | 1237 | snprintf(transport, sizeof(transport) - 1, |
eee2cbff RB |
1238 | "%s/UDP;", trans_pref); |
1239 | if (rt->server_type != RTSP_SERVER_REAL) | |
1240 | av_strlcat(transport, "unicast;", sizeof(transport)); | |
1241 | av_strlcatf(transport, sizeof(transport), | |
1242 | "client_port=%d", port); | |
f830c9a4 RB |
1243 | if (rt->transport == RTSP_TRANSPORT_RTP && |
1244 | !(rt->server_type == RTSP_SERVER_WMS && i > 0)) | |
e9dea59f | 1245 | av_strlcatf(transport, sizeof(transport), "-%d", port + 1); |
1617ad97 FB |
1246 | } |
1247 | ||
1248 | /* RTP/TCP */ | |
90abbdba | 1249 | else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) { |
f75e3da5 | 1250 | /* For WMS streams, the application streams are only used for |
090438cc RB |
1251 | * UDP. When trying to set it up for TCP streams, the server |
1252 | * will return an error. Therefore, we skip those streams. */ | |
1253 | if (rt->server_type == RTSP_SERVER_WMS && | |
c8965800 | 1254 | s->streams[rtsp_st->stream_index]->codec->codec_type == |
72415b2a | 1255 | AVMEDIA_TYPE_DATA) |
090438cc | 1256 | continue; |
0ad306bc | 1257 | snprintf(transport, sizeof(transport) - 1, |
d1c6e47c | 1258 | "%s/TCP;", trans_pref); |
895678f8 | 1259 | if (rt->transport != RTSP_TRANSPORT_RDT) |
d1c6e47c RB |
1260 | av_strlcat(transport, "unicast;", sizeof(transport)); |
1261 | av_strlcatf(transport, sizeof(transport), | |
1262 | "interleaved=%d-%d", | |
1263 | interleave, interleave + 1); | |
1264 | interleave += 2; | |
1617ad97 FB |
1265 | } |
1266 | ||
90abbdba | 1267 | else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) { |
0ad306bc | 1268 | snprintf(transport, sizeof(transport) - 1, |
e9dea59f | 1269 | "%s/UDP;multicast", trans_pref); |
1617ad97 | 1270 | } |
69adcc4f MS |
1271 | if (s->oformat) { |
1272 | av_strlcat(transport, ";mode=receive", sizeof(transport)); | |
1273 | } else if (rt->server_type == RTSP_SERVER_REAL || | |
2efc97c2 | 1274 | rt->server_type == RTSP_SERVER_WMS) |
e9dea59f | 1275 | av_strlcat(transport, ";mode=play", sizeof(transport)); |
115329f1 | 1276 | snprintf(cmd, sizeof(cmd), |
b6892136 | 1277 | "Transport: %s\r\n", |
b17d11c6 | 1278 | transport); |
76b0d03d MS |
1279 | if (rt->accept_dynamic_rate) |
1280 | av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd)); | |
44b70ce5 | 1281 | if (i == 0 && rt->server_type == RTSP_SERVER_REAL && CONFIG_RTPDEC) { |
e9dea59f RB |
1282 | char real_res[41], real_csum[9]; |
1283 | ff_rdt_calc_response_and_checksum(real_res, real_csum, | |
1284 | real_challenge); | |
1285 | av_strlcatf(cmd, sizeof(cmd), | |
1286 | "If-Match: %s\r\n" | |
1287 | "RealChallenge2: %s, sd=%s\r\n", | |
1288 | rt->session_id, real_res, real_csum); | |
1289 | } | |
b17d11c6 | 1290 | ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL); |
8a8754d8 RB |
1291 | if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) { |
1292 | err = 1; | |
1293 | goto fail; | |
7e6ca34f RB |
1294 | } else if (reply->status_code != RTSP_STATUS_OK || |
1295 | reply->nb_transports != 1) { | |
1617ad97 FB |
1296 | err = AVERROR_INVALIDDATA; |
1297 | goto fail; | |
1298 | } | |
1299 | ||
1300 | /* XXX: same protocol for all streams is required */ | |
1301 | if (i > 0) { | |
119b4668 RB |
1302 | if (reply->transports[0].lower_transport != rt->lower_transport || |
1303 | reply->transports[0].transport != rt->transport) { | |
1617ad97 FB |
1304 | err = AVERROR_INVALIDDATA; |
1305 | goto fail; | |
1306 | } | |
1307 | } else { | |
90abbdba | 1308 | rt->lower_transport = reply->transports[0].lower_transport; |
119b4668 | 1309 | rt->transport = reply->transports[0].transport; |
1617ad97 FB |
1310 | } |
1311 | ||
8c579c1c MS |
1312 | /* Fail if the server responded with another lower transport mode |
1313 | * than what we requested. */ | |
1314 | if (reply->transports[0].lower_transport != lower_transport) { | |
1315 | av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n"); | |
1316 | err = AVERROR_INVALIDDATA; | |
1317 | goto fail; | |
1617ad97 FB |
1318 | } |
1319 | ||
90abbdba RB |
1320 | switch(reply->transports[0].lower_transport) { |
1321 | case RTSP_LOWER_TRANSPORT_TCP: | |
1617ad97 FB |
1322 | rtsp_st->interleaved_min = reply->transports[0].interleaved_min; |
1323 | rtsp_st->interleaved_max = reply->transports[0].interleaved_max; | |
1324 | break; | |
115329f1 | 1325 | |
c8965800 | 1326 | case RTSP_LOWER_TRANSPORT_UDP: { |
a92c30d7 | 1327 | char url[1024], options[30] = ""; |
c8965800 | 1328 | |
9867aea5 | 1329 | if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC) |
a92c30d7 | 1330 | av_strlcpy(options, "?connect=1", sizeof(options)); |
619298a8 JW |
1331 | /* Use source address if specified */ |
1332 | if (reply->transports[0].source[0]) { | |
1333 | ff_url_join(url, sizeof(url), "rtp", NULL, | |
1334 | reply->transports[0].source, | |
d8407339 | 1335 | reply->transports[0].server_port_min, "%s", options); |
619298a8 | 1336 | } else { |
7bac991f | 1337 | ff_url_join(url, sizeof(url), "rtp", NULL, host, |
d8407339 | 1338 | reply->transports[0].server_port_min, "%s", options); |
619298a8 | 1339 | } |
c8965800 | 1340 | if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && |
bfc6db44 | 1341 | ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) { |
c8965800 RB |
1342 | err = AVERROR_INVALIDDATA; |
1343 | goto fail; | |
1617ad97 | 1344 | } |
9c8fa20d MS |
1345 | /* Try to initialize the connection state in a |
1346 | * potential NAT router by sending dummy packets. | |
1347 | * RTP/RTCP dummy packets are used for RDT, too. | |
1348 | */ | |
44b70ce5 MS |
1349 | if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && s->iformat && |
1350 | CONFIG_RTPDEC) | |
bfc6db44 | 1351 | ff_rtp_send_punch_packets(rtsp_st->rtp_handle); |
1617ad97 | 1352 | break; |
c8965800 RB |
1353 | } |
1354 | case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: { | |
6294d708 | 1355 | char url[1024], namebuf[50], optbuf[20] = ""; |
7934b15d | 1356 | struct sockaddr_storage addr; |
c8965800 RB |
1357 | int port, ttl; |
1358 | ||
7934b15d MS |
1359 | if (reply->transports[0].destination.ss_family) { |
1360 | addr = reply->transports[0].destination; | |
c8965800 RB |
1361 | port = reply->transports[0].port_min; |
1362 | ttl = reply->transports[0].ttl; | |
1363 | } else { | |
7934b15d | 1364 | addr = rtsp_st->sdp_ip; |
c8965800 RB |
1365 | port = rtsp_st->sdp_port; |
1366 | ttl = rtsp_st->sdp_ttl; | |
1367 | } | |
6294d708 MS |
1368 | if (ttl > 0) |
1369 | snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl); | |
7934b15d MS |
1370 | getnameinfo((struct sockaddr*) &addr, sizeof(addr), |
1371 | namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST); | |
1372 | ff_url_join(url, sizeof(url), "rtp", NULL, namebuf, | |
6294d708 | 1373 | port, "%s", optbuf); |
6f1b7b39 | 1374 | if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE, |
ddffc2fd | 1375 | &s->interrupt_callback, NULL) < 0) { |
c8965800 RB |
1376 | err = AVERROR_INVALIDDATA; |
1377 | goto fail; | |
1617ad97 FB |
1378 | } |
1379 | break; | |
1380 | } | |
c8965800 | 1381 | } |
d1ccf0e0 | 1382 | |
ee0cb67f | 1383 | if ((err = rtsp_open_transport_ctx(s, rtsp_st))) |
8b1ab7bf | 1384 | goto fail; |
1617ad97 FB |
1385 | } |
1386 | ||
30e79845 RB |
1387 | if (reply->timeout > 0) |
1388 | rt->timeout = reply->timeout; | |
1389 | ||
2e889ae4 | 1390 | if (rt->server_type == RTSP_SERVER_REAL) |
1256d16b RB |
1391 | rt->need_subscription = 1; |
1392 | ||
53620bba RB |
1393 | return 0; |
1394 | ||
1395 | fail: | |
aeb2de1c | 1396 | ff_rtsp_undo_setup(s); |
53620bba RB |
1397 | return err; |
1398 | } | |
1399 | ||
b8c2c41d JA |
1400 | void ff_rtsp_close_connections(AVFormatContext *s) |
1401 | { | |
1402 | RTSPState *rt = s->priv_data; | |
e52a9145 AK |
1403 | if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out); |
1404 | ffurl_close(rt->rtsp_hd); | |
6217b645 | 1405 | rt->rtsp_hd = rt->rtsp_hd_out = NULL; |
b8c2c41d JA |
1406 | } |
1407 | ||
3307e6ea | 1408 | int ff_rtsp_connect(AVFormatContext *s) |
53620bba RB |
1409 | { |
1410 | RTSPState *rt = s->priv_data; | |
921da217 | 1411 | char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128]; |
03f8fc08 | 1412 | int port, err, tcp_fd; |
354b7573 | 1413 | RTSPMessageHeader reply1 = {0}, *reply = &reply1; |
90abbdba | 1414 | int lower_transport_mask = 0; |
2762a7a2 | 1415 | char real_challenge[64] = ""; |
03f8fc08 MS |
1416 | struct sockaddr_storage peer; |
1417 | socklen_t peer_len = sizeof(peer); | |
57b5555c | 1418 | |
dbb06b8c MS |
1419 | if (rt->rtp_port_max < rt->rtp_port_min) { |
1420 | av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less " | |
1421 | "than min port %d\n", rt->rtp_port_max, | |
1422 | rt->rtp_port_min); | |
1423 | return AVERROR(EINVAL); | |
1424 | } | |
1425 | ||
57b5555c MS |
1426 | if (!ff_network_init()) |
1427 | return AVERROR(EIO); | |
eca4850c | 1428 | |
4fa57d52 MS |
1429 | if (s->max_delay < 0) /* Not set by the caller */ |
1430 | s->max_delay = 0; | |
1431 | ||
f5d33f52 | 1432 | rt->control_transport = RTSP_MODE_PLAIN; |
eca4850c MS |
1433 | if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) { |
1434 | rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP; | |
1435 | rt->control_transport = RTSP_MODE_TUNNEL; | |
1436 | } | |
1437 | /* Only pass through valid flags from here */ | |
1438 | rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1; | |
eca4850c MS |
1439 | |
1440 | redirect: | |
1441 | lower_transport_mask = rt->lower_transport_mask; | |
53620bba | 1442 | /* extract hostname and port */ |
f3bfe388 | 1443 | av_url_split(NULL, 0, auth, sizeof(auth), |
f984dcf6 | 1444 | host, sizeof(host), &port, path, sizeof(path), s->filename); |
f9337897 | 1445 | if (*auth) { |
aa8bf2fb | 1446 | av_strlcpy(rt->auth, auth, sizeof(rt->auth)); |
f9337897 | 1447 | } |
53620bba RB |
1448 | if (port < 0) |
1449 | port = RTSP_DEFAULT_PORT; | |
1450 | ||
90abbdba | 1451 | if (!lower_transport_mask) |
2a1d51c5 | 1452 | lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1; |
53620bba | 1453 | |
3e24c770 | 1454 | if (s->oformat) { |
b7dc88fc MS |
1455 | /* Only UDP or TCP - UDP multicast isn't supported. */ |
1456 | lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) | | |
1457 | (1 << RTSP_LOWER_TRANSPORT_TCP); | |
f5d33f52 | 1458 | if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) { |
3e24c770 | 1459 | av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, " |
b7dc88fc | 1460 | "only UDP and TCP are supported for output.\n"); |
3e24c770 MS |
1461 | err = AVERROR(EINVAL); |
1462 | goto fail; | |
1463 | } | |
1464 | } | |
1465 | ||
4bc5cc23 MS |
1466 | /* Construct the URI used in request; this is similar to s->filename, |
1467 | * but with authentication credentials removed and RTSP specific options | |
1468 | * stripped out. */ | |
1469 | ff_url_join(rt->control_uri, sizeof(rt->control_uri), "rtsp", NULL, | |
1470 | host, port, "%s", path); | |
1471 | ||
f5d33f52 JA |
1472 | if (rt->control_transport == RTSP_MODE_TUNNEL) { |
1473 | /* set up initial handshake for tunneling */ | |
1474 | char httpname[1024]; | |
1475 | char sessioncookie[17]; | |
1476 | char headers[1024]; | |
1477 | ||
10ed37b5 | 1478 | ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path); |
f5d33f52 JA |
1479 | snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x", |
1480 | av_get_random_seed(), av_get_random_seed()); | |
1481 | ||
1482 | /* GET requests */ | |
6f1b7b39 MS |
1483 | if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ, |
1484 | &s->interrupt_callback) < 0) { | |
f5d33f52 JA |
1485 | err = AVERROR(EIO); |
1486 | goto fail; | |
1487 | } | |
1488 | ||
1489 | /* generate GET headers */ | |
1490 | snprintf(headers, sizeof(headers), | |
1491 | "x-sessioncookie: %s\r\n" | |
1492 | "Accept: application/x-rtsp-tunnelled\r\n" | |
1493 | "Pragma: no-cache\r\n" | |
1494 | "Cache-Control: no-cache\r\n", | |
1495 | sessioncookie); | |
196bf28c | 1496 | av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0); |
f5d33f52 JA |
1497 | |
1498 | /* complete the connection */ | |
ddffc2fd | 1499 | if (ffurl_connect(rt->rtsp_hd, NULL)) { |
f5d33f52 JA |
1500 | err = AVERROR(EIO); |
1501 | goto fail; | |
1502 | } | |
1503 | ||
1504 | /* POST requests */ | |
6f1b7b39 MS |
1505 | if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE, |
1506 | &s->interrupt_callback) < 0 ) { | |
f5d33f52 JA |
1507 | err = AVERROR(EIO); |
1508 | goto fail; | |
1509 | } | |
1510 | ||
1511 | /* generate POST headers */ | |
1512 | snprintf(headers, sizeof(headers), | |
1513 | "x-sessioncookie: %s\r\n" | |
1514 | "Content-Type: application/x-rtsp-tunnelled\r\n" | |
1515 | "Pragma: no-cache\r\n" | |
1516 | "Cache-Control: no-cache\r\n" | |
1517 | "Content-Length: 32767\r\n" | |
1518 | "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n", | |
1519 | sessioncookie); | |
196bf28c | 1520 | av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0); |
6149485f | 1521 | av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0); |
f5d33f52 | 1522 | |
a8ead332 MS |
1523 | /* Initialize the authentication state for the POST session. The HTTP |
1524 | * protocol implementation doesn't properly handle multi-pass | |
1525 | * authentication for POST requests, since it would require one of | |
1526 | * the following: | |
1527 | * - implementing Expect: 100-continue, which many HTTP servers | |
1528 | * don't support anyway, even less the RTSP servers that do HTTP | |
1529 | * tunneling | |
1530 | * - sending the whole POST data until getting a 401 reply specifying | |
1531 | * what authentication method to use, then resending all that data | |
1532 | * - waiting for potential 401 replies directly after sending the | |
1533 | * POST header (waiting for some unspecified time) | |
1534 | * Therefore, we copy the full auth state, which works for both basic | |
1535 | * and digest. (For digest, we would have to synchronize the nonce | |
1536 | * count variable between the two sessions, if we'd do more requests | |
1537 | * with the original session, though.) | |
1538 | */ | |
1539 | ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd); | |
1540 | ||
9290f15d | 1541 | /* complete the connection */ |
ddffc2fd | 1542 | if (ffurl_connect(rt->rtsp_hd_out, NULL)) { |
9290f15d MS |
1543 | err = AVERROR(EIO); |
1544 | goto fail; | |
1545 | } | |
f5d33f52 | 1546 | } else { |
48e77473 | 1547 | /* open the tcp connection */ |
41874d0a | 1548 | ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL); |
6f1b7b39 | 1549 | if (ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE, |
ddffc2fd | 1550 | &s->interrupt_callback, NULL) < 0) { |
41874d0a JA |
1551 | err = AVERROR(EIO); |
1552 | goto fail; | |
1553 | } | |
00e4a1f4 | 1554 | rt->rtsp_hd_out = rt->rtsp_hd; |
f5d33f52 | 1555 | } |
53620bba RB |
1556 | rt->seq = 0; |
1557 | ||
1869ea03 | 1558 | tcp_fd = ffurl_get_file_handle(rt->rtsp_hd); |
03f8fc08 MS |
1559 | if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) { |
1560 | getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host), | |
1561 | NULL, 0, NI_NUMERICHOST); | |
1562 | } | |
1563 | ||
c8965800 RB |
1564 | /* request options supported by the server; this also detects server |
1565 | * type */ | |
1cf151e9 | 1566 | for (rt->server_type = RTSP_SERVER_RTP;;) { |
b17d11c6 | 1567 | cmd[0] = 0; |
2e889ae4 | 1568 | if (rt->server_type == RTSP_SERVER_REAL) |
1cf151e9 | 1569 | av_strlcat(cmd, |
f75e3da5 | 1570 | /* |
1cf151e9 RB |
1571 | * The following entries are required for proper |
1572 | * streaming from a Realmedia server. They are | |
1573 | * interdependent in some way although we currently | |
1574 | * don't quite understand how. Values were copied | |
1575 | * from mplayer SVN r23589. | |
f75e3da5 DB |
1576 | * ClientChallenge is a 16-byte ID in hex |
1577 | * CompanyID is a 16-byte ID in base64 | |
1cf151e9 RB |
1578 | */ |
1579 | "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n" | |
1580 | "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n" | |
1581 | "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n" | |
1582 | "GUID: 00000000-0000-0000-0000-000000000000\r\n", | |
1583 | sizeof(cmd)); | |
b17d11c6 | 1584 | ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL); |
1cf151e9 RB |
1585 | if (reply->status_code != RTSP_STATUS_OK) { |
1586 | err = AVERROR_INVALIDDATA; | |
1587 | goto fail; | |
1588 | } | |
1589 | ||
1590 | /* detect server type if not standard-compliant RTP */ | |
2e889ae4 RB |
1591 | if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) { |
1592 | rt->server_type = RTSP_SERVER_REAL; | |
1cf151e9 | 1593 | continue; |
bb3244de | 1594 | } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) { |
7a86bafa | 1595 | rt->server_type = RTSP_SERVER_WMS; |
c8965800 | 1596 | } else if (rt->server_type == RTSP_SERVER_REAL) |
1cf151e9 | 1597 | strcpy(real_challenge, reply->real_challenge); |
1cf151e9 RB |
1598 | break; |
1599 | } | |
1600 | ||
44b70ce5 | 1601 | if (s->iformat && CONFIG_RTSP_DEMUXER) |
0526c6f7 | 1602 | err = ff_rtsp_setup_input_streams(s, reply); |
44b70ce5 | 1603 | else if (CONFIG_RTSP_MUXER) |
c2688f3a | 1604 | err = ff_rtsp_setup_output_streams(s, host); |
e23d195d | 1605 | if (err) |
53620bba | 1606 | goto fail; |
53620bba | 1607 | |
8a8754d8 | 1608 | do { |
c8965800 RB |
1609 | int lower_transport = ff_log2_tab[lower_transport_mask & |
1610 | ~(lower_transport_mask - 1)]; | |
8a8754d8 | 1611 | |
fef5649a | 1612 | err = ff_rtsp_make_setup_request(s, host, port, lower_transport, |
2e889ae4 | 1613 | rt->server_type == RTSP_SERVER_REAL ? |
e9dea59f | 1614 | real_challenge : NULL); |
8a8754d8 | 1615 | if (err < 0) |
7e6ca34f | 1616 | goto fail; |
90abbdba RB |
1617 | lower_transport_mask &= ~(1 << lower_transport); |
1618 | if (lower_transport_mask == 0 && err == 1) { | |
28c4741a | 1619 | err = AVERROR(EPROTONOSUPPORT); |
8a8754d8 RB |
1620 | goto fail; |
1621 | } | |
1622 | } while (err); | |
53620bba | 1623 | |
2762a7a2 MS |
1624 | rt->lower_transport_mask = lower_transport_mask; |
1625 | av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge)); | |
ff762d6e | 1626 | rt->state = RTSP_STATE_IDLE; |
c8965800 | 1627 | rt->seek_timestamp = 0; /* default is to start stream at position zero */ |
1617ad97 FB |
1628 | return 0; |
1629 | fail: | |
3307e6ea | 1630 | ff_rtsp_close_streams(s); |
b8c2c41d | 1631 | ff_rtsp_close_connections(s); |
35cfd646 | 1632 | if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) { |
d243ba30 LB |
1633 | av_strlcpy(s->filename, reply->location, sizeof(s->filename)); |
1634 | av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n", | |
1635 | reply->status_code, | |
1636 | s->filename); | |
1637 | goto redirect; | |
1638 | } | |
57b5555c | 1639 | ff_network_close(); |
1617ad97 FB |
1640 | return err; |
1641 | } | |
2e802e38 | 1642 | #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */ |
1617ad97 | 1643 | |
44b70ce5 | 1644 | #if CONFIG_RTPDEC |
0e59034e | 1645 | static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, |
321259c1 | 1646 | uint8_t *buf, int buf_size, int64_t wait_end) |
0e59034e RB |
1647 | { |
1648 | RTSPState *rt = s->priv_data; | |
1649 | RTSPStream *rtsp_st; | |
a8475bbd LB |
1650 | int n, i, ret, tcp_fd, timeout_cnt = 0; |
1651 | int max_p = 0; | |
1652 | struct pollfd *p = rt->p; | |
0e59034e | 1653 | |
c8965800 | 1654 | for (;;) { |
9957cdbf | 1655 | if (ff_check_interrupt(&s->interrupt_callback)) |
c76374c6 | 1656 | return AVERROR_EXIT; |
321259c1 MS |
1657 | if (wait_end && wait_end - av_gettime() < 0) |
1658 | return AVERROR(EAGAIN); | |
a8475bbd | 1659 | max_p = 0; |
0e59034e | 1660 | if (rt->rtsp_hd) { |
1869ea03 | 1661 | tcp_fd = ffurl_get_file_handle(rt->rtsp_hd); |
a8475bbd LB |
1662 | p[max_p].fd = tcp_fd; |
1663 | p[max_p++].events = POLLIN; | |
0e59034e | 1664 | } else { |
0e59034e RB |
1665 | tcp_fd = -1; |
1666 | } | |
c8965800 | 1667 | for (i = 0; i < rt->nb_rtsp_streams; i++) { |
0e59034e RB |
1668 | rtsp_st = rt->rtsp_streams[i]; |
1669 | if (rtsp_st->rtp_handle) { | |
1869ea03 | 1670 | p[max_p].fd = ffurl_get_file_handle(rtsp_st->rtp_handle); |
a8475bbd | 1671 | p[max_p++].events = POLLIN; |
bfc6db44 | 1672 | p[max_p].fd = ff_rtp_get_rtcp_file_handle(rtsp_st->rtp_handle); |
a8475bbd | 1673 | p[max_p++].events = POLLIN; |
0e59034e RB |
1674 | } |
1675 | } | |
a8475bbd | 1676 | n = poll(p, max_p, POLL_TIMEOUT_MS); |
0e59034e | 1677 | if (n > 0) { |
a8475bbd | 1678 | int j = 1 - (tcp_fd == -1); |
9cba6f5f | 1679 | timeout_cnt = 0; |
c8965800 | 1680 | for (i = 0; i < rt->nb_rtsp_streams; i++) { |
0e59034e RB |
1681 | rtsp_st = rt->rtsp_streams[i]; |
1682 | if (rtsp_st->rtp_handle) { | |
a8475bbd | 1683 | if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) { |
bc371aca | 1684 | ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size); |
0e59034e RB |
1685 | if (ret > 0) { |
1686 | *prtsp_st = rtsp_st; | |
1687 | return ret; | |
1688 | } | |
1689 | } | |
a8475bbd | 1690 | j+=2; |
0e59034e RB |
1691 | } |
1692 | } | |
5fe8021a | 1693 | #if CONFIG_RTSP_DEMUXER |
a8475bbd | 1694 | if (tcp_fd != -1 && p[0].revents & POLLIN) { |
0e59034e RB |
1695 | RTSPMessageHeader reply; |
1696 | ||
3df54c6b | 1697 | ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL); |
3032276b MS |
1698 | if (ret < 0) |
1699 | return ret; | |
0e59034e | 1700 | /* XXX: parse message */ |
c02fd3d2 | 1701 | if (rt->state != RTSP_STATE_STREAMING) |
0e59034e RB |
1702 | return 0; |
1703 | } | |
5fe8021a | 1704 | #endif |
9cba6f5f | 1705 | } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) { |
28c4741a | 1706 | return AVERROR(ETIMEDOUT); |
9cba6f5f SG |
1707 | } else if (n < 0 && errno != EINTR) |
1708 | return AVERROR(errno); | |
0e59034e RB |
1709 | } |
1710 | } | |
1711 | ||
0526c6f7 | 1712 | int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt) |
0e59034e RB |
1713 | { |
1714 | RTSPState *rt = s->priv_data; | |
1715 | int ret, len; | |
321259c1 MS |
1716 | RTSPStream *rtsp_st, *first_queue_st = NULL; |
1717 | int64_t wait_end = 0; | |
0e59034e | 1718 | |
b20359f5 JA |
1719 | if (rt->nb_byes == rt->nb_rtsp_streams) |
1720 | return AVERROR_EOF; | |
1721 | ||
0e59034e RB |
1722 | /* get next frames from the same RTP packet */ |
1723 | if (rt->cur_transport_priv) { | |
c8965800 | 1724 | if (rt->transport == RTSP_TRANSPORT_RDT) { |
0e59034e | 1725 | ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0); |
c8965800 | 1726 | } else |
bfc6db44 | 1727 | ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0); |
0e59034e RB |
1728 | if (ret == 0) { |
1729 | rt->cur_transport_priv = NULL; | |
1730 | return 0; | |
1731 | } else if (ret == 1) { | |
1732 | return 0; | |
c8965800 | 1733 | } else |
0e59034e | 1734 | rt->cur_transport_priv = NULL; |
0e59034e RB |
1735 | } |
1736 | ||
321259c1 MS |
1737 | if (rt->transport == RTSP_TRANSPORT_RTP) { |
1738 | int i; | |
1739 | int64_t first_queue_time = 0; | |
1740 | for (i = 0; i < rt->nb_rtsp_streams; i++) { | |
1741 | RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv; | |
9e99f84f MS |
1742 | int64_t queue_time; |
1743 | if (!rtpctx) | |
1744 | continue; | |
1745 | queue_time = ff_rtp_queued_packet_time(rtpctx); | |
321259c1 MS |
1746 | if (queue_time && (queue_time - first_queue_time < 0 || |
1747 | !first_queue_time)) { | |
1748 | first_queue_time = queue_time; | |
1749 | first_queue_st = rt->rtsp_streams[i]; | |
1750 | } | |
1751 | } | |
1752 | if (first_queue_time) | |
1753 | wait_end = first_queue_time + s->max_delay; | |
1754 | } | |
1755 | ||
0e59034e RB |
1756 | /* read next RTP packet */ |
1757 | redo: | |
96a7c975 MS |
1758 | if (!rt->recvbuf) { |
1759 | rt->recvbuf = av_malloc(RECVBUF_SIZE); | |
1760 | if (!rt->recvbuf) | |
1761 | return AVERROR(ENOMEM); | |
1762 | } | |
1763 | ||
0e59034e RB |
1764 | switch(rt->lower_transport) { |
1765 | default: | |
5fe8021a | 1766 | #if CONFIG_RTSP_DEMUXER |
0e59034e | 1767 | case RTSP_LOWER_TRANSPORT_TCP: |
0526c6f7 | 1768 | len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE); |
0e59034e | 1769 | break; |
5fe8021a | 1770 | #endif |
0e59034e RB |
1771 | case RTSP_LOWER_TRANSPORT_UDP: |
1772 | case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: | |
321259c1 | 1773 | len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end); |
2c35a6bd | 1774 | if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP) |
bfc6db44 | 1775 | ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, len); |
0e59034e RB |
1776 | break; |
1777 | } | |
321259c1 MS |
1778 | if (len == AVERROR(EAGAIN) && first_queue_st && |
1779 | rt->transport == RTSP_TRANSPORT_RTP) { | |
1780 | rtsp_st = first_queue_st; | |
bfc6db44 | 1781 | ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0); |
321259c1 MS |
1782 | goto end; |
1783 | } | |
0e59034e RB |
1784 | if (len < 0) |
1785 | return len; | |
1786 | if (len == 0) | |
1787 | return AVERROR_EOF; | |
c8965800 | 1788 | if (rt->transport == RTSP_TRANSPORT_RDT) { |
ad4ad27f | 1789 | ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len); |
2cab6b48 | 1790 | } else { |
bfc6db44 | 1791 | ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len); |
2cab6b48 MS |
1792 | if (ret < 0) { |
1793 | /* Either bad packet, or a RTCP packet. Check if the | |
1794 | * first_rtcp_ntp_time field was initialized. */ | |
1795 | RTPDemuxContext *rtpctx = rtsp_st->transport_priv; | |
1796 | if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) { | |
1797 | /* first_rtcp_ntp_time has been initialized for this stream, | |
1798 | * copy the same value to all other uninitialized streams, | |
1799 | * in order to map their timestamp origin to the same ntp time | |
1800 | * as this one. */ | |
1801 | int i; | |
3a1cdcc7 MS |
1802 | AVStream *st = NULL; |
1803 | if (rtsp_st->stream_index >= 0) | |
1804 | st = s->streams[rtsp_st->stream_index]; | |
2cab6b48 | 1805 | for (i = 0; i < rt->nb_rtsp_streams; i++) { |
744a882f | 1806 | RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv; |
3a1cdcc7 MS |
1807 | AVStream *st2 = NULL; |
1808 | if (rt->rtsp_streams[i]->stream_index >= 0) | |
1809 | st2 = s->streams[rt->rtsp_streams[i]->stream_index]; | |
1810 | if (rtpctx2 && st && st2 && | |
1811 | rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) { | |
2cab6b48 | 1812 | rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time; |
3a1cdcc7 MS |
1813 | rtpctx2->rtcp_ts_offset = av_rescale_q( |
1814 | rtpctx->rtcp_ts_offset, st->time_base, | |
1815 | st2->time_base); | |
1816 | } | |
2cab6b48 MS |
1817 | } |
1818 | } | |
b20359f5 JA |
1819 | if (ret == -RTCP_BYE) { |
1820 | rt->nb_byes++; | |
1821 | ||
1822 | av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n", | |
1823 | rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams); | |
1824 | ||
1825 | if (rt->nb_byes == rt->nb_rtsp_streams) | |
1826 | return AVERROR_EOF; | |
1827 | } | |
2cab6b48 MS |
1828 | } |
1829 | } | |
321259c1 | 1830 | end: |
0e59034e RB |
1831 | if (ret < 0) |
1832 | goto redo; | |
c8965800 | 1833 | if (ret == 1) |
0e59034e RB |
1834 | /* more packets may follow, so we save the RTP context */ |
1835 | rt->cur_transport_priv = rtsp_st->transport_priv; | |
0e59034e RB |
1836 | |
1837 | return ret; | |
1838 | } | |
44b70ce5 | 1839 | #endif /* CONFIG_RTPDEC */ |
0e59034e | 1840 | |
44b70ce5 | 1841 | #if CONFIG_SDP_DEMUXER |
cb1fdc61 | 1842 | static int sdp_probe(AVProbeData *p1) |
93ced3e8 | 1843 | { |
0e1ceacd | 1844 | const char *p = p1->buf, *p_end = p1->buf + p1->buf_size; |
cb1fdc61 | 1845 | |
3fbd12d1 | 1846 | /* we look for a line beginning "c=IN IP" */ |
0e1ceacd | 1847 | while (p < p_end && *p != '\0') { |
3fbd12d1 MS |
1848 | if (p + sizeof("c=IN IP") - 1 < p_end && |
1849 | av_strstart(p, "c=IN IP", NULL)) | |
cb1fdc61 | 1850 | return AVPROBE_SCORE_MAX / 2; |
0e1ceacd | 1851 | |
c8965800 | 1852 | while (p < p_end - 1 && *p != '\n') p++; |
0e1ceacd | 1853 | if (++p >= p_end) |
cb1fdc61 | 1854 | break; |
cb1fdc61 FB |
1855 | if (*p == '\r') |
1856 | p++; | |
1857 | } | |
93ced3e8 FB |
1858 | return 0; |
1859 | } | |
1860 | ||
6e9651d1 | 1861 | static int sdp_read_header(AVFormatContext *s) |
93ced3e8 | 1862 | { |
8b1ab7bf | 1863 | RTSPState *rt = s->priv_data; |
93ced3e8 FB |
1864 | RTSPStream *rtsp_st; |
1865 | int size, i, err; | |
1866 | char *content; | |
1867 | char url[1024]; | |
1868 | ||
57b5555c MS |
1869 | if (!ff_network_init()) |
1870 | return AVERROR(EIO); | |
1871 | ||
4fa57d52 MS |
1872 | if (s->max_delay < 0) /* Not set by the caller */ |
1873 | s->max_delay = 0; | |
1874 | ||
93ced3e8 FB |
1875 | /* read the whole sdp file */ |
1876 | /* XXX: better loading */ | |
1877 | content = av_malloc(SDP_MAX_SIZE); | |
b7effd4e | 1878 | size = avio_read(s->pb, content, SDP_MAX_SIZE - 1); |
93ced3e8 FB |
1879 | if (size <= 0) { |
1880 | av_free(content); | |
1881 | return AVERROR_INVALIDDATA; | |
1882 | } | |
1883 | content[size] ='\0'; | |
1884 | ||
f81c7ac7 | 1885 | err = ff_sdp_parse(s, content); |
93ced3e8 | 1886 | av_free(content); |
f81c7ac7 | 1887 | if (err) goto fail; |
93ced3e8 FB |
1888 | |
1889 | /* open each RTP stream */ | |
c8965800 | 1890 | for (i = 0; i < rt->nb_rtsp_streams; i++) { |
3fbd12d1 | 1891 | char namebuf[50]; |
8b1ab7bf | 1892 | rtsp_st = rt->rtsp_streams[i]; |
115329f1 | 1893 | |
3fbd12d1 MS |
1894 | getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip), |
1895 | namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST); | |
57b5555c | 1896 | ff_url_join(url, sizeof(url), "rtp", NULL, |
3fbd12d1 | 1897 | namebuf, rtsp_st->sdp_port, |
51369f28 MS |
1898 | "?localport=%d&ttl=%d&connect=%d", rtsp_st->sdp_port, |
1899 | rtsp_st->sdp_ttl, | |
1900 | rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0); | |
6f1b7b39 | 1901 | if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE, |
ddffc2fd | 1902 | &s->interrupt_callback, NULL) < 0) { |
93ced3e8 FB |
1903 | err = AVERROR_INVALIDDATA; |
1904 | goto fail; | |
1905 | } | |
ee0cb67f | 1906 | if ((err = rtsp_open_transport_ctx(s, rtsp_st))) |
8b1ab7bf | 1907 | goto fail; |
93ced3e8 FB |
1908 | } |
1909 | return 0; | |
c8965800 | 1910 | fail: |
3307e6ea | 1911 | ff_rtsp_close_streams(s); |
57b5555c | 1912 | ff_network_close(); |
93ced3e8 FB |
1913 | return err; |
1914 | } | |
1915 | ||
93ced3e8 FB |
1916 | static int sdp_read_close(AVFormatContext *s) |
1917 | { | |
3307e6ea | 1918 | ff_rtsp_close_streams(s); |
57b5555c | 1919 | ff_network_close(); |
93ced3e8 FB |
1920 | return 0; |
1921 | } | |
1922 | ||
51369f28 MS |
1923 | static const AVClass sdp_demuxer_class = { |
1924 | .class_name = "SDP demuxer", | |
1925 | .item_name = av_default_item_name, | |
1926 | .option = sdp_options, | |
1927 | .version = LIBAVUTIL_VERSION_INT, | |
1928 | }; | |
1929 | ||
c6610a21 | 1930 | AVInputFormat ff_sdp_demuxer = { |
dfc2c4d9 AK |
1931 | .name = "sdp", |
1932 | .long_name = NULL_IF_CONFIG_SMALL("SDP"), | |
1933 | .priv_data_size = sizeof(RTSPState), | |
1934 | .read_probe = sdp_probe, | |
1935 | .read_header = sdp_read_header, | |
1936 | .read_packet = ff_rtsp_fetch_packet, | |
1937 | .read_close = sdp_read_close, | |
17934c18 | 1938 | .priv_class = &sdp_demuxer_class, |
93ced3e8 | 1939 | }; |
44b70ce5 | 1940 | #endif /* CONFIG_SDP_DEMUXER */ |
44594cc7 | 1941 | |
44b70ce5 | 1942 | #if CONFIG_RTP_DEMUXER |
44594cc7 MS |
1943 | static int rtp_probe(AVProbeData *p) |
1944 | { | |
1945 | if (av_strstart(p->filename, "rtp:", NULL)) | |
1946 | return AVPROBE_SCORE_MAX; | |
1947 | return 0; | |
1948 | } | |
1949 | ||
6e9651d1 | 1950 | static int rtp_read_header(AVFormatContext *s) |
44594cc7 MS |
1951 | { |
1952 | uint8_t recvbuf[1500]; | |
1953 | char host[500], sdp[500]; | |
1954 | int ret, port; | |
1955 | URLContext* in = NULL; | |
1956 | int payload_type; | |
1957 | AVCodecContext codec; | |
1958 | struct sockaddr_storage addr; | |
ae628ec1 | 1959 | AVIOContext pb; |
44594cc7 | 1960 | socklen_t addrlen = sizeof(addr); |
30266038 | 1961 | RTSPState *rt = s->priv_data; |
44594cc7 MS |
1962 | |
1963 | if (!ff_network_init()) | |
1964 | return AVERROR(EIO); | |
1965 | ||
6f1b7b39 | 1966 | ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ, |
ddffc2fd | 1967 | &s->interrupt_callback, NULL); |
44594cc7 MS |
1968 | if (ret) |
1969 | goto fail; | |
1970 | ||
1971 | while (1) { | |
bc371aca | 1972 | ret = ffurl_read(in, recvbuf, sizeof(recvbuf)); |
44594cc7 MS |
1973 | if (ret == AVERROR(EAGAIN)) |
1974 | continue; | |
1975 | if (ret < 0) | |
1976 | goto fail; | |
1977 | if (ret < 12) { | |
1978 | av_log(s, AV_LOG_WARNING, "Received too short packet\n"); | |
1979 | continue; | |
1980 | } | |
1981 | ||
1982 | if ((recvbuf[0] & 0xc0) != 0x80) { | |
1983 | av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet " | |
1984 | "received\n"); | |
1985 | continue; | |
1986 | } | |
1987 | ||
298a587f | 1988 | if (RTP_PT_IS_RTCP(recvbuf[1])) |
f3a094f2 MS |
1989 | continue; |
1990 | ||
44594cc7 MS |
1991 | payload_type = recvbuf[1] & 0x7f; |
1992 | break; | |
1993 | } | |
1869ea03 | 1994 | getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen); |
e52a9145 | 1995 | ffurl_close(in); |
44594cc7 MS |
1996 | in = NULL; |
1997 | ||
1998 | memset(&codec, 0, sizeof(codec)); | |
1999 | if (ff_rtp_get_codec_info(&codec, payload_type)) { | |
2000 | av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d " | |
2001 | "without an SDP file describing it\n", | |
2002 | payload_type); | |
2003 | goto fail; | |
2004 | } | |
2005 | if (codec.codec_type != AVMEDIA_TYPE_DATA) { | |
2006 | av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received " | |
2007 | "properly you need an SDP file " | |
2008 | "describing it\n"); | |
2009 | } | |
2010 | ||
2011 | av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port, | |
2012 | NULL, 0, s->filename); | |
2013 | ||
2014 | snprintf(sdp, sizeof(sdp), | |
2015 | "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n", | |
2016 | addr.ss_family == AF_INET ? 4 : 6, host, | |
2017 | codec.codec_type == AVMEDIA_TYPE_DATA ? "application" : | |
2018 | codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio", | |
2019 | port, payload_type); | |
2020 | av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp); | |
2021 | ||
e731b8d8 | 2022 | ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL); |
44594cc7 MS |
2023 | s->pb = &pb; |
2024 | ||
2025 | /* sdp_read_header initializes this again */ | |
2026 | ff_network_close(); | |
2027 | ||
30266038 MS |
2028 | rt->media_type_mask = (1 << (AVMEDIA_TYPE_DATA+1)) - 1; |
2029 | ||
6e9651d1 | 2030 | ret = sdp_read_header(s); |
44594cc7 MS |
2031 | s->pb = NULL; |
2032 | return ret; | |
2033 | ||
2034 | fail: | |
2035 | if (in) | |
e52a9145 | 2036 | ffurl_close(in); |
44594cc7 MS |
2037 | ff_network_close(); |
2038 | return ret; | |
2039 | } | |
2040 | ||
51369f28 MS |
2041 | static const AVClass rtp_demuxer_class = { |
2042 | .class_name = "RTP demuxer", | |
2043 | .item_name = av_default_item_name, | |
2044 | .option = rtp_options, | |
2045 | .version = LIBAVUTIL_VERSION_INT, | |
2046 | }; | |
2047 | ||
c6610a21 | 2048 | AVInputFormat ff_rtp_demuxer = { |
dfc2c4d9 AK |
2049 | .name = "rtp", |
2050 | .long_name = NULL_IF_CONFIG_SMALL("RTP input format"), | |
2051 | .priv_data_size = sizeof(RTSPState), | |
2052 | .read_probe = rtp_probe, | |
2053 | .read_header = rtp_read_header, | |
2054 | .read_packet = ff_rtsp_fetch_packet, | |
2055 | .read_close = sdp_read_close, | |
17934c18 MS |
2056 | .flags = AVFMT_NOFILE, |
2057 | .priv_class = &rtp_demuxer_class, | |
44594cc7 | 2058 | }; |
44b70ce5 | 2059 | #endif /* CONFIG_RTP_DEMUXER */ |