• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "src/webp/config.h"
16 #endif
17 
18 #include "src/utils/bit_reader_inl_utils.h"
19 #include "src/utils/utils.h"
20 
21 //------------------------------------------------------------------------------
22 // VP8BitReader
23 
VP8BitReaderSetBuffer(VP8BitReader * const br,const uint8_t * const start,size_t size)24 void VP8BitReaderSetBuffer(VP8BitReader* const br,
25                            const uint8_t* const start,
26                            size_t size) {
27   br->buf_     = start;
28   br->buf_end_ = start + size;
29   br->buf_max_ =
30       (size >= sizeof(lbit_t)) ? start + size - sizeof(lbit_t) + 1
31                                : start;
32 }
33 
VP8InitBitReader(VP8BitReader * const br,const uint8_t * const start,size_t size)34 void VP8InitBitReader(VP8BitReader* const br,
35                       const uint8_t* const start, size_t size) {
36   assert(br != NULL);
37   assert(start != NULL);
38   assert(size < (1u << 31));   // limit ensured by format and upstream checks
39   br->range_   = 255 - 1;
40   br->value_   = 0;
41   br->bits_    = -8;   // to load the very first 8bits
42   br->eof_     = 0;
43   VP8BitReaderSetBuffer(br, start, size);
44   VP8LoadNewBytes(br);
45 }
46 
VP8RemapBitReader(VP8BitReader * const br,ptrdiff_t offset)47 void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) {
48   if (br->buf_ != NULL) {
49     br->buf_ += offset;
50     br->buf_end_ += offset;
51     br->buf_max_ += offset;
52   }
53 }
54 
55 const uint8_t kVP8Log2Range[128] = {
56      7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
57   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
58   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
59   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
60   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
61   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
62   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
63   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
64   0
65 };
66 
67 // range = ((range - 1) << kVP8Log2Range[range]) + 1
68 const uint8_t kVP8NewRange[128] = {
69   127, 127, 191, 127, 159, 191, 223, 127,
70   143, 159, 175, 191, 207, 223, 239, 127,
71   135, 143, 151, 159, 167, 175, 183, 191,
72   199, 207, 215, 223, 231, 239, 247, 127,
73   131, 135, 139, 143, 147, 151, 155, 159,
74   163, 167, 171, 175, 179, 183, 187, 191,
75   195, 199, 203, 207, 211, 215, 219, 223,
76   227, 231, 235, 239, 243, 247, 251, 127,
77   129, 131, 133, 135, 137, 139, 141, 143,
78   145, 147, 149, 151, 153, 155, 157, 159,
79   161, 163, 165, 167, 169, 171, 173, 175,
80   177, 179, 181, 183, 185, 187, 189, 191,
81   193, 195, 197, 199, 201, 203, 205, 207,
82   209, 211, 213, 215, 217, 219, 221, 223,
83   225, 227, 229, 231, 233, 235, 237, 239,
84   241, 243, 245, 247, 249, 251, 253, 127
85 };
86 
VP8LoadFinalBytes(VP8BitReader * const br)87 void VP8LoadFinalBytes(VP8BitReader* const br) {
88   assert(br != NULL && br->buf_ != NULL);
89   // Only read 8bits at a time
90   if (br->buf_ < br->buf_end_) {
91     br->bits_ += 8;
92     br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8);
93   } else if (!br->eof_) {
94     br->value_ <<= 8;
95     br->bits_ += 8;
96     br->eof_ = 1;
97   } else {
98     br->bits_ = 0;  // This is to avoid undefined behaviour with shifts.
99   }
100 }
101 
102 //------------------------------------------------------------------------------
103 // Higher-level calls
104 
VP8GetValue(VP8BitReader * const br,int bits)105 uint32_t VP8GetValue(VP8BitReader* const br, int bits) {
106   uint32_t v = 0;
107   while (bits-- > 0) {
108     v |= VP8GetBit(br, 0x80) << bits;
109   }
110   return v;
111 }
112 
VP8GetSignedValue(VP8BitReader * const br,int bits)113 int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) {
114   const int value = VP8GetValue(br, bits);
115   return VP8Get(br) ? -value : value;
116 }
117 
118 //------------------------------------------------------------------------------
119 // VP8LBitReader
120 
121 #define VP8L_LOG8_WBITS 4  // Number of bytes needed to store VP8L_WBITS bits.
122 
123 #if defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || \
124     defined(__i386__) || defined(_M_IX86) || \
125     defined(__x86_64__) || defined(_M_X64)
126 #define VP8L_USE_FAST_LOAD
127 #endif
128 
129 static const uint32_t kBitMask[VP8L_MAX_NUM_BIT_READ + 1] = {
130   0,
131   0x000001, 0x000003, 0x000007, 0x00000f,
132   0x00001f, 0x00003f, 0x00007f, 0x0000ff,
133   0x0001ff, 0x0003ff, 0x0007ff, 0x000fff,
134   0x001fff, 0x003fff, 0x007fff, 0x00ffff,
135   0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff,
136   0x1fffff, 0x3fffff, 0x7fffff, 0xffffff
137 };
138 
VP8LInitBitReader(VP8LBitReader * const br,const uint8_t * const start,size_t length)139 void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start,
140                        size_t length) {
141   size_t i;
142   vp8l_val_t value = 0;
143   assert(br != NULL);
144   assert(start != NULL);
145   assert(length < 0xfffffff8u);   // can't happen with a RIFF chunk.
146 
147   br->len_ = length;
148   br->val_ = 0;
149   br->bit_pos_ = 0;
150   br->eos_ = 0;
151 
152   if (length > sizeof(br->val_)) {
153     length = sizeof(br->val_);
154   }
155   for (i = 0; i < length; ++i) {
156     value |= (vp8l_val_t)start[i] << (8 * i);
157   }
158   br->val_ = value;
159   br->pos_ = length;
160   br->buf_ = start;
161 }
162 
VP8LBitReaderSetBuffer(VP8LBitReader * const br,const uint8_t * const buf,size_t len)163 void VP8LBitReaderSetBuffer(VP8LBitReader* const br,
164                             const uint8_t* const buf, size_t len) {
165   assert(br != NULL);
166   assert(buf != NULL);
167   assert(len < 0xfffffff8u);   // can't happen with a RIFF chunk.
168   br->buf_ = buf;
169   br->len_ = len;
170   // pos_ > len_ should be considered a param error.
171   br->eos_ = (br->pos_ > br->len_) || VP8LIsEndOfStream(br);
172 }
173 
VP8LSetEndOfStream(VP8LBitReader * const br)174 static void VP8LSetEndOfStream(VP8LBitReader* const br) {
175   br->eos_ = 1;
176   br->bit_pos_ = 0;  // To avoid undefined behaviour with shifts.
177 }
178 
179 // If not at EOS, reload up to VP8L_LBITS byte-by-byte
ShiftBytes(VP8LBitReader * const br)180 static void ShiftBytes(VP8LBitReader* const br) {
181   while (br->bit_pos_ >= 8 && br->pos_ < br->len_) {
182     br->val_ >>= 8;
183     br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (VP8L_LBITS - 8);
184     ++br->pos_;
185     br->bit_pos_ -= 8;
186   }
187   if (VP8LIsEndOfStream(br)) {
188     VP8LSetEndOfStream(br);
189   }
190 }
191 
VP8LDoFillBitWindow(VP8LBitReader * const br)192 void VP8LDoFillBitWindow(VP8LBitReader* const br) {
193   assert(br->bit_pos_ >= VP8L_WBITS);
194 #if defined(VP8L_USE_FAST_LOAD)
195   if (br->pos_ + sizeof(br->val_) < br->len_) {
196     br->val_ >>= VP8L_WBITS;
197     br->bit_pos_ -= VP8L_WBITS;
198     br->val_ |= (vp8l_val_t)HToLE32(WebPMemToUint32(br->buf_ + br->pos_)) <<
199                 (VP8L_LBITS - VP8L_WBITS);
200     br->pos_ += VP8L_LOG8_WBITS;
201     return;
202   }
203 #endif
204   ShiftBytes(br);       // Slow path.
205 }
206 
VP8LReadBits(VP8LBitReader * const br,int n_bits)207 uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
208   assert(n_bits >= 0);
209   // Flag an error if end_of_stream or n_bits is more than allowed limit.
210   if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) {
211     const uint32_t val = VP8LPrefetchBits(br) & kBitMask[n_bits];
212     const int new_bits = br->bit_pos_ + n_bits;
213     br->bit_pos_ = new_bits;
214     ShiftBytes(br);
215     return val;
216   } else {
217     VP8LSetEndOfStream(br);
218     return 0;
219   }
220 }
221 
222 //------------------------------------------------------------------------------
223