1 /* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef VPX_DSP_BITREADER_H_ 12 #define VPX_DSP_BITREADER_H_ 13 14 #include <stddef.h> 15 #include <limits.h> 16 17 #include "./vpx_config.h" 18 #include "vpx_ports/mem.h" 19 #include "vpx/vp8dx.h" 20 #include "vpx/vpx_integer.h" 21 #include "vpx_dsp/prob.h" 22 23 #ifdef __cplusplus 24 extern "C" { 25 #endif 26 27 typedef size_t BD_VALUE; 28 29 #define BD_VALUE_SIZE ((int)sizeof(BD_VALUE) * CHAR_BIT) 30 31 // This is meant to be a large, positive constant that can still be efficiently 32 // loaded as an immediate (on platforms like ARM, for example). 33 // Even relatively modest values like 100 would work fine. 34 #define LOTS_OF_BITS 0x40000000 35 36 typedef struct { 37 // Be careful when reordering this struct, it may impact the cache negatively. 38 BD_VALUE value; 39 unsigned int range; 40 int count; 41 const uint8_t *buffer_end; 42 const uint8_t *buffer; 43 vpx_decrypt_cb decrypt_cb; 44 void *decrypt_state; 45 uint8_t clear_buffer[sizeof(BD_VALUE) + 1]; 46 } vpx_reader; 47 48 int vpx_reader_init(vpx_reader *r, 49 const uint8_t *buffer, 50 size_t size, 51 vpx_decrypt_cb decrypt_cb, 52 void *decrypt_state); 53 54 void vpx_reader_fill(vpx_reader *r); 55 56 const uint8_t *vpx_reader_find_end(vpx_reader *r); 57 58 static INLINE int vpx_reader_has_error(vpx_reader *r) { 59 // Check if we have reached the end of the buffer. 60 // 61 // Variable 'count' stores the number of bits in the 'value' buffer, minus 62 // 8. The top byte is part of the algorithm, and the remainder is buffered 63 // to be shifted into it. So if count == 8, the top 16 bits of 'value' are 64 // occupied, 8 for the algorithm and 8 in the buffer. 65 // 66 // When reading a byte from the user's buffer, count is filled with 8 and 67 // one byte is filled into the value buffer. When we reach the end of the 68 // data, count is additionally filled with LOTS_OF_BITS. So when 69 // count == LOTS_OF_BITS - 1, the user's data has been exhausted. 70 // 71 // 1 if we have tried to decode bits after the end of stream was encountered. 72 // 0 No error. 73 return r->count > BD_VALUE_SIZE && r->count < LOTS_OF_BITS; 74 } 75 76 static INLINE int vpx_read(vpx_reader *r, int prob) { 77 unsigned int bit = 0; 78 BD_VALUE value; 79 BD_VALUE bigsplit; 80 int count; 81 unsigned int range; 82 unsigned int split = (r->range * prob + (256 - prob)) >> CHAR_BIT; 83 84 if (r->count < 0) 85 vpx_reader_fill(r); 86 87 value = r->value; 88 count = r->count; 89 90 bigsplit = (BD_VALUE)split << (BD_VALUE_SIZE - CHAR_BIT); 91 92 range = split; 93 94 if (value >= bigsplit) { 95 range = r->range - split; 96 value = value - bigsplit; 97 bit = 1; 98 } 99 100 { 101 register unsigned int shift = vpx_norm[range]; 102 range <<= shift; 103 value <<= shift; 104 count -= shift; 105 } 106 r->value = value; 107 r->count = count; 108 r->range = range; 109 110 return bit; 111 } 112 113 static INLINE int vpx_read_bit(vpx_reader *r) { 114 return vpx_read(r, 128); // vpx_prob_half 115 } 116 117 static INLINE int vpx_read_literal(vpx_reader *r, int bits) { 118 int literal = 0, bit; 119 120 for (bit = bits - 1; bit >= 0; bit--) 121 literal |= vpx_read_bit(r) << bit; 122 123 return literal; 124 } 125 126 static INLINE int vpx_read_tree(vpx_reader *r, const vpx_tree_index *tree, 127 const vpx_prob *probs) { 128 vpx_tree_index i = 0; 129 130 while ((i = tree[i + vpx_read(r, probs[i >> 1])]) > 0) 131 continue; 132 133 return -i; 134 } 135 136 #ifdef __cplusplus 137 } // extern "C" 138 #endif 139 140 #endif // VPX_DSP_BITREADER_H_ 141
