GetBackwardReferences: fail on alloc error

previously failures in the call to VP8LBackwardReferencesTraceBackwards() would be ignored which, though it wouldn't result in a crash, would produce non-deterministic output Change-Id: Id9890a60883c3270ec75e968506d46eea32b76d4 (cherry picked from commit e3cfafaf71) (cherry picked from commit 20ef03ee35) (cherry picked from commit 89e226a3c7)
BackwardReferencesHashChainDistanceOnly: fix segfault on OOM
2025-07-15 13:29:54 +02:00 · 2022-04-06 21:56:38 -07:00 · 2022-04-06 21:56:38 -07:00 · 2022-04-06 21:56:38 -07:00 · 2022-03-08 19:37:29 +00:00 · 2022-03-03 18:06:50 +00:00
89 changed files with 748 additions and 1527 deletions
--- a/.gitignore
+++ b/.gitignore
@ -20,11 +20,9 @@
 Makefile
 Makefile.in
 examples/anim_diff
-examples/anim_dump
 examples/[cdv]webp
 examples/gif2webp
 examples/img2webp
-examples/webpinfo
 examples/webpmux
 src/webp/config.h*
 src/webp/stamp-h1
@ -40,5 +38,4 @@ cmake_install.cmake
 .gradle
 /build
 extras/get_disto
-extras/vwebp_sdl
 extras/webp_quality
--- a/3
+++ b/3
@ -1,8 +1,6 @@
 Contributors:
- Aidan O'Loan (aidanol at gmail dot com)
 - Alan Browning (browning at google dot com)
 - Charles Munger (clm at google dot com)
- Cheng Yi (cyi at google dot com)
 - Christian Duvivier (cduvivier at google dot com)
 - Djordje Pesut (djordje dot pesut at imgtec dot com)
 - Hui Su (huisu at google dot com)
@ -22,7 +20,6 @@ Contributors:
 - Mislav Bradac (mislavm at google dot com)
 - Nico Weber (thakis at chromium dot org)
 - Noel Chromium (noel at chromium dot org)
- Oliver Wolff (oliver dot wolff at qt dot io)
 - Owen Rodley (orodley at google dot com)
 - Parag Salasakar (img dot mips1 at gmail dot com)
 - Pascal Massimino (pascal dot massimino at gmail dot com)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -17,8 +17,6 @@ option(WEBP_BUILD_WEBP_JS "Emscripten build of webp.js." OFF)
 option(WEBP_NEAR_LOSSLESS "Enable near-lossless encoding" ON)
 option(WEBP_ENABLE_SWAP_16BIT_CSP "Enable byte swap for 16 bit colorspaces."
       OFF)
-set(WEBP_BITTRACE "0" CACHE STRING "Bit trace mode (0=none, 1=bit, 2=bytes)")
-set_property(CACHE WEBP_BITTRACE PROPERTY STRINGS 0 1 2)

 # Option needed for handling Unicode file names on Windows.
 if(WIN32)
@ -57,10 +55,6 @@ if(WEBP_ENABLE_SWAP_16BIT_CSP)
  add_definitions(-DWEBP_SWAP_16BIT_CSP=1)
 endif()

-if(NOT WEBP_BITTRACE STREQUAL "0")
-  add_definitions(-DBITTRACE=${WEBP_BITTRACE})
-endif()
-
 if(WEBP_UNICODE)
  # Windows recommends setting both UNICODE and _UNICODE.
  add_definitions(-DUNICODE -D_UNICODE)
@ -71,7 +65,6 @@ set(exec_prefix "\$\{prefix\}")
 set(libdir "\$\{prefix\}/lib")
 set(includedir "\$\{prefix\}/include")
 set(PTHREAD_LIBS ${CMAKE_THREAD_LIBS_INIT})
-set(INSTALLED_LIBRARIES)

 # ##############################################################################
 # Android only.
@ -79,7 +72,6 @@ if(ANDROID)
  include_directories(${ANDROID_NDK}/sources/android/cpufeatures)
  add_library(cpufeatures STATIC
              ${ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c)
-  list(APPEND INSTALLED_LIBRARIES cpufeatures)
  target_link_libraries(cpufeatures dl)
  set(WEBP_DEP_LIBRARIES ${WEBP_DEP_LIBRARIES} cpufeatures)
  set(WEBP_DEP_INCLUDE_DIRS ${WEBP_DEP_INCLUDE_DIRS}
@ -314,7 +306,7 @@ string(REGEX MATCH
             ${TMP})

 # Define the libraries to install.
-list(APPEND INSTALLED_LIBRARIES webpdecoder webp webpdemux)
+set(INSTALLED_LIBRARIES webpdecoder webp webpdemux)

 # Deal with SIMD. Change the compile flags for SIMD files we use.
 list(LENGTH WEBP_SIMD_FILES_TO_INCLUDE WEBP_SIMD_FILES_TO_INCLUDE_LENGTH)
@ -349,21 +341,20 @@ if(WEBP_BUILD_ANIM_UTILS
  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "EXAMPLEUTIL_SRCS"
                    "example_util_[^ ]*")
  list(APPEND EXAMPLEUTIL_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/examples/stopwatch.h)
-  add_library(exampleutil STATIC ${EXAMPLEUTIL_SRCS})
-  target_link_libraries(exampleutil imageioutil)
+  add_library(exampleutil ${EXAMPLEUTIL_SRCS})
  target_include_directories(
    exampleutil
    PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)

  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEIOUTILS_SRCS"
                    "imageio_util_[^ ]*")
-  add_library(imageioutil STATIC ${IMAGEIOUTILS_SRCS})
+  add_library(imageioutil ${IMAGEIOUTILS_SRCS})
  target_link_libraries(imageioutil webp)

  # Image-decoding utility library.
  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEDEC_SRCS"
                    "imagedec_[^ ]*")
-  add_library(imagedec STATIC ${IMAGEDEC_SRCS})
+  add_library(imagedec ${IMAGEDEC_SRCS})
  target_link_libraries(imagedec
                        imageioutil
                        webpdemux
@ -373,8 +364,8 @@ if(WEBP_BUILD_ANIM_UTILS
  # Image-encoding utility library.
  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEENC_SRCS"
                    "imageenc_[^ ]*")
-  add_library(imageenc STATIC ${IMAGEENC_SRCS})
-  target_link_libraries(imageenc imageioutil webp)
+  add_library(imageenc ${IMAGEENC_SRCS})
+  target_link_libraries(imageenc webp)

  set_property(TARGET exampleutil
                      imageioutil
@ -467,12 +458,12 @@ if(WEBP_BUILD_VWEBP)
    target_link_libraries(vwebp
                          ${OPENGL_LIBRARIES}
                          exampleutil
-                          ${GLUT_glut_LIBRARY}
+                          GLUT::GLUT
                          imageioutil
                          webp
                          webpdemux)
    target_include_directories(vwebp
-                               PRIVATE ${GLUT_INCLUDE_DIR}
+                               PRIVATE GLUT::GLUT
                                       ${CMAKE_CURRENT_BINARY_DIR}/src
                                       ${OPENGL_INCLUDE_DIR})
    install(TARGETS vwebp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
@ -525,9 +516,7 @@ if(WEBP_BUILD_EXTRAS)
  # webp_quality
  add_executable(webp_quality ${WEBP_QUALITY_SRCS} ${WEBP_EXTRAS_SRCS})
  target_link_libraries(webp_quality exampleutil imagedec)
-  target_include_directories(webp_quality
-                             PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
-                                     ${CMAKE_CURRENT_BINARY_DIR})
+  target_include_directories(webp_quality PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
  install(TARGETS webp_quality RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

  # vwebp_sdl
--- a/95
+++ b/95
@ -1,82 +1,3 @@
-7f006436 Makefile.vc: fix webp_quality.exe link
-c074c653 update NEWS
-30f09551 bump version to 1.1.0
-a76694a1 update AUTHORS
-6e3ef7b3 extras: fix WEBP_SWAP_16BIT_CSP check
-47178dbd extras: add WebPUnmultiplyARGB() convenience function
-22cbae33 idec_dec: fix 0 offset of NULL pointer
-290dd0b4 muxread: fix 0 offset of NULL pointer
-0df474ac Merge "lossless_(enc_|)sse2: avoid offsetting a NULL pointer"
-c6b75a19 lossless_(enc_|)sse2: avoid offsetting a NULL pointer
-295e5e38 fix UBSAN warning
-e2575e05 DC8_NEON,aarch64: use vaddv
-b0e09e34 dec_neon: Fix build failure under some toolchains
-cf0e903c dsp/lossless: Fix non gcc ARM builds
-bb7bc40b Remove ubsan errors.
-78881b76 CMake: fix GLUT library link
-9f750f7a cmake: fix BUILD_SHARED_LIBS build on mac
-17850e74 libwebp: Remove char-subscripts warning in pnmdec.c
-2fa2552d Merge "Expose WebPMalloc() in addition to WebPFree()"
-a4df4aae Expose WebPMalloc() in addition to WebPFree()
-853ea3d8 imageio/tiff: Return error before allocating bad tile size
-af650c0b Fix a Wxor-used-as-pow false positive
-601ef17c libwebp.py: update to swig 3.0.12
-0e48d889 bugfix: last alpha rows were incorrectly decoded
-24d2ccb4 webp: Fix imageio ReadPNM() TUPLTYPE
-fab8f9cf cosmetics: normalize '*' association
-94138e0e update .gitignore
-0fe1a89d update ChangeLog (tag: v1.0.3-rc1, tag: v1.0.3)
-2ad0916d update NEWS
-1287362b bump version to 1.0.3
-7b968cc2 update AUTHORS
-9d6988f4 Fix the oscillating prediction problem at low quality
-312f74d0 makefile.unix: allow *_LIBS to be overridden w/EXTRA_LIBS
-92dbf237 filters_sse2,cosmetics: shorten some long lines
-a277d197 filters_sse2.c: quiet integer sanitizer warnings
-804540f1 Fix cpufeatures in CMake.
-bf00c15b Add CMake option for bittrace.
-a788b498 filters_sse2.c: quiet integer sanitizer warnings
-e6a92c5e filters.c: quiet integer sanitizer warnings
-ec1cc40a lossless.c: remove U32 -> S8 conversion warnings
-1106478f remove conversion U32 -> S8 warnings
-812a6b49 lossless_enc: fix some conversion warning
-4627c1c9 lossless_enc,TransformColorBlue: quiet uint32_t conv warning
-c84673a6 lossless_enc_sse{2,41}: quiet signed conv warnings
-776a7757 dec_sse2: quiet signed conv warnings
-bd39c063 Merge "thread_utils: release mutex before signaling"
-0550576f Merge "(alpha_processing,enc}_sse2: quiet signed conv warnings"
-6682f2c4 thread_utils: release mutex before signaling
-e78dea75 (alpha_processing,enc}_sse2: quiet signed conv warnings
-9acf18ba iosbuild.sh: add WebP{Demux,Mux}.framework
-b9be7e65 vwebp: remove the -fit option (and make it default)
-1394a2bb Merge "README.webp_js: update Emscripten.cmake note"
-dd3e7f8a README.webp_js: update Emscripten.cmake note
-32cf8801 predictor_enc,GetBestGreenRedToBlue: quiet implicit conv warnings
-e1c8acb5 Merge "vwebp: add a -fit option"
-cbd23dd5 vwebp: add a -fit option
-2e672351 bit_writer_utils,Flush: quiet implicit conversion warnings
-1326988d swig: update libwebp_python_wrap.c
-0e7f8548 update generated swig files
-17ed1438 Merge "PutLE{16,24}: quiet implicit conversion warnings"
-24686538 PutLE{16,24}: quiet implicit conversion warnings
-153bb3a0 fix some clang-7 warnings:
-ab2dc893 Rescaler: fix rounding error
-aa65f89a HistogramCombineStochastic: fix free of uninit value
-af0bac64 Merge "encode.h: mention 'exact' default in WebPEncodeLossless*"
-6d2e11ec encode.h: mention 'exact' default in WebPEncodeLossless*
-8c3f04fe AndroidCPUInfo: reorder terms in conditional
-fcfd9c71 BitTrace: if BITTRACE is > 0, record and print syntax bits used
-067031ea Speedups for unused Huffman groups.
-01ac46ba libwebp: Display "libjpeg error:" in imageio/jpegdec
-d9a662e1 WebPRescalerGetScaledDimensions: round scaled dimension up
-62eb3f08 libwebp: Fix missing '{' in README
-e05f785a Merge "unicode,INIT_WARGV: add missing cast"
-63c9a69f tag the VP8LHashPix() function for potential uint roll-over
-2b7214ab unicode,INIT_WARGV: add missing cast
-bf424b46 tag the GetPixPairHash64() function for potential uint roll-over
-7d05d6ca Have the color cache computation be u32-bit only.
-6bcf8769 Remove BINARYEN_METHOD in wasm settings.
-2b98df90 update ChangeLog (tag: v1.0.2-rc1, tag: v1.0.2)
 61e372b7 update NEWS
 7ae658a0 bump version to 1.0.2
 51c4907d update AUTHORS
@ -95,7 +16,7 @@ f435de95 IsFlat: return int
 9f4d4a3f neon: GetResidualCost
 0fd7514b neon: SetResidualCoeffs
 f95a996c Simpler histogram clustering.
-e85d3313 update ChangeLog (tag: v1.0.1-rc2, tag: v1.0.1)
+e85d3313 update ChangeLog (tag: v1.0.1-rc2, tag: v1.0.1, origin/1.0.1, 1.0.1)
 fa8210e4 Fix pair update in stochastic entropy merging.
 fd198f73 add codereview.settings
 825389ac README.mux: add a reference to the AnimDecoder API
@ -564,7 +485,7 @@ dcf9d82a imageio: add limited PNM support for reading
 6524fcd6 vwebp_sdl: simple viewer based on SDL
 6cf24a24 get_disto: fix reference file read
 43d472aa Merge tag 'v0.6.0'
-50d1a848 update ChangeLog (tag: v0.6.0, origin/0.6.0)
+50d1a848 update ChangeLog (tag: v0.6.0, origin/0.6.0, 0.6.0)
 20a7fea0 extras/Makefile.am: fix libwebpextras.la reference
 415f3ffe update ChangeLog (tag: v0.6.0-rc3)
 3c6d1224 update NEWS
@ -641,7 +562,7 @@ b016cb91 NEON: faster fancy upsampling
 f04eb376 Merge tag 'v0.5.2'
 341d711c NEON: 5% faster conversion to RGB565 and RGBA4444
 abb54827 remove Clang warnings with unused arch arguments.
-ece9684f update ChangeLog (tag: v0.5.2-rc2, tag: v0.5.2, origin/0.5.2)
+ece9684f update ChangeLog (tag: v0.5.2-rc2, tag: v0.5.2, origin/0.5.2, 0.5.2)
 aa7744ca anim_util: quiet implicit conv warnings in 32-bit
 d9120271 jpegdec: correct ContextFill signature
 24eb3940 Remove some errors when compiling the code as C++.
@ -928,7 +849,7 @@ bbb6ecd9 Merge "Add MSA optimized distortion functions"
 c0991a14 io,EmitRescaledAlphaYUV: factor out a common expr
 48bf5ed1 build.gradle: remove tab
 bfef6c9f Merge tag 'v0.5.1'
-3d97bb75 update ChangeLog (tag: v0.5.1, origin/0.5.1)
+3d97bb75 update ChangeLog (tag: v0.5.1, origin/0.5.1, 0.5.1)
 deb54d91 Clarify the expected 'config' lifespan in WebPIDecode()
 435308e0 Add MSA optimized encoder transform functions
 dce64bfa Add MSA optimized alpha filter functions
@ -1122,7 +1043,7 @@ b74657fb configure: fix builtin detection w/-Werror
 6c1d7631 avoid Yoda style for comparison
 8ce975ac SSE optimization for vector mismatch.
 7db53831 Merge tag 'v0.5.0'
-37f04949 update ChangeLog (tag: v0.5.0-rc1, tag: v0.5.0, origin/0.5.0)
+37f04949 update ChangeLog (tag: v0.5.0-rc1, tag: v0.5.0, origin/0.5.0, 0.5.0)
 7e7b6ccc faster rgb565/rgb4444/argb output
 4c7f565f update NEWS
 1f62b6b2 update AUTHORS
@ -1906,7 +1827,7 @@ b5a36cc9 add -near_lossless [0..100] experimental option
 0524d9e5 dsp: detect mips64 & disable mips32 code
 d3485d96 cwebp.1: fix quality description placement
 29a9fe22 Merge tag 'v0.4.1'
-8af27718 update ChangeLog (tag: v0.4.1, origin/0.4.1)
+8af27718 update ChangeLog (tag: v0.4.1, origin/0.4.1, 0.4.1)
 e09e9ff6 Record & log the image pre-processing time.
 f59c0b4b iosbuild.sh: specify optimization flags
 8d34ea3e update ChangeLog (tag: v0.4.1-rc1)
@ -2291,7 +2212,7 @@ ea59a8e9 Merge "Merge tag 'v0.4.0'"
 effcb0fd Merge tag 'v0.4.0'
 7c76255d autoconf: update ax_pthread.m4
 fff2a11b make -short work with -print_ssim, -print_psnr, etc.
-68e7901d update ChangeLog (tag: v0.4.0-rc1, tag: v0.4.0, origin/0.4.0)
+68e7901d update ChangeLog (tag: v0.4.0-rc1, tag: v0.4.0, origin/0.4.0, 0.4.0)
 256e4333 update NEWS description with new general features
 29625340 Merge "gif2webp: don't use C99 %zu" into 0.4.0
 3b9f9dd0 gif2webp: don't use C99 %zu
@ -3067,7 +2988,7 @@ a61a824b Merge "Add NULL check in chunk APIs"
 a0770727 mux struct naming
 6c66dde8 Merge "Tune Lossless encoder"
 ab5ea217 Tune Lossless encoder
-74fefc8c Update ChangeLog (tag: v0.2.1, origin/0.2.0)
+74fefc8c Update ChangeLog (tag: v0.2.1, origin/0.2.0, 0.2.0)
 92f8059c Rename some chunks:
 3bb4bbeb Merge "Mux API change:"
 d0c79f05 Mux API change:
--- a/Makefile.vc
+++ b/Makefile.vc
@ -391,13 +391,7 @@ $(DIRBIN)\get_disto.exe: $(IMAGEIO_DEC_OBJS) $(IMAGEIO_UTIL_OBJS)
 $(DIRBIN)\get_disto.exe: $(LIBWEBPDEMUX) $(LIBWEBP)
 $(DIRBIN)\webp_quality.exe: $(DIROBJ)\extras\webp_quality.obj
 $(DIRBIN)\webp_quality.exe: $(IMAGEIO_UTIL_OBJS)
-$(DIRBIN)\webp_quality.exe: $(EXTRAS_OBJS)
-# EXTRA_OBJS requires private symbols from dsp. Explicitly add those when
-# building libwebp as a dll.
-!IF "$(DLLBUILD)" == "TRUE"
-$(DIRBIN)\webp_quality.exe: $(DSP_DEC_OBJS)
-!ENDIF
-$(DIRBIN)\webp_quality.exe: $(LIBWEBP)
+$(DIRBIN)\webp_quality.exe: $(EXTRAS_OBJS) $(LIBWEBP)
 $(DIRBIN)\webpinfo.exe: $(DIROBJ)\examples\webpinfo.obj
 $(DIRBIN)\webpinfo.exe: $(IMAGEIO_DEC_OBJS)
 $(DIRBIN)\webpinfo.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)
--- a/23
+++ b/23
@ -1,26 +1,3 @@
- 12/18/2019: version 1.1.0
-  * API changes:
-    - libwebp:
-      WebPMalloc (issue #442)
-    - extras:
-      WebPUnmultiplyARGB
-  * alpha decode fix (issue #439)
-  * toolchain updates and bug fixes
-    (chromium: #1026858, #1027136, #1027409, #1028620, #1028716, #995200)
-    (oss-fuzz: #19430, #19447)
-
- 7/4/2019: version 1.0.3
-  This is a binary compatible release.
-  * resize fixes for Nx1 sizes and the addition of non-opaque alpha values for
-    odd sizes (issues #418, #434)
-  * lossless encode/decode performance improvements
-  * lossy compression performance improvement at low quality levels with flat
-    content (issue #432)
-  * python swig files updated to support python 3
-  Tool updates:
-    vwebp will now preserve the aspect ratio of images that exceed monitor
-    resolution by scaling the image to fit (issue #433)
-
 - 1/14/2019: version 1.0.2
  This is a binary compatible release.
  * (Windows) unicode file support in the tools (linux and mac already had
--- a/4
+++ b/4
@ -4,7 +4,7 @@
          \__\__/\____/\_____/__/ ____  ___
                / _/ /    \    \ /  _ \/ _/
               /  \_/   / /   \ \   __/  \__
-               \____/____/\_____/_____/____/v1.1.0
+               \____/____/\_____/_____/____/v1.0.2

 Description:
 ============
@ -597,7 +597,7 @@ The encoding flow looks like:
  // Setup a config, starting form a preset and tuning some additional
  // parameters
  WebPConfig config;
-  if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor)) {
+  if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor))
    return 0;   // version error
  }
  // ... additional tuning
--- a/README.mux
+++ b/README.mux
@ -1,7 +1,7 @@
          __   __  ____  ____  ____  __ __  _     __ __
         /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
         \       /   __/  _  \   __/      /  /  (_/  /__
-          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.1.0
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.0.2


 Description:
--- a/README.webp_js
+++ b/README.webp_js
@ -17,10 +17,6 @@ using Emscripten and CMake.

 - make sure the file $EMSCRIPTEN/cmake/Modules/Platform/Emscripten.cmake is
   accessible. This is the toolchain file used by CMake to invoke Emscripten.
-   If $EMSCRIPTEN is unset search for Emscripten.cmake under $EMSDK and set
-   $EMSCRIPTEN accordingly, for example:
-   unix-like environments: export EMSCRIPTEN=$EMSDK/fastcomp/emscripten
-   windows: set EMSCRIPTEN=%EMSDK%\fastcomp\emscripten

 - configure the project 'WEBP_JS' with CMake using:

--- a/configure.ac
+++ b/configure.ac
@ -1,4 +1,4 @@
-AC_INIT([libwebp], [1.1.0],
+AC_INIT([libwebp], [1.0.2],
        [https://bugs.chromium.org/p/webp],,
        [http://developers.google.com/speed/webp])
 AC_CANONICAL_HOST
--- a/examples/anim_util.c
+++ b/examples/anim_util.c
@ -60,15 +60,15 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
      !CheckSizeForOverflow(total_frame_size)) {
    return 0;
  }
-  mem = (uint8_t*)WebPMalloc((size_t)total_size);
-  frames = (DecodedFrame*)WebPMalloc((size_t)total_frame_size);
+  mem = (uint8_t*)malloc((size_t)total_size);
+  frames = (DecodedFrame*)malloc((size_t)total_frame_size);

  if (mem == NULL || frames == NULL) {
-    WebPFree(mem);
-    WebPFree(frames);
+    free(mem);
+    free(frames);
    return 0;
  }
-  WebPFree(image->raw_mem);
+  free(image->raw_mem);
  image->num_frames = num_frames;
  image->frames = frames;
  for (i = 0; i < num_frames; ++i) {
@ -82,8 +82,8 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {

 void ClearAnimatedImage(AnimatedImage* const image) {
  if (image != NULL) {
-    WebPFree(image->raw_mem);
-    WebPFree(image->frames);
+    free(image->raw_mem);
+    free(image->frames);
    image->num_frames = 0;
    image->frames = NULL;
    image->raw_mem = NULL;
@ -165,7 +165,7 @@ static int DumpFrame(const char filename[], const char dump_folder[],
  base_name = (base_name == NULL) ? (const W_CHAR*)filename : base_name + 1;
  max_len = WSTRLEN(dump_folder) + 1 + WSTRLEN(base_name)
          + strlen("_frame_") + strlen(".pam") + 8;
-  file_name = (W_CHAR*)WebPMalloc(max_len * sizeof(*file_name));
+  file_name = (W_CHAR*)malloc(max_len * sizeof(*file_name));
  if (file_name == NULL) goto End;

  if (WSNPRINTF(file_name, max_len, "%s/%s_frame_%d.pam",
@ -197,7 +197,7 @@ static int DumpFrame(const char filename[], const char dump_folder[],
  ok = 1;
 End:
  if (f != NULL) fclose(f);
-  WebPFree(file_name);
+  free(file_name);
  return ok;
 }

--- a/examples/cwebp.c
+++ b/examples/cwebp.c
@ -128,8 +128,7 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
 static void AllocExtraInfo(WebPPicture* const pic) {
  const int mb_w = (pic->width + 15) / 16;
  const int mb_h = (pic->height + 15) / 16;
-  pic->extra_info =
-      (uint8_t*)WebPMalloc(mb_w * mb_h * sizeof(*pic->extra_info));
+  pic->extra_info = (uint8_t*)malloc(mb_w * mb_h * sizeof(*pic->extra_info));
 }

 static void PrintByteCount(const int bytes[4], int total_size,
@ -641,10 +640,10 @@ static const char* const kErrorMessages[VP8_ENC_ERROR_LAST] = {

 //------------------------------------------------------------------------------

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  int return_value = -1;
-  const char* in_file = NULL, *out_file = NULL, *dump_file = NULL;
-  FILE* out = NULL;
+  const char *in_file = NULL, *out_file = NULL, *dump_file = NULL;
+  FILE *out = NULL;
  int c;
  int short_output = 0;
  int quiet = 0;
@ -1169,7 +1168,7 @@ int main(int argc, const char* argv[]) {

 Error:
  WebPMemoryWriterClear(&memory_writer);
-  WebPFree(picture.extra_info);
+  free(picture.extra_info);
  MetadataFree(&metadata);
  WebPPictureFree(&picture);
  WebPPictureFree(&original_picture);
--- a/examples/dwebp.c
+++ b/examples/dwebp.c
@ -132,7 +132,7 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
                     format == RGB_565) ? 2
                  : 4;
    uint32_t stride = bpp * w + 7;   // <- just for exercising
-    external_buffer = (uint8_t*)WebPMalloc(stride * h);
+    external_buffer = (uint8_t*)malloc(stride * h);
    if (external_buffer == NULL) return NULL;
    output_buffer->u.RGBA.stride = stride;
    output_buffer->u.RGBA.size = stride * h;
@ -145,7 +145,7 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
    uint32_t total_size = stride * h * (has_alpha ? 2 : 1)
                        + 2 * uv_stride * (h + 1) / 2;
    assert(format >= YUV && format <= YUVA);
-    external_buffer = (uint8_t*)WebPMalloc(total_size);
+    external_buffer = (uint8_t*)malloc(total_size);
    if (external_buffer == NULL) return NULL;
    tmp = external_buffer;
    output_buffer->u.YUVA.y = tmp;
@ -176,10 +176,10 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
  return external_buffer;
 }

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  int ok = 0;
-  const char* in_file = NULL;
-  const char* out_file = NULL;
+  const char *in_file = NULL;
+  const char *out_file = NULL;

  WebPDecoderConfig config;
  WebPDecBuffer* const output_buffer = &config.output;
@ -412,8 +412,8 @@ int main(int argc, const char* argv[]) {
  }
 Exit:
  WebPFreeDecBuffer(output_buffer);
-  WebPFree((void*)external_buffer);
-  WebPFree((void*)data);
+  free((void*)external_buffer);
+  free((void*)data);
  FREE_WARGV_AND_RETURN(ok ? 0 : -1);
 }

--- a/examples/example_util.c
+++ b/examples/example_util.c
@ -75,7 +75,7 @@ static void ResetCommandLineArguments(int argc, const char* argv[],
 void ExUtilDeleteCommandLineArguments(CommandLineArguments* const args) {
  if (args != NULL) {
    if (args->own_argv_) {
-      WebPFree((void*)args->argv_);
+      free((void*)args->argv_);
      WebPDataClear(&args->argv_data_);
    }
    ResetCommandLineArguments(0, NULL, args);
@ -102,7 +102,7 @@ int ExUtilInitCommandLineArguments(int argc, const char* argv[],
      return 0;
    }
    args->own_argv_ = 1;
-    args->argv_ = (const char**)WebPMalloc(MAX_ARGC * sizeof(*args->argv_));
+    args->argv_ = (const char**)malloc(MAX_ARGC * sizeof(*args->argv_));
    if (args->argv_ == NULL) return 0;

    argc = 0;
--- a/examples/gif2webp.c
+++ b/examples/gif2webp.c
@ -96,12 +96,12 @@ static void Help(void) {

 //------------------------------------------------------------------------------

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  int verbose = 0;
  int gif_error = GIF_ERROR;
  WebPMuxError err = WEBP_MUX_OK;
  int ok = 0;
-  const W_CHAR* in_file = NULL, *out_file = NULL;
+  const W_CHAR *in_file = NULL, *out_file = NULL;
  GifFileType* gif = NULL;
  int frame_duration = 0;
  int frame_timestamp = 0;
@ -379,7 +379,7 @@ int main(int argc, const char* argv[]) {
      }
      case EXTENSION_RECORD_TYPE: {
        int extension;
-        GifByteType* data = NULL;
+        GifByteType *data = NULL;
        if (DGifGetExtension(gif, &extension, &data) == GIF_ERROR) {
          goto End;
        }
@ -593,7 +593,7 @@ int main(int argc, const char* argv[]) {

 #else  // !WEBP_HAVE_GIF

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  fprintf(stderr, "GIF support not enabled in %s.\n", argv[0]);
  (void)argc;
  return 0;
--- a/examples/gifdec.c
+++ b/examples/gifdec.c
@ -137,7 +137,7 @@ int GIFReadFrame(GifFileType* const gif, int transparent_index,
  }
  dst = sub_image.argb;

-  tmp = (uint8_t*)WebPMalloc(rect.width * sizeof(*tmp));
+  tmp = (uint8_t*)malloc(rect.width * sizeof(*tmp));
  if (tmp == NULL) goto End;

  if (image_desc->Interlace) {  // Interlaced image.
@ -168,7 +168,7 @@ int GIFReadFrame(GifFileType* const gif, int transparent_index,
 End:
  if (!ok) picture->error_code = sub_image.error_code;
  WebPPictureFree(&sub_image);
-  WebPFree(tmp);
+  free(tmp);
  return ok;
 }

--- a/examples/vwebp.c
+++ b/examples/vwebp.c
@ -418,9 +418,8 @@ static void HandleDisplay(void) {
 }

 static void StartDisplay(void) {
-  int width = kParams.canvas_width;
-  int height = kParams.canvas_height;
-  int screen_width, screen_height;
+  const int width = kParams.canvas_width;
+  const int height = kParams.canvas_height;
  // TODO(webp:365) GLUT_DOUBLE results in flickering / old frames to be
  // partially displayed with animated webp + alpha.
 #if defined(__APPLE__) || defined(_WIN32)
@ -428,18 +427,6 @@ static void StartDisplay(void) {
 #else
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
 #endif
-  screen_width = glutGet(GLUT_SCREEN_WIDTH);
-  screen_height = glutGet(GLUT_SCREEN_HEIGHT);
-  if (width > screen_width || height > screen_height) {
-    if (width > screen_width) {
-      height = (height * screen_width + width - 1) / width;
-      width = screen_width;
-    }
-    if (height > screen_height) {
-      width = (width * screen_height + height - 1) / height;
-      height = screen_height;
-    }
-  }
  glutInitWindowSize(width, height);
  glutCreateWindow("WebP viewer");
  glutDisplayFunc(HandleDisplay);
@ -479,7 +466,7 @@ static void Help(void) {
      "  'q' / 'Q' / ESC .... quit\n");
 }

-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[]) {
  int c;
  WebPDecoderConfig* const config = &kParams.config;
  WebPIterator* const curr = &kParams.curr_frame;
@ -630,7 +617,7 @@ int main(int argc, char* argv[]) {

 #else   // !WEBP_HAVE_GL

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  fprintf(stderr, "OpenGL support not enabled in %s.\n", argv[0]);
  (void)argc;
  return 0;
--- a/examples/webpmux.c
+++ b/examples/webpmux.c
@ -1045,7 +1045,7 @@ static int Process(const Config* config) {
        int* durations = NULL;
        WebPMux* new_mux = DuplicateMuxHeader(mux);
        if (new_mux == NULL) goto Err2;
-        durations = (int*)WebPMalloc((size_t)num_frames * sizeof(*durations));
+        durations = (int*)malloc((size_t)num_frames * sizeof(*durations));
        if (durations == NULL) goto Err2;
        for (i = 0; i < num_frames; ++i) durations[i] = -1;

@ -1103,7 +1103,7 @@ static int Process(const Config* config) {
        new_mux = NULL;

 Err3:
-        WebPFree(durations);
+        free(durations);
        WebPMuxDelete(new_mux);
        if (!ok) goto Err2;
      }
--- a/extras/extras.c
+++ b/extras/extras.c
@ -12,14 +12,13 @@

 #include "extras/extras.h"
 #include "webp/format_constants.h"
-#include "src/dsp/dsp.h"

 #include <assert.h>
 #include <string.h>

 #define XTRA_MAJ_VERSION 1
-#define XTRA_MIN_VERSION 1
-#define XTRA_REV_VERSION 0
+#define XTRA_MIN_VERSION 0
+#define XTRA_REV_VERSION 2

 //------------------------------------------------------------------------------

@ -58,7 +57,7 @@ int WebPImportRGB565(const uint8_t* rgb565, WebPPicture* pic) {
  for (y = 0; y < pic->height; ++y) {
    const int width = pic->width;
    for (x = 0; x < width; ++x) {
-#if defined(WEBP_SWAP_16BIT_CSP) && (WEBP_SWAP_16BIT_CSP == 1)
+#ifdef WEBP_SWAP_16BIT_CSP
      const uint32_t rg = rgb565[2 * x + 1];
      const uint32_t gb = rgb565[2 * x + 0];
 #else
@ -91,7 +90,7 @@ int WebPImportRGB4444(const uint8_t* rgb4444, WebPPicture* pic) {
  for (y = 0; y < pic->height; ++y) {
    const int width = pic->width;
    for (x = 0; x < width; ++x) {
-#if defined(WEBP_SWAP_16BIT_CSP) && (WEBP_SWAP_16BIT_CSP == 1)
+#ifdef WEBP_SWAP_16BIT_CSP
      const uint32_t rg = rgb4444[2 * x + 1];
      const uint32_t ba = rgb4444[2 * x + 0];
 #else
@ -145,18 +144,3 @@ int WebPImportColorMappedARGB(const uint8_t* indexed, int indexed_stride,
 }

 //------------------------------------------------------------------------------
-
-int WebPUnmultiplyARGB(WebPPicture* pic) {
-  int y;
-  uint32_t* dst;
-  if (pic == NULL || pic->use_argb != 1 || pic->argb == NULL) return 0;
-  WebPInitAlphaProcessing();
-  dst = pic->argb;
-  for (y = 0; y < pic->height; ++y) {
-    WebPMultARGBRow(dst, pic->width, /*inverse=*/1);
-    dst += pic->argb_stride;
-  }
-  return 1;
-}
-
-//------------------------------------------------------------------------------
--- a/extras/extras.h
+++ b/extras/extras.h
@ -19,7 +19,7 @@ extern "C" {

 #include "webp/encode.h"

-#define WEBP_EXTRAS_ABI_VERSION 0x0002    // MAJOR(8b) + MINOR(8b)
+#define WEBP_EXTRAS_ABI_VERSION 0x0001    // MAJOR(8b) + MINOR(8b)

 //------------------------------------------------------------------------------

@ -51,13 +51,6 @@ WebPImportColorMappedARGB(const uint8_t* indexed, int indexed_stride,
                          const uint32_t palette[], int palette_size,
                          WebPPicture* pic);

-// Convert the ARGB content of 'pic' from associated to unassociated.
-// 'pic' can be for instance the result of calling of some WebPPictureImportXXX
-// functions, with pic->use_argb set to 'true'. It is assumed (and not checked)
-// that the pre-multiplied r/g/b values as less or equal than the alpha value.
-// Return false in case of error (invalid parameter, ...).
-WEBP_EXTERN int WebPUnmultiplyARGB(WebPPicture* pic);
-
 //------------------------------------------------------------------------------

 // Parse a bitstream, search for VP8 (lossy) header and report a
--- a/extras/get_disto.c
+++ b/extras/get_disto.c
@ -226,7 +226,7 @@ static void Help(void) {
          " Also handles PNG, JPG and TIFF files, in addition to WebP.\n");
 }

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  WebPPicture pic1, pic2;
  size_t size1 = 0, size2 = 0;
  int ret = 1;
--- a/extras/vwebp_sdl.c
+++ b/extras/vwebp_sdl.c
@ -92,7 +92,7 @@ int main(int argc, char* argv[]) {

 #else  // !WEBP_HAVE_SDL

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  fprintf(stderr, "SDL support not enabled in %s.\n", argv[0]);
  (void)argc;
  return 0;
--- a/extras/webp_quality.c
+++ b/extras/webp_quality.c
@ -15,7 +15,7 @@
 #include "imageio/imageio_util.h"
 #include "../examples/unicode.h"

-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
  int c;
  int quiet = 0;
  int ok = 1;
--- a/imageio/jpegdec.c
+++ b/imageio/jpegdec.c
@ -206,7 +206,6 @@ struct my_error_mgr {

 static void my_error_exit(j_common_ptr dinfo) {
  struct my_error_mgr* myerr = (struct my_error_mgr*)dinfo->err;
-  fprintf(stderr, "libjpeg error: ");
  dinfo->err->output_message(dinfo);
  longjmp(myerr->setjmp_buffer, 1);
 }
--- a/imageio/pnmdec.c
+++ b/imageio/pnmdec.c
@ -26,7 +26,7 @@ typedef enum {
  DEPTH_FLAG      = 1 << 2,
  MAXVAL_FLAG     = 1 << 3,
  TUPLE_FLAG      = 1 << 4,
-  ALL_NEEDED_FLAGS = WIDTH_FLAG | HEIGHT_FLAG | DEPTH_FLAG | MAXVAL_FLAG
+  ALL_NEEDED_FLAGS = 0x1f
 } PNMFlags;

 typedef struct {
@ -74,7 +74,6 @@ static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
  char out[MAX_LINE_SIZE + 1];
  size_t out_size;
  int tmp;
-  int expected_depth = -1;
  assert(info != NULL);
  while (1) {
    off = ReadLine(info->data, off, info->data_size, out, &out_size);
@ -96,13 +95,13 @@ static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
      info->seen_flags |= MAXVAL_FLAG;
      info->max_value = tmp;
    } else if (!strcmp(out, "TUPLTYPE RGB_ALPHA")) {
-      expected_depth = 4;
+      info->bytes_per_px = 4;
      info->seen_flags |= TUPLE_FLAG;
    } else if (!strcmp(out, "TUPLTYPE RGB")) {
-      expected_depth = 3;
+      info->bytes_per_px = 3;
      info->seen_flags |= TUPLE_FLAG;
    } else if (!strcmp(out, "TUPLTYPE GRAYSCALE")) {
-      expected_depth = 1;
+      info->bytes_per_px = 1;
      info->seen_flags |= TUPLE_FLAG;
    } else if (!strcmp(out, "ENDHDR")) {
      break;
@ -111,24 +110,23 @@ static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
      int i;
      if (out_size > 20) sprintf(out + 20 - strlen(kEllipsis), kEllipsis);
      for (i = 0; i < (int)strlen(out); ++i) {
-        // isprint() might trigger a "char-subscripts" warning if given a char.
-        if (!isprint((int)out[i])) out[i] = ' ';
+        if (!isprint(out[i])) out[i] = ' ';
      }
      fprintf(stderr, "PAM header error: unrecognized entry [%s]\n", out);
      return 0;
    }
  }
-  if (!(info->seen_flags & ALL_NEEDED_FLAGS)) {
-    fprintf(stderr, "PAM header error: missing tags%s%s%s%s\n",
-            (info->seen_flags & WIDTH_FLAG) ? "" : " WIDTH",
-            (info->seen_flags & HEIGHT_FLAG) ? "" : " HEIGHT",
-            (info->seen_flags & DEPTH_FLAG) ? "" : " DEPTH",
-            (info->seen_flags & MAXVAL_FLAG) ? "" : " MAXVAL");
-    return 0;
+  if (!(info->seen_flags & TUPLE_FLAG)) {
+    if (info->depth > 0 && info->depth <= 4 && info->depth != 2) {
+      info->seen_flags |= TUPLE_FLAG;
+      info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
+    } else {
+      fprintf(stderr, "PAM: invalid bitdepth (%d).\n", info->depth);
+      return 0;
+    }
  }
-  if (expected_depth != -1 && info->depth != expected_depth) {
-    fprintf(stderr, "PAM header error: expected DEPTH %d but got DEPTH %d\n",
-            expected_depth, info->depth);
+  if (info->seen_flags != ALL_NEEDED_FLAGS) {
+    fprintf(stderr, "PAM: incomplete header.\n");
    return 0;
  }
  return off;
@ -162,15 +160,16 @@ static size_t ReadHeader(PNMInfo* const info) {

    // finish initializing missing fields
    info->depth = (info->type == 5) ? 1 : 3;
+    info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
  }
  // perform some basic numerical validation
  if (info->width <= 0 || info->height <= 0 ||
      info->type <= 0 || info->type >= 9 ||
      info->depth <= 0 || info->depth == 2 || info->depth > 4 ||
+      info->bytes_per_px < info->depth ||
      info->max_value <= 0 || info->max_value >= 65536) {
    return 0;
  }
-  info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
  return off;
 }

--- a/imageio/tiffdec.c
+++ b/imageio/tiffdec.c
@ -156,7 +156,7 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
             Metadata* const metadata) {
  MyData my_data = { data, (toff_t)data_size, 0 };
  TIFF* tif;
-  uint32_t image_width, image_height, tile_width, tile_height;
+  uint32_t width, height;
  uint16_t samples_per_px = 0;
  uint16_t extra_samples = 0;
  uint16_t* extra_samples_ptr = NULL;
@ -189,25 +189,15 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
  }
  if (samples_per_px < 3 || samples_per_px > 4) goto End;  // not supported

-  if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &image_width) &&
-        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &image_height))) {
+  if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) &&
+        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))) {
    fprintf(stderr, "Error! Cannot retrieve TIFF image dimensions.\n");
    goto End;
  }
-  if (!ImgIoUtilCheckSizeArgumentsOverflow((uint64_t)image_width * image_height,
+  if (!ImgIoUtilCheckSizeArgumentsOverflow((uint64_t)width * height,
                                           sizeof(*raster))) {
    goto End;
  }
-  // According to spec, a tile can be bigger than the image. However it should
-  // be a multiple of 16 and not way too large, so check that it's not more than
-  // twice the image size, for dimensions above some arbitrary minimum 32.
-  if ((TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width) &&
-       tile_width > 32 && tile_width / 2 > image_width) ||
-      (TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height) &&
-       tile_height > 32 && tile_height / 2 > image_height)) {
-    fprintf(stderr, "Error! TIFF tile dimensions are too big.\n");
-    goto End;
-  }
  if (samples_per_px > 3 && !TIFFGetField(tif, TIFFTAG_EXTRASAMPLES,
                                          &extra_samples, &extra_samples_ptr)) {
    fprintf(stderr, "Error! Cannot retrieve TIFF ExtraSamples info.\n");
@ -215,28 +205,27 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
  }

  // _Tiffmalloc uses a signed type for size.
-  alloc_size =
-      (int64_t)((uint64_t)image_width * image_height * sizeof(*raster));
+  alloc_size = (int64_t)((uint64_t)width * height * sizeof(*raster));
  if (alloc_size < 0 || alloc_size != (tsize_t)alloc_size) goto End;

  raster = (uint32*)_TIFFmalloc((tsize_t)alloc_size);
  if (raster != NULL) {
-    if (TIFFReadRGBAImageOriented(tif, image_width, image_height, raster,
+    if (TIFFReadRGBAImageOriented(tif, width, height, raster,
                                  ORIENTATION_TOPLEFT, 1)) {
-      const int stride = image_width * sizeof(*raster);
-      pic->width = image_width;
-      pic->height = image_height;
+      const int stride = width * sizeof(*raster);
+      pic->width = width;
+      pic->height = height;
      // TIFF data is ABGR
 #ifdef WORDS_BIGENDIAN
-      TIFFSwabArrayOfLong(raster, image_width * image_height);
+      TIFFSwabArrayOfLong(raster, width * height);
 #endif
      // if we have an alpha channel, we must un-multiply from rgbA to RGBA
      if (extra_samples == 1 && extra_samples_ptr != NULL &&
          extra_samples_ptr[0] == EXTRASAMPLE_ASSOCALPHA) {
        uint32_t y;
        uint8_t* tmp = (uint8_t*)raster;
-        for (y = 0; y < image_height; ++y) {
-          MultARGBRow(tmp, image_width);
+        for (y = 0; y < height; ++y) {
+          MultARGBRow(tmp, width);
          tmp += stride;
        }
      }
--- a/iosbuild.sh
+++ b/iosbuild.sh
@ -35,15 +35,11 @@ readonly TOPDIR=$(pwd)
 readonly BUILDDIR="${TOPDIR}/iosbuild"
 readonly TARGETDIR="${TOPDIR}/WebP.framework"
 readonly DECTARGETDIR="${TOPDIR}/WebPDecoder.framework"
-readonly MUXTARGETDIR="${TOPDIR}/WebPMux.framework"
-readonly DEMUXTARGETDIR="${TOPDIR}/WebPDemux.framework"
 readonly DEVELOPER=$(xcode-select --print-path)
 readonly PLATFORMSROOT="${DEVELOPER}/Platforms"
 readonly LIPO=$(xcrun -sdk iphoneos${SDK} -find lipo)
 LIBLIST=''
 DECLIBLIST=''
-MUXLIBLIST=''
-DEMUXLIBLIST=''

 if [[ -z "${SDK}" ]]; then
  echo "iOS SDK not available"
@ -57,10 +53,8 @@ else
  echo "iOS SDK Version ${SDK}"
 fi

-rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR} \
-    ${MUXTARGETDIR} ${DEMUXTARGETDIR}
-mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/ \
-    ${MUXTARGETDIR}/Headers/ ${DEMUXTARGETDIR}/Headers/
+rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR}
+mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/

 if [[ ! -e ${SRCDIR}/configure ]]; then
  if ! (cd ${SRCDIR} && sh autogen.sh); then
@ -111,7 +105,6 @@ for PLATFORM in ${PLATFORMS}; do
    --build=$(${SRCDIR}/config.guess) \
    --disable-shared --enable-static \
    --enable-libwebpdecoder --enable-swap-16bit-csp \
-    --enable-libwebpmux \
    CFLAGS="${CFLAGS}"
  set +x

@ -122,8 +115,6 @@ for PLATFORM in ${PLATFORMS}; do

  LIBLIST+=" ${ROOTDIR}/lib/libwebp.a"
  DECLIBLIST+=" ${ROOTDIR}/lib/libwebpdecoder.a"
-  MUXLIBLIST+=" ${ROOTDIR}/lib/libwebpmux.a"
-  DEMUXLIBLIST+=" ${ROOTDIR}/lib/libwebpdemux.a"

  make clean
  cd ..
@ -131,20 +122,8 @@ for PLATFORM in ${PLATFORMS}; do
  export PATH=${OLDPATH}
 done

-echo "LIBLIST = ${LIBLIST}"
 cp -a ${SRCDIR}/src/webp/{decode,encode,types}.h ${TARGETDIR}/Headers/
 ${LIPO} -create ${LIBLIST} -output ${TARGETDIR}/WebP

-echo "DECLIBLIST = ${DECLIBLIST}"
 cp -a ${SRCDIR}/src/webp/{decode,types}.h ${DECTARGETDIR}/Headers/
 ${LIPO} -create ${DECLIBLIST} -output ${DECTARGETDIR}/WebPDecoder
-
-echo "MUXLIBLIST = ${MUXLIBLIST}"
-cp -a ${SRCDIR}/src/webp/{types,mux,mux_types}.h \
-    ${MUXTARGETDIR}/Headers/
-${LIPO} -create ${MUXLIBLIST} -output ${MUXTARGETDIR}/WebPMux
-
-echo "DEMUXLIBLIST = ${DEMUXLIBLIST}"
-cp -a ${SRCDIR}/src/webp/{decode,types,mux_types,demux}.h \
-    ${DEMUXTARGETDIR}/Headers/
-${LIPO} -create ${DEMUXLIBLIST} -output ${DEMUXTARGETDIR}/WebPDemux
--- a/makefile.unix
+++ b/makefile.unix
@ -118,10 +118,6 @@ GROFF = /usr/bin/groff
 COL = /usr/bin/col
 LDFLAGS = $(EXTRA_LIBS) $(EXTRA_FLAGS) -lm

-ifdef BITTRACE
-CFLAGS += -DBITTRACE=$(BITTRACE)
-endif
-
 ANIM_UTIL_OBJS = \
    examples/anim_util.o \

@ -402,7 +398,7 @@ examples/webpinfo: examples/webpinfo.o
 examples/anim_diff: examples/libanim_util.a examples/libgifdec.a
 examples/anim_diff: src/demux/libwebpdemux.a examples/libexample_util.a
 examples/anim_diff: imageio/libimageio_util.a src/libwebp.a
-examples/anim_diff: override EXTRA_LIBS += $(GIF_LIBS)
+examples/anim_diff: EXTRA_LIBS += $(GIF_LIBS)
 examples/anim_diff: EXTRA_FLAGS += -DWEBP_HAVE_GIF
 examples/anim_dump: examples/libanim_util.a examples/libgifdec.a
 examples/anim_dump: src/demux/libwebpdemux.a
@ -410,27 +406,27 @@ examples/anim_dump: examples/libexample_util.a
 examples/anim_dump: imageio/libimageio_util.a
 examples/anim_dump: imageio/libimageenc.a
 examples/anim_dump: src/libwebp.a
-examples/anim_dump: override EXTRA_LIBS += $(GIF_LIBS) $(DWEBP_LIBS)
+examples/anim_dump: EXTRA_LIBS += $(GIF_LIBS) $(DWEBP_LIBS)
 examples/cwebp: examples/libexample_util.a
 examples/cwebp: imageio/libimagedec.a
 examples/cwebp: src/demux/libwebpdemux.a
 examples/cwebp: imageio/libimageio_util.a
 examples/cwebp: src/libwebp.a
-examples/cwebp: override EXTRA_LIBS += $(CWEBP_LIBS)
+examples/cwebp: EXTRA_LIBS += $(CWEBP_LIBS)
 examples/dwebp: examples/libexample_util.a
 examples/dwebp: imageio/libimagedec.a
 examples/dwebp: src/demux/libwebpdemux.a
 examples/dwebp: imageio/libimageenc.a
 examples/dwebp: imageio/libimageio_util.a
 examples/dwebp: src/libwebp.a
-examples/dwebp: override EXTRA_LIBS += $(DWEBP_LIBS)
+examples/dwebp: EXTRA_LIBS += $(DWEBP_LIBS)
 examples/gif2webp: examples/libexample_util.a imageio/libimageio_util.a
 examples/gif2webp: examples/libgifdec.a src/mux/libwebpmux.a src/libwebp.a
-examples/gif2webp: override EXTRA_LIBS += $(GIF_LIBS)
+examples/gif2webp: EXTRA_LIBS += $(GIF_LIBS)
 examples/gif2webp: EXTRA_FLAGS += -DWEBP_HAVE_GIF
 examples/vwebp: examples/libexample_util.a src/demux/libwebpdemux.a
 examples/vwebp: imageio/libimageio_util.a src/libwebp.a
-examples/vwebp: override EXTRA_LIBS += $(GL_LIBS)
+examples/vwebp: EXTRA_LIBS += $(GL_LIBS)
 examples/vwebp: EXTRA_FLAGS += -DWEBP_HAVE_GL
 examples/webpmux: examples/libexample_util.a imageio/libimageio_util.a
 examples/webpmux: src/mux/libwebpmux.a src/libwebpdecoder.a
@ -438,7 +434,7 @@ examples/img2webp: examples/libexample_util.a imageio/libimageio_util.a
 examples/img2webp: imageio/libimagedec.a
 examples/img2webp: src/demux/libwebpdemux.a
 examples/img2webp: src/mux/libwebpmux.a src/libwebp.a
-examples/img2webp: override EXTRA_LIBS += $(CWEBP_LIBS)
+examples/img2webp: EXTRA_LIBS += $(CWEBP_LIBS)
 examples/webpinfo: examples/libexample_util.a imageio/libimageio_util.a
 examples/webpinfo: src/libwebpdecoder.a

@ -447,7 +443,7 @@ extras/get_disto: imageio/libimagedec.a
 extras/get_disto: src/demux/libwebpdemux.a
 extras/get_disto: imageio/libimageio_util.a
 extras/get_disto: src/libwebp.a
-extras/get_disto: override EXTRA_LIBS += $(CWEBP_LIBS)
+extras/get_disto: EXTRA_LIBS += $(CWEBP_LIBS)

 extras/webp_quality: extras/webp_quality.o
 extras/webp_quality: imageio/libimageio_util.a
@ -458,7 +454,7 @@ extras/vwebp_sdl: extras/webp_to_sdl.o
 extras/vwebp_sdl: imageio/libimageio_util.a
 extras/vwebp_sdl: src/libwebp.a
 extras/vwebp_sdl: EXTRA_FLAGS += -DWEBP_HAVE_SDL $(SDL_FLAGS)
-extras/vwebp_sdl: override EXTRA_LIBS += $(SDL_LIBS)
+extras/vwebp_sdl: EXTRA_LIBS += $(SDL_LIBS)

 $(OUT_EXAMPLES) $(EXTRA_EXAMPLES) $(OTHER_EXAMPLES):
 	$(CC) -o $@ $^ $(LDFLAGS)
--- a/man/vwebp.1
+++ b/man/vwebp.1
@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH VWEBP 1 "June 5, 2019"
+.TH VWEBP 1 "July 20, 2018"
 .SH NAME
 vwebp \- decompress a WebP file and display it in a window
 .SH SYNOPSIS
--- a/src/Makefile.am
+++ b/src/Makefile.am
@ -36,7 +36,7 @@ libwebp_la_LIBADD += utils/libwebputils.la
 # other than the ones listed on the command line, i.e., after linking, it will
 # not have unresolved symbols. Some platforms (Windows among them) require all
 # symbols in shared libraries to be resolved at library creation.
-libwebp_la_LDFLAGS = -no-undefined -version-info 8:0:1
+libwebp_la_LDFLAGS = -no-undefined -version-info 7:4:0
 libwebpincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebp.pc

@ -48,7 +48,7 @@ if BUILD_LIBWEBPDECODER
  libwebpdecoder_la_LIBADD += dsp/libwebpdspdecode.la
  libwebpdecoder_la_LIBADD += utils/libwebputilsdecode.la

-  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 4:0:1
+  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 3:4:0
  pkgconfig_DATA += libwebpdecoder.pc
 endif

--- a/src/dec/frame_dec.c
+++ b/src/dec/frame_dec.c
@ -732,7 +732,7 @@ static int AllocateMemory(VP8Decoder* const dec) {
  mem += f_info_size;
  dec->thread_ctx_.id_ = 0;
  dec->thread_ctx_.f_info_ = dec->f_info_;
-  if (dec->filter_type_ > 0 && dec->mt_method_ > 0) {
+  if (dec->mt_method_ > 0) {
    // secondary cache line. The deblocking process need to make use of the
    // filtering strength from previous macroblock row, while the new ones
    // are being decoded in parallel. We'll just swap the pointers.
--- a/src/dec/idec_dec.c
+++ b/src/dec/idec_dec.c
@ -166,11 +166,9 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
  VP8Decoder* const dec = (VP8Decoder*)idec->dec_;
  MemBuffer* const mem = &idec->mem_;
  const int need_compressed_alpha = NeedCompressedAlpha(idec);
-  const uint8_t* const old_start =
-      (mem->buf_ == NULL) ? NULL : mem->buf_ + mem->start_;
+  const uint8_t* const old_start = mem->buf_ + mem->start_;
  const uint8_t* const old_base =
      need_compressed_alpha ? dec->alpha_data_ : old_start;
-  assert(mem->buf_ != NULL || mem->start_ == 0);
  assert(mem->mode_ == MEM_MODE_APPEND);
  if (data_size > MAX_CHUNK_PAYLOAD) {
    // security safeguard: trying to allocate more than what the format
@ -186,7 +184,7 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
    uint8_t* const new_buf =
        (uint8_t*)WebPSafeMalloc(extra_size, sizeof(*new_buf));
    if (new_buf == NULL) return 0;
-    if (old_base != NULL) memcpy(new_buf, old_base, current_size);
+    memcpy(new_buf, old_base, current_size);
    WebPSafeFree(mem->buf_);
    mem->buf_ = new_buf;
    mem->buf_size_ = (size_t)extra_size;
@ -194,7 +192,6 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
    mem->end_ = current_size;
  }

-  assert(mem->buf_ != NULL);
  memcpy(mem->buf_ + mem->end_, data, data_size);
  mem->end_ += data_size;
  assert(mem->end_ <= mem->buf_size_);
@ -207,9 +204,7 @@ static int RemapMemBuffer(WebPIDecoder* const idec,
                          const uint8_t* const data, size_t data_size) {
  MemBuffer* const mem = &idec->mem_;
  const uint8_t* const old_buf = mem->buf_;
-  const uint8_t* const old_start =
-      (old_buf == NULL) ? NULL : old_buf + mem->start_;
-  assert(old_buf != NULL || mem->start_ == 0);
+  const uint8_t* const old_start = old_buf + mem->start_;
  assert(mem->mode_ == MEM_MODE_MAP);

  if (data_size < mem->buf_size_) return 0;  // can't remap to a shorter buffer!
--- a/src/dec/quant_dec.c
+++ b/src/dec/quant_dec.c
@ -61,17 +61,12 @@ static const uint16_t kAcTable[128] = {

 void VP8ParseQuant(VP8Decoder* const dec) {
  VP8BitReader* const br = &dec->br_;
-  const int base_q0 = VP8GetValue(br, 7, "global-header");
-  const int dqy1_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dqy2_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dqy2_ac = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dquv_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dquv_ac = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
+  const int base_q0 = VP8GetValue(br, 7);
+  const int dqy1_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dqy2_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dqy2_ac = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dquv_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dquv_ac = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;

  const VP8SegmentHeader* const hdr = &dec->segment_hdr_;
  int i;
--- a/src/dec/tree_dec.c
+++ b/src/dec/tree_dec.c
@ -296,21 +296,20 @@ static void ParseIntraMode(VP8BitReader* const br,
  // to decode more than 1 keyframe.
  if (dec->segment_hdr_.update_map_) {
    // Hardcoded tree parsing
-    block->segment_ = !VP8GetBit(br, dec->proba_.segments_[0], "segments")
-                    ?  VP8GetBit(br, dec->proba_.segments_[1], "segments")
-                    :  VP8GetBit(br, dec->proba_.segments_[2], "segments") + 2;
+    block->segment_ = !VP8GetBit(br, dec->proba_.segments_[0])
+                    ? VP8GetBit(br, dec->proba_.segments_[1])
+                    : 2 + VP8GetBit(br, dec->proba_.segments_[2]);
  } else {
    block->segment_ = 0;  // default for intra
  }
-  if (dec->use_skip_proba_) block->skip_ = VP8GetBit(br, dec->skip_p_, "skip");
+  if (dec->use_skip_proba_) block->skip_ = VP8GetBit(br, dec->skip_p_);

-  block->is_i4x4_ = !VP8GetBit(br, 145, "block-size");
+  block->is_i4x4_ = !VP8GetBit(br, 145);   // decide for B_PRED first
  if (!block->is_i4x4_) {
    // Hardcoded 16x16 intra-mode decision tree.
    const int ymode =
-        VP8GetBit(br, 156, "pred-modes") ?
-            (VP8GetBit(br, 128, "pred-modes") ? TM_PRED : H_PRED) :
-            (VP8GetBit(br, 163, "pred-modes") ? V_PRED : DC_PRED);
+        VP8GetBit(br, 156) ? (VP8GetBit(br, 128) ? TM_PRED : H_PRED)
+                           : (VP8GetBit(br, 163) ? V_PRED : DC_PRED);
    block->imodes_[0] = ymode;
    memset(top, ymode, 4 * sizeof(*top));
    memset(left, ymode, 4 * sizeof(*left));
@ -324,25 +323,22 @@ static void ParseIntraMode(VP8BitReader* const br,
        const uint8_t* const prob = kBModesProba[top[x]][ymode];
 #if (USE_GENERIC_TREE == 1)
        // Generic tree-parsing
-        int i = kYModesIntra4[VP8GetBit(br, prob[0], "pred-modes")];
+        int i = kYModesIntra4[VP8GetBit(br, prob[0])];
        while (i > 0) {
-          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i], "pred-modes")];
+          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i])];
        }
        ymode = -i;
 #else
        // Hardcoded tree parsing
-        ymode = !VP8GetBit(br, prob[0], "pred-modes") ? B_DC_PRED :
-                  !VP8GetBit(br, prob[1], "pred-modes") ? B_TM_PRED :
-                    !VP8GetBit(br, prob[2], "pred-modes") ? B_VE_PRED :
-                      !VP8GetBit(br, prob[3], "pred-modes") ?
-                        (!VP8GetBit(br, prob[4], "pred-modes") ? B_HE_PRED :
-                          (!VP8GetBit(br, prob[5], "pred-modes") ? B_RD_PRED
-                                                                 : B_VR_PRED)) :
-                        (!VP8GetBit(br, prob[6], "pred-modes") ? B_LD_PRED :
-                          (!VP8GetBit(br, prob[7], "pred-modes") ? B_VL_PRED :
-                            (!VP8GetBit(br, prob[8], "pred-modes") ? B_HD_PRED
-                                                                   : B_HU_PRED))
-                        );
+        ymode = !VP8GetBit(br, prob[0]) ? B_DC_PRED :
+                  !VP8GetBit(br, prob[1]) ? B_TM_PRED :
+                    !VP8GetBit(br, prob[2]) ? B_VE_PRED :
+                      !VP8GetBit(br, prob[3]) ?
+                        (!VP8GetBit(br, prob[4]) ? B_HE_PRED :
+                          (!VP8GetBit(br, prob[5]) ? B_RD_PRED : B_VR_PRED)) :
+                        (!VP8GetBit(br, prob[6]) ? B_LD_PRED :
+                          (!VP8GetBit(br, prob[7]) ? B_VL_PRED :
+                            (!VP8GetBit(br, prob[8]) ? B_HD_PRED : B_HU_PRED)));
 #endif  // USE_GENERIC_TREE
        top[x] = ymode;
      }
@ -352,9 +348,9 @@ static void ParseIntraMode(VP8BitReader* const br,
    }
  }
  // Hardcoded UVMode decision tree
-  block->uvmode_ = !VP8GetBit(br, 142, "pred-modes-uv") ? DC_PRED
-                 : !VP8GetBit(br, 114, "pred-modes-uv") ? V_PRED
-                 : VP8GetBit(br, 183, "pred-modes-uv") ? TM_PRED : H_PRED;
+  block->uvmode_ = !VP8GetBit(br, 142) ? DC_PRED
+                 : !VP8GetBit(br, 114) ? V_PRED
+                 : VP8GetBit(br, 183) ? TM_PRED : H_PRED;
 }

 int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
@ -518,10 +514,8 @@ void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
    for (b = 0; b < NUM_BANDS; ++b) {
      for (c = 0; c < NUM_CTX; ++c) {
        for (p = 0; p < NUM_PROBAS; ++p) {
-          const int v =
-              VP8GetBit(br, CoeffsUpdateProba[t][b][c][p], "global-header") ?
-                        VP8GetValue(br, 8, "global-header") :
-                        CoeffsProba0[t][b][c][p];
+          const int v = VP8GetBit(br, CoeffsUpdateProba[t][b][c][p]) ?
+                        VP8GetValue(br, 8) : CoeffsProba0[t][b][c][p];
          proba->bands_[t][b].probas_[c][p] = v;
        }
      }
@ -530,8 +524,9 @@ void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
      proba->bands_ptr_[t][b] = &proba->bands_[t][kBands[b]];
    }
  }
-  dec->use_skip_proba_ = VP8Get(br, "global-header");
+  dec->use_skip_proba_ = VP8Get(br);
  if (dec->use_skip_proba_) {
-    dec->skip_p_ = VP8GetValue(br, 8, "global-header");
+    dec->skip_p_ = VP8GetValue(br, 8);
  }
 }
+
--- a/src/dec/vp8_dec.c
+++ b/src/dec/vp8_dec.c
@ -161,26 +161,23 @@ static int ParseSegmentHeader(VP8BitReader* br,
                              VP8SegmentHeader* hdr, VP8Proba* proba) {
  assert(br != NULL);
  assert(hdr != NULL);
-  hdr->use_segment_ = VP8Get(br, "global-header");
+  hdr->use_segment_ = VP8Get(br);
  if (hdr->use_segment_) {
-    hdr->update_map_ = VP8Get(br, "global-header");
-    if (VP8Get(br, "global-header")) {   // update data
+    hdr->update_map_ = VP8Get(br);
+    if (VP8Get(br)) {   // update data
      int s;
-      hdr->absolute_delta_ = VP8Get(br, "global-header");
+      hdr->absolute_delta_ = VP8Get(br);
      for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->quantizer_[s] = VP8Get(br, "global-header") ?
-            VP8GetSignedValue(br, 7, "global-header") : 0;
+        hdr->quantizer_[s] = VP8Get(br) ? VP8GetSignedValue(br, 7) : 0;
      }
      for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->filter_strength_[s] = VP8Get(br, "global-header") ?
-            VP8GetSignedValue(br, 6, "global-header") : 0;
+        hdr->filter_strength_[s] = VP8Get(br) ? VP8GetSignedValue(br, 6) : 0;
      }
    }
    if (hdr->update_map_) {
      int s;
      for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
-        proba->segments_[s] = VP8Get(br, "global-header") ?
-            VP8GetValue(br, 8, "global-header") : 255u;
+        proba->segments_[s] = VP8Get(br) ? VP8GetValue(br, 8) : 255u;
      }
    }
  } else {
@ -208,7 +205,7 @@ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
  size_t last_part;
  size_t p;

-  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2, "global-header")) - 1;
+  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2)) - 1;
  last_part = dec->num_parts_minus_one_;
  if (size < 3 * last_part) {
    // we can't even read the sizes with sz[]! That's a failure.
@ -232,21 +229,21 @@ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
 // Paragraph 9.4
 static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
  VP8FilterHeader* const hdr = &dec->filter_hdr_;
-  hdr->simple_    = VP8Get(br, "global-header");
-  hdr->level_     = VP8GetValue(br, 6, "global-header");
-  hdr->sharpness_ = VP8GetValue(br, 3, "global-header");
-  hdr->use_lf_delta_ = VP8Get(br, "global-header");
+  hdr->simple_    = VP8Get(br);
+  hdr->level_     = VP8GetValue(br, 6);
+  hdr->sharpness_ = VP8GetValue(br, 3);
+  hdr->use_lf_delta_ = VP8Get(br);
  if (hdr->use_lf_delta_) {
-    if (VP8Get(br, "global-header")) {   // update lf-delta?
+    if (VP8Get(br)) {   // update lf-delta?
      int i;
      for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
-        if (VP8Get(br, "global-header")) {
-          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
+        if (VP8Get(br)) {
+          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6);
        }
      }
      for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
-        if (VP8Get(br, "global-header")) {
-          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
+        if (VP8Get(br)) {
+          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6);
        }
      }
    }
@ -355,8 +352,8 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
  buf_size -= frm_hdr->partition_length_;

  if (frm_hdr->key_frame_) {
-    pic_hdr->colorspace_ = VP8Get(br, "global-header");
-    pic_hdr->clamp_type_ = VP8Get(br, "global-header");
+    pic_hdr->colorspace_ = VP8Get(br);
+    pic_hdr->clamp_type_ = VP8Get(br);
  }
  if (!ParseSegmentHeader(br, &dec->segment_hdr_, &dec->proba_)) {
    return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
@ -381,7 +378,7 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
                       "Not a key frame.");
  }

-  VP8Get(br, "global-header");   // ignore the value of update_proba_
+  VP8Get(br);   // ignore the value of update_proba_

  VP8ParseProba(br, dec);

@ -406,28 +403,28 @@ static const uint8_t kZigzag[16] = {
 // See section 13-2: http://tools.ietf.org/html/rfc6386#section-13.2
 static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
  int v;
-  if (!VP8GetBit(br, p[3], "coeffs")) {
-    if (!VP8GetBit(br, p[4], "coeffs")) {
+  if (!VP8GetBit(br, p[3])) {
+    if (!VP8GetBit(br, p[4])) {
      v = 2;
    } else {
-      v = 3 + VP8GetBit(br, p[5], "coeffs");
+      v = 3 + VP8GetBit(br, p[5]);
    }
  } else {
-    if (!VP8GetBit(br, p[6], "coeffs")) {
-      if (!VP8GetBit(br, p[7], "coeffs")) {
-        v = 5 + VP8GetBit(br, 159, "coeffs");
+    if (!VP8GetBit(br, p[6])) {
+      if (!VP8GetBit(br, p[7])) {
+        v = 5 + VP8GetBit(br, 159);
      } else {
-        v = 7 + 2 * VP8GetBit(br, 165, "coeffs");
-        v += VP8GetBit(br, 145, "coeffs");
+        v = 7 + 2 * VP8GetBit(br, 165);
+        v += VP8GetBit(br, 145);
      }
    } else {
      const uint8_t* tab;
-      const int bit1 = VP8GetBit(br, p[8], "coeffs");
-      const int bit0 = VP8GetBit(br, p[9 + bit1], "coeffs");
+      const int bit1 = VP8GetBit(br, p[8]);
+      const int bit0 = VP8GetBit(br, p[9 + bit1]);
      const int cat = 2 * bit1 + bit0;
      v = 0;
      for (tab = kCat3456[cat]; *tab; ++tab) {
-        v += v + VP8GetBit(br, *tab, "coeffs");
+        v += v + VP8GetBit(br, *tab);
      }
      v += 3 + (8 << cat);
    }
@ -441,24 +438,24 @@ static int GetCoeffsFast(VP8BitReader* const br,
                         int ctx, const quant_t dq, int n, int16_t* out) {
  const uint8_t* p = prob[n]->probas_[ctx];
  for (; n < 16; ++n) {
-    if (!VP8GetBit(br, p[0], "coeffs")) {
+    if (!VP8GetBit(br, p[0])) {
      return n;  // previous coeff was last non-zero coeff
    }
-    while (!VP8GetBit(br, p[1], "coeffs")) {       // sequence of zero coeffs
+    while (!VP8GetBit(br, p[1])) {       // sequence of zero coeffs
      p = prob[++n]->probas_[0];
      if (n == 16) return 16;
    }
    {        // non zero coeff
      const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas_[0];
      int v;
-      if (!VP8GetBit(br, p[2], "coeffs")) {
+      if (!VP8GetBit(br, p[2])) {
        v = 1;
        p = p_ctx[1];
      } else {
        v = GetLargeValue(br, p);
        p = p_ctx[2];
      }
-      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
+      out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
    }
  }
  return 16;
@ -471,24 +468,24 @@ static int GetCoeffsAlt(VP8BitReader* const br,
                        int ctx, const quant_t dq, int n, int16_t* out) {
  const uint8_t* p = prob[n]->probas_[ctx];
  for (; n < 16; ++n) {
-    if (!VP8GetBitAlt(br, p[0], "coeffs")) {
+    if (!VP8GetBitAlt(br, p[0])) {
      return n;  // previous coeff was last non-zero coeff
    }
-    while (!VP8GetBitAlt(br, p[1], "coeffs")) {       // sequence of zero coeffs
+    while (!VP8GetBitAlt(br, p[1])) {       // sequence of zero coeffs
      p = prob[++n]->probas_[0];
      if (n == 16) return 16;
    }
    {        // non zero coeff
      const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas_[0];
      int v;
-      if (!VP8GetBitAlt(br, p[2], "coeffs")) {
+      if (!VP8GetBitAlt(br, p[2])) {
        v = 1;
        p = p_ctx[1];
      } else {
        v = GetLargeValue(br, p);
        p = p_ctx[2];
      }
-      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
+      out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
    }
  }
  return 16;
--- a/src/dec/vp8i_dec.h
+++ b/src/dec/vp8i_dec.h
@ -31,8 +31,8 @@ extern "C" {

 // version numbers
 #define DEC_MAJ_VERSION 1
-#define DEC_MIN_VERSION 1
-#define DEC_REV_VERSION 0
+#define DEC_MIN_VERSION 0
+#define DEC_REV_VERSION 2

 // YUV-cache parameters. Cache is 32-bytes wide (= one cacheline).
 // Constraints are: We need to store one 16x16 block of luma samples (y),
--- a/src/dec/vp8l_dec.c
+++ b/src/dec/vp8l_dec.c
@ -253,11 +253,11 @@ static int ReadHuffmanCodeLengths(
  int symbol;
  int max_symbol;
  int prev_code_len = DEFAULT_CODE_LENGTH;
-  HuffmanTables tables;
+  HuffmanCode table[1 << LENGTHS_TABLE_BITS];

-  if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables) ||
-      !VP8LBuildHuffmanTable(&tables, LENGTHS_TABLE_BITS,
-                             code_length_code_lengths, NUM_CODE_LENGTH_CODES)) {
+  if (!VP8LBuildHuffmanTable(table, LENGTHS_TABLE_BITS,
+                             code_length_code_lengths,
+                             NUM_CODE_LENGTH_CODES)) {
    goto End;
  }

@ -277,7 +277,7 @@ static int ReadHuffmanCodeLengths(
    int code_len;
    if (max_symbol-- == 0) break;
    VP8LFillBitWindow(br);
-    p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
+    p = &table[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
    VP8LSetBitPos(br, br->bit_pos_ + p->bits);
    code_len = p->value;
    if (code_len < kCodeLengthLiterals) {
@ -300,7 +300,6 @@ static int ReadHuffmanCodeLengths(
  ok = 1;

 End:
-  VP8LHuffmanTablesDeallocate(&tables);
  if (!ok) dec->status_ = VP8_STATUS_BITSTREAM_ERROR;
  return ok;
 }
@ -308,8 +307,7 @@ static int ReadHuffmanCodeLengths(
 // 'code_lengths' is pre-allocated temporary buffer, used for creating Huffman
 // tree.
 static int ReadHuffmanCode(int alphabet_size, VP8LDecoder* const dec,
-                           int* const code_lengths,
-                           HuffmanTables* const table) {
+                           int* const code_lengths, HuffmanCode* const table) {
  int ok = 0;
  int size = 0;
  VP8LBitReader* const br = &dec->br_;
@ -364,7 +362,12 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
  VP8LMetadata* const hdr = &dec->hdr_;
  uint32_t* huffman_image = NULL;
  HTreeGroup* htree_groups = NULL;
-  HuffmanTables* huffman_tables = &hdr->huffman_tables_;
+  // When reading htrees, some might be unused, as the format allows it.
+  // We will still read them but put them in this htree_group_bogus.
+  HTreeGroup htree_group_bogus;
+  HuffmanCode* huffman_tables = NULL;
+  HuffmanCode* huffman_tables_bogus = NULL;
+  HuffmanCode* next = NULL;
  int num_htree_groups = 1;
  int num_htree_groups_max = 1;
  int max_alphabet_size = 0;
@ -373,10 +376,6 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
  int* mapping = NULL;
  int ok = 0;

-  // Check the table has been 0 initialized (through InitMetadata).
-  assert(huffman_tables->root.start == NULL);
-  assert(huffman_tables->curr_segment == NULL);
-
  if (allow_recursion && VP8LReadBits(br, 1)) {
    // use meta Huffman codes.
    const int huffman_precision = VP8LReadBits(br, 3) + 2;
@ -419,6 +418,12 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
        if (*mapped_group == -1) *mapped_group = num_htree_groups++;
        huffman_image[i] = *mapped_group;
      }
+      huffman_tables_bogus = (HuffmanCode*)WebPSafeMalloc(
+          table_size, sizeof(*huffman_tables_bogus));
+      if (huffman_tables_bogus == NULL) {
+        dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
+        goto Error;
+      }
    } else {
      num_htree_groups = num_htree_groups_max;
    }
@ -439,80 +444,72 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,

  code_lengths = (int*)WebPSafeCalloc((uint64_t)max_alphabet_size,
                                      sizeof(*code_lengths));
+  huffman_tables = (HuffmanCode*)WebPSafeMalloc(num_htree_groups * table_size,
+                                                sizeof(*huffman_tables));
  htree_groups = VP8LHtreeGroupsNew(num_htree_groups);

-  if (htree_groups == NULL || code_lengths == NULL ||
-      !VP8LHuffmanTablesAllocate(num_htree_groups * table_size,
-                                 huffman_tables)) {
+  if (htree_groups == NULL || code_lengths == NULL || huffman_tables == NULL) {
    dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
    goto Error;
  }

+  next = huffman_tables;
  for (i = 0; i < num_htree_groups_max; ++i) {
-    // If the index "i" is unused in the Huffman image, just make sure the
-    // coefficients are valid but do not store them.
-    if (mapping != NULL && mapping[i] == -1) {
-      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
-        int alphabet_size = kAlphabetSize[j];
-        if (j == 0 && color_cache_bits > 0) {
-          alphabet_size += (1 << color_cache_bits);
-        }
-        // Passing in NULL so that nothing gets filled.
-        if (!ReadHuffmanCode(alphabet_size, dec, code_lengths, NULL)) {
-          goto Error;
-        }
+    // If the index "i" is unused in the Huffman image, read the coefficients
+    // but store them to a bogus htree_group.
+    const int is_bogus = (mapping != NULL && mapping[i] == -1);
+    HTreeGroup* const htree_group =
+        is_bogus ? &htree_group_bogus :
+        &htree_groups[(mapping == NULL) ? i : mapping[i]];
+    HuffmanCode** const htrees = htree_group->htrees;
+    HuffmanCode* huffman_tables_i = is_bogus ? huffman_tables_bogus : next;
+    int size;
+    int total_size = 0;
+    int is_trivial_literal = 1;
+    int max_bits = 0;
+    for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
+      int alphabet_size = kAlphabetSize[j];
+      htrees[j] = huffman_tables_i;
+      if (j == 0 && color_cache_bits > 0) {
+        alphabet_size += 1 << color_cache_bits;
      }
-    } else {
-      HTreeGroup* const htree_group =
-          &htree_groups[(mapping == NULL) ? i : mapping[i]];
-      HuffmanCode** const htrees = htree_group->htrees;
-      int size;
-      int total_size = 0;
-      int is_trivial_literal = 1;
-      int max_bits = 0;
-      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
-        int alphabet_size = kAlphabetSize[j];
-        if (j == 0 && color_cache_bits > 0) {
-          alphabet_size += (1 << color_cache_bits);
-        }
-        size =
-            ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables);
-        htrees[j] = huffman_tables->curr_segment->curr_table;
-        if (size == 0) {
-          goto Error;
-        }
-        if (is_trivial_literal && kLiteralMap[j] == 1) {
-          is_trivial_literal = (htrees[j]->bits == 0);
-        }
-        total_size += htrees[j]->bits;
-        huffman_tables->curr_segment->curr_table += size;
-        if (j <= ALPHA) {
-          int local_max_bits = code_lengths[0];
-          int k;
-          for (k = 1; k < alphabet_size; ++k) {
-            if (code_lengths[k] > local_max_bits) {
-              local_max_bits = code_lengths[k];
-            }
+      size =
+          ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables_i);
+      if (size == 0) {
+        goto Error;
+      }
+      if (is_trivial_literal && kLiteralMap[j] == 1) {
+        is_trivial_literal = (huffman_tables_i->bits == 0);
+      }
+      total_size += huffman_tables_i->bits;
+      huffman_tables_i += size;
+      if (j <= ALPHA) {
+        int local_max_bits = code_lengths[0];
+        int k;
+        for (k = 1; k < alphabet_size; ++k) {
+          if (code_lengths[k] > local_max_bits) {
+            local_max_bits = code_lengths[k];
          }
-          max_bits += local_max_bits;
        }
+        max_bits += local_max_bits;
      }
-      htree_group->is_trivial_literal = is_trivial_literal;
-      htree_group->is_trivial_code = 0;
-      if (is_trivial_literal) {
-        const int red = htrees[RED][0].value;
-        const int blue = htrees[BLUE][0].value;
-        const int alpha = htrees[ALPHA][0].value;
-        htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue;
-        if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) {
-          htree_group->is_trivial_code = 1;
-          htree_group->literal_arb |= htrees[GREEN][0].value << 8;
-        }
-      }
-      htree_group->use_packed_table =
-          !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS);
-      if (htree_group->use_packed_table) BuildPackedTable(htree_group);
    }
+    if (!is_bogus) next = huffman_tables_i;
+    htree_group->is_trivial_literal = is_trivial_literal;
+    htree_group->is_trivial_code = 0;
+    if (is_trivial_literal) {
+      const int red = htrees[RED][0].value;
+      const int blue = htrees[BLUE][0].value;
+      const int alpha = htrees[ALPHA][0].value;
+      htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue;
+      if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) {
+        htree_group->is_trivial_code = 1;
+        htree_group->literal_arb |= htrees[GREEN][0].value << 8;
+      }
+    }
+    htree_group->use_packed_table =
+        !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS);
+    if (htree_group->use_packed_table) BuildPackedTable(htree_group);
  }
  ok = 1;

@ -520,13 +517,15 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
  hdr->huffman_image_ = huffman_image;
  hdr->num_htree_groups_ = num_htree_groups;
  hdr->htree_groups_ = htree_groups;
+  hdr->huffman_tables_ = huffman_tables;

 Error:
  WebPSafeFree(code_lengths);
+  WebPSafeFree(huffman_tables_bogus);
  WebPSafeFree(mapping);
  if (!ok) {
    WebPSafeFree(huffman_image);
-    VP8LHuffmanTablesDeallocate(huffman_tables);
+    WebPSafeFree(huffman_tables);
    VP8LHtreeGroupsFree(htree_groups);
  }
  return ok;
@ -758,11 +757,11 @@ static WEBP_INLINE HTreeGroup* GetHtreeGroupForPos(VP8LMetadata* const hdr,

 typedef void (*ProcessRowsFunc)(VP8LDecoder* const dec, int row);

-static void ApplyInverseTransforms(VP8LDecoder* const dec,
-                                   int start_row, int num_rows,
+static void ApplyInverseTransforms(VP8LDecoder* const dec, int num_rows,
                                   const uint32_t* const rows) {
  int n = dec->next_transform_;
  const int cache_pixs = dec->width_ * num_rows;
+  const int start_row = dec->last_row_;
  const int end_row = start_row + num_rows;
  const uint32_t* rows_in = rows;
  uint32_t* const rows_out = dec->argb_cache_;
@ -793,7 +792,8 @@ static void ProcessRows(VP8LDecoder* const dec, int row) {
    VP8Io* const io = dec->io_;
    uint8_t* rows_data = (uint8_t*)dec->argb_cache_;
    const int in_stride = io->width * sizeof(uint32_t);  // in unit of RGBA
-    ApplyInverseTransforms(dec, dec->last_row_, num_rows, rows);
+
+    ApplyInverseTransforms(dec, num_rows, rows);
    if (!SetCropWindow(io, dec->last_row_, row, &rows_data, in_stride)) {
      // Nothing to output (this time).
    } else {
@ -1196,7 +1196,6 @@ static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data,
      VP8LFillBitWindow(br);
      dist_code = GetCopyDistance(dist_symbol, br);
      dist = PlaneCodeToDistance(width, dist_code);
-
      if (VP8LIsEndOfStream(br)) break;
      if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) {
        goto Error;
@ -1358,7 +1357,7 @@ static void ClearMetadata(VP8LMetadata* const hdr) {
  assert(hdr != NULL);

  WebPSafeFree(hdr->huffman_image_);
-  VP8LHuffmanTablesDeallocate(&hdr->huffman_tables_);
+  WebPSafeFree(hdr->huffman_tables_);
  VP8LHtreeGroupsFree(hdr->htree_groups_);
  VP8LColorCacheClear(&hdr->color_cache_);
  VP8LColorCacheClear(&hdr->saved_color_cache_);
@ -1557,7 +1556,7 @@ static void ExtractAlphaRows(VP8LDecoder* const dec, int last_row) {
    const int cache_pixs = width * num_rows_to_process;
    uint8_t* const dst = output + width * cur_row;
    const uint32_t* const src = dec->argb_cache_;
-    ApplyInverseTransforms(dec, cur_row, num_rows_to_process, in);
+    ApplyInverseTransforms(dec, num_rows_to_process, in);
    WebPExtractGreen(src, dst, cache_pixs);
    AlphaApplyFilter(alph_dec,
                     cur_row, cur_row + num_rows_to_process, dst, width);
@ -1674,7 +1673,7 @@ int VP8LDecodeImage(VP8LDecoder* const dec) {
  // Sanity checks.
  if (dec == NULL) return 0;

-  assert(dec->hdr_.huffman_tables_.root.start != NULL);
+  assert(dec->hdr_.huffman_tables_ != NULL);
  assert(dec->hdr_.htree_groups_ != NULL);
  assert(dec->hdr_.num_htree_groups_ > 0);

--- a/src/dec/vp8li_dec.h
+++ b/src/dec/vp8li_dec.h
@ -37,7 +37,7 @@ struct VP8LTransform {
  int                    bits_;   // subsampling bits defining transform window.
  int                    xsize_;  // transform window X index.
  int                    ysize_;  // transform window Y index.
-  uint32_t*              data_;   // transform data.
+  uint32_t              *data_;   // transform data.
 };

 typedef struct {
@ -48,23 +48,23 @@ typedef struct {
  int             huffman_mask_;
  int             huffman_subsample_bits_;
  int             huffman_xsize_;
-  uint32_t*       huffman_image_;
+  uint32_t       *huffman_image_;
  int             num_htree_groups_;
-  HTreeGroup*     htree_groups_;
-  HuffmanTables   huffman_tables_;
+  HTreeGroup     *htree_groups_;
+  HuffmanCode    *huffman_tables_;
 } VP8LMetadata;

 typedef struct VP8LDecoder VP8LDecoder;
 struct VP8LDecoder {
  VP8StatusCode    status_;
  VP8LDecodeState  state_;
-  VP8Io*           io_;
+  VP8Io           *io_;

-  const WebPDecBuffer* output_;    // shortcut to io->opaque->output
+  const WebPDecBuffer *output_;    // shortcut to io->opaque->output

-  uint32_t*        pixels_;        // Internal data: either uint8_t* for alpha
+  uint32_t        *pixels_;        // Internal data: either uint8_t* for alpha
                                   // or uint32_t* for BGRA.
-  uint32_t*        argb_cache_;    // Scratch buffer for temporary BGRA storage.
+  uint32_t        *argb_cache_;    // Scratch buffer for temporary BGRA storage.

  VP8LBitReader    br_;
  int              incremental_;   // if true, incremental decoding is expected
@ -86,8 +86,8 @@ struct VP8LDecoder {
  // or'd bitset storing the transforms types.
  uint32_t         transforms_seen_;

-  uint8_t*         rescaler_memory;  // Working memory for rescaling work.
-  WebPRescaler*    rescaler;         // Common rescaler for all channels.
+  uint8_t         *rescaler_memory;  // Working memory for rescaling work.
+  WebPRescaler    *rescaler;         // Common rescaler for all channels.
 };

 //------------------------------------------------------------------------------
--- a/src/demux/demux.c
+++ b/src/demux/demux.c
@ -24,8 +24,8 @@
 #include "src/webp/format_constants.h"

 #define DMUX_MAJ_VERSION 1
-#define DMUX_MIN_VERSION 1
-#define DMUX_REV_VERSION 0
+#define DMUX_MIN_VERSION 0
+#define DMUX_REV_VERSION 2

 typedef struct {
  size_t start_;        // start location of the data
--- a/src/demux/libwebpdemux.rc
+++ b/src/demux/libwebpdemux.rc
@ -6,8 +6,8 @@
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,0,1,0
- PRODUCTVERSION 1,0,1,0
+ FILEVERSION 1,0,0,2
+ PRODUCTVERSION 1,0,0,2
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebpdemux DLL"
-            VALUE "FileVersion", "1.1.0"
+            VALUE "FileVersion", "1.0.2"
            VALUE "InternalName", "libwebpdemux.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebpdemux.dll"
            VALUE "ProductName", "WebP Image Demuxer"
-            VALUE "ProductVersion", "1.1.0"
+            VALUE "ProductVersion", "1.0.2"
        END
    END
    BLOCK "VarFileInfo"
--- a/src/dsp/alpha_processing_sse2.c
+++ b/src/dsp/alpha_processing_sse2.c
@ -214,7 +214,7 @@ static void ApplyAlphaMultiply_SSE2(uint8_t* rgba, int alpha_first,
 // Alpha detection

 static int HasAlpha8b_SSE2(const uint8_t* src, int length) {
-  const __m128i all_0xff = _mm_set1_epi8((char)0xff);
+  const __m128i all_0xff = _mm_set1_epi8(0xff);
  int i = 0;
  for (; i + 16 <= length; i += 16) {
    const __m128i v = _mm_loadu_si128((const __m128i*)(src + i));
@ -228,7 +228,7 @@ static int HasAlpha8b_SSE2(const uint8_t* src, int length) {

 static int HasAlpha32b_SSE2(const uint8_t* src, int length) {
  const __m128i alpha_mask = _mm_set1_epi32(0xff);
-  const __m128i all_0xff = _mm_set1_epi8((char)0xff);
+  const __m128i all_0xff = _mm_set1_epi8(0xff);
  int i = 0;
  // We don't know if we can access the last 3 bytes after the last alpha
  // value 'src[4 * length - 4]' (because we don't know if alpha is the first
--- a/src/dsp/cpu.c
+++ b/src/dsp/cpu.c
@ -173,8 +173,8 @@ static int AndroidCPUInfo(CPUFeature feature) {
  const AndroidCpuFamily cpu_family = android_getCpuFamily();
  const uint64_t cpu_features = android_getCpuFeatures();
  if (feature == kNEON) {
-    return cpu_family == ANDROID_CPU_FAMILY_ARM &&
-           (cpu_features & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
+    return (cpu_family == ANDROID_CPU_FAMILY_ARM &&
+            0 != (cpu_features & ANDROID_CPU_ARM_FEATURE_NEON));
  }
  return 0;
 }
--- a/src/dsp/dec_neon.c
+++ b/src/dsp/dec_neon.c
@ -1361,8 +1361,7 @@ static void RD4_NEON(uint8_t* dst) {   // Down-right
  const uint32_t J = dst[-1 + 1 * BPS];
  const uint32_t K = dst[-1 + 2 * BPS];
  const uint32_t L = dst[-1 + 3 * BPS];
-  const uint64x1_t LKJI____ =
-      vcreate_u64((uint64_t)L | (K << 8) | (J << 16) | (I << 24));
+  const uint64x1_t LKJI____ = vcreate_u64(L | (K << 8) | (J << 16) | (I << 24));
  const uint64x1_t LKJIXABC = vorr_u64(LKJI____, ____XABC);
  const uint8x8_t KJIXABC_ = vreinterpret_u8_u64(vshr_n_u64(LKJIXABC, 8));
  const uint8x8_t JIXABC__ = vreinterpret_u8_u64(vshr_n_u64(LKJIXABC, 16));
@ -1428,16 +1427,10 @@ static WEBP_INLINE void DC8_NEON(uint8_t* dst, int do_top, int do_left) {

  if (do_top) {
    const uint8x8_t A = vld1_u8(dst - BPS);  // top row
-#if defined(__aarch64__)
-    const uint16x8_t B = vmovl_u8(A);
-    const uint16_t p2 = vaddvq_u16(B);
-    sum_top = vdupq_n_u16(p2);
-#else
    const uint16x4_t p0 = vpaddl_u8(A);  // cascading summation of the top
    const uint16x4_t p1 = vpadd_u16(p0, p0);
    const uint16x4_t p2 = vpadd_u16(p1, p1);
    sum_top = vcombine_u16(p2, p2);
-#endif
  }

  if (do_left) {
--- a/src/dsp/dec_sse2.c
+++ b/src/dsp/dec_sse2.c
@ -326,7 +326,7 @@ static WEBP_INLINE void Update2Pixels_SSE2(__m128i* const pi, __m128i* const qi,
  const __m128i a1_lo = _mm_srai_epi16(*a0_lo, 7);
  const __m128i a1_hi = _mm_srai_epi16(*a0_hi, 7);
  const __m128i delta = _mm_packs_epi16(a1_lo, a1_hi);
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
  *pi = _mm_adds_epi8(*pi, delta);
  *qi = _mm_subs_epi8(*qi, delta);
  FLIP_SIGN_BIT2(*pi, *qi);
@ -338,9 +338,9 @@ static WEBP_INLINE void NeedsFilter_SSE2(const __m128i* const p1,
                                         const __m128i* const q0,
                                         const __m128i* const q1,
                                         int thresh, __m128i* const mask) {
-  const __m128i m_thresh = _mm_set1_epi8((char)thresh);
+  const __m128i m_thresh = _mm_set1_epi8(thresh);
  const __m128i t1 = MM_ABS(*p1, *q1);        // abs(p1 - q1)
-  const __m128i kFE = _mm_set1_epi8((char)0xFE);
+  const __m128i kFE = _mm_set1_epi8(0xFE);
  const __m128i t2 = _mm_and_si128(t1, kFE);  // set lsb of each byte to zero
  const __m128i t3 = _mm_srli_epi16(t2, 1);   // abs(p1 - q1) / 2

@ -360,7 +360,7 @@ static WEBP_INLINE void DoFilter2_SSE2(__m128i* const p1, __m128i* const p0,
                                       __m128i* const q0, __m128i* const q1,
                                       int thresh) {
  __m128i a, mask;
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
  // convert p1/q1 to int8_t (for GetBaseDelta_SSE2)
  const __m128i p1s = _mm_xor_si128(*p1, sign_bit);
  const __m128i q1s = _mm_xor_si128(*q1, sign_bit);
@ -380,7 +380,7 @@ static WEBP_INLINE void DoFilter4_SSE2(__m128i* const p1, __m128i* const p0,
                                       const __m128i* const mask,
                                       int hev_thresh) {
  const __m128i zero = _mm_setzero_si128();
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
  const __m128i k64 = _mm_set1_epi8(64);
  const __m128i k3 = _mm_set1_epi8(3);
  const __m128i k4 = _mm_set1_epi8(4);
@ -427,7 +427,7 @@ static WEBP_INLINE void DoFilter6_SSE2(__m128i* const p2, __m128i* const p1,
                                       const __m128i* const mask,
                                       int hev_thresh) {
  const __m128i zero = _mm_setzero_si128();
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
  __m128i a, not_hev;

  // compute hev mask
@ -941,7 +941,7 @@ static void VR4_SSE2(uint8_t* dst) {   // Vertical-Right
  const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
  const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
  const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
-  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(I | (X << 8)), 0);
+  const __m128i IXABCD = _mm_insert_epi16(_XABCD, I | (X << 8), 0);
  const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
  const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
--- a/src/dsp/dsp.h
+++ b/src/dsp/dsp.h
@ -246,9 +246,9 @@ extern VP8Fdct VP8FTransform2;   // performs two transforms at a time
 extern VP8WHT VP8FTransformWHT;
 // Predictions
 // *dst is the destination block. *top and *left can be NULL.
-typedef void (*VP8IntraPreds)(uint8_t* dst, const uint8_t* left,
+typedef void (*VP8IntraPreds)(uint8_t *dst, const uint8_t* left,
                              const uint8_t* top);
-typedef void (*VP8Intra4Preds)(uint8_t* dst, const uint8_t* top);
+typedef void (*VP8Intra4Preds)(uint8_t *dst, const uint8_t* top);
 extern VP8Intra4Preds VP8EncPredLuma4;
 extern VP8IntraPreds VP8EncPredLuma16;
 extern VP8IntraPreds VP8EncPredChroma8;
--- a/src/dsp/enc_sse2.c
+++ b/src/dsp/enc_sse2.c
@ -777,7 +777,7 @@ static WEBP_INLINE void VR4_SSE2(uint8_t* dst,
  const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
  const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
  const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
-  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(I | (X << 8)), 0);
+  const __m128i IXABCD = _mm_insert_epi16(_XABCD, I | (X << 8), 0);
  const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
  const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
--- a/src/dsp/filters.c
+++ b/src/dsp/filters.c
@ -33,9 +33,9 @@ static WEBP_INLINE void PredictLine_C(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] = (uint8_t)(src[i] + pred[i]);
+    for (i = 0; i < length; ++i) dst[i] = src[i] + pred[i];
  } else {
-    for (i = 0; i < length; ++i) dst[i] = (uint8_t)(src[i] - pred[i]);
+    for (i = 0; i < length; ++i) dst[i] = src[i] - pred[i];
  }
 }

@ -155,7 +155,7 @@ static WEBP_INLINE void DoGradientFilter_C(const uint8_t* in,
      const int pred = GradientPredictor_C(preds[w - 1],
                                           preds[w - stride],
                                           preds[w - stride - 1]);
-      out[w] = (uint8_t)(in[w] + (inverse ? pred : -pred));
+      out[w] = in[w] + (inverse ? pred : -pred);
    }
    ++row;
    preds += stride;
@ -194,7 +194,7 @@ static void HorizontalUnfilter_C(const uint8_t* prev, const uint8_t* in,
  uint8_t pred = (prev == NULL) ? 0 : prev[0];
  int i;
  for (i = 0; i < width; ++i) {
-    out[i] = (uint8_t)(pred + in[i]);
+    out[i] = pred + in[i];
    pred = out[i];
  }
 }
@ -206,7 +206,7 @@ static void VerticalUnfilter_C(const uint8_t* prev, const uint8_t* in,
    HorizontalUnfilter_C(NULL, in, out, width);
  } else {
    int i;
-    for (i = 0; i < width; ++i) out[i] = (uint8_t)(prev[i] + in[i]);
+    for (i = 0; i < width; ++i) out[i] = prev[i] + in[i];
  }
 }
 #endif  // !WEBP_NEON_OMIT_C_CODE
@ -220,7 +220,7 @@ static void GradientUnfilter_C(const uint8_t* prev, const uint8_t* in,
    int i;
    for (i = 0; i < width; ++i) {
      top = prev[i];  // need to read this first, in case prev==out
-      left = (uint8_t)(in[i] + GradientPredictor_C(left, top, top_left));
+      left = in[i] + GradientPredictor_C(left, top, top_left);
      top_left = top;
      out[i] = left;
    }
--- a/src/dsp/filters_sse2.c
+++ b/src/dsp/filters_sse2.c
@ -163,8 +163,7 @@ static void GradientPredictDirect_SSE2(const uint8_t* const row,
    _mm_storel_epi64((__m128i*)(out + i), H);
  }
  for (; i < length; ++i) {
-    const int delta = GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
-    out[i] = (uint8_t)(row[i] - delta);
+    out[i] = row[i] - GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
  }
 }

@ -189,7 +188,7 @@ static WEBP_INLINE void DoGradientFilter_SSE2(const uint8_t* in,

  // Filter line-by-line.
  while (row < last_row) {
-    out[0] = (uint8_t)(in[0] - in[-stride]);
+    out[0] = in[0] - in[-stride];
    GradientPredictDirect_SSE2(in + 1, in + 1 - stride, out + 1, width - 1);
    ++row;
    in += stride;
@ -224,7 +223,7 @@ static void HorizontalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
                                    uint8_t* out, int width) {
  int i;
  __m128i last;
-  out[0] = (uint8_t)(in[0] + (prev == NULL ? 0 : prev[0]));
+  out[0] = in[0] + (prev == NULL ? 0 : prev[0]);
  if (width <= 1) return;
  last = _mm_set_epi32(0, 0, 0, out[0]);
  for (i = 1; i + 8 <= width; i += 8) {
@ -239,7 +238,7 @@ static void HorizontalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
    _mm_storel_epi64((__m128i*)(out + i), A7);
    last = _mm_srli_epi64(A7, 56);
  }
-  for (; i < width; ++i) out[i] = (uint8_t)(in[i] + out[i - 1]);
+  for (; i < width; ++i) out[i] = in[i] + out[i - 1];
 }

 static void VerticalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
@ -260,7 +259,7 @@ static void VerticalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
      _mm_storeu_si128((__m128i*)&out[i +  0], C0);
      _mm_storeu_si128((__m128i*)&out[i + 16], C1);
    }
-    for (; i < width; ++i) out[i] = (uint8_t)(in[i] + prev[i]);
+    for (; i < width; ++i) out[i] = in[i] + prev[i];
  }
 }

@ -297,8 +296,7 @@ static void GradientPredictInverse_SSE2(const uint8_t* const in,
      _mm_storel_epi64((__m128i*)&row[i], out);
    }
    for (; i < length; ++i) {
-      const int delta = GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
-      row[i] = (uint8_t)(in[i] + delta);
+      row[i] = in[i] + GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
    }
  }
 }
@ -308,7 +306,7 @@ static void GradientUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
  if (prev == NULL) {
    HorizontalUnfilter_SSE2(NULL, in, out, width);
  } else {
-    out[0] = (uint8_t)(in[0] + prev[0]);  // predict from above
+    out[0] = in[0] + prev[0];  // predict from above
    GradientPredictInverse_SSE2(in + 1, prev + 1, out + 1, width - 1);
  }
 }
--- a/src/dsp/lossless.c
+++ b/src/dsp/lossless.c
@ -81,7 +81,7 @@ static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,

 // gcc <= 4.9 on ARM generates incorrect code in Select() when Sub3() is
 // inlined.
-#if defined(__arm__) && defined(__GNUC__) && LOCAL_GCC_VERSION <= 0x409
+#if defined(__arm__) && LOCAL_GCC_VERSION <= 0x409
 # define LOCAL_INLINE __attribute__ ((noinline))
 #else
 # define LOCAL_INLINE WEBP_INLINE
@ -167,20 +167,15 @@ static uint32_t Predictor13_C(uint32_t left, const uint32_t* const top) {
  return pred;
 }

-static void PredictorAdd0_C(const uint32_t* in, const uint32_t* upper,
-                            int num_pixels, uint32_t* out) {
-  int x;
-  (void)upper;
-  for (x = 0; x < num_pixels; ++x) out[x] = VP8LAddPixels(in[x], ARGB_BLACK);
-}
+GENERATE_PREDICTOR_ADD(Predictor0_C, PredictorAdd0_C)
 static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
                            int num_pixels, uint32_t* out) {
  int i;
  uint32_t left = out[-1];
-  (void)upper;
  for (i = 0; i < num_pixels; ++i) {
    out[i] = left = VP8LAddPixels(in[i], left);
  }
+  (void)upper;
 }
 GENERATE_PREDICTOR_ADD(Predictor2_C, PredictorAdd2_C)
 GENERATE_PREDICTOR_ADD(Predictor3_C, PredictorAdd3_C)
@ -275,14 +270,14 @@ void VP8LTransformColorInverse_C(const VP8LMultipliers* const m,
  int i;
  for (i = 0; i < num_pixels; ++i) {
    const uint32_t argb = src[i];
-    const int8_t green = (int8_t)(argb >> 8);
+    const uint32_t green = argb >> 8;
    const uint32_t red = argb >> 16;
    int new_red = red & 0xff;
    int new_blue = argb & 0xff;
    new_red += ColorTransformDelta(m->green_to_red_, green);
    new_red &= 0xff;
    new_blue += ColorTransformDelta(m->green_to_blue_, green);
-    new_blue += ColorTransformDelta(m->red_to_blue_, (int8_t)new_red);
+    new_blue += ColorTransformDelta(m->red_to_blue_, new_red);
    new_blue &= 0xff;
    dst[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);
  }
--- a/src/dsp/lossless_common.h
+++ b/src/dsp/lossless_common.h
@ -177,7 +177,6 @@ uint32_t VP8LSubPixels(uint32_t a, uint32_t b) {
 static void PREDICTOR_ADD(const uint32_t* in, const uint32_t* upper, \
                          int num_pixels, uint32_t* out) {           \
  int x;                                                             \
-  assert(upper != NULL);                                             \
  for (x = 0; x < num_pixels; ++x) {                                 \
    const uint32_t pred = (PREDICTOR)(out[x - 1], upper + x);        \
    out[x] = VP8LAddPixels(in[x], pred);                             \
@ -190,7 +189,6 @@ static void PREDICTOR_ADD(const uint32_t* in, const uint32_t* upper, \
 static void PREDICTOR_SUB(const uint32_t* in, const uint32_t* upper, \
                          int num_pixels, uint32_t* out) {           \
  int x;                                                             \
-  assert(upper != NULL);                                             \
  for (x = 0; x < num_pixels; ++x) {                                 \
    const uint32_t pred = (PREDICTOR)(in[x - 1], upper + x);         \
    out[x] = VP8LSubPixels(in[x], pred);                             \
--- a/src/dsp/lossless_enc.c
+++ b/src/dsp/lossless_enc.c
@ -515,17 +515,13 @@ static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) {
  return ((int)color_pred * color) >> 5;
 }

-static WEBP_INLINE int8_t U32ToS8(uint32_t v) {
-  return (int8_t)(v & 0xff);
-}
-
 void VP8LTransformColor_C(const VP8LMultipliers* const m, uint32_t* data,
                          int num_pixels) {
  int i;
  for (i = 0; i < num_pixels; ++i) {
    const uint32_t argb = data[i];
-    const int8_t green = U32ToS8(argb >>  8);
-    const int8_t red   = U32ToS8(argb >> 16);
+    const uint32_t green = argb >> 8;
+    const uint32_t red = argb >> 16;
    int new_red = red & 0xff;
    int new_blue = argb & 0xff;
    new_red -= ColorTransformDelta(m->green_to_red_, green);
@ -539,7 +535,7 @@ void VP8LTransformColor_C(const VP8LMultipliers* const m, uint32_t* data,

 static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red,
                                             uint32_t argb) {
-  const int8_t green = U32ToS8(argb >> 8);
+  const uint32_t green = argb >> 8;
  int new_red = argb >> 16;
  new_red -= ColorTransformDelta(green_to_red, green);
  return (new_red & 0xff);
@ -548,9 +544,9 @@ static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red,
 static WEBP_INLINE uint8_t TransformColorBlue(uint8_t green_to_blue,
                                              uint8_t red_to_blue,
                                              uint32_t argb) {
-  const int8_t green = U32ToS8(argb >>  8);
-  const int8_t red   = U32ToS8(argb >> 16);
-  uint8_t new_blue = argb & 0xff;
+  const uint32_t green = argb >> 8;
+  const uint32_t red = argb >> 16;
+  uint8_t new_blue = argb;
  new_blue -= ColorTransformDelta(green_to_blue, green);
  new_blue -= ColorTransformDelta(red_to_blue, red);
  return (new_blue & 0xff);
@ -562,7 +558,7 @@ void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride,
  while (tile_height-- > 0) {
    int x;
    for (x = 0; x < tile_width; ++x) {
-      ++histo[TransformColorRed((uint8_t)green_to_red, argb[x])];
+      ++histo[TransformColorRed(green_to_red, argb[x])];
    }
    argb += stride;
  }
@ -575,8 +571,7 @@ void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride,
  while (tile_height-- > 0) {
    int x;
    for (x = 0; x < tile_width; ++x) {
-      ++histo[TransformColorBlue((uint8_t)green_to_blue, (uint8_t)red_to_blue,
-                                 argb[x])];
+      ++histo[TransformColorBlue(green_to_blue, red_to_blue, argb[x])];
    }
    argb += stride;
  }
--- a/src/dsp/lossless_enc_sse2.c
+++ b/src/dsp/lossless_enc_sse2.c
@ -363,7 +363,7 @@ static void BundleColorMap_SSE2(const uint8_t* const row, int width, int xbits,
  assert(xbits <= 3);
  switch (xbits) {
    case 0: {
-      const __m128i ff = _mm_set1_epi16((short)0xff00);
+      const __m128i ff = _mm_set1_epi16(0xff00);
      const __m128i zero = _mm_setzero_si128();
      // Store 0xff000000 | (row[x] << 8).
      for (x = 0; x + 16 <= width; x += 16, dst += 16) {
@ -382,7 +382,7 @@ static void BundleColorMap_SSE2(const uint8_t* const row, int width, int xbits,
      break;
    }
    case 1: {
-      const __m128i ff = _mm_set1_epi16((short)0xff00);
+      const __m128i ff = _mm_set1_epi16(0xff00);
      const __m128i mul = _mm_set1_epi16(0x110);
      for (x = 0; x + 16 <= width; x += 16, dst += 8) {
        // 0a0b | (where a/b are 4 bits).
@ -455,9 +455,8 @@ static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
    _mm_storeu_si128((__m128i*)&out[i], res);
  }
  if (i != num_pixels) {
-    VP8LPredictorsSub_C[0](in + i, NULL, num_pixels - i, out + i);
+    VP8LPredictorsSub_C[0](in + i, upper + i, num_pixels - i, out + i);
  }
-  (void)upper;
 }

 #define GENERATE_PREDICTOR_1(X, IN)                                           \
--- a/src/dsp/lossless_enc_sse41.c
+++ b/src/dsp/lossless_enc_sse41.c
@ -51,9 +51,9 @@ static void CollectColorBlueTransforms_SSE41(const uint32_t* argb, int stride,
                                             int histo[]) {
  const __m128i mults_r = _mm_set1_epi16(CST_5b(red_to_blue));
  const __m128i mults_g = _mm_set1_epi16(CST_5b(green_to_blue));
-  const __m128i mask_g = _mm_set1_epi16((short)0xff00);   // green mask
-  const __m128i mask_gb = _mm_set1_epi32(0xffff);         // green/blue mask
-  const __m128i mask_b = _mm_set1_epi16(0x00ff);          // blue mask
+  const __m128i mask_g = _mm_set1_epi16(0xff00);   // green mask
+  const __m128i mask_gb = _mm_set1_epi32(0xffff);  // green/blue mask
+  const __m128i mask_b = _mm_set1_epi16(0x00ff);   // blue mask
  const __m128i shuffler_lo = _mm_setr_epi8(-1, 2, -1, 6, -1, 10, -1, 14, -1,
                                            -1, -1, -1, -1, -1, -1, -1);
  const __m128i shuffler_hi = _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1,
--- a/src/dsp/lossless_sse2.c
+++ b/src/dsp/lossless_sse2.c
@ -191,9 +191,8 @@ static void PredictorAdd0_SSE2(const uint32_t* in, const uint32_t* upper,
    _mm_storeu_si128((__m128i*)&out[i], res);
  }
  if (i != num_pixels) {
-    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
+    VP8LPredictorsAdd_C[0](in + i, upper + i, num_pixels - i, out + i);
  }
-  (void)upper;
 }

 // Predictor1: left.
--- a/src/dsp/quant.h
+++ b/src/dsp/quant.h
@ -10,8 +10,6 @@
 #ifndef WEBP_DSP_QUANT_H_
 #define WEBP_DSP_QUANT_H_

-#include <string.h>
-
 #include "src/dsp/dsp.h"
 #include "src/webp/types.h"

@ -69,17 +67,4 @@ static WEBP_INLINE int IsFlat(const int16_t* levels, int num_blocks,
 #endif  // defined(WEBP_USE_NEON) && !defined(WEBP_ANDROID_NEON) &&
        // !defined(WEBP_HAVE_NEON_RTCD)

-static WEBP_INLINE int IsFlatSource16(const uint8_t* src) {
-  const uint32_t v = src[0] * 0x01010101u;
-  int i;
-  for (i = 0; i < 16; ++i) {
-    if (memcmp(src + 0, &v, 4) || memcmp(src +  4, &v, 4) ||
-        memcmp(src + 8, &v, 4) || memcmp(src + 12, &v, 4)) {
-      return 0;
-    }
-    src += BPS;
-  }
-  return 1;
-}
-
 #endif  // WEBP_DSP_QUANT_H_
--- a/src/dsp/upsampling_msa.c
+++ b/src/dsp/upsampling_msa.c
@ -576,9 +576,9 @@ static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bot_y,        \
  const uint32_t l_uv = ((cur_u[0]) | ((cur_v[0]) << 16));               \
  const uint32_t uv0 = (3 * tl_uv + l_uv + 0x00020002u) >> 2;            \
  const uint8_t* ptop_y = &top_y[1];                                     \
-  uint8_t* ptop_dst = top_dst + XSTEP;                                   \
+  uint8_t *ptop_dst = top_dst + XSTEP;                                   \
  const uint8_t* pbot_y = &bot_y[1];                                     \
-  uint8_t* pbot_dst = bot_dst + XSTEP;                                   \
+  uint8_t *pbot_dst = bot_dst + XSTEP;                                   \
                                                                         \
  FUNC(top_y[0], uv0 & 0xff, (uv0 >> 16), top_dst);                      \
  if (bot_y != NULL) {                                                   \
--- a/src/dsp/upsampling_neon.c
+++ b/src/dsp/upsampling_neon.c
@ -58,8 +58,8 @@
 } while (0)

 // Turn the macro into a function for reducing code-size when non-critical
-static void Upsample16Pixels_NEON(const uint8_t* r1, const uint8_t* r2,
-                                  uint8_t* out) {
+static void Upsample16Pixels_NEON(const uint8_t *r1, const uint8_t *r2,
+                                  uint8_t *out) {
  UPSAMPLE_16PIXELS(r1, r2, out);
 }

@ -190,14 +190,14 @@ static const int16_t kCoeffs1[4] = { 19077, 26149, 6419, 13320 };
 }

 #define NEON_UPSAMPLE_FUNC(FUNC_NAME, FMT, XSTEP)                       \
-static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bottom_y,    \
-                      const uint8_t* top_u, const uint8_t* top_v,       \
-                      const uint8_t* cur_u, const uint8_t* cur_v,       \
-                      uint8_t* top_dst, uint8_t* bottom_dst, int len) { \
+static void FUNC_NAME(const uint8_t *top_y, const uint8_t *bottom_y,    \
+                      const uint8_t *top_u, const uint8_t *top_v,       \
+                      const uint8_t *cur_u, const uint8_t *cur_v,       \
+                      uint8_t *top_dst, uint8_t *bottom_dst, int len) { \
  int block;                                                            \
  /* 16 byte aligned array to cache reconstructed u and v */            \
  uint8_t uv_buf[2 * 32 + 15];                                          \
-  uint8_t* const r_uv = (uint8_t*)((uintptr_t)(uv_buf + 15) & ~15);     \
+  uint8_t *const r_uv = (uint8_t*)((uintptr_t)(uv_buf + 15) & ~15);     \
  const int uv_len = (len + 1) >> 1;                                    \
  /* 9 pixels must be read-able for each block */                       \
  const int num_blocks = (uv_len - 1) >> 3;                             \
--- a/src/enc/alpha_enc.c
+++ b/src/enc/alpha_enc.c
@ -13,7 +13,6 @@

 #include <assert.h>
 #include <stdlib.h>
-#include <string.h>

 #include "src/enc/vp8i_enc.h"
 #include "src/dsp/dsp.h"
@ -149,7 +148,6 @@ static int EncodeAlphaInternal(const uint8_t* const data, int width, int height,
      }
    } else {
      VP8LBitWriterWipeOut(&tmp_bw);
-      memset(&result->bw, 0, sizeof(result->bw));
      return 0;
    }
  }
@ -164,7 +162,7 @@ static int EncodeAlphaInternal(const uint8_t* const data, int width, int height,
  header = method | (filter << 2);
  if (reduce_levels) header |= ALPHA_PREPROCESSED_LEVELS << 4;

-  if (!VP8BitWriterInit(&result->bw, ALPHA_HEADER_LEN + output_size)) ok = 0;
+  VP8BitWriterInit(&result->bw, ALPHA_HEADER_LEN + output_size);
  ok = ok && VP8BitWriterAppend(&result->bw, &header, ALPHA_HEADER_LEN);
  ok = ok && VP8BitWriterAppend(&result->bw, output, output_size);

--- a/src/enc/backward_references_enc.c
+++ b/src/enc/backward_references_enc.c
@ -191,14 +191,13 @@ void VP8LHashChainClear(VP8LHashChain* const p) {

 // -----------------------------------------------------------------------------

-static const uint32_t kHashMultiplierHi = 0xc6a4a793u;
-static const uint32_t kHashMultiplierLo = 0x5bd1e996u;
+#define HASH_MULTIPLIER_HI (0xc6a4a793ULL)
+#define HASH_MULTIPLIER_LO (0x5bd1e996ULL)

-static WEBP_UBSAN_IGNORE_UNSIGNED_OVERFLOW WEBP_INLINE
-uint32_t GetPixPairHash64(const uint32_t* const argb) {
+static WEBP_INLINE uint32_t GetPixPairHash64(const uint32_t* const argb) {
  uint32_t key;
-  key  = argb[1] * kHashMultiplierHi;
-  key += argb[0] * kHashMultiplierLo;
+  key  = (argb[1] * HASH_MULTIPLIER_HI) & 0xffffffffu;
+  key += (argb[0] * HASH_MULTIPLIER_LO) & 0xffffffffu;
  key = key >> (32 - HASH_BITS);
  return key;
 }
--- a/src/enc/histogram_enc.c
+++ b/src/enc/histogram_enc.c
@ -641,7 +641,7 @@ static void HistogramAnalyzeEntropyBin(VP8LHistogramSet* const image_histo,
 // Merges some histograms with same bin_id together if it's advantageous.
 // Sets the remaining histograms to NULL.
 static void HistogramCombineEntropyBin(VP8LHistogramSet* const image_histo,
-                                       int* num_used,
+                                       int *num_used,
                                       const uint16_t* const clusters,
                                       uint16_t* const cluster_mappings,
                                       VP8LHistogram* cur_combo,
--- a/src/enc/picture_csp_enc.c
+++ b/src/enc/picture_csp_enc.c
@ -29,15 +29,11 @@
 #define USE_INVERSE_ALPHA_TABLE

 #ifdef WORDS_BIGENDIAN
-// uint32_t 0xff000000 is 0xff,00,00,00 in memory
-#define CHANNEL_OFFSET(i) (i)
+#define ALPHA_OFFSET 0   // uint32_t 0xff000000 is 0xff,00,00,00 in memory
 #else
-// uint32_t 0xff000000 is 0x00,00,00,ff in memory
-#define CHANNEL_OFFSET(i) (3-(i))
+#define ALPHA_OFFSET 3   // uint32_t 0xff000000 is 0x00,00,00,ff in memory
 #endif

-#define ALPHA_OFFSET CHANNEL_OFFSET(0)
-
 //------------------------------------------------------------------------------
 // Detection of non-trivial transparency

@ -1001,10 +997,10 @@ static int PictureARGBToYUVA(WebPPicture* picture, WebPEncCSP colorspace,
    return WebPEncodingSetError(picture, VP8_ENC_ERROR_INVALID_CONFIGURATION);
  } else {
    const uint8_t* const argb = (const uint8_t*)picture->argb;
-    const uint8_t* const a = argb + CHANNEL_OFFSET(0);
-    const uint8_t* const r = argb + CHANNEL_OFFSET(1);
-    const uint8_t* const g = argb + CHANNEL_OFFSET(2);
-    const uint8_t* const b = argb + CHANNEL_OFFSET(3);
+    const uint8_t* const a = argb + (0 ^ ALPHA_OFFSET);
+    const uint8_t* const r = argb + (1 ^ ALPHA_OFFSET);
+    const uint8_t* const g = argb + (2 ^ ALPHA_OFFSET);
+    const uint8_t* const b = argb + (3 ^ ALPHA_OFFSET);

    picture->colorspace = WEBP_YUV420;
    return ImportYUVAFromRGBA(r, g, b, a, 4, 4 * picture->argb_stride,
@ -1054,7 +1050,7 @@ int WebPPictureYUVAToARGB(WebPPicture* picture) {
    const int height = picture->height;
    const int argb_stride = 4 * picture->argb_stride;
    uint8_t* dst = (uint8_t*)picture->argb;
-    const uint8_t* cur_u = picture->u, *cur_v = picture->v, *cur_y = picture->y;
+    const uint8_t *cur_u = picture->u, *cur_v = picture->v, *cur_y = picture->y;
    WebPUpsampleLinePairFunc upsample =
        WebPGetLinePairConverter(ALPHA_OFFSET > 0);

--- a/src/enc/predictor_enc.c
+++ b/src/enc/predictor_enc.c
@ -202,7 +202,7 @@ static uint32_t NearLossless(uint32_t value, uint32_t predict,
  }
  if ((value >> 24) == 0 || (value >> 24) == 0xff) {
    // Preserve transparency of fully transparent or fully opaque pixels.
-    a = NearLosslessDiff((value >> 24) & 0xff, (predict >> 24) & 0xff);
+    a = NearLosslessDiff(value >> 24, predict >> 24);
  } else {
    a = NearLosslessComponent(value >> 24, predict >> 24, 0xff, quantization);
  }
@ -215,12 +215,12 @@ static uint32_t NearLossless(uint32_t value, uint32_t predict,
    // The amount by which green has been adjusted during quantization. It is
    // subtracted from red and blue for compensation, to avoid accumulating two
    // quantization errors in them.
-    green_diff = NearLosslessDiff(new_green, (value >> 8) & 0xff);
+    green_diff = NearLosslessDiff(new_green, value >> 8);
  }
-  r = NearLosslessComponent(NearLosslessDiff((value >> 16) & 0xff, green_diff),
+  r = NearLosslessComponent(NearLosslessDiff(value >> 16, green_diff),
                            (predict >> 16) & 0xff, 0xff - new_green,
                            quantization);
-  b = NearLosslessComponent(NearLosslessDiff(value & 0xff, green_diff),
+  b = NearLosslessComponent(NearLosslessDiff(value, green_diff),
                            predict & 0xff, 0xff - new_green, quantization);
  return ((uint32_t)a << 24) | ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
 }
@ -587,7 +587,7 @@ static void GetBestGreenToRed(
      }
    }
  }
-  best_tx->green_to_red_ = (green_to_red_best & 0xff);
+  best_tx->green_to_red_ = green_to_red_best;
 }

 static float GetPredictionCostCrossColorBlue(
@ -666,8 +666,8 @@ static void GetBestGreenRedToBlue(
      break;  // out of iter-loop.
    }
  }
-  best_tx->green_to_blue_ = green_to_blue_best & 0xff;
-  best_tx->red_to_blue_ = red_to_blue_best & 0xff;
+  best_tx->green_to_blue_ = green_to_blue_best;
+  best_tx->red_to_blue_ = red_to_blue_best;
 }
 #undef kGreenRedToBlueMaxIters
 #undef kGreenRedToBlueNumAxis
--- a/src/enc/quant_enc.c
+++ b/src/enc/quant_enc.c
@ -33,7 +33,7 @@

 // number of non-zero coeffs below which we consider the block very flat
 // (and apply a penalty to complex predictions)
-#define FLATNESS_LIMIT_I16 0       // I16 mode (special case)
+#define FLATNESS_LIMIT_I16 10      // I16 mode
 #define FLATNESS_LIMIT_I4  3       // I4 mode
 #define FLATNESS_LIMIT_UV  2       // UV mode
 #define FLATNESS_PENALTY   140     // roughly ~1bit per block
@ -988,7 +988,6 @@ static void PickBestIntra16(VP8EncIterator* const it, VP8ModeScore* rd) {
  VP8ModeScore* rd_cur = &rd_tmp;
  VP8ModeScore* rd_best = rd;
  int mode;
-  int is_flat = IsFlatSource16(it->yuv_in_ + Y_OFF_ENC);

  rd->mode_i16 = -1;
  for (mode = 0; mode < NUM_PRED_MODES; ++mode) {
@ -1004,14 +1003,10 @@ static void PickBestIntra16(VP8EncIterator* const it, VP8ModeScore* rd) {
        tlambda ? MULT_8B(tlambda, VP8TDisto16x16(src, tmp_dst, kWeightY)) : 0;
    rd_cur->H = VP8FixedCostsI16[mode];
    rd_cur->R = VP8GetCostLuma16(it, rd_cur);
-    if (is_flat) {
-      // refine the first impression (which was in pixel space)
-      is_flat = IsFlat(rd_cur->y_ac_levels[0], kNumBlocks, FLATNESS_LIMIT_I16);
-      if (is_flat) {
-        // Block is very flat. We put emphasis on the distortion being very low!
-        rd_cur->D *= 2;
-        rd_cur->SD *= 2;
-      }
+    if (mode > 0 &&
+        IsFlat(rd_cur->y_ac_levels[0], kNumBlocks, FLATNESS_LIMIT_I16)) {
+      // penalty to avoid flat area to be mispredicted by complex mode
+      rd_cur->R += FLATNESS_PENALTY * kNumBlocks;
    }

    // Since we always examine Intra16 first, we can overwrite *rd directly.
@ -1092,8 +1087,7 @@ static int PickBestIntra4(VP8EncIterator* const it, VP8ModeScore* const rd) {
                  : 0;
      rd_tmp.H = mode_costs[mode];

-      // Add flatness penalty, to avoid flat area to be mispredicted
-      // by a complex mode.
+      // Add flatness penalty
      if (mode > 0 && IsFlat(tmp_levels, kNumBlocks, FLATNESS_LIMIT_I4)) {
        rd_tmp.R = FLATNESS_PENALTY * kNumBlocks;
      } else {
@ -1248,19 +1242,11 @@ static void RefineUsingDistortion(VP8EncIterator* const it,
      if (mode > 0 && VP8FixedCostsI16[mode] > bit_limit) {
        continue;
      }
-
      if (score < best_score) {
        best_mode = mode;
        best_score = score;
      }
    }
-    if (it->x_ == 0 || it->y_ == 0) {
-      // avoid starting a checkerboard resonance from the border. See bug #432.
-      if (IsFlatSource16(src)) {
-        best_mode = (it->x_ == 0) ? 0 : 2;
-        try_both_modes = 0;  // stick to i16
-      }
-    }
    VP8SetIntra16Mode(it, best_mode);
    // we'll reconstruct later, if i16 mode actually gets selected
  }
--- a/src/enc/vp8i_enc.h
+++ b/src/enc/vp8i_enc.h
@ -31,8 +31,8 @@ extern "C" {

 // version numbers
 #define ENC_MAJ_VERSION 1
-#define ENC_MIN_VERSION 1
-#define ENC_REV_VERSION 0
+#define ENC_MIN_VERSION 0
+#define ENC_REV_VERSION 2

 enum { MAX_LF_LEVELS = 64,       // Maximum loop filter level
       MAX_VARIABLE_LEVEL = 67,  // last (inclusive) level with variable cost
@ -249,7 +249,7 @@ typedef struct {
  int           percent0_;         // saved initial progress percent

  DError        left_derr_;        // left error diffusion (u/v)
-  DError*       top_derr_;         // top diffusion error - NULL if disabled
+  DError       *top_derr_;         // top diffusion error - NULL if disabled

  uint8_t* y_left_;    // left luma samples (addressable from index -1 to 15).
  uint8_t* u_left_;    // left u samples (addressable from index -1 to 7)
--- a/src/libwebp.rc
+++ b/src/libwebp.rc
@ -6,8 +6,8 @@
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,0,1,0
- PRODUCTVERSION 1,0,1,0
+ FILEVERSION 1,0,0,2
+ PRODUCTVERSION 1,0,0,2
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebp DLL"
-            VALUE "FileVersion", "1.1.0"
+            VALUE "FileVersion", "1.0.2"
            VALUE "InternalName", "libwebp.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebp.dll"
            VALUE "ProductName", "WebP Image Codec"
-            VALUE "ProductVersion", "1.1.0"
+            VALUE "ProductVersion", "1.0.2"
        END
    END
    BLOCK "VarFileInfo"
--- a/src/libwebpdecoder.rc
+++ b/src/libwebpdecoder.rc
@ -6,8 +6,8 @@
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,0,1,0
- PRODUCTVERSION 1,0,1,0
+ FILEVERSION 1,0,0,2
+ PRODUCTVERSION 1,0,0,2
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebpdecoder DLL"
-            VALUE "FileVersion", "1.1.0"
+            VALUE "FileVersion", "1.0.2"
            VALUE "InternalName", "libwebpdecoder.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebpdecoder.dll"
            VALUE "ProductName", "WebP Image Decoder"
-            VALUE "ProductVersion", "1.1.0"
+            VALUE "ProductVersion", "1.0.2"
        END
    END
    BLOCK "VarFileInfo"
--- a/src/mux/Makefile.am
+++ b/src/mux/Makefile.am
@ -17,6 +17,6 @@ noinst_HEADERS =
 noinst_HEADERS += ../webp/format_constants.h

 libwebpmux_la_LIBADD = ../libwebp.la
-libwebpmux_la_LDFLAGS = -no-undefined -version-info 3:5:0 -lm
+libwebpmux_la_LDFLAGS = -no-undefined -version-info 3:4:0 -lm
 libwebpmuxincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebpmux.pc
--- a/src/mux/libwebpmux.rc
+++ b/src/mux/libwebpmux.rc
@ -6,8 +6,8 @@
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,0,1,0
- PRODUCTVERSION 1,0,1,0
+ FILEVERSION 1,0,0,2
+ PRODUCTVERSION 1,0,0,2
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebpmux DLL"
-            VALUE "FileVersion", "1.1.0"
+            VALUE "FileVersion", "1.0.2"
            VALUE "InternalName", "libwebpmux.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebpmux.dll"
            VALUE "ProductName", "WebP Image Muxer"
-            VALUE "ProductVersion", "1.1.0"
+            VALUE "ProductVersion", "1.0.2"
        END
    END
    BLOCK "VarFileInfo"
--- a/src/mux/muxi.h
+++ b/src/mux/muxi.h
@ -28,8 +28,8 @@ extern "C" {
 // Defines and constants.

 #define MUX_MAJ_VERSION 1
-#define MUX_MIN_VERSION 1
-#define MUX_REV_VERSION 0
+#define MUX_MIN_VERSION 0
+#define MUX_REV_VERSION 2

 // Chunk object.
 typedef struct WebPChunk WebPChunk;
--- a/src/mux/muxread.c
+++ b/src/mux/muxread.c
@ -100,7 +100,7 @@ static int MuxImageParse(const WebPChunk* const chunk, int copy_data,
                         WebPMuxImage* const wpi) {
  const uint8_t* bytes = chunk->data_.bytes;
  size_t size = chunk->data_.size;
-  const uint8_t* const last = (bytes == NULL) ? NULL : bytes + size;
+  const uint8_t* const last = bytes + size;
  WebPChunk subchunk;
  size_t subchunk_size;
  WebPChunk** unknown_chunk_list = &wpi->unknown_;
--- a/src/utils/bit_reader_inl_utils.h
+++ b/src/utils/bit_reader_inl_utils.h
@ -104,8 +104,7 @@ void VP8LoadNewBytes(VP8BitReader* const br) {
 }

 // Read a bit with proba 'prob'. Speed-critical function!
-static WEBP_INLINE int VP8GetBit(VP8BitReader* const br,
-                                 int prob, const char label[]) {
+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.
@ -130,14 +129,13 @@ static WEBP_INLINE int VP8GetBit(VP8BitReader* const br,
      br->bits_ -= shift;
    }
    br->range_ = range - 1;
-    BT_TRACK(br);
    return bit;
  }
 }

 // simplified version of VP8GetBit() for prob=0x80 (note shift is always 1 here)
 static WEBP_UBSAN_IGNORE_UNSIGNED_OVERFLOW WEBP_INLINE
-int VP8GetSigned(VP8BitReader* const br, int v, const char label[]) {
+int VP8GetSigned(VP8BitReader* const br, int v) {
  if (br->bits_ < 0) {
    VP8LoadNewBytes(br);
  }
@ -150,13 +148,11 @@ int VP8GetSigned(VP8BitReader* const br, int v, const char label[]) {
    br->range_ += mask;
    br->range_ |= 1;
    br->value_ -= (bit_t)((split + 1) & mask) << pos;
-    BT_TRACK(br);
    return (v ^ mask) - mask;
  }
 }

-static WEBP_INLINE int VP8GetBitAlt(VP8BitReader* const br,
-                                    int prob, const char label[]) {
+static WEBP_INLINE int VP8GetBitAlt(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.
@ -183,7 +179,6 @@ static WEBP_INLINE int VP8GetBitAlt(VP8BitReader* const br,
      br->bits_ -= shift;
    }
    br->range_ = range;
-    BT_TRACK(br);
    return bit;
  }
 }
--- a/src/utils/bit_reader_utils.c
+++ b/src/utils/bit_reader_utils.c
@ -102,18 +102,17 @@ void VP8LoadFinalBytes(VP8BitReader* const br) {
 //------------------------------------------------------------------------------
 // Higher-level calls

-uint32_t VP8GetValue(VP8BitReader* const br, int bits, const char label[]) {
+uint32_t VP8GetValue(VP8BitReader* const br, int bits) {
  uint32_t v = 0;
  while (bits-- > 0) {
-    v |= VP8GetBit(br, 0x80, label) << bits;
+    v |= VP8GetBit(br, 0x80) << bits;
  }
  return v;
 }

-int32_t VP8GetSignedValue(VP8BitReader* const br, int bits,
-                          const char label[]) {
-  const int value = VP8GetValue(br, bits, label);
-  return VP8Get(br, label) ? -value : value;
+int32_t VP8GetSignedValue(VP8BitReader* const br, int bits) {
+  const int value = VP8GetValue(br, bits);
+  return VP8Get(br) ? -value : value;
 }

 //------------------------------------------------------------------------------
@ -221,78 +220,3 @@ uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
 }

 //------------------------------------------------------------------------------
-// Bit-tracing tool
-
-#if (BITTRACE > 0)
-
-#include <stdlib.h>   // for atexit()
-#include <stdio.h>
-#include <string.h>
-
-#define MAX_NUM_LABELS 32
-static struct {
-  const char* label;
-  int size;
-  int count;
-} kLabels[MAX_NUM_LABELS];
-
-static int last_label = 0;
-static int last_pos = 0;
-static const uint8_t* buf_start = NULL;
-static int init_done = 0;
-
-static void PrintBitTraces(void) {
-  int i;
-  int scale = 1;
-  int total = 0;
-  const char* units = "bits";
-#if (BITTRACE == 2)
-  scale = 8;
-  units = "bytes";
-#endif
-  for (i = 0; i < last_label; ++i) total += kLabels[i].size;
-  if (total < 1) total = 1;   // avoid rounding errors
-  printf("=== Bit traces ===\n");
-  for (i = 0; i < last_label; ++i) {
-    const int skip = 16 - (int)strlen(kLabels[i].label);
-    const int value = (kLabels[i].size + scale - 1) / scale;
-    assert(skip > 0);
-    printf("%s \%*s: %6d %s   \t[%5.2f%%] [count: %7d]\n",
-           kLabels[i].label, skip, "", value, units,
-           100.f * kLabels[i].size / total,
-           kLabels[i].count);
-  }
-  total = (total + scale - 1) / scale;
-  printf("Total: %d %s\n", total, units);
-}
-
-void BitTrace(const struct VP8BitReader* const br, const char label[]) {
-  int i, pos;
-  if (!init_done) {
-    memset(kLabels, 0, sizeof(kLabels));
-    atexit(PrintBitTraces);
-    buf_start = br->buf_;
-    init_done = 1;
-  }
-  pos = (int)(br->buf_ - buf_start) * 8 - br->bits_;
-  // if there's a too large jump, we've changed partition -> reset counter
-  if (abs(pos - last_pos) > 32) {
-    buf_start = br->buf_;
-    pos = 0;
-    last_pos = 0;
-  }
-  if (br->range_ >= 0x7f) pos += kVP8Log2Range[br->range_ - 0x7f];
-  for (i = 0; i < last_label; ++i) {
-    if (!strcmp(label, kLabels[i].label)) break;
-  }
-  if (i == MAX_NUM_LABELS) abort();   // overflow!
-  kLabels[i].label = label;
-  kLabels[i].size += pos - last_pos;
-  kLabels[i].count += 1;
-  if (i == last_label) ++last_label;
-  last_pos = pos;
-}
-
-#endif  // BITTRACE > 0
-
-//------------------------------------------------------------------------------
--- a/src/utils/bit_reader_utils.h
+++ b/src/utils/bit_reader_utils.h
@ -21,27 +21,6 @@
 #endif
 #include "src/webp/types.h"

-// Warning! This macro triggers quite some MACRO wizardry around func signature!
-#if !defined(BITTRACE)
-#define BITTRACE 0    // 0 = off, 1 = print bits, 2 = print bytes
-#endif
-
-#if (BITTRACE > 0)
-struct VP8BitReader;
-extern void BitTrace(const struct VP8BitReader* const br, const char label[]);
-#define BT_TRACK(br) BitTrace(br, label)
-#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
-#else
-#define BT_TRACK(br)
-// We'll REMOVE the 'const char label[]' from all signatures and calls (!!):
-#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
-#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
-#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
-#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
-#define VP8GetBitAlt(BR, P, L) VP8GetBitAlt(BR, P)
-#define VP8GetSigned(BR, V, L) VP8GetSigned(BR, V)
-#endif
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@ -113,15 +92,17 @@ void VP8BitReaderSetBuffer(VP8BitReader* const br,
 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, const char label[]);
+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,
-                          const char label[]);
+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, ...)
+//   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.
--- a/src/utils/bit_writer_utils.c
+++ b/src/utils/bit_writer_utils.c
@ -70,7 +70,7 @@ static void Flush(VP8BitWriter* const bw) {
      const int value = (bits & 0x100) ? 0x00 : 0xff;
      for (; bw->run_ > 0; --bw->run_) bw->buf_[pos++] = value;
    }
-    bw->buf_[pos++] = bits & 0xff;
+    bw->buf_[pos++] = bits;
    bw->pos_ = pos;
  } else {
    bw->run_++;   // delay writing of bytes 0xff, pending eventual carry.
--- a/src/utils/color_cache_utils.h
+++ b/src/utils/color_cache_utils.h
@ -17,7 +17,6 @@

 #include <assert.h>

-#include "src/dsp/dsp.h"
 #include "src/webp/types.h"

 #ifdef __cplusplus
@ -26,16 +25,15 @@ extern "C" {

 // Main color cache struct.
 typedef struct {
-  uint32_t* colors_;  // color entries
+  uint32_t *colors_;  // color entries
  int hash_shift_;    // Hash shift: 32 - hash_bits_.
  int hash_bits_;
 } VP8LColorCache;

-static const uint32_t kHashMul = 0x1e35a7bdu;
+static const uint64_t kHashMul = 0x1e35a7bdull;

-static WEBP_UBSAN_IGNORE_UNSIGNED_OVERFLOW WEBP_INLINE
-int VP8LHashPix(uint32_t argb, int shift) {
-  return (int)((argb * kHashMul) >> shift);
+static WEBP_INLINE int VP8LHashPix(uint32_t argb, int shift) {
+  return (int)(((argb * kHashMul) & 0xffffffffu) >> shift);
 }

 static WEBP_INLINE uint32_t VP8LColorCacheLookup(
--- a/src/utils/huffman_utils.c
+++ b/src/utils/huffman_utils.c
@ -91,8 +91,7 @@ static int BuildHuffmanTable(HuffmanCode* const root_table, int root_bits,

  assert(code_lengths_size != 0);
  assert(code_lengths != NULL);
-  assert((root_table != NULL && sorted != NULL) ||
-         (root_table == NULL && sorted == NULL));
+  assert(root_table != NULL);
  assert(root_bits > 0);

  // Build histogram of code lengths.
@ -121,22 +120,16 @@ static int BuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
    const int symbol_code_length = code_lengths[symbol];
    if (code_lengths[symbol] > 0) {
-      if (sorted != NULL) {
-        sorted[offset[symbol_code_length]++] = symbol;
-      } else {
-        offset[symbol_code_length]++;
-      }
+      sorted[offset[symbol_code_length]++] = symbol;
    }
  }

  // Special case code with only one value.
  if (offset[MAX_ALLOWED_CODE_LENGTH] == 1) {
-    if (sorted != NULL) {
-      HuffmanCode code;
-      code.bits = 0;
-      code.value = (uint16_t)sorted[0];
-      ReplicateValue(table, 1, total_size, code);
-    }
+    HuffmanCode code;
+    code.bits = 0;
+    code.value = (uint16_t)sorted[0];
+    ReplicateValue(table, 1, total_size, code);
    return total_size;
  }

@ -158,7 +151,6 @@ static int BuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
      if (num_open < 0) {
        return 0;
      }
-      if (root_table == NULL) continue;
      for (; count[len] > 0; --count[len]) {
        HuffmanCode code;
        code.bits = (uint8_t)len;
@ -180,21 +172,17 @@ static int BuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
      for (; count[len] > 0; --count[len]) {
        HuffmanCode code;
        if ((key & mask) != low) {
-          if (root_table != NULL) table += table_size;
+          table += table_size;
          table_bits = NextTableBitSize(count, len, root_bits);
          table_size = 1 << table_bits;
          total_size += table_size;
          low = key & mask;
-          if (root_table != NULL) {
-            root_table[low].bits = (uint8_t)(table_bits + root_bits);
-            root_table[low].value = (uint16_t)((table - root_table) - low);
-          }
-        }
-        if (root_table != NULL) {
-          code.bits = (uint8_t)(len - root_bits);
-          code.value = (uint16_t)sorted[symbol++];
-          ReplicateValue(&table[key >> root_bits], step, table_size, code);
+          root_table[low].bits = (uint8_t)(table_bits + root_bits);
+          root_table[low].value = (uint16_t)((table - root_table) - low);
        }
+        code.bits = (uint8_t)(len - root_bits);
+        code.value = (uint16_t)sorted[symbol++];
+        ReplicateValue(&table[key >> root_bits], step, table_size, code);
        key = GetNextKey(key, len);
      }
    }
@ -214,83 +202,22 @@ static int BuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
  ((1 << MAX_CACHE_BITS) + NUM_LITERAL_CODES + NUM_LENGTH_CODES)
 // Cut-off value for switching between heap and stack allocation.
 #define SORTED_SIZE_CUTOFF 512
-int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits,
+int VP8LBuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
                          const int code_lengths[], int code_lengths_size) {
-  const int total_size =
-      BuildHuffmanTable(NULL, root_bits, code_lengths, code_lengths_size, NULL);
+  int total_size;
  assert(code_lengths_size <= MAX_CODE_LENGTHS_SIZE);
-  if (total_size == 0 || root_table == NULL) return total_size;
-
-  if (root_table->curr_segment->curr_table + total_size >=
-      root_table->curr_segment->start + root_table->curr_segment->size) {
-    // If 'root_table' does not have enough memory, allocate a new segment.
-    // The available part of root_table->curr_segment is left unused because we
-    // need a contiguous buffer.
-    const int segment_size = root_table->curr_segment->size;
-    struct HuffmanTablesSegment* next =
-        (HuffmanTablesSegment*)WebPSafeMalloc(1, sizeof(*next));
-    if (next == NULL) return 0;
-    // Fill the new segment.
-    // We need at least 'total_size' but if that value is small, it is better to
-    // allocate a big chunk to prevent more allocations later. 'segment_size' is
-    // therefore chosen (any other arbitrary value could be chosen).
-    next->size = total_size > segment_size ? total_size : segment_size;
-    next->start =
-        (HuffmanCode*)WebPSafeMalloc(next->size, sizeof(*next->start));
-    if (next->start == NULL) {
-      WebPSafeFree(next);
-      return 0;
-    }
-    next->curr_table = next->start;
-    next->next = NULL;
-    // Point to the new segment.
-    root_table->curr_segment->next = next;
-    root_table->curr_segment = next;
-  }
  if (code_lengths_size <= SORTED_SIZE_CUTOFF) {
    // use local stack-allocated array.
    uint16_t sorted[SORTED_SIZE_CUTOFF];
-    BuildHuffmanTable(root_table->curr_segment->curr_table, root_bits,
-                      code_lengths, code_lengths_size, sorted);
-  } else {  // rare case. Use heap allocation.
+    total_size = BuildHuffmanTable(root_table, root_bits,
+                                   code_lengths, code_lengths_size, sorted);
+  } else {   // rare case. Use heap allocation.
    uint16_t* const sorted =
        (uint16_t*)WebPSafeMalloc(code_lengths_size, sizeof(*sorted));
    if (sorted == NULL) return 0;
-    BuildHuffmanTable(root_table->curr_segment->curr_table, root_bits,
-                      code_lengths, code_lengths_size, sorted);
+    total_size = BuildHuffmanTable(root_table, root_bits,
+                                   code_lengths, code_lengths_size, sorted);
    WebPSafeFree(sorted);
  }
  return total_size;
 }
-
-int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables) {
-  // Have 'segment' point to the first segment for now, 'root'.
-  HuffmanTablesSegment* const root = &huffman_tables->root;
-  huffman_tables->curr_segment = root;
-  // Allocate root.
-  root->start = (HuffmanCode*)WebPSafeMalloc(size, sizeof(*root->start));
-  if (root->start == NULL) return 0;
-  root->curr_table = root->start;
-  root->next = NULL;
-  root->size = size;
-  return 1;
-}
-
-void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables) {
-  HuffmanTablesSegment *current, *next;
-  if (huffman_tables == NULL) return;
-  // Free the root node.
-  current = &huffman_tables->root;
-  next = current->next;
-  WebPSafeFree(current->start);
-  current->start = NULL;
-  current->next = NULL;
-  current = next;
-  // Free the following nodes.
-  while (current != NULL) {
-    next = current->next;
-    WebPSafeFree(current->start);
-    WebPSafeFree(current);
-    current = next;
-  }
-}
--- a/src/utils/huffman_utils.h
+++ b/src/utils/huffman_utils.h
@ -43,29 +43,6 @@ typedef struct {
                    // or non-literal symbol otherwise
 } HuffmanCode32;

-// Contiguous memory segment of HuffmanCodes.
-typedef struct HuffmanTablesSegment {
-  HuffmanCode* start;
-  // Pointer to where we are writing into the segment. Starts at 'start' and
-  // cannot go beyond 'start' + 'size'.
-  HuffmanCode* curr_table;
-  // Pointer to the next segment in the chain.
-  struct HuffmanTablesSegment* next;
-  int size;
-} HuffmanTablesSegment;
-
-// Chained memory segments of HuffmanCodes.
-typedef struct HuffmanTables {
-  HuffmanTablesSegment root;
-  // Currently processed segment. At first, this is 'root'.
-  HuffmanTablesSegment* curr_segment;
-} HuffmanTables;
-
-// Allocates a HuffmanTables with 'size' contiguous HuffmanCodes. Returns 0 on
-// memory allocation error, 1 otherwise.
-int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables);
-void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables);
-
 #define HUFFMAN_PACKED_BITS 6
 #define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)

@ -101,7 +78,7 @@ void VP8LHtreeGroupsFree(HTreeGroup* const htree_groups);
 // the huffman table.
 // Returns built table size or 0 in case of error (invalid tree or
 // memory error).
-int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits,
+int VP8LBuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
                          const int code_lengths[], int code_lengths_size);

 #ifdef __cplusplus
--- a/src/utils/rescaler_utils.c
+++ b/src/utils/rescaler_utils.c
@ -84,14 +84,14 @@ int WebPRescalerGetScaledDimensions(int src_width, int src_height,
    int height = *scaled_height;

    // if width is unspecified, scale original proportionally to height ratio.
-    if (width == 0 && src_height > 0) {
+    if (width == 0) {
      width =
-          (int)(((uint64_t)src_width * height + src_height - 1) / src_height);
+          (int)(((uint64_t)src_width * height + src_height / 2) / src_height);
    }
    // if height is unspecified, scale original proportionally to width ratio.
-    if (height == 0 && src_width > 0) {
+    if (height == 0) {
      height =
-          (int)(((uint64_t)src_height * width + src_width - 1) / src_width);
+          (int)(((uint64_t)src_height * width + src_width / 2) / src_width);
    }
    // Check if the overall dimensions still make sense.
    if (width <= 0 || height <= 0) {
--- a/src/utils/thread_utils.c
+++ b/src/utils/thread_utils.c
@ -73,7 +73,7 @@ typedef struct {
 #endif

 static int pthread_create(pthread_t* const thread, const void* attr,
-                          unsigned int (__stdcall* start)(void*), void* arg) {
+                          unsigned int (__stdcall *start)(void*), void* arg) {
  (void)attr;
 #ifdef USE_CREATE_THREAD
  *thread = CreateThread(NULL,   /* lpThreadAttributes */
@ -217,12 +217,8 @@ static THREADFN ThreadLoop(void* ptr) {
      done = 1;
    }
    // signal to the main thread that we're done (for Sync())
-    // Note the associated mutex does not need to be held when signaling the
-    // condition. Unlocking the mutex first may improve performance in some
-    // implementations, avoiding the case where the waiting thread can't
-    // reacquire the mutex when woken.
-    pthread_mutex_unlock(&impl->mutex_);
    pthread_cond_signal(&impl->condition_);
+    pthread_mutex_unlock(&impl->mutex_);
  }
  return THREAD_RETURN(NULL);    // Thread is finished
 }
@ -244,13 +240,7 @@ static void ChangeState(WebPWorker* const worker, WebPWorkerStatus new_status) {
    // assign new status and release the working thread if needed
    if (new_status != OK) {
      worker->status_ = new_status;
-      // Note the associated mutex does not need to be held when signaling the
-      // condition. Unlocking the mutex first may improve performance in some
-      // implementations, avoiding the case where the waiting thread can't
-      // reacquire the mutex when woken.
-      pthread_mutex_unlock(&impl->mutex_);
      pthread_cond_signal(&impl->condition_);
-      return;
    }
  }
  pthread_mutex_unlock(&impl->mutex_);
--- a/src/utils/utils.c
+++ b/src/utils/utils.c
@ -216,14 +216,9 @@ void WebPSafeFree(void* const ptr) {
  free(ptr);
 }

-// Public API functions.
-
-void* WebPMalloc(size_t size) {
-  return WebPSafeMalloc(1, size);
-}
-
+// Public API function.
 void WebPFree(void* ptr) {
-  WebPSafeFree(ptr);
+  free(ptr);
 }

 //------------------------------------------------------------------------------
--- a/src/utils/utils.h
+++ b/src/utils/utils.h
@ -92,14 +92,14 @@ static WEBP_INLINE uint32_t GetLE32(const uint8_t* const data) {
 // 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) & 0xff;
-  data[1] = (val >> 8) & 0xff;
+  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) & 0xff;
+  data[2] = (val >> 16);
 }

 static WEBP_INLINE void PutLE32(uint8_t* const data, uint32_t val) {
--- a/src/webp/decode.h
+++ b/src/webp/decode.h
@ -20,7 +20,7 @@
 extern "C" {
 #endif

-#define WEBP_DECODER_ABI_VERSION 0x0209    // MAJOR(8b) + MINOR(8b)
+#define WEBP_DECODER_ABI_VERSION 0x0208    // MAJOR(8b) + MINOR(8b)

 // Note: forward declaring enumerations is not allowed in (strict) C and C++,
 // the types are left here for reference.
@ -91,6 +91,9 @@ WEBP_EXTERN uint8_t* WebPDecodeYUV(const uint8_t* data, size_t data_size,
                                   uint8_t** u, uint8_t** v,
                                   int* stride, int* uv_stride);

+// Releases memory returned by the WebPDecode*() functions above.
+WEBP_EXTERN void WebPFree(void* ptr);
+
 // These five functions are variants of the above ones, that decode the image
 // directly into a pre-allocated buffer 'output_buffer'. The maximum storage
 // available in this buffer is indicated by 'output_buffer_size'. If this
--- a/src/webp/encode.h
+++ b/src/webp/encode.h
@ -20,7 +20,7 @@
 extern "C" {
 #endif

-#define WEBP_ENCODER_ABI_VERSION 0x020f    // MAJOR(8b) + MINOR(8b)
+#define WEBP_ENCODER_ABI_VERSION 0x020e    // MAJOR(8b) + MINOR(8b)

 // Note: forward declaring enumerations is not allowed in (strict) C and C++,
 // the types are left here for reference.
@ -62,10 +62,6 @@ WEBP_EXTERN size_t WebPEncodeBGRA(const uint8_t* bgra,
 // These functions are the equivalent of the above, but compressing in a
 // lossless manner. Files are usually larger than lossy format, but will
 // not suffer any compression loss.
-// Note these functions, like the lossy versions, use the library's default
-// settings. For lossless this means 'exact' is disabled. RGB values in
-// transparent areas will be modified to improve compression. To avoid this,
-// use WebPEncode() and set WebPConfig::exact to 1.
 WEBP_EXTERN size_t WebPEncodeLosslessRGB(const uint8_t* rgb,
                                         int width, int height, int stride,
                                         uint8_t** output);
@ -79,6 +75,9 @@ WEBP_EXTERN size_t WebPEncodeLosslessBGRA(const uint8_t* bgra,
                                          int width, int height, int stride,
                                          uint8_t** output);

+// Releases memory returned by the WebPEncode*() functions above.
+WEBP_EXTERN void WebPFree(void* ptr);
+
 //------------------------------------------------------------------------------
 // Coding parameters

@ -303,7 +302,7 @@ struct WebPPicture {
  // YUV input (mostly used for input to lossy compression)
  WebPEncCSP colorspace;     // colorspace: should be YUV420 for now (=Y'CbCr).
  int width, height;         // dimensions (less or equal to WEBP_MAX_DIMENSION)
-  uint8_t* y, *u, *v;        // pointers to luma/chroma planes.
+  uint8_t *y, *u, *v;        // pointers to luma/chroma planes.
  int y_stride, uv_stride;   // luma/chroma strides.
  uint8_t* a;                // pointer to the alpha plane
  int a_stride;              // stride of the alpha plane
@ -347,7 +346,7 @@ struct WebPPicture {
  uint32_t pad3[3];       // padding for later use

  // Unused for now
-  uint8_t* pad4, *pad5;
+  uint8_t *pad4, *pad5;
  uint32_t pad6[8];       // padding for later use

  // PRIVATE FIELDS
--- a/src/webp/mux.h
+++ b/src/webp/mux.h
@ -57,7 +57,7 @@ extern "C" {
  WebPMuxGetChunk(mux, "ICCP", &icc_profile);
  // ... (Consume icc_data).
  WebPMuxDelete(mux);
-  WebPFree(data);
+  free(data);
 */

 // Note: forward declaring enumerations is not allowed in (strict) C and C++,
@ -245,7 +245,7 @@ WEBP_EXTERN WebPMuxError WebPMuxPushFrame(
    WebPMux* mux, const WebPMuxFrameInfo* frame, int copy_data);

 // Gets the nth frame from the mux object.
-// The content of 'frame->bitstream' is allocated using WebPMalloc(), and NOT
+// The content of 'frame->bitstream' is allocated using malloc(), and NOT
 // owned by the 'mux' object. It MUST be deallocated by the caller by calling
 // WebPDataClear().
 // nth=0 has a special meaning - last position.
@ -376,10 +376,10 @@ WEBP_EXTERN WebPMuxError WebPMuxNumChunks(const WebPMux* mux,
 // Assembles all chunks in WebP RIFF format and returns in 'assembled_data'.
 // This function also validates the mux object.
 // Note: The content of 'assembled_data' will be ignored and overwritten.
-// Also, the content of 'assembled_data' is allocated using WebPMalloc(), and
-// NOT owned by the 'mux' object. It MUST be deallocated by the caller by
-// calling WebPDataClear(). It's always safe to call WebPDataClear() upon
-// return, even in case of error.
+// Also, the content of 'assembled_data' is allocated using malloc(), and NOT
+// owned by the 'mux' object. It MUST be deallocated by the caller by calling
+// WebPDataClear(). It's always safe to call WebPDataClear() upon return,
+// even in case of error.
 // Parameters:
 //   mux - (in/out) object whose chunks are to be assembled
 //   assembled_data - (out) assembled WebP data
--- a/src/webp/mux_types.h
+++ b/src/webp/mux_types.h
@ -14,6 +14,7 @@
 #ifndef WEBP_WEBP_MUX_TYPES_H_
 #define WEBP_WEBP_MUX_TYPES_H_

+#include <stdlib.h>  // free()
 #include <string.h>  // memset()
 #include "./types.h"

@ -55,7 +56,6 @@ typedef enum WebPMuxAnimBlend {

 // Data type used to describe 'raw' data, e.g., chunk data
 // (ICC profile, metadata) and WebP compressed image data.
-// 'bytes' memory must be allocated using WebPMalloc() and such.
 struct WebPData {
  const uint8_t* bytes;
  size_t size;
@ -68,11 +68,11 @@ static WEBP_INLINE void WebPDataInit(WebPData* webp_data) {
  }
 }

-// Clears the contents of the 'webp_data' object by calling WebPFree().
-// Does not deallocate the object itself.
+// Clears the contents of the 'webp_data' object by calling free(). Does not
+// deallocate the object itself.
 static WEBP_INLINE void WebPDataClear(WebPData* webp_data) {
  if (webp_data != NULL) {
-    WebPFree((void*)webp_data->bytes);
+    free((void*)webp_data->bytes);
    WebPDataInit(webp_data);
  }
 }
@ -83,7 +83,7 @@ static WEBP_INLINE int WebPDataCopy(const WebPData* src, WebPData* dst) {
  if (src == NULL || dst == NULL) return 0;
  WebPDataInit(dst);
  if (src->bytes != NULL && src->size != 0) {
-    dst->bytes = (uint8_t*)WebPMalloc(src->size);
+    dst->bytes = (uint8_t*)malloc(src->size);
    if (dst->bytes == NULL) return 0;
    memcpy((void*)dst->bytes, src->bytes, src->size);
    dst->size = src->size;
--- a/src/webp/types.h
+++ b/src/webp/types.h
@ -7,7 +7,7 @@
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
-//  Common types + memory wrappers
+//  Common types
 //
 // Author: Skal (pascal.massimino@gmail.com)

@ -49,20 +49,4 @@ typedef long long int int64_t;
 // Macro to check ABI compatibility (same major revision number)
 #define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))

-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Allocates 'size' bytes of memory. Returns NULL upon error. Memory
-// must be deallocated by calling WebPFree(). This function is made available
-// by the core 'libwebp' library.
-WEBP_EXTERN void* WebPMalloc(size_t size);
-
-// Releases memory returned by the WebPDecode*() functions (from decode.h).
-WEBP_EXTERN void WebPFree(void* ptr);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
 #endif  // WEBP_WEBP_TYPES_H_
--- a/swig/libwebp.py
+++ b/swig/libwebp.py
@ -1,22 +1,13 @@
 # This file was automatically generated by SWIG (http://www.swig.org).
-# Version 3.0.12
+# Version 2.0.4
 #
 # Do not make changes to this file unless you know what you are doing--modify
 # the SWIG interface file instead.

-from sys import version_info as _swig_python_version_info
-if _swig_python_version_info >= (2, 7, 0):
-    def swig_import_helper():
-        import importlib
-        pkg = __name__.rpartition('.')[0]
-        mname = '.'.join((pkg, '_libwebp')).lstrip('.')
-        try:
-            return importlib.import_module(mname)
-        except ImportError:
-            return importlib.import_module('_libwebp')
-    _libwebp = swig_import_helper()
-    del swig_import_helper
-elif _swig_python_version_info >= (2, 6, 0):
+
+
+from sys import version_info
+if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
@ -26,143 +17,122 @@ elif _swig_python_version_info >= (2, 6, 0):
        except ImportError:
            import _libwebp
            return _libwebp
-        try:
-            _mod = imp.load_module('_libwebp', fp, pathname, description)
-        finally:
-            if fp is not None:
+        if fp is not None:
+            try:
+                _mod = imp.load_module('_libwebp', fp, pathname, description)
+            finally:
                fp.close()
-        return _mod
+            return _mod
    _libwebp = swig_import_helper()
    del swig_import_helper
 else:
    import _libwebp
-del _swig_python_version_info
-
+del version_info
 try:
    _swig_property = property
 except NameError:
-    pass  # Python < 2.2 doesn't have 'property'.
-
-try:
-    import builtins as __builtin__
-except ImportError:
-    import __builtin__
-
-def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
-    if (name == "thisown"):
-        return self.this.own(value)
+    pass # Python < 2.2 doesn't have 'property'.
+def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
+    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
-    method = class_type.__swig_setmethods__.get(name, None)
-    if method:
-        return method(self, value)
+    method = class_type.__swig_setmethods__.get(name,None)
+    if method: return method(self,value)
    if (not static):
-        if _newclass:
-            object.__setattr__(self, name, value)
-        else:
-            self.__dict__[name] = value
+        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

+def _swig_setattr(self,class_type,name,value):
+    return _swig_setattr_nondynamic(self,class_type,name,value,0)

-def _swig_setattr(self, class_type, name, value):
-    return _swig_setattr_nondynamic(self, class_type, name, value, 0)
-
-
-def _swig_getattr(self, class_type, name):
-    if (name == "thisown"):
-        return self.this.own()
-    method = class_type.__swig_getmethods__.get(name, None)
-    if method:
-        return method(self)
-    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
-
+def _swig_getattr(self,class_type,name):
+    if (name == "thisown"): return self.this.own()
+    method = class_type.__swig_getmethods__.get(name,None)
+    if method: return method(self)
+    raise AttributeError(name)

 def _swig_repr(self):
-    try:
-        strthis = "proxy of " + self.this.__repr__()
-    except __builtin__.Exception:
-        strthis = ""
+    try: strthis = "proxy of " + self.this.__repr__()
+    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

 try:
    _object = object
    _newclass = 1
-except __builtin__.Exception:
-    class _object:
-        pass
+except AttributeError:
+    class _object : pass
    _newclass = 0


+
 def WebPGetDecoderVersion():
-    """WebPGetDecoderVersion() -> int"""
-    return _libwebp.WebPGetDecoderVersion()
+  """WebPGetDecoderVersion() -> int"""
+  return _libwebp.WebPGetDecoderVersion()

-def WebPGetInfo(data):
-    """WebPGetInfo(uint8_t data) -> (width, height)"""
-    return _libwebp.WebPGetInfo(data)
+def WebPGetInfo(*args):
+  """WebPGetInfo(uint8_t data) -> (width, height)"""
+  return _libwebp.WebPGetInfo(*args)

-def WebPDecodeRGB(data):
-    """WebPDecodeRGB(uint8_t data) -> (rgb, width, height)"""
-    return _libwebp.WebPDecodeRGB(data)
+def WebPDecodeRGB(*args):
+  """WebPDecodeRGB(uint8_t data) -> (rgb, width, height)"""
+  return _libwebp.WebPDecodeRGB(*args)

-def WebPDecodeRGBA(data):
-    """WebPDecodeRGBA(uint8_t data) -> (rgb, width, height)"""
-    return _libwebp.WebPDecodeRGBA(data)
+def WebPDecodeRGBA(*args):
+  """WebPDecodeRGBA(uint8_t data) -> (rgb, width, height)"""
+  return _libwebp.WebPDecodeRGBA(*args)

-def WebPDecodeARGB(data):
-    """WebPDecodeARGB(uint8_t data) -> (rgb, width, height)"""
-    return _libwebp.WebPDecodeARGB(data)
+def WebPDecodeARGB(*args):
+  """WebPDecodeARGB(uint8_t data) -> (rgb, width, height)"""
+  return _libwebp.WebPDecodeARGB(*args)

-def WebPDecodeBGR(data):
-    """WebPDecodeBGR(uint8_t data) -> (rgb, width, height)"""
-    return _libwebp.WebPDecodeBGR(data)
+def WebPDecodeBGR(*args):
+  """WebPDecodeBGR(uint8_t data) -> (rgb, width, height)"""
+  return _libwebp.WebPDecodeBGR(*args)

-def WebPDecodeBGRA(data):
-    """WebPDecodeBGRA(uint8_t data) -> (rgb, width, height)"""
-    return _libwebp.WebPDecodeBGRA(data)
+def WebPDecodeBGRA(*args):
+  """WebPDecodeBGRA(uint8_t data) -> (rgb, width, height)"""
+  return _libwebp.WebPDecodeBGRA(*args)

 def WebPGetEncoderVersion():
-    """WebPGetEncoderVersion() -> int"""
-    return _libwebp.WebPGetEncoderVersion()
+  """WebPGetEncoderVersion() -> int"""
+  return _libwebp.WebPGetEncoderVersion()

-def wrap_WebPEncodeRGB(rgb, unused1, unused2, width, height, stride, quality_factor):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeRGB(rgb, unused1, unused2, width, height, stride, quality_factor)
+def wrap_WebPEncodeRGB(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeRGB(*args)

-def wrap_WebPEncodeBGR(rgb, unused1, unused2, width, height, stride, quality_factor):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeBGR(rgb, unused1, unused2, width, height, stride, quality_factor)
+def wrap_WebPEncodeBGR(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeBGR(*args)

-def wrap_WebPEncodeRGBA(rgb, unused1, unused2, width, height, stride, quality_factor):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeRGBA(rgb, unused1, unused2, width, height, stride, quality_factor)
+def wrap_WebPEncodeRGBA(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeRGBA(*args)

-def wrap_WebPEncodeBGRA(rgb, unused1, unused2, width, height, stride, quality_factor):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeBGRA(rgb, unused1, unused2, width, height, stride, quality_factor)
+def wrap_WebPEncodeBGRA(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeBGRA(*args)

-def wrap_WebPEncodeLosslessRGB(rgb, unused1, unused2, width, height, stride):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeLosslessRGB(rgb, unused1, unused2, width, height, stride)
+def wrap_WebPEncodeLosslessRGB(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeLosslessRGB(*args)

-def wrap_WebPEncodeLosslessBGR(rgb, unused1, unused2, width, height, stride):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeLosslessBGR(rgb, unused1, unused2, width, height, stride)
+def wrap_WebPEncodeLosslessBGR(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeLosslessBGR(*args)

-def wrap_WebPEncodeLosslessRGBA(rgb, unused1, unused2, width, height, stride):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeLosslessRGBA(rgb, unused1, unused2, width, height, stride)
-
-def wrap_WebPEncodeLosslessBGRA(rgb, unused1, unused2, width, height, stride):
-    """private, do not call directly."""
-    return _libwebp.wrap_WebPEncodeLosslessBGRA(rgb, unused1, unused2, width, height, stride)
+def wrap_WebPEncodeLosslessRGBA(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeLosslessRGBA(*args)

+def wrap_WebPEncodeLosslessBGRA(*args):
+  """private, do not call directly."""
+  return _libwebp.wrap_WebPEncodeLosslessBGRA(*args)
 _UNUSED = 1

-
 def WebPEncodeRGB(rgb, width, height, stride, quality_factor):
  """WebPEncodeRGB(uint8_t rgb, int width, int height, int stride, float quality_factor) -> lossy_webp"""
  webp = wrap_WebPEncodeRGB(
@ -171,7 +141,6 @@ def WebPEncodeRGB(rgb, width, height, stride, quality_factor):
    return None
  return webp[0]

-
 def WebPEncodeRGBA(rgb, width, height, stride, quality_factor):
  """WebPEncodeRGBA(uint8_t rgb, int width, int height, int stride, float quality_factor) -> lossy_webp"""
  webp = wrap_WebPEncodeRGBA(
@ -180,7 +149,6 @@ def WebPEncodeRGBA(rgb, width, height, stride, quality_factor):
    return None
  return webp[0]

-
 def WebPEncodeBGR(rgb, width, height, stride, quality_factor):
  """WebPEncodeBGR(uint8_t rgb, int width, int height, int stride, float quality_factor) -> lossy_webp"""
  webp = wrap_WebPEncodeBGR(
@ -189,7 +157,6 @@ def WebPEncodeBGR(rgb, width, height, stride, quality_factor):
    return None
  return webp[0]

-
 def WebPEncodeBGRA(rgb, width, height, stride, quality_factor):
  """WebPEncodeBGRA(uint8_t rgb, int width, int height, int stride, float quality_factor) -> lossy_webp"""
  webp = wrap_WebPEncodeBGRA(
@ -198,7 +165,6 @@ def WebPEncodeBGRA(rgb, width, height, stride, quality_factor):
    return None
  return webp[0]

-
 def WebPEncodeLosslessRGB(rgb, width, height, stride):
  """WebPEncodeLosslessRGB(uint8_t rgb, int width, int height, int stride) -> lossless_webp"""
  webp = wrap_WebPEncodeLosslessRGB(rgb, _UNUSED, _UNUSED, width, height, stride)
@ -206,7 +172,6 @@ def WebPEncodeLosslessRGB(rgb, width, height, stride):
    return None
  return webp[0]

-
 def WebPEncodeLosslessRGBA(rgb, width, height, stride):
  """WebPEncodeLosslessRGBA(uint8_t rgb, int width, int height, int stride) -> lossless_webp"""
  webp = wrap_WebPEncodeLosslessRGBA(rgb, _UNUSED, _UNUSED, width, height, stride)
@ -214,7 +179,6 @@ def WebPEncodeLosslessRGBA(rgb, width, height, stride):
    return None
  return webp[0]

-
 def WebPEncodeLosslessBGR(rgb, width, height, stride):
  """WebPEncodeLosslessBGR(uint8_t rgb, int width, int height, int stride) -> lossless_webp"""
  webp = wrap_WebPEncodeLosslessBGR(rgb, _UNUSED, _UNUSED, width, height, stride)
@ -222,7 +186,6 @@ def WebPEncodeLosslessBGR(rgb, width, height, stride):
    return None
  return webp[0]

-
 def WebPEncodeLosslessBGRA(rgb, width, height, stride):
  """WebPEncodeLosslessBGRA(uint8_t rgb, int width, int height, int stride) -> lossless_webp"""
  webp = wrap_WebPEncodeLosslessBGRA(rgb, _UNUSED, _UNUSED, width, height, stride)
--- a/swig/libwebp.swig
+++ b/swig/libwebp.swig
@ -32,9 +32,6 @@

 #ifdef SWIGPYTHON
 %module(package="com.google.webp") libwebp
-%begin %{
-#define SWIG_PYTHON_STRICT_BYTE_CHAR
-%}
 #else
 %module libwebp
 #endif  /* SWIGPYTHON */
--- a/swig/libwebp_python_wrap.c
+++ b/swig/libwebp_python_wrap.c
Author	SHA1	Message	Date
James Zern	7b75522d5e	GetBackwardReferences: fail on alloc error previously failures in the call to VP8LBackwardReferencesTraceBackwards() would be ignored which, though it wouldn't result in a crash, would produce non-deterministic output Change-Id: Id9890a60883c3270ec75e968506d46eea32b76d4 (cherry picked from commit `e3cfafaf71`) (cherry picked from commit `20ef03ee35`) (cherry picked from commit `89e226a3c7`)	2022-04-06 21:56:38 -07:00
James Zern	3180b6f4b7	BackwardReferencesHashChainDistanceOnly: fix segfault on OOM change CostManager to calloc to avoid frees on undefined pointer values in CostManagerClear() should the cost_model allocation succeed, but the cost_manager allocation fail since: v0.5.0-93-g3e023c17 Speed-up BackwardReferencesHashChainDistanceOnly. Tested: for i in `seq 1 639`; do export MALLOC_FAIL_AT=$i ./examples/cwebp -m 6 -q 100 -lossless jpeg_file done Bug: webp:565 Change-Id: I376d81e6f41eb73529053e9e30c142b4b4f6b45b (cherry picked from commit `a828a59b49`) (cherry picked from commit `dd80bb4343`) (cherry picked from commit `4d0964cd0c`)	2022-04-06 21:56:38 -07:00
James Zern	16f36e4e39	VP8LEncodeStream: fix segfault on OOM initialize bw_side before calling EncoderAnalyze() & EncoderInit() which may fail; previously this would cause a free of an invalid pointer in VP8LBitWriterWipeOut(). since at least: v0.6.0-120-gf8c2ac15 Multi-thread the lossless cruncher. Tested: for i in `seq 1 639`; do export MALLOC_FAIL_AT=$i ./examples/cwebp -m 6 -q 100 -lossless jpeg_file done Bug: webp:565 Change-Id: I1c95883834b6e4b13aee890568ce3bad0f4266f0 (cherry picked from commit `fe153fae98`) (cherry picked from commit `ddd65f0d19`) (cherry picked from commit `5d805f7205`)	2022-04-06 21:56:38 -07:00
James Zern	df9e129b0d	alpha_processing_neon.c: fix 0x01... typo one instance was overlong leading to a int64->uint32 conversion warning Change-Id: I56d5ab75d89960c79293f62cd489d7ab519bbc34 (cherry picked from commit `03d1219055`)	2022-03-08 19:37:29 +00:00
James Zern	28b53efd6f	alpha_processing_neon.c: fix Dispatch/ExtractAlpha_NEON the trailing width % 8 bytes would clear the upper bytes of alpha_mask as they're done one at a time since: `49d0280d` NEON: implement several alpha-processing functions Change-Id: Iff76c0af3094597285a6aa6ed032b345f9856aae (cherry picked from commit `924e7ca654`)	2022-03-03 18:06:50 +00:00
Vincent Rabaud	81efa2a3f1	Fix lossless encoding for MIPS. Bug: webp:558 Change-Id: I3d3ddb64ed26a8d8ff5664664c5f20f6eadfeb4f (cherry picked from commit `e4cbcdd2b5`)	2022-03-02 02:56:38 +00:00
Pascal Massimino	d8481223b3	Rescaler: fix rounding error We saturate the result to [0..255] It's the easiest and safest, given the wide variety of scaling range we cover: we're not using floats, so precision is always an issue at one end or the other of the scaling spectrum. we also use: round(a - floor(b)) instead of: floor(a - round(b)) to handle difficult cases (ratio ~= .99, e.g.) MIPS code is still disabled (and wrong) Change-Id: I18d3f5ddc4c524879c257b928329b1c648fa7fb5 (cherry picked from commit `ab2dc8939f`)	2019-04-01 16:22:10 -07:00
James Zern	4fdc903597	HistogramCombineStochastic: fix free of uninit value previously if the mappings allocation failed histo_queue->queue would be uninitialized; split the conditionals Change-Id: I1b50b987e734393893dc8a83a3f314522ccd0c83 (cherry picked from commit `aa65f89a8f`)	2019-03-30 00:06:25 -07:00
James Zern	fa58371c6a	unicode,INIT_WARGV: add missing cast CommandLineToArgvW() returns a LPWSTR, storing to const LPWSTR is incorrect without a cast; fixes gcc -Wincompatible-pointer-types and clang(-cl) -Wincompatible-pointer-types-discads-qualifiers warnings Change-Id: Iad5b49c4862c7be68251272e50d3c751099559bc (cherry picked from commit `2b7214ab99`)	2019-01-25 01:33:20 -08:00
Vincent Rabaud	84fdd0d12e	Remove BINARYEN_METHOD in wasm settings. This was removed according to https://kripken.github.io/emscripten-site/docs/compiling/WebAssembly.html#debugging BUG=webp:413 Change-Id: If8f1a3f1260d34cdd2b937b286e4c57fb48ed828 (cherry picked from commit `6bcf876980`)	2019-01-25 01:33:11 -08:00