FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rtsp.c
Go to the documentation of this file.
1 /*
2  * RTSP/SDP client
3  * Copyright (c) 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
23 #include "libavutil/base64.h"
24 #include "libavutil/avstring.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/parseutils.h"
28 #include "libavutil/random_seed.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/time.h"
32 #include "avformat.h"
33 #include "avio_internal.h"
34 
35 #if HAVE_POLL_H
36 #include <poll.h>
37 #endif
38 #include "internal.h"
39 #include "network.h"
40 #include "os_support.h"
41 #include "http.h"
42 #include "rtsp.h"
43 
44 #include "rtpdec.h"
45 #include "rtpproto.h"
46 #include "rdt.h"
47 #include "rtpdec_formats.h"
48 #include "rtpenc_chain.h"
49 #include "url.h"
50 #include "rtpenc.h"
51 #include "mpegts.h"
52 
53 /* Timeout values for socket poll, in ms,
54  * and read_packet(), in seconds */
55 #define POLL_TIMEOUT_MS 100
56 #define READ_PACKET_TIMEOUT_S 10
57 #define MAX_TIMEOUTS READ_PACKET_TIMEOUT_S * 1000 / POLL_TIMEOUT_MS
58 #define SDP_MAX_SIZE 16384
59 #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
60 #define DEFAULT_REORDERING_DELAY 100000
61 
62 #define OFFSET(x) offsetof(RTSPState, x)
63 #define DEC AV_OPT_FLAG_DECODING_PARAM
64 #define ENC AV_OPT_FLAG_ENCODING_PARAM
65 
66 #define RTSP_FLAG_OPTS(name, longname) \
67  { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtsp_flags" }, \
68  { "filter_src", "only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, "rtsp_flags" }
69 
70 #define RTSP_MEDIATYPE_OPTS(name, longname) \
71  { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1 }, INT_MIN, INT_MAX, DEC, "allowed_media_types" }, \
72  { "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, "allowed_media_types" }, \
73  { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, "allowed_media_types" }, \
74  { "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, "allowed_media_types" }, \
75  { "subtitle", "Subtitle", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_SUBTITLE}, 0, 0, DEC, "allowed_media_types" }
76 
77 #define RTSP_REORDERING_OPTS() \
78  { "reorder_queue_size", "set number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }
79 
80 const AVOption ff_rtsp_options[] = {
81  { "initial_pause", "do not start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC },
82  FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
83  { "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, "rtsp_transport" }, \
84  { "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
85  { "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
86  { "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, "rtsp_transport" },
87  { "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, "rtsp_transport" },
88  RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),
89  { "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, "rtsp_flags" },
90  { "prefer_tcp", "try RTP via TCP first, if available", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_PREFER_TCP}, 0, 0, DEC|ENC, "rtsp_flags" },
91  RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
92  { "min_port", "set minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },
93  { "max_port", "set maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },
94  { "timeout", "set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen)", OFFSET(initial_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC },
95  { "stimeout", "set timeout (in microseconds) of socket TCP I/O operations", OFFSET(stimeout), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC },
96  RTSP_REORDERING_OPTS(),
97  { "user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },
98  { NULL },
99 };
100 
101 static const AVOption sdp_options[] = {
102  RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
103  { "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, "rtsp_flags" },
104  { "rtcp_to_source", "send RTCP packets to the source address of received packets", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_RTCP_TO_SOURCE}, 0, 0, DEC, "rtsp_flags" },
105  RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
106  RTSP_REORDERING_OPTS(),
107  { NULL },
108 };
109 
110 static const AVOption rtp_options[] = {
111  RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
112  RTSP_REORDERING_OPTS(),
113  { NULL },
114 };
115 
116 static void get_word_until_chars(char *buf, int buf_size,
117  const char *sep, const char **pp)
118 {
119  const char *p;
120  char *q;
121 
122  p = *pp;
123  p += strspn(p, SPACE_CHARS);
124  q = buf;
125  while (!strchr(sep, *p) && *p != '\0') {
126  if ((q - buf) < buf_size - 1)
127  *q++ = *p;
128  p++;
129  }
130  if (buf_size > 0)
131  *q = '\0';
132  *pp = p;
133 }
134 
135 static void get_word_sep(char *buf, int buf_size, const char *sep,
136  const char **pp)
137 {
138  if (**pp == '/') (*pp)++;
139  get_word_until_chars(buf, buf_size, sep, pp);
140 }
141 
142 static void get_word(char *buf, int buf_size, const char **pp)
143 {
144  get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
145 }
146 
147 /** Parse a string p in the form of Range:npt=xx-xx, and determine the start
148  * and end time.
149  * Used for seeking in the rtp stream.
150  */
151 static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
152 {
153  char buf[256];
154 
155  p += strspn(p, SPACE_CHARS);
156  if (!av_stristart(p, "npt=", &p))
157  return;
158 
159  *start = AV_NOPTS_VALUE;
160  *end = AV_NOPTS_VALUE;
161 
162  get_word_sep(buf, sizeof(buf), "-", &p);
163  av_parse_time(start, buf, 1);
164  if (*p == '-') {
165  p++;
166  get_word_sep(buf, sizeof(buf), "-", &p);
167  av_parse_time(end, buf, 1);
168  }
169 }
170 
171 static int get_sockaddr(const char *buf, struct sockaddr_storage *sock)
172 {
173  struct addrinfo hints = { 0 }, *ai = NULL;
174  hints.ai_flags = AI_NUMERICHOST;
175  if (getaddrinfo(buf, NULL, &hints, &ai))
176  return -1;
177  memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
178  freeaddrinfo(ai);
179  return 0;
180 }
181 
182 #if CONFIG_RTPDEC
183 static void init_rtp_handler(RTPDynamicProtocolHandler *handler,
184  RTSPStream *rtsp_st, AVStream *st)
185 {
186  AVCodecContext *codec = st ? st->codec : NULL;
187  if (!handler)
188  return;
189  if (codec)
190  codec->codec_id = handler->codec_id;
191  rtsp_st->dynamic_handler = handler;
192  if (st)
193  st->need_parsing = handler->need_parsing;
194  if (handler->priv_data_size) {
195  rtsp_st->dynamic_protocol_context = av_mallocz(handler->priv_data_size);
196  if (!rtsp_st->dynamic_protocol_context)
197  rtsp_st->dynamic_handler = NULL;
198  }
199 }
200 
201 static void finalize_rtp_handler_init(AVFormatContext *s, RTSPStream *rtsp_st,
202  AVStream *st)
203 {
204  if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init) {
205  int ret = rtsp_st->dynamic_handler->init(s, st ? st->index : -1,
206  rtsp_st->dynamic_protocol_context);
207  if (ret < 0) {
208  if (rtsp_st->dynamic_protocol_context) {
209  if (rtsp_st->dynamic_handler->close)
210  rtsp_st->dynamic_handler->close(
211  rtsp_st->dynamic_protocol_context);
212  av_free(rtsp_st->dynamic_protocol_context);
213  }
214  rtsp_st->dynamic_protocol_context = NULL;
215  rtsp_st->dynamic_handler = NULL;
216  }
217  }
218 }
219 
220 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
221 static int sdp_parse_rtpmap(AVFormatContext *s,
222  AVStream *st, RTSPStream *rtsp_st,
223  int payload_type, const char *p)
224 {
225  AVCodecContext *codec = st->codec;
226  char buf[256];
227  int i;
228  AVCodec *c;
229  const char *c_name;
230 
231  /* See if we can handle this kind of payload.
232  * The space should normally not be there but some Real streams or
233  * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
234  * have a trailing space. */
235  get_word_sep(buf, sizeof(buf), "/ ", &p);
236  if (payload_type < RTP_PT_PRIVATE) {
237  /* We are in a standard case
238  * (from http://www.iana.org/assignments/rtp-parameters). */
239  codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
240  }
241 
242  if (codec->codec_id == AV_CODEC_ID_NONE) {
243  RTPDynamicProtocolHandler *handler =
244  ff_rtp_handler_find_by_name(buf, codec->codec_type);
245  init_rtp_handler(handler, rtsp_st, st);
246  /* If no dynamic handler was found, check with the list of standard
247  * allocated types, if such a stream for some reason happens to
248  * use a private payload type. This isn't handled in rtpdec.c, since
249  * the format name from the rtpmap line never is passed into rtpdec. */
250  if (!rtsp_st->dynamic_handler)
251  codec->codec_id = ff_rtp_codec_id(buf, codec->codec_type);
252  }
253 
254  c = avcodec_find_decoder(codec->codec_id);
255  if (c && c->name)
256  c_name = c->name;
257  else
258  c_name = "(null)";
259 
260  get_word_sep(buf, sizeof(buf), "/", &p);
261  i = atoi(buf);
262  switch (codec->codec_type) {
263  case AVMEDIA_TYPE_AUDIO:
264  av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
265  codec->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
266  codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
267  if (i > 0) {
268  codec->sample_rate = i;
269  avpriv_set_pts_info(st, 32, 1, codec->sample_rate);
270  get_word_sep(buf, sizeof(buf), "/", &p);
271  i = atoi(buf);
272  if (i > 0)
273  codec->channels = i;
274  }
275  av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
276  codec->sample_rate);
277  av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
278  codec->channels);
279  break;
280  case AVMEDIA_TYPE_VIDEO:
281  av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
282  if (i > 0)
283  avpriv_set_pts_info(st, 32, 1, i);
284  break;
285  default:
286  break;
287  }
288  finalize_rtp_handler_init(s, rtsp_st, st);
289  return 0;
290 }
291 
292 /* parse the attribute line from the fmtp a line of an sdp response. This
293  * is broken out as a function because it is used in rtp_h264.c, which is
294  * forthcoming. */
295 int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
296  char *value, int value_size)
297 {
298  *p += strspn(*p, SPACE_CHARS);
299  if (**p) {
300  get_word_sep(attr, attr_size, "=", p);
301  if (**p == '=')
302  (*p)++;
303  get_word_sep(value, value_size, ";", p);
304  if (**p == ';')
305  (*p)++;
306  return 1;
307  }
308  return 0;
309 }
310 
311 typedef struct SDPParseState {
312  /* SDP only */
313  struct sockaddr_storage default_ip;
314  int default_ttl;
315  int skip_media; ///< set if an unknown m= line occurs
316  int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */
317  struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */
318  int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
319  struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */
320  int seen_rtpmap;
321  int seen_fmtp;
322  char delayed_fmtp[2048];
323 } SDPParseState;
324 
325 static void copy_default_source_addrs(struct RTSPSource **addrs, int count,
326  struct RTSPSource ***dest, int *dest_count)
327 {
328  RTSPSource *rtsp_src, *rtsp_src2;
329  int i;
330  for (i = 0; i < count; i++) {
331  rtsp_src = addrs[i];
332  rtsp_src2 = av_malloc(sizeof(*rtsp_src2));
333  if (!rtsp_src2)
334  continue;
335  memcpy(rtsp_src2, rtsp_src, sizeof(*rtsp_src));
336  dynarray_add(dest, dest_count, rtsp_src2);
337  }
338 }
339 
340 static void parse_fmtp(AVFormatContext *s, RTSPState *rt,
341  int payload_type, const char *line)
342 {
343  int i;
344 
345  for (i = 0; i < rt->nb_rtsp_streams; i++) {
346  RTSPStream *rtsp_st = rt->rtsp_streams[i];
347  if (rtsp_st->sdp_payload_type == payload_type &&
348  rtsp_st->dynamic_handler &&
349  rtsp_st->dynamic_handler->parse_sdp_a_line) {
350  rtsp_st->dynamic_handler->parse_sdp_a_line(s, i,
351  rtsp_st->dynamic_protocol_context, line);
352  }
353  }
354 }
355 
356 static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
357  int letter, const char *buf)
358 {
359  RTSPState *rt = s->priv_data;
360  char buf1[64], st_type[64];
361  const char *p;
362  enum AVMediaType codec_type;
363  int payload_type;
364  AVStream *st;
365  RTSPStream *rtsp_st;
366  RTSPSource *rtsp_src;
367  struct sockaddr_storage sdp_ip;
368  int ttl;
369 
370  av_dlog(s, "sdp: %c='%s'\n", letter, buf);
371 
372  p = buf;
373  if (s1->skip_media && letter != 'm')
374  return;
375  switch (letter) {
376  case 'c':
377  get_word(buf1, sizeof(buf1), &p);
378  if (strcmp(buf1, "IN") != 0)
379  return;
380  get_word(buf1, sizeof(buf1), &p);
381  if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
382  return;
383  get_word_sep(buf1, sizeof(buf1), "/", &p);
384  if (get_sockaddr(buf1, &sdp_ip))
385  return;
386  ttl = 16;
387  if (*p == '/') {
388  p++;
389  get_word_sep(buf1, sizeof(buf1), "/", &p);
390  ttl = atoi(buf1);
391  }
392  if (s->nb_streams == 0) {
393  s1->default_ip = sdp_ip;
394  s1->default_ttl = ttl;
395  } else {
396  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
397  rtsp_st->sdp_ip = sdp_ip;
398  rtsp_st->sdp_ttl = ttl;
399  }
400  break;
401  case 's':
402  av_dict_set(&s->metadata, "title", p, 0);
403  break;
404  case 'i':
405  if (s->nb_streams == 0) {
406  av_dict_set(&s->metadata, "comment", p, 0);
407  break;
408  }
409  break;
410  case 'm':
411  /* new stream */
412  s1->skip_media = 0;
413  s1->seen_fmtp = 0;
414  s1->seen_rtpmap = 0;
415  codec_type = AVMEDIA_TYPE_UNKNOWN;
416  get_word(st_type, sizeof(st_type), &p);
417  if (!strcmp(st_type, "audio")) {
418  codec_type = AVMEDIA_TYPE_AUDIO;
419  } else if (!strcmp(st_type, "video")) {
420  codec_type = AVMEDIA_TYPE_VIDEO;
421  } else if (!strcmp(st_type, "application")) {
422  codec_type = AVMEDIA_TYPE_DATA;
423  } else if (!strcmp(st_type, "text")) {
424  codec_type = AVMEDIA_TYPE_SUBTITLE;
425  }
426  if (codec_type == AVMEDIA_TYPE_UNKNOWN || !(rt->media_type_mask & (1 << codec_type))) {
427  s1->skip_media = 1;
428  return;
429  }
430  rtsp_st = av_mallocz(sizeof(RTSPStream));
431  if (!rtsp_st)
432  return;
433  rtsp_st->stream_index = -1;
434  dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
435 
436  rtsp_st->sdp_ip = s1->default_ip;
437  rtsp_st->sdp_ttl = s1->default_ttl;
438 
439  copy_default_source_addrs(s1->default_include_source_addrs,
440  s1->nb_default_include_source_addrs,
441  &rtsp_st->include_source_addrs,
442  &rtsp_st->nb_include_source_addrs);
443  copy_default_source_addrs(s1->default_exclude_source_addrs,
444  s1->nb_default_exclude_source_addrs,
445  &rtsp_st->exclude_source_addrs,
446  &rtsp_st->nb_exclude_source_addrs);
447 
448  get_word(buf1, sizeof(buf1), &p); /* port */
449  rtsp_st->sdp_port = atoi(buf1);
450 
451  get_word(buf1, sizeof(buf1), &p); /* protocol */
452  if (!strcmp(buf1, "udp"))
453  rt->transport = RTSP_TRANSPORT_RAW;
454  else if (strstr(buf1, "/AVPF") || strstr(buf1, "/SAVPF"))
455  rtsp_st->feedback = 1;
456 
457  /* XXX: handle list of formats */
458  get_word(buf1, sizeof(buf1), &p); /* format list */
459  rtsp_st->sdp_payload_type = atoi(buf1);
460 
461  if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
462  /* no corresponding stream */
463  if (rt->transport == RTSP_TRANSPORT_RAW) {
464  if (CONFIG_RTPDEC && !rt->ts)
465  rt->ts = avpriv_mpegts_parse_open(s);
466  } else {
467  RTPDynamicProtocolHandler *handler;
468  handler = ff_rtp_handler_find_by_id(
469  rtsp_st->sdp_payload_type, AVMEDIA_TYPE_DATA);
470  init_rtp_handler(handler, rtsp_st, NULL);
471  finalize_rtp_handler_init(s, rtsp_st, NULL);
472  }
473  } else if (rt->server_type == RTSP_SERVER_WMS &&
474  codec_type == AVMEDIA_TYPE_DATA) {
475  /* RTX stream, a stream that carries all the other actual
476  * audio/video streams. Don't expose this to the callers. */
477  } else {
478  st = avformat_new_stream(s, NULL);
479  if (!st)
480  return;
481  st->id = rt->nb_rtsp_streams - 1;
482  rtsp_st->stream_index = st->index;
483  st->codec->codec_type = codec_type;
484  if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
485  RTPDynamicProtocolHandler *handler;
486  /* if standard payload type, we can find the codec right now */
487  ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
488  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
489  st->codec->sample_rate > 0)
490  avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
491  /* Even static payload types may need a custom depacketizer */
492  handler = ff_rtp_handler_find_by_id(
493  rtsp_st->sdp_payload_type, st->codec->codec_type);
494  init_rtp_handler(handler, rtsp_st, st);
495  finalize_rtp_handler_init(s, rtsp_st, st);
496  }
497  if (rt->default_lang[0])
498  av_dict_set(&st->metadata, "language", rt->default_lang, 0);
499  }
500  /* put a default control url */
501  av_strlcpy(rtsp_st->control_url, rt->control_uri,
502  sizeof(rtsp_st->control_url));
503  break;
504  case 'a':
505  if (av_strstart(p, "control:", &p)) {
506  if (s->nb_streams == 0) {
507  if (!strncmp(p, "rtsp://", 7))
508  av_strlcpy(rt->control_uri, p,
509  sizeof(rt->control_uri));
510  } else {
511  char proto[32];
512  /* get the control url */
513  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
514 
515  /* XXX: may need to add full url resolution */
516  av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
517  NULL, NULL, 0, p);
518  if (proto[0] == '\0') {
519  /* relative control URL */
520  if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
521  av_strlcat(rtsp_st->control_url, "/",
522  sizeof(rtsp_st->control_url));
523  av_strlcat(rtsp_st->control_url, p,
524  sizeof(rtsp_st->control_url));
525  } else
526  av_strlcpy(rtsp_st->control_url, p,
527  sizeof(rtsp_st->control_url));
528  }
529  } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
530  /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
531  get_word(buf1, sizeof(buf1), &p);
532  payload_type = atoi(buf1);
533  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
534  if (rtsp_st->stream_index >= 0) {
535  st = s->streams[rtsp_st->stream_index];
536  sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
537  }
538  s1->seen_rtpmap = 1;
539  if (s1->seen_fmtp) {
540  parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);
541  }
542  } else if (av_strstart(p, "fmtp:", &p) ||
543  av_strstart(p, "framesize:", &p)) {
544  // let dynamic protocol handlers have a stab at the line.
545  get_word(buf1, sizeof(buf1), &p);
546  payload_type = atoi(buf1);
547  if (s1->seen_rtpmap) {
548  parse_fmtp(s, rt, payload_type, buf);
549  } else {
550  s1->seen_fmtp = 1;
551  av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp));
552  }
553  } else if (av_strstart(p, "range:", &p)) {
554  int64_t start, end;
555 
556  // this is so that seeking on a streamed file can work.
557  rtsp_parse_range_npt(p, &start, &end);
558  s->start_time = start;
559  /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
560  s->duration = (end == AV_NOPTS_VALUE) ?
561  AV_NOPTS_VALUE : end - start;
562  } else if (av_strstart(p, "lang:", &p)) {
563  if (s->nb_streams > 0) {
564  get_word(buf1, sizeof(buf1), &p);
565  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
566  if (rtsp_st->stream_index >= 0) {
567  st = s->streams[rtsp_st->stream_index];
568  av_dict_set(&st->metadata, "language", buf1, 0);
569  }
570  } else
571  get_word(rt->default_lang, sizeof(rt->default_lang), &p);
572  } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
573  if (atoi(p) == 1)
574  rt->transport = RTSP_TRANSPORT_RDT;
575  } else if (av_strstart(p, "SampleRate:integer;", &p) &&
576  s->nb_streams > 0) {
577  st = s->streams[s->nb_streams - 1];
578  st->codec->sample_rate = atoi(p);
579  } else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {
580  // RFC 4568
581  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
582  get_word(buf1, sizeof(buf1), &p); // ignore tag
583  get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);
584  p += strspn(p, SPACE_CHARS);
585  if (av_strstart(p, "inline:", &p))
586  get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);
587  } else if (av_strstart(p, "source-filter:", &p)) {
588  int exclude = 0;
589  get_word(buf1, sizeof(buf1), &p);
590  if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))
591  return;
592  exclude = !strcmp(buf1, "excl");
593 
594  get_word(buf1, sizeof(buf1), &p);
595  if (strcmp(buf1, "IN") != 0)
596  return;
597  get_word(buf1, sizeof(buf1), &p);
598  if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))
599  return;
600  // not checking that the destination address actually matches or is wildcard
601  get_word(buf1, sizeof(buf1), &p);
602 
603  while (*p != '\0') {
604  rtsp_src = av_mallocz(sizeof(*rtsp_src));
605  if (!rtsp_src)
606  return;
607  get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);
608  if (exclude) {
609  if (s->nb_streams == 0) {
610  dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
611  } else {
612  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
613  dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);
614  }
615  } else {
616  if (s->nb_streams == 0) {
617  dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
618  } else {
619  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
620  dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);
621  }
622  }
623  }
624  } else {
625  if (rt->server_type == RTSP_SERVER_WMS)
626  ff_wms_parse_sdp_a_line(s, p);
627  if (s->nb_streams > 0) {
628  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
629 
630  if (rt->server_type == RTSP_SERVER_REAL)
631  ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p);
632 
633  if (rtsp_st->dynamic_handler &&
634  rtsp_st->dynamic_handler->parse_sdp_a_line)
635  rtsp_st->dynamic_handler->parse_sdp_a_line(s,
636  rtsp_st->stream_index,
637  rtsp_st->dynamic_protocol_context, buf);
638  }
639  }
640  break;
641  }
642 }
643 
644 int ff_sdp_parse(AVFormatContext *s, const char *content)
645 {
646  RTSPState *rt = s->priv_data;
647  const char *p;
648  int letter, i;
649  /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
650  * contain long SDP lines containing complete ASF Headers (several
651  * kB) or arrays of MDPR (RM stream descriptor) headers plus
652  * "rulebooks" describing their properties. Therefore, the SDP line
653  * buffer is large.
654  *
655  * The Vorbis FMTP line can be up to 16KB - see xiph_parse_sdp_line
656  * in rtpdec_xiph.c. */
657  char buf[16384], *q;
658  SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
659 
660  p = content;
661  for (;;) {
662  p += strspn(p, SPACE_CHARS);
663  letter = *p;
664  if (letter == '\0')
665  break;
666  p++;
667  if (*p != '=')
668  goto next_line;
669  p++;
670  /* get the content */
671  q = buf;
672  while (*p != '\n' && *p != '\r' && *p != '\0') {
673  if ((q - buf) < sizeof(buf) - 1)
674  *q++ = *p;
675  p++;
676  }
677  *q = '\0';
678  sdp_parse_line(s, s1, letter, buf);
679  next_line:
680  while (*p != '\n' && *p != '\0')
681  p++;
682  if (*p == '\n')
683  p++;
684  }
685 
686  for (i = 0; i < s1->nb_default_include_source_addrs; i++)
687  av_freep(&s1->default_include_source_addrs[i]);
688  av_freep(&s1->default_include_source_addrs);
689  for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
690  av_freep(&s1->default_exclude_source_addrs[i]);
691  av_freep(&s1->default_exclude_source_addrs);
692 
693  rt->p = av_malloc_array(rt->nb_rtsp_streams + 1, sizeof(struct pollfd) * 2);
694  if (!rt->p) return AVERROR(ENOMEM);
695  return 0;
696 }
697 #endif /* CONFIG_RTPDEC */
698 
699 void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
700 {
701  RTSPState *rt = s->priv_data;
702  int i;
703 
704  for (i = 0; i < rt->nb_rtsp_streams; i++) {
705  RTSPStream *rtsp_st = rt->rtsp_streams[i];
706  if (!rtsp_st)
707  continue;
708  if (rtsp_st->transport_priv) {
709  if (s->oformat) {
710  AVFormatContext *rtpctx = rtsp_st->transport_priv;
711  av_write_trailer(rtpctx);
712  if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
713  if (CONFIG_RTSP_MUXER && rtpctx->pb && send_packets)
714  ff_rtsp_tcp_write_packet(s, rtsp_st);
715  ffio_free_dyn_buf(&rtpctx->pb);
716  } else {
717  avio_closep(&rtpctx->pb);
718  }
719  avformat_free_context(rtpctx);
720  } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
721  ff_rdt_parse_close(rtsp_st->transport_priv);
722  else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)
723  ff_rtp_parse_close(rtsp_st->transport_priv);
724  }
725  rtsp_st->transport_priv = NULL;
726  if (rtsp_st->rtp_handle)
727  ffurl_close(rtsp_st->rtp_handle);
728  rtsp_st->rtp_handle = NULL;
729  }
730 }
731 
732 /* close and free RTSP streams */
733 void ff_rtsp_close_streams(AVFormatContext *s)
734 {
735  RTSPState *rt = s->priv_data;
736  int i, j;
737  RTSPStream *rtsp_st;
738 
739  ff_rtsp_undo_setup(s, 0);
740  for (i = 0; i < rt->nb_rtsp_streams; i++) {
741  rtsp_st = rt->rtsp_streams[i];
742  if (rtsp_st) {
743  if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) {
744  if (rtsp_st->dynamic_handler->close)
745  rtsp_st->dynamic_handler->close(
746  rtsp_st->dynamic_protocol_context);
747  av_free(rtsp_st->dynamic_protocol_context);
748  }
749  for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)
750  av_freep(&rtsp_st->include_source_addrs[j]);
751  av_freep(&rtsp_st->include_source_addrs);
752  for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)
753  av_freep(&rtsp_st->exclude_source_addrs[j]);
754  av_freep(&rtsp_st->exclude_source_addrs);
755 
756  av_freep(&rtsp_st);
757  }
758  }
759  av_freep(&rt->rtsp_streams);
760  if (rt->asf_ctx) {
761  avformat_close_input(&rt->asf_ctx);
762  }
763  if (CONFIG_RTPDEC && rt->ts)
764  avpriv_mpegts_parse_close(rt->ts);
765  av_freep(&rt->p);
766  av_freep(&rt->recvbuf);
767 }
768 
769 int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
770 {
771  RTSPState *rt = s->priv_data;
772  AVStream *st = NULL;
773  int reordering_queue_size = rt->reordering_queue_size;
774  if (reordering_queue_size < 0) {
775  if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
776  reordering_queue_size = 0;
777  else
778  reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
779  }
780 
781  /* open the RTP context */
782  if (rtsp_st->stream_index >= 0)
783  st = s->streams[rtsp_st->stream_index];
784  if (!st)
785  s->ctx_flags |= AVFMTCTX_NOHEADER;
786 
787  if (CONFIG_RTSP_MUXER && s->oformat) {
788  int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,
789  s, st, rtsp_st->rtp_handle,
790  RTSP_TCP_MAX_PACKET_SIZE,
791  rtsp_st->stream_index);
792  /* Ownership of rtp_handle is passed to the rtp mux context */
793  rtsp_st->rtp_handle = NULL;
794  if (ret < 0)
795  return ret;
796  st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
797  } else if (rt->transport == RTSP_TRANSPORT_RAW) {
798  return 0; // Don't need to open any parser here
799  } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
800  rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
801  rtsp_st->dynamic_protocol_context,
802  rtsp_st->dynamic_handler);
803  else if (CONFIG_RTPDEC)
804  rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
805  rtsp_st->sdp_payload_type,
806  reordering_queue_size);
807 
808  if (!rtsp_st->transport_priv) {
809  return AVERROR(ENOMEM);
810  } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) {
811  if (rtsp_st->dynamic_handler) {
812  ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
813  rtsp_st->dynamic_protocol_context,
814  rtsp_st->dynamic_handler);
815  }
816  if (rtsp_st->crypto_suite[0])
817  ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
818  rtsp_st->crypto_suite,
819  rtsp_st->crypto_params);
820  }
821 
822  return 0;
823 }
824 
825 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
826 static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
827 {
828  const char *q;
829  char *p;
830  int v;
831 
832  q = *pp;
833  q += strspn(q, SPACE_CHARS);
834  v = strtol(q, &p, 10);
835  if (*p == '-') {
836  p++;
837  *min_ptr = v;
838  v = strtol(p, &p, 10);
839  *max_ptr = v;
840  } else {
841  *min_ptr = v;
842  *max_ptr = v;
843  }
844  *pp = p;
845 }
846 
847 /* XXX: only one transport specification is parsed */
848 static void rtsp_parse_transport(RTSPMessageHeader *reply, const char *p)
849 {
850  char transport_protocol[16];
851  char profile[16];
852  char lower_transport[16];
853  char parameter[16];
854  RTSPTransportField *th;
855  char buf[256];
856 
857  reply->nb_transports = 0;
858 
859  for (;;) {
860  p += strspn(p, SPACE_CHARS);
861  if (*p == '\0')
862  break;
863 
864  th = &reply->transports[reply->nb_transports];
865 
866  get_word_sep(transport_protocol, sizeof(transport_protocol),
867  "/", &p);
868  if (!av_strcasecmp (transport_protocol, "rtp")) {
869  get_word_sep(profile, sizeof(profile), "/;,", &p);
870  lower_transport[0] = '\0';
871  /* rtp/avp/<protocol> */
872  if (*p == '/') {
873  get_word_sep(lower_transport, sizeof(lower_transport),
874  ";,", &p);
875  }
876  th->transport = RTSP_TRANSPORT_RTP;
877  } else if (!av_strcasecmp (transport_protocol, "x-pn-tng") ||
878  !av_strcasecmp (transport_protocol, "x-real-rdt")) {
879  /* x-pn-tng/<protocol> */
880  get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
881  profile[0] = '\0';
882  th->transport = RTSP_TRANSPORT_RDT;
883  } else if (!av_strcasecmp(transport_protocol, "raw")) {
884  get_word_sep(profile, sizeof(profile), "/;,", &p);
885  lower_transport[0] = '\0';
886  /* raw/raw/<protocol> */
887  if (*p == '/') {
888  get_word_sep(lower_transport, sizeof(lower_transport),
889  ";,", &p);
890  }
891  th->transport = RTSP_TRANSPORT_RAW;
892  }
893  if (!av_strcasecmp(lower_transport, "TCP"))
894  th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
895  else
896  th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
897 
898  if (*p == ';')
899  p++;
900  /* get each parameter */
901  while (*p != '\0' && *p != ',') {
902  get_word_sep(parameter, sizeof(parameter), "=;,", &p);
903  if (!strcmp(parameter, "port")) {
904  if (*p == '=') {
905  p++;
906  rtsp_parse_range(&th->port_min, &th->port_max, &p);
907  }
908  } else if (!strcmp(parameter, "client_port")) {
909  if (*p == '=') {
910  p++;
911  rtsp_parse_range(&th->client_port_min,
912  &th->client_port_max, &p);
913  }
914  } else if (!strcmp(parameter, "server_port")) {
915  if (*p == '=') {
916  p++;
917  rtsp_parse_range(&th->server_port_min,
918  &th->server_port_max, &p);
919  }
920  } else if (!strcmp(parameter, "interleaved")) {
921  if (*p == '=') {
922  p++;
923  rtsp_parse_range(&th->interleaved_min,
924  &th->interleaved_max, &p);
925  }
926  } else if (!strcmp(parameter, "multicast")) {
927  if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
928  th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
929  } else if (!strcmp(parameter, "ttl")) {
930  if (*p == '=') {
931  char *end;
932  p++;
933  th->ttl = strtol(p, &end, 10);
934  p = end;
935  }
936  } else if (!strcmp(parameter, "destination")) {
937  if (*p == '=') {
938  p++;
939  get_word_sep(buf, sizeof(buf), ";,", &p);
940  get_sockaddr(buf, &th->destination);
941  }
942  } else if (!strcmp(parameter, "source")) {
943  if (*p == '=') {
944  p++;
945  get_word_sep(buf, sizeof(buf), ";,", &p);
946  av_strlcpy(th->source, buf, sizeof(th->source));
947  }
948  } else if (!strcmp(parameter, "mode")) {
949  if (*p == '=') {
950  p++;
951  get_word_sep(buf, sizeof(buf), ";, ", &p);
952  if (!strcmp(buf, "record") ||
953  !strcmp(buf, "receive"))
954  th->mode_record = 1;
955  }
956  }
957 
958  while (*p != ';' && *p != '\0' && *p != ',')
959  p++;
960  if (*p == ';')
961  p++;
962  }
963  if (*p == ',')
964  p++;
965 
966  reply->nb_transports++;
967  }
968 }
969 
970 static void handle_rtp_info(RTSPState *rt, const char *url,
971  uint32_t seq, uint32_t rtptime)
972 {
973  int i;
974  if (!rtptime || !url[0])
975  return;
976  if (rt->transport != RTSP_TRANSPORT_RTP)
977  return;
978  for (i = 0; i < rt->nb_rtsp_streams; i++) {
979  RTSPStream *rtsp_st = rt->rtsp_streams[i];
980  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
981  if (!rtpctx)
982  continue;
983  if (!strcmp(rtsp_st->control_url, url)) {
984  rtpctx->base_timestamp = rtptime;
985  break;
986  }
987  }
988 }
989 
990 static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
991 {
992  int read = 0;
993  char key[20], value[1024], url[1024] = "";
994  uint32_t seq = 0, rtptime = 0;
995 
996  for (;;) {
997  p += strspn(p, SPACE_CHARS);
998  if (!*p)
999  break;
1000  get_word_sep(key, sizeof(key), "=", &p);
1001  if (*p != '=')
1002  break;
1003  p++;
1004  get_word_sep(value, sizeof(value), ";, ", &p);
1005  read++;
1006  if (!strcmp(key, "url"))
1007  av_strlcpy(url, value, sizeof(url));
1008  else if (!strcmp(key, "seq"))
1009  seq = strtoul(value, NULL, 10);
1010  else if (!strcmp(key, "rtptime"))
1011  rtptime = strtoul(value, NULL, 10);
1012  if (*p == ',') {
1013  handle_rtp_info(rt, url, seq, rtptime);
1014  url[0] = '\0';
1015  seq = rtptime = 0;
1016  read = 0;
1017  }
1018  if (*p)
1019  p++;
1020  }
1021  if (read > 0)
1022  handle_rtp_info(rt, url, seq, rtptime);
1023 }
1024 
1025 void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
1026  RTSPState *rt, const char *method)
1027 {
1028  const char *p;
1029 
1030  /* NOTE: we do case independent match for broken servers */
1031  p = buf;
1032  if (av_stristart(p, "Session:", &p)) {
1033  int t;
1034  get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
1035  if (av_stristart(p, ";timeout=", &p) &&
1036  (t = strtol(p, NULL, 10)) > 0) {
1037  reply->timeout = t;
1038  }
1039  } else if (av_stristart(p, "Content-Length:", &p)) {
1040  reply->content_length = strtol(p, NULL, 10);
1041  } else if (av_stristart(p, "Transport:", &p)) {
1042  rtsp_parse_transport(reply, p);
1043  } else if (av_stristart(p, "CSeq:", &p)) {
1044  reply->seq = strtol(p, NULL, 10);
1045  } else if (av_stristart(p, "Range:", &p)) {
1046  rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
1047  } else if (av_stristart(p, "RealChallenge1:", &p)) {
1048  p += strspn(p, SPACE_CHARS);
1049  av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
1050  } else if (av_stristart(p, "Server:", &p)) {
1051  p += strspn(p, SPACE_CHARS);
1052  av_strlcpy(reply->server, p, sizeof(reply->server));
1053  } else if (av_stristart(p, "Notice:", &p) ||
1054  av_stristart(p, "X-Notice:", &p)) {
1055  reply->notice = strtol(p, NULL, 10);
1056  } else if (av_stristart(p, "Location:", &p)) {
1057  p += strspn(p, SPACE_CHARS);
1058  av_strlcpy(reply->location, p , sizeof(reply->location));
1059  } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
1060  p += strspn(p, SPACE_CHARS);
1061  ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
1062  } else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
1063  p += strspn(p, SPACE_CHARS);
1064  ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
1065  } else if (av_stristart(p, "Content-Base:", &p) && rt) {
1066  p += strspn(p, SPACE_CHARS);
1067  if (method && !strcmp(method, "DESCRIBE"))
1068  av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
1069  } else if (av_stristart(p, "RTP-Info:", &p) && rt) {
1070  p += strspn(p, SPACE_CHARS);
1071  if (method && !strcmp(method, "PLAY"))
1072  rtsp_parse_rtp_info(rt, p);
1073  } else if (av_stristart(p, "Public:", &p) && rt) {
1074  if (strstr(p, "GET_PARAMETER") &&
1075  method && !strcmp(method, "OPTIONS"))
1076  rt->get_parameter_supported = 1;
1077  } else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
1078  p += strspn(p, SPACE_CHARS);
1079  rt->accept_dynamic_rate = atoi(p);
1080  } else if (av_stristart(p, "Content-Type:", &p)) {
1081  p += strspn(p, SPACE_CHARS);
1082  av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
1083  }
1084 }
1085 
1086 /* skip a RTP/TCP interleaved packet */
1087 void ff_rtsp_skip_packet(AVFormatContext *s)
1088 {
1089  RTSPState *rt = s->priv_data;
1090  int ret, len, len1;
1091  uint8_t buf[1024];
1092 
1093  ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
1094  if (ret != 3)
1095  return;
1096  len = AV_RB16(buf + 1);
1097 
1098  av_dlog(s, "skipping RTP packet len=%d\n", len);
1099 
1100  /* skip payload */
1101  while (len > 0) {
1102  len1 = len;
1103  if (len1 > sizeof(buf))
1104  len1 = sizeof(buf);
1105  ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);
1106  if (ret != len1)
1107  return;
1108  len -= len1;
1109  }
1110 }
1111 
1112 int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
1113  unsigned char **content_ptr,
1114  int return_on_interleaved_data, const char *method)
1115 {
1116  RTSPState *rt = s->priv_data;
1117  char buf[4096], buf1[1024], *q;
1118  unsigned char ch;
1119  const char *p;
1120  int ret, content_length, line_count = 0, request = 0;
1121  unsigned char *content = NULL;
1122 
1123 start:
1124  line_count = 0;
1125  request = 0;
1126  content = NULL;
1127  memset(reply, 0, sizeof(*reply));
1128 
1129  /* parse reply (XXX: use buffers) */
1130  rt->last_reply[0] = '\0';
1131  for (;;) {
1132  q = buf;
1133  for (;;) {
1134  ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
1135  av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
1136  if (ret != 1)
1137  return AVERROR_EOF;
1138  if (ch == '\n')
1139  break;
1140  if (ch == '$') {
1141  /* XXX: only parse it if first char on line ? */
1142  if (return_on_interleaved_data) {
1143  return 1;
1144  } else
1145  ff_rtsp_skip_packet(s);
1146  } else if (ch != '\r') {
1147  if ((q - buf) < sizeof(buf) - 1)
1148  *q++ = ch;
1149  }
1150  }
1151  *q = '\0';
1152 
1153  av_dlog(s, "line='%s'\n", buf);
1154 
1155  /* test if last line */
1156  if (buf[0] == '\0')
1157  break;
1158  p = buf;
1159  if (line_count == 0) {
1160  /* get reply code */
1161  get_word(buf1, sizeof(buf1), &p);
1162  if (!strncmp(buf1, "RTSP/", 5)) {
1163  get_word(buf1, sizeof(buf1), &p);
1164  reply->status_code = atoi(buf1);
1165  av_strlcpy(reply->reason, p, sizeof(reply->reason));
1166  } else {
1167  av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
1168  get_word(buf1, sizeof(buf1), &p); // object
1169  request = 1;
1170  }
1171  } else {
1172  ff_rtsp_parse_line(reply, p, rt, method);
1173  av_strlcat(rt->last_reply, p, sizeof(rt->last_reply));
1174  av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
1175  }
1176  line_count++;
1177  }
1178 
1179  if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
1180  av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
1181 
1182  content_length = reply->content_length;
1183  if (content_length > 0) {
1184  /* leave some room for a trailing '\0' (useful for simple parsing) */
1185  content = av_malloc(content_length + 1);
1186  if (!content)
1187  return AVERROR(ENOMEM);
1188  ffurl_read_complete(rt->rtsp_hd, content, content_length);
1189  content[content_length] = '\0';
1190  }
1191  if (content_ptr)
1192  *content_ptr = content;
1193  else
1194  av_freep(&content);
1195 
1196  if (request) {
1197  char buf[1024];
1198  char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1199  const char* ptr = buf;
1200 
1201  if (!strcmp(reply->reason, "OPTIONS")) {
1202  snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
1203  if (reply->seq)
1204  av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
1205  if (reply->session_id[0])
1206  av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
1207  reply->session_id);
1208  } else {
1209  snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
1210  }
1211  av_strlcat(buf, "\r\n", sizeof(buf));
1212 
1213  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1214  av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1215  ptr = base64buf;
1216  }
1217  ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
1218 
1219  rt->last_cmd_time = av_gettime_relative();
1220  /* Even if the request from the server had data, it is not the data
1221  * that the caller wants or expects. The memory could also be leaked
1222  * if the actual following reply has content data. */
1223  if (content_ptr)
1224  av_freep(content_ptr);
1225  /* If method is set, this is called from ff_rtsp_send_cmd,
1226  * where a reply to exactly this request is awaited. For
1227  * callers from within packet receiving, we just want to
1228  * return to the caller and go back to receiving packets. */
1229  if (method)
1230  goto start;
1231  return 0;
1232  }
1233 
1234  if (rt->seq != reply->seq) {
1235  av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
1236  rt->seq, reply->seq);
1237  }
1238 
1239  /* EOS */
1240  if (reply->notice == 2101 /* End-of-Stream Reached */ ||
1241  reply->notice == 2104 /* Start-of-Stream Reached */ ||
1242  reply->notice == 2306 /* Continuous Feed Terminated */) {
1243  rt->state = RTSP_STATE_IDLE;
1244  } else if (reply->notice >= 4400 && reply->notice < 5500) {
1245  return AVERROR(EIO); /* data or server error */
1246  } else if (reply->notice == 2401 /* Ticket Expired */ ||
1247  (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
1248  return AVERROR(EPERM);
1249 
1250  return 0;
1251 }
1252 
1253 /**
1254  * Send a command to the RTSP server without waiting for the reply.
1255  *
1256  * @param s RTSP (de)muxer context
1257  * @param method the method for the request
1258  * @param url the target url for the request
1259  * @param headers extra header lines to include in the request
1260  * @param send_content if non-null, the data to send as request body content
1261  * @param send_content_length the length of the send_content data, or 0 if
1262  * send_content is null
1263  *
1264  * @return zero if success, nonzero otherwise
1265  */
1266 static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
1267  const char *method, const char *url,
1268  const char *headers,
1269  const unsigned char *send_content,
1270  int send_content_length)
1271 {
1272  RTSPState *rt = s->priv_data;
1273  char buf[4096], *out_buf;
1274  char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1275 
1276  /* Add in RTSP headers */
1277  out_buf = buf;
1278  rt->seq++;
1279  snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
1280  if (headers)
1281  av_strlcat(buf, headers, sizeof(buf));
1282  av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
1283  av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent);
1284  if (rt->session_id[0] != '\0' && (!headers ||
1285  !strstr(headers, "\nIf-Match:"))) {
1286  av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
1287  }
1288  if (rt->auth[0]) {
1289  char *str = ff_http_auth_create_response(&rt->auth_state,
1290  rt->auth, url, method);
1291  if (str)
1292  av_strlcat(buf, str, sizeof(buf));
1293  av_free(str);
1294  }
1295  if (send_content_length > 0 && send_content)
1296  av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1297  av_strlcat(buf, "\r\n", sizeof(buf));
1298 
1299  /* base64 encode rtsp if tunneling */
1300  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1301  av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1302  out_buf = base64buf;
1303  }
1304 
1305  av_dlog(s, "Sending:\n%s--\n", buf);
1306 
1307  ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
1308  if (send_content_length > 0 && send_content) {
1309  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1310  av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
1311  "with content data not supported\n");
1312  return AVERROR_PATCHWELCOME;
1313  }
1314  ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
1315  }
1316  rt->last_cmd_time = av_gettime_relative();
1317 
1318  return 0;
1319 }
1320 
1321 int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1322  const char *url, const char *headers)
1323 {
1324  return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1325 }
1326 
1327 int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1328  const char *headers, RTSPMessageHeader *reply,
1329  unsigned char **content_ptr)
1330 {
1331  return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1332  content_ptr, NULL, 0);
1333 }
1334 
1335 int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1336  const char *method, const char *url,
1337  const char *header,
1338  RTSPMessageHeader *reply,
1339  unsigned char **content_ptr,
1340  const unsigned char *send_content,
1341  int send_content_length)
1342 {
1343  RTSPState *rt = s->priv_data;
1344  HTTPAuthType cur_auth_type;
1345  int ret, attempts = 0;
1346 
1347 retry:
1348  cur_auth_type = rt->auth_state.auth_type;
1349  if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1350  send_content,
1351  send_content_length)))
1352  return ret;
1353 
1354  if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1355  return ret;
1356  attempts++;
1357 
1358  if (reply->status_code == 401 &&
1359  (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
1360  rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
1361  goto retry;
1362 
1363  if (reply->status_code > 400){
1364  av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
1365  method,
1366  reply->status_code,
1367  reply->reason);
1368  av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1369  }
1370 
1371  return 0;
1372 }
1373 
1374 int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1375  int lower_transport, const char *real_challenge)
1376 {
1377  RTSPState *rt = s->priv_data;
1378  int rtx = 0, j, i, err, interleave = 0, port_off;
1379  RTSPStream *rtsp_st;
1380  RTSPMessageHeader reply1, *reply = &reply1;
1381  char cmd[2048];
1382  const char *trans_pref;
1383 
1384  if (rt->transport == RTSP_TRANSPORT_RDT)
1385  trans_pref = "x-pn-tng";
1386  else if (rt->transport == RTSP_TRANSPORT_RAW)
1387  trans_pref = "RAW/RAW";
1388  else
1389  trans_pref = "RTP/AVP";
1390 
1391  /* default timeout: 1 minute */
1392  rt->timeout = 60;
1393 
1394  /* Choose a random starting offset within the first half of the
1395  * port range, to allow for a number of ports to try even if the offset
1396  * happens to be at the end of the random range. */
1397  port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
1398  /* even random offset */
1399  port_off -= port_off & 0x01;
1400 
1401  for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1402  char transport[2048];
1403 
1404  /*
1405  * WMS serves all UDP data over a single connection, the RTX, which
1406  * isn't necessarily the first in the SDP but has to be the first
1407  * to be set up, else the second/third SETUP will fail with a 461.
1408  */
1409  if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1410  rt->server_type == RTSP_SERVER_WMS) {
1411  if (i == 0) {
1412  /* rtx first */
1413  for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1414  int len = strlen(rt->rtsp_streams[rtx]->control_url);
1415  if (len >= 4 &&
1416  !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1417  "/rtx"))
1418  break;
1419  }
1420  if (rtx == rt->nb_rtsp_streams)
1421  return -1; /* no RTX found */
1422  rtsp_st = rt->rtsp_streams[rtx];
1423  } else
1424  rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1425  } else
1426  rtsp_st = rt->rtsp_streams[i];
1427 
1428  /* RTP/UDP */
1429  if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1430  char buf[256];
1431 
1432  if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1433  port = reply->transports[0].client_port_min;
1434  goto have_port;
1435  }
1436 
1437  /* first try in specified port range */
1438  while (j <= rt->rtp_port_max) {
1439  ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1440  "?localport=%d", j);
1441  /* we will use two ports per rtp stream (rtp and rtcp) */
1442  j += 2;
1443  if (!ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
1444  &s->interrupt_callback, NULL))
1445  goto rtp_opened;
1446  }
1447  av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1448  err = AVERROR(EIO);
1449  goto fail;
1450 
1451  rtp_opened:
1452  port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1453  have_port:
1454  snprintf(transport, sizeof(transport) - 1,
1455  "%s/UDP;", trans_pref);
1456  if (rt->server_type != RTSP_SERVER_REAL)
1457  av_strlcat(transport, "unicast;", sizeof(transport));
1458  av_strlcatf(transport, sizeof(transport),
1459  "client_port=%d", port);
1460  if (rt->transport == RTSP_TRANSPORT_RTP &&
1461  !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1462  av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1463  }
1464 
1465  /* RTP/TCP */
1466  else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1467  /* For WMS streams, the application streams are only used for
1468  * UDP. When trying to set it up for TCP streams, the server
1469  * will return an error. Therefore, we skip those streams. */
1470  if (rt->server_type == RTSP_SERVER_WMS &&
1471  (rtsp_st->stream_index < 0 ||
1472  s->streams[rtsp_st->stream_index]->codec->codec_type ==
1473  AVMEDIA_TYPE_DATA))
1474  continue;
1475  snprintf(transport, sizeof(transport) - 1,
1476  "%s/TCP;", trans_pref);
1477  if (rt->transport != RTSP_TRANSPORT_RDT)
1478  av_strlcat(transport, "unicast;", sizeof(transport));
1479  av_strlcatf(transport, sizeof(transport),
1480  "interleaved=%d-%d",
1481  interleave, interleave + 1);
1482  interleave += 2;
1483  }
1484 
1485  else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1486  snprintf(transport, sizeof(transport) - 1,
1487  "%s/UDP;multicast", trans_pref);
1488  }
1489  if (s->oformat) {
1490  av_strlcat(transport, ";mode=record", sizeof(transport));
1491  } else if (rt->server_type == RTSP_SERVER_REAL ||
1492  rt->server_type == RTSP_SERVER_WMS)
1493  av_strlcat(transport, ";mode=play", sizeof(transport));
1494  snprintf(cmd, sizeof(cmd),
1495  "Transport: %s\r\n",
1496  transport);
1497  if (rt->accept_dynamic_rate)
1498  av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
1499  if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1500  char real_res[41], real_csum[9];
1501  ff_rdt_calc_response_and_checksum(real_res, real_csum,
1502  real_challenge);
1503  av_strlcatf(cmd, sizeof(cmd),
1504  "If-Match: %s\r\n"
1505  "RealChallenge2: %s, sd=%s\r\n",
1506  rt->session_id, real_res, real_csum);
1507  }
1508  ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1509  if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1510  err = 1;
1511  goto fail;
1512  } else if (reply->status_code != RTSP_STATUS_OK ||
1513  reply->nb_transports != 1) {
1514  err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1515  goto fail;
1516  }
1517 
1518  /* XXX: same protocol for all streams is required */
1519  if (i > 0) {
1520  if (reply->transports[0].lower_transport != rt->lower_transport ||
1521  reply->transports[0].transport != rt->transport) {
1522  err = AVERROR_INVALIDDATA;
1523  goto fail;
1524  }
1525  } else {
1526  rt->lower_transport = reply->transports[0].lower_transport;
1527  rt->transport = reply->transports[0].transport;
1528  }
1529 
1530  /* Fail if the server responded with another lower transport mode
1531  * than what we requested. */
1532  if (reply->transports[0].lower_transport != lower_transport) {
1533  av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1534  err = AVERROR_INVALIDDATA;
1535  goto fail;
1536  }
1537 
1538  switch(reply->transports[0].lower_transport) {
1539  case RTSP_LOWER_TRANSPORT_TCP:
1540  rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1541  rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1542  break;
1543 
1544  case RTSP_LOWER_TRANSPORT_UDP: {
1545  char url[1024], options[30] = "";
1546  const char *peer = host;
1547 
1548  if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
1549  av_strlcpy(options, "?connect=1", sizeof(options));
1550  /* Use source address if specified */
1551  if (reply->transports[0].source[0])
1552  peer = reply->transports[0].source;
1553  ff_url_join(url, sizeof(url), "rtp", NULL, peer,
1554  reply->transports[0].server_port_min, "%s", options);
1555  if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1556  ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1557  err = AVERROR_INVALIDDATA;
1558  goto fail;
1559  }
1560  break;
1561  }
1562  case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1563  char url[1024], namebuf[50], optbuf[20] = "";
1564  struct sockaddr_storage addr;
1565  int port, ttl;
1566 
1567  if (reply->transports[0].destination.ss_family) {
1568  addr = reply->transports[0].destination;
1569  port = reply->transports[0].port_min;
1570  ttl = reply->transports[0].ttl;
1571  } else {
1572  addr = rtsp_st->sdp_ip;
1573  port = rtsp_st->sdp_port;
1574  ttl = rtsp_st->sdp_ttl;
1575  }
1576  if (ttl > 0)
1577  snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1578  getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1579  namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1580  ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1581  port, "%s", optbuf);
1582  if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
1583  &s->interrupt_callback, NULL) < 0) {
1584  err = AVERROR_INVALIDDATA;
1585  goto fail;
1586  }
1587  break;
1588  }
1589  }
1590 
1591  if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
1592  goto fail;
1593  }
1594 
1595  if (rt->nb_rtsp_streams && reply->timeout > 0)
1596  rt->timeout = reply->timeout;
1597 
1598  if (rt->server_type == RTSP_SERVER_REAL)
1599  rt->need_subscription = 1;
1600 
1601  return 0;
1602 
1603 fail:
1604  ff_rtsp_undo_setup(s, 0);
1605  return err;
1606 }
1607 
1608 void ff_rtsp_close_connections(AVFormatContext *s)
1609 {
1610  RTSPState *rt = s->priv_data;
1611  if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out);
1612  ffurl_close(rt->rtsp_hd);
1613  rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1614 }
1615 
1616 int ff_rtsp_connect(AVFormatContext *s)
1617 {
1618  RTSPState *rt = s->priv_data;
1619  char proto[128], host[1024], path[1024];
1620  char tcpname[1024], cmd[2048], auth[128];
1621  const char *lower_rtsp_proto = "tcp";
1622  int port, err, tcp_fd;
1623  RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1624  int lower_transport_mask = 0;
1625  int default_port = RTSP_DEFAULT_PORT;
1626  char real_challenge[64] = "";
1627  struct sockaddr_storage peer;
1628  socklen_t peer_len = sizeof(peer);
1629 
1630  if (rt->rtp_port_max < rt->rtp_port_min) {
1631  av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1632  "than min port %d\n", rt->rtp_port_max,
1633  rt->rtp_port_min);
1634  return AVERROR(EINVAL);
1635  }
1636 
1637  if (!ff_network_init())
1638  return AVERROR(EIO);
1639 
1640  if (s->max_delay < 0) /* Not set by the caller */
1641  s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
1642 
1643  rt->control_transport = RTSP_MODE_PLAIN;
1644  if (rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTP)) {
1645  rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1646  rt->control_transport = RTSP_MODE_TUNNEL;
1647  }
1648  /* Only pass through valid flags from here */
1649  rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1650 
1651 redirect:
1652  /* extract hostname and port */
1653  av_url_split(proto, sizeof(proto), auth, sizeof(auth),
1654  host, sizeof(host), &port, path, sizeof(path), s->filename);
1655 
1656  if (!strcmp(proto, "rtsps")) {
1657  lower_rtsp_proto = "tls";
1658  default_port = RTSPS_DEFAULT_PORT;
1659  rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1660  }
1661 
1662  if (*auth) {
1663  av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1664  }
1665  if (port < 0)
1666  port = default_port;
1667 
1668  lower_transport_mask = rt->lower_transport_mask;
1669 
1670  if (!lower_transport_mask)
1671  lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1672 
1673  if (s->oformat) {
1674  /* Only UDP or TCP - UDP multicast isn't supported. */
1675  lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1676  (1 << RTSP_LOWER_TRANSPORT_TCP);
1677  if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1678  av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1679  "only UDP and TCP are supported for output.\n");
1680  err = AVERROR(EINVAL);
1681  goto fail;
1682  }
1683  }
1684 
1685  /* Construct the URI used in request; this is similar to s->filename,
1686  * but with authentication credentials removed and RTSP specific options
1687  * stripped out. */
1688  ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
1689  host, port, "%s", path);
1690 
1691  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1692  /* set up initial handshake for tunneling */
1693  char httpname[1024];
1694  char sessioncookie[17];
1695  char headers[1024];
1696 
1697  ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1698  snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1699  av_get_random_seed(), av_get_random_seed());
1700 
1701  /* GET requests */
1702  if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
1703  &s->interrupt_callback) < 0) {
1704  err = AVERROR(EIO);
1705  goto fail;
1706  }
1707 
1708  /* generate GET headers */
1709  snprintf(headers, sizeof(headers),
1710  "x-sessioncookie: %s\r\n"
1711  "Accept: application/x-rtsp-tunnelled\r\n"
1712  "Pragma: no-cache\r\n"
1713  "Cache-Control: no-cache\r\n",
1714  sessioncookie);
1715  av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
1716 
1717  /* complete the connection */
1718  if (ffurl_connect(rt->rtsp_hd, NULL)) {
1719  err = AVERROR(EIO);
1720  goto fail;
1721  }
1722 
1723  /* POST requests */
1724  if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
1725  &s->interrupt_callback) < 0 ) {
1726  err = AVERROR(EIO);
1727  goto fail;
1728  }
1729 
1730  /* generate POST headers */
1731  snprintf(headers, sizeof(headers),
1732  "x-sessioncookie: %s\r\n"
1733  "Content-Type: application/x-rtsp-tunnelled\r\n"
1734  "Pragma: no-cache\r\n"
1735  "Cache-Control: no-cache\r\n"
1736  "Content-Length: 32767\r\n"
1737  "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1738  sessioncookie);
1739  av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
1740  av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
1741 
1742  /* Initialize the authentication state for the POST session. The HTTP
1743  * protocol implementation doesn't properly handle multi-pass
1744  * authentication for POST requests, since it would require one of
1745  * the following:
1746  * - implementing Expect: 100-continue, which many HTTP servers
1747  * don't support anyway, even less the RTSP servers that do HTTP
1748  * tunneling
1749  * - sending the whole POST data until getting a 401 reply specifying
1750  * what authentication method to use, then resending all that data
1751  * - waiting for potential 401 replies directly after sending the
1752  * POST header (waiting for some unspecified time)
1753  * Therefore, we copy the full auth state, which works for both basic
1754  * and digest. (For digest, we would have to synchronize the nonce
1755  * count variable between the two sessions, if we'd do more requests
1756  * with the original session, though.)
1757  */
1758  ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1759 
1760  /* complete the connection */
1761  if (ffurl_connect(rt->rtsp_hd_out, NULL)) {
1762  err = AVERROR(EIO);
1763  goto fail;
1764  }
1765  } else {
1766  int ret;
1767  /* open the tcp connection */
1768  ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
1769  host, port,
1770  "?timeout=%d", rt->stimeout);
1771  if ((ret = ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
1772  &s->interrupt_callback, NULL)) < 0) {
1773  err = ret;
1774  goto fail;
1775  }
1776  rt->rtsp_hd_out = rt->rtsp_hd;
1777  }
1778  rt->seq = 0;
1779 
1780  tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1781  if (tcp_fd < 0) {
1782  err = tcp_fd;
1783  goto fail;
1784  }
1785  if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1786  getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1787  NULL, 0, NI_NUMERICHOST);
1788  }
1789 
1790  /* request options supported by the server; this also detects server
1791  * type */
1792  for (rt->server_type = RTSP_SERVER_RTP;;) {
1793  cmd[0] = 0;
1794  if (rt->server_type == RTSP_SERVER_REAL)
1795  av_strlcat(cmd,
1796  /*
1797  * The following entries are required for proper
1798  * streaming from a Realmedia server. They are
1799  * interdependent in some way although we currently
1800  * don't quite understand how. Values were copied
1801  * from mplayer SVN r23589.
1802  * ClientChallenge is a 16-byte ID in hex
1803  * CompanyID is a 16-byte ID in base64
1804  */
1805  "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1806  "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1807  "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1808  "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1809  sizeof(cmd));
1810  ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1811  if (reply->status_code != RTSP_STATUS_OK) {
1812  err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1813  goto fail;
1814  }
1815 
1816  /* detect server type if not standard-compliant RTP */
1817  if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1818  rt->server_type = RTSP_SERVER_REAL;
1819  continue;
1820  } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
1821  rt->server_type = RTSP_SERVER_WMS;
1822  } else if (rt->server_type == RTSP_SERVER_REAL)
1823  strcpy(real_challenge, reply->real_challenge);
1824  break;
1825  }
1826 
1827  if (CONFIG_RTSP_DEMUXER && s->iformat)
1828  err = ff_rtsp_setup_input_streams(s, reply);
1829  else if (CONFIG_RTSP_MUXER)
1830  err = ff_rtsp_setup_output_streams(s, host);
1831  else
1832  av_assert0(0);
1833  if (err)
1834  goto fail;
1835 
1836  do {
1837  int lower_transport = ff_log2_tab[lower_transport_mask &
1838  ~(lower_transport_mask - 1)];
1839 
1840  if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
1841  && (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
1842  lower_transport = RTSP_LOWER_TRANSPORT_TCP;
1843 
1844  err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
1845  rt->server_type == RTSP_SERVER_REAL ?
1846  real_challenge : NULL);
1847  if (err < 0)
1848  goto fail;
1849  lower_transport_mask &= ~(1 << lower_transport);
1850  if (lower_transport_mask == 0 && err == 1) {
1851  err = AVERROR(EPROTONOSUPPORT);
1852  goto fail;
1853  }
1854  } while (err);
1855 
1856  rt->lower_transport_mask = lower_transport_mask;
1857  av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
1858  rt->state = RTSP_STATE_IDLE;
1859  rt->seek_timestamp = 0; /* default is to start stream at position zero */
1860  return 0;
1861  fail:
1862  ff_rtsp_close_streams(s);
1863  ff_rtsp_close_connections(s);
1864  if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1865  av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1866  rt->session_id[0] = '\0';
1867  av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1868  reply->status_code,
1869  s->filename);
1870  goto redirect;
1871  }
1872  ff_network_close();
1873  return err;
1874 }
1875 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1876 
1877 #if CONFIG_RTPDEC
1878 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1879  uint8_t *buf, int buf_size, int64_t wait_end)
1880 {
1881  RTSPState *rt = s->priv_data;
1882  RTSPStream *rtsp_st;
1883  int n, i, ret, tcp_fd, timeout_cnt = 0;
1884  int max_p = 0;
1885  struct pollfd *p = rt->p;
1886  int *fds = NULL, fdsnum, fdsidx;
1887 
1888  for (;;) {
1889  if (ff_check_interrupt(&s->interrupt_callback))
1890  return AVERROR_EXIT;
1891  if (wait_end && wait_end - av_gettime_relative() < 0)
1892  return AVERROR(EAGAIN);
1893  max_p = 0;
1894  if (rt->rtsp_hd) {
1895  tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1896  p[max_p].fd = tcp_fd;
1897  p[max_p++].events = POLLIN;
1898  } else {
1899  tcp_fd = -1;
1900  }
1901  for (i = 0; i < rt->nb_rtsp_streams; i++) {
1902  rtsp_st = rt->rtsp_streams[i];
1903  if (rtsp_st->rtp_handle) {
1904  if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
1905  &fds, &fdsnum)) {
1906  av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
1907  return ret;
1908  }
1909  if (fdsnum != 2) {
1910  av_log(s, AV_LOG_ERROR,
1911  "Number of fds %d not supported\n", fdsnum);
1912  return AVERROR_INVALIDDATA;
1913  }
1914  for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
1915  p[max_p].fd = fds[fdsidx];
1916  p[max_p++].events = POLLIN;
1917  }
1918  av_freep(&fds);
1919  }
1920  }
1921  n = poll(p, max_p, POLL_TIMEOUT_MS);
1922  if (n > 0) {
1923  int j = 1 - (tcp_fd == -1);
1924  timeout_cnt = 0;
1925  for (i = 0; i < rt->nb_rtsp_streams; i++) {
1926  rtsp_st = rt->rtsp_streams[i];
1927  if (rtsp_st->rtp_handle) {
1928  if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1929  ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
1930  if (ret > 0) {
1931  *prtsp_st = rtsp_st;
1932  return ret;
1933  }
1934  }
1935  j+=2;
1936  }
1937  }
1938 #if CONFIG_RTSP_DEMUXER
1939  if (tcp_fd != -1 && p[0].revents & POLLIN) {
1940  if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
1941  if (rt->state == RTSP_STATE_STREAMING) {
1942  if (!ff_rtsp_parse_streaming_commands(s))
1943  return AVERROR_EOF;
1944  else
1945  av_log(s, AV_LOG_WARNING,
1946  "Unable to answer to TEARDOWN\n");
1947  } else
1948  return 0;
1949  } else {
1950  RTSPMessageHeader reply;
1951  ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
1952  if (ret < 0)
1953  return ret;
1954  /* XXX: parse message */
1955  if (rt->state != RTSP_STATE_STREAMING)
1956  return 0;
1957  }
1958  }
1959 #endif
1960  } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1961  return AVERROR(ETIMEDOUT);
1962  } else if (n < 0 && errno != EINTR)
1963  return AVERROR(errno);
1964  }
1965 }
1966 
1967 static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
1968  const uint8_t *buf, int len)
1969 {
1970  RTSPState *rt = s->priv_data;
1971  int i;
1972  if (len < 0)
1973  return len;
1974  if (rt->nb_rtsp_streams == 1) {
1975  *rtsp_st = rt->rtsp_streams[0];
1976  return len;
1977  }
1978  if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
1979  if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
1980  int no_ssrc = 0;
1981  for (i = 0; i < rt->nb_rtsp_streams; i++) {
1982  RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
1983  if (!rtpctx)
1984  continue;
1985  if (rtpctx->ssrc == AV_RB32(&buf[4])) {
1986  *rtsp_st = rt->rtsp_streams[i];
1987  return len;
1988  }
1989  if (!rtpctx->ssrc)
1990  no_ssrc = 1;
1991  }
1992  if (no_ssrc) {
1993  av_log(s, AV_LOG_WARNING,
1994  "Unable to pick stream for packet - SSRC not known for "
1995  "all streams\n");
1996  return AVERROR(EAGAIN);
1997  }
1998  } else {
1999  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2000  if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
2001  *rtsp_st = rt->rtsp_streams[i];
2002  return len;
2003  }
2004  }
2005  }
2006  }
2007  av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
2008  return AVERROR(EAGAIN);
2009 }
2010 
2011 int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
2012 {
2013  RTSPState *rt = s->priv_data;
2014  int ret, len;
2015  RTSPStream *rtsp_st, *first_queue_st = NULL;
2016  int64_t wait_end = 0;
2017 
2018  if (rt->nb_byes == rt->nb_rtsp_streams)
2019  return AVERROR_EOF;
2020 
2021  /* get next frames from the same RTP packet */
2022  if (rt->cur_transport_priv) {
2023  if (rt->transport == RTSP_TRANSPORT_RDT) {
2024  ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2025  } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2026  ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2027  } else if (CONFIG_RTPDEC && rt->ts) {
2028  ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
2029  if (ret >= 0) {
2030  rt->recvbuf_pos += ret;
2031  ret = rt->recvbuf_pos < rt->recvbuf_len;
2032  }
2033  } else
2034  ret = -1;
2035  if (ret == 0) {
2036  rt->cur_transport_priv = NULL;
2037  return 0;
2038  } else if (ret == 1) {
2039  return 0;
2040  } else
2041  rt->cur_transport_priv = NULL;
2042  }
2043 
2044 redo:
2045  if (rt->transport == RTSP_TRANSPORT_RTP) {
2046  int i;
2047  int64_t first_queue_time = 0;
2048  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2049  RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2050  int64_t queue_time;
2051  if (!rtpctx)
2052  continue;
2053  queue_time = ff_rtp_queued_packet_time(rtpctx);
2054  if (queue_time && (queue_time - first_queue_time < 0 ||
2055  !first_queue_time)) {
2056  first_queue_time = queue_time;
2057  first_queue_st = rt->rtsp_streams[i];
2058  }
2059  }
2060  if (first_queue_time) {
2061  wait_end = first_queue_time + s->max_delay;
2062  } else {
2063  wait_end = 0;
2064  first_queue_st = NULL;
2065  }
2066  }
2067 
2068  /* read next RTP packet */
2069  if (!rt->recvbuf) {
2070  rt->recvbuf = av_malloc(RECVBUF_SIZE);
2071  if (!rt->recvbuf)
2072  return AVERROR(ENOMEM);
2073  }
2074 
2075  switch(rt->lower_transport) {
2076  default:
2077 #if CONFIG_RTSP_DEMUXER
2078  case RTSP_LOWER_TRANSPORT_TCP:
2079  len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
2080  break;
2081 #endif
2082  case RTSP_LOWER_TRANSPORT_UDP:
2083  case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
2084  len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2085  if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2086  ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);
2087  break;
2088  case RTSP_LOWER_TRANSPORT_CUSTOM:
2089  if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2090  wait_end && wait_end < av_gettime_relative())
2091  len = AVERROR(EAGAIN);
2092  else
2093  len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
2094  len = pick_stream(s, &rtsp_st, rt->recvbuf, len);
2095  if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2096  ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len);
2097  break;
2098  }
2099  if (len == AVERROR(EAGAIN) && first_queue_st &&
2100  rt->transport == RTSP_TRANSPORT_RTP) {
2101  rtsp_st = first_queue_st;
2102  ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
2103  goto end;
2104  }
2105  if (len < 0)
2106  return len;
2107  if (len == 0)
2108  return AVERROR_EOF;
2109  if (rt->transport == RTSP_TRANSPORT_RDT) {
2110  ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2111  } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2112  ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2113  if (rtsp_st->feedback) {
2114  AVIOContext *pb = NULL;
2115  if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)
2116  pb = s->pb;
2117  ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
2118  }
2119  if (ret < 0) {
2120  /* Either bad packet, or a RTCP packet. Check if the
2121  * first_rtcp_ntp_time field was initialized. */
2122  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
2123  if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
2124  /* first_rtcp_ntp_time has been initialized for this stream,
2125  * copy the same value to all other uninitialized streams,
2126  * in order to map their timestamp origin to the same ntp time
2127  * as this one. */
2128  int i;
2129  AVStream *st = NULL;
2130  if (rtsp_st->stream_index >= 0)
2131  st = s->streams[rtsp_st->stream_index];
2132  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2133  RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2134  AVStream *st2 = NULL;
2135  if (rt->rtsp_streams[i]->stream_index >= 0)
2136  st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2137  if (rtpctx2 && st && st2 &&
2138  rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
2139  rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2140  rtpctx2->rtcp_ts_offset = av_rescale_q(
2141  rtpctx->rtcp_ts_offset, st->time_base,
2142  st2->time_base);
2143  }
2144  }
2145  // Make real NTP start time available in AVFormatContext
2146  if (s->start_time_realtime == AV_NOPTS_VALUE) {
2147  s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32);
2148  if (rtpctx->st) {
2149  s->start_time_realtime -=
2150  av_rescale (rtpctx->rtcp_ts_offset,
2151  (uint64_t) rtpctx->st->time_base.num * 1000000,
2152  rtpctx->st->time_base.den);
2153  }
2154  }
2155  }
2156  if (ret == -RTCP_BYE) {
2157  rt->nb_byes++;
2158 
2159  av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2160  rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2161 
2162  if (rt->nb_byes == rt->nb_rtsp_streams)
2163  return AVERROR_EOF;
2164  }
2165  }
2166  } else if (CONFIG_RTPDEC && rt->ts) {
2167  ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
2168  if (ret >= 0) {
2169  if (ret < len) {
2170  rt->recvbuf_len = len;
2171  rt->recvbuf_pos = ret;
2172  rt->cur_transport_priv = rt->ts;
2173  return 1;
2174  } else {
2175  ret = 0;
2176  }
2177  }
2178  } else {
2179  return AVERROR_INVALIDDATA;
2180  }
2181 end:
2182  if (ret < 0)
2183  goto redo;
2184  if (ret == 1)
2185  /* more packets may follow, so we save the RTP context */
2186  rt->cur_transport_priv = rtsp_st->transport_priv;
2187 
2188  return ret;
2189 }
2190 #endif /* CONFIG_RTPDEC */
2191 
2192 #if CONFIG_SDP_DEMUXER
2193 static int sdp_probe(AVProbeData *p1)
2194 {
2195  const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2196 
2197  /* we look for a line beginning "c=IN IP" */
2198  while (p < p_end && *p != '\0') {
2199  if (p + sizeof("c=IN IP") - 1 < p_end &&
2200  av_strstart(p, "c=IN IP", NULL))
2201  return AVPROBE_SCORE_EXTENSION;
2202 
2203  while (p < p_end - 1 && *p != '\n') p++;
2204  if (++p >= p_end)
2205  break;
2206  if (*p == '\r')
2207  p++;
2208  }
2209  return 0;
2210 }
2211 
2212 static void append_source_addrs(char *buf, int size, const char *name,
2213  int count, struct RTSPSource **addrs)
2214 {
2215  int i;
2216  if (!count)
2217  return;
2218  av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
2219  for (i = 1; i < count; i++)
2220  av_strlcatf(buf, size, ",%s", addrs[i]->addr);
2221 }
2222 
2223 static int sdp_read_header(AVFormatContext *s)
2224 {
2225  RTSPState *rt = s->priv_data;
2226  RTSPStream *rtsp_st;
2227  int size, i, err;
2228  char *content;
2229  char url[1024];
2230 
2231  if (!ff_network_init())
2232  return AVERROR(EIO);
2233 
2234  if (s->max_delay < 0) /* Not set by the caller */
2235  s->max_delay = DEFAULT_REORDERING_DELAY;
2236  if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2237  rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;
2238 
2239  /* read the whole sdp file */
2240  /* XXX: better loading */
2241  content = av_malloc(SDP_MAX_SIZE);
2242  size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);
2243  if (size <= 0) {
2244  av_free(content);
2245  return AVERROR_INVALIDDATA;
2246  }
2247  content[size] ='\0';
2248 
2249  err = ff_sdp_parse(s, content);
2250  av_freep(&content);
2251  if (err) goto fail;
2252 
2253  /* open each RTP stream */
2254  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2255  char namebuf[50];
2256  rtsp_st = rt->rtsp_streams[i];
2257 
2258  if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2259  getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
2260  namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2261  ff_url_join(url, sizeof(url), "rtp", NULL,
2262  namebuf, rtsp_st->sdp_port,
2263  "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2264  rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2265  rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2266  rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2267 
2268  append_source_addrs(url, sizeof(url), "sources",
2269  rtsp_st->nb_include_source_addrs,
2270  rtsp_st->include_source_addrs);
2271  append_source_addrs(url, sizeof(url), "block",
2272  rtsp_st->nb_exclude_source_addrs,
2273  rtsp_st->exclude_source_addrs);
2274  if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
2275  &s->interrupt_callback, NULL) < 0) {
2276  err = AVERROR_INVALIDDATA;
2277  goto fail;
2278  }
2279  }
2280  if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2281  goto fail;
2282  }
2283  return 0;
2284 fail:
2285  ff_rtsp_close_streams(s);
2286  ff_network_close();
2287  return err;
2288 }
2289 
2290 static int sdp_read_close(AVFormatContext *s)
2291 {
2292  ff_rtsp_close_streams(s);
2293  ff_network_close();
2294  return 0;
2295 }
2296 
2297 static const AVClass sdp_demuxer_class = {
2298  .class_name = "SDP demuxer",
2299  .item_name = av_default_item_name,
2300  .option = sdp_options,
2301  .version = LIBAVUTIL_VERSION_INT,
2302 };
2303 
2304 AVInputFormat ff_sdp_demuxer = {
2305  .name = "sdp",
2306  .long_name = NULL_IF_CONFIG_SMALL("SDP"),
2307  .priv_data_size = sizeof(RTSPState),
2308  .read_probe = sdp_probe,
2309  .read_header = sdp_read_header,
2310  .read_packet = ff_rtsp_fetch_packet,
2311  .read_close = sdp_read_close,
2312  .priv_class = &sdp_demuxer_class,
2313 };
2314 #endif /* CONFIG_SDP_DEMUXER */
2315 
2316 #if CONFIG_RTP_DEMUXER
2317 static int rtp_probe(AVProbeData *p)
2318 {
2319  if (av_strstart(p->filename, "rtp:", NULL))
2320  return AVPROBE_SCORE_MAX;
2321  return 0;
2322 }
2323 
2324 static int rtp_read_header(AVFormatContext *s)
2325 {
2326  uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2327  char host[500], sdp[500];
2328  int ret, port;
2329  URLContext* in = NULL;
2330  int payload_type;
2331  AVCodecContext codec = { 0 };
2332  struct sockaddr_storage addr;
2333  AVIOContext pb;
2334  socklen_t addrlen = sizeof(addr);
2335  RTSPState *rt = s->priv_data;
2336 
2337  if (!ff_network_init())
2338  return AVERROR(EIO);
2339 
2340  ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ,
2341  &s->interrupt_callback, NULL);
2342  if (ret)
2343  goto fail;
2344 
2345  while (1) {
2346  ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2347  if (ret == AVERROR(EAGAIN))
2348  continue;
2349  if (ret < 0)
2350  goto fail;
2351  if (ret < 12) {
2352  av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2353  continue;
2354  }
2355 
2356  if ((recvbuf[0] & 0xc0) != 0x80) {
2357  av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2358  "received\n");
2359  continue;
2360  }
2361 
2362  if (RTP_PT_IS_RTCP(recvbuf[1]))
2363  continue;
2364 
2365  payload_type = recvbuf[1] & 0x7f;
2366  break;
2367  }
2368  getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2369  ffurl_close(in);
2370  in = NULL;
2371 
2372  if (ff_rtp_get_codec_info(&codec, payload_type)) {
2373  av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2374  "without an SDP file describing it\n",
2375  payload_type);
2376  goto fail;
2377  }
2378  if (codec.codec_type != AVMEDIA_TYPE_DATA) {
2379  av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2380  "properly you need an SDP file "
2381  "describing it\n");
2382  }
2383 
2384  av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2385  NULL, 0, s->filename);
2386 
2387  snprintf(sdp, sizeof(sdp),
2388  "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2389  addr.ss_family == AF_INET ? 4 : 6, host,
2390  codec.codec_type == AVMEDIA_TYPE_DATA ? "application" :
2391  codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2392  port, payload_type);
2393  av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
2394 
2395  ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);
2396  s->pb = &pb;
2397 
2398  /* sdp_read_header initializes this again */
2399  ff_network_close();
2400 
2401  rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;
2402 
2403  ret = sdp_read_header(s);
2404  s->pb = NULL;
2405  return ret;
2406 
2407 fail:
2408  if (in)
2409  ffurl_close(in);
2410  ff_network_close();
2411  return ret;
2412 }
2413 
2414 static const AVClass rtp_demuxer_class = {
2415  .class_name = "RTP demuxer",
2416  .item_name = av_default_item_name,
2417  .option = rtp_options,
2418  .version = LIBAVUTIL_VERSION_INT,
2419 };
2420 
2421 AVInputFormat ff_rtp_demuxer = {
2422  .name = "rtp",
2423  .long_name = NULL_IF_CONFIG_SMALL("RTP input"),
2424  .priv_data_size = sizeof(RTSPState),
2425  .read_probe = rtp_probe,
2426  .read_header = rtp_read_header,
2427  .read_packet = ff_rtsp_fetch_packet,
2428  .read_close = sdp_read_close,
2429  .flags = AVFMT_NOFILE,
2430  .priv_class = &rtp_demuxer_class,
2431 };
2432 #endif /* CONFIG_RTP_DEMUXER */
Generated on Sun Mar 8 2015 02:35:12 for FFmpeg by   doxygen 1.8.2