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        #[cfg(feature = "std")]
41        eprintln!("peek_bits({}): {}", n_bits, value);
42        Ok(value)
43    }
44
45    fn skip_bits(&mut self, n_bits: usize) -> Result<(), Self::Error> {
46        #[cfg(feature = "std")]
47        eprintln!("skip_bits({})", n_bits);
48        self.reader.skip_bits(n_bits)
49    }
50
51    fn read_bits(&mut self, n_bits: usize) -> Result<u64, Self::Error> {
52        let value = self.reader.read_bits(n_bits)?;
53        #[cfg(feature = "std")]
54        eprintln!("read_bits({}): {}", n_bits, value);
55        Ok(value)
56    }
57
58    fn read_unary(&mut self) -> Result<u64, Self::Error> {
59        let value = self.reader.read_unary()?;
60        #[cfg(feature = "std")]
61        eprintln!("{{U:{}}}", value);
62        Ok(value)
63    }
64
65    fn skip_bits_after_peek(&mut self, n: usize) {
66        self.reader.skip_bits_after_peek(n)
67    }
68}
69
70impl<E: Endianness, R: GammaRead<E>> GammaRead<E> for DbgBitReader<E, R>
71where
72    R::PeekWord: core::fmt::Display,
73{
74    fn read_gamma(&mut self) -> Result<u64, R::Error> {
75        let value = self.reader.read_gamma()?;
76        #[cfg(feature = "std")]
77        eprintln!("{{g:{}}}", value);
78        Ok(value)
79    }
80}
81
82impl<E: Endianness, R: DeltaRead<E>> DeltaRead<E> for DbgBitReader<E, R>
83where
84    R::PeekWord: core::fmt::Display,
85{
86    fn read_delta(&mut self) -> Result<u64, R::Error> {
87        let value = self.reader.read_delta()?;
88        #[cfg(feature = "std")]
89        eprintln!("{{d:{}}}", value);
90        Ok(value)
91    }
92}
93
94impl<E: Endianness, R: ZetaRead<E>> ZetaRead<E> for DbgBitReader<E, R>
95where
96    R::PeekWord: core::fmt::Display,
97{
98    fn read_zeta3(&mut self) -> Result<u64, R::Error> {
99        let value = self.reader.read_zeta3()?;
100        #[cfg(feature = "std")]
101        eprintln!("{{z3:{}}}", value);
102        Ok(value)
103    }
104
105    fn read_zeta(&mut self, k: usize) -> Result<u64, R::Error> {
106        let value = self.reader.read_zeta(k)?;
107        #[cfg(feature = "std")]
108        eprintln!("{{z{}:{}}}", k, value);
109        Ok(value)
110    }
111}
112
113/// A wrapper over a [`BitWrite`] that report on standard error all operations performed,
114/// including all code writes.
115#[derive(Debug, Clone)]
116#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
117pub struct DbgBitWriter<E: Endianness, W> {
118    writer: W,
119    _marker: core::marker::PhantomData<E>,
120}
121
122impl<E: Endianness, W> DbgBitWriter<E, W> {
123    pub fn new(cw: W) -> Self {
124        Self {
125            writer: cw,
126            _marker: Default::default(),
127        }
128    }
129}
130
131impl<E: Endianness, W: BitWrite<E>> BitWrite<E> for DbgBitWriter<E, W> {
132    type Error = W::Error;
133
134    fn write_bits(&mut self, value: u64, n_bits: usize) -> Result<usize, Self::Error> {
135        #[cfg(feature = "std")]
136        eprintln!("write_bits({}, {})", value, n_bits);
137        self.writer.write_bits(value, n_bits)
138    }
139
140    fn write_unary(&mut self, value: u64) -> Result<usize, Self::Error> {
141        #[cfg(feature = "std")]
142        eprintln!("{{U:{}}}", value);
143        self.writer.write_unary(value)
144    }
145
146    fn flush(&mut self) -> Result<usize, Self::Error> {
147        self.writer.flush()
148    }
149}
150
151impl<E: Endianness, W: GammaWrite<E>> GammaWrite<E> for DbgBitWriter<E, W> {
152    fn write_gamma(&mut self, value: u64) -> Result<usize, W::Error> {
153        #[cfg(feature = "std")]
154        eprintln!("{{g:{}}}", value);
155        self.writer.write_gamma(value)
156    }
157}
158
159impl<E: Endianness, W: DeltaWrite<E>> DeltaWrite<E> for DbgBitWriter<E, W> {
160    fn write_delta(&mut self, value: u64) -> Result<usize, W::Error> {
161        #[cfg(feature = "std")]
162        eprintln!("{{d:{}}}", value);
163        self.writer.write_delta(value)
164    }
165}
166
167impl<E: Endianness, W: ZetaWrite<E>> ZetaWrite<E> for DbgBitWriter<E, W> {
168    fn write_zeta(&mut self, value: u64, k: usize) -> Result<usize, W::Error> {
169        #[cfg(feature = "std")]
170        eprintln!("{{z{}:{}}}", value, k);
171        self.writer.write_zeta(value, k)
172    }
173    fn write_zeta3(&mut self, value: u64) -> Result<usize, W::Error> {
174        #[cfg(feature = "std")]
175        eprintln!("{{z3:{}}}", value);
176        self.writer.write_zeta3(value)
177    }
178}
dsi_bitstream/utils/dbg_codes.rs

dsi_bitstream/utils/
dbg_codes.rs
