j2k-metal 0.7.3

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

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

#[cfg(target_os = "macos")]
pub(crate) use j2k_core::{
    checked_batch_count_product as checked_count_product,
    checked_batch_count_sum as checked_count_sum, try_batch_reserve_to as try_reserve_to,
};
pub(crate) use j2k_core::{
    try_batch_reserve_for_push as try_reserve_for_push,
    BatchAllocationBudget as BatchMetadataBudget, BatchAllocationRequest as BatchMetadataRequest,
};

#[cfg(test)]
mod tests {
    use core::mem::size_of;

    use j2k_core::{BatchInfrastructureError, CodecError};

    use super::{BatchMetadataBudget, BatchMetadataRequest};
    use crate::Error;

    #[test]
    fn j2k_grouped_result_plan_honors_exact_cap_and_one_byte_over() {
        type ResultSlot = Option<Result<u16, Error>>;
        let count = 3;
        let exact_cap = count * size_of::<ResultSlot>() * 2;
        let requests = [
            BatchMetadataRequest::of::<ResultSlot>(count),
            BatchMetadataRequest::of::<ResultSlot>(count),
        ];
        let mut exact =
            BatchMetadataBudget::with_cap("J2K Metal grouped result collection", exact_cap);
        exact
            .preflight(&requests)
            .expect("exact grouped result cap");
        let first = exact
            .try_vec::<ResultSlot>(count, "J2K Metal grouped result slots")
            .expect("first result vector");
        let second = exact
            .try_vec::<ResultSlot>(count, "J2K Metal ordered result slots")
            .expect("second result vector");
        assert_eq!(first.capacity(), count);
        assert_eq!(second.capacity(), count);

        assert_eq!(
            BatchMetadataBudget::with_cap("J2K Metal grouped result collection", exact_cap - 1)
                .preflight(&requests)
                .expect_err("one byte over grouped result cap"),
            BatchInfrastructureError::AllocationTooLarge {
                what: "J2K Metal grouped result collection",
                requested: exact_cap,
                cap: exact_cap - 1,
            }
        );
    }

    #[test]
    fn allocator_failure_keeps_batch_infrastructure_source_and_category() {
        let mut budget = BatchMetadataBudget::with_cap("test batch metadata", usize::MAX);
        let source = budget
            .try_vec::<u8>(usize::MAX, "test result slots")
            .expect_err("impossible reservation");
        let error = Error::from(source);

        assert!(matches!(
            &error,
            Error::BatchInfrastructure(BatchInfrastructureError::HostAllocationFailed {
                what: "test result slots",
                bytes: usize::MAX,
            })
        ));
        assert!(std::error::Error::source(&error)
            .and_then(|source| source.downcast_ref::<BatchInfrastructureError>())
            .is_some());
        assert!(!error.is_unsupported());
        assert!(!error.is_buffer_error());
    }
}