j2k-native 0.7.2

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
89
90
91
92
93
94
95
96
97

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

//! Move-only conversion from the internal 5/3 decomposition to the typed API output.

use super::super::single_tile::ownership::dwt_decompositions_retained_bytes;
#[cfg(test)]
use super::super::NativeEncodeRetainedInput;
use super::super::{
    allocation::{checked_add_bytes, checked_element_bytes, host_allocation_failed},
    DwtDecomposition, J2kForwardDwt53Level, J2kForwardDwt53Output, NativeEncodePipelineResult,
    NativeEncodeSession, Vec,
};

pub(in crate::j2c::encode) fn try_forward_dwt53_output_from_decomposition(
    decomposition: DwtDecomposition,
    session: &NativeEncodeSession<'_>,
    retained_base_bytes: usize,
) -> NativeEncodePipelineResult<J2kForwardDwt53Output> {
    let source_bytes = dwt_decompositions_retained_bytes(core::slice::from_ref(&decomposition), 0)?;
    session.checked_phase(
        checked_add_bytes(
            retained_base_bytes,
            source_bytes,
            "typed component DWT source",
        )?,
        "typed component DWT source",
    )?;
    let requested_owner_bytes = checked_element_bytes::<J2kForwardDwt53Level>(
        decomposition.levels.len(),
        "typed component DWT level owners",
    )?;
    session.checked_phase(
        checked_add_bytes(
            retained_base_bytes,
            checked_add_bytes(
                source_bytes,
                requested_owner_bytes,
                "typed component DWT conversion overlap",
            )?,
            "typed component DWT conversion overlap",
        )?,
        "typed component DWT conversion overlap",
    )?;
    let mut levels = Vec::new();
    levels
        .try_reserve_exact(decomposition.levels.len())
        .map_err(|_| {
            host_allocation_failed("typed component DWT level owners", requested_owner_bytes)
        })?;
    let actual_owner_bytes = checked_element_bytes::<J2kForwardDwt53Level>(
        levels.capacity(),
        "typed component DWT level owners",
    )?;
    session.checked_phase(
        checked_add_bytes(
            retained_base_bytes,
            checked_add_bytes(
                source_bytes,
                actual_owner_bytes,
                "typed component DWT conversion overlap",
            )?,
            "typed component DWT conversion overlap",
        )?,
        "typed component DWT conversion overlap",
    )?;
    levels.extend(decomposition.levels.into_iter().map(|level| {
        let width = level.low_width + level.high_width;
        let height = level.low_height + level.high_height;
        J2kForwardDwt53Level {
            hl: level.hl,
            lh: level.lh,
            hh: level.hh,
            width,
            height,
            low_width: level.low_width,
            low_height: level.low_height,
            high_width: level.high_width,
            high_height: level.high_height,
        }
    }));
    Ok(J2kForwardDwt53Output {
        ll: decomposition.ll,
        ll_width: decomposition.ll_width,
        ll_height: decomposition.ll_height,
        levels,
    })
}

#[cfg(test)]
pub(in crate::j2c::encode) fn forward_dwt53_output_from_decomposition(
    decomposition: DwtDecomposition,
) -> J2kForwardDwt53Output {
    let session = NativeEncodeSession::try_new(NativeEncodeRetainedInput::none())
        .expect("test DWT conversion session");
    try_forward_dwt53_output_from_decomposition(decomposition, &session, 0)
        .expect("test DWT conversion")
}