| 1 | /* |
| 2 | * copyright (c) 2001 Fabrice Bellard |
| 3 | * |
| 4 | * This file is part of FFmpeg. |
| 5 | * |
| 6 | * FFmpeg is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU Lesser General Public |
| 8 | * License as published by the Free Software Foundation; either |
| 9 | * version 2.1 of the License, or (at your option) any later version. |
| 10 | * |
| 11 | * FFmpeg is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 | * Lesser General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU Lesser General Public |
| 17 | * License along with FFmpeg; if not, write to the Free Software |
| 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 19 | */ |
| 20 | #ifndef AVFORMAT_AVIO_H |
| 21 | #define AVFORMAT_AVIO_H |
| 22 | |
| 23 | /** |
| 24 | * @file |
| 25 | * @ingroup lavf_io |
| 26 | * Buffered I/O operations |
| 27 | */ |
| 28 | |
| 29 | #include <stdint.h> |
| 30 | |
| 31 | #include "libavutil/common.h" |
| 32 | #include "libavutil/dict.h" |
| 33 | #include "libavutil/log.h" |
| 34 | |
| 35 | #include "libavformat/version.h" |
| 36 | |
| 37 | |
| 38 | #define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */ |
| 39 | |
| 40 | /** |
| 41 | * Callback for checking whether to abort blocking functions. |
| 42 | * AVERROR_EXIT is returned in this case by the interrupted |
| 43 | * function. During blocking operations, callback is called with |
| 44 | * opaque as parameter. If the callback returns 1, the |
| 45 | * blocking operation will be aborted. |
| 46 | * |
| 47 | * No members can be added to this struct without a major bump, if |
| 48 | * new elements have been added after this struct in AVFormatContext |
| 49 | * or AVIOContext. |
| 50 | */ |
| 51 | typedef struct AVIOInterruptCB { |
| 52 | int (*callback)(void*); |
| 53 | void *opaque; |
| 54 | } AVIOInterruptCB; |
| 55 | |
| 56 | /** |
| 57 | * Bytestream IO Context. |
| 58 | * New fields can be added to the end with minor version bumps. |
| 59 | * Removal, reordering and changes to existing fields require a major |
| 60 | * version bump. |
| 61 | * sizeof(AVIOContext) must not be used outside libav*. |
| 62 | * |
| 63 | * @note None of the function pointers in AVIOContext should be called |
| 64 | * directly, they should only be set by the client application |
| 65 | * when implementing custom I/O. Normally these are set to the |
| 66 | * function pointers specified in avio_alloc_context() |
| 67 | */ |
| 68 | typedef struct AVIOContext { |
| 69 | /** |
| 70 | * A class for private options. |
| 71 | * |
| 72 | * If this AVIOContext is created by avio_open2(), av_class is set and |
| 73 | * passes the options down to protocols. |
| 74 | * |
| 75 | * If this AVIOContext is manually allocated, then av_class may be set by |
| 76 | * the caller. |
| 77 | * |
| 78 | * warning -- this field can be NULL, be sure to not pass this AVIOContext |
| 79 | * to any av_opt_* functions in that case. |
| 80 | */ |
| 81 | const AVClass *av_class; |
| 82 | unsigned char *buffer; /**< Start of the buffer. */ |
| 83 | int buffer_size; /**< Maximum buffer size */ |
| 84 | unsigned char *buf_ptr; /**< Current position in the buffer */ |
| 85 | unsigned char *buf_end; /**< End of the data, may be less than |
| 86 | buffer+buffer_size if the read function returned |
| 87 | less data than requested, e.g. for streams where |
| 88 | no more data has been received yet. */ |
| 89 | void *opaque; /**< A private pointer, passed to the read/write/seek/... |
| 90 | functions. */ |
| 91 | int (*read_packet)(void *opaque, uint8_t *buf, int buf_size); |
| 92 | int (*write_packet)(void *opaque, uint8_t *buf, int buf_size); |
| 93 | int64_t (*seek)(void *opaque, int64_t offset, int whence); |
| 94 | int64_t pos; /**< position in the file of the current buffer */ |
| 95 | int must_flush; /**< true if the next seek should flush */ |
| 96 | int eof_reached; /**< true if eof reached */ |
| 97 | int write_flag; /**< true if open for writing */ |
| 98 | int max_packet_size; |
| 99 | unsigned long checksum; |
| 100 | unsigned char *checksum_ptr; |
| 101 | unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size); |
| 102 | int error; /**< contains the error code or 0 if no error happened */ |
| 103 | /** |
| 104 | * Pause or resume playback for network streaming protocols - e.g. MMS. |
| 105 | */ |
| 106 | int (*read_pause)(void *opaque, int pause); |
| 107 | /** |
| 108 | * Seek to a given timestamp in stream with the specified stream_index. |
| 109 | * Needed for some network streaming protocols which don't support seeking |
| 110 | * to byte position. |
| 111 | */ |
| 112 | int64_t (*read_seek)(void *opaque, int stream_index, |
| 113 | int64_t timestamp, int flags); |
| 114 | /** |
| 115 | * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable. |
| 116 | */ |
| 117 | int seekable; |
| 118 | |
| 119 | /** |
| 120 | * max filesize, used to limit allocations |
| 121 | * This field is internal to libavformat and access from outside is not allowed. |
| 122 | */ |
| 123 | int64_t maxsize; |
| 124 | |
| 125 | /** |
| 126 | * avio_read and avio_write should if possible be satisfied directly |
| 127 | * instead of going through a buffer, and avio_seek will always |
| 128 | * call the underlying seek function directly. |
| 129 | */ |
| 130 | int direct; |
| 131 | |
| 132 | /** |
| 133 | * Bytes read statistic |
| 134 | * This field is internal to libavformat and access from outside is not allowed. |
| 135 | */ |
| 136 | int64_t bytes_read; |
| 137 | |
| 138 | /** |
| 139 | * seek statistic |
| 140 | * This field is internal to libavformat and access from outside is not allowed. |
| 141 | */ |
| 142 | int seek_count; |
| 143 | |
| 144 | /** |
| 145 | * writeout statistic |
| 146 | * This field is internal to libavformat and access from outside is not allowed. |
| 147 | */ |
| 148 | int writeout_count; |
| 149 | |
| 150 | /** |
| 151 | * Original buffer size |
| 152 | * used internally after probing and ensure seekback to reset the buffer size |
| 153 | * This field is internal to libavformat and access from outside is not allowed. |
| 154 | */ |
| 155 | int orig_buffer_size; |
| 156 | } AVIOContext; |
| 157 | |
| 158 | /* unbuffered I/O */ |
| 159 | |
| 160 | /** |
| 161 | * Return the name of the protocol that will handle the passed URL. |
| 162 | * |
| 163 | * NULL is returned if no protocol could be found for the given URL. |
| 164 | * |
| 165 | * @return Name of the protocol or NULL. |
| 166 | */ |
| 167 | const char *avio_find_protocol_name(const char *url); |
| 168 | |
| 169 | /** |
| 170 | * Return AVIO_FLAG_* access flags corresponding to the access permissions |
| 171 | * of the resource in url, or a negative value corresponding to an |
| 172 | * AVERROR code in case of failure. The returned access flags are |
| 173 | * masked by the value in flags. |
| 174 | * |
| 175 | * @note This function is intrinsically unsafe, in the sense that the |
| 176 | * checked resource may change its existence or permission status from |
| 177 | * one call to another. Thus you should not trust the returned value, |
| 178 | * unless you are sure that no other processes are accessing the |
| 179 | * checked resource. |
| 180 | */ |
| 181 | int avio_check(const char *url, int flags); |
| 182 | |
| 183 | /** |
| 184 | * Allocate and initialize an AVIOContext for buffered I/O. It must be later |
| 185 | * freed with av_free(). |
| 186 | * |
| 187 | * @param buffer Memory block for input/output operations via AVIOContext. |
| 188 | * The buffer must be allocated with av_malloc() and friends. |
| 189 | * It may be freed and replaced with a new buffer by libavformat. |
| 190 | * AVIOContext.buffer holds the buffer currently in use, |
| 191 | * which must be later freed with av_free(). |
| 192 | * @param buffer_size The buffer size is very important for performance. |
| 193 | * For protocols with fixed blocksize it should be set to this blocksize. |
| 194 | * For others a typical size is a cache page, e.g. 4kb. |
| 195 | * @param write_flag Set to 1 if the buffer should be writable, 0 otherwise. |
| 196 | * @param opaque An opaque pointer to user-specific data. |
| 197 | * @param read_packet A function for refilling the buffer, may be NULL. |
| 198 | * @param write_packet A function for writing the buffer contents, may be NULL. |
| 199 | * The function may not change the input buffers content. |
| 200 | * @param seek A function for seeking to specified byte position, may be NULL. |
| 201 | * |
| 202 | * @return Allocated AVIOContext or NULL on failure. |
| 203 | */ |
| 204 | AVIOContext *avio_alloc_context( |
| 205 | unsigned char *buffer, |
| 206 | int buffer_size, |
| 207 | int write_flag, |
| 208 | void *opaque, |
| 209 | int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), |
| 210 | int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), |
| 211 | int64_t (*seek)(void *opaque, int64_t offset, int whence)); |
| 212 | |
| 213 | void avio_w8(AVIOContext *s, int b); |
| 214 | void avio_write(AVIOContext *s, const unsigned char *buf, int size); |
| 215 | void avio_wl64(AVIOContext *s, uint64_t val); |
| 216 | void avio_wb64(AVIOContext *s, uint64_t val); |
| 217 | void avio_wl32(AVIOContext *s, unsigned int val); |
| 218 | void avio_wb32(AVIOContext *s, unsigned int val); |
| 219 | void avio_wl24(AVIOContext *s, unsigned int val); |
| 220 | void avio_wb24(AVIOContext *s, unsigned int val); |
| 221 | void avio_wl16(AVIOContext *s, unsigned int val); |
| 222 | void avio_wb16(AVIOContext *s, unsigned int val); |
| 223 | |
| 224 | /** |
| 225 | * Write a NULL-terminated string. |
| 226 | * @return number of bytes written. |
| 227 | */ |
| 228 | int avio_put_str(AVIOContext *s, const char *str); |
| 229 | |
| 230 | /** |
| 231 | * Convert an UTF-8 string to UTF-16LE and write it. |
| 232 | * @return number of bytes written. |
| 233 | */ |
| 234 | int avio_put_str16le(AVIOContext *s, const char *str); |
| 235 | |
| 236 | /** |
| 237 | * Passing this as the "whence" parameter to a seek function causes it to |
| 238 | * return the filesize without seeking anywhere. Supporting this is optional. |
| 239 | * If it is not supported then the seek function will return <0. |
| 240 | */ |
| 241 | #define AVSEEK_SIZE 0x10000 |
| 242 | |
| 243 | /** |
| 244 | * Oring this flag as into the "whence" parameter to a seek function causes it to |
| 245 | * seek by any means (like reopening and linear reading) or other normally unreasonable |
| 246 | * means that can be extremely slow. |
| 247 | * This may be ignored by the seek code. |
| 248 | */ |
| 249 | #define AVSEEK_FORCE 0x20000 |
| 250 | |
| 251 | /** |
| 252 | * fseek() equivalent for AVIOContext. |
| 253 | * @return new position or AVERROR. |
| 254 | */ |
| 255 | int64_t avio_seek(AVIOContext *s, int64_t offset, int whence); |
| 256 | |
| 257 | /** |
| 258 | * Skip given number of bytes forward |
| 259 | * @return new position or AVERROR. |
| 260 | */ |
| 261 | int64_t avio_skip(AVIOContext *s, int64_t offset); |
| 262 | |
| 263 | /** |
| 264 | * ftell() equivalent for AVIOContext. |
| 265 | * @return position or AVERROR. |
| 266 | */ |
| 267 | static av_always_inline int64_t avio_tell(AVIOContext *s) |
| 268 | { |
| 269 | return avio_seek(s, 0, SEEK_CUR); |
| 270 | } |
| 271 | |
| 272 | /** |
| 273 | * Get the filesize. |
| 274 | * @return filesize or AVERROR |
| 275 | */ |
| 276 | int64_t avio_size(AVIOContext *s); |
| 277 | |
| 278 | /** |
| 279 | * feof() equivalent for AVIOContext. |
| 280 | * @return non zero if and only if end of file |
| 281 | */ |
| 282 | int avio_feof(AVIOContext *s); |
| 283 | #if FF_API_URL_FEOF |
| 284 | /** |
| 285 | * @deprecated use avio_feof() |
| 286 | */ |
| 287 | attribute_deprecated |
| 288 | int url_feof(AVIOContext *s); |
| 289 | #endif |
| 290 | |
| 291 | /** @warning currently size is limited */ |
| 292 | int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3); |
| 293 | |
| 294 | /** |
| 295 | * Force flushing of buffered data. |
| 296 | * |
| 297 | * For write streams, force the buffered data to be immediately written to the output, |
| 298 | * without to wait to fill the internal buffer. |
| 299 | * |
| 300 | * For read streams, discard all currently buffered data, and advance the |
| 301 | * reported file position to that of the underlying stream. This does not |
| 302 | * read new data, and does not perform any seeks. |
| 303 | */ |
| 304 | void avio_flush(AVIOContext *s); |
| 305 | |
| 306 | /** |
| 307 | * Read size bytes from AVIOContext into buf. |
| 308 | * @return number of bytes read or AVERROR |
| 309 | */ |
| 310 | int avio_read(AVIOContext *s, unsigned char *buf, int size); |
| 311 | |
| 312 | /** |
| 313 | * @name Functions for reading from AVIOContext |
| 314 | * @{ |
| 315 | * |
| 316 | * @note return 0 if EOF, so you cannot use it if EOF handling is |
| 317 | * necessary |
| 318 | */ |
| 319 | int avio_r8 (AVIOContext *s); |
| 320 | unsigned int avio_rl16(AVIOContext *s); |
| 321 | unsigned int avio_rl24(AVIOContext *s); |
| 322 | unsigned int avio_rl32(AVIOContext *s); |
| 323 | uint64_t avio_rl64(AVIOContext *s); |
| 324 | unsigned int avio_rb16(AVIOContext *s); |
| 325 | unsigned int avio_rb24(AVIOContext *s); |
| 326 | unsigned int avio_rb32(AVIOContext *s); |
| 327 | uint64_t avio_rb64(AVIOContext *s); |
| 328 | /** |
| 329 | * @} |
| 330 | */ |
| 331 | |
| 332 | /** |
| 333 | * Read a string from pb into buf. The reading will terminate when either |
| 334 | * a NULL character was encountered, maxlen bytes have been read, or nothing |
| 335 | * more can be read from pb. The result is guaranteed to be NULL-terminated, it |
| 336 | * will be truncated if buf is too small. |
| 337 | * Note that the string is not interpreted or validated in any way, it |
| 338 | * might get truncated in the middle of a sequence for multi-byte encodings. |
| 339 | * |
| 340 | * @return number of bytes read (is always <= maxlen). |
| 341 | * If reading ends on EOF or error, the return value will be one more than |
| 342 | * bytes actually read. |
| 343 | */ |
| 344 | int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen); |
| 345 | |
| 346 | /** |
| 347 | * Read a UTF-16 string from pb and convert it to UTF-8. |
| 348 | * The reading will terminate when either a null or invalid character was |
| 349 | * encountered or maxlen bytes have been read. |
| 350 | * @return number of bytes read (is always <= maxlen) |
| 351 | */ |
| 352 | int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen); |
| 353 | int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen); |
| 354 | |
| 355 | |
| 356 | /** |
| 357 | * @name URL open modes |
| 358 | * The flags argument to avio_open must be one of the following |
| 359 | * constants, optionally ORed with other flags. |
| 360 | * @{ |
| 361 | */ |
| 362 | #define AVIO_FLAG_READ 1 /**< read-only */ |
| 363 | #define AVIO_FLAG_WRITE 2 /**< write-only */ |
| 364 | #define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE) /**< read-write pseudo flag */ |
| 365 | /** |
| 366 | * @} |
| 367 | */ |
| 368 | |
| 369 | /** |
| 370 | * Use non-blocking mode. |
| 371 | * If this flag is set, operations on the context will return |
| 372 | * AVERROR(EAGAIN) if they can not be performed immediately. |
| 373 | * If this flag is not set, operations on the context will never return |
| 374 | * AVERROR(EAGAIN). |
| 375 | * Note that this flag does not affect the opening/connecting of the |
| 376 | * context. Connecting a protocol will always block if necessary (e.g. on |
| 377 | * network protocols) but never hang (e.g. on busy devices). |
| 378 | * Warning: non-blocking protocols is work-in-progress; this flag may be |
| 379 | * silently ignored. |
| 380 | */ |
| 381 | #define AVIO_FLAG_NONBLOCK 8 |
| 382 | |
| 383 | /** |
| 384 | * Use direct mode. |
| 385 | * avio_read and avio_write should if possible be satisfied directly |
| 386 | * instead of going through a buffer, and avio_seek will always |
| 387 | * call the underlying seek function directly. |
| 388 | */ |
| 389 | #define AVIO_FLAG_DIRECT 0x8000 |
| 390 | |
| 391 | /** |
| 392 | * Create and initialize a AVIOContext for accessing the |
| 393 | * resource indicated by url. |
| 394 | * @note When the resource indicated by url has been opened in |
| 395 | * read+write mode, the AVIOContext can be used only for writing. |
| 396 | * |
| 397 | * @param s Used to return the pointer to the created AVIOContext. |
| 398 | * In case of failure the pointed to value is set to NULL. |
| 399 | * @param url resource to access |
| 400 | * @param flags flags which control how the resource indicated by url |
| 401 | * is to be opened |
| 402 | * @return >= 0 in case of success, a negative value corresponding to an |
| 403 | * AVERROR code in case of failure |
| 404 | */ |
| 405 | int avio_open(AVIOContext **s, const char *url, int flags); |
| 406 | |
| 407 | /** |
| 408 | * Create and initialize a AVIOContext for accessing the |
| 409 | * resource indicated by url. |
| 410 | * @note When the resource indicated by url has been opened in |
| 411 | * read+write mode, the AVIOContext can be used only for writing. |
| 412 | * |
| 413 | * @param s Used to return the pointer to the created AVIOContext. |
| 414 | * In case of failure the pointed to value is set to NULL. |
| 415 | * @param url resource to access |
| 416 | * @param flags flags which control how the resource indicated by url |
| 417 | * is to be opened |
| 418 | * @param int_cb an interrupt callback to be used at the protocols level |
| 419 | * @param options A dictionary filled with protocol-private options. On return |
| 420 | * this parameter will be destroyed and replaced with a dict containing options |
| 421 | * that were not found. May be NULL. |
| 422 | * @return >= 0 in case of success, a negative value corresponding to an |
| 423 | * AVERROR code in case of failure |
| 424 | */ |
| 425 | int avio_open2(AVIOContext **s, const char *url, int flags, |
| 426 | const AVIOInterruptCB *int_cb, AVDictionary **options); |
| 427 | |
| 428 | /** |
| 429 | * Close the resource accessed by the AVIOContext s and free it. |
| 430 | * This function can only be used if s was opened by avio_open(). |
| 431 | * |
| 432 | * The internal buffer is automatically flushed before closing the |
| 433 | * resource. |
| 434 | * |
| 435 | * @return 0 on success, an AVERROR < 0 on error. |
| 436 | * @see avio_closep |
| 437 | */ |
| 438 | int avio_close(AVIOContext *s); |
| 439 | |
| 440 | /** |
| 441 | * Close the resource accessed by the AVIOContext *s, free it |
| 442 | * and set the pointer pointing to it to NULL. |
| 443 | * This function can only be used if s was opened by avio_open(). |
| 444 | * |
| 445 | * The internal buffer is automatically flushed before closing the |
| 446 | * resource. |
| 447 | * |
| 448 | * @return 0 on success, an AVERROR < 0 on error. |
| 449 | * @see avio_close |
| 450 | */ |
| 451 | int avio_closep(AVIOContext **s); |
| 452 | |
| 453 | |
| 454 | /** |
| 455 | * Open a write only memory stream. |
| 456 | * |
| 457 | * @param s new IO context |
| 458 | * @return zero if no error. |
| 459 | */ |
| 460 | int avio_open_dyn_buf(AVIOContext **s); |
| 461 | |
| 462 | /** |
| 463 | * Return the written size and a pointer to the buffer. The buffer |
| 464 | * must be freed with av_free(). |
| 465 | * Padding of FF_INPUT_BUFFER_PADDING_SIZE is added to the buffer. |
| 466 | * |
| 467 | * @param s IO context |
| 468 | * @param pbuffer pointer to a byte buffer |
| 469 | * @return the length of the byte buffer |
| 470 | */ |
| 471 | int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer); |
| 472 | |
| 473 | /** |
| 474 | * Iterate through names of available protocols. |
| 475 | * |
| 476 | * @param opaque A private pointer representing current protocol. |
| 477 | * It must be a pointer to NULL on first iteration and will |
| 478 | * be updated by successive calls to avio_enum_protocols. |
| 479 | * @param output If set to 1, iterate over output protocols, |
| 480 | * otherwise over input protocols. |
| 481 | * |
| 482 | * @return A static string containing the name of current protocol or NULL |
| 483 | */ |
| 484 | const char *avio_enum_protocols(void **opaque, int output); |
| 485 | |
| 486 | /** |
| 487 | * Pause and resume playing - only meaningful if using a network streaming |
| 488 | * protocol (e.g. MMS). |
| 489 | * |
| 490 | * @param h IO context from which to call the read_pause function pointer |
| 491 | * @param pause 1 for pause, 0 for resume |
| 492 | */ |
| 493 | int avio_pause(AVIOContext *h, int pause); |
| 494 | |
| 495 | /** |
| 496 | * Seek to a given timestamp relative to some component stream. |
| 497 | * Only meaningful if using a network streaming protocol (e.g. MMS.). |
| 498 | * |
| 499 | * @param h IO context from which to call the seek function pointers |
| 500 | * @param stream_index The stream index that the timestamp is relative to. |
| 501 | * If stream_index is (-1) the timestamp should be in AV_TIME_BASE |
| 502 | * units from the beginning of the presentation. |
| 503 | * If a stream_index >= 0 is used and the protocol does not support |
| 504 | * seeking based on component streams, the call will fail. |
| 505 | * @param timestamp timestamp in AVStream.time_base units |
| 506 | * or if there is no stream specified then in AV_TIME_BASE units. |
| 507 | * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE |
| 508 | * and AVSEEK_FLAG_ANY. The protocol may silently ignore |
| 509 | * AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will |
| 510 | * fail if used and not supported. |
| 511 | * @return >= 0 on success |
| 512 | * @see AVInputFormat::read_seek |
| 513 | */ |
| 514 | int64_t avio_seek_time(AVIOContext *h, int stream_index, |
| 515 | int64_t timestamp, int flags); |
| 516 | |
| 517 | /* Avoid a warning. The header can not be included because it breaks c++. */ |
| 518 | struct AVBPrint; |
| 519 | |
| 520 | /** |
| 521 | * Read contents of h into print buffer, up to max_size bytes, or up to EOF. |
| 522 | * |
| 523 | * @return 0 for success (max_size bytes read or EOF reached), negative error |
| 524 | * code otherwise |
| 525 | */ |
| 526 | int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size); |
| 527 | |
| 528 | #endif /* AVFORMAT_AVIO_H */ |