sdec-bitstream 0.8.0

Low-level bit packing primitives for the sdec codec
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
149
150
151

use bitstream::{BitReader, BitVecWriter};
use proptest::prelude::*;

#[derive(Clone, Debug)]
enum Op {
    Bit(bool),
    Bits { bits: u8, value: u64 },
    Align,
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    VarU32(u32),
    VarS32(i32),
}

fn mask_value(bits: u8, value: u64) -> u64 {
    if bits >= 64 {
        value
    } else {
        let mask = (1u64 << bits) - 1;
        value & mask
    }
}

fn op_strategy() -> impl Strategy<Value = Op> {
    prop_oneof![
        any::<bool>().prop_map(Op::Bit),
        (1u8..=64, any::<u64>()).prop_map(|(bits, value)| Op::Bits {
            bits,
            value: mask_value(bits, value),
        }),
        Just(Op::Align),
        any::<u8>().prop_map(Op::U8),
        any::<u16>().prop_map(Op::U16),
        any::<u32>().prop_map(Op::U32),
        any::<u64>().prop_map(Op::U64),
        any::<u32>().prop_map(Op::VarU32),
        any::<i32>().prop_map(Op::VarS32),
    ]
}

proptest! {
    #[test]
    fn prop_roundtrip_ops(ops in prop::collection::vec(op_strategy(), 1..64)) {
        let mut writer = BitVecWriter::new();

        for op in &ops {
            match op {
                Op::Bit(b) => {
                    writer.write_bit(*b);
                }
                Op::Bits { bits, value } => {
                    writer.write_bits(*value, *bits).unwrap();
                }
                Op::Align => {
                    writer.align_to_byte();
                }
                Op::U8(v) => {
                    if writer.bits_written() % 8 != 0 {
                        writer.align_to_byte();
                    }
                    writer.write_u8_aligned(*v).unwrap();
                }
                Op::U16(v) => {
                    if writer.bits_written() % 8 != 0 {
                        writer.align_to_byte();
                    }
                    writer.write_u16_aligned(*v).unwrap();
                }
                Op::U32(v) => {
                    if writer.bits_written() % 8 != 0 {
                        writer.align_to_byte();
                    }
                    writer.write_u32_aligned(*v).unwrap();
                }
                Op::U64(v) => {
                    if writer.bits_written() % 8 != 0 {
                        writer.align_to_byte();
                    }
                    writer.write_u64_aligned(*v).unwrap();
                }
                Op::VarU32(v) => {
                    if writer.bits_written() % 8 != 0 {
                        writer.align_to_byte();
                    }
                    writer.write_varu32(*v).unwrap();
                }
                Op::VarS32(v) => {
                    if writer.bits_written() % 8 != 0 {
                        writer.align_to_byte();
                    }
                    writer.write_vars32(*v).unwrap();
                }
            }
        }

        let bytes = writer.finish();
        let mut reader = BitReader::new(&bytes);

        for op in &ops {
            match op {
                Op::Bit(b) => {
                    prop_assert_eq!(reader.read_bit().unwrap(), *b);
                }
                Op::Bits { bits, value } => {
                    prop_assert_eq!(reader.read_bits(*bits).unwrap(), *value);
                }
                Op::Align => {
                    reader.align_to_byte().unwrap();
                }
                Op::U8(v) => {
                    if reader.bit_position() % 8 != 0 {
                        reader.align_to_byte().unwrap();
                    }
                    prop_assert_eq!(reader.read_u8_aligned().unwrap(), *v);
                }
                Op::U16(v) => {
                    if reader.bit_position() % 8 != 0 {
                        reader.align_to_byte().unwrap();
                    }
                    prop_assert_eq!(reader.read_u16_aligned().unwrap(), *v);
                }
                Op::U32(v) => {
                    if reader.bit_position() % 8 != 0 {
                        reader.align_to_byte().unwrap();
                    }
                    prop_assert_eq!(reader.read_u32_aligned().unwrap(), *v);
                }
                Op::U64(v) => {
                    if reader.bit_position() % 8 != 0 {
                        reader.align_to_byte().unwrap();
                    }
                    prop_assert_eq!(reader.read_u64_aligned().unwrap(), *v);
                }
                Op::VarU32(v) => {
                    if reader.bit_position() % 8 != 0 {
                        reader.align_to_byte().unwrap();
                    }
                    prop_assert_eq!(reader.read_varu32().unwrap(), *v);
                }
                Op::VarS32(v) => {
                    if reader.bit_position() % 8 != 0 {
                        reader.align_to_byte().unwrap();
                    }
                    prop_assert_eq!(reader.read_vars32().unwrap(), *v);
                }
            }
        }
    }
}