FFmpeg
rtpproto.c
Go to the documentation of this file.
1 /*
2  * RTP network protocol
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 /**
23  * @file
24  * RTP protocol
25  */
26 
27 #include "libavutil/parseutils.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/opt.h"
30 #include "avformat.h"
31 #include "avio_internal.h"
32 #include "rtp.h"
33 #include "rtpproto.h"
34 #include "url.h"
35 #include "ip.h"
36 
37 #include <stdarg.h>
38 #include "internal.h"
39 #include "network.h"
40 #include "os_support.h"
41 #include <fcntl.h>
42 #if HAVE_POLL_H
43 #include <poll.h>
44 #endif
45 
46 typedef struct RTPContext {
47  const AVClass *class;
52  struct sockaddr_storage last_rtp_source, last_rtcp_source;
54  int ttl;
57  int connect;
58  int pkt_size;
59  int dscp;
60  char *sources;
61  char *block;
63  int64_t rw_timeout;
64 } RTPContext;
65 
66 #define OFFSET(x) offsetof(RTPContext, x)
67 #define D AV_OPT_FLAG_DECODING_PARAM
68 #define E AV_OPT_FLAG_ENCODING_PARAM
69 static const AVOption options[] = {
70  { "ttl", "Time to live (in milliseconds, multicast only)", OFFSET(ttl), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
71  { "buffer_size", "Send/Receive buffer size (in bytes)", OFFSET(buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
72  { "rtcp_port", "Custom rtcp port", OFFSET(rtcp_port), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
73  { "local_rtpport", "Local rtp port", OFFSET(local_rtpport), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
74  { "local_rtcpport", "Local rtcp port", OFFSET(local_rtcpport), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
75  { "connect", "Connect socket", OFFSET(connect), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = D|E },
76  { "write_to_source", "Send packets to the source address of the latest received packet", OFFSET(write_to_source), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = D|E },
77  { "pkt_size", "Maximum packet size", OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
78  { "dscp", "DSCP class", OFFSET(dscp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
79  { "timeout", "set timeout (in microseconds) of socket I/O operations", OFFSET(rw_timeout), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, .flags = D|E },
80  { "sources", "Source list", OFFSET(sources), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
81  { "block", "Block list", OFFSET(block), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
82  { "fec", "FEC", OFFSET(fec_options_str), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = E },
83  { NULL }
84 };
85 
86 static const AVClass rtp_class = {
87  .class_name = "rtp",
88  .item_name = av_default_item_name,
89  .option = options,
90  .version = LIBAVUTIL_VERSION_INT,
91 };
92 
93 /**
94  * If no filename is given to av_open_input_file because you want to
95  * get the local port first, then you must call this function to set
96  * the remote server address.
97  *
98  * @param h media file context
99  * @param uri of the remote server
100  * @return zero if no error.
101  */
102 
103 int ff_rtp_set_remote_url(URLContext *h, const char *uri)
104 {
105  RTPContext *s = h->priv_data;
106  char hostname[256];
107  int port, rtcp_port;
108  const char *p;
109 
110  char buf[1024];
111  char path[1024];
112 
113  av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port,
114  path, sizeof(path), uri);
115  rtcp_port = port + 1;
116 
117  p = strchr(uri, '?');
118  if (p) {
119  if (av_find_info_tag(buf, sizeof(buf), "rtcpport", p)) {
120  rtcp_port = strtol(buf, NULL, 10);
121  }
122  }
123 
124  ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port, "%s", path);
125  ff_udp_set_remote_url(s->rtp_hd, buf);
126 
127  ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, rtcp_port, "%s", path);
129  return 0;
130 }
131 
132 static int get_port(const struct sockaddr_storage *ss)
133 {
134  if (ss->ss_family == AF_INET)
135  return ntohs(((const struct sockaddr_in *)ss)->sin_port);
136 #if HAVE_STRUCT_SOCKADDR_IN6
137  if (ss->ss_family == AF_INET6)
138  return ntohs(((const struct sockaddr_in6 *)ss)->sin6_port);
139 #endif
140  return 0;
141 }
142 
143 static void set_port(struct sockaddr_storage *ss, int port)
144 {
145  if (ss->ss_family == AF_INET)
146  ((struct sockaddr_in *)ss)->sin_port = htons(port);
147 #if HAVE_STRUCT_SOCKADDR_IN6
148  else if (ss->ss_family == AF_INET6)
149  ((struct sockaddr_in6 *)ss)->sin6_port = htons(port);
150 #endif
151 }
152 
153 /**
154  * add option to url of the form:
155  * "http://host:port/path?option1=val1&option2=val2...
156  */
157 
158 static av_printf_format(3, 4) void url_add_option(char *buf, int buf_size, const char *fmt, ...)
159 {
160  char buf1[1024];
161  va_list ap;
162 
163  va_start(ap, fmt);
164  if (strchr(buf, '?'))
165  av_strlcat(buf, "&", buf_size);
166  else
167  av_strlcat(buf, "?", buf_size);
168  vsnprintf(buf1, sizeof(buf1), fmt, ap);
169  av_strlcat(buf, buf1, buf_size);
170  va_end(ap);
171 }
172 
174  char *buf, int buf_size,
175  const char *hostname,
176  int port, int local_port,
177  const char *include_sources,
178  const char *exclude_sources)
179 {
180  ff_url_join(buf, buf_size, "udp", NULL, hostname, port, NULL);
181  if (local_port >= 0)
182  url_add_option(buf, buf_size, "localport=%d", local_port);
183  if (s->ttl >= 0)
184  url_add_option(buf, buf_size, "ttl=%d", s->ttl);
185  if (s->buffer_size >= 0)
186  url_add_option(buf, buf_size, "buffer_size=%d", s->buffer_size);
187  if (s->pkt_size >= 0)
188  url_add_option(buf, buf_size, "pkt_size=%d", s->pkt_size);
189  if (s->connect)
190  url_add_option(buf, buf_size, "connect=1");
191  if (s->dscp >= 0)
192  url_add_option(buf, buf_size, "dscp=%d", s->dscp);
193  url_add_option(buf, buf_size, "fifo_size=0");
194  if (include_sources && include_sources[0])
195  url_add_option(buf, buf_size, "sources=%s", include_sources);
196  if (exclude_sources && exclude_sources[0])
197  url_add_option(buf, buf_size, "block=%s", exclude_sources);
198 }
199 
200 /**
201  * url syntax: rtp://host:port[?option=val...]
202  * option: 'ttl=n' : set the ttl value (for multicast only)
203  * 'rtcpport=n' : set the remote rtcp port to n
204  * 'localrtpport=n' : set the local rtp port to n
205  * 'localrtcpport=n' : set the local rtcp port to n
206  * 'pkt_size=n' : set max packet size
207  * 'connect=0/1' : do a connect() on the UDP socket
208  * 'sources=ip[,ip]' : list allowed source IP addresses
209  * 'block=ip[,ip]' : list disallowed source IP addresses
210  * 'write_to_source=0/1' : send packets to the source address of the latest received packet
211  * 'dscp=n' : set DSCP value to n (QoS)
212  * deprecated option:
213  * 'localport=n' : set the local port to n
214  *
215  * if rtcpport isn't set the rtcp port will be the rtp port + 1
216  * if local rtp port isn't set any available port will be used for the local
217  * rtp and rtcp ports
218  * if the local rtcp port is not set it will be the local rtp port + 1
219  */
220 
221 static int rtp_open(URLContext *h, const char *uri, int flags)
222 {
223  RTPContext *s = h->priv_data;
224  AVDictionary *fec_opts = NULL;
225  int rtp_port;
226  char hostname[256], include_sources[1024] = "", exclude_sources[1024] = "";
227  char *sources = include_sources, *block = exclude_sources;
228  char *fec_protocol = NULL;
229  char buf[1024];
230  char path[1024];
231  const char *p;
232  int i, max_retry_count = 3;
233  int rtcpflags;
234 
235  av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &rtp_port,
236  path, sizeof(path), uri);
237  /* extract parameters */
238  if (s->rtcp_port < 0)
239  s->rtcp_port = rtp_port + 1;
240 
241  p = strchr(uri, '?');
242  if (p) {
243  if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {
244  s->ttl = strtol(buf, NULL, 10);
245  }
246  if (av_find_info_tag(buf, sizeof(buf), "rtcpport", p)) {
247  s->rtcp_port = strtol(buf, NULL, 10);
248  }
249  if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {
250  s->local_rtpport = strtol(buf, NULL, 10);
251  }
252  if (av_find_info_tag(buf, sizeof(buf), "localrtpport", p)) {
253  s->local_rtpport = strtol(buf, NULL, 10);
254  }
255  if (av_find_info_tag(buf, sizeof(buf), "localrtcpport", p)) {
256  s->local_rtcpport = strtol(buf, NULL, 10);
257  }
258  if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {
259  s->pkt_size = strtol(buf, NULL, 10);
260  }
261  if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
262  s->connect = strtol(buf, NULL, 10);
263  }
264  if (av_find_info_tag(buf, sizeof(buf), "write_to_source", p)) {
265  s->write_to_source = strtol(buf, NULL, 10);
266  }
267  if (av_find_info_tag(buf, sizeof(buf), "dscp", p)) {
268  s->dscp = strtol(buf, NULL, 10);
269  }
270  if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) {
271  s->rw_timeout = strtol(buf, NULL, 10);
272  }
273  if (av_find_info_tag(buf, sizeof(buf), "sources", p)) {
274  av_strlcpy(include_sources, buf, sizeof(include_sources));
275  ff_ip_parse_sources(h, buf, &s->filters);
276  } else {
277  ff_ip_parse_sources(h, s->sources, &s->filters);
278  sources = s->sources;
279  }
280  if (av_find_info_tag(buf, sizeof(buf), "block", p)) {
281  av_strlcpy(exclude_sources, buf, sizeof(exclude_sources));
282  ff_ip_parse_blocks(h, buf, &s->filters);
283  } else {
284  ff_ip_parse_blocks(h, s->block, &s->filters);
285  block = s->block;
286  }
287  }
288  if (s->rw_timeout >= 0)
289  h->rw_timeout = s->rw_timeout;
290 
291  if (s->fec_options_str) {
292  p = s->fec_options_str;
293 
294  if (!(fec_protocol = av_get_token(&p, "="))) {
295  av_log(h, AV_LOG_ERROR, "Failed to parse the FEC protocol value\n");
296  goto fail;
297  }
298  if (strcmp(fec_protocol, "prompeg")) {
299  av_log(h, AV_LOG_ERROR, "Unsupported FEC protocol %s\n", fec_protocol);
300  goto fail;
301  }
302 
303  p = s->fec_options_str + strlen(fec_protocol);
304  while (*p && *p == '=') p++;
305 
306  if (av_dict_parse_string(&fec_opts, p, "=", ":", 0) < 0) {
307  av_log(h, AV_LOG_ERROR, "Failed to parse the FEC options\n");
308  goto fail;
309  }
310  if (s->ttl > 0) {
311  av_dict_set_int(&fec_opts, "ttl", s->ttl, 0);
312  }
313  }
314 
315  for (i = 0; i < max_retry_count; i++) {
316  build_udp_url(s, buf, sizeof(buf),
317  hostname, rtp_port, s->local_rtpport,
318  sources, block);
319  if (ffurl_open_whitelist(&s->rtp_hd, buf, flags, &h->interrupt_callback,
321  goto fail;
323  if(s->local_rtpport == 65535) {
324  s->local_rtpport = -1;
325  continue;
326  }
327  rtcpflags = flags | AVIO_FLAG_WRITE;
328  if (s->local_rtcpport < 0) {
329  s->local_rtcpport = s->local_rtpport + 1;
330  build_udp_url(s, buf, sizeof(buf),
331  hostname, s->rtcp_port, s->local_rtcpport,
332  sources, block);
333  if (ffurl_open_whitelist(&s->rtcp_hd, buf, rtcpflags,
335  h->protocol_whitelist, h->protocol_blacklist, h) < 0) {
336  s->local_rtpport = s->local_rtcpport = -1;
337  continue;
338  }
339  break;
340  }
341  build_udp_url(s, buf, sizeof(buf),
342  hostname, s->rtcp_port, s->local_rtcpport,
343  sources, block);
344  if (ffurl_open_whitelist(&s->rtcp_hd, buf, rtcpflags, &h->interrupt_callback,
346  goto fail;
347  break;
348  }
349 
350  s->fec_hd = NULL;
351  if (fec_protocol) {
352  ff_url_join(buf, sizeof(buf), fec_protocol, NULL, hostname, rtp_port, NULL);
353  if (ffurl_open_whitelist(&s->fec_hd, buf, flags, &h->interrupt_callback,
354  &fec_opts, h->protocol_whitelist, h->protocol_blacklist, h) < 0)
355  goto fail;
356  }
357 
358  /* just to ease handle access. XXX: need to suppress direct handle
359  access */
362 
364  h->is_streamed = 1;
365 
366  av_free(fec_protocol);
367  av_dict_free(&fec_opts);
368 
369  return 0;
370 
371  fail:
372  ffurl_closep(&s->rtp_hd);
373  ffurl_closep(&s->rtcp_hd);
374  ffurl_closep(&s->fec_hd);
375  av_free(fec_protocol);
376  av_dict_free(&fec_opts);
377  return AVERROR(EIO);
378 }
379 
380 static int rtp_read(URLContext *h, uint8_t *buf, int size)
381 {
382  RTPContext *s = h->priv_data;
383  int len, n, i;
384  struct pollfd p[2] = {{s->rtp_fd, POLLIN, 0}, {s->rtcp_fd, POLLIN, 0}};
385  int poll_delay = h->flags & AVIO_FLAG_NONBLOCK ? 0 : POLLING_TIME;
386  struct sockaddr_storage *addrs[2] = { &s->last_rtp_source, &s->last_rtcp_source };
387  socklen_t *addr_lens[2] = { &s->last_rtp_source_len, &s->last_rtcp_source_len };
388  int runs = h->rw_timeout / 1000 / POLLING_TIME;
389 
390  for(;;) {
392  return AVERROR_EXIT;
393  n = poll(p, 2, poll_delay);
394  if (n > 0) {
395  /* first try RTCP, then RTP */
396  for (i = 1; i >= 0; i--) {
397  if (!(p[i].revents & POLLIN))
398  continue;
399  *addr_lens[i] = sizeof(*addrs[i]);
400  len = recvfrom(p[i].fd, buf, size, 0,
401  (struct sockaddr *)addrs[i], addr_lens[i]);
402  if (len < 0) {
403  if (ff_neterrno() == AVERROR(EAGAIN) ||
404  ff_neterrno() == AVERROR(EINTR))
405  continue;
406  return AVERROR(EIO);
407  }
408  if (ff_ip_check_source_lists(addrs[i], &s->filters))
409  continue;
410  return len;
411  }
412  } else if (n == 0 && h->rw_timeout > 0 && --runs <= 0) {
413  return AVERROR(ETIMEDOUT);
414  } else if (n < 0) {
415  if (ff_neterrno() == AVERROR(EINTR))
416  continue;
417  return AVERROR(EIO);
418  }
419  if (h->flags & AVIO_FLAG_NONBLOCK)
420  return AVERROR(EAGAIN);
421  }
422 }
423 
424 static int rtp_write(URLContext *h, const uint8_t *buf, int size)
425 {
426  RTPContext *s = h->priv_data;
427  int ret, ret_fec;
428  URLContext *hd;
429 
430  if (size < 2)
431  return AVERROR(EINVAL);
432 
433  if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
434  av_log(h, AV_LOG_WARNING, "Data doesn't look like RTP packets, "
435  "make sure the RTP muxer is used\n");
436 
437  if (s->write_to_source) {
438  int fd;
439  struct sockaddr_storage *source, temp_source;
440  socklen_t *source_len, temp_len;
441  if (!s->last_rtp_source.ss_family && !s->last_rtcp_source.ss_family) {
442  av_log(h, AV_LOG_ERROR,
443  "Unable to send packet to source, no packets received yet\n");
444  // Intentionally not returning an error here
445  return size;
446  }
447 
448  if (RTP_PT_IS_RTCP(buf[1])) {
449  fd = s->rtcp_fd;
450  source = &s->last_rtcp_source;
451  source_len = &s->last_rtcp_source_len;
452  } else {
453  fd = s->rtp_fd;
454  source = &s->last_rtp_source;
455  source_len = &s->last_rtp_source_len;
456  }
457  if (!source->ss_family) {
458  source = &temp_source;
459  source_len = &temp_len;
460  if (RTP_PT_IS_RTCP(buf[1])) {
461  temp_source = s->last_rtp_source;
462  temp_len = s->last_rtp_source_len;
463  set_port(source, get_port(source) + 1);
464  av_log(h, AV_LOG_INFO,
465  "Not received any RTCP packets yet, inferring peer port "
466  "from the RTP port\n");
467  } else {
468  temp_source = s->last_rtcp_source;
469  temp_len = s->last_rtcp_source_len;
470  set_port(source, get_port(source) - 1);
471  av_log(h, AV_LOG_INFO,
472  "Not received any RTP packets yet, inferring peer port "
473  "from the RTCP port\n");
474  }
475  }
476 
477  if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
478  ret = ff_network_wait_fd(fd, 1);
479  if (ret < 0)
480  return ret;
481  }
482  ret = sendto(fd, buf, size, 0, (struct sockaddr *) source,
483  *source_len);
484 
485  return ret < 0 ? ff_neterrno() : ret;
486  }
487 
488  if (RTP_PT_IS_RTCP(buf[1])) {
489  /* RTCP payload type */
490  hd = s->rtcp_hd;
491  } else {
492  /* RTP payload type */
493  hd = s->rtp_hd;
494  }
495 
496  if ((ret = ffurl_write(hd, buf, size)) < 0) {
497  return ret;
498  }
499 
500  if (s->fec_hd && !RTP_PT_IS_RTCP(buf[1])) {
501  if ((ret_fec = ffurl_write(s->fec_hd, buf, size)) < 0) {
502  av_log(h, AV_LOG_ERROR, "Failed to send FEC\n");
503  return ret_fec;
504  }
505  }
506 
507  return ret;
508 }
509 
510 static int rtp_close(URLContext *h)
511 {
512  RTPContext *s = h->priv_data;
513 
515 
516  ffurl_closep(&s->rtp_hd);
517  ffurl_closep(&s->rtcp_hd);
518  ffurl_closep(&s->fec_hd);
519  return 0;
520 }
521 
522 /**
523  * Return the local rtp port used by the RTP connection
524  * @param h media file context
525  * @return the local port number
526  */
527 
529 {
530  RTPContext *s = h->priv_data;
531  return ff_udp_get_local_port(s->rtp_hd);
532 }
533 
534 /**
535  * Return the local rtcp port used by the RTP connection
536  * @param h media file context
537  * @return the local port number
538  */
539 
541 {
542  RTPContext *s = h->priv_data;
543  return s->rtp_fd;
544 }
545 
546 static int rtp_get_multi_file_handle(URLContext *h, int **handles,
547  int *numhandles)
548 {
549  RTPContext *s = h->priv_data;
550  int *hs = *handles = av_malloc(sizeof(**handles) * 2);
551  if (!hs)
552  return AVERROR(ENOMEM);
553  hs[0] = s->rtp_fd;
554  hs[1] = s->rtcp_fd;
555  *numhandles = 2;
556  return 0;
557 }
558 
560  .name = "rtp",
561  .url_open = rtp_open,
562  .url_read = rtp_read,
563  .url_write = rtp_write,
564  .url_close = rtp_close,
565  .url_get_file_handle = rtp_get_file_handle,
566  .url_get_multi_file_handle = rtp_get_multi_file_handle,
567  .priv_data_size = sizeof(RTPContext),
569  .priv_data_class = &rtp_class,
570 };
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:4725
#define NULL
Definition: coverity.c:32
int rtcp_port
Definition: rtpproto.c:56
int buffer_size
Definition: rtpproto.c:55
int ff_rtp_get_local_rtp_port(URLContext *h)
Return the local rtp port used by the RTP connection.
Definition: rtpproto.c:528
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:310
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:34
AVOption.
Definition: opt.h:248
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
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:423
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:45
AVIOInterruptCB interrupt_callback
Definition: url.h:47
#define RTP_VERSION
Definition: rtp.h:78
#define vsnprintf
Definition: snprintf.h:36
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int64_t rw_timeout
maximum time to wait for (network) read/write operation completion, in mcs
Definition: url.h:48
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
int ff_ip_parse_blocks(void *log_ctx, const char *buf, IPSourceFilters *filters)
Parses the address[,address] source block list in buf and adds it to the filters in the IPSourceFilte...
Definition: ip.c:148
char * block
Definition: rtpproto.c:61
int flags
Definition: url.h:43
const URLProtocol ff_rtp_protocol
Definition: rtpproto.c:559
URLContext * rtcp_hd
Definition: rtpproto.c:48
static int rtp_write(URLContext *h, const uint8_t *buf, int size)
Definition: rtpproto.c:424
int ff_ip_parse_sources(void *log_ctx, const char *buf, IPSourceFilters *filters)
Parses the address[,address] source list in buf and adds it to the filters in the IPSourceFilters str...
Definition: ip.c:143
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:72
static int rtp_close(URLContext *h)
Definition: rtpproto.c:510
uint8_t
#define av_malloc(s)
IPSourceFilters filters
Definition: rtpproto.c:50
AVOptions.
#define D
Definition: rtpproto.c:67
miscellaneous OS support macros and functions.
socklen_t last_rtp_source_len
Definition: rtpproto.c:53
static int get_port(const struct sockaddr_storage *ss)
Definition: rtpproto.c:132
int ff_udp_get_local_port(URLContext *h)
Return the local port used by the UDP connection.
Definition: udp.c:445
uint16_t ss_family
Definition: network.h:116
int pkt_size
Definition: rtpproto.c:58
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
Attempt to find a specific tag in a URL.
Definition: parseutils.c:749
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a source
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
URLContext * rtp_hd
Definition: rtpproto.c:48
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int ff_udp_set_remote_url(URLContext *h, const char *uri)
If no filename is given to av_open_input_file because you want to get the local port first...
Definition: udp.c:406
const char * protocol_whitelist
Definition: url.h:49
static int rtp_read(URLContext *h, uint8_t *buf, int size)
Definition: rtpproto.c:380
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
void ff_ip_reset_filters(IPSourceFilters *filters)
Resets the IP filter list and frees the internal fields of an IPSourceFilters structure.
Definition: ip.c:153
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:83
#define fail()
Definition: checkasm.h:123
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:151
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
char * fec_options_str
Definition: rtpproto.c:62
static const AVClass rtp_class
Definition: rtpproto.c:86
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
struct sockaddr_storage last_rtp_source last_rtcp_source
Definition: rtpproto.c:52
#define ff_neterrno()
Definition: network.h:68
static int rtp_open(URLContext *h, const char *uri, int flags)
url syntax: rtp://host:port[?option=val...] option: &#39;ttl=n&#39; : set the ttl value (for multicast only) ...
Definition: rtpproto.c:221
#define s(width, name)
Definition: cbs_vp9.c:257
static const AVOption options[]
Definition: rtpproto.c:69
int rtcp_fd
Definition: rtpproto.c:49
static int rtp_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Definition: rtpproto.c:546
int rtp_fd
Definition: rtpproto.c:49
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
Definition: avio.c:628
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
Definition: avio.c:446
int local_rtcpport
Definition: rtpproto.c:56
int64_t rw_timeout
Definition: rtpproto.c:63
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
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
const char * protocol_blacklist
Definition: url.h:50
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:666
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
Definition: avio.h:693
socklen_t last_rtcp_source_len
Definition: rtpproto.c:53
Definition: url.h:38
int ff_ip_check_source_lists(struct sockaddr_storage *source_addr_ptr, IPSourceFilters *s)
Checks the source address against a given IP source filter.
Definition: ip.c:44
Describe the class of an AVClass context structure.
Definition: log.h:67
static av_printf_format(3, 4)
add option to url of the form: "http://host:port/path?option1=val1&option2=val2...
Definition: rtpproto.c:158
void * priv_data
Definition: url.h:41
misc parsing utilities
#define POLLING_TIME
Definition: network.h:249
URLContext * fec_hd
Definition: rtpproto.c:48
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:93
const char * name
Definition: url.h:55
#define RTP_PT_IS_RTCP(x)
Definition: rtp.h:110
static void set_port(struct sockaddr_storage *ss, int port)
Definition: rtpproto.c:143
int dscp
Definition: rtpproto.c:59
#define flags(name, subs,...)
Definition: cbs_av1.c:560
char * sources
Definition: rtpproto.c:60
Main libavformat public API header.
static int rtp_get_file_handle(URLContext *h)
Return the local rtcp port used by the RTP connection.
Definition: rtpproto.c:540
static void build_udp_url(RTPContext *s, char *buf, int buf_size, const char *hostname, int port, int local_port, const char *include_sources, const char *exclude_sources)
Definition: rtpproto.c:173
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
int write_to_source
Definition: rtpproto.c:51
#define av_free(p)
int len
int local_rtpport
Definition: rtpproto.c:56
int ttl
Definition: rtpproto.c:54
#define OFFSET(x)
Definition: rtpproto.c:66
int max_packet_size
if non zero, the stream is packetized with this max packet size
Definition: url.h:44
int ff_network_wait_fd(int fd, int write)
Definition: network.c:69
unbuffered private I/O API
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
int ff_rtp_set_remote_url(URLContext *h, const char *uri)
If no filename is given to av_open_input_file because you want to get the local port first...
Definition: rtpproto.c:103
Structure for storing IP (UDP) source filters or block lists.
Definition: ip.h:29
int i
Definition: input.c:407
int connect
Definition: rtpproto.c:57
#define E
Definition: rtpproto.c:68