j2k-metal 0.8.1

Metal decoder and encode-stage adapter for j2k
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

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

use std::time::{Duration, Instant};

use j2k::J2kLosslessEncodeOptions;
use j2k_native::J2kPacketizationPacketDescriptor;

use crate::compute;

use super::{
    resident_schedule::SubmittedResidentLosslessChunkPipeline,
    submitted::OwnedMetalLosslessEncodeTile, LosslessDeviceEncodePlan, MetalEncodeInputStaging,
    MetalEncodedJ2k, MetalLosslessEncodeBatchStats,
};

pub(super) struct ResidentLosslessBufferEncodeMetadata {
    pub(super) tile: OwnedMetalLosslessEncodeTile,
    pub(super) components: u8,
    pub(super) bit_depth: u8,
    pub(super) bytes_per_pixel: usize,
    pub(super) code_block_count: usize,
    pub(super) resolution_count: usize,
    pub(super) plan: LosslessDeviceEncodePlan,
    pub(super) packet_descriptors: Vec<J2kPacketizationPacketDescriptor>,
    pub(super) packetization_resolutions: Vec<compute::J2kResidentPacketizationResolution>,
}

impl ResidentLosslessBufferEncodeMetadata {
    pub(super) fn take_packet_descriptors(&mut self) -> Vec<J2kPacketizationPacketDescriptor> {
        std::mem::take(&mut self.packet_descriptors)
    }

    pub(super) fn take_packetization_resolutions(
        &mut self,
    ) -> Vec<compute::J2kResidentPacketizationResolution> {
        std::mem::take(&mut self.packetization_resolutions)
    }
}

pub(super) struct PreparedResidentLosslessBufferEncode {
    pub(super) metadata: ResidentLosslessBufferEncodeMetadata,
    pub(super) prepared: compute::J2kPreparedLosslessDeviceCodeBlocks,
}

pub(super) struct PlannedResidentLosslessBufferEncode {
    pub(super) index: usize,
    pub(super) metadata: ResidentLosslessBufferEncodeMetadata,
    pub(super) coefficient_count: usize,
    pub(super) bytes_per_sample: u8,
    pub(super) estimated_peak_bytes: usize,
    #[cfg(test)]
    pub(super) failure_injection_index: Option<usize>,
}

impl PlannedResidentLosslessBufferEncode {
    pub(super) fn estimated_peak_bytes(&self) -> usize {
        self.estimated_peak_bytes
    }
}

pub(super) struct SubmittedResidentLosslessMetalBufferEncodeBatch {
    pub(super) options: J2kLosslessEncodeOptions,
    pub(super) session: crate::MetalBackendSession,
    pub(super) stats: MetalLosslessEncodeBatchStats,
    pub(super) encode_started: Instant,
    pub(super) tiles: Vec<OwnedMetalLosslessEncodeTile>,
    pub(super) staging: MetalEncodeInputStaging,
    pub(super) pipeline: Option<SubmittedResidentLosslessChunkPipeline>,
}

pub(super) struct SubmittedResidentLosslessMetalBufferEncodeChunk {
    pub(super) metadatas: Vec<ResidentLosslessBufferEncodeMetadata>,
    pub(super) prepare_durations: Vec<Duration>,
    pub(super) pending: compute::J2kPendingResidentLosslessCodestreamBatch,
    pub(super) batch_started: Instant,
}

pub(super) struct FinishedResidentLosslessBufferEncode {
    pub(super) metadata: ResidentLosslessBufferEncodeMetadata,
    pub(super) encoded: MetalEncodedJ2k,
    pub(super) encode_duration: Duration,
    pub(super) gpu_duration: Option<Duration>,
}