j2k-jpeg 0.7.0

JPEG inspect/decode and fallback encode support 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

//! SOF/SOS validation shared by the header and progressive-script walkers.

use crate::error::JpegError;
use crate::info::SofKind;
use crate::parse::scan::ParsedScan;
use crate::parse::sof::ParsedSof;

pub(super) fn validate_scan_parameters(
    sof_kind: SofKind,
    scan: &ParsedScan,
    offset: usize,
) -> Result<(), JpegError> {
    if matches!(sof_kind, SofKind::Baseline8 | SofKind::Extended8)
        && (scan.ss != 0 || scan.se != 63 || scan.ah != 0 || scan.al != 0)
    {
        return Err(JpegError::InvalidScanParameters {
            offset,
            ss: scan.ss,
            se: scan.se,
            ah: scan.ah,
            al: scan.al,
        });
    }
    Ok(())
}

pub(super) const fn normalize_restart_interval(interval: u16) -> Option<u16> {
    if interval == 0 {
        None
    } else {
        Some(interval)
    }
}

#[expect(
    clippy::cast_possible_truncation,
    reason = "validated sequential scan component counts fit the JPEG SOS byte field"
)]
pub(super) fn validate_sequential_scan_components(
    sof: &ParsedSof,
    scan: &ParsedScan,
    offset: usize,
) -> Result<(), JpegError> {
    if !matches!(sof.sof_kind, SofKind::Baseline8 | SofKind::Extended8) {
        return Ok(());
    }

    validate_known_unique_components(sof, scan, offset)?;
    if scan.components.len() != sof.component_ids.len() {
        return Err(JpegError::InvalidSequentialComponentSet {
            offset,
            expected: sof.component_ids.len() as u8,
            found: scan.components.len() as u8,
        });
    }
    Ok(())
}

pub(super) fn validate_progressive_scan_components(
    sof: &ParsedSof,
    scan: &ParsedScan,
    offset: usize,
) -> Result<(), JpegError> {
    if !matches!(sof.sof_kind, SofKind::Progressive8 | SofKind::Progressive12) {
        return Ok(());
    }
    if scan.components.is_empty()
        || scan.ss > scan.se
        || scan.se > 63
        || scan.ah > 13
        || scan.al > 13
        || (scan.ah != 0 && scan.ah != scan.al + 1)
        || (scan.ss == 0 && scan.se != 0)
        || (scan.ss > 0 && scan.components.len() != 1)
    {
        return Err(JpegError::InvalidScanParameters {
            offset,
            ss: scan.ss,
            se: scan.se,
            ah: scan.ah,
            al: scan.al,
        });
    }
    validate_known_unique_components(sof, scan, offset)
}

fn validate_known_unique_components(
    sof: &ParsedSof,
    scan: &ParsedScan,
    offset: usize,
) -> Result<(), JpegError> {
    for (index, component) in scan.components.iter().enumerate() {
        let component_offset = offset + 1 + index * 2;
        if !sof.component_ids.contains(&component.id) {
            return Err(JpegError::UnknownScanComponent {
                offset: component_offset,
                component: component.id,
            });
        }
        if scan.components.as_slice()[..index]
            .iter()
            .any(|seen| seen.id == component.id)
        {
            return Err(JpegError::DuplicateScanComponent {
                offset: component_offset,
                component: component.id,
            });
        }
    }
    Ok(())
}