Commit | Line | Data |
---|---|---|
1617ad97 | 1 | /* |
93ced3e8 | 2 | * RTSP/SDP client |
1617ad97 FB |
3 | * Copyright (c) 2002 Fabrice Bellard. |
4 | * | |
b78e7197 DB |
5 | * This file is part of FFmpeg. |
6 | * | |
7 | * FFmpeg 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 | * |
b78e7197 | 12 | * FFmpeg 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 | |
b78e7197 | 18 | * License along with FFmpeg; if not, write to the Free Software |
5509bffa | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1617ad97 FB |
20 | */ |
21 | #include "avformat.h" | |
22 | ||
db0ed93e | 23 | #include <sys/time.h> |
438fcb75 | 24 | #include <unistd.h> /* for select() prototype */ |
42572ef5 | 25 | #include "network.h" |
75e61b0e | 26 | #include "avstring.h" |
1617ad97 | 27 | |
4934884a RM |
28 | #include "rtp_internal.h" |
29 | ||
1617ad97 | 30 | //#define DEBUG |
b6892136 | 31 | //#define DEBUG_RTP_TCP |
1617ad97 | 32 | |
ff762d6e FB |
33 | enum RTSPClientState { |
34 | RTSP_STATE_IDLE, | |
35 | RTSP_STATE_PLAYING, | |
36 | RTSP_STATE_PAUSED, | |
37 | }; | |
38 | ||
1617ad97 FB |
39 | typedef struct RTSPState { |
40 | URLContext *rtsp_hd; /* RTSP TCP connexion handle */ | |
8b1ab7bf FB |
41 | int nb_rtsp_streams; |
42 | struct RTSPStream **rtsp_streams; | |
115329f1 | 43 | |
ff762d6e FB |
44 | enum RTSPClientState state; |
45 | int64_t seek_timestamp; | |
115329f1 | 46 | |
b6892136 FB |
47 | /* XXX: currently we use unbuffered input */ |
48 | // ByteIOContext rtsp_gb; | |
1617ad97 FB |
49 | int seq; /* RTSP command sequence number */ |
50 | char session_id[512]; | |
51 | enum RTSPProtocol protocol; | |
52 | char last_reply[2048]; /* XXX: allocate ? */ | |
8b1ab7bf | 53 | RTPDemuxContext *cur_rtp; |
1617ad97 FB |
54 | } RTSPState; |
55 | ||
56 | typedef struct RTSPStream { | |
8b1ab7bf FB |
57 | URLContext *rtp_handle; /* RTP stream handle */ |
58 | RTPDemuxContext *rtp_ctx; /* RTP parse context */ | |
115329f1 | 59 | |
8b1ab7bf | 60 | int stream_index; /* corresponding stream index, if any. -1 if none (MPEG2TS case) */ |
1617ad97 | 61 | int interleaved_min, interleaved_max; /* interleave ids, if TCP transport */ |
93ced3e8 FB |
62 | char control_url[1024]; /* url for this stream (from SDP) */ |
63 | ||
64 | int sdp_port; /* port (from SDP content - not used in RTSP) */ | |
65 | struct in_addr sdp_ip; /* IP address (from SDP content - not used in RTSP) */ | |
66 | int sdp_ttl; /* IP TTL (from SDP content - not used in RTSP) */ | |
67 | int sdp_payload_type; /* payload type - only used in SDP */ | |
d1ccf0e0 | 68 | rtp_payload_data_t rtp_payload_data; /* rtp payload parsing infos from SDP */ |
4934884a RM |
69 | |
70 | RTPDynamicProtocolHandler *dynamic_handler; ///< Only valid if it's a dynamic protocol. (This is the handler structure) | |
71 | void *dynamic_protocol_context; ///< Only valid if it's a dynamic protocol. (This is any private data associated with the dynamic protocol) | |
1617ad97 FB |
72 | } RTSPStream; |
73 | ||
ff762d6e FB |
74 | static int rtsp_read_play(AVFormatContext *s); |
75 | ||
1617ad97 FB |
76 | /* XXX: currently, the only way to change the protocols consists in |
77 | changing this variable */ | |
1617ad97 | 78 | |
d1ccf0e0 | 79 | int rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_UDP); |
85fb7b34 | 80 | |
1617ad97 FB |
81 | static int rtsp_probe(AVProbeData *p) |
82 | { | |
83 | if (strstart(p->filename, "rtsp:", NULL)) | |
84 | return AVPROBE_SCORE_MAX; | |
85 | return 0; | |
86 | } | |
87 | ||
88 | static int redir_isspace(int c) | |
89 | { | |
90 | return (c == ' ' || c == '\t' || c == '\n' || c == '\r'); | |
91 | } | |
92 | ||
93 | static void skip_spaces(const char **pp) | |
94 | { | |
95 | const char *p; | |
96 | p = *pp; | |
97 | while (redir_isspace(*p)) | |
98 | p++; | |
99 | *pp = p; | |
100 | } | |
101 | ||
115329f1 | 102 | static void get_word_sep(char *buf, int buf_size, const char *sep, |
1617ad97 FB |
103 | const char **pp) |
104 | { | |
105 | const char *p; | |
106 | char *q; | |
107 | ||
108 | p = *pp; | |
d1ccf0e0 RD |
109 | if (*p == '/') |
110 | p++; | |
1617ad97 FB |
111 | skip_spaces(&p); |
112 | q = buf; | |
113 | while (!strchr(sep, *p) && *p != '\0') { | |
114 | if ((q - buf) < buf_size - 1) | |
115 | *q++ = *p; | |
116 | p++; | |
117 | } | |
118 | if (buf_size > 0) | |
119 | *q = '\0'; | |
120 | *pp = p; | |
121 | } | |
122 | ||
123 | static void get_word(char *buf, int buf_size, const char **pp) | |
124 | { | |
125 | const char *p; | |
126 | char *q; | |
127 | ||
128 | p = *pp; | |
129 | skip_spaces(&p); | |
130 | q = buf; | |
131 | while (!redir_isspace(*p) && *p != '\0') { | |
132 | if ((q - buf) < buf_size - 1) | |
133 | *q++ = *p; | |
134 | p++; | |
135 | } | |
136 | if (buf_size > 0) | |
137 | *q = '\0'; | |
138 | *pp = p; | |
139 | } | |
140 | ||
93ced3e8 FB |
141 | /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other |
142 | params>] */ | |
4934884a | 143 | static int sdp_parse_rtpmap(AVCodecContext *codec, RTSPStream *rtsp_st, int payload_type, const char *p) |
93ced3e8 FB |
144 | { |
145 | char buf[256]; | |
d1ccf0e0 RD |
146 | int i; |
147 | AVCodec *c; | |
7b49ce2e | 148 | const char *c_name; |
93ced3e8 | 149 | |
d1ccf0e0 RD |
150 | /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and |
151 | see if we can handle this kind of payload */ | |
93ced3e8 | 152 | get_word_sep(buf, sizeof(buf), "/", &p); |
d1ccf0e0 | 153 | if (payload_type >= RTP_PT_PRIVATE) { |
4934884a RM |
154 | RTPDynamicProtocolHandler *handler= RTPFirstDynamicPayloadHandler; |
155 | while(handler) { | |
156 | if (!strcmp(buf, handler->enc_name) && (codec->codec_type == handler->codec_type)) { | |
157 | codec->codec_id = handler->codec_id; | |
158 | rtsp_st->dynamic_handler= handler; | |
159 | if(handler->open) { | |
160 | rtsp_st->dynamic_protocol_context= handler->open(); | |
161 | } | |
d1ccf0e0 RD |
162 | break; |
163 | } | |
4934884a RM |
164 | handler= handler->next; |
165 | } | |
93ced3e8 | 166 | } else { |
d1ccf0e0 RD |
167 | /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */ |
168 | /* search into AVRtpPayloadTypes[] */ | |
169 | for (i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i) | |
170 | if (!strcmp(buf, AVRtpPayloadTypes[i].enc_name) && (codec->codec_type == AVRtpPayloadTypes[i].codec_type)){ | |
171 | codec->codec_id = AVRtpPayloadTypes[i].codec_id; | |
172 | break; | |
173 | } | |
174 | } | |
175 | ||
176 | c = avcodec_find_decoder(codec->codec_id); | |
177 | if (c && c->name) | |
7b49ce2e | 178 | c_name = c->name; |
d1ccf0e0 RD |
179 | else |
180 | c_name = (char *)NULL; | |
181 | ||
182 | if (c_name) { | |
183 | get_word_sep(buf, sizeof(buf), "/", &p); | |
184 | i = atoi(buf); | |
185 | switch (codec->codec_type) { | |
186 | case CODEC_TYPE_AUDIO: | |
187 | av_log(codec, AV_LOG_DEBUG, " audio codec set to : %s\n", c_name); | |
188 | codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE; | |
189 | codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS; | |
190 | if (i > 0) { | |
191 | codec->sample_rate = i; | |
192 | get_word_sep(buf, sizeof(buf), "/", &p); | |
193 | i = atoi(buf); | |
194 | if (i > 0) | |
195 | codec->channels = i; | |
d0deedcb RM |
196 | // TODO: there is a bug here; if it is a mono stream, and less than 22000Hz, faad upconverts to stereo and twice the |
197 | // frequency. No problem, but the sample rate is being set here by the sdp line. Upcoming patch forthcoming. (rdm) | |
d1ccf0e0 RD |
198 | } |
199 | av_log(codec, AV_LOG_DEBUG, " audio samplerate set to : %i\n", codec->sample_rate); | |
200 | av_log(codec, AV_LOG_DEBUG, " audio channels set to : %i\n", codec->channels); | |
201 | break; | |
202 | case CODEC_TYPE_VIDEO: | |
203 | av_log(codec, AV_LOG_DEBUG, " video codec set to : %s\n", c_name); | |
204 | break; | |
205 | default: | |
206 | break; | |
207 | } | |
208 | return 0; | |
93ced3e8 | 209 | } |
d1ccf0e0 RD |
210 | |
211 | return -1; | |
93ced3e8 FB |
212 | } |
213 | ||
214 | /* return the length and optionnaly the data */ | |
215 | static int hex_to_data(uint8_t *data, const char *p) | |
216 | { | |
217 | int c, len, v; | |
218 | ||
219 | len = 0; | |
220 | v = 1; | |
221 | for(;;) { | |
222 | skip_spaces(&p); | |
223 | if (p == '\0') | |
224 | break; | |
225 | c = toupper((unsigned char)*p++); | |
226 | if (c >= '0' && c <= '9') | |
227 | c = c - '0'; | |
228 | else if (c >= 'A' && c <= 'F') | |
229 | c = c - 'A' + 10; | |
230 | else | |
231 | break; | |
232 | v = (v << 4) | c; | |
233 | if (v & 0x100) { | |
234 | if (data) | |
235 | data[len] = v; | |
236 | len++; | |
237 | v = 1; | |
238 | } | |
239 | } | |
240 | return len; | |
241 | } | |
242 | ||
d1ccf0e0 RD |
243 | static void sdp_parse_fmtp_config(AVCodecContext *codec, char *attr, char *value) |
244 | { | |
245 | switch (codec->codec_id) { | |
246 | case CODEC_ID_MPEG4: | |
cbee7a69 | 247 | case CODEC_ID_AAC: |
d1ccf0e0 RD |
248 | if (!strcmp(attr, "config")) { |
249 | /* decode the hexa encoded parameter */ | |
250 | int len = hex_to_data(NULL, value); | |
251 | codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE); | |
252 | if (!codec->extradata) | |
253 | return; | |
254 | codec->extradata_size = len; | |
255 | hex_to_data(codec->extradata, value); | |
256 | } | |
257 | break; | |
258 | default: | |
259 | break; | |
260 | } | |
261 | return; | |
262 | } | |
263 | ||
264 | typedef struct attrname_map | |
265 | { | |
7b49ce2e | 266 | const char *str; |
d1ccf0e0 RD |
267 | uint16_t type; |
268 | uint32_t offset; | |
269 | } attrname_map_t; | |
270 | ||
271 | /* All known fmtp parmeters and the corresping RTPAttrTypeEnum */ | |
272 | #define ATTR_NAME_TYPE_INT 0 | |
273 | #define ATTR_NAME_TYPE_STR 1 | |
274 | static attrname_map_t attr_names[]= | |
275 | { | |
276 | {"SizeLength", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, sizelength)}, | |
277 | {"IndexLength", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, indexlength)}, | |
278 | {"IndexDeltaLength", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, indexdeltalength)}, | |
279 | {"profile-level-id", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, profile_level_id)}, | |
280 | {"StreamType", ATTR_NAME_TYPE_INT, offsetof(rtp_payload_data_t, streamtype)}, | |
281 | {"mode", ATTR_NAME_TYPE_STR, offsetof(rtp_payload_data_t, mode)}, | |
282 | {NULL, -1, -1}, | |
283 | }; | |
284 | ||
d0deedcb RM |
285 | /** parse the attribute line from the fmtp a line of an sdp resonse. This is broken out as a function |
286 | * because it is used in rtp_h264.c, which is forthcoming. | |
287 | */ | |
288 | int rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size) | |
289 | { | |
290 | skip_spaces(p); | |
291 | if(**p) | |
292 | { | |
293 | get_word_sep(attr, attr_size, "=", p); | |
294 | if (**p == '=') | |
295 | (*p)++; | |
296 | get_word_sep(value, value_size, ";", p); | |
297 | if (**p == ';') | |
298 | (*p)++; | |
299 | return 1; | |
300 | } | |
301 | return 0; | |
302 | } | |
303 | ||
d1ccf0e0 RD |
304 | /* parse a SDP line and save stream attributes */ |
305 | static void sdp_parse_fmtp(AVStream *st, const char *p) | |
93ced3e8 FB |
306 | { |
307 | char attr[256]; | |
308 | char value[4096]; | |
d1ccf0e0 RD |
309 | int i; |
310 | ||
311 | RTSPStream *rtsp_st = st->priv_data; | |
01f4895c | 312 | AVCodecContext *codec = st->codec; |
d1ccf0e0 | 313 | rtp_payload_data_t *rtp_payload_data = &rtsp_st->rtp_payload_data; |
93ced3e8 FB |
314 | |
315 | /* loop on each attribute */ | |
1ad20f96 RM |
316 | while(rtsp_next_attr_and_value(&p, attr, sizeof(attr), value, sizeof(value))) |
317 | { | |
bb270c08 | 318 | /* grab the codec extra_data from the config parameter of the fmtp line */ |
d1ccf0e0 RD |
319 | sdp_parse_fmtp_config(codec, attr, value); |
320 | /* Looking for a known attribute */ | |
321 | for (i = 0; attr_names[i].str; ++i) { | |
322 | if (!strcasecmp(attr, attr_names[i].str)) { | |
323 | if (attr_names[i].type == ATTR_NAME_TYPE_INT) | |
324 | *(int *)((char *)rtp_payload_data + attr_names[i].offset) = atoi(value); | |
325 | else if (attr_names[i].type == ATTR_NAME_TYPE_STR) | |
326 | *(char **)((char *)rtp_payload_data + attr_names[i].offset) = av_strdup(value); | |
bb270c08 | 327 | } |
93ced3e8 | 328 | } |
93ced3e8 FB |
329 | } |
330 | } | |
331 | ||
31693e00 RM |
332 | /** Parse a string \p in the form of Range:npt=xx-xx, and determine the start |
333 | * and end time. | |
334 | * Used for seeking in the rtp stream. | |
335 | */ | |
336 | static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end) | |
337 | { | |
338 | char buf[256]; | |
339 | ||
340 | skip_spaces(&p); | |
341 | if (!stristart(p, "npt=", &p)) | |
342 | return; | |
343 | ||
344 | *start = AV_NOPTS_VALUE; | |
345 | *end = AV_NOPTS_VALUE; | |
346 | ||
347 | get_word_sep(buf, sizeof(buf), "-", &p); | |
348 | *start = parse_date(buf, 1); | |
349 | if (*p == '-') { | |
350 | p++; | |
351 | get_word_sep(buf, sizeof(buf), "-", &p); | |
352 | *end = parse_date(buf, 1); | |
353 | } | |
354 | // av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start); | |
355 | // av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end); | |
356 | } | |
357 | ||
93ced3e8 FB |
358 | typedef struct SDPParseState { |
359 | /* SDP only */ | |
360 | struct in_addr default_ip; | |
361 | int default_ttl; | |
362 | } SDPParseState; | |
363 | ||
364 | static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1, | |
1617ad97 FB |
365 | int letter, const char *buf) |
366 | { | |
8b1ab7bf | 367 | RTSPState *rt = s->priv_data; |
1617ad97 FB |
368 | char buf1[64], st_type[64]; |
369 | const char *p; | |
93ced3e8 | 370 | int codec_type, payload_type, i; |
1617ad97 FB |
371 | AVStream *st; |
372 | RTSPStream *rtsp_st; | |
93ced3e8 FB |
373 | struct in_addr sdp_ip; |
374 | int ttl; | |
375 | ||
1617ad97 FB |
376 | #ifdef DEBUG |
377 | printf("sdp: %c='%s'\n", letter, buf); | |
378 | #endif | |
379 | ||
380 | p = buf; | |
381 | switch(letter) { | |
93ced3e8 FB |
382 | case 'c': |
383 | get_word(buf1, sizeof(buf1), &p); | |
384 | if (strcmp(buf1, "IN") != 0) | |
385 | return; | |
386 | get_word(buf1, sizeof(buf1), &p); | |
387 | if (strcmp(buf1, "IP4") != 0) | |
388 | return; | |
389 | get_word_sep(buf1, sizeof(buf1), "/", &p); | |
390 | if (inet_aton(buf1, &sdp_ip) == 0) | |
391 | return; | |
392 | ttl = 16; | |
393 | if (*p == '/') { | |
394 | p++; | |
395 | get_word_sep(buf1, sizeof(buf1), "/", &p); | |
396 | ttl = atoi(buf1); | |
397 | } | |
398 | if (s->nb_streams == 0) { | |
399 | s1->default_ip = sdp_ip; | |
400 | s1->default_ttl = ttl; | |
401 | } else { | |
402 | st = s->streams[s->nb_streams - 1]; | |
403 | rtsp_st = st->priv_data; | |
404 | rtsp_st->sdp_ip = sdp_ip; | |
405 | rtsp_st->sdp_ttl = ttl; | |
406 | } | |
407 | break; | |
1617ad97 | 408 | case 's': |
75e61b0e | 409 | av_strlcpy(s->title, p, sizeof(s->title)); |
1617ad97 FB |
410 | break; |
411 | case 'i': | |
412 | if (s->nb_streams == 0) { | |
75e61b0e | 413 | av_strlcpy(s->comment, p, sizeof(s->comment)); |
1617ad97 FB |
414 | break; |
415 | } | |
416 | break; | |
417 | case 'm': | |
418 | /* new stream */ | |
419 | get_word(st_type, sizeof(st_type), &p); | |
420 | if (!strcmp(st_type, "audio")) { | |
421 | codec_type = CODEC_TYPE_AUDIO; | |
422 | } else if (!strcmp(st_type, "video")) { | |
423 | codec_type = CODEC_TYPE_VIDEO; | |
424 | } else { | |
425 | return; | |
426 | } | |
1617ad97 FB |
427 | rtsp_st = av_mallocz(sizeof(RTSPStream)); |
428 | if (!rtsp_st) | |
429 | return; | |
8b1ab7bf FB |
430 | rtsp_st->stream_index = -1; |
431 | dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st); | |
93ced3e8 FB |
432 | |
433 | rtsp_st->sdp_ip = s1->default_ip; | |
434 | rtsp_st->sdp_ttl = s1->default_ttl; | |
435 | ||
93ced3e8 FB |
436 | get_word(buf1, sizeof(buf1), &p); /* port */ |
437 | rtsp_st->sdp_port = atoi(buf1); | |
438 | ||
439 | get_word(buf1, sizeof(buf1), &p); /* protocol (ignored) */ | |
115329f1 | 440 | |
93ced3e8 FB |
441 | /* XXX: handle list of formats */ |
442 | get_word(buf1, sizeof(buf1), &p); /* format list */ | |
443 | rtsp_st->sdp_payload_type = atoi(buf1); | |
93ced3e8 | 444 | |
d1ccf0e0 | 445 | if (!strcmp(AVRtpPayloadTypes[rtsp_st->sdp_payload_type].enc_name, "MP2T")) { |
8b1ab7bf FB |
446 | /* no corresponding stream */ |
447 | } else { | |
448 | st = av_new_stream(s, 0); | |
449 | if (!st) | |
450 | return; | |
451 | st->priv_data = rtsp_st; | |
452 | rtsp_st->stream_index = st->index; | |
01f4895c | 453 | st->codec->codec_type = codec_type; |
d1ccf0e0 | 454 | if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) { |
8b1ab7bf | 455 | /* if standard payload type, we can find the codec right now */ |
01f4895c | 456 | rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type); |
8b1ab7bf FB |
457 | } |
458 | } | |
1617ad97 | 459 | /* put a default control url */ |
75e61b0e | 460 | av_strlcpy(rtsp_st->control_url, s->filename, sizeof(rtsp_st->control_url)); |
1617ad97 FB |
461 | break; |
462 | case 'a': | |
463 | if (strstart(p, "control:", &p) && s->nb_streams > 0) { | |
464 | char proto[32]; | |
465 | /* get the control url */ | |
466 | st = s->streams[s->nb_streams - 1]; | |
467 | rtsp_st = st->priv_data; | |
115329f1 | 468 | |
1617ad97 | 469 | /* XXX: may need to add full url resolution */ |
6ba5cbc6 | 470 | url_split(proto, sizeof(proto), NULL, 0, NULL, 0, NULL, NULL, 0, p); |
1617ad97 FB |
471 | if (proto[0] == '\0') { |
472 | /* relative control URL */ | |
75e61b0e MR |
473 | av_strlcat(rtsp_st->control_url, "/", sizeof(rtsp_st->control_url)); |
474 | av_strlcat(rtsp_st->control_url, p, sizeof(rtsp_st->control_url)); | |
1617ad97 | 475 | } else { |
75e61b0e | 476 | av_strlcpy(rtsp_st->control_url, p, sizeof(rtsp_st->control_url)); |
1617ad97 | 477 | } |
93ced3e8 FB |
478 | } else if (strstart(p, "rtpmap:", &p)) { |
479 | /* NOTE: rtpmap is only supported AFTER the 'm=' tag */ | |
115329f1 | 480 | get_word(buf1, sizeof(buf1), &p); |
93ced3e8 FB |
481 | payload_type = atoi(buf1); |
482 | for(i = 0; i < s->nb_streams;i++) { | |
483 | st = s->streams[i]; | |
484 | rtsp_st = st->priv_data; | |
485 | if (rtsp_st->sdp_payload_type == payload_type) { | |
4934884a | 486 | sdp_parse_rtpmap(st->codec, rtsp_st, payload_type, p); |
93ced3e8 FB |
487 | } |
488 | } | |
489 | } else if (strstart(p, "fmtp:", &p)) { | |
490 | /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */ | |
115329f1 | 491 | get_word(buf1, sizeof(buf1), &p); |
93ced3e8 FB |
492 | payload_type = atoi(buf1); |
493 | for(i = 0; i < s->nb_streams;i++) { | |
494 | st = s->streams[i]; | |
495 | rtsp_st = st->priv_data; | |
496 | if (rtsp_st->sdp_payload_type == payload_type) { | |
4934884a RM |
497 | if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) { |
498 | if(!rtsp_st->dynamic_handler->parse_sdp_a_line(st, rtsp_st->dynamic_protocol_context, buf)) { | |
499 | sdp_parse_fmtp(st, p); | |
500 | } | |
501 | } else { | |
ed787542 | 502 | sdp_parse_fmtp(st, p); |
4934884a | 503 | } |
93ced3e8 FB |
504 | } |
505 | } | |
d0deedcb RM |
506 | } else if(strstart(p, "framesize:", &p)) { |
507 | // let dynamic protocol handlers have a stab at the line. | |
508 | get_word(buf1, sizeof(buf1), &p); | |
509 | payload_type = atoi(buf1); | |
510 | for(i = 0; i < s->nb_streams;i++) { | |
511 | st = s->streams[i]; | |
512 | rtsp_st = st->priv_data; | |
513 | if (rtsp_st->sdp_payload_type == payload_type) { | |
514 | if(rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->parse_sdp_a_line) { | |
515 | rtsp_st->dynamic_handler->parse_sdp_a_line(st, rtsp_st->dynamic_protocol_context, buf); | |
516 | } | |
517 | } | |
518 | } | |
31693e00 RM |
519 | } else if(strstart(p, "range:", &p)) { |
520 | int64_t start, end; | |
521 | ||
522 | // this is so that seeking on a streamed file can work. | |
523 | rtsp_parse_range_npt(p, &start, &end); | |
524 | s->start_time= start; | |
525 | s->duration= (end==AV_NOPTS_VALUE)?AV_NOPTS_VALUE:end-start; // AV_NOPTS_VALUE means live broadcast (and can't seek) | |
1617ad97 FB |
526 | } |
527 | break; | |
528 | } | |
529 | } | |
530 | ||
5c91a675 | 531 | static int sdp_parse(AVFormatContext *s, const char *content) |
1617ad97 FB |
532 | { |
533 | const char *p; | |
534 | int letter; | |
535 | char buf[1024], *q; | |
93ced3e8 | 536 | SDPParseState sdp_parse_state, *s1 = &sdp_parse_state; |
115329f1 | 537 | |
93ced3e8 | 538 | memset(s1, 0, sizeof(SDPParseState)); |
1617ad97 FB |
539 | p = content; |
540 | for(;;) { | |
541 | skip_spaces(&p); | |
542 | letter = *p; | |
543 | if (letter == '\0') | |
544 | break; | |
545 | p++; | |
546 | if (*p != '=') | |
547 | goto next_line; | |
548 | p++; | |
549 | /* get the content */ | |
550 | q = buf; | |
b6892136 | 551 | while (*p != '\n' && *p != '\r' && *p != '\0') { |
1617ad97 FB |
552 | if ((q - buf) < sizeof(buf) - 1) |
553 | *q++ = *p; | |
554 | p++; | |
555 | } | |
556 | *q = '\0'; | |
93ced3e8 | 557 | sdp_parse_line(s, s1, letter, buf); |
1617ad97 FB |
558 | next_line: |
559 | while (*p != '\n' && *p != '\0') | |
560 | p++; | |
561 | if (*p == '\n') | |
562 | p++; | |
563 | } | |
564 | return 0; | |
565 | } | |
566 | ||
567 | static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp) | |
568 | { | |
569 | const char *p; | |
570 | int v; | |
571 | ||
572 | p = *pp; | |
573 | skip_spaces(&p); | |
574 | v = strtol(p, (char **)&p, 10); | |
575 | if (*p == '-') { | |
576 | p++; | |
577 | *min_ptr = v; | |
578 | v = strtol(p, (char **)&p, 10); | |
579 | *max_ptr = v; | |
580 | } else { | |
581 | *min_ptr = v; | |
582 | *max_ptr = v; | |
583 | } | |
584 | *pp = p; | |
585 | } | |
586 | ||
587 | /* XXX: only one transport specification is parsed */ | |
588 | static void rtsp_parse_transport(RTSPHeader *reply, const char *p) | |
589 | { | |
590 | char transport_protocol[16]; | |
591 | char profile[16]; | |
592 | char lower_transport[16]; | |
593 | char parameter[16]; | |
594 | RTSPTransportField *th; | |
595 | char buf[256]; | |
115329f1 | 596 | |
1617ad97 | 597 | reply->nb_transports = 0; |
115329f1 | 598 | |
1617ad97 FB |
599 | for(;;) { |
600 | skip_spaces(&p); | |
601 | if (*p == '\0') | |
602 | break; | |
603 | ||
604 | th = &reply->transports[reply->nb_transports]; | |
605 | ||
115329f1 | 606 | get_word_sep(transport_protocol, sizeof(transport_protocol), |
1617ad97 FB |
607 | "/", &p); |
608 | if (*p == '/') | |
609 | p++; | |
610 | get_word_sep(profile, sizeof(profile), "/;,", &p); | |
611 | lower_transport[0] = '\0'; | |
612 | if (*p == '/') { | |
b6892136 | 613 | p++; |
115329f1 | 614 | get_word_sep(lower_transport, sizeof(lower_transport), |
1617ad97 FB |
615 | ";,", &p); |
616 | } | |
b6892136 | 617 | if (!strcasecmp(lower_transport, "TCP")) |
1617ad97 FB |
618 | th->protocol = RTSP_PROTOCOL_RTP_TCP; |
619 | else | |
620 | th->protocol = RTSP_PROTOCOL_RTP_UDP; | |
115329f1 | 621 | |
1617ad97 FB |
622 | if (*p == ';') |
623 | p++; | |
624 | /* get each parameter */ | |
625 | while (*p != '\0' && *p != ',') { | |
626 | get_word_sep(parameter, sizeof(parameter), "=;,", &p); | |
627 | if (!strcmp(parameter, "port")) { | |
628 | if (*p == '=') { | |
629 | p++; | |
630 | rtsp_parse_range(&th->port_min, &th->port_max, &p); | |
631 | } | |
632 | } else if (!strcmp(parameter, "client_port")) { | |
633 | if (*p == '=') { | |
634 | p++; | |
115329f1 | 635 | rtsp_parse_range(&th->client_port_min, |
1617ad97 FB |
636 | &th->client_port_max, &p); |
637 | } | |
638 | } else if (!strcmp(parameter, "server_port")) { | |
639 | if (*p == '=') { | |
640 | p++; | |
115329f1 | 641 | rtsp_parse_range(&th->server_port_min, |
1617ad97 FB |
642 | &th->server_port_max, &p); |
643 | } | |
644 | } else if (!strcmp(parameter, "interleaved")) { | |
645 | if (*p == '=') { | |
646 | p++; | |
115329f1 | 647 | rtsp_parse_range(&th->interleaved_min, |
1617ad97 FB |
648 | &th->interleaved_max, &p); |
649 | } | |
650 | } else if (!strcmp(parameter, "multicast")) { | |
651 | if (th->protocol == RTSP_PROTOCOL_RTP_UDP) | |
652 | th->protocol = RTSP_PROTOCOL_RTP_UDP_MULTICAST; | |
653 | } else if (!strcmp(parameter, "ttl")) { | |
654 | if (*p == '=') { | |
655 | p++; | |
656 | th->ttl = strtol(p, (char **)&p, 10); | |
657 | } | |
658 | } else if (!strcmp(parameter, "destination")) { | |
659 | struct in_addr ipaddr; | |
660 | ||
661 | if (*p == '=') { | |
662 | p++; | |
663 | get_word_sep(buf, sizeof(buf), ";,", &p); | |
115329f1 | 664 | if (inet_aton(buf, &ipaddr)) |
1617ad97 FB |
665 | th->destination = ntohl(ipaddr.s_addr); |
666 | } | |
667 | } | |
668 | while (*p != ';' && *p != '\0' && *p != ',') | |
669 | p++; | |
670 | if (*p == ';') | |
671 | p++; | |
672 | } | |
673 | if (*p == ',') | |
674 | p++; | |
675 | ||
676 | reply->nb_transports++; | |
677 | } | |
678 | } | |
679 | ||
680 | void rtsp_parse_line(RTSPHeader *reply, const char *buf) | |
681 | { | |
682 | const char *p; | |
683 | ||
684 | /* NOTE: we do case independent match for broken servers */ | |
685 | p = buf; | |
686 | if (stristart(p, "Session:", &p)) { | |
687 | get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p); | |
688 | } else if (stristart(p, "Content-Length:", &p)) { | |
689 | reply->content_length = strtol(p, NULL, 10); | |
690 | } else if (stristart(p, "Transport:", &p)) { | |
691 | rtsp_parse_transport(reply, p); | |
692 | } else if (stristart(p, "CSeq:", &p)) { | |
693 | reply->seq = strtol(p, NULL, 10); | |
ff762d6e | 694 | } else if (stristart(p, "Range:", &p)) { |
31693e00 | 695 | rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end); |
1617ad97 FB |
696 | } |
697 | } | |
698 | ||
2a42b5c3 LS |
699 | static int url_readbuf(URLContext *h, unsigned char *buf, int size) |
700 | { | |
701 | int ret, len; | |
702 | ||
703 | len = 0; | |
704 | while (len < size) { | |
705 | ret = url_read(h, buf+len, size-len); | |
706 | if (ret < 1) | |
707 | return ret; | |
708 | len += ret; | |
709 | } | |
710 | return len; | |
711 | } | |
712 | ||
b7b8fc34 FB |
713 | /* skip a RTP/TCP interleaved packet */ |
714 | static void rtsp_skip_packet(AVFormatContext *s) | |
715 | { | |
716 | RTSPState *rt = s->priv_data; | |
717 | int ret, len, len1; | |
718 | uint8_t buf[1024]; | |
719 | ||
2a42b5c3 | 720 | ret = url_readbuf(rt->rtsp_hd, buf, 3); |
b7b8fc34 FB |
721 | if (ret != 3) |
722 | return; | |
723 | len = (buf[1] << 8) | buf[2]; | |
724 | #ifdef DEBUG | |
725 | printf("skipping RTP packet len=%d\n", len); | |
726 | #endif | |
727 | /* skip payload */ | |
728 | while (len > 0) { | |
729 | len1 = len; | |
730 | if (len1 > sizeof(buf)) | |
731 | len1 = sizeof(buf); | |
2a42b5c3 | 732 | ret = url_readbuf(rt->rtsp_hd, buf, len1); |
b7b8fc34 FB |
733 | if (ret != len1) |
734 | return; | |
735 | len -= len1; | |
736 | } | |
737 | } | |
1617ad97 | 738 | |
115329f1 DB |
739 | static void rtsp_send_cmd(AVFormatContext *s, |
740 | const char *cmd, RTSPHeader *reply, | |
1617ad97 FB |
741 | unsigned char **content_ptr) |
742 | { | |
743 | RTSPState *rt = s->priv_data; | |
744 | char buf[4096], buf1[1024], *q; | |
745 | unsigned char ch; | |
746 | const char *p; | |
747 | int content_length, line_count; | |
748 | unsigned char *content = NULL; | |
749 | ||
750 | memset(reply, 0, sizeof(RTSPHeader)); | |
751 | ||
752 | rt->seq++; | |
75e61b0e | 753 | av_strlcpy(buf, cmd, sizeof(buf)); |
b6892136 | 754 | snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq); |
75e61b0e | 755 | av_strlcat(buf, buf1, sizeof(buf)); |
1617ad97 | 756 | if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) { |
b6892136 | 757 | snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id); |
75e61b0e | 758 | av_strlcat(buf, buf1, sizeof(buf)); |
1617ad97 | 759 | } |
75e61b0e | 760 | av_strlcat(buf, "\r\n", sizeof(buf)); |
1617ad97 FB |
761 | #ifdef DEBUG |
762 | printf("Sending:\n%s--\n", buf); | |
763 | #endif | |
764 | url_write(rt->rtsp_hd, buf, strlen(buf)); | |
765 | ||
766 | /* parse reply (XXX: use buffers) */ | |
767 | line_count = 0; | |
768 | rt->last_reply[0] = '\0'; | |
769 | for(;;) { | |
770 | q = buf; | |
771 | for(;;) { | |
2a42b5c3 | 772 | if (url_readbuf(rt->rtsp_hd, &ch, 1) != 1) |
1617ad97 FB |
773 | break; |
774 | if (ch == '\n') | |
775 | break; | |
b7b8fc34 FB |
776 | if (ch == '$') { |
777 | /* XXX: only parse it if first char on line ? */ | |
778 | rtsp_skip_packet(s); | |
779 | } else if (ch != '\r') { | |
1617ad97 FB |
780 | if ((q - buf) < sizeof(buf) - 1) |
781 | *q++ = ch; | |
782 | } | |
783 | } | |
784 | *q = '\0'; | |
785 | #ifdef DEBUG | |
786 | printf("line='%s'\n", buf); | |
787 | #endif | |
788 | /* test if last line */ | |
789 | if (buf[0] == '\0') | |
790 | break; | |
791 | p = buf; | |
792 | if (line_count == 0) { | |
793 | /* get reply code */ | |
794 | get_word(buf1, sizeof(buf1), &p); | |
795 | get_word(buf1, sizeof(buf1), &p); | |
796 | reply->status_code = atoi(buf1); | |
797 | } else { | |
798 | rtsp_parse_line(reply, p); | |
75e61b0e MR |
799 | av_strlcat(rt->last_reply, p, sizeof(rt->last_reply)); |
800 | av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply)); | |
1617ad97 FB |
801 | } |
802 | line_count++; | |
803 | } | |
115329f1 | 804 | |
1617ad97 | 805 | if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0') |
75e61b0e | 806 | av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id)); |
115329f1 | 807 | |
1617ad97 FB |
808 | content_length = reply->content_length; |
809 | if (content_length > 0) { | |
810 | /* leave some room for a trailing '\0' (useful for simple parsing) */ | |
811 | content = av_malloc(content_length + 1); | |
2a42b5c3 | 812 | (void)url_readbuf(rt->rtsp_hd, content, content_length); |
1617ad97 FB |
813 | content[content_length] = '\0'; |
814 | } | |
815 | if (content_ptr) | |
816 | *content_ptr = content; | |
817 | } | |
818 | ||
1617ad97 | 819 | |
8b1ab7bf FB |
820 | /* close and free RTSP streams */ |
821 | static void rtsp_close_streams(RTSPState *rt) | |
822 | { | |
823 | int i; | |
824 | RTSPStream *rtsp_st; | |
825 | ||
826 | for(i=0;i<rt->nb_rtsp_streams;i++) { | |
827 | rtsp_st = rt->rtsp_streams[i]; | |
828 | if (rtsp_st) { | |
829 | if (rtsp_st->rtp_ctx) | |
830 | rtp_parse_close(rtsp_st->rtp_ctx); | |
831 | if (rtsp_st->rtp_handle) | |
832 | url_close(rtsp_st->rtp_handle); | |
4934884a RM |
833 | if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) |
834 | rtsp_st->dynamic_handler->close(rtsp_st->dynamic_protocol_context); | |
8b1ab7bf FB |
835 | } |
836 | av_free(rtsp_st); | |
837 | } | |
838 | av_free(rt->rtsp_streams); | |
839 | } | |
840 | ||
1617ad97 FB |
841 | static int rtsp_read_header(AVFormatContext *s, |
842 | AVFormatParameters *ap) | |
843 | { | |
844 | RTSPState *rt = s->priv_data; | |
badc9ae2 | 845 | char host[1024], path[1024], tcpname[1024], cmd[2048], *option_list, *option; |
1617ad97 | 846 | URLContext *rtsp_hd; |
d1ccf0e0 | 847 | int port, i, j, ret, err; |
1617ad97 FB |
848 | RTSPHeader reply1, *reply = &reply1; |
849 | unsigned char *content = NULL; | |
1617ad97 | 850 | RTSPStream *rtsp_st; |
8bd32c04 | 851 | int protocol_mask = 0; |
8b1ab7bf | 852 | AVStream *st; |
1617ad97 | 853 | |
1617ad97 | 854 | /* extract hostname and port */ |
6ba5cbc6 | 855 | url_split(NULL, 0, NULL, 0, |
1617ad97 FB |
856 | host, sizeof(host), &port, path, sizeof(path), s->filename); |
857 | if (port < 0) | |
858 | port = RTSP_DEFAULT_PORT; | |
859 | ||
badc9ae2 TV |
860 | /* search for options */ |
861 | option_list = strchr(path, '?'); | |
862 | if (option_list) { | |
863 | /* remove the options from the path */ | |
864 | *option_list++ = 0; | |
865 | while(option_list) { | |
866 | /* move the option pointer */ | |
867 | option = option_list; | |
868 | option_list = strchr(option_list, '&'); | |
869 | if (option_list) | |
870 | *(option_list++) = 0; | |
871 | /* handle the options */ | |
8bd32c04 TV |
872 | if (strcmp(option, "udp") == 0) |
873 | protocol_mask = (1<< RTSP_PROTOCOL_RTP_UDP); | |
874 | else if (strcmp(option, "multicast") == 0) | |
875 | protocol_mask = (1<< RTSP_PROTOCOL_RTP_UDP_MULTICAST); | |
876 | else if (strcmp(option, "tcp") == 0) | |
877 | protocol_mask = (1<< RTSP_PROTOCOL_RTP_TCP); | |
badc9ae2 TV |
878 | } |
879 | } | |
880 | ||
8bd32c04 TV |
881 | if (!protocol_mask) |
882 | protocol_mask = rtsp_default_protocols; | |
883 | ||
1617ad97 FB |
884 | /* open the tcp connexion */ |
885 | snprintf(tcpname, sizeof(tcpname), "tcp://%s:%d", host, port); | |
886 | if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) | |
887 | return AVERROR_IO; | |
888 | rt->rtsp_hd = rtsp_hd; | |
889 | rt->seq = 0; | |
115329f1 | 890 | |
1617ad97 | 891 | /* describe the stream */ |
115329f1 | 892 | snprintf(cmd, sizeof(cmd), |
b6892136 FB |
893 | "DESCRIBE %s RTSP/1.0\r\n" |
894 | "Accept: application/sdp\r\n", | |
1617ad97 FB |
895 | s->filename); |
896 | rtsp_send_cmd(s, cmd, reply, &content); | |
897 | if (!content) { | |
898 | err = AVERROR_INVALIDDATA; | |
899 | goto fail; | |
900 | } | |
901 | if (reply->status_code != RTSP_STATUS_OK) { | |
902 | err = AVERROR_INVALIDDATA; | |
903 | goto fail; | |
904 | } | |
115329f1 | 905 | |
1617ad97 FB |
906 | /* now we got the SDP description, we parse it */ |
907 | ret = sdp_parse(s, (const char *)content); | |
908 | av_freep(&content); | |
909 | if (ret < 0) { | |
910 | err = AVERROR_INVALIDDATA; | |
911 | goto fail; | |
912 | } | |
115329f1 | 913 | |
1617ad97 FB |
914 | /* for each stream, make the setup request */ |
915 | /* XXX: we assume the same server is used for the control of each | |
916 | RTSP stream */ | |
d1ccf0e0 RD |
917 | |
918 | for(j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) { | |
1617ad97 FB |
919 | char transport[2048]; |
920 | ||
8b1ab7bf | 921 | rtsp_st = rt->rtsp_streams[i]; |
1617ad97 FB |
922 | |
923 | /* compute available transports */ | |
924 | transport[0] = '\0'; | |
925 | ||
926 | /* RTP/UDP */ | |
927 | if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP)) { | |
85fb7b34 | 928 | char buf[256]; |
85fb7b34 FB |
929 | |
930 | /* first try in specified port range */ | |
d1ccf0e0 RD |
931 | if (RTSP_RTP_PORT_MIN != 0) { |
932 | while(j <= RTSP_RTP_PORT_MAX) { | |
85fb7b34 | 933 | snprintf(buf, sizeof(buf), "rtp://?localport=%d", j); |
dbf30963 | 934 | if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0) { |
d1ccf0e0 | 935 | j += 2; /* we will use two port by rtp stream (rtp and rtcp) */ |
85fb7b34 | 936 | goto rtp_opened; |
d1ccf0e0 | 937 | } |
85fb7b34 | 938 | } |
1617ad97 | 939 | } |
85fb7b34 | 940 | |
d1ccf0e0 RD |
941 | /* then try on any port |
942 | ** if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) { | |
943 | ** err = AVERROR_INVALIDDATA; | |
944 | ** goto fail; | |
945 | ** } | |
946 | */ | |
85fb7b34 FB |
947 | |
948 | rtp_opened: | |
8b1ab7bf | 949 | port = rtp_get_local_port(rtsp_st->rtp_handle); |
1617ad97 | 950 | if (transport[0] != '\0') |
75e61b0e | 951 | av_strlcat(transport, ",", sizeof(transport)); |
1617ad97 FB |
952 | snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1, |
953 | "RTP/AVP/UDP;unicast;client_port=%d-%d", | |
954 | port, port + 1); | |
955 | } | |
956 | ||
957 | /* RTP/TCP */ | |
d1ccf0e0 | 958 | else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_TCP)) { |
1617ad97 | 959 | if (transport[0] != '\0') |
75e61b0e | 960 | av_strlcat(transport, ",", sizeof(transport)); |
1617ad97 FB |
961 | snprintf(transport + strlen(transport), sizeof(transport) - strlen(transport) - 1, |
962 | "RTP/AVP/TCP"); | |
963 | } | |
964 | ||
d1ccf0e0 | 965 | else if (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP_MULTICAST)) { |
1617ad97 | 966 | if (transport[0] != '\0') |
75e61b0e | 967 | av_strlcat(transport, ",", sizeof(transport)); |
115329f1 | 968 | snprintf(transport + strlen(transport), |
1617ad97 FB |
969 | sizeof(transport) - strlen(transport) - 1, |
970 | "RTP/AVP/UDP;multicast"); | |
971 | } | |
115329f1 | 972 | snprintf(cmd, sizeof(cmd), |
b6892136 FB |
973 | "SETUP %s RTSP/1.0\r\n" |
974 | "Transport: %s\r\n", | |
1617ad97 FB |
975 | rtsp_st->control_url, transport); |
976 | rtsp_send_cmd(s, cmd, reply, NULL); | |
977 | if (reply->status_code != RTSP_STATUS_OK || | |
978 | reply->nb_transports != 1) { | |
979 | err = AVERROR_INVALIDDATA; | |
980 | goto fail; | |
981 | } | |
982 | ||
983 | /* XXX: same protocol for all streams is required */ | |
984 | if (i > 0) { | |
985 | if (reply->transports[0].protocol != rt->protocol) { | |
986 | err = AVERROR_INVALIDDATA; | |
987 | goto fail; | |
988 | } | |
989 | } else { | |
990 | rt->protocol = reply->transports[0].protocol; | |
991 | } | |
992 | ||
993 | /* close RTP connection if not choosen */ | |
994 | if (reply->transports[0].protocol != RTSP_PROTOCOL_RTP_UDP && | |
995 | (protocol_mask & (1 << RTSP_PROTOCOL_RTP_UDP))) { | |
8b1ab7bf FB |
996 | url_close(rtsp_st->rtp_handle); |
997 | rtsp_st->rtp_handle = NULL; | |
1617ad97 FB |
998 | } |
999 | ||
1000 | switch(reply->transports[0].protocol) { | |
1001 | case RTSP_PROTOCOL_RTP_TCP: | |
1617ad97 FB |
1002 | rtsp_st->interleaved_min = reply->transports[0].interleaved_min; |
1003 | rtsp_st->interleaved_max = reply->transports[0].interleaved_max; | |
1004 | break; | |
115329f1 | 1005 | |
1617ad97 FB |
1006 | case RTSP_PROTOCOL_RTP_UDP: |
1007 | { | |
1008 | char url[1024]; | |
115329f1 | 1009 | |
1617ad97 | 1010 | /* XXX: also use address if specified */ |
115329f1 | 1011 | snprintf(url, sizeof(url), "rtp://%s:%d", |
1617ad97 | 1012 | host, reply->transports[0].server_port_min); |
8b1ab7bf | 1013 | if (rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) { |
1617ad97 FB |
1014 | err = AVERROR_INVALIDDATA; |
1015 | goto fail; | |
1016 | } | |
1017 | } | |
1018 | break; | |
1019 | case RTSP_PROTOCOL_RTP_UDP_MULTICAST: | |
1020 | { | |
1021 | char url[1024]; | |
1022 | int ttl; | |
1023 | ||
1617ad97 FB |
1024 | ttl = reply->transports[0].ttl; |
1025 | if (!ttl) | |
1026 | ttl = 16; | |
115329f1 DB |
1027 | snprintf(url, sizeof(url), "rtp://%s:%d?multicast=1&ttl=%d", |
1028 | host, | |
1617ad97 FB |
1029 | reply->transports[0].server_port_min, |
1030 | ttl); | |
dbf30963 | 1031 | if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) { |
1617ad97 FB |
1032 | err = AVERROR_INVALIDDATA; |
1033 | goto fail; | |
1034 | } | |
1035 | } | |
1036 | break; | |
1037 | } | |
8b1ab7bf FB |
1038 | /* open the RTP context */ |
1039 | st = NULL; | |
1040 | if (rtsp_st->stream_index >= 0) | |
1041 | st = s->streams[rtsp_st->stream_index]; | |
1042 | if (!st) | |
1043 | s->ctx_flags |= AVFMTCTX_NOHEADER; | |
dbf30963 | 1044 | rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data); |
d1ccf0e0 | 1045 | |
8b1ab7bf FB |
1046 | if (!rtsp_st->rtp_ctx) { |
1047 | err = AVERROR_NOMEM; | |
1048 | goto fail; | |
4934884a RM |
1049 | } else { |
1050 | if(rtsp_st->dynamic_handler) { | |
1051 | rtsp_st->rtp_ctx->dynamic_protocol_context= rtsp_st->dynamic_protocol_context; | |
1052 | rtsp_st->rtp_ctx->parse_packet= rtsp_st->dynamic_handler->parse_packet; | |
1053 | } | |
8b1ab7bf | 1054 | } |
1617ad97 FB |
1055 | } |
1056 | ||
ff762d6e FB |
1057 | rt->state = RTSP_STATE_IDLE; |
1058 | rt->seek_timestamp = 0; /* default is to start stream at position | |
1059 | zero */ | |
c04c3282 | 1060 | if (ap->initial_pause) { |
ff762d6e FB |
1061 | /* do not start immediately */ |
1062 | } else { | |
1063 | if (rtsp_read_play(s) < 0) { | |
1064 | err = AVERROR_INVALIDDATA; | |
1617ad97 FB |
1065 | goto fail; |
1066 | } | |
1067 | } | |
1617ad97 FB |
1068 | return 0; |
1069 | fail: | |
8b1ab7bf | 1070 | rtsp_close_streams(rt); |
1617ad97 FB |
1071 | av_freep(&content); |
1072 | url_close(rt->rtsp_hd); | |
1073 | return err; | |
1074 | } | |
1075 | ||
8b1ab7bf FB |
1076 | static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, |
1077 | uint8_t *buf, int buf_size) | |
1617ad97 FB |
1078 | { |
1079 | RTSPState *rt = s->priv_data; | |
b6892136 | 1080 | int id, len, i, ret; |
1617ad97 | 1081 | RTSPStream *rtsp_st; |
1617ad97 | 1082 | |
b6892136 FB |
1083 | #ifdef DEBUG_RTP_TCP |
1084 | printf("tcp_read_packet:\n"); | |
1085 | #endif | |
1617ad97 FB |
1086 | redo: |
1087 | for(;;) { | |
2a42b5c3 | 1088 | ret = url_readbuf(rt->rtsp_hd, buf, 1); |
b6892136 FB |
1089 | #ifdef DEBUG_RTP_TCP |
1090 | printf("ret=%d c=%02x [%c]\n", ret, buf[0], buf[0]); | |
1091 | #endif | |
1092 | if (ret != 1) | |
8b1ab7bf | 1093 | return -1; |
b6892136 | 1094 | if (buf[0] == '$') |
1617ad97 FB |
1095 | break; |
1096 | } | |
2a42b5c3 | 1097 | ret = url_readbuf(rt->rtsp_hd, buf, 3); |
b6892136 | 1098 | if (ret != 3) |
8b1ab7bf | 1099 | return -1; |
b6892136 FB |
1100 | id = buf[0]; |
1101 | len = (buf[1] << 8) | buf[2]; | |
1102 | #ifdef DEBUG_RTP_TCP | |
1103 | printf("id=%d len=%d\n", id, len); | |
1104 | #endif | |
8b1ab7bf | 1105 | if (len > buf_size || len < 12) |
1617ad97 FB |
1106 | goto redo; |
1107 | /* get the data */ | |
2a42b5c3 | 1108 | ret = url_readbuf(rt->rtsp_hd, buf, len); |
b6892136 | 1109 | if (ret != len) |
8b1ab7bf | 1110 | return -1; |
115329f1 | 1111 | |
1617ad97 | 1112 | /* find the matching stream */ |
8b1ab7bf FB |
1113 | for(i = 0; i < rt->nb_rtsp_streams; i++) { |
1114 | rtsp_st = rt->rtsp_streams[i]; | |
115329f1 DB |
1115 | if (id >= rtsp_st->interleaved_min && |
1116 | id <= rtsp_st->interleaved_max) | |
1617ad97 FB |
1117 | goto found; |
1118 | } | |
1119 | goto redo; | |
1120 | found: | |
8b1ab7bf FB |
1121 | *prtsp_st = rtsp_st; |
1122 | return len; | |
1617ad97 FB |
1123 | } |
1124 | ||
115329f1 | 1125 | static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, |
8b1ab7bf | 1126 | uint8_t *buf, int buf_size) |
1617ad97 | 1127 | { |
8b1ab7bf | 1128 | RTSPState *rt = s->priv_data; |
1617ad97 FB |
1129 | RTSPStream *rtsp_st; |
1130 | fd_set rfds; | |
1131 | int fd1, fd2, fd_max, n, i, ret; | |
1617ad97 FB |
1132 | struct timeval tv; |
1133 | ||
1134 | for(;;) { | |
b7b8fc34 | 1135 | if (url_interrupt_cb()) |
8b1ab7bf | 1136 | return -1; |
1617ad97 FB |
1137 | FD_ZERO(&rfds); |
1138 | fd_max = -1; | |
8b1ab7bf FB |
1139 | for(i = 0; i < rt->nb_rtsp_streams; i++) { |
1140 | rtsp_st = rt->rtsp_streams[i]; | |
1617ad97 | 1141 | /* currently, we cannot probe RTCP handle because of blocking restrictions */ |
8b1ab7bf | 1142 | rtp_get_file_handles(rtsp_st->rtp_handle, &fd1, &fd2); |
1617ad97 FB |
1143 | if (fd1 > fd_max) |
1144 | fd_max = fd1; | |
1145 | FD_SET(fd1, &rfds); | |
1146 | } | |
1617ad97 | 1147 | tv.tv_sec = 0; |
b7b8fc34 | 1148 | tv.tv_usec = 100 * 1000; |
1617ad97 FB |
1149 | n = select(fd_max + 1, &rfds, NULL, NULL, &tv); |
1150 | if (n > 0) { | |
8b1ab7bf FB |
1151 | for(i = 0; i < rt->nb_rtsp_streams; i++) { |
1152 | rtsp_st = rt->rtsp_streams[i]; | |
1153 | rtp_get_file_handles(rtsp_st->rtp_handle, &fd1, &fd2); | |
1617ad97 | 1154 | if (FD_ISSET(fd1, &rfds)) { |
8b1ab7bf FB |
1155 | ret = url_read(rtsp_st->rtp_handle, buf, buf_size); |
1156 | if (ret > 0) { | |
1157 | *prtsp_st = rtsp_st; | |
1617ad97 FB |
1158 | return ret; |
1159 | } | |
1160 | } | |
1161 | } | |
1162 | } | |
1163 | } | |
1164 | } | |
1165 | ||
1166 | static int rtsp_read_packet(AVFormatContext *s, | |
1167 | AVPacket *pkt) | |
1168 | { | |
1169 | RTSPState *rt = s->priv_data; | |
8b1ab7bf FB |
1170 | RTSPStream *rtsp_st; |
1171 | int ret, len; | |
1172 | uint8_t buf[RTP_MAX_PACKET_LENGTH]; | |
1173 | ||
1174 | /* get next frames from the same RTP packet */ | |
1175 | if (rt->cur_rtp) { | |
1176 | ret = rtp_parse_packet(rt->cur_rtp, pkt, NULL, 0); | |
1177 | if (ret == 0) { | |
1178 | rt->cur_rtp = NULL; | |
1179 | return 0; | |
1180 | } else if (ret == 1) { | |
1181 | return 0; | |
1182 | } else { | |
1183 | rt->cur_rtp = NULL; | |
1184 | } | |
1185 | } | |
1617ad97 | 1186 | |
8b1ab7bf FB |
1187 | /* read next RTP packet */ |
1188 | redo: | |
1617ad97 FB |
1189 | switch(rt->protocol) { |
1190 | default: | |
1191 | case RTSP_PROTOCOL_RTP_TCP: | |
8b1ab7bf | 1192 | len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf)); |
1617ad97 FB |
1193 | break; |
1194 | case RTSP_PROTOCOL_RTP_UDP: | |
8b1ab7bf FB |
1195 | case RTSP_PROTOCOL_RTP_UDP_MULTICAST: |
1196 | len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf)); | |
dbf30963 T |
1197 | if (rtsp_st->rtp_ctx) |
1198 | rtp_check_and_send_back_rr(rtsp_st->rtp_ctx, len); | |
1617ad97 FB |
1199 | break; |
1200 | } | |
8b1ab7bf FB |
1201 | if (len < 0) |
1202 | return AVERROR_IO; | |
1203 | ret = rtp_parse_packet(rtsp_st->rtp_ctx, pkt, buf, len); | |
1204 | if (ret < 0) | |
1205 | goto redo; | |
1206 | if (ret == 1) { | |
1207 | /* more packets may follow, so we save the RTP context */ | |
1208 | rt->cur_rtp = rtsp_st->rtp_ctx; | |
1209 | } | |
1210 | return 0; | |
1617ad97 FB |
1211 | } |
1212 | ||
ff762d6e | 1213 | static int rtsp_read_play(AVFormatContext *s) |
b7b8fc34 | 1214 | { |
ff762d6e | 1215 | RTSPState *rt = s->priv_data; |
b7b8fc34 FB |
1216 | RTSPHeader reply1, *reply = &reply1; |
1217 | char cmd[1024]; | |
1218 | ||
bc874dae | 1219 | av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state); |
ff762d6e FB |
1220 | |
1221 | if (rt->state == RTSP_STATE_PAUSED) { | |
115329f1 | 1222 | snprintf(cmd, sizeof(cmd), |
ff762d6e FB |
1223 | "PLAY %s RTSP/1.0\r\n", |
1224 | s->filename); | |
1225 | } else { | |
115329f1 | 1226 | snprintf(cmd, sizeof(cmd), |
ff762d6e FB |
1227 | "PLAY %s RTSP/1.0\r\n" |
1228 | "Range: npt=%0.3f-\r\n", | |
1229 | s->filename, | |
1230 | (double)rt->seek_timestamp / AV_TIME_BASE); | |
1231 | } | |
b7b8fc34 FB |
1232 | rtsp_send_cmd(s, cmd, reply, NULL); |
1233 | if (reply->status_code != RTSP_STATUS_OK) { | |
1234 | return -1; | |
1235 | } else { | |
ff762d6e | 1236 | rt->state = RTSP_STATE_PLAYING; |
b7b8fc34 FB |
1237 | return 0; |
1238 | } | |
1239 | } | |
1240 | ||
ff762d6e FB |
1241 | /* pause the stream */ |
1242 | static int rtsp_read_pause(AVFormatContext *s) | |
b7b8fc34 | 1243 | { |
ff762d6e | 1244 | RTSPState *rt = s->priv_data; |
b7b8fc34 FB |
1245 | RTSPHeader reply1, *reply = &reply1; |
1246 | char cmd[1024]; | |
1247 | ||
b7b8fc34 | 1248 | rt = s->priv_data; |
115329f1 | 1249 | |
ff762d6e FB |
1250 | if (rt->state != RTSP_STATE_PLAYING) |
1251 | return 0; | |
1252 | ||
115329f1 | 1253 | snprintf(cmd, sizeof(cmd), |
ff762d6e | 1254 | "PAUSE %s RTSP/1.0\r\n", |
b7b8fc34 FB |
1255 | s->filename); |
1256 | rtsp_send_cmd(s, cmd, reply, NULL); | |
1257 | if (reply->status_code != RTSP_STATUS_OK) { | |
1258 | return -1; | |
1259 | } else { | |
ff762d6e | 1260 | rt->state = RTSP_STATE_PAUSED; |
b7b8fc34 FB |
1261 | return 0; |
1262 | } | |
1263 | } | |
1264 | ||
115329f1 | 1265 | static int rtsp_read_seek(AVFormatContext *s, int stream_index, |
7b3c1382 | 1266 | int64_t timestamp, int flags) |
ff762d6e FB |
1267 | { |
1268 | RTSPState *rt = s->priv_data; | |
115329f1 | 1269 | |
ff762d6e FB |
1270 | rt->seek_timestamp = timestamp; |
1271 | switch(rt->state) { | |
1272 | default: | |
1273 | case RTSP_STATE_IDLE: | |
1274 | break; | |
1275 | case RTSP_STATE_PLAYING: | |
1276 | if (rtsp_read_play(s) != 0) | |
1277 | return -1; | |
1278 | break; | |
1279 | case RTSP_STATE_PAUSED: | |
1280 | rt->state = RTSP_STATE_IDLE; | |
1281 | break; | |
1282 | } | |
1283 | return 0; | |
1284 | } | |
1285 | ||
1617ad97 FB |
1286 | static int rtsp_read_close(AVFormatContext *s) |
1287 | { | |
1288 | RTSPState *rt = s->priv_data; | |
1617ad97 | 1289 | RTSPHeader reply1, *reply = &reply1; |
1617ad97 FB |
1290 | char cmd[1024]; |
1291 | ||
b6892136 | 1292 | #if 0 |
1617ad97 FB |
1293 | /* NOTE: it is valid to flush the buffer here */ |
1294 | if (rt->protocol == RTSP_PROTOCOL_RTP_TCP) { | |
1295 | url_fclose(&rt->rtsp_gb); | |
1296 | } | |
b6892136 | 1297 | #endif |
115329f1 | 1298 | snprintf(cmd, sizeof(cmd), |
b6892136 | 1299 | "TEARDOWN %s RTSP/1.0\r\n", |
1617ad97 FB |
1300 | s->filename); |
1301 | rtsp_send_cmd(s, cmd, reply, NULL); | |
1302 | ||
8b1ab7bf | 1303 | rtsp_close_streams(rt); |
1617ad97 FB |
1304 | url_close(rt->rtsp_hd); |
1305 | return 0; | |
1306 | } | |
1307 | ||
96862926 | 1308 | #ifdef CONFIG_RTSP_DEMUXER |
d2a067d1 | 1309 | AVInputFormat rtsp_demuxer = { |
1617ad97 FB |
1310 | "rtsp", |
1311 | "RTSP input format", | |
1312 | sizeof(RTSPState), | |
1313 | rtsp_probe, | |
1314 | rtsp_read_header, | |
1315 | rtsp_read_packet, | |
1316 | rtsp_read_close, | |
ff762d6e | 1317 | rtsp_read_seek, |
bb76a117 | 1318 | .flags = AVFMT_NOFILE, |
ff762d6e FB |
1319 | .read_play = rtsp_read_play, |
1320 | .read_pause = rtsp_read_pause, | |
1617ad97 | 1321 | }; |
96862926 | 1322 | #endif |
1617ad97 | 1323 | |
cb1fdc61 | 1324 | static int sdp_probe(AVProbeData *p1) |
93ced3e8 | 1325 | { |
0e1ceacd | 1326 | const char *p = p1->buf, *p_end = p1->buf + p1->buf_size; |
cb1fdc61 FB |
1327 | |
1328 | /* we look for a line beginning "c=IN IP4" */ | |
0e1ceacd MN |
1329 | while (p < p_end && *p != '\0') { |
1330 | if (p + sizeof("c=IN IP4") - 1 < p_end && strstart(p, "c=IN IP4", NULL)) | |
cb1fdc61 | 1331 | return AVPROBE_SCORE_MAX / 2; |
0e1ceacd MN |
1332 | |
1333 | while(p < p_end - 1 && *p != '\n') p++; | |
1334 | if (++p >= p_end) | |
cb1fdc61 | 1335 | break; |
cb1fdc61 FB |
1336 | if (*p == '\r') |
1337 | p++; | |
1338 | } | |
93ced3e8 FB |
1339 | return 0; |
1340 | } | |
1341 | ||
1342 | #define SDP_MAX_SIZE 8192 | |
1343 | ||
1344 | static int sdp_read_header(AVFormatContext *s, | |
1345 | AVFormatParameters *ap) | |
1346 | { | |
8b1ab7bf | 1347 | RTSPState *rt = s->priv_data; |
93ced3e8 FB |
1348 | RTSPStream *rtsp_st; |
1349 | int size, i, err; | |
1350 | char *content; | |
1351 | char url[1024]; | |
8b1ab7bf | 1352 | AVStream *st; |
93ced3e8 FB |
1353 | |
1354 | /* read the whole sdp file */ | |
1355 | /* XXX: better loading */ | |
1356 | content = av_malloc(SDP_MAX_SIZE); | |
1357 | size = get_buffer(&s->pb, content, SDP_MAX_SIZE - 1); | |
1358 | if (size <= 0) { | |
1359 | av_free(content); | |
1360 | return AVERROR_INVALIDDATA; | |
1361 | } | |
1362 | content[size] ='\0'; | |
1363 | ||
1364 | sdp_parse(s, content); | |
1365 | av_free(content); | |
1366 | ||
1367 | /* open each RTP stream */ | |
8b1ab7bf FB |
1368 | for(i=0;i<rt->nb_rtsp_streams;i++) { |
1369 | rtsp_st = rt->rtsp_streams[i]; | |
115329f1 DB |
1370 | |
1371 | snprintf(url, sizeof(url), "rtp://%s:%d?multicast=1&ttl=%d", | |
1372 | inet_ntoa(rtsp_st->sdp_ip), | |
93ced3e8 FB |
1373 | rtsp_st->sdp_port, |
1374 | rtsp_st->sdp_ttl); | |
dbf30963 | 1375 | if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) { |
93ced3e8 FB |
1376 | err = AVERROR_INVALIDDATA; |
1377 | goto fail; | |
1378 | } | |
8b1ab7bf FB |
1379 | /* open the RTP context */ |
1380 | st = NULL; | |
1381 | if (rtsp_st->stream_index >= 0) | |
1382 | st = s->streams[rtsp_st->stream_index]; | |
1383 | if (!st) | |
1384 | s->ctx_flags |= AVFMTCTX_NOHEADER; | |
dbf30963 | 1385 | rtsp_st->rtp_ctx = rtp_parse_open(s, st, rtsp_st->rtp_handle, rtsp_st->sdp_payload_type, &rtsp_st->rtp_payload_data); |
8b1ab7bf FB |
1386 | if (!rtsp_st->rtp_ctx) { |
1387 | err = AVERROR_NOMEM; | |
1388 | goto fail; | |
4934884a RM |
1389 | } else { |
1390 | if(rtsp_st->dynamic_handler) { | |
1391 | rtsp_st->rtp_ctx->dynamic_protocol_context= rtsp_st->dynamic_protocol_context; | |
1392 | rtsp_st->rtp_ctx->parse_packet= rtsp_st->dynamic_handler->parse_packet; | |
1393 | } | |
8b1ab7bf | 1394 | } |
93ced3e8 FB |
1395 | } |
1396 | return 0; | |
1397 | fail: | |
8b1ab7bf | 1398 | rtsp_close_streams(rt); |
93ced3e8 FB |
1399 | return err; |
1400 | } | |
1401 | ||
1402 | static int sdp_read_packet(AVFormatContext *s, | |
1403 | AVPacket *pkt) | |
1404 | { | |
8b1ab7bf | 1405 | return rtsp_read_packet(s, pkt); |
93ced3e8 FB |
1406 | } |
1407 | ||
1408 | static int sdp_read_close(AVFormatContext *s) | |
1409 | { | |
8b1ab7bf FB |
1410 | RTSPState *rt = s->priv_data; |
1411 | rtsp_close_streams(rt); | |
93ced3e8 FB |
1412 | return 0; |
1413 | } | |
1414 | ||
ff70e601 MR |
1415 | #ifdef CONFIG_SDP_DEMUXER |
1416 | AVInputFormat sdp_demuxer = { | |
93ced3e8 FB |
1417 | "sdp", |
1418 | "SDP", | |
1419 | sizeof(RTSPState), | |
1420 | sdp_probe, | |
1421 | sdp_read_header, | |
1422 | sdp_read_packet, | |
1423 | sdp_read_close, | |
1424 | }; | |
ff70e601 | 1425 | #endif |
93ced3e8 | 1426 | |
e7047005 | 1427 | #ifdef CONFIG_REDIR_DEMUXER |
1617ad97 FB |
1428 | /* dummy redirector format (used directly in av_open_input_file now) */ |
1429 | static int redir_probe(AVProbeData *pd) | |
1430 | { | |
1431 | const char *p; | |
1432 | p = pd->buf; | |
1433 | while (redir_isspace(*p)) | |
1434 | p++; | |
1435 | if (strstart(p, "http://", NULL) || | |
1436 | strstart(p, "rtsp://", NULL)) | |
1437 | return AVPROBE_SCORE_MAX; | |
1438 | return 0; | |
1439 | } | |
1440 | ||
1441 | /* called from utils.c */ | |
1442 | int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f) | |
1443 | { | |
1444 | char buf[4096], *q; | |
1445 | int c; | |
1446 | AVFormatContext *ic = NULL; | |
1447 | ||
1448 | /* parse each URL and try to open it */ | |
1449 | c = url_fgetc(f); | |
1450 | while (c != URL_EOF) { | |
1451 | /* skip spaces */ | |
1452 | for(;;) { | |
1453 | if (!redir_isspace(c)) | |
1454 | break; | |
1455 | c = url_fgetc(f); | |
1456 | } | |
1457 | if (c == URL_EOF) | |
1458 | break; | |
1459 | /* record url */ | |
1460 | q = buf; | |
1461 | for(;;) { | |
1462 | if (c == URL_EOF || redir_isspace(c)) | |
1463 | break; | |
1464 | if ((q - buf) < sizeof(buf) - 1) | |
1465 | *q++ = c; | |
1466 | c = url_fgetc(f); | |
1467 | } | |
1468 | *q = '\0'; | |
1469 | //printf("URL='%s'\n", buf); | |
1470 | /* try to open the media file */ | |
1471 | if (av_open_input_file(&ic, buf, NULL, 0, NULL) == 0) | |
1472 | break; | |
1473 | } | |
1474 | *ic_ptr = ic; | |
1475 | if (!ic) | |
1476 | return AVERROR_IO; | |
1477 | else | |
1478 | return 0; | |
1479 | } | |
1480 | ||
d2a067d1 | 1481 | AVInputFormat redir_demuxer = { |
1617ad97 FB |
1482 | "redir", |
1483 | "Redirector format", | |
1484 | 0, | |
1485 | redir_probe, | |
1486 | NULL, | |
1487 | NULL, | |
1488 | NULL, | |
1489 | }; | |
e7047005 | 1490 | #endif |