Struct constriction::stream::queue::RangeDecoder

pub struct RangeDecoder<Word, State, Backend> where
    Word: BitArray,
    State: BitArray,
    Backend: ReadWords<Word, Queue>,  { /* fields omitted */ }

Implementations

impl<Word, State, Backend> RangeDecoder<Word, State, Backend> where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue>, 

pub fn from_compressed<Buf>(compressed: Buf) -> Result<Self, Backend::ReadError> where
    Buf: IntoReadWords<Word, Queue, IntoReadWords = Backend>, 

pub fn with_backend(backend: Backend) -> Result<Self, Backend::ReadError>

pub fn for_compressed<'a, Buf>(
    compressed: &'a Buf
) -> Result<Self, Backend::ReadError> where
    Buf: AsReadWords<'a, Word, Queue, AsReadWords = Backend>, 

pub fn from_raw_parts(
    _bulk: Backend,
    _state: State
) -> Result<Self, (Backend, RangeCoderState<Word, State>)>

pub fn into_raw_parts(self) -> (Backend, RangeCoderState<Word, State>)

pub fn maybe_exhausted(&self) -> bool

Same as Decoder::maybe_exhausted, but can be called on a concrete type without type annotations.

Trait Implementations

impl<Word, State, Backend> Code for RangeDecoder<Word, State, Backend> where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue>, 

type State = RangeCoderState<Word, State>

The internal coder state, as returned by the method state.

type Word = Word

The smallest unit of compressed data that this coder can emit or read at once. Most coders guarantee that encoding emits at most one Word per symbol (plus a constant overhead).

fn state(&self) -> Self::State

Returns the current internal state of the coder.

fn encoder_maybe_full<const PRECISION: usize>(&self) -> bool where
    Self: Encode<PRECISION>, 

Checks if there might not be any room to encode more data.

fn decoder_maybe_exhausted<const PRECISION: usize>(&self) -> bool where
    Self: Decode<PRECISION>, 

Checks if there might be no compressed data left for decoding.

impl<Word: Debug, State: Debug, Backend: Debug> Debug for RangeDecoder<Word, State, Backend> where
    Word: BitArray,
    State: BitArray,
    Backend: ReadWords<Word, Queue>, 

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

Formats the value using the given formatter.

impl<Word, State, Backend, const PRECISION: usize> Decode<PRECISION> for RangeDecoder<Word, State, Backend> where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue>, 

fn decode_symbol<D>(
    &mut self,
    model: D
) -> Result<D::Symbol, CoderError<Self::FrontendError, Self::BackendError>> where
    D: DecoderModel<PRECISION>,
    D::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<D::Probability>, 

Decodes a single symbol and pops it off the compressed data.

This is a low level method. You usually probably want to call a batch method like decode_symbols or decode_iid_symbols instead.

This method is called decode_symbol rather than decode_symbol to stress the fact that the Coder is a stack: decode_symbol will return the last symbol that was previously encoded via encode_symbol.

Note that this method cannot fail. It will still produce symbols in a deterministic way even if the coder is empty, but such symbols will not recover any previously encoded data and will generally have low entropy. Still, being able to pop off an arbitrary number of symbols can sometimes be useful in edge cases of, e.g., the bits-back algorithm.

type FrontendError = DecoderFrontendError

The error type for logical decoding errors.

type BackendError = Backend::ReadError

The error type for reading in encoded data.

fn maybe_exhausted(&self) -> bool

Checks if there might be no compressed data left for decoding.

fn decode_symbols<'s, I, M>(
    &'s mut self,
    models: I
) -> DecodeSymbols<'s, Self, I::IntoIter, PRECISION> where
    I: IntoIterator<Item = M> + 's,
    M: DecoderModel<PRECISION>,
    M::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<M::Probability>, 

Decodes a sequence of symbols, using an individual entropy model for each symbol.

fn try_decode_symbols<'s, I, M, E>(
    &'s mut self,
    models: I
) -> TryDecodeSymbols<'s, Self, I::IntoIter, PRECISION> where
    I: IntoIterator<Item = Result<M, E>> + 's,
    M: DecoderModel<PRECISION>,
    M::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<M::Probability>, 

Decodes a sequence of symbols from a fallible iterator over entropy models.

fn decode_iid_symbols<M>(
    &mut self,
    amt: usize,
    model: M
) -> DecodeIidSymbols<'_, Self, M, PRECISION> where
    M: DecoderModel<PRECISION> + Copy,
    M::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<M::Probability>, 

Decodes amt symbols using the same entropy model for all symbols.

impl<Word, State, Backend> From<RangeEncoder<Word, State, Backend>> for RangeDecoder<Word, State, Backend::IntoReadWords> where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: WriteWords<Word> + IntoReadWords<Word, Queue>, 

fn from(encoder: RangeEncoder<Word, State, Backend>) -> Self

Performs the conversion.

impl<Word, State, Backend> PosSeek for RangeDecoder<Word, State, Backend> where
    Word: BitArray,
    State: BitArray,
    Backend: ReadWords<Word, Queue>,
    Backend: PosSeek,
    Self: Code, 

type Position = (Backend::Position, Self::State)

impl<Word, State, Backend> Seek for RangeDecoder<Word, State, Backend> where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue> + Seek, 

fn seek(&mut self, pos_and_state: Self::Position) -> Result<(), ()>

Jumps to a given position in the compressed data.