j2k 0.6.0

GPU-aware JPEG 2000 and HTJ2K codec APIs in Rust
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

use j2k::adapter::device_plan::{DeviceDecodePlan, DeviceDecodeRequest};
use j2k_core::{Downscale, Rect};

#[test]
fn full_request_plan_uses_full_source_rect() {
    let plan = DeviceDecodePlan::for_image((320, 200), DeviceDecodeRequest::Full)
        .expect("full request plan");

    assert_eq!(plan.source_rect(), Rect::full((320, 200)));
    assert_eq!(plan.output_rect(), Rect::full((320, 200)));
    assert_eq!(plan.output_dims(), (320, 200));
    assert_eq!(plan.target_resolution(), None);
    assert!(plan.is_full_frame());
}

#[test]
fn scaled_request_plan_reports_target_resolution() {
    let plan = DeviceDecodePlan::for_image(
        (320, 200),
        DeviceDecodeRequest::Scaled {
            scale: Downscale::Quarter,
        },
    )
    .expect("scaled request plan");

    assert_eq!(plan.output_rect(), Rect::full((80, 50)));
    assert_eq!(plan.output_dims(), (80, 50));
    assert_eq!(plan.target_resolution(), Some((80, 50)));
}

#[test]
fn region_scaled_request_plan_uses_covering_scaled_rect() {
    let roi = Rect {
        x: 7,
        y: 9,
        w: 11,
        h: 13,
    };
    let plan = DeviceDecodePlan::for_image(
        (64, 64),
        DeviceDecodeRequest::RegionScaled {
            roi,
            scale: Downscale::Half,
        },
    )
    .expect("region scaled request plan");

    assert_eq!(plan.source_rect(), roi);
    assert_eq!(
        plan.output_rect(),
        Rect {
            x: 3,
            y: 4,
            w: 6,
            h: 7,
        }
    );
    assert_eq!(plan.output_dims(), (6, 7));
    assert_eq!(plan.target_resolution(), Some((6, 7)));
    assert!(!plan.is_full_frame());
}

#[test]
fn invalid_region_is_rejected() {
    let roi = Rect {
        x: 60,
        y: 60,
        w: 8,
        h: 8,
    };
    let result = DeviceDecodePlan::for_image((64, 64), DeviceDecodeRequest::Region { roi });

    assert!(result.is_err(), "out-of-bounds ROI must be rejected");
}