Struct TileStateMut 

pub struct TileStateMut<'a, T: Pixel> {
    pub sbo: PlaneSuperBlockOffset,
    pub sb_width: usize,
    pub sb_height: usize,
    pub mi_width: usize,
    pub mi_height: usize,
    pub width: usize,
    pub height: usize,
    pub input_tile: Tile<'a, T>,
    pub input_hres: &'a Plane<T>,
    pub input_qres: &'a Plane<T>,
    pub me_stats: Vec<TileMEStatsMut<'a>>,
}

Tiled view of FrameState

Contrary to PlaneRegionMut and TileMut, there is no const version:

• in practice, we don’t need it;
• it would require to instantiate a const version of every of its inner tiled views recursively.

TileState fields

The way the FrameState fields are mapped depend on how they are accessed tile-wise and frame-wise.

Some fields (like qc) are only used during tile-encoding, so they are only stored in TileState.

Some other fields (like input or segmentation) are not written tile-wise, so they just reference the matching field in FrameState.

Some others (like rec) are written tile-wise, but must be accessible frame-wise once the tile views vanish (e.g. for deblocking).

Fields

sbo: PlaneSuperBlockOffset

sb_width: usize

sb_height: usize

mi_width: usize

mi_height: usize

width: usize

height: usize

input_tile: Tile<'a, T>

input_hres: &'a Plane<T>

input_qres: &'a Plane<T>

me_stats: Vec<TileMEStatsMut<'a>>

Implementations

impl<'a, T: Pixel> TileStateMut<'a, T>

pub fn new( fs: &'a mut FrameState<T>, sbo: PlaneSuperBlockOffset, width: usize, height: usize, frame_me_stats: &'a mut [FrameMEStats], ) -> Self

pub fn to_frame_block_offset( &self, tile_bo: TileBlockOffset, ) -> PlaneBlockOffset

Trait Implementations

impl<'a, T: Debug + Pixel> Debug for TileStateMut<'a, T>

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

Formats the value using the given formatter.