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