fpzip_rs/core/
pc_decoder.rs

1use crate::codec::range_decoder::RangeDecoder;
2use crate::codec::rc_qs_model::RCQsModel;
3use crate::core::pc_map;
4
5const PC_BIT_MAX: u32 = 8;
6
7/// Predictive coder decoder for float values.
8pub struct PCDecoderFloat<'a, 'b> {
9    decoder: &'a mut RangeDecoder<'b>,
10    model: &'a mut RCQsModel,
11    bits: u32,
12}
13
14impl<'a, 'b> PCDecoderFloat<'a, 'b> {
15    pub fn new(decoder: &'a mut RangeDecoder<'b>, model: &'a mut RCQsModel, bits: u32) -> Self {
16        Self {
17            decoder,
18            model,
19            bits,
20        }
21    }
22
23    #[inline]
24    pub fn decode(&mut self, predicted: u32) -> u32 {
25        let predicted = pc_map::mask_u32(predicted, self.bits);
26        if self.bits > PC_BIT_MAX {
27            self.decode_wide(predicted)
28        } else {
29            self.decode_narrow(predicted)
30        }
31    }
32
33    #[inline]
34    fn decode_wide(&mut self, predicted: u32) -> u32 {
35        let bias = self.bits;
36        let s = self.decoder.decode_with_model(self.model);
37
38        if s > bias {
39            let k = (s - bias - 1) as i32;
40            let d = (1u32 << k) + self.decoder.decode_uint(k);
41            pc_map::mask_u32(predicted.wrapping_add(d), self.bits)
42        } else if s < bias {
43            let k = (bias - 1 - s) as i32;
44            let d = (1u32 << k) + self.decoder.decode_uint(k);
45            pc_map::mask_u32(predicted.wrapping_sub(d), self.bits)
46        } else {
47            predicted
48        }
49    }
50
51    #[inline]
52    fn decode_narrow(&mut self, predicted: u32) -> u32 {
53        let bias = (1u32 << self.bits) - 1;
54        let s = self.decoder.decode_with_model(self.model);
55        let r = predicted.wrapping_add(s).wrapping_sub(bias);
56        pc_map::mask_u32(r, self.bits)
57    }
58}
59
60/// Predictive coder decoder for double values.
61pub struct PCDecoderDouble<'a, 'b> {
62    decoder: &'a mut RangeDecoder<'b>,
63    model: &'a mut RCQsModel,
64    bits: u32,
65}
66
67impl<'a, 'b> PCDecoderDouble<'a, 'b> {
68    pub fn new(decoder: &'a mut RangeDecoder<'b>, model: &'a mut RCQsModel, bits: u32) -> Self {
69        Self {
70            decoder,
71            model,
72            bits,
73        }
74    }
75
76    #[inline]
77    pub fn decode(&mut self, predicted: u64) -> u64 {
78        let predicted = pc_map::mask_u64(predicted, self.bits);
79        if self.bits > PC_BIT_MAX {
80            self.decode_wide(predicted)
81        } else {
82            self.decode_narrow(predicted)
83        }
84    }
85
86    #[inline]
87    fn decode_wide(&mut self, predicted: u64) -> u64 {
88        let bias = self.bits;
89        let s = self.decoder.decode_with_model(self.model);
90
91        if s > bias {
92            let k = (s - bias - 1) as i32;
93            let d = (1u64 << k) + self.decoder.decode_ulong(k);
94            pc_map::mask_u64(predicted.wrapping_add(d), self.bits)
95        } else if s < bias {
96            let k = (bias - 1 - s) as i32;
97            let d = (1u64 << k) + self.decoder.decode_ulong(k);
98            pc_map::mask_u64(predicted.wrapping_sub(d), self.bits)
99        } else {
100            predicted
101        }
102    }
103
104    #[inline]
105    fn decode_narrow(&mut self, predicted: u64) -> u64 {
106        let bias = (1u64 << self.bits) - 1;
107        let s = self.decoder.decode_with_model(self.model) as u64;
108        let r = predicted.wrapping_add(s).wrapping_sub(bias);
109        pc_map::mask_u64(r, self.bits)
110    }
111}
fpzip_rs/core/pc_decoder.rs

fpzip_rs/core/
pc_decoder.rs
