Statistics
| Branch: | Revision:

ffmpeg / libavformat / avio.h @ a8c5ab27

History | View | Annotate | Download (8.62 KB)

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
/* output byte stream handling */
25

    
26
typedef int64_t offset_t;
27

    
28
/* unbuffered I/O */
29

    
30
struct URLContext {
31
    struct URLProtocol *prot;
32
    int flags;
33
    int is_streamed;  /* true if streamed (no seek possible), default = false */
34
    int max_packet_size;  /* if non zero, the stream is packetized with this max packet size */
35
    void *priv_data;
36
#if LIBAVFORMAT_VERSION_INT >= (52<<16)
37
    char *filename; /* specified filename */
38
#else
39
    char filename[1]; /* specified filename */
40
#endif
41
};
42

    
43
typedef struct URLContext URLContext;
44

    
45
typedef struct URLPollEntry {
46
    URLContext *handle;
47
    int events;
48
    int revents;
49
} URLPollEntry;
50

    
51
#define URL_RDONLY 0
52
#define URL_WRONLY 1
53
#define URL_RDWR   2
54

    
55
typedef int URLInterruptCB(void);
56

    
57
int url_open(URLContext **h, const char *filename, int flags);
58
int url_read(URLContext *h, unsigned char *buf, int size);
59
int url_write(URLContext *h, unsigned char *buf, int size);
60
offset_t url_seek(URLContext *h, offset_t pos, int whence);
61
int url_close(URLContext *h);
62
int url_exist(const char *filename);
63
offset_t url_filesize(URLContext *h);
64
int url_get_max_packet_size(URLContext *h);
65
void url_get_filename(URLContext *h, char *buf, int buf_size);
66

    
67
/* the callback is called in blocking functions to test regulary if
68
   asynchronous interruption is needed. AVERROR(EINTR) is returned
69
   in this case by the interrupted function. 'NULL' means no interrupt
70
   callback is given. */
71
void url_set_interrupt_cb(URLInterruptCB *interrupt_cb);
72

    
73
/* not implemented */
74
int url_poll(URLPollEntry *poll_table, int n, int timeout);
75

    
76
/**
77
 * passing this as the "whence" parameter to a seek function causes it to
78
 * return the filesize without seeking anywhere, supporting this is optional
79
 * if its not supprted then the seek function will return <0
80
 */
81
#define AVSEEK_SIZE 0x10000
82

    
83
typedef struct URLProtocol {
84
    const char *name;
85
    int (*url_open)(URLContext *h, const char *filename, int flags);
86
    int (*url_read)(URLContext *h, unsigned char *buf, int size);
87
    int (*url_write)(URLContext *h, unsigned char *buf, int size);
88
    offset_t (*url_seek)(URLContext *h, offset_t pos, int whence);
89
    int (*url_close)(URLContext *h);
90
    struct URLProtocol *next;
91
} URLProtocol;
92

    
93
extern URLProtocol *first_protocol;
94
extern URLInterruptCB *url_interrupt_cb;
95

    
96
int register_protocol(URLProtocol *protocol);
97

    
98
typedef struct {
99
    unsigned char *buffer;
100
    int buffer_size;
101
    unsigned char *buf_ptr, *buf_end;
102
    void *opaque;
103
    int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
104
    int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
105
    offset_t (*seek)(void *opaque, offset_t offset, int whence);
106
    offset_t pos; /* position in the file of the current buffer */
107
    int must_flush; /* true if the next seek should flush */
108
    int eof_reached; /* true if eof reached */
109
    int write_flag;  /* true if open for writing */
110
    int is_streamed;
111
    int max_packet_size;
112
    unsigned long checksum;
113
    unsigned char *checksum_ptr;
114
    unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
115
    int error;         ///< contains the error code or 0 if no error happened
116
} ByteIOContext;
117

    
118
int init_put_byte(ByteIOContext *s,
119
                  unsigned char *buffer,
120
                  int buffer_size,
121
                  int write_flag,
122
                  void *opaque,
123
                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
124
                  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
125
                  offset_t (*seek)(void *opaque, offset_t offset, int whence));
126

    
127
void put_byte(ByteIOContext *s, int b);
128
void put_buffer(ByteIOContext *s, const unsigned char *buf, int size);
129
void put_le64(ByteIOContext *s, uint64_t val);
130
void put_be64(ByteIOContext *s, uint64_t val);
131
void put_le32(ByteIOContext *s, unsigned int val);
132
void put_be32(ByteIOContext *s, unsigned int val);
133
void put_le24(ByteIOContext *s, unsigned int val);
134
void put_be24(ByteIOContext *s, unsigned int val);
135
void put_le16(ByteIOContext *s, unsigned int val);
136
void put_be16(ByteIOContext *s, unsigned int val);
137
void put_tag(ByteIOContext *s, const char *tag);
138

    
139
void put_strz(ByteIOContext *s, const char *buf);
140

    
141
offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence);
142
void url_fskip(ByteIOContext *s, offset_t offset);
143
offset_t url_ftell(ByteIOContext *s);
144
offset_t url_fsize(ByteIOContext *s);
145
int url_feof(ByteIOContext *s);
146
int url_ferror(ByteIOContext *s);
147

    
148
#define URL_EOF (-1)
149
/* NOTE: return URL_EOF (-1) if EOF */
150
int url_fgetc(ByteIOContext *s);
151

    
152
/* XXX: currently size is limited */
153
#ifdef __GNUC__
154
int url_fprintf(ByteIOContext *s, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3)));
155
#else
156
int url_fprintf(ByteIOContext *s, const char *fmt, ...);
157
#endif
158

    
159
/* note: unlike fgets, the EOL character is not returned and a whole
160
   line is parsed. return NULL if first char read was EOF */
161
char *url_fgets(ByteIOContext *s, char *buf, int buf_size);
162

    
163
void put_flush_packet(ByteIOContext *s);
164

    
165
int get_buffer(ByteIOContext *s, unsigned char *buf, int size);
166
int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size);
167

    
168
/* NOTE: return 0 if EOF, so you cannot use it if EOF handling is
169
   necessary */
170
int get_byte(ByteIOContext *s);
171
unsigned int get_le24(ByteIOContext *s);
172
unsigned int get_le32(ByteIOContext *s);
173
uint64_t get_le64(ByteIOContext *s);
174
unsigned int get_le16(ByteIOContext *s);
175

    
176
char *get_strz(ByteIOContext *s, char *buf, int maxlen);
177
unsigned int get_be16(ByteIOContext *s);
178
unsigned int get_be24(ByteIOContext *s);
179
unsigned int get_be32(ByteIOContext *s);
180
uint64_t get_be64(ByteIOContext *s);
181

    
182
static inline int url_is_streamed(ByteIOContext *s)
183
{
184
    return s->is_streamed;
185
}
186

    
187
int url_fdopen(ByteIOContext *s, URLContext *h);
188

    
189
/* XXX: must be called before any I/O */
190
int url_setbufsize(ByteIOContext *s, int buf_size);
191

    
192
/* NOTE: when opened as read/write, the buffers are only used for
193
   reading */
194
int url_fopen(ByteIOContext *s, const char *filename, int flags);
195
int url_fclose(ByteIOContext *s);
196
URLContext *url_fileno(ByteIOContext *s);
197

    
198
/*
199
 * Return the maximum packet size associated to packetized buffered file
200
 * handle. If the file is not packetized (stream like http or file on
201
 * disk), then 0 is returned.
202
 *
203
 * @param h buffered file handle
204
 * @return maximum packet size in bytes
205
 */
206
int url_fget_max_packet_size(ByteIOContext *s);
207

    
208
int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags);
209

    
210
/* return the written or read size */
211
int url_close_buf(ByteIOContext *s);
212

    
213
/*
214
 * Open a write only memory stream.
215
 *
216
 * @param s new IO context
217
 * @return zero if no error.
218
 */
219
int url_open_dyn_buf(ByteIOContext *s);
220

    
221
/*
222
 * Open a write only packetized memory stream with a maximum packet
223
 * size of 'max_packet_size'.  The stream is stored in a memory buffer
224
 * with a big endian 4 byte header giving the packet size in bytes.
225
 *
226
 * @param s new IO context
227
 * @param max_packet_size maximum packet size (must be > 0)
228
 * @return zero if no error.
229
 */
230
int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size);
231

    
232
/*
233
 * Return the written size and a pointer to the buffer. The buffer
234
 *  must be freed with av_free().
235
 * @param s IO context
236
 * @param pointer to a byte buffer
237
 * @return the length of the byte buffer
238
 */
239
int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer);
240

    
241
unsigned long get_checksum(ByteIOContext *s);
242
void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum);
243

    
244
/* file.c */
245
extern URLProtocol file_protocol;
246
extern URLProtocol pipe_protocol;
247

    
248
/* udp.c */
249
extern URLProtocol udp_protocol;
250
int udp_set_remote_url(URLContext *h, const char *uri);
251
int udp_get_local_port(URLContext *h);
252
int udp_get_file_handle(URLContext *h);
253

    
254
/* tcp.c  */
255
extern URLProtocol tcp_protocol;
256

    
257
/* http.c */
258
extern URLProtocol http_protocol;
259

    
260
#endif
261