Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 1 | // Copyright 2010 Google Inc. All Rights Reserved. |
| 2 | // |
Vikas Arora | 0406ce1 | 2013-08-09 15:57:12 -0700 | [diff] [blame] | 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. |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 8 | // ----------------------------------------------------------------------------- |
| 9 | // |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 10 | // Boolean decoder non-inlined methods |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 11 | // |
| 12 | // Author: Skal (pascal.massimino@gmail.com) |
| 13 | |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 14 | #ifdef HAVE_CONFIG_H |
| 15 | #include "webp/config.h" |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 16 | #endif |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 17 | |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 18 | #include "./bit_reader_inl.h" |
| 19 | |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 20 | //------------------------------------------------------------------------------ |
| 21 | // VP8BitReader |
| 22 | |
| 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); |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 28 | br->range_ = 255 - 1; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 29 | br->buf_ = start; |
| 30 | br->buf_end_ = end; |
| 31 | br->value_ = 0; |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 32 | br->bits_ = -8; // to load the very first 8bits |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 33 | br->eof_ = 0; |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 34 | VP8LoadNewBytes(br); |
| 35 | } |
| 36 | |
| 37 | void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) { |
| 38 | if (br->buf_ != NULL) { |
| 39 | br->buf_ += offset; |
| 40 | br->buf_end_ += offset; |
| 41 | } |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 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 | |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 56 | // range = ((range - 1) << kVP8Log2Range[range]) + 1 |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 57 | const range_t kVP8NewRange[128] = { |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 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 |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 74 | }; |
| 75 | |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 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_) { |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 80 | br->bits_ += 8; |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 81 | br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8); |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 82 | } else if (!br->eof_) { |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 83 | br->value_ <<= 8; |
| 84 | br->bits_ += 8; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 85 | br->eof_ = 1; |
| 86 | } |
| 87 | } |
| 88 | |
| 89 | //------------------------------------------------------------------------------ |
| 90 | // Higher-level calls |
| 91 | |
| 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 | |
| 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 | |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 108 | #define LBITS 64 // Number of bits prefetched. |
| 109 | #define WBITS 32 // Minimum number of bytes needed after VP8LFillBitWindow. |
| 110 | #define LOG8_WBITS 4 // Number of bytes needed to store WBITS bits. |
| 111 | |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 112 | #if !defined(WEBP_FORCE_ALIGNED) && \ |
| 113 | (defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || \ |
| 114 | defined(__i386__) || defined(_M_IX86) || \ |
| 115 | defined(__x86_64__) || defined(_M_X64)) |
| 116 | #define VP8L_USE_UNALIGNED_LOAD |
| 117 | #endif |
| 118 | |
| 119 | static const uint32_t kBitMask[VP8L_MAX_NUM_BIT_READ + 1] = { |
| 120 | 0, |
| 121 | 0x000001, 0x000003, 0x000007, 0x00000f, |
| 122 | 0x00001f, 0x00003f, 0x00007f, 0x0000ff, |
| 123 | 0x0001ff, 0x0003ff, 0x0007ff, 0x000fff, |
| 124 | 0x001fff, 0x003fff, 0x007fff, 0x00ffff, |
| 125 | 0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff, |
| 126 | 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 127 | }; |
| 128 | |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 129 | void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start, |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 130 | size_t length) { |
| 131 | size_t i; |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 132 | vp8l_val_t value = 0; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 133 | assert(br != NULL); |
| 134 | assert(start != NULL); |
| 135 | assert(length < 0xfffffff8u); // can't happen with a RIFF chunk. |
| 136 | |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 137 | br->len_ = length; |
| 138 | br->val_ = 0; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 139 | br->bit_pos_ = 0; |
| 140 | br->eos_ = 0; |
| 141 | br->error_ = 0; |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 142 | |
| 143 | if (length > sizeof(br->val_)) { |
| 144 | length = sizeof(br->val_); |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 145 | } |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 146 | for (i = 0; i < length; ++i) { |
| 147 | value |= (vp8l_val_t)start[i] << (8 * i); |
| 148 | } |
| 149 | br->val_ = value; |
| 150 | br->pos_ = length; |
| 151 | br->buf_ = start; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 152 | } |
| 153 | |
Urvang Joshi | 40d3274 | 2014-04-22 17:24:23 -0700 | [diff] [blame] | 154 | // Special version that assumes br->pos_ <= br_len_. |
| 155 | static int IsEndOfStreamSpecial(const VP8LBitReader* const br) { |
| 156 | assert(br->pos_ <= br->len_); |
| 157 | return br->pos_ == br->len_ && br->bit_pos_ >= LBITS; |
| 158 | } |
| 159 | |
| 160 | static int IsEndOfStream(const VP8LBitReader* const br) { |
| 161 | return (br->pos_ > br->len_) || IsEndOfStreamSpecial(br); |
| 162 | } |
| 163 | |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 164 | void VP8LBitReaderSetBuffer(VP8LBitReader* const br, |
| 165 | const uint8_t* const buf, size_t len) { |
| 166 | assert(br != NULL); |
| 167 | assert(buf != NULL); |
| 168 | assert(len < 0xfffffff8u); // can't happen with a RIFF chunk. |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 169 | br->buf_ = buf; |
| 170 | br->len_ = len; |
Urvang Joshi | 40d3274 | 2014-04-22 17:24:23 -0700 | [diff] [blame] | 171 | br->eos_ = IsEndOfStream(br); |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 172 | } |
| 173 | |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 174 | // If not at EOS, reload up to LBITS byte-by-byte |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 175 | static void ShiftBytes(VP8LBitReader* const br) { |
| 176 | while (br->bit_pos_ >= 8 && br->pos_ < br->len_) { |
| 177 | br->val_ >>= 8; |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 178 | br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (LBITS - 8); |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 179 | ++br->pos_; |
| 180 | br->bit_pos_ -= 8; |
| 181 | } |
| 182 | } |
| 183 | |
| 184 | void VP8LFillBitWindow(VP8LBitReader* const br) { |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 185 | if (br->bit_pos_ >= WBITS) { |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 186 | // TODO(jzern): given the fixed read size it may be possible to force |
| 187 | // alignment in this block. |
| 188 | #if defined(VP8L_USE_UNALIGNED_LOAD) |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 189 | if (br->pos_ + sizeof(br->val_) < br->len_) { |
| 190 | br->val_ >>= WBITS; |
| 191 | br->bit_pos_ -= WBITS; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 192 | // The expression below needs a little-endian arch to work correctly. |
| 193 | // This gives a large speedup for decoding speed. |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 194 | br->val_ |= (vp8l_val_t)*(const uint32_t*)(br->buf_ + br->pos_) << |
| 195 | (LBITS - WBITS); |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 196 | br->pos_ += LOG8_WBITS; |
| 197 | return; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 198 | } |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 199 | #endif |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 200 | ShiftBytes(br); // Slow path. |
Urvang Joshi | 40d3274 | 2014-04-22 17:24:23 -0700 | [diff] [blame] | 201 | br->eos_ = IsEndOfStreamSpecial(br); |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 202 | } |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) { |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 206 | assert(n_bits >= 0); |
| 207 | // Flag an error if end_of_stream or n_bits is more than allowed limit. |
Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 208 | if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) { |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 209 | const uint32_t val = |
| 210 | (uint32_t)(br->val_ >> br->bit_pos_) & kBitMask[n_bits]; |
| 211 | const int new_bits = br->bit_pos_ + n_bits; |
| 212 | br->bit_pos_ = new_bits; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 213 | // If this read is going to cross the read buffer, set the eos flag. |
Urvang Joshi | 40d3274 | 2014-04-22 17:24:23 -0700 | [diff] [blame] | 214 | br->eos_ = IsEndOfStreamSpecial(br); |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 215 | ShiftBytes(br); |
| 216 | return val; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 217 | } else { |
| 218 | br->error_ = 1; |
Vikas Arora | 1e7bf88 | 2013-03-13 16:43:18 -0700 | [diff] [blame] | 219 | return 0; |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 220 | } |
Vikas Arora | a241572 | 2012-08-09 16:18:58 -0700 | [diff] [blame] | 221 | } |
| 222 | |
| 223 | //------------------------------------------------------------------------------ |