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 #ifdef HAVE_SYS_SELECT_H
30 #include <sys/select.h>
36 #include "rtp_internal.h"
40 //#define DEBUG_RTP_TCP
42 enum RTSPClientState
{
49 RTSP_SERVER_RTP
, /*< Standard-compliant RTP-server */
50 RTSP_SERVER_REAL
, /*< Realmedia-style server */
60 typedef struct RTSPState
{
61 URLContext
*rtsp_hd
; /* RTSP TCP connexion handle */
63 struct RTSPStream
**rtsp_streams
;
65 enum RTSPClientState state
;
66 int64_t seek_timestamp
;
68 /* XXX: currently we use unbuffered input */
69 // ByteIOContext rtsp_gb;
70 int seq
; /* RTSP command sequence number */
72 enum RTSPTransport transport
;
73 enum RTSPLowerTransport lower_transport
;
74 enum RTSPServerType server_type
;
75 char last_reply
[2048]; /* XXX: allocate ? */
77 int need_subscription
;
80 typedef struct RTSPStream
{
81 URLContext
*rtp_handle
; /* RTP stream handle */
82 void *tx_ctx
; /* RTP/RDT parse context */
84 int stream_index
; /* corresponding stream index, if any. -1 if none (MPEG2TS case) */
85 int interleaved_min
, interleaved_max
; /* interleave ids, if TCP transport */
86 char control_url
[1024]; /* url for this stream (from SDP) */
88 int sdp_port
; /* port (from SDP content - not used in RTSP) */
89 struct in_addr sdp_ip
; /* IP address (from SDP content - not used in RTSP) */
90 int sdp_ttl
; /* IP TTL (from SDP content - not used in RTSP) */
91 int sdp_payload_type
; /* payload type - only used in SDP */
92 rtp_payload_data_t rtp_payload_data
; /* rtp payload parsing infos from SDP */
94 RTPDynamicProtocolHandler
*dynamic_handler
; ///< Only valid if it's a dynamic protocol. (This is the handler structure)
95 PayloadContext
*dynamic_protocol_context
; ///< Only valid if it's a dynamic protocol. (This is any private data associated with the dynamic protocol)
98 static int rtsp_read_play(AVFormatContext
*s
);
100 /* XXX: currently, the only way to change the protocols consists in
101 changing this variable */
103 #if LIBAVFORMAT_VERSION_INT < (53 << 16)
104 int rtsp_default_protocols
= (1 << RTSP_LOWER_TRANSPORT_UDP
);
107 static int rtsp_probe(AVProbeData
*p
)
109 if (av_strstart(p
->filename
, "rtsp:", NULL
))
110 return AVPROBE_SCORE_MAX
;
114 static int redir_isspace(int c
)
116 return c
== ' ' || c
== '\t' || c
== '\n' || c
== '\r';
119 static void skip_spaces(const char **pp
)
123 while (redir_isspace(*p
))
128 static void get_word_sep(char *buf
, int buf_size
, const char *sep
,
139 while (!strchr(sep
, *p
) && *p
!= '\0') {
140 if ((q
- buf
) < buf_size
- 1)
149 static void get_word(char *buf
, int buf_size
, const char **pp
)
157 while (!redir_isspace(*p
) && *p
!= '\0') {
158 if ((q
- buf
) < buf_size
- 1)
167 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other
169 static int sdp_parse_rtpmap(AVCodecContext
*codec
, RTSPStream
*rtsp_st
, int payload_type
, const char *p
)
176 /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
177 see if we can handle this kind of payload */
178 get_word_sep(buf
, sizeof(buf
), "/", &p
);
179 if (payload_type
>= RTP_PT_PRIVATE
) {
180 RTPDynamicProtocolHandler
*handler
= RTPFirstDynamicPayloadHandler
;
182 if (!strcmp(buf
, handler
->enc_name
) && (codec
->codec_type
== handler
->codec_type
)) {
183 codec
->codec_id
= handler
->codec_id
;
184 rtsp_st
->dynamic_handler
= handler
;
186 rtsp_st
->dynamic_protocol_context
= handler
->open();
190 handler
= handler
->next
;
193 /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
194 /* search into AVRtpPayloadTypes[] */
195 codec
->codec_id
= ff_rtp_codec_id(buf
, codec
->codec_type
);
198 c
= avcodec_find_decoder(codec
->codec_id
);
202 c_name
= (char *)NULL
;
205 get_word_sep(buf
, sizeof(buf
), "/", &p
);
207 switch (codec
->codec_type
) {
208 case CODEC_TYPE_AUDIO
:
209 av_log(codec
, AV_LOG_DEBUG
, " audio codec set to : %s\n", c_name
);
210 codec
->sample_rate
= RTSP_DEFAULT_AUDIO_SAMPLERATE
;
211 codec
->channels
= RTSP_DEFAULT_NB_AUDIO_CHANNELS
;
213 codec
->sample_rate
= i
;
214 get_word_sep(buf
, sizeof(buf
), "/", &p
);
218 // TODO: there is a bug here; if it is a mono stream, and less than 22000Hz, faad upconverts to stereo and twice the
219 // frequency. No problem, but the sample rate is being set here by the sdp line. Upcoming patch forthcoming. (rdm)
221 av_log(codec
, AV_LOG_DEBUG
, " audio samplerate set to : %i\n", codec
->sample_rate
);
222 av_log(codec
, AV_LOG_DEBUG
, " audio channels set to : %i\n", codec
->channels
);
224 case CODEC_TYPE_VIDEO
:
225 av_log(codec
, AV_LOG_DEBUG
, " video codec set to : %s\n", c_name
);
236 /* return the length and optionnaly the data */
237 static int hex_to_data(uint8_t *data
, const char *p
)
247 c
= toupper((unsigned char)*p
++);
248 if (c
>= '0' && c
<= '9')
250 else if (c
>= 'A' && c
<= 'F')
265 static void sdp_parse_fmtp_config(AVCodecContext
*codec
, char *attr
, char *value
)
267 switch (codec
->codec_id
) {
270 if (!strcmp(attr
, "config")) {
271 /* decode the hexa encoded parameter */
272 int len
= hex_to_data(NULL
, value
);
273 codec
->extradata
= av_mallocz(len
+ FF_INPUT_BUFFER_PADDING_SIZE
);
274 if (!codec
->extradata
)
276 codec
->extradata_size
= len
;
277 hex_to_data(codec
->extradata
, value
);
286 typedef struct attrname_map
293 /* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
294 #define ATTR_NAME_TYPE_INT 0
295 #define ATTR_NAME_TYPE_STR 1
296 static const attrname_map_t attr_names
[]=
298 {"SizeLength", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, sizelength
)},
299 {"IndexLength", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, indexlength
)},
300 {"IndexDeltaLength", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, indexdeltalength
)},
301 {"profile-level-id", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, profile_level_id
)},
302 {"StreamType", ATTR_NAME_TYPE_INT
, offsetof(rtp_payload_data_t
, streamtype
)},
303 {"mode", ATTR_NAME_TYPE_STR
, offsetof(rtp_payload_data_t
, mode
)},
307 /** parse the attribute line from the fmtp a line of an sdp resonse. This is broken out as a function
308 * because it is used in rtp_h264.c, which is forthcoming.
310 int rtsp_next_attr_and_value(const char **p
, char *attr
, int attr_size
, char *value
, int value_size
)
315 get_word_sep(attr
, attr_size
, "=", p
);
318 get_word_sep(value
, value_size
, ";", p
);
326 /* parse a SDP line and save stream attributes */
327 static void sdp_parse_fmtp(AVStream
*st
, const char *p
)
333 RTSPStream
*rtsp_st
= st
->priv_data
;
334 AVCodecContext
*codec
= st
->codec
;
335 rtp_payload_data_t
*rtp_payload_data
= &rtsp_st
->rtp_payload_data
;
337 /* loop on each attribute */
338 while(rtsp_next_attr_and_value(&p
, attr
, sizeof(attr
), value
, sizeof(value
)))
340 /* grab the codec extra_data from the config parameter of the fmtp line */
341 sdp_parse_fmtp_config(codec
, attr
, value
);
342 /* Looking for a known attribute */
343 for (i
= 0; attr_names
[i
].str
; ++i
) {
344 if (!strcasecmp(attr
, attr_names
[i
].str
)) {
345 if (attr_names
[i
].type
== ATTR_NAME_TYPE_INT
)
346 *(int *)((char *)rtp_payload_data
+ attr_names
[i
].offset
) = atoi(value
);
347 else if (attr_names
[i
].type
== ATTR_NAME_TYPE_STR
)
348 *(char **)((char *)rtp_payload_data
+ attr_names
[i
].offset
) = av_strdup(value
);
354 /** Parse a string \p in the form of Range:npt=xx-xx, and determine the start
356 * Used for seeking in the rtp stream.
358 static void rtsp_parse_range_npt(const char *p
, int64_t *start
, int64_t *end
)
363 if (!av_stristart(p
, "npt=", &p
))
366 *start
= AV_NOPTS_VALUE
;
367 *end
= AV_NOPTS_VALUE
;
369 get_word_sep(buf
, sizeof(buf
), "-", &p
);
370 *start
= parse_date(buf
, 1);
373 get_word_sep(buf
, sizeof(buf
), "-", &p
);
374 *end
= parse_date(buf
, 1);
376 // av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
377 // av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
380 typedef struct SDPParseState
{
382 struct in_addr default_ip
;
386 static void sdp_parse_line(AVFormatContext
*s
, SDPParseState
*s1
,
387 int letter
, const char *buf
)
389 RTSPState
*rt
= s
->priv_data
;
390 char buf1
[64], st_type
[64];
392 enum CodecType codec_type
;
396 struct in_addr sdp_ip
;
400 printf("sdp: %c='%s'\n", letter
, buf
);
406 get_word(buf1
, sizeof(buf1
), &p
);
407 if (strcmp(buf1
, "IN") != 0)
409 get_word(buf1
, sizeof(buf1
), &p
);
410 if (strcmp(buf1
, "IP4") != 0)
412 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
413 if (inet_aton(buf1
, &sdp_ip
) == 0)
418 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
421 if (s
->nb_streams
== 0) {
422 s1
->default_ip
= sdp_ip
;
423 s1
->default_ttl
= ttl
;
425 st
= s
->streams
[s
->nb_streams
- 1];
426 rtsp_st
= st
->priv_data
;
427 rtsp_st
->sdp_ip
= sdp_ip
;
428 rtsp_st
->sdp_ttl
= ttl
;
432 av_strlcpy(s
->title
, p
, sizeof(s
->title
));
435 if (s
->nb_streams
== 0) {
436 av_strlcpy(s
->comment
, p
, sizeof(s
->comment
));
442 get_word(st_type
, sizeof(st_type
), &p
);
443 if (!strcmp(st_type
, "audio")) {
444 codec_type
= CODEC_TYPE_AUDIO
;
445 } else if (!strcmp(st_type
, "video")) {
446 codec_type
= CODEC_TYPE_VIDEO
;
450 rtsp_st
= av_mallocz(sizeof(RTSPStream
));
453 rtsp_st
->stream_index
= -1;
454 dynarray_add(&rt
->rtsp_streams
, &rt
->nb_rtsp_streams
, rtsp_st
);
456 rtsp_st
->sdp_ip
= s1
->default_ip
;
457 rtsp_st
->sdp_ttl
= s1
->default_ttl
;
459 get_word(buf1
, sizeof(buf1
), &p
); /* port */
460 rtsp_st
->sdp_port
= atoi(buf1
);
462 get_word(buf1
, sizeof(buf1
), &p
); /* protocol (ignored) */
464 /* XXX: handle list of formats */
465 get_word(buf1
, sizeof(buf1
), &p
); /* format list */
466 rtsp_st
->sdp_payload_type
= atoi(buf1
);
468 if (!strcmp(ff_rtp_enc_name(rtsp_st
->sdp_payload_type
), "MP2T")) {
469 /* no corresponding stream */
471 st
= av_new_stream(s
, 0);
474 st
->priv_data
= rtsp_st
;
475 rtsp_st
->stream_index
= st
->index
;
476 st
->codec
->codec_type
= codec_type
;
477 if (rtsp_st
->sdp_payload_type
< RTP_PT_PRIVATE
) {
478 /* if standard payload type, we can find the codec right now */
479 rtp_get_codec_info(st
->codec
, rtsp_st
->sdp_payload_type
);
482 /* put a default control url */
483 av_strlcpy(rtsp_st
->control_url
, s
->filename
, sizeof(rtsp_st
->control_url
));
486 if (av_strstart(p
, "control:", &p
) && s
->nb_streams
> 0) {
488 /* get the control url */
489 st
= s
->streams
[s
->nb_streams
- 1];
490 rtsp_st
= st
->priv_data
;
492 /* XXX: may need to add full url resolution */
493 url_split(proto
, sizeof(proto
), NULL
, 0, NULL
, 0, NULL
, NULL
, 0, p
);
494 if (proto
[0] == '\0') {
495 /* relative control URL */
496 av_strlcat(rtsp_st
->control_url
, "/", sizeof(rtsp_st
->control_url
));
497 av_strlcat(rtsp_st
->control_url
, p
, sizeof(rtsp_st
->control_url
));
499 av_strlcpy(rtsp_st
->control_url
, p
, sizeof(rtsp_st
->control_url
));
501 } else if (av_strstart(p
, "rtpmap:", &p
)) {
502 /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
503 get_word(buf1
, sizeof(buf1
), &p
);
504 payload_type
= atoi(buf1
);
505 for(i
= 0; i
< s
->nb_streams
;i
++) {
507 rtsp_st
= st
->priv_data
;
508 if (rtsp_st
->sdp_payload_type
== payload_type
) {
509 sdp_parse_rtpmap(st
->codec
, rtsp_st
, payload_type
, p
);
512 } else if (av_strstart(p
, "fmtp:", &p
)) {
513 /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
514 get_word(buf1
, sizeof(buf1
), &p
);
515 payload_type
= atoi(buf1
);
516 for(i
= 0; i
< s
->nb_streams
;i
++) {
518 rtsp_st
= st
->priv_data
;
519 if (rtsp_st
->sdp_payload_type
== payload_type
) {
520 if(rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_handler
->parse_sdp_a_line
) {
521 if(!rtsp_st
->dynamic_handler
->parse_sdp_a_line(st
, rtsp_st
->dynamic_protocol_context
, buf
)) {
522 sdp_parse_fmtp(st
, p
);
525 sdp_parse_fmtp(st
, p
);
529 } else if(av_strstart(p
, "framesize:", &p
)) {
530 // let dynamic protocol handlers have a stab at the line.
531 get_word(buf1
, sizeof(buf1
), &p
);
532 payload_type
= atoi(buf1
);
533 for(i
= 0; i
< s
->nb_streams
;i
++) {
535 rtsp_st
= st
->priv_data
;
536 if (rtsp_st
->sdp_payload_type
== payload_type
) {
537 if(rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_handler
->parse_sdp_a_line
) {
538 rtsp_st
->dynamic_handler
->parse_sdp_a_line(st
, rtsp_st
->dynamic_protocol_context
, buf
);
542 } else if(av_strstart(p
, "range:", &p
)) {
545 // this is so that seeking on a streamed file can work.
546 rtsp_parse_range_npt(p
, &start
, &end
);
547 s
->start_time
= start
;
548 s
->duration
= (end
==AV_NOPTS_VALUE
)?AV_NOPTS_VALUE
:end
-start
; // AV_NOPTS_VALUE means live broadcast (and can't seek)
549 } else if (av_strstart(p
, "IsRealDataType:integer;",&p
)) {
551 rt
->transport
= RTSP_TRANSPORT_RDT
;
552 } else if (s
->nb_streams
> 0) {
553 rtsp_st
= s
->streams
[s
->nb_streams
- 1]->priv_data
;
554 if (rtsp_st
->dynamic_handler
&&
555 rtsp_st
->dynamic_handler
->parse_sdp_a_line
)
556 rtsp_st
->dynamic_handler
->parse_sdp_a_line(s
->streams
[s
->nb_streams
- 1],
557 rtsp_st
->dynamic_protocol_context
, buf
);
563 static int sdp_parse(AVFormatContext
*s
, const char *content
)
568 SDPParseState sdp_parse_state
, *s1
= &sdp_parse_state
;
570 memset(s1
, 0, sizeof(SDPParseState
));
581 /* get the content */
583 while (*p
!= '\n' && *p
!= '\r' && *p
!= '\0') {
584 if ((q
- buf
) < sizeof(buf
) - 1)
589 sdp_parse_line(s
, s1
, letter
, buf
);
591 while (*p
!= '\n' && *p
!= '\0')
599 static void rtsp_parse_range(int *min_ptr
, int *max_ptr
, const char **pp
)
606 v
= strtol(p
, (char **)&p
, 10);
610 v
= strtol(p
, (char **)&p
, 10);
619 /* XXX: only one transport specification is parsed */
620 static void rtsp_parse_transport(RTSPHeader
*reply
, const char *p
)
622 char transport_protocol
[16];
624 char lower_transport
[16];
626 RTSPTransportField
*th
;
629 reply
->nb_transports
= 0;
636 th
= &reply
->transports
[reply
->nb_transports
];
638 get_word_sep(transport_protocol
, sizeof(transport_protocol
),
642 if (!strcasecmp (transport_protocol
, "rtp")) {
643 get_word_sep(profile
, sizeof(profile
), "/;,", &p
);
644 lower_transport
[0] = '\0';
645 /* rtp/avp/<protocol> */
648 get_word_sep(lower_transport
, sizeof(lower_transport
),
651 th
->transport
= RTSP_TRANSPORT_RTP
;
652 } else if (!strcasecmp (transport_protocol
, "x-pn-tng") ||
653 !strcasecmp (transport_protocol
, "x-real-rdt")) {
654 /* x-pn-tng/<protocol> */
655 get_word_sep(lower_transport
, sizeof(lower_transport
), "/;,", &p
);
657 th
->transport
= RTSP_TRANSPORT_RDT
;
659 if (!strcasecmp(lower_transport
, "TCP"))
660 th
->lower_transport
= RTSP_LOWER_TRANSPORT_TCP
;
662 th
->lower_transport
= RTSP_LOWER_TRANSPORT_UDP
;
666 /* get each parameter */
667 while (*p
!= '\0' && *p
!= ',') {
668 get_word_sep(parameter
, sizeof(parameter
), "=;,", &p
);
669 if (!strcmp(parameter
, "port")) {
672 rtsp_parse_range(&th
->port_min
, &th
->port_max
, &p
);
674 } else if (!strcmp(parameter
, "client_port")) {
677 rtsp_parse_range(&th
->client_port_min
,
678 &th
->client_port_max
, &p
);
680 } else if (!strcmp(parameter
, "server_port")) {
683 rtsp_parse_range(&th
->server_port_min
,
684 &th
->server_port_max
, &p
);
686 } else if (!strcmp(parameter
, "interleaved")) {
689 rtsp_parse_range(&th
->interleaved_min
,
690 &th
->interleaved_max
, &p
);
692 } else if (!strcmp(parameter
, "multicast")) {
693 if (th
->lower_transport
== RTSP_LOWER_TRANSPORT_UDP
)
694 th
->lower_transport
= RTSP_LOWER_TRANSPORT_UDP_MULTICAST
;
695 } else if (!strcmp(parameter
, "ttl")) {
698 th
->ttl
= strtol(p
, (char **)&p
, 10);
700 } else if (!strcmp(parameter
, "destination")) {
701 struct in_addr ipaddr
;
705 get_word_sep(buf
, sizeof(buf
), ";,", &p
);
706 if (inet_aton(buf
, &ipaddr
))
707 th
->destination
= ntohl(ipaddr
.s_addr
);
710 while (*p
!= ';' && *p
!= '\0' && *p
!= ',')
718 reply
->nb_transports
++;
722 void rtsp_parse_line(RTSPHeader
*reply
, const char *buf
)
726 /* NOTE: we do case independent match for broken servers */
728 if (av_stristart(p
, "Session:", &p
)) {
729 get_word_sep(reply
->session_id
, sizeof(reply
->session_id
), ";", &p
);
730 } else if (av_stristart(p
, "Content-Length:", &p
)) {
731 reply
->content_length
= strtol(p
, NULL
, 10);
732 } else if (av_stristart(p
, "Transport:", &p
)) {
733 rtsp_parse_transport(reply
, p
);
734 } else if (av_stristart(p
, "CSeq:", &p
)) {
735 reply
->seq
= strtol(p
, NULL
, 10);
736 } else if (av_stristart(p
, "Range:", &p
)) {
737 rtsp_parse_range_npt(p
, &reply
->range_start
, &reply
->range_end
);
738 } else if (av_stristart(p
, "RealChallenge1:", &p
)) {
740 av_strlcpy(reply
->real_challenge
, p
, sizeof(reply
->real_challenge
));
744 static int url_readbuf(URLContext
*h
, unsigned char *buf
, int size
)
750 ret
= url_read(h
, buf
+len
, size
-len
);
758 /* skip a RTP/TCP interleaved packet */
759 static void rtsp_skip_packet(AVFormatContext
*s
)
761 RTSPState
*rt
= s
->priv_data
;
765 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 3);
768 len
= AV_RB16(buf
+ 1);
770 printf("skipping RTP packet len=%d\n", len
);
775 if (len1
> sizeof(buf
))
777 ret
= url_readbuf(rt
->rtsp_hd
, buf
, len1
);
784 static void rtsp_send_cmd(AVFormatContext
*s
,
785 const char *cmd
, RTSPHeader
*reply
,
786 unsigned char **content_ptr
)
788 RTSPState
*rt
= s
->priv_data
;
789 char buf
[4096], buf1
[1024], *q
;
792 int content_length
, line_count
;
793 unsigned char *content
= NULL
;
795 memset(reply
, 0, sizeof(RTSPHeader
));
798 av_strlcpy(buf
, cmd
, sizeof(buf
));
799 snprintf(buf1
, sizeof(buf1
), "CSeq: %d\r\n", rt
->seq
);
800 av_strlcat(buf
, buf1
, sizeof(buf
));
801 if (rt
->session_id
[0] != '\0' && !strstr(cmd
, "\nIf-Match:")) {
802 snprintf(buf1
, sizeof(buf1
), "Session: %s\r\n", rt
->session_id
);
803 av_strlcat(buf
, buf1
, sizeof(buf
));
805 av_strlcat(buf
, "\r\n", sizeof(buf
));
807 printf("Sending:\n%s--\n", buf
);
809 url_write(rt
->rtsp_hd
, buf
, strlen(buf
));
811 /* parse reply (XXX: use buffers) */
813 rt
->last_reply
[0] = '\0';
817 if (url_readbuf(rt
->rtsp_hd
, &ch
, 1) != 1)
822 /* XXX: only parse it if first char on line ? */
824 } else if (ch
!= '\r') {
825 if ((q
- buf
) < sizeof(buf
) - 1)
831 printf("line='%s'\n", buf
);
833 /* test if last line */
837 if (line_count
== 0) {
839 get_word(buf1
, sizeof(buf1
), &p
);
840 get_word(buf1
, sizeof(buf1
), &p
);
841 reply
->status_code
= atoi(buf1
);
843 rtsp_parse_line(reply
, p
);
844 av_strlcat(rt
->last_reply
, p
, sizeof(rt
->last_reply
));
845 av_strlcat(rt
->last_reply
, "\n", sizeof(rt
->last_reply
));
850 if (rt
->session_id
[0] == '\0' && reply
->session_id
[0] != '\0')
851 av_strlcpy(rt
->session_id
, reply
->session_id
, sizeof(rt
->session_id
));
853 content_length
= reply
->content_length
;
854 if (content_length
> 0) {
855 /* leave some room for a trailing '\0' (useful for simple parsing) */
856 content
= av_malloc(content_length
+ 1);
857 (void)url_readbuf(rt
->rtsp_hd
, content
, content_length
);
858 content
[content_length
] = '\0';
861 *content_ptr
= content
;
867 /* close and free RTSP streams */
868 static void rtsp_close_streams(RTSPState
*rt
)
873 for(i
=0;i
<rt
->nb_rtsp_streams
;i
++) {
874 rtsp_st
= rt
->rtsp_streams
[i
];
876 if (rtsp_st
->tx_ctx
) {
877 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
878 ff_rdt_parse_close(rtsp_st
->tx_ctx
);
880 rtp_parse_close(rtsp_st
->tx_ctx
);
882 if (rtsp_st
->rtp_handle
)
883 url_close(rtsp_st
->rtp_handle
);
884 if (rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_protocol_context
)
885 rtsp_st
->dynamic_handler
->close(rtsp_st
->dynamic_protocol_context
);
888 av_free(rt
->rtsp_streams
);
892 rtsp_open_transport_ctx(AVFormatContext
*s
, RTSPStream
*rtsp_st
)
894 RTSPState
*rt
= s
->priv_data
;
897 /* open the RTP context */
898 if (rtsp_st
->stream_index
>= 0)
899 st
= s
->streams
[rtsp_st
->stream_index
];
901 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
903 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
904 rtsp_st
->tx_ctx
= ff_rdt_parse_open(s
, st
,
905 rtsp_st
->dynamic_protocol_context
,
906 rtsp_st
->dynamic_handler
);
908 rtsp_st
->tx_ctx
= rtp_parse_open(s
, st
, rtsp_st
->rtp_handle
,
909 rtsp_st
->sdp_payload_type
,
910 &rtsp_st
->rtp_payload_data
);
912 if (!rtsp_st
->tx_ctx
) {
913 return AVERROR(ENOMEM
);
914 } else if (rt
->transport
!= RTSP_TRANSPORT_RDT
) {
915 if(rtsp_st
->dynamic_handler
) {
916 rtp_parse_set_dynamic_protocol(rtsp_st
->tx_ctx
,
917 rtsp_st
->dynamic_protocol_context
,
918 rtsp_st
->dynamic_handler
);
926 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
929 make_setup_request (AVFormatContext
*s
, const char *host
, int port
,
930 int lower_transport
, const char *real_challenge
)
932 RTSPState
*rt
= s
->priv_data
;
935 RTSPHeader reply1
, *reply
= &reply1
;
937 const char *trans_pref
;
939 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
940 trans_pref
= "x-pn-tng";
942 trans_pref
= "RTP/AVP";
944 /* for each stream, make the setup request */
945 /* XXX: we assume the same server is used for the control of each
948 for(j
= RTSP_RTP_PORT_MIN
, i
= 0; i
< rt
->nb_rtsp_streams
; ++i
) {
949 char transport
[2048];
951 rtsp_st
= rt
->rtsp_streams
[i
];
954 if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
) {
957 /* first try in specified port range */
958 if (RTSP_RTP_PORT_MIN
!= 0) {
959 while(j
<= RTSP_RTP_PORT_MAX
) {
960 snprintf(buf
, sizeof(buf
), "rtp://%s?localport=%d", host
, j
);
961 j
+= 2; /* we will use two port by rtp stream (rtp and rtcp) */
962 if (url_open(&rtsp_st
->rtp_handle
, buf
, URL_RDWR
) == 0) {
968 /* then try on any port
969 ** if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
970 ** err = AVERROR_INVALIDDATA;
976 port
= rtp_get_local_port(rtsp_st
->rtp_handle
);
977 snprintf(transport
, sizeof(transport
) - 1,
978 "%s/UDP;", trans_pref
);
979 if (rt
->server_type
!= RTSP_SERVER_REAL
)
980 av_strlcat(transport
, "unicast;", sizeof(transport
));
981 av_strlcatf(transport
, sizeof(transport
),
982 "client_port=%d", port
);
983 if (rt
->transport
== RTSP_TRANSPORT_RTP
)
984 av_strlcatf(transport
, sizeof(transport
), "-%d", port
+ 1);
988 else if (lower_transport
== RTSP_LOWER_TRANSPORT_TCP
) {
989 snprintf(transport
, sizeof(transport
) - 1,
990 "%s/TCP", trans_pref
);
993 else if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP_MULTICAST
) {
994 snprintf(transport
, sizeof(transport
) - 1,
995 "%s/UDP;multicast", trans_pref
);
997 if (rt
->server_type
== RTSP_SERVER_REAL
)
998 av_strlcat(transport
, ";mode=play", sizeof(transport
));
999 snprintf(cmd
, sizeof(cmd
),
1000 "SETUP %s RTSP/1.0\r\n"
1001 "Transport: %s\r\n",
1002 rtsp_st
->control_url
, transport
);
1003 if (i
== 0 && rt
->server_type
== RTSP_SERVER_REAL
) {
1004 char real_res
[41], real_csum
[9];
1005 ff_rdt_calc_response_and_checksum(real_res
, real_csum
,
1007 av_strlcatf(cmd
, sizeof(cmd
),
1009 "RealChallenge2: %s, sd=%s\r\n",
1010 rt
->session_id
, real_res
, real_csum
);
1012 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1013 if (reply
->status_code
== 461 /* Unsupported protocol */ && i
== 0) {
1016 } else if (reply
->status_code
!= RTSP_STATUS_OK
||
1017 reply
->nb_transports
!= 1) {
1018 err
= AVERROR_INVALIDDATA
;
1022 /* XXX: same protocol for all streams is required */
1024 if (reply
->transports
[0].lower_transport
!= rt
->lower_transport
||
1025 reply
->transports
[0].transport
!= rt
->transport
) {
1026 err
= AVERROR_INVALIDDATA
;
1030 rt
->lower_transport
= reply
->transports
[0].lower_transport
;
1031 rt
->transport
= reply
->transports
[0].transport
;
1034 /* close RTP connection if not choosen */
1035 if (reply
->transports
[0].lower_transport
!= RTSP_LOWER_TRANSPORT_UDP
&&
1036 (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
)) {
1037 url_close(rtsp_st
->rtp_handle
);
1038 rtsp_st
->rtp_handle
= NULL
;
1041 switch(reply
->transports
[0].lower_transport
) {
1042 case RTSP_LOWER_TRANSPORT_TCP
:
1043 rtsp_st
->interleaved_min
= reply
->transports
[0].interleaved_min
;
1044 rtsp_st
->interleaved_max
= reply
->transports
[0].interleaved_max
;
1047 case RTSP_LOWER_TRANSPORT_UDP
:
1051 /* XXX: also use address if specified */
1052 snprintf(url
, sizeof(url
), "rtp://%s:%d",
1053 host
, reply
->transports
[0].server_port_min
);
1054 if (rtp_set_remote_url(rtsp_st
->rtp_handle
, url
) < 0) {
1055 err
= AVERROR_INVALIDDATA
;
1060 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
:
1065 in
.s_addr
= htonl(reply
->transports
[0].destination
);
1066 snprintf(url
, sizeof(url
), "rtp://%s:%d?ttl=%d",
1068 reply
->transports
[0].port_min
,
1069 reply
->transports
[0].ttl
);
1070 if (url_open(&rtsp_st
->rtp_handle
, url
, URL_RDWR
) < 0) {
1071 err
= AVERROR_INVALIDDATA
;
1078 if ((err
= rtsp_open_transport_ctx(s
, rtsp_st
)))
1082 if (rt
->server_type
== RTSP_SERVER_REAL
)
1083 rt
->need_subscription
= 1;
1088 for (i
=0; i
<rt
->nb_rtsp_streams
; i
++) {
1089 if (rt
->rtsp_streams
[i
]->rtp_handle
) {
1090 url_close(rt
->rtsp_streams
[i
]->rtp_handle
);
1091 rt
->rtsp_streams
[i
]->rtp_handle
= NULL
;
1097 static int rtsp_read_header(AVFormatContext
*s
,
1098 AVFormatParameters
*ap
)
1100 RTSPState
*rt
= s
->priv_data
;
1101 char host
[1024], path
[1024], tcpname
[1024], cmd
[2048], *option_list
, *option
;
1102 URLContext
*rtsp_hd
;
1104 RTSPHeader reply1
, *reply
= &reply1
;
1105 unsigned char *content
= NULL
;
1106 int lower_transport_mask
= 0;
1107 char real_challenge
[64];
1109 /* extract hostname and port */
1110 url_split(NULL
, 0, NULL
, 0,
1111 host
, sizeof(host
), &port
, path
, sizeof(path
), s
->filename
);
1113 port
= RTSP_DEFAULT_PORT
;
1115 /* search for options */
1116 option_list
= strchr(path
, '?');
1118 /* remove the options from the path */
1120 while(option_list
) {
1121 /* move the option pointer */
1122 option
= option_list
;
1123 option_list
= strchr(option_list
, '&');
1125 *(option_list
++) = 0;
1126 /* handle the options */
1127 if (strcmp(option
, "udp") == 0)
1128 lower_transport_mask
= (1<< RTSP_LOWER_TRANSPORT_UDP
);
1129 else if (strcmp(option
, "multicast") == 0)
1130 lower_transport_mask
= (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST
);
1131 else if (strcmp(option
, "tcp") == 0)
1132 lower_transport_mask
= (1<< RTSP_LOWER_TRANSPORT_TCP
);
1136 if (!lower_transport_mask
)
1137 lower_transport_mask
= (1 << RTSP_LOWER_TRANSPORT_LAST
) - 1;
1139 /* open the tcp connexion */
1140 snprintf(tcpname
, sizeof(tcpname
), "tcp://%s:%d", host
, port
);
1141 if (url_open(&rtsp_hd
, tcpname
, URL_RDWR
) < 0)
1142 return AVERROR(EIO
);
1143 rt
->rtsp_hd
= rtsp_hd
;
1146 /* request options supported by the server; this also detects server type */
1147 for (rt
->server_type
= RTSP_SERVER_RTP
;;) {
1148 snprintf(cmd
, sizeof(cmd
),
1149 "OPTIONS %s RTSP/1.0\r\n", s
->filename
);
1150 if (rt
->server_type
== RTSP_SERVER_REAL
)
1153 * The following entries are required for proper
1154 * streaming from a Realmedia server. They are
1155 * interdependent in some way although we currently
1156 * don't quite understand how. Values were copied
1157 * from mplayer SVN r23589.
1158 * @param CompanyID is a 16-byte ID in base64
1159 * @param ClientChallenge is a 16-byte ID in hex
1161 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1162 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1163 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1164 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1166 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1167 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1168 err
= AVERROR_INVALIDDATA
;
1172 /* detect server type if not standard-compliant RTP */
1173 if (rt
->server_type
!= RTSP_SERVER_REAL
&& reply
->real_challenge
[0]) {
1174 rt
->server_type
= RTSP_SERVER_REAL
;
1176 } else if (rt
->server_type
== RTSP_SERVER_REAL
) {
1177 strcpy(real_challenge
, reply
->real_challenge
);
1182 /* describe the stream */
1183 snprintf(cmd
, sizeof(cmd
),
1184 "DESCRIBE %s RTSP/1.0\r\n"
1185 "Accept: application/sdp\r\n",
1187 if (rt
->server_type
== RTSP_SERVER_REAL
) {
1189 * The Require: attribute is needed for proper streaming from
1190 * Realmedia servers.
1193 "Require: com.real.retain-entity-for-setup\r\n",
1196 rtsp_send_cmd(s
, cmd
, reply
, &content
);
1198 err
= AVERROR_INVALIDDATA
;
1201 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1202 err
= AVERROR_INVALIDDATA
;
1206 /* now we got the SDP description, we parse it */
1207 ret
= sdp_parse(s
, (const char *)content
);
1210 err
= AVERROR_INVALIDDATA
;
1215 int lower_transport
= ff_log2_tab
[lower_transport_mask
& ~(lower_transport_mask
- 1)];
1217 err
= make_setup_request(s
, host
, port
, lower_transport
,
1218 rt
->server_type
== RTSP_SERVER_REAL
?
1219 real_challenge
: NULL
);
1222 lower_transport_mask
&= ~(1 << lower_transport
);
1223 if (lower_transport_mask
== 0 && err
== 1) {
1224 err
= AVERROR(FF_NETERROR(EPROTONOSUPPORT
));
1229 rt
->state
= RTSP_STATE_IDLE
;
1230 rt
->seek_timestamp
= 0; /* default is to start stream at position
1232 if (ap
->initial_pause
) {
1233 /* do not start immediately */
1235 if (rtsp_read_play(s
) < 0) {
1236 err
= AVERROR_INVALIDDATA
;
1242 rtsp_close_streams(rt
);
1244 url_close(rt
->rtsp_hd
);
1248 static int tcp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1249 uint8_t *buf
, int buf_size
)
1251 RTSPState
*rt
= s
->priv_data
;
1252 int id
, len
, i
, ret
;
1253 RTSPStream
*rtsp_st
;
1255 #ifdef DEBUG_RTP_TCP
1256 printf("tcp_read_packet:\n");
1260 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 1);
1261 #ifdef DEBUG_RTP_TCP
1262 printf("ret=%d c=%02x [%c]\n", ret
, buf
[0], buf
[0]);
1269 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 3);
1273 len
= AV_RB16(buf
+ 1);
1274 #ifdef DEBUG_RTP_TCP
1275 printf("id=%d len=%d\n", id
, len
);
1277 if (len
> buf_size
|| len
< 12)
1280 ret
= url_readbuf(rt
->rtsp_hd
, buf
, len
);
1283 if (rt
->transport
== RTSP_TRANSPORT_RDT
&&
1284 ff_rdt_parse_header(buf
, len
, &id
, NULL
, NULL
, NULL
) < 0)
1287 /* find the matching stream */
1288 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1289 rtsp_st
= rt
->rtsp_streams
[i
];
1290 if (id
>= rtsp_st
->interleaved_min
&&
1291 id
<= rtsp_st
->interleaved_max
)
1296 *prtsp_st
= rtsp_st
;
1300 static int udp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1301 uint8_t *buf
, int buf_size
)
1303 RTSPState
*rt
= s
->priv_data
;
1304 RTSPStream
*rtsp_st
;
1306 int fd1
, fd2
, fd_max
, n
, i
, ret
;
1310 if (url_interrupt_cb())
1311 return AVERROR(EINTR
);
1314 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1315 rtsp_st
= rt
->rtsp_streams
[i
];
1316 /* currently, we cannot probe RTCP handle because of blocking restrictions */
1317 rtp_get_file_handles(rtsp_st
->rtp_handle
, &fd1
, &fd2
);
1323 tv
.tv_usec
= 100 * 1000;
1324 n
= select(fd_max
+ 1, &rfds
, NULL
, NULL
, &tv
);
1326 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1327 rtsp_st
= rt
->rtsp_streams
[i
];
1328 rtp_get_file_handles(rtsp_st
->rtp_handle
, &fd1
, &fd2
);
1329 if (FD_ISSET(fd1
, &rfds
)) {
1330 ret
= url_read(rtsp_st
->rtp_handle
, buf
, buf_size
);
1332 *prtsp_st
= rtsp_st
;
1341 static int rtsp_read_packet(AVFormatContext
*s
,
1344 RTSPState
*rt
= s
->priv_data
;
1345 RTSPStream
*rtsp_st
;
1347 uint8_t buf
[RTP_MAX_PACKET_LENGTH
];
1349 if (rt
->server_type
== RTSP_SERVER_REAL
&& rt
->need_subscription
) {
1351 RTSPHeader reply1
, *reply
= &reply1
;
1354 snprintf(cmd
, sizeof(cmd
),
1355 "SET_PARAMETER %s RTSP/1.0\r\n"
1358 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1359 if (i
!= 0) av_strlcat(cmd
, ",", sizeof(cmd
));
1360 ff_rdt_subscribe_rule(cmd
, sizeof(cmd
), i
, 0);
1361 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
1362 ff_rdt_subscribe_rule2(
1363 rt
->rtsp_streams
[i
]->tx_ctx
,
1364 cmd
, sizeof(cmd
), i
, 0);
1366 av_strlcat(cmd
, "\r\n", sizeof(cmd
));
1367 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1368 if (reply
->status_code
!= RTSP_STATUS_OK
)
1369 return AVERROR_INVALIDDATA
;
1370 rt
->need_subscription
= 0;
1372 if (rt
->state
== RTSP_STATE_PLAYING
)
1376 /* get next frames from the same RTP packet */
1378 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
1379 ret
= ff_rdt_parse_packet(rt
->cur_tx
, pkt
, NULL
, 0);
1381 ret
= rtp_parse_packet(rt
->cur_tx
, pkt
, NULL
, 0);
1385 } else if (ret
== 1) {
1392 /* read next RTP packet */
1394 switch(rt
->lower_transport
) {
1396 case RTSP_LOWER_TRANSPORT_TCP
:
1397 len
= tcp_read_packet(s
, &rtsp_st
, buf
, sizeof(buf
));
1399 case RTSP_LOWER_TRANSPORT_UDP
:
1400 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
:
1401 len
= udp_read_packet(s
, &rtsp_st
, buf
, sizeof(buf
));
1402 if (len
>=0 && rtsp_st
->tx_ctx
)
1403 rtp_check_and_send_back_rr(rtsp_st
->tx_ctx
, len
);
1408 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
1409 ret
= ff_rdt_parse_packet(rtsp_st
->tx_ctx
, pkt
, buf
, len
);
1411 ret
= rtp_parse_packet(rtsp_st
->tx_ctx
, pkt
, buf
, len
);
1415 /* more packets may follow, so we save the RTP context */
1416 rt
->cur_tx
= rtsp_st
->tx_ctx
;
1421 static int rtsp_read_play(AVFormatContext
*s
)
1423 RTSPState
*rt
= s
->priv_data
;
1424 RTSPHeader reply1
, *reply
= &reply1
;
1427 av_log(s
, AV_LOG_DEBUG
, "hello state=%d\n", rt
->state
);
1429 if (!(rt
->server_type
== RTSP_SERVER_REAL
&& rt
->need_subscription
)) {
1430 if (rt
->state
== RTSP_STATE_PAUSED
) {
1431 snprintf(cmd
, sizeof(cmd
),
1432 "PLAY %s RTSP/1.0\r\n",
1435 snprintf(cmd
, sizeof(cmd
),
1436 "PLAY %s RTSP/1.0\r\n"
1437 "Range: npt=%0.3f-\r\n",
1439 (double)rt
->seek_timestamp
/ AV_TIME_BASE
);
1441 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1442 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1446 rt
->state
= RTSP_STATE_PLAYING
;
1450 /* pause the stream */
1451 static int rtsp_read_pause(AVFormatContext
*s
)
1453 RTSPState
*rt
= s
->priv_data
;
1454 RTSPHeader reply1
, *reply
= &reply1
;
1459 if (rt
->state
!= RTSP_STATE_PLAYING
)
1461 else if (!(rt
->server_type
== RTSP_SERVER_REAL
&& rt
->need_subscription
)) {
1462 snprintf(cmd
, sizeof(cmd
),
1463 "PAUSE %s RTSP/1.0\r\n",
1465 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1466 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1470 rt
->state
= RTSP_STATE_PAUSED
;
1474 static int rtsp_read_seek(AVFormatContext
*s
, int stream_index
,
1475 int64_t timestamp
, int flags
)
1477 RTSPState
*rt
= s
->priv_data
;
1479 rt
->seek_timestamp
= av_rescale_q(timestamp
, s
->streams
[stream_index
]->time_base
, AV_TIME_BASE_Q
);
1482 case RTSP_STATE_IDLE
:
1484 case RTSP_STATE_PLAYING
:
1485 if (rtsp_read_play(s
) != 0)
1488 case RTSP_STATE_PAUSED
:
1489 rt
->state
= RTSP_STATE_IDLE
;
1495 static int rtsp_read_close(AVFormatContext
*s
)
1497 RTSPState
*rt
= s
->priv_data
;
1498 RTSPHeader reply1
, *reply
= &reply1
;
1502 /* NOTE: it is valid to flush the buffer here */
1503 if (rt
->lower_transport
== RTSP_LOWER_TRANSPORT_TCP
) {
1504 url_fclose(&rt
->rtsp_gb
);
1507 snprintf(cmd
, sizeof(cmd
),
1508 "TEARDOWN %s RTSP/1.0\r\n",
1510 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1512 rtsp_close_streams(rt
);
1513 url_close(rt
->rtsp_hd
);
1517 #ifdef CONFIG_RTSP_DEMUXER
1518 AVInputFormat rtsp_demuxer
= {
1520 NULL_IF_CONFIG_SMALL("RTSP input format"),
1527 .flags
= AVFMT_NOFILE
,
1528 .read_play
= rtsp_read_play
,
1529 .read_pause
= rtsp_read_pause
,
1533 static int sdp_probe(AVProbeData
*p1
)
1535 const char *p
= p1
->buf
, *p_end
= p1
->buf
+ p1
->buf_size
;
1537 /* we look for a line beginning "c=IN IP4" */
1538 while (p
< p_end
&& *p
!= '\0') {
1539 if (p
+ sizeof("c=IN IP4") - 1 < p_end
&& av_strstart(p
, "c=IN IP4", NULL
))
1540 return AVPROBE_SCORE_MAX
/ 2;
1542 while(p
< p_end
- 1 && *p
!= '\n') p
++;
1551 #define SDP_MAX_SIZE 8192
1553 static int sdp_read_header(AVFormatContext
*s
,
1554 AVFormatParameters
*ap
)
1556 RTSPState
*rt
= s
->priv_data
;
1557 RTSPStream
*rtsp_st
;
1562 /* read the whole sdp file */
1563 /* XXX: better loading */
1564 content
= av_malloc(SDP_MAX_SIZE
);
1565 size
= get_buffer(s
->pb
, content
, SDP_MAX_SIZE
- 1);
1568 return AVERROR_INVALIDDATA
;
1570 content
[size
] ='\0';
1572 sdp_parse(s
, content
);
1575 /* open each RTP stream */
1576 for(i
=0;i
<rt
->nb_rtsp_streams
;i
++) {
1577 rtsp_st
= rt
->rtsp_streams
[i
];
1579 snprintf(url
, sizeof(url
), "rtp://%s:%d?localport=%d&ttl=%d",
1580 inet_ntoa(rtsp_st
->sdp_ip
),
1584 if (url_open(&rtsp_st
->rtp_handle
, url
, URL_RDWR
) < 0) {
1585 err
= AVERROR_INVALIDDATA
;
1588 if ((err
= rtsp_open_transport_ctx(s
, rtsp_st
)))
1593 rtsp_close_streams(rt
);
1597 static int sdp_read_packet(AVFormatContext
*s
,
1600 return rtsp_read_packet(s
, pkt
);
1603 static int sdp_read_close(AVFormatContext
*s
)
1605 RTSPState
*rt
= s
->priv_data
;
1606 rtsp_close_streams(rt
);
1610 #ifdef CONFIG_SDP_DEMUXER
1611 AVInputFormat sdp_demuxer
= {
1613 NULL_IF_CONFIG_SMALL("SDP"),
1622 #ifdef CONFIG_REDIR_DEMUXER
1623 /* dummy redirector format (used directly in av_open_input_file now) */
1624 static int redir_probe(AVProbeData
*pd
)
1628 while (redir_isspace(*p
))
1630 if (av_strstart(p
, "http://", NULL
) ||
1631 av_strstart(p
, "rtsp://", NULL
))
1632 return AVPROBE_SCORE_MAX
;
1636 static int redir_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
1640 AVFormatContext
*ic
= NULL
;
1641 ByteIOContext
*f
= s
->pb
;
1643 /* parse each URL and try to open it */
1645 while (c
!= URL_EOF
) {
1648 if (!redir_isspace(c
))
1657 if (c
== URL_EOF
|| redir_isspace(c
))
1659 if ((q
- buf
) < sizeof(buf
) - 1)
1664 //printf("URL='%s'\n", buf);
1665 /* try to open the media file */
1666 if (av_open_input_file(&ic
, buf
, NULL
, 0, NULL
) == 0)
1670 return AVERROR(EIO
);
1678 AVInputFormat redir_demuxer
= {
1680 NULL_IF_CONFIG_SMALL("Redirector format"),