FFmpeg
udp.c
Go to the documentation of this file.
1 /*
2  * UDP prototype streaming system
3  * Copyright (c) 2000, 2001, 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  * UDP protocol
25  */
26 
27 #define _DEFAULT_SOURCE
28 #define _BSD_SOURCE /* Needed for using struct ip_mreq with recent glibc */
29 
30 #include "avformat.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/fifo.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/log.h"
38 #include "libavutil/time.h"
39 #include "internal.h"
40 #include "network.h"
41 #include "os_support.h"
42 #include "url.h"
43 #include "ip.h"
44 
45 #ifdef __APPLE__
46 #include "TargetConditionals.h"
47 #endif
48 
49 #if HAVE_UDPLITE_H
50 #include "udplite.h"
51 #else
52 /* On many Linux systems, udplite.h is missing but the kernel supports UDP-Lite.
53  * So, we provide a fallback here.
54  */
55 #define UDPLITE_SEND_CSCOV 10
56 #define UDPLITE_RECV_CSCOV 11
57 #endif
58 
59 #ifndef IPPROTO_UDPLITE
60 #define IPPROTO_UDPLITE 136
61 #endif
62 
63 #if HAVE_W32THREADS
64 #undef HAVE_PTHREAD_CANCEL
65 #define HAVE_PTHREAD_CANCEL 1
66 #endif
67 
68 #if HAVE_PTHREAD_CANCEL
69 #include "libavutil/thread.h"
70 #endif
71 
72 #ifndef IPV6_ADD_MEMBERSHIP
73 #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
74 #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
75 #endif
76 
77 #define UDP_TX_BUF_SIZE 32768
78 #define UDP_RX_BUF_SIZE 393216
79 #define UDP_MAX_PKT_SIZE 65536
80 #define UDP_HEADER_SIZE 8
81 
82 typedef struct UDPQueuedPacketHeader {
83  int pkt_size;
85  socklen_t addr_len;
87 
88 typedef struct UDPContext {
89  const AVClass *class;
90  int udp_fd;
91  int ttl;
94  int pkt_size;
103 
104  /* Circular Buffer variables for use in UDP receive code */
109  int64_t bitrate; /* number of bits to send per second */
112 #if HAVE_PTHREAD_CANCEL
113  pthread_t circular_buffer_thread;
116  int thread_started;
117 #endif
120  char *localaddr;
121  int timeout;
122  int dscp;
124  char *sources;
125  char *block;
129 } UDPContext;
130 
131 #define OFFSET(x) offsetof(UDPContext, x)
132 #define D AV_OPT_FLAG_DECODING_PARAM
133 #define E AV_OPT_FLAG_ENCODING_PARAM
134 static const AVOption options[] = {
135  { "buffer_size", "System data size (in bytes)", OFFSET(buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
136  { "bitrate", "Bits to send per second", OFFSET(bitrate), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, .flags = E },
137  { "burst_bits", "Max length of bursts in bits (when using bitrate)", OFFSET(burst_bits), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, .flags = E },
138  { "localport", "Local port", OFFSET(local_port), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, D|E },
139  { "local_port", "Local port", OFFSET(local_port), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },
140  { "localaddr", "Local address", OFFSET(localaddr), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
141  { "udplite_coverage", "choose UDPLite head size which should be validated by checksum", OFFSET(udplite_coverage), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, D|E },
142  { "pkt_size", "Maximum UDP packet size", OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = 1472 }, -1, INT_MAX, .flags = D|E },
143  { "reuse", "explicitly allow reusing UDP sockets", OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, D|E },
144  { "reuse_socket", "explicitly allow reusing UDP sockets", OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },
145  { "broadcast", "explicitly allow or disallow broadcast destination", OFFSET(is_broadcast), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
146  { "ttl", "Time to live (multicast only)", OFFSET(ttl), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 255, E },
147  { "dscp", "DSCP class for outgoing packets", OFFSET(dscp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 63, E },
148  { "connect", "set if connect() should be called on socket", OFFSET(is_connected), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = D|E },
149  { "fifo_size", "set the UDP circular buffer size (in 188-byte packets)", OFFSET(circular_buffer_size), AV_OPT_TYPE_INT, {.i64 = HAVE_PTHREAD_CANCEL ? 7*4096 : 0}, 0, INT_MAX, D },
150  { "overrun_nonfatal", "survive in case of UDP receiving circular buffer overrun", OFFSET(overrun_nonfatal), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, D },
151  { "timeout", "set raise error timeout, in microseconds (only in read mode)",OFFSET(timeout), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, D },
152  { "sources", "Source list", OFFSET(sources), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
153  { "block", "Block list", OFFSET(block), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },
154  { NULL }
155 };
156 
157 static const AVClass udp_class = {
158  .class_name = "udp",
159  .item_name = av_default_item_name,
160  .option = options,
161  .version = LIBAVUTIL_VERSION_INT,
162 };
163 
165  .class_name = "udplite",
166  .item_name = av_default_item_name,
167  .option = options,
168  .version = LIBAVUTIL_VERSION_INT,
169 };
170 
171 static int udp_set_multicast_ttl(int sockfd, int mcastTTL,
172  struct sockaddr *addr,
173  void *logctx)
174 {
175  int protocol, cmd;
176 
177  /* There is some confusion in the world whether IP_MULTICAST_TTL
178  * takes a byte or an int as an argument.
179  * BSD seems to indicate byte so we are going with that and use
180  * int and fall back to byte to be safe */
181  switch (addr->sa_family) {
182 #ifdef IP_MULTICAST_TTL
183  case AF_INET:
184  protocol = IPPROTO_IP;
185  cmd = IP_MULTICAST_TTL;
186  break;
187 #endif
188 #ifdef IPV6_MULTICAST_HOPS
189  case AF_INET6:
190  protocol = IPPROTO_IPV6;
191  cmd = IPV6_MULTICAST_HOPS;
192  break;
193 #endif
194  default:
195  return 0;
196  }
197 
198  if (setsockopt(sockfd, protocol, cmd, &mcastTTL, sizeof(mcastTTL)) < 0) {
199  /* BSD compatibility */
200  unsigned char ttl = (unsigned char) mcastTTL;
201 
202  ff_log_net_error(logctx, AV_LOG_DEBUG, "setsockopt(IPV4/IPV6 MULTICAST TTL)");
203  if (setsockopt(sockfd, protocol, cmd, &ttl, sizeof(ttl)) < 0) {
204  ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV4/IPV6 MULTICAST TTL)");
205  return ff_neterrno();
206  }
207  }
208 
209  return 0;
210 }
211 
212 static int udp_join_multicast_group(int sockfd, struct sockaddr *addr,
213  struct sockaddr *local_addr, void *logctx)
214 {
215 #ifdef IP_ADD_MEMBERSHIP
216  if (addr->sa_family == AF_INET) {
217  struct ip_mreq mreq;
218 
219  mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
220  if (local_addr)
221  mreq.imr_interface= ((struct sockaddr_in *)local_addr)->sin_addr;
222  else
223  mreq.imr_interface.s_addr = INADDR_ANY;
224  if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
225  ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IP_ADD_MEMBERSHIP)");
226  return ff_neterrno();
227  }
228  }
229 #endif
230 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
231  if (addr->sa_family == AF_INET6) {
232  struct ipv6_mreq mreq6;
233 
234  memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
235  //TODO: Interface index should be looked up from local_addr
236  mreq6.ipv6mr_interface = 0;
237  if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
238  ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV6_ADD_MEMBERSHIP)");
239  return ff_neterrno();
240  }
241  }
242 #endif
243  return 0;
244 }
245 
246 static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr,
247  struct sockaddr *local_addr, void *logctx)
248 {
249 #ifdef IP_DROP_MEMBERSHIP
250  if (addr->sa_family == AF_INET) {
251  struct ip_mreq mreq;
252 
253  mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
254  if (local_addr)
255  mreq.imr_interface = ((struct sockaddr_in *)local_addr)->sin_addr;
256  else
257  mreq.imr_interface.s_addr = INADDR_ANY;
258  if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
259  ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IP_DROP_MEMBERSHIP)");
260  return -1;
261  }
262  }
263 #endif
264 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)
265  if (addr->sa_family == AF_INET6) {
266  struct ipv6_mreq mreq6;
267 
268  memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
269  //TODO: Interface index should be looked up from local_addr
270  mreq6.ipv6mr_interface = 0;
271  if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
272  ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV6_DROP_MEMBERSHIP)");
273  return -1;
274  }
275  }
276 #endif
277  return 0;
278 }
279 
281  int sockfd, struct sockaddr *addr,
282  int addr_len, struct sockaddr_storage *local_addr,
283  struct sockaddr_storage *sources,
284  int nb_sources, int include)
285 {
286  if (addr->sa_family != AF_INET) {
287 #if HAVE_STRUCT_GROUP_SOURCE_REQ && defined(MCAST_BLOCK_SOURCE)
288  /* For IPv4 prefer the old approach, as that alone works reliably on
289  * Windows and it also supports supplying the interface based on its
290  * address. */
291  for (int i = 0; i < nb_sources; i++) {
292  struct group_source_req mreqs;
293  int level = addr->sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
294 
295  //TODO: Interface index should be looked up from local_addr
296  mreqs.gsr_interface = 0;
297  memcpy(&mreqs.gsr_group, addr, addr_len);
298  memcpy(&mreqs.gsr_source, &sources[i], sizeof(*sources));
299 
300  if (setsockopt(sockfd, level,
301  include ? MCAST_JOIN_SOURCE_GROUP : MCAST_BLOCK_SOURCE,
302  (const void *)&mreqs, sizeof(mreqs)) < 0) {
303  if (include)
304  ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(MCAST_JOIN_SOURCE_GROUP)");
305  else
306  ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(MCAST_BLOCK_SOURCE)");
307  return ff_neterrno();
308  }
309  }
310  return 0;
311 #else
313  "Setting multicast sources only supported for IPv4\n");
314  return AVERROR(EINVAL);
315 #endif
316  }
317 #if HAVE_STRUCT_IP_MREQ_SOURCE && defined(IP_BLOCK_SOURCE)
318  for (int i = 0; i < nb_sources; i++) {
319  struct ip_mreq_source mreqs;
320  if (sources[i].ss_family != AF_INET) {
321  av_log(h, AV_LOG_ERROR, "Source/block address %d is of incorrect protocol family\n", i + 1);
322  return AVERROR(EINVAL);
323  }
324 
325  mreqs.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
326  if (local_addr)
327  mreqs.imr_interface = ((struct sockaddr_in *)local_addr)->sin_addr;
328  else
329  mreqs.imr_interface.s_addr = INADDR_ANY;
330  mreqs.imr_sourceaddr.s_addr = ((struct sockaddr_in *)&sources[i])->sin_addr.s_addr;
331 
332  if (setsockopt(sockfd, IPPROTO_IP,
333  include ? IP_ADD_SOURCE_MEMBERSHIP : IP_BLOCK_SOURCE,
334  (const void *)&mreqs, sizeof(mreqs)) < 0) {
335  if (include)
336  ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(IP_ADD_SOURCE_MEMBERSHIP)");
337  else
338  ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(IP_BLOCK_SOURCE)");
339  return ff_neterrno();
340  }
341  }
342 #else
343  return AVERROR(ENOSYS);
344 #endif
345  return 0;
346 }
348  struct sockaddr_storage *addr,
349  const char *hostname, int port)
350 {
351  struct addrinfo *res0;
352  int addr_len;
353 
354  res0 = ff_ip_resolve_host(h, hostname, port, SOCK_DGRAM, AF_UNSPEC, 0);
355  if (!res0) return AVERROR(EIO);
356  memcpy(addr, res0->ai_addr, res0->ai_addrlen);
357  addr_len = res0->ai_addrlen;
358  freeaddrinfo(res0);
359 
360  return addr_len;
361 }
362 
363 static int udp_socket_create(URLContext *h, struct sockaddr_storage *addr,
364  socklen_t *addr_len, const char *localaddr)
365 {
366  UDPContext *s = h->priv_data;
367  int udp_fd = -1;
368  struct addrinfo *res0, *res;
369  int family = AF_UNSPEC;
370 
371  if (((struct sockaddr *) &s->dest_addr)->sa_family)
372  family = ((struct sockaddr *) &s->dest_addr)->sa_family;
373  res0 = ff_ip_resolve_host(h, (localaddr && localaddr[0]) ? localaddr : NULL,
374  s->local_port,
375  SOCK_DGRAM, family, AI_PASSIVE);
376  if (!res0)
377  goto fail;
378  for (res = res0; res; res=res->ai_next) {
379  if (s->udplite_coverage)
380  udp_fd = ff_socket(res->ai_family, SOCK_DGRAM, IPPROTO_UDPLITE, h);
381  else
382  udp_fd = ff_socket(res->ai_family, SOCK_DGRAM, 0, h);
383  if (udp_fd != -1) break;
384  ff_log_net_error(h, AV_LOG_ERROR, "socket");
385  }
386 
387  if (udp_fd < 0)
388  goto fail;
389 
390  memcpy(addr, res->ai_addr, res->ai_addrlen);
391  *addr_len = res->ai_addrlen;
392 
393  freeaddrinfo(res0);
394 
395  return udp_fd;
396 
397  fail:
398  if (udp_fd >= 0)
399  closesocket(udp_fd);
400  if(res0)
401  freeaddrinfo(res0);
402  return -1;
403 }
404 
405 static int udp_port(struct sockaddr_storage *addr, int addr_len)
406 {
407  char sbuf[sizeof(int)*3+1];
408  int error;
409 
410  if ((error = getnameinfo((struct sockaddr *)addr, addr_len, NULL, 0, sbuf, sizeof(sbuf), NI_NUMERICSERV)) != 0) {
411  av_log(NULL, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(error));
412  return -1;
413  }
414 
415  return strtol(sbuf, NULL, 10);
416 }
417 
418 
419 /**
420  * If no filename is given to av_open_input_file because you want to
421  * get the local port first, then you must call this function to set
422  * the remote server address.
423  *
424  * url syntax: udp://host:port[?option=val...]
425  * option: 'ttl=n' : set the ttl value (for multicast only)
426  * 'localport=n' : set the local port
427  * 'pkt_size=n' : set max packet size
428  * 'reuse=1' : enable reusing the socket
429  * 'overrun_nonfatal=1': survive in case of circular buffer overrun
430  *
431  * @param h media file context
432  * @param uri of the remote server
433  * @return zero if no error.
434  */
435 int ff_udp_set_remote_url(URLContext *h, const char *uri)
436 {
437  UDPContext *s = h->priv_data;
438  char hostname[256], buf[10];
439  int port;
440  const char *p;
441 
442  av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
443 
444  /* set the destination address */
445  s->dest_addr_len = udp_set_url(h, &s->dest_addr, hostname, port);
446  if (s->dest_addr_len < 0) {
447  return AVERROR(EIO);
448  }
449  s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);
450  p = strchr(uri, '?');
451  if (p) {
452  if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {
453  int was_connected = s->is_connected;
454  s->is_connected = strtol(buf, NULL, 10);
455  if (s->is_connected && !was_connected) {
456  if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,
457  s->dest_addr_len)) {
458  s->is_connected = 0;
459  ff_log_net_error(h, AV_LOG_ERROR, "connect");
460  return AVERROR(EIO);
461  }
462  }
463  }
464  }
465 
466  return 0;
467 }
468 
469 /**
470  * This function is identical to ff_udp_set_remote_url, except that it takes a sockaddr directly.
471  */
472 int ff_udp_set_remote_addr(URLContext *h, const struct sockaddr *dest_addr, socklen_t dest_addr_len, int do_connect)
473 {
474  UDPContext *s = h->priv_data;
475 
476  /* set the destination address */
477  if ((size_t)dest_addr_len > sizeof(s->dest_addr))
478  return AVERROR(EIO);
479  s->dest_addr_len = dest_addr_len;
480  memcpy(&s->dest_addr, dest_addr, dest_addr_len);
481 
482  s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);
483  if (do_connect >= 0) {
484  int was_connected = s->is_connected;
485  s->is_connected = do_connect;
486  if (s->is_connected && !was_connected) {
487  if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,
488  s->dest_addr_len)) {
489  s->is_connected = 0;
490  ff_log_net_error(h, AV_LOG_ERROR, "connect");
491  return AVERROR(EIO);
492  }
493  }
494  }
495 
496  return 0;
497 }
498 
499 /**
500  * Return the local port used by the UDP connection
501  * @param h media file context
502  * @return the local port number
503  */
505 {
506  UDPContext *s = h->priv_data;
507  return s->local_port;
508 }
509 
510 void ff_udp_get_last_recv_addr(URLContext *h, struct sockaddr_storage *addr, socklen_t *addr_len)
511 {
512  UDPContext *s = h->priv_data;
513  *addr = s->last_recv_addr;
514  *addr_len = s->last_recv_addr_len;
515 }
516 
517 /**
518  * Return the udp file handle for select() usage to wait for several RTP
519  * streams at the same time.
520  * @param h media file context
521  */
523 {
524  UDPContext *s = h->priv_data;
525  return s->udp_fd;
526 }
527 
528 #if HAVE_PTHREAD_CANCEL
529 static void *circular_buffer_task_rx( void *_URLContext)
530 {
531  URLContext *h = _URLContext;
532  UDPContext *s = h->priv_data;
533  int old_cancelstate;
534 
535  ff_thread_setname("udp-rx");
536 
538  pthread_mutex_lock(&s->mutex);
539  if (ff_socket_nonblock(s->udp_fd, 0) < 0) {
540  av_log(h, AV_LOG_ERROR, "Failed to set blocking mode");
541  s->circular_buffer_error = AVERROR(EIO);
542  goto end;
543  }
544  while(1) {
545  UDPQueuedPacketHeader pkt_header;
546 
547  pthread_mutex_unlock(&s->mutex);
548  /* Blocking operations are always cancellation points;
549  see "General Information" / "Thread Cancellation Overview"
550  in Single Unix. */
552  pkt_header.pkt_size = recvfrom(s->udp_fd, s->tmp + sizeof(pkt_header), sizeof(s->tmp) - sizeof(pkt_header), 0, (struct sockaddr *)&pkt_header.addr, &pkt_header.addr_len);
554  pthread_mutex_lock(&s->mutex);
555  if (pkt_header.pkt_size < 0) {
556  if (ff_neterrno() != AVERROR(EAGAIN) && ff_neterrno() != AVERROR(EINTR)) {
557  s->circular_buffer_error = ff_neterrno();
558  goto end;
559  }
560  continue;
561  }
562  if (ff_ip_check_source_lists(&pkt_header.addr, &s->filters))
563  continue;
564  memcpy(s->tmp, &pkt_header, sizeof(pkt_header));
565 
566  if (av_fifo_can_write(s->rx_fifo) < pkt_header.pkt_size + sizeof(pkt_header)) {
567  /* No Space left */
568  if (s->overrun_nonfatal) {
569  av_log(h, AV_LOG_WARNING, "Circular buffer overrun. "
570  "Surviving due to overrun_nonfatal option\n");
571  continue;
572  } else {
573  av_log(h, AV_LOG_ERROR, "Circular buffer overrun. "
574  "To avoid, increase fifo_size URL option. "
575  "To survive in such case, use overrun_nonfatal option\n");
576  s->circular_buffer_error = AVERROR(EIO);
577  goto end;
578  }
579  }
580  av_fifo_write(s->rx_fifo, s->tmp, pkt_header.pkt_size + sizeof(pkt_header));
581  pthread_cond_signal(&s->cond);
582  }
583 
584 end:
585  pthread_cond_signal(&s->cond);
586  pthread_mutex_unlock(&s->mutex);
587  return NULL;
588 }
589 
590 static void *circular_buffer_task_tx( void *_URLContext)
591 {
592  URLContext *h = _URLContext;
593  UDPContext *s = h->priv_data;
594  int64_t target_timestamp = av_gettime_relative();
595  int64_t start_timestamp = av_gettime_relative();
596  int64_t sent_bits = 0;
597  int64_t burst_interval = s->bitrate ? (s->burst_bits * 1000000 / s->bitrate) : 0;
598  int64_t max_delay = s->bitrate ? ((int64_t)h->max_packet_size * 8 * 1000000 / s->bitrate + 1) : 0;
599 
600  ff_thread_setname("udp-tx");
601 
602  pthread_mutex_lock(&s->mutex);
603 
604  if (ff_socket_nonblock(s->udp_fd, 0) < 0) {
605  av_log(h, AV_LOG_ERROR, "Failed to set blocking mode");
606  s->circular_buffer_error = AVERROR(EIO);
607  goto end;
608  }
609 
610  for(;;) {
611  int len;
612  const uint8_t *p;
613  uint8_t tmp[4];
614  int64_t timestamp;
615 
616  len = av_fifo_can_read(s->tx_fifo);
617 
618  while (len<4) {
619  if (s->close_req)
620  goto end;
621  pthread_cond_wait(&s->cond, &s->mutex);
622  len = av_fifo_can_read(s->tx_fifo);
623  }
624 
625  av_fifo_read(s->tx_fifo, tmp, 4);
626  len = AV_RL32(tmp);
627 
628  av_assert0(len >= 0);
629  av_assert0(len <= sizeof(s->tmp));
630 
631  av_fifo_read(s->tx_fifo, s->tmp, len);
632 
633  pthread_mutex_unlock(&s->mutex);
634 
635  if (s->bitrate) {
636  timestamp = av_gettime_relative();
637  if (timestamp < target_timestamp) {
638  int64_t delay = target_timestamp - timestamp;
639  if (delay > max_delay) {
640  delay = max_delay;
641  start_timestamp = timestamp + delay;
642  sent_bits = 0;
643  }
644  av_usleep(delay);
645  } else {
646  if (timestamp - burst_interval > target_timestamp) {
647  start_timestamp = timestamp - burst_interval;
648  sent_bits = 0;
649  }
650  }
651  sent_bits += len * 8;
652  target_timestamp = start_timestamp + sent_bits * 1000000 / s->bitrate;
653  }
654 
655  p = s->tmp;
656  while (len) {
657  int ret;
658  av_assert0(len > 0);
659  if (!s->is_connected) {
660  ret = sendto (s->udp_fd, p, len, 0,
661  (struct sockaddr *) &s->dest_addr,
662  s->dest_addr_len);
663  } else
664  ret = send(s->udp_fd, p, len, 0);
665  if (ret >= 0) {
666  len -= ret;
667  p += ret;
668  } else {
669  ret = ff_neterrno();
670  if (ret != AVERROR(EAGAIN) && ret != AVERROR(EINTR)) {
671  pthread_mutex_lock(&s->mutex);
672  s->circular_buffer_error = ret;
673  pthread_mutex_unlock(&s->mutex);
674  return NULL;
675  }
676  }
677  }
678 
679  pthread_mutex_lock(&s->mutex);
680  }
681 
682 end:
683  pthread_mutex_unlock(&s->mutex);
684  return NULL;
685 }
686 
687 
688 #endif
689 
690 /* put it in UDP context */
691 /* return non zero if error */
692 static int udp_open(URLContext *h, const char *uri, int flags)
693 {
694  char hostname[1024];
695  int port, udp_fd = -1, tmp, bind_ret = -1;
696  UDPContext *s = h->priv_data;
697  int is_output;
698  const char *p;
699  struct sockaddr_storage my_addr;
700  socklen_t len;
701  int ret;
702 
703  h->is_streamed = 1;
704 
705  is_output = !(flags & AVIO_FLAG_READ);
706  if (s->buffer_size < 0)
707  s->buffer_size = is_output ? UDP_TX_BUF_SIZE : UDP_RX_BUF_SIZE;
708 
709  p = strchr(uri, '?');
710  if (p) {
712  if (ret < 0)
713  goto fail;
714  }
715  if (!HAVE_PTHREAD_CANCEL) {
716  int64_t optvals[] = {s->overrun_nonfatal, s->bitrate, s->circular_buffer_size};
717  const char* optnames[] = { "overrun_nonfatal", "bitrate", "fifo_size"};
718  for (unsigned i = 0; i < FF_ARRAY_ELEMS(optvals); i++) {
719  if (optvals[i])
721  "'%s' option was set but it is not supported "
722  "on this build (pthread support is required)\n", optnames[i]);
723  }
724  }
725  if (s->sources) {
726  if ((ret = ff_ip_parse_sources(h, s->sources, &s->filters)) < 0)
727  goto fail;
728  }
729  if (s->block) {
730  if ((ret = ff_ip_parse_blocks(h, s->block, &s->filters)) < 0)
731  goto fail;
732  }
733 
734  /* handling needed to support options picking from both AVOption and URL */
735  s->circular_buffer_size *= 188;
736  if (flags & AVIO_FLAG_WRITE) {
737  h->max_packet_size = s->pkt_size;
738  } else {
739  h->max_packet_size = UDP_MAX_PKT_SIZE;
740  }
741  h->rw_timeout = s->timeout;
742 
743  /* fill the dest addr */
744  av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
745 
746  /* XXX: fix av_url_split */
747  if (hostname[0] == '\0' || hostname[0] == '?') {
748  /* only accepts null hostname if input */
749  if (!(flags & AVIO_FLAG_READ)) {
750  ret = AVERROR(EINVAL);
751  goto fail;
752  }
753  } else {
754  if ((ret = ff_udp_set_remote_url(h, uri)) < 0)
755  goto fail;
756  }
757 
758  if ((s->is_multicast || s->local_port < 0) && (h->flags & AVIO_FLAG_READ))
759  s->local_port = port;
760 
761  udp_fd = udp_socket_create(h, &my_addr, &len, s->localaddr);
762  if (udp_fd < 0) {
763  ret = AVERROR(EIO);
764  goto fail;
765  }
766 
767  s->local_addr_storage=my_addr; //store for future multicast join
768 
769  /* Follow the requested reuse option, unless it's multicast in which
770  * case enable reuse unless explicitly disabled.
771  */
772  if (s->reuse_socket > 0 || (s->is_multicast && s->reuse_socket < 0)) {
773  s->reuse_socket = 1;
774  if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0) {
775  ret = ff_neterrno();
776  goto fail;
777  }
778  }
779 
780  if (s->is_broadcast) {
781 #ifdef SO_BROADCAST
782  if (setsockopt (udp_fd, SOL_SOCKET, SO_BROADCAST, &(s->is_broadcast), sizeof(s->is_broadcast)) != 0) {
783  ret = ff_neterrno();
784  goto fail;
785  }
786 #else
787  ret = AVERROR(ENOSYS);
788  goto fail;
789 #endif
790  }
791 
792  /* Set the checksum coverage for UDP-Lite (RFC 3828) for sending and receiving.
793  * The receiver coverage has to be less than or equal to the sender coverage.
794  * Otherwise, the receiver will drop all packets.
795  */
796  if (s->udplite_coverage) {
797  if (setsockopt (udp_fd, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV, &(s->udplite_coverage), sizeof(s->udplite_coverage)) != 0)
798  av_log(h, AV_LOG_WARNING, "socket option UDPLITE_SEND_CSCOV not available");
799 
800  if (setsockopt (udp_fd, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV, &(s->udplite_coverage), sizeof(s->udplite_coverage)) != 0)
801  av_log(h, AV_LOG_WARNING, "socket option UDPLITE_RECV_CSCOV not available");
802  }
803 
804  if (s->dscp >= 0) {
805  int dscp = s->dscp << 2;
806  if (setsockopt (udp_fd, IPPROTO_IP, IP_TOS, &dscp, sizeof(dscp)) != 0) {
807  ret = ff_neterrno();
808  goto fail;
809  }
810  }
811 
812  /* If multicast, try binding the multicast address first, to avoid
813  * receiving UDP packets from other sources aimed at the same UDP
814  * port. This fails on windows. This makes sending to the same address
815  * using sendto() fail, so only do it if we're opened in read-only mode. */
816  if (s->is_multicast && (h->flags & AVIO_FLAG_READ)) {
817  bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);
818  }
819  /* bind to the local address if not multicast or if the multicast
820  * bind failed */
821  /* the bind is needed to give a port to the socket now */
822  if (bind_ret < 0 && bind(udp_fd,(struct sockaddr *)&my_addr, len) < 0) {
823  ff_log_net_error(h, AV_LOG_ERROR, "bind failed");
824  ret = ff_neterrno();
825  goto fail;
826  }
827 
828  len = sizeof(my_addr);
829  getsockname(udp_fd, (struct sockaddr *)&my_addr, &len);
830  s->local_port = udp_port(&my_addr, len);
831 
832  if (s->is_multicast) {
833  if (h->flags & AVIO_FLAG_WRITE) {
834  /* output */
835  if ((ret = udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr, h)) < 0)
836  goto fail;
837  }
838  if (h->flags & AVIO_FLAG_READ) {
839  /* input */
840  if (s->filters.nb_include_addrs) {
841  if ((ret = udp_set_multicast_sources(h, udp_fd,
842  (struct sockaddr *)&s->dest_addr,
843  s->dest_addr_len, &s->local_addr_storage,
844  s->filters.include_addrs,
845  s->filters.nb_include_addrs, 1)) < 0)
846  goto fail;
847  } else {
848  if ((ret = udp_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr,
849  (struct sockaddr *)&s->local_addr_storage, h)) < 0)
850  goto fail;
851  }
852  if (s->filters.nb_exclude_addrs) {
853  if ((ret = udp_set_multicast_sources(h, udp_fd,
854  (struct sockaddr *)&s->dest_addr,
855  s->dest_addr_len, &s->local_addr_storage,
856  s->filters.exclude_addrs,
857  s->filters.nb_exclude_addrs, 0)) < 0)
858  goto fail;
859  }
860  }
861  }
862 
863  if (is_output) {
864  /* limit the tx buf size to limit latency */
865  tmp = s->buffer_size;
866  if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {
867  ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(SO_SNDBUF)");
868  ret = ff_neterrno();
869  goto fail;
870  }
871  } else {
872  /* set udp recv buffer size to the requested value (default UDP_RX_BUF_SIZE) */
873  tmp = s->buffer_size;
874  if (setsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, sizeof(tmp)) < 0) {
875  ff_log_net_error(h, AV_LOG_WARNING, "setsockopt(SO_RECVBUF)");
876  }
877  len = sizeof(tmp);
878  if (getsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, &len) < 0) {
879  ff_log_net_error(h, AV_LOG_WARNING, "getsockopt(SO_RCVBUF)");
880  } else {
881  av_log(h, AV_LOG_DEBUG, "end receive buffer size reported is %d\n", tmp);
882  if(tmp < s->buffer_size)
883  av_log(h, AV_LOG_WARNING, "attempted to set receive buffer to size %d but it only ended up set as %d\n", s->buffer_size, tmp);
884  }
885 
886  /* make the socket non-blocking */
887  ff_socket_nonblock(udp_fd, 1);
888  }
889  if (s->is_connected) {
890  if (connect(udp_fd, (struct sockaddr *) &s->dest_addr, s->dest_addr_len)) {
891  ff_log_net_error(h, AV_LOG_ERROR, "connect");
892  ret = ff_neterrno();
893  goto fail;
894  }
895  }
896 
897  s->udp_fd = udp_fd;
898 
899 #if HAVE_PTHREAD_CANCEL
900  /*
901  Create thread in case of:
902  1. Input and circular_buffer_size is set
903  2. Output and bitrate and circular_buffer_size is set
904  */
905 
906  if (is_output && s->bitrate && !s->circular_buffer_size) {
907  /* Warn user in case of 'circular_buffer_size' is not set */
908  av_log(h, AV_LOG_WARNING,"'bitrate' option was set but 'circular_buffer_size' is not, but required\n");
909  }
910 
911  if ((!is_output && s->circular_buffer_size) || (is_output && s->bitrate && s->circular_buffer_size)) {
912  /* start the task going */
913  AVFifo *fifo = av_fifo_alloc2(s->circular_buffer_size, 1, 0);
914  if (!fifo) {
915  ret = AVERROR(ENOMEM);
916  goto fail;
917  }
918  if (is_output)
919  s->tx_fifo = fifo;
920  else
921  s->rx_fifo = fifo;
922  ret = pthread_mutex_init(&s->mutex, NULL);
923  if (ret != 0) {
924  av_log(h, AV_LOG_ERROR, "pthread_mutex_init failed : %s\n", strerror(ret));
925  ret = AVERROR(ret);
926  goto fail;
927  }
928  ret = pthread_cond_init(&s->cond, NULL);
929  if (ret != 0) {
930  av_log(h, AV_LOG_ERROR, "pthread_cond_init failed : %s\n", strerror(ret));
931  ret = AVERROR(ret);
932  goto cond_fail;
933  }
934  ret = pthread_create(&s->circular_buffer_thread, NULL, is_output?circular_buffer_task_tx:circular_buffer_task_rx, h);
935  if (ret != 0) {
936  av_log(h, AV_LOG_ERROR, "pthread_create failed : %s\n", strerror(ret));
937  ret = AVERROR(ret);
938  goto thread_fail;
939  }
940  s->thread_started = 1;
941  }
942 #endif
943 
944  return 0;
945 #if HAVE_PTHREAD_CANCEL
946  thread_fail:
947  pthread_cond_destroy(&s->cond);
948  cond_fail:
949  pthread_mutex_destroy(&s->mutex);
950 #endif
951  fail:
952  if (udp_fd >= 0)
953  closesocket(udp_fd);
954  av_fifo_freep2(&s->rx_fifo);
955  av_fifo_freep2(&s->tx_fifo);
956  ff_ip_reset_filters(&s->filters);
957  return ret;
958 }
959 
960 static int udplite_open(URLContext *h, const char *uri, int flags)
961 {
962  UDPContext *s = h->priv_data;
963 
964  // set default checksum coverage
965  s->udplite_coverage = UDP_HEADER_SIZE;
966 
967  return udp_open(h, uri, flags);
968 }
969 
970 static int udp_read(URLContext *h, uint8_t *buf, int size)
971 {
972  UDPContext *s = h->priv_data;
973  int ret;
974 #if HAVE_PTHREAD_CANCEL
975  int avail, nonblock = h->flags & AVIO_FLAG_NONBLOCK;
976 
977  if (s->rx_fifo) {
978  pthread_mutex_lock(&s->mutex);
979  do {
980  avail = av_fifo_can_read(s->rx_fifo);
981  if (avail) { // >=size) {
983 
984  av_fifo_read(s->rx_fifo, &header, sizeof(header));
985 
986  s->last_recv_addr = header.addr;
987  s->last_recv_addr_len = header.addr_len;
988 
989  avail = header.pkt_size;
990  if(avail > size){
991  av_log(h, AV_LOG_WARNING, "Part of datagram lost due to insufficient buffer size\n");
992  avail = size;
993  }
994 
995  av_fifo_read(s->rx_fifo, buf, avail);
996  av_fifo_drain2(s->rx_fifo, header.pkt_size - avail);
997  pthread_mutex_unlock(&s->mutex);
998  return avail;
999  } else if(s->circular_buffer_error){
1000  int err = s->circular_buffer_error;
1001  pthread_mutex_unlock(&s->mutex);
1002  return err;
1003  } else if(nonblock) {
1004  pthread_mutex_unlock(&s->mutex);
1005  return AVERROR(EAGAIN);
1006  } else {
1007  /* FIXME: using the monotonic clock would be better,
1008  but it does not exist on all supported platforms. */
1009  int64_t t = av_gettime() + 100000;
1010  struct timespec tv = { .tv_sec = t / 1000000,
1011  .tv_nsec = (t % 1000000) * 1000 };
1012  int err = pthread_cond_timedwait(&s->cond, &s->mutex, &tv);
1013  if (err) {
1014  pthread_mutex_unlock(&s->mutex);
1015  return AVERROR(err == ETIMEDOUT ? EAGAIN : err);
1016  }
1017  nonblock = 1;
1018  }
1019  } while(1);
1020  }
1021 #endif
1022 
1023  if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
1024  ret = ff_network_wait_fd(s->udp_fd, 0);
1025  if (ret < 0)
1026  return ret;
1027  }
1028  s->last_recv_addr_len = sizeof(s->last_recv_addr);
1029  ret = recvfrom(s->udp_fd, buf, size, 0, (struct sockaddr *)&s->last_recv_addr, &s->last_recv_addr_len);
1030  if (ret < 0)
1031  return ff_neterrno();
1032  if (ff_ip_check_source_lists(&s->last_recv_addr, &s->filters))
1033  return AVERROR(EINTR);
1034  return ret;
1035 }
1036 
1037 static int udp_write(URLContext *h, const uint8_t *buf, int size)
1038 {
1039  UDPContext *s = h->priv_data;
1040  int ret;
1041 
1042 #if HAVE_PTHREAD_CANCEL
1043  if (s->tx_fifo) {
1044  uint8_t tmp[4];
1045 
1046  pthread_mutex_lock(&s->mutex);
1047 
1048  /*
1049  Return error if last tx failed.
1050  Here we can't know on which packet error was, but it needs to know that error exists.
1051  */
1052  if (s->circular_buffer_error<0) {
1053  int err = s->circular_buffer_error;
1054  pthread_mutex_unlock(&s->mutex);
1055  return err;
1056  }
1057 
1058  if (av_fifo_can_write(s->tx_fifo) < size + 4) {
1059  /* What about a partial packet tx ? */
1060  pthread_mutex_unlock(&s->mutex);
1061  return AVERROR(ENOMEM);
1062  }
1063  AV_WL32(tmp, size);
1064  av_fifo_write(s->tx_fifo, tmp, 4); /* size of packet */
1065  av_fifo_write(s->tx_fifo, buf, size); /* the data */
1066  pthread_cond_signal(&s->cond);
1067  pthread_mutex_unlock(&s->mutex);
1068  return size;
1069  }
1070 #endif
1071  if (!(h->flags & AVIO_FLAG_NONBLOCK)) {
1072  ret = ff_network_wait_fd(s->udp_fd, 1);
1073  if (ret < 0)
1074  return ret;
1075  }
1076 
1077  if (!s->is_connected) {
1078  ret = sendto (s->udp_fd, buf, size, 0,
1079  (struct sockaddr *) &s->dest_addr,
1080  s->dest_addr_len);
1081  } else
1082  ret = send(s->udp_fd, buf, size, 0);
1083 
1084  return ret < 0 ? ff_neterrno() : ret;
1085 }
1086 
1087 static int udp_close(URLContext *h)
1088 {
1089  UDPContext *s = h->priv_data;
1090 
1091 #if HAVE_PTHREAD_CANCEL
1092  // Request close once writing is finished
1093  if (s->thread_started && !(h->flags & AVIO_FLAG_READ)) {
1094  pthread_mutex_lock(&s->mutex);
1095  s->close_req = 1;
1096  pthread_cond_signal(&s->cond);
1097  pthread_mutex_unlock(&s->mutex);
1098  }
1099 #endif
1100 
1101  if (s->is_multicast && (h->flags & AVIO_FLAG_READ))
1102  udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr,
1103  (struct sockaddr *)&s->local_addr_storage, h);
1104 #if HAVE_PTHREAD_CANCEL
1105  if (s->thread_started) {
1106  int ret;
1107  // Cancel only read, as write has been signaled as success to the user
1108  if (h->flags & AVIO_FLAG_READ) {
1109 #ifdef _WIN32
1110  /* recvfrom() is not a cancellation point for win32, so we shutdown
1111  * the socket and abort pending IO, subsequent recvfrom() calls
1112  * will fail with WSAESHUTDOWN causing the thread to exit. */
1113  shutdown(s->udp_fd, SD_RECEIVE);
1114  CancelIoEx((HANDLE)(SOCKET)s->udp_fd, NULL);
1115 #else
1116  pthread_cancel(s->circular_buffer_thread);
1117 #endif
1118  }
1119  ret = pthread_join(s->circular_buffer_thread, NULL);
1120  if (ret != 0)
1121  av_log(h, AV_LOG_ERROR, "pthread_join(): %s\n", strerror(ret));
1122  pthread_mutex_destroy(&s->mutex);
1123  pthread_cond_destroy(&s->cond);
1124  }
1125 #endif
1126  closesocket(s->udp_fd);
1127  av_fifo_freep2(&s->rx_fifo);
1128  av_fifo_freep2(&s->tx_fifo);
1129  ff_ip_reset_filters(&s->filters);
1130  return 0;
1131 }
1132 
1134  .name = "udp",
1135  .url_open = udp_open,
1136  .url_read = udp_read,
1137  .url_write = udp_write,
1138  .url_close = udp_close,
1139  .url_get_file_handle = udp_get_file_handle,
1140  .priv_data_size = sizeof(UDPContext),
1141  .priv_data_class = &udp_class,
1143 };
1144 
1146  .name = "udplite",
1147  .url_open = udplite_open,
1148  .url_read = udp_read,
1149  .url_write = udp_write,
1150  .url_close = udp_close,
1151  .url_get_file_handle = udp_get_file_handle,
1152  .priv_data_size = sizeof(UDPContext),
1153  .priv_data_class = &udplite_context_class,
1155 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
flags
const SwsFlags flags[]
Definition: swscale.c:61
pthread_mutex_t
_fmutex pthread_mutex_t
Definition: os2threads.h:53
PTHREAD_CANCEL_ENABLE
#define PTHREAD_CANCEL_ENABLE
Definition: w32pthreads.h:66
av_fifo_drain2
void av_fifo_drain2(AVFifo *f, size_t size)
Discard the specified amount of data from an AVFifo.
Definition: fifo.c:266
pthread_join
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
Definition: os2threads.h:94
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
ff_udp_get_local_port
int ff_udp_get_local_port(URLContext *h)
Return the local port used by the UDP connection.
Definition: udp.c:504
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
level
uint8_t level
Definition: svq3.c:208
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
av_find_info_tag
int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
Attempt to find a specific tag in a URL.
Definition: parseutils.c:756
UDPContext::pkt_size
int pkt_size
Definition: udp.c:94
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
UDPContext::is_connected
int is_connected
Definition: udp.c:102
PTHREAD_CANCEL_DISABLE
#define PTHREAD_CANCEL_DISABLE
Definition: w32pthreads.h:67
URL_PROTOCOL_FLAG_NETWORK
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:33
ff_ip_parse_sources
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:145
udp_socket_create
static int udp_socket_create(URLContext *h, struct sockaddr_storage *addr, socklen_t *addr_len, const char *localaddr)
Definition: udp.c:363
thread.h
E
#define E
Definition: udp.c:133
UDPContext::tmp
uint8_t tmp[UDP_MAX_PKT_SIZE+sizeof(UDPQueuedPacketHeader)]
Definition: udp.c:118
pthread_mutex_init
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
IPPROTO_UDPLITE
#define IPPROTO_UDPLITE
Definition: udp.c:60
int64_t
long long int64_t
Definition: coverity.c:34
udp_set_multicast_ttl
static int udp_set_multicast_ttl(int sockfd, int mcastTTL, struct sockaddr *addr, void *logctx)
Definition: udp.c:171
NI_NUMERICSERV
#define NI_NUMERICSERV
Definition: network.h:203
UDPQueuedPacketHeader
Definition: udp.c:82
OFFSET
#define OFFSET(x)
Definition: udp.c:131
sources
Note except for filters that can have queued frames and sources
Definition: filter_design.txt:286
pthread_mutex_lock
static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
Definition: os2threads.h:119
AVOption
AVOption.
Definition: opt.h:429
ff_log_net_error
void ff_log_net_error(void *ctx, int level, const char *prefix)
Definition: network.c:579
udp_port
static int udp_port(struct sockaddr_storage *addr, int addr_len)
Definition: udp.c:405
ff_udp_set_remote_url
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:435
UDPLITE_RECV_CSCOV
#define UDPLITE_RECV_CSCOV
Definition: udp.c:56
udplite_context_class
static const AVClass udplite_context_class
Definition: udp.c:164
URLProtocol
Definition: url.h:51
os_support.h
UDPContext::bitrate
int64_t bitrate
Definition: udp.c:109
UDPContext::local_addr_storage
struct sockaddr_storage local_addr_storage
Definition: udp.c:123
UDPContext::is_broadcast
int is_broadcast
Definition: udp.c:96
ff_udp_set_remote_addr
int ff_udp_set_remote_addr(URLContext *h, const struct sockaddr *dest_addr, socklen_t dest_addr_len, int do_connect)
This function is identical to ff_udp_set_remote_url, except that it takes a sockaddr directly.
Definition: udp.c:472
sockaddr_storage
Definition: network.h:111
UDPContext::is_multicast
int is_multicast
Definition: udp.c:95
freeaddrinfo
#define freeaddrinfo
Definition: network.h:218
fifo.h
ff_ip_reset_filters
void ff_ip_reset_filters(IPSourceFilters *filters)
Resets the IP filter list and frees the internal fields of an IPSourceFilters structure.
Definition: ip.c:155
ff_udp_protocol
const URLProtocol ff_udp_protocol
Definition: udp.c:1133
udp_leave_multicast_group
static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr, struct sockaddr *local_addr, void *logctx)
Definition: udp.c:246
fail
#define fail()
Definition: checkasm.h:204
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
UDPContext::filters
IPSourceFilters filters
Definition: udp.c:126
UDPContext::dscp
int dscp
Definition: udp.c:122
udp_set_url
static int udp_set_url(URLContext *h, struct sockaddr_storage *addr, const char *hostname, int port)
Definition: udp.c:347
mutex
static AVMutex mutex
Definition: resman.c:61
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
UDPContext::remaining_in_dg
int remaining_in_dg
Definition: udp.c:119
pthread_mutex_unlock
static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
Definition: os2threads.h:126
bitrate
int64_t bitrate
Definition: av1_levels.c:47
UDPContext::close_req
int close_req
Definition: udp.c:111
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Underlying C type is int64_t.
Definition: opt.h:263
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
UDPContext::dest_addr_len
int dest_addr_len
Definition: udp.c:101
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
pthread_create
static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
Definition: os2threads.h:80
UDPContext::reuse_socket
int reuse_socket
Definition: udp.c:98
internal.h
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
ff_ip_parse_blocks
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:150
UDPContext::circular_buffer_size
int circular_buffer_size
Definition: udp.c:105
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:241
UDPContext::overrun_nonfatal
int overrun_nonfatal
Definition: udp.c:99
parseutils.h
ff_is_multicast_address
int ff_is_multicast_address(struct sockaddr *addr)
Definition: network.c:142
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
options
Definition: swscale.c:43
UDPContext::localaddr
char * localaddr
Definition: udp.c:120
time.h
ff_neterrno
#define ff_neterrno()
Definition: network.h:68
addrinfo::ai_addr
struct sockaddr * ai_addr
Definition: network.h:143
UDPContext::buffer_size
int buffer_size
Definition: udp.c:93
ff_ip_resolve_host
struct addrinfo * ff_ip_resolve_host(void *log_ctx, const char *hostname, int port, int type, int family, int flags)
Resolves hostname into an addrinfo structure.
Definition: ip.c:65
options
static const AVOption options[]
Definition: udp.c:134
addrinfo::ai_family
int ai_family
Definition: network.h:139
UDPContext::udp_fd
int udp_fd
Definition: udp.c:90
AVFifo
Definition: fifo.c:35
UDPContext::circular_buffer_error
int circular_buffer_error
Definition: udp.c:108
UDPContext
Definition: udp.c:88
size
int size
Definition: twinvq_data.h:10344
UDP_RX_BUF_SIZE
#define UDP_RX_BUF_SIZE
Definition: udp.c:78
URLProtocol::name
const char * name
Definition: url.h:52
UDPContext::burst_bits
int64_t burst_bits
Definition: udp.c:110
UDPContext::tx_fifo
AVFifo * tx_fifo
Definition: udp.c:107
ff_socket_nonblock
int ff_socket_nonblock(int socket, int enable)
header
static const uint8_t header[24]
Definition: sdr2.c:68
UDPContext::block
char * block
Definition: udp.c:125
ff_udp_get_last_recv_addr
void ff_udp_get_last_recv_addr(URLContext *h, struct sockaddr_storage *addr, socklen_t *addr_len)
Definition: udp.c:510
udplite_open
static int udplite_open(URLContext *h, const char *uri, int flags)
Definition: udp.c:960
gai_strerror
#define gai_strerror
Definition: network.h:225
UDPContext::local_port
int local_port
Definition: udp.c:97
pthread_t
Definition: os2threads.h:44
UDPContext::last_recv_addr
struct sockaddr_storage last_recv_addr
Definition: udp.c:127
UDPContext::ttl
int ttl
Definition: udp.c:91
pthread_cond_destroy
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:144
addrinfo::ai_next
struct addrinfo * ai_next
Definition: network.h:145
addrinfo::ai_addrlen
int ai_addrlen
Definition: network.h:142
pthread_mutex_destroy
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
udp_close
static int udp_close(URLContext *h)
Definition: udp.c:1087
UDP_MAX_PKT_SIZE
#define UDP_MAX_PKT_SIZE
Definition: udp.c:79
URLContext
Definition: url.h:35
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
getnameinfo
#define getnameinfo
Definition: network.h:219
ip.h
UDPContext::dest_addr
struct sockaddr_storage dest_addr
Definition: udp.c:100
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:361
udp_join_multicast_group
static int udp_join_multicast_group(int sockfd, struct sockaddr *addr, struct sockaddr *local_addr, void *logctx)
Definition: udp.c:212
url.h
len
int len
Definition: vorbis_enc_data.h:426
pthread_cond_t
Definition: os2threads.h:58
ff_parse_opts_from_query_string
int ff_parse_opts_from_query_string(void *obj, const char *str, int allow_unkown)
Set a list of query string options on an object.
Definition: utils.c:636
ff_udplite_protocol
const URLProtocol ff_udplite_protocol
Definition: udp.c:1145
pthread_setcancelstate
static int pthread_setcancelstate(int state, int *oldstate)
Definition: w32pthreads.h:208
udp_read
static int udp_read(URLContext *h, uint8_t *buf, int size)
Definition: udp.c:970
udp_set_multicast_sources
static int udp_set_multicast_sources(URLContext *h, int sockfd, struct sockaddr *addr, int addr_len, struct sockaddr_storage *local_addr, struct sockaddr_storage *sources, int nb_sources, int include)
Definition: udp.c:280
ret
ret
Definition: filter_design.txt:187
UDP_TX_BUF_SIZE
#define UDP_TX_BUF_SIZE
Definition: udp.c:77
D
#define D
Definition: udp.c:132
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:81
avformat.h
UDPContext::timeout
int timeout
Definition: udp.c:121
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
network.h
pthread_cond_signal
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
UDPQueuedPacketHeader::addr
struct sockaddr_storage addr
Definition: udp.c:84
UDPQueuedPacketHeader::pkt_size
int pkt_size
Definition: udp.c:83
IPSourceFilters
Structure for storing IP (UDP) source filters or block lists.
Definition: ip.h:29
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
IPV6_DROP_MEMBERSHIP
#define IPV6_DROP_MEMBERSHIP
Definition: udp.c:74
udp_write
static int udp_write(URLContext *h, const uint8_t *buf, int size)
Definition: udp.c:1037
ff_ip_check_source_lists
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:46
UDPQueuedPacketHeader::addr_len
socklen_t addr_len
Definition: udp.c:85
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
udp_open
static int udp_open(URLContext *h, const char *uri, int flags)
Definition: udp.c:692
pthread_cond_wait
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
UDPContext::rx_fifo
AVFifo * rx_fifo
Definition: udp.c:106
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:617
mem.h
udp_get_file_handle
static int udp_get_file_handle(URLContext *h)
Return the udp file handle for select() usage to wait for several RTP streams at the same time.
Definition: udp.c:522
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
AVIO_FLAG_NONBLOCK
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
Definition: avio.h:636
UDPContext::last_recv_addr_len
socklen_t last_recv_addr_len
Definition: udp.c:128
UDPContext::sources
char * sources
Definition: udp.c:124
pthread_cond_timedwait
static av_always_inline int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
Definition: os2threads.h:170
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
UDPContext::udplite_coverage
int udplite_coverage
Definition: udp.c:92
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
pthread_cond_init
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:133
h
h
Definition: vp9dsp_template.c:2070
ff_socket
int ff_socket(int af, int type, int proto, void *logctx)
Definition: network.c:180
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
addrinfo
Definition: network.h:137
IPV6_ADD_MEMBERSHIP
#define IPV6_ADD_MEMBERSHIP
Definition: udp.c:73
UDP_HEADER_SIZE
#define UDP_HEADER_SIZE
Definition: udp.c:80
cond
int(* cond)(enum AVPixelFormat pix_fmt)
Definition: pixdesc_query.c:28
udp_class
static const AVClass udp_class
Definition: udp.c:157
AI_PASSIVE
#define AI_PASSIVE
Definition: network.h:179
UDPLITE_SEND_CSCOV
#define UDPLITE_SEND_CSCOV
Definition: udp.c:55
ff_thread_setname
static int ff_thread_setname(const char *name)
Definition: thread.h:216
ff_network_wait_fd
int ff_network_wait_fd(int fd, int write)
Definition: network.c:66