FFmpeg
avio.c
Go to the documentation of this file.
1 /*
2  * unbuffered I/O
3  * Copyright (c) 2001 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avstring.h"
23 #include "libavutil/dict.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/time.h"
26 #include "libavutil/avassert.h"
27 #include "os_support.h"
28 #include "avformat.h"
29 #include "internal.h"
30 #if CONFIG_NETWORK
31 #include "network.h"
32 #endif
33 #include "url.h"
34 
35 /** @name Logging context. */
36 /*@{*/
37 static const char *urlcontext_to_name(void *ptr)
38 {
39  URLContext *h = (URLContext *)ptr;
40  if (h->prot)
41  return h->prot->name;
42  else
43  return "NULL";
44 }
45 
46 static void *urlcontext_child_next(void *obj, void *prev)
47 {
48  URLContext *h = obj;
49  if (!prev && h->priv_data && h->prot->priv_data_class)
50  return h->priv_data;
51  return NULL;
52 }
53 
54 #define OFFSET(x) offsetof(URLContext,x)
55 #define E AV_OPT_FLAG_ENCODING_PARAM
56 #define D AV_OPT_FLAG_DECODING_PARAM
57 static const AVOption options[] = {
58  {"protocol_whitelist", "List of protocols that are allowed to be used", OFFSET(protocol_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D },
59  {"protocol_blacklist", "List of protocols that are not allowed to be used", OFFSET(protocol_blacklist), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D },
60  {"rw_timeout", "Timeout for IO operations (in microseconds)", offsetof(URLContext, rw_timeout), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_DECODING_PARAM },
61  { NULL }
62 };
63 
65  .class_name = "URLContext",
66  .item_name = urlcontext_to_name,
67  .option = options,
68  .version = LIBAVUTIL_VERSION_INT,
69  .child_next = urlcontext_child_next,
70 #if FF_API_CHILD_CLASS_NEXT
71  .child_class_next = ff_urlcontext_child_class_next,
72 #endif
73  .child_class_iterate = ff_urlcontext_child_class_iterate,
74 };
75 /*@}*/
76 
77 static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up,
78  const char *filename, int flags,
79  const AVIOInterruptCB *int_cb)
80 {
81  URLContext *uc;
82  int err;
83 
84 #if CONFIG_NETWORK
86  return AVERROR(EIO);
87 #endif
88  if ((flags & AVIO_FLAG_READ) && !up->url_read) {
90  "Impossible to open the '%s' protocol for reading\n", up->name);
91  return AVERROR(EIO);
92  }
93  if ((flags & AVIO_FLAG_WRITE) && !up->url_write) {
95  "Impossible to open the '%s' protocol for writing\n", up->name);
96  return AVERROR(EIO);
97  }
98  uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);
99  if (!uc) {
100  err = AVERROR(ENOMEM);
101  goto fail;
102  }
104  uc->filename = (char *)&uc[1];
105  strcpy(uc->filename, filename);
106  uc->prot = up;
107  uc->flags = flags;
108  uc->is_streamed = 0; /* default = not streamed */
109  uc->max_packet_size = 0; /* default: stream file */
110  if (up->priv_data_size) {
112  if (!uc->priv_data) {
113  err = AVERROR(ENOMEM);
114  goto fail;
115  }
116  if (up->priv_data_class) {
117  char *start;
118  *(const AVClass **)uc->priv_data = up->priv_data_class;
120  if (av_strstart(uc->filename, up->name, (const char**)&start) && *start == ',') {
121  int ret= 0;
122  char *p= start;
123  char sep= *++p;
124  char *key, *val;
125  p++;
126 
127  if (strcmp(up->name, "subfile"))
128  ret = AVERROR(EINVAL);
129 
130  while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){
131  *val= *key= 0;
132  if (strcmp(p, "start") && strcmp(p, "end")) {
134  } else
135  ret= av_opt_set(uc->priv_data, p, key+1, 0);
136  if (ret == AVERROR_OPTION_NOT_FOUND)
137  av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);
138  *val= *key= sep;
139  p= val+1;
140  }
141  if(ret<0 || p!=key){
142  av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);
143  av_freep(&uc->priv_data);
144  av_freep(&uc);
145  err = AVERROR(EINVAL);
146  goto fail;
147  }
148  memmove(start, key+1, strlen(key));
149  }
150  }
151  }
152  if (int_cb)
153  uc->interrupt_callback = *int_cb;
154 
155  *puc = uc;
156  return 0;
157 fail:
158  *puc = NULL;
159  if (uc)
160  av_freep(&uc->priv_data);
161  av_freep(&uc);
162 #if CONFIG_NETWORK
165 #endif
166  return err;
167 }
168 
170 {
171  int err;
172  AVDictionary *tmp_opts = NULL;
174 
175  if (!options)
176  options = &tmp_opts;
177 
178  // Check that URLContext was initialized correctly and lists are matching if set
179  av_assert0(!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
180  (uc->protocol_whitelist && !strcmp(uc->protocol_whitelist, e->value)));
181  av_assert0(!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
182  (uc->protocol_blacklist && !strcmp(uc->protocol_blacklist, e->value)));
183 
184  if (uc->protocol_whitelist && av_match_list(uc->prot->name, uc->protocol_whitelist, ',') <= 0) {
185  av_log(uc, AV_LOG_ERROR, "Protocol '%s' not on whitelist '%s'!\n", uc->prot->name, uc->protocol_whitelist);
186  return AVERROR(EINVAL);
187  }
188 
189  if (uc->protocol_blacklist && av_match_list(uc->prot->name, uc->protocol_blacklist, ',') > 0) {
190  av_log(uc, AV_LOG_ERROR, "Protocol '%s' on blacklist '%s'!\n", uc->prot->name, uc->protocol_blacklist);
191  return AVERROR(EINVAL);
192  }
193 
194  if (!uc->protocol_whitelist && uc->prot->default_whitelist) {
195  av_log(uc, AV_LOG_DEBUG, "Setting default whitelist '%s'\n", uc->prot->default_whitelist);
197  if (!uc->protocol_whitelist) {
198  return AVERROR(ENOMEM);
199  }
200  } else if (!uc->protocol_whitelist)
201  av_log(uc, AV_LOG_DEBUG, "No default whitelist set\n"); // This should be an error once all declare a default whitelist
202 
203  if ((err = av_dict_set(options, "protocol_whitelist", uc->protocol_whitelist, 0)) < 0)
204  return err;
205  if ((err = av_dict_set(options, "protocol_blacklist", uc->protocol_blacklist, 0)) < 0)
206  return err;
207 
208  err =
209  uc->prot->url_open2 ? uc->prot->url_open2(uc,
210  uc->filename,
211  uc->flags,
212  options) :
213  uc->prot->url_open(uc, uc->filename, uc->flags);
214 
215  av_dict_set(options, "protocol_whitelist", NULL, 0);
216  av_dict_set(options, "protocol_blacklist", NULL, 0);
217 
218  if (err)
219  return err;
220  uc->is_connected = 1;
221  /* We must be careful here as ffurl_seek() could be slow,
222  * for example for http */
223  if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))
224  if (!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)
225  uc->is_streamed = 1;
226  return 0;
227 }
228 
230 {
231  av_assert0(!*c);
232  if (s->prot->url_accept)
233  return s->prot->url_accept(s, c);
234  return AVERROR(EBADF);
235 }
236 
238 {
239  int ret;
240  if (c->prot->url_handshake) {
241  ret = c->prot->url_handshake(c);
242  if (ret)
243  return ret;
244  }
245  c->is_connected = 1;
246  return 0;
247 }
248 
249 #define URL_SCHEME_CHARS \
250  "abcdefghijklmnopqrstuvwxyz" \
251  "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
252  "0123456789+-."
253 
254 static const struct URLProtocol *url_find_protocol(const char *filename)
255 {
256  const URLProtocol **protocols;
257  char proto_str[128], proto_nested[128], *ptr;
258  size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
259  int i;
260 
261  if (filename[proto_len] != ':' &&
262  (strncmp(filename, "subfile,", 8) || !strchr(filename + proto_len + 1, ':')) ||
263  is_dos_path(filename))
264  strcpy(proto_str, "file");
265  else
266  av_strlcpy(proto_str, filename,
267  FFMIN(proto_len + 1, sizeof(proto_str)));
268 
269  av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
270  if ((ptr = strchr(proto_nested, '+')))
271  *ptr = '\0';
272 
273  protocols = ffurl_get_protocols(NULL, NULL);
274  if (!protocols)
275  return NULL;
276  for (i = 0; protocols[i]; i++) {
277  const URLProtocol *up = protocols[i];
278  if (!strcmp(proto_str, up->name)) {
279  av_freep(&protocols);
280  return up;
281  }
283  !strcmp(proto_nested, up->name)) {
284  av_freep(&protocols);
285  return up;
286  }
287  }
288  av_freep(&protocols);
289  if (av_strstart(filename, "https:", NULL) || av_strstart(filename, "tls:", NULL))
290  av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with "
291  "openssl, gnutls or securetransport enabled.\n");
292 
293  return NULL;
294 }
295 
296 int ffurl_alloc(URLContext **puc, const char *filename, int flags,
297  const AVIOInterruptCB *int_cb)
298 {
299  const URLProtocol *p = NULL;
300 
301  p = url_find_protocol(filename);
302  if (p)
303  return url_alloc_for_protocol(puc, p, filename, flags, int_cb);
304 
305  *puc = NULL;
307 }
308 
309 int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags,
310  const AVIOInterruptCB *int_cb, AVDictionary **options,
311  const char *whitelist, const char* blacklist,
312  URLContext *parent)
313 {
314  AVDictionary *tmp_opts = NULL;
316  int ret = ffurl_alloc(puc, filename, flags, int_cb);
317  if (ret < 0)
318  return ret;
319  if (parent)
320  av_opt_copy(*puc, parent);
321  if (options &&
322  (ret = av_opt_set_dict(*puc, options)) < 0)
323  goto fail;
324  if (options && (*puc)->prot->priv_data_class &&
325  (ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
326  goto fail;
327 
328  if (!options)
329  options = &tmp_opts;
330 
331  av_assert0(!whitelist ||
332  !(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
333  !strcmp(whitelist, e->value));
334  av_assert0(!blacklist ||
335  !(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
336  !strcmp(blacklist, e->value));
337 
338  if ((ret = av_dict_set(options, "protocol_whitelist", whitelist, 0)) < 0)
339  goto fail;
340 
341  if ((ret = av_dict_set(options, "protocol_blacklist", blacklist, 0)) < 0)
342  goto fail;
343 
344  if ((ret = av_opt_set_dict(*puc, options)) < 0)
345  goto fail;
346 
347  ret = ffurl_connect(*puc, options);
348 
349  if (!ret)
350  return 0;
351 fail:
352  ffurl_closep(puc);
353  return ret;
354 }
355 
356 static inline int retry_transfer_wrapper(URLContext *h, uint8_t *buf,
357  int size, int size_min,
358  int (*transfer_func)(URLContext *h,
359  uint8_t *buf,
360  int size))
361 {
362  int ret, len;
363  int fast_retries = 5;
364  int64_t wait_since = 0;
365 
366  len = 0;
367  while (len < size_min) {
369  return AVERROR_EXIT;
370  ret = transfer_func(h, buf + len, size - len);
371  if (ret == AVERROR(EINTR))
372  continue;
373  if (h->flags & AVIO_FLAG_NONBLOCK)
374  return ret;
375  if (ret == AVERROR(EAGAIN)) {
376  ret = 0;
377  if (fast_retries) {
378  fast_retries--;
379  } else {
380  if (h->rw_timeout) {
381  if (!wait_since)
382  wait_since = av_gettime_relative();
383  else if (av_gettime_relative() > wait_since + h->rw_timeout)
384  return AVERROR(EIO);
385  }
386  av_usleep(1000);
387  }
388  } else if (ret == AVERROR_EOF)
389  return (len > 0) ? len : AVERROR_EOF;
390  else if (ret < 0)
391  return ret;
392  if (ret) {
393  fast_retries = FFMAX(fast_retries, 2);
394  wait_since = 0;
395  }
396  len += ret;
397  }
398  return len;
399 }
400 
401 int ffurl_read(URLContext *h, unsigned char *buf, int size)
402 {
403  if (!(h->flags & AVIO_FLAG_READ))
404  return AVERROR(EIO);
405  return retry_transfer_wrapper(h, buf, size, 1, h->prot->url_read);
406 }
407 
408 int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
409 {
410  if (!(h->flags & AVIO_FLAG_READ))
411  return AVERROR(EIO);
412  return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);
413 }
414 
415 int ffurl_write(URLContext *h, const unsigned char *buf, int size)
416 {
417  if (!(h->flags & AVIO_FLAG_WRITE))
418  return AVERROR(EIO);
419  /* avoid sending too big packets */
420  if (h->max_packet_size && size > h->max_packet_size)
421  return AVERROR(EIO);
422 
423  return retry_transfer_wrapper(h, (unsigned char *)buf, size, size,
424  (int (*)(struct URLContext *, uint8_t *, int))
425  h->prot->url_write);
426 }
427 
428 int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
429 {
430  int64_t ret;
431 
432  if (!h->prot->url_seek)
433  return AVERROR(ENOSYS);
434  ret = h->prot->url_seek(h, pos, whence & ~AVSEEK_FORCE);
435  return ret;
436 }
437 
439 {
440  URLContext *h= *hh;
441  int ret = 0;
442  if (!h)
443  return 0; /* can happen when ffurl_open fails */
444 
445  if (h->is_connected && h->prot->url_close)
446  ret = h->prot->url_close(h);
447 #if CONFIG_NETWORK
450 #endif
451  if (h->prot->priv_data_size) {
452  if (h->prot->priv_data_class)
454  av_freep(&h->priv_data);
455  }
456  av_opt_free(h);
457  av_freep(hh);
458  return ret;
459 }
460 
462 {
463  return ffurl_closep(&h);
464 }
465 
466 
467 const char *avio_find_protocol_name(const char *url)
468 {
469  const URLProtocol *p = url_find_protocol(url);
470 
471  return p ? p->name : NULL;
472 }
473 
474 int avio_check(const char *url, int flags)
475 {
476  URLContext *h;
477  int ret = ffurl_alloc(&h, url, flags, NULL);
478  if (ret < 0)
479  return ret;
480 
481  if (h->prot->url_check) {
482  ret = h->prot->url_check(h, flags);
483  } else {
484  ret = ffurl_connect(h, NULL);
485  if (ret >= 0)
486  ret = flags;
487  }
488 
489  ffurl_close(h);
490  return ret;
491 }
492 
493 int avpriv_io_move(const char *url_src, const char *url_dst)
494 {
495  URLContext *h_src, *h_dst;
496  int ret = ffurl_alloc(&h_src, url_src, AVIO_FLAG_READ_WRITE, NULL);
497  if (ret < 0)
498  return ret;
499  ret = ffurl_alloc(&h_dst, url_dst, AVIO_FLAG_WRITE, NULL);
500  if (ret < 0) {
501  ffurl_close(h_src);
502  return ret;
503  }
504 
505  if (h_src->prot == h_dst->prot && h_src->prot->url_move)
506  ret = h_src->prot->url_move(h_src, h_dst);
507  else
508  ret = AVERROR(ENOSYS);
509 
510  ffurl_close(h_src);
511  ffurl_close(h_dst);
512  return ret;
513 }
514 
515 int avpriv_io_delete(const char *url)
516 {
517  URLContext *h;
518  int ret = ffurl_alloc(&h, url, AVIO_FLAG_WRITE, NULL);
519  if (ret < 0)
520  return ret;
521 
522  if (h->prot->url_delete)
523  ret = h->prot->url_delete(h);
524  else
525  ret = AVERROR(ENOSYS);
526 
527  ffurl_close(h);
528  return ret;
529 }
530 
531 int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
532 {
533  URLContext *h = NULL;
535  int ret;
536  av_assert0(s);
537 
538  ctx = av_mallocz(sizeof(*ctx));
539  if (!ctx) {
540  ret = AVERROR(ENOMEM);
541  goto fail;
542  }
543 
544  if ((ret = ffurl_alloc(&h, url, AVIO_FLAG_READ, NULL)) < 0)
545  goto fail;
546 
547  if (h->prot->url_open_dir && h->prot->url_read_dir && h->prot->url_close_dir) {
548  if (options && h->prot->priv_data_class &&
549  (ret = av_opt_set_dict(h->priv_data, options)) < 0)
550  goto fail;
551  ret = h->prot->url_open_dir(h);
552  } else
553  ret = AVERROR(ENOSYS);
554  if (ret < 0)
555  goto fail;
556 
557  h->is_connected = 1;
558  ctx->url_context = h;
559  *s = ctx;
560  return 0;
561 
562  fail:
563  av_free(ctx);
564  *s = NULL;
565  ffurl_close(h);
566  return ret;
567 }
568 
570 {
571  URLContext *h;
572  int ret;
573 
574  if (!s || !s->url_context)
575  return AVERROR(EINVAL);
576  h = s->url_context;
577  if ((ret = h->prot->url_read_dir(h, next)) < 0)
579  return ret;
580 }
581 
583 {
584  URLContext *h;
585 
586  av_assert0(s);
587  if (!(*s) || !(*s)->url_context)
588  return AVERROR(EINVAL);
589  h = (*s)->url_context;
590  h->prot->url_close_dir(h);
591  ffurl_close(h);
592  av_freep(s);
593  *s = NULL;
594  return 0;
595 }
596 
598 {
599  if (!entry || !*entry)
600  return;
601  av_free((*entry)->name);
602  av_freep(entry);
603 }
604 
606 {
607  int64_t pos, size;
608 
609  size = ffurl_seek(h, 0, AVSEEK_SIZE);
610  if (size < 0) {
611  pos = ffurl_seek(h, 0, SEEK_CUR);
612  if ((size = ffurl_seek(h, -1, SEEK_END)) < 0)
613  return size;
614  size++;
615  ffurl_seek(h, pos, SEEK_SET);
616  }
617  return size;
618 }
619 
621 {
622  if (!h || !h->prot || !h->prot->url_get_file_handle)
623  return -1;
624  return h->prot->url_get_file_handle(h);
625 }
626 
627 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
628 {
629  if (!h || !h->prot)
630  return AVERROR(ENOSYS);
631  if (!h->prot->url_get_multi_file_handle) {
632  if (!h->prot->url_get_file_handle)
633  return AVERROR(ENOSYS);
634  *handles = av_malloc(sizeof(**handles));
635  if (!*handles)
636  return AVERROR(ENOMEM);
637  *numhandles = 1;
638  *handles[0] = h->prot->url_get_file_handle(h);
639  return 0;
640  }
641  return h->prot->url_get_multi_file_handle(h, handles, numhandles);
642 }
643 
645 {
646  if (!h || !h->prot || !h->prot->url_get_short_seek)
647  return AVERROR(ENOSYS);
648  return h->prot->url_get_short_seek(h);
649 }
650 
652 {
653  if (!h || !h->prot || !h->prot->url_shutdown)
654  return AVERROR(ENOSYS);
655  return h->prot->url_shutdown(h, flags);
656 }
657 
659 {
660  if (cb && cb->callback)
661  return cb->callback(cb->opaque);
662  return 0;
663 }
664 
665 int ff_rename(const char *url_src, const char *url_dst, void *logctx)
666 {
667  int ret = avpriv_io_move(url_src, url_dst);
668  if (ret < 0)
669  av_log(logctx, AV_LOG_ERROR, "failed to rename file %s to %s: %s\n", url_src, url_dst, av_err2str(ret));
670  return ret;
671 }
#define NULL
Definition: coverity.c:32
int(* url_write)(URLContext *h, const unsigned char *buf, int size)
Definition: url.h:79
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it. ...
Definition: avio.c:309
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:34
AVOption.
Definition: opt.h:248
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int flags
Definition: url.h:92
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: avio.c:415
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:45
int ffurl_connect(URLContext *uc, AVDictionary **options)
Connect an URLContext that has been allocated by ffurl_alloc.
Definition: avio.c:169
AVIOInterruptCB interrupt_callback
Definition: url.h:47
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
int(* url_read)(URLContext *h, unsigned char *buf, int size)
Read data from the protocol.
Definition: url.h:78
Describes single entry of the directory.
Definition: avio.h:86
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
int64_t rw_timeout
maximum time to wait for (network) read/write operation completion, in mcs
Definition: url.h:48
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
void ff_network_close(void)
Definition: network.c:116
int(* url_get_file_handle)(URLContext *h)
Definition: url.h:85
int flags
Definition: url.h:43
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
static void * urlcontext_child_next(void *obj, void *prev)
Definition: avio.c:46
int(* url_get_short_seek)(URLContext *h)
Definition: url.h:88
static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up, const char *filename, int flags, const AVIOInterruptCB *int_cb)
Definition: avio.c:77
int(* url_open2)(URLContext *h, const char *url, int flags, AVDictionary **options)
This callback is to be used by protocols which open further nested protocols.
Definition: url.h:62
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
Definition: avio.c:651
#define URL_SCHEME_CHARS
Definition: avio.c:249
int avpriv_io_move(const char *url_src, const char *url_dst)
Move or rename a resource.
Definition: avio.c:493
void * opaque
Definition: avio.h:60
const AVClass * priv_data_class
Definition: url.h:90
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
Definition: avio.c:474
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
uint8_t
#define av_malloc(s)
int ff_network_init(void)
Definition: network.c:58
AVOptions.
miscellaneous OS support macros and functions.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int(* url_shutdown)(URLContext *h, int flags)
Definition: url.h:89
int avio_read_dir(AVIODirContext *s, AVIODirEntry **next)
Get next directory entry.
Definition: avio.c:569
#define OFFSET(x)
Definition: avio.c:54
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
#define AVERROR_EOF
End of file.
Definition: error.h:55
ptrdiff_t size
Definition: opengl_enc.c:100
int(* url_read_dir)(URLContext *h, AVIODirEntry **next)
Definition: url.h:95
int(* url_close)(URLContext *h)
Definition: url.h:81
#define av_log(a,...)
int(* callback)(void *)
Definition: avio.h:59
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
Callback for checking whether to abort blocking functions.
Definition: avio.h:58
int ffurl_alloc(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb)
Create a URLContext for accessing to the resource indicated by url, but do not initiate the connectio...
Definition: avio.c:296
int(* url_get_multi_file_handle)(URLContext *h, int **handles, int *numhandles)
Definition: url.h:86
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Return the file descriptors associated with this URL.
Definition: avio.c:627
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:513
const char * protocol_whitelist
Definition: url.h:49
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:451
unsigned int pos
Definition: spdifenc.c:412
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define URL_PROTOCOL_FLAG_NESTED_SCHEME
Definition: url.h:33
simple assert() macros that are a bit more flexible than ISO C assert().
#define FFMAX(a, b)
Definition: common.h:103
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:133
static const char * urlcontext_to_name(void *ptr)
Definition: avio.c:37
void avio_free_directory_entry(AVIODirEntry **entry)
Free entry allocated by avio_read_dir().
Definition: avio.c:597
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap avpriv_io_move and log if error happens.
Definition: avio.c:665
static const AVOption options[]
Definition: avio.c:57
static int retry_transfer_wrapper(URLContext *h, uint8_t *buf, int size, int size_min, int(*transfer_func)(URLContext *h, uint8_t *buf, int size))
Definition: avio.c:356
int(* url_accept)(URLContext *s, URLContext **c)
Definition: url.h:63
int ffurl_get_short_seek(URLContext *h)
Return the current short seek threshold value for this URL.
Definition: avio.c:644
#define FFMIN(a, b)
Definition: common.h:105
int(* url_move)(URLContext *h_src, URLContext *h_dst)
Definition: url.h:98
const AVClass * ff_urlcontext_child_class_iterate(void **iter)
Definition: protocols.c:97
int(* url_check)(URLContext *h, int mask)
Definition: url.h:93
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
int ffurl_handshake(URLContext *c)
Perform one step of the protocol handshake to accept a new client.
Definition: avio.c:237
#define s(width, name)
Definition: cbs_vp9.c:257
int64_t(* url_seek)(URLContext *h, int64_t pos, int whence)
Definition: url.h:80
int ffurl_get_file_handle(URLContext *h)
Return the file descriptor associated with this URL.
Definition: avio.c:620
int ffurl_accept(URLContext *s, URLContext **c)
Accept an URLContext c on an URLContext s.
Definition: avio.c:229
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
int is_connected
Definition: url.h:46
int ffurl_closep(URLContext **hh)
Close the resource accessed by the URLContext h, and free the memory used by it.
Definition: avio.c:438
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
static int is_dos_path(const char *path)
Definition: os_support.h:70
const char * protocol_blacklist
Definition: url.h:50
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrupt a blocking function associated with cb.
Definition: avio.c:658
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1656
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
Definition: avio.h:693
const char * default_whitelist
Definition: url.h:99
int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
Open directory for reading.
Definition: avio.c:531
int64_t ffurl_size(URLContext *h)
Return the filesize of the resource accessed by h, AVERROR(ENOSYS) if the operation is not supported ...
Definition: avio.c:605
Definition: url.h:38
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
Definition: avio.h:676
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AVSEEK_FORCE
Passing this flag as the "whence" parameter to a seek function causes it to seek by any means (like r...
Definition: avio.h:539
void * priv_data
Definition: url.h:41
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:279
const char * name
Definition: url.h:55
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:467
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
#define flags(name, subs,...)
Definition: cbs_av1.c:561
const AVClass * av_class
information for av_log().
Definition: url.h:39
int ffurl_close(URLContext *h)
Definition: avio.c:461
const AVClass ffurl_context_class
Definition: avio.c:64
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:34
Main libavformat public API header.
int(* url_open)(URLContext *h, const char *url, int flags)
Definition: url.h:56
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
Change the position that will be used by the next read/write operation on the resource accessed by h...
Definition: avio.c:428
const struct URLProtocol * prot
Definition: url.h:40
int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
Read as many bytes as possible (up to size), calling the read function multiple times if necessary...
Definition: avio.c:408
char * filename
specified URL
Definition: url.h:42
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1789
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:531
int avio_close_dir(AVIODirContext **s)
Close directory.
Definition: avio.c:582
#define av_free(p)
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
char * value
Definition: dict.h:87
int len
int(* url_open_dir)(URLContext *h)
Definition: url.h:94
int avpriv_io_delete(const char *url)
Delete a resource.
Definition: avio.c:515
int max_packet_size
if non zero, the stream is packetized with this max packet size
Definition: url.h:44
#define av_freep(p)
unbuffered private I/O API
#define D
Definition: avio.c:56
static const struct URLProtocol * url_find_protocol(const char *filename)
Definition: avio.c:254
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
struct URLContext * url_context
Definition: avio.h:104
int priv_data_size
Definition: url.h:91
const URLProtocol ** ffurl_get_protocols(const char *whitelist, const char *blacklist)
Construct a list of protocols matching a given whitelist and/or blacklist.
Definition: protocols.c:137
static double val(void *priv, double ch)
Definition: aeval.c:76
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf...
Definition: avio.c:401
int(* url_close_dir)(URLContext *h)
Definition: url.h:96
int(* url_delete)(URLContext *h)
Definition: url.h:97
int i
Definition: input.c:407
int(* url_handshake)(URLContext *c)
Definition: url.h:64