Fix OOB write in BuildHuffmanTable.

First, BuildHuffmanTable is called to check if the data is valid.
If it is and the table is not big enough, more memory is allocated.

This will make sure that valid (but unoptimized because of unbalanced
codes) streams are still decodable.

Bug: chromium:1479274
Change-Id: I31c36dbf3aa78d35ecf38706b50464fd3d375741
(cherry picked from commit 902bc91903)
(cherry picked from commit 2af26267cd)

.gitignore

@@ -20,9 +20,11 @@
 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
@@ -38,4 +40,5 @@ cmake_install.cmake
 .gradle
 /build
 extras/get_disto
+extras/vwebp_sdl
 extras/webp_quality

.mailmap

@@ -1,7 +1,8 @@
-<johann.koenig@duck.com> <johannkoenig@google.com>
+Johann Koenig <johann.koenig@duck.com>
+Johann Koenig <johann.koenig@duck.com> <johannkoenig@google.com>
 Mikołaj Zalewski <mikolajz@google.com>
 Pascal Massimino <pascal.massimino@gmail.com>
-<pascal.massimino@gmail.com> <skal@google.com>
+Pascal Massimino <pascal.massimino@gmail.com> <skal@google.com>
 Vikas Arora <vikasa@google.com>
 <vikasa@google.com> <vikasa@gmail.com>
 <vikasa@google.com> <vikaas.arora@gmail.com>

AUTHORS

@@ -1,14 +1,18 @@
 Contributors:
+- Aidan O'Loan (aidanol at gmail dot com)
+- Alan Browning (browning at google dot com)
 - Charles Munger (clm at google dot com)
+- Cheng Yi (cyi at google dot com)
 - Christian Duvivier (cduvivier at google dot com)
 - Djordje Pesut (djordje dot pesut at imgtec dot com)
 - Hui Su (huisu at google dot com)
 - James Zern (jzern at google dot com)
 - Jan Engelhardt (jengelh at medozas dot de)
 - Jehan (jehan at girinstud dot io)
-- Johann (johann dot koenig at duck dot com)
+- Johann Koenig (johann dot koenig at duck dot com)
 - Jovan Zelincevic (jovan dot zelincevic at imgtec dot com)
 - Jyrki Alakuijala (jyrki at google dot com)
+- Konstantin Ivlev (tomskside at gmail dot com)
 - Lode Vandevenne (lode at google dot com)
 - Lou Quillio (louquillio at google dot com)
 - Mans Rullgard (mans at mansr dot com)
@@ -18,6 +22,7 @@ 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)
@@ -35,4 +40,6 @@ Contributors:
 - Urvang Joshi (urvang at google dot com)
 - Vikas Arora (vikasa at google dot com)
 - Vincent Rabaud (vrabaud at google dot com)
+- Vlad Tsyrklevich (vtsyrklevich at chromium dot org)
 - Yang Zhang (yang dot zhang at arm dot com)
+- Yannis Guyon (yguyon at google dot com)

Android.mk

@@ -85,19 +85,21 @@ dsp_dec_srcs := \
     src/dsp/upsampling_msa.c \
     src/dsp/upsampling_neon.$(NEON) \
     src/dsp/upsampling_sse2.c \
+    src/dsp/upsampling_sse41.c \
     src/dsp/yuv.c \
     src/dsp/yuv_mips32.c \
     src/dsp/yuv_mips_dsp_r2.c \
     src/dsp/yuv_neon.$(NEON) \
     src/dsp/yuv_sse2.c \
+    src/dsp/yuv_sse41.c \
 
 dsp_enc_srcs := \
     src/dsp/cost.c \
     src/dsp/cost_mips32.c \
     src/dsp/cost_mips_dsp_r2.c \
+    src/dsp/cost_neon.$(NEON) \
     src/dsp/cost_sse2.c \
     src/dsp/enc.c \
-    src/dsp/enc_avx2.c \
     src/dsp/enc_mips32.c \
     src/dsp/enc_mips_dsp_r2.c \
     src/dsp/enc_msa.c \
@@ -121,7 +123,6 @@ enc_srcs := \
     src/enc/backward_references_enc.c \
     src/enc/config_enc.c \
     src/enc/cost_enc.c \
-    src/enc/delta_palettization_enc.c \
     src/enc/filter_enc.c \
     src/enc/frame_enc.c \
     src/enc/histogram_enc.c \
@@ -173,7 +174,7 @@ LOCAL_SRC_FILES := \
     $(utils_dec_srcs) \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm
@@ -207,7 +208,7 @@ LOCAL_SRC_FILES := \
     $(utils_enc_srcs) \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm
@@ -230,7 +231,7 @@ include $(CLEAR_VARS)
 LOCAL_SRC_FILES := $(demux_srcs)
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm
@@ -253,7 +254,7 @@ include $(CLEAR_VARS)
 LOCAL_SRC_FILES := $(mux_srcs)
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm

CMakeLists.txt

@@ -1,81 +1,136 @@
-cmake_minimum_required(VERSION 2.8.7)
+cmake_minimum_required(VERSION 3.5)
 
-project(libwebp C)
+project(WebP C)
 
 # Options for coder / decoder executables.
 option(WEBP_ENABLE_SIMD "Enable any SIMD optimization." ON)
-option(WEBP_BUILD_CWEBP "Build the cwebp command line tool." OFF)
-option(WEBP_BUILD_DWEBP "Build the dwebp command line tool." OFF)
-option(WEBP_BUILD_GIF2WEBP "Build the gif2webp conversion tool." OFF)
-option(WEBP_BUILD_IMG2WEBP "Build the img2webp animation tool." OFF)
-option(WEBP_BUILD_WEBPINFO "Build the webpinfo command line tool." OFF)
+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)
+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_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_ENABLE_NEAR_LOSSLESS "Enable near-lossless encoding" ON)
-option(WEBP_EXPERIMENTAL_FEATURES "Build with experimental features." OFF)
-option(WEBP_ENABLE_SWAP_16BIT_CSP "Enable byte swap for 16 bit colorspaces." OFF)
+option(WEBP_NEAR_LOSSLESS "Enable near-lossless encoding" ON)
+option(WEBP_ENABLE_SWAP_16BIT_CSP "Enable byte swap for 16 bit colorspaces."
+       OFF)
+set(WEBP_BITTRACE "0" CACHE STRING "Bit trace mode (0=none, 1=bit, 2=bytes)")
+set_property(CACHE WEBP_BITTRACE PROPERTY STRINGS 0 1 2)
+
+# Option needed for handling Unicode file names on Windows.
+if(WIN32)
+  option(WEBP_UNICODE "Build Unicode executables." ON)
+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)
+  set(WEBP_BUILD_GIF2WEBP OFF)
+  set(WEBP_BUILD_IMG2WEBP OFF)
+  set(WEBP_BUILD_VWEBP OFF)
+  set(WEBP_BUILD_WEBPINFO OFF)
+  set(WEBP_BUILD_WEBPMUX OFF)
+  set(WEBP_BUILD_EXTRAS OFF)
 endif()
 
 set(WEBP_DEP_LIBRARIES)
 set(WEBP_DEP_INCLUDE_DIRS)
 
 if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release" CACHE
-    "Build type: Release, Debug or RelWithDebInfo" STRING FORCE
-  )
+  set(CMAKE_BUILD_TYPE "Release"
+      CACHE "Build type: Release, Debug, MinSizeRel or RelWithDebInfo" STRING
+      FORCE)
 endif()
 
 # Include dependencies.
 include(cmake/deps.cmake)
 include(GNUInstallDirs)
 
-################################################################################
+# ##############################################################################
 # Options.
 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)
+endif()
+
+set(prefix ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix "\$\{prefix\}")
+set(libdir "\$\{prefix\}/lib")
+set(includedir "\$\{prefix\}/include")
+set(PTHREAD_LIBS ${CMAKE_THREAD_LIBS_INIT})
+set(INSTALLED_LIBRARIES)
+
+# ##############################################################################
 # Android only.
 if(ANDROID)
   include_directories(${ANDROID_NDK}/sources/android/cpufeatures)
   add_library(cpufeatures STATIC
-    ${ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c
-  )
+              ${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}
-    ${ANDROID_NDK}/sources/android/cpufeatures
-  )
+      ${ANDROID_NDK}/sources/android/cpufeatures)
   add_definitions(-DHAVE_CPU_FEATURES_H=1)
   set(HAVE_CPU_FEATURES_H 1)
 else()
   set(HAVE_CPU_FEATURES_H 0)
 endif()
 
-################################################################################
-# WebP source files.
-# Read the Makefile.am to get the source files.
+function(configure_pkg_config FILE)
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${FILE}.in"
+                 "${CMAKE_CURRENT_BINARY_DIR}/${FILE}")
 
-# We expect the Makefiles to define the sources as defined in
-# the first regex. E.g.:
-# libimagedec_la_SOURCES  = image_dec.c image_dec.h
+  if(HAVE_MATH_LIBRARY)
+    # MSVC doesn't have libm
+    file(READ ${CMAKE_CURRENT_BINARY_DIR}/${FILE} data)
+    string(REPLACE "-lm" "" data ${data})
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${FILE} ${data})
+  endif()
+
+  install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/${FILE}"
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+  )
+endfunction()
+
+# ##############################################################################
+# WebP source files. Read the Makefile.am to get the source files.
+
+# We expect the Makefiles to define the sources as defined in the first regex.
+# E.g.: libimagedec_la_SOURCES  = image_dec.c image_dec.h
 function(parse_Makefile_am FOLDER VAR SRC_REGEX)
   file(READ ${FOLDER}/Makefile.am MAKEFILE_AM)
-  string(REGEX MATCHALL "${SRC_REGEX}_SOURCES[ ]*\\+?=[ ]+[0-9a-z\\._ ]*"
-    FILES_PER_LINE ${MAKEFILE_AM}
-  )
+  string(REGEX MATCHALL
+               "${SRC_REGEX}_SOURCES[ ]*\\+?=[ ]+[0-9a-z\\._ ]*"
+               FILES_PER_LINE
+               ${MAKEFILE_AM})
   set(SRCS ${${VAR}})
   foreach(FILES ${FILES_PER_LINE})
     string(FIND ${FILES} "=" OFFSET)
     math(EXPR OFFSET "${OFFSET} + 2")
-    string(SUBSTRING ${FILES} ${OFFSET} -1 FILES)
+    string(SUBSTRING ${FILES}
+                     ${OFFSET}
+                     -1
+                     FILES)
     if(FILES)
-      string(REGEX MATCHALL "[0-9a-z\\._]+"
-        FILES ${FILES}
-      )
+      string(REGEX MATCHALL
+                   "[0-9a-z\\._]+"
+                   FILES
+                   ${FILES})
       foreach(FILE ${FILES})
         list(APPEND SRCS ${FOLDER}/${FILE})
       endforeach()
@@ -85,16 +140,16 @@ function(parse_Makefile_am FOLDER VAR SRC_REGEX)
 endfunction()
 
 set(WEBP_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
-parse_Makefile_am(${WEBP_SRC_DIR}/dec "WEBP_DEC_SRCS" "")
-parse_Makefile_am(${WEBP_SRC_DIR}/demux "WEBP_DEMUX_SRCS" "")
-parse_Makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_COMMON_SRCS" "COMMON")
-parse_Makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_ENC_SRCS" "ENC")
-parse_Makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_ENC_SRCS" "dsp_[^ ]*")
-parse_Makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_DEC_SRCS" "decode_[^ ]*")
-parse_Makefile_am(${WEBP_SRC_DIR}/enc "WEBP_ENC_SRCS" "")
-parse_Makefile_am(${WEBP_SRC_DIR}/utils "WEBP_UTILS_COMMON_SRCS" "COMMON")
-parse_Makefile_am(${WEBP_SRC_DIR}/utils "WEBP_UTILS_ENC_SRCS" "ENC")
-parse_Makefile_am(${WEBP_SRC_DIR}/utils "WEBP_UTILS_DEC_SRCS" "decode_[^ ]*")
+parse_makefile_am(${WEBP_SRC_DIR}/dec "WEBP_DEC_SRCS" "")
+parse_makefile_am(${WEBP_SRC_DIR}/demux "WEBP_DEMUX_SRCS" "")
+parse_makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_COMMON_SRCS" "COMMON")
+parse_makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_ENC_SRCS" "ENC")
+parse_makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_ENC_SRCS" "dsp_[^ ]*")
+parse_makefile_am(${WEBP_SRC_DIR}/dsp "WEBP_DSP_DEC_SRCS" "decode_[^ ]*")
+parse_makefile_am(${WEBP_SRC_DIR}/enc "WEBP_ENC_SRCS" "")
+parse_makefile_am(${WEBP_SRC_DIR}/utils "WEBP_UTILS_COMMON_SRCS" "COMMON")
+parse_makefile_am(${WEBP_SRC_DIR}/utils "WEBP_UTILS_ENC_SRCS" "ENC")
+parse_makefile_am(${WEBP_SRC_DIR}/utils "WEBP_UTILS_DEC_SRCS" "decode_[^ ]*")
 
 # Remove the files specific to SIMD we don't use.
 foreach(FILE ${WEBP_SIMD_FILES_NOT_TO_INCLUDE})
@@ -102,7 +157,12 @@ foreach(FILE ${WEBP_SIMD_FILES_NOT_TO_INCLUDE})
   list(REMOVE_ITEM WEBP_DSP_DEC_SRCS ${FILE})
 endforeach()
 
-### Define the mandatory libraries.
+# Generate the config.h file.
+configure_file(${CMAKE_CURRENT_LIST_DIR}/cmake/config.h.in
+               ${CMAKE_CURRENT_BINARY_DIR}/src/webp/config.h)
+add_definitions(-DHAVE_CONFIG_H)
+
+# ##############################################################################
 # Build the webpdecoder library.
 if(MSVC)
   # avoid security warnings for e.g., fopen() used in the examples.
@@ -110,257 +170,458 @@ if(MSVC)
 else()
   add_definitions(-Wall)
 endif()
-include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${WEBP_DEP_INCLUDE_DIRS})
+include_directories(${WEBP_DEP_INCLUDE_DIRS})
 add_library(webpdecode OBJECT ${WEBP_DEC_SRCS})
+target_include_directories(webpdecode
+                           PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+                                   ${CMAKE_CURRENT_SOURCE_DIR})
 add_library(webpdspdecode OBJECT ${WEBP_DSP_COMMON_SRCS} ${WEBP_DSP_DEC_SRCS})
-add_library(webputilsdecode OBJECT ${WEBP_UTILS_COMMON_SRCS}
+target_include_directories(webpdspdecode
+                           PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+                                   ${CMAKE_CURRENT_SOURCE_DIR})
+add_library(webputilsdecode
+            OBJECT
+            ${WEBP_UTILS_COMMON_SRCS}
             ${WEBP_UTILS_DEC_SRCS})
-add_library(webpdecoder $<TARGET_OBJECTS:webpdecode>
-  $<TARGET_OBJECTS:webpdspdecode> $<TARGET_OBJECTS:webputilsdecode>)
+target_include_directories(webputilsdecode
+                           PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+                                   ${CMAKE_CURRENT_SOURCE_DIR})
+add_library(webpdecoder
+            $<TARGET_OBJECTS:webpdecode>
+            $<TARGET_OBJECTS:webpdspdecode>
+            $<TARGET_OBJECTS:webputilsdecode>)
 target_link_libraries(webpdecoder ${WEBP_DEP_LIBRARIES})
+target_include_directories(
+  webpdecoder
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}
+  INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+set_target_properties(
+  webpdecoder
+  PROPERTIES PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/decode.h;\
+${CMAKE_CURRENT_SOURCE_DIR}/src/webp/types.h")
+
+configure_pkg_config("src/libwebpdecoder.pc")
 
 # Build the webp library.
 add_library(webpencode OBJECT ${WEBP_ENC_SRCS})
-target_include_directories(
-  webpencode PRIVATE ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}
-                     ${CMAKE_CURRENT_SOURCE_DIR}/src)
-add_library(webpdsp OBJECT ${WEBP_DSP_COMMON_SRCS} ${WEBP_DSP_DEC_SRCS}
+target_include_directories(webpencode
+                           PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+                                   ${CMAKE_CURRENT_SOURCE_DIR})
+add_library(webpdsp
+            OBJECT
+            ${WEBP_DSP_COMMON_SRCS}
+            ${WEBP_DSP_DEC_SRCS}
             ${WEBP_DSP_ENC_SRCS})
-target_include_directories(webpdsp PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+target_include_directories(webpdsp
+                           PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
                                    ${CMAKE_CURRENT_SOURCE_DIR})
-add_library(webputils OBJECT ${WEBP_UTILS_COMMON_SRCS} ${WEBP_UTILS_DEC_SRCS}
+add_library(webputils
+            OBJECT
+            ${WEBP_UTILS_COMMON_SRCS}
+            ${WEBP_UTILS_DEC_SRCS}
             ${WEBP_UTILS_ENC_SRCS})
-target_include_directories(webputils PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+target_include_directories(webputils
+                           PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
                                    ${CMAKE_CURRENT_SOURCE_DIR})
-add_library(webp $<TARGET_OBJECTS:webpdecode> $<TARGET_OBJECTS:webpdsp>
-                 $<TARGET_OBJECTS:webpencode> $<TARGET_OBJECTS:webputils>)
-if(XCODE)
-  libwebp_add_stub_file(webp)
-endif()
+add_library(webp
+            $<TARGET_OBJECTS:webpdecode>
+            $<TARGET_OBJECTS:webpdsp>
+            $<TARGET_OBJECTS:webpencode>
+            $<TARGET_OBJECTS:webputils>)
 target_link_libraries(webp ${WEBP_DEP_LIBRARIES})
-target_include_directories(
-  webp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}
-  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-         $<INSTALL_INTERFACE:include>)
+target_include_directories(webp
+                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+                                   ${CMAKE_CURRENT_BINARY_DIR}
+                           PUBLIC $<INSTALL_INTERFACE:include>)
 set_target_properties(
   webp
   PROPERTIES PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/decode.h;\
 ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/encode.h;\
 ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/types.h")
 
-# Make sure the OBJECT libraries are built with position independent code
-# (it is not ON by default).
-set_target_properties(webpdecode webpdspdecode webputilsdecode
-  webpencode webpdsp webputils PROPERTIES POSITION_INDEPENDENT_CODE ON)
+# Make sure the OBJECT libraries are built with position independent code (it is
+# not ON by default).
+set_target_properties(webpdecode
+                      webpdspdecode
+                      webputilsdecode
+                      webpencode
+                      webpdsp
+                      webputils
+                      PROPERTIES POSITION_INDEPENDENT_CODE ON)
+configure_pkg_config("src/libwebp.pc")
 
 # Build the webp demux library.
 add_library(webpdemux ${WEBP_DEMUX_SRCS})
 target_link_libraries(webpdemux webp)
-target_include_directories(
-  webpdemux PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}
+target_include_directories(webpdemux
+                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+                                   ${CMAKE_CURRENT_BINARY_DIR}
                            PUBLIC $<INSTALL_INTERFACE:include>)
 set_target_properties(
   webpdemux
-  PROPERTIES
-    PUBLIC_HEADER
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/decode.h;\
+  PROPERTIES PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/decode.h;\
 ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/demux.h;\
 ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/mux_types.h;\
 ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/types.h")
 
+configure_pkg_config("src/demux/libwebpdemux.pc")
+
 # Set the version numbers.
 function(parse_version FILE NAME VAR)
   file(READ ${CMAKE_CURRENT_SOURCE_DIR}/src/${FILE} SOURCE_FILE)
-  string(REGEX MATCH "${NAME}_la_LDFLAGS[^\n]* -version-info [0-9:]+" TMP
+  string(REGEX MATCH
+               "${NAME}_la_LDFLAGS[^\n]* -version-info [0-9:]+"
+               TMP
                ${SOURCE_FILE})
-  string(REGEX MATCH "[0-9:]+" TMP ${TMP})
-  string(REGEX REPLACE ":" "." VERSION ${TMP})
+  string(REGEX MATCH
+               "[0-9:]+"
+               TMP
+               ${TMP})
+  string(REGEX
+         REPLACE ":"
+                 "."
+                 VERSION
+                 ${TMP})
   set(${VAR} "${VERSION}" PARENT_SCOPE)
 endfunction()
 parse_version(Makefile.am webp WEBP_WEBP_SOVERSION)
-set_target_properties(webp PROPERTIES VERSION ${PACKAGE_VERSION}
-  SOVERSION ${WEBP_WEBP_SOVERSION})
+set_target_properties(webp
+                      PROPERTIES VERSION
+                                 ${PACKAGE_VERSION}
+                                 SOVERSION
+                                 ${WEBP_WEBP_SOVERSION})
 parse_version(Makefile.am webpdecoder WEBP_DECODER_SOVERSION)
-set_target_properties(webpdecoder PROPERTIES VERSION ${PACKAGE_VERSION}
-  SOVERSION ${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})
+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\\.]+\\]"
+             TMP
+             ${CONFIGURE_FILE})
+string(REGEX MATCH
+             "[0-9\\.]+"
+             PROJECT_VERSION
+             ${TMP})
 
 # Define the libraries to install.
-set(INSTALLED_LIBRARIES webpdecoder webp webpdemux)
+list(APPEND INSTALLED_LIBRARIES webpdecoder webp webpdemux)
 
-### Deal with SIMD.
-# Change the compile flags for SIMD files we use.
+# 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)
 math(EXPR WEBP_SIMD_FILES_TO_INCLUDE_RANGE
-  "${WEBP_SIMD_FILES_TO_INCLUDE_LENGTH}-1"
-)
+     "${WEBP_SIMD_FILES_TO_INCLUDE_LENGTH}-1")
 
 foreach(I_FILE RANGE ${WEBP_SIMD_FILES_TO_INCLUDE_RANGE})
   list(GET WEBP_SIMD_FILES_TO_INCLUDE ${I_FILE} FILE)
   list(GET WEBP_SIMD_FLAGS_TO_INCLUDE ${I_FILE} SIMD_COMPILE_FLAG)
-  set_source_files_properties(${FILE} PROPERTIES
-    COMPILE_FLAGS ${SIMD_COMPILE_FLAG}
-  )
+  set_source_files_properties(${FILE}
+                              PROPERTIES
+                              COMPILE_FLAGS
+                              ${SIMD_COMPILE_FLAG})
 endforeach()
 
-# Build the executables if asked for.
-if(WEBP_BUILD_CWEBP OR WEBP_BUILD_DWEBP OR
-   WEBP_BUILD_GIF2WEBP OR WEBP_BUILD_IMG2WEBP OR WEBP_BUILD_WEBP_JS)
-  # Example utility library.
-  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 ${EXAMPLEUTIL_SRCS})
+if(WEBP_BUILD_GIF2WEBP AND NOT GIF_FOUND)
+  set(WEBP_BUILD_GIF2WEBP OFF)
+endif()
 
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEIOUTILS_SRCS"
+if(WEBP_BUILD_ANIM_UTILS AND NOT GIF_FOUND)
+  set(WEBP_BUILD_ANIM_UTILS OFF)
+endif()
+
+# Build the executables if asked for.
+if(WEBP_BUILD_ANIM_UTILS
+   OR WEBP_BUILD_CWEBP
+   OR WEBP_BUILD_DWEBP
+   OR WEBP_BUILD_GIF2WEBP
+   OR WEBP_BUILD_IMG2WEBP
+   OR WEBP_BUILD_VWEBP)
+  # Example utility library.
+  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)
+  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 ${IMAGEIOUTILS_SRCS})
+  add_library(imageioutil STATIC ${IMAGEIOUTILS_SRCS})
   target_link_libraries(imageioutil webp)
 
   # Image-decoding utility library.
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEDEC_SRCS"
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEDEC_SRCS"
                     "imagedec_[^ ]*")
-  add_library(imagedec ${IMAGEDEC_SRCS})
-  target_link_libraries(imagedec imageioutil webp ${WEBP_DEP_IMG_LIBRARIES})
+  add_library(imagedec STATIC ${IMAGEDEC_SRCS})
+  target_link_libraries(imagedec
+                        imageioutil
+                        webpdemux
+                        webp
+                        ${WEBP_DEP_IMG_LIBRARIES})
 
   # Image-encoding utility library.
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEENC_SRCS"
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEENC_SRCS"
                     "imageenc_[^ ]*")
-  add_library(imageenc ${IMAGEENC_SRCS})
-  target_link_libraries(imageenc webp)
+  add_library(imageenc STATIC ${IMAGEENC_SRCS})
+  target_link_libraries(imageenc imageioutil webp)
 
-  set_property(TARGET exampleutil imageioutil imagedec imageenc
-    PROPERTY INCLUDE_DIRECTORIES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}/src)
+  set_property(TARGET exampleutil
+                      imageioutil
+                      imagedec
+                      imageenc
+               PROPERTY INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/src
+                        ${CMAKE_CURRENT_BINARY_DIR}/src)
 endif()
 
 if(WEBP_BUILD_DWEBP)
   # dwebp
-  include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS})
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "DWEBP_SRCS"
-    "dwebp")
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "DWEBP_SRCS" "dwebp")
   add_executable(dwebp ${DWEBP_SRCS})
-  target_link_libraries(dwebp exampleutil imagedec imageenc webpdecoder)
-  install(TARGETS dwebp RUNTIME DESTINATION bin)
-  set_property(TARGET dwebp PROPERTY INCLUDE_DIRECTORIES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}/src)
+  target_link_libraries(dwebp exampleutil imagedec imageenc)
+  target_include_directories(dwebp PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
+  install(TARGETS dwebp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 endif()
 
 if(WEBP_BUILD_CWEBP)
   # cwebp
-  include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS})
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "CWEBP_SRCS"
-    "cwebp")
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "CWEBP_SRCS" "cwebp")
   add_executable(cwebp ${CWEBP_SRCS})
   target_link_libraries(cwebp exampleutil imagedec webp)
-  install(TARGETS cwebp RUNTIME DESTINATION bin)
-  set_property(TARGET cwebp PROPERTY INCLUDE_DIRECTORIES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}/src)
-endif()
-
-if(WEBP_BUILD_GIF2WEBP AND NOT GIF_FOUND)
-  unset(WEBP_BUILD_GIF2WEBP CACHE)
+  target_include_directories(cwebp PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
+  install(TARGETS cwebp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 endif()
 
 if(WEBP_BUILD_GIF2WEBP OR WEBP_BUILD_IMG2WEBP)
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/src/mux "WEBP_MUX_SRCS"
-    "")
-  add_library(webpmux ${WEBP_MUX_SRCS})
-  target_link_libraries(webpmux webp)
+  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})
   parse_version(mux/Makefile.am webpmux WEBP_MUX_SOVERSION)
-  set_target_properties(webpmux PROPERTIES VERSION ${PACKAGE_VERSION}
-    SOVERSION ${WEBP_MUX_SOVERSION})
-  set_target_properties(
-    webpmux
-    PROPERTIES PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/mux.h;\
+  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;\
 ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/mux_types.h;\
 ${CMAKE_CURRENT_SOURCE_DIR}/src/webp/types.h;")
-  list(APPEND INSTALLED_LIBRARIES webpmux)
+  set_target_properties(libwebpmux PROPERTIES OUTPUT_NAME webpmux)
+  list(APPEND INSTALLED_LIBRARIES libwebpmux)
+  configure_pkg_config("src/mux/libwebpmux.pc")
 endif()
 
 if(WEBP_BUILD_GIF2WEBP)
   # gif2webp
   include_directories(${WEBP_DEP_GIF_INCLUDE_DIRS})
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "GIF2WEBP_SRCS"
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "GIF2WEBP_SRCS"
                     "gif2webp")
   add_executable(gif2webp ${GIF2WEBP_SRCS})
-  target_link_libraries(gif2webp exampleutil imageioutil webp webpmux
+  target_link_libraries(gif2webp
+                        exampleutil
+                        imageioutil
+                        webp
+                        libwebpmux
                         ${WEBP_DEP_GIF_LIBRARIES})
-  install(TARGETS gif2webp RUNTIME DESTINATION bin)
-  set_property(TARGET gif2webp PROPERTY INCLUDE_DIRECTORIES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}/src)
+  target_include_directories(gif2webp PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
+  install(TARGETS gif2webp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 endif()
 
 if(WEBP_BUILD_IMG2WEBP)
   # img2webp
   include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS})
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "IMG2WEBP_SRCS"
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "IMG2WEBP_SRCS"
                     "img2webp")
   add_executable(img2webp ${IMG2WEBP_SRCS})
-  target_link_libraries(img2webp exampleutil imagedec imageioutil webp webpmux)
-  install(TARGETS img2webp RUNTIME DESTINATION bin)
-  set_property(TARGET img2webp PROPERTY INCLUDE_DIRECTORIES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}/src)
+  target_link_libraries(img2webp
+                        exampleutil
+                        imagedec
+                        imageioutil
+                        webp
+                        libwebpmux)
+  target_include_directories(img2webp PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
+  install(TARGETS img2webp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+endif()
+
+if(WEBP_BUILD_VWEBP)
+  # vwebp
+  find_package(GLUT)
+  if(GLUT_FOUND)
+    include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS})
+    parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "VWEBP_SRCS" "vwebp")
+    add_executable(vwebp ${VWEBP_SRCS})
+    target_link_libraries(vwebp
+                          ${OPENGL_LIBRARIES}
+                          exampleutil
+                          ${GLUT_glut_LIBRARY}
+                          imageioutil
+                          webp
+                          webpdemux)
+    target_include_directories(vwebp
+                               PRIVATE ${GLUT_INCLUDE_DIR}
+                                       ${CMAKE_CURRENT_BINARY_DIR}/src
+                                       ${OPENGL_INCLUDE_DIR})
+    install(TARGETS vwebp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+    if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+      check_c_compiler_flag("-Wno-deprecated-declarations" HAS_NO_DEPRECATED)
+      if(HAS_NO_DEPRECATED)
+        target_compile_options(vwebp PRIVATE "-Wno-deprecated-declarations")
+      endif()
+    endif()
+  endif()
 endif()
 
 if(WEBP_BUILD_WEBPINFO)
   # webpinfo
   include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS})
-  parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "WEBPINFO_SRCS"
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "WEBPINFO_SRCS"
                     "webpinfo")
   add_executable(webpinfo ${WEBPINFO_SRCS})
   target_link_libraries(webpinfo exampleutil imageioutil)
-  install(TARGETS webpinfo RUNTIME DESTINATION bin)
-  set_property(TARGET webpinfo PROPERTY INCLUDE_DIRECTORIES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}/src)
+  target_include_directories(webpinfo PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
+  install(TARGETS webpinfo RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+endif()
+
+if(WEBP_BUILD_WEBPMUX)
+  # webpmux
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "WEBPMUX_SRCS"
+                    "webpmux")
+  add_executable(webpmux ${WEBPMUX_SRCS})
+  target_link_libraries(webpmux exampleutil imageioutil libwebpmux webp)
+  target_include_directories(webpmux PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
+  install(TARGETS webpmux RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+endif()
+
+if(WEBP_BUILD_EXTRAS)
+  set(EXTRAS_MAKEFILE "${CMAKE_CURRENT_SOURCE_DIR}/extras")
+  parse_makefile_am(${EXTRAS_MAKEFILE} "WEBP_EXTRAS_SRCS" "libwebpextras_la")
+  parse_makefile_am(${EXTRAS_MAKEFILE} "GET_DISTO_SRCS" "get_disto")
+  parse_makefile_am(${EXTRAS_MAKEFILE} "WEBP_QUALITY_SRCS" "webp_quality")
+  parse_makefile_am(${EXTRAS_MAKEFILE} "VWEBP_SDL_SRCS" "vwebp_sdl")
+
+  # get_disto
+  add_executable(get_disto ${GET_DISTO_SRCS})
+  target_link_libraries(get_disto imagedec)
+  target_include_directories(get_disto
+                             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})
+  install(TARGETS webp_quality RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+  # vwebp_sdl
+  find_package(SDL)
+  if(SDL_FOUND)
+    add_executable(vwebp_sdl ${VWEBP_SDL_SRCS})
+    target_link_libraries(vwebp_sdl ${SDL_LIBRARY} imageioutil webp)
+    target_include_directories(vwebp_sdl
+                               PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+                                       ${CMAKE_CURRENT_SOURCE_DIR}/src
+                                       ${CMAKE_CURRENT_BINARY_DIR}
+                                       ${CMAKE_CURRENT_BINARY_DIR}/src
+                                       ${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)
   # JavaScript version
-  add_executable(webp_js
-                 ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
+  add_executable(webp_js ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
   target_link_libraries(webp_js webpdecoder SDL)
+  target_include_directories(webp_js PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
   set(WEBP_HAVE_SDL 1)
-  set_target_properties(webp_js PROPERTIES LINK_FLAGS
-      "-s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0")
+  set_target_properties(
+    webp_js
+    PROPERTIES LINK_FLAGS
+               "-s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0 \
+       -s EXTRA_EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
   set_target_properties(webp_js PROPERTIES OUTPUT_NAME webp)
   target_compile_definitions(webp_js PUBLIC EMSCRIPTEN WEBP_HAVE_SDL)
 
   # WASM version
-  add_executable(webp_wasm
-                 ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
+  add_executable(webp_wasm ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
   target_link_libraries(webp_wasm webpdecoder SDL)
-  set_target_properties(webp_wasm PROPERTIES LINK_FLAGS
-      "-s WASM=1 -s 'BINARYEN_METHOD=\"native-wasm\"' \
-      -s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0")
+  target_include_directories(webp_wasm PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+  set_target_properties(
+    webp_wasm
+    PROPERTIES LINK_FLAGS "-s WASM=1 \
+       -s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0 \
+       -s EXTRA_EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
   target_compile_definitions(webp_wasm PUBLIC EMSCRIPTEN WEBP_HAVE_SDL)
 
-  target_compile_definitions(webpdecoder PUBLIC EMSCRIPTEN)
+  target_compile_definitions(webpdspdecode PUBLIC EMSCRIPTEN)
 endif()
 
-# Generate the config.h file.
-configure_file(${CMAKE_CURRENT_LIST_DIR}/cmake/config.h.in
-  ${CMAKE_CURRENT_BINARY_DIR}/src/webp/config.h)
-add_definitions(-DHAVE_CONFIG_H)
-# The webp folder is included as we reference config.h as
-# ../webp/config.h or webp/config.h
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
+if(WEBP_BUILD_ANIM_UTILS)
+  # anim_diff
+  include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS} ${WEBP_DEP_GIF_INCLUDE_DIRS})
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "ANIM_DIFF_SRCS"
+                    "anim_diff")
+  add_executable(anim_diff ${ANIM_DIFF_SRCS})
+  target_link_libraries(anim_diff
+                        exampleutil
+                        imagedec
+                        imageenc
+                        imageioutil
+                        webp
+                        libwebpmux
+                        webpdemux
+                        ${WEBP_DEP_GIF_LIBRARIES})
+  target_include_directories(anim_diff PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
+
+  # anim_dump
+  include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS} ${WEBP_DEP_GIF_INCLUDE_DIRS})
+  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "ANIM_DUMP_SRCS"
+                    "anim_dump")
+  add_executable(anim_dump ${ANIM_DUMP_SRCS})
+  target_link_libraries(anim_dump
+                        exampleutil
+                        imagedec
+                        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.
-install(
-  TARGETS ${INSTALLED_LIBRARIES}
-  EXPORT WebPTargets
+include(GNUInstallDirs)
+install(TARGETS ${INSTALLED_LIBRARIES}
+        EXPORT ${PROJECT_NAME}Targets
         PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/webp
         INCLUDES
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-set(ConfigPackageLocation ${CMAKE_INSTALL_DATADIR}/WebP/cmake/)
-install(EXPORT WebPTargets NAMESPACE WebP::
+set(ConfigPackageLocation ${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/cmake/)
+install(EXPORT ${PROJECT_NAME}Targets
+        NAMESPACE ${PROJECT_NAME}::
         DESTINATION ${ConfigPackageLocation})
 
 # Create the CMake version file.
@@ -368,29 +629,37 @@ include(CMakePackageConfigHelpers)
 write_basic_package_version_file(
   "${CMAKE_CURRENT_BINARY_DIR}/WebPConfigVersion.cmake"
   VERSION ${PACKAGE_VERSION}
-  COMPATIBILITY AnyNewerVersion
-)
+  COMPATIBILITY AnyNewerVersion)
 
 # Create the Config file.
 include(CMakePackageConfigHelpers)
-set(ConfigPackageLocation share/WebP/cmake/)
 configure_package_config_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/cmake/WebPConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/WebPConfig.cmake
-  INSTALL_DESTINATION ${ConfigPackageLocation}
-  PATH_VARS CMAKE_INSTALL_INCLUDEDIR)
+  INSTALL_DESTINATION
+  ${ConfigPackageLocation})
 
 # Install the generated CMake files.
-install(
-  FILES "${CMAKE_CURRENT_BINARY_DIR}/WebPConfigVersion.cmake"
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/WebPConfigVersion.cmake"
               "${CMAKE_CURRENT_BINARY_DIR}/WebPConfig.cmake"
-  DESTINATION ${ConfigPackageLocation}
-)
+        DESTINATION ${ConfigPackageLocation})
 
 # Install the man pages.
-set(MAN_PAGES cwebp.1 dwebp.1 gif2webp.1 img2webp.1 vwebp.1 webpmux.1
+set(MAN_PAGES
+    cwebp.1
+    dwebp.1
+    gif2webp.1
+    img2webp.1
+    vwebp.1
+    webpmux.1
     webpinfo.1)
-set(EXEC_BUILDS "CWEBP" "DWEBP" "GIF2WEBP" "IMG2WEBP" "VWEBP" "WEBPMUX"
+set(EXEC_BUILDS
+    "CWEBP"
+    "DWEBP"
+    "GIF2WEBP"
+    "IMG2WEBP"
+    "VWEBP"
+    "WEBPMUX"
     "WEBPINFO")
 list(LENGTH MAN_PAGES MAN_PAGES_LENGTH)
 math(EXPR MAN_PAGES_RANGE "${MAN_PAGES_LENGTH} - 1")
@@ -400,8 +669,7 @@ foreach(I_MAN RANGE ${MAN_PAGES_RANGE})
   if(WEBP_BUILD_${EXEC_BUILD})
     list(GET MAN_PAGES ${I_MAN} MAN_PAGE)
     install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man/${MAN_PAGE}
-      DESTINATION ${CMAKE_INSTALL_PREFIX}/share/man/man1
-      COMPONENT doc
-    )
+            DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
+            COMPONENT doc)
   endif()
 endforeach()

ChangeLog

@@ -1,9 +1,294 @@
+7f006436 Makefile.vc: fix webp_quality.exe link
+c074c653 update NEWS
+30f09551 bump version to 1.1.0
+a76694a1 update AUTHORS
+6e3ef7b3 extras: fix WEBP_SWAP_16BIT_CSP check
+47178dbd extras: add WebPUnmultiplyARGB() convenience function
+22cbae33 idec_dec: fix 0 offset of NULL pointer
+290dd0b4 muxread: fix 0 offset of NULL pointer
+0df474ac Merge "lossless_(enc_|)sse2: avoid offsetting a NULL pointer"
+c6b75a19 lossless_(enc_|)sse2: avoid offsetting a NULL pointer
+295e5e38 fix UBSAN warning
+e2575e05 DC8_NEON,aarch64: use vaddv
+b0e09e34 dec_neon: Fix build failure under some toolchains
+cf0e903c dsp/lossless: Fix non gcc ARM builds
+bb7bc40b Remove ubsan errors.
+78881b76 CMake: fix GLUT library link
+9f750f7a cmake: fix BUILD_SHARED_LIBS build on mac
+17850e74 libwebp: Remove char-subscripts warning in pnmdec.c
+2fa2552d Merge "Expose WebPMalloc() in addition to WebPFree()"
+a4df4aae Expose WebPMalloc() in addition to WebPFree()
+853ea3d8 imageio/tiff: Return error before allocating bad tile size
+af650c0b Fix a Wxor-used-as-pow false positive
+601ef17c libwebp.py: update to swig 3.0.12
+0e48d889 bugfix: last alpha rows were incorrectly decoded
+24d2ccb4 webp: Fix imageio ReadPNM() TUPLTYPE
+fab8f9cf cosmetics: normalize '*' association
+94138e0e update .gitignore
+0fe1a89d update ChangeLog (tag: v1.0.3-rc1, tag: v1.0.3)
+2ad0916d update NEWS
+1287362b bump version to 1.0.3
+7b968cc2 update AUTHORS
+9d6988f4 Fix the oscillating prediction problem at low quality
+312f74d0 makefile.unix: allow *_LIBS to be overridden w/EXTRA_LIBS
+92dbf237 filters_sse2,cosmetics: shorten some long lines
+a277d197 filters_sse2.c: quiet integer sanitizer warnings
+804540f1 Fix cpufeatures in CMake.
+bf00c15b Add CMake option for bittrace.
+a788b498 filters_sse2.c: quiet integer sanitizer warnings
+e6a92c5e filters.c: quiet integer sanitizer warnings
+ec1cc40a lossless.c: remove U32 -> S8 conversion warnings
+1106478f remove conversion U32 -> S8 warnings
+812a6b49 lossless_enc: fix some conversion warning
+4627c1c9 lossless_enc,TransformColorBlue: quiet uint32_t conv warning
+c84673a6 lossless_enc_sse{2,41}: quiet signed conv warnings
+776a7757 dec_sse2: quiet signed conv warnings
+bd39c063 Merge "thread_utils: release mutex before signaling"
+0550576f Merge "(alpha_processing,enc}_sse2: quiet signed conv warnings"
+6682f2c4 thread_utils: release mutex before signaling
+e78dea75 (alpha_processing,enc}_sse2: quiet signed conv warnings
+9acf18ba iosbuild.sh: add WebP{Demux,Mux}.framework
+b9be7e65 vwebp: remove the -fit option (and make it default)
+1394a2bb Merge "README.webp_js: update Emscripten.cmake note"
+dd3e7f8a README.webp_js: update Emscripten.cmake note
+32cf8801 predictor_enc,GetBestGreenRedToBlue: quiet implicit conv warnings
+e1c8acb5 Merge "vwebp: add a -fit option"
+cbd23dd5 vwebp: add a -fit option
+2e672351 bit_writer_utils,Flush: quiet implicit conversion warnings
+1326988d swig: update libwebp_python_wrap.c
+0e7f8548 update generated swig files
+17ed1438 Merge "PutLE{16,24}: quiet implicit conversion warnings"
+24686538 PutLE{16,24}: quiet implicit conversion warnings
+153bb3a0 fix some clang-7 warnings:
+ab2dc893 Rescaler: fix rounding error
+aa65f89a HistogramCombineStochastic: fix free of uninit value
+af0bac64 Merge "encode.h: mention 'exact' default in WebPEncodeLossless*"
+6d2e11ec encode.h: mention 'exact' default in WebPEncodeLossless*
+8c3f04fe AndroidCPUInfo: reorder terms in conditional
+fcfd9c71 BitTrace: if BITTRACE is > 0, record and print syntax bits used
+067031ea Speedups for unused Huffman groups.
+01ac46ba libwebp: Display "libjpeg error:" in imageio/jpegdec
+d9a662e1 WebPRescalerGetScaledDimensions: round scaled dimension up
+62eb3f08 libwebp: Fix missing '{' in README
+e05f785a Merge "unicode,INIT_WARGV: add missing cast"
+63c9a69f tag the VP8LHashPix() function for potential uint roll-over
+2b7214ab unicode,INIT_WARGV: add missing cast
+bf424b46 tag the GetPixPairHash64() function for potential uint roll-over
+7d05d6ca Have the color cache computation be u32-bit only.
+6bcf8769 Remove BINARYEN_METHOD in wasm settings.
+2b98df90 update ChangeLog (tag: v1.0.2-rc1, tag: v1.0.2)
+61e372b7 update NEWS
+7ae658a0 bump version to 1.0.2
+51c4907d update AUTHORS
+666bd6c6 man/cwebp.1: refine near-lossless text
+561cdce5 Clarify the doc about GetFeatures.
+aec2cf02 near_lossless: fix fuzzing-detected integer overflow
+928a75de webp: Fix VP8LBitWriterClone() bug
+5173d4ee neon IsFlat
+5b081219 IsFlat: inline when possible
+381b7b54 IsFlat: use int for thresh
+6ed15ea1 fix unprobable leak in webp_sdl.c
+22bbb24e Merge "IsFlat: return int"
+8b3fb238 Merge tag 'v1.0.1'
+f435de95 IsFlat: return int
+41521aed utils.h: only define WEBP_NEED_LOG_TABLE_8BIT when needed
+9f4d4a3f neon: GetResidualCost
+0fd7514b neon: SetResidualCoeffs
+f95a996c Simpler histogram clustering.
+e85d3313 update ChangeLog (tag: v1.0.1-rc2, tag: v1.0.1)
+fa8210e4 Fix pair update in stochastic entropy merging.
+fd198f73 add codereview.settings
+825389ac README.mux: add a reference to the AnimDecoder API
+3be698c3 CMake: fix webp_js compilation
+485ff86f Fix pair update in stochastic entropy merging.
+4cd0582d CMake: fix webp_js compilation
+4cbb4caf update NEWS
+f5a5918d bump version to 1.0.1
+d61385db Speed-up: Make sure we only initialize histograms when needed.
+6752904b Speed-up: Make sure we only initialize histograms when needed.
+0c570316 update AUTHORS
+301a2dda img2webp: add help note about arguments from a file
+f0abab92 Speedups for empty histograms.
+f2dfd925 Split HistogramAdd to only have the high level logic in C.
+06b7bc7d Fix compilation on windows and clang-cl+ninja.
+b6284d82 img2webp: add help note about arguments from a file
+decf6f6b Speedups for empty histograms.
+dea3e899 Split HistogramAdd to only have the high level logic in C.
+632798ae Merge "Fix compilation on windows and clang-cl+ninja."
+dc1a9518 Merge "libwebp: Unicode command tools on Windows"
+9cf9841b libwebp: Unicode command tools on Windows
+98179495 remove some minor TODOs
+a376e7b9 Fix compilation on windows and clang-cl+ninja.
+cbf82cc0 Remove AVX2 files.
+5030e902 Merge "TIFF decoder: remove unused KINV definition"
+ac543311 Remove a few more useless #defines
+123d3306 TIFF decoder: remove unused KINV definition
+ef1094b0 Merge "- install pkg-config files during the CMake build"
+b911fbc9 libwebp: Remove duplicate GIFDisplayError in anim_util
+eee00b66 - install pkg-config files during the CMake build
+ac3ec8c9 Merge "Clean-up the common sources in dsp."
+3e13da7b Clean-up the common sources in dsp.
+5c395f1d libwebp: cmake-format all
+e7a69729 libwebp: Add extras targets in CMakeLists.txt
+e52485d6 libwebp: Rename macros in webpmux.c
+92dc0f09 clean-up MakeInputImageCopy()
+39952de2 VP8IteratorImport: add missing 'const'
+382af7a2 clean-up WebPBlendAlpha
+14d020f6 libwebp: Use ExUtilGet*() in anim_diff
+0d92ff25 libwebp: remove useless variable in gif2webp
+556cb1b4 Merge "CMake: Set WEBP_BUILD_GIF2WEBP to off"
+da26ee49 CMake: Set WEBP_BUILD_GIF2WEBP to off
+b2a867c0 cwebp: Don't premultiply during -resize if -exact
+637141bc pngdec: fix build w/libpng < 1.4.x
+bc5092b1 pngdec: set memory functions
+50d8345a Fix CMake math library.
+6aa3e8aa Fix math library on Visual Studio.
+d71df4e2 Fix math library finding in CMake.
+de08d727 cosmetics: normalize include guard comment
+009562b4 vwebp: Fix bug when Dispose then NoBlend frames
+423f2579 Fix up CMake to create targets.
+907208f9 Wait for all threads to be done in DecodeRemaining.
+4649b3c4 vwebp: Add background color display option
+78ad57a3 Fix bad glClearColor parameters
+da96d8d9 Allow for a non-initialized alpha decompressor in DoRemap.
+2563db47 fix rescaling rounding inaccuracy
+211f37ee fix endian problems in pattern copy
+5f0f5c07 Make sure partition #0 is read before VP8 data in IDecode.
+de98732b fix GetColorf() bug
+4338cd36 misc fixes in libwebpmux
+e00af13e fix signatures after a9ceda7ff1
+a9ceda7f Speed-up chunk list operations.
+2281bbf6 Merge "Better handling of bogus Huffman codes."
+39cb9aad Better handling of bogus Huffman codes.
+89cc9d37 Merge "fix read-overflow while parsing VP8X chunk"
+95fd6507 fix read-overflow while parsing VP8X chunk
+9e729fe1 Fix VP8IoTeardownHook being called twice on worker sync failure
+29fb8562 Merge "muxread,anmf: fail on multiple image chunks"
+eb82ce76 muxread,anmf: fail on multiple image chunks
+1344a2e9 fix alpha-filtering crash when image width is larger than radius
+be738c6d muxread,ChunkVerifyAndAssign: validate chunk_size
+2c70ad76 muxread,CreateInternal: fix riff size checks
+569001f1 Fix for thread race heap-use-after-free
+c56a02d9 Android.mk: use LOCAL_EXPORT_C_INCLUDES w/public libs
+15795596 CMakeLists.txt,cosmetics: normalize if() formatting
+1a44c233 Merge "cmake: add support for webpmux"
+e9569ad7 Merge "configure,*am,cosmetics: s/WANT_/BUILD_/"
+35c7de6f cmake: add support for webpmux
+0f25e61c WebpToSDL(): fix the return value in case of error
+5d8985de configure,*am,cosmetics: s/WANT_/BUILD_/
+895fd28f Merge "man/Makefile.am: add img2webp.1"
+5cf3e2af man/Makefile.am: add img2webp.1
+2a9de5b9 Add build rules for anim_diff & anim_dump utils.
+71ed73cf fix invalid check for buffer size
+af0e4fbb gif2webp: fix transcode of loop count=65535
+dce5d764 Limit memory allocation when reading invalid Huffman codes.
+f9df0081 Merge "cmake: quiet glut deprecation warnings on OS X"
+dc39b16f webpmux.1: correct grammar
+c7aa1264 cwebp.c: fix a missing \n
+53aa51e9 Merge tag 'v1.0.0'
+698b8844 update ChangeLog (tag: v1.0.0)
+8d510751 webp-container-spec: correct frame duration=0 note
+e6b2164e vwebp: Copy Chrome's behavior w/frame duration == 0
+094b3b28 cmake: quiet glut deprecation warnings on OS X
+71c39a06 webp-container-spec: correct frame duration=0 note
+fd3d5756 vwebp: Copy Chrome's behavior w/frame duration == 0
+b0c966fb Build vwebp from CMake.
+d20b7707 update ChangeLog (tag: v1.0.0-rc3)
+0d5fad46 add WEBP_DSP_INIT / WEBP_DSP_INIT_FUNC
+d77bf512 add WEBP_DSP_INIT / WEBP_DSP_INIT_FUNC
+c1cb86af fix 16b overflow in SSE2
+e577feb7 makefile.unix: add DEBUG flag for compiling w/ debug-symbol
+99be34b3 cwebp,get_disto: fix bpp output
+e122e511 cwebp,get_disto: fix bpp output
+f5565ca8 cmake: Make sure we use near-lossless by default.
+d898dc14 fix bug in WebPImport565: alpha value was not set
+1c8f358d Fix CMake with WASM.
+a0215fb7 webp_js: fix webp_js demo html
+882784b0 update ChangeLog (tag: v1.0.0-rc2)
+2f930e08 Revert "Use proper targets for CMake."
+8165e8fb Use proper targets for CMake.
+3f157dd5 Remove some very hard TODOs.
+abb47760 Merge "Use proper targets for CMake."
+cd758a17 {de,}mux/Makefile.am: add missing headers
+e155dda0 Use proper targets for CMake.
+b892b8ba makefile.unix,dist: use ascii for text output
+64a57d05 add -version option to anim_dump,anim_diff and img2webp
+994be82d Merge "Remove some very hard TODOs."
+4033e1d7 Remove some very hard TODOs.
+fc1b8e3a webp_js: fix webp_js demo html
+15aa48d9 update ChangeLog (tag: v1.0.0-rc1)
+e607dabc update AUTHORS
+38410c08 [CFI] Remove function pointer casts
+978eec25 [CFI] Remove function pointer casts
+c57b2736 bump version to 1.0.0
+cba28853 update NEWS
+c909d531 Merge "remove some deprecation warning on MacOSX"
+217443c7 remove some deprecation warning on MacOSX
+b672bdfa configure: quiet glut deprecation warnings on OS X
+daa9fcaf configure: use sdl-config if available
+dd174cae Merge "imagedec: support metadata reading for WebP image decoding"
+641cedcc imagedec: support metadata reading for WebP image decoding
+065b2ce1 anim_diff: add a couple missing newlines in Help()
+c4cc1147 Merge "gif2webp: force low duration frames to 100ms"
+09333097 gif2webp: force low duration frames to 100ms
+e03f0ec3 sharp_yuv: use 14b fixed-point precision for gamma
+b2db361c image_enc,WebPWritePNG: move locals after setjmp
+74e82ec6 Merge "WebPPictureDistortion: fix big-endian results order"
+645d04ca Merge "cwebp,get_disto: report bpp"
+120f58c3 Merge "lossless*sse2: improve non-const 16-bit vector creation"
+a7fe9412 WebPPictureDistortion: fix big-endian results order
+e26fe066 cwebp,get_disto: report bpp
+9df64e28 Merge changes Id5b4a1a4,Ia20ce844
+8043504f lossless*sse2: improve non-const 16-bit vector creation
+1e3dfc48 Import: extract condition from loop
+3b07d327 Import,RGBA: fix for BigEndian import
+551948e4 Remove unused argument in VP8LBitsEntropy.
+3005237a ReadWebP: fix for big-endian
+499c395a Merge "anim_diff: expose the -max_diff option"
+f69dcd69 Merge "remove WEBP_EXPERIMENTAL_FEATURES"
+07d884d5 anim_diff: expose the -max_diff option
+f4dd9256 remove WEBP_EXPERIMENTAL_FEATURES
+94a8377b extract the command-line parsing helpers to example_util
+fc09e6e2 PNM decoder: prevent unsupported depth=2 PAM case.
+6de58603 MIPS64: Fix defined-but-not-used errors with WEBP_REDUCE_CSP
+cbde5728 gif2webp: add support for reading from stdin
+cf1c5054 Add an SSE4 version of some lossless color transforms.
+45a8b5eb Fix lint error with man page.
+cff38e8f Merge "PNG decoder: handle gAMA chunk"
+59cb1a48 Merge "enable dc error-diffusion always"
+78318b30 PNG decoder: handle gAMA chunk
+664c21dd Merge "remove some TODOs"
+815652de enable dc error-diffusion always
+aec45cec remove some TODOs
+5715dfce fix block-count[] increment in case of large image
+c2d04f3e enable DC error-diffusion always for multi-pass
+96bf07c5 use DC error diffusion for U/V at low-quality
+1c59020b fix missing sse41 targets in makefile.unix
+7a8e814b cosmetics: s/color_space/colorspace/
+05f6fe24 upsampling: rm asserts w/REDUCE_CSP+OMIT_C_CODE
+b4cf5597 Merge "Upsampling SSE2/SSE4 speedup."
+ccbeb32c Makefile.vc: add missing sse41 files
+55403a9a Upsampling SSE2/SSE4 speedup.
+807b53c4 Implement the upsampling/yuv functions in SSE41
+84101a81 Fix wasm WebP compilation
+8bebd2a3 fix warning on MSVC
+a7f93fe3 webpmux: allow reading argument from a file
+b69f18a7 gif2webp.1: fix -loop_compatibility layout
+72d530c0 Merge "fix lossless decoding w/WEBP_REDUCE_SIZE"
+296c7dc4 fix lossless decoding w/WEBP_REDUCE_SIZE
+0d5d029c Merge "ImgIoUtilReadFile: fix file leak upon error"
+ae568ce7 ImgIoUtilReadFile: fix file leak upon error
+796b5a8a Merge tag 'v0.6.1'
+6b7a95fd update ChangeLog (tag: v0.6.1)
 f66955de WEBP_REDUCE_CSP: restrict colorspace support
+1af0df76 Merge "WEBP_REDUCE_CSP: restrict colorspace support"
+6de20df0 WEBP_REDUCE_CSP: restrict colorspace support
 a289d8e7 update ChangeLog (tag: v0.6.1-rc2)
 c10a493c vwebp: disable double buffering on windows & mac
 0d4466c2 webp_to_sdl.c: fix file mode
 1b27bf8b WEBP_REDUCE_SIZE: disable all rescaler code
 126be109 webpinfo: add -version option
+0df22b9e WEBP_REDUCE_SIZE: disable all rescaler code
 9add62b5 bump version to 0.6.1
 d3e26144 update NEWS
 2edda639 README: add webpinfo section
@@ -279,7 +564,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, 0.6.0)
+50d1a848 update ChangeLog (tag: v0.6.0, origin/0.6.0)
 20a7fea0 extras/Makefile.am: fix libwebpextras.la reference
 415f3ffe update ChangeLog (tag: v0.6.0-rc3)
 3c6d1224 update NEWS
@@ -356,7 +641,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, 0.5.2)
+ece9684f update ChangeLog (tag: v0.5.2-rc2, tag: v0.5.2, origin/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++.
@@ -643,7 +928,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, 0.5.1)
+3d97bb75 update ChangeLog (tag: v0.5.1, origin/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
@@ -837,7 +1122,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, 0.5.0)
+37f04949 update ChangeLog (tag: v0.5.0-rc1, tag: v0.5.0, origin/0.5.0)
 7e7b6ccc faster rgb565/rgb4444/argb output
 4c7f565f update NEWS
 1f62b6b2 update AUTHORS
@@ -1621,7 +1906,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, 0.4.1)
+8af27718 update ChangeLog (tag: v0.4.1, origin/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)
@@ -2006,7 +2291,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, 0.4.0)
+68e7901d update ChangeLog (tag: v0.4.0-rc1, tag: v0.4.0, origin/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
@@ -2782,7 +3067,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, 0.2.0)
+74fefc8c Update ChangeLog (tag: v0.2.1, origin/0.2.0)
 92f8059c Rename some chunks:
 3bb4bbeb Merge "Mux API change:"
 d0c79f05 Mux API change:

Makefile.am

@@ -2,7 +2,7 @@ ACLOCAL_AMFLAGS = -I m4
 SUBDIRS = src imageio man
 EXTRA_DIST = COPYING autogen.sh
 
-if WANT_EXTRAS
+if BUILD_EXTRAS
   SUBDIRS += extras
 endif
 

Makefile.vc

@@ -53,11 +53,6 @@ OUTDIR = ..\obj\
 OUTDIR = $(OBJDIR)
 !ENDIF
 
-!IF "$(HAVE_AVX2)" == "1"
-CFLAGS = $(CFLAGS) /DWEBP_HAVE_AVX2
-AVX2_FLAGS = /arch:AVX2
-!ENDIF
-
 ##############################################################
 # Runtime library configuration
 !IF "$(RTLIBCFG)" == "static"
@@ -134,12 +129,16 @@ LIBWEBP_PDBNAME = $(DIROBJ)\$(LIBWEBP_BASENAME)_dll.pdb
 CFGSET = TRUE
 !ENDIF
 
+!IF "$(UNICODE)" == "1"
+CFLAGS = $(CFLAGS) /D_UNICODE /DUNICODE
+!ENDIF
+
 #######################
 # Usage
 #
 !IF "$(CFGSET)" == "FALSE"
 !MESSAGE Usage: nmake /f Makefile.vc [CFG=<config>]
-!MESSAGE .          [OBJDIR=<path>] [RTLIBCFG=<rtlib>] [<target>]
+!MESSAGE .          [OBJDIR=<path>] [RTLIBCFG=<rtlib>] [UNICODE=1] [<target>]
 !MESSAGE
 !MESSAGE where <config> is one of:
 !MESSAGE -  release-static                - release static library
@@ -227,19 +226,21 @@ DSP_DEC_OBJS = \
     $(DIROBJ)\dsp\upsampling_msa.obj \
     $(DIROBJ)\dsp\upsampling_neon.obj \
     $(DIROBJ)\dsp\upsampling_sse2.obj \
+    $(DIROBJ)\dsp\upsampling_sse41.obj \
     $(DIROBJ)\dsp\yuv.obj \
     $(DIROBJ)\dsp\yuv_mips32.obj \
     $(DIROBJ)\dsp\yuv_mips_dsp_r2.obj \
     $(DIROBJ)\dsp\yuv_neon.obj \
     $(DIROBJ)\dsp\yuv_sse2.obj \
+    $(DIROBJ)\dsp\yuv_sse41.obj \
 
 DSP_ENC_OBJS = \
     $(DIROBJ)\dsp\cost.obj \
     $(DIROBJ)\dsp\cost_mips32.obj \
     $(DIROBJ)\dsp\cost_mips_dsp_r2.obj \
+    $(DIROBJ)\dsp\cost_neon.obj \
     $(DIROBJ)\dsp\cost_sse2.obj \
     $(DIROBJ)\dsp\enc.obj \
-    $(DIROBJ)\dsp\enc_avx2.obj \
     $(DIROBJ)\dsp\enc_mips32.obj \
     $(DIROBJ)\dsp\enc_mips_dsp_r2.obj \
     $(DIROBJ)\dsp\enc_msa.obj \
@@ -285,7 +286,6 @@ ENC_OBJS = \
     $(DIROBJ)\enc\backward_references_enc.obj \
     $(DIROBJ)\enc\config_enc.obj \
     $(DIROBJ)\enc\cost_enc.obj \
-    $(DIROBJ)\enc\delta_palettization_enc.obj \
     $(DIROBJ)\enc\filter_enc.obj \
     $(DIROBJ)\enc\frame_enc.obj \
     $(DIROBJ)\enc\histogram_enc.obj \
@@ -367,9 +367,11 @@ $(DIRBIN)\anim_dump.exe: $(EX_GIF_DEC_OBJS) $(LIBWEBPDEMUX) $(LIBWEBP)
 $(DIRBIN)\anim_dump.exe: $(IMAGEIO_ENC_OBJS)
 $(DIRBIN)\cwebp.exe: $(DIROBJ)\examples\cwebp.obj $(IMAGEIO_DEC_OBJS)
 $(DIRBIN)\cwebp.exe: $(IMAGEIO_UTIL_OBJS)
+$(DIRBIN)\cwebp.exe: $(LIBWEBPDEMUX)
 $(DIRBIN)\dwebp.exe: $(DIROBJ)\examples\dwebp.obj $(IMAGEIO_DEC_OBJS)
 $(DIRBIN)\dwebp.exe: $(IMAGEIO_ENC_OBJS)
 $(DIRBIN)\dwebp.exe: $(IMAGEIO_UTIL_OBJS)
+$(DIRBIN)\dwebp.exe: $(LIBWEBPDEMUX)
 $(DIRBIN)\gif2webp.exe: $(DIROBJ)\examples\gif2webp.obj $(EX_GIF_DEC_OBJS)
 $(DIRBIN)\gif2webp.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS) $(LIBWEBPMUX)
 $(DIRBIN)\gif2webp.exe: $(LIBWEBP)
@@ -382,26 +384,30 @@ $(DIRBIN)\webpmux.exe: $(DIROBJ)\examples\webpmux.obj $(LIBWEBPMUX)
 $(DIRBIN)\webpmux.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS) $(LIBWEBP)
 $(DIRBIN)\img2webp.exe: $(DIROBJ)\examples\img2webp.obj $(LIBWEBPMUX)
 $(DIRBIN)\img2webp.exe: $(IMAGEIO_DEC_OBJS)
-$(DIRBIN)\img2webp.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS) $(LIBWEBP)
+$(DIRBIN)\img2webp.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)
+$(DIRBIN)\img2webp.exe: $(LIBWEBPDEMUX) $(LIBWEBP)
 $(DIRBIN)\get_disto.exe: $(DIROBJ)\extras\get_disto.obj
-$(DIRBIN)\get_disto.exe: $(IMAGEIO_DEC_OBJS) $(IMAGEIO_UTIL_OBJS) $(LIBWEBP)
+$(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) $(LIBWEBP)
+$(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)\webpinfo.exe: $(DIROBJ)\examples\webpinfo.obj
 $(DIRBIN)\webpinfo.exe: $(IMAGEIO_DEC_OBJS)
-$(DIRBIN)\webpinfo.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS) $(LIBWEBP)
+$(DIRBIN)\webpinfo.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)
+$(DIRBIN)\webpinfo.exe: $(LIBWEBPDEMUX) $(LIBWEBP)
 
 $(OUT_EXAMPLES): $(EX_UTIL_OBJS) $(LIBWEBP)
 $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS): $(OUTPUT_DIRS)
 $(IMAGEIO_DEC_OBJS) $(IMAGEIO_ENC_OBJS) $(EXTRAS_OBJS): $(OUTPUT_DIRS)
 !ENDIF  # ARCH == ARM
 
-experimental:
-	$(MAKE) /f Makefile.vc \
-	    CFG=$(CFG) \
-	    CFLAGS="$(CFLAGS) /DWEBP_EXPERIMENTAL_FEATURES" /$(MAKEFLAGS)
-
 $(LIBWEBPDECODER): $(LIBWEBPDECODER_OBJS)
 $(LIBWEBP): $(LIBWEBP_OBJS)
 $(LIBWEBPMUX): $(LIBWEBPMUX_OBJS)
@@ -453,9 +459,6 @@ $(DIROBJ)\$(DLLINC):
 .SUFFIXES: .c .obj .res .exe
 # File-specific flag builds. Note batch rules take precedence over wildcards,
 # so for now name each file individually.
-$(DIROBJ)\dsp\enc_avx2.obj: src\dsp\enc_avx2.c
-	$(CC) $(CFLAGS) $(AVX2_FLAGS) /Fd$(LIBWEBP_PDBNAME) /Fo$(DIROBJ)\dsp\ \
-	  src\dsp\$(@B).c
 $(DIROBJ)\examples\anim_diff.obj: examples\anim_diff.c
 	$(CC) $(CFLAGS) /DWEBP_HAVE_GIF /Fd$(LIBWEBP_PDBNAME) \
 	  /Fo$(DIROBJ)\examples\ examples\$(@B).c
@@ -491,15 +494,18 @@ $(DIROBJ)\examples\gifdec.obj: examples\gifdec.c
 {src\utils}.c{$(DIROBJ)\utils}.obj::
 	$(CC) $(CFLAGS) /Fd$(LIBWEBP_PDBNAME) /Fo$(DIROBJ)\utils\ $<
 
+LNKLIBS     = ole32.lib windowscodecs.lib shlwapi.lib
+!IF "$(UNICODE)" == "1"
+LNKLIBS     = $(LNKLIBS) Shell32.lib
+!ENDIF
+
 {$(DIROBJ)\examples}.obj{$(DIRBIN)}.exe:
-	$(LNKEXE) $(LDFLAGS) /OUT:$@ $** \
-	    ole32.lib windowscodecs.lib shlwapi.lib
+	$(LNKEXE) $(LDFLAGS) /OUT:$@ $** $(LNKLIBS)
 	$(MT) -manifest $@.manifest -outputresource:$@;1
 	del $@.manifest
 
 {$(DIROBJ)\extras}.obj{$(DIRBIN)}.exe:
-	$(LNKEXE) $(LDFLAGS) /OUT:$@ $** \
-	    ole32.lib windowscodecs.lib shlwapi.lib
+	$(LNKEXE) $(LDFLAGS) /OUT:$@ $** $(LNKLIBS)
 	$(MT) -manifest $@.manifest -outputresource:$@;1
 	del $@.manifest
 

NEWS

@@ -1,3 +1,56 @@
+- 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
+    support, issue #398)
+  * lossless encoder speedups
+  * lossy encoder speedup on ARM
+  * lossless multi-threaded security fix (chromium:917029)
+
+- 11/2/2018: version 1.0.1
+  This is a binary compatible release.
+  * lossless encoder speedups
+  * big-endian fix for alpha decoding (issue #393)
+  * gif2webp fix for loop count=65535 transcode (issue #382)
+  * further security related hardening in libwebp & libwebpmux
+    (issues #383, #385, #386, #387, #388, #391)
+    (oss-fuzz #9099, #9100, #9105, #9106, #9111, #9112, #9119, #9123, #9170,
+              #9178, #9179, #9183, #9186, #9191, #9364, #9417, #9496, #10349,
+              #10423, #10634, #10700, #10838, #10922, #11021, #11088, #11152)
+  * miscellaneous bug & build fixes (issues #381, #394, #396, #397, #400)
+
+- 4/2/2018: version 1.0.0
+  This is a binary compatible release.
+  * lossy encoder improvements to avoid chroma shifts in various circumstances
+    (issues #308, #340)
+  * big-endian fixes for decode, RGBA import and WebPPictureDistortion
+  Tool updates:
+    gifwebp, anim_diff - default duration behavior (<= 10ms) changed to match
+                         web browsers, transcoding tools (issue #379)
+    img2webp, webpmux - allow options to be passed in via a file (issue #355)
+
 - 11/24/2017: version 0.6.1
   This is a binary compatible release.
   * lossless performance and compression improvements + a new 'cruncher' mode

README

@@ -4,7 +4,7 @@
           \__\__/\____/\_____/__/ ____  ___
                 / _/ /    \    \ /  _ \/ _/
                /  \_/   / /   \ \   __/  \__
-               \____/____/\_____/_____/____/v0.6.1
+               \____/____/\_____/_____/____/v1.1.0
 
 Description:
 ============
@@ -136,6 +136,8 @@ cmake -DWEBP_BUILD_CWEBP=ON -DWEBP_BUILD_DWEBP=ON ../
 
 or through your favorite interface (like ccmake or cmake-qt-gui).
 
+Use option -DWEBP_UNICODE=ON for Unicode support on Windows (with chcp 65001).
+
 Finally, once installed, you can also use WebP in your CMake project by doing:
 
 find_package(WebP)
@@ -402,12 +404,14 @@ Options are:
   -nofilter .... disable in-loop filtering
   -dither <int>  dithering strength (0..100), default=50
   -noalphadither disable alpha plane dithering
+  -usebgcolor .. display background color
   -mt .......... use multi-threading
   -info ........ print info
   -h ........... this help message
 
 Keyboard shortcuts:
   'c' ................ toggle use of color profile
+  'b' ................ toggle background color display
   'i' ................ overlay file information
   'd' ................ disable blending & disposal (debug)
   'q' / 'Q' / ESC .... quit
@@ -458,6 +462,7 @@ File-level options (only used at the start of compression):
  -mixed ............... use mixed lossy/lossless automatic mode
  -v ................... verbose mode
  -h ................... this help
+ -version ............. print version number and exit
 
 Per-frame options (only used for subsequent images input):
  -d <int> ............. frame duration in ms (default: 100)
@@ -469,6 +474,9 @@ Per-frame options (only used for subsequent images input):
 example: img2webp -loop 2 in0.png -lossy in1.jpg
                   -d 80 in2.tiff -o out.webp
 
+Note: if a single file name is passed as the argument, the arguments will be
+tokenized from this file. The file name must not start with the character '-'.
+
 Animated GIF conversion:
 ========================
 Animated GIF files can be converted to WebP files with animation using the
@@ -524,6 +532,11 @@ Options:
   -min_psnr <float> ... minimum per-frame PSNR
   -raw_comparison ..... if this flag is not used, RGB is
                         premultiplied before comparison
+  -max_diff <int> ..... maximum allowed difference per channel
+                        between corresponding pixels in subsequent
+                        frames
+  -h .................. this help
+  -version ............ print version number and exit
 
 Building:
 ---------
@@ -584,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

README.mux

@@ -1,7 +1,7 @@
           __   __  ____  ____  ____  __ __  _     __ __
          /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
          \       /   __/  _  \   __/      /  /  (_/  /__
-          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v0.4.1
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.1.0
 
 
 Description:
@@ -33,6 +33,7 @@ Usage: webpmux -get GET_OPTIONS INPUT -o OUTPUT
        webpmux -info INPUT
        webpmux [-h|-help]
        webpmux -version
+       webpmux argument_file_name
 
 GET_OPTIONS:
  Extract relevant data:
@@ -92,6 +93,9 @@ INPUT & OUTPUT are in WebP format.
 Note: The nature of EXIF, XMP and ICC data is not checked and is assumed to be
 valid.
 
+Note: if a single file name is passed as the argument, the arguments will be
+tokenized from this file. The file name must not start with the character '-'.
+
 Visualization tool:
 ===================
 
@@ -207,6 +211,35 @@ Code example:
 For a detailed AnimEncoder API reference, please refer to the header file
 (src/webp/mux.h).
 
+AnimDecoder API:
+================
+This AnimDecoder API allows decoding (possibly) animated WebP images.
+
+Code Example:
+
+  WebPAnimDecoderOptions dec_options;
+  WebPAnimDecoderOptionsInit(&dec_options);
+  // Tune 'dec_options' as needed.
+  WebPAnimDecoder* dec = WebPAnimDecoderNew(webp_data, &dec_options);
+  WebPAnimInfo anim_info;
+  WebPAnimDecoderGetInfo(dec, &anim_info);
+  for (uint32_t i = 0; i < anim_info.loop_count; ++i) {
+    while (WebPAnimDecoderHasMoreFrames(dec)) {
+      uint8_t* buf;
+      int timestamp;
+      WebPAnimDecoderGetNext(dec, &buf, &timestamp);
+      // ... (Render 'buf' based on 'timestamp').
+      // ... (Do NOT free 'buf', as it is owned by 'dec').
+    }
+    WebPAnimDecoderReset(dec);
+  }
+  const WebPDemuxer* demuxer = WebPAnimDecoderGetDemuxer(dec);
+  // ... (Do something using 'demuxer'; e.g. get EXIF/XMP/ICC data).
+  WebPAnimDecoderDelete(dec);
+
+For a detailed AnimDecoder API reference, please refer to the header file
+(src/webp/demux.h).
+
 
 Bugs:
 =====

README.webp_js

@@ -17,6 +17,10 @@ using Emscripten and CMake.
 
  - make sure the file $EMSCRIPTEN/cmake/Modules/Platform/Emscripten.cmake is
    accessible. This is the toolchain file used by CMake to invoke Emscripten.
+   If $EMSCRIPTEN is unset search for Emscripten.cmake under $EMSDK and set
+   $EMSCRIPTEN accordingly, for example:
+   unix-like environments: export EMSCRIPTEN=$EMSDK/fastcomp/emscripten
+   windows: set EMSCRIPTEN=%EMSDK%\fastcomp\emscripten
 
  - configure the project 'WEBP_JS' with CMake using:
 
@@ -32,7 +36,8 @@ using Emscripten and CMake.
    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.
+bitstream into a canvas. See webp_js/index.html for a simple usage sample
+(see below for instructions).
 
 Demo HTML page:
 ===============

build.gradle

@@ -152,11 +152,13 @@ model {
             include "upsampling_msa.c"
             include "upsampling_neon.$NEON"
             include "upsampling_sse2.c"
+            include "upsampling_sse41.c"
             include "yuv.c"
             include "yuv_mips32.c"
             include "yuv_mips_dsp_r2.c"
             include "yuv_neon.$NEON"
             include "yuv_sse2.c"
+            include "yuv_sse41.c"
             srcDir "src/utils"
             include "bit_reader_utils.c"
             include "color_cache_utils.c"
@@ -171,9 +173,9 @@ model {
             include "cost.c"
             include "cost_mips32.c"
             include "cost_mips_dsp_r2.c"
+            include "cost_neon.$NEON"
             include "cost_sse2.c"
             include "enc.c"
-            include "enc_avx2.c"
             include "enc_mips32.c"
             include "enc_mips_dsp_r2.c"
             include "enc_msa.c"
@@ -196,7 +198,6 @@ model {
             include "backward_references_enc.c"
             include "config_enc.c"
             include "cost_enc.c"
-            include "delta_palettization_enc.c"
             include "filter_enc.c"
             include "frame_enc.c"
             include "histogram_enc.c"
@@ -288,6 +289,7 @@ model {
     imagedec(NativeLibrarySpec) {
       binaries {
         all {
+          lib library: "webpdemux", linkage: "static"
           lib library: "webp", linkage: "static"
         }
       }
@@ -330,6 +332,7 @@ model {
           lib library: "example_util", linkage: "static"
           lib library: "imagedec", linkage: "static"
           lib library: "imageio_util", linkage: "static"
+          lib library: "webpdemux", linkage: "static"
           lib library: "webp", linkage: "static"
         }
       }
@@ -350,6 +353,7 @@ model {
           lib library: "imagedec", linkage: "static"
           lib library: "imageenc", linkage: "static"
           lib library: "imageio_util", linkage: "static"
+          lib library: "webpdemux", linkage: "static"
           lib library: "webp"
         }
       }
@@ -389,6 +393,7 @@ model {
           lib library: "imagedec", linkage: "static"
           lib library: "imageio_util", linkage: "static"
           lib library: "webpmux", linkage: "static"
+          lib library: "webpdemux", linkage: "static"
           lib library: "webp"
         }
       }

cmake/WebPConfig.cmake.in

@@ -3,17 +3,9 @@ set(WEBP_VERSION ${WebP_VERSION})
 
 @PACKAGE_INIT@
 
-if(@WEBP_USE_THREAD@)
-  include(CMakeFindDependencyMacro)
-  find_dependency(Threads REQUIRED)
-endif()
+include ("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
 
-include("${CMAKE_CURRENT_LIST_DIR}/WebPTargets.cmake")
-
-set_and_check(WebP_INCLUDE_DIR "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@")
-set(WebP_INCLUDE_DIRS ${WebP_INCLUDE_DIR})
-set(WEBP_INCLUDE_DIRS ${WebP_INCLUDE_DIR})
+set(WebP_INCLUDE_DIRS "webp")
+set(WEBP_INCLUDE_DIRS ${WebP_INCLUDE_DIRS})
 set(WebP_LIBRARIES "@INSTALLED_LIBRARIES@")
 set(WEBP_LIBRARIES "${WebP_LIBRARIES}")
-
-check_required_components(WebP)

cmake/config.h.in

@@ -103,12 +103,6 @@
 /* Version number of package */
 #cmakedefine VERSION "@VERSION@"
 
-/* Enable experimental code */
-#cmakedefine WEBP_EXPERIMENTAL_FEATURES 1
-
-/* Set to 1 if AVX2 is supported */
-#cmakedefine WEBP_HAVE_AVX2 1
-
 /* Set to 1 if GIF library is installed */
 #cmakedefine WEBP_HAVE_GIF 1
 

cmake/cpu.cmake

@@ -1,4 +1,4 @@
-## Check for SIMD extensions.
+# Check for SIMD extensions.
 include(CMakePushCheckState)
 
 function(webp_check_compiler_flag WEBP_SIMD_FLAG ENABLE_SIMD)
@@ -18,8 +18,7 @@ function(webp_check_compiler_flag WEBP_SIMD_FLAG ENABLE_SIMD)
         #endif
         return 0;
       }
-    " WEBP_HAVE_FLAG_${WEBP_SIMD_FLAG}
-  )
+    " WEBP_HAVE_FLAG_${WEBP_SIMD_FLAG})
   cmake_pop_check_state()
   if(WEBP_HAVE_FLAG_${WEBP_SIMD_FLAG})
     set(WEBP_HAVE_${WEBP_SIMD_FLAG} 1 PARENT_SCOPE)
@@ -29,16 +28,18 @@ function(webp_check_compiler_flag WEBP_SIMD_FLAG ENABLE_SIMD)
 endfunction()
 
 # those are included in the names of WEBP_USE_* in c++ code.
-set(WEBP_SIMD_FLAGS "SSE2;SSE41;AVX2;MIPS32;MIPS_DSP_R2;NEON;MSA")
-set(WEBP_SIMD_FILE_EXTENSIONS "_sse2.c;_sse41.c;_avx2.c;_mips32.c;_mips_dsp_r2.c;_neon.c;_msa.c")
+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)
-  # MSVC does not have a SSE4 flag but AVX2 support implies
-  # SSE4 support.
-  set(SIMD_ENABLE_FLAGS "/arch:SSE2;/arch:AVX2;/arch:AVX2;;;;")
+  # MSVC does not have a SSE4 flag but AVX support implies SSE4 support.
+  set(SIMD_ENABLE_FLAGS "/arch:AVX;/arch:SSE2;;;;")
   set(SIMD_DISABLE_FLAGS)
 else()
-  set(SIMD_ENABLE_FLAGS "-msse2;-msse4.1;-mavx2;-mips32;-mdspr2;-mfpu=neon;-mmsa")
-  set(SIMD_DISABLE_FLAGS "-mno-sse2;-mno-sse4.1;-mno-avx2;;-mno-dspr2;;-mno-msa")
+  set(SIMD_ENABLE_FLAGS
+      "-msse4.1;-msse2;-mips32;-mdspr2;-mfpu=neon;-mmsa")
+  set(SIMD_DISABLE_FLAGS
+      "-mno-sse4.1;-mno-sse2;;-mno-dspr2;;-mno-msa")
 endif()
 
 set(WEBP_SIMD_FILES_TO_NOT_INCLUDE)
@@ -47,16 +48,16 @@ set(WEBP_SIMD_FLAGS_TO_INCLUDE)
 
 if(${ANDROID})
   if(${ANDROID_ABI} STREQUAL "armeabi-v7a")
-    # This is because Android studio uses the configuration
-    # "-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16"
-    # that does not trigger neon optimizations but should
-    # (as this configuration does not exist anymore).
+    # This is because Android studio uses the configuration "-march=armv7-a
+    # -mfloat-abi=softfp -mfpu=vfpv3-d16" that does not trigger neon
+    # optimizations but should (as this configuration does not exist anymore).
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon ")
   endif()
 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})
   list(GET WEBP_SIMD_FLAGS ${I_SIMD} WEBP_SIMD_FLAG)
@@ -71,19 +72,29 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
     list(GET SIMD_ENABLE_FLAGS ${I_SIMD} SIMD_COMPILE_FLAG)
     set(CMAKE_REQUIRED_FLAGS ${SIMD_COMPILE_FLAG})
     webp_check_compiler_flag(${WEBP_SIMD_FLAG} ${WEBP_ENABLE_SIMD})
+  else()
+    if(MSVC)
+      list(GET SIMD_ENABLE_FLAGS ${I_SIMD} SIMD_COMPILE_FLAG)
     else()
       set(SIMD_COMPILE_FLAG " ")
     endif()
+  endif()
   # Check which files we should include or not.
   list(GET WEBP_SIMD_FILE_EXTENSIONS ${I_SIMD} WEBP_SIMD_FILE_EXTENSION)
   file(GLOB SIMD_FILES "${CMAKE_CURRENT_LIST_DIR}/../"
-    "src/dsp/*${WEBP_SIMD_FILE_EXTENSION}"
-  )
+            "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.
@@ -108,9 +119,9 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
           set(CMAKE_REQUIRED_DEFINITIONS ${SIMD_COMPILE_FLAG})
           check_c_source_compiles("int main(void) {return 0;}"
                                   FLAG_${SIMD_COMPILE_FLAG}
-            FAIL_REGEX "warning: argument unused during compilation:"
-            ${COMMON_PATTERNS}
-          )
+                                  FAIL_REGEX
+                                  "warning: argument unused during compilation:"
+                                  ${COMMON_PATTERNS})
           if(NOT FLAG_${SIMD_COMPILE_FLAG})
             unset(HAS_COMPILE_FLAG CACHE)
           endif()

cmake/deps.cmake

@@ -1,33 +1,27 @@
 # Generate the config.h to compile with specific intrinsics / libs.
 
-## Check for compiler options.
+# Check for compiler options.
 include(CheckCSourceCompiles)
 check_c_source_compiles("
     int main(void) {
       (void)__builtin_bswap16(0);
       return 0;
     }
-  "
-  HAVE_BUILTIN_BSWAP16
-)
+  " HAVE_BUILTIN_BSWAP16)
 check_c_source_compiles("
     int main(void) {
       (void)__builtin_bswap32(0);
       return 0;
     }
-  "
-  HAVE_BUILTIN_BSWAP32
-)
+  " HAVE_BUILTIN_BSWAP32)
 check_c_source_compiles("
     int main(void) {
       (void)__builtin_bswap64(0);
       return 0;
     }
-  "
-  HAVE_BUILTIN_BSWAP64
-)
+  " HAVE_BUILTIN_BSWAP64)
 
-## Check for libraries.
+# Check for libraries.
 find_package(Threads)
 if(Threads_FOUND)
   if(CMAKE_USE_PTHREADS_INIT)
@@ -40,8 +34,7 @@ if(Threads_FOUND)
           int attr = ${PTHREAD_TEST};
           return attr;
         }
-      " ${PTHREAD_TEST}
-    )
+      " ${PTHREAD_TEST})
   endforeach()
   list(APPEND WEBP_DEP_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
 endif()
@@ -51,15 +44,20 @@ set(WEBP_USE_THREAD ${Threads_FOUND})
 set(LT_OBJDIR ".libs/")
 
 # Only useful for vwebp, so useless for now.
-# find_package(OpenGL)
-# set(WEBP_HAVE_GL ${OPENGL_FOUND})
-# set(WEBP_DEP_INCLUDE_DIRS ${WEBP_DEP_INCLUDE_DIRS} ${OPENGL_INCLUDE_DIRS})
-# set(WEBP_DEP_LIBRARIES ${WEBP_DEP_LIBRARIES} ${OPENGL_LIBRARIES})
+find_package(OpenGL)
+set(WEBP_HAVE_GL ${OPENGL_FOUND})
 
-# Find the standard C math library.
-find_library(MATH_LIBRARY NAMES m)
-if(MATH_LIBRARY)
-  list(APPEND WEBP_DEP_LIBRARIES ${MATH_LIBRARY})
+# Check if we need to link to the C math library. We do not look for it as it is
+# not found when cross-compiling, while it is here.
+check_c_source_compiles("
+    #include <math.h>
+    int main(int argc, char** argv) {
+      return (int)pow(argc, 2.5);
+    }
+  " HAVE_MATH_LIBRARY)
+if(NOT HAVE_MATH_LIBRARY)
+  message(STATUS "Adding -lm flag.")
+  list(APPEND WEBP_DEP_LIBRARIES m)
 endif()
 
 # Find the standard image libraries.
@@ -70,8 +68,8 @@ foreach(I_LIB PNG JPEG TIFF)
   set(WEBP_HAVE_${I_LIB} ${${I_LIB}_FOUND})
   if(${I_LIB}_FOUND)
     list(APPEND WEBP_DEP_IMG_LIBRARIES ${${I_LIB}_LIBRARIES})
-    list(APPEND WEBP_DEP_IMG_INCLUDE_DIRS
-         ${${I_LIB}_INCLUDE_DIR} ${${I_LIB}_INCLUDE_DIRS})
+    list(APPEND WEBP_DEP_IMG_INCLUDE_DIRS ${${I_LIB}_INCLUDE_DIR}
+                ${${I_LIB}_INCLUDE_DIRS})
   endif()
 endforeach()
 if(WEBP_DEP_IMG_INCLUDE_DIRS)
@@ -87,8 +85,8 @@ set(WEBP_HAVE_GIF ${GIF_FOUND})
 if(GIF_FOUND)
   # GIF find_package only locates the header and library, it doesn't fail
   # compile tests when detecting the version, but falls back to 3 (as of at
-  # least cmake 3.7.2). Make sure the library links to avoid incorrect
-  # detection when cross compiling.
+  # least cmake 3.7.2). Make sure the library links to avoid incorrect detection
+  # when cross compiling.
   cmake_push_check_state()
   set(CMAKE_REQUIRED_LIBRARIES ${GIF_LIBRARIES})
   set(CMAKE_REQUIRED_INCLUDES ${GIF_INCLUDE_DIR})
@@ -98,8 +96,7 @@ if(GIF_FOUND)
         (void)DGifOpenFileHandle;
         return 0;
       }
-      " GIF_COMPILES
-  )
+      " GIF_COMPILES)
   cmake_pop_check_state()
   if(GIF_COMPILES)
     list(APPEND WEBP_DEP_GIF_LIBRARIES ${GIF_LIBRARIES})
@@ -109,7 +106,7 @@ if(GIF_FOUND)
   endif()
 endif()
 
-## Check for specific headers.
+# Check for specific headers.
 include(CheckIncludeFiles)
 check_include_files("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS)
 check_include_files(dlfcn.h HAVE_DLFCN_H)
@@ -131,25 +128,32 @@ check_include_files(windows.h HAVE_WINDOWS_H)
 
 # Windows specifics
 if(HAVE_WINCODEC_H)
-  list(APPEND WEBP_DEP_LIBRARIES shlwapi ole32 windowscodecs)
+  list(APPEND WEBP_DEP_LIBRARIES
+              shlwapi
+              ole32
+              windowscodecs)
 endif()
 
-## Check for SIMD extensions.
+# Check for SIMD extensions.
 include(${CMAKE_CURRENT_LIST_DIR}/cpu.cmake)
 
-## Define extra info.
+# Define extra info.
 set(PACKAGE ${PROJECT_NAME})
 set(PACKAGE_NAME ${PROJECT_NAME})
 
 # Read from configure.ac.
 file(READ ${CMAKE_CURRENT_SOURCE_DIR}/configure.ac CONFIGURE_AC)
-string(REGEX MATCHALL "\\[([0-9a-z\\.:/]*)\\]"
-  CONFIGURE_AC_PACKAGE_INFO ${CONFIGURE_AC}
-)
+string(REGEX MATCHALL
+             "\\[([0-9a-z\\.:/]*)\\]"
+             CONFIGURE_AC_PACKAGE_INFO
+             ${CONFIGURE_AC})
 function(strip_bracket VAR)
   string(LENGTH ${${VAR}} TMP_LEN)
   math(EXPR TMP_LEN ${TMP_LEN}-2)
-  string(SUBSTRING ${${VAR}} 1 ${TMP_LEN} TMP_SUB)
+  string(SUBSTRING ${${VAR}}
+                   1
+                   ${TMP_LEN}
+                   TMP_SUB)
   set(${VAR} ${TMP_SUB} PARENT_SCOPE)
 endfunction()
 

codereview.settings

@@ -0,0 +1,4 @@
+# This file is used by git cl to get repository specific information.
+GERRIT_HOST: True
+CODE_REVIEW_SERVER: chromium-review.googlesource.com
+GERRIT_SQUASH_UPLOADS: False

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libwebp], [0.6.1],
+AC_INIT([libwebp], [1.1.0],
         [https://bugs.chromium.org/p/webp],,
         [http://developers.google.com/speed/webp])
 AC_CANONICAL_HOST
@@ -122,31 +122,6 @@ AS_IF([test "$GCC" = "yes" ], [
 AC_SUBST([AM_CFLAGS])
 
 dnl === Check for machine specific flags
-AC_ARG_ENABLE([avx2],
-              AS_HELP_STRING([--disable-avx2],
-                             [Disable detection of AVX2 support
-                              @<:@default=auto@:>@]))
-
-AS_IF([test "x$enable_avx2" != "xno" -a "x$enable_sse4_1" != "xno" \
-         -a "x$enable_sse2" != "xno"], [
-  AVX2_CFLAGS="$INTRINSICS_CFLAGS $AVX2_FLAGS"
-  TEST_AND_ADD_CFLAGS([AVX2_FLAGS], [-mavx2])
-  AS_IF([test -n "$AVX2_FLAGS"], [
-    SAVED_CFLAGS=$CFLAGS
-    CFLAGS="$CFLAGS $AVX2_FLAGS"
-    AC_CHECK_HEADER([immintrin.h],
-                    [AC_DEFINE(WEBP_HAVE_AVX2, [1],
-                     [Set to 1 if AVX2 is supported])],
-                    [AVX2_FLAGS=""],
-                    dnl it's illegal to directly include avx2intrin.h, but it's
-                    dnl included conditionally in immintrin.h, tricky!
-                    [#ifndef __AVX2__
-                     #error avx2 is not enabled
-                     #endif
-                    ])
-    CFLAGS=$SAVED_CFLAGS])
-  AC_SUBST([AVX2_FLAGS])])
-
 AC_ARG_ENABLE([sse4.1],
               AS_HELP_STRING([--disable-sse4.1],
                              [Disable detection of SSE4.1 support
@@ -347,6 +322,8 @@ AS_IF([test "x$enable_gl" != "xno"], [
       # override with --with-gl*
       glut_cflags="$glut_cflags|-framework GLUT -framework OpenGL"
       glut_ldflags="$glut_ldflags|-framework GLUT -framework OpenGL"
+      # quiet deprecation warnings for glut
+      TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wno-deprecated-declarations])
       ;;
   esac
 
@@ -443,31 +420,54 @@ AC_ARG_ENABLE([sdl],
                               @<:@default=auto@:>@]))
 AS_IF([test "x$enable_sdl" != "xno"], [
   CLEAR_LIBVARS([SDL])
+  AC_PATH_PROGS([LIBSDL_CONFIG], [sdl-config])
+  if test -n "$LIBSDL_CONFIG"; then
+    SDL_INCLUDES=`$LIBSDL_CONFIG --cflags`
+    SDL_LIBS="`$LIBSDL_CONFIG --libs`"
+  fi
+
   WITHLIB_OPTION([sdl], [SDL])
 
   sdl_header="no"
   LIBCHECK_PROLOGUE([SDL])
-  AC_CHECK_HEADER([SDL/SDL.h], [sdl_header="SDL_SDL.h"],
+  AC_CHECK_HEADER([SDL/SDL.h], [sdl_header="SDL/SDL.h"],
                   [AC_CHECK_HEADER([SDL.h], [sdl_header="SDL.h"],
                   [AC_MSG_WARN(SDL library not available - no sdl.h)])])
   if test x"$sdl_header" != "xno"; then
-    AC_CHECK_LIB(SDL, SDL_Init,
-                 [SDL_LIBS="-lSDL"
-                  SDL_INCLUDES="-DWEBP_HAVE_SDL"
+    AC_LANG_PUSH(C)
+    SDL_SAVED_LIBS="$LIBS"
+    for lib in "" "-lSDL" "-lSDLmain -lSDL"; do
+      LIBS="$SDL_SAVED_LIBS $lib"
+      # Perform a full link to ensure SDL_main is resolved if needed.
+      AC_LINK_IFELSE(
+        [AC_LANG_SOURCE([
+           #include <$sdl_header>
+           int main(int argc, char** argv) {
+             SDL_Init(0);
+             return 0;
+           }])],
+        [SDL_LIBS="$LDFLAGS $LIBS"
+         SDL_INCLUDES="$SDL_INCLUDES -DWEBP_HAVE_SDL"
          AC_DEFINE(WEBP_HAVE_SDL, [1],
                    [Set to 1 if SDL library is installed])
-                  sdl_support=yes
-                 ],
-                 AC_MSG_WARN(Optional SDL library not found),
-                 [$MATH_LIBS])
+         sdl_support=yes]
+      )
+      if test x"$sdl_support" = "xyes"; then
+        break
+      fi
+    done
+    # LIBS is restored by LIBCHECK_EPILOGUE
+    AC_LANG_POP
     if test x"$sdl_header" = "xSDL.h"; then
       SDL_INCLUDES="$SDL_INCLUDES -DWEBP_HAVE_JUST_SDL_H"
     fi
   fi
   LIBCHECK_EPILOGUE([SDL])
 
-  if test "$sdl_support" = "yes"; then
+  if test x"$sdl_support" = "xyes"; then
     build_vwebp_sdl=yes
+  else
+    AC_MSG_WARN(Optional SDL library not found)
   fi
 ])
 
@@ -601,7 +601,7 @@ AS_IF([test "x$enable_gif" != "xno"], [
 AM_CONDITIONAL([BUILD_ANIMDIFF], [test "${build_anim_diff}" = "yes"])
 AM_CONDITIONAL([BUILD_GIF2WEBP], [test "${build_gif2webp}" = "yes"])
 
-if test "$enable_libwebpmux" = "yes"; then
+if test "$enable_libwebpdemux" = "yes" -a "$enable_libwebpmux" = "yes"; then
   build_img2webp=yes
 fi
 AM_CONDITIONAL([BUILD_IMG2WEBP], [test "${build_img2webp}" = "yes"])
@@ -676,19 +676,6 @@ fi
 AC_MSG_RESULT(${enable_swap_16bit_csp-no})
 AC_SUBST(USE_SWAP_16BIT_CSP)
 
-dnl === If --enable-experimental is defined, add -DWEBP_EXPERIMENTAL_FEATURES
-
-USE_EXPERIMENTAL_CODE=""
-AC_MSG_CHECKING(if --enable-experimental option is specified)
-AC_ARG_ENABLE([experimental], AS_HELP_STRING([--enable-experimental],
-                                             [Activate experimental features]))
-if test "$enable_experimental" = "yes"; then
-  AC_DEFINE(WEBP_EXPERIMENTAL_FEATURES, [1], [Enable experimental code])
-  USE_EXPERIMENTAL_CODE="-DWEBP_EXPERIMENTAL_FEATURES"
-fi
-AC_MSG_RESULT(${enable_experimental-no})
-AC_SUBST(USE_EXPERIMENTAL_CODE)
-
 dnl === If --disable-near-lossless is defined, add -DWEBP_NEAR_LOSSLESS=0
 
 AC_DEFINE(WEBP_NEAR_LOSSLESS, [1], [Enable near lossless encoding])
@@ -710,15 +697,16 @@ AC_ARG_ENABLE([libwebpmux],
               AS_HELP_STRING([--enable-libwebpmux],
                              [Build libwebpmux @<:@default=no@:>@]))
 AC_MSG_RESULT(${enable_libwebpmux-no})
-AM_CONDITIONAL([WANT_MUX], [test "$enable_libwebpmux" = "yes"])
+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([--enable-libwebpdemux],
-                             [Build libwebpdemux @<:@default=no@:>@]))
+              AS_HELP_STRING([--disable-libwebpdemux],
+                             [Disable libwebpdemux @<:@default=no@:>@]),
+              [], [enable_libwebpdemux=yes])
 AC_MSG_RESULT(${enable_libwebpdemux-no})
-AM_CONDITIONAL([WANT_DEMUX], [test "$enable_libwebpdemux" = "yes"])
+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)
@@ -734,7 +722,7 @@ AC_ARG_ENABLE([libwebpextras],
               AS_HELP_STRING([--enable-libwebpextras],
                              [Build libwebpextras @<:@default=no@:>@]))
 AC_MSG_RESULT(${enable_libwebpextras-no})
-AM_CONDITIONAL([WANT_EXTRAS], [test "$enable_libwebpextras" = "yes"])
+AM_CONDITIONAL([BUILD_EXTRAS], [test "$enable_libwebpextras" = "yes"])
 
 dnl =========================
 
@@ -765,14 +753,14 @@ libwebpmux: ${enable_libwebpmux-no}
 libwebpextras: ${enable_libwebpextras-no}
 
 Tools:
-cwebp : yes
+cwebp : ${enable_libwebpdemux-no}
   Input format support
   ====================
   JPEG : ${jpeg_support-no}
   PNG  : ${png_support-no}
   TIFF : ${tiff_support-no}
   WIC  : ${wic_support-no}
-dwebp : yes
+dwebp : ${enable_libwebpdemux-no}
   Output format support
   =====================
   PNG  : ${png_support-no}

doc/webp-container-spec.txt

@@ -446,8 +446,9 @@ Frame Height Minus One: 24 bits (_uint24_)
 Frame Duration: 24 bits (_uint24_)
 
 : The time to wait before displaying the next frame, in 1 millisecond units.
-  In particular, frame duration of 0 is useful when one wants to update
-  multiple areas of the canvas at once during the animation.
+  Note the interpretation of frame duration of 0 (and often <= 10) is
+  implementation defined. Many tools and browsers assign a minimum duration
+  similar to GIF.
 
 Reserved: 6 bits
 

examples/Android.mk

@@ -26,8 +26,7 @@ LOCAL_SRC_FILES := \
     cwebp.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
-LOCAL_STATIC_LIBRARIES := example_util imageio_util imagedec webp
+LOCAL_STATIC_LIBRARIES := example_util imageio_util imagedec webpdemux webp
 
 LOCAL_MODULE := cwebp
 
@@ -42,9 +41,7 @@ LOCAL_SRC_FILES := \
     dwebp.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
-LOCAL_STATIC_LIBRARIES := example_util imagedec imageenc webp
-
+LOCAL_STATIC_LIBRARIES := example_util imagedec imageenc webpdemux webp
 LOCAL_MODULE := dwebp
 
 include $(BUILD_EXECUTABLE)
@@ -58,7 +55,6 @@ LOCAL_SRC_FILES := \
     webpmux.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
 LOCAL_STATIC_LIBRARIES := example_util imageio_util webpmux webp
 
 LOCAL_MODULE := webpmux_example
@@ -74,8 +70,8 @@ LOCAL_SRC_FILES := \
     img2webp.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
-LOCAL_STATIC_LIBRARIES := example_util imageio_util imagedec webpmux webp
+LOCAL_STATIC_LIBRARIES := example_util imageio_util imagedec webpmux webpdemux \
+                          webp
 
 LOCAL_MODULE := img2webp_example
 
@@ -90,7 +86,6 @@ LOCAL_SRC_FILES := \
     webpinfo.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
 LOCAL_STATIC_LIBRARIES := example_util imageio_util webp
 
 LOCAL_MODULE := webpinfo_example

examples/Makefile.am

@@ -1,6 +1,9 @@
 AM_CPPFLAGS += -I$(top_builddir)/src -I$(top_srcdir)/src
 
-bin_PROGRAMS = dwebp cwebp
+bin_PROGRAMS =
+if BUILD_DEMUX
+  bin_PROGRAMS += dwebp cwebp
+endif
 if BUILD_ANIMDIFF
   noinst_PROGRAMS = anim_diff anim_dump
 endif
@@ -10,7 +13,7 @@ endif
 if BUILD_IMG2WEBP
   bin_PROGRAMS += img2webp
 endif
-if WANT_MUX
+if BUILD_MUX
   bin_PROGRAMS += webpmux
 endif
 if BUILD_VWEBP
@@ -25,16 +28,16 @@ noinst_LTLIBRARIES = libexample_util.la
 libexample_util_la_SOURCES = example_util.c example_util.h
 libexample_util_la_LIBADD = ../src/libwebp.la
 
-anim_diff_SOURCES = anim_diff.c anim_util.c anim_util.h
-anim_diff_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE) $(GIF_INCLUDES)
+anim_diff_SOURCES = anim_diff.c anim_util.c anim_util.h gifdec.c gifdec.h
+anim_diff_CPPFLAGS = $(AM_CPPFLAGS) $(GIF_INCLUDES)
 anim_diff_LDADD  =
 anim_diff_LDADD += ../src/demux/libwebpdemux.la
 anim_diff_LDADD += libexample_util.la
 anim_diff_LDADD += ../imageio/libimageio_util.la
 anim_diff_LDADD += $(GIF_LIBS) -lm
 
-anim_dump_SOURCES = anim_dump.c anim_util.c anim_util.h
-anim_dump_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE) $(PNG_INCLUDES)
+anim_dump_SOURCES = anim_dump.c anim_util.c anim_util.h gifdec.c gifdec.h
+anim_dump_CPPFLAGS = $(AM_CPPFLAGS) $(PNG_INCLUDES)
 anim_dump_CPPFLAGS += $(GIF_INCLUDES)
 anim_dump_LDADD  =
 anim_dump_LDADD += ../src/demux/libwebpdemux.la
@@ -44,7 +47,7 @@ anim_dump_LDADD += ../imageio/libimageenc.la
 anim_dump_LDADD += $(PNG_LIBS) $(GIF_LIBS) $(TIFF_LIBS) -lm
 
 cwebp_SOURCES  = cwebp.c stopwatch.h
-cwebp_CPPFLAGS  = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+cwebp_CPPFLAGS  = $(AM_CPPFLAGS)
 cwebp_LDADD  =
 cwebp_LDADD += libexample_util.la
 cwebp_LDADD += ../imageio/libimageio_util.la
@@ -53,7 +56,7 @@ cwebp_LDADD += ../src/libwebp.la
 cwebp_LDADD += $(JPEG_LIBS) $(PNG_LIBS) $(TIFF_LIBS)
 
 dwebp_SOURCES = dwebp.c stopwatch.h
-dwebp_CPPFLAGS  = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+dwebp_CPPFLAGS  = $(AM_CPPFLAGS)
 dwebp_CPPFLAGS += $(JPEG_INCLUDES) $(PNG_INCLUDES)
 dwebp_LDADD  =
 dwebp_LDADD += libexample_util.la
@@ -64,7 +67,7 @@ dwebp_LDADD += ../src/libwebp.la
 dwebp_LDADD +=$(PNG_LIBS) $(JPEG_LIBS)
 
 gif2webp_SOURCES = gif2webp.c gifdec.c gifdec.h
-gif2webp_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE) $(GIF_INCLUDES)
+gif2webp_CPPFLAGS = $(AM_CPPFLAGS) $(GIF_INCLUDES)
 gif2webp_LDADD  =
 gif2webp_LDADD += libexample_util.la
 gif2webp_LDADD += ../imageio/libimageio_util.la
@@ -73,7 +76,7 @@ gif2webp_LDADD += ../src/libwebp.la
 gif2webp_LDADD += $(GIF_LIBS)
 
 vwebp_SOURCES = vwebp.c
-vwebp_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE) $(GL_INCLUDES)
+vwebp_CPPFLAGS = $(AM_CPPFLAGS) $(GL_INCLUDES)
 vwebp_LDADD  =
 vwebp_LDADD += libexample_util.la
 vwebp_LDADD += ../imageio/libimageio_util.la
@@ -81,7 +84,7 @@ vwebp_LDADD += ../src/demux/libwebpdemux.la
 vwebp_LDADD += $(GL_LIBS)
 
 webpmux_SOURCES = webpmux.c
-webpmux_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+webpmux_CPPFLAGS = $(AM_CPPFLAGS)
 webpmux_LDADD  =
 webpmux_LDADD += libexample_util.la
 webpmux_LDADD += ../imageio/libimageio_util.la
@@ -89,7 +92,7 @@ webpmux_LDADD += ../src/mux/libwebpmux.la
 webpmux_LDADD += ../src/libwebp.la
 
 img2webp_SOURCES = img2webp.c
-img2webp_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+img2webp_CPPFLAGS = $(AM_CPPFLAGS)
 img2webp_LDADD  =
 img2webp_LDADD += libexample_util.la
 img2webp_LDADD += ../imageio/libimageio_util.la
@@ -99,7 +102,7 @@ img2webp_LDADD += ../src/libwebp.la
 img2webp_LDADD += $(PNG_LIBS) $(JPEG_LIBS) $(TIFF_LIBS)
 
 webpinfo_SOURCES = webpinfo.c
-webpinfo_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+webpinfo_CPPFLAGS = $(AM_CPPFLAGS)
 webpinfo_LDADD  =
 webpinfo_LDADD += libexample_util.la
 webpinfo_LDADD += ../imageio/libimageio_util.la

examples/anim_diff.c

@@ -20,6 +20,8 @@
 #include <string.h>  // for 'strcmp'.
 
 #include "./anim_util.h"
+#include "./example_util.h"
+#include "./unicode.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
@@ -197,11 +199,11 @@ static void Help(void) {
   printf("  -min_psnr <float> ... minimum per-frame PSNR\n");
   printf("  -raw_comparison ..... if this flag is not used, RGB is\n");
   printf("                        premultiplied before comparison\n");
-#ifdef WEBP_EXPERIMENTAL_FEATURES
-  printf("  -max_diff <int> ..... maximum allowed difference per channel "
-         "                        between corresponding pixels in subsequent"
+  printf("  -max_diff <int> ..... maximum allowed difference per channel\n"
+         "                        between corresponding pixels in subsequent\n"
          "                        frames\n");
-#endif
+  printf("  -h .................. this help\n");
+  printf("  -version ............ print version number and exit\n");
 }
 
 int main(int argc, const char* argv[]) {
@@ -217,56 +219,49 @@ int main(int argc, const char* argv[]) {
   const char* files[2] = { NULL, NULL };
   AnimatedImage images[2];
 
-  if (argc < 3) {
-    Help();
-    return -1;
-  }
+  INIT_WARGV(argc, argv);
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-dump_frames")) {
       if (c < argc - 1) {
         dump_frames = 1;
-        dump_folder = argv[++c];
+        dump_folder = (const char*)GET_WARGV(argv, ++c);
       } else {
         parse_error = 1;
       }
     } else if (!strcmp(argv[c], "-min_psnr")) {
       if (c < argc - 1) {
-        const char* const v = argv[++c];
-        char* end = NULL;
-        const double d = strtod(v, &end);
-        if (end == v) {
-          parse_error = 1;
-          fprintf(stderr, "Error! '%s' is not a floating point number.\n", v);
-        }
-        min_psnr = d;
+        min_psnr = ExUtilGetFloat(argv[++c], &parse_error);
       } else {
         parse_error = 1;
       }
     } else if (!strcmp(argv[c], "-raw_comparison")) {
       premultiply = 0;
-#ifdef WEBP_EXPERIMENTAL_FEATURES
     } else if (!strcmp(argv[c], "-max_diff")) {
       if (c < argc - 1) {
-        const char* const v = argv[++c];
-        char* end = NULL;
-        const int n = (int)strtol(v, &end, 10);
-        if (end == v) {
-          parse_error = 1;
-          fprintf(stderr, "Error! '%s' is not an integer.\n", v);
-        }
-        max_diff = n;
+        max_diff = ExUtilGetInt(argv[++c], 0, &parse_error);
       } else {
         parse_error = 1;
       }
-#endif
+    } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
+      Help();
+      FREE_WARGV_AND_RETURN(0);
+    } else if (!strcmp(argv[c], "-version")) {
+      int dec_version, demux_version;
+      GetAnimatedImageVersions(&dec_version, &demux_version);
+      printf("WebP Decoder version: %d.%d.%d\nWebP Demux version: %d.%d.%d\n",
+             (dec_version >> 16) & 0xff, (dec_version >> 8) & 0xff,
+             (dec_version >> 0) & 0xff,
+             (demux_version >> 16) & 0xff, (demux_version >> 8) & 0xff,
+             (demux_version >> 0) & 0xff);
+      FREE_WARGV_AND_RETURN(0);
     } else {
       if (!got_input1) {
-        files[0] = argv[c];
+        files[0] = (const char*)GET_WARGV(argv, c);
         got_input1 = 1;
       } else if (!got_input2) {
-        files[1] = argv[c];
+        files[1] = (const char*)GET_WARGV(argv, c);
         got_input2 = 1;
       } else {
         parse_error = 1;
@@ -274,23 +269,30 @@ int main(int argc, const char* argv[]) {
     }
     if (parse_error) {
       Help();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     }
   }
+  if (argc < 3) {
+    Help();
+    FREE_WARGV_AND_RETURN(-1);
+  }
+
+
   if (!got_input2) {
     Help();
-    return -1;
+    FREE_WARGV_AND_RETURN(-1);
   }
 
   if (dump_frames) {
-    printf("Dumping decoded frames in: %s\n", dump_folder);
+    WPRINTF("Dumping decoded frames in: %s\n", (const W_CHAR*)dump_folder);
   }
 
   memset(images, 0, sizeof(images));
   for (i = 0; i < 2; ++i) {
-    printf("Decoding file: %s\n", files[i]);
+    WPRINTF("Decoding file: %s\n", (const W_CHAR*)files[i]);
     if (!ReadAnimatedImage(files[i], &images[i], dump_frames, dump_folder)) {
-      fprintf(stderr, "Error decoding file: %s\n Aborting.\n", files[i]);
+      WFPRINTF(stderr, "Error decoding file: %s\n Aborting.\n",
+               (const W_CHAR*)files[i]);
       return_code = -2;
       goto End;
     } else {
@@ -300,14 +302,16 @@ int main(int argc, const char* argv[]) {
 
   if (!CompareAnimatedImagePair(&images[0], &images[1],
                                 premultiply, min_psnr)) {
-    fprintf(stderr, "\nFiles %s and %s differ.\n", files[0], files[1]);
+    WFPRINTF(stderr, "\nFiles %s and %s differ.\n", (const W_CHAR*)files[0],
+             (const W_CHAR*)files[1]);
     return_code = -3;
   } else {
-    printf("\nFiles %s and %s are identical.\n", files[0], files[1]);
+    WPRINTF("\nFiles %s and %s are identical.\n", (const W_CHAR*)files[0],
+            (const W_CHAR*)files[1]);
     return_code = 0;
   }
  End:
   ClearAnimatedImage(&images[0]);
   ClearAnimatedImage(&images[1]);
-  return return_code;
+  FREE_WARGV_AND_RETURN(return_code);
 }

examples/anim_dump.c

@@ -17,6 +17,7 @@
 #include "./anim_util.h"
 #include "webp/decode.h"
 #include "../imageio/image_enc.h"
+#include "./unicode.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
@@ -30,19 +31,23 @@ static void Help(void) {
                                   "(default: 'dump_')\n");
   printf("  -tiff ............... save frames as TIFF\n");
   printf("  -pam ................ save frames as PAM\n");
+  printf("  -h .................. this help\n");
+  printf("  -version ............ print version number and exit\n");
 }
 
 int main(int argc, const char* argv[]) {
   int error = 0;
-  const char* dump_folder = ".";
-  const char* prefix = "dump_";
-  const char* suffix = "png";
+  const W_CHAR* dump_folder = TO_W_CHAR(".");
+  const W_CHAR* prefix = TO_W_CHAR("dump_");
+  const W_CHAR* suffix = TO_W_CHAR("png");
   WebPOutputFileFormat format = PNG;
   int c;
 
+  INIT_WARGV(argc, argv);
+
   if (argc < 2) {
     Help();
-    return -1;
+    FREE_WARGV_AND_RETURN(-1);
   }
 
   for (c = 1; !error && c < argc; ++c) {
@@ -52,34 +57,46 @@ int main(int argc, const char* argv[]) {
         error = 1;
         break;
       }
-      dump_folder = argv[++c];
+      dump_folder = GET_WARGV(argv, ++c);
     } else if (!strcmp(argv[c], "-prefix")) {
       if (c + 1 == argc) {
         fprintf(stderr, "missing argument after option '%s'\n", argv[c]);
         error = 1;
         break;
       }
-      prefix = argv[++c];
+      prefix = GET_WARGV(argv, ++c);
     } else if (!strcmp(argv[c], "-tiff")) {
       format = TIFF;
-      suffix = "tiff";
+      suffix = TO_W_CHAR("tiff");
     } else if (!strcmp(argv[c], "-pam")) {
       format = PAM;
-      suffix = "pam";
+      suffix = TO_W_CHAR("pam");
+    } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
+      Help();
+      FREE_WARGV_AND_RETURN(0);
+    } else if (!strcmp(argv[c], "-version")) {
+      int dec_version, demux_version;
+      GetAnimatedImageVersions(&dec_version, &demux_version);
+      printf("WebP Decoder version: %d.%d.%d\nWebP Demux version: %d.%d.%d\n",
+             (dec_version >> 16) & 0xff, (dec_version >> 8) & 0xff,
+             (dec_version >> 0) & 0xff,
+             (demux_version >> 16) & 0xff, (demux_version >> 8) & 0xff,
+             (demux_version >> 0) & 0xff);
+      FREE_WARGV_AND_RETURN(0);
     } else {
       uint32_t i;
       AnimatedImage image;
-      const char* const file = argv[c];
+      const W_CHAR* const file = GET_WARGV(argv, c);
       memset(&image, 0, sizeof(image));
-      printf("Decoding file: %s as %s/%sxxxx.%s\n",
+      WPRINTF("Decoding file: %s as %s/%sxxxx.%s\n",
               file, dump_folder, prefix, suffix);
-      if (!ReadAnimatedImage(file, &image, 0, NULL)) {
-        fprintf(stderr, "Error decoding file: %s\n Aborting.\n", file);
+      if (!ReadAnimatedImage((const char*)file, &image, 0, NULL)) {
+        WFPRINTF(stderr, "Error decoding file: %s\n Aborting.\n", file);
         error = 1;
         break;
       }
       for (i = 0; !error && i < image.num_frames; ++i) {
-        char out_file[1024];
+        W_CHAR out_file[1024];
         WebPDecBuffer buffer;
         WebPInitDecBuffer(&buffer);
         buffer.colorspace = MODE_RGBA;
@@ -89,10 +106,10 @@ int main(int argc, const char* argv[]) {
         buffer.u.RGBA.rgba = image.frames[i].rgba;
         buffer.u.RGBA.stride = buffer.width * sizeof(uint32_t);
         buffer.u.RGBA.size = buffer.u.RGBA.stride * buffer.height;
-        snprintf(out_file, sizeof(out_file), "%s/%s%.4d.%s",
+        WSNPRINTF(out_file, sizeof(out_file), "%s/%s%.4d.%s",
                   dump_folder, prefix, i, suffix);
-        if (!WebPSaveImage(&buffer, format, out_file)) {
-          fprintf(stderr, "Error while saving image '%s'\n", out_file);
+        if (!WebPSaveImage(&buffer, format, (const char*)out_file)) {
+          WFPRINTF(stderr, "Error while saving image '%s'\n", out_file);
           error = 1;
         }
         WebPFreeDecBuffer(&buffer);
@@ -100,5 +117,5 @@ int main(int argc, const char* argv[]) {
       ClearAnimatedImage(&image);
     }
   }
-  return error ? 1 : 0;
+  FREE_WARGV_AND_RETURN(error ? 1 : 0);
 }

examples/anim_util.c

@@ -23,6 +23,9 @@
 #include "webp/decode.h"
 #include "webp/demux.h"
 #include "../imageio/imageio_util.h"
+#include "./gifdec.h"
+#include "./unicode.h"
+#include "./unicode_gif.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
@@ -57,15 +60,15 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
       !CheckSizeForOverflow(total_frame_size)) {
     return 0;
   }
-  mem = (uint8_t*)malloc((size_t)total_size);
-  frames = (DecodedFrame*)malloc((size_t)total_frame_size);
+  mem = (uint8_t*)WebPMalloc((size_t)total_size);
+  frames = (DecodedFrame*)WebPMalloc((size_t)total_frame_size);
 
   if (mem == NULL || frames == NULL) {
-    free(mem);
-    free(frames);
+    WebPFree(mem);
+    WebPFree(frames);
     return 0;
   }
-  free(image->raw_mem);
+  WebPFree(image->raw_mem);
   image->num_frames = num_frames;
   image->frames = frames;
   for (i = 0; i < num_frames; ++i) {
@@ -79,8 +82,8 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
 
 void ClearAnimatedImage(AnimatedImage* const image) {
   if (image != NULL) {
-    free(image->raw_mem);
-    free(image->frames);
+    WebPFree(image->raw_mem);
+    WebPFree(image->frames);
     image->num_frames = 0;
     image->frames = NULL;
     image->raw_mem = NULL;
@@ -151,42 +154,42 @@ static int DumpFrame(const char filename[], const char dump_folder[],
   int ok = 0;
   size_t max_len;
   int y;
-  const char* base_name = NULL;
-  char* file_name = NULL;
+  const W_CHAR* base_name = NULL;
+  W_CHAR* file_name = NULL;
   FILE* f = NULL;
   const char* row;
 
-  if (dump_folder == NULL) dump_folder = ".";
+  if (dump_folder == NULL) dump_folder = (const char*)TO_W_CHAR(".");
 
-  base_name = strrchr(filename, '/');
-  base_name = (base_name == NULL) ? filename : base_name + 1;
-  max_len = strlen(dump_folder) + 1 + strlen(base_name)
+  base_name = WSTRRCHR(filename, '/');
+  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 = (char*)malloc(max_len * sizeof(*file_name));
+  file_name = (W_CHAR*)WebPMalloc(max_len * sizeof(*file_name));
   if (file_name == NULL) goto End;
 
-  if (snprintf(file_name, max_len, "%s/%s_frame_%d.pam",
-               dump_folder, base_name, frame_num) < 0) {
+  if (WSNPRINTF(file_name, max_len, "%s/%s_frame_%d.pam",
+                (const W_CHAR*)dump_folder, base_name, frame_num) < 0) {
     fprintf(stderr, "Error while generating file name\n");
     goto End;
   }
 
-  f = fopen(file_name, "wb");
+  f = WFOPEN(file_name, "wb");
   if (f == NULL) {
-    fprintf(stderr, "Error opening file for writing: %s\n", file_name);
+    WFPRINTF(stderr, "Error opening file for writing: %s\n", file_name);
     ok = 0;
     goto End;
   }
   if (fprintf(f, "P7\nWIDTH %d\nHEIGHT %d\n"
               "DEPTH 4\nMAXVAL 255\nTUPLTYPE RGB_ALPHA\nENDHDR\n",
               canvas_width, canvas_height) < 0) {
-    fprintf(stderr, "Write error for file %s\n", file_name);
+    WFPRINTF(stderr, "Write error for file %s\n", file_name);
     goto End;
   }
   row = (const char*)rgba;
   for (y = 0; y < canvas_height; ++y) {
     if (fwrite(row, canvas_width * kNumChannels, 1, f) != 1) {
-      fprintf(stderr, "Error writing to file: %s\n", file_name);
+      WFPRINTF(stderr, "Error writing to file: %s\n", file_name);
       goto End;
     }
     row += canvas_width * kNumChannels;
@@ -194,7 +197,7 @@ static int DumpFrame(const char filename[], const char dump_folder[],
   ok = 1;
  End:
   if (f != NULL) fclose(f);
-  free(file_name);
+  WebPFree(file_name);
   return ok;
 }
 
@@ -222,7 +225,7 @@ static int ReadAnimatedWebP(const char filename[],
 
   dec = WebPAnimDecoderNew(webp_data, NULL);
   if (dec == NULL) {
-    fprintf(stderr, "Error parsing image: %s\n", filename);
+    WFPRINTF(stderr, "Error parsing image: %s\n", (const W_CHAR*)filename);
     goto End;
   }
 
@@ -370,26 +373,6 @@ static int DGifSavedExtensionToGCB(GifFileType* GifFile, int ImageIndex,
 #define DGifCloseFile(a, b) DGifCloseFile(a)
 #endif
 
-static void GIFDisplayError(const GifFileType* const gif, int gif_error) {
-  // libgif 4.2.0 has retired PrintGifError() and added GifErrorString().
-#if LOCAL_GIF_PREREQ(4, 2)
-#if LOCAL_GIF_PREREQ(5, 0)
-  const char* error_str =
-      GifErrorString((gif == NULL) ? gif_error : gif->Error);
-#else
-  const char* error_str = GifErrorString();
-  (void)gif;
-#endif
-  if (error_str == NULL) error_str = "Unknown error";
-  fprintf(stderr, "GIFLib Error %d: %s\n", gif_error, error_str);
-#else
-  (void)gif;
-  fprintf(stderr, "GIFLib Error %d: ", gif_error);
-  PrintGifError();
-  fprintf(stderr, "\n");
-#endif
-}
-
 static int IsKeyFrameGIF(const GifImageDesc* prev_desc, int prev_dispose,
                          const DecodedFrame* const prev_frame,
                          int canvas_width, int canvas_height) {
@@ -530,15 +513,15 @@ static int ReadAnimatedGIF(const char filename[], AnimatedImage* const image,
   int gif_error;
   GifFileType* gif;
 
-  gif = DGifOpenFileName(filename, NULL);
+  gif = DGifOpenFileUnicode((const W_CHAR*)filename, NULL);
   if (gif == NULL) {
-    fprintf(stderr, "Could not read file: %s.\n", filename);
+    WFPRINTF(stderr, "Could not read file: %s.\n", (const W_CHAR*)filename);
     return 0;
   }
 
   gif_error = DGifSlurp(gif);
   if (gif_error != GIF_OK) {
-    fprintf(stderr, "Could not parse image: %s.\n", filename);
+    WFPRINTF(stderr, "Could not parse image: %s.\n", (const W_CHAR*)filename);
     GIFDisplayError(gif, gif_error);
     DGifCloseFile(gif, NULL);
     return 0;
@@ -594,6 +577,9 @@ static int ReadAnimatedGIF(const char filename[], AnimatedImage* const image,
     curr_frame = &image->frames[i];
     curr_rgba = curr_frame->rgba;
     curr_frame->duration = GetFrameDurationGIF(gif, i);
+    // Force frames with a small or no duration to 100ms to be consistent
+    // with web browsers and other transcoding tools (like gif2webp itself).
+    if (curr_frame->duration <= 10) curr_frame->duration = 100;
 
     if (i == 0) {  // Initialize as transparent.
       curr_frame->is_key_frame = 1;
@@ -721,7 +707,7 @@ int ReadAnimatedImage(const char filename[], AnimatedImage* const image,
   memset(image, 0, sizeof(*image));
 
   if (!ImgIoUtilReadFile(filename, &webp_data.bytes, &webp_data.size)) {
-    fprintf(stderr, "Error reading file: %s\n", filename);
+    WFPRINTF(stderr, "Error reading file: %s\n", (const W_CHAR*)filename);
     return 0;
   }
 
@@ -731,9 +717,9 @@ int ReadAnimatedImage(const char filename[], AnimatedImage* const image,
   } else if (IsGIF(&webp_data)) {
     ok = ReadAnimatedGIF(filename, image, dump_frames, dump_folder);
   } else {
-    fprintf(stderr,
+    WFPRINTF(stderr,
              "Unknown file type: %s. Supported file types are WebP and GIF\n",
-            filename);
+             (const W_CHAR*)filename);
     ok = 0;
   }
   if (!ok) ClearAnimatedImage(image);
@@ -785,3 +771,9 @@ void GetDiffAndPSNR(const uint8_t rgba1[], const uint8_t rgba2[],
     *psnr = 4.3429448 * log(255. * 255. / sse);
   }
 }
+
+void GetAnimatedImageVersions(int* const decoder_version,
+                              int* const demux_version) {
+  *decoder_version = WebPGetDecoderVersion();
+  *demux_version = WebPGetDemuxVersion();
+}

examples/anim_util.h

@@ -62,6 +62,10 @@ void GetDiffAndPSNR(const uint8_t rgba1[], const uint8_t rgba2[],
                     uint32_t width, uint32_t height, int premultiply,
                     int* const max_diff, double* const psnr);
 
+// Return library versions used by anim_util.
+void GetAnimatedImageVersions(int* const decoder_version,
+                              int* const demux_version);
+
 #ifdef __cplusplus
 }    // extern "C"
 #endif

examples/cwebp.c

@@ -24,6 +24,7 @@
 #include "../imageio/image_dec.h"
 #include "../imageio/imageio_util.h"
 #include "./stopwatch.h"
+#include "./unicode.h"
 #include "webp/encode.h"
 
 #ifndef WEBP_DLL
@@ -88,7 +89,8 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
     }
   }
   if (!ok) {
-    fprintf(stderr, "Error! Could not process file %s\n", filename);
+    WFPRINTF(stderr, "Error! Could not process file %s\n",
+             (const W_CHAR*)filename);
   }
   free((void*)data);
   return ok;
@@ -114,7 +116,8 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
   }
  End:
   if (!ok) {
-    fprintf(stderr, "Error! Could not process file %s\n", filename);
+    WFPRINTF(stderr, "Error! Could not process file %s\n",
+             (const W_CHAR*)filename);
   }
   free((void*)data);
   return ok;
@@ -125,7 +128,8 @@ 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*)malloc(mb_w * mb_h * sizeof(*pic->extra_info));
+  pic->extra_info =
+      (uint8_t*)WebPMalloc(mb_w * mb_h * sizeof(*pic->extra_info));
 }
 
 static void PrintByteCount(const int bytes[4], int total_size,
@@ -140,10 +144,11 @@ static void PrintByteCount(const int bytes[4], int total_size,
   fprintf(stderr, "| %7d  (%.1f%%)\n", total, 100.f * total / total_size);
 }
 
-static void PrintPercents(const int counts[4], int total) {
+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, "|      %2d%%", 100 * counts[s] / total);
+    fprintf(stderr, "|      %2d%%", (int)(100. * counts[s] / total + .5));
   }
   fprintf(stderr, "| %7d\n", total);
 }
@@ -184,9 +189,10 @@ static void PrintExtraInfoLossless(const WebPPicture* const pic,
   if (short_output) {
     fprintf(stderr, "%7d %2.2f\n", stats->coded_size, stats->PSNR[3]);
   } else {
-    fprintf(stderr, "File:      %s\n", file_name);
+    WFPRINTF(stderr, "File:      %s\n", (const W_CHAR*)file_name);
     fprintf(stderr, "Dimension: %d x %d\n", pic->width, pic->height);
-    fprintf(stderr, "Output:    %d bytes\n", stats->coded_size);
+    fprintf(stderr, "Output:    %d bytes (%.2f bpp)\n", stats->coded_size,
+            8.f * stats->coded_size / pic->width / pic->height);
     PrintFullLosslessInfo(stats, "ARGB");
   }
 }
@@ -202,20 +208,23 @@ static void PrintExtraInfoLossy(const WebPPicture* const pic, int short_output,
     const int num_i16 = stats->block_count[1];
     const int num_skip = stats->block_count[2];
     const int total = num_i4 + num_i16;
-    fprintf(stderr, "File:      %s\n", file_name);
+    WFPRINTF(stderr, "File:      %s\n", (const W_CHAR*)file_name);
     fprintf(stderr, "Dimension: %d x %d%s\n",
             pic->width, pic->height,
             stats->alpha_data_size ? " (with alpha)" : "");
     fprintf(stderr, "Output:    "
-            "%d bytes Y-U-V-All-PSNR %2.2f %2.2f %2.2f   %2.2f dB\n",
+            "%d bytes Y-U-V-All-PSNR %2.2f %2.2f %2.2f   %2.2f dB\n"
+            "           (%.2f bpp)\n",
             stats->coded_size,
-            stats->PSNR[0], stats->PSNR[1], stats->PSNR[2], stats->PSNR[3]);
+            stats->PSNR[0], stats->PSNR[1], stats->PSNR[2], stats->PSNR[3],
+            8.f * stats->coded_size / pic->width / pic->height);
     if (total > 0) {
       int totals[4] = { 0, 0, 0, 0 };
-      fprintf(stderr, "block count:  intra4: %d\n"
-                      "              intra16: %d  (-> %.2f%%)\n",
-              num_i4, num_i16, 100.f * num_i16 / total);
-      fprintf(stderr, "              skipped block: %d (%.2f%%)\n",
+      fprintf(stderr, "block count:  intra4:     %6d  (%.2f%%)\n"
+                      "              intra16:    %6d  (%.2f%%)\n"
+                      "              skipped:    %6d  (%.2f%%)\n",
+              num_i4, 100.f * num_i4 / total,
+              num_i16, 100.f * num_i16 / total,
               num_skip, 100.f * num_skip / total);
       fprintf(stderr, "bytes used:  header:         %6d  (%.1f%%)\n"
                       "             mode-partition: %6d  (%.1f%%)\n",
@@ -239,7 +248,7 @@ static void PrintExtraInfoLossy(const WebPPicture* const pic, int short_output,
         PrintByteCount(stats->residual_bytes[2], stats->coded_size, totals);
       }
       fprintf(stderr, "    macroblocks:  ");
-      PrintPercents(stats->segment_size, total);
+      PrintPercents(stats->segment_size);
       fprintf(stderr, "      quantizer:  ");
       PrintValues(stats->segment_quant);
       fprintf(stderr, "   filter level:  ");
@@ -304,7 +313,7 @@ static int DumpPicture(const WebPPicture* const picture, const char* PGM_name) {
   const int alpha_height =
       WebPPictureHasTransparency(picture) ? picture->height : 0;
   const int height = picture->height + uv_height + alpha_height;
-  FILE* const f = fopen(PGM_name, "wb");
+  FILE* const f = WFOPEN(PGM_name, "wb");
   if (f == NULL) return 0;
   fprintf(f, "P5\n%d %d\n255\n", stride, height);
   for (y = 0; y < picture->height; ++y) {
@@ -580,9 +589,6 @@ static void HelpLong(void) {
   printf("  -near_lossless <int> ... use near-lossless image\n"
          "                           preprocessing (0..100=off), "
          "default=100\n");
-#ifdef WEBP_EXPERIMENTAL_FEATURES  /* not documented yet */
-  printf("  -delta_palette ......... use delta palettization\n");
-#endif  // WEBP_EXPERIMENTAL_FEATURES
   printf("  -hint <string> ......... specify image characteristics hint,\n");
   printf("                           one of: photo, picture or graph\n");
 
@@ -661,32 +667,34 @@ int main(int argc, const char *argv[]) {
   Metadata metadata;
   Stopwatch stop_watch;
 
+  INIT_WARGV(argc, argv);
+
   MetadataInit(&metadata);
   WebPMemoryWriterInit(&memory_writer);
   if (!WebPPictureInit(&picture) ||
       !WebPPictureInit(&original_picture) ||
       !WebPConfigInit(&config)) {
     fprintf(stderr, "Error! Version mismatch!\n");
-    return -1;
+    FREE_WARGV_AND_RETURN(-1);
   }
 
   if (argc == 1) {
     HelpShort();
-    return 0;
+    FREE_WARGV_AND_RETURN(0);
   }
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       HelpShort();
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-H") || !strcmp(argv[c], "-longhelp")) {
       HelpLong();
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
-      out_file = argv[++c];
+      out_file = (const char*)GET_WARGV(argv, ++c);
     } else if (!strcmp(argv[c], "-d") && c < argc - 1) {
-      dump_file = argv[++c];
+      dump_file = (const char*)GET_WARGV(argv, ++c);
       config.show_compressed = 1;
     } else if (!strcmp(argv[c], "-print_psnr")) {
       config.show_compressed = 1;
@@ -751,11 +759,6 @@ int main(int argc, const char *argv[]) {
     } 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
-#ifdef WEBP_EXPERIMENTAL_FEATURES
-    } else if (!strcmp(argv[c], "-delta_palette")) {
-      config.use_delta_palette = 1;
-      config.lossless = 1;  // delta-palette is for lossless only
-#endif  // WEBP_EXPERIMENTAL_FEATURES
     } else if (!strcmp(argv[c], "-hint") && c < argc - 1) {
       ++c;
       if (!strcmp(argv[c], "photo")) {
@@ -819,7 +822,7 @@ int main(int argc, const char *argv[]) {
       const int version = WebPGetEncoderVersion();
       printf("%d.%d.%d\n",
              (version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-progress")) {
       show_progress = 1;
     } else if (!strcmp(argv[c], "-quiet")) {
@@ -881,8 +884,7 @@ int main(int argc, const char *argv[]) {
         if (i == kNumTokens) {
           fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
                   (int)(token - start), start);
-          HelpLong();
-          return -1;
+          FREE_WARGV_AND_RETURN(-1);
         }
         start = token + 1;
       }
@@ -896,19 +898,19 @@ int main(int argc, const char *argv[]) {
     } else if (!strcmp(argv[c], "-v")) {
       verbose = 1;
     } else if (!strcmp(argv[c], "--")) {
-      if (c < argc - 1) in_file = 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]);
       HelpLong();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     } else {
-      in_file = argv[c];
+      in_file = (const char*)GET_WARGV(argv, c);
     }
 
     if (parse_error) {
       HelpLong();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     }
   }
   if (in_file == NULL) {
@@ -958,7 +960,8 @@ int main(int argc, const char *argv[]) {
   }
   if (!ReadPicture(in_file, &picture, keep_alpha,
                    (keep_metadata == 0) ? NULL : &metadata)) {
-    fprintf(stderr, "Error! Cannot read input picture file '%s'\n", in_file);
+    WFPRINTF(stderr, "Error! Cannot read input picture file '%s'\n",
+             (const W_CHAR*)in_file);
     goto Error;
   }
   picture.progress_hook = (show_progress && !quiet) ? ProgressReport : NULL;
@@ -974,14 +977,15 @@ int main(int argc, const char *argv[]) {
 
   // Open the output
   if (out_file != NULL) {
-    const int use_stdout = !strcmp(out_file, "-");
-    out = use_stdout ? ImgIoUtilSetBinaryMode(stdout) : fopen(out_file, "wb");
+    const int use_stdout = !WSTRCMP(out_file, "-");
+    out = use_stdout ? ImgIoUtilSetBinaryMode(stdout) : WFOPEN(out_file, "wb");
     if (out == NULL) {
-      fprintf(stderr, "Error! Cannot open output file '%s'\n", out_file);
+      WFPRINTF(stderr, "Error! Cannot open output file '%s'\n",
+               (const W_CHAR*)out_file);
       goto Error;
     } else {
       if (!short_output && !quiet) {
-        fprintf(stderr, "Saving file '%s'\n", out_file);
+        WFPRINTF(stderr, "Saving file '%s'\n", (const W_CHAR*)out_file);
       }
     }
     if (keep_metadata == 0) {
@@ -1015,10 +1019,53 @@ int main(int argc, const char *argv[]) {
     }
   }
   if ((resize_w | resize_h) > 0) {
+    WebPPicture picture_no_alpha;
+    if (config.exact) {
+      // If -exact, we can't premultiply RGB by A otherwise RGB is lost if A=0.
+      // We rescale an opaque copy and assemble scaled A and non-premultiplied
+      // RGB channels. This is slower but it's a very uncommon use case. Color
+      // leak at sharp alpha edges is possible.
+      if (!WebPPictureCopy(&picture, &picture_no_alpha)) {
+        fprintf(stderr, "Error! Cannot copy temporary picture\n");
+        goto Error;
+      }
+
+      // We enforced picture.use_argb = 1 above. Now, remove the alpha values.
+      {
+        int x, y;
+        uint32_t* argb_no_alpha = picture_no_alpha.argb;
+        for (y = 0; y < picture_no_alpha.height; ++y) {
+          for (x = 0; x < picture_no_alpha.width; ++x) {
+            argb_no_alpha[x] |= 0xff000000;  // Opaque copy.
+          }
+          argb_no_alpha += picture_no_alpha.argb_stride;
+        }
+      }
+
+      if (!WebPPictureRescale(&picture_no_alpha, resize_w, resize_h)) {
+        fprintf(stderr, "Error! Cannot resize temporary picture\n");
+        goto Error;
+      }
+    }
+
     if (!WebPPictureRescale(&picture, resize_w, resize_h)) {
       fprintf(stderr, "Error! Cannot resize picture\n");
       goto Error;
     }
+
+    if (config.exact) {  // Put back the alpha information.
+      int x, y;
+      uint32_t* argb_no_alpha = picture_no_alpha.argb;
+      uint32_t* argb = picture.argb;
+      for (y = 0; y < picture_no_alpha.height; ++y) {
+        for (x = 0; x < picture_no_alpha.width; ++x) {
+          argb[x] = (argb[x] & 0xff000000) | (argb_no_alpha[x] & 0x00ffffff);
+        }
+        argb_no_alpha += picture_no_alpha.argb_stride;
+        argb += picture.argb_stride;
+      }
+      WebPPictureFree(&picture_no_alpha);
+    }
   }
   if (verbose && (crop != 0 || (resize_w | resize_h) > 0)) {
     const double preproc_time = StopwatchReadAndReset(&stop_watch);
@@ -1050,9 +1097,11 @@ int main(int argc, const char *argv[]) {
   // Write info
   if (dump_file) {
     if (picture.use_argb) {
-      fprintf(stderr, "Warning: can't dump file (-d option) in lossless mode.");
+      fprintf(stderr, "Warning: can't dump file (-d option) "
+                      "in lossless mode.\n");
     } else if (!DumpPicture(&picture, dump_file)) {
-      fprintf(stderr, "Warning, couldn't dump picture %s\n", dump_file);
+      WFPRINTF(stderr, "Warning, couldn't dump picture %s\n",
+               (const W_CHAR*)dump_file);
     }
   }
 
@@ -1120,7 +1169,7 @@ int main(int argc, const char *argv[]) {
 
  Error:
   WebPMemoryWriterClear(&memory_writer);
-  free(picture.extra_info);
+  WebPFree(picture.extra_info);
   MetadataFree(&metadata);
   WebPPictureFree(&picture);
   WebPPictureFree(&original_picture);
@@ -1128,7 +1177,7 @@ int main(int argc, const char *argv[]) {
     fclose(out);
   }
 
-  return return_value;
+  FREE_WARGV_AND_RETURN(return_value);
 }
 
 //------------------------------------------------------------------------------

examples/dwebp.c

@@ -24,6 +24,7 @@
 #include "../imageio/image_enc.h"
 #include "../imageio/webpdec.h"
 #include "./stopwatch.h"
+#include "./unicode.h"
 
 static int verbose = 0;
 static int quiet = 0;
@@ -42,7 +43,7 @@ extern void* VP8GetCPUInfo;   // opaque forward declaration.
 
 static int SaveOutput(const WebPDecBuffer* const buffer,
                       WebPOutputFileFormat format, const char* const out_file) {
-  const int use_stdout = (out_file != NULL) && !strcmp(out_file, "-");
+  const int use_stdout = (out_file != NULL) && !WSTRCMP(out_file, "-");
   int ok = 1;
   Stopwatch stop_watch;
 
@@ -56,7 +57,7 @@ static int SaveOutput(const WebPDecBuffer* const buffer,
       if (use_stdout) {
         fprintf(stderr, "Saved to stdout\n");
       } else {
-        fprintf(stderr, "Saved file %s\n", out_file);
+        WFPRINTF(stderr, "Saved file %s\n", (const W_CHAR*)out_file);
       }
     }
     if (verbose) {
@@ -67,7 +68,7 @@ static int SaveOutput(const WebPDecBuffer* const buffer,
     if (use_stdout) {
       fprintf(stderr, "Error writing to stdout !!\n");
     } else {
-      fprintf(stderr, "Error writing file %s !!\n", out_file);
+      WFPRINTF(stderr, "Error writing file %s !!\n", (const W_CHAR*)out_file);
     }
   }
   return ok;
@@ -131,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*)malloc(stride * h);
+    external_buffer = (uint8_t*)WebPMalloc(stride * h);
     if (external_buffer == NULL) return NULL;
     output_buffer->u.RGBA.stride = stride;
     output_buffer->u.RGBA.size = stride * h;
@@ -144,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*)malloc(total_size);
+    external_buffer = (uint8_t*)WebPMalloc(total_size);
     if (external_buffer == NULL) return NULL;
     tmp = external_buffer;
     output_buffer->u.YUVA.y = tmp;
@@ -191,18 +192,20 @@ int main(int argc, const char *argv[]) {
   int incremental = 0;
   int c;
 
+  INIT_WARGV(argc, argv);
+
   if (!WebPInitDecoderConfig(&config)) {
     fprintf(stderr, "Library version mismatch!\n");
-    return -1;
+    FREE_WARGV_AND_RETURN(-1);
   }
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       Help();
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
-      out_file = argv[++c];
+      out_file = (const char*)GET_WARGV(argv, ++c);
     } else if (!strcmp(argv[c], "-alpha")) {
       format = ALPHA_PLANE_ONLY;
     } else if (!strcmp(argv[c], "-nofancy")) {
@@ -223,7 +226,7 @@ int main(int argc, const char *argv[]) {
       const int version = WebPGetDecoderVersion();
       printf("%d.%d.%d\n",
              (version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-pgm")) {
       format = PGM;
     } else if (!strcmp(argv[c], "-yuv")) {
@@ -284,26 +287,26 @@ int main(int argc, const char *argv[]) {
     } else if (!strcmp(argv[c], "-incremental")) {
       incremental = 1;
     } else if (!strcmp(argv[c], "--")) {
-      if (c < argc - 1) in_file = argv[++c];
+      if (c < argc - 1) in_file = (const char*)GET_WARGV(argv, ++c);
       break;
     } else if (argv[c][0] == '-') {
       fprintf(stderr, "Unknown option '%s'\n", argv[c]);
       Help();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     } else {
-      in_file = argv[c];
+      in_file = (const char*)GET_WARGV(argv, c);
     }
 
     if (parse_error) {
       Help();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     }
   }
 
   if (in_file == NULL) {
     fprintf(stderr, "missing input file!!\n");
     Help();
-    return -1;
+    FREE_WARGV_AND_RETURN(-1);
   }
 
   if (quiet) verbose = 0;
@@ -312,7 +315,7 @@ int main(int argc, const char *argv[]) {
     VP8StatusCode status = VP8_STATUS_OK;
     size_t data_size = 0;
     if (!LoadWebP(in_file, &data, &data_size, bitstream)) {
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     }
 
     switch (format) {
@@ -389,18 +392,18 @@ int main(int argc, const char *argv[]) {
 
   if (out_file != NULL) {
     if (!quiet) {
-      fprintf(stderr, "Decoded %s. Dimensions: %d x %d %s. Format: %s. "
-                      "Now saving...\n",
-              in_file, output_buffer->width, output_buffer->height,
+      WFPRINTF(stderr, "Decoded %s.", (const W_CHAR*)in_file);
+      fprintf(stderr, " Dimensions: %d x %d %s. Format: %s. Now saving...\n",
+              output_buffer->width, output_buffer->height,
               bitstream->has_alpha ? " (with alpha)" : "",
               kFormatType[bitstream->format]);
     }
     ok = SaveOutput(output_buffer, format, out_file);
   } else {
     if (!quiet) {
-      fprintf(stderr, "File %s can be decoded "
-                      "(dimensions: %d x %d %s. Format: %s).\n",
-              in_file, output_buffer->width, output_buffer->height,
+      WFPRINTF(stderr, "File %s can be decoded ", (const W_CHAR*)in_file);
+      fprintf(stderr, "(dimensions: %d x %d %s. Format: %s).\n",
+              output_buffer->width, output_buffer->height,
               bitstream->has_alpha ? " (with alpha)" : "",
               kFormatType[bitstream->format]);
       fprintf(stderr, "Nothing written; "
@@ -409,9 +412,9 @@ int main(int argc, const char *argv[]) {
   }
  Exit:
   WebPFreeDecBuffer(output_buffer);
-  free((void*)external_buffer);
-  free((void*)data);
-  return ok ? 0 : -1;
+  WebPFree((void*)external_buffer);
+  WebPFree((void*)data);
+  FREE_WARGV_AND_RETURN(ok ? 0 : -1);
 }
 
 //------------------------------------------------------------------------------

examples/example_util.c

@@ -12,10 +12,14 @@
 
 #include "./example_util.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "webp/mux_types.h"
+#include "../imageio/imageio_util.h"
+
 //------------------------------------------------------------------------------
 // String parsing
 
@@ -56,3 +60,76 @@ float ExUtilGetFloat(const char* const v, int* const error) {
   }
   return f;
 }
+
+//------------------------------------------------------------------------------
+
+static void ResetCommandLineArguments(int argc, const char* argv[],
+                                      CommandLineArguments* const args) {
+  assert(args != NULL);
+  args->argc_ = argc;
+  args->argv_ = argv;
+  args->own_argv_ = 0;
+  WebPDataInit(&args->argv_data_);
+}
+
+void ExUtilDeleteCommandLineArguments(CommandLineArguments* const args) {
+  if (args != NULL) {
+    if (args->own_argv_) {
+      WebPFree((void*)args->argv_);
+      WebPDataClear(&args->argv_data_);
+    }
+    ResetCommandLineArguments(0, NULL, args);
+  }
+}
+
+#define MAX_ARGC 16384
+int ExUtilInitCommandLineArguments(int argc, const char* argv[],
+                                   CommandLineArguments* const args) {
+  if (args == NULL || argv == NULL) return 0;
+  ResetCommandLineArguments(argc, argv, args);
+  if (argc == 1 && argv[0][0] != '-') {
+    char* cur;
+    const char sep[] = " \t\r\n\f\v";
+
+#if defined(_WIN32) && defined(_UNICODE)
+    fprintf(stderr,
+            "Error: Reading arguments from a file is a feature unavailable "
+            "with Unicode binaries.\n");
+    return 0;
+#endif
+
+    if (!ExUtilReadFileToWebPData(argv[0], &args->argv_data_)) {
+      return 0;
+    }
+    args->own_argv_ = 1;
+    args->argv_ = (const char**)WebPMalloc(MAX_ARGC * sizeof(*args->argv_));
+    if (args->argv_ == NULL) return 0;
+
+    argc = 0;
+    for (cur = strtok((char*)args->argv_data_.bytes, sep);
+         cur != NULL;
+         cur = strtok(NULL, sep)) {
+      if (argc == MAX_ARGC) {
+        fprintf(stderr, "ERROR: Arguments limit %d reached\n", MAX_ARGC);
+        return 0;
+      }
+      assert(strlen(cur) != 0);
+      args->argv_[argc++] = cur;
+    }
+    args->argc_ = argc;
+  }
+  return 1;
+}
+
+//------------------------------------------------------------------------------
+
+int ExUtilReadFileToWebPData(const char* const filename,
+                             WebPData* const webp_data) {
+  const uint8_t* data;
+  size_t size;
+  if (webp_data == NULL) return 0;
+  if (!ImgIoUtilReadFile(filename, &data, &size)) return 0;
+  webp_data->bytes = data;
+  webp_data->size = size;
+  return 1;
+}

examples/example_util.h

@@ -14,6 +14,7 @@
 #define WEBP_EXAMPLES_EXAMPLE_UTIL_H_
 
 #include "webp/types.h"
+#include "webp/mux_types.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -35,6 +36,33 @@ float ExUtilGetFloat(const char* const v, int* const error);
 // actually parsed is returned, or -1 if an error occurred.
 int ExUtilGetInts(const char* v, int base, int max_output, int output[]);
 
+// Reads a file named 'filename' into a WebPData structure. The content of
+// webp_data is overwritten. Returns false in case of error.
+int ExUtilReadFileToWebPData(const char* const filename,
+                             WebPData* const webp_data);
+
+//------------------------------------------------------------------------------
+// Command-line arguments
+
+typedef struct {
+  int argc_;
+  const char** argv_;
+  WebPData argv_data_;
+  int own_argv_;
+} CommandLineArguments;
+
+// Initializes the structure from the command-line parameters. If there is
+// only one parameter and it does not start with a '-', then it is assumed to
+// be a file name. This file will be read and tokenized into command-line
+// arguments. The content of 'args' is overwritten.
+// Returns false in case of error (memory allocation failure, non
+// existing file, too many arguments, ...).
+int ExUtilInitCommandLineArguments(int argc, const char* argv[],
+                                   CommandLineArguments* const args);
+
+// Deallocate all memory and reset 'args'.
+void ExUtilDeleteCommandLineArguments(CommandLineArguments* const args);
+
 #ifdef __cplusplus
 }    // extern "C"
 #endif

examples/gif2webp.c

@@ -23,12 +23,22 @@
 
 #ifdef WEBP_HAVE_GIF
 
+#if defined(HAVE_UNISTD_H) && HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
 #include <gif_lib.h>
 #include "webp/encode.h"
 #include "webp/mux.h"
 #include "../examples/example_util.h"
 #include "../imageio/imageio_util.h"
 #include "./gifdec.h"
+#include "./unicode.h"
+#include "./unicode_gif.h"
+
+#if !defined(STDIN_FILENO)
+#define STDIN_FILENO 0
+#endif
 
 //------------------------------------------------------------------------------
 
@@ -91,8 +101,7 @@ int main(int argc, const char *argv[]) {
   int gif_error = GIF_ERROR;
   WebPMuxError err = WEBP_MUX_OK;
   int ok = 0;
-  const char *in_file = NULL, *out_file = NULL;
-  FILE* out = NULL;
+  const W_CHAR* in_file = NULL, *out_file = NULL;
   GifFileType* gif = NULL;
   int frame_duration = 0;
   int frame_timestamp = 0;
@@ -125,11 +134,13 @@ int main(int argc, const char *argv[]) {
   int default_kmin = 1;  // Whether to use default kmin value.
   int default_kmax = 1;
 
+  INIT_WARGV(argc, argv);
+
   if (!WebPConfigInit(&config) || !WebPAnimEncoderOptionsInit(&enc_options) ||
       !WebPPictureInit(&frame) || !WebPPictureInit(&curr_canvas) ||
       !WebPPictureInit(&prev_canvas)) {
     fprintf(stderr, "Error! Version mismatch!\n");
-    return -1;
+    FREE_WARGV_AND_RETURN(-1);
   }
   config.lossless = 1;  // Use lossless compression by default.
 
@@ -139,16 +150,16 @@ int main(int argc, const char *argv[]) {
 
   if (argc == 1) {
     Help();
-    return 0;
+    FREE_WARGV_AND_RETURN(0);
   }
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       Help();
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
-      out_file = argv[++c];
+      out_file = GET_WARGV(argv, ++c);
     } else if (!strcmp(argv[c], "-lossy")) {
       config.lossless = 0;
     } else if (!strcmp(argv[c], "-mixed")) {
@@ -205,7 +216,7 @@ int main(int argc, const char *argv[]) {
           fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
                   (int)(token - start), start);
           Help();
-          return -1;
+          FREE_WARGV_AND_RETURN(-1);
         }
         start = token + 1;
       }
@@ -218,7 +229,7 @@ int main(int argc, const char *argv[]) {
              (enc_version >> 16) & 0xff, (enc_version >> 8) & 0xff,
              enc_version & 0xff, (mux_version >> 16) & 0xff,
              (mux_version >> 8) & 0xff, mux_version & 0xff);
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-quiet")) {
       quiet = 1;
       enc_options.verbose = 0;
@@ -226,19 +237,19 @@ int main(int argc, const char *argv[]) {
       verbose = 1;
       enc_options.verbose = 1;
     } else if (!strcmp(argv[c], "--")) {
-      if (c < argc - 1) in_file = argv[++c];
+      if (c < argc - 1) in_file = GET_WARGV(argv, ++c);
       break;
     } else if (argv[c][0] == '-') {
       fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
       Help();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     } else {
-      in_file = argv[c];
+      in_file = GET_WARGV(argv, c);
     }
 
     if (parse_error) {
       Help();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     }
   }
 
@@ -262,11 +273,7 @@ int main(int argc, const char *argv[]) {
   }
 
   // Start the decoder object
-#if LOCAL_GIF_PREREQ(5,0)
-  gif = DGifOpenFileName(in_file, &gif_error);
-#else
-  gif = DGifOpenFileName(in_file);
-#endif
+  gif = DGifOpenFileUnicode(in_file, &gif_error);
   if (gif == NULL) goto End;
 
   // Loop over GIF images
@@ -351,6 +358,14 @@ int main(int argc, const char *argv[]) {
         GIFDisposeFrame(orig_dispose, &gif_rect, &prev_canvas, &curr_canvas);
         GIFCopyPixels(&curr_canvas, &prev_canvas);
 
+        // Force frames with a small or no duration to 100ms to be consistent
+        // with web browsers and other transcoding tools. This also avoids
+        // incorrect durations between frames when padding frames are
+        // discarded.
+        if (frame_duration <= 10) {
+          frame_duration = 100;
+        }
+
         // Update timestamp (for next frame).
         frame_timestamp += frame_duration;
 
@@ -527,14 +542,20 @@ int main(int argc, const char *argv[]) {
   }
 
   if (out_file != NULL) {
-    if (!ImgIoUtilWriteFile(out_file, webp_data.bytes, webp_data.size)) {
-      fprintf(stderr, "Error writing output file: %s\n", out_file);
+    if (!ImgIoUtilWriteFile((const char*)out_file, webp_data.bytes,
+                            webp_data.size)) {
+      WFPRINTF(stderr, "Error writing output file: %s\n", out_file);
       goto End;
     }
     if (!quiet) {
-      fprintf(stderr, "Saved output file (%d bytes): %s\n",
+      if (!WSTRCMP(out_file, "-")) {
+        fprintf(stderr, "Saved %d bytes to STDIO\n",
+                (int)webp_data.size);
+      } else {
+        WFPRINTF(stderr, "Saved output file (%d bytes): %s\n",
                  (int)webp_data.size, out_file);
       }
+    }
   } else {
     if (!quiet) {
       fprintf(stderr, "Nothing written; use -o flag to save the result "
@@ -555,7 +576,6 @@ int main(int argc, const char *argv[]) {
   WebPPictureFree(&curr_canvas);
   WebPPictureFree(&prev_canvas);
   WebPAnimEncoderDelete(enc);
-  if (out != NULL && out_file != NULL) fclose(out);
 
   if (gif_error != GIF_OK) {
     GIFDisplayError(gif, gif_error);
@@ -568,7 +588,7 @@ int main(int argc, const char *argv[]) {
 #endif
   }
 
-  return !ok;
+  FREE_WARGV_AND_RETURN(!ok);
 }
 
 #else  // !WEBP_HAVE_GIF

examples/gifdec.c

@@ -137,7 +137,7 @@ int GIFReadFrame(GifFileType* const gif, int transparent_index,
   }
   dst = sub_image.argb;
 
-  tmp = (uint8_t*)malloc(rect.width * sizeof(*tmp));
+  tmp = (uint8_t*)WebPMalloc(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);
-  free(tmp);
+  WebPFree(tmp);
   return ok;
 }
 

examples/img2webp.c

@@ -27,6 +27,7 @@
 #include "../imageio/image_dec.h"
 #include "../imageio/imageio_util.h"
 #include "./stopwatch.h"
+#include "./unicode.h"
 #include "webp/encode.h"
 #include "webp/mux.h"
 
@@ -48,6 +49,7 @@ static void Help(void) {
   printf(" -mixed ............... use mixed lossy/lossless automatic mode\n");
   printf(" -v ................... verbose mode\n");
   printf(" -h ................... this help\n");
+  printf(" -version ............. print version number and exit\n");
   printf("\n");
 
   printf("Per-frame options (only used for subsequent images input):\n");
@@ -60,6 +62,10 @@ static void Help(void) {
   printf("\n");
   printf("example: img2webp -loop 2 in0.png -lossy in1.jpg\n"
          "                  -d 80 in2.tiff -o out.webp\n");
+  printf("\nNote: if a single file name is passed as the argument, the "
+         "arguments will be\n");
+  printf("tokenized from this file. The file name must not start with "
+         "the character '-'.\n");
 }
 
 //------------------------------------------------------------------------------
@@ -117,14 +123,13 @@ static int SetLoopCount(int loop_count, WebPData* const webp_data) {
 
 //------------------------------------------------------------------------------
 
-int main(int argc, char* argv[]) {
+int main(int argc, const char* argv[]) {
   const char* output = NULL;
   WebPAnimEncoder* enc = NULL;
   int verbose = 0;
   int pic_num = 0;
   int duration = 100;
   int timestamp_ms = 0;
-  int ok = 1;
   int loop_count = 0;
   int width = 0, height = 0;
   WebPAnimEncoderOptions anim_config;
@@ -133,22 +138,33 @@ int main(int argc, char* argv[]) {
   WebPData webp_data;
   int c;
   int have_input = 0;
+  CommandLineArguments cmd_args;
+  int ok;
+
+  INIT_WARGV(argc, argv);
+
+  ok = ExUtilInitCommandLineArguments(argc - 1, argv + 1, &cmd_args);
+  if (!ok) FREE_WARGV_AND_RETURN(1);
+
+  argc = cmd_args.argc_;
+  argv = cmd_args.argv_;
 
   WebPDataInit(&webp_data);
   if (!WebPAnimEncoderOptionsInit(&anim_config) ||
       !WebPConfigInit(&config) ||
       !WebPPictureInit(&pic)) {
     fprintf(stderr, "Library version mismatch!\n");
-    return 1;
+    ok = 0;
+    goto End;
   }
 
   // 1st pass of option parsing
-  for (c = 1; ok && c < argc; ++c) {
+  for (c = 0; ok && c < argc; ++c) {
     if (argv[c][0] == '-') {
       int parse_error = 0;
       if (!strcmp(argv[c], "-o") && c + 1 < argc) {
         argv[c] = NULL;
-        output = argv[++c];
+        output = (const char*)GET_WARGV_SHIFTED(argv, ++c);
       } else if (!strcmp(argv[c], "-kmin") && c + 1 < argc) {
         argv[c] = NULL;
         anim_config.kmin = ExUtilGetInt(argv[++c], 0, &parse_error);
@@ -171,7 +187,15 @@ int main(int argc, char* argv[]) {
         verbose = 1;
       } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
         Help();
-        return 0;
+        goto End;
+      } else if (!strcmp(argv[c], "-version")) {
+        const int enc_version = WebPGetEncoderVersion();
+        const int mux_version = WebPGetMuxVersion();
+        printf("WebP Encoder version: %d.%d.%d\nWebP Mux version: %d.%d.%d\n",
+               (enc_version >> 16) & 0xff, (enc_version >> 8) & 0xff,
+               enc_version & 0xff, (mux_version >> 16) & 0xff,
+               (mux_version >> 8) & 0xff, mux_version & 0xff);
+        goto End;
       } else {
         continue;
       }
@@ -184,13 +208,13 @@ int main(int argc, char* argv[]) {
   }
   if (!have_input) {
     fprintf(stderr, "No input file(s) for generating animation!\n");
-    return 0;
+    goto End;
   }
 
   // image-reading pass
   pic_num = 0;
   config.lossless = 1;
-  for (c = 1; ok && c < argc; ++c) {
+  for (c = 0; ok && c < argc; ++c) {
     if (argv[c] == NULL) continue;
     if (argv[c][0] == '-') {    // parse local options
       int parse_error = 0;
@@ -227,7 +251,7 @@ int main(int argc, char* argv[]) {
 
     // read next input image
     pic.use_argb = 1;
-    ok = ReadImage(argv[c], &pic);
+    ok = ReadImage((const char*)GET_WARGV_SHIFTED(argv, c), &pic);
     if (!ok) goto End;
 
     if (enc == NULL) {
@@ -259,8 +283,8 @@ int main(int argc, char* argv[]) {
     if (!ok) goto End;
 
     if (verbose) {
-      fprintf(stderr, "Added frame #%3d at time %4d (file: %s)\n",
-              pic_num, timestamp_ms, argv[c]);
+      WFPRINTF(stderr, "Added frame #%3d at time %4d (file: %s)\n",
+               pic_num, timestamp_ms, GET_WARGV_SHIFTED(argv, c));
     }
     timestamp_ms += duration;
     ++pic_num;
@@ -284,7 +308,7 @@ int main(int argc, char* argv[]) {
   if (ok) {
     if (output != NULL) {
       ok = ImgIoUtilWriteFile(output, webp_data.bytes, webp_data.size);
-      if (ok) fprintf(stderr, "output file: %s     ", output);
+      if (ok) WFPRINTF(stderr, "output file: %s     ", (const W_CHAR*)output);
     } else {
       fprintf(stderr, "[no output file specified]   ");
     }
@@ -294,7 +318,7 @@ int main(int argc, char* argv[]) {
     fprintf(stderr, "[%d frames, %u bytes].\n",
             pic_num, (unsigned int)webp_data.size);
   }
-
   WebPDataClear(&webp_data);
-  return ok ? 0 : 1;
+  ExUtilDeleteCommandLineArguments(&cmd_args);
+  FREE_WARGV_AND_RETURN(ok ? 0 : 1);
 }

examples/stopwatch.h

@@ -60,4 +60,4 @@ static WEBP_INLINE double StopwatchReadAndReset(Stopwatch* watch) {
 
 #endif   /* _WIN32 */
 
-#endif  /* WEBP_EXAMPLES_STOPWATCH_H_ */
+#endif  // WEBP_EXAMPLES_STOPWATCH_H_

examples/unicode.h

@@ -0,0 +1,102 @@
+// Copyright 2018 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.
+// -----------------------------------------------------------------------------
+//
+// Unicode support for Windows. The main idea is to maintain an array of Unicode
+// arguments (wargv) and use it only for file paths. The regular argv is used
+// for everything else.
+//
+// Author: Yannis Guyon (yguyon@google.com)
+
+#ifndef WEBP_EXAMPLES_UNICODE_H_
+#define WEBP_EXAMPLES_UNICODE_H_
+
+#if defined(_WIN32) && defined(_UNICODE)
+
+// wchar_t is used instead of TCHAR because we only perform additional work when
+// Unicode is enabled and because the output of CommandLineToArgvW() is wchar_t.
+
+#include <wchar.h>
+#include <windows.h>
+#include <shellapi.h>
+
+// Create a wchar_t array containing Unicode parameters.
+#define INIT_WARGV(ARGC, ARGV)                                                \
+  int wargc;                                                                  \
+  const W_CHAR** const wargv =                                                \
+      (const W_CHAR**)CommandLineToArgvW(GetCommandLineW(), &wargc);          \
+  do {                                                                        \
+    if (wargv == NULL || wargc != (ARGC)) {                                   \
+      fprintf(stderr, "Error: Unable to get Unicode arguments.\n");           \
+      FREE_WARGV_AND_RETURN(-1);                                              \
+    }                                                                         \
+  } while (0)
+
+// Use this to get a Unicode argument (e.g. file path).
+#define GET_WARGV(UNUSED, C) wargv[C]
+// For cases where argv is shifted by one compared to wargv.
+#define GET_WARGV_SHIFTED(UNUSED, C) wargv[(C) + 1]
+#define GET_WARGV_OR_NULL() wargv
+
+// Release resources. LocalFree() is needed after CommandLineToArgvW().
+#define FREE_WARGV() LOCAL_FREE((W_CHAR** const)wargv)
+#define LOCAL_FREE(WARGV)                  \
+  do {                                     \
+    if ((WARGV) != NULL) LocalFree(WARGV); \
+  } while (0)
+
+#define W_CHAR wchar_t  // WCHAR without underscore might already be defined.
+#define TO_W_CHAR(STR) (L##STR)
+
+#define WFOPEN(ARG, OPT) _wfopen((const W_CHAR*)ARG, TO_W_CHAR(OPT))
+
+#define WPRINTF(STR, ...) wprintf(TO_W_CHAR(STR), __VA_ARGS__)
+#define WFPRINTF(STDERR, STR, ...) fwprintf(STDERR, TO_W_CHAR(STR), __VA_ARGS__)
+
+#define WSTRLEN(FILENAME) wcslen((const W_CHAR*)FILENAME)
+#define WSTRCMP(FILENAME, STR) wcscmp((const W_CHAR*)FILENAME, TO_W_CHAR(STR))
+#define WSTRRCHR(FILENAME, STR) wcsrchr((const W_CHAR*)FILENAME, TO_W_CHAR(STR))
+#define WSNPRINTF(A, B, STR, ...) _snwprintf(A, B, TO_W_CHAR(STR), __VA_ARGS__)
+
+#else
+
+// Unicode file paths work as is on Unix platforms, and no extra work is done on
+// Windows either if Unicode is disabled.
+
+#define INIT_WARGV(ARGC, ARGV)
+
+#define GET_WARGV(ARGV, C) (ARGV)[C]
+#define GET_WARGV_SHIFTED(ARGV, C) (ARGV)[C]
+#define GET_WARGV_OR_NULL() NULL
+
+#define FREE_WARGV()
+#define LOCAL_FREE(WARGV)
+
+#define W_CHAR char
+#define TO_W_CHAR(STR) (STR)
+
+#define WFOPEN(ARG, OPT) fopen(ARG, OPT)
+
+#define WPRINTF(STR, ...) printf(STR, __VA_ARGS__)
+#define WFPRINTF(STDERR, STR, ...) fprintf(STDERR, STR, __VA_ARGS__)
+
+#define WSTRLEN(FILENAME) strlen(FILENAME)
+#define WSTRCMP(FILENAME, STR) strcmp(FILENAME, STR)
+#define WSTRRCHR(FILENAME, STR) strrchr(FILENAME, STR)
+#define WSNPRINTF(A, B, STR, ...) snprintf(A, B, STR, __VA_ARGS__)
+
+#endif  // defined(_WIN32) && defined(_UNICODE)
+
+// Don't forget to free wargv before returning (e.g. from main).
+#define FREE_WARGV_AND_RETURN(VALUE) \
+  do {                               \
+    FREE_WARGV();                    \
+    return (VALUE);                  \
+  } while (0)
+
+#endif  // WEBP_EXAMPLES_UNICODE_H_

examples/unicode_gif.h

@@ -0,0 +1,75 @@
+// Copyright 2018 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.
+// -----------------------------------------------------------------------------
+//
+// giflib doesn't have a Unicode DGifOpenFileName(). Let's make one.
+//
+// Author: Yannis Guyon (yguyon@google.com)
+
+#ifndef WEBP_EXAMPLES_UNICODE_GIF_H_
+#define WEBP_EXAMPLES_UNICODE_GIF_H_
+
+#include "./unicode.h"
+#ifdef HAVE_CONFIG_H
+#include "webp/config.h"  // For WEBP_HAVE_GIF
+#endif
+
+#if defined(WEBP_HAVE_GIF)
+
+#ifdef _WIN32
+#include <fcntl.h>  // Not standard, needed for _topen and flags.
+#include <io.h>
+#endif
+
+#include <gif_lib.h>
+#include <string.h>
+#include "./gifdec.h"
+
+#if !defined(STDIN_FILENO)
+#define STDIN_FILENO 0
+#endif
+
+static GifFileType* DGifOpenFileUnicode(const W_CHAR* file_name, int* error) {
+  if (!WSTRCMP(file_name, "-")) {
+#if LOCAL_GIF_PREREQ(5, 0)
+    return DGifOpenFileHandle(STDIN_FILENO, error);
+#else
+    (void)error;
+    return DGifOpenFileHandle(STDIN_FILENO);
+#endif
+  }
+
+#if defined(_WIN32) && defined(_UNICODE)
+
+  int file_handle = _wopen(file_name, _O_RDONLY | _O_BINARY);
+  if (file_handle == -1) {
+    if (error != NULL) *error = D_GIF_ERR_OPEN_FAILED;
+    return NULL;
+  }
+
+#if LOCAL_GIF_PREREQ(5, 0)
+  return DGifOpenFileHandle(file_handle, error);
+#else
+  return DGifOpenFileHandle(file_handle);
+#endif
+
+#else
+
+#if LOCAL_GIF_PREREQ(5, 0)
+  return DGifOpenFileName(file_name, error);
+#else
+  return DGifOpenFileName(file_name);
+#endif
+
+#endif  // defined(_WIN32) && defined(_UNICODE)
+  // DGifCloseFile() is called later.
+}
+
+#endif  // defined(WEBP_HAVE_GIF)
+
+#endif  // WEBP_EXAMPLES_UNICODE_GIF_H_

examples/vwebp.c

@@ -42,6 +42,7 @@
 
 #include "../examples/example_util.h"
 #include "../imageio/imageio_util.h"
+#include "./unicode.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
@@ -56,6 +57,7 @@ static struct {
   int print_info;
   int only_deltas;
   int use_color_profile;
+  int draw_anim_background_color;
 
   int canvas_width, canvas_height;
   int loop_count;
@@ -205,6 +207,11 @@ static void decode_callback(int what) {
         }
       }
       duration = curr->duration;
+      // Behavior copied from Chrome, cf:
+      // https://cs.chromium.org/chromium/src/third_party/WebKit/Source/
+      // platform/graphics/DeferredImageDecoder.cpp?
+      // rcl=b4c33049f096cd283f32be9a58b9a9e768227c26&l=246
+      if (duration <= 10) duration = 100;
     }
     if (!Decode()) {
       kParams.decoding_error = 1;
@@ -220,6 +227,9 @@ static void decode_callback(int what) {
 // Callbacks
 
 static void HandleKey(unsigned char key, int pos_x, int pos_y) {
+  // Note: rescaling the window or toggling some features during an animation
+  // generates visual artifacts. This is not fixed because refreshing the frame
+  // may require rendering the whole animation from start till current frame.
   (void)pos_x;
   (void)pos_y;
   if (key == 'q' || key == 'Q' || key == 27 /* Esc */) {
@@ -247,9 +257,11 @@ static void HandleKey(unsigned char key, int pos_x, int pos_y) {
         glutPostRedisplay();
       }
     }
+  } else if (key == 'b') {
+    kParams.draw_anim_background_color = 1 - kParams.draw_anim_background_color;
+    if (!kParams.has_animation) ClearPreviousFrame();
+    glutPostRedisplay();
   } else if (key == 'i') {
-    // Note: doesn't handle refresh of animation's last-frame (it's quite
-    // more involved to do, since you need to save the previous frame).
     kParams.print_info = 1 - kParams.print_info;
     if (!kParams.has_animation) ClearPreviousFrame();
     glutPostRedisplay();
@@ -281,7 +293,7 @@ static void PrintString(const char* const text) {
 }
 
 static float GetColorf(uint32_t color, int shift) {
-  return (color >> shift) / 255.f;
+  return ((color >> shift) & 0xff) / 255.f;
 }
 
 static void DrawCheckerBoard(void) {
@@ -304,6 +316,43 @@ static void DrawCheckerBoard(void) {
   glPopMatrix();
 }
 
+static void DrawBackground(void) {
+  // Whole window cleared with clear color, checkerboard rendered on top of it.
+  glClear(GL_COLOR_BUFFER_BIT);
+  DrawCheckerBoard();
+
+  // ANIM background color rendered (blend) on top. Default is white for still
+  // images (without ANIM chunk). glClear() can't be used for that (no blend).
+  if (kParams.draw_anim_background_color) {
+    glPushMatrix();
+    glLoadIdentity();
+    glColor4f(GetColorf(kParams.bg_color, 16),  // BGRA from spec
+              GetColorf(kParams.bg_color, 8),
+              GetColorf(kParams.bg_color, 0),
+              GetColorf(kParams.bg_color, 24));
+    glRecti(-1, -1, +1, +1);
+    glPopMatrix();
+  }
+}
+
+// Draw background in a scissored rectangle.
+static void DrawBackgroundScissored(int window_x, int window_y, int frame_w,
+                                    int frame_h) {
+  // Only update the requested area, not the whole canvas.
+  window_x = window_x * kParams.viewport_width / kParams.canvas_width;
+  window_y = window_y * kParams.viewport_height / kParams.canvas_height;
+  frame_w = frame_w * kParams.viewport_width / kParams.canvas_width;
+  frame_h = frame_h * kParams.viewport_height / kParams.canvas_height;
+
+  // glScissor() takes window coordinates (0,0 at bottom left).
+  window_y = kParams.viewport_height - window_y - frame_h;
+
+  glEnable(GL_SCISSOR_TEST);
+  glScissor(window_x, window_y, frame_w, frame_h);
+  DrawBackground();
+  glDisable(GL_SCISSOR_TEST);
+}
+
 static void HandleDisplay(void) {
   const WebPDecBuffer* const pic = kParams.pic;
   const WebPIterator* const curr = &kParams.curr_frame;
@@ -320,38 +369,21 @@ static void HandleDisplay(void) {
   glPixelStorei(GL_UNPACK_ROW_LENGTH, pic->u.RGBA.stride / 4);
 
   if (kParams.only_deltas) {
-    DrawCheckerBoard();
-  } else if (prev->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND ||
-      curr->blend_method == WEBP_MUX_NO_BLEND) {
-    // glScissor() takes window coordinates (0,0 at bottom left).
-    int window_x, window_y;
-    int frame_w, frame_h;
+    DrawBackground();
+  } else {
+    // The rectangle of the previous frame might be different than the current
+    // frame, so we may need to DrawBackgroundScissored for both.
     if (prev->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
       // Clear the previous frame rectangle.
-      window_x = prev->x_offset;
-      window_y = kParams.canvas_height - prev->y_offset - prev->height;
-      frame_w = prev->width;
-      frame_h = prev->height;
-    } else {  // curr->blend_method == WEBP_MUX_NO_BLEND.
-      // We simulate no-blending behavior by first clearing the current frame
-      // rectangle (to a checker-board) and then alpha-blending against it.
-      window_x = curr->x_offset;
-      window_y = kParams.canvas_height - curr->y_offset - curr->height;
-      frame_w = curr->width;
-      frame_h = curr->height;
+      DrawBackgroundScissored(prev->x_offset, prev->y_offset, prev->width,
+                              prev->height);
+    }
+    if (curr->blend_method == WEBP_MUX_NO_BLEND) {
+      // We simulate no-blending behavior by first clearing the current frame
+      // rectangle and then alpha-blending against it.
+      DrawBackgroundScissored(curr->x_offset, curr->y_offset, curr->width,
+                              curr->height);
     }
-    glEnable(GL_SCISSOR_TEST);
-    // Only update the requested area, not the whole canvas.
-    window_x = window_x * kParams.viewport_width / kParams.canvas_width;
-    window_y = window_y * kParams.viewport_height / kParams.canvas_height;
-    frame_w = frame_w * kParams.viewport_width / kParams.canvas_width;
-    frame_h = frame_h * kParams.viewport_height / kParams.canvas_height;
-    glScissor(window_x, window_y, frame_w, frame_h);
-
-    glClear(GL_COLOR_BUFFER_BIT);  // use clear color
-    DrawCheckerBoard();
-
-    glDisable(GL_SCISSOR_TEST);
   }
 
   *prev = *curr;
@@ -386,8 +418,9 @@ static void HandleDisplay(void) {
 }
 
 static void StartDisplay(void) {
-  const int width = kParams.canvas_width;
-  const int height = kParams.canvas_height;
+  int width = kParams.canvas_width;
+  int height = kParams.canvas_height;
+  int screen_width, screen_height;
   // TODO(webp:365) GLUT_DOUBLE results in flickering / old frames to be
   // partially displayed with animated webp + alpha.
 #if defined(__APPLE__) || defined(_WIN32)
@@ -395,6 +428,18 @@ 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);
@@ -403,19 +448,16 @@ static void StartDisplay(void) {
   glutKeyboardFunc(HandleKey);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glEnable(GL_BLEND);
-  glClearColor(GetColorf(kParams.bg_color, 0),
-               GetColorf(kParams.bg_color, 8),
-               GetColorf(kParams.bg_color, 16),
-               GetColorf(kParams.bg_color, 24));
-  glClear(GL_COLOR_BUFFER_BIT);
-  DrawCheckerBoard();
+  glClearColor(0, 0, 0, 0);  // window will be cleared to black (no blend)
+  DrawBackground();
 }
 
 //------------------------------------------------------------------------------
 // Main
 
 static void Help(void) {
-  printf("Usage: vwebp in_file [options]\n\n"
+  printf(
+      "Usage: vwebp in_file [options]\n\n"
       "Decodes the WebP image file and visualize it using OpenGL\n"
       "Options are:\n"
       "  -version ..... print version number and exit\n"
@@ -424,16 +466,17 @@ static void Help(void) {
       "  -nofilter .... disable in-loop filtering\n"
       "  -dither <int>  dithering strength (0..100), default=50\n"
       "  -noalphadither disable alpha plane dithering\n"
+      "  -usebgcolor .. display background color\n"
       "  -mt .......... use multi-threading\n"
       "  -info ........ print info\n"
       "  -h ........... this help message\n"
       "\n"
       "Keyboard shortcuts:\n"
       "  'c' ................ toggle use of color profile\n"
+      "  'b' ................ toggle background color display\n"
       "  'i' ................ overlay file information\n"
       "  'd' ................ disable blending & disposal (debug)\n"
-         "  'q' / 'Q' / ESC .... quit\n"
-        );
+      "  'q' / 'Q' / ESC .... quit\n");
 }
 
 int main(int argc, char* argv[]) {
@@ -441,19 +484,23 @@ int main(int argc, char *argv[]) {
   WebPDecoderConfig* const config = &kParams.config;
   WebPIterator* const curr = &kParams.curr_frame;
 
+  INIT_WARGV(argc, argv);
+
   if (!WebPInitDecoderConfig(config)) {
     fprintf(stderr, "Library version mismatch!\n");
-    return -1;
+    FREE_WARGV_AND_RETURN(-1);
   }
   config->options.dithering_strength = 50;
   config->options.alpha_dithering_strength = 100;
   kParams.use_color_profile = 1;
+  // Background color hidden by default to see transparent areas.
+  kParams.draw_anim_background_color = 0;
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       Help();
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-noicc")) {
       kParams.use_color_profile = 0;
     } else if (!strcmp(argv[c], "-nofancy")) {
@@ -462,6 +509,8 @@ int main(int argc, char *argv[]) {
       config->options.bypass_filtering = 1;
     } else if (!strcmp(argv[c], "-noalphadither")) {
       config->options.alpha_dithering_strength = 0;
+    } else if (!strcmp(argv[c], "-usebgcolor")) {
+      kParams.draw_anim_background_color = 1;
     } else if (!strcmp(argv[c], "-dither") && c + 1 < argc) {
       config->options.dithering_strength =
           ExUtilGetInt(argv[++c], 0, &parse_error);
@@ -474,30 +523,30 @@ int main(int argc, char *argv[]) {
              (dec_version >> 16) & 0xff, (dec_version >> 8) & 0xff,
              dec_version & 0xff, (dmux_version >> 16) & 0xff,
              (dmux_version >> 8) & 0xff, dmux_version & 0xff);
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else if (!strcmp(argv[c], "-mt")) {
       config->options.use_threads = 1;
     } else if (!strcmp(argv[c], "--")) {
-      if (c < argc - 1) kParams.file_name = argv[++c];
+      if (c < argc - 1) kParams.file_name = (const char*)GET_WARGV(argv, ++c);
       break;
     } else if (argv[c][0] == '-') {
       printf("Unknown option '%s'\n", argv[c]);
       Help();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     } else {
-      kParams.file_name = argv[c];
+      kParams.file_name = (const char*)GET_WARGV(argv, c);
     }
 
     if (parse_error) {
       Help();
-      return -1;
+      FREE_WARGV_AND_RETURN(-1);
     }
   }
 
   if (kParams.file_name == NULL) {
     printf("missing input file!!\n");
     Help();
-    return 0;
+    FREE_WARGV_AND_RETURN(0);
   }
 
   if (!ImgIoUtilReadFile(kParams.file_name,
@@ -572,11 +621,11 @@ int main(int argc, char *argv[]) {
 
   // Should only be reached when using FREEGLUT:
   ClearParams();
-  return 0;
+  FREE_WARGV_AND_RETURN(0);
 
  Error:
   ClearParams();
-  return -1;
+  FREE_WARGV_AND_RETURN(-1);
 }
 
 #else   // !WEBP_HAVE_GL

examples/webpinfo.c

@@ -20,6 +20,7 @@
 #endif
 
 #include "../imageio/imageio_util.h"
+#include "./unicode.h"
 #include "webp/decode.h"
 #include "webp/format_constants.h"
 #include "webp/mux_types.h"
@@ -340,7 +341,7 @@ static WebPInfoStatus ParseLossyHeader(const ChunkData* const chunk_data,
   WebPInfoStatus status = WEBP_INFO_OK;
   uint64_t bit_position = 0;
   uint64_t* const bit_pos = &bit_position;
-  int color_space, clamp_type;
+  int colorspace, clamp_type;
   printf("  Parsing lossy bitstream...\n");
   // Calling WebPGetFeatures() in ProcessImageChunk() should ensure this.
   assert(chunk_data->size_ >= CHUNK_HEADER_SIZE + 10);
@@ -381,9 +382,9 @@ static WebPInfoStatus ParseLossyHeader(const ChunkData* const chunk_data,
     LOG_ERROR("Bad partition length.");
     return WEBP_INFO_BITSTREAM_ERROR;
   }
-  GET_BITS(color_space, 1);
+  GET_BITS(colorspace, 1);
   GET_BITS(clamp_type, 1);
-  printf("  Color space:      %d\n", color_space);
+  printf("  Color space:      %d\n", colorspace);
   printf("  Clamp type:       %d\n", clamp_type);
   status = ParseLossySegmentHeader(webp_info, data, data_size, bit_pos);
   if (status != WEBP_INFO_OK) return status;
@@ -1119,19 +1120,21 @@ int main(int argc, const char* argv[]) {
   WebPInfoStatus webp_info_status = WEBP_INFO_OK;
   WebPInfo webp_info;
 
+  INIT_WARGV(argc, argv);
+
   if (argc == 1) {
     HelpShort();
-    return WEBP_INFO_OK;
+    FREE_WARGV_AND_RETURN(WEBP_INFO_OK);
   }
 
   // Parse command-line input.
   for (c = 1; c < argc; ++c) {
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       HelpShort();
-      return WEBP_INFO_OK;
+      FREE_WARGV_AND_RETURN(WEBP_INFO_OK);
     } else if (!strcmp(argv[c], "-H") || !strcmp(argv[c], "-longhelp")) {
       HelpLong();
-      return WEBP_INFO_OK;
+      FREE_WARGV_AND_RETURN(WEBP_INFO_OK);
     } else if (!strcmp(argv[c], "-quiet")) {
       quiet = 1;
     } else if (!strcmp(argv[c], "-diag")) {
@@ -1144,7 +1147,7 @@ int main(int argc, const char* argv[]) {
       const int version = WebPGetDecoderVersion();
       printf("WebP Decoder version: %d.%d.%d\n",
              (version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else {  // Assume the remaining are all input files.
       break;
     }
@@ -1152,27 +1155,28 @@ int main(int argc, const char* argv[]) {
 
   if (c == argc) {
     HelpShort();
-    return WEBP_INFO_INVALID_COMMAND;
+    FREE_WARGV_AND_RETURN(WEBP_INFO_INVALID_COMMAND);
   }
 
   // Process input files one by one.
   for (; c < argc; ++c) {
     WebPData webp_data;
-    const char* in_file = NULL;
+    const W_CHAR* in_file = NULL;
     WebPInfoInit(&webp_info);
     webp_info.quiet_ = quiet;
     webp_info.show_diagnosis_ = show_diag;
     webp_info.show_summary_ = show_summary;
     webp_info.parse_bitstream_ = parse_bitstream;
-    in_file = argv[c];
-    if (in_file == NULL || !ReadFileToWebPData(in_file, &webp_data)) {
+    in_file = GET_WARGV(argv, c);
+    if (in_file == NULL ||
+        !ReadFileToWebPData((const char*)in_file, &webp_data)) {
       webp_info_status = WEBP_INFO_INVALID_COMMAND;
-      fprintf(stderr, "Failed to open input file %s.\n", in_file);
+      WFPRINTF(stderr, "Failed to open input file %s.\n", in_file);
       continue;
     }
-    if (!webp_info.quiet_) printf("File: %s\n", in_file);
+    if (!webp_info.quiet_) WPRINTF("File: %s\n", in_file);
     webp_info_status = AnalyzeWebP(&webp_info, &webp_data);
     WebPDataClear(&webp_data);
   }
-  return webp_info_status;
+  FREE_WARGV_AND_RETURN(webp_info_status);
 }

examples/webpmux.c

@@ -47,6 +47,7 @@
     webpmux -info in.webp
     webpmux [ -h | -help ]
     webpmux -version
+    webpmux argument_file_name
 */
 
 #ifdef HAVE_CONFIG_H
@@ -61,6 +62,7 @@
 #include "webp/mux.h"
 #include "../examples/example_util.h"
 #include "../imageio/imageio_util.h"
+#include "./unicode.h"
 
 //------------------------------------------------------------------------------
 // Config object to parse command-line arguments.
@@ -108,28 +110,26 @@ static const char* const kDescriptions[LAST_FEATURE] = {
 };
 
 typedef struct {
-  FeatureType type_;
-  FeatureArg* args_;
-  int arg_count_;
-} Feature;
+  CommandLineArguments cmd_args_;
 
-typedef struct {
   ActionType action_type_;
   const char* input_;
   const char* output_;
-  Feature feature_;
-} WebPMuxConfig;
+  FeatureType type_;
+  FeatureArg* args_;
+  int arg_count_;
+} Config;
 
 //------------------------------------------------------------------------------
 // Helper functions.
 
-static int CountOccurrences(const char* arglist[], int list_length,
-                            const char* arg) {
+static int CountOccurrences(const CommandLineArguments* const args,
+                            const char* const arg) {
   int i;
   int num_occurences = 0;
 
-  for (i = 0; i < list_length; ++i) {
-    if (!strcmp(arglist[i], arg)) {
+  for (i = 0; i < args->argc_; ++i) {
+    if (!strcmp(args->argv_[i], arg)) {
       ++num_occurences;
     }
   }
@@ -301,6 +301,7 @@ static void PrintHelp(void) {
   printf("       webpmux -info INPUT\n");
   printf("       webpmux [-h|-help]\n");
   printf("       webpmux -version\n");
+  printf("       webpmux argument_file_name\n");
 
   printf("\n");
   printf("GET_OPTIONS:\n");
@@ -369,6 +370,10 @@ static void PrintHelp(void) {
 
   printf("\nNote: The nature of EXIF, XMP and ICC data is not checked");
   printf(" and is assumed to be\nvalid.\n");
+  printf("\nNote: if a single file name is passed as the argument, the "
+         "arguments will be\n");
+  printf("tokenized from this file. The file name must not start with "
+         "the character '-'.\n");
 }
 
 static void WarnAboutOddOffset(const WebPMuxFrameInfo* const info) {
@@ -379,40 +384,32 @@ static void WarnAboutOddOffset(const WebPMuxFrameInfo* const info) {
   }
 }
 
-static int ReadFileToWebPData(const char* const filename,
-                              WebPData* const webp_data) {
-  const uint8_t* data;
-  size_t size;
-  if (!ImgIoUtilReadFile(filename, &data, &size)) return 0;
-  webp_data->bytes = data;
-  webp_data->size = size;
-  return 1;
-}
-
 static int CreateMux(const char* const filename, WebPMux** mux) {
   WebPData bitstream;
   assert(mux != NULL);
-  if (!ReadFileToWebPData(filename, &bitstream)) return 0;
+  if (!ExUtilReadFileToWebPData(filename, &bitstream)) return 0;
   *mux = WebPMuxCreate(&bitstream, 1);
-  free((void*)bitstream.bytes);
+  WebPDataClear(&bitstream);
   if (*mux != NULL) return 1;
-  fprintf(stderr, "Failed to create mux object from file %s.\n", filename);
+  WFPRINTF(stderr, "Failed to create mux object from file %s.\n",
+           (const W_CHAR*)filename);
   return 0;
 }
 
 static int WriteData(const char* filename, const WebPData* const webpdata) {
   int ok = 0;
-  FILE* fout = strcmp(filename, "-") ? fopen(filename, "wb")
+  FILE* fout = WSTRCMP(filename, "-") ? WFOPEN(filename, "wb")
                                       : ImgIoUtilSetBinaryMode(stdout);
   if (fout == NULL) {
-    fprintf(stderr, "Error opening output WebP file %s!\n", filename);
+    WFPRINTF(stderr, "Error opening output WebP file %s!\n",
+             (const W_CHAR*)filename);
     return 0;
   }
   if (fwrite(webpdata->bytes, webpdata->size, 1, fout) != 1) {
-    fprintf(stderr, "Error writing file %s!\n", filename);
+    WFPRINTF(stderr, "Error writing file %s!\n", (const W_CHAR*)filename);
   } else {
-    fprintf(stderr, "Saved file %s (%d bytes)\n",
-            filename, (int)webpdata->size);
+    WFPRINTF(stderr, "Saved file %s (%d bytes)\n",
+             (const W_CHAR*)filename, (int)webpdata->size);
     ok = 1;
   }
   if (fout != stdout) fclose(fout);
@@ -517,9 +514,10 @@ static int ParseBgcolorArgs(const char* args, uint32_t* const bgcolor) {
 //------------------------------------------------------------------------------
 // Clean-up.
 
-static void DeleteConfig(WebPMuxConfig* config) {
+static void DeleteConfig(Config* const config) {
   if (config != NULL) {
-    free(config->feature_.args_);
+    free(config->args_);
+    ExUtilDeleteCommandLineArguments(&config->cmd_args_);
     memset(config, 0, sizeof(*config));
   }
 }
@@ -531,7 +529,7 @@ static void DeleteConfig(WebPMuxConfig* config) {
 // Returns 1 on valid, 0 otherwise.
 // Also fills up num_feature_args to be number of feature arguments given.
 // (e.g. if there are 4 '-frame's and 1 '-loop', then num_feature_args = 5).
-static int ValidateCommandLine(int argc, const char* argv[],
+static int ValidateCommandLine(const CommandLineArguments* const cmd_args,
                                int* num_feature_args) {
   int num_frame_args;
   int num_loop_args;
@@ -543,27 +541,27 @@ static int ValidateCommandLine(int argc, const char* argv[],
   *num_feature_args = 0;
 
   // Simple checks.
-  if (CountOccurrences(argv, argc, "-get") > 1) {
+  if (CountOccurrences(cmd_args, "-get") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-get' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(argv, argc, "-set") > 1) {
+  if (CountOccurrences(cmd_args, "-set") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-set' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(argv, argc, "-strip") > 1) {
+  if (CountOccurrences(cmd_args, "-strip") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-strip' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(argv, argc, "-info") > 1) {
+  if (CountOccurrences(cmd_args, "-info") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-info' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(argv, argc, "-o") > 1) {
+  if (CountOccurrences(cmd_args, "-o") > 1) {
     ERROR_GOTO1("ERROR: Multiple output files specified.\n", ErrValidate);
   }
 
   // Compound checks.
-  num_frame_args = CountOccurrences(argv, argc, "-frame");
-  num_loop_args = CountOccurrences(argv, argc, "-loop");
-  num_bgcolor_args = CountOccurrences(argv, argc, "-bgcolor");
-  num_durations_args = CountOccurrences(argv, argc, "-duration");
+  num_frame_args = CountOccurrences(cmd_args, "-frame");
+  num_loop_args = CountOccurrences(cmd_args, "-loop");
+  num_bgcolor_args = CountOccurrences(cmd_args, "-bgcolor");
+  num_durations_args = CountOccurrences(cmd_args, "-duration");
 
   if (num_loop_args > 1) {
     ERROR_GOTO1("ERROR: Multiple loop counts specified.\n", ErrValidate);
@@ -598,31 +596,38 @@ static int ValidateCommandLine(int argc, const char* argv[],
 
 #define ACTION_IS_NIL (config->action_type_ == NIL_ACTION)
 
-#define FEATURETYPE_IS_NIL (feature->type_ == NIL_FEATURE)
+#define FEATURETYPE_IS_NIL (config->type_ == NIL_FEATURE)
 
-#define CHECK_NUM_ARGS_LESS(NUM, LABEL)                                  \
+#define CHECK_NUM_ARGS_AT_LEAST(NUM, LABEL)                              \
   if (argc < i + (NUM)) {                                                \
     fprintf(stderr, "ERROR: Too few arguments for '%s'.\n", argv[i]);    \
     goto LABEL;                                                          \
   }
 
-#define CHECK_NUM_ARGS_NOT_EQUAL(NUM, LABEL)                             \
-  if (argc != i + (NUM)) {                                               \
+#define CHECK_NUM_ARGS_AT_MOST(NUM, LABEL)                               \
+  if (argc > i + (NUM)) {                                                \
     fprintf(stderr, "ERROR: Too many arguments for '%s'.\n", argv[i]);   \
     goto LABEL;                                                          \
   }
 
+#define CHECK_NUM_ARGS_EXACTLY(NUM, LABEL)                               \
+  CHECK_NUM_ARGS_AT_LEAST(NUM, LABEL);                                   \
+  CHECK_NUM_ARGS_AT_MOST(NUM, LABEL);
+
 // Parses command-line arguments to fill up config object. Also performs some
-// semantic checks.
-static int ParseCommandLine(int argc, const char* argv[],
-                            WebPMuxConfig* config) {
+// semantic checks. unicode_argv contains wchar_t arguments or is null.
+static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
   int i = 0;
   int feature_arg_index = 0;
   int ok = 1;
+  int argc = config->cmd_args_.argc_;
+  const char* const* argv = config->cmd_args_.argv_;
+  // Unicode file paths will be used if available.
+  const char* const* wargv =
+      (unicode_argv != NULL) ? (const char**)(unicode_argv + 1) : argv;
 
   while (i < argc) {
-    Feature* const feature = &config->feature_;
-    FeatureArg* const arg = &feature->args_[feature_arg_index];
+    FeatureArg* const arg = &config->args_[feature_arg_index];
     if (argv[i][0] == '-') {  // One of the action types or output.
       if (!strcmp(argv[i], "-set")) {
         if (ACTION_IS_NIL) {
@@ -632,14 +637,14 @@ static int ParseCommandLine(int argc, const char* argv[],
         }
         ++i;
       } else if (!strcmp(argv[i], "-duration")) {
-        CHECK_NUM_ARGS_LESS(2, ErrParse);
+        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
         if (ACTION_IS_NIL || config->action_type_ == ACTION_DURATION) {
           config->action_type_ = ACTION_DURATION;
         } else {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         }
-        if (FEATURETYPE_IS_NIL || feature->type_ == FEATURE_DURATION) {
-          feature->type_ = FEATURE_DURATION;
+        if (FEATURETYPE_IS_NIL || config->type_ == FEATURE_DURATION) {
+          config->type_ = FEATURE_DURATION;
         } else {
           ERROR_GOTO1("ERROR: Multiple features specified.\n", ErrParse);
         }
@@ -656,20 +661,20 @@ static int ParseCommandLine(int argc, const char* argv[],
       } else if (!strcmp(argv[i], "-strip")) {
         if (ACTION_IS_NIL) {
           config->action_type_ = ACTION_STRIP;
-          feature->arg_count_ = 0;
+          config->arg_count_ = 0;
         } else {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         }
         ++i;
       } else if (!strcmp(argv[i], "-frame")) {
-        CHECK_NUM_ARGS_LESS(3, ErrParse);
+        CHECK_NUM_ARGS_AT_LEAST(3, ErrParse);
         if (ACTION_IS_NIL || config->action_type_ == ACTION_SET) {
           config->action_type_ = ACTION_SET;
         } else {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         }
-        if (FEATURETYPE_IS_NIL || feature->type_ == FEATURE_ANMF) {
-          feature->type_ = FEATURE_ANMF;
+        if (FEATURETYPE_IS_NIL || config->type_ == FEATURE_ANMF) {
+          config->type_ = FEATURE_ANMF;
         } else {
           ERROR_GOTO1("ERROR: Multiple features specified.\n", ErrParse);
         }
@@ -679,14 +684,14 @@ static int ParseCommandLine(int argc, const char* argv[],
         ++feature_arg_index;
         i += 3;
       } else if (!strcmp(argv[i], "-loop") || !strcmp(argv[i], "-bgcolor")) {
-        CHECK_NUM_ARGS_LESS(2, ErrParse);
+        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
         if (ACTION_IS_NIL || config->action_type_ == ACTION_SET) {
           config->action_type_ = ACTION_SET;
         } else {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         }
-        if (FEATURETYPE_IS_NIL || feature->type_ == FEATURE_ANMF) {
-          feature->type_ = FEATURE_ANMF;
+        if (FEATURETYPE_IS_NIL || config->type_ == FEATURE_ANMF) {
+          config->type_ = FEATURE_ANMF;
         } else {
           ERROR_GOTO1("ERROR: Multiple features specified.\n", ErrParse);
         }
@@ -696,34 +701,36 @@ static int ParseCommandLine(int argc, const char* argv[],
         ++feature_arg_index;
         i += 2;
       } else if (!strcmp(argv[i], "-o")) {
-        CHECK_NUM_ARGS_LESS(2, ErrParse);
-        config->output_ = argv[i + 1];
+        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
+        config->output_ = wargv[i + 1];
         i += 2;
       } else if (!strcmp(argv[i], "-info")) {
-        CHECK_NUM_ARGS_NOT_EQUAL(2, ErrParse);
+        CHECK_NUM_ARGS_EXACTLY(2, ErrParse);
         if (config->action_type_ != NIL_ACTION) {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         } else {
           config->action_type_ = ACTION_INFO;
-          feature->arg_count_ = 0;
-          config->input_ = argv[i + 1];
+          config->arg_count_ = 0;
+          config->input_ = wargv[i + 1];
         }
         i += 2;
       } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "-help")) {
         PrintHelp();
         DeleteConfig(config);
+        LOCAL_FREE((W_CHAR** const)unicode_argv);
         exit(0);
       } else if (!strcmp(argv[i], "-version")) {
         const int version = WebPGetMuxVersion();
         printf("%d.%d.%d\n",
                (version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
         DeleteConfig(config);
+        LOCAL_FREE((W_CHAR** const)unicode_argv);
         exit(0);
       } else if (!strcmp(argv[i], "--")) {
         if (i < argc - 1) {
           ++i;
           if (config->input_ == NULL) {
-            config->input_ = argv[i];
+            config->input_ = wargv[i];
           } else {
             ERROR_GOTO2("ERROR at '%s': Multiple input files specified.\n",
                         argv[i], ErrParse);
@@ -741,14 +748,14 @@ static int ParseCommandLine(int argc, const char* argv[],
       if (!strcmp(argv[i], "icc") || !strcmp(argv[i], "exif") ||
           !strcmp(argv[i], "xmp")) {
         if (FEATURETYPE_IS_NIL) {
-          feature->type_ = (!strcmp(argv[i], "icc")) ? FEATURE_ICCP :
+          config->type_ = (!strcmp(argv[i], "icc")) ? FEATURE_ICCP :
               (!strcmp(argv[i], "exif")) ? FEATURE_EXIF : FEATURE_XMP;
         } else {
           ERROR_GOTO1("ERROR: Multiple features specified.\n", ErrParse);
         }
         if (config->action_type_ == ACTION_SET) {
-          CHECK_NUM_ARGS_LESS(2, ErrParse);
-          arg->filename_ = argv[i + 1];
+          CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
+          arg->filename_ = wargv[i + 1];
           ++feature_arg_index;
           i += 2;
         } else {
@@ -756,14 +763,14 @@ static int ParseCommandLine(int argc, const char* argv[],
         }
       } else if (!strcmp(argv[i], "frame") &&
                  (config->action_type_ == ACTION_GET)) {
-        CHECK_NUM_ARGS_LESS(2, ErrParse);
-        feature->type_ = FEATURE_ANMF;
+        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
+        config->type_ = FEATURE_ANMF;
         arg->params_ = argv[i + 1];
         ++feature_arg_index;
         i += 2;
       } else {  // Assume input file.
         if (config->input_ == NULL) {
-          config->input_ = argv[i];
+          config->input_ = wargv[i];
         } else {
           ERROR_GOTO2("ERROR at '%s': Multiple input files specified.\n",
                       argv[i], ErrParse);
@@ -777,9 +784,8 @@ static int ParseCommandLine(int argc, const char* argv[],
 }
 
 // Additional checks after config is filled.
-static int ValidateConfig(WebPMuxConfig* config) {
+static int ValidateConfig(Config* const config) {
   int ok = 1;
-  Feature* const feature = &config->feature_;
 
   // Action.
   if (ACTION_IS_NIL) {
@@ -795,7 +801,7 @@ static int ValidateConfig(WebPMuxConfig* config) {
   if (config->input_ == NULL) {
     if (config->action_type_ != ACTION_SET) {
       ERROR_GOTO1("ERROR: No input file specified.\n", ErrValidate2);
-    } else if (feature->type_ != FEATURE_ANMF) {
+    } else if (config->type_ != FEATURE_ANMF) {
       ERROR_GOTO1("ERROR: No input file specified.\n", ErrValidate2);
     }
   }
@@ -810,28 +816,29 @@ static int ValidateConfig(WebPMuxConfig* config) {
 }
 
 // Create config object from command-line arguments.
-static int InitializeConfig(int argc, const char* argv[],
-                            WebPMuxConfig* config) {
+static int InitializeConfig(int argc, const char* argv[], Config* const config,
+                            const W_CHAR** const unicode_argv) {
   int num_feature_args = 0;
-  int ok = 1;
+  int ok;
 
-  assert(config != NULL);
   memset(config, 0, sizeof(*config));
 
+  ok = ExUtilInitCommandLineArguments(argc, argv, &config->cmd_args_);
+  if (!ok) return 0;
+
   // Validate command-line arguments.
-  if (!ValidateCommandLine(argc, argv, &num_feature_args)) {
+  if (!ValidateCommandLine(&config->cmd_args_, &num_feature_args)) {
     ERROR_GOTO1("Exiting due to command-line parsing error.\n", Err1);
   }
 
-  config->feature_.arg_count_ = num_feature_args;
-  config->feature_.args_ =
-      (FeatureArg*)calloc(num_feature_args, sizeof(*config->feature_.args_));
-  if (config->feature_.args_ == NULL) {
+  config->arg_count_ = num_feature_args;
+  config->args_ = (FeatureArg*)calloc(num_feature_args, sizeof(*config->args_));
+  if (config->args_ == NULL) {
     ERROR_GOTO1("ERROR: Memory allocation error.\n", Err1);
   }
 
   // Parse command-line.
-  if (!ParseCommandLine(argc, argv, config) || !ValidateConfig(config)) {
+  if (!ParseCommandLine(config, unicode_argv) || !ValidateConfig(config)) {
     ERROR_GOTO1("Exiting due to command-line parsing error.\n", Err1);
   }
 
@@ -841,13 +848,14 @@ static int InitializeConfig(int argc, const char* argv[],
 
 #undef ACTION_IS_NIL
 #undef FEATURETYPE_IS_NIL
-#undef CHECK_NUM_ARGS_LESS
-#undef CHECK_NUM_ARGS_MORE
+#undef CHECK_NUM_ARGS_AT_LEAST
+#undef CHECK_NUM_ARGS_AT_MOST
+#undef CHECK_NUM_ARGS_EXACTLY
 
 //------------------------------------------------------------------------------
 // Processing.
 
-static int GetFrame(const WebPMux* mux, const WebPMuxConfig* config) {
+static int GetFrame(const WebPMux* mux, const Config* config) {
   WebPMuxError err = WEBP_MUX_OK;
   WebPMux* mux_single = NULL;
   int num = 0;
@@ -857,7 +865,7 @@ static int GetFrame(const WebPMux* mux, const WebPMuxConfig* config) {
   WebPMuxFrameInfo info;
   WebPDataInit(&info.bitstream);
 
-  num = ExUtilGetInt(config->feature_.args_[0].params_, 10, &parse_error);
+  num = ExUtilGetInt(config->args_[0].params_, 10, &parse_error);
   if (num < 0) {
     ERROR_GOTO1("ERROR: Frame/Fragment index must be non-negative.\n", ErrGet);
   }
@@ -891,18 +899,17 @@ static int GetFrame(const WebPMux* mux, const WebPMuxConfig* config) {
 }
 
 // Read and process config.
-static int Process(const WebPMuxConfig* config) {
+static int Process(const Config* config) {
   WebPMux* mux = NULL;
   WebPData chunk;
   WebPMuxError err = WEBP_MUX_OK;
   int ok = 1;
-  const Feature* const feature = &config->feature_;
 
   switch (config->action_type_) {
     case ACTION_GET: {
       ok = CreateMux(config->input_, &mux);
       if (!ok) goto Err2;
-      switch (feature->type_) {
+      switch (config->type_) {
         case FEATURE_ANMF:
           ok = GetFrame(mux, config);
           break;
@@ -910,10 +917,10 @@ static int Process(const WebPMuxConfig* config) {
         case FEATURE_ICCP:
         case FEATURE_EXIF:
         case FEATURE_XMP:
-          err = WebPMuxGetChunk(mux, kFourccList[feature->type_], &chunk);
+          err = WebPMuxGetChunk(mux, kFourccList[config->type_], &chunk);
           if (err != WEBP_MUX_OK) {
             ERROR_GOTO3("ERROR (%s): Could not get the %s.\n",
-                        ErrorString(err), kDescriptions[feature->type_], Err2);
+                        ErrorString(err), kDescriptions[config->type_], Err2);
           }
           ok = WriteData(config->output_, &chunk);
           break;
@@ -925,7 +932,7 @@ static int Process(const WebPMuxConfig* config) {
       break;
     }
     case ACTION_SET: {
-      switch (feature->type_) {
+      switch (config->type_) {
         case FEATURE_ANMF: {
           int i;
           WebPMuxAnimParams params = { 0xFFFFFFFF, 0 };
@@ -934,11 +941,11 @@ static int Process(const WebPMuxConfig* config) {
             ERROR_GOTO2("ERROR (%s): Could not allocate a mux object.\n",
                         ErrorString(WEBP_MUX_MEMORY_ERROR), Err2);
           }
-          for (i = 0; i < feature->arg_count_; ++i) {
-            switch (feature->args_[i].subtype_) {
+          for (i = 0; i < config->arg_count_; ++i) {
+            switch (config->args_[i].subtype_) {
               case SUBTYPE_BGCOLOR: {
                 uint32_t bgcolor;
-                ok = ParseBgcolorArgs(feature->args_[i].params_, &bgcolor);
+                ok = ParseBgcolorArgs(config->args_[i].params_, &bgcolor);
                 if (!ok) {
                   ERROR_GOTO1("ERROR: Could not parse the background color \n",
                               Err2);
@@ -949,7 +956,7 @@ static int Process(const WebPMuxConfig* config) {
               case SUBTYPE_LOOP: {
                 int parse_error = 0;
                 const int loop_count =
-                    ExUtilGetInt(feature->args_[i].params_, 10, &parse_error);
+                    ExUtilGetInt(config->args_[i].params_, 10, &parse_error);
                 if (loop_count < 0 || loop_count > 65535) {
                   // Note: This is only a 'necessary' condition for loop_count
                   // to be valid. The 'sufficient' conditioned in checked in
@@ -965,10 +972,10 @@ static int Process(const WebPMuxConfig* config) {
               case SUBTYPE_ANMF: {
                 WebPMuxFrameInfo frame;
                 frame.id = WEBP_CHUNK_ANMF;
-                ok = ReadFileToWebPData(feature->args_[i].filename_,
+                ok = ExUtilReadFileToWebPData(config->args_[i].filename_,
                                               &frame.bitstream);
                 if (!ok) goto Err2;
-                ok = ParseFrameArgs(feature->args_[i].params_, &frame);
+                ok = ParseFrameArgs(config->args_[i].params_, &frame);
                 if (!ok) {
                   WebPDataClear(&frame.bitstream);
                   ERROR_GOTO1("ERROR: Could not parse frame properties.\n",
@@ -1001,13 +1008,13 @@ static int Process(const WebPMuxConfig* config) {
         case FEATURE_XMP: {
           ok = CreateMux(config->input_, &mux);
           if (!ok) goto Err2;
-          ok = ReadFileToWebPData(feature->args_[0].filename_, &chunk);
+          ok = ExUtilReadFileToWebPData(config->args_[0].filename_, &chunk);
           if (!ok) goto Err2;
-          err = WebPMuxSetChunk(mux, kFourccList[feature->type_], &chunk, 1);
+          err = WebPMuxSetChunk(mux, kFourccList[config->type_], &chunk, 1);
           free((void*)chunk.bytes);
           if (err != WEBP_MUX_OK) {
             ERROR_GOTO3("ERROR (%s): Could not set the %s.\n",
-                        ErrorString(err), kDescriptions[feature->type_], Err2);
+                        ErrorString(err), kDescriptions[config->type_], Err2);
           }
           break;
         }
@@ -1038,16 +1045,16 @@ static int Process(const WebPMuxConfig* config) {
         int* durations = NULL;
         WebPMux* new_mux = DuplicateMuxHeader(mux);
         if (new_mux == NULL) goto Err2;
-        durations = (int*)malloc((size_t)num_frames * sizeof(*durations));
+        durations = (int*)WebPMalloc((size_t)num_frames * sizeof(*durations));
         if (durations == NULL) goto Err2;
         for (i = 0; i < num_frames; ++i) durations[i] = -1;
 
         // Parse intervals to process.
-        for (i = 0; i < feature->arg_count_; ++i) {
+        for (i = 0; i < config->arg_count_; ++i) {
           int k;
           int args[3];
           int duration, start, end;
-          const int nb_args = ExUtilGetInts(feature->args_[i].params_,
+          const int nb_args = ExUtilGetInts(config->args_[i].params_,
                                             10, 3, args);
           ok = (nb_args >= 1);
           if (!ok) goto Err3;
@@ -1096,7 +1103,7 @@ static int Process(const WebPMuxConfig* config) {
         new_mux = NULL;
 
  Err3:
-        free(durations);
+        WebPFree(durations);
         WebPMuxDelete(new_mux);
         if (!ok) goto Err2;
       }
@@ -1105,12 +1112,12 @@ static int Process(const WebPMuxConfig* config) {
     case ACTION_STRIP: {
       ok = CreateMux(config->input_, &mux);
       if (!ok) goto Err2;
-      if (feature->type_ == FEATURE_ICCP || feature->type_ == FEATURE_EXIF ||
-          feature->type_ == FEATURE_XMP) {
-        err = WebPMuxDeleteChunk(mux, kFourccList[feature->type_]);
+      if (config->type_ == FEATURE_ICCP || config->type_ == FEATURE_EXIF ||
+          config->type_ == FEATURE_XMP) {
+        err = WebPMuxDeleteChunk(mux, kFourccList[config->type_]);
         if (err != WEBP_MUX_OK) {
           ERROR_GOTO3("ERROR (%s): Could not strip the %s.\n",
-                      ErrorString(err), kDescriptions[feature->type_], Err2);
+                      ErrorString(err), kDescriptions[config->type_], Err2);
         }
       } else {
         ERROR_GOTO1("ERROR: Invalid feature for action 'strip'.\n", Err2);
@@ -1140,15 +1147,19 @@ static int Process(const WebPMuxConfig* config) {
 // Main.
 
 int main(int argc, const char* argv[]) {
-  WebPMuxConfig config;
-  int ok = InitializeConfig(argc - 1, argv + 1, &config);
+  Config config;
+  int ok;
+
+  INIT_WARGV(argc, argv);
+
+  ok = InitializeConfig(argc - 1, argv + 1, &config, GET_WARGV_OR_NULL());
   if (ok) {
     ok = Process(&config);
   } else {
     PrintHelp();
   }
   DeleteConfig(&config);
-  return !ok;
+  FREE_WARGV_AND_RETURN(!ok);
 }
 
 //------------------------------------------------------------------------------

extras/Makefile.am

@@ -13,7 +13,10 @@ libwebpextras_la_LDFLAGS = -lm
 libwebpextras_la_LIBADD = ../src/libwebp.la
 
 noinst_PROGRAMS =
-noinst_PROGRAMS += get_disto webp_quality
+noinst_PROGRAMS += webp_quality
+if BUILD_DEMUX
+  noinst_PROGRAMS += get_disto
+endif
 if BUILD_VWEBP_SDL
   noinst_PROGRAMS += vwebp_sdl
 endif
@@ -27,7 +30,7 @@ get_disto_LDADD += ../src/libwebp.la
 get_disto_LDADD += $(PNG_LIBS) $(JPEG_LIBS) $(TIFF_LIBS)
 
 webp_quality_SOURCES  = webp_quality.c
-webp_quality_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+webp_quality_CPPFLAGS = $(AM_CPPFLAGS)
 webp_quality_LDADD =
 webp_quality_LDADD += ../imageio/libimageio_util.la
 webp_quality_LDADD += libwebpextras.la

extras/extras.c

@@ -12,13 +12,14 @@
 
 #include "extras/extras.h"
 #include "webp/format_constants.h"
+#include "src/dsp/dsp.h"
 
 #include <assert.h>
 #include <string.h>
 
-#define XTRA_MAJ_VERSION 0
+#define XTRA_MAJ_VERSION 1
 #define XTRA_MIN_VERSION 1
-#define XTRA_REV_VERSION 1
+#define XTRA_REV_VERSION 0
 
 //------------------------------------------------------------------------------
 
@@ -48,15 +49,16 @@ int WebPImportGray(const uint8_t* gray_data, WebPPicture* pic) {
 
 int WebPImportRGB565(const uint8_t* rgb565, WebPPicture* pic) {
   int x, y;
+  uint32_t* dst;
   if (pic == NULL || rgb565 == NULL) return 0;
   pic->colorspace = WEBP_YUV420;
   pic->use_argb = 1;
   if (!WebPPictureAlloc(pic)) return 0;
+  dst = pic->argb;
   for (y = 0; y < pic->height; ++y) {
     const int width = pic->width;
-    uint32_t* dst = pic->argb + y * pic->argb_stride;
     for (x = 0; x < width; ++x) {
-#ifdef WEBP_SWAP_16BIT_CSP
+#if defined(WEBP_SWAP_16BIT_CSP) && (WEBP_SWAP_16BIT_CSP == 1)
       const uint32_t rg = rgb565[2 * x + 1];
       const uint32_t gb = rgb565[2 * x + 0];
 #else
@@ -70,24 +72,26 @@ int WebPImportRGB565(const uint8_t* rgb565, WebPPicture* pic) {
       r = r | (r >> 5);
       g = g | (g >> 6);
       b = b | (b >> 5);
-      dst[x] = (r << 16) | (g << 8) | b;
+      dst[x] = (0xffu << 24) | (r << 16) | (g << 8) | b;
     }
     rgb565 += 2 * width;
+    dst += pic->argb_stride;
   }
   return 1;
 }
 
 int WebPImportRGB4444(const uint8_t* rgb4444, WebPPicture* pic) {
   int x, y;
+  uint32_t* dst;
   if (pic == NULL || rgb4444 == NULL) return 0;
   pic->colorspace = WEBP_YUV420;
   pic->use_argb = 1;
   if (!WebPPictureAlloc(pic)) return 0;
+  dst = pic->argb;
   for (y = 0; y < pic->height; ++y) {
     const int width = pic->width;
-    uint32_t* dst = pic->argb + y * pic->argb_stride;
     for (x = 0; x < width; ++x) {
-#ifdef WEBP_SWAP_16BIT_CSP
+#if defined(WEBP_SWAP_16BIT_CSP) && (WEBP_SWAP_16BIT_CSP == 1)
       const uint32_t rg = rgb4444[2 * x + 1];
       const uint32_t ba = rgb4444[2 * x + 0];
 #else
@@ -106,6 +110,7 @@ int WebPImportRGB4444(const uint8_t* rgb4444, WebPPicture* pic) {
       dst[x] = (a << 24) | (r << 16) | (g << 8) | b;
     }
     rgb4444 += 2 * width;
+    dst += pic->argb_stride;
   }
   return 1;
 }
@@ -140,3 +145,18 @@ 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 0x0001    // MAJOR(8b) + MINOR(8b)
+#define WEBP_EXTRAS_ABI_VERSION 0x0002    // MAJOR(8b) + MINOR(8b)
 
 //------------------------------------------------------------------------------
 
@@ -51,6 +51,13 @@ 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
@@ -67,4 +74,4 @@ WEBP_EXTERN int VP8EstimateQuality(const uint8_t* const data, size_t size);
 }    // extern "C"
 #endif
 
-#endif  /* WEBP_EXTRAS_EXTRAS_H_ */
+#endif  // WEBP_EXTRAS_EXTRAS_H_

extras/get_disto.c

@@ -26,6 +26,7 @@
 #include "webp/encode.h"
 #include "imageio/image_dec.h"
 #include "imageio/imageio_util.h"
+#include "../examples/unicode.h"
 
 static size_t ReadPicture(const char* const filename, WebPPicture* const pic,
                           int keep_alpha) {
@@ -48,7 +49,8 @@ static size_t ReadPicture(const char* const filename, WebPPicture* const pic,
 
  End:
   if (!ok) {
-    fprintf(stderr, "Error! Could not process file %s\n", filename);
+    WFPRINTF(stderr, "Error! Could not process file %s\n",
+             (const W_CHAR*)filename);
   }
   free((void*)data);
   return ok ? data_size : 0;
@@ -239,9 +241,11 @@ int main(int argc, const char *argv[]) {
   const char* name2 = NULL;
   const char* output = NULL;
 
+  INIT_WARGV(argc, argv);
+
   if (!WebPPictureInit(&pic1) || !WebPPictureInit(&pic2)) {
     fprintf(stderr, "Can't init pictures\n");
-    return 1;
+    FREE_WARGV_AND_RETURN(1);
   }
 
   for (c = 1; c < argc; ++c) {
@@ -263,11 +267,11 @@ int main(int argc, const char *argv[]) {
         fprintf(stderr, "missing file name after %s option.\n", argv[c - 1]);
         goto End;
       }
-      output = argv[c];
+      output = (const char*)GET_WARGV(argv, c);
     } else if (name1 == NULL) {
-      name1 = argv[c];
+      name1 = (const char*)GET_WARGV(argv, c);
     } else {
-      name2 = argv[c];
+      name2 = (const char*)GET_WARGV(argv, c);
     }
   }
   if (help || name1 == NULL || name2 == NULL) {
@@ -290,9 +294,10 @@ int main(int argc, const char *argv[]) {
     fprintf(stderr, "Error while computing the distortion.\n");
     goto End;
   }
-  printf("%u %.2f    %.2f %.2f %.2f %.2f\n",
+  printf("%u %.2f    %.2f %.2f %.2f %.2f [ %.2f bpp ]\n",
          (unsigned int)size1,
-         disto[4], disto[0], disto[1], disto[2], disto[3]);
+         disto[4], disto[0], disto[1], disto[2], disto[3],
+         8.f * size1 / pic1.width / pic1.height);
 
   if (output != NULL) {
     uint8_t* data = NULL;
@@ -346,5 +351,5 @@ int main(int argc, const char *argv[]) {
  End:
   WebPPictureFree(&pic1);
   WebPPictureFree(&pic2);
-  return ret;
+  FREE_WARGV_AND_RETURN(ret);
 }

extras/quality_estimate.c

@@ -73,7 +73,7 @@ int VP8EstimateQuality(const uint8_t* const data, size_t size) {
   pos += 4;
   bit_pos = pos * 8;
 
-  GET_BIT(2);  // color_space + clamp type
+  GET_BIT(2);  // colorspace + clamp type
 
   // Segment header
   if (GET_BIT(1)) {       // use_segment_

extras/vwebp_sdl.c

@@ -25,6 +25,7 @@
 #include "webp_to_sdl.h"
 #include "webp/decode.h"
 #include "imageio/imageio_util.h"
+#include "../examples/unicode.h"
 
 #if defined(WEBP_HAVE_JUST_SDL_H)
 #include <SDL.h>
@@ -51,29 +52,33 @@ static void ProcessEvents(void) {
 int main(int argc, char* argv[]) {
   int c;
   int ok = 0;
+
+  INIT_WARGV(argc, argv);
+
   for (c = 1; c < argc; ++c) {
     const char* file = NULL;
     const uint8_t* webp = NULL;
     size_t webp_size = 0;
     if (!strcmp(argv[c], "-h")) {
       printf("Usage: %s [-h] image.webp [more_files.webp...]\n", argv[0]);
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else {
-      file = argv[c];
+      file = (const char*)GET_WARGV(argv, c);
     }
     if (file == NULL) continue;
     if (!ImgIoUtilReadFile(file, &webp, &webp_size)) {
-      fprintf(stderr, "Error opening file: %s\n", file);
+      WFPRINTF(stderr, "Error opening file: %s\n", (const W_CHAR*)file);
       goto Error;
     }
     if (webp_size != (size_t)(int)webp_size) {
+      free((void*)webp);
       fprintf(stderr, "File too large.\n");
       goto Error;
     }
     ok = WebpToSDL((const char*)webp, (int)webp_size);
     free((void*)webp);
     if (!ok) {
-      fprintf(stderr, "Error decoding file %s\n", file);
+      WFPRINTF(stderr, "Error decoding file %s\n", (const W_CHAR*)file);
       goto Error;
     }
     ProcessEvents();
@@ -82,7 +87,7 @@ int main(int argc, char* argv[]) {
 
  Error:
   SDL_Quit();
-  return ok ? 0 : 1;
+  FREE_WARGV_AND_RETURN(ok ? 0 : 1);
 }
 
 #else  // !WEBP_HAVE_SDL

extras/webp_quality.c

@@ -13,26 +13,30 @@
 
 #include "extras/extras.h"
 #include "imageio/imageio_util.h"
+#include "../examples/unicode.h"
 
 int main(int argc, const char* argv[]) {
   int c;
   int quiet = 0;
   int ok = 1;
+
+  INIT_WARGV(argc, argv);
+
   for (c = 1; ok && c < argc; ++c) {
     if (!strcmp(argv[c], "-quiet")) {
       quiet = 1;
     } else if (!strcmp(argv[c], "-help") || !strcmp(argv[c], "-h")) {
       printf("webp_quality [-h][-quiet] webp_files...\n");
-      return 0;
+      FREE_WARGV_AND_RETURN(0);
     } else {
-      const char* const filename = argv[c];
+      const char* const filename = (const char*)GET_WARGV(argv, c);
       const uint8_t* data = NULL;
       size_t data_size = 0;
       int q;
       ok = ImgIoUtilReadFile(filename, &data, &data_size);
       if (!ok) break;
       q = VP8EstimateQuality(data, data_size);
-      if (!quiet) printf("[%s] ", filename);
+      if (!quiet) WPRINTF("[%s] ", (const W_CHAR*)filename);
       if (q < 0) {
         fprintf(stderr, "Not a WebP file, or not a lossy WebP file.\n");
         ok = 0;
@@ -46,5 +50,5 @@ int main(int argc, const char *argv[]) {
       free((void*)data);
     }
   }
-  return ok ? 0 : 1;
+  FREE_WARGV_AND_RETURN(ok ? 0 : 1);
 }

extras/webp_to_sdl.c

@@ -12,7 +12,7 @@
 // Author: James Zern (jzern@google.com)
 
 #ifdef HAVE_CONFIG_H
-#include "webp/config.h"
+#include "src/webp/config.h"
 #endif
 
 #if defined(WEBP_HAVE_SDL)
@@ -20,7 +20,7 @@
 #include "webp_to_sdl.h"
 
 #include <stdio.h>
-#include "webp/decode.h"
+#include "src/webp/decode.h"
 
 #if defined(WEBP_HAVE_JUST_SDL_H)
 #include <SDL.h>
@@ -40,7 +40,7 @@ int WebpToSDL(const char* data, unsigned int data_size) {
 
   if (!WebPInitDecoderConfig(&config)) {
     fprintf(stderr, "Library version mismatch!\n");
-    return 1;
+    return 0;
   }
 
   if (!init_ok) {

imageio/Makefile.am

@@ -1,7 +1,9 @@
 AM_CPPFLAGS += -I$(top_builddir)/src -I$(top_srcdir)/src
 noinst_LTLIBRARIES =
 noinst_LTLIBRARIES += libimageio_util.la
+if BUILD_DEMUX
   noinst_LTLIBRARIES += libimagedec.la
+endif
 noinst_LTLIBRARIES += libimageenc.la
 
 noinst_HEADERS =
@@ -21,9 +23,10 @@ libimagedec_la_SOURCES += tiffdec.c tiffdec.h
 libimagedec_la_SOURCES += webpdec.c webpdec.h
 libimagedec_la_SOURCES += wicdec.c wicdec.h
 libimagedec_la_CPPFLAGS = $(JPEG_INCLUDES) $(PNG_INCLUDES) $(TIFF_INCLUDES)
-libimagedec_la_CPPFLAGS += $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+libimagedec_la_CPPFLAGS += $(AM_CPPFLAGS)
+libimagedec_la_LIBADD = ../src/demux/libwebpdemux.la
 
 libimageenc_la_SOURCES  =
 libimageenc_la_SOURCES += image_enc.c image_enc.h
 libimageenc_la_CPPFLAGS = $(JPEG_INCLUDES) $(PNG_INCLUDES) $(TIFF_INCLUDES)
-libimageenc_la_CPPFLAGS += $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+libimageenc_la_CPPFLAGS += $(AM_CPPFLAGS)

imageio/image_enc.c

@@ -29,11 +29,13 @@
                          // code with COBJMACROS.
 #include <ole2.h>  // CreateStreamOnHGlobal()
 #include <shlwapi.h>
+#include <tchar.h>
 #include <windows.h>
 #include <wincodec.h>
 #endif
 
 #include "./imageio_util.h"
+#include "../examples/unicode.h"
 
 //------------------------------------------------------------------------------
 // PNG
@@ -61,11 +63,12 @@ static HRESULT CreateOutputStream(const char* out_file_name,
     // Output to a memory buffer. This is freed when 'stream' is released.
     IFS(CreateStreamOnHGlobal(NULL, TRUE, stream));
   } else {
-    IFS(SHCreateStreamOnFileA(out_file_name, STGM_WRITE | STGM_CREATE, stream));
+    IFS(SHCreateStreamOnFile((const LPTSTR)out_file_name,
+                             STGM_WRITE | STGM_CREATE, stream));
   }
   if (FAILED(hr)) {
-    fprintf(stderr, "Error opening output file %s (%08lx)\n",
-            out_file_name, hr);
+    _ftprintf(stderr, _T("Error opening output file %s (%08lx)\n"),
+              (const LPTSTR)out_file_name, hr);
   }
   return hr;
 }
@@ -158,14 +161,8 @@ static void PNGAPI PNGErrorFunction(png_structp png, png_const_charp dummy) {
 }
 
 int WebPWritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
-  const uint32_t width = buffer->width;
-  const uint32_t height = buffer->height;
-  png_bytep row = buffer->u.RGBA.rgba;
-  const int stride = buffer->u.RGBA.stride;
-  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
   volatile png_structp png;
   volatile png_infop info;
-  png_uint_32 y;
 
   if (out_file == NULL || buffer == NULL) return 0;
 
@@ -184,6 +181,14 @@ int WebPWritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
     return 0;
   }
   png_init_io(png, out_file);
+  {
+    const uint32_t width = buffer->width;
+    const uint32_t height = buffer->height;
+    png_bytep row = buffer->u.RGBA.rgba;
+    const int stride = buffer->u.RGBA.stride;
+    const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
+    uint32_t y;
+
     png_set_IHDR(png, info, width, height, 8,
                  has_alpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB,
                  PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
@@ -193,6 +198,7 @@ int WebPWritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
       png_write_rows(png, &row, 1);
       row += stride;
     }
+  }
   png_write_end(png, info);
   png_destroy_write_struct((png_structpp)&png, (png_infopp)&info);
   return 1;
@@ -546,7 +552,8 @@ int WebPSaveImage(const WebPDecBuffer* const buffer,
                   const char* const out_file_name) {
   FILE* fout = NULL;
   int needs_open_file = 1;
-  const int use_stdout = (out_file_name != NULL) && !strcmp(out_file_name, "-");
+  const int use_stdout =
+      (out_file_name != NULL) && !WSTRCMP(out_file_name, "-");
   int ok = 1;
 
   if (buffer == NULL || out_file_name == NULL) return 0;
@@ -557,9 +564,10 @@ int WebPSaveImage(const WebPDecBuffer* const buffer,
 
   if (needs_open_file) {
     fout = use_stdout ? ImgIoUtilSetBinaryMode(stdout)
-                      : fopen(out_file_name, "wb");
+                      : WFOPEN(out_file_name, "wb");
     if (fout == NULL) {
-      fprintf(stderr, "Error opening output file %s\n", out_file_name);
+      WFPRINTF(stderr, "Error opening output file %s\n",
+               (const W_CHAR*)out_file_name);
       return 0;
     }
   }

imageio/imageio_util.c

@@ -18,6 +18,7 @@
 #endif
 #include <stdlib.h>
 #include <string.h>
+#include "../examples/unicode.h"
 
 // -----------------------------------------------------------------------------
 // File I/O
@@ -47,7 +48,8 @@ int ImgIoUtilReadFromStdin(const uint8_t** data, size_t* data_size) {
   while (!feof(stdin)) {
     // We double the buffer size each time and read as much as possible.
     const size_t extra_size = (max_size == 0) ? kBlockSize : max_size;
-    void* const new_data = realloc(input, max_size + extra_size);
+    // we allocate one extra byte for the \0 terminator
+    void* const new_data = realloc(input, max_size + extra_size + 1);
     if (new_data == NULL) goto Error;
     input = (uint8_t*)new_data;
     max_size += extra_size;
@@ -55,6 +57,7 @@ int ImgIoUtilReadFromStdin(const uint8_t** data, size_t* data_size) {
     if (size < max_size) break;
   }
   if (ferror(stdin)) goto Error;
+  if (input != NULL) input[size] = '\0';  // convenient 0-terminator
   *data = input;
   *data_size = size;
   return 1;
@@ -68,10 +71,10 @@ int ImgIoUtilReadFromStdin(const uint8_t** data, size_t* data_size) {
 int ImgIoUtilReadFile(const char* const file_name,
                       const uint8_t** data, size_t* data_size) {
   int ok;
-  void* file_data;
+  uint8_t* file_data;
   size_t file_size;
   FILE* in;
-  const int from_stdin = (file_name == NULL) || !strcmp(file_name, "-");
+  const int from_stdin = (file_name == NULL) || !WSTRCMP(file_name, "-");
 
   if (from_stdin) return ImgIoUtilReadFromStdin(data, data_size);
 
@@ -79,42 +82,52 @@ int ImgIoUtilReadFile(const char* const file_name,
   *data = NULL;
   *data_size = 0;
 
-  in = fopen(file_name, "rb");
+  in = WFOPEN(file_name, "rb");
   if (in == NULL) {
-    fprintf(stderr, "cannot open input file '%s'\n", file_name);
+    WFPRINTF(stderr, "cannot open input file '%s'\n", (const W_CHAR*)file_name);
     return 0;
   }
   fseek(in, 0, SEEK_END);
   file_size = ftell(in);
   fseek(in, 0, SEEK_SET);
-  file_data = malloc(file_size);
-  if (file_data == NULL) return 0;
+  // we allocate one extra byte for the \0 terminator
+  file_data = (uint8_t*)malloc(file_size + 1);
+  if (file_data == NULL) {
+    fclose(in);
+    WFPRINTF(stderr, "memory allocation failure when reading file %s\n",
+             (const W_CHAR*)file_name);
+    return 0;
+  }
   ok = (fread(file_data, file_size, 1, in) == 1);
   fclose(in);
 
   if (!ok) {
-    fprintf(stderr, "Could not read %d bytes of data from file %s\n",
-            (int)file_size, file_name);
+    WFPRINTF(stderr, "Could not read %d bytes of data from file %s\n",
+             (int)file_size, (const W_CHAR*)file_name);
     free(file_data);
     return 0;
   }
-  *data = (uint8_t*)file_data;
+  file_data[file_size] = '\0';  // convenient 0-terminator
+  *data = file_data;
   *data_size = file_size;
   return 1;
 }
 
+// -----------------------------------------------------------------------------
+
 int ImgIoUtilWriteFile(const char* const file_name,
                        const uint8_t* data, size_t data_size) {
   int ok;
   FILE* out;
-  const int to_stdout = (file_name == NULL) || !strcmp(file_name, "-");
+  const int to_stdout = (file_name == NULL) || !WSTRCMP(file_name, "-");
 
   if (data == NULL) {
     return 0;
   }
-  out = to_stdout ? ImgIoUtilSetBinaryMode(stdout) : fopen(file_name, "wb");
+  out = to_stdout ? ImgIoUtilSetBinaryMode(stdout) : WFOPEN(file_name, "wb");
   if (out == NULL) {
-    fprintf(stderr, "Error! Cannot open output file '%s'\n", file_name);
+    WFPRINTF(stderr, "Error! Cannot open output file '%s'\n",
+             (const W_CHAR*)file_name);
     return 0;
   }
   ok = (fwrite(data, data_size, 1, out) == 1);

imageio/imageio_util.h

@@ -30,6 +30,9 @@ 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 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.
 // If 'file_name' is NULL or equal to "-", input is read from stdin by calling
 // the function ImgIoUtilReadFromStdin().
 int ImgIoUtilReadFile(const char* const file_name,

imageio/jpegdec.c

@@ -206,6 +206,7 @@ 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);
 }

imageio/pngdec.c

@@ -18,6 +18,9 @@
 #include <stdio.h>
 
 #ifdef WEBP_HAVE_PNG
+#ifndef PNG_USER_MEM_SUPPORTED
+#define PNG_USER_MEM_SUPPORTED  // for png_create_read_struct_2
+#endif
 #include <png.h>
 #include <setjmp.h>   // note: this must be included *after* png.h
 #include <stdlib.h>
@@ -27,11 +30,33 @@
 #include "./imageio_util.h"
 #include "./metadata.h"
 
+#define LOCAL_PNG_VERSION ((PNG_LIBPNG_VER_MAJOR << 8) | PNG_LIBPNG_VER_MINOR)
+#define LOCAL_PNG_PREREQ(maj, min) \
+   (LOCAL_PNG_VERSION >= (((maj) << 8) | (min)))
+
 static void PNGAPI error_function(png_structp png, png_const_charp error) {
   if (error != NULL) fprintf(stderr, "libpng error: %s\n", error);
   longjmp(png_jmpbuf(png), 1);
 }
 
+#if LOCAL_PNG_PREREQ(1,4)
+typedef png_alloc_size_t LocalPngAllocSize;
+#else
+typedef png_size_t LocalPngAllocSize;
+#endif
+
+static png_voidp MallocFunc(png_structp png_ptr, LocalPngAllocSize size) {
+  (void)png_ptr;
+  if (size != (size_t)size) return NULL;
+  if (!ImgIoUtilCheckSizeArgumentsOverflow(size, 1)) return NULL;
+  return (png_voidp)malloc((size_t)size);
+}
+
+static void FreeFunc(png_structp png_ptr, png_voidp ptr) {
+  (void)png_ptr;
+  free(ptr);
+}
+
 // Converts the NULL terminated 'hexstring' which contains 2-byte character
 // representations of hex values to raw data.
 // 'hexstring' may contain values consisting of [A-F][a-f][0-9] in pairs,
@@ -171,11 +196,10 @@ static int ExtractMetadataFromPNG(png_structp png,
     {
       png_charp name;
       int comp_type;
-#if ((PNG_LIBPNG_VER_MAJOR << 8) | PNG_LIBPNG_VER_MINOR << 0) < \
-    ((1 << 8) | (5 << 0))
-      png_charp profile;
-#else  // >= libpng 1.5.0
+#if LOCAL_PNG_PREREQ(1,5)
       png_bytep profile;
+#else
+      png_charp profile;
 #endif
       png_uint_32 len;
 
@@ -185,7 +209,6 @@ static int ExtractMetadataFromPNG(png_structp png,
       }
     }
   }
-
   return 1;
 }
 
@@ -225,7 +248,8 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
   context.data = data;
   context.data_size = data_size;
 
-  png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
+  png = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL,
+                                 NULL, MallocFunc, FreeFunc);
   if (png == NULL) goto End;
 
   png_set_error_fn(png, 0, error_function, NULL);
@@ -265,6 +289,16 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
     has_alpha = !!(color_type & PNG_COLOR_MASK_ALPHA);
   }
 
+  // Apply gamma correction if needed.
+  {
+    double image_gamma = 1 / 2.2, screen_gamma = 2.2;
+    int srgb_intent;
+    if (png_get_sRGB(png, info, &srgb_intent) ||
+        png_get_gAMA(png, info, &image_gamma)) {
+      png_set_gamma(png, screen_gamma, image_gamma);
+    }
+  }
+
   if (!keep_alpha) {
     png_set_strip_alpha(png);
     has_alpha = 0;

imageio/pnmdec.c

@@ -26,7 +26,7 @@ typedef enum {
   DEPTH_FLAG      = 1 << 2,
   MAXVAL_FLAG     = 1 << 3,
   TUPLE_FLAG      = 1 << 4,
-  ALL_NEEDED_FLAGS = 0x1f
+  ALL_NEEDED_FLAGS = WIDTH_FLAG | HEIGHT_FLAG | DEPTH_FLAG | MAXVAL_FLAG
 } PNMFlags;
 
 typedef struct {
@@ -74,6 +74,7 @@ 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);
@@ -95,13 +96,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")) {
-      info->bytes_per_px = 4;
+      expected_depth = 4;
       info->seen_flags |= TUPLE_FLAG;
     } else if (!strcmp(out, "TUPLTYPE RGB")) {
-      info->bytes_per_px = 3;
+      expected_depth = 3;
       info->seen_flags |= TUPLE_FLAG;
     } else if (!strcmp(out, "TUPLTYPE GRAYSCALE")) {
-      info->bytes_per_px = 1;
+      expected_depth = 1;
       info->seen_flags |= TUPLE_FLAG;
     } else if (!strcmp(out, "ENDHDR")) {
       break;
@@ -110,23 +111,24 @@ 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) {
-        if (!isprint(out[i])) out[i] = ' ';
+        // isprint() might trigger a "char-subscripts" warning if given a char.
+        if (!isprint((int)out[i])) out[i] = ' ';
       }
       fprintf(stderr, "PAM header error: unrecognized entry [%s]\n", out);
       return 0;
     }
   }
-  if (!(info->seen_flags & TUPLE_FLAG)) {
-    if (info->depth > 0 && info->depth <= 4) {
-      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);
+  if (!(info->seen_flags & ALL_NEEDED_FLAGS)) {
+    fprintf(stderr, "PAM header error: missing tags%s%s%s%s\n",
+            (info->seen_flags & WIDTH_FLAG) ? "" : " WIDTH",
+            (info->seen_flags & HEIGHT_FLAG) ? "" : " HEIGHT",
+            (info->seen_flags & DEPTH_FLAG) ? "" : " DEPTH",
+            (info->seen_flags & MAXVAL_FLAG) ? "" : " MAXVAL");
     return 0;
   }
-  }
-  if (info->seen_flags != ALL_NEEDED_FLAGS) {
-    fprintf(stderr, "PAM: incomplete header.\n");
+  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);
     return 0;
   }
   return off;
@@ -160,16 +162,15 @@ 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->bytes_per_px < info->depth ||
+      info->depth <= 0 || info->depth == 2 || info->depth > 4 ||
       info->max_value <= 0 || info->max_value >= 65536) {
     return 0;
   }
+  info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
   return off;
 }
 

imageio/tiffdec.c

@@ -121,7 +121,6 @@ static tsize_t MyRead(thandle_t opaque, void* dst, tsize_t size) {
 // (we don't want to force a dependency to a libdspdec library).
 #define MFIX 24    // 24bit fixed-point arithmetic
 #define HALF ((1u << MFIX) >> 1)
-#define KINV_255 ((1u << MFIX) / 255u)
 
 static uint32_t Unmult(uint8_t x, uint32_t mult) {
   const uint32_t v = (x * mult + HALF) >> MFIX;
@@ -132,6 +131,9 @@ static WEBP_INLINE uint32_t GetScale(uint32_t a) {
   return (255u << MFIX) / a;
 }
 
+#undef MFIX
+#undef HALF
+
 static void MultARGBRow(uint8_t* ptr, int width) {
   int x;
   for (x = 0; x < width; ++x, ptr += 4) {
@@ -154,7 +156,7 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
              Metadata* const metadata) {
   MyData my_data = { data, (toff_t)data_size, 0 };
   TIFF* tif;
-  uint32_t width, height;
+  uint32_t image_width, image_height, tile_width, tile_height;
   uint16_t samples_per_px = 0;
   uint16_t extra_samples = 0;
   uint16_t* extra_samples_ptr = NULL;
@@ -187,15 +189,25 @@ 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, &width) &&
-        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))) {
+  if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &image_width) &&
+        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &image_height))) {
     fprintf(stderr, "Error! Cannot retrieve TIFF image dimensions.\n");
     goto End;
   }
-  if (!ImgIoUtilCheckSizeArgumentsOverflow((uint64_t)width * height,
+  if (!ImgIoUtilCheckSizeArgumentsOverflow((uint64_t)image_width * image_height,
                                            sizeof(*raster))) {
     goto End;
   }
+  // According to spec, a tile can be bigger than the image. However it should
+  // be a multiple of 16 and not way too large, so check that it's not more than
+  // twice the image size, for dimensions above some arbitrary minimum 32.
+  if ((TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width) &&
+       tile_width > 32 && tile_width / 2 > image_width) ||
+      (TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height) &&
+       tile_height > 32 && tile_height / 2 > image_height)) {
+    fprintf(stderr, "Error! TIFF tile dimensions are too big.\n");
+    goto End;
+  }
   if (samples_per_px > 3 && !TIFFGetField(tif, TIFFTAG_EXTRASAMPLES,
                                           &extra_samples, &extra_samples_ptr)) {
     fprintf(stderr, "Error! Cannot retrieve TIFF ExtraSamples info.\n");
@@ -203,27 +215,28 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
   }
 
   // _Tiffmalloc uses a signed type for size.
-  alloc_size = (int64_t)((uint64_t)width * height * sizeof(*raster));
+  alloc_size =
+      (int64_t)((uint64_t)image_width * image_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, width, height, raster,
+    if (TIFFReadRGBAImageOriented(tif, image_width, image_height, raster,
                                   ORIENTATION_TOPLEFT, 1)) {
-      const int stride = width * sizeof(*raster);
-      pic->width = width;
-      pic->height = height;
+      const int stride = image_width * sizeof(*raster);
+      pic->width = image_width;
+      pic->height = image_height;
       // TIFF data is ABGR
 #ifdef WORDS_BIGENDIAN
-      TIFFSwabArrayOfLong(raster, width * height);
+      TIFFSwabArrayOfLong(raster, image_width * image_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 < height; ++y) {
-          MultARGBRow(tmp, width);
+        for (y = 0; y < image_height; ++y) {
+          MultARGBRow(tmp, image_width);
           tmp += stride;
         }
       }

imageio/webpdec.c

@@ -15,11 +15,14 @@
 
 #include "./webpdec.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "webp/decode.h"
+#include "webp/demux.h"
 #include "webp/encode.h"
+#include "../examples/unicode.h"
 #include "./imageio_util.h"
 #include "./metadata.h"
 
@@ -41,7 +44,7 @@ static void PrintAnimationWarning(const WebPDecoderConfig* const config) {
 }
 
 void PrintWebPError(const char* const in_file, int status) {
-  fprintf(stderr, "Decoding of %s failed.\n", in_file);
+  WFPRINTF(stderr, "Decoding of %s failed.\n", (const W_CHAR*)in_file);
   fprintf(stderr, "Status: %d", status);
   if (status >= VP8_STATUS_OK && status <= VP8_STATUS_NOT_ENOUGH_DATA) {
     fprintf(stderr, "(%s)", kStatusMessages[status]);
@@ -95,25 +98,47 @@ VP8StatusCode DecodeWebPIncremental(
       fprintf(stderr, "Failed during WebPINewDecoder().\n");
       return VP8_STATUS_OUT_OF_MEMORY;
     } else {
-#ifdef WEBP_EXPERIMENTAL_FEATURES
-      size_t size = 0;
-      const size_t incr = 2 + (data_size / 20);
-      while (size < data_size) {
-        size_t next_size = size + (rand() % incr);
-        if (next_size > data_size) next_size = data_size;
-        status = WebPIUpdate(idec, data, next_size);
-        if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED) break;
-        size = next_size;
-      }
-#else
       status = WebPIUpdate(idec, data, data_size);
-#endif
       WebPIDelete(idec);
     }
   }
   return status;
 }
 
+// -----------------------------------------------------------------------------
+// Metadata
+
+static int ExtractMetadata(const uint8_t* const data, size_t data_size,
+                           Metadata* const metadata) {
+  WebPData webp_data = { data, data_size };
+  WebPDemuxer* const demux = WebPDemux(&webp_data);
+  WebPChunkIterator chunk_iter;
+  uint32_t flags;
+
+  if (demux == NULL) return 0;
+  assert(metadata != NULL);
+
+  flags = WebPDemuxGetI(demux, WEBP_FF_FORMAT_FLAGS);
+
+  if ((flags & ICCP_FLAG) && WebPDemuxGetChunk(demux, "ICCP", 1, &chunk_iter)) {
+    MetadataCopy((const char*)chunk_iter.chunk.bytes, chunk_iter.chunk.size,
+                 &metadata->iccp);
+    WebPDemuxReleaseChunkIterator(&chunk_iter);
+  }
+  if ((flags & EXIF_FLAG) && WebPDemuxGetChunk(demux, "EXIF", 1, &chunk_iter)) {
+    MetadataCopy((const char*)chunk_iter.chunk.bytes, chunk_iter.chunk.size,
+                 &metadata->exif);
+    WebPDemuxReleaseChunkIterator(&chunk_iter);
+  }
+  if ((flags & XMP_FLAG) && WebPDemuxGetChunk(demux, "XMP ", 1, &chunk_iter)) {
+    MetadataCopy((const char*)chunk_iter.chunk.bytes, chunk_iter.chunk.size,
+                 &metadata->xmp);
+    WebPDemuxReleaseChunkIterator(&chunk_iter);
+  }
+  WebPDemuxDelete(demux);
+  return 1;
+}
+
 // -----------------------------------------------------------------------------
 
 int ReadWebP(const uint8_t* const data, size_t data_size,
@@ -127,11 +152,6 @@ int ReadWebP(const uint8_t* const data, size_t data_size,
 
   if (data == NULL || data_size == 0 || pic == NULL) return 0;
 
-  // TODO(jzern): add Exif/XMP/ICC extraction.
-  if (metadata != NULL) {
-    fprintf(stderr, "Warning: metadata extraction from WebP is unsupported.\n");
-  }
-
   if (!WebPInitDecoderConfig(&config)) {
     fprintf(stderr, "Library version mismatch!\n");
     return 0;
@@ -193,7 +213,6 @@ int ReadWebP(const uint8_t* const data, size_t data_size,
 
     status = DecodeWebP(data, data_size, &config);
     ok = (status == VP8_STATUS_OK);
-    if (!ok) WebPPictureFree(pic);
     if (ok && !keep_alpha && pic->use_argb) {
       // Need to wipe out the alpha value, as requested.
       int x, y;
@@ -207,9 +226,18 @@ int ReadWebP(const uint8_t* const data, size_t data_size,
 
   if (status != VP8_STATUS_OK) {
     PrintWebPError("input data", status);
+    ok = 0;
   }
 
   WebPFreeDecBuffer(output_buffer);
+
+  if (ok && metadata != NULL) {
+    ok = ExtractMetadata(data, data_size, metadata);
+    if (!ok) {
+      PrintWebPError("metadata", VP8_STATUS_BITSTREAM_ERROR);
+    }
+  }
+  if (!ok) WebPPictureFree(pic);
   return ok;
 }
 

imageio/wicdec.c

@@ -29,12 +29,14 @@
                          // code with COBJMACROS.
 #include <ole2.h>  // CreateStreamOnHGlobal()
 #include <shlwapi.h>
+#include <tchar.h>
 #include <windows.h>
 #include <wincodec.h>
 
-#include "webp/encode.h"
+#include "../examples/unicode.h"
 #include "./imageio_util.h"
 #include "./metadata.h"
+#include "webp/encode.h"
 
 #define IFS(fn)                                                     \
   do {                                                              \
@@ -85,7 +87,7 @@ WEBP_DEFINE_GUID(GUID_WICPixelFormat64bppRGBA_,
 
 static HRESULT OpenInputStream(const char* filename, IStream** stream) {
   HRESULT hr = S_OK;
-  if (!strcmp(filename, "-")) {
+  if (!WSTRCMP(filename, "-")) {
     const uint8_t* data = NULL;
     size_t data_size = 0;
     const int ok = ImgIoUtilReadFile(filename, &data, &data_size);
@@ -108,11 +110,12 @@ static HRESULT OpenInputStream(const char* filename, IStream** stream) {
       hr = E_FAIL;
     }
   } else {
-    IFS(SHCreateStreamOnFileA(filename, STGM_READ, stream));
+    IFS(SHCreateStreamOnFile((const LPTSTR)filename, STGM_READ, stream));
   }
 
   if (FAILED(hr)) {
-    fprintf(stderr, "Error opening input file %s (%08lx)\n", filename, hr);
+    _ftprintf(stderr, _T("Error opening input file %s (%08lx)\n"),
+              (const LPTSTR)filename, hr);
   }
   return hr;
 }

iosbuild.sh

@@ -35,11 +35,15 @@ 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"
@@ -53,8 +57,10 @@ else
   echo "iOS SDK Version ${SDK}"
 fi
 
-rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR}
-mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/
+rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR} \
+    ${MUXTARGETDIR} ${DEMUXTARGETDIR}
+mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/ \
+    ${MUXTARGETDIR}/Headers/ ${DEMUXTARGETDIR}/Headers/
 
 if [[ ! -e ${SRCDIR}/configure ]]; then
   if ! (cd ${SRCDIR} && sh autogen.sh); then
@@ -105,6 +111,7 @@ 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
 
@@ -115,6 +122,8 @@ 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 ..
@@ -122,8 +131,20 @@ 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

makefile.unix

@@ -25,6 +25,7 @@ ifeq ($(strip $(shell uname)), Darwin)
   # Failure observed with: gcc 4.2.1 and 4.0.1.
   EXTRA_FLAGS += -fno-common
   EXTRA_FLAGS += -DHAVE_GLUT_GLUT_H
+  EXTRA_FLAGS += -Wno-deprecated-declarations
   EXTRA_FLAGS += -I/opt/local/include
   EXTRA_LIBS  += -L/opt/local/lib
   GL_LIBS = -framework GLUT -framework OpenGL
@@ -63,9 +64,6 @@ endif
 # 'make -f makefile.unix EXTRA_FLAGS=-m32' to that effect.
 # EXTRA_FLAGS += -m32
 
-# Extra flags to enable experimental features and code
-# EXTRA_FLAGS += -DWEBP_EXPERIMENTAL_FEATURES
-
 # Extra flags to enable byte swap for 16 bit colorspaces.
 # EXTRA_FLAGS += -DWEBP_SWAP_16BIT_CSP=1
 
@@ -91,12 +89,6 @@ EXTRA_FLAGS += -DWEBP_HAVE_SSE41
 src/dsp/%_sse41.o: EXTRA_FLAGS += -msse4.1
 endif
 
-# AVX2-specific flags:
-ifeq ($(HAVE_AVX2), 1)
-EXTRA_FLAGS += -DWEBP_HAVE_AVX2
-src/dsp/%_avx2.o: EXTRA_FLAGS += -mavx2
-endif
-
 # NEON-specific flags:
 # EXTRA_FLAGS += -march=armv7-a -mfloat-abi=hard -mfpu=neon -mtune=cortex-a8
 # -> seems to make the overall lib slower: -fno-split-wide-types
@@ -114,13 +106,22 @@ endif
 AR = ar
 ARFLAGS = r
 CPPFLAGS = -I. -Isrc/ -Wall
-CFLAGS = -O3 -DNDEBUG $(EXTRA_FLAGS)
+ifeq ($(DEBUG), 1)
+  CFLAGS = -g
+else
+  CFLAGS = -O3 -DNDEBUG
+endif
+CFLAGS += $(EXTRA_FLAGS)
 CC = gcc
 INSTALL = install
 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 \
 
@@ -176,19 +177,21 @@ DSP_DEC_OBJS = \
     src/dsp/upsampling_msa.o \
     src/dsp/upsampling_neon.o \
     src/dsp/upsampling_sse2.o \
+    src/dsp/upsampling_sse41.o \
     src/dsp/yuv.o \
     src/dsp/yuv_mips32.o \
     src/dsp/yuv_mips_dsp_r2.o \
     src/dsp/yuv_neon.o \
     src/dsp/yuv_sse2.o \
+    src/dsp/yuv_sse41.o \
 
 DSP_ENC_OBJS = \
     src/dsp/cost.o \
     src/dsp/cost_mips32.o \
     src/dsp/cost_mips_dsp_r2.o \
+    src/dsp/cost_neon.o \
     src/dsp/cost_sse2.o \
     src/dsp/enc.o \
-    src/dsp/enc_avx2.o \
     src/dsp/enc_mips32.o \
     src/dsp/enc_mips_dsp_r2.o \
     src/dsp/enc_msa.o \
@@ -212,7 +215,6 @@ ENC_OBJS = \
     src/enc/backward_references_enc.o \
     src/enc/config_enc.o \
     src/enc/cost_enc.o \
-    src/enc/delta_palettization_enc.o \
     src/enc/filter_enc.o \
     src/enc/frame_enc.o \
     src/enc/histogram_enc.o \
@@ -310,7 +312,6 @@ HDRS = \
     src/dsp/yuv.h \
     src/enc/backward_references_enc.h \
     src/enc/cost_enc.h \
-    src/enc/delta_palettization_enc.h \
     src/enc/histogram_enc.h \
     src/enc/vp8i_enc.h \
     src/enc/vp8li_enc.h \
@@ -389,7 +390,7 @@ src/demux/libwebpdemux.a: $(LIBWEBPDEMUX_OBJS)
 	$(AR) $(ARFLAGS) $@ $^
 
 examples/anim_diff: examples/anim_diff.o $(ANIM_UTIL_OBJS) $(GIFDEC_OBJS)
-examples/anim_dump: examples/anim_dump.o $(ANIM_UTIL_OBJS)
+examples/anim_dump: examples/anim_dump.o $(ANIM_UTIL_OBJS) $(GIFDEC_OBJS)
 examples/cwebp: examples/cwebp.o
 examples/dwebp: examples/dwebp.o
 examples/gif2webp: examples/gif2webp.o $(GIFDEC_OBJS)
@@ -401,46 +402,52 @@ 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: EXTRA_LIBS += $(GIF_LIBS)
+examples/anim_diff: override EXTRA_LIBS += $(GIF_LIBS)
 examples/anim_diff: EXTRA_FLAGS += -DWEBP_HAVE_GIF
-examples/anim_dump: examples/libanim_util.a
+examples/anim_dump: examples/libanim_util.a examples/libgifdec.a
 examples/anim_dump: src/demux/libwebpdemux.a
 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: EXTRA_LIBS += $(GIF_LIBS) $(DWEBP_LIBS)
+examples/anim_dump: override 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: EXTRA_LIBS += $(CWEBP_LIBS)
+examples/cwebp: override 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: EXTRA_LIBS += $(DWEBP_LIBS)
+examples/dwebp: override 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: EXTRA_LIBS += $(GIF_LIBS)
+examples/gif2webp: override 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: EXTRA_LIBS += $(GL_LIBS)
+examples/vwebp: override 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
 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: EXTRA_LIBS += $(CWEBP_LIBS)
+examples/img2webp: override EXTRA_LIBS += $(CWEBP_LIBS)
 examples/webpinfo: examples/libexample_util.a imageio/libimageio_util.a
 examples/webpinfo: src/libwebpdecoder.a
 
 extras/get_disto: extras/get_disto.o
-extras/get_disto: imageio/libimagedec.a imageio/libimageio_util.a src/libwebp.a
-extras/get_disto: EXTRA_LIBS += $(CWEBP_LIBS)
+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/webp_quality: extras/webp_quality.o
 extras/webp_quality: imageio/libimageio_util.a
@@ -451,7 +458,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: EXTRA_LIBS += $(SDL_LIBS)
+extras/vwebp_sdl: override EXTRA_LIBS += $(SDL_LIBS)
 
 $(OUT_EXAMPLES) $(EXTRA_EXAMPLES) $(OTHER_EXAMPLES):
 	$(CC) -o $@ $^ $(LDFLAGS)
@@ -470,7 +477,7 @@ dist: all
 	for m in man/[cdv]webp.1 man/gif2webp.1 man/webpmux.1 \
                  man/img2webp.1 man/webpinfo.1; do \
 	  basenam=$$(basename $$m .1); \
-	  $(GROFF) -t -e -man -T utf8 $$m \
+	  $(GROFF) -t -e -man -T ascii $$m \
 	    | $(COL) -bx >$(DESTDIR)/doc/$${basenam}.txt; \
 	  $(GROFF) -t -e -man -T html $$m \
 	    | $(COL) -bx >$(DESTDIR)/doc/$${basenam}.html; \

man/Makefile.am

@@ -1,10 +1,13 @@
 man_MANS = cwebp.1 dwebp.1
-if WANT_MUX
+if BUILD_MUX
   man_MANS += webpmux.1
 endif
 if BUILD_GIF2WEBP
   man_MANS += gif2webp.1
 endif
+if BUILD_IMG2WEBP
+  man_MANS += img2webp.1
+endif
 if BUILD_VWEBP
   man_MANS += vwebp.1
 endif

man/cwebp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH CWEBP 1 "January 20, 2017"
+.TH CWEBP 1 "January 11, 2019"
 .SH NAME
 cwebp \- compress an image file to a WebP file
 .SH SYNOPSIS
@@ -41,10 +41,12 @@ the invisible pixel values (R/G/B or Y/U/V) will be preserved only if the
 \-exact option is used.
 .TP
 .BI \-near_lossless " int
-Use near\-lossless image preprocessing. This option adjusts pixel values
-to help compressibility, but has minimal impact on the visual quality.
-It triggers lossless compression mode automatically.
-Range is 0 (maximum preprocessing) to 100 (no preprocessing, the default).
+Specify the level of near\-lossless image preprocessing. This option adjusts
+pixel values to help compressibility, but has minimal impact on the visual
+quality. It triggers lossless compression mode automatically. The range is 0
+(maximum preprocessing) to 100 (no preprocessing, the default). The typical
+value is around 60. Note that lossy with \fB\-q 100\fP can at times yield
+better results.
 .TP
 .BI \-q " float
 Specify the compression factor for RGB channels between 0 and 100. The default

man/gif2webp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH GIF2WEBP 1 "September 20, 2017"
+.TH GIF2WEBP 1 "January 25, 2018"
 .SH NAME
 gif2webp \- Convert a GIF image to WebP
 .SH SYNOPSIS
@@ -20,6 +20,12 @@ Specify the name of the output WebP file. If omitted, \fBgif2webp\fP will
 perform conversion but only report statistics.
 Using "\-" as output name will direct output to 'stdout'.
 .TP
+.BI \-\- " string
+Explicitly specify the input file. This option is useful if the input
+file starts with an '\-' for instance. This option must appear \fBlast\fP.
+Any other options afterward will be ignored. If the input file is "\-",
+the data will be read from \fIstdin\fP instead of a file.
+.TP
 .B \-h, \-help
 Usage information.
 .TP
@@ -109,6 +115,7 @@ the range of 20 to 50.
 .TP
 .B \-mt
 Use multi-threading for encoding, if possible.
+.TP
 .B \-loop_compatibility
 If enabled, handle the loop information in a compatible fashion for Chrome
 version prior to M62 (inclusive) and Firefox.
@@ -136,6 +143,8 @@ gif2webp \-lossy \-m 3 picture.gif \-o picture_lossy.webp
 gif2webp \-lossy \-f 50 picture.gif \-o picture.webp
 .br
 gif2webp \-q 70 \-o picture.webp \-\- \-\-\-picture.gif
+.br
+cat picture.gif | gif2webp \-o \- \-\- \- > output.webp
 
 .SH AUTHORS
 \fBgif2webp\fP is a part of libwebp and was written by the WebP team.

man/img2webp.1

@@ -1,11 +1,13 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH IMG2WEBP 1 "January 23, 2017"
+.TH IMG2WEBP 1 "April 3, 2018"
 .SH NAME
 img2webp \- create animated WebP file from a sequence of input images.
 .SH SYNOPSIS
 .B img2webp
 [file_level_options] [files] [per_frame_options...]
 .br
+.B img2webp argument_file_name
+.br
 .SH DESCRIPTION
 This manual page documents the
 .B img2webp
@@ -13,6 +15,9 @@ command.
 .PP
 \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 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.
@@ -40,14 +45,17 @@ lossy or lossless compression for each frame heuristically. This global
 option disables the local option \fB-lossy\fP and \fB-lossless\fP .
 .TP
 .BI \-loop " int
-Specifies the number of times the animation should loop. Using '0' means
-'loop indefinitely'.
+Specifies the number of times the animation should loop. Using '0'
+means 'loop indefinitely'.
 .TP
 .BI \-v
 Be more verbose.
 .TP
 .B \-h, \-help
 A short usage summary.
+.TP
+.B \-version
+Print the version numbers of the relevant libraries used.
 
 .SH PER-FRAME OPTIONS
 The per-frame options are applied for the images following as arguments in the

man/vwebp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH VWEBP 1 "November 25, 2016"
+.TH VWEBP 1 "June 5, 2019"
 .SH NAME
 vwebp \- decompress a WebP file and display it in a window
 .SH SYNOPSIS
@@ -38,6 +38,10 @@ It helps by smoothing gradients and avoiding banding artifacts. Default: 50.
 By default, quantized transparency planes are dithered during decompression,
 to smooth the gradients. This flag will prevent this dithering.
 .TP
+.B \-usebgcolor
+Fill transparent areas with the bitstream's own background color instead of
+checkerboard only. Default is white for non-animated images.
+.TP
 .B \-mt
 Use multi-threading for decoding, if possible.
 .TP
@@ -56,6 +60,9 @@ the data will be read from \fIstdin\fP instead of a file.
 .B 'c'
 Toggle use of color profile.
 .TP
+.B 'b'
+Toggle display of background color.
+.TP
 .B 'i'
 Overlay file information.
 .TP

man/webpmux.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH WEBPMUX 1 "November 10, 2016"
+.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.
@@ -48,6 +48,8 @@ frames from animated WebP images, and manage XMP/EXIF metadata and ICC profile.
 .B webpmux [\-h|\-help]
 .br
 .B webpmux \-version
+.br
+.B webpmux argument_file_name
 .SH DESCRIPTION
 This manual page documents the
 .B webpmux
@@ -55,6 +57,9 @@ command.
 .PP
 \fBwebpmux\fP can be used to create/extract from animated WebP files, as well as
 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 large number of arguments.
 .SH OPTIONS
 .SS GET_OPTIONS (\-get):
 .TP

src/Makefile.am

@@ -1,10 +1,10 @@
 # The mux and demux libraries depend on libwebp, thus the '.' to force
 # the build order so it's available to them.
 SUBDIRS = dec enc dsp utils .
-if WANT_MUX
+if BUILD_MUX
   SUBDIRS += mux
 endif
-if WANT_DEMUX
+if BUILD_DEMUX
   SUBDIRS += demux
 endif
 
@@ -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 7:1:0
+libwebp_la_LDFLAGS = -no-undefined -version-info 8:0:1
 libwebpincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebp.pc
 
@@ -48,7 +48,7 @@ if BUILD_LIBWEBPDECODER
   libwebpdecoder_la_LIBADD += dsp/libwebpdspdecode.la
   libwebpdecoder_la_LIBADD += utils/libwebputilsdecode.la
 
-  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 3:1:0
+  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 4:0:1
   pkgconfig_DATA += libwebpdecoder.pc
 endif
 

src/dec/Makefile.am

@@ -25,5 +25,5 @@ libwebpdecodeinclude_HEADERS += ../webp/types.h
 noinst_HEADERS =
 noinst_HEADERS += ../webp/format_constants.h
 
-libwebpdecode_la_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+libwebpdecode_la_CPPFLAGS = $(AM_CPPFLAGS)
 libwebpdecodeincludedir = $(includedir)/webp

src/dec/alphai_dec.h

@@ -51,4 +51,4 @@ void WebPDeallocateAlphaMemory(VP8Decoder* const dec);
 }    // extern "C"
 #endif
 
-#endif  /* WEBP_DEC_ALPHAI_DEC_H_ */
+#endif  // WEBP_DEC_ALPHAI_DEC_H_

src/dec/frame_dec.c

@@ -338,7 +338,6 @@ void VP8InitDithering(const WebPDecoderOptions* const options,
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
         VP8QuantMatrix* const dqm = &dec->dqm_[s];
         if (dqm->uv_quant_ < DITHER_AMP_TAB_SIZE) {
-          // TODO(skal): should we specially dither more for uv_quant_ < 0?
           const int idx = (dqm->uv_quant_ < 0) ? 0 : dqm->uv_quant_;
           dqm->dither_ = (f * kQuantToDitherAmp[idx]) >> 3;
         }
@@ -400,7 +399,9 @@ static void DitherRow(VP8Decoder* const dec) {
 #define MACROBLOCK_VPOS(mb_y)  ((mb_y) * 16)    // vertical position of a MB
 
 // Finalize and transmit a complete row. Return false in case of user-abort.
-static int FinishRow(VP8Decoder* const dec, VP8Io* const io) {
+static int FinishRow(void* arg1, void* arg2) {
+  VP8Decoder* const dec = (VP8Decoder*)arg1;
+  VP8Io* const io = (VP8Io*)arg2;
   int ok = 1;
   const VP8ThreadContext* const ctx = &dec->thread_ctx_;
   const int cache_id = ctx->id_;
@@ -448,10 +449,9 @@ static int FinishRow(VP8Decoder* const dec, VP8Io* const io) {
     if (y_end > io->crop_bottom) {
       y_end = io->crop_bottom;    // make sure we don't overflow on last row.
     }
+    // If dec->alpha_data_ is not NULL, we have some alpha plane present.
     io->a = NULL;
     if (dec->alpha_data_ != NULL && y_start < y_end) {
-      // TODO(skal): testing presence of alpha with dec->alpha_data_ is not a
-      // good idea.
       io->a = VP8DecompressAlphaRows(dec, io, y_start, y_end - y_start);
       if (io->a == NULL) {
         return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
@@ -558,7 +558,6 @@ VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io) {
   if (io->bypass_filtering) {
     dec->filter_type_ = 0;
   }
-  // TODO(skal): filter type / strength / sharpness forcing
 
   // Define the area where we can skip in-loop filtering, in case of cropping.
   //
@@ -569,8 +568,6 @@ VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io) {
   // Means: there's a dependency chain that goes all the way up to the
   // top-left corner of the picture (MB #0). We must filter all the previous
   // macroblocks.
-  // TODO(skal): add an 'approximate_decoding' option, that won't produce
-  // a 1:1 bit-exactness for complex filtering?
   {
     const int extra_pixels = kFilterExtraRows[dec->filter_type_];
     if (dec->filter_type_ == 2) {
@@ -651,7 +648,7 @@ static int InitThreadContext(VP8Decoder* const dec) {
     }
     worker->data1 = dec;
     worker->data2 = (void*)&dec->thread_ctx_.io_;
-    worker->hook = (WebPWorkerHook)FinishRow;
+    worker->hook = FinishRow;
     dec->num_caches_ =
       (dec->filter_type_ > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
   } else {
@@ -671,15 +668,9 @@ int VP8GetThreadMethod(const WebPDecoderOptions* const options,
   (void)height;
   assert(headers == NULL || !headers->is_lossless);
 #if defined(WEBP_USE_THREAD)
-  if (width < MIN_WIDTH_FOR_THREADS) return 0;
-  // TODO(skal): tune the heuristic further
-#if 0
-  if (height < 2 * width) return 2;
+  if (width >= MIN_WIDTH_FOR_THREADS) return 2;
 #endif
-  return 2;
-#else   // !WEBP_USE_THREAD
   return 0;
-#endif
 }
 
 #undef MT_CACHE_LINES
@@ -741,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->mt_method_ > 0) {
+  if (dec->filter_type_ > 0 && 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

@@ -140,10 +140,9 @@ static void DoRemap(WebPIDecoder* const idec, ptrdiff_t offset) {
       if (NeedCompressedAlpha(idec)) {
         ALPHDecoder* const alph_dec = dec->alph_dec_;
         dec->alpha_data_ += offset;
-        if (alph_dec != NULL) {
+        if (alph_dec != NULL && alph_dec->vp8l_dec_ != NULL) {
           if (alph_dec->method_ == ALPHA_LOSSLESS_COMPRESSION) {
             VP8LDecoder* const alph_vp8l_dec = alph_dec->vp8l_dec_;
-            assert(alph_vp8l_dec != NULL);
             assert(dec->alpha_data_size_ >= ALPHA_HEADER_LEN);
             VP8LBitReaderSetBuffer(&alph_vp8l_dec->br_,
                                    dec->alpha_data_ + ALPHA_HEADER_LEN,
@@ -167,9 +166,11 @@ 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_ + mem->start_;
+  const uint8_t* const old_start =
+      (mem->buf_ == NULL) ? NULL : 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
@@ -185,7 +186,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;
-    memcpy(new_buf, old_base, current_size);
+    if (old_base != NULL) memcpy(new_buf, old_base, current_size);
     WebPSafeFree(mem->buf_);
     mem->buf_ = new_buf;
     mem->buf_size_ = (size_t)extra_size;
@@ -193,6 +194,7 @@ 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_);
@@ -205,7 +207,9 @@ 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 + mem->start_;
+  const uint8_t* const old_start =
+      (old_buf == NULL) ? NULL : old_buf + mem->start_;
+  assert(old_buf != NULL || mem->start_ == 0);
   assert(mem->mode_ == MEM_MODE_MAP);
 
   if (data_size < mem->buf_size_) return 0;  // can't remap to a shorter buffer!
@@ -474,6 +478,12 @@ static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) {
             MemDataSize(&idec->mem_) > MAX_MB_SIZE) {
           return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR);
         }
+        // Synchronize the threads.
+        if (dec->mt_method_ > 0) {
+          if (!WebPGetWorkerInterface()->Sync(&dec->worker_)) {
+            return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR);
+          }
+        }
         RestoreContext(&context, dec, token_br);
         return VP8_STATUS_SUSPENDED;
       }

src/dec/quant_dec.c

@@ -61,12 +61,17 @@ static const uint16_t kAcTable[128] = {
 
 void VP8ParseQuant(VP8Decoder* const dec) {
   VP8BitReader* const br = &dec->br_;
-  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 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 VP8SegmentHeader* const hdr = &dec->segment_hdr_;
   int i;

src/dec/tree_dec.c

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

src/dec/vp8_dec.c

@@ -161,23 +161,26 @@ static int ParseSegmentHeader(VP8BitReader* br,
                               VP8SegmentHeader* hdr, VP8Proba* proba) {
   assert(br != NULL);
   assert(hdr != NULL);
-  hdr->use_segment_ = VP8Get(br);
+  hdr->use_segment_ = VP8Get(br, "global-header");
   if (hdr->use_segment_) {
-    hdr->update_map_ = VP8Get(br);
-    if (VP8Get(br)) {   // update data
+    hdr->update_map_ = VP8Get(br, "global-header");
+    if (VP8Get(br, "global-header")) {   // update data
       int s;
-      hdr->absolute_delta_ = VP8Get(br);
+      hdr->absolute_delta_ = VP8Get(br, "global-header");
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->quantizer_[s] = VP8Get(br) ? VP8GetSignedValue(br, 7) : 0;
+        hdr->quantizer_[s] = VP8Get(br, "global-header") ?
+            VP8GetSignedValue(br, 7, "global-header") : 0;
       }
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->filter_strength_[s] = VP8Get(br) ? VP8GetSignedValue(br, 6) : 0;
+        hdr->filter_strength_[s] = VP8Get(br, "global-header") ?
+            VP8GetSignedValue(br, 6, "global-header") : 0;
       }
     }
     if (hdr->update_map_) {
       int s;
       for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
-        proba->segments_[s] = VP8Get(br) ? VP8GetValue(br, 8) : 255u;
+        proba->segments_[s] = VP8Get(br, "global-header") ?
+            VP8GetValue(br, 8, "global-header") : 255u;
       }
     }
   } else {
@@ -205,7 +208,7 @@ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
   size_t last_part;
   size_t p;
 
-  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2)) - 1;
+  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2, "global-header")) - 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.
@@ -229,21 +232,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);
-  hdr->level_     = VP8GetValue(br, 6);
-  hdr->sharpness_ = VP8GetValue(br, 3);
-  hdr->use_lf_delta_ = VP8Get(br);
+  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");
   if (hdr->use_lf_delta_) {
-    if (VP8Get(br)) {   // update lf-delta?
+    if (VP8Get(br, "global-header")) {   // update lf-delta?
       int i;
       for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
-        if (VP8Get(br)) {
-          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6);
+        if (VP8Get(br, "global-header")) {
+          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
         }
       }
       for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
-        if (VP8Get(br)) {
-          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6);
+        if (VP8Get(br, "global-header")) {
+          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
         }
       }
     }
@@ -352,8 +355,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);
-    pic_hdr->clamp_type_ = VP8Get(br);
+    pic_hdr->colorspace_ = VP8Get(br, "global-header");
+    pic_hdr->clamp_type_ = VP8Get(br, "global-header");
   }
   if (!ParseSegmentHeader(br, &dec->segment_hdr_, &dec->proba_)) {
     return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
@@ -378,7 +381,7 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
                        "Not a key frame.");
   }
 
-  VP8Get(br);   // ignore the value of update_proba_
+  VP8Get(br, "global-header");   // ignore the value of update_proba_
 
   VP8ParseProba(br, dec);
 
@@ -403,28 +406,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])) {
-    if (!VP8GetBit(br, p[4])) {
+  if (!VP8GetBit(br, p[3], "coeffs")) {
+    if (!VP8GetBit(br, p[4], "coeffs")) {
       v = 2;
     } else {
-      v = 3 + VP8GetBit(br, p[5]);
+      v = 3 + VP8GetBit(br, p[5], "coeffs");
     }
   } else {
-    if (!VP8GetBit(br, p[6])) {
-      if (!VP8GetBit(br, p[7])) {
-        v = 5 + VP8GetBit(br, 159);
+    if (!VP8GetBit(br, p[6], "coeffs")) {
+      if (!VP8GetBit(br, p[7], "coeffs")) {
+        v = 5 + VP8GetBit(br, 159, "coeffs");
       } else {
-        v = 7 + 2 * VP8GetBit(br, 165);
-        v += VP8GetBit(br, 145);
+        v = 7 + 2 * VP8GetBit(br, 165, "coeffs");
+        v += VP8GetBit(br, 145, "coeffs");
       }
     } else {
       const uint8_t* tab;
-      const int bit1 = VP8GetBit(br, p[8]);
-      const int bit0 = VP8GetBit(br, p[9 + bit1]);
+      const int bit1 = VP8GetBit(br, p[8], "coeffs");
+      const int bit0 = VP8GetBit(br, p[9 + bit1], "coeffs");
       const int cat = 2 * bit1 + bit0;
       v = 0;
       for (tab = kCat3456[cat]; *tab; ++tab) {
-        v += v + VP8GetBit(br, *tab);
+        v += v + VP8GetBit(br, *tab, "coeffs");
       }
       v += 3 + (8 << cat);
     }
@@ -438,24 +441,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])) {
+    if (!VP8GetBit(br, p[0], "coeffs")) {
       return n;  // previous coeff was last non-zero coeff
     }
-    while (!VP8GetBit(br, p[1])) {       // sequence of zero coeffs
+    while (!VP8GetBit(br, p[1], "coeffs")) {       // 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])) {
+      if (!VP8GetBit(br, p[2], "coeffs")) {
         v = 1;
         p = p_ctx[1];
       } else {
         v = GetLargeValue(br, p);
         p = p_ctx[2];
       }
-      out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
+      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
     }
   }
   return 16;
@@ -468,30 +471,30 @@ 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])) {
+    if (!VP8GetBitAlt(br, p[0], "coeffs")) {
       return n;  // previous coeff was last non-zero coeff
     }
-    while (!VP8GetBitAlt(br, p[1])) {       // sequence of zero coeffs
+    while (!VP8GetBitAlt(br, p[1], "coeffs")) {       // 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])) {
+      if (!VP8GetBitAlt(br, p[2], "coeffs")) {
         v = 1;
         p = p_ctx[1];
       } else {
         v = GetLargeValue(br, p);
         p = p_ctx[2];
       }
-      out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
+      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
     }
   }
   return 16;
 }
 
-WEBP_TSAN_IGNORE_FUNCTION static void InitGetCoeffs(void) {
+static WEBP_TSAN_IGNORE_FUNCTION void InitGetCoeffs(void) {
   if (GetCoeffs == NULL) {
     if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
       GetCoeffs = GetCoeffsAlt;

src/dec/vp8_dec.h

@@ -182,4 +182,4 @@ WEBP_EXTERN int VP8LGetInfo(
 }    // extern "C"
 #endif
 
-#endif  /* WEBP_DEC_VP8_DEC_H_ */
+#endif  // WEBP_DEC_VP8_DEC_H_

src/dec/vp8i_dec.h

@@ -30,9 +30,9 @@ extern "C" {
 // Various defines and enums
 
 // version numbers
-#define DEC_MAJ_VERSION 0
-#define DEC_MIN_VERSION 6
-#define DEC_REV_VERSION 1
+#define DEC_MAJ_VERSION 1
+#define DEC_MIN_VERSION 1
+#define DEC_REV_VERSION 0
 
 // YUV-cache parameters. Cache is 32-bytes wide (= one cacheline).
 // Constraints are: We need to store one 16x16 block of luma samples (y),
@@ -316,4 +316,4 @@ const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec,
 }    // extern "C"
 #endif
 
-#endif  /* WEBP_DEC_VP8I_DEC_H_ */
+#endif  // WEBP_DEC_VP8I_DEC_H_

src/dec/vp8l_dec.c

@@ -437,9 +437,9 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
     }
   }
 
-  htree_groups = VP8LHtreeGroupsNew(num_htree_groups);
   code_lengths = (int*)WebPSafeCalloc((uint64_t)max_alphabet_size,
                                       sizeof(*code_lengths));
+  htree_groups = VP8LHtreeGroupsNew(num_htree_groups);
 
   if (htree_groups == NULL || code_lengths == NULL ||
       !VP8LHuffmanTablesAllocate(num_htree_groups * table_size,
@@ -758,11 +758,11 @@ static WEBP_INLINE HTreeGroup* GetHtreeGroupForPos(VP8LMetadata* const hdr,
 
 typedef void (*ProcessRowsFunc)(VP8LDecoder* const dec, int row);
 
-static void ApplyInverseTransforms(VP8LDecoder* const dec, int num_rows,
+static void ApplyInverseTransforms(VP8LDecoder* const dec,
+                                   int start_row, 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,8 +793,7 @@ 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, num_rows, rows);
+    ApplyInverseTransforms(dec, dec->last_row_, num_rows, rows);
     if (!SetCropWindow(io, dec->last_row_, row, &rows_data, in_stride)) {
       // Nothing to output (this time).
     } else {
@@ -1197,6 +1196,7 @@ 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;
@@ -1237,20 +1237,9 @@ static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data,
   }
 
   br->eos_ = VP8LIsEndOfStream(br);
-  // In incremental decoding:
-  // br->eos_ && src < src_last: if 'br' reached the end of the buffer and
-  // 'src_last' has not been reached yet, there is not enough data. 'dec' has to
-  // be reset until there is more data.
-  // !br->eos_ && src < src_last: this cannot happen as either the buffer is
-  // fully read, either enough has been read to reach 'src_last'.
-  // src >= src_last: 'src_last' is reached, all is fine. 'src' can actually go
-  // beyond 'src_last' in case the image is cropped and an LZ77 goes further.
-  // The buffer might have been enough or there is some left. 'br->eos_' does
-  // not matter.
-  assert(!dec->incremental_ || (br->eos_ && src < src_last) || src >= src_last);
-  if (dec->incremental_ && br->eos_ && src < src_last) {
+  if (dec->incremental_ && br->eos_ && src < src_end) {
     RestoreState(dec);
-  } else if ((dec->incremental_ && src >= src_last) || !br->eos_) {
+  } else if (!br->eos_) {
     // Process the remaining rows corresponding to last row-block.
     if (process_func != NULL) {
       process_func(dec, row > last_row ? last_row : row);
@@ -1568,7 +1557,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, num_rows_to_process, in);
+    ApplyInverseTransforms(dec, cur_row, num_rows_to_process, in);
     WebPExtractGreen(src, dst, cache_pixs);
     AlphaApplyFilter(alph_dec,
                      cur_row, cur_row + num_rows_to_process, dst, width);
@@ -1588,7 +1577,6 @@ int VP8LDecodeAlphaHeader(ALPHDecoder* const alph_dec,
   if (dec == NULL) return 0;
 
   assert(alph_dec != NULL);
-  alph_dec->vp8l_dec_ = dec;
 
   dec->width_ = alph_dec->width_;
   dec->height_ = alph_dec->height_;
@@ -1620,11 +1608,12 @@ int VP8LDecodeAlphaHeader(ALPHDecoder* const alph_dec,
 
   if (!ok) goto Err;
 
+  // Only set here, once we are sure it is valid (to avoid thread races).
+  alph_dec->vp8l_dec_ = dec;
   return 1;
 
  Err:
-  VP8LDelete(alph_dec->vp8l_dec_);
-  alph_dec->vp8l_dec_ = NULL;
+  VP8LDelete(dec);
   return 0;
 }
 
@@ -1708,17 +1697,17 @@ int VP8LDecodeImage(VP8LDecoder* const dec) {
 
 #if !defined(WEBP_REDUCE_SIZE)
     if (io->use_scaling && !AllocateAndInitRescaler(dec, io)) goto Err;
-
-    if (io->use_scaling || WebPIsPremultipliedMode(dec->output_->colorspace)) {
-      // need the alpha-multiply functions for premultiplied output or rescaling
-      WebPInitAlphaProcessing();
-    }
 #else
     if (io->use_scaling) {
       dec->status_ = VP8_STATUS_INVALID_PARAM;
       goto Err;
     }
 #endif
+    if (io->use_scaling || WebPIsPremultipliedMode(dec->output_->colorspace)) {
+      // need the alpha-multiply functions for premultiplied output or rescaling
+      WebPInitAlphaProcessing();
+    }
+
     if (!WebPIsRGBMode(dec->output_->colorspace)) {
       WebPInitConvertARGBToYUV();
       if (dec->output_->u.YUVA.a != NULL) WebPInitAlphaProcessing();

src/dec/vp8li_dec.h

@@ -132,4 +132,4 @@ void VP8LDelete(VP8LDecoder* const dec);
 }    // extern "C"
 #endif
 
-#endif  /* WEBP_DEC_VP8LI_DEC_H_ */
+#endif  // WEBP_DEC_VP8LI_DEC_H_

src/dec/webpi_dec.h

@@ -130,4 +130,4 @@ int WebPAvoidSlowMemory(const WebPDecBuffer* const output,
 }    // extern "C"
 #endif
 
-#endif  /* WEBP_DEC_WEBPI_DEC_H_ */
+#endif  // WEBP_DEC_WEBPI_DEC_H_

src/demux/Makefile.am

@@ -5,11 +5,14 @@ libwebpdemux_la_SOURCES =
 libwebpdemux_la_SOURCES += anim_decode.c demux.c
 
 libwebpdemuxinclude_HEADERS =
+libwebpdemuxinclude_HEADERS += ../webp/decode.h
 libwebpdemuxinclude_HEADERS += ../webp/demux.h
 libwebpdemuxinclude_HEADERS += ../webp/mux_types.h
 libwebpdemuxinclude_HEADERS += ../webp/types.h
+noinst_HEADERS =
+noinst_HEADERS += ../webp/format_constants.h
 
 libwebpdemux_la_LIBADD = ../libwebp.la
-libwebpdemux_la_LDFLAGS = -no-undefined -version-info 2:3:0
+libwebpdemux_la_LDFLAGS = -no-undefined -version-info 2:6:0
 libwebpdemuxincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebpdemux.pc

src/demux/demux.c

@@ -23,9 +23,9 @@
 #include "src/webp/demux.h"
 #include "src/webp/format_constants.h"
 
-#define DMUX_MAJ_VERSION 0
-#define DMUX_MIN_VERSION 3
-#define DMUX_REV_VERSION 3
+#define DMUX_MAJ_VERSION 1
+#define DMUX_MIN_VERSION 1
+#define DMUX_REV_VERSION 0
 
 typedef struct {
   size_t start_;        // start location of the data

src/demux/libwebpdemux.rc

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

src/dsp/Makefile.am

@@ -1,7 +1,6 @@
 AM_CPPFLAGS += -I$(top_builddir) -I$(top_srcdir)
 noinst_LTLIBRARIES =
 noinst_LTLIBRARIES += libwebpdsp.la
-noinst_LTLIBRARIES += libwebpdsp_avx2.la
 noinst_LTLIBRARIES += libwebpdsp_sse2.la
 noinst_LTLIBRARIES += libwebpdspdecode_sse2.la
 noinst_LTLIBRARIES += libwebpdsp_sse41.la
@@ -10,6 +9,10 @@ noinst_LTLIBRARIES += libwebpdsp_neon.la
 noinst_LTLIBRARIES += libwebpdspdecode_neon.la
 noinst_LTLIBRARIES += libwebpdsp_msa.la
 noinst_LTLIBRARIES += libwebpdspdecode_msa.la
+noinst_LTLIBRARIES += libwebpdsp_mips32.la
+noinst_LTLIBRARIES += libwebpdspdecode_mips32.la
+noinst_LTLIBRARIES += libwebpdsp_mips_dsp_r2.la
+noinst_LTLIBRARIES += libwebpdspdecode_mips_dsp_r2.la
 
 if BUILD_LIBWEBPDECODER
   noinst_LTLIBRARIES += libwebpdspdecode.la
@@ -20,56 +23,37 @@ commondir = $(includedir)/webp
 
 COMMON_SOURCES =
 COMMON_SOURCES += alpha_processing.c
-COMMON_SOURCES += alpha_processing_mips_dsp_r2.c
-COMMON_SOURCES += common_sse2.h
 COMMON_SOURCES += cpu.c
 COMMON_SOURCES += dec.c
 COMMON_SOURCES += dec_clip_tables.c
-COMMON_SOURCES += dec_mips32.c
-COMMON_SOURCES += dec_mips_dsp_r2.c
 COMMON_SOURCES += dsp.h
 COMMON_SOURCES += filters.c
-COMMON_SOURCES += filters_mips_dsp_r2.c
 COMMON_SOURCES += lossless.c
 COMMON_SOURCES += lossless.h
 COMMON_SOURCES += lossless_common.h
-COMMON_SOURCES += lossless_mips_dsp_r2.c
-COMMON_SOURCES += mips_macro.h
 COMMON_SOURCES += rescaler.c
-COMMON_SOURCES += rescaler_mips32.c
-COMMON_SOURCES += rescaler_mips_dsp_r2.c
 COMMON_SOURCES += upsampling.c
-COMMON_SOURCES += upsampling_mips_dsp_r2.c
 COMMON_SOURCES += yuv.c
 COMMON_SOURCES += yuv.h
-COMMON_SOURCES += yuv_mips32.c
-COMMON_SOURCES += yuv_mips_dsp_r2.c
 
 ENC_SOURCES =
 ENC_SOURCES += cost.c
-ENC_SOURCES += cost_mips32.c
-ENC_SOURCES += cost_mips_dsp_r2.c
 ENC_SOURCES += enc.c
-ENC_SOURCES += enc_mips32.c
-ENC_SOURCES += enc_mips_dsp_r2.c
 ENC_SOURCES += lossless_enc.c
-ENC_SOURCES += lossless_enc_mips32.c
-ENC_SOURCES += lossless_enc_mips_dsp_r2.c
+ENC_SOURCES += quant.h
 ENC_SOURCES += ssim.c
 
-libwebpdsp_avx2_la_SOURCES =
-libwebpdsp_avx2_la_SOURCES += enc_avx2.c
-libwebpdsp_avx2_la_CPPFLAGS = $(libwebpdsp_la_CPPFLAGS)
-libwebpdsp_avx2_la_CFLAGS = $(AM_CFLAGS) $(AVX2_FLAGS)
-
 libwebpdspdecode_sse41_la_SOURCES =
 libwebpdspdecode_sse41_la_SOURCES += alpha_processing_sse41.c
 libwebpdspdecode_sse41_la_SOURCES += dec_sse41.c
+libwebpdspdecode_sse41_la_SOURCES += upsampling_sse41.c
+libwebpdspdecode_sse41_la_SOURCES += yuv_sse41.c
 libwebpdspdecode_sse41_la_CPPFLAGS = $(libwebpdsp_la_CPPFLAGS)
 libwebpdspdecode_sse41_la_CFLAGS = $(AM_CFLAGS) $(SSE41_FLAGS)
 
 libwebpdspdecode_sse2_la_SOURCES =
 libwebpdspdecode_sse2_la_SOURCES += alpha_processing_sse2.c
+libwebpdspdecode_sse2_la_SOURCES += common_sse2.h
 libwebpdspdecode_sse2_la_SOURCES += dec_sse2.c
 libwebpdspdecode_sse2_la_SOURCES += filters_sse2.c
 libwebpdspdecode_sse2_la_SOURCES += lossless_sse2.c
@@ -101,6 +85,26 @@ libwebpdspdecode_msa_la_SOURCES += upsampling_msa.c
 libwebpdspdecode_msa_la_CPPFLAGS = $(libwebpdsp_msa_la_CPPFLAGS)
 libwebpdspdecode_msa_la_CFLAGS = $(libwebpdsp_msa_la_CFLAGS)
 
+libwebpdspdecode_mips32_la_SOURCES =
+libwebpdspdecode_mips32_la_SOURCES += dec_mips32.c
+libwebpdspdecode_mips32_la_SOURCES += mips_macro.h
+libwebpdspdecode_mips32_la_SOURCES += rescaler_mips32.c
+libwebpdspdecode_mips32_la_SOURCES += yuv_mips32.c
+libwebpdspdecode_mips32_la_CPPFLAGS = $(libwebpdsp_mips32_la_CPPFLAGS)
+libwebpdspdecode_mips32_la_CFLAGS = $(libwebpdsp_mips32_la_CFLAGS)
+
+libwebpdspdecode_mips_dsp_r2_la_SOURCES =
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += alpha_processing_mips_dsp_r2.c
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += dec_mips_dsp_r2.c
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += filters_mips_dsp_r2.c
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += lossless_mips_dsp_r2.c
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += mips_macro.h
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += rescaler_mips_dsp_r2.c
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += upsampling_mips_dsp_r2.c
+libwebpdspdecode_mips_dsp_r2_la_SOURCES += yuv_mips_dsp_r2.c
+libwebpdspdecode_mips_dsp_r2_la_CPPFLAGS = $(libwebpdsp_mips_dsp_r2_la_CPPFLAGS)
+libwebpdspdecode_mips_dsp_r2_la_CFLAGS = $(libwebpdsp_mips_dsp_r2_la_CFLAGS)
+
 libwebpdsp_sse2_la_SOURCES =
 libwebpdsp_sse2_la_SOURCES += cost_sse2.c
 libwebpdsp_sse2_la_SOURCES += enc_sse2.c
@@ -118,6 +122,7 @@ libwebpdsp_sse41_la_CFLAGS = $(AM_CFLAGS) $(SSE41_FLAGS)
 libwebpdsp_sse41_la_LIBADD = libwebpdspdecode_sse41.la
 
 libwebpdsp_neon_la_SOURCES =
+libwebpdsp_neon_la_SOURCES += cost_neon.c
 libwebpdsp_neon_la_SOURCES += enc_neon.c
 libwebpdsp_neon_la_SOURCES += lossless_enc_neon.c
 libwebpdsp_neon_la_CPPFLAGS = $(libwebpdsp_la_CPPFLAGS)
@@ -131,6 +136,22 @@ libwebpdsp_msa_la_CPPFLAGS = $(libwebpdsp_la_CPPFLAGS)
 libwebpdsp_msa_la_CFLAGS = $(AM_CFLAGS)
 libwebpdsp_msa_la_LIBADD = libwebpdspdecode_msa.la
 
+libwebpdsp_mips32_la_SOURCES =
+libwebpdsp_mips32_la_SOURCES += cost_mips32.c
+libwebpdsp_mips32_la_SOURCES += enc_mips32.c
+libwebpdsp_mips32_la_SOURCES += lossless_enc_mips32.c
+libwebpdsp_mips32_la_CPPFLAGS = $(libwebpdsp_la_CPPFLAGS)
+libwebpdsp_mips32_la_CFLAGS = $(AM_CFLAGS)
+libwebpdsp_mips32_la_LIBADD = libwebpdspdecode_mips32.la
+
+libwebpdsp_mips_dsp_r2_la_SOURCES =
+libwebpdsp_mips_dsp_r2_la_SOURCES += cost_mips_dsp_r2.c
+libwebpdsp_mips_dsp_r2_la_SOURCES += enc_mips_dsp_r2.c
+libwebpdsp_mips_dsp_r2_la_SOURCES += lossless_enc_mips_dsp_r2.c
+libwebpdsp_mips_dsp_r2_la_CPPFLAGS = $(libwebpdsp_la_CPPFLAGS)
+libwebpdsp_mips_dsp_r2_la_CFLAGS = $(AM_CFLAGS)
+libwebpdsp_mips_dsp_r2_la_LIBADD = libwebpdspdecode_mips_dsp_r2.la
+
 libwebpdsp_la_SOURCES = $(COMMON_SOURCES) $(ENC_SOURCES)
 
 noinst_HEADERS =
@@ -139,14 +160,15 @@ noinst_HEADERS += ../webp/decode.h
 
 libwebpdsp_la_CPPFLAGS =
 libwebpdsp_la_CPPFLAGS += $(AM_CPPFLAGS)
-libwebpdsp_la_CPPFLAGS += $(USE_EXPERIMENTAL_CODE) $(USE_SWAP_16BIT_CSP)
+libwebpdsp_la_CPPFLAGS += $(USE_SWAP_16BIT_CSP)
 libwebpdsp_la_LDFLAGS = -lm
 libwebpdsp_la_LIBADD =
-libwebpdsp_la_LIBADD += libwebpdsp_avx2.la
 libwebpdsp_la_LIBADD += libwebpdsp_sse2.la
 libwebpdsp_la_LIBADD += libwebpdsp_sse41.la
 libwebpdsp_la_LIBADD += libwebpdsp_neon.la
 libwebpdsp_la_LIBADD += libwebpdsp_msa.la
+libwebpdsp_la_LIBADD += libwebpdsp_mips32.la
+libwebpdsp_la_LIBADD += libwebpdsp_mips_dsp_r2.la
 
 if BUILD_LIBWEBPDECODER
   libwebpdspdecode_la_SOURCES = $(COMMON_SOURCES)
@@ -158,4 +180,6 @@ if BUILD_LIBWEBPDECODER
   libwebpdspdecode_la_LIBADD += libwebpdspdecode_sse41.la
   libwebpdspdecode_la_LIBADD += libwebpdspdecode_neon.la
   libwebpdspdecode_la_LIBADD += libwebpdspdecode_msa.la
+  libwebpdspdecode_la_LIBADD += libwebpdspdecode_mips32.la
+  libwebpdspdecode_la_LIBADD += libwebpdspdecode_mips_dsp_r2.la
 endif

src/dsp/alpha_processing.c

@@ -409,12 +409,7 @@ extern void WebPInitAlphaProcessingSSE2(void);
 extern void WebPInitAlphaProcessingSSE41(void);
 extern void WebPInitAlphaProcessingNEON(void);
 
-static volatile VP8CPUInfo alpha_processing_last_cpuinfo_used =
-    (VP8CPUInfo)&alpha_processing_last_cpuinfo_used;
-
-WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessing(void) {
-  if (alpha_processing_last_cpuinfo_used == VP8GetCPUInfo) return;
-
+WEBP_DSP_INIT_FUNC(WebPInitAlphaProcessing) {
   WebPMultARGBRow = WebPMultARGBRow_C;
   WebPMultRow = WebPMultRow_C;
   WebPApplyAlphaMultiply4444 = ApplyAlphaMultiply_16b_C;
@@ -474,6 +469,4 @@ WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessing(void) {
   assert(WebPPackRGB != NULL);
   assert(WebPHasAlpha8b != NULL);
   assert(WebPHasAlpha32b != NULL);
-
-  alpha_processing_last_cpuinfo_used = VP8GetCPUInfo;
 }

src/dsp/alpha_processing_sse2.c

@@ -214,7 +214,7 @@ static void ApplyAlphaMultiply_SSE2(uint8_t* rgba, int alpha_first,
 // Alpha detection
 
 static int HasAlpha8b_SSE2(const uint8_t* src, int length) {
-  const __m128i all_0xff = _mm_set1_epi8(0xff);
+  const __m128i all_0xff = _mm_set1_epi8((char)0xff);
   int i = 0;
   for (; i + 16 <= length; i += 16) {
     const __m128i v = _mm_loadu_si128((const __m128i*)(src + i));
@@ -228,7 +228,7 @@ static int HasAlpha8b_SSE2(const uint8_t* src, int length) {
 
 static int HasAlpha32b_SSE2(const uint8_t* src, int length) {
   const __m128i alpha_mask = _mm_set1_epi32(0xff);
-  const __m128i all_0xff = _mm_set1_epi8(0xff);
+  const __m128i all_0xff = _mm_set1_epi8((char)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

src/dsp/common_sse2.h

@@ -128,9 +128,9 @@ static WEBP_INLINE void VP8Transpose_2_4x4_16b(
 // Pack the planar buffers
 // rrrr... rrrr... gggg... gggg... bbbb... bbbb....
 // triplet by triplet in the output buffer rgb as rgbrgbrgbrgb ...
-static WEBP_INLINE void VP8PlanarTo24b(__m128i* const in0, __m128i* const in1,
-                                       __m128i* const in2, __m128i* const in3,
-                                       __m128i* const in4, __m128i* const in5) {
+static WEBP_INLINE void VP8PlanarTo24b_SSE2(
+    __m128i* const in0, __m128i* const in1, __m128i* const in2,
+    __m128i* const in3, __m128i* const in4, __m128i* const in5) {
   // The input is 6 registers of sixteen 8b but for the sake of explanation,
   // let's take 6 registers of four 8b values.
   // To pack, we will keep taking one every two 8b integer and move it
@@ -159,7 +159,7 @@ static WEBP_INLINE void VP8PlanarTo24b(__m128i* const in0, __m128i* const in1,
 
 // Convert four packed four-channel buffers like argbargbargbargb... into the
 // split channels aaaaa ... rrrr ... gggg .... bbbbb ......
-static WEBP_INLINE void VP8L32bToPlanar(__m128i* const in0,
+static WEBP_INLINE void VP8L32bToPlanar_SSE2(__m128i* const in0,
                                              __m128i* const in1,
                                              __m128i* const in2,
                                              __m128i* const in3) {

src/dsp/common_sse41.h

@@ -0,0 +1,132 @@
+// Copyright 2016 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.
+// -----------------------------------------------------------------------------
+//
+// SSE4 code common to several files.
+//
+// Author: Vincent Rabaud (vrabaud@google.com)
+
+#ifndef WEBP_DSP_COMMON_SSE41_H_
+#define WEBP_DSP_COMMON_SSE41_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(WEBP_USE_SSE41)
+#include <smmintrin.h>
+
+//------------------------------------------------------------------------------
+// Channel mixing.
+// Shuffles the input buffer as A0 0 0 A1 0 0 A2 ...
+#define WEBP_SSE41_SHUFF(OUT, IN0, IN1)    \
+  OUT##0 = _mm_shuffle_epi8(*IN0, shuff0); \
+  OUT##1 = _mm_shuffle_epi8(*IN0, shuff1); \
+  OUT##2 = _mm_shuffle_epi8(*IN0, shuff2); \
+  OUT##3 = _mm_shuffle_epi8(*IN1, shuff0); \
+  OUT##4 = _mm_shuffle_epi8(*IN1, shuff1); \
+  OUT##5 = _mm_shuffle_epi8(*IN1, shuff2);
+
+// Pack the planar buffers
+// rrrr... rrrr... gggg... gggg... bbbb... bbbb....
+// triplet by triplet in the output buffer rgb as rgbrgbrgbrgb ...
+static WEBP_INLINE void VP8PlanarTo24b_SSE41(
+    __m128i* const in0, __m128i* const in1, __m128i* const in2,
+    __m128i* const in3, __m128i* const in4, __m128i* const in5) {
+  __m128i R0, R1, R2, R3, R4, R5;
+  __m128i G0, G1, G2, G3, G4, G5;
+  __m128i B0, B1, B2, B3, B4, B5;
+
+  // Process R.
+  {
+    const __m128i shuff0 = _mm_set_epi8(
+        5, -1, -1, 4, -1, -1, 3, -1, -1, 2, -1, -1, 1, -1, -1, 0);
+    const __m128i shuff1 = _mm_set_epi8(
+        -1, 10, -1, -1, 9, -1, -1, 8, -1, -1, 7, -1, -1, 6, -1, -1);
+    const __m128i shuff2 = _mm_set_epi8(
+     -1, -1, 15, -1, -1, 14, -1, -1, 13, -1, -1, 12, -1, -1, 11, -1);
+    WEBP_SSE41_SHUFF(R, in0, in1)
+  }
+
+  // Process G.
+  {
+    // Same as before, just shifted to the left by one and including the right
+    // padding.
+    const __m128i shuff0 = _mm_set_epi8(
+        -1, -1, 4, -1, -1, 3, -1, -1, 2, -1, -1, 1, -1, -1, 0, -1);
+    const __m128i shuff1 = _mm_set_epi8(
+        10, -1, -1, 9, -1, -1, 8, -1, -1, 7, -1, -1, 6, -1, -1, 5);
+    const __m128i shuff2 = _mm_set_epi8(
+     -1, 15, -1, -1, 14, -1, -1, 13, -1, -1, 12, -1, -1, 11, -1, -1);
+    WEBP_SSE41_SHUFF(G, in2, in3)
+  }
+
+  // Process B.
+  {
+    const __m128i shuff0 = _mm_set_epi8(
+        -1, 4, -1, -1, 3, -1, -1, 2, -1, -1, 1, -1, -1, 0, -1, -1);
+    const __m128i shuff1 = _mm_set_epi8(
+        -1, -1, 9, -1, -1, 8, -1, -1, 7, -1, -1, 6, -1, -1, 5, -1);
+    const __m128i shuff2 = _mm_set_epi8(
+      15, -1, -1, 14, -1, -1, 13, -1, -1, 12, -1, -1, 11, -1, -1, 10);
+    WEBP_SSE41_SHUFF(B, in4, in5)
+  }
+
+  // OR the different channels.
+  {
+    const __m128i RG0 = _mm_or_si128(R0, G0);
+    const __m128i RG1 = _mm_or_si128(R1, G1);
+    const __m128i RG2 = _mm_or_si128(R2, G2);
+    const __m128i RG3 = _mm_or_si128(R3, G3);
+    const __m128i RG4 = _mm_or_si128(R4, G4);
+    const __m128i RG5 = _mm_or_si128(R5, G5);
+    *in0 = _mm_or_si128(RG0, B0);
+    *in1 = _mm_or_si128(RG1, B1);
+    *in2 = _mm_or_si128(RG2, B2);
+    *in3 = _mm_or_si128(RG3, B3);
+    *in4 = _mm_or_si128(RG4, B4);
+    *in5 = _mm_or_si128(RG5, B5);
+  }
+}
+
+#undef WEBP_SSE41_SHUFF
+
+// Convert four packed four-channel buffers like argbargbargbargb... into the
+// split channels aaaaa ... rrrr ... gggg .... bbbbb ......
+static WEBP_INLINE void VP8L32bToPlanar_SSE41(__m128i* const in0,
+                                              __m128i* const in1,
+                                              __m128i* const in2,
+                                              __m128i* const in3) {
+  // aaaarrrrggggbbbb
+  const __m128i shuff0 =
+      _mm_set_epi8(15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0);
+  const __m128i A0 = _mm_shuffle_epi8(*in0, shuff0);
+  const __m128i A1 = _mm_shuffle_epi8(*in1, shuff0);
+  const __m128i A2 = _mm_shuffle_epi8(*in2, shuff0);
+  const __m128i A3 = _mm_shuffle_epi8(*in3, shuff0);
+  // A0A1R0R1
+  // G0G1B0B1
+  // A2A3R2R3
+  // G0G1B0B1
+  const __m128i B0 = _mm_unpacklo_epi32(A0, A1);
+  const __m128i B1 = _mm_unpackhi_epi32(A0, A1);
+  const __m128i B2 = _mm_unpacklo_epi32(A2, A3);
+  const __m128i B3 = _mm_unpackhi_epi32(A2, A3);
+  *in3 = _mm_unpacklo_epi64(B0, B2);
+  *in2 = _mm_unpackhi_epi64(B0, B2);
+  *in1 = _mm_unpacklo_epi64(B1, B3);
+  *in0 = _mm_unpackhi_epi64(B1, B3);
+}
+
+#endif  // WEBP_USE_SSE41
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // WEBP_DSP_COMMON_SSE41_H_

src/dsp/cost.c

@@ -377,13 +377,9 @@ VP8SetResidualCoeffsFunc VP8SetResidualCoeffs;
 extern void VP8EncDspCostInitMIPS32(void);
 extern void VP8EncDspCostInitMIPSdspR2(void);
 extern void VP8EncDspCostInitSSE2(void);
+extern void VP8EncDspCostInitNEON(void);
 
-static volatile VP8CPUInfo cost_last_cpuinfo_used =
-    (VP8CPUInfo)&cost_last_cpuinfo_used;
-
-WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspCostInit(void) {
-  if (cost_last_cpuinfo_used == VP8GetCPUInfo) return;
-
+WEBP_DSP_INIT_FUNC(VP8EncDspCostInit) {
   VP8GetResidualCost = GetResidualCost_C;
   VP8SetResidualCoeffs = SetResidualCoeffs_C;
 
@@ -403,10 +399,13 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspCostInit(void) {
     if (VP8GetCPUInfo(kSSE2)) {
       VP8EncDspCostInitSSE2();
     }
+#endif
+#if defined(WEBP_USE_NEON)
+    if (VP8GetCPUInfo(kNEON)) {
+      VP8EncDspCostInitNEON();
+    }
 #endif
   }
-
-  cost_last_cpuinfo_used = VP8GetCPUInfo;
 }
 
 //------------------------------------------------------------------------------

src/dsp/cost_neon.c

@@ -0,0 +1,122 @@
+// Copyright 2018 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.
+// -----------------------------------------------------------------------------
+//
+// ARM NEON version of cost functions
+
+#include "src/dsp/dsp.h"
+
+#if defined(WEBP_USE_NEON)
+
+#include "src/dsp/neon.h"
+#include "src/enc/cost_enc.h"
+
+static const uint8_t position[16] = { 1, 2,  3,  4,  5,  6,  7,  8,
+                                      9, 10, 11, 12, 13, 14, 15, 16 };
+
+static void SetResidualCoeffs_NEON(const int16_t* const coeffs,
+                                   VP8Residual* const res) {
+  const int16x8_t minus_one = vdupq_n_s16(-1);
+  const int16x8_t coeffs_0 = vld1q_s16(coeffs);
+  const int16x8_t coeffs_1 = vld1q_s16(coeffs + 8);
+  const uint16x8_t eob_0 = vtstq_s16(coeffs_0, minus_one);
+  const uint16x8_t eob_1 = vtstq_s16(coeffs_1, minus_one);
+  const uint8x16_t eob = vcombine_u8(vqmovn_u16(eob_0), vqmovn_u16(eob_1));
+  const uint8x16_t masked = vandq_u8(eob, vld1q_u8(position));
+
+#ifdef __aarch64__
+  res->last = vmaxvq_u8(masked) - 1;
+#else
+  const uint8x8_t eob_8x8 = vmax_u8(vget_low_u8(masked), vget_high_u8(masked));
+  const uint16x8_t eob_16x8 = vmovl_u8(eob_8x8);
+  const uint16x4_t eob_16x4 =
+      vmax_u16(vget_low_u16(eob_16x8), vget_high_u16(eob_16x8));
+  const uint32x4_t eob_32x4 = vmovl_u16(eob_16x4);
+  uint32x2_t eob_32x2 =
+      vmax_u32(vget_low_u32(eob_32x4), vget_high_u32(eob_32x4));
+  eob_32x2 = vpmax_u32(eob_32x2, eob_32x2);
+
+  vst1_lane_s32(&res->last, vreinterpret_s32_u32(eob_32x2), 0);
+  --res->last;
+#endif  // __aarch64__
+
+  res->coeffs = coeffs;
+}
+
+static int GetResidualCost_NEON(int ctx0, const VP8Residual* const res) {
+  uint8_t levels[16], ctxs[16];
+  uint16_t abs_levels[16];
+  int n = res->first;
+  // should be prob[VP8EncBands[n]], but it's equivalent for n=0 or 1
+  const int p0 = res->prob[n][ctx0][0];
+  CostArrayPtr const costs = res->costs;
+  const uint16_t* t = costs[n][ctx0];
+  // bit_cost(1, p0) is already incorporated in t[] tables, but only if ctx != 0
+  // (as required by the syntax). For ctx0 == 0, we need to add it here or it'll
+  // be missing during the loop.
+  int cost = (ctx0 == 0) ? VP8BitCost(1, p0) : 0;
+
+  if (res->last < 0) {
+    return VP8BitCost(0, p0);
+  }
+
+  {   // precompute clamped levels and contexts, packed to 8b.
+    const uint8x16_t kCst2 = vdupq_n_u8(2);
+    const uint8x16_t kCst67 = vdupq_n_u8(MAX_VARIABLE_LEVEL);
+    const int16x8_t c0 = vld1q_s16(res->coeffs);
+    const int16x8_t c1 = vld1q_s16(res->coeffs + 8);
+    const uint16x8_t E0 = vreinterpretq_u16_s16(vabsq_s16(c0));
+    const uint16x8_t E1 = vreinterpretq_u16_s16(vabsq_s16(c1));
+    const uint8x16_t F = vcombine_u8(vqmovn_u16(E0), vqmovn_u16(E1));
+    const uint8x16_t G = vminq_u8(F, kCst2);   // context = 0,1,2
+    const uint8x16_t H = vminq_u8(F, kCst67);  // clamp_level in [0..67]
+
+    vst1q_u8(ctxs, G);
+    vst1q_u8(levels, H);
+
+    vst1q_u16(abs_levels, E0);
+    vst1q_u16(abs_levels + 8, E1);
+  }
+  for (; n < res->last; ++n) {
+    const int ctx = ctxs[n];
+    const int level = levels[n];
+    const int flevel = abs_levels[n];   // full level
+    cost += VP8LevelFixedCosts[flevel] + t[level];  // simplified VP8LevelCost()
+    t = costs[n + 1][ctx];
+  }
+  // Last coefficient is always non-zero
+  {
+    const int level = levels[n];
+    const int flevel = abs_levels[n];
+    assert(flevel != 0);
+    cost += VP8LevelFixedCosts[flevel] + t[level];
+    if (n < 15) {
+      const int b = VP8EncBands[n + 1];
+      const int ctx = ctxs[n];
+      const int last_p0 = res->prob[b][ctx][0];
+      cost += VP8BitCost(0, last_p0);
+    }
+  }
+  return cost;
+}
+
+//------------------------------------------------------------------------------
+// Entry point
+
+extern void VP8EncDspCostInitNEON(void);
+
+WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspCostInitNEON(void) {
+  VP8SetResidualCoeffs = SetResidualCoeffs_NEON;
+  VP8GetResidualCost = GetResidualCost_NEON;
+}
+
+#else  // !WEBP_USE_NEON
+
+WEBP_DSP_INIT_STUB(VP8EncDspCostInitNEON)
+
+#endif  // WEBP_USE_NEON

src/dsp/cpu.c

@@ -173,8 +173,8 @@ static int AndroidCPUInfo(CPUFeature feature) {
   const AndroidCpuFamily cpu_family = android_getCpuFamily();
   const uint64_t cpu_features = android_getCpuFeatures();
   if (feature == kNEON) {
-    return (cpu_family == ANDROID_CPU_FAMILY_ARM &&
-            0 != (cpu_features & ANDROID_CPU_ARM_FEATURE_NEON));
+    return cpu_family == ANDROID_CPU_FAMILY_ARM &&
+           (cpu_features & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
   }
   return 0;
 }

src/dsp/dec.c

@@ -741,12 +741,7 @@ extern void VP8DspInitMIPS32(void);
 extern void VP8DspInitMIPSdspR2(void);
 extern void VP8DspInitMSA(void);
 
-static volatile VP8CPUInfo dec_last_cpuinfo_used =
-    (VP8CPUInfo)&dec_last_cpuinfo_used;
-
-WEBP_TSAN_IGNORE_FUNCTION void VP8DspInit(void) {
-  if (dec_last_cpuinfo_used == VP8GetCPUInfo) return;
-
+WEBP_DSP_INIT_FUNC(VP8DspInit) {
   VP8InitClipTables();
 
 #if !WEBP_NEON_OMIT_C_CODE
@@ -889,6 +884,4 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8DspInit(void) {
   assert(VP8PredChroma8[5] != NULL);
   assert(VP8PredChroma8[6] != NULL);
   assert(VP8DitherCombine8x8 != NULL);
-
-  dec_last_cpuinfo_used = VP8GetCPUInfo;
 }

src/dsp/dec_neon.c

@@ -1361,7 +1361,8 @@ 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(L | (K << 8) | (J << 16) | (I << 24));
+  const uint64x1_t LKJI____ =
+      vcreate_u64((uint64_t)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));
@@ -1427,10 +1428,16 @@ static WEBP_INLINE void DC8_NEON(uint8_t* dst, int do_top, int do_left) {
 
   if (do_top) {
     const uint8x8_t A = vld1_u8(dst - BPS);  // top row
+#if defined(__aarch64__)
+    const uint16x8_t B = vmovl_u8(A);
+    const uint16_t p2 = vaddvq_u16(B);
+    sum_top = vdupq_n_u16(p2);
+#else
     const uint16x4_t p0 = vpaddl_u8(A);  // cascading summation of the top
     const uint16x4_t p1 = vpadd_u16(p0, p0);
     const uint16x4_t p2 = vpadd_u16(p1, p1);
     sum_top = vcombine_u16(p2, p2);
+#endif
   }
 
   if (do_left) {

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(0x80);
+  const __m128i sign_bit = _mm_set1_epi8((char)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(thresh);
+  const __m128i m_thresh = _mm_set1_epi8((char)thresh);
   const __m128i t1 = MM_ABS(*p1, *q1);        // abs(p1 - q1)
-  const __m128i kFE = _mm_set1_epi8(0xFE);
+  const __m128i kFE = _mm_set1_epi8((char)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(0x80);
+  const __m128i sign_bit = _mm_set1_epi8((char)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(0x80);
+  const __m128i sign_bit = _mm_set1_epi8((char)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(0x80);
+  const __m128i sign_bit = _mm_set1_epi8((char)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, I | (X << 8), 0);
+  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(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

@@ -76,10 +76,6 @@ extern "C" {
 #define WEBP_USE_SSE41
 #endif
 
-#if defined(__AVX2__) || defined(WEBP_HAVE_AVX2)
-#define WEBP_USE_AVX2
-#endif
-
 // 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__) || \
@@ -141,6 +137,42 @@ extern "C" {
 #endif
 #endif
 
+#if defined(WEBP_USE_THREAD) && !defined(_WIN32)
+#include <pthread.h>  // NOLINT
+
+#define WEBP_DSP_INIT(func) do {                                    \
+  static volatile VP8CPUInfo func ## _last_cpuinfo_used =           \
+      (VP8CPUInfo)&func ## _last_cpuinfo_used;                      \
+  static pthread_mutex_t func ## _lock = PTHREAD_MUTEX_INITIALIZER; \
+  if (pthread_mutex_lock(&func ## _lock)) break;                    \
+  if (func ## _last_cpuinfo_used != VP8GetCPUInfo) func();          \
+  func ## _last_cpuinfo_used = VP8GetCPUInfo;                       \
+  (void)pthread_mutex_unlock(&func ## _lock);                       \
+} while (0)
+#else  // !(defined(WEBP_USE_THREAD) && !defined(_WIN32))
+#define WEBP_DSP_INIT(func) do {                                    \
+  static volatile VP8CPUInfo func ## _last_cpuinfo_used =           \
+      (VP8CPUInfo)&func ## _last_cpuinfo_used;                      \
+  if (func ## _last_cpuinfo_used == VP8GetCPUInfo) break;           \
+  func();                                                           \
+  func ## _last_cpuinfo_used = VP8GetCPUInfo;                       \
+} while (0)
+#endif  // defined(WEBP_USE_THREAD) && !defined(_WIN32)
+
+// Defines an Init + helper function that control multiple initialization of
+// function pointers / tables.
+/* Usage:
+   WEBP_DSP_INIT_FUNC(InitFunc) {
+     ...function body
+   }
+*/
+#define WEBP_DSP_INIT_FUNC(name)                             \
+  static WEBP_TSAN_IGNORE_FUNCTION void name ## _body(void); \
+  WEBP_TSAN_IGNORE_FUNCTION void name(void) {                \
+    WEBP_DSP_INIT(name ## _body);                            \
+  }                                                          \
+  static WEBP_TSAN_IGNORE_FUNCTION void name ## _body(void)
+
 #define WEBP_UBSAN_IGNORE_UNDEF
 #define WEBP_UBSAN_IGNORE_UNSIGNED_OVERFLOW
 #if defined(__clang__) && defined(__has_attribute)
@@ -196,7 +228,7 @@ WEBP_EXTERN VP8CPUInfo VP8GetCPUInfo;
 // avoiding a compiler warning.
 #define WEBP_DSP_INIT_STUB(func) \
   extern void func(void); \
-  WEBP_TSAN_IGNORE_FUNCTION void func(void) {}
+  void func(void) {}
 
 //------------------------------------------------------------------------------
 // Encoding
@@ -643,4 +675,4 @@ void VP8FiltersInit(void);
 }    // extern "C"
 #endif
 
-#endif  /* WEBP_DSP_DSP_H_ */
+#endif  // WEBP_DSP_DSP_H_

src/dsp/enc.c

@@ -734,18 +734,12 @@ VP8BlockCopy VP8Copy16x8;
 
 extern void VP8EncDspInitSSE2(void);
 extern void VP8EncDspInitSSE41(void);
-extern void VP8EncDspInitAVX2(void);
 extern void VP8EncDspInitNEON(void);
 extern void VP8EncDspInitMIPS32(void);
 extern void VP8EncDspInitMIPSdspR2(void);
 extern void VP8EncDspInitMSA(void);
 
-static volatile VP8CPUInfo enc_last_cpuinfo_used =
-    (VP8CPUInfo)&enc_last_cpuinfo_used;
-
-WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspInit(void) {
-  if (enc_last_cpuinfo_used == VP8GetCPUInfo) return;
-
+WEBP_DSP_INIT_FUNC(VP8EncDspInit) {
   VP8DspInit();  // common inverse transforms
   InitTables();
 
@@ -789,11 +783,6 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspInit(void) {
 #endif
     }
 #endif
-#if defined(WEBP_USE_AVX2)
-    if (VP8GetCPUInfo(kAVX2)) {
-      VP8EncDspInitAVX2();
-    }
-#endif
 #if defined(WEBP_USE_MIPS32)
     if (VP8GetCPUInfo(kMIPS32)) {
       VP8EncDspInitMIPS32();
@@ -838,6 +827,4 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspInit(void) {
   assert(VP8EncQuantizeBlockWHT != NULL);
   assert(VP8Copy4x4 != NULL);
   assert(VP8Copy16x8 != NULL);
-
-  enc_last_cpuinfo_used = VP8GetCPUInfo;
 }

src/dsp/enc_avx2.c

@@ -1,21 +0,0 @@
-// Copyright 2014 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// AVX2 version of speed-critical encoding functions.
-
-#include "src/dsp/dsp.h"
-
-#if defined(WEBP_USE_AVX2)
-
-#endif  // WEBP_USE_AVX2
-
-//------------------------------------------------------------------------------
-// Entry point
-
-WEBP_DSP_INIT_STUB(VP8EncDspInitAVX2)

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, I | (X << 8), 0);
+  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(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] = src[i] + pred[i];
+    for (i = 0; i < length; ++i) dst[i] = (uint8_t)(src[i] + pred[i]);
   } else {
-    for (i = 0; i < length; ++i) dst[i] = src[i] - pred[i];
+    for (i = 0; i < length; ++i) dst[i] = (uint8_t)(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] = in[w] + (inverse ? pred : -pred);
+      out[w] = (uint8_t)(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] = pred + in[i];
+    out[i] = (uint8_t)(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] = prev[i] + in[i];
+    for (i = 0; i < width; ++i) out[i] = (uint8_t)(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 = in[i] + GradientPredictor_C(left, top, top_left);
+      left = (uint8_t)(in[i] + GradientPredictor_C(left, top, top_left));
       top_left = top;
       out[i] = left;
     }
@@ -238,12 +238,7 @@ extern void VP8FiltersInitMSA(void);
 extern void VP8FiltersInitNEON(void);
 extern void VP8FiltersInitSSE2(void);
 
-static volatile VP8CPUInfo filters_last_cpuinfo_used =
-    (VP8CPUInfo)&filters_last_cpuinfo_used;
-
-WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInit(void) {
-  if (filters_last_cpuinfo_used == VP8GetCPUInfo) return;
-
+WEBP_DSP_INIT_FUNC(VP8FiltersInit) {
   WebPUnfilters[WEBP_FILTER_NONE] = NULL;
 #if !WEBP_NEON_OMIT_C_CODE
   WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter_C;
@@ -289,6 +284,4 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInit(void) {
   assert(WebPFilters[WEBP_FILTER_HORIZONTAL] != NULL);
   assert(WebPFilters[WEBP_FILTER_VERTICAL] != NULL);
   assert(WebPFilters[WEBP_FILTER_GRADIENT] != NULL);
-
-  filters_last_cpuinfo_used = VP8GetCPUInfo;
 }

src/dsp/filters_sse2.c

@@ -163,7 +163,8 @@ static void GradientPredictDirect_SSE2(const uint8_t* const row,
     _mm_storel_epi64((__m128i*)(out + i), H);
   }
   for (; i < length; ++i) {
-    out[i] = row[i] - GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
+    const int delta = GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
+    out[i] = (uint8_t)(row[i] - delta);
   }
 }
 
@@ -188,7 +189,7 @@ static WEBP_INLINE void DoGradientFilter_SSE2(const uint8_t* in,
 
   // Filter line-by-line.
   while (row < last_row) {
-    out[0] = in[0] - in[-stride];
+    out[0] = (uint8_t)(in[0] - in[-stride]);
     GradientPredictDirect_SSE2(in + 1, in + 1 - stride, out + 1, width - 1);
     ++row;
     in += stride;
@@ -223,7 +224,7 @@ static void HorizontalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
                                     uint8_t* out, int width) {
   int i;
   __m128i last;
-  out[0] = in[0] + (prev == NULL ? 0 : prev[0]);
+  out[0] = (uint8_t)(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) {
@@ -238,7 +239,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] = in[i] + out[i - 1];
+  for (; i < width; ++i) out[i] = (uint8_t)(in[i] + out[i - 1]);
 }
 
 static void VerticalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
@@ -259,7 +260,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] = in[i] + prev[i];
+    for (; i < width; ++i) out[i] = (uint8_t)(in[i] + prev[i]);
   }
 }
 
@@ -296,7 +297,8 @@ static void GradientPredictInverse_SSE2(const uint8_t* const in,
       _mm_storel_epi64((__m128i*)&row[i], out);
     }
     for (; i < length; ++i) {
-      row[i] = in[i] + GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
+      const int delta = GradientPredictor_SSE2(row[i - 1], top[i], top[i - 1]);
+      row[i] = (uint8_t)(in[i] + delta);
     }
   }
 }
@@ -306,7 +308,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] = in[0] + prev[0];  // predict from above
+    out[0] = (uint8_t)(in[0] + prev[0]);  // predict from above
     GradientPredictInverse_SSE2(in + 1, prev + 1, out + 1, width - 1);
   }
 }

src/dsp/lossless.c

@@ -23,8 +23,6 @@
 #include "src/dsp/lossless.h"
 #include "src/dsp/lossless_common.h"
 
-#define MAX_DIFF_COST (1e30f)
-
 //------------------------------------------------------------------------------
 // Image transforms.
 
@@ -83,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__) && LOCAL_GCC_VERSION <= 0x409
+#if defined(__arm__) && defined(__GNUC__) && LOCAL_GCC_VERSION <= 0x409
 # define LOCAL_INLINE __attribute__ ((noinline))
 #else
 # define LOCAL_INLINE WEBP_INLINE
@@ -169,15 +167,20 @@ static uint32_t Predictor13_C(uint32_t left, const uint32_t* const top) {
   return pred;
 }
 
-GENERATE_PREDICTOR_ADD(Predictor0_C, PredictorAdd0_C)
+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);
+}
 static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
                             int num_pixels, uint32_t* out) {
   int i;
   uint32_t left = out[-1];
+  (void)upper;
   for (i = 0; i < num_pixels; ++i) {
     out[i] = left = VP8LAddPixels(in[i], left);
   }
-  (void)upper;
 }
 GENERATE_PREDICTOR_ADD(Predictor2_C, PredictorAdd2_C)
 GENERATE_PREDICTOR_ADD(Predictor3_C, PredictorAdd3_C)
@@ -272,14 +275,14 @@ void VP8LTransformColorInverse_C(const VP8LMultipliers* const m,
   int i;
   for (i = 0; i < num_pixels; ++i) {
     const uint32_t argb = src[i];
-    const uint32_t green = argb >> 8;
+    const int8_t green = (int8_t)(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_, new_red);
+    new_blue += ColorTransformDelta(m->red_to_blue_, (int8_t)new_red);
     new_blue &= 0xff;
     dst[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);
   }
@@ -577,9 +580,6 @@ extern void VP8LDspInitNEON(void);
 extern void VP8LDspInitMIPSdspR2(void);
 extern void VP8LDspInitMSA(void);
 
-static volatile VP8CPUInfo lossless_last_cpuinfo_used =
-    (VP8CPUInfo)&lossless_last_cpuinfo_used;
-
 #define COPY_PREDICTOR_ARRAY(IN, OUT) do {                \
   (OUT)[0] = IN##0_C;                                     \
   (OUT)[1] = IN##1_C;                                     \
@@ -599,9 +599,7 @@ static volatile VP8CPUInfo lossless_last_cpuinfo_used =
   (OUT)[15] = IN##0_C;                                    \
 } while (0);
 
-WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInit(void) {
-  if (lossless_last_cpuinfo_used == VP8GetCPUInfo) return;
-
+WEBP_DSP_INIT_FUNC(VP8LDspInit) {
   COPY_PREDICTOR_ARRAY(Predictor, VP8LPredictors)
   COPY_PREDICTOR_ARRAY(Predictor, VP8LPredictors_C)
   COPY_PREDICTOR_ARRAY(PredictorAdd, VP8LPredictorsAdd)
@@ -658,8 +656,6 @@ WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInit(void) {
   assert(VP8LConvertBGRAToRGB565 != NULL);
   assert(VP8LMapColor32b != NULL);
   assert(VP8LMapColor8b != NULL);
-
-  lossless_last_cpuinfo_used = VP8GetCPUInfo;
 }
 #undef COPY_PREDICTOR_ARRAY
 

src/dsp/lossless.h

@@ -25,10 +25,6 @@
 extern "C" {
 #endif
 
-#ifdef WEBP_EXPERIMENTAL_FEATURES
-#include "src/enc/delta_palettization_enc.h"
-#endif  // WEBP_EXPERIMENTAL_FEATURES
-
 //------------------------------------------------------------------------------
 // Decoding
 
@@ -167,7 +163,7 @@ extern VP8LCostCombinedFunc VP8LExtraCostCombined;
 extern VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy;
 
 typedef struct {        // small struct to hold counters
-  int counts[2];        // index: 0=zero steak, 1=non-zero streak
+  int counts[2];        // index: 0=zero streak, 1=non-zero streak
   int streaks[2][2];    // [zero/non-zero][streak<3 / streak>=3]
 } VP8LStreaks;
 
@@ -198,10 +194,14 @@ extern VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined;
 void VP8LBitsEntropyUnrefined(const uint32_t* const array, int n,
                               VP8LBitEntropy* const entropy);
 
-typedef void (*VP8LHistogramAddFunc)(const VP8LHistogram* const a,
+typedef void (*VP8LAddVectorFunc)(const uint32_t* a, const uint32_t* b,
+                                  uint32_t* out, int size);
+extern VP8LAddVectorFunc VP8LAddVector;
+typedef void (*VP8LAddVectorEqFunc)(const uint32_t* a, uint32_t* out, int size);
+extern VP8LAddVectorEqFunc VP8LAddVectorEq;
+void VP8LHistogramAdd(const VP8LHistogram* const a,
                       const VP8LHistogram* const b,
                       VP8LHistogram* const out);
-extern VP8LHistogramAddFunc VP8LHistogramAdd;
 
 // -----------------------------------------------------------------------------
 // PrefixEncode()