Struct png::Reader

pub struct Reader<R: Read> {
    decoder: ReadDecoder<R>,
    bpp: BytesPerPixel,
    subframe: SubframeInfo,
    fctl_read: u32,
    next_frame: SubframeIdx,
    data_stream: Vec<u8>,
    prev_start: usize,
    current_start: usize,
    transform: Transformations,
    transform_fn: Option<Box<dyn Fn(&[u8], &mut [u8], &Info<'_>) + Send + Sync>>,
    scratch_buffer: Vec<u8>,
}

PNG reader (mostly high-level interface)

Provides a high level that iterates over lines or whole images.

Fields

decoder: ReadDecoder<R>

bpp: BytesPerPixel

subframe: SubframeInfo

fctl_read: u32

Number of frame control chunks read. By the APNG specification the total number must equal the count specified in the animation control chunk. The IDAT image may have such a chunk applying to it.

next_frame: SubframeIdx

data_stream: Vec<u8>

Vec containing the uncompressed image data currently being processed.

prev_start: usize

Index in data_stream where the previous row starts.

current_start: usize

Index in data_stream where the current row starts.

transform: Transformations

Output transformations

transform_fn: Option<Box<dyn Fn(&[u8], &mut [u8], &Info<'_>) + Send + Sync>>

Function that can transform decompressed, unfiltered rows into final output. See the transform.rs module for more details.

scratch_buffer: Vec<u8>

This buffer is only used so that next_row and next_interlaced_row can return reference to a byte slice. In a future version of this library, this buffer will be removed and next_row and next_interlaced_row will write directly into a user provided output buffer.

Implementations

impl<R: Read> Reader<R>

fn read_until_image_data(&mut self) -> Result<(), DecodingError>

Reads all meta data until the next frame data starts. Requires IHDR before the IDAT and fcTL before fdAT.

pub fn info(&self) -> &Info<'static>

Get information on the image.

The structure will change as new frames of an animated image are decoded.

pub fn next_frame( &mut self, buf: &mut [u8], ) -> Result<OutputInfo, DecodingError>

Decodes the next frame into buf.

Note that this decodes raw subframes that need to be mixed according to blend-op and dispose-op by the caller.

The caller must always provide a buffer large enough to hold a complete frame (the APNG specification restricts subframes to the dimensions given in the image header). The region that has been written be checked afterwards by calling info after a successful call and inspecting the frame_control data. This requirement may be lifted in a later version of png.

Output lines will be written in row-major, packed matrix with width and height of the read frame (or subframe), all samples are in big endian byte order where this matters.

pub fn next_row(&mut self) -> Result<Option<Row<'_>>, DecodingError>

Returns the next processed row of the image

pub fn next_interlaced_row( &mut self, ) -> Result<Option<InterlacedRow<'_>>, DecodingError>

Returns the next processed row of the image

pub fn finish(&mut self) -> Result<(), DecodingError>

Read the rest of the image and chunks and finish up, including text chunks or others This will discard the rest of the image if the image is not read already with Reader::next_frame, Reader::next_row or Reader::next_interlaced_row

fn next_interlaced_row_impl( &mut self, rowlen: usize, output_buffer: &mut [u8], ) -> Result<(), DecodingError>

Fetch the next interlaced row and filter it according to our own transformations.

pub fn output_color_type(&self) -> (ColorType, BitDepth)

Returns the color type and the number of bits per sample of the data returned by Reader::next_row and Reader::frames`.

pub fn output_buffer_size(&self) -> usize

Returns the number of bytes required to hold a deinterlaced image frame that is decoded using the given input transformations.

pub fn output_line_size(&self, width: u32) -> usize

Returns the number of bytes required to hold a deinterlaced row.

fn next_raw_interlaced_row( &mut self, rowlen: usize, ) -> Result<(), DecodingError>

Write the next raw interlaced row into self.prev.

The scanline is filtered against the previous scanline according to the specification.