Update libwebp to 0.4.0

third_party/libwebp/utils/bit_reader.h

 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Boolean decoder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora (vikaas.arora@gmail.com)
 
 #ifndef WEBP_UTILS_BIT_READER_H_
 #define WEBP_UTILS_BIT_READER_H_
 
 #include <assert.h>
 #ifdef _MSC_VER
 #include <stdlib.h>  // _byteswap_ulong
 #endif
-#include <string.h>  // For memcpy
 #include "../webp/types.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
+#ifdef __cplusplus
 extern "C" {
 #endif
 
 // The Boolean decoder needs to maintain infinite precision on the value_ field.
 // However, since range_ is only 8bit, we only need an active window of 8 bits
 // for value_. Left bits (MSB) gets zeroed and shifted away when value_ falls
 // below 128, range_ is updated, and fresh bits read from the bitstream are
 // brought in as LSB.
 // To avoid reading the fresh bits one by one (slow), we cache a few of them
 // ahead (actually, we cache BITS of them ahead. See below). There's two
@@ skipping 12 matching lines @@
 //                                        ||
 // After calling VP8Shift(), where we need to shift away two zeros:
 //  [........vvvvvvvvBBBBBBBBBBB00000]LSB || [.............vvvvvvvvBBBBBBBBBBB]
 //                                        ||
 // Just before we need to call VP8LoadNewBytes(), the situation is:
 //  [........vvvvvv000000000000000000]LSB || [..........................vvvvvv]
 //                                        ||
 // And just after calling VP8LoadNewBytes():
 //  [........vvvvvvvvBBBBBBBBBBBBBBBB]LSB || [........vvvvvvvvBBBBBBBBBBBBBBBB]
 //
-// -> we're back to height active 'value_' bits (marked 'v') and BITS cached
+// -> we're back to eight active 'value_' bits (marked 'v') and BITS cached
 // bits (marked 'B')
 //
 // The right-justify strategy tends to use less shifts and is often faster.
 
 //------------------------------------------------------------------------------
 // BITS can be any multiple of 8 from 8 to 56 (inclusive).
 // Pick values that fit natural register size.
 
 #if !defined(WEBP_REFERENCE_IMPLEMENTATION)
 
@@ skipping 79 matching lines @@
 extern const range_t kVP8NewRange[128];
 
 void VP8LoadFinalBytes(VP8BitReader* const br);    // special case for the tail
 
 static WEBP_INLINE void VP8LoadNewBytes(VP8BitReader* const br) {
   assert(br != NULL && br->buf_ != NULL);
   // Read 'BITS' bits at a time if possible.
   if (br->buf_ + sizeof(lbit_t) <= br->buf_end_) {
     // convert memory type to register type (with some zero'ing!)
     bit_t bits;
-    lbit_t in_bits = *(lbit_t*)br->buf_;
+    const lbit_t in_bits = *(const lbit_t*)br->buf_;
     br->buf_ += (BITS) >> 3;
 #if !defined(__BIG_ENDIAN__)
 #if (BITS > 32)
 // gcc 4.3 has builtin functions for swap32/swap64
 #if defined(__GNUC__) && \
            (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
     bits = (bit_t)__builtin_bswap64(in_bits);
 #elif defined(_MSC_VER)
     bits = (bit_t)_byteswap_uint64(in_bits);
 #elif defined(__x86_64__)
     __asm__ volatile("bswapq %0" : "=r"(bits) : "0"(in_bits));
 #else  // generic code for swapping 64-bit values (suggested by bdb@)
     bits = (bit_t)in_bits;
     bits = ((bits & 0xffffffff00000000ull) >> 32) |
            ((bits & 0x00000000ffffffffull) << 32);
     bits = ((bits & 0xffff0000ffff0000ull) >> 16) |
            ((bits & 0x0000ffff0000ffffull) << 16);
     bits = ((bits & 0xff00ff00ff00ff00ull) >> 8) |
            ((bits & 0x00ff00ff00ff00ffull) << 8);
 #endif
     bits >>= 64 - BITS;
 #elif (BITS >= 24)
 #if defined(__i386__) || defined(__x86_64__)
-    __asm__ volatile("bswap %k0" : "=r"(in_bits) : "0"(in_bits));
-    bits = (bit_t)in_bits;   // 24b/32b -> 32b/64b zero-extension
+    {
+      lbit_t swapped_in_bits;
+      __asm__ volatile("bswap %k0" : "=r"(swapped_in_bits) : "0"(in_bits));
+      bits = (bit_t)swapped_in_bits;   // 24b/32b -> 32b/64b zero-extension
+    }
 #elif defined(_MSC_VER)
     bits = (bit_t)_byteswap_ulong(in_bits);
 #else
     bits = (bit_t)(in_bits >> 24) | ((in_bits >> 8) & 0xff00)
          | ((in_bits << 8) & 0xff0000)  | (in_bits << 24);
 #endif  // x86
     bits >>= (32 - BITS);
 #elif (BITS == 16)
     // gcc will recognize a 'rorw $8, ...' here:
     bits = (bit_t)(in_bits >> 8) | ((in_bits & 0xff) << 8);
@@ skipping 53 matching lines @@
   br->range_ = kVP8NewRange[idx];
   br->value_ <<= shift;
   br->bits_ -= shift;
 #else
   const int shift = kVP8Log2Range[br->range_];
   assert(br->range_ < (range_t)128);
   br->range_ = kVP8NewRange[br->range_];
   br->bits_ -= shift;
 #endif
 }
+
 static WEBP_INLINE int VP8GetBit(VP8BitReader* const br, int prob) {
 #ifndef USE_RIGHT_JUSTIFY
   // It's important to avoid generating a 64bit x 64bit multiply here.
   // We just need an 8b x 8b after all.
   const range_t split =
       (range_t)((uint32_t)(br->range_ >> (BITS)) * prob) << ((BITS) - 8);
   const int bit = VP8BitUpdate(br, split);
   if (br->range_ <= (((range_t)0x7e << (BITS)) | (MASK))) {
     VP8Shift(br);
   }
   return bit;
 #else
   const range_t split = (br->range_ * prob) >> 8;
   const int bit = VP8BitUpdate(br, split);
   if (br->range_ <= (range_t)0x7e) {
     VP8Shift(br);
   }
   return bit;
 #endif
 }
 
 static WEBP_INLINE int VP8GetSigned(VP8BitReader* const br, int v) {
   const range_t split = (br->range_ >> 1);
   const int bit = VP8BitUpdate(br, split);
   VP8Shift(br);
   return bit ? -v : v;
 }
 
-
 // -----------------------------------------------------------------------------
 // Bitreader for lossless format
 
 typedef uint64_t vp8l_val_t;  // right now, this bit-reader can only use 64bit.
 
 typedef struct {
   vp8l_val_t     val_;        // pre-fetched bits
   const uint8_t* buf_;        // input byte buffer
   size_t         len_;        // buffer length
   size_t         pos_;        // byte position in buf_
@@ skipping 13 matching lines @@
 // Reads the specified number of bits from Read Buffer.
 // Flags an error in case end_of_stream or n_bits is more than allowed limit.
 // Flags eos if this read attempt is going to cross the read buffer.
 uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits);
 
 // Return the prefetched bits, so they can be looked up.
 static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
   return (uint32_t)(br->val_ >> br->bit_pos_);
 }
 
-// Discard 'num_bits' bits from the cache.
-static WEBP_INLINE void VP8LDiscardBits(VP8LBitReader* const br, int num_bits) {
-  br->bit_pos_ += num_bits;
+// For jumping over a number of bits in the bit stream when accessed with
+// VP8LPrefetchBits and VP8LFillBitWindow.
+static WEBP_INLINE void VP8LSetBitPos(VP8LBitReader* const br, int val) {
+  br->bit_pos_ = val;
 }
 
-// Advances the Read buffer by 4 bytes to make room for reading next 32 bits.
+// Advances the read buffer by 4 bytes to make room for reading next 32 bits.
 void VP8LFillBitWindow(VP8LBitReader* const br);
 
-#if defined(__cplusplus) || defined(c_plusplus)
+#ifdef __cplusplus
 }    // extern "C"
 #endif
 
 #endif  /* WEBP_UTILS_BIT_READER_H_ */