j2k-cuda 0.8.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

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

#[cfg(not(feature = "cuda-runtime"))]
use super::CudaEncodeFallbackReason;
use super::{
    assert_strict_cuda_classic_tier1_error, BackendKind, CudaLosslessEncoder,
    EncodeBackendPreference, J2kBlockCodingMode, J2kEncodeValidation, J2kLosslessEncodeOptions,
    J2kLosslessSamples,
};

#[cfg(not(feature = "cuda-runtime"))]
#[test]
fn cuda_encoder_auto_reports_unavailable_fallback_and_reuses_after_success() {
    let pixels = vec![17u8; 16 * 16];
    let samples =
        J2kLosslessSamples::new(&pixels, 16, 16, 1, 8, false).expect("valid gray8 samples");
    let options = J2kLosslessEncodeOptions::default()
        .with_backend(EncodeBackendPreference::Auto)
        .with_block_coding_mode(J2kBlockCodingMode::HighThroughput)
        .with_max_decomposition_levels(Some(0))
        .with_validation(J2kEncodeValidation::CpuRoundTrip);
    let mut encoder = CudaLosslessEncoder::new();

    for _ in 0..2 {
        let result = encoder
            .encode(samples, &options)
            .expect("Auto must fall back when CUDA support is not compiled");

        assert_eq!(result.requested_backend(), EncodeBackendPreference::Auto);
        assert_eq!(result.actual_backend(), BackendKind::Cpu);
        assert_eq!(
            result.fallback_reason(),
            Some(CudaEncodeFallbackReason::DeviceUnavailable)
        );
        assert_eq!(
            result.dispatch_report(),
            j2k::J2kEncodeDispatchReport::default()
        );
        assert!(!result.encoded().codestream.is_empty());
    }
}

#[test]
fn cuda_encoder_cpu_only_reports_no_fallback() {
    let pixels = vec![23u8; 16 * 16];
    let samples =
        J2kLosslessSamples::new(&pixels, 16, 16, 1, 8, false).expect("valid gray8 samples");
    let options = J2kLosslessEncodeOptions::default()
        .with_backend(EncodeBackendPreference::CpuOnly)
        .with_max_decomposition_levels(Some(0))
        .with_validation(J2kEncodeValidation::CpuRoundTrip);
    let mut encoder = CudaLosslessEncoder::new();

    let result = encoder
        .encode(samples, &options)
        .expect("CPU-only encode must not require CUDA");

    assert_eq!(result.requested_backend(), EncodeBackendPreference::CpuOnly);
    assert_eq!(result.actual_backend(), BackendKind::Cpu);
    assert_eq!(result.fallback_reason(), None);
    assert_eq!(
        result.dispatch_report(),
        j2k::J2kEncodeDispatchReport::default()
    );
}

#[test]
fn cuda_encoder_reuses_after_strict_route_failure() {
    let pixels = vec![31u8; 16 * 16];
    let samples =
        J2kLosslessSamples::new(&pixels, 16, 16, 1, 8, false).expect("valid gray8 samples");
    let cpu_template = J2kLosslessEncodeOptions::default()
        .with_backend(EncodeBackendPreference::CpuOnly)
        .with_block_coding_mode(J2kBlockCodingMode::Classic)
        .with_max_decomposition_levels(Some(0))
        .with_validation(J2kEncodeValidation::External);
    let cpu_options = cpu_template.with_validation(J2kEncodeValidation::CpuRoundTrip);
    let mut encoder = CudaLosslessEncoder::new();

    let error = encoder
        .encode_strict_cuda(samples, &cpu_template)
        .expect_err("strict method must override the CPU-only template");
    assert_strict_cuda_classic_tier1_error(&error, "reusable strict CUDA encoder");

    let result = encoder
        .encode(samples, &cpu_options)
        .expect("a route failure must not poison later jobs");
    assert_eq!(result.requested_backend(), EncodeBackendPreference::CpuOnly);
    assert_eq!(result.actual_backend(), BackendKind::Cpu);
    assert_eq!(result.fallback_reason(), None);
}

#[test]
fn cuda_lossless_encoder_is_send() {
    fn assert_send<T: Send>() {}

    assert_send::<CudaLosslessEncoder>();
}