draco_oxide_core/
bit_coder.rs

1use crate::safety_assert;
2use std::{iter::Rev, vec};
3
4use super::buffer::{MsbFirst, OrderConfig};
5
6/// A trait that defines what a byte writer should implement. Users can implement this for any custom
7/// buffer type, and draco-oxide is able to write the output to it.
8pub trait ByteWriter: Sized {
9    fn write_u8(&mut self, value: u8);
10    fn write_u16(&mut self, value: u16) {
11        self.write_u8(value as u8);
12        self.write_u8((value >> 8) as u8);
13    }
14    fn write_u24(&mut self, value: u32) {
15        self.write_u8(value as u8);
16        self.write_u8((value >> 8) as u8);
17        self.write_u8((value >> 16) as u8);
18    }
19    fn write_u32(&mut self, value: u32) {
20        self.write_u16(value as u16);
21        self.write_u16((value >> 16) as u16);
22    }
23    fn write_u64(&mut self, value: u64) {
24        self.write_u32(value as u32);
25        self.write_u32((value >> 32) as u32);
26    }
27}
28
29impl ByteWriter for Vec<u8> {
30    fn write_u8(&mut self, value: u8) {
31        self.push(value);
32    }
33
34    fn write_u16(&mut self, value: u16) {
35        self.extend_from_slice(&value.to_le_bytes());
36    }
37
38    fn write_u24(&mut self, value: u32) {
39        self.extend_from_slice(&value.to_le_bytes()[..3]);
40    }
41
42    fn write_u32(&mut self, value: u32) {
43        self.extend_from_slice(&value.to_le_bytes());
44    }
45
46    fn write_u64(&mut self, value: u64) {
47        self.extend_from_slice(&value.to_le_bytes());
48    }
49}
50
51/// A special byte writer that is provided by draco-oxide that allows users to build
52/// custom byte writers using a cloure.
53pub struct FunctionalByteWriter<R> {
54    write_fn: R,
55}
56
57impl<R: FnMut(u8)> ByteWriter for FunctionalByteWriter<R> {
58    fn write_u8(&mut self, value: u8) {
59        (self.write_fn)(value);
60    }
61
62    fn write_u16(&mut self, value: u16) {
63        // ToDo: use unsafe code to avoid the allocation of the array.
64        self.write_u8(value as u8);
65        self.write_u8((value >> 8) as u8);
66    }
67
68    fn write_u24(&mut self, value: u32) {
69        self.write_u8(value as u8);
70        self.write_u8((value >> 8) as u8);
71        self.write_u8((value >> 16) as u8);
72    }
73
74    fn write_u32(&mut self, value: u32) {
75        self.write_u16(value as u16);
76        self.write_u16((value >> 16) as u16);
77    }
78
79    fn write_u64(&mut self, value: u64) {
80        self.write_u32(value as u32);
81        self.write_u32((value >> 32) as u32);
82    }
83}
84
85impl<R: FnMut(u8)> FunctionalByteWriter<R> {
86    pub fn new(write_fn: R) -> Self {
87        FunctionalByteWriter { write_fn }
88    }
89}
90
91pub struct BitWriter<'buffer, Buffer: ByteWriter, Order: OrderConfig = MsbFirst> {
92    buffer: &'buffer mut Buffer,
93
94    /// The position in the current byte where the next bit will be written.
95    /// It is always less than 8.
96    pos_in_curr_byte: u8,
97
98    /// The current byte being written to. This byte will be written to the buffer when it is full.
99    curr_byte: u8,
100
101    phantom: std::marker::PhantomData<Order>,
102}
103
104impl<'buffer, Buffer: ByteWriter, Order: OrderConfig> BitWriter<'buffer, Buffer, Order> {
105    pub fn spown_from(buffer: &mut Buffer) -> BitWriter<'_, Buffer, Order> {
106        BitWriter {
107            buffer,
108            pos_in_curr_byte: 0,
109            curr_byte: 0,
110            phantom: std::marker::PhantomData,
111        }
112    }
113
114    pub fn write_bits(&mut self, (size, value): (u8, u64)) {
115        let mut offset = if Order::IS_MSB_FIRST { size } else { 0 };
116
117        if self.pos_in_curr_byte != 0 {
118            // Safety: by definition, `pos_in_curr_byte` is always less than 8.
119            let num_remaining_in_curr_byte = unsafe { 8_u8.unchecked_sub(self.pos_in_curr_byte) };
120            if size <= num_remaining_in_curr_byte {
121                self.curr_byte |= if Order::IS_MSB_FIRST {
122                    // Safety: `checked by the if condition above.
123                    unsafe {
124                        (value & ((1 << num_remaining_in_curr_byte) - 1))
125                            << num_remaining_in_curr_byte.unchecked_sub(size)
126                    }
127                } else {
128                    value << self.pos_in_curr_byte
129                } as u8;
130                self.pos_in_curr_byte = if size == num_remaining_in_curr_byte {
131                    self.buffer.write_u8(self.curr_byte);
132                    self.curr_byte = 0;
133                    0
134                } else {
135                    unsafe { self.pos_in_curr_byte.unchecked_add(size) }
136                };
137                return;
138            }
139            self.curr_byte |= if Order::IS_MSB_FIRST {
140                // Safety: 'num_remaining_in_curr_byte' is guaranteed to be less than 8.
141                unsafe {
142                    (value >> size.unchecked_sub(num_remaining_in_curr_byte))
143                        & ((1 << num_remaining_in_curr_byte) - 1)
144                }
145            } else {
146                value << self.pos_in_curr_byte
147            } as u8;
148            self.buffer.write_u8(self.curr_byte);
149            self.curr_byte = 0;
150            offset = if Order::IS_MSB_FIRST {
151                // Safety: `checked by the if condition above.
152                unsafe { size.unchecked_sub(num_remaining_in_curr_byte) }
153            } else {
154                num_remaining_in_curr_byte
155            }
156        }
157
158        // ToDo: Change the following and avoid the loop
159        // Safety:
160        // In the case of MSB first. 'offset' is the number of bits remaining to write, and we iterate only 'offset/8' times
161        // means its safe to subtract 8 for each iteration.
162        // In the case of LSB first, 'offset' is the number of bits written so far, so even if we add 8 to it '(size-offset)/8' times,
163        // it is at most 'size', which is of type 'u8'. Hence it will never overflow.
164        for _ in 0..if Order::IS_MSB_FIRST {
165            offset
166        } else {
167            unsafe { size.unchecked_sub(offset) }
168        } >> 3
169        {
170            unsafe {
171                if Order::IS_MSB_FIRST {
172                    offset = offset.unchecked_sub(8)
173                };
174                self.buffer.write_u8((value >> offset) as u8);
175                if !Order::IS_MSB_FIRST {
176                    offset = offset.unchecked_add(8)
177                };
178            }
179        }
180        self.curr_byte = if Order::IS_MSB_FIRST {
181            // Safety: 'offset' is guaranteed to be less than or equal to 8 due to the previous loop.
182            unsafe { (value & ((1 << offset) - 1)) << (8_u8.unchecked_sub(offset)) }
183        } else {
184            value >> offset
185        } as u8;
186        self.pos_in_curr_byte = if Order::IS_MSB_FIRST {
187            offset
188        } else {
189            // Safety: 'size-offset' is guaranteed to be positive.
190            unsafe { size.unchecked_sub(offset) & 7 }
191        };
192    }
193}
194
195impl<'buffer, Buffer: ByteWriter, Order: OrderConfig> Drop for BitWriter<'buffer, Buffer, Order> {
196    fn drop(&mut self) {
197        // If there are bits left in the current byte, pad the current byte by writing the current data.
198        if self.pos_in_curr_byte > 0 {
199            self.buffer.write_u8(self.curr_byte);
200        }
201    }
202}
203
204pub trait ByteReader {
205    type Rev: ReverseByteReader;
206    fn read_u8(&mut self) -> Result<u8, ReaderErr>;
207    fn read_u16(&mut self) -> Result<u16, ReaderErr> {
208        let out = [self.read_u8()?, self.read_u8()?];
209        Ok(u16::from_le_bytes(out))
210    }
211    fn read_u24(&mut self) -> Result<u32, ReaderErr> {
212        let out = [self.read_u8()?, self.read_u8()?, self.read_u8()?];
213        Ok(u32::from_le_bytes([out[0], out[1], out[2], 0]))
214    }
215    fn read_u32(&mut self) -> Result<u32, ReaderErr> {
216        let out = [
217            self.read_u8()?,
218            self.read_u8()?,
219            self.read_u8()?,
220            self.read_u8()?,
221        ];
222        Ok(u32::from_le_bytes(out))
223    }
224    fn read_u64(&mut self) -> Result<u64, ReaderErr> {
225        let out = [
226            self.read_u8()?,
227            self.read_u8()?,
228            self.read_u8()?,
229            self.read_u8()?,
230            self.read_u8()?,
231            self.read_u8()?,
232            self.read_u8()?,
233            self.read_u8()?,
234        ];
235        Ok(u64::from_le_bytes(out))
236    }
237
238    fn spown_reverse_reader_at(&mut self, offset: usize) -> Result<Self::Rev, ReaderErr>;
239}
240
241impl ByteReader for vec::IntoIter<u8> {
242    fn read_u8(&mut self) -> Result<u8, ReaderErr> {
243        self.next().ok_or(ReaderErr::NotEnoughData)
244    }
245
246    fn read_u16(&mut self) -> Result<u16, ReaderErr> {
247        let out = [
248            self.next().ok_or(ReaderErr::NotEnoughData)?,
249            self.next().ok_or(ReaderErr::NotEnoughData)?,
250        ];
251        Ok(u16::from_le_bytes(out))
252    }
253
254    fn read_u32(&mut self) -> Result<u32, ReaderErr> {
255        let out = [
256            self.next().ok_or(ReaderErr::NotEnoughData)?,
257            self.next().ok_or(ReaderErr::NotEnoughData)?,
258            self.next().ok_or(ReaderErr::NotEnoughData)?,
259            self.next().ok_or(ReaderErr::NotEnoughData)?,
260        ];
261        Ok(u32::from_le_bytes(out))
262    }
263
264    fn read_u64(&mut self) -> Result<u64, ReaderErr> {
265        let out = [
266            self.next().ok_or(ReaderErr::NotEnoughData)?,
267            self.next().ok_or(ReaderErr::NotEnoughData)?,
268            self.next().ok_or(ReaderErr::NotEnoughData)?,
269            self.next().ok_or(ReaderErr::NotEnoughData)?,
270            self.next().ok_or(ReaderErr::NotEnoughData)?,
271            self.next().ok_or(ReaderErr::NotEnoughData)?,
272            self.next().ok_or(ReaderErr::NotEnoughData)?,
273            self.next().ok_or(ReaderErr::NotEnoughData)?,
274        ];
275        Ok(u64::from_le_bytes(out))
276    }
277
278    type Rev = Rev<vec::IntoIter<u8>>;
279    fn spown_reverse_reader_at(&mut self, offset: usize) -> Result<Self::Rev, ReaderErr> {
280        let mut vec: Vec<_> = self.collect();
281        if offset > vec.len() {
282            return Err(ReaderErr::NotEnoughData);
283        }
284        let rest = vec.split_off(offset);
285        let rev = vec.into_iter().rev();
286        *self = rest.into_iter();
287        Ok(rev)
288    }
289}
290
291/// A special byte reader that is provided by draco-oxide that allows users to build
292/// custom byte readers using a cloure.
293pub struct FunctionalByteReader<R> {
294    read_fn: R,
295}
296
297impl<R: FnMut() -> Result<u8, ReaderErr>> ByteReader for FunctionalByteReader<R> {
298    fn read_u8(&mut self) -> Result<u8, ReaderErr> {
299        (self.read_fn)()
300    }
301
302    fn read_u16(&mut self) -> Result<u16, ReaderErr> {
303        let out = [self.read_u8()?, self.read_u8()?];
304        Ok(u16::from_le_bytes(out))
305    }
306
307    fn read_u32(&mut self) -> Result<u32, ReaderErr> {
308        let out = [
309            self.read_u8()?,
310            self.read_u8()?,
311            self.read_u8()?,
312            self.read_u8()?,
313        ];
314        Ok(u32::from_le_bytes(out))
315    }
316
317    fn read_u64(&mut self) -> Result<u64, ReaderErr> {
318        let out = [
319            self.read_u8()?,
320            self.read_u8()?,
321            self.read_u8()?,
322            self.read_u8()?,
323            self.read_u8()?,
324            self.read_u8()?,
325            self.read_u8()?,
326            self.read_u8()?,
327        ];
328        Ok(u64::from_le_bytes(out))
329    }
330
331    type Rev = Rev<vec::IntoIter<u8>>;
332
333    fn spown_reverse_reader_at(&mut self, offset: usize) -> Result<Self::Rev, ReaderErr> {
334        let mut vec = Vec::new();
335        for _ in 0..offset {
336            vec.push(self.read_u8()?);
337        }
338        let rest = vec.into_iter().rev();
339        Ok(rest)
340    }
341}
342
343impl<R: FnMut() -> Result<u8, ReaderErr>> FunctionalByteReader<R> {
344    pub fn new(read_fn: R) -> Self {
345        FunctionalByteReader { read_fn }
346    }
347}
348
349#[allow(unused)] // will be used in the decoder
350pub struct BitReader<'buffer, Buffer, Order: OrderConfig = MsbFirst> {
351    buffer: &'buffer mut Buffer,
352
353    /// The position in the current byte where the next bit will be read.
354    /// It is always less than 8.
355    pos_in_curr_byte: u8,
356
357    /// The current byte being read from. This byte will be read from the buffer when it is full.
358    curr_byte: u8,
359
360    phantom: std::marker::PhantomData<Order>,
361}
362
363#[allow(unused)] // will be used in the decoder
364impl<'buffer, Buffer: ByteReader, Order: OrderConfig> BitReader<'buffer, Buffer, Order> {
365    /// Spowns a new BitReader from the given buffer if the buffer is not empty.
366    /// If the buffer is empty then it returns 'None'.
367    pub fn spown_from(buffer: &'buffer mut Buffer) -> Option<BitReader<'buffer, Buffer, Order>> {
368        Some(BitReader {
369            buffer,
370            pos_in_curr_byte: 0,
371            curr_byte: 0,
372            phantom: std::marker::PhantomData,
373        })
374    }
375
376    /// Reads 'size' bits from the buffer and returns them as a 'u64'.
377    /// 'size' must be greater than 0 and less than or equal to 64.
378    pub fn read_bits(&mut self, size: u8) -> Result<u64, ReaderErr> {
379        safety_assert!(
380            size > 0 && size <= 64,
381            "Size must be between 1 and 64 bits."
382        );
383
384        let mut offset = if Order::IS_MSB_FIRST { size } else { 0 };
385        let mut value: u64 = 0;
386
387        if self.pos_in_curr_byte != 0 {
388            // Safety: by definition, `pos_in_curr_byte` is always less than 8.
389            let num_remaining_in_curr_byte = unsafe { 8_u8.unchecked_sub(self.pos_in_curr_byte) };
390            if size <= num_remaining_in_curr_byte {
391                value = unsafe {
392                    if Order::IS_MSB_FIRST {
393                        (self.curr_byte & ((1 << num_remaining_in_curr_byte) - 1))
394                            >> (num_remaining_in_curr_byte.unchecked_sub(size))
395                    } else {
396                        self.curr_byte >> self.pos_in_curr_byte
397                    }
398                } as u64;
399                self.pos_in_curr_byte = if size == num_remaining_in_curr_byte {
400                    0
401                } else {
402                    unsafe { self.pos_in_curr_byte.unchecked_add(size) }
403                };
404                return Ok(value & ((1 << size) - 1));
405            }
406            value = if Order::IS_MSB_FIRST {
407                ((self.curr_byte as usize) & ((1 << num_remaining_in_curr_byte) - 1))
408                    << unsafe { size.unchecked_sub(num_remaining_in_curr_byte) }
409            } else {
410                (self.curr_byte >> self.pos_in_curr_byte) as usize
411            } as u64;
412            offset = if Order::IS_MSB_FIRST {
413                unsafe { offset.unchecked_sub(num_remaining_in_curr_byte) }
414            } else {
415                num_remaining_in_curr_byte
416            };
417        }
418
419        for _ in 0..if Order::IS_MSB_FIRST {
420            offset
421        } else {
422            unsafe { size.unchecked_sub(offset) }
423        } >> 3
424        {
425            self.curr_byte = self.buffer.read_u8()?;
426            if Order::IS_MSB_FIRST {
427                offset = unsafe { offset.unchecked_sub(8) };
428            }
429            value |= (self.curr_byte as u64) << offset;
430            if !Order::IS_MSB_FIRST {
431                offset = unsafe { offset.unchecked_add(8) };
432            }
433        }
434
435        // 'size - offset' is the number of bits remaining to be read.
436        if (Order::IS_MSB_FIRST && offset > 0) || (!Order::IS_MSB_FIRST && size - offset > 0) {
437            self.curr_byte = self.buffer.read_u8()?;
438            value |= unsafe {
439                if Order::IS_MSB_FIRST {
440                    (self.curr_byte as u64 >> (8_u8.unchecked_sub(offset))) & ((1 << offset) - 1)
441                } else {
442                    (self.curr_byte as u64 & ((1 << size.unchecked_sub(offset)) - 1)) << offset
443                }
444            };
445        }
446
447        self.pos_in_curr_byte = if Order::IS_MSB_FIRST {
448            offset
449        } else {
450            (size - offset) & 7
451        };
452        Ok(value)
453    }
454}
455
456#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Eq)]
457pub enum ReaderErr {
458    #[error("Not enough data to read")]
459    NotEnoughData,
460}
461
462#[allow(unused)] // will be used in the decoder
463pub trait ReverseByteReader {
464    fn read_u8_back(&mut self) -> Result<u8, ReaderErr>;
465    fn read_u16_back(&mut self) -> Result<u16, ReaderErr> {
466        let mut out = [self.read_u8_back()?, self.read_u8_back()?];
467        out.reverse();
468        Ok(u16::from_le_bytes(out))
469    }
470    fn read_u24_back(&mut self) -> Result<u32, ReaderErr> {
471        let mut out = [
472            self.read_u8_back()?,
473            self.read_u8_back()?,
474            self.read_u8_back()?,
475        ];
476        out.reverse();
477        Ok(u32::from_le_bytes([out[0], out[1], out[2], 0]))
478    }
479    fn read_u32_back(&mut self) -> Result<u32, ReaderErr> {
480        let mut out = [
481            self.read_u8_back()?,
482            self.read_u8_back()?,
483            self.read_u8_back()?,
484            self.read_u8_back()?,
485        ];
486        out.reverse();
487        Ok(u32::from_le_bytes(out))
488    }
489    fn read_u64_back(&mut self) -> Result<u64, ReaderErr> {
490        let mut out = [
491            self.read_u8_back()?,
492            self.read_u8_back()?,
493            self.read_u8_back()?,
494            self.read_u8_back()?,
495            self.read_u8_back()?,
496            self.read_u8_back()?,
497            self.read_u8_back()?,
498            self.read_u8_back()?,
499        ];
500        out.reverse();
501        Ok(u64::from_le_bytes(out))
502    }
503}
504
505impl<I: DoubleEndedIterator<Item = u8>> ReverseByteReader for Rev<I> {
506    fn read_u8_back(&mut self) -> Result<u8, ReaderErr> {
507        self.next().ok_or(ReaderErr::NotEnoughData)
508    }
509}
510
511#[cfg(test)]
512mod tests {
513    use super::BitWriter;
514    use crate::bit_coder::ByteWriter;
515    use crate::{bit_coder::BitReader, buffer::*};
516
517    #[test]
518    fn test_writer_reader_msb_first() {
519        let mut buffer = Vec::new();
520        let mut writer = BitWriter::<_, MsbFirst>::spown_from(&mut buffer);
521        writer.write_bits((2, 0b10));
522        writer.write_bits((3, 0b011));
523        drop(writer); // drop the bit writer to end bit-writing
524        assert_eq!(buffer.len(), 1);
525        let mut reader = buffer.into_iter();
526        let mut reader = BitReader::<_, MsbFirst>::spown_from(&mut reader).unwrap();
527        assert_eq!(reader.read_bits(2).unwrap(), 0b10);
528        assert_eq!(reader.read_bits(3).unwrap(), 0b011);
529
530        let mut buffer = Vec::new();
531        let mut writer = BitWriter::<_, MsbFirst>::spown_from(&mut buffer);
532        writer.write_bits((7, 0b0111010));
533        drop(writer); // drop the bit writer to end bit-writing
534        assert_eq!(buffer.len(), 1);
535        let mut reader = buffer.into_iter();
536        let mut reader = BitReader::<_, MsbFirst>::spown_from(&mut reader).unwrap();
537        assert_eq!(reader.read_bits(7).unwrap(), 0b0111010);
538
539        let mut buffer = Vec::new();
540        let mut writer: BitWriter<_> = BitWriter::spown_from(&mut buffer);
541        writer.write_bits((8, 0b10111010));
542        drop(writer); // drop the bit writer to end bit-writing
543        assert_eq!(buffer[0], 0b10111010);
544        let mut reader = buffer.into_iter();
545        let mut reader: BitReader<_> = BitReader::spown_from(&mut reader).unwrap();
546        assert_eq!(reader.read_bits(8).unwrap(), 0b10111010);
547
548        let mut buffer = Vec::new();
549        let mut writer: BitWriter<_> = BitWriter::spown_from(&mut buffer);
550        writer.write_bits((9, 0b110111011));
551        drop(writer); // drop the bit writer to end bit-writing
552        assert_eq!(buffer.len(), 2);
553        assert_eq!(buffer[0], 0b11011101);
554        assert_eq!(buffer[1], 0b10000000);
555        let mut reader = buffer.into_iter();
556        let mut reader: BitReader<_> = BitReader::spown_from(&mut reader).unwrap();
557        assert_eq!(reader.read_bits(9).unwrap(), 0b110111011);
558
559        let mut buffer = Vec::new();
560        let mut writer: BitWriter<_> = BitWriter::spown_from(&mut buffer);
561        writer.write_bits((9, 0b101010100));
562        writer.write_bits((8, 0b10101110));
563        writer.write_bits((7, 0b0101010));
564        writer.write_bits((6, 0b111100));
565        writer.write_bits((5, 0b00001));
566        writer.write_bits((4, 0b1100));
567        drop(writer); // drop the bit writer to end bit-writing
568        assert_eq!(buffer.len(), (9 + 8 + 7 + 6 + 5 + 4) / 8 + 1);
569        assert_eq!(buffer[0], 0b10101010);
570        assert_eq!(buffer[1], 0b01010111);
571        assert_eq!(buffer[2], 0b00101010);
572        assert_eq!(buffer[3], 0b11110000);
573        assert_eq!(buffer[4], 0b00111000);
574        let mut reader = buffer.into_iter();
575        let mut reader: BitReader<_> = BitReader::spown_from(&mut reader).unwrap();
576        assert_eq!(reader.read_bits(9).unwrap(), 0b101010100);
577        assert_eq!(reader.read_bits(8).unwrap(), 0b10101110);
578        assert_eq!(reader.read_bits(7).unwrap(), 0b0101010);
579        assert_eq!(reader.read_bits(6).unwrap(), 0b111100);
580        assert_eq!(reader.read_bits(5).unwrap(), 0b00001);
581        assert_eq!(reader.read_bits(4).unwrap(), 0b1100);
582
583        let mut buffer = Vec::new();
584        let mut writer: BitWriter<_> = BitWriter::spown_from(&mut buffer);
585        writer.write_bits((11, 0b10111010110));
586        drop(writer); // drop the bit writer to end bit-writing
587        assert_eq!(buffer.len(), 2);
588        let mut reader = buffer.into_iter();
589        let mut reader: BitReader<_> = BitReader::spown_from(&mut reader).unwrap();
590        assert_eq!(reader.read_bits(2).unwrap(), 0b10);
591        assert_eq!(reader.read_bits(1).unwrap(), 0b1);
592        assert_eq!(reader.read_bits(3).unwrap(), 0b110);
593        assert_eq!(reader.read_bits(3).unwrap(), 0b101);
594        assert_eq!(reader.read_bits(2).unwrap(), 0b10);
595    }
596
597    #[test]
598    fn test_writer_reader_lsb_first() {
599        let mut buffer = Vec::new();
600        {
601            let mut writer = BitWriter::<_, LsbFirst>::spown_from(&mut buffer);
602            writer.write_bits((9, 0b101010100));
603            writer.write_bits((8, 0b10101010));
604            writer.write_bits((7, 0b0101010));
605            writer.write_bits((6, 0b111100));
606            writer.write_bits((5, 0b00001));
607            writer.write_bits((4, 0b1100));
608        }
609        assert_eq!(buffer.len(), (9 + 8 + 7 + 6 + 5 + 4) / 8 + 1);
610        let mut reader = buffer.into_iter();
611        let mut reader = BitReader::<_, LsbFirst>::spown_from(&mut reader).unwrap();
612        assert_eq!(reader.read_bits(9).unwrap(), 0b101010100);
613        assert_eq!(reader.read_bits(8).unwrap(), 0b10101010);
614        assert_eq!(reader.read_bits(7).unwrap(), 0b0101010);
615        assert_eq!(reader.read_bits(6).unwrap(), 0b111100);
616        assert_eq!(reader.read_bits(5).unwrap(), 0b00001);
617        assert_eq!(reader.read_bits(4).unwrap(), 0b1100);
618
619        let mut buffer = Vec::new();
620        {
621            let mut writer = BitWriter::<_, LsbFirst>::spown_from(&mut buffer);
622            writer.write_bits((10, 0b1010101010));
623        }
624        assert_eq!(buffer.len(), 2);
625        let mut reader = buffer.into_iter();
626        let mut reader = BitReader::<_, LsbFirst>::spown_from(&mut reader).unwrap();
627        for _ in 0..5 {
628            assert_eq!(reader.read_bits(2).unwrap(), 0b10);
629        }
630    }
631
632    use crate::bit_coder::ByteReader;
633    use crate::bit_coder::ReaderErr::NotEnoughData;
634    use crate::bit_coder::ReverseByteReader;
635    #[test]
636    fn test_reverse_reader1() {
637        let buffer = vec![1_u8, 2, 3, 4, 5];
638        let mut reader = buffer.into_iter();
639        let mut reverse_reader = reader.spown_reverse_reader_at(2).unwrap();
640        assert_eq!(reverse_reader.read_u8_back().unwrap(), 2);
641        assert_eq!(reverse_reader.read_u8_back().unwrap(), 1);
642        assert_eq!(reverse_reader.read_u8_back(), Err(NotEnoughData));
643        assert!(reader.next().unwrap() == 3);
644        assert!(reader.next().unwrap() == 4);
645        assert!(reader.next().unwrap() == 5);
646        assert!(reader.next().is_none());
647    }
648
649    #[test]
650    fn test_reverse_reader2() {
651        let mut buffer = Vec::new();
652        buffer.write_u8(200);
653        buffer.write_u16(201);
654        buffer.write_u24(202);
655        buffer.write_u32(203);
656        assert!(buffer.len() == 10);
657        let mut reader = buffer.into_iter();
658        let mut reverse_reader = reader.spown_reverse_reader_at(10).unwrap();
659        assert_eq!(reverse_reader.read_u32_back().unwrap(), 203);
660        assert_eq!(reverse_reader.read_u24_back().unwrap(), 202);
661        assert_eq!(reverse_reader.read_u16_back().unwrap(), 201);
662        assert_eq!(reverse_reader.read_u8_back().unwrap(), 200);
663        assert_eq!(reverse_reader.read_u8_back(), Err(NotEnoughData));
664        assert!(reader.next().is_none());
665    }
666}
draco_oxide_core/bit_coder.rs

draco_oxide_core/
bit_coder.rs
