tinytga 0.5.0

No-std, low memory footprint TGA image loader
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

use embedded_graphics::{
    image::Image,
    mock_display::{ColorMapping, MockDisplay},
    pixelcolor::{Gray8, Rgb555, Rgb888},
    prelude::*,
};
use paste::paste;
use tinytga::Tga;

const CHESSBOARD_PATTERN: &[&str] = &[
    "WKWK", //
    "KRKG", //
    "WKBK", //
    "KWKW", //
];

const GRAY_PATTERN: &[&str] = &[
    "0F0F0F0F0",
    "00FF00FF0",
    "0000FFFF0",
    "012345670",
    "89ABCDEF0",
];

const COLOR_PATTERN: &[&str] = &[
    "WKRGBYMCW",
    "KKRGBYMCW",
    "WKRGBYMCW",
    "KKKKKKKKK",
    "WKWCMYBGR",
];

#[test]
fn chessboard_compressed() {
    let tga = Tga::from_slice(include_bytes!("./chessboard_4px_rle.tga")).unwrap();
    let image = Image::new(&tga, Point::zero());

    let mut display = MockDisplay::<Rgb888>::new();
    image.draw(&mut display).unwrap();

    display.assert_pattern(CHESSBOARD_PATTERN);
}

#[test]
fn chessboard_uncompressed() {
    let tga = Tga::from_slice(include_bytes!("./chessboard_raw.tga")).unwrap();
    let image = Image::new(&tga, Point::zero());

    let mut display = MockDisplay::<Rgb888>::new();
    image.draw(&mut display).unwrap();

    display.assert_pattern(CHESSBOARD_PATTERN);
}

fn test_tga<C>(data: &[u8], pattern: &[&str])
where
    C: PixelColor + From<Gray8> + From<Rgb555> + From<Rgb888> + ColorMapping,
{
    let tga = Tga::from_slice(data).unwrap();
    let image = Image::new(&tga, Point::zero());

    let mut display = MockDisplay::<C>::new();
    image.draw(&mut display).unwrap();

    display.assert_pattern(pattern);
}

fn test_pixels_iter<C>(data: &[u8], pattern: &[&str])
where
    C: PixelColor + From<Gray8> + From<Rgb555> + From<Rgb888> + ColorMapping,
{
    let tga = Tga::from_slice(data).unwrap();

    let mut display = MockDisplay::<Rgb888>::new();
    tga.pixels().draw(&mut display).unwrap();

    let expected: MockDisplay<Rgb888> = MockDisplay::<C>::from_pattern(pattern).map(|c| c.into());

    display.assert_eq(&expected);
}

macro_rules! test_tga {
    ($image_type:ident, $color_type:ty, $pattern:expr) => {
        paste! {
            #[test]
            fn [<$image_type _bl>]() {
                test_tga::<$color_type>(include_bytes!(concat!(stringify!($image_type), "_bl.tga")), $pattern);
            }

            #[test]
            fn [<$image_type _tl>]() {
                test_tga::<$color_type>(include_bytes!(concat!(stringify!($image_type), "_tl.tga")), $pattern);
            }

            #[test]
            fn [<$image_type _bl_pixels_iter>]() {
                test_pixels_iter::<$color_type>(include_bytes!(concat!(stringify!($image_type), "_bl.tga")), $pattern);
            }

            #[test]
            fn [<$image_type _tl_pixels_iter>]() {
                test_pixels_iter::<$color_type>(include_bytes!(concat!(stringify!($image_type), "_tl.tga")), $pattern);
            }
        }
    };

    ($image_type:ident, Rgb555) => {
        test_tga!($image_type, Rgb555, COLOR_PATTERN);
    };

    ($image_type:ident, Rgb888) => {
        test_tga!($image_type, Rgb888, COLOR_PATTERN);
    };

    ($image_type:ident, Gray8) => {
        test_tga!($image_type, Gray8, GRAY_PATTERN);
    };
}

// Type 1: color mapped, uncompressed
test_tga!(type1_16bpp, Rgb555);
test_tga!(type1_24bpp, Rgb888);

// Type 2: true color, uncompressed
test_tga!(type2_16bpp, Rgb555);
test_tga!(type2_24bpp, Rgb888);

// Type 3: grayscale, uncompressed
test_tga!(type3, Gray8);

// Type 9: color mapped, RLE compressed
test_tga!(type9_16bpp, Rgb555);
test_tga!(type9_24bpp, Rgb888);

// Type 10: true color, RLE compressed
test_tga!(type10_16bpp, Rgb555);
test_tga!(type10_24bpp, Rgb888);

// Type 11: grayscale, RLE compressed
test_tga!(type11, Gray8);