image-encoder 0.1.0

simple image encoder for png encoding
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

mod zlib;

use crc::{crc32, Hasher32};
use std::io;
use zlib::compress;

pub struct Image<'a> {
    pub width: u32,
    pub height: u32,
    data: &'a [u8],
}

impl<'a> Image<'a> {
    pub fn new(data: &'a [u8], width: u32, height: u32) -> Image<'a> {
        Image {
            data,
            width,
            height,
        }
    }

    pub fn encode_into<W: io::Write>(&self, buffer: &mut W) -> io::Result<()> {
        write_header(buffer)?;
        write_chunks(buffer, self.data, self.width, self.height)
    }
}

pub fn write_header<W: io::Write>(buffer: &mut W) -> io::Result<()> {
    buffer.write_all(b"\x89PNG\r\n\x1A\n")
}

pub fn write_chunks<W: io::Write>(
    buffer: &mut W,
    screen_data: &[u8],
    width: u32,
    height: u32,
) -> io::Result<()> {
    write_ihdr(buffer, width, height, 8u8, 6u8, 0u8, 0u8, 0u8)?;
    write_idat(buffer, screen_data, width, height)?;
    write_iend(buffer)?;

    Ok(())
}

fn write_ihdr<W: io::Write>(
    buffer: &mut W,
    width: u32,
    height: u32,
    bit_depth: u8,
    color_type: u8,
    compression_method: u8,
    filter_method: u8,
    interlace_method: u8,
) -> io::Result<()> {
    let wb = width.to_be_bytes();
    let hb = height.to_be_bytes();
    let mut data = [
        wb[0],
        wb[1],
        wb[2],
        wb[3],
        hb[0],
        hb[1],
        hb[2],
        hb[3],
        bit_depth,
        color_type,
        compression_method,
        filter_method,
        interlace_method,
    ];
    write_chunk(buffer, b"IHDR", &mut data)
}

fn write_idat<W: io::Write>(
    buffer: &mut W,
    screen_data: &[u8],
    width: u32,
    height: u32,
) -> io::Result<()> {
    let mut filtered = vec![];
    for y in 0..height {
        let start = (y * width * 4) as usize;
        let end = start + (width as usize) * 4;
        filtered.push(0);
        let data = &screen_data[start..end];
        filtered.extend_from_slice(data);
    }
    let compressed = compress(&filtered);

    write_chunk(buffer, b"IDAT", &compressed)
}

fn write_iend<W: io::Write>(buffer: &mut W) -> io::Result<()> {
    write_chunk(buffer, b"IEND", &[])
}

fn write_chunk<W: io::Write>(buffer: &mut W, kind: &[u8; 4], data: &[u8]) -> io::Result<()> {
    buffer.write_all(&(data.len() as u32).to_be_bytes())?;
    buffer.write_all(kind)?;
    buffer.write_all(data)?;

    let mut digest = crc32::Digest::new(crc32::IEEE);
    digest.write(kind);
    digest.write(data);
    buffer.write_all(&digest.sum32().to_be_bytes())?;

    Ok(())
}