Fix OOB write in BuildHuffmanTable.

First, BuildHuffmanTable is called to check if the data is valid. If it is and the table is not big enough, more memory is allocated. This will make sure that valid (but unoptimized because of unbalanced codes) streams are still decodable. Bug: chromium:1479274 Change-Id: I31c36dbf3aa78d35ecf38706b50464fd3d375741 (cherry picked from commit 902bc91903) (cherry picked from commit 2af26267cd)
EncodeAlphaInternal: clear result->bw on error
2025-07-15 13:29:54 +02:00 · 2023-09-07 15:40:16 -07:00 · 2023-02-28 00:26:34 +00:00 · 2022-04-06 21:55:27 -07:00 · 2022-04-06 21:50:21 -07:00 · 2022-04-06 21:50:21 -07:00
99 changed files with 1074 additions and 8637 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -1,6 +1,5 @@
 .gitattributes export-ignore
 .gitignore export-ignore
 .mailmap export-ignore
-*.bat text eol=crlf
 *.pdf -text -diff
 *.ppm -text -diff
--- a/.gitignore
+++ b/.gitignore
@ -1,7 +1,6 @@
 *.l[ao]
 *.[ao]
 *.pc
-.DS_Store
 .deps
 .libs
 /aclocal.m4
@ -34,8 +33,7 @@ src/webp/stamp-h1
 *.idb
 *.pdb
 /iosbuild
-/xcframeworkbuild
-/WebP*.*framework
+/WebP.framework
 CMakeCache.txt
 CMakeFiles/
 cmake_install.cmake
@ -44,11 +42,3 @@ cmake_install.cmake
 extras/get_disto
 extras/vwebp_sdl
 extras/webp_quality
-tests/fuzzer/advanced_api_fuzzer
-tests/fuzzer/animation_api_fuzzer
-tests/fuzzer/animdecoder_fuzzer
-tests/fuzzer/animencoder_fuzzer
-tests/fuzzer/demux_api_fuzzer
-tests/fuzzer/enc_dec_fuzzer
-tests/fuzzer/mux_demux_api_fuzzer
-tests/fuzzer/simple_api_fuzzer
--- a/2
+++ b/2
@ -6,7 +6,6 @@ Contributors:
 - Christian Duvivier (cduvivier at google dot com)
 - Djordje Pesut (djordje dot pesut at imgtec dot com)
 - Hui Su (huisu at google dot com)
- Ingvar Stepanyan (rreverser at google dot com)
 - James Zern (jzern at google dot com)
 - Jan Engelhardt (jengelh at medozas dot de)
 - Jehan (jehan at girinstud dot io)
@ -42,6 +41,5 @@ Contributors:
 - Vikas Arora (vikasa at google dot com)
 - Vincent Rabaud (vrabaud at google dot com)
 - Vlad Tsyrklevich (vtsyrklevich at chromium dot org)
- Wan-Teh Chang (wtc at google dot com)
 - Yang Zhang (yang dot zhang at arm dot com)
 - Yannis Guyon (yguyon at google dot com)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,24 +1,9 @@
-##
-##  Copyright (c) 2020 Google LLC.
-##
-##  Use of this source code is governed by a BSD-style license
-##  that can be found in the LICENSE file in the root of the source
-##  tree. An additional intellectual property rights grant can be found
-##  in the file PATENTS.  All contributing project authors may
-##  be found in the AUTHORS file in the root of the source tree.
-
 cmake_minimum_required(VERSION 3.5)

 project(WebP C)

 # Options for coder / decoder executables.
-if(NOT EMSCRIPTEN)
-  # Disable SIMD on Emscripten by default, as it's a new unstable Wasm feature.
-  # Users can still explicitly opt-in to make a SIMD-enabled build.
-  set(WEBP_ENABLE_SIMD_DEFAULT ON)
-endif()
-option(WEBP_ENABLE_SIMD "Enable any SIMD optimization."
-       ${WEBP_ENABLE_SIMD_DEFAULT})
+option(WEBP_ENABLE_SIMD "Enable any SIMD optimization." ON)
 option(WEBP_BUILD_ANIM_UTILS "Build animation utilities." ON)
 option(WEBP_BUILD_CWEBP "Build the cwebp command line tool." ON)
 option(WEBP_BUILD_DWEBP "Build the dwebp command line tool." ON)
@ -41,6 +26,7 @@ if(WIN32)
 endif()

 if(WEBP_BUILD_WEBP_JS)
+  set(WEBP_ENABLE_SIMD OFF)
  set(WEBP_BUILD_ANIM_UTILS OFF)
  set(WEBP_BUILD_CWEBP OFF)
  set(WEBP_BUILD_DWEBP OFF)
@ -50,10 +36,6 @@ if(WEBP_BUILD_WEBP_JS)
  set(WEBP_BUILD_WEBPINFO OFF)
  set(WEBP_BUILD_WEBPMUX OFF)
  set(WEBP_BUILD_EXTRAS OFF)
-
-  if(WEBP_ENABLE_SIMD)
-    message("wasm2js does not support SIMD, disabling webp.js generation.")
-  endif()
 endif()

 set(WEBP_DEP_LIBRARIES)
@ -61,7 +43,7 @@ set(WEBP_DEP_INCLUDE_DIRS)

 if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE "Release"
-      CACHE STRING "Build type: Release, Debug, MinSizeRel or RelWithDebInfo"
+      CACHE "Build type: Release, Debug, MinSizeRel or RelWithDebInfo" STRING
      FORCE)
 endif()

@ -182,29 +164,6 @@ add_definitions(-DHAVE_CONFIG_H)

 # ##############################################################################
 # Build the webpdecoder library.
-
-# Creates a source file with an unused stub function in $CMAKE_BINARY_DIR and
-# adds it to the specified target. Currently used only with Xcode.
-#
-# See also:
-# https://cmake.org/cmake/help/v3.18/command/add_library.html#object-libraries
-# "Some native build systems (such as Xcode) may not like targets that have
-# only object files, so consider adding at least one real source file to any
-# target that references $<TARGET_OBJECTS:objlib>."
-function(libwebp_add_stub_file TARGET)
-  set(stub_source_dir "${CMAKE_BINARY_DIR}")
-  set(stub_source_file
-      "${stub_source_dir}/libwebp_${TARGET}_stub.c")
-  set(stub_source_code
-      "// Generated file. DO NOT EDIT!\n"
-      "// C source file created for target ${TARGET}.\n"
-      "void libwebp_${TARGET}_stub_function(void)\;\n"
-      "void libwebp_${TARGET}_stub_function(void) {}\n")
-  file(WRITE "${stub_source_file}" ${stub_source_code})
-
-  target_sources(${TARGET} PRIVATE ${stub_source_file})
-endfunction()
-
 if(MSVC)
  # avoid security warnings for e.g., fopen() used in the examples.
  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
@ -231,9 +190,6 @@ add_library(webpdecoder
            $<TARGET_OBJECTS:webpdecode>
            $<TARGET_OBJECTS:webpdspdecode>
            $<TARGET_OBJECTS:webputilsdecode>)
-if(XCODE)
-  libwebp_add_stub_file(webpdecoder)
-endif()
 target_link_libraries(webpdecoder ${WEBP_DEP_LIBRARIES})
 target_include_directories(
  webpdecoder
@ -273,9 +229,6 @@ add_library(webp
            $<TARGET_OBJECTS:webpdsp>
            $<TARGET_OBJECTS:webpencode>
            $<TARGET_OBJECTS:webputils>)
-if(XCODE)
-  libwebp_add_stub_file(webp)
-endif()
 target_link_libraries(webp ${WEBP_DEP_LIBRARIES})
 target_include_directories(webp
                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
@ -595,21 +548,18 @@ if(WEBP_BUILD_EXTRAS)
 endif()

 if(WEBP_BUILD_WEBP_JS)
-  # wasm2js does not support SIMD.
-  if(NOT WEBP_ENABLE_SIMD)
-    # JavaScript version
-    add_executable(webp_js ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
-    target_link_libraries(webp_js webpdecoder SDL)
-    target_include_directories(webp_js PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-    set(WEBP_HAVE_SDL 1)
-    set_target_properties(
-      webp_js
-      PROPERTIES LINK_FLAGS "-s WASM=0 \
-         -s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0 \
-         -s EXTRA_EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
-    set_target_properties(webp_js PROPERTIES OUTPUT_NAME webp)
-    target_compile_definitions(webp_js PUBLIC EMSCRIPTEN WEBP_HAVE_SDL)
-  endif()
+  # JavaScript version
+  add_executable(webp_js ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
+  target_link_libraries(webp_js webpdecoder SDL)
+  target_include_directories(webp_js PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+  set(WEBP_HAVE_SDL 1)
+  set_target_properties(
+    webp_js
+    PROPERTIES LINK_FLAGS
+               "-s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0 \
+       -s EXTRA_EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
+  set_target_properties(webp_js PROPERTIES OUTPUT_NAME webp)
+  target_compile_definitions(webp_js PUBLIC EMSCRIPTEN WEBP_HAVE_SDL)

  # WASM version
  add_executable(webp_wasm ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
@ -660,6 +610,7 @@ if(WEBP_BUILD_ANIM_UTILS)
 endif()

 # Install the different headers and libraries.
+include(GNUInstallDirs)
 install(TARGETS ${INSTALLED_LIBRARIES}
        EXPORT ${PROJECT_NAME}Targets
        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/webp
--- a/78
+++ b/78
@ -1,82 +1,4 @@
-170a8712 Fix check_c_source_compiles with pthread.
-85995719 disable CombinedShannonEntropy_SSE2 on x86
-8af7436f Merge "{ios,xcframework}build.sh: make min version(s) more visible" into 1.2.0
-e56c3c5b pngdec: raise memory limit if needed
-13b8e9fe {ios,xcframework}build.sh: make min version(s) more visible
-a9225410 animdecoder_fuzzer: fix memory leak
-d6c2285d update gradle to 6.1.1
-52ce6333 update NEWS
-28c49820 bump version to 1.2.0
-7363dff2 webp/encode.h: restore WEBP_ENCODER_ABI_VERSION to v1.1.0
-826aafa5 update AUTHORS
-63258823 animdecoder_fuzzer: validate canvas size
-9eb26381 CMake: remove duplicate "include(GNUInstallDirs)"
-2e7bed79 WebPPicture: clarify the ownership of user-owned data.
-cccf5e33 webpmux: add an '-set loop <value>' option
-c9a3f6a1 Merge changes Ie29f9867,I289c54c4
-319f56f1 iosbuild.sh: sync some aspects of xcframeworkbuild.sh
-e8e8db98 add xcframeworkbuild.sh
-ae545534 dsp.h: allow config.h to override MSVC SIMD autodetection
-fef789f3 Merge "cmake: fix per-file assembly flags"
-fc14fc03 Have C encoding predictors use decoding predictors.
-7656f0b3 README,cosmetics: fix a couple typos
-d2e245ea cmake: disable webp.js if WEBP_ENABLE_SIMD=1
-96099a79 cmake: fix per-file assembly flags
-5abb5582 Merge "cmake: fix compilation w/Xcode generator"
-8484a120 cmake: fix compilation w/Xcode generator
-d7bf01c9 Merge changes Ifcae0f38,Iee2d7401
-36c81ff6 WASM-SIMD: port 2 patches from rreverser@'s tree
-988b02ab Merge "Couple of fixes to allow SIMD on Emscripten"
-26faf770 wicdec: fail with animated images
-ab2d08a8 [cd]webp: document lack of animated webp support
-52273943 Couple of fixes to allow SIMD on Emscripten
-8870ba7f Fix skia bug #10952
-4b3c6953 Detect if StoreFrame read more than anmf_payload_size bytes
-17fd4ba8 webp/decode.h,cosmetics: normalize 'flip' comment
-411d3677 remove some unreachable break statements
-3700ffd7 WebPPictureHasTransparency: remove unreachable return
-83604bf3 {animencoder,enc_dec}_fuzzer: convert some abort()s to returns
-eb44119c Merge changes I8ae09473,I678c8b1e
-9f6055fc fuzz_utils.h: rename max() to Max()
-695788e7 fuzz_utils.h: make functions WEBP_INLINE
-906c1fcd make ImgIoUtilReadFile use WebPMalloc instead of malloc
-8cb7e536 rename demux_api_fuzzer.c -> mux_demux_api_fuzzer.c
-443db47d add animdecoder_fuzzer.cc
-36a6eea3 Merge "import fuzzers from oss-fuzz/chromium"
-ec5f12c1 Makefile.vc: remove deprecated /Gm option
-64425a08 picture_tools_enc: fix windows build warning
-bd94090a import fuzzers from oss-fuzz/chromium
-cf847cba use WEBP_DSP_INIT_FUNC for Init{GammaTables*,GetCoeffs}
-55a080e5 Add WebPReplaceTransparentPixels() in dsp
-84739717 GetBackgroundColorGIF: promote to uint32_t before << 24
-def64e92 cwebp: Fix -print_psnr for near_lossless
-cf2f88b3 Add palette and spatial for q >= 75 and -m 5
-f0110bae Add no-color cache configuration to the cruncher
-749a8b99 Better estimate of the cache cost.
-4f9f00cc Use spatial predictors on top of palette no matter what.
-7658c686 Add spatial prediction on top of palette in cruncher.
-133ff0e3 webp_js: force WASM=0 option explicitly
-e3c259a2 Fix integer overflow in EmitFancyRGB.
-b3ff0bde man/{gif2,img2}webp,webpmux: normalize some wording
-f9b30586 fix ABI breakage introduced by 6a0ff358
-1d58dcfc README.webp_js: update note about emscripten version
-44070266 README.webp_js: s/fastcomp/upstream/
-2565fa8f README.webp_js: update cmake command
-47309ef5 webp: WEBP_OFFSET_PTR()
-687ab00e DC{4,8,16}_NEON: replace vmovl w/vaddl
-1b92fe75 DC16_NEON,aarch64: use vaddlv
-53f3d8cf dec_neon,DC8_NEON: use vaddlv instead of movl+vaddv
-27d08240 Fix integer overflow in WebPAnimDecoderGetNext()
-69776e38 Merge "remove call to MBAnalyzeBestIntra4Mode for method >= 5"
-a99078c1 remove call to MBAnalyzeBestIntra4Mode for method >= 5
-22e404cc CMakeLists.txt: fix set(CACHE) argument order
-71690b52 fix MSVC warning
-6a0ff358 Enc: add a qmin / qmax range for quality factor
-0fa56f30 Merge tag 'v1.1.0'
-6cf504d0 PNM decoding: handle max_value != 255
-d7844e97 update ChangeLog (tag: v1.1.0-rc2, tag: v1.1.0, origin/1.1.0)
 7f006436 Makefile.vc: fix webp_quality.exe link
-cf047e83 Makefile.vc: fix webp_quality.exe link
 c074c653 update NEWS
 30f09551 bump version to 1.1.0
 a76694a1 update AUTHORS
--- a/Makefile.vc
+++ b/Makefile.vc
@ -28,7 +28,7 @@ PLATFORM_LDFLAGS = /SAFESEH

 NOLOGO     = /nologo
 CCNODBG    = cl.exe $(NOLOGO) /O2 /DNDEBUG
-CCDEBUG    = cl.exe $(NOLOGO) /Od /Zi /D_DEBUG /RTC1
+CCDEBUG    = cl.exe $(NOLOGO) /Od /Gm /Zi /D_DEBUG /RTC1
 CFLAGS     = /I. /Isrc $(NOLOGO) /W3 /EHsc /c
 CFLAGS     = $(CFLAGS) /DWIN32 /D_CRT_SECURE_NO_WARNINGS /DWIN32_LEAN_AND_MEAN
 LDFLAGS    = /LARGEADDRESSAWARE /MANIFEST /NXCOMPAT /DYNAMICBASE
--- a/12
+++ b/12
@ -1,15 +1,3 @@
- 12/23/2020: version 1.2.0
-  * API changes:
-    - libwebp:
-      encode.h: add a qmin / qmax range for quality factor (cwebp adds -qrange)
-  * lossless encoder improvements
-  * SIMD support for Wasm builds
-  * add xcframeworkbuild.sh, supports Mac Catalyst builds
-  * import fuzzers from oss-fuzz & chromium (#409)
-  * webpmux: add an '-set loop <value>' option (#494)
-  * toolchain updates and bug fixes (#449, #463, #470, #475, #477, #478, #479,
-    #488, #491)
-
 - 12/18/2019: version 1.1.0
  * API changes:
    - libwebp:
--- a/14
+++ b/14
@ -4,7 +4,7 @@
          \__\__/\____/\_____/__/ ____  ___
                / _/ /    \    \ /  _ \/ _/
               /  \_/   / /   \ \   __/  \__
-               \____/____/\_____/_____/____/v1.2.0
+               \____/____/\_____/_____/____/v1.1.0

 Description:
 ============
@ -113,7 +113,7 @@ make install

 CMake:
 ------
-With CMake, you can compile libwebp, cwebp, dwebp, gif2webp, img2webp, webpinfo
+With CMake, you can compile libwebp, cwebp, dwebp, gif2web, img2webp, webpinfo
 and the JS bindings.

 Prerequisites:
@ -225,7 +225,6 @@ Usage:

 If input size (-s) for an image is not specified, it is
 assumed to be a PNG, JPEG, TIFF or WebP file.
-Note: Animated PNG and WebP files are not supported.

 Options:
  -h / -help ............. short help
@ -255,8 +254,6 @@ Options:
  -partition_limit <int> . limit quality to fit the 512k limit on
                           the first partition (0=no degradation ... 100=full)
  -pass <int> ............ analysis pass number (1..10)
-  -qrange <min> <max> .... specifies the permissible quality range
-                           (default: 0 100)
  -crop <x> <y> <w> <h> .. crop picture with the given rectangle
  -resize <w> <h> ........ resize picture (after any cropping)
  -mt .................... use multi-threading if available
@ -297,7 +294,6 @@ Experimental Options:
  -af .................... auto-adjust filter strength
  -pre <int> ............. pre-processing filter

-
 The main options you might want to try in order to further tune the
 visual quality are:
 -preset
@ -345,9 +341,7 @@ The full list of options is available using -h:
 > dwebp -h
 Usage: dwebp in_file [options] [-o out_file]

-Decodes the WebP image file to PNG format [Default].
-Note: Animated WebP files are not supported.
-
+Decodes the WebP image file to PNG format [Default]
 Use following options to convert into alternate image formats:
  -pam ......... save the raw RGBA samples as a color PAM
  -ppm ......... save the raw RGB samples as a color PPM
@ -429,7 +423,7 @@ Prerequisites:
 1) OpenGL & OpenGL Utility Toolkit (GLUT)
  Linux:
    $ sudo apt-get install freeglut3-dev mesa-common-dev
-  Mac + Xcode:
+  Mac + XCode:
    - These libraries should be available in the OpenGL / GLUT frameworks.
  Windows:
    http://freeglut.sourceforge.net/index.php#download
--- a/README.mux
+++ b/README.mux
@ -1,7 +1,7 @@
          __   __  ____  ____  ____  __ __  _     __ __
         /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
         \       /   __/  _  \   __/      /  /  (_/  /__
-          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.2.0
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.1.0


 Description:
@ -44,7 +44,6 @@ GET_OPTIONS:

 SET_OPTIONS:
 Set color profile/metadata:
-   loop LOOP_COUNT   set the loop count
   icc  file.icc     set ICC profile
   exif file.exif    set EXIF metadata
   xmp  file.xmp     set XMP metadata
--- a/README.webp_js
+++ b/README.webp_js
@ -19,20 +19,21 @@ using Emscripten and CMake.
   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/upstream/emscripten
-   windows: set EMSCRIPTEN=%EMSDK%\upstream\emscripten
+   unix-like environments: export EMSCRIPTEN=$EMSDK/fastcomp/emscripten
+   windows: set EMSCRIPTEN=%EMSDK%\fastcomp\emscripten

 - configure the project 'WEBP_JS' with CMake using:

 cd webp_js && \
 cmake -DWEBP_BUILD_WEBP_JS=ON \
+       -DEMSCRIPTEN_GENERATE_BITCODE_STATIC_LIBRARIES=1 \
       -DCMAKE_TOOLCHAIN_FILE=$EMSCRIPTEN/cmake/Modules/Platform/Emscripten.cmake \
       ../

 - compile webp.js using 'make'.

 - that's it! Upon completion, you should have the webp.js and
-   webp.wasm files generated.
+   webp.js.mem files generated.

 The callable JavaScript function is WebPToSDL(), which decodes a raw WebP
 bitstream into a canvas. See webp_js/index.html for a simple usage sample
@ -58,9 +59,8 @@ Web-Assembly (WASM) version:
  See webp_js/index_wasm.html for a simple demo page using the WASM version
  of the library.

-  You will need a fairly recent version of Emscripten (at least 1.37.8,
-  latest-upstream is recommended) and of your WASM-enabled browser to run this
-  version.
+  You will need a fairly recent version of Emscripten (at least 1.37.8) and of
+  your WASM-enabled browser to run this version. Consider it very experimental!

 Caveat:
 =======
@ -78,6 +78,3 @@ Caveat:
    https://github.com/kripken/emscripten/issues/3788

    Therefore, SSE2 optimization is currently disabled in CMakeLists.txt.
-
-  - If WEBP_ENABLE_SIMD is set to 1 the JavaScript version (webp.js) will be
-    disabled as wasm2js does not support SIMD.
--- a/build.gradle
+++ b/build.gradle
@ -432,3 +432,8 @@ model {
    }
  }
 }
+
+// Task to generate the wrapper.
+task wrapper(type: Wrapper) {
+  gradleVersion = '2.13'
+}
--- a/cmake/config.h.in
+++ b/cmake/config.h.in
@ -93,6 +93,10 @@
 /* Define to the version of this package. */
 #cmakedefine PACKAGE_VERSION "@PACKAGE_VERSION@"

+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+#cmakedefine PTHREAD_CREATE_JOINABLE 1
+
 /* Define to 1 if you have the ANSI C header files. */
 #cmakedefine STDC_HEADERS 1

--- a/cmake/cpu.cmake
+++ b/cmake/cpu.cmake
@ -31,17 +31,9 @@ endfunction()
 set(WEBP_SIMD_FLAGS "SSE41;SSE2;MIPS32;MIPS_DSP_R2;NEON;MSA")
 set(WEBP_SIMD_FILE_EXTENSIONS
    "_sse41.c;_sse2.c;_mips32.c;_mips_dsp_r2.c;_neon.c;_msa.c")
-if(MSVC AND CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-  # With at least Visual Studio 12 (2013)+ /arch is not necessary to build SSE2
-  # or SSE4 code unless a lesser /arch is forced. MSVC does not have a SSE4
-  # flag, but an AVX one. Using that with SSE4 code risks generating illegal
-  # instructions when used on machines with SSE4 only. The flags are left for
-  # older (untested) versions to avoid any potential compatibility issues.
-  if(MSVC_VERSION GREATER_EQUAL 1800 AND NOT CMAKE_C_FLAGS MATCHES "/arch:")
-    set(SIMD_ENABLE_FLAGS)
-  else()
-    set(SIMD_ENABLE_FLAGS "/arch:AVX;/arch:SSE2;;;;")
-  endif()
+if(MSVC)
+  # MSVC does not have a SSE4 flag but AVX support implies SSE4 support.
+  set(SIMD_ENABLE_FLAGS "/arch:AVX;/arch:SSE2;;;;")
  set(SIMD_DISABLE_FLAGS)
 else()
  set(SIMD_ENABLE_FLAGS
@ -65,14 +57,9 @@ endif()

 list(LENGTH WEBP_SIMD_FLAGS WEBP_SIMD_FLAGS_LENGTH)
 math(EXPR WEBP_SIMD_FLAGS_RANGE "${WEBP_SIMD_FLAGS_LENGTH} - 1")
+unset(HIGHEST_SSE_FLAG)

 foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
-  # With Emscripten 2.0.9 -msimd128 -mfpu=neon will enable NEON, but the
-  # source will fail to compile.
-  if(EMSCRIPTEN AND ${I_SIMD} GREATER_EQUAL 2)
-    break()
-  endif()
-
  list(GET WEBP_SIMD_FLAGS ${I_SIMD} WEBP_SIMD_FLAG)

  # First try with no extra flag added as the compiler might have default flags
@ -83,15 +70,10 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
  webp_check_compiler_flag(${WEBP_SIMD_FLAG} ${WEBP_ENABLE_SIMD})
  if(NOT WEBP_HAVE_${WEBP_SIMD_FLAG})
    list(GET SIMD_ENABLE_FLAGS ${I_SIMD} SIMD_COMPILE_FLAG)
-    if(EMSCRIPTEN)
-      set(SIMD_COMPILE_FLAG "-msimd128 ${SIMD_COMPILE_FLAG}")
-    endif()
    set(CMAKE_REQUIRED_FLAGS ${SIMD_COMPILE_FLAG})
    webp_check_compiler_flag(${WEBP_SIMD_FLAG} ${WEBP_ENABLE_SIMD})
  else()
-    if(MSVC AND SIMD_ENABLE_FLAGS)
-      # The detection for SSE2/SSE4 support under MSVC is based on the compiler
-      # version so e.g., clang-cl will require flags to enable the assembly.
+    if(MSVC)
      list(GET SIMD_ENABLE_FLAGS ${I_SIMD} SIMD_COMPILE_FLAG)
    else()
      set(SIMD_COMPILE_FLAG " ")
@ -102,10 +84,17 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
  file(GLOB SIMD_FILES "${CMAKE_CURRENT_LIST_DIR}/../"
            "src/dsp/*${WEBP_SIMD_FILE_EXTENSION}")
  if(WEBP_HAVE_${WEBP_SIMD_FLAG})
+    if(${I_SIMD} LESS 2 AND NOT HIGHEST_SSE_FLAG)
+      set(HIGHEST_SSE_FLAG ${SIMD_COMPILE_FLAG})
+    endif()
    # Memorize the file and flags.
    foreach(FILE ${SIMD_FILES})
      list(APPEND WEBP_SIMD_FILES_TO_INCLUDE ${FILE})
-      list(APPEND WEBP_SIMD_FLAGS_TO_INCLUDE ${SIMD_COMPILE_FLAG})
+      if(${I_SIMD} LESS 2)
+        list(APPEND WEBP_SIMD_FLAGS_TO_INCLUDE ${HIGHEST_SSE_FLAG})
+      else()
+        list(APPEND WEBP_SIMD_FLAGS_TO_INCLUDE ${SIMD_COMPILE_FLAG})
+      endif()
    endforeach()
  else()
    # Remove the file from the list.
--- a/cmake/deps.cmake
+++ b/cmake/deps.cmake
@ -22,23 +22,20 @@ check_c_source_compiles("
  " HAVE_BUILTIN_BSWAP64)

 # Check for libraries.
-if(NOT WEBP_BUILD_WEBP_JS)
-  # Disable pThreads for WASM.
-  find_package(Threads)
-endif()
+find_package(Threads)
 if(Threads_FOUND)
-  # work around cmake bug on QNX (https://cmake.org/Bug/view.php?id=11333)
-  if(CMAKE_USE_PTHREADS_INIT AND NOT CMAKE_SYSTEM_NAME STREQUAL "QNX")
+  if(CMAKE_USE_PTHREADS_INIT)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread")
  endif()
-  check_c_source_compiles("
-      #include <pthread.h>
-      int main (void) {
-        int attr = PTHREAD_PRIO_INHERIT;
-        return attr;
-      }
-    " FLAG_HAVE_PTHREAD_PRIO_INHERIT)
-  set(HAVE_PTHREAD_PRIO_INHERIT ${FLAG_HAVE_PTHREAD_PRIO_INHERIT})
+  foreach(PTHREAD_TEST HAVE_PTHREAD_PRIO_INHERIT PTHREAD_CREATE_UNDETACHED)
+    check_c_source_compiles("
+        #include <pthread.h>
+        int main (void) {
+          int attr = ${PTHREAD_TEST};
+          return attr;
+        }
+      " ${PTHREAD_TEST})
+  endforeach()
  list(APPEND WEBP_DEP_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
 endif()
 set(WEBP_USE_THREAD ${Threads_FOUND})
--- a/configure.ac
+++ b/configure.ac
@ -1,4 +1,4 @@
-AC_INIT([libwebp], [1.2.0],
+AC_INIT([libwebp], [1.1.0],
        [https://bugs.chromium.org/p/webp],,
        [http://developers.google.com/speed/webp])
 AC_CANONICAL_HOST
@ -80,7 +80,6 @@ TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wparentheses-equality])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wshadow])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wshorten-64-to-32])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wundef])
-TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunreachable-code-aggressive])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunreachable-code])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused-but-set-variable])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused])
--- a/examples/anim_util.c
+++ b/examples/anim_util.c
@ -405,7 +405,7 @@ static uint32_t GetBackgroundColorGIF(GifFileType* gif) {
    return 0xffffffff;  // Invalid: assume white.
  } else {
    const GifColorType color = color_map->Colors[gif->SBackGroundColor];
-    return (0xffu << 24) |
+    return (0xff << 24) |
           (color.Red << 16) |
           (color.Green << 8) |
           (color.Blue << 0);
--- a/examples/cwebp.c
+++ b/examples/cwebp.c
@ -12,7 +12,6 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)

-#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@ -24,7 +23,6 @@
 #include "../examples/example_util.h"
 #include "../imageio/image_dec.h"
 #include "../imageio/imageio_util.h"
-#include "../imageio/webpdec.h"
 #include "./stopwatch.h"
 #include "./unicode.h"
 #include "webp/encode.h"
@ -94,7 +92,7 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
    WFPRINTF(stderr, "Error! Could not process file %s\n",
             (const W_CHAR*)filename);
  }
-  WebPFree((void*)data);
+  free((void*)data);
  return ok;
 }

@ -121,7 +119,7 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
    WFPRINTF(stderr, "Error! Could not process file %s\n",
             (const W_CHAR*)filename);
  }
-  WebPFree((void*)data);
+  free((void*)data);
  return ok;
 }

@ -150,7 +148,7 @@ static void PrintPercents(const int counts[4]) {
  int s;
  const int total = counts[0] + counts[1] + counts[2] + counts[3];
  for (s = 0; s < 4; ++s) {
-    fprintf(stderr, "|     %3d%%", (int)(100. * counts[s] / total + .5));
+    fprintf(stderr, "|      %2d%%", (int)(100. * counts[s] / total + .5));
  }
  fprintf(stderr, "| %7d\n", total);
 }
@ -527,7 +525,6 @@ static void HelpLong(void) {
  printf(" cwebp [-preset <...>] [options] in_file [-o out_file]\n\n");
  printf("If input size (-s) for an image is not specified, it is\n"
         "assumed to be a PNG, JPEG, TIFF or WebP file.\n");
-  printf("Note: Animated PNG and WebP files are not supported.\n");
 #ifdef HAVE_WINCODEC_H
  printf("Windows builds can take as input any of the files handled by WIC.\n");
 #endif
@ -568,8 +565,6 @@ static void HelpLong(void) {
  printf("                           "
         "the first partition (0=no degradation ... 100=full)\n");
  printf("  -pass <int> ............ analysis pass number (1..10)\n");
-  printf("  -qrange <min> <max> .... specifies the permissible quality range\n"
-         "                           (default: 0 100)\n");
  printf("  -crop <x> <y> <w> <h> .. crop picture with the given rectangle\n");
  printf("  -resize <w> <h> ........ resize picture (after any cropping)\n");
  printf("  -mt .................... use multi-threading if available\n");
@ -669,7 +664,6 @@ int main(int argc, const char* argv[]) {
  WebPConfig config;
  WebPAuxStats stats;
  WebPMemoryWriter memory_writer;
-  int use_memory_writer;
  Metadata metadata;
  Stopwatch stop_watch;

@ -697,9 +691,9 @@ int main(int argc, const char* argv[]) {
    } else if (!strcmp(argv[c], "-H") || !strcmp(argv[c], "-longhelp")) {
      HelpLong();
      FREE_WARGV_AND_RETURN(0);
-    } else if (!strcmp(argv[c], "-o") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
      out_file = (const char*)GET_WARGV(argv, ++c);
-    } else if (!strcmp(argv[c], "-d") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-d") && c < argc - 1) {
      dump_file = (const char*)GET_WARGV(argv, ++c);
      config.show_compressed = 1;
    } else if (!strcmp(argv[c], "-print_psnr")) {
@ -713,7 +707,7 @@ int main(int argc, const char* argv[]) {
      print_distortion = 2;
    } else if (!strcmp(argv[c], "-short")) {
      ++short_output;
-    } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
+    } else if (!strcmp(argv[c], "-s") && c < argc - 2) {
      picture.width = ExUtilGetInt(argv[++c], 0, &parse_error);
      picture.height = ExUtilGetInt(argv[++c], 0, &parse_error);
      if (picture.width > WEBP_MAX_DIMENSION || picture.width < 0 ||
@ -723,30 +717,30 @@ int main(int argc, const char* argv[]) {
                picture.width, picture.height);
        goto Error;
      }
-    } else if (!strcmp(argv[c], "-m") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-m") && c < argc - 1) {
      config.method = ExUtilGetInt(argv[++c], 0, &parse_error);
      use_lossless_preset = 0;   // disable -z option
-    } else if (!strcmp(argv[c], "-q") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-q") && c < argc - 1) {
      config.quality = ExUtilGetFloat(argv[++c], &parse_error);
      use_lossless_preset = 0;   // disable -z option
-    } else if (!strcmp(argv[c], "-z") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-z") && c < argc - 1) {
      lossless_preset = ExUtilGetInt(argv[++c], 0, &parse_error);
      if (use_lossless_preset != 0) use_lossless_preset = 1;
-    } else if (!strcmp(argv[c], "-alpha_q") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-alpha_q") && c < argc - 1) {
      config.alpha_quality = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-alpha_method") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-alpha_method") && c < argc - 1) {
      config.alpha_compression = ExUtilGetInt(argv[++c], 0, &parse_error);
    } else if (!strcmp(argv[c], "-alpha_cleanup")) {
      // This flag is obsolete, does opposite of -exact.
      config.exact = 0;
    } else if (!strcmp(argv[c], "-exact")) {
      config.exact = 1;
-    } else if (!strcmp(argv[c], "-blend_alpha") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-blend_alpha") && c < argc - 1) {
      blend_alpha = 1;
      // background color is given in hex with an optional '0x' prefix
      background_color = ExUtilGetInt(argv[++c], 16, &parse_error);
      background_color = background_color & 0x00ffffffu;
-    } else if (!strcmp(argv[c], "-alpha_filter") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-alpha_filter") && c < argc - 1) {
      ++c;
      if (!strcmp(argv[c], "none")) {
        config.alpha_filtering = 0;
@ -762,10 +756,10 @@ int main(int argc, const char* argv[]) {
      keep_alpha = 0;
    } else if (!strcmp(argv[c], "-lossless")) {
      config.lossless = 1;
-    } else if (!strcmp(argv[c], "-near_lossless") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-near_lossless") && c < argc - 1) {
      config.near_lossless = ExUtilGetInt(argv[++c], 0, &parse_error);
      config.lossless = 1;  // use near-lossless only with lossless
-    } else if (!strcmp(argv[c], "-hint") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-hint") && c < argc - 1) {
      ++c;
      if (!strcmp(argv[c], "photo")) {
        config.image_hint = WEBP_HINT_PHOTO;
@ -777,13 +771,13 @@ int main(int argc, const char* argv[]) {
        fprintf(stderr, "Error! Unrecognized image hint: %s\n", argv[c]);
        goto Error;
      }
-    } else if (!strcmp(argv[c], "-size") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-size") && c < argc - 1) {
      config.target_size = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-psnr") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-psnr") && c < argc - 1) {
      config.target_PSNR = ExUtilGetFloat(argv[++c], &parse_error);
-    } else if (!strcmp(argv[c], "-sns") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-sns") && c < argc - 1) {
      config.sns_strength = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-f") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-f") && c < argc - 1) {
      config.filter_strength = ExUtilGetInt(argv[++c], 0, &parse_error);
    } else if (!strcmp(argv[c], "-af")) {
      config.autofilter = 1;
@ -797,32 +791,27 @@ int main(int argc, const char* argv[]) {
      config.filter_type = 1;
    } else if (!strcmp(argv[c], "-nostrong")) {
      config.filter_type = 0;
-    } else if (!strcmp(argv[c], "-sharpness") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-sharpness") && c < argc - 1) {
      config.filter_sharpness = ExUtilGetInt(argv[++c], 0, &parse_error);
    } else if (!strcmp(argv[c], "-sharp_yuv")) {
      config.use_sharp_yuv = 1;
-    } else if (!strcmp(argv[c], "-pass") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-pass") && c < argc - 1) {
      config.pass = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-qrange") && c + 2 < argc) {
-      config.qmin = ExUtilGetInt(argv[++c], 0, &parse_error);
-      config.qmax = ExUtilGetInt(argv[++c], 0, &parse_error);
-      if (config.qmin < 0) config.qmin = 0;
-      if (config.qmax > 100) config.qmax = 100;
-    } else if (!strcmp(argv[c], "-pre") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-pre") && c < argc - 1) {
      config.preprocessing = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-segments") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-segments") && c < argc - 1) {
      config.segments = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-partition_limit") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-partition_limit") && c < argc - 1) {
      config.partition_limit = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-map") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-map") && c < argc - 1) {
      picture.extra_info_type = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-crop") && c + 4 < argc) {
+    } else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
      crop = 1;
      crop_x = ExUtilGetInt(argv[++c], 0, &parse_error);
      crop_y = ExUtilGetInt(argv[++c], 0, &parse_error);
      crop_w = ExUtilGetInt(argv[++c], 0, &parse_error);
      crop_h = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-resize") && c + 2 < argc) {
+    } else if (!strcmp(argv[c], "-resize") && c < argc - 2) {
      resize_w = ExUtilGetInt(argv[++c], 0, &parse_error);
      resize_h = ExUtilGetInt(argv[++c], 0, &parse_error);
 #ifndef WEBP_DLL
@ -838,7 +827,7 @@ int main(int argc, const char* argv[]) {
      show_progress = 1;
    } else if (!strcmp(argv[c], "-quiet")) {
      quiet = 1;
-    } else if (!strcmp(argv[c], "-preset") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-preset") && c < argc - 1) {
      WebPPreset preset;
      ++c;
      if (!strcmp(argv[c], "default")) {
@ -861,7 +850,7 @@ int main(int argc, const char* argv[]) {
        fprintf(stderr, "Error! Could initialize configuration with preset.\n");
        goto Error;
      }
-    } else if (!strcmp(argv[c], "-metadata") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-metadata") && c < argc - 1) {
      static const struct {
        const char* option;
        int flag;
@ -909,7 +898,7 @@ int main(int argc, const char* argv[]) {
    } else if (!strcmp(argv[c], "-v")) {
      verbose = 1;
    } else if (!strcmp(argv[c], "--")) {
-      if (c + 1 < argc) in_file = (const char*)GET_WARGV(argv, ++c);
+      if (c < argc - 1) in_file = (const char*)GET_WARGV(argv, ++c);
      break;
    } else if (argv[c][0] == '-') {
      fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
@ -985,14 +974,6 @@ int main(int argc, const char* argv[]) {
    const double read_time = StopwatchReadAndReset(&stop_watch);
    fprintf(stderr, "Time to read input: %.3fs\n", read_time);
  }
-  // The bitstream should be kept in memory when metadata must be appended
-  // before writing it to a file/stream, and/or when the near-losslessly encoded
-  // bitstream must be decoded for distortion computation (lossy will modify the
-  // 'picture' but not the lossless pipeline).
-  // Otherwise directly write the bitstream to a file.
-  use_memory_writer = (out_file != NULL && keep_metadata) ||
-                      (!quiet && print_distortion >= 0 && config.lossless &&
-                       config.near_lossless < 100);

  // Open the output
  if (out_file != NULL) {
@ -1007,19 +988,15 @@ int main(int argc, const char* argv[]) {
        WFPRINTF(stderr, "Saving file '%s'\n", (const W_CHAR*)out_file);
      }
    }
-    if (use_memory_writer) {
-      picture.writer = WebPMemoryWrite;
-      picture.custom_ptr = (void*)&memory_writer;
-    } else {
+    if (keep_metadata == 0) {
      picture.writer = MyWriter;
      picture.custom_ptr = (void*)out;
+    } else {
+      picture.writer = WebPMemoryWrite;
+      picture.custom_ptr = (void*)&memory_writer;
    }
  } else {
    out = NULL;
-    if (use_memory_writer) {
-      picture.writer = WebPMemoryWrite;
-      picture.custom_ptr = (void*)&memory_writer;
-    }
    if (!quiet && !short_output) {
      fprintf(stderr, "No output file specified (no -o flag). Encoding will\n");
      fprintf(stderr, "be performed, but its results discarded.\n\n");
@ -1098,12 +1075,8 @@ int main(int argc, const char* argv[]) {
  if (picture.extra_info_type > 0) {
    AllocExtraInfo(&picture);
  }
-  // Save original picture for later comparison. Only for lossy as lossless does
-  // not modify 'picture' (even near-lossless).
-  if (print_distortion >= 0 && !config.lossless &&
-      !WebPPictureCopy(&picture, &original_picture)) {
-    fprintf(stderr, "Error! Cannot copy temporary picture\n");
-    goto Error;
+  if (print_distortion >= 0) {  // Save original picture for later comparison
+    WebPPictureCopy(&picture, &original_picture);
  }

  // Compress.
@ -1121,38 +1094,7 @@ int main(int argc, const char* argv[]) {
    fprintf(stderr, "Time to encode picture: %.3fs\n", encode_time);
  }

-  // Get the decompressed image for the lossless pipeline.
-  if (!quiet && print_distortion >= 0 && config.lossless) {
-    if (config.near_lossless == 100) {
-      // Pure lossless: image was not modified, make 'original_picture' a view
-      // of 'picture' by copying all members except the freeable pointers.
-      original_picture = picture;
-      original_picture.memory_ = original_picture.memory_argb_ = NULL;
-    } else {
-      // Decode the bitstream stored in 'memory_writer' to get the altered image
-      // to 'picture'; save the 'original_picture' beforehand.
-      assert(use_memory_writer);
-      original_picture = picture;
-      if (!WebPPictureInit(&picture)) {  // Do not free 'picture'.
-        fprintf(stderr, "Error! Version mismatch!\n");
-        goto Error;
-      }
-
-      picture.use_argb = 1;
-      if (!ReadWebP(memory_writer.mem, memory_writer.size, &picture,
-                    /*keep_alpha=*/WebPPictureHasTransparency(&picture),
-                    /*metadata=*/NULL)) {
-        fprintf(stderr, "Error! Cannot decode encoded WebP bitstream\n");
-        fprintf(stderr, "Error code: %d (%s)\n", picture.error_code,
-                kErrorMessages[picture.error_code]);
-        goto Error;
-      }
-      picture.stats = original_picture.stats;
-    }
-    original_picture.stats = NULL;
-  }
-
-  // Write the YUV planes to a PGM file. Only available for lossy.
+  // Write info
  if (dump_file) {
    if (picture.use_argb) {
      fprintf(stderr, "Warning: can't dump file (-d option) "
@ -1163,29 +1105,31 @@ int main(int argc, const char* argv[]) {
    }
  }

-  if (use_memory_writer && out != NULL &&
-      !WriteWebPWithMetadata(out, &picture, &memory_writer, &metadata,
-                             keep_metadata, &metadata_written)) {
-    fprintf(stderr, "Error writing WebP file!\n");
-    goto Error;
-  }
+  if (keep_metadata != 0) {
+    if (out != NULL) {
+      if (!WriteWebPWithMetadata(out, &picture, &memory_writer,
+                                 &metadata, keep_metadata, &metadata_written)) {
+        fprintf(stderr, "Error writing WebP file with metadata!\n");
+        goto Error;
+      }
+    } else {  // output is disabled, just display the metadata stats.
+      const struct {
+        const MetadataPayload* const payload;
+        int flag;
+      } *iter, info[] = {
+        { &metadata.exif, METADATA_EXIF },
+        { &metadata.iccp, METADATA_ICC },
+        { &metadata.xmp, METADATA_XMP },
+        { NULL, 0 }
+      };
+      uint32_t unused1 = 0;
+      uint64_t unused2 = 0;

-  if (out == NULL && keep_metadata) {
-    // output is disabled, just display the metadata stats.
-    const struct {
-      const MetadataPayload* const payload;
-      int flag;
-    } *iter, info[] = {{&metadata.exif, METADATA_EXIF},
-                       {&metadata.iccp, METADATA_ICC},
-                       {&metadata.xmp, METADATA_XMP},
-                       {NULL, 0}};
-    uint32_t unused1 = 0;
-    uint64_t unused2 = 0;
-
-    for (iter = info; iter->payload != NULL; ++iter) {
-      if (UpdateFlagsAndSize(iter->payload, !!(keep_metadata & iter->flag),
-                             /*flag=*/0, &unused1, &unused2)) {
-        metadata_written |= iter->flag;
+      for (iter = info; iter->payload != NULL; ++iter) {
+        if (UpdateFlagsAndSize(iter->payload, !!(keep_metadata & iter->flag),
+                               0, &unused1, &unused2)) {
+          metadata_written |= iter->flag;
+        }
      }
    }
  }
--- a/examples/dwebp.c
+++ b/examples/dwebp.c
@ -76,8 +76,7 @@ static int SaveOutput(const WebPDecBuffer* const buffer,

 static void Help(void) {
  printf("Usage: dwebp in_file [options] [-o out_file]\n\n"
-         "Decodes the WebP image file to PNG format [Default].\n"
-         "Note: Animated WebP files are not supported.\n\n"
+         "Decodes the WebP image file to PNG format [Default]\n"
         "Use following options to convert into alternate image formats:\n"
         "  -pam ......... save the raw RGBA samples as a color PAM\n"
         "  -ppm ......... save the raw RGB samples as a color PPM\n"
--- a/examples/img2webp.c
+++ b/examples/img2webp.c
@ -84,7 +84,7 @@ static int ReadImage(const char filename[], WebPPicture* const pic) {
  if (!ImgIoUtilReadFile(filename, &data, &data_size)) return 0;
  reader = WebPGuessImageReader(data, data_size);
  ok = reader(data, data_size, pic, 1, NULL);
-  WebPFree((void*)data);
+  free((void*)data);
  return ok;
 }

--- a/examples/webpmux.c
+++ b/examples/webpmux.c
@ -26,7 +26,6 @@
    webpmux -set icc image_profile.icc in.webp -o out_icc_container.webp
    webpmux -set exif image_metadata.exif in.webp -o out_exif_container.webp
    webpmux -set xmp image_metadata.xmp in.webp -o out_xmp_container.webp
-    webpmux -set loop 1 in.webp -o out_looped.webp

  Extract relevant data from WebP container file:
    webpmux -get frame n in.webp -o out_frame.webp
@ -98,7 +97,6 @@ typedef enum {
  FEATURE_ICCP,
  FEATURE_ANMF,
  FEATURE_DURATION,
-  FEATURE_LOOP,
  LAST_FEATURE
 } FeatureType;

@ -316,7 +314,6 @@ static void PrintHelp(void) {
  printf("\n");
  printf("SET_OPTIONS:\n");
  printf(" Set color profile/metadata:\n");
-  printf("   loop LOOP_COUNT   set the loop count\n");
  printf("   icc  file.icc     set ICC profile\n");
  printf("   exif file.exif    set EXIF metadata\n");
  printf("   xmp  file.xmp     set XMP metadata\n");
@ -771,13 +768,6 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
        arg->params_ = argv[i + 1];
        ++feature_arg_index;
        i += 2;
-      } else if (!strcmp(argv[i], "loop") &&
-                 (config->action_type_ == ACTION_SET)) {
-        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
-        config->type_ = FEATURE_LOOP;
-        arg->params_ = argv[i + 1];
-        ++feature_arg_index;
-        i += 2;
      } else {  // Assume input file.
        if (config->input_ == NULL) {
          config->input_ = wargv[i];
@ -1021,38 +1011,13 @@ static int Process(const Config* config) {
          ok = ExUtilReadFileToWebPData(config->args_[0].filename_, &chunk);
          if (!ok) goto Err2;
          err = WebPMuxSetChunk(mux, kFourccList[config->type_], &chunk, 1);
-          WebPDataClear(&chunk);
+          free((void*)chunk.bytes);
          if (err != WEBP_MUX_OK) {
            ERROR_GOTO3("ERROR (%s): Could not set the %s.\n",
                        ErrorString(err), kDescriptions[config->type_], Err2);
          }
          break;
        }
-        case FEATURE_LOOP: {
-          WebPMuxAnimParams params = { 0xFFFFFFFF, 0 };
-          int parse_error = 0;
-          const int loop_count =
-              ExUtilGetInt(config->args_[0].params_, 10, &parse_error);
-          if (loop_count < 0 || loop_count > 65535 || parse_error) {
-            ERROR_GOTO1("ERROR: Loop count must be in the range 0 to 65535.\n",
-                        Err2);
-          }
-          ok = CreateMux(config->input_, &mux);
-          if (!ok) goto Err2;
-          ok = (WebPMuxGetAnimationParams(mux, &params) == WEBP_MUX_OK);
-          if (!ok) {
-            ERROR_GOTO1("ERROR: input file does not seem to be an animation.\n",
-                        Err2);
-          }
-          params.loop_count = loop_count;
-          err = WebPMuxSetAnimationParams(mux, &params);
-          ok = (err == WEBP_MUX_OK);
-          if (!ok) {
-            ERROR_GOTO2("ERROR (%s): Could not set animation parameters.\n",
-                        ErrorString(err), Err2);
-          }
-          break;
-        }
        default: {
          ERROR_GOTO1("ERROR: Invalid feature for action 'set'.\n", Err2);
          break;
--- a/extras/extras.c
+++ b/extras/extras.c
@ -18,7 +18,7 @@
 #include <string.h>

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

 //------------------------------------------------------------------------------
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@ -1,5 +1,6 @@
+#Thu May 12 17:06:25 CEST 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-bin.zip
--- a/65
+++ b/65
@ -1,20 +1,4 @@
-#!/usr/bin/env sh
-
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
+#!/usr/bin/env bash

 ##############################################################################
 ##
@ -44,16 +28,16 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`

 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+DEFAULT_JVM_OPTS=""

 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"

-warn () {
+warn ( ) {
    echo "$*"
 }

-die () {
+die ( ) {
    echo
    echo "$*"
    echo
@ -125,8 +109,8 @@ if $darwin; then
    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi

-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
    JAVACMD=`cygpath --unix "$JAVACMD"`
@ -154,30 +138,27 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
        else
            eval `echo args$i`="\"$arg\""
        fi
-        i=`expr $i + 1`
+        i=$((i+1))
    done
    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
    esac
 fi

-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
 }
-APP_ARGS=`save "$@"`
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"

-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-exec "$JAVACMD" "$@"
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
--- a/gradlew.bat
+++ b/gradlew.bat
@ -1,100 +1,90 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
--- a/imageio/imageio_util.c
+++ b/imageio/imageio_util.c
@ -91,7 +91,7 @@ int ImgIoUtilReadFile(const char* const file_name,
  file_size = ftell(in);
  fseek(in, 0, SEEK_SET);
  // we allocate one extra byte for the \0 terminator
-  file_data = (uint8_t*)WebPMalloc(file_size + 1);
+  file_data = (uint8_t*)malloc(file_size + 1);
  if (file_data == NULL) {
    fclose(in);
    WFPRINTF(stderr, "memory allocation failure when reading file %s\n",
@ -104,7 +104,7 @@ int ImgIoUtilReadFile(const char* const file_name,
  if (!ok) {
    WFPRINTF(stderr, "Could not read %d bytes of data from file %s\n",
             (int)file_size, (const W_CHAR*)file_name);
-    WebPFree(file_data);
+    free(file_data);
    return 0;
  }
  file_data[file_size] = '\0';  // convenient 0-terminator
--- a/imageio/imageio_util.h
+++ b/imageio/imageio_util.h
@ -29,7 +29,7 @@ FILE* ImgIoUtilSetBinaryMode(FILE* file);

 // Allocates storage for entire file 'file_name' and returns contents and size
 // in 'data' and 'data_size'. Returns 1 on success, 0 otherwise. '*data' should
-// be deleted using WebPFree().
+// be deleted using free().
 // Note: for convenience, the data will be null-terminated with an extra byte
 // (not accounted for in *data_size), in case the file is text and intended
 // to be used as a C-string.
--- a/imageio/pngdec.c
+++ b/imageio/pngdec.c
@ -259,12 +259,6 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
    goto End;
  }

-  // If it looks like the bitstream is going to need more memory than libpng's
-  // internal limit (default: 8M), try to (reasonably) raise it.
-  if (data_size > png_get_chunk_malloc_max(png) && data_size < (1u << 24)) {
-    png_set_chunk_malloc_max(png, data_size);
-  }
-
  info = png_create_info_struct(png);
  if (info == NULL) goto Error;
  end_info = png_create_info_struct(png);
--- a/imageio/pnmdec.c
+++ b/imageio/pnmdec.c
@ -33,8 +33,8 @@ typedef struct {
  const uint8_t* data;
  size_t data_size;
  int width, height;
-  int bytes_per_px;
-  int depth;          // 1 (grayscale), 2 (grayscale + alpha), 3 (rgb), 4 (rgba)
+  int bytes_per_px;   // 1, 3, 4
+  int depth;
  int max_value;
  int type;           // 5, 6 or 7
  int seen_flags;
@ -101,9 +101,6 @@ static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
    } else if (!strcmp(out, "TUPLTYPE RGB")) {
      expected_depth = 3;
      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "TUPLTYPE GRAYSCALE_ALPHA")) {
-      expected_depth = 2;
-      info->seen_flags |= TUPLE_FLAG;
    } else if (!strcmp(out, "TUPLTYPE GRAYSCALE")) {
      expected_depth = 1;
      info->seen_flags |= TUPLE_FLAG;
@ -169,7 +166,7 @@ static size_t ReadHeader(PNMInfo* const info) {
  // perform some basic numerical validation
  if (info->width <= 0 || info->height <= 0 ||
      info->type <= 0 || info->type >= 9 ||
-      info->depth <= 0 || info->depth > 4 ||
+      info->depth <= 0 || info->depth == 2 || info->depth > 4 ||
      info->max_value <= 0 || info->max_value >= 65536) {
    return 0;
  }
@ -182,7 +179,7 @@ int ReadPNM(const uint8_t* const data, size_t data_size,
            struct Metadata* const metadata) {
  int ok = 0;
  int i, j;
-  uint64_t stride, pixel_bytes, sample_size, depth;
+  uint64_t stride, pixel_bytes;
  uint8_t* rgb = NULL, *tmp_rgb;
  size_t offset;
  PNMInfo info;
@ -213,10 +210,8 @@ int ReadPNM(const uint8_t* const data, size_t data_size,
    fprintf(stderr, "Truncated PNM file (P%d).\n", info.type);
    goto End;
  }
-  sample_size = (info.max_value > 255) ? 2 : 1;
-  // final depth
-  depth = (info.depth == 1 || info.depth == 3 || !keep_alpha) ? 3 : 4;
-  stride = depth * info.width;
+  stride =
+      (uint64_t)(info.bytes_per_px < 3 ? 3 : info.bytes_per_px) * info.width;
  if (stride != (size_t)stride ||
      !ImgIoUtilCheckSizeArgumentsOverflow(stride, info.height)) {
    goto End;
@ -225,63 +220,30 @@ int ReadPNM(const uint8_t* const data, size_t data_size,
  rgb = (uint8_t*)malloc((size_t)stride * info.height);
  if (rgb == NULL) goto End;

-  // Convert input.
-  // We only optimize for the sample_size=1, max_value=255, depth=1 case.
+  // Convert input
  tmp_rgb = rgb;
  for (j = 0; j < info.height; ++j) {
-    const uint8_t* in = data + offset;
-    offset += info.bytes_per_px * info.width;
-    assert(offset <= data_size);
-    if (info.max_value == 255 && info.depth >= 3) {
-      // RGB or RGBA
-      if (info.depth == 3 || keep_alpha) {
-        memcpy(tmp_rgb, in, info.depth * info.width * sizeof(*in));
-      } else {
-        assert(info.depth == 4 && !keep_alpha);
-        for (i = 0; i < info.width; ++i) {
-          tmp_rgb[3 * i + 0] = in[4 * i + 0];
-          tmp_rgb[3 * i + 1] = in[4 * i + 1];
-          tmp_rgb[3 * i + 2] = in[4 * i + 2];
-        }
-      }
-    } else {
-      // Unoptimized case, we need to handle non-trivial operations:
-      //   * convert 16b to 8b (if max_value > 255)
-      //   * rescale to [0..255] range (if max_value != 255)
-      //   * drop the alpha channel (if keep_alpha is false)
-      const uint32_t round = info.max_value / 2;
-      int k = 0;
-      for (i = 0; i < info.width * info.depth; ++i) {
-        uint32_t v = (sample_size == 2) ? 256u * in[2 * i + 0] + in[2 * i + 1]
-                   : in[i];
-        if (info.max_value != 255) v = (v * 255u + round) / info.max_value;
-        if (v > 255u) v = 255u;
-        if (info.depth > 2) {
-          if (!keep_alpha && info.depth == 4 && (i % 4) == 3) {
-            // skip alpha
-          } else {
-            tmp_rgb[k] = v;
-            k += 1;
-          }
-        } else if (info.depth == 1 || (i % 2) == 0) {
-          tmp_rgb[k + 0] = tmp_rgb[k + 1] = tmp_rgb[k + 2] = v;
-          k += 3;
-        } else if (keep_alpha && info.depth == 2) {
-          tmp_rgb[k] = v;
-          k += 1;
-        } else {
-          // skip alpha
-        }
+    assert(offset + info.bytes_per_px * info.width <= data_size);
+    if (info.depth == 1) {
+      // convert grayscale -> RGB
+      for (i = 0; i < info.width; ++i) {
+        const uint8_t v = data[offset + i];
+        tmp_rgb[3 * i + 0] = tmp_rgb[3 * i + 1] = tmp_rgb[3 * i + 2] = v;
      }
+    } else if (info.depth == 3) {   // RGB
+      memcpy(tmp_rgb, data + offset, 3 * info.width * sizeof(*data));
+    } else if (info.depth == 4) {   // RGBA
+      memcpy(tmp_rgb, data + offset, 4 * info.width * sizeof(*data));
    }
+    offset += info.bytes_per_px * info.width;
    tmp_rgb += stride;
  }

  // WebP conversion.
  pic->width = info.width;
  pic->height = info.height;
-  ok = (depth == 4) ? WebPPictureImportRGBA(pic, rgb, (int)stride)
-                    : WebPPictureImportRGB(pic, rgb, (int)stride);
+  ok = (info.depth == 4) ? WebPPictureImportRGBA(pic, rgb, (int)stride)
+                         : WebPPictureImportRGB(pic, rgb, (int)stride);
  if (!ok) goto End;

  ok = 1;
--- a/imageio/webpdec.c
+++ b/imageio/webpdec.c
@ -65,7 +65,7 @@ int LoadWebP(const char* const in_file,

  status = WebPGetFeatures(*data, *data_size, bitstream);
  if (status != VP8_STATUS_OK) {
-    WebPFree((void*)*data);
+    free((void*)*data);
    *data = NULL;
    *data_size = 0;
    PrintWebPError(in_file, status);
--- a/imageio/wicdec.c
+++ b/imageio/wicdec.c
@ -298,15 +298,9 @@ int ReadPictureWithWIC(const char* const filename,
          factory, stream, NULL,
          WICDecodeMetadataCacheOnDemand, &decoder));
  IFS(IWICBitmapDecoder_GetFrameCount(decoder, &frame_count));
-  if (SUCCEEDED(hr)) {
-    if (frame_count == 0) {
-      fprintf(stderr, "No frame found in input file.\n");
-      hr = E_FAIL;
-    } else if (frame_count > 1) {
-      // WIC will be tried before native WebP decoding so avoid duplicating the
-      // error message.
-      hr = E_FAIL;
-    }
+  if (SUCCEEDED(hr) && frame_count == 0) {
+    fprintf(stderr, "No frame found in input file.\n");
+    hr = E_FAIL;
  }
  IFS(IWICBitmapDecoder_GetFrame(decoder, 0, &frame));
  IFS(IWICBitmapFrameDecode_GetPixelFormat(frame, &src_pixel_format));
--- a/iosbuild.sh
+++ b/iosbuild.sh
@ -1,9 +1,8 @@
 #!/bin/bash
 #
-# This script generates 'WebP.framework' and 'WebPDecoder.framework',
-# 'WebPDemux.framework' and 'WebPMux.framework'.
-# An iOS app can decode WebP images by including 'WebPDecoder.framework' and
-# both encode and decode WebP images by including 'WebP.framework'.
+# This script generates 'WebP.framework' and 'WebPDecoder.framework'. An iOS
+# app can decode WebP images by including 'WebPDecoder.framework' and both
+# encode and decode WebP images by including 'WebP.framework'.
 #
 # Run ./iosbuild.sh to generate the frameworks under the current directory
 # (the previous build will be erased if it exists).
@ -13,9 +12,6 @@

 set -e

-# Set this variable based on the desired minimum deployment target.
-readonly IOS_MIN_VERSION=6.0
-
 # Extract the latest SDK version from the final field of the form: iphoneosX.Y
 readonly SDK=$(xcodebuild -showsdks \
  | grep iphoneos | sort | tail -n 1 | awk '{print substr($NF, 9)}'
@ -54,27 +50,13 @@ if [[ -z "${SDK}" ]]; then
  exit 1
 elif [[ ${SDK%%.*} -gt 8 ]]; then
  EXTRA_CFLAGS="-fembed-bitcode"
-elif [[ ${SDK%%.*} -le 6 ]]; then
+elif [[ ${SDK} < 6.0 ]]; then
  echo "You need iOS SDK version 6.0 or above"
  exit 1
+else
+  echo "iOS SDK Version ${SDK}"
 fi

-echo "Xcode Version: ${XCODE}"
-echo "iOS SDK Version: ${SDK}"
-
-if [[ -e "${BUILDDIR}" || -e "${TARGETDIR}" || -e "${DECTARGETDIR}" \
-      || -e "${MUXTARGETDIR}" || -e "${DEMUXTARGETDIR}" ]]; then
-  cat << EOF
-WARNING: The following directories will be deleted:
-WARNING:   ${BUILDDIR}
-WARNING:   ${TARGETDIR}
-WARNING:   ${DECTARGETDIR}
-WARNING:   ${MUXTARGETDIR}
-WARNING:   ${DEMUXTARGETDIR}
-WARNING: The build will continue in 5 seconds...
-EOF
-  sleep 5
-fi
 rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR} \
    ${MUXTARGETDIR} ${DEMUXTARGETDIR}
 mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/ \
@ -82,12 +64,12 @@ mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/ \

 if [[ ! -e ${SRCDIR}/configure ]]; then
  if ! (cd ${SRCDIR} && sh autogen.sh); then
-    cat << EOF
+    cat <<EOT
 Error creating configure script!
 This script requires the autoconf/automake and libtool to build. MacPorts can
 be used to obtain these:
 http://www.macports.org/install.php
-EOF
+EOT
    exit 1
  fi
 fi
@ -121,7 +103,7 @@ for PLATFORM in ${PLATFORMS}; do
  SDKROOT="${PLATFORMSROOT}/"
  SDKROOT+="${PLATFORM}.platform/Developer/SDKs/${PLATFORM}${SDK}.sdk/"
  CFLAGS="-arch ${ARCH2:-${ARCH}} -pipe -isysroot ${SDKROOT} -O3 -DNDEBUG"
-  CFLAGS+=" -miphoneos-version-min=${IOS_MIN_VERSION} ${EXTRA_CFLAGS}"
+  CFLAGS+=" -miphoneos-version-min=6.0 ${EXTRA_CFLAGS}"

  set -x
  export PATH="${DEVROOT}/usr/bin:${OLDPATH}"
@ -166,5 +148,3 @@ echo "DEMUXLIBLIST = ${DEMUXLIBLIST}"
 cp -a ${SRCDIR}/src/webp/{decode,types,mux_types,demux}.h \
    ${DEMUXTARGETDIR}/Headers/
 ${LIPO} -create ${DEMUXLIBLIST} -output ${DEMUXTARGETDIR}/WebPDemux
-
-echo  "SUCCESS"
--- a/man/cwebp.1
+++ b/man/cwebp.1
@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH CWEBP 1 "November 19, 2020"
+.TH CWEBP 1 "January 11, 2019"
 .SH NAME
 cwebp \- compress an image file to a WebP file
 .SH SYNOPSIS
@ -13,7 +13,6 @@ command.
 .PP
 \fBcwebp\fP compresses an image using the WebP format.
 Input format can be either PNG, JPEG, TIFF, WebP or raw Y'CbCr samples.
-Note: Animated PNG and WebP files are not supported.
 .SH OPTIONS
 The basic options are:
 .TP
@ -135,13 +134,6 @@ options \fB\-size\fP or \fB\-psnr\fP. Maximum value is 10, default is 1.
 If options \fB\-size\fP or \fB\-psnr\fP were used, but \fB\-pass\fP wasn't
 specified, a default value of '6' passes will be used.
 .TP
-.BI \-qrange " int int
-Specifies the permissible interval for the quality factor. This is particularly
-useful when using multi-pass (\fB\-size\fP or \fB\-psnr\fP options).
-Default is 0 100.
-If the quality factor is outside this range, it will be clamped.
-If the minimum value must be less or equal to the maximum one.
-.TP
 .B \-af
 Turns auto\-filter on. This algorithm will spend additional time optimizing
 the filtering strength to reach a well\-balanced quality.
--- a/man/dwebp.1
+++ b/man/dwebp.1
@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH DWEBP 1 "November 19, 2020"
+.TH DWEBP 1 "June 23, 2016"
 .SH NAME
 dwebp \- decompress a WebP file to an image file
 .SH SYNOPSIS
@ -12,7 +12,6 @@ This manual page documents the
 command.
 .PP
 \fBdwebp\fP decompresses WebP files into PNG, PAM, PPM or PGM images.
-Note: Animated WebP files are not supported.
 .SH OPTIONS
 The basic options are:
 .TP
--- a/man/gif2webp.1
+++ b/man/gif2webp.1
@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH GIF2WEBP 1 "May 1, 2020"
+.TH GIF2WEBP 1 "January 25, 2018"
 .SH NAME
 gif2webp \- Convert a GIF image to WebP
 .SH SYNOPSIS
@ -62,9 +62,9 @@ larger file size and lower compression quality.
 .TP
 .BI \-min_size
 Encode image to achieve smallest size. This disables key frame insertion and
-picks the dispose method resulting in the smallest output for each frame. It
-uses lossless compression by default, but can be combined with \-q, \-m,
-\-lossy or \-mixed options.
+picks the dispose method resulting in smallest output for each frame. It uses
+lossless compression by default, but can be combined with \-q, \-m, \-lossy or
+\-mixed options.
 .TP
 .BI \-kmin " int
 .TP
--- a/man/img2webp.1
+++ b/man/img2webp.1
@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH IMG2WEBP 1 "May 1, 2020"
+.TH IMG2WEBP 1 "April 3, 2018"
 .SH NAME
 img2webp \- create animated WebP file from a sequence of input images.
 .SH SYNOPSIS
@ -16,8 +16,8 @@ command.
 \fBimg2webp\fP compresses a sequence of images using the animated WebP format.
 Input images can either be PNG, JPEG, TIFF or WebP.
 If a single file name (not starting with the character '\-') is supplied as
-the argument, the command line arguments are actually tokenized from this file.
-This allows for easy scripting or using a large number of arguments.
+the argument, the command line argument are actually tokenized from this file.
+This allows for easy scripting or using large number of arguments.
 .SH FILE-LEVEL OPTIONS
 The file-level options are applied at the beginning of the compression process,
 before the input frames are read.
@ -27,7 +27,7 @@ Specify the name of the output WebP file.
 .TP
 .BI \-min_size
 Encode images to achieve smallest size. This disables key frame insertion and
-picks the parameters resulting in the smallest output for each frame. It uses
+picks the parameters resulting in smallest output for each frame. It uses
 lossless compression by default, but can be combined with \-q, \-m, \-lossy or
 \-mixed options.
 .TP
--- a/man/webpmux.1
+++ b/man/webpmux.1
@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH WEBPMUX 1 "December 12, 2020"
+.TH WEBPMUX 1 "April 23, 2018"
 .SH NAME
 webpmux \- create animated WebP files from non\-animated WebP images, extract
 frames from animated WebP images, and manage XMP/EXIF metadata and ICC profile.
@ -59,7 +59,7 @@ command.
 to add/extract/strip XMP/EXIF metadata and ICC profile.
 If a single file name (not starting with the character '\-') is supplied as
 the argument, the command line arguments are actually tokenized from this file.
-This allows for easy scripting or using a large number of arguments.
+This allows for easy scripting or using large number of arguments.
 .SH OPTIONS
 .SS GET_OPTIONS (\-get):
 .TP
@ -77,11 +77,6 @@ Get nth frame from an animated image. (n = 0 has a special meaning: last frame).

 .SS SET_OPTIONS (\-set)
 .TP
-.BI loop " loop_count
-Set loop count on an animated file.
-.P
-Where: 'loop_count' must be in range [0, 65535].
-.TP
 .BI icc " file.icc
 Set ICC profile.
 .P
--- 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:1:1
+libwebp_la_LDFLAGS = -no-undefined -version-info 8:0:1
 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:1:1
+  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 4:0:1
  pkgconfig_DATA += libwebpdecoder.pc
 endif

--- a/src/dec/io_dec.c
+++ b/src/dec/io_dec.c
@ -25,16 +25,21 @@
 static int EmitYUV(const VP8Io* const io, WebPDecParams* const p) {
  WebPDecBuffer* output = p->output;
  const WebPYUVABuffer* const buf = &output->u.YUVA;
-  uint8_t* const y_dst = buf->y + (size_t)io->mb_y * buf->y_stride;
-  uint8_t* const u_dst = buf->u + (size_t)(io->mb_y >> 1) * buf->u_stride;
-  uint8_t* const v_dst = buf->v + (size_t)(io->mb_y >> 1) * buf->v_stride;
+  uint8_t* const y_dst = buf->y + io->mb_y * buf->y_stride;
+  uint8_t* const u_dst = buf->u + (io->mb_y >> 1) * buf->u_stride;
+  uint8_t* const v_dst = buf->v + (io->mb_y >> 1) * buf->v_stride;
  const int mb_w = io->mb_w;
  const int mb_h = io->mb_h;
  const int uv_w = (mb_w + 1) / 2;
  const int uv_h = (mb_h + 1) / 2;
-  WebPCopyPlane(io->y, io->y_stride, y_dst, buf->y_stride, mb_w, mb_h);
-  WebPCopyPlane(io->u, io->uv_stride, u_dst, buf->u_stride, uv_w, uv_h);
-  WebPCopyPlane(io->v, io->uv_stride, v_dst, buf->v_stride, uv_w, uv_h);
+  int j;
+  for (j = 0; j < mb_h; ++j) {
+    memcpy(y_dst + j * buf->y_stride, io->y + j * io->y_stride, mb_w);
+  }
+  for (j = 0; j < uv_h; ++j) {
+    memcpy(u_dst + j * buf->u_stride, io->u + j * io->uv_stride, uv_w);
+    memcpy(v_dst + j * buf->v_stride, io->v + j * io->uv_stride, uv_w);
+  }
  return io->mb_h;
 }

@ -42,7 +47,7 @@ static int EmitYUV(const VP8Io* const io, WebPDecParams* const p) {
 static int EmitSampledRGB(const VP8Io* const io, WebPDecParams* const p) {
  WebPDecBuffer* const output = p->output;
  WebPRGBABuffer* const buf = &output->u.RGBA;
-  uint8_t* const dst = buf->rgba + (size_t)io->mb_y * buf->stride;
+  uint8_t* const dst = buf->rgba + io->mb_y * buf->stride;
  WebPSamplerProcessPlane(io->y, io->y_stride,
                          io->u, io->v, io->uv_stride,
                          dst, buf->stride, io->mb_w, io->mb_h,
@ -57,7 +62,7 @@ static int EmitSampledRGB(const VP8Io* const io, WebPDecParams* const p) {
 static int EmitFancyRGB(const VP8Io* const io, WebPDecParams* const p) {
  int num_lines_out = io->mb_h;   // a priori guess
  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
-  uint8_t* dst = buf->rgba + (size_t)io->mb_y * buf->stride;
+  uint8_t* dst = buf->rgba + io->mb_y * buf->stride;
  WebPUpsampleLinePairFunc upsample = WebPUpsamplers[p->output->colorspace];
  const uint8_t* cur_y = io->y;
  const uint8_t* cur_u = io->u;
@ -128,7 +133,7 @@ static int EmitAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
  const WebPYUVABuffer* const buf = &p->output->u.YUVA;
  const int mb_w = io->mb_w;
  const int mb_h = io->mb_h;
-  uint8_t* dst = buf->a + (size_t)io->mb_y * buf->a_stride;
+  uint8_t* dst = buf->a + io->mb_y * buf->a_stride;
  int j;
  (void)expected_num_lines_out;
  assert(expected_num_lines_out == mb_h);
@ -181,7 +186,7 @@ static int EmitAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
        (colorspace == MODE_ARGB || colorspace == MODE_Argb);
    const WebPRGBABuffer* const buf = &p->output->u.RGBA;
    int num_rows;
-    const size_t start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
+    const int start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
    uint8_t* const base_rgba = buf->rgba + start_y * buf->stride;
    uint8_t* const dst = base_rgba + (alpha_first ? 0 : 3);
    const int has_alpha = WebPDispatchAlpha(alpha, io->width, mb_w,
@ -205,7 +210,7 @@ static int EmitAlphaRGBA4444(const VP8Io* const io, WebPDecParams* const p,
    const WEBP_CSP_MODE colorspace = p->output->colorspace;
    const WebPRGBABuffer* const buf = &p->output->u.RGBA;
    int num_rows;
-    const size_t start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
+    const int start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
    uint8_t* const base_rgba = buf->rgba + start_y * buf->stride;
 #if (WEBP_SWAP_16BIT_CSP == 1)
    uint8_t* alpha_dst = base_rgba;
@ -271,9 +276,9 @@ static int EmitRescaledYUV(const VP8Io* const io, WebPDecParams* const p) {
 static int EmitRescaledAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
                                int expected_num_lines_out) {
  const WebPYUVABuffer* const buf = &p->output->u.YUVA;
-  uint8_t* const dst_a = buf->a + (size_t)p->last_y * buf->a_stride;
+  uint8_t* const dst_a = buf->a + p->last_y * buf->a_stride;
  if (io->a != NULL) {
-    uint8_t* const dst_y = buf->y + (size_t)p->last_y * buf->y_stride;
+    uint8_t* const dst_y = buf->y + p->last_y * buf->y_stride;
    const int num_lines_out = Rescale(io->a, io->width, io->mb_h, p->scaler_a);
    assert(expected_num_lines_out == num_lines_out);
    if (num_lines_out > 0) {   // unmultiply the Y
@ -351,7 +356,7 @@ static int ExportRGB(WebPDecParams* const p, int y_pos) {
  const WebPYUV444Converter convert =
      WebPYUV444Converters[p->output->colorspace];
  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
-  uint8_t* dst = buf->rgba + (size_t)y_pos * buf->stride;
+  uint8_t* dst = buf->rgba + y_pos * buf->stride;
  int num_lines_out = 0;
  // For RGB rescaling, because of the YUV420, current scan position
  // U/V can be +1/-1 line from the Y one.  Hence the double test.
@ -378,15 +383,15 @@ static int EmitRescaledRGB(const VP8Io* const io, WebPDecParams* const p) {
  while (j < mb_h) {
    const int y_lines_in =
        WebPRescalerImport(p->scaler_y, mb_h - j,
-                           io->y + (size_t)j * io->y_stride, io->y_stride);
+                           io->y + j * io->y_stride, io->y_stride);
    j += y_lines_in;
    if (WebPRescaleNeededLines(p->scaler_u, uv_mb_h - uv_j)) {
-      const int u_lines_in = WebPRescalerImport(
-          p->scaler_u, uv_mb_h - uv_j, io->u + (size_t)uv_j * io->uv_stride,
-          io->uv_stride);
-      const int v_lines_in = WebPRescalerImport(
-          p->scaler_v, uv_mb_h - uv_j, io->v + (size_t)uv_j * io->uv_stride,
-          io->uv_stride);
+      const int u_lines_in =
+          WebPRescalerImport(p->scaler_u, uv_mb_h - uv_j,
+                             io->u + uv_j * io->uv_stride, io->uv_stride);
+      const int v_lines_in =
+          WebPRescalerImport(p->scaler_v, uv_mb_h - uv_j,
+                             io->v + uv_j * io->uv_stride, io->uv_stride);
      (void)v_lines_in;   // remove a gcc warning
      assert(u_lines_in == v_lines_in);
      uv_j += u_lines_in;
@ -398,7 +403,7 @@ static int EmitRescaledRGB(const VP8Io* const io, WebPDecParams* const p) {

 static int ExportAlpha(WebPDecParams* const p, int y_pos, int max_lines_out) {
  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
-  uint8_t* const base_rgba = buf->rgba + (size_t)y_pos * buf->stride;
+  uint8_t* const base_rgba = buf->rgba + y_pos * buf->stride;
  const WEBP_CSP_MODE colorspace = p->output->colorspace;
  const int alpha_first =
      (colorspace == MODE_ARGB || colorspace == MODE_Argb);
@ -426,7 +431,7 @@ static int ExportAlpha(WebPDecParams* const p, int y_pos, int max_lines_out) {
 static int ExportAlphaRGBA4444(WebPDecParams* const p, int y_pos,
                               int max_lines_out) {
  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
-  uint8_t* const base_rgba = buf->rgba + (size_t)y_pos * buf->stride;
+  uint8_t* const base_rgba = buf->rgba + y_pos * buf->stride;
 #if (WEBP_SWAP_16BIT_CSP == 1)
  uint8_t* alpha_dst = base_rgba;
 #else
@ -465,7 +470,7 @@ static int EmitRescaledAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
    int lines_left = expected_num_out_lines;
    const int y_end = p->last_y + lines_left;
    while (lines_left > 0) {
-      const int64_t row_offset = (int64_t)scaler->src_y - io->mb_y;
+      const int row_offset = scaler->src_y - io->mb_y;
      WebPRescalerImport(scaler, io->mb_h + io->mb_y - scaler->src_y,
                         io->a + row_offset * io->width, io->width);
      lines_left -= p->emit_alpha_row(p, y_end - lines_left, lines_left);
--- a/src/dec/vp8_dec.c
+++ b/src/dec/vp8_dec.c
@ -494,11 +494,13 @@ static int GetCoeffsAlt(VP8BitReader* const br,
  return 16;
 }

-WEBP_DSP_INIT_FUNC(InitGetCoeffs) {
-  if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
-    GetCoeffs = GetCoeffsAlt;
-  } else {
-    GetCoeffs = GetCoeffsFast;
+static WEBP_TSAN_IGNORE_FUNCTION void InitGetCoeffs(void) {
+  if (GetCoeffs == NULL) {
+    if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
+      GetCoeffs = GetCoeffsAlt;
+    } else {
+      GetCoeffs = GetCoeffsFast;
+    }
  }
 }

--- a/src/dec/vp8i_dec.h
+++ b/src/dec/vp8i_dec.h
@ -31,7 +31,7 @@ extern "C" {

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

 // YUV-cache parameters. Cache is 32-bytes wide (= one cacheline).
--- 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;
-  HuffmanCode table[1 << LENGTHS_TABLE_BITS];
+  HuffmanTables tables;

-  if (!VP8LBuildHuffmanTable(table, LENGTHS_TABLE_BITS,
-                             code_length_code_lengths,
-                             NUM_CODE_LENGTH_CODES)) {
+  if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables) ||
+      !VP8LBuildHuffmanTable(&tables, 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 = &table[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
+    p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
    VP8LSetBitPos(br, br->bit_pos_ + p->bits);
    code_len = p->value;
    if (code_len < kCodeLengthLiterals) {
@ -300,6 +300,7 @@ static int ReadHuffmanCodeLengths(
  ok = 1;

 End:
+  VP8LHuffmanTablesDeallocate(&tables);
  if (!ok) dec->status_ = VP8_STATUS_BITSTREAM_ERROR;
  return ok;
 }
@ -307,7 +308,8 @@ 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, HuffmanCode* const table) {
+                           int* const code_lengths,
+                           HuffmanTables* const table) {
  int ok = 0;
  int size = 0;
  VP8LBitReader* const br = &dec->br_;
@ -362,8 +364,7 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
  VP8LMetadata* const hdr = &dec->hdr_;
  uint32_t* huffman_image = NULL;
  HTreeGroup* htree_groups = NULL;
-  HuffmanCode* huffman_tables = NULL;
-  HuffmanCode* huffman_table = NULL;
+  HuffmanTables* huffman_tables = &hdr->huffman_tables_;
  int num_htree_groups = 1;
  int num_htree_groups_max = 1;
  int max_alphabet_size = 0;
@ -372,6 +373,10 @@ 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;
@ -434,16 +439,15 @@ 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 || huffman_tables == NULL) {
+  if (htree_groups == NULL || code_lengths == NULL ||
+      !VP8LHuffmanTablesAllocate(num_htree_groups * table_size,
+                                 huffman_tables)) {
    dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
    goto Error;
  }

-  huffman_table = 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.
@ -468,19 +472,20 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
      int max_bits = 0;
      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
        int alphabet_size = kAlphabetSize[j];
-        htrees[j] = huffman_table;
        if (j == 0 && color_cache_bits > 0) {
          alphabet_size += (1 << color_cache_bits);
        }
-        size = ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_table);
+        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 = (huffman_table->bits == 0);
+          is_trivial_literal = (htrees[j]->bits == 0);
        }
-        total_size += huffman_table->bits;
-        huffman_table += size;
+        total_size += htrees[j]->bits;
+        huffman_tables->curr_segment->curr_table += size;
        if (j <= ALPHA) {
          int local_max_bits = code_lengths[0];
          int k;
@ -515,14 +520,13 @@ 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(mapping);
  if (!ok) {
    WebPSafeFree(huffman_image);
-    WebPSafeFree(huffman_tables);
+    VP8LHuffmanTablesDeallocate(huffman_tables);
    VP8LHtreeGroupsFree(htree_groups);
  }
  return ok;
@ -947,6 +951,7 @@ static WEBP_INLINE void CopyBlock8b(uint8_t* const dst, int dist, int length) {
        break;
      default:
        goto Copy;
+        break;
    }
    CopySmallPattern8b(src, dst, length, pattern);
    return;
@ -1353,7 +1358,7 @@ static void ClearMetadata(VP8LMetadata* const hdr) {
  assert(hdr != NULL);

  WebPSafeFree(hdr->huffman_image_);
-  WebPSafeFree(hdr->huffman_tables_);
+  VP8LHuffmanTablesDeallocate(&hdr->huffman_tables_);
  VP8LHtreeGroupsFree(hdr->htree_groups_);
  VP8LColorCacheClear(&hdr->color_cache_);
  VP8LColorCacheClear(&hdr->saved_color_cache_);
@ -1669,7 +1674,7 @@ int VP8LDecodeImage(VP8LDecoder* const dec) {
  // Sanity checks.
  if (dec == NULL) return 0;

-  assert(dec->hdr_.huffman_tables_ != NULL);
+  assert(dec->hdr_.huffman_tables_.root.start != 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
@ -51,7 +51,7 @@ typedef struct {
  uint32_t*       huffman_image_;
  int             num_htree_groups_;
  HTreeGroup*     htree_groups_;
-  HuffmanCode*    huffman_tables_;
+  HuffmanTables   huffman_tables_;
 } VP8LMetadata;

 typedef struct VP8LDecoder VP8LDecoder;
--- a/src/demux/Makefile.am
+++ b/src/demux/Makefile.am
@ -13,6 +13,6 @@ noinst_HEADERS =
 noinst_HEADERS += ../webp/format_constants.h

 libwebpdemux_la_LIBADD = ../libwebp.la
-libwebpdemux_la_LDFLAGS = -no-undefined -version-info 2:7:0
+libwebpdemux_la_LDFLAGS = -no-undefined -version-info 2:6:0
 libwebpdemuxincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebpdemux.pc
--- a/src/demux/anim_decode.c
+++ b/src/demux/anim_decode.c
@ -346,15 +346,12 @@ int WebPAnimDecoderGetNext(WebPAnimDecoder* dec,
  {
    const uint8_t* in = iter.fragment.bytes;
    const size_t in_size = iter.fragment.size;
-    const uint32_t stride = width * NUM_CHANNELS;  // at most 25 + 2 bits
-    const uint64_t out_offset = (uint64_t)iter.y_offset * stride +
-                                (uint64_t)iter.x_offset * NUM_CHANNELS;  // 53b
-    const uint64_t size = (uint64_t)iter.height * stride;  // at most 25 + 27b
+    const size_t out_offset =
+        (iter.y_offset * width + iter.x_offset) * NUM_CHANNELS;
    WebPDecoderConfig* const config = &dec->config_;
    WebPRGBABuffer* const buf = &config->output.u.RGBA;
-    if ((size_t)size != size) goto Error;
-    buf->stride = (int)stride;
-    buf->size = (size_t)size;
+    buf->stride = NUM_CHANNELS * width;
+    buf->size = buf->stride * iter.height;
    buf->rgba = dec->curr_frame_ + out_offset;

    if (WebPDecode(in, in_size, config) != VP8_STATUS_OK) {
--- a/src/demux/demux.c
+++ b/src/demux/demux.c
@ -24,7 +24,7 @@
 #include "src/webp/format_constants.h"

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

 typedef struct {
@ -312,7 +312,6 @@ static ParseStatus ParseAnimationFrame(
  int bits;
  MemBuffer* const mem = &dmux->mem_;
  Frame* frame;
-  size_t start_offset;
  ParseStatus status =
      NewFrame(mem, ANMF_CHUNK_SIZE, frame_chunk_size, &frame);
  if (status != PARSE_OK) return status;
@ -333,11 +332,7 @@ static ParseStatus ParseAnimationFrame(

  // Store a frame only if the animation flag is set there is some data for
  // this frame is available.
-  start_offset = mem->start_;
  status = StoreFrame(dmux->num_frames_ + 1, anmf_payload_size, mem, frame);
-  if (status != PARSE_ERROR && mem->start_ - start_offset > anmf_payload_size) {
-    status = PARSE_ERROR;
-  }
  if (status != PARSE_ERROR && is_animation && frame->frame_num_ > 0) {
    added_frame = AddFrame(dmux, frame);
    if (added_frame) {
--- 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,2,0
- PRODUCTVERSION 1,0,2,0
+ FILEVERSION 1,0,1,0
+ PRODUCTVERSION 1,0,1,0
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebpdemux DLL"
-            VALUE "FileVersion", "1.2.0"
+            VALUE "FileVersion", "1.1.0"
            VALUE "InternalName", "libwebpdemux.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebpdemux.dll"
            VALUE "ProductName", "WebP Image Demuxer"
-            VALUE "ProductVersion", "1.2.0"
+            VALUE "ProductVersion", "1.1.0"
        END
    END
    BLOCK "VarFileInfo"
--- a/src/dsp/alpha_processing.c
+++ b/src/dsp/alpha_processing.c
@ -359,11 +359,6 @@ static int HasAlpha32b_C(const uint8_t* src, int length) {
  return 0;
 }

-static void AlphaReplace_C(uint32_t* src, int length, uint32_t color) {
-  int x;
-  for (x = 0; x < length; ++x) if ((src[x] >> 24) == 0) src[x] = color;
-}
-
 //------------------------------------------------------------------------------
 // Simple channel manipulations.

@ -405,7 +400,6 @@ void (*WebPPackRGB)(const uint8_t* r, const uint8_t* g, const uint8_t* b,

 int (*WebPHasAlpha8b)(const uint8_t* src, int length);
 int (*WebPHasAlpha32b)(const uint8_t* src, int length);
-void (*WebPAlphaReplace)(uint32_t* src, int length, uint32_t color);

 //------------------------------------------------------------------------------
 // Init function
@ -434,7 +428,6 @@ WEBP_DSP_INIT_FUNC(WebPInitAlphaProcessing) {

  WebPHasAlpha8b = HasAlpha8b_C;
  WebPHasAlpha32b = HasAlpha32b_C;
-  WebPAlphaReplace = AlphaReplace_C;

  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  if (VP8GetCPUInfo != NULL) {
@ -476,5 +469,4 @@ WEBP_DSP_INIT_FUNC(WebPInitAlphaProcessing) {
  assert(WebPPackRGB != NULL);
  assert(WebPHasAlpha8b != NULL);
  assert(WebPHasAlpha32b != NULL);
-  assert(WebPAlphaReplace != NULL);
 }
--- a/src/dsp/alpha_processing_neon.c
+++ b/src/dsp/alpha_processing_neon.c
@ -83,7 +83,7 @@ static void ApplyAlphaMultiply_NEON(uint8_t* rgba, int alpha_first,
 static int DispatchAlpha_NEON(const uint8_t* alpha, int alpha_stride,
                              int width, int height,
                              uint8_t* dst, int dst_stride) {
-  uint32_t alpha_mask = 0xffffffffu;
+  uint32_t alpha_mask = 0xffu;
  uint8x8_t mask8 = vdup_n_u8(0xff);
  uint32_t tmp[2];
  int i, j;
@ -107,6 +107,7 @@ static int DispatchAlpha_NEON(const uint8_t* alpha, int alpha_stride,
    dst += dst_stride;
  }
  vst1_u8((uint8_t*)tmp, mask8);
+  alpha_mask *= 0x01010101;
  alpha_mask &= tmp[0];
  alpha_mask &= tmp[1];
  return (alpha_mask != 0xffffffffu);
@ -134,7 +135,7 @@ static void DispatchAlphaToGreen_NEON(const uint8_t* alpha, int alpha_stride,
 static int ExtractAlpha_NEON(const uint8_t* argb, int argb_stride,
                             int width, int height,
                             uint8_t* alpha, int alpha_stride) {
-  uint32_t alpha_mask = 0xffffffffu;
+  uint32_t alpha_mask = 0xffu;
  uint8x8_t mask8 = vdup_n_u8(0xff);
  uint32_t tmp[2];
  int i, j;
@ -156,6 +157,7 @@ static int ExtractAlpha_NEON(const uint8_t* argb, int argb_stride,
    alpha += alpha_stride;
  }
  vst1_u8((uint8_t*)tmp, mask8);
+  alpha_mask *= 0x01010101;
  alpha_mask &= tmp[0];
  alpha_mask &= tmp[1];
  return (alpha_mask == 0xffffffffu);
--- a/src/dsp/alpha_processing_sse2.c
+++ b/src/dsp/alpha_processing_sse2.c
@ -265,27 +265,6 @@ static int HasAlpha32b_SSE2(const uint8_t* src, int length) {
  return 0;
 }

-static void AlphaReplace_SSE2(uint32_t* src, int length, uint32_t color) {
-  const __m128i m_color = _mm_set1_epi32(color);
-  const __m128i zero = _mm_setzero_si128();
-  int i = 0;
-  for (; i + 8 <= length; i += 8) {
-    const __m128i a0 = _mm_loadu_si128((const __m128i*)(src + i + 0));
-    const __m128i a1 = _mm_loadu_si128((const __m128i*)(src + i + 4));
-    const __m128i b0 = _mm_srai_epi32(a0, 24);
-    const __m128i b1 = _mm_srai_epi32(a1, 24);
-    const __m128i c0 = _mm_cmpeq_epi32(b0, zero);
-    const __m128i c1 = _mm_cmpeq_epi32(b1, zero);
-    const __m128i d0 = _mm_and_si128(c0, m_color);
-    const __m128i d1 = _mm_and_si128(c1, m_color);
-    const __m128i e0 = _mm_andnot_si128(c0, a0);
-    const __m128i e1 = _mm_andnot_si128(c1, a1);
-    _mm_storeu_si128((__m128i*)(src + i + 0), _mm_or_si128(d0, e0));
-    _mm_storeu_si128((__m128i*)(src + i + 4), _mm_or_si128(d1, e1));
-  }
-  for (; i < length; ++i) if ((src[i] >> 24) == 0) src[i] = color;
-}
-
 // -----------------------------------------------------------------------------
 // Apply alpha value to rows

@ -355,7 +334,6 @@ WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessingSSE2(void) {

  WebPHasAlpha8b = HasAlpha8b_SSE2;
  WebPHasAlpha32b = HasAlpha32b_SSE2;
-  WebPAlphaReplace = AlphaReplace_SSE2;
 }

 #else  // !WEBP_USE_SSE2
--- a/src/dsp/cpu.c
+++ b/src/dsp/cpu.c
@ -55,18 +55,12 @@ static WEBP_INLINE void GetCPUInfo(int cpu_info[4], int info_type) {
    : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
    : "a"(info_type), "c"(0));
 }
-#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
-
-#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 150030729  // >= VS2008 SP1
+#elif (defined(_M_X64) || defined(_M_IX86)) && \
+      defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 150030729  // >= VS2008 SP1
 #include <intrin.h>
 #define GetCPUInfo(info, type) __cpuidex(info, type, 0)  // set ecx=0
-#define WEBP_HAVE_MSC_CPUID
-#elif _MSC_VER > 1310
-#include <intrin.h>
+#elif defined(WEBP_MSC_SSE2)
 #define GetCPUInfo __cpuid
-#define WEBP_HAVE_MSC_CPUID
-#endif
-
 #endif

 // NaCl has no support for xgetbv or the raw opcode.
@ -100,7 +94,7 @@ static WEBP_INLINE uint64_t xgetbv(void) {
 #define xgetbv() 0U  // no AVX for older x64 or unrecognized toolchains.
 #endif

-#if defined(__i386__) || defined(__x86_64__) || defined(WEBP_HAVE_MSC_CPUID)
+#if defined(__i386__) || defined(__x86_64__) || defined(WEBP_MSC_SSE2)

 // helper function for run-time detection of slow SSSE3 platforms
 static int CheckSlowModel(int info) {
@ -185,30 +179,6 @@ static int AndroidCPUInfo(CPUFeature feature) {
  return 0;
 }
 VP8CPUInfo VP8GetCPUInfo = AndroidCPUInfo;
-#elif defined(EMSCRIPTEN) // also needs to be before generic NEON test
-// Use compile flags as an indicator of SIMD support instead of a runtime check.
-static int wasmCPUInfo(CPUFeature feature) {
-  switch (feature) {
-#ifdef WEBP_USE_SSE2
-    case kSSE2:
-      return 1;
-#endif
-#ifdef WEBP_USE_SSE41
-    case kSSE3:
-    case kSlowSSSE3:
-    case kSSE4_1:
-      return 1;
-#endif
-#ifdef WEBP_USE_NEON
-    case kNEON:
-      return 1;
-#endif
-    default:
-      break;
-  }
-  return 0;
-}
-VP8CPUInfo VP8GetCPUInfo = wasmCPUInfo;
 #elif defined(WEBP_USE_NEON)
 // define a dummy function to enable turning off NEON at runtime by setting
 // VP8DecGetCPUInfo = NULL
--- a/src/dsp/dec_neon.c
+++ b/src/dsp/dec_neon.c
@ -1283,12 +1283,12 @@ static void DC4_NEON(uint8_t* dst) {    // DC
  const uint8x8_t A = vld1_u8(dst - BPS);  // top row
  const uint16x4_t p0 = vpaddl_u8(A);  // cascading summation of the top
  const uint16x4_t p1 = vpadd_u16(p0, p0);
-  const uint8x8_t L0 = vld1_u8(dst + 0 * BPS - 1);
-  const uint8x8_t L1 = vld1_u8(dst + 1 * BPS - 1);
-  const uint8x8_t L2 = vld1_u8(dst + 2 * BPS - 1);
-  const uint8x8_t L3 = vld1_u8(dst + 3 * BPS - 1);
-  const uint16x8_t s0 = vaddl_u8(L0, L1);
-  const uint16x8_t s1 = vaddl_u8(L2, L3);
+  const uint16x8_t L0 = vmovl_u8(vld1_u8(dst + 0 * BPS - 1));
+  const uint16x8_t L1 = vmovl_u8(vld1_u8(dst + 1 * BPS - 1));
+  const uint16x8_t L2 = vmovl_u8(vld1_u8(dst + 2 * BPS - 1));
+  const uint16x8_t L3 = vmovl_u8(vld1_u8(dst + 3 * BPS - 1));
+  const uint16x8_t s0 = vaddq_u16(L0, L1);
+  const uint16x8_t s1 = vaddq_u16(L2, L3);
  const uint16x8_t s01 = vaddq_u16(s0, s1);
  const uint16x8_t sum = vaddq_u16(s01, vcombine_u16(p1, p1));
  const uint8x8_t dc0 = vrshrn_n_u16(sum, 3);  // (sum + 4) >> 3
@ -1429,7 +1429,8 @@ 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 uint16_t p2 = vaddlv_u8(A);
+    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
@ -1440,18 +1441,18 @@ static WEBP_INLINE void DC8_NEON(uint8_t* dst, int do_top, int do_left) {
  }

  if (do_left) {
-    const uint8x8_t L0 = vld1_u8(dst + 0 * BPS - 1);
-    const uint8x8_t L1 = vld1_u8(dst + 1 * BPS - 1);
-    const uint8x8_t L2 = vld1_u8(dst + 2 * BPS - 1);
-    const uint8x8_t L3 = vld1_u8(dst + 3 * BPS - 1);
-    const uint8x8_t L4 = vld1_u8(dst + 4 * BPS - 1);
-    const uint8x8_t L5 = vld1_u8(dst + 5 * BPS - 1);
-    const uint8x8_t L6 = vld1_u8(dst + 6 * BPS - 1);
-    const uint8x8_t L7 = vld1_u8(dst + 7 * BPS - 1);
-    const uint16x8_t s0 = vaddl_u8(L0, L1);
-    const uint16x8_t s1 = vaddl_u8(L2, L3);
-    const uint16x8_t s2 = vaddl_u8(L4, L5);
-    const uint16x8_t s3 = vaddl_u8(L6, L7);
+    const uint16x8_t L0 = vmovl_u8(vld1_u8(dst + 0 * BPS - 1));
+    const uint16x8_t L1 = vmovl_u8(vld1_u8(dst + 1 * BPS - 1));
+    const uint16x8_t L2 = vmovl_u8(vld1_u8(dst + 2 * BPS - 1));
+    const uint16x8_t L3 = vmovl_u8(vld1_u8(dst + 3 * BPS - 1));
+    const uint16x8_t L4 = vmovl_u8(vld1_u8(dst + 4 * BPS - 1));
+    const uint16x8_t L5 = vmovl_u8(vld1_u8(dst + 5 * BPS - 1));
+    const uint16x8_t L6 = vmovl_u8(vld1_u8(dst + 6 * BPS - 1));
+    const uint16x8_t L7 = vmovl_u8(vld1_u8(dst + 7 * BPS - 1));
+    const uint16x8_t s0 = vaddq_u16(L0, L1);
+    const uint16x8_t s1 = vaddq_u16(L2, L3);
+    const uint16x8_t s2 = vaddq_u16(L4, L5);
+    const uint16x8_t s3 = vaddq_u16(L6, L7);
    const uint16x8_t s01 = vaddq_u16(s0, s1);
    const uint16x8_t s23 = vaddq_u16(s2, s3);
    sum_left = vaddq_u16(s01, s23);
@ -1511,34 +1512,29 @@ static WEBP_INLINE void DC16_NEON(uint8_t* dst, int do_top, int do_left) {

  if (do_top) {
    const uint8x16_t A = vld1q_u8(dst - BPS);  // top row
-#if defined(__aarch64__)
-    const uint16_t p3 = vaddlvq_u8(A);
-    sum_top = vdupq_n_u16(p3);
-#else
    const uint16x8_t p0 = vpaddlq_u8(A);  // cascading summation of the top
    const uint16x4_t p1 = vadd_u16(vget_low_u16(p0), vget_high_u16(p0));
    const uint16x4_t p2 = vpadd_u16(p1, p1);
    const uint16x4_t p3 = vpadd_u16(p2, p2);
    sum_top = vcombine_u16(p3, p3);
-#endif
  }

  if (do_left) {
    int i;
    sum_left = vdupq_n_u16(0);
    for (i = 0; i < 16; i += 8) {
-      const uint8x8_t L0 = vld1_u8(dst + (i + 0) * BPS - 1);
-      const uint8x8_t L1 = vld1_u8(dst + (i + 1) * BPS - 1);
-      const uint8x8_t L2 = vld1_u8(dst + (i + 2) * BPS - 1);
-      const uint8x8_t L3 = vld1_u8(dst + (i + 3) * BPS - 1);
-      const uint8x8_t L4 = vld1_u8(dst + (i + 4) * BPS - 1);
-      const uint8x8_t L5 = vld1_u8(dst + (i + 5) * BPS - 1);
-      const uint8x8_t L6 = vld1_u8(dst + (i + 6) * BPS - 1);
-      const uint8x8_t L7 = vld1_u8(dst + (i + 7) * BPS - 1);
-      const uint16x8_t s0 = vaddl_u8(L0, L1);
-      const uint16x8_t s1 = vaddl_u8(L2, L3);
-      const uint16x8_t s2 = vaddl_u8(L4, L5);
-      const uint16x8_t s3 = vaddl_u8(L6, L7);
+      const uint16x8_t L0 = vmovl_u8(vld1_u8(dst + (i + 0) * BPS - 1));
+      const uint16x8_t L1 = vmovl_u8(vld1_u8(dst + (i + 1) * BPS - 1));
+      const uint16x8_t L2 = vmovl_u8(vld1_u8(dst + (i + 2) * BPS - 1));
+      const uint16x8_t L3 = vmovl_u8(vld1_u8(dst + (i + 3) * BPS - 1));
+      const uint16x8_t L4 = vmovl_u8(vld1_u8(dst + (i + 4) * BPS - 1));
+      const uint16x8_t L5 = vmovl_u8(vld1_u8(dst + (i + 5) * BPS - 1));
+      const uint16x8_t L6 = vmovl_u8(vld1_u8(dst + (i + 6) * BPS - 1));
+      const uint16x8_t L7 = vmovl_u8(vld1_u8(dst + (i + 7) * BPS - 1));
+      const uint16x8_t s0 = vaddq_u16(L0, L1);
+      const uint16x8_t s1 = vaddq_u16(L2, L3);
+      const uint16x8_t s2 = vaddq_u16(L4, L5);
+      const uint16x8_t s3 = vaddq_u16(L6, L7);
      const uint16x8_t s01 = vaddq_u16(s0, s1);
      const uint16x8_t s23 = vaddq_u16(s2, s3);
      const uint16x8_t sum = vaddq_u16(s01, s23);
--- a/src/dsp/dsp.h
+++ b/src/dsp/dsp.h
@ -51,7 +51,9 @@ extern "C" {
 # define __has_builtin(x) 0
 #endif

-#if !defined(HAVE_CONFIG_H)
+// for now, none of the optimizations below are available in emscripten
+#if !defined(EMSCRIPTEN)
+
 #if defined(_MSC_VER) && _MSC_VER > 1310 && \
    (defined(_M_X64) || defined(_M_IX86))
 #define WEBP_MSC_SSE2  // Visual C++ SSE2 targets
@ -61,7 +63,6 @@ extern "C" {
    (defined(_M_X64) || defined(_M_IX86))
 #define WEBP_MSC_SSE41  // Visual C++ SSE4.1 targets
 #endif
-#endif

 // WEBP_HAVE_* are used to indicate the presence of the instruction set in dsp
 // files without intrinsics, allowing the corresponding Init() to be called.
@ -75,9 +76,6 @@ extern "C" {
 #define WEBP_USE_SSE41
 #endif

-#undef WEBP_MSC_SSE41
-#undef WEBP_MSC_SSE2
-
 // The intrinsics currently cause compiler errors with arm-nacl-gcc and the
 // inline assembly would need to be modified for use with Native Client.
 #if (defined(__ARM_NEON__) || \
@ -112,6 +110,8 @@ extern "C" {
 #define WEBP_USE_MSA
 #endif

+#endif  /* EMSCRIPTEN */
+
 #ifndef WEBP_DSP_OMIT_C_CODE
 #define WEBP_DSP_OMIT_C_CODE 1
 #endif
@ -193,12 +193,6 @@ extern "C" {
 #endif
 #endif

-// If 'ptr' is NULL, returns NULL. Otherwise returns 'ptr + off'.
-// Prevents undefined behavior sanitizer nullptr-with-nonzero-offset warning.
-#if !defined(WEBP_OFFSET_PTR)
-#define WEBP_OFFSET_PTR(ptr, off) (((ptr) == NULL) ? NULL : ((ptr) + (off)))
-#endif
-
 // Regularize the definition of WEBP_SWAP_16BIT_CSP (backward compatibility)
 #if !defined(WEBP_SWAP_16BIT_CSP)
 #define WEBP_SWAP_16BIT_CSP 0
@ -638,8 +632,6 @@ extern void (*WebPPackRGB)(const uint8_t* r, const uint8_t* g, const uint8_t* b,
 extern int (*WebPHasAlpha8b)(const uint8_t* src, int length);
 // This function returns true if src[4*i] contains a value different from 0xff.
 extern int (*WebPHasAlpha32b)(const uint8_t* src, int length);
-// replaces transparent values in src[] by 'color'.
-extern void (*WebPAlphaReplace)(uint32_t* src, int length, uint32_t color);

 // To be called first before using the above.
 void WebPInitAlphaProcessing(void);
--- a/src/dsp/lossless.c
+++ b/src/dsp/lossless.c
@ -107,62 +107,62 @@ static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
 //------------------------------------------------------------------------------
 // Predictors

-uint32_t VP8LPredictor0_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor0_C(uint32_t left, const uint32_t* const top) {
  (void)top;
  (void)left;
  return ARGB_BLACK;
 }
-uint32_t VP8LPredictor1_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor1_C(uint32_t left, const uint32_t* const top) {
  (void)top;
  return left;
 }
-uint32_t VP8LPredictor2_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor2_C(uint32_t left, const uint32_t* const top) {
  (void)left;
  return top[0];
 }
-uint32_t VP8LPredictor3_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor3_C(uint32_t left, const uint32_t* const top) {
  (void)left;
  return top[1];
 }
-uint32_t VP8LPredictor4_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor4_C(uint32_t left, const uint32_t* const top) {
  (void)left;
  return top[-1];
 }
-uint32_t VP8LPredictor5_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor5_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = Average3(left, top[0], top[1]);
  return pred;
 }
-uint32_t VP8LPredictor6_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor6_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = Average2(left, top[-1]);
  return pred;
 }
-uint32_t VP8LPredictor7_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor7_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = Average2(left, top[0]);
  return pred;
 }
-uint32_t VP8LPredictor8_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor8_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = Average2(top[-1], top[0]);
  (void)left;
  return pred;
 }
-uint32_t VP8LPredictor9_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor9_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = Average2(top[0], top[1]);
  (void)left;
  return pred;
 }
-uint32_t VP8LPredictor10_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor10_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = Average4(left, top[-1], top[0], top[1]);
  return pred;
 }
-uint32_t VP8LPredictor11_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor11_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = Select(top[0], left, top[-1]);
  return pred;
 }
-uint32_t VP8LPredictor12_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor12_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]);
  return pred;
 }
-uint32_t VP8LPredictor13_C(uint32_t left, const uint32_t* const top) {
+static uint32_t Predictor13_C(uint32_t left, const uint32_t* const top) {
  const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]);
  return pred;
 }
@ -182,18 +182,18 @@ static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
    out[i] = left = VP8LAddPixels(in[i], left);
  }
 }
-GENERATE_PREDICTOR_ADD(VP8LPredictor2_C, PredictorAdd2_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor3_C, PredictorAdd3_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor4_C, PredictorAdd4_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor5_C, PredictorAdd5_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor6_C, PredictorAdd6_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor7_C, PredictorAdd7_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor8_C, PredictorAdd8_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor9_C, PredictorAdd9_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor10_C, PredictorAdd10_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor11_C, PredictorAdd11_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor12_C, PredictorAdd12_C)
-GENERATE_PREDICTOR_ADD(VP8LPredictor13_C, PredictorAdd13_C)
+GENERATE_PREDICTOR_ADD(Predictor2_C, PredictorAdd2_C)
+GENERATE_PREDICTOR_ADD(Predictor3_C, PredictorAdd3_C)
+GENERATE_PREDICTOR_ADD(Predictor4_C, PredictorAdd4_C)
+GENERATE_PREDICTOR_ADD(Predictor5_C, PredictorAdd5_C)
+GENERATE_PREDICTOR_ADD(Predictor6_C, PredictorAdd6_C)
+GENERATE_PREDICTOR_ADD(Predictor7_C, PredictorAdd7_C)
+GENERATE_PREDICTOR_ADD(Predictor8_C, PredictorAdd8_C)
+GENERATE_PREDICTOR_ADD(Predictor9_C, PredictorAdd9_C)
+GENERATE_PREDICTOR_ADD(Predictor10_C, PredictorAdd10_C)
+GENERATE_PREDICTOR_ADD(Predictor11_C, PredictorAdd11_C)
+GENERATE_PREDICTOR_ADD(Predictor12_C, PredictorAdd12_C)
+GENERATE_PREDICTOR_ADD(Predictor13_C, PredictorAdd13_C)

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

@ -562,6 +562,7 @@ VP8LPredictorFunc VP8LPredictors[16];

 // exposed plain-C implementations
 VP8LPredictorAddSubFunc VP8LPredictorsAdd_C[16];
+VP8LPredictorFunc VP8LPredictors_C[16];

 VP8LTransformColorInverseFunc VP8LTransformColorInverse;

@ -599,7 +600,8 @@ extern void VP8LDspInitMSA(void);
 } while (0);

 WEBP_DSP_INIT_FUNC(VP8LDspInit) {
-  COPY_PREDICTOR_ARRAY(VP8LPredictor, VP8LPredictors)
+  COPY_PREDICTOR_ARRAY(Predictor, VP8LPredictors)
+  COPY_PREDICTOR_ARRAY(Predictor, VP8LPredictors_C)
  COPY_PREDICTOR_ARRAY(PredictorAdd, VP8LPredictorsAdd)
  COPY_PREDICTOR_ARRAY(PredictorAdd, VP8LPredictorsAdd_C)

--- a/src/dsp/lossless.h
+++ b/src/dsp/lossless.h
@ -30,22 +30,7 @@ extern "C" {

 typedef uint32_t (*VP8LPredictorFunc)(uint32_t left, const uint32_t* const top);
 extern VP8LPredictorFunc VP8LPredictors[16];
-
-uint32_t VP8LPredictor0_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor1_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor2_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor3_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor4_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor5_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor6_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor7_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor8_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor9_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor10_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor11_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor12_C(uint32_t left, const uint32_t* const top);
-uint32_t VP8LPredictor13_C(uint32_t left, const uint32_t* const top);
-
+extern VP8LPredictorFunc VP8LPredictors_C[16];
 // These Add/Sub function expects upper[-1] and out[-1] to be readable.
 typedef void (*VP8LPredictorAddSubFunc)(const uint32_t* in,
                                        const uint32_t* upper, int num_pixels,
--- a/src/dsp/lossless_common.h
+++ b/src/dsp/lossless_common.h
@ -184,6 +184,19 @@ static void PREDICTOR_ADD(const uint32_t* in, const uint32_t* upper, \
  }                                                                  \
 }

+// It subtracts the prediction from the input pixel and stores the residual
+// in the output pixel.
+#define GENERATE_PREDICTOR_SUB(PREDICTOR, PREDICTOR_SUB)             \
+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);                             \
+  }                                                                  \
+}
+
 #ifdef __cplusplus
 }    // extern "C"
 #endif
--- a/src/dsp/lossless_enc.c
+++ b/src/dsp/lossless_enc.c
@ -702,6 +702,140 @@ void VP8LHistogramAdd(const VP8LHistogram* const a,
 //------------------------------------------------------------------------------
 // Image transforms.

+static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {
+  return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);
+}
+
+static WEBP_INLINE uint32_t Average3(uint32_t a0, uint32_t a1, uint32_t a2) {
+  return Average2(Average2(a0, a2), a1);
+}
+
+static WEBP_INLINE uint32_t Average4(uint32_t a0, uint32_t a1,
+                                     uint32_t a2, uint32_t a3) {
+  return Average2(Average2(a0, a1), Average2(a2, a3));
+}
+
+static WEBP_INLINE uint32_t Clip255(uint32_t a) {
+  if (a < 256) {
+    return a;
+  }
+  // return 0, when a is a negative integer.
+  // return 255, when a is positive.
+  return ~a >> 24;
+}
+
+static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {
+  return Clip255(a + b - c);
+}
+
+static WEBP_INLINE uint32_t ClampedAddSubtractFull(uint32_t c0, uint32_t c1,
+                                                   uint32_t c2) {
+  const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24);
+  const int r = AddSubtractComponentFull((c0 >> 16) & 0xff,
+                                         (c1 >> 16) & 0xff,
+                                         (c2 >> 16) & 0xff);
+  const int g = AddSubtractComponentFull((c0 >> 8) & 0xff,
+                                         (c1 >> 8) & 0xff,
+                                         (c2 >> 8) & 0xff);
+  const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff);
+  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
+}
+
+static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) {
+  return Clip255(a + (a - b) / 2);
+}
+
+static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,
+                                                   uint32_t c2) {
+  const uint32_t ave = Average2(c0, c1);
+  const int a = AddSubtractComponentHalf(ave >> 24, c2 >> 24);
+  const int r = AddSubtractComponentHalf((ave >> 16) & 0xff, (c2 >> 16) & 0xff);
+  const int g = AddSubtractComponentHalf((ave >> 8) & 0xff, (c2 >> 8) & 0xff);
+  const int b = AddSubtractComponentHalf((ave >> 0) & 0xff, (c2 >> 0) & 0xff);
+  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
+}
+
+// gcc-4.9 on ARM generates incorrect code in Select() when Sub3() is inlined.
+#if defined(__arm__) && \
+    (LOCAL_GCC_VERSION == 0x409 || LOCAL_GCC_VERSION == 0x408)
+# define LOCAL_INLINE __attribute__ ((noinline))
+#else
+# define LOCAL_INLINE WEBP_INLINE
+#endif
+
+static LOCAL_INLINE int Sub3(int a, int b, int c) {
+  const int pb = b - c;
+  const int pa = a - c;
+  return abs(pb) - abs(pa);
+}
+
+#undef LOCAL_INLINE
+
+static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
+  const int pa_minus_pb =
+      Sub3((a >> 24)       , (b >> 24)       , (c >> 24)       ) +
+      Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) +
+      Sub3((a >>  8) & 0xff, (b >>  8) & 0xff, (c >>  8) & 0xff) +
+      Sub3((a      ) & 0xff, (b      ) & 0xff, (c      ) & 0xff);
+  return (pa_minus_pb <= 0) ? a : b;
+}
+
+//------------------------------------------------------------------------------
+// Predictors
+
+static uint32_t Predictor2(uint32_t left, const uint32_t* const top) {
+  (void)left;
+  return top[0];
+}
+static uint32_t Predictor3(uint32_t left, const uint32_t* const top) {
+  (void)left;
+  return top[1];
+}
+static uint32_t Predictor4(uint32_t left, const uint32_t* const top) {
+  (void)left;
+  return top[-1];
+}
+static uint32_t Predictor5(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = Average3(left, top[0], top[1]);
+  return pred;
+}
+static uint32_t Predictor6(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = Average2(left, top[-1]);
+  return pred;
+}
+static uint32_t Predictor7(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = Average2(left, top[0]);
+  return pred;
+}
+static uint32_t Predictor8(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = Average2(top[-1], top[0]);
+  (void)left;
+  return pred;
+}
+static uint32_t Predictor9(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = Average2(top[0], top[1]);
+  (void)left;
+  return pred;
+}
+static uint32_t Predictor10(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = Average4(left, top[-1], top[0], top[1]);
+  return pred;
+}
+static uint32_t Predictor11(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = Select(top[0], left, top[-1]);
+  return pred;
+}
+static uint32_t Predictor12(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]);
+  return pred;
+}
+static uint32_t Predictor13(uint32_t left, const uint32_t* const top) {
+  const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]);
+  return pred;
+}
+
+//------------------------------------------------------------------------------
+
 static void PredictorSub0_C(const uint32_t* in, const uint32_t* upper,
                            int num_pixels, uint32_t* out) {
  int i;
@ -716,33 +850,18 @@ static void PredictorSub1_C(const uint32_t* in, const uint32_t* upper,
  (void)upper;
 }

-// It subtracts the prediction from the input pixel and stores the residual
-// in the output pixel.
-#define GENERATE_PREDICTOR_SUB(PREDICTOR_I)                                \
-static void PredictorSub##PREDICTOR_I##_C(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 =                                                  \
-        VP8LPredictor##PREDICTOR_I##_C(in[x - 1], upper + x);              \
-    out[x] = VP8LSubPixels(in[x], pred);                                   \
-  }                                                                        \
-}
-
-GENERATE_PREDICTOR_SUB(2)
-GENERATE_PREDICTOR_SUB(3)
-GENERATE_PREDICTOR_SUB(4)
-GENERATE_PREDICTOR_SUB(5)
-GENERATE_PREDICTOR_SUB(6)
-GENERATE_PREDICTOR_SUB(7)
-GENERATE_PREDICTOR_SUB(8)
-GENERATE_PREDICTOR_SUB(9)
-GENERATE_PREDICTOR_SUB(10)
-GENERATE_PREDICTOR_SUB(11)
-GENERATE_PREDICTOR_SUB(12)
-GENERATE_PREDICTOR_SUB(13)
+GENERATE_PREDICTOR_SUB(Predictor2, PredictorSub2_C)
+GENERATE_PREDICTOR_SUB(Predictor3, PredictorSub3_C)
+GENERATE_PREDICTOR_SUB(Predictor4, PredictorSub4_C)
+GENERATE_PREDICTOR_SUB(Predictor5, PredictorSub5_C)
+GENERATE_PREDICTOR_SUB(Predictor6, PredictorSub6_C)
+GENERATE_PREDICTOR_SUB(Predictor7, PredictorSub7_C)
+GENERATE_PREDICTOR_SUB(Predictor8, PredictorSub8_C)
+GENERATE_PREDICTOR_SUB(Predictor9, PredictorSub9_C)
+GENERATE_PREDICTOR_SUB(Predictor10, PredictorSub10_C)
+GENERATE_PREDICTOR_SUB(Predictor11, PredictorSub11_C)
+GENERATE_PREDICTOR_SUB(Predictor12, PredictorSub12_C)
+GENERATE_PREDICTOR_SUB(Predictor13, PredictorSub13_C)

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

--- a/src/dsp/lossless_enc_mips32.c
+++ b/src/dsp/lossless_enc_mips32.c
@ -347,24 +347,24 @@ static void GetCombinedEntropyUnrefined_MIPS32(const uint32_t X[],
 static void AddVector_MIPS32(const uint32_t* pa, const uint32_t* pb,
                             uint32_t* pout, int size) {
  uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
-  const uint32_t end = ((size) / 4) * 4;
+  const int end = ((size) / 4) * 4;
  const uint32_t* const LoopEnd = pa + end;
  int i;
  ASM_START
  ADD_TO_OUT(0, 4, 8, 12, 1, pa, pb, pout)
  ASM_END_0
-  for (i = end; i < size; ++i) pout[i] = pa[i] + pb[i];
+  for (i = 0; i < size - end; ++i) pout[i] = pa[i] + pb[i];
 }

 static void AddVectorEq_MIPS32(const uint32_t* pa, uint32_t* pout, int size) {
  uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
-  const uint32_t end = ((size) / 4) * 4;
+  const int end = ((size) / 4) * 4;
  const uint32_t* const LoopEnd = pa + end;
  int i;
  ASM_START
  ADD_TO_OUT(0, 4, 8, 12, 0, pa, pout, pout)
  ASM_END_1
-  for (i = end; i < size; ++i) pout[i] += pa[i];
+  for (i = 0; i < size - end; ++i) pout[i] += pa[i];
 }

 #undef ASM_END_1
--- a/src/dsp/lossless_enc_sse2.c
+++ b/src/dsp/lossless_enc_sse2.c
@ -249,7 +249,6 @@ static void AddVectorEq_SSE2(const uint32_t* a, uint32_t* out, int size) {
    }                                  \
  } while (0)

-#if !(defined(__i386__) || defined(_M_IX86))
 static float CombinedShannonEntropy_SSE2(const int X[256], const int Y[256]) {
  int i;
  double retval = 0.;
@ -301,8 +300,6 @@ static float CombinedShannonEntropy_SSE2(const int X[256], const int Y[256]) {
  retval += VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY);
  return (float)retval;
 }
-#endif  // !(defined(__i386__) || defined(_M_IX86))
-
 #undef ANALYZE_X_OR_Y
 #undef ANALYZE_XY

@ -463,22 +460,20 @@ static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
  (void)upper;
 }

-#define GENERATE_PREDICTOR_1(X, IN)                                         \
-  static void PredictorSub##X##_SSE2(const uint32_t* const in,              \
-                                     const uint32_t* const upper,           \
-                                     int num_pixels, uint32_t* const out) { \
-    int i;                                                                  \
-    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
-      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
-      const __m128i pred = _mm_loadu_si128((const __m128i*)&(IN));          \
-      const __m128i res = _mm_sub_epi8(src, pred);                          \
-      _mm_storeu_si128((__m128i*)&out[i], res);                             \
-    }                                                                       \
-    if (i != num_pixels) {                                                  \
-      VP8LPredictorsSub_C[(X)](in + i, WEBP_OFFSET_PTR(upper, i),           \
-                               num_pixels - i, out + i);                    \
-    }                                                                       \
-  }
+#define GENERATE_PREDICTOR_1(X, IN)                                           \
+static void PredictorSub##X##_SSE2(const uint32_t* in, const uint32_t* upper, \
+                                   int num_pixels, uint32_t* out) {           \
+  int i;                                                                      \
+  for (i = 0; i + 4 <= num_pixels; i += 4) {                                  \
+    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);              \
+    const __m128i pred = _mm_loadu_si128((const __m128i*)&(IN));              \
+    const __m128i res = _mm_sub_epi8(src, pred);                              \
+    _mm_storeu_si128((__m128i*)&out[i], res);                                 \
+  }                                                                           \
+  if (i != num_pixels) {                                                      \
+    VP8LPredictorsSub_C[(X)](in + i, upper + i, num_pixels - i, out + i);     \
+  }                                                                           \
+}

 GENERATE_PREDICTOR_1(1, in[i - 1])       // Predictor1: L
 GENERATE_PREDICTOR_1(2, upper[i])        // Predictor2: T
@ -662,12 +657,7 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {
  VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;
  VP8LAddVector = AddVector_SSE2;
  VP8LAddVectorEq = AddVectorEq_SSE2;
-  // TODO(https://crbug.com/webp/499): this function produces different results
-  // from the C code due to use of double/float resulting in output differences
-  // when compared to -noasm.
-#if !(defined(__i386__) || defined(_M_IX86))
  VP8LCombinedShannonEntropy = CombinedShannonEntropy_SSE2;
-#endif
  VP8LVectorMismatch = VectorMismatch_SSE2;
  VP8LBundleColorMap = BundleColorMap_SSE2;

--- a/src/enc/alpha_enc.c
+++ b/src/enc/alpha_enc.c
@ -13,6 +13,7 @@

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

 #include "src/enc/vp8i_enc.h"
 #include "src/dsp/dsp.h"
@ -148,6 +149,7 @@ 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;
    }
  }
@ -162,7 +164,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;

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

--- a/src/enc/analysis_enc.c
+++ b/src/enc/analysis_enc.c
@ -126,6 +126,16 @@ static void InitHistogram(VP8Histogram* const histo) {
  histo->last_non_zero = 1;
 }

+static void MergeHistograms(const VP8Histogram* const in,
+                            VP8Histogram* const out) {
+  if (in->max_value > out->max_value) {
+    out->max_value = in->max_value;
+  }
+  if (in->last_non_zero > out->last_non_zero) {
+    out->last_non_zero = in->last_non_zero;
+  }
+}
+
 //------------------------------------------------------------------------------
 // Simplified k-Means, to assign Nb segments based on alpha-histogram

@ -275,6 +285,49 @@ static int FastMBAnalyze(VP8EncIterator* const it) {
  return 0;
 }

+static int MBAnalyzeBestIntra4Mode(VP8EncIterator* const it,
+                                   int best_alpha) {
+  uint8_t modes[16];
+  const int max_mode = MAX_INTRA4_MODE;
+  int i4_alpha;
+  VP8Histogram total_histo;
+  int cur_histo = 0;
+  InitHistogram(&total_histo);
+
+  VP8IteratorStartI4(it);
+  do {
+    int mode;
+    int best_mode_alpha = DEFAULT_ALPHA;
+    VP8Histogram histos[2];
+    const uint8_t* const src = it->yuv_in_ + Y_OFF_ENC + VP8Scan[it->i4_];
+
+    VP8MakeIntra4Preds(it);
+    for (mode = 0; mode < max_mode; ++mode) {
+      int alpha;
+
+      InitHistogram(&histos[cur_histo]);
+      VP8CollectHistogram(src, it->yuv_p_ + VP8I4ModeOffsets[mode],
+                          0, 1, &histos[cur_histo]);
+      alpha = GetAlpha(&histos[cur_histo]);
+      if (IS_BETTER_ALPHA(alpha, best_mode_alpha)) {
+        best_mode_alpha = alpha;
+        modes[it->i4_] = mode;
+        cur_histo ^= 1;   // keep track of best histo so far.
+      }
+    }
+    // accumulate best histogram
+    MergeHistograms(&histos[cur_histo ^ 1], &total_histo);
+    // Note: we reuse the original samples for predictors
+  } while (VP8IteratorRotateI4(it, it->yuv_in_ + Y_OFF_ENC));
+
+  i4_alpha = GetAlpha(&total_histo);
+  if (IS_BETTER_ALPHA(i4_alpha, best_alpha)) {
+    VP8SetIntra4Mode(it, modes);
+    best_alpha = i4_alpha;
+  }
+  return best_alpha;
+}
+
 static int MBAnalyzeBestUVMode(VP8EncIterator* const it) {
  int best_alpha = DEFAULT_ALPHA;
  int smallest_alpha = 0;
@ -318,6 +371,13 @@ static void MBAnalyze(VP8EncIterator* const it,
    best_alpha = FastMBAnalyze(it);
  } else {
    best_alpha = MBAnalyzeBestIntra16Mode(it);
+    if (enc->method_ >= 5) {
+      // We go and make a fast decision for intra4/intra16.
+      // It's usually not a good and definitive pick, but helps seeding the
+      // stats about level bit-cost.
+      // TODO(skal): improve criterion.
+      best_alpha = MBAnalyzeBestIntra4Mode(it, best_alpha);
+    }
  }
  best_uv_alpha = MBAnalyzeBestUVMode(it);

--- a/src/enc/backward_references_cost_enc.c
+++ b/src/enc/backward_references_cost_enc.c
@ -577,7 +577,7 @@ static int BackwardReferencesHashChainDistanceOnly(
      (CostModel*)WebPSafeCalloc(1ULL, cost_model_size);
  VP8LColorCache hashers;
  CostManager* cost_manager =
-      (CostManager*)WebPSafeMalloc(1ULL, sizeof(*cost_manager));
+      (CostManager*)WebPSafeCalloc(1ULL, sizeof(*cost_manager));
  int offset_prev = -1, len_prev = -1;
  double offset_cost = -1;
  int first_offset_is_constant = -1;  // initialized with 'impossible' value
--- a/src/enc/backward_references_enc.c
+++ b/src/enc/backward_references_enc.c
@ -11,14 +11,13 @@
 //

 #include <assert.h>
-#include <float.h>
 #include <math.h>

-#include "src/dsp/dsp.h"
-#include "src/dsp/lossless.h"
-#include "src/dsp/lossless_common.h"
 #include "src/enc/backward_references_enc.h"
 #include "src/enc/histogram_enc.h"
+#include "src/dsp/lossless.h"
+#include "src/dsp/lossless_common.h"
+#include "src/dsp/dsp.h"
 #include "src/utils/color_cache_utils.h"
 #include "src/utils/utils.h"

@ -104,20 +103,6 @@ void VP8LBackwardRefsClear(VP8LBackwardRefs* const refs) {
  }
 }

-// Swaps the content of two VP8LBackwardRefs.
-static void BackwardRefsSwap(VP8LBackwardRefs* const refs1,
-                             VP8LBackwardRefs* const refs2) {
-  const int point_to_refs1 =
-      (refs1->tail_ != NULL && refs1->tail_ == &refs1->refs_);
-  const int point_to_refs2 =
-      (refs2->tail_ != NULL && refs2->tail_ == &refs2->refs_);
-  const VP8LBackwardRefs tmp = *refs1;
-  *refs1 = *refs2;
-  *refs2 = tmp;
-  if (point_to_refs2) refs1->tail_ = &refs1->refs_;
-  if (point_to_refs1) refs2->tail_ = &refs2->refs_;
-}
-
 void VP8LBackwardRefsInit(VP8LBackwardRefs* const refs, int block_size) {
  assert(refs != NULL);
  memset(refs, 0, sizeof(*refs));
@ -169,22 +154,6 @@ static PixOrCopyBlock* BackwardRefsNewBlock(VP8LBackwardRefs* const refs) {
  return b;
 }

-// Return 1 on success, 0 on error.
-static int BackwardRefsClone(const VP8LBackwardRefs* const from,
-                             VP8LBackwardRefs* const to) {
-  const PixOrCopyBlock* block_from = from->refs_;
-  VP8LClearBackwardRefs(to);
-  while (block_from != NULL) {
-    PixOrCopyBlock* const block_to = BackwardRefsNewBlock(to);
-    if (block_to == NULL) return 0;
-    memcpy(block_to->start_, block_from->start_,
-           block_from->size_ * sizeof(PixOrCopy));
-    block_to->size_ = block_from->size_;
-    block_from = block_from->next_;
-  }
-  return 1;
-}
-
 extern void VP8LBackwardRefsCursorAdd(VP8LBackwardRefs* const refs,
                                      const PixOrCopy v);
 void VP8LBackwardRefsCursorAdd(VP8LBackwardRefs* const refs,
@ -784,18 +753,12 @@ static int CalculateBestCacheSize(const uint32_t* argb, int quality,
        }
      }
    } else {
-      int code, extra_bits, extra_bits_value;
      // We should compute the contribution of the (distance,length)
      // histograms but those are the same independently from the cache size.
      // As those constant contributions are in the end added to the other
-      // histogram contributions, we can ignore them, except for the length
-      // prefix that is part of the literal_ histogram.
+      // histogram contributions, we can safely ignore them.
      int len = PixOrCopyLength(v);
      uint32_t argb_prev = *argb ^ 0xffffffffu;
-      VP8LPrefixEncode(len, &code, &extra_bits, &extra_bits_value);
-      for (i = 0; i <= cache_bits_max; ++i) {
-        ++histos[i]->literal_[NUM_LITERAL_CODES + code];
-      }
      // Update the color caches.
      do {
        if (*argb != argb_prev) {
@ -879,21 +842,16 @@ extern int VP8LBackwardReferencesTraceBackwards(
    int xsize, int ysize, const uint32_t* const argb, int cache_bits,
    const VP8LHashChain* const hash_chain,
    const VP8LBackwardRefs* const refs_src, VP8LBackwardRefs* const refs_dst);
-static int GetBackwardReferences(int width, int height,
-                                 const uint32_t* const argb, int quality,
-                                 int lz77_types_to_try, int cache_bits_max,
-                                 int do_no_cache,
-                                 const VP8LHashChain* const hash_chain,
-                                 VP8LBackwardRefs* const refs,
-                                 int* const cache_bits_best) {
+static VP8LBackwardRefs* GetBackwardReferences(
+    int width, int height, const uint32_t* const argb, int quality,
+    int lz77_types_to_try, int* const cache_bits,
+    const VP8LHashChain* const hash_chain, VP8LBackwardRefs* best,
+    VP8LBackwardRefs* worst) {
+  const int cache_bits_initial = *cache_bits;
+  double bit_cost_best = -1;
  VP8LHistogram* histo = NULL;
-  int i, lz77_type;
-  // Index 0 is for a color cache, index 1 for no cache (if needed).
-  int lz77_types_best[2] = {0, 0};
-  double bit_costs_best[2] = {DBL_MAX, DBL_MAX};
+  int lz77_type, lz77_type_best = 0;
  VP8LHashChain hash_chain_box;
-  VP8LBackwardRefs* const refs_tmp = &refs[do_no_cache ? 2 : 1];
-  int status = 0;
  memset(&hash_chain_box, 0, sizeof(hash_chain_box));

  histo = VP8LAllocateHistogram(MAX_COLOR_CACHE_BITS);
@ -902,129 +860,87 @@ static int GetBackwardReferences(int width, int height,
  for (lz77_type = 1; lz77_types_to_try;
       lz77_types_to_try &= ~lz77_type, lz77_type <<= 1) {
    int res = 0;
-    double bit_cost = 0.;
+    double bit_cost;
+    int cache_bits_tmp = cache_bits_initial;
    if ((lz77_types_to_try & lz77_type) == 0) continue;
    switch (lz77_type) {
      case kLZ77RLE:
-        res = BackwardReferencesRle(width, height, argb, 0, refs_tmp);
+        res = BackwardReferencesRle(width, height, argb, 0, worst);
        break;
      case kLZ77Standard:
        // Compute LZ77 with no cache (0 bits), as the ideal LZ77 with a color
        // cache is not that different in practice.
-        res = BackwardReferencesLz77(width, height, argb, 0, hash_chain,
-                                     refs_tmp);
+        res = BackwardReferencesLz77(width, height, argb, 0, hash_chain, worst);
        break;
      case kLZ77Box:
        if (!VP8LHashChainInit(&hash_chain_box, width * height)) goto Error;
        res = BackwardReferencesLz77Box(width, height, argb, 0, hash_chain,
-                                        &hash_chain_box, refs_tmp);
+                                        &hash_chain_box, worst);
        break;
      default:
        assert(0);
    }
    if (!res) goto Error;

-    // Start with the no color cache case.
-    for (i = 1; i >= 0; --i) {
-      int cache_bits = (i == 1) ? 0 : cache_bits_max;
-
-      if (i == 1 && !do_no_cache) continue;
-
-      if (i == 0) {
-        // Try with a color cache.
-        if (!CalculateBestCacheSize(argb, quality, refs_tmp, &cache_bits)) {
-          goto Error;
-        }
-        if (cache_bits > 0) {
-          if (!BackwardRefsWithLocalCache(argb, cache_bits, refs_tmp)) {
-            goto Error;
-          }
-        }
-      }
-
-      if (i == 0 && do_no_cache && cache_bits == 0) {
-        // No need to re-compute bit_cost as it was computed at i == 1.
-      } else {
-        VP8LHistogramCreate(histo, refs_tmp, cache_bits);
-        bit_cost = VP8LHistogramEstimateBits(histo);
-      }
-
-      if (bit_cost < bit_costs_best[i]) {
-        if (i == 1) {
-          // Do not swap as the full cache analysis would have the wrong
-          // VP8LBackwardRefs to start with.
-          if (!BackwardRefsClone(refs_tmp, &refs[1])) goto Error;
-        } else {
-          BackwardRefsSwap(refs_tmp, &refs[0]);
-        }
-        bit_costs_best[i] = bit_cost;
-        lz77_types_best[i] = lz77_type;
-        if (i == 0) *cache_bits_best = cache_bits;
+    // Next, try with a color cache and update the references.
+    if (!CalculateBestCacheSize(argb, quality, worst, &cache_bits_tmp)) {
+      goto Error;
+    }
+    if (cache_bits_tmp > 0) {
+      if (!BackwardRefsWithLocalCache(argb, cache_bits_tmp, worst)) {
+        goto Error;
      }
    }
+
+    // Keep the best backward references.
+    VP8LHistogramCreate(histo, worst, cache_bits_tmp);
+    bit_cost = VP8LHistogramEstimateBits(histo);
+    if (lz77_type_best == 0 || bit_cost < bit_cost_best) {
+      VP8LBackwardRefs* const tmp = worst;
+      worst = best;
+      best = tmp;
+      bit_cost_best = bit_cost;
+      *cache_bits = cache_bits_tmp;
+      lz77_type_best = lz77_type;
+    }
  }
-  assert(lz77_types_best[0] > 0);
-  assert(!do_no_cache || lz77_types_best[1] > 0);
+  assert(lz77_type_best > 0);

  // Improve on simple LZ77 but only for high quality (TraceBackwards is
  // costly).
-  for (i = 1; i >= 0; --i) {
-    if (i == 1 && !do_no_cache) continue;
-    if ((lz77_types_best[i] == kLZ77Standard ||
-         lz77_types_best[i] == kLZ77Box) &&
-        quality >= 25) {
-      const VP8LHashChain* const hash_chain_tmp =
-          (lz77_types_best[i] == kLZ77Standard) ? hash_chain : &hash_chain_box;
-      const int cache_bits = (i == 1) ? 0 : *cache_bits_best;
-      if (VP8LBackwardReferencesTraceBackwards(width, height, argb, cache_bits,
-                                               hash_chain_tmp, &refs[i],
-                                               refs_tmp)) {
-        double bit_cost_trace;
-        VP8LHistogramCreate(histo, refs_tmp, cache_bits);
-        bit_cost_trace = VP8LHistogramEstimateBits(histo);
-        if (bit_cost_trace < bit_costs_best[i]) {
-          BackwardRefsSwap(refs_tmp, &refs[i]);
-        }
-      }
-    }
-
-    BackwardReferences2DLocality(width, &refs[i]);
-
-    if (i == 1 && lz77_types_best[0] == lz77_types_best[1] &&
-        *cache_bits_best == 0) {
-      // If the best cache size is 0 and we have the same best LZ77, just copy
-      // the data over and stop here.
-      if (!BackwardRefsClone(&refs[1], &refs[0])) goto Error;
-      break;
+  if ((lz77_type_best == kLZ77Standard || lz77_type_best == kLZ77Box) &&
+      quality >= 25) {
+    const VP8LHashChain* const hash_chain_tmp =
+        (lz77_type_best == kLZ77Standard) ? hash_chain : &hash_chain_box;
+    double bit_cost_trace;
+    if (!VP8LBackwardReferencesTraceBackwards(width, height, argb, *cache_bits,
+                                              hash_chain_tmp, best, worst)) {
+      goto Error;
    }
+    VP8LHistogramCreate(histo, worst, *cache_bits);
+    bit_cost_trace = VP8LHistogramEstimateBits(histo);
+    if (bit_cost_trace < bit_cost_best) best = worst;
  }
-  status = 1;
+
+  BackwardReferences2DLocality(width, best);

 Error:
  VP8LHashChainClear(&hash_chain_box);
  VP8LFreeHistogram(histo);
-  return status;
+  return best;
 }

-WebPEncodingError VP8LGetBackwardReferences(
+VP8LBackwardRefs* VP8LGetBackwardReferences(
    int width, int height, const uint32_t* const argb, int quality,
-    int low_effort, int lz77_types_to_try, int cache_bits_max, int do_no_cache,
-    const VP8LHashChain* const hash_chain, VP8LBackwardRefs* const refs,
-    int* const cache_bits_best) {
+    int low_effort, int lz77_types_to_try, int* const cache_bits,
+    const VP8LHashChain* const hash_chain, VP8LBackwardRefs* const refs_tmp1,
+    VP8LBackwardRefs* const refs_tmp2) {
  if (low_effort) {
-    VP8LBackwardRefs* refs_best;
-    *cache_bits_best = cache_bits_max;
-    refs_best = GetBackwardReferencesLowEffort(
-        width, height, argb, cache_bits_best, hash_chain, refs);
-    if (refs_best == NULL) return VP8_ENC_ERROR_OUT_OF_MEMORY;
-    // Set it in first position.
-    BackwardRefsSwap(refs_best, &refs[0]);
+    return GetBackwardReferencesLowEffort(width, height, argb, cache_bits,
+                                          hash_chain, refs_tmp1);
  } else {
-    if (!GetBackwardReferences(width, height, argb, quality, lz77_types_to_try,
-                               cache_bits_max, do_no_cache, hash_chain, refs,
-                               cache_bits_best)) {
-      return VP8_ENC_ERROR_OUT_OF_MEMORY;
-    }
+    return GetBackwardReferences(width, height, argb, quality,
+                                 lz77_types_to_try, cache_bits, hash_chain,
+                                 refs_tmp1, refs_tmp2);
  }
-  return VP8_ENC_OK;
 }
--- a/src/enc/backward_references_enc.h
+++ b/src/enc/backward_references_enc.h
@ -16,7 +16,6 @@
 #include <assert.h>
 #include <stdlib.h>
 #include "src/webp/types.h"
-#include "src/webp/encode.h"
 #include "src/webp/format_constants.h"

 #ifdef __cplusplus
@ -219,19 +218,14 @@ enum VP8LLZ77Type {
 // Evaluates best possible backward references for specified quality.
 // The input cache_bits to 'VP8LGetBackwardReferences' sets the maximum cache
 // bits to use (passing 0 implies disabling the local color cache).
-// The optimal cache bits is evaluated and set for the *cache_bits_best
-// parameter with the matching refs_best.
-// If do_no_cache == 0, refs is an array of 2 values and the best
-// VP8LBackwardRefs is put in the first element.
-// If do_no_cache != 0, refs is an array of 3 values and the best
-// VP8LBackwardRefs is put in the first element, the best value with no-cache in
-// the second element.
-// In both cases, the last element is used as temporary internally.
-WebPEncodingError VP8LGetBackwardReferences(
+// The optimal cache bits is evaluated and set for the *cache_bits parameter.
+// The return value is the pointer to the best of the two backward refs viz,
+// refs[0] or refs[1].
+VP8LBackwardRefs* VP8LGetBackwardReferences(
    int width, int height, const uint32_t* const argb, int quality,
-    int low_effort, int lz77_types_to_try, int cache_bits_max, int do_no_cache,
-    const VP8LHashChain* const hash_chain, VP8LBackwardRefs* const refs,
-    int* const cache_bits_best);
+    int low_effort, int lz77_types_to_try, int* const cache_bits,
+    const VP8LHashChain* const hash_chain, VP8LBackwardRefs* const refs_tmp1,
+    VP8LBackwardRefs* const refs_tmp2);

 #ifdef __cplusplus
 }
--- a/src/enc/config_enc.c
+++ b/src/enc/config_enc.c
@ -39,8 +39,6 @@ int WebPConfigInitInternal(WebPConfig* config,
  config->partitions = 0;
  config->segments = 4;
  config->pass = 1;
-  config->qmin = 0;
-  config->qmax = 100;
  config->show_compressed = 0;
  config->preprocessing = 0;
  config->autofilter = 0;
@ -108,9 +106,6 @@ int WebPValidateConfig(const WebPConfig* config) {
  if (config->filter_type < 0 || config->filter_type > 1) return 0;
  if (config->autofilter < 0 || config->autofilter > 1) return 0;
  if (config->pass < 1 || config->pass > 10) return 0;
-  if (config->qmin < 0 || config->qmax > 100 || config->qmin > config->qmax) {
-    return 0;
-  }
  if (config->show_compressed < 0 || config->show_compressed > 1) return 0;
  if (config->preprocessing < 0 || config->preprocessing > 7) return 0;
  if (config->partitions < 0 || config->partitions > 3) return 0;
--- a/src/enc/frame_enc.c
+++ b/src/enc/frame_enc.c
@ -31,15 +31,10 @@
 // we allow 2k of extra head-room in PARTITION0 limit.
 #define PARTITION0_SIZE_LIMIT ((VP8_MAX_PARTITION0_SIZE - 2048ULL) << 11)

-static float Clamp(float v, float min, float max) {
-  return (v < min) ? min : (v > max) ? max : v;
-}
-
 typedef struct {  // struct for organizing convergence in either size or PSNR
  int is_first;
  float dq;
  float q, last_q;
-  float qmin, qmax;
  double value, last_value;   // PSNR or size
  double target;
  int do_size_search;
@ -52,9 +47,7 @@ static int InitPassStats(const VP8Encoder* const enc, PassStats* const s) {

  s->is_first = 1;
  s->dq = 10.f;
-  s->qmin = 1.f * enc->config_->qmin;
-  s->qmax = 1.f * enc->config_->qmax;
-  s->q = s->last_q = Clamp(enc->config_->quality, s->qmin, s->qmax);
+  s->q = s->last_q = enc->config_->quality;
  s->target = do_size_search ? (double)target_size
            : (target_PSNR > 0.) ? target_PSNR
            : 40.;   // default, just in case
@ -63,6 +56,10 @@ static int InitPassStats(const VP8Encoder* const enc, PassStats* const s) {
  return do_size_search;
 }

+static float Clamp(float v, float min, float max) {
+  return (v < min) ? min : (v > max) ? max : v;
+}
+
 static float ComputeNextQ(PassStats* const s) {
  float dq;
  if (s->is_first) {
@ -78,7 +75,7 @@ static float ComputeNextQ(PassStats* const s) {
  s->dq = Clamp(dq, -30.f, 30.f);
  s->last_q = s->q;
  s->last_value = s->value;
-  s->q = Clamp(s->q + s->dq, s->qmin, s->qmax);
+  s->q = Clamp(s->q + s->dq, 0.f, 100.f);
  return s->q;
 }

@ -851,10 +848,9 @@ int VP8EncTokenLoop(VP8Encoder* const enc) {
    }

 #if (DEBUG_SEARCH > 0)
-    printf("#%2d metric:%.1lf -> %.1lf   last_q=%.2lf q=%.2lf dq=%.2lf "
-           " range:[%.1f, %.1f]\n",
+    printf("#%2d metric:%.1lf -> %.1lf   last_q=%.2lf q=%.2lf dq=%.2lf\n",
           num_pass_left, stats.last_value, stats.value,
-           stats.last_q, stats.q, stats.dq, stats.qmin, stats.qmax);
+           stats.last_q, stats.q, stats.dq);
 #endif
    if (enc->max_i4_header_bits_ > 0 && size_p0 > PARTITION0_SIZE_LIMIT) {
      ++num_pass_left;
--- a/src/enc/histogram_enc.c
+++ b/src/enc/histogram_enc.c
@ -208,7 +208,6 @@ void VP8LHistogramAddSinglePixOrCopy(VP8LHistogram* const histo,
  } else if (PixOrCopyIsCacheIdx(v)) {
    const int literal_ix =
        NUM_LITERAL_CODES + NUM_LENGTH_CODES + PixOrCopyCacheIdx(v);
-    assert(histo->palette_code_bits_ != 0);
    ++histo->literal_[literal_ix];
  } else {
    int code, extra_bits;
--- a/src/enc/picture_csp_enc.c
+++ b/src/enc/picture_csp_enc.c
@ -61,14 +61,16 @@ static int CheckNonOpaque(const uint8_t* alpha, int width, int height,
 // Checking for the presence of non-opaque alpha.
 int WebPPictureHasTransparency(const WebPPicture* picture) {
  if (picture == NULL) return 0;
-  if (picture->use_argb) {
+  if (!picture->use_argb) {
+    return CheckNonOpaque(picture->a, picture->width, picture->height,
+                          1, picture->a_stride);
+  } else {
    const int alpha_offset = ALPHA_OFFSET;
    return CheckNonOpaque((const uint8_t*)picture->argb + alpha_offset,
                          picture->width, picture->height,
                          4, picture->argb_stride * sizeof(*picture->argb));
  }
-  return CheckNonOpaque(picture->a, picture->width, picture->height,
-                        1, picture->a_stride);
+  return 0;
 }

 //------------------------------------------------------------------------------
@ -88,9 +90,8 @@ int WebPPictureHasTransparency(const WebPPicture* picture) {
 static int kLinearToGammaTab[kGammaTabSize + 1];
 static uint16_t kGammaToLinearTab[256];
 static volatile int kGammaTablesOk = 0;
-static void InitGammaTables(void);

-WEBP_DSP_INIT_FUNC(InitGammaTables) {
+static WEBP_TSAN_IGNORE_FUNCTION void InitGammaTables(void) {
  if (!kGammaTablesOk) {
    int v;
    const double scale = (double)(1 << kGammaTabFix) / kGammaScale;
@ -180,9 +181,8 @@ static uint32_t kLinearToGammaTabS[kGammaTabSize + 2];
 #define GAMMA_TO_LINEAR_BITS 14
 static uint32_t kGammaToLinearTabS[MAX_Y_T + 1];   // size scales with Y_FIX
 static volatile int kGammaTablesSOk = 0;
-static void InitGammaTablesS(void);

-WEBP_DSP_INIT_FUNC(InitGammaTablesS) {
+static WEBP_TSAN_IGNORE_FUNCTION void InitGammaTablesS(void) {
  assert(2 * GAMMA_TO_LINEAR_BITS < 32);  // we use uint32_t intermediate values
  if (!kGammaTablesSOk) {
    int v;
--- a/src/enc/picture_tools_enc.c
+++ b/src/enc/picture_tools_enc.c
@ -83,19 +83,6 @@ static int SmoothenBlock(const uint8_t* a_ptr, int a_stride, uint8_t* y_ptr,
  return (count == 0);
 }

-void WebPReplaceTransparentPixels(WebPPicture* const pic, uint32_t color) {
-  if (pic != NULL && pic->use_argb) {
-    int y = pic->height;
-    uint32_t* argb = pic->argb;
-    color &= 0xffffffu;   // force alpha=0
-    WebPInitAlphaProcessing();
-    while (y-- > 0) {
-      WebPAlphaReplace(argb, pic->width, color);
-      argb += pic->argb_stride;
-    }
-  }
-}
-
 void WebPCleanupTransparentArea(WebPPicture* pic) {
  int x, y, w, h;
  if (pic == NULL) return;
@ -178,6 +165,24 @@ void WebPCleanupTransparentArea(WebPPicture* pic) {
 #undef SIZE
 #undef SIZE2

+void WebPCleanupTransparentAreaLossless(WebPPicture* const pic) {
+  int x, y, w, h;
+  uint32_t* argb;
+  assert(pic != NULL && pic->use_argb);
+  w = pic->width;
+  h = pic->height;
+  argb = pic->argb;
+
+  for (y = 0; y < h; ++y) {
+    for (x = 0; x < w; ++x) {
+      if ((argb[x] & 0xff000000) == 0) {
+        argb[x] = 0x00000000;
+      }
+    }
+    argb += pic->argb_stride;
+  }
+}
+
 //------------------------------------------------------------------------------
 // Blend color and remove transparency info

--- a/src/enc/vp8i_enc.h
+++ b/src/enc/vp8i_enc.h
@ -31,7 +31,7 @@ extern "C" {

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

 enum { MAX_LF_LEVELS = 64,       // Maximum loop filter level
@ -505,9 +505,9 @@ int WebPPictureAllocARGB(WebPPicture* const picture, int width, int height);
 // Returns false in case of error (invalid param, out-of-memory).
 int WebPPictureAllocYUVA(WebPPicture* const picture, int width, int height);

-// Replace samples that are fully transparent by 'color' to help compressibility
-// (no guarantee, though). Assumes pic->use_argb is true.
-void WebPReplaceTransparentPixels(WebPPicture* const pic, uint32_t color);
+// Clean-up the RGB samples under fully transparent area, to help lossless
+// compressibility (no guarantee, though). Assumes that pic->use_argb is true.
+void WebPCleanupTransparentAreaLossless(WebPPicture* const pic);

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

--- a/src/enc/vp8l_enc.c
+++ b/src/enc/vp8l_enc.c
@ -144,8 +144,7 @@ typedef enum {
  kSubGreen = 2,
  kSpatialSubGreen = 3,
  kPalette = 4,
-  kPaletteAndSpatial = 5,
-  kNumEntropyIx = 6
+  kNumEntropyIx = 5
 } EntropyIx;

 typedef enum {
@ -355,15 +354,11 @@ static int GetTransformBits(int method, int histo_bits) {
 }

 // Set of parameters to be used in each iteration of the cruncher.
-#define CRUNCH_SUBCONFIGS_MAX 2
-typedef struct {
-  int lz77_;
-  int do_no_cache_;
-} CrunchSubConfig;
+#define CRUNCH_CONFIGS_LZ77_MAX 2
 typedef struct {
  int entropy_idx_;
-  CrunchSubConfig sub_configs_[CRUNCH_SUBCONFIGS_MAX];
-  int sub_configs_size_;
+  int lz77s_types_to_try_[CRUNCH_CONFIGS_LZ77_MAX];
+  int lz77s_types_to_try_size_;
 } CrunchConfig;

 #define CRUNCH_CONFIGS_MAX kNumEntropyIx
@ -381,9 +376,6 @@ static int EncoderAnalyze(VP8LEncoder* const enc,
  int i;
  int use_palette;
  int n_lz77s;
-  // If set to 0, analyze the cache with the computed cache value. If 1, also
-  // analyze with no-cache.
-  int do_no_cache = 0;
  assert(pic != NULL && pic->argb != NULL);

  use_palette =
@ -410,13 +402,10 @@ static int EncoderAnalyze(VP8LEncoder* const enc,
      return 0;
    }
    if (method == 6 && config->quality == 100) {
-      do_no_cache = 1;
      // Go brute force on all transforms.
      *crunch_configs_size = 0;
      for (i = 0; i < kNumEntropyIx; ++i) {
-        // We can only apply kPalette or kPaletteAndSpatial if we can indeed use
-        // a palette.
-        if ((i != kPalette && i != kPaletteAndSpatial) || use_palette) {
+        if (i != kPalette || use_palette) {
          assert(*crunch_configs_size < CRUNCH_CONFIGS_MAX);
          crunch_configs[(*crunch_configs_size)++].entropy_idx_ = i;
        }
@ -425,28 +414,17 @@ static int EncoderAnalyze(VP8LEncoder* const enc,
      // Only choose the guessed best transform.
      *crunch_configs_size = 1;
      crunch_configs[0].entropy_idx_ = min_entropy_ix;
-      if (config->quality >= 75 && method == 5) {
-        // Test with and without color cache.
-        do_no_cache = 1;
-        // If we have a palette, also check in combination with spatial.
-        if (min_entropy_ix == kPalette) {
-          *crunch_configs_size = 2;
-          crunch_configs[1].entropy_idx_ = kPaletteAndSpatial;
-        }
-      }
    }
  }
  // Fill in the different LZ77s.
-  assert(n_lz77s <= CRUNCH_SUBCONFIGS_MAX);
+  assert(n_lz77s <= CRUNCH_CONFIGS_LZ77_MAX);
  for (i = 0; i < *crunch_configs_size; ++i) {
    int j;
    for (j = 0; j < n_lz77s; ++j) {
-      assert(j < CRUNCH_SUBCONFIGS_MAX);
-      crunch_configs[i].sub_configs_[j].lz77_ =
+      crunch_configs[i].lz77s_types_to_try_[j] =
          (j == 0) ? kLZ77Standard | kLZ77RLE : kLZ77Box;
-      crunch_configs[i].sub_configs_[j].do_no_cache_ = do_no_cache;
    }
-    crunch_configs[i].sub_configs_size_ = n_lz77s;
+    crunch_configs[i].lz77s_types_to_try_size_ = n_lz77s;
  }
  return 1;
 }
@ -462,7 +440,7 @@ static int EncoderInit(VP8LEncoder* const enc) {
  int i;
  if (!VP8LHashChainInit(&enc->hash_chain_, pix_cnt)) return 0;

-  for (i = 0; i < 4; ++i) VP8LBackwardRefsInit(&enc->refs_[i], refs_block_size);
+  for (i = 0; i < 3; ++i) VP8LBackwardRefsInit(&enc->refs_[i], refs_block_size);

  return 1;
 }
@ -791,10 +769,13 @@ static WebPEncodingError StoreImageToBitMask(
 }

 // Special case of EncodeImageInternal() for cache-bits=0, histo_bits=31
-static WebPEncodingError EncodeImageNoHuffman(
-    VP8LBitWriter* const bw, const uint32_t* const argb,
-    VP8LHashChain* const hash_chain, VP8LBackwardRefs* const refs_array,
-    int width, int height, int quality, int low_effort) {
+static WebPEncodingError EncodeImageNoHuffman(VP8LBitWriter* const bw,
+                                              const uint32_t* const argb,
+                                              VP8LHashChain* const hash_chain,
+                                              VP8LBackwardRefs* const refs_tmp1,
+                                              VP8LBackwardRefs* const refs_tmp2,
+                                              int width, int height,
+                                              int quality, int low_effort) {
  int i;
  int max_tokens = 0;
  WebPEncodingError err = VP8_ENC_OK;
@ -817,11 +798,13 @@ static WebPEncodingError EncodeImageNoHuffman(
    err = VP8_ENC_ERROR_OUT_OF_MEMORY;
    goto Error;
  }
-  err = VP8LGetBackwardReferences(
-      width, height, argb, quality, /*low_effort=*/0, kLZ77Standard | kLZ77RLE,
-      cache_bits, /*do_no_cache=*/0, hash_chain, refs_array, &cache_bits);
-  if (err != VP8_ENC_OK) goto Error;
-  refs = &refs_array[0];
+  refs = VP8LGetBackwardReferences(width, height, argb, quality, 0,
+                                   kLZ77Standard | kLZ77RLE, &cache_bits,
+                                   hash_chain, refs_tmp1, refs_tmp2);
+  if (refs == NULL) {
+    err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+    goto Error;
+  }
  histogram_image = VP8LAllocateHistogramSet(1, cache_bits);
  if (histogram_image == NULL) {
    err = VP8_ENC_ERROR_OUT_OF_MEMORY;
@ -877,11 +860,11 @@ static WebPEncodingError EncodeImageNoHuffman(

 static WebPEncodingError EncodeImageInternal(
    VP8LBitWriter* const bw, const uint32_t* const argb,
-    VP8LHashChain* const hash_chain, VP8LBackwardRefs refs_array[4], int width,
+    VP8LHashChain* const hash_chain, VP8LBackwardRefs refs_array[3], int width,
    int height, int quality, int low_effort, int use_cache,
    const CrunchConfig* const config, int* cache_bits, int histogram_bits,
    size_t init_byte_position, int* const hdr_size, int* const data_size) {
-  WebPEncodingError err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+  WebPEncodingError err = VP8_ENC_OK;
  const uint32_t histogram_image_xysize =
      VP8LSubSampleSize(width, histogram_bits) *
      VP8LSubSampleSize(height, histogram_bits);
@ -893,103 +876,103 @@ static WebPEncodingError EncodeImageInternal(
      3ULL * CODE_LENGTH_CODES, sizeof(*huff_tree));
  HuffmanTreeToken* tokens = NULL;
  HuffmanTreeCode* huffman_codes = NULL;
+  VP8LBackwardRefs* refs_best;
+  VP8LBackwardRefs* refs_tmp;
  uint16_t* const histogram_symbols =
      (uint16_t*)WebPSafeMalloc(histogram_image_xysize,
                                sizeof(*histogram_symbols));
-  int sub_configs_idx;
-  int cache_bits_init, write_histogram_image;
+  int lz77s_idx;
  VP8LBitWriter bw_init = *bw, bw_best;
  int hdr_size_tmp;
-  VP8LHashChain hash_chain_histogram;  // histogram image hash chain
-  size_t bw_size_best = ~(size_t)0;
  assert(histogram_bits >= MIN_HUFFMAN_BITS);
  assert(histogram_bits <= MAX_HUFFMAN_BITS);
  assert(hdr_size != NULL);
  assert(data_size != NULL);

-  // Make sure we can allocate the different objects.
-  memset(&hash_chain_histogram, 0, sizeof(hash_chain_histogram));
-  if (huff_tree == NULL || histogram_symbols == NULL ||
-      !VP8LHashChainInit(&hash_chain_histogram, histogram_image_xysize) ||
-      !VP8LHashChainFill(hash_chain, quality, argb, width, height,
-                         low_effort)) {
+  if (histogram_symbols == NULL) {
+    err = VP8_ENC_ERROR_OUT_OF_MEMORY;
    goto Error;
  }
+
  if (use_cache) {
    // If the value is different from zero, it has been set during the
    // palette analysis.
-    cache_bits_init = (*cache_bits == 0) ? MAX_COLOR_CACHE_BITS : *cache_bits;
+    if (*cache_bits == 0) *cache_bits = MAX_COLOR_CACHE_BITS;
  } else {
-    cache_bits_init = 0;
+    *cache_bits = 0;
  }
-  // If several iterations will happen, clone into bw_best.
-  if (!VP8LBitWriterInit(&bw_best, 0) ||
-      ((config->sub_configs_size_ > 1 ||
-        config->sub_configs_[0].do_no_cache_) &&
+  // 'best_refs' is the reference to the best backward refs and points to one
+  // of refs_array[0] or refs_array[1].
+  // Calculate backward references from ARGB image.
+  if (huff_tree == NULL ||
+      !VP8LHashChainFill(hash_chain, quality, argb, width, height,
+                         low_effort) ||
+      !VP8LBitWriterInit(&bw_best, 0) ||
+      (config->lz77s_types_to_try_size_ > 1 &&
       !VP8LBitWriterClone(bw, &bw_best))) {
+    err = VP8_ENC_ERROR_OUT_OF_MEMORY;
    goto Error;
  }
-  for (sub_configs_idx = 0; sub_configs_idx < config->sub_configs_size_;
-       ++sub_configs_idx) {
-    const CrunchSubConfig* const sub_config =
-        &config->sub_configs_[sub_configs_idx];
-    int cache_bits_best, i_cache;
-    err = VP8LGetBackwardReferences(width, height, argb, quality, low_effort,
-                                    sub_config->lz77_, cache_bits_init,
-                                    sub_config->do_no_cache_, hash_chain,
-                                    &refs_array[0], &cache_bits_best);
-    if (err != VP8_ENC_OK) goto Error;
+  for (lz77s_idx = 0; lz77s_idx < config->lz77s_types_to_try_size_;
+       ++lz77s_idx) {
+    refs_best = VP8LGetBackwardReferences(
+        width, height, argb, quality, low_effort,
+        config->lz77s_types_to_try_[lz77s_idx], cache_bits, hash_chain,
+        &refs_array[0], &refs_array[1]);
+    if (refs_best == NULL) {
+      err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+      goto Error;
+    }
+    // Keep the best references aside and use the other element from the first
+    // two as a temporary for later usage.
+    refs_tmp = &refs_array[refs_best == &refs_array[0] ? 1 : 0];

-    for (i_cache = 0; i_cache < (sub_config->do_no_cache_ ? 2 : 1); ++i_cache) {
-      const int cache_bits_tmp = (i_cache == 0) ? cache_bits_best : 0;
-      // Speed-up: no need to study the no-cache case if it was already studied
-      // in i_cache == 0.
-      if (i_cache == 1 && cache_bits_best == 0) break;
+    histogram_image =
+        VP8LAllocateHistogramSet(histogram_image_xysize, *cache_bits);
+    tmp_histo = VP8LAllocateHistogram(*cache_bits);
+    if (histogram_image == NULL || tmp_histo == NULL) {
+      err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+      goto Error;
+    }

-      // Reset the bit writer for this iteration.
-      VP8LBitWriterReset(&bw_init, bw);
+    // Build histogram image and symbols from backward references.
+    if (!VP8LGetHistoImageSymbols(width, height, refs_best, quality, low_effort,
+                                  histogram_bits, *cache_bits, histogram_image,
+                                  tmp_histo, histogram_symbols)) {
+      err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+      goto Error;
+    }
+    // Create Huffman bit lengths and codes for each histogram image.
+    histogram_image_size = histogram_image->size;
+    bit_array_size = 5 * histogram_image_size;
+    huffman_codes = (HuffmanTreeCode*)WebPSafeCalloc(bit_array_size,
+                                                     sizeof(*huffman_codes));
+    // Note: some histogram_image entries may point to tmp_histos[], so the
+    // latter need to outlive the following call to GetHuffBitLengthsAndCodes().
+    if (huffman_codes == NULL ||
+        !GetHuffBitLengthsAndCodes(histogram_image, huffman_codes)) {
+      err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+      goto Error;
+    }
+    // Free combined histograms.
+    VP8LFreeHistogramSet(histogram_image);
+    histogram_image = NULL;

-      // Build histogram image and symbols from backward references.
-      histogram_image =
-          VP8LAllocateHistogramSet(histogram_image_xysize, cache_bits_tmp);
-      tmp_histo = VP8LAllocateHistogram(cache_bits_tmp);
-      if (histogram_image == NULL || tmp_histo == NULL ||
-          !VP8LGetHistoImageSymbols(width, height, &refs_array[i_cache],
-                                    quality, low_effort, histogram_bits,
-                                    cache_bits_tmp, histogram_image, tmp_histo,
-                                    histogram_symbols)) {
-        goto Error;
-      }
-      // Create Huffman bit lengths and codes for each histogram image.
-      histogram_image_size = histogram_image->size;
-      bit_array_size = 5 * histogram_image_size;
-      huffman_codes = (HuffmanTreeCode*)WebPSafeCalloc(bit_array_size,
-                                                       sizeof(*huffman_codes));
-      // Note: some histogram_image entries may point to tmp_histos[], so the
-      // latter need to outlive the following call to
-      // GetHuffBitLengthsAndCodes().
-      if (huffman_codes == NULL ||
-          !GetHuffBitLengthsAndCodes(histogram_image, huffman_codes)) {
-        goto Error;
-      }
-      // Free combined histograms.
-      VP8LFreeHistogramSet(histogram_image);
-      histogram_image = NULL;
+    // Free scratch histograms.
+    VP8LFreeHistogram(tmp_histo);
+    tmp_histo = NULL;

-      // Free scratch histograms.
-      VP8LFreeHistogram(tmp_histo);
-      tmp_histo = NULL;
+    // Color Cache parameters.
+    if (*cache_bits > 0) {
+      VP8LPutBits(bw, 1, 1);
+      VP8LPutBits(bw, *cache_bits, 4);
+    } else {
+      VP8LPutBits(bw, 0, 1);
+    }

-      // Color Cache parameters.
-      if (cache_bits_tmp > 0) {
-        VP8LPutBits(bw, 1, 1);
-        VP8LPutBits(bw, cache_bits_tmp, 4);
-      } else {
-        VP8LPutBits(bw, 0, 1);
-      }
-
-      // Huffman image + meta huffman.
-      write_histogram_image = (histogram_image_size > 1);
+    // Huffman image + meta huffman.
+    {
+      const int write_histogram_image = (histogram_image_size > 1);
      VP8LPutBits(bw, write_histogram_image, 1);
      if (write_histogram_image) {
        uint32_t* const histogram_argb =
@ -997,7 +980,10 @@ static WebPEncodingError EncodeImageInternal(
                                      sizeof(*histogram_argb));
        int max_index = 0;
        uint32_t i;
-        if (histogram_argb == NULL) goto Error;
+        if (histogram_argb == NULL) {
+          err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+          goto Error;
+        }
        for (i = 0; i < histogram_image_xysize; ++i) {
          const int symbol_index = histogram_symbols[i] & 0xffff;
          histogram_argb[i] = (symbol_index << 8);
@ -1009,64 +995,65 @@ static WebPEncodingError EncodeImageInternal(

        VP8LPutBits(bw, histogram_bits - 2, 3);
        err = EncodeImageNoHuffman(
-            bw, histogram_argb, &hash_chain_histogram, &refs_array[2],
+            bw, histogram_argb, hash_chain, refs_tmp, &refs_array[2],
            VP8LSubSampleSize(width, histogram_bits),
            VP8LSubSampleSize(height, histogram_bits), quality, low_effort);
        WebPSafeFree(histogram_argb);
        if (err != VP8_ENC_OK) goto Error;
      }
+    }

-      // Store Huffman codes.
-      {
-        int i;
-        int max_tokens = 0;
-        // Find maximum number of symbols for the huffman tree-set.
-        for (i = 0; i < 5 * histogram_image_size; ++i) {
-          HuffmanTreeCode* const codes = &huffman_codes[i];
-          if (max_tokens < codes->num_symbols) {
-            max_tokens = codes->num_symbols;
-          }
-        }
-        tokens = (HuffmanTreeToken*)WebPSafeMalloc(max_tokens, sizeof(*tokens));
-        if (tokens == NULL) goto Error;
-        for (i = 0; i < 5 * histogram_image_size; ++i) {
-          HuffmanTreeCode* const codes = &huffman_codes[i];
-          StoreHuffmanCode(bw, huff_tree, tokens, codes);
-          ClearHuffmanTreeIfOnlyOneSymbol(codes);
+    // Store Huffman codes.
+    {
+      int i;
+      int max_tokens = 0;
+      // Find maximum number of symbols for the huffman tree-set.
+      for (i = 0; i < 5 * histogram_image_size; ++i) {
+        HuffmanTreeCode* const codes = &huffman_codes[i];
+        if (max_tokens < codes->num_symbols) {
+          max_tokens = codes->num_symbols;
        }
      }
-      // Store actual literals.
-      hdr_size_tmp = (int)(VP8LBitWriterNumBytes(bw) - init_byte_position);
-      err = StoreImageToBitMask(bw, width, histogram_bits, &refs_array[i_cache],
-                                histogram_symbols, huffman_codes);
-      if (err != VP8_ENC_OK) goto Error;
-      // Keep track of the smallest image so far.
-      if (VP8LBitWriterNumBytes(bw) < bw_size_best) {
-        bw_size_best = VP8LBitWriterNumBytes(bw);
-        *cache_bits = cache_bits_tmp;
-        *hdr_size = hdr_size_tmp;
-        *data_size =
-            (int)(VP8LBitWriterNumBytes(bw) - init_byte_position - *hdr_size);
-        VP8LBitWriterSwap(bw, &bw_best);
+      tokens = (HuffmanTreeToken*)WebPSafeMalloc(max_tokens, sizeof(*tokens));
+      if (tokens == NULL) {
+        err = VP8_ENC_ERROR_OUT_OF_MEMORY;
+        goto Error;
      }
-      WebPSafeFree(tokens);
-      tokens = NULL;
-      if (huffman_codes != NULL) {
-        WebPSafeFree(huffman_codes->codes);
-        WebPSafeFree(huffman_codes);
-        huffman_codes = NULL;
+      for (i = 0; i < 5 * histogram_image_size; ++i) {
+        HuffmanTreeCode* const codes = &huffman_codes[i];
+        StoreHuffmanCode(bw, huff_tree, tokens, codes);
+        ClearHuffmanTreeIfOnlyOneSymbol(codes);
      }
    }
+    // Store actual literals.
+    hdr_size_tmp = (int)(VP8LBitWriterNumBytes(bw) - init_byte_position);
+    err = StoreImageToBitMask(bw, width, histogram_bits, refs_best,
+                              histogram_symbols, huffman_codes);
+    // Keep track of the smallest image so far.
+    if (lz77s_idx == 0 ||
+        VP8LBitWriterNumBytes(bw) < VP8LBitWriterNumBytes(&bw_best)) {
+      *hdr_size = hdr_size_tmp;
+      *data_size =
+          (int)(VP8LBitWriterNumBytes(bw) - init_byte_position - *hdr_size);
+      VP8LBitWriterSwap(bw, &bw_best);
+    }
+    // Reset the bit writer for the following iteration if any.
+    if (config->lz77s_types_to_try_size_ > 1) VP8LBitWriterReset(&bw_init, bw);
+    WebPSafeFree(tokens);
+    tokens = NULL;
+    if (huffman_codes != NULL) {
+      WebPSafeFree(huffman_codes->codes);
+      WebPSafeFree(huffman_codes);
+      huffman_codes = NULL;
+    }
  }
  VP8LBitWriterSwap(bw, &bw_best);
-  err = VP8_ENC_OK;

 Error:
  WebPSafeFree(tokens);
  WebPSafeFree(huff_tree);
  VP8LFreeHistogramSet(histogram_image);
  VP8LFreeHistogram(tmp_histo);
-  VP8LHashChainClear(&hash_chain_histogram);
  if (huffman_codes != NULL) {
    WebPSafeFree(huffman_codes->codes);
    WebPSafeFree(huffman_codes);
@ -1108,7 +1095,8 @@ static WebPEncodingError ApplyPredictFilter(const VP8LEncoder* const enc,
  VP8LPutBits(bw, pred_bits - 2, 3);
  return EncodeImageNoHuffman(
      bw, enc->transform_data_, (VP8LHashChain*)&enc->hash_chain_,
-      (VP8LBackwardRefs*)&enc->refs_[0], transform_width, transform_height,
+      (VP8LBackwardRefs*)&enc->refs_[0],  // cast const away
+      (VP8LBackwardRefs*)&enc->refs_[1], transform_width, transform_height,
      quality, low_effort);
 }

@ -1128,7 +1116,8 @@ static WebPEncodingError ApplyCrossColorFilter(const VP8LEncoder* const enc,
  VP8LPutBits(bw, ccolor_transform_bits - 2, 3);
  return EncodeImageNoHuffman(
      bw, enc->transform_data_, (VP8LHashChain*)&enc->hash_chain_,
-      (VP8LBackwardRefs*)&enc->refs_[0], transform_width, transform_height,
+      (VP8LBackwardRefs*)&enc->refs_[0],  // cast const away
+      (VP8LBackwardRefs*)&enc->refs_[1], transform_width, transform_height,
      quality, low_effort);
 }

@ -1475,8 +1464,8 @@ static WebPEncodingError EncodePalette(VP8LBitWriter* const bw, int low_effort,
  }
  tmp_palette[0] = palette[0];
  return EncodeImageNoHuffman(bw, tmp_palette, &enc->hash_chain_,
-                              &enc->refs_[0], palette_size, 1, /*quality=*/20,
-                              low_effort);
+                              &enc->refs_[0], &enc->refs_[1], palette_size, 1,
+                              20 /* quality */, low_effort);
 }

 // -----------------------------------------------------------------------------
@ -1502,7 +1491,7 @@ static void VP8LEncoderDelete(VP8LEncoder* enc) {
  if (enc != NULL) {
    int i;
    VP8LHashChainClear(&enc->hash_chain_);
-    for (i = 0; i < 4; ++i) VP8LBackwardRefsClear(&enc->refs_[i]);
+    for (i = 0; i < 3; ++i) VP8LBackwardRefsClear(&enc->refs_[i]);
    ClearTransformBuffer(enc);
    WebPSafeFree(enc);
  }
@ -1552,7 +1541,7 @@ static int EncodeStreamHook(void* input, void* data2) {
  int data_size = 0;
  int use_delta_palette = 0;
  int idx;
-  size_t best_size = ~(size_t)0;
+  size_t best_size = 0;
  VP8LBitWriter bw_init = *bw, bw_best;
  (void)data2;

@ -1564,13 +1553,11 @@ static int EncodeStreamHook(void* input, void* data2) {

  for (idx = 0; idx < num_crunch_configs; ++idx) {
    const int entropy_idx = crunch_configs[idx].entropy_idx_;
-    enc->use_palette_ =
-        (entropy_idx == kPalette) || (entropy_idx == kPaletteAndSpatial);
+    enc->use_palette_ = (entropy_idx == kPalette);
    enc->use_subtract_green_ =
        (entropy_idx == kSubGreen) || (entropy_idx == kSpatialSubGreen);
-    enc->use_predict_ = (entropy_idx == kSpatial) ||
-                        (entropy_idx == kSpatialSubGreen) ||
-                        (entropy_idx == kPaletteAndSpatial);
+    enc->use_predict_ =
+        (entropy_idx == kSpatial) || (entropy_idx == kSpatialSubGreen);
    if (low_effort) {
      enc->use_cross_color_ = 0;
    } else {
@ -1653,7 +1640,7 @@ static int EncodeStreamHook(void* input, void* data2) {
    if (err != VP8_ENC_OK) goto Error;

    // If we are better than what we already have.
-    if (VP8LBitWriterNumBytes(bw) < best_size) {
+    if (idx == 0 || VP8LBitWriterNumBytes(bw) < best_size) {
      best_size = VP8LBitWriterNumBytes(bw);
      // Store the BitWriter.
      VP8LBitWriterSwap(bw, &bw_best);
@ -1706,11 +1693,16 @@ WebPEncodingError VP8LEncodeStream(const WebPConfig* const config,
  const WebPWorkerInterface* const worker_interface = WebPGetWorkerInterface();
  int ok_main;

+  if (enc_main == NULL || !VP8LBitWriterInit(&bw_side, 0)) {
+    WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
+    VP8LEncoderDelete(enc_main);
+    return 0;
+  }
+
  // Analyze image (entropy, num_palettes etc)
-  if (enc_main == NULL ||
-      !EncoderAnalyze(enc_main, crunch_configs, &num_crunch_configs_main,
+  if (!EncoderAnalyze(enc_main, crunch_configs, &num_crunch_configs_main,
                      &red_and_blue_always_zero) ||
-      !EncoderInit(enc_main) || !VP8LBitWriterInit(&bw_side, 0)) {
+      !EncoderInit(enc_main)) {
    err = VP8_ENC_ERROR_OUT_OF_MEMORY;
    goto Error;
  }
@ -1829,7 +1821,7 @@ Error:
 }

 #undef CRUNCH_CONFIGS_MAX
-#undef CRUNCH_SUBCONFIGS_MAX
+#undef CRUNCH_CONFIGS_LZ77_MAX

 int VP8LEncodeImage(const WebPConfig* const config,
                    const WebPPicture* const picture) {
--- a/src/enc/vp8li_enc.h
+++ b/src/enc/vp8li_enc.h
@ -71,7 +71,7 @@ typedef struct {
  uint32_t palette_[MAX_PALETTE_SIZE];

  // Some 'scratch' (potentially large) objects.
-  struct VP8LBackwardRefs refs_[4];  // Backward Refs array for temporaries.
+  struct VP8LBackwardRefs refs_[3];  // Backward Refs array for temporaries.
  VP8LHashChain hash_chain_;         // HashChain data for constructing
                                     // backward references.
 } VP8LEncoder;
--- a/src/enc/webp_enc.c
+++ b/src/enc/webp_enc.c
@ -400,7 +400,7 @@ int WebPEncode(const WebPConfig* config, WebPPicture* pic) {
    }

    if (!config->exact) {
-      WebPReplaceTransparentPixels(pic, 0x000000);
+      WebPCleanupTransparentAreaLossless(pic);
    }

    ok = VP8LEncodeImage(config, pic);  // Sets pic->error in case of problem.
--- 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,2,0
- PRODUCTVERSION 1,0,2,0
+ FILEVERSION 1,0,1,0
+ PRODUCTVERSION 1,0,1,0
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebp DLL"
-            VALUE "FileVersion", "1.2.0"
+            VALUE "FileVersion", "1.1.0"
            VALUE "InternalName", "libwebp.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebp.dll"
            VALUE "ProductName", "WebP Image Codec"
-            VALUE "ProductVersion", "1.2.0"
+            VALUE "ProductVersion", "1.1.0"
        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,2,0
- PRODUCTVERSION 1,0,2,0
+ FILEVERSION 1,0,1,0
+ PRODUCTVERSION 1,0,1,0
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebpdecoder DLL"
-            VALUE "FileVersion", "1.2.0"
+            VALUE "FileVersion", "1.1.0"
            VALUE "InternalName", "libwebpdecoder.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebpdecoder.dll"
            VALUE "ProductName", "WebP Image Decoder"
-            VALUE "ProductVersion", "1.2.0"
+            VALUE "ProductVersion", "1.1.0"
        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:6:0 -lm
+libwebpmux_la_LDFLAGS = -no-undefined -version-info 3:5: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,2,0
- PRODUCTVERSION 1,0,2,0
+ FILEVERSION 1,0,1,0
+ PRODUCTVERSION 1,0,1,0
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -24,12 +24,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "Google, Inc."
            VALUE "FileDescription", "libwebpmux DLL"
-            VALUE "FileVersion", "1.2.0"
+            VALUE "FileVersion", "1.1.0"
            VALUE "InternalName", "libwebpmux.dll"
            VALUE "LegalCopyright", "Copyright (C) 2019"
            VALUE "OriginalFilename", "libwebpmux.dll"
            VALUE "ProductName", "WebP Image Muxer"
-            VALUE "ProductVersion", "1.2.0"
+            VALUE "ProductVersion", "1.1.0"
        END
    END
    BLOCK "VarFileInfo"
--- a/src/mux/muxi.h
+++ b/src/mux/muxi.h
@ -28,7 +28,7 @@ extern "C" {
 // Defines and constants.

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

 // Chunk object.
--- a/src/mux/muxread.c
+++ b/src/mux/muxread.c
@ -155,6 +155,7 @@ static int MuxImageParse(const WebPChunk* const chunk, int copy_data,
        break;
      default:
        goto Fail;
+        break;
    }
    subchunk_size = ChunkDiskSize(&subchunk);
    bytes += subchunk_size;
@ -263,6 +264,7 @@ WebPMux* WebPMuxCreateInternal(const WebPData* bitstream, int copy_data,
        if (!MuxImageParse(&chunk, copy_data, wpi)) goto Err;
        ChunkRelease(&chunk);
        goto PushImage;
+        break;
      default:  // A non-image chunk.
        if (wpi->is_partial_) goto Err;  // Encountered a non-image chunk before
                                         // getting all chunks of an image.
--- a/src/utils/huffman_utils.c
+++ b/src/utils/huffman_utils.c
@ -177,21 +177,24 @@ 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;
        if ((key & mask) != low) {
-          table += table_size;
+          if (root_table != NULL) table += table_size;
          table_bits = NextTableBitSize(count, len, root_bits);
          table_size = 1 << table_bits;
          total_size += table_size;
          low = key & mask;
-          root_table[low].bits = (uint8_t)(table_bits + root_bits);
-          root_table[low].value = (uint16_t)((table - root_table) - low);
+          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);
        }
-        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);
      }
    }
@ -211,25 +214,83 @@ 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(HuffmanCode* const root_table, int root_bits,
+int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits,
                          const int code_lengths[], int code_lengths_size) {
-  int total_size;
+  const int total_size =
+      BuildHuffmanTable(NULL, root_bits, code_lengths, code_lengths_size, NULL);
  assert(code_lengths_size <= MAX_CODE_LENGTHS_SIZE);
-  if (root_table == NULL) {
-    total_size = BuildHuffmanTable(NULL, root_bits,
-                                   code_lengths, code_lengths_size, NULL);
-  } else if (code_lengths_size <= SORTED_SIZE_CUTOFF) {
+  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];
-    total_size = BuildHuffmanTable(root_table, root_bits,
-                                   code_lengths, code_lengths_size, sorted);
-  } else {   // rare case. Use heap allocation.
+    BuildHuffmanTable(root_table->curr_segment->curr_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;
-    total_size = BuildHuffmanTable(root_table, root_bits,
-                                   code_lengths, code_lengths_size, sorted);
+    BuildHuffmanTable(root_table->curr_segment->curr_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,6 +43,29 @@ 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)

@ -78,9 +101,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).
-// If root_table is NULL, it returns 0 if a lookup cannot be built, something
-// > 0 otherwise (but not the table size).
-int VP8LBuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
+int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits,
                          const int code_lengths[], int code_lengths_size);

 #ifdef __cplusplus
--- a/src/utils/utils.c
+++ b/src/utils/utils.c
@ -231,7 +231,7 @@ void WebPFree(void* ptr) {
 void WebPCopyPlane(const uint8_t* src, int src_stride,
                   uint8_t* dst, int dst_stride, int width, int height) {
  assert(src != NULL && dst != NULL);
-  assert(abs(src_stride) >= width && abs(dst_stride) >= width);
+  assert(src_stride >= width && dst_stride >= width);
  while (height-- > 0) {
    memcpy(dst, src, width);
    src += src_stride;
--- a/src/webp/decode.h
+++ b/src/webp/decode.h
@ -453,7 +453,7 @@ struct WebPDecoderOptions {
  int scaled_width, scaled_height;    // final resolution
  int use_threads;                    // if true, use multi-threaded decoding
  int dithering_strength;             // dithering strength (0=Off, 100=full)
-  int flip;                           // if true, flip output vertically
+  int flip;                           // flip output vertically
  int alpha_dithering_strength;       // alpha dithering strength in [0..100]

  uint32_t pad[5];                    // padding for later use
--- a/src/webp/encode.h
+++ b/src/webp/encode.h
@ -148,8 +148,7 @@ struct WebPConfig {
  int use_delta_palette;  // reserved for future lossless feature
  int use_sharp_yuv;      // if needed, use sharp (and slow) RGB->YUV conversion

-  int qmin;               // minimum permissible quality factor
-  int qmax;               // maximum permissible quality factor
+  uint32_t pad[2];        // padding for later use
 };

 // Enumerate some predefined settings for WebPConfig, depending on the type
@ -292,11 +291,6 @@ typedef enum WebPEncodingError {
 #define WEBP_MAX_DIMENSION 16383

 // Main exchange structure (input samples, output bytes, statistics)
-//
-// Once WebPPictureInit() has been called, it's ok to make all the INPUT fields
-// (use_argb, y/u/v, argb, ...) point to user-owned data, even if
-// WebPPictureAlloc() has been called. Depending on the value use_argb,
-// it's guaranteed that either *argb or *y/*u/*v content will be kept untouched.
 struct WebPPicture {
  //   INPUT
  //////////////
--- a/tests/README
+++ b/tests/README
@ -1,19 +0,0 @@
-Description:
-============
-
-This is a collection of tests for the libwebp libraries, currently covering
-fuzzing through the APIs. Additional test vector coverage can be found at:
-https://chromium.googlesource.com/webm/libwebp-test-data
-
-Building:
-=========
-
-Fuzzers:
--------
-
-Follow the build instructions in ../README for libwebp, optionally adding build
-flags for various sanitizers (e.g., -fsanitize=address).
-
-fuzzer/makefile.unix can then be used to compile the fuzzer targets:
-
-$ make -C fuzzer -f makefile.unix
--- a/tests/fuzzer/advanced_api_fuzzer.c
+++ b/tests/fuzzer/advanced_api_fuzzer.c
@ -1,97 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "./fuzz_utils.h"
-#include "webp/decode.h"
-
-int LLVMFuzzerTestOneInput(const uint8_t* const data, size_t size) {
-  WebPDecoderConfig config;
-  if (!WebPInitDecoderConfig(&config)) return 0;
-  if (WebPGetFeatures(data, size, &config.input) != VP8_STATUS_OK) return 0;
-  if ((size_t)config.input.width * config.input.height > kFuzzPxLimit) return 0;
-
-  // Using two independent criteria ensures that all combinations of options
-  // can reach each path at the decoding stage, with meaningful differences.
-
-  const uint8_t value = FuzzHash(data, size);
-  const float factor = value / 255.f;  // 0-1
-
-  config.options.flip = value & 1;
-  config.options.bypass_filtering = value & 2;
-  config.options.no_fancy_upsampling = value & 4;
-  config.options.use_threads = value & 8;
-  if (size & 1) {
-    config.options.use_cropping = 1;
-    config.options.crop_width = (int)(config.input.width * (1 - factor));
-    config.options.crop_height = (int)(config.input.height * (1 - factor));
-    config.options.crop_left = config.input.width - config.options.crop_width;
-    config.options.crop_top = config.input.height - config.options.crop_height;
-  }
-  if (size & 2) {
-    int strength = (int)(factor * 100);
-    config.options.dithering_strength = strength;
-    config.options.alpha_dithering_strength = 100 - strength;
-  }
-  if (size & 4) {
-    config.options.use_scaling = 1;
-    config.options.scaled_width = (int)(config.input.width * factor * 2);
-    config.options.scaled_height = (int)(config.input.height * factor * 2);
-  }
-
-#if defined(WEBP_REDUCE_CSP)
-  config.output.colorspace = (value & 1)
-                                 ? ((value & 2) ? MODE_RGBA : MODE_BGRA)
-                                 : ((value & 2) ? MODE_rgbA : MODE_bgrA);
-#else
-  config.output.colorspace = (WEBP_CSP_MODE)(value % MODE_LAST);
-#endif  // WEBP_REDUCE_CSP
-
-  if (size % 3) {
-    // Decodes incrementally in chunks of increasing size.
-    WebPIDecoder* idec = WebPIDecode(NULL, 0, &config);
-    if (!idec) return 0;
-    VP8StatusCode status;
-    if (size & 8) {
-      size_t available_size = value + 1;
-      while (1) {
-        if (available_size > size) available_size = size;
-        status = WebPIUpdate(idec, data, available_size);
-        if (status != VP8_STATUS_SUSPENDED || available_size == size) break;
-        available_size *= 2;
-      }
-    } else {
-      // WebPIAppend expects new data and its size with each call.
-      // Implemented here by simply advancing the pointer into data.
-      const uint8_t* new_data = data;
-      size_t new_size = value + 1;
-      while (1) {
-        if (new_data + new_size > data + size) {
-          new_size = data + size - new_data;
-        }
-        status = WebPIAppend(idec, new_data, new_size);
-        if (status != VP8_STATUS_SUSPENDED || new_size == 0) break;
-        new_data += new_size;
-        new_size *= 2;
-      }
-    }
-    WebPIDelete(idec);
-  } else {
-    WebPDecode(data, size, &config);
-  }
-
-  WebPFreeDecBuffer(&config.output);
-  return 0;
-}
--- a/tests/fuzzer/animation_api_fuzzer.c
+++ b/tests/fuzzer/animation_api_fuzzer.c
@ -1,78 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "./fuzz_utils.h"
-#include "webp/decode.h"
-#include "webp/demux.h"
-#include "webp/mux_types.h"
-
-int LLVMFuzzerTestOneInput(const uint8_t* const data, size_t size) {
-  WebPData webp_data;
-  WebPDataInit(&webp_data);
-  webp_data.size = size;
-  webp_data.bytes = data;
-
-  // WebPAnimDecoderNew uses WebPDemux internally to calloc canvas size.
-  WebPDemuxer* const demux = WebPDemux(&webp_data);
-  if (!demux) return 0;
-  const uint32_t cw = WebPDemuxGetI(demux, WEBP_FF_CANVAS_WIDTH);
-  const uint32_t ch = WebPDemuxGetI(demux, WEBP_FF_CANVAS_HEIGHT);
-  if ((size_t)cw * ch > kFuzzPxLimit) {
-    WebPDemuxDelete(demux);
-    return 0;
-  }
-
-  // In addition to canvas size, check each frame separately.
-  WebPIterator iter;
-  for (int i = 0; i < kFuzzFrameLimit; i++) {
-    if (!WebPDemuxGetFrame(demux, i + 1, &iter)) break;
-    int w, h;
-    if (WebPGetInfo(iter.fragment.bytes, iter.fragment.size, &w, &h)) {
-      if ((size_t)w * h > kFuzzPxLimit) {  // image size of the frame payload
-        WebPDemuxReleaseIterator(&iter);
-        WebPDemuxDelete(demux);
-        return 0;
-      }
-    }
-  }
-
-  WebPDemuxReleaseIterator(&iter);
-  WebPDemuxDelete(demux);
-
-  WebPAnimDecoderOptions dec_options;
-  if (!WebPAnimDecoderOptionsInit(&dec_options)) return 0;
-
-  dec_options.use_threads = size & 1;
-  // Animations only support 4 (of 12) modes.
-  dec_options.color_mode = (WEBP_CSP_MODE)(size % MODE_LAST);
-  if (dec_options.color_mode != MODE_BGRA &&
-      dec_options.color_mode != MODE_rgbA &&
-      dec_options.color_mode != MODE_bgrA) {
-    dec_options.color_mode = MODE_RGBA;
-  }
-
-  WebPAnimDecoder* dec = WebPAnimDecoderNew(&webp_data, &dec_options);
-  if (!dec) return 0;
-
-  for (int i = 0; i < kFuzzFrameLimit; i++) {
-    uint8_t* buf;
-    int timestamp;
-    if (!WebPAnimDecoderGetNext(dec, &buf, &timestamp)) break;
-  }
-
-  WebPAnimDecoderDelete(dec);
-  return 0;
-}
--- a/tests/fuzzer/animdecoder_fuzzer.cc
+++ b/tests/fuzzer/animdecoder_fuzzer.cc
@ -1,52 +0,0 @@
-// Copyright 2020 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "examples/anim_util.h"
-#include "imageio/imageio_util.h"
-#include "webp/demux.h"
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  // WebPAnimDecoderGetInfo() is too late to check the canvas size as
-  // WebPAnimDecoderNew() will handle the allocations.
-  WebPBitstreamFeatures features;
-  if (WebPGetFeatures(data, size, &features) == VP8_STATUS_OK) {
-    if (!ImgIoUtilCheckSizeArgumentsOverflow(features.width * 4,
-                                             features.height)) {
-      return 0;
-    }
-  }
-
-  // decode everything as an animation
-  WebPData webp_data = { data, size };
-  WebPAnimDecoder* const dec = WebPAnimDecoderNew(&webp_data, NULL);
-  if (dec == NULL) return 0;
-
-  WebPAnimInfo info;
-  if (!WebPAnimDecoderGetInfo(dec, &info)) goto End;
-  if (!ImgIoUtilCheckSizeArgumentsOverflow(info.canvas_width * 4,
-                                           info.canvas_height)) {
-    goto End;
-  }
-
-  while (WebPAnimDecoderHasMoreFrames(dec)) {
-    uint8_t* buf;
-    int timestamp;
-    if (!WebPAnimDecoderGetNext(dec, &buf, &timestamp)) break;
-  }
- End:
-  WebPAnimDecoderDelete(dec);
-  return 0;
-}
--- a/tests/fuzzer/animencoder_fuzzer.cc
+++ b/tests/fuzzer/animencoder_fuzzer.cc
@ -1,177 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "./fuzz_utils.h"
-#include "webp/encode.h"
-#include "webp/mux.h"
-
-namespace {
-
-const VP8CPUInfo default_VP8GetCPUInfo = VP8GetCPUInfo;
-
-int AddFrame(WebPAnimEncoder** const enc,
-             const WebPAnimEncoderOptions& anim_config, int* const width,
-             int* const height, int timestamp_ms, const uint8_t data[],
-             size_t size, uint32_t* const bit_pos) {
-  if (enc == nullptr || width == nullptr || height == nullptr) {
-    fprintf(stderr, "NULL parameters.\n");
-    if (enc != nullptr) WebPAnimEncoderDelete(*enc);
-    abort();
-  }
-
-  // Init the source picture.
-  WebPPicture pic;
-  if (!WebPPictureInit(&pic)) {
-    fprintf(stderr, "WebPPictureInit failed.\n");
-    WebPAnimEncoderDelete(*enc);
-    abort();
-  }
-  pic.use_argb = Extract(1, data, size, bit_pos);
-
-  // Read the source picture.
-  if (!ExtractSourcePicture(&pic, data, size, bit_pos)) {
-    const WebPEncodingError error_code = pic.error_code;
-    WebPPictureFree(&pic);
-    if (error_code == VP8_ENC_ERROR_OUT_OF_MEMORY) return 0;
-    fprintf(stderr, "Can't read input image. Error code: %d\n", error_code);
-    abort();
-  }
-
-  // Crop and scale.
-  if (*enc == nullptr) {  // First frame will set canvas width and height.
-    if (!ExtractAndCropOrScale(&pic, data, size, bit_pos)) {
-      const WebPEncodingError error_code = pic.error_code;
-      WebPPictureFree(&pic);
-      if (error_code == VP8_ENC_ERROR_OUT_OF_MEMORY) return 0;
-      fprintf(stderr, "ExtractAndCropOrScale failed. Error code: %d\n",
-              error_code);
-      abort();
-    }
-  } else {  // Other frames will be resized to the first frame's dimensions.
-    if (!WebPPictureRescale(&pic, *width, *height)) {
-      const WebPEncodingError error_code = pic.error_code;
-      WebPAnimEncoderDelete(*enc);
-      WebPPictureFree(&pic);
-      if (error_code == VP8_ENC_ERROR_OUT_OF_MEMORY) return 0;
-      fprintf(stderr,
-              "WebPPictureRescale failed. Size: %d,%d. Error code: %d\n",
-              *width, *height, error_code);
-      abort();
-    }
-  }
-
-  // Create encoder if it doesn't exist.
-  if (*enc == nullptr) {
-    *width = pic.width;
-    *height = pic.height;
-    *enc = WebPAnimEncoderNew(*width, *height, &anim_config);
-    if (*enc == nullptr) {
-      WebPPictureFree(&pic);
-      return 0;
-    }
-  }
-
-  // Create frame encoding config.
-  WebPConfig config;
-  if (!ExtractWebPConfig(&config, data, size, bit_pos)) {
-    fprintf(stderr, "ExtractWebPConfig failed.\n");
-    WebPAnimEncoderDelete(*enc);
-    WebPPictureFree(&pic);
-    abort();
-  }
-  // Skip slow settings on big images, it's likely to timeout.
-  if (pic.width * pic.height > 32 * 32) {
-    config.method = (config.method > 4) ? 4 : config.method;
-    config.quality = (config.quality > 99.0f) ? 99.0f : config.quality;
-    config.alpha_quality =
-        (config.alpha_quality > 99) ? 99 : config.alpha_quality;
-  }
-
-  // Encode.
-  if (!WebPAnimEncoderAdd(*enc, &pic, timestamp_ms, &config)) {
-    const WebPEncodingError error_code = pic.error_code;
-    WebPAnimEncoderDelete(*enc);
-    WebPPictureFree(&pic);
-    if (error_code == VP8_ENC_ERROR_OUT_OF_MEMORY) return 0;
-    fprintf(stderr, "WebPEncode failed. Error code: %d\n", error_code);
-    abort();
-  }
-
-  WebPPictureFree(&pic);
-  return 1;
-}
-
-}  // namespace
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* const data, size_t size) {
-  WebPAnimEncoder* enc = nullptr;
-  int width = 0, height = 0, timestamp_ms = 0;
-  uint32_t bit_pos = 0;
-
-  ExtractAndDisableOptimizations(default_VP8GetCPUInfo, data, size, &bit_pos);
-
-  // Extract a configuration from the packed bits.
-  WebPAnimEncoderOptions anim_config;
-  if (!WebPAnimEncoderOptionsInit(&anim_config)) {
-    fprintf(stderr, "WebPAnimEncoderOptionsInit failed.\n");
-    abort();
-  }
-  anim_config.minimize_size = Extract(1, data, size, &bit_pos);
-  anim_config.kmax = Extract(15, data, size, &bit_pos);
-  const int min_kmin = (anim_config.kmax > 1) ? (anim_config.kmax / 2) : 0;
-  const int max_kmin = (anim_config.kmax > 1) ? (anim_config.kmax - 1) : 0;
-  anim_config.kmin =
-      min_kmin + Extract((uint32_t)(max_kmin - min_kmin), data, size, &bit_pos);
-  anim_config.allow_mixed = Extract(1, data, size, &bit_pos);
-  anim_config.verbose = 0;
-
-  const int nb_frames = 1 + Extract(15, data, size, &bit_pos);
-
-  // For each frame.
-  for (int i = 0; i < nb_frames; ++i) {
-    if (!AddFrame(&enc, anim_config, &width, &height, timestamp_ms, data, size,
-                  &bit_pos)) {
-      return 0;
-    }
-
-    timestamp_ms += (1 << (2 + Extract(15, data, size, &bit_pos))) +
-                    Extract(1, data, size, &bit_pos);  // [1..131073], arbitrary
-  }
-
-  // Assemble.
-  if (!WebPAnimEncoderAdd(enc, nullptr, timestamp_ms, nullptr)) {
-    fprintf(stderr, "Last WebPAnimEncoderAdd failed: %s.\n",
-            WebPAnimEncoderGetError(enc));
-    WebPAnimEncoderDelete(enc);
-    abort();
-  }
-  WebPData webp_data;
-  WebPDataInit(&webp_data);
-  if (!WebPAnimEncoderAssemble(enc, &webp_data)) {
-    fprintf(stderr, "WebPAnimEncoderAssemble failed: %s.\n",
-            WebPAnimEncoderGetError(enc));
-    WebPAnimEncoderDelete(enc);
-    WebPDataClear(&webp_data);
-    abort();
-  }
-
-  WebPAnimEncoderDelete(enc);
-  WebPDataClear(&webp_data);
-  return 0;
-}
--- a/tests/fuzzer/enc_dec_fuzzer.cc
+++ b/tests/fuzzer/enc_dec_fuzzer.cc
@ -1,141 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "./fuzz_utils.h"
-#include "webp/decode.h"
-#include "webp/encode.h"
-
-namespace {
-
-const VP8CPUInfo default_VP8GetCPUInfo = VP8GetCPUInfo;
-
-}  // namespace
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* const data, size_t size) {
-  uint32_t bit_pos = 0;
-
-  ExtractAndDisableOptimizations(default_VP8GetCPUInfo, data, size, &bit_pos);
-
-  // Init the source picture.
-  WebPPicture pic;
-  if (!WebPPictureInit(&pic)) {
-    fprintf(stderr, "WebPPictureInit failed.\n");
-    abort();
-  }
-  pic.use_argb = Extract(1, data, size, &bit_pos);
-
-  // Read the source picture.
-  if (!ExtractSourcePicture(&pic, data, size, &bit_pos)) {
-    const WebPEncodingError error_code = pic.error_code;
-    WebPPictureFree(&pic);
-    if (error_code == VP8_ENC_ERROR_OUT_OF_MEMORY) return 0;
-    fprintf(stderr, "Can't read input image. Error code: %d\n", error_code);
-    abort();
-  }
-
-  // Crop and scale.
-  if (!ExtractAndCropOrScale(&pic, data, size, &bit_pos)) {
-    const WebPEncodingError error_code = pic.error_code;
-    WebPPictureFree(&pic);
-    if (error_code == VP8_ENC_ERROR_OUT_OF_MEMORY) return 0;
-    fprintf(stderr, "ExtractAndCropOrScale failed. Error code: %d\n",
-            error_code);
-    abort();
-  }
-
-  // Extract a configuration from the packed bits.
-  WebPConfig config;
-  if (!ExtractWebPConfig(&config, data, size, &bit_pos)) {
-    fprintf(stderr, "ExtractWebPConfig failed.\n");
-    abort();
-  }
-  // Skip slow settings on big images, it's likely to timeout.
-  if (pic.width * pic.height > 32 * 32) {
-    if (config.lossless) {
-      if (config.quality > 99.0f && config.method >= 5) {
-        config.quality = 99.0f;
-        config.method = 5;
-      }
-    } else {
-      if (config.quality > 99.0f && config.method == 6) {
-        config.quality = 99.0f;
-      }
-    }
-    if (config.alpha_quality == 100 && config.method == 6) {
-      config.alpha_quality = 99;
-    }
-  }
-
-  // Encode.
-  WebPMemoryWriter memory_writer;
-  WebPMemoryWriterInit(&memory_writer);
-  pic.writer = WebPMemoryWrite;
-  pic.custom_ptr = &memory_writer;
-  if (!WebPEncode(&config, &pic)) {
-    const WebPEncodingError error_code = pic.error_code;
-    WebPMemoryWriterClear(&memory_writer);
-    WebPPictureFree(&pic);
-    if (error_code == VP8_ENC_ERROR_OUT_OF_MEMORY) return 0;
-    fprintf(stderr, "WebPEncode failed. Error code: %d\n", error_code);
-    abort();
-  }
-
-  // Try decoding the result.
-  int w, h;
-  const uint8_t* const out_data = memory_writer.mem;
-  const size_t out_size = memory_writer.size;
-  uint8_t* const rgba = WebPDecodeBGRA(out_data, out_size, &w, &h);
-  if (rgba == nullptr || w != pic.width || h != pic.height) {
-    fprintf(stderr, "WebPDecodeBGRA failed.\n");
-    WebPFree(rgba);
-    WebPMemoryWriterClear(&memory_writer);
-    WebPPictureFree(&pic);
-    abort();
-  }
-
-  // Compare the results if exact encoding.
-  if (pic.use_argb && config.lossless && config.near_lossless == 100) {
-    const uint32_t* src1 = (const uint32_t*)rgba;
-    const uint32_t* src2 = pic.argb;
-    for (int y = 0; y < h; ++y, src1 += w, src2 += pic.argb_stride) {
-      for (int x = 0; x < w; ++x) {
-        uint32_t v1 = src1[x], v2 = src2[x];
-        if (!config.exact) {
-          if ((v1 & 0xff000000u) == 0 || (v2 & 0xff000000u) == 0) {
-            // Only keep alpha for comparison of fully transparent area.
-            v1 &= 0xff000000u;
-            v2 &= 0xff000000u;
-          }
-        }
-        if (v1 != v2) {
-          fprintf(stderr, "Lossless compression failed pixel-exactness.\n");
-          WebPFree(rgba);
-          WebPMemoryWriterClear(&memory_writer);
-          WebPPictureFree(&pic);
-          abort();
-        }
-      }
-    }
-  }
-
-  WebPFree(rgba);
-  WebPMemoryWriterClear(&memory_writer);
-  WebPPictureFree(&pic);
-  return 0;
-}
--- a/tests/fuzzer/fuzz.dict
+++ b/tests/fuzzer/fuzz.dict
@ -1,17 +0,0 @@
-# https://developers.google.com/speed/webp/docs/riff_container
-
-# FourCC
-"ALPH"
-"ANIM"
-"ANMF"
-"EXIF"
-"ICCP"
-"RIFF"
-"VP8 "
-"VP8L"
-"VP8X"
-"WEBP"
-"XMP "
-
-# VP8 signature
-"\x9D\x01\x2A"
--- a/tests/fuzzer/fuzz_utils.h
+++ b/tests/fuzzer/fuzz_utils.h
@ -1,207 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef WEBP_TESTS_FUZZER_FUZZ_UTILS_H_
-#define WEBP_TESTS_FUZZER_FUZZ_UTILS_H_
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "./img_alpha.h"
-#include "./img_grid.h"
-#include "./img_peak.h"
-#include "dsp/dsp.h"
-#include "webp/encode.h"
-
-//------------------------------------------------------------------------------
-// Arbitrary limits to prevent OOM, timeout, or slow execution.
-//
-// The decoded image size, and for animations additionally the canvas size.
-static const size_t kFuzzPxLimit = 1024 * 1024;
-// Demuxed or decoded animation frames.
-static const int kFuzzFrameLimit = 3;
-
-// Reads and sums (up to) 128 spread-out bytes.
-static WEBP_INLINE uint8_t FuzzHash(const uint8_t* const data, size_t size) {
-  uint8_t value = 0;
-  size_t incr = size / 128;
-  if (!incr) incr = 1;
-  for (size_t i = 0; i < size; i += incr) value += data[i];
-  return value;
-}
-
-//------------------------------------------------------------------------------
-// Extract an integer in [0, max_value].
-
-static WEBP_INLINE uint32_t Extract(uint32_t max_value,
-                                    const uint8_t data[], size_t size,
-                                    uint32_t* const bit_pos) {
-  uint32_t v = 0;
-  uint32_t range = 1;
-  while (*bit_pos < 8 * size && range <= max_value) {
-    const uint8_t mask = 1u << (*bit_pos & 7);
-    v = (v << 1) | !!(data[*bit_pos >> 3] & mask);
-    range <<= 1;
-    ++*bit_pos;
-  }
-  return v % (max_value + 1);
-}
-
-//------------------------------------------------------------------------------
-// Some functions to override VP8GetCPUInfo and disable some optimizations.
-
-static VP8CPUInfo GetCPUInfo;
-
-static WEBP_INLINE int GetCPUInfoNoSSE41(CPUFeature feature) {
-  if (feature == kSSE4_1 || feature == kAVX) return 0;
-  return GetCPUInfo(feature);
-}
-
-static WEBP_INLINE int GetCPUInfoNoAVX(CPUFeature feature) {
-  if (feature == kAVX) return 0;
-  return GetCPUInfo(feature);
-}
-
-static WEBP_INLINE int GetCPUInfoForceSlowSSSE3(CPUFeature feature) {
-  if (feature == kSlowSSSE3 && GetCPUInfo(kSSE3)) {
-    return 1;  // we have SSE3 -> force SlowSSSE3
-  }
-  return GetCPUInfo(feature);
-}
-
-static WEBP_INLINE int GetCPUInfoOnlyC(CPUFeature feature) {
-  (void)feature;
-  return 0;
-}
-
-static WEBP_INLINE void ExtractAndDisableOptimizations(
-    VP8CPUInfo default_VP8GetCPUInfo, const uint8_t data[], size_t size,
-    uint32_t* const bit_pos) {
-  GetCPUInfo = default_VP8GetCPUInfo;
-  const VP8CPUInfo kVP8CPUInfos[5] = {GetCPUInfoOnlyC, GetCPUInfoForceSlowSSSE3,
-                                      GetCPUInfoNoSSE41, GetCPUInfoNoAVX,
-                                      GetCPUInfo};
-  int VP8GetCPUInfo_index = Extract(4, data, size, bit_pos);
-  VP8GetCPUInfo = kVP8CPUInfos[VP8GetCPUInfo_index];
-}
-
-//------------------------------------------------------------------------------
-
-static WEBP_INLINE int ExtractWebPConfig(WebPConfig* const config,
-                                         const uint8_t data[], size_t size,
-                                         uint32_t* const bit_pos) {
-  if (config == NULL || !WebPConfigInit(config)) return 0;
-  config->lossless = Extract(1, data, size, bit_pos);
-  config->quality = Extract(100, data, size, bit_pos);
-  config->method = Extract(6, data, size, bit_pos);
-  config->image_hint =
-      (WebPImageHint)Extract(WEBP_HINT_LAST - 1, data, size, bit_pos);
-  config->segments = 1 + Extract(3, data, size, bit_pos);
-  config->sns_strength = Extract(100, data, size, bit_pos);
-  config->filter_strength = Extract(100, data, size, bit_pos);
-  config->filter_sharpness = Extract(7, data, size, bit_pos);
-  config->filter_type = Extract(1, data, size, bit_pos);
-  config->autofilter = Extract(1, data, size, bit_pos);
-  config->alpha_compression = Extract(1, data, size, bit_pos);
-  config->alpha_filtering = Extract(2, data, size, bit_pos);
-  config->alpha_quality = Extract(100, data, size, bit_pos);
-  config->pass = 1 + Extract(9, data, size, bit_pos);
-  config->show_compressed = 1;
-  config->preprocessing = Extract(2, data, size, bit_pos);
-  config->partitions = Extract(3, data, size, bit_pos);
-  config->partition_limit = 10 * Extract(10, data, size, bit_pos);
-  config->emulate_jpeg_size = Extract(1, data, size, bit_pos);
-  config->thread_level = Extract(1, data, size, bit_pos);
-  config->low_memory = Extract(1, data, size, bit_pos);
-  config->near_lossless = 20 * Extract(5, data, size, bit_pos);
-  config->exact = Extract(1, data, size, bit_pos);
-  config->use_delta_palette = Extract(1, data, size, bit_pos);
-  config->use_sharp_yuv = Extract(1, data, size, bit_pos);
-  return WebPValidateConfig(config);
-}
-
-//------------------------------------------------------------------------------
-
-static WEBP_INLINE int ExtractSourcePicture(WebPPicture* const pic,
-                                            const uint8_t data[], size_t size,
-                                            uint32_t* const bit_pos) {
-  if (pic == NULL) return 0;
-
-  // Pick a source picture.
-  const uint8_t* kImagesData[] = {
-      kImgAlphaData,
-      kImgGridData,
-      kImgPeakData
-  };
-  const int kImagesWidth[] = {
-      kImgAlphaWidth,
-      kImgGridWidth,
-      kImgPeakWidth
-  };
-  const int kImagesHeight[] = {
-      kImgAlphaHeight,
-      kImgGridHeight,
-      kImgPeakHeight
-  };
-  const size_t kNbImages = sizeof(kImagesData) / sizeof(kImagesData[0]);
-  const size_t image_index = Extract(kNbImages - 1, data, size, bit_pos);
-  const uint8_t* const image_data = kImagesData[image_index];
-  pic->width = kImagesWidth[image_index];
-  pic->height = kImagesHeight[image_index];
-  pic->argb_stride = pic->width * 4 * sizeof(uint8_t);
-
-  // Read the bytes.
-  return WebPPictureImportRGBA(pic, image_data, pic->argb_stride);
-}
-
-//------------------------------------------------------------------------------
-
-static WEBP_INLINE int Max(int a, int b) { return ((a < b) ? b : a); }
-
-static WEBP_INLINE int ExtractAndCropOrScale(WebPPicture* const pic,
-                                             const uint8_t data[], size_t size,
-                                             uint32_t* const bit_pos) {
-  if (pic == NULL) return 0;
-#if !defined(WEBP_REDUCE_SIZE)
-  const int alter_input = Extract(1, data, size, bit_pos);
-  const int crop_or_scale = Extract(1, data, size, bit_pos);
-  const int width_ratio = 1 + Extract(7, data, size, bit_pos);
-  const int height_ratio = 1 + Extract(7, data, size, bit_pos);
-  if (alter_input) {
-    if (crop_or_scale) {
-      const uint32_t left_ratio = 1 + Extract(7, data, size, bit_pos);
-      const uint32_t top_ratio = 1 + Extract(7, data, size, bit_pos);
-      const int cropped_width = Max(1, pic->width / width_ratio);
-      const int cropped_height = Max(1, pic->height / height_ratio);
-      const int cropped_left = (pic->width - cropped_width) / left_ratio;
-      const int cropped_top = (pic->height - cropped_height) / top_ratio;
-      return WebPPictureCrop(pic, cropped_left, cropped_top, cropped_width,
-                             cropped_height);
-    } else {
-      const int scaled_width = 1 + (pic->width * width_ratio) / 8;
-      const int scaled_height = 1 + (pic->height * height_ratio) / 8;
-      return WebPPictureRescale(pic, scaled_width, scaled_height);
-    }
-  }
-#else   // defined(WEBP_REDUCE_SIZE)
-  (void)data;
-  (void)size;
-  (void)bit_pos;
-#endif  // !defined(WEBP_REDUCE_SIZE)
-  return 1;
-}
-
-#endif  // WEBP_TESTS_FUZZER_FUZZ_UTILS_H_
--- a/tests/fuzzer/img_alpha.h
+++ b/tests/fuzzer/img_alpha.h
@ -1,381 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef WEBP_TESTS_FUZZER_IMG_ALPHA_H_
-#define WEBP_TESTS_FUZZER_IMG_ALPHA_H_
-
-#include <stdint.h>
-
-static const int kImgAlphaWidth = 32;
-static const int kImgAlphaHeight = 32;
-
-/*Pixel format: Red: 8 bit, Green: 8 bit, Blue: 8 bit, Fix 0xFF: 8 bit*/
-static const uint8_t kImgAlphaData[] = {
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xfe, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0xfd, 0xff, 0xfe, 0xfd, 0xfc, 0xff,
-    0xfe, 0xfd, 0xfb, 0xff, 0xfe, 0xfc, 0xfb, 0xff, 0xfe, 0xfc, 0xfa, 0xff,
-    0xfe, 0xfc, 0xf9, 0xff, 0xfe, 0xfb, 0xf8, 0xff, 0xfe, 0xfb, 0xf7, 0xff,
-    0xfe, 0xfb, 0xf7, 0xff, 0xfe, 0xfa, 0xf6, 0xff, 0xfe, 0xf9, 0xf5, 0xff,
-    0xfd, 0xf9, 0xf3, 0xff, 0xfd, 0xf8, 0xf2, 0xff, 0xfd, 0xf7, 0xf1, 0xff,
-    0xfc, 0xf7, 0xf0, 0xff, 0xfc, 0xf6, 0xef, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff,
-    0xfe, 0xfe, 0xfd, 0xff, 0xfe, 0xfd, 0xfc, 0xff, 0xfe, 0xfd, 0xfb, 0xff,
-    0xfe, 0xfc, 0xfa, 0xff, 0xfe, 0xfc, 0xfa, 0xff, 0xfe, 0xfb, 0xf9, 0xff,
-    0xfe, 0xfb, 0xf8, 0xff, 0xfe, 0xfb, 0xf7, 0xff, 0xfe, 0xfa, 0xf7, 0xff,
-    0xfe, 0xfa, 0xf5, 0xff, 0xfe, 0xfa, 0xf5, 0xff, 0xfd, 0xf9, 0xf4, 0xff,
-    0xfd, 0xf8, 0xf2, 0xff, 0xfc, 0xf7, 0xf1, 0xff, 0xfc, 0xf7, 0xf0, 0xff,
-    0xfc, 0xf7, 0xef, 0xff, 0xfc, 0xf6, 0xee, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xfe, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0xfd, 0xff, 0xfe, 0xfd, 0xfd, 0xff,
-    0xfe, 0xfd, 0xfc, 0xff, 0xfe, 0xfd, 0xfb, 0xff, 0xfe, 0xfc, 0xfa, 0xff,
-    0xfe, 0xfc, 0xfa, 0xff, 0xfe, 0xfc, 0xf9, 0xff, 0xfe, 0xfb, 0xf8, 0xff,
-    0xfe, 0xfb, 0xf7, 0xff, 0xfe, 0xfb, 0xf6, 0xff, 0xfe, 0xfa, 0xf5, 0xff,
-    0xfe, 0xfa, 0xf5, 0xff, 0xfe, 0xf9, 0xf4, 0xff, 0xfe, 0xf8, 0xf3, 0xff,
-    0xfd, 0xf8, 0xf2, 0xff, 0xfc, 0xf7, 0xf1, 0xff, 0xfc, 0xf5, 0xf0, 0xff,
-    0xfc, 0xf6, 0xee, 0xff, 0xfc, 0xf5, 0xed, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xfd, 0xff,
-    0xfc, 0xfb, 0xfb, 0xff, 0xfd, 0xfc, 0xfc, 0xff, 0xfe, 0xfd, 0xfb, 0xff,
-    0xfe, 0xfc, 0xfa, 0xff, 0xfe, 0xfc, 0xfa, 0xff, 0xfe, 0xfc, 0xf9, 0xff,
-    0xfe, 0xfb, 0xf8, 0xff, 0xfe, 0xfb, 0xf8, 0xff, 0xfe, 0xfb, 0xf7, 0xff,
-    0xfe, 0xfb, 0xf6, 0xff, 0xfe, 0xfa, 0xf5, 0xff, 0xfe, 0xfa, 0xf5, 0xff,
-    0xfe, 0xf9, 0xf4, 0xff, 0xfe, 0xf9, 0xf3, 0xff, 0xfe, 0xf8, 0xf2, 0xff,
-    0xfd, 0xf7, 0xf1, 0xff, 0xfc, 0xf6, 0xf0, 0xff, 0xfc, 0xf6, 0xee, 0xff,
-    0xfc, 0xf5, 0xec, 0xff, 0xfb, 0xf5, 0xec, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xfc, 0xfc, 0xfc, 0xff, 0xfb, 0xfb, 0xfb, 0xff,
-    0xfa, 0xf9, 0xf9, 0xff, 0xf7, 0xf6, 0xf6, 0xff, 0xfd, 0xfc, 0xfa, 0xff,
-    0xfe, 0xfc, 0xfa, 0xff, 0xfe, 0xfc, 0xf9, 0xff, 0xfe, 0xfb, 0xf9, 0xff,
-    0xfe, 0xfb, 0xf7, 0xff, 0xfe, 0xfb, 0xf7, 0xff, 0xfe, 0xfb, 0xf6, 0xff,
-    0xfe, 0xfa, 0xf5, 0xff, 0xfe, 0xfa, 0xf5, 0xff, 0xfe, 0xfa, 0xf3, 0xff,
-    0xfe, 0xfa, 0xf4, 0xfb, 0xfe, 0xf9, 0xf4, 0xeb, 0xfe, 0xfb, 0xf6, 0xdc,
-    0xfd, 0xfa, 0xf6, 0xcf, 0xfd, 0xfa, 0xf5, 0xcc, 0xfc, 0xf9, 0xf4, 0xcb,
-    0xfd, 0xf8, 0xf3, 0xc7, 0xfc, 0xf8, 0xf2, 0xc7,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xfd, 0xff,
-    0xfb, 0xfa, 0xfa, 0xff, 0xf8, 0xf7, 0xf7, 0xff, 0xf6, 0xf4, 0xf4, 0xff,
-    0xf7, 0xf5, 0xf5, 0xff, 0xf5, 0xf5, 0xf4, 0xff, 0xf8, 0xf7, 0xf7, 0xff,
-    0xfd, 0xfb, 0xf8, 0xff, 0xfe, 0xfb, 0xf8, 0xff, 0xfe, 0xfb, 0xf7, 0xff,
-    0xfe, 0xfb, 0xf7, 0xff, 0xfe, 0xfa, 0xf6, 0xff, 0xfe, 0xfa, 0xf5, 0xff,
-    0xfe, 0xfa, 0xf4, 0xff, 0xfd, 0xfa, 0xf4, 0xfc, 0xfe, 0xfc, 0xf9, 0xcf,
-    0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, 0xa8, 0xff, 0xff, 0xff, 0xa4,
-    0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 0x9b, 0xff, 0xff, 0xff, 0x94,
-    0xff, 0xff, 0xff, 0x90, 0xff, 0xff, 0xff, 0x8b,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xfd, 0xfc, 0xfc, 0xff, 0xfa, 0xf9, 0xf9, 0xff,
-    0xf6, 0xf5, 0xf4, 0xff, 0xf5, 0xf3, 0xf3, 0xff, 0xf4, 0xf2, 0xf1, 0xff,
-    0xf2, 0xf1, 0xf0, 0xff, 0xf2, 0xf0, 0xf0, 0xff, 0xf0, 0xee, 0xee, 0xff,
-    0xf1, 0xf0, 0xef, 0xff, 0xfe, 0xfb, 0xf8, 0xff, 0xfe, 0xfb, 0xf6, 0xff,
-    0xfe, 0xfa, 0xf6, 0xff, 0xfe, 0xfa, 0xf5, 0xff, 0xfe, 0xfb, 0xf4, 0xff,
-    0xfe, 0xfb, 0xf5, 0xf3, 0xff, 0xfe, 0xfe, 0xb4, 0xff, 0xff, 0xff, 0xac,
-    0xff, 0xff, 0xff, 0xa7, 0xff, 0xff, 0xff, 0xa3, 0xff, 0xff, 0xff, 0x9c,
-    0xff, 0xff, 0xff, 0x98, 0xff, 0xff, 0xff, 0x93, 0xff, 0xff, 0xff, 0x8f,
-    0xff, 0xff, 0xff, 0x88, 0xff, 0xff, 0xff, 0x84,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff,
-    0xfc, 0xfb, 0xfb, 0xff, 0xf9, 0xf8, 0xf8, 0xff, 0xf6, 0xf5, 0xf4, 0xff,
-    0xf3, 0xf1, 0xf1, 0xff, 0xf0, 0xed, 0xed, 0xff, 0xef, 0xec, 0xeb, 0xff,
-    0xee, 0xeb, 0xeb, 0xff, 0xf0, 0xee, 0xee, 0xff, 0xea, 0xe7, 0xe7, 0xff,
-    0xec, 0xe9, 0xe9, 0xff, 0xf5, 0xf2, 0xf0, 0xff, 0xfe, 0xfb, 0xf6, 0xff,
-    0xfe, 0xfb, 0xf5, 0xff, 0xfe, 0xfa, 0xf4, 0xff, 0xfe, 0xfb, 0xf6, 0xeb,
-    0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xff, 0xab, 0xff, 0xff, 0xff, 0xa4,
-    0xff, 0xff, 0xff, 0xa0, 0xff, 0xff, 0xff, 0x9b, 0xff, 0xff, 0xff, 0x97,
-    0xff, 0xff, 0xff, 0x90, 0xff, 0xff, 0xff, 0x8c, 0xff, 0xff, 0xff, 0x87,
-    0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xff, 0x7c,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xfd, 0xfc, 0xfc, 0xff, 0xfb, 0xfb, 0xfa, 0xff,
-    0xf8, 0xf6, 0xf6, 0xff, 0xf4, 0xf3, 0xf2, 0xff, 0xf2, 0xf0, 0xf0, 0xff,
-    0xef, 0xec, 0xeb, 0xff, 0xef, 0xec, 0xeb, 0xff, 0xeb, 0xe7, 0xe6, 0xff,
-    0xea, 0xe6, 0xe5, 0xff, 0xeb, 0xe8, 0xe8, 0xff, 0xe9, 0xe6, 0xe7, 0xff,
-    0xe5, 0xe2, 0xe2, 0xff, 0xed, 0xeb, 0xeb, 0xff, 0xf7, 0xf5, 0xf2, 0xff,
-    0xfe, 0xfa, 0xf5, 0xff, 0xfe, 0xfb, 0xf5, 0xf8, 0xff, 0xff, 0xff, 0xac,
-    0xff, 0xff, 0xff, 0xa8, 0xff, 0xff, 0xff, 0xa3, 0xff, 0xff, 0xff, 0x9f,
-    0xff, 0xff, 0xff, 0x98, 0xff, 0xff, 0xff, 0x94, 0xff, 0xff, 0xff, 0x8f,
-    0xff, 0xff, 0xff, 0x8b, 0xff, 0xff, 0xff, 0x84, 0xff, 0xff, 0xff, 0x80,
-    0xff, 0xff, 0xff, 0x7c, 0xff, 0xff, 0xff, 0x77,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xfc, 0xfc, 0xfc, 0xff, 0xf8, 0xf7, 0xf7, 0xff, 0xf6, 0xf5, 0xf4, 0xff,
-    0xf3, 0xf1, 0xf0, 0xff, 0xf1, 0xef, 0xef, 0xff, 0xef, 0xed, 0xec, 0xff,
-    0xec, 0xe8, 0xe7, 0xff, 0xe9, 0xe6, 0xe6, 0xff, 0xec, 0xe9, 0xe9, 0xff,
-    0xe4, 0xe0, 0xdf, 0xff, 0xec, 0xe9, 0xe9, 0xff, 0xea, 0xe6, 0xe6, 0xff,
-    0xe6, 0xe2, 0xe2, 0xff, 0xea, 0xe8, 0xe8, 0xff, 0xec, 0xe8, 0xe7, 0xff,
-    0xfc, 0xf9, 0xf4, 0xff, 0xfe, 0xfd, 0xfa, 0xc3, 0xff, 0xff, 0xff, 0xa7,
-    0xff, 0xff, 0xff, 0xa0, 0xff, 0xff, 0xff, 0x9c, 0xff, 0xff, 0xff, 0x97,
-    0xff, 0xff, 0xff, 0x93, 0xff, 0xff, 0xff, 0x8c, 0xfe, 0xfc, 0xf9, 0xa3,
-    0xfc, 0xfb, 0xf5, 0xb0, 0xfc, 0xf9, 0xf1, 0xbb, 0xfb, 0xf8, 0xf1, 0xb8,
-    0xfb, 0xf8, 0xef, 0xb4, 0xfb, 0xf9, 0xf2, 0xa4,
-    0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xfc, 0xfc, 0xfc, 0xff,
-    0xf8, 0xf7, 0xf7, 0xff, 0xf5, 0xf3, 0xf3, 0xff, 0xf1, 0xef, 0xef, 0xff,
-    0xef, 0xec, 0xeb, 0xff, 0xeb, 0xe7, 0xe7, 0xff, 0xea, 0xe7, 0xe6, 0xff,
-    0xe7, 0xe3, 0xe2, 0xff, 0xe4, 0xdf, 0xde, 0xff, 0xe6, 0xe2, 0xe2, 0xff,
-    0xe4, 0xe1, 0xe0, 0xff, 0xe6, 0xe3, 0xe2, 0xff, 0xe0, 0xdc, 0xdc, 0xff,
-    0xe3, 0xdf, 0xdf, 0xff, 0xe8, 0xe5, 0xe5, 0xff, 0xe4, 0xe1, 0xe2, 0xff,
-    0xec, 0xe8, 0xe5, 0xf8, 0xff, 0xff, 0xff, 0xa4, 0xff, 0xff, 0xff, 0xa0,
-    0xff, 0xff, 0xff, 0x9b, 0xff, 0xff, 0xff, 0x97, 0xff, 0xff, 0xff, 0x90,
-    0xfe, 0xfe, 0xfb, 0x9c, 0xfc, 0xf9, 0xef, 0xf7, 0xfc, 0xf8, 0xed, 0xff,
-    0xfc, 0xf7, 0xeb, 0xff, 0xfb, 0xf7, 0xeb, 0xff, 0xfa, 0xf6, 0xe9, 0xff,
-    0xfa, 0xf5, 0xe7, 0xff, 0xf8, 0xf4, 0xe5, 0xff,
-    0xfd, 0xfd, 0xfd, 0xff, 0xfa, 0xfa, 0xfa, 0xff, 0xfc, 0xfc, 0xfc, 0xff,
-    0xf8, 0xf7, 0xf7, 0xff, 0xf1, 0xef, 0xee, 0xff, 0xed, 0xea, 0xe9, 0xff,
-    0xea, 0xe6, 0xe5, 0xff, 0xe7, 0xe3, 0xe2, 0xff, 0xe4, 0xe0, 0xdf, 0xff,
-    0xe3, 0xde, 0xdd, 0xff, 0xe2, 0xde, 0xdd, 0xff, 0xe5, 0xe1, 0xe1, 0xff,
-    0xde, 0xda, 0xda, 0xff, 0xe0, 0xdd, 0xdc, 0xff, 0xe1, 0xdd, 0xdd, 0xff,
-    0xe3, 0xe0, 0xdf, 0xff, 0xe4, 0xe1, 0xe1, 0xff, 0xe3, 0xe0, 0xe0, 0xff,
-    0xec, 0xea, 0xea, 0xe8, 0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 0x98,
-    0xff, 0xff, 0xff, 0x93, 0xff, 0xff, 0xff, 0x8f, 0xfe, 0xfe, 0xfe, 0x8c,
-    0xfd, 0xfb, 0xef, 0xff, 0xfd, 0xfb, 0xed, 0xff, 0xfd, 0xf8, 0xec, 0xff,
-    0xfc, 0xf8, 0xeb, 0xff, 0xfc, 0xf7, 0xea, 0xff, 0xfb, 0xf6, 0xe9, 0xff,
-    0xfa, 0xf6, 0xe7, 0xff, 0xfa, 0xf5, 0xe5, 0xff,
-    0xfa, 0xfa, 0xfa, 0xff, 0xf8, 0xf7, 0xf8, 0xff, 0xf6, 0xf6, 0xf6, 0xff,
-    0xf1, 0xf0, 0xf0, 0xff, 0xed, 0xec, 0xec, 0xff, 0xe9, 0xe6, 0xe5, 0xff,
-    0xe6, 0xe1, 0xe0, 0xff, 0xe2, 0xde, 0xdc, 0xff, 0xe0, 0xda, 0xd8, 0xff,
-    0xdd, 0xd7, 0xd5, 0xff, 0xde, 0xda, 0xd9, 0xff, 0xde, 0xda, 0xda, 0xff,
-    0xdc, 0xd7, 0xd8, 0xff, 0xdf, 0xdc, 0xdc, 0xff, 0xe5, 0xe3, 0xe4, 0xff,
-    0xe1, 0xde, 0xde, 0xff, 0xde, 0xdc, 0xdc, 0xff, 0xe9, 0xe7, 0xe8, 0xff,
-    0xe8, 0xe7, 0xe6, 0xe7, 0xff, 0xff, 0xff, 0x97, 0xff, 0xff, 0xff, 0x93,
-    0xff, 0xff, 0xff, 0x8c, 0xff, 0xff, 0xff, 0x88, 0xfe, 0xfe, 0xfa, 0x9b,
-    0xfc, 0xfb, 0xee, 0xff, 0xfc, 0xfa, 0xed, 0xff, 0xfb, 0xfa, 0xeb, 0xff,
-    0xfb, 0xf8, 0xeb, 0xff, 0xfb, 0xf7, 0xea, 0xff, 0xfa, 0xf6, 0xe8, 0xff,
-    0xf8, 0xf6, 0xe6, 0xff, 0xf7, 0xf5, 0xe3, 0xff,
-    0xf9, 0xf9, 0xf9, 0xff, 0xf7, 0xf6, 0xf7, 0xff, 0xf5, 0xf4, 0xf4, 0xff,
-    0xf0, 0xee, 0xef, 0xff, 0xe8, 0xe7, 0xe7, 0xff, 0xe7, 0xe4, 0xe3, 0xff,
-    0xe2, 0xdd, 0xdb, 0xff, 0xdf, 0xd9, 0xd7, 0xff, 0xdc, 0xd6, 0xd4, 0xff,
-    0xd8, 0xd2, 0xcf, 0xff, 0xd8, 0xd2, 0xd1, 0xff, 0xe0, 0xdc, 0xdc, 0xff,
-    0xdb, 0xd7, 0xd7, 0xff, 0xdb, 0xd7, 0xd7, 0xff, 0xe7, 0xe5, 0xe5, 0xff,
-    0xde, 0xda, 0xdb, 0xff, 0xdb, 0xd8, 0xd9, 0xff, 0xe0, 0xde, 0xde, 0xff,
-    0xed, 0xeb, 0xec, 0xe4, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0x8b,
-    0xff, 0xff, 0xff, 0x87, 0xff, 0xff, 0xff, 0x80, 0xfe, 0xfe, 0xfa, 0x94,
-    0xfd, 0xfb, 0xee, 0xff, 0xfd, 0xfb, 0xed, 0xff, 0xfc, 0xfb, 0xec, 0xff,
-    0xfc, 0xfa, 0xea, 0xff, 0xf8, 0xf7, 0xe9, 0xff, 0xf8, 0xf6, 0xe7, 0xff,
-    0xf7, 0xf7, 0xe5, 0xff, 0xf7, 0xf5, 0xe3, 0xff,
-    0xf9, 0xf9, 0xf9, 0xff, 0xf5, 0xf4, 0xf4, 0xff, 0xf2, 0xf2, 0xf2, 0xff,
-    0xe9, 0xe6, 0xe6, 0xff, 0xe9, 0xe7, 0xe6, 0xff, 0xe9, 0xe7, 0xe7, 0xff,
-    0xe0, 0xdb, 0xda, 0xff, 0xda, 0xd3, 0xd2, 0xff, 0xd6, 0xd0, 0xce, 0xff,
-    0xd4, 0xcd, 0xcb, 0xff, 0xd0, 0xc8, 0xc7, 0xff, 0xd7, 0xd2, 0xd1, 0xff,
-    0xd8, 0xd3, 0xd3, 0xff, 0xd4, 0xd1, 0xd1, 0xff, 0xe6, 0xe3, 0xe2, 0xff,
-    0xdd, 0xda, 0xda, 0xff, 0xe3, 0xe1, 0xe1, 0xff, 0xe0, 0xde, 0xde, 0xff,
-    0xe7, 0xe5, 0xe5, 0xe3, 0xff, 0xff, 0xff, 0x88, 0xff, 0xff, 0xff, 0x84,
-    0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7b, 0xfe, 0xfe, 0xfb, 0x88,
-    0xfc, 0xfc, 0xef, 0xff, 0xfb, 0xfc, 0xee, 0xff, 0xfb, 0xfa, 0xeb, 0xff,
-    0xfa, 0xfa, 0xea, 0xff, 0xf9, 0xf9, 0xe7, 0xff, 0xf7, 0xf7, 0xe6, 0xff,
-    0xf6, 0xf5, 0xe5, 0xff, 0xf7, 0xf5, 0xe3, 0xff,
-    0xf8, 0xf7, 0xf7, 0xff, 0xf4, 0xf4, 0xf4, 0xff, 0xf2, 0xf2, 0xf1, 0xff,
-    0xe8, 0xe6, 0xe6, 0xff, 0xe4, 0xe1, 0xe1, 0xff, 0xdd, 0xda, 0xda, 0xff,
-    0xe7, 0xe3, 0xe3, 0xff, 0xd6, 0xcf, 0xcd, 0xff, 0xd4, 0xcc, 0xca, 0xff,
-    0xcf, 0xc7, 0xc5, 0xff, 0xcc, 0xc3, 0xc1, 0xff, 0xd3, 0xce, 0xcc, 0xff,
-    0xd9, 0xd4, 0xd4, 0xff, 0xda, 0xd6, 0xd6, 0xff, 0xe3, 0xe1, 0xe0, 0xff,
-    0xdb, 0xd8, 0xd7, 0xff, 0xe4, 0xe2, 0xe2, 0xff, 0xe1, 0xde, 0xdf, 0xff,
-    0xe3, 0xe1, 0xe1, 0xf0, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xff, 0x7c,
-    0xff, 0xff, 0xff, 0x78, 0xff, 0xff, 0xff, 0x73, 0xff, 0xff, 0xff, 0x6f,
-    0xfb, 0xfc, 0xed, 0xff, 0xfa, 0xfb, 0xed, 0xff, 0xfb, 0xfa, 0xeb, 0xff,
-    0xfa, 0xf9, 0xe9, 0xff, 0xfa, 0xf9, 0xe7, 0xff, 0xf8, 0xf9, 0xe7, 0xff,
-    0xf7, 0xf5, 0xe3, 0xff, 0xf7, 0xf4, 0xe1, 0xff,
-    0xf2, 0xf2, 0xf2, 0xff, 0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0xf0, 0xef, 0xff,
-    0xe5, 0xe3, 0xe3, 0xff, 0xdd, 0xd9, 0xd9, 0xff, 0xdf, 0xdc, 0xdc, 0xff,
-    0xe6, 0xe3, 0xe3, 0xff, 0xe1, 0xda, 0xdb, 0xff, 0xd2, 0xca, 0xc7, 0xff,
-    0xca, 0xc2, 0xc0, 0xff, 0xc7, 0xbe, 0xbc, 0xff, 0xc8, 0xc2, 0xc0, 0xff,
-    0xd2, 0xcf, 0xce, 0xff, 0xd5, 0xcf, 0xd0, 0xff, 0xd5, 0xd1, 0xd1, 0xff,
-    0xda, 0xd6, 0xd7, 0xff, 0xde, 0xdc, 0xdd, 0xff, 0xde, 0xdd, 0xdc, 0xff,
-    0xe2, 0xe0, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x7c, 0xff, 0xff, 0xff, 0x77,
-    0xff, 0xff, 0xff, 0x70, 0xff, 0xff, 0xff, 0x6c, 0xff, 0xff, 0xff, 0x67,
-    0xfa, 0xfd, 0xed, 0xf8, 0xf9, 0xfc, 0xeb, 0xff, 0xf9, 0xfb, 0xea, 0xff,
-    0xf8, 0xf9, 0xe8, 0xff, 0xf7, 0xf9, 0xe6, 0xff, 0xf7, 0xf8, 0xe6, 0xff,
-    0xf6, 0xf5, 0xe4, 0xff, 0xf6, 0xf4, 0xe1, 0xff,
-    0xe7, 0xe7, 0xe7, 0xff, 0xe3, 0xe4, 0xe3, 0xff, 0xe1, 0xe2, 0xe2, 0xff,
-    0xe4, 0xe4, 0xe4, 0xff, 0xd7, 0xd6, 0xd5, 0xff, 0xd5, 0xd4, 0xd4, 0xff,
-    0xdd, 0xdc, 0xdc, 0xff, 0xdc, 0xda, 0xda, 0xff, 0xd0, 0xc9, 0xc9, 0xff,
-    0xc9, 0xbf, 0xbe, 0xff, 0xc2, 0xba, 0xb8, 0xff, 0xc0, 0xb8, 0xb6, 0xff,
-    0xcc, 0xc7, 0xc7, 0xff, 0xd2, 0xcd, 0xcd, 0xff, 0xd2, 0xce, 0xcf, 0xff,
-    0xd1, 0xcc, 0xcd, 0xff, 0xdf, 0xde, 0xde, 0xff, 0xe7, 0xe6, 0xe6, 0xff,
-    0xe4, 0xe3, 0xe3, 0xff, 0xfd, 0xfd, 0xfd, 0x78, 0xff, 0xff, 0xff, 0x70,
-    0xff, 0xff, 0xff, 0x6b, 0xff, 0xff, 0xff, 0x67, 0xff, 0xff, 0xff, 0x60,
-    0xfc, 0xfe, 0xef, 0xcf, 0xf9, 0xfc, 0xec, 0xff, 0xfa, 0xfa, 0xe9, 0xff,
-    0xf8, 0xfa, 0xe8, 0xff, 0xf7, 0xf7, 0xe5, 0xff, 0xf6, 0xf7, 0xe5, 0xff,
-    0xf5, 0xf5, 0xe3, 0xff, 0xf6, 0xf4, 0xe0, 0xff,
-    0xdc, 0xdd, 0xdd, 0xff, 0xdb, 0xdc, 0xdc, 0xff, 0xd3, 0xd4, 0xd4, 0xff,
-    0xd8, 0xd8, 0xd8, 0xff, 0xd1, 0xd1, 0xd1, 0xff, 0xd0, 0xd0, 0xd0, 0xff,
-    0xca, 0xcb, 0xcb, 0xff, 0xcc, 0xcc, 0xcd, 0xff, 0xcb, 0xcb, 0xcb, 0xff,
-    0xc6, 0xc1, 0xc1, 0xff, 0xc0, 0xbc, 0xba, 0xff, 0xba, 0xb1, 0xaf, 0xff,
-    0xc5, 0xbf, 0xc0, 0xff, 0xd6, 0xd2, 0xd2, 0xff, 0xc4, 0xbf, 0xbf, 0xff,
-    0xd3, 0xce, 0xcd, 0xff, 0xd3, 0xd1, 0xd2, 0xff, 0xe3, 0xe2, 0xe2, 0xff,
-    0xe6, 0xe4, 0xe4, 0xff, 0xee, 0xee, 0xed, 0x9b, 0xff, 0xff, 0xff, 0x68,
-    0xff, 0xff, 0xff, 0x63, 0xff, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xff, 0x5b,
-    0xfd, 0xfe, 0xf6, 0x80, 0xf9, 0xfc, 0xeb, 0xff, 0xf7, 0xfa, 0xeb, 0xff,
-    0xf7, 0xf9, 0xe9, 0xff, 0xf6, 0xf8, 0xe8, 0xff, 0xf6, 0xf7, 0xe5, 0xff,
-    0xf5, 0xf4, 0xe4, 0xff, 0xf5, 0xf4, 0xe3, 0xff,
-    0xd7, 0xd8, 0xd8, 0xff, 0xd4, 0xd5, 0xd4, 0xff, 0xd2, 0xd3, 0xd3, 0xff,
-    0xcf, 0xd0, 0xd0, 0xff, 0xcc, 0xce, 0xcd, 0xff, 0xc9, 0xca, 0xca, 0xff,
-    0xc5, 0xc6, 0xc6, 0xff, 0xc3, 0xc4, 0xc4, 0xff, 0xbf, 0xbf, 0xbd, 0xff,
-    0xbe, 0xbf, 0xbf, 0xff, 0xba, 0xba, 0xba, 0xff, 0xb4, 0xb1, 0xb1, 0xff,
-    0xbb, 0xba, 0xb9, 0xff, 0xc9, 0xc8, 0xc7, 0xff, 0xe2, 0xde, 0xde, 0xff,
-    0xc1, 0xbd, 0xbd, 0xff, 0xd6, 0xd5, 0xd5, 0xff, 0xde, 0xdd, 0xdc, 0xff,
-    0xdc, 0xda, 0xda, 0xff, 0xe6, 0xe5, 0xe5, 0xcf, 0xff, 0xff, 0xff, 0x63,
-    0xff, 0xff, 0xff, 0x5c, 0xff, 0xff, 0xff, 0x58, 0xff, 0xff, 0xff, 0x53,
-    0xff, 0xff, 0xff, 0x4f, 0xf9, 0xfc, 0xeb, 0xfb, 0xf6, 0xf9, 0xeb, 0xff,
-    0xf6, 0xf9, 0xea, 0xff, 0xf6, 0xf9, 0xe8, 0xff, 0xf5, 0xf5, 0xe4, 0xff,
-    0xf6, 0xf6, 0xe4, 0xff, 0xf5, 0xf4, 0xe2, 0xff,
-    0xd3, 0xd4, 0xd4, 0xff, 0xcc, 0xcd, 0xcd, 0xff, 0xce, 0xcf, 0xcf, 0xff,
-    0xc9, 0xcb, 0xcb, 0xff, 0xc6, 0xc7, 0xc7, 0xff, 0xc3, 0xc5, 0xc4, 0xff,
-    0xc0, 0xc1, 0xc1, 0xff, 0xbb, 0xbd, 0xbc, 0xff, 0xb7, 0xb9, 0xb8, 0xff,
-    0xb6, 0xb7, 0xb7, 0xff, 0xb4, 0xb7, 0xb6, 0xff, 0xaf, 0xaf, 0xaf, 0xff,
-    0xb0, 0xb2, 0xb2, 0xff, 0xb5, 0xb5, 0xb5, 0xff, 0xc1, 0xc0, 0xc0, 0xff,
-    0xc9, 0xc6, 0xc7, 0xff, 0xb3, 0xad, 0xae, 0xff, 0xcf, 0xcd, 0xce, 0xff,
-    0xe3, 0xe2, 0xe2, 0xff, 0xe4, 0xe2, 0xe2, 0xff, 0xfd, 0xfd, 0xfd, 0x60,
-    0xff, 0xff, 0xff, 0x57, 0xff, 0xff, 0xff, 0x50, 0xff, 0xff, 0xff, 0x4c,
-    0xff, 0xff, 0xff, 0x47, 0xfa, 0xfb, 0xef, 0xa8, 0xf8, 0xfc, 0xed, 0xff,
-    0xf7, 0xf9, 0xea, 0xff, 0xf6, 0xf7, 0xe7, 0xff, 0xf6, 0xf4, 0xe7, 0xff,
-    0xf5, 0xf4, 0xe5, 0xff, 0xf4, 0xf3, 0xe3, 0xff,
-    0xce, 0xcf, 0xcf, 0xff, 0xc8, 0xc9, 0xc9, 0xff, 0xc6, 0xc8, 0xc8, 0xff,
-    0xc4, 0xc6, 0xc6, 0xff, 0xc2, 0xc3, 0xc3, 0xff, 0xba, 0xbd, 0xbc, 0xff,
-    0xbc, 0xbe, 0xbe, 0xff, 0xb5, 0xb8, 0xb7, 0xff, 0xb4, 0xb6, 0xb5, 0xff,
-    0xb0, 0xb2, 0xb2, 0xff, 0xaf, 0xb1, 0xb0, 0xff, 0xaa, 0xad, 0xac, 0xff,
-    0xaa, 0xad, 0xac, 0xff, 0xa7, 0xa9, 0xa8, 0xff, 0xa4, 0xa5, 0xa5, 0xff,
-    0xa7, 0xa8, 0xa8, 0xff, 0xc4, 0xc3, 0xc3, 0xff, 0xb8, 0xb7, 0xb7, 0xff,
-    0xc0, 0xbf, 0xbe, 0xff, 0xd0, 0xce, 0xce, 0xff, 0xe3, 0xe2, 0xe2, 0x94,
-    0xff, 0xff, 0xff, 0x4f, 0xff, 0xff, 0xff, 0x4b, 0xff, 0xff, 0xff, 0x44,
-    0xff, 0xff, 0xff, 0x40, 0xed, 0xe7, 0xe6, 0x48, 0xba, 0xad, 0xa1, 0xff,
-    0xd6, 0xcf, 0xc1, 0xff, 0xf4, 0xf3, 0xe4, 0xff, 0xf5, 0xf4, 0xe5, 0xff,
-    0xf5, 0xf3, 0xe5, 0xff, 0xf5, 0xf5, 0xe5, 0xff,
-    0xc7, 0xc9, 0xc8, 0xff, 0xc5, 0xc6, 0xc6, 0xff, 0xc1, 0xc2, 0xc2, 0xff,
-    0xbd, 0xbe, 0xbe, 0xff, 0xba, 0xbc, 0xbb, 0xff, 0xb3, 0xb4, 0xb4, 0xff,
-    0xb2, 0xb5, 0xb4, 0xff, 0xb1, 0xb4, 0xb3, 0xff, 0xac, 0xaf, 0xae, 0xff,
-    0xa8, 0xaa, 0xa9, 0xff, 0xa8, 0xab, 0xaa, 0xff, 0xa1, 0xa4, 0xa3, 0xff,
-    0xa1, 0xa4, 0xa3, 0xff, 0xa3, 0xa5, 0xa4, 0xff, 0x9f, 0xa1, 0xa0, 0xff,
-    0x99, 0x9b, 0x9a, 0xff, 0x98, 0x9a, 0x9a, 0xff, 0x97, 0x9a, 0x99, 0xff,
-    0xa0, 0xa0, 0xa0, 0xff, 0x9b, 0x9b, 0x9b, 0xff, 0x9f, 0xa0, 0x9f, 0xe8,
-    0xff, 0xff, 0xff, 0x48, 0xff, 0xff, 0xff, 0x44, 0xff, 0xff, 0xff, 0x3f,
-    0xff, 0xff, 0xff, 0x3b, 0xff, 0xff, 0xff, 0x34, 0xbb, 0xa7, 0xa5, 0xd8,
-    0xb9, 0xa9, 0xa6, 0xff, 0xb9, 0xac, 0xa0, 0xff, 0xf8, 0xfa, 0xe7, 0xff,
-    0xf5, 0xf4, 0xe6, 0xff, 0xf4, 0xf3, 0xe4, 0xff,
-    0xc0, 0xc0, 0xbf, 0xff, 0xbb, 0xbb, 0xbb, 0xff, 0xbb, 0xbc, 0xbb, 0xff,
-    0xb6, 0xb6, 0xb6, 0xff, 0xb0, 0xb1, 0xb1, 0xff, 0xad, 0xad, 0xad, 0xff,
-    0xa8, 0xa7, 0xa7, 0xff, 0xa8, 0xa9, 0xa9, 0xff, 0xa5, 0xa6, 0xa6, 0xff,
-    0xa4, 0xa6, 0xa5, 0xff, 0xa3, 0xa6, 0xa6, 0xff, 0x9b, 0x9d, 0x9c, 0xff,
-    0x96, 0x99, 0x99, 0xff, 0x9b, 0x9d, 0x9d, 0xff, 0x97, 0x99, 0x98, 0xff,
-    0x8e, 0x91, 0x91, 0xff, 0x98, 0x9b, 0x9b, 0xff, 0x89, 0x8c, 0x8b, 0xff,
-    0x87, 0x8b, 0x89, 0xff, 0x84, 0x7f, 0x81, 0xff, 0x82, 0x82, 0x83, 0xff,
-    0xc0, 0xbe, 0xbf, 0x67, 0xff, 0xff, 0xff, 0x3c, 0xff, 0xff, 0xff, 0x37,
-    0xff, 0xff, 0xff, 0x33, 0xff, 0xff, 0xff, 0x2f, 0xc6, 0xbb, 0xb9, 0x50,
-    0xac, 0x9c, 0x99, 0xff, 0xa8, 0x98, 0x91, 0xff, 0xbd, 0xb0, 0xa5, 0xff,
-    0xf6, 0xf5, 0xe6, 0xff, 0xf4, 0xf3, 0xe4, 0xff,
-    0xbb, 0xbb, 0xba, 0xff, 0xb3, 0xb3, 0xb3, 0xff, 0xb3, 0xb4, 0xb4, 0xff,
-    0xae, 0xaf, 0xae, 0xff, 0xad, 0xae, 0xae, 0xff, 0xb2, 0xb4, 0xb4, 0xfc,
-    0xa8, 0xa8, 0xa9, 0xf3, 0xa7, 0xa7, 0xa7, 0xf3, 0x9e, 0x9f, 0x9d, 0xfc,
-    0x9b, 0x9c, 0x9a, 0xff, 0x9c, 0x9e, 0x9e, 0xff, 0x94, 0x96, 0x94, 0xff,
-    0x90, 0x90, 0x90, 0xff, 0x96, 0x98, 0x99, 0xff, 0x8d, 0x8f, 0x8e, 0xff,
-    0x83, 0x83, 0x84, 0xff, 0x8f, 0x92, 0x91, 0xff, 0x83, 0x85, 0x85, 0xff,
-    0x87, 0x87, 0x87, 0xff, 0x7c, 0x7d, 0x7d, 0xff, 0x78, 0x74, 0x72, 0xff,
-    0x95, 0x93, 0x92, 0x97, 0xff, 0xff, 0xff, 0x34, 0xff, 0xff, 0xff, 0x30,
-    0xff, 0xff, 0xff, 0x2c, 0xff, 0xff, 0xff, 0x27, 0xff, 0xff, 0xff, 0x23,
-    0xa2, 0x93, 0x94, 0xe7, 0x96, 0x83, 0x81, 0xff, 0xa8, 0x91, 0x8b, 0xff,
-    0xc4, 0xbc, 0xb2, 0xff, 0xf5, 0xf5, 0xe4, 0xff,
-    0xb7, 0xb9, 0xb8, 0xff, 0xaf, 0xaf, 0xae, 0xff, 0xaf, 0xaf, 0xaf, 0xff,
-    0xac, 0xad, 0xae, 0xff, 0xa8, 0xaa, 0xa9, 0xff, 0xae, 0xaf, 0xaf, 0xec,
-    0xc6, 0xc7, 0xc7, 0xb4, 0xc5, 0xc6, 0xc6, 0xb3, 0x9a, 0x99, 0x99, 0xeb,
-    0x91, 0x91, 0x90, 0xff, 0x94, 0x95, 0x95, 0xff, 0x95, 0x96, 0x96, 0xff,
-    0x8c, 0x8e, 0x8e, 0xff, 0x86, 0x88, 0x87, 0xff, 0x83, 0x82, 0x82, 0xff,
-    0x80, 0x81, 0x81, 0xff, 0x82, 0x84, 0x84, 0xff, 0x7b, 0x79, 0x7a, 0xff,
-    0x73, 0x74, 0x73, 0xff, 0x79, 0x7a, 0x7b, 0xff, 0x75, 0x73, 0x72, 0xff,
-    0x6f, 0x70, 0x6e, 0xfc, 0xe8, 0xe7, 0xe7, 0x37, 0xff, 0xff, 0xff, 0x2b,
-    0xff, 0xff, 0xff, 0x24, 0xff, 0xff, 0xff, 0x20, 0xff, 0xff, 0xff, 0x1c,
-    0x70, 0x6e, 0x6d, 0xeb, 0x6c, 0x69, 0x66, 0xff, 0x83, 0x78, 0x7b, 0xff,
-    0x83, 0x7f, 0x78, 0xff, 0xdc, 0xd5, 0xcd, 0xff,
-    0xb3, 0xb5, 0xb4, 0xff, 0xa9, 0xa9, 0xaa, 0xff, 0xa7, 0xa8, 0xa7, 0xff,
-    0xa7, 0xa8, 0xa7, 0xff, 0xa6, 0xa8, 0xa8, 0xff, 0xab, 0xac, 0xab, 0xe3,
-    0xdb, 0xdc, 0xdc, 0x97, 0xd9, 0xda, 0xda, 0x93, 0x99, 0x99, 0x98, 0xe0,
-    0x94, 0x95, 0x95, 0xff, 0x8e, 0x8f, 0x8e, 0xff, 0x8f, 0x93, 0x92, 0xff,
-    0x88, 0x8a, 0x89, 0xff, 0x79, 0x78, 0x78, 0xff, 0x80, 0x82, 0x82, 0xff,
-    0x7f, 0x81, 0x81, 0xff, 0x7f, 0x7d, 0x7e, 0xff, 0x76, 0x72, 0x72, 0xff,
-    0x70, 0x70, 0x70, 0xff, 0x73, 0x73, 0x73, 0xff, 0x67, 0x66, 0x64, 0xff,
-    0x6b, 0x6b, 0x6a, 0xff, 0x70, 0x73, 0x72, 0xd4, 0xff, 0xff, 0xff, 0x23,
-    0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0x1b, 0x79, 0x74, 0x72, 0x67,
-    0x63, 0x61, 0x61, 0xff, 0x63, 0x62, 0x60, 0xff, 0x5e, 0x5c, 0x5a, 0xff,
-    0x61, 0x5f, 0x5c, 0xff, 0x6b, 0x63, 0x5e, 0xff,
-    0xae, 0xaf, 0xaf, 0xff, 0xa9, 0xa9, 0xa9, 0xff, 0x9c, 0x9b, 0x99, 0xff,
-    0x9d, 0x9c, 0x9b, 0xff, 0x9c, 0x9c, 0x9c, 0xff, 0x9c, 0x9c, 0x9d, 0xf7,
-    0xaa, 0xac, 0xac, 0xd4, 0xa5, 0xa7, 0xa6, 0xd3, 0x98, 0x9a, 0x9a, 0xf4,
-    0x8d, 0x8e, 0x8e, 0xff, 0x85, 0x85, 0x85, 0xff, 0x85, 0x86, 0x86, 0xff,
-    0x82, 0x84, 0x84, 0xff, 0x7b, 0x7b, 0x7b, 0xff, 0x7e, 0x82, 0x81, 0xff,
-    0x79, 0x7b, 0x7b, 0xff, 0x79, 0x7b, 0x7b, 0xff, 0x72, 0x73, 0x73, 0xff,
-    0x70, 0x6e, 0x6e, 0xff, 0x6d, 0x6d, 0x6d, 0xff, 0x61, 0x5f, 0x5d, 0xff,
-    0x5d, 0x5d, 0x5b, 0xff, 0x64, 0x60, 0x61, 0xff, 0x5e, 0x5d, 0x5d, 0xec,
-    0x6a, 0x69, 0x67, 0xa0, 0x67, 0x66, 0x64, 0xbc, 0x59, 0x56, 0x55, 0xff,
-    0x54, 0x51, 0x4e, 0xff, 0x56, 0x52, 0x51, 0xff, 0x55, 0x52, 0x4f, 0xff,
-    0x52, 0x4e, 0x49, 0xff, 0x54, 0x54, 0x52, 0xff,
-    0xa9, 0xac, 0xab, 0xff, 0xa1, 0xa0, 0xa0, 0xff, 0x9a, 0x99, 0x98, 0xff,
-    0x97, 0x97, 0x96, 0xff, 0x95, 0x94, 0x94, 0xff, 0x8e, 0x8c, 0x8c, 0xff,
-    0x95, 0x98, 0x97, 0xfc, 0x90, 0x91, 0x91, 0xfc, 0x95, 0x96, 0x96, 0xff,
-    0x86, 0x86, 0x86, 0xff, 0x81, 0x82, 0x80, 0xff, 0x7d, 0x7e, 0x7b, 0xff,
-    0x78, 0x79, 0x78, 0xff, 0x71, 0x70, 0x6e, 0xff, 0x72, 0x71, 0x70, 0xff,
-    0x72, 0x73, 0x72, 0xff, 0x70, 0x70, 0x6e, 0xff, 0x6d, 0x6a, 0x6a, 0xff,
-    0x64, 0x64, 0x63, 0xff, 0x69, 0x68, 0x67, 0xff, 0x61, 0x5f, 0x5e, 0xff,
-    0x59, 0x57, 0x57, 0xff, 0x5f, 0x5f, 0x5e, 0xff, 0x55, 0x55, 0x53, 0xff,
-    0x57, 0x58, 0x57, 0xff, 0x51, 0x53, 0x50, 0xff, 0x54, 0x51, 0x51, 0xff,
-    0x4c, 0x4b, 0x4a, 0xff, 0x49, 0x4a, 0x47, 0xff, 0x4f, 0x51, 0x4e, 0xff,
-    0x4f, 0x4d, 0x49, 0xff, 0x4c, 0x4b, 0x46, 0xff,
-    0xa7, 0xaa, 0xaa, 0xff, 0x99, 0x98, 0x98, 0xff, 0x95, 0x92, 0x92, 0xff,
-    0x94, 0x93, 0x92, 0xff, 0x8a, 0x87, 0x84, 0xff, 0x85, 0x80, 0x7f, 0xff,
-    0x8d, 0x90, 0x8f, 0xff, 0x85, 0x85, 0x85, 0xff, 0x8e, 0x8e, 0x8e, 0xff,
-    0x80, 0x80, 0x81, 0xff, 0x7c, 0x7d, 0x7b, 0xff, 0x79, 0x79, 0x78, 0xff,
-    0x78, 0x79, 0x78, 0xff, 0x6e, 0x6c, 0x6b, 0xff, 0x68, 0x66, 0x66, 0xff,
-    0x69, 0x6a, 0x67, 0xff, 0x60, 0x5e, 0x5d, 0xff, 0x5b, 0x58, 0x57, 0xff,
-    0x58, 0x56, 0x55, 0xff, 0x61, 0x5e, 0x5d, 0xff, 0x54, 0x53, 0x52, 0xff,
-    0x60, 0x5d, 0x5c, 0xff, 0x5b, 0x5b, 0x5a, 0xff, 0x59, 0x5a, 0x58, 0xff,
-    0x48, 0x43, 0x42, 0xff, 0x44, 0x40, 0x40, 0xff, 0x48, 0x46, 0x44, 0xff,
-    0x4a, 0x46, 0x46, 0xff, 0x4c, 0x4f, 0x4c, 0xff, 0x49, 0x4a, 0x48, 0xff,
-    0x47, 0x46, 0x41, 0xff, 0x44, 0x43, 0x3f, 0xff,
-    0xa2, 0xa4, 0xa4, 0xff, 0x96, 0x95, 0x96, 0xff, 0x8e, 0x8c, 0x8a, 0xff,
-    0x89, 0x86, 0x86, 0xff, 0x82, 0x7c, 0x7c, 0xff, 0x83, 0x80, 0x7f, 0xff,
-    0x82, 0x82, 0x80, 0xff, 0x82, 0x83, 0x81, 0xff, 0x82, 0x85, 0x85, 0xff,
-    0x7c, 0x7c, 0x7c, 0xff, 0x77, 0x78, 0x75, 0xff, 0x75, 0x77, 0x76, 0xff,
-    0x71, 0x72, 0x70, 0xff, 0x68, 0x66, 0x65, 0xff, 0x62, 0x60, 0x5f, 0xff,
-    0x5f, 0x5e, 0x5c, 0xff, 0x5a, 0x52, 0x4f, 0xff, 0x5b, 0x53, 0x4f, 0xff,
-    0x50, 0x49, 0x49, 0xff, 0x5c, 0x58, 0x57, 0xff, 0x50, 0x4b, 0x49, 0xff,
-    0x57, 0x54, 0x53, 0xff, 0x4f, 0x4f, 0x4e, 0xff, 0x53, 0x57, 0x55, 0xff,
-    0x48, 0x45, 0x44, 0xff, 0x3c, 0x33, 0x33, 0xff, 0x49, 0x45, 0x43, 0xff,
-    0x41, 0x3f, 0x3d, 0xff, 0x49, 0x46, 0x44, 0xff, 0x4a, 0x48, 0x47, 0xff,
-    0x3f, 0x3c, 0x3a, 0xff, 0x43, 0x41, 0x3e, 0xff,
-    0x99, 0x9c, 0x9a, 0xff, 0x90, 0x8e, 0x8f, 0xff, 0x8c, 0x8b, 0x89, 0xff,
-    0x81, 0x7c, 0x7c, 0xff, 0x7d, 0x78, 0x78, 0xff, 0x82, 0x82, 0x80, 0xff,
-    0x77, 0x74, 0x73, 0xff, 0x75, 0x73, 0x73, 0xff, 0x78, 0x76, 0x76, 0xff,
-    0x70, 0x6f, 0x6f, 0xff, 0x6d, 0x6c, 0x6b, 0xff, 0x6e, 0x6f, 0x6d, 0xff,
-    0x68, 0x68, 0x66, 0xff, 0x5f, 0x5b, 0x5b, 0xff, 0x5b, 0x56, 0x56, 0xff,
-    0x5a, 0x58, 0x57, 0xff, 0x53, 0x49, 0x47, 0xff, 0x4e, 0x45, 0x43, 0xff,
-    0x49, 0x43, 0x41, 0xff, 0x5f, 0x5b, 0x5a, 0xff, 0x46, 0x3f, 0x3e, 0xff,
-    0x4b, 0x48, 0x47, 0xff, 0x42, 0x3f, 0x3f, 0xff, 0x4d, 0x50, 0x50, 0xff,
-    0x52, 0x52, 0x51, 0xff, 0x37, 0x31, 0x30, 0xff, 0x3d, 0x38, 0x37, 0xff,
-    0x3f, 0x39, 0x38, 0xff, 0x40, 0x3c, 0x3b, 0xff, 0x4a, 0x48, 0x47, 0xff,
-    0x3f, 0x3d, 0x3b, 0xff, 0x46, 0x45, 0x43, 0xff,
-};
-
-#endif  // WEBP_TESTS_FUZZER_IMG_ALPHA_H_
--- a/tests/fuzzer/img_grid.h
+++ b/tests/fuzzer/img_grid.h
@ -1,125 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef WEBP_TESTS_FUZZER_IMG_GRID_H_
-#define WEBP_TESTS_FUZZER_IMG_GRID_H_
-
-#include <stdint.h>
-
-static const int kImgGridWidth = 16;
-static const int kImgGridHeight = 16;
-
-/*Pixel format: Red: 8 bit, Green: 8 bit, Blue: 8 bit, Fix 0xFF: 8 bit*/
-static const uint8_t kImgGridData[] = {
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
-    0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff,
-    0xff, 0x00, 0x00, 0xff,
-};
-
-#endif  // WEBP_TESTS_FUZZER_IMG_GRID_H_
--- a/tests/fuzzer/img_peak.h
+++ b/tests/fuzzer/img_peak.h
--- a/tests/fuzzer/makefile.unix
+++ b/tests/fuzzer/makefile.unix
@ -1,30 +0,0 @@
-# This Makefile will compile all fuzzing targets. It doesn't check tool
-# requirements and paths may need to be updated depending on your environment.
-# Note a clang 6+ toolchain is assumed for use of -fsanitize=fuzzer.
-
-CC = clang
-CXX = clang++
-CFLAGS = -fsanitize=fuzzer -I../../src -I../.. -Wall -Wextra
-CXXFLAGS = $(CFLAGS)
-LDFLAGS = -fsanitize=fuzzer
-LDLIBS = ../../src/mux/libwebpmux.a ../../src/demux/libwebpdemux.a
-LDLIBS += ../../src/libwebp.a ../../imageio/libimageio_util.a
-
-FUZZERS = advanced_api_fuzzer animation_api_fuzzer animencoder_fuzzer
-FUZZERS += animdecoder_fuzzer mux_demux_api_fuzzer enc_dec_fuzzer
-FUZZERS += simple_api_fuzzer
-
-%.o: fuzz_utils.h img_alpha.h img_grid.h img_peak.h
-all: $(FUZZERS)
-
-define FUZZER_template
-$(1): $$(addsuffix .o, $(1)) $(LDLIBS)
-OBJS += $$(addsuffix .o, $(1))
-endef
-
-$(foreach fuzzer, $(FUZZERS), $(eval $(call FUZZER_template, $(fuzzer))))
-
-clean:
-	$(RM) $(FUZZERS) $(OBJS)
-
-.PHONY: all clean
--- a/tests/fuzzer/mux_demux_api_fuzzer.c
+++ b/tests/fuzzer/mux_demux_api_fuzzer.c
@ -1,96 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "./fuzz_utils.h"
-#include "webp/demux.h"
-#include "webp/mux.h"
-
-int LLVMFuzzerTestOneInput(const uint8_t* const data, size_t size) {
-  WebPData webp_data;
-  WebPDataInit(&webp_data);
-  webp_data.size = size;
-  webp_data.bytes = data;
-
-  // Extracted chunks and frames are not processed or decoded,
-  // which is already covered extensively by the other fuzz targets.
-
-  if (size & 1) {
-    // Mux API
-    WebPMux* mux = WebPMuxCreate(&webp_data, size & 2);
-    if (!mux) return 0;
-
-    WebPData chunk;
-    WebPMuxGetChunk(mux, "EXIF", &chunk);
-    WebPMuxGetChunk(mux, "ICCP", &chunk);
-    WebPMuxGetChunk(mux, "FUZZ", &chunk);  // unknown
-
-    uint32_t flags;
-    WebPMuxGetFeatures(mux, &flags);
-
-    WebPMuxAnimParams params;
-    WebPMuxGetAnimationParams(mux, &params);
-
-    WebPMuxError status;
-    WebPMuxFrameInfo info;
-    for (int i = 0; i < kFuzzFrameLimit; i++) {
-      status = WebPMuxGetFrame(mux, i + 1, &info);
-      if (status == WEBP_MUX_NOT_FOUND) {
-        break;
-      } else if (status == WEBP_MUX_OK) {
-        WebPDataClear(&info.bitstream);
-      }
-    }
-
-    WebPMuxDelete(mux);
-  } else {
-    // Demux API
-    WebPDemuxer* demux;
-    if (size & 2) {
-      WebPDemuxState state;
-      demux = WebPDemuxPartial(&webp_data, &state);
-      if (state < WEBP_DEMUX_PARSED_HEADER) {
-        WebPDemuxDelete(demux);
-        return 0;
-      }
-    } else {
-      demux = WebPDemux(&webp_data);
-      if (!demux) return 0;
-    }
-
-    WebPChunkIterator chunk_iter;
-    if (WebPDemuxGetChunk(demux, "EXIF", 1, &chunk_iter)) {
-      WebPDemuxNextChunk(&chunk_iter);
-    }
-    WebPDemuxReleaseChunkIterator(&chunk_iter);
-    if (WebPDemuxGetChunk(demux, "ICCP", 0, &chunk_iter)) {  // 0 == last
-      WebPDemuxPrevChunk(&chunk_iter);
-    }
-    WebPDemuxReleaseChunkIterator(&chunk_iter);
-    // Skips FUZZ because the Demux API has no concept of (un)known chunks.
-
-    WebPIterator iter;
-    if (WebPDemuxGetFrame(demux, 1, &iter)) {
-      for (int i = 1; i < kFuzzFrameLimit; i++) {
-        if (!WebPDemuxNextFrame(&iter)) break;
-      }
-    }
-
-    WebPDemuxReleaseIterator(&iter);
-    WebPDemuxDelete(demux);
-  }
-
-  return 0;
-}
--- a/tests/fuzzer/simple_api_fuzzer.c
+++ b/tests/fuzzer/simple_api_fuzzer.c
@ -1,88 +0,0 @@
-// Copyright 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "./fuzz_utils.h"
-#include "webp/decode.h"
-
-int LLVMFuzzerTestOneInput(const uint8_t* const data, size_t size) {
-  int w, h;
-  if (!WebPGetInfo(data, size, &w, &h)) return 0;
-  if ((size_t)w * h > kFuzzPxLimit) return 0;
-
-  const uint8_t value = FuzzHash(data, size);
-  uint8_t* buf = NULL;
-
-  // For *Into functions, which decode into an external buffer, an
-  // intentionally too small buffer can be given with low probability.
-  if (value < 0x16) {
-    buf = WebPDecodeRGBA(data, size, &w, &h);
-  } else if (value < 0x2b) {
-    buf = WebPDecodeBGRA(data, size, &w, &h);
-#if !defined(WEBP_REDUCE_CSP)
-  } else if (value < 0x40) {
-    buf = WebPDecodeARGB(data, size, &w, &h);
-  } else if (value < 0x55) {
-    buf = WebPDecodeRGB(data, size, &w, &h);
-  } else if (value < 0x6a) {
-    buf = WebPDecodeBGR(data, size, &w, &h);
-#endif  // !defined(WEBP_REDUCE_CSP)
-  } else if (value < 0x7f) {
-    uint8_t *u, *v;
-    int stride, uv_stride;
-    buf = WebPDecodeYUV(data, size, &w, &h, &u, &v, &stride, &uv_stride);
-  } else if (value < 0xe8) {
-    const int stride = (value < 0xbe ? 4 : 3) * w;
-    size_t buf_size = stride * h;
-    if (value % 0x10 == 0) buf_size--;
-    uint8_t* const ext_buf = (uint8_t*)malloc(buf_size);
-    if (value < 0x94) {
-      WebPDecodeRGBAInto(data, size, ext_buf, buf_size, stride);
-#if !defined(WEBP_REDUCE_CSP)
-    } else if (value < 0xa9) {
-      WebPDecodeARGBInto(data, size, ext_buf, buf_size, stride);
-    } else if (value < 0xbe) {
-      WebPDecodeBGRInto(data, size, ext_buf, buf_size, stride);
-    } else if (value < 0xd3) {
-      WebPDecodeRGBInto(data, size, ext_buf, buf_size, stride);
-#endif  // !defined(WEBP_REDUCE_CSP)
-    } else {
-      WebPDecodeBGRAInto(data, size, ext_buf, buf_size, stride);
-    }
-    free(ext_buf);
-  } else {
-    size_t luma_size = w * h;
-    const int uv_stride = (w + 1) / 2;
-    size_t u_size = uv_stride * (h + 1) / 2;
-    size_t v_size = uv_stride * (h + 1) / 2;
-    if (value % 0x10 == 0) {
-      if (size & 1) luma_size--;
-      if (size & 2) u_size--;
-      if (size & 4) v_size--;
-    }
-    uint8_t* const luma_buf = (uint8_t*)malloc(luma_size);
-    uint8_t* const u_buf = (uint8_t*)malloc(u_size);
-    uint8_t* const v_buf = (uint8_t*)malloc(v_size);
-    WebPDecodeYUVInto(data, size, luma_buf, luma_size, w /* luma_stride */,
-                      u_buf, u_size, uv_stride, v_buf, v_size, uv_stride);
-    free(luma_buf);
-    free(u_buf);
-    free(v_buf);
-  }
-
-  if (buf) WebPFree(buf);
-
-  return 0;
-}
--- a/xcframeworkbuild.sh
+++ b/xcframeworkbuild.sh
@ -1,230 +0,0 @@
-#!/bin/bash
-#
-# This script generates 'WebP.xcframework', 'WebPDecoder.xcframework',
-# 'WebPDemux.xcframework' and 'WebPMux.xcframework'.
-# An iOS, Mac or Mac Catalyst app can decode WebP images by including
-# 'WebPDecoder.xcframework' and both encode and decode WebP images by including
-# 'WebP.xcframework'.
-#
-# Run ./xcframeworkbuild.sh to generate the frameworks under the current
-# directory (the previous build will be erased if it exists).
-#
-
-set -e
-
-# Set these variables based on the desired minimum deployment target.
-readonly IOS_MIN_VERSION=6.0
-readonly MACOSX_MIN_VERSION=10.15
-readonly MACOSX_CATALYST_MIN_VERSION=13.0
-
-# Extract Xcode version.
-readonly XCODE=$(xcodebuild -version | grep Xcode | cut -d " " -f2)
-if [[ -z "${XCODE}" ]] || [[ "${XCODE%%.*}" -lt 11 ]]; then
-  echo "Xcode 11.0 or higher is required!"
-  exit 1
-fi
-
-# Extract the latest SDK version from the final field of the form: iphoneosX.Y
-# / macosxX.Y
-readonly SDK=($(
-  xcodebuild -showsdks \
-    | grep iphoneos | sort | tail -n 1 | awk '{print substr($NF, 9)}'
-  xcodebuild -showsdks \
-    | grep macosx | sort | tail -n 1 | awk '{print substr($NF, 7)}'
-))
-readonly IOS=0
-readonly MACOS=1
-readonly IOS_SIMULATOR=2
-readonly MACOS_CATALYST=3
-readonly NUM_PLATFORMS=4
-
-readonly OLDPATH=${PATH}
-
-# Names should be of the form '<platform>-[<variant>-]<architecture>'.
-PLATFORMS[$IOS]="iPhoneOS-armv7 iPhoneOS-armv7s iPhoneOS-arm64"
-PLATFORMS[$IOS_SIMULATOR]="iPhoneSimulator-i386 iPhoneSimulator-x86_64"
-PLATFORMS[$MACOS]="MacOSX-x86_64"
-PLATFORMS[$MACOS_CATALYST]="MacOSX-Catalyst-x86_64"
-if [[ "${XCODE%%.*}" -ge 12 ]]; then
-  PLATFORMS[$MACOS]+=" MacOSX-arm64"
-  PLATFORMS[$MACOS_CATALYST]+=" MacOSX-Catalyst-arm64"
-elif [[ "${XCODE%%.*}" -eq 11 ]]; then
-  cat << EOF
-WARNING: Xcode 12.0 or higher is required to build targets for
-WARNING: Apple Silicon (arm64). The XCFrameworks generated with Xcode 11 will
-WARNING: contain libraries for MacOS & Catalyst supporting x86_64 only.
-WARNING: The build will continue in 5 seconds...
-EOF
-  sleep 5
-else
-  echo "Xcode 11.0 or higher is required!"
-  exit 1
-fi
-readonly PLATFORMS
-readonly SRCDIR=$(dirname $0)
-readonly TOPDIR=$(pwd)
-readonly BUILDDIR="${TOPDIR}/xcframeworkbuild"
-readonly TARGETDIR="${TOPDIR}/WebP.xcframework"
-readonly DECTARGETDIR="${TOPDIR}/WebPDecoder.xcframework"
-readonly MUXTARGETDIR="${TOPDIR}/WebPMux.xcframework"
-readonly DEMUXTARGETDIR="${TOPDIR}/WebPDemux.xcframework"
-readonly DEVELOPER=$(xcode-select --print-path)
-readonly DEVROOT="${DEVELOPER}/Toolchains/XcodeDefault.xctoolchain"
-readonly PLATFORMSROOT="${DEVELOPER}/Platforms"
-readonly LIPO=$(xcrun -sdk iphoneos${SDK[$IOS]} -find lipo)
-
-if [[ -z "${SDK[$IOS]}" ]] || [[ ${SDK[$IOS]%%.*} -lt 8 ]]; then
-  echo "iOS SDK version 8.0 or higher is required!"
-  exit 1
-fi
-
-echo "Xcode Version: ${XCODE}"
-echo "iOS SDK Version: ${SDK[$IOS]}"
-echo "MacOS SDK Version: ${SDK[$MACOS]}"
-
-if [[ -e "${BUILDDIR}" || -e "${TARGETDIR}" || -e "${DECTARGETDIR}" \
-      || -e "${MUXTARGETDIR}" || -e "${DEMUXTARGETDIR}" ]]; then
-  cat << EOF
-WARNING: The following directories will be deleted:
-WARNING:   ${BUILDDIR}
-WARNING:   ${TARGETDIR}
-WARNING:   ${DECTARGETDIR}
-WARNING:   ${MUXTARGETDIR}
-WARNING:   ${DEMUXTARGETDIR}
-WARNING: The build will continue in 5 seconds...
-EOF
-  sleep 5
-fi
-rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR} \
-  ${MUXTARGETDIR} ${DEMUXTARGETDIR}
-
-if [[ ! -e ${SRCDIR}/configure ]]; then
-  if ! (cd ${SRCDIR} && sh autogen.sh); then
-    cat << EOF
-Error creating configure script!
-This script requires the autoconf/automake and libtool to build. MacPorts or
-Homebrew can be used to obtain these:
-http://www.macports.org/install.php
-https://brew.sh/
-EOF
-    exit 1
-  fi
-fi
-
-for (( i = 0; i < $NUM_PLATFORMS; ++i )); do
-  LIBLIST=()
-  DECLIBLIST=()
-  MUXLIBLIST=()
-  DEMUXLIBLIST=()
-
-  for PLATFORM in ${PLATFORMS[$i]}; do
-    ROOTDIR="${BUILDDIR}/${PLATFORM}"
-    mkdir -p "${ROOTDIR}"
-
-    ARCH="${PLATFORM##*-}"
-    case "${PLATFORM}" in
-      iPhone*)
-        sdk="${SDK[$IOS]}"
-        ;;
-      MacOS*)
-        sdk="${SDK[$MACOS]}"
-        ;;
-      *)
-        echo "Unrecognized platform: ${PLATFORM}!"
-        exit 1
-        ;;
-    esac
-
-    SDKROOT="${PLATFORMSROOT}/${PLATFORM%%-*}.platform/"
-    SDKROOT+="Developer/SDKs/${PLATFORM%%-*}${sdk}.sdk/"
-    CFLAGS="-pipe -isysroot ${SDKROOT} -O3 -DNDEBUG"
-    case "${PLATFORM}" in
-      iPhone*)
-        CFLAGS+=" -miphoneos-version-min=${IOS_MIN_VERSION} -fembed-bitcode"
-        ;;
-      MacOSX-Catalyst*)
-        CFLAGS+=" -target"
-        CFLAGS+=" ${ARCH}-apple-ios${MACOSX_CATALYST_MIN_VERSION}-macabi"
-        ;;
-      MacOSX*)
-        CFLAGS+=" -mmacosx-version-min=${MACOSX_MIN_VERSION}"
-        ;;
-    esac
-
-    set -x
-    export PATH="${DEVROOT}/usr/bin:${OLDPATH}"
-    ${SRCDIR}/configure --host=${ARCH/arm64/aarch64}-apple-darwin \
-      --build=$(${SRCDIR}/config.guess) \
-      --prefix=${ROOTDIR} \
-      --disable-shared --enable-static \
-      --enable-libwebpdecoder --enable-swap-16bit-csp \
-      --enable-libwebpmux \
-      CC="clang -arch ${ARCH}" \
-      CFLAGS="${CFLAGS}"
-    set +x
-
-    # run make only in the src/ directory to create libwebp.a/libwebpdecoder.a
-    cd src/
-    make V=0
-    make install
-
-    LIBLIST+=("${ROOTDIR}/lib/libwebp.a")
-    DECLIBLIST+=("${ROOTDIR}/lib/libwebpdecoder.a")
-    MUXLIBLIST+=("${ROOTDIR}/lib/libwebpmux.a")
-    DEMUXLIBLIST+=("${ROOTDIR}/lib/libwebpdemux.a")
-    # xcodebuild requires a directory for the -headers option, these will match
-    # for all builds.
-    make install-data DESTDIR="${ROOTDIR}/lib-headers"
-    make install-commonHEADERS DESTDIR="${ROOTDIR}/dec-headers"
-    make -C demux install-data DESTDIR="${ROOTDIR}/demux-headers"
-    make -C mux install-data DESTDIR="${ROOTDIR}/mux-headers"
-    LIB_HEADERS="${ROOTDIR}/lib-headers/${ROOTDIR}/include/webp"
-    DEC_HEADERS="${ROOTDIR}/dec-headers/${ROOTDIR}/include/webp"
-    DEMUX_HEADERS="${ROOTDIR}/demux-headers/${ROOTDIR}/include/webp"
-    MUX_HEADERS="${ROOTDIR}/mux-headers/${ROOTDIR}/include/webp"
-
-    make distclean
-    cd ..
-
-    export PATH=${OLDPATH}
-  done
-
-  [[ -z "${LIBLIST[@]}" ]] && continue
-
-  # Create a temporary target directory for each <platform>[-<variant>].
-  target_dir="${BUILDDIR}/${PLATFORMS[$i]}"
-  target_dir="${target_dir%% *}"
-  target_dir="${target_dir%-*}"
-  target_lib="${target_dir}/$(basename ${LIBLIST[0]})"
-  target_declib="${target_dir}/$(basename ${DECLIBLIST[0]})"
-  target_demuxlib="${target_dir}/$(basename ${DEMUXLIBLIST[0]})"
-  target_muxlib="${target_dir}/$(basename ${MUXLIBLIST[0]})"
-
-  mkdir -p "${target_dir}"
-  ${LIPO} -create ${LIBLIST[@]} -output "${target_lib}"
-  ${LIPO} -create ${DECLIBLIST[@]} -output "${target_declib}"
-  ${LIPO} -create ${DEMUXLIBLIST[@]} -output "${target_demuxlib}"
-  ${LIPO} -create ${MUXLIBLIST[@]} -output "${target_muxlib}"
-  FAT_LIBLIST+=(-library "${target_lib}" -headers "${LIB_HEADERS}")
-  FAT_DECLIBLIST+=(-library "${target_declib}" -headers "${DEC_HEADERS}")
-  FAT_DEMUXLIBLIST+=(-library "${target_demuxlib}" -headers "${DEMUX_HEADERS}")
-  FAT_MUXLIBLIST+=(-library "${target_muxlib}" -headers "${MUX_HEADERS}")
-done
-
-# lipo will not put archives with the same architecture (e.g., x86_64
-# iPhoneSimulator & MacOS) in the same fat output file. xcodebuild
-# -create-xcframework requires universal archives to avoid e.g.:
-#   Both ios-x86_64-maccatalyst and ios-arm64-maccatalyst represent two
-#   equivalent library definitions
-set -x
-xcodebuild -create-xcframework "${FAT_LIBLIST[@]}" \
-  -output ${TARGETDIR}
-xcodebuild -create-xcframework "${FAT_DECLIBLIST[@]}" \
-  -output ${DECTARGETDIR}
-xcodebuild -create-xcframework "${FAT_DEMUXLIBLIST[@]}" \
-  -output ${DEMUXTARGETDIR}
-xcodebuild -create-xcframework "${FAT_MUXLIBLIST[@]}" \
-  -output ${MUXTARGETDIR}
-set +x
-
-echo  "SUCCESS"
Author	SHA1	Message	Date
Vincent Rabaud	50f60add5c	Fix OOB write in BuildHuffmanTable. First, BuildHuffmanTable is called to check if the data is valid. If it is and the table is not big enough, more memory is allocated. This will make sure that valid (but unoptimized because of unbalanced codes) streams are still decodable. Bug: chromium:1479274 Change-Id: I31c36dbf3aa78d35ecf38706b50464fd3d375741 (cherry picked from commit `902bc91903`) (cherry picked from commit `2af26267cd`)	2023-09-07 15:40:16 -07:00
James Zern	5df85e9c0b	EncodeAlphaInternal: clear result->bw on error This avoids a double free should the function fail prior to VP8BitWriterInit() and a previous trial result's buffer carried over. Previously in ApplyFiltersAndEncode() trial.bw (with a previous iteration's buffer) would be freed, followed by best.bw pointing to the same buffer. Since: `187d379d` add a fallback to ALPHA_NO_COMPRESSION In addition, check the return value of VP8BitWriterInit() in this function. Bug: webp:603 Change-Id: Ic258381ee26c8c16bc211d157c8153831c8c6910 (cherry picked from commit `a486d800b6`)	2023-02-28 00:26:34 +00:00
James Zern	89e226a3c7	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`)	2022-04-06 21:55:27 -07:00
James Zern	4d0964cd0c	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`)	2022-04-06 21:50:21 -07:00
James Zern	5d805f7205	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`)	2022-04-06 21:50:21 -07:00
James Zern	b14eba6497	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:04 +00:00
James Zern	9183ff2ef9	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:24 +00:00
Vincent Rabaud	68d52453cd	Fix lossless encoding for MIPS. Bug: webp:558 Change-Id: I3d3ddb64ed26a8d8ff5664664c5f20f6eadfeb4f (cherry picked from commit `e4cbcdd2b5`)	2022-03-02 02:56:13 +00:00