FFmpeg
file.c
Go to the documentation of this file.
1 /*
2  * buffered file 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 "config_components.h"
23 
24 #include "libavutil/avstring.h"
25 #include "libavutil/file_open.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/mem.h"
28 #include "libavutil/opt.h"
29 #include "avio.h"
30 #if HAVE_DIRENT_H
31 #include <dirent.h>
32 #endif
33 #include <fcntl.h>
34 #if HAVE_IO_H
35 #include <io.h>
36 #endif
37 #if HAVE_UNISTD_H
38 #include <unistd.h>
39 #endif
40 #include <sys/stat.h>
41 #include <stdlib.h>
42 #include "os_support.h"
43 #include "url.h"
44 
45 /* Some systems may not have S_ISFIFO */
46 #ifndef S_ISFIFO
47 # ifdef S_IFIFO
48 # define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
49 # else
50 # define S_ISFIFO(m) 0
51 # endif
52 #endif
53 
54 /* Not available in POSIX.1-1996 */
55 #ifndef S_ISLNK
56 # ifdef S_IFLNK
57 # define S_ISLNK(m) (((m) & S_IFLNK) == S_IFLNK)
58 # else
59 # define S_ISLNK(m) 0
60 # endif
61 #endif
62 
63 /* Not available in POSIX.1-1996 */
64 #ifndef S_ISSOCK
65 # ifdef S_IFSOCK
66 # define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
67 # else
68 # define S_ISSOCK(m) 0
69 # endif
70 #endif
71 
72 /* S_ISREG not available on Windows */
73 #ifndef S_ISREG
74 # ifdef S_IFREG
75 # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
76 # else
77 # define S_ISREG(m) 0
78 # endif
79 #endif
80 
81 /* S_ISBLK not available on Windows */
82 #ifndef S_ISBLK
83 # ifdef S_IFBLK
84 # define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
85 # else
86 # define S_ISBLK(m) 0
87 # endif
88 #endif
89 
90 /* standard file protocol */
91 
92 typedef struct FileContext {
93  const AVClass *class;
94  int fd;
95  int trunc;
96  int blocksize;
97  int follow;
98  int seekable;
99 #if HAVE_DIRENT_H
100  DIR *dir;
101 #endif
102 } FileContext;
103 
104 static const AVOption file_options[] = {
105  { "truncate", "truncate existing files on write", offsetof(FileContext, trunc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
106  { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
107  { "follow", "Follow a file as it is being written", offsetof(FileContext, follow), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
108  { "seekable", "Sets if the file is seekable", offsetof(FileContext, seekable), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
109  { NULL }
110 };
111 
112 static const AVOption pipe_options[] = {
113  { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
114  { "fd", "set file descriptor", offsetof(FileContext, fd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
115  { NULL }
116 };
117 
118 static const AVClass file_class = {
119  .class_name = "file",
120  .item_name = av_default_item_name,
121  .option = file_options,
122  .version = LIBAVUTIL_VERSION_INT,
123 };
124 
125 static const AVClass pipe_class = {
126  .class_name = "pipe",
127  .item_name = av_default_item_name,
128  .option = pipe_options,
129  .version = LIBAVUTIL_VERSION_INT,
130 };
131 
132 static const AVClass fd_class = {
133  .class_name = "fd",
134  .item_name = av_default_item_name,
135  .option = pipe_options,
136  .version = LIBAVUTIL_VERSION_INT,
137 };
138 
139 static int file_read(URLContext *h, unsigned char *buf, int size)
140 {
141  FileContext *c = h->priv_data;
142  int ret;
143  size = FFMIN(size, c->blocksize);
144  ret = read(c->fd, buf, size);
145  if (ret == 0 && c->follow)
146  return AVERROR(EAGAIN);
147  if (ret == 0)
148  return AVERROR_EOF;
149  return (ret == -1) ? AVERROR(errno) : ret;
150 }
151 
152 static int file_write(URLContext *h, const unsigned char *buf, int size)
153 {
154  FileContext *c = h->priv_data;
155  int ret;
156  size = FFMIN(size, c->blocksize);
157  ret = write(c->fd, buf, size);
158  return (ret == -1) ? AVERROR(errno) : ret;
159 }
160 
162 {
163  FileContext *c = h->priv_data;
164  return c->fd;
165 }
166 
167 static int file_check(URLContext *h, int mask)
168 {
169  int ret = 0;
170  const char *filename = h->filename;
171  av_strstart(filename, "file:", &filename);
172 
173  {
174 #if HAVE_ACCESS && defined(R_OK)
175  if (access(filename, F_OK) < 0)
176  return AVERROR(errno);
177  if (mask&AVIO_FLAG_READ)
178  if (access(filename, R_OK) >= 0)
179  ret |= AVIO_FLAG_READ;
180  if (mask&AVIO_FLAG_WRITE)
181  if (access(filename, W_OK) >= 0)
182  ret |= AVIO_FLAG_WRITE;
183 #else
184  struct stat st;
185  ret = stat(filename, &st);
186  if (ret < 0)
187  return AVERROR(errno);
188 
189  ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ : 0;
190  ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0;
191 #endif
192  }
193  return ret;
194 }
195 
196 #if CONFIG_FD_PROTOCOL || CONFIG_PIPE_PROTOCOL
197 static int fd_dup(URLContext *h, int oldfd)
198 {
199  int newfd;
200 
201 #ifdef F_DUPFD_CLOEXEC
202  newfd = fcntl(oldfd, F_DUPFD_CLOEXEC, 0);
203 #else
204  newfd = dup(oldfd);
205 #endif
206  if (newfd == -1)
207  return newfd;
208 
209 #if HAVE_FCNTL
210  if (fcntl(newfd, F_SETFD, FD_CLOEXEC) == -1)
211  av_log(h, AV_LOG_DEBUG, "Failed to set close on exec\n");
212 #endif
213 
214 #if HAVE_SETMODE
215  setmode(newfd, O_BINARY);
216 #endif
217  return newfd;
218 }
219 #endif
220 
221 static int file_close(URLContext *h)
222 {
223  FileContext *c = h->priv_data;
224  int ret = close(c->fd);
225  return (ret == -1) ? AVERROR(errno) : 0;
226 }
227 
228 /* XXX: use llseek */
229 static int64_t file_seek(URLContext *h, int64_t pos, int whence)
230 {
231  FileContext *c = h->priv_data;
232  int64_t ret;
233 
234  if (whence == AVSEEK_SIZE) {
235  struct stat st;
236  ret = fstat(c->fd, &st);
237  return ret < 0 ? AVERROR(errno) : (S_ISFIFO(st.st_mode) ? 0 : st.st_size);
238  }
239 
240  ret = lseek(c->fd, pos, whence);
241 
242  return ret < 0 ? AVERROR(errno) : ret;
243 }
244 
245 #if CONFIG_FILE_PROTOCOL
246 
247 static int file_delete(URLContext *h)
248 {
249 #if HAVE_UNISTD_H
250  int ret;
251  const char *filename = h->filename;
252  av_strstart(filename, "file:", &filename);
253 
254  ret = rmdir(filename);
255  if (ret < 0 && (errno == ENOTDIR
256 # ifdef _WIN32
257  || errno == EINVAL
258 # endif
259  ))
260  ret = unlink(filename);
261  if (ret < 0)
262  return AVERROR(errno);
263 
264  return ret;
265 #else
266  return AVERROR(ENOSYS);
267 #endif /* HAVE_UNISTD_H */
268 }
269 
270 static int file_move(URLContext *h_src, URLContext *h_dst)
271 {
272  const char *filename_src = h_src->filename;
273  const char *filename_dst = h_dst->filename;
274  av_strstart(filename_src, "file:", &filename_src);
275  av_strstart(filename_dst, "file:", &filename_dst);
276 
277  if (rename(filename_src, filename_dst) < 0)
278  return AVERROR(errno);
279 
280  return 0;
281 }
282 
283 static int file_open(URLContext *h, const char *filename, int flags)
284 {
285  FileContext *c = h->priv_data;
286  int access;
287  int fd;
288  struct stat st;
289 
290  av_strstart(filename, "file:", &filename);
291 
293  access = O_CREAT | O_RDWR;
294  if (c->trunc)
295  access |= O_TRUNC;
296  } else if (flags & AVIO_FLAG_WRITE) {
297  access = O_CREAT | O_WRONLY;
298  if (c->trunc)
299  access |= O_TRUNC;
300  } else {
301  access = O_RDONLY;
302  }
303 #ifdef O_BINARY
304  access |= O_BINARY;
305 #endif
306  fd = avpriv_open(filename, access, 0666);
307  if (fd == -1)
308  return AVERROR(errno);
309  c->fd = fd;
310 
311  h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode);
312 
313  /* Buffer writes more than the default 32k to improve throughput especially
314  * with networked file systems */
315  if (!h->is_streamed && flags & AVIO_FLAG_WRITE)
316  h->min_packet_size = h->max_packet_size = 262144;
317 
318  if (c->seekable >= 0)
319  h->is_streamed = !c->seekable;
320 
321  return 0;
322 }
323 
324 static int file_open_dir(URLContext *h)
325 {
326 #if HAVE_LSTAT
327  FileContext *c = h->priv_data;
328 
329  c->dir = opendir(h->filename);
330  if (!c->dir)
331  return AVERROR(errno);
332 
333  return 0;
334 #else
335  return AVERROR(ENOSYS);
336 #endif /* HAVE_LSTAT */
337 }
338 
339 static int file_read_dir(URLContext *h, AVIODirEntry **next)
340 {
341 #if HAVE_LSTAT
342  FileContext *c = h->priv_data;
343  struct dirent *dir;
344  char *fullpath = NULL;
345 
346  *next = ff_alloc_dir_entry();
347  if (!*next)
348  return AVERROR(ENOMEM);
349  do {
350  errno = 0;
351  dir = readdir(c->dir);
352  if (!dir) {
353  av_freep(next);
354  return AVERROR(errno);
355  }
356  } while (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."));
357 
358  fullpath = av_append_path_component(h->filename, dir->d_name);
359  if (fullpath) {
360  struct stat st;
361  if (!lstat(fullpath, &st)) {
362  if (S_ISDIR(st.st_mode))
363  (*next)->type = AVIO_ENTRY_DIRECTORY;
364  else if (S_ISFIFO(st.st_mode))
365  (*next)->type = AVIO_ENTRY_NAMED_PIPE;
366  else if (S_ISCHR(st.st_mode))
367  (*next)->type = AVIO_ENTRY_CHARACTER_DEVICE;
368  else if (S_ISBLK(st.st_mode))
369  (*next)->type = AVIO_ENTRY_BLOCK_DEVICE;
370  else if (S_ISLNK(st.st_mode))
371  (*next)->type = AVIO_ENTRY_SYMBOLIC_LINK;
372  else if (S_ISSOCK(st.st_mode))
373  (*next)->type = AVIO_ENTRY_SOCKET;
374  else if (S_ISREG(st.st_mode))
375  (*next)->type = AVIO_ENTRY_FILE;
376  else
377  (*next)->type = AVIO_ENTRY_UNKNOWN;
378 
379  (*next)->group_id = st.st_gid;
380  (*next)->user_id = st.st_uid;
381  (*next)->size = st.st_size;
382  (*next)->filemode = st.st_mode & 0777;
383  (*next)->modification_timestamp = INT64_C(1000000) * st.st_mtime;
384  (*next)->access_timestamp = INT64_C(1000000) * st.st_atime;
385  (*next)->status_change_timestamp = INT64_C(1000000) * st.st_ctime;
386  }
387  av_free(fullpath);
388  }
389 
390  (*next)->name = av_strdup(dir->d_name);
391  return 0;
392 #else
393  return AVERROR(ENOSYS);
394 #endif /* HAVE_LSTAT */
395 }
396 
397 static int file_close_dir(URLContext *h)
398 {
399 #if HAVE_LSTAT
400  FileContext *c = h->priv_data;
401  closedir(c->dir);
402  return 0;
403 #else
404  return AVERROR(ENOSYS);
405 #endif /* HAVE_LSTAT */
406 }
407 
409  .name = "file",
410  .url_open = file_open,
411  .url_read = file_read,
412  .url_write = file_write,
413  .url_seek = file_seek,
414  .url_close = file_close,
415  .url_get_file_handle = file_get_handle,
416  .url_check = file_check,
417  .url_delete = file_delete,
418  .url_move = file_move,
419  .priv_data_size = sizeof(FileContext),
420  .priv_data_class = &file_class,
421  .url_open_dir = file_open_dir,
422  .url_read_dir = file_read_dir,
423  .url_close_dir = file_close_dir,
424  .default_whitelist = "file,crypto,data"
425 };
426 
427 #endif /* CONFIG_FILE_PROTOCOL */
428 
429 #if CONFIG_PIPE_PROTOCOL
430 
431 static int pipe_open(URLContext *h, const char *filename, int flags)
432 {
433  FileContext *c = h->priv_data;
434  int fd;
435  char *final;
436 
437  if (c->fd < 0) {
438  av_strstart(filename, "pipe:", &filename);
439 
440  if (!*filename) {
441  if (flags & AVIO_FLAG_WRITE) {
442  fd = 1;
443  } else {
444  fd = 0;
445  }
446  } else {
447  fd = strtol(filename, &final, 10);
448  if (*final) /* No digits found, or something like 10ab */
449  return AVERROR(EINVAL);
450  }
451  c->fd = fd;
452  }
453 
454  c->fd = fd_dup(h, c->fd);
455  if (c->fd == -1)
456  return AVERROR(errno);
457  h->is_streamed = 1;
458  return 0;
459 }
460 
462  .name = "pipe",
463  .url_open = pipe_open,
464  .url_read = file_read,
465  .url_write = file_write,
466  .url_close = file_close,
467  .url_get_file_handle = file_get_handle,
468  .url_check = file_check,
469  .priv_data_size = sizeof(FileContext),
470  .priv_data_class = &pipe_class,
471  .default_whitelist = "crypto,data"
472 };
473 
474 #endif /* CONFIG_PIPE_PROTOCOL */
475 
476 #if CONFIG_FD_PROTOCOL
477 
478 static int fd_open(URLContext *h, const char *filename, int flags)
479 {
480  FileContext *c = h->priv_data;
481  struct stat st;
482 
483  if (strcmp(filename, "fd:") != 0) {
484  av_log(h, AV_LOG_ERROR, "Doesn't support pass file descriptor via URL,"
485  " please set it via -fd {num}\n");
486  return AVERROR(EINVAL);
487  }
488 
489  if (c->fd < 0) {
490  if (flags & AVIO_FLAG_WRITE) {
491  c->fd = 1;
492  } else {
493  c->fd = 0;
494  }
495  }
496  if (fstat(c->fd, &st) < 0)
497  return AVERROR(errno);
498  h->is_streamed = !(S_ISREG(st.st_mode) || S_ISBLK(st.st_mode));
499  c->fd = fd_dup(h, c->fd);
500  if (c->fd == -1)
501  return AVERROR(errno);
502 
503  return 0;
504 }
505 
506 const URLProtocol ff_fd_protocol = {
507  .name = "fd",
508  .url_open = fd_open,
509  .url_read = file_read,
510  .url_write = file_write,
511  .url_seek = file_seek,
512  .url_close = file_close,
513  .url_get_file_handle = file_get_handle,
514  .url_check = file_check,
515  .priv_data_size = sizeof(FileContext),
516  .priv_data_class = &fd_class,
517  .default_whitelist = "crypto,data"
518 };
519 
520 #endif /* CONFIG_FD_PROTOCOL */
521 
522 #if CONFIG_ANDROID_CONTENT_PROTOCOL
523 #include <jni.h>
524 #include "libavcodec/ffjni.h"
525 #include "libavcodec/jni.h"
526 
527 typedef struct JFields {
528  jclass uri_class;
529  jmethodID parse_id;
530 
531  jclass context_class;
532  jmethodID get_content_resolver_id;
533 
534  jclass content_resolver_class;
535  jmethodID open_file_descriptor_id;
536 
537  jclass parcel_file_descriptor_class;
538  jmethodID detach_fd_id;
539 } JFields;
540 
541 #define OFFSET(x) offsetof(JFields, x)
542 static const struct FFJniField jfields_mapping[] = {
543  { "android/net/Uri", NULL, NULL, FF_JNI_CLASS, OFFSET(uri_class), 1 },
544  { "android/net/Uri", "parse", "(Ljava/lang/String;)Landroid/net/Uri;", FF_JNI_STATIC_METHOD, OFFSET(parse_id), 1 },
545 
546  { "android/content/Context", NULL, NULL, FF_JNI_CLASS, OFFSET(context_class), 1 },
547  { "android/content/Context", "getContentResolver", "()Landroid/content/ContentResolver;", FF_JNI_METHOD, OFFSET(get_content_resolver_id), 1 },
548 
549  { "android/content/ContentResolver", NULL, NULL, FF_JNI_CLASS, OFFSET(content_resolver_class), 1 },
550  { "android/content/ContentResolver", "openFileDescriptor", "(Landroid/net/Uri;Ljava/lang/String;)Landroid/os/ParcelFileDescriptor;", FF_JNI_METHOD, OFFSET(open_file_descriptor_id), 1 },
551 
552  { "android/os/ParcelFileDescriptor", NULL, NULL, FF_JNI_CLASS, OFFSET(parcel_file_descriptor_class), 1 },
553  { "android/os/ParcelFileDescriptor", "detachFd", "()I", FF_JNI_METHOD, OFFSET(detach_fd_id), 1 },
554 
555  { NULL }
556 };
557 #undef OFFSET
558 
559 static int android_content_open(URLContext *h, const char *filename, int flags)
560 {
561  FileContext *c = h->priv_data;
562  int fd, ret;
563  struct stat st;
564  const char *mode_str = "r";
565 
566  JNIEnv *env;
567  JFields jfields = { 0 };
568  jobject application_context = NULL;
569  jobject url = NULL;
570  jobject mode = NULL;
571  jobject uri = NULL;
572  jobject content_resolver = NULL;
573  jobject parcel_file_descriptor = NULL;
574 
575  env = ff_jni_get_env(c);
576  if (!env) {
577  return AVERROR(EINVAL);
578  }
579 
580  ret = ff_jni_init_jfields(env, &jfields, jfields_mapping, 0, c);
581  if (ret < 0) {
582  av_log(c, AV_LOG_ERROR, "failed to initialize jni fields\n");
583  return ret;
584  }
585 
586  application_context = av_jni_get_android_app_ctx();
587  if (!application_context) {
588  av_log(c, AV_LOG_ERROR, "application context is not set\n");
590  goto done;
591  }
592 
593  url = ff_jni_utf_chars_to_jstring(env, filename, c);
594  if (!url) {
596  goto done;
597  }
598 
600  mode_str = "rw";
601  else if (flags & AVIO_FLAG_WRITE)
602  mode_str = "w";
603 
604  mode = ff_jni_utf_chars_to_jstring(env, mode_str, c);
605  if (!mode) {
607  goto done;
608  }
609 
610  uri = (*env)->CallStaticObjectMethod(env, jfields.uri_class, jfields.parse_id, url);
611  ret = ff_jni_exception_check(env, 1, c);
612  if (ret < 0)
613  goto done;
614 
615  content_resolver = (*env)->CallObjectMethod(env, application_context, jfields.get_content_resolver_id);
616  ret = ff_jni_exception_check(env, 1, c);
617  if (ret < 0)
618  goto done;
619 
620  parcel_file_descriptor = (*env)->CallObjectMethod(env, content_resolver, jfields.open_file_descriptor_id, uri, mode);
621  ret = ff_jni_exception_check(env, 1, c);
622  if (ret < 0)
623  goto done;
624 
625  fd = (*env)->CallIntMethod(env, parcel_file_descriptor, jfields.detach_fd_id);
626  ret = ff_jni_exception_check(env, 1, c);
627  if (ret < 0)
628  goto done;
629 
630  if (fstat(fd, &st) < 0) {
631  close(fd);
632  return AVERROR(errno);
633  }
634 
635  c->fd = fd;
636  h->is_streamed = !(S_ISREG(st.st_mode) || S_ISBLK(st.st_mode));
637 
638 done:
639  (*env)->DeleteLocalRef(env, url);
640  (*env)->DeleteLocalRef(env, mode);
641  (*env)->DeleteLocalRef(env, uri);
642  (*env)->DeleteLocalRef(env, content_resolver);
643  (*env)->DeleteLocalRef(env, parcel_file_descriptor);
644  ff_jni_reset_jfields(env, &jfields, jfields_mapping, 0, c);
645 
646  return ret;
647 }
648 
649 static const AVOption android_content_options[] = {
650  { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
651  { NULL }
652 };
653 
654 static const AVClass android_content_class = {
655  .class_name = "android_content",
656  .item_name = av_default_item_name,
657  .option = android_content_options,
658  .version = LIBAVUTIL_VERSION_INT,
659 };
660 
662  .name = "content",
663  .url_open = android_content_open,
664  .url_read = file_read,
665  .url_write = file_write,
666  .url_seek = file_seek,
667  .url_close = file_close,
668  .url_get_file_handle = file_get_handle,
669  .url_check = NULL,
670  .priv_data_size = sizeof(FileContext),
671  .priv_data_class = &android_content_class,
672 };
673 
674 #endif /* CONFIG_ANDROID_CONTENT_PROTOCOL */
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
S_ISSOCK
#define S_ISSOCK(m)
Definition: file.c:68
URLContext::filename
char * filename
specified URL
Definition: url.h:39
ff_jni_utf_chars_to_jstring
jstring ff_jni_utf_chars_to_jstring(JNIEnv *env, const char *utf_chars, void *log_ctx)
Definition: ffjni.c:129
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
int64_t
long long int64_t
Definition: coverity.c:34
mask
int mask
Definition: mediacodecdec_common.c:154
file_close
static int file_close(URLContext *h)
Definition: file.c:221
mode
Definition: swscale.c:52
ff_jni_reset_jfields
int ff_jni_reset_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
Definition: ffjni.c:368
AVOption
AVOption.
Definition: opt.h:429
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:468
AVIO_ENTRY_NAMED_PIPE
@ AVIO_ENTRY_NAMED_PIPE
Definition: avio.h:72
file_check
static int file_check(URLContext *h, int mask)
Definition: file.c:167
URLProtocol
Definition: url.h:51
os_support.h
AVIO_ENTRY_UNKNOWN
@ AVIO_ENTRY_UNKNOWN
Definition: avio.h:68
ff_jni_init_jfields
int ff_jni_init_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)
Definition: ffjni.c:279
av_append_path_component
char * av_append_path_component(const char *path, const char *component)
Append path component to the existing path.
Definition: avstring.c:296
AVIO_ENTRY_DIRECTORY
@ AVIO_ENTRY_DIRECTORY
Definition: avio.h:71
trunc
static __device__ float trunc(float a)
Definition: cuda_runtime.h:179
AVIO_ENTRY_CHARACTER_DEVICE
@ AVIO_ENTRY_CHARACTER_DEVICE
Definition: avio.h:70
FF_JNI_CLASS
@ FF_JNI_CLASS
Definition: ffjni.h:91
ff_android_content_protocol
const URLProtocol ff_android_content_protocol
FileContext::blocksize
int blocksize
Definition: file.c:96
file_write
static int file_write(URLContext *h, const unsigned char *buf, int size)
Definition: file.c:152
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
ff_fd_protocol
const URLProtocol ff_fd_protocol
file_read
static int file_read(URLContext *h, unsigned char *buf, int size)
Definition: file.c:139
AVIO_ENTRY_SYMBOLIC_LINK
@ AVIO_ENTRY_SYMBOLIC_LINK
Definition: avio.h:73
FileContext::seekable
int seekable
Definition: file.c:98
S_ISFIFO
#define S_ISFIFO(m)
Definition: file.c:50
avpriv_open
int avpriv_open(const char *filename, int flags,...)
A wrapper for open() setting O_CLOEXEC.
Definition: file_open.c:67
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
FileContext
Definition: file.c:92
pipe_class
static const AVClass pipe_class
Definition: file.c:125
file_open.h
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
FF_JNI_METHOD
@ FF_JNI_METHOD
Definition: ffjni.h:94
NULL
#define NULL
Definition: coverity.c:32
S_ISBLK
#define S_ISBLK(m)
Definition: file.c:86
FFJniField
Definition: ffjni.h:103
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVIO_ENTRY_FILE
@ AVIO_ENTRY_FILE
Definition: avio.h:75
FileContext::fd
int fd
Definition: file.c:94
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:352
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
pipe_options
static const AVOption pipe_options[]
Definition: file.c:112
FileContext::follow
int follow
Definition: file.c:97
ff_file_protocol
const URLProtocol ff_file_protocol
size
int size
Definition: twinvq_data.h:10344
AVIODirEntry
Describes single entry of the directory.
Definition: avio.h:87
avio.h
URLProtocol::name
const char * name
Definition: url.h:52
FileContext::trunc
int trunc
Definition: file.c:95
file_seek
static int64_t file_seek(URLContext *h, int64_t pos, int whence)
Definition: file.c:229
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
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
AVIO_ENTRY_SOCKET
@ AVIO_ENTRY_SOCKET
Definition: avio.h:74
ff_alloc_dir_entry
AVIODirEntry * ff_alloc_dir_entry(void)
Allocate directory entry with default values.
Definition: url.c:327
ff_jni_exception_check
int ff_jni_exception_check(JNIEnv *env, int log, void *log_ctx)
Definition: ffjni.c:246
URLContext
Definition: url.h:35
ffjni.h
file_options
static const AVOption file_options[]
Definition: file.c:104
av_jni_get_android_app_ctx
void * av_jni_get_android_app_ctx(void)
internal.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
url.h
file_class
static const AVClass file_class
Definition: file.c:118
S_ISLNK
#define S_ISLNK(m)
Definition: file.c:59
O_BINARY
#define O_BINARY
ff_pipe_protocol
const URLProtocol ff_pipe_protocol
AVIO_ENTRY_BLOCK_DEVICE
@ AVIO_ENTRY_BLOCK_DEVICE
Definition: avio.h:69
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:80
file_get_handle
static int file_get_handle(URLContext *h)
Definition: file.c:161
pos
unsigned int pos
Definition: spdifenc.c:414
OFFSET
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
fd_class
static const AVClass fd_class
Definition: file.c:132
ff_jni_get_env
JNIEnv * ff_jni_get_env(void *log_ctx)
Definition: ffjni.c:53
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:617
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
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:356
mem.h
S_ISREG
#define S_ISREG(m)
Definition: file.c:77
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FF_JNI_STATIC_METHOD
@ FF_JNI_STATIC_METHOD
Definition: ffjni.h:95
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2070
avstring.h
jni.h
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