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