Struct Encoder

pub struct Encoder<M, W>
where
    M: Model,
    W: BitWrite,
{
    pub model: M,
    /* private fields */
}

An arithmetic encoder

An arithmetic decoder converts a stream of symbols into a stream of bits, using a predictive Model.

Fields

model: M

The model used for the encoder

Implementations

impl<M, W> Encoder<M, W>

where M: Model, W: BitWrite,

pub fn new(model: M) -> Self

Construct a new Encoder.

The ‘precision’ of the encoder is maximised, based on the number of bits needed to represent the Model::denominator. ‘precision’ bits is equal to BitStore::BITS - Model::denominator bits. If you need to set the precision manually, use Encoder::with_precision.

Panics

The calculation of the number of bits used for ‘precision’ is subject to the following constraints:

• The total available bits is BitStore::BITS
• The precision must use at least 2 more bits than that needed to represent Model::denominator

If these constraints cannot be satisfied this method will panic in debug builds

pub fn with_precision(model: M, precision: u32) -> Self

Construct a new Encoder with a custom precision.

Panics

The calculation of the number of bits used for ‘precision’ is subject to the following constraints:

• The total available bits is BitStore::BITS
• The precision must use at least 2 more bits than that needed to represent Model::denominator

If these constraints cannot be satisfied this method will panic in debug builds

pub const fn with_state(state: State<M::B, W>, model: M) -> Self

todo

pub fn encode_all( &mut self, symbols: impl IntoIterator<Item = M::Symbol>, output: &mut W, ) -> Result<(), Error>

Encode a stream of symbols into the provided output.

This method will encode all the symbols in the iterator, followed by EOF (None), and then call Encoder::flush.

Errors

This method can fail if the underlying BitWrite cannot be written to.

pub fn encode( &mut self, symbol: Option<&M::Symbol>, output: &mut W, ) -> Result<(), Error>

Encode a symbol into the provided output.

When you finish encoding symbols, you must manually encode an EOF symbol by calling Encoder::encode with None.

The internal buffer must be manually flushed using Encoder::flush.

Errors

This method can fail if the underlying BitWrite cannot be written to.

pub fn flush(&mut self, output: &mut W) -> Result<()>

Flush any pending bits from the buffer

This method must be called when you finish writing symbols to a stream of bits. This is called automatically when you use Encoder::encode_all.

Errors

This method can fail if the underlying BitWrite cannot be written to.

pub fn into_inner(self) -> (M, State<M::B, W>)

todo

pub fn chain<X>(self, model: X) -> Encoder<X, W>

where X: Model<B = M::B>,

Reuse the internal state of the Encoder with a new model.

Allows for chaining multiple sequences of symbols into a single stream of bits

Trait Implementations

impl<M, W> Debug for Encoder<M, W>

where M: Model + Debug, W: BitWrite + Debug, M::B: Debug,

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

Formats the value using the given formatter.