j2k 0.7.0

Safe public JPEG 2000 and HTJ2K CPU codec APIs with optional CUDA and Metal adapters
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
139
140
141

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

//! Allocation-free JP2/JPH color-specification resolution.

use crate::{parse::ParsedImageInfo, J2kColorSpec, J2kError, J2kFileColorSpec};
use j2k_core::{BufferError, Colorspace, Unsupported};

#[derive(Clone, Copy)]
pub(super) enum ColorSelection<'a> {
    Options {
        legacy: J2kFileColorSpec<'a>,
        explicit: &'a [J2kFileColorSpec<'a>],
    },
    Inspected(&'a [J2kColorSpec]),
}

#[derive(Clone, Copy)]
pub(super) enum PlannedColorSpec<'a> {
    Enumerated(u32),
    IccProfile(&'a [u8]),
}

impl ColorSelection<'_> {
    pub(super) fn for_each_resolved<'a, F>(
        &'a self,
        parsed: &ParsedImageInfo,
        mut visit: F,
    ) -> Result<(), J2kError>
    where
        F: FnMut(PlannedColorSpec<'a>) -> Result<(), J2kError>,
    {
        match *self {
            Self::Options { legacy, explicit } => {
                if explicit.is_empty() {
                    return visit(resolve_color_spec(parsed, legacy)?);
                }
                for &color in explicit {
                    visit(resolve_color_spec(parsed, color)?)?;
                }
            }
            Self::Inspected(color_specs) => {
                let has_representable = color_specs
                    .iter()
                    .any(|color| J2kFileColorSpec::from_inspected(color).is_some());
                if !has_representable {
                    return visit(resolve_color_spec(parsed, J2kFileColorSpec::Infer)?);
                }
                for color in color_specs {
                    if let Some(color) = J2kFileColorSpec::from_inspected(color) {
                        visit(resolve_color_spec(parsed, color)?)?;
                    }
                }
            }
        }
        Ok(())
    }

    pub(super) fn writes_rgba_cdef(self, parsed: &ParsedImageInfo) -> Result<bool, J2kError> {
        if parsed.info.components != 4 {
            return Ok(false);
        }
        Ok(matches!(
            self.first_resolved(parsed)?,
            PlannedColorSpec::Enumerated(16)
        ))
    }

    fn first_resolved<'a>(
        &'a self,
        parsed: &ParsedImageInfo,
    ) -> Result<PlannedColorSpec<'a>, J2kError> {
        let mut first = None;
        self.for_each_resolved(parsed, |color| {
            if first.is_none() {
                first = Some(color);
            }
            Ok(())
        })?;
        first.ok_or(J2kError::InternalInvariant {
            what: "JP2/JPH color selection produced no COLR box",
        })
    }
}

impl PlannedColorSpec<'_> {
    pub(super) fn payload_len(self) -> Result<usize, J2kError> {
        match self {
            Self::Enumerated(_) => Ok(7),
            Self::IccProfile(profile) => {
                profile
                    .len()
                    .checked_add(3)
                    .ok_or(J2kError::Buffer(BufferError::SizeOverflow {
                        what: "JP2/JPH ICC COLR payload",
                    }))
            }
        }
    }
}

fn resolve_color_spec<'a>(
    parsed: &ParsedImageInfo,
    color: J2kFileColorSpec<'a>,
) -> Result<PlannedColorSpec<'a>, J2kError> {
    match color {
        J2kFileColorSpec::Infer => Ok(PlannedColorSpec::Enumerated(
            inferred_enumerated_colorspace(parsed.info.components, parsed.info.colorspace)?,
        )),
        J2kFileColorSpec::Enumerated(colorspace) => Ok(PlannedColorSpec::Enumerated(
            enumerated_colorspace_code(colorspace)?,
        )),
        J2kFileColorSpec::IccProfile(profile) => Ok(PlannedColorSpec::IccProfile(profile)),
    }
}

fn inferred_enumerated_colorspace(
    components: u16,
    colorspace: Colorspace,
) -> Result<u32, J2kError> {
    match colorspace {
        Colorspace::Grayscale | Colorspace::SGray => Ok(17),
        Colorspace::YCbCr => Ok(18),
        Colorspace::Rgb | Colorspace::SRgb | Colorspace::Rct | Colorspace::Ict => Ok(16),
        Colorspace::IccTagged if components == 1 => Ok(17),
        Colorspace::IccTagged if components == 3 || components == 4 => Ok(16),
        _ => Err(J2kError::Unsupported(Unsupported {
            what: "JP2/JPH wrapping for this colorspace requires an ICC profile",
        })),
    }
}

fn enumerated_colorspace_code(colorspace: Colorspace) -> Result<u32, J2kError> {
    match colorspace {
        Colorspace::Grayscale | Colorspace::SGray => Ok(17),
        Colorspace::YCbCr => Ok(18),
        Colorspace::Rgb | Colorspace::SRgb | Colorspace::Rct | Colorspace::Ict => Ok(16),
        _ => Err(J2kError::Unsupported(Unsupported {
            what: "JP2/JPH enumerated colorspace must be sRGB, sGray, or YCbCr",
        })),
    }
}