FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "libavutil/avstring.h"
23 #include "libavutil/internal.h"
24 #include "libavutil/opt.h"
25 #include "avformat.h"
26 #include <fcntl.h>
27 #if HAVE_IO_H
28 #include <io.h>
29 #endif
30 #if HAVE_UNISTD_H
31 #include <unistd.h>
32 #endif
33 #include <sys/stat.h>
34 #include <stdlib.h>
35 #include "os_support.h"
36 #include "url.h"
37 
38 /* Some systems may not have S_ISFIFO */
39 #ifndef S_ISFIFO
40 # ifdef S_IFIFO
41 # define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
42 # else
43 # define S_ISFIFO(m) 0
44 # endif
45 #endif
46 
47 /* standard file protocol */
48 
49 typedef struct FileContext {
50  const AVClass *class;
51  int fd;
52  int trunc;
53  int blocksize;
54 } FileContext;
55 
56 static const AVOption file_options[] = {
57  { "truncate", "truncate existing files on write", offsetof(FileContext, trunc), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
58  { "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 },
59  { NULL }
60 };
61 
62 static const AVOption pipe_options[] = {
63  { "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 },
64  { NULL }
65 };
66 
67 static const AVClass file_class = {
68  .class_name = "file",
69  .item_name = av_default_item_name,
70  .option = file_options,
71  .version = LIBAVUTIL_VERSION_INT,
72 };
73 
74 static const AVClass pipe_class = {
75  .class_name = "pipe",
76  .item_name = av_default_item_name,
77  .option = pipe_options,
78  .version = LIBAVUTIL_VERSION_INT,
79 };
80 
81 static int file_read(URLContext *h, unsigned char *buf, int size)
82 {
83  FileContext *c = h->priv_data;
84  int r;
85  size = FFMIN(size, c->blocksize);
86  r = read(c->fd, buf, size);
87  return (-1 == r)?AVERROR(errno):r;
88 }
89 
90 static int file_write(URLContext *h, const unsigned char *buf, int size)
91 {
92  FileContext *c = h->priv_data;
93  int r;
94  size = FFMIN(size, c->blocksize);
95  r = write(c->fd, buf, size);
96  return (-1 == r)?AVERROR(errno):r;
97 }
98 
100 {
101  FileContext *c = h->priv_data;
102  return c->fd;
103 }
104 
105 static int file_check(URLContext *h, int mask)
106 {
107  int ret = 0;
108  const char *filename = h->filename;
109  av_strstart(filename, "file:", &filename);
110 
111  {
112 #if HAVE_ACCESS && defined(R_OK)
113  if (access(filename, F_OK) < 0)
114  return AVERROR(errno);
115  if (mask&AVIO_FLAG_READ)
116  if (access(filename, R_OK) >= 0)
117  ret |= AVIO_FLAG_READ;
118  if (mask&AVIO_FLAG_WRITE)
119  if (access(filename, W_OK) >= 0)
120  ret |= AVIO_FLAG_WRITE;
121 #else
122  struct stat st;
123  ret = stat(filename, &st);
124  if (ret < 0)
125  return AVERROR(errno);
126 
127  ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ : 0;
128  ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0;
129 #endif
130  }
131  return ret;
132 }
133 
134 #if CONFIG_FILE_PROTOCOL
135 
136 static int file_open(URLContext *h, const char *filename, int flags)
137 {
138  FileContext *c = h->priv_data;
139  int access;
140  int fd;
141  struct stat st;
142 
143  av_strstart(filename, "file:", &filename);
144 
145  if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {
146  access = O_CREAT | O_RDWR;
147  if (c->trunc)
148  access |= O_TRUNC;
149  } else if (flags & AVIO_FLAG_WRITE) {
150  access = O_CREAT | O_WRONLY;
151  if (c->trunc)
152  access |= O_TRUNC;
153  } else {
154  access = O_RDONLY;
155  }
156 #ifdef O_BINARY
157  access |= O_BINARY;
158 #endif
159  fd = avpriv_open(filename, access, 0666);
160  if (fd == -1)
161  return AVERROR(errno);
162  c->fd = fd;
163 
164  h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode);
165 
166  return 0;
167 }
168 
169 /* XXX: use llseek */
170 static int64_t file_seek(URLContext *h, int64_t pos, int whence)
171 {
172  FileContext *c = h->priv_data;
173  int64_t ret;
174 
175  if (whence == AVSEEK_SIZE) {
176  struct stat st;
177  ret = fstat(c->fd, &st);
178  return ret < 0 ? AVERROR(errno) : (S_ISFIFO(st.st_mode) ? 0 : st.st_size);
179  }
180 
181  ret = lseek(c->fd, pos, whence);
182 
183  return ret < 0 ? AVERROR(errno) : ret;
184 }
185 
186 static int file_close(URLContext *h)
187 {
188  FileContext *c = h->priv_data;
189  return close(c->fd);
190 }
191 
192 URLProtocol ff_file_protocol = {
193  .name = "file",
194  .url_open = file_open,
195  .url_read = file_read,
196  .url_write = file_write,
197  .url_seek = file_seek,
198  .url_close = file_close,
199  .url_get_file_handle = file_get_handle,
200  .url_check = file_check,
201  .priv_data_size = sizeof(FileContext),
202  .priv_data_class = &file_class,
203 };
204 
205 #endif /* CONFIG_FILE_PROTOCOL */
206 
207 #if CONFIG_PIPE_PROTOCOL
208 
209 static int pipe_open(URLContext *h, const char *filename, int flags)
210 {
211  FileContext *c = h->priv_data;
212  int fd;
213  char *final;
214  av_strstart(filename, "pipe:", &filename);
215 
216  fd = strtol(filename, &final, 10);
217  if((filename == final) || *final ) {/* No digits found, or something like 10ab */
218  if (flags & AVIO_FLAG_WRITE) {
219  fd = 1;
220  } else {
221  fd = 0;
222  }
223  }
224 #if HAVE_SETMODE
225  setmode(fd, O_BINARY);
226 #endif
227  c->fd = fd;
228  h->is_streamed = 1;
229  return 0;
230 }
231 
232 URLProtocol ff_pipe_protocol = {
233  .name = "pipe",
234  .url_open = pipe_open,
235  .url_read = file_read,
236  .url_write = file_write,
237  .url_get_file_handle = file_get_handle,
238  .url_check = file_check,
239  .priv_data_size = sizeof(FileContext),
240  .priv_data_class = &pipe_class,
241 };
242 
243 #endif /* CONFIG_PIPE_PROTOCOL */
#define NULL
Definition: coverity.c:32
static int file_read(URLContext *h, unsigned char *buf, int size)
Definition: file.c:81
AVOption.
Definition: opt.h:255
#define LIBAVUTIL_VERSION_INT
Definition: version.h:62
static const AVOption pipe_options[]
Definition: file.c:62
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:46
#define AVIO_FLAG_READ
read-only
Definition: avio.h:460
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:461
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
AVOptions.
miscellaneous OS support macros and functions.
int blocksize
Definition: file.c:53
int avpriv_open(const char *filename, int flags,...)
A wrapper for open() setting O_CLOEXEC.
Definition: file_open.c:66
ptrdiff_t size
Definition: opengl_enc.c:101
static int file_check(URLContext *h, int mask)
Definition: file.c:105
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:285
int trunc
Definition: file.c:52
static const uint16_t mask[17]
Definition: lzw.c:38
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
#define S_ISFIFO(m)
Definition: file.c:43
const char * r
Definition: vf_curves.c:107
common internal API header
#define FFMIN(a, b)
Definition: common.h:66
ret
Definition: avfilter.c:974
static av_always_inline av_const double trunc(double x)
Definition: libm.h:176
#define O_BINARY
void * buf
Definition: avisynth_c.h:553
Definition: url.h:39
Describe the class of an AVClass context structure.
Definition: log.h:67
void * priv_data
Definition: url.h:42
static const AVClass file_class
Definition: file.c:67
static const AVOption file_options[]
Definition: file.c:56
const char * name
Definition: url.h:53
int fd
Definition: file.c:51
static int flags
Definition: cpu.c:47
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:34
Main libavformat public API header.
static int file_get_handle(URLContext *h)
Definition: file.c:99
static const AVClass pipe_class
Definition: file.c:74
static double c[64]
char * filename
specified URL
Definition: url.h:43
#define AVSEEK_SIZE
Passing this as the "whence" parameter to a seek function causes it to return the filesize without se...
Definition: avio.h:339
unbuffered private I/O API
static int file_write(URLContext *h, const unsigned char *buf, int size)
Definition: file.c:90