vpx_dsp/bitreader.h

   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 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_