icu_lib 0.11.0

Image Converter Ultra Library
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

use crate::endecoder::lvgl;

pub use image;
pub use mirx;

pub mod endecoder;
pub mod midata;
pub mod postprocess;
type RawImageHeader = lvgl::ImageHeader;

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum PngColorMode {
    #[default]
    Rgba,
    Rgb,
    Indexed(u8),
    Preserve,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum PngCompression {
    Fast,
    #[default]
    Balanced,
    Best,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum MirxCoding {
    #[default]
    Raw,
    Pixel,
    Rle,
    Lz4,
    FrequencyReversible,
    FrequencyQuantized(u8),
}

pub struct EncoderParams {
    pub color_format: endecoder::ColorFormat,
    pub stride_align: u32,
    pub dither: Option<u32>,
    pub compress: lvgl::Compress,
    pub mirx_coding: MirxCoding,
    pub lvgl_version: lvgl::LVGLVersion,
    pub raw_image_header: Option<RawImageHeader>,
    pub png_color_mode: PngColorMode,
    pub png_compression: PngCompression,
    pub jpeg_quality: u8,
    pub jpeg_background: [u8; 3],
}

impl Default for EncoderParams {
    fn default() -> Self {
        Self {
            color_format: endecoder::ColorFormat::RGB565,
            stride_align: 1,
            dither: None,
            compress: Default::default(),
            mirx_coding: MirxCoding::default(),
            lvgl_version: lvgl::LVGLVersion::Unknown,
            raw_image_header: Default::default(),
            png_color_mode: PngColorMode::default(),
            png_compression: PngCompression::default(),
            jpeg_quality: 85,
            jpeg_background: [255, 255, 255],
        }
    }
}

impl EncoderParams {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_color_format(mut self, color_format: endecoder::ColorFormat) -> Self {
        self.color_format = color_format;
        self
    }

    pub fn with_stride_align(mut self, stride_align: u32) -> Self {
        self.stride_align = stride_align;
        self
    }

    pub fn with_dither(mut self, dither: Option<u32>) -> Self {
        self.dither = dither;
        self
    }

    pub fn with_compress(mut self, compress: lvgl::Compress) -> Self {
        self.compress = compress;
        self
    }

    pub fn with_mirx_coding(mut self, coding: MirxCoding) -> Self {
        self.mirx_coding = coding;
        self
    }

    pub fn with_lvgl_version(mut self, lvgl_version: lvgl::LVGLVersion) -> Self {
        self.lvgl_version = lvgl_version;
        self
    }

    pub fn with_raw_image_header(mut self, raw_image_header: RawImageHeader) -> Self {
        self.raw_image_header = Some(raw_image_header);
        self
    }

    pub fn with_png_color_mode(mut self, png_color_mode: PngColorMode) -> Self {
        self.png_color_mode = png_color_mode;
        self
    }

    pub fn with_png_compression(mut self, png_compression: PngCompression) -> Self {
        self.png_compression = png_compression;
        self
    }

    pub fn with_jpeg_quality(mut self, jpeg_quality: u8) -> Self {
        self.jpeg_quality = jpeg_quality;
        self
    }

    pub fn with_jpeg_background(mut self, jpeg_background: [u8; 3]) -> Self {
        self.jpeg_background = jpeg_background;
        self
    }
}