Struct png::StreamWriter

pub struct StreamWriter<'a, W: Write> {

    writer: Wrapper<'a, W>,
    prev_buf: Vec<u8>,
    curr_buf: Vec<u8>,
    index: usize,
    line_len: usize,
    to_write: usize,
    width: u32,
    height: u32,
    bpp: BytesPerPixel,
    filter: FilterType,
    adaptive_filter: AdaptiveFilterType,
    fctl: Option<FrameControl>,
    compression: Compression,
}

Streaming PNG writer

This may silently fail in the destructor, so it is a good idea to call finish or flush before dropping.

Fields

writer: Wrapper<'a, W>

The option here is needed in order to access the inner ChunkWriter in-between each frame, which is needed for writing the fcTL chunks between each frame

prev_buf: Vec<u8>

curr_buf: Vec<u8>

index: usize

Amount of data already written

line_len: usize

length of the current scanline

to_write: usize

size of the frame (width * height * sample_size)

width: u32

height: u32

bpp: BytesPerPixel

filter: FilterType

adaptive_filter: AdaptiveFilterType

fctl: Option<FrameControl>

compression: Compression

Implementations

impl<'a, W: Write> StreamWriter<'a, W>

fn new( writer: ChunkOutput<'a, W>, buf_len: usize, ) -> Result<StreamWriter<'a, W>, EncodingError>

pub fn set_filter(&mut self, filter: FilterType)

Set the used filter type for the next frame.

The default filter is FilterType::Sub which provides a basic prediction algorithm for sample values based on the previous.

For optimal compression ratio you should enable adaptive filtering instead of setting a single filter for the entire image, see set_adaptive_filter.

pub fn set_adaptive_filter(&mut self, adaptive_filter: AdaptiveFilterType)

Set the adaptive filter type for the next frame.

Adaptive filtering attempts to select the best filter for each line based on heuristics which minimize the file size for compression rather than use a single filter for the entire image.

The default method is AdaptiveFilterType::NonAdaptive.

pub fn set_frame_delay( &mut self, numerator: u16, denominator: u16, ) -> Result<(), EncodingError>

Set the fraction of time the following frames are going to be displayed, in seconds

If the denominator is 0, it is to be treated as if it were 100 (that is, the numerator then specifies 1/100ths of a second). If the value of the numerator is 0 the decoder should render the next frame as quickly as possible, though viewers may impose a reasonable lower bound.

This method will return an error if the image is not animated.

pub fn set_frame_dimension( &mut self, width: u32, height: u32, ) -> Result<(), EncodingError>

Set the dimension of the following frames.

This function will return an error when:

• The image is not an animated;

• The selected dimension, considering also the current frame position, goes outside the image boundaries;

• One or both the width and height are 0;

pub fn set_frame_position( &mut self, x: u32, y: u32, ) -> Result<(), EncodingError>

Set the position of the following frames.

An error will be returned if:

• The image is not animated;

• The selected position, considering also the current frame dimension, goes outside the image boundaries;

pub fn reset_frame_dimension(&mut self) -> Result<(), EncodingError>

Set the frame dimension to occupy all the image, starting from the current position.

To reset the frame to the full image size reset_frame_position should be called first.

This method will return an error if the image is not animated.

pub fn reset_frame_position(&mut self) -> Result<(), EncodingError>

Set the frame position to (0, 0).

Equivalent to calling set_frame_position(0, 0).

This method will return an error if the image is not animated.

pub fn set_blend_op(&mut self, op: BlendOp) -> Result<(), EncodingError>

Set the blend operation for the following frames.

The blend operation specifies whether the frame is to be alpha blended into the current output buffer content, or whether it should completely replace its region in the output buffer.

See the BlendOp documentation for the possible values and their effects.

Note that for the first frame the two blend modes are functionally equivalent due to the clearing of the output buffer at the beginning of each play.

This method will return an error if the image is not animated.

pub fn set_dispose_op(&mut self, op: DisposeOp) -> Result<(), EncodingError>

Set the dispose operation for the following frames.

The dispose operation specifies how the output buffer should be changed at the end of the delay (before rendering the next frame)

See the DisposeOp documentation for the possible values and their effects.

Note that if the first frame uses DisposeOp::Previous it will be treated as DisposeOp::Background.

This method will return an error if the image is not animated.

pub fn finish(self) -> Result<(), EncodingError>

Consume the stream writer with validation.

Unlike a simple drop this ensures that the all data was written correctly. When other validation options (chunk sequencing) had been turned on in the configuration of inner Writer, then it will also do a check on their correctness. Differently from Writer::finish, this just flushes, returns error if some data is abandoned.

fn new_frame(&mut self) -> Result<(), EncodingError>

Flushes the buffered chunk, checks if it was the last frame, writes the next frame header and gets the next frame scanline size and image size. NOTE: This method must only be called when the writer is the variant Chunk(_)

Trait Implementations

impl<W: Write> Drop for StreamWriter<'_, W>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, W: Write> Write for StreamWriter<'a, W>

fn write(&mut self, data: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.