j2k-native 0.8.1

Pure-Rust JPEG 2000 and HTJ2K codec engine 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

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

//! JP2/JPH wrapper and codestream consistency validation.

use crate::error::{bail, FormatError, Result};

use super::container::Jp2FileKind;
use super::{ComponentDescriptor, ImageBoxes};

pub(super) fn validate_codestream_file_kind(
    file_kind: Jp2FileKind,
    header: &crate::j2c::Header<'_>,
) -> Result<()> {
    let high_throughput = header.component_infos.iter().any(|component| {
        component
            .code_block_style()
            .uses_high_throughput_block_coding()
    });
    match (file_kind, high_throughput) {
        (Jp2FileKind::Jph, false) | (Jp2FileKind::Jp2, true) => {
            bail!(FormatError::InvalidFileType);
        }
        _ => Ok(()),
    }
}

pub(super) fn validate_image_header_matches_codestream(
    boxes: &ImageBoxes,
    header: &crate::j2c::Header<'_>,
) -> Result<()> {
    let Some(image_header) = boxes.image_header else {
        bail!(FormatError::InvalidBox);
    };
    if image_header.width != header.size_data.reference_image_width()
        || image_header.height != header.size_data.reference_image_height()
    {
        bail!(FormatError::InvalidBox);
    }
    Ok(())
}

pub(super) fn validate_component_precision_metadata(
    boxes: &ImageBoxes,
    header: &crate::j2c::Header<'_>,
) -> Result<()> {
    let Some(image_header) = boxes.image_header else {
        bail!(FormatError::InvalidBox);
    };
    let codestream_count = header.component_infos.len();
    if codestream_count != usize::from(image_header.components) {
        bail!(FormatError::InvalidBox);
    }

    if let Some(descriptor) = image_header.bits_per_component {
        if !boxes.bits_per_component.is_empty() {
            bail!(FormatError::InvalidBox);
        }
        for component in &header.component_infos {
            let component = component_descriptor_from_size_info(
                component.size_info.precision,
                component.size_info.signed,
            );
            if component != descriptor {
                bail!(FormatError::InvalidBox);
            }
        }
    } else {
        if boxes.bits_per_component.len() != usize::from(image_header.components) {
            bail!(FormatError::InvalidBox);
        }
        for (component, descriptor) in header.component_infos.iter().zip(&boxes.bits_per_component)
        {
            let component = component_descriptor_from_size_info(
                component.size_info.precision,
                component.size_info.signed,
            );
            if component != *descriptor {
                bail!(FormatError::InvalidBox);
            }
        }
    }

    Ok(())
}

fn component_descriptor_from_size_info(bit_depth: u8, signed: bool) -> ComponentDescriptor {
    ComponentDescriptor { bit_depth, signed }
}