optimized imports

26 files changed, 0 insertions, 4156 deletions

diff --git a/src/main/jni/libwebp/utils/bit_reader.c b/src/main/jni/libwebp/utils/bit_reader.c
deleted file mode 100644
index 64503e6b9..000000000
--- a/src/main/jni/libwebp/utils/bit_reader.c
+++ /dev/null
@@ -1,210 +0,0 @@
-// 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 non-inlined methods
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#ifdef HAVE_CONFIG_H
-#include "../webp/config.h"
-#endif
-
-#include "./bit_reader_inl.h"
-
-//------------------------------------------------------------------------------
-// VP8BitReader
-
-void VP8InitBitReader(VP8BitReader* const br,
-                      const uint8_t* const start, const uint8_t* const end) {
-  assert(br != NULL);
-  assert(start != NULL);
-  assert(start <= end);
-  br->range_   = 255 - 1;
-  br->buf_     = start;
-  br->buf_end_ = end;
-  br->value_   = 0;
-  br->bits_    = -8;   // to load the very first 8bits
-  br->eof_     = 0;
-  VP8LoadNewBytes(br);
-}
-
-void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) {
-  if (br->buf_ != NULL) {
-    br->buf_ += offset;
-    br->buf_end_ += offset;
-  }
-}
-
-const uint8_t kVP8Log2Range[128] = {
-     7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  0
-};
-
-// range = ((range - 1) << kVP8Log2Range[range]) + 1
-const range_t kVP8NewRange[128] = {
-  127, 127, 191, 127, 159, 191, 223, 127,
-  143, 159, 175, 191, 207, 223, 239, 127,
-  135, 143, 151, 159, 167, 175, 183, 191,
-  199, 207, 215, 223, 231, 239, 247, 127,
-  131, 135, 139, 143, 147, 151, 155, 159,
-  163, 167, 171, 175, 179, 183, 187, 191,
-  195, 199, 203, 207, 211, 215, 219, 223,
-  227, 231, 235, 239, 243, 247, 251, 127,
-  129, 131, 133, 135, 137, 139, 141, 143,
-  145, 147, 149, 151, 153, 155, 157, 159,
-  161, 163, 165, 167, 169, 171, 173, 175,
-  177, 179, 181, 183, 185, 187, 189, 191,
-  193, 195, 197, 199, 201, 203, 205, 207,
-  209, 211, 213, 215, 217, 219, 221, 223,
-  225, 227, 229, 231, 233, 235, 237, 239,
-  241, 243, 245, 247, 249, 251, 253, 127
-};
-
-void VP8LoadFinalBytes(VP8BitReader* const br) {
-  assert(br != NULL && br->buf_ != NULL);
-  // Only read 8bits at a time
-  if (br->buf_ < br->buf_end_) {
-    br->bits_ += 8;
-    br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8);
-  } else if (!br->eof_) {
-    br->value_ <<= 8;
-    br->bits_ += 8;
-    br->eof_ = 1;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Higher-level calls
-
-uint32_t VP8GetValue(VP8BitReader* const br, int bits) {
-  uint32_t v = 0;
-  while (bits-- > 0) {
-    v |= VP8GetBit(br, 0x80) << bits;
-  }
-  return v;
-}
-
-int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) {
-  const int value = VP8GetValue(br, bits);
-  return VP8Get(br) ? -value : value;
-}
-
-//------------------------------------------------------------------------------
-// VP8LBitReader
-
-#define VP8L_LOG8_WBITS 4  // Number of bytes needed to store VP8L_WBITS bits.
-
-#if !defined(WEBP_FORCE_ALIGNED) && \
-    (defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || \
-     defined(__i386__) || defined(_M_IX86) || \
-     defined(__x86_64__) || defined(_M_X64))
-#define VP8L_USE_UNALIGNED_LOAD
-#endif
-
-static const uint32_t kBitMask[VP8L_MAX_NUM_BIT_READ + 1] = {
-  0,
-  0x000001, 0x000003, 0x000007, 0x00000f,
-  0x00001f, 0x00003f, 0x00007f, 0x0000ff,
-  0x0001ff, 0x0003ff, 0x0007ff, 0x000fff,
-  0x001fff, 0x003fff, 0x007fff, 0x00ffff,
-  0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff,
-  0x1fffff, 0x3fffff, 0x7fffff, 0xffffff
-};
-
-void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start,
-                       size_t length) {
-  size_t i;
-  vp8l_val_t value = 0;
-  assert(br != NULL);
-  assert(start != NULL);
-  assert(length < 0xfffffff8u);   // can't happen with a RIFF chunk.
-
-  br->len_ = length;
-  br->val_ = 0;
-  br->bit_pos_ = 0;
-  br->eos_ = 0;
-  br->error_ = 0;
-
-  if (length > sizeof(br->val_)) {
-    length = sizeof(br->val_);
-  }
-  for (i = 0; i < length; ++i) {
-    value |= (vp8l_val_t)start[i] << (8 * i);
-  }
-  br->val_ = value;
-  br->pos_ = length;
-  br->buf_ = start;
-}
-
-void VP8LBitReaderSetBuffer(VP8LBitReader* const br,
-                            const uint8_t* const buf, size_t len) {
-  assert(br != NULL);
-  assert(buf != NULL);
-  assert(len < 0xfffffff8u);   // can't happen with a RIFF chunk.
-  br->buf_ = buf;
-  br->len_ = len;
-  // pos_ > len_ should be considered a param error.
-  br->error_ = (br->pos_ > br->len_);
-  br->eos_ = br->error_ || VP8LIsEndOfStream(br);
-}
-
-// If not at EOS, reload up to VP8L_LBITS byte-by-byte
-static void ShiftBytes(VP8LBitReader* const br) {
-  while (br->bit_pos_ >= 8 && br->pos_ < br->len_) {
-    br->val_ >>= 8;
-    br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (VP8L_LBITS - 8);
-    ++br->pos_;
-    br->bit_pos_ -= 8;
-  }
-  br->eos_ = VP8LIsEndOfStream(br);
-}
-
-void VP8LDoFillBitWindow(VP8LBitReader* const br) {
-  assert(br->bit_pos_ >= VP8L_WBITS);
-  // TODO(jzern): given the fixed read size it may be possible to force
-  //              alignment in this block.
-#if defined(VP8L_USE_UNALIGNED_LOAD)
-  if (br->pos_ + sizeof(br->val_) < br->len_) {
-    br->val_ >>= VP8L_WBITS;
-    br->bit_pos_ -= VP8L_WBITS;
-    // The expression below needs a little-endian arch to work correctly.
-    // This gives a large speedup for decoding speed.
-    br->val_ |= (vp8l_val_t)*(const uint32_t*)(br->buf_ + br->pos_) <<
-                (VP8L_LBITS - VP8L_WBITS);
-    br->pos_ += VP8L_LOG8_WBITS;
-    return;
-  }
-#endif
-  ShiftBytes(br);       // Slow path.
-}
-
-uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
-  assert(n_bits >= 0);
-  // Flag an error if end_of_stream or n_bits is more than allowed limit.
-  if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) {
-    const uint32_t val =
-        (uint32_t)(br->val_ >> br->bit_pos_) & kBitMask[n_bits];
-    const int new_bits = br->bit_pos_ + n_bits;
-    br->bit_pos_ = new_bits;
-    ShiftBytes(br);
-    return val;
-  } else {
-    br->error_ = 1;
-    return 0;
-  }
-}
-
-//------------------------------------------------------------------------------
diff --git a/src/main/jni/libwebp/utils/bit_reader.h b/src/main/jni/libwebp/utils/bit_reader.h
deleted file mode 100644
index f569734f5..000000000
--- a/src/main/jni/libwebp/utils/bit_reader.h
+++ /dev/null
@@ -1,169 +0,0 @@
-// 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 "../webp/types.h"
-
-#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 BITS of them ahead. The total of (BITS + 8) bits must fit into a
-// natural register (with type bit_t). To fetch BITS bits from bitstream we
-// use a type lbit_t.
-//
-// BITS can be any multiple of 8 from 8 to 56 (inclusive).
-// Pick values that fit natural register size.
-
-#if defined(__i386__) || defined(_M_IX86)      // x86 32bit
-#define BITS 24
-#elif defined(__x86_64__) || defined(_M_X64)   // x86 64bit
-#define BITS 56
-#elif defined(__arm__) || defined(_M_ARM)      // ARM
-#define BITS 24
-#elif defined(__mips__)                        // MIPS
-#define BITS 24
-#else                                          // reasonable default
-#define BITS 24  // TODO(skal): test aarch64 and find the proper BITS value.
-#endif
-
-//------------------------------------------------------------------------------
-// Derived types and constants:
-//   bit_t = natural register type for storing 'value_' (which is BITS+8 bits)
-//   range_t = register for 'range_' (which is 8bits only)
-
-#if (BITS > 24)
-typedef uint64_t bit_t;
-#else
-typedef uint32_t bit_t;
-#endif
-
-typedef uint32_t range_t;
-
-//------------------------------------------------------------------------------
-// Bitreader
-
-typedef struct VP8BitReader VP8BitReader;
-struct VP8BitReader {
-  // boolean decoder  (keep the field ordering as is!)
-  bit_t value_;               // current value
-  range_t range_;             // current range minus 1. In [127, 254] interval.
-  int bits_;                  // number of valid bits left
-  // read buffer
-  const uint8_t* buf_;        // next byte to be read
-  const uint8_t* buf_end_;    // end of read buffer
-  int eof_;                   // true if input is exhausted
-};
-
-// Initialize the bit reader and the boolean decoder.
-void VP8InitBitReader(VP8BitReader* const br,
-                      const uint8_t* const start, const uint8_t* const end);
-
-// Update internal pointers to displace the byte buffer by the
-// relative offset 'offset'.
-void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset);
-
-// return the next value made of 'num_bits' bits
-uint32_t VP8GetValue(VP8BitReader* const br, int num_bits);
-static WEBP_INLINE uint32_t VP8Get(VP8BitReader* const br) {
-  return VP8GetValue(br, 1);
-}
-
-// return the next value with sign-extension.
-int32_t VP8GetSignedValue(VP8BitReader* const br, int num_bits);
-
-// bit_reader_inl.h will implement the following methods:
-//   static WEBP_INLINE int VP8GetBit(VP8BitReader* const br, int prob)
-//   static WEBP_INLINE int VP8GetSigned(VP8BitReader* const br, int v)
-// and should be included by the .c files that actually need them.
-// This is to avoid recompiling the whole library whenever this file is touched,
-// and also allowing platform-specific ad-hoc hacks.
-
-// -----------------------------------------------------------------------------
-// Bitreader for lossless format
-
-// maximum number of bits (inclusive) the bit-reader can handle:
-#define VP8L_MAX_NUM_BIT_READ 24
-
-#define VP8L_LBITS 64  // Number of bits prefetched.
-#define VP8L_WBITS 32  // Minimum number of bytes ready after VP8LFillBitWindow.
-
-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_
-  int            bit_pos_;    // current bit-reading position in val_
-  int            eos_;        // bitstream is finished
-  int            error_;      // an error occurred (buffer overflow attempt...)
-} VP8LBitReader;
-
-void VP8LInitBitReader(VP8LBitReader* const br,
-                       const uint8_t* const start,
-                       size_t length);
-
-//  Sets a new data buffer.
-void VP8LBitReaderSetBuffer(VP8LBitReader* const br,
-                            const uint8_t* const buffer, size_t length);
-
-// Reads the specified number of bits from read buffer.
-// Flags an error in case end_of_stream or n_bits is more than the allowed limit
-// of VP8L_MAX_NUM_BIT_READ (inclusive).
-// 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_);
-}
-
-// Returns true if there was an attempt at reading bit past the end of
-// the buffer. Doesn't set br->eos_ flag.
-static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
-  assert(br->pos_ <= br->len_);
-  return (br->pos_ == br->len_) && (br->bit_pos_ > VP8L_LBITS);
-}
-
-// 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;
-  br->eos_ = VP8LIsEndOfStream(br);
-}
-
-// Advances the read buffer by 4 bytes to make room for reading next 32 bits.
-// Speed critical, but infrequent part of the code can be non-inlined.
-extern void VP8LDoFillBitWindow(VP8LBitReader* const br);
-static WEBP_INLINE void VP8LFillBitWindow(VP8LBitReader* const br) {
-  if (br->bit_pos_ >= VP8L_WBITS) VP8LDoFillBitWindow(br);
-}
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_BIT_READER_H_ */
diff --git a/src/main/jni/libwebp/utils/bit_reader_inl.h b/src/main/jni/libwebp/utils/bit_reader_inl.h
deleted file mode 100644
index 81427c625..000000000
--- a/src/main/jni/libwebp/utils/bit_reader_inl.h
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2014 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.
-// -----------------------------------------------------------------------------
-//
-// Specific inlined methods for boolean decoder [VP8GetBit() ...]
-// This file should be included by the .c sources that actually need to call
-// these methods.
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#ifndef WEBP_UTILS_BIT_READER_INL_H_
-#define WEBP_UTILS_BIT_READER_INL_H_
-
-#ifdef HAVE_CONFIG_H
-#include "../webp/config.h"
-#endif
-
-#ifdef WEBP_FORCE_ALIGNED
-#include <string.h>  // memcpy
-#endif
-
-#include "../dsp/dsp.h"
-#include "./bit_reader.h"
-#include "./endian_inl.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//------------------------------------------------------------------------------
-// Derived type lbit_t = natural type for memory I/O
-
-#if   (BITS > 32)
-typedef uint64_t lbit_t;
-#elif (BITS > 16)
-typedef uint32_t lbit_t;
-#elif (BITS >  8)
-typedef uint16_t lbit_t;
-#else
-typedef uint8_t lbit_t;
-#endif
-
-extern const uint8_t kVP8Log2Range[128];
-extern const range_t kVP8NewRange[128];
-
-// special case for the tail byte-reading
-void VP8LoadFinalBytes(VP8BitReader* const br);
-
-//------------------------------------------------------------------------------
-// Inlined critical functions
-
-// makes sure br->value_ has at least BITS bits worth of data
-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;
-#if defined(WEBP_FORCE_ALIGNED)
-    lbit_t in_bits;
-    memcpy(&in_bits, br->buf_, sizeof(in_bits));
-#elif defined(WEBP_USE_MIPS32)
-    // This is needed because of un-aligned read.
-    lbit_t in_bits;
-    lbit_t* p_buf_ = (lbit_t*)br->buf_;
-    __asm__ volatile(
-      ".set   push                             \n\t"
-      ".set   at                               \n\t"
-      ".set   macro                            \n\t"
-      "ulw    %[in_bits], 0(%[p_buf_])         \n\t"
-      ".set   pop                              \n\t"
-      : [in_bits]"=r"(in_bits)
-      : [p_buf_]"r"(p_buf_)
-      : "memory", "at"
-    );
-#else
-    const lbit_t in_bits = *(const lbit_t*)br->buf_;
-#endif
-    br->buf_ += BITS >> 3;
-#if !defined(WORDS_BIGENDIAN)
-#if (BITS > 32)
-    bits = BSwap64(in_bits);
-    bits >>= 64 - BITS;
-#elif (BITS >= 24)
-    bits = BSwap32(in_bits);
-    bits >>= (32 - BITS);
-#elif (BITS == 16)
-    bits = BSwap16(in_bits);
-#else   // BITS == 8
-    bits = (bit_t)in_bits;
-#endif  // BITS > 32
-#else    // WORDS_BIGENDIAN
-    bits = (bit_t)in_bits;
-    if (BITS != 8 * sizeof(bit_t)) bits >>= (8 * sizeof(bit_t) - BITS);
-#endif
-    br->value_ = bits | (br->value_ << BITS);
-    br->bits_ += BITS;
-  } else {
-    VP8LoadFinalBytes(br);    // no need to be inlined
-  }
-}
-
-// Read a bit with proba 'prob'. Speed-critical function!
-static WEBP_INLINE int VP8GetBit(VP8BitReader* const br, int prob) {
-  // Don't move this declaration! It makes a big speed difference to store
-  // 'range' *before* calling VP8LoadNewBytes(), even if this function doesn't
-  // alter br->range_ value.
-  range_t range = br->range_;
-  if (br->bits_ < 0) {
-    VP8LoadNewBytes(br);
-  }
-  {
-    const int pos = br->bits_;
-    const range_t split = (range * prob) >> 8;
-    const range_t value = (range_t)(br->value_ >> pos);
-#if defined(__arm__) || defined(_M_ARM)      // ARM-specific
-    const int bit = ((int)(split - value) >> 31) & 1;
-    if (value > split) {
-      range -= split + 1;
-      br->value_ -= (bit_t)(split + 1) << pos;
-    } else {
-      range = split;
-    }
-#else  // faster version on x86
-    int bit;  // Don't use 'const int bit = (value > split);", it's slower.
-    if (value > split) {
-      range -= split + 1;
-      br->value_ -= (bit_t)(split + 1) << pos;
-      bit = 1;
-    } else {
-      range = split;
-      bit = 0;
-    }
-#endif
-    if (range <= (range_t)0x7e) {
-      const int shift = kVP8Log2Range[range];
-      range = kVP8NewRange[range];
-      br->bits_ -= shift;
-    }
-    br->range_ = range;
-    return bit;
-  }
-}
-
-// simplified version of VP8GetBit() for prob=0x80 (note shift is always 1 here)
-static WEBP_INLINE int VP8GetSigned(VP8BitReader* const br, int v) {
-  if (br->bits_ < 0) {
-    VP8LoadNewBytes(br);
-  }
-  {
-    const int pos = br->bits_;
-    const range_t split = br->range_ >> 1;
-    const range_t value = (range_t)(br->value_ >> pos);
-    const int32_t mask = (int32_t)(split - value) >> 31;  // -1 or 0
-    br->bits_ -= 1;
-    br->range_ += mask;
-    br->range_ |= 1;
-    br->value_ -= (bit_t)((split + 1) & mask) << pos;
-    return (v ^ mask) - mask;
-  }
-}
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif   // WEBP_UTILS_BIT_READER_INL_H_
diff --git a/src/main/jni/libwebp/utils/bit_writer.c b/src/main/jni/libwebp/utils/bit_writer.c
deleted file mode 100644
index 9875ca662..000000000
--- a/src/main/jni/libwebp/utils/bit_writer.c
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Bit writing and boolean coder
-//
-// Author: Skal (pascal.massimino@gmail.com)
-//         Vikas Arora (vikaas.arora@gmail.com)
-
-#include <assert.h>
-#include <string.h>   // for memcpy()
-#include <stdlib.h>
-
-#include "./bit_writer.h"
-#include "./endian_inl.h"
-#include "./utils.h"
-
-//------------------------------------------------------------------------------
-// VP8BitWriter
-
-static int BitWriterResize(VP8BitWriter* const bw, size_t extra_size) {
-  uint8_t* new_buf;
-  size_t new_size;
-  const uint64_t needed_size_64b = (uint64_t)bw->pos_ + extra_size;
-  const size_t needed_size = (size_t)needed_size_64b;
-  if (needed_size_64b != needed_size) {
-    bw->error_ = 1;
-    return 0;
-  }
-  if (needed_size <= bw->max_pos_) return 1;
-  // If the following line wraps over 32bit, the test just after will catch it.
-  new_size = 2 * bw->max_pos_;
-  if (new_size < needed_size) new_size = needed_size;
-  if (new_size < 1024) new_size = 1024;
-  new_buf = (uint8_t*)WebPSafeMalloc(1ULL, new_size);
-  if (new_buf == NULL) {
-    bw->error_ = 1;
-    return 0;
-  }
-  if (bw->pos_ > 0) {
-    assert(bw->buf_ != NULL);
-    memcpy(new_buf, bw->buf_, bw->pos_);
-  }
-  WebPSafeFree(bw->buf_);
-  bw->buf_ = new_buf;
-  bw->max_pos_ = new_size;
-  return 1;
-}
-
-static void Flush(VP8BitWriter* const bw) {
-  const int s = 8 + bw->nb_bits_;
-  const int32_t bits = bw->value_ >> s;
-  assert(bw->nb_bits_ >= 0);
-  bw->value_ -= bits << s;
-  bw->nb_bits_ -= 8;
-  if ((bits & 0xff) != 0xff) {
-    size_t pos = bw->pos_;
-    if (!BitWriterResize(bw, bw->run_ + 1)) {
-      return;
-    }
-    if (bits & 0x100) {  // overflow -> propagate carry over pending 0xff's
-      if (pos > 0) bw->buf_[pos - 1]++;
-    }
-    if (bw->run_ > 0) {
-      const int value = (bits & 0x100) ? 0x00 : 0xff;
-      for (; bw->run_ > 0; --bw->run_) bw->buf_[pos++] = value;
-    }
-    bw->buf_[pos++] = bits;
-    bw->pos_ = pos;
-  } else {
-    bw->run_++;   // delay writing of bytes 0xff, pending eventual carry.
-  }
-}
-
-//------------------------------------------------------------------------------
-// renormalization
-
-static const uint8_t kNorm[128] = {  // renorm_sizes[i] = 8 - log2(i)
-     7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
-  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  0
-};
-
-// range = ((range + 1) << kVP8Log2Range[range]) - 1
-static const uint8_t kNewRange[128] = {
-  127, 127, 191, 127, 159, 191, 223, 127, 143, 159, 175, 191, 207, 223, 239,
-  127, 135, 143, 151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239,
-  247, 127, 131, 135, 139, 143, 147, 151, 155, 159, 163, 167, 171, 175, 179,
-  183, 187, 191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239,
-  243, 247, 251, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149,
-  151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179,
-  181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209,
-  211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
-  241, 243, 245, 247, 249, 251, 253, 127
-};
-
-int VP8PutBit(VP8BitWriter* const bw, int bit, int prob) {
-  const int split = (bw->range_ * prob) >> 8;
-  if (bit) {
-    bw->value_ += split + 1;
-    bw->range_ -= split + 1;
-  } else {
-    bw->range_ = split;
-  }
-  if (bw->range_ < 127) {   // emit 'shift' bits out and renormalize
-    const int shift = kNorm[bw->range_];
-    bw->range_ = kNewRange[bw->range_];
-    bw->value_ <<= shift;
-    bw->nb_bits_ += shift;
-    if (bw->nb_bits_ > 0) Flush(bw);
-  }
-  return bit;
-}
-
-int VP8PutBitUniform(VP8BitWriter* const bw, int bit) {
-  const int split = bw->range_ >> 1;
-  if (bit) {
-    bw->value_ += split + 1;
-    bw->range_ -= split + 1;
-  } else {
-    bw->range_ = split;
-  }
-  if (bw->range_ < 127) {
-    bw->range_ = kNewRange[bw->range_];
-    bw->value_ <<= 1;
-    bw->nb_bits_ += 1;
-    if (bw->nb_bits_ > 0) Flush(bw);
-  }
-  return bit;
-}
-
-void VP8PutValue(VP8BitWriter* const bw, int value, int nb_bits) {
-  int mask;
-  for (mask = 1 << (nb_bits - 1); mask; mask >>= 1)
-    VP8PutBitUniform(bw, value & mask);
-}
-
-void VP8PutSignedValue(VP8BitWriter* const bw, int value, int nb_bits) {
-  if (!VP8PutBitUniform(bw, value != 0))
-    return;
-  if (value < 0) {
-    VP8PutValue(bw, ((-value) << 1) | 1, nb_bits + 1);
-  } else {
-    VP8PutValue(bw, value << 1, nb_bits + 1);
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int VP8BitWriterInit(VP8BitWriter* const bw, size_t expected_size) {
-  bw->range_   = 255 - 1;
-  bw->value_   = 0;
-  bw->run_     = 0;
-  bw->nb_bits_ = -8;
-  bw->pos_     = 0;
-  bw->max_pos_ = 0;
-  bw->error_   = 0;
-  bw->buf_     = NULL;
-  return (expected_size > 0) ? BitWriterResize(bw, expected_size) : 1;
-}
-
-uint8_t* VP8BitWriterFinish(VP8BitWriter* const bw) {
-  VP8PutValue(bw, 0, 9 - bw->nb_bits_);
-  bw->nb_bits_ = 0;   // pad with zeroes
-  Flush(bw);
-  return bw->buf_;
-}
-
-int VP8BitWriterAppend(VP8BitWriter* const bw,
-                       const uint8_t* data, size_t size) {
-  assert(data != NULL);
-  if (bw->nb_bits_ != -8) return 0;   // Flush() must have been called
-  if (!BitWriterResize(bw, size)) return 0;
-  memcpy(bw->buf_ + bw->pos_, data, size);
-  bw->pos_ += size;
-  return 1;
-}
-
-void VP8BitWriterWipeOut(VP8BitWriter* const bw) {
-  if (bw != NULL) {
-    WebPSafeFree(bw->buf_);
-    memset(bw, 0, sizeof(*bw));
-  }
-}
-
-//------------------------------------------------------------------------------
-// VP8LBitWriter
-
-// This is the minimum amount of size the memory buffer is guaranteed to grow
-// when extra space is needed.
-#define MIN_EXTRA_SIZE  (32768ULL)
-
-#define VP8L_WRITER_BYTES ((int)sizeof(vp8l_wtype_t))
-#define VP8L_WRITER_BITS (VP8L_WRITER_BYTES * 8)
-#define VP8L_WRITER_MAX_BITS (8 * (int)sizeof(vp8l_atype_t))
-
-// Returns 1 on success.
-static int VP8LBitWriterResize(VP8LBitWriter* const bw, size_t extra_size) {
-  uint8_t* allocated_buf;
-  size_t allocated_size;
-  const size_t max_bytes = bw->end_ - bw->buf_;
-  const size_t current_size = bw->cur_ - bw->buf_;
-  const uint64_t size_required_64b = (uint64_t)current_size + extra_size;
-  const size_t size_required = (size_t)size_required_64b;
-  if (size_required != size_required_64b) {
-    bw->error_ = 1;
-    return 0;
-  }
-  if (max_bytes > 0 && size_required <= max_bytes) return 1;
-  allocated_size = (3 * max_bytes) >> 1;
-  if (allocated_size < size_required) allocated_size = size_required;
-  // make allocated size multiple of 1k
-  allocated_size = (((allocated_size >> 10) + 1) << 10);
-  allocated_buf = (uint8_t*)WebPSafeMalloc(1ULL, allocated_size);
-  if (allocated_buf == NULL) {
-    bw->error_ = 1;
-    return 0;
-  }
-  if (current_size > 0) {
-    memcpy(allocated_buf, bw->buf_, current_size);
-  }
-  WebPSafeFree(bw->buf_);
-  bw->buf_ = allocated_buf;
-  bw->cur_ = bw->buf_ + current_size;
-  bw->end_ = bw->buf_ + allocated_size;
-  return 1;
-}
-
-int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size) {
-  memset(bw, 0, sizeof(*bw));
-  return VP8LBitWriterResize(bw, expected_size);
-}
-
-void VP8LBitWriterDestroy(VP8LBitWriter* const bw) {
-  if (bw != NULL) {
-    WebPSafeFree(bw->buf_);
-    memset(bw, 0, sizeof(*bw));
-  }
-}
-
-void VP8LWriteBits(VP8LBitWriter* const bw, int n_bits, uint32_t bits) {
-  assert(n_bits <= 32);
-  // That's the max we can handle:
-  assert(bw->used_ + n_bits <= 2 * VP8L_WRITER_MAX_BITS);
-  if (n_bits > 0) {
-    // Local field copy.
-    vp8l_atype_t lbits = bw->bits_;
-    int used = bw->used_;
-    // Special case of overflow handling for 32bit accumulator (2-steps flush).
-    if (VP8L_WRITER_BITS == 16) {
-      if (used + n_bits >= VP8L_WRITER_MAX_BITS) {
-        // Fill up all the VP8L_WRITER_MAX_BITS so it can be flushed out below.
-        const int shift = VP8L_WRITER_MAX_BITS - used;
-        lbits |= (vp8l_atype_t)bits << used;
-        used = VP8L_WRITER_MAX_BITS;
-        n_bits -= shift;
-        bits >>= shift;
-        assert(n_bits <= VP8L_WRITER_MAX_BITS);
-      }
-    }
-    // If needed, make some room by flushing some bits out.
-    while (used >= VP8L_WRITER_BITS) {
-      if (bw->cur_ + VP8L_WRITER_BYTES > bw->end_) {
-        const uint64_t extra_size = (bw->end_ - bw->buf_) + MIN_EXTRA_SIZE;
-        if (extra_size != (size_t)extra_size ||
-            !VP8LBitWriterResize(bw, (size_t)extra_size)) {
-          bw->cur_ = bw->buf_;
-          bw->error_ = 1;
-          return;
-        }
-      }
-      *(vp8l_wtype_t*)bw->cur_ = (vp8l_wtype_t)WSWAP((vp8l_wtype_t)lbits);
-      bw->cur_ += VP8L_WRITER_BYTES;
-      lbits >>= VP8L_WRITER_BITS;
-      used -= VP8L_WRITER_BITS;
-    }
-    // Eventually, insert new bits.
-    bw->bits_ = lbits | ((vp8l_atype_t)bits << used);
-    bw->used_ = used + n_bits;
-  }
-}
-
-uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw) {
-  // flush leftover bits
-  if (VP8LBitWriterResize(bw, (bw->used_ + 7) >> 3)) {
-    while (bw->used_ > 0) {
-      *bw->cur_++ = (uint8_t)bw->bits_;
-      bw->bits_ >>= 8;
-      bw->used_ -= 8;
-    }
-    bw->used_ = 0;
-  }
-  return bw->buf_;
-}
-
-//------------------------------------------------------------------------------
diff --git a/src/main/jni/libwebp/utils/bit_writer.h b/src/main/jni/libwebp/utils/bit_writer.h
deleted file mode 100644
index c80d22ae9..000000000
--- a/src/main/jni/libwebp/utils/bit_writer.h
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Bit writing and boolean coder
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#ifndef WEBP_UTILS_BIT_WRITER_H_
-#define WEBP_UTILS_BIT_WRITER_H_
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//------------------------------------------------------------------------------
-// Bit-writing
-
-typedef struct VP8BitWriter VP8BitWriter;
-struct VP8BitWriter {
-  int32_t  range_;      // range-1
-  int32_t  value_;
-  int      run_;        // number of outstanding bits
-  int      nb_bits_;    // number of pending bits
-  uint8_t* buf_;        // internal buffer. Re-allocated regularly. Not owned.
-  size_t   pos_;
-  size_t   max_pos_;
-  int      error_;      // true in case of error
-};
-
-// Initialize the object. Allocates some initial memory based on expected_size.
-int VP8BitWriterInit(VP8BitWriter* const bw, size_t expected_size);
-// Finalize the bitstream coding. Returns a pointer to the internal buffer.
-uint8_t* VP8BitWriterFinish(VP8BitWriter* const bw);
-// Release any pending memory and zeroes the object. Not a mandatory call.
-// Only useful in case of error, when the internal buffer hasn't been grabbed!
-void VP8BitWriterWipeOut(VP8BitWriter* const bw);
-
-int VP8PutBit(VP8BitWriter* const bw, int bit, int prob);
-int VP8PutBitUniform(VP8BitWriter* const bw, int bit);
-void VP8PutValue(VP8BitWriter* const bw, int value, int nb_bits);
-void VP8PutSignedValue(VP8BitWriter* const bw, int value, int nb_bits);
-
-// Appends some bytes to the internal buffer. Data is copied.
-int VP8BitWriterAppend(VP8BitWriter* const bw,
-                       const uint8_t* data, size_t size);
-
-// return approximate write position (in bits)
-static WEBP_INLINE uint64_t VP8BitWriterPos(const VP8BitWriter* const bw) {
-  return (uint64_t)(bw->pos_ + bw->run_) * 8 + 8 + bw->nb_bits_;
-}
-
-// Returns a pointer to the internal buffer.
-static WEBP_INLINE uint8_t* VP8BitWriterBuf(const VP8BitWriter* const bw) {
-  return bw->buf_;
-}
-// Returns the size of the internal buffer.
-static WEBP_INLINE size_t VP8BitWriterSize(const VP8BitWriter* const bw) {
-  return bw->pos_;
-}
-
-//------------------------------------------------------------------------------
-// VP8LBitWriter
-
-#if defined(__x86_64__) || defined(_M_X64)   // 64bit
-typedef uint64_t vp8l_atype_t;   // accumulator type
-typedef uint32_t vp8l_wtype_t;   // writing type
-#define WSWAP HToLE32
-#else
-typedef uint32_t vp8l_atype_t;
-typedef uint16_t vp8l_wtype_t;
-#define WSWAP HToLE16
-#endif
-
-typedef struct {
-  vp8l_atype_t bits_;   // bit accumulator
-  int          used_;   // number of bits used in accumulator
-  uint8_t*     buf_;    // start of buffer
-  uint8_t*     cur_;    // current write position
-  uint8_t*     end_;    // end of buffer
-
-  // After all bits are written (VP8LBitWriterFinish()), the caller must observe
-  // the state of error_. A value of 1 indicates that a memory allocation
-  // failure has happened during bit writing. A value of 0 indicates successful
-  // writing of bits.
-  int error_;
-} VP8LBitWriter;
-
-static WEBP_INLINE size_t VP8LBitWriterNumBytes(VP8LBitWriter* const bw) {
-  return (bw->cur_ - bw->buf_) + ((bw->used_ + 7) >> 3);
-}
-
-uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw);
-
-// Returns 0 in case of memory allocation error.
-int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size);
-
-void VP8LBitWriterDestroy(VP8LBitWriter* const bw);
-
-// This function writes bits into bytes in increasing addresses (little endian),
-// and within a byte least-significant-bit first.
-// This function can write up to 32 bits in one go, but VP8LBitReader can only
-// read 24 bits max (VP8L_MAX_NUM_BIT_READ).
-// VP8LBitWriter's error_ flag is set in case of  memory allocation error.
-void VP8LWriteBits(VP8LBitWriter* const bw, int n_bits, uint32_t bits);
-
-//------------------------------------------------------------------------------
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_BIT_WRITER_H_ */
diff --git a/src/main/jni/libwebp/utils/color_cache.c b/src/main/jni/libwebp/utils/color_cache.c
deleted file mode 100644
index 8a88f08b7..000000000
--- a/src/main/jni/libwebp/utils/color_cache.c
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Color Cache for WebP Lossless
-//
-// Author: Jyrki Alakuijala (jyrki@google.com)
-
-#include <assert.h>
-#include <stdlib.h>
-#include "./color_cache.h"
-#include "../utils/utils.h"
-
-//------------------------------------------------------------------------------
-// VP8LColorCache.
-
-int VP8LColorCacheInit(VP8LColorCache* const cc, int hash_bits) {
-  const int hash_size = 1 << hash_bits;
-  assert(cc != NULL);
-  assert(hash_bits > 0);
-  cc->colors_ = (uint32_t*)WebPSafeCalloc((uint64_t)hash_size,
-                                          sizeof(*cc->colors_));
-  if (cc->colors_ == NULL) return 0;
-  cc->hash_shift_ = 32 - hash_bits;
-  return 1;
-}
-
-void VP8LColorCacheClear(VP8LColorCache* const cc) {
-  if (cc != NULL) {
-    WebPSafeFree(cc->colors_);
-    cc->colors_ = NULL;
-  }
-}
-
diff --git a/src/main/jni/libwebp/utils/color_cache.h b/src/main/jni/libwebp/utils/color_cache.h
deleted file mode 100644
index 0f824ed45..000000000
--- a/src/main/jni/libwebp/utils/color_cache.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Color Cache for WebP Lossless
-//
-// Authors: Jyrki Alakuijala (jyrki@google.com)
-//          Urvang Joshi (urvang@google.com)
-
-#ifndef WEBP_UTILS_COLOR_CACHE_H_
-#define WEBP_UTILS_COLOR_CACHE_H_
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Main color cache struct.
-typedef struct {
-  uint32_t *colors_;  // color entries
-  int hash_shift_;    // Hash shift: 32 - hash_bits.
-} VP8LColorCache;
-
-static const uint32_t kHashMul = 0x1e35a7bd;
-
-static WEBP_INLINE uint32_t VP8LColorCacheLookup(
-    const VP8LColorCache* const cc, uint32_t key) {
-  assert(key <= (~0U >> cc->hash_shift_));
-  return cc->colors_[key];
-}
-
-static WEBP_INLINE void VP8LColorCacheInsert(const VP8LColorCache* const cc,
-                                             uint32_t argb) {
-  const uint32_t key = (kHashMul * argb) >> cc->hash_shift_;
-  cc->colors_[key] = argb;
-}
-
-static WEBP_INLINE int VP8LColorCacheGetIndex(const VP8LColorCache* const cc,
-                                              uint32_t argb) {
-  return (kHashMul * argb) >> cc->hash_shift_;
-}
-
-static WEBP_INLINE int VP8LColorCacheContains(const VP8LColorCache* const cc,
-                                              uint32_t argb) {
-  const uint32_t key = (kHashMul * argb) >> cc->hash_shift_;
-  return cc->colors_[key] == argb;
-}
-
-//------------------------------------------------------------------------------
-
-// Initializes the color cache with 'hash_bits' bits for the keys.
-// Returns false in case of memory error.
-int VP8LColorCacheInit(VP8LColorCache* const color_cache, int hash_bits);
-
-// Delete the memory associated to color cache.
-void VP8LColorCacheClear(VP8LColorCache* const color_cache);
-
-//------------------------------------------------------------------------------
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // WEBP_UTILS_COLOR_CACHE_H_
diff --git a/src/main/jni/libwebp/utils/endian_inl.h b/src/main/jni/libwebp/utils/endian_inl.h
deleted file mode 100644
index cd56c37f4..000000000
--- a/src/main/jni/libwebp/utils/endian_inl.h
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2014 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.
-// -----------------------------------------------------------------------------
-//
-// Endian related functions.
-
-#ifndef WEBP_UTILS_ENDIAN_INL_H_
-#define WEBP_UTILS_ENDIAN_INL_H_
-
-#ifdef HAVE_CONFIG_H
-#include "../webp/config.h"
-#endif
-
-#include "../dsp/dsp.h"
-#include "../webp/types.h"
-
-// some endian fix (e.g.: mips-gcc doesn't define __BIG_ENDIAN__)
-#if !defined(WORDS_BIGENDIAN) && \
-    (defined(__BIG_ENDIAN__) || defined(_M_PPC) || \
-     (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
-#define WORDS_BIGENDIAN
-#endif
-
-#if defined(WORDS_BIGENDIAN)
-#define HToLE32 BSwap32
-#define HToLE16 BSwap16
-#else
-#define HToLE32(x) (x)
-#define HToLE16(x) (x)
-#endif
-
-#if !defined(HAVE_CONFIG_H)
-// clang-3.3 and gcc-4.3 have builtin functions for swap32/swap64
-#if LOCAL_GCC_PREREQ(4,3) || LOCAL_CLANG_PREREQ(3,3)
-#define HAVE_BUILTIN_BSWAP32
-#define HAVE_BUILTIN_BSWAP64
-#endif
-// clang-3.3 and gcc-4.8 have a builtin function for swap16
-#if LOCAL_GCC_PREREQ(4,8) || LOCAL_CLANG_PREREQ(3,3)
-#define HAVE_BUILTIN_BSWAP16
-#endif
-#endif  // !HAVE_CONFIG_H
-
-static WEBP_INLINE uint16_t BSwap16(uint16_t x) {
-#if defined(HAVE_BUILTIN_BSWAP16)
-  return __builtin_bswap16(x);
-#elif defined(_MSC_VER)
-  return _byteswap_ushort(x);
-#else
-  // gcc will recognize a 'rorw $8, ...' here:
-  return (x >> 8) | ((x & 0xff) << 8);
-#endif  // HAVE_BUILTIN_BSWAP16
-}
-
-static WEBP_INLINE uint32_t BSwap32(uint32_t x) {
-#if defined(WEBP_USE_MIPS32_R2)
-  uint32_t ret;
-  __asm__ volatile (
-    "wsbh   %[ret], %[x]          \n\t"
-    "rotr   %[ret], %[ret],  16   \n\t"
-    : [ret]"=r"(ret)
-    : [x]"r"(x)
-  );
-  return ret;
-#elif defined(HAVE_BUILTIN_BSWAP32)
-  return __builtin_bswap32(x);
-#elif defined(__i386__) || defined(__x86_64__)
-  uint32_t swapped_bytes;
-  __asm__ volatile("bswap %0" : "=r"(swapped_bytes) : "0"(x));
-  return swapped_bytes;
-#elif defined(_MSC_VER)
-  return (uint32_t)_byteswap_ulong(x);
-#else
-  return (x >> 24) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | (x << 24);
-#endif  // HAVE_BUILTIN_BSWAP32
-}
-
-static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
-#if defined(HAVE_BUILTIN_BSWAP64)
-  return __builtin_bswap64(x);
-#elif defined(__x86_64__)
-  uint64_t swapped_bytes;
-  __asm__ volatile("bswapq %0" : "=r"(swapped_bytes) : "0"(x));
-  return swapped_bytes;
-#elif defined(_MSC_VER)
-  return (uint64_t)_byteswap_uint64(x);
-#else  // generic code for swapping 64-bit values (suggested by bdb@)
-  x = ((x & 0xffffffff00000000ull) >> 32) | ((x & 0x00000000ffffffffull) << 32);
-  x = ((x & 0xffff0000ffff0000ull) >> 16) | ((x & 0x0000ffff0000ffffull) << 16);
-  x = ((x & 0xff00ff00ff00ff00ull) >>  8) | ((x & 0x00ff00ff00ff00ffull) <<  8);
-  return x;
-#endif  // HAVE_BUILTIN_BSWAP64
-}
-
-#endif  // WEBP_UTILS_ENDIAN_INL_H_
diff --git a/src/main/jni/libwebp/utils/filters.c b/src/main/jni/libwebp/utils/filters.c
deleted file mode 100644
index 2d15bd0e4..000000000
--- a/src/main/jni/libwebp/utils/filters.c
+++ /dev/null
@@ -1,266 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Spatial prediction using various filters
-//
-// Author: Urvang (urvang@google.com)
-
-#include "./filters.h"
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-//------------------------------------------------------------------------------
-// Helpful macro.
-
-# define SANITY_CHECK(in, out)                                                 \
-  assert(in != NULL);                                                          \
-  assert(out != NULL);                                                         \
-  assert(width > 0);                                                           \
-  assert(height > 0);                                                          \
-  assert(stride >= width);                                                     \
-  assert(row >= 0 && num_rows > 0 && row + num_rows <= height);                \
-  (void)height;  // Silence unused warning.
-
-static WEBP_INLINE void PredictLine(const uint8_t* src, const uint8_t* pred,
-                                    uint8_t* dst, int length, int inverse) {
-  int i;
-  if (inverse) {
-    for (i = 0; i < length; ++i) dst[i] = src[i] + pred[i];
-  } else {
-    for (i = 0; i < length; ++i) dst[i] = src[i] - pred[i];
-  }
-}
-
-//------------------------------------------------------------------------------
-// Horizontal filter.
-
-static WEBP_INLINE void DoHorizontalFilter(const uint8_t* in,
-                                           int width, int height, int stride,
-                                           int row, int num_rows,
-                                           int inverse, uint8_t* out) {
-  const uint8_t* preds;
-  const size_t start_offset = row * stride;
-  const int last_row = row + num_rows;
-  SANITY_CHECK(in, out);
-  in += start_offset;
-  out += start_offset;
-  preds = inverse ? out : in;
-
-  if (row == 0) {
-    // Leftmost pixel is the same as input for topmost scanline.
-    out[0] = in[0];
-    PredictLine(in + 1, preds, out + 1, width - 1, inverse);
-    row = 1;
-    preds += stride;
-    in += stride;
-    out += stride;
-  }
-
-  // Filter line-by-line.
-  while (row < last_row) {
-    // Leftmost pixel is predicted from above.
-    PredictLine(in, preds - stride, out, 1, inverse);
-    PredictLine(in + 1, preds, out + 1, width - 1, inverse);
-    ++row;
-    preds += stride;
-    in += stride;
-    out += stride;
-  }
-}
-
-static void HorizontalFilter(const uint8_t* data, int width, int height,
-                             int stride, uint8_t* filtered_data) {
-  DoHorizontalFilter(data, width, height, stride, 0, height, 0, filtered_data);
-}
-
-static void HorizontalUnfilter(int width, int height, int stride, int row,
-                               int num_rows, uint8_t* data) {
-  DoHorizontalFilter(data, width, height, stride, row, num_rows, 1, data);
-}
-
-//------------------------------------------------------------------------------
-// Vertical filter.
-
-static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
-                                         int width, int height, int stride,
-                                         int row, int num_rows,
-                                         int inverse, uint8_t* out) {
-  const uint8_t* preds;
-  const size_t start_offset = row * stride;
-  const int last_row = row + num_rows;
-  SANITY_CHECK(in, out);
-  in += start_offset;
-  out += start_offset;
-  preds = inverse ? out : in;
-
-  if (row == 0) {
-    // Very first top-left pixel is copied.
-    out[0] = in[0];
-    // Rest of top scan-line is left-predicted.
-    PredictLine(in + 1, preds, out + 1, width - 1, inverse);
-    row = 1;
-    in += stride;
-    out += stride;
-  } else {
-    // We are starting from in-between. Make sure 'preds' points to prev row.
-    preds -= stride;
-  }
-
-  // Filter line-by-line.
-  while (row < last_row) {
-    PredictLine(in, preds, out, width, inverse);
-    ++row;
-    preds += stride;
-    in += stride;
-    out += stride;
-  }
-}
-
-static void VerticalFilter(const uint8_t* data, int width, int height,
-                           int stride, uint8_t* filtered_data) {
-  DoVerticalFilter(data, width, height, stride, 0, height, 0, filtered_data);
-}
-
-static void VerticalUnfilter(int width, int height, int stride, int row,
-                             int num_rows, uint8_t* data) {
-  DoVerticalFilter(data, width, height, stride, row, num_rows, 1, data);
-}
-
-//------------------------------------------------------------------------------
-// Gradient filter.
-
-static WEBP_INLINE int GradientPredictor(uint8_t a, uint8_t b, uint8_t c) {
-  const int g = a + b - c;
-  return ((g & ~0xff) == 0) ? g : (g < 0) ? 0 : 255;  // clip to 8bit
-}
-
-static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
-                                         int width, int height, int stride,
-                                         int row, int num_rows,
-                                         int inverse, uint8_t* out) {
-  const uint8_t* preds;
-  const size_t start_offset = row * stride;
-  const int last_row = row + num_rows;
-  SANITY_CHECK(in, out);
-  in += start_offset;
-  out += start_offset;
-  preds = inverse ? out : in;
-
-  // left prediction for top scan-line
-  if (row == 0) {
-    out[0] = in[0];
-    PredictLine(in + 1, preds, out + 1, width - 1, inverse);
-    row = 1;
-    preds += stride;
-    in += stride;
-    out += stride;
-  }
-
-  // Filter line-by-line.
-  while (row < last_row) {
-    int w;
-    // leftmost pixel: predict from above.
-    PredictLine(in, preds - stride, out, 1, inverse);
-    for (w = 1; w < width; ++w) {
-      const int pred = GradientPredictor(preds[w - 1],
-                                         preds[w - stride],
-                                         preds[w - stride - 1]);
-      out[w] = in[w] + (inverse ? pred : -pred);
-    }
-    ++row;
-    preds += stride;
-    in += stride;
-    out += stride;
-  }
-}
-
-static void GradientFilter(const uint8_t* data, int width, int height,
-                           int stride, uint8_t* filtered_data) {
-  DoGradientFilter(data, width, height, stride, 0, height, 0, filtered_data);
-}
-
-static void GradientUnfilter(int width, int height, int stride, int row,
-                             int num_rows, uint8_t* data) {
-  DoGradientFilter(data, width, height, stride, row, num_rows, 1, data);
-}
-
-#undef SANITY_CHECK
-
-// -----------------------------------------------------------------------------
-// Quick estimate of a potentially interesting filter mode to try.
-
-#define SMAX 16
-#define SDIFF(a, b) (abs((a) - (b)) >> 4)   // Scoring diff, in [0..SMAX)
-
-WEBP_FILTER_TYPE EstimateBestFilter(const uint8_t* data,
-                                    int width, int height, int stride) {
-  int i, j;
-  int bins[WEBP_FILTER_LAST][SMAX];
-  memset(bins, 0, sizeof(bins));
-
-  // We only sample every other pixels. That's enough.
-  for (j = 2; j < height - 1; j += 2) {
-    const uint8_t* const p = data + j * stride;
-    int mean = p[0];
-    for (i = 2; i < width - 1; i += 2) {
-      const int diff0 = SDIFF(p[i], mean);
-      const int diff1 = SDIFF(p[i], p[i - 1]);
-      const int diff2 = SDIFF(p[i], p[i - width]);
-      const int grad_pred =
-          GradientPredictor(p[i - 1], p[i - width], p[i - width - 1]);
-      const int diff3 = SDIFF(p[i], grad_pred);
-      bins[WEBP_FILTER_NONE][diff0] = 1;
-      bins[WEBP_FILTER_HORIZONTAL][diff1] = 1;
-      bins[WEBP_FILTER_VERTICAL][diff2] = 1;
-      bins[WEBP_FILTER_GRADIENT][diff3] = 1;
-      mean = (3 * mean + p[i] + 2) >> 2;
-    }
-  }
-  {
-    int filter;
-    WEBP_FILTER_TYPE best_filter = WEBP_FILTER_NONE;
-    int best_score = 0x7fffffff;
-    for (filter = WEBP_FILTER_NONE; filter < WEBP_FILTER_LAST; ++filter) {
-      int score = 0;
-      for (i = 0; i < SMAX; ++i) {
-        if (bins[filter][i] > 0) {
-          score += i;
-        }
-      }
-      if (score < best_score) {
-        best_score = score;
-        best_filter = (WEBP_FILTER_TYPE)filter;
-      }
-    }
-    return best_filter;
-  }
-}
-
-#undef SMAX
-#undef SDIFF
-
-//------------------------------------------------------------------------------
-
-const WebPFilterFunc WebPFilters[WEBP_FILTER_LAST] = {
-  NULL,              // WEBP_FILTER_NONE
-  HorizontalFilter,  // WEBP_FILTER_HORIZONTAL
-  VerticalFilter,    // WEBP_FILTER_VERTICAL
-  GradientFilter     // WEBP_FILTER_GRADIENT
-};
-
-const WebPUnfilterFunc WebPUnfilters[WEBP_FILTER_LAST] = {
-  NULL,                // WEBP_FILTER_NONE
-  HorizontalUnfilter,  // WEBP_FILTER_HORIZONTAL
-  VerticalUnfilter,    // WEBP_FILTER_VERTICAL
-  GradientUnfilter     // WEBP_FILTER_GRADIENT
-};
-
-//------------------------------------------------------------------------------
-
diff --git a/src/main/jni/libwebp/utils/filters.h b/src/main/jni/libwebp/utils/filters.h
deleted file mode 100644
index dde39cb5c..000000000
--- a/src/main/jni/libwebp/utils/filters.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Spatial prediction using various filters
-//
-// Author: Urvang (urvang@google.com)
-
-#ifndef WEBP_UTILS_FILTERS_H_
-#define WEBP_UTILS_FILTERS_H_
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Filters.
-typedef enum {
-  WEBP_FILTER_NONE = 0,
-  WEBP_FILTER_HORIZONTAL,
-  WEBP_FILTER_VERTICAL,
-  WEBP_FILTER_GRADIENT,
-  WEBP_FILTER_LAST = WEBP_FILTER_GRADIENT + 1,  // end marker
-  WEBP_FILTER_BEST,
-  WEBP_FILTER_FAST
-} WEBP_FILTER_TYPE;
-
-typedef void (*WebPFilterFunc)(const uint8_t* in, int width, int height,
-                               int stride, uint8_t* out);
-typedef void (*WebPUnfilterFunc)(int width, int height, int stride,
-                                 int row, int num_rows, uint8_t* data);
-
-// Filter the given data using the given predictor.
-// 'in' corresponds to a 2-dimensional pixel array of size (stride * height)
-// in raster order.
-// 'stride' is number of bytes per scan line (with possible padding).
-// 'out' should be pre-allocated.
-extern const WebPFilterFunc WebPFilters[WEBP_FILTER_LAST];
-
-// In-place reconstruct the original data from the given filtered data.
-// The reconstruction will be done for 'num_rows' rows starting from 'row'
-// (assuming rows upto 'row - 1' are already reconstructed).
-extern const WebPUnfilterFunc WebPUnfilters[WEBP_FILTER_LAST];
-
-// Fast estimate of a potentially good filter.
-WEBP_FILTER_TYPE EstimateBestFilter(const uint8_t* data,
-                                    int width, int height, int stride);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_FILTERS_H_ */
diff --git a/src/main/jni/libwebp/utils/huffman.c b/src/main/jni/libwebp/utils/huffman.c
deleted file mode 100644
index c4c16d9e6..000000000
--- a/src/main/jni/libwebp/utils/huffman.c
+++ /dev/null
@@ -1,319 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Utilities for building and looking up Huffman trees.
-//
-// Author: Urvang Joshi (urvang@google.com)
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include "./huffman.h"
-#include "../utils/utils.h"
-#include "../webp/format_constants.h"
-
-// Uncomment the following to use look-up table for ReverseBits()
-// (might be faster on some platform)
-// #define USE_LUT_REVERSE_BITS
-
-// Huffman data read via DecodeImageStream is represented in two (red and green)
-// bytes.
-#define MAX_HTREE_GROUPS    0x10000
-#define NON_EXISTENT_SYMBOL (-1)
-
-static void TreeNodeInit(HuffmanTreeNode* const node) {
-  node->children_ = -1;   // means: 'unassigned so far'
-}
-
-static int NodeIsEmpty(const HuffmanTreeNode* const node) {
-  return (node->children_ < 0);
-}
-
-static int IsFull(const HuffmanTree* const tree) {
-  return (tree->num_nodes_ == tree->max_nodes_);
-}
-
-static void AssignChildren(HuffmanTree* const tree,
-                           HuffmanTreeNode* const node) {
-  HuffmanTreeNode* const children = tree->root_ + tree->num_nodes_;
-  node->children_ = (int)(children - node);
-  assert(children - node == (int)(children - node));
-  tree->num_nodes_ += 2;
-  TreeNodeInit(children + 0);
-  TreeNodeInit(children + 1);
-}
-
-// A Huffman tree is a full binary tree; and in a full binary tree with L
-// leaves, the total number of nodes N = 2 * L - 1.
-static int HuffmanTreeMaxNodes(int num_leaves) {
-  return (2 * num_leaves - 1);
-}
-
-static int HuffmanTreeAllocate(HuffmanTree* const tree, int num_nodes) {
-  assert(tree != NULL);
-  tree->root_ =
-      (HuffmanTreeNode*)WebPSafeMalloc(num_nodes, sizeof(*tree->root_));
-  return (tree->root_ != NULL);
-}
-
-static int TreeInit(HuffmanTree* const tree, int num_leaves) {
-  assert(tree != NULL);
-  if (num_leaves == 0) return 0;
-  tree->max_nodes_ = HuffmanTreeMaxNodes(num_leaves);
-  assert(tree->max_nodes_ < (1 << 16));   // limit for the lut_jump_ table
-  if (!HuffmanTreeAllocate(tree, tree->max_nodes_)) return 0;
-  TreeNodeInit(tree->root_);  // Initialize root.
-  tree->num_nodes_ = 1;
-  memset(tree->lut_bits_, 255, sizeof(tree->lut_bits_));
-  memset(tree->lut_jump_, 0, sizeof(tree->lut_jump_));
-  return 1;
-}
-
-void VP8LHuffmanTreeFree(HuffmanTree* const tree) {
-  if (tree != NULL) {
-    WebPSafeFree(tree->root_);
-    tree->root_ = NULL;
-    tree->max_nodes_ = 0;
-    tree->num_nodes_ = 0;
-  }
-}
-
-HTreeGroup* VP8LHtreeGroupsNew(int num_htree_groups) {
-  HTreeGroup* const htree_groups =
-      (HTreeGroup*)WebPSafeCalloc(num_htree_groups, sizeof(*htree_groups));
-  assert(num_htree_groups <= MAX_HTREE_GROUPS);
-  if (htree_groups == NULL) {
-    return NULL;
-  }
-  return htree_groups;
-}
-
-void VP8LHtreeGroupsFree(HTreeGroup* htree_groups, int num_htree_groups) {
-  if (htree_groups != NULL) {
-    int i, j;
-    for (i = 0; i < num_htree_groups; ++i) {
-      HuffmanTree* const htrees = htree_groups[i].htrees_;
-      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
-        VP8LHuffmanTreeFree(&htrees[j]);
-      }
-    }
-    WebPSafeFree(htree_groups);
-  }
-}
-
-int VP8LHuffmanCodeLengthsToCodes(
-    const int* const code_lengths, int code_lengths_size,
-    int* const huff_codes) {
-  int symbol;
-  int code_len;
-  int code_length_hist[MAX_ALLOWED_CODE_LENGTH + 1] = { 0 };
-  int curr_code;
-  int next_codes[MAX_ALLOWED_CODE_LENGTH + 1] = { 0 };
-  int max_code_length = 0;
-
-  assert(code_lengths != NULL);
-  assert(code_lengths_size > 0);
-  assert(huff_codes != NULL);
-
-  // Calculate max code length.
-  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
-    if (code_lengths[symbol] > max_code_length) {
-      max_code_length = code_lengths[symbol];
-    }
-  }
-  if (max_code_length > MAX_ALLOWED_CODE_LENGTH) return 0;
-
-  // Calculate code length histogram.
-  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
-    ++code_length_hist[code_lengths[symbol]];
-  }
-  code_length_hist[0] = 0;
-
-  // Calculate the initial values of 'next_codes' for each code length.
-  // next_codes[code_len] denotes the code to be assigned to the next symbol
-  // of code length 'code_len'.
-  curr_code = 0;
-  next_codes[0] = -1;  // Unused, as code length = 0 implies code doesn't exist.
-  for (code_len = 1; code_len <= max_code_length; ++code_len) {
-    curr_code = (curr_code + code_length_hist[code_len - 1]) << 1;
-    next_codes[code_len] = curr_code;
-  }
-
-  // Get symbols.
-  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
-    if (code_lengths[symbol] > 0) {
-      huff_codes[symbol] = next_codes[code_lengths[symbol]]++;
-    } else {
-      huff_codes[symbol] = NON_EXISTENT_SYMBOL;
-    }
-  }
-  return 1;
-}
-
-#ifndef USE_LUT_REVERSE_BITS
-
-static int ReverseBitsShort(int bits, int num_bits) {
-  int retval = 0;
-  int i;
-  assert(num_bits <= 8);   // Not a hard requirement, just for coherency.
-  for (i = 0; i < num_bits; ++i) {
-    retval <<= 1;
-    retval |= bits & 1;
-    bits >>= 1;
-  }
-  return retval;
-}
-
-#else
-
-static const uint8_t kReversedBits[16] = {  // Pre-reversed 4-bit values.
-  0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
-  0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf
-};
-
-static int ReverseBitsShort(int bits, int num_bits) {
-  const uint8_t v = (kReversedBits[bits & 0xf] << 4) | kReversedBits[bits >> 4];
-  assert(num_bits <= 8);
-  return v >> (8 - num_bits);
-}
-
-#endif
-
-static int TreeAddSymbol(HuffmanTree* const tree,
-                         int symbol, int code, int code_length) {
-  int step = HUFF_LUT_BITS;
-  int base_code;
-  HuffmanTreeNode* node = tree->root_;
-  const HuffmanTreeNode* const max_node = tree->root_ + tree->max_nodes_;
-  assert(symbol == (int16_t)symbol);
-  if (code_length <= HUFF_LUT_BITS) {
-    int i;
-    base_code = ReverseBitsShort(code, code_length);
-    for (i = 0; i < (1 << (HUFF_LUT_BITS - code_length)); ++i) {
-      const int idx = base_code | (i << code_length);
-      tree->lut_symbol_[idx] = (int16_t)symbol;
-      tree->lut_bits_[idx] = code_length;
-    }
-  } else {
-    base_code = ReverseBitsShort((code >> (code_length - HUFF_LUT_BITS)),
-                                 HUFF_LUT_BITS);
-  }
-  while (code_length-- > 0) {
-    if (node >= max_node) {
-      return 0;
-    }
-    if (NodeIsEmpty(node)) {
-      if (IsFull(tree)) return 0;    // error: too many symbols.
-      AssignChildren(tree, node);
-    } else if (!HuffmanTreeNodeIsNotLeaf(node)) {
-      return 0;  // leaf is already occupied.
-    }
-    node += node->children_ + ((code >> code_length) & 1);
-    if (--step == 0) {
-      tree->lut_jump_[base_code] = (int16_t)(node - tree->root_);
-    }
-  }
-  if (NodeIsEmpty(node)) {
-    node->children_ = 0;      // turn newly created node into a leaf.
-  } else if (HuffmanTreeNodeIsNotLeaf(node)) {
-    return 0;   // trying to assign a symbol to already used code.
-  }
-  node->symbol_ = symbol;  // Add symbol in this node.
-  return 1;
-}
-
-int VP8LHuffmanTreeBuildImplicit(HuffmanTree* const tree,
-                                 const int* const code_lengths,
-                                 int* const codes,
-                                 int code_lengths_size) {
-  int symbol;
-  int num_symbols = 0;
-  int root_symbol = 0;
-
-  assert(tree != NULL);
-  assert(code_lengths != NULL);
-
-  // Find out number of symbols and the root symbol.
-  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
-    if (code_lengths[symbol] > 0) {
-      // Note: code length = 0 indicates non-existent symbol.
-      ++num_symbols;
-      root_symbol = symbol;
-    }
-  }
-
-  // Initialize the tree. Will fail for num_symbols = 0
-  if (!TreeInit(tree, num_symbols)) return 0;
-
-  // Build tree.
-  if (num_symbols == 1) {  // Trivial case.
-    const int max_symbol = code_lengths_size;
-    if (root_symbol < 0 || root_symbol >= max_symbol) {
-      VP8LHuffmanTreeFree(tree);
-      return 0;
-    }
-    return TreeAddSymbol(tree, root_symbol, 0, 0);
-  } else {  // Normal case.
-    int ok = 0;
-    memset(codes, 0, code_lengths_size * sizeof(*codes));
-
-    if (!VP8LHuffmanCodeLengthsToCodes(code_lengths, code_lengths_size,
-                                       codes)) {
-      goto End;
-    }
-
-    // Add symbols one-by-one.
-    for (symbol = 0; symbol < code_lengths_size; ++symbol) {
-      if (code_lengths[symbol] > 0) {
-        if (!TreeAddSymbol(tree, symbol, codes[symbol],
-                           code_lengths[symbol])) {
-          goto End;
-        }
-      }
-    }
-    ok = 1;
- End:
-    ok = ok && IsFull(tree);
-    if (!ok) VP8LHuffmanTreeFree(tree);
-    return ok;
-  }
-}
-
-int VP8LHuffmanTreeBuildExplicit(HuffmanTree* const tree,
-                                 const int* const code_lengths,
-                                 const int* const codes,
-                                 const int* const symbols, int max_symbol,
-                                 int num_symbols) {
-  int ok = 0;
-  int i;
-  assert(tree != NULL);
-  assert(code_lengths != NULL);
-  assert(codes != NULL);
-  assert(symbols != NULL);
-
-  // Initialize the tree. Will fail if num_symbols = 0.
-  if (!TreeInit(tree, num_symbols)) return 0;
-
-  // Add symbols one-by-one.
-  for (i = 0; i < num_symbols; ++i) {
-    if (codes[i] != NON_EXISTENT_SYMBOL) {
-      if (symbols[i] < 0 || symbols[i] >= max_symbol) {
-        goto End;
-      }
-      if (!TreeAddSymbol(tree, symbols[i], codes[i], code_lengths[i])) {
-        goto End;
-      }
-    }
-  }
-  ok = 1;
- End:
-  ok = ok && IsFull(tree);
-  if (!ok) VP8LHuffmanTreeFree(tree);
-  return ok;
-}
diff --git a/src/main/jni/libwebp/utils/huffman.h b/src/main/jni/libwebp/utils/huffman.h
deleted file mode 100644
index 624bc1750..000000000
--- a/src/main/jni/libwebp/utils/huffman.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Utilities for building and looking up Huffman trees.
-//
-// Author: Urvang Joshi (urvang@google.com)
-
-#ifndef WEBP_UTILS_HUFFMAN_H_
-#define WEBP_UTILS_HUFFMAN_H_
-
-#include <assert.h>
-#include "../webp/format_constants.h"
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// A node of a Huffman tree.
-typedef struct {
-  int symbol_;
-  int children_;  // delta offset to both children (contiguous) or 0 if leaf.
-} HuffmanTreeNode;
-
-// Huffman Tree.
-#define HUFF_LUT_BITS 7
-#define HUFF_LUT (1U << HUFF_LUT_BITS)
-typedef struct HuffmanTree HuffmanTree;
-struct HuffmanTree {
-  // Fast lookup for short bit lengths.
-  uint8_t lut_bits_[HUFF_LUT];
-  int16_t lut_symbol_[HUFF_LUT];
-  int16_t lut_jump_[HUFF_LUT];
-  // Complete tree for lookups.
-  HuffmanTreeNode* root_;   // all the nodes, starting at root.
-  int max_nodes_;           // max number of nodes
-  int num_nodes_;           // number of currently occupied nodes
-};
-
-// Huffman Tree group.
-typedef struct HTreeGroup HTreeGroup;
-struct HTreeGroup {
-  HuffmanTree htrees_[HUFFMAN_CODES_PER_META_CODE];
-};
-
-// Returns true if the given node is not a leaf of the Huffman tree.
-static WEBP_INLINE int HuffmanTreeNodeIsNotLeaf(
-    const HuffmanTreeNode* const node) {
-  return node->children_;
-}
-
-// Go down one level. Most critical function. 'right_child' must be 0 or 1.
-static WEBP_INLINE const HuffmanTreeNode* HuffmanTreeNextNode(
-    const HuffmanTreeNode* node, int right_child) {
-  return node + node->children_ + right_child;
-}
-
-// Releases the nodes of the Huffman tree.
-// Note: It does NOT free 'tree' itself.
-void VP8LHuffmanTreeFree(HuffmanTree* const tree);
-
-// Creates the instance of HTreeGroup with specified number of tree-groups.
-HTreeGroup* VP8LHtreeGroupsNew(int num_htree_groups);
-
-// Releases the memory allocated for HTreeGroup.
-void VP8LHtreeGroupsFree(HTreeGroup* htree_groups, int num_htree_groups);
-
-// Builds Huffman tree assuming code lengths are implicitly in symbol order.
-// The 'huff_codes' and 'code_lengths' are pre-allocated temporary memory
-// buffers, used for creating the huffman tree.
-// Returns false in case of error (invalid tree or memory error).
-int VP8LHuffmanTreeBuildImplicit(HuffmanTree* const tree,
-                                 const int* const code_lengths,
-                                 int* const huff_codes,
-                                 int code_lengths_size);
-
-// Build a Huffman tree with explicitly given lists of code lengths, codes
-// and symbols. Verifies that all symbols added are smaller than max_symbol.
-// Returns false in case of an invalid symbol, invalid tree or memory error.
-int VP8LHuffmanTreeBuildExplicit(HuffmanTree* const tree,
-                                 const int* const code_lengths,
-                                 const int* const codes,
-                                 const int* const symbols, int max_symbol,
-                                 int num_symbols);
-
-// Utility: converts Huffman code lengths to corresponding Huffman codes.
-// 'huff_codes' should be pre-allocated.
-// Returns false in case of error (memory allocation, invalid codes).
-int VP8LHuffmanCodeLengthsToCodes(const int* const code_lengths,
-                                  int code_lengths_size, int* const huff_codes);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  // WEBP_UTILS_HUFFMAN_H_
diff --git a/src/main/jni/libwebp/utils/huffman_encode.c b/src/main/jni/libwebp/utils/huffman_encode.c
deleted file mode 100644
index 6421c2bee..000000000
--- a/src/main/jni/libwebp/utils/huffman_encode.c
+++ /dev/null
@@ -1,417 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Author: Jyrki Alakuijala (jyrki@google.com)
-//
-// Entropy encoding (Huffman) for webp lossless.
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include "./huffman_encode.h"
-#include "../utils/utils.h"
-#include "../webp/format_constants.h"
-
-// -----------------------------------------------------------------------------
-// Util function to optimize the symbol map for RLE coding
-
-// Heuristics for selecting the stride ranges to collapse.
-static int ValuesShouldBeCollapsedToStrideAverage(int a, int b) {
-  return abs(a - b) < 4;
-}
-
-// Change the population counts in a way that the consequent
-// Huffman tree compression, especially its RLE-part, give smaller output.
-static void OptimizeHuffmanForRle(int length, uint8_t* const good_for_rle,
-                                  uint32_t* const counts) {
-  // 1) Let's make the Huffman code more compatible with rle encoding.
-  int i;
-  for (; length >= 0; --length) {
-    if (length == 0) {
-      return;  // All zeros.
-    }
-    if (counts[length - 1] != 0) {
-      // Now counts[0..length - 1] does not have trailing zeros.
-      break;
-    }
-  }
-  // 2) Let's mark all population counts that already can be encoded
-  // with an rle code.
-  {
-    // Let's not spoil any of the existing good rle codes.
-    // Mark any seq of 0's that is longer as 5 as a good_for_rle.
-    // Mark any seq of non-0's that is longer as 7 as a good_for_rle.
-    uint32_t symbol = counts[0];
-    int stride = 0;
-    for (i = 0; i < length + 1; ++i) {
-      if (i == length || counts[i] != symbol) {
-        if ((symbol == 0 && stride >= 5) ||
-            (symbol != 0 && stride >= 7)) {
-          int k;
-          for (k = 0; k < stride; ++k) {
-            good_for_rle[i - k - 1] = 1;
-          }
-        }
-        stride = 1;
-        if (i != length) {
-          symbol = counts[i];
-        }
-      } else {
-        ++stride;
-      }
-    }
-  }
-  // 3) Let's replace those population counts that lead to more rle codes.
-  {
-    uint32_t stride = 0;
-    uint32_t limit = counts[0];
-    uint32_t sum = 0;
-    for (i = 0; i < length + 1; ++i) {
-      if (i == length || good_for_rle[i] ||
-          (i != 0 && good_for_rle[i - 1]) ||
-          !ValuesShouldBeCollapsedToStrideAverage(counts[i], limit)) {
-        if (stride >= 4 || (stride >= 3 && sum == 0)) {
-          uint32_t k;
-          // The stride must end, collapse what we have, if we have enough (4).
-          uint32_t count = (sum + stride / 2) / stride;
-          if (count < 1) {
-            count = 1;
-          }
-          if (sum == 0) {
-            // Don't make an all zeros stride to be upgraded to ones.
-            count = 0;
-          }
-          for (k = 0; k < stride; ++k) {
-            // We don't want to change value at counts[i],
-            // that is already belonging to the next stride. Thus - 1.
-            counts[i - k - 1] = count;
-          }
-        }
-        stride = 0;
-        sum = 0;
-        if (i < length - 3) {
-          // All interesting strides have a count of at least 4,
-          // at least when non-zeros.
-          limit = (counts[i] + counts[i + 1] +
-                   counts[i + 2] + counts[i + 3] + 2) / 4;
-        } else if (i < length) {
-          limit = counts[i];
-        } else {
-          limit = 0;
-        }
-      }
-      ++stride;
-      if (i != length) {
-        sum += counts[i];
-        if (stride >= 4) {
-          limit = (sum + stride / 2) / stride;
-        }
-      }
-    }
-  }
-}
-
-// A comparer function for two Huffman trees: sorts first by 'total count'
-// (more comes first), and then by 'value' (more comes first).
-static int CompareHuffmanTrees(const void* ptr1, const void* ptr2) {
-  const HuffmanTree* const t1 = (const HuffmanTree*)ptr1;
-  const HuffmanTree* const t2 = (const HuffmanTree*)ptr2;
-  if (t1->total_count_ > t2->total_count_) {
-    return -1;
-  } else if (t1->total_count_ < t2->total_count_) {
-    return 1;
-  } else {
-    assert(t1->value_ != t2->value_);
-    return (t1->value_ < t2->value_) ? -1 : 1;
-  }
-}
-
-static void SetBitDepths(const HuffmanTree* const tree,
-                         const HuffmanTree* const pool,
-                         uint8_t* const bit_depths, int level) {
-  if (tree->pool_index_left_ >= 0) {
-    SetBitDepths(&pool[tree->pool_index_left_], pool, bit_depths, level + 1);
-    SetBitDepths(&pool[tree->pool_index_right_], pool, bit_depths, level + 1);
-  } else {
-    bit_depths[tree->value_] = level;
-  }
-}
-
-// Create an optimal Huffman tree.
-//
-// (data,length): population counts.
-// tree_limit: maximum bit depth (inclusive) of the codes.
-// bit_depths[]: how many bits are used for the symbol.
-//
-// Returns 0 when an error has occurred.
-//
-// The catch here is that the tree cannot be arbitrarily deep
-//
-// count_limit is the value that is to be faked as the minimum value
-// and this minimum value is raised until the tree matches the
-// maximum length requirement.
-//
-// This algorithm is not of excellent performance for very long data blocks,
-// especially when population counts are longer than 2**tree_limit, but
-// we are not planning to use this with extremely long blocks.
-//
-// See http://en.wikipedia.org/wiki/Huffman_coding
-static void GenerateOptimalTree(const uint32_t* const histogram,
-                                int histogram_size,
-                                HuffmanTree* tree, int tree_depth_limit,
-                                uint8_t* const bit_depths) {
-  uint32_t count_min;
-  HuffmanTree* tree_pool;
-  int tree_size_orig = 0;
-  int i;
-
-  for (i = 0; i < histogram_size; ++i) {
-    if (histogram[i] != 0) {
-      ++tree_size_orig;
-    }
-  }
-
-  if (tree_size_orig == 0) {   // pretty optimal already!
-    return;
-  }
-
-  tree_pool = tree + tree_size_orig;
-
-  // For block sizes with less than 64k symbols we never need to do a
-  // second iteration of this loop.
-  // If we actually start running inside this loop a lot, we would perhaps
-  // be better off with the Katajainen algorithm.
-  assert(tree_size_orig <= (1 << (tree_depth_limit - 1)));
-  for (count_min = 1; ; count_min *= 2) {
-    int tree_size = tree_size_orig;
-    // We need to pack the Huffman tree in tree_depth_limit bits.
-    // So, we try by faking histogram entries to be at least 'count_min'.
-    int idx = 0;
-    int j;
-    for (j = 0; j < histogram_size; ++j) {
-      if (histogram[j] != 0) {
-        const uint32_t count =
-            (histogram[j] < count_min) ? count_min : histogram[j];
-        tree[idx].total_count_ = count;
-        tree[idx].value_ = j;
-        tree[idx].pool_index_left_ = -1;
-        tree[idx].pool_index_right_ = -1;
-        ++idx;
-      }
-    }
-
-    // Build the Huffman tree.
-    qsort(tree, tree_size, sizeof(*tree), CompareHuffmanTrees);
-
-    if (tree_size > 1) {  // Normal case.
-      int tree_pool_size = 0;
-      while (tree_size > 1) {  // Finish when we have only one root.
-        uint32_t count;
-        tree_pool[tree_pool_size++] = tree[tree_size - 1];
-        tree_pool[tree_pool_size++] = tree[tree_size - 2];
-        count = tree_pool[tree_pool_size - 1].total_count_ +
-                tree_pool[tree_pool_size - 2].total_count_;
-        tree_size -= 2;
-        {
-          // Search for the insertion point.
-          int k;
-          for (k = 0; k < tree_size; ++k) {
-            if (tree[k].total_count_ <= count) {
-              break;
-            }
-          }
-          memmove(tree + (k + 1), tree + k, (tree_size - k) * sizeof(*tree));
-          tree[k].total_count_ = count;
-          tree[k].value_ = -1;
-
-          tree[k].pool_index_left_ = tree_pool_size - 1;
-          tree[k].pool_index_right_ = tree_pool_size - 2;
-          tree_size = tree_size + 1;
-        }
-      }
-      SetBitDepths(&tree[0], tree_pool, bit_depths, 0);
-    } else if (tree_size == 1) {  // Trivial case: only one element.
-      bit_depths[tree[0].value_] = 1;
-    }
-
-    {
-      // Test if this Huffman tree satisfies our 'tree_depth_limit' criteria.
-      int max_depth = bit_depths[0];
-      for (j = 1; j < histogram_size; ++j) {
-        if (max_depth < bit_depths[j]) {
-          max_depth = bit_depths[j];
-        }
-      }
-      if (max_depth <= tree_depth_limit) {
-        break;
-      }
-    }
-  }
-}
-
-// -----------------------------------------------------------------------------
-// Coding of the Huffman tree values
-
-static HuffmanTreeToken* CodeRepeatedValues(int repetitions,
-                                            HuffmanTreeToken* tokens,
-                                            int value, int prev_value) {
-  assert(value <= MAX_ALLOWED_CODE_LENGTH);
-  if (value != prev_value) {
-    tokens->code = value;
-    tokens->extra_bits = 0;
-    ++tokens;
-    --repetitions;
-  }
-  while (repetitions >= 1) {
-    if (repetitions < 3) {
-      int i;
-      for (i = 0; i < repetitions; ++i) {
-        tokens->code = value;
-        tokens->extra_bits = 0;
-        ++tokens;
-      }
-      break;
-    } else if (repetitions < 7) {
-      tokens->code = 16;
-      tokens->extra_bits = repetitions - 3;
-      ++tokens;
-      break;
-    } else {
-      tokens->code = 16;
-      tokens->extra_bits = 3;
-      ++tokens;
-      repetitions -= 6;
-    }
-  }
-  return tokens;
-}
-
-static HuffmanTreeToken* CodeRepeatedZeros(int repetitions,
-                                           HuffmanTreeToken* tokens) {
-  while (repetitions >= 1) {
-    if (repetitions < 3) {
-      int i;
-      for (i = 0; i < repetitions; ++i) {
-        tokens->code = 0;   // 0-value
-        tokens->extra_bits = 0;
-        ++tokens;
-      }
-      break;
-    } else if (repetitions < 11) {
-      tokens->code = 17;
-      tokens->extra_bits = repetitions - 3;
-      ++tokens;
-      break;
-    } else if (repetitions < 139) {
-      tokens->code = 18;
-      tokens->extra_bits = repetitions - 11;
-      ++tokens;
-      break;
-    } else {
-      tokens->code = 18;
-      tokens->extra_bits = 0x7f;  // 138 repeated 0s
-      ++tokens;
-      repetitions -= 138;
-    }
-  }
-  return tokens;
-}
-
-int VP8LCreateCompressedHuffmanTree(const HuffmanTreeCode* const tree,
-                                    HuffmanTreeToken* tokens, int max_tokens) {
-  HuffmanTreeToken* const starting_token = tokens;
-  HuffmanTreeToken* const ending_token = tokens + max_tokens;
-  const int depth_size = tree->num_symbols;
-  int prev_value = 8;  // 8 is the initial value for rle.
-  int i = 0;
-  assert(tokens != NULL);
-  while (i < depth_size) {
-    const int value = tree->code_lengths[i];
-    int k = i + 1;
-    int runs;
-    while (k < depth_size && tree->code_lengths[k] == value) ++k;
-    runs = k - i;
-    if (value == 0) {
-      tokens = CodeRepeatedZeros(runs, tokens);
-    } else {
-      tokens = CodeRepeatedValues(runs, tokens, value, prev_value);
-      prev_value = value;
-    }
-    i += runs;
-    assert(tokens <= ending_token);
-  }
-  (void)ending_token;    // suppress 'unused variable' warning
-  return (int)(tokens - starting_token);
-}
-
-// -----------------------------------------------------------------------------
-
-// Pre-reversed 4-bit values.
-static const uint8_t kReversedBits[16] = {
-  0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
-  0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf
-};
-
-static uint32_t ReverseBits(int num_bits, uint32_t bits) {
-  uint32_t retval = 0;
-  int i = 0;
-  while (i < num_bits) {
-    i += 4;
-    retval |= kReversedBits[bits & 0xf] << (MAX_ALLOWED_CODE_LENGTH + 1 - i);
-    bits >>= 4;
-  }
-  retval >>= (MAX_ALLOWED_CODE_LENGTH + 1 - num_bits);
-  return retval;
-}
-
-// Get the actual bit values for a tree of bit depths.
-static void ConvertBitDepthsToSymbols(HuffmanTreeCode* const tree) {
-  // 0 bit-depth means that the symbol does not exist.
-  int i;
-  int len;
-  uint32_t next_code[MAX_ALLOWED_CODE_LENGTH + 1];
-  int depth_count[MAX_ALLOWED_CODE_LENGTH + 1] = { 0 };
-
-  assert(tree != NULL);
-  len = tree->num_symbols;
-  for (i = 0; i < len; ++i) {
-    const int code_length = tree->code_lengths[i];
-    assert(code_length <= MAX_ALLOWED_CODE_LENGTH);
-    ++depth_count[code_length];
-  }
-  depth_count[0] = 0;  // ignore unused symbol
-  next_code[0] = 0;
-  {
-    uint32_t code = 0;
-    for (i = 1; i <= MAX_ALLOWED_CODE_LENGTH; ++i) {
-      code = (code + depth_count[i - 1]) << 1;
-      next_code[i] = code;
-    }
-  }
-  for (i = 0; i < len; ++i) {
-    const int code_length = tree->code_lengths[i];
-    tree->codes[i] = ReverseBits(code_length, next_code[code_length]++);
-  }
-}
-
-// -----------------------------------------------------------------------------
-// Main entry point
-
-void VP8LCreateHuffmanTree(uint32_t* const histogram, int tree_depth_limit,
-                           uint8_t* const buf_rle,
-                           HuffmanTree* const huff_tree,
-                           HuffmanTreeCode* const huff_code) {
-  const int num_symbols = huff_code->num_symbols;
-  memset(buf_rle, 0, num_symbols * sizeof(*buf_rle));
-  OptimizeHuffmanForRle(num_symbols, buf_rle, histogram);
-  GenerateOptimalTree(histogram, num_symbols, huff_tree, tree_depth_limit,
-                      huff_code->code_lengths);
-  // Create the actual bit codes for the bit lengths.
-  ConvertBitDepthsToSymbols(huff_code);
-}
diff --git a/src/main/jni/libwebp/utils/huffman_encode.h b/src/main/jni/libwebp/utils/huffman_encode.h
deleted file mode 100644
index 91aa18f46..000000000
--- a/src/main/jni/libwebp/utils/huffman_encode.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Author: Jyrki Alakuijala (jyrki@google.com)
-//
-// Entropy encoding (Huffman) for webp lossless
-
-#ifndef WEBP_UTILS_HUFFMAN_ENCODE_H_
-#define WEBP_UTILS_HUFFMAN_ENCODE_H_
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Struct for holding the tree header in coded form.
-typedef struct {
-  uint8_t code;         // value (0..15) or escape code (16,17,18)
-  uint8_t extra_bits;   // extra bits for escape codes
-} HuffmanTreeToken;
-
-// Struct to represent the tree codes (depth and bits array).
-typedef struct {
-  int       num_symbols;   // Number of symbols.
-  uint8_t*  code_lengths;  // Code lengths of the symbols.
-  uint16_t* codes;         // Symbol Codes.
-} HuffmanTreeCode;
-
-// Struct to represent the Huffman tree.
-// TODO(vikasa): Add comment for the fields of the Struct.
-typedef struct {
-  uint32_t total_count_;
-  int value_;
-  int pool_index_left_;    // Index for the left sub-tree.
-  int pool_index_right_;   // Index for the right sub-tree.
-} HuffmanTree;
-
-// Turn the Huffman tree into a token sequence.
-// Returns the number of tokens used.
-int VP8LCreateCompressedHuffmanTree(const HuffmanTreeCode* const tree,
-                                    HuffmanTreeToken* tokens, int max_tokens);
-
-// Create an optimized tree, and tokenize it.
-// 'buf_rle' and 'huff_tree' are pre-allocated and the 'tree' is the constructed
-// huffman code tree.
-void VP8LCreateHuffmanTree(uint32_t* const histogram, int tree_depth_limit,
-                           uint8_t* const buf_rle, HuffmanTree* const huff_tree,
-                           HuffmanTreeCode* const tree);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // WEBP_UTILS_HUFFMAN_ENCODE_H_
diff --git a/src/main/jni/libwebp/utils/quant_levels.c b/src/main/jni/libwebp/utils/quant_levels.c
deleted file mode 100644
index d7c8aab92..000000000
--- a/src/main/jni/libwebp/utils/quant_levels.c
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Quantize levels for specified number of quantization-levels ([2, 256]).
-// Min and max values are preserved (usual 0 and 255 for alpha plane).
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <assert.h>
-
-#include "./quant_levels.h"
-
-#define NUM_SYMBOLS     256
-
-#define MAX_ITER  6             // Maximum number of convergence steps.
-#define ERROR_THRESHOLD 1e-4    // MSE stopping criterion.
-
-// -----------------------------------------------------------------------------
-// Quantize levels.
-
-int QuantizeLevels(uint8_t* const data, int width, int height,
-                   int num_levels, uint64_t* const sse) {
-  int freq[NUM_SYMBOLS] = { 0 };
-  int q_level[NUM_SYMBOLS] = { 0 };
-  double inv_q_level[NUM_SYMBOLS] = { 0 };
-  int min_s = 255, max_s = 0;
-  const size_t data_size = height * width;
-  int i, num_levels_in, iter;
-  double last_err = 1.e38, err = 0.;
-  const double err_threshold = ERROR_THRESHOLD * data_size;
-
-  if (data == NULL) {
-    return 0;
-  }
-
-  if (width <= 0 || height <= 0) {
-    return 0;
-  }
-
-  if (num_levels < 2 || num_levels > 256) {
-    return 0;
-  }
-
-  {
-    size_t n;
-    num_levels_in = 0;
-    for (n = 0; n < data_size; ++n) {
-      num_levels_in += (freq[data[n]] == 0);
-      if (min_s > data[n]) min_s = data[n];
-      if (max_s < data[n]) max_s = data[n];
-      ++freq[data[n]];
-    }
-  }
-
-  if (num_levels_in <= num_levels) goto End;  // nothing to do!
-
-  // Start with uniformly spread centroids.
-  for (i = 0; i < num_levels; ++i) {
-    inv_q_level[i] = min_s + (double)(max_s - min_s) * i / (num_levels - 1);
-  }
-
-  // Fixed values. Won't be changed.
-  q_level[min_s] = 0;
-  q_level[max_s] = num_levels - 1;
-  assert(inv_q_level[0] == min_s);
-  assert(inv_q_level[num_levels - 1] == max_s);
-
-  // k-Means iterations.
-  for (iter = 0; iter < MAX_ITER; ++iter) {
-    double q_sum[NUM_SYMBOLS] = { 0 };
-    double q_count[NUM_SYMBOLS] = { 0 };
-    int s, slot = 0;
-
-    // Assign classes to representatives.
-    for (s = min_s; s <= max_s; ++s) {
-      // Keep track of the nearest neighbour 'slot'
-      while (slot < num_levels - 1 &&
-             2 * s > inv_q_level[slot] + inv_q_level[slot + 1]) {
-        ++slot;
-      }
-      if (freq[s] > 0) {
-        q_sum[slot] += s * freq[s];
-        q_count[slot] += freq[s];
-      }
-      q_level[s] = slot;
-    }
-
-    // Assign new representatives to classes.
-    if (num_levels > 2) {
-      for (slot = 1; slot < num_levels - 1; ++slot) {
-        const double count = q_count[slot];
-        if (count > 0.) {
-          inv_q_level[slot] = q_sum[slot] / count;
-        }
-      }
-    }
-
-    // Compute convergence error.
-    err = 0.;
-    for (s = min_s; s <= max_s; ++s) {
-      const double error = s - inv_q_level[q_level[s]];
-      err += freq[s] * error * error;
-    }
-
-    // Check for convergence: we stop as soon as the error is no
-    // longer improving.
-    if (last_err - err < err_threshold) break;
-    last_err = err;
-  }
-
-  // Remap the alpha plane to quantized values.
-  {
-    // double->int rounding operation can be costly, so we do it
-    // once for all before remapping. We also perform the data[] -> slot
-    // mapping, while at it (avoid one indirection in the final loop).
-    uint8_t map[NUM_SYMBOLS];
-    int s;
-    size_t n;
-    for (s = min_s; s <= max_s; ++s) {
-      const int slot = q_level[s];
-      map[s] = (uint8_t)(inv_q_level[slot] + .5);
-    }
-    // Final pass.
-    for (n = 0; n < data_size; ++n) {
-      data[n] = map[data[n]];
-    }
-  }
- End:
-  // Store sum of squared error if needed.
-  if (sse != NULL) *sse = (uint64_t)err;
-
-  return 1;
-}
-
diff --git a/src/main/jni/libwebp/utils/quant_levels.h b/src/main/jni/libwebp/utils/quant_levels.h
deleted file mode 100644
index 1cb5a32ca..000000000
--- a/src/main/jni/libwebp/utils/quant_levels.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Alpha plane quantization utility
-//
-// Author:  Vikas Arora (vikasa@google.com)
-
-#ifndef WEBP_UTILS_QUANT_LEVELS_H_
-#define WEBP_UTILS_QUANT_LEVELS_H_
-
-#include <stdlib.h>
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Replace the input 'data' of size 'width'x'height' with 'num-levels'
-// quantized values. If not NULL, 'sse' will contain the sum of squared error.
-// Valid range for 'num_levels' is [2, 256].
-// Returns false in case of error (data is NULL, or parameters are invalid).
-int QuantizeLevels(uint8_t* const data, int width, int height, int num_levels,
-                   uint64_t* const sse);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_QUANT_LEVELS_H_ */
diff --git a/src/main/jni/libwebp/utils/quant_levels_dec.c b/src/main/jni/libwebp/utils/quant_levels_dec.c
deleted file mode 100644
index 5b8b8b49e..000000000
--- a/src/main/jni/libwebp/utils/quant_levels_dec.c
+++ /dev/null
@@ -1,279 +0,0 @@
-// Copyright 2013 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.
-// -----------------------------------------------------------------------------
-//
-// Implement gradient smoothing: we replace a current alpha value by its
-// surrounding average if it's close enough (that is: the change will be less
-// than the minimum distance between two quantized level).
-// We use sliding window for computing the 2d moving average.
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include "./quant_levels_dec.h"
-
-#include <string.h>   // for memset
-
-#include "./utils.h"
-
-// #define USE_DITHERING   // uncomment to enable ordered dithering (not vital)
-
-#define FIX 16     // fix-point precision for averaging
-#define LFIX 2     // extra precision for look-up table
-#define LUT_SIZE ((1 << (8 + LFIX)) - 1)  // look-up table size
-
-#if defined(USE_DITHERING)
-
-#define DFIX 4           // extra precision for ordered dithering
-#define DSIZE 4          // dithering size (must be a power of two)
-// cf. http://en.wikipedia.org/wiki/Ordered_dithering
-static const uint8_t kOrderedDither[DSIZE][DSIZE] = {
-  {  0,  8,  2, 10 },     // coefficients are in DFIX fixed-point precision
-  { 12,  4, 14,  6 },
-  {  3, 11,  1,  9 },
-  { 15,  7, 13,  5 }
-};
-
-#else
-#define DFIX 0
-#endif
-
-typedef struct {
-  int width_, height_;  // dimension
-  int row_;             // current input row being processed
-  uint8_t* src_;        // input pointer
-  uint8_t* dst_;        // output pointer
-
-  int radius_;          // filter radius (=delay)
-  int scale_;           // normalization factor, in FIX bits precision
-
-  void* mem_;           // all memory
-
-  // various scratch buffers
-  uint16_t* start_;
-  uint16_t* cur_;
-  uint16_t* end_;
-  uint16_t* top_;
-  uint16_t* average_;
-
-  // input levels distribution
-  int num_levels_;       // number of quantized levels
-  int min_, max_;        // min and max level values
-  int min_level_dist_;   // smallest distance between two consecutive levels
-
-  int16_t* correction_;  // size = 1 + 2*LUT_SIZE  -> ~4k memory
-} SmoothParams;
-
-//------------------------------------------------------------------------------
-
-#define CLIP_MASK (int)(~0U << (8 + DFIX))
-static WEBP_INLINE uint8_t clip_8b(int v) {
-  return (!(v & CLIP_MASK)) ? (uint8_t)(v >> DFIX) : (v < 0) ? 0u : 255u;
-}
-
-// vertical accumulation
-static void VFilter(SmoothParams* const p) {
-  const uint8_t* src = p->src_;
-  const int w = p->width_;
-  uint16_t* const cur = p->cur_;
-  const uint16_t* const top = p->top_;
-  uint16_t* const out = p->end_;
-  uint16_t sum = 0;               // all arithmetic is modulo 16bit
-  int x;
-
-  for (x = 0; x < w; ++x) {
-    uint16_t new_value;
-    sum += src[x];
-    new_value = top[x] + sum;
-    out[x] = new_value - cur[x];  // vertical sum of 'r' pixels.
-    cur[x] = new_value;
-  }
-  // move input pointers one row down
-  p->top_ = p->cur_;
-  p->cur_ += w;
-  if (p->cur_ == p->end_) p->cur_ = p->start_;  // roll-over
-  // We replicate edges, as it's somewhat easier as a boundary condition.
-  // That's why we don't update the 'src' pointer on top/bottom area:
-  if (p->row_ >= 0 && p->row_ < p->height_ - 1) {
-    p->src_ += p->width_;
-  }
-}
-
-// horizontal accumulation. We use mirror replication of missing pixels, as it's
-// a little easier to implement (surprisingly).
-static void HFilter(SmoothParams* const p) {
-  const uint16_t* const in = p->end_;
-  uint16_t* const out = p->average_;
-  const uint32_t scale = p->scale_;
-  const int w = p->width_;
-  const int r = p->radius_;
-
-  int x;
-  for (x = 0; x <= r; ++x) {   // left mirroring
-    const uint16_t delta = in[x + r - 1] + in[r - x];
-    out[x] = (delta * scale) >> FIX;
-  }
-  for (; x < w - r; ++x) {     // bulk middle run
-    const uint16_t delta = in[x + r] - in[x - r - 1];
-    out[x] = (delta * scale) >> FIX;
-  }
-  for (; x < w; ++x) {         // right mirroring
-    const uint16_t delta =
-        2 * in[w - 1] - in[2 * w - 2 - r - x] - in[x - r - 1];
-    out[x] = (delta * scale) >> FIX;
-  }
-}
-
-// emit one filtered output row
-static void ApplyFilter(SmoothParams* const p) {
-  const uint16_t* const average = p->average_;
-  const int w = p->width_;
-  const int16_t* const correction = p->correction_;
-#if defined(USE_DITHERING)
-  const uint8_t* const dither = kOrderedDither[p->row_ % DSIZE];
-#endif
-  uint8_t* const dst = p->dst_;
-  int x;
-  for (x = 0; x < w; ++x) {
-    const int v = dst[x];
-    if (v < p->max_ && v > p->min_) {
-      const int c = (v << DFIX) + correction[average[x] - (v << LFIX)];
-#if defined(USE_DITHERING)
-      dst[x] = clip_8b(c + dither[x % DSIZE]);
-#else
-      dst[x] = clip_8b(c);
-#endif
-    }
-  }
-  p->dst_ += w;  // advance output pointer
-}
-
-//------------------------------------------------------------------------------
-// Initialize correction table
-
-static void InitCorrectionLUT(int16_t* const lut, int min_dist) {
-  // The correction curve is:
-  //   f(x) = x for x <= threshold2
-  //   f(x) = 0 for x >= threshold1
-  // and a linear interpolation for range x=[threshold2, threshold1]
-  // (along with f(-x) = -f(x) symmetry).
-  // Note that: threshold2 = 3/4 * threshold1
-  const int threshold1 = min_dist << LFIX;
-  const int threshold2 = (3 * threshold1) >> 2;
-  const int max_threshold = threshold2 << DFIX;
-  const int delta = threshold1 - threshold2;
-  int i;
-  for (i = 1; i <= LUT_SIZE; ++i) {
-    int c = (i <= threshold2) ? (i << DFIX)
-          : (i < threshold1) ? max_threshold * (threshold1 - i) / delta
-          : 0;
-    c >>= LFIX;
-    lut[+i] = +c;
-    lut[-i] = -c;
-  }
-  lut[0] = 0;
-}
-
-static void CountLevels(const uint8_t* const data, int size,
-                        SmoothParams* const p) {
-  int i, last_level;
-  uint8_t used_levels[256] = { 0 };
-  p->min_ = 255;
-  p->max_ = 0;
-  for (i = 0; i < size; ++i) {
-    const int v = data[i];
-    if (v < p->min_) p->min_ = v;
-    if (v > p->max_) p->max_ = v;
-    used_levels[v] = 1;
-  }
-  // Compute the mininum distance between two non-zero levels.
-  p->min_level_dist_ = p->max_ - p->min_;
-  last_level = -1;
-  for (i = 0; i < 256; ++i) {
-    if (used_levels[i]) {
-      ++p->num_levels_;
-      if (last_level >= 0) {
-        const int level_dist = i - last_level;
-        if (level_dist < p->min_level_dist_) {
-          p->min_level_dist_ = level_dist;
-        }
-      }
-      last_level = i;
-    }
-  }
-}
-
-// Initialize all params.
-static int InitParams(uint8_t* const data, int width, int height,
-                      int radius, SmoothParams* const p) {
-  const int R = 2 * radius + 1;  // total size of the kernel
-
-  const size_t size_scratch_m = (R + 1) * width * sizeof(*p->start_);
-  const size_t size_m =  width * sizeof(*p->average_);
-  const size_t size_lut = (1 + 2 * LUT_SIZE) * sizeof(*p->correction_);
-  const size_t total_size = size_scratch_m + size_m + size_lut;
-  uint8_t* mem = (uint8_t*)WebPSafeMalloc(1U, total_size);
-
-  if (mem == NULL) return 0;
-  p->mem_ = (void*)mem;
-
-  p->start_ = (uint16_t*)mem;
-  p->cur_ = p->start_;
-  p->end_ = p->start_ + R * width;
-  p->top_ = p->end_ - width;
-  memset(p->top_, 0, width * sizeof(*p->top_));
-  mem += size_scratch_m;
-
-  p->average_ = (uint16_t*)mem;
-  mem += size_m;
-
-  p->width_ = width;
-  p->height_ = height;
-  p->src_ = data;
-  p->dst_ = data;
-  p->radius_ = radius;
-  p->scale_ = (1 << (FIX + LFIX)) / (R * R);  // normalization constant
-  p->row_ = -radius;
-
-  // analyze the input distribution so we can best-fit the threshold
-  CountLevels(data, width * height, p);
-
-  // correction table
-  p->correction_ = ((int16_t*)mem) + LUT_SIZE;
-  InitCorrectionLUT(p->correction_, p->min_level_dist_);
-
-  return 1;
-}
-
-static void CleanupParams(SmoothParams* const p) {
-  WebPSafeFree(p->mem_);
-}
-
-int WebPDequantizeLevels(uint8_t* const data, int width, int height,
-                         int strength) {
-  const int radius = 4 * strength / 100;
-  if (strength < 0 || strength > 100) return 0;
-  if (data == NULL || width <= 0 || height <= 0) return 0;  // bad params
-  if (radius > 0) {
-    SmoothParams p;
-    memset(&p, 0, sizeof(p));
-    if (!InitParams(data, width, height, radius, &p)) return 0;
-    if (p.num_levels_ > 2) {
-      for (; p.row_ < p.height_; ++p.row_) {
-        VFilter(&p);  // accumulate average of input
-        // Need to wait few rows in order to prime the filter,
-        // before emitting some output.
-        if (p.row_ >= p.radius_) {
-          HFilter(&p);
-          ApplyFilter(&p);
-        }
-      }
-    }
-    CleanupParams(&p);
-  }
-  return 1;
-}
diff --git a/src/main/jni/libwebp/utils/quant_levels_dec.h b/src/main/jni/libwebp/utils/quant_levels_dec.h
deleted file mode 100644
index 9aab06807..000000000
--- a/src/main/jni/libwebp/utils/quant_levels_dec.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2013 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.
-// -----------------------------------------------------------------------------
-//
-// Alpha plane de-quantization utility
-//
-// Author:  Vikas Arora (vikasa@google.com)
-
-#ifndef WEBP_UTILS_QUANT_LEVELS_DEC_H_
-#define WEBP_UTILS_QUANT_LEVELS_DEC_H_
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Apply post-processing to input 'data' of size 'width'x'height' assuming that
-// the source was quantized to a reduced number of levels.
-// Strength is in [0..100] and controls the amount of dithering applied.
-// Returns false in case of error (data is NULL, invalid parameters,
-// malloc failure, ...).
-int WebPDequantizeLevels(uint8_t* const data, int width, int height,
-                         int strength);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_QUANT_LEVELS_DEC_H_ */
diff --git a/src/main/jni/libwebp/utils/random.c b/src/main/jni/libwebp/utils/random.c
deleted file mode 100644
index 24e96ad64..000000000
--- a/src/main/jni/libwebp/utils/random.c
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2013 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.
-// -----------------------------------------------------------------------------
-//
-// Pseudo-random utilities
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <string.h>
-#include "./random.h"
-
-//------------------------------------------------------------------------------
-
-// 31b-range values
-static const uint32_t kRandomTable[VP8_RANDOM_TABLE_SIZE] = {
-  0x0de15230, 0x03b31886, 0x775faccb, 0x1c88626a, 0x68385c55, 0x14b3b828,
-  0x4a85fef8, 0x49ddb84b, 0x64fcf397, 0x5c550289, 0x4a290000, 0x0d7ec1da,
-  0x5940b7ab, 0x5492577d, 0x4e19ca72, 0x38d38c69, 0x0c01ee65, 0x32a1755f,
-  0x5437f652, 0x5abb2c32, 0x0faa57b1, 0x73f533e7, 0x685feeda, 0x7563cce2,
-  0x6e990e83, 0x4730a7ed, 0x4fc0d9c6, 0x496b153c, 0x4f1403fa, 0x541afb0c,
-  0x73990b32, 0x26d7cb1c, 0x6fcc3706, 0x2cbb77d8, 0x75762f2a, 0x6425ccdd,
-  0x24b35461, 0x0a7d8715, 0x220414a8, 0x141ebf67, 0x56b41583, 0x73e502e3,
-  0x44cab16f, 0x28264d42, 0x73baaefb, 0x0a50ebed, 0x1d6ab6fb, 0x0d3ad40b,
-  0x35db3b68, 0x2b081e83, 0x77ce6b95, 0x5181e5f0, 0x78853bbc, 0x009f9494,
-  0x27e5ed3c
-};
-
-void VP8InitRandom(VP8Random* const rg, float dithering) {
-  memcpy(rg->tab_, kRandomTable, sizeof(rg->tab_));
-  rg->index1_ = 0;
-  rg->index2_ = 31;
-  rg->amp_ = (dithering < 0.0) ? 0
-           : (dithering > 1.0) ? (1 << VP8_RANDOM_DITHER_FIX)
-           : (uint32_t)((1 << VP8_RANDOM_DITHER_FIX) * dithering);
-}
-
-//------------------------------------------------------------------------------
-
diff --git a/src/main/jni/libwebp/utils/random.h b/src/main/jni/libwebp/utils/random.h
deleted file mode 100644
index c392a615c..000000000
--- a/src/main/jni/libwebp/utils/random.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2013 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.
-// -----------------------------------------------------------------------------
-//
-// Pseudo-random utilities
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#ifndef WEBP_UTILS_RANDOM_H_
-#define WEBP_UTILS_RANDOM_H_
-
-#include <assert.h>
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define VP8_RANDOM_DITHER_FIX 8   // fixed-point precision for dithering
-#define VP8_RANDOM_TABLE_SIZE 55
-
-typedef struct {
-  int index1_, index2_;
-  uint32_t tab_[VP8_RANDOM_TABLE_SIZE];
-  int amp_;
-} VP8Random;
-
-// Initializes random generator with an amplitude 'dithering' in range [0..1].
-void VP8InitRandom(VP8Random* const rg, float dithering);
-
-// Returns a centered pseudo-random number with 'num_bits' amplitude.
-// (uses D.Knuth's Difference-based random generator).
-// 'amp' is in VP8_RANDOM_DITHER_FIX fixed-point precision.
-static WEBP_INLINE int VP8RandomBits2(VP8Random* const rg, int num_bits,
-                                      int amp) {
-  int diff;
-  assert(num_bits + VP8_RANDOM_DITHER_FIX <= 31);
-  diff = rg->tab_[rg->index1_] - rg->tab_[rg->index2_];
-  if (diff < 0) diff += (1u << 31);
-  rg->tab_[rg->index1_] = diff;
-  if (++rg->index1_ == VP8_RANDOM_TABLE_SIZE) rg->index1_ = 0;
-  if (++rg->index2_ == VP8_RANDOM_TABLE_SIZE) rg->index2_ = 0;
-  // sign-extend, 0-center
-  diff = (int)((uint32_t)diff << 1) >> (32 - num_bits);
-  diff = (diff * amp) >> VP8_RANDOM_DITHER_FIX;  // restrict range
-  diff += 1 << (num_bits - 1);                   // shift back to 0.5-center
-  return diff;
-}
-
-static WEBP_INLINE int VP8RandomBits(VP8Random* const rg, int num_bits) {
-  return VP8RandomBits2(rg, num_bits, rg->amp_);
-}
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_RANDOM_H_ */
diff --git a/src/main/jni/libwebp/utils/rescaler.c b/src/main/jni/libwebp/utils/rescaler.c
deleted file mode 100644
index fad9c6b0e..000000000
--- a/src/main/jni/libwebp/utils/rescaler.c
+++ /dev/null
@@ -1,333 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Rescaling functions
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <assert.h>
-#include <stdlib.h>
-#include "./rescaler.h"
-#include "../dsp/dsp.h"
-
-//------------------------------------------------------------------------------
-// Implementations of critical functions ImportRow / ExportRow
-
-void (*WebPRescalerImportRow)(WebPRescaler* const wrk,
-                              const uint8_t* const src, int channel) = NULL;
-void (*WebPRescalerExportRow)(WebPRescaler* const wrk, int x_out) = NULL;
-
-#define RFIX 30
-#define MULT_FIX(x, y) (((int64_t)(x) * (y) + (1 << (RFIX - 1))) >> RFIX)
-
-static void ImportRowC(WebPRescaler* const wrk,
-                       const uint8_t* const src, int channel) {
-  const int x_stride = wrk->num_channels;
-  const int x_out_max = wrk->dst_width * wrk->num_channels;
-  int x_in = channel;
-  int x_out;
-  int accum = 0;
-  if (!wrk->x_expand) {
-    int sum = 0;
-    for (x_out = channel; x_out < x_out_max; x_out += x_stride) {
-      accum += wrk->x_add;
-      for (; accum > 0; accum -= wrk->x_sub) {
-        sum += src[x_in];
-        x_in += x_stride;
-      }
-      {        // Emit next horizontal pixel.
-        const int32_t base = src[x_in];
-        const int32_t frac = base * (-accum);
-        x_in += x_stride;
-        wrk->frow[x_out] = (sum + base) * wrk->x_sub - frac;
-        // fresh fractional start for next pixel
-        sum = (int)MULT_FIX(frac, wrk->fx_scale);
-      }
-    }
-  } else {        // simple bilinear interpolation
-    int left = src[channel], right = src[channel];
-    for (x_out = channel; x_out < x_out_max; x_out += x_stride) {
-      if (accum < 0) {
-        left = right;
-        x_in += x_stride;
-        right = src[x_in];
-        accum += wrk->x_add;
-      }
-      wrk->frow[x_out] = right * wrk->x_add + (left - right) * accum;
-      accum -= wrk->x_sub;
-    }
-  }
-  // Accumulate the contribution of the new row.
-  for (x_out = channel; x_out < x_out_max; x_out += x_stride) {
-    wrk->irow[x_out] += wrk->frow[x_out];
-  }
-}
-
-static void ExportRowC(WebPRescaler* const wrk, int x_out) {
-  if (wrk->y_accum <= 0) {
-    uint8_t* const dst = wrk->dst;
-    int32_t* const irow = wrk->irow;
-    const int32_t* const frow = wrk->frow;
-    const int yscale = wrk->fy_scale * (-wrk->y_accum);
-    const int x_out_max = wrk->dst_width * wrk->num_channels;
-    for (; x_out < x_out_max; ++x_out) {
-      const int frac = (int)MULT_FIX(frow[x_out], yscale);
-      const int v = (int)MULT_FIX(irow[x_out] - frac, wrk->fxy_scale);
-      dst[x_out] = (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255;
-      irow[x_out] = frac;   // new fractional start
-    }
-    wrk->y_accum += wrk->y_add;
-    wrk->dst += wrk->dst_stride;
-  }
-}
-
-//------------------------------------------------------------------------------
-// MIPS version
-
-#if defined(WEBP_USE_MIPS32)
-
-static void ImportRowMIPS(WebPRescaler* const wrk,
-                          const uint8_t* const src, int channel) {
-  const int x_stride = wrk->num_channels;
-  const int x_out_max = wrk->dst_width * wrk->num_channels;
-  const int fx_scale = wrk->fx_scale;
-  const int x_add = wrk->x_add;
-  const int x_sub = wrk->x_sub;
-  int* frow = wrk->frow + channel;
-  int* irow = wrk->irow + channel;
-  const uint8_t* src1 = src + channel;
-  int temp1, temp2, temp3;
-  int base, frac, sum;
-  int accum, accum1;
-  const int x_stride1 = x_stride << 2;
-  int loop_c = x_out_max - channel;
-
-  if (!wrk->x_expand) {
-    __asm__ volatile (
-      "li     %[temp1],   0x8000                    \n\t"
-      "li     %[temp2],   0x10000                   \n\t"
-      "li     %[sum],     0                         \n\t"
-      "li     %[accum],   0                         \n\t"
-    "1:                                             \n\t"
-      "addu   %[accum],   %[accum],   %[x_add]      \n\t"
-      "blez   %[accum],   3f                        \n\t"
-    "2:                                             \n\t"
-      "lbu    %[temp3],   0(%[src1])                \n\t"
-      "subu   %[accum],   %[accum],   %[x_sub]      \n\t"
-      "addu   %[src1],    %[src1],    %[x_stride]   \n\t"
-      "addu   %[sum],     %[sum],     %[temp3]      \n\t"
-      "bgtz   %[accum],   2b                        \n\t"
-    "3:                                             \n\t"
-      "lbu    %[base],    0(%[src1])                \n\t"
-      "addu   %[src1],    %[src1],    %[x_stride]   \n\t"
-      "negu   %[accum1],  %[accum]                  \n\t"
-      "mul    %[frac],    %[base],    %[accum1]     \n\t"
-      "addu   %[temp3],   %[sum],     %[base]       \n\t"
-      "mul    %[temp3],   %[temp3],   %[x_sub]      \n\t"
-      "lw     %[base],    0(%[irow])                \n\t"
-      "subu   %[loop_c],  %[loop_c],  %[x_stride]   \n\t"
-      "sll    %[accum1],  %[frac],    2             \n\t"
-      "mult   %[temp1],   %[temp2]                  \n\t"
-      "madd   %[accum1],  %[fx_scale]               \n\t"
-      "mfhi   %[sum]                                \n\t"
-      "subu   %[temp3],   %[temp3],   %[frac]       \n\t"
-      "sw     %[temp3],   0(%[frow])                \n\t"
-      "add    %[base],    %[base],    %[temp3]      \n\t"
-      "sw     %[base],    0(%[irow])                \n\t"
-      "addu   %[irow],    %[irow],    %[x_stride1]  \n\t"
-      "addu   %[frow],    %[frow],    %[x_stride1]  \n\t"
-      "bgtz   %[loop_c],  1b                        \n\t"
-
-      : [accum] "=&r" (accum), [src1] "+r" (src1), [temp3] "=&r" (temp3),
-        [sum] "=&r" (sum), [base] "=&r" (base), [frac] "=&r" (frac),
-        [frow] "+r" (frow), [irow] "+r" (irow), [accum1] "=&r" (accum1),
-        [temp2] "=&r" (temp2), [temp1] "=&r" (temp1)
-      : [x_stride] "r" (x_stride), [fx_scale] "r" (fx_scale),
-        [x_sub] "r" (x_sub), [x_add] "r" (x_add),
-        [loop_c] "r" (loop_c), [x_stride1] "r" (x_stride1)
-      : "memory", "hi", "lo"
-    );
-  } else {
-    __asm__ volatile (
-      "lbu    %[temp1],   0(%[src1])                \n\t"
-      "move   %[temp2],   %[temp1]                  \n\t"
-      "li     %[accum],   0                         \n\t"
-    "1:                                             \n\t"
-      "bgez   %[accum],   2f                        \n\t"
-      "move   %[temp2],   %[temp1]                  \n\t"
-      "addu   %[src1],    %[x_stride]               \n\t"
-      "lbu    %[temp1],   0(%[src1])                \n\t"
-      "addu   %[accum],   %[x_add]                  \n\t"
-    "2:                                             \n\t"
-      "subu   %[temp3],   %[temp2],   %[temp1]      \n\t"
-      "mul    %[temp3],   %[temp3],   %[accum]      \n\t"
-      "mul    %[base],    %[temp1],   %[x_add]      \n\t"
-      "subu   %[accum],   %[accum],   %[x_sub]      \n\t"
-      "lw     %[frac],    0(%[irow])                \n\t"
-      "subu   %[loop_c],  %[loop_c],  %[x_stride]   \n\t"
-      "addu   %[temp3],   %[base],    %[temp3]      \n\t"
-      "sw     %[temp3],   0(%[frow])                \n\t"
-      "addu   %[frow],    %[x_stride1]              \n\t"
-      "addu   %[frac],    %[temp3]                  \n\t"
-      "sw     %[frac],    0(%[irow])                \n\t"
-      "addu   %[irow],    %[x_stride1]              \n\t"
-      "bgtz   %[loop_c],  1b                        \n\t"
-
-      : [src1] "+r" (src1), [accum] "=&r" (accum), [temp1] "=&r" (temp1),
-        [temp2] "=&r" (temp2), [temp3] "=&r" (temp3), [base] "=&r" (base),
-        [frac] "=&r" (frac), [frow] "+r" (frow), [irow] "+r" (irow)
-      : [x_stride] "r" (x_stride), [x_add] "r" (x_add), [x_sub] "r" (x_sub),
-        [x_stride1] "r" (x_stride1), [loop_c] "r" (loop_c)
-      : "memory", "hi", "lo"
-    );
-  }
-}
-
-static void ExportRowMIPS(WebPRescaler* const wrk, int x_out) {
-  if (wrk->y_accum <= 0) {
-    uint8_t* const dst = wrk->dst;
-    int32_t* const irow = wrk->irow;
-    const int32_t* const frow = wrk->frow;
-    const int yscale = wrk->fy_scale * (-wrk->y_accum);
-    const int x_out_max = wrk->dst_width * wrk->num_channels;
-    // if wrk->fxy_scale can fit into 32 bits use optimized code,
-    // otherwise use C code
-    if ((wrk->fxy_scale >> 32) == 0) {
-      int temp0, temp1, temp3, temp4, temp5, temp6, temp7, loop_end;
-      const int temp2 = (int)(wrk->fxy_scale);
-      const int temp8 = x_out_max << 2;
-      uint8_t* dst_t = (uint8_t*)dst;
-      int32_t* irow_t = (int32_t*)irow;
-      const int32_t* frow_t = (const int32_t*)frow;
-
-      __asm__ volatile(
-        "addiu    %[temp6],    $zero,       -256          \n\t"
-        "addiu    %[temp7],    $zero,       255           \n\t"
-        "li       %[temp3],    0x10000                    \n\t"
-        "li       %[temp4],    0x8000                     \n\t"
-        "addu     %[loop_end], %[frow_t],   %[temp8]      \n\t"
-      "1:                                                 \n\t"
-        "lw       %[temp0],    0(%[frow_t])               \n\t"
-        "mult     %[temp3],    %[temp4]                   \n\t"
-        "addiu    %[frow_t],   %[frow_t],   4             \n\t"
-        "sll      %[temp0],    %[temp0],    2             \n\t"
-        "madd     %[temp0],    %[yscale]                  \n\t"
-        "mfhi     %[temp1]                                \n\t"
-        "lw       %[temp0],    0(%[irow_t])               \n\t"
-        "addiu    %[dst_t],    %[dst_t],    1             \n\t"
-        "addiu    %[irow_t],   %[irow_t],   4             \n\t"
-        "subu     %[temp0],    %[temp0],    %[temp1]      \n\t"
-        "mult     %[temp3],    %[temp4]                   \n\t"
-        "sll      %[temp0],    %[temp0],    2             \n\t"
-        "madd     %[temp0],    %[temp2]                   \n\t"
-        "mfhi     %[temp5]                                \n\t"
-        "sw       %[temp1],    -4(%[irow_t])              \n\t"
-        "and      %[temp0],    %[temp5],    %[temp6]      \n\t"
-        "slti     %[temp1],    %[temp5],    0             \n\t"
-        "beqz     %[temp0],    2f                         \n\t"
-        "xor      %[temp5],    %[temp5],    %[temp5]      \n\t"
-        "movz     %[temp5],    %[temp7],    %[temp1]      \n\t"
-      "2:                                                 \n\t"
-        "sb       %[temp5],    -1(%[dst_t])               \n\t"
-        "bne      %[frow_t],   %[loop_end], 1b            \n\t"
-
-        : [temp0]"=&r"(temp0), [temp1]"=&r"(temp1), [temp3]"=&r"(temp3),
-          [temp4]"=&r"(temp4), [temp5]"=&r"(temp5), [temp6]"=&r"(temp6),
-          [temp7]"=&r"(temp7), [frow_t]"+r"(frow_t), [irow_t]"+r"(irow_t),
-          [dst_t]"+r"(dst_t), [loop_end]"=&r"(loop_end)
-        : [temp2]"r"(temp2), [yscale]"r"(yscale), [temp8]"r"(temp8)
-        : "memory", "hi", "lo"
-      );
-      wrk->y_accum += wrk->y_add;
-      wrk->dst += wrk->dst_stride;
-    } else {
-      ExportRowC(wrk, x_out);
-    }
-  }
-}
-#endif   // WEBP_USE_MIPS32
-
-//------------------------------------------------------------------------------
-
-void WebPRescalerInit(WebPRescaler* const wrk, int src_width, int src_height,
-                      uint8_t* const dst, int dst_width, int dst_height,
-                      int dst_stride, int num_channels, int x_add, int x_sub,
-                      int y_add, int y_sub, int32_t* const work) {
-  wrk->x_expand = (src_width < dst_width);
-  wrk->src_width = src_width;
-  wrk->src_height = src_height;
-  wrk->dst_width = dst_width;
-  wrk->dst_height = dst_height;
-  wrk->dst = dst;
-  wrk->dst_stride = dst_stride;
-  wrk->num_channels = num_channels;
-  // for 'x_expand', we use bilinear interpolation
-  wrk->x_add = wrk->x_expand ? (x_sub - 1) : x_add - x_sub;
-  wrk->x_sub = wrk->x_expand ? (x_add - 1) : x_sub;
-  wrk->y_accum = y_add;
-  wrk->y_add = y_add;
-  wrk->y_sub = y_sub;
-  wrk->fx_scale = (1 << RFIX) / x_sub;
-  wrk->fy_scale = (1 << RFIX) / y_sub;
-  wrk->fxy_scale = wrk->x_expand ?
-      ((int64_t)dst_height << RFIX) / (x_sub * src_height) :
-      ((int64_t)dst_height << RFIX) / (x_add * src_height);
-  wrk->irow = work;
-  wrk->frow = work + num_channels * dst_width;
-
-  if (WebPRescalerImportRow == NULL) {
-    WebPRescalerImportRow = ImportRowC;
-    WebPRescalerExportRow = ExportRowC;
-    if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_USE_MIPS32)
-      if (VP8GetCPUInfo(kMIPS32)) {
-        WebPRescalerImportRow = ImportRowMIPS;
-        WebPRescalerExportRow = ExportRowMIPS;
-      }
-#endif
-    }
-  }
-}
-
-#undef MULT_FIX
-#undef RFIX
-
-//------------------------------------------------------------------------------
-// all-in-one calls
-
-int WebPRescaleNeededLines(const WebPRescaler* const wrk, int max_num_lines) {
-  const int num_lines = (wrk->y_accum + wrk->y_sub - 1) / wrk->y_sub;
-  return (num_lines > max_num_lines) ? max_num_lines : num_lines;
-}
-
-int WebPRescalerImport(WebPRescaler* const wrk, int num_lines,
-                       const uint8_t* src, int src_stride) {
-  int total_imported = 0;
-  while (total_imported < num_lines && wrk->y_accum > 0) {
-    int channel;
-    for (channel = 0; channel < wrk->num_channels; ++channel) {
-      WebPRescalerImportRow(wrk, src, channel);
-    }
-    src += src_stride;
-    ++total_imported;
-    wrk->y_accum -= wrk->y_sub;
-  }
-  return total_imported;
-}
-
-int WebPRescalerExport(WebPRescaler* const rescaler) {
-  int total_exported = 0;
-  while (WebPRescalerHasPendingOutput(rescaler)) {
-    WebPRescalerExportRow(rescaler, 0);
-    ++total_exported;
-  }
-  return total_exported;
-}
-
-//------------------------------------------------------------------------------
diff --git a/src/main/jni/libwebp/utils/rescaler.h b/src/main/jni/libwebp/utils/rescaler.h
deleted file mode 100644
index a6f378712..000000000
--- a/src/main/jni/libwebp/utils/rescaler.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Rescaling functions
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#ifndef WEBP_UTILS_RESCALER_H_
-#define WEBP_UTILS_RESCALER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "../webp/types.h"
-
-// Structure used for on-the-fly rescaling
-typedef struct {
-  int x_expand;               // true if we're expanding in the x direction
-  int num_channels;           // bytes to jump between pixels
-  int fy_scale, fx_scale;     // fixed-point scaling factor
-  int64_t fxy_scale;          // ''
-  // we need hpel-precise add/sub increments, for the downsampled U/V planes.
-  int y_accum;                // vertical accumulator
-  int y_add, y_sub;           // vertical increments (add ~= src, sub ~= dst)
-  int x_add, x_sub;           // horizontal increments (add ~= src, sub ~= dst)
-  int src_width, src_height;  // source dimensions
-  int dst_width, dst_height;  // destination dimensions
-  uint8_t* dst;
-  int dst_stride;
-  int32_t* irow, *frow;       // work buffer
-} WebPRescaler;
-
-// Initialize a rescaler given scratch area 'work' and dimensions of src & dst.
-void WebPRescalerInit(WebPRescaler* const rescaler,
-                      int src_width, int src_height,
-                      uint8_t* const dst,
-                      int dst_width, int dst_height, int dst_stride,
-                      int num_channels,
-                      int x_add, int x_sub,
-                      int y_add, int y_sub,
-                      int32_t* const work);
-
-// Returns the number of input lines needed next to produce one output line,
-// considering that the maximum available input lines are 'max_num_lines'.
-int WebPRescaleNeededLines(const WebPRescaler* const rescaler,
-                           int max_num_lines);
-
-// Import multiple rows over all channels, until at least one row is ready to
-// be exported. Returns the actual number of lines that were imported.
-int WebPRescalerImport(WebPRescaler* const rescaler, int num_rows,
-                       const uint8_t* src, int src_stride);
-
-// Import a row of data and save its contribution in the rescaler.
-// 'channel' denotes the channel number to be imported.
-extern void (*WebPRescalerImportRow)(WebPRescaler* const wrk,
-                                     const uint8_t* const src, int channel);
-// Export one row (starting at x_out position) from rescaler.
-extern void (*WebPRescalerExportRow)(WebPRescaler* const wrk, int x_out);
-
-// Return true if there is pending output rows ready.
-static WEBP_INLINE
-int WebPRescalerHasPendingOutput(const WebPRescaler* const rescaler) {
-  return (rescaler->y_accum <= 0);
-}
-
-// Export as many rows as possible. Return the numbers of rows written.
-int WebPRescalerExport(WebPRescaler* const rescaler);
-
-//------------------------------------------------------------------------------
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_RESCALER_H_ */
diff --git a/src/main/jni/libwebp/utils/thread.c b/src/main/jni/libwebp/utils/thread.c
deleted file mode 100644
index 264210ba2..000000000
--- a/src/main/jni/libwebp/utils/thread.c
+++ /dev/null
@@ -1,309 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Multi-threaded worker
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <assert.h>
-#include <string.h>   // for memset()
-#include "./thread.h"
-#include "./utils.h"
-
-#ifdef WEBP_USE_THREAD
-
-#if defined(_WIN32)
-
-#include <windows.h>
-typedef HANDLE pthread_t;
-typedef CRITICAL_SECTION pthread_mutex_t;
-typedef struct {
-  HANDLE waiting_sem_;
-  HANDLE received_sem_;
-  HANDLE signal_event_;
-} pthread_cond_t;
-
-#else  // !_WIN32
-
-#include <pthread.h>
-
-#endif  // _WIN32
-
-struct WebPWorkerImpl {
-  pthread_mutex_t mutex_;
-  pthread_cond_t  condition_;
-  pthread_t       thread_;
-};
-
-#if defined(_WIN32)
-
-//------------------------------------------------------------------------------
-// simplistic pthread emulation layer
-
-#include <process.h>
-
-// _beginthreadex requires __stdcall
-#define THREADFN unsigned int __stdcall
-#define THREAD_RETURN(val) (unsigned int)((DWORD_PTR)val)
-
-static int pthread_create(pthread_t* const thread, const void* attr,
-                          unsigned int (__stdcall *start)(void*), void* arg) {
-  (void)attr;
-  *thread = (pthread_t)_beginthreadex(NULL,   /* void *security */
-                                      0,      /* unsigned stack_size */
-                                      start,
-                                      arg,
-                                      0,      /* unsigned initflag */
-                                      NULL);  /* unsigned *thrdaddr */
-  if (*thread == NULL) return 1;
-  SetThreadPriority(*thread, THREAD_PRIORITY_ABOVE_NORMAL);
-  return 0;
-}
-
-static int pthread_join(pthread_t thread, void** value_ptr) {
-  (void)value_ptr;
-  return (WaitForSingleObject(thread, INFINITE) != WAIT_OBJECT_0 ||
-          CloseHandle(thread) == 0);
-}
-
-// Mutex
-static int pthread_mutex_init(pthread_mutex_t* const mutex, void* mutexattr) {
-  (void)mutexattr;
-  InitializeCriticalSection(mutex);
-  return 0;
-}
-
-static int pthread_mutex_lock(pthread_mutex_t* const mutex) {
-  EnterCriticalSection(mutex);
-  return 0;
-}
-
-static int pthread_mutex_unlock(pthread_mutex_t* const mutex) {
-  LeaveCriticalSection(mutex);
-  return 0;
-}
-
-static int pthread_mutex_destroy(pthread_mutex_t* const mutex) {
-  DeleteCriticalSection(mutex);
-  return 0;
-}
-
-// Condition
-static int pthread_cond_destroy(pthread_cond_t* const condition) {
-  int ok = 1;
-  ok &= (CloseHandle(condition->waiting_sem_) != 0);
-  ok &= (CloseHandle(condition->received_sem_) != 0);
-  ok &= (CloseHandle(condition->signal_event_) != 0);
-  return !ok;
-}
-
-static int pthread_cond_init(pthread_cond_t* const condition, void* cond_attr) {
-  (void)cond_attr;
-  condition->waiting_sem_ = CreateSemaphore(NULL, 0, 1, NULL);
-  condition->received_sem_ = CreateSemaphore(NULL, 0, 1, NULL);
-  condition->signal_event_ = CreateEvent(NULL, FALSE, FALSE, NULL);
-  if (condition->waiting_sem_ == NULL ||
-      condition->received_sem_ == NULL ||
-      condition->signal_event_ == NULL) {
-    pthread_cond_destroy(condition);
-    return 1;
-  }
-  return 0;
-}
-
-static int pthread_cond_signal(pthread_cond_t* const condition) {
-  int ok = 1;
-  if (WaitForSingleObject(condition->waiting_sem_, 0) == WAIT_OBJECT_0) {
-    // a thread is waiting in pthread_cond_wait: allow it to be notified
-    ok = SetEvent(condition->signal_event_);
-    // wait until the event is consumed so the signaler cannot consume
-    // the event via its own pthread_cond_wait.
-    ok &= (WaitForSingleObject(condition->received_sem_, INFINITE) !=
-           WAIT_OBJECT_0);
-  }
-  return !ok;
-}
-
-static int pthread_cond_wait(pthread_cond_t* const condition,
-                             pthread_mutex_t* const mutex) {
-  int ok;
-  // note that there is a consumer available so the signal isn't dropped in
-  // pthread_cond_signal
-  if (!ReleaseSemaphore(condition->waiting_sem_, 1, NULL))
-    return 1;
-  // now unlock the mutex so pthread_cond_signal may be issued
-  pthread_mutex_unlock(mutex);
-  ok = (WaitForSingleObject(condition->signal_event_, INFINITE) ==
-        WAIT_OBJECT_0);
-  ok &= ReleaseSemaphore(condition->received_sem_, 1, NULL);
-  pthread_mutex_lock(mutex);
-  return !ok;
-}
-
-#else  // !_WIN32
-# define THREADFN void*
-# define THREAD_RETURN(val) val
-#endif  // _WIN32
-
-//------------------------------------------------------------------------------
-
-static void Execute(WebPWorker* const worker);  // Forward declaration.
-
-static THREADFN ThreadLoop(void* ptr) {
-  WebPWorker* const worker = (WebPWorker*)ptr;
-  int done = 0;
-  while (!done) {
-    pthread_mutex_lock(&worker->impl_->mutex_);
-    while (worker->status_ == OK) {   // wait in idling mode
-      pthread_cond_wait(&worker->impl_->condition_, &worker->impl_->mutex_);
-    }
-    if (worker->status_ == WORK) {
-      Execute(worker);
-      worker->status_ = OK;
-    } else if (worker->status_ == NOT_OK) {   // finish the worker
-      done = 1;
-    }
-    // signal to the main thread that we're done (for Sync())
-    pthread_cond_signal(&worker->impl_->condition_);
-    pthread_mutex_unlock(&worker->impl_->mutex_);
-  }
-  return THREAD_RETURN(NULL);    // Thread is finished
-}
-
-// main thread state control
-static void ChangeState(WebPWorker* const worker,
-                        WebPWorkerStatus new_status) {
-  // No-op when attempting to change state on a thread that didn't come up.
-  // Checking status_ without acquiring the lock first would result in a data
-  // race.
-  if (worker->impl_ == NULL) return;
-
-  pthread_mutex_lock(&worker->impl_->mutex_);
-  if (worker->status_ >= OK) {
-    // wait for the worker to finish
-    while (worker->status_ != OK) {
-      pthread_cond_wait(&worker->impl_->condition_, &worker->impl_->mutex_);
-    }
-    // assign new status and release the working thread if needed
-    if (new_status != OK) {
-      worker->status_ = new_status;
-      pthread_cond_signal(&worker->impl_->condition_);
-    }
-  }
-  pthread_mutex_unlock(&worker->impl_->mutex_);
-}
-
-#endif  // WEBP_USE_THREAD
-
-//------------------------------------------------------------------------------
-
-static void Init(WebPWorker* const worker) {
-  memset(worker, 0, sizeof(*worker));
-  worker->status_ = NOT_OK;
-}
-
-static int Sync(WebPWorker* const worker) {
-#ifdef WEBP_USE_THREAD
-  ChangeState(worker, OK);
-#endif
-  assert(worker->status_ <= OK);
-  return !worker->had_error;
-}
-
-static int Reset(WebPWorker* const worker) {
-  int ok = 1;
-  worker->had_error = 0;
-  if (worker->status_ < OK) {
-#ifdef WEBP_USE_THREAD
-    worker->impl_ = (WebPWorkerImpl*)WebPSafeCalloc(1, sizeof(*worker->impl_));
-    if (worker->impl_ == NULL) {
-      return 0;
-    }
-    if (pthread_mutex_init(&worker->impl_->mutex_, NULL)) {
-      goto Error;
-    }
-    if (pthread_cond_init(&worker->impl_->condition_, NULL)) {
-      pthread_mutex_destroy(&worker->impl_->mutex_);
-      goto Error;
-    }
-    pthread_mutex_lock(&worker->impl_->mutex_);
-    ok = !pthread_create(&worker->impl_->thread_, NULL, ThreadLoop, worker);
-    if (ok) worker->status_ = OK;
-    pthread_mutex_unlock(&worker->impl_->mutex_);
-    if (!ok) {
-      pthread_mutex_destroy(&worker->impl_->mutex_);
-      pthread_cond_destroy(&worker->impl_->condition_);
- Error:
-      WebPSafeFree(worker->impl_);
-      worker->impl_ = NULL;
-      return 0;
-    }
-#else
-    worker->status_ = OK;
-#endif
-  } else if (worker->status_ > OK) {
-    ok = Sync(worker);
-  }
-  assert(!ok || (worker->status_ == OK));
-  return ok;
-}
-
-static void Execute(WebPWorker* const worker) {
-  if (worker->hook != NULL) {
-    worker->had_error |= !worker->hook(worker->data1, worker->data2);
-  }
-}
-
-static void Launch(WebPWorker* const worker) {
-#ifdef WEBP_USE_THREAD
-  ChangeState(worker, WORK);
-#else
-  Execute(worker);
-#endif
-}
-
-static void End(WebPWorker* const worker) {
-#ifdef WEBP_USE_THREAD
-  if (worker->impl_ != NULL) {
-    ChangeState(worker, NOT_OK);
-    pthread_join(worker->impl_->thread_, NULL);
-    pthread_mutex_destroy(&worker->impl_->mutex_);
-    pthread_cond_destroy(&worker->impl_->condition_);
-    WebPSafeFree(worker->impl_);
-    worker->impl_ = NULL;
-  }
-#else
-  worker->status_ = NOT_OK;
-  assert(worker->impl_ == NULL);
-#endif
-  assert(worker->status_ == NOT_OK);
-}
-
-//------------------------------------------------------------------------------
-
-static WebPWorkerInterface g_worker_interface = {
-  Init, Reset, Sync, Launch, Execute, End
-};
-
-int WebPSetWorkerInterface(const WebPWorkerInterface* const winterface) {
-  if (winterface == NULL ||
-      winterface->Init == NULL || winterface->Reset == NULL ||
-      winterface->Sync == NULL || winterface->Launch == NULL ||
-      winterface->Execute == NULL || winterface->End == NULL) {
-    return 0;
-  }
-  g_worker_interface = *winterface;
-  return 1;
-}
-
-const WebPWorkerInterface* WebPGetWorkerInterface(void) {
-  return &g_worker_interface;
-}
-
-//------------------------------------------------------------------------------
diff --git a/src/main/jni/libwebp/utils/thread.h b/src/main/jni/libwebp/utils/thread.h
deleted file mode 100644
index 7bd451b12..000000000
--- a/src/main/jni/libwebp/utils/thread.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2011 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.
-// -----------------------------------------------------------------------------
-//
-// Multi-threaded worker
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#ifndef WEBP_UTILS_THREAD_H_
-#define WEBP_UTILS_THREAD_H_
-
-#ifdef HAVE_CONFIG_H
-#include "../webp/config.h"
-#endif
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// State of the worker thread object
-typedef enum {
-  NOT_OK = 0,   // object is unusable
-  OK,           // ready to work
-  WORK          // busy finishing the current task
-} WebPWorkerStatus;
-
-// Function to be called by the worker thread. Takes two opaque pointers as
-// arguments (data1 and data2), and should return false in case of error.
-typedef int (*WebPWorkerHook)(void*, void*);
-
-// Platform-dependent implementation details for the worker.
-typedef struct WebPWorkerImpl WebPWorkerImpl;
-
-// Synchronization object used to launch job in the worker thread
-typedef struct {
-  WebPWorkerImpl* impl_;
-  WebPWorkerStatus status_;
-  WebPWorkerHook hook;    // hook to call
-  void* data1;            // first argument passed to 'hook'
-  void* data2;            // second argument passed to 'hook'
-  int had_error;          // return value of the last call to 'hook'
-} WebPWorker;
-
-// The interface for all thread-worker related functions. All these functions
-// must be implemented.
-typedef struct {
-  // Must be called first, before any other method.
-  void (*Init)(WebPWorker* const worker);
-  // Must be called to initialize the object and spawn the thread. Re-entrant.
-  // Will potentially launch the thread. Returns false in case of error.
-  int (*Reset)(WebPWorker* const worker);
-  // Makes sure the previous work is finished. Returns true if worker->had_error
-  // was not set and no error condition was triggered by the working thread.
-  int (*Sync)(WebPWorker* const worker);
-  // Triggers the thread to call hook() with data1 and data2 arguments. These
-  // hook/data1/data2 values can be changed at any time before calling this
-  // function, but not be changed afterward until the next call to Sync().
-  void (*Launch)(WebPWorker* const worker);
-  // This function is similar to Launch() except that it calls the
-  // hook directly instead of using a thread. Convenient to bypass the thread
-  // mechanism while still using the WebPWorker structs. Sync() must
-  // still be called afterward (for error reporting).
-  void (*Execute)(WebPWorker* const worker);
-  // Kill the thread and terminate the object. To use the object again, one
-  // must call Reset() again.
-  void (*End)(WebPWorker* const worker);
-} WebPWorkerInterface;
-
-// Install a new set of threading functions, overriding the defaults. This
-// should be done before any workers are started, i.e., before any encoding or
-// decoding takes place. The contents of the interface struct are copied, it
-// is safe to free the corresponding memory after this call. This function is
-// not thread-safe. Return false in case of invalid pointer or methods.
-WEBP_EXTERN(int) WebPSetWorkerInterface(
-    const WebPWorkerInterface* const interface);
-
-// Retrieve the currently set thread worker interface.
-WEBP_EXTERN(const WebPWorkerInterface*) WebPGetWorkerInterface(void);
-
-//------------------------------------------------------------------------------
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_THREAD_H_ */
diff --git a/src/main/jni/libwebp/utils/utils.c b/src/main/jni/libwebp/utils/utils.c
deleted file mode 100644
index 8ff7f12fa..000000000
--- a/src/main/jni/libwebp/utils/utils.c
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Misc. common utility functions
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <stdlib.h>
-#include "./utils.h"
-
-// If PRINT_MEM_INFO is defined, extra info (like total memory used, number of
-// alloc/free etc) is printed. For debugging/tuning purpose only (it's slow,
-// and not multi-thread safe!).
-// An interesting alternative is valgrind's 'massif' tool:
-//    http://valgrind.org/docs/manual/ms-manual.html
-// Here is an example command line:
-/*    valgrind --tool=massif --massif-out-file=massif.out \
-               --stacks=yes --alloc-fn=WebPSafeAlloc --alloc-fn=WebPSafeCalloc
-      ms_print massif.out
-*/
-// In addition:
-// * if PRINT_MEM_TRAFFIC is defined, all the details of the malloc/free cycles
-//   are printed.
-// * if MALLOC_FAIL_AT is defined, the global environment variable
-//   $MALLOC_FAIL_AT is used to simulate a memory error when calloc or malloc
-//   is called for the nth time. Example usage:
-//   export MALLOC_FAIL_AT=50 && ./examples/cwebp input.png
-// * if MALLOC_LIMIT is defined, the global environment variable $MALLOC_LIMIT
-//   sets the maximum amount of memory (in bytes) made available to libwebp.
-//   This can be used to emulate environment with very limited memory.
-//   Example: export MALLOC_LIMIT=64000000 && ./examples/dwebp picture.webp
-
-// #define PRINT_MEM_INFO
-// #define PRINT_MEM_TRAFFIC
-// #define MALLOC_FAIL_AT
-// #define MALLOC_LIMIT
-
-//------------------------------------------------------------------------------
-// Checked memory allocation
-
-#if defined(PRINT_MEM_INFO)
-
-#include <stdio.h>
-#include <stdlib.h>  // for abort()
-
-static int num_malloc_calls = 0;
-static int num_calloc_calls = 0;
-static int num_free_calls = 0;
-static int countdown_to_fail = 0;     // 0 = off
-
-typedef struct MemBlock MemBlock;
-struct MemBlock {
-  void* ptr_;
-  size_t size_;
-  MemBlock* next_;
-};
-
-static MemBlock* all_blocks = NULL;
-static size_t total_mem = 0;
-static size_t total_mem_allocated = 0;
-static size_t high_water_mark = 0;
-static size_t mem_limit = 0;
-
-static int exit_registered = 0;
-
-static void PrintMemInfo(void) {
-  fprintf(stderr, "\nMEMORY INFO:\n");
-  fprintf(stderr, "num calls to: malloc = %4d\n", num_malloc_calls);
-  fprintf(stderr, "              calloc = %4d\n", num_calloc_calls);
-  fprintf(stderr, "              free   = %4d\n", num_free_calls);
-  fprintf(stderr, "total_mem: %u\n", (uint32_t)total_mem);
-  fprintf(stderr, "total_mem allocated: %u\n", (uint32_t)total_mem_allocated);
-  fprintf(stderr, "high-water mark: %u\n", (uint32_t)high_water_mark);
-  while (all_blocks != NULL) {
-    MemBlock* b = all_blocks;
-    all_blocks = b->next_;
-    free(b);
-  }
-}
-
-static void Increment(int* const v) {
-  if (!exit_registered) {
-#if defined(MALLOC_FAIL_AT)
-    {
-      const char* const malloc_fail_at_str = getenv("MALLOC_FAIL_AT");
-      if (malloc_fail_at_str != NULL) {
-        countdown_to_fail = atoi(malloc_fail_at_str);
-      }
-    }
-#endif
-#if defined(MALLOC_LIMIT)
-    {
-      const char* const malloc_limit_str = getenv("MALLOC_LIMIT");
-      if (malloc_limit_str != NULL) {
-        mem_limit = atoi(malloc_limit_str);
-      }
-    }
-#endif
-    (void)countdown_to_fail;
-    (void)mem_limit;
-    atexit(PrintMemInfo);
-    exit_registered = 1;
-  }
-  ++*v;
-}
-
-static void AddMem(void* ptr, size_t size) {
-  if (ptr != NULL) {
-    MemBlock* const b = (MemBlock*)malloc(sizeof(*b));
-    if (b == NULL) abort();
-    b->next_ = all_blocks;
-    all_blocks = b;
-    b->ptr_ = ptr;
-    b->size_ = size;
-    total_mem += size;
-    total_mem_allocated += size;
-#if defined(PRINT_MEM_TRAFFIC)
-#if defined(MALLOC_FAIL_AT)
-    fprintf(stderr, "fail-count: %5d [mem=%u]\n",
-            num_malloc_calls + num_calloc_calls, (uint32_t)total_mem);
-#else
-    fprintf(stderr, "Mem: %u (+%u)\n", (uint32_t)total_mem, (uint32_t)size);
-#endif
-#endif
-    if (total_mem > high_water_mark) high_water_mark = total_mem;
-  }
-}
-
-static void SubMem(void* ptr) {
-  if (ptr != NULL) {
-    MemBlock** b = &all_blocks;
-    // Inefficient search, but that's just for debugging.
-    while (*b != NULL && (*b)->ptr_ != ptr) b = &(*b)->next_;
-    if (*b == NULL) {
-      fprintf(stderr, "Invalid pointer free! (%p)\n", ptr);
-      abort();
-    }
-    {
-      MemBlock* const block = *b;
-      *b = block->next_;
-      total_mem -= block->size_;
-#if defined(PRINT_MEM_TRAFFIC)
-      fprintf(stderr, "Mem: %u (-%u)\n",
-              (uint32_t)total_mem, (uint32_t)block->size_);
-#endif
-      free(block);
-    }
-  }
-}
-
-#else
-#define Increment(v) do {} while (0)
-#define AddMem(p, s) do {} while (0)
-#define SubMem(p)    do {} while (0)
-#endif
-
-// Returns 0 in case of overflow of nmemb * size.
-static int CheckSizeArgumentsOverflow(uint64_t nmemb, size_t size) {
-  const uint64_t total_size = nmemb * size;
-  if (nmemb == 0) return 1;
-  if ((uint64_t)size > WEBP_MAX_ALLOCABLE_MEMORY / nmemb) return 0;
-  if (total_size != (size_t)total_size) return 0;
-#if defined(PRINT_MEM_INFO) && defined(MALLOC_FAIL_AT)
-  if (countdown_to_fail > 0 && --countdown_to_fail == 0) {
-    return 0;    // fake fail!
-  }
-#endif
-#if defined(MALLOC_LIMIT)
-  if (mem_limit > 0 && total_mem + total_size >= mem_limit) {
-    return 0;   // fake fail!
-  }
-#endif
-
-  return 1;
-}
-
-void* WebPSafeMalloc(uint64_t nmemb, size_t size) {
-  void* ptr;
-  Increment(&num_malloc_calls);
-  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
-  assert(nmemb * size > 0);
-  ptr = malloc((size_t)(nmemb * size));
-  AddMem(ptr, (size_t)(nmemb * size));
-  return ptr;
-}
-
-void* WebPSafeCalloc(uint64_t nmemb, size_t size) {
-  void* ptr;
-  Increment(&num_calloc_calls);
-  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
-  assert(nmemb * size > 0);
-  ptr = calloc((size_t)nmemb, size);
-  AddMem(ptr, (size_t)(nmemb * size));
-  return ptr;
-}
-
-void WebPSafeFree(void* const ptr) {
-  if (ptr != NULL) {
-    Increment(&num_free_calls);
-    SubMem(ptr);
-  }
-  free(ptr);
-}
-
-//------------------------------------------------------------------------------
diff --git a/src/main/jni/libwebp/utils/utils.h b/src/main/jni/libwebp/utils/utils.h
deleted file mode 100644
index f2c498a9d..000000000
--- a/src/main/jni/libwebp/utils/utils.h
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2012 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.
-// -----------------------------------------------------------------------------
-//
-// Misc. common utility functions
-//
-// Authors: Skal (pascal.massimino@gmail.com)
-//          Urvang (urvang@google.com)
-
-#ifndef WEBP_UTILS_UTILS_H_
-#define WEBP_UTILS_UTILS_H_
-
-#include <assert.h>
-
-#include "../webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//------------------------------------------------------------------------------
-// Memory allocation
-
-// This is the maximum memory amount that libwebp will ever try to allocate.
-#define WEBP_MAX_ALLOCABLE_MEMORY (1ULL << 40)
-
-// size-checking safe malloc/calloc: verify that the requested size is not too
-// large, or return NULL. You don't need to call these for constructs like
-// malloc(sizeof(foo)), but only if there's picture-dependent size involved
-// somewhere (like: malloc(num_pixels * sizeof(*something))). That's why this
-// safe malloc() borrows the signature from calloc(), pointing at the dangerous
-// underlying multiply involved.
-WEBP_EXTERN(void*) WebPSafeMalloc(uint64_t nmemb, size_t size);
-// Note that WebPSafeCalloc() expects the second argument type to be 'size_t'
-// in order to favor the "calloc(num_foo, sizeof(foo))" pattern.
-WEBP_EXTERN(void*) WebPSafeCalloc(uint64_t nmemb, size_t size);
-
-// Companion deallocation function to the above allocations.
-WEBP_EXTERN(void) WebPSafeFree(void* const ptr);
-
-//------------------------------------------------------------------------------
-// Reading/writing data.
-
-// Read 16, 24 or 32 bits stored in little-endian order.
-static WEBP_INLINE int GetLE16(const uint8_t* const data) {
-  return (int)(data[0] << 0) | (data[1] << 8);
-}
-
-static WEBP_INLINE int GetLE24(const uint8_t* const data) {
-  return GetLE16(data) | (data[2] << 16);
-}
-
-static WEBP_INLINE uint32_t GetLE32(const uint8_t* const data) {
-  return (uint32_t)GetLE16(data) | (GetLE16(data + 2) << 16);
-}
-
-// Store 16, 24 or 32 bits in little-endian order.
-static WEBP_INLINE void PutLE16(uint8_t* const data, int val) {
-  assert(val < (1 << 16));
-  data[0] = (val >> 0);
-  data[1] = (val >> 8);
-}
-
-static WEBP_INLINE void PutLE24(uint8_t* const data, int val) {
-  assert(val < (1 << 24));
-  PutLE16(data, val & 0xffff);
-  data[2] = (val >> 16);
-}
-
-static WEBP_INLINE void PutLE32(uint8_t* const data, uint32_t val) {
-  PutLE16(data, (int)(val & 0xffff));
-  PutLE16(data + 2, (int)(val >> 16));
-}
-
-// Returns (int)floor(log2(n)). n must be > 0.
-// use GNU builtins where available.
-#if defined(__GNUC__) && \
-    ((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)
-static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
-  return 31 ^ __builtin_clz(n);
-}
-#elif defined(_MSC_VER) && _MSC_VER > 1310 && \
-      (defined(_M_X64) || defined(_M_IX86))
-#include <intrin.h>
-#pragma intrinsic(_BitScanReverse)
-
-static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
-  uint32_t first_set_bit;
-  _BitScanReverse(&first_set_bit, n);
-  return first_set_bit;
-}
-#else
-static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
-  int log = 0;
-  uint32_t value = n;
-  int i;
-
-  for (i = 4; i >= 0; --i) {
-    const int shift = (1 << i);
-    const uint32_t x = value >> shift;
-    if (x != 0) {
-      value = x;
-      log += shift;
-    }
-  }
-  return log;
-}
-#endif
-
-//------------------------------------------------------------------------------
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  /* WEBP_UTILS_UTILS_H_ */