j2k-cuda 0.7.5

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

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

use super::flatten::flatten_cuda_htj2k_packetization_job_classified;
use super::state::checked_cuda_packetization_state_count;
use super::types::{packetization_plan_allocation_error, CudaHtj2kPacketizationPlanError};
use j2k::{
    J2kPacketizationEncodeJob, J2kPacketizationPacketDescriptor, J2kPacketizationProgressionOrder,
    J2kPacketizationResolution,
};

mod ht_segment;

#[test]
fn sparse_descriptor_state_index_is_rejected_before_state_allocation() {
    let descriptor = J2kPacketizationPacketDescriptor {
        packet_index: 0,
        state_index: u32::MAX,
        layer: 0,
        resolution: 0,
        component: 0,
        precinct: 0,
    };
    let resolution = J2kPacketizationResolution {
        subbands: Vec::new(),
    };
    let error = flatten_cuda_htj2k_packetization_job_classified(J2kPacketizationEncodeJob {
        resolution_count: 1,
        num_layers: 1,
        num_components: 1,
        code_block_count: 0,
        progression_order: J2kPacketizationProgressionOrder::Lrcp,
        packet_descriptors: &[descriptor],
        resolutions: &[resolution],
    })
    .expect_err("sparse state indexes must fail before host allocation");

    assert_eq!(
        error,
        CudaHtj2kPacketizationPlanError::Invalid(
            "CUDA HTJ2K packetization descriptor state index exceeds descriptor count"
        )
    );
}

#[test]
fn descriptor_state_count_addition_is_checked() {
    assert_eq!(
        checked_cuda_packetization_state_count(Some(usize::MAX)).unwrap_err(),
        CudaHtj2kPacketizationPlanError::Invalid(
            "CUDA HTJ2K packetization descriptor state count overflow"
        )
    );
}

#[test]
fn packetization_plan_allocation_failure_keeps_its_typed_category() {
    let source = crate::Error::HostAllocationFailed {
        bytes: 4096,
        what: "test packetization plan",
    };

    assert_eq!(
        packetization_plan_allocation_error(source),
        CudaHtj2kPacketizationPlanError::HostAllocation {
            bytes: 4096,
            what: "test packetization plan"
        }
    );
}