Struct PixelSliceMut 

#[non_exhaustive]
pub struct PixelSliceMut<'a, P = ()> { /* private fields */ }

Mutable borrowed view of pixel data.

Same semantics as PixelSlice but allows writing to rows. The type parameter P tracks pixel format at compile time.

Implementations

impl<'a> PixelSliceMut<'a>

pub fn new( data: &'a mut [u8], width: u32, rows: u32, stride_bytes: usize, descriptor: PixelDescriptor, ) -> Result<PixelSliceMut<'a>, At<BufferError>>

Create a new mutable pixel slice with validation.

stride_bytes is the byte distance between the start of consecutive rows.

Endianness contract

Multi-byte samples (U16, F16, F32) are interpreted in native byte order; see PixelSlice::new — the same contract applies here.

Errors

Returns an error if the data is too small, the stride is too small, or the data is not aligned for the channel type.

impl<'a, P> PixelSliceMut<'a, P>

pub fn erase(self) -> PixelSliceMut<'a>

Erase the pixel type, returning a type-erased mutable slice.

pub fn try_typed<Q>(self) -> Option<PixelSliceMut<'a, Q>>

where Q: Pixel,

Try to reinterpret as a typed mutable pixel slice.

Succeeds if the descriptors are layout-compatible.

pub fn with_descriptor( self, descriptor: PixelDescriptor, ) -> PixelSliceMut<'a, P>

Replace the descriptor with a layout-compatible one.

See PixelSlice::with_descriptor() for details.

pub fn reinterpret( self, descriptor: PixelDescriptor, ) -> Result<PixelSliceMut<'a, P>, At<BufferError>>

Reinterpret the buffer with a different physical layout.

See PixelSlice::reinterpret() for details.

pub fn with_transfer(self, tf: TransferFunction) -> PixelSliceMut<'a, P>

Return a copy with a different transfer function.

pub fn with_primaries(self, cp: ColorPrimaries) -> PixelSliceMut<'a, P>

Return a copy with different color primaries.

pub fn with_signal_range(self, sr: SignalRange) -> PixelSliceMut<'a, P>

Return a copy with a different signal range.

pub fn with_alpha_mode(self, am: Option<AlphaMode>) -> PixelSliceMut<'a, P>

Return a copy with a different alpha mode.

pub fn width(&self) -> u32

Image width in pixels.

pub fn rows(&self) -> u32

Number of rows in this slice.

pub fn stride(&self) -> usize

Byte stride between row starts.

pub fn descriptor(&self) -> PixelDescriptor

Pixel format descriptor.

pub fn color_context(&self) -> Option<&Arc<ColorContext>>

Source color context (ICC/CICP metadata), if set.

pub fn with_color_context(self, ctx: Arc<ColorContext>) -> PixelSliceMut<'a, P>

Return a copy of this slice with a color context attached.

pub fn with_diffuse_white(self, white: DiffuseWhite) -> PixelSliceMut<'a, P>

Relabel the source diffuse-white anchor — the cd/m² that relative-linear 1.0 represents. Reinterpretation only: pixels are untouched (use a converter to change pixel values). Clones any existing ColorContext, overrides its diffuse_white, and re-attaches it.

pub fn with_cicp(self, cicp: Cicp) -> PixelSliceMut<'a, P>

Relabel the source Cicp colour signalling. Reinterpretation only — pixels are untouched. Clones any existing ColorContext, sets cicp, and re-attaches it.

pub fn with_icc(self, icc: impl Into<Arc<[u8]>>) -> PixelSliceMut<'a, P>

Relabel the source ICC profile. Reinterpretation only — pixels are untouched. Clones any existing ColorContext, sets icc, and re-attaches it.

pub fn as_pixel_slice(&self) -> PixelSlice<'_, P>

Reborrow as an immutable PixelSlice (zero-copy).

The returned slice borrows from self, so the mutable slice cannot be used while the immutable reborrow is alive.

pub fn as_strided_bytes(&self) -> &[u8]

Zero-copy access to the raw backing bytes, including any stride padding.

Unlike PixelSlice::as_strided_bytes() (which clips to the image extent), this returns the full backing buffer so callers can write stride padding (zeroing, codec requirements, etc.).

pub fn as_strided_bytes_mut(&mut self) -> &mut [u8]

Mutable access to the raw backing bytes, including any stride padding.

Returns the full backing buffer so callers can write stride padding.

pub fn row(&self, y: u32) -> &[u8]

Pixel bytes for row y (immutable, no padding).

Panics

Panics if y >= rows.

pub fn row_mut(&mut self, y: u32) -> &mut [u8]

Mutable pixel bytes for row y (no padding).

Panics

Panics if y >= rows.

pub fn sub_rows_mut(&mut self, y: u32, count: u32) -> PixelSliceMut<'_, P>

Borrow a mutable sub-range of rows.

Panics

Panics if y + count > rows.

impl<'a, P> PixelSliceMut<'a, P>

where P: Pixel,

pub fn new_typed( data: &'a mut [u8], width: u32, rows: u32, stride_pixels: u32, ) -> Result<PixelSliceMut<'a, P>, At<BufferError>>

Create a typed mutable pixel slice.

stride_pixels is the number of pixels per row (>= width). The byte stride is stride_pixels * size_of::<P>().

impl<'a> PixelSliceMut<'a, Rgbx>

pub fn swap_to_bgrx(self) -> PixelSliceMut<'a, Bgrx>

Byte-swap R<->B channels in place, converting to BGRX.

impl<'a> PixelSliceMut<'a, Rgbx>

pub fn upgrade_to_rgba(self) -> PixelSliceMut<'a, Rgba<u8>>

Upgrade to RGBA by setting all padding bytes to 255 (fully opaque).

impl<'a> PixelSliceMut<'a, Bgrx>

pub fn swap_to_rgbx(self) -> PixelSliceMut<'a, Rgbx>

Byte-swap B<->R channels in place, converting to RGBX.

impl<'a> PixelSliceMut<'a, Bgrx>

pub fn upgrade_to_bgra(self) -> PixelSliceMut<'a, Bgra<u8>>

Upgrade to BGRA by setting all padding bytes to 255 (fully opaque).

impl<'a> PixelSliceMut<'a, Rgba<u8>>

pub fn matte_to_rgbx(self, bg: Rgb<u8>) -> PixelSliceMut<'a, Rgbx>

Matte alpha against a solid RGB background, producing RGBX.

Each pixel is composited: out = src * alpha/255 + bg * (255 - alpha)/255. The alpha byte becomes padding.

pub fn strip_alpha_to_rgbx(self) -> PixelSliceMut<'a, Rgbx>

Strip alpha to RGBX without compositing (just mark as padding).

The alpha byte value is preserved in memory but semantically ignored. Use when you know alpha is already 255 or don’t care about the values.

pub fn swap_to_bgra(self) -> PixelSliceMut<'a, Bgra<u8>>

Byte-swap R<->B channels in place, converting to BGRA.

impl<'a> PixelSliceMut<'a, Bgra<u8>>

pub fn matte_to_bgrx(self, bg: Rgb<u8>) -> PixelSliceMut<'a, Bgrx>

Matte alpha against a solid RGB background, producing BGRX.

Each pixel is composited: out = src * alpha/255 + bg * (255 - alpha)/255. The alpha byte becomes padding.

pub fn strip_alpha_to_bgrx(self) -> PixelSliceMut<'a, Bgrx>

Strip alpha to BGRX without compositing (just mark as padding).

pub fn swap_to_rgba(self) -> PixelSliceMut<'a, Rgba<u8>>

Byte-swap B<->R channels in place, converting to RGBA.

Trait Implementations

impl<P> Debug for PixelSliceMut<'_, P>

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

Formats the value using the given formatter.

impl<'a> From<Img<&'a mut [Bgra<u8>]>> for PixelSliceMut<'a, Bgra<u8>>

fn from(img: Img<&'a mut [Bgra<u8>]>) -> PixelSliceMut<'a, Bgra<u8>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Gray_v08<f32>]>> for PixelSliceMut<'a, Gray_v08<f32>>

fn from(img: Img<&'a mut [Gray_v08<f32>]>) -> PixelSliceMut<'a, Gray_v08<f32>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Gray_v08<u8>]>> for PixelSliceMut<'a, Gray_v08<u8>>

fn from(img: Img<&'a mut [Gray_v08<u8>]>) -> PixelSliceMut<'a, Gray_v08<u8>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Gray_v08<u16>]>> for PixelSliceMut<'a, Gray_v08<u16>>

fn from(img: Img<&'a mut [Gray_v08<u16>]>) -> PixelSliceMut<'a, Gray_v08<u16>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Rgb<f32>]>> for PixelSliceMut<'a, Rgb<f32>>

fn from(img: Img<&'a mut [Rgb<f32>]>) -> PixelSliceMut<'a, Rgb<f32>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Rgb<u8>]>> for PixelSliceMut<'a, Rgb<u8>>

fn from(img: Img<&'a mut [Rgb<u8>]>) -> PixelSliceMut<'a, Rgb<u8>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Rgb<u16>]>> for PixelSliceMut<'a, Rgb<u16>>

fn from(img: Img<&'a mut [Rgb<u16>]>) -> PixelSliceMut<'a, Rgb<u16>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Rgba<f32>]>> for PixelSliceMut<'a, Rgba<f32>>

fn from(img: Img<&'a mut [Rgba<f32>]>) -> PixelSliceMut<'a, Rgba<f32>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Rgba<u8>]>> for PixelSliceMut<'a, Rgba<u8>>

fn from(img: Img<&'a mut [Rgba<u8>]>) -> PixelSliceMut<'a, Rgba<u8>>

Converts to this type from the input type.

impl<'a> From<Img<&'a mut [Rgba<u16>]>> for PixelSliceMut<'a, Rgba<u16>>

fn from(img: Img<&'a mut [Rgba<u16>]>) -> PixelSliceMut<'a, Rgba<u16>>

Converts to this type from the input type.

impl<'a, P> From<PixelSliceMut<'a, P>> for PixelSliceMut<'a>

where P: Pixel,

fn from(typed: PixelSliceMut<'a, P>) -> PixelSliceMut<'a>

Converts to this type from the input type.

impl<'a, P> From<PixelSliceMut<'a, P>> for PixelSlice<'a, P>

Consume a mutable pixel slice and produce an immutable one (zero-copy).

fn from(mut_slice: PixelSliceMut<'a, P>) -> PixelSlice<'a, P>

Converts to this type from the input type.