Enum zune_core::bit_depth::BitDepth

#[non_exhaustive]
pub enum BitDepth {
    Eight,
    Sixteen,
    Float32,
    Unknown,
}

The image bit depth.

The library successfully supports depths up to 16 bits, as the underlying storage is usually a u16.

This allows us to comfortably support a wide variety of images e.g 10 bit av1, 16 bit png and ppm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Eight

U8 bit depth.

Images with such bit depth use u8 to store pixels and use the whole range from 0-255.

It is currently the smallest supported bit depth by the library.

For images with bit depths lower than this, they will be scaled to this bit depth

Sixteen

U16 bit depth

Images with such bit depths use u16 to store values and use the whole range i.e 0-65535

Data is stored and processed in native endian.

Float32

Floating point 32 bit data, range is 0.0 to 1.0

Uses f32 to store data

Unknown

Bit depth information is unknown

Implementations

impl BitDepth

pub const fn max_value(self) -> u16

Get the max value supported by the bit depth

During conversion from one bit depth to another

larger values should be clamped to this bit depth

pub const fn bit_type(self) -> BitType

Return the minimum number of bits that can be used to represent each pixel in the image

All bit depths below 8 return a bit type of BitType::U8. and all those above 8 and below 16 return a bit type of BitType::SixTeen

Returns

An enum whose variants represent the minimum size for an unsigned integer which can store the image pixels without overflow

Example

use zune_core::bit_depth::{BitDepth, BitType};
assert_eq!(BitDepth::Eight.bit_type(),BitType::U8);

assert_eq!(BitDepth::Sixteen.bit_type(),BitType::U16);

See also size_of

pub const fn size_of(self) -> usize

Get the number of bytes needed to store a specific bit depth

Example

For images less than or equal to 8 bits(1 byte), we can use a u8 to store the pixels, and a size_of u8 is 1

For images greater than 8 bits and less than 16 bits(2 bytes), we can use a u16 to store the pixels, a size_of u16 is 2.

use zune_core::bit_depth::BitDepth;
let depth = BitDepth::Sixteen;
// greater 12 bits is greater than 8 and less than 16
assert_eq!(depth.size_of(),2);

pub const fn bit_size(&self) -> usize

Trait Implementations

impl Clone for BitDepth

fn clone(&self) -> BitDepth

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BitDepth

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

Formats the value using the given formatter.

impl Default for BitDepth

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for BitDepth

fn eq(&self, other: &BitDepth) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for BitDepth

impl Eq for BitDepth

impl StructuralEq for BitDepth

impl StructuralPartialEq for BitDepth