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