Mercurial > libavformat.hg
annotate rtsp.c @ 5565:befe2f0f9a00 libavformat
Use the configure check from r21351 and use it to properly define struct
sockaddr (in case it's not missing) so it always works on the system that
we are defining it for, in a RFC-2553/3493-compliant way (i.e. containing
a ss_family field). which is used in udp.c. Patch by Martin Storsj
<$firstname $firstname st>.
author | rbultje |
---|---|
date | Wed, 20 Jan 2010 17:26:14 +0000 |
parents | 0a67dbb939a0 |
children | 346dce85a801 |
rev | line source |
---|---|
0 | 1 /* |
2 * RTSP/SDP client | |
4251
77e0c7511d41
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
4206
diff
changeset
|
3 * Copyright (c) 2002 Fabrice Bellard |
0 | 4 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
0 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
887
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
3286 | 21 |
3722
68749aaea50f
ensure we get explicit definition of various _XOPEN_SOURCE functions we use
aurel
parents:
3714
diff
changeset
|
22 /* needed by inet_aton() */ |
68749aaea50f
ensure we get explicit definition of various _XOPEN_SOURCE functions we use
aurel
parents:
3714
diff
changeset
|
23 #define _SVID_SOURCE |
68749aaea50f
ensure we get explicit definition of various _XOPEN_SOURCE functions we use
aurel
parents:
3714
diff
changeset
|
24 |
5220
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
25 #include "libavutil/base64.h" |
3286 | 26 #include "libavutil/avstring.h" |
4201
7d2f3f1b68d8
Fix build: Add intreadwrite.h and bswap.h #includes where necessary.
diego
parents:
4187
diff
changeset
|
27 #include "libavutil/intreadwrite.h" |
0 | 28 #include "avformat.h" |
29 | |
1808
572ce77d7333
Fix compilation on Mac OS X, patch by Marc Hoffman, mmh pleasantst com.
diego
parents:
1754
diff
changeset
|
30 #include <sys/time.h> |
4206 | 31 #if HAVE_SYS_SELECT_H |
3936
6154f62ef652
include sys/select.h instead of unistd.h to get select,
bcoudurier
parents:
3924
diff
changeset
|
32 #include <sys/select.h> |
3941
53c5b89b8dff
only include sys/select.h if present, fix mingw compilation
bcoudurier
parents:
3936
diff
changeset
|
33 #endif |
3714 | 34 #include <strings.h> |
1754 | 35 #include "network.h" |
2681
6037eb4919fb
Remove the inclusion of rtsp.h and rtp.h from avformat.h, and
lucabe
parents:
2408
diff
changeset
|
36 #include "rtsp.h" |
0 | 37 |
4388 | 38 #include "rtpdec.h" |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
39 #include "rdt.h" |
4744
51899c07a4f1
Add RTP/ASF header parsing, which is part of the SDP of these streams. See
rbultje
parents:
4667
diff
changeset
|
40 #include "rtp_asf.h" |
4875
13a2a1a475d5
Add a Vorbis payload parser. Implemented by Colin McQuillan as a GSoC
rbultje
parents:
4874
diff
changeset
|
41 #include "rtp_vorbis.h" |
1419 | 42 |
0 | 43 //#define DEBUG |
172 | 44 //#define DEBUG_RTP_TCP |
0 | 45 |
2884 | 46 #if LIBAVFORMAT_VERSION_INT < (53 << 16) |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
47 int rtsp_default_protocols = (1 << RTSP_LOWER_TRANSPORT_UDP); |
2884 | 48 #endif |
0 | 49 |
4773
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
50 #define SPACE_CHARS " \t\r\n" |
4789
c18ea19a9771
strchr(string, '\0') returns non-NULL, and is thus not suited for use in
rbultje
parents:
4779
diff
changeset
|
51 /* we use memchr() instead of strchr() here because strchr() will return |
c18ea19a9771
strchr(string, '\0') returns non-NULL, and is thus not suited for use in
rbultje
parents:
4779
diff
changeset
|
52 * the terminating '\0' of SPACE_CHARS instead of NULL if c is '\0'. */ |
c18ea19a9771
strchr(string, '\0') returns non-NULL, and is thus not suited for use in
rbultje
parents:
4779
diff
changeset
|
53 #define redir_isspace(c) memchr(SPACE_CHARS, c, 4) |
0 | 54 static void skip_spaces(const char **pp) |
55 { | |
56 const char *p; | |
57 p = *pp; | |
58 while (redir_isspace(*p)) | |
59 p++; | |
60 *pp = p; | |
61 } | |
62 | |
4773
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
63 static void get_word_until_chars(char *buf, int buf_size, |
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
64 const char *sep, const char **pp) |
0 | 65 { |
66 const char *p; | |
67 char *q; | |
68 | |
69 p = *pp; | |
70 skip_spaces(&p); | |
71 q = buf; | |
72 while (!strchr(sep, *p) && *p != '\0') { | |
73 if ((q - buf) < buf_size - 1) | |
74 *q++ = *p; | |
75 p++; | |
76 } | |
77 if (buf_size > 0) | |
78 *q = '\0'; | |
79 *pp = p; | |
80 } | |
81 | |
4773
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
82 static void get_word_sep(char *buf, int buf_size, const char *sep, |
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
83 const char **pp) |
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
84 { |
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
85 if (**pp == '/') (*pp)++; |
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
86 get_word_until_chars(buf, buf_size, sep, pp); |
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
87 } |
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
88 |
0 | 89 static void get_word(char *buf, int buf_size, const char **pp) |
90 { | |
4773
1c9751d3065c
Merge functional code from get_word() and get_word_sep() into a single
rbultje
parents:
4772
diff
changeset
|
91 get_word_until_chars(buf, buf_size, SPACE_CHARS, pp); |
0 | 92 } |
93 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
94 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */ |
5503
4ec7bcff8719
Add correct log context to av_log() calls in parse_rtpmap().
rbultje
parents:
5502
diff
changeset
|
95 static int sdp_parse_rtpmap(AVFormatContext *s, |
4ec7bcff8719
Add correct log context to av_log() calls in parse_rtpmap().
rbultje
parents:
5502
diff
changeset
|
96 AVCodecContext *codec, RTSPStream *rtsp_st, |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
97 int payload_type, const char *p) |
0 | 98 { |
99 char buf[256]; | |
774 | 100 int i; |
101 AVCodec *c; | |
1124
d3aff2c607f9
Add const to (mostly) char* and make some functions static, which aren't used
diego
parents:
1003
diff
changeset
|
102 const char *c_name; |
0 | 103 |
774 | 104 /* Loop into AVRtpDynamicPayloadTypes[] and AVRtpPayloadTypes[] and |
5529
0a67dbb939a0
Fix issue1658 (trailing space in rtpmap descriptor).
rbultje
parents:
5503
diff
changeset
|
105 * see if we can handle this kind of payload. |
0a67dbb939a0
Fix issue1658 (trailing space in rtpmap descriptor).
rbultje
parents:
5503
diff
changeset
|
106 * The space should normally not be there but some Real streams or |
0a67dbb939a0
Fix issue1658 (trailing space in rtpmap descriptor).
rbultje
parents:
5503
diff
changeset
|
107 * particular servers ("RealServer Version 6.1.3.970", see issue 1658) |
0a67dbb939a0
Fix issue1658 (trailing space in rtpmap descriptor).
rbultje
parents:
5503
diff
changeset
|
108 * have a trailing space. */ |
0a67dbb939a0
Fix issue1658 (trailing space in rtpmap descriptor).
rbultje
parents:
5503
diff
changeset
|
109 get_word_sep(buf, sizeof(buf), "/ ", &p); |
774 | 110 if (payload_type >= RTP_PT_PRIVATE) { |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
111 RTPDynamicProtocolHandler *handler; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
112 for (handler = RTPFirstDynamicPayloadHandler; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
113 handler; handler = handler->next) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
114 if (!strcasecmp(buf, handler->enc_name) && |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
115 codec->codec_type == handler->codec_type) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
116 codec->codec_id = handler->codec_id; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
117 rtsp_st->dynamic_handler = handler; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
118 if (handler->open) |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
119 rtsp_st->dynamic_protocol_context = handler->open(); |
774 | 120 break; |
121 } | |
1419 | 122 } |
774 | 123 } else { |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
124 /* We are in a standard case |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
125 * (from http://www.iana.org/assignments/rtp-parameters). */ |
774 | 126 /* search into AVRtpPayloadTypes[] */ |
2759
b252e318023a
Remove the "AVRtpPayloadTypes[i].pt == i" assumption from RTP and RTSP
lucabe
parents:
2711
diff
changeset
|
127 codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type); |
774 | 128 } |
129 | |
130 c = avcodec_find_decoder(codec->codec_id); | |
131 if (c && c->name) | |
1124
d3aff2c607f9
Add const to (mostly) char* and make some functions static, which aren't used
diego
parents:
1003
diff
changeset
|
132 c_name = c->name; |
774 | 133 else |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
134 c_name = (char *) NULL; |
774 | 135 |
136 if (c_name) { | |
137 get_word_sep(buf, sizeof(buf), "/", &p); | |
138 i = atoi(buf); | |
139 switch (codec->codec_type) { | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
140 case CODEC_TYPE_AUDIO: |
5503
4ec7bcff8719
Add correct log context to av_log() calls in parse_rtpmap().
rbultje
parents:
5502
diff
changeset
|
141 av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
142 codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
143 codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
144 if (i > 0) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
145 codec->sample_rate = i; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
146 get_word_sep(buf, sizeof(buf), "/", &p); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
147 i = atoi(buf); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
148 if (i > 0) |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
149 codec->channels = i; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
150 // TODO: there is a bug here; if it is a mono stream, and |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
151 // less than 22000Hz, faad upconverts to stereo and twice |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
152 // the frequency. No problem, but the sample rate is being |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
153 // set here by the sdp line. Patch on its way. (rdm) |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
154 } |
5503
4ec7bcff8719
Add correct log context to av_log() calls in parse_rtpmap().
rbultje
parents:
5502
diff
changeset
|
155 av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n", |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
156 codec->sample_rate); |
5503
4ec7bcff8719
Add correct log context to av_log() calls in parse_rtpmap().
rbultje
parents:
5502
diff
changeset
|
157 av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n", |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
158 codec->channels); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
159 break; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
160 case CODEC_TYPE_VIDEO: |
5503
4ec7bcff8719
Add correct log context to av_log() calls in parse_rtpmap().
rbultje
parents:
5502
diff
changeset
|
161 av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
162 break; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
163 default: |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
164 break; |
774 | 165 } |
0 | 166 return 0; |
167 } | |
774 | 168 |
169 return -1; | |
0 | 170 } |
171 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
172 /* return the length and optionally the data */ |
0 | 173 static int hex_to_data(uint8_t *data, const char *p) |
174 { | |
175 int c, len, v; | |
176 | |
177 len = 0; | |
178 v = 1; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
179 for (;;) { |
0 | 180 skip_spaces(&p); |
4776
894e353aaeca
Fix silly bug in hex_to_data() where it compares a string pointer for whether
rbultje
parents:
4775
diff
changeset
|
181 if (*p == '\0') |
0 | 182 break; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
183 c = toupper((unsigned char) *p++); |
0 | 184 if (c >= '0' && c <= '9') |
185 c = c - '0'; | |
186 else if (c >= 'A' && c <= 'F') | |
187 c = c - 'A' + 10; | |
188 else | |
189 break; | |
190 v = (v << 4) | c; | |
191 if (v & 0x100) { | |
192 if (data) | |
193 data[len] = v; | |
194 len++; | |
195 v = 1; | |
196 } | |
197 } | |
198 return len; | |
199 } | |
200 | |
4875
13a2a1a475d5
Add a Vorbis payload parser. Implemented by Colin McQuillan as a GSoC
rbultje
parents:
4874
diff
changeset
|
201 static void sdp_parse_fmtp_config(AVCodecContext * codec, void *ctx, |
13a2a1a475d5
Add a Vorbis payload parser. Implemented by Colin McQuillan as a GSoC
rbultje
parents:
4874
diff
changeset
|
202 char *attr, char *value) |
774 | 203 { |
204 switch (codec->codec_id) { | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
205 case CODEC_ID_MPEG4: |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
206 case CODEC_ID_AAC: |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
207 if (!strcmp(attr, "config")) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
208 /* decode the hexa encoded parameter */ |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
209 int len = hex_to_data(NULL, value); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
210 if (codec->extradata) |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
211 av_free(codec->extradata); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
212 codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
213 if (!codec->extradata) |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
214 return; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
215 codec->extradata_size = len; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
216 hex_to_data(codec->extradata, value); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
217 } |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
218 break; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
219 case CODEC_ID_VORBIS: |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
220 ff_vorbis_parse_fmtp_config(codec, ctx, attr, value); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
221 break; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
222 default: |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
223 break; |
774 | 224 } |
225 return; | |
226 } | |
227 | |
4088 | 228 typedef struct { |
1124
d3aff2c607f9
Add const to (mostly) char* and make some functions static, which aren't used
diego
parents:
1003
diff
changeset
|
229 const char *str; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
230 uint16_t type; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
231 uint32_t offset; |
4088 | 232 } AttrNameMap; |
774 | 233 |
234 /* All known fmtp parmeters and the corresping RTPAttrTypeEnum */ | |
235 #define ATTR_NAME_TYPE_INT 0 | |
236 #define ATTR_NAME_TYPE_STR 1 | |
4088 | 237 static const AttrNameMap attr_names[]= |
774 | 238 { |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
239 { "SizeLength", ATTR_NAME_TYPE_INT, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
240 offsetof(RTPPayloadData, sizelength) }, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
241 { "IndexLength", ATTR_NAME_TYPE_INT, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
242 offsetof(RTPPayloadData, indexlength) }, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
243 { "IndexDeltaLength", ATTR_NAME_TYPE_INT, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
244 offsetof(RTPPayloadData, indexdeltalength) }, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
245 { "profile-level-id", ATTR_NAME_TYPE_INT, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
246 offsetof(RTPPayloadData, profile_level_id) }, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
247 { "StreamType", ATTR_NAME_TYPE_INT, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
248 offsetof(RTPPayloadData, streamtype) }, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
249 { "mode", ATTR_NAME_TYPE_STR, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
250 offsetof(RTPPayloadData, mode) }, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
251 { NULL, -1, -1 }, |
774 | 252 }; |
253 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
254 /* parse the attribute line from the fmtp a line of an sdp resonse. This |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
255 * is broken out as a function because it is used in rtp_h264.c, which is |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
256 * forthcoming. */ |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
257 int rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
258 char *value, int value_size) |
1431
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
259 { |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
260 skip_spaces(p); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
261 if (**p) { |
1431
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
262 get_word_sep(attr, attr_size, "=", p); |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
263 if (**p == '=') |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
264 (*p)++; |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
265 get_word_sep(value, value_size, ";", p); |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
266 if (**p == ';') |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
267 (*p)++; |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
268 return 1; |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
269 } |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
270 return 0; |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
271 } |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
272 |
774 | 273 /* parse a SDP line and save stream attributes */ |
274 static void sdp_parse_fmtp(AVStream *st, const char *p) | |
0 | 275 { |
276 char attr[256]; | |
4874
5370b0c1653c
Increase the SDP buffer size (again!) and also increase the temporary
rbultje
parents:
4789
diff
changeset
|
277 /* Vorbis setup headers can be up to 12KB and are sent base64 |
5370b0c1653c
Increase the SDP buffer size (again!) and also increase the temporary
rbultje
parents:
4789
diff
changeset
|
278 * encoded, giving a 12KB * (4/3) = 16KB FMTP line. */ |
5370b0c1653c
Increase the SDP buffer size (again!) and also increase the temporary
rbultje
parents:
4789
diff
changeset
|
279 char value[16384]; |
774 | 280 int i; |
281 RTSPStream *rtsp_st = st->priv_data; | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
774
diff
changeset
|
282 AVCodecContext *codec = st->codec; |
4101
af2c0aef892b
Rename rtp_payload_data_t to avoid clashes with the POSIX namespace
lucabe
parents:
4088
diff
changeset
|
283 RTPPayloadData *rtp_payload_data = &rtsp_st->rtp_payload_data; |
0 | 284 |
285 /* loop on each attribute */ | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
286 while (rtsp_next_attr_and_value(&p, attr, sizeof(attr), |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
287 value, sizeof(value))) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
288 /* grab the codec extra_data from the config parameter of the fmtp |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
289 * line */ |
4875
13a2a1a475d5
Add a Vorbis payload parser. Implemented by Colin McQuillan as a GSoC
rbultje
parents:
4874
diff
changeset
|
290 sdp_parse_fmtp_config(codec, rtsp_st->dynamic_protocol_context, |
13a2a1a475d5
Add a Vorbis payload parser. Implemented by Colin McQuillan as a GSoC
rbultje
parents:
4874
diff
changeset
|
291 attr, value); |
774 | 292 /* Looking for a known attribute */ |
293 for (i = 0; attr_names[i].str; ++i) { | |
294 if (!strcasecmp(attr, attr_names[i].str)) { | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
295 if (attr_names[i].type == ATTR_NAME_TYPE_INT) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
296 *(int *)((char *)rtp_payload_data + |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
297 attr_names[i].offset) = atoi(value); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
298 } else if (attr_names[i].type == ATTR_NAME_TYPE_STR) |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
299 *(char **)((char *)rtp_payload_data + |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
300 attr_names[i].offset) = av_strdup(value); |
887 | 301 } |
0 | 302 } |
303 } | |
304 } | |
305 | |
5485 | 306 /** Parse a string p in the form of Range:npt=xx-xx, and determine the start |
1453
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
307 * and end time. |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
308 * Used for seeking in the rtp stream. |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
309 */ |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
310 static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end) |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
311 { |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
312 char buf[256]; |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
313 |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
314 skip_spaces(&p); |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
315 if (!av_stristart(p, "npt=", &p)) |
1453
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
316 return; |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
317 |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
318 *start = AV_NOPTS_VALUE; |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
319 *end = AV_NOPTS_VALUE; |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
320 |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
321 get_word_sep(buf, sizeof(buf), "-", &p); |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
322 *start = parse_date(buf, 1); |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
323 if (*p == '-') { |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
324 p++; |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
325 get_word_sep(buf, sizeof(buf), "-", &p); |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
326 *end = parse_date(buf, 1); |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
327 } |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
328 // av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start); |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
329 // av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end); |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
330 } |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
331 |
0 | 332 typedef struct SDPParseState { |
333 /* SDP only */ | |
334 struct in_addr default_ip; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
335 int default_ttl; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
336 int skip_media; ///< set if an unknown m= line occurs |
0 | 337 } SDPParseState; |
338 | |
339 static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1, | |
340 int letter, const char *buf) | |
341 { | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
342 RTSPState *rt = s->priv_data; |
0 | 343 char buf1[64], st_type[64]; |
344 const char *p; | |
3967 | 345 enum CodecType codec_type; |
346 int payload_type, i; | |
0 | 347 AVStream *st; |
348 RTSPStream *rtsp_st; | |
349 struct in_addr sdp_ip; | |
350 int ttl; | |
351 | |
4990 | 352 dprintf(s, "sdp: %c='%s'\n", letter, buf); |
0 | 353 |
354 p = buf; | |
4281
f1d8951d6813
Skip m= blocks in the SDP if the media type is unknown. This prevents
rbultje
parents:
4251
diff
changeset
|
355 if (s1->skip_media && letter != 'm') |
f1d8951d6813
Skip m= blocks in the SDP if the media type is unknown. This prevents
rbultje
parents:
4251
diff
changeset
|
356 return; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
357 switch (letter) { |
0 | 358 case 'c': |
359 get_word(buf1, sizeof(buf1), &p); | |
360 if (strcmp(buf1, "IN") != 0) | |
361 return; | |
362 get_word(buf1, sizeof(buf1), &p); | |
363 if (strcmp(buf1, "IP4") != 0) | |
364 return; | |
365 get_word_sep(buf1, sizeof(buf1), "/", &p); | |
366 if (inet_aton(buf1, &sdp_ip) == 0) | |
367 return; | |
368 ttl = 16; | |
369 if (*p == '/') { | |
370 p++; | |
371 get_word_sep(buf1, sizeof(buf1), "/", &p); | |
372 ttl = atoi(buf1); | |
373 } | |
374 if (s->nb_streams == 0) { | |
375 s1->default_ip = sdp_ip; | |
376 s1->default_ttl = ttl; | |
377 } else { | |
378 st = s->streams[s->nb_streams - 1]; | |
379 rtsp_st = st->priv_data; | |
380 rtsp_st->sdp_ip = sdp_ip; | |
381 rtsp_st->sdp_ttl = ttl; | |
382 } | |
383 break; | |
384 case 's': | |
4361 | 385 av_metadata_set(&s->metadata, "title", p); |
0 | 386 break; |
387 case 'i': | |
388 if (s->nb_streams == 0) { | |
4361 | 389 av_metadata_set(&s->metadata, "comment", p); |
0 | 390 break; |
391 } | |
392 break; | |
393 case 'm': | |
394 /* new stream */ | |
4281
f1d8951d6813
Skip m= blocks in the SDP if the media type is unknown. This prevents
rbultje
parents:
4251
diff
changeset
|
395 s1->skip_media = 0; |
0 | 396 get_word(st_type, sizeof(st_type), &p); |
397 if (!strcmp(st_type, "audio")) { | |
398 codec_type = CODEC_TYPE_AUDIO; | |
399 } else if (!strcmp(st_type, "video")) { | |
400 codec_type = CODEC_TYPE_VIDEO; | |
4637
eaf90db8cc42
Recognize the "application" data type, which is required for WMS/UDP
rbultje
parents:
4557
diff
changeset
|
401 } else if (!strcmp(st_type, "application")) { |
eaf90db8cc42
Recognize the "application" data type, which is required for WMS/UDP
rbultje
parents:
4557
diff
changeset
|
402 codec_type = CODEC_TYPE_DATA; |
0 | 403 } else { |
4281
f1d8951d6813
Skip m= blocks in the SDP if the media type is unknown. This prevents
rbultje
parents:
4251
diff
changeset
|
404 s1->skip_media = 1; |
0 | 405 return; |
406 } | |
407 rtsp_st = av_mallocz(sizeof(RTSPStream)); | |
408 if (!rtsp_st) | |
409 return; | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
410 rtsp_st->stream_index = -1; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
411 dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st); |
0 | 412 |
413 rtsp_st->sdp_ip = s1->default_ip; | |
414 rtsp_st->sdp_ttl = s1->default_ttl; | |
415 | |
416 get_word(buf1, sizeof(buf1), &p); /* port */ | |
417 rtsp_st->sdp_port = atoi(buf1); | |
418 | |
419 get_word(buf1, sizeof(buf1), &p); /* protocol (ignored) */ | |
885 | 420 |
0 | 421 /* XXX: handle list of formats */ |
422 get_word(buf1, sizeof(buf1), &p); /* format list */ | |
423 rtsp_st->sdp_payload_type = atoi(buf1); | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
424 |
2759
b252e318023a
Remove the "AVRtpPayloadTypes[i].pt == i" assumption from RTP and RTSP
lucabe
parents:
2711
diff
changeset
|
425 if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) { |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
426 /* no corresponding stream */ |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
427 } else { |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
428 st = av_new_stream(s, 0); |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
429 if (!st) |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
430 return; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
431 st->priv_data = rtsp_st; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
432 rtsp_st->stream_index = st->index; |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
774
diff
changeset
|
433 st->codec->codec_type = codec_type; |
774 | 434 if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) { |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
435 /* if standard payload type, we can find the codec right now */ |
4519
f4b9967e0131
Remame rtp_get_codec_info() to ff_rtp_get_codec_info(), as it is not
lucabe
parents:
4514
diff
changeset
|
436 ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type); |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
437 } |
0 | 438 } |
439 /* put a default control url */ | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
440 av_strlcpy(rtsp_st->control_url, s->filename, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
441 sizeof(rtsp_st->control_url)); |
0 | 442 break; |
443 case 'a': | |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
444 if (av_strstart(p, "control:", &p) && s->nb_streams > 0) { |
0 | 445 char proto[32]; |
446 /* get the control url */ | |
447 st = s->streams[s->nb_streams - 1]; | |
448 rtsp_st = st->priv_data; | |
885 | 449 |
0 | 450 /* XXX: may need to add full url resolution */ |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
451 url_split(proto, sizeof(proto), NULL, 0, NULL, 0, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
452 NULL, NULL, 0, p); |
0 | 453 if (proto[0] == '\0') { |
454 /* relative control URL */ | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
455 av_strlcat(rtsp_st->control_url, "/", |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
456 sizeof(rtsp_st->control_url)); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
457 av_strlcat(rtsp_st->control_url, p, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
458 sizeof(rtsp_st->control_url)); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
459 } else |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
460 av_strlcpy(rtsp_st->control_url, p, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
461 sizeof(rtsp_st->control_url)); |
4185
023976c45ae1
Apply rtpmap: SDP lines to the last m= line only, since they generally just
rbultje
parents:
4182
diff
changeset
|
462 } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) { |
0 | 463 /* NOTE: rtpmap is only supported AFTER the 'm=' tag */ |
885 | 464 get_word(buf1, sizeof(buf1), &p); |
0 | 465 payload_type = atoi(buf1); |
4185
023976c45ae1
Apply rtpmap: SDP lines to the last m= line only, since they generally just
rbultje
parents:
4182
diff
changeset
|
466 st = s->streams[s->nb_streams - 1]; |
4186 | 467 rtsp_st = st->priv_data; |
5503
4ec7bcff8719
Add correct log context to av_log() calls in parse_rtpmap().
rbultje
parents:
5502
diff
changeset
|
468 sdp_parse_rtpmap(s, st->codec, rtsp_st, payload_type, p); |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
469 } else if (av_strstart(p, "fmtp:", &p)) { |
0 | 470 /* NOTE: fmtp is only supported AFTER the 'a=rtpmap:xxx' tag */ |
885 | 471 get_word(buf1, sizeof(buf1), &p); |
0 | 472 payload_type = atoi(buf1); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
473 for (i = 0; i < s->nb_streams; i++) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
474 st = s->streams[i]; |
0 | 475 rtsp_st = st->priv_data; |
476 if (rtsp_st->sdp_payload_type == payload_type) { | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
477 if (!(rtsp_st->dynamic_handler && |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
478 rtsp_st->dynamic_handler->parse_sdp_a_line && |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
479 rtsp_st->dynamic_handler->parse_sdp_a_line(s, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
480 i, rtsp_st->dynamic_protocol_context, buf))) |
1424
1c39ce5c6a5d
indentation fix, patch by Ryan Martell % rdm4 A martellventures P com %
gpoirier
parents:
1419
diff
changeset
|
481 sdp_parse_fmtp(st, p); |
0 | 482 } |
483 } | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
484 } else if (av_strstart(p, "framesize:", &p)) { |
1431
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
485 // let dynamic protocol handlers have a stab at the line. |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
486 get_word(buf1, sizeof(buf1), &p); |
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
487 payload_type = atoi(buf1); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
488 for (i = 0; i < s->nb_streams; i++) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
489 st = s->streams[i]; |
1431
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
490 rtsp_st = st->priv_data; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
491 if (rtsp_st->sdp_payload_type == payload_type && |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
492 rtsp_st->dynamic_handler && |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
493 rtsp_st->dynamic_handler->parse_sdp_a_line) |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
494 rtsp_st->dynamic_handler->parse_sdp_a_line(s, i, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
495 rtsp_st->dynamic_protocol_context, buf); |
1431
2d8a17631520
fix more dynamic protocol stuff, needed by the forthcoming h264
gpoirier
parents:
1425
diff
changeset
|
496 } |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
497 } else if (av_strstart(p, "range:", &p)) { |
1453
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
498 int64_t start, end; |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
499 |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
500 // this is so that seeking on a streamed file can work. |
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
501 rtsp_parse_range_npt(p, &start, &end); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
502 s->start_time = start; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
503 /* AV_NOPTS_VALUE means live broadcast (and can't seek) */ |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
504 s->duration = (end == AV_NOPTS_VALUE) ? |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
505 AV_NOPTS_VALUE : end - start; |
3960
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
506 } else if (av_strstart(p, "IsRealDataType:integer;",&p)) { |
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
507 if (atoi(p) == 1) |
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
508 rt->transport = RTSP_TRANSPORT_RDT; |
4744
51899c07a4f1
Add RTP/ASF header parsing, which is part of the SDP of these streams. See
rbultje
parents:
4667
diff
changeset
|
509 } else { |
51899c07a4f1
Add RTP/ASF header parsing, which is part of the SDP of these streams. See
rbultje
parents:
4667
diff
changeset
|
510 if (rt->server_type == RTSP_SERVER_WMS) |
51899c07a4f1
Add RTP/ASF header parsing, which is part of the SDP of these streams. See
rbultje
parents:
4667
diff
changeset
|
511 ff_wms_parse_sdp_a_line(s, p); |
51899c07a4f1
Add RTP/ASF header parsing, which is part of the SDP of these streams. See
rbultje
parents:
4667
diff
changeset
|
512 if (s->nb_streams > 0) { |
4745 | 513 if (rt->server_type == RTSP_SERVER_REAL) |
514 ff_real_parse_sdp_a_line(s, s->nb_streams - 1, p); | |
4163
8d6512cbd657
Parse the ASMRuleBook SDP line to dynamically create one new AVStream for
rbultje
parents:
4109
diff
changeset
|
515 |
4745 | 516 rtsp_st = s->streams[s->nb_streams - 1]->priv_data; |
517 if (rtsp_st->dynamic_handler && | |
518 rtsp_st->dynamic_handler->parse_sdp_a_line) | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
519 rtsp_st->dynamic_handler->parse_sdp_a_line(s, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
520 s->nb_streams - 1, |
4745 | 521 rtsp_st->dynamic_protocol_context, buf); |
4744
51899c07a4f1
Add RTP/ASF header parsing, which is part of the SDP of these streams. See
rbultje
parents:
4667
diff
changeset
|
522 } |
0 | 523 } |
524 break; | |
525 } | |
526 } | |
527 | |
64 | 528 static int sdp_parse(AVFormatContext *s, const char *content) |
0 | 529 { |
530 const char *p; | |
531 int letter; | |
4187 | 532 /* Some SDP lines, particularly for Realmedia or ASF RTSP streams, |
533 * contain long SDP lines containing complete ASF Headers (several | |
534 * kB) or arrays of MDPR (RM stream descriptor) headers plus | |
535 * "rulebooks" describing their properties. Therefore, the SDP line | |
4874
5370b0c1653c
Increase the SDP buffer size (again!) and also increase the temporary
rbultje
parents:
4789
diff
changeset
|
536 * buffer is large. |
5370b0c1653c
Increase the SDP buffer size (again!) and also increase the temporary
rbultje
parents:
4789
diff
changeset
|
537 * |
5370b0c1653c
Increase the SDP buffer size (again!) and also increase the temporary
rbultje
parents:
4789
diff
changeset
|
538 * The Vorbis FMTP line can be up to 16KB - see sdp_parse_fmtp. */ |
5370b0c1653c
Increase the SDP buffer size (again!) and also increase the temporary
rbultje
parents:
4789
diff
changeset
|
539 char buf[16384], *q; |
0 | 540 SDPParseState sdp_parse_state, *s1 = &sdp_parse_state; |
885 | 541 |
0 | 542 memset(s1, 0, sizeof(SDPParseState)); |
543 p = content; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
544 for (;;) { |
0 | 545 skip_spaces(&p); |
546 letter = *p; | |
547 if (letter == '\0') | |
548 break; | |
549 p++; | |
550 if (*p != '=') | |
551 goto next_line; | |
552 p++; | |
553 /* get the content */ | |
554 q = buf; | |
172 | 555 while (*p != '\n' && *p != '\r' && *p != '\0') { |
0 | 556 if ((q - buf) < sizeof(buf) - 1) |
557 *q++ = *p; | |
558 p++; | |
559 } | |
560 *q = '\0'; | |
561 sdp_parse_line(s, s1, letter, buf); | |
562 next_line: | |
563 while (*p != '\n' && *p != '\0') | |
564 p++; | |
565 if (*p == '\n') | |
566 p++; | |
567 } | |
568 return 0; | |
569 } | |
570 | |
5365
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
571 /* close and free RTSP streams */ |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
572 static void rtsp_close_streams(RTSPState *rt) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
573 { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
574 int i; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
575 RTSPStream *rtsp_st; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
576 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
577 for (i = 0; i < rt->nb_rtsp_streams; i++) { |
5365
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
578 rtsp_st = rt->rtsp_streams[i]; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
579 if (rtsp_st) { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
580 if (rtsp_st->transport_priv) { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
581 if (rt->transport == RTSP_TRANSPORT_RDT) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
582 ff_rdt_parse_close(rtsp_st->transport_priv); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
583 else |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
584 rtp_parse_close(rtsp_st->transport_priv); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
585 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
586 if (rtsp_st->rtp_handle) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
587 url_close(rtsp_st->rtp_handle); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
588 if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
589 rtsp_st->dynamic_handler->close( |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
590 rtsp_st->dynamic_protocol_context); |
5365
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
591 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
592 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
593 av_free(rt->rtsp_streams); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
594 if (rt->asf_ctx) { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
595 av_close_input_stream (rt->asf_ctx); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
596 rt->asf_ctx = NULL; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
597 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
598 av_freep(&rt->auth_b64); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
599 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
600 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
601 static int rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st) |
5365
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
602 { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
603 RTSPState *rt = s->priv_data; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
604 AVStream *st = NULL; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
605 |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
606 /* open the RTP context */ |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
607 if (rtsp_st->stream_index >= 0) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
608 st = s->streams[rtsp_st->stream_index]; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
609 if (!st) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
610 s->ctx_flags |= AVFMTCTX_NOHEADER; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
611 |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
612 if (rt->transport == RTSP_TRANSPORT_RDT) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
613 rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index, |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
614 rtsp_st->dynamic_protocol_context, |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
615 rtsp_st->dynamic_handler); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
616 else |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
617 rtsp_st->transport_priv = rtp_parse_open(s, st, rtsp_st->rtp_handle, |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
618 rtsp_st->sdp_payload_type, |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
619 &rtsp_st->rtp_payload_data); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
620 |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
621 if (!rtsp_st->transport_priv) { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
622 return AVERROR(ENOMEM); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
623 } else if (rt->transport != RTSP_TRANSPORT_RDT) { |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
624 if (rtsp_st->dynamic_handler) { |
5365
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
625 rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv, |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
626 rtsp_st->dynamic_protocol_context, |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
627 rtsp_st->dynamic_handler); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
628 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
629 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
630 |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
631 return 0; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
632 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
633 |
5368
d93af9bfc0b8
Add some "#if"s to avoid compiling the RTSP code when the RTSP demuxer
lucabe
parents:
5366
diff
changeset
|
634 #if CONFIG_RTSP_DEMUXER |
5365
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
635 static int rtsp_probe(AVProbeData *p) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
636 { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
637 if (av_strstart(p->filename, "rtsp:", NULL)) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
638 return AVPROBE_SCORE_MAX; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
639 return 0; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
640 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
641 |
0 | 642 static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp) |
643 { | |
644 const char *p; | |
645 int v; | |
646 | |
647 p = *pp; | |
648 skip_spaces(&p); | |
649 v = strtol(p, (char **)&p, 10); | |
650 if (*p == '-') { | |
651 p++; | |
652 *min_ptr = v; | |
653 v = strtol(p, (char **)&p, 10); | |
654 *max_ptr = v; | |
655 } else { | |
656 *min_ptr = v; | |
657 *max_ptr = v; | |
658 } | |
659 *pp = p; | |
660 } | |
661 | |
662 /* XXX: only one transport specification is parsed */ | |
4557
bfe6fb676d46
Rename RTSPHeader to RTSPMessageHeader to reflect more clearly what the
rbultje
parents:
4549
diff
changeset
|
663 static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p) |
0 | 664 { |
665 char transport_protocol[16]; | |
666 char profile[16]; | |
667 char lower_transport[16]; | |
668 char parameter[16]; | |
669 RTSPTransportField *th; | |
670 char buf[256]; | |
885 | 671 |
0 | 672 reply->nb_transports = 0; |
885 | 673 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
674 for (;;) { |
0 | 675 skip_spaces(&p); |
676 if (*p == '\0') | |
677 break; | |
678 | |
679 th = &reply->transports[reply->nb_transports]; | |
680 | |
885 | 681 get_word_sep(transport_protocol, sizeof(transport_protocol), |
0 | 682 "/", &p); |
2865
51aa1054528c
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 2 x-pn-tng support
lu_zero
parents:
2864
diff
changeset
|
683 if (!strcasecmp (transport_protocol, "rtp")) { |
2866
ccbca87ccd5e
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 3 Reindent
lu_zero
parents:
2865
diff
changeset
|
684 get_word_sep(profile, sizeof(profile), "/;,", &p); |
ccbca87ccd5e
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 3 Reindent
lu_zero
parents:
2865
diff
changeset
|
685 lower_transport[0] = '\0'; |
ccbca87ccd5e
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 3 Reindent
lu_zero
parents:
2865
diff
changeset
|
686 /* rtp/avp/<protocol> */ |
ccbca87ccd5e
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 3 Reindent
lu_zero
parents:
2865
diff
changeset
|
687 if (*p == '/') { |
ccbca87ccd5e
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 3 Reindent
lu_zero
parents:
2865
diff
changeset
|
688 get_word_sep(lower_transport, sizeof(lower_transport), |
ccbca87ccd5e
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 3 Reindent
lu_zero
parents:
2865
diff
changeset
|
689 ";,", &p); |
3960
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
690 } |
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
691 th->transport = RTSP_TRANSPORT_RTP; |
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
692 } else if (!strcasecmp (transport_protocol, "x-pn-tng") || |
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
693 !strcasecmp (transport_protocol, "x-real-rdt")) { |
2866
ccbca87ccd5e
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 3 Reindent
lu_zero
parents:
2865
diff
changeset
|
694 /* x-pn-tng/<protocol> */ |
2865
51aa1054528c
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 2 x-pn-tng support
lu_zero
parents:
2864
diff
changeset
|
695 get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p); |
51aa1054528c
Real RTSP support, from Ronald S. Bultje rsbultje gmail - part 2 x-pn-tng support
lu_zero
parents:
2864
diff
changeset
|
696 profile[0] = '\0'; |
3960
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
697 th->transport = RTSP_TRANSPORT_RDT; |
0 | 698 } |
172 | 699 if (!strcasecmp(lower_transport, "TCP")) |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
700 th->lower_transport = RTSP_LOWER_TRANSPORT_TCP; |
0 | 701 else |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
702 th->lower_transport = RTSP_LOWER_TRANSPORT_UDP; |
885 | 703 |
0 | 704 if (*p == ';') |
705 p++; | |
706 /* get each parameter */ | |
707 while (*p != '\0' && *p != ',') { | |
708 get_word_sep(parameter, sizeof(parameter), "=;,", &p); | |
709 if (!strcmp(parameter, "port")) { | |
710 if (*p == '=') { | |
711 p++; | |
712 rtsp_parse_range(&th->port_min, &th->port_max, &p); | |
713 } | |
714 } else if (!strcmp(parameter, "client_port")) { | |
715 if (*p == '=') { | |
716 p++; | |
885 | 717 rtsp_parse_range(&th->client_port_min, |
0 | 718 &th->client_port_max, &p); |
719 } | |
720 } else if (!strcmp(parameter, "server_port")) { | |
721 if (*p == '=') { | |
722 p++; | |
885 | 723 rtsp_parse_range(&th->server_port_min, |
0 | 724 &th->server_port_max, &p); |
725 } | |
726 } else if (!strcmp(parameter, "interleaved")) { | |
727 if (*p == '=') { | |
728 p++; | |
885 | 729 rtsp_parse_range(&th->interleaved_min, |
0 | 730 &th->interleaved_max, &p); |
731 } | |
732 } else if (!strcmp(parameter, "multicast")) { | |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
733 if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP) |
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
734 th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST; |
0 | 735 } else if (!strcmp(parameter, "ttl")) { |
736 if (*p == '=') { | |
737 p++; | |
738 th->ttl = strtol(p, (char **)&p, 10); | |
739 } | |
740 } else if (!strcmp(parameter, "destination")) { | |
741 struct in_addr ipaddr; | |
742 | |
743 if (*p == '=') { | |
744 p++; | |
745 get_word_sep(buf, sizeof(buf), ";,", &p); | |
885 | 746 if (inet_aton(buf, &ipaddr)) |
0 | 747 th->destination = ntohl(ipaddr.s_addr); |
748 } | |
749 } | |
750 while (*p != ';' && *p != '\0' && *p != ',') | |
751 p++; | |
752 if (*p == ';') | |
753 p++; | |
754 } | |
755 if (*p == ',') | |
756 p++; | |
757 | |
758 reply->nb_transports++; | |
759 } | |
760 } | |
761 | |
4557
bfe6fb676d46
Rename RTSPHeader to RTSPMessageHeader to reflect more clearly what the
rbultje
parents:
4549
diff
changeset
|
762 void rtsp_parse_line(RTSPMessageHeader *reply, const char *buf) |
0 | 763 { |
764 const char *p; | |
765 | |
766 /* NOTE: we do case independent match for broken servers */ | |
767 p = buf; | |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
768 if (av_stristart(p, "Session:", &p)) { |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
769 int t; |
0 | 770 get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p); |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
771 if (av_stristart(p, ";timeout=", &p) && |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
772 (t = strtol(p, NULL, 10)) > 0) { |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
773 reply->timeout = t; |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
774 } |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
775 } else if (av_stristart(p, "Content-Length:", &p)) { |
0 | 776 reply->content_length = strtol(p, NULL, 10); |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
777 } else if (av_stristart(p, "Transport:", &p)) { |
0 | 778 rtsp_parse_transport(reply, p); |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
779 } else if (av_stristart(p, "CSeq:", &p)) { |
0 | 780 reply->seq = strtol(p, NULL, 10); |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2189
diff
changeset
|
781 } else if (av_stristart(p, "Range:", &p)) { |
1453
c0235bab9e92
Add support for getting duration of a RTP stream (for seeking in stream)
gpoirier
parents:
1431
diff
changeset
|
782 rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end); |
3855 | 783 } else if (av_stristart(p, "RealChallenge1:", &p)) { |
784 skip_spaces(&p); | |
785 av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge)); | |
4169
619845a9bab3
Use the "server" RTSP field to detect whether the server that we're talking
rbultje
parents:
4168
diff
changeset
|
786 } else if (av_stristart(p, "Server:", &p)) { |
619845a9bab3
Use the "server" RTSP field to detect whether the server that we're talking
rbultje
parents:
4168
diff
changeset
|
787 skip_spaces(&p); |
619845a9bab3
Use the "server" RTSP field to detect whether the server that we're talking
rbultje
parents:
4168
diff
changeset
|
788 av_strlcpy(reply->server, p, sizeof(reply->server)); |
5112
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
789 } else if (av_stristart(p, "Notice:", &p) || |
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
790 av_stristart(p, "X-Notice:", &p)) { |
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
791 reply->notice = strtol(p, NULL, 10); |
5333 | 792 } else if (av_stristart(p, "Location:", &p)) { |
793 skip_spaces(&p); | |
794 av_strlcpy(reply->location, p , sizeof(reply->location)); | |
0 | 795 } |
796 } | |
797 | |
179 | 798 /* skip a RTP/TCP interleaved packet */ |
799 static void rtsp_skip_packet(AVFormatContext *s) | |
800 { | |
801 RTSPState *rt = s->priv_data; | |
802 int ret, len, len1; | |
803 uint8_t buf[1024]; | |
804 | |
5004
84a7b7a2f252
Move function for reading whole specified amount of data from RTSP
kostya
parents:
4990
diff
changeset
|
805 ret = url_read_complete(rt->rtsp_hd, buf, 3); |
179 | 806 if (ret != 3) |
807 return; | |
2222 | 808 len = AV_RB16(buf + 1); |
4990 | 809 |
810 dprintf(s, "skipping RTP packet len=%d\n", len); | |
811 | |
179 | 812 /* skip payload */ |
813 while (len > 0) { | |
814 len1 = len; | |
815 if (len1 > sizeof(buf)) | |
816 len1 = sizeof(buf); | |
5004
84a7b7a2f252
Move function for reading whole specified amount of data from RTSP
kostya
parents:
4990
diff
changeset
|
817 ret = url_read_complete(rt->rtsp_hd, buf, len1); |
179 | 818 if (ret != len1) |
819 return; | |
820 len -= len1; | |
821 } | |
822 } | |
0 | 823 |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
824 /** |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
825 * Read a RTSP message from the server, or prepare to read data |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
826 * packets if we're reading data interleaved over the TCP/RTSP |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
827 * connection as well. |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
828 * |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
829 * @param s RTSP demuxer context |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
830 * @param reply pointer where the RTSP message header will be stored |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
831 * @param content_ptr pointer where the RTSP message body, if any, will |
5484
ee963dbe6ced
Remove residual use of the doxygen markup which is deprecated,
stefano
parents:
5480
diff
changeset
|
832 * be stored (length is in reply) |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
833 * @param return_on_interleaved_data whether the function may return if we |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
834 * encounter a data marker ('$'), which precedes data |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
835 * packets over interleaved TCP/RTSP connections. If this |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
836 * is set, this function will return 1 after encountering |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
837 * a '$'. If it is not set, the function will skip any |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
838 * data packets (if they are encountered), until a reply |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
839 * has been fully parsed. If no more data is available |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
840 * without parsing a reply, it will return an error. |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
841 * |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
842 * @returns 1 if a data packets is ready to be received, -1 on error, |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
843 * and 0 on success. |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
844 */ |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
845 static int rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
846 unsigned char **content_ptr, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
847 int return_on_interleaved_data) |
0 | 848 { |
849 RTSPState *rt = s->priv_data; | |
850 char buf[4096], buf1[1024], *q; | |
851 unsigned char ch; | |
852 const char *p; | |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
853 int ret, content_length, line_count = 0; |
0 | 854 unsigned char *content = NULL; |
855 | |
4549 | 856 memset(reply, 0, sizeof(*reply)); |
0 | 857 |
858 /* parse reply (XXX: use buffers) */ | |
859 rt->last_reply[0] = '\0'; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
860 for (;;) { |
0 | 861 q = buf; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
862 for (;;) { |
5004
84a7b7a2f252
Move function for reading whole specified amount of data from RTSP
kostya
parents:
4990
diff
changeset
|
863 ret = url_read_complete(rt->rtsp_hd, &ch, 1); |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
864 #ifdef DEBUG_RTP_TCP |
4990 | 865 dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch); |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
866 #endif |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
867 if (ret != 1) |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
868 return -1; |
0 | 869 if (ch == '\n') |
870 break; | |
179 | 871 if (ch == '$') { |
872 /* XXX: only parse it if first char on line ? */ | |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
873 if (return_on_interleaved_data) { |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
874 return 1; |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
875 } else |
179 | 876 rtsp_skip_packet(s); |
877 } else if (ch != '\r') { | |
0 | 878 if ((q - buf) < sizeof(buf) - 1) |
879 *q++ = ch; | |
880 } | |
881 } | |
882 *q = '\0'; | |
4990 | 883 |
884 dprintf(s, "line='%s'\n", buf); | |
885 | |
0 | 886 /* test if last line */ |
887 if (buf[0] == '\0') | |
888 break; | |
889 p = buf; | |
890 if (line_count == 0) { | |
891 /* get reply code */ | |
892 get_word(buf1, sizeof(buf1), &p); | |
893 get_word(buf1, sizeof(buf1), &p); | |
894 reply->status_code = atoi(buf1); | |
895 } else { | |
896 rtsp_parse_line(reply, p); | |
2189 | 897 av_strlcat(rt->last_reply, p, sizeof(rt->last_reply)); |
898 av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply)); | |
0 | 899 } |
900 line_count++; | |
901 } | |
885 | 902 |
0 | 903 if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0') |
2189 | 904 av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id)); |
885 | 905 |
0 | 906 content_length = reply->content_length; |
907 if (content_length > 0) { | |
908 /* leave some room for a trailing '\0' (useful for simple parsing) */ | |
909 content = av_malloc(content_length + 1); | |
5004
84a7b7a2f252
Move function for reading whole specified amount of data from RTSP
kostya
parents:
4990
diff
changeset
|
910 (void)url_read_complete(rt->rtsp_hd, content, content_length); |
0 | 911 content[content_length] = '\0'; |
912 } | |
913 if (content_ptr) | |
914 *content_ptr = content; | |
2263 | 915 else |
916 av_free(content); | |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
917 |
5112
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
918 /* EOS */ |
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
919 if (reply->notice == 2101 /* End-of-Stream Reached */ || |
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
920 reply->notice == 2104 /* Start-of-Stream Reached */ || |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
921 reply->notice == 2306 /* Continuous Feed Terminated */) { |
5112
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
922 rt->state = RTSP_STATE_IDLE; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
923 } else if (reply->notice >= 4400 && reply->notice < 5500) { |
5112
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
924 return AVERROR(EIO); /* data or server error */ |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
925 } else if (reply->notice == 2401 /* Ticket Expired */ || |
5112
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
926 (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ ) |
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
927 return AVERROR(EPERM); |
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
928 |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
929 return 0; |
0 | 930 } |
931 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
932 static void rtsp_send_cmd_async(AVFormatContext *s, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
933 const char *cmd, RTSPMessageHeader *reply, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
934 unsigned char **content_ptr) |
4644
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
935 { |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
936 RTSPState *rt = s->priv_data; |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
937 char buf[4096], buf1[1024]; |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
938 |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
939 rt->seq++; |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
940 av_strlcpy(buf, cmd, sizeof(buf)); |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
941 snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq); |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
942 av_strlcat(buf, buf1, sizeof(buf)); |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
943 if (rt->session_id[0] != '\0' && !strstr(cmd, "\nIf-Match:")) { |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
944 snprintf(buf1, sizeof(buf1), "Session: %s\r\n", rt->session_id); |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
945 av_strlcat(buf, buf1, sizeof(buf)); |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
946 } |
5220
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
947 if (rt->auth_b64) |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
948 av_strlcatf(buf, sizeof(buf), |
5221 | 949 "Authorization: Basic %s\r\n", |
950 rt->auth_b64); | |
4644
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
951 av_strlcat(buf, "\r\n", sizeof(buf)); |
4990 | 952 |
953 dprintf(s, "Sending:\n%s--\n", buf); | |
954 | |
4644
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
955 url_write(rt->rtsp_hd, buf, strlen(buf)); |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
956 rt->last_cmd_time = av_gettime(); |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
957 } |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
958 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
959 static void rtsp_send_cmd(AVFormatContext *s, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
960 const char *cmd, RTSPMessageHeader *reply, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
961 unsigned char **content_ptr) |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
962 { |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
963 rtsp_send_cmd_async(s, cmd, reply, content_ptr); |
4644
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
964 |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
965 rtsp_read_reply(s, reply, content_ptr, 0); |
4644
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
966 } |
2962d395431b
Split rtsp_send_cmd() into two functions, one for the actual sending of the
rbultje
parents:
4641
diff
changeset
|
967 |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
968 /** |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
969 * @returns 0 on success, <0 on error, 1 if protocol is unavailable. |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
970 */ |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
971 static int make_setup_request(AVFormatContext *s, const char *host, int port, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
972 int lower_transport, const char *real_challenge) |
0 | 973 { |
974 RTSPState *rt = s->priv_data; | |
4638
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
975 int rtx, j, i, err, interleave = 0; |
0 | 976 RTSPStream *rtsp_st; |
4557
bfe6fb676d46
Rename RTSPHeader to RTSPMessageHeader to reflect more clearly what the
rbultje
parents:
4549
diff
changeset
|
977 RTSPMessageHeader reply1, *reply = &reply1; |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
978 char cmd[2048]; |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
979 const char *trans_pref; |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
980 |
3960
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
981 if (rt->transport == RTSP_TRANSPORT_RDT) |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
982 trans_pref = "x-pn-tng"; |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
983 else |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
984 trans_pref = "RTP/AVP"; |
885 | 985 |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
986 /* default timeout: 1 minute */ |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
987 rt->timeout = 60; |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
988 |
0 | 989 /* for each stream, make the setup request */ |
990 /* XXX: we assume the same server is used for the control of each | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
991 * RTSP stream */ |
774 | 992 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
993 for (j = RTSP_RTP_PORT_MIN, i = 0; i < rt->nb_rtsp_streams; ++i) { |
0 | 994 char transport[2048]; |
995 | |
4638
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
996 /** |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
997 * WMS serves all UDP data over a single connection, the RTX, which |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
998 * isn't necessarily the first in the SDP but has to be the first |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
999 * to be set up, else the second/third SETUP will fail with a 461. |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1000 */ |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1001 if (lower_transport == RTSP_LOWER_TRANSPORT_UDP && |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1002 rt->server_type == RTSP_SERVER_WMS) { |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1003 if (i == 0) { |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1004 /* rtx first */ |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1005 for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) { |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1006 int len = strlen(rt->rtsp_streams[rtx]->control_url); |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1007 if (len >= 4 && |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1008 !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1009 "/rtx")) |
4638
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1010 break; |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1011 } |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1012 if (rtx == rt->nb_rtsp_streams) |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1013 return -1; /* no RTX found */ |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1014 rtsp_st = rt->rtsp_streams[rtx]; |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1015 } else |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1016 rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1]; |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1017 } else |
4639 | 1018 rtsp_st = rt->rtsp_streams[i]; |
0 | 1019 |
1020 /* RTP/UDP */ | |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1021 if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) { |
0 | 1022 char buf[256]; |
1023 | |
4638
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1024 if (rt->server_type == RTSP_SERVER_WMS && i > 1) { |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1025 port = reply->transports[0].client_port_min; |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1026 goto have_port; |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1027 } |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1028 |
0 | 1029 /* first try in specified port range */ |
774 | 1030 if (RTSP_RTP_PORT_MIN != 0) { |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1031 while (j <= RTSP_RTP_PORT_MAX) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1032 snprintf(buf, sizeof(buf), "rtp://%s?localport=%d", |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1033 host, j); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1034 /* we will use two ports per rtp stream (rtp and rtcp) */ |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1035 j += 2; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1036 if (url_open(&rtsp_st->rtp_handle, buf, URL_RDWR) == 0) |
0 | 1037 goto rtp_opened; |
1038 } | |
1039 } | |
1040 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1041 #if 0 |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1042 /* then try on any port */ |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1043 if (url_open(&rtsp_st->rtp_handle, "rtp://", URL_RDONLY) < 0) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1044 err = AVERROR_INVALIDDATA; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1045 goto fail; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1046 } |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1047 #endif |
0 | 1048 |
1049 rtp_opened: | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1050 port = rtp_get_local_port(rtsp_st->rtp_handle); |
4638
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1051 have_port: |
3877
3e0c7ad2a675
Remove unused code that used to handle protocol concatenation, i.e. trying
rbultje
parents:
3876
diff
changeset
|
1052 snprintf(transport, sizeof(transport) - 1, |
3958
ab2d2bc3a6e7
Send improper UDP SETUP request, which is what Realmedia servers expect.
rbultje
parents:
3957
diff
changeset
|
1053 "%s/UDP;", trans_pref); |
ab2d2bc3a6e7
Send improper UDP SETUP request, which is what Realmedia servers expect.
rbultje
parents:
3957
diff
changeset
|
1054 if (rt->server_type != RTSP_SERVER_REAL) |
ab2d2bc3a6e7
Send improper UDP SETUP request, which is what Realmedia servers expect.
rbultje
parents:
3957
diff
changeset
|
1055 av_strlcat(transport, "unicast;", sizeof(transport)); |
ab2d2bc3a6e7
Send improper UDP SETUP request, which is what Realmedia servers expect.
rbultje
parents:
3957
diff
changeset
|
1056 av_strlcatf(transport, sizeof(transport), |
ab2d2bc3a6e7
Send improper UDP SETUP request, which is what Realmedia servers expect.
rbultje
parents:
3957
diff
changeset
|
1057 "client_port=%d", port); |
4638
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1058 if (rt->transport == RTSP_TRANSPORT_RTP && |
801468f16243
Make RTSP-MS-over-UDP negotiation work. See "[PATCH] RTSP-MS 8/15: fix
rbultje
parents:
4637
diff
changeset
|
1059 !(rt->server_type == RTSP_SERVER_WMS && i > 0)) |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1060 av_strlcatf(transport, sizeof(transport), "-%d", port + 1); |
0 | 1061 } |
1062 | |
1063 /* RTP/TCP */ | |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1064 else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) { |
4637
eaf90db8cc42
Recognize the "application" data type, which is required for WMS/UDP
rbultje
parents:
4557
diff
changeset
|
1065 /** For WMS streams, the application streams are only used for |
eaf90db8cc42
Recognize the "application" data type, which is required for WMS/UDP
rbultje
parents:
4557
diff
changeset
|
1066 * UDP. When trying to set it up for TCP streams, the server |
eaf90db8cc42
Recognize the "application" data type, which is required for WMS/UDP
rbultje
parents:
4557
diff
changeset
|
1067 * will return an error. Therefore, we skip those streams. */ |
eaf90db8cc42
Recognize the "application" data type, which is required for WMS/UDP
rbultje
parents:
4557
diff
changeset
|
1068 if (rt->server_type == RTSP_SERVER_WMS && |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1069 s->streams[rtsp_st->stream_index]->codec->codec_type == |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1070 CODEC_TYPE_DATA) |
4637
eaf90db8cc42
Recognize the "application" data type, which is required for WMS/UDP
rbultje
parents:
4557
diff
changeset
|
1071 continue; |
3877
3e0c7ad2a675
Remove unused code that used to handle protocol concatenation, i.e. trying
rbultje
parents:
3876
diff
changeset
|
1072 snprintf(transport, sizeof(transport) - 1, |
4332
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1073 "%s/TCP;", trans_pref); |
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1074 if (rt->server_type == RTSP_SERVER_WMS) |
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1075 av_strlcat(transport, "unicast;", sizeof(transport)); |
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1076 av_strlcatf(transport, sizeof(transport), |
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1077 "interleaved=%d-%d", |
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1078 interleave, interleave + 1); |
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1079 interleave += 2; |
0 | 1080 } |
1081 | |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1082 else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) { |
3877
3e0c7ad2a675
Remove unused code that used to handle protocol concatenation, i.e. trying
rbultje
parents:
3876
diff
changeset
|
1083 snprintf(transport, sizeof(transport) - 1, |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1084 "%s/UDP;multicast", trans_pref); |
0 | 1085 } |
4332
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1086 if (rt->server_type == RTSP_SERVER_REAL || |
0d776969b708
Fix the Transport: line in the SETUP request so that it works with WMS
rbultje
parents:
4291
diff
changeset
|
1087 rt->server_type == RTSP_SERVER_WMS) |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1088 av_strlcat(transport, ";mode=play", sizeof(transport)); |
885 | 1089 snprintf(cmd, sizeof(cmd), |
172 | 1090 "SETUP %s RTSP/1.0\r\n" |
1091 "Transport: %s\r\n", | |
0 | 1092 rtsp_st->control_url, transport); |
3923
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1093 if (i == 0 && rt->server_type == RTSP_SERVER_REAL) { |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1094 char real_res[41], real_csum[9]; |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1095 ff_rdt_calc_response_and_checksum(real_res, real_csum, |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1096 real_challenge); |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1097 av_strlcatf(cmd, sizeof(cmd), |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1098 "If-Match: %s\r\n" |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1099 "RealChallenge2: %s, sd=%s\r\n", |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1100 rt->session_id, real_res, real_csum); |
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1101 } |
0 | 1102 rtsp_send_cmd(s, cmd, reply, NULL); |
3149
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1103 if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) { |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1104 err = 1; |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1105 goto fail; |
3151 | 1106 } else if (reply->status_code != RTSP_STATUS_OK || |
1107 reply->nb_transports != 1) { | |
0 | 1108 err = AVERROR_INVALIDDATA; |
1109 goto fail; | |
1110 } | |
1111 | |
1112 /* XXX: same protocol for all streams is required */ | |
1113 if (i > 0) { | |
3960
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
1114 if (reply->transports[0].lower_transport != rt->lower_transport || |
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
1115 reply->transports[0].transport != rt->transport) { |
0 | 1116 err = AVERROR_INVALIDDATA; |
1117 goto fail; | |
1118 } | |
1119 } else { | |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1120 rt->lower_transport = reply->transports[0].lower_transport; |
3960
13e9b0d3a314
Implement a RTSPTransport field, which allows proper separation of server
rbultje
parents:
3959
diff
changeset
|
1121 rt->transport = reply->transports[0].transport; |
0 | 1122 } |
1123 | |
1124 /* close RTP connection if not choosen */ | |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1125 if (reply->transports[0].lower_transport != RTSP_LOWER_TRANSPORT_UDP && |
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1126 (lower_transport == RTSP_LOWER_TRANSPORT_UDP)) { |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1127 url_close(rtsp_st->rtp_handle); |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1128 rtsp_st->rtp_handle = NULL; |
0 | 1129 } |
1130 | |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1131 switch(reply->transports[0].lower_transport) { |
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1132 case RTSP_LOWER_TRANSPORT_TCP: |
0 | 1133 rtsp_st->interleaved_min = reply->transports[0].interleaved_min; |
1134 rtsp_st->interleaved_max = reply->transports[0].interleaved_max; | |
1135 break; | |
885 | 1136 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1137 case RTSP_LOWER_TRANSPORT_UDP: { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1138 char url[1024]; |
885 | 1139 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1140 /* XXX: also use address if specified */ |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1141 snprintf(url, sizeof(url), "rtp://%s:%d", |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1142 host, reply->transports[0].server_port_min); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1143 if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) && |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1144 rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1145 err = AVERROR_INVALIDDATA; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1146 goto fail; |
0 | 1147 } |
1148 break; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1149 } |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1150 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1151 char url[1024]; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1152 struct in_addr in; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1153 int port, ttl; |
0 | 1154 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1155 if (reply->transports[0].destination) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1156 in.s_addr = htonl(reply->transports[0].destination); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1157 port = reply->transports[0].port_min; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1158 ttl = reply->transports[0].ttl; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1159 } else { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1160 in = rtsp_st->sdp_ip; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1161 port = rtsp_st->sdp_port; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1162 ttl = rtsp_st->sdp_ttl; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1163 } |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1164 snprintf(url, sizeof(url), "rtp://%s:%d?ttl=%d", |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1165 inet_ntoa(in), port, ttl); |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1166 if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) { |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1167 err = AVERROR_INVALIDDATA; |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1168 goto fail; |
0 | 1169 } |
1170 break; | |
1171 } | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1172 } |
774 | 1173 |
3919
1879eab34f88
Factorize out common code for opening of the RTP parsing context between
rbultje
parents:
3905
diff
changeset
|
1174 if ((err = rtsp_open_transport_ctx(s, rtsp_st))) |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1175 goto fail; |
0 | 1176 } |
1177 | |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1178 if (reply->timeout > 0) |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1179 rt->timeout = reply->timeout; |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1180 |
3923
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1181 if (rt->server_type == RTSP_SERVER_REAL) |
3903
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1182 rt->need_subscription = 1; |
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1183 |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1184 return 0; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1185 |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1186 fail: |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1187 for (i = 0; i < rt->nb_rtsp_streams; i++) { |
3149
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1188 if (rt->rtsp_streams[i]->rtp_handle) { |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1189 url_close(rt->rtsp_streams[i]->rtp_handle); |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1190 rt->rtsp_streams[i]->rtp_handle = NULL; |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1191 } |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1192 } |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1193 return err; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1194 } |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1195 |
5365
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1196 static int rtsp_read_play(AVFormatContext *s) |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1197 { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1198 RTSPState *rt = s->priv_data; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1199 RTSPMessageHeader reply1, *reply = &reply1; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1200 char cmd[1024]; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1201 |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1202 av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1203 |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1204 if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1205 if (rt->state == RTSP_STATE_PAUSED) { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1206 snprintf(cmd, sizeof(cmd), |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1207 "PLAY %s RTSP/1.0\r\n", |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1208 s->filename); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1209 } else { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1210 snprintf(cmd, sizeof(cmd), |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1211 "PLAY %s RTSP/1.0\r\n" |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1212 "Range: npt=%0.3f-\r\n", |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1213 s->filename, |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1214 (double)rt->seek_timestamp / AV_TIME_BASE); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1215 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1216 rtsp_send_cmd(s, cmd, reply, NULL); |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1217 if (reply->status_code != RTSP_STATUS_OK) { |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1218 return -1; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1219 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1220 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1221 rt->state = RTSP_STATE_PLAYING; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1222 return 0; |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1223 } |
4097dc22e612
Move some some functions around, so that splitting the SDP code out of
lucabe
parents:
5334
diff
changeset
|
1224 |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1225 static int rtsp_read_header(AVFormatContext *s, |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1226 AVFormatParameters *ap) |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1227 { |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1228 RTSPState *rt = s->priv_data; |
5331 | 1229 char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128]; |
1230 char *option_list, *option, *filename; | |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1231 URLContext *rtsp_hd; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1232 int port, ret, err; |
4557
bfe6fb676d46
Rename RTSPHeader to RTSPMessageHeader to reflect more clearly what the
rbultje
parents:
4549
diff
changeset
|
1233 RTSPMessageHeader reply1, *reply = &reply1; |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1234 unsigned char *content = NULL; |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1235 int lower_transport_mask = 0; |
3856 | 1236 char real_challenge[64]; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1237 redirect: |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1238 /* extract hostname and port */ |
5220
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1239 url_split(NULL, 0, auth, sizeof(auth), |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1240 host, sizeof(host), &port, path, sizeof(path), s->filename); |
5220
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1241 if (*auth) { |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1242 int auth_len = strlen(auth), b64_len = ((auth_len + 2) / 3) * 4 + 1; |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1243 |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1244 if (!(rt->auth_b64 = av_malloc(b64_len))) |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1245 return AVERROR(ENOMEM); |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1246 if (!av_base64_encode(rt->auth_b64, b64_len, auth, auth_len)) { |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1247 err = AVERROR(EINVAL); |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1248 goto fail; |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1249 } |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1250 } |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1251 if (port < 0) |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1252 port = RTSP_DEFAULT_PORT; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1253 |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1254 /* search for options */ |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1255 option_list = strchr(path, '?'); |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1256 if (option_list) { |
5331 | 1257 filename = strchr(s->filename, '?'); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1258 while (option_list) { |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1259 /* move the option pointer */ |
5331 | 1260 option = ++option_list; |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1261 option_list = strchr(option_list, '&'); |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1262 if (option_list) |
5331 | 1263 *option_list = 0; |
1264 | |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1265 /* handle the options */ |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1266 if (!strcmp(option, "udp")) { |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1267 lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1268 } else if (!strcmp(option, "multicast")) { |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1269 lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_UDP_MULTICAST); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1270 } else if (!strcmp(option, "tcp")) { |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1271 lower_transport_mask = (1<< RTSP_LOWER_TRANSPORT_TCP); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1272 } else { |
5331 | 1273 strcpy(++filename, option); |
1274 filename += strlen(option); | |
1275 if (option_list) *filename = '&'; | |
1276 } | |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1277 } |
5331 | 1278 *filename = 0; |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1279 } |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1280 |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1281 if (!lower_transport_mask) |
4514
2a84d46427d1
Rename RTSP_*_LAST to RTSP_*_NB in line with PIX_FMT_* in lavc. See "[PATCH]
rbultje
parents:
4388
diff
changeset
|
1282 lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1; |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1283 |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1284 /* open the tcp connexion */ |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1285 snprintf(tcpname, sizeof(tcpname), "tcp://%s:%d", host, port); |
5220
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1286 if (url_open(&rtsp_hd, tcpname, URL_RDWR) < 0) { |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1287 err = AVERROR(EIO); |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1288 goto fail; |
cad276e8f96e
RTSP basic authentication, patch originally by Philip Coombes
rbultje
parents:
5112
diff
changeset
|
1289 } |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1290 rt->rtsp_hd = rtsp_hd; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1291 rt->seq = 0; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1292 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1293 /* request options supported by the server; this also detects server |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1294 * type */ |
3856 | 1295 for (rt->server_type = RTSP_SERVER_RTP;;) { |
1296 snprintf(cmd, sizeof(cmd), | |
1297 "OPTIONS %s RTSP/1.0\r\n", s->filename); | |
3923
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1298 if (rt->server_type == RTSP_SERVER_REAL) |
3856 | 1299 av_strlcat(cmd, |
1300 /** | |
1301 * The following entries are required for proper | |
1302 * streaming from a Realmedia server. They are | |
1303 * interdependent in some way although we currently | |
1304 * don't quite understand how. Values were copied | |
1305 * from mplayer SVN r23589. | |
1306 * @param CompanyID is a 16-byte ID in base64 | |
1307 * @param ClientChallenge is a 16-byte ID in hex | |
1308 */ | |
1309 "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n" | |
1310 "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n" | |
1311 "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n" | |
1312 "GUID: 00000000-0000-0000-0000-000000000000\r\n", | |
1313 sizeof(cmd)); | |
1314 rtsp_send_cmd(s, cmd, reply, NULL); | |
1315 if (reply->status_code != RTSP_STATUS_OK) { | |
1316 err = AVERROR_INVALIDDATA; | |
1317 goto fail; | |
1318 } | |
1319 | |
1320 /* detect server type if not standard-compliant RTP */ | |
3923
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1321 if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) { |
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1322 rt->server_type = RTSP_SERVER_REAL; |
3856 | 1323 continue; |
4169
619845a9bab3
Use the "server" RTSP field to detect whether the server that we're talking
rbultje
parents:
4168
diff
changeset
|
1324 } else if (!strncasecmp(reply->server, "WMServer/", 9)) { |
619845a9bab3
Use the "server" RTSP field to detect whether the server that we're talking
rbultje
parents:
4168
diff
changeset
|
1325 rt->server_type = RTSP_SERVER_WMS; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1326 } else if (rt->server_type == RTSP_SERVER_REAL) |
3856 | 1327 strcpy(real_challenge, reply->real_challenge); |
1328 break; | |
1329 } | |
1330 | |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1331 /* describe the stream */ |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1332 snprintf(cmd, sizeof(cmd), |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1333 "DESCRIBE %s RTSP/1.0\r\n" |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1334 "Accept: application/sdp\r\n", |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1335 s->filename); |
3923
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1336 if (rt->server_type == RTSP_SERVER_REAL) { |
3859 | 1337 /** |
1338 * The Require: attribute is needed for proper streaming from | |
1339 * Realmedia servers. | |
1340 */ | |
1341 av_strlcat(cmd, | |
1342 "Require: com.real.retain-entity-for-setup\r\n", | |
1343 sizeof(cmd)); | |
1344 } | |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1345 rtsp_send_cmd(s, cmd, reply, &content); |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1346 if (!content) { |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1347 err = AVERROR_INVALIDDATA; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1348 goto fail; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1349 } |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1350 if (reply->status_code != RTSP_STATUS_OK) { |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1351 err = AVERROR_INVALIDDATA; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1352 goto fail; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1353 } |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1354 |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1355 /* now we got the SDP description, we parse it */ |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1356 ret = sdp_parse(s, (const char *)content); |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1357 av_freep(&content); |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1358 if (ret < 0) { |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1359 err = AVERROR_INVALIDDATA; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1360 goto fail; |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1361 } |
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1362 |
3149
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1363 do { |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1364 int lower_transport = ff_log2_tab[lower_transport_mask & |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1365 ~(lower_transport_mask - 1)]; |
3149
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1366 |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1367 err = make_setup_request(s, host, port, lower_transport, |
3923
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1368 rt->server_type == RTSP_SERVER_REAL ? |
3876
1026953d4ffe
Implement Realmedia/RTSP-compatible SETUP command. This includes calculation
rbultje
parents:
3861
diff
changeset
|
1369 real_challenge : NULL); |
3149
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1370 if (err < 0) |
3151 | 1371 goto fail; |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1372 lower_transport_mask &= ~(1 << lower_transport); |
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1373 if (lower_transport_mask == 0 && err == 1) { |
3202
98e633b72d38
use FF_NETERROR to make winsock happy, patch from prossATxvidDoTorg
lu_zero
parents:
3151
diff
changeset
|
1374 err = AVERROR(FF_NETERROR(EPROTONOSUPPORT)); |
3149
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1375 goto fail; |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1376 } |
5a7a7406ab1f
Allow cycling between different protocols (TCP, UDP or multicast) so that if
rbultje
parents:
3147
diff
changeset
|
1377 } while (err); |
3147
91d65fdf91e1
Split the SETUP request into a separate function, as a prelude into allowing
rbultje
parents:
2884
diff
changeset
|
1378 |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1379 rt->state = RTSP_STATE_IDLE; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1380 rt->seek_timestamp = 0; /* default is to start stream at position zero */ |
1003 | 1381 if (ap->initial_pause) { |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1382 /* do not start immediately */ |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1383 } else { |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1384 if (rtsp_read_play(s) < 0) { |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1385 err = AVERROR_INVALIDDATA; |
0 | 1386 goto fail; |
1387 } | |
1388 } | |
1389 return 0; | |
1390 fail: | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1391 rtsp_close_streams(rt); |
0 | 1392 av_freep(&content); |
1393 url_close(rt->rtsp_hd); | |
5333 | 1394 if (reply->status_code >=300 && reply->status_code < 400) { |
1395 av_strlcpy(s->filename, reply->location, sizeof(s->filename)); | |
1396 av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n", | |
1397 reply->status_code, | |
1398 s->filename); | |
1399 goto redirect; | |
1400 } | |
0 | 1401 return err; |
1402 } | |
1403 | |
5493 | 1404 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, |
1405 uint8_t *buf, int buf_size) | |
1406 { | |
1407 RTSPState *rt = s->priv_data; | |
1408 RTSPStream *rtsp_st; | |
1409 fd_set rfds; | |
1410 int fd, fd_max, n, i, ret, tcp_fd; | |
1411 struct timeval tv; | |
1412 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1413 for (;;) { |
5493 | 1414 if (url_interrupt_cb()) |
1415 return AVERROR(EINTR); | |
1416 FD_ZERO(&rfds); | |
1417 if (rt->rtsp_hd) { | |
1418 tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd); | |
1419 FD_SET(tcp_fd, &rfds); | |
1420 } else { | |
1421 fd_max = 0; | |
1422 tcp_fd = -1; | |
1423 } | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1424 for (i = 0; i < rt->nb_rtsp_streams; i++) { |
5493 | 1425 rtsp_st = rt->rtsp_streams[i]; |
1426 if (rtsp_st->rtp_handle) { | |
1427 /* currently, we cannot probe RTCP handle because of | |
1428 * blocking restrictions */ | |
1429 fd = url_get_file_handle(rtsp_st->rtp_handle); | |
1430 if (fd > fd_max) | |
1431 fd_max = fd; | |
1432 FD_SET(fd, &rfds); | |
1433 } | |
1434 } | |
1435 tv.tv_sec = 0; | |
1436 tv.tv_usec = 100 * 1000; | |
1437 n = select(fd_max + 1, &rfds, NULL, NULL, &tv); | |
1438 if (n > 0) { | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1439 for (i = 0; i < rt->nb_rtsp_streams; i++) { |
5493 | 1440 rtsp_st = rt->rtsp_streams[i]; |
1441 if (rtsp_st->rtp_handle) { | |
1442 fd = url_get_file_handle(rtsp_st->rtp_handle); | |
1443 if (FD_ISSET(fd, &rfds)) { | |
1444 ret = url_read(rtsp_st->rtp_handle, buf, buf_size); | |
1445 if (ret > 0) { | |
1446 *prtsp_st = rtsp_st; | |
1447 return ret; | |
1448 } | |
1449 } | |
1450 } | |
1451 } | |
1452 #if CONFIG_RTSP_DEMUXER | |
1453 if (FD_ISSET(tcp_fd, &rfds)) { | |
1454 RTSPMessageHeader reply; | |
1455 | |
1456 rtsp_read_reply(s, &reply, NULL, 0); | |
1457 /* XXX: parse message */ | |
1458 if (rt->state != RTSP_STATE_PLAYING) | |
1459 return 0; | |
1460 } | |
1461 #endif | |
1462 } | |
1463 } | |
1464 } | |
1465 | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1466 static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1467 uint8_t *buf, int buf_size) |
0 | 1468 { |
1469 RTSPState *rt = s->priv_data; | |
172 | 1470 int id, len, i, ret; |
0 | 1471 RTSPStream *rtsp_st; |
1472 | |
172 | 1473 #ifdef DEBUG_RTP_TCP |
4990 | 1474 dprintf(s, "tcp_read_packet:\n"); |
172 | 1475 #endif |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1476 redo: |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1477 for (;;) { |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
1478 RTSPMessageHeader reply; |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
1479 |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
1480 ret = rtsp_read_reply(s, &reply, NULL, 1); |
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
1481 if (ret == -1) |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1482 return -1; |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
1483 if (ret == 1) /* received '$' */ |
0 | 1484 break; |
4772
fb0b1e68356c
Allow (and parse) incoming server messages (notices) interleaved with TCP
rbultje
parents:
4745
diff
changeset
|
1485 /* XXX: parse message */ |
5112
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
1486 if (rt->state != RTSP_STATE_PLAYING) |
85e0a9761818
Implement support for EOS as used by WMS and other RTSP servers that do not
rbultje
parents:
5013
diff
changeset
|
1487 return 0; |
0 | 1488 } |
5004
84a7b7a2f252
Move function for reading whole specified amount of data from RTSP
kostya
parents:
4990
diff
changeset
|
1489 ret = url_read_complete(rt->rtsp_hd, buf, 3); |
172 | 1490 if (ret != 3) |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1491 return -1; |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1492 id = buf[0]; |
2222 | 1493 len = AV_RB16(buf + 1); |
172 | 1494 #ifdef DEBUG_RTP_TCP |
4990 | 1495 dprintf(s, "id=%d len=%d\n", id, len); |
172 | 1496 #endif |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1497 if (len > buf_size || len < 12) |
0 | 1498 goto redo; |
1499 /* get the data */ | |
5004
84a7b7a2f252
Move function for reading whole specified amount of data from RTSP
kostya
parents:
4990
diff
changeset
|
1500 ret = url_read_complete(rt->rtsp_hd, buf, len); |
172 | 1501 if (ret != len) |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1502 return -1; |
3962
72efef66f566
This patch refactors RDT packet header parsing so that it can be used in
rbultje
parents:
3961
diff
changeset
|
1503 if (rt->transport == RTSP_TRANSPORT_RDT && |
4029
9a0a46d465ae
Add is_keyframe param to ff_rdt_parse_header(). See ML discussion in
rbultje
parents:
4026
diff
changeset
|
1504 ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0) |
3962
72efef66f566
This patch refactors RDT packet header parsing so that it can be used in
rbultje
parents:
3961
diff
changeset
|
1505 return -1; |
885 | 1506 |
0 | 1507 /* find the matching stream */ |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1508 for (i = 0; i < rt->nb_rtsp_streams; i++) { |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1509 rtsp_st = rt->rtsp_streams[i]; |
885 | 1510 if (id >= rtsp_st->interleaved_min && |
1511 id <= rtsp_st->interleaved_max) | |
0 | 1512 goto found; |
1513 } | |
1514 goto redo; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1515 found: |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1516 *prtsp_st = rtsp_st; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1517 return len; |
0 | 1518 } |
1519 | |
5493 | 1520 static int rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt) |
1521 { | |
1522 RTSPState *rt = s->priv_data; | |
1523 int ret, len; | |
1524 uint8_t buf[10 * RTP_MAX_PACKET_LENGTH]; | |
1525 RTSPStream *rtsp_st; | |
1526 | |
1527 /* get next frames from the same RTP packet */ | |
1528 if (rt->cur_transport_priv) { | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1529 if (rt->transport == RTSP_TRANSPORT_RDT) { |
5493 | 1530 ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1531 } else |
5493 | 1532 ret = rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0); |
1533 if (ret == 0) { | |
1534 rt->cur_transport_priv = NULL; | |
1535 return 0; | |
1536 } else if (ret == 1) { | |
1537 return 0; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1538 } else |
5493 | 1539 rt->cur_transport_priv = NULL; |
1540 } | |
1541 | |
1542 /* read next RTP packet */ | |
1543 redo: | |
1544 switch(rt->lower_transport) { | |
1545 default: | |
1546 #if CONFIG_RTSP_DEMUXER | |
1547 case RTSP_LOWER_TRANSPORT_TCP: | |
1548 len = tcp_read_packet(s, &rtsp_st, buf, sizeof(buf)); | |
1549 break; | |
1550 #endif | |
1551 case RTSP_LOWER_TRANSPORT_UDP: | |
1552 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: | |
1553 len = udp_read_packet(s, &rtsp_st, buf, sizeof(buf)); | |
1554 if (len >=0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP) | |
1555 rtp_check_and_send_back_rr(rtsp_st->transport_priv, len); | |
1556 break; | |
1557 } | |
1558 if (len < 0) | |
1559 return len; | |
1560 if (len == 0) | |
1561 return AVERROR_EOF; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1562 if (rt->transport == RTSP_TRANSPORT_RDT) { |
5493 | 1563 ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, buf, len); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1564 } else |
5493 | 1565 ret = rtp_parse_packet(rtsp_st->transport_priv, pkt, buf, len); |
1566 if (ret < 0) | |
1567 goto redo; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1568 if (ret == 1) |
5493 | 1569 /* more packets may follow, so we save the RTP context */ |
1570 rt->cur_transport_priv = rtsp_st->transport_priv; | |
1571 | |
1572 return ret; | |
1573 } | |
1574 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1575 static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt) |
0 | 1576 { |
1577 RTSPState *rt = s->priv_data; | |
5366
a04be95927ac
Split the sdp_read_packet() function out of rtsp_read_packet().
lucabe
parents:
5365
diff
changeset
|
1578 int ret; |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1579 RTSPMessageHeader reply1, *reply = &reply1; |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1580 char cmd[1024]; |
0 | 1581 |
4166
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1582 if (rt->server_type == RTSP_SERVER_REAL) { |
3903
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1583 int i; |
4166
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1584 enum AVDiscard cache[MAX_STREAMS]; |
3903
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1585 |
4166
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1586 for (i = 0; i < s->nb_streams; i++) |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1587 cache[i] = s->streams[i]->discard; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1588 |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1589 if (!rt->need_subscription) { |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1590 if (memcmp (cache, rt->real_setup_cache, |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1591 sizeof(enum AVDiscard) * s->nb_streams)) { |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1592 av_strlcatf(cmd, sizeof(cmd), |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1593 "SET_PARAMETER %s RTSP/1.0\r\n" |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1594 "Unsubscribe: %s\r\n", |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1595 s->filename, rt->last_subscription); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1596 rtsp_send_cmd(s, cmd, reply, NULL); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1597 if (reply->status_code != RTSP_STATUS_OK) |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1598 return AVERROR_INVALIDDATA; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1599 rt->need_subscription = 1; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1600 } |
3903
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1601 } |
4166
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1602 |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1603 if (rt->need_subscription) { |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1604 int r, rule_nr, first = 1; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1605 |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1606 memcpy(rt->real_setup_cache, cache, |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1607 sizeof(enum AVDiscard) * s->nb_streams); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1608 rt->last_subscription[0] = 0; |
3903
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1609 |
4166
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1610 snprintf(cmd, sizeof(cmd), |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1611 "SET_PARAMETER %s RTSP/1.0\r\n" |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1612 "Subscribe: ", |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1613 s->filename); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1614 for (i = 0; i < rt->nb_rtsp_streams; i++) { |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1615 rule_nr = 0; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1616 for (r = 0; r < s->nb_streams; r++) { |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1617 if (s->streams[r]->priv_data == rt->rtsp_streams[i]) { |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1618 if (s->streams[r]->discard != AVDISCARD_ALL) { |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1619 if (!first) |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1620 av_strlcat(rt->last_subscription, ",", |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1621 sizeof(rt->last_subscription)); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1622 ff_rdt_subscribe_rule( |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1623 rt->last_subscription, |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1624 sizeof(rt->last_subscription), i, rule_nr); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1625 first = 0; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1626 } |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1627 rule_nr++; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1628 } |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1629 } |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1630 } |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1631 av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1632 rtsp_send_cmd(s, cmd, reply, NULL); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1633 if (reply->status_code != RTSP_STATUS_OK) |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1634 return AVERROR_INVALIDDATA; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1635 rt->need_subscription = 0; |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1636 |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1637 if (rt->state == RTSP_STATE_PLAYING) |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1638 rtsp_read_play (s); |
1dbda91eaebd
Allow subscription to any of the streams, not just the first, available in
rbultje
parents:
4165
diff
changeset
|
1639 } |
3903
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1640 } |
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1641 |
5480 | 1642 ret = rtsp_fetch_packet(s, pkt); |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1643 if (ret < 0) |
5366
a04be95927ac
Split the sdp_read_packet() function out of rtsp_read_packet().
lucabe
parents:
5365
diff
changeset
|
1644 return ret; |
4877
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1645 |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1646 /* send dummy request to keep TCP connection alive */ |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1647 if ((rt->server_type == RTSP_SERVER_WMS || |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1648 rt->server_type == RTSP_SERVER_REAL) && |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1649 (av_gettime() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2) { |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1650 if (rt->server_type == RTSP_SERVER_WMS) { |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1651 snprintf(cmd, sizeof(cmd) - 1, |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1652 "GET_PARAMETER %s RTSP/1.0\r\n", |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1653 s->filename); |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1654 rtsp_send_cmd_async(s, cmd, reply, NULL); |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1655 } else { |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1656 rtsp_send_cmd_async(s, "OPTIONS * RTSP/1.0\r\n", |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1657 reply, NULL); |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1658 } |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1659 } |
940946a4569b
Send dummy requests over the TCP connection (WMS wants GET_PARAMETER,
rbultje
parents:
4875
diff
changeset
|
1660 |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1661 return 0; |
0 | 1662 } |
1663 | |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1664 /* pause the stream */ |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1665 static int rtsp_read_pause(AVFormatContext *s) |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1666 { |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1667 RTSPState *rt = s->priv_data; |
4557
bfe6fb676d46
Rename RTSPHeader to RTSPMessageHeader to reflect more clearly what the
rbultje
parents:
4549
diff
changeset
|
1668 RTSPMessageHeader reply1, *reply = &reply1; |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1669 char cmd[1024]; |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1670 |
179 | 1671 rt = s->priv_data; |
885 | 1672 |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1673 if (rt->state != RTSP_STATE_PLAYING) |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1674 return 0; |
3923
83e51bcb03c2
Rename RTSP_SERVER_RDT to RTSP_SERVER_REAL, because RDT (the transport
rbultje
parents:
3920
diff
changeset
|
1675 else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) { |
3904 | 1676 snprintf(cmd, sizeof(cmd), |
1677 "PAUSE %s RTSP/1.0\r\n", | |
1678 s->filename); | |
1679 rtsp_send_cmd(s, cmd, reply, NULL); | |
1680 if (reply->status_code != RTSP_STATUS_OK) { | |
1681 return -1; | |
1682 } | |
3903
aeb79f68ba7e
Implement a RDT-specific SET_PARAMETER command that subscribes to the
rbultje
parents:
3877
diff
changeset
|
1683 } |
3861
a0098594ab90
Remove useless "else" case in if X { A; return }; else { B }. See discussion
rbultje
parents:
3860
diff
changeset
|
1684 rt->state = RTSP_STATE_PAUSED; |
a0098594ab90
Remove useless "else" case in if X { A; return }; else { B }. See discussion
rbultje
parents:
3860
diff
changeset
|
1685 return 0; |
179 | 1686 } |
1687 | |
885 | 1688 static int rtsp_read_seek(AVFormatContext *s, int stream_index, |
558 | 1689 int64_t timestamp, int flags) |
179 | 1690 { |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1691 RTSPState *rt = s->priv_data; |
885 | 1692 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1693 rt->seek_timestamp = av_rescale_q(timestamp, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1694 s->streams[stream_index]->time_base, |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1695 AV_TIME_BASE_Q); |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1696 switch(rt->state) { |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1697 default: |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1698 case RTSP_STATE_IDLE: |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1699 break; |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1700 case RTSP_STATE_PLAYING: |
5013 | 1701 if (rtsp_read_pause(s) != 0) |
1702 return -1; | |
1703 rt->state = RTSP_STATE_SEEKING; | |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1704 if (rtsp_read_play(s) != 0) |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1705 return -1; |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1706 break; |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1707 case RTSP_STATE_PAUSED: |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1708 rt->state = RTSP_STATE_IDLE; |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1709 break; |
179 | 1710 } |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1711 return 0; |
179 | 1712 } |
1713 | |
0 | 1714 static int rtsp_read_close(AVFormatContext *s) |
1715 { | |
1716 RTSPState *rt = s->priv_data; | |
4557
bfe6fb676d46
Rename RTSPHeader to RTSPMessageHeader to reflect more clearly what the
rbultje
parents:
4549
diff
changeset
|
1717 RTSPMessageHeader reply1, *reply = &reply1; |
0 | 1718 char cmd[1024]; |
1719 | |
172 | 1720 #if 0 |
0 | 1721 /* NOTE: it is valid to flush the buffer here */ |
3957
9f943bb755f9
Rename RTSPProtocol to RTSPLowerTransport, so that its name properly tells us
rbultje
parents:
3941
diff
changeset
|
1722 if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) { |
0 | 1723 url_fclose(&rt->rtsp_gb); |
1724 } | |
172 | 1725 #endif |
885 | 1726 snprintf(cmd, sizeof(cmd), |
172 | 1727 "TEARDOWN %s RTSP/1.0\r\n", |
0 | 1728 s->filename); |
1729 rtsp_send_cmd(s, cmd, reply, NULL); | |
1730 | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1731 rtsp_close_streams(rt); |
0 | 1732 url_close(rt->rtsp_hd); |
1733 return 0; | |
1734 } | |
1735 | |
1167 | 1736 AVInputFormat rtsp_demuxer = { |
0 | 1737 "rtsp", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
1738 NULL_IF_CONFIG_SMALL("RTSP input format"), |
0 | 1739 sizeof(RTSPState), |
1740 rtsp_probe, | |
1741 rtsp_read_header, | |
1742 rtsp_read_packet, | |
1743 rtsp_read_close, | |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1744 rtsp_read_seek, |
0 | 1745 .flags = AVFMT_NOFILE, |
304
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1746 .read_play = rtsp_read_play, |
d58c8859ff8c
initial seek support - more generic play/pause support
bellard
parents:
294
diff
changeset
|
1747 .read_pause = rtsp_read_pause, |
0 | 1748 }; |
2054 | 1749 #endif |
0 | 1750 |
1751 static int sdp_probe(AVProbeData *p1) | |
1752 { | |
706
fc254f396f15
buffer overflow in sdp_probe() fix by (Gildas Bazin )gbazin altern org)
michael
parents:
587
diff
changeset
|
1753 const char *p = p1->buf, *p_end = p1->buf + p1->buf_size; |
0 | 1754 |
1755 /* we look for a line beginning "c=IN IP4" */ | |
706
fc254f396f15
buffer overflow in sdp_probe() fix by (Gildas Bazin )gbazin altern org)
michael
parents:
587
diff
changeset
|
1756 while (p < p_end && *p != '\0') { |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1757 if (p + sizeof("c=IN IP4") - 1 < p_end && |
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1758 av_strstart(p, "c=IN IP4", NULL)) |
0 | 1759 return AVPROBE_SCORE_MAX / 2; |
706
fc254f396f15
buffer overflow in sdp_probe() fix by (Gildas Bazin )gbazin altern org)
michael
parents:
587
diff
changeset
|
1760 |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1761 while (p < p_end - 1 && *p != '\n') p++; |
706
fc254f396f15
buffer overflow in sdp_probe() fix by (Gildas Bazin )gbazin altern org)
michael
parents:
587
diff
changeset
|
1762 if (++p >= p_end) |
0 | 1763 break; |
1764 if (*p == '\r') | |
1765 p++; | |
1766 } | |
1767 return 0; | |
1768 } | |
1769 | |
1770 #define SDP_MAX_SIZE 8192 | |
1771 | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1772 static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap) |
0 | 1773 { |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1774 RTSPState *rt = s->priv_data; |
0 | 1775 RTSPStream *rtsp_st; |
1776 int size, i, err; | |
1777 char *content; | |
1778 char url[1024]; | |
1779 | |
1780 /* read the whole sdp file */ | |
1781 /* XXX: better loading */ | |
1782 content = av_malloc(SDP_MAX_SIZE); | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2759
diff
changeset
|
1783 size = get_buffer(s->pb, content, SDP_MAX_SIZE - 1); |
0 | 1784 if (size <= 0) { |
1785 av_free(content); | |
1786 return AVERROR_INVALIDDATA; | |
1787 } | |
1788 content[size] ='\0'; | |
1789 | |
1790 sdp_parse(s, content); | |
1791 av_free(content); | |
1792 | |
1793 /* open each RTP stream */ | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1794 for (i = 0; i < rt->nb_rtsp_streams; i++) { |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1795 rtsp_st = rt->rtsp_streams[i]; |
885 | 1796 |
3222 | 1797 snprintf(url, sizeof(url), "rtp://%s:%d?localport=%d&ttl=%d", |
885 | 1798 inet_ntoa(rtsp_st->sdp_ip), |
0 | 1799 rtsp_st->sdp_port, |
3222 | 1800 rtsp_st->sdp_port, |
0 | 1801 rtsp_st->sdp_ttl); |
1425
00d9393a126f
make ffmpeg able to send back a RTCP receiver report.
gpoirier
parents:
1424
diff
changeset
|
1802 if (url_open(&rtsp_st->rtp_handle, url, URL_RDWR) < 0) { |
0 | 1803 err = AVERROR_INVALIDDATA; |
1804 goto fail; | |
1805 } | |
3919
1879eab34f88
Factorize out common code for opening of the RTP parsing context between
rbultje
parents:
3905
diff
changeset
|
1806 if ((err = rtsp_open_transport_ctx(s, rtsp_st))) |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1807 goto fail; |
0 | 1808 } |
1809 return 0; | |
5502
da007db2fe9c
Re-indent to more closely follow general coding standards used in other
rbultje
parents:
5493
diff
changeset
|
1810 fail: |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1811 rtsp_close_streams(rt); |
0 | 1812 return err; |
1813 } | |
1814 | |
1815 static int sdp_read_close(AVFormatContext *s) | |
1816 { | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1817 RTSPState *rt = s->priv_data; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
229
diff
changeset
|
1818 rtsp_close_streams(rt); |
0 | 1819 return 0; |
1820 } | |
1821 | |
1169 | 1822 AVInputFormat sdp_demuxer = { |
0 | 1823 "sdp", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
1824 NULL_IF_CONFIG_SMALL("SDP"), |
0 | 1825 sizeof(RTSPState), |
1826 sdp_probe, | |
1827 sdp_read_header, | |
5480 | 1828 rtsp_fetch_packet, |
0 | 1829 sdp_read_close, |
1830 }; |