1 // Copyright 2010 Google Inc. All Rights Reserved.
2 //
3 // Use of this source code is governed by a BSD-style license
4 // that can be found in the COPYING file in the root of the source
5 // tree. An additional intellectual property rights grant can be found
6 // in the file PATENTS. All contributing project authors may
7 // be found in the AUTHORS file in the root of the source tree.
8 // -----------------------------------------------------------------------------
9 //
10 // Boolean decoder non-inlined methods
11 //
12 // Author: Skal (pascal.massimino@gmail.com)
13
14 #ifdef HAVE_CONFIG_H
15 #include "../webp/config.h"
16 #endif
17
18 #include "./bit_reader_inl.h"
19
20 //------------------------------------------------------------------------------
21 // VP8BitReader
22
VP8InitBitReader(VP8BitReader * const br,const uint8_t * const start,const uint8_t * const end)23 void VP8InitBitReader(VP8BitReader* const br,
24 const uint8_t* const start, const uint8_t* const end) {
25 assert(br != NULL);
26 assert(start != NULL);
27 assert(start <= end);
28 br->range_ = 255 - 1;
29 br->buf_ = start;
30 br->buf_end_ = end;
31 br->value_ = 0;
32 br->bits_ = -8; // to load the very first 8bits
33 br->eof_ = 0;
34 VP8LoadNewBytes(br);
35 }
36
VP8RemapBitReader(VP8BitReader * const br,ptrdiff_t offset)37 void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) {
38 if (br->buf_ != NULL) {
39 br->buf_ += offset;
40 br->buf_end_ += offset;
41 }
42 }
43
44 const uint8_t kVP8Log2Range[128] = {
45 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
46 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
47 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
48 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
49 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
50 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
51 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
52 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
53 0
54 };
55
56 // range = ((range - 1) << kVP8Log2Range[range]) + 1
57 const range_t kVP8NewRange[128] = {
58 127, 127, 191, 127, 159, 191, 223, 127,
59 143, 159, 175, 191, 207, 223, 239, 127,
60 135, 143, 151, 159, 167, 175, 183, 191,
61 199, 207, 215, 223, 231, 239, 247, 127,
62 131, 135, 139, 143, 147, 151, 155, 159,
63 163, 167, 171, 175, 179, 183, 187, 191,
64 195, 199, 203, 207, 211, 215, 219, 223,
65 227, 231, 235, 239, 243, 247, 251, 127,
66 129, 131, 133, 135, 137, 139, 141, 143,
67 145, 147, 149, 151, 153, 155, 157, 159,
68 161, 163, 165, 167, 169, 171, 173, 175,
69 177, 179, 181, 183, 185, 187, 189, 191,
70 193, 195, 197, 199, 201, 203, 205, 207,
71 209, 211, 213, 215, 217, 219, 221, 223,
72 225, 227, 229, 231, 233, 235, 237, 239,
73 241, 243, 245, 247, 249, 251, 253, 127
74 };
75
VP8LoadFinalBytes(VP8BitReader * const br)76 void VP8LoadFinalBytes(VP8BitReader* const br) {
77 assert(br != NULL && br->buf_ != NULL);
78 // Only read 8bits at a time
79 if (br->buf_ < br->buf_end_) {
80 br->bits_ += 8;
81 br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8);
82 } else if (!br->eof_) {
83 br->value_ <<= 8;
84 br->bits_ += 8;
85 br->eof_ = 1;
86 }
87 }
88
89 //------------------------------------------------------------------------------
90 // Higher-level calls
91
VP8GetValue(VP8BitReader * const br,int bits)92 uint32_t VP8GetValue(VP8BitReader* const br, int bits) {
93 uint32_t v = 0;
94 while (bits-- > 0) {
95 v |= VP8GetBit(br, 0x80) << bits;
96 }
97 return v;
98 }
99
VP8GetSignedValue(VP8BitReader * const br,int bits)100 int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) {
101 const int value = VP8GetValue(br, bits);
102 return VP8Get(br) ? -value : value;
103 }
104
105 //------------------------------------------------------------------------------
106 // VP8LBitReader
107
108 #define VP8L_LOG8_WBITS 4 // Number of bytes needed to store VP8L_WBITS bits.
109
110 #if !defined(WEBP_FORCE_ALIGNED) && \
111 (defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || \
112 defined(__i386__) || defined(_M_IX86) || \
113 defined(__x86_64__) || defined(_M_X64))
114 #define VP8L_USE_UNALIGNED_LOAD
115 #endif
116
117 static const uint32_t kBitMask[VP8L_MAX_NUM_BIT_READ + 1] = {
118 0,
119 0x000001, 0x000003, 0x000007, 0x00000f,
120 0x00001f, 0x00003f, 0x00007f, 0x0000ff,
121 0x0001ff, 0x0003ff, 0x0007ff, 0x000fff,
122 0x001fff, 0x003fff, 0x007fff, 0x00ffff,
123 0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff,
124 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff
125 };
126
VP8LInitBitReader(VP8LBitReader * const br,const uint8_t * const start,size_t length)127 void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start,
128 size_t length) {
129 size_t i;
130 vp8l_val_t value = 0;
131 assert(br != NULL);
132 assert(start != NULL);
133 assert(length < 0xfffffff8u); // can't happen with a RIFF chunk.
134
135 br->len_ = length;
136 br->val_ = 0;
137 br->bit_pos_ = 0;
138 br->eos_ = 0;
139 br->error_ = 0;
140
141 if (length > sizeof(br->val_)) {
142 length = sizeof(br->val_);
143 }
144 for (i = 0; i < length; ++i) {
145 value |= (vp8l_val_t)start[i] << (8 * i);
146 }
147 br->val_ = value;
148 br->pos_ = length;
149 br->buf_ = start;
150 }
151
VP8LBitReaderSetBuffer(VP8LBitReader * const br,const uint8_t * const buf,size_t len)152 void VP8LBitReaderSetBuffer(VP8LBitReader* const br,
153 const uint8_t* const buf, size_t len) {
154 assert(br != NULL);
155 assert(buf != NULL);
156 assert(len < 0xfffffff8u); // can't happen with a RIFF chunk.
157 br->buf_ = buf;
158 br->len_ = len;
159 // pos_ > len_ should be considered a param error.
160 br->error_ = (br->pos_ > br->len_);
161 br->eos_ = br->error_ || VP8LIsEndOfStream(br);
162 }
163
164 // If not at EOS, reload up to VP8L_LBITS byte-by-byte
ShiftBytes(VP8LBitReader * const br)165 static void ShiftBytes(VP8LBitReader* const br) {
166 while (br->bit_pos_ >= 8 && br->pos_ < br->len_) {
167 br->val_ >>= 8;
168 br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (VP8L_LBITS - 8);
169 ++br->pos_;
170 br->bit_pos_ -= 8;
171 }
172 br->eos_ = VP8LIsEndOfStream(br);
173 }
174
VP8LDoFillBitWindow(VP8LBitReader * const br)175 void VP8LDoFillBitWindow(VP8LBitReader* const br) {
176 assert(br->bit_pos_ >= VP8L_WBITS);
177 // TODO(jzern): given the fixed read size it may be possible to force
178 // alignment in this block.
179 #if defined(VP8L_USE_UNALIGNED_LOAD)
180 if (br->pos_ + sizeof(br->val_) < br->len_) {
181 br->val_ >>= VP8L_WBITS;
182 br->bit_pos_ -= VP8L_WBITS;
183 // The expression below needs a little-endian arch to work correctly.
184 // This gives a large speedup for decoding speed.
185 br->val_ |= (vp8l_val_t)*(const uint32_t*)(br->buf_ + br->pos_) <<
186 (VP8L_LBITS - VP8L_WBITS);
187 br->pos_ += VP8L_LOG8_WBITS;
188 return;
189 }
190 #endif
191 ShiftBytes(br); // Slow path.
192 }
193
VP8LReadBits(VP8LBitReader * const br,int n_bits)194 uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
195 assert(n_bits >= 0);
196 // Flag an error if end_of_stream or n_bits is more than allowed limit.
197 if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) {
198 const uint32_t val =
199 (uint32_t)(br->val_ >> br->bit_pos_) & kBitMask[n_bits];
200 const int new_bits = br->bit_pos_ + n_bits;
201 br->bit_pos_ = new_bits;
202 ShiftBytes(br);
203 return val;
204 } else {
205 br->error_ = 1;
206 return 0;
207 }
208 }
209
210 //------------------------------------------------------------------------------
211