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"
26 #include "libavutil/intreadwrite.h"
31 #include <sys/select.h>
41 //#define DEBUG_RTP_TCP
43 static int rtsp_read_play(AVFormatContext
*s
);
45 /* XXX: currently, the only way to change the protocols consists in
46 changing this variable */
48 #if LIBAVFORMAT_VERSION_INT < (53 << 16)
49 int rtsp_default_protocols
= (1 << RTSP_LOWER_TRANSPORT_UDP
);
52 static int rtsp_probe(AVProbeData
*p
)
54 if (av_strstart(p
->filename
, "rtsp:", NULL
))
55 return AVPROBE_SCORE_MAX
;
59 static int redir_isspace(int c
)
61 return c
== ' ' || c
== '\t' || c
== '\n' || c
== '\r';
64 static void skip_spaces(const char **pp
)
68 while (redir_isspace(*p
))
73 static void get_word_sep(char *buf
, int buf_size
, const char *sep
,
84 while (!strchr(sep
, *p
) && *p
!= '\0') {
85 if ((q
- buf
) < buf_size
- 1)
94 static void get_word(char *buf
, int buf_size
, const char **pp
)
102 while (!redir_isspace(*p
) && *p
!= '\0') {
103 if ((q
- buf
) < buf_size
- 1)
112 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other
114 static int sdp_parse_rtpmap(AVCodecContext
*codec
, RTSPStream
*rtsp_st
, int payload_type
, const char *p
)
121 /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and
122 see if we can handle this kind of payload */
123 get_word_sep(buf
, sizeof(buf
), "/", &p
);
124 if (payload_type
>= RTP_PT_PRIVATE
) {
125 RTPDynamicProtocolHandler
*handler
= RTPFirstDynamicPayloadHandler
;
127 if (!strcmp(buf
, handler
->enc_name
) && (codec
->codec_type
== handler
->codec_type
)) {
128 codec
->codec_id
= handler
->codec_id
;
129 rtsp_st
->dynamic_handler
= handler
;
131 rtsp_st
->dynamic_protocol_context
= handler
->open();
135 handler
= handler
->next
;
138 /* We are in a standard case ( from http://www.iana.org/assignments/rtp-parameters) */
139 /* search into AVRtpPayloadTypes[] */
140 codec
->codec_id
= ff_rtp_codec_id(buf
, codec
->codec_type
);
143 c
= avcodec_find_decoder(codec
->codec_id
);
147 c_name
= (char *)NULL
;
150 get_word_sep(buf
, sizeof(buf
), "/", &p
);
152 switch (codec
->codec_type
) {
153 case CODEC_TYPE_AUDIO
:
154 av_log(codec
, AV_LOG_DEBUG
, " audio codec set to : %s\n", c_name
);
155 codec
->sample_rate
= RTSP_DEFAULT_AUDIO_SAMPLERATE
;
156 codec
->channels
= RTSP_DEFAULT_NB_AUDIO_CHANNELS
;
158 codec
->sample_rate
= i
;
159 get_word_sep(buf
, sizeof(buf
), "/", &p
);
163 // TODO: there is a bug here; if it is a mono stream, and less than 22000Hz, faad upconverts to stereo and twice the
164 // frequency. No problem, but the sample rate is being set here by the sdp line. Upcoming patch forthcoming. (rdm)
166 av_log(codec
, AV_LOG_DEBUG
, " audio samplerate set to : %i\n", codec
->sample_rate
);
167 av_log(codec
, AV_LOG_DEBUG
, " audio channels set to : %i\n", codec
->channels
);
169 case CODEC_TYPE_VIDEO
:
170 av_log(codec
, AV_LOG_DEBUG
, " video codec set to : %s\n", c_name
);
181 /* return the length and optionnaly the data */
182 static int hex_to_data(uint8_t *data
, const char *p
)
192 c
= toupper((unsigned char)*p
++);
193 if (c
>= '0' && c
<= '9')
195 else if (c
>= 'A' && c
<= 'F')
210 static void sdp_parse_fmtp_config(AVCodecContext
*codec
, char *attr
, char *value
)
212 switch (codec
->codec_id
) {
215 if (!strcmp(attr
, "config")) {
216 /* decode the hexa encoded parameter */
217 int len
= hex_to_data(NULL
, value
);
218 codec
->extradata
= av_mallocz(len
+ FF_INPUT_BUFFER_PADDING_SIZE
);
219 if (!codec
->extradata
)
221 codec
->extradata_size
= len
;
222 hex_to_data(codec
->extradata
, value
);
237 /* All known fmtp parmeters and the corresping RTPAttrTypeEnum */
238 #define ATTR_NAME_TYPE_INT 0
239 #define ATTR_NAME_TYPE_STR 1
240 static const AttrNameMap attr_names
[]=
242 {"SizeLength", ATTR_NAME_TYPE_INT
, offsetof(RTPPayloadData
, sizelength
)},
243 {"IndexLength", ATTR_NAME_TYPE_INT
, offsetof(RTPPayloadData
, indexlength
)},
244 {"IndexDeltaLength", ATTR_NAME_TYPE_INT
, offsetof(RTPPayloadData
, indexdeltalength
)},
245 {"profile-level-id", ATTR_NAME_TYPE_INT
, offsetof(RTPPayloadData
, profile_level_id
)},
246 {"StreamType", ATTR_NAME_TYPE_INT
, offsetof(RTPPayloadData
, streamtype
)},
247 {"mode", ATTR_NAME_TYPE_STR
, offsetof(RTPPayloadData
, mode
)},
251 /** parse the attribute line from the fmtp a line of an sdp resonse. This is broken out as a function
252 * because it is used in rtp_h264.c, which is forthcoming.
254 int rtsp_next_attr_and_value(const char **p
, char *attr
, int attr_size
, char *value
, int value_size
)
259 get_word_sep(attr
, attr_size
, "=", p
);
262 get_word_sep(value
, value_size
, ";", p
);
270 /* parse a SDP line and save stream attributes */
271 static void sdp_parse_fmtp(AVStream
*st
, const char *p
)
277 RTSPStream
*rtsp_st
= st
->priv_data
;
278 AVCodecContext
*codec
= st
->codec
;
279 RTPPayloadData
*rtp_payload_data
= &rtsp_st
->rtp_payload_data
;
281 /* loop on each attribute */
282 while(rtsp_next_attr_and_value(&p
, attr
, sizeof(attr
), value
, sizeof(value
)))
284 /* grab the codec extra_data from the config parameter of the fmtp line */
285 sdp_parse_fmtp_config(codec
, attr
, value
);
286 /* Looking for a known attribute */
287 for (i
= 0; attr_names
[i
].str
; ++i
) {
288 if (!strcasecmp(attr
, attr_names
[i
].str
)) {
289 if (attr_names
[i
].type
== ATTR_NAME_TYPE_INT
)
290 *(int *)((char *)rtp_payload_data
+ attr_names
[i
].offset
) = atoi(value
);
291 else if (attr_names
[i
].type
== ATTR_NAME_TYPE_STR
)
292 *(char **)((char *)rtp_payload_data
+ attr_names
[i
].offset
) = av_strdup(value
);
298 /** Parse a string \p in the form of Range:npt=xx-xx, and determine the start
300 * Used for seeking in the rtp stream.
302 static void rtsp_parse_range_npt(const char *p
, int64_t *start
, int64_t *end
)
307 if (!av_stristart(p
, "npt=", &p
))
310 *start
= AV_NOPTS_VALUE
;
311 *end
= AV_NOPTS_VALUE
;
313 get_word_sep(buf
, sizeof(buf
), "-", &p
);
314 *start
= parse_date(buf
, 1);
317 get_word_sep(buf
, sizeof(buf
), "-", &p
);
318 *end
= parse_date(buf
, 1);
320 // av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
321 // av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
324 typedef struct SDPParseState
{
326 struct in_addr default_ip
;
328 int skip_media
; ///< set if an unknown m= line occurs
331 static void sdp_parse_line(AVFormatContext
*s
, SDPParseState
*s1
,
332 int letter
, const char *buf
)
334 RTSPState
*rt
= s
->priv_data
;
335 char buf1
[64], st_type
[64];
337 enum CodecType codec_type
;
341 struct in_addr sdp_ip
;
345 printf("sdp: %c='%s'\n", letter
, buf
);
349 if (s1
->skip_media
&& letter
!= 'm')
353 get_word(buf1
, sizeof(buf1
), &p
);
354 if (strcmp(buf1
, "IN") != 0)
356 get_word(buf1
, sizeof(buf1
), &p
);
357 if (strcmp(buf1
, "IP4") != 0)
359 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
360 if (inet_aton(buf1
, &sdp_ip
) == 0)
365 get_word_sep(buf1
, sizeof(buf1
), "/", &p
);
368 if (s
->nb_streams
== 0) {
369 s1
->default_ip
= sdp_ip
;
370 s1
->default_ttl
= ttl
;
372 st
= s
->streams
[s
->nb_streams
- 1];
373 rtsp_st
= st
->priv_data
;
374 rtsp_st
->sdp_ip
= sdp_ip
;
375 rtsp_st
->sdp_ttl
= ttl
;
379 av_metadata_set(&s
->metadata
, "title", p
);
382 if (s
->nb_streams
== 0) {
383 av_metadata_set(&s
->metadata
, "comment", p
);
390 get_word(st_type
, sizeof(st_type
), &p
);
391 if (!strcmp(st_type
, "audio")) {
392 codec_type
= CODEC_TYPE_AUDIO
;
393 } else if (!strcmp(st_type
, "video")) {
394 codec_type
= CODEC_TYPE_VIDEO
;
399 rtsp_st
= av_mallocz(sizeof(RTSPStream
));
402 rtsp_st
->stream_index
= -1;
403 dynarray_add(&rt
->rtsp_streams
, &rt
->nb_rtsp_streams
, rtsp_st
);
405 rtsp_st
->sdp_ip
= s1
->default_ip
;
406 rtsp_st
->sdp_ttl
= s1
->default_ttl
;
408 get_word(buf1
, sizeof(buf1
), &p
); /* port */
409 rtsp_st
->sdp_port
= atoi(buf1
);
411 get_word(buf1
, sizeof(buf1
), &p
); /* protocol (ignored) */
413 /* XXX: handle list of formats */
414 get_word(buf1
, sizeof(buf1
), &p
); /* format list */
415 rtsp_st
->sdp_payload_type
= atoi(buf1
);
417 if (!strcmp(ff_rtp_enc_name(rtsp_st
->sdp_payload_type
), "MP2T")) {
418 /* no corresponding stream */
420 st
= av_new_stream(s
, 0);
423 st
->priv_data
= rtsp_st
;
424 rtsp_st
->stream_index
= st
->index
;
425 st
->codec
->codec_type
= codec_type
;
426 if (rtsp_st
->sdp_payload_type
< RTP_PT_PRIVATE
) {
427 /* if standard payload type, we can find the codec right now */
428 ff_rtp_get_codec_info(st
->codec
, rtsp_st
->sdp_payload_type
);
431 /* put a default control url */
432 av_strlcpy(rtsp_st
->control_url
, s
->filename
, sizeof(rtsp_st
->control_url
));
435 if (av_strstart(p
, "control:", &p
) && s
->nb_streams
> 0) {
437 /* get the control url */
438 st
= s
->streams
[s
->nb_streams
- 1];
439 rtsp_st
= st
->priv_data
;
441 /* XXX: may need to add full url resolution */
442 url_split(proto
, sizeof(proto
), NULL
, 0, NULL
, 0, NULL
, NULL
, 0, p
);
443 if (proto
[0] == '\0') {
444 /* relative control URL */
445 av_strlcat(rtsp_st
->control_url
, "/", sizeof(rtsp_st
->control_url
));
446 av_strlcat(rtsp_st
->control_url
, p
, sizeof(rtsp_st
->control_url
));
448 av_strlcpy(rtsp_st
->control_url
, p
, sizeof(rtsp_st
->control_url
));
450 } else if (av_strstart(p
, "rtpmap:", &p
) && s
->nb_streams
> 0) {
451 /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
452 get_word(buf1
, sizeof(buf1
), &p
);
453 payload_type
= atoi(buf1
);
454 st
= s
->streams
[s
->nb_streams
- 1];
455 rtsp_st
= st
->priv_data
;
456 sdp_parse_rtpmap(st
->codec
, rtsp_st
, payload_type
, p
);
457 } else if (av_strstart(p
, "fmtp:", &p
)) {
458 /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */
459 get_word(buf1
, sizeof(buf1
), &p
);
460 payload_type
= atoi(buf1
);
461 for(i
= 0; i
< s
->nb_streams
;i
++) {
463 rtsp_st
= st
->priv_data
;
464 if (rtsp_st
->sdp_payload_type
== payload_type
) {
465 if(rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_handler
->parse_sdp_a_line
) {
466 if(!rtsp_st
->dynamic_handler
->parse_sdp_a_line(s
, i
, rtsp_st
->dynamic_protocol_context
, buf
)) {
467 sdp_parse_fmtp(st
, p
);
470 sdp_parse_fmtp(st
, p
);
474 } else if(av_strstart(p
, "framesize:", &p
)) {
475 // let dynamic protocol handlers have a stab at the line.
476 get_word(buf1
, sizeof(buf1
), &p
);
477 payload_type
= atoi(buf1
);
478 for(i
= 0; i
< s
->nb_streams
;i
++) {
480 rtsp_st
= st
->priv_data
;
481 if (rtsp_st
->sdp_payload_type
== payload_type
) {
482 if(rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_handler
->parse_sdp_a_line
) {
483 rtsp_st
->dynamic_handler
->parse_sdp_a_line(s
, i
, rtsp_st
->dynamic_protocol_context
, buf
);
487 } else if(av_strstart(p
, "range:", &p
)) {
490 // this is so that seeking on a streamed file can work.
491 rtsp_parse_range_npt(p
, &start
, &end
);
492 s
->start_time
= start
;
493 s
->duration
= (end
==AV_NOPTS_VALUE
)?AV_NOPTS_VALUE
:end
-start
; // AV_NOPTS_VALUE means live broadcast (and can't seek)
494 } else if (av_strstart(p
, "IsRealDataType:integer;",&p
)) {
496 rt
->transport
= RTSP_TRANSPORT_RDT
;
497 } else if (s
->nb_streams
> 0) {
498 if (rt
->server_type
== RTSP_SERVER_REAL
)
499 ff_real_parse_sdp_a_line(s
, s
->nb_streams
- 1, p
);
501 rtsp_st
= s
->streams
[s
->nb_streams
- 1]->priv_data
;
502 if (rtsp_st
->dynamic_handler
&&
503 rtsp_st
->dynamic_handler
->parse_sdp_a_line
)
504 rtsp_st
->dynamic_handler
->parse_sdp_a_line(s
, s
->nb_streams
- 1,
505 rtsp_st
->dynamic_protocol_context
, buf
);
511 static int sdp_parse(AVFormatContext
*s
, const char *content
)
515 /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
516 * contain long SDP lines containing complete ASF Headers (several
517 * kB) or arrays of MDPR (RM stream descriptor) headers plus
518 * "rulebooks" describing their properties. Therefore, the SDP line
519 * buffer is large. */
521 SDPParseState sdp_parse_state
, *s1
= &sdp_parse_state
;
523 memset(s1
, 0, sizeof(SDPParseState
));
534 /* get the content */
536 while (*p
!= '\n' && *p
!= '\r' && *p
!= '\0') {
537 if ((q
- buf
) < sizeof(buf
) - 1)
542 sdp_parse_line(s
, s1
, letter
, buf
);
544 while (*p
!= '\n' && *p
!= '\0')
552 static void rtsp_parse_range(int *min_ptr
, int *max_ptr
, const char **pp
)
559 v
= strtol(p
, (char **)&p
, 10);
563 v
= strtol(p
, (char **)&p
, 10);
572 /* XXX: only one transport specification is parsed */
573 static void rtsp_parse_transport(RTSPHeader
*reply
, const char *p
)
575 char transport_protocol
[16];
577 char lower_transport
[16];
579 RTSPTransportField
*th
;
582 reply
->nb_transports
= 0;
589 th
= &reply
->transports
[reply
->nb_transports
];
591 get_word_sep(transport_protocol
, sizeof(transport_protocol
),
595 if (!strcasecmp (transport_protocol
, "rtp")) {
596 get_word_sep(profile
, sizeof(profile
), "/;,", &p
);
597 lower_transport
[0] = '\0';
598 /* rtp/avp/<protocol> */
601 get_word_sep(lower_transport
, sizeof(lower_transport
),
604 th
->transport
= RTSP_TRANSPORT_RTP
;
605 } else if (!strcasecmp (transport_protocol
, "x-pn-tng") ||
606 !strcasecmp (transport_protocol
, "x-real-rdt")) {
607 /* x-pn-tng/<protocol> */
608 get_word_sep(lower_transport
, sizeof(lower_transport
), "/;,", &p
);
610 th
->transport
= RTSP_TRANSPORT_RDT
;
612 if (!strcasecmp(lower_transport
, "TCP"))
613 th
->lower_transport
= RTSP_LOWER_TRANSPORT_TCP
;
615 th
->lower_transport
= RTSP_LOWER_TRANSPORT_UDP
;
619 /* get each parameter */
620 while (*p
!= '\0' && *p
!= ',') {
621 get_word_sep(parameter
, sizeof(parameter
), "=;,", &p
);
622 if (!strcmp(parameter
, "port")) {
625 rtsp_parse_range(&th
->port_min
, &th
->port_max
, &p
);
627 } else if (!strcmp(parameter
, "client_port")) {
630 rtsp_parse_range(&th
->client_port_min
,
631 &th
->client_port_max
, &p
);
633 } else if (!strcmp(parameter
, "server_port")) {
636 rtsp_parse_range(&th
->server_port_min
,
637 &th
->server_port_max
, &p
);
639 } else if (!strcmp(parameter
, "interleaved")) {
642 rtsp_parse_range(&th
->interleaved_min
,
643 &th
->interleaved_max
, &p
);
645 } else if (!strcmp(parameter
, "multicast")) {
646 if (th
->lower_transport
== RTSP_LOWER_TRANSPORT_UDP
)
647 th
->lower_transport
= RTSP_LOWER_TRANSPORT_UDP_MULTICAST
;
648 } else if (!strcmp(parameter
, "ttl")) {
651 th
->ttl
= strtol(p
, (char **)&p
, 10);
653 } else if (!strcmp(parameter
, "destination")) {
654 struct in_addr ipaddr
;
658 get_word_sep(buf
, sizeof(buf
), ";,", &p
);
659 if (inet_aton(buf
, &ipaddr
))
660 th
->destination
= ntohl(ipaddr
.s_addr
);
663 while (*p
!= ';' && *p
!= '\0' && *p
!= ',')
671 reply
->nb_transports
++;
675 void rtsp_parse_line(RTSPHeader
*reply
, const char *buf
)
679 /* NOTE: we do case independent match for broken servers */
681 if (av_stristart(p
, "Session:", &p
)) {
682 get_word_sep(reply
->session_id
, sizeof(reply
->session_id
), ";", &p
);
683 } else if (av_stristart(p
, "Content-Length:", &p
)) {
684 reply
->content_length
= strtol(p
, NULL
, 10);
685 } else if (av_stristart(p
, "Transport:", &p
)) {
686 rtsp_parse_transport(reply
, p
);
687 } else if (av_stristart(p
, "CSeq:", &p
)) {
688 reply
->seq
= strtol(p
, NULL
, 10);
689 } else if (av_stristart(p
, "Range:", &p
)) {
690 rtsp_parse_range_npt(p
, &reply
->range_start
, &reply
->range_end
);
691 } else if (av_stristart(p
, "RealChallenge1:", &p
)) {
693 av_strlcpy(reply
->real_challenge
, p
, sizeof(reply
->real_challenge
));
694 } else if (av_stristart(p
, "Server:", &p
)) {
696 av_strlcpy(reply
->server
, p
, sizeof(reply
->server
));
700 static int url_readbuf(URLContext
*h
, unsigned char *buf
, int size
)
706 ret
= url_read(h
, buf
+len
, size
-len
);
714 /* skip a RTP/TCP interleaved packet */
715 static void rtsp_skip_packet(AVFormatContext
*s
)
717 RTSPState
*rt
= s
->priv_data
;
721 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 3);
724 len
= AV_RB16(buf
+ 1);
726 printf("skipping RTP packet len=%d\n", len
);
731 if (len1
> sizeof(buf
))
733 ret
= url_readbuf(rt
->rtsp_hd
, buf
, len1
);
740 static void rtsp_send_cmd(AVFormatContext
*s
,
741 const char *cmd
, RTSPHeader
*reply
,
742 unsigned char **content_ptr
)
744 RTSPState
*rt
= s
->priv_data
;
745 char buf
[4096], buf1
[1024], *q
;
748 int content_length
, line_count
;
749 unsigned char *content
= NULL
;
751 memset(reply
, 0, sizeof(*reply
));
754 av_strlcpy(buf
, cmd
, sizeof(buf
));
755 snprintf(buf1
, sizeof(buf1
), "CSeq: %d\r\n", rt
->seq
);
756 av_strlcat(buf
, buf1
, sizeof(buf
));
757 if (rt
->session_id
[0] != '\0' && !strstr(cmd
, "\nIf-Match:")) {
758 snprintf(buf1
, sizeof(buf1
), "Session: %s\r\n", rt
->session_id
);
759 av_strlcat(buf
, buf1
, sizeof(buf
));
761 av_strlcat(buf
, "\r\n", sizeof(buf
));
763 printf("Sending:\n%s--\n", buf
);
765 url_write(rt
->rtsp_hd
, buf
, strlen(buf
));
767 /* parse reply (XXX: use buffers) */
769 rt
->last_reply
[0] = '\0';
773 if (url_readbuf(rt
->rtsp_hd
, &ch
, 1) != 1)
778 /* XXX: only parse it if first char on line ? */
780 } else if (ch
!= '\r') {
781 if ((q
- buf
) < sizeof(buf
) - 1)
787 printf("line='%s'\n", buf
);
789 /* test if last line */
793 if (line_count
== 0) {
795 get_word(buf1
, sizeof(buf1
), &p
);
796 get_word(buf1
, sizeof(buf1
), &p
);
797 reply
->status_code
= atoi(buf1
);
799 rtsp_parse_line(reply
, p
);
800 av_strlcat(rt
->last_reply
, p
, sizeof(rt
->last_reply
));
801 av_strlcat(rt
->last_reply
, "\n", sizeof(rt
->last_reply
));
806 if (rt
->session_id
[0] == '\0' && reply
->session_id
[0] != '\0')
807 av_strlcpy(rt
->session_id
, reply
->session_id
, sizeof(rt
->session_id
));
809 content_length
= reply
->content_length
;
810 if (content_length
> 0) {
811 /* leave some room for a trailing '\0' (useful for simple parsing) */
812 content
= av_malloc(content_length
+ 1);
813 (void)url_readbuf(rt
->rtsp_hd
, content
, content_length
);
814 content
[content_length
] = '\0';
817 *content_ptr
= content
;
823 /* close and free RTSP streams */
824 static void rtsp_close_streams(RTSPState
*rt
)
829 for(i
=0;i
<rt
->nb_rtsp_streams
;i
++) {
830 rtsp_st
= rt
->rtsp_streams
[i
];
832 if (rtsp_st
->transport_priv
) {
833 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
834 ff_rdt_parse_close(rtsp_st
->transport_priv
);
836 rtp_parse_close(rtsp_st
->transport_priv
);
838 if (rtsp_st
->rtp_handle
)
839 url_close(rtsp_st
->rtp_handle
);
840 if (rtsp_st
->dynamic_handler
&& rtsp_st
->dynamic_protocol_context
)
841 rtsp_st
->dynamic_handler
->close(rtsp_st
->dynamic_protocol_context
);
844 av_free(rt
->rtsp_streams
);
848 rtsp_open_transport_ctx(AVFormatContext
*s
, RTSPStream
*rtsp_st
)
850 RTSPState
*rt
= s
->priv_data
;
853 /* open the RTP context */
854 if (rtsp_st
->stream_index
>= 0)
855 st
= s
->streams
[rtsp_st
->stream_index
];
857 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
859 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
860 rtsp_st
->transport_priv
= ff_rdt_parse_open(s
, st
->index
,
861 rtsp_st
->dynamic_protocol_context
,
862 rtsp_st
->dynamic_handler
);
864 rtsp_st
->transport_priv
= rtp_parse_open(s
, st
, rtsp_st
->rtp_handle
,
865 rtsp_st
->sdp_payload_type
,
866 &rtsp_st
->rtp_payload_data
);
868 if (!rtsp_st
->transport_priv
) {
869 return AVERROR(ENOMEM
);
870 } else if (rt
->transport
!= RTSP_TRANSPORT_RDT
) {
871 if(rtsp_st
->dynamic_handler
) {
872 rtp_parse_set_dynamic_protocol(rtsp_st
->transport_priv
,
873 rtsp_st
->dynamic_protocol_context
,
874 rtsp_st
->dynamic_handler
);
882 * @returns 0 on success, <0 on error, 1 if protocol is unavailable.
885 make_setup_request (AVFormatContext
*s
, const char *host
, int port
,
886 int lower_transport
, const char *real_challenge
)
888 RTSPState
*rt
= s
->priv_data
;
889 int j
, i
, err
, interleave
= 0;
891 RTSPHeader reply1
, *reply
= &reply1
;
893 const char *trans_pref
;
895 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
896 trans_pref
= "x-pn-tng";
898 trans_pref
= "RTP/AVP";
900 /* for each stream, make the setup request */
901 /* XXX: we assume the same server is used for the control of each
904 for(j
= RTSP_RTP_PORT_MIN
, i
= 0; i
< rt
->nb_rtsp_streams
; ++i
) {
905 char transport
[2048];
907 rtsp_st
= rt
->rtsp_streams
[i
];
910 if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
) {
913 /* first try in specified port range */
914 if (RTSP_RTP_PORT_MIN
!= 0) {
915 while(j
<= RTSP_RTP_PORT_MAX
) {
916 snprintf(buf
, sizeof(buf
), "rtp://%s?localport=%d", host
, j
);
917 j
+= 2; /* we will use two port by rtp stream (rtp and rtcp) */
918 if (url_open(&rtsp_st
->rtp_handle
, buf
, URL_RDWR
) == 0) {
924 /* then try on any port
925 ** if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) {
926 ** err = AVERROR_INVALIDDATA;
932 port
= rtp_get_local_port(rtsp_st
->rtp_handle
);
933 snprintf(transport
, sizeof(transport
) - 1,
934 "%s/UDP;", trans_pref
);
935 if (rt
->server_type
!= RTSP_SERVER_REAL
)
936 av_strlcat(transport
, "unicast;", sizeof(transport
));
937 av_strlcatf(transport
, sizeof(transport
),
938 "client_port=%d", port
);
939 if (rt
->transport
== RTSP_TRANSPORT_RTP
)
940 av_strlcatf(transport
, sizeof(transport
), "-%d", port
+ 1);
944 else if (lower_transport
== RTSP_LOWER_TRANSPORT_TCP
) {
945 snprintf(transport
, sizeof(transport
) - 1,
946 "%s/TCP;", trans_pref
);
947 if (rt
->server_type
== RTSP_SERVER_WMS
)
948 av_strlcat(transport
, "unicast;", sizeof(transport
));
949 av_strlcatf(transport
, sizeof(transport
),
951 interleave
, interleave
+ 1);
955 else if (lower_transport
== RTSP_LOWER_TRANSPORT_UDP_MULTICAST
) {
956 snprintf(transport
, sizeof(transport
) - 1,
957 "%s/UDP;multicast", trans_pref
);
959 if (rt
->server_type
== RTSP_SERVER_REAL
||
960 rt
->server_type
== RTSP_SERVER_WMS
)
961 av_strlcat(transport
, ";mode=play", sizeof(transport
));
962 snprintf(cmd
, sizeof(cmd
),
963 "SETUP %s RTSP/1.0\r\n"
965 rtsp_st
->control_url
, transport
);
966 if (i
== 0 && rt
->server_type
== RTSP_SERVER_REAL
) {
967 char real_res
[41], real_csum
[9];
968 ff_rdt_calc_response_and_checksum(real_res
, real_csum
,
970 av_strlcatf(cmd
, sizeof(cmd
),
972 "RealChallenge2: %s, sd=%s\r\n",
973 rt
->session_id
, real_res
, real_csum
);
975 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
976 if (reply
->status_code
== 461 /* Unsupported protocol */ && i
== 0) {
979 } else if (reply
->status_code
!= RTSP_STATUS_OK
||
980 reply
->nb_transports
!= 1) {
981 err
= AVERROR_INVALIDDATA
;
985 /* XXX: same protocol for all streams is required */
987 if (reply
->transports
[0].lower_transport
!= rt
->lower_transport
||
988 reply
->transports
[0].transport
!= rt
->transport
) {
989 err
= AVERROR_INVALIDDATA
;
993 rt
->lower_transport
= reply
->transports
[0].lower_transport
;
994 rt
->transport
= reply
->transports
[0].transport
;
997 /* close RTP connection if not choosen */
998 if (reply
->transports
[0].lower_transport
!= RTSP_LOWER_TRANSPORT_UDP
&&
999 (lower_transport
== RTSP_LOWER_TRANSPORT_UDP
)) {
1000 url_close(rtsp_st
->rtp_handle
);
1001 rtsp_st
->rtp_handle
= NULL
;
1004 switch(reply
->transports
[0].lower_transport
) {
1005 case RTSP_LOWER_TRANSPORT_TCP
:
1006 rtsp_st
->interleaved_min
= reply
->transports
[0].interleaved_min
;
1007 rtsp_st
->interleaved_max
= reply
->transports
[0].interleaved_max
;
1010 case RTSP_LOWER_TRANSPORT_UDP
:
1014 /* XXX: also use address if specified */
1015 snprintf(url
, sizeof(url
), "rtp://%s:%d",
1016 host
, reply
->transports
[0].server_port_min
);
1017 if (rtp_set_remote_url(rtsp_st
->rtp_handle
, url
) < 0) {
1018 err
= AVERROR_INVALIDDATA
;
1023 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
:
1028 in
.s_addr
= htonl(reply
->transports
[0].destination
);
1029 snprintf(url
, sizeof(url
), "rtp://%s:%d?ttl=%d",
1031 reply
->transports
[0].port_min
,
1032 reply
->transports
[0].ttl
);
1033 if (url_open(&rtsp_st
->rtp_handle
, url
, URL_RDWR
) < 0) {
1034 err
= AVERROR_INVALIDDATA
;
1041 if ((err
= rtsp_open_transport_ctx(s
, rtsp_st
)))
1045 if (rt
->server_type
== RTSP_SERVER_REAL
)
1046 rt
->need_subscription
= 1;
1051 for (i
=0; i
<rt
->nb_rtsp_streams
; i
++) {
1052 if (rt
->rtsp_streams
[i
]->rtp_handle
) {
1053 url_close(rt
->rtsp_streams
[i
]->rtp_handle
);
1054 rt
->rtsp_streams
[i
]->rtp_handle
= NULL
;
1060 static int rtsp_read_header(AVFormatContext
*s
,
1061 AVFormatParameters
*ap
)
1063 RTSPState
*rt
= s
->priv_data
;
1064 char host
[1024], path
[1024], tcpname
[1024], cmd
[2048], *option_list
, *option
;
1065 URLContext
*rtsp_hd
;
1067 RTSPHeader reply1
, *reply
= &reply1
;
1068 unsigned char *content
= NULL
;
1069 int lower_transport_mask
= 0;
1070 char real_challenge
[64];
1072 /* extract hostname and port */
1073 url_split(NULL
, 0, NULL
, 0,
1074 host
, sizeof(host
), &port
, path
, sizeof(path
), s
->filename
);
1076 port
= RTSP_DEFAULT_PORT
;
1078 /* search for options */
1079 option_list
= strchr(path
, '?');
1081 /* remove the options from the path */
1083 while(option_list
) {
1084 /* move the option pointer */
1085 option
= option_list
;
1086 option_list
= strchr(option_list
, '&');
1088 *(option_list
++) = 0;
1089 /* handle the options */
1090 if (strcmp(option
, "udp") == 0)
1091 lower_transport_mask
= (1<< RTSP_LOWER_TRANSPORT_UDP
);
1092 else if (strcmp(option
, "multicast") == 0)
1093 lower_transport_mask
= (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST
);
1094 else if (strcmp(option
, "tcp") == 0)
1095 lower_transport_mask
= (1<< RTSP_LOWER_TRANSPORT_TCP
);
1099 if (!lower_transport_mask
)
1100 lower_transport_mask
= (1 << RTSP_LOWER_TRANSPORT_NB
) - 1;
1102 /* open the tcp connexion */
1103 snprintf(tcpname
, sizeof(tcpname
), "tcp://%s:%d", host
, port
);
1104 if (url_open(&rtsp_hd
, tcpname
, URL_RDWR
) < 0)
1105 return AVERROR(EIO
);
1106 rt
->rtsp_hd
= rtsp_hd
;
1109 /* request options supported by the server; this also detects server type */
1110 for (rt
->server_type
= RTSP_SERVER_RTP
;;) {
1111 snprintf(cmd
, sizeof(cmd
),
1112 "OPTIONS %s RTSP/1.0\r\n", s
->filename
);
1113 if (rt
->server_type
== RTSP_SERVER_REAL
)
1116 * The following entries are required for proper
1117 * streaming from a Realmedia server. They are
1118 * interdependent in some way although we currently
1119 * don't quite understand how. Values were copied
1120 * from mplayer SVN r23589.
1121 * @param CompanyID is a 16-byte ID in base64
1122 * @param ClientChallenge is a 16-byte ID in hex
1124 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1125 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1126 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1127 "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1129 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1130 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1131 err
= AVERROR_INVALIDDATA
;
1135 /* detect server type if not standard-compliant RTP */
1136 if (rt
->server_type
!= RTSP_SERVER_REAL
&& reply
->real_challenge
[0]) {
1137 rt
->server_type
= RTSP_SERVER_REAL
;
1139 } else if (!strncasecmp(reply
->server
, "WMServer/", 9)) {
1140 rt
->server_type
= RTSP_SERVER_WMS
;
1141 } else if (rt
->server_type
== RTSP_SERVER_REAL
) {
1142 strcpy(real_challenge
, reply
->real_challenge
);
1147 /* describe the stream */
1148 snprintf(cmd
, sizeof(cmd
),
1149 "DESCRIBE %s RTSP/1.0\r\n"
1150 "Accept: application/sdp\r\n",
1152 if (rt
->server_type
== RTSP_SERVER_REAL
) {
1154 * The Require: attribute is needed for proper streaming from
1155 * Realmedia servers.
1158 "Require: com.real.retain-entity-for-setup\r\n",
1161 rtsp_send_cmd(s
, cmd
, reply
, &content
);
1163 err
= AVERROR_INVALIDDATA
;
1166 if (reply
->status_code
!= RTSP_STATUS_OK
) {
1167 err
= AVERROR_INVALIDDATA
;
1171 /* now we got the SDP description, we parse it */
1172 ret
= sdp_parse(s
, (const char *)content
);
1175 err
= AVERROR_INVALIDDATA
;
1180 int lower_transport
= ff_log2_tab
[lower_transport_mask
& ~(lower_transport_mask
- 1)];
1182 err
= make_setup_request(s
, host
, port
, lower_transport
,
1183 rt
->server_type
== RTSP_SERVER_REAL
?
1184 real_challenge
: NULL
);
1187 lower_transport_mask
&= ~(1 << lower_transport
);
1188 if (lower_transport_mask
== 0 && err
== 1) {
1189 err
= AVERROR(FF_NETERROR(EPROTONOSUPPORT
));
1194 rt
->state
= RTSP_STATE_IDLE
;
1195 rt
->seek_timestamp
= 0; /* default is to start stream at position
1197 if (ap
->initial_pause
) {
1198 /* do not start immediately */
1200 if (rtsp_read_play(s
) < 0) {
1201 err
= AVERROR_INVALIDDATA
;
1207 rtsp_close_streams(rt
);
1209 url_close(rt
->rtsp_hd
);
1213 static int tcp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1214 uint8_t *buf
, int buf_size
)
1216 RTSPState
*rt
= s
->priv_data
;
1217 int id
, len
, i
, ret
;
1218 RTSPStream
*rtsp_st
;
1220 #ifdef DEBUG_RTP_TCP
1221 printf("tcp_read_packet:\n");
1225 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 1);
1226 #ifdef DEBUG_RTP_TCP
1227 printf("ret=%d c=%02x [%c]\n", ret
, buf
[0], buf
[0]);
1234 ret
= url_readbuf(rt
->rtsp_hd
, buf
, 3);
1238 len
= AV_RB16(buf
+ 1);
1239 #ifdef DEBUG_RTP_TCP
1240 printf("id=%d len=%d\n", id
, len
);
1242 if (len
> buf_size
|| len
< 12)
1245 ret
= url_readbuf(rt
->rtsp_hd
, buf
, len
);
1248 if (rt
->transport
== RTSP_TRANSPORT_RDT
&&
1249 ff_rdt_parse_header(buf
, len
, &id
, NULL
, NULL
, NULL
, NULL
) < 0)
1252 /* find the matching stream */
1253 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1254 rtsp_st
= rt
->rtsp_streams
[i
];
1255 if (id
>= rtsp_st
->interleaved_min
&&
1256 id
<= rtsp_st
->interleaved_max
)
1261 *prtsp_st
= rtsp_st
;
1265 static int udp_read_packet(AVFormatContext
*s
, RTSPStream
**prtsp_st
,
1266 uint8_t *buf
, int buf_size
)
1268 RTSPState
*rt
= s
->priv_data
;
1269 RTSPStream
*rtsp_st
;
1271 int fd1
, fd2
, fd_max
, n
, i
, ret
;
1275 if (url_interrupt_cb())
1276 return AVERROR(EINTR
);
1279 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1280 rtsp_st
= rt
->rtsp_streams
[i
];
1281 /* currently, we cannot probe RTCP handle because of blocking restrictions */
1282 rtp_get_file_handles(rtsp_st
->rtp_handle
, &fd1
, &fd2
);
1288 tv
.tv_usec
= 100 * 1000;
1289 n
= select(fd_max
+ 1, &rfds
, NULL
, NULL
, &tv
);
1291 for(i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1292 rtsp_st
= rt
->rtsp_streams
[i
];
1293 rtp_get_file_handles(rtsp_st
->rtp_handle
, &fd1
, &fd2
);
1294 if (FD_ISSET(fd1
, &rfds
)) {
1295 ret
= url_read(rtsp_st
->rtp_handle
, buf
, buf_size
);
1297 *prtsp_st
= rtsp_st
;
1306 static int rtsp_read_packet(AVFormatContext
*s
,
1309 RTSPState
*rt
= s
->priv_data
;
1310 RTSPStream
*rtsp_st
;
1312 uint8_t buf
[10 * RTP_MAX_PACKET_LENGTH
];
1314 if (rt
->server_type
== RTSP_SERVER_REAL
) {
1316 RTSPHeader reply1
, *reply
= &reply1
;
1317 enum AVDiscard cache
[MAX_STREAMS
];
1320 for (i
= 0; i
< s
->nb_streams
; i
++)
1321 cache
[i
] = s
->streams
[i
]->discard
;
1323 if (!rt
->need_subscription
) {
1324 if (memcmp (cache
, rt
->real_setup_cache
,
1325 sizeof(enum AVDiscard
) * s
->nb_streams
)) {
1326 av_strlcatf(cmd
, sizeof(cmd
),
1327 "SET_PARAMETER %s RTSP/1.0\r\n"
1328 "Unsubscribe: %s\r\n",
1329 s
->filename
, rt
->last_subscription
);
1330 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1331 if (reply
->status_code
!= RTSP_STATUS_OK
)
1332 return AVERROR_INVALIDDATA
;
1333 rt
->need_subscription
= 1;
1337 if (rt
->need_subscription
) {
1338 int r
, rule_nr
, first
= 1;
1340 memcpy(rt
->real_setup_cache
, cache
,
1341 sizeof(enum AVDiscard
) * s
->nb_streams
);
1342 rt
->last_subscription
[0] = 0;
1344 snprintf(cmd
, sizeof(cmd
),
1345 "SET_PARAMETER %s RTSP/1.0\r\n"
1348 for (i
= 0; i
< rt
->nb_rtsp_streams
; i
++) {
1350 for (r
= 0; r
< s
->nb_streams
; r
++) {
1351 if (s
->streams
[r
]->priv_data
== rt
->rtsp_streams
[i
]) {
1352 if (s
->streams
[r
]->discard
!= AVDISCARD_ALL
) {
1354 av_strlcat(rt
->last_subscription
, ",",
1355 sizeof(rt
->last_subscription
));
1356 ff_rdt_subscribe_rule(
1357 rt
->last_subscription
,
1358 sizeof(rt
->last_subscription
), i
, rule_nr
);
1365 av_strlcatf(cmd
, sizeof(cmd
), "%s\r\n", rt
->last_subscription
);
1366 rtsp_send_cmd(s
, cmd
, reply
, NULL
);
1367 if (reply
->status_code
!= RTSP_STATUS_OK
)
1368 return AVERROR_INVALIDDATA
;
1369 rt
->need_subscription
= 0;
1371 if (rt
->state
== RTSP_STATE_PLAYING
)
1376 /* get next frames from the same RTP packet */
1377 if (rt
->cur_transport_priv
) {
1378 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
1379 ret
= ff_rdt_parse_packet(rt
->cur_transport_priv
, pkt
, NULL
, 0);
1381 ret
= rtp_parse_packet(rt
->cur_transport_priv
, pkt
, NULL
, 0);
1383 rt
->cur_transport_priv
= NULL
;
1385 } else if (ret
== 1) {
1388 rt
->cur_transport_priv
= NULL
;
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
->transport_priv
&& rt
->transport
== RTSP_TRANSPORT_RTP
)
1403 rtp_check_and_send_back_rr(rtsp_st
->transport_priv
, len
);
1408 if (rt
->transport
== RTSP_TRANSPORT_RDT
)
1409 ret
= ff_rdt_parse_packet(rtsp_st
->transport_priv
, pkt
, buf
, len
);
1411 ret
= rtp_parse_packet(rtsp_st
->transport_priv
, pkt
, buf
, len
);
1415 /* more packets may follow, so we save the RTP context */
1416 rt
->cur_transport_priv
= rtsp_st
->transport_priv
;
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 #if 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 #if CONFIG_SDP_DEMUXER
1611 AVInputFormat sdp_demuxer
= {
1613 NULL_IF_CONFIG_SMALL("SDP"),
1622 #if 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"),