Struct AVIOContext 

#[repr(C)]
pub struct AVIOContext {

    pub av_class: *const AVClass,
    pub buffer: *mut c_uchar,
    pub buffer_size: c_int,
    pub buf_ptr: *mut c_uchar,
    pub buf_end: *mut c_uchar,
    pub opaque: *mut c_void,
    pub read_packet: Option<unsafe extern "C" fn(opaque: *mut c_void, buf: *mut u8, buf_size: c_int) -> c_int>,
    pub write_packet: Option<unsafe extern "C" fn(opaque: *mut c_void, buf: *mut u8, buf_size: c_int) -> c_int>,
    pub seek: Option<unsafe extern "C" fn(opaque: *mut c_void, offset: i64, whence: c_int) -> i64>,
    pub pos: i64,
    pub eof_reached: c_int,
    pub error: c_int,
    pub write_flag: c_int,
    pub max_packet_size: c_int,
    pub min_packet_size: c_int,
    pub checksum: c_ulong,
    pub checksum_ptr: *mut c_uchar,
    pub update_checksum: Option<unsafe extern "C" fn(checksum: c_ulong, buf: *const u8, size: c_uint) -> c_ulong>,
    pub read_pause: Option<unsafe extern "C" fn(opaque: *mut c_void, pause: c_int) -> c_int>,
    pub read_seek: Option<unsafe extern "C" fn(opaque: *mut c_void, stream_index: c_int, timestamp: i64, flags: c_int) -> i64>,
    pub seekable: c_int,
    pub direct: c_int,
    pub protocol_whitelist: *const c_char,
    pub protocol_blacklist: *const c_char,
    pub write_data_type: Option<unsafe extern "C" fn(opaque: *mut c_void, buf: *mut u8, buf_size: c_int, type_: AVIODataMarkerType, time: i64) -> c_int>,
    pub ignore_boundary_point: c_int,
    pub buf_ptr_max: *mut c_uchar,
    pub bytes_read: i64,
    pub bytes_written: i64,
}

Bytestream IO Context. New public fields can be added with minor version bumps. Removal, reordering and changes to existing public fields require a major version bump. sizeof(AVIOContext) must not be used outside libav*.

@note None of the function pointers in AVIOContext should be called directly, they should only be set by the client application when implementing custom I/O. Normally these are set to the function pointers specified in avio_alloc_context()

Fields

av_class: *const AVClass

A class for private options.

If this AVIOContext is created by avio_open2(), av_class is set and passes the options down to protocols.

If this AVIOContext is manually allocated, then av_class may be set by the caller.

warning – this field can be NULL, be sure to not pass this AVIOContext to any av_opt_* functions in that case.

buffer: *mut c_uchar

< Start of the buffer.

buffer_size: c_int

< Maximum buffer size

buf_ptr: *mut c_uchar

< Current position in the buffer

buf_end: *mut c_uchar

< End of the data, may be less than buffer+buffer_size if the read function returned less data than requested, e.g. for streams where no more data has been received yet.

opaque: *mut c_void

< A private pointer, passed to the read/write/seek/… functions.

read_packet: Option<unsafe extern "C" fn(opaque: *mut c_void, buf: *mut u8, buf_size: c_int) -> c_int>

write_packet: Option<unsafe extern "C" fn(opaque: *mut c_void, buf: *mut u8, buf_size: c_int) -> c_int>

seek: Option<unsafe extern "C" fn(opaque: *mut c_void, offset: i64, whence: c_int) -> i64>

pos: i64

< position in the file of the current buffer

eof_reached: c_int

< true if was unable to read due to error or eof

error: c_int

< contains the error code or 0 if no error happened

write_flag: c_int

< true if open for writing

max_packet_size: c_int

min_packet_size: c_int

< Try to buffer at least this amount of data before flushing it.

checksum: c_ulong

checksum_ptr: *mut c_uchar

update_checksum: Option<unsafe extern "C" fn(checksum: c_ulong, buf: *const u8, size: c_uint) -> c_ulong>

read_pause: Option<unsafe extern "C" fn(opaque: *mut c_void, pause: c_int) -> c_int>

Pause or resume playback for network streaming protocols - e.g. MMS.

read_seek: Option<unsafe extern "C" fn(opaque: *mut c_void, stream_index: c_int, timestamp: i64, flags: c_int) -> i64>

Seek to a given timestamp in stream with the specified stream_index. Needed for some network streaming protocols which don’t support seeking to byte position.

seekable: c_int

A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.

direct: c_int

avio_read and avio_write should if possible be satisfied directly instead of going through a buffer, and avio_seek will always call the underlying seek function directly.

protocol_whitelist: *const c_char

‘,’ separated list of allowed protocols.

protocol_blacklist: *const c_char

‘,’ separated list of disallowed protocols.

write_data_type: Option<unsafe extern "C" fn(opaque: *mut c_void, buf: *mut u8, buf_size: c_int, type_: AVIODataMarkerType, time: i64) -> c_int>

ignore_boundary_point: c_int

If set, don’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).

buf_ptr_max: *mut c_uchar

Maximum reached position before a backward seek in the write buffer, used keeping track of already written data for a later flush.

bytes_read: i64

Read-only statistic of bytes read for this AVIOContext.

bytes_written: i64

Read-only statistic of bytes written for this AVIOContext.

Trait Implementations

impl Clone for AVIOContext

fn clone(&self) -> AVIOContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AVIOContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for AVIOContext

fn eq(&self, other: &AVIOContext) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for AVIOContext

impl Eq for AVIOContext

impl StructuralPartialEq for AVIOContext