FFmpeg  2.6.9
 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 
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 },
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"),
107  { NULL },
108 };
109 
110 static const AVOption rtp_options[] = {
111  RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
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) {
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);
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 =
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);
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"))
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 {
468  handler = ff_rtp_handler_find_by_id(
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) {
486  /* if standard payload type, we can find the codec right now */
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)
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)
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 &&
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);
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)
722  else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)
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 */
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);
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) {
762  }
763  if (CONFIG_RTPDEC && rt->ts)
765  av_freep(&rt->p);
766  av_freep(&rt->recvbuf);
767 }
768 
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) {
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)
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,
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) {
813  rtsp_st->dynamic_protocol_context,
814  rtsp_st->dynamic_handler);
815  }
816  if (rtsp_st->crypto_suite[0])
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];
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  }
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';
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  }
892  }
893  if (!av_strcasecmp(lower_transport, "TCP"))
895  else
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")) {
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  if (reply->nb_transports >= RTSP_MAX_TRANSPORTS)
968  break;
969  }
970 }
971 
972 static void handle_rtp_info(RTSPState *rt, const char *url,
973  uint32_t seq, uint32_t rtptime)
974 {
975  int i;
976  if (!rtptime || !url[0])
977  return;
978  if (rt->transport != RTSP_TRANSPORT_RTP)
979  return;
980  for (i = 0; i < rt->nb_rtsp_streams; i++) {
981  RTSPStream *rtsp_st = rt->rtsp_streams[i];
982  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
983  if (!rtpctx)
984  continue;
985  if (!strcmp(rtsp_st->control_url, url)) {
986  rtpctx->base_timestamp = rtptime;
987  break;
988  }
989  }
990 }
991 
992 static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
993 {
994  int read = 0;
995  char key[20], value[1024], url[1024] = "";
996  uint32_t seq = 0, rtptime = 0;
997 
998  for (;;) {
999  p += strspn(p, SPACE_CHARS);
1000  if (!*p)
1001  break;
1002  get_word_sep(key, sizeof(key), "=", &p);
1003  if (*p != '=')
1004  break;
1005  p++;
1006  get_word_sep(value, sizeof(value), ";, ", &p);
1007  read++;
1008  if (!strcmp(key, "url"))
1009  av_strlcpy(url, value, sizeof(url));
1010  else if (!strcmp(key, "seq"))
1011  seq = strtoul(value, NULL, 10);
1012  else if (!strcmp(key, "rtptime"))
1013  rtptime = strtoul(value, NULL, 10);
1014  if (*p == ',') {
1015  handle_rtp_info(rt, url, seq, rtptime);
1016  url[0] = '\0';
1017  seq = rtptime = 0;
1018  read = 0;
1019  }
1020  if (*p)
1021  p++;
1022  }
1023  if (read > 0)
1024  handle_rtp_info(rt, url, seq, rtptime);
1025 }
1026 
1027 void ff_rtsp_parse_line(RTSPMessageHeader *reply, const char *buf,
1028  RTSPState *rt, const char *method)
1029 {
1030  const char *p;
1031 
1032  /* NOTE: we do case independent match for broken servers */
1033  p = buf;
1034  if (av_stristart(p, "Session:", &p)) {
1035  int t;
1036  get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
1037  if (av_stristart(p, ";timeout=", &p) &&
1038  (t = strtol(p, NULL, 10)) > 0) {
1039  reply->timeout = t;
1040  }
1041  } else if (av_stristart(p, "Content-Length:", &p)) {
1042  reply->content_length = strtol(p, NULL, 10);
1043  } else if (av_stristart(p, "Transport:", &p)) {
1044  rtsp_parse_transport(reply, p);
1045  } else if (av_stristart(p, "CSeq:", &p)) {
1046  reply->seq = strtol(p, NULL, 10);
1047  } else if (av_stristart(p, "Range:", &p)) {
1048  rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
1049  } else if (av_stristart(p, "RealChallenge1:", &p)) {
1050  p += strspn(p, SPACE_CHARS);
1051  av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
1052  } else if (av_stristart(p, "Server:", &p)) {
1053  p += strspn(p, SPACE_CHARS);
1054  av_strlcpy(reply->server, p, sizeof(reply->server));
1055  } else if (av_stristart(p, "Notice:", &p) ||
1056  av_stristart(p, "X-Notice:", &p)) {
1057  reply->notice = strtol(p, NULL, 10);
1058  } else if (av_stristart(p, "Location:", &p)) {
1059  p += strspn(p, SPACE_CHARS);
1060  av_strlcpy(reply->location, p , sizeof(reply->location));
1061  } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
1062  p += strspn(p, SPACE_CHARS);
1063  ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
1064  } else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
1065  p += strspn(p, SPACE_CHARS);
1066  ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
1067  } else if (av_stristart(p, "Content-Base:", &p) && rt) {
1068  p += strspn(p, SPACE_CHARS);
1069  if (method && !strcmp(method, "DESCRIBE"))
1070  av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
1071  } else if (av_stristart(p, "RTP-Info:", &p) && rt) {
1072  p += strspn(p, SPACE_CHARS);
1073  if (method && !strcmp(method, "PLAY"))
1074  rtsp_parse_rtp_info(rt, p);
1075  } else if (av_stristart(p, "Public:", &p) && rt) {
1076  if (strstr(p, "GET_PARAMETER") &&
1077  method && !strcmp(method, "OPTIONS"))
1078  rt->get_parameter_supported = 1;
1079  } else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
1080  p += strspn(p, SPACE_CHARS);
1081  rt->accept_dynamic_rate = atoi(p);
1082  } else if (av_stristart(p, "Content-Type:", &p)) {
1083  p += strspn(p, SPACE_CHARS);
1084  av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
1085  }
1086 }
1087 
1088 /* skip a RTP/TCP interleaved packet */
1090 {
1091  RTSPState *rt = s->priv_data;
1092  int ret, len, len1;
1093  uint8_t buf[1024];
1094 
1095  ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
1096  if (ret != 3)
1097  return;
1098  len = AV_RB16(buf + 1);
1099 
1100  av_dlog(s, "skipping RTP packet len=%d\n", len);
1101 
1102  /* skip payload */
1103  while (len > 0) {
1104  len1 = len;
1105  if (len1 > sizeof(buf))
1106  len1 = sizeof(buf);
1107  ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);
1108  if (ret != len1)
1109  return;
1110  len -= len1;
1111  }
1112 }
1113 
1115  unsigned char **content_ptr,
1116  int return_on_interleaved_data, const char *method)
1117 {
1118  RTSPState *rt = s->priv_data;
1119  char buf[4096], buf1[1024], *q;
1120  unsigned char ch;
1121  const char *p;
1122  int ret, content_length, line_count = 0, request = 0;
1123  unsigned char *content = NULL;
1124 
1125 start:
1126  line_count = 0;
1127  request = 0;
1128  content = NULL;
1129  memset(reply, 0, sizeof(*reply));
1130 
1131  /* parse reply (XXX: use buffers) */
1132  rt->last_reply[0] = '\0';
1133  for (;;) {
1134  q = buf;
1135  for (;;) {
1136  ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
1137  av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
1138  if (ret != 1)
1139  return AVERROR_EOF;
1140  if (ch == '\n')
1141  break;
1142  if (ch == '$') {
1143  /* XXX: only parse it if first char on line ? */
1144  if (return_on_interleaved_data) {
1145  return 1;
1146  } else
1148  } else if (ch != '\r') {
1149  if ((q - buf) < sizeof(buf) - 1)
1150  *q++ = ch;
1151  }
1152  }
1153  *q = '\0';
1154 
1155  av_dlog(s, "line='%s'\n", buf);
1156 
1157  /* test if last line */
1158  if (buf[0] == '\0')
1159  break;
1160  p = buf;
1161  if (line_count == 0) {
1162  /* get reply code */
1163  get_word(buf1, sizeof(buf1), &p);
1164  if (!strncmp(buf1, "RTSP/", 5)) {
1165  get_word(buf1, sizeof(buf1), &p);
1166  reply->status_code = atoi(buf1);
1167  av_strlcpy(reply->reason, p, sizeof(reply->reason));
1168  } else {
1169  av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
1170  get_word(buf1, sizeof(buf1), &p); // object
1171  request = 1;
1172  }
1173  } else {
1174  ff_rtsp_parse_line(reply, p, rt, method);
1175  av_strlcat(rt->last_reply, p, sizeof(rt->last_reply));
1176  av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
1177  }
1178  line_count++;
1179  }
1180 
1181  if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
1182  av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
1183 
1184  content_length = reply->content_length;
1185  if (content_length > 0) {
1186  /* leave some room for a trailing '\0' (useful for simple parsing) */
1187  content = av_malloc(content_length + 1);
1188  if (!content)
1189  return AVERROR(ENOMEM);
1190  ffurl_read_complete(rt->rtsp_hd, content, content_length);
1191  content[content_length] = '\0';
1192  }
1193  if (content_ptr)
1194  *content_ptr = content;
1195  else
1196  av_freep(&content);
1197 
1198  if (request) {
1199  char buf[1024];
1200  char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1201  const char* ptr = buf;
1202 
1203  if (!strcmp(reply->reason, "OPTIONS")) {
1204  snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
1205  if (reply->seq)
1206  av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
1207  if (reply->session_id[0])
1208  av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
1209  reply->session_id);
1210  } else {
1211  snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
1212  }
1213  av_strlcat(buf, "\r\n", sizeof(buf));
1214 
1215  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1216  av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1217  ptr = base64buf;
1218  }
1219  ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
1220 
1222  /* Even if the request from the server had data, it is not the data
1223  * that the caller wants or expects. The memory could also be leaked
1224  * if the actual following reply has content data. */
1225  if (content_ptr)
1226  av_freep(content_ptr);
1227  /* If method is set, this is called from ff_rtsp_send_cmd,
1228  * where a reply to exactly this request is awaited. For
1229  * callers from within packet receiving, we just want to
1230  * return to the caller and go back to receiving packets. */
1231  if (method)
1232  goto start;
1233  return 0;
1234  }
1235 
1236  if (rt->seq != reply->seq) {
1237  av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
1238  rt->seq, reply->seq);
1239  }
1240 
1241  /* EOS */
1242  if (reply->notice == 2101 /* End-of-Stream Reached */ ||
1243  reply->notice == 2104 /* Start-of-Stream Reached */ ||
1244  reply->notice == 2306 /* Continuous Feed Terminated */) {
1245  rt->state = RTSP_STATE_IDLE;
1246  } else if (reply->notice >= 4400 && reply->notice < 5500) {
1247  return AVERROR(EIO); /* data or server error */
1248  } else if (reply->notice == 2401 /* Ticket Expired */ ||
1249  (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
1250  return AVERROR(EPERM);
1251 
1252  return 0;
1253 }
1254 
1255 /**
1256  * Send a command to the RTSP server without waiting for the reply.
1257  *
1258  * @param s RTSP (de)muxer context
1259  * @param method the method for the request
1260  * @param url the target url for the request
1261  * @param headers extra header lines to include in the request
1262  * @param send_content if non-null, the data to send as request body content
1263  * @param send_content_length the length of the send_content data, or 0 if
1264  * send_content is null
1265  *
1266  * @return zero if success, nonzero otherwise
1267  */
1268 static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
1269  const char *method, const char *url,
1270  const char *headers,
1271  const unsigned char *send_content,
1272  int send_content_length)
1273 {
1274  RTSPState *rt = s->priv_data;
1275  char buf[4096], *out_buf;
1276  char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1277 
1278  /* Add in RTSP headers */
1279  out_buf = buf;
1280  rt->seq++;
1281  snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
1282  if (headers)
1283  av_strlcat(buf, headers, sizeof(buf));
1284  av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
1285  av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent);
1286  if (rt->session_id[0] != '\0' && (!headers ||
1287  !strstr(headers, "\nIf-Match:"))) {
1288  av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
1289  }
1290  if (rt->auth[0]) {
1291  char *str = ff_http_auth_create_response(&rt->auth_state,
1292  rt->auth, url, method);
1293  if (str)
1294  av_strlcat(buf, str, sizeof(buf));
1295  av_free(str);
1296  }
1297  if (send_content_length > 0 && send_content)
1298  av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1299  av_strlcat(buf, "\r\n", sizeof(buf));
1300 
1301  /* base64 encode rtsp if tunneling */
1302  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1303  av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1304  out_buf = base64buf;
1305  }
1306 
1307  av_dlog(s, "Sending:\n%s--\n", buf);
1308 
1309  ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
1310  if (send_content_length > 0 && send_content) {
1311  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1312  av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
1313  "with content data not supported\n");
1314  return AVERROR_PATCHWELCOME;
1315  }
1316  ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
1317  }
1319 
1320  return 0;
1321 }
1322 
1323 int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1324  const char *url, const char *headers)
1325 {
1326  return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1327 }
1328 
1329 int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1330  const char *headers, RTSPMessageHeader *reply,
1331  unsigned char **content_ptr)
1332 {
1333  return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1334  content_ptr, NULL, 0);
1335 }
1336 
1338  const char *method, const char *url,
1339  const char *header,
1340  RTSPMessageHeader *reply,
1341  unsigned char **content_ptr,
1342  const unsigned char *send_content,
1343  int send_content_length)
1344 {
1345  RTSPState *rt = s->priv_data;
1346  HTTPAuthType cur_auth_type;
1347  int ret, attempts = 0;
1348 
1349 retry:
1350  cur_auth_type = rt->auth_state.auth_type;
1351  if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1352  send_content,
1353  send_content_length)))
1354  return ret;
1355 
1356  if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1357  return ret;
1358  attempts++;
1359 
1360  if (reply->status_code == 401 &&
1361  (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
1362  rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
1363  goto retry;
1364 
1365  if (reply->status_code > 400){
1366  av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
1367  method,
1368  reply->status_code,
1369  reply->reason);
1370  av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1371  }
1372 
1373  return 0;
1374 }
1375 
1376 int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1377  int lower_transport, const char *real_challenge)
1378 {
1379  RTSPState *rt = s->priv_data;
1380  int rtx = 0, j, i, err, interleave = 0, port_off;
1381  RTSPStream *rtsp_st;
1382  RTSPMessageHeader reply1, *reply = &reply1;
1383  char cmd[2048];
1384  const char *trans_pref;
1385 
1386  if (rt->transport == RTSP_TRANSPORT_RDT)
1387  trans_pref = "x-pn-tng";
1388  else if (rt->transport == RTSP_TRANSPORT_RAW)
1389  trans_pref = "RAW/RAW";
1390  else
1391  trans_pref = "RTP/AVP";
1392 
1393  /* default timeout: 1 minute */
1394  rt->timeout = 60;
1395 
1396  /* Choose a random starting offset within the first half of the
1397  * port range, to allow for a number of ports to try even if the offset
1398  * happens to be at the end of the random range. */
1399  port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
1400  /* even random offset */
1401  port_off -= port_off & 0x01;
1402 
1403  for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1404  char transport[2048];
1405 
1406  /*
1407  * WMS serves all UDP data over a single connection, the RTX, which
1408  * isn't necessarily the first in the SDP but has to be the first
1409  * to be set up, else the second/third SETUP will fail with a 461.
1410  */
1411  if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1412  rt->server_type == RTSP_SERVER_WMS) {
1413  if (i == 0) {
1414  /* rtx first */
1415  for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1416  int len = strlen(rt->rtsp_streams[rtx]->control_url);
1417  if (len >= 4 &&
1418  !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1419  "/rtx"))
1420  break;
1421  }
1422  if (rtx == rt->nb_rtsp_streams)
1423  return -1; /* no RTX found */
1424  rtsp_st = rt->rtsp_streams[rtx];
1425  } else
1426  rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1427  } else
1428  rtsp_st = rt->rtsp_streams[i];
1429 
1430  /* RTP/UDP */
1431  if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1432  char buf[256];
1433 
1434  if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1435  port = reply->transports[0].client_port_min;
1436  goto have_port;
1437  }
1438 
1439  /* first try in specified port range */
1440  while (j <= rt->rtp_port_max) {
1441  ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1442  "?localport=%d", j);
1443  /* we will use two ports per rtp stream (rtp and rtcp) */
1444  j += 2;
1445  if (!ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
1446  &s->interrupt_callback, NULL))
1447  goto rtp_opened;
1448  }
1449  av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1450  err = AVERROR(EIO);
1451  goto fail;
1452 
1453  rtp_opened:
1454  port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1455  have_port:
1456  snprintf(transport, sizeof(transport) - 1,
1457  "%s/UDP;", trans_pref);
1458  if (rt->server_type != RTSP_SERVER_REAL)
1459  av_strlcat(transport, "unicast;", sizeof(transport));
1460  av_strlcatf(transport, sizeof(transport),
1461  "client_port=%d", port);
1462  if (rt->transport == RTSP_TRANSPORT_RTP &&
1463  !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1464  av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1465  }
1466 
1467  /* RTP/TCP */
1468  else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1469  /* For WMS streams, the application streams are only used for
1470  * UDP. When trying to set it up for TCP streams, the server
1471  * will return an error. Therefore, we skip those streams. */
1472  if (rt->server_type == RTSP_SERVER_WMS &&
1473  (rtsp_st->stream_index < 0 ||
1474  s->streams[rtsp_st->stream_index]->codec->codec_type ==
1476  continue;
1477  snprintf(transport, sizeof(transport) - 1,
1478  "%s/TCP;", trans_pref);
1479  if (rt->transport != RTSP_TRANSPORT_RDT)
1480  av_strlcat(transport, "unicast;", sizeof(transport));
1481  av_strlcatf(transport, sizeof(transport),
1482  "interleaved=%d-%d",
1483  interleave, interleave + 1);
1484  interleave += 2;
1485  }
1486 
1487  else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1488  snprintf(transport, sizeof(transport) - 1,
1489  "%s/UDP;multicast", trans_pref);
1490  }
1491  if (s->oformat) {
1492  av_strlcat(transport, ";mode=record", sizeof(transport));
1493  } else if (rt->server_type == RTSP_SERVER_REAL ||
1495  av_strlcat(transport, ";mode=play", sizeof(transport));
1496  snprintf(cmd, sizeof(cmd),
1497  "Transport: %s\r\n",
1498  transport);
1499  if (rt->accept_dynamic_rate)
1500  av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
1501  if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1502  char real_res[41], real_csum[9];
1503  ff_rdt_calc_response_and_checksum(real_res, real_csum,
1504  real_challenge);
1505  av_strlcatf(cmd, sizeof(cmd),
1506  "If-Match: %s\r\n"
1507  "RealChallenge2: %s, sd=%s\r\n",
1508  rt->session_id, real_res, real_csum);
1509  }
1510  ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1511  if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1512  err = 1;
1513  goto fail;
1514  } else if (reply->status_code != RTSP_STATUS_OK ||
1515  reply->nb_transports != 1) {
1517  goto fail;
1518  }
1519 
1520  /* XXX: same protocol for all streams is required */
1521  if (i > 0) {
1522  if (reply->transports[0].lower_transport != rt->lower_transport ||
1523  reply->transports[0].transport != rt->transport) {
1524  err = AVERROR_INVALIDDATA;
1525  goto fail;
1526  }
1527  } else {
1528  rt->lower_transport = reply->transports[0].lower_transport;
1529  rt->transport = reply->transports[0].transport;
1530  }
1531 
1532  /* Fail if the server responded with another lower transport mode
1533  * than what we requested. */
1534  if (reply->transports[0].lower_transport != lower_transport) {
1535  av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1536  err = AVERROR_INVALIDDATA;
1537  goto fail;
1538  }
1539 
1540  switch(reply->transports[0].lower_transport) {
1542  rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1543  rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1544  break;
1545 
1546  case RTSP_LOWER_TRANSPORT_UDP: {
1547  char url[1024], options[30] = "";
1548  const char *peer = host;
1549 
1550  if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
1551  av_strlcpy(options, "?connect=1", sizeof(options));
1552  /* Use source address if specified */
1553  if (reply->transports[0].source[0])
1554  peer = reply->transports[0].source;
1555  ff_url_join(url, sizeof(url), "rtp", NULL, peer,
1556  reply->transports[0].server_port_min, "%s", options);
1557  if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1558  ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1559  err = AVERROR_INVALIDDATA;
1560  goto fail;
1561  }
1562  break;
1563  }
1565  char url[1024], namebuf[50], optbuf[20] = "";
1566  struct sockaddr_storage addr;
1567  int port, ttl;
1568 
1569  if (reply->transports[0].destination.ss_family) {
1570  addr = reply->transports[0].destination;
1571  port = reply->transports[0].port_min;
1572  ttl = reply->transports[0].ttl;
1573  } else {
1574  addr = rtsp_st->sdp_ip;
1575  port = rtsp_st->sdp_port;
1576  ttl = rtsp_st->sdp_ttl;
1577  }
1578  if (ttl > 0)
1579  snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1580  getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1581  namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1582  ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1583  port, "%s", optbuf);
1584  if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
1585  &s->interrupt_callback, NULL) < 0) {
1586  err = AVERROR_INVALIDDATA;
1587  goto fail;
1588  }
1589  break;
1590  }
1591  }
1592 
1593  if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
1594  goto fail;
1595  }
1596 
1597  if (rt->nb_rtsp_streams && reply->timeout > 0)
1598  rt->timeout = reply->timeout;
1599 
1600  if (rt->server_type == RTSP_SERVER_REAL)
1601  rt->need_subscription = 1;
1602 
1603  return 0;
1604 
1605 fail:
1606  ff_rtsp_undo_setup(s, 0);
1607  return err;
1608 }
1609 
1611 {
1612  RTSPState *rt = s->priv_data;
1613  if (rt->rtsp_hd_out != rt->rtsp_hd) ffurl_close(rt->rtsp_hd_out);
1614  ffurl_close(rt->rtsp_hd);
1615  rt->rtsp_hd = rt->rtsp_hd_out = NULL;
1616 }
1617 
1619 {
1620  RTSPState *rt = s->priv_data;
1621  char proto[128], host[1024], path[1024];
1622  char tcpname[1024], cmd[2048], auth[128];
1623  const char *lower_rtsp_proto = "tcp";
1624  int port, err, tcp_fd;
1625  RTSPMessageHeader reply1 = {0}, *reply = &reply1;
1626  int lower_transport_mask = 0;
1627  int default_port = RTSP_DEFAULT_PORT;
1628  char real_challenge[64] = "";
1629  struct sockaddr_storage peer;
1630  socklen_t peer_len = sizeof(peer);
1631 
1632  if (rt->rtp_port_max < rt->rtp_port_min) {
1633  av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1634  "than min port %d\n", rt->rtp_port_max,
1635  rt->rtp_port_min);
1636  return AVERROR(EINVAL);
1637  }
1638 
1639  if (!ff_network_init())
1640  return AVERROR(EIO);
1641 
1642  if (s->max_delay < 0) /* Not set by the caller */
1644 
1649  }
1650  /* Only pass through valid flags from here */
1652 
1653 redirect:
1654  /* extract hostname and port */
1655  av_url_split(proto, sizeof(proto), auth, sizeof(auth),
1656  host, sizeof(host), &port, path, sizeof(path), s->filename);
1657 
1658  if (!strcmp(proto, "rtsps")) {
1659  lower_rtsp_proto = "tls";
1660  default_port = RTSPS_DEFAULT_PORT;
1662  }
1663 
1664  if (*auth) {
1665  av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1666  }
1667  if (port < 0)
1668  port = default_port;
1669 
1670  lower_transport_mask = rt->lower_transport_mask;
1671 
1672  if (!lower_transport_mask)
1673  lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1674 
1675  if (s->oformat) {
1676  /* Only UDP or TCP - UDP multicast isn't supported. */
1677  lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1678  (1 << RTSP_LOWER_TRANSPORT_TCP);
1679  if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1680  av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1681  "only UDP and TCP are supported for output.\n");
1682  err = AVERROR(EINVAL);
1683  goto fail;
1684  }
1685  }
1686 
1687  /* Construct the URI used in request; this is similar to s->filename,
1688  * but with authentication credentials removed and RTSP specific options
1689  * stripped out. */
1690  ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
1691  host, port, "%s", path);
1692 
1693  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1694  /* set up initial handshake for tunneling */
1695  char httpname[1024];
1696  char sessioncookie[17];
1697  char headers[1024];
1698 
1699  ff_url_join(httpname, sizeof(httpname), "http", auth, host, port, "%s", path);
1700  snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1702 
1703  /* GET requests */
1704  if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
1705  &s->interrupt_callback) < 0) {
1706  err = AVERROR(EIO);
1707  goto fail;
1708  }
1709 
1710  /* generate GET headers */
1711  snprintf(headers, sizeof(headers),
1712  "x-sessioncookie: %s\r\n"
1713  "Accept: application/x-rtsp-tunnelled\r\n"
1714  "Pragma: no-cache\r\n"
1715  "Cache-Control: no-cache\r\n",
1716  sessioncookie);
1717  av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
1718 
1719  /* complete the connection */
1720  if (ffurl_connect(rt->rtsp_hd, NULL)) {
1721  err = AVERROR(EIO);
1722  goto fail;
1723  }
1724 
1725  /* POST requests */
1726  if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
1727  &s->interrupt_callback) < 0 ) {
1728  err = AVERROR(EIO);
1729  goto fail;
1730  }
1731 
1732  /* generate POST headers */
1733  snprintf(headers, sizeof(headers),
1734  "x-sessioncookie: %s\r\n"
1735  "Content-Type: application/x-rtsp-tunnelled\r\n"
1736  "Pragma: no-cache\r\n"
1737  "Cache-Control: no-cache\r\n"
1738  "Content-Length: 32767\r\n"
1739  "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1740  sessioncookie);
1741  av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
1742  av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
1743 
1744  /* Initialize the authentication state for the POST session. The HTTP
1745  * protocol implementation doesn't properly handle multi-pass
1746  * authentication for POST requests, since it would require one of
1747  * the following:
1748  * - implementing Expect: 100-continue, which many HTTP servers
1749  * don't support anyway, even less the RTSP servers that do HTTP
1750  * tunneling
1751  * - sending the whole POST data until getting a 401 reply specifying
1752  * what authentication method to use, then resending all that data
1753  * - waiting for potential 401 replies directly after sending the
1754  * POST header (waiting for some unspecified time)
1755  * Therefore, we copy the full auth state, which works for both basic
1756  * and digest. (For digest, we would have to synchronize the nonce
1757  * count variable between the two sessions, if we'd do more requests
1758  * with the original session, though.)
1759  */
1761 
1762  /* complete the connection */
1763  if (ffurl_connect(rt->rtsp_hd_out, NULL)) {
1764  err = AVERROR(EIO);
1765  goto fail;
1766  }
1767  } else {
1768  int ret;
1769  /* open the tcp connection */
1770  ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
1771  host, port,
1772  "?timeout=%d", rt->stimeout);
1773  if ((ret = ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
1774  &s->interrupt_callback, NULL)) < 0) {
1775  err = ret;
1776  goto fail;
1777  }
1778  rt->rtsp_hd_out = rt->rtsp_hd;
1779  }
1780  rt->seq = 0;
1781 
1782  tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1783  if (tcp_fd < 0) {
1784  err = tcp_fd;
1785  goto fail;
1786  }
1787  if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1788  getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1789  NULL, 0, NI_NUMERICHOST);
1790  }
1791 
1792  /* request options supported by the server; this also detects server
1793  * type */
1794  for (rt->server_type = RTSP_SERVER_RTP;;) {
1795  cmd[0] = 0;
1796  if (rt->server_type == RTSP_SERVER_REAL)
1797  av_strlcat(cmd,
1798  /*
1799  * The following entries are required for proper
1800  * streaming from a Realmedia server. They are
1801  * interdependent in some way although we currently
1802  * don't quite understand how. Values were copied
1803  * from mplayer SVN r23589.
1804  * ClientChallenge is a 16-byte ID in hex
1805  * CompanyID is a 16-byte ID in base64
1806  */
1807  "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1808  "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1809  "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1810  "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1811  sizeof(cmd));
1812  ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1813  if (reply->status_code != RTSP_STATUS_OK) {
1815  goto fail;
1816  }
1817 
1818  /* detect server type if not standard-compliant RTP */
1819  if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1821  continue;
1822  } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
1824  } else if (rt->server_type == RTSP_SERVER_REAL)
1825  strcpy(real_challenge, reply->real_challenge);
1826  break;
1827  }
1828 
1829  if (CONFIG_RTSP_DEMUXER && s->iformat)
1830  err = ff_rtsp_setup_input_streams(s, reply);
1831  else if (CONFIG_RTSP_MUXER)
1832  err = ff_rtsp_setup_output_streams(s, host);
1833  else
1834  av_assert0(0);
1835  if (err)
1836  goto fail;
1837 
1838  do {
1839  int lower_transport = ff_log2_tab[lower_transport_mask &
1840  ~(lower_transport_mask - 1)];
1841 
1842  if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
1843  && (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
1844  lower_transport = RTSP_LOWER_TRANSPORT_TCP;
1845 
1846  err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
1847  rt->server_type == RTSP_SERVER_REAL ?
1848  real_challenge : NULL);
1849  if (err < 0)
1850  goto fail;
1851  lower_transport_mask &= ~(1 << lower_transport);
1852  if (lower_transport_mask == 0 && err == 1) {
1853  err = AVERROR(EPROTONOSUPPORT);
1854  goto fail;
1855  }
1856  } while (err);
1857 
1858  rt->lower_transport_mask = lower_transport_mask;
1859  av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
1860  rt->state = RTSP_STATE_IDLE;
1861  rt->seek_timestamp = 0; /* default is to start stream at position zero */
1862  return 0;
1863  fail:
1866  if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
1867  av_strlcpy(s->filename, reply->location, sizeof(s->filename));
1868  rt->session_id[0] = '\0';
1869  av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
1870  reply->status_code,
1871  s->filename);
1872  goto redirect;
1873  }
1874  ff_network_close();
1875  return err;
1876 }
1877 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
1878 
1879 #if CONFIG_RTPDEC
1880 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
1881  uint8_t *buf, int buf_size, int64_t wait_end)
1882 {
1883  RTSPState *rt = s->priv_data;
1884  RTSPStream *rtsp_st;
1885  int n, i, ret, tcp_fd, timeout_cnt = 0;
1886  int max_p = 0;
1887  struct pollfd *p = rt->p;
1888  int *fds = NULL, fdsnum, fdsidx;
1889 
1890  for (;;) {
1892  return AVERROR_EXIT;
1893  if (wait_end && wait_end - av_gettime_relative() < 0)
1894  return AVERROR(EAGAIN);
1895  max_p = 0;
1896  if (rt->rtsp_hd) {
1897  tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1898  p[max_p].fd = tcp_fd;
1899  p[max_p++].events = POLLIN;
1900  } else {
1901  tcp_fd = -1;
1902  }
1903  for (i = 0; i < rt->nb_rtsp_streams; i++) {
1904  rtsp_st = rt->rtsp_streams[i];
1905  if (rtsp_st->rtp_handle) {
1906  if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
1907  &fds, &fdsnum)) {
1908  av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
1909  return ret;
1910  }
1911  if (fdsnum != 2) {
1912  av_log(s, AV_LOG_ERROR,
1913  "Number of fds %d not supported\n", fdsnum);
1914  return AVERROR_INVALIDDATA;
1915  }
1916  for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
1917  p[max_p].fd = fds[fdsidx];
1918  p[max_p++].events = POLLIN;
1919  }
1920  av_freep(&fds);
1921  }
1922  }
1923  n = poll(p, max_p, POLL_TIMEOUT_MS);
1924  if (n > 0) {
1925  int j = 1 - (tcp_fd == -1);
1926  timeout_cnt = 0;
1927  for (i = 0; i < rt->nb_rtsp_streams; i++) {
1928  rtsp_st = rt->rtsp_streams[i];
1929  if (rtsp_st->rtp_handle) {
1930  if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
1931  ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
1932  if (ret > 0) {
1933  *prtsp_st = rtsp_st;
1934  return ret;
1935  }
1936  }
1937  j+=2;
1938  }
1939  }
1940 #if CONFIG_RTSP_DEMUXER
1941  if (tcp_fd != -1 && p[0].revents & POLLIN) {
1942  if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
1943  if (rt->state == RTSP_STATE_STREAMING) {
1945  return AVERROR_EOF;
1946  else
1948  "Unable to answer to TEARDOWN\n");
1949  } else
1950  return 0;
1951  } else {
1952  RTSPMessageHeader reply;
1953  ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
1954  if (ret < 0)
1955  return ret;
1956  /* XXX: parse message */
1957  if (rt->state != RTSP_STATE_STREAMING)
1958  return 0;
1959  }
1960  }
1961 #endif
1962  } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
1963  return AVERROR(ETIMEDOUT);
1964  } else if (n < 0 && errno != EINTR)
1965  return AVERROR(errno);
1966  }
1967 }
1968 
1969 static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
1970  const uint8_t *buf, int len)
1971 {
1972  RTSPState *rt = s->priv_data;
1973  int i;
1974  if (len < 0)
1975  return len;
1976  if (rt->nb_rtsp_streams == 1) {
1977  *rtsp_st = rt->rtsp_streams[0];
1978  return len;
1979  }
1980  if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
1981  if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
1982  int no_ssrc = 0;
1983  for (i = 0; i < rt->nb_rtsp_streams; i++) {
1984  RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
1985  if (!rtpctx)
1986  continue;
1987  if (rtpctx->ssrc == AV_RB32(&buf[4])) {
1988  *rtsp_st = rt->rtsp_streams[i];
1989  return len;
1990  }
1991  if (!rtpctx->ssrc)
1992  no_ssrc = 1;
1993  }
1994  if (no_ssrc) {
1996  "Unable to pick stream for packet - SSRC not known for "
1997  "all streams\n");
1998  return AVERROR(EAGAIN);
1999  }
2000  } else {
2001  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2002  if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
2003  *rtsp_st = rt->rtsp_streams[i];
2004  return len;
2005  }
2006  }
2007  }
2008  }
2009  av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
2010  return AVERROR(EAGAIN);
2011 }
2012 
2014 {
2015  RTSPState *rt = s->priv_data;
2016  int ret, len;
2017  RTSPStream *rtsp_st, *first_queue_st = NULL;
2018  int64_t wait_end = 0;
2019 
2020  if (rt->nb_byes == rt->nb_rtsp_streams)
2021  return AVERROR_EOF;
2022 
2023  /* get next frames from the same RTP packet */
2024  if (rt->cur_transport_priv) {
2025  if (rt->transport == RTSP_TRANSPORT_RDT) {
2026  ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2027  } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2028  ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2029  } else if (CONFIG_RTPDEC && rt->ts) {
2030  ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
2031  if (ret >= 0) {
2032  rt->recvbuf_pos += ret;
2033  ret = rt->recvbuf_pos < rt->recvbuf_len;
2034  }
2035  } else
2036  ret = -1;
2037  if (ret == 0) {
2038  rt->cur_transport_priv = NULL;
2039  return 0;
2040  } else if (ret == 1) {
2041  return 0;
2042  } else
2043  rt->cur_transport_priv = NULL;
2044  }
2045 
2046 redo:
2047  if (rt->transport == RTSP_TRANSPORT_RTP) {
2048  int i;
2049  int64_t first_queue_time = 0;
2050  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2051  RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2052  int64_t queue_time;
2053  if (!rtpctx)
2054  continue;
2055  queue_time = ff_rtp_queued_packet_time(rtpctx);
2056  if (queue_time && (queue_time - first_queue_time < 0 ||
2057  !first_queue_time)) {
2058  first_queue_time = queue_time;
2059  first_queue_st = rt->rtsp_streams[i];
2060  }
2061  }
2062  if (first_queue_time) {
2063  wait_end = first_queue_time + s->max_delay;
2064  } else {
2065  wait_end = 0;
2066  first_queue_st = NULL;
2067  }
2068  }
2069 
2070  /* read next RTP packet */
2071  if (!rt->recvbuf) {
2073  if (!rt->recvbuf)
2074  return AVERROR(ENOMEM);
2075  }
2076 
2077  switch(rt->lower_transport) {
2078  default:
2079 #if CONFIG_RTSP_DEMUXER
2081  len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
2082  break;
2083 #endif
2086  len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2087  if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2088  ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);
2089  break;
2091  if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2092  wait_end && wait_end < av_gettime_relative())
2093  len = AVERROR(EAGAIN);
2094  else
2095  len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
2096  len = pick_stream(s, &rtsp_st, rt->recvbuf, len);
2097  if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2099  break;
2100  }
2101  if (len == AVERROR(EAGAIN) && first_queue_st &&
2102  rt->transport == RTSP_TRANSPORT_RTP) {
2103  rtsp_st = first_queue_st;
2104  ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
2105  goto end;
2106  }
2107  if (len < 0)
2108  return len;
2109  if (len == 0)
2110  return AVERROR_EOF;
2111  if (rt->transport == RTSP_TRANSPORT_RDT) {
2112  ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2113  } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2114  ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2115  if (rtsp_st->feedback) {
2116  AVIOContext *pb = NULL;
2118  pb = s->pb;
2119  ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
2120  }
2121  if (ret < 0) {
2122  /* Either bad packet, or a RTCP packet. Check if the
2123  * first_rtcp_ntp_time field was initialized. */
2124  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
2125  if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
2126  /* first_rtcp_ntp_time has been initialized for this stream,
2127  * copy the same value to all other uninitialized streams,
2128  * in order to map their timestamp origin to the same ntp time
2129  * as this one. */
2130  int i;
2131  AVStream *st = NULL;
2132  if (rtsp_st->stream_index >= 0)
2133  st = s->streams[rtsp_st->stream_index];
2134  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2135  RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2136  AVStream *st2 = NULL;
2137  if (rt->rtsp_streams[i]->stream_index >= 0)
2138  st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2139  if (rtpctx2 && st && st2 &&
2140  rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
2141  rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2142  rtpctx2->rtcp_ts_offset = av_rescale_q(
2143  rtpctx->rtcp_ts_offset, st->time_base,
2144  st2->time_base);
2145  }
2146  }
2147  // Make real NTP start time available in AVFormatContext
2148  if (s->start_time_realtime == AV_NOPTS_VALUE) {
2149  s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32);
2150  if (rtpctx->st) {
2151  s->start_time_realtime -=
2152  av_rescale (rtpctx->rtcp_ts_offset,
2153  (uint64_t) rtpctx->st->time_base.num * 1000000,
2154  rtpctx->st->time_base.den);
2155  }
2156  }
2157  }
2158  if (ret == -RTCP_BYE) {
2159  rt->nb_byes++;
2160 
2161  av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2162  rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2163 
2164  if (rt->nb_byes == rt->nb_rtsp_streams)
2165  return AVERROR_EOF;
2166  }
2167  }
2168  } else if (CONFIG_RTPDEC && rt->ts) {
2169  ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
2170  if (ret >= 0) {
2171  if (ret < len) {
2172  rt->recvbuf_len = len;
2173  rt->recvbuf_pos = ret;
2174  rt->cur_transport_priv = rt->ts;
2175  return 1;
2176  } else {
2177  ret = 0;
2178  }
2179  }
2180  } else {
2181  return AVERROR_INVALIDDATA;
2182  }
2183 end:
2184  if (ret < 0)
2185  goto redo;
2186  if (ret == 1)
2187  /* more packets may follow, so we save the RTP context */
2188  rt->cur_transport_priv = rtsp_st->transport_priv;
2189 
2190  return ret;
2191 }
2192 #endif /* CONFIG_RTPDEC */
2193 
2194 #if CONFIG_SDP_DEMUXER
2195 static int sdp_probe(AVProbeData *p1)
2196 {
2197  const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2198 
2199  /* we look for a line beginning "c=IN IP" */
2200  while (p < p_end && *p != '\0') {
2201  if (p + sizeof("c=IN IP") - 1 < p_end &&
2202  av_strstart(p, "c=IN IP", NULL))
2203  return AVPROBE_SCORE_EXTENSION;
2204 
2205  while (p < p_end - 1 && *p != '\n') p++;
2206  if (++p >= p_end)
2207  break;
2208  if (*p == '\r')
2209  p++;
2210  }
2211  return 0;
2212 }
2213 
2214 static void append_source_addrs(char *buf, int size, const char *name,
2215  int count, struct RTSPSource **addrs)
2216 {
2217  int i;
2218  if (!count)
2219  return;
2220  av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
2221  for (i = 1; i < count; i++)
2222  av_strlcatf(buf, size, ",%s", addrs[i]->addr);
2223 }
2224 
2225 static int sdp_read_header(AVFormatContext *s)
2226 {
2227  RTSPState *rt = s->priv_data;
2228  RTSPStream *rtsp_st;
2229  int size, i, err;
2230  char *content;
2231  char url[1024];
2232 
2233  if (!ff_network_init())
2234  return AVERROR(EIO);
2235 
2236  if (s->max_delay < 0) /* Not set by the caller */
2238  if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2240 
2241  /* read the whole sdp file */
2242  /* XXX: better loading */
2243  content = av_malloc(SDP_MAX_SIZE);
2244  size = avio_read(s->pb, content, SDP_MAX_SIZE - 1);
2245  if (size <= 0) {
2246  av_free(content);
2247  return AVERROR_INVALIDDATA;
2248  }
2249  content[size] ='\0';
2250 
2251  err = ff_sdp_parse(s, content);
2252  av_freep(&content);
2253  if (err) goto fail;
2254 
2255  /* open each RTP stream */
2256  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2257  char namebuf[50];
2258  rtsp_st = rt->rtsp_streams[i];
2259 
2260  if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2261  getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip, sizeof(rtsp_st->sdp_ip),
2262  namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2263  ff_url_join(url, sizeof(url), "rtp", NULL,
2264  namebuf, rtsp_st->sdp_port,
2265  "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2266  rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2267  rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2268  rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2269 
2270  append_source_addrs(url, sizeof(url), "sources",
2271  rtsp_st->nb_include_source_addrs,
2272  rtsp_st->include_source_addrs);
2273  append_source_addrs(url, sizeof(url), "block",
2274  rtsp_st->nb_exclude_source_addrs,
2275  rtsp_st->exclude_source_addrs);
2276  if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
2277  &s->interrupt_callback, NULL) < 0) {
2278  err = AVERROR_INVALIDDATA;
2279  goto fail;
2280  }
2281  }
2282  if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2283  goto fail;
2284  }
2285  return 0;
2286 fail:
2288  ff_network_close();
2289  return err;
2290 }
2291 
2292 static int sdp_read_close(AVFormatContext *s)
2293 {
2295  ff_network_close();
2296  return 0;
2297 }
2298 
2299 static const AVClass sdp_demuxer_class = {
2300  .class_name = "SDP demuxer",
2301  .item_name = av_default_item_name,
2302  .option = sdp_options,
2303  .version = LIBAVUTIL_VERSION_INT,
2304 };
2305 
2306 AVInputFormat ff_sdp_demuxer = {
2307  .name = "sdp",
2308  .long_name = NULL_IF_CONFIG_SMALL("SDP"),
2309  .priv_data_size = sizeof(RTSPState),
2310  .read_probe = sdp_probe,
2311  .read_header = sdp_read_header,
2313  .read_close = sdp_read_close,
2314  .priv_class = &sdp_demuxer_class,
2315 };
2316 #endif /* CONFIG_SDP_DEMUXER */
2317 
2318 #if CONFIG_RTP_DEMUXER
2319 static int rtp_probe(AVProbeData *p)
2320 {
2321  if (av_strstart(p->filename, "rtp:", NULL))
2322  return AVPROBE_SCORE_MAX;
2323  return 0;
2324 }
2325 
2326 static int rtp_read_header(AVFormatContext *s)
2327 {
2328  uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2329  char host[500], sdp[500];
2330  int ret, port;
2331  URLContext* in = NULL;
2332  int payload_type;
2333  AVCodecContext codec = { 0 };
2334  struct sockaddr_storage addr;
2335  AVIOContext pb;
2336  socklen_t addrlen = sizeof(addr);
2337  RTSPState *rt = s->priv_data;
2338 
2339  if (!ff_network_init())
2340  return AVERROR(EIO);
2341 
2342  ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ,
2343  &s->interrupt_callback, NULL);
2344  if (ret)
2345  goto fail;
2346 
2347  while (1) {
2348  ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2349  if (ret == AVERROR(EAGAIN))
2350  continue;
2351  if (ret < 0)
2352  goto fail;
2353  if (ret < 12) {
2354  av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2355  continue;
2356  }
2357 
2358  if ((recvbuf[0] & 0xc0) != 0x80) {
2359  av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2360  "received\n");
2361  continue;
2362  }
2363 
2364  if (RTP_PT_IS_RTCP(recvbuf[1]))
2365  continue;
2366 
2367  payload_type = recvbuf[1] & 0x7f;
2368  break;
2369  }
2370  getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2371  ffurl_close(in);
2372  in = NULL;
2373 
2374  if (ff_rtp_get_codec_info(&codec, payload_type)) {
2375  av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2376  "without an SDP file describing it\n",
2377  payload_type);
2378  goto fail;
2379  }
2380  if (codec.codec_type != AVMEDIA_TYPE_DATA) {
2381  av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2382  "properly you need an SDP file "
2383  "describing it\n");
2384  }
2385 
2386  av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2387  NULL, 0, s->filename);
2388 
2389  snprintf(sdp, sizeof(sdp),
2390  "v=0\r\nc=IN IP%d %s\r\nm=%s %d RTP/AVP %d\r\n",
2391  addr.ss_family == AF_INET ? 4 : 6, host,
2392  codec.codec_type == AVMEDIA_TYPE_DATA ? "application" :
2393  codec.codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2394  port, payload_type);
2395  av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
2396 
2397  ffio_init_context(&pb, sdp, strlen(sdp), 0, NULL, NULL, NULL, NULL);
2398  s->pb = &pb;
2399 
2400  /* sdp_read_header initializes this again */
2401  ff_network_close();
2402 
2403  rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;
2404 
2405  ret = sdp_read_header(s);
2406  s->pb = NULL;
2407  return ret;
2408 
2409 fail:
2410  if (in)
2411  ffurl_close(in);
2412  ff_network_close();
2413  return ret;
2414 }
2415 
2416 static const AVClass rtp_demuxer_class = {
2417  .class_name = "RTP demuxer",
2418  .item_name = av_default_item_name,
2419  .option = rtp_options,
2420  .version = LIBAVUTIL_VERSION_INT,
2421 };
2422 
2423 AVInputFormat ff_rtp_demuxer = {
2424  .name = "rtp",
2425  .long_name = NULL_IF_CONFIG_SMALL("RTP input"),
2426  .priv_data_size = sizeof(RTSPState),
2427  .read_probe = rtp_probe,
2428  .read_header = rtp_read_header,
2430  .read_close = sdp_read_close,
2431  .flags = AVFMT_NOFILE,
2432  .priv_class = &rtp_demuxer_class,
2433 };
2434 #endif /* CONFIG_RTP_DEMUXER */