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
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

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

#[cfg(feature = "cuda-runtime")]
use j2k::J2kEncodeStageError;

#[cfg(feature = "cuda-runtime")]
use crate::encode::stage_error::{adapter_error, arithmetic_overflow};

pub(super) const CUDA_PACKETIZATION_TAG_TREE_ALLOCATION: &str =
    "CUDA HTJ2K packetization tag-tree state";

#[derive(Debug)]
pub(in crate::encode) enum CudaHtj2kPacketizationPlanError {
    Invalid(&'static str),
    ArithmeticOverflow(&'static str),
    MemoryCapExceeded {
        what: &'static str,
        requested: usize,
        cap: usize,
    },
    HostAllocation {
        what: &'static str,
        bytes: usize,
    },
    Adapter(crate::Error),
}

impl CudaHtj2kPacketizationPlanError {
    #[cfg(feature = "cuda-runtime")]
    pub(in crate::encode) fn into_stage_error(self) -> J2kEncodeStageError {
        match self {
            Self::Invalid(what) => J2kEncodeStageError::invalid_request(what),
            Self::ArithmeticOverflow(what) => arithmetic_overflow(what),
            Self::MemoryCapExceeded {
                what,
                requested,
                cap,
            } => J2kEncodeStageError::memory_cap_exceeded(what, requested, cap),
            Self::HostAllocation { what, bytes } => {
                J2kEncodeStageError::host_allocation_failed(what, bytes)
            }
            Self::Adapter(source) => adapter_error("prepare CUDA HTJ2K packetization plan", source),
        }
    }
}

impl PartialEq for CudaHtj2kPacketizationPlanError {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Invalid(left), Self::Invalid(right))
            | (Self::ArithmeticOverflow(left), Self::ArithmeticOverflow(right)) => left == right,
            (
                Self::MemoryCapExceeded {
                    what: left_what,
                    requested: left_requested,
                    cap: left_cap,
                },
                Self::MemoryCapExceeded {
                    what: right_what,
                    requested: right_requested,
                    cap: right_cap,
                },
            ) => {
                left_what == right_what
                    && left_requested == right_requested
                    && left_cap == right_cap
            }
            (
                Self::HostAllocation {
                    what: left_what,
                    bytes: left_bytes,
                },
                Self::HostAllocation {
                    what: right_what,
                    bytes: right_bytes,
                },
            ) => left_what == right_what && left_bytes == right_bytes,
            _ => false,
        }
    }
}

pub(super) fn packetization_plan_allocation_error(
    error: crate::Error,
) -> CudaHtj2kPacketizationPlanError {
    match error {
        crate::Error::HostAllocationFailed { bytes, what } => {
            CudaHtj2kPacketizationPlanError::HostAllocation { what, bytes }
        }
        crate::Error::HostAllocationTooLarge {
            requested,
            cap,
            what,
        } => CudaHtj2kPacketizationPlanError::MemoryCapExceeded {
            what,
            requested,
            cap,
        },
        source => CudaHtj2kPacketizationPlanError::Adapter(source),
    }
}

pub(super) type PacketizationPlanResult<T> =
    core::result::Result<T, CudaHtj2kPacketizationPlanError>;