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 reports on standard error all
14/// operations performed, 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    #[must_use]
24    pub const fn new(cr: R) -> Self {
25        Self {
26            reader: cr,
27            _marker: core::marker::PhantomData,
28        }
29    }
30}
31
32impl<E: Endianness, R: BitRead<E>> BitRead<E> for DbgBitReader<E, R>
33where
34    R::PeekWord: core::fmt::Display,
35{
36    type Error = R::Error;
37    type PeekWord = R::PeekWord;
38    const PEEK_BITS: usize = R::PEEK_BITS;
39
40    fn peek_bits(&mut self, n_bits: usize) -> Result<Self::PeekWord, Self::Error> {
41        let value = self.reader.peek_bits(n_bits)?;
42        #[cfg(feature = "std")]
43        eprintln!("peek_bits({}): {}", n_bits, value);
44        Ok(value)
45    }
46
47    fn skip_bits(&mut self, n_bits: usize) -> Result<(), Self::Error> {
48        #[cfg(feature = "std")]
49        eprintln!("skip_bits({})", n_bits);
50        self.reader.skip_bits(n_bits)
51    }
52
53    fn read_bits(&mut self, num_bits: usize) -> Result<u64, Self::Error> {
54        let value = self.reader.read_bits(num_bits)?;
55        #[cfg(feature = "std")]
56        eprintln!("read_bits({}): {}", num_bits, value);
57        Ok(value)
58    }
59
60    fn read_unary(&mut self) -> Result<u64, Self::Error> {
61        let value = self.reader.read_unary()?;
62        #[cfg(feature = "std")]
63        eprintln!("{{U:{}}}", value);
64        Ok(value)
65    }
66
67    fn skip_bits_after_peek(&mut self, n: usize) {
68        self.reader.skip_bits_after_peek(n)
69    }
70}
71
72impl<E: Endianness, R: GammaRead<E>> GammaRead<E> for DbgBitReader<E, R>
73where
74    R::PeekWord: core::fmt::Display,
75{
76    fn read_gamma(&mut self) -> Result<u64, R::Error> {
77        let value = self.reader.read_gamma()?;
78        #[cfg(feature = "std")]
79        eprintln!("{{g:{}}}", value);
80        Ok(value)
81    }
82}
83
84impl<E: Endianness, R: DeltaRead<E>> DeltaRead<E> for DbgBitReader<E, R>
85where
86    R::PeekWord: core::fmt::Display,
87{
88    fn read_delta(&mut self) -> Result<u64, R::Error> {
89        let value = self.reader.read_delta()?;
90        #[cfg(feature = "std")]
91        eprintln!("{{d:{}}}", value);
92        Ok(value)
93    }
94}
95
96impl<E: Endianness, R: ZetaRead<E>> ZetaRead<E> for DbgBitReader<E, R>
97where
98    R::PeekWord: core::fmt::Display,
99{
100    fn read_zeta3(&mut self) -> Result<u64, R::Error> {
101        let value = self.reader.read_zeta3()?;
102        #[cfg(feature = "std")]
103        eprintln!("{{z3:{}}}", value);
104        Ok(value)
105    }
106
107    fn read_zeta(&mut self, k: usize) -> Result<u64, R::Error> {
108        let value = self.reader.read_zeta(k)?;
109        #[cfg(feature = "std")]
110        eprintln!("{{z{}:{}}}", k, value);
111        Ok(value)
112    }
113}
114
115impl<E: Endianness, R: OmegaRead<E>> OmegaRead<E> for DbgBitReader<E, R>
116where
117    R::PeekWord: core::fmt::Display,
118{
119    fn read_omega(&mut self) -> Result<u64, R::Error> {
120        let value = self.reader.read_omega()?;
121        #[cfg(feature = "std")]
122        eprintln!("{{o:{}}}", value);
123        Ok(value)
124    }
125}
126
127impl<E: Endianness, R: PiRead<E>> PiRead<E> for DbgBitReader<E, R>
128where
129    R::PeekWord: core::fmt::Display,
130{
131    fn read_pi(&mut self, k: usize) -> Result<u64, R::Error> {
132        let value = self.reader.read_pi(k)?;
133        #[cfg(feature = "std")]
134        eprintln!("{{p{}:{}}}", k, value);
135        Ok(value)
136    }
137
138    fn read_pi2(&mut self) -> Result<u64, R::Error> {
139        let value = self.reader.read_pi2()?;
140        #[cfg(feature = "std")]
141        eprintln!("{{p2:{}}}", value);
142        Ok(value)
143    }
144}
145
146/// A wrapper over a [`BitWrite`] that reports on standard error all operations performed,
147/// including all code writes.
148#[derive(Debug, Clone)]
149#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
150pub struct DbgBitWriter<E: Endianness, W> {
151    writer: W,
152    _marker: core::marker::PhantomData<E>,
153}
154
155impl<E: Endianness, W> DbgBitWriter<E, W> {
156    #[must_use]
157    pub const fn new(cw: W) -> Self {
158        Self {
159            writer: cw,
160            _marker: core::marker::PhantomData,
161        }
162    }
163}
164
165impl<E: Endianness, W: BitWrite<E>> BitWrite<E> for DbgBitWriter<E, W> {
166    type Error = W::Error;
167
168    fn write_bits(&mut self, value: u64, num_bits: usize) -> Result<usize, Self::Error> {
169        #[cfg(feature = "std")]
170        eprintln!("write_bits({}, {})", value, num_bits);
171        self.writer.write_bits(value, num_bits)
172    }
173
174    fn write_unary(&mut self, n: u64) -> Result<usize, Self::Error> {
175        #[cfg(feature = "std")]
176        eprintln!("{{U:{}}}", n);
177        self.writer.write_unary(n)
178    }
179
180    fn flush(&mut self) -> Result<usize, Self::Error> {
181        self.writer.flush()
182    }
183}
184
185impl<E: Endianness, W: GammaWrite<E>> GammaWrite<E> for DbgBitWriter<E, W> {
186    fn write_gamma(&mut self, n: u64) -> Result<usize, W::Error> {
187        #[cfg(feature = "std")]
188        eprintln!("{{g:{}}}", n);
189        self.writer.write_gamma(n)
190    }
191}
192
193impl<E: Endianness, W: DeltaWrite<E>> DeltaWrite<E> for DbgBitWriter<E, W> {
194    fn write_delta(&mut self, n: u64) -> Result<usize, W::Error> {
195        #[cfg(feature = "std")]
196        eprintln!("{{d:{}}}", n);
197        self.writer.write_delta(n)
198    }
199}
200
201impl<E: Endianness, W: ZetaWrite<E>> ZetaWrite<E> for DbgBitWriter<E, W> {
202    fn write_zeta(&mut self, n: u64, k: usize) -> Result<usize, W::Error> {
203        #[cfg(feature = "std")]
204        eprintln!("{{z{}:{}}}", k, n);
205        self.writer.write_zeta(n, k)
206    }
207    fn write_zeta3(&mut self, n: u64) -> Result<usize, W::Error> {
208        #[cfg(feature = "std")]
209        eprintln!("{{z3:{}}}", n);
210        self.writer.write_zeta3(n)
211    }
212}
213
214impl<E: Endianness, W: OmegaWrite<E>> OmegaWrite<E> for DbgBitWriter<E, W> {
215    fn write_omega(&mut self, n: u64) -> Result<usize, W::Error> {
216        #[cfg(feature = "std")]
217        eprintln!("{{o:{}}}", n);
218        self.writer.write_omega(n)
219    }
220}
221
222impl<E: Endianness, W: PiWrite<E>> PiWrite<E> for DbgBitWriter<E, W> {
223    fn write_pi(&mut self, n: u64, k: usize) -> Result<usize, W::Error> {
224        #[cfg(feature = "std")]
225        eprintln!("{{p{}:{}}}", k, n);
226        self.writer.write_pi(n, k)
227    }
228
229    fn write_pi2(&mut self, n: u64) -> Result<usize, W::Error> {
230        #[cfg(feature = "std")]
231        eprintln!("{{p2:{}}}", n);
232        self.writer.write_pi2(n)
233    }
234}
dsi_bitstream/utils/dbg_codes.rs

dsi_bitstream/utils/
dbg_codes.rs
