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 21 module ffmpeg.libavformat.avio; 22 23 /** 24 * @file 25 * @ingroup lavf_io 26 * Buffered I/O operations 27 */ 28 import std.stdint; 29 import std.stdio; 30 import ffmpeg.libavutil.avutil; 31 import ffmpeg.libavformat.avformat_version; 32 import ffmpeg.libavformat.url; 33 import ffmpeg.libavutil.dict; 34 35 @nogc nothrow extern(C): 36 37 const int AVIO_SEEKABLE_NORMAL = 0x0001; /**< Seeking works like for a local file */ 38 39 /** 40 * Callback for checking whether to abort blocking functions. 41 * AVERROR_EXIT is returned in this case by the interrupted 42 * function. During blocking operations, callback is called with 43 * opaque as parameter. If the callback returns 1, the 44 * blocking operation will be aborted. 45 * 46 * No members can be added to this struct without a major bump, if 47 * new elements have been added after this struct in AVFormatContext 48 * or AVIOContext. 49 */ 50 struct AVIOInterruptCB { 51 int function (void*) callback; 52 void *opaque; 53 } 54 55 /** 56 * Directory entry types. 57 */ 58 enum AVIODirEntryType { 59 AVIO_ENTRY_UNKNOWN, 60 AVIO_ENTRY_BLOCK_DEVICE, 61 AVIO_ENTRY_CHARACTER_DEVICE, 62 AVIO_ENTRY_DIRECTORY, 63 AVIO_ENTRY_NAMED_PIPE, 64 AVIO_ENTRY_SYMBOLIC_LINK, 65 AVIO_ENTRY_SOCKET, 66 AVIO_ENTRY_FILE, 67 AVIO_ENTRY_SERVER, 68 AVIO_ENTRY_SHARE, 69 AVIO_ENTRY_WORKGROUP 70 } 71 72 /** 73 * Describes single entry of the directory. 74 * 75 * Only name and type fields are guaranteed be set. 76 * Rest of fields are protocol or/and platform dependent and might be unknown. 77 */ 78 struct AVIODirEntry { 79 char *name; /**< Filename */ 80 int type; /**< Type of the entry */ 81 int utf8; /**< Set to 1 when name is encoded with UTF-8, 0 otherwise. 82 Name can be encoded with UTF-8 even though 0 is set. */ 83 int64_t size; /**< File size in bytes, -1 if unknown. */ 84 int64_t modification_timestamp; /**< Time of last modification in microseconds since unix 85 epoch, -1 if unknown. */ 86 int64_t access_timestamp; /**< Time of last access in microseconds since unix epoch, 87 -1 if unknown. */ 88 int64_t status_change_timestamp; /**< Time of last status change in microseconds since unix 89 epoch, -1 if unknown. */ 90 int64_t user_id; /**< User ID of owner, -1 if unknown. */ 91 int64_t group_id; /**< Group ID of owner, -1 if unknown. */ 92 int64_t filemode; /**< Unix file mode, -1 if unknown. */ 93 } 94 95 struct AVIODirContext { 96 URLContext *url_context; 97 } 98 99 /** 100 * Different data types that can be returned via the AVIO 101 * write_data_type callback. 102 */ 103 enum AVIODataMarkerType { 104 /** 105 * Header data; this needs to be present for the stream to be decodeable. 106 */ 107 AVIO_DATA_MARKER_HEADER, 108 /** 109 * A point in the output bytestream where a decoder can start decoding 110 * (i.e. a keyframe). A demuxer/decoder given the data flagged with 111 * AVIO_DATA_MARKER_HEADER, followed by any AVIO_DATA_MARKER_SYNC_POINT, 112 * should give decodeable results. 113 */ 114 AVIO_DATA_MARKER_SYNC_POINT, 115 /** 116 * A point in the output bytestream where a demuxer can start parsing 117 * (for non self synchronizing bytestream formats). That is, any 118 * non-keyframe packet start point. 119 */ 120 AVIO_DATA_MARKER_BOUNDARY_POINT, 121 /** 122 * This is any, unlabelled data. It can either be a muxer not marking 123 * any positions at all, it can be an actual boundary/sync point 124 * that the muxer chooses not to mark, or a later part of a packet/fragment 125 * that is cut into multiple write callbacks due to limited IO buffer size. 126 */ 127 AVIO_DATA_MARKER_UNKNOWN, 128 /** 129 * Trailer data, which doesn't contain actual content, but only for 130 * finalizing the output file. 131 */ 132 AVIO_DATA_MARKER_TRAILER 133 } 134 135 /** 136 * Bytestream IO Context. 137 * New fields can be added to the end with minor version bumps. 138 * Removal, reordering and changes to existing fields require a major 139 * version bump. 140 * sizeof(AVIOContext) must not be used outside libav*. 141 * 142 * @note None of the function pointers in AVIOContext should be called 143 * directly, they should only be set by the client application 144 * when implementing custom I/O. Normally these are set to the 145 * function pointers specified in avio_alloc_context() 146 */ 147 struct AVIOContext { 148 /** 149 * A class for private options. 150 * 151 * If this AVIOContext is created by avio_open2(), av_class is set and 152 * passes the options down to protocols. 153 * 154 * If this AVIOContext is manually allocated, then av_class may be set by 155 * the caller. 156 * 157 * warning -- this field can be NULL, be sure to not pass this AVIOContext 158 * to any av_opt_* functions in that case. 159 */ 160 const AVClass *av_class; 161 162 /* 163 * The following shows the relationship between buffer, buf_ptr, buf_end, buf_size, 164 * and pos, when reading and when writing (since AVIOContext is used for both): 165 * 166 ********************************************************************************** 167 * READING 168 ********************************************************************************** 169 * 170 * | buffer_size | 171 * |---------------------------------------| 172 * | | 173 * 174 * buffer buf_ptr buf_end 175 * +---------------+-----------------------+ 176 * |/ / / / / / / /|/ / / / / / /| | 177 * read buffer: |/ / consumed / | to be read /| | 178 * |/ / / / / / / /|/ / / / / / /| | 179 * +---------------+-----------------------+ 180 * 181 * pos 182 * +-------------------------------------------+-----------------+ 183 * input file: | | | 184 * +-------------------------------------------+-----------------+ 185 * 186 * 187 ********************************************************************************** 188 * WRITING 189 ********************************************************************************** 190 * 191 * | buffer_size | 192 * |-------------------------------| 193 * | | 194 * 195 * buffer buf_ptr buf_end 196 * +-------------------+-----------+ 197 * |/ / / / / / / / / /| | 198 * write buffer: | / to be flushed / | | 199 * |/ / / / / / / / / /| | 200 * +-------------------+-----------+ 201 * 202 * pos 203 * +--------------------------+-----------------------------------+ 204 * output file: | | | 205 * +--------------------------+-----------------------------------+ 206 * 207 */ 208 ubyte *buffer; /**< Start of the buffer. */ 209 int buffer_size; /**< Maximum buffer size */ 210 ubyte *buf_ptr; /**< Current position in the buffer */ 211 ubyte *buf_end; /**< End of the data, may be less than 212 buffer+buffer_size if the read function returned 213 less data than requested, e.g. for streams where 214 no more data has been received yet. */ 215 void *opaque; /**< A private pointer, passed to the read/write/seek/... 216 functions. */ 217 int function(void *opaque, uint8_t *buf, int buf_size) read_packet; 218 int function(void *opaque, uint8_t *buf, int buf_size) write_packet; 219 int64_t function(void *opaque, int64_t offset, int whence) seek; 220 int64_t pos; /**< position in the file of the current buffer */ 221 int must_flush; /**< true if the next seek should flush */ 222 int eof_reached; /**< true if eof reached */ 223 int write_flag; /**< true if open for writing */ 224 int max_packet_size; 225 uint checksum; 226 ubyte *checksum_ptr; 227 uint function(uint checksum, const uint8_t *buf, uint size) update_checksum; 228 int error; /**< contains the error code or 0 if no error happened */ 229 /** 230 * Pause or resume playback for network streaming protocols - e.g. MMS. 231 */ 232 int function(void *opaque, int pause) read_pause; 233 /** 234 * Seek to a given timestamp in stream with the specified stream_index. 235 * Needed for some network streaming protocols which don't support seeking 236 * to byte position. 237 */ 238 int64_t function(void *opaque, int stream_index, 239 int64_t timestamp, int flags) read_seek; 240 /** 241 * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable. 242 */ 243 int seekable; 244 245 /** 246 * max filesize, used to limit allocations 247 * This field is internal to libavformat and access from outside is not allowed. 248 */ 249 int64_t maxsize; 250 251 /** 252 * avio_read and avio_write should if possible be satisfied directly 253 * instead of going through a buffer, and avio_seek will always 254 * call the underlying seek function directly. 255 */ 256 int direct; 257 258 /** 259 * Bytes read statistic 260 * This field is internal to libavformat and access from outside is not allowed. 261 */ 262 int64_t bytes_read; 263 264 /** 265 * seek statistic 266 * This field is internal to libavformat and access from outside is not allowed. 267 */ 268 int seek_count; 269 270 /** 271 * writeout statistic 272 * This field is internal to libavformat and access from outside is not allowed. 273 */ 274 int writeout_count; 275 276 /** 277 * Original buffer size 278 * used internally after probing and ensure seekback to reset the buffer size 279 * This field is internal to libavformat and access from outside is not allowed. 280 */ 281 int orig_buffer_size; 282 283 /** 284 * Threshold to favor readahead over seek. 285 * This is current internal only, do not use from outside. 286 */ 287 int short_seek_threshold; 288 289 /** 290 * ',' separated list of allowed protocols. 291 */ 292 const char *protocol_whitelist; 293 294 /** 295 * ',' separated list of disallowed protocols. 296 */ 297 const char *protocol_blacklist; 298 299 /** 300 * A callback that is used instead of write_packet. 301 */ 302 int function(void *opaque, uint8_t *buf, int buf_size, 303 AVIODataMarkerType type, int64_t time) write_data_type; 304 /** 305 * If set, don't call write_data_type separately for AVIO_DATA_MARKER_BOUNDARY_POINT, 306 * but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly 307 * small chunks of data returned from the callback). 308 */ 309 int ignore_boundary_point; 310 311 /** 312 * Internal, not meant to be used from outside of AVIOContext. 313 */ 314 AVIODataMarkerType current_type; 315 int64_t last_time; 316 } 317 318 /** 319 * Return the name of the protocol that will handle the passed URL. 320 * 321 * NULL is returned if no protocol could be found for the given URL. 322 * 323 * @return Name of the protocol or NULL. 324 */ 325 char *avio_find_protocol_name(const char *url); 326 327 /** 328 * Return AVIO_FLAG_* access flags corresponding to the access permissions 329 * of the resource in url, or a negative value corresponding to an 330 * AVERROR code in case of failure. The returned access flags are 331 * masked by the value in flags. 332 * 333 * @note This function is intrinsically unsafe, in the sense that the 334 * checked resource may change its existence or permission status from 335 * one call to another. Thus you should not trust the returned value, 336 * unless you are sure that no other processes are accessing the 337 * checked resource. 338 */ 339 int avio_check(const char *url, int flags); 340 341 /** 342 * Move or rename a resource. 343 * 344 * @note url_src and url_dst should share the same protocol and authority. 345 * 346 * @param url_src url to resource to be moved 347 * @param url_dst new url to resource if the operation succeeded 348 * @return >=0 on success or negative on error. 349 */ 350 int avpriv_io_move(const char *url_src, const char *url_dst); 351 352 /** 353 * Delete a resource. 354 * 355 * @param url resource to be deleted. 356 * @return >=0 on success or negative on error. 357 */ 358 int avpriv_io_delete(const char *url); 359 360 /** 361 * Open directory for reading. 362 * 363 * @param s directory read context. Pointer to a NULL pointer must be passed. 364 * @param url directory to be listed. 365 * @param options A dictionary filled with protocol-private options. On return 366 * this parameter will be destroyed and replaced with a dictionary 367 * containing options that were not found. May be NULL. 368 * @return >=0 on success or negative on error. 369 */ 370 int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options); 371 372 /** 373 * Get next directory entry. 374 * 375 * Returned entry must be freed with avio_free_directory_entry(). In particular 376 * it may outlive AVIODirContext. 377 * 378 * @param s directory read context. 379 * @param[out] next next entry or NULL when no more entries. 380 * @return >=0 on success or negative on error. End of list is not considered an 381 * error. 382 */ 383 int avio_read_dir(AVIODirContext *s, AVIODirEntry **next); 384 385 /** 386 * Close directory. 387 * 388 * @note Entries created using avio_read_dir() are not deleted and must be 389 * freeded with avio_free_directory_entry(). 390 * 391 * @param s directory read context. 392 * @return >=0 on success or negative on error. 393 */ 394 int avio_close_dir(AVIODirContext **s); 395 396 /** 397 * Free entry allocated by avio_read_dir(). 398 * 399 * @param entry entry to be freed. 400 */ 401 void avio_free_directory_entry(AVIODirEntry **entry); 402 403 /** 404 * Allocate and initialize an AVIOContext for buffered I/O. It must be later 405 * freed with av_free(). 406 * 407 * @param buffer Memory block for input/output operations via AVIOContext. 408 * The buffer must be allocated with av_malloc() and friends. 409 * It may be freed and replaced with a new buffer by libavformat. 410 * AVIOContext.buffer holds the buffer currently in use, 411 * which must be later freed with av_free(). 412 * @param buffer_size The buffer size is very important for performance. 413 * For protocols with fixed blocksize it should be set to this blocksize. 414 * For others a typical size is a cache page, e.g. 4kb. 415 * @param write_flag Set to 1 if the buffer should be writable, 0 otherwise. 416 * @param opaque An opaque pointer to user-specific data. 417 * @param read_packet A function for refilling the buffer, may be NULL. 418 * @param write_packet A function for writing the buffer contents, may be NULL. 419 * The function may not change the input buffers content. 420 * @param seek A function for seeking to specified byte position, may be NULL. 421 * 422 * @return Allocated AVIOContext or NULL on failure. 423 */ 424 AVIOContext *avio_alloc_context( 425 ubyte *buffer, 426 int buffer_size, 427 int write_flag, 428 void *opaque, 429 int function(void *opaque, uint8_t *buf, int buf_size) read_packet, 430 int function(void *opaque, uint8_t *buf, int buf_size) write_packet, 431 int64_t function(void *opaque, int64_t offset, int whence) seek); 432 433 void avio_w8(AVIOContext *s, int b); 434 void avio_write(AVIOContext *s, const ubyte *buf, int size); 435 void avio_wl64(AVIOContext *s, uint64_t val); 436 void avio_wb64(AVIOContext *s, uint64_t val); 437 void avio_wl32(AVIOContext *s, uint val); 438 void avio_wb32(AVIOContext *s, uint val); 439 void avio_wl24(AVIOContext *s, uint val); 440 void avio_wb24(AVIOContext *s, uint val); 441 void avio_wl16(AVIOContext *s, uint val); 442 void avio_wb16(AVIOContext *s, uint val); 443 444 /** 445 * Write a NULL-terminated string. 446 * @return number of bytes written. 447 */ 448 int avio_put_str(AVIOContext *s, const char *str); 449 450 /** 451 * Convert an UTF-8 string to UTF-16LE and write it. 452 * @param s the AVIOContext 453 * @param str NULL-terminated UTF-8 string 454 * 455 * @return number of bytes written. 456 */ 457 int avio_put_str16le(AVIOContext *s, const char *str); 458 459 /** 460 * Convert an UTF-8 string to UTF-16BE and write it. 461 * @param s the AVIOContext 462 * @param str NULL-terminated UTF-8 string 463 * 464 * @return number of bytes written. 465 */ 466 int avio_put_str16be(AVIOContext *s, const char *str); 467 468 /** 469 * Mark the written bytestream as a specific type. 470 * 471 * Zero-length ranges are omitted from the output. 472 * 473 * @param time the stream time the current bytestream pos corresponds to 474 * (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not 475 * applicable 476 * @param type the kind of data written starting at the current pos 477 */ 478 void avio_write_marker(AVIOContext *s, int64_t time, AVIODataMarkerType type); 479 480 /** 481 * Passing this as the "whence" parameter to a seek function causes it to 482 * return the filesize without seeking anywhere. Supporting this is optional. 483 * If it is not supported then the seek function will return <0. 484 */ 485 enum AVSEEK_SIZE = 0x10000; 486 487 /** 488 * Oring this flag as into the "whence" parameter to a seek function causes it to 489 * seek by any means (like reopening and linear reading) or other normally unreasonable 490 * means that can be extremely slow. 491 * This may be ignored by the seek code. 492 */ 493 enum AVSEEK_FORCE = 0x20000; 494 495 /** 496 * fseek() equivalent for AVIOContext. 497 * @return new position or AVERROR. 498 */ 499 int64_t avio_seek(AVIOContext *s, int64_t offset, int whence); 500 501 /** 502 * Skip given number of bytes forward 503 * @return new position or AVERROR. 504 */ 505 int64_t avio_skip(AVIOContext *s, int64_t offset); 506 507 /** 508 * ftell() equivalent for AVIOContext. 509 * @return position or AVERROR. 510 */ 511 static int64_t avio_tell(AVIOContext *s) 512 { 513 return avio_seek(s, 0, SEEK_CUR); 514 } 515 516 /** 517 * Get the filesize. 518 * @return filesize or AVERROR 519 */ 520 int64_t avio_size(AVIOContext *s); 521 522 /** 523 * feof() equivalent for AVIOContext. 524 * @return non zero if and only if end of file 525 */ 526 int avio_feof(AVIOContext *s); 527 static if (FF_API_URL_FEOF) { 528 /** 529 * @deprecated use avio_feof() 530 */ 531 deprecated 532 int url_feof(AVIOContext *s); 533 } 534 535 /** @warning currently size is limited */ 536 int avio_printf(AVIOContext *s, const char *fmt, ...); 537 538 /** 539 * Force flushing of buffered data. 540 * 541 * For write streams, force the buffered data to be immediately written to the output, 542 * without to wait to fill the internal buffer. 543 * 544 * For read streams, discard all currently buffered data, and advance the 545 * reported file position to that of the underlying stream. This does not 546 * read new data, and does not perform any seeks. 547 */ 548 void avio_flush(AVIOContext *s); 549 550 /** 551 * Read size bytes from AVIOContext into buf. 552 * @return number of bytes read or AVERROR 553 */ 554 int avio_read(AVIOContext *s, ubyte *buf, int size); 555 556 /** 557 * @name Functions for reading from AVIOContext 558 * @{ 559 * 560 * @note return 0 if EOF, so you cannot use it if EOF handling is 561 * necessary 562 */ 563 int avio_r8 (AVIOContext *s); 564 uint avio_rl16(AVIOContext *s); 565 uint avio_rl24(AVIOContext *s); 566 uint avio_rl32(AVIOContext *s); 567 uint64_t avio_rl64(AVIOContext *s); 568 uint avio_rb16(AVIOContext *s); 569 uint avio_rb24(AVIOContext *s); 570 uint avio_rb32(AVIOContext *s); 571 uint64_t avio_rb64(AVIOContext *s); 572 /** 573 * @} 574 */ 575 576 /** 577 * Read a string from pb into buf. The reading will terminate when either 578 * a NULL character was encountered, maxlen bytes have been read, or nothing 579 * more can be read from pb. The result is guaranteed to be NULL-terminated, it 580 * will be truncated if buf is too small. 581 * Note that the string is not interpreted or validated in any way, it 582 * might get truncated in the middle of a sequence for multi-byte encodings. 583 * 584 * @return number of bytes read (is always <= maxlen). 585 * If reading ends on EOF or error, the return value will be one more than 586 * bytes actually read. 587 */ 588 int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen); 589 590 /** 591 * Read a UTF-16 string from pb and convert it to UTF-8. 592 * The reading will terminate when either a null or invalid character was 593 * encountered or maxlen bytes have been read. 594 * @return number of bytes read (is always <= maxlen) 595 */ 596 int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen); 597 int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen); 598 599 600 /** 601 * @name URL open modes 602 * The flags argument to avio_open must be one of the following 603 * constants, optionally ORed with other flags. 604 * @{ 605 */ 606 enum AVIO_FLAG_READ = 1; /**< read-only */ 607 enum AVIO_FLAG_WRITE = 2; /**< write-only */ 608 enum AVIO_FLAG_READ_WRITE = (AVIO_FLAG_READ|AVIO_FLAG_WRITE); /**< read-write pseudo flag */ 609 /** 610 * @} 611 */ 612 613 /** 614 * Use non-blocking mode. 615 * If this flag is set, operations on the context will return 616 * AVERROR(EAGAIN) if they can not be performed immediately. 617 * If this flag is not set, operations on the context will never return 618 * AVERROR(EAGAIN). 619 * Note that this flag does not affect the opening/connecting of the 620 * context. Connecting a protocol will always block if necessary (e.g. on 621 * network protocols) but never hang (e.g. on busy devices). 622 * Warning: non-blocking protocols is work-in-progress; this flag may be 623 * silently ignored. 624 */ 625 enum AVIO_FLAG_NONBLOCK = 8; 626 627 /** 628 * Use direct mode. 629 * avio_read and avio_write should if possible be satisfied directly 630 * instead of going through a buffer, and avio_seek will always 631 * call the underlying seek function directly. 632 */ 633 enum AVIO_FLAG_DIRECT = 0x8000; 634 635 /** 636 * Create and initialize a AVIOContext for accessing the 637 * resource indicated by url. 638 * @note When the resource indicated by url has been opened in 639 * read+write mode, the AVIOContext can be used only for writing. 640 * 641 * @param s Used to return the pointer to the created AVIOContext. 642 * In case of failure the pointed to value is set to NULL. 643 * @param url resource to access 644 * @param flags flags which control how the resource indicated by url 645 * is to be opened 646 * @return >= 0 in case of success, a negative value corresponding to an 647 * AVERROR code in case of failure 648 */ 649 int avio_open(AVIOContext **s, const char *url, int flags); 650 651 /** 652 * Create and initialize a AVIOContext for accessing the 653 * resource indicated by url. 654 * @note When the resource indicated by url has been opened in 655 * read+write mode, the AVIOContext can be used only for writing. 656 * 657 * @param s Used to return the pointer to the created AVIOContext. 658 * In case of failure the pointed to value is set to NULL. 659 * @param url resource to access 660 * @param flags flags which control how the resource indicated by url 661 * is to be opened 662 * @param int_cb an interrupt callback to be used at the protocols level 663 * @param options A dictionary filled with protocol-private options. On return 664 * this parameter will be destroyed and replaced with a dict containing options 665 * that were not found. May be NULL. 666 * @return >= 0 in case of success, a negative value corresponding to an 667 * AVERROR code in case of failure 668 */ 669 int avio_open2(AVIOContext **s, const char *url, int flags, 670 const AVIOInterruptCB *int_cb, AVDictionary **options); 671 672 /** 673 * Close the resource accessed by the AVIOContext s and free it. 674 * This function can only be used if s was opened by avio_open(). 675 * 676 * The internal buffer is automatically flushed before closing the 677 * resource. 678 * 679 * @return 0 on success, an AVERROR < 0 on error. 680 * @see avio_closep 681 */ 682 int avio_close(AVIOContext *s); 683 684 /** 685 * Close the resource accessed by the AVIOContext *s, free it 686 * and set the pointer pointing to it to NULL. 687 * This function can only be used if s was opened by avio_open(). 688 * 689 * The internal buffer is automatically flushed before closing the 690 * resource. 691 * 692 * @return 0 on success, an AVERROR < 0 on error. 693 * @see avio_close 694 */ 695 int avio_closep(AVIOContext **s); 696 697 698 /** 699 * Open a write only memory stream. 700 * 701 * @param s new IO context 702 * @return zero if no error. 703 */ 704 int avio_open_dyn_buf(AVIOContext **s); 705 706 /** 707 * Return the written size and a pointer to the buffer. The buffer 708 * must be freed with av_free(). 709 * Padding of FF_INPUT_BUFFER_PADDING_SIZE is added to the buffer. 710 * 711 * @param s IO context 712 * @param pbuffer pointer to a byte buffer 713 * @return the length of the byte buffer 714 */ 715 int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer); 716 717 /** 718 * Iterate through names of available protocols. 719 * 720 * @param opaque A private pointer representing current protocol. 721 * It must be a pointer to NULL on first iteration and will 722 * be updated by successive calls to avio_enum_protocols. 723 * @param output If set to 1, iterate over output protocols, 724 * otherwise over input protocols. 725 * 726 * @return A static string containing the name of current protocol or NULL 727 */ 728 char *avio_enum_protocols(void **opaque, int output); 729 730 /** 731 * Pause and resume playing - only meaningful if using a network streaming 732 * protocol (e.g. MMS). 733 * 734 * @param h IO context from which to call the read_pause function pointer 735 * @param pause 1 for pause, 0 for resume 736 */ 737 int avio_pause(AVIOContext *h, int pause); 738 739 /** 740 * Seek to a given timestamp relative to some component stream. 741 * Only meaningful if using a network streaming protocol (e.g. MMS.). 742 * 743 * @param h IO context from which to call the seek function pointers 744 * @param stream_index The stream index that the timestamp is relative to. 745 * If stream_index is (-1) the timestamp should be in AV_TIME_BASE 746 * units from the beginning of the presentation. 747 * If a stream_index >= 0 is used and the protocol does not support 748 * seeking based on component streams, the call will fail. 749 * @param timestamp timestamp in AVStream.time_base units 750 * or if there is no stream specified then in AV_TIME_BASE units. 751 * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE 752 * and AVSEEK_FLAG_ANY. The protocol may silently ignore 753 * AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will 754 * fail if used and not supported. 755 * @return >= 0 on success 756 * @see AVInputFormat::read_seek 757 */ 758 int64_t avio_seek_time(AVIOContext *h, int stream_index, 759 int64_t timestamp, int flags); 760 761 /* Avoid a warning. The header can not be included because it breaks c++. */ 762 struct AVBPrint; 763 764 /** 765 * Read contents of h into print buffer, up to max_size bytes, or up to EOF. 766 * 767 * @return 0 for success (max_size bytes read or EOF reached), negative error 768 * code otherwise 769 */ 770 int avio_read_to_bprint(AVIOContext *h, AVBPrint *pb, size_t max_size); 771 772 /** 773 * Accept and allocate a client context on a server context. 774 * @param s the server context 775 * @param c the client context, must be unallocated 776 * @return >= 0 on success or a negative value corresponding 777 * to an AVERROR on failure 778 */ 779 int avio_accept(AVIOContext *s, AVIOContext **c); 780 781 /** 782 * Perform one step of the protocol handshake to accept a new client. 783 * This function must be called on a client returned by avio_accept() before 784 * using it as a read/write context. 785 * It is separate from avio_accept() because it may block. 786 * A step of the handshake is defined by places where the application may 787 * decide to change the proceedings. 788 * For example, on a protocol with a request header and a reply header, each 789 * one can constitute a step because the application may use the parameters 790 * from the request to change parameters in the reply; or each individual 791 * chunk of the request can constitute a step. 792 * If the handshake is already finished, avio_handshake() does nothing and 793 * returns 0 immediately. 794 * 795 * @param c the client context to perform the handshake on 796 * @return 0 on a complete and successful handshake 797 * > 0 if the handshake progressed, but is not complete 798 * < 0 for an AVERROR code 799 */ 800 int avio_handshake(AVIOContext *c); 801 //#endif /* AVFORMAT_AVIO_H */