libavformat/avio.h

   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