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 
64 const AVClass ffurl_context_class = {
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_iterate = ff_urlcontext_child_class_iterate,
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
82  if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init())
83  return AVERROR(EIO);
84 #endif
85  if ((flags & AVIO_FLAG_READ) && !up->url_read) {
86  av_log(NULL, AV_LOG_ERROR,
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) {
91  av_log(NULL, AV_LOG_ERROR,
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  }
100  uc->av_class = &ffurl_context_class;
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) {
108  uc->priv_data = av_mallocz(up->priv_data_size);
109  if (!uc->priv_data) {
110  err = AVERROR(ENOMEM);
111  goto fail;
112  }
113  if (up->priv_data_class) {
114  char *start;
115  *(const AVClass **)uc->priv_data = up->priv_data_class;
116  av_opt_set_defaults(uc->priv_data);
117  if (av_strstart(uc->filename, up->name, (const char**)&start) && *start == ',') {
118  int ret= 0;
119  char *p= start;
120  char sep= *++p;
121  char *key, *val;
122  p++;
123 
124  if (strcmp(up->name, "subfile"))
125  ret = AVERROR(EINVAL);
126 
127  while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){
128  *val= *key= 0;
129  if (strcmp(p, "start") && strcmp(p, "end")) {
130  ret = AVERROR_OPTION_NOT_FOUND;
131  } else
132  ret= av_opt_set(uc->priv_data, p, key+1, 0);
133  if (ret == AVERROR_OPTION_NOT_FOUND)
134  av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);
135  *val= *key= sep;
136  p= val+1;
137  }
138  if(ret<0 || p!=key){
139  av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);
140  av_freep(&uc->priv_data);
141  av_freep(&uc);
142  err = AVERROR(EINVAL);
143  goto fail;
144  }
145  memmove(start, key+1, strlen(key));
146  }
147  }
148  }
149  if (int_cb)
150  uc->interrupt_callback = *int_cb;
151 
152  *puc = uc;
153  return 0;
154 fail:
155  *puc = NULL;
156  if (uc)
157  av_freep(&uc->priv_data);
158  av_freep(&uc);
159 #if CONFIG_NETWORK
160  if (up->flags & URL_PROTOCOL_FLAG_NETWORK)
161  ff_network_close();
162 #endif
163  return err;
164 }
165 
166 int ffurl_connect(URLContext *uc, AVDictionary **options)
167 {
168  int err;
169  AVDictionary *tmp_opts = NULL;
170  AVDictionaryEntry *e;
171 
172  if (!options)
173  options = &tmp_opts;
174 
175  // Check that URLContext was initialized correctly and lists are matching if set
176  av_assert0(!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
177  (uc->protocol_whitelist && !strcmp(uc->protocol_whitelist, e->value)));
178  av_assert0(!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
179  (uc->protocol_blacklist && !strcmp(uc->protocol_blacklist, e->value)));
180 
181  if (uc->protocol_whitelist && av_match_list(uc->prot->name, uc->protocol_whitelist, ',') <= 0) {
182  av_log(uc, AV_LOG_ERROR, "Protocol '%s' not on whitelist '%s'!\n", uc->prot->name, uc->protocol_whitelist);
183  return AVERROR(EINVAL);
184  }
185 
186  if (uc->protocol_blacklist && av_match_list(uc->prot->name, uc->protocol_blacklist, ',') > 0) {
187  av_log(uc, AV_LOG_ERROR, "Protocol '%s' on blacklist '%s'!\n", uc->prot->name, uc->protocol_blacklist);
188  return AVERROR(EINVAL);
189  }
190 
191  if (!uc->protocol_whitelist && uc->prot->default_whitelist) {
192  av_log(uc, AV_LOG_DEBUG, "Setting default whitelist '%s'\n", uc->prot->default_whitelist);
193  uc->protocol_whitelist = av_strdup(uc->prot->default_whitelist);
194  if (!uc->protocol_whitelist) {
195  return AVERROR(ENOMEM);
196  }
197  } else if (!uc->protocol_whitelist)
198  av_log(uc, AV_LOG_DEBUG, "No default whitelist set\n"); // This should be an error once all declare a default whitelist
199 
200  if ((err = av_dict_set(options, "protocol_whitelist", uc->protocol_whitelist, 0)) < 0)
201  return err;
202  if ((err = av_dict_set(options, "protocol_blacklist", uc->protocol_blacklist, 0)) < 0)
203  return err;
204 
205  err =
206  uc->prot->url_open2 ? uc->prot->url_open2(uc,
207  uc->filename,
208  uc->flags,
209  options) :
210  uc->prot->url_open(uc, uc->filename, uc->flags);
211 
212  av_dict_set(options, "protocol_whitelist", NULL, 0);
213  av_dict_set(options, "protocol_blacklist", NULL, 0);
214 
215  if (err)
216  return err;
217  uc->is_connected = 1;
218  /* We must be careful here as ffurl_seek() could be slow,
219  * for example for http */
220  if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))
221  if (!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)
222  uc->is_streamed = 1;
223  return 0;
224 }
225 
226 int ffurl_accept(URLContext *s, URLContext **c)
227 {
228  av_assert0(!*c);
229  if (s->prot->url_accept)
230  return s->prot->url_accept(s, c);
231  return AVERROR(EBADF);
232 }
233 
234 int ffurl_handshake(URLContext *c)
235 {
236  int ret;
237  if (c->prot->url_handshake) {
238  ret = c->prot->url_handshake(c);
239  if (ret)
240  return ret;
241  }
242  c->is_connected = 1;
243  return 0;
244 }
245 
246 #define URL_SCHEME_CHARS \
247  "abcdefghijklmnopqrstuvwxyz" \
248  "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
249  "0123456789+-."
250 
251 static const struct URLProtocol *url_find_protocol(const char *filename)
252 {
253  const URLProtocol **protocols;
254  char proto_str[128], proto_nested[128], *ptr;
255  size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
256  int i;
257 
258  if (filename[proto_len] != ':' &&
259  (strncmp(filename, "subfile,", 8) || !strchr(filename + proto_len + 1, ':')) ||
260  is_dos_path(filename))
261  strcpy(proto_str, "file");
262  else
263  av_strlcpy(proto_str, filename,
264  FFMIN(proto_len + 1, sizeof(proto_str)));
265 
266  av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
267  if ((ptr = strchr(proto_nested, '+')))
268  *ptr = '\0';
269 
270  protocols = ffurl_get_protocols(NULL, NULL);
271  if (!protocols)
272  return NULL;
273  for (i = 0; protocols[i]; i++) {
274  const URLProtocol *up = protocols[i];
275  if (!strcmp(proto_str, up->name)) {
276  av_freep(&protocols);
277  return up;
278  }
279  if (up->flags & URL_PROTOCOL_FLAG_NESTED_SCHEME &&
280  !strcmp(proto_nested, up->name)) {
281  av_freep(&protocols);
282  return up;
283  }
284  }
285  av_freep(&protocols);
286  if (av_strstart(filename, "https:", NULL) || av_strstart(filename, "tls:", NULL))
287  av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with "
288  "openssl, gnutls or securetransport enabled.\n");
289 
290  return NULL;
291 }
292 
293 int ffurl_alloc(URLContext **puc, const char *filename, int flags,
294  const AVIOInterruptCB *int_cb)
295 {
296  const URLProtocol *p = NULL;
297 
298  p = url_find_protocol(filename);
299  if (p)
300  return url_alloc_for_protocol(puc, p, filename, flags, int_cb);
301 
302  *puc = NULL;
303  return AVERROR_PROTOCOL_NOT_FOUND;
304 }
305 
306 int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags,
307  const AVIOInterruptCB *int_cb, AVDictionary **options,
308  const char *whitelist, const char* blacklist,
309  URLContext *parent)
310 {
311  AVDictionary *tmp_opts = NULL;
312  AVDictionaryEntry *e;
313  int ret = ffurl_alloc(puc, filename, flags, int_cb);
314  if (ret < 0)
315  return ret;
316  if (parent) {
317  ret = av_opt_copy(*puc, parent);
318  if (ret < 0)
319  goto fail;
320  }
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) {
368  if (ff_check_interrupt(&h->interrupt_callback))
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 
438 int ffurl_closep(URLContext **hh)
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
448  if (h->prot->flags & URL_PROTOCOL_FLAG_NETWORK)
449  ff_network_close();
450 #endif
451  if (h->prot->priv_data_size) {
452  if (h->prot->priv_data_class)
453  av_opt_free(h->priv_data);
454  av_freep(&h->priv_data);
455  }
456  av_opt_free(h);
457  av_freep(hh);
458  return ret;
459 }
460 
461 int ffurl_close(URLContext *h)
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 ffurl_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 ffurl_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 #if !FF_API_AVIODIRCONTEXT
532 struct AVIODirContext {
533  struct URLContext *url_context;
534 };
535 #endif
536 
537 int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options)
538 {
539  URLContext *h = NULL;
540  AVIODirContext *ctx = NULL;
541  int ret;
542  av_assert0(s);
543 
544  ctx = av_mallocz(sizeof(*ctx));
545  if (!ctx) {
546  ret = AVERROR(ENOMEM);
547  goto fail;
548  }
549 
550  if ((ret = ffurl_alloc(&h, url, AVIO_FLAG_READ, NULL)) < 0)
551  goto fail;
552 
553  if (h->prot->url_open_dir && h->prot->url_read_dir && h->prot->url_close_dir) {
554  if (options && h->prot->priv_data_class &&
555  (ret = av_opt_set_dict(h->priv_data, options)) < 0)
556  goto fail;
557  ret = h->prot->url_open_dir(h);
558  } else
559  ret = AVERROR(ENOSYS);
560  if (ret < 0)
561  goto fail;
562 
563  h->is_connected = 1;
564  ctx->url_context = h;
565  *s = ctx;
566  return 0;
567 
568  fail:
569  av_free(ctx);
570  *s = NULL;
571  ffurl_close(h);
572  return ret;
573 }
574 
575 int avio_read_dir(AVIODirContext *s, AVIODirEntry **next)
576 {
577  URLContext *h;
578  int ret;
579 
580  if (!s || !s->url_context)
581  return AVERROR(EINVAL);
582  h = s->url_context;
583  if ((ret = h->prot->url_read_dir(h, next)) < 0)
584  avio_free_directory_entry(next);
585  return ret;
586 }
587 
588 int avio_close_dir(AVIODirContext **s)
589 {
590  URLContext *h;
591 
592  av_assert0(s);
593  if (!(*s) || !(*s)->url_context)
594  return AVERROR(EINVAL);
595  h = (*s)->url_context;
596  h->prot->url_close_dir(h);
597  ffurl_close(h);
598  av_freep(s);
599  *s = NULL;
600  return 0;
601 }
602 
603 void avio_free_directory_entry(AVIODirEntry **entry)
604 {
605  if (!entry || !*entry)
606  return;
607  av_free((*entry)->name);
608  av_freep(entry);
609 }
610 
611 int64_t ffurl_size(URLContext *h)
612 {
613  int64_t pos, size;
614 
615  size = ffurl_seek(h, 0, AVSEEK_SIZE);
616  if (size < 0) {
617  pos = ffurl_seek(h, 0, SEEK_CUR);
618  if ((size = ffurl_seek(h, -1, SEEK_END)) < 0)
619  return size;
620  size++;
621  ffurl_seek(h, pos, SEEK_SET);
622  }
623  return size;
624 }
625 
626 int ffurl_get_file_handle(URLContext *h)
627 {
628  if (!h || !h->prot || !h->prot->url_get_file_handle)
629  return -1;
630  return h->prot->url_get_file_handle(h);
631 }
632 
633 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
634 {
635  if (!h || !h->prot)
636  return AVERROR(ENOSYS);
637  if (!h->prot->url_get_multi_file_handle) {
638  if (!h->prot->url_get_file_handle)
639  return AVERROR(ENOSYS);
640  *handles = av_malloc(sizeof(**handles));
641  if (!*handles)
642  return AVERROR(ENOMEM);
643  *numhandles = 1;
644  *handles[0] = h->prot->url_get_file_handle(h);
645  return 0;
646  }
647  return h->prot->url_get_multi_file_handle(h, handles, numhandles);
648 }
649 
650 int ffurl_get_short_seek(URLContext *h)
651 {
652  if (!h || !h->prot || !h->prot->url_get_short_seek)
653  return AVERROR(ENOSYS);
654  return h->prot->url_get_short_seek(h);
655 }
656 
657 int ffurl_shutdown(URLContext *h, int flags)
658 {
659  if (!h || !h->prot || !h->prot->url_shutdown)
660  return AVERROR(ENOSYS);
661  return h->prot->url_shutdown(h, flags);
662 }
663 
664 int ff_check_interrupt(AVIOInterruptCB *cb)
665 {
666  if (cb && cb->callback)
667  return cb->callback(cb->opaque);
668  return 0;
669 }
670 
671 int ff_rename(const char *url_src, const char *url_dst, void *logctx)
672 {
673  int ret = ffurl_move(url_src, url_dst);
674  if (ret < 0)
675  av_log(logctx, AV_LOG_ERROR, "failed to rename file %s to %s: %s\n", url_src, url_dst, av_err2str(ret));
676  return ret;
677 }
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:64
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:239
ffurl_seek
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
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:625
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:474
ffurl_close
int ffurl_close(URLContext *h)
Definition: avio.c:461
urlcontext_to_name
static const char * urlcontext_to_name(void *ptr)
Definition: avio.c:37
AVDictionary
Definition: dict.c:32
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:81
URLContext::is_connected
int is_connected
Definition: url.h:45
fail
#define fail()
Definition: checkasm.h:134
ffurl_connect
int ffurl_connect(URLContext *uc, AVDictionary **options)
Connect an URLContext that has been allocated by ffurl_alloc.
Definition: avio.c:166
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:77
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:664
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:671
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:603
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:74
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:60
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:306
retry_transfer_wrapper
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
s
#define s(width, name)
Definition: cbs_vp9.c:256
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:588
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:226
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:624
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:226
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:121
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:56
NULL
#define NULL
Definition: coverity.c:32
urlcontext_child_next
static void * urlcontext_child_next(void *obj, void *prev)
Definition: avio.c:46
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:445
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:493
ffurl_shutdown
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
Definition: avio.c:657
URL_SCHEME_CHARS
#define URL_SCHEME_CHARS
Definition: avio.c:246
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:575
OFFSET
#define OFFSET(x)
Definition: avio.c:54
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:633
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:474
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:37
ffurl_get_short_seek
int ffurl_get_short_seek(URLContext *h)
Return the current short seek threshold value for this URL.
Definition: avio.c:650
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:293
URLContext
Definition: url.h:37
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:537
len
int len
Definition: vorbis_enc_data.h:426
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:500
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:438
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
AVIODirContext
Definition: avio.c:532
URLContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Definition: url.h:46
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
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:57
url_find_protocol
static const struct URLProtocol * url_find_protocol(const char *filename)
Definition: avio.c:251
ffurl_read
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
URLContext::av_class
const AVClass * av_class
information for av_log().
Definition: url.h:38
ffurl_write
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
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:482
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:623
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:408
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:234
AVIO_FLAG_NONBLOCK
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
Definition: avio.h:642
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:86
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:533
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:467
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:86
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:611
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:515
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:626
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
Generated on Tue Feb 28 2023 21:34:02 for FFmpeg by   doxygen 1.8.17