wav1c 0.2.0

Wondrous AV1 encoder written in safe 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

#[derive(Default)]
pub struct BitWriter {
    buf: Vec<u8>,
    current_byte: u8,
    bits_in_current: u8,
}

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

    pub fn write_bit(&mut self, bit: bool) {
        self.current_byte = (self.current_byte << 1) | (bit as u8);
        self.bits_in_current += 1;
        if self.bits_in_current == 8 {
            self.buf.push(self.current_byte);
            self.current_byte = 0;
            self.bits_in_current = 0;
        }
    }

    pub fn write_bits(&mut self, value: u64, n: u8) {
        debug_assert!(n <= 64);
        for i in (0..n).rev() {
            self.write_bit((value >> i) & 1 == 1);
        }
    }

    pub fn byte_align(&mut self) {
        if self.bits_in_current > 0 {
            self.current_byte <<= 8 - self.bits_in_current;
            self.buf.push(self.current_byte);
            self.current_byte = 0;
            self.bits_in_current = 0;
        }
    }

    pub fn finalize(mut self) -> Vec<u8> {
        self.byte_align();
        self.buf
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn single_bit_true() {
        let mut w = BitWriter::new();
        w.write_bit(true);
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0x80]);
    }

    #[test]
    fn single_bit_false() {
        let mut w = BitWriter::new();
        w.write_bit(false);
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0x00]);
    }

    #[test]
    fn write_byte_value() {
        let mut w = BitWriter::new();
        w.write_bits(0xAB, 8);
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0xAB]);
    }

    #[test]
    fn write_3_bits() {
        let mut w = BitWriter::new();
        w.write_bits(0b101, 3);
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0xA0]);
    }

    #[test]
    fn write_across_byte_boundary() {
        let mut w = BitWriter::new();
        w.write_bits(0b11111, 5);
        w.write_bits(0b11111, 5);
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0xFF, 0xC0]);
    }

    #[test]
    fn byte_align_no_op_when_aligned() {
        let mut w = BitWriter::new();
        w.write_bits(0xFF, 8);
        w.byte_align();
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0xFF]);
    }

    #[test]
    fn byte_align_pads_with_zeros() {
        let mut w = BitWriter::new();
        w.write_bits(0b111, 3);
        w.byte_align();
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0xE0]);
    }

    #[test]
    fn empty_writer() {
        let w = BitWriter::new();
        let bytes = w.finalize();
        assert_eq!(bytes, vec![]);
    }

    #[test]
    fn write_16_bits() {
        let mut w = BitWriter::new();
        w.write_bits(0xCAFE, 16);
        let bytes = w.finalize();
        assert_eq!(bytes, vec![0xCA, 0xFE]);
    }
}