ozlrip-decode 0.2.0

OpenZL decoder for ozlrip
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

#![cfg_attr(feature = "paranoid", forbid(unsafe_code))]

use alloc::vec::Vec;

pub(super) fn decode_numeric(input: &[u8], element_width: usize, output: &mut Vec<u8>) {
    #[cfg(not(feature = "paranoid"))]
    if decode_numeric_fast(input, element_width, output) {
        return;
    }
    decode_numeric_safe(input, element_width, output);
}

fn decode_numeric_safe(input: &[u8], element_width: usize, output: &mut Vec<u8>) {
    match element_width {
        1 => {
            for &encoded in input {
                let mask = 0u8.wrapping_sub(encoded & 1);
                output.push((encoded >> 1) ^ mask);
            }
        }
        2 => {
            for encoded in input.chunks_exact(2) {
                let value = u16::from_le_bytes([encoded[0], encoded[1]]);
                let mask = 0u16.wrapping_sub(value & 1);
                output.extend_from_slice(&((value >> 1) ^ mask).to_le_bytes());
            }
        }
        4 => {
            for encoded in input.chunks_exact(4) {
                let value = u32::from_le_bytes([encoded[0], encoded[1], encoded[2], encoded[3]]);
                let mask = 0u32.wrapping_sub(value & 1);
                output.extend_from_slice(&((value >> 1) ^ mask).to_le_bytes());
            }
        }
        8 => {
            for encoded in input.chunks_exact(8) {
                let value = u64::from_le_bytes([
                    encoded[0], encoded[1], encoded[2], encoded[3], encoded[4], encoded[5],
                    encoded[6], encoded[7],
                ]);
                let mask = 0u64.wrapping_sub(value & 1);
                output.extend_from_slice(&((value >> 1) ^ mask).to_le_bytes());
            }
        }
        _ => unreachable!("validate_numeric_stream_width accepted only supported widths"),
    }
}

#[cfg(not(feature = "paranoid"))]
fn decode_numeric_fast(input: &[u8], element_width: usize, output: &mut Vec<u8>) -> bool {
    match element_width {
        2 => decode_u16_fast(input, output),
        4 => decode_u32_fast(input, output),
        8 => decode_u64_fast(input, output),
        _ => false,
    }
}

#[cfg(not(feature = "paranoid"))]
fn decode_u16_fast(input: &[u8], output: &mut Vec<u8>) -> bool {
    if !input.len().is_multiple_of(2) {
        return false;
    }
    debug_assert!(output.len() + input.len() <= output.capacity());
    let start = output.len();
    unsafe {
        // SAFETY: the caller reserved `input.len()` bytes in `output` and the
        // width validation above ensures exact 2-byte chunks.
        let dst = output.as_mut_ptr().add(start);
        for (index, encoded) in input.chunks_exact(2).enumerate() {
            let value = u16::from_le_bytes([encoded[0], encoded[1]]);
            let mask = 0u16.wrapping_sub(value & 1);
            dst.add(index * 2)
                .cast::<u16>()
                .write_unaligned(((value >> 1) ^ mask).to_le());
        }
        output.set_len(start + input.len());
    }
    true
}

#[cfg(not(feature = "paranoid"))]
fn decode_u32_fast(input: &[u8], output: &mut Vec<u8>) -> bool {
    if !input.len().is_multiple_of(4) {
        return false;
    }
    debug_assert!(output.len() + input.len() <= output.capacity());
    let start = output.len();
    unsafe {
        // SAFETY: the caller reserved `input.len()` bytes in `output` and the
        // width validation above ensures exact 4-byte chunks.
        let dst = output.as_mut_ptr().add(start);
        for (index, encoded) in input.chunks_exact(4).enumerate() {
            let value = u32::from_le_bytes([encoded[0], encoded[1], encoded[2], encoded[3]]);
            let mask = 0u32.wrapping_sub(value & 1);
            dst.add(index * 4)
                .cast::<u32>()
                .write_unaligned(((value >> 1) ^ mask).to_le());
        }
        output.set_len(start + input.len());
    }
    true
}

#[cfg(not(feature = "paranoid"))]
fn decode_u64_fast(input: &[u8], output: &mut Vec<u8>) -> bool {
    if !input.len().is_multiple_of(8) {
        return false;
    }
    debug_assert!(output.len() + input.len() <= output.capacity());
    let start = output.len();
    unsafe {
        // SAFETY: the caller reserved `input.len()` bytes in `output` and the
        // width validation above ensures exact 8-byte chunks.
        let dst = output.as_mut_ptr().add(start);
        for (index, encoded) in input.chunks_exact(8).enumerate() {
            let value = u64::from_le_bytes([
                encoded[0], encoded[1], encoded[2], encoded[3], encoded[4], encoded[5], encoded[6],
                encoded[7],
            ]);
            let mask = 0u64.wrapping_sub(value & 1);
            dst.add(index * 8)
                .cast::<u64>()
                .write_unaligned(((value >> 1) ^ mask).to_le());
        }
        output.set_len(start + input.len());
    }
    true
}