FFmpeg
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 "config_components.h"
23 
24 #include "libavutil/avassert.h"
25 #include "libavutil/base64.h"
26 #include "libavutil/bprint.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/mathematics.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/parseutils.h"
32 #include "libavutil/random_seed.h"
33 #include "libavutil/dict.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/time.h"
36 #include "libavcodec/codec_desc.h"
37 #include "avformat.h"
38 #include "avio_internal.h"
39 #include "demux.h"
40 
41 #if HAVE_POLL_H
42 #include <poll.h>
43 #endif
44 #include "internal.h"
45 #include "network.h"
46 #include "os_support.h"
47 #include "http.h"
48 #include "rtsp.h"
49 
50 #include "rtpdec.h"
51 #include "rtpproto.h"
52 #include "rdt.h"
53 #include "rtpdec_formats.h"
54 #include "rtpenc_chain.h"
55 #include "url.h"
56 #include "rtpenc.h"
57 #include "mpegts.h"
58 #include "version.h"
59 
60 /* Default timeout values for read packet in seconds */
61 #define READ_PACKET_TIMEOUT_S 10
62 #define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
63 #define DEFAULT_REORDERING_DELAY 100000
64 
65 #define OFFSET(x) offsetof(RTSPState, x)
66 #define DEC AV_OPT_FLAG_DECODING_PARAM
67 #define ENC AV_OPT_FLAG_ENCODING_PARAM
68 
69 #define RTSP_FLAG_OPTS(name, longname) \
70  { name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, .unit = "rtsp_flags" }, \
71  { "filter_src", "only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, .unit = "rtsp_flags" }
72 
73 #define RTSP_MEDIATYPE_OPTS(name, longname) \
74  { name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1 }, INT_MIN, INT_MAX, DEC, .unit = "allowed_media_types" }, \
75  { "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, .unit = "allowed_media_types" }, \
76  { "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, .unit = "allowed_media_types" }, \
77  { "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, .unit = "allowed_media_types" }, \
78  { "subtitle", "Subtitle", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_SUBTITLE}, 0, 0, DEC, .unit = "allowed_media_types" }
79 
80 #define COMMON_OPTS() \
81  { "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 }, \
82  { "buffer_size", "Underlying protocol send/receive buffer size", OFFSET(buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC|ENC }, \
83  { "pkt_size", "Underlying protocol send packet size", OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = 1472 }, -1, INT_MAX, ENC } \
84 
85 
87  { "initial_pause", "do not start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },
88  FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
89  { "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, .unit = "rtsp_transport" }, \
90  { "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, .unit = "rtsp_transport" }, \
91  { "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, .unit = "rtsp_transport" }, \
92  { "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, .unit = "rtsp_transport" },
93  { "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, .unit = "rtsp_transport" },
94  { "https", "HTTPS tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTPS )}, 0, 0, DEC, .unit = "rtsp_transport" },
95  RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),
96  { "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, .unit = "rtsp_flags" },
97  { "prefer_tcp", "try RTP via TCP first, if available", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_PREFER_TCP}, 0, 0, DEC|ENC, .unit = "rtsp_flags" },
98  { "satip_raw", "export raw MPEG-TS stream instead of demuxing", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_SATIP_RAW}, 0, 0, DEC, .unit = "rtsp_flags" },
99  RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
100  { "min_port", "set minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },
101  { "max_port", "set maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },
102  { "listen_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 },
103  { "timeout", "set timeout (in microseconds) of socket I/O operations", OFFSET(stimeout), AV_OPT_TYPE_INT64, {.i64 = 0}, INT_MIN, INT64_MAX, DEC },
104  COMMON_OPTS(),
105  { "user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },
106  { NULL },
107 };
108 
109 static const AVOption sdp_options[] = {
110  RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
111  { "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, .unit = "rtsp_flags" },
112  { "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, .unit = "rtsp_flags" },
113  { "listen_timeout", "set maximum timeout (in seconds) to wait for incoming connections", OFFSET(stimeout), AV_OPT_TYPE_DURATION, {.i64 = READ_PACKET_TIMEOUT_S*1000000}, INT_MIN, INT64_MAX, DEC },
114  { "localaddr", "local address", OFFSET(localaddr),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
115  RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
116  COMMON_OPTS(),
117  { NULL },
118 };
119 
120 static const AVOption rtp_options[] = {
121  RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
122  { "listen_timeout", "set maximum timeout (in seconds) to wait for incoming connections", OFFSET(stimeout), AV_OPT_TYPE_DURATION, {.i64 = READ_PACKET_TIMEOUT_S*1000000}, INT_MIN, INT64_MAX, DEC },
123  { "localaddr", "local address", OFFSET(localaddr),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
124  RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
125  COMMON_OPTS(),
126  { NULL },
127 };
128 
129 
131 {
133 
134  av_dict_set_int(&opts, "buffer_size", rt->buffer_size, 0);
135  av_dict_set_int(&opts, "pkt_size", rt->pkt_size, 0);
136  if (rt->localaddr && rt->localaddr[0])
137  av_dict_set(&opts, "localaddr", rt->localaddr, 0);
138 
139  return opts;
140 }
141 
142 static void get_word_until_chars(char *buf, int buf_size,
143  const char *sep, const char **pp)
144 {
145  const char *p;
146  char *q;
147 
148  p = *pp;
149  p += strspn(p, SPACE_CHARS);
150  q = buf;
151  while (!strchr(sep, *p) && *p != '\0') {
152  if ((q - buf) < buf_size - 1)
153  *q++ = *p;
154  p++;
155  }
156  if (buf_size > 0)
157  *q = '\0';
158  *pp = p;
159 }
160 
161 static void get_word_sep(char *buf, int buf_size, const char *sep,
162  const char **pp)
163 {
164  if (**pp == '/') (*pp)++;
165  get_word_until_chars(buf, buf_size, sep, pp);
166 }
167 
168 static void get_word(char *buf, int buf_size, const char **pp)
169 {
170  get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
171 }
172 
173 /** Parse a string p in the form of Range:npt=xx-xx, and determine the start
174  * and end time.
175  * Used for seeking in the rtp stream.
176  */
177 static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
178 {
179  char buf[256];
180 
181  p += strspn(p, SPACE_CHARS);
182  if (!av_stristart(p, "npt=", &p))
183  return;
184 
185  *start = AV_NOPTS_VALUE;
186  *end = AV_NOPTS_VALUE;
187 
188  get_word_sep(buf, sizeof(buf), "-", &p);
189  if (av_parse_time(start, buf, 1) < 0)
190  return;
191  if (*p == '-') {
192  p++;
193  get_word_sep(buf, sizeof(buf), "-", &p);
194  if (av_parse_time(end, buf, 1) < 0)
195  av_log(NULL, AV_LOG_DEBUG, "Failed to parse interval end specification '%s'\n", buf);
196  }
197 }
198 
200  const char *buf, struct sockaddr_storage *sock)
201 {
202  struct addrinfo hints = { 0 }, *ai = NULL;
203  int ret;
204 
205  hints.ai_flags = AI_NUMERICHOST;
206  if ((ret = getaddrinfo(buf, NULL, &hints, &ai))) {
207  av_log(s, AV_LOG_ERROR, "getaddrinfo(%s): %s\n",
208  buf,
209  gai_strerror(ret));
210  return -1;
211  }
212  memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
213  freeaddrinfo(ai);
214  return 0;
215 }
216 
217 #if CONFIG_RTPDEC
218 static void init_rtp_handler(const RTPDynamicProtocolHandler *handler,
219  RTSPStream *rtsp_st, AVStream *st)
220 {
221  AVCodecParameters *par = st ? st->codecpar : NULL;
222  if (!handler)
223  return;
224  if (par)
225  par->codec_id = handler->codec_id;
226  rtsp_st->dynamic_handler = handler;
227  if (st)
228  ffstream(st)->need_parsing = handler->need_parsing;
229  if (handler->priv_data_size) {
230  rtsp_st->dynamic_protocol_context = av_mallocz(handler->priv_data_size);
231  if (!rtsp_st->dynamic_protocol_context)
232  rtsp_st->dynamic_handler = NULL;
233  }
234 }
235 
236 static void finalize_rtp_handler_init(AVFormatContext *s, RTSPStream *rtsp_st,
237  AVStream *st)
238 {
239  if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init) {
240  int ret = rtsp_st->dynamic_handler->init(s, st ? st->index : -1,
241  rtsp_st->dynamic_protocol_context);
242  if (ret < 0) {
243  if (rtsp_st->dynamic_protocol_context) {
244  if (rtsp_st->dynamic_handler->close)
245  rtsp_st->dynamic_handler->close(
246  rtsp_st->dynamic_protocol_context);
248  }
249  rtsp_st->dynamic_protocol_context = NULL;
250  rtsp_st->dynamic_handler = NULL;
251  }
252  }
253 }
254 
255 #if CONFIG_RTSP_DEMUXER
256 static int init_satip_stream(AVFormatContext *s)
257 {
258  RTSPState *rt = s->priv_data;
259  RTSPStream *rtsp_st = av_mallocz(sizeof(RTSPStream));
260  if (!rtsp_st)
261  return AVERROR(ENOMEM);
263  &rt->nb_rtsp_streams, rtsp_st);
264 
265  rtsp_st->sdp_payload_type = 33; // MP2T
266  av_strlcpy(rtsp_st->control_url,
267  rt->control_uri, sizeof(rtsp_st->control_url));
268 
269  if (rt->rtsp_flags & RTSP_FLAG_SATIP_RAW) {
271  if (!st)
272  return AVERROR(ENOMEM);
273  st->id = rt->nb_rtsp_streams - 1;
274  rtsp_st->stream_index = st->index;
277  } else {
278  rtsp_st->stream_index = -1;
279  init_rtp_handler(&ff_mpegts_dynamic_handler, rtsp_st, NULL);
280  finalize_rtp_handler_init(s, rtsp_st, NULL);
281  }
282  return 0;
283 }
284 #endif
285 
286 /* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
287 static int sdp_parse_rtpmap(AVFormatContext *s,
288  AVStream *st, RTSPStream *rtsp_st,
289  int payload_type, const char *p)
290 {
291  AVCodecParameters *par = st->codecpar;
292  char buf[256];
293  int i;
294  const AVCodecDescriptor *desc;
295  const char *c_name;
296 
297  /* See if we can handle this kind of payload.
298  * The space should normally not be there but some Real streams or
299  * particular servers ("RealServer Version 6.1.3.970", see issue 1658)
300  * have a trailing space. */
301  get_word_sep(buf, sizeof(buf), "/ ", &p);
302  if (payload_type < RTP_PT_PRIVATE) {
303  /* We are in a standard case
304  * (from http://www.iana.org/assignments/rtp-parameters). */
305  par->codec_id = ff_rtp_codec_id(buf, par->codec_type);
306  }
307 
308  if (par->codec_id == AV_CODEC_ID_NONE) {
311  init_rtp_handler(handler, rtsp_st, st);
312  /* If no dynamic handler was found, check with the list of standard
313  * allocated types, if such a stream for some reason happens to
314  * use a private payload type. This isn't handled in rtpdec.c, since
315  * the format name from the rtpmap line never is passed into rtpdec. */
316  if (!rtsp_st->dynamic_handler)
317  par->codec_id = ff_rtp_codec_id(buf, par->codec_type);
318  }
319 
321  if (desc && desc->name)
322  c_name = desc->name;
323  else
324  c_name = "(null)";
325 
326  get_word_sep(buf, sizeof(buf), "/", &p);
327  i = atoi(buf);
328  switch (par->codec_type) {
329  case AVMEDIA_TYPE_AUDIO:
330  av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
333  if (i > 0) {
334  par->sample_rate = i;
335  avpriv_set_pts_info(st, 32, 1, par->sample_rate);
336  get_word_sep(buf, sizeof(buf), "/", &p);
337  i = atoi(buf);
338  if (i > 0)
340  }
341  av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
342  par->sample_rate);
343  av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
344  par->ch_layout.nb_channels);
345  break;
346  case AVMEDIA_TYPE_VIDEO:
347  av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
348  if (i > 0)
349  avpriv_set_pts_info(st, 32, 1, i);
350  break;
351  default:
352  break;
353  }
354  finalize_rtp_handler_init(s, rtsp_st, st);
355  return 0;
356 }
357 
358 /* parse the attribute line from the fmtp a line of an sdp response. This
359  * is broken out as a function because it is used in rtp_h264.c, which is
360  * forthcoming. */
361 int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
362  char *value, int value_size)
363 {
364  *p += strspn(*p, SPACE_CHARS);
365  if (**p) {
366  get_word_sep(attr, attr_size, "=", p);
367  if (**p == '=')
368  (*p)++;
369  get_word_sep(value, value_size, ";", p);
370  if (**p == ';')
371  (*p)++;
372  return 1;
373  }
374  return 0;
375 }
376 
377 typedef struct SDPParseState {
378  /* SDP only */
379  struct sockaddr_storage default_ip;
380  int default_ttl;
381  int skip_media; ///< set if an unknown m= line occurs
382  int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */
383  struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */
384  int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
385  struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */
386  int seen_rtpmap;
387  int seen_fmtp;
388  char delayed_fmtp[2048];
389 } SDPParseState;
390 
391 static void copy_default_source_addrs(struct RTSPSource **addrs, int count,
392  struct RTSPSource ***dest, int *dest_count)
393 {
394  RTSPSource *rtsp_src, *rtsp_src2;
395  int i;
396  for (i = 0; i < count; i++) {
397  rtsp_src = addrs[i];
398  rtsp_src2 = av_memdup(rtsp_src, sizeof(*rtsp_src));
399  if (!rtsp_src2)
400  continue;
401  dynarray_add(dest, dest_count, rtsp_src2);
402  }
403 }
404 
405 static void parse_fmtp(AVFormatContext *s, RTSPState *rt,
406  int payload_type, const char *line)
407 {
408  int i;
409 
410  for (i = 0; i < rt->nb_rtsp_streams; i++) {
411  RTSPStream *rtsp_st = rt->rtsp_streams[i];
412  if (rtsp_st->sdp_payload_type == payload_type &&
413  rtsp_st->dynamic_handler &&
414  rtsp_st->dynamic_handler->parse_sdp_a_line) {
415  rtsp_st->dynamic_handler->parse_sdp_a_line(s, rtsp_st->stream_index,
416  rtsp_st->dynamic_protocol_context, line);
417  }
418  }
419 }
420 
421 static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
422  int letter, const char *buf)
423 {
424  RTSPState *rt = s->priv_data;
425  char buf1[64], st_type[64];
426  const char *p;
427  enum AVMediaType codec_type;
428  int payload_type;
429  AVStream *st;
430  RTSPStream *rtsp_st;
431  RTSPSource *rtsp_src;
432  struct sockaddr_storage sdp_ip;
433  int ttl;
434 
435  av_log(s, AV_LOG_TRACE, "sdp: %c='%s'\n", letter, buf);
436 
437  p = buf;
438  if (s1->skip_media && letter != 'm')
439  return;
440  switch (letter) {
441  case 'c':
442  get_word(buf1, sizeof(buf1), &p);
443  if (strcmp(buf1, "IN") != 0)
444  return;
445  get_word(buf1, sizeof(buf1), &p);
446  if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
447  return;
448  get_word_sep(buf1, sizeof(buf1), "/", &p);
449  if (get_sockaddr(s, buf1, &sdp_ip))
450  return;
451  ttl = 16;
452  if (*p == '/') {
453  p++;
454  get_word_sep(buf1, sizeof(buf1), "/", &p);
455  ttl = atoi(buf1);
456  }
457  if (s->nb_streams == 0) {
458  s1->default_ip = sdp_ip;
459  s1->default_ttl = ttl;
460  } else {
461  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
462  rtsp_st->sdp_ip = sdp_ip;
463  rtsp_st->sdp_ttl = ttl;
464  }
465  break;
466  case 's':
467  av_dict_set(&s->metadata, "title", p, 0);
468  break;
469  case 'i':
470  if (s->nb_streams == 0) {
471  av_dict_set(&s->metadata, "comment", p, 0);
472  break;
473  }
474  break;
475  case 'm':
476  /* new stream */
477  s1->skip_media = 0;
478  s1->seen_fmtp = 0;
479  s1->seen_rtpmap = 0;
481  get_word(st_type, sizeof(st_type), &p);
482  if (!strcmp(st_type, "audio")) {
484  } else if (!strcmp(st_type, "video")) {
486  } else if (!strcmp(st_type, "application")) {
488  } else if (!strcmp(st_type, "text")) {
490  }
492  !(rt->media_type_mask & (1 << codec_type)) ||
493  rt->nb_rtsp_streams >= s->max_streams
494  ) {
495  s1->skip_media = 1;
496  return;
497  }
498  rtsp_st = av_mallocz(sizeof(RTSPStream));
499  if (!rtsp_st)
500  return;
501  rtsp_st->stream_index = -1;
502  dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
503 
504  rtsp_st->sdp_ip = s1->default_ip;
505  rtsp_st->sdp_ttl = s1->default_ttl;
506 
507  copy_default_source_addrs(s1->default_include_source_addrs,
508  s1->nb_default_include_source_addrs,
509  &rtsp_st->include_source_addrs,
510  &rtsp_st->nb_include_source_addrs);
511  copy_default_source_addrs(s1->default_exclude_source_addrs,
512  s1->nb_default_exclude_source_addrs,
513  &rtsp_st->exclude_source_addrs,
514  &rtsp_st->nb_exclude_source_addrs);
515 
516  get_word(buf1, sizeof(buf1), &p); /* port */
517  rtsp_st->sdp_port = atoi(buf1);
518 
519  get_word(buf1, sizeof(buf1), &p); /* protocol */
520  if (!strcmp(buf1, "udp"))
522  else if (strstr(buf1, "/AVPF") || strstr(buf1, "/SAVPF"))
523  rtsp_st->feedback = 1;
524 
525  /* XXX: handle list of formats */
526  get_word(buf1, sizeof(buf1), &p); /* format list */
527  rtsp_st->sdp_payload_type = atoi(buf1);
528 
529  if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
530  /* no corresponding stream */
531  if (rt->transport == RTSP_TRANSPORT_RAW) {
532  if (CONFIG_RTPDEC && !rt->ts)
534  } else {
538  init_rtp_handler(handler, rtsp_st, NULL);
539  finalize_rtp_handler_init(s, rtsp_st, NULL);
540  }
541  } else if (rt->server_type == RTSP_SERVER_WMS &&
543  /* RTX stream, a stream that carries all the other actual
544  * audio/video streams. Don't expose this to the callers. */
545  } else {
546  st = avformat_new_stream(s, NULL);
547  if (!st)
548  return;
549  st->id = rt->nb_rtsp_streams - 1;
550  rtsp_st->stream_index = st->index;
552  if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
554  /* if standard payload type, we can find the codec right now */
556  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
557  st->codecpar->sample_rate > 0)
558  avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
559  /* Even static payload types may need a custom depacketizer */
561  rtsp_st->sdp_payload_type, st->codecpar->codec_type);
562  init_rtp_handler(handler, rtsp_st, st);
563  finalize_rtp_handler_init(s, rtsp_st, st);
564  }
565  if (rt->default_lang[0])
566  av_dict_set(&st->metadata, "language", rt->default_lang, 0);
567  }
568  /* put a default control url */
569  av_strlcpy(rtsp_st->control_url, rt->control_uri,
570  sizeof(rtsp_st->control_url));
571  break;
572  case 'a':
573  if (av_strstart(p, "control:", &p)) {
574  if (rt->nb_rtsp_streams == 0) {
575  if (!strncmp(p, "rtsp://", 7))
576  av_strlcpy(rt->control_uri, p,
577  sizeof(rt->control_uri));
578  } else {
579  char proto[32];
580  /* get the control url */
581  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
582 
583  /* XXX: may need to add full url resolution */
584  av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
585  NULL, NULL, 0, p);
586  if (proto[0] == '\0') {
587  /* relative control URL */
588  if (rtsp_st->control_url[strlen(rtsp_st->control_url)-1]!='/')
589  av_strlcat(rtsp_st->control_url, "/",
590  sizeof(rtsp_st->control_url));
591  av_strlcat(rtsp_st->control_url, p,
592  sizeof(rtsp_st->control_url));
593  } else
594  av_strlcpy(rtsp_st->control_url, p,
595  sizeof(rtsp_st->control_url));
596  }
597  } else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
598  /* NOTE: rtpmap is only supported AFTER the 'm=' tag */
599  get_word(buf1, sizeof(buf1), &p);
600  payload_type = atoi(buf1);
601  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
602  if (rtsp_st->stream_index >= 0) {
603  st = s->streams[rtsp_st->stream_index];
604  sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
605  }
606  s1->seen_rtpmap = 1;
607  if (s1->seen_fmtp) {
608  parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);
609  }
610  } else if (av_strstart(p, "fmtp:", &p) ||
611  av_strstart(p, "framesize:", &p)) {
612  // let dynamic protocol handlers have a stab at the line.
613  get_word(buf1, sizeof(buf1), &p);
614  payload_type = atoi(buf1);
615  if (s1->seen_rtpmap) {
616  parse_fmtp(s, rt, payload_type, buf);
617  } else {
618  s1->seen_fmtp = 1;
619  av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp));
620  }
621  } else if (av_strstart(p, "ssrc:", &p) && s->nb_streams > 0) {
622  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
623  get_word(buf1, sizeof(buf1), &p);
624  rtsp_st->ssrc = strtoll(buf1, NULL, 10);
625  } else if (av_strstart(p, "range:", &p)) {
626  int64_t start, end;
627 
628  // this is so that seeking on a streamed file can work.
629  rtsp_parse_range_npt(p, &start, &end);
630  s->start_time = start;
631  /* AV_NOPTS_VALUE means live broadcast (and can't seek) */
632  s->duration = (end == AV_NOPTS_VALUE) ?
633  AV_NOPTS_VALUE : end - start;
634  } else if (av_strstart(p, "lang:", &p)) {
635  if (s->nb_streams > 0) {
636  get_word(buf1, sizeof(buf1), &p);
637  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
638  if (rtsp_st->stream_index >= 0) {
639  st = s->streams[rtsp_st->stream_index];
640  av_dict_set(&st->metadata, "language", buf1, 0);
641  }
642  } else
643  get_word(rt->default_lang, sizeof(rt->default_lang), &p);
644  } else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
645  if (atoi(p) == 1)
647  } else if (av_strstart(p, "SampleRate:integer;", &p) &&
648  s->nb_streams > 0) {
649  st = s->streams[s->nb_streams - 1];
650  st->codecpar->sample_rate = atoi(p);
651  } else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {
652  // RFC 4568
653  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
654  get_word(buf1, sizeof(buf1), &p); // ignore tag
655  get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);
656  p += strspn(p, SPACE_CHARS);
657  if (av_strstart(p, "inline:", &p))
658  get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);
659  } else if (av_strstart(p, "source-filter:", &p)) {
660  int exclude = 0;
661  get_word(buf1, sizeof(buf1), &p);
662  if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))
663  return;
664  exclude = !strcmp(buf1, "excl");
665 
666  get_word(buf1, sizeof(buf1), &p);
667  if (strcmp(buf1, "IN") != 0)
668  return;
669  get_word(buf1, sizeof(buf1), &p);
670  if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))
671  return;
672  // not checking that the destination address actually matches or is wildcard
673  get_word(buf1, sizeof(buf1), &p);
674 
675  while (*p != '\0') {
676  rtsp_src = av_mallocz(sizeof(*rtsp_src));
677  if (!rtsp_src)
678  return;
679  get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);
680  if (exclude) {
681  if (s->nb_streams == 0) {
682  dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
683  } else {
684  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
685  dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);
686  }
687  } else {
688  if (s->nb_streams == 0) {
689  dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
690  } else {
691  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
692  dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);
693  }
694  }
695  }
696  } else {
697  if (rt->server_type == RTSP_SERVER_WMS)
699  if (s->nb_streams > 0) {
700  rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
701 
702  if (rt->server_type == RTSP_SERVER_REAL)
704 
705  if (rtsp_st->dynamic_handler &&
708  rtsp_st->stream_index,
709  rtsp_st->dynamic_protocol_context, buf);
710  }
711  }
712  break;
713  }
714 }
715 
716 int ff_sdp_parse(AVFormatContext *s, const char *content)
717 {
718  const char *p;
719  int letter, i;
720  char buf[SDP_MAX_SIZE], *q;
721  SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
722 
723  p = content;
724  for (;;) {
725  p += strspn(p, SPACE_CHARS);
726  letter = *p;
727  if (letter == '\0')
728  break;
729  p++;
730  if (*p != '=')
731  goto next_line;
732  p++;
733  /* get the content */
734  q = buf;
735  while (*p != '\n' && *p != '\r' && *p != '\0') {
736  if ((q - buf) < sizeof(buf) - 1)
737  *q++ = *p;
738  p++;
739  }
740  *q = '\0';
741  sdp_parse_line(s, s1, letter, buf);
742  next_line:
743  while (*p != '\n' && *p != '\0')
744  p++;
745  if (*p == '\n')
746  p++;
747  }
748 
749  for (i = 0; i < s1->nb_default_include_source_addrs; i++)
750  av_freep(&s1->default_include_source_addrs[i]);
751  av_freep(&s1->default_include_source_addrs);
752  for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
753  av_freep(&s1->default_exclude_source_addrs[i]);
754  av_freep(&s1->default_exclude_source_addrs);
755 
756  return 0;
757 }
758 #endif /* CONFIG_RTPDEC */
759 
760 void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
761 {
762  RTSPState *rt = s->priv_data;
763  int i;
764 
765  for (i = 0; i < rt->nb_rtsp_streams; i++) {
766  RTSPStream *rtsp_st = rt->rtsp_streams[i];
767  if (!rtsp_st)
768  continue;
769  if (rtsp_st->transport_priv) {
770  if (s->oformat) {
771  AVFormatContext *rtpctx = rtsp_st->transport_priv;
772  av_write_trailer(rtpctx);
774  if (CONFIG_RTSP_MUXER && rtpctx->pb && send_packets)
775  ff_rtsp_tcp_write_packet(s, rtsp_st);
776  ffio_free_dyn_buf(&rtpctx->pb);
777  } else {
778  avio_closep(&rtpctx->pb);
779  }
780  avformat_free_context(rtpctx);
781  } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
783  else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)
785  }
786  rtsp_st->transport_priv = NULL;
787  ffurl_closep(&rtsp_st->rtp_handle);
788  }
789 }
790 
791 /* close and free RTSP streams */
793 {
794  RTSPState *rt = s->priv_data;
795  int i, j;
796  RTSPStream *rtsp_st;
797 
798  ff_rtsp_undo_setup(s, 0);
799  for (i = 0; i < rt->nb_rtsp_streams; i++) {
800  rtsp_st = rt->rtsp_streams[i];
801  if (rtsp_st) {
802  if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) {
803  if (rtsp_st->dynamic_handler->close)
804  rtsp_st->dynamic_handler->close(
805  rtsp_st->dynamic_protocol_context);
807  }
808  for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)
809  av_freep(&rtsp_st->include_source_addrs[j]);
810  av_freep(&rtsp_st->include_source_addrs);
811  for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)
812  av_freep(&rtsp_st->exclude_source_addrs[j]);
813  av_freep(&rtsp_st->exclude_source_addrs);
814 
815  av_freep(&rtsp_st);
816  }
817  }
818  av_freep(&rt->rtsp_streams);
819  if (rt->asf_ctx) {
821  }
822  if (CONFIG_RTPDEC && rt->ts)
824  av_freep(&rt->p);
825  av_freep(&rt->recvbuf);
826 }
827 
829 {
830  RTSPState *rt = s->priv_data;
831  AVStream *st = NULL;
832  int reordering_queue_size = rt->reordering_queue_size;
833  if (reordering_queue_size < 0) {
834  if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
835  reordering_queue_size = 0;
836  else
837  reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
838  }
839 
840  /* open the RTP context */
841  if (rtsp_st->stream_index >= 0)
842  st = s->streams[rtsp_st->stream_index];
843  if (!st)
844  s->ctx_flags |= AVFMTCTX_NOHEADER;
845 
846  if (CONFIG_RTSP_MUXER && s->oformat && st) {
848  s, st, rtsp_st->rtp_handle,
849  rt->pkt_size,
850  rtsp_st->stream_index);
851  /* Ownership of rtp_handle is passed to the rtp mux context */
852  rtsp_st->rtp_handle = NULL;
853  if (ret < 0)
854  return ret;
855  st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
856  } else if (rt->transport == RTSP_TRANSPORT_RAW) {
857  return 0; // Don't need to open any parser here
858  } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT && st)
859  rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
860  rtsp_st->dynamic_protocol_context,
861  rtsp_st->dynamic_handler);
862  else if (CONFIG_RTPDEC)
863  rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
864  rtsp_st->sdp_payload_type,
865  reordering_queue_size);
866 
867  if (!rtsp_st->transport_priv) {
868  return AVERROR(ENOMEM);
869  } else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP &&
870  s->iformat) {
871  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
872  rtpctx->ssrc = rtsp_st->ssrc;
873  if (rtsp_st->dynamic_handler) {
875  rtsp_st->dynamic_protocol_context,
876  rtsp_st->dynamic_handler);
877  }
878  if (rtsp_st->crypto_suite[0])
880  rtsp_st->crypto_suite,
881  rtsp_st->crypto_params);
882  }
883 
884  return 0;
885 }
886 
887 #if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
888 static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
889 {
890  const char *q;
891  char *p;
892  int v;
893 
894  q = *pp;
895  q += strspn(q, SPACE_CHARS);
896  v = strtol(q, &p, 10);
897  if (*p == '-') {
898  p++;
899  *min_ptr = v;
900  v = strtol(p, &p, 10);
901  *max_ptr = v;
902  } else {
903  *min_ptr = v;
904  *max_ptr = v;
905  }
906  *pp = p;
907 }
908 
909 /* XXX: only one transport specification is parsed */
910 static void rtsp_parse_transport(AVFormatContext *s,
911  RTSPMessageHeader *reply, const char *p)
912 {
913  char transport_protocol[16];
914  char profile[16];
915  char lower_transport[16];
916  char parameter[16];
917  RTSPTransportField *th;
918  char buf[256];
919 
920  reply->nb_transports = 0;
921 
922  for (;;) {
923  p += strspn(p, SPACE_CHARS);
924  if (*p == '\0')
925  break;
926 
927  th = &reply->transports[reply->nb_transports];
928 
929  get_word_sep(transport_protocol, sizeof(transport_protocol),
930  "/", &p);
931  if (!av_strcasecmp (transport_protocol, "rtp")) {
932  get_word_sep(profile, sizeof(profile), "/;,", &p);
933  lower_transport[0] = '\0';
934  /* rtp/avp/<protocol> */
935  if (*p == '/') {
936  get_word_sep(lower_transport, sizeof(lower_transport),
937  ";,", &p);
938  }
940  } else if (!av_strcasecmp (transport_protocol, "x-pn-tng") ||
941  !av_strcasecmp (transport_protocol, "x-real-rdt")) {
942  /* x-pn-tng/<protocol> */
943  get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
944  profile[0] = '\0';
946  } else if (!av_strcasecmp(transport_protocol, "raw")) {
947  get_word_sep(profile, sizeof(profile), "/;,", &p);
948  lower_transport[0] = '\0';
949  /* raw/raw/<protocol> */
950  if (*p == '/') {
951  get_word_sep(lower_transport, sizeof(lower_transport),
952  ";,", &p);
953  }
955  } else {
956  break;
957  }
958  if (!av_strcasecmp(lower_transport, "TCP"))
960  else
962 
963  if (*p == ';')
964  p++;
965  /* get each parameter */
966  while (*p != '\0' && *p != ',') {
967  get_word_sep(parameter, sizeof(parameter), "=;,", &p);
968  if (!strcmp(parameter, "port")) {
969  if (*p == '=') {
970  p++;
971  rtsp_parse_range(&th->port_min, &th->port_max, &p);
972  }
973  } else if (!strcmp(parameter, "client_port")) {
974  if (*p == '=') {
975  p++;
976  rtsp_parse_range(&th->client_port_min,
977  &th->client_port_max, &p);
978  }
979  } else if (!strcmp(parameter, "server_port")) {
980  if (*p == '=') {
981  p++;
982  rtsp_parse_range(&th->server_port_min,
983  &th->server_port_max, &p);
984  }
985  } else if (!strcmp(parameter, "interleaved")) {
986  if (*p == '=') {
987  p++;
988  rtsp_parse_range(&th->interleaved_min,
989  &th->interleaved_max, &p);
990  }
991  } else if (!strcmp(parameter, "multicast")) {
994  } else if (!strcmp(parameter, "ttl")) {
995  if (*p == '=') {
996  char *end;
997  p++;
998  th->ttl = strtol(p, &end, 10);
999  p = end;
1000  }
1001  } else if (!strcmp(parameter, "destination")) {
1002  if (*p == '=') {
1003  p++;
1004  get_word_sep(buf, sizeof(buf), ";,", &p);
1005  get_sockaddr(s, buf, &th->destination);
1006  }
1007  } else if (!strcmp(parameter, "source")) {
1008  if (*p == '=') {
1009  p++;
1010  get_word_sep(buf, sizeof(buf), ";,", &p);
1011  av_strlcpy(th->source, buf, sizeof(th->source));
1012  }
1013  } else if (!strcmp(parameter, "mode")) {
1014  if (*p == '=') {
1015  p++;
1016  get_word_sep(buf, sizeof(buf), ";, ", &p);
1017  if (!av_strcasecmp(buf, "record") ||
1018  !av_strcasecmp(buf, "receive"))
1019  th->mode_record = 1;
1020  }
1021  }
1022 
1023  while (*p != ';' && *p != '\0' && *p != ',')
1024  p++;
1025  if (*p == ';')
1026  p++;
1027  }
1028  if (*p == ',')
1029  p++;
1030 
1031  reply->nb_transports++;
1032  if (reply->nb_transports >= RTSP_MAX_TRANSPORTS)
1033  break;
1034  }
1035 }
1036 
1037 static void handle_rtp_info(RTSPState *rt, const char *url,
1038  uint32_t seq, uint32_t rtptime)
1039 {
1040  int i;
1041  if (!rtptime || !url[0])
1042  return;
1043  if (rt->transport != RTSP_TRANSPORT_RTP)
1044  return;
1045  for (i = 0; i < rt->nb_rtsp_streams; i++) {
1046  RTSPStream *rtsp_st = rt->rtsp_streams[i];
1047  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1048  if (!rtpctx)
1049  continue;
1050  if (!strcmp(rtsp_st->control_url, url)) {
1051  rtpctx->base_timestamp = rtptime;
1052  break;
1053  }
1054  }
1055 }
1056 
1057 static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
1058 {
1059  int read = 0;
1060  char key[20], value[MAX_URL_SIZE], url[MAX_URL_SIZE] = "";
1061  uint32_t seq = 0, rtptime = 0;
1062 
1063  for (;;) {
1064  p += strspn(p, SPACE_CHARS);
1065  if (!*p)
1066  break;
1067  get_word_sep(key, sizeof(key), "=", &p);
1068  if (*p != '=')
1069  break;
1070  p++;
1071  get_word_sep(value, sizeof(value), ";, ", &p);
1072  read++;
1073  if (!strcmp(key, "url"))
1074  av_strlcpy(url, value, sizeof(url));
1075  else if (!strcmp(key, "seq"))
1076  seq = strtoul(value, NULL, 10);
1077  else if (!strcmp(key, "rtptime"))
1078  rtptime = strtoul(value, NULL, 10);
1079  if (*p == ',') {
1080  handle_rtp_info(rt, url, seq, rtptime);
1081  url[0] = '\0';
1082  seq = rtptime = 0;
1083  read = 0;
1084  }
1085  if (*p)
1086  p++;
1087  }
1088  if (read > 0)
1089  handle_rtp_info(rt, url, seq, rtptime);
1090 }
1091 
1093  RTSPMessageHeader *reply, const char *buf,
1094  RTSPState *rt, const char *method)
1095 {
1096  const char *p;
1097 
1098  /* NOTE: we do case independent match for broken servers */
1099  p = buf;
1100  if (av_stristart(p, "Session:", &p)) {
1101  int t;
1102  get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
1103  if (av_stristart(p, ";timeout=", &p) &&
1104  (t = strtol(p, NULL, 10)) > 0) {
1105  reply->timeout = t;
1106  }
1107  } else if (av_stristart(p, "Content-Length:", &p)) {
1108  reply->content_length = strtol(p, NULL, 10);
1109  } else if (av_stristart(p, "Transport:", &p)) {
1110  rtsp_parse_transport(s, reply, p);
1111  } else if (av_stristart(p, "CSeq:", &p)) {
1112  reply->seq = strtol(p, NULL, 10);
1113  } else if (av_stristart(p, "Range:", &p)) {
1114  rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
1115  } else if (av_stristart(p, "RealChallenge1:", &p)) {
1116  p += strspn(p, SPACE_CHARS);
1117  av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
1118  } else if (av_stristart(p, "Server:", &p)) {
1119  p += strspn(p, SPACE_CHARS);
1120  av_strlcpy(reply->server, p, sizeof(reply->server));
1121  } else if (av_stristart(p, "Notice:", &p) ||
1122  av_stristart(p, "X-Notice:", &p)) {
1123  reply->notice = strtol(p, NULL, 10);
1124  } else if (av_stristart(p, "Location:", &p)) {
1125  p += strspn(p, SPACE_CHARS);
1126  av_strlcpy(reply->location, p , sizeof(reply->location));
1127  } else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
1128  p += strspn(p, SPACE_CHARS);
1129  ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
1130  } else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
1131  p += strspn(p, SPACE_CHARS);
1132  ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
1133  } else if (av_stristart(p, "Content-Base:", &p) && rt) {
1134  p += strspn(p, SPACE_CHARS);
1135  if (method && !strcmp(method, "DESCRIBE"))
1136  av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
1137  } else if (av_stristart(p, "RTP-Info:", &p) && rt) {
1138  p += strspn(p, SPACE_CHARS);
1139  if (method && !strcmp(method, "PLAY"))
1140  rtsp_parse_rtp_info(rt, p);
1141  } else if (av_stristart(p, "Public:", &p) && rt) {
1142  if (strstr(p, "GET_PARAMETER") &&
1143  method && !strcmp(method, "OPTIONS"))
1144  rt->get_parameter_supported = 1;
1145  } else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
1146  p += strspn(p, SPACE_CHARS);
1147  rt->accept_dynamic_rate = atoi(p);
1148  } else if (av_stristart(p, "Content-Type:", &p)) {
1149  p += strspn(p, SPACE_CHARS);
1150  av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
1151  } else if (av_stristart(p, "com.ses.streamID:", &p)) {
1152  p += strspn(p, SPACE_CHARS);
1153  av_strlcpy(reply->stream_id, p, sizeof(reply->stream_id));
1154  }
1155 }
1156 
1157 /* skip a RTP/TCP interleaved packet */
1159 {
1160  RTSPState *rt = s->priv_data;
1161  int ret, len, len1;
1162  uint8_t buf[MAX_URL_SIZE];
1163 
1164  ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
1165  if (ret != 3)
1166  return ret < 0 ? ret : AVERROR(EIO);
1167  len = AV_RB16(buf + 1);
1168 
1169  av_log(s, AV_LOG_TRACE, "skipping RTP packet len=%d\n", len);
1170 
1171  /* skip payload */
1172  while (len > 0) {
1173  len1 = len;
1174  if (len1 > sizeof(buf))
1175  len1 = sizeof(buf);
1176  ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);
1177  if (ret != len1)
1178  return ret < 0 ? ret : AVERROR(EIO);
1179  len -= len1;
1180  }
1181 
1182  return 0;
1183 }
1184 
1186  unsigned char **content_ptr,
1187  int return_on_interleaved_data, const char *method)
1188 {
1189  RTSPState *rt = s->priv_data;
1190  char buf[MAX_URL_SIZE], buf1[MAX_URL_SIZE], *q;
1191  unsigned char ch;
1192  const char *p;
1193  int ret, content_length, line_count, request;
1194  unsigned char *content;
1195 
1196 start:
1197  line_count = 0;
1198  request = 0;
1199  content = NULL;
1200  memset(reply, 0, sizeof(*reply));
1201 
1202  /* parse reply (XXX: use buffers) */
1203  rt->last_reply[0] = '\0';
1204  for (;;) {
1205  q = buf;
1206  for (;;) {
1207  ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
1208  av_log(s, AV_LOG_TRACE, "ret=%d c=%02x [%c]\n", ret, ch, ch);
1209  if (ret != 1)
1210  return ret < 0 ? ret : AVERROR(EIO);
1211  if (ch == '\n')
1212  break;
1213  if (ch == '$' && q == buf) {
1214  if (return_on_interleaved_data) {
1215  return 1;
1216  } else {
1218  if (ret < 0)
1219  return ret;
1220  }
1221  } else if (ch != '\r') {
1222  if ((q - buf) < sizeof(buf) - 1)
1223  *q++ = ch;
1224  }
1225  }
1226  *q = '\0';
1227 
1228  av_log(s, AV_LOG_TRACE, "line='%s'\n", buf);
1229 
1230  /* test if last line */
1231  if (buf[0] == '\0')
1232  break;
1233  p = buf;
1234  if (line_count == 0) {
1235  /* get reply code */
1236  get_word(buf1, sizeof(buf1), &p);
1237  if (!strncmp(buf1, "RTSP/", 5)) {
1238  get_word(buf1, sizeof(buf1), &p);
1239  reply->status_code = atoi(buf1);
1240  av_strlcpy(reply->reason, p, sizeof(reply->reason));
1241  } else {
1242  av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
1243  get_word(buf1, sizeof(buf1), &p); // object
1244  request = 1;
1245  }
1246  } else {
1247  ff_rtsp_parse_line(s, reply, p, rt, method);
1248  av_strlcat(rt->last_reply, p, sizeof(rt->last_reply));
1249  av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
1250  }
1251  line_count++;
1252  }
1253 
1254  if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
1255  av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
1256 
1257  content_length = reply->content_length;
1258  if (content_length > 0) {
1259  /* leave some room for a trailing '\0' (useful for simple parsing) */
1260  content = av_malloc(content_length + 1);
1261  if (!content)
1262  return AVERROR(ENOMEM);
1263  if ((ret = ffurl_read_complete(rt->rtsp_hd, content, content_length)) != content_length) {
1264  av_freep(&content);
1265  return ret < 0 ? ret : AVERROR(EIO);
1266  }
1267  content[content_length] = '\0';
1268  }
1269  if (content_ptr)
1270  *content_ptr = content;
1271  else
1272  av_freep(&content);
1273 
1274  if (request) {
1275  char buf[MAX_URL_SIZE];
1276  char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1277  const char* ptr = buf;
1278 
1279  if (!strcmp(reply->reason, "OPTIONS") ||
1280  !strcmp(reply->reason, "GET_PARAMETER")) {
1281  snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
1282  if (reply->seq)
1283  av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
1284  if (reply->session_id[0])
1285  av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
1286  reply->session_id);
1287  } else {
1288  snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
1289  }
1290  av_strlcat(buf, "\r\n", sizeof(buf));
1291 
1292  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1293  av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1294  ptr = base64buf;
1295  }
1296  ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
1297 
1299  /* Even if the request from the server had data, it is not the data
1300  * that the caller wants or expects. The memory could also be leaked
1301  * if the actual following reply has content data. */
1302  if (content_ptr)
1303  av_freep(content_ptr);
1304  /* If method is set, this is called from ff_rtsp_send_cmd,
1305  * where a reply to exactly this request is awaited. For
1306  * callers from within packet receiving, we just want to
1307  * return to the caller and go back to receiving packets. */
1308  if (method)
1309  goto start;
1310  return 0;
1311  }
1312 
1313  if (rt->seq != reply->seq) {
1314  av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
1315  rt->seq, reply->seq);
1316  }
1317 
1318  /* EOS */
1319  if (reply->notice == 2101 /* End-of-Stream Reached */ ||
1320  reply->notice == 2104 /* Start-of-Stream Reached */ ||
1321  reply->notice == 2306 /* Continuous Feed Terminated */) {
1322  rt->state = RTSP_STATE_IDLE;
1323  } else if (reply->notice >= 4400 && reply->notice < 5500) {
1324  return AVERROR(EIO); /* data or server error */
1325  } else if (reply->notice == 2401 /* Ticket Expired */ ||
1326  (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
1327  return AVERROR(EPERM);
1328 
1329  return 0;
1330 }
1331 
1332 /**
1333  * Send a command to the RTSP server without waiting for the reply.
1334  *
1335  * @param s RTSP (de)muxer context
1336  * @param method the method for the request
1337  * @param url the target url for the request
1338  * @param headers extra header lines to include in the request
1339  * @param send_content if non-null, the data to send as request body content
1340  * @param send_content_length the length of the send_content data, or 0 if
1341  * send_content is null
1342  *
1343  * @return zero if success, nonzero otherwise
1344  */
1345 static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
1346  const char *method, const char *url,
1347  const char *headers,
1348  const unsigned char *send_content,
1349  int send_content_length)
1350 {
1351  RTSPState *rt = s->priv_data;
1352  char buf[MAX_URL_SIZE], *out_buf;
1353  char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1354 
1355  if (!rt->rtsp_hd_out)
1356  return AVERROR(ENOTCONN);
1357 
1358  /* Add in RTSP headers */
1359  out_buf = buf;
1360  rt->seq++;
1361  snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
1362  if (headers)
1363  av_strlcat(buf, headers, sizeof(buf));
1364  av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
1365  av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent);
1366  if (rt->session_id[0] != '\0' && (!headers ||
1367  !strstr(headers, "\nIf-Match:"))) {
1368  av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
1369  }
1370  if (rt->auth[0]) {
1371  char *str = ff_http_auth_create_response(&rt->auth_state,
1372  rt->auth, url, method);
1373  if (str)
1374  av_strlcat(buf, str, sizeof(buf));
1375  av_free(str);
1376  }
1377  if (send_content_length > 0 && send_content)
1378  av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1379  av_strlcat(buf, "\r\n", sizeof(buf));
1380 
1381  /* base64 encode rtsp if tunneling */
1382  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1383  av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1384  out_buf = base64buf;
1385  }
1386 
1387  av_log(s, AV_LOG_TRACE, "Sending:\n%s--\n", buf);
1388 
1389  ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
1390  if (send_content_length > 0 && send_content) {
1391  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1392  avpriv_report_missing_feature(s, "Tunneling of RTSP requests with content data");
1393  return AVERROR_PATCHWELCOME;
1394  }
1395  ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
1396  }
1398 
1399  return 0;
1400 }
1401 
1402 int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1403  const char *url, const char *headers)
1404 {
1405  return rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1406 }
1407 
1408 int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1409  const char *headers, RTSPMessageHeader *reply,
1410  unsigned char **content_ptr)
1411 {
1412  return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1413  content_ptr, NULL, 0);
1414 }
1415 
1417  const char *method, const char *url,
1418  const char *header,
1419  RTSPMessageHeader *reply,
1420  unsigned char **content_ptr,
1421  const unsigned char *send_content,
1422  int send_content_length)
1423 {
1424  RTSPState *rt = s->priv_data;
1425  HTTPAuthType cur_auth_type;
1426  int ret, attempts = 0;
1427 
1428 retry:
1429  cur_auth_type = rt->auth_state.auth_type;
1430  if ((ret = rtsp_send_cmd_with_content_async(s, method, url, header,
1431  send_content,
1432  send_content_length)) < 0)
1433  return ret;
1434 
1435  if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1436  return ret;
1437  attempts++;
1438 
1439  if (reply->status_code == 401 &&
1440  (cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
1441  rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
1442  goto retry;
1443 
1444  if (reply->status_code > 400){
1445  av_log(s, AV_LOG_ERROR, "method %s failed: %d%s\n",
1446  method,
1447  reply->status_code,
1448  reply->reason);
1449  av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1450  }
1451 
1452  return 0;
1453 }
1454 
1455 int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1456  int lower_transport, const char *real_challenge)
1457 {
1458  RTSPState *rt = s->priv_data;
1459  int rtx = 0, j, i, err, interleave = 0, port_off = 0;
1460  RTSPStream *rtsp_st;
1461  RTSPMessageHeader reply1, *reply = &reply1;
1462  char cmd[MAX_URL_SIZE];
1463  const char *trans_pref;
1464 
1465  memset(&reply1, 0, sizeof(reply1));
1466 
1467  if (rt->transport == RTSP_TRANSPORT_RDT)
1468  trans_pref = "x-pn-tng";
1469  else if (rt->transport == RTSP_TRANSPORT_RAW)
1470  trans_pref = "RAW/RAW";
1471  else
1472  trans_pref = "RTP/AVP";
1473 
1474  /* default timeout: 1 minute */
1475  rt->timeout = 60;
1476 
1477  /* Choose a random starting offset within the first half of the
1478  * port range, to allow for a number of ports to try even if the offset
1479  * happens to be at the end of the random range. */
1480  if (rt->rtp_port_max - rt->rtp_port_min >= 4) {
1481  port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
1482  /* even random offset */
1483  port_off -= port_off & 0x01;
1484  }
1485 
1486  for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1487  char transport[MAX_URL_SIZE];
1488 
1489  /*
1490  * WMS serves all UDP data over a single connection, the RTX, which
1491  * isn't necessarily the first in the SDP but has to be the first
1492  * to be set up, else the second/third SETUP will fail with a 461.
1493  */
1494  if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1495  rt->server_type == RTSP_SERVER_WMS) {
1496  if (i == 0) {
1497  /* rtx first */
1498  for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1499  int len = strlen(rt->rtsp_streams[rtx]->control_url);
1500  if (len >= 4 &&
1501  !strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1502  "/rtx"))
1503  break;
1504  }
1505  if (rtx == rt->nb_rtsp_streams)
1506  return -1; /* no RTX found */
1507  rtsp_st = rt->rtsp_streams[rtx];
1508  } else
1509  rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1510  } else
1511  rtsp_st = rt->rtsp_streams[i];
1512 
1513  /* RTP/UDP */
1514  if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1515  char buf[256];
1516 
1517  if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1518  port = reply->transports[0].client_port_min;
1519  goto have_port;
1520  }
1521 
1522  /* first try in specified port range */
1523  while (j + 1 <= rt->rtp_port_max) {
1524  AVDictionary *opts = map_to_opts(rt);
1525 
1526  ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1527  "?localport=%d", j);
1528  /* we will use two ports per rtp stream (rtp and rtcp) */
1529  j += 2;
1531  &s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
1532 
1533  av_dict_free(&opts);
1534 
1535  if (!err)
1536  goto rtp_opened;
1537  }
1538  av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1539  err = AVERROR(EIO);
1540  goto fail;
1541 
1542  rtp_opened:
1543  port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1544  have_port:
1545  av_strlcpy(transport, trans_pref, sizeof(transport));
1546  av_strlcat(transport,
1547  rt->server_type == RTSP_SERVER_SATIP ? ";" : "/UDP;",
1548  sizeof(transport));
1549  if (rt->server_type != RTSP_SERVER_REAL)
1550  av_strlcat(transport, "unicast;", sizeof(transport));
1551  av_strlcatf(transport, sizeof(transport),
1552  "client_port=%d", port);
1553  if (rt->transport == RTSP_TRANSPORT_RTP &&
1554  !(rt->server_type == RTSP_SERVER_WMS && i > 0))
1555  av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1556  }
1557 
1558  /* RTP/TCP */
1559  else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1560  /* For WMS streams, the application streams are only used for
1561  * UDP. When trying to set it up for TCP streams, the server
1562  * will return an error. Therefore, we skip those streams. */
1563  if (rt->server_type == RTSP_SERVER_WMS &&
1564  (rtsp_st->stream_index < 0 ||
1565  s->streams[rtsp_st->stream_index]->codecpar->codec_type ==
1567  continue;
1568  snprintf(transport, sizeof(transport) - 1,
1569  "%s/TCP;", trans_pref);
1570  if (rt->transport != RTSP_TRANSPORT_RDT)
1571  av_strlcat(transport, "unicast;", sizeof(transport));
1572  av_strlcatf(transport, sizeof(transport),
1573  "interleaved=%d-%d",
1574  interleave, interleave + 1);
1575  interleave += 2;
1576  }
1577 
1578  else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1579  snprintf(transport, sizeof(transport) - 1,
1580  "%s/UDP;multicast", trans_pref);
1581  } else {
1582  err = AVERROR(EINVAL);
1583  goto fail; // transport would be uninitialized
1584  }
1585 
1586  if (s->oformat) {
1587  av_strlcat(transport, ";mode=record", sizeof(transport));
1588  } else if (rt->server_type == RTSP_SERVER_REAL ||
1590  av_strlcat(transport, ";mode=play", sizeof(transport));
1591  snprintf(cmd, sizeof(cmd),
1592  "Transport: %s\r\n",
1593  transport);
1594  if (rt->accept_dynamic_rate)
1595  av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
1596  if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1597  char real_res[41], real_csum[9];
1598  ff_rdt_calc_response_and_checksum(real_res, real_csum,
1599  real_challenge);
1600  av_strlcatf(cmd, sizeof(cmd),
1601  "If-Match: %s\r\n"
1602  "RealChallenge2: %s, sd=%s\r\n",
1603  rt->session_id, real_res, real_csum);
1604  }
1605  ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1606  if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1607  err = 1;
1608  goto fail;
1609  } else if (reply->status_code != RTSP_STATUS_OK ||
1610  reply->nb_transports != 1) {
1612  goto fail;
1613  }
1614 
1615  if (rt->server_type == RTSP_SERVER_SATIP && reply->stream_id[0]) {
1616  char proto[128], host[128], path[512], auth[128];
1617  int port;
1618  av_url_split(proto, sizeof(proto), auth, sizeof(auth), host, sizeof(host),
1619  &port, path, sizeof(path), rt->control_uri);
1620  ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL, host,
1621  port, "/stream=%s", reply->stream_id);
1622  }
1623 
1624  /* XXX: same protocol for all streams is required */
1625  if (i > 0) {
1626  if (reply->transports[0].lower_transport != rt->lower_transport ||
1627  reply->transports[0].transport != rt->transport) {
1628  err = AVERROR_INVALIDDATA;
1629  goto fail;
1630  }
1631  } else {
1632  rt->lower_transport = reply->transports[0].lower_transport;
1633  rt->transport = reply->transports[0].transport;
1634  }
1635 
1636  /* Fail if the server responded with another lower transport mode
1637  * than what we requested. */
1638  if (reply->transports[0].lower_transport != lower_transport) {
1639  av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1640  err = AVERROR_INVALIDDATA;
1641  goto fail;
1642  }
1643 
1644  switch(reply->transports[0].lower_transport) {
1646  rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1647  rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1648  break;
1649 
1650  case RTSP_LOWER_TRANSPORT_UDP: {
1651  char url[MAX_URL_SIZE], options[30] = "";
1652  const char *peer = host;
1653 
1654  if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
1655  av_strlcpy(options, "?connect=1", sizeof(options));
1656  /* Use source address if specified */
1657  if (reply->transports[0].source[0])
1658  peer = reply->transports[0].source;
1659  ff_url_join(url, sizeof(url), "rtp", NULL, peer,
1660  reply->transports[0].server_port_min, "%s", options);
1661  if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1662  ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1663  err = AVERROR_INVALIDDATA;
1664  goto fail;
1665  }
1666  break;
1667  }
1669  char url[MAX_URL_SIZE], namebuf[50], optbuf[20] = "";
1670  struct sockaddr_storage addr;
1671  int port, ttl;
1672  AVDictionary *opts = map_to_opts(rt);
1673 
1674  if (reply->transports[0].destination.ss_family) {
1675  addr = reply->transports[0].destination;
1676  port = reply->transports[0].port_min;
1677  ttl = reply->transports[0].ttl;
1678  } else {
1679  addr = rtsp_st->sdp_ip;
1680  port = rtsp_st->sdp_port;
1681  ttl = rtsp_st->sdp_ttl;
1682  }
1683  if (ttl > 0)
1684  snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1685  getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1686  namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1687  ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1688  port, "%s", optbuf);
1690  &s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
1691  av_dict_free(&opts);
1692 
1693  if (err < 0) {
1694  err = AVERROR_INVALIDDATA;
1695  goto fail;
1696  }
1697  break;
1698  }
1699  }
1700 
1701  if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
1702  goto fail;
1703  }
1704 
1705  if (rt->nb_rtsp_streams && reply->timeout > 0)
1706  rt->timeout = reply->timeout;
1707 
1708  if (rt->server_type == RTSP_SERVER_REAL)
1709  rt->need_subscription = 1;
1710 
1711  return 0;
1712 
1713 fail:
1714  ff_rtsp_undo_setup(s, 0);
1715  return err;
1716 }
1717 
1719 {
1720  RTSPState *rt = s->priv_data;
1721  if (rt->rtsp_hd_out != rt->rtsp_hd)
1722  ffurl_closep(&rt->rtsp_hd_out);
1723  rt->rtsp_hd_out = NULL;
1724  ffurl_closep(&rt->rtsp_hd);
1725 }
1726 
1728 {
1729  RTSPState *rt = s->priv_data;
1730  char proto[128], host[1024], path[2048];
1731  char tcpname[1024], cmd[MAX_URL_SIZE], auth[128];
1732  const char *lower_rtsp_proto = "tcp";
1733  int port, err, tcp_fd;
1734  RTSPMessageHeader reply1, *reply = &reply1;
1735  int lower_transport_mask = 0;
1736  int default_port = RTSP_DEFAULT_PORT;
1737  int https_tunnel = 0;
1738  char real_challenge[64] = "";
1739  struct sockaddr_storage peer;
1740  socklen_t peer_len = sizeof(peer);
1741 
1742  if (rt->rtp_port_max < rt->rtp_port_min) {
1743  av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1744  "than min port %d\n", rt->rtp_port_max,
1745  rt->rtp_port_min);
1746  return AVERROR(EINVAL);
1747  }
1748 
1749  if (!ff_network_init())
1750  return AVERROR(EIO);
1751 
1752  if (s->max_delay < 0) /* Not set by the caller */
1753  s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
1754 
1757  (1 << RTSP_LOWER_TRANSPORT_HTTPS))) {
1758  https_tunnel = !!(rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTPS));
1761  }
1762  /* Only pass through valid flags from here */
1764 
1765 redirect:
1766  memset(&reply1, 0, sizeof(reply1));
1767  /* extract hostname and port */
1768  av_url_split(proto, sizeof(proto), auth, sizeof(auth),
1769  host, sizeof(host), &port, path, sizeof(path), s->url);
1770 
1771  if (!strcmp(proto, "rtsps")) {
1772  lower_rtsp_proto = "tls";
1773  default_port = RTSPS_DEFAULT_PORT;
1775  } else if (!strcmp(proto, "satip")) {
1776  av_strlcpy(proto, "rtsp", sizeof(proto));
1778  }
1779 
1780  if (*auth) {
1781  av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1782  }
1783  if (port < 0)
1784  port = default_port;
1785 
1786  lower_transport_mask = rt->lower_transport_mask;
1787 
1788  if (!lower_transport_mask)
1789  lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1790 
1791  if (s->oformat) {
1792  /* Only UDP or TCP - UDP multicast isn't supported. */
1793  lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1794  (1 << RTSP_LOWER_TRANSPORT_TCP);
1795  if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1796  av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1797  "only UDP and TCP are supported for output.\n");
1798  err = AVERROR(EINVAL);
1799  goto fail;
1800  }
1801  }
1802 
1803  /* Construct the URI used in request; this is similar to s->url,
1804  * but with authentication credentials removed and RTSP specific options
1805  * stripped out. */
1806  ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
1807  host, port, "%s", path);
1808 
1809  if (rt->control_transport == RTSP_MODE_TUNNEL) {
1810  /* set up initial handshake for tunneling */
1811  char httpname[1024];
1812  char sessioncookie[17];
1813  char headers[1024];
1815 
1816  av_dict_set_int(&options, "timeout", rt->stimeout, 0);
1817 
1818  ff_url_join(httpname, sizeof(httpname), https_tunnel ? "https" : "http", auth, host, port, "%s", path);
1819  snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1821 
1822  /* GET requests */
1823  if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
1824  &s->interrupt_callback) < 0) {
1825  err = AVERROR(EIO);
1826  goto fail;
1827  }
1828 
1829  /* generate GET headers */
1830  snprintf(headers, sizeof(headers),
1831  "x-sessioncookie: %s\r\n"
1832  "Accept: application/x-rtsp-tunnelled\r\n"
1833  "Pragma: no-cache\r\n"
1834  "Cache-Control: no-cache\r\n",
1835  sessioncookie);
1836  av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
1837 
1838  if (!rt->rtsp_hd->protocol_whitelist && s->protocol_whitelist) {
1839  rt->rtsp_hd->protocol_whitelist = av_strdup(s->protocol_whitelist);
1840  if (!rt->rtsp_hd->protocol_whitelist) {
1841  err = AVERROR(ENOMEM);
1842  goto fail;
1843  }
1844  }
1845 
1846  /* complete the connection */
1847  if (ffurl_connect(rt->rtsp_hd, &options)) {
1849  err = AVERROR(EIO);
1850  goto fail;
1851  }
1852 
1853  /* POST requests */
1854  if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
1855  &s->interrupt_callback) < 0 ) {
1856  err = AVERROR(EIO);
1857  goto fail;
1858  }
1859 
1860  /* generate POST headers */
1861  snprintf(headers, sizeof(headers),
1862  "x-sessioncookie: %s\r\n"
1863  "Content-Type: application/x-rtsp-tunnelled\r\n"
1864  "Pragma: no-cache\r\n"
1865  "Cache-Control: no-cache\r\n"
1866  "Content-Length: 32767\r\n"
1867  "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1868  sessioncookie);
1869  av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
1870  av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
1871  av_opt_set(rt->rtsp_hd_out->priv_data, "send_expect_100", "0", 0);
1872 
1873  /* Initialize the authentication state for the POST session. The HTTP
1874  * protocol implementation doesn't properly handle multi-pass
1875  * authentication for POST requests, since it would require one of
1876  * the following:
1877  * - implementing Expect: 100-continue, which many HTTP servers
1878  * don't support anyway, even less the RTSP servers that do HTTP
1879  * tunneling
1880  * - sending the whole POST data until getting a 401 reply specifying
1881  * what authentication method to use, then resending all that data
1882  * - waiting for potential 401 replies directly after sending the
1883  * POST header (waiting for some unspecified time)
1884  * Therefore, we copy the full auth state, which works for both basic
1885  * and digest. (For digest, we would have to synchronize the nonce
1886  * count variable between the two sessions, if we'd do more requests
1887  * with the original session, though.)
1888  */
1890 
1891  /* complete the connection */
1892  if (ffurl_connect(rt->rtsp_hd_out, &options)) {
1894  err = AVERROR(EIO);
1895  goto fail;
1896  }
1898  } else {
1899  int ret;
1900  /* open the tcp connection */
1901  ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
1902  host, port,
1903  "?timeout=%"PRId64, rt->stimeout);
1904  if ((ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
1905  &s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL)) < 0) {
1906  err = ret;
1907  goto fail;
1908  }
1909  rt->rtsp_hd_out = rt->rtsp_hd;
1910  }
1911  rt->seq = 0;
1912 
1913  tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1914  if (tcp_fd < 0) {
1915  err = tcp_fd;
1916  goto fail;
1917  }
1918  if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1919  getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1920  NULL, 0, NI_NUMERICHOST);
1921  }
1922 
1923  /* request options supported by the server; this also detects server
1924  * type */
1925  if (rt->server_type != RTSP_SERVER_SATIP)
1927  for (;;) {
1928  cmd[0] = 0;
1929  if (rt->server_type == RTSP_SERVER_REAL)
1930  av_strlcat(cmd,
1931  /*
1932  * The following entries are required for proper
1933  * streaming from a Realmedia server. They are
1934  * interdependent in some way although we currently
1935  * don't quite understand how. Values were copied
1936  * from mplayer SVN r23589.
1937  * ClientChallenge is a 16-byte ID in hex
1938  * CompanyID is a 16-byte ID in base64
1939  */
1940  "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1941  "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1942  "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1943  "GUID: 00000000-0000-0000-0000-000000000000\r\n",
1944  sizeof(cmd));
1945  ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1946  if (reply->status_code != RTSP_STATUS_OK) {
1948  goto fail;
1949  }
1950 
1951  /* detect server type if not standard-compliant RTP */
1952  if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1954  continue;
1955  } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
1957  } else if (rt->server_type == RTSP_SERVER_REAL)
1958  strcpy(real_challenge, reply->real_challenge);
1959  break;
1960  }
1961 
1962 #if CONFIG_RTSP_DEMUXER
1963  if (s->iformat) {
1964  if (rt->server_type == RTSP_SERVER_SATIP)
1965  err = init_satip_stream(s);
1966  else
1967  err = ff_rtsp_setup_input_streams(s, reply);
1968  } else
1969 #endif
1970  if (CONFIG_RTSP_MUXER)
1971  err = ff_rtsp_setup_output_streams(s, host);
1972  else
1973  av_assert0(0);
1974  if (err)
1975  goto fail;
1976 
1977  do {
1978  int lower_transport = ff_log2_tab[lower_transport_mask &
1979  ~(lower_transport_mask - 1)];
1980 
1981  if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
1982  && (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
1983  lower_transport = RTSP_LOWER_TRANSPORT_TCP;
1984 
1985  err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
1986  rt->server_type == RTSP_SERVER_REAL ?
1987  real_challenge : NULL);
1988  if (err < 0)
1989  goto fail;
1990  lower_transport_mask &= ~(1 << lower_transport);
1991  if (lower_transport_mask == 0 && err == 1) {
1992  err = AVERROR(EPROTONOSUPPORT);
1993  goto fail;
1994  }
1995  } while (err);
1996 
1997  rt->lower_transport_mask = lower_transport_mask;
1998  av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
1999  rt->state = RTSP_STATE_IDLE;
2000  rt->seek_timestamp = 0; /* default is to start stream at position zero */
2001  return 0;
2002  fail:
2005  if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
2006  char *new_url = av_strdup(reply->location);
2007  if (!new_url) {
2008  err = AVERROR(ENOMEM);
2009  goto fail2;
2010  }
2011  ff_format_set_url(s, new_url);
2012  rt->session_id[0] = '\0';
2013  av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
2014  reply->status_code,
2015  s->url);
2016  goto redirect;
2017  }
2018  fail2:
2019  ff_network_close();
2020  return err;
2021 }
2022 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
2023 
2024 #if CONFIG_RTPDEC
2025 #if CONFIG_RTSP_DEMUXER
2026 static int parse_rtsp_message(AVFormatContext *s)
2027 {
2028  RTSPState *rt = s->priv_data;
2029  int ret;
2030 
2031  if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
2032  if (rt->state == RTSP_STATE_STREAMING) {
2034  } else
2035  return AVERROR_EOF;
2036  } else {
2037  RTSPMessageHeader reply;
2038  ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
2039  if (ret < 0)
2040  return ret;
2041  /* XXX: parse message */
2042  if (rt->state != RTSP_STATE_STREAMING)
2043  return 0;
2044  }
2045 
2046  return 0;
2047 }
2048 #endif
2049 
2050 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
2051  uint8_t *buf, int buf_size, int64_t wait_end)
2052 {
2053  RTSPState *rt = s->priv_data;
2054  RTSPStream *rtsp_st;
2055  int n, i, ret;
2056  struct pollfd *p = rt->p;
2057  int *fds = NULL, fdsnum, fdsidx;
2058  int64_t runs = rt->stimeout / POLLING_TIME / 1000;
2059 
2060  if (!p) {
2061  p = rt->p = av_malloc_array(2 * rt->nb_rtsp_streams + 1, sizeof(*p));
2062  if (!p)
2063  return AVERROR(ENOMEM);
2064 
2065  if (rt->rtsp_hd) {
2066  p[rt->max_p].fd = ffurl_get_file_handle(rt->rtsp_hd);
2067  p[rt->max_p++].events = POLLIN;
2068  }
2069  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2070  rtsp_st = rt->rtsp_streams[i];
2071  if (rtsp_st->rtp_handle) {
2073  &fds, &fdsnum)) {
2074  av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
2075  return ret;
2076  }
2077  if (fdsnum != 2) {
2079  "Number of fds %d not supported\n", fdsnum);
2080  av_freep(&fds);
2081  return AVERROR_INVALIDDATA;
2082  }
2083  for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
2084  p[rt->max_p].fd = fds[fdsidx];
2085  p[rt->max_p++].events = POLLIN;
2086  }
2087  av_freep(&fds);
2088  }
2089  }
2090  }
2091 
2092  for (;;) {
2093  if (ff_check_interrupt(&s->interrupt_callback))
2094  return AVERROR_EXIT;
2095  if (wait_end && wait_end - av_gettime_relative() < 0)
2096  return AVERROR(EAGAIN);
2097  n = poll(p, rt->max_p, POLLING_TIME);
2098  if (n > 0) {
2099  int j = rt->rtsp_hd ? 1 : 0;
2100  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2101  rtsp_st = rt->rtsp_streams[i];
2102  if (rtsp_st->rtp_handle) {
2103  if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
2104  ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
2105  if (ret > 0) {
2106  *prtsp_st = rtsp_st;
2107  return ret;
2108  }
2109  }
2110  j+=2;
2111  }
2112  }
2113 #if CONFIG_RTSP_DEMUXER
2114  if (rt->rtsp_hd && p[0].revents & POLLIN) {
2115  if ((ret = parse_rtsp_message(s)) < 0) {
2116  return ret;
2117  }
2118  }
2119 #endif
2120  } else if (n == 0 && rt->stimeout > 0 && --runs <= 0) {
2121  return AVERROR(ETIMEDOUT);
2122  } else if (n < 0 && errno != EINTR)
2123  return AVERROR(errno);
2124  }
2125 }
2126 
2127 static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
2128  const uint8_t *buf, int len)
2129 {
2130  RTSPState *rt = s->priv_data;
2131  int i;
2132  if (len < 0)
2133  return len;
2134  if (rt->nb_rtsp_streams == 1) {
2135  *rtsp_st = rt->rtsp_streams[0];
2136  return len;
2137  }
2138  if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
2139  if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
2140  int no_ssrc = 0;
2141  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2142  RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2143  if (!rtpctx)
2144  continue;
2145  if (rtpctx->ssrc == AV_RB32(&buf[4])) {
2146  *rtsp_st = rt->rtsp_streams[i];
2147  return len;
2148  }
2149  if (!rtpctx->ssrc)
2150  no_ssrc = 1;
2151  }
2152  if (no_ssrc) {
2154  "Unable to pick stream for packet - SSRC not known for "
2155  "all streams\n");
2156  return AVERROR(EAGAIN);
2157  }
2158  } else {
2159  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2160  if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
2161  *rtsp_st = rt->rtsp_streams[i];
2162  return len;
2163  }
2164  }
2165  }
2166  }
2167  av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
2168  return AVERROR(EAGAIN);
2169 }
2170 
2171 static int read_packet(AVFormatContext *s,
2172  RTSPStream **rtsp_st, RTSPStream *first_queue_st,
2173  int64_t wait_end)
2174 {
2175  RTSPState *rt = s->priv_data;
2176  int len;
2177 
2178  switch(rt->lower_transport) {
2179  default:
2180 #if CONFIG_RTSP_DEMUXER
2182  len = ff_rtsp_tcp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE);
2183  break;
2184 #endif
2187  len = udp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2188  if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2189  ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, (*rtsp_st)->rtp_handle, NULL, len);
2190  break;
2192  if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2193  wait_end && wait_end < av_gettime_relative())
2194  len = AVERROR(EAGAIN);
2195  else
2197  len = pick_stream(s, rtsp_st, rt->recvbuf, len);
2198  if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2199  ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, NULL, s->pb, len);
2200  break;
2201  }
2202 
2203  if (len == 0)
2204  return AVERROR_EOF;
2205 
2206  return len;
2207 }
2208 
2210 {
2211  RTSPState *rt = s->priv_data;
2212  int ret, len;
2213  RTSPStream *rtsp_st, *first_queue_st = NULL;
2214  int64_t wait_end = 0;
2215 
2216  if (rt->nb_byes == rt->nb_rtsp_streams)
2217  return AVERROR_EOF;
2218 
2219  /* get next frames from the same RTP packet */
2220  if (rt->cur_transport_priv) {
2221  if (rt->transport == RTSP_TRANSPORT_RDT) {
2223  } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2225  } else if (CONFIG_RTPDEC && rt->ts) {
2227  if (ret >= 0) {
2228  rt->recvbuf_pos += ret;
2229  ret = rt->recvbuf_pos < rt->recvbuf_len;
2230  }
2231  } else
2232  ret = -1;
2233  if (ret == 0) {
2234  rt->cur_transport_priv = NULL;
2235  return 0;
2236  } else if (ret == 1) {
2237  return 0;
2238  } else
2239  rt->cur_transport_priv = NULL;
2240  }
2241 
2242 redo:
2243  if (rt->transport == RTSP_TRANSPORT_RTP) {
2244  int i;
2245  int64_t first_queue_time = 0;
2246  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2247  RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2248  int64_t queue_time;
2249  if (!rtpctx)
2250  continue;
2251  queue_time = ff_rtp_queued_packet_time(rtpctx);
2252  if (queue_time && (queue_time - first_queue_time < 0 ||
2253  !first_queue_time)) {
2254  first_queue_time = queue_time;
2255  first_queue_st = rt->rtsp_streams[i];
2256  }
2257  }
2258  if (first_queue_time) {
2259  wait_end = first_queue_time + s->max_delay;
2260  } else {
2261  wait_end = 0;
2262  first_queue_st = NULL;
2263  }
2264  }
2265 
2266  /* read next RTP packet */
2267  if (!rt->recvbuf) {
2269  if (!rt->recvbuf)
2270  return AVERROR(ENOMEM);
2271  }
2272 
2273  len = read_packet(s, &rtsp_st, first_queue_st, wait_end);
2274  if (len == AVERROR(EAGAIN) && first_queue_st &&
2275  rt->transport == RTSP_TRANSPORT_RTP) {
2277  "max delay reached. need to consume packet\n");
2278  rtsp_st = first_queue_st;
2279  ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
2280  goto end;
2281  }
2282  if (len < 0)
2283  return len;
2284 
2285  if (rt->transport == RTSP_TRANSPORT_RDT) {
2286  ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2287  } else if (rt->transport == RTSP_TRANSPORT_RTP) {
2288  ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2289  if (rtsp_st->feedback) {
2290  AVIOContext *pb = NULL;
2292  pb = s->pb;
2293  ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
2294  }
2295  if (ret < 0) {
2296  /* Either bad packet, or a RTCP packet. Check if the
2297  * first_rtcp_ntp_time field was initialized. */
2298  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
2299  if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
2300  /* first_rtcp_ntp_time has been initialized for this stream,
2301  * copy the same value to all other uninitialized streams,
2302  * in order to map their timestamp origin to the same ntp time
2303  * as this one. */
2304  int i;
2305  AVStream *st = NULL;
2306  if (rtsp_st->stream_index >= 0)
2307  st = s->streams[rtsp_st->stream_index];
2308  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2309  RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2310  AVStream *st2 = NULL;
2311  if (rt->rtsp_streams[i]->stream_index >= 0)
2312  st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2313  if (rtpctx2 && st && st2 &&
2314  rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
2315  rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2316  rtpctx2->rtcp_ts_offset = av_rescale_q(
2317  rtpctx->rtcp_ts_offset, st->time_base,
2318  st2->time_base);
2319  }
2320  }
2321  // Make real NTP start time available in AVFormatContext
2322  if (s->start_time_realtime == AV_NOPTS_VALUE) {
2323  s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time, 1000000, 1LL << 32) - NTP_OFFSET_US;
2324  if (rtpctx->st) {
2325  s->start_time_realtime -=
2326  av_rescale_q (rtpctx->rtcp_ts_offset, rtpctx->st->time_base, AV_TIME_BASE_Q);
2327  }
2328  }
2329  }
2330  if (ret == -RTCP_BYE) {
2331  rt->nb_byes++;
2332 
2333  av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2334  rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2335 
2336  if (rt->nb_byes == rt->nb_rtsp_streams)
2337  return AVERROR_EOF;
2338  }
2339  }
2340  } else if (CONFIG_RTPDEC && rt->ts) {
2342  if (ret >= 0) {
2343  if (ret < len) {
2344  rt->recvbuf_len = len;
2345  rt->recvbuf_pos = ret;
2346  rt->cur_transport_priv = rt->ts;
2347  return 1;
2348  } else {
2349  ret = 0;
2350  }
2351  }
2352  } else {
2353  return AVERROR_INVALIDDATA;
2354  }
2355 end:
2356  if (ret < 0)
2357  goto redo;
2358  if (ret == 1)
2359  /* more packets may follow, so we save the RTP context */
2360  rt->cur_transport_priv = rtsp_st->transport_priv;
2361 
2362  return ret;
2363 }
2364 #endif /* CONFIG_RTPDEC */
2365 
2366 #if CONFIG_SDP_DEMUXER
2367 static int sdp_probe(const AVProbeData *p1)
2368 {
2369  const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2370 
2371  /* we look for a line beginning "c=IN IP" */
2372  while (p < p_end && *p != '\0') {
2373  if (sizeof("c=IN IP") - 1 < p_end - p &&
2374  av_strstart(p, "c=IN IP", NULL))
2375  return AVPROBE_SCORE_EXTENSION;
2376 
2377  while (p < p_end - 1 && *p != '\n') p++;
2378  if (++p >= p_end)
2379  break;
2380  if (*p == '\r')
2381  p++;
2382  }
2383  return 0;
2384 }
2385 
2386 static void append_source_addrs(char *buf, int size, const char *name,
2387  int count, struct RTSPSource **addrs)
2388 {
2389  int i;
2390  if (!count)
2391  return;
2392  av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
2393  for (i = 1; i < count; i++)
2394  av_strlcatf(buf, size, ",%s", addrs[i]->addr);
2395 }
2396 
2397 static int sdp_read_header(AVFormatContext *s)
2398 {
2399  RTSPState *rt = s->priv_data;
2400  RTSPStream *rtsp_st;
2401  int i, err;
2402  char url[MAX_URL_SIZE];
2403  AVBPrint bp;
2404 
2405  if (!ff_network_init())
2406  return AVERROR(EIO);
2407 
2408  if (s->max_delay < 0) /* Not set by the caller */
2409  s->max_delay = DEFAULT_REORDERING_DELAY;
2410  if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2412 
2413  /* read the whole sdp file */
2415  err = avio_read_to_bprint(s->pb, &bp, INT_MAX);
2416  if (err < 0 ) {
2417  ff_network_close();
2418  av_bprint_finalize(&bp, NULL);
2419  return err;
2420  }
2421  err = ff_sdp_parse(s, bp.str);
2422  av_bprint_finalize(&bp, NULL);
2423  if (err) goto fail;
2424 
2425  /* open each RTP stream */
2426  for (i = 0; i < rt->nb_rtsp_streams; i++) {
2427  char namebuf[50];
2428  rtsp_st = rt->rtsp_streams[i];
2429 
2430  if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2431  AVDictionary *opts = map_to_opts(rt);
2432  char buf[MAX_URL_SIZE];
2433  const char *p;
2434 
2435  err = getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip,
2436  sizeof(rtsp_st->sdp_ip),
2437  namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2438  if (err) {
2439  av_log(s, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(err));
2440  err = AVERROR(EIO);
2441  av_dict_free(&opts);
2442  goto fail;
2443  }
2444  ff_url_join(url, sizeof(url), "rtp", NULL,
2445  namebuf, rtsp_st->sdp_port,
2446  "?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2447  rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2448  rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2449  rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2450 
2451  p = strchr(s->url, '?');
2452  if (p && av_find_info_tag(buf, sizeof(buf), "localaddr", p))
2453  av_strlcatf(url, sizeof(url), "&localaddr=%s", buf);
2454  else if (rt->localaddr && rt->localaddr[0])
2455  av_strlcatf(url, sizeof(url), "&localaddr=%s", rt->localaddr);
2456  append_source_addrs(url, sizeof(url), "sources",
2457  rtsp_st->nb_include_source_addrs,
2458  rtsp_st->include_source_addrs);
2459  append_source_addrs(url, sizeof(url), "block",
2460  rtsp_st->nb_exclude_source_addrs,
2461  rtsp_st->exclude_source_addrs);
2462  err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ,
2463  &s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
2464 
2465  av_dict_free(&opts);
2466 
2467  if (err < 0) {
2468  err = AVERROR_INVALIDDATA;
2469  goto fail;
2470  }
2471  }
2472  if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2473  goto fail;
2474  }
2475  return 0;
2476 fail:
2478  ff_network_close();
2479  return err;
2480 }
2481 
2482 static int sdp_read_close(AVFormatContext *s)
2483 {
2485  ff_network_close();
2486  return 0;
2487 }
2488 
2489 static const AVClass sdp_demuxer_class = {
2490  .class_name = "SDP demuxer",
2491  .item_name = av_default_item_name,
2492  .option = sdp_options,
2493  .version = LIBAVUTIL_VERSION_INT,
2494 };
2495 
2496 const FFInputFormat ff_sdp_demuxer = {
2497  .p.name = "sdp",
2498  .p.long_name = NULL_IF_CONFIG_SMALL("SDP"),
2499  .p.priv_class = &sdp_demuxer_class,
2500  .priv_data_size = sizeof(RTSPState),
2501  .read_probe = sdp_probe,
2502  .read_header = sdp_read_header,
2504  .read_close = sdp_read_close,
2505 };
2506 #endif /* CONFIG_SDP_DEMUXER */
2507 
2508 #if CONFIG_RTP_DEMUXER
2509 static int rtp_probe(const AVProbeData *p)
2510 {
2511  if (av_strstart(p->filename, "rtp:", NULL))
2512  return AVPROBE_SCORE_MAX;
2513  return 0;
2514 }
2515 
2516 static int rtp_read_header(AVFormatContext *s)
2517 {
2518  uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2519  char host[500], filters_buf[1000];
2520  int ret, port;
2521  URLContext* in = NULL;
2522  int payload_type;
2523  AVCodecParameters *par = NULL;
2524  struct sockaddr_storage addr;
2525  FFIOContext pb;
2526  socklen_t addrlen = sizeof(addr);
2527  RTSPState *rt = s->priv_data;
2528  const char *p;
2529  AVBPrint sdp;
2530  AVDictionary *opts = NULL;
2531 
2532  if (!ff_network_init())
2533  return AVERROR(EIO);
2534 
2535  opts = map_to_opts(rt);
2537  &s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
2538  av_dict_free(&opts);
2539  if (ret)
2540  goto fail;
2541 
2542  while (1) {
2543  ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2544  if (ret == AVERROR(EAGAIN))
2545  continue;
2546  if (ret < 0)
2547  goto fail;
2548  if (ret < 12) {
2549  av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2550  continue;
2551  }
2552 
2553  if ((recvbuf[0] & 0xc0) != 0x80) {
2554  av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2555  "received\n");
2556  continue;
2557  }
2558 
2559  if (RTP_PT_IS_RTCP(recvbuf[1]))
2560  continue;
2561 
2562  payload_type = recvbuf[1] & 0x7f;
2563  break;
2564  }
2565  getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2566  ffurl_closep(&in);
2567 
2568  par = avcodec_parameters_alloc();
2569  if (!par) {
2570  ret = AVERROR(ENOMEM);
2571  goto fail;
2572  }
2573 
2574  if (ff_rtp_get_codec_info(par, payload_type)) {
2575  av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2576  "without an SDP file describing it\n",
2577  payload_type);
2579  goto fail;
2580  }
2581  if (par->codec_type != AVMEDIA_TYPE_DATA) {
2582  av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2583  "properly you need an SDP file "
2584  "describing it\n");
2585  }
2586 
2587  av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2588  NULL, 0, s->url);
2589 
2591  av_bprintf(&sdp, "v=0\r\nc=IN IP%d %s\r\n",
2592  addr.ss_family == AF_INET ? 4 : 6, host);
2593 
2594  p = strchr(s->url, '?');
2595  if (p) {
2596  static const char filters[][2][8] = { { "sources", "incl" },
2597  { "block", "excl" } };
2598  int i;
2599  char *q;
2600  for (i = 0; i < FF_ARRAY_ELEMS(filters); i++) {
2601  if (av_find_info_tag(filters_buf, sizeof(filters_buf), filters[i][0], p)) {
2602  q = filters_buf;
2603  while ((q = strchr(q, ',')) != NULL)
2604  *q = ' ';
2605  av_bprintf(&sdp, "a=source-filter:%s IN IP%d %s %s\r\n",
2606  filters[i][1],
2607  addr.ss_family == AF_INET ? 4 : 6, host,
2608  filters_buf);
2609  }
2610  }
2611  }
2612 
2613  av_bprintf(&sdp, "m=%s %d RTP/AVP %d\r\n",
2614  par->codec_type == AVMEDIA_TYPE_DATA ? "application" :
2615  par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2616  port, payload_type);
2617  av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp.str);
2618  if (!av_bprint_is_complete(&sdp))
2619  goto fail_nobuf;
2621 
2622  ffio_init_read_context(&pb, sdp.str, sdp.len);
2623  s->pb = &pb.pub;
2624 
2625  /* if sdp_read_header() fails then following ff_network_close() cancels out */
2626  /* ff_network_init() at the start of this function. Otherwise it cancels out */
2627  /* ff_network_init() inside sdp_read_header() */
2628  ff_network_close();
2629 
2630  rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;
2631 
2632  ret = sdp_read_header(s);
2633  s->pb = NULL;
2634  av_bprint_finalize(&sdp, NULL);
2635  return ret;
2636 
2637 fail_nobuf:
2638  ret = AVERROR(ENOMEM);
2639  av_log(s, AV_LOG_ERROR, "rtp_read_header(): not enough buffer space for sdp-headers\n");
2640  av_bprint_finalize(&sdp, NULL);
2641 fail:
2643  ffurl_closep(&in);
2644  ff_network_close();
2645  return ret;
2646 }
2647 
2648 static const AVClass rtp_demuxer_class = {
2649  .class_name = "RTP demuxer",
2650  .item_name = av_default_item_name,
2651  .option = rtp_options,
2652  .version = LIBAVUTIL_VERSION_INT,
2653 };
2654 
2655 const FFInputFormat ff_rtp_demuxer = {
2656  .p.name = "rtp",
2657  .p.long_name = NULL_IF_CONFIG_SMALL("RTP input"),
2658  .p.flags = AVFMT_NOFILE,
2659  .p.priv_class = &rtp_demuxer_class,
2660  .priv_data_size = sizeof(RTSPState),
2661  .read_probe = rtp_probe,
2662  .read_header = rtp_read_header,
2664  .read_close = sdp_read_close,
2665 };
2666 #endif /* CONFIG_RTP_DEMUXER */
ff_rtsp_read_reply
int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply, unsigned char **content_ptr, int return_on_interleaved_data, const char *method)
Read a RTSP message from the server, or prepare to read data packets if we're reading data interleave...
RTSPState::last_cmd_time
int64_t last_cmd_time
timestamp of the last RTSP command that we sent to the RTSP server.
Definition: rtsp.h:263
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
ff_rtsp_close_streams
void ff_rtsp_close_streams(AVFormatContext *s)
Close and free all streams within the RTSP (de)muxer.
Definition: rtsp.c:792
RTPDynamicProtocolHandler::init
int(* init)(AVFormatContext *s, int st_index, PayloadContext *priv_data)
Initialize dynamic protocol handler, called after the full rtpmap line is parsed, may be null.
Definition: rtpdec.h:127
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:45
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:218
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
av_find_info_tag
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
Attempt to find a specific tag in a URL.
Definition: parseutils.c:753
RTSPStream::transport_priv
void * transport_priv
RTP/RDT parse context if input, RTP AVFormatContext if output.
Definition: rtsp.h:446
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
ff_rtsp_send_cmd_with_content
int ff_rtsp_send_cmd_with_content(AVFormatContext *s, const char *method, const char *url, const char *headers, RTSPMessageHeader *reply, unsigned char **content_ptr, const unsigned char *send_content, int send_content_length)
Send a command to the RTSP server and wait for the reply.
mpegts.h
RTPDynamicProtocolHandler::parse_sdp_a_line
int(* parse_sdp_a_line)(AVFormatContext *s, int st_index, PayloadContext *priv_data, const char *line)
Parse the a= line from the sdp field.
Definition: rtpdec.h:129
RTSPStream::rtp_handle
URLContext * rtp_handle
RTP stream handle (if UDP)
Definition: rtsp.h:445
ff_rtp_codec_id
enum AVCodecID ff_rtp_codec_id(const char *buf, enum AVMediaType codec_type)
Return the codec id for the given encoding name and codec type.
Definition: rtp.c:146
RTSPTransportField::port_max
int port_max
Definition: rtsp.h:99
ff_rtp_send_rtcp_feedback
int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio)
Definition: rtpdec.c:469
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
RTSP_SERVER_RTP
@ RTSP_SERVER_RTP
Standards-compliant RTP-server.
Definition: rtsp.h:214
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
RTSPMessageHeader::status_code
enum RTSPStatusCode status_code
response code from server
Definition: rtsp.h:133
ff_rtsp_send_cmd
int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url, const char *headers, RTSPMessageHeader *reply, unsigned char **content_ptr)
Send a command to the RTSP server and wait for the reply.
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
RTSPState::control_transport
enum RTSPControlTransport control_transport
RTSP transport mode, such as plain or tunneled.
Definition: rtsp.h:339
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
avpriv_mpegts_parse_packet
int avpriv_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, const uint8_t *buf, int len)
Definition: mpegts.c:3407
AVIO_FLAG_READ_WRITE
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
Definition: avio.h:619
RTSP_MODE_PLAIN
@ RTSP_MODE_PLAIN
Normal RTSP.
Definition: rtsp.h:71
parse_fmtp
static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)
Definition: rtpdec_latm.c:133
rtpdec_formats.h
RTSP_TRANSPORT_RTP
@ RTSP_TRANSPORT_RTP
Standards-compliant RTP.
Definition: rtsp.h:60
ff_rtp_demuxer
const FFInputFormat ff_rtp_demuxer
RTSPTransportField::source
char source[INET6_ADDRSTRLEN+1]
source IP address
Definition: rtsp.h:117
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
RTSPMessageHeader::range_end
int64_t range_end
Definition: rtsp.h:140
int64_t
long long int64_t
Definition: coverity.c:34
sdp_options
static const AVOption sdp_options[]
Definition: rtsp.c:109
ffurl_write
static int ffurl_write(URLContext *h, const uint8_t *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: url.h:202
RTSPState::get_parameter_supported
int get_parameter_supported
Whether the server supports the GET_PARAMETER method.
Definition: rtsp.h:368
ff_rtsp_averror
static int ff_rtsp_averror(enum RTSPStatusCode status_code, int default_averror)
Definition: rtspcodes.h:144
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
RTSP_DEFAULT_AUDIO_SAMPLERATE
#define RTSP_DEFAULT_AUDIO_SAMPLERATE
Definition: rtsp.h:78
RTSPStream::nb_include_source_addrs
int nb_include_source_addrs
Number of source-specific multicast include source IP addresses (from SDP content)
Definition: rtsp.h:461
RTSPTransportField::server_port_min
int server_port_min
UDP unicast server port range; the ports to which we should connect to receive unicast UDP RTP/RTCP d...
Definition: rtsp.h:107
RTSPState::auth
char auth[128]
plaintext authorization line (username:password)
Definition: rtsp.h:281
RTSPStream::interleaved_min
int interleaved_min
interleave IDs; copies of RTSPTransportField->interleaved_min/max for the selected transport.
Definition: rtsp.h:453
rtp_options
static const AVOption rtp_options[]
Definition: rtsp.c:120
RTSPState::recvbuf_pos
int recvbuf_pos
Definition: rtsp.h:330
AVOption
AVOption.
Definition: opt.h:429
RTSP_RTP_PORT_MIN
#define RTSP_RTP_PORT_MIN
Definition: rtsp.h:79
RTSPTransportField::lower_transport
enum RTSPLowerTransport lower_transport
network layer transport protocol; e.g.
Definition: rtsp.h:123
RTSPState::rtp_port_min
int rtp_port_min
Minimum and maximum local UDP ports.
Definition: rtsp.h:396
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Underlying C type is int64_t.
Definition: opt.h:319
RTSP_LOWER_TRANSPORT_CUSTOM
@ RTSP_LOWER_TRANSPORT_CUSTOM
Custom IO - not a public option for lower_transport_mask, but set in the SDP demuxer based on a flag.
Definition: rtsp.h:48
RTSPTransportField::interleaved_min
int interleaved_min
interleave ids, if TCP transport; each TCP/RTSP data packet starts with a '$', stream length and stre...
Definition: rtsp.h:95
RTSPTransportField::interleaved_max
int interleaved_max
Definition: rtsp.h:95
RTSPStream
Describe a single stream, as identified by a single m= line block in the SDP content.
Definition: rtsp.h:444
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
ff_rtsp_send_cmd_async
int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method, const char *url, const char *headers)
Send a command to the RTSP server without waiting for the reply.
RTSPState::real_challenge
char real_challenge[64]
the "RealChallenge1:" field from the server
Definition: rtsp.h:278
mathematics.h
ff_rdt_calc_response_and_checksum
void ff_rdt_calc_response_and_checksum(char response[41], char chksum[9], const char *challenge)
Calculate the response (RealChallenge2 in the RTSP header) to the challenge (RealChallenge1 in the RT...
Definition: rdt.c:96
AVDictionary
Definition: dict.c:34
ffio_init_read_context
void ffio_init_read_context(FFIOContext *s, const uint8_t *buffer, int buffer_size)
Wrap a buffer in an AVIOContext for reading.
Definition: aviobuf.c:99
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
ff_network_close
void ff_network_close(void)
Definition: network.c:121
RTSPMessageHeader::nb_transports
int nb_transports
number of items in the 'transports' variable below
Definition: rtsp.h:136
RTSP_SERVER_REAL
@ RTSP_SERVER_REAL
Realmedia-style server.
Definition: rtsp.h:215
ff_http_auth_create_response
char * ff_http_auth_create_response(HTTPAuthState *state, const char *auth, const char *path, const char *method)
Definition: httpauth.c:240
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
ff_rtp_check_and_send_back_rr
int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio, int count)
some rtp servers assume client is dead if they don't hear from them...
Definition: rtpdec.c:312
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
RTSPState::seek_timestamp
int64_t seek_timestamp
the seek value requested when calling av_seek_frame().
Definition: rtsp.h:247
ENC
#define ENC
Definition: rtsp.c:67
os_support.h
FFIOContext
Definition: avio_internal.h:28
sockaddr_storage
Definition: network.h:111
ff_network_init
int ff_network_init(void)
Definition: network.c:63
ff_sdp_parse
int ff_sdp_parse(AVFormatContext *s, const char *content)
Parse an SDP description of streams by populating an RTSPState struct within the AVFormatContext; als...
FF_RTP_FLAG_OPTS
#define FF_RTP_FLAG_OPTS(ctx, fieldname)
Definition: rtpenc.h:74
map_to_opts
static AVDictionary * map_to_opts(RTSPState *rt)
Definition: rtsp.c:130
RTSPState::pkt_size
int pkt_size
Definition: rtsp.h:420
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
RTSPStream::feedback
int feedback
Enable sending RTCP feedback messages according to RFC 4585.
Definition: rtsp.h:479
av_get_random_seed
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:167
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
RTSPState::asf_ctx
AVFormatContext * asf_ctx
The following are used for RTP/ASF streams.
Definition: rtsp.h:315
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:363
freeaddrinfo
#define freeaddrinfo
Definition: network.h:218
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:862
RTSP_FLAG_SATIP_RAW
#define RTSP_FLAG_SATIP_RAW
Export SAT>IP stream as raw MPEG-TS.
Definition: rtsp.h:432
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:419
fail
#define fail()
Definition: checkasm.h:188
ff_rtp_get_local_rtp_port
int ff_rtp_get_local_rtp_port(URLContext *h)
Return the local rtp port used by the RTP connection.
Definition: rtpproto.c:539
rtpenc_chain.h
ff_rtp_set_remote_url
int ff_rtp_set_remote_url(URLContext *h, const char *uri)
If no filename is given to av_open_input_file because you want to get the local port first,...
Definition: rtpproto.c:104
RTSPState::nb_rtsp_streams
int nb_rtsp_streams
number of items in the 'rtsp_streams' variable
Definition: rtsp.h:231
ffurl_connect
int ffurl_connect(URLContext *uc, AVDictionary **options)
Connect an URLContext that has been allocated by ffurl_alloc.
Definition: avio.c:205
sockaddr_storage::ss_family
uint16_t ss_family
Definition: network.h:116
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
ff_rdt_parse_packet
int ff_rdt_parse_packet(RDTDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Parse RDT-style packet data (header + media data).
Definition: rdt.c:339
get_word
static void get_word(char *buf, int buf_size, const char **pp)
Definition: rtsp.c:168
dynarray_add
#define dynarray_add(tab, nb_ptr, elem)
Definition: internal.h:450
OFFSET
#define OFFSET(x)
Definition: rtsp.c:65
RTSPMessageHeader::content_length
int content_length
length of the data following this header
Definition: rtsp.h:131
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:827
RTPDynamicProtocolHandler::close
void(* close)(PayloadContext *protocol_data)
Free any data needed by the rtp parsing for this dynamic data.
Definition: rtpdec.h:134
ff_rtp_parse_set_crypto
void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite, const char *params)
Definition: rtpdec.c:628
RTSP_TRANSPORT_RDT
@ RTSP_TRANSPORT_RDT
Realmedia Data Transport.
Definition: rtsp.h:61
ff_check_interrupt
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:854
RTSP_STATE_STREAMING
@ RTSP_STATE_STREAMING
initialized and sending/receiving data
Definition: rtsp.h:204
rtsp.h
ff_rtsp_setup_input_streams
int ff_rtsp_setup_input_streams(AVFormatContext *s, RTSPMessageHeader *reply)
Get the description of the stream and set up the RTSPStream child objects.
Definition: rtspdec.c:614
RTSPState::lower_transport_mask
int lower_transport_mask
A mask with all requested transport methods.
Definition: rtsp.h:352
RTSP_MODE_TUNNEL
@ RTSP_MODE_TUNNEL
RTSP over HTTP (tunneling)
Definition: rtsp.h:72
SPACE_CHARS
#define SPACE_CHARS
Definition: dnn_backend_tf.c:356
RTSPStream::stream_index
int stream_index
corresponding stream index, if any.
Definition: rtsp.h:449
RTSPTransportField::destination
struct sockaddr_storage destination
destination IP address
Definition: rtsp.h:116
URLContext::priv_data
void * priv_data
Definition: url.h:38
ff_rdt_parse_close
void ff_rdt_parse_close(RDTDemuxContext *s)
Definition: rdt.c:80
avassert.h
RTSP_LOWER_TRANSPORT_HTTPS
@ RTSP_LOWER_TRANSPORT_HTTPS
HTTPS tunneled.
Definition: rtsp.h:47
RTSPState::rtsp_hd_out
URLContext * rtsp_hd_out
Additional output handle, used when input and output are done separately, eg for HTTP tunneling.
Definition: rtsp.h:336
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:235
avpriv_mpegts_parse_close
void avpriv_mpegts_parse_close(MpegTSContext *ts)
Definition: mpegts.c:3432
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
RTSP_FLAG_LISTEN
#define RTSP_FLAG_LISTEN
Wait for incoming connections.
Definition: rtsp.h:427
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
RTSPState::reordering_queue_size
int reordering_queue_size
Size of RTP packet reordering queue.
Definition: rtsp.h:411
ffurl_open_whitelist
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it.
Definition: avio.c:362
RTSPState::ts
struct MpegTSContext * ts
The following are used for parsing raw mpegts in udp.
Definition: rtsp.h:329
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
RTSPState::nb_byes
int nb_byes
Definition: rtsp.h:344
AI_NUMERICHOST
#define AI_NUMERICHOST
Definition: network.h:187
avio_read_to_bprint
int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size)
Read contents of h into print buffer, up to max_size bytes, or up to EOF.
Definition: aviobuf.c:1251
RTSPState::p
struct pollfd * p
Polling array for udp.
Definition: rtsp.h:362
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
RTSPMessageHeader::location
char location[4096]
the "Location:" field.
Definition: rtsp.h:154
RTSPState::control_uri
char control_uri[MAX_URL_SIZE]
some MS RTSP streams contain a URL in the SDP that we need to use for all subsequent RTSP requests,...
Definition: rtsp.h:325
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVProbeData::filename
const char * filename
Definition: avformat.h:452
RTSPMessageHeader::transports
RTSPTransportField transports[RTSP_MAX_TRANSPORTS]
describes the complete "Transport:" line of the server in response to a SETUP RTSP command by the cli...
Definition: rtsp.h:144
RTSPMessageHeader::stream_id
char stream_id[64]
SAT>IP com.ses.streamID header.
Definition: rtsp.h:194
ff_url_join
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...)
Definition: url.c:40
filters
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
Definition: af_crystalizer.c:55
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Underlying C type is int64_t.
Definition: opt.h:263
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
ff_rtsp_undo_setup
void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
Undo the effect of ff_rtsp_make_setup_request, close the transport_priv and rtp_handle fields.
Definition: rtsp.c:760
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
RTSPState::buffer_size
int buffer_size
Definition: rtsp.h:419
ff_rtsp_open_transport_ctx
int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
Open RTSP transport context.
Definition: rtsp.c:828
RTSPTransportField::ttl
int ttl
time-to-live value (required for multicast); the amount of HOPs that packets will be allowed to make ...
Definition: rtsp.h:111
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
ff_rtsp_fetch_packet
int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
Receive one packet from the RTSPStreams set up in the AVFormatContext (which should contain a RTSPSta...
RTSPStream::dynamic_handler
const RTPDynamicProtocolHandler * dynamic_handler
The following are used for dynamic protocols (rtpdec_*.c/rdt.c)
Definition: rtsp.h:472
av_stristart
int av_stristart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str independent of case.
Definition: avstring.c:47
RTSPMessageHeader::seq
int seq
sequence number
Definition: rtsp.h:146
key
const char * key
Definition: hwcontext_opencl.c:189
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
RTSP_FLAG_OPTS
#define RTSP_FLAG_OPTS(name, longname)
Definition: rtsp.c:69
ff_rtp_handler_find_by_id
const RTPDynamicProtocolHandler * ff_rtp_handler_find_by_id(int id, enum AVMediaType codec_type)
Find a registered rtp dynamic protocol handler with a matching codec ID.
Definition: rtpdec.c:173
handler
static void handler(vbi_event *ev, void *user_data)
Definition: libzvbi-teletextdec.c:508
RTP_REORDER_QUEUE_DEFAULT_SIZE
#define RTP_REORDER_QUEUE_DEFAULT_SIZE
Definition: rtpdec.h:39
ff_http_auth_handle_header
void ff_http_auth_handle_header(HTTPAuthState *state, const char *key, const char *value)
Definition: httpauth.c:90
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
ff_rtsp_setup_output_streams
int ff_rtsp_setup_output_streams(AVFormatContext *s, const char *addr)
Announce the stream to the server and set up the RTSPStream child objects for each media stream.
Definition: rtspenc.c:47
RTSP_MEDIATYPE_OPTS
#define RTSP_MEDIATYPE_OPTS(name, longname)
Definition: rtsp.c:73
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
internal.h
opts
AVDictionary * opts
Definition: movenc.c:51
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
RTP_PT_PRIVATE
#define RTP_PT_PRIVATE
Definition: rtp.h:79
RTSPState::session_id
char session_id[512]
copy of RTSPMessageHeader->session_id, i.e.
Definition: rtsp.h:253
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
RTSPMessageHeader::reason
char reason[256]
The "reason" is meant to specify better the meaning of the error code returned.
Definition: rtsp.h:184
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:538
RTSP_STATUS_OK
@ RTSP_STATUS_OK
Definition: rtspcodes.h:33
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
URLContext::protocol_whitelist
const char * protocol_whitelist
Definition: url.h:46
ff_rtsp_next_attr_and_value
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:787
NULL
#define NULL
Definition: coverity.c:32
RECVBUF_SIZE
#define RECVBUF_SIZE
Definition: rtsp.c:62
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
RTSPState::rtsp_hd
URLContext * rtsp_hd
Definition: rtsp.h:228
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1251
ff_rtp_queued_packet_time
int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
Definition: rtpdec.c:826
ff_http_init_auth_state
void ff_http_init_auth_state(URLContext *dest, const URLContext *src)
Initialize the authentication state based on another HTTP URLContext.
Definition: http.c:200
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1342
RTSPState::default_lang
char default_lang[4]
Definition: rtsp.h:418
RTSPMessageHeader::real_challenge
char real_challenge[64]
the "RealChallenge1:" field from the server
Definition: rtsp.h:157
get_word_sep
static void get_word_sep(char *buf, int buf_size, const char *sep, const char **pp)
Definition: rtsp.c:161
parseutils.h
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
SDP_MAX_SIZE
#define SDP_MAX_SIZE
Definition: rtsp.h:81
AV_CODEC_ID_MPEG2TS
@ AV_CODEC_ID_MPEG2TS
FAKE codec to indicate a raw MPEG-2 TS stream (only used by libavformat)
Definition: codec_id.h:597
DEC
#define DEC
Definition: rtsp.c:66
RTSP_MAX_TRANSPORTS
#define RTSP_MAX_TRANSPORTS
Definition: rtsp.h:77
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:589
RTPDemuxContext::rtcp_ts_offset
int64_t rtcp_ts_offset
Definition: rtpdec.h:180
time.h
RTSPState::state
enum RTSPClientState state
indicator of whether we are currently receiving data from the server.
Definition: rtsp.h:239
RTSPState::recvbuf
uint8_t * recvbuf
Reusable buffer for receiving packets.
Definition: rtsp.h:347
RTSP_FLAG_PREFER_TCP
#define RTSP_FLAG_PREFER_TCP
Try RTP via TCP first if possible.
Definition: rtsp.h:431
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
RTSPStream::sdp_port
int sdp_port
The following are used only in SDP, not RTSP.
Definition: rtsp.h:459
base64.h
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:461
RTSPStream::exclude_source_addrs
struct RTSPSource ** exclude_source_addrs
Source-specific multicast exclude source IP addresses (from SDP content)
Definition: rtsp.h:464
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
rtpdec.h
ff_log2_tab
const uint8_t ff_log2_tab[256]
Definition: log2_tab.c:23
get_sockaddr
static int get_sockaddr(AVFormatContext *s, const char *buf, struct sockaddr_storage *sock)
Definition: rtsp.c:199
ff_rtp_parse_close
void ff_rtp_parse_close(RTPDemuxContext *s)
Definition: rtpdec.c:958
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:217
interleave
static void interleave(uint8_t *dst, uint8_t *src, int w, int h, int dst_linesize, int src_linesize, enum FilterMode mode, int swap)
Definition: vf_il.c:110
RTP_PT_IS_RTCP
#define RTP_PT_IS_RTCP(x)
Definition: rtp.h:112
options
const OptionDef options[]
RTSPSource
Definition: rtsp.h:434
ff_rtp_parse_open
RTPDemuxContext * ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, int queue_size)
open a new RTP parse context for stream 'st'.
Definition: rtpdec.c:574
NI_NUMERICHOST
#define NI_NUMERICHOST
Definition: network.h:195
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
RTSPStream::dynamic_protocol_context
PayloadContext * dynamic_protocol_context
private data associated with the dynamic protocol
Definition: rtsp.h:475
AVMediaType
AVMediaType
Definition: avutil.h:199
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
ff_rtsp_tcp_read_packet
int ff_rtsp_tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, uint8_t *buf, int buf_size)
Receive one RTP packet from an TCP interleaved RTSP stream.
Definition: rtspdec.c:785
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
RTSPState::rtsp_flags
int rtsp_flags
Various option flags for the RTSP muxer/demuxer.
Definition: rtsp.h:386
ffurl_get_multi_file_handle
int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Return the file descriptors associated with this URL.
Definition: avio.c:821
ff_rtsp_options
const AVOption ff_rtsp_options[]
Definition: rtsp.c:86
ff_rtsp_close_connections
void ff_rtsp_close_connections(AVFormatContext *s)
Close all connection handles within the RTSP (de)muxer.
RTSPState
Private data for the RTSP demuxer.
Definition: rtsp.h:226
RTSPStream::include_source_addrs
struct RTSPSource ** include_source_addrs
Source-specific multicast include source IP addresses (from SDP content)
Definition: rtsp.h:462
RTSPState::lower_transport
enum RTSPLowerTransport lower_transport
the negotiated network layer transport protocol; e.g.
Definition: rtsp.h:270
RTSPMessageHeader::range_start
int64_t range_start
Time range of the streams that the server will stream.
Definition: rtsp.h:140
RTSPState::recvbuf_len
int recvbuf_len
Definition: rtsp.h:331
RTSPState::last_reply
char last_reply[2048]
The last reply of the server to a RTSP command.
Definition: rtsp.h:287
size
int size
Definition: twinvq_data.h:10344
RTSPTransportField::transport
enum RTSPTransport transport
data/packet transport protocol; e.g.
Definition: rtsp.h:120
RTPDemuxContext::first_rtcp_ntp_time
uint64_t first_rtcp_ntp_time
Definition: rtpdec.h:178
RTSPState::rtsp_streams
struct RTSPStream ** rtsp_streams
streams in this session
Definition: rtsp.h:233
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
NTP_OFFSET_US
#define NTP_OFFSET_US
Definition: internal.h:499
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
ff_rtsp_skip_packet
int ff_rtsp_skip_packet(AVFormatContext *s)
Skip a RTP/TCP interleaved packet.
RTSPState::seq
int seq
RTSP command sequence number.
Definition: rtsp.h:249
COMMON_OPTS
#define COMMON_OPTS()
Definition: rtsp.c:80
RTSPStream::crypto_params
char crypto_params[100]
Definition: rtsp.h:485
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
header
static const uint8_t header[24]
Definition: sdr2.c:68
RTSPState::max_p
int max_p
Definition: rtsp.h:363
RTSPState::auth_state
HTTPAuthState auth_state
authentication state
Definition: rtsp.h:284
ff_rtp_get_codec_info
int ff_rtp_get_codec_info(AVCodecParameters *par, int payload_type)
Initialize a codec context based on the payload type.
Definition: rtp.c:71
ff_rtp_handler_find_by_name
const RTPDynamicProtocolHandler * ff_rtp_handler_find_by_name(const char *name, enum AVMediaType codec_type)
Find a registered rtp dynamic protocol handler with the specified name.
Definition: rtpdec.c:159
line
Definition: graph2dot.c:48
ff_rdt_parse_open
RDTDemuxContext * ff_rdt_parse_open(AVFormatContext *ic, int first_stream_of_set_idx, void *priv_data, const RTPDynamicProtocolHandler *handler)
Allocate and init the RDT parsing context.
Definition: rdt.c:57
READ_PACKET_TIMEOUT_S
#define READ_PACKET_TIMEOUT_S
Definition: rtsp.c:61
ff_rtsp_parse_line
void ff_rtsp_parse_line(AVFormatContext *s, RTSPMessageHeader *reply, const char *buf, RTSPState *rt, const char *method)
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
gai_strerror
#define gai_strerror
Definition: network.h:225
RTSPStream::nb_exclude_source_addrs
int nb_exclude_source_addrs
Number of source-specific multicast exclude source IP addresses (from SDP content)
Definition: rtsp.h:463
ff_real_parse_sdp_a_line
void ff_real_parse_sdp_a_line(AVFormatContext *s, int stream_index, const char *line)
Parse a server-related SDP line.
Definition: rdt.c:519
RTSPState::timeout
int timeout
copy of RTSPMessageHeader->timeout, i.e.
Definition: rtsp.h:258
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
DEFAULT_REORDERING_DELAY
#define DEFAULT_REORDERING_DELAY
Definition: rtsp.c:63
RTSPTransportField::client_port_max
int client_port_max
Definition: rtsp.h:103
ffurl_alloc
int ffurl_alloc(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb)
Create a URLContext for accessing to the resource indicated by url, but do not initiate the connectio...
Definition: avio.c:349
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:834
getaddrinfo
#define getaddrinfo
Definition: network.h:217
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1295
RTSP_SERVER_SATIP
@ RTSP_SERVER_SATIP
SAT>IP server.
Definition: rtsp.h:217
bprint.h
HTTP_AUTH_NONE
@ HTTP_AUTH_NONE
No authentication specified.
Definition: httpauth.h:29
AV_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
RTSPState::media_type_mask
int media_type_mask
Mask of all requested media types.
Definition: rtsp.h:391
URLContext
Definition: url.h:35
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
RTSPSource::addr
char addr[128]
Source-specific multicast include source IP address (from SDP content)
Definition: rtsp.h:435
avio_internal.h
getnameinfo
#define getnameinfo
Definition: network.h:219
ff_rtp_parse_packet
int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Parse an RTP or RTCP packet directly sent as a buffer.
Definition: rtpdec.c:945
RTPDemuxContext::ssrc
uint32_t ssrc
Definition: rtpdec.h:152
RTSPMessageHeader::timeout
int timeout
The "timeout" comes as part of the server response to the "SETUP" command, in the "Session: <xyz>[;ti...
Definition: rtsp.h:174
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
RTSPState::need_subscription
int need_subscription
The following are used for Real stream selection.
Definition: rtsp.h:296
RTCP_BYE
@ RTCP_BYE
Definition: rtp.h:102
rtpproto.h
RTPDemuxContext::st
AVStream * st
Definition: rtpdec.h:150
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
ff_rtsp_tcp_write_packet
int ff_rtsp_tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st)
Send buffered packets over TCP.
Definition: rtspenc.c:143
av_url_split
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:351
ff_rtsp_parse_streaming_commands
int ff_rtsp_parse_streaming_commands(AVFormatContext *s)
Parse RTSP commands (OPTIONS, PAUSE and TEARDOWN) during streaming in listen mode.
Definition: rtspdec.c:485
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
RTSPStream::ssrc
uint32_t ssrc
SSRC for this stream, to allow identifying RTCP packets before the first RTP packet.
Definition: rtsp.h:482
url.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
RTSP_LOWER_TRANSPORT_TCP
@ RTSP_LOWER_TRANSPORT_TCP
TCP; interleaved in RTSP.
Definition: rtsp.h:41
demux.h
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2228
rtpenc.h
RTSPStream::sdp_ttl
int sdp_ttl
IP Time-To-Live (from SDP content)
Definition: rtsp.h:465
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
RTSP_FLAG_CUSTOM_IO
#define RTSP_FLAG_CUSTOM_IO
Do all IO via the AVIOContext.
Definition: rtsp.h:428
RTPDemuxContext
Definition: rtpdec.h:148
RTSPTransportField::client_port_min
int client_port_min
UDP client ports; these should be the local ports of the UDP RTP (and RTCP) sockets over which we rec...
Definition: rtsp.h:103
version.h
RTSPState::rtp_port_max
int rtp_port_max
Definition: rtsp.h:396
ffurl_closep
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
Definition: avio.c:588
RTSP_LOWER_TRANSPORT_UDP_MULTICAST
@ RTSP_LOWER_TRANSPORT_UDP_MULTICAST
UDP/multicast.
Definition: rtsp.h:42
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1435
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
RTSPState::cur_transport_priv
void * cur_transport_priv
RTSPStream->transport_priv of the last stream that we read a packet from.
Definition: rtsp.h:291
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
av_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:95
RTSPStream::sdp_payload_type
int sdp_payload_type
payload type
Definition: rtsp.h:466
ff_wms_parse_sdp_a_line
int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
Parse a Windows Media Server-specific SDP line.
Definition: rtpdec_asf.c:100
avformat.h
ff_rtp_chain_mux_open
int ff_rtp_chain_mux_open(AVFormatContext **out, AVFormatContext *s, AVStream *st, URLContext *handle, int packet_size, int idx)
Definition: rtpenc_chain.c:29
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
dict.h
network.h
RTP_MAX_PACKET_LENGTH
#define RTP_MAX_PACKET_LENGTH
Definition: rtpdec.h:37
rtsp_parse_range_npt
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
Parse a string p in the form of Range:npt=xx-xx, and determine the start and end time.
Definition: rtsp.c:177
RTSPStream::sdp_ip
struct sockaddr_storage sdp_ip
IP address (from SDP content)
Definition: rtsp.h:460
HTTPAuthState::stale
int stale
Auth ok, but needs to be resent with a new nonce.
Definition: httpauth.h:71
RTSP_DEFAULT_PORT
#define RTSP_DEFAULT_PORT
Definition: rtsp.h:75
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
RTSP_LOWER_TRANSPORT_HTTP
@ RTSP_LOWER_TRANSPORT_HTTP
HTTP tunneled - not a proper transport mode as such, only for use via AVOptions.
Definition: rtsp.h:44
RTSPTransportField
This describes a single item in the "Transport:" line of one stream as negotiated by the SETUP RTSP c...
Definition: rtsp.h:90
RTSPState::transport
enum RTSPTransport transport
the negotiated data/packet transport protocol; e.g.
Definition: rtsp.h:266
random_seed.h
MAX_URL_SIZE
#define MAX_URL_SIZE
Definition: internal.h:30
RTPDemuxContext::base_timestamp
uint32_t base_timestamp
Definition: rtpdec.h:155
RTSPStream::control_url
char control_url[MAX_URL_SIZE]
url for this stream (from SDP)
Definition: rtsp.h:455
addrinfo::ai_flags
int ai_flags
Definition: network.h:138
RTSPStream::interleaved_max
int interleaved_max
Definition: rtsp.h:453
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
RTSPState::localaddr
char * localaddr
Definition: rtsp.h:421
headers
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
Definition: build_system.txt:34
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:147
RTSP_SERVER_WMS
@ RTSP_SERVER_WMS
Windows Media server.
Definition: rtsp.h:216
avpriv_mpegts_parse_open
MpegTSContext * avpriv_mpegts_parse_open(AVFormatContext *s)
Definition: mpegts.c:3385
RTSPMessageHeader
This describes the server response to each RTSP command.
Definition: rtsp.h:129
av_base64_encode
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:147
RTSP_TRANSPORT_RAW
@ RTSP_TRANSPORT_RAW
Raw data (over UDP)
Definition: rtsp.h:62
ff_mpegts_dynamic_handler
const RTPDynamicProtocolHandler ff_mpegts_dynamic_handler
Definition: rtpdec_mpegts.c:92
RTSP_RTP_PORT_MAX
#define RTSP_RTP_PORT_MAX
Definition: rtsp.h:80
RTSPState::stimeout
int64_t stimeout
timeout of socket i/o operations.
Definition: rtsp.h:406
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
Definition: dict.c:167
HTTPAuthType
HTTPAuthType
Authentication types, ordered from weakest to strongest.
Definition: httpauth.h:28
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:617
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
desc
const char * desc
Definition: libsvtav1.c:79
RTSP_STATE_IDLE
@ RTSP_STATE_IDLE
not initialized
Definition: rtsp.h:203
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
mem.h
HTTPAuthState::auth_type
int auth_type
The currently chosen auth type.
Definition: httpauth.h:59
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:386
ffurl_read_complete
int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
Read as many bytes as possible (up to size), calling the read function multiple times if necessary.
Definition: avio.c:557
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
rdt.h
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
RTSP_LOWER_TRANSPORT_NB
@ RTSP_LOWER_TRANSPORT_NB
Definition: rtsp.h:43
ff_rtp_parse_set_dynamic_protocol
void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, const RTPDynamicProtocolHandler *handler)
Definition: rtpdec.c:621
AVPacket
This structure stores compressed data.
Definition: packet.h:516
RTSPState::server_type
enum RTSPServerType server_type
brand of server that we're talking to; e.g.
Definition: rtsp.h:275
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
RTSPMessageHeader::content_type
char content_type[64]
Content type header.
Definition: rtsp.h:189
RTSPTransportField::server_port_max
int server_port_max
Definition: rtsp.h:107
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: avio.c:649
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
POLLING_TIME
#define POLLING_TIME
Definition: network.h:249
FFInputFormat
Definition: demux.h:37
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
RTSPTransportField::mode_record
int mode_record
transport set to record data
Definition: rtsp.h:114
RTSPState::accept_dynamic_rate
int accept_dynamic_rate
Whether the server accepts the x-Dynamic-Rate header.
Definition: rtsp.h:381
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
RTSPMessageHeader::session_id
char session_id[512]
the "Session:" field.
Definition: rtsp.h:150
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_rtsp_make_setup_request
int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port, int lower_transport, const char *real_challenge)
Do the SETUP requests for each stream for the chosen lower transport mode.
ff_rtp_enc_name
const char * ff_rtp_enc_name(int payload_type)
Return the encoding name (as defined in http://www.iana.org/assignments/rtp-parameters) for a given p...
Definition: rtp.c:135
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3741
RTSPMessageHeader::server
char server[64]
the "Server: field, which can be used to identify some special-case servers that are not 100% standar...
Definition: rtsp.h:166
RTSPStream::crypto_suite
char crypto_suite[40]
Definition: rtsp.h:484
get_word_until_chars
static void get_word_until_chars(char *buf, int buf_size, const char *sep, const char **pp)
Definition: rtsp.c:142
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
addrinfo
Definition: network.h:137
http.h
codec_desc.h
ff_rtsp_connect
int ff_rtsp_connect(AVFormatContext *s)
Connect to the RTSP server and set up the individual media streams.
RTSPTransportField::port_min
int port_min
UDP multicast port range; the ports to which we should connect to receive multicast UDP data.
Definition: rtsp.h:99
ff_sdp_demuxer
const FFInputFormat ff_sdp_demuxer
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
ff_format_set_url
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: avformat.c:946
RTSP_FLAG_FILTER_SRC
#define RTSP_FLAG_FILTER_SRC
Filter incoming UDP packets - receive packets only from the right source address and port.
Definition: rtsp.h:424
RTSPMessageHeader::notice
int notice
The "Notice" or "X-Notice" field value.
Definition: rtsp.h:179
avio_read_partial
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:684
ffurl_get_file_handle
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
Definition: avio.c:814
RTSPS_DEFAULT_PORT
#define RTSPS_DEFAULT_PORT
Definition: rtsp.h:76
RTSP_LOWER_TRANSPORT_UDP
@ RTSP_LOWER_TRANSPORT_UDP
UDP/unicast.
Definition: rtsp.h:40
read
static uint32_t BS_FUNC() read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition: bitstream_template.h:231
RTPDynamicProtocolHandler
Definition: rtpdec.h:116
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
RTSPState::user_agent
char * user_agent
User-Agent string.
Definition: rtsp.h:416
RTSP_FLAG_RTCP_TO_SOURCE
#define RTSP_FLAG_RTCP_TO_SOURCE
Send RTCP packets to the source address of received packets.
Definition: rtsp.h:429
ffurl_read
static int ffurl_read(URLContext *h, uint8_t *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf.
Definition: url.h:181