inochi2d 0.1.1

Pure Rust implementation of Inochi2D, the realtime 2D puppet animation framework
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

unsafe fn copy_intersperce(dst: *mut u8, src: *const u8) -> *mut u8 {
    dst.copy_from(src, 3);
    dst.offset(3).write(255);
    dst.offset(4)
}

// This function decodes to RGBA instead of RGB, by interspercing a 255 byte every three bytes.
fn decode_rle_24(mut rle: &[u8], mut ptr: *mut u8) {
    while rle.len() > 18 {
        let c = rle[0];
        rle = &rle[1..];
        if c & 0x80 != 0 {
            let c = (c & !0x80) + 1;
            let pixel = &rle[..3];
            rle = &rle[3..];
            for _ in 0..c {
                ptr = unsafe { copy_intersperce(ptr, pixel.as_ptr()) };
            }
        } else {
            let c = c + 1;
            for _ in 0..c {
                let pixel = &rle[..3];
                rle = &rle[3..];
                ptr = unsafe { copy_intersperce(ptr, pixel.as_ptr()) };
            }
        }
    }
}

fn decode_rle_32(mut rle: &[u8], mut ptr: *mut u8) {
    while rle.len() > 16 {
        let c = rle[0];
        rle = &rle[1..];
        if c & 0x80 != 0 {
            let c = (c & !0x80) + 1;
            let pixel = &rle[..4];
            rle = &rle[4..];
            for _ in 0..c {
                unsafe {
                    core::ptr::copy(pixel.as_ptr(), ptr, 4);
                    ptr = ptr.offset(4);
                }
            }
        } else {
            let c = c + 1;
            let pixels = &rle[..4 * c as usize];
            rle = &rle[4 * c as usize..];
            unsafe {
                core::ptr::copy(pixels.as_ptr(), ptr, 4 * c as usize);
                ptr = ptr.offset(4 * c as isize);
            }
        }
    }
}

pub fn decode(tga: &[u8]) -> (u32, u32, Vec<u8>) {
    let width = u16::from_le_bytes([tga[12], tga[13]]) as u32;
    let height = u16::from_le_bytes([tga[14], tga[15]]) as u32;
    let mut data = Vec::with_capacity((width * height * 4) as usize);
    let pixel_depth = tga[16];
    match pixel_depth {
        24 => decode_rle_24(&tga[18..], data.as_mut_ptr()),
        32 => decode_rle_32(&tga[18..], data.as_mut_ptr()),
        depth => todo!("Unimplemented pixel depth {depth}"),
    }
    unsafe { data.set_len((width * height * 4) as usize) };
    (width, height, data)
}