1 | /*
|
---|
2 | * unbuffered io for ffmpeg system
|
---|
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 | #ifndef AVIO_H
|
---|
22 | #define AVIO_H
|
---|
23 |
|
---|
24 | #include <stdint.h>
|
---|
25 |
|
---|
26 | /* output byte stream handling */
|
---|
27 |
|
---|
28 | typedef int64_t offset_t;
|
---|
29 |
|
---|
30 | /* unbuffered I/O */
|
---|
31 |
|
---|
32 | struct URLContext {
|
---|
33 | struct URLProtocol *prot;
|
---|
34 | int flags;
|
---|
35 | int is_streamed; /**< true if streamed (no seek possible), default = false */
|
---|
36 | int max_packet_size; /**< if non zero, the stream is packetized with this max packet size */
|
---|
37 | void *priv_data;
|
---|
38 | #if LIBAVFORMAT_VERSION_INT >= (52<<16)
|
---|
39 | char *filename; /**< specified filename */
|
---|
40 | #else
|
---|
41 | char filename[1]; /**< specified filename */
|
---|
42 | #endif
|
---|
43 | };
|
---|
44 |
|
---|
45 | typedef struct URLContext URLContext;
|
---|
46 |
|
---|
47 | typedef struct URLPollEntry {
|
---|
48 | URLContext *handle;
|
---|
49 | int events;
|
---|
50 | int revents;
|
---|
51 | } URLPollEntry;
|
---|
52 |
|
---|
53 | #define URL_RDONLY 0
|
---|
54 | #define URL_WRONLY 1
|
---|
55 | #define URL_RDWR 2
|
---|
56 |
|
---|
57 | typedef int URLInterruptCB(void);
|
---|
58 |
|
---|
59 | int url_open(URLContext **h, const char *filename, int flags);
|
---|
60 | int url_read(URLContext *h, unsigned char *buf, int size);
|
---|
61 | int url_write(URLContext *h, unsigned char *buf, int size);
|
---|
62 | offset_t url_seek(URLContext *h, offset_t pos, int whence);
|
---|
63 | int url_close(URLContext *h);
|
---|
64 | int url_exist(const char *filename);
|
---|
65 | offset_t url_filesize(URLContext *h);
|
---|
66 |
|
---|
67 | /**
|
---|
68 | * Return the maximum packet size associated to packetized file
|
---|
69 | * handle. If the file is not packetized (stream like http or file on
|
---|
70 | * disk), then 0 is returned.
|
---|
71 | *
|
---|
72 | * @param h file handle
|
---|
73 | * @return maximum packet size in bytes
|
---|
74 | */
|
---|
75 | int url_get_max_packet_size(URLContext *h);
|
---|
76 | void url_get_filename(URLContext *h, char *buf, int buf_size);
|
---|
77 |
|
---|
78 | /**
|
---|
79 | * the callback is called in blocking functions to test regulary if
|
---|
80 | * asynchronous interruption is needed. AVERROR(EINTR) is returned
|
---|
81 | * in this case by the interrupted function. 'NULL' means no interrupt
|
---|
82 | * callback is given. i
|
---|
83 | */
|
---|
84 | void url_set_interrupt_cb(URLInterruptCB *interrupt_cb);
|
---|
85 |
|
---|
86 | /* not implemented */
|
---|
87 | int url_poll(URLPollEntry *poll_table, int n, int timeout);
|
---|
88 |
|
---|
89 | /**
|
---|
90 | * Passing this as the "whence" parameter to a seek function causes it to
|
---|
91 | * return the filesize without seeking anywhere. Supporting this is optional.
|
---|
92 | * If it is not supported then the seek function will return <0.
|
---|
93 | */
|
---|
94 | #define AVSEEK_SIZE 0x10000
|
---|
95 |
|
---|
96 | typedef struct URLProtocol {
|
---|
97 | const char *name;
|
---|
98 | int (*url_open)(URLContext *h, const char *filename, int flags);
|
---|
99 | int (*url_read)(URLContext *h, unsigned char *buf, int size);
|
---|
100 | int (*url_write)(URLContext *h, unsigned char *buf, int size);
|
---|
101 | offset_t (*url_seek)(URLContext *h, offset_t pos, int whence);
|
---|
102 | int (*url_close)(URLContext *h);
|
---|
103 | struct URLProtocol *next;
|
---|
104 | } URLProtocol;
|
---|
105 |
|
---|
106 | extern URLProtocol *first_protocol;
|
---|
107 | extern URLInterruptCB *url_interrupt_cb;
|
---|
108 |
|
---|
109 | int register_protocol(URLProtocol *protocol);
|
---|
110 |
|
---|
111 | typedef struct {
|
---|
112 | unsigned char *buffer;
|
---|
113 | int buffer_size;
|
---|
114 | unsigned char *buf_ptr, *buf_end;
|
---|
115 | void *opaque;
|
---|
116 | int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
|
---|
117 | int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
|
---|
118 | offset_t (*seek)(void *opaque, offset_t offset, int whence);
|
---|
119 | offset_t pos; /**< position in the file of the current buffer */
|
---|
120 | int must_flush; /**< true if the next seek should flush */
|
---|
121 | int eof_reached; /**< true if eof reached */
|
---|
122 | int write_flag; /**< true if open for writing */
|
---|
123 | int is_streamed;
|
---|
124 | int max_packet_size;
|
---|
125 | unsigned long checksum;
|
---|
126 | unsigned char *checksum_ptr;
|
---|
127 | unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
|
---|
128 | int error; ///< contains the error code or 0 if no error happened
|
---|
129 | } ByteIOContext;
|
---|
130 |
|
---|
131 | int init_put_byte(ByteIOContext *s,
|
---|
132 | unsigned char *buffer,
|
---|
133 | int buffer_size,
|
---|
134 | int write_flag,
|
---|
135 | void *opaque,
|
---|
136 | int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
|
---|
137 | int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
|
---|
138 | offset_t (*seek)(void *opaque, offset_t offset, int whence));
|
---|
139 |
|
---|
140 | void put_byte(ByteIOContext *s, int b);
|
---|
141 | void put_buffer(ByteIOContext *s, const unsigned char *buf, int size);
|
---|
142 | void put_le64(ByteIOContext *s, uint64_t val);
|
---|
143 | void put_be64(ByteIOContext *s, uint64_t val);
|
---|
144 | void put_le32(ByteIOContext *s, unsigned int val);
|
---|
145 | void put_be32(ByteIOContext *s, unsigned int val);
|
---|
146 | void put_le24(ByteIOContext *s, unsigned int val);
|
---|
147 | void put_be24(ByteIOContext *s, unsigned int val);
|
---|
148 | void put_le16(ByteIOContext *s, unsigned int val);
|
---|
149 | void put_be16(ByteIOContext *s, unsigned int val);
|
---|
150 | void put_tag(ByteIOContext *s, const char *tag);
|
---|
151 |
|
---|
152 | void put_strz(ByteIOContext *s, const char *buf);
|
---|
153 |
|
---|
154 | offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence);
|
---|
155 | void url_fskip(ByteIOContext *s, offset_t offset);
|
---|
156 | offset_t url_ftell(ByteIOContext *s);
|
---|
157 | offset_t url_fsize(ByteIOContext *s);
|
---|
158 | int url_feof(ByteIOContext *s);
|
---|
159 | int url_ferror(ByteIOContext *s);
|
---|
160 |
|
---|
161 | #define URL_EOF (-1)
|
---|
162 | /** @note return URL_EOF (-1) if EOF */
|
---|
163 | int url_fgetc(ByteIOContext *s);
|
---|
164 |
|
---|
165 | /** @warning currently size is limited */
|
---|
166 | #ifdef __GNUC__
|
---|
167 | int url_fprintf(ByteIOContext *s, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3)));
|
---|
168 | #else
|
---|
169 | int url_fprintf(ByteIOContext *s, const char *fmt, ...);
|
---|
170 | #endif
|
---|
171 |
|
---|
172 | /** @note unlike fgets, the EOL character is not returned and a whole
|
---|
173 | line is parsed. return NULL if first char read was EOF */
|
---|
174 | char *url_fgets(ByteIOContext *s, char *buf, int buf_size);
|
---|
175 |
|
---|
176 | void put_flush_packet(ByteIOContext *s);
|
---|
177 |
|
---|
178 | int get_buffer(ByteIOContext *s, unsigned char *buf, int size);
|
---|
179 | int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size);
|
---|
180 |
|
---|
181 | /** @note return 0 if EOF, so you cannot use it if EOF handling is
|
---|
182 | necessary */
|
---|
183 | int get_byte(ByteIOContext *s);
|
---|
184 | unsigned int get_le24(ByteIOContext *s);
|
---|
185 | unsigned int get_le32(ByteIOContext *s);
|
---|
186 | uint64_t get_le64(ByteIOContext *s);
|
---|
187 | unsigned int get_le16(ByteIOContext *s);
|
---|
188 |
|
---|
189 | char *get_strz(ByteIOContext *s, char *buf, int maxlen);
|
---|
190 | unsigned int get_be16(ByteIOContext *s);
|
---|
191 | unsigned int get_be24(ByteIOContext *s);
|
---|
192 | unsigned int get_be32(ByteIOContext *s);
|
---|
193 | uint64_t get_be64(ByteIOContext *s);
|
---|
194 |
|
---|
195 | static inline int url_is_streamed(ByteIOContext *s)
|
---|
196 | {
|
---|
197 | return s->is_streamed;
|
---|
198 | }
|
---|
199 |
|
---|
200 | int url_fdopen(ByteIOContext *s, URLContext *h);
|
---|
201 |
|
---|
202 | /** @warning must be called before any I/O */
|
---|
203 | int url_setbufsize(ByteIOContext *s, int buf_size);
|
---|
204 |
|
---|
205 | /** @note when opened as read/write, the buffers are only used for
|
---|
206 | reading */
|
---|
207 | int url_fopen(ByteIOContext *s, const char *filename, int flags);
|
---|
208 | int url_fclose(ByteIOContext *s);
|
---|
209 | URLContext *url_fileno(ByteIOContext *s);
|
---|
210 |
|
---|
211 | /**
|
---|
212 | * Return the maximum packet size associated to packetized buffered file
|
---|
213 | * handle. If the file is not packetized (stream like http or file on
|
---|
214 | * disk), then 0 is returned.
|
---|
215 | *
|
---|
216 | * @param h buffered file handle
|
---|
217 | * @return maximum packet size in bytes
|
---|
218 | */
|
---|
219 | int url_fget_max_packet_size(ByteIOContext *s);
|
---|
220 |
|
---|
221 | int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags);
|
---|
222 |
|
---|
223 | /** return the written or read size */
|
---|
224 | int url_close_buf(ByteIOContext *s);
|
---|
225 |
|
---|
226 | /**
|
---|
227 | * Open a write only memory stream.
|
---|
228 | *
|
---|
229 | * @param s new IO context
|
---|
230 | * @return zero if no error.
|
---|
231 | */
|
---|
232 | int url_open_dyn_buf(ByteIOContext *s);
|
---|
233 |
|
---|
234 | /**
|
---|
235 | * Open a write only packetized memory stream with a maximum packet
|
---|
236 | * size of 'max_packet_size'. The stream is stored in a memory buffer
|
---|
237 | * with a big endian 4 byte header giving the packet size in bytes.
|
---|
238 | *
|
---|
239 | * @param s new IO context
|
---|
240 | * @param max_packet_size maximum packet size (must be > 0)
|
---|
241 | * @return zero if no error.
|
---|
242 | */
|
---|
243 | int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size);
|
---|
244 |
|
---|
245 | /**
|
---|
246 | * Return the written size and a pointer to the buffer. The buffer
|
---|
247 | * must be freed with av_free().
|
---|
248 | * @param s IO context
|
---|
249 | * @param pointer to a byte buffer
|
---|
250 | * @return the length of the byte buffer
|
---|
251 | */
|
---|
252 | int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer);
|
---|
253 |
|
---|
254 | unsigned long get_checksum(ByteIOContext *s);
|
---|
255 | void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum);
|
---|
256 |
|
---|
257 | /* file.c */
|
---|
258 | extern URLProtocol file_protocol;
|
---|
259 | extern URLProtocol pipe_protocol;
|
---|
260 |
|
---|
261 | /* udp.c */
|
---|
262 | extern URLProtocol udp_protocol;
|
---|
263 | int udp_set_remote_url(URLContext *h, const char *uri);
|
---|
264 | int udp_get_local_port(URLContext *h);
|
---|
265 | int udp_get_file_handle(URLContext *h);
|
---|
266 |
|
---|
267 | /* tcp.c */
|
---|
268 | extern URLProtocol tcp_protocol;
|
---|
269 |
|
---|
270 | /* http.c */
|
---|
271 | extern URLProtocol http_protocol;
|
---|
272 |
|
---|
273 | #endif
|
---|
274 |
|
---|