21     def __init__(self, data):  argument
23         self.bytes = data
25         self.bp_bw = len(data) - 1
26         self.mask_bw = 1
28         self.bp = 0
29         self.low = 0
30         self.range = 0xffffff
32     def dump(self):  argument
34         b = self.bytes
42     def __init__(self, data):  argument
46         self.low = ( (self.bytes[0] << 16) |
47                      (self.bytes[1] <<  8) |
48                      (self.bytes[2]      ) )
49         self.bp = 3
51     def read_bit(self):  argument
53         bit = bool(self.bytes[self.bp_bw] & self.mask_bw)
55         self.mask_bw <<= 1
56         if self.mask_bw == 0x100:
57             self.mask_bw = 1
58             self.bp_bw -= 1
62     def read_uint(self, nbits):  argument
66             val |= self.read_bit() << k
70     def ac_decode(self, cum_freqs, sym_freqs):  argument
72         r = self.range >> 10
73         if self.low >= r << 10:
77         while self.low < r * cum_freqs[val]:
80         self.low -= r * cum_freqs[val]
81         self.range = r * sym_freqs[val]
82         while self.range < 0x10000:
83             self.range <<= 8
85             self.low <<= 8
86             self.low &= 0xffffff
87             self.low += self.bytes[self.bp]
88             self.bp += 1
92     def get_bits_left(self):  argument
94         nbits = 8 * len(self.bytes)
97             (8*self.bp_bw + 8 - int(math.log2(self.mask_bw)))
99         nbits_ac = 8 * (self.bp - 3) + \
100             (25 - int(math.floor(math.log2(self.range))))
106     def __init__(self, nbytes):  argument
110         self.cache = -1
111         self.carry = 0
112         self.carry_count = 0
114     def write_bit(self, bit):  argument
116         mask = self.mask_bw
117         bp = self.bp_bw
120             self.bytes[bp] &= ~mask
122             self.bytes[bp] |= mask
124         self.mask_bw <<= 1
125         if self.mask_bw == 0x100:
126             self.mask_bw = 1
127             self.bp_bw -= 1
129     def write_uint(self, val, nbits):  argument
132             self.write_bit(val & 1)
135     def ac_shift(self):  argument
137         if self.low < 0xff0000 or self.carry == 1:
139             if self.cache >= 0:
140                 self.bytes[self.bp] = self.cache + self.carry
141                 self.bp += 1
143             while self.carry_count > 0:
144                 self.bytes[self.bp] = (self.carry + 0xff) & 0xff
145                 self.bp += 1
146                 self.carry_count -= 1
148             self.cache = self.low >> 16
149             self.carry = 0
152             self.carry_count += 1
154         self.low <<= 8
155         self.low &= 0xffffff
157     def ac_encode(self, cum_freq, sym_freq):  argument
159         r = self.range >> 10
160         self.low += r * cum_freq
161         if (self.low >> 24) != 0:
162             self.carry = 1
164         self.low &= 0xffffff
165         self.range = r * sym_freq
166         while self.range < 0x10000:
167             self.range <<= 8
168             self.ac_shift()
170     def get_bits_left(self):  argument
172         nbits = 8 * len(self.bytes)
175             (8*self.bp_bw + 8 - int(math.log2(self.mask_bw)))
177         nbits_ac = 8 * self.bp + (25 - int(math.floor(math.log2(self.range))))
178         if self.cache >= 0:
180         if self.carry_count > 0:
181             nbits_ac += 8 * self.carry_count
185     def terminate(self):  argument
188         while self.range >> (24 - bits) == 0:
192         val = self.low + mask
196         high = self.low + self.range
206                 val = ((self.low + mask) & 0x00ffffff) & ~mask
208             if val < self.low:
209                 self.carry = 1
211         self.low = val
213             self.ac_shift()
217         val = self.cache
219         if self.carry_count > 0:
220             self.bytes[self.bp] = self.cache
221             self.bp += 1
223             while self.carry_count > 1:
224                 self.bytes[self.bp] = 0xff
225                 self.bp += 1
226                 self.carry_count -= 1
234                 self.bytes[self.bp] &= ~mask
236                 self.bytes[self.bp] |= mask
240         return self.bytes