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 (at) 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 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 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 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 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 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 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 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 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 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 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
