src/third_party/libwebp/utils/bit_reader.c

   1 // Copyright 2010 Google Inc. All Rights Reserved.
   2 //
   3 // Use of this source code is governed by a BSD-style license
   4 // that can be found in the COPYING file in the root of the source
   5 // tree. An additional intellectual property rights grant can be found
   6 // in the file PATENTS. All contributing project authors may
   7 // be found in the AUTHORS file in the root of the source tree.
   8 // -----------------------------------------------------------------------------
   9 //
  10 // Boolean decoder non-inlined methods
  11 //
  12 // Author: Skal (pascal.massimino@gmail.com)
  13
  14 #ifdef HAVE_CONFIG_H
  15 #include "../webp/config.h"
  16 #endif
  17
  18 #include "./bit_reader_inl.h"
  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_   = 255 - 1;
  29   br->buf_     = start;
  30   br->buf_end_ = end;
  31   br->value_   = 0;
  32   br->bits_    = -8;   // to load the very first 8bits
  33   br->eof_     = 0;
  34   VP8LoadNewBytes(br);
  35 }
  36
  37 void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) {
  38   if (br->buf_ != NULL) {
  39     br->buf_ += offset;
  40     br->buf_end_ += offset;
  41   }
  42 }
  43
  44 const uint8_t kVP8Log2Range[128] = {
  45      7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
  46   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  47   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  48   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  49   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  50   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  51   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  52   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  53   0
  54 };
  55
  56 // range = ((range - 1) << kVP8Log2Range[range]) + 1
  57 const range_t kVP8NewRange[128] = {
  58   127, 127, 191, 127, 159, 191, 223, 127,
  59   143, 159, 175, 191, 207, 223, 239, 127,
  60   135, 143, 151, 159, 167, 175, 183, 191,
  61   199, 207, 215, 223, 231, 239, 247, 127,
  62   131, 135, 139, 143, 147, 151, 155, 159,
  63   163, 167, 171, 175, 179, 183, 187, 191,
  64   195, 199, 203, 207, 211, 215, 219, 223,
  65   227, 231, 235, 239, 243, 247, 251, 127,
  66   129, 131, 133, 135, 137, 139, 141, 143,
  67   145, 147, 149, 151, 153, 155, 157, 159,
  68   161, 163, 165, 167, 169, 171, 173, 175,
  69   177, 179, 181, 183, 185, 187, 189, 191,
  70   193, 195, 197, 199, 201, 203, 205, 207,
  71   209, 211, 213, 215, 217, 219, 221, 223,
  72   225, 227, 229, 231, 233, 235, 237, 239,
  73   241, 243, 245, 247, 249, 251, 253, 127
  74 };
  75
  76 void VP8LoadFinalBytes(VP8BitReader* const br) {
  77   assert(br != NULL && br->buf_ != NULL);
  78   // Only read 8bits at a time
  79   if (br->buf_ < br->buf_end_) {
  80     br->bits_ += 8;
  81     br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8);
  82   } else if (!br->eof_) {
  83     br->value_ <<= 8;
  84     br->bits_ += 8;
  85     br->eof_ = 1;
  86   }
  87 }
  88
  89 //------------------------------------------------------------------------------
  90 // Higher-level calls
  91
  92 uint32_t VP8GetValue(VP8BitReader* const br, int bits) {
  93   uint32_t v = 0;
  94   while (bits-- > 0) {
  95     v |= VP8GetBit(br, 0x80) << bits;
  96   }
  97   return v;
  98 }
  99
 100 int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) {
 101   const int value = VP8GetValue(br, bits);
 102   return VP8Get(br) ? -value : value;
 103 }
 104
 105 //------------------------------------------------------------------------------
 106 // VP8LBitReader
 107
 108 #define VP8L_LOG8_WBITS 4  // Number of bytes needed to store VP8L_WBITS bits.
 109
 110 #if !defined(WEBP_FORCE_ALIGNED) && \
 111     (defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || \
 112      defined(__i386__) || defined(_M_IX86) || \
 113      defined(__x86_64__) || defined(_M_X64))
 114 #define VP8L_USE_UNALIGNED_LOAD
 115 #endif
 116
 117 static const uint32_t kBitMask[VP8L_MAX_NUM_BIT_READ + 1] = {
 118   0,
 119   0x000001, 0x000003, 0x000007, 0x00000f,
 120   0x00001f, 0x00003f, 0x00007f, 0x0000ff,
 121   0x0001ff, 0x0003ff, 0x0007ff, 0x000fff,
 122   0x001fff, 0x003fff, 0x007fff, 0x00ffff,
 123   0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff,
 124   0x1fffff, 0x3fffff, 0x7fffff, 0xffffff
 125 };
 126
 127 void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start,
 128                        size_t length) {
 129   size_t i;
 130   vp8l_val_t value = 0;
 131   assert(br != NULL);
 132   assert(start != NULL);
 133   assert(length < 0xfffffff8u);   // can't happen with a RIFF chunk.
 134
 135   br->len_ = length;
 136   br->val_ = 0;
 137   br->bit_pos_ = 0;
 138   br->eos_ = 0;
 139   br->error_ = 0;
 140
 141   if (length > sizeof(br->val_)) {
 142     length = sizeof(br->val_);
 143   }
 144   for (i = 0; i < length; ++i) {
 145     value |= (vp8l_val_t)start[i] << (8 * i);
 146   }
 147   br->val_ = value;
 148   br->pos_ = length;
 149   br->buf_ = start;
 150 }
 151
 152 void VP8LBitReaderSetBuffer(VP8LBitReader* const br,
 153                             const uint8_t* const buf, size_t len) {
 154   assert(br != NULL);
 155   assert(buf != NULL);
 156   assert(len < 0xfffffff8u);   // can't happen with a RIFF chunk.
 157   br->buf_ = buf;
 158   br->len_ = len;
 159   // pos_ > len_ should be considered a param error.
 160   br->error_ = (br->pos_ > br->len_);
 161   br->eos_ = br->error_ || VP8LIsEndOfStream(br);
 162 }
 163
 164 // If not at EOS, reload up to VP8L_LBITS byte-by-byte
 165 static void ShiftBytes(VP8LBitReader* const br) {
 166   while (br->bit_pos_ >= 8 && br->pos_ < br->len_) {
 167     br->val_ >>= 8;
 168     br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (VP8L_LBITS - 8);
 169     ++br->pos_;
 170     br->bit_pos_ -= 8;
 171   }
 172   br->eos_ = VP8LIsEndOfStream(br);
 173 }
 174
 175 void VP8LDoFillBitWindow(VP8LBitReader* const br) {
 176   assert(br->bit_pos_ >= VP8L_WBITS);
 177   // TODO(jzern): given the fixed read size it may be possible to force
 178   //              alignment in this block.
 179 #if defined(VP8L_USE_UNALIGNED_LOAD)
 180   if (br->pos_ + sizeof(br->val_) < br->len_) {
 181     br->val_ >>= VP8L_WBITS;
 182     br->bit_pos_ -= VP8L_WBITS;
 183     // The expression below needs a little-endian arch to work correctly.
 184     // This gives a large speedup for decoding speed.
 185     br->val_ |= (vp8l_val_t)*(const uint32_t*)(br->buf_ + br->pos_) <<
 186                 (VP8L_LBITS - VP8L_WBITS);
 187     br->pos_ += VP8L_LOG8_WBITS;
 188     return;
 189   }
 190 #endif
 191   ShiftBytes(br);       // Slow path.
 192 }
 193
 194 uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
 195   assert(n_bits >= 0);
 196   // Flag an error if end_of_stream or n_bits is more than allowed limit.
 197   if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) {
 198     const uint32_t val =
 199         (uint32_t)(br->val_ >> br->bit_pos_) & kBitMask[n_bits];
 200     const int new_bits = br->bit_pos_ + n_bits;
 201     br->bit_pos_ = new_bits;
 202     ShiftBytes(br);
 203     return val;
 204   } else {
 205     br->error_ = 1;
 206     return 0;
 207   }
 208 }
 209
 210 //------------------------------------------------------------------------------