GetBackwardReferences: fail on alloc error

previously failures in the call to
VP8LBackwardReferencesTraceBackwards() would be ignored which, though it
wouldn't result in a crash, would produce non-deterministic output

Change-Id: Id9890a60883c3270ec75e968506d46eea32b76d4
(cherry picked from commit e3cfafaf71)
(cherry picked from commit 20ef03ee35)
(cherry picked from commit 89e226a3c7)

.gitattributes

@@ -1,6 +1,5 @@
 .gitattributes export-ignore
 .gitignore export-ignore
 .mailmap export-ignore
-*.bat text eol=crlf
 *.pdf -text -diff
 *.ppm -text -diff

.gitignore

@@ -1,7 +1,6 @@
 *.l[ao]
 *.[ao]
 *.pc
-.DS_Store
 .deps
 .libs
 /aclocal.m4
@@ -21,11 +20,9 @@
 Makefile
 Makefile.in
 examples/anim_diff
-examples/anim_dump
 examples/[cdv]webp
 examples/gif2webp
 examples/img2webp
-examples/webpinfo
 examples/webpmux
 src/webp/config.h*
 src/webp/stamp-h1
@@ -34,21 +31,11 @@ src/webp/stamp-h1
 *.idb
 *.pdb
 /iosbuild
-/xcframeworkbuild
-/WebP*.*framework
+/WebP.framework
 CMakeCache.txt
 CMakeFiles/
 cmake_install.cmake
 .gradle
 /build
 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

.mailmap

@@ -11,4 +11,3 @@ Vikas Arora <vikasa@google.com>
 Tamar Levy <tamar.levy@intel.com>
 <qrczak@google.com> <qrczak>
 Hui Su <huisu@google.com>
-James Zern <jzern@google.com>

AUTHORS

@@ -1,15 +1,9 @@
 Contributors:
-- Aidan O'Loan (aidanol at gmail dot com)
 - Alan Browning (browning at google dot com)
 - Charles Munger (clm at google dot com)
-- Cheng Yi (cyi at google dot com)
 - Christian Duvivier (cduvivier at google dot com)
-- Christopher Degawa (ccom at randomderp dot com)
-- Clement Courbet (courbet at google dot com)
 - Djordje Pesut (djordje dot pesut at imgtec dot com)
 - Hui Su (huisu at google dot com)
-- Ilya Kurdyukov (jpegqs at gmail 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)
@@ -26,7 +20,6 @@ Contributors:
 - Mislav Bradac (mislavm at google dot com)
 - Nico Weber (thakis at chromium dot org)
 - Noel Chromium (noel at chromium dot org)
-- Oliver Wolff (oliver dot wolff at qt dot io)
 - Owen Rodley (orodley at google dot com)
 - Parag Salasakar (img dot mips1 at gmail dot com)
 - Pascal Massimino (pascal dot massimino at gmail dot com)
@@ -45,7 +38,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)
-- Zhi An Ng (zhin at chromium dot org)

Android.mk

@@ -74,7 +74,6 @@ dsp_dec_srcs := \
     src/dsp/lossless_msa.c \
     src/dsp/lossless_neon.$(NEON) \
     src/dsp/lossless_sse2.c \
-    src/dsp/lossless_sse41.c \
     src/dsp/rescaler.c \
     src/dsp/rescaler_mips32.c \
     src/dsp/rescaler_mips_dsp_r2.c \

CMakeLists.txt

@@ -1,27 +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)
 
-if(POLICY CMP0072)
-  cmake_policy(SET CMP0072 NEW)
-endif()
-
 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)
@@ -29,16 +11,12 @@ option(WEBP_BUILD_GIF2WEBP "Build the gif2webp conversion tool." ON)
 option(WEBP_BUILD_IMG2WEBP "Build the img2webp animation tool." ON)
 option(WEBP_BUILD_VWEBP "Build the vwebp viewer tool." ON)
 option(WEBP_BUILD_WEBPINFO "Build the webpinfo command line tool." ON)
-option(WEBP_BUILD_LIBWEBPMUX "Build the libwebpmux library." ON)
 option(WEBP_BUILD_WEBPMUX "Build the webpmux command line tool." ON)
 option(WEBP_BUILD_EXTRAS "Build extras." ON)
 option(WEBP_BUILD_WEBP_JS "Emscripten build of webp.js." OFF)
-option(WEBP_USE_THREAD "Enable threading support" ON)
 option(WEBP_NEAR_LOSSLESS "Enable near-lossless encoding" ON)
 option(WEBP_ENABLE_SWAP_16BIT_CSP "Enable byte swap for 16 bit colorspaces."
        OFF)
-set(WEBP_BITTRACE "0" CACHE STRING "Bit trace mode (0=none, 1=bit, 2=bytes)")
-set_property(CACHE WEBP_BITTRACE PROPERTY STRINGS 0 1 2)
 
 # Option needed for handling Unicode file names on Windows.
 if(WIN32)
@@ -46,6 +24,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)
@@ -55,11 +34,6 @@ if(WEBP_BUILD_WEBP_JS)
   set(WEBP_BUILD_WEBPINFO OFF)
   set(WEBP_BUILD_WEBPMUX OFF)
   set(WEBP_BUILD_EXTRAS OFF)
-  set(WEBP_USE_THREAD OFF)
-
-  if(WEBP_ENABLE_SIMD)
-    message("wasm2js does not support SIMD, disabling webp.js generation.")
-  endif()
 endif()
 
 set(WEBP_DEP_LIBRARIES)
@@ -67,7 +41,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()
 
@@ -81,10 +55,6 @@ if(WEBP_ENABLE_SWAP_16BIT_CSP)
   add_definitions(-DWEBP_SWAP_16BIT_CSP=1)
 endif()
 
-if(NOT WEBP_BITTRACE STREQUAL "0")
-  add_definitions(-DBITTRACE=${WEBP_BITTRACE})
-endif()
-
 if(WEBP_UNICODE)
   # Windows recommends setting both UNICODE and _UNICODE.
   add_definitions(-DUNICODE -D_UNICODE)
@@ -95,7 +65,6 @@ set(exec_prefix "\$\{prefix\}")
 set(libdir "\$\{prefix\}/lib")
 set(includedir "\$\{prefix\}/include")
 set(PTHREAD_LIBS ${CMAKE_THREAD_LIBS_INIT})
-set(INSTALLED_LIBRARIES)
 
 # ##############################################################################
 # Android only.
@@ -103,7 +72,6 @@ if(ANDROID)
   include_directories(${ANDROID_NDK}/sources/android/cpufeatures)
   add_library(cpufeatures STATIC
               ${ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c)
-  list(APPEND INSTALLED_LIBRARIES cpufeatures)
   target_link_libraries(cpufeatures dl)
   set(WEBP_DEP_LIBRARIES ${WEBP_DEP_LIBRARIES} cpufeatures)
   set(WEBP_DEP_INCLUDE_DIRS ${WEBP_DEP_INCLUDE_DIRS}
@@ -188,29 +156,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)
@@ -237,9 +182,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
@@ -279,16 +221,11 @@ 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
+target_include_directories(webp
                            PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
                                    ${CMAKE_CURRENT_BINARY_DIR}
-  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-         $<INSTALL_INTERFACE:include>)
+                           PUBLIC $<INSTALL_INTERFACE:include>)
 set_target_properties(
   webp
   PROPERTIES PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/decode.h;\
@@ -323,10 +260,10 @@ ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/types.h")
 configure_pkg_config("src/demux/libwebpdemux.pc")
 
 # Set the version numbers.
-macro(set_version FILE TARGET_NAME NAME_IN_MAKEFILE)
+function(parse_version FILE NAME VAR)
   file(READ ${CMAKE_CURRENT_SOURCE_DIR}/src/${FILE} SOURCE_FILE)
   string(REGEX MATCH
-               "${NAME_IN_MAKEFILE}_la_LDFLAGS[^\n]* -version-info [0-9:]+"
+               "${NAME}_la_LDFLAGS[^\n]* -version-info [0-9:]+"
                TMP
                ${SOURCE_FILE})
   string(REGEX MATCH
@@ -335,35 +272,29 @@ macro(set_version FILE TARGET_NAME NAME_IN_MAKEFILE)
                ${TMP})
   string(REGEX
          REPLACE ":"
-                 " "
-                 LT_VERSION
+                 "."
+                 VERSION
                  ${TMP})
-
-  # See the libtool docs for more information:
-  # https://www.gnu.org/software/libtool/manual/libtool.html#Updating-version-info
-  #
-  # c=<current>, a=<age>, r=<revision>
-  #
-  # libtool generates a .so file as .so.[c-a].a.r, while -version-info c:r:a is
-  # passed to libtool.
-  #
-  # We set FULL = [c-a].a.r and MAJOR = [c-a].
-  separate_arguments(LT_VERSION)
-  list(GET LT_VERSION 0 LT_CURRENT)
-  list(GET LT_VERSION 1 LT_REVISION)
-  list(GET LT_VERSION 2 LT_AGE)
-  math(EXPR LT_CURRENT_MINUS_AGE "${LT_CURRENT} - ${LT_AGE}")
-
-  set_target_properties(
-    ${TARGET_NAME}
+  set(${VAR} "${VERSION}" PARENT_SCOPE)
+endfunction()
+parse_version(Makefile.am webp WEBP_WEBP_SOVERSION)
+set_target_properties(webp
                       PROPERTIES VERSION
-               ${LT_CURRENT_MINUS_AGE}.${LT_AGE}.${LT_REVISION}
+                                 ${PACKAGE_VERSION}
                                  SOVERSION
-               ${LT_CURRENT_MINUS_AGE})
-endmacro()
-set_version(Makefile.am webp webp)
-set_version(Makefile.am webpdecoder webpdecoder)
-set_version(demux/Makefile.am webpdemux webpdemux)
+                                 ${WEBP_WEBP_SOVERSION})
+parse_version(Makefile.am webpdecoder WEBP_DECODER_SOVERSION)
+set_target_properties(webpdecoder
+                      PROPERTIES VERSION
+                                 ${PACKAGE_VERSION}
+                                 SOVERSION
+                                 ${WEBP_DECODER_SOVERSION})
+parse_version(demux/Makefile.am webpdemux WEBP_DEMUX_SOVERSION)
+set_target_properties(webpdemux
+                      PROPERTIES VERSION
+                                 ${PACKAGE_VERSION}
+                                 SOVERSION
+                                 ${WEBP_DEMUX_SOVERSION})
 file(READ ${CMAKE_CURRENT_SOURCE_DIR}/configure.ac CONFIGURE_FILE)
 string(REGEX MATCH
              "AC_INIT\\([^\n]*\\[[0-9\\.]+\\]"
@@ -375,7 +306,7 @@ string(REGEX MATCH
              ${TMP})
 
 # Define the libraries to install.
-list(APPEND INSTALLED_LIBRARIES webpdecoder webp webpdemux)
+set(INSTALLED_LIBRARIES webpdecoder webp webpdemux)
 
 # Deal with SIMD. Change the compile flags for SIMD files we use.
 list(LENGTH WEBP_SIMD_FILES_TO_INCLUDE WEBP_SIMD_FILES_TO_INCLUDE_LENGTH)
@@ -391,12 +322,6 @@ foreach(I_FILE RANGE ${WEBP_SIMD_FILES_TO_INCLUDE_RANGE})
                               ${SIMD_COMPILE_FLAG})
 endforeach()
 
-if(NOT WEBP_BUILD_LIBWEBPMUX)
-  set(WEBP_BUILD_GIF2WEBP OFF)
-  set(WEBP_BUILD_IMG2WEBP OFF)
-  set(WEBP_BUILD_WEBPMUX OFF)
-endif()
-
 if(WEBP_BUILD_GIF2WEBP AND NOT GIF_FOUND)
   set(WEBP_BUILD_GIF2WEBP OFF)
 endif()
@@ -416,21 +341,20 @@ if(WEBP_BUILD_ANIM_UTILS
   parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "EXAMPLEUTIL_SRCS"
                     "example_util_[^ ]*")
   list(APPEND EXAMPLEUTIL_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/examples/stopwatch.h)
-  add_library(exampleutil STATIC ${EXAMPLEUTIL_SRCS})
-  target_link_libraries(exampleutil imageioutil)
+  add_library(exampleutil ${EXAMPLEUTIL_SRCS})
   target_include_directories(
     exampleutil
     PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
 
   parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEIOUTILS_SRCS"
                     "imageio_util_[^ ]*")
-  add_library(imageioutil STATIC ${IMAGEIOUTILS_SRCS})
+  add_library(imageioutil ${IMAGEIOUTILS_SRCS})
   target_link_libraries(imageioutil webp)
 
   # Image-decoding utility library.
   parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEDEC_SRCS"
                     "imagedec_[^ ]*")
-  add_library(imagedec STATIC ${IMAGEDEC_SRCS})
+  add_library(imagedec ${IMAGEDEC_SRCS})
   target_link_libraries(imagedec
                         imageioutil
                         webpdemux
@@ -440,8 +364,8 @@ if(WEBP_BUILD_ANIM_UTILS
   # Image-encoding utility library.
   parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEENC_SRCS"
                     "imageenc_[^ ]*")
-  add_library(imageenc STATIC ${IMAGEENC_SRCS})
-  target_link_libraries(imageenc imageioutil webp)
+  add_library(imageenc ${IMAGEENC_SRCS})
+  target_link_libraries(imageenc webp)
 
   set_property(TARGET exampleutil
                       imageioutil
@@ -469,14 +393,19 @@ if(WEBP_BUILD_CWEBP)
   install(TARGETS cwebp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 endif()
 
-if(WEBP_BUILD_LIBWEBPMUX)
+if(WEBP_BUILD_GIF2WEBP OR WEBP_BUILD_IMG2WEBP)
   parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/src/mux "WEBP_MUX_SRCS" "")
   add_library(libwebpmux ${WEBP_MUX_SRCS})
   target_link_libraries(libwebpmux webp)
   target_include_directories(libwebpmux
                              PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
                                      ${CMAKE_CURRENT_SOURCE_DIR})
-  set_version(mux/Makefile.am libwebpmux webpmux)
+  parse_version(mux/Makefile.am webpmux WEBP_MUX_SOVERSION)
+  set_target_properties(libwebpmux
+                        PROPERTIES VERSION
+                                   ${PACKAGE_VERSION}
+                                   SOVERSION
+                                   ${WEBP_MUX_SOVERSION})
   set_target_properties(libwebpmux
                         PROPERTIES PUBLIC_HEADER
                                    "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/mux.h;\
@@ -529,12 +458,12 @@ if(WEBP_BUILD_VWEBP)
     target_link_libraries(vwebp
                           ${OPENGL_LIBRARIES}
                           exampleutil
-                          ${GLUT_glut_LIBRARY}
+                          GLUT::GLUT
                           imageioutil
                           webp
                           webpdemux)
     target_include_directories(vwebp
-                               PRIVATE ${GLUT_INCLUDE_DIR}
+                               PRIVATE GLUT::GLUT
                                        ${CMAKE_CURRENT_BINARY_DIR}/src
                                        ${OPENGL_INCLUDE_DIR})
     install(TARGETS vwebp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
@@ -582,13 +511,13 @@ if(WEBP_BUILD_EXTRAS)
                              PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
                                      ${CMAKE_CURRENT_SOURCE_DIR}/src
                                      ${CMAKE_CURRENT_BINARY_DIR}/src)
+  install(TARGETS get_disto RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
   # webp_quality
   add_executable(webp_quality ${WEBP_QUALITY_SRCS} ${WEBP_EXTRAS_SRCS})
   target_link_libraries(webp_quality exampleutil imagedec)
-  target_include_directories(webp_quality
-                             PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
-                                     ${CMAKE_CURRENT_BINARY_DIR})
+  target_include_directories(webp_quality PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+  install(TARGETS webp_quality RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
   # vwebp_sdl
   find_package(SDL)
@@ -603,12 +532,11 @@ if(WEBP_BUILD_EXTRAS)
                                        ${SDL_INCLUDE_DIR})
     set(WEBP_HAVE_SDL 1)
     target_compile_definitions(vwebp_sdl PUBLIC WEBP_HAVE_SDL)
+    install(TARGETS vwebp_sdl RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
   endif()
 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)
@@ -616,12 +544,11 @@ if(WEBP_BUILD_WEBP_JS)
   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 EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
+    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)
-  endif()
 
   # WASM version
   add_executable(webp_wasm ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
@@ -631,7 +558,7 @@ if(WEBP_BUILD_WEBP_JS)
     webp_wasm
     PROPERTIES LINK_FLAGS "-s WASM=1 \
        -s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0 \
-       -s EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
+       -s EXTRA_EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
   target_compile_definitions(webp_wasm PUBLIC EMSCRIPTEN WEBP_HAVE_SDL)
 
   target_compile_definitions(webpdspdecode PUBLIC EMSCRIPTEN)
@@ -649,6 +576,7 @@ if(WEBP_BUILD_ANIM_UTILS)
                         imageenc
                         imageioutil
                         webp
+                        libwebpmux
                         webpdemux
                         ${WEBP_DEP_GIF_LIBRARIES})
   target_include_directories(anim_diff PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
@@ -664,12 +592,14 @@ if(WEBP_BUILD_ANIM_UTILS)
                         imageenc
                         imageioutil
                         webp
+                        libwebpmux
                         webpdemux
                         ${WEBP_DEP_GIF_LIBRARIES})
   target_include_directories(anim_dump PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
 endif()
 
 # Install the different headers and libraries.
+include(GNUInstallDirs)
 install(TARGETS ${INSTALLED_LIBRARIES}
         EXPORT ${PROJECT_NAME}Targets
         PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/webp

CONTRIBUTING.md

@@ -1,29 +0,0 @@
-# How to Contribute
-
-We'd love to accept your patches and contributions to this project. There are
-just a few small guidelines you need to follow.
-
-## Contributor License Agreement
-
-Contributions to this project must be accompanied by a Contributor License
-Agreement. You (or your employer) retain the copyright to your contribution;
-this simply gives us permission to use and redistribute your contributions as
-part of the project. Head over to <https://cla.developers.google.com/> to see
-your current agreements on file or to sign a new one.
-
-You generally only need to submit a CLA once, so if you've already submitted one
-(even if it was for a different project), you probably don't need to do it
-again.
-
-## Code reviews
-
-All submissions, including submissions by project members, require review. We
-use a [Gerrit](https://www.gerritcodereview.com) instance hosted at
-https://chromium-review.googlesource.com for this purpose. See the
-[WebM Project page](https://www.webmproject.org/code/contribute/submitting-patches/)
-for additional details.
-
-## Community Guidelines
-
-This project follows
-[Google's Open Source Community Guidelines](https://opensource.google.com/conduct/).

ChangeLog

@@ -1,259 +1,3 @@
-d9191588 fuzzer/*: normalize src/ includes
-53b6f762 fix indent
-731246ba update ChangeLog (tag: v1.2.1-rc2)
-d250f01d dsp/*: use WEBP_HAVE_* to determine Init availability
-3a4d3ecd update NEWS
-b2bc8093 bump version to 1.2.1
-e542fc7a update AUTHORS
-e0241154 Merge "libwebp/CMake: Add <BUILD_INTERFACE> to webp incl" into main
-edea6444 libwebp/CMake: Add <BUILD_INTERFACE> to webp incl
-ece18e55 dsp.h: respect --disable-sse2/sse4.1/neon
-a89a3230 wicdec: support alpha from WebP WIC decoder
-26f4aa01 Merge "alpha_processing: fix visual studio warnings" into main
-8f594663 alpha_processing: fix visual studio warnings
-46d844e6 Merge "cpu.cmake: fix compiler flag detection w/3.17.0+" into main
-298d26ea Merge changes I593adf92,If20675e7,Ifac68eac into main
-a1e5dae0 alpha_processing*: use WEBP_RESTRICT qualifier
-327ef24f cpu.cmake: fix compiler flag detection w/3.17.0+
-f70819de configure: enable libwebpmux by default
-dc7e2b42 configure: add informational notices when disabling binaries
-9df23ddd configure: move lib flag checks before binaries
-a2e18f10 Merge "WebPConfig.config.in: correct WEBP_INCLUDE_DIRS" into main
-e1a8d4f3 Merge "bit_reader_inl_utils: uniformly apply WEBP_RESTRICT" into main
-4de35f43 rescaler.c: fix alignment
-0f13eec7 bit_reader_inl_utils: uniformly apply WEBP_RESTRICT
-277d3074 Fix size_t overflow in  WebPRescalerInit
-97adbba5 WebPConfig.config.in: correct WEBP_INCLUDE_DIRS
-b60d4603 advanced_api_fuzzer: add extreme config value coverage
-72fe52f6 anim_encode.c,cosmetics: normalize indent
-116d235c anim_encode: Fix encoded_frames_[] overflow
-6f445b3e CMake: set CMP0072 to NEW
-b1cf887f define WEBP_RESTRICT for MSVC
-3e265136 Add WEBP_RESTRICT & use it in VP8BitReader
-f6d29247 vp8l_dec::ProcessRows: fix int overflow in multiply
-de3b4ba8 CMake: add WEBP_BUILD_LIBWEBPMUX
-7f09d3d1 CMakeLists.txt: rm libwebpmux dep from anim_{diff,dump}
-4edea4a6 Init{RGB,YUV}Rescaler: fix a few more int overflows
-c9e26bdb rescaler_utils: set max valid scaled w/h to INT_MAX/2
-28d488e6 utils.h: add SizeOverflow()
-695bdaa2 Export/EmitRescaledRowsRGBA: fix pointer offset int overflow
-685d073e Init{RGB,YUV}Rescaler: fix int overflows in multiplication
-d38bd0dd WebPFlipBuffer: fix integer overflow
-109ff0f1 utils: allow MALLOC_LIMIT to indicate a max
-a2fce867 WebPRescalerImportRowExpand_C: promote some vals before multiply
-776983d4 AllocateBuffer: fix int multiplication overflow check
-315abbd6 Merge "Revert "Do not use a palette for one color images.""
-eae815d0 Merge changes Ica3bbf75,I82f82954
-afbca5a1 Require Emscripten 2.0.18
-3320416b CMakeLists,emscripten: use EXPORTED_RUNTIME_METHODS
-29145ed6 Update README instructions for using Emscripten
-1f579139 cosmetics: remove use of 'sanity' / 'master'
-29b6129c WebPAnimEncoderNewInternal: remove some unnecessary inits
-b60869a1 Revert "Do not use a palette for one color images."
-6fb4cddc demux: move padded size calc post unpadded validation
-05b72d42 vp8l_enc.c: normalize index types
-b6513fba Do not use a palette for one color images.
-98bbe35b Fix multi-threading with palettes.
-b1674240 Add modified Zeng's method to palette sorting.
-88c90c45 add CONTRIBUTING.md
-6a9916d7 WebPRescalerInit: add missing int64_t promotion
-b6cf52d5 WebPIoInitFromOptions: treat use_scaling as a bool
-3b12b7f4 WebPIoInitFromOptions: treat use_cropping as a bool
-595fa13f add WebPCheckCropDimensions()
-8fdaecb0 Disable cross-color when palette is used.
-8933bac2 WebPIoInitFromOptions: respect incoming bypass_filtering val
-7d416ff0 webpdec,cosmetics: match error text to function call
-ec6cfeb5 Fix typo on WebPPictureAlloc() in README
-7e58a1a2 *.cmake: add license header
-5651a6b2 cmake: fix .so versioning
-25ae67b3 xcframeworkbuild.sh: add arm64 simulator target
-5d4ee4c3 cosmetics: remove use of the term 'dummy'
-01b38ee1 faster CollectColorXXXTransforms_SSE41
-652aa344 Merge "Use BitCtz for FastSLog2Slow_C"
-0320e1e3 add the missing default BitsCtz() code
-8886f620 Use BitCtz for FastSLog2Slow_C
-fae41617 faster CombinedShannonEntropy_SSE2
-5bd2704e Introduce the BitCtz() function.
-fee64287 Merge "wicdec,icc: treat unsupported op as non-fatal"
-33ddb894 lossless_sse{2,41}: remove some unneeded includes
-b27ea852 wicdec,icc: treat unsupported op as non-fatal
-b78494a9 Merge "Fix undefined signed shift."
-e79974cd Fix undefined signed shift.
-a8853394 SSE4.1 versions of BGRA to RGB/BGR color-space conversions
-a09a6472 SSE4.1 version of TransformColorInverse
-401da22b Merge "pngdec: check version before using png_get_chunk_malloc_max"
-26907822 pngdec: check version before using png_get_chunk_malloc_max
-06c1e72e Code cleanup
-8f0d41aa Merge changes Id135bbf4,I99e59797
-373eb170 gif2webp: don't store loop-count if there's only 1 frame
-759b9d5a cmake: add WEBP_USE_THREAD option
-926ce921 cmake: don't install binaries from extras/
-9c367bc6 WebPAnimDecoderNewInternal: validate bitstream before alloc
-47f64f6e filters_sse2: import Chromium change
-cc3577e9 fuzzer/*: use src/ based include paths
-004d77ff Merge tag 'v1.2.0'
-fedac6cc update ChangeLog (tag: v1.2.0-rc3, tag: v1.2.0)
-170a8712 Fix check_c_source_compiles with pthread.
-ceddb5fc Fix check_c_source_compiles with pthread.
-85995719 disable CombinedShannonEntropy_SSE2 on x86
-289757fe TiffDec: enforce stricter mem/dimension limit on tiles
-8af7436f Merge "{ios,xcframework}build.sh: make min version(s) more visible" into 1.2.0
-e56c3c5b pngdec: raise memory limit if needed
-8696147d 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
-8df77fb1 animdecoder_fuzzer: fix memory leak
-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
-6e3ef7b3 extras: fix WEBP_SWAP_16BIT_CSP check
-47178dbd extras: add WebPUnmultiplyARGB() convenience function
-22cbae33 idec_dec: fix 0 offset of NULL pointer
-290dd0b4 muxread: fix 0 offset of NULL pointer
-0df474ac Merge "lossless_(enc_|)sse2: avoid offsetting a NULL pointer"
-c6b75a19 lossless_(enc_|)sse2: avoid offsetting a NULL pointer
-295e5e38 fix UBSAN warning
-e2575e05 DC8_NEON,aarch64: use vaddv
-b0e09e34 dec_neon: Fix build failure under some toolchains
-cf0e903c dsp/lossless: Fix non gcc ARM builds
-bb7bc40b Remove ubsan errors.
-78881b76 CMake: fix GLUT library link
-9f750f7a cmake: fix BUILD_SHARED_LIBS build on mac
-17850e74 libwebp: Remove char-subscripts warning in pnmdec.c
-2fa2552d Merge "Expose WebPMalloc() in addition to WebPFree()"
-a4df4aae Expose WebPMalloc() in addition to WebPFree()
-853ea3d8 imageio/tiff: Return error before allocating bad tile size
-af650c0b Fix a Wxor-used-as-pow false positive
-601ef17c libwebp.py: update to swig 3.0.12
-0e48d889 bugfix: last alpha rows were incorrectly decoded
-24d2ccb4 webp: Fix imageio ReadPNM() TUPLTYPE
-fab8f9cf cosmetics: normalize '*' association
-94138e0e update .gitignore
-0fe1a89d update ChangeLog (tag: v1.0.3-rc1, tag: v1.0.3)
-2ad0916d update NEWS
-1287362b bump version to 1.0.3
-7b968cc2 update AUTHORS
-9d6988f4 Fix the oscillating prediction problem at low quality
-312f74d0 makefile.unix: allow *_LIBS to be overridden w/EXTRA_LIBS
-92dbf237 filters_sse2,cosmetics: shorten some long lines
-a277d197 filters_sse2.c: quiet integer sanitizer warnings
-804540f1 Fix cpufeatures in CMake.
-bf00c15b Add CMake option for bittrace.
-a788b498 filters_sse2.c: quiet integer sanitizer warnings
-e6a92c5e filters.c: quiet integer sanitizer warnings
-ec1cc40a lossless.c: remove U32 -> S8 conversion warnings
-1106478f remove conversion U32 -> S8 warnings
-812a6b49 lossless_enc: fix some conversion warning
-4627c1c9 lossless_enc,TransformColorBlue: quiet uint32_t conv warning
-c84673a6 lossless_enc_sse{2,41}: quiet signed conv warnings
-776a7757 dec_sse2: quiet signed conv warnings
-bd39c063 Merge "thread_utils: release mutex before signaling"
-0550576f Merge "(alpha_processing,enc}_sse2: quiet signed conv warnings"
-6682f2c4 thread_utils: release mutex before signaling
-e78dea75 (alpha_processing,enc}_sse2: quiet signed conv warnings
-9acf18ba iosbuild.sh: add WebP{Demux,Mux}.framework
-b9be7e65 vwebp: remove the -fit option (and make it default)
-1394a2bb Merge "README.webp_js: update Emscripten.cmake note"
-dd3e7f8a README.webp_js: update Emscripten.cmake note
-32cf8801 predictor_enc,GetBestGreenRedToBlue: quiet implicit conv warnings
-e1c8acb5 Merge "vwebp: add a -fit option"
-cbd23dd5 vwebp: add a -fit option
-2e672351 bit_writer_utils,Flush: quiet implicit conversion warnings
-1326988d swig: update libwebp_python_wrap.c
-0e7f8548 update generated swig files
-17ed1438 Merge "PutLE{16,24}: quiet implicit conversion warnings"
-24686538 PutLE{16,24}: quiet implicit conversion warnings
-153bb3a0 fix some clang-7 warnings:
-ab2dc893 Rescaler: fix rounding error
-aa65f89a HistogramCombineStochastic: fix free of uninit value
-af0bac64 Merge "encode.h: mention 'exact' default in WebPEncodeLossless*"
-6d2e11ec encode.h: mention 'exact' default in WebPEncodeLossless*
-8c3f04fe AndroidCPUInfo: reorder terms in conditional
-fcfd9c71 BitTrace: if BITTRACE is > 0, record and print syntax bits used
-067031ea Speedups for unused Huffman groups.
-01ac46ba libwebp: Display "libjpeg error:" in imageio/jpegdec
-d9a662e1 WebPRescalerGetScaledDimensions: round scaled dimension up
-62eb3f08 libwebp: Fix missing '{' in README
-e05f785a Merge "unicode,INIT_WARGV: add missing cast"
-63c9a69f tag the VP8LHashPix() function for potential uint roll-over
-2b7214ab unicode,INIT_WARGV: add missing cast
-bf424b46 tag the GetPixPairHash64() function for potential uint roll-over
-7d05d6ca Have the color cache computation be u32-bit only.
-6bcf8769 Remove BINARYEN_METHOD in wasm settings.
-2b98df90 update ChangeLog (tag: v1.0.2-rc1, tag: v1.0.2)
 61e372b7 update NEWS
 7ae658a0 bump version to 1.0.2
 51c4907d update AUTHORS
@@ -272,7 +16,7 @@ f435de95 IsFlat: return int
 9f4d4a3f neon: GetResidualCost
 0fd7514b neon: SetResidualCoeffs
 f95a996c Simpler histogram clustering.
-e85d3313 update ChangeLog (tag: v1.0.1-rc2, tag: v1.0.1)
+e85d3313 update ChangeLog (tag: v1.0.1-rc2, tag: v1.0.1, origin/1.0.1, 1.0.1)
 fa8210e4 Fix pair update in stochastic entropy merging.
 fd198f73 add codereview.settings
 825389ac README.mux: add a reference to the AnimDecoder API
@@ -741,7 +485,7 @@ dcf9d82a imageio: add limited PNM support for reading
 6524fcd6 vwebp_sdl: simple viewer based on SDL
 6cf24a24 get_disto: fix reference file read
 43d472aa Merge tag 'v0.6.0'
-50d1a848 update ChangeLog (tag: v0.6.0, origin/0.6.0)
+50d1a848 update ChangeLog (tag: v0.6.0, origin/0.6.0, 0.6.0)
 20a7fea0 extras/Makefile.am: fix libwebpextras.la reference
 415f3ffe update ChangeLog (tag: v0.6.0-rc3)
 3c6d1224 update NEWS
@@ -818,7 +562,7 @@ b016cb91 NEON: faster fancy upsampling
 f04eb376 Merge tag 'v0.5.2'
 341d711c NEON: 5% faster conversion to RGB565 and RGBA4444
 abb54827 remove Clang warnings with unused arch arguments.
-ece9684f update ChangeLog (tag: v0.5.2-rc2, tag: v0.5.2, origin/0.5.2)
+ece9684f update ChangeLog (tag: v0.5.2-rc2, tag: v0.5.2, origin/0.5.2, 0.5.2)
 aa7744ca anim_util: quiet implicit conv warnings in 32-bit
 d9120271 jpegdec: correct ContextFill signature
 24eb3940 Remove some errors when compiling the code as C++.
@@ -1105,7 +849,7 @@ bbb6ecd9 Merge "Add MSA optimized distortion functions"
 c0991a14 io,EmitRescaledAlphaYUV: factor out a common expr
 48bf5ed1 build.gradle: remove tab
 bfef6c9f Merge tag 'v0.5.1'
-3d97bb75 update ChangeLog (tag: v0.5.1, origin/0.5.1)
+3d97bb75 update ChangeLog (tag: v0.5.1, origin/0.5.1, 0.5.1)
 deb54d91 Clarify the expected 'config' lifespan in WebPIDecode()
 435308e0 Add MSA optimized encoder transform functions
 dce64bfa Add MSA optimized alpha filter functions
@@ -1299,7 +1043,7 @@ b74657fb configure: fix builtin detection w/-Werror
 6c1d7631 avoid Yoda style for comparison
 8ce975ac SSE optimization for vector mismatch.
 7db53831 Merge tag 'v0.5.0'
-37f04949 update ChangeLog (tag: v0.5.0-rc1, tag: v0.5.0, origin/0.5.0)
+37f04949 update ChangeLog (tag: v0.5.0-rc1, tag: v0.5.0, origin/0.5.0, 0.5.0)
 7e7b6ccc faster rgb565/rgb4444/argb output
 4c7f565f update NEWS
 1f62b6b2 update AUTHORS
@@ -2083,7 +1827,7 @@ b5a36cc9 add -near_lossless [0..100] experimental option
 0524d9e5 dsp: detect mips64 & disable mips32 code
 d3485d96 cwebp.1: fix quality description placement
 29a9fe22 Merge tag 'v0.4.1'
-8af27718 update ChangeLog (tag: v0.4.1, origin/0.4.1)
+8af27718 update ChangeLog (tag: v0.4.1, origin/0.4.1, 0.4.1)
 e09e9ff6 Record & log the image pre-processing time.
 f59c0b4b iosbuild.sh: specify optimization flags
 8d34ea3e update ChangeLog (tag: v0.4.1-rc1)
@@ -2468,7 +2212,7 @@ ea59a8e9 Merge "Merge tag 'v0.4.0'"
 effcb0fd Merge tag 'v0.4.0'
 7c76255d autoconf: update ax_pthread.m4
 fff2a11b make -short work with -print_ssim, -print_psnr, etc.
-68e7901d update ChangeLog (tag: v0.4.0-rc1, tag: v0.4.0, origin/0.4.0)
+68e7901d update ChangeLog (tag: v0.4.0-rc1, tag: v0.4.0, origin/0.4.0, 0.4.0)
 256e4333 update NEWS description with new general features
 29625340 Merge "gif2webp: don't use C99 %zu" into 0.4.0
 3b9f9dd0 gif2webp: don't use C99 %zu
@@ -3244,7 +2988,7 @@ a61a824b Merge "Add NULL check in chunk APIs"
 a0770727 mux struct naming
 6c66dde8 Merge "Tune Lossless encoder"
 ab5ea217 Tune Lossless encoder
-74fefc8c Update ChangeLog (tag: v0.2.1, origin/0.2.0)
+74fefc8c Update ChangeLog (tag: v0.2.1, origin/0.2.0, 0.2.0)
 92f8059c Rename some chunks:
 3bb4bbeb Merge "Mux API change:"
 d0c79f05 Mux API change:

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
@@ -215,7 +215,6 @@ DSP_DEC_OBJS = \
     $(DIROBJ)\dsp\lossless_msa.obj \
     $(DIROBJ)\dsp\lossless_neon.obj \
     $(DIROBJ)\dsp\lossless_sse2.obj \
-    $(DIROBJ)\dsp\lossless_sse41.obj \
     $(DIROBJ)\dsp\rescaler.obj \
     $(DIROBJ)\dsp\rescaler_mips32.obj \
     $(DIROBJ)\dsp\rescaler_mips_dsp_r2.obj \
@@ -392,13 +391,7 @@ $(DIRBIN)\get_disto.exe: $(IMAGEIO_DEC_OBJS) $(IMAGEIO_UTIL_OBJS)
 $(DIRBIN)\get_disto.exe: $(LIBWEBPDEMUX) $(LIBWEBP)
 $(DIRBIN)\webp_quality.exe: $(DIROBJ)\extras\webp_quality.obj
 $(DIRBIN)\webp_quality.exe: $(IMAGEIO_UTIL_OBJS)
-$(DIRBIN)\webp_quality.exe: $(EXTRAS_OBJS)
-# EXTRA_OBJS requires private symbols from dsp. Explicitly add those when
-# building libwebp as a dll.
-!IF "$(DLLBUILD)" == "TRUE"
-$(DIRBIN)\webp_quality.exe: $(DSP_DEC_OBJS)
-!ENDIF
-$(DIRBIN)\webp_quality.exe: $(LIBWEBP)
+$(DIRBIN)\webp_quality.exe: $(EXTRAS_OBJS) $(LIBWEBP)
 $(DIRBIN)\webpinfo.exe: $(DIROBJ)\examples\webpinfo.obj
 $(DIRBIN)\webpinfo.exe: $(IMAGEIO_DEC_OBJS)
 $(DIRBIN)\webpinfo.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)

NEWS

@@ -1,50 +1,3 @@
-- 7/20/2021: version 1.2.1
-  This is a binary compatible release.
-  * minor lossless encoder improvements and x86 color conversion speed up
-  * add ARM64 simulator support to xcframeworkbuild.sh (#510)
-  * further security related hardening in libwebp & examples
-    (issues: #497, #508, #518)
-    (chromium: #1196480, #1196773, #1196775, #1196777, #1196778, #1196850)
-    (oss-fuzz: #28658, #28978)
-  * toolchain updates and bug fixes (#498, #501, #502, #504, #505, #506, #509,
-                                     #533)
-  * use more inclusive language within the source (#507)
-
-- 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:
-      WebPMalloc (issue #442)
-    - extras:
-      WebPUnmultiplyARGB
-  * alpha decode fix (issue #439)
-  * toolchain updates and bug fixes
-    (chromium: #1026858, #1027136, #1027409, #1028620, #1028716, #995200)
-    (oss-fuzz: #19430, #19447)
-
-- 7/4/2019: version 1.0.3
-  This is a binary compatible release.
-  * resize fixes for Nx1 sizes and the addition of non-opaque alpha values for
-    odd sizes (issues #418, #434)
-  * lossless encode/decode performance improvements
-  * lossy compression performance improvement at low quality levels with flat
-    content (issue #432)
-  * python swig files updated to support python 3
-  Tool updates:
-    vwebp will now preserve the aspect ratio of images that exceed monitor
-    resolution by scaling the image to fit (issue #433)
-
 - 1/14/2019: version 1.0.2
   This is a binary compatible release.
   * (Windows) unicode file support in the tools (linux and mac already had

README

@@ -4,7 +4,7 @@
           \__\__/\____/\_____/__/ ____  ___
                 / _/ /    \    \ /  _ \/ _/
                /  \_/   / /   \ \   __/  \__
-               \____/____/\_____/_____/____/v1.2.1
+               \____/____/\_____/_____/____/v1.0.2
 
 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
@@ -603,7 +597,7 @@ The encoding flow looks like:
   // Setup a config, starting form a preset and tuning some additional
   // parameters
   WebPConfig config;
-  if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor)) {
+  if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor))
     return 0;   // version error
   }
   // ... additional tuning
@@ -619,7 +613,7 @@ The encoding flow looks like:
   pic.width = width;
   pic.height = height;
   // allocated picture of dimension width x height
-  if (!WebPPictureAlloc(&pic)) {
+  if (!WebPPictureAllocate(&pic)) {
     return 0;   // memory error
   }
   // at this point, 'pic' has been initialized as a container,

README.mux

@@ -1,7 +1,7 @@
           __   __  ____  ____  ____  __ __  _     __ __
          /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
          \       /   __/  _  \   __/      /  /  (_/  /__
-          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.2.1
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.0.2
 
 
 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

README.webp_js

@@ -10,21 +10,26 @@ This file describes the compilation of libwebp into a JavaScript decoder
 using Emscripten and CMake.
 
  - install the Emscripten SDK following the procedure described at:
-   https://emscripten.org/docs/getting_started/downloads.html#installation-instructions-using-the-emsdk-recommended
+   https://kripken.github.io/emscripten-site/docs/getting_started/downloads.html
    After installation, you should have some global variable positioned to the
-   location of the SDK. In particular, $EMSDK should point to the
+   location of the SDK. In particular, $EMSCRIPTEN should point to the
    top-level directory containing Emscripten tools.
 
+ - make sure the file $EMSCRIPTEN/cmake/Modules/Platform/Emscripten.cmake is
+   accessible. This is the toolchain file used by CMake to invoke Emscripten.
+
  - configure the project 'WEBP_JS' with CMake using:
 
  cd webp_js && \
- emcmake cmake -DWEBP_BUILD_WEBP_JS=ON \
+ 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 'emmake make'.
+ - 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
@@ -50,9 +55,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 2.0.18,
-  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:
 =======
@@ -70,6 +74,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.

build.gradle

@@ -141,7 +141,6 @@ model {
             include "lossless_msa.c"
             include "lossless_neon.$NEON"
             include "lossless_sse2.c"
-            include "lossless_sse41.c"
             include "rescaler.c"
             include "rescaler_mips32.c"
             include "rescaler_mips_dsp_r2.c"
@@ -433,3 +432,8 @@ model {
     }
   }
 }
+
+// Task to generate the wrapper.
+task wrapper(type: Wrapper) {
+  gradleVersion = '2.13'
+}

cmake/WebPConfig.cmake.in

@@ -5,7 +5,7 @@ set(WEBP_VERSION ${WebP_VERSION})
 
 include ("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
 
-set(WebP_INCLUDE_DIRS "@CMAKE_INSTALL_FULL_INCLUDEDIR@")
+set(WebP_INCLUDE_DIRS "webp")
 set(WEBP_INCLUDE_DIRS ${WebP_INCLUDE_DIRS})
 set(WebP_LIBRARIES "@INSTALLED_LIBRARIES@")
 set(WEBP_LIBRARIES "${WebP_LIBRARIES}")

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
 

cmake/cpu.cmake

@@ -1,11 +1,3 @@
-#  Copyright (c) 2021 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.
-
 # Check for SIMD extensions.
 include(CMakePushCheckState)
 
@@ -39,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()
+if(MSVC)
+  # MSVC does not have a SSE4 flag but AVX support implies SSE4 support.
   set(SIMD_ENABLE_FLAGS "/arch:AVX;/arch:SSE2;;;;")
-  endif()
   set(SIMD_DISABLE_FLAGS)
 else()
   set(SIMD_ENABLE_FLAGS
@@ -73,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
@@ -91,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 " ")
@@ -110,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})
+      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.
@@ -125,12 +106,6 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
       list(GET SIMD_DISABLE_FLAGS ${I_SIMD} SIMD_COMPILE_FLAG)
       include(CheckCCompilerFlag)
       if(SIMD_COMPILE_FLAG)
-        # Between 3.17.0 and 3.18.2 check_cxx_compiler_flag() sets a normal
-        # variable at parent scope while check_cxx_source_compiles() continues
-        # to set an internal cache variable, so we unset both to avoid the
-        # failure / success state persisting between checks. See
-        # https://gitlab.kitware.com/cmake/cmake/-/issues/21207.
-        unset(HAS_COMPILE_FLAG)
         unset(HAS_COMPILE_FLAG CACHE)
         check_c_compiler_flag(${SIMD_COMPILE_FLAG} HAS_COMPILE_FLAG)
         if(HAS_COMPILE_FLAG)
@@ -148,7 +123,6 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
                                   "warning: argument unused during compilation:"
                                   ${COMMON_PATTERNS})
           if(NOT FLAG_${SIMD_COMPILE_FLAG})
-            unset(HAS_COMPILE_FLAG)
             unset(HAS_COMPILE_FLAG CACHE)
           endif()
         endif()

cmake/deps.cmake

@@ -1,11 +1,3 @@
-#  Copyright (c) 2021 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.
-
 # Generate the config.h to compile with specific intrinsics / libs.
 
 # Check for compiler options.
@@ -30,25 +22,23 @@ check_c_source_compiles("
   " HAVE_BUILTIN_BSWAP64)
 
 # Check for libraries.
-if(WEBP_USE_THREAD)
-  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")
+find_package(Threads)
+if(Threads_FOUND)
+  if(CMAKE_USE_PTHREADS_INIT)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread")
   endif()
+  foreach(PTHREAD_TEST HAVE_PTHREAD_PRIO_INHERIT PTHREAD_CREATE_UNDETACHED)
     check_c_source_compiles("
         #include <pthread.h>
         int main (void) {
-          int attr = PTHREAD_PRIO_INHERIT;
+          int attr = ${PTHREAD_TEST};
           return attr;
         }
-      " FLAG_HAVE_PTHREAD_PRIO_INHERIT)
-    set(HAVE_PTHREAD_PRIO_INHERIT ${FLAG_HAVE_PTHREAD_PRIO_INHERIT})
+      " ${PTHREAD_TEST})
+  endforeach()
   list(APPEND WEBP_DEP_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
-  endif()
-  set(WEBP_USE_THREAD ${Threads_FOUND})
 endif()
+set(WEBP_USE_THREAD ${Threads_FOUND})
 
 # TODO: this seems unused, check with autotools.
 set(LT_OBJDIR ".libs/")

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libwebp], [1.2.1],
+AC_INIT([libwebp], [1.0.2],
         [https://bugs.chromium.org/p/webp],,
         [http://developers.google.com/speed/webp])
 AC_CANONICAL_HOST
@@ -32,40 +32,6 @@ AC_ARG_ENABLE([everything],
                SET_IF_UNSET([enable_libwebpextras], [$enableval])
                SET_IF_UNSET([enable_libwebpmux], [$enableval])])
 
-dnl === Check whether libwebpmux should be built
-AC_MSG_CHECKING(whether libwebpmux is to be built)
-AC_ARG_ENABLE([libwebpmux],
-              AS_HELP_STRING([--disable-libwebpmux],
-                             [Disable libwebpmux @<:@default=no@:>@]),
-              [], [enable_libwebpmux=yes])
-AC_MSG_RESULT(${enable_libwebpmux-no})
-AM_CONDITIONAL([BUILD_MUX], [test "$enable_libwebpmux" = "yes"])
-
-dnl === Check whether libwebpdemux should be built
-AC_MSG_CHECKING(whether libwebpdemux is to be built)
-AC_ARG_ENABLE([libwebpdemux],
-              AS_HELP_STRING([--disable-libwebpdemux],
-                             [Disable libwebpdemux @<:@default=no@:>@]),
-              [], [enable_libwebpdemux=yes])
-AC_MSG_RESULT(${enable_libwebpdemux-no})
-AM_CONDITIONAL([BUILD_DEMUX], [test "$enable_libwebpdemux" = "yes"])
-
-dnl === Check whether decoder library should be built.
-AC_MSG_CHECKING(whether decoder library is to be built)
-AC_ARG_ENABLE([libwebpdecoder],
-              AS_HELP_STRING([--enable-libwebpdecoder],
-                             [Build libwebpdecoder @<:@default=no@:>@]))
-AC_MSG_RESULT(${enable_libwebpdecoder-no})
-AM_CONDITIONAL([BUILD_LIBWEBPDECODER], [test "$enable_libwebpdecoder" = "yes"])
-
-dnl === Check whether libwebpextras should be built
-AC_MSG_CHECKING(whether libwebpextras is to be built)
-AC_ARG_ENABLE([libwebpextras],
-              AS_HELP_STRING([--enable-libwebpextras],
-                             [Build libwebpextras @<:@default=no@:>@]))
-AC_MSG_RESULT(${enable_libwebpextras-no})
-AM_CONDITIONAL([BUILD_EXTRAS], [test "$enable_libwebpextras" = "yes"])
-
 dnl === If --enable-asserts is not defined, define NDEBUG
 
 AC_MSG_CHECKING(whether asserts are enabled)
@@ -114,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])
@@ -259,9 +224,6 @@ AS_IF([test "x$enable_neon" != "xno"], [
         *android*) AC_CHECK_HEADERS([cpu-features.h]) ;;
       esac
       ;;
-    aarch64*|arm64*)
-      AC_DEFINE(WEBP_HAVE_NEON, [1], [Set to 1 if NEON is supported])
-      ;;
   esac
   AC_SUBST([NEON_FLAGS])])
 
@@ -446,10 +408,6 @@ AS_IF([test "x$enable_gl" != "xno"], [
 
   if test "$glut_support" = "yes" -a "$enable_libwebpdemux" = "yes"; then
     build_vwebp=yes
-  else
-    AC_MSG_NOTICE(
-      m4_normalize([Not building vwebp.
-                    OpenGL libraries and --enable-libwebpdemux are required.]))
   fi
 ])
 AM_CONDITIONAL([BUILD_VWEBP], [test "$build_vwebp" = "yes"])
@@ -509,7 +467,7 @@ AS_IF([test "x$enable_sdl" != "xno"], [
   if test x"$sdl_support" = "xyes"; then
     build_vwebp_sdl=yes
   else
-    AC_MSG_NOTICE([Not building vwebp-sdl. SDL library is required.])
+    AC_MSG_WARN(Optional SDL library not found)
   fi
 ])
 
@@ -633,17 +591,11 @@ AS_IF([test "x$enable_gif" != "xno"], [
   if test "$gif_support" = "yes" -a \
           "$enable_libwebpdemux" = "yes"; then
     build_anim_diff=yes
-  else
-    AC_MSG_NOTICE(
-      [Not building anim_diff. libgif and --enable-libwebpdemux are required.])
   fi
 
   if test "$gif_support" = "yes" -a \
           "$enable_libwebpmux" = "yes"; then
     build_gif2webp=yes
-  else
-    AC_MSG_NOTICE(
-      [Not building gif2webp. libgif and --enable-libwebpmux are required.])
   fi
 ])
 AM_CONDITIONAL([BUILD_ANIMDIFF], [test "${build_anim_diff}" = "yes"])
@@ -651,17 +603,11 @@ AM_CONDITIONAL([BUILD_GIF2WEBP], [test "${build_gif2webp}" = "yes"])
 
 if test "$enable_libwebpdemux" = "yes" -a "$enable_libwebpmux" = "yes"; then
   build_img2webp=yes
-else
-  AC_MSG_NOTICE(
-    m4_normalize([Not building img2webp.
-                  --enable-libwebpdemux & --enable-libwebpmux are required.]))
 fi
 AM_CONDITIONAL([BUILD_IMG2WEBP], [test "${build_img2webp}" = "yes"])
 
 if test "$enable_libwebpmux" = "yes"; then
   build_webpinfo=yes
-else
-  AC_MSG_NOTICE([Not building webpinfo. --enable-libwebpdemux is required.])
 fi
 AM_CONDITIONAL([BUILD_WEBPINFO], [test "${build_webpinfo}" = "yes"])
 
@@ -745,6 +691,39 @@ else
   AC_MSG_RESULT([no])
 fi
 
+dnl === Check whether libwebpmux should be built
+AC_MSG_CHECKING(whether libwebpmux is to be built)
+AC_ARG_ENABLE([libwebpmux],
+              AS_HELP_STRING([--enable-libwebpmux],
+                             [Build libwebpmux @<:@default=no@:>@]))
+AC_MSG_RESULT(${enable_libwebpmux-no})
+AM_CONDITIONAL([BUILD_MUX], [test "$enable_libwebpmux" = "yes"])
+
+dnl === Check whether libwebpdemux should be built
+AC_MSG_CHECKING(whether libwebpdemux is to be built)
+AC_ARG_ENABLE([libwebpdemux],
+              AS_HELP_STRING([--disable-libwebpdemux],
+                             [Disable libwebpdemux @<:@default=no@:>@]),
+              [], [enable_libwebpdemux=yes])
+AC_MSG_RESULT(${enable_libwebpdemux-no})
+AM_CONDITIONAL([BUILD_DEMUX], [test "$enable_libwebpdemux" = "yes"])
+
+dnl === Check whether decoder library should be built.
+AC_MSG_CHECKING(whether decoder library is to be built)
+AC_ARG_ENABLE([libwebpdecoder],
+              AS_HELP_STRING([--enable-libwebpdecoder],
+                             [Build libwebpdecoder @<:@default=no@:>@]))
+AC_MSG_RESULT(${enable_libwebpdecoder-no})
+AM_CONDITIONAL([BUILD_LIBWEBPDECODER], [test "$enable_libwebpdecoder" = "yes"])
+
+dnl === Check whether libwebpextras should be built
+AC_MSG_CHECKING(whether libwebpextras is to be built)
+AC_ARG_ENABLE([libwebpextras],
+              AS_HELP_STRING([--enable-libwebpextras],
+                             [Build libwebpextras @<:@default=no@:>@]))
+AC_MSG_RESULT(${enable_libwebpextras-no})
+AM_CONDITIONAL([BUILD_EXTRAS], [test "$enable_libwebpextras" = "yes"])
+
 dnl =========================
 
 AC_CONFIG_MACRO_DIR([m4])

doc/webp-container-spec.txt

@@ -816,7 +816,7 @@ RIFF/WEBP
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [vp8spec]:  http://tools.ietf.org/html/rfc6386
-[webpllspec]: https://chromium.googlesource.com/webm/libwebp/+/HEAD/doc/webp-lossless-bitstream-spec.txt
+[webpllspec]: https://chromium.googlesource.com/webm/libwebp/+/master/doc/webp-lossless-bitstream-spec.txt
 [iccspec]: http://www.color.org/icc_specs2.xalter
 [metadata]: http://www.metadataworkinggroup.org/pdf/mwg_guidance.pdf
 [rfc 1166]: http://tools.ietf.org/html/rfc1166

examples/anim_util.c

@@ -60,15 +60,15 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
       !CheckSizeForOverflow(total_frame_size)) {
     return 0;
   }
-  mem = (uint8_t*)WebPMalloc((size_t)total_size);
-  frames = (DecodedFrame*)WebPMalloc((size_t)total_frame_size);
+  mem = (uint8_t*)malloc((size_t)total_size);
+  frames = (DecodedFrame*)malloc((size_t)total_frame_size);
 
   if (mem == NULL || frames == NULL) {
-    WebPFree(mem);
-    WebPFree(frames);
+    free(mem);
+    free(frames);
     return 0;
   }
-  WebPFree(image->raw_mem);
+  free(image->raw_mem);
   image->num_frames = num_frames;
   image->frames = frames;
   for (i = 0; i < num_frames; ++i) {
@@ -82,8 +82,8 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
 
 void ClearAnimatedImage(AnimatedImage* const image) {
   if (image != NULL) {
-    WebPFree(image->raw_mem);
-    WebPFree(image->frames);
+    free(image->raw_mem);
+    free(image->frames);
     image->num_frames = 0;
     image->frames = NULL;
     image->raw_mem = NULL;
@@ -165,7 +165,7 @@ static int DumpFrame(const char filename[], const char dump_folder[],
   base_name = (base_name == NULL) ? (const W_CHAR*)filename : base_name + 1;
   max_len = WSTRLEN(dump_folder) + 1 + WSTRLEN(base_name)
           + strlen("_frame_") + strlen(".pam") + 8;
-  file_name = (W_CHAR*)WebPMalloc(max_len * sizeof(*file_name));
+  file_name = (W_CHAR*)malloc(max_len * sizeof(*file_name));
   if (file_name == NULL) goto End;
 
   if (WSNPRINTF(file_name, max_len, "%s/%s_frame_%d.pam",
@@ -197,7 +197,7 @@ static int DumpFrame(const char filename[], const char dump_folder[],
   ok = 1;
  End:
   if (f != NULL) fclose(f);
-  WebPFree(file_name);
+  free(file_name);
   return ok;
 }
 
@@ -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);

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;
 }
 
@@ -130,8 +128,7 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
 static void AllocExtraInfo(WebPPicture* const pic) {
   const int mb_w = (pic->width + 15) / 16;
   const int mb_h = (pic->height + 15) / 16;
-  pic->extra_info =
-      (uint8_t*)WebPMalloc(mb_w * mb_h * sizeof(*pic->extra_info));
+  pic->extra_info = (uint8_t*)malloc(mb_w * mb_h * sizeof(*pic->extra_info));
 }
 
 static void PrintByteCount(const int bytes[4], int total_size,
@@ -150,7 +147,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 +524,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 +564,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");
@@ -646,10 +640,10 @@ static const char* const kErrorMessages[VP8_ENC_ERROR_LAST] = {
 
 //------------------------------------------------------------------------------
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   int return_value = -1;
-  const char* in_file = NULL, *out_file = NULL, *dump_file = NULL;
-  FILE* out = NULL;
+  const char *in_file = NULL, *out_file = NULL, *dump_file = NULL;
+  FILE *out = NULL;
   int c;
   int short_output = 0;
   int quiet = 0;
@@ -669,7 +663,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 +690,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 +706,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 +716,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 +755,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 +770,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 +790,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 +826,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 +849,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 +897,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 +973,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 +987,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 +1074,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 +1093,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,32 +1104,34 @@ 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");
+  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;
       }
-
-  if (out == NULL && keep_metadata) {
-    // output is disabled, just display the metadata stats.
+    } 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}};
+      } *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)) {
+                               0, &unused1, &unused2)) {
           metadata_written |= iter->flag;
         }
       }
     }
+  }
 
   if (!quiet) {
     if (!short_output || print_distortion < 0) {
@@ -1225,7 +1168,7 @@ int main(int argc, const char* argv[]) {
 
  Error:
   WebPMemoryWriterClear(&memory_writer);
-  WebPFree(picture.extra_info);
+  free(picture.extra_info);
   MetadataFree(&metadata);
   WebPPictureFree(&picture);
   WebPPictureFree(&original_picture);

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"
@@ -133,7 +132,7 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
                      format == RGB_565) ? 2
                   : 4;
     uint32_t stride = bpp * w + 7;   // <- just for exercising
-    external_buffer = (uint8_t*)WebPMalloc(stride * h);
+    external_buffer = (uint8_t*)malloc(stride * h);
     if (external_buffer == NULL) return NULL;
     output_buffer->u.RGBA.stride = stride;
     output_buffer->u.RGBA.size = stride * h;
@@ -146,7 +145,7 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
     uint32_t total_size = stride * h * (has_alpha ? 2 : 1)
                         + 2 * uv_stride * (h + 1) / 2;
     assert(format >= YUV && format <= YUVA);
-    external_buffer = (uint8_t*)WebPMalloc(total_size);
+    external_buffer = (uint8_t*)malloc(total_size);
     if (external_buffer == NULL) return NULL;
     tmp = external_buffer;
     output_buffer->u.YUVA.y = tmp;
@@ -177,10 +176,10 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
   return external_buffer;
 }
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   int ok = 0;
-  const char* in_file = NULL;
-  const char* out_file = NULL;
+  const char *in_file = NULL;
+  const char *out_file = NULL;
 
   WebPDecoderConfig config;
   WebPDecBuffer* const output_buffer = &config.output;
@@ -413,8 +412,8 @@ int main(int argc, const char* argv[]) {
   }
  Exit:
   WebPFreeDecBuffer(output_buffer);
-  WebPFree((void*)external_buffer);
-  WebPFree((void*)data);
+  free((void*)external_buffer);
+  free((void*)data);
   FREE_WARGV_AND_RETURN(ok ? 0 : -1);
 }
 

examples/example_util.c

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

examples/gif2webp.c

@@ -96,12 +96,12 @@ static void Help(void) {
 
 //------------------------------------------------------------------------------
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   int verbose = 0;
   int gif_error = GIF_ERROR;
   WebPMuxError err = WEBP_MUX_OK;
   int ok = 0;
-  const W_CHAR* in_file = NULL, *out_file = NULL;
+  const W_CHAR *in_file = NULL, *out_file = NULL;
   GifFileType* gif = NULL;
   int frame_duration = 0;
   int frame_timestamp = 0;
@@ -379,7 +379,7 @@ int main(int argc, const char* argv[]) {
       }
       case EXTENSION_RECORD_TYPE: {
         int extension;
-        GifByteType* data = NULL;
+        GifByteType *data = NULL;
         if (DGifGetExtension(gif, &extension, &data) == GIF_ERROR) {
           goto End;
         }
@@ -465,10 +465,8 @@ int main(int argc, const char* argv[]) {
     fprintf(stderr, "%s\n", WebPAnimEncoderGetError(enc));
     goto End;
   }
-  // If there's only one frame, we don't need to handle loop count.
-  if (frame_number == 1) {
-    loop_count = 0;
-  } else if (!loop_compatibility) {
+
+  if (!loop_compatibility) {
     if (!stored_loop_count) {
       // if no loop-count element is seen, the default is '1' (loop-once)
       // and we need to signal it explicitly in WebP. Note however that
@@ -595,7 +593,7 @@ int main(int argc, const char* argv[]) {
 
 #else  // !WEBP_HAVE_GIF
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   fprintf(stderr, "GIF support not enabled in %s.\n", argv[0]);
   (void)argc;
   return 0;

examples/gifdec.c

@@ -137,7 +137,7 @@ int GIFReadFrame(GifFileType* const gif, int transparent_index,
   }
   dst = sub_image.argb;
 
-  tmp = (uint8_t*)WebPMalloc(rect.width * sizeof(*tmp));
+  tmp = (uint8_t*)malloc(rect.width * sizeof(*tmp));
   if (tmp == NULL) goto End;
 
   if (image_desc->Interlace) {  // Interlaced image.
@@ -168,7 +168,7 @@ int GIFReadFrame(GifFileType* const gif, int transparent_index,
  End:
   if (!ok) picture->error_code = sub_image.error_code;
   WebPPictureFree(&sub_image);
-  WebPFree(tmp);
+  free(tmp);
   return ok;
 }
 

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;
 }
 

examples/vwebp.c

@@ -418,9 +418,8 @@ static void HandleDisplay(void) {
 }
 
 static void StartDisplay(void) {
-  int width = kParams.canvas_width;
-  int height = kParams.canvas_height;
-  int screen_width, screen_height;
+  const int width = kParams.canvas_width;
+  const int height = kParams.canvas_height;
   // TODO(webp:365) GLUT_DOUBLE results in flickering / old frames to be
   // partially displayed with animated webp + alpha.
 #if defined(__APPLE__) || defined(_WIN32)
@@ -428,18 +427,6 @@ static void StartDisplay(void) {
 #else
   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
 #endif
-  screen_width = glutGet(GLUT_SCREEN_WIDTH);
-  screen_height = glutGet(GLUT_SCREEN_HEIGHT);
-  if (width > screen_width || height > screen_height) {
-    if (width > screen_width) {
-      height = (height * screen_width + width - 1) / width;
-      width = screen_width;
-    }
-    if (height > screen_height) {
-      width = (width * screen_height + height - 1) / height;
-      height = screen_height;
-    }
-  }
   glutInitWindowSize(width, height);
   glutCreateWindow("WebP viewer");
   glutDisplayFunc(HandleDisplay);
@@ -479,7 +466,7 @@ static void Help(void) {
       "  'q' / 'Q' / ESC .... quit\n");
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[]) {
   int c;
   WebPDecoderConfig* const config = &kParams.config;
   WebPIterator* const curr = &kParams.curr_frame;
@@ -630,7 +617,7 @@ int main(int argc, char* argv[]) {
 
 #else   // !WEBP_HAVE_GL
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   fprintf(stderr, "OpenGL support not enabled in %s.\n", argv[0]);
   (void)argc;
   return 0;

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");
@@ -472,11 +469,11 @@ static WebPMux* DuplicateMuxHeader(const WebPMux* const mux) {
 }
 
 static int ParseFrameArgs(const char* args, WebPMuxFrameInfo* const info) {
-  int dispose_method, unused;
+  int dispose_method, dummy;
   char plus_minus, blend_method;
   const int num_args = sscanf(args, "+%d+%d+%d+%d%c%c+%d", &info->duration,
                               &info->x_offset, &info->y_offset, &dispose_method,
-                              &plus_minus, &blend_method, &unused);
+                              &plus_minus, &blend_method, &dummy);
   switch (num_args) {
     case 1:
       info->x_offset = info->y_offset = 0;  // fall through
@@ -495,7 +492,7 @@ static int ParseFrameArgs(const char* args, WebPMuxFrameInfo* const info) {
 
   WarnAboutOddOffset(info);
 
-  // Note: The validity of the following conversion is checked by
+  // Note: The sanity of the following conversion is checked by
   // WebPMuxPushFrame().
   info->dispose_method = (WebPMuxAnimDispose)dispose_method;
 
@@ -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;
@@ -1080,7 +1045,7 @@ static int Process(const Config* config) {
         int* durations = NULL;
         WebPMux* new_mux = DuplicateMuxHeader(mux);
         if (new_mux == NULL) goto Err2;
-        durations = (int*)WebPMalloc((size_t)num_frames * sizeof(*durations));
+        durations = (int*)malloc((size_t)num_frames * sizeof(*durations));
         if (durations == NULL) goto Err2;
         for (i = 0; i < num_frames; ++i) durations[i] = -1;
 
@@ -1138,7 +1103,7 @@ static int Process(const Config* config) {
         new_mux = NULL;
 
  Err3:
-        WebPFree(durations);
+        free(durations);
         WebPMuxDelete(new_mux);
         if (!ok) goto Err2;
       }

extras/extras.c

@@ -12,14 +12,13 @@
 
 #include "extras/extras.h"
 #include "webp/format_constants.h"
-#include "src/dsp/dsp.h"
 
 #include <assert.h>
 #include <string.h>
 
 #define XTRA_MAJ_VERSION 1
-#define XTRA_MIN_VERSION 2
-#define XTRA_REV_VERSION 1
+#define XTRA_MIN_VERSION 0
+#define XTRA_REV_VERSION 2
 
 //------------------------------------------------------------------------------
 
@@ -58,7 +57,7 @@ int WebPImportRGB565(const uint8_t* rgb565, WebPPicture* pic) {
   for (y = 0; y < pic->height; ++y) {
     const int width = pic->width;
     for (x = 0; x < width; ++x) {
-#if defined(WEBP_SWAP_16BIT_CSP) && (WEBP_SWAP_16BIT_CSP == 1)
+#ifdef WEBP_SWAP_16BIT_CSP
       const uint32_t rg = rgb565[2 * x + 1];
       const uint32_t gb = rgb565[2 * x + 0];
 #else
@@ -91,7 +90,7 @@ int WebPImportRGB4444(const uint8_t* rgb4444, WebPPicture* pic) {
   for (y = 0; y < pic->height; ++y) {
     const int width = pic->width;
     for (x = 0; x < width; ++x) {
-#if defined(WEBP_SWAP_16BIT_CSP) && (WEBP_SWAP_16BIT_CSP == 1)
+#ifdef WEBP_SWAP_16BIT_CSP
       const uint32_t rg = rgb4444[2 * x + 1];
       const uint32_t ba = rgb4444[2 * x + 0];
 #else
@@ -145,18 +144,3 @@ int WebPImportColorMappedARGB(const uint8_t* indexed, int indexed_stride,
 }
 
 //------------------------------------------------------------------------------
-
-int WebPUnmultiplyARGB(WebPPicture* pic) {
-  int y;
-  uint32_t* dst;
-  if (pic == NULL || pic->use_argb != 1 || pic->argb == NULL) return 0;
-  WebPInitAlphaProcessing();
-  dst = pic->argb;
-  for (y = 0; y < pic->height; ++y) {
-    WebPMultARGBRow(dst, pic->width, /*inverse=*/1);
-    dst += pic->argb_stride;
-  }
-  return 1;
-}
-
-//------------------------------------------------------------------------------

extras/extras.h

@@ -19,7 +19,7 @@ extern "C" {
 
 #include "webp/encode.h"
 
-#define WEBP_EXTRAS_ABI_VERSION 0x0002    // MAJOR(8b) + MINOR(8b)
+#define WEBP_EXTRAS_ABI_VERSION 0x0001    // MAJOR(8b) + MINOR(8b)
 
 //------------------------------------------------------------------------------
 
@@ -51,13 +51,6 @@ WebPImportColorMappedARGB(const uint8_t* indexed, int indexed_stride,
                           const uint32_t palette[], int palette_size,
                           WebPPicture* pic);
 
-// Convert the ARGB content of 'pic' from associated to unassociated.
-// 'pic' can be for instance the result of calling of some WebPPictureImportXXX
-// functions, with pic->use_argb set to 'true'. It is assumed (and not checked)
-// that the pre-multiplied r/g/b values as less or equal than the alpha value.
-// Return false in case of error (invalid parameter, ...).
-WEBP_EXTERN int WebPUnmultiplyARGB(WebPPicture* pic);
-
 //------------------------------------------------------------------------------
 
 // Parse a bitstream, search for VP8 (lossy) header and report a

extras/get_disto.c

@@ -226,7 +226,7 @@ static void Help(void) {
           " Also handles PNG, JPG and TIFF files, in addition to WebP.\n");
 }
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   WebPPicture pic1, pic2;
   size_t size1 = 0, size2 = 0;
   int ret = 1;

extras/vwebp_sdl.c

@@ -92,7 +92,7 @@ int main(int argc, char* argv[]) {
 
 #else  // !WEBP_HAVE_SDL
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   fprintf(stderr, "SDL support not enabled in %s.\n", argv[0]);
   (void)argc;
   return 0;

extras/webp_quality.c

@@ -15,7 +15,7 @@
 #include "imageio/imageio_util.h"
 #include "../examples/unicode.h"
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   int c;
   int quiet = 0;
   int ok = 1;

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

gradlew

@@ -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 "$@"

gradlew.bat

@@ -1,19 +1,3 @@
-@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
@@ -30,7 +14,7 @@ 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"
+set DEFAULT_JVM_OPTS=
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
@@ -65,6 +49,7 @@ goto fail
 @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.
@@ -75,6 +60,11 @@ set _SKIP=2
 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

imageio/image_enc.c

@@ -155,8 +155,8 @@ int WebPWritePNG(const char* out_file_name, int use_stdout,
 }
 
 #elif defined(WEBP_HAVE_PNG)    // !HAVE_WINCODEC_H
-static void PNGAPI PNGErrorFunction(png_structp png, png_const_charp unused) {
-  (void)unused;  // remove variable-unused warning
+static void PNGAPI PNGErrorFunction(png_structp png, png_const_charp dummy) {
+  (void)dummy;  // remove variable-unused warning
   longjmp(png_jmpbuf(png), 1);
 }
 
@@ -320,7 +320,7 @@ int WebPWriteBMP(FILE* fout, const WebPDecBuffer* const buffer) {
   PutLE16(bmp_header + 26, 1);                    // number of planes
   PutLE16(bmp_header + 28, bytes_per_px * 8);     // bits per pixel
   PutLE32(bmp_header + 30, 0);                    // no compression (BI_RGB)
-  PutLE32(bmp_header + 34, 0);                    // image size (placeholder)
+  PutLE32(bmp_header + 34, 0);                    // image size (dummy)
   PutLE32(bmp_header + 38, 2400);                 // x pixels/meter
   PutLE32(bmp_header + 42, 2400);                 // y pixels/meter
   PutLE32(bmp_header + 46, 0);                    // number of palette colors

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
@@ -148,11 +148,9 @@ void ImgIoUtilCopyPlane(const uint8_t* src, int src_stride,
 
 // -----------------------------------------------------------------------------
 
-int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t stride, size_t height) {
-  const uint64_t total_size = stride * height;
+int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t nmemb, size_t size) {
+  const uint64_t total_size = nmemb * size;
   int ok = (total_size == (size_t)total_size);
-  // check that 'stride' is representable as int:
-  ok = ok && ((uint64_t)(int)stride == stride);
 #if defined(WEBP_MAX_IMAGE_SIZE)
   ok = ok && (total_size <= (uint64_t)WEBP_MAX_IMAGE_SIZE);
 #endif

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.
@@ -54,8 +54,8 @@ void ImgIoUtilCopyPlane(const uint8_t* src, int src_stride,
 
 //------------------------------------------------------------------------------
 
-// Returns 0 in case of overflow, memory over-allocation or excessive dimension.
-int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t stride, size_t height);
+// Returns 0 in case of overflow of nmemb * size.
+int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t nmemb, size_t size);
 
 #ifdef __cplusplus
 }    // extern "C"

imageio/jpegdec.c

@@ -206,7 +206,6 @@ struct my_error_mgr {
 
 static void my_error_exit(j_common_ptr dinfo) {
   struct my_error_mgr* myerr = (struct my_error_mgr*)dinfo->err;
-  fprintf(stderr, "libjpeg error: ");
   dinfo->err->output_message(dinfo);
   longjmp(myerr->setjmp_buffer, 1);
 }
@@ -274,7 +273,7 @@ int ReadJPEG(const uint8_t* const data, size_t data_size,
   ctx.data = data;
   ctx.data_size = data_size;
 
-  memset((j_decompress_ptr)&dinfo, 0, sizeof(dinfo));   // for setjmp safety
+  memset((j_decompress_ptr)&dinfo, 0, sizeof(dinfo));   // for setjmp sanity
   dinfo.err = jpeg_std_error(&jerr.pub);
   jerr.pub.error_exit = my_error_exit;
 

imageio/pngdec.c

@@ -259,15 +259,6 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
     goto End;
   }
 
-#if LOCAL_PNG_PREREQ(1,5) || \
-    (LOCAL_PNG_PREREQ(1,4) && PNG_LIBPNG_VER_RELEASE >= 1)
-  // 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);
-  }
-#endif
-
   info = png_create_info_struct(png);
   if (info == NULL) goto Error;
   end_info = png_create_info_struct(png);

imageio/pnmdec.c

@@ -26,15 +26,15 @@ typedef enum {
   DEPTH_FLAG      = 1 << 2,
   MAXVAL_FLAG     = 1 << 3,
   TUPLE_FLAG      = 1 << 4,
-  ALL_NEEDED_FLAGS = WIDTH_FLAG | HEIGHT_FLAG | DEPTH_FLAG | MAXVAL_FLAG
+  ALL_NEEDED_FLAGS = 0x1f
 } PNMFlags;
 
 typedef struct {
   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;
@@ -74,7 +74,6 @@ static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
   char out[MAX_LINE_SIZE + 1];
   size_t out_size;
   int tmp;
-  int expected_depth = -1;
   assert(info != NULL);
   while (1) {
     off = ReadLine(info->data, off, info->data_size, out, &out_size);
@@ -96,16 +95,13 @@ static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
       info->seen_flags |= MAXVAL_FLAG;
       info->max_value = tmp;
     } else if (!strcmp(out, "TUPLTYPE RGB_ALPHA")) {
-      expected_depth = 4;
+      info->bytes_per_px = 4;
       info->seen_flags |= TUPLE_FLAG;
     } else if (!strcmp(out, "TUPLTYPE RGB")) {
-      expected_depth = 3;
-      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "TUPLTYPE GRAYSCALE_ALPHA")) {
-      expected_depth = 2;
+      info->bytes_per_px = 3;
       info->seen_flags |= TUPLE_FLAG;
     } else if (!strcmp(out, "TUPLTYPE GRAYSCALE")) {
-      expected_depth = 1;
+      info->bytes_per_px = 1;
       info->seen_flags |= TUPLE_FLAG;
     } else if (!strcmp(out, "ENDHDR")) {
       break;
@@ -114,24 +110,23 @@ static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
       int i;
       if (out_size > 20) sprintf(out + 20 - strlen(kEllipsis), kEllipsis);
       for (i = 0; i < (int)strlen(out); ++i) {
-        // isprint() might trigger a "char-subscripts" warning if given a char.
-        if (!isprint((int)out[i])) out[i] = ' ';
+        if (!isprint(out[i])) out[i] = ' ';
       }
       fprintf(stderr, "PAM header error: unrecognized entry [%s]\n", out);
       return 0;
     }
   }
-  if (!(info->seen_flags & ALL_NEEDED_FLAGS)) {
-    fprintf(stderr, "PAM header error: missing tags%s%s%s%s\n",
-            (info->seen_flags & WIDTH_FLAG) ? "" : " WIDTH",
-            (info->seen_flags & HEIGHT_FLAG) ? "" : " HEIGHT",
-            (info->seen_flags & DEPTH_FLAG) ? "" : " DEPTH",
-            (info->seen_flags & MAXVAL_FLAG) ? "" : " MAXVAL");
+  if (!(info->seen_flags & TUPLE_FLAG)) {
+    if (info->depth > 0 && info->depth <= 4 && info->depth != 2) {
+      info->seen_flags |= TUPLE_FLAG;
+      info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
+    } else {
+      fprintf(stderr, "PAM: invalid bitdepth (%d).\n", info->depth);
       return 0;
     }
-  if (expected_depth != -1 && info->depth != expected_depth) {
-    fprintf(stderr, "PAM header error: expected DEPTH %d but got DEPTH %d\n",
-            expected_depth, info->depth);
+  }
+  if (info->seen_flags != ALL_NEEDED_FLAGS) {
+    fprintf(stderr, "PAM: incomplete header.\n");
     return 0;
   }
   return off;
@@ -165,15 +160,16 @@ static size_t ReadHeader(PNMInfo* const info) {
 
     // finish initializing missing fields
     info->depth = (info->type == 5) ? 1 : 3;
+    info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
   }
   // perform some basic numerical validation
   if (info->width <= 0 || info->height <= 0 ||
       info->type <= 0 || info->type >= 9 ||
-      info->depth <= 0 || info->depth > 4 ||
+      info->depth <= 0 || info->depth == 2 || info->depth > 4 ||
+      info->bytes_per_px < info->depth ||
       info->max_value <= 0 || info->max_value >= 65536) {
     return 0;
   }
-  info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
   return off;
 }
 
@@ -182,7 +178,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 +209,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,62 +219,29 @@ 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);
+    assert(offset + info.bytes_per_px * info.width <= data_size);
+    if (info.depth == 1) {
+      // convert grayscale -> RGB
       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
-        }
+        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)
+  ok = (info.depth == 4) ? WebPPictureImportRGBA(pic, rgb, (int)stride)
                          : WebPPictureImportRGB(pic, rgb, (int)stride);
   if (!ok) goto End;
 

imageio/tiffdec.c

@@ -156,8 +156,7 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
              Metadata* const metadata) {
   MyData my_data = { data, (toff_t)data_size, 0 };
   TIFF* tif;
-  uint32_t image_width, image_height, tile_width, tile_height;
-  uint64_t stride;
+  uint32_t width, height;
   uint16_t samples_per_px = 0;
   uint16_t extra_samples = 0;
   uint16_t* extra_samples_ptr = NULL;
@@ -190,36 +189,15 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
   }
   if (samples_per_px < 3 || samples_per_px > 4) goto End;  // not supported
 
-  if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &image_width) &&
-        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &image_height))) {
+  if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) &&
+        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))) {
     fprintf(stderr, "Error! Cannot retrieve TIFF image dimensions.\n");
     goto End;
   }
-  stride = (uint64_t)image_width * sizeof(*raster);
-  if (!ImgIoUtilCheckSizeArgumentsOverflow(stride, image_height)) {
-    fprintf(stderr, "Error! TIFF image dimension (%d x %d) is too large.\n",
-            image_width, image_height);
+  if (!ImgIoUtilCheckSizeArgumentsOverflow((uint64_t)width * height,
+                                           sizeof(*raster))) {
     goto End;
   }
-
-  // According to spec, a tile can be bigger than the image. However it should
-  // be a multiple of 16 and not way too large, so check that it's not more
-  // than twice the image size, for dimensions above some arbitrary minimum
-  // 32. We also check that they respect WebP's dimension and memory limit.
-  // Note that a tile can be 6byte/px in some cases. Here we assume
-  // 4byte/px with sizeof(*raster), to be conservative.
-  if (TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width) &&
-      TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height)) {
-    if ((tile_width > 32 && tile_width / 2 > image_width) ||
-        (tile_height > 32 && tile_height / 2 > image_height) ||
-        ImgIoUtilCheckSizeArgumentsOverflow(
-            (uint64_t)tile_width * sizeof(*raster), tile_height)) {
-      fprintf(stderr, "Error! TIFF tile dimension (%d x %d) is too large.\n",
-              tile_width, tile_height);
-      goto End;
-    }
-  }
-
   if (samples_per_px > 3 && !TIFFGetField(tif, TIFFTAG_EXTRASAMPLES,
                                           &extra_samples, &extra_samples_ptr)) {
     fprintf(stderr, "Error! Cannot retrieve TIFF ExtraSamples info.\n");
@@ -227,32 +205,33 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
   }
 
   // _Tiffmalloc uses a signed type for size.
-  alloc_size = (int64_t)(stride * image_height);
+  alloc_size = (int64_t)((uint64_t)width * height * sizeof(*raster));
   if (alloc_size < 0 || alloc_size != (tsize_t)alloc_size) goto End;
 
   raster = (uint32*)_TIFFmalloc((tsize_t)alloc_size);
   if (raster != NULL) {
-    if (TIFFReadRGBAImageOriented(tif, image_width, image_height, raster,
+    if (TIFFReadRGBAImageOriented(tif, width, height, raster,
                                   ORIENTATION_TOPLEFT, 1)) {
-      pic->width = image_width;
-      pic->height = image_height;
+      const int stride = width * sizeof(*raster);
+      pic->width = width;
+      pic->height = height;
       // TIFF data is ABGR
 #ifdef WORDS_BIGENDIAN
-      TIFFSwabArrayOfLong(raster, image_width * image_height);
+      TIFFSwabArrayOfLong(raster, width * height);
 #endif
       // if we have an alpha channel, we must un-multiply from rgbA to RGBA
       if (extra_samples == 1 && extra_samples_ptr != NULL &&
           extra_samples_ptr[0] == EXTRASAMPLE_ASSOCALPHA) {
         uint32_t y;
         uint8_t* tmp = (uint8_t*)raster;
-        for (y = 0; y < image_height; ++y) {
-          MultARGBRow(tmp, image_width);
+        for (y = 0; y < height; ++y) {
+          MultARGBRow(tmp, width);
           tmp += stride;
         }
       }
       ok = keep_alpha
-         ? WebPPictureImportRGBA(pic, (const uint8_t*)raster, (int)stride)
-         : WebPPictureImportRGBX(pic, (const uint8_t*)raster, (int)stride);
+         ? WebPPictureImportRGBA(pic, (const uint8_t*)raster, stride)
+         : WebPPictureImportRGBX(pic, (const uint8_t*)raster, stride);
     }
     _TIFFfree(raster);
   } else {

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);
@@ -95,7 +95,7 @@ VP8StatusCode DecodeWebPIncremental(
   {
     WebPIDecoder* const idec = WebPIDecode(data, data_size, config);
     if (idec == NULL) {
-      fprintf(stderr, "Failed during WebPIDecode().\n");
+      fprintf(stderr, "Failed during WebPINewDecoder().\n");
       return VP8_STATUS_OUT_OF_MEMORY;
     } else {
       status = WebPIUpdate(idec, data, data_size);

imageio/wicdec.c

@@ -134,10 +134,7 @@ static HRESULT ExtractICCP(IWICImagingFactory* const factory,
   IWICColorContext** color_contexts;
 
   IFS(IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, &count));
-  if (FAILED(hr) || count == 0) {
-    // Treat unsupported operation as a non-fatal error. See crbug.com/webp/506.
-    return (hr == WINCODEC_ERR_UNSUPPORTEDOPERATION) ? S_OK : hr;
-  }
+  if (FAILED(hr) || count == 0) return hr;
 
   color_contexts = (IWICColorContext**)calloc(count, sizeof(*color_contexts));
   if (color_contexts == NULL) return E_OUTOFMEMORY;
@@ -273,15 +270,10 @@ int ReadPictureWithWIC(const char* const filename,
   WICPixelFormatGUID src_pixel_format = GUID_WICPixelFormatUndefined;
   const WICFormatImporter* importer = NULL;
   GUID src_container_format = GUID_NULL_;
-  // From Windows Kits\10\Include\10.0.19041.0\um\wincodec.h
-  WEBP_DEFINE_GUID(GUID_ContainerFormatWebp_,
-                   0xe094b0e2, 0x67f2, 0x45b3,
-                   0xb0, 0xea, 0x11, 0x53, 0x37, 0xca, 0x7c, 0xf3);
   static const GUID* kAlphaContainers[] = {
     &GUID_ContainerFormatBmp,
     &GUID_ContainerFormatPng,
     &GUID_ContainerFormatTiff,
-    &GUID_ContainerFormatWebp_,
     NULL
   };
   int has_alpha = 0;
@@ -306,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) {
+  if (SUCCEEDED(hr) && 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;
-    }
   }
   IFS(IWICBitmapDecoder_GetFrame(decoder, 0, &frame));
   IFS(IWICBitmapFrameDecode_GetPixelFormat(frame, &src_pixel_format));

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)}'
@@ -39,55 +35,35 @@ readonly TOPDIR=$(pwd)
 readonly BUILDDIR="${TOPDIR}/iosbuild"
 readonly TARGETDIR="${TOPDIR}/WebP.framework"
 readonly DECTARGETDIR="${TOPDIR}/WebPDecoder.framework"
-readonly MUXTARGETDIR="${TOPDIR}/WebPMux.framework"
-readonly DEMUXTARGETDIR="${TOPDIR}/WebPDemux.framework"
 readonly DEVELOPER=$(xcode-select --print-path)
 readonly PLATFORMSROOT="${DEVELOPER}/Platforms"
 readonly LIPO=$(xcrun -sdk iphoneos${SDK} -find lipo)
 LIBLIST=''
 DECLIBLIST=''
-MUXLIBLIST=''
-DEMUXLIBLIST=''
 
 if [[ -z "${SDK}" ]]; then
   echo "iOS SDK not available"
   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/ \
-    ${MUXTARGETDIR}/Headers/ ${DEMUXTARGETDIR}/Headers/
+rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR}
+mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/
 
 if [[ ! -e ${SRCDIR}/configure ]]; then
   if ! (cd ${SRCDIR} && sh autogen.sh); then
-    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 +97,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}"
@@ -129,7 +105,6 @@ for PLATFORM in ${PLATFORMS}; do
     --build=$(${SRCDIR}/config.guess) \
     --disable-shared --enable-static \
     --enable-libwebpdecoder --enable-swap-16bit-csp \
-    --enable-libwebpmux \
     CFLAGS="${CFLAGS}"
   set +x
 
@@ -140,8 +115,6 @@ for PLATFORM in ${PLATFORMS}; do
 
   LIBLIST+=" ${ROOTDIR}/lib/libwebp.a"
   DECLIBLIST+=" ${ROOTDIR}/lib/libwebpdecoder.a"
-  MUXLIBLIST+=" ${ROOTDIR}/lib/libwebpmux.a"
-  DEMUXLIBLIST+=" ${ROOTDIR}/lib/libwebpdemux.a"
 
   make clean
   cd ..
@@ -149,22 +122,8 @@ for PLATFORM in ${PLATFORMS}; do
   export PATH=${OLDPATH}
 done
 
-echo "LIBLIST = ${LIBLIST}"
 cp -a ${SRCDIR}/src/webp/{decode,encode,types}.h ${TARGETDIR}/Headers/
 ${LIPO} -create ${LIBLIST} -output ${TARGETDIR}/WebP
 
-echo "DECLIBLIST = ${DECLIBLIST}"
 cp -a ${SRCDIR}/src/webp/{decode,types}.h ${DECTARGETDIR}/Headers/
 ${LIPO} -create ${DECLIBLIST} -output ${DECTARGETDIR}/WebPDecoder
-
-echo "MUXLIBLIST = ${MUXLIBLIST}"
-cp -a ${SRCDIR}/src/webp/{types,mux,mux_types}.h \
-    ${MUXTARGETDIR}/Headers/
-${LIPO} -create ${MUXLIBLIST} -output ${MUXTARGETDIR}/WebPMux
-
-echo "DEMUXLIBLIST = ${DEMUXLIBLIST}"
-cp -a ${SRCDIR}/src/webp/{decode,types,mux_types,demux}.h \
-    ${DEMUXTARGETDIR}/Headers/
-${LIPO} -create ${DEMUXLIBLIST} -output ${DEMUXTARGETDIR}/WebPDemux
-
-echo  "SUCCESS"

makefile.unix

@@ -118,10 +118,6 @@ GROFF = /usr/bin/groff
 COL = /usr/bin/col
 LDFLAGS = $(EXTRA_LIBS) $(EXTRA_FLAGS) -lm
 
-ifdef BITTRACE
-CFLAGS += -DBITTRACE=$(BITTRACE)
-endif
-
 ANIM_UTIL_OBJS = \
     examples/anim_util.o \
 
@@ -166,7 +162,6 @@ DSP_DEC_OBJS = \
     src/dsp/lossless_msa.o \
     src/dsp/lossless_neon.o \
     src/dsp/lossless_sse2.o \
-    src/dsp/lossless_sse41.o \
     src/dsp/rescaler.o \
     src/dsp/rescaler_mips32.o \
     src/dsp/rescaler_mips_dsp_r2.o \
@@ -403,7 +398,7 @@ examples/webpinfo: examples/webpinfo.o
 examples/anim_diff: examples/libanim_util.a examples/libgifdec.a
 examples/anim_diff: src/demux/libwebpdemux.a examples/libexample_util.a
 examples/anim_diff: imageio/libimageio_util.a src/libwebp.a
-examples/anim_diff: override EXTRA_LIBS += $(GIF_LIBS)
+examples/anim_diff: EXTRA_LIBS += $(GIF_LIBS)
 examples/anim_diff: EXTRA_FLAGS += -DWEBP_HAVE_GIF
 examples/anim_dump: examples/libanim_util.a examples/libgifdec.a
 examples/anim_dump: src/demux/libwebpdemux.a
@@ -411,27 +406,27 @@ examples/anim_dump: examples/libexample_util.a
 examples/anim_dump: imageio/libimageio_util.a
 examples/anim_dump: imageio/libimageenc.a
 examples/anim_dump: src/libwebp.a
-examples/anim_dump: override EXTRA_LIBS += $(GIF_LIBS) $(DWEBP_LIBS)
+examples/anim_dump: EXTRA_LIBS += $(GIF_LIBS) $(DWEBP_LIBS)
 examples/cwebp: examples/libexample_util.a
 examples/cwebp: imageio/libimagedec.a
 examples/cwebp: src/demux/libwebpdemux.a
 examples/cwebp: imageio/libimageio_util.a
 examples/cwebp: src/libwebp.a
-examples/cwebp: override EXTRA_LIBS += $(CWEBP_LIBS)
+examples/cwebp: EXTRA_LIBS += $(CWEBP_LIBS)
 examples/dwebp: examples/libexample_util.a
 examples/dwebp: imageio/libimagedec.a
 examples/dwebp: src/demux/libwebpdemux.a
 examples/dwebp: imageio/libimageenc.a
 examples/dwebp: imageio/libimageio_util.a
 examples/dwebp: src/libwebp.a
-examples/dwebp: override EXTRA_LIBS += $(DWEBP_LIBS)
+examples/dwebp: EXTRA_LIBS += $(DWEBP_LIBS)
 examples/gif2webp: examples/libexample_util.a imageio/libimageio_util.a
 examples/gif2webp: examples/libgifdec.a src/mux/libwebpmux.a src/libwebp.a
-examples/gif2webp: override EXTRA_LIBS += $(GIF_LIBS)
+examples/gif2webp: EXTRA_LIBS += $(GIF_LIBS)
 examples/gif2webp: EXTRA_FLAGS += -DWEBP_HAVE_GIF
 examples/vwebp: examples/libexample_util.a src/demux/libwebpdemux.a
 examples/vwebp: imageio/libimageio_util.a src/libwebp.a
-examples/vwebp: override EXTRA_LIBS += $(GL_LIBS)
+examples/vwebp: EXTRA_LIBS += $(GL_LIBS)
 examples/vwebp: EXTRA_FLAGS += -DWEBP_HAVE_GL
 examples/webpmux: examples/libexample_util.a imageio/libimageio_util.a
 examples/webpmux: src/mux/libwebpmux.a src/libwebpdecoder.a
@@ -439,7 +434,7 @@ examples/img2webp: examples/libexample_util.a imageio/libimageio_util.a
 examples/img2webp: imageio/libimagedec.a
 examples/img2webp: src/demux/libwebpdemux.a
 examples/img2webp: src/mux/libwebpmux.a src/libwebp.a
-examples/img2webp: override EXTRA_LIBS += $(CWEBP_LIBS)
+examples/img2webp: EXTRA_LIBS += $(CWEBP_LIBS)
 examples/webpinfo: examples/libexample_util.a imageio/libimageio_util.a
 examples/webpinfo: src/libwebpdecoder.a
 
@@ -448,7 +443,7 @@ extras/get_disto: imageio/libimagedec.a
 extras/get_disto: src/demux/libwebpdemux.a
 extras/get_disto: imageio/libimageio_util.a
 extras/get_disto: src/libwebp.a
-extras/get_disto: override EXTRA_LIBS += $(CWEBP_LIBS)
+extras/get_disto: EXTRA_LIBS += $(CWEBP_LIBS)
 
 extras/webp_quality: extras/webp_quality.o
 extras/webp_quality: imageio/libimageio_util.a
@@ -459,7 +454,7 @@ extras/vwebp_sdl: extras/webp_to_sdl.o
 extras/vwebp_sdl: imageio/libimageio_util.a
 extras/vwebp_sdl: src/libwebp.a
 extras/vwebp_sdl: EXTRA_FLAGS += -DWEBP_HAVE_SDL $(SDL_FLAGS)
-extras/vwebp_sdl: override EXTRA_LIBS += $(SDL_LIBS)
+extras/vwebp_sdl: EXTRA_LIBS += $(SDL_LIBS)
 
 $(OUT_EXAMPLES) $(EXTRA_EXAMPLES) $(OTHER_EXAMPLES):
 	$(CC) -o $@ $^ $(LDFLAGS)

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.

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

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

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

man/vwebp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH VWEBP 1 "June 5, 2019"
+.TH VWEBP 1 "July 20, 2018"
 .SH NAME
 vwebp \- decompress a WebP file and display it in a window
 .SH SYNOPSIS

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

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:2:1
+libwebp_la_LDFLAGS = -no-undefined -version-info 7:4:0
 libwebpincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebp.pc
 
@@ -48,7 +48,7 @@ if BUILD_LIBWEBPDECODER
   libwebpdecoder_la_LIBADD += dsp/libwebpdspdecode.la
   libwebpdecoder_la_LIBADD += utils/libwebputilsdecode.la
 
-  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 4:2:1
+  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 3:4:0
   pkgconfig_DATA += libwebpdecoder.pc
 endif
 

src/dec/alpha_dec.c

@@ -183,7 +183,7 @@ const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec,
   assert(dec != NULL && io != NULL);
 
   if (row < 0 || num_rows <= 0 || row + num_rows > height) {
-    return NULL;
+    return NULL;    // sanity check.
   }
 
   if (!dec->is_alpha_decoded_) {

src/dec/buffer_dec.c

@@ -102,7 +102,7 @@ static VP8StatusCode AllocateBuffer(WebPDecBuffer* const buffer) {
     int stride;
     uint64_t size;
 
-    if ((uint64_t)w * kModeBpp[mode] >= (1ull << 31)) {
+    if ((uint64_t)w * kModeBpp[mode] >= (1ull << 32)) {
       return VP8_STATUS_INVALID_PARAM;
     }
     stride = w * kModeBpp[mode];
@@ -117,6 +117,7 @@ static VP8StatusCode AllocateBuffer(WebPDecBuffer* const buffer) {
     }
     total_size = size + 2 * uv_size + a_size;
 
+    // Security/sanity checks
     output = (uint8_t*)WebPSafeMalloc(total_size, sizeof(*output));
     if (output == NULL) {
       return VP8_STATUS_OUT_OF_MEMORY;
@@ -155,11 +156,11 @@ VP8StatusCode WebPFlipBuffer(WebPDecBuffer* const buffer) {
   }
   if (WebPIsRGBMode(buffer->colorspace)) {
     WebPRGBABuffer* const buf = &buffer->u.RGBA;
-    buf->rgba += (int64_t)(buffer->height - 1) * buf->stride;
+    buf->rgba += (buffer->height - 1) * buf->stride;
     buf->stride = -buf->stride;
   } else {
     WebPYUVABuffer* const buf = &buffer->u.YUVA;
-    const int64_t H = buffer->height;
+    const int H = buffer->height;
     buf->y += (H - 1) * buf->y_stride;
     buf->y_stride = -buf->y_stride;
     buf->u += ((H - 1) >> 1) * buf->u_stride;
@@ -187,7 +188,8 @@ VP8StatusCode WebPAllocateDecBuffer(int width, int height,
       const int ch = options->crop_height;
       const int x = options->crop_left & ~1;
       const int y = options->crop_top & ~1;
-      if (!WebPCheckCropDimensions(width, height, x, y, cw, ch)) {
+      if (x < 0 || y < 0 || cw <= 0 || ch <= 0 ||
+          x + cw > width || y + ch > height) {
         return VP8_STATUS_INVALID_PARAM;   // out of frame boundary.
       }
       width = cw;

src/dec/frame_dec.c

@@ -705,7 +705,7 @@ static int AllocateMemory(VP8Decoder* const dec) {
                         + cache_size + alpha_size + WEBP_ALIGN_CST;
   uint8_t* mem;
 
-  if (!CheckSizeOverflow(needed)) return 0;  // check for overflow
+  if (needed != (size_t)needed) return 0;  // check for overflow
   if (needed > dec->mem_size_) {
     WebPSafeFree(dec->mem_);
     dec->mem_size_ = 0;
@@ -732,7 +732,7 @@ static int AllocateMemory(VP8Decoder* const dec) {
   mem += f_info_size;
   dec->thread_ctx_.id_ = 0;
   dec->thread_ctx_.f_info_ = dec->f_info_;
-  if (dec->filter_type_ > 0 && dec->mt_method_ > 0) {
+  if (dec->mt_method_ > 0) {
     // secondary cache line. The deblocking process need to make use of the
     // filtering strength from previous macroblock row, while the new ones
     // are being decoded in parallel. We'll just swap the pointers.

src/dec/idec_dec.c

@@ -166,11 +166,9 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
   VP8Decoder* const dec = (VP8Decoder*)idec->dec_;
   MemBuffer* const mem = &idec->mem_;
   const int need_compressed_alpha = NeedCompressedAlpha(idec);
-  const uint8_t* const old_start =
-      (mem->buf_ == NULL) ? NULL : mem->buf_ + mem->start_;
+  const uint8_t* const old_start = mem->buf_ + mem->start_;
   const uint8_t* const old_base =
       need_compressed_alpha ? dec->alpha_data_ : old_start;
-  assert(mem->buf_ != NULL || mem->start_ == 0);
   assert(mem->mode_ == MEM_MODE_APPEND);
   if (data_size > MAX_CHUNK_PAYLOAD) {
     // security safeguard: trying to allocate more than what the format
@@ -186,7 +184,7 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
     uint8_t* const new_buf =
         (uint8_t*)WebPSafeMalloc(extra_size, sizeof(*new_buf));
     if (new_buf == NULL) return 0;
-    if (old_base != NULL) memcpy(new_buf, old_base, current_size);
+    memcpy(new_buf, old_base, current_size);
     WebPSafeFree(mem->buf_);
     mem->buf_ = new_buf;
     mem->buf_size_ = (size_t)extra_size;
@@ -194,7 +192,6 @@ static int AppendToMemBuffer(WebPIDecoder* const idec,
     mem->end_ = current_size;
   }
 
-  assert(mem->buf_ != NULL);
   memcpy(mem->buf_ + mem->end_, data, data_size);
   mem->end_ += data_size;
   assert(mem->end_ <= mem->buf_size_);
@@ -207,9 +204,7 @@ static int RemapMemBuffer(WebPIDecoder* const idec,
                           const uint8_t* const data, size_t data_size) {
   MemBuffer* const mem = &idec->mem_;
   const uint8_t* const old_buf = mem->buf_;
-  const uint8_t* const old_start =
-      (old_buf == NULL) ? NULL : old_buf + mem->start_;
-  assert(old_buf != NULL || mem->start_ == 0);
+  const uint8_t* const old_start = old_buf + mem->start_;
   assert(mem->mode_ == MEM_MODE_MAP);
 
   if (data_size < mem->buf_size_) return 0;  // can't remap to a shorter buffer!

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
@@ -298,57 +303,46 @@ static int InitYUVRescaler(const VP8Io* const io, WebPDecParams* const p) {
   const int uv_out_height = (out_height + 1) >> 1;
   const int uv_in_width  = (io->mb_w + 1) >> 1;
   const int uv_in_height = (io->mb_h + 1) >> 1;
-  // scratch memory for luma rescaler
-  const size_t work_size = 2 * (size_t)out_width;
+  const size_t work_size = 2 * out_width;   // scratch memory for luma rescaler
   const size_t uv_work_size = 2 * uv_out_width;  // and for each u/v ones
-  uint64_t total_size;
-  size_t rescaler_size;
+  size_t tmp_size, rescaler_size;
   rescaler_t* work;
   WebPRescaler* scalers;
   const int num_rescalers = has_alpha ? 4 : 3;
 
-  total_size = ((uint64_t)work_size + 2 * uv_work_size) * sizeof(*work);
+  tmp_size = (work_size + 2 * uv_work_size) * sizeof(*work);
   if (has_alpha) {
-    total_size += (uint64_t)work_size * sizeof(*work);
+    tmp_size += work_size * sizeof(*work);
   }
   rescaler_size = num_rescalers * sizeof(*p->scaler_y) + WEBP_ALIGN_CST;
-  total_size += rescaler_size;
-  if (!CheckSizeOverflow(total_size)) {
-    return 0;
-  }
 
-  p->memory = WebPSafeMalloc(1ULL, (size_t)total_size);
+  p->memory = WebPSafeMalloc(1ULL, tmp_size + rescaler_size);
   if (p->memory == NULL) {
     return 0;   // memory error
   }
   work = (rescaler_t*)p->memory;
 
-  scalers = (WebPRescaler*)WEBP_ALIGN(
-      (const uint8_t*)work + total_size - rescaler_size);
+  scalers = (WebPRescaler*)WEBP_ALIGN((const uint8_t*)work + tmp_size);
   p->scaler_y = &scalers[0];
   p->scaler_u = &scalers[1];
   p->scaler_v = &scalers[2];
   p->scaler_a = has_alpha ? &scalers[3] : NULL;
 
-  if (!WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
+  WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
                    buf->y, out_width, out_height, buf->y_stride, 1,
-                        work) ||
-      !WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
+                   work);
+  WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
                    buf->u, uv_out_width, uv_out_height, buf->u_stride, 1,
-                        work + work_size) ||
-      !WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
+                   work + work_size);
+  WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
                    buf->v, uv_out_width, uv_out_height, buf->v_stride, 1,
-                        work + work_size + uv_work_size)) {
-    return 0;
-  }
+                   work + work_size + uv_work_size);
   p->emit = EmitRescaledYUV;
 
   if (has_alpha) {
-    if (!WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
+    WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
                      buf->a, out_width, out_height, buf->a_stride, 1,
-                          work + work_size + 2 * uv_work_size)) {
-      return 0;
-    }
+                     work + work_size + 2 * uv_work_size);
     p->emit_alpha = EmitRescaledAlphaYUV;
     WebPInitAlphaProcessing();
   }
@@ -362,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.
@@ -389,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;
@@ -409,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);
@@ -437,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
@@ -476,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);
@@ -491,58 +485,51 @@ static int InitRGBRescaler(const VP8Io* const io, WebPDecParams* const p) {
   const int out_height = io->scaled_height;
   const int uv_in_width  = (io->mb_w + 1) >> 1;
   const int uv_in_height = (io->mb_h + 1) >> 1;
-  // scratch memory for one rescaler
-  const size_t work_size = 2 * (size_t)out_width;
+  const size_t work_size = 2 * out_width;   // scratch memory for one rescaler
   rescaler_t* work;  // rescalers work area
   uint8_t* tmp;   // tmp storage for scaled YUV444 samples before RGB conversion
-  uint64_t tmp_size1, tmp_size2, total_size;
-  size_t rescaler_size;
+  size_t tmp_size1, tmp_size2, total_size, rescaler_size;
   WebPRescaler* scalers;
   const int num_rescalers = has_alpha ? 4 : 3;
 
-  tmp_size1 = (uint64_t)num_rescalers * work_size;
-  tmp_size2 = (uint64_t)num_rescalers * out_width;
+  tmp_size1 = 3 * work_size;
+  tmp_size2 = 3 * out_width;
+  if (has_alpha) {
+    tmp_size1 += work_size;
+    tmp_size2 += out_width;
+  }
   total_size = tmp_size1 * sizeof(*work) + tmp_size2 * sizeof(*tmp);
   rescaler_size = num_rescalers * sizeof(*p->scaler_y) + WEBP_ALIGN_CST;
-  total_size += rescaler_size;
-  if (!CheckSizeOverflow(total_size)) {
-    return 0;
-  }
 
-  p->memory = WebPSafeMalloc(1ULL, (size_t)total_size);
+  p->memory = WebPSafeMalloc(1ULL, total_size + rescaler_size);
   if (p->memory == NULL) {
     return 0;   // memory error
   }
   work = (rescaler_t*)p->memory;
   tmp = (uint8_t*)(work + tmp_size1);
 
-  scalers = (WebPRescaler*)WEBP_ALIGN(
-      (const uint8_t*)work + total_size - rescaler_size);
+  scalers = (WebPRescaler*)WEBP_ALIGN((const uint8_t*)work + total_size);
   p->scaler_y = &scalers[0];
   p->scaler_u = &scalers[1];
   p->scaler_v = &scalers[2];
   p->scaler_a = has_alpha ? &scalers[3] : NULL;
 
-  if (!WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
+  WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
                    tmp + 0 * out_width, out_width, out_height, 0, 1,
-                        work + 0 * work_size) ||
-      !WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
+                   work + 0 * work_size);
+  WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
                    tmp + 1 * out_width, out_width, out_height, 0, 1,
-                        work + 1 * work_size) ||
-      !WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
+                   work + 1 * work_size);
+  WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
                    tmp + 2 * out_width, out_width, out_height, 0, 1,
-                        work + 2 * work_size)) {
-    return 0;
-  }
+                   work + 2 * work_size);
   p->emit = EmitRescaledRGB;
   WebPInitYUV444Converters();
 
   if (has_alpha) {
-    if (!WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
+    WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
                      tmp + 3 * out_width, out_width, out_height, 0, 1,
-                          work + 3 * work_size)) {
-      return 0;
-    }
+                     work + 3 * work_size);
     p->emit_alpha = EmitRescaledAlphaRGB;
     if (p->output->colorspace == MODE_RGBA_4444 ||
         p->output->colorspace == MODE_rgbA_4444) {

src/dec/quant_dec.c

@@ -61,17 +61,12 @@ static const uint16_t kAcTable[128] = {
 
 void VP8ParseQuant(VP8Decoder* const dec) {
   VP8BitReader* const br = &dec->br_;
-  const int base_q0 = VP8GetValue(br, 7, "global-header");
-  const int dqy1_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dqy2_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dqy2_ac = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dquv_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dquv_ac = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
+  const int base_q0 = VP8GetValue(br, 7);
+  const int dqy1_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dqy2_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dqy2_ac = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dquv_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dquv_ac = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
 
   const VP8SegmentHeader* const hdr = &dec->segment_hdr_;
   int i;

src/dec/tree_dec.c

@@ -296,21 +296,20 @@ static void ParseIntraMode(VP8BitReader* const br,
   // to decode more than 1 keyframe.
   if (dec->segment_hdr_.update_map_) {
     // Hardcoded tree parsing
-    block->segment_ = !VP8GetBit(br, dec->proba_.segments_[0], "segments")
-                    ?  VP8GetBit(br, dec->proba_.segments_[1], "segments")
-                    :  VP8GetBit(br, dec->proba_.segments_[2], "segments") + 2;
+    block->segment_ = !VP8GetBit(br, dec->proba_.segments_[0])
+                    ? VP8GetBit(br, dec->proba_.segments_[1])
+                    : 2 + VP8GetBit(br, dec->proba_.segments_[2]);
   } else {
     block->segment_ = 0;  // default for intra
   }
-  if (dec->use_skip_proba_) block->skip_ = VP8GetBit(br, dec->skip_p_, "skip");
+  if (dec->use_skip_proba_) block->skip_ = VP8GetBit(br, dec->skip_p_);
 
-  block->is_i4x4_ = !VP8GetBit(br, 145, "block-size");
+  block->is_i4x4_ = !VP8GetBit(br, 145);   // decide for B_PRED first
   if (!block->is_i4x4_) {
     // Hardcoded 16x16 intra-mode decision tree.
     const int ymode =
-        VP8GetBit(br, 156, "pred-modes") ?
-            (VP8GetBit(br, 128, "pred-modes") ? TM_PRED : H_PRED) :
-            (VP8GetBit(br, 163, "pred-modes") ? V_PRED : DC_PRED);
+        VP8GetBit(br, 156) ? (VP8GetBit(br, 128) ? TM_PRED : H_PRED)
+                           : (VP8GetBit(br, 163) ? V_PRED : DC_PRED);
     block->imodes_[0] = ymode;
     memset(top, ymode, 4 * sizeof(*top));
     memset(left, ymode, 4 * sizeof(*left));
@@ -324,25 +323,22 @@ static void ParseIntraMode(VP8BitReader* const br,
         const uint8_t* const prob = kBModesProba[top[x]][ymode];
 #if (USE_GENERIC_TREE == 1)
         // Generic tree-parsing
-        int i = kYModesIntra4[VP8GetBit(br, prob[0], "pred-modes")];
+        int i = kYModesIntra4[VP8GetBit(br, prob[0])];
         while (i > 0) {
-          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i], "pred-modes")];
+          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i])];
         }
         ymode = -i;
 #else
         // Hardcoded tree parsing
-        ymode = !VP8GetBit(br, prob[0], "pred-modes") ? B_DC_PRED :
-                  !VP8GetBit(br, prob[1], "pred-modes") ? B_TM_PRED :
-                    !VP8GetBit(br, prob[2], "pred-modes") ? B_VE_PRED :
-                      !VP8GetBit(br, prob[3], "pred-modes") ?
-                        (!VP8GetBit(br, prob[4], "pred-modes") ? B_HE_PRED :
-                          (!VP8GetBit(br, prob[5], "pred-modes") ? B_RD_PRED
-                                                                 : B_VR_PRED)) :
-                        (!VP8GetBit(br, prob[6], "pred-modes") ? B_LD_PRED :
-                          (!VP8GetBit(br, prob[7], "pred-modes") ? B_VL_PRED :
-                            (!VP8GetBit(br, prob[8], "pred-modes") ? B_HD_PRED
-                                                                   : B_HU_PRED))
-                        );
+        ymode = !VP8GetBit(br, prob[0]) ? B_DC_PRED :
+                  !VP8GetBit(br, prob[1]) ? B_TM_PRED :
+                    !VP8GetBit(br, prob[2]) ? B_VE_PRED :
+                      !VP8GetBit(br, prob[3]) ?
+                        (!VP8GetBit(br, prob[4]) ? B_HE_PRED :
+                          (!VP8GetBit(br, prob[5]) ? B_RD_PRED : B_VR_PRED)) :
+                        (!VP8GetBit(br, prob[6]) ? B_LD_PRED :
+                          (!VP8GetBit(br, prob[7]) ? B_VL_PRED :
+                            (!VP8GetBit(br, prob[8]) ? B_HD_PRED : B_HU_PRED)));
 #endif  // USE_GENERIC_TREE
         top[x] = ymode;
       }
@@ -352,9 +348,9 @@ static void ParseIntraMode(VP8BitReader* const br,
     }
   }
   // Hardcoded UVMode decision tree
-  block->uvmode_ = !VP8GetBit(br, 142, "pred-modes-uv") ? DC_PRED
-                 : !VP8GetBit(br, 114, "pred-modes-uv") ? V_PRED
-                 : VP8GetBit(br, 183, "pred-modes-uv") ? TM_PRED : H_PRED;
+  block->uvmode_ = !VP8GetBit(br, 142) ? DC_PRED
+                 : !VP8GetBit(br, 114) ? V_PRED
+                 : VP8GetBit(br, 183) ? TM_PRED : H_PRED;
 }
 
 int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
@@ -518,10 +514,8 @@ void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
     for (b = 0; b < NUM_BANDS; ++b) {
       for (c = 0; c < NUM_CTX; ++c) {
         for (p = 0; p < NUM_PROBAS; ++p) {
-          const int v =
-              VP8GetBit(br, CoeffsUpdateProba[t][b][c][p], "global-header") ?
-                        VP8GetValue(br, 8, "global-header") :
-                        CoeffsProba0[t][b][c][p];
+          const int v = VP8GetBit(br, CoeffsUpdateProba[t][b][c][p]) ?
+                        VP8GetValue(br, 8) : CoeffsProba0[t][b][c][p];
           proba->bands_[t][b].probas_[c][p] = v;
         }
       }
@@ -530,8 +524,9 @@ void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
       proba->bands_ptr_[t][b] = &proba->bands_[t][kBands[b]];
     }
   }
-  dec->use_skip_proba_ = VP8Get(br, "global-header");
+  dec->use_skip_proba_ = VP8Get(br);
   if (dec->use_skip_proba_) {
-    dec->skip_p_ = VP8GetValue(br, 8, "global-header");
+    dec->skip_p_ = VP8GetValue(br, 8);
   }
 }
+

src/dec/vp8_dec.c

@@ -161,26 +161,23 @@ static int ParseSegmentHeader(VP8BitReader* br,
                               VP8SegmentHeader* hdr, VP8Proba* proba) {
   assert(br != NULL);
   assert(hdr != NULL);
-  hdr->use_segment_ = VP8Get(br, "global-header");
+  hdr->use_segment_ = VP8Get(br);
   if (hdr->use_segment_) {
-    hdr->update_map_ = VP8Get(br, "global-header");
-    if (VP8Get(br, "global-header")) {   // update data
+    hdr->update_map_ = VP8Get(br);
+    if (VP8Get(br)) {   // update data
       int s;
-      hdr->absolute_delta_ = VP8Get(br, "global-header");
+      hdr->absolute_delta_ = VP8Get(br);
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->quantizer_[s] = VP8Get(br, "global-header") ?
-            VP8GetSignedValue(br, 7, "global-header") : 0;
+        hdr->quantizer_[s] = VP8Get(br) ? VP8GetSignedValue(br, 7) : 0;
       }
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->filter_strength_[s] = VP8Get(br, "global-header") ?
-            VP8GetSignedValue(br, 6, "global-header") : 0;
+        hdr->filter_strength_[s] = VP8Get(br) ? VP8GetSignedValue(br, 6) : 0;
       }
     }
     if (hdr->update_map_) {
       int s;
       for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
-        proba->segments_[s] = VP8Get(br, "global-header") ?
-            VP8GetValue(br, 8, "global-header") : 255u;
+        proba->segments_[s] = VP8Get(br) ? VP8GetValue(br, 8) : 255u;
       }
     }
   } else {
@@ -208,7 +205,7 @@ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
   size_t last_part;
   size_t p;
 
-  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2, "global-header")) - 1;
+  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2)) - 1;
   last_part = dec->num_parts_minus_one_;
   if (size < 3 * last_part) {
     // we can't even read the sizes with sz[]! That's a failure.
@@ -232,21 +229,21 @@ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
 // Paragraph 9.4
 static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
   VP8FilterHeader* const hdr = &dec->filter_hdr_;
-  hdr->simple_    = VP8Get(br, "global-header");
-  hdr->level_     = VP8GetValue(br, 6, "global-header");
-  hdr->sharpness_ = VP8GetValue(br, 3, "global-header");
-  hdr->use_lf_delta_ = VP8Get(br, "global-header");
+  hdr->simple_    = VP8Get(br);
+  hdr->level_     = VP8GetValue(br, 6);
+  hdr->sharpness_ = VP8GetValue(br, 3);
+  hdr->use_lf_delta_ = VP8Get(br);
   if (hdr->use_lf_delta_) {
-    if (VP8Get(br, "global-header")) {   // update lf-delta?
+    if (VP8Get(br)) {   // update lf-delta?
       int i;
       for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
-        if (VP8Get(br, "global-header")) {
-          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
+        if (VP8Get(br)) {
+          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6);
         }
       }
       for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
-        if (VP8Get(br, "global-header")) {
-          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
+        if (VP8Get(br)) {
+          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6);
         }
       }
     }
@@ -335,7 +332,7 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
     io->scaled_width = io->width;
     io->scaled_height = io->height;
 
-    io->mb_w = io->width;   // for soundness
+    io->mb_w = io->width;   // sanity check
     io->mb_h = io->height;  // ditto
 
     VP8ResetProba(&dec->proba_);
@@ -355,8 +352,8 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
   buf_size -= frm_hdr->partition_length_;
 
   if (frm_hdr->key_frame_) {
-    pic_hdr->colorspace_ = VP8Get(br, "global-header");
-    pic_hdr->clamp_type_ = VP8Get(br, "global-header");
+    pic_hdr->colorspace_ = VP8Get(br);
+    pic_hdr->clamp_type_ = VP8Get(br);
   }
   if (!ParseSegmentHeader(br, &dec->segment_hdr_, &dec->proba_)) {
     return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
@@ -381,7 +378,7 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
                        "Not a key frame.");
   }
 
-  VP8Get(br, "global-header");   // ignore the value of update_proba_
+  VP8Get(br);   // ignore the value of update_proba_
 
   VP8ParseProba(br, dec);
 
@@ -406,28 +403,28 @@ static const uint8_t kZigzag[16] = {
 // See section 13-2: http://tools.ietf.org/html/rfc6386#section-13.2
 static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
   int v;
-  if (!VP8GetBit(br, p[3], "coeffs")) {
-    if (!VP8GetBit(br, p[4], "coeffs")) {
+  if (!VP8GetBit(br, p[3])) {
+    if (!VP8GetBit(br, p[4])) {
       v = 2;
     } else {
-      v = 3 + VP8GetBit(br, p[5], "coeffs");
+      v = 3 + VP8GetBit(br, p[5]);
     }
   } else {
-    if (!VP8GetBit(br, p[6], "coeffs")) {
-      if (!VP8GetBit(br, p[7], "coeffs")) {
-        v = 5 + VP8GetBit(br, 159, "coeffs");
+    if (!VP8GetBit(br, p[6])) {
+      if (!VP8GetBit(br, p[7])) {
+        v = 5 + VP8GetBit(br, 159);
       } else {
-        v = 7 + 2 * VP8GetBit(br, 165, "coeffs");
-        v += VP8GetBit(br, 145, "coeffs");
+        v = 7 + 2 * VP8GetBit(br, 165);
+        v += VP8GetBit(br, 145);
       }
     } else {
       const uint8_t* tab;
-      const int bit1 = VP8GetBit(br, p[8], "coeffs");
-      const int bit0 = VP8GetBit(br, p[9 + bit1], "coeffs");
+      const int bit1 = VP8GetBit(br, p[8]);
+      const int bit0 = VP8GetBit(br, p[9 + bit1]);
       const int cat = 2 * bit1 + bit0;
       v = 0;
       for (tab = kCat3456[cat]; *tab; ++tab) {
-        v += v + VP8GetBit(br, *tab, "coeffs");
+        v += v + VP8GetBit(br, *tab);
       }
       v += 3 + (8 << cat);
     }
@@ -441,24 +438,24 @@ static int GetCoeffsFast(VP8BitReader* const br,
                          int ctx, const quant_t dq, int n, int16_t* out) {
   const uint8_t* p = prob[n]->probas_[ctx];
   for (; n < 16; ++n) {
-    if (!VP8GetBit(br, p[0], "coeffs")) {
+    if (!VP8GetBit(br, p[0])) {
       return n;  // previous coeff was last non-zero coeff
     }
-    while (!VP8GetBit(br, p[1], "coeffs")) {       // sequence of zero coeffs
+    while (!VP8GetBit(br, p[1])) {       // sequence of zero coeffs
       p = prob[++n]->probas_[0];
       if (n == 16) return 16;
     }
     {        // non zero coeff
       const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas_[0];
       int v;
-      if (!VP8GetBit(br, p[2], "coeffs")) {
+      if (!VP8GetBit(br, p[2])) {
         v = 1;
         p = p_ctx[1];
       } else {
         v = GetLargeValue(br, p);
         p = p_ctx[2];
       }
-      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
+      out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
     }
   }
   return 16;
@@ -471,35 +468,37 @@ static int GetCoeffsAlt(VP8BitReader* const br,
                         int ctx, const quant_t dq, int n, int16_t* out) {
   const uint8_t* p = prob[n]->probas_[ctx];
   for (; n < 16; ++n) {
-    if (!VP8GetBitAlt(br, p[0], "coeffs")) {
+    if (!VP8GetBitAlt(br, p[0])) {
       return n;  // previous coeff was last non-zero coeff
     }
-    while (!VP8GetBitAlt(br, p[1], "coeffs")) {       // sequence of zero coeffs
+    while (!VP8GetBitAlt(br, p[1])) {       // sequence of zero coeffs
       p = prob[++n]->probas_[0];
       if (n == 16) return 16;
     }
     {        // non zero coeff
       const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas_[0];
       int v;
-      if (!VP8GetBitAlt(br, p[2], "coeffs")) {
+      if (!VP8GetBitAlt(br, p[2])) {
         v = 1;
         p = p_ctx[1];
       } else {
         v = GetLargeValue(br, p);
         p = p_ctx[2];
       }
-      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
+      out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
     }
   }
   return 16;
 }
 
-WEBP_DSP_INIT_FUNC(InitGetCoeffs) {
+static WEBP_TSAN_IGNORE_FUNCTION void InitGetCoeffs(void) {
+  if (GetCoeffs == NULL) {
     if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
       GetCoeffs = GetCoeffsAlt;
     } else {
       GetCoeffs = GetCoeffsFast;
     }
+  }
 }
 
 static WEBP_INLINE uint32_t NzCodeBits(uint32_t nz_coeffs, int nz, int dc_nz) {

src/dec/vp8i_dec.h

@@ -31,8 +31,8 @@ extern "C" {
 
 // version numbers
 #define DEC_MAJ_VERSION 1
-#define DEC_MIN_VERSION 2
-#define DEC_REV_VERSION 1
+#define DEC_MIN_VERSION 0
+#define DEC_REV_VERSION 2
 
 // YUV-cache parameters. Cache is 32-bytes wide (= one cacheline).
 // Constraints are: We need to store one 16x16 block of luma samples (y),

src/dec/vp8l_dec.c

@@ -362,8 +362,12 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
   VP8LMetadata* const hdr = &dec->hdr_;
   uint32_t* huffman_image = NULL;
   HTreeGroup* htree_groups = NULL;
+  // When reading htrees, some might be unused, as the format allows it.
+  // We will still read them but put them in this htree_group_bogus.
+  HTreeGroup htree_group_bogus;
   HuffmanCode* huffman_tables = NULL;
-  HuffmanCode* huffman_table = NULL;
+  HuffmanCode* huffman_tables_bogus = NULL;
+  HuffmanCode* next = NULL;
   int num_htree_groups = 1;
   int num_htree_groups_max = 1;
   int max_alphabet_size = 0;
@@ -414,6 +418,12 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
         if (*mapped_group == -1) *mapped_group = num_htree_groups++;
         huffman_image[i] = *mapped_group;
       }
+      huffman_tables_bogus = (HuffmanCode*)WebPSafeMalloc(
+          table_size, sizeof(*huffman_tables_bogus));
+      if (huffman_tables_bogus == NULL) {
+        dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
+        goto Error;
+      }
     } else {
       num_htree_groups = num_htree_groups_max;
     }
@@ -443,44 +453,36 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
     goto Error;
   }
 
-  huffman_table = huffman_tables;
+  next = huffman_tables;
   for (i = 0; i < num_htree_groups_max; ++i) {
-    // If the index "i" is unused in the Huffman image, just make sure the
-    // coefficients are valid but do not store them.
-    if (mapping != NULL && mapping[i] == -1) {
-      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
-        int alphabet_size = kAlphabetSize[j];
-        if (j == 0 && color_cache_bits > 0) {
-          alphabet_size += (1 << color_cache_bits);
-        }
-        // Passing in NULL so that nothing gets filled.
-        if (!ReadHuffmanCode(alphabet_size, dec, code_lengths, NULL)) {
-          goto Error;
-        }
-      }
-    } else {
+    // If the index "i" is unused in the Huffman image, read the coefficients
+    // but store them to a bogus htree_group.
+    const int is_bogus = (mapping != NULL && mapping[i] == -1);
     HTreeGroup* const htree_group =
+        is_bogus ? &htree_group_bogus :
         &htree_groups[(mapping == NULL) ? i : mapping[i]];
     HuffmanCode** const htrees = htree_group->htrees;
+    HuffmanCode* huffman_tables_i = is_bogus ? huffman_tables_bogus : next;
     int size;
     int total_size = 0;
     int is_trivial_literal = 1;
     int max_bits = 0;
     for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
       int alphabet_size = kAlphabetSize[j];
-        htrees[j] = huffman_table;
+      htrees[j] = huffman_tables_i;
       if (j == 0 && color_cache_bits > 0) {
-          alphabet_size += (1 << color_cache_bits);
+        alphabet_size += 1 << color_cache_bits;
       }
-        size = ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_table);
+      size =
+          ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables_i);
       if (size == 0) {
         goto Error;
       }
       if (is_trivial_literal && kLiteralMap[j] == 1) {
-          is_trivial_literal = (huffman_table->bits == 0);
+        is_trivial_literal = (huffman_tables_i->bits == 0);
       }
-        total_size += huffman_table->bits;
-        huffman_table += size;
+      total_size += huffman_tables_i->bits;
+      huffman_tables_i += size;
       if (j <= ALPHA) {
         int local_max_bits = code_lengths[0];
         int k;
@@ -492,6 +494,7 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
         max_bits += local_max_bits;
       }
     }
+    if (!is_bogus) next = huffman_tables_i;
     htree_group->is_trivial_literal = is_trivial_literal;
     htree_group->is_trivial_code = 0;
     if (is_trivial_literal) {
@@ -508,7 +511,6 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
         !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS);
     if (htree_group->use_packed_table) BuildPackedTable(htree_group);
   }
-  }
   ok = 1;
 
   // All OK. Finalize pointers.
@@ -519,6 +521,7 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
 
  Error:
   WebPSafeFree(code_lengths);
+  WebPSafeFree(huffman_tables_bogus);
   WebPSafeFree(mapping);
   if (!ok) {
     WebPSafeFree(huffman_image);
@@ -559,11 +562,8 @@ static int AllocateAndInitRescaler(VP8LDecoder* const dec, VP8Io* const io) {
   memory += work_size * sizeof(*work);
   scaled_data = (uint32_t*)memory;
 
-  if (!WebPRescalerInit(dec->rescaler, in_width, in_height,
-                        (uint8_t*)scaled_data, out_width, out_height,
-                        0, num_channels, work)) {
-    return 0;
-  }
+  WebPRescalerInit(dec->rescaler, in_width, in_height, (uint8_t*)scaled_data,
+                   out_width, out_height, 0, num_channels, work);
   return 1;
 }
 #endif   // WEBP_REDUCE_SIZE
@@ -577,14 +577,13 @@ static int AllocateAndInitRescaler(VP8LDecoder* const dec, VP8Io* const io) {
 static int Export(WebPRescaler* const rescaler, WEBP_CSP_MODE colorspace,
                   int rgba_stride, uint8_t* const rgba) {
   uint32_t* const src = (uint32_t*)rescaler->dst;
-  uint8_t* dst = rgba;
   const int dst_width = rescaler->dst_width;
   int num_lines_out = 0;
   while (WebPRescalerHasPendingOutput(rescaler)) {
+    uint8_t* const dst = rgba + num_lines_out * rgba_stride;
     WebPRescalerExportRow(rescaler);
     WebPMultARGBRow(src, dst_width, 1);
     VP8LConvertFromBGRA(src, dst_width, colorspace, dst);
-    dst += rgba_stride;
     ++num_lines_out;
   }
   return num_lines_out;
@@ -598,8 +597,8 @@ static int EmitRescaledRowsRGBA(const VP8LDecoder* const dec,
   int num_lines_in = 0;
   int num_lines_out = 0;
   while (num_lines_in < mb_h) {
-    uint8_t* const row_in = in + (uint64_t)num_lines_in * in_stride;
-    uint8_t* const row_out = out + (uint64_t)num_lines_out * out_stride;
+    uint8_t* const row_in = in + num_lines_in * in_stride;
+    uint8_t* const row_out = out + num_lines_out * out_stride;
     const int lines_left = mb_h - num_lines_in;
     const int needed_lines = WebPRescaleNeededLines(dec->rescaler, lines_left);
     int lines_imported;
@@ -758,11 +757,11 @@ static WEBP_INLINE HTreeGroup* GetHtreeGroupForPos(VP8LMetadata* const hdr,
 
 typedef void (*ProcessRowsFunc)(VP8LDecoder* const dec, int row);
 
-static void ApplyInverseTransforms(VP8LDecoder* const dec,
-                                   int start_row, int num_rows,
+static void ApplyInverseTransforms(VP8LDecoder* const dec, int num_rows,
                                    const uint32_t* const rows) {
   int n = dec->next_transform_;
   const int cache_pixs = dec->width_ * num_rows;
+  const int start_row = dec->last_row_;
   const int end_row = start_row + num_rows;
   const uint32_t* rows_in = rows;
   uint32_t* const rows_out = dec->argb_cache_;
@@ -793,15 +792,15 @@ static void ProcessRows(VP8LDecoder* const dec, int row) {
     VP8Io* const io = dec->io_;
     uint8_t* rows_data = (uint8_t*)dec->argb_cache_;
     const int in_stride = io->width * sizeof(uint32_t);  // in unit of RGBA
-    ApplyInverseTransforms(dec, dec->last_row_, num_rows, rows);
+
+    ApplyInverseTransforms(dec, num_rows, rows);
     if (!SetCropWindow(io, dec->last_row_, row, &rows_data, in_stride)) {
       // Nothing to output (this time).
     } else {
       const WebPDecBuffer* const output = dec->output_;
       if (WebPIsRGBMode(output->colorspace)) {  // convert to RGBA
         const WebPRGBABuffer* const buf = &output->u.RGBA;
-        uint8_t* const rgba =
-            buf->rgba + (int64_t)dec->last_out_row_ * buf->stride;
+        uint8_t* const rgba = buf->rgba + dec->last_out_row_ * buf->stride;
         const int num_rows_out =
 #if !defined(WEBP_REDUCE_SIZE)
          io->use_scaling ?
@@ -952,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;
@@ -1196,7 +1196,6 @@ static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data,
       VP8LFillBitWindow(br);
       dist_code = GetCopyDistance(dist_symbol, br);
       dist = PlaneCodeToDistance(width, dist_code);
-
       if (VP8LIsEndOfStream(br)) break;
       if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) {
         goto Error;
@@ -1519,7 +1518,7 @@ static int AllocateInternalBuffers32b(VP8LDecoder* const dec, int final_width) {
   assert(dec->width_ <= final_width);
   dec->pixels_ = (uint32_t*)WebPSafeMalloc(total_num_pixels, sizeof(uint32_t));
   if (dec->pixels_ == NULL) {
-    dec->argb_cache_ = NULL;    // for soundness
+    dec->argb_cache_ = NULL;    // for sanity check
     dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
     return 0;
   }
@@ -1529,7 +1528,7 @@ static int AllocateInternalBuffers32b(VP8LDecoder* const dec, int final_width) {
 
 static int AllocateInternalBuffers8b(VP8LDecoder* const dec) {
   const uint64_t total_num_pixels = (uint64_t)dec->width_ * dec->height_;
-  dec->argb_cache_ = NULL;    // for soundness
+  dec->argb_cache_ = NULL;    // for sanity check
   dec->pixels_ = (uint32_t*)WebPSafeMalloc(total_num_pixels, sizeof(uint8_t));
   if (dec->pixels_ == NULL) {
     dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
@@ -1557,7 +1556,7 @@ static void ExtractAlphaRows(VP8LDecoder* const dec, int last_row) {
     const int cache_pixs = width * num_rows_to_process;
     uint8_t* const dst = output + width * cur_row;
     const uint32_t* const src = dec->argb_cache_;
-    ApplyInverseTransforms(dec, cur_row, num_rows_to_process, in);
+    ApplyInverseTransforms(dec, num_rows_to_process, in);
     WebPExtractGreen(src, dst, cache_pixs);
     AlphaApplyFilter(alph_dec,
                      cur_row, cur_row + num_rows_to_process, dst, width);
@@ -1671,6 +1670,7 @@ int VP8LDecodeImage(VP8LDecoder* const dec) {
   VP8Io* io = NULL;
   WebPDecParams* params = NULL;
 
+  // Sanity checks.
   if (dec == NULL) return 0;
 
   assert(dec->hdr_.huffman_tables_ != NULL);

src/dec/vp8li_dec.h

@@ -37,7 +37,7 @@ struct VP8LTransform {
   int                    bits_;   // subsampling bits defining transform window.
   int                    xsize_;  // transform window X index.
   int                    ysize_;  // transform window Y index.
-  uint32_t*              data_;   // transform data.
+  uint32_t              *data_;   // transform data.
 };
 
 typedef struct {
@@ -48,23 +48,23 @@ typedef struct {
   int             huffman_mask_;
   int             huffman_subsample_bits_;
   int             huffman_xsize_;
-  uint32_t*       huffman_image_;
+  uint32_t       *huffman_image_;
   int             num_htree_groups_;
-  HTreeGroup*     htree_groups_;
-  HuffmanCode*    huffman_tables_;
+  HTreeGroup     *htree_groups_;
+  HuffmanCode    *huffman_tables_;
 } VP8LMetadata;
 
 typedef struct VP8LDecoder VP8LDecoder;
 struct VP8LDecoder {
   VP8StatusCode    status_;
   VP8LDecodeState  state_;
-  VP8Io*           io_;
+  VP8Io           *io_;
 
-  const WebPDecBuffer* output_;    // shortcut to io->opaque->output
+  const WebPDecBuffer *output_;    // shortcut to io->opaque->output
 
-  uint32_t*        pixels_;        // Internal data: either uint8_t* for alpha
+  uint32_t        *pixels_;        // Internal data: either uint8_t* for alpha
                                    // or uint32_t* for BGRA.
-  uint32_t*        argb_cache_;    // Scratch buffer for temporary BGRA storage.
+  uint32_t        *argb_cache_;    // Scratch buffer for temporary BGRA storage.
 
   VP8LBitReader    br_;
   int              incremental_;   // if true, incremental decoding is expected
@@ -86,8 +86,8 @@ struct VP8LDecoder {
   // or'd bitset storing the transforms types.
   uint32_t         transforms_seen_;
 
-  uint8_t*         rescaler_memory;  // Working memory for rescaling work.
-  WebPRescaler*    rescaler;         // Common rescaler for all channels.
+  uint8_t         *rescaler_memory;  // Working memory for rescaling work.
+  WebPRescaler    *rescaler;         // Common rescaler for all channels.
 };
 
 //------------------------------------------------------------------------------

src/dec/webp_dec.c

@@ -785,13 +785,6 @@ VP8StatusCode WebPDecode(const uint8_t* data, size_t data_size,
 //------------------------------------------------------------------------------
 // Cropping and rescaling.
 
-int WebPCheckCropDimensions(int image_width, int image_height,
-                            int x, int y, int w, int h) {
-  return !(x < 0 || y < 0 || w <= 0 || h <= 0 ||
-           x >= image_width || w > image_width || w > image_width - x ||
-           y >= image_height || h > image_height || h > image_height - y);
-}
-
 int WebPIoInitFromOptions(const WebPDecoderOptions* const options,
                           VP8Io* const io, WEBP_CSP_MODE src_colorspace) {
   const int W = io->width;
@@ -799,7 +792,7 @@ int WebPIoInitFromOptions(const WebPDecoderOptions* const options,
   int x = 0, y = 0, w = W, h = H;
 
   // Cropping
-  io->use_cropping = (options != NULL) && options->use_cropping;
+  io->use_cropping = (options != NULL) && (options->use_cropping > 0);
   if (io->use_cropping) {
     w = options->crop_width;
     h = options->crop_height;
@@ -809,7 +802,7 @@ int WebPIoInitFromOptions(const WebPDecoderOptions* const options,
       x &= ~1;
       y &= ~1;
     }
-    if (!WebPCheckCropDimensions(W, H, x, y, w, h)) {
+    if (x < 0 || y < 0 || w <= 0 || h <= 0 || x + w > W || y + h > H) {
       return 0;  // out of frame boundary error
     }
   }
@@ -821,7 +814,7 @@ int WebPIoInitFromOptions(const WebPDecoderOptions* const options,
   io->mb_h = h;
 
   // Scaling
-  io->use_scaling = (options != NULL) && options->use_scaling;
+  io->use_scaling = (options != NULL) && (options->use_scaling > 0);
   if (io->use_scaling) {
     int scaled_width = options->scaled_width;
     int scaled_height = options->scaled_height;
@@ -842,7 +835,7 @@ int WebPIoInitFromOptions(const WebPDecoderOptions* const options,
 
   if (io->use_scaling) {
     // disable filter (only for large downscaling ratio).
-    io->bypass_filtering |= (io->scaled_width < W * 3 / 4) &&
+    io->bypass_filtering = (io->scaled_width < W * 3 / 4) &&
                            (io->scaled_height < H * 3 / 4);
     io->fancy_upsampling = 0;
   }

src/dec/webpi_dec.h

@@ -77,10 +77,6 @@ VP8StatusCode WebPParseHeaders(WebPHeaderStructure* const headers);
 //------------------------------------------------------------------------------
 // Misc utils
 
-// Returns true if crop dimensions are within image bounds.
-int WebPCheckCropDimensions(int image_width, int image_height,
-                            int x, int y, int w, int h);
-
 // Initializes VP8Io with custom setup, io and teardown functions. The default
 // hooks will use the supplied 'params' as io->opaque handle.
 void WebPInitCustomIo(WebPDecParams* const params, VP8Io* const io);

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:8:0
+libwebpdemux_la_LDFLAGS = -no-undefined -version-info 2:6:0
 libwebpdemuxincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebpdemux.pc

src/demux/anim_decode.c

@@ -87,19 +87,11 @@ WebPAnimDecoder* WebPAnimDecoderNewInternal(
     int abi_version) {
   WebPAnimDecoderOptions options;
   WebPAnimDecoder* dec = NULL;
-  WebPBitstreamFeatures features;
   if (webp_data == NULL ||
       WEBP_ABI_IS_INCOMPATIBLE(abi_version, WEBP_DEMUX_ABI_VERSION)) {
     return NULL;
   }
 
-  // Validate the bitstream before doing expensive allocations. The demuxer may
-  // be more tolerant than the decoder.
-  if (WebPGetFeatures(webp_data->bytes, webp_data->size, &features) !=
-      VP8_STATUS_OK) {
-    return NULL;
-  }
-
   // Note: calloc() so that the pointer members are initialized to NULL.
   dec = (WebPAnimDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
   if (dec == NULL) goto Error;
@@ -153,7 +145,7 @@ static int ZeroFillCanvas(uint8_t* buf, uint32_t canvas_width,
                           uint32_t canvas_height) {
   const uint64_t size =
       (uint64_t)canvas_width * canvas_height * NUM_CHANNELS * sizeof(*buf);
-  if (!CheckSizeOverflow(size)) return 0;
+  if (size != (size_t)size) return 0;
   memset(buf, 0, (size_t)size);
   return 1;
 }
@@ -174,7 +166,7 @@ static void ZeroFillFrameRect(uint8_t* buf, int buf_stride, int x_offset,
 static int CopyCanvas(const uint8_t* src, uint8_t* dst,
                       uint32_t width, uint32_t height) {
   const uint64_t size = (uint64_t)width * height * NUM_CHANNELS;
-  if (!CheckSizeOverflow(size)) return 0;
+  if (size != (size_t)size) return 0;
   assert(src != NULL && dst != NULL);
   memcpy(dst, src, (size_t)size);
   return 1;
@@ -354,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) {

src/demux/demux.c

@@ -24,8 +24,8 @@
 #include "src/webp/format_constants.h"
 
 #define DMUX_MAJ_VERSION 1
-#define DMUX_MIN_VERSION 2
-#define DMUX_REV_VERSION 1
+#define DMUX_MIN_VERSION 0
+#define DMUX_REV_VERSION 2
 
 typedef struct {
   size_t start_;        // start location of the data
@@ -221,16 +221,12 @@ static ParseStatus StoreFrame(int frame_num, uint32_t min_size,
     const size_t chunk_start_offset = mem->start_;
     const uint32_t fourcc = ReadLE32(mem);
     const uint32_t payload_size = ReadLE32(mem);
-    uint32_t payload_size_padded;
-    size_t payload_available;
-    size_t chunk_size;
+    const uint32_t payload_size_padded = payload_size + (payload_size & 1);
+    const size_t payload_available = (payload_size_padded > MemDataSize(mem))
+                                   ? MemDataSize(mem) : payload_size_padded;
+    const size_t chunk_size = CHUNK_HEADER_SIZE + payload_available;
 
     if (payload_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
-
-    payload_size_padded = payload_size + (payload_size & 1);
-    payload_available = (payload_size_padded > MemDataSize(mem))
-                      ? MemDataSize(mem) : payload_size_padded;
-    chunk_size = CHUNK_HEADER_SIZE + payload_available;
     if (SizeIsInvalid(mem, payload_size_padded)) return PARSE_ERROR;
     if (payload_size_padded > MemDataSize(mem)) status = PARSE_NEED_MORE_DATA;
 
@@ -316,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;
@@ -337,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) {
@@ -455,11 +446,9 @@ static ParseStatus ParseVP8XChunks(WebPDemuxer* const dmux) {
     const size_t chunk_start_offset = mem->start_;
     const uint32_t fourcc = ReadLE32(mem);
     const uint32_t chunk_size = ReadLE32(mem);
-    uint32_t chunk_size_padded;
+    const uint32_t chunk_size_padded = chunk_size + (chunk_size & 1);
 
     if (chunk_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
-
-    chunk_size_padded = chunk_size + (chunk_size & 1);
     if (SizeIsInvalid(mem, chunk_size_padded)) return PARSE_ERROR;
 
     switch (fourcc) {

src/demux/libwebpdemux.rc

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

src/dsp/Makefile.am

@@ -46,7 +46,6 @@ ENC_SOURCES += ssim.c
 libwebpdspdecode_sse41_la_SOURCES =
 libwebpdspdecode_sse41_la_SOURCES += alpha_processing_sse41.c
 libwebpdspdecode_sse41_la_SOURCES += dec_sse41.c
-libwebpdspdecode_sse41_la_SOURCES += lossless_sse41.c
 libwebpdspdecode_sse41_la_SOURCES += upsampling_sse41.c
 libwebpdspdecode_sse41_la_SOURCES += yuv_sse41.c
 libwebpdspdecode_sse41_la_CPPFLAGS = $(libwebpdsp_la_CPPFLAGS)

src/dsp/alpha_processing.c

@@ -157,8 +157,7 @@ void WebPMultARGBRow_C(uint32_t* const ptr, int width, int inverse) {
   }
 }
 
-void WebPMultRow_C(uint8_t* WEBP_RESTRICT const ptr,
-                   const uint8_t* WEBP_RESTRICT const alpha,
+void WebPMultRow_C(uint8_t* const ptr, const uint8_t* const alpha,
                    int width, int inverse) {
   int x;
   for (x = 0; x < width; ++x) {
@@ -179,8 +178,7 @@ void WebPMultRow_C(uint8_t* WEBP_RESTRICT const ptr,
 #undef MFIX
 
 void (*WebPMultARGBRow)(uint32_t* const ptr, int width, int inverse);
-void (*WebPMultRow)(uint8_t* WEBP_RESTRICT const ptr,
-                    const uint8_t* WEBP_RESTRICT const alpha,
+void (*WebPMultRow)(uint8_t* const ptr, const uint8_t* const alpha,
                     int width, int inverse);
 
 //------------------------------------------------------------------------------
@@ -195,8 +193,8 @@ void WebPMultARGBRows(uint8_t* ptr, int stride, int width, int num_rows,
   }
 }
 
-void WebPMultRows(uint8_t* WEBP_RESTRICT ptr, int stride,
-                  const uint8_t* WEBP_RESTRICT alpha, int alpha_stride,
+void WebPMultRows(uint8_t* ptr, int stride,
+                  const uint8_t* alpha, int alpha_stride,
                   int width, int num_rows, int inverse) {
   int n;
   for (n = 0; n < num_rows; ++n) {
@@ -292,9 +290,9 @@ static void ApplyAlphaMultiply_16b_C(uint8_t* rgba4444,
 }
 
 #if !WEBP_NEON_OMIT_C_CODE
-static int DispatchAlpha_C(const uint8_t* WEBP_RESTRICT alpha, int alpha_stride,
+static int DispatchAlpha_C(const uint8_t* alpha, int alpha_stride,
                            int width, int height,
-                           uint8_t* WEBP_RESTRICT dst, int dst_stride) {
+                           uint8_t* dst, int dst_stride) {
   uint32_t alpha_mask = 0xff;
   int i, j;
 
@@ -311,10 +309,9 @@ static int DispatchAlpha_C(const uint8_t* WEBP_RESTRICT alpha, int alpha_stride,
   return (alpha_mask != 0xff);
 }
 
-static void DispatchAlphaToGreen_C(const uint8_t* WEBP_RESTRICT alpha,
-                                   int alpha_stride, int width, int height,
-                                   uint32_t* WEBP_RESTRICT dst,
-                                   int dst_stride) {
+static void DispatchAlphaToGreen_C(const uint8_t* alpha, int alpha_stride,
+                                   int width, int height,
+                                   uint32_t* dst, int dst_stride) {
   int i, j;
   for (j = 0; j < height; ++j) {
     for (i = 0; i < width; ++i) {
@@ -325,9 +322,9 @@ static void DispatchAlphaToGreen_C(const uint8_t* WEBP_RESTRICT alpha,
   }
 }
 
-static int ExtractAlpha_C(const uint8_t* WEBP_RESTRICT argb, int argb_stride,
+static int ExtractAlpha_C(const uint8_t* argb, int argb_stride,
                           int width, int height,
-                          uint8_t* WEBP_RESTRICT alpha, int alpha_stride) {
+                          uint8_t* alpha, int alpha_stride) {
   uint8_t alpha_mask = 0xff;
   int i, j;
 
@@ -343,8 +340,7 @@ static int ExtractAlpha_C(const uint8_t* WEBP_RESTRICT argb, int argb_stride,
   return (alpha_mask == 0xff);
 }
 
-static void ExtractGreen_C(const uint32_t* WEBP_RESTRICT argb,
-                           uint8_t* WEBP_RESTRICT alpha, int size) {
+static void ExtractGreen_C(const uint32_t* argb, uint8_t* alpha, int size) {
   int i;
   for (i = 0; i < size; ++i) alpha[i] = argb[i] >> 8;
 }
@@ -363,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.
 
@@ -376,11 +367,8 @@ static WEBP_INLINE uint32_t MakeARGB32(int a, int r, int g, int b) {
 }
 
 #ifdef WORDS_BIGENDIAN
-static void PackARGB_C(const uint8_t* WEBP_RESTRICT a,
-                       const uint8_t* WEBP_RESTRICT r,
-                       const uint8_t* WEBP_RESTRICT g,
-                       const uint8_t* WEBP_RESTRICT b,
-                       int len, uint32_t* WEBP_RESTRICT out) {
+static void PackARGB_C(const uint8_t* a, const uint8_t* r, const uint8_t* g,
+                       const uint8_t* b, int len, uint32_t* out) {
   int i;
   for (i = 0; i < len; ++i) {
     out[i] = MakeARGB32(a[4 * i], r[4 * i], g[4 * i], b[4 * i]);
@@ -388,10 +376,8 @@ static void PackARGB_C(const uint8_t* WEBP_RESTRICT a,
 }
 #endif
 
-static void PackRGB_C(const uint8_t* WEBP_RESTRICT r,
-                      const uint8_t* WEBP_RESTRICT g,
-                      const uint8_t* WEBP_RESTRICT b,
-                      int len, int step, uint32_t* WEBP_RESTRICT out) {
+static void PackRGB_C(const uint8_t* r, const uint8_t* g, const uint8_t* b,
+                      int len, int step, uint32_t* out) {
   int i, offset = 0;
   for (i = 0; i < len; ++i) {
     out[i] = MakeARGB32(0xff, r[offset], g[offset], b[offset]);
@@ -401,26 +387,19 @@ static void PackRGB_C(const uint8_t* WEBP_RESTRICT r,
 
 void (*WebPApplyAlphaMultiply)(uint8_t*, int, int, int, int);
 void (*WebPApplyAlphaMultiply4444)(uint8_t*, int, int, int);
-int (*WebPDispatchAlpha)(const uint8_t* WEBP_RESTRICT, int, int, int,
-                         uint8_t* WEBP_RESTRICT, int);
-void (*WebPDispatchAlphaToGreen)(const uint8_t* WEBP_RESTRICT, int, int, int,
-                                 uint32_t* WEBP_RESTRICT, int);
-int (*WebPExtractAlpha)(const uint8_t* WEBP_RESTRICT, int, int, int,
-                        uint8_t* WEBP_RESTRICT, int);
-void (*WebPExtractGreen)(const uint32_t* WEBP_RESTRICT argb,
-                         uint8_t* WEBP_RESTRICT alpha, int size);
+int (*WebPDispatchAlpha)(const uint8_t*, int, int, int, uint8_t*, int);
+void (*WebPDispatchAlphaToGreen)(const uint8_t*, int, int, int, uint32_t*, int);
+int (*WebPExtractAlpha)(const uint8_t*, int, int, int, uint8_t*, int);
+void (*WebPExtractGreen)(const uint32_t* argb, uint8_t* alpha, int size);
 #ifdef WORDS_BIGENDIAN
 void (*WebPPackARGB)(const uint8_t* a, const uint8_t* r, const uint8_t* g,
                      const uint8_t* b, int, uint32_t*);
 #endif
-void (*WebPPackRGB)(const uint8_t* WEBP_RESTRICT r,
-                    const uint8_t* WEBP_RESTRICT g,
-                    const uint8_t* WEBP_RESTRICT b,
-                    int len, int step, uint32_t* WEBP_RESTRICT out);
+void (*WebPPackRGB)(const uint8_t* r, const uint8_t* g, const uint8_t* b,
+                    int len, int step, uint32_t* out);
 
 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
@@ -449,14 +428,13 @@ 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) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       WebPInitAlphaProcessingSSE2();
-#if defined(WEBP_HAVE_SSE41)
+#if defined(WEBP_USE_SSE41)
       if (VP8GetCPUInfo(kSSE4_1)) {
         WebPInitAlphaProcessingSSE41();
       }
@@ -470,7 +448,7 @@ WEBP_DSP_INIT_FUNC(WebPInitAlphaProcessing) {
 #endif
   }
 
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
   if (WEBP_NEON_OMIT_C_CODE ||
       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
     WebPInitAlphaProcessingNEON();
@@ -491,5 +469,4 @@ WEBP_DSP_INIT_FUNC(WebPInitAlphaProcessing) {
   assert(WebPPackRGB != NULL);
   assert(WebPHasAlpha8b != NULL);
   assert(WebPHasAlpha32b != NULL);
-  assert(WebPAlphaReplace != NULL);
 }

src/dsp/alpha_processing_neon.c

@@ -80,10 +80,10 @@ static void ApplyAlphaMultiply_NEON(uint8_t* rgba, int alpha_first,
 
 //------------------------------------------------------------------------------
 
-static int DispatchAlpha_NEON(const uint8_t* WEBP_RESTRICT alpha,
-                              int alpha_stride, int width, int height,
-                              uint8_t* WEBP_RESTRICT dst, int dst_stride) {
-  uint32_t alpha_mask = 0xffffffffu;
+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 = 0xffu;
   uint8x8_t mask8 = vdup_n_u8(0xff);
   uint32_t tmp[2];
   int i, j;
@@ -107,15 +107,15 @@ static int DispatchAlpha_NEON(const uint8_t* WEBP_RESTRICT alpha,
     dst += dst_stride;
   }
   vst1_u8((uint8_t*)tmp, mask8);
+  alpha_mask *= 0x01010101;
   alpha_mask &= tmp[0];
   alpha_mask &= tmp[1];
   return (alpha_mask != 0xffffffffu);
 }
 
-static void DispatchAlphaToGreen_NEON(const uint8_t* WEBP_RESTRICT alpha,
-                                      int alpha_stride, int width, int height,
-                                      uint32_t* WEBP_RESTRICT dst,
-                                      int dst_stride) {
+static void DispatchAlphaToGreen_NEON(const uint8_t* alpha, int alpha_stride,
+                                      int width, int height,
+                                      uint32_t* dst, int dst_stride) {
   int i, j;
   uint8x8x4_t greens;   // leave A/R/B channels zero'd.
   greens.val[0] = vdup_n_u8(0);
@@ -132,10 +132,10 @@ static void DispatchAlphaToGreen_NEON(const uint8_t* WEBP_RESTRICT alpha,
   }
 }
 
-static int ExtractAlpha_NEON(const uint8_t* WEBP_RESTRICT argb, int argb_stride,
+static int ExtractAlpha_NEON(const uint8_t* argb, int argb_stride,
                              int width, int height,
-                             uint8_t* WEBP_RESTRICT alpha, int alpha_stride) {
-  uint32_t alpha_mask = 0xffffffffu;
+                             uint8_t* alpha, int alpha_stride) {
+  uint32_t alpha_mask = 0xffu;
   uint8x8_t mask8 = vdup_n_u8(0xff);
   uint32_t tmp[2];
   int i, j;
@@ -157,13 +157,14 @@ static int ExtractAlpha_NEON(const uint8_t* WEBP_RESTRICT 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);
 }
 
-static void ExtractGreen_NEON(const uint32_t* WEBP_RESTRICT argb,
-                              uint8_t* WEBP_RESTRICT alpha, int size) {
+static void ExtractGreen_NEON(const uint32_t* argb,
+                              uint8_t* alpha, int size) {
   int i;
   for (i = 0; i + 16 <= size; i += 16) {
     const uint8x16x4_t rgbX = vld4q_u8((const uint8_t*)(argb + i));

src/dsp/alpha_processing_sse2.c

@@ -18,9 +18,9 @@
 
 //------------------------------------------------------------------------------
 
-static int DispatchAlpha_SSE2(const uint8_t* WEBP_RESTRICT alpha,
-                              int alpha_stride, int width, int height,
-                              uint8_t* WEBP_RESTRICT dst, int dst_stride) {
+static int DispatchAlpha_SSE2(const uint8_t* alpha, int alpha_stride,
+                              int width, int height,
+                              uint8_t* dst, int dst_stride) {
   // alpha_and stores an 'and' operation of all the alpha[] values. The final
   // value is not 0xff if any of the alpha[] is not equal to 0xff.
   uint32_t alpha_and = 0xff;
@@ -72,10 +72,9 @@ static int DispatchAlpha_SSE2(const uint8_t* WEBP_RESTRICT alpha,
   return (alpha_and != 0xff);
 }
 
-static void DispatchAlphaToGreen_SSE2(const uint8_t* WEBP_RESTRICT alpha,
-                                      int alpha_stride, int width, int height,
-                                      uint32_t* WEBP_RESTRICT dst,
-                                      int dst_stride) {
+static void DispatchAlphaToGreen_SSE2(const uint8_t* alpha, int alpha_stride,
+                                      int width, int height,
+                                      uint32_t* dst, int dst_stride) {
   int i, j;
   const __m128i zero = _mm_setzero_si128();
   const int limit = width & ~15;
@@ -99,9 +98,9 @@ static void DispatchAlphaToGreen_SSE2(const uint8_t* WEBP_RESTRICT alpha,
   }
 }
 
-static int ExtractAlpha_SSE2(const uint8_t* WEBP_RESTRICT argb, int argb_stride,
+static int ExtractAlpha_SSE2(const uint8_t* argb, int argb_stride,
                              int width, int height,
-                             uint8_t* WEBP_RESTRICT alpha, int alpha_stride) {
+                             uint8_t* alpha, int alpha_stride) {
   // alpha_and stores an 'and' operation of all the alpha[] values. The final
   // value is not 0xff if any of the alpha[] is not equal to 0xff.
   uint32_t alpha_and = 0xff;
@@ -215,7 +214,7 @@ static void ApplyAlphaMultiply_SSE2(uint8_t* rgba, int alpha_first,
 // Alpha detection
 
 static int HasAlpha8b_SSE2(const uint8_t* src, int length) {
-  const __m128i all_0xff = _mm_set1_epi8((char)0xff);
+  const __m128i all_0xff = _mm_set1_epi8(0xff);
   int i = 0;
   for (; i + 16 <= length; i += 16) {
     const __m128i v = _mm_loadu_si128((const __m128i*)(src + i));
@@ -229,7 +228,7 @@ static int HasAlpha8b_SSE2(const uint8_t* src, int length) {
 
 static int HasAlpha32b_SSE2(const uint8_t* src, int length) {
   const __m128i alpha_mask = _mm_set1_epi32(0xff);
-  const __m128i all_0xff = _mm_set1_epi8((char)0xff);
+  const __m128i all_0xff = _mm_set1_epi8(0xff);
   int i = 0;
   // We don't know if we can access the last 3 bytes after the last alpha
   // value 'src[4 * length - 4]' (because we don't know if alpha is the first
@@ -266,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
 
@@ -318,8 +296,7 @@ static void MultARGBRow_SSE2(uint32_t* const ptr, int width, int inverse) {
   if (width > 0) WebPMultARGBRow_C(ptr + x, width, inverse);
 }
 
-static void MultRow_SSE2(uint8_t* WEBP_RESTRICT const ptr,
-                         const uint8_t* WEBP_RESTRICT const alpha,
+static void MultRow_SSE2(uint8_t* const ptr, const uint8_t* const alpha,
                          int width, int inverse) {
   int x = 0;
   if (!inverse) {
@@ -357,7 +334,6 @@ WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessingSSE2(void) {
 
   WebPHasAlpha8b = HasAlpha8b_SSE2;
   WebPHasAlpha32b = HasAlpha32b_SSE2;
-  WebPAlphaReplace = AlphaReplace_SSE2;
 }
 
 #else  // !WEBP_USE_SSE2

src/dsp/alpha_processing_sse41.c

@@ -19,9 +19,9 @@
 
 //------------------------------------------------------------------------------
 
-static int ExtractAlpha_SSE41(const uint8_t* WEBP_RESTRICT argb,
-                              int argb_stride, int width, int height,
-                              uint8_t* WEBP_RESTRICT alpha, int alpha_stride) {
+static int ExtractAlpha_SSE41(const uint8_t* argb, int argb_stride,
+                              int width, int height,
+                              uint8_t* alpha, int alpha_stride) {
   // alpha_and stores an 'and' operation of all the alpha[] values. The final
   // value is not 0xff if any of the alpha[] is not equal to 0xff.
   uint32_t alpha_and = 0xff;

src/dsp/cost.c

@@ -395,12 +395,12 @@ WEBP_DSP_INIT_FUNC(VP8EncDspCostInit) {
       VP8EncDspCostInitMIPSdspR2();
     }
 #endif
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       VP8EncDspCostInitSSE2();
     }
 #endif
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
     if (VP8GetCPUInfo(kNEON)) {
       VP8EncDspCostInitNEON();
     }

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) {
@@ -179,40 +173,15 @@ static int AndroidCPUInfo(CPUFeature feature) {
   const AndroidCpuFamily cpu_family = android_getCpuFamily();
   const uint64_t cpu_features = android_getCpuFeatures();
   if (feature == kNEON) {
-    return cpu_family == ANDROID_CPU_FAMILY_ARM &&
-           (cpu_features & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
+    return (cpu_family == ANDROID_CPU_FAMILY_ARM &&
+            0 != (cpu_features & ANDROID_CPU_ARM_FEATURE_NEON));
   }
   return 0;
 }
 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_HAVE_SSE2
-    case kSSE2:
-      return 1;
-#endif
-#ifdef WEBP_HAVE_SSE41
-    case kSSE3:
-    case kSlowSSSE3:
-    case kSSE4_1:
-      return 1;
-#endif
-#ifdef WEBP_HAVE_NEON
-    case kNEON:
-      return 1;
-#endif
-    default:
-      break;
-  }
-  return 0;
-}
-VP8CPUInfo VP8GetCPUInfo = wasmCPUInfo;
-#elif defined(WEBP_HAVE_NEON)
-// In most cases this function doesn't check for NEON support (it's assumed by
-// the configuration), but enables turning off NEON at runtime, for testing
-// purposes, by setting VP8DecGetCPUInfo = NULL.
+#elif defined(WEBP_USE_NEON)
+// define a dummy function to enable turning off NEON at runtime by setting
+// VP8DecGetCPUInfo = NULL
 static int armCPUInfo(CPUFeature feature) {
   if (feature != kNEON) return 0;
 #if defined(__linux__) && defined(WEBP_HAVE_NEON_RTCD)

src/dsp/dec.c

@@ -807,10 +807,10 @@ WEBP_DSP_INIT_FUNC(VP8DspInit) {
 
   // If defined, use CPUInfo() to overwrite some pointers with faster versions.
   if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       VP8DspInitSSE2();
-#if defined(WEBP_HAVE_SSE41)
+#if defined(WEBP_USE_SSE41)
       if (VP8GetCPUInfo(kSSE4_1)) {
         VP8DspInitSSE41();
       }
@@ -834,7 +834,7 @@ WEBP_DSP_INIT_FUNC(VP8DspInit) {
 #endif
   }
 
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
   if (WEBP_NEON_OMIT_C_CODE ||
       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
     VP8DspInitNEON();

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
@@ -1361,8 +1361,7 @@ static void RD4_NEON(uint8_t* dst) {   // Down-right
   const uint32_t J = dst[-1 + 1 * BPS];
   const uint32_t K = dst[-1 + 2 * BPS];
   const uint32_t L = dst[-1 + 3 * BPS];
-  const uint64x1_t LKJI____ =
-      vcreate_u64((uint64_t)L | (K << 8) | (J << 16) | (I << 24));
+  const uint64x1_t LKJI____ = vcreate_u64(L | (K << 8) | (J << 16) | (I << 24));
   const uint64x1_t LKJIXABC = vorr_u64(LKJI____, ____XABC);
   const uint8x8_t KJIXABC_ = vreinterpret_u8_u64(vshr_n_u64(LKJIXABC, 8));
   const uint8x8_t JIXABC__ = vreinterpret_u8_u64(vshr_n_u64(LKJIXABC, 16));
@@ -1428,30 +1427,25 @@ 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);
-    sum_top = vdupq_n_u16(p2);
-#else
     const uint16x4_t p0 = vpaddl_u8(A);  // cascading summation of the top
     const uint16x4_t p1 = vpadd_u16(p0, p0);
     const uint16x4_t p2 = vpadd_u16(p1, p1);
     sum_top = vcombine_u16(p2, p2);
-#endif
   }
 
   if (do_left) {
-    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 +1505,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);

src/dsp/dec_sse2.c

@@ -326,7 +326,7 @@ static WEBP_INLINE void Update2Pixels_SSE2(__m128i* const pi, __m128i* const qi,
   const __m128i a1_lo = _mm_srai_epi16(*a0_lo, 7);
   const __m128i a1_hi = _mm_srai_epi16(*a0_hi, 7);
   const __m128i delta = _mm_packs_epi16(a1_lo, a1_hi);
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
   *pi = _mm_adds_epi8(*pi, delta);
   *qi = _mm_subs_epi8(*qi, delta);
   FLIP_SIGN_BIT2(*pi, *qi);
@@ -338,9 +338,9 @@ static WEBP_INLINE void NeedsFilter_SSE2(const __m128i* const p1,
                                          const __m128i* const q0,
                                          const __m128i* const q1,
                                          int thresh, __m128i* const mask) {
-  const __m128i m_thresh = _mm_set1_epi8((char)thresh);
+  const __m128i m_thresh = _mm_set1_epi8(thresh);
   const __m128i t1 = MM_ABS(*p1, *q1);        // abs(p1 - q1)
-  const __m128i kFE = _mm_set1_epi8((char)0xFE);
+  const __m128i kFE = _mm_set1_epi8(0xFE);
   const __m128i t2 = _mm_and_si128(t1, kFE);  // set lsb of each byte to zero
   const __m128i t3 = _mm_srli_epi16(t2, 1);   // abs(p1 - q1) / 2
 
@@ -360,7 +360,7 @@ static WEBP_INLINE void DoFilter2_SSE2(__m128i* const p1, __m128i* const p0,
                                        __m128i* const q0, __m128i* const q1,
                                        int thresh) {
   __m128i a, mask;
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
   // convert p1/q1 to int8_t (for GetBaseDelta_SSE2)
   const __m128i p1s = _mm_xor_si128(*p1, sign_bit);
   const __m128i q1s = _mm_xor_si128(*q1, sign_bit);
@@ -380,7 +380,7 @@ static WEBP_INLINE void DoFilter4_SSE2(__m128i* const p1, __m128i* const p0,
                                        const __m128i* const mask,
                                        int hev_thresh) {
   const __m128i zero = _mm_setzero_si128();
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
   const __m128i k64 = _mm_set1_epi8(64);
   const __m128i k3 = _mm_set1_epi8(3);
   const __m128i k4 = _mm_set1_epi8(4);
@@ -427,7 +427,7 @@ static WEBP_INLINE void DoFilter6_SSE2(__m128i* const p2, __m128i* const p1,
                                        const __m128i* const mask,
                                        int hev_thresh) {
   const __m128i zero = _mm_setzero_si128();
-  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
+  const __m128i sign_bit = _mm_set1_epi8(0x80);
   __m128i a, not_hev;
 
   // compute hev mask
@@ -941,7 +941,7 @@ static void VR4_SSE2(uint8_t* dst) {   // Vertical-Right
   const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
   const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
   const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
-  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(I | (X << 8)), 0);
+  const __m128i IXABCD = _mm_insert_epi16(_XABCD, I | (X << 8), 0);
   const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
   const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
   const __m128i avg2 = _mm_subs_epu8(avg1, lsb);

src/dsp/dsp.h

@@ -26,23 +26,6 @@ extern "C" {
 
 #define BPS 32   // this is the common stride for enc/dec
 
-//------------------------------------------------------------------------------
-// WEBP_RESTRICT
-
-// Declares a pointer with the restrict type qualifier if available.
-// This allows code to hint to the compiler that only this pointer references a
-// particular object or memory region within the scope of the block in which it
-// is declared. This may allow for improved optimizations due to the lack of
-// pointer aliasing. See also:
-// https://en.cppreference.com/w/c/language/restrict
-#if defined(__GNUC__)
-#define WEBP_RESTRICT __restrict__
-#elif defined(_MSC_VER)
-#define WEBP_RESTRICT __restrict
-#else
-#define WEBP_RESTRICT
-#endif
-
 //------------------------------------------------------------------------------
 // CPU detection
 
@@ -68,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
@@ -78,37 +63,23 @@ 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.
 // Files containing intrinsics will need to be built targeting the instruction
 // set so should succeed on one of the earlier tests.
-#if (defined(__SSE2__) || defined(WEBP_MSC_SSE2)) && \
-    (!defined(HAVE_CONFIG_H) || defined(WEBP_HAVE_SSE2))
+#if defined(__SSE2__) || defined(WEBP_MSC_SSE2) || defined(WEBP_HAVE_SSE2)
 #define WEBP_USE_SSE2
 #endif
 
-#if defined(WEBP_USE_SSE2) && !defined(WEBP_HAVE_SSE2)
-#define WEBP_HAVE_SSE2
-#endif
-
-#if (defined(__SSE4_1__) || defined(WEBP_MSC_SSE41)) && \
-    (!defined(HAVE_CONFIG_H) || defined(WEBP_HAVE_SSE41))
+#if defined(__SSE4_1__) || defined(WEBP_MSC_SSE41) || defined(WEBP_HAVE_SSE41)
 #define WEBP_USE_SSE41
 #endif
 
-#if defined(WEBP_USE_SSE41) && !defined(WEBP_HAVE_SSE41)
-#define WEBP_HAVE_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__) || defined(__aarch64__)) && \
-     (!defined(HAVE_CONFIG_H) || defined(WEBP_HAVE_NEON))) && \
+#if (defined(__ARM_NEON__) || \
+     defined(__aarch64__) || defined(WEBP_HAVE_NEON)) && \
     !defined(__native_client__)
 #define WEBP_USE_NEON
 #endif
@@ -124,10 +95,6 @@ extern "C" {
 #define WEBP_USE_INTRINSICS
 #endif
 
-#if defined(WEBP_USE_NEON) && !defined(WEBP_HAVE_NEON)
-#define WEBP_HAVE_NEON
-#endif
-
 #if defined(__mips__) && !defined(__mips64) && \
     defined(__mips_isa_rev) && (__mips_isa_rev >= 1) && (__mips_isa_rev < 6)
 #define WEBP_USE_MIPS32
@@ -143,11 +110,13 @@ extern "C" {
 #define WEBP_USE_MSA
 #endif
 
+#endif  /* EMSCRIPTEN */
+
 #ifndef WEBP_DSP_OMIT_C_CODE
 #define WEBP_DSP_OMIT_C_CODE 1
 #endif
 
-#if defined(WEBP_USE_NEON) && WEBP_DSP_OMIT_C_CODE
+#if (defined(__aarch64__) || defined(__ARM_NEON__)) && WEBP_DSP_OMIT_C_CODE
 #define WEBP_NEON_OMIT_C_CODE 1
 #else
 #define WEBP_NEON_OMIT_C_CODE 0
@@ -224,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
@@ -283,9 +246,9 @@ extern VP8Fdct VP8FTransform2;   // performs two transforms at a time
 extern VP8WHT VP8FTransformWHT;
 // Predictions
 // *dst is the destination block. *top and *left can be NULL.
-typedef void (*VP8IntraPreds)(uint8_t* dst, const uint8_t* left,
+typedef void (*VP8IntraPreds)(uint8_t *dst, const uint8_t* left,
                               const uint8_t* top);
-typedef void (*VP8Intra4Preds)(uint8_t* dst, const uint8_t* top);
+typedef void (*VP8Intra4Preds)(uint8_t *dst, const uint8_t* top);
 extern VP8Intra4Preds VP8EncPredLuma4;
 extern VP8IntraPreds VP8EncPredLuma16;
 extern VP8IntraPreds VP8EncPredChroma8;
@@ -609,29 +572,26 @@ extern void (*WebPApplyAlphaMultiply4444)(
 
 // Dispatch the values from alpha[] plane to the ARGB destination 'dst'.
 // Returns true if alpha[] plane has non-trivial values different from 0xff.
-extern int (*WebPDispatchAlpha)(const uint8_t* WEBP_RESTRICT alpha,
-                                int alpha_stride, int width, int height,
-                                uint8_t* WEBP_RESTRICT dst, int dst_stride);
+extern int (*WebPDispatchAlpha)(const uint8_t* alpha, int alpha_stride,
+                                int width, int height,
+                                uint8_t* dst, int dst_stride);
 
 // Transfer packed 8b alpha[] values to green channel in dst[], zero'ing the
 // A/R/B values. 'dst_stride' is the stride for dst[] in uint32_t units.
-extern void (*WebPDispatchAlphaToGreen)(const uint8_t* WEBP_RESTRICT alpha,
-                                        int alpha_stride, int width, int height,
-                                        uint32_t* WEBP_RESTRICT dst,
-                                        int dst_stride);
+extern void (*WebPDispatchAlphaToGreen)(const uint8_t* alpha, int alpha_stride,
+                                        int width, int height,
+                                        uint32_t* dst, int dst_stride);
 
 // Extract the alpha values from 32b values in argb[] and pack them into alpha[]
 // (this is the opposite of WebPDispatchAlpha).
 // Returns true if there's only trivial 0xff alpha values.
-extern int (*WebPExtractAlpha)(const uint8_t* WEBP_RESTRICT argb,
-                               int argb_stride, int width, int height,
-                               uint8_t* WEBP_RESTRICT alpha,
-                               int alpha_stride);
+extern int (*WebPExtractAlpha)(const uint8_t* argb, int argb_stride,
+                               int width, int height,
+                               uint8_t* alpha, int alpha_stride);
 
 // Extract the green values from 32b values in argb[] and pack them into alpha[]
 // (this is the opposite of WebPDispatchAlphaToGreen).
-extern void (*WebPExtractGreen)(const uint32_t* WEBP_RESTRICT argb,
-                                uint8_t* WEBP_RESTRICT alpha, int size);
+extern void (*WebPExtractGreen)(const uint32_t* argb, uint8_t* alpha, int size);
 
 // Pre-Multiply operation transforms x into x * A / 255  (where x=Y,R,G or B).
 // Un-Multiply operation transforms x into x * 255 / A.
@@ -644,42 +604,34 @@ void WebPMultARGBRows(uint8_t* ptr, int stride, int width, int num_rows,
                       int inverse);
 
 // Same for a row of single values, with side alpha values.
-extern void (*WebPMultRow)(uint8_t* WEBP_RESTRICT const ptr,
-                           const uint8_t* WEBP_RESTRICT const alpha,
+extern void (*WebPMultRow)(uint8_t* const ptr, const uint8_t* const alpha,
                            int width, int inverse);
 
 // Same a WebPMultRow(), but for several 'num_rows' rows.
-void WebPMultRows(uint8_t* WEBP_RESTRICT ptr, int stride,
-                  const uint8_t* WEBP_RESTRICT alpha, int alpha_stride,
+void WebPMultRows(uint8_t* ptr, int stride,
+                  const uint8_t* alpha, int alpha_stride,
                   int width, int num_rows, int inverse);
 
 // Plain-C versions, used as fallback by some implementations.
-void WebPMultRow_C(uint8_t* WEBP_RESTRICT const ptr,
-                   const uint8_t* WEBP_RESTRICT const alpha,
+void WebPMultRow_C(uint8_t* const ptr, const uint8_t* const alpha,
                    int width, int inverse);
 void WebPMultARGBRow_C(uint32_t* const ptr, int width, int inverse);
 
 #ifdef WORDS_BIGENDIAN
 // ARGB packing function: a/r/g/b input is rgba or bgra order.
-extern void (*WebPPackARGB)(const uint8_t* WEBP_RESTRICT a,
-                            const uint8_t* WEBP_RESTRICT r,
-                            const uint8_t* WEBP_RESTRICT g,
-                            const uint8_t* WEBP_RESTRICT b,
-                            int len, uint32_t* WEBP_RESTRICT out);
+extern void (*WebPPackARGB)(const uint8_t* a, const uint8_t* r,
+                            const uint8_t* g, const uint8_t* b, int len,
+                            uint32_t* out);
 #endif
 
 // RGB packing function. 'step' can be 3 or 4. r/g/b input is rgb or bgr order.
-extern void (*WebPPackRGB)(const uint8_t* WEBP_RESTRICT r,
-                           const uint8_t* WEBP_RESTRICT g,
-                           const uint8_t* WEBP_RESTRICT b,
-                           int len, int step, uint32_t* WEBP_RESTRICT out);
+extern void (*WebPPackRGB)(const uint8_t* r, const uint8_t* g, const uint8_t* b,
+                           int len, int step, uint32_t* out);
 
 // This function returns true if src[i] contains a value different from 0xff.
 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);

src/dsp/enc.c

@@ -773,10 +773,10 @@ WEBP_DSP_INIT_FUNC(VP8EncDspInit) {
 
   // If defined, use CPUInfo() to overwrite some pointers with faster versions.
   if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       VP8EncDspInitSSE2();
-#if defined(WEBP_HAVE_SSE41)
+#if defined(WEBP_USE_SSE41)
       if (VP8GetCPUInfo(kSSE4_1)) {
         VP8EncDspInitSSE41();
       }
@@ -800,7 +800,7 @@ WEBP_DSP_INIT_FUNC(VP8EncDspInit) {
 #endif
   }
 
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
   if (WEBP_NEON_OMIT_C_CODE ||
       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
     VP8EncDspInitNEON();

src/dsp/enc_sse2.c

@@ -777,7 +777,7 @@ static WEBP_INLINE void VR4_SSE2(uint8_t* dst,
   const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
   const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
   const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
-  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(I | (X << 8)), 0);
+  const __m128i IXABCD = _mm_insert_epi16(_XABCD, I | (X << 8), 0);
   const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
   const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
   const __m128i avg2 = _mm_subs_epu8(avg1, lsb);

src/dsp/filters.c

@@ -33,9 +33,9 @@ static WEBP_INLINE void PredictLine_C(const uint8_t* src, const uint8_t* pred,
                                       uint8_t* dst, int length, int inverse) {
   int i;
   if (inverse) {
-    for (i = 0; i < length; ++i) dst[i] = (uint8_t)(src[i] + pred[i]);
+    for (i = 0; i < length; ++i) dst[i] = src[i] + pred[i];
   } else {
-    for (i = 0; i < length; ++i) dst[i] = (uint8_t)(src[i] - pred[i]);
+    for (i = 0; i < length; ++i) dst[i] = src[i] - pred[i];
   }
 }
 
@@ -155,7 +155,7 @@ static WEBP_INLINE void DoGradientFilter_C(const uint8_t* in,
       const int pred = GradientPredictor_C(preds[w - 1],
                                            preds[w - stride],
                                            preds[w - stride - 1]);
-      out[w] = (uint8_t)(in[w] + (inverse ? pred : -pred));
+      out[w] = in[w] + (inverse ? pred : -pred);
     }
     ++row;
     preds += stride;
@@ -194,7 +194,7 @@ static void HorizontalUnfilter_C(const uint8_t* prev, const uint8_t* in,
   uint8_t pred = (prev == NULL) ? 0 : prev[0];
   int i;
   for (i = 0; i < width; ++i) {
-    out[i] = (uint8_t)(pred + in[i]);
+    out[i] = pred + in[i];
     pred = out[i];
   }
 }
@@ -206,7 +206,7 @@ static void VerticalUnfilter_C(const uint8_t* prev, const uint8_t* in,
     HorizontalUnfilter_C(NULL, in, out, width);
   } else {
     int i;
-    for (i = 0; i < width; ++i) out[i] = (uint8_t)(prev[i] + in[i]);
+    for (i = 0; i < width; ++i) out[i] = prev[i] + in[i];
   }
 }
 #endif  // !WEBP_NEON_OMIT_C_CODE
@@ -220,7 +220,7 @@ static void GradientUnfilter_C(const uint8_t* prev, const uint8_t* in,
     int i;
     for (i = 0; i < width; ++i) {
       top = prev[i];  // need to read this first, in case prev==out
-      left = (uint8_t)(in[i] + GradientPredictor_C(left, top, top_left));
+      left = in[i] + GradientPredictor_C(left, top, top_left);
       top_left = top;
       out[i] = left;
     }
@@ -254,7 +254,7 @@ WEBP_DSP_INIT_FUNC(VP8FiltersInit) {
 #endif
 
   if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       VP8FiltersInitSSE2();
     }
@@ -271,7 +271,7 @@ WEBP_DSP_INIT_FUNC(VP8FiltersInit) {
 #endif
   }
 
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
   if (WEBP_NEON_OMIT_C_CODE ||
       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
     VP8FiltersInitNEON();

src/dsp/filters_sse2.c

@@ -163,8 +163,7 @@ static void GradientPredictDirect_SSE2(const uint8_t* const row,
     _mm_storel_epi64((__m128i*)(out + i), H);
   }
   for (; i < length; ++i) {
-    const int delta = GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
-    out[i] = (uint8_t)(row[i] - delta);
+    out[i] = row[i] - GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
   }
 }
 
@@ -189,7 +188,7 @@ static WEBP_INLINE void DoGradientFilter_SSE2(const uint8_t* in,
 
   // Filter line-by-line.
   while (row < last_row) {
-    out[0] = (uint8_t)(in[0] - in[-stride]);
+    out[0] = in[0] - in[-stride];
     GradientPredictDirect_SSE2(in + 1, in + 1 - stride, out + 1, width - 1);
     ++row;
     in += stride;
@@ -224,7 +223,7 @@ static void HorizontalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
                                     uint8_t* out, int width) {
   int i;
   __m128i last;
-  out[0] = (uint8_t)(in[0] + (prev == NULL ? 0 : prev[0]));
+  out[0] = in[0] + (prev == NULL ? 0 : prev[0]);
   if (width <= 1) return;
   last = _mm_set_epi32(0, 0, 0, out[0]);
   for (i = 1; i + 8 <= width; i += 8) {
@@ -239,7 +238,7 @@ static void HorizontalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
     _mm_storel_epi64((__m128i*)(out + i), A7);
     last = _mm_srli_epi64(A7, 56);
   }
-  for (; i < width; ++i) out[i] = (uint8_t)(in[i] + out[i - 1]);
+  for (; i < width; ++i) out[i] = in[i] + out[i - 1];
 }
 
 static void VerticalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
@@ -260,7 +259,7 @@ static void VerticalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
       _mm_storeu_si128((__m128i*)&out[i +  0], C0);
       _mm_storeu_si128((__m128i*)&out[i + 16], C1);
     }
-    for (; i < width; ++i) out[i] = (uint8_t)(in[i] + prev[i]);
+    for (; i < width; ++i) out[i] = in[i] + prev[i];
   }
 }
 
@@ -297,8 +296,7 @@ static void GradientPredictInverse_SSE2(const uint8_t* const in,
       _mm_storel_epi64((__m128i*)&row[i], out);
     }
     for (; i < length; ++i) {
-      const int delta = GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
-      row[i] = (uint8_t)(in[i] + delta);
+      row[i] = in[i] + GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
     }
   }
 }
@@ -308,7 +306,7 @@ static void GradientUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
   if (prev == NULL) {
     HorizontalUnfilter_SSE2(NULL, in, out, width);
   } else {
-    out[0] = (uint8_t)(in[0] + prev[0]);  // predict from above
+    out[0] = in[0] + prev[0];  // predict from above
     GradientPredictInverse_SSE2(in + 1, prev + 1, out + 1, width - 1);
   }
 }
@@ -320,12 +318,7 @@ extern void VP8FiltersInitSSE2(void);
 
 WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitSSE2(void) {
   WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter_SSE2;
-#if defined(CHROMIUM)
-  // TODO(crbug.com/654974)
-  (void)VerticalUnfilter_SSE2;
-#else
   WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter_SSE2;
-#endif
   WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter_SSE2;
 
   WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter_SSE2;

src/dsp/lossless.c

@@ -81,7 +81,7 @@ static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,
 
 // gcc <= 4.9 on ARM generates incorrect code in Select() when Sub3() is
 // inlined.
-#if defined(__arm__) && defined(__GNUC__) && LOCAL_GCC_VERSION <= 0x409
+#if defined(__arm__) && LOCAL_GCC_VERSION <= 0x409
 # define LOCAL_INLINE __attribute__ ((noinline))
 #else
 # define LOCAL_INLINE WEBP_INLINE
@@ -107,93 +107,88 @@ 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;
 }
 
-static void PredictorAdd0_C(const uint32_t* in, const uint32_t* upper,
-                            int num_pixels, uint32_t* out) {
-  int x;
-  (void)upper;
-  for (x = 0; x < num_pixels; ++x) out[x] = VP8LAddPixels(in[x], ARGB_BLACK);
-}
+GENERATE_PREDICTOR_ADD(Predictor0_C, PredictorAdd0_C)
 static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
                             int num_pixels, uint32_t* out) {
   int i;
   uint32_t left = out[-1];
-  (void)upper;
   for (i = 0; i < num_pixels; ++i) {
     out[i] = left = VP8LAddPixels(in[i], left);
   }
+  (void)upper;
 }
-GENERATE_PREDICTOR_ADD(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)
 
 //------------------------------------------------------------------------------
 
@@ -275,14 +270,14 @@ void VP8LTransformColorInverse_C(const VP8LMultipliers* const m,
   int i;
   for (i = 0; i < num_pixels; ++i) {
     const uint32_t argb = src[i];
-    const int8_t green = (int8_t)(argb >> 8);
+    const uint32_t green = argb >> 8;
     const uint32_t red = argb >> 16;
     int new_red = red & 0xff;
     int new_blue = argb & 0xff;
     new_red += ColorTransformDelta(m->green_to_red_, green);
     new_red &= 0xff;
     new_blue += ColorTransformDelta(m->green_to_blue_, green);
-    new_blue += ColorTransformDelta(m->red_to_blue_, (int8_t)new_red);
+    new_blue += ColorTransformDelta(m->red_to_blue_, new_red);
     new_blue &= 0xff;
     dst[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);
   }
@@ -562,6 +557,7 @@ VP8LPredictorFunc VP8LPredictors[16];
 
 // exposed plain-C implementations
 VP8LPredictorAddSubFunc VP8LPredictorsAdd_C[16];
+VP8LPredictorFunc VP8LPredictors_C[16];
 
 VP8LTransformColorInverseFunc VP8LTransformColorInverse;
 
@@ -575,7 +571,6 @@ VP8LMapARGBFunc VP8LMapColor32b;
 VP8LMapAlphaFunc VP8LMapColor8b;
 
 extern void VP8LDspInitSSE2(void);
-extern void VP8LDspInitSSE41(void);
 extern void VP8LDspInitNEON(void);
 extern void VP8LDspInitMIPSdspR2(void);
 extern void VP8LDspInitMSA(void);
@@ -600,7 +595,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)
 
@@ -622,14 +618,9 @@ WEBP_DSP_INIT_FUNC(VP8LDspInit) {
 
   // If defined, use CPUInfo() to overwrite some pointers with faster versions.
   if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       VP8LDspInitSSE2();
-#if defined(WEBP_HAVE_SSE41)
-      if (VP8GetCPUInfo(kSSE4_1)) {
-        VP8LDspInitSSE41();
-      }
-#endif
     }
 #endif
 #if defined(WEBP_USE_MIPS_DSP_R2)
@@ -644,7 +635,7 @@ WEBP_DSP_INIT_FUNC(VP8LDspInit) {
 #endif
   }
 
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
   if (WEBP_NEON_OMIT_C_CODE ||
       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
     VP8LDspInitNEON();

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,

src/dsp/lossless_common.h

@@ -177,13 +177,24 @@ uint32_t VP8LSubPixels(uint32_t a, uint32_t b) {
 static void PREDICTOR_ADD(const uint32_t* in, const uint32_t* upper, \
                           int num_pixels, uint32_t* out) {           \
   int x;                                                             \
-  assert(upper != NULL);                                             \
   for (x = 0; x < num_pixels; ++x) {                                 \
     const uint32_t pred = (PREDICTOR)(out[x - 1], upper + x);        \
     out[x] = VP8LAddPixels(in[x], pred);                             \
   }                                                                  \
 }
 
+// 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;                                                             \
+  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

src/dsp/lossless_enc.c

@@ -329,15 +329,6 @@ const uint8_t kPrefixEncodeExtraBitsValue[PREFIX_LOOKUP_IDX_MAX] = {
 static float FastSLog2Slow_C(uint32_t v) {
   assert(v >= LOG_LOOKUP_IDX_MAX);
   if (v < APPROX_LOG_WITH_CORRECTION_MAX) {
-#if !defined(WEBP_HAVE_SLOW_CLZ_CTZ)
-    // use clz if available
-    const int log_cnt = BitsLog2Floor(v) - 7;
-    const uint32_t y = 1 << log_cnt;
-    int correction = 0;
-    const float v_f = (float)v;
-    const uint32_t orig_v = v;
-    v >>= log_cnt;
-#else
     int log_cnt = 0;
     uint32_t y = 1;
     int correction = 0;
@@ -348,7 +339,6 @@ static float FastSLog2Slow_C(uint32_t v) {
       v = v >> 1;
       y = y << 1;
     } while (v >= LOG_LOOKUP_IDX_MAX);
-#endif
     // vf = (2^log_cnt) * Xf; where y = 2^log_cnt and Xf < 256
     // Xf = floor(Xf) * (1 + (v % y) / v)
     // log2(Xf) = log2(floor(Xf)) + log2(1 + (v % y) / v)
@@ -365,14 +355,6 @@ static float FastSLog2Slow_C(uint32_t v) {
 static float FastLog2Slow_C(uint32_t v) {
   assert(v >= LOG_LOOKUP_IDX_MAX);
   if (v < APPROX_LOG_WITH_CORRECTION_MAX) {
-#if !defined(WEBP_HAVE_SLOW_CLZ_CTZ)
-    // use clz if available
-    const int log_cnt = BitsLog2Floor(v) - 7;
-    const uint32_t y = 1 << log_cnt;
-    const uint32_t orig_v = v;
-    double log_2;
-    v >>= log_cnt;
-#else
     int log_cnt = 0;
     uint32_t y = 1;
     const uint32_t orig_v = v;
@@ -382,7 +364,6 @@ static float FastLog2Slow_C(uint32_t v) {
       v = v >> 1;
       y = y << 1;
     } while (v >= LOG_LOOKUP_IDX_MAX);
-#endif
     log_2 = kLog2Table[v] + log_cnt;
     if (orig_v >= APPROX_LOG_MAX) {
       // Since the division is still expensive, add this correction factor only
@@ -534,17 +515,13 @@ static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) {
   return ((int)color_pred * color) >> 5;
 }
 
-static WEBP_INLINE int8_t U32ToS8(uint32_t v) {
-  return (int8_t)(v & 0xff);
-}
-
 void VP8LTransformColor_C(const VP8LMultipliers* const m, uint32_t* data,
                           int num_pixels) {
   int i;
   for (i = 0; i < num_pixels; ++i) {
     const uint32_t argb = data[i];
-    const int8_t green = U32ToS8(argb >>  8);
-    const int8_t red   = U32ToS8(argb >> 16);
+    const uint32_t green = argb >> 8;
+    const uint32_t red = argb >> 16;
     int new_red = red & 0xff;
     int new_blue = argb & 0xff;
     new_red -= ColorTransformDelta(m->green_to_red_, green);
@@ -558,7 +535,7 @@ void VP8LTransformColor_C(const VP8LMultipliers* const m, uint32_t* data,
 
 static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red,
                                              uint32_t argb) {
-  const int8_t green = U32ToS8(argb >> 8);
+  const uint32_t green = argb >> 8;
   int new_red = argb >> 16;
   new_red -= ColorTransformDelta(green_to_red, green);
   return (new_red & 0xff);
@@ -567,9 +544,9 @@ static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red,
 static WEBP_INLINE uint8_t TransformColorBlue(uint8_t green_to_blue,
                                               uint8_t red_to_blue,
                                               uint32_t argb) {
-  const int8_t green = U32ToS8(argb >>  8);
-  const int8_t red   = U32ToS8(argb >> 16);
-  uint8_t new_blue = argb & 0xff;
+  const uint32_t green = argb >> 8;
+  const uint32_t red = argb >> 16;
+  uint8_t new_blue = argb;
   new_blue -= ColorTransformDelta(green_to_blue, green);
   new_blue -= ColorTransformDelta(red_to_blue, red);
   return (new_blue & 0xff);
@@ -581,7 +558,7 @@ void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride,
   while (tile_height-- > 0) {
     int x;
     for (x = 0; x < tile_width; ++x) {
-      ++histo[TransformColorRed((uint8_t)green_to_red, argb[x])];
+      ++histo[TransformColorRed(green_to_red, argb[x])];
     }
     argb += stride;
   }
@@ -594,8 +571,7 @@ void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride,
   while (tile_height-- > 0) {
     int x;
     for (x = 0; x < tile_width; ++x) {
-      ++histo[TransformColorBlue((uint8_t)green_to_blue, (uint8_t)red_to_blue,
-                                 argb[x])];
+      ++histo[TransformColorBlue(green_to_blue, red_to_blue, argb[x])];
     }
     argb += stride;
   }
@@ -721,6 +697,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;
@@ -735,33 +845,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)
 
 //------------------------------------------------------------------------------
 
@@ -862,10 +957,10 @@ WEBP_DSP_INIT_FUNC(VP8LEncDspInit) {
 
   // If defined, use CPUInfo() to overwrite some pointers with faster versions.
   if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       VP8LEncDspInitSSE2();
-#if defined(WEBP_HAVE_SSE41)
+#if defined(WEBP_USE_SSE41)
       if (VP8GetCPUInfo(kSSE4_1)) {
         VP8LEncDspInitSSE41();
       }
@@ -889,7 +984,7 @@ WEBP_DSP_INIT_FUNC(VP8LEncDspInit) {
 #endif
   }
 
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
   if (WEBP_NEON_OMIT_C_CODE ||
       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
     VP8LEncDspInitNEON();

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

src/dsp/lossless_enc_sse2.c

@@ -232,55 +232,76 @@ static void AddVectorEq_SSE2(const uint32_t* a, uint32_t* out, int size) {
 //------------------------------------------------------------------------------
 // Entropy
 
-// 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(WEBP_HAVE_SLOW_CLZ_CTZ) || defined(__i386__) || defined(_M_IX86))
+// Checks whether the X or Y contribution is worth computing and adding.
+// Used in loop unrolling.
+#define ANALYZE_X_OR_Y(x_or_y, j)                                           \
+  do {                                                                      \
+    if ((x_or_y)[i + (j)] != 0) retval -= VP8LFastSLog2((x_or_y)[i + (j)]); \
+  } while (0)
+
+// Checks whether the X + Y contribution is worth computing and adding.
+// Used in loop unrolling.
+#define ANALYZE_XY(j)                  \
+  do {                                 \
+    if (tmp[j] != 0) {                 \
+      retval -= VP8LFastSLog2(tmp[j]); \
+      ANALYZE_X_OR_Y(X, j);            \
+    }                                  \
+  } while (0)
 
 static float CombinedShannonEntropy_SSE2(const int X[256], const int Y[256]) {
   int i;
   double retval = 0.;
-  int sumX = 0, sumXY = 0;
-  const __m128i zero = _mm_setzero_si128();
+  int sumX, sumXY;
+  int32_t tmp[4];
+  __m128i zero = _mm_setzero_si128();
+  // Sums up X + Y, 4 ints at a time (and will merge it at the end for sumXY).
+  __m128i sumXY_128 = zero;
+  __m128i sumX_128 = zero;
 
-  for (i = 0; i < 256; i += 16) {
-    const __m128i x0 = _mm_loadu_si128((const __m128i*)(X + i +  0));
-    const __m128i y0 = _mm_loadu_si128((const __m128i*)(Y + i +  0));
-    const __m128i x1 = _mm_loadu_si128((const __m128i*)(X + i +  4));
-    const __m128i y1 = _mm_loadu_si128((const __m128i*)(Y + i +  4));
-    const __m128i x2 = _mm_loadu_si128((const __m128i*)(X + i +  8));
-    const __m128i y2 = _mm_loadu_si128((const __m128i*)(Y + i +  8));
-    const __m128i x3 = _mm_loadu_si128((const __m128i*)(X + i + 12));
-    const __m128i y3 = _mm_loadu_si128((const __m128i*)(Y + i + 12));
-    const __m128i x4 = _mm_packs_epi16(_mm_packs_epi32(x0, x1),
-                                       _mm_packs_epi32(x2, x3));
-    const __m128i y4 = _mm_packs_epi16(_mm_packs_epi32(y0, y1),
-                                       _mm_packs_epi32(y2, y3));
-    const int32_t mx = _mm_movemask_epi8(_mm_cmpgt_epi8(x4, zero));
-    int32_t my = _mm_movemask_epi8(_mm_cmpgt_epi8(y4, zero)) | mx;
-    while (my) {
-      const int32_t j = BitsCtz(my);
-      int xy;
-      if ((mx >> j) & 1) {
-        const int x = X[i + j];
-        sumXY += x;
-        retval -= VP8LFastSLog2(x);
-      }
-      xy = X[i + j] + Y[i + j];
-      sumX += xy;
-      retval -= VP8LFastSLog2(xy);
-      my &= my - 1;
+  for (i = 0; i < 256; i += 4) {
+    const __m128i x = _mm_loadu_si128((const __m128i*)(X + i));
+    const __m128i y = _mm_loadu_si128((const __m128i*)(Y + i));
+
+    // Check if any X is non-zero: this actually provides a speedup as X is
+    // usually sparse.
+    if (_mm_movemask_epi8(_mm_cmpeq_epi32(x, zero)) != 0xFFFF) {
+      const __m128i xy_128 = _mm_add_epi32(x, y);
+      sumXY_128 = _mm_add_epi32(sumXY_128, xy_128);
+
+      sumX_128 = _mm_add_epi32(sumX_128, x);
+
+      // Analyze the different X + Y.
+      _mm_storeu_si128((__m128i*)tmp, xy_128);
+
+      ANALYZE_XY(0);
+      ANALYZE_XY(1);
+      ANALYZE_XY(2);
+      ANALYZE_XY(3);
+    } else {
+      // X is fully 0, so only deal with Y.
+      sumXY_128 = _mm_add_epi32(sumXY_128, y);
+
+      ANALYZE_X_OR_Y(Y, 0);
+      ANALYZE_X_OR_Y(Y, 1);
+      ANALYZE_X_OR_Y(Y, 2);
+      ANALYZE_X_OR_Y(Y, 3);
     }
   }
+
+  // Sum up sumX_128 to get sumX.
+  _mm_storeu_si128((__m128i*)tmp, sumX_128);
+  sumX = tmp[3] + tmp[2] + tmp[1] + tmp[0];
+
+  // Sum up sumXY_128 to get sumXY.
+  _mm_storeu_si128((__m128i*)tmp, sumXY_128);
+  sumXY = tmp[3] + tmp[2] + tmp[1] + tmp[0];
+
   retval += VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY);
   return (float)retval;
 }
-
-#else
-
-#define DONT_USE_COMBINED_SHANNON_ENTROPY_SSE2_FUNC   // won't be faster
-
-#endif
+#undef ANALYZE_X_OR_Y
+#undef ANALYZE_XY
 
 //------------------------------------------------------------------------------
 
@@ -342,7 +363,7 @@ static void BundleColorMap_SSE2(const uint8_t* const row, int width, int xbits,
   assert(xbits <= 3);
   switch (xbits) {
     case 0: {
-      const __m128i ff = _mm_set1_epi16((short)0xff00);
+      const __m128i ff = _mm_set1_epi16(0xff00);
       const __m128i zero = _mm_setzero_si128();
       // Store 0xff000000 | (row[x] << 8).
       for (x = 0; x + 16 <= width; x += 16, dst += 16) {
@@ -361,7 +382,7 @@ static void BundleColorMap_SSE2(const uint8_t* const row, int width, int xbits,
       break;
     }
     case 1: {
-      const __m128i ff = _mm_set1_epi16((short)0xff00);
+      const __m128i ff = _mm_set1_epi16(0xff00);
       const __m128i mul = _mm_set1_epi16(0x110);
       for (x = 0; x + 16 <= width; x += 16, dst += 8) {
         // 0a0b | (where a/b are 4 bits).
@@ -434,15 +455,13 @@ static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
     _mm_storeu_si128((__m128i*)&out[i], res);
   }
   if (i != num_pixels) {
-    VP8LPredictorsSub_C[0](in + i, NULL, num_pixels - i, out + i);
+    VP8LPredictorsSub_C[0](in + i, upper + i, num_pixels - i, out + i);
   }
-  (void)upper;
 }
 
 #define GENERATE_PREDICTOR_1(X, IN)                                           \
-  static void PredictorSub##X##_SSE2(const uint32_t* const in,              \
-                                     const uint32_t* const upper,           \
-                                     int num_pixels, uint32_t* const out) { \
+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]);              \
@@ -451,10 +470,9 @@ static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
     _mm_storeu_si128((__m128i*)&out[i], res);                                 \
   }                                                                           \
   if (i != num_pixels) {                                                      \
-      VP8LPredictorsSub_C[(X)](in + i, WEBP_OFFSET_PTR(upper, i),           \
-                               num_pixels - i, out + i);                    \
+    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
@@ -638,9 +656,7 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {
   VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;
   VP8LAddVector = AddVector_SSE2;
   VP8LAddVectorEq = AddVectorEq_SSE2;
-#if !defined(DONT_USE_COMBINED_SHANNON_ENTROPY_SSE2_FUNC)
   VP8LCombinedShannonEntropy = CombinedShannonEntropy_SSE2;
-#endif
   VP8LVectorMismatch = VectorMismatch_SSE2;
   VP8LBundleColorMap = BundleColorMap_SSE2;
 

src/dsp/lossless_enc_sse41.c

@@ -44,47 +44,46 @@ static void SubtractGreenFromBlueAndRed_SSE41(uint32_t* argb_data,
 //------------------------------------------------------------------------------
 // Color Transform
 
-#define MK_CST_16(HI, LO) \
-  _mm_set1_epi32((int)(((uint32_t)(HI) << 16) | ((LO) & 0xffff)))
-
+#define SPAN 8
 static void CollectColorBlueTransforms_SSE41(const uint32_t* argb, int stride,
                                              int tile_width, int tile_height,
                                              int green_to_blue, int red_to_blue,
                                              int histo[]) {
-  const __m128i mult =
-      MK_CST_16(CST_5b(red_to_blue) + 256,CST_5b(green_to_blue));
-  const __m128i perm =
-      _mm_setr_epi8(-1, 1, -1, 2, -1, 5, -1, 6, -1, 9, -1, 10, -1, 13, -1, 14);
-  if (tile_width >= 4) {
+  const __m128i mults_r = _mm_set1_epi16(CST_5b(red_to_blue));
+  const __m128i mults_g = _mm_set1_epi16(CST_5b(green_to_blue));
+  const __m128i mask_g = _mm_set1_epi16(0xff00);   // green mask
+  const __m128i mask_gb = _mm_set1_epi32(0xffff);  // green/blue mask
+  const __m128i mask_b = _mm_set1_epi16(0x00ff);   // blue mask
+  const __m128i shuffler_lo = _mm_setr_epi8(-1, 2, -1, 6, -1, 10, -1, 14, -1,
+                                            -1, -1, -1, -1, -1, -1, -1);
+  const __m128i shuffler_hi = _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                            2, -1, 6, -1, 10, -1, 14);
   int y;
   for (y = 0; y < tile_height; ++y) {
     const uint32_t* const src = argb + y * stride;
-      const __m128i A1 = _mm_loadu_si128((const __m128i*)src);
-      const __m128i B1 = _mm_shuffle_epi8(A1, perm);
-      const __m128i C1 = _mm_mulhi_epi16(B1, mult);
-      const __m128i D1 = _mm_sub_epi16(A1, C1);
-      __m128i E = _mm_add_epi16(_mm_srli_epi32(D1, 16), D1);
-      int x;
-      for (x = 4; x + 4 <= tile_width; x += 4) {
-        const __m128i A2 = _mm_loadu_si128((const __m128i*)(src + x));
-        __m128i B2, C2, D2;
-        ++histo[_mm_extract_epi8(E,  0)];
-        B2 = _mm_shuffle_epi8(A2, perm);
-        ++histo[_mm_extract_epi8(E,  4)];
-        C2 = _mm_mulhi_epi16(B2, mult);
-        ++histo[_mm_extract_epi8(E,  8)];
-        D2 = _mm_sub_epi16(A2, C2);
-        ++histo[_mm_extract_epi8(E, 12)];
-        E = _mm_add_epi16(_mm_srli_epi32(D2, 16), D2);
-      }
-      ++histo[_mm_extract_epi8(E,  0)];
-      ++histo[_mm_extract_epi8(E,  4)];
-      ++histo[_mm_extract_epi8(E,  8)];
-      ++histo[_mm_extract_epi8(E, 12)];
+    int i, x;
+    for (x = 0; x + SPAN <= tile_width; x += SPAN) {
+      uint16_t values[SPAN];
+      const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x + 0]);
+      const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);
+      const __m128i r0 = _mm_shuffle_epi8(in0, shuffler_lo);
+      const __m128i r1 = _mm_shuffle_epi8(in1, shuffler_hi);
+      const __m128i r = _mm_or_si128(r0, r1);         // r 0
+      const __m128i gb0 = _mm_and_si128(in0, mask_gb);
+      const __m128i gb1 = _mm_and_si128(in1, mask_gb);
+      const __m128i gb = _mm_packus_epi32(gb0, gb1);  // g b
+      const __m128i g = _mm_and_si128(gb, mask_g);    // g 0
+      const __m128i A = _mm_mulhi_epi16(r, mults_r);  // x dbr
+      const __m128i B = _mm_mulhi_epi16(g, mults_g);  // x dbg
+      const __m128i C = _mm_sub_epi8(gb, B);          // x b'
+      const __m128i D = _mm_sub_epi8(C, A);           // x b''
+      const __m128i E = _mm_and_si128(D, mask_b);     // 0 b''
+      _mm_storeu_si128((__m128i*)values, E);
+      for (i = 0; i < SPAN; ++i) ++histo[values[i]];
     }
   }
   {
-    const int left_over = tile_width & 3;
+    const int left_over = tile_width & (SPAN - 1);
     if (left_over > 0) {
       VP8LCollectColorBlueTransforms_C(argb + tile_width - left_over, stride,
                                        left_over, tile_height,
@@ -96,37 +95,33 @@ static void CollectColorBlueTransforms_SSE41(const uint32_t* argb, int stride,
 static void CollectColorRedTransforms_SSE41(const uint32_t* argb, int stride,
                                             int tile_width, int tile_height,
                                             int green_to_red, int histo[]) {
+  const __m128i mults_g = _mm_set1_epi16(CST_5b(green_to_red));
+  const __m128i mask_g = _mm_set1_epi32(0x00ff00);  // green mask
+  const __m128i mask = _mm_set1_epi16(0xff);
 
-  const __m128i mult = MK_CST_16(0, CST_5b(green_to_red));
-  const __m128i mask_g = _mm_set1_epi32(0x0000ff00);
-  if (tile_width >= 4) {
   int y;
   for (y = 0; y < tile_height; ++y) {
     const uint32_t* const src = argb + y * stride;
-      const __m128i A1 = _mm_loadu_si128((const __m128i*)src);
-      const __m128i B1 = _mm_and_si128(A1, mask_g);
-      const __m128i C1 = _mm_madd_epi16(B1, mult);
-      __m128i D = _mm_sub_epi16(A1, C1);
-      int x;
-      for (x = 4; x + 4 <= tile_width; x += 4) {
-        const __m128i A2 = _mm_loadu_si128((const __m128i*)(src + x));
-        __m128i B2, C2;
-        ++histo[_mm_extract_epi8(D,  2)];
-        B2 = _mm_and_si128(A2, mask_g);
-        ++histo[_mm_extract_epi8(D,  6)];
-        C2 = _mm_madd_epi16(B2, mult);
-        ++histo[_mm_extract_epi8(D, 10)];
-        ++histo[_mm_extract_epi8(D, 14)];
-        D = _mm_sub_epi16(A2, C2);
-      }
-      ++histo[_mm_extract_epi8(D,  2)];
-      ++histo[_mm_extract_epi8(D,  6)];
-      ++histo[_mm_extract_epi8(D, 10)];
-      ++histo[_mm_extract_epi8(D, 14)];
+    int i, x;
+    for (x = 0; x + SPAN <= tile_width; x += SPAN) {
+      uint16_t values[SPAN];
+      const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x + 0]);
+      const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);
+      const __m128i g0 = _mm_and_si128(in0, mask_g);  // 0 0  | g 0
+      const __m128i g1 = _mm_and_si128(in1, mask_g);
+      const __m128i g = _mm_packus_epi32(g0, g1);     // g 0
+      const __m128i A0 = _mm_srli_epi32(in0, 16);     // 0 0  | x r
+      const __m128i A1 = _mm_srli_epi32(in1, 16);
+      const __m128i A = _mm_packus_epi32(A0, A1);     // x r
+      const __m128i B = _mm_mulhi_epi16(g, mults_g);  // x dr
+      const __m128i C = _mm_sub_epi8(A, B);           // x r'
+      const __m128i D = _mm_and_si128(C, mask);       // 0 r'
+      _mm_storeu_si128((__m128i*)values, D);
+      for (i = 0; i < SPAN; ++i) ++histo[values[i]];
     }
   }
   {
-    const int left_over = tile_width & 3;
+    const int left_over = tile_width & (SPAN - 1);
     if (left_over > 0) {
       VP8LCollectColorRedTransforms_C(argb + tile_width - left_over, stride,
                                       left_over, tile_height, green_to_red,
@@ -135,8 +130,6 @@ static void CollectColorRedTransforms_SSE41(const uint32_t* argb, int stride,
   }
 }
 
-#undef MK_CST_16
-
 //------------------------------------------------------------------------------
 // Entry point
 

src/dsp/lossless_sse2.c

@@ -18,6 +18,7 @@
 #include "src/dsp/common_sse2.h"
 #include "src/dsp/lossless.h"
 #include "src/dsp/lossless_common.h"
+#include <assert.h>
 #include <emmintrin.h>
 
 //------------------------------------------------------------------------------
@@ -190,9 +191,8 @@ static void PredictorAdd0_SSE2(const uint32_t* in, const uint32_t* upper,
     _mm_storeu_si128((__m128i*)&out[i], res);
   }
   if (i != num_pixels) {
-    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
+    VP8LPredictorsAdd_C[0](in + i, upper + i, num_pixels - i, out + i);
   }
-  (void)upper;
 }
 
 // Predictor1: left.

src/dsp/lossless_sse41.c

@@ -1,132 +0,0 @@
-// Copyright 2021 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// SSE41 variant of methods for lossless decoder
-
-#include "src/dsp/dsp.h"
-
-#if defined(WEBP_USE_SSE41)
-
-#include "src/dsp/common_sse41.h"
-#include "src/dsp/lossless.h"
-#include "src/dsp/lossless_common.h"
-
-//------------------------------------------------------------------------------
-// Color-space conversion functions
-
-static void TransformColorInverse_SSE41(const VP8LMultipliers* const m,
-                                        const uint32_t* const src,
-                                        int num_pixels, uint32_t* dst) {
-// sign-extended multiplying constants, pre-shifted by 5.
-#define CST(X)  (((int16_t)(m->X << 8)) >> 5)   // sign-extend
-  const __m128i mults_rb = _mm_set1_epi32((uint32_t)CST(green_to_red_) << 16 |
-                                          (CST(green_to_blue_) & 0xffff));
-  const __m128i mults_b2 = _mm_set1_epi32(CST(red_to_blue_));
-#undef CST
-  const __m128i mask_ag = _mm_set1_epi32(0xff00ff00);
-  const __m128i perm1 = _mm_setr_epi8(-1, 1, -1, 1, -1, 5, -1, 5,
-                                      -1, 9, -1, 9, -1, 13, -1, 13);
-  const __m128i perm2 = _mm_setr_epi8(-1, 2, -1, -1, -1, 6, -1, -1,
-                                      -1, 10, -1, -1, -1, 14, -1, -1);
-  int i;
-  for (i = 0; i + 4 <= num_pixels; i += 4) {
-    const __m128i A = _mm_loadu_si128((const __m128i*)(src + i));
-    const __m128i B = _mm_shuffle_epi8(A, perm1); // argb -> g0g0
-    const __m128i C = _mm_mulhi_epi16(B, mults_rb);
-    const __m128i D = _mm_add_epi8(A, C);
-    const __m128i E = _mm_shuffle_epi8(D, perm2);
-    const __m128i F = _mm_mulhi_epi16(E, mults_b2);
-    const __m128i G = _mm_add_epi8(D, F);
-    const __m128i out = _mm_blendv_epi8(G, A, mask_ag);
-    _mm_storeu_si128((__m128i*)&dst[i], out);
-  }
-  // Fall-back to C-version for left-overs.
-  if (i != num_pixels) {
-    VP8LTransformColorInverse_C(m, src + i, num_pixels - i, dst + i);
-  }
-}
-
-//------------------------------------------------------------------------------
-
-#define ARGB_TO_RGB_SSE41 do {                        \
-  while (num_pixels >= 16) {                          \
-    const __m128i in0 = _mm_loadu_si128(in + 0);      \
-    const __m128i in1 = _mm_loadu_si128(in + 1);      \
-    const __m128i in2 = _mm_loadu_si128(in + 2);      \
-    const __m128i in3 = _mm_loadu_si128(in + 3);      \
-    const __m128i a0 = _mm_shuffle_epi8(in0, perm0);  \
-    const __m128i a1 = _mm_shuffle_epi8(in1, perm1);  \
-    const __m128i a2 = _mm_shuffle_epi8(in2, perm2);  \
-    const __m128i a3 = _mm_shuffle_epi8(in3, perm3);  \
-    const __m128i b0 = _mm_blend_epi16(a0, a1, 0xc0); \
-    const __m128i b1 = _mm_blend_epi16(a1, a2, 0xf0); \
-    const __m128i b2 = _mm_blend_epi16(a2, a3, 0xfc); \
-    _mm_storeu_si128(out + 0, b0);                    \
-    _mm_storeu_si128(out + 1, b1);                    \
-    _mm_storeu_si128(out + 2, b2);                    \
-    in += 4;                                          \
-    out += 3;                                         \
-    num_pixels -= 16;                                 \
-  }                                                   \
-} while (0)
-
-static void ConvertBGRAToRGB_SSE41(const uint32_t* src, int num_pixels,
-                                   uint8_t* dst) {
-  const __m128i* in = (const __m128i*)src;
-  __m128i* out = (__m128i*)dst;
-  const __m128i perm0 = _mm_setr_epi8(2, 1, 0, 6, 5, 4, 10, 9,
-                                      8, 14, 13, 12, -1, -1, -1, -1);
-  const __m128i perm1 = _mm_shuffle_epi32(perm0, 0x39);
-  const __m128i perm2 = _mm_shuffle_epi32(perm0, 0x4e);
-  const __m128i perm3 = _mm_shuffle_epi32(perm0, 0x93);
-
-  ARGB_TO_RGB_SSE41;
-
-  // left-overs
-  if (num_pixels > 0) {
-    VP8LConvertBGRAToRGB_C((const uint32_t*)in, num_pixels, (uint8_t*)out);
-  }
-}
-
-static void ConvertBGRAToBGR_SSE41(const uint32_t* src,
-                                   int num_pixels, uint8_t* dst) {
-  const __m128i* in = (const __m128i*)src;
-  __m128i* out = (__m128i*)dst;
-  const __m128i perm0 = _mm_setr_epi8(0, 1, 2, 4, 5, 6, 8, 9, 10,
-                                      12, 13, 14, -1, -1, -1, -1);
-  const __m128i perm1 = _mm_shuffle_epi32(perm0, 0x39);
-  const __m128i perm2 = _mm_shuffle_epi32(perm0, 0x4e);
-  const __m128i perm3 = _mm_shuffle_epi32(perm0, 0x93);
-
-  ARGB_TO_RGB_SSE41;
-
-  // left-overs
-  if (num_pixels > 0) {
-    VP8LConvertBGRAToBGR_C((const uint32_t*)in, num_pixels, (uint8_t*)out);
-  }
-}
-
-#undef ARGB_TO_RGB_SSE41
-
-//------------------------------------------------------------------------------
-// Entry point
-
-extern void VP8LDspInitSSE41(void);
-
-WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitSSE41(void) {
-  VP8LTransformColorInverse = TransformColorInverse_SSE41;
-  VP8LConvertBGRAToRGB = ConvertBGRAToRGB_SSE41;
-  VP8LConvertBGRAToBGR = ConvertBGRAToBGR_SSE41;
-}
-
-#else  // !WEBP_USE_SSE41
-
-WEBP_DSP_INIT_STUB(VP8LDspInitSSE41)
-
-#endif  // WEBP_USE_SSE41

src/dsp/quant.h

@@ -10,8 +10,6 @@
 #ifndef WEBP_DSP_QUANT_H_
 #define WEBP_DSP_QUANT_H_
 
-#include <string.h>
-
 #include "src/dsp/dsp.h"
 #include "src/webp/types.h"
 
@@ -69,17 +67,4 @@ static WEBP_INLINE int IsFlat(const int16_t* levels, int num_blocks,
 #endif  // defined(WEBP_USE_NEON) && !defined(WEBP_ANDROID_NEON) &&
         // !defined(WEBP_HAVE_NEON_RTCD)
 
-static WEBP_INLINE int IsFlatSource16(const uint8_t* src) {
-  const uint32_t v = src[0] * 0x01010101u;
-  int i;
-  for (i = 0; i < 16; ++i) {
-    if (memcmp(src + 0, &v, 4) || memcmp(src +  4, &v, 4) ||
-        memcmp(src + 8, &v, 4) || memcmp(src + 12, &v, 4)) {
-      return 0;
-    }
-    src += BPS;
-  }
-  return 1;
-}
-
 #endif  // WEBP_DSP_QUANT_H_

src/dsp/rescaler.c

@@ -38,9 +38,8 @@ void WebPRescalerImportRowExpand_C(WebPRescaler* const wrk,
     int x_out = channel;
     // simple bilinear interpolation
     int accum = wrk->x_add;
-    rescaler_t left = (rescaler_t)src[x_in];
-    rescaler_t right =
-        (wrk->src_width > 1) ? (rescaler_t)src[x_in + x_stride] : left;
+    int left = src[x_in];
+    int right = (wrk->src_width > 1) ? src[x_in + x_stride] : left;
     x_in += x_stride;
     while (1) {
       wrk->frow[x_out] = right * wrk->x_add + (left - right) * accum;
@@ -51,7 +50,7 @@ void WebPRescalerImportRowExpand_C(WebPRescaler* const wrk,
         left = right;
         x_in += x_stride;
         assert(x_in < wrk->src_width * x_stride);
-        right = (rescaler_t)src[x_in];
+        right = src[x_in];
         accum += wrk->x_add;
       }
     }
@@ -214,7 +213,7 @@ WEBP_DSP_INIT_FUNC(WebPRescalerDspInit) {
   WebPRescalerImportRowShrink = WebPRescalerImportRowShrink_C;
 
   if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       WebPRescalerDspInitSSE2();
     }
@@ -236,7 +235,7 @@ WEBP_DSP_INIT_FUNC(WebPRescalerDspInit) {
 #endif
   }
 
-#if defined(WEBP_HAVE_NEON)
+#if defined(WEBP_USE_NEON)
   if (WEBP_NEON_OMIT_C_CODE ||
       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
     WebPRescalerDspInitNEON();

src/dsp/ssim.c

@@ -150,7 +150,7 @@ WEBP_DSP_INIT_FUNC(VP8SSIMDspInit) {
 #endif
 
   if (VP8GetCPUInfo != NULL) {
-#if defined(WEBP_HAVE_SSE2)
+#if defined(WEBP_USE_SSE2)
     if (VP8GetCPUInfo(kSSE2)) {
       VP8SSIMDspInitSSE2();
     }