libqoi 0.3.2

A basic QOI encoder/decoder 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
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

use crate::shared::*;

// (cpxl.0 as isize - last.0 as isize) >= -2 && (cpxl.0 as isize - last.0 as isize) <= 1 &&
//             (cpxl.1 as isize - last.1 as isize) >= -2 && (cpxl.1 as isize - last.1 as isize) <= 1 &&
//             (cpxl.2 as isize - last.2 as isize) >= -2 && (cpxl.2 as isize - last.2 as isize) <= 1 &&
//             (cpxl.3 == last.3 as isize)

//
// 299534 - RGBA + run of one
// 45730 - run len + RBG + RBGA
// 29689 - run len + index + RBG + RBGA
// 26098 - run len + small diff + index + RGB + RBGA
// 22356 - run len + small diff + diff luma + index + RGB + RBGA
// 21855 - run len + small wapping diff + diff wapping luma + index + RGB + RBGA

#[inline]
fn can_use_small_dif(a: (u8, u8, u8, u8), b: (u8, u8, u8, u8)) -> bool {
    let dr = (a.0 as i8).wrapping_sub(b.0 as i8);
    let dg = (a.1 as i8).wrapping_sub(b.1 as i8);
    let db = (a.2 as i8).wrapping_sub(b.2 as i8);
    let da = (a.3 as i8).wrapping_sub(b.3 as i8);

    if da != 0 {
        return false;
    }

    dr >= -2 && dr <= 1 && dg >= -2 && dg <= 1 && db >= -2 && db <= 1
}

#[inline]
fn can_use_luma(a: (u8, u8, u8, u8), b: (u8, u8, u8, u8)) -> bool {
    let dr = a.0 as isize - b.0 as isize;
    let dg = a.1 as isize - b.1 as isize;
    let db = a.2 as isize - b.2 as isize;
    let da = a.3 as isize - b.3 as isize;

    let drdg = dr - dg;
    let dbdg = db - dg;

    if da != 0 {
        return false;
    }

    dg >= -32 && dg <= 31 && drdg >= -8 && drdg <= 7 && dbdg >= -8 && dbdg <= 7
}

/// Compresses raw image data to QOI.
/// img_data :  Row major RGBA image data
/// hight, width: Image size
/// channel_count: 3 = RBG, 4 = RBGA
/// Panics if img_data.len() is not divisable by 4
pub fn encode_qoi(
    img_data: &[u8],
    height: usize,
    width: usize,
    channel_count: u8,
    color_space: u8,
) -> Option<Vec<u8>> {
    let mut buf = Vec::new();
    let header = Header {
        height: height as u32,
        width: width as u32,
        channel_count: channel_count,
        color_space: color_space,
    };
    encode_header(header, &mut buf);
    let mut colorhashes = [(0u8, 0u8, 0u8, 0u8); 64];
    let mut last = (0u8, 0u8, 0u8, 255u8);

    let mut rest = img_data;

    while rest.len() > 0 {
        let cpxl = (rest[0], rest[1], rest[2], rest[3]);

        // Run 1

        if cpxl.0 == last.0 && cpxl.1 == last.1 && cpxl.2 == last.2 && cpxl.3 == last.3 {
            // We have more than one pixel of the same color, encode as run
            let mut runlen = 1_usize;
            // TODO find best run len
            rest = &rest[4..];
            while rest[0] == cpxl.0 && rest[1] == cpxl.1 && rest[2] == cpxl.2 && rest[3] == cpxl.3 {
                runlen += 1;
                rest = &rest[4..];
                if rest.len() == 0 {
                    break;
                }
                // respect the max runlen
                if runlen == 62 {
                    break;
                }
            }
            Part::Run(runlen as u8).encode(&mut buf);
            // we dont need to update the hashes or last pxl for runs
            // TODO this is a bit slow (recomputes hashes)
        } else if colorhashes[color_hash(cpxl.0, cpxl.1, cpxl.2, cpxl.3)] == cpxl {
            Part::Idx(color_hash(cpxl.0, cpxl.1, cpxl.2, cpxl.3) as u8).encode(&mut buf);
            rest = &rest[4..];
            last = cpxl;
        // todo
        } else if can_use_small_dif(cpxl, last) {
            let dr = (cpxl.0 as i8).wrapping_sub(last.0 as i8);
            let dg = (cpxl.1 as i8).wrapping_sub(last.1 as i8);
            let db = (cpxl.2 as i8).wrapping_sub(last.2 as i8);
            //             println!("diff {} {} {}",dr, dg, db);
            Part::SmallDiff(dr as i8, dg as i8, db as i8).encode(&mut buf);
            rest = &rest[4..];
        } else if can_use_luma(cpxl, last) {
            let dr = (cpxl.0 as i8).wrapping_sub(last.0 as i8);
            let dg = (cpxl.1 as i8).wrapping_sub(last.1 as i8);
            let db = (cpxl.2 as i8).wrapping_sub(last.2 as i8);
            let drdg = dr.wrapping_sub(dg);
            let dbdg = db.wrapping_sub(dg);
            Part::LumaDiff(drdg as i8, dg as i8, dbdg as i8).encode(&mut buf);
            rest = &rest[4..];
        // if the last alpha is the same as the old one, use RGB
        } else if cpxl.3 == last.3 {
            let r = rest[0];
            let g = rest[1];
            let b = rest[2];
            // RGB encodes one pixel
            Part::RGB(r, g, b).encode(&mut buf);
            rest = &rest[4..];
        } else {
            // Otherwize fallback to RGBA
            let r = rest[0];
            let g = rest[1];
            let b = rest[2];
            let a = rest[3];
            //             println!("{:?}", (r,g,b,a));
            Part::RGBA(r, g, b, a).encode(&mut buf);
            // RGBA encodes one pixel
            rest = &rest[4..];
        }
        add_hash_and_last(cpxl.0, cpxl.1, cpxl.2, cpxl.3, &mut colorhashes, &mut last);
    }
    // Padding to help detect truncation
    buf.push(0x00);
    buf.push(0x00);
    buf.push(0x00);
    buf.push(0x00);
    buf.push(0x00);
    buf.push(0x00);
    buf.push(0x00);
    buf.push(0x01);

    Some(buf)
}