dsi_bitstream/utils/
dbg_codes.rs

1/*
2 * SPDX-FileCopyrightText: 2023 Inria
3 * SPDX-FileCopyrightText: 2023 Sebastiano Vigna
4 *
5 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
6 */
7
8use crate::prelude::*;
9use crate::traits::*;
10#[cfg(feature = "mem_dbg")]
11use mem_dbg::{MemDbg, MemSize};
12
13/// A wrapper over a [`BitRead`] that report on standard error all operations performed,
14/// including all code reads.
15#[derive(Debug, Clone)]
16#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
17pub struct DbgBitReader<E: Endianness, R> {
18    reader: R,
19    _marker: core::marker::PhantomData<E>,
20}
21
22impl<E: Endianness, R> DbgBitReader<E, R> {
23    pub fn new(cr: R) -> Self {
24        Self {
25            reader: cr,
26            _marker: Default::default(),
27        }
28    }
29}
30
31impl<E: Endianness, R: BitRead<E>> BitRead<E> for DbgBitReader<E, R>
32where
33    R::PeekWord: core::fmt::Display,
34{
35    type Error = R::Error;
36    type PeekWord = R::PeekWord;
37
38    fn peek_bits(&mut self, n_bits: usize) -> Result<Self::PeekWord, Self::Error> {
39        let value = self.reader.peek_bits(n_bits)?;
40        eprintln!("peek_bits({}): {}", n_bits, value);
41        Ok(value)
42    }
43
44    fn skip_bits(&mut self, n_bits: usize) -> Result<(), Self::Error> {
45        eprintln!("skip_bits({})", n_bits);
46        self.reader.skip_bits(n_bits)
47    }
48
49    fn read_bits(&mut self, n_bits: usize) -> Result<u64, Self::Error> {
50        let value = self.reader.read_bits(n_bits)?;
51        eprintln!("read_bits({}): {}", n_bits, value);
52        Ok(value)
53    }
54
55    fn read_unary(&mut self) -> Result<u64, Self::Error> {
56        let value = self.reader.read_unary()?;
57        eprintln!("{{U:{}}}", value);
58        Ok(value)
59    }
60
61    fn skip_bits_after_peek(&mut self, n: usize) {
62        self.reader.skip_bits_after_peek(n)
63    }
64}
65
66impl<E: Endianness, R: GammaRead<E>> GammaRead<E> for DbgBitReader<E, R>
67where
68    R::PeekWord: core::fmt::Display,
69{
70    fn read_gamma(&mut self) -> Result<u64, R::Error> {
71        let value = self.reader.read_gamma()?;
72        eprintln!("{{g:{}}}", value);
73        Ok(value)
74    }
75}
76
77impl<E: Endianness, R: DeltaRead<E>> DeltaRead<E> for DbgBitReader<E, R>
78where
79    R::PeekWord: core::fmt::Display,
80{
81    fn read_delta(&mut self) -> Result<u64, R::Error> {
82        let value = self.reader.read_delta()?;
83        eprintln!("{{d:{}}}", value);
84        Ok(value)
85    }
86}
87
88impl<E: Endianness, R: ZetaRead<E>> ZetaRead<E> for DbgBitReader<E, R>
89where
90    R::PeekWord: core::fmt::Display,
91{
92    fn read_zeta3(&mut self) -> Result<u64, R::Error> {
93        let value = self.reader.read_zeta3()?;
94        eprintln!("{{z3:{}}}", value);
95        Ok(value)
96    }
97
98    fn read_zeta(&mut self, k: usize) -> Result<u64, R::Error> {
99        let value = self.reader.read_zeta(k)?;
100        eprintln!("{{z{}:{}}}", k, value);
101        Ok(value)
102    }
103}
104
105/// A wrapper over a [`BitWrite`] that report on standard error all operations performed,
106/// including all code writes.
107#[derive(Debug, Clone)]
108#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
109pub struct DbgBitWriter<E: Endianness, W> {
110    writer: W,
111    _marker: core::marker::PhantomData<E>,
112}
113
114impl<E: Endianness, W> DbgBitWriter<E, W> {
115    pub fn new(cw: W) -> Self {
116        Self {
117            writer: cw,
118            _marker: Default::default(),
119        }
120    }
121}
122
123impl<E: Endianness, W: BitWrite<E>> BitWrite<E> for DbgBitWriter<E, W> {
124    type Error = W::Error;
125
126    fn write_bits(&mut self, value: u64, n_bits: usize) -> Result<usize, Self::Error> {
127        eprintln!("write_bits({}, {})", value, n_bits);
128        self.writer.write_bits(value, n_bits)
129    }
130
131    fn write_unary(&mut self, value: u64) -> Result<usize, Self::Error> {
132        eprintln!("{{U:{}}}", value);
133        self.writer.write_unary(value)
134    }
135
136    fn flush(&mut self) -> Result<usize, Self::Error> {
137        self.writer.flush()
138    }
139}
140
141impl<E: Endianness, W: GammaWrite<E>> GammaWrite<E> for DbgBitWriter<E, W> {
142    fn write_gamma(&mut self, value: u64) -> Result<usize, W::Error> {
143        eprintln!("{{g:{}}}", value);
144        self.writer.write_gamma(value)
145    }
146}
147
148impl<E: Endianness, W: DeltaWrite<E>> DeltaWrite<E> for DbgBitWriter<E, W> {
149    fn write_delta(&mut self, value: u64) -> Result<usize, W::Error> {
150        eprintln!("{{d:{}}}", value);
151        self.writer.write_delta(value)
152    }
153}
154
155impl<E: Endianness, W: ZetaWrite<E>> ZetaWrite<E> for DbgBitWriter<E, W> {
156    fn write_zeta(&mut self, value: u64, k: usize) -> Result<usize, W::Error> {
157        eprintln!("{{z{}:{}}}", value, k);
158        self.writer.write_zeta(value, k)
159    }
160    fn write_zeta3(&mut self, value: u64) -> Result<usize, W::Error> {
161        eprintln!("{{z3:{}}}", value);
162        self.writer.write_zeta3(value)
163    }
164}
dsi_bitstream/utils/dbg_codes.rs

dsi_bitstream/utils/
dbg_codes.rs
