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 }, CHAR_MIN, CHAR_MAX, D },
59  {"protocol_blacklist", "List of protocols that are not allowed to be used", OFFSET(protocol_blacklist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, 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  .child_class_next = ff_urlcontext_child_class_next,
71 };
72 /*@}*/
73 
74 static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up,
75  const char *filename, int flags,
76  const AVIOInterruptCB *int_cb)
77 {
78  URLContext *uc;
79  int err;
80 
81 #if CONFIG_NETWORK
83  return AVERROR(EIO);
84 #endif
85  if ((flags & AVIO_FLAG_READ) && !up->url_read) {
87  "Impossible to open the '%s' protocol for reading\n", up->name);
88  return AVERROR(EIO);
89  }
90  if ((flags & AVIO_FLAG_WRITE) && !up->url_write) {
92  "Impossible to open the '%s' protocol for writing\n", up->name);
93  return AVERROR(EIO);
94  }
95  uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);
96  if (!uc) {
97  err = AVERROR(ENOMEM);
98  goto fail;
99  }
101  uc->filename = (char *)&uc[1];
102  strcpy(uc->filename, filename);
103  uc->prot = up;
104  uc->flags = flags;
105  uc->is_streamed = 0; /* default = not streamed */
106  uc->max_packet_size = 0; /* default: stream file */
107  if (up->priv_data_size) {
109  if (!uc->priv_data) {
110  err = AVERROR(ENOMEM);
111  goto fail;
112  }
113  if (up->priv_data_class) {
114  int proto_len= strlen(up->name);
115  char *start = strchr(uc->filename, ',');
116  *(const AVClass **)uc->priv_data = up->priv_data_class;
118  if(!strncmp(up->name, uc->filename, proto_len) && uc->filename + proto_len == start){
119  int ret= 0;
120  char *p= start;
121  char sep= *++p;
122  char *key, *val;
123  p++;
124 
125  if (strcmp(up->name, "subfile"))
126  ret = AVERROR(EINVAL);
127 
128  while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){
129  *val= *key= 0;
130  if (strcmp(p, "start") && strcmp(p, "end")) {
132  } else
133  ret= av_opt_set(uc->priv_data, p, key+1, 0);
134  if (ret == AVERROR_OPTION_NOT_FOUND)
135  av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);
136  *val= *key= sep;
137  p= val+1;
138  }
139  if(ret<0 || p!=key){
140  av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);
141  av_freep(&uc->priv_data);
142  av_freep(&uc);
143  err = AVERROR(EINVAL);
144  goto fail;
145  }
146  memmove(start, key+1, strlen(key));
147  }
148  }
149  }
150  if (int_cb)
151  uc->interrupt_callback = *int_cb;
152 
153  *puc = uc;
154  return 0;
155 fail:
156  *puc = NULL;
157  if (uc)
158  av_freep(&uc->priv_data);
159  av_freep(&uc);
160 #if CONFIG_NETWORK
163 #endif
164  return err;
165 }
166 
168 {
169  int err;
170  AVDictionary *tmp_opts = NULL;
172 
173  if (!options)
174  options = &tmp_opts;
175 
176  // Check that URLContext was initialized correctly and lists are matching if set
177  av_assert0(!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
178  (uc->protocol_whitelist && !strcmp(uc->protocol_whitelist, e->value)));
179  av_assert0(!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
180  (uc->protocol_blacklist && !strcmp(uc->protocol_blacklist, e->value)));
181 
182  if (uc->protocol_whitelist && av_match_list(uc->prot->name, uc->protocol_whitelist, ',') <= 0) {
183  av_log(uc, AV_LOG_ERROR, "Protocol '%s' not on whitelist '%s'!\n", uc->prot->name, uc->protocol_whitelist);
184  return AVERROR(EINVAL);
185  }
186 
187  if (uc->protocol_blacklist && av_match_list(uc->prot->name, uc->protocol_blacklist, ',') > 0) {
188  av_log(uc, AV_LOG_ERROR, "Protocol '%s' on blacklist '%s'!\n", uc->prot->name, uc->protocol_blacklist);
189  return AVERROR(EINVAL);
190  }
191 
192  if (!uc->protocol_whitelist && uc->prot->default_whitelist) {
193  av_log(uc, AV_LOG_DEBUG, "Setting default whitelist '%s'\n", uc->prot->default_whitelist);
195  if (!uc->protocol_whitelist) {
196  return AVERROR(ENOMEM);
197  }
198  } else if (!uc->protocol_whitelist)
199  av_log(uc, AV_LOG_DEBUG, "No default whitelist set\n"); // This should be an error once all declare a default whitelist
200 
201  if ((err = av_dict_set(options, "protocol_whitelist", uc->protocol_whitelist, 0)) < 0)
202  return err;
203  if ((err = av_dict_set(options, "protocol_blacklist", uc->protocol_blacklist, 0)) < 0)
204  return err;
205 
206  err =
207  uc->prot->url_open2 ? uc->prot->url_open2(uc,
208  uc->filename,
209  uc->flags,
210  options) :
211  uc->prot->url_open(uc, uc->filename, uc->flags);
212 
213  av_dict_set(options, "protocol_whitelist", NULL, 0);
214  av_dict_set(options, "protocol_blacklist", NULL, 0);
215 
216  if (err)
217  return err;
218  uc->is_connected = 1;
219  /* We must be careful here as ffurl_seek() could be slow,
220  * for example for http */
221  if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))
222  if (!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)
223  uc->is_streamed = 1;
224  return 0;
225 }
226 
228 {
229  av_assert0(!*c);
230  if (s->prot->url_accept)
231  return s->prot->url_accept(s, c);
232  return AVERROR(EBADF);
233 }
234 
236 {
237  int ret;
238  if (c->prot->url_handshake) {
239  ret = c->prot->url_handshake(c);
240  if (ret)
241  return ret;
242  }
243  c->is_connected = 1;
244  return 0;
245 }
246 
247 #define URL_SCHEME_CHARS \
248  "abcdefghijklmnopqrstuvwxyz" \
249  "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
250  "0123456789+-."
251 
252 static const struct URLProtocol *url_find_protocol(const char *filename)
253 {
254  const URLProtocol **protocols;
255  char proto_str[128], proto_nested[128], *ptr;
256  size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
257  int i;
258 
259  if (filename[proto_len] != ':' &&
260  (strncmp(filename, "subfile,", 8) || !strchr(filename + proto_len + 1, ':')) ||
261  is_dos_path(filename))
262  strcpy(proto_str, "file");
263  else
264  av_strlcpy(proto_str, filename,
265  FFMIN(proto_len + 1, sizeof(proto_str)));
266 
267  av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
268  if ((ptr = strchr(proto_nested, '+')))
269  *ptr = '\0';
270 
271  protocols = ffurl_get_protocols(NULL, NULL);
272  if (!protocols)
273  return NULL;
274  for (i = 0; protocols[i]; i++) {
275  const URLProtocol *up = protocols[i];
276  if (!strcmp(proto_str, up->name)) {
277  av_freep(&protocols);
278  return up;
279  }
281  !strcmp(proto_nested, up->name)) {
282  av_freep(&protocols);
283  return up;
284  }
285  }
286  av_freep(&protocols);
287  if (av_strstart(filename, "https:", NULL) || av_strstart(filename, "tls:", NULL))
288  av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with "
289  "openssl, gnutls or securetransport enabled.\n");
290 
291  return NULL;
292 }
293 
294 int ffurl_alloc(URLContext **puc, const char *filename, int flags,
295  const AVIOInterruptCB *int_cb)
296 {
297  const URLProtocol *p = NULL;
298 
299  p = url_find_protocol(filename);
300  if (p)
301  return url_alloc_for_protocol(puc, p, filename, flags, int_cb);
302 
303  *puc = NULL;
305 }
306 
307 int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags,
308  const AVIOInterruptCB *int_cb, AVDictionary **options,
309  const char *whitelist, const char* blacklist,
310  URLContext *parent)
311 {
312  AVDictionary *tmp_opts = NULL;
314  int ret = ffurl_alloc(puc, filename, flags, int_cb);
315  if (ret < 0)
316  return ret;
317  if (parent)
318  av_opt_copy(*puc, parent);
319  if (options &&
320  (ret = av_opt_set_dict(*puc, options)) < 0)
321  goto fail;
322  if (options && (*puc)->prot->priv_data_class &&
323  (ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
324  goto fail;
325 
326  if (!options)
327  options = &tmp_opts;
328 
329  av_assert0(!whitelist ||
330  !(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
331  !strcmp(whitelist, e->value));
332  av_assert0(!blacklist ||
333  !(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
334  !strcmp(blacklist, e->value));
335 
336  if ((ret = av_dict_set(options, "protocol_whitelist", whitelist, 0)) < 0)
337  goto fail;
338 
339  if ((ret = av_dict_set(options, "protocol_blacklist", blacklist, 0)) < 0)
340  goto fail;
341 
342  if ((ret = av_opt_set_dict(*puc, options)) < 0)
343  goto fail;
344 
345  ret = ffurl_connect(*puc, options);
346 
347  if (!ret)
348  return 0;
349 fail:
350  ffurl_closep(puc);
351  return ret;
352 }
353 
354 int ffurl_open(URLContext **puc, const char *filename, int flags,
355  const AVIOInterruptCB *int_cb, AVDictionary **options)
356 {
357  return ffurl_open_whitelist(puc, filename, flags,
358  int_cb, options, NULL, NULL, NULL);
359 }
360 
362  int size, int size_min,
363  int (*transfer_func)(URLContext *h,
364  uint8_t *buf,
365  int size))
366 {
367  int ret, len;
368  int fast_retries = 5;
369  int64_t wait_since = 0;
370 
371  len = 0;
372  while (len < size_min) {
374  return AVERROR_EXIT;
375  ret = transfer_func(h, buf + len, size - len);
376  if (ret == AVERROR(EINTR))
377  continue;
378  if (h->flags & AVIO_FLAG_NONBLOCK)
379  return ret;
380  if (ret == AVERROR(EAGAIN)) {
381  ret = 0;
382  if (fast_retries) {
383  fast_retries--;
384  } else {
385  if (h->rw_timeout) {
386  if (!wait_since)
387  wait_since = av_gettime_relative();
388  else if (av_gettime_relative() > wait_since + h->rw_timeout)
389  return AVERROR(EIO);
390  }
391  av_usleep(1000);
392  }
393  } else if (ret == AVERROR_EOF)
394  return (len > 0) ? len : AVERROR_EOF;
395  else if (ret < 0)
396  return ret;
397  if (ret) {
398  fast_retries = FFMAX(fast_retries, 2);
399  wait_since = 0;
400  }
401  len += ret;
402  }
403  return len;
404 }
405 
406 int ffurl_read(URLContext *h, unsigned char *buf, int size)
407 {
408  if (!(h->flags & AVIO_FLAG_READ))
409  return AVERROR(EIO);
410  return retry_transfer_wrapper(h, buf, size, 1, h->prot->url_read);
411 }
412 
413 int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
414 {
415  if (!(h->flags & AVIO_FLAG_READ))
416  return AVERROR(EIO);
417  return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);
418 }
419 
420 int ffurl_write(URLContext *h, const unsigned char *buf, int size)
421 {
422  if (!(h->flags & AVIO_FLAG_WRITE))
423  return AVERROR(EIO);
424  /* avoid sending too big packets */
425  if (h->max_packet_size && size > h->max_packet_size)
426  return AVERROR(EIO);
427 
428  return retry_transfer_wrapper(h, (unsigned char *)buf, size, size,
429  (int (*)(struct URLContext *, uint8_t *, int))
430  h->prot->url_write);
431 }
432 
433 int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
434 {
435  int64_t ret;
436 
437  if (!h->prot->url_seek)
438  return AVERROR(ENOSYS);
439  ret = h->prot->url_seek(h, pos, whence & ~AVSEEK_FORCE);
440  return ret;
441 }
442 
444 {
445  URLContext *h= *hh;
446  int ret = 0;
447  if (!h)
448  return 0; /* can happen when ffurl_open fails */
449 
450  if (h->is_connected && h->prot->url_close)
451  ret = h->prot->url_close(h);
452 #if CONFIG_NETWORK
455 #endif
456  if (h->prot->priv_data_size) {
457  if (h->prot->priv_data_class)
459  av_freep(&h->priv_data);
460  }
461  av_opt_free(h);
462  av_freep(hh);
463  return ret;
464 }
465 
467 {
468  return ffurl_closep(&h);
469 }
470 
471 
472 const char *avio_find_protocol_name(const char *url)
473 {
474  const URLProtocol *p = url_find_protocol(url);
475 
476  return p ? p->name : NULL;
477 }
478 
479 int avio_check(const char *url, int flags)
480 {
481  URLContext *h;
482  int ret = ffurl_alloc(&h, url, flags, NULL);
483  if (ret < 0)
484  return ret;
485 
486  if (h->prot->url_check) {
487  ret = h->prot->url_check(h, flags);
488  } else {
489  ret = ffurl_connect(h, NULL);
490  if (ret >= 0)
491  ret = flags;
492  }
493 
494  ffurl_close(h);
495  return ret;
496 }
497 
498 int avpriv_io_move(const char *url_src, const char *url_dst)
499 {
500  URLContext *h_src, *h_dst;
501  int ret = ffurl_alloc(&h_src, url_src, AVIO_FLAG_READ_WRITE, NULL);
502  if (ret < 0)
503  return ret;
504  ret = ffurl_alloc(&h_dst, url_dst, AVIO_FLAG_WRITE, NULL);
505  if (ret < 0) {
506  ffurl_close(h_src);
507  return ret;
508  }
509 
510  if (h_src->prot == h_dst->prot && h_src->prot->url_move)
511  ret = h_src->prot->url_move(h_src, h_dst);
512  else
513  ret = AVERROR(ENOSYS);
514 
515  ffurl_close(h_src);
516  ffurl_close(h_dst);
517  return ret;
518 }
519 
520 int avpriv_io_delete(const char *url)
521 {
522  URLContext *h;
523  int ret = ffurl_alloc(&h, url, AVIO_FLAG_WRITE, NULL);
524  if (ret < 0)
525  return ret;
526 
527  if (h->prot->url_delete)
528  ret = h->prot->url_delete(h);
529  else
530  ret = AVERROR(ENOSYS);
531 
532  ffurl_close(h);
533  return ret;
534 }
535 
536 int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
537 {
538  URLContext *h = NULL;
540  int ret;
541  av_assert0(s);
542 
543  ctx = av_mallocz(sizeof(*ctx));
544  if (!ctx) {
545  ret = AVERROR(ENOMEM);
546  goto fail;
547  }
548 
549  if ((ret = ffurl_alloc(&h, url, AVIO_FLAG_READ, NULL)) < 0)
550  goto fail;
551 
552  if (h->prot->url_open_dir && h->prot->url_read_dir && h->prot->url_close_dir) {
553  if (options && h->prot->priv_data_class &&
554  (ret = av_opt_set_dict(h->priv_data, options)) < 0)
555  goto fail;
556  ret = h->prot->url_open_dir(h);
557  } else
558  ret = AVERROR(ENOSYS);
559  if (ret < 0)
560  goto fail;
561 
562  h->is_connected = 1;
563  ctx->url_context = h;
564  *s = ctx;
565  return 0;
566 
567  fail:
568  av_free(ctx);
569  *s = NULL;
570  ffurl_close(h);
571  return ret;
572 }
573 
575 {
576  URLContext *h;
577  int ret;
578 
579  if (!s || !s->url_context)
580  return AVERROR(EINVAL);
581  h = s->url_context;
582  if ((ret = h->prot->url_read_dir(h, next)) < 0)
584  return ret;
585 }
586 
588 {
589  URLContext *h;
590 
591  av_assert0(s);
592  if (!(*s) || !(*s)->url_context)
593  return AVERROR(EINVAL);
594  h = (*s)->url_context;
595  h->prot->url_close_dir(h);
596  ffurl_close(h);
597  av_freep(s);
598  *s = NULL;
599  return 0;
600 }
601 
603 {
604  if (!entry || !*entry)
605  return;
606  av_free((*entry)->name);
607  av_freep(entry);
608 }
609 
611 {
612  int64_t pos, size;
613 
614  size = ffurl_seek(h, 0, AVSEEK_SIZE);
615  if (size < 0) {
616  pos = ffurl_seek(h, 0, SEEK_CUR);
617  if ((size = ffurl_seek(h, -1, SEEK_END)) < 0)
618  return size;
619  size++;
620  ffurl_seek(h, pos, SEEK_SET);
621  }
622  return size;
623 }
624 
626 {
627  if (!h || !h->prot || !h->prot->url_get_file_handle)
628  return -1;
629  return h->prot->url_get_file_handle(h);
630 }
631 
632 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
633 {
634  if (!h || !h->prot)
635  return AVERROR(ENOSYS);
636  if (!h->prot->url_get_multi_file_handle) {
637  if (!h->prot->url_get_file_handle)
638  return AVERROR(ENOSYS);
639  *handles = av_malloc(sizeof(**handles));
640  if (!*handles)
641  return AVERROR(ENOMEM);
642  *numhandles = 1;
643  *handles[0] = h->prot->url_get_file_handle(h);
644  return 0;
645  }
646  return h->prot->url_get_multi_file_handle(h, handles, numhandles);
647 }
648 
650 {
651  if (!h || !h->prot || !h->prot->url_get_short_seek)
652  return AVERROR(ENOSYS);
653  return h->prot->url_get_short_seek(h);
654 }
655 
657 {
658  if (!h || !h->prot || !h->prot->url_shutdown)
659  return AVERROR(ENOSYS);
660  return h->prot->url_shutdown(h, flags);
661 }
662 
664 {
665  if (cb && cb->callback)
666  return cb->callback(cb->opaque);
667  return 0;
668 }
669 
670 int ff_rename(const char *url_src, const char *url_dst, void *logctx)
671 {
672  int ret = avpriv_io_move(url_src, url_dst);
673  if (ret < 0)
674  av_log(logctx, AV_LOG_ERROR, "failed to rename file %s to %s: %s\n", url_src, url_dst, av_err2str(ret));
675  return ret;
676 }
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
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:307
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:34
AVOption.
Definition: opt.h:246
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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:420
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:167
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:1359
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:236
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:74
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:656
#define URL_SCHEME_CHARS
Definition: avio.c:247
int avpriv_io_move(const char *url_src, const char *url_dst)
Move or rename a resource.
Definition: avio.c:498
void * opaque
Definition: avio.h:60
const AVClass * priv_data_class
Definition: url.h:91
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:479
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:214
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:574
#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
const AVClass * ff_urlcontext_child_class_next(const AVClass *prev)
Definition: protocols.c:75
#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:276
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:294
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:176
int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
Return the file descriptors associated with this URL.
Definition: avio.c:632
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:481
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:449
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#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:94
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:122
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:602
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:670
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:361
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:649
#define FFMIN(a, b)
Definition: common.h:96
int(* url_move)(URLContext *h_src, URLContext *h_dst)
Definition: url.h:98
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:235
#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:625
int ffurl_accept(URLContext *s, URLContext **c)
Accept an URLContext c on an URLContext s.
Definition: avio.c:227
#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:443
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
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:663
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1657
#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:536
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:610
void * buf
Definition: avisynth_c.h:766
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:277
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:472
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:564
const AVClass * av_class
information for av_log().
Definition: url.h:39
int ffurl_close(URLContext *h)
Definition: avio.c:466
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:1612
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:433
const struct URLProtocol * prot
Definition: url.h:40
int ffurl_open(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: avio.c:354
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:413
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:1770
#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:587
#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:520
int max_packet_size
if non zero, the stream is packetized with this max packet size
Definition: url.h:44
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
unbuffered private I/O API
#define D
Definition: avio.c:56
static const struct URLProtocol * url_find_protocol(const char *filename)
Definition: avio.c:252
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:90
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:110
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:467
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:406
int(* url_close_dir)(URLContext *h)
Definition: url.h:96
int(* url_delete)(URLContext *h)
Definition: url.h:97
int(* url_handshake)(URLContext *c)
Definition: url.h:64