j2k-metal 0.7.0

Metal decoder and encode-stage adapter for j2k
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

// SPDX-License-Identifier: MIT OR Apache-2.0

use j2k_core::{Downscale, PixelFormat, Rect};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum PreparedPlanKind {
    DirectGray,
    DirectColor,
    RegionScaledColor,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) struct PreparedPlanCacheKey<'a> {
    input: &'a [u8],
    format: PixelFormat,
    roi: Option<Rect>,
    scale: Downscale,
    kind: PreparedPlanKind,
}

impl<'a> PreparedPlanCacheKey<'a> {
    pub(crate) const fn direct_gray(input: &'a [u8], format: PixelFormat) -> Self {
        Self {
            input,
            format,
            roi: None,
            scale: Downscale::None,
            kind: PreparedPlanKind::DirectGray,
        }
    }

    pub(crate) const fn direct_color(input: &'a [u8], format: PixelFormat) -> Self {
        Self {
            input,
            format,
            roi: None,
            scale: Downscale::None,
            kind: PreparedPlanKind::DirectColor,
        }
    }

    pub(crate) const fn region_scaled_color(
        input: &'a [u8],
        format: PixelFormat,
        roi: Rect,
        scale: Downscale,
    ) -> Self {
        Self {
            input,
            format,
            roi: Some(roi),
            scale,
            kind: PreparedPlanKind::RegionScaledColor,
        }
    }

    pub(super) const fn input_len(self) -> usize {
        self.input.len()
    }
}

pub(super) struct OwnedPreparedPlanCacheKey {
    input: Vec<u8>,
    format: PixelFormat,
    roi: Option<Rect>,
    scale: Downscale,
    kind: PreparedPlanKind,
}

impl OwnedPreparedPlanCacheKey {
    pub(super) fn try_from_borrowed(
        key: PreparedPlanCacheKey<'_>,
    ) -> Result<Self, std::collections::TryReserveError> {
        let mut input = Vec::new();
        input.try_reserve_exact(key.input.len())?;
        input.extend_from_slice(key.input);
        Ok(Self {
            input,
            format: key.format,
            roi: key.roi,
            scale: key.scale,
            kind: key.kind,
        })
    }

    pub(super) fn matches(&self, key: PreparedPlanCacheKey<'_>) -> bool {
        self.input.as_slice() == key.input
            && self.format == key.format
            && self.roi == key.roi
            && self.scale == key.scale
            && self.kind == key.kind
    }

    pub(super) const fn input_capacity(&self) -> usize {
        self.input.capacity()
    }

    #[cfg(test)]
    pub(super) fn with_input_capacity_for_test(capacity: usize, input: &[u8]) -> Self {
        let mut owned = Vec::new();
        owned
            .try_reserve_exact(capacity)
            .expect("test key capacity reservation");
        owned.extend_from_slice(input);
        Self {
            input: owned,
            format: PixelFormat::Rgb8,
            roi: None,
            scale: Downscale::None,
            kind: PreparedPlanKind::DirectColor,
        }
    }
}