OLD | NEW |
1 // Copyright 2010 Google Inc. | 1 // Copyright 2010 Google Inc. All Rights Reserved. |
2 // | 2 // |
3 // This code is licensed under the same terms as WebM: | 3 // This code is licensed under the same terms as WebM: |
4 // Software License Agreement: http://www.webmproject.org/license/software/ | 4 // Software License Agreement: http://www.webmproject.org/license/software/ |
5 // Additional IP Rights Grant: http://www.webmproject.org/license/additional/ | 5 // Additional IP Rights Grant: http://www.webmproject.org/license/additional/ |
6 // ----------------------------------------------------------------------------- | 6 // ----------------------------------------------------------------------------- |
7 // | 7 // |
8 // Boolean decoder | 8 // Boolean decoder |
9 // | 9 // |
10 // Author: Skal (pascal.massimino@gmail.com) | 10 // Author: Skal (pascal.massimino@gmail.com) |
11 | 11 |
12 #include "./bit_reader.h" | 12 #include "./bit_reader.h" |
13 | 13 |
14 #if defined(__cplusplus) || defined(c_plusplus) | 14 #if defined(__cplusplus) || defined(c_plusplus) |
15 extern "C" { | 15 extern "C" { |
16 #endif | 16 #endif |
17 | 17 |
| 18 #define MK(X) (((bit_t)(X) << (BITS)) | (MASK)) |
| 19 |
18 //------------------------------------------------------------------------------ | 20 //------------------------------------------------------------------------------ |
19 // VP8BitReader | 21 // VP8BitReader |
20 | 22 |
21 void VP8InitBitReader(VP8BitReader* const br, | 23 void VP8InitBitReader(VP8BitReader* const br, |
22 const uint8_t* const start, const uint8_t* const end) { | 24 const uint8_t* const start, const uint8_t* const end) { |
23 assert(br); | 25 assert(br != NULL); |
24 assert(start); | 26 assert(start != NULL); |
25 assert(start <= end); | 27 assert(start <= end); |
26 br->range_ = 255 - 1; | 28 br->range_ = MK(255 - 1); |
27 br->buf_ = start; | 29 br->buf_ = start; |
28 br->buf_end_ = end; | 30 br->buf_end_ = end; |
29 br->value_ = 0; | 31 br->value_ = 0; |
30 br->missing_ = 8; | 32 br->missing_ = 8; // to load the very first 8bits |
31 br->eof_ = 0; | 33 br->eof_ = 0; |
32 } | 34 } |
33 | 35 |
34 const uint8_t kVP8Log2Range[128] = { | 36 const uint8_t kVP8Log2Range[128] = { |
35 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, | 37 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, |
36 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, | 38 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
37 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 39 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
38 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, |
39 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | 41 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
40 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, |
41 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, |
42 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, |
43 0 | 45 0 |
44 }; | 46 }; |
45 | 47 |
46 // range = ((range + 1) << kVP8Log2Range[range]) - 1 | 48 // range = (range << kVP8Log2Range[range]) + trailing 1's |
47 const uint8_t kVP8NewRange[128] = { | 49 const bit_t kVP8NewRange[128] = { |
48 127, 127, 191, 127, 159, 191, 223, 127, 143, 159, 175, 191, 207, 223, 239, | 50 MK(127), MK(127), MK(191), MK(127), MK(159), MK(191), MK(223), MK(127), |
49 127, 135, 143, 151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239, | 51 MK(143), MK(159), MK(175), MK(191), MK(207), MK(223), MK(239), MK(127), |
50 247, 127, 131, 135, 139, 143, 147, 151, 155, 159, 163, 167, 171, 175, 179, | 52 MK(135), MK(143), MK(151), MK(159), MK(167), MK(175), MK(183), MK(191), |
51 183, 187, 191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, | 53 MK(199), MK(207), MK(215), MK(223), MK(231), MK(239), MK(247), MK(127), |
52 243, 247, 251, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, | 54 MK(131), MK(135), MK(139), MK(143), MK(147), MK(151), MK(155), MK(159), |
53 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, | 55 MK(163), MK(167), MK(171), MK(175), MK(179), MK(183), MK(187), MK(191), |
54 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, | 56 MK(195), MK(199), MK(203), MK(207), MK(211), MK(215), MK(219), MK(223), |
55 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, | 57 MK(227), MK(231), MK(235), MK(239), MK(243), MK(247), MK(251), MK(127), |
56 241, 243, 245, 247, 249, 251, 253, 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) |
57 }; | 66 }; |
58 | 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 |
59 //------------------------------------------------------------------------------ | 81 //------------------------------------------------------------------------------ |
60 // Higher-level calls | 82 // Higher-level calls |
61 | 83 |
62 uint32_t VP8GetValue(VP8BitReader* const br, int bits) { | 84 uint32_t VP8GetValue(VP8BitReader* const br, int bits) { |
63 uint32_t v = 0; | 85 uint32_t v = 0; |
64 while (bits-- > 0) { | 86 while (bits-- > 0) { |
65 v |= VP8GetBit(br, 0x80) << bits; | 87 v |= VP8GetBit(br, 0x80) << bits; |
66 } | 88 } |
67 return v; | 89 return v; |
68 } | 90 } |
69 | 91 |
70 int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) { | 92 int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) { |
71 const int value = VP8GetValue(br, bits); | 93 const int value = VP8GetValue(br, bits); |
72 return VP8Get(br) ? -value : value; | 94 return VP8Get(br) ? -value : value; |
73 } | 95 } |
74 | 96 |
75 //------------------------------------------------------------------------------ | 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 //------------------------------------------------------------------------------ |
76 | 226 |
77 #if defined(__cplusplus) || defined(c_plusplus) | 227 #if defined(__cplusplus) || defined(c_plusplus) |
78 } // extern "C" | 228 } // extern "C" |
79 #endif | 229 #endif |
OLD | NEW |