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