zenjxl-decoder 0.3.8

High performance Rust implementation of a JPEG XL decoder
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

use std::fmt::Debug;

mod private {
    pub trait Sealed {}
}

#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum DataTypeTag {
    U8,
    U16,
    U32,
    F32,
    I8,
    I16,
    I32,
    F16,
    F64,
}

impl DataTypeTag {
    // Note that the const block below asserts that the implementation of this method is correct
    // (as in, matches the size of the types that the tag corresponds to).
    pub const fn size(&self) -> usize {
        match self {
            DataTypeTag::U8 | DataTypeTag::I8 => 1,
            DataTypeTag::U16 | DataTypeTag::F16 | DataTypeTag::I16 => 2,
            DataTypeTag::U32 | DataTypeTag::F32 | DataTypeTag::I32 => 4,
            DataTypeTag::F64 => 8,
        }
    }
}

const _: () = {
    assert!(std::mem::size_of::<i8>() == DataTypeTag::I8.size());
    assert!(std::mem::size_of::<u8>() == DataTypeTag::U8.size());
    assert!(std::mem::size_of::<i16>() == DataTypeTag::I16.size());
    assert!(std::mem::size_of::<u16>() == DataTypeTag::U16.size());
    assert!(std::mem::size_of::<crate::util::f16>() == DataTypeTag::F16.size());
    assert!(std::mem::size_of::<i32>() == DataTypeTag::I32.size());
    assert!(std::mem::size_of::<u32>() == DataTypeTag::U32.size());
    assert!(std::mem::size_of::<f32>() == DataTypeTag::F32.size());
    assert!(std::mem::size_of::<f64>() == DataTypeTag::F64.size());
};

/// Image data type trait. Implementors must be "bag-of-bits" types with no padding,
/// guaranteed by the `bytemuck::Pod` bound.
pub trait ImageDataType:
    private::Sealed + bytemuck::Pod + Copy + Default + 'static + Debug + PartialEq + Send + Sync
{
    /// ID of this data type. Different types *must* have different values.
    const DATA_TYPE_ID: DataTypeTag;

    fn from_f64(f: f64) -> Self;
    fn to_f64(self) -> f64;
    #[cfg(test)]
    fn random<R: rand::Rng>(rng: &mut R) -> Self;
}

#[cfg(test)]
macro_rules! type_min {
    (f32) => {
        0.0f32
    };
    (f64) => {
        0.0f64
    };
    ($ty: ty) => {
        <$ty>::MIN
    };
}

#[cfg(test)]
macro_rules! type_max {
    (f32) => {
        1.0f32
    };
    (f64) => {
        1.0f64
    };
    ($ty: ty) => {
        <$ty>::MAX
    };
}

macro_rules! impl_image_data_type {
    ($ty: ident, $id: ident) => {
        impl private::Sealed for $ty {}
        impl ImageDataType for $ty {
            const DATA_TYPE_ID: DataTypeTag = DataTypeTag::$id;
            fn from_f64(f: f64) -> $ty {
                f as $ty
            }
            fn to_f64(self) -> f64 {
                self as f64
            }
            #[cfg(test)]
            fn random<R: rand::Rng>(rng: &mut R) -> Self {
                use rand::distr::{Distribution, Uniform};
                let min = type_min!($ty);
                let max = type_max!($ty);
                Uniform::new_inclusive(min, max).unwrap().sample(rng)
            }
        }
    };
}

impl_image_data_type!(u8, U8);
impl_image_data_type!(u16, U16);
impl_image_data_type!(u32, U32);
impl_image_data_type!(f32, F32);
impl_image_data_type!(i8, I8);
impl_image_data_type!(i16, I16);
impl_image_data_type!(i32, I32);

// Meant to be used by the simple render pipeline and in general for
// testing purposes.
impl_image_data_type!(f64, F64);

impl private::Sealed for crate::util::f16 {}
impl ImageDataType for crate::util::f16 {
    const DATA_TYPE_ID: DataTypeTag = DataTypeTag::F16;
    fn from_f64(f: f64) -> crate::util::f16 {
        crate::util::f16::from_f64(f)
    }
    fn to_f64(self) -> f64 {
        crate::util::f16::to_f64(self)
    }
    #[cfg(test)]
    fn random<R: rand::Rng>(rng: &mut R) -> Self {
        use rand::distr::{Distribution, Uniform};
        Self::from_f64(Uniform::new(0.0f32, 1.0f32).unwrap().sample(rng) as f64)
    }
}