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
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

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

use super::super::{
    execute_hybrid_cpu_tier1_direct_color_plan_batch, hybrid_repeated_output_blits_for_test,
    prepare_direct_color_plan, reset_hybrid_cpu_decode_inputs_for_test,
    reset_hybrid_repeated_output_blits_for_test, reset_thread_hybrid_cpu_decode_inputs_for_test,
    thread_hybrid_cpu_decode_inputs_for_test,
};
use super::{
    hybrid_support::{
        cached_direct_color_tier1_input_count, prepared_direct_color_tier1_input_count,
        HYBRID_COUNTER_TEST_LOCK,
    },
    runtime::should_run_metal_runtime,
};
use j2k_core::PixelFormat;
use j2k_native::{encode, DecodeSettings, DecoderContext, EncodeOptions, Image};
use std::sync::Arc;

#[test]
fn hybrid_rgb8_reused_plan_caches_cpu_tier1_inputs_across_calls() {
    if !should_run_metal_runtime() {
        return;
    }

    let pixels = j2k_test_support::gradient_u8(32, 32, 3);
    let options = EncodeOptions {
        reversible: true,
        num_decomposition_levels: 2,
        ..EncodeOptions::default()
    };
    let bytes = encode(&pixels, 32, 32, 3, 8, false, &options).expect("encode rgb8");
    let image = Image::new(&bytes, &DecodeSettings::default()).expect("image");
    let mut context = DecoderContext::default();
    let plan = image
        .build_direct_color_plan_with_context(&mut context)
        .expect("direct color plan");
    let prepared = Arc::new(prepare_direct_color_plan(&plan).expect("prepared color plan"));
    let unique_tier1_inputs = prepared_direct_color_tier1_input_count(&prepared);
    assert!(
        unique_tier1_inputs > 0,
        "fixture should have Tier-1 inputs to decode"
    );
    let _guard = HYBRID_COUNTER_TEST_LOCK
        .lock()
        .expect("hybrid counter lock");
    reset_hybrid_cpu_decode_inputs_for_test();
    reset_thread_hybrid_cpu_decode_inputs_for_test();

    let surfaces = execute_hybrid_cpu_tier1_direct_color_plan_batch(
        &[prepared.clone(), prepared.clone()],
        PixelFormat::Rgb8,
    )
    .expect("first hybrid repeated RGB8 batch");
    assert_eq!(surfaces.len(), 2);
    assert_eq!(
        cached_direct_color_tier1_input_count(&prepared),
        unique_tier1_inputs,
        "first RGB hybrid call should cache every decoded CPU Tier-1 input"
    );
    assert_eq!(
        thread_hybrid_cpu_decode_inputs_for_test(),
        unique_tier1_inputs,
        "first RGB hybrid call should decode each shared Tier-1 input once"
    );

    let surfaces = execute_hybrid_cpu_tier1_direct_color_plan_batch(
        &[prepared.clone(), prepared.clone()],
        PixelFormat::Rgb8,
    )
    .expect("second hybrid repeated RGB8 batch");
    assert_eq!(surfaces.len(), 2);
    assert_eq!(
        cached_direct_color_tier1_input_count(&prepared),
        unique_tier1_inputs,
        "second RGB hybrid call should keep every decoded CPU Tier-1 input cached"
    );
    assert_eq!(
        thread_hybrid_cpu_decode_inputs_for_test(),
        unique_tier1_inputs,
        "second RGB hybrid call must reuse cached CPU Tier-1 coefficients without re-decoding"
    );
}

#[test]
fn hybrid_rgb8_repeated_batch_decodes_once_and_blits_distinct_outputs() {
    if !should_run_metal_runtime() {
        return;
    }

    let pixels = j2k_test_support::gradient_u8(32, 32, 3);
    let options = EncodeOptions {
        reversible: true,
        num_decomposition_levels: 2,
        ..EncodeOptions::default()
    };
    let bytes = encode(&pixels, 32, 32, 3, 8, false, &options).expect("encode rgb8");
    let image = Image::new(&bytes, &DecodeSettings::default()).expect("image");
    let mut context = DecoderContext::default();
    let plan = image
        .build_direct_color_plan_with_context(&mut context)
        .expect("direct color plan");
    let prepared = Arc::new(prepare_direct_color_plan(&plan).expect("prepared color plan"));
    let _guard = HYBRID_COUNTER_TEST_LOCK
        .lock()
        .expect("hybrid counter lock");
    reset_hybrid_repeated_output_blits_for_test();

    let surfaces = execute_hybrid_cpu_tier1_direct_color_plan_batch(
        &[
            prepared.clone(),
            prepared.clone(),
            prepared.clone(),
            prepared,
        ],
        PixelFormat::Rgb8,
    )
    .expect("hybrid repeated RGB8 batch");

    assert_eq!(surfaces.len(), 4);
    let surface_bytes = surfaces[0].as_bytes().expect("surface byte access").len();
    let offsets = surfaces
        .iter()
        .map(|surface| {
            surface
                .metal_buffer_trusted()
                .expect("resident Metal surface")
                .1
        })
        .collect::<Vec<_>>();
    assert_eq!(
        offsets,
        (0..surfaces.len())
            .map(|index| index * surface_bytes)
            .collect::<Vec<_>>(),
        "repeated outputs must retain distinct Metal buffer offsets"
    );
    for surface in &surfaces[1..] {
        assert_eq!(
            surface.as_bytes().expect("surface byte access"),
            surfaces[0].as_bytes().expect("surface byte access"),
            "repeated outputs should remain byte-identical"
        );
    }
    assert_eq!(
        hybrid_repeated_output_blits_for_test(),
        2,
        "repeated RGB hybrid batches should duplicate packed output surfaces with logarithmic Metal blit ranges"
    );
}