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