3 * Copyright (c) 2002 Fabrice Bellard.
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed by inet_aton() */
25 #include "libavutil/avstring.h"
29 #include <unistd.h> /* for select() prototype */
34 #include "rtp_internal.h"
38 //#define DEBUG_RTP_TCP
40 enum RTSPClientState
{
47 RTSP_SERVER_RTP
, /*< Standard-compliant RTP-server */
48 RTSP_SERVER_RDT
, /*< Realmedia-style server */
52 typedef struct RTSPState
{
53 URLContext
*rtsp_hd
; /* RTSP TCP connexion handle */
55 struct RTSPStream
**rtsp_streams
;
57 enum RTSPClientState state
;
58 int64_t seek_timestamp
;
60 /* XXX: currently we use unbuffered input */
61 // ByteIOContext rtsp_gb;
62 int seq
; /* RTSP command sequence number */
64 enum RTSPProtocol protocol
;
65 enum RTSPServerType server_type
;
66 char last_reply
[2048]; /* XXX: allocate ? */
67 RTPDemuxContext
*cur_rtp
;
68 int need_subscription
;
71 typedef struct RTSPStream
{
72 URLContext
*rtp_handle
; /* RTP stream handle */
73 RTPDemuxContext
*rtp_ctx
; /* RTP parse context */
75 int stream_index
; /* corresponding stream index, if any. -1 if none (MPEG2TS case) */
76 int interleaved_min
, interleaved_max
; /* interleave ids, if TCP transport */
77 char control_url
[1024]; /* url for this stream (from SDP) */
79 int sdp_port
; /* port (from SDP content - not used in RTSP) */
80 struct in_addr sdp_ip
; /* IP address (from SDP content - not used in RTSP) */
81 int sdp_ttl
; /* IP TTL (from SDP content - not used in RTSP) */
82 int sdp_payload_type
; /* payload type - only used in SDP */
83 rtp_payload_data_t rtp_payload_data
; /* rtp payload parsing infos from SDP */
85 RTPDynamicProtocolHandler
*dynamic_handler
; ///< Only valid if it's a dynamic protocol. (This is the handler structure)
86 void *dynamic_protocol_context
; ///< Only valid if it's a dynamic protocol. (This is any private data associated with the dynamic protocol)
89 static int rtsp_read_play(AVFormatContext
*s
);
91 /* XXX: currently, the only way to change the protocols consists in
92 changing this variable */
94 #if LIBAVFORMAT_VERSION_INT < (53 << 16)
95 int rtsp_default_protocols
= (1 << RTSP_PROTOCOL_RTP_UDP
);
98 static int rtsp_probe(AVProbeData
*p
)
100 if (av_strstart(p
->filename
, "rtsp:", NULL
))
101 return AVPROBE_SCORE_MAX
;
105 static int redir_isspace(int c
)
107 return c
== ' ' || c
== '\t' || c
== '\n' || c
== '\r';
110 static void skip_spaces(const char **pp
)
114 while (redir_isspace(*p
))
119 static void get_word_sep(char *buf
, int buf_size
, const char *sep
,
130 while (!strchr(sep
, *p
) && *p
!= '\0') {
131 if ((q
- buf
) < buf_size
- 1)
140 static void get_word(char *buf
, int buf_size
, const char **pp
)
148 while (!redir_isspace(*p
) && *p
!= '\0') {
149 if ((q
- buf
) < buf_size
- 1)
158 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other
160 static int sdp_parse_rtpmap(AVCodecContext
*codec
, RTSPStream
*rtsp_st
, int payload_type
, const char *p
)
167 /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
168 see if we can handle this kind of payload */
169 get_word_sep(buf
, sizeof(buf
), "/", &p
);
170 if (payload_type
>= RTP_PT_PRIVATE
) {
171 RTPDynamicProtocolHandler
*handler
= RTPFirstDynamicPayloadHandler
;
173 if (!strcmp(buf
, handler
->enc_name
) && (codec
->codec_type
== handler
->codec_type
)) {
174 codec
->codec_id
= handler
->codec_id
;
175 rtsp_st
->dynamic_handler
= handler
;
177 rtsp_st
->dynamic_protocol_context
= handler
->open();
181 handler
= handler
->next
;
184 /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
185 /* search into AVRtpPayloadTypes[] */
186 codec
->codec_id
= ff_rtp_codec_id(buf
, codec
->codec_type
);
189 c
= avcodec_find_decoder(codec
->codec_id
);
193 c_name
= (char *)NULL
;
196 get_word_sep(buf
, sizeof(buf
), "/", &p
);
198 switch (codec
->codec_type
) {
199 case CODEC_TYPE_AUDIO
:
200 av_log(codec
, AV_LOG_DEBUG
, " audio codec set to : %s\n", c_name
);
201 codec
->sample_rate
= RTSP_DEFAULT_AUDIO_SAMPLERATE
;
202 codec
->channels
= RTSP_DEFAULT_NB_AUDIO_CHANNELS
;
204 codec
->sample_rate
= i
;
205 get_word_sep(buf
, sizeof(buf
), "/", &p
);
209 // TODO: there is a bug here; if it is a mono stream, and less than 22000Hz, faad upconverts to stereo and twice the
210 // frequency. No problem, but the sample rate is being set here by the sdp line. Upcoming patch forthcoming. (rdm)
212 av_log(codec
, AV_LOG_DEBUG
, " audio samplerate set to : %i\n", codec
->sample_rate
);
213 av_log(codec
, AV_LOG_DEBUG
, " audio channels set to : %i\n", codec
->channels
);
215 case CODEC_TYPE_VIDEO
:
216 av_log(codec
, AV_LOG_DEBUG
, " video codec set to : %s\n", c_name
);
227 /* return the length and optionnaly the data */
228 static int hex_to_data(uint8_t *data
, const char *p
)
238 c
= toupper((unsigned char)*p
++);
239 if (c
>= '0' && c
<= '9')
241 else if (c
>= 'A' && c
<= 'F')
256 static void sdp_parse_fmtp_config(AVCodecContext
*codec
, char *attr
, char *value
)
258 switch (codec
->codec_id
) {
261 if (!strcmp(attr
, "config")) {
262 /* decode the hexa encoded parameter */
263 int len
= hex_to_data(NULL
, value
);
264 codec
->extradata
= av_mallocz(len
+ FF_INPUT_BUFFER_PADDING_SIZE
);
265 if (!codec
->extradata
)
267 codec
->extradata_size
= len
;
268 hex_to_data(codec
->extradata
, value
);
277 typedef struct attrname_map
284 /* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
285 #define ATTR_NAME_TYPE_INT 0
286 #define ATTR_NAME_TYPE_STR 1
287 static attrname_map_t attr_names
[]=
289 {"SizeLength", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, sizelength
)},
290 {"IndexLength", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, indexlength
)},
291 {"IndexDeltaLength", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, indexdeltalength
)},
292 {"profile-level-id", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, profile_level_id
)},
293 {"StreamType", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, streamtype
)},
294 {"mode", ATTR_NAME_TYPE_STR
, offsetof(rtp_payload_data_t
, mode
)},
298 /** parse the attribute line from the fmtp a line of an sdp resonse. This is broken out as a function
299 * because it is used in rtp_h264.c, which is forthcoming.
301 int rtsp_next_attr_and_value(const char **p
, char *attr
, int attr_size
, char *value
, int value_size
)
306 get_word_sep(attr
, attr_size
, "=", p
);
309 get_word_sep(value
, value_size
, ";", p
);
317 /* parse a SDP line and save stream attributes */
318 static void sdp_parse_fmtp(AVStream
*st
, const char *p
)
324 RTSPStream
*rtsp_st
= st
->priv_data
;
325 AVCodecContext
*codec
= st
->codec
;
326 rtp_payload_data_t
*rtp_payload_data
= &rtsp_st
->rtp_payload_data
;
328 /* loop on each attribute */
329 while(rtsp_next_attr_and_value(&p
, attr
, sizeof(attr
), value
, sizeof(value
)))
331 /* grab the codec extra_data from the config parameter of the fmtp line */
332 sdp_parse_fmtp_config(codec
, attr
, value
);
333 /* Looking for a known attribute */
334 for (i
= 0; attr_names
[i
].str
; ++i
) {
335 if (!strcasecmp(attr
, attr_names
[i
].str
)) {
336 if (attr_names
[i
].type
== ATTR_NAME_TYPE_INT
)
337 *(int *)((char *)rtp_payload_data
+ attr_names
[i
].offset
) = atoi(value
);
338 else if (attr_names
[i
].type
== ATTR_NAME_TYPE_STR
)
339 *(char **)((char *)rtp_payload_data
+ attr_names
[i
].offset
) = av_strdup(value
);
345 /** Parse a string \p in the form of Range:npt=xx-xx, and determine the start
347 * Used for seeking in the rtp stream.
349 static void rtsp_parse_range_npt(const char *p
, int64_t *start
, int64_t *end
)
354 if (!av_stristart(p
, "npt=", &p
))
357 *start
= AV_NOPTS_VALUE
;
358 *end
= AV_NOPTS_VALUE
;
360 get_word_sep(buf
, sizeof(buf
), "-", &p
);
361 *start
= parse_date(buf
, 1);
364 get_word_sep(buf
, sizeof(buf
), "-", &p
);
365 *end
= parse_date(buf
, 1);
367 // av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
368 // av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
371 typedef struct SDPParseState
{
373 struct in_addr default_ip
;
377 static void sdp_parse_line(AVFormatContext
*s
, SDPParseState
*s1
,
378 int letter
, const char *buf
)
380 RTSPState
*rt
= s
->priv_data
;
381 char buf1
[64], st_type
[64];
383 int codec_type
, payload_type
, i
;
386 struct in_addr sdp_ip
;
390 printf("sdp: %c='%s'\n", letter
, buf
);
396 get_word(buf1
, sizeof(buf1
), &p
);
397 if (strcmp(buf1
, "IN") != 0)
399 get_word(buf1
, sizeof(buf1
), &p
);
400 if (strcmp(buf1
, "IP4") != 0)
402 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
403 if (inet_aton(buf1
, &sdp_ip
) == 0)
408 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
411 if (s
->nb_streams
== 0) {
412 s1
->default_ip
= sdp_ip
;
413 s1
->default_ttl
= ttl
;
415 st
= s
->streams
[s
->nb_streams
- 1];
416 rtsp_st
= st
->priv_data
;
417 rtsp_st
->sdp_ip
= sdp_ip
;
418 rtsp_st
->sdp_ttl
= ttl
;
422 av_strlcpy(s
->title
, p
, sizeof(s
->title
));
425 if (s
->nb_streams
== 0) {
426 av_strlcpy(s
->comment
, p
, sizeof(s
->comment
));
432 get_word(st_type
, sizeof(st_type
), &p
);
433 if (!strcmp(st_type
, "audio")) {
434 codec_type
= CODEC_TYPE_AUDIO
;
435 } else if (!strcmp(st_type
, "video")) {
436 codec_type
= CODEC_TYPE_VIDEO
;
440 rtsp_st
= av_mallocz(sizeof(RTSPStream
));
443 rtsp_st
->stream_index
= -1;
444 dynarray_add(&rt
->rtsp_streams
, &rt
->nb_rtsp_streams
, rtsp_st
);
446 rtsp_st
->sdp_ip
= s1
->default_ip
;
447 rtsp_st
->sdp_ttl
= s1
->default_ttl
;
449 get_word(buf1
, sizeof(buf1
), &p
); /* port */
450 rtsp_st
->sdp_port
= atoi(buf1
);
452 get_word(buf1
, sizeof(buf1
), &p
); /* protocol (ignored) */
454 /* XXX: handle list of formats */
455 get_word(buf1
, sizeof(buf1
), &p
); /* format list */
456 rtsp_st
->sdp_payload_type
= atoi(buf1
);
458 if (!strcmp(ff_rtp_enc_name(rtsp_st
->sdp_payload_type
), "MP2T")) {
459 /* no corresponding stream */
461 st
= av_new_stream(s
, 0);
464 st
->priv_data
= rtsp_st
;
465 rtsp_st
->stream_index
= st
->index
;
466 st
->codec
->codec_type
= codec_type
;
467 if (rtsp_st
->sdp_payload_type
< RTP_PT_PRIVATE
) {
468 /* if standard payload type, we can find the codec right now */
469 rtp_get_codec_info(st
->codec
, rtsp_st
->sdp_payload_type
);
472 /* put a default control url */
473 av_strlcpy(rtsp_st
->control_url
, s
->filename
, sizeof(rtsp_st
->control_url
));
476 if (av_strstart(p
, "control:", &p
) && s
->nb_streams
> 0) {
478 /* get the control url */
479 st
= s
->streams
[s
->nb_streams
- 1];
480 rtsp_st
= st
->priv_data
;
482 /* XXX: may need to add full url resolution */
483 url_split(proto
, sizeof(proto
), NULL
, 0, NULL
, 0, NULL
, NULL
, 0, p
);
484 if (proto
[0] == '\0') {
485 /* relative control URL */
486 av_strlcat(rtsp_st
->control_url
, "/", sizeof(rtsp_st
->control_url
));
487 av_strlcat(rtsp_st
->control_url
, p
, sizeof(rtsp_st
->control_url
));
489 av_strlcpy(rtsp_st
->control_url
, p
, sizeof(rtsp_st
->control_url
));
491 } else if (av_strstart(p
, "rtpmap:", &p
)) {
492 /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
493 get_word(buf1
, sizeof(buf1
), &p
);
494 payload_type
= atoi(buf1
);
495 for(i
= 0; i
< s
->nb_streams
;i
++) {
497 rtsp_st
= st
->priv_data
;
498 if (rtsp_st
->sdp_payload_type
== payload_type
) {
499 sdp_parse_rtpmap(st
->codec
, rtsp_st
, payload_type
, p
);
502 } else if (av_strstart(p
, "fmtp:", &p
)) {
503 /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
504 get_word(buf1
, sizeof(buf1
), &p
);
505 payload_type
= atoi(buf1
);
506 for(i
= 0; i
< s
->nb_streams
;i
++) {
508 rtsp_st
= st
->priv_data
;
509 if (rtsp_st
->sdp_payload_type
== payload_type
) {
510 if(rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_handler
->parse_sdp_a_line
) {
511 if(!rtsp_st
->dynamic_handler
->parse_sdp_a_line(st
, rtsp_st
->dynamic_protocol_context
, buf
)) {
512 sdp_parse_fmtp(st
, p
);
515 sdp_parse_fmtp(st
, p
);
519 } else if(av_strstart(p
, "framesize:", &p
)) {
520 // let dynamic protocol handlers have a stab at the line.
521 get_word(buf1
, sizeof(buf1
), &p
);
522 payload_type
= atoi(buf1
);
523 for(i
= 0; i
< s
->nb_streams
;i
++) {
525 rtsp_st
= st
->priv_data
;
526 if (rtsp_st
->sdp_payload_type
== payload_type
) {
527 if(rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_handler
->parse_sdp_a_line
) {
528 rtsp_st
->dynamic_handler
->parse_sdp_a_line(st
, rtsp_st
->dynamic_protocol_context
, buf
);
532 } else if(av_strstart(p
, "range:", &p
)) {
535 // this is so that seeking on a streamed file can work.
536 rtsp_parse_range_npt(p
, &start
, &end
);
537 s
->start_time
= start
;
538 s
->duration
= (end
==AV_NOPTS_VALUE
)?AV_NOPTS_VALUE
:end
-start
; // AV_NOPTS_VALUE means live broadcast (and can't seek)
539 } else if (s
->nb_streams
> 0) {
540 rtsp_st
= s
->streams
[s
->nb_streams
- 1]->priv_data
;
541 if (rtsp_st
->dynamic_handler
&&
542 rtsp_st
->dynamic_handler
->parse_sdp_a_line
)
543 rtsp_st
->dynamic_handler
->parse_sdp_a_line(s
->streams
[s
->nb_streams
- 1],
544 rtsp_st
->dynamic_protocol_context
, buf
);
550 static int sdp_parse(AVFormatContext
*s
, const char *content
)
555 SDPParseState sdp_parse_state
, *s1
= &sdp_parse_state
;
557 memset(s1
, 0, sizeof(SDPParseState
));
568 /* get the content */
570 while (*p
!= '\n' && *p
!= '\r' && *p
!= '\0') {
571 if ((q
- buf
) < sizeof(buf
) - 1)
576 sdp_parse_line(s
, s1
, letter
, buf
);
578 while (*p
!= '\n' && *p
!= '\0')
586 static void rtsp_parse_range(int *min_ptr
, int *max_ptr
, const char **pp
)
593 v
= strtol(p
, (char **)&p
, 10);
597 v
= strtol(p
, (char **)&p
, 10);
606 /* XXX: only one transport specification is parsed */
607 static void rtsp_parse_transport(RTSPHeader
*reply
, const char *p
)
609 char transport_protocol
[16];
611 char lower_transport
[16];
613 RTSPTransportField
*th
;
616 reply
->nb_transports
= 0;
623 th
= &reply
->transports
[reply
->nb_transports
];
625 get_word_sep(transport_protocol
, sizeof(transport_protocol
),
629 if (!strcasecmp (transport_protocol
, "rtp")) {
630 get_word_sep(profile
, sizeof(profile
), "/;,", &p
);
631 lower_transport
[0] = '\0';
632 /* rtp/avp/<protocol> */
635 get_word_sep(lower_transport
, sizeof(lower_transport
),
638 } else if (!strcasecmp (transport_protocol
, "x-pn-tng")) {
639 /* x-pn-tng/<protocol> */
640 get_word_sep(lower_transport
, sizeof(lower_transport
), "/;,", &p
);
643 if (!strcasecmp(lower_transport
, "TCP"))
644 th
->protocol
= RTSP_PROTOCOL_RTP_TCP
;
646 th
->protocol
= RTSP_PROTOCOL_RTP_UDP
;
650 /* get each parameter */
651 while (*p
!= '\0' && *p
!= ',') {
652 get_word_sep(parameter
, sizeof(parameter
), "=;,", &p
);
653 if (!strcmp(parameter
, "port")) {
656 rtsp_parse_range(&th
->port_min
, &th
->port_max
, &p
);
658 } else if (!strcmp(parameter
, "client_port")) {
661 rtsp_parse_range(&th
->client_port_min
,
662 &th
->client_port_max
, &p
);
664 } else if (!strcmp(parameter
, "server_port")) {
667 rtsp_parse_range(&th
->server_port_min
,
668 &th
->server_port_max
, &p
);
670 } else if (!strcmp(parameter
, "interleaved")) {
673 rtsp_parse_range(&th
->interleaved_min
,
674 &th
->interleaved_max
, &p
);
676 } else if (!strcmp(parameter
, "multicast")) {
677 if (th
->protocol
== RTSP_PROTOCOL_RTP_UDP
)
678 th
->protocol
= RTSP_PROTOCOL_RTP_UDP_MULTICAST
;
679 } else if (!strcmp(parameter
, "ttl")) {
682 th
->ttl
= strtol(p
, (char **)&p
, 10);
684 } else if (!strcmp(parameter
, "destination")) {
685 struct in_addr ipaddr
;
689 get_word_sep(buf
, sizeof(buf
), ";,", &p
);
690 if (inet_aton(buf
, &ipaddr
))
691 th
->destination
= ntohl(ipaddr
.s_addr
);
694 while (*p
!= ';' && *p
!= '\0' && *p
!= ',')
702 reply
->nb_transports
++;
706 void rtsp_parse_line(RTSPHeader
*reply
, const char *buf
)
710 /* NOTE: we do case independent match for broken servers */
712 if (av_stristart(p
, "Session:", &p
)) {
713 get_word_sep(reply
->session_id
, sizeof(reply
->session_id
), ";", &p
);
714 } else if (av_stristart(p
, "Content-Length:", &p
)) {
715 reply
->content_length
= strtol(p
, NULL
, 10);
716 } else if (av_stristart(p
, "Transport:", &p
)) {
717 rtsp_parse_transport(reply
, p
);
718 } else if (av_stristart(p
, "CSeq:", &p
)) {
719 reply
->seq
= strtol(p
, NULL
, 10);
720 } else if (av_stristart(p
, "Range:", &p
)) {
721 rtsp_parse_range_npt(p
, &reply
->range_start
, &reply
->range_end
);
722 } else if (av_stristart(p
, "RealChallenge1:", &p
)) {
724 av_strlcpy(reply
->real_challenge
, p
, sizeof(reply
->real_challenge
));
728 static int url_readbuf(URLContext
*h
, unsigned char *buf
, int size
)
734 ret
= url_read(h
, buf
+len
, size
-len
);
742 /* skip a RTP/TCP interleaved packet */
743 static void rtsp_skip_packet(AVFormatContext
*s
)
745 RTSPState
*rt
= s
->priv_data
;
749 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 3);
752 len
= AV_RB16(buf
+ 1);
754 printf("skipping RTP packet len=%d\n", len
);
759 if (len1
> sizeof(buf
))
761 ret
= url_readbuf(rt
->rtsp_hd
, buf
, len1
);
768 static void rtsp_send_cmd(AVFormatContext
*s
,
769 const char *cmd
, RTSPHeader
*reply
,
770 unsigned char **content_ptr
)
772 RTSPState
*rt
= s
->priv_data
;
773 char buf
[4096], buf1
[1024], *q
;
776 int content_length
, line_count
;
777 unsigned char *content
= NULL
;
779 memset(reply
, 0, sizeof(RTSPHeader
));
782 av_strlcpy(buf
, cmd
, sizeof(buf
));
783 snprintf(buf1
, sizeof(buf1
), "CSeq: %d\r\n", rt
->seq
);
784 av_strlcat(buf
, buf1
, sizeof(buf
));
785 if (rt
->session_id
[0] != '\0' && !strstr(cmd
, "\nIf-Match:")) {
786 snprintf(buf1
, sizeof(buf1
), "Session: %s\r\n", rt
->session_id
);
787 av_strlcat(buf
, buf1
, sizeof(buf
));
789 av_strlcat(buf
, "\r\n", sizeof(buf
));
791 printf("Sending:\n%s--\n", buf
);
793 url_write(rt
->rtsp_hd
, buf
, strlen(buf
));
795 /* parse reply (XXX: use buffers) */
797 rt
->last_reply
[0] = '\0';
801 if (url_readbuf(rt
->rtsp_hd
, &ch
, 1) != 1)
806 /* XXX: only parse it if first char on line ? */
808 } else if (ch
!= '\r') {
809 if ((q
- buf
) < sizeof(buf
) - 1)
815 printf("line='%s'\n", buf
);
817 /* test if last line */
821 if (line_count
== 0) {
823 get_word(buf1
, sizeof(buf1
), &p
);
824 get_word(buf1
, sizeof(buf1
), &p
);
825 reply
->status_code
= atoi(buf1
);
827 rtsp_parse_line(reply
, p
);
828 av_strlcat(rt
->last_reply
, p
, sizeof(rt
->last_reply
));
829 av_strlcat(rt
->last_reply
, "\n", sizeof(rt
->last_reply
));
834 if (rt
->session_id
[0] == '\0' && reply
->session_id
[0] != '\0')
835 av_strlcpy(rt
->session_id
, reply
->session_id
, sizeof(rt
->session_id
));
837 content_length
= reply
->content_length
;
838 if (content_length
> 0) {
839 /* leave some room for a trailing '\0' (useful for simple parsing) */
840 content
= av_malloc(content_length
+ 1);
841 (void)url_readbuf(rt
->rtsp_hd
, content
, content_length
);
842 content
[content_length
] = '\0';
845 *content_ptr
= content
;
851 /* close and free RTSP streams */
852 static void rtsp_close_streams(RTSPState
*rt
)
857 for(i
=0;i
<rt
->nb_rtsp_streams
;i
++) {
858 rtsp_st
= rt
->rtsp_streams
[i
];
860 if (rtsp_st
->rtp_ctx
)
861 rtp_parse_close(rtsp_st
->rtp_ctx
);
862 if (rtsp_st
->rtp_handle
)
863 url_close(rtsp_st
->rtp_handle
);
864 if (rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_protocol_context
)
865 rtsp_st
->dynamic_handler
->close(rtsp_st
->dynamic_protocol_context
);
868 av_free(rt
->rtsp_streams
);
872 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
875 make_setup_request (AVFormatContext
*s
, const char *host
, int port
,
876 int protocol
, const char *real_challenge
)
878 RTSPState
*rt
= s
->priv_data
;
882 RTSPHeader reply1
, *reply
= &reply1
;
884 const char *trans_pref
;
886 if (rt
->server_type
== RTSP_SERVER_RDT
)
887 trans_pref
= "x-pn-tng";
889 trans_pref
= "RTP/AVP";
891 /* for each stream, make the setup request */
892 /* XXX: we assume the same server is used for the control of each
895 for(j
= RTSP_RTP_PORT_MIN
, i
= 0; i
< rt
->nb_rtsp_streams
; ++i
) {
896 char transport
[2048];
898 rtsp_st
= rt
->rtsp_streams
[i
];
901 if (protocol
== RTSP_PROTOCOL_RTP_UDP
) {
904 /* first try in specified port range */
905 if (RTSP_RTP_PORT_MIN
!= 0) {
906 while(j
<= RTSP_RTP_PORT_MAX
) {
907 snprintf(buf
, sizeof(buf
), "rtp://%s?localport=%d", host
, j
);
908 j
+= 2; /* we will use two port by rtp stream (rtp and rtcp) */
909 if (url_open(&rtsp_st
->rtp_handle
, buf
, URL_RDWR
) == 0) {
915 /* then try on any port
916 ** if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
917 ** err = AVERROR_INVALIDDATA;
923 port
= rtp_get_local_port(rtsp_st
->rtp_handle
);
924 snprintf(transport
, sizeof(transport
) - 1,
925 "%s/UDP;unicast;client_port=%d",
927 if (rt
->server_type
== RTSP_SERVER_RTP
)
928 av_strlcatf(transport
, sizeof(transport
), "-%d", port
+ 1);
932 else if (protocol
== RTSP_PROTOCOL_RTP_TCP
) {
933 snprintf(transport
, sizeof(transport
) - 1,
934 "%s/TCP", trans_pref
);
937 else if (protocol
== RTSP_PROTOCOL_RTP_UDP_MULTICAST
) {
938 snprintf(transport
, sizeof(transport
) - 1,
939 "%s/UDP;multicast", trans_pref
);
941 if (rt
->server_type
== RTSP_SERVER_RDT
)
942 av_strlcat(transport
, ";mode=play", sizeof(transport
));
943 snprintf(cmd
, sizeof(cmd
),
944 "SETUP %s RTSP/1.0\r\n"
946 rtsp_st
->control_url
, transport
);
947 if (i
== 0 && rt
->server_type
== RTSP_SERVER_RDT
) {
948 char real_res
[41], real_csum
[9];
949 ff_rdt_calc_response_and_checksum(real_res
, real_csum
,
951 av_strlcatf(cmd
, sizeof(cmd
),
953 "RealChallenge2: %s, sd=%s\r\n",
954 rt
->session_id
, real_res
, real_csum
);
956 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
957 if (reply
->status_code
== 461 /* Unsupported protocol */ && i
== 0) {
960 } else if (reply
->status_code
!= RTSP_STATUS_OK
||
961 reply
->nb_transports
!= 1) {
962 err
= AVERROR_INVALIDDATA
;
966 /* XXX: same protocol for all streams is required */
968 if (reply
->transports
[0].protocol
!= rt
->protocol
) {
969 err
= AVERROR_INVALIDDATA
;
973 rt
->protocol
= reply
->transports
[0].protocol
;
976 /* close RTP connection if not choosen */
977 if (reply
->transports
[0].protocol
!= RTSP_PROTOCOL_RTP_UDP
&&
978 (protocol
== RTSP_PROTOCOL_RTP_UDP
)) {
979 url_close(rtsp_st
->rtp_handle
);
980 rtsp_st
->rtp_handle
= NULL
;
983 switch(reply
->transports
[0].protocol
) {
984 case RTSP_PROTOCOL_RTP_TCP
:
985 rtsp_st
->interleaved_min
= reply
->transports
[0].interleaved_min
;
986 rtsp_st
->interleaved_max
= reply
->transports
[0].interleaved_max
;
989 case RTSP_PROTOCOL_RTP_UDP
:
993 /* XXX: also use address if specified */
994 snprintf(url
, sizeof(url
), "rtp://%s:%d",
995 host
, reply
->transports
[0].server_port_min
);
996 if (rtp_set_remote_url(rtsp_st
->rtp_handle
, url
) < 0) {
997 err
= AVERROR_INVALIDDATA
;
1002 case RTSP_PROTOCOL_RTP_UDP_MULTICAST
:
1007 in
.s_addr
= htonl(reply
->transports
[0].destination
);
1008 snprintf(url
, sizeof(url
), "rtp://%s:%d?ttl=%d",
1010 reply
->transports
[0].port_min
,
1011 reply
->transports
[0].ttl
);
1012 if (url_open(&rtsp_st
->rtp_handle
, url
, URL_RDWR
) < 0) {
1013 err
= AVERROR_INVALIDDATA
;
1019 /* open the RTP context */
1021 if (rtsp_st
->stream_index
>= 0)
1022 st
= s
->streams
[rtsp_st
->stream_index
];
1024 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
1025 rtsp_st
->rtp_ctx
= rtp_parse_open(s
, st
, rtsp_st
->rtp_handle
, rtsp_st
->sdp_payload_type
, &rtsp_st
->rtp_payload_data
);
1027 if (!rtsp_st
->rtp_ctx
) {
1028 err
= AVERROR(ENOMEM
);
1031 if(rtsp_st
->dynamic_handler
) {
1032 rtsp_st
->rtp_ctx
->dynamic_protocol_context
= rtsp_st
->dynamic_protocol_context
;
1033 rtsp_st
->rtp_ctx
->parse_packet
= rtsp_st
->dynamic_handler
->parse_packet
;
1038 if (rt
->server_type
== RTSP_SERVER_RDT
)
1039 rt
->need_subscription
= 1;
1044 for (i
=0; i
<rt
->nb_rtsp_streams
; i
++) {
1045 if (rt
->rtsp_streams
[i
]->rtp_handle
) {
1046 url_close(rt
->rtsp_streams
[i
]->rtp_handle
);
1047 rt
->rtsp_streams
[i
]->rtp_handle
= NULL
;
1053 static int rtsp_read_header(AVFormatContext
*s
,
1054 AVFormatParameters
*ap
)
1056 RTSPState
*rt
= s
->priv_data
;
1057 char host
[1024], path
[1024], tcpname
[1024], cmd
[2048], *option_list
, *option
;
1058 URLContext
*rtsp_hd
;
1060 RTSPHeader reply1
, *reply
= &reply1
;
1061 unsigned char *content
= NULL
;
1062 int protocol_mask
= 0;
1063 char real_challenge
[64];
1065 /* extract hostname and port */
1066 url_split(NULL
, 0, NULL
, 0,
1067 host
, sizeof(host
), &port
, path
, sizeof(path
), s
->filename
);
1069 port
= RTSP_DEFAULT_PORT
;
1071 /* search for options */
1072 option_list
= strchr(path
, '?');
1074 /* remove the options from the path */
1076 while(option_list
) {
1077 /* move the option pointer */
1078 option
= option_list
;
1079 option_list
= strchr(option_list
, '&');
1081 *(option_list
++) = 0;
1082 /* handle the options */
1083 if (strcmp(option
, "udp") == 0)
1084 protocol_mask
= (1<< RTSP_PROTOCOL_RTP_UDP
);
1085 else if (strcmp(option
, "multicast") == 0)
1086 protocol_mask
= (1<< RTSP_PROTOCOL_RTP_UDP_MULTICAST
);
1087 else if (strcmp(option
, "tcp") == 0)
1088 protocol_mask
= (1<< RTSP_PROTOCOL_RTP_TCP
);
1093 protocol_mask
= (1 << RTSP_PROTOCOL_RTP_LAST
) - 1;
1095 /* open the tcp connexion */
1096 snprintf(tcpname
, sizeof(tcpname
), "tcp://%s:%d", host
, port
);
1097 if (url_open(&rtsp_hd
, tcpname
, URL_RDWR
) < 0)
1098 return AVERROR(EIO
);
1099 rt
->rtsp_hd
= rtsp_hd
;
1102 /* request options supported by the server; this also detects server type */
1103 for (rt
->server_type
= RTSP_SERVER_RTP
;;) {
1104 snprintf(cmd
, sizeof(cmd
),
1105 "OPTIONS %s RTSP/1.0\r\n", s
->filename
);
1106 if (rt
->server_type
== RTSP_SERVER_RDT
)
1109 * The following entries are required for proper
1110 * streaming from a Realmedia server. They are
1111 * interdependent in some way although we currently
1112 * don't quite understand how. Values were copied
1113 * from mplayer SVN r23589.
1114 * @param CompanyID is a 16-byte ID in base64
1115 * @param ClientChallenge is a 16-byte ID in hex
1117 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1118 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1119 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1120 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1122 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1123 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1124 err
= AVERROR_INVALIDDATA
;
1128 /* detect server type if not standard-compliant RTP */
1129 if (rt
->server_type
!= RTSP_SERVER_RDT
&& reply
->real_challenge
[0]) {
1130 rt
->server_type
= RTSP_SERVER_RDT
;
1132 } else if (rt
->server_type
== RTSP_SERVER_RDT
) {
1133 strcpy(real_challenge
, reply
->real_challenge
);
1138 /* describe the stream */
1139 snprintf(cmd
, sizeof(cmd
),
1140 "DESCRIBE %s RTSP/1.0\r\n"
1141 "Accept: application/sdp\r\n",
1143 if (rt
->server_type
== RTSP_SERVER_RDT
) {
1145 * The Require: attribute is needed for proper streaming from
1146 * Realmedia servers.
1149 "Require: com.real.retain-entity-for-setup\r\n",
1152 rtsp_send_cmd(s
, cmd
, reply
, &content
);
1154 err
= AVERROR_INVALIDDATA
;
1157 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1158 err
= AVERROR_INVALIDDATA
;
1162 /* now we got the SDP description, we parse it */
1163 ret
= sdp_parse(s
, (const char *)content
);
1166 err
= AVERROR_INVALIDDATA
;
1171 int protocol
= ff_log2_tab
[protocol_mask
& ~(protocol_mask
- 1)];
1173 err
= make_setup_request(s
, host
, port
, protocol
,
1174 rt
->server_type
== RTSP_SERVER_RDT
?
1175 real_challenge
: NULL
);
1178 protocol_mask
&= ~(1 << protocol
);
1179 if (protocol_mask
== 0 && err
== 1) {
1180 err
= AVERROR(FF_NETERROR(EPROTONOSUPPORT
));
1185 rt
->state
= RTSP_STATE_IDLE
;
1186 rt
->seek_timestamp
= 0; /* default is to start stream at position
1188 if (ap
->initial_pause
) {
1189 /* do not start immediately */
1191 if (rtsp_read_play(s
) < 0) {
1192 err
= AVERROR_INVALIDDATA
;
1198 rtsp_close_streams(rt
);
1200 url_close(rt
->rtsp_hd
);
1204 static int tcp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1205 uint8_t *buf
, int buf_size
)
1207 RTSPState
*rt
= s
->priv_data
;
1208 int id
, len
, i
, ret
;
1209 RTSPStream
*rtsp_st
;
1211 #ifdef DEBUG_RTP_TCP
1212 printf("tcp_read_packet:\n");
1216 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 1);
1217 #ifdef DEBUG_RTP_TCP
1218 printf("ret=%d c=%02x [%c]\n", ret
, buf
[0], buf
[0]);
1225 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 3);
1229 len
= AV_RB16(buf
+ 1);
1230 #ifdef DEBUG_RTP_TCP
1231 printf("id=%d len=%d\n", id
, len
);
1233 if (len
> buf_size
|| len
< 12)
1236 ret
= url_readbuf(rt
->rtsp_hd
, buf
, len
);
1240 /* find the matching stream */
1241 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1242 rtsp_st
= rt
->rtsp_streams
[i
];
1243 if (id
>= rtsp_st
->interleaved_min
&&
1244 id
<= rtsp_st
->interleaved_max
)
1249 *prtsp_st
= rtsp_st
;
1253 static int udp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1254 uint8_t *buf
, int buf_size
)
1256 RTSPState
*rt
= s
->priv_data
;
1257 RTSPStream
*rtsp_st
;
1259 int fd1
, fd2
, fd_max
, n
, i
, ret
;
1263 if (url_interrupt_cb())
1264 return AVERROR(EINTR
);
1267 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1268 rtsp_st
= rt
->rtsp_streams
[i
];
1269 /* currently, we cannot probe RTCP handle because of blocking restrictions */
1270 rtp_get_file_handles(rtsp_st
->rtp_handle
, &fd1
, &fd2
);
1276 tv
.tv_usec
= 100 * 1000;
1277 n
= select(fd_max
+ 1, &rfds
, NULL
, NULL
, &tv
);
1279 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1280 rtsp_st
= rt
->rtsp_streams
[i
];
1281 rtp_get_file_handles(rtsp_st
->rtp_handle
, &fd1
, &fd2
);
1282 if (FD_ISSET(fd1
, &rfds
)) {
1283 ret
= url_read(rtsp_st
->rtp_handle
, buf
, buf_size
);
1285 *prtsp_st
= rtsp_st
;
1294 static int rtsp_read_packet(AVFormatContext
*s
,
1297 RTSPState
*rt
= s
->priv_data
;
1298 RTSPStream
*rtsp_st
;
1300 uint8_t buf
[RTP_MAX_PACKET_LENGTH
];
1302 if (rt
->server_type
== RTSP_SERVER_RDT
&& rt
->need_subscription
) {
1304 RTSPHeader reply1
, *reply
= &reply1
;
1307 snprintf(cmd
, sizeof(cmd
),
1308 "SET_PARAMETER %s RTSP/1.0\r\n"
1311 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1312 if (i
!= 0) av_strlcat(cmd
, ",", sizeof(cmd
));
1313 ff_rdt_subscribe_rule(
1314 rt
->rtsp_streams
[i
]->rtp_ctx
,
1315 cmd
, sizeof(cmd
), i
, 0);
1317 av_strlcat(cmd
, "\r\n", sizeof(cmd
));
1318 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1319 if (reply
->status_code
!= RTSP_STATUS_OK
)
1320 return AVERROR_INVALIDDATA
;
1321 rt
->need_subscription
= 0;
1323 if (rt
->state
== RTSP_STATE_PLAYING
)
1327 /* get next frames from the same RTP packet */
1329 if (rt
->server_type
== RTSP_SERVER_RDT
)
1330 ret
= ff_rdt_parse_packet(rt
->cur_rtp
, pkt
, NULL
, 0);
1332 ret
= rtp_parse_packet(rt
->cur_rtp
, pkt
, NULL
, 0);
1336 } else if (ret
== 1) {
1343 /* read next RTP packet */
1345 switch(rt
->protocol
) {
1347 case RTSP_PROTOCOL_RTP_TCP
:
1348 len
= tcp_read_packet(s
, &rtsp_st
, buf
, sizeof(buf
));
1350 case RTSP_PROTOCOL_RTP_UDP
:
1351 case RTSP_PROTOCOL_RTP_UDP_MULTICAST
:
1352 len
= udp_read_packet(s
, &rtsp_st
, buf
, sizeof(buf
));
1353 if (len
>=0 && rtsp_st
->rtp_ctx
)
1354 rtp_check_and_send_back_rr(rtsp_st
->rtp_ctx
, len
);
1359 if (rt
->server_type
== RTSP_SERVER_RDT
)
1360 ret
= ff_rdt_parse_packet(rtsp_st
->rtp_ctx
, pkt
, buf
, len
);
1362 ret
= rtp_parse_packet(rtsp_st
->rtp_ctx
, pkt
, buf
, len
);
1366 /* more packets may follow, so we save the RTP context */
1367 rt
->cur_rtp
= rtsp_st
->rtp_ctx
;
1372 static int rtsp_read_play(AVFormatContext
*s
)
1374 RTSPState
*rt
= s
->priv_data
;
1375 RTSPHeader reply1
, *reply
= &reply1
;
1378 av_log(s
, AV_LOG_DEBUG
, "hello state=%d\n", rt
->state
);
1380 if (!(rt
->server_type
== RTSP_SERVER_RDT
&& rt
->need_subscription
)) {
1381 if (rt
->state
== RTSP_STATE_PAUSED
) {
1382 snprintf(cmd
, sizeof(cmd
),
1383 "PLAY %s RTSP/1.0\r\n",
1386 snprintf(cmd
, sizeof(cmd
),
1387 "PLAY %s RTSP/1.0\r\n"
1388 "Range: npt=%0.3f-\r\n",
1390 (double)rt
->seek_timestamp
/ AV_TIME_BASE
);
1392 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1393 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1397 rt
->state
= RTSP_STATE_PLAYING
;
1401 /* pause the stream */
1402 static int rtsp_read_pause(AVFormatContext
*s
)
1404 RTSPState
*rt
= s
->priv_data
;
1405 RTSPHeader reply1
, *reply
= &reply1
;
1410 if (rt
->state
!= RTSP_STATE_PLAYING
)
1412 else if (!(rt
->server_type
== RTSP_SERVER_RDT
&& rt
->need_subscription
)) {
1413 snprintf(cmd
, sizeof(cmd
),
1414 "PAUSE %s RTSP/1.0\r\n",
1416 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1417 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1421 rt
->state
= RTSP_STATE_PAUSED
;
1425 static int rtsp_read_seek(AVFormatContext
*s
, int stream_index
,
1426 int64_t timestamp
, int flags
)
1428 RTSPState
*rt
= s
->priv_data
;
1430 rt
->seek_timestamp
= av_rescale_q(timestamp
, s
->streams
[stream_index
]->time_base
, AV_TIME_BASE_Q
);
1433 case RTSP_STATE_IDLE
:
1435 case RTSP_STATE_PLAYING
:
1436 if (rtsp_read_play(s
) != 0)
1439 case RTSP_STATE_PAUSED
:
1440 rt
->state
= RTSP_STATE_IDLE
;
1446 static int rtsp_read_close(AVFormatContext
*s
)
1448 RTSPState
*rt
= s
->priv_data
;
1449 RTSPHeader reply1
, *reply
= &reply1
;
1453 /* NOTE: it is valid to flush the buffer here */
1454 if (rt
->protocol
== RTSP_PROTOCOL_RTP_TCP
) {
1455 url_fclose(&rt
->rtsp_gb
);
1458 snprintf(cmd
, sizeof(cmd
),
1459 "TEARDOWN %s RTSP/1.0\r\n",
1461 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1463 rtsp_close_streams(rt
);
1464 url_close(rt
->rtsp_hd
);
1468 #ifdef CONFIG_RTSP_DEMUXER
1469 AVInputFormat rtsp_demuxer
= {
1471 NULL_IF_CONFIG_SMALL("RTSP input format"),
1478 .flags
= AVFMT_NOFILE
,
1479 .read_play
= rtsp_read_play
,
1480 .read_pause
= rtsp_read_pause
,
1484 static int sdp_probe(AVProbeData
*p1
)
1486 const char *p
= p1
->buf
, *p_end
= p1
->buf
+ p1
->buf_size
;
1488 /* we look for a line beginning "c=IN IP4" */
1489 while (p
< p_end
&& *p
!= '\0') {
1490 if (p
+ sizeof("c=IN IP4") - 1 < p_end
&& av_strstart(p
, "c=IN IP4", NULL
))
1491 return AVPROBE_SCORE_MAX
/ 2;
1493 while(p
< p_end
- 1 && *p
!= '\n') p
++;
1502 #define SDP_MAX_SIZE 8192
1504 static int sdp_read_header(AVFormatContext
*s
,
1505 AVFormatParameters
*ap
)
1507 RTSPState
*rt
= s
->priv_data
;
1508 RTSPStream
*rtsp_st
;
1514 /* read the whole sdp file */
1515 /* XXX: better loading */
1516 content
= av_malloc(SDP_MAX_SIZE
);
1517 size
= get_buffer(s
->pb
, content
, SDP_MAX_SIZE
- 1);
1520 return AVERROR_INVALIDDATA
;
1522 content
[size
] ='\0';
1524 sdp_parse(s
, content
);
1527 /* open each RTP stream */
1528 for(i
=0;i
<rt
->nb_rtsp_streams
;i
++) {
1529 rtsp_st
= rt
->rtsp_streams
[i
];
1531 snprintf(url
, sizeof(url
), "rtp://%s:%d?localport=%d&ttl=%d",
1532 inet_ntoa(rtsp_st
->sdp_ip
),
1536 if (url_open(&rtsp_st
->rtp_handle
, url
, URL_RDWR
) < 0) {
1537 err
= AVERROR_INVALIDDATA
;
1540 /* open the RTP context */
1542 if (rtsp_st
->stream_index
>= 0)
1543 st
= s
->streams
[rtsp_st
->stream_index
];
1545 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
1546 rtsp_st
->rtp_ctx
= rtp_parse_open(s
, st
, rtsp_st
->rtp_handle
, rtsp_st
->sdp_payload_type
, &rtsp_st
->rtp_payload_data
);
1547 if (!rtsp_st
->rtp_ctx
) {
1548 err
= AVERROR(ENOMEM
);
1551 if(rtsp_st
->dynamic_handler
) {
1552 rtsp_st
->rtp_ctx
->dynamic_protocol_context
= rtsp_st
->dynamic_protocol_context
;
1553 rtsp_st
->rtp_ctx
->parse_packet
= rtsp_st
->dynamic_handler
->parse_packet
;
1559 rtsp_close_streams(rt
);
1563 static int sdp_read_packet(AVFormatContext
*s
,
1566 return rtsp_read_packet(s
, pkt
);
1569 static int sdp_read_close(AVFormatContext
*s
)
1571 RTSPState
*rt
= s
->priv_data
;
1572 rtsp_close_streams(rt
);
1576 #ifdef CONFIG_SDP_DEMUXER
1577 AVInputFormat sdp_demuxer
= {
1579 NULL_IF_CONFIG_SMALL("SDP"),
1588 #ifdef CONFIG_REDIR_DEMUXER
1589 /* dummy redirector format (used directly in av_open_input_file now) */
1590 static int redir_probe(AVProbeData
*pd
)
1594 while (redir_isspace(*p
))
1596 if (av_strstart(p
, "http://", NULL
) ||
1597 av_strstart(p
, "rtsp://", NULL
))
1598 return AVPROBE_SCORE_MAX
;
1602 static int redir_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
1606 AVFormatContext
*ic
= NULL
;
1607 ByteIOContext
*f
= s
->pb
;
1609 /* parse each URL and try to open it */
1611 while (c
!= URL_EOF
) {
1614 if (!redir_isspace(c
))
1623 if (c
== URL_EOF
|| redir_isspace(c
))
1625 if ((q
- buf
) < sizeof(buf
) - 1)
1630 //printf("URL='%s'\n", buf);
1631 /* try to open the media file */
1632 if (av_open_input_file(&ic
, buf
, NULL
, 0, NULL
) == 0)
1636 return AVERROR(EIO
);
1644 AVInputFormat redir_demuxer
= {
1646 NULL_IF_CONFIG_SMALL("Redirector format"),