j2k-cuda 0.11.0

CUDA adapter for resident HTJ2K decode/encode and shared JPEG 2000 stages
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

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

use super::*;
use j2k_native::{encode, encode_htj2k, DecodeSettings, DecoderContext, EncodeOptions, Image};

#[test]
fn classic_cuda_plan_retains_irreversible_midpoint_reconstruction() {
    let pixels = j2k_test_support::gradient_u8(16, 16, 1);
    let bytes = encode(
        &pixels,
        16,
        16,
        1,
        8,
        false,
        &EncodeOptions {
            reversible: false,
            num_decomposition_levels: 2,
            ..EncodeOptions::default()
        },
    )
    .expect("encode irreversible grayscale");
    let image = Image::new(&bytes, &DecodeSettings::default()).expect("image");
    let mut context = DecoderContext::default();
    let direct = image
        .build_direct_grayscale_plan_with_context(&mut context)
        .expect("direct plan");

    let cuda = CudaHtj2kDecodePlan::from_grayscale_direct_plan(&direct, PixelFormat::Gray8, (0, 0))
        .expect("CUDA plan");

    assert!(
        cuda.classic_subbands
            .iter()
            .all(|subband| subband.irreversible_midpoint),
        "every classic CUDA sub-band must retain the 9/7 reconstruction rule"
    );
}

#[test]
fn classic_cuda_plan_accepts_roi_maxshift() {
    let pixels = j2k_test_support::gradient_u8(16, 16, 1);
    let bytes = encode(
        &pixels,
        16,
        16,
        1,
        8,
        false,
        &EncodeOptions {
            reversible: true,
            num_decomposition_levels: 2,
            roi_component_shifts: vec![7],
            ..EncodeOptions::default()
        },
    )
    .expect("encode ROI maxshift grayscale");
    let image = Image::new(&bytes, &DecodeSettings::default()).expect("image");
    let mut context = DecoderContext::default();
    let direct = image
        .build_direct_grayscale_plan_with_context(&mut context)
        .expect("direct ROI plan");

    let cuda = CudaHtj2kDecodePlan::from_grayscale_direct_plan(&direct, PixelFormat::Gray8, (0, 0))
        .expect("CUDA classic ROI plan");
    assert!(
        cuda.classic_code_blocks
            .iter()
            .all(|block| block.roi_shift == 7),
        "every classic CUDA code-block must retain the component ROI maxshift"
    );
}

#[test]
fn ht_cuda_plan_retains_irreversible_midpoint_reconstruction() {
    let pixels = j2k_test_support::gradient_u8(32, 32, 1);
    let bytes = encode_htj2k(
        &pixels,
        32,
        32,
        1,
        8,
        false,
        &EncodeOptions {
            reversible: false,
            num_decomposition_levels: 3,
            ..EncodeOptions::default()
        },
    )
    .expect("encode irreversible HTJ2K");
    let image = Image::new(&bytes, &DecodeSettings::default()).expect("image");
    let mut context = DecoderContext::default();
    let direct = image
        .build_direct_grayscale_plan_with_context(&mut context)
        .expect("direct HTJ2K plan");

    let cuda = CudaHtj2kDecodePlan::from_grayscale_direct_plan(&direct, PixelFormat::Gray8, (0, 0))
        .expect("CUDA HTJ2K plan");
    assert!(
        !cuda.code_blocks().is_empty()
            && cuda
                .code_blocks()
                .iter()
                .all(|block| block.irreversible_midpoint),
        "every HT CUDA code-block must retain the fixed-point reconstruction rule"
    );
}