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