FFmpeg
rtspdec.c
Go to the documentation of this file.
1 /*
2  * RTSP demuxer
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/avstring.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/random_seed.h"
28 #include "libavutil/time.h"
29 #include "avformat.h"
30 #include "demux.h"
31 
32 #include "internal.h"
33 #include "network.h"
34 #include "os_support.h"
35 #include "rtpproto.h"
36 #include "rtsp.h"
37 #include "rdt.h"
38 #include "tls.h"
39 #include "url.h"
40 #include "version.h"
41 
42 static const struct RTSPStatusMessage {
44  const char *message;
45 } status_messages[] = {
46  { RTSP_STATUS_OK, "OK" },
47  { RTSP_STATUS_METHOD, "Method Not Allowed" },
48  { RTSP_STATUS_BANDWIDTH, "Not Enough Bandwidth" },
49  { RTSP_STATUS_SESSION, "Session Not Found" },
50  { RTSP_STATUS_STATE, "Method Not Valid in This State" },
51  { RTSP_STATUS_AGGREGATE, "Aggregate operation not allowed" },
52  { RTSP_STATUS_ONLY_AGGREGATE, "Only aggregate operation allowed" },
53  { RTSP_STATUS_TRANSPORT, "Unsupported transport" },
54  { RTSP_STATUS_INTERNAL, "Internal Server Error" },
55  { RTSP_STATUS_SERVICE, "Service Unavailable" },
56  { RTSP_STATUS_VERSION, "RTSP Version not supported" },
57  { 0, "NULL" }
58 };
59 
61 {
62  RTSPState *rt = s->priv_data;
63 
64  if (!(rt->rtsp_flags & RTSP_FLAG_LISTEN))
65  ff_rtsp_send_cmd_async(s, "TEARDOWN", rt->control_uri, NULL);
66 
70  rt->real_setup = NULL;
72  return 0;
73 }
74 
75 static inline int read_line(AVFormatContext *s, char *rbuf, const int rbufsize,
76  int *rbuflen)
77 {
78  RTSPState *rt = s->priv_data;
79  int idx = 0;
80  int ret = 0;
81  *rbuflen = 0;
82 
83  do {
84  ret = ffurl_read_complete(rt->rtsp_hd, rbuf + idx, 1);
85  if (ret <= 0)
86  return ret ? ret : AVERROR_EOF;
87  if (rbuf[idx] == '\r') {
88  /* Ignore */
89  } else if (rbuf[idx] == '\n') {
90  rbuf[idx] = '\0';
91  *rbuflen = idx;
92  return 0;
93  } else
94  idx++;
95  } while (idx < rbufsize);
96  av_log(s, AV_LOG_ERROR, "Message too long\n");
97  return AVERROR(EIO);
98 }
99 
101  const char *extracontent, uint16_t seq)
102 {
103  RTSPState *rt = s->priv_data;
104  char message[MAX_URL_SIZE];
105  int index = 0;
106  while (status_messages[index].code) {
107  if (status_messages[index].code == code) {
108  snprintf(message, sizeof(message), "RTSP/1.0 %d %s\r\n",
110  break;
111  }
112  index++;
113  }
114  if (!status_messages[index].code)
115  return AVERROR(EINVAL);
116  av_strlcatf(message, sizeof(message), "CSeq: %d\r\n", seq);
117  av_strlcatf(message, sizeof(message), "Server: %s\r\n", LIBAVFORMAT_IDENT);
118  if (extracontent)
119  av_strlcat(message, extracontent, sizeof(message));
120  av_strlcat(message, "\r\n", sizeof(message));
121  av_log(s, AV_LOG_TRACE, "Sending response:\n%s", message);
122  ffurl_write(rt->rtsp_hd_out, message, strlen(message));
123 
124  return 0;
125 }
126 
127 static inline int check_sessionid(AVFormatContext *s,
128  RTSPMessageHeader *request)
129 {
130  RTSPState *rt = s->priv_data;
131  unsigned char *session_id = rt->session_id;
132  if (!session_id[0]) {
133  av_log(s, AV_LOG_WARNING, "There is no session-id at the moment\n");
134  return 0;
135  }
136  if (strcmp(session_id, request->session_id)) {
137  av_log(s, AV_LOG_ERROR, "Unexpected session-id %s\n",
138  request->session_id);
141  }
142  return 0;
143 }
144 
146  RTSPMessageHeader *request,
147  const char *method)
148 {
149  RTSPState *rt = s->priv_data;
150  char rbuf[MAX_URL_SIZE];
151  int rbuflen, ret;
152  do {
153  ret = read_line(s, rbuf, sizeof(rbuf), &rbuflen);
154  if (ret)
155  return ret;
156  if (rbuflen > 1) {
157  av_log(s, AV_LOG_TRACE, "Parsing[%d]: %s\n", rbuflen, rbuf);
158  ff_rtsp_parse_line(s, request, rbuf, rt, method);
159  }
160  } while (rbuflen > 0);
161  if (request->seq != rt->seq + 1) {
162  av_log(s, AV_LOG_ERROR, "Unexpected Sequence number %d\n",
163  request->seq);
164  return AVERROR(EINVAL);
165  }
166  if (rt->session_id[0] && strcmp(method, "OPTIONS")) {
167  ret = check_sessionid(s, request);
168  if (ret)
169  return ret;
170  }
171 
172  return 0;
173 }
174 
176 {
177  RTSPState *rt = s->priv_data;
178  RTSPMessageHeader request = { 0 };
179  char *sdp;
180  int ret;
181 
182  ret = rtsp_read_request(s, &request, "ANNOUNCE");
183  if (ret)
184  return ret;
185  rt->seq++;
186  if (strcmp(request.content_type, "application/sdp")) {
187  av_log(s, AV_LOG_ERROR, "Unexpected content type %s\n",
188  request.content_type);
191  }
192  if (request.content_length) {
193  sdp = av_malloc(request.content_length + 1);
194  if (!sdp)
195  return AVERROR(ENOMEM);
196 
197  /* Read SDP */
198  if (ffurl_read_complete(rt->rtsp_hd, sdp, request.content_length)
199  < request.content_length) {
201  "Unable to get complete SDP Description in ANNOUNCE\n");
203  av_free(sdp);
204  return AVERROR(EIO);
205  }
206  sdp[request.content_length] = '\0';
207  av_log(s, AV_LOG_VERBOSE, "SDP: %s\n", sdp);
208  ret = ff_sdp_parse(s, sdp);
209  av_free(sdp);
210  if (ret)
211  return ret;
213  return 0;
214  }
216  "Content-Length header value exceeds sdp allocated buffer (4KB)\n");
218  "Content-Length exceeds buffer size", request.seq);
219  return AVERROR(EIO);
220 }
221 
223 {
224  RTSPState *rt = s->priv_data;
225  RTSPMessageHeader request = { 0 };
226  int ret = 0;
227 
228  /* Parsing headers */
229  ret = rtsp_read_request(s, &request, "OPTIONS");
230  if (ret)
231  return ret;
232  rt->seq++;
233  /* Send Reply */
235  "Public: ANNOUNCE, PAUSE, SETUP, TEARDOWN, RECORD\r\n",
236  request.seq);
237  return 0;
238 }
239 
240 static int rtsp_read_setup(AVFormatContext *s, char* host, char *controlurl)
241 {
242  RTSPState *rt = s->priv_data;
243  RTSPMessageHeader request = { 0 };
244  int ret = 0;
245  char url[MAX_URL_SIZE];
246  RTSPStream *rtsp_st;
247  char responseheaders[MAX_URL_SIZE];
248  int localport = -1;
249  int transportidx = 0;
250  int streamid = 0;
251 
252  ret = rtsp_read_request(s, &request, "SETUP");
253  if (ret)
254  return ret;
255  rt->seq++;
256  if (!request.nb_transports) {
257  av_log(s, AV_LOG_ERROR, "No transport defined in SETUP\n");
258  return AVERROR_INVALIDDATA;
259  }
260  for (transportidx = 0; transportidx < request.nb_transports;
261  transportidx++) {
262  if (!request.transports[transportidx].mode_record ||
263  (request.transports[transportidx].lower_transport !=
265  request.transports[transportidx].lower_transport !=
267  av_log(s, AV_LOG_ERROR, "mode=record/receive not set or transport"
268  " protocol not supported (yet)\n");
269  return AVERROR_INVALIDDATA;
270  }
271  }
272  if (request.nb_transports > 1)
273  av_log(s, AV_LOG_WARNING, "More than one transport not supported, "
274  "using first of all\n");
275  for (streamid = 0; streamid < rt->nb_rtsp_streams; streamid++) {
276  if (!strcmp(rt->rtsp_streams[streamid]->control_url,
277  controlurl))
278  break;
279  }
280  if (streamid == rt->nb_rtsp_streams) {
281  av_log(s, AV_LOG_ERROR, "Unable to find requested track\n");
283  }
284  rtsp_st = rt->rtsp_streams[streamid];
285  localport = rt->rtp_port_min;
286 
287  /* check if the stream has already been setup */
288  if (rtsp_st->transport_priv) {
289  if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
291  else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)
293  rtsp_st->transport_priv = NULL;
294  }
295  if (rtsp_st->rtp_handle)
296  ffurl_closep(&rtsp_st->rtp_handle);
297 
300  if ((ret = ff_rtsp_open_transport_ctx(s, rtsp_st))) {
302  return ret;
303  }
304  rtsp_st->interleaved_min = request.transports[0].interleaved_min;
305  rtsp_st->interleaved_max = request.transports[0].interleaved_max;
306  snprintf(responseheaders, sizeof(responseheaders), "Transport: "
307  "RTP/AVP/TCP;unicast;mode=record;interleaved=%d-%d"
308  "\r\n", request.transports[0].interleaved_min,
309  request.transports[0].interleaved_max);
310  } else {
311  do {
313  av_dict_set_int(&opts, "buffer_size", rt->buffer_size, 0);
314  ff_url_join(url, sizeof(url), "rtp", NULL, host, localport, NULL);
315  av_log(s, AV_LOG_TRACE, "Opening: %s\n", url);
317  &s->interrupt_callback, &opts,
318  s->protocol_whitelist, s->protocol_blacklist, NULL);
319  av_dict_free(&opts);
320  if (ret)
321  localport += 2;
322  } while (ret || localport > rt->rtp_port_max);
323  if (localport > rt->rtp_port_max) {
325  return ret;
326  }
327 
328  av_log(s, AV_LOG_TRACE, "Listening on: %d\n",
330  if ((ret = ff_rtsp_open_transport_ctx(s, rtsp_st))) {
332  return ret;
333  }
334 
335  localport = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
336  snprintf(responseheaders, sizeof(responseheaders), "Transport: "
337  "RTP/AVP/UDP;unicast;mode=record;source=%s;"
338  "client_port=%d-%d;server_port=%d-%d\r\n",
339  host, request.transports[0].client_port_min,
340  request.transports[0].client_port_max, localport,
341  localport + 1);
342  }
343 
344  /* Establish sessionid if not previously set */
345  /* Put this in a function? */
346  /* RFC 2326: session id must be at least 8 digits */
347  while (strlen(rt->session_id) < 8)
348  av_strlcatf(rt->session_id, 512, "%u", av_get_random_seed());
349 
350  av_strlcatf(responseheaders, sizeof(responseheaders), "Session: %s\r\n",
351  rt->session_id);
352  /* Send Reply */
353  rtsp_send_reply(s, RTSP_STATUS_OK, responseheaders, request.seq);
354 
355  rt->state = RTSP_STATE_PAUSED;
356  return 0;
357 }
358 
360 {
361  RTSPState *rt = s->priv_data;
362  RTSPMessageHeader request = { 0 };
363  int ret = 0;
364  char responseheaders[MAX_URL_SIZE];
365 
366  ret = rtsp_read_request(s, &request, "RECORD");
367  if (ret)
368  return ret;
369  ret = check_sessionid(s, &request);
370  if (ret)
371  return ret;
372  rt->seq++;
373  snprintf(responseheaders, sizeof(responseheaders), "Session: %s\r\n",
374  rt->session_id);
375  rtsp_send_reply(s, RTSP_STATUS_OK, responseheaders, request.seq);
376 
378  return 0;
379 }
380 
381 static inline int parse_command_line(AVFormatContext *s, const char *line,
382  int linelen, char *uri, int urisize,
383  char *method, int methodsize,
384  enum RTSPMethod *methodcode)
385 {
386  RTSPState *rt = s->priv_data;
387  const char *linept, *searchlinept;
388  linept = strchr(line, ' ');
389 
390  if (!linept) {
391  av_log(s, AV_LOG_ERROR, "Error parsing method string\n");
392  return AVERROR_INVALIDDATA;
393  }
394 
395  if (linept - line > methodsize - 1) {
396  av_log(s, AV_LOG_ERROR, "Method string too long\n");
397  return AVERROR(EIO);
398  }
399  memcpy(method, line, linept - line);
400  method[linept - line] = '\0';
401  linept++;
402  if (!strcmp(method, "ANNOUNCE"))
403  *methodcode = ANNOUNCE;
404  else if (!strcmp(method, "OPTIONS"))
405  *methodcode = OPTIONS;
406  else if (!strcmp(method, "RECORD"))
407  *methodcode = RECORD;
408  else if (!strcmp(method, "SETUP"))
409  *methodcode = SETUP;
410  else if (!strcmp(method, "PAUSE"))
411  *methodcode = PAUSE;
412  else if (!strcmp(method, "TEARDOWN"))
413  *methodcode = TEARDOWN;
414  else
415  *methodcode = UNKNOWN;
416  /* Check method with the state */
417  if (rt->state == RTSP_STATE_IDLE) {
418  if ((*methodcode != ANNOUNCE) && (*methodcode != OPTIONS)) {
419  av_log(s, AV_LOG_ERROR, "Unexpected command in Idle State %s\n",
420  line);
422  }
423  } else if (rt->state == RTSP_STATE_PAUSED) {
424  if ((*methodcode != OPTIONS) && (*methodcode != RECORD)
425  && (*methodcode != SETUP)) {
426  av_log(s, AV_LOG_ERROR, "Unexpected command in Paused State %s\n",
427  line);
429  }
430  } else if (rt->state == RTSP_STATE_STREAMING) {
431  if ((*methodcode != PAUSE) && (*methodcode != OPTIONS)
432  && (*methodcode != TEARDOWN)) {
433  av_log(s, AV_LOG_ERROR, "Unexpected command in Streaming State"
434  " %s\n", line);
436  }
437  } else {
438  av_log(s, AV_LOG_ERROR, "Unexpected State [%d]\n", rt->state);
439  return AVERROR_BUG;
440  }
441 
442  searchlinept = strchr(linept, ' ');
443  if (!searchlinept) {
444  av_log(s, AV_LOG_ERROR, "Error parsing message URI\n");
445  return AVERROR_INVALIDDATA;
446  }
447  if (searchlinept - linept > urisize - 1) {
448  av_log(s, AV_LOG_ERROR, "uri string length exceeded buffer size\n");
449  return AVERROR(EIO);
450  }
451  memcpy(uri, linept, searchlinept - linept);
452  uri[searchlinept - linept] = '\0';
453  if (strcmp(rt->control_uri, uri)) {
454  char host[128], path[512], auth[128];
455  int port;
456  char ctl_host[128], ctl_path[512], ctl_auth[128];
457  int ctl_port;
458  av_url_split(NULL, 0, auth, sizeof(auth), host, sizeof(host), &port,
459  path, sizeof(path), uri);
460  av_url_split(NULL, 0, ctl_auth, sizeof(ctl_auth), ctl_host,
461  sizeof(ctl_host), &ctl_port, ctl_path, sizeof(ctl_path),
462  rt->control_uri);
463  if (strcmp(host, ctl_host))
464  av_log(s, AV_LOG_INFO, "Host %s differs from expected %s\n",
465  host, ctl_host);
466  if (strcmp(path, ctl_path) && *methodcode != SETUP)
467  av_log(s, AV_LOG_WARNING, "WARNING: Path %s differs from expected"
468  " %s\n", path, ctl_path);
469  if (*methodcode == ANNOUNCE) {
471  "Updating control URI to %s\n", uri);
472  av_strlcpy(rt->control_uri, uri, sizeof(rt->control_uri));
473  }
474  }
475 
476  linept = searchlinept + 1;
477  if (!av_strstart(linept, "RTSP/1.0", NULL)) {
478  av_log(s, AV_LOG_ERROR, "Error parsing protocol or version\n");
480  }
481  return 0;
482 }
483 
485 {
486  RTSPState *rt = s->priv_data;
487  unsigned char rbuf[MAX_URL_SIZE];
488  unsigned char method[10];
489  char uri[500];
490  int ret;
491  int rbuflen = 0;
492  RTSPMessageHeader request = { 0 };
493  enum RTSPMethod methodcode;
494 
495  ret = read_line(s, rbuf, sizeof(rbuf), &rbuflen);
496  if (ret < 0)
497  return ret;
498  av_log(s, AV_LOG_TRACE, "Parsing[%d]: %s\n", rbuflen, rbuf);
499  ret = parse_command_line(s, rbuf, rbuflen, uri, sizeof(uri), method,
500  sizeof(method), &methodcode);
501  if (ret) {
502  av_log(s, AV_LOG_ERROR, "RTSP: Unexpected Command\n");
503  return ret;
504  }
505 
506  ret = rtsp_read_request(s, &request, method);
507  if (ret)
508  return ret;
509  rt->seq++;
510  if (methodcode == PAUSE) {
511  rt->state = RTSP_STATE_PAUSED;
512  ret = rtsp_send_reply(s, RTSP_STATUS_OK, NULL , request.seq);
513  // TODO: Missing date header in response
514  } else if (methodcode == OPTIONS) {
516  "Public: ANNOUNCE, PAUSE, SETUP, TEARDOWN, "
517  "RECORD\r\n", request.seq);
518  } else if (methodcode == TEARDOWN) {
519  rt->state = RTSP_STATE_IDLE;
520  ret = rtsp_send_reply(s, RTSP_STATUS_OK, NULL , request.seq);
521  }
522  return ret;
523 }
524 
526 {
527  RTSPState *rt = s->priv_data;
528  RTSPMessageHeader reply1, *reply = &reply1;
529  int i;
530  char cmd[MAX_URL_SIZE];
531 
532  av_log(s, AV_LOG_DEBUG, "hello state=%d\n", rt->state);
533  rt->nb_byes = 0;
534 
536  for (i = 0; i < rt->nb_rtsp_streams; i++) {
537  RTSPStream *rtsp_st = rt->rtsp_streams[i];
538  /* Try to initialize the connection state in a
539  * potential NAT router by sending dummy packets.
540  * RTP/RTCP dummy packets are used for RDT, too.
541  */
542  if (rtsp_st->rtp_handle &&
543  !(rt->server_type == RTSP_SERVER_WMS && i > 1))
545  }
546  }
547  if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
548  if (rt->transport == RTSP_TRANSPORT_RTP) {
549  for (i = 0; i < rt->nb_rtsp_streams; i++) {
550  RTSPStream *rtsp_st = rt->rtsp_streams[i];
551  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
552  if (!rtpctx)
553  continue;
557  rtpctx->base_timestamp = 0;
558  rtpctx->timestamp = 0;
559  rtpctx->unwrapped_timestamp = 0;
560  rtpctx->rtcp_ts_offset = 0;
561  }
562  }
563  if (rt->state == RTSP_STATE_PAUSED) {
564  cmd[0] = 0;
565  } else {
566  snprintf(cmd, sizeof(cmd),
567  "Range: npt=%"PRId64".%03"PRId64"-\r\n",
569  rt->seek_timestamp / (AV_TIME_BASE / 1000) % 1000);
570  }
571  ff_rtsp_send_cmd(s, "PLAY", rt->control_uri, cmd, reply, NULL);
572  if (reply->status_code != RTSP_STATUS_OK) {
573  return ff_rtsp_averror(reply->status_code, -1);
574  }
575  if (rt->transport == RTSP_TRANSPORT_RTP &&
576  reply->range_start != AV_NOPTS_VALUE) {
577  for (i = 0; i < rt->nb_rtsp_streams; i++) {
578  RTSPStream *rtsp_st = rt->rtsp_streams[i];
579  RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
580  AVStream *st = NULL;
581  if (!rtpctx || rtsp_st->stream_index < 0)
582  continue;
583 
584  st = s->streams[rtsp_st->stream_index];
585  rtpctx->range_start_offset =
587  st->time_base);
588  }
589  }
590  }
592  return 0;
593 }
594 
595 /* pause the stream */
597 {
598  RTSPState *rt = s->priv_data;
599  RTSPMessageHeader reply1, *reply = &reply1;
600 
601  if (rt->state != RTSP_STATE_STREAMING)
602  return 0;
603  else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
604  ff_rtsp_send_cmd(s, "PAUSE", rt->control_uri, NULL, reply, NULL);
605  if (reply->status_code != RTSP_STATUS_OK) {
606  return ff_rtsp_averror(reply->status_code, -1);
607  }
608  }
609  rt->state = RTSP_STATE_PAUSED;
610  return 0;
611 }
612 
614 {
615  RTSPState *rt = s->priv_data;
616  char cmd[MAX_URL_SIZE];
617  unsigned char *content = NULL;
618  int ret;
619 
620  /* describe the stream */
621  snprintf(cmd, sizeof(cmd),
622  "Accept: application/sdp\r\n");
623  if (rt->server_type == RTSP_SERVER_REAL) {
624  /**
625  * The Require: attribute is needed for proper streaming from
626  * Realmedia servers.
627  */
628  av_strlcat(cmd,
629  "Require: com.real.retain-entity-for-setup\r\n",
630  sizeof(cmd));
631  }
632  ff_rtsp_send_cmd(s, "DESCRIBE", rt->control_uri, cmd, reply, &content);
633  if (reply->status_code != RTSP_STATUS_OK) {
634  av_freep(&content);
636  }
637  if (!content)
638  return AVERROR_INVALIDDATA;
639 
640  av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", content);
641  /* now we got the SDP description, we parse it */
642  ret = ff_sdp_parse(s, (const char *)content);
643  av_freep(&content);
644  if (ret < 0)
645  return ret;
646 
647  return 0;
648 }
649 
651 {
652  RTSPState *rt = s->priv_data;
653  char proto[128], host[128], path[512], auth[128];
654  char uri[500];
655  int port;
656  int default_port = RTSP_DEFAULT_PORT;
657  char tcpname[500];
658  const char *lower_proto = "tcp";
659  unsigned char rbuf[MAX_URL_SIZE];
660  unsigned char method[10];
661  int rbuflen = 0;
662  int ret;
663  enum RTSPMethod methodcode;
664 
665  if (!ff_network_init())
666  return AVERROR(EIO);
667 
668  /* extract hostname and port */
669  av_url_split(proto, sizeof(proto), auth, sizeof(auth), host, sizeof(host),
670  &port, path, sizeof(path), s->url);
671 
672  /* ff_url_join. No authorization by now (NULL) */
673  ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL, host,
674  port, "%s", path);
675 
676  if (!strcmp(proto, "rtsps")) {
677  lower_proto = "tls";
678  default_port = RTSPS_DEFAULT_PORT;
679  }
680 
681  if (port < 0)
682  port = default_port;
683 
684  /* Create TCP connection */
685  ff_url_join(tcpname, sizeof(tcpname), lower_proto, NULL, host, port,
686  "?listen&listen_timeout=%d", rt->initial_timeout * 1000);
687 
689  &s->interrupt_callback, NULL,
690  s->protocol_whitelist, s->protocol_blacklist, NULL)) {
691  av_log(s, AV_LOG_ERROR, "Unable to open RTSP for listening\n");
692  goto fail;
693  }
694  rt->state = RTSP_STATE_IDLE;
695  rt->rtsp_hd_out = rt->rtsp_hd;
696  for (;;) { /* Wait for incoming RTSP messages */
697  ret = read_line(s, rbuf, sizeof(rbuf), &rbuflen);
698  if (ret < 0)
699  goto fail;
700  av_log(s, AV_LOG_TRACE, "Parsing[%d]: %s\n", rbuflen, rbuf);
701  ret = parse_command_line(s, rbuf, rbuflen, uri, sizeof(uri), method,
702  sizeof(method), &methodcode);
703  if (ret) {
704  av_log(s, AV_LOG_ERROR, "RTSP: Unexpected Command\n");
705  goto fail;
706  }
707 
708  if (methodcode == ANNOUNCE) {
710  rt->state = RTSP_STATE_PAUSED;
711  } else if (methodcode == OPTIONS) {
713  } else if (methodcode == RECORD) {
715  if (!ret)
716  return 0; // We are ready for streaming
717  } else if (methodcode == SETUP)
718  ret = rtsp_read_setup(s, host, uri);
719  if (ret) {
721  goto fail;
722  }
723  }
724 fail:
728  return ret;
729 }
730 
731 static int rtsp_probe(const AVProbeData *p)
732 {
733  if (
734 #if CONFIG_TLS_PROTOCOL
735  av_strstart(p->filename, "rtsps:", NULL) ||
736 #endif
737  av_strstart(p->filename, "satip:", NULL) ||
738  av_strstart(p->filename, "rtsp:", NULL))
739  return AVPROBE_SCORE_MAX;
740  return 0;
741 }
742 
744 {
745  RTSPState *rt = s->priv_data;
746  int ret;
747 
748  if (rt->initial_timeout > 0)
750 
751  if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
752  ret = rtsp_listen(s);
753  if (ret)
754  return ret;
755  } else {
756  ret = ff_rtsp_connect(s);
757  if (ret)
758  return ret;
759 
760  rt->real_setup_cache = !s->nb_streams ? NULL :
761  av_calloc(s->nb_streams, 2 * sizeof(*rt->real_setup_cache));
762  if (!rt->real_setup_cache && s->nb_streams) {
763  ret = AVERROR(ENOMEM);
764  goto fail;
765  }
766  rt->real_setup = rt->real_setup_cache + s->nb_streams;
767 
768  if (rt->initial_pause) {
769  /* do not start immediately */
770  } else {
771  ret = rtsp_read_play(s);
772  if (ret < 0)
773  goto fail;
774  }
775  }
776 
777  return 0;
778 
779 fail:
781  return ret;
782 }
783 
785  uint8_t *buf, int buf_size)
786 {
787  RTSPState *rt = s->priv_data;
788  int id, len, i, ret;
789  RTSPStream *rtsp_st;
790 
791  av_log(s, AV_LOG_TRACE, "tcp_read_packet:\n");
792 redo:
793  for (;;) {
794  RTSPMessageHeader reply;
795 
796  ret = ff_rtsp_read_reply(s, &reply, NULL, 1, NULL);
797  if (ret < 0)
798  return ret;
799  if (ret == 1) /* received '$' */
800  break;
801  /* XXX: parse message */
802  if (rt->state != RTSP_STATE_STREAMING)
803  return 0;
804  }
805  ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
806  if (ret != 3)
807  return AVERROR(EIO);
808  id = buf[0];
809  len = AV_RB16(buf + 1);
810  av_log(s, AV_LOG_TRACE, "id=%d len=%d\n", id, len);
811  if (len > buf_size || len < 8)
812  goto redo;
813  /* get the data */
814  ret = ffurl_read_complete(rt->rtsp_hd, buf, len);
815  if (ret != len)
816  return AVERROR(EIO);
817  if (rt->transport == RTSP_TRANSPORT_RDT &&
818  (ret = ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL)) < 0)
819  return ret;
820 
821  /* find the matching stream */
822  for (i = 0; i < rt->nb_rtsp_streams; i++) {
823  rtsp_st = rt->rtsp_streams[i];
824  if (id >= rtsp_st->interleaved_min &&
825  id <= rtsp_st->interleaved_max)
826  goto found;
827  }
828  goto redo;
829 found:
830  *prtsp_st = rtsp_st;
831  return len;
832 }
833 
835 {
836  RTSPState *rt = s->priv_data;
837  char host[1024];
838  int port;
839 
840  av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port, NULL, 0,
841  s->url);
842  ff_rtsp_undo_setup(s, 0);
844  rt->real_challenge);
845 }
846 
848 {
849  RTSPState *rt = s->priv_data;
850  int ret;
851  RTSPMessageHeader reply1, *reply = &reply1;
852  char cmd[MAX_URL_SIZE];
853 
854 retry:
855  if (rt->server_type == RTSP_SERVER_REAL) {
856  int i;
857 
858  for (i = 0; i < s->nb_streams; i++)
859  rt->real_setup[i] = s->streams[i]->discard;
860 
861  if (!rt->need_subscription) {
862  if (memcmp (rt->real_setup, rt->real_setup_cache,
863  sizeof(enum AVDiscard) * s->nb_streams)) {
864  snprintf(cmd, sizeof(cmd),
865  "Unsubscribe: %s\r\n",
866  rt->last_subscription);
867  ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
868  cmd, reply, NULL);
869  if (reply->status_code != RTSP_STATUS_OK)
871  rt->need_subscription = 1;
872  }
873  }
874 
875  if (rt->need_subscription) {
876  int r, rule_nr, first = 1;
877 
878  memcpy(rt->real_setup_cache, rt->real_setup,
879  sizeof(enum AVDiscard) * s->nb_streams);
880  rt->last_subscription[0] = 0;
881 
882  snprintf(cmd, sizeof(cmd),
883  "Subscribe: ");
884  for (i = 0; i < rt->nb_rtsp_streams; i++) {
885  rule_nr = 0;
886  for (r = 0; r < s->nb_streams; r++) {
887  if (s->streams[r]->id == i) {
888  if (s->streams[r]->discard != AVDISCARD_ALL) {
889  if (!first)
890  av_strlcat(rt->last_subscription, ",",
891  sizeof(rt->last_subscription));
893  rt->last_subscription,
894  sizeof(rt->last_subscription), i, rule_nr);
895  first = 0;
896  }
897  rule_nr++;
898  }
899  }
900  }
901  av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
902  ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
903  cmd, reply, NULL);
904  if (reply->status_code != RTSP_STATUS_OK)
906  rt->need_subscription = 0;
907 
908  if (rt->state == RTSP_STATE_STREAMING)
909  rtsp_read_play (s);
910  }
911  }
912 
914  if (ret < 0) {
915  if (ret == AVERROR(ETIMEDOUT) && !rt->packets) {
918  RTSPMessageHeader reply1, *reply = &reply1;
919  av_log(s, AV_LOG_WARNING, "UDP timeout, retrying with TCP\n");
920  if (rtsp_read_pause(s) != 0)
921  return -1;
922  // TEARDOWN is required on Real-RTSP, but might make
923  // other servers close the connection.
924  if (rt->server_type == RTSP_SERVER_REAL)
925  ff_rtsp_send_cmd(s, "TEARDOWN", rt->control_uri, NULL,
926  reply, NULL);
927  rt->session_id[0] = '\0';
928  if (resetup_tcp(s) == 0) {
929  rt->state = RTSP_STATE_IDLE;
930  rt->need_subscription = 1;
931  if (rtsp_read_play(s) != 0)
932  return -1;
933  goto retry;
934  }
935  }
936  }
937  return ret;
938  }
939  rt->packets++;
940 
941  if (!(rt->rtsp_flags & RTSP_FLAG_LISTEN)) {
942  /* send dummy request to keep TCP connection alive */
943  if ((av_gettime_relative() - rt->last_cmd_time) / 1000000 >= rt->timeout / 2 ||
944  rt->auth_state.stale) {
945  if (rt->server_type == RTSP_SERVER_WMS ||
946  (rt->server_type != RTSP_SERVER_REAL &&
948  ff_rtsp_send_cmd_async(s, "GET_PARAMETER", rt->control_uri, NULL);
949  } else {
950  ff_rtsp_send_cmd_async(s, "OPTIONS", rt->control_uri, NULL);
951  }
952  /* The stale flag should be reset when creating the auth response in
953  * ff_rtsp_send_cmd_async, but reset it here just in case we never
954  * called the auth code (if we didn't have any credentials set). */
955  rt->auth_state.stale = 0;
956  }
957  }
958 
959  return 0;
960 }
961 
962 static int rtsp_read_seek(AVFormatContext *s, int stream_index,
963  int64_t timestamp, int flags)
964 {
965  RTSPState *rt = s->priv_data;
966  int ret;
967 
968  rt->seek_timestamp = av_rescale_q(timestamp,
969  s->streams[stream_index]->time_base,
971  switch(rt->state) {
972  default:
973  case RTSP_STATE_IDLE:
974  break;
976  if ((ret = rtsp_read_pause(s)) != 0)
977  return ret;
979  if ((ret = rtsp_read_play(s)) != 0)
980  return ret;
981  break;
982  case RTSP_STATE_PAUSED:
983  rt->state = RTSP_STATE_IDLE;
984  break;
985  }
986  return 0;
987 }
988 
989 static const AVClass rtsp_demuxer_class = {
990  .class_name = "RTSP demuxer",
991  .item_name = av_default_item_name,
992  .option = ff_rtsp_options,
993  .version = LIBAVUTIL_VERSION_INT,
994 };
995 
997  .p.name = "rtsp",
998  .p.long_name = NULL_IF_CONFIG_SMALL("RTSP input"),
999  .p.flags = AVFMT_NOFILE,
1000  .p.priv_class = &rtsp_demuxer_class,
1001  .priv_data_size = sizeof(RTSPState),
1007  .read_play = rtsp_read_play,
1008  .read_pause = rtsp_read_pause,
1009 };
RTSPState::initial_timeout
int initial_timeout
Timeout to wait for incoming connections.
Definition: rtsp.h:401
RTSP_STATE_PAUSED
@ RTSP_STATE_PAUSED
initialized, but not receiving data
Definition: rtsp.h:205
ff_rdt_subscribe_rule
void ff_rdt_subscribe_rule(char *cmd, int size, int stream_nr, int rule_nr)
Add subscription information to Subscribe parameter string.
Definition: rdt.c:385
RTSPState::initial_pause
int initial_pause
Do not begin to play the stream immediately.
Definition: rtsp.h:373
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
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:186
ff_rtsp_close_streams
void ff_rtsp_close_streams(AVFormatContext *s)
Close and free all streams within the RTSP (de)muxer.
Definition: rtsp.c:791
LIBAVFORMAT_IDENT
#define LIBAVFORMAT_IDENT
Definition: version.h:45
rtsp_read_request
static int rtsp_read_request(AVFormatContext *s, RTSPMessageHeader *request, const char *method)
Definition: rtspdec.c:145
r
const char * r
Definition: vf_curves.c:126
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
RTSPStream::transport_priv
void * transport_priv
RTP/RDT parse context if input, RTP AVFormatContext if output.
Definition: rtsp.h:446
RTSPStream::rtp_handle
URLContext * rtp_handle
RTP stream handle (if UDP)
Definition: rtsp.h:445
message
Definition: api-threadmessage-test.c:46
RTSP_STATE_SEEKING
@ RTSP_STATE_SEEKING
initialized, requesting a seek
Definition: rtsp.h:206
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.
resetup_tcp
static int resetup_tcp(AVFormatContext *s)
Definition: rtspdec.c:834
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVIO_FLAG_READ_WRITE
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
Definition: avio.h:619
rtsp_read_options
static int rtsp_read_options(AVFormatContext *s)
Definition: rtspdec.c:222
RTSP_TRANSPORT_RTP
@ RTSP_TRANSPORT_RTP
Standards-compliant RTP.
Definition: rtsp.h:60
RTSP_STATUS_METHOD
@ RTSP_STATUS_METHOD
Definition: rtspcodes.h:47
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
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
RTSPStream::interleaved_min
int interleaved_min
interleave IDs; copies of RTSPTransportField->interleaved_min/max for the selected transport.
Definition: rtsp.h:453
rtsp_read_setup
static int rtsp_read_setup(AVFormatContext *s, char *host, char *controlurl)
Definition: rtspdec.c:240
OPTIONS
@ OPTIONS
Definition: rtspcodes.h:132
rtsp_read_close
static int rtsp_read_close(AVFormatContext *s)
Definition: rtspdec.c:60
rtsp_send_reply
static int rtsp_send_reply(AVFormatContext *s, enum RTSPStatusCode code, const char *extracontent, uint16_t seq)
Definition: rtspdec.c:100
RTPDemuxContext::range_start_offset
int64_t range_start_offset
Definition: rtpdec.h:157
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
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:196
UNKNOWN
@ UNKNOWN
Definition: ftp.c:38
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
AVDictionary
Definition: dict.c:34
ff_network_close
void ff_network_close(void)
Definition: network.c:116
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
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
ANNOUNCE
@ ANNOUNCE
Definition: rtspcodes.h:131
os_support.h
ff_network_init
int ff_network_init(void)
Definition: network.c:58
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...
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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
ff_rtp_send_punch_packets
void ff_rtp_send_punch_packets(URLContext *rtp_handle)
Send a dummy packet on both port pairs to set up the connection state in potential NAT routers,...
Definition: rtpdec.c:414
TEARDOWN
@ TEARDOWN
Definition: rtspcodes.h:136
check_sessionid
static int check_sessionid(AVFormatContext *s, RTSPMessageHeader *request)
Definition: rtspdec.c:127
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
RTSP_STATUS_BANDWIDTH
@ RTSP_STATUS_BANDWIDTH
Definition: rtspcodes.h:59
fail
#define fail()
Definition: checkasm.h:179
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:538
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
RTSPState::nb_rtsp_streams
int nb_rtsp_streams
number of items in the 'rtsp_streams' variable
Definition: rtsp.h:231
read_line
static int read_line(AVFormatContext *s, char *rbuf, const int rbufsize, int *rbuflen)
Definition: rtspdec.c:75
rtsp_read_header
static int rtsp_read_header(AVFormatContext *s)
Definition: rtspdec.c:743
rtsp_read_packet
static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rtspdec.c:847
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
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:613
RTSPStatusMessage::message
const char * message
Definition: rtspdec.c:44
RTSPMessageHeader::content_length
int content_length
length of the data following this header
Definition: rtsp.h:131
RTSP_TRANSPORT_RDT
@ RTSP_TRANSPORT_RDT
Realmedia Data Transport.
Definition: rtsp.h:61
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:784
RTSP_STATE_STREAMING
@ RTSP_STATE_STREAMING
initialized and sending/receiving data
Definition: rtsp.h:204
rtsp.h
RTSPState::lower_transport_mask
int lower_transport_mask
A mask with all requested transport methods.
Definition: rtsp.h:352
RTSPMethod
RTSPMethod
Definition: rtspcodes.h:129
RTSPStream::stream_index
int stream_index
corresponding stream index, if any.
Definition: rtsp.h:449
ff_rdt_parse_close
void ff_rdt_parse_close(RDTDemuxContext *s)
Definition: rdt.c:79
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
ff_rdt_parse_header
int ff_rdt_parse_header(const uint8_t *buf, int len, int *pset_id, int *pseq_no, int *pstream_id, int *pis_keyframe, uint32_t *ptimestamp)
Parse RDT-style packet header.
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:206
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
RTSP_FLAG_LISTEN
#define RTSP_FLAG_LISTEN
Wait for incoming connections.
Definition: rtsp.h:427
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:484
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
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:361
RTSP_STATUS_STATE
@ RTSP_STATUS_STATE
Definition: rtspcodes.h:61
RTSP_STATUS_TRANSPORT
@ RTSP_STATUS_TRANSPORT
Definition: rtspcodes.h:67
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
RTSPState::nb_byes
int nb_byes
Definition: rtsp.h:344
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
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::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
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
RTSP_STATUS_VERSION
@ RTSP_STATUS_VERSION
Definition: rtspcodes.h:74
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:759
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
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:827
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...
RTSP_STATUS_INTERNAL
@ RTSP_STATUS_INTERNAL
Definition: rtspcodes.h:69
RTSPMessageHeader::seq
int seq
sequence number
Definition: rtsp.h:146
parse_command_line
static int parse_command_line(AVFormatContext *s, const char *line, int linelen, char *uri, int urisize, char *method, int methodsize, enum RTSPMethod *methodcode)
Definition: rtspdec.c:381
if
if(ret)
Definition: filter_design.txt:179
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
opts
AVDictionary * opts
Definition: movenc.c:50
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
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
RTSP_STATUS_OK
@ RTSP_STATUS_OK
Definition: rtspcodes.h:33
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
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:782
NULL
#define NULL
Definition: coverity.c:32
RTSPState::rtsp_hd
URLContext * rtsp_hd
Definition: rtsp.h:228
RECORD
@ RECORD
Definition: rtspcodes.h:140
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
rtsp_probe
static int rtsp_probe(const AVProbeData *p)
Definition: rtspdec.c:731
RTSPState::real_setup
enum AVDiscard * real_setup
current stream setup.
Definition: rtsp.h:304
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
RTSP_STATUS_SESSION
@ RTSP_STATUS_SESSION
Definition: rtspcodes.h:60
rtsp_read_play
static int rtsp_read_play(AVFormatContext *s)
Definition: rtspdec.c:525
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
RTPDemuxContext::last_rtcp_ntp_time
uint64_t last_rtcp_ntp_time
Definition: rtpdec.h:176
rtsp_read_record
static int rtsp_read_record(AVFormatContext *s)
Definition: rtspdec.c:359
index
int index
Definition: gxfenc.c:89
ff_rtp_parse_close
void ff_rtp_parse_close(RTPDemuxContext *s)
Definition: rtpdec.c:957
rtsp_listen
static int rtsp_listen(AVFormatContext *s)
Definition: rtspdec.c:650
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:106
RTSPState::rtsp_flags
int rtsp_flags
Various option flags for the RTSP muxer/demuxer.
Definition: rtsp.h:386
ff_rtsp_options
const AVOption ff_rtsp_options[]
Definition: rtsp.c:85
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
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
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
RTSPState::seq
int seq
RTSP command sequence number.
Definition: rtsp.h:249
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
RTSPState::auth_state
HTTPAuthState auth_state
authentication state
Definition: rtsp.h:284
RTPDemuxContext::unwrapped_timestamp
int64_t unwrapped_timestamp
Definition: rtpdec.h:156
line
Definition: graph2dot.c:48
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
RTSPState::last_subscription
char last_subscription[1024]
the last value of the "SET_PARAMETER Subscribe:" RTSP command.
Definition: rtsp.h:309
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:191
RTSPTransportField::client_port_max
int client_port_max
Definition: rtsp.h:103
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
RTSPState::need_subscription
int need_subscription
The following are used for Real stream selection.
Definition: rtsp.h:296
rtsp_read_seek
static int rtsp_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: rtspdec.c:962
rtpproto.h
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:358
url.h
RTSP_LOWER_TRANSPORT_TCP
@ RTSP_LOWER_TRANSPORT_TCP
TCP; interleaved in RTSP.
Definition: rtsp.h:41
demux.h
status_messages
static const struct RTSPStatusMessage status_messages[]
len
int len
Definition: vorbis_enc_data.h:426
RTSP_STATUS_AGGREGATE
@ RTSP_STATUS_AGGREGATE
Definition: rtspcodes.h:65
RTPDemuxContext
Definition: rtpdec.h:148
RTPDemuxContext::timestamp
uint32_t timestamp
Definition: rtpdec.h:154
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
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
rtsp_demuxer_class
static const AVClass rtsp_demuxer_class
Definition: rtspdec.c:989
version.h
RTSPState::rtp_port_max
int rtp_port_max
Definition: rtsp.h:396
rtsp_read_announce
static int rtsp_read_announce(AVFormatContext *s)
Definition: rtspdec.c:175
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:587
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
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:71
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
avformat.h
RTSPStatusMessage
Definition: rtspdec.c:42
network.h
id
enum AVCodecID id
Definition: dts2pts.c:364
HTTPAuthState::stale
int stale
Auth ok, but needs to be resent with a new nonce.
Definition: httpauth.h:71
tls.h
RTSP_DEFAULT_PORT
#define RTSP_DEFAULT_PORT
Definition: rtsp.h:75
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
AVERROR_STREAM_NOT_FOUND
#define AVERROR_STREAM_NOT_FOUND
Stream not found.
Definition: error.h:67
SETUP
@ SETUP
Definition: rtspcodes.h:133
RTSPStream::interleaved_max
int interleaved_max
Definition: rtsp.h:453
RTSPStatusCode
RTSPStatusCode
RTSP handling.
Definition: rtspcodes.h:31
RTSP_SERVER_WMS
@ RTSP_SERVER_WMS
Windows Media server.
Definition: rtsp.h:216
PAUSE
@ PAUSE
Definition: rtspcodes.h:135
RTSP_STATUS_SERVICE
@ RTSP_STATUS_SERVICE
Definition: rtspcodes.h:72
ff_rtsp_demuxer
const FFInputFormat ff_rtsp_demuxer
Definition: rtspdec.c:996
RTSPMessageHeader
This describes the server response to each RTSP command.
Definition: rtsp.h:129
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
RTSPState::real_setup_cache
enum AVDiscard * real_setup_cache
stream setup during the last frame read.
Definition: rtsp.h:300
RTSP_STATE_IDLE
@ RTSP_STATE_IDLE
not initialized
Definition: rtsp.h:203
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
RTSP_STATUS_ONLY_AGGREGATE
@ RTSP_STATUS_ONLY_AGGREGATE
Definition: rtspcodes.h:66
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:556
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
rdt.h
AVPacket
This structure stores compressed data.
Definition: packet.h:499
RTSPState::server_type
enum RTSPServerType server_type
brand of server that we're talking to; e.g.
Definition: rtsp.h:275
RTSPMessageHeader::content_type
char content_type[64]
Content type header.
Definition: rtsp.h:189
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
FFInputFormat
Definition: demux.h:37
ff_rtp_reset_packet_queue
void ff_rtp_reset_packet_queue(RTPDemuxContext *s)
Definition: rtpdec.c:780
RTSPState::packets
uint64_t packets
The number of returned packets.
Definition: rtsp.h:357
RTSPTransportField::mode_record
int mode_record
transport set to record data
Definition: rtsp.h:114
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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.
RTSPStatusMessage::code
enum RTSPStatusCode code
Definition: rtspdec.c:43
avstring.h
AVDiscard
AVDiscard
Definition: defs.h:210
ff_rtsp_connect
int ff_rtsp_connect(AVFormatContext *s)
Connect to the RTSP server and set up the individual media streams.
AVERROR_PROTOCOL_NOT_FOUND
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:65
snprintf
#define snprintf
Definition: snprintf.h:34
rtsp_read_pause
static int rtsp_read_pause(AVFormatContext *s)
Definition: rtspdec.c:596
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
line
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
Definition: swscale.txt:40
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