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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

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

use j2k_cuda_runtime::{
    CudaHtj2kPacketizationBlock, CudaHtj2kPacketizationPacket, CudaHtj2kPacketizationSubband,
    CudaHtj2kPacketizationSubbandTagState, CudaHtj2kPacketizationTagNodeState,
};

use crate::allocation::HostPhaseBudget;
use crate::encode::stage_error::{adapter_error, CudaStageResult};

use super::types::CudaHtj2kPacketizationPlan;

fn packetization_allocation_error(error: crate::Error) -> j2k::J2kEncodeStageError {
    adapter_error("allocate CUDA packetization runtime descriptors", error)
}

#[cfg(feature = "cuda-runtime")]
pub(in crate::encode) fn cuda_packetization_packets(
    plan: &CudaHtj2kPacketizationPlan,
    host_budget: &mut HostPhaseBudget,
) -> CudaStageResult<Vec<CudaHtj2kPacketizationPacket>> {
    let mut packets = host_budget
        .try_vec_with_capacity(plan.packets.len())
        .map_err(packetization_allocation_error)?;
    packets.extend(
        plan.packets
            .iter()
            .map(|packet| CudaHtj2kPacketizationPacket {
                block_start: packet.block_start,
                block_count: packet.block_count,
                subband_start: packet.subband_start,
                subband_count: packet.subband_count,
                output_capacity: packet.output_capacity,
                layer: packet.layer,
            }),
    );
    Ok(packets)
}

#[cfg(feature = "cuda-runtime")]
pub(in crate::encode) fn cuda_packetization_subbands(
    plan: &CudaHtj2kPacketizationPlan,
    host_budget: &mut HostPhaseBudget,
) -> CudaStageResult<Vec<CudaHtj2kPacketizationSubband>> {
    let mut subbands = host_budget
        .try_vec_with_capacity(plan.subbands.len())
        .map_err(packetization_allocation_error)?;
    subbands.extend(
        plan.subbands
            .iter()
            .map(|subband| CudaHtj2kPacketizationSubband {
                block_start: subband.block_start,
                block_count: subband.block_count,
                num_cbs_x: subband.num_cbs_x,
                num_cbs_y: subband.num_cbs_y,
            }),
    );
    Ok(subbands)
}

#[cfg(feature = "cuda-runtime")]
pub(in crate::encode) fn cuda_packetization_blocks(
    plan: &CudaHtj2kPacketizationPlan,
    host_budget: &mut HostPhaseBudget,
) -> CudaStageResult<Vec<CudaHtj2kPacketizationBlock>> {
    let mut blocks = host_budget
        .try_vec_with_capacity(plan.blocks.len())
        .map_err(packetization_allocation_error)?;
    blocks.extend(plan.blocks.iter().map(|block| CudaHtj2kPacketizationBlock {
        data_offset: block.data_offset,
        data_len: block.data_len,
        cleanup_length: block.cleanup_length,
        refinement_length: block.refinement_length,
        num_coding_passes: block.num_coding_passes,
        num_zero_bitplanes: block.num_zero_bitplanes,
        l_block: block.l_block,
        previously_included: block.previously_included,
        inclusion_layer: block.inclusion_layer,
    }));
    Ok(blocks)
}

#[cfg(feature = "cuda-runtime")]
pub(in crate::encode) fn cuda_packetization_tag_states(
    plan: &CudaHtj2kPacketizationPlan,
    host_budget: &mut HostPhaseBudget,
) -> CudaStageResult<Vec<CudaHtj2kPacketizationSubbandTagState>> {
    let mut states = host_budget
        .try_vec_with_capacity(plan.tag_states.len())
        .map_err(packetization_allocation_error)?;
    states.extend(
        plan.tag_states
            .iter()
            .map(|state| CudaHtj2kPacketizationSubbandTagState {
                inclusion_node_start: state.inclusion_node_start,
                zero_bitplane_node_start: state.zero_bitplane_node_start,
                node_count: state.node_count,
                reserved0: 0,
            }),
    );
    Ok(states)
}

#[cfg(feature = "cuda-runtime")]
pub(in crate::encode) fn cuda_packetization_tag_nodes(
    plan: &CudaHtj2kPacketizationPlan,
    host_budget: &mut HostPhaseBudget,
) -> CudaStageResult<Vec<CudaHtj2kPacketizationTagNodeState>> {
    let mut nodes = host_budget
        .try_vec_with_capacity(plan.tag_nodes.len())
        .map_err(packetization_allocation_error)?;
    nodes.extend(
        plan.tag_nodes
            .iter()
            .map(|node| CudaHtj2kPacketizationTagNodeState {
                current: node.current,
                known: node.known,
            }),
    );
    Ok(nodes)
}