draco_oxide/core/
bit_coder.rs

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

draco_oxide/core/
bit_coder.rs
