dsi_bitstream/dispatch/
static.rs

1/*
2 * SPDX-FileCopyrightText: 2025 Tommaso Fontana
3 * SPDX-FileCopyrightText: 2025 Inria
4 * SPDX-FileCopyrightText: 2025 Sebastiano Vigna
5 *
6 * SPDX-License-Identifier: Apache-2.0 OR MIT
7 */
8
9//! Static dispatch for codes.
10//!
11//! This kind of dispatch is resolved at compile time against a specific
12//! [`CodesRead`]. Thus, the code can be inlined and optimized, contrary to the
13//! [dynamic case], but you have less flexibility as codes have to be chosen at
14//! compile time.
15//!
16//! [dynamic case]: crate::dispatch::dynamic
17
18use super::*;
19
20#[cfg(feature = "mem_dbg")]
21use mem_dbg::{MemDbg, MemSize};
22
23/// A zero-sized struct with a const generic parameter representing a code using
24/// the constants exported by the [`code_consts`] module.
25///
26/// Methods for all traits are implemented for this struct using a match on the
27/// value of the const type parameter. Since the parameter is a constant, the
28/// match is resolved at compile time, so there will be no runtime overhead.
29///
30/// If the value is not among those defined in the [`code_consts`] module, the
31/// methods will panic.
32///
33/// See the [module documentation] for more information.
34///
35/// [module documentation]: crate::dispatch
36#[derive(Debug, Clone, Copy, PartialEq, Eq)]
37#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
38pub struct ConstCode<const CODE: usize>;
39
40impl<const CODE: usize> ConstCode<CODE> {
41    /// Delegates the read method to the [`DynamicCodeRead`] implementation.
42    ///
43    /// This inherent method is provided to reduce ambiguity in method
44    /// resolution.
45    #[inline(always)]
46    pub fn read<E: Endianness, CR: CodesRead<E> + ?Sized>(
47        &self,
48        reader: &mut CR,
49    ) -> Result<u64, CR::Error> {
50        DynamicCodeRead::read(self, reader)
51    }
52
53    /// Delegates to the [`DynamicCodeWrite`] implementation.
54    ///
55    /// This inherent method is provided to reduce ambiguity in method
56    /// resolution.
57    #[inline(always)]
58    pub fn write<E: Endianness, CW: CodesWrite<E> + ?Sized>(
59        &self,
60        writer: &mut CW,
61        n: u64,
62    ) -> Result<usize, CW::Error> {
63        DynamicCodeWrite::write(self, writer, n)
64    }
65}
66
67/// The constants to use as generic parameter for the [`ConstCode`] struct.
68///
69/// Aliases for equivalent codes (e.g., [`ZETA1`], [`RICE0`]) are derived from
70/// [`Codes::canonicalize`] via [`Codes::to_code_const`], so they are guaranteed
71/// to be consistent.
72///
73/// [`ZETA1`]: self::code_consts::ZETA1
74/// [`RICE0`]: self::code_consts::RICE0
75pub mod code_consts {
76    use super::Codes;
77
78    /// Unwraps a [`Codes::to_code_const`] result at compile
79    /// time.
80    const fn canonical(code: Codes) -> usize {
81        match code.to_code_const() {
82            Ok(v) => v,
83            Err(_) => panic!("unsupported canonical code"),
84        }
85    }
86
87    pub const UNARY: usize = 0;
88    pub const GAMMA: usize = 1;
89    pub const DELTA: usize = 2;
90    pub const OMEGA: usize = 3;
91    pub const VBYTE_BE: usize = 4;
92    pub const VBYTE_LE: usize = 5;
93    pub const ZETA1: usize = canonical(Codes::Zeta(1));
94    pub const ZETA2: usize = 6;
95    pub const ZETA3: usize = 7;
96    pub const ZETA4: usize = 8;
97    pub const ZETA5: usize = 9;
98    pub const ZETA6: usize = 10;
99    pub const ZETA7: usize = 11;
100    pub const ZETA8: usize = 12;
101    pub const ZETA9: usize = 13;
102    pub const ZETA10: usize = 14;
103    pub const RICE0: usize = canonical(Codes::Rice(0));
104    pub const RICE1: usize = 15;
105    pub const RICE2: usize = 16;
106    pub const RICE3: usize = 17;
107    pub const RICE4: usize = 18;
108    pub const RICE5: usize = 19;
109    pub const RICE6: usize = 20;
110    pub const RICE7: usize = 21;
111    pub const RICE8: usize = 22;
112    pub const RICE9: usize = 23;
113    pub const RICE10: usize = 24;
114    pub const PI0: usize = canonical(Codes::Pi(0));
115    pub const PI1: usize = 25;
116    pub const PI2: usize = 26;
117    pub const PI3: usize = 27;
118    pub const PI4: usize = 28;
119    pub const PI5: usize = 29;
120    pub const PI6: usize = 30;
121    pub const PI7: usize = 31;
122    pub const PI8: usize = 32;
123    pub const PI9: usize = 33;
124    pub const PI10: usize = 34;
125    pub const GOLOMB1: usize = canonical(Codes::Golomb(1));
126    pub const GOLOMB2: usize = canonical(Codes::Golomb(2));
127    pub const GOLOMB3: usize = 35;
128    pub const GOLOMB4: usize = canonical(Codes::Golomb(4));
129    pub const GOLOMB5: usize = 36;
130    pub const GOLOMB6: usize = 37;
131    pub const GOLOMB7: usize = 38;
132    pub const GOLOMB8: usize = canonical(Codes::Golomb(8));
133    pub const GOLOMB9: usize = 39;
134    pub const GOLOMB10: usize = 40;
135    pub const EXP_GOLOMB0: usize = canonical(Codes::ExpGolomb(0));
136    pub const EXP_GOLOMB1: usize = 41;
137    pub const EXP_GOLOMB2: usize = 42;
138    pub const EXP_GOLOMB3: usize = 43;
139    pub const EXP_GOLOMB4: usize = 44;
140    pub const EXP_GOLOMB5: usize = 45;
141    pub const EXP_GOLOMB6: usize = 46;
142    pub const EXP_GOLOMB7: usize = 47;
143    pub const EXP_GOLOMB8: usize = 48;
144    pub const EXP_GOLOMB9: usize = 49;
145    pub const EXP_GOLOMB10: usize = 50;
146}
147
148impl<const CODE: usize> DynamicCodeRead for ConstCode<CODE> {
149    fn read<E: Endianness, CR: CodesRead<E> + ?Sized>(
150        &self,
151        reader: &mut CR,
152    ) -> Result<u64, CR::Error> {
153        match CODE {
154            code_consts::UNARY => reader.read_unary(),
155            code_consts::GAMMA => reader.read_gamma(),
156            code_consts::DELTA => reader.read_delta(),
157            code_consts::OMEGA => reader.read_omega(),
158            code_consts::VBYTE_BE => reader.read_vbyte_be(),
159            code_consts::VBYTE_LE => reader.read_vbyte_le(),
160            code_consts::ZETA2 => reader.read_zeta(2),
161            code_consts::ZETA3 => reader.read_zeta3(),
162            code_consts::ZETA4 => reader.read_zeta(4),
163            code_consts::ZETA5 => reader.read_zeta(5),
164            code_consts::ZETA6 => reader.read_zeta(6),
165            code_consts::ZETA7 => reader.read_zeta(7),
166            code_consts::ZETA8 => reader.read_zeta(8),
167            code_consts::ZETA9 => reader.read_zeta(9),
168            code_consts::ZETA10 => reader.read_zeta(10),
169            code_consts::RICE1 => reader.read_rice(1),
170            code_consts::RICE2 => reader.read_rice(2),
171            code_consts::RICE3 => reader.read_rice(3),
172            code_consts::RICE4 => reader.read_rice(4),
173            code_consts::RICE5 => reader.read_rice(5),
174            code_consts::RICE6 => reader.read_rice(6),
175            code_consts::RICE7 => reader.read_rice(7),
176            code_consts::RICE8 => reader.read_rice(8),
177            code_consts::RICE9 => reader.read_rice(9),
178            code_consts::RICE10 => reader.read_rice(10),
179            code_consts::PI1 => reader.read_pi(1),
180            code_consts::PI2 => reader.read_pi2(),
181            code_consts::PI3 => reader.read_pi(3),
182            code_consts::PI4 => reader.read_pi(4),
183            code_consts::PI5 => reader.read_pi(5),
184            code_consts::PI6 => reader.read_pi(6),
185            code_consts::PI7 => reader.read_pi(7),
186            code_consts::PI8 => reader.read_pi(8),
187            code_consts::PI9 => reader.read_pi(9),
188            code_consts::PI10 => reader.read_pi(10),
189            code_consts::GOLOMB3 => reader.read_golomb(3),
190            code_consts::GOLOMB5 => reader.read_golomb(5),
191            code_consts::GOLOMB6 => reader.read_golomb(6),
192            code_consts::GOLOMB7 => reader.read_golomb(7),
193            code_consts::GOLOMB9 => reader.read_golomb(9),
194            code_consts::GOLOMB10 => reader.read_golomb(10),
195            code_consts::EXP_GOLOMB1 => reader.read_exp_golomb(1),
196            code_consts::EXP_GOLOMB2 => reader.read_exp_golomb(2),
197            code_consts::EXP_GOLOMB3 => reader.read_exp_golomb(3),
198            code_consts::EXP_GOLOMB4 => reader.read_exp_golomb(4),
199            code_consts::EXP_GOLOMB5 => reader.read_exp_golomb(5),
200            code_consts::EXP_GOLOMB6 => reader.read_exp_golomb(6),
201            code_consts::EXP_GOLOMB7 => reader.read_exp_golomb(7),
202            code_consts::EXP_GOLOMB8 => reader.read_exp_golomb(8),
203            code_consts::EXP_GOLOMB9 => reader.read_exp_golomb(9),
204            code_consts::EXP_GOLOMB10 => reader.read_exp_golomb(10),
205            _ => panic!("Unknown code index: {}", CODE),
206        }
207    }
208}
209
210impl<const CODE: usize> DynamicCodeWrite for ConstCode<CODE> {
211    fn write<E: Endianness, CW: CodesWrite<E> + ?Sized>(
212        &self,
213        writer: &mut CW,
214        n: u64,
215    ) -> Result<usize, CW::Error> {
216        match CODE {
217            code_consts::UNARY => writer.write_unary(n),
218            code_consts::GAMMA => writer.write_gamma(n),
219            code_consts::DELTA => writer.write_delta(n),
220            code_consts::OMEGA => writer.write_omega(n),
221            code_consts::VBYTE_BE => writer.write_vbyte_be(n),
222            code_consts::VBYTE_LE => writer.write_vbyte_le(n),
223            code_consts::ZETA2 => writer.write_zeta(n, 2),
224            code_consts::ZETA3 => writer.write_zeta3(n),
225            code_consts::ZETA4 => writer.write_zeta(n, 4),
226            code_consts::ZETA5 => writer.write_zeta(n, 5),
227            code_consts::ZETA6 => writer.write_zeta(n, 6),
228            code_consts::ZETA7 => writer.write_zeta(n, 7),
229            code_consts::ZETA8 => writer.write_zeta(n, 8),
230            code_consts::ZETA9 => writer.write_zeta(n, 9),
231            code_consts::ZETA10 => writer.write_zeta(n, 10),
232            code_consts::RICE1 => writer.write_rice(n, 1),
233            code_consts::RICE2 => writer.write_rice(n, 2),
234            code_consts::RICE3 => writer.write_rice(n, 3),
235            code_consts::RICE4 => writer.write_rice(n, 4),
236            code_consts::RICE5 => writer.write_rice(n, 5),
237            code_consts::RICE6 => writer.write_rice(n, 6),
238            code_consts::RICE7 => writer.write_rice(n, 7),
239            code_consts::RICE8 => writer.write_rice(n, 8),
240            code_consts::RICE9 => writer.write_rice(n, 9),
241            code_consts::RICE10 => writer.write_rice(n, 10),
242            code_consts::PI1 => writer.write_pi(n, 1),
243            code_consts::PI2 => writer.write_pi2(n),
244            code_consts::PI3 => writer.write_pi(n, 3),
245            code_consts::PI4 => writer.write_pi(n, 4),
246            code_consts::PI5 => writer.write_pi(n, 5),
247            code_consts::PI6 => writer.write_pi(n, 6),
248            code_consts::PI7 => writer.write_pi(n, 7),
249            code_consts::PI8 => writer.write_pi(n, 8),
250            code_consts::PI9 => writer.write_pi(n, 9),
251            code_consts::PI10 => writer.write_pi(n, 10),
252            code_consts::GOLOMB3 => writer.write_golomb(n, 3),
253            code_consts::GOLOMB5 => writer.write_golomb(n, 5),
254            code_consts::GOLOMB6 => writer.write_golomb(n, 6),
255            code_consts::GOLOMB7 => writer.write_golomb(n, 7),
256            code_consts::GOLOMB9 => writer.write_golomb(n, 9),
257            code_consts::GOLOMB10 => writer.write_golomb(n, 10),
258            code_consts::EXP_GOLOMB1 => writer.write_exp_golomb(n, 1),
259            code_consts::EXP_GOLOMB2 => writer.write_exp_golomb(n, 2),
260            code_consts::EXP_GOLOMB3 => writer.write_exp_golomb(n, 3),
261            code_consts::EXP_GOLOMB4 => writer.write_exp_golomb(n, 4),
262            code_consts::EXP_GOLOMB5 => writer.write_exp_golomb(n, 5),
263            code_consts::EXP_GOLOMB6 => writer.write_exp_golomb(n, 6),
264            code_consts::EXP_GOLOMB7 => writer.write_exp_golomb(n, 7),
265            code_consts::EXP_GOLOMB8 => writer.write_exp_golomb(n, 8),
266            code_consts::EXP_GOLOMB9 => writer.write_exp_golomb(n, 9),
267            code_consts::EXP_GOLOMB10 => writer.write_exp_golomb(n, 10),
268            _ => panic!("Unknown code: {}", CODE),
269        }
270    }
271}
272
273impl<E: Endianness, CR: CodesRead<E> + ?Sized, const CODE: usize> StaticCodeRead<E, CR>
274    for ConstCode<CODE>
275{
276    #[inline(always)]
277    fn read(&self, reader: &mut CR) -> Result<u64, CR::Error> {
278        <Self as DynamicCodeRead>::read(self, reader)
279    }
280}
281
282impl<E: Endianness, CW: CodesWrite<E> + ?Sized, const CODE: usize> StaticCodeWrite<E, CW>
283    for ConstCode<CODE>
284{
285    #[inline(always)]
286    fn write(&self, writer: &mut CW, n: u64) -> Result<usize, CW::Error> {
287        <Self as DynamicCodeWrite>::write(self, writer, n)
288    }
289}
290
291impl<const CODE: usize> CodeLen for ConstCode<CODE> {
292    #[inline]
293    fn len(&self, n: u64) -> usize {
294        match CODE {
295            code_consts::UNARY => n as usize + 1,
296            code_consts::GAMMA => len_gamma(n),
297            code_consts::DELTA => len_delta(n),
298            code_consts::OMEGA => len_omega(n),
299            code_consts::VBYTE_BE | code_consts::VBYTE_LE => bit_len_vbyte(n),
300            code_consts::ZETA2 => len_zeta(n, 2),
301            code_consts::ZETA3 => len_zeta(n, 3),
302            code_consts::ZETA4 => len_zeta(n, 4),
303            code_consts::ZETA5 => len_zeta(n, 5),
304            code_consts::ZETA6 => len_zeta(n, 6),
305            code_consts::ZETA7 => len_zeta(n, 7),
306            code_consts::ZETA8 => len_zeta(n, 8),
307            code_consts::ZETA9 => len_zeta(n, 9),
308            code_consts::ZETA10 => len_zeta(n, 10),
309            code_consts::RICE1 => len_rice(n, 1),
310            code_consts::RICE2 => len_rice(n, 2),
311            code_consts::RICE3 => len_rice(n, 3),
312            code_consts::RICE4 => len_rice(n, 4),
313            code_consts::RICE5 => len_rice(n, 5),
314            code_consts::RICE6 => len_rice(n, 6),
315            code_consts::RICE7 => len_rice(n, 7),
316            code_consts::RICE8 => len_rice(n, 8),
317            code_consts::RICE9 => len_rice(n, 9),
318            code_consts::RICE10 => len_rice(n, 10),
319            code_consts::PI1 => len_pi(n, 1),
320            code_consts::PI2 => len_pi(n, 2),
321            code_consts::PI3 => len_pi(n, 3),
322            code_consts::PI4 => len_pi(n, 4),
323            code_consts::PI5 => len_pi(n, 5),
324            code_consts::PI6 => len_pi(n, 6),
325            code_consts::PI7 => len_pi(n, 7),
326            code_consts::PI8 => len_pi(n, 8),
327            code_consts::PI9 => len_pi(n, 9),
328            code_consts::PI10 => len_pi(n, 10),
329            code_consts::GOLOMB3 => len_golomb(n, 3),
330            code_consts::GOLOMB5 => len_golomb(n, 5),
331            code_consts::GOLOMB6 => len_golomb(n, 6),
332            code_consts::GOLOMB7 => len_golomb(n, 7),
333            code_consts::GOLOMB9 => len_golomb(n, 9),
334            code_consts::GOLOMB10 => len_golomb(n, 10),
335            code_consts::EXP_GOLOMB1 => len_exp_golomb(n, 1),
336            code_consts::EXP_GOLOMB2 => len_exp_golomb(n, 2),
337            code_consts::EXP_GOLOMB3 => len_exp_golomb(n, 3),
338            code_consts::EXP_GOLOMB4 => len_exp_golomb(n, 4),
339            code_consts::EXP_GOLOMB5 => len_exp_golomb(n, 5),
340            code_consts::EXP_GOLOMB6 => len_exp_golomb(n, 6),
341            code_consts::EXP_GOLOMB7 => len_exp_golomb(n, 7),
342            code_consts::EXP_GOLOMB8 => len_exp_golomb(n, 8),
343            code_consts::EXP_GOLOMB9 => len_exp_golomb(n, 9),
344            code_consts::EXP_GOLOMB10 => len_exp_golomb(n, 10),
345            _ => panic!("Unknown code: {}", CODE),
346        }
347    }
348}
dsi_bitstream/dispatch/static.rs

dsi_bitstream/dispatch/
static.rs
