1 // Copyright 2010 Google Inc. All Rights Reserved. 2 // 3 // This code is licensed under the same terms as WebM: 4 // Software License Agreement: http://www.webmproject.org/license/software/ 5 // Additional IP Rights Grant: http://www.webmproject.org/license/additional/ 6 // ----------------------------------------------------------------------------- 7 // 8 // Boolean decoder 9 // 10 // Author: Skal (pascal.massimino (at) gmail.com) 11 12 #include "./bit_reader.h" 13 14 #if defined(__cplusplus) || defined(c_plusplus) 15 extern "C" { 16 #endif 17 18 #define MK(X) (((bit_t)(X) << (BITS)) | (MASK)) 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_ = MK(255 - 1); 29 br->buf_ = start; 30 br->buf_end_ = end; 31 br->value_ = 0; 32 br->missing_ = 8; // to load the very first 8bits 33 br->eof_ = 0; 34 } 35 36 const uint8_t kVP8Log2Range[128] = { 37 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 38 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 39 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 40 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 41 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 42 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 43 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 44 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 45 0 46 }; 47 48 // range = (range << kVP8Log2Range[range]) + trailing 1's 49 const bit_t kVP8NewRange[128] = { 50 MK(127), MK(127), MK(191), MK(127), MK(159), MK(191), MK(223), MK(127), 51 MK(143), MK(159), MK(175), MK(191), MK(207), MK(223), MK(239), MK(127), 52 MK(135), MK(143), MK(151), MK(159), MK(167), MK(175), MK(183), MK(191), 53 MK(199), MK(207), MK(215), MK(223), MK(231), MK(239), MK(247), MK(127), 54 MK(131), MK(135), MK(139), MK(143), MK(147), MK(151), MK(155), MK(159), 55 MK(163), MK(167), MK(171), MK(175), MK(179), MK(183), MK(187), MK(191), 56 MK(195), MK(199), MK(203), MK(207), MK(211), MK(215), MK(219), MK(223), 57 MK(227), MK(231), MK(235), MK(239), MK(243), MK(247), MK(251), MK(127), 58 MK(129), MK(131), MK(133), MK(135), MK(137), MK(139), MK(141), MK(143), 59 MK(145), MK(147), MK(149), MK(151), MK(153), MK(155), MK(157), MK(159), 60 MK(161), MK(163), MK(165), MK(167), MK(169), MK(171), MK(173), MK(175), 61 MK(177), MK(179), MK(181), MK(183), MK(185), MK(187), MK(189), MK(191), 62 MK(193), MK(195), MK(197), MK(199), MK(201), MK(203), MK(205), MK(207), 63 MK(209), MK(211), MK(213), MK(215), MK(217), MK(219), MK(221), MK(223), 64 MK(225), MK(227), MK(229), MK(231), MK(233), MK(235), MK(237), MK(239), 65 MK(241), MK(243), MK(245), MK(247), MK(249), MK(251), MK(253), MK(127) 66 }; 67 68 #undef MK 69 70 void VP8LoadFinalBytes(VP8BitReader* const br) { 71 assert(br != NULL && br->buf_ != NULL); 72 // Only read 8bits at a time 73 if (br->buf_ < br->buf_end_) { 74 br->value_ |= (bit_t)(*br->buf_++) << ((BITS) - 8 + br->missing_); 75 br->missing_ -= 8; 76 } else { 77 br->eof_ = 1; 78 } 79 } 80 81 //------------------------------------------------------------------------------ 82 // Higher-level calls 83 84 uint32_t VP8GetValue(VP8BitReader* const br, int bits) { 85 uint32_t v = 0; 86 while (bits-- > 0) { 87 v |= VP8GetBit(br, 0x80) << bits; 88 } 89 return v; 90 } 91 92 int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) { 93 const int value = VP8GetValue(br, bits); 94 return VP8Get(br) ? -value : value; 95 } 96 97 //------------------------------------------------------------------------------ 98 // VP8LBitReader 99 100 #define MAX_NUM_BIT_READ 25 101 102 static const uint32_t kBitMask[MAX_NUM_BIT_READ] = { 103 0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 104 65535, 131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215 105 }; 106 107 void VP8LInitBitReader(VP8LBitReader* const br, 108 const uint8_t* const start, 109 size_t length) { 110 size_t i; 111 assert(br != NULL); 112 assert(start != NULL); 113 assert(length < 0xfffffff8u); // can't happen with a RIFF chunk. 114 115 br->buf_ = start; 116 br->len_ = length; 117 br->val_ = 0; 118 br->pos_ = 0; 119 br->bit_pos_ = 0; 120 br->eos_ = 0; 121 br->error_ = 0; 122 for (i = 0; i < sizeof(br->val_) && i < br->len_; ++i) { 123 br->val_ |= ((uint64_t)br->buf_[br->pos_]) << (8 * i); 124 ++br->pos_; 125 } 126 } 127 128 void VP8LBitReaderSetBuffer(VP8LBitReader* const br, 129 const uint8_t* const buf, size_t len) { 130 assert(br != NULL); 131 assert(buf != NULL); 132 assert(len < 0xfffffff8u); // can't happen with a RIFF chunk. 133 br->eos_ = (br->pos_ >= len); 134 br->buf_ = buf; 135 br->len_ = len; 136 } 137 138 static void ShiftBytes(VP8LBitReader* const br) { 139 while (br->bit_pos_ >= 8 && br->pos_ < br->len_) { 140 br->val_ >>= 8; 141 br->val_ |= ((uint64_t)br->buf_[br->pos_]) << 56; 142 ++br->pos_; 143 br->bit_pos_ -= 8; 144 } 145 } 146 147 void VP8LFillBitWindow(VP8LBitReader* const br) { 148 if (br->bit_pos_ >= 32) { 149 #if defined(__x86_64__) || defined(_M_X64) 150 if (br->pos_ + 8 < br->len_) { 151 br->val_ >>= 32; 152 // The expression below needs a little-endian arch to work correctly. 153 // This gives a large speedup for decoding speed. 154 br->val_ |= *(const uint64_t *)(br->buf_ + br->pos_) << 32; 155 br->pos_ += 4; 156 br->bit_pos_ -= 32; 157 } else { 158 // Slow path. 159 ShiftBytes(br); 160 } 161 #else 162 // Always the slow path. 163 ShiftBytes(br); 164 #endif 165 } 166 if (br->pos_ == br->len_ && br->bit_pos_ == 64) { 167 br->eos_ = 1; 168 } 169 } 170 171 uint32_t VP8LReadOneBit(VP8LBitReader* const br) { 172 const uint32_t val = (br->val_ >> br->bit_pos_) & 1; 173 // Flag an error at end_of_stream. 174 if (!br->eos_) { 175 ++br->bit_pos_; 176 if (br->bit_pos_ >= 32) { 177 ShiftBytes(br); 178 } 179 // After this last bit is read, check if eos needs to be flagged. 180 if (br->pos_ == br->len_ && br->bit_pos_ == 64) { 181 br->eos_ = 1; 182 } 183 } else { 184 br->error_ = 1; 185 } 186 return val; 187 } 188 189 uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) { 190 uint32_t val = 0; 191 assert(n_bits >= 0); 192 // Flag an error if end_of_stream or n_bits is more than allowed limit. 193 if (!br->eos_ && n_bits < MAX_NUM_BIT_READ) { 194 // If this read is going to cross the read buffer, set the eos flag. 195 if (br->pos_ == br->len_) { 196 if ((br->bit_pos_ + n_bits) >= 64) { 197 br->eos_ = 1; 198 if ((br->bit_pos_ + n_bits) > 64) return val; 199 } 200 } 201 val = (br->val_ >> br->bit_pos_) & kBitMask[n_bits]; 202 br->bit_pos_ += n_bits; 203 if (br->bit_pos_ >= 40) { 204 if (br->pos_ + 5 < br->len_) { 205 br->val_ >>= 40; 206 br->val_ |= 207 (((uint64_t)br->buf_[br->pos_ + 0]) << 24) | 208 (((uint64_t)br->buf_[br->pos_ + 1]) << 32) | 209 (((uint64_t)br->buf_[br->pos_ + 2]) << 40) | 210 (((uint64_t)br->buf_[br->pos_ + 3]) << 48) | 211 (((uint64_t)br->buf_[br->pos_ + 4]) << 56); 212 br->pos_ += 5; 213 br->bit_pos_ -= 40; 214 } 215 if (br->bit_pos_ >= 8) { 216 ShiftBytes(br); 217 } 218 } 219 } else { 220 br->error_ = 1; 221 } 222 return val; 223 } 224 225 //------------------------------------------------------------------------------ 226 227 #if defined(__cplusplus) || defined(c_plusplus) 228 } // extern "C" 229 #endif 230
