The Tor Browser / file comparison
comparison: media/libvpx/vp8/decoder/dboolhuff.h
media/libvpx/vp8/decoder/dboolhuff.h
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:c8904eaee78f |
|---|---|
| 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 | |
| 12 #ifndef DBOOLHUFF_H_ | |
| 13 #define DBOOLHUFF_H_ | |
| 14 | |
| 15 #include <stddef.h> | |
| 16 #include <limits.h> | |
| 17 | |
| 18 #include "vpx_config.h" | |
| 19 #include "vpx_ports/mem.h" | |
| 20 #include "vpx/vpx_integer.h" | |
| 21 | |
| 22 typedef size_t VP8_BD_VALUE; | |
| 23 | |
| 24 #define VP8_BD_VALUE_SIZE ((int)sizeof(VP8_BD_VALUE)*CHAR_BIT) | |
| 25 | |
| 26 /*This is meant to be a large, positive constant that can still be efficiently | |
| 27 loaded as an immediate (on platforms like ARM, for example). | |
| 28 Even relatively modest values like 100 would work fine.*/ | |
| 29 #define VP8_LOTS_OF_BITS (0x40000000) | |
| 30 | |
| 31 /*Decrypt n bytes of data from input -> output, using the decrypt_state | |
| 32 passed in VP8D_SET_DECRYPTOR. | |
| 33 */ | |
| 34 typedef void (vp8_decrypt_cb)(void *decrypt_state, const unsigned char *input, | |
| 35 unsigned char *output, int count); | |
| 36 | |
| 37 typedef struct | |
| 38 { | |
| 39 const unsigned char *user_buffer_end; | |
| 40 const unsigned char *user_buffer; | |
| 41 VP8_BD_VALUE value; | |
| 42 int count; | |
| 43 unsigned int range; | |
| 44 vp8_decrypt_cb *decrypt_cb; | |
| 45 void *decrypt_state; | |
| 46 } BOOL_DECODER; | |
| 47 | |
| 48 DECLARE_ALIGNED(16, extern const unsigned char, vp8_norm[256]); | |
| 49 | |
| 50 int vp8dx_start_decode(BOOL_DECODER *br, | |
| 51 const unsigned char *source, | |
| 52 unsigned int source_sz, | |
| 53 vp8_decrypt_cb *decrypt_cb, | |
| 54 void *decrypt_state); | |
| 55 | |
| 56 void vp8dx_bool_decoder_fill(BOOL_DECODER *br); | |
| 57 | |
| 58 | |
| 59 static int vp8dx_decode_bool(BOOL_DECODER *br, int probability) { | |
| 60 unsigned int bit = 0; | |
| 61 VP8_BD_VALUE value; | |
| 62 unsigned int split; | |
| 63 VP8_BD_VALUE bigsplit; | |
| 64 int count; | |
| 65 unsigned int range; | |
| 66 | |
| 67 split = 1 + (((br->range - 1) * probability) >> 8); | |
| 68 | |
| 69 if(br->count < 0) | |
| 70 vp8dx_bool_decoder_fill(br); | |
| 71 | |
| 72 value = br->value; | |
| 73 count = br->count; | |
| 74 | |
| 75 bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); | |
| 76 | |
| 77 range = split; | |
| 78 | |
| 79 if (value >= bigsplit) | |
| 80 { | |
| 81 range = br->range - split; | |
| 82 value = value - bigsplit; | |
| 83 bit = 1; | |
| 84 } | |
| 85 | |
| 86 { | |
| 87 register unsigned int shift = vp8_norm[range]; | |
| 88 range <<= shift; | |
| 89 value <<= shift; | |
| 90 count -= shift; | |
| 91 } | |
| 92 br->value = value; | |
| 93 br->count = count; | |
| 94 br->range = range; | |
| 95 | |
| 96 return bit; | |
| 97 } | |
| 98 | |
| 99 static int vp8_decode_value(BOOL_DECODER *br, int bits) | |
| 100 { | |
| 101 int z = 0; | |
| 102 int bit; | |
| 103 | |
| 104 for (bit = bits - 1; bit >= 0; bit--) | |
| 105 { | |
| 106 z |= (vp8dx_decode_bool(br, 0x80) << bit); | |
| 107 } | |
| 108 | |
| 109 return z; | |
| 110 } | |
| 111 | |
| 112 static int vp8dx_bool_error(BOOL_DECODER *br) | |
| 113 { | |
| 114 /* Check if we have reached the end of the buffer. | |
| 115 * | |
| 116 * Variable 'count' stores the number of bits in the 'value' buffer, minus | |
| 117 * 8. The top byte is part of the algorithm, and the remainder is buffered | |
| 118 * to be shifted into it. So if count == 8, the top 16 bits of 'value' are | |
| 119 * occupied, 8 for the algorithm and 8 in the buffer. | |
| 120 * | |
| 121 * When reading a byte from the user's buffer, count is filled with 8 and | |
| 122 * one byte is filled into the value buffer. When we reach the end of the | |
| 123 * data, count is additionally filled with VP8_LOTS_OF_BITS. So when | |
| 124 * count == VP8_LOTS_OF_BITS - 1, the user's data has been exhausted. | |
| 125 */ | |
| 126 if ((br->count > VP8_BD_VALUE_SIZE) && (br->count < VP8_LOTS_OF_BITS)) | |
| 127 { | |
| 128 /* We have tried to decode bits after the end of | |
| 129 * stream was encountered. | |
| 130 */ | |
| 131 return 1; | |
| 132 } | |
| 133 | |
| 134 /* No error. */ | |
| 135 return 0; | |
| 136 } | |
| 137 | |
| 138 #endif // DBOOLHUFF_H_ |
