Fix invalid incremental decoding check.

(cherry picked from commit 95ea5226c8)

Change-Id: I80c2165aa9fdf43077db155d2d00e0e99db73eab

.gitignore

@@ -22,7 +22,6 @@ Makefile.in
 examples/anim_diff
 examples/[cdv]webp
 examples/gif2webp
-examples/img2webp
 examples/webpmux
 src/webp/config.h*
 src/webp/stamp-h1
@@ -35,7 +34,3 @@ src/webp/stamp-h1
 CMakeCache.txt
 CMakeFiles/
 cmake_install.cmake
-.gradle
-/build
-extras/get_disto
-extras/webp_quality

.mailmap

@@ -1,8 +1,7 @@
-Johann Koenig <johann.koenig@duck.com>
-Johann Koenig <johann.koenig@duck.com> <johannkoenig@google.com>
+<johann.koenig@duck.com> <johannkoenig@google.com>
 Mikołaj Zalewski <mikolajz@google.com>
 Pascal Massimino <pascal.massimino@gmail.com>
-Pascal Massimino <pascal.massimino@gmail.com> <skal@google.com>
+<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,17 +1,13 @@
 Contributors:
-- Aidan O'Loan (aidanol at gmail dot com)
-- Alan Browning (browning at google dot com)
 - Charles Munger (clm 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 Koenig (johann dot koenig at duck dot com)
+- Johann (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)
@@ -21,7 +17,6 @@ Contributors:
 - Mislav Bradac (mislavm at google dot com)
 - Nico Weber (thakis at chromium dot org)
 - Noel Chromium (noel at chromium dot org)
-- 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)
 - Paweł Hajdan, Jr (phajdan dot jr at chromium dot org)
@@ -38,6 +33,4 @@ 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

@@ -11,39 +11,27 @@ ifeq ($(APP_OPTIM),release)
   endif
 endif
 
-# mips32 fails to build with clang from r14b
-# https://bugs.chromium.org/p/webp/issues/detail?id=343
-ifeq ($(findstring clang,$(NDK_TOOLCHAIN_VERSION)),clang)
-  ifeq ($(TARGET_ARCH),mips)
-    clang_version := $(shell $(TARGET_CC) --version)
-    ifneq ($(findstring clang version 3,$(clang_version)),)
-      WEBP_CFLAGS += -no-integrated-as
-    endif
-  endif
-endif
-
 ifneq ($(findstring armeabi-v7a, $(TARGET_ARCH_ABI)),)
   # Setting LOCAL_ARM_NEON will enable -mfpu=neon which may cause illegal
   # instructions to be generated for armv7a code. Instead target the neon code
   # specifically.
   NEON := c.neon
   USE_CPUFEATURES := yes
-  WEBP_CFLAGS += -DHAVE_CPU_FEATURES_H
 else
   NEON := c
 endif
 
 dec_srcs := \
-    src/dec/alpha_dec.c \
-    src/dec/buffer_dec.c \
-    src/dec/frame_dec.c \
-    src/dec/idec_dec.c \
-    src/dec/io_dec.c \
-    src/dec/quant_dec.c \
-    src/dec/tree_dec.c \
-    src/dec/vp8_dec.c \
-    src/dec/vp8l_dec.c \
-    src/dec/webp_dec.c \
+    src/dec/alpha.c \
+    src/dec/buffer.c \
+    src/dec/frame.c \
+    src/dec/idec.c \
+    src/dec/io.c \
+    src/dec/quant.c \
+    src/dec/tree.c \
+    src/dec/vp8.c \
+    src/dec/vp8l.c \
+    src/dec/webp.c \
 
 demux_srcs := \
     src/demux/anim_decode.c \
@@ -52,9 +40,11 @@ demux_srcs := \
 dsp_dec_srcs := \
     src/dsp/alpha_processing.c \
     src/dsp/alpha_processing_mips_dsp_r2.c \
-    src/dsp/alpha_processing_neon.$(NEON) \
     src/dsp/alpha_processing_sse2.c \
     src/dsp/alpha_processing_sse41.c \
+    src/dsp/argb.c \
+    src/dsp/argb_mips_dsp_r2.c \
+    src/dsp/argb_sse2.c \
     src/dsp/cpu.c \
     src/dsp/dec.c \
     src/dsp/dec_clip_tables.c \
@@ -66,80 +56,67 @@ dsp_dec_srcs := \
     src/dsp/dec_sse41.c \
     src/dsp/filters.c \
     src/dsp/filters_mips_dsp_r2.c \
-    src/dsp/filters_msa.c \
-    src/dsp/filters_neon.$(NEON) \
     src/dsp/filters_sse2.c \
     src/dsp/lossless.c \
     src/dsp/lossless_mips_dsp_r2.c \
-    src/dsp/lossless_msa.c \
     src/dsp/lossless_neon.$(NEON) \
     src/dsp/lossless_sse2.c \
     src/dsp/rescaler.c \
     src/dsp/rescaler_mips32.c \
     src/dsp/rescaler_mips_dsp_r2.c \
-    src/dsp/rescaler_msa.c \
     src/dsp/rescaler_neon.$(NEON) \
     src/dsp/rescaler_sse2.c \
     src/dsp/upsampling.c \
     src/dsp/upsampling_mips_dsp_r2.c \
-    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 \
     src/dsp/enc_neon.$(NEON) \
     src/dsp/enc_sse2.c \
     src/dsp/enc_sse41.c \
     src/dsp/lossless_enc.c \
     src/dsp/lossless_enc_mips32.c \
     src/dsp/lossless_enc_mips_dsp_r2.c \
-    src/dsp/lossless_enc_msa.c \
     src/dsp/lossless_enc_neon.$(NEON) \
     src/dsp/lossless_enc_sse2.c \
     src/dsp/lossless_enc_sse41.c \
-    src/dsp/ssim.c \
-    src/dsp/ssim_sse2.c \
 
 enc_srcs := \
-    src/enc/alpha_enc.c \
-    src/enc/analysis_enc.c \
-    src/enc/backward_references_cost_enc.c \
-    src/enc/backward_references_enc.c \
-    src/enc/config_enc.c \
-    src/enc/cost_enc.c \
-    src/enc/filter_enc.c \
-    src/enc/frame_enc.c \
-    src/enc/histogram_enc.c \
-    src/enc/iterator_enc.c \
-    src/enc/near_lossless_enc.c \
-    src/enc/picture_enc.c \
-    src/enc/picture_csp_enc.c \
-    src/enc/picture_psnr_enc.c \
-    src/enc/picture_rescale_enc.c \
-    src/enc/picture_tools_enc.c \
-    src/enc/predictor_enc.c \
-    src/enc/quant_enc.c \
-    src/enc/syntax_enc.c \
-    src/enc/token_enc.c \
-    src/enc/tree_enc.c \
-    src/enc/vp8l_enc.c \
-    src/enc/webp_enc.c \
+    src/enc/alpha.c \
+    src/enc/analysis.c \
+    src/enc/backward_references.c \
+    src/enc/config.c \
+    src/enc/cost.c \
+    src/enc/delta_palettization.c \
+    src/enc/filter.c \
+    src/enc/frame.c \
+    src/enc/histogram.c \
+    src/enc/iterator.c \
+    src/enc/near_lossless.c \
+    src/enc/picture.c \
+    src/enc/picture_csp.c \
+    src/enc/picture_psnr.c \
+    src/enc/picture_rescale.c \
+    src/enc/picture_tools.c \
+    src/enc/quant.c \
+    src/enc/syntax.c \
+    src/enc/token.c \
+    src/enc/tree.c \
+    src/enc/vp8l.c \
+    src/enc/webpenc.c \
 
 mux_srcs := \
     src/mux/anim_encode.c \
@@ -148,20 +125,20 @@ mux_srcs := \
     src/mux/muxread.c \
 
 utils_dec_srcs := \
-    src/utils/bit_reader_utils.c \
-    src/utils/color_cache_utils.c \
-    src/utils/filters_utils.c \
-    src/utils/huffman_utils.c \
-    src/utils/quant_levels_dec_utils.c \
-    src/utils/random_utils.c \
-    src/utils/rescaler_utils.c \
-    src/utils/thread_utils.c \
+    src/utils/bit_reader.c \
+    src/utils/color_cache.c \
+    src/utils/filters.c \
+    src/utils/huffman.c \
+    src/utils/quant_levels_dec.c \
+    src/utils/random.c \
+    src/utils/rescaler.c \
+    src/utils/thread.c \
     src/utils/utils.c \
 
 utils_enc_srcs := \
-    src/utils/bit_writer_utils.c \
-    src/utils/huffman_encode_utils.c \
-    src/utils/quant_levels_utils.c \
+    src/utils/bit_writer.c \
+    src/utils/huffman_encode.c \
+    src/utils/quant_levels.c \
 
 ################################################################################
 # libwebpdecoder
@@ -174,7 +151,7 @@ LOCAL_SRC_FILES := \
     $(utils_dec_srcs) \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm
@@ -208,7 +185,7 @@ LOCAL_SRC_FILES := \
     $(utils_enc_srcs) \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm
@@ -231,7 +208,7 @@ include $(CLEAR_VARS)
 LOCAL_SRC_FILES := $(demux_srcs)
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm
@@ -254,7 +231,7 @@ include $(CLEAR_VARS)
 LOCAL_SRC_FILES := $(mux_srcs)
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)/src
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
 
 # prefer arm over thumb mode for performance gains
 LOCAL_ARM_MODE := arm
@@ -271,9 +248,7 @@ endif
 
 ################################################################################
 
-WEBP_SRC_PATH := $(LOCAL_PATH)
-include $(WEBP_SRC_PATH)/imageio/Android.mk
-include $(WEBP_SRC_PATH)/examples/Android.mk
+include $(LOCAL_PATH)/examples/Android.mk
 
 ifeq ($(USE_CPUFEATURES),yes)
   $(call import-module,android/cpufeatures)

CMakeLists.txt

@@ -1,672 +1,151 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 2.8.7)
 
-project(WebP C)
+project(libwebp C)
 
 # Options for coder / decoder executables.
-option(WEBP_ENABLE_SIMD "Enable any SIMD optimization." ON)
-option(WEBP_BUILD_ANIM_UTILS "Build animation utilities." ON)
-option(WEBP_BUILD_CWEBP "Build the cwebp command line tool." ON)
-option(WEBP_BUILD_DWEBP "Build the dwebp command line tool." ON)
-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_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()
+option(WEBP_BUILD_CWEBP "Build the cwebp command line tool." OFF)
+option(WEBP_BUILD_DWEBP "Build the dwebp command line tool." OFF)
+option(WEBP_EXPERIMENTAL_FEATURES "Build with experimental features." OFF)
+option(WEBP_FORCE_ALIGNED "Force aligned memory operations." OFF)
+option(WEBP_ENABLE_SWAP_16BIT_CSP "Enable byte swap for 16 bit colorspaces." OFF)
 
 set(WEBP_DEP_LIBRARIES)
 set(WEBP_DEP_INCLUDE_DIRS)
 
 if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release"
-      CACHE "Build type: Release, Debug, MinSizeRel or RelWithDebInfo" STRING
-      FORCE)
+  set(CMAKE_BUILD_TYPE "Release" CACHE
+    "Build type: Release, Debug or RelWithDebInfo" STRING FORCE
+  )
 endif()
 
-# Include dependencies.
-include(cmake/deps.cmake)
-include(GNUInstallDirs)
+include(cmake/config.h.cmake)
 
-# ##############################################################################
+################################################################################
 # Options.
 if(WEBP_ENABLE_SWAP_16BIT_CSP)
-  add_definitions(-DWEBP_SWAP_16BIT_CSP=1)
+  add_definitions(-DWEBP_SWAP_16BIT_CSP)
 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)
-  list(APPEND INSTALLED_LIBRARIES cpufeatures)
+    ${ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c
+  )
   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)
-  add_definitions(-DHAVE_CPU_FEATURES_H=1)
-  set(HAVE_CPU_FEATURES_H 1)
-else()
-  set(HAVE_CPU_FEATURES_H 0)
+    ${ANDROID_NDK}/sources/android/cpufeatures
+  )
 endif()
 
-function(configure_pkg_config FILE)
-  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${FILE}.in"
-                 "${CMAKE_CURRENT_BINARY_DIR}/${FILE}")
+################################################################################
+# WebP source files.
+# Read the Makefile.am to get the source files.
+set(WEBP_SRCS)
 
-  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)
+function(parse_Makefile_am FOLDER WEBP_SRCS)
   file(READ ${FOLDER}/Makefile.am MAKEFILE_AM)
-  string(REGEX MATCHALL
-               "${SRC_REGEX}_SOURCES[ ]*\\+?=[ ]+[0-9a-z\\._ ]*"
-               FILES_PER_LINE
-               ${MAKEFILE_AM})
-  set(SRCS ${${VAR}})
+  string(REGEX MATCHALL "_SOURCES \\+= [^\n]*"
+    FILES_PER_LINE ${MAKEFILE_AM}
+  )
+  set(SRCS ${WEBP_SRCS})
   foreach(FILES ${FILES_PER_LINE})
-    string(FIND ${FILES} "=" OFFSET)
-    math(EXPR OFFSET "${OFFSET} + 2")
-    string(SUBSTRING ${FILES}
-                     ${OFFSET}
-                     -1
-                     FILES)
-    if(FILES)
-      string(REGEX MATCHALL
-                   "[0-9a-z\\._]+"
-                   FILES
-                   ${FILES})
-      foreach(FILE ${FILES})
-        list(APPEND SRCS ${FOLDER}/${FILE})
-      endforeach()
-    endif()
+    string(SUBSTRING ${FILES} 12 -1 FILES)
+    string(REGEX MATCHALL "[0-9a-z\\._]+"
+      FILES ${FILES}
+    )
+    foreach(FILE ${FILES})
+      list(APPEND SRCS ${FOLDER}/${FILE})
+    endforeach()
   endforeach()
-  set(${VAR} ${SRCS} PARENT_SCOPE)
+  set(WEBP_SRCS ${SRCS} PARENT_SCOPE)
 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(${CMAKE_CURRENT_SOURCE_DIR}/src/dec "${WEBP_SRCS}")
+parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/src/demux "${WEBP_SRCS}")
+parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/src/dsp "${WEBP_SRCS}")
+parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/src/enc "${WEBP_SRCS}")
+parse_Makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/src/utils "${WEBP_SRCS}")
 
 # Remove the files specific to SIMD we don't use.
 foreach(FILE ${WEBP_SIMD_FILES_NOT_TO_INCLUDE})
-  list(REMOVE_ITEM WEBP_DSP_ENC_SRCS ${FILE})
-  list(REMOVE_ITEM WEBP_DSP_DEC_SRCS ${FILE})
+  list(REMOVE_ITEM WEBP_SRCS ${FILE})
 endforeach()
 
-# 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.
-  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-else()
-  add_definitions(-Wall)
-endif()
-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})
-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})
-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})
-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}
-                                   ${CMAKE_CURRENT_SOURCE_DIR})
-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}
-                                   ${CMAKE_CURRENT_SOURCE_DIR})
-add_library(webp
-            $<TARGET_OBJECTS:webpdecode>
-            $<TARGET_OBJECTS:webpdsp>
-            $<TARGET_OBJECTS:webpencode>
-            $<TARGET_OBJECTS:webputils>)
+# Build the library.
+add_definitions(-Wall)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src/ ${WEBP_DEP_INCLUDE_DIRS})
+add_library(webp ${WEBP_SRCS})
 target_link_libraries(webp ${WEBP_DEP_LIBRARIES})
-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)
-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}
-                           PUBLIC $<INSTALL_INTERFACE:include>)
-set_target_properties(
-  webpdemux
-  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
-               ${SOURCE_FILE})
-  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})
-parse_version(Makefile.am webpdecoder WEBP_DECODER_SOVERSION)
-set_target_properties(webpdecoder
-                      PROPERTIES VERSION
-                                 ${PACKAGE_VERSION}
-                                 SOVERSION
-                                 ${WEBP_DECODER_SOVERSION})
-parse_version(demux/Makefile.am webpdemux WEBP_DEMUX_SOVERSION)
-set_target_properties(webpdemux
-                      PROPERTIES VERSION
-                                 ${PACKAGE_VERSION}
-                                 SOVERSION
-                                 ${WEBP_DEMUX_SOVERSION})
-file(READ ${CMAKE_CURRENT_SOURCE_DIR}/configure.ac CONFIGURE_FILE)
-string(REGEX MATCH
-             "AC_INIT\\([^\n]*\\[[0-9\\.]+\\]"
-             TMP
-             ${CONFIGURE_FILE})
-string(REGEX MATCH
-             "[0-9\\.]+"
-             PROJECT_VERSION
-             ${TMP})
-
-# Define the libraries to install.
-list(APPEND INSTALLED_LIBRARIES webpdecoder webp webpdemux)
-
-# Deal with SIMD. Change the compile flags for SIMD files we use.
+# 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()
 
-if(WEBP_BUILD_GIF2WEBP AND NOT GIF_FOUND)
-  set(WEBP_BUILD_GIF2WEBP OFF)
-endif()
-
-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)
+if(WEBP_BUILD_CWEBP OR WEBP_BUILD_DWEBP)
   # 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})
-  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})
-  target_link_libraries(imageioutil webp)
+  set(exampleutil_SRCS
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/example_util.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/example_util.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/stopwatch.h)
+  add_library(exampleutil ${exampleutil_SRCS})
+  target_link_libraries(exampleutil webp ${WEBP_DEP_LIBRARIES})
+endif()
 
+if(WEBP_BUILD_CWEBP)
   # Image-decoding utility library.
-  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEDEC_SRCS"
-                    "imagedec_[^ ]*")
-  add_library(imagedec ${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"
-                    "imageenc_[^ ]*")
-  add_library(imageenc ${IMAGEENC_SRCS})
-  target_link_libraries(imageenc webp)
-
-  set_property(TARGET exampleutil
-                      imageioutil
-                      imagedec
-                      imageenc
-               PROPERTY INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/src
-                        ${CMAKE_CURRENT_BINARY_DIR}/src)
+  set(exampledec_SRCS
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/image_dec.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/image_dec.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/jpegdec.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/jpegdec.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/metadata.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/metadata.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/pngdec.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/pngdec.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/tiffdec.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/tiffdec.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/webpdec.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/webpdec.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/wicdec.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/wicdec.h)
+  add_library(exampledec ${exampledec_SRCS})
+  target_link_libraries(exampledec webp ${WEBP_DEP_LIBRARIES}
+    ${WEBP_DEP_IMG_LIBRARIES})
 endif()
 
 if(WEBP_BUILD_DWEBP)
   # dwebp
-  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "DWEBP_SRCS" "dwebp")
-  add_executable(dwebp ${DWEBP_SRCS})
-  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})
+  include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS})
+  add_executable(dwebp
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/dwebp.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/stopwatch.h
+  )
+  target_link_libraries(dwebp webp exampleutil ${WEBP_DEP_LIBRARIES}
+    ${WEBP_DEP_IMG_LIBRARIES}
+  )
 endif()
 
 if(WEBP_BUILD_CWEBP)
   # cwebp
-  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "CWEBP_SRCS" "cwebp")
-  add_executable(cwebp ${CWEBP_SRCS})
-  target_link_libraries(cwebp exampleutil imagedec webp)
-  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(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(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;")
-  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"
-                    "gif2webp")
-  add_executable(gif2webp ${GIF2WEBP_SRCS})
-  target_link_libraries(gif2webp
-                        exampleutil
-                        imageioutil
-                        webp
-                        libwebpmux
-                        ${WEBP_DEP_GIF_LIBRARIES})
-  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"
-                    "img2webp")
-  add_executable(img2webp ${IMG2WEBP_SRCS})
-  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})
+  add_executable(cwebp
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/cwebp.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/examples/stopwatch.h)
+  target_link_libraries(cwebp exampledec webp exampleutil
+    ${WEBP_DEP_LIBRARIES} ${WEBP_DEP_IMG_LIBRARIES}
+  )
 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
-                          imageioutil
-                          webp
-                          webpdemux)
-    target_include_directories(vwebp
-                               PRIVATE GLUT::GLUT
-                                       ${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"
-                    "webpinfo")
-  add_executable(webpinfo ${WEBPINFO_SRCS})
-  target_link_libraries(webpinfo exampleutil imageioutil)
-  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})
-  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)
-  target_link_libraries(webp_js webpdecoder SDL)
-  target_include_directories(webp_js PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-  set(WEBP_HAVE_SDL 1)
-  set_target_properties(
-    webp_js
-    PROPERTIES LINK_FLAGS
-               "-s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0 \
-       -s EXTRA_EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
-  set_target_properties(webp_js PROPERTIES OUTPUT_NAME webp)
-  target_compile_definitions(webp_js PUBLIC EMSCRIPTEN WEBP_HAVE_SDL)
-
-  # WASM version
-  add_executable(webp_wasm ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
-  target_link_libraries(webp_wasm webpdecoder SDL)
-  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(webpdspdecode PUBLIC EMSCRIPTEN)
-endif()
-
-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.
-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}/${PROJECT_NAME}/cmake/)
-install(EXPORT ${PROJECT_NAME}Targets
-        NAMESPACE ${PROJECT_NAME}::
-        DESTINATION ${ConfigPackageLocation})
-
-# Create the CMake version file.
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(
-  "${CMAKE_CURRENT_BINARY_DIR}/WebPConfigVersion.cmake"
-  VERSION ${PACKAGE_VERSION}
-  COMPATIBILITY AnyNewerVersion)
-
-# Create the Config file.
-include(CMakePackageConfigHelpers)
-configure_package_config_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/WebPConfig.cmake.in
-  ${CMAKE_CURRENT_BINARY_DIR}/WebPConfig.cmake
-  INSTALL_DESTINATION
-  ${ConfigPackageLocation})
-
-# Install the generated CMake files.
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/WebPConfigVersion.cmake"
-              "${CMAKE_CURRENT_BINARY_DIR}/WebPConfig.cmake"
-        DESTINATION ${ConfigPackageLocation})
-
-# Install the man pages.
-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"
-    "WEBPINFO")
-list(LENGTH MAN_PAGES MAN_PAGES_LENGTH)
-math(EXPR MAN_PAGES_RANGE "${MAN_PAGES_LENGTH} - 1")
-
-foreach(I_MAN RANGE ${MAN_PAGES_RANGE})
-  list(GET EXEC_BUILDS ${I_MAN} EXEC_BUILD)
-  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_MANDIR}/man1
-            COMPONENT doc)
-  endif()
-endforeach()

Makefile.am

@@ -1,9 +1,3 @@
 ACLOCAL_AMFLAGS = -I m4
-SUBDIRS = src imageio man
+SUBDIRS = src examples man
 EXTRA_DIST = COPYING autogen.sh
-
-if BUILD_EXTRAS
-  SUBDIRS += extras
-endif
-
-SUBDIRS += examples

Makefile.vc

@@ -29,7 +29,7 @@ PLATFORM_LDFLAGS = /SAFESEH
 NOLOGO     = /nologo
 CCNODBG    = cl.exe $(NOLOGO) /O2 /DNDEBUG
 CCDEBUG    = cl.exe $(NOLOGO) /Od /Gm /Zi /D_DEBUG /RTC1
-CFLAGS     = /I. /Isrc $(NOLOGO) /W3 /EHsc /c
+CFLAGS     = /Isrc $(NOLOGO) /W3 /EHsc /c
 CFLAGS     = $(CFLAGS) /DWIN32 /D_CRT_SECURE_NO_WARNINGS /DWIN32_LEAN_AND_MEAN
 LDFLAGS    = /LARGEADDRESSAWARE /MANIFEST /NXCOMPAT /DYNAMICBASE
 LDFLAGS    = $(LDFLAGS) $(PLATFORM_LDFLAGS)
@@ -37,8 +37,6 @@ LNKDLL     = link.exe /DLL $(NOLOGO)
 LNKEXE     = link.exe $(NOLOGO)
 LNKLIB     = lib.exe $(NOLOGO)
 MT         = mt.exe $(NOLOGO)
-RCNODBG    = rc.exe $(NOLOGO) /l"0x0409"  # 0x409 = U.S. English
-RCDEBUG    = $(RCNODBG) /D_DEBUG
 
 !IF "$(ARCH)" == "ARM"
 CFLAGS = $(CFLAGS) /DWINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP /DWEBP_USE_THREAD
@@ -53,6 +51,11 @@ 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"
@@ -79,8 +82,6 @@ OUTPUT_DIRS = $(DIRBIN) $(DIRINC) $(DIRLIB) \
               $(DIROBJ)\dsp \
               $(DIROBJ)\enc \
               $(DIROBJ)\examples \
-              $(DIROBJ)\extras \
-              $(DIROBJ)\imageio \
               $(DIROBJ)\mux \
               $(DIROBJ)\utils \
 
@@ -98,11 +99,9 @@ LIBWEBPMUX_BASENAME = $(LIBWEBPMUX_BASENAME)_debug
 LIBWEBPDEMUX_BASENAME = $(LIBWEBPDEMUX_BASENAME)_debug
 !ELSE IF "$(CFG)" == "release-dynamic"
 CC        = $(CCNODBG)
-RC        = $(RCNODBG)
 DLLBUILD  = TRUE
 !ELSE IF "$(CFG)" == "debug-dynamic"
 CC        = $(CCDEBUG)
-RC        = $(RCDEBUG)
 RTLIB     = $(RTLIBD)
 DLLBUILD  = TRUE
 LIBWEBPDECODER_BASENAME = $(LIBWEBPDECODER_BASENAME)_debug
@@ -129,16 +128,12 @@ 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>] [UNICODE=1] [<target>]
+!MESSAGE .          [OBJDIR=<path>] [RTLIBCFG=<rtlib>] [<target>]
 !MESSAGE
 !MESSAGE where <config> is one of:
 !MESSAGE -  release-static                - release static library
@@ -154,7 +149,6 @@ CFLAGS = $(CFLAGS) /D_UNICODE /DUNICODE
 !MESSAGE - all                            - build (de)mux-based targets for CFG
 !MESSAGE - gif2webp                       - requires libgif & >= VS2013
 !MESSAGE - anim_diff                      - requires libgif & >= VS2013
-!MESSAGE - anim_dump
 !MESSAGE
 !MESSAGE RTLIBCFG controls the runtime library linkage - 'static' or 'dynamic'.
 !MESSAGE   'legacy' will produce a Windows 2000 compatible library.
@@ -175,16 +169,16 @@ CFLAGS = $(CFLAGS) /D_UNICODE /DUNICODE
 #
 
 DEC_OBJS = \
-    $(DIROBJ)\dec\alpha_dec.obj \
-    $(DIROBJ)\dec\buffer_dec.obj \
-    $(DIROBJ)\dec\frame_dec.obj \
-    $(DIROBJ)\dec\idec_dec.obj \
-    $(DIROBJ)\dec\io_dec.obj \
-    $(DIROBJ)\dec\quant_dec.obj \
-    $(DIROBJ)\dec\tree_dec.obj \
-    $(DIROBJ)\dec\vp8_dec.obj \
-    $(DIROBJ)\dec\vp8l_dec.obj \
-    $(DIROBJ)\dec\webp_dec.obj \
+    $(DIROBJ)\dec\alpha.obj \
+    $(DIROBJ)\dec\buffer.obj \
+    $(DIROBJ)\dec\frame.obj \
+    $(DIROBJ)\dec\idec.obj \
+    $(DIROBJ)\dec\io.obj \
+    $(DIROBJ)\dec\quant.obj \
+    $(DIROBJ)\dec\tree.obj \
+    $(DIROBJ)\dec\vp8.obj \
+    $(DIROBJ)\dec\vp8l.obj \
+    $(DIROBJ)\dec\webp.obj \
 
 DEMUX_OBJS = \
     $(DIROBJ)\demux\anim_decode.obj \
@@ -193,7 +187,6 @@ DEMUX_OBJS = \
 DSP_DEC_OBJS = \
     $(DIROBJ)\dsp\alpha_processing.obj \
     $(DIROBJ)\dsp\alpha_processing_mips_dsp_r2.obj \
-    $(DIROBJ)\dsp\alpha_processing_neon.obj \
     $(DIROBJ)\dsp\alpha_processing_sse2.obj \
     $(DIROBJ)\dsp\alpha_processing_sse41.obj \
     $(DIROBJ)\dsp\cpu.obj \
@@ -207,71 +200,58 @@ DSP_DEC_OBJS = \
     $(DIROBJ)\dsp\dec_sse41.obj \
     $(DIROBJ)\dsp\filters.obj \
     $(DIROBJ)\dsp\filters_mips_dsp_r2.obj \
-    $(DIROBJ)\dsp\filters_msa.obj \
-    $(DIROBJ)\dsp\filters_neon.obj \
     $(DIROBJ)\dsp\filters_sse2.obj \
     $(DIROBJ)\dsp\lossless.obj \
     $(DIROBJ)\dsp\lossless_mips_dsp_r2.obj \
-    $(DIROBJ)\dsp\lossless_msa.obj \
     $(DIROBJ)\dsp\lossless_neon.obj \
     $(DIROBJ)\dsp\lossless_sse2.obj \
     $(DIROBJ)\dsp\rescaler.obj \
     $(DIROBJ)\dsp\rescaler_mips32.obj \
     $(DIROBJ)\dsp\rescaler_mips_dsp_r2.obj \
-    $(DIROBJ)\dsp\rescaler_msa.obj \
     $(DIROBJ)\dsp\rescaler_neon.obj \
     $(DIROBJ)\dsp\rescaler_sse2.obj \
     $(DIROBJ)\dsp\upsampling.obj \
     $(DIROBJ)\dsp\upsampling_mips_dsp_r2.obj \
-    $(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\argb.obj \
+    $(DIROBJ)\dsp\argb_mips_dsp_r2.obj \
+    $(DIROBJ)\dsp\argb_sse2.obj \
     $(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 \
     $(DIROBJ)\dsp\enc_neon.obj \
     $(DIROBJ)\dsp\enc_sse2.obj \
     $(DIROBJ)\dsp\enc_sse41.obj \
     $(DIROBJ)\dsp\lossless_enc.obj \
     $(DIROBJ)\dsp\lossless_enc_mips32.obj \
     $(DIROBJ)\dsp\lossless_enc_mips_dsp_r2.obj \
-    $(DIROBJ)\dsp\lossless_enc_msa.obj \
     $(DIROBJ)\dsp\lossless_enc_neon.obj \
     $(DIROBJ)\dsp\lossless_enc_sse2.obj \
     $(DIROBJ)\dsp\lossless_enc_sse41.obj \
-    $(DIROBJ)\dsp\ssim.obj \
-    $(DIROBJ)\dsp\ssim_sse2.obj \
 
 EX_ANIM_UTIL_OBJS = \
     $(DIROBJ)\examples\anim_util.obj \
 
-IMAGEIO_DEC_OBJS = \
-    $(DIROBJ)\imageio\image_dec.obj \
-    $(DIROBJ)\imageio\jpegdec.obj \
-    $(DIROBJ)\imageio\metadata.obj \
-    $(DIROBJ)\imageio\pngdec.obj \
-    $(DIROBJ)\imageio\pnmdec.obj \
-    $(DIROBJ)\imageio\tiffdec.obj \
-    $(DIROBJ)\imageio\webpdec.obj \
-    $(DIROBJ)\imageio\wicdec.obj \
-
-IMAGEIO_ENC_OBJS = \
-    $(DIROBJ)\imageio\image_enc.obj \
+EX_FORMAT_DEC_OBJS = \
+    $(DIROBJ)\examples\image_dec.obj \
+    $(DIROBJ)\examples\jpegdec.obj \
+    $(DIROBJ)\examples\metadata.obj \
+    $(DIROBJ)\examples\pngdec.obj \
+    $(DIROBJ)\examples\tiffdec.obj \
+    $(DIROBJ)\examples\webpdec.obj \
+    $(DIROBJ)\examples\wicdec.obj \
 
 EX_GIF_DEC_OBJS = \
     $(DIROBJ)\examples\gifdec.obj \
@@ -280,36 +260,28 @@ EX_UTIL_OBJS = \
     $(DIROBJ)\examples\example_util.obj \
 
 ENC_OBJS = \
-    $(DIROBJ)\enc\alpha_enc.obj \
-    $(DIROBJ)\enc\analysis_enc.obj \
-    $(DIROBJ)\enc\backward_references_cost_enc.obj \
-    $(DIROBJ)\enc\backward_references_enc.obj \
-    $(DIROBJ)\enc\config_enc.obj \
-    $(DIROBJ)\enc\cost_enc.obj \
-    $(DIROBJ)\enc\filter_enc.obj \
-    $(DIROBJ)\enc\frame_enc.obj \
-    $(DIROBJ)\enc\histogram_enc.obj \
-    $(DIROBJ)\enc\iterator_enc.obj \
-    $(DIROBJ)\enc\near_lossless_enc.obj \
-    $(DIROBJ)\enc\picture_enc.obj \
-    $(DIROBJ)\enc\picture_csp_enc.obj \
-    $(DIROBJ)\enc\picture_psnr_enc.obj \
-    $(DIROBJ)\enc\picture_rescale_enc.obj \
-    $(DIROBJ)\enc\picture_tools_enc.obj \
-    $(DIROBJ)\enc\predictor_enc.obj \
-    $(DIROBJ)\enc\quant_enc.obj \
-    $(DIROBJ)\enc\syntax_enc.obj \
-    $(DIROBJ)\enc\token_enc.obj \
-    $(DIROBJ)\enc\tree_enc.obj \
-    $(DIROBJ)\enc\vp8l_enc.obj \
-    $(DIROBJ)\enc\webp_enc.obj \
-
-EXTRAS_OBJS = \
-    $(DIROBJ)\extras\extras.obj \
-    $(DIROBJ)\extras\quality_estimate.obj \
-
-IMAGEIO_UTIL_OBJS = \
-    $(DIROBJ)\imageio\imageio_util.obj \
+    $(DIROBJ)\enc\alpha.obj \
+    $(DIROBJ)\enc\analysis.obj \
+    $(DIROBJ)\enc\backward_references.obj \
+    $(DIROBJ)\enc\config.obj \
+    $(DIROBJ)\enc\cost.obj \
+    $(DIROBJ)\enc\delta_palettization.obj \
+    $(DIROBJ)\enc\filter.obj \
+    $(DIROBJ)\enc\frame.obj \
+    $(DIROBJ)\enc\histogram.obj \
+    $(DIROBJ)\enc\iterator.obj \
+    $(DIROBJ)\enc\near_lossless.obj \
+    $(DIROBJ)\enc\picture.obj \
+    $(DIROBJ)\enc\picture_csp.obj \
+    $(DIROBJ)\enc\picture_psnr.obj \
+    $(DIROBJ)\enc\picture_rescale.obj \
+    $(DIROBJ)\enc\picture_tools.obj \
+    $(DIROBJ)\enc\quant.obj \
+    $(DIROBJ)\enc\syntax.obj \
+    $(DIROBJ)\enc\token.obj \
+    $(DIROBJ)\enc\tree.obj \
+    $(DIROBJ)\enc\vp8l.obj \
+    $(DIROBJ)\enc\webpenc.obj \
 
 MUX_OBJS = \
     $(DIROBJ)\mux\anim_encode.obj \
@@ -318,20 +290,20 @@ MUX_OBJS = \
     $(DIROBJ)\mux\muxread.obj \
 
 UTILS_DEC_OBJS = \
-    $(DIROBJ)\utils\bit_reader_utils.obj \
-    $(DIROBJ)\utils\color_cache_utils.obj \
-    $(DIROBJ)\utils\filters_utils.obj \
-    $(DIROBJ)\utils\huffman_utils.obj \
-    $(DIROBJ)\utils\quant_levels_dec_utils.obj \
-    $(DIROBJ)\utils\rescaler_utils.obj \
-    $(DIROBJ)\utils\random_utils.obj \
-    $(DIROBJ)\utils\thread_utils.obj \
+    $(DIROBJ)\utils\bit_reader.obj \
+    $(DIROBJ)\utils\color_cache.obj \
+    $(DIROBJ)\utils\filters.obj \
+    $(DIROBJ)\utils\huffman.obj \
+    $(DIROBJ)\utils\quant_levels_dec.obj \
+    $(DIROBJ)\utils\rescaler.obj \
+    $(DIROBJ)\utils\random.obj \
+    $(DIROBJ)\utils\thread.obj \
     $(DIROBJ)\utils\utils.obj \
 
 UTILS_ENC_OBJS = \
-    $(DIROBJ)\utils\bit_writer_utils.obj \
-    $(DIROBJ)\utils\huffman_encode_utils.obj \
-    $(DIROBJ)\utils\quant_levels_utils.obj \
+    $(DIROBJ)\utils\bit_writer.obj \
+    $(DIROBJ)\utils\huffman_encode.obj \
+    $(DIROBJ)\utils\quant_levels.obj \
 
 LIBWEBPDECODER_OBJS = $(DEC_OBJS) $(DSP_DEC_OBJS) $(UTILS_DEC_OBJS)
 LIBWEBP_OBJS = $(LIBWEBPDECODER_OBJS) $(ENC_OBJS) $(DSP_ENC_OBJS) \
@@ -345,10 +317,7 @@ ex: $(OUT_LIBS)
 all: ex
 !ELSE
 OUT_EXAMPLES = $(DIRBIN)\cwebp.exe $(DIRBIN)\dwebp.exe
-EXTRA_EXAMPLES = $(DIRBIN)\vwebp.exe $(DIRBIN)\webpmux.exe \
-                 $(DIRBIN)\img2webp.exe $(DIRBIN)\get_disto.exe \
-                 $(DIRBIN)\webp_quality.exe $(DIRBIN)\vwebp_sdl.exe \
-                 $(DIRBIN)\webpinfo.exe
+EXTRA_EXAMPLES = $(DIRBIN)\vwebp.exe $(DIRBIN)\webpmux.exe
 
 ex: $(OUT_LIBS) $(OUT_EXAMPLES)
 all: ex $(EXTRA_EXAMPLES)
@@ -356,52 +325,27 @@ all: ex $(EXTRA_EXAMPLES)
 # C99 support which is only available from VS2013 onward.
 gif2webp: $(DIRBIN)\gif2webp.exe
 anim_diff: $(DIRBIN)\anim_diff.exe
-anim_dump: $(DIRBIN)\anim_dump.exe
 
 $(DIRBIN)\anim_diff.exe: $(DIROBJ)\examples\anim_diff.obj $(EX_ANIM_UTIL_OBJS)
-$(DIRBIN)\anim_diff.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)
+$(DIRBIN)\anim_diff.exe: $(EX_UTIL_OBJS)
 $(DIRBIN)\anim_diff.exe: $(EX_GIF_DEC_OBJS) $(LIBWEBPDEMUX) $(LIBWEBP)
-$(DIRBIN)\anim_dump.exe: $(DIROBJ)\examples\anim_dump.obj $(EX_ANIM_UTIL_OBJS)
-$(DIRBIN)\anim_dump.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)
-$(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)\cwebp.exe: $(DIROBJ)\examples\cwebp.obj $(EX_FORMAT_DEC_OBJS)
+$(DIRBIN)\dwebp.exe: $(DIROBJ)\examples\dwebp.obj
 $(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)
-$(DIRBIN)\vwebp.exe: $(DIROBJ)\examples\vwebp.obj $(EX_UTIL_OBJS)
-$(DIRBIN)\vwebp.exe: $(IMAGEIO_UTIL_OBJS) $(LIBWEBPDEMUX) $(LIBWEBP)
-$(DIRBIN)\vwebp_sdl.exe: $(DIROBJ)\extras\vwebp_sdl.obj
-$(DIRBIN)\vwebp_sdl.exe: $(DIROBJ)\extras\webp_to_sdl.obj
-$(DIRBIN)\vwebp_sdl.exe: $(IMAGEIO_UTIL_OBJS) $(LIBWEBP)
+$(DIRBIN)\gif2webp.exe: $(EX_UTIL_OBJS) $(LIBWEBPMUX) $(LIBWEBP)
+$(DIRBIN)\vwebp.exe: $(DIROBJ)\examples\vwebp.obj
+$(DIRBIN)\vwebp.exe: $(EX_UTIL_OBJS) $(LIBWEBPDEMUX) $(LIBWEBP)
 $(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)
-$(DIRBIN)\img2webp.exe: $(LIBWEBPDEMUX) $(LIBWEBP)
-$(DIRBIN)\get_disto.exe: $(DIROBJ)\extras\get_disto.obj
-$(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)\webpinfo.exe: $(DIROBJ)\examples\webpinfo.obj
-$(DIRBIN)\webpinfo.exe: $(IMAGEIO_DEC_OBJS)
-$(DIRBIN)\webpinfo.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)
-$(DIRBIN)\webpinfo.exe: $(LIBWEBPDEMUX) $(LIBWEBP)
-
+$(DIRBIN)\webpmux.exe: $(EX_UTIL_OBJS) $(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)
+$(EX_UTIL_OBJS) $(EX_FORMAT_DEC_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)
@@ -416,17 +360,8 @@ $(LIBWEBP_OBJS) $(LIBWEBPMUX_OBJS) $(LIBWEBPDEMUX_OBJS): \
 {$(DIROBJ)}.c{$(DIROBJ)}.obj:
 	$(CC) $(CFLAGS) /Fd$(LIBWEBP_PDBNAME) /Fo$@  $<
 
-{src}.rc{$(DIROBJ)}.res:
-	$(RC) /fo$@ $<
-{src\demux}.rc{$(DIROBJ)\demux}.res:
-	$(RC) /fo$@ $<
-{src\mux}.rc{$(DIROBJ)\mux}.res:
-	$(RC) /fo$@ $<
-
-$(LIBWEBP): $(DIROBJ)\$(LIBWEBP_BASENAME:_debug=).res
-$(LIBWEBPDECODER): $(DIROBJ)\$(LIBWEBPDECODER_BASENAME:_debug=).res
-$(LIBWEBPMUX): $(LIBWEBP) $(DIROBJ)\mux\$(LIBWEBPMUX_BASENAME:_debug=).res
-$(LIBWEBPDEMUX): $(LIBWEBP) $(DIROBJ)\demux\$(LIBWEBPDEMUX_BASENAME:_debug=).res
+$(LIBWEBPMUX): $(LIBWEBP)
+$(LIBWEBPDEMUX): $(LIBWEBP)
 
 $(LIBWEBPDECODER) $(LIBWEBP) $(LIBWEBPMUX) $(LIBWEBPDEMUX):
 	$(LNKDLL) /out:$(DIRBIN)\$(@B:_dll=.dll) /implib:$@ $(LFLAGS) $**
@@ -447,18 +382,18 @@ $(OUTPUT_DIRS):
 $(DIROBJ)\$(DLLINC):
 	@echo #ifndef WEBP_DLL_H_ > $@
 	@echo #define WEBP_DLL_H_ >> $@
-	@echo #define WEBP_EXTERN __declspec(dllexport) >> $@
+	@echo #define WEBP_EXTERN(type) __declspec(dllexport) type >> $@
 	@echo #endif  /* WEBP_DLL_H_ */ >> $@
 
 .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
-$(DIROBJ)\examples\anim_dump.obj: examples\anim_dump.c
-	$(CC) $(CFLAGS) /DWEBP_HAVE_GIF /Fd$(LIBWEBP_PDBNAME) \
-	  /Fo$(DIROBJ)\examples\ examples\$(@B).c
 $(DIROBJ)\examples\anim_util.obj: examples\anim_util.c
 	$(CC) $(CFLAGS) /DWEBP_HAVE_GIF /Fd$(LIBWEBP_PDBNAME) \
 	  /Fo$(DIROBJ)\examples\ examples\$(@B).c
@@ -471,10 +406,6 @@ $(DIROBJ)\examples\gifdec.obj: examples\gifdec.c
 # Batch rules
 {examples}.c{$(DIROBJ)\examples}.obj::
 	$(CC) $(CFLAGS) /Fd$(DIROBJ)\examples\ /Fo$(DIROBJ)\examples\ $<
-{extras}.c{$(DIROBJ)\extras}.obj::
-	$(CC) $(CFLAGS) /Fd$(DIROBJ)\extras\ /Fo$(DIROBJ)\extras\ $<
-{imageio}.c{$(DIROBJ)\imageio}.obj::
-	$(CC) $(CFLAGS) /Fd$(DIROBJ)\imageio\ /Fo$(DIROBJ)\imageio\ $<
 {src\dec}.c{$(DIROBJ)\dec}.obj::
 	$(CC) $(CFLAGS) /Fd$(LIBWEBP_PDBNAME) /Fo$(DIROBJ)\dec\ $<
 {src\demux}.c{$(DIROBJ)\demux}.obj::
@@ -488,18 +419,9 @@ $(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:$@ $** $(LNKLIBS)
-	$(MT) -manifest $@.manifest -outputresource:$@;1
-	del $@.manifest
-
-{$(DIROBJ)\extras}.obj{$(DIRBIN)}.exe:
-	$(LNKEXE) $(LDFLAGS) /OUT:$@ $** $(LNKLIBS)
+	$(LNKEXE) $(LDFLAGS) /OUT:$@ $** \
+	    ole32.lib windowscodecs.lib shlwapi.lib
 	$(MT) -manifest $@.manifest -outputresource:$@;1
 	del $@.manifest
 

NEWS

@@ -1,73 +1,3 @@
-- 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
-    (-m 6 -q 100)
-  * ARM performance improvements with clang (15-20% w/ndk r15c, issue #339)
-  * webp-js: emscripten/webassembly based javascript decoder
-  * miscellaneous bug & build fixes (issue #329, #332, #343, #353, #360, #361,
-    #363)
-  Tool updates / additions:
-    added webpinfo - prints file format information (issue #330)
-    gif2webp - loop behavior modified to match Chrome M63+ (crbug.com/649264);
-               '-loop_compatibility' can be used for the old behavior
-
-- 1/26/2017: version 0.6.0
-  * lossless performance and compression improvements
-  * miscellaneous performance improvements (SSE2, NEON, MSA)
-  * webpmux gained a -duration option allowing for frame timing modification
-  * new img2webp utility allowing a sequence of images to be converted to
-    animated webp
-  * API changes:
-    - libwebp:
-      WebPPictureSharpARGBToYUVA
-      WebPPlaneDistortion
-    - libwebpmux / gif2webp:
-      WebPAnimEncoderOptions: kmax <= 0 now disables keyframes, kmax == 1
-                              forces all keyframes. See mux.h and the gif2webp
-                              manpage for details.
-
 - 12/13/2016: version 0.5.2
   This is a binary compatible release.
   This release covers CVE-2016-8888 and CVE-2016-9085.

README

@@ -4,7 +4,7 @@
           \__\__/\____/\_____/__/ ____  ___
                 / _/ /    \    \ /  _ \/ _/
                /  \_/   / /   \ \   __/  \__
-               \____/____/\_____/_____/____/v1.0.3
+               \____/____/\_____/_____/____/v0.5.2
 
 Description:
 ============
@@ -113,8 +113,8 @@ make install
 
 CMake:
 ------
-With CMake, you can compile libwebp, cwebp, dwebp, gif2web, img2webp, webpinfo
-and the JS bindings.
+The support for CMake is minimal: it only helps you compile libwebp, cwebp and
+dwebp.
 
 Prerequisites:
 A compiler (e.g., gcc with autotools) and CMake.
@@ -123,27 +123,18 @@ minimal build:
 $ sudo apt-get install build-essential cmake
 
 When building from git sources, you will need to run cmake to generate the
-makefiles.
+configure script.
 
 mkdir build && cd build && cmake ../
 make
 make install
 
-If you also want any of the executables, you will need to enable them through
-CMake, e.g.:
+If you also want cwebp or dwebp, you will need to enable them through CMake:
 
 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)
-
-which will define the CMake variables WebP_INCLUDE_DIRS and WebP_LIBRARIES.
-
 Gradle:
 -------
 The support for Gradle is minimal: it only helps you compile libwebp, cwebp and
@@ -250,7 +241,6 @@ Options:
   -sharpness <int> ....... filter sharpness (0:most .. 7:least sharp), default=0
   -strong ................ use strong filter instead of simple (default)
   -nostrong .............. use simple filter instead of strong
-  -sharp_yuv ............. use sharper (and slower) RGB->YUV conversion
   -partition_limit <int> . limit quality to fit the 512k limit on
                            the first partition (0=no degradation ... 100=full)
   -pass <int> ............ analysis pass number (1..10)
@@ -369,23 +359,6 @@ Use following options to convert into alternate image formats:
   -quiet ....... quiet mode, don't print anything
   -noasm ....... disable all assembly optimizations
 
-WebP file analysis tool:
-========================
-
-'webpinfo' can be used to print out the chunk level structure and bitstream
-header information of WebP files. It can also check if the files are of valid
-WebP format.
-
-Usage: webpinfo [options] in_files
-Note: there could be multiple input files;
-      options must come before input files.
-Options:
-  -version ........... Print version number and exit.
-  -quiet ............. Do not show chunk parsing information.
-  -diag .............. Show parsing error diagnosis.
-  -summary ........... Show chunk stats summary.
-  -bitstream_info .... Parse bitstream header.
-
 Visualization tool:
 ===================
 
@@ -404,16 +377,13 @@ 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
 
 Building:
@@ -442,41 +412,6 @@ $ make -f makefile.unix examples/vwebp
 > nmake /f Makefile.vc CFG=release-static \
     ../obj/x64/release-static/bin/vwebp.exe
 
-Animation creation tool:
-========================
-The utility 'img2webp' can turn a sequence of input images (PNG, JPEG, ...)
-into an animated WebP file. It offers fine control over duration, encoding
-modes, etc.
-
-Usage:
-
-  img2webp [file-level options] [image files...] [per-frame options...]
-
-File-level options (only used at the start of compression):
- -min_size ............ minimize size
- -loop <int> .......... loop count (default: 0, = infinite loop)
- -kmax <int> .......... maximum number of frame between key-frames
-                        (0=only keyframes)
- -kmin <int> .......... minimum number of frame between key-frames
-                        (0=disable key-frames altogether)
- -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)
- -lossless  ........... use lossless mode (default)
- -lossy ... ........... use lossy mode
- -q <float> ........... quality
- -m <int> ............. method to use
-
-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
@@ -502,8 +437,6 @@ Options:
   -metadata <string> ..... comma separated list of metadata to
                            copy from the input to the output if present
                            Valid values: all, none, icc, xmp (default)
-  -loop_compatibility .... use compatibility mode for Chrome
-                           version prior to M62 (inclusive)
   -mt .................... use multi-threading if available
 
   -version ............... print version number and exit
@@ -532,11 +465,6 @@ 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:
 ---------
@@ -597,7 +525,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 @@
           __   __  ____  ____  ____  __ __  _     __ __
          /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
          \       /   __/  _  \   __/      /  /  (_/  /__
-          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v1.0.3
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v0.3.2
 
 
 Description:
@@ -25,15 +25,12 @@ A list of options is available using the -help command line flag:
 > webpmux -help
 Usage: webpmux -get GET_OPTIONS INPUT -o OUTPUT
        webpmux -set SET_OPTIONS INPUT -o OUTPUT
-       webpmux -duration DURATION_OPTIONS [-duration ...]
-               INPUT -o OUTPUT
        webpmux -strip STRIP_OPTIONS INPUT -o OUTPUT
        webpmux -frame FRAME_OPTIONS [-frame...] [-loop LOOP_COUNT]
                [-bgcolor BACKGROUND_COLOR] -o OUTPUT
        webpmux -info INPUT
        webpmux [-h|-help]
        webpmux -version
-       webpmux argument_file_name
 
 GET_OPTIONS:
  Extract relevant data:
@@ -51,17 +48,6 @@ SET_OPTIONS:
              'file.exif' contains the EXIF metadata to be set
              'file.xmp' contains the XMP metadata to be set
 
-DURATION_OPTIONS:
- Set duration of selected frames:
-   duration            set duration for each frames
-   duration,frame      set duration of a particular frame
-   duration,start,end  set duration of frames in the
-                        interval [start,end])
-   where: 'duration' is the duration in milliseconds
-          'start' is the start frame index
-          'end' is the inclusive end frame index
-           The special 'end' value '0' means: last frame.
-
 STRIP_OPTIONS:
  Strip color profile/metadata:
    icc       strip ICC profile
@@ -93,9 +79,6 @@ 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:
 ===================
 
@@ -211,35 +194,6 @@ 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

@@ -1,80 +0,0 @@
-     __   __ ____ ____ ____     __  ____
-    /  \\/  \  _ \  _ \  _ \   (__)/  __\
-    \       /  __/ _  \  __/   _)  \_   \
-     \__\__/_____/____/_/     /____/____/
-
-Description:
-============
-
-This file describes the compilation of libwebp into a JavaScript decoder
-using Emscripten and CMake.
-
- - install the Emscripten SDK following the procedure described at:
-   https://kripken.github.io/emscripten-site/docs/getting_started/downloads.html
-   After installation, you should have some global variable positioned to the
-   location of the SDK. In particular, $EMSCRIPTEN should point to the
-   top-level directory containing Emscripten tools.
-
- - make sure the file $EMSCRIPTEN/cmake/Modules/Platform/Emscripten.cmake is
-   accessible. This is the toolchain file used by CMake to invoke Emscripten.
-   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:
-
- cd webp_js && \
- cmake -DWEBP_BUILD_WEBP_JS=ON \
-       -DEMSCRIPTEN_GENERATE_BITCODE_STATIC_LIBRARIES=1 \
-       -DCMAKE_TOOLCHAIN_FILE=$EMSCRIPTEN/cmake/Modules/Platform/Emscripten.cmake \
-       ../
-
- - compile webp.js using 'make'.
-
- - that's it! Upon completion, you should have the webp.js and
-   webp.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
-(see below for instructions).
-
-Demo HTML page:
-===============
-
-   The HTML page webp_js/index.html requires an HTTP server to serve the WebP
-   image example. It's easy to just use Python for that.
-
-cd webp_js && python -m SimpleHTTPServer 8080
-
-and then navigate to http://localhost:8080 in your favorite browser.
-
-
-Web-Assembly (WASM) version:
-============================
-
-  CMakeLists.txt is configured to build the WASM version when using
-  the option WEBP_BUILD_WEBP_JS=ON. The compilation step will assemble
-  the files 'webp_wasm.js', 'webp_wasm.wasm' in the webp_js/ directory.
-  See webp_js/index_wasm.html for a simple demo page using the WASM version
-  of the library.
-
-  You will need a fairly recent version of Emscripten (at least 1.37.8) and of
-  your WASM-enabled browser to run this version. Consider it very experimental!
-
-Caveat:
-=======
-
-  - First decoding using the library is usually slower, due to just-in-time
-    compilation.
-
-  - Some versions of llvm produce the following compile error when SSE2 is
-    enabled.
-
-"Unsupported:   %516 = bitcast <8 x i16> %481 to i128
- LLVM ERROR: BitCast Instruction not yet supported for integer types larger than 64 bits"
-
-    The corresponding Emscripten bug is at:
-    https://github.com/kripken/emscripten/issues/3788
-
-    Therefore, SSE2 optimization is currently disabled in CMakeLists.txt.

build.gradle

@@ -74,22 +74,12 @@ model {
           cCompiler.args "-frename-registers -s"
         }
       }
-      // mips32 fails to build with clang from r14b
-      // https://bugs.chromium.org/p/webp/issues/detail?id=343
-      if (toolChain in Clang) {
-        if (getTargetPlatform() == "mips") {
-          cCompiler.args "-no-integrated-as"
-        }
-      }
       // Check for NEON usage.
-      if (getTargetPlatform() == "arm") {
+      if (getTargetPlatform() == "arm" || getTargetPlatform() == "arm64") {
         NEON = "c.neon"
-        cCompiler.define "HAVE_CPU_FEATURES_H"
       } else {
         NEON = "c"
       }
-
-      cCompiler.args "-I" + file(".").absolutePath
     }
     // Link to pthread for shared libraries.
     withType(SharedLibraryBinarySpec) {
@@ -106,22 +96,24 @@ model {
         c {
           source {
             srcDir "src/dec"
-            include "alpha_dec.c"
-            include "buffer_dec.c"
-            include "frame_dec.c"
-            include "idec_dec.c"
-            include "io_dec.c"
-            include "quant_dec.c"
-            include "tree_dec.c"
-            include "vp8_dec.c"
-            include "vp8l_dec.c"
-            include "webp_dec.c"
+            include "alpha.c"
+            include "buffer.c"
+            include "frame.c"
+            include "idec.c"
+            include "io.c"
+            include "quant.c"
+            include "tree.c"
+            include "vp8.c"
+            include "vp8l.c"
+            include "webp.c"
             srcDir "src/dsp"
             include "alpha_processing.c"
             include "alpha_processing_mips_dsp_r2.c"
-            include "alpha_processing_neon.$NEON"
             include "alpha_processing_sse2.c"
             include "alpha_processing_sse41.c"
+            include "argb.c"
+            include "argb_mips_dsp_r2.c"
+            include "argb_sse2.c"
             include "cpu.c"
             include "dec.c"
             include "dec_clip_tables.c"
@@ -133,92 +125,80 @@ model {
             include "dec_sse41.c"
             include "filters.c"
             include "filters_mips_dsp_r2.c"
-            include "filters_msa.c"
-            include "filters_neon.$NEON"
             include "filters_sse2.c"
             include "lossless.c"
             include "lossless_mips_dsp_r2.c"
-            include "lossless_msa.c"
             include "lossless_neon.$NEON"
             include "lossless_sse2.c"
             include "rescaler.c"
             include "rescaler_mips32.c"
             include "rescaler_mips_dsp_r2.c"
-            include "rescaler_msa.c"
             include "rescaler_neon.$NEON"
             include "rescaler_sse2.c"
             include "upsampling.c"
             include "upsampling_mips_dsp_r2.c"
-            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"
-            include "filters_utils.c"
-            include "huffman_utils.c"
-            include "quant_levels_dec_utils.c"
-            include "random_utils.c"
-            include "rescaler_utils.c"
-            include "thread_utils.c"
+            include "ans.c"
+            include "bit_reader.c"
+            include "color_cache.c"
+            include "filters.c"
+            include "huffman.c"
+            include "quant_levels_dec.c"
+            include "random.c"
+            include "rescaler.c"
+            include "thread.c"
             include "utils.c"
             srcDir "src/dsp"
             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"
             include "enc_neon.$NEON"
             include "enc_sse2.c"
             include "enc_sse41.c"
             include "lossless_enc.c"
             include "lossless_enc_mips32.c"
             include "lossless_enc_mips_dsp_r2.c"
-            include "lossless_enc_msa.c"
             include "lossless_enc_neon.$NEON"
             include "lossless_enc_sse2.c"
             include "lossless_enc_sse41.c"
-            include "ssim.c"
-            include "ssim_sse2.c"
             srcDir "src/enc"
-            include "alpha_enc.c"
-            include "analysis_enc.c"
-            include "backward_references_cost_enc.c"
-            include "backward_references_enc.c"
-            include "config_enc.c"
-            include "cost_enc.c"
-            include "filter_enc.c"
-            include "frame_enc.c"
-            include "histogram_enc.c"
-            include "iterator_enc.c"
-            include "near_lossless_enc.c"
-            include "picture_enc.c"
-            include "picture_csp_enc.c"
-            include "picture_psnr_enc.c"
-            include "picture_rescale_enc.c"
-            include "picture_tools_enc.c"
-            include "predictor_enc.c"
-            include "quant_enc.c"
-            include "syntax_enc.c"
-            include "token_enc.c"
-            include "tree_enc.c"
-            include "vp8l_enc.c"
-            include "webp_enc.c"
+            include "alpha.c"
+            include "analysis.c"
+            include "backward_references.c"
+            include "config.c"
+            include "cost.c"
+            include "delta_palettization.c"
+            include "filter.c"
+            include "frame.c"
+            include "histogram.c"
+            include "iterator.c"
+            include "near_lossless.c"
+            include "picture.c"
+            include "picture_csp.c"
+            include "picture_psnr.c"
+            include "picture_rescale.c"
+            include "picture_tools.c"
+            include "quant.c"
+            include "syntax.c"
+            include "token.c"
+            include "tree.c"
+            include "vp8l.c"
+            include "webpenc.c"
             srcDir "src/utils"
-            include "bit_writer_utils.c"
-            include "huffman_encode_utils.c"
-            include "quant_levels_utils.c"
+            include "bit_writer.c"
+            include "huffman_encode.c"
+            include "quant_levels.c"
           }
           exportedHeaders {
             srcDir "src"
@@ -270,7 +250,7 @@ model {
       }
     }
 
-    imageio_util(NativeLibrarySpec) {
+    example_dec(NativeLibrarySpec) {
       binaries {
         all {
           lib library: "webp", linkage: "static"
@@ -279,60 +259,22 @@ model {
       sources {
         c {
           source {
-            srcDir "./imageio"
-            include "imageio_util.c"
-          }
-        }
-      }
-    }
-
-    imagedec(NativeLibrarySpec) {
-      binaries {
-        all {
-          lib library: "webpdemux", linkage: "static"
-          lib library: "webp", linkage: "static"
-        }
-      }
-      sources {
-        c {
-          source {
-            srcDir "./imageio"
+            srcDir "./examples"
             include "image_dec.c"
             include "jpegdec.c"
             include "metadata.c"
             include "pngdec.c"
-            include "pnmdec.c"
             include "tiffdec.c"
             include "webpdec.c"
           }
         }
       }
     }
-
-    imageenc(NativeLibrarySpec) {
-      binaries {
-        all {
-          lib library: "webp", linkage: "static"
-          lib library: "imageio_util", linkage: "static"
-        }
-      }
-      sources {
-        c {
-          source {
-            srcDir "./imageio"
-            include "image_enc.c"
-          }
-        }
-      }
-    }
-
     cwebp(NativeExecutableSpec) {
       binaries {
         all {
           lib library: "example_util", linkage: "static"
-          lib library: "imagedec", linkage: "static"
-          lib library: "imageio_util", linkage: "static"
-          lib library: "webpdemux", linkage: "static"
+          lib library: "example_dec", linkage: "static"
           lib library: "webp", linkage: "static"
         }
       }
@@ -350,10 +292,6 @@ model {
       binaries {
         all {
           lib library: "example_util", linkage: "static"
-          lib library: "imagedec", linkage: "static"
-          lib library: "imageenc", linkage: "static"
-          lib library: "imageio_util", linkage: "static"
-          lib library: "webpdemux", linkage: "static"
           lib library: "webp"
         }
       }
@@ -371,7 +309,6 @@ model {
       binaries {
         all {
           lib library: "example_util", linkage: "static"
-          lib library: "imageio_util", linkage: "static"
           lib library: "webpmux", linkage: "static"
           lib library: "webp"
         }
@@ -385,45 +322,6 @@ model {
         }
       }
     }
-
-    img2webp_example(NativeExecutableSpec) {
-      binaries {
-        all {
-          lib library: "example_util", linkage: "static"
-          lib library: "imagedec", linkage: "static"
-          lib library: "imageio_util", linkage: "static"
-          lib library: "webpmux", linkage: "static"
-          lib library: "webpdemux", linkage: "static"
-          lib library: "webp"
-        }
-      }
-      sources {
-        c {
-          source {
-            srcDir "./examples"
-            include "img2webp.c"
-          }
-        }
-      }
-    }
-
-    webpinfo_example(NativeExecutableSpec) {
-      binaries {
-        all {
-          lib library: "example_util", linkage: "static"
-          lib library: "imageio_util", linkage: "static"
-          lib library: "webp"
-        }
-      }
-      sources {
-        c {
-          source {
-            srcDir "./examples"
-            include "webpinfo.c"
-          }
-        }
-      }
-    }
   }
   tasks {
     // Task to test all possible configurations.

cmake/WebPConfig.cmake.in

@@ -1,11 +0,0 @@
-set(WebP_VERSION @PROJECT_VERSION@)
-set(WEBP_VERSION ${WebP_VERSION})
-
-@PACKAGE_INIT@
-
-include ("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
-
-set(WebP_INCLUDE_DIRS "webp")
-set(WEBP_INCLUDE_DIRS ${WebP_INCLUDE_DIRS})
-set(WebP_LIBRARIES "@INSTALLED_LIBRARIES@")
-set(WEBP_LIBRARIES "${WebP_LIBRARIES}")

cmake/config.h.cmake

@@ -1,27 +1,33 @@
 # 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)
@@ -34,7 +40,8 @@ if(Threads_FOUND)
           int attr = ${PTHREAD_TEST};
           return attr;
         }
-      " ${PTHREAD_TEST})
+      " ${PTHREAD_TEST}
+    )
   endforeach()
   list(APPEND WEBP_DEP_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
 endif()
@@ -44,69 +51,30 @@ 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})
+# 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})
 
-# 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)
+# Find the standard C math library.
+find_library(MATH_LIBRARY NAMES m)
+if(MATH_LIBRARY)
+  list(APPEND WEBP_DEP_LIBRARIES ${MATH_LIBRARY})
 endif()
 
 # Find the standard image libraries.
 set(WEBP_DEP_IMG_LIBRARIES)
 set(WEBP_DEP_IMG_INCLUDE_DIRS)
-foreach(I_LIB PNG JPEG TIFF)
+foreach(I_LIB PNG JPEG TIFF GIF)
   find_package(${I_LIB})
   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_DIRS})
   endif()
 endforeach()
-if(WEBP_DEP_IMG_INCLUDE_DIRS)
-  list(REMOVE_DUPLICATES WEBP_DEP_IMG_INCLUDE_DIRS)
-endif()
 
-# GIF detection, gifdec isn't part of the imageio lib.
-include(CMakePushCheckState)
-set(WEBP_DEP_GIF_LIBRARIES)
-set(WEBP_DEP_GIF_INCLUDE_DIRS)
-find_package(GIF)
-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.
-  cmake_push_check_state()
-  set(CMAKE_REQUIRED_LIBRARIES ${GIF_LIBRARIES})
-  set(CMAKE_REQUIRED_INCLUDES ${GIF_INCLUDE_DIR})
-  check_c_source_compiles("
-      #include <gif_lib.h>
-      int main(void) {
-        (void)DGifOpenFileHandle;
-        return 0;
-      }
-      " GIF_COMPILES)
-  cmake_pop_check_state()
-  if(GIF_COMPILES)
-    list(APPEND WEBP_DEP_GIF_LIBRARIES ${GIF_LIBRARIES})
-    list(APPEND WEBP_DEP_GIF_INCLUDE_DIRS ${GIF_INCLUDE_DIR})
-  else()
-    unset(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)
@@ -128,32 +96,25 @@ 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()
 
@@ -168,3 +129,13 @@ strip_bracket(PACKAGE_URL)
 set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
 set(PACKAGE_TARNAME ${PACKAGE_NAME})
 set(VERSION ${PACKAGE_VERSION})
+
+## Generate the config.h header.
+configure_file(${CMAKE_CURRENT_LIST_DIR}/config.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/include/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}/include
+  ${CMAKE_CURRENT_BINARY_DIR}/include/webp
+)

cmake/config.h.in

@@ -13,9 +13,6 @@
 /* Set to 1 if __builtin_bswap64 is available */
 #cmakedefine HAVE_BUILTIN_BSWAP64 1
 
-/* Define to 1 if you have the <cpu-features.h> header file. */
-#cmakedefine HAVE_CPU_FEATURES_H 1
-
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #cmakedefine HAVE_DLFCN_H 1
 
@@ -103,6 +100,15 @@
 /* Version number of package */
 #cmakedefine VERSION "@VERSION@"
 
+/* Enable experimental code */
+#cmakedefine WEBP_EXPERIMENTAL_FEATURES 1
+
+/* Define to 1 to force aligned memory operations */
+#cmakedefine WEBP_FORCE_ALIGNED 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
 
@@ -112,19 +118,9 @@
 /* Set to 1 if JPEG library is installed */
 #cmakedefine WEBP_HAVE_JPEG 1
 
-/* Set to 1 if NEON is supported */
-#cmakedefine WEBP_HAVE_NEON
-
-/* Set to 1 if runtime detection of NEON is enabled */
-/* TODO: handle properly in CMake */
-#cmakedefine WEBP_HAVE_NEON_RTCD
-
 /* Set to 1 if PNG library is installed */
 #cmakedefine WEBP_HAVE_PNG 1
 
-/* Set to 1 if SDL library is installed */
-#cmakedefine WEBP_HAVE_SDL 1
-
 /* Set to 1 if SSE2 is supported */
 #cmakedefine WEBP_HAVE_SSE2 1
 
@@ -134,9 +130,6 @@
 /* Set to 1 if TIFF library is installed */
 #cmakedefine WEBP_HAVE_TIFF 1
 
-/* Enable near lossless encoding */
-#cmakedefine WEBP_NEAR_LOSSLESS 1
-
 /* Undefine this to disable thread support. */
 #cmakedefine WEBP_USE_THREAD 1
 

cmake/cpu.cmake

@@ -1,15 +1,7 @@
-# Check for SIMD extensions.
-include(CMakePushCheckState)
+## Check for SIMD extensions.
 
-function(webp_check_compiler_flag WEBP_SIMD_FLAG ENABLE_SIMD)
-  if(NOT ENABLE_SIMD)
-    message(STATUS "Disabling ${WEBP_SIMD_FLAG} optimization.")
-    set(WEBP_HAVE_${WEBP_SIMD_FLAG} 0 PARENT_SCOPE)
-    return()
-  endif()
+function(webp_check_compiler_flag WEBP_SIMD_FLAG)
   unset(WEBP_HAVE_FLAG_${WEBP_SIMD_FLAG} CACHE)
-  cmake_push_check_state()
-  set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR})
   check_c_source_compiles("
       #include \"${CMAKE_CURRENT_LIST_DIR}/../src/dsp/dsp.h\"
       int main(void) {
@@ -18,8 +10,8 @@ function(webp_check_compiler_flag WEBP_SIMD_FLAG ENABLE_SIMD)
         #endif
         return 0;
       }
-    " WEBP_HAVE_FLAG_${WEBP_SIMD_FLAG})
-  cmake_pop_check_state()
+    " WEBP_HAVE_FLAG_${WEBP_SIMD_FLAG}
+  )
   if(WEBP_HAVE_FLAG_${WEBP_SIMD_FLAG})
     set(WEBP_HAVE_${WEBP_SIMD_FLAG} 1 PARENT_SCOPE)
   else()
@@ -28,18 +20,16 @@ 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 "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")
+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")
 if(MSVC)
-  # MSVC does not have a SSE4 flag but AVX support implies SSE4 support.
-  set(SIMD_ENABLE_FLAGS "/arch:AVX;/arch:SSE2;;;;")
+  # MSVC does not have a SSE4 flag but AVX2 support implies
+  # SSE4 support.
+  set(SIMD_ENABLE_FLAGS "/arch:SSE2;/arch:AVX2;/arch:AVX2;;;;")
   set(SIMD_DISABLE_FLAGS)
 else()
-  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")
+  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")
 endif()
 
 set(WEBP_SIMD_FILES_TO_NOT_INCLUDE)
@@ -48,16 +38,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)
@@ -65,36 +55,25 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
   # First try with no extra flag added as the compiler might have default flags
   # (especially on Android).
   unset(WEBP_HAVE_${WEBP_SIMD_FLAG} CACHE)
-  cmake_push_check_state()
   set(CMAKE_REQUIRED_FLAGS)
-  webp_check_compiler_flag(${WEBP_SIMD_FLAG} ${WEBP_ENABLE_SIMD})
+  webp_check_compiler_flag(${WEBP_SIMD_FLAG})
   if(NOT WEBP_HAVE_${WEBP_SIMD_FLAG})
     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})
+    webp_check_compiler_flag(${WEBP_SIMD_FLAG})
   else()
-    if(MSVC)
-      list(GET SIMD_ENABLE_FLAGS ${I_SIMD} SIMD_COMPILE_FLAG)
-    else()
-      set(SIMD_COMPILE_FLAG " ")
-    endif()
+    set(SIMD_COMPILE_FLAG " ")
   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()
+      list(APPEND WEBP_SIMD_FLAGS_TO_INCLUDE ${SIMD_COMPILE_FLAG})
     endforeach()
   else()
     # Remove the file from the list.
@@ -108,29 +87,10 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
       if(SIMD_COMPILE_FLAG)
         unset(HAS_COMPILE_FLAG CACHE)
         check_c_compiler_flag(${SIMD_COMPILE_FLAG} HAS_COMPILE_FLAG)
-        if(HAS_COMPILE_FLAG)
-          # Do one more check for Clang to circumvent CMake issue 13194.
-          if(COMMAND check_compiler_flag_common_patterns)
-            # Only in CMake 3.0 and above.
-            check_compiler_flag_common_patterns(COMMON_PATTERNS)
-          else()
-            set(COMMON_PATTERNS)
-          endif()
-          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})
-          if(NOT FLAG_${SIMD_COMPILE_FLAG})
-            unset(HAS_COMPILE_FLAG CACHE)
-          endif()
-        endif()
         if(HAS_COMPILE_FLAG)
           set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SIMD_COMPILE_FLAG}")
         endif()
       endif()
     endif()
   endif()
-  cmake_pop_check_state()
 endforeach()

codereview.settings

@@ -1,4 +0,0 @@
-# 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], [1.0.3],
+AC_INIT([libwebp], [0.5.2],
         [https://bugs.chromium.org/p/webp],,
         [http://developers.google.com/speed/webp])
 AC_CANONICAL_HOST
@@ -67,7 +67,6 @@ AC_DEFUN([TEST_AND_ADD_CFLAGS],
           CFLAGS="$SAVED_CFLAGS"])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-fvisibility=hidden])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wall])
-TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wconstant-conversion])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wdeclaration-after-statement])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wextra])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wfloat-conversion])
@@ -76,10 +75,8 @@ TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wformat -Wformat-security])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wmissing-declarations])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wmissing-prototypes])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wold-style-definition])
-TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wparentheses-equality])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wshadow])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wshorten-64-to-32])
-TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wundef])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunreachable-code])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused-but-set-variable])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused])
@@ -122,6 +119,31 @@ 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
@@ -219,13 +241,9 @@ AS_IF([test "x$enable_neon" != "xno"], [
           NEON_FLAGS=""],
           [AC_DEFINE(WEBP_HAVE_NEON_RTCD, [1],
                      [Set to 1 if runtime detection of NEON is enabled])])])
-
-      case "$host_os" in
-        *android*) AC_CHECK_HEADERS([cpu-features.h]) ;;
-      esac
-      ;;
-  esac
-  AC_SUBST([NEON_FLAGS])])
+        ;;
+    esac
+    AC_SUBST([NEON_FLAGS])])
 
 dnl === CLEAR_LIBVARS([var_pfx])
 dnl ===   Clears <var_pfx>_{INCLUDES,LIBS}.
@@ -322,8 +340,6 @@ 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
 
@@ -412,67 +428,6 @@ AS_IF([test "x$enable_gl" != "xno"], [
 ])
 AM_CONDITIONAL([BUILD_VWEBP], [test "$build_vwebp" = "yes"])
 
-dnl === check for SDL support ===
-
-AC_ARG_ENABLE([sdl],
-              AS_HELP_STRING([--disable-sdl],
-                             [Disable detection of SDL support
-                              @<:@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.h], [sdl_header="SDL.h"],
-                  [AC_MSG_WARN(SDL library not available - no sdl.h)])])
-  if test x"$sdl_header" != "xno"; then
-    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]
-      )
-      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 x"$sdl_support" = "xyes"; then
-    build_vwebp_sdl=yes
-  else
-    AC_MSG_WARN(Optional SDL library not found)
-  fi
-])
-
-AM_CONDITIONAL([BUILD_VWEBP_SDL], [test "$build_vwebp_sdl" = "yes"])
-
 dnl === check for PNG support ===
 
 AC_ARG_ENABLE([png], AS_HELP_STRING([--disable-png],
@@ -590,7 +545,7 @@ AS_IF([test "x$enable_gif" != "xno"], [
 
   if test "$gif_support" = "yes" -a \
           "$enable_libwebpdemux" = "yes"; then
-    build_anim_diff=yes
+    build_animdiff=yes
   fi
 
   if test "$gif_support" = "yes" -a \
@@ -598,19 +553,9 @@ AS_IF([test "x$enable_gif" != "xno"], [
     build_gif2webp=yes
   fi
 ])
-AM_CONDITIONAL([BUILD_ANIMDIFF], [test "${build_anim_diff}" = "yes"])
+AM_CONDITIONAL([BUILD_ANIMDIFF], [test "${build_animdiff}" = "yes"])
 AM_CONDITIONAL([BUILD_GIF2WEBP], [test "${build_gif2webp}" = "yes"])
 
-if test "$enable_libwebpdemux" = "yes" -a "$enable_libwebpmux" = "yes"; then
-  build_img2webp=yes
-fi
-AM_CONDITIONAL([BUILD_IMG2WEBP], [test "${build_img2webp}" = "yes"])
-
-if test "$enable_libwebpmux" = "yes"; then
-  build_webpinfo=yes
-fi
-AM_CONDITIONAL([BUILD_WEBPINFO], [test "${build_webpinfo}" = "yes"])
-
 dnl === check for WIC support ===
 
 AC_ARG_ENABLE([wic],
@@ -663,7 +608,20 @@ if test "$enable_wic" = "yes"; then
 fi
 esac
 
-dnl === If --enable-swap-16bit-csp is defined, add -DWEBP_SWAP_16BIT_CSP=1
+dnl === If --enable-aligned is defined, define WEBP_FORCE_ALIGNED
+
+AC_MSG_CHECKING(if --enable-aligned option is specified)
+AC_ARG_ENABLE([aligned],
+              AS_HELP_STRING([--enable-aligned],
+                             [Force aligned memory operations in non-dsp code
+                              (may be slower)]))
+if test "$enable_aligned" = "yes"; then
+  AC_DEFINE(WEBP_FORCE_ALIGNED, [1],
+            [Define to 1 to force aligned memory operations])
+fi
+AC_MSG_RESULT(${enable_aligned-no})
+
+dnl === If --enable-swap-16bit-csp is defined, add -DWEBP_SWAP_16BIT_CSP
 
 USE_SWAP_16BIT_CSP=""
 AC_MSG_CHECKING(if --enable-swap-16bit-csp option is specified)
@@ -671,25 +629,23 @@ AC_ARG_ENABLE([swap-16bit-csp],
               AS_HELP_STRING([--enable-swap-16bit-csp],
                              [Enable byte swap for 16 bit colorspaces]))
 if test "$enable_swap_16bit_csp" = "yes"; then
-  USE_SWAP_16BIT_CSP="-DWEBP_SWAP_16BIT_CSP=1"
+  USE_SWAP_16BIT_CSP="-DWEBP_SWAP_16BIT_CSP"
 fi
 AC_MSG_RESULT(${enable_swap_16bit_csp-no})
 AC_SUBST(USE_SWAP_16BIT_CSP)
 
-dnl === If --disable-near-lossless is defined, add -DWEBP_NEAR_LOSSLESS=0
+dnl === If --enable-experimental is defined, add -DWEBP_EXPERIMENTAL_FEATURES
 
-AC_DEFINE(WEBP_NEAR_LOSSLESS, [1], [Enable near lossless encoding])
-AC_MSG_CHECKING(if --disable-near-lossless option is specified)
-AC_ARG_ENABLE([near_lossless],
-              AS_HELP_STRING([--disable-near-lossless],
-                             [Disable near lossless encoding]),
-              [], [enable_near_lossless=yes])
-if test "$enable_near_lossless" = "no"; then
-  AC_DEFINE(WEBP_NEAR_LOSSLESS, [0], [Enable near lossless encoding])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
+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 === Check whether libwebpmux should be built
 AC_MSG_CHECKING(whether libwebpmux is to be built)
@@ -697,16 +653,15 @@ AC_ARG_ENABLE([libwebpmux],
               AS_HELP_STRING([--enable-libwebpmux],
                              [Build libwebpmux @<:@default=no@:>@]))
 AC_MSG_RESULT(${enable_libwebpmux-no})
-AM_CONDITIONAL([BUILD_MUX], [test "$enable_libwebpmux" = "yes"])
+AM_CONDITIONAL([WANT_MUX], [test "$enable_libwebpmux" = "yes"])
 
 dnl === Check whether libwebpdemux should be built
 AC_MSG_CHECKING(whether libwebpdemux is to be built)
 AC_ARG_ENABLE([libwebpdemux],
-              AS_HELP_STRING([--disable-libwebpdemux],
-                             [Disable libwebpdemux @<:@default=no@:>@]),
-              [], [enable_libwebpdemux=yes])
+              AS_HELP_STRING([--enable-libwebpdemux],
+                             [Build libwebpdemux @<:@default=no@:>@]))
 AC_MSG_RESULT(${enable_libwebpdemux-no})
-AM_CONDITIONAL([BUILD_DEMUX], [test "$enable_libwebpdemux" = "yes"])
+AM_CONDITIONAL([WANT_DEMUX], [test "$enable_libwebpdemux" = "yes"])
 
 dnl === Check whether decoder library should be built.
 AC_MSG_CHECKING(whether decoder library is to be built)
@@ -722,19 +677,20 @@ AC_ARG_ENABLE([libwebpextras],
               AS_HELP_STRING([--enable-libwebpextras],
                              [Build libwebpextras @<:@default=no@:>@]))
 AC_MSG_RESULT(${enable_libwebpextras-no})
-AM_CONDITIONAL([BUILD_EXTRAS], [test "$enable_libwebpextras" = "yes"])
+AM_CONDITIONAL([WANT_EXTRAS], [test "$enable_libwebpextras" = "yes"])
 
 dnl =========================
 
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_HEADERS([src/webp/config.h])
 AC_CONFIG_FILES([Makefile src/Makefile man/Makefile \
-                 examples/Makefile extras/Makefile imageio/Makefile \
-                 src/dec/Makefile src/enc/Makefile src/dsp/Makefile \
+                 examples/Makefile src/dec/Makefile \
+                 src/enc/Makefile src/dsp/Makefile \
                  src/demux/Makefile src/mux/Makefile \
-                 src/utils/Makefile \
+                 src/utils/Makefile src/extras/Makefile \
                  src/libwebp.pc src/libwebpdecoder.pc \
-                 src/demux/libwebpdemux.pc src/mux/libwebpmux.pc])
+                 src/demux/libwebpdemux.pc src/mux/libwebpmux.pc \
+                 src/extras/libwebpextras.pc])
 
 
 AC_OUTPUT
@@ -753,25 +709,21 @@ libwebpmux: ${enable_libwebpmux-no}
 libwebpextras: ${enable_libwebpextras-no}
 
 Tools:
-cwebp : ${enable_libwebpdemux-no}
+cwebp : yes
   Input format support
   ====================
   JPEG : ${jpeg_support-no}
   PNG  : ${png_support-no}
   TIFF : ${tiff_support-no}
   WIC  : ${wic_support-no}
-dwebp : ${enable_libwebpdemux-no}
+dwebp : yes
   Output format support
   =====================
   PNG  : ${png_support-no}
   WIC  : ${wic_support-no}
 GIF support : ${gif_support-no}
-anim_diff   : ${build_anim_diff-no}
+anim_diff   : ${build_animdiff-no}
 gif2webp    : ${build_gif2webp-no}
-img2webp    : ${build_img2webp-no}
 webpmux     : ${enable_libwebpmux-no}
 vwebp       : ${build_vwebp-no}
-webpinfo    : ${build_webpinfo-no}
-SDL support : ${sdl_support-no}
-vwebp_sdl   : ${build_vwebp_sdl-no}
 ])

doc/webp-container-spec.txt

@@ -446,9 +446,8 @@ 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.
-  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.
+  In particular, frame duration of 0 is useful when one wants to update
+  multiple areas of the canvas at once during the animation.
 
 Reserved: 6 bits
 

examples/Android.mk

@@ -15,6 +15,27 @@ LOCAL_MODULE := example_util
 
 include $(BUILD_STATIC_LIBRARY)
 
+
+################################################################################
+# libexample_dec
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    image_dec.c \
+    jpegdec.c \
+    metadata.c \
+    pngdec.c \
+    tiffdec.c \
+    webpdec.c \
+
+LOCAL_CFLAGS := $(WEBP_CFLAGS)
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
+
+LOCAL_MODULE := example_dec
+
+include $(BUILD_STATIC_LIBRARY)
+
 ################################################################################
 # cwebp
 
@@ -26,7 +47,8 @@ LOCAL_SRC_FILES := \
     cwebp.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_STATIC_LIBRARIES := example_util imageio_util imagedec webpdemux webp
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
+LOCAL_STATIC_LIBRARIES := example_util example_dec webp
 
 LOCAL_MODULE := cwebp
 
@@ -41,7 +63,9 @@ LOCAL_SRC_FILES := \
     dwebp.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_STATIC_LIBRARIES := example_util imagedec imageenc webpdemux webp
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
+LOCAL_STATIC_LIBRARIES := example_util webp
+
 LOCAL_MODULE := dwebp
 
 include $(BUILD_EXECUTABLE)
@@ -55,39 +79,9 @@ LOCAL_SRC_FILES := \
     webpmux.c \
 
 LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_STATIC_LIBRARIES := example_util imageio_util webpmux webp
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
+LOCAL_STATIC_LIBRARIES := example_util webpmux webp
 
 LOCAL_MODULE := webpmux_example
 
 include $(BUILD_EXECUTABLE)
-
-################################################################################
-# img2webp
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-    img2webp.c \
-
-LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_STATIC_LIBRARIES := example_util imageio_util imagedec webpmux webpdemux \
-                          webp
-
-LOCAL_MODULE := img2webp_example
-
-include $(BUILD_EXECUTABLE)
-
-################################################################################
-# webpinfo
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-    webpinfo.c \
-
-LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_STATIC_LIBRARIES := example_util imageio_util webp
-
-LOCAL_MODULE := webpinfo_example
-
-include $(BUILD_EXECUTABLE)

examples/Makefile.am

@@ -1,119 +1,70 @@
 AM_CPPFLAGS += -I$(top_builddir)/src -I$(top_srcdir)/src
 
-bin_PROGRAMS =
-if BUILD_DEMUX
-  bin_PROGRAMS += dwebp cwebp
-endif
-if BUILD_ANIMDIFF
-  noinst_PROGRAMS = anim_diff anim_dump
-endif
-if BUILD_GIF2WEBP
-  bin_PROGRAMS += gif2webp
-endif
-if BUILD_IMG2WEBP
-  bin_PROGRAMS += img2webp
-endif
-if BUILD_MUX
-  bin_PROGRAMS += webpmux
-endif
+bin_PROGRAMS = dwebp cwebp
 if BUILD_VWEBP
   bin_PROGRAMS += vwebp
 endif
-if BUILD_WEBPINFO
-  bin_PROGRAMS += webpinfo
+if WANT_MUX
+  bin_PROGRAMS += webpmux
 endif
 
-noinst_LTLIBRARIES = libexample_util.la
+if BUILD_GIF2WEBP
+  bin_PROGRAMS += gif2webp
+endif
 
-libexample_util_la_SOURCES = example_util.c example_util.h
-libexample_util_la_LIBADD = ../src/libwebp.la
+noinst_LTLIBRARIES = libexampleutil.la libexampledec.la
 
-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
+libexampleutil_la_SOURCES = example_util.c example_util.h stopwatch.h
+
+libexampledec_la_SOURCES  = image_dec.c image_dec.h
+libexampledec_la_SOURCES += jpegdec.c jpegdec.h
+libexampledec_la_SOURCES += metadata.c metadata.h
+libexampledec_la_SOURCES += pngdec.c pngdec.h
+libexampledec_la_SOURCES += tiffdec.c tiffdec.h
+libexampledec_la_SOURCES += webpdec.c webpdec.h
+libexampledec_la_SOURCES += wicdec.c wicdec.h
+libexampledec_la_CPPFLAGS = $(JPEG_INCLUDES) $(PNG_INCLUDES) $(TIFF_INCLUDES)
+libexampledec_la_CPPFLAGS += $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+
+if BUILD_ANIMDIFF
+  noinst_PROGRAMS = anim_diff
+endif
+
+anim_diff_SOURCES = anim_diff.c anim_util.c anim_util.h
+anim_diff_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE) $(GIF_INCLUDES)
+anim_diff_LDADD  = ../src/demux/libwebpdemux.la
+anim_diff_LDADD += libexampleutil.la
 anim_diff_LDADD += $(GIF_LIBS) -lm
 
-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
-anim_dump_LDADD += libexample_util.la
-anim_dump_LDADD += ../imageio/libimageio_util.la
-anim_dump_LDADD += ../imageio/libimageenc.la
-anim_dump_LDADD += $(PNG_LIBS) $(GIF_LIBS) $(TIFF_LIBS) -lm
+dwebp_SOURCES = dwebp.c stopwatch.h
+dwebp_CPPFLAGS  = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+dwebp_CPPFLAGS += $(JPEG_INCLUDES) $(PNG_INCLUDES)
+dwebp_LDADD = libexampleutil.la $(PNG_LIBS) $(JPEG_LIBS)
 
 cwebp_SOURCES  = cwebp.c stopwatch.h
-cwebp_CPPFLAGS  = $(AM_CPPFLAGS)
-cwebp_LDADD  =
-cwebp_LDADD += libexample_util.la
-cwebp_LDADD += ../imageio/libimageio_util.la
-cwebp_LDADD += ../imageio/libimagedec.la
-cwebp_LDADD += ../src/libwebp.la
+cwebp_CPPFLAGS  = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+cwebp_LDADD  = libexampleutil.la libexampledec.la ../src/libwebp.la
 cwebp_LDADD += $(JPEG_LIBS) $(PNG_LIBS) $(TIFF_LIBS)
 
-dwebp_SOURCES = dwebp.c stopwatch.h
-dwebp_CPPFLAGS  = $(AM_CPPFLAGS)
-dwebp_CPPFLAGS += $(JPEG_INCLUDES) $(PNG_INCLUDES)
-dwebp_LDADD  =
-dwebp_LDADD += libexample_util.la
-dwebp_LDADD += ../imageio/libimagedec.la
-dwebp_LDADD += ../imageio/libimageenc.la
-dwebp_LDADD += ../imageio/libimageio_util.la
-dwebp_LDADD += ../src/libwebp.la
-dwebp_LDADD +=$(PNG_LIBS) $(JPEG_LIBS)
-
 gif2webp_SOURCES = gif2webp.c gifdec.c gifdec.h
-gif2webp_CPPFLAGS = $(AM_CPPFLAGS) $(GIF_INCLUDES)
-gif2webp_LDADD  =
-gif2webp_LDADD += libexample_util.la
-gif2webp_LDADD += ../imageio/libimageio_util.la
-gif2webp_LDADD += ../src/mux/libwebpmux.la
-gif2webp_LDADD += ../src/libwebp.la
+gif2webp_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE) $(GIF_INCLUDES)
+gif2webp_LDADD  = libexampleutil.la ../src/mux/libwebpmux.la ../src/libwebp.la
 gif2webp_LDADD += $(GIF_LIBS)
 
-vwebp_SOURCES = vwebp.c
-vwebp_CPPFLAGS = $(AM_CPPFLAGS) $(GL_INCLUDES)
-vwebp_LDADD  =
-vwebp_LDADD += libexample_util.la
-vwebp_LDADD += ../imageio/libimageio_util.la
-vwebp_LDADD += ../src/demux/libwebpdemux.la
-vwebp_LDADD += $(GL_LIBS)
-
 webpmux_SOURCES = webpmux.c
-webpmux_CPPFLAGS = $(AM_CPPFLAGS)
-webpmux_LDADD  =
-webpmux_LDADD += libexample_util.la
-webpmux_LDADD += ../imageio/libimageio_util.la
-webpmux_LDADD += ../src/mux/libwebpmux.la
-webpmux_LDADD += ../src/libwebp.la
+webpmux_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
+webpmux_LDADD = libexampleutil.la ../src/mux/libwebpmux.la ../src/libwebp.la
 
-img2webp_SOURCES = img2webp.c
-img2webp_CPPFLAGS = $(AM_CPPFLAGS)
-img2webp_LDADD  =
-img2webp_LDADD += libexample_util.la
-img2webp_LDADD += ../imageio/libimageio_util.la
-img2webp_LDADD += ../imageio/libimagedec.la
-img2webp_LDADD += ../src/mux/libwebpmux.la
-img2webp_LDADD += ../src/libwebp.la
-img2webp_LDADD += $(PNG_LIBS) $(JPEG_LIBS) $(TIFF_LIBS)
-
-webpinfo_SOURCES = webpinfo.c
-webpinfo_CPPFLAGS = $(AM_CPPFLAGS)
-webpinfo_LDADD  =
-webpinfo_LDADD += libexample_util.la
-webpinfo_LDADD += ../imageio/libimageio_util.la
-webpinfo_LDADD += ../src/libwebp.la
+vwebp_SOURCES = vwebp.c
+vwebp_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE) $(GL_INCLUDES)
+vwebp_LDADD = libexampleutil.la ../src/demux/libwebpdemux.la $(GL_LIBS)
 
 if BUILD_LIBWEBPDECODER
   anim_diff_LDADD += ../src/libwebpdecoder.la
-  anim_dump_LDADD += ../src/libwebpdecoder.la
+  dwebp_LDADD += ../src/libwebpdecoder.la
   vwebp_LDADD += ../src/libwebpdecoder.la
 else
   anim_diff_LDADD += ../src/libwebp.la
-  anim_dump_LDADD += ../src/libwebp.la
+  dwebp_LDADD += ../src/libwebp.la
   vwebp_LDADD += ../src/libwebp.la
 endif

examples/anim_diff.c

@@ -20,8 +20,6 @@
 #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
@@ -145,18 +143,8 @@ static int CompareAnimatedImagePair(const AnimatedImage* const img1,
   if (!ok) return 0;  // These are fatal failures, can't proceed.
 
   if (is_multi_frame_image) {  // Checks relevant for multi-frame images only.
-    int max_loop_count_workaround = 0;
-    // Transcodes to webp increase the gif loop count by 1 for compatibility.
-    // When the gif has the maximum value the webp value will be off by one.
-    if ((img1->format == ANIM_GIF && img1->loop_count == 65536 &&
-         img2->format == ANIM_WEBP && img2->loop_count == 65535) ||
-        (img1->format == ANIM_WEBP && img1->loop_count == 65535 &&
-         img2->format == ANIM_GIF && img2->loop_count == 65536)) {
-      max_loop_count_workaround = 1;
-    }
-    ok = (max_loop_count_workaround ||
-          CompareValues(img1->loop_count, img2->loop_count,
-                        "Loop count mismatch")) && ok;
+    ok = CompareValues(img1->loop_count, img2->loop_count,
+                       "Loop count mismatch") && ok;
     ok = CompareBackgroundColor(img1->bgcolor, img2->bgcolor,
                                 premultiply) && ok;
   }
@@ -199,11 +187,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");
-  printf("  -max_diff <int> ..... maximum allowed difference per channel\n"
-         "                        between corresponding pixels in subsequent\n"
+#ifdef WEBP_EXPERIMENTAL_FEATURES
+  printf("  -max_diff <int> ..... maximum allowed difference per channel "
+         "                        between corresponding pixels in subsequent"
          "                        frames\n");
-  printf("  -h .................. this help\n");
-  printf("  -version ............ print version number and exit\n");
+#endif
 }
 
 int main(int argc, const char* argv[]) {
@@ -219,49 +207,56 @@ int main(int argc, const char* argv[]) {
   const char* files[2] = { NULL, NULL };
   AnimatedImage images[2];
 
-  INIT_WARGV(argc, argv);
+  if (argc < 3) {
+    Help();
+    return -1;
+  }
 
   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 = (const char*)GET_WARGV(argv, ++c);
+        dump_folder = argv[++c];
       } else {
         parse_error = 1;
       }
     } else if (!strcmp(argv[c], "-min_psnr")) {
       if (c < argc - 1) {
-        min_psnr = ExUtilGetFloat(argv[++c], &parse_error);
+        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;
       } 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) {
-        max_diff = ExUtilGetInt(argv[++c], 0, &parse_error);
+        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;
       } else {
         parse_error = 1;
       }
-    } 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);
+#endif
     } else {
       if (!got_input1) {
-        files[0] = (const char*)GET_WARGV(argv, c);
+        files[0] = argv[c];
         got_input1 = 1;
       } else if (!got_input2) {
-        files[1] = (const char*)GET_WARGV(argv, c);
+        files[1] = argv[c];
         got_input2 = 1;
       } else {
         parse_error = 1;
@@ -269,30 +264,23 @@ int main(int argc, const char* argv[]) {
     }
     if (parse_error) {
       Help();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     }
   }
-  if (argc < 3) {
-    Help();
-    FREE_WARGV_AND_RETURN(-1);
-  }
-
-
   if (!got_input2) {
     Help();
-    FREE_WARGV_AND_RETURN(-1);
+    return -1;
   }
 
   if (dump_frames) {
-    WPRINTF("Dumping decoded frames in: %s\n", (const W_CHAR*)dump_folder);
+    printf("Dumping decoded frames in: %s\n", dump_folder);
   }
 
   memset(images, 0, sizeof(images));
   for (i = 0; i < 2; ++i) {
-    WPRINTF("Decoding file: %s\n", (const W_CHAR*)files[i]);
+    printf("Decoding file: %s\n", files[i]);
     if (!ReadAnimatedImage(files[i], &images[i], dump_frames, dump_folder)) {
-      WFPRINTF(stderr, "Error decoding file: %s\n Aborting.\n",
-               (const W_CHAR*)files[i]);
+      fprintf(stderr, "Error decoding file: %s\n Aborting.\n", files[i]);
       return_code = -2;
       goto End;
     } else {
@@ -302,16 +290,14 @@ int main(int argc, const char* argv[]) {
 
   if (!CompareAnimatedImagePair(&images[0], &images[1],
                                 premultiply, min_psnr)) {
-    WFPRINTF(stderr, "\nFiles %s and %s differ.\n", (const W_CHAR*)files[0],
-             (const W_CHAR*)files[1]);
+    fprintf(stderr, "\nFiles %s and %s differ.\n", files[0], files[1]);
     return_code = -3;
   } else {
-    WPRINTF("\nFiles %s and %s are identical.\n", (const W_CHAR*)files[0],
-            (const W_CHAR*)files[1]);
+    printf("\nFiles %s and %s are identical.\n", files[0], files[1]);
     return_code = 0;
   }
  End:
   ClearAnimatedImage(&images[0]);
   ClearAnimatedImage(&images[1]);
-  FREE_WARGV_AND_RETURN(return_code);
+  return return_code;
 }

examples/anim_dump.c

@@ -1,121 +0,0 @@
-// Copyright 2017 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.
-// -----------------------------------------------------------------------------
-//
-// Decodes an animated WebP file and dumps the decoded frames as PNG or TIFF.
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <stdio.h>
-#include <string.h>  // for 'strcmp'.
-
-#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
-#endif
-
-static void Help(void) {
-  printf("Usage: anim_dump [options] files...\n");
-  printf("\nOptions:\n");
-  printf("  -folder <string> .... dump folder (default: '.')\n");
-  printf("  -prefix <string> .... prefix for dumped frames "
-                                  "(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 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();
-    FREE_WARGV_AND_RETURN(-1);
-  }
-
-  for (c = 1; !error && c < argc; ++c) {
-    if (!strcmp(argv[c], "-folder")) {
-      if (c + 1 == argc) {
-        fprintf(stderr, "missing argument after option '%s'\n", argv[c]);
-        error = 1;
-        break;
-      }
-      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 = GET_WARGV(argv, ++c);
-    } else if (!strcmp(argv[c], "-tiff")) {
-      format = TIFF;
-      suffix = TO_W_CHAR("tiff");
-    } else if (!strcmp(argv[c], "-pam")) {
-      format = 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 W_CHAR* const file = GET_WARGV(argv, c);
-      memset(&image, 0, sizeof(image));
-      WPRINTF("Decoding file: %s as %s/%sxxxx.%s\n",
-              file, dump_folder, prefix, suffix);
-      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) {
-        W_CHAR out_file[1024];
-        WebPDecBuffer buffer;
-        WebPInitDecBuffer(&buffer);
-        buffer.colorspace = MODE_RGBA;
-        buffer.is_external_memory = 1;
-        buffer.width = image.canvas_width;
-        buffer.height = image.canvas_height;
-        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;
-        WSNPRINTF(out_file, sizeof(out_file), "%s/%s%.4d.%s",
-                  dump_folder, prefix, i, suffix);
-        if (!WebPSaveImage(&buffer, format, (const char*)out_file)) {
-          WFPRINTF(stderr, "Error while saving image '%s'\n", out_file);
-          error = 1;
-        }
-        WebPFreeDecBuffer(&buffer);
-      }
-      ClearAnimatedImage(&image);
-    }
-  }
-  FREE_WARGV_AND_RETURN(error ? 1 : 0);
-}

examples/anim_util.c

@@ -16,16 +16,13 @@
 #include <stdio.h>
 #include <string.h>
 
-#if defined(WEBP_HAVE_GIF)
+#ifdef WEBP_HAVE_GIF
 #include <gif_lib.h>
 #endif
 #include "webp/format_constants.h"
 #include "webp/decode.h"
 #include "webp/demux.h"
-#include "../imageio/imageio_util.h"
-#include "./gifdec.h"
-#include "./unicode.h"
-#include "./unicode_gif.h"
+#include "./example_util.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
@@ -36,13 +33,11 @@ static const int kNumChannels = 4;
 // -----------------------------------------------------------------------------
 // Common utilities.
 
-#if defined(WEBP_HAVE_GIF)
 // Returns true if the frame covers the full canvas.
 static int IsFullFrame(int width, int height,
                        int canvas_width, int canvas_height) {
   return (width == canvas_width && height == canvas_height);
 }
-#endif // WEBP_HAVE_GIF
 
 static int CheckSizeForOverflow(uint64_t size) {
   return (size == (size_t)size);
@@ -90,7 +85,6 @@ void ClearAnimatedImage(AnimatedImage* const image) {
   }
 }
 
-#if defined(WEBP_HAVE_GIF)
 // Clear the canvas to transparent.
 static void ZeroFillCanvas(uint8_t* rgba,
                            uint32_t canvas_width, uint32_t canvas_height) {
@@ -132,7 +126,6 @@ static void CopyFrameRectangle(const uint8_t* src, uint8_t* dst, int stride,
     dst += stride;
   }
 }
-#endif // WEBP_HAVE_GIF
 
 // Canonicalize all transparent pixels to transparent black to aid comparison.
 static void CleanupTransparentPixels(uint32_t* rgba,
@@ -154,45 +147,41 @@ static int DumpFrame(const char filename[], const char dump_folder[],
   int ok = 0;
   size_t max_len;
   int y;
-  const W_CHAR* base_name = NULL;
-  W_CHAR* file_name = NULL;
+  const char* base_name = NULL;
+  char* file_name = NULL;
   FILE* f = NULL;
-  const char* row;
 
-  if (dump_folder == NULL) dump_folder = (const char*)TO_W_CHAR(".");
-
-  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)
+  base_name = strrchr(filename, '/');
+  base_name = (base_name == NULL) ? filename : base_name + 1;
+  max_len = strlen(dump_folder) + 1 + strlen(base_name)
           + strlen("_frame_") + strlen(".pam") + 8;
-  file_name = (W_CHAR*)malloc(max_len * sizeof(*file_name));
+  file_name = (char*)malloc(max_len * sizeof(*file_name));
   if (file_name == NULL) goto End;
 
-  if (WSNPRINTF(file_name, max_len, "%s/%s_frame_%d.pam",
-                (const W_CHAR*)dump_folder, base_name, frame_num) < 0) {
+  if (snprintf(file_name, max_len, "%s/%s_frame_%d.pam",
+               dump_folder, base_name, frame_num) < 0) {
     fprintf(stderr, "Error while generating file name\n");
     goto End;
   }
 
-  f = WFOPEN(file_name, "wb");
+  f = fopen(file_name, "wb");
   if (f == NULL) {
-    WFPRINTF(stderr, "Error opening file for writing: %s\n", file_name);
+    fprintf(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) {
-    WFPRINTF(stderr, "Write error for file %s\n", file_name);
+    fprintf(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) {
-      WFPRINTF(stderr, "Error writing to file: %s\n", file_name);
+    if (fwrite((const char*)(rgba) + y * canvas_width * kNumChannels,
+               canvas_width * kNumChannels, 1, f) != 1) {
+      fprintf(stderr, "Error writing to file: %s\n", file_name);
       goto End;
     }
-    row += canvas_width * kNumChannels;
   }
   ok = 1;
  End:
@@ -209,7 +198,7 @@ static int IsWebP(const WebPData* const webp_data) {
   return (WebPGetInfo(webp_data->bytes, webp_data->size, NULL, NULL) != 0);
 }
 
-// Read animated WebP bitstream 'webp_data' into 'AnimatedImage' struct.
+// Read animated WebP bitstream 'file_str' into 'AnimatedImage' struct.
 static int ReadAnimatedWebP(const char filename[],
                             const WebPData* const webp_data,
                             AnimatedImage* const image, int dump_frames,
@@ -225,7 +214,7 @@ static int ReadAnimatedWebP(const char filename[],
 
   dec = WebPAnimDecoderNew(webp_data, NULL);
   if (dec == NULL) {
-    WFPRINTF(stderr, "Error parsing image: %s\n", (const W_CHAR*)filename);
+    fprintf(stderr, "Error parsing image: %s\n", filename);
     goto End;
   }
 
@@ -278,7 +267,6 @@ static int ReadAnimatedWebP(const char filename[],
     prev_frame_timestamp = timestamp;
   }
   ok = dump_ok;
-  if (ok) image->format = ANIM_WEBP;
 
  End:
   WebPAnimDecoderDelete(dec);
@@ -288,7 +276,7 @@ static int ReadAnimatedWebP(const char filename[],
 // -----------------------------------------------------------------------------
 // GIF Decoding.
 
-#if defined(WEBP_HAVE_GIF)
+#ifdef WEBP_HAVE_GIF
 
 // Returns true if this is a valid GIF bitstream.
 static int IsGIF(const WebPData* const data) {
@@ -373,6 +361,26 @@ 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) {
@@ -413,11 +421,6 @@ static uint32_t GetBackgroundColorGIF(GifFileType* gif) {
 }
 
 // Find appropriate app extension and get loop count from the next extension.
-// We use Chrome's interpretation of the 'loop_count' semantics:
-//   if not present -> loop once
-//   if present and loop_count == 0, return 0 ('infinite').
-//   if present and loop_count != 0, it's the number of *extra* loops
-//     so we need to return loop_count + 1 as total loop number.
 static uint32_t GetLoopCountGIF(const GifFileType* const gif) {
   int i;
   for (i = 0; i < gif->ImageCount; ++i) {
@@ -435,13 +438,12 @@ static uint32_t GetLoopCountGIF(const GifFileType* const gif) {
       if (signature_is_ok &&
           eb2->Function == CONTINUE_EXT_FUNC_CODE && eb2->ByteCount >= 3 &&
           eb2->Bytes[0] == 1) {
-        const uint32_t extra_loop = ((uint32_t)(eb2->Bytes[2]) << 8) +
-                                    ((uint32_t)(eb2->Bytes[1]) << 0);
-        return (extra_loop > 0) ? extra_loop + 1 : 0;
+        return ((uint32_t)(eb2->Bytes[2]) << 8) +
+               ((uint32_t)(eb2->Bytes[1]) << 0);
       }
     }
   }
-  return 1;  // Default.
+  return 0;  // Default.
 }
 
 // Get duration of 'n'th frame in milliseconds.
@@ -513,15 +515,15 @@ static int ReadAnimatedGIF(const char filename[], AnimatedImage* const image,
   int gif_error;
   GifFileType* gif;
 
-  gif = DGifOpenFileUnicode((const W_CHAR*)filename, NULL);
+  gif = DGifOpenFileName(filename, NULL);
   if (gif == NULL) {
-    WFPRINTF(stderr, "Could not read file: %s.\n", (const W_CHAR*)filename);
+    fprintf(stderr, "Could not read file: %s.\n", filename);
     return 0;
   }
 
   gif_error = DGifSlurp(gif);
   if (gif_error != GIF_OK) {
-    WFPRINTF(stderr, "Could not parse image: %s.\n", (const W_CHAR*)filename);
+    fprintf(stderr, "Could not parse image: %s.\n", filename);
     GIFDisplayError(gif, gif_error);
     DGifCloseFile(gif, NULL);
     return 0;
@@ -577,9 +579,6 @@ 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;
@@ -671,7 +670,6 @@ static int ReadAnimatedGIF(const char filename[], AnimatedImage* const image,
       }
     }
   }
-  image->format = ANIM_GIF;
   DGifCloseFile(gif, NULL);
   return 1;
 }
@@ -706,8 +704,8 @@ int ReadAnimatedImage(const char filename[], AnimatedImage* const image,
   WebPDataInit(&webp_data);
   memset(image, 0, sizeof(*image));
 
-  if (!ImgIoUtilReadFile(filename, &webp_data.bytes, &webp_data.size)) {
-    WFPRINTF(stderr, "Error reading file: %s\n", (const W_CHAR*)filename);
+  if (!ExUtilReadFile(filename, &webp_data.bytes, &webp_data.size)) {
+    fprintf(stderr, "Error reading file: %s\n", filename);
     return 0;
   }
 
@@ -717,9 +715,9 @@ int ReadAnimatedImage(const char filename[], AnimatedImage* const image,
   } else if (IsGIF(&webp_data)) {
     ok = ReadAnimatedGIF(filename, image, dump_frames, dump_folder);
   } else {
-    WFPRINTF(stderr,
-             "Unknown file type: %s. Supported file types are WebP and GIF\n",
-             (const W_CHAR*)filename);
+    fprintf(stderr,
+            "Unknown file type: %s. Supported file types are WebP and GIF\n",
+            filename);
     ok = 0;
   }
   if (!ok) ClearAnimatedImage(image);
@@ -745,7 +743,7 @@ void GetDiffAndPSNR(const uint8_t rgba1[], const uint8_t rgba2[],
   for (y = 0; y < height; ++y) {
     for (x = 0; x < stride; x += kNumChannels) {
       int k;
-      const size_t offset = (size_t)y * stride + x;
+      const size_t offset = y * stride + x;
       const int alpha1 = rgba1[offset + kAlphaChannel];
       const int alpha2 = rgba2[offset + kAlphaChannel];
       Accumulate(alpha1, alpha2, &f_max_diff, &sse);
@@ -771,9 +769,3 @@ 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

@@ -22,11 +22,6 @@
 extern "C" {
 #endif
 
-typedef enum {
-  ANIM_GIF,
-  ANIM_WEBP
-} AnimatedFileFormat;
-
 typedef struct {
   uint8_t* rgba;         // Decoded and reconstructed full frame.
   int duration;          // Frame duration in milliseconds.
@@ -34,7 +29,6 @@ typedef struct {
 } DecodedFrame;
 
 typedef struct {
-  AnimatedFileFormat format;
   uint32_t canvas_width;
   uint32_t canvas_height;
   uint32_t bgcolor;
@@ -62,10 +56,6 @@ 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

@@ -20,11 +20,9 @@
 #include "webp/config.h"
 #endif
 
-#include "../examples/example_util.h"
-#include "../imageio/image_dec.h"
-#include "../imageio/imageio_util.h"
+#include "./example_util.h"
+#include "./image_dec.h"
 #include "./stopwatch.h"
-#include "./unicode.h"
 #include "webp/encode.h"
 
 #ifndef WEBP_DLL
@@ -61,12 +59,12 @@ static int ReadYUV(const uint8_t* const data, size_t data_size,
 
   pic->use_argb = 0;
   if (!WebPPictureAlloc(pic)) return 0;
-  ImgIoUtilCopyPlane(data, pic->width, pic->y, pic->y_stride,
-                     pic->width, pic->height);
-  ImgIoUtilCopyPlane(data + y_plane_size, uv_width,
-                     pic->u, pic->uv_stride, uv_width, uv_height);
-  ImgIoUtilCopyPlane(data + y_plane_size + uv_plane_size, uv_width,
-                     pic->v, pic->uv_stride, uv_width, uv_height);
+  ExUtilCopyPlane(data, pic->width, pic->y, pic->y_stride,
+                  pic->width, pic->height);
+  ExUtilCopyPlane(data + y_plane_size, uv_width,
+                  pic->u, pic->uv_stride, uv_width, uv_height);
+  ExUtilCopyPlane(data + y_plane_size + uv_plane_size, uv_width,
+                  pic->v, pic->uv_stride, uv_width, uv_height);
   return use_argb ? WebPPictureYUVAToARGB(pic) : 1;
 }
 
@@ -78,19 +76,18 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
   const uint8_t* data = NULL;
   size_t data_size = 0;
   if (pic->width != 0 && pic->height != 0) {
-    ok = ImgIoUtilReadFile(filename, &data, &data_size);
+    ok = ExUtilReadFile(filename, &data, &data_size);
     ok = ok && ReadYUV(data, data_size, pic);
   } else {
     // If no size specified, try to decode it using WIC.
     ok = ReadPictureWithWIC(filename, pic, keep_alpha, metadata);
     if (!ok) {
-      ok = ImgIoUtilReadFile(filename, &data, &data_size);
+      ok = ExUtilReadFile(filename, &data, &data_size);
       ok = ok && ReadWebP(data, data_size, pic, keep_alpha, metadata);
     }
   }
   if (!ok) {
-    WFPRINTF(stderr, "Error! Could not process file %s\n",
-             (const W_CHAR*)filename);
+    fprintf(stderr, "Error! Could not process file %s\n", filename);
   }
   free((void*)data);
   return ok;
@@ -104,20 +101,19 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
   size_t data_size = 0;
   int ok = 0;
 
-  ok = ImgIoUtilReadFile(filename, &data, &data_size);
+  ok = ExUtilReadFile(filename, &data, &data_size);
   if (!ok) goto End;
 
   if (pic->width == 0 || pic->height == 0) {
     WebPImageReader reader = WebPGuessImageReader(data, data_size);
-    ok = reader(data, data_size, pic, keep_alpha, metadata);
+    ok = (reader != NULL) && reader(data, data_size, pic, keep_alpha, metadata);
   } else {
     // If image size is specified, infer it as YUV format.
     ok = ReadYUV(data, data_size, pic);
   }
  End:
   if (!ok) {
-    WFPRINTF(stderr, "Error! Could not process file %s\n",
-             (const W_CHAR*)filename);
+    fprintf(stderr, "Error! Could not process file %s\n", filename);
   }
   free((void*)data);
   return ok;
@@ -143,11 +139,10 @@ 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]) {
+static void PrintPercents(const int counts[4], int total) {
   int s;
-  const int total = counts[0] + counts[1] + counts[2] + counts[3];
   for (s = 0; s < 4; ++s) {
-    fprintf(stderr, "|      %2d%%", (int)(100. * counts[s] / total + .5));
+    fprintf(stderr, "|      %2d%%", 100 * counts[s] / total);
   }
   fprintf(stderr, "| %7d\n", total);
 }
@@ -188,10 +183,9 @@ static void PrintExtraInfoLossless(const WebPPicture* const pic,
   if (short_output) {
     fprintf(stderr, "%7d %2.2f\n", stats->coded_size, stats->PSNR[3]);
   } else {
-    WFPRINTF(stderr, "File:      %s\n", (const W_CHAR*)file_name);
+    fprintf(stderr, "File:      %s\n", file_name);
     fprintf(stderr, "Dimension: %d x %d\n", pic->width, pic->height);
-    fprintf(stderr, "Output:    %d bytes (%.2f bpp)\n", stats->coded_size,
-            8.f * stats->coded_size / pic->width / pic->height);
+    fprintf(stderr, "Output:    %d bytes\n", stats->coded_size);
     PrintFullLosslessInfo(stats, "ARGB");
   }
 }
@@ -207,23 +201,20 @@ 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;
-    WFPRINTF(stderr, "File:      %s\n", (const W_CHAR*)file_name);
+    fprintf(stderr, "File:      %s\n", 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"
-            "           (%.2f bpp)\n",
+            "%d bytes Y-U-V-All-PSNR %2.2f %2.2f %2.2f   %2.2f dB\n",
             stats->coded_size,
-            stats->PSNR[0], stats->PSNR[1], stats->PSNR[2], stats->PSNR[3],
-            8.f * stats->coded_size / pic->width / pic->height);
+            stats->PSNR[0], stats->PSNR[1], stats->PSNR[2], stats->PSNR[3]);
     if (total > 0) {
       int totals[4] = { 0, 0, 0, 0 };
-      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,
+      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",
               num_skip, 100.f * num_skip / total);
       fprintf(stderr, "bytes used:  header:         %6d  (%.1f%%)\n"
                       "             mode-partition: %6d  (%.1f%%)\n",
@@ -247,7 +238,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);
+      PrintPercents(stats->segment_size, total);
       fprintf(stderr, "      quantizer:  ");
       PrintValues(stats->segment_quant);
       fprintf(stderr, "   filter level:  ");
@@ -305,31 +296,27 @@ static int DumpPicture(const WebPPicture* const picture, const char* PGM_name) {
   const int uv_width = (picture->width + 1) / 2;
   const int uv_height = (picture->height + 1) / 2;
   const int stride = (picture->width + 1) & ~1;
-  const uint8_t* src_y = picture->y;
-  const uint8_t* src_u = picture->u;
-  const uint8_t* src_v = picture->v;
-  const uint8_t* src_a = picture->a;
   const int alpha_height =
       WebPPictureHasTransparency(picture) ? picture->height : 0;
   const int height = picture->height + uv_height + alpha_height;
-  FILE* const f = WFOPEN(PGM_name, "wb");
+  FILE* const f = fopen(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) {
-    if (fwrite(src_y, picture->width, 1, f) != 1) return 0;
+    if (fwrite(picture->y + y * picture->y_stride, picture->width, 1, f) != 1)
+      return 0;
     if (picture->width & 1) fputc(0, f);  // pad
-    src_y += picture->y_stride;
   }
   for (y = 0; y < uv_height; ++y) {
-    if (fwrite(src_u, uv_width, 1, f) != 1) return 0;
-    if (fwrite(src_v, uv_width, 1, f) != 1) return 0;
-    src_u += picture->uv_stride;
-    src_v += picture->uv_stride;
+    if (fwrite(picture->u + y * picture->uv_stride, uv_width, 1, f) != 1)
+      return 0;
+    if (fwrite(picture->v + y * picture->uv_stride, uv_width, 1, f) != 1)
+      return 0;
   }
   for (y = 0; y < alpha_height; ++y) {
-    if (fwrite(src_a, picture->width, 1, f) != 1) return 0;
+    if (fwrite(picture->a + y * picture->a_stride, picture->width, 1, f) != 1)
+      return 0;
     if (picture->width & 1) fputc(0, f);  // pad
-    src_a += picture->a_stride;
   }
   fclose(f);
   return 1;
@@ -471,9 +458,8 @@ static int WriteWebPWithMetadata(FILE* const out,
     } else {
       const int is_lossless = !memcmp(webp, "VP8L", kTagSize);
       if (is_lossless) {
-        // Presence of alpha is stored in the 37th bit (29th after the
-        // signature) of VP8L data.
-        if (webp[kChunkHeaderSize + 4] & (1 << 4)) flags |= kAlphaFlag;
+        // Presence of alpha is stored in the 29th bit of VP8L data.
+        if (webp[kChunkHeaderSize + 3] & (1 << 5)) flags |= kAlphaFlag;
       }
       ok = ok && (fwrite(kVP8XHeader, kChunkHeaderSize, 1, out) == 1);
       ok = ok && WriteLE32(out, flags);
@@ -495,10 +481,10 @@ static int WriteWebPWithMetadata(FILE* const out,
       *metadata_written |= METADATA_XMP;
     }
     return ok;
+  } else {
+    // No metadata, just write the original image file.
+    return (fwrite(webp, webp_size, 1, out) == 1);
   }
-
-  // No metadata, just write the original image file.
-  return (fwrite(webp, webp_size, 1, out) == 1);
 }
 
 //------------------------------------------------------------------------------
@@ -558,8 +544,6 @@ static void HelpLong(void) {
   printf("  -strong ................ use strong filter instead "
                                      "of simple (default)\n");
   printf("  -nostrong .............. use simple filter instead of strong\n");
-  printf("  -sharp_yuv ............. use sharper (and slower) RGB->YUV "
-                                     "conversion\n");
   printf("  -partition_limit <int> . limit quality to fit the 512k limit on\n");
   printf("                           "
          "the first partition (0=no degradation ... 100=full)\n");
@@ -588,6 +572,9 @@ static void HelpLong(void) {
   printf("  -near_lossless <int> ... use near-lossless image\n"
          "                           preprocessing (0..100=off), "
          "default=100\n");
+#ifdef WEBP_EXPERIMENTAL_FEATURES
+  printf("  -delta_palettization ... use delta palettization\n");
+#endif  // WEBP_EXPERIMENTAL_FEATURES
   printf("  -hint <string> ......... specify image characteristics hint,\n");
   printf("                           one of: photo, picture or graph\n");
 
@@ -666,34 +653,32 @@ 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");
-    FREE_WARGV_AND_RETURN(-1);
+    return -1;
   }
 
   if (argc == 1) {
     HelpShort();
-    FREE_WARGV_AND_RETURN(0);
+    return 0;
   }
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       HelpShort();
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-H") || !strcmp(argv[c], "-longhelp")) {
       HelpLong();
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
-      out_file = (const char*)GET_WARGV(argv, ++c);
+      out_file = argv[++c];
     } else if (!strcmp(argv[c], "-d") && c < argc - 1) {
-      dump_file = (const char*)GET_WARGV(argv, ++c);
+      dump_file = argv[++c];
       config.show_compressed = 1;
     } else if (!strcmp(argv[c], "-print_psnr")) {
       config.show_compressed = 1;
@@ -758,6 +743,11 @@ 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_palettization")) {
+      config.delta_palettization = 1;
+      config.lossless = 1;  // use delta-palettization only with lossless
+#endif  // WEBP_EXPERIMENTAL_FEATURES
     } else if (!strcmp(argv[c], "-hint") && c < argc - 1) {
       ++c;
       if (!strcmp(argv[c], "photo")) {
@@ -792,8 +782,6 @@ int main(int argc, const char *argv[]) {
       config.filter_type = 0;
     } else if (!strcmp(argv[c], "-sharpness") && c < argc - 1) {
       config.filter_sharpness = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-sharp_yuv")) {
-      config.use_sharp_yuv = 1;
     } else if (!strcmp(argv[c], "-pass") && c < argc - 1) {
       config.pass = ExUtilGetInt(argv[++c], 0, &parse_error);
     } else if (!strcmp(argv[c], "-pre") && c < argc - 1) {
@@ -821,7 +809,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);
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-progress")) {
       show_progress = 1;
     } else if (!strcmp(argv[c], "-quiet")) {
@@ -883,7 +871,8 @@ int main(int argc, const char *argv[]) {
         if (i == kNumTokens) {
           fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
                   (int)(token - start), start);
-          FREE_WARGV_AND_RETURN(-1);
+          HelpLong();
+          return -1;
         }
         start = token + 1;
       }
@@ -897,19 +886,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 = (const char*)GET_WARGV(argv, ++c);
+      if (c < argc - 1) in_file = argv[++c];
       break;
     } else if (argv[c][0] == '-') {
       fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
       HelpLong();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     } else {
-      in_file = (const char*)GET_WARGV(argv, c);
+      in_file = argv[c];
     }
 
     if (parse_error) {
       HelpLong();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     }
   }
   if (in_file == NULL) {
@@ -951,16 +940,14 @@ int main(int argc, const char *argv[]) {
   // Read the input. We need to decide if we prefer ARGB or YUVA
   // samples, depending on the expected compression mode (this saves
   // some conversion steps).
-  picture.use_argb = (config.lossless || config.use_sharp_yuv ||
-                      config.preprocessing > 0 ||
+  picture.use_argb = (config.lossless || config.preprocessing > 0 ||
                       crop || (resize_w | resize_h) > 0);
   if (verbose) {
     StopwatchReset(&stop_watch);
   }
   if (!ReadPicture(in_file, &picture, keep_alpha,
                    (keep_metadata == 0) ? NULL : &metadata)) {
-    WFPRINTF(stderr, "Error! Cannot read input picture file '%s'\n",
-             (const W_CHAR*)in_file);
+    fprintf(stderr, "Error! Cannot read input picture file '%s'\n", in_file);
     goto Error;
   }
   picture.progress_hook = (show_progress && !quiet) ? ProgressReport : NULL;
@@ -976,15 +963,14 @@ int main(int argc, const char *argv[]) {
 
   // Open the output
   if (out_file != NULL) {
-    const int use_stdout = !WSTRCMP(out_file, "-");
-    out = use_stdout ? ImgIoUtilSetBinaryMode(stdout) : WFOPEN(out_file, "wb");
+    const int use_stdout = !strcmp(out_file, "-");
+    out = use_stdout ? ExUtilSetBinaryMode(stdout) : fopen(out_file, "wb");
     if (out == NULL) {
-      WFPRINTF(stderr, "Error! Cannot open output file '%s'\n",
-               (const W_CHAR*)out_file);
+      fprintf(stderr, "Error! Cannot open output file '%s'\n", out_file);
       goto Error;
     } else {
       if (!short_output && !quiet) {
-        WFPRINTF(stderr, "Saving file '%s'\n", (const W_CHAR*)out_file);
+        fprintf(stderr, "Saving file '%s'\n", out_file);
       }
     }
     if (keep_metadata == 0) {
@@ -1018,53 +1004,10 @@ 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);
@@ -1096,11 +1039,9 @@ 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.\n");
+      fprintf(stderr, "Warning: can't dump file (-d option) in lossless mode.");
     } else if (!DumpPicture(&picture, dump_file)) {
-      WFPRINTF(stderr, "Warning, couldn't dump picture %s\n",
-               (const W_CHAR*)dump_file);
+      fprintf(stderr, "Warning, couldn't dump picture %s\n", dump_file);
     }
   }
 
@@ -1147,6 +1088,20 @@ int main(int argc, const char *argv[]) {
     if (print_distortion >= 0) {    // print distortion
       static const char* distortion_names[] = { "PSNR", "SSIM", "LSIM" };
       float values[5];
+      if (picture.use_argb != original_picture.use_argb) {
+        // Somehow, the WebPEncode() call converted the original picture.
+        // We need to make both match before calling WebPPictureDistortion().
+        int ok = 0;
+        if (picture.use_argb) {
+          ok = WebPPictureYUVAToARGB(&original_picture);
+        } else {
+          ok = WebPPictureARGBToYUVA(&original_picture, WEBP_YUV420A);
+        }
+        if (!ok) {
+          fprintf(stderr, "Error while converting original picture.\n");
+          goto Error;
+        }
+      }
       if (!WebPPictureDistortion(&picture, &original_picture,
                                  print_distortion, values)) {
         fprintf(stderr, "Error while computing the distortion.\n");
@@ -1154,8 +1109,13 @@ int main(int argc, const char *argv[]) {
       }
       if (!short_output) {
         fprintf(stderr, "%s: ", distortion_names[print_distortion]);
-        fprintf(stderr, "B:%.2f G:%.2f R:%.2f A:%.2f  Total:%.2f\n",
-                values[0], values[1], values[2], values[3], values[4]);
+        if (picture.use_argb) {
+          fprintf(stderr, "B:%.2f G:%.2f R:%.2f A:%.2f  Total:%.2f\n",
+                  values[0], values[1], values[2], values[3], values[4]);
+        } else {
+          fprintf(stderr, "Y:%.2f U:%.2f V:%.2f A:%.2f  Total:%.2f\n",
+                  values[0], values[1], values[2], values[3], values[4]);
+        }
       } else {
         fprintf(stderr, "%7d %.4f\n", picture.stats->coded_size, values[4]);
       }
@@ -1176,7 +1136,7 @@ int main(int argc, const char *argv[]) {
     fclose(out);
   }
 
-  FREE_WARGV_AND_RETURN(return_value);
+  return return_value;
 }
 
 //------------------------------------------------------------------------------

examples/dwebp.c

@@ -20,11 +20,28 @@
 #include "webp/config.h"
 #endif
 
-#include "../examples/example_util.h"
-#include "../imageio/image_enc.h"
-#include "../imageio/webpdec.h"
+#ifdef WEBP_HAVE_PNG
+#include <png.h>
+#include <setjmp.h>   // note: this must be included *after* png.h
+#endif
+
+#ifdef HAVE_WINCODEC_H
+#ifdef __MINGW32__
+#define INITGUID  // Without this GUIDs are declared extern and fail to link
+#endif
+#define CINTERFACE
+#define COBJMACROS
+#define _WIN32_IE 0x500  // Workaround bug in shlwapi.h when compiling C++
+                         // code with COBJMACROS.
+#include <ole2.h>  // CreateStreamOnHGlobal()
+#include <shlwapi.h>
+#include <windows.h>
+#include <wincodec.h>
+#endif
+
+#include "webp/decode.h"
+#include "./example_util.h"
 #include "./stopwatch.h"
-#include "./unicode.h"
 
 static int verbose = 0;
 static int quiet = 0;
@@ -40,24 +57,492 @@ extern void* VP8GetCPUInfo;   // opaque forward declaration.
 #endif
 #endif  // WEBP_DLL
 
+//------------------------------------------------------------------------------
+
+// Output types
+typedef enum {
+  PNG = 0,
+  PAM,
+  PPM,
+  PGM,
+  BMP,
+  TIFF,
+  RAW_YUV,
+  ALPHA_PLANE_ONLY,  // this is for experimenting only
+  // forced colorspace output (for testing, mostly)
+  RGB, RGBA, BGR, BGRA, ARGB,
+  RGBA_4444, RGB_565,
+  rgbA, bgrA, Argb, rgbA_4444,
+  YUV, YUVA
+} OutputFileFormat;
+
+#ifdef HAVE_WINCODEC_H
+
+#define IFS(fn)                                                     \
+  do {                                                              \
+    if (SUCCEEDED(hr)) {                                            \
+      hr = (fn);                                                    \
+      if (FAILED(hr)) fprintf(stderr, #fn " failed %08lx\n", hr);   \
+    }                                                               \
+  } while (0)
+
+#ifdef __cplusplus
+#define MAKE_REFGUID(x) (x)
+#else
+#define MAKE_REFGUID(x) &(x)
+#endif
+
+static HRESULT CreateOutputStream(const char* out_file_name,
+                                  int write_to_mem, IStream** stream) {
+  HRESULT hr = S_OK;
+  if (write_to_mem) {
+    // 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));
+  }
+  if (FAILED(hr)) {
+    fprintf(stderr, "Error opening output file %s (%08lx)\n",
+            out_file_name, hr);
+  }
+  return hr;
+}
+
+static HRESULT WriteUsingWIC(const char* out_file_name, int use_stdout,
+                             REFGUID container_guid,
+                             uint8_t* rgb, int stride,
+                             uint32_t width, uint32_t height, int has_alpha) {
+  HRESULT hr = S_OK;
+  IWICImagingFactory* factory = NULL;
+  IWICBitmapFrameEncode* frame = NULL;
+  IWICBitmapEncoder* encoder = NULL;
+  IStream* stream = NULL;
+  WICPixelFormatGUID pixel_format = has_alpha ? GUID_WICPixelFormat32bppBGRA
+                                              : GUID_WICPixelFormat24bppBGR;
+
+  IFS(CoInitialize(NULL));
+  IFS(CoCreateInstance(MAKE_REFGUID(CLSID_WICImagingFactory), NULL,
+                       CLSCTX_INPROC_SERVER,
+                       MAKE_REFGUID(IID_IWICImagingFactory),
+                       (LPVOID*)&factory));
+  if (hr == REGDB_E_CLASSNOTREG) {
+    fprintf(stderr,
+            "Couldn't access Windows Imaging Component (are you running "
+            "Windows XP SP3 or newer?). PNG support not available. "
+            "Use -ppm or -pgm for available PPM and PGM formats.\n");
+  }
+  IFS(CreateOutputStream(out_file_name, use_stdout, &stream));
+  IFS(IWICImagingFactory_CreateEncoder(factory, container_guid, NULL,
+                                       &encoder));
+  IFS(IWICBitmapEncoder_Initialize(encoder, stream,
+                                   WICBitmapEncoderNoCache));
+  IFS(IWICBitmapEncoder_CreateNewFrame(encoder, &frame, NULL));
+  IFS(IWICBitmapFrameEncode_Initialize(frame, NULL));
+  IFS(IWICBitmapFrameEncode_SetSize(frame, width, height));
+  IFS(IWICBitmapFrameEncode_SetPixelFormat(frame, &pixel_format));
+  IFS(IWICBitmapFrameEncode_WritePixels(frame, height, stride,
+                                        height * stride, rgb));
+  IFS(IWICBitmapFrameEncode_Commit(frame));
+  IFS(IWICBitmapEncoder_Commit(encoder));
+
+  if (SUCCEEDED(hr) && use_stdout) {
+    HGLOBAL image;
+    IFS(GetHGlobalFromStream(stream, &image));
+    if (SUCCEEDED(hr)) {
+      HANDLE std_output = GetStdHandle(STD_OUTPUT_HANDLE);
+      DWORD mode;
+      const BOOL update_mode = GetConsoleMode(std_output, &mode);
+      const void* const image_mem = GlobalLock(image);
+      DWORD bytes_written = 0;
+
+      // Clear output processing if necessary, then output the image.
+      if (update_mode) SetConsoleMode(std_output, 0);
+      if (!WriteFile(std_output, image_mem, (DWORD)GlobalSize(image),
+                     &bytes_written, NULL) ||
+          bytes_written != GlobalSize(image)) {
+        hr = E_FAIL;
+      }
+      if (update_mode) SetConsoleMode(std_output, mode);
+      GlobalUnlock(image);
+    }
+  }
+
+  if (frame != NULL) IUnknown_Release(frame);
+  if (encoder != NULL) IUnknown_Release(encoder);
+  if (factory != NULL) IUnknown_Release(factory);
+  if (stream != NULL) IUnknown_Release(stream);
+  return hr;
+}
+
+static int WritePNG(const char* out_file_name, int use_stdout,
+                    const WebPDecBuffer* const buffer) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  uint8_t* const rgb = buffer->u.RGBA.rgba;
+  const int stride = buffer->u.RGBA.stride;
+  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
+
+  return SUCCEEDED(WriteUsingWIC(out_file_name, use_stdout,
+                                 MAKE_REFGUID(GUID_ContainerFormatPng),
+                                 rgb, stride, width, height, has_alpha));
+}
+
+#elif defined(WEBP_HAVE_PNG)    // !HAVE_WINCODEC_H
+static void PNGAPI PNGErrorFunction(png_structp png, png_const_charp dummy) {
+  (void)dummy;  // remove variable-unused warning
+  longjmp(png_jmpbuf(png), 1);
+}
+
+static int WritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  uint8_t* const rgb = 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;
+
+  png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+                                NULL, PNGErrorFunction, NULL);
+  if (png == NULL) {
+    return 0;
+  }
+  info = png_create_info_struct(png);
+  if (info == NULL) {
+    png_destroy_write_struct((png_structpp)&png, NULL);
+    return 0;
+  }
+  if (setjmp(png_jmpbuf(png))) {
+    png_destroy_write_struct((png_structpp)&png, (png_infopp)&info);
+    return 0;
+  }
+  png_init_io(png, out_file);
+  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,
+               PNG_FILTER_TYPE_DEFAULT);
+  png_write_info(png, info);
+  for (y = 0; y < height; ++y) {
+    png_bytep row = rgb + y * stride;
+    png_write_rows(png, &row, 1);
+  }
+  png_write_end(png, info);
+  png_destroy_write_struct((png_structpp)&png, (png_infopp)&info);
+  return 1;
+}
+#else    // !HAVE_WINCODEC_H && !WEBP_HAVE_PNG
+static int WritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
+  (void)out_file;
+  (void)buffer;
+  fprintf(stderr, "PNG support not compiled. Please install the libpng "
+          "development package before building.\n");
+  fprintf(stderr, "You can run with -ppm flag to decode in PPM format.\n");
+  return 0;
+}
+#endif
+
+static int WritePPM(FILE* fout, const WebPDecBuffer* const buffer, int alpha) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  const uint8_t* const rgb = buffer->u.RGBA.rgba;
+  const int stride = buffer->u.RGBA.stride;
+  const size_t bytes_per_px = alpha ? 4 : 3;
+  uint32_t y;
+
+  if (alpha) {
+    fprintf(fout, "P7\nWIDTH %u\nHEIGHT %u\nDEPTH 4\nMAXVAL 255\n"
+                  "TUPLTYPE RGB_ALPHA\nENDHDR\n", width, height);
+  } else {
+    fprintf(fout, "P6\n%u %u\n255\n", width, height);
+  }
+  for (y = 0; y < height; ++y) {
+    if (fwrite(rgb + y * stride, width, bytes_per_px, fout) != bytes_per_px) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+// Save 16b mode (RGBA4444, RGB565, ...) for debugging purpose.
+static int Write16bAsPGM(FILE* fout, const WebPDecBuffer* const buffer) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  const uint8_t* const rgba = buffer->u.RGBA.rgba;
+  const int stride = buffer->u.RGBA.stride;
+  const uint32_t bytes_per_px = 2;
+  uint32_t y;
+
+  fprintf(fout, "P5\n%u %u\n255\n", width * bytes_per_px, height);
+  for (y = 0; y < height; ++y) {
+    if (fwrite(rgba + y * stride, width, bytes_per_px, fout) != bytes_per_px) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+static void PutLE16(uint8_t* const dst, uint32_t value) {
+  dst[0] = (value >> 0) & 0xff;
+  dst[1] = (value >> 8) & 0xff;
+}
+
+static void PutLE32(uint8_t* const dst, uint32_t value) {
+  PutLE16(dst + 0, (value >>  0) & 0xffff);
+  PutLE16(dst + 2, (value >> 16) & 0xffff);
+}
+
+#define BMP_HEADER_SIZE 54
+static int WriteBMP(FILE* fout, const WebPDecBuffer* const buffer) {
+  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  const uint8_t* const rgba = buffer->u.RGBA.rgba;
+  const int stride = buffer->u.RGBA.stride;
+  const uint32_t bytes_per_px = has_alpha ? 4 : 3;
+  uint32_t y;
+  const uint32_t line_size = bytes_per_px * width;
+  const uint32_t bmp_stride = (line_size + 3) & ~3;   // pad to 4
+  const uint32_t total_size = bmp_stride * height + BMP_HEADER_SIZE;
+  uint8_t bmp_header[BMP_HEADER_SIZE] = { 0 };
+
+  // bitmap file header
+  PutLE16(bmp_header + 0, 0x4d42);                // signature 'BM'
+  PutLE32(bmp_header + 2, total_size);            // size including header
+  PutLE32(bmp_header + 6, 0);                     // reserved
+  PutLE32(bmp_header + 10, BMP_HEADER_SIZE);      // offset to pixel array
+  // bitmap info header
+  PutLE32(bmp_header + 14, 40);                   // DIB header size
+  PutLE32(bmp_header + 18, width);                // dimensions
+  PutLE32(bmp_header + 22, -(int)height);         // vertical flip!
+  PutLE16(bmp_header + 26, 1);                    // number of planes
+  PutLE16(bmp_header + 28, bytes_per_px * 8);     // bits per pixel
+  PutLE32(bmp_header + 30, 0);                    // no compression (BI_RGB)
+  PutLE32(bmp_header + 34, 0);                    // image size (dummy)
+  PutLE32(bmp_header + 38, 2400);                 // x pixels/meter
+  PutLE32(bmp_header + 42, 2400);                 // y pixels/meter
+  PutLE32(bmp_header + 46, 0);                    // number of palette colors
+  PutLE32(bmp_header + 50, 0);                    // important color count
+
+  // TODO(skal): color profile
+
+  // write header
+  if (fwrite(bmp_header, sizeof(bmp_header), 1, fout) != 1) {
+    return 0;
+  }
+
+  // write pixel array
+  for (y = 0; y < height; ++y) {
+    if (fwrite(rgba + y * stride, line_size, 1, fout) != 1) {
+      return 0;
+    }
+    // write padding zeroes
+    if (bmp_stride != line_size) {
+      const uint8_t zeroes[3] = { 0 };
+      if (fwrite(zeroes, bmp_stride - line_size, 1, fout) != 1) {
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+#undef BMP_HEADER_SIZE
+
+#define NUM_IFD_ENTRIES 15
+#define EXTRA_DATA_SIZE 16
+// 10b for signature/header + n * 12b entries + 4b for IFD terminator:
+#define EXTRA_DATA_OFFSET (10 + 12 * NUM_IFD_ENTRIES + 4)
+#define TIFF_HEADER_SIZE (EXTRA_DATA_OFFSET + EXTRA_DATA_SIZE)
+
+static int WriteTIFF(FILE* fout, const WebPDecBuffer* const buffer) {
+  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  const uint8_t* const rgba = buffer->u.RGBA.rgba;
+  const int stride = buffer->u.RGBA.stride;
+  const uint8_t bytes_per_px = has_alpha ? 4 : 3;
+  // For non-alpha case, we omit tag 0x152 (ExtraSamples).
+  const uint8_t num_ifd_entries = has_alpha ? NUM_IFD_ENTRIES
+                                            : NUM_IFD_ENTRIES - 1;
+  uint8_t tiff_header[TIFF_HEADER_SIZE] = {
+    0x49, 0x49, 0x2a, 0x00,   // little endian signature
+    8, 0, 0, 0,               // offset to the unique IFD that follows
+    // IFD (offset = 8). Entries must be written in increasing tag order.
+    num_ifd_entries, 0,       // Number of entries in the IFD (12 bytes each).
+    0x00, 0x01, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,    //  10: Width  (TBD)
+    0x01, 0x01, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,    //  22: Height (TBD)
+    0x02, 0x01, 3, 0, bytes_per_px, 0, 0, 0,     //  34: BitsPerSample: 8888
+        EXTRA_DATA_OFFSET + 0, 0, 0, 0,
+    0x03, 0x01, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0,    //  46: Compression: none
+    0x06, 0x01, 3, 0, 1, 0, 0, 0, 2, 0, 0, 0,    //  58: Photometric: RGB
+    0x11, 0x01, 4, 0, 1, 0, 0, 0,                //  70: Strips offset:
+        TIFF_HEADER_SIZE, 0, 0, 0,               //      data follows header
+    0x12, 0x01, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0,    //  82: Orientation: topleft
+    0x15, 0x01, 3, 0, 1, 0, 0, 0,                //  94: SamplesPerPixels
+        bytes_per_px, 0, 0, 0,
+    0x16, 0x01, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,    // 106: Rows per strip (TBD)
+    0x17, 0x01, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0,    // 118: StripByteCount (TBD)
+    0x1a, 0x01, 5, 0, 1, 0, 0, 0,                // 130: X-resolution
+        EXTRA_DATA_OFFSET + 8, 0, 0, 0,
+    0x1b, 0x01, 5, 0, 1, 0, 0, 0,                // 142: Y-resolution
+        EXTRA_DATA_OFFSET + 8, 0, 0, 0,
+    0x1c, 0x01, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0,    // 154: PlanarConfiguration
+    0x28, 0x01, 3, 0, 1, 0, 0, 0, 2, 0, 0, 0,    // 166: ResolutionUnit (inch)
+    0x52, 0x01, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0,    // 178: ExtraSamples: rgbA
+    0, 0, 0, 0,                                  // 190: IFD terminator
+    // EXTRA_DATA_OFFSET:
+    8, 0, 8, 0, 8, 0, 8, 0,      // BitsPerSample
+    72, 0, 0, 0, 1, 0, 0, 0      // 72 pixels/inch, for X/Y-resolution
+  };
+  uint32_t y;
+
+  // Fill placeholders in IFD:
+  PutLE32(tiff_header + 10 + 8, width);
+  PutLE32(tiff_header + 22 + 8, height);
+  PutLE32(tiff_header + 106 + 8, height);
+  PutLE32(tiff_header + 118 + 8, width * bytes_per_px * height);
+  if (!has_alpha) PutLE32(tiff_header + 178, 0);  // IFD terminator
+
+  // write header
+  if (fwrite(tiff_header, sizeof(tiff_header), 1, fout) != 1) {
+    return 0;
+  }
+  // write pixel values
+  for (y = 0; y < height; ++y) {
+    if (fwrite(rgba + y * stride, bytes_per_px, width, fout) != width) {
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+#undef TIFF_HEADER_SIZE
+#undef EXTRA_DATA_OFFSET
+#undef EXTRA_DATA_SIZE
+#undef NUM_IFD_ENTRIES
+
+static int WriteAlphaPlane(FILE* fout, const WebPDecBuffer* const buffer) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  const uint8_t* const a = buffer->u.YUVA.a;
+  const int a_stride = buffer->u.YUVA.a_stride;
+  uint32_t y;
+  assert(a != NULL);
+  fprintf(fout, "P5\n%u %u\n255\n", width, height);
+  for (y = 0; y < height; ++y) {
+    if (fwrite(a + y * a_stride, width, 1, fout) != 1) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+// format=PGM: save a grayscale PGM file using the IMC4 layout
+// (http://www.fourcc.org/yuv.php#IMC4). This is a very convenient format for
+// viewing the samples, esp. for odd dimensions.
+// format=RAW_YUV: just save the Y/U/V/A planes sequentially without header.
+static int WritePGMOrYUV(FILE* fout, const WebPDecBuffer* const buffer,
+                         OutputFileFormat format) {
+  const int width = buffer->width;
+  const int height = buffer->height;
+  const WebPYUVABuffer* const yuv = &buffer->u.YUVA;
+  int ok = 1;
+  int y;
+  const int pad = (format == RAW_YUV) ? 0 : 1;
+  const int uv_width = (width + 1) / 2;
+  const int uv_height = (height + 1) / 2;
+  const int out_stride = (width + pad) & ~pad;
+  const int a_height = yuv->a ? height : 0;
+  if (format == PGM) {
+    fprintf(fout, "P5\n%d %d\n255\n",
+            out_stride, height + uv_height + a_height);
+  }
+  for (y = 0; ok && y < height; ++y) {
+    ok &= (fwrite(yuv->y + y * yuv->y_stride, width, 1, fout) == 1);
+    if (format == PGM) {
+      if (width & 1) fputc(0, fout);    // padding byte
+    }
+  }
+  if (format == PGM) {   // IMC4 layout
+    for (y = 0; ok && y < uv_height; ++y) {
+      ok &= (fwrite(yuv->u + y * yuv->u_stride, uv_width, 1, fout) == 1);
+      ok &= (fwrite(yuv->v + y * yuv->v_stride, uv_width, 1, fout) == 1);
+    }
+  } else {
+    for (y = 0; ok && y < uv_height; ++y) {
+      ok &= (fwrite(yuv->u + y * yuv->u_stride, uv_width, 1, fout) == 1);
+    }
+    for (y = 0; ok && y < uv_height; ++y) {
+      ok &= (fwrite(yuv->v + y * yuv->v_stride, uv_width, 1, fout) == 1);
+    }
+  }
+  for (y = 0; ok && y < a_height; ++y) {
+    ok &= (fwrite(yuv->a + y * yuv->a_stride, width, 1, fout) == 1);
+    if (format == PGM) {
+      if (width & 1) fputc(0, fout);    // padding byte
+    }
+  }
+  return ok;
+}
 
 static int SaveOutput(const WebPDecBuffer* const buffer,
-                      WebPOutputFileFormat format, const char* const out_file) {
-  const int use_stdout = (out_file != NULL) && !WSTRCMP(out_file, "-");
+                      OutputFileFormat format, const char* const out_file) {
+  FILE* fout = NULL;
+  int needs_open_file = 1;
+  const int use_stdout = !strcmp(out_file, "-");
   int ok = 1;
   Stopwatch stop_watch;
 
   if (verbose) {
     StopwatchReset(&stop_watch);
   }
-  ok = WebPSaveImage(buffer, format, out_file);
 
+#ifdef HAVE_WINCODEC_H
+  needs_open_file = (format != PNG);
+#endif
+
+  if (needs_open_file) {
+    fout = use_stdout ? ExUtilSetBinaryMode(stdout) : fopen(out_file, "wb");
+    if (fout == NULL) {
+      fprintf(stderr, "Error opening output file %s\n", out_file);
+      return 0;
+    }
+  }
+
+  if (format == PNG ||
+      format == RGBA || format == BGRA || format == ARGB ||
+      format == rgbA || format == bgrA || format == Argb) {
+#ifdef HAVE_WINCODEC_H
+    ok &= WritePNG(out_file, use_stdout, buffer);
+#else
+    ok &= WritePNG(fout, buffer);
+#endif
+  } else if (format == PAM) {
+    ok &= WritePPM(fout, buffer, 1);
+  } else if (format == PPM || format == RGB || format == BGR) {
+    ok &= WritePPM(fout, buffer, 0);
+  } else if (format == RGBA_4444 || format == RGB_565 || format == rgbA_4444) {
+    ok &= Write16bAsPGM(fout, buffer);
+  } else if (format == BMP) {
+    ok &= WriteBMP(fout, buffer);
+  } else if (format == TIFF) {
+    ok &= WriteTIFF(fout, buffer);
+  } else if (format == PGM || format == RAW_YUV ||
+             format == YUV || format == YUVA) {
+    ok &= WritePGMOrYUV(fout, buffer, format == RAW_YUV ? RAW_YUV : PGM);
+  } else if (format == ALPHA_PLANE_ONLY) {
+    ok &= WriteAlphaPlane(fout, buffer);
+  }
+  if (fout != NULL && fout != stdout) {
+    fclose(fout);
+  }
   if (ok) {
     if (!quiet) {
       if (use_stdout) {
         fprintf(stderr, "Saved to stdout\n");
       } else {
-        WFPRINTF(stderr, "Saved file %s\n", (const W_CHAR*)out_file);
+        fprintf(stderr, "Saved file %s\n", out_file);
       }
     }
     if (verbose) {
@@ -68,7 +553,7 @@ static int SaveOutput(const WebPDecBuffer* const buffer,
     if (use_stdout) {
       fprintf(stderr, "Error writing to stdout !!\n");
     } else {
-      WFPRINTF(stderr, "Error writing file %s !!\n", (const W_CHAR*)out_file);
+      fprintf(stderr, "Error writing file %s !!\n", out_file);
     }
   }
   return ok;
@@ -113,7 +598,7 @@ static const char* const kFormatType[] = {
 };
 
 static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
-                                       WebPOutputFileFormat format,
+                                       OutputFileFormat format,
                                        int use_external_memory) {
   uint8_t* external_buffer = NULL;
   WebPDecBuffer* const output_buffer = &config->output;
@@ -184,7 +669,7 @@ int main(int argc, const char *argv[]) {
   WebPDecoderConfig config;
   WebPDecBuffer* const output_buffer = &config.output;
   WebPBitstreamFeatures* const bitstream = &config.input;
-  WebPOutputFileFormat format = PNG;
+  OutputFileFormat format = PNG;
   uint8_t* external_buffer = NULL;
   int use_external_memory = 0;
   const uint8_t* data = NULL;
@@ -192,20 +677,18 @@ 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");
-    FREE_WARGV_AND_RETURN(-1);
+    return -1;
   }
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       Help();
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
-      out_file = (const char*)GET_WARGV(argv, ++c);
+      out_file = argv[++c];
     } else if (!strcmp(argv[c], "-alpha")) {
       format = ALPHA_PLANE_ONLY;
     } else if (!strcmp(argv[c], "-nofancy")) {
@@ -226,7 +709,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);
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-pgm")) {
       format = PGM;
     } else if (!strcmp(argv[c], "-yuv")) {
@@ -287,26 +770,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 = (const char*)GET_WARGV(argv, ++c);
+      if (c < argc - 1) in_file = argv[++c];
       break;
     } else if (argv[c][0] == '-') {
       fprintf(stderr, "Unknown option '%s'\n", argv[c]);
       Help();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     } else {
-      in_file = (const char*)GET_WARGV(argv, c);
+      in_file = argv[c];
     }
 
     if (parse_error) {
       Help();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     }
   }
 
   if (in_file == NULL) {
     fprintf(stderr, "missing input file!!\n");
     Help();
-    FREE_WARGV_AND_RETURN(-1);
+    return -1;
   }
 
   if (quiet) verbose = 0;
@@ -314,8 +797,8 @@ 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)) {
-      FREE_WARGV_AND_RETURN(-1);
+    if (!ExUtilLoadWebP(in_file, &data, &data_size, bitstream)) {
+      return -1;
     }
 
     switch (format) {
@@ -335,8 +818,9 @@ int main(int argc, const char *argv[]) {
       case BMP:
         output_buffer->colorspace = bitstream->has_alpha ? MODE_BGRA : MODE_BGR;
         break;
-      case TIFF:
-        output_buffer->colorspace = bitstream->has_alpha ? MODE_RGBA : MODE_RGB;
+      case TIFF:    // note: force pre-multiplied alpha
+        output_buffer->colorspace =
+            bitstream->has_alpha ? MODE_rgbA : MODE_RGB;
         break;
       case PGM:
       case RAW_YUV:
@@ -368,42 +852,33 @@ int main(int argc, const char *argv[]) {
       if (external_buffer == NULL) goto Exit;
     }
 
-    {
-      Stopwatch stop_watch;
-      if (verbose) StopwatchReset(&stop_watch);
-
-      if (incremental) {
-        status = DecodeWebPIncremental(data, data_size, &config);
-      } else {
-        status = DecodeWebP(data, data_size, &config);
-      }
-      if (verbose) {
-        const double decode_time = StopwatchReadAndReset(&stop_watch);
-        fprintf(stderr, "Time to decode picture: %.3fs\n", decode_time);
-      }
+    if (incremental) {
+      status = ExUtilDecodeWebPIncremental(data, data_size, verbose, &config);
+    } else {
+      status = ExUtilDecodeWebP(data, data_size, verbose, &config);
     }
 
     ok = (status == VP8_STATUS_OK);
     if (!ok) {
-      PrintWebPError(in_file, status);
+      ExUtilPrintWebPError(in_file, status);
       goto Exit;
     }
   }
 
   if (out_file != NULL) {
     if (!quiet) {
-      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,
+      fprintf(stderr, "Decoded %s. Dimensions: %d x %d %s. Format: %s. "
+                      "Now saving...\n",
+              in_file, output_buffer->width, output_buffer->height,
               bitstream->has_alpha ? " (with alpha)" : "",
               kFormatType[bitstream->format]);
     }
     ok = SaveOutput(output_buffer, format, out_file);
   } else {
     if (!quiet) {
-      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,
+      fprintf(stderr, "File %s can be decoded "
+                      "(dimensions: %d x %d %s. Format: %s).\n",
+              in_file, output_buffer->width, output_buffer->height,
               bitstream->has_alpha ? " (with alpha)" : "",
               kFormatType[bitstream->format]);
       fprintf(stderr, "Nothing written; "
@@ -414,7 +889,7 @@ int main(int argc, const char *argv[]) {
   WebPFreeDecBuffer(output_buffer);
   free((void*)external_buffer);
   free((void*)data);
-  FREE_WARGV_AND_RETURN(ok ? 0 : -1);
+  return ok ? 0 : -1;
 }
 
 //------------------------------------------------------------------------------

examples/example_util.c

@@ -12,13 +12,16 @@
 
 #include "./example_util.h"
 
-#include <assert.h>
+#if defined(_WIN32)
+#include <fcntl.h>   // for _O_BINARY
+#include <io.h>      // for _setmode()
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "webp/mux_types.h"
-#include "../imageio/imageio_util.h"
+#include "webp/decode.h"
+#include "./stopwatch.h"
 
 //------------------------------------------------------------------------------
 // String parsing
@@ -38,18 +41,6 @@ int ExUtilGetInt(const char* const v, int base, int* const error) {
   return (int)ExUtilGetUInt(v, base, error);
 }
 
-int ExUtilGetInts(const char* v, int base, int max_output, int output[]) {
-  int n, error = 0;
-  for (n = 0; v != NULL && n < max_output; ++n) {
-    const int value = ExUtilGetInt(v, base, &error);
-    if (error) return -1;
-    output[n] = value;
-    v = strchr(v, ',');
-    if (v != NULL) ++v;   // skip over the trailing ','
-  }
-  return n;
-}
-
 float ExUtilGetFloat(const char* const v, int* const error) {
   char* end = NULL;
   const float f = (v != NULL) ? (float)strtod(v, &end) : 0.f;
@@ -61,75 +52,237 @@ float ExUtilGetFloat(const char* const v, int* const error) {
   return f;
 }
 
-//------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// File I/O
 
-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_) {
-      free((void*)args->argv_);
-      WebPDataClear(&args->argv_data_);
-    }
-    ResetCommandLineArguments(0, NULL, args);
+FILE* ExUtilSetBinaryMode(FILE* file) {
+#if defined(_WIN32)
+  if (_setmode(_fileno(file), _O_BINARY) == -1) {
+    fprintf(stderr, "Failed to reopen file in O_BINARY mode.\n");
+    return NULL;
   }
-}
-
-#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
+  return file;
+}
 
-    if (!ExUtilReadFileToWebPData(argv[0], &args->argv_data_)) {
-      return 0;
-    }
-    args->own_argv_ = 1;
-    args->argv_ = (const char**)malloc(MAX_ARGC * sizeof(*args->argv_));
-    if (args->argv_ == NULL) return 0;
+int ExUtilReadFromStdin(const uint8_t** data, size_t* data_size) {
+  static const size_t kBlockSize = 16384;  // default initial size
+  size_t max_size = 0;
+  size_t size = 0;
+  uint8_t* input = NULL;
 
-    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;
+  if (data == NULL || data_size == NULL) return 0;
+  *data = NULL;
+  *data_size = 0;
+
+  if (!ExUtilSetBinaryMode(stdin)) return 0;
+
+  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);
+    if (new_data == NULL) goto Error;
+    input = (uint8_t*)new_data;
+    max_size += extra_size;
+    size += fread(input + size, 1, extra_size, stdin);
+    if (size < max_size) break;
+  }
+  if (ferror(stdin)) goto Error;
+  *data = input;
+  *data_size = size;
+  return 1;
+
+ Error:
+  free(input);
+  fprintf(stderr, "Could not read from stdin\n");
+  return 0;
+}
+
+int ExUtilReadFile(const char* const file_name,
+                   const uint8_t** data, size_t* data_size) {
+  int ok;
+  void* file_data;
+  size_t file_size;
+  FILE* in;
+  const int from_stdin = (file_name == NULL) || !strcmp(file_name, "-");
+
+  if (from_stdin) return ExUtilReadFromStdin(data, data_size);
+
+  if (data == NULL || data_size == NULL) return 0;
+  *data = NULL;
+  *data_size = 0;
+
+  in = fopen(file_name, "rb");
+  if (in == NULL) {
+    fprintf(stderr, "cannot open input file '%s'\n", 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;
+  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);
+    free(file_data);
+    return 0;
+  }
+  *data = (uint8_t*)file_data;
+  *data_size = file_size;
+  return 1;
+}
+
+int ExUtilWriteFile(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, "-");
+
+  if (data == NULL) {
+    return 0;
+  }
+  out = to_stdout ? stdout : fopen(file_name, "wb");
+  if (out == NULL) {
+    fprintf(stderr, "Error! Cannot open output file '%s'\n", file_name);
+    return 0;
+  }
+  ok = (fwrite(data, data_size, 1, out) == 1);
+  if (out != stdout) fclose(out);
+  return ok;
+}
+
+//------------------------------------------------------------------------------
+// WebP decoding
+
+static const char* const kStatusMessages[VP8_STATUS_NOT_ENOUGH_DATA + 1] = {
+  "OK", "OUT_OF_MEMORY", "INVALID_PARAM", "BITSTREAM_ERROR",
+  "UNSUPPORTED_FEATURE", "SUSPENDED", "USER_ABORT", "NOT_ENOUGH_DATA"
+};
+
+static void PrintAnimationWarning(const WebPDecoderConfig* const config) {
+  if (config->input.has_animation) {
+    fprintf(stderr,
+            "Error! Decoding of an animated WebP file is not supported.\n"
+            "       Use webpmux to extract the individual frames or\n"
+            "       vwebp to view this image.\n");
+  }
+}
+
+void ExUtilPrintWebPError(const char* const in_file, int status) {
+  fprintf(stderr, "Decoding of %s failed.\n", in_file);
+  fprintf(stderr, "Status: %d", status);
+  if (status >= VP8_STATUS_OK && status <= VP8_STATUS_NOT_ENOUGH_DATA) {
+    fprintf(stderr, "(%s)", kStatusMessages[status]);
+  }
+  fprintf(stderr, "\n");
+}
+
+int ExUtilLoadWebP(const char* const in_file,
+                   const uint8_t** data, size_t* data_size,
+                   WebPBitstreamFeatures* bitstream) {
+  VP8StatusCode status;
+  WebPBitstreamFeatures local_features;
+  if (!ExUtilReadFile(in_file, data, data_size)) return 0;
+
+  if (bitstream == NULL) {
+    bitstream = &local_features;
+  }
+
+  status = WebPGetFeatures(*data, *data_size, bitstream);
+  if (status != VP8_STATUS_OK) {
+    free((void*)*data);
+    *data = NULL;
+    *data_size = 0;
+    ExUtilPrintWebPError(in_file, status);
+    return 0;
   }
   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;
+VP8StatusCode ExUtilDecodeWebP(const uint8_t* const data, size_t data_size,
+                               int verbose, WebPDecoderConfig* const config) {
+  Stopwatch stop_watch;
+  VP8StatusCode status = VP8_STATUS_OK;
+  if (config == NULL) return VP8_STATUS_INVALID_PARAM;
+
+  PrintAnimationWarning(config);
+
+  StopwatchReset(&stop_watch);
+
+  // Decoding call.
+  status = WebPDecode(data, data_size, config);
+
+  if (verbose) {
+    const double decode_time = StopwatchReadAndReset(&stop_watch);
+    fprintf(stderr, "Time to decode picture: %.3fs\n", decode_time);
+  }
+  return status;
 }
+
+VP8StatusCode ExUtilDecodeWebPIncremental(
+    const uint8_t* const data, size_t data_size,
+    int verbose, WebPDecoderConfig* const config) {
+  Stopwatch stop_watch;
+  VP8StatusCode status = VP8_STATUS_OK;
+  if (config == NULL) return VP8_STATUS_INVALID_PARAM;
+
+  PrintAnimationWarning(config);
+
+  StopwatchReset(&stop_watch);
+
+  // Decoding call.
+  {
+    WebPIDecoder* const idec = WebPIDecode(data, data_size, config);
+    if (idec == NULL) {
+      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);
+    }
+  }
+
+  if (verbose) {
+    const double decode_time = StopwatchReadAndReset(&stop_watch);
+    fprintf(stderr, "Time to decode picture: %.3fs\n", decode_time);
+  }
+  return status;
+}
+
+// -----------------------------------------------------------------------------
+
+void ExUtilCopyPlane(const uint8_t* src, int src_stride,
+                     uint8_t* dst, int dst_stride, int width, int height) {
+  while (height-- > 0) {
+    memcpy(dst, src, width * sizeof(*dst));
+    src += src_stride;
+    dst += dst_stride;
+  }
+}
+
+// -----------------------------------------------------------------------------
+
+int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t nmemb, size_t size) {
+  const uint64_t total_size = nmemb * size;
+  return (total_size == (size_t)total_size);
+}
+
+// -----------------------------------------------------------------------------

examples/example_util.h

@@ -13,8 +13,8 @@
 #ifndef WEBP_EXAMPLES_EXAMPLE_UTIL_H_
 #define WEBP_EXAMPLES_EXAMPLE_UTIL_H_
 
-#include "webp/types.h"
-#include "webp/mux_types.h"
+#include <stdio.h>
+#include "webp/decode.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -30,38 +30,68 @@ uint32_t ExUtilGetUInt(const char* const v, int base, int* const error);
 int ExUtilGetInt(const char* const v, int base, int* const error);
 float ExUtilGetFloat(const char* const v, int* const error);
 
-// This variant of ExUtilGetInt() will parse multiple integers from a
-// comma-separated list. Up to 'max_output' integers are parsed.
-// The result is placed in the output[] array, and the number of integers
-// actually parsed is returned, or -1 if an error occurred.
-int ExUtilGetInts(const char* v, int base, int max_output, int output[]);
+//------------------------------------------------------------------------------
+// File I/O
 
-// 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);
+// Reopen file in binary (O_BINARY) mode.
+// Returns 'file' on success, NULL otherwise.
+FILE* ExUtilSetBinaryMode(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().
+// If 'file_name' is NULL or equal to "-", input is read from stdin by calling
+// the function ExUtilReadFromStdin().
+int ExUtilReadFile(const char* const file_name,
+                   const uint8_t** data, size_t* data_size);
+
+// Same as ExUtilReadFile(), but reads until EOF from stdin instead.
+int ExUtilReadFromStdin(const uint8_t** data, size_t* data_size);
+
+// Write a data segment into a file named 'file_name'. Returns true if ok.
+// If 'file_name' is NULL or equal to "-", output is written to stdout.
+int ExUtilWriteFile(const char* const file_name,
+                    const uint8_t* data, size_t data_size);
 
 //------------------------------------------------------------------------------
-// Command-line arguments
 
-typedef struct {
-  int argc_;
-  const char** argv_;
-  WebPData argv_data_;
-  int own_argv_;
-} CommandLineArguments;
+// Copy width x height pixels from 'src' to 'dst' honoring the strides.
+void ExUtilCopyPlane(const uint8_t* src, int src_stride,
+                     uint8_t* dst, int dst_stride, int width, int height);
 
-// 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);
+// Returns 0 in case of overflow of nmemb * size.
+int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t nmemb, size_t size);
+
+//------------------------------------------------------------------------------
+// WebP decoding
+
+// Prints an informative error message regarding decode failure of 'in_file'.
+// 'status' is treated as a VP8StatusCode and if valid will be printed as a
+// text string.
+void ExUtilPrintWebPError(const char* const in_file, int status);
+
+// Reads a WebP from 'in_file', returning the contents and size in 'data' and
+// 'data_size'. If not NULL, 'bitstream' is populated using WebPGetFeatures().
+// Returns true on success.
+int ExUtilLoadWebP(const char* const in_file,
+                   const uint8_t** data, size_t* data_size,
+                   WebPBitstreamFeatures* bitstream);
+
+// Decodes the WebP contained in 'data'.
+// 'config' is a structure previously initialized by WebPInitDecoderConfig().
+// 'config->output' should have the desired colorspace selected. 'verbose' will
+// cause decode timing to be reported.
+// Returns the decoder status. On success 'config->output' will contain the
+// decoded picture.
+VP8StatusCode ExUtilDecodeWebP(const uint8_t* const data, size_t data_size,
+                               int verbose, WebPDecoderConfig* const config);
+
+// Same as ExUtilDecodeWebP(), but using the incremental decoder.
+VP8StatusCode ExUtilDecodeWebPIncremental(
+    const uint8_t* const data, size_t data_size,
+    int verbose, WebPDecoderConfig* const config);
 
 #ifdef __cplusplus
 }    // extern "C"

examples/gif2webp.c

@@ -23,22 +23,11 @@
 
 #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 "./example_util.h"
 #include "./gifdec.h"
-#include "./unicode.h"
-#include "./unicode_gif.h"
-
-#if !defined(STDIN_FILENO)
-#define STDIN_FILENO 0
-#endif
 
 //------------------------------------------------------------------------------
 
@@ -82,10 +71,8 @@ static void Help(void) {
   printf("  -metadata <string> ..... comma separated list of metadata to\n");
   printf("                           ");
   printf("copy from the input to the output if present\n");
-  printf("                           ");
-  printf("Valid values: all, none, icc, xmp (default)\n");
-  printf("  -loop_compatibility .... use compatibility mode for Chrome\n");
-  printf("                           version prior to M62 (inclusive)\n");
+  printf("                           "
+         "Valid values: all, none, icc, xmp (default)\n");
   printf("  -mt .................... use multi-threading if available\n");
   printf("\n");
   printf("  -version ............... print version number and exit\n");
@@ -101,7 +88,8 @@ int main(int argc, const char *argv[]) {
   int gif_error = GIF_ERROR;
   WebPMuxError err = WEBP_MUX_OK;
   int ok = 0;
-  const W_CHAR *in_file = NULL, *out_file = NULL;
+  const char *in_file = NULL, *out_file = NULL;
+  FILE* out = NULL;
   GifFileType* gif = NULL;
   int frame_duration = 0;
   int frame_timestamp = 0;
@@ -115,7 +103,7 @@ int main(int argc, const char *argv[]) {
   WebPAnimEncoderOptions enc_options;
   WebPConfig config;
 
-  int frame_number = 0;     // Whether we are processing the first frame.
+  int is_first_frame = 1;     // Whether we are processing the first frame.
   int done;
   int c;
   int quiet = 0;
@@ -126,21 +114,18 @@ int main(int argc, const char *argv[]) {
   int stored_icc = 0;         // Whether we have already stored an ICC profile.
   WebPData xmp_data;
   int stored_xmp = 0;         // Whether we have already stored an XMP profile.
-  int loop_count = 0;         // default: infinite
+  int loop_count = 0;
   int stored_loop_count = 0;  // Whether we have found an explicit loop count.
-  int loop_compatibility = 0;
   WebPMux* mux = NULL;
 
   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");
-    FREE_WARGV_AND_RETURN(-1);
+    return -1;
   }
   config.lossless = 1;  // Use lossless compression by default.
 
@@ -150,23 +135,21 @@ int main(int argc, const char *argv[]) {
 
   if (argc == 1) {
     Help();
-    FREE_WARGV_AND_RETURN(0);
+    return 0;
   }
 
   for (c = 1; c < argc; ++c) {
     int parse_error = 0;
     if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
       Help();
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
-      out_file = GET_WARGV(argv, ++c);
+      out_file = argv[++c];
     } else if (!strcmp(argv[c], "-lossy")) {
       config.lossless = 0;
     } else if (!strcmp(argv[c], "-mixed")) {
       enc_options.allow_mixed = 1;
       config.lossless = 0;
-    } else if (!strcmp(argv[c], "-loop_compatibility")) {
-      loop_compatibility = 1;
     } else if (!strcmp(argv[c], "-q") && c < argc - 1) {
       config.quality = ExUtilGetFloat(argv[++c], &parse_error);
     } else if (!strcmp(argv[c], "-m") && c < argc - 1) {
@@ -216,7 +199,7 @@ int main(int argc, const char *argv[]) {
           fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
                   (int)(token - start), start);
           Help();
-          FREE_WARGV_AND_RETURN(-1);
+          return -1;
         }
         start = token + 1;
       }
@@ -229,7 +212,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);
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-quiet")) {
       quiet = 1;
       enc_options.verbose = 0;
@@ -237,19 +220,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 = GET_WARGV(argv, ++c);
+      if (c < argc - 1) in_file = argv[++c];
       break;
     } else if (argv[c][0] == '-') {
       fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
       Help();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     } else {
-      in_file = GET_WARGV(argv, c);
+      in_file = argv[c];
     }
 
     if (parse_error) {
       Help();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     }
   }
 
@@ -273,7 +256,11 @@ int main(int argc, const char *argv[]) {
   }
 
   // Start the decoder object
-  gif = DGifOpenFileUnicode(in_file, &gif_error);
+#if LOCAL_GIF_PREREQ(5,0)
+  gif = DGifOpenFileName(in_file, &gif_error);
+#else
+  gif = DGifOpenFileName(in_file);
+#endif
   if (gif == NULL) goto End;
 
   // Loop over GIF images
@@ -289,7 +276,7 @@ int main(int argc, const char *argv[]) {
 
         if (!DGifGetImageDesc(gif)) goto End;
 
-        if (frame_number == 0) {
+        if (is_first_frame) {
           if (verbose) {
             printf("Canvas screen: %d x %d\n", gif->SWidth, gif->SHeight);
           }
@@ -331,6 +318,7 @@ int main(int argc, const char *argv[]) {
                     "a memory error.\n");
             goto End;
           }
+          is_first_frame = 0;
         }
 
         // Some even more broken GIF can have sub-rect with zero width/height.
@@ -347,25 +335,13 @@ int main(int argc, const char *argv[]) {
         GIFBlendFrames(&frame, &gif_rect, &curr_canvas);
 
         if (!WebPAnimEncoderAdd(enc, &curr_canvas, frame_timestamp, &config)) {
-          fprintf(stderr, "Error while adding frame #%d: %s\n", frame_number,
-                  WebPAnimEncoderGetError(enc));
-          goto End;
-        } else {
-          ++frame_number;
+          fprintf(stderr, "%s\n", WebPAnimEncoderGetError(enc));
         }
 
         // Update canvases.
         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;
 
@@ -409,7 +385,7 @@ int main(int argc, const char *argv[]) {
               if (verbose) {
                 fprintf(stderr, "Loop count: %d\n", loop_count);
               }
-              stored_loop_count = loop_compatibility ? (loop_count != 0) : 1;
+              stored_loop_count = (loop_count != 0);
             } else {  // An extension containing metadata.
               // We only store the first encountered chunk of each type, and
               // only if requested by the user.
@@ -466,23 +442,6 @@ int main(int argc, const char *argv[]) {
     goto End;
   }
 
-  if (!loop_compatibility) {
-    if (!stored_loop_count) {
-      // if no loop-count element is seen, the default is '1' (loop-once)
-      // and we need to signal it explicitly in WebP. Note however that
-      // in case there's a single frame, we still don't need to store it.
-      if (frame_number > 1) {
-        stored_loop_count = 1;
-        loop_count = 1;
-      }
-    } else if (loop_count > 0 && loop_count < 65535) {
-      // adapt GIF's semantic to WebP's (except in the infinite-loop case)
-      loop_count += 1;
-    }
-  }
-  // loop_count of 0 is the default (infinite), so no need to signal it
-  if (loop_count == 0) stored_loop_count = 0;
-
   if (stored_loop_count || stored_icc || stored_xmp) {
     // Re-mux to add loop count and/or metadata as needed.
     mux = WebPMuxCreate(&webp_data, 1);
@@ -542,19 +501,13 @@ int main(int argc, const char *argv[]) {
   }
 
   if (out_file != NULL) {
-    if (!ImgIoUtilWriteFile((const char*)out_file, webp_data.bytes,
-                            webp_data.size)) {
-      WFPRINTF(stderr, "Error writing output file: %s\n", out_file);
+    if (!ExUtilWriteFile(out_file, webp_data.bytes, webp_data.size)) {
+      fprintf(stderr, "Error writing output file: %s\n", out_file);
       goto End;
     }
     if (!quiet) {
-      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);
-      }
+      fprintf(stderr, "Saved output file (%d bytes): %s\n",
+              (int)webp_data.size, out_file);
     }
   } else {
     if (!quiet) {
@@ -576,6 +529,7 @@ 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);
@@ -588,7 +542,7 @@ int main(int argc, const char *argv[]) {
 #endif
   }
 
-  FREE_WARGV_AND_RETURN(!ok);
+  return !ok;
 }
 
 #else  // !WEBP_HAVE_GIF

examples/gifdec.c

@@ -21,24 +21,18 @@
 #include "webp/encode.h"
 #include "webp/mux_types.h"
 
-#define GIF_TRANSPARENT_COLOR 0x00000000u
-#define GIF_WHITE_COLOR       0xffffffffu
+#define GIF_TRANSPARENT_COLOR 0x00000000
+#define GIF_WHITE_COLOR       0xffffffff
 #define GIF_TRANSPARENT_MASK  0x01
 #define GIF_DISPOSE_MASK      0x07
 #define GIF_DISPOSE_SHIFT     2
 
 // from utils/utils.h
-#ifdef __cplusplus
-extern "C" {
-#endif
 extern void WebPCopyPlane(const uint8_t* src, int src_stride,
                           uint8_t* dst, int dst_stride,
                           int width, int height);
 extern void WebPCopyPixels(const WebPPicture* const src,
                            WebPPicture* const dst);
-#ifdef __cplusplus
-}
-#endif
 
 void GIFGetBackgroundColor(const ColorMapObject* const color_map,
                            int bgcolor_index, int transparent_index,
@@ -54,7 +48,7 @@ void GIFGetBackgroundColor(const ColorMapObject* const color_map,
             "white background.\n");
   } else {
     const GifColorType color = color_map->Colors[bgcolor_index];
-    *bgcolor = (0xffu       << 24)
+    *bgcolor = (0xff        << 24)
              | (color.Red   << 16)
              | (color.Green <<  8)
              | (color.Blue  <<  0);

examples/image_dec.c

@@ -29,38 +29,18 @@ WebPInputFileFormat WebPGuessImageType(const uint8_t* const data,
       format = WEBP_TIFF_FORMAT;
     } else if (magic1 == 0x52494646 && magic2 == 0x57454250) {
       format = WEBP_WEBP_FORMAT;
-    } else if (((magic1 >> 24) & 0xff) == 'P') {
-      const int type = (magic1 >> 16) & 0xff;
-      // we only support 'P5 -> P7' for now.
-      if (type >= '5' && type <= '7') format = WEBP_PNM_FORMAT;
     }
   }
   return format;
 }
 
-static int FailReader(const uint8_t* const data, size_t data_size,
-                      struct WebPPicture* const pic,
-                      int keep_alpha, struct Metadata* const metadata) {
-  (void)data;
-  (void)data_size;
-  (void)pic;
-  (void)keep_alpha;
-  (void)metadata;
-  return 0;
-}
-
-WebPImageReader WebPGetImageReader(WebPInputFileFormat format) {
-  switch (format) {
+WebPImageReader WebPGuessImageReader(const uint8_t* const data,
+                                     size_t data_size) {
+  switch (WebPGuessImageType(data, data_size)) {
     case WEBP_PNG_FORMAT: return ReadPNG;
     case WEBP_JPEG_FORMAT: return ReadJPEG;
     case WEBP_TIFF_FORMAT: return ReadTIFF;
     case WEBP_WEBP_FORMAT: return ReadWebP;
-    case WEBP_PNM_FORMAT: return ReadPNM;
-    default: return FailReader;
+    default: return NULL;
   }
-}
-
-WebPImageReader WebPGuessImageReader(const uint8_t* const data,
-                                     size_t data_size) {
-  return WebPGetImageReader(WebPGuessImageType(data, data_size));
-}
+}

examples/image_dec.h

@@ -11,8 +11,8 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
-#ifndef WEBP_IMAGEIO_IMAGE_DEC_H_
-#define WEBP_IMAGEIO_IMAGE_DEC_H_
+#ifndef WEBP_EXAMPLES_IMAGE_DEC_H_
+#define WEBP_EXAMPLES_IMAGE_DEC_H_
 
 #include "webp/types.h"
 
@@ -23,7 +23,6 @@
 #include "./metadata.h"
 #include "./jpegdec.h"
 #include "./pngdec.h"
-#include "./pnmdec.h"
 #include "./tiffdec.h"
 #include "./webpdec.h"
 #include "./wicdec.h"
@@ -37,7 +36,6 @@ typedef enum {
   WEBP_JPEG_FORMAT,
   WEBP_TIFF_FORMAT,
   WEBP_WEBP_FORMAT,
-  WEBP_PNM_FORMAT,
   WEBP_UNSUPPORTED_FORMAT
 } WebPInputFileFormat;
 
@@ -51,12 +49,8 @@ typedef int (*WebPImageReader)(const uint8_t* const data, size_t data_size,
                                struct WebPPicture* const pic,
                                int keep_alpha, struct Metadata* const metadata);
 
-// Return the reader associated to a given file format.
-WebPImageReader WebPGetImageReader(WebPInputFileFormat format);
-
 // This function is similar to WebPGuessImageType(), but returns a
-// suitable reader function. The returned reader is never NULL, but
-// unknown formats will return an always-failing valid reader.
+// suitable reader function. Or NULL if the image can't be guessed.
 WebPImageReader WebPGuessImageReader(const uint8_t* const data,
                                      size_t data_size);
 
@@ -64,4 +58,4 @@ WebPImageReader WebPGuessImageReader(const uint8_t* const data,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_IMAGEIO_IMAGE_DEC_H_
+#endif  // WEBP_EXAMPLES_IMAGE_DEC_H_

examples/img2webp.c

@@ -1,324 +0,0 @@
-// 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.
-// -----------------------------------------------------------------------------
-//
-//  generate an animated WebP out of a sequence of images
-//  (PNG, JPEG, ...)
-//
-//  Example usage:
-//     img2webp -o out.webp -q 40 -mixed -duration 40 input??.png
-//
-// Author: skal@google.com (Pascal Massimino)
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef HAVE_CONFIG_H
-#include "webp/config.h"
-#endif
-
-#include "../examples/example_util.h"
-#include "../imageio/image_dec.h"
-#include "../imageio/imageio_util.h"
-#include "./stopwatch.h"
-#include "./unicode.h"
-#include "webp/encode.h"
-#include "webp/mux.h"
-
-//------------------------------------------------------------------------------
-
-static void Help(void) {
-  printf("Usage:\n\n");
-  printf("  img2webp [file-level options] [image files...] "
-         "[per-frame options...]\n");
-  printf("\n");
-
-  printf("File-level options (only used at the start of compression):\n");
-  printf(" -min_size ............ minimize size\n");
-  printf(" -loop <int> .......... loop count (default: 0, = infinite loop)\n");
-  printf(" -kmax <int> .......... maximum number of frame between key-frames\n"
-         "                        (0=only keyframes)\n");
-  printf(" -kmin <int> .......... minimum number of frame between key-frames\n"
-         "                        (0=disable key-frames altogether)\n");
-  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");
-  printf(" -d <int> ............. frame duration in ms (default: 100)\n");
-  printf(" -lossless  ........... use lossless mode (default)\n");
-  printf(" -lossy ... ........... use lossy mode\n");
-  printf(" -q <float> ........... quality\n");
-  printf(" -m <int> ............. method to use\n");
-
-  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");
-}
-
-//------------------------------------------------------------------------------
-
-static int ReadImage(const char filename[], WebPPicture* const pic) {
-  const uint8_t* data = NULL;
-  size_t data_size = 0;
-  WebPImageReader reader;
-  int ok;
-#ifdef HAVE_WINCODEC_H
-  // Try to decode the file using WIC falling back to the other readers for
-  // e.g., WebP.
-  ok = ReadPictureWithWIC(filename, pic, 1, NULL);
-  if (ok) return 1;
-#endif
-  if (!ImgIoUtilReadFile(filename, &data, &data_size)) return 0;
-  reader = WebPGuessImageReader(data, data_size);
-  ok = reader(data, data_size, pic, 1, NULL);
-  free((void*)data);
-  return ok;
-}
-
-static int SetLoopCount(int loop_count, WebPData* const webp_data) {
-  int ok = 1;
-  WebPMuxError err;
-  uint32_t features;
-  WebPMuxAnimParams new_params;
-  WebPMux* const mux = WebPMuxCreate(webp_data, 1);
-  if (mux == NULL) return 0;
-
-  err = WebPMuxGetFeatures(mux, &features);
-  ok = (err == WEBP_MUX_OK);
-  if (!ok || !(features & ANIMATION_FLAG)) goto End;
-
-  err = WebPMuxGetAnimationParams(mux, &new_params);
-  ok = (err == WEBP_MUX_OK);
-  if (ok) {
-    new_params.loop_count = loop_count;
-    err = WebPMuxSetAnimationParams(mux, &new_params);
-    ok = (err == WEBP_MUX_OK);
-  }
-  if (ok) {
-    WebPDataClear(webp_data);
-    err = WebPMuxAssemble(mux, webp_data);
-    ok = (err == WEBP_MUX_OK);
-  }
-
- End:
-  WebPMuxDelete(mux);
-  if (!ok) {
-    fprintf(stderr, "Error during loop-count setting\n");
-  }
-  return ok;
-}
-
-//------------------------------------------------------------------------------
-
-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 loop_count = 0;
-  int width = 0, height = 0;
-  WebPAnimEncoderOptions anim_config;
-  WebPConfig config;
-  WebPPicture pic;
-  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");
-    ok = 0;
-    goto End;
-  }
-
-  // 1st pass of option parsing
-  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 = (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);
-      } else if (!strcmp(argv[c], "-kmax") && c + 1 < argc) {
-        argv[c] = NULL;
-        anim_config.kmax = ExUtilGetInt(argv[++c], 0, &parse_error);
-      } else if (!strcmp(argv[c], "-loop") && c + 1 < argc) {
-        argv[c] = NULL;
-        loop_count = ExUtilGetInt(argv[++c], 0, &parse_error);
-        if (loop_count < 0) {
-          fprintf(stderr, "Invalid non-positive loop-count (%d)\n", loop_count);
-          parse_error = 1;
-        }
-      } else if (!strcmp(argv[c], "-min_size")) {
-        anim_config.minimize_size = 1;
-      } else if (!strcmp(argv[c], "-mixed")) {
-        anim_config.allow_mixed = 1;
-        config.lossless = 0;
-      } else if (!strcmp(argv[c], "-v")) {
-        verbose = 1;
-      } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
-        Help();
-        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;
-      }
-      ok = !parse_error;
-      if (!ok) goto End;
-      argv[c] = NULL;   // mark option as 'parsed' during 1st pass
-    } else {
-      have_input |= 1;
-    }
-  }
-  if (!have_input) {
-    fprintf(stderr, "No input file(s) for generating animation!\n");
-    goto End;
-  }
-
-  // image-reading pass
-  pic_num = 0;
-  config.lossless = 1;
-  for (c = 0; ok && c < argc; ++c) {
-    if (argv[c] == NULL) continue;
-    if (argv[c][0] == '-') {    // parse local options
-      int parse_error = 0;
-      if (!strcmp(argv[c], "-lossy")) {
-        if (!anim_config.allow_mixed) config.lossless = 0;
-      } else if (!strcmp(argv[c], "-lossless")) {
-        if (!anim_config.allow_mixed) config.lossless = 1;
-      } else if (!strcmp(argv[c], "-q") && c + 1 < argc) {
-        config.quality = ExUtilGetFloat(argv[++c], &parse_error);
-      } else if (!strcmp(argv[c], "-m") && c + 1 < argc) {
-        config.method = ExUtilGetInt(argv[++c], 0, &parse_error);
-      } else if (!strcmp(argv[c], "-d") && c + 1 < argc) {
-        duration = ExUtilGetInt(argv[++c], 0, &parse_error);
-        if (duration <= 0) {
-          fprintf(stderr, "Invalid negative duration (%d)\n", duration);
-          parse_error = 1;
-        }
-      } else {
-        parse_error = 1;   // shouldn't be here.
-        fprintf(stderr, "Unknown option [%s]\n", argv[c]);
-      }
-      ok = !parse_error;
-      if (!ok) goto End;
-      continue;
-    }
-
-    if (ok) {
-      ok = WebPValidateConfig(&config);
-      if (!ok) {
-        fprintf(stderr, "Invalid configuration.\n");
-        goto End;
-      }
-    }
-
-    // read next input image
-    pic.use_argb = 1;
-    ok = ReadImage((const char*)GET_WARGV_SHIFTED(argv, c), &pic);
-    if (!ok) goto End;
-
-    if (enc == NULL) {
-      width  = pic.width;
-      height = pic.height;
-      enc = WebPAnimEncoderNew(width, height, &anim_config);
-      ok = (enc != NULL);
-      if (!ok) {
-        fprintf(stderr, "Could not create WebPAnimEncoder object.\n");
-      }
-    }
-
-    if (ok) {
-      ok = (width == pic.width && height == pic.height);
-      if (!ok) {
-        fprintf(stderr, "Frame #%d dimension mismatched! "
-                        "Got %d x %d. Was expecting %d x %d.\n",
-                pic_num, pic.width, pic.height, width, height);
-      }
-    }
-
-    if (ok) {
-      ok = WebPAnimEncoderAdd(enc, &pic, timestamp_ms, &config);
-      if (!ok) {
-        fprintf(stderr, "Error while adding frame #%d\n", pic_num);
-      }
-    }
-    WebPPictureFree(&pic);
-    if (!ok) goto End;
-
-    if (verbose) {
-      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;
-  }
-
-  // add a last fake frame to signal the last duration
-  ok = ok && WebPAnimEncoderAdd(enc, NULL, timestamp_ms, NULL);
-  ok = ok && WebPAnimEncoderAssemble(enc, &webp_data);
-  if (!ok) {
-    fprintf(stderr, "Error during final animation assembly.\n");
-  }
-
- End:
-  // free resources
-  WebPAnimEncoderDelete(enc);
-
-  if (ok && loop_count > 0) {  // Re-mux to add loop count.
-    ok = SetLoopCount(loop_count, &webp_data);
-  }
-
-  if (ok) {
-    if (output != NULL) {
-      ok = ImgIoUtilWriteFile(output, webp_data.bytes, webp_data.size);
-      if (ok) WFPRINTF(stderr, "output file: %s     ", (const W_CHAR*)output);
-    } else {
-      fprintf(stderr, "[no output file specified]   ");
-    }
-  }
-
-  if (ok) {
-    fprintf(stderr, "[%d frames, %u bytes].\n",
-            pic_num, (unsigned int)webp_data.size);
-  }
-  WebPDataClear(&webp_data);
-  ExUtilDeleteCommandLineArguments(&cmd_args);
-  FREE_WARGV_AND_RETURN(ok ? 0 : 1);
-}

examples/jpegdec.c

@@ -25,7 +25,7 @@
 #include <string.h>
 
 #include "webp/encode.h"
-#include "./imageio_util.h"
+#include "./example_util.h"
 #include "./metadata.h"
 
 // -----------------------------------------------------------------------------
@@ -206,7 +206,6 @@ struct my_error_mgr {
 
 static void my_error_exit(j_common_ptr dinfo) {
   struct my_error_mgr* myerr = (struct my_error_mgr*)dinfo->err;
-  fprintf(stderr, "libjpeg error: ");
   dinfo->err->output_message(dinfo);
   longjmp(myerr->setjmp_buffer, 1);
 }
@@ -267,8 +266,6 @@ int ReadJPEG(const uint8_t* const data, size_t data_size,
   JSAMPROW buffer[1];
   JPEGReadContext ctx;
 
-  if (data == NULL || data_size == 0 || pic == NULL) return 0;
-
   (void)keep_alpha;
   memset(&ctx, 0, sizeof(ctx));
   ctx.data = data;
@@ -305,18 +302,18 @@ int ReadJPEG(const uint8_t* const data, size_t data_size,
 
   if (stride != (int)stride ||
       !ImgIoUtilCheckSizeArgumentsOverflow(stride, height)) {
-    goto Error;
+    goto End;
   }
 
   rgb = (uint8_t*)malloc((size_t)stride * height);
   if (rgb == NULL) {
-    goto Error;
+    goto End;
   }
   buffer[0] = (JSAMPLE*)rgb;
 
   while (dinfo.output_scanline < dinfo.output_height) {
     if (jpeg_read_scanlines((j_decompress_ptr)&dinfo, buffer, 1) != 1) {
-      goto Error;
+      goto End;
     }
     buffer[0] += stride;
   }

examples/jpegdec.h

@@ -9,9 +9,10 @@
 //
 // JPEG decode.
 
-#ifndef WEBP_IMAGEIO_JPEGDEC_H_
-#define WEBP_IMAGEIO_JPEGDEC_H_
+#ifndef WEBP_EXAMPLES_JPEGDEC_H_
+#define WEBP_EXAMPLES_JPEGDEC_H_
 
+#include <stdio.h>
 #include "webp/types.h"
 
 #ifdef __cplusplus
@@ -34,4 +35,4 @@ int ReadJPEG(const uint8_t* const data, size_t data_size,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_IMAGEIO_JPEGDEC_H_
+#endif  // WEBP_EXAMPLES_JPEGDEC_H_

examples/metadata.h

@@ -10,8 +10,8 @@
 //  Metadata types and functions.
 //
 
-#ifndef WEBP_IMAGEIO_METADATA_H_
-#define WEBP_IMAGEIO_METADATA_H_
+#ifndef WEBP_EXAMPLES_METADATA_H_
+#define WEBP_EXAMPLES_METADATA_H_
 
 #include "webp/types.h"
 
@@ -44,4 +44,4 @@ int MetadataCopy(const char* metadata, size_t metadata_len,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_IMAGEIO_METADATA_H_
+#endif  // WEBP_EXAMPLES_METADATA_H_

examples/pngdec.c

@@ -18,45 +18,20 @@
 #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>
 #include <string.h>
 
 #include "webp/encode.h"
-#include "./imageio_util.h"
+#include "./example_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,
@@ -196,10 +171,11 @@ static int ExtractMetadataFromPNG(png_structp png,
     {
       png_charp name;
       int comp_type;
-#if LOCAL_PNG_PREREQ(1,5)
-      png_bytep profile;
-#else
+#if ((PNG_LIBPNG_VER_MAJOR << 8) | PNG_LIBPNG_VER_MINOR << 0) < \
+    ((1 << 8) | (5 << 0))
       png_charp profile;
+#else  // >= libpng 1.5.0
+      png_bytep profile;
 #endif
       png_uint_32 len;
 
@@ -209,6 +185,7 @@ static int ExtractMetadataFromPNG(png_structp png,
       }
     }
   }
+
   return 1;
 }
 
@@ -243,13 +220,10 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
   int64_t stride;
   uint8_t* volatile rgb = NULL;
 
-  if (data == NULL || data_size == 0 || pic == NULL) return 0;
-
   context.data = data;
   context.data_size = data_size;
 
-  png = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL,
-                                 NULL, MallocFunc, FreeFunc);
+  png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
   if (png == NULL) goto End;
 
   png_set_error_fn(png, 0, error_function, NULL);
@@ -289,16 +263,6 @@ 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;
@@ -316,10 +280,9 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
   rgb = (uint8_t*)malloc((size_t)stride * height);
   if (rgb == NULL) goto Error;
   for (p = 0; p < num_passes; ++p) {
-    png_bytep row = rgb;
     for (y = 0; y < height; ++y) {
+      png_bytep row = (png_bytep)(rgb + y * stride);
       png_read_rows(png, &row, NULL, 1);
-      row += stride;
     }
   }
   png_read_end(png, end_info);

examples/pngdec.h

@@ -9,8 +9,8 @@
 //
 // PNG decode.
 
-#ifndef WEBP_IMAGEIO_PNGDEC_H_
-#define WEBP_IMAGEIO_PNGDEC_H_
+#ifndef WEBP_EXAMPLES_PNGDEC_H_
+#define WEBP_EXAMPLES_PNGDEC_H_
 
 #include "webp/types.h"
 
@@ -34,4 +34,4 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_IMAGEIO_PNGDEC_H_
+#endif  // WEBP_EXAMPLES_PNGDEC_H_

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/tiffdec.c

@@ -15,7 +15,6 @@
 #include "webp/config.h"
 #endif
 
-#include <limits.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -23,7 +22,7 @@
 #include <tiffio.h>
 
 #include "webp/encode.h"
-#include "./imageio_util.h"
+#include "./example_util.h"
 #include "./metadata.h"
 
 static const struct {
@@ -108,7 +107,7 @@ static void MyUnmapFile(thandle_t opaque, void* base, toff_t size) {
 static tsize_t MyRead(thandle_t opaque, void* dst, tsize_t size) {
   MyData* const my_data = (MyData*)opaque;
   if (my_data->pos + size > my_data->size) {
-    size = (tsize_t)(my_data->size - my_data->pos);
+    size = my_data->size - my_data->pos;
   }
   if (size > 0) {
     memcpy(dst, my_data->data + my_data->pos, size);
@@ -117,61 +116,19 @@ static tsize_t MyRead(thandle_t opaque, void* dst, tsize_t size) {
   return size;
 }
 
-// Unmultiply Argb data. Taken from dsp/alpha_processing
-// (we don't want to force a dependency to a libdspdec library).
-#define MFIX 24    // 24bit fixed-point arithmetic
-#define HALF ((1u << MFIX) >> 1)
-
-static uint32_t Unmult(uint8_t x, uint32_t mult) {
-  const uint32_t v = (x * mult + HALF) >> MFIX;
-  return (v > 255u) ? 255u : v;
-}
-
-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) {
-    const uint32_t alpha = ptr[3];
-    if (alpha < 255) {
-      if (alpha == 0) {   // alpha == 0
-        ptr[0] = ptr[1] = ptr[2] = 0;
-      } else {
-        const uint32_t scale = GetScale(alpha);
-        ptr[0] = Unmult(ptr[0], scale);
-        ptr[1] = Unmult(ptr[1], scale);
-        ptr[2] = Unmult(ptr[2], scale);
-      }
-    }
-  }
-}
-
 int ReadTIFF(const uint8_t* const data, size_t data_size,
              WebPPicture* const pic, int keep_alpha,
              Metadata* const metadata) {
   MyData my_data = { data, (toff_t)data_size, 0 };
-  TIFF* tif;
-  uint32_t width, height;
-  uint16_t samples_per_px = 0;
-  uint16_t extra_samples = 0;
-  uint16_t* extra_samples_ptr = NULL;
-  uint32_t* raster;
+  TIFF* const tif = TIFFClientOpen("Memory", "r", &my_data,
+                                   MyRead, MyRead, MySeek, MyClose,
+                                   MySize, MyMapFile, MyUnmapFile);
+  uint32 width, height;
+  uint32* raster;
   int64_t alloc_size;
   int ok = 0;
   tdir_t dircount;
 
-  if (data == NULL || data_size == 0 || data_size > INT_MAX || pic == NULL) {
-    return 0;
-  }
-
-  tif = TIFFClientOpen("Memory", "r", &my_data,
-                       MyRead, MyRead, MySeek, MyClose,
-                       MySize, MyMapFile, MyUnmapFile);
   if (tif == NULL) {
     fprintf(stderr, "Error! Cannot parse TIFF file\n");
     return 0;
@@ -183,27 +140,17 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
                     "Only the first will be used, %d will be ignored.\n",
                     dircount - 1);
   }
-  if (!TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &samples_per_px)) {
-    fprintf(stderr, "Error! Cannot retrieve TIFF samples-per-pixel info.\n");
-    goto End;
-  }
-  if (samples_per_px < 3 || samples_per_px > 4) goto End;  // not supported
 
   if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) &&
         TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))) {
     fprintf(stderr, "Error! Cannot retrieve TIFF image dimensions.\n");
     goto End;
   }
+
   if (!ImgIoUtilCheckSizeArgumentsOverflow((uint64_t)width * height,
                                            sizeof(*raster))) {
     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");
-    goto End;
-  }
-
   // _Tiffmalloc uses a signed type for size.
   alloc_size = (int64_t)((uint64_t)width * height * sizeof(*raster));
   if (alloc_size < 0 || alloc_size != (tsize_t)alloc_size) goto End;
@@ -219,16 +166,6 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
 #ifdef WORDS_BIGENDIAN
       TIFFSwabArrayOfLong(raster, width * height);
 #endif
-      // if we have an alpha channel, we must un-multiply from rgbA to RGBA
-      if (extra_samples == 1 && extra_samples_ptr != NULL &&
-          extra_samples_ptr[0] == EXTRASAMPLE_ASSOCALPHA) {
-        uint32_t y;
-        uint8_t* tmp = (uint8_t*)raster;
-        for (y = 0; y < height; ++y) {
-          MultARGBRow(tmp, width);
-          tmp += stride;
-        }
-      }
       ok = keep_alpha
          ? WebPPictureImportRGBA(pic, (const uint8_t*)raster, stride)
          : WebPPictureImportRGBX(pic, (const uint8_t*)raster, stride);

examples/tiffdec.h

@@ -9,8 +9,8 @@
 //
 // TIFF decode.
 
-#ifndef WEBP_IMAGEIO_TIFFDEC_H_
-#define WEBP_IMAGEIO_TIFFDEC_H_
+#ifndef WEBP_EXAMPLES_TIFFDEC_H_
+#define WEBP_EXAMPLES_TIFFDEC_H_
 
 #include "webp/types.h"
 
@@ -34,4 +34,4 @@ int ReadTIFF(const uint8_t* const data, size_t data_size,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_IMAGEIO_TIFFDEC_H_
+#endif  // WEBP_EXAMPLES_TIFFDEC_H_

examples/unicode.h

@@ -1,102 +0,0 @@
-// 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

@@ -1,75 +0,0 @@
-// 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

@@ -40,9 +40,7 @@
 #include "webp/decode.h"
 #include "webp/demux.h"
 
-#include "../examples/example_util.h"
-#include "../imageio/imageio_util.h"
-#include "./unicode.h"
+#include "./example_util.h"
 
 #if defined(_MSC_VER) && _MSC_VER < 1900
 #define snprintf _snprintf
@@ -55,9 +53,7 @@ static struct {
   int done;
   int decoding_error;
   int print_info;
-  int only_deltas;
   int use_color_profile;
-  int draw_anim_background_color;
 
   int canvas_width, canvas_height;
   int loop_count;
@@ -207,11 +203,6 @@ 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;
@@ -227,9 +218,6 @@ 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 */) {
@@ -257,23 +245,18 @@ 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') {
     kParams.print_info = 1 - kParams.print_info;
+    // TODO(skal): handle refresh of animation's last-frame too. It's quite
+    // more involved though (need to save the previous frame).
     if (!kParams.has_animation) ClearPreviousFrame();
     glutPostRedisplay();
-  } else if (key == 'd') {
-    kParams.only_deltas = 1 - kParams.only_deltas;
-    glutPostRedisplay();
   }
 }
 
 static void HandleReshape(int width, int height) {
-  // Note: reshape doesn't preserve aspect ratio, and might
-  // be handling larger-than-screen pictures incorrectly.
+  // TODO(skal): should we preserve aspect ratio?
+  // Also: handle larger-than-screen pictures correctly.
   glViewport(0, 0, width, height);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
@@ -293,7 +276,7 @@ static void PrintString(const char* const text) {
 }
 
 static float GetColorf(uint32_t color, int shift) {
-  return ((color >> shift) & 0xff) / 255.f;
+  return (color >> shift) / 255.f;
 }
 
 static void DrawCheckerBoard(void) {
@@ -316,43 +299,6 @@ 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;
@@ -368,22 +314,37 @@ static void HandleDisplay(void) {
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   glPixelStorei(GL_UNPACK_ROW_LENGTH, pic->u.RGBA.stride / 4);
 
-  if (kParams.only_deltas) {
-    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 ||
+      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;
     if (prev->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
       // Clear the previous frame rectangle.
-      DrawBackgroundScissored(prev->x_offset, prev->y_offset, prev->width,
-                              prev->height);
-    }
-    if (curr->blend_method == WEBP_MUX_NO_BLEND) {
+      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 and then alpha-blending against it.
-      DrawBackgroundScissored(curr->x_offset, curr->y_offset, curr->width,
-                              curr->height);
+      // 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;
     }
+    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;
@@ -410,36 +371,13 @@ static void HandleDisplay(void) {
     }
   }
   glPopMatrix();
-#if defined(__APPLE__) || defined(_WIN32)
   glFlush();
-#else
-  glutSwapBuffers();
-#endif
 }
 
 static void StartDisplay(void) {
-  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)
+  const int width = kParams.canvas_width;
+  const int height = kParams.canvas_height;
   glutInitDisplayMode(GLUT_RGBA);
-#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);
@@ -448,35 +386,36 @@ static void StartDisplay(void) {
   glutKeyboardFunc(HandleKey);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glEnable(GL_BLEND);
-  glClearColor(0, 0, 0, 0);  // window will be cleared to black (no blend)
-  DrawBackground();
+  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();
 }
 
 //------------------------------------------------------------------------------
 // Main
 
 static void Help(void) {
-  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"
-      "  -noicc ....... don't use the icc profile if present\n"
-      "  -nofancy ..... don't use the fancy YUV420 upscaler\n"
-      "  -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");
+  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"
+         "  -noicc ....... don't use the icc profile if present\n"
+         "  -nofancy ..... don't use the fancy YUV420 upscaler\n"
+         "  -nofilter .... disable in-loop filtering\n"
+         "  -dither <int>  dithering strength (0..100), default=50\n"
+         "  -noalphadither disable alpha plane dithering\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"
+         "  'i' ................ overlay file information\n"
+         "  'q' / 'Q' / ESC .... quit\n"
+        );
 }
 
 int main(int argc, char *argv[]) {
@@ -484,23 +423,19 @@ 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");
-    FREE_WARGV_AND_RETURN(-1);
+    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();
-      FREE_WARGV_AND_RETURN(0);
+      return 0;
     } else if (!strcmp(argv[c], "-noicc")) {
       kParams.use_color_profile = 0;
     } else if (!strcmp(argv[c], "-nofancy")) {
@@ -509,8 +444,6 @@ 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);
@@ -523,34 +456,34 @@ 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);
-      FREE_WARGV_AND_RETURN(0);
+      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 = (const char*)GET_WARGV(argv, ++c);
+      if (c < argc - 1) kParams.file_name = argv[++c];
       break;
     } else if (argv[c][0] == '-') {
       printf("Unknown option '%s'\n", argv[c]);
       Help();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     } else {
-      kParams.file_name = (const char*)GET_WARGV(argv, c);
+      kParams.file_name = argv[c];
     }
 
     if (parse_error) {
       Help();
-      FREE_WARGV_AND_RETURN(-1);
+      return -1;
     }
   }
 
   if (kParams.file_name == NULL) {
     printf("missing input file!!\n");
     Help();
-    FREE_WARGV_AND_RETURN(0);
+    return 0;
   }
 
-  if (!ImgIoUtilReadFile(kParams.file_name,
-                         &kParams.data.bytes, &kParams.data.size)) {
+  if (!ExUtilReadFile(kParams.file_name,
+                      &kParams.data.bytes, &kParams.data.size)) {
     goto Error;
   }
 
@@ -565,6 +498,10 @@ int main(int argc, char *argv[]) {
     goto Error;
   }
 
+  if (WebPDemuxGetI(kParams.dmux, WEBP_FF_FORMAT_FLAGS) & FRAGMENTS_FLAG) {
+    fprintf(stderr, "Image fragments are not supported for now!\n");
+    goto Error;
+  }
   kParams.canvas_width = WebPDemuxGetI(kParams.dmux, WEBP_FF_CANVAS_WIDTH);
   kParams.canvas_height = WebPDemuxGetI(kParams.dmux, WEBP_FF_CANVAS_HEIGHT);
   if (kParams.print_info) {
@@ -621,11 +558,11 @@ int main(int argc, char *argv[]) {
 
   // Should only be reached when using FREEGLUT:
   ClearParams();
-  FREE_WARGV_AND_RETURN(0);
+  return 0;
 
  Error:
   ClearParams();
-  FREE_WARGV_AND_RETURN(-1);
+  return -1;
 }
 
 #else   // !WEBP_HAVE_GL

examples/webpdec.c

@@ -0,0 +1,95 @@
+// 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.
+// -----------------------------------------------------------------------------
+//
+// WebP decode.
+
+#include "./webpdec.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "webp/decode.h"
+#include "webp/encode.h"
+#include "./example_util.h"
+#include "./metadata.h"
+
+int ReadWebP(const uint8_t* const data, size_t data_size,
+             WebPPicture* const pic,
+             int keep_alpha, Metadata* const metadata) {
+  int ok = 0;
+  VP8StatusCode status = VP8_STATUS_OK;
+  WebPDecoderConfig config;
+  WebPDecBuffer* const output_buffer = &config.output;
+  WebPBitstreamFeatures* const bitstream = &config.input;
+
+  // 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;
+  }
+
+  status = WebPGetFeatures(data, data_size, bitstream);
+  if (status != VP8_STATUS_OK) {
+    ExUtilPrintWebPError("input data", status);
+    return 0;
+  }
+  {
+    const int has_alpha = keep_alpha && bitstream->has_alpha;
+    if (pic->use_argb) {
+      output_buffer->colorspace = has_alpha ? MODE_RGBA : MODE_RGB;
+    } else {
+      output_buffer->colorspace = has_alpha ? MODE_YUVA : MODE_YUV;
+    }
+
+    status = ExUtilDecodeWebP(data, data_size, 0, &config);
+    if (status == VP8_STATUS_OK) {
+      pic->width = output_buffer->width;
+      pic->height = output_buffer->height;
+      if (pic->use_argb) {
+        const uint8_t* const rgba = output_buffer->u.RGBA.rgba;
+        const int stride = output_buffer->u.RGBA.stride;
+        ok = has_alpha ? WebPPictureImportRGBA(pic, rgba, stride)
+                       : WebPPictureImportRGB(pic, rgba, stride);
+      } else {
+        pic->colorspace = has_alpha ? WEBP_YUV420A : WEBP_YUV420;
+        ok = WebPPictureAlloc(pic);
+        if (!ok) {
+          status = VP8_STATUS_OUT_OF_MEMORY;
+        } else {
+          const WebPYUVABuffer* const yuva = &output_buffer->u.YUVA;
+          const int uv_width = (pic->width + 1) >> 1;
+          const int uv_height = (pic->height + 1) >> 1;
+          ExUtilCopyPlane(yuva->y, yuva->y_stride,
+                          pic->y, pic->y_stride, pic->width, pic->height);
+          ExUtilCopyPlane(yuva->u, yuva->u_stride,
+                          pic->u, pic->uv_stride, uv_width, uv_height);
+          ExUtilCopyPlane(yuva->v, yuva->v_stride,
+                          pic->v, pic->uv_stride, uv_width, uv_height);
+          if (has_alpha) {
+            ExUtilCopyPlane(yuva->a, yuva->a_stride,
+                            pic->a, pic->a_stride, pic->width, pic->height);
+          }
+        }
+      }
+    }
+  }
+
+  if (status != VP8_STATUS_OK) {
+    ExUtilPrintWebPError("input data", status);
+  }
+
+  WebPFreeDecBuffer(output_buffer);
+  return ok;
+}
+
+// -----------------------------------------------------------------------------

examples/webpdec.h

@@ -0,0 +1,37 @@
+// 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.
+// -----------------------------------------------------------------------------
+//
+// WebP decode.
+
+#ifndef WEBP_EXAMPLES_WEBPDEC_H_
+#define WEBP_EXAMPLES_WEBPDEC_H_
+
+#include "webp/types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct Metadata;
+struct WebPPicture;
+
+// Reads a WebP from 'in_file', returning the decoded output in 'pic'.
+// Output is RGBA or YUVA, depending on pic->use_argb value.
+// If 'keep_alpha' is true and the WebP has an alpha channel, the output is RGBA
+// or YUVA. Otherwise, alpha channel is dropped and output is RGB or YUV.
+// Returns true on success.
+int ReadWebP(const uint8_t* const data, size_t data_size,
+             struct WebPPicture* const pic,
+             int keep_alpha, struct Metadata* const metadata);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  // WEBP_EXAMPLES_WEBPDEC_H_

examples/webpmux.c

@@ -28,6 +28,7 @@
     webpmux -set xmp image_metadata.xmp in.webp -o out_xmp_container.webp
 
   Extract relevant data from WebP container file:
+    webpmux -get frgm n in.webp -o out_fragment.webp
     webpmux -get frame n in.webp -o out_frame.webp
     webpmux -get icc in.webp -o image_profile.icc
     webpmux -get exif in.webp -o image_metadata.exif
@@ -38,16 +39,10 @@
     webpmux -strip exif in.webp -o out.webp
     webpmux -strip xmp in.webp -o out.webp
 
-  Change duration of frame intervals:
-    webpmux -duration 150 in.webp -o out.webp
-    webpmux -duration 33,2 in.webp -o out.webp
-    webpmux -duration 200,10,0 -duration 150,6,50 in.webp -o out.webp
-
   Misc:
     webpmux -info in.webp
     webpmux [ -h | -help ]
     webpmux -version
-    webpmux argument_file_name
 */
 
 #ifdef HAVE_CONFIG_H
@@ -60,9 +55,7 @@
 #include <string.h>
 #include "webp/decode.h"
 #include "webp/mux.h"
-#include "../examples/example_util.h"
-#include "../imageio/imageio_util.h"
-#include "./unicode.h"
+#include "./example_util.h"
 
 //------------------------------------------------------------------------------
 // Config object to parse command-line arguments.
@@ -73,8 +66,7 @@ typedef enum {
   ACTION_SET,
   ACTION_STRIP,
   ACTION_INFO,
-  ACTION_HELP,
-  ACTION_DURATION
+  ACTION_HELP
 } ActionType;
 
 typedef enum {
@@ -96,40 +88,42 @@ typedef enum {
   FEATURE_XMP,
   FEATURE_ICCP,
   FEATURE_ANMF,
-  FEATURE_DURATION,
+  FEATURE_FRGM,
   LAST_FEATURE
 } FeatureType;
 
 static const char* const kFourccList[LAST_FEATURE] = {
-  NULL, "EXIF", "XMP ", "ICCP", "ANMF"
+  NULL, "EXIF", "XMP ", "ICCP", "ANMF", "FRGM"
 };
 
 static const char* const kDescriptions[LAST_FEATURE] = {
   NULL, "EXIF metadata", "XMP metadata", "ICC profile",
-  "Animation frame"
+  "Animation frame", "Image fragment"
 };
 
 typedef struct {
-  CommandLineArguments cmd_args_;
-
-  ActionType action_type_;
-  const char* input_;
-  const char* output_;
   FeatureType type_;
   FeatureArg* args_;
   int arg_count_;
-} Config;
+} Feature;
+
+typedef struct {
+  ActionType action_type_;
+  const char* input_;
+  const char* output_;
+  Feature feature_;
+} WebPMuxConfig;
 
 //------------------------------------------------------------------------------
 // Helper functions.
 
-static int CountOccurrences(const CommandLineArguments* const args,
-                            const char* const arg) {
+static int CountOccurrences(const char* arglist[], int list_length,
+                            const char* arg) {
   int i;
   int num_occurences = 0;
 
-  for (i = 0; i < args->argc_; ++i) {
-    if (!strcmp(args->argv_[i], arg)) {
+  for (i = 0; i < list_length; ++i) {
+    if (!strcmp(arglist[i], arg)) {
       ++num_occurences;
     }
   }
@@ -188,6 +182,7 @@ static WebPMuxError DisplayInfo(const WebPMux* mux) {
   printf("Canvas size: %d x %d\n", width, height);
 
   err = WebPMuxGetFeatures(mux, &flag);
+  if (flag & FRAGMENTS_FLAG) err = WEBP_MUX_INVALID_ARGUMENT;
   RETURN_IF_ERROR("Failed to retrieve features\n");
 
   if (flag == 0) {
@@ -198,22 +193,26 @@ static WebPMuxError DisplayInfo(const WebPMux* mux) {
   // Print the features present.
   printf("Features present:");
   if (flag & ANIMATION_FLAG) printf(" animation");
+  if (flag & FRAGMENTS_FLAG) printf(" image fragments");
   if (flag & ICCP_FLAG)      printf(" ICC profile");
   if (flag & EXIF_FLAG)      printf(" EXIF metadata");
   if (flag & XMP_FLAG)       printf(" XMP metadata");
   if (flag & ALPHA_FLAG)     printf(" transparency");
   printf("\n");
 
-  if (flag & ANIMATION_FLAG) {
-    const WebPChunkId id = WEBP_CHUNK_ANMF;
-    const char* const type_str = "frame";
+  if ((flag & ANIMATION_FLAG) || (flag & FRAGMENTS_FLAG)) {
+    const int is_anim = !!(flag & ANIMATION_FLAG);
+    const WebPChunkId id = is_anim ? WEBP_CHUNK_ANMF : WEBP_CHUNK_FRGM;
+    const char* const type_str = is_anim ? "frame" : "fragment";
     int nFrames;
 
-    WebPMuxAnimParams params;
-    err = WebPMuxGetAnimationParams(mux, &params);
-    assert(err == WEBP_MUX_OK);
-    printf("Background color : 0x%.8X  Loop Count : %d\n",
-           params.bgcolor, params.loop_count);
+    if (is_anim) {
+      WebPMuxAnimParams params;
+      err = WebPMuxGetAnimationParams(mux, &params);
+      assert(err == WEBP_MUX_OK);
+      printf("Background color : 0x%.8X  Loop Count : %d\n",
+             params.bgcolor, params.loop_count);
+    }
 
     err = WebPMuxNumChunks(mux, id, &nFrames);
     assert(err == WEBP_MUX_OK);
@@ -222,8 +221,8 @@ static WebPMuxError DisplayInfo(const WebPMux* mux) {
     if (nFrames > 0) {
       int i;
       printf("No.: width height alpha x_offset y_offset ");
-      printf("duration   dispose blend ");
-      printf("image_size  compression\n");
+      if (is_anim) printf("duration   dispose blend ");
+      printf("image_size\n");
       for (i = 1; i <= nFrames; i++) {
         WebPMuxFrameInfo frame;
         err = WebPMuxGetFrame(mux, i, &frame);
@@ -236,7 +235,7 @@ static WebPMuxError DisplayInfo(const WebPMux* mux) {
           printf("%3d: %5d %5d %5s %8d %8d ", i, features.width,
                  features.height, features.has_alpha ? "yes" : "no",
                  frame.x_offset, frame.y_offset);
-          {
+          if (is_anim) {
             const char* const dispose =
                 (frame.dispose_method == WEBP_MUX_DISPOSE_NONE) ? "none"
                                                                 : "background";
@@ -244,10 +243,7 @@ static WebPMuxError DisplayInfo(const WebPMux* mux) {
                 (frame.blend_method == WEBP_MUX_BLEND) ? "yes" : "no";
             printf("%8d %10s %5s ", frame.duration, dispose, blend);
           }
-          printf("%10d %11s\n", (int)frame.bitstream.size,
-                 (features.format == 1) ? "lossy" :
-                 (features.format == 2) ? "lossless" :
-                                          "undefined");
+          printf("%10d\n", (int)frame.bitstream.size);
         }
         WebPDataClear(&frame.bitstream);
         RETURN_IF_ERROR3("Failed to retrieve %s#%d\n", type_str, i);
@@ -276,7 +272,7 @@ static WebPMuxError DisplayInfo(const WebPMux* mux) {
     printf("Size of the XMP metadata: %d\n", (int)xmp.size);
   }
 
-  if ((flag & ALPHA_FLAG) && !(flag & ANIMATION_FLAG)) {
+  if ((flag & ALPHA_FLAG) && !(flag & (ANIMATION_FLAG | FRAGMENTS_FLAG))) {
     WebPMuxFrameInfo image;
     err = WebPMuxGetFrame(mux, 1, &image);
     if (err == WEBP_MUX_OK) {
@@ -292,8 +288,6 @@ static WebPMuxError DisplayInfo(const WebPMux* mux) {
 static void PrintHelp(void) {
   printf("Usage: webpmux -get GET_OPTIONS INPUT -o OUTPUT\n");
   printf("       webpmux -set SET_OPTIONS INPUT -o OUTPUT\n");
-  printf("       webpmux -duration DURATION_OPTIONS [-duration ...]\n");
-  printf("               INPUT -o OUTPUT\n");
   printf("       webpmux -strip STRIP_OPTIONS INPUT -o OUTPUT\n");
   printf("       webpmux -frame FRAME_OPTIONS [-frame...] [-loop LOOP_COUNT]"
          "\n");
@@ -301,7 +295,6 @@ 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");
@@ -321,18 +314,6 @@ static void PrintHelp(void) {
   printf("             'file.exif' contains the EXIF metadata to be set\n");
   printf("             'file.xmp' contains the XMP metadata to be set\n");
 
-  printf("\n");
-  printf("DURATION_OPTIONS:\n");
-  printf(" Set duration of selected frames:\n");
-  printf("   duration            set duration for each frames\n");
-  printf("   duration,frame      set duration of a particular frame\n");
-  printf("   duration,start,end  set duration of frames in the\n");
-  printf("                        interval [start,end])\n");
-  printf("   where: 'duration' is the duration in milliseconds\n");
-  printf("          'start' is the start frame index\n");
-  printf("          'end' is the inclusive end frame index\n");
-  printf("           The special 'end' value '0' means: last frame.\n");
-
   printf("\n");
   printf("STRIP_OPTIONS:\n");
   printf(" Strip color profile/metadata:\n");
@@ -370,10 +351,6 @@ 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) {
@@ -384,32 +361,40 @@ 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 (!ExUtilReadFile(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 (!ExUtilReadFileToWebPData(filename, &bitstream)) return 0;
+  if (!ReadFileToWebPData(filename, &bitstream)) return 0;
   *mux = WebPMuxCreate(&bitstream, 1);
-  WebPDataClear(&bitstream);
+  free((void*)bitstream.bytes);
   if (*mux != NULL) return 1;
-  WFPRINTF(stderr, "Failed to create mux object from file %s.\n",
-           (const W_CHAR*)filename);
+  fprintf(stderr, "Failed to create mux object from file %s.\n", filename);
   return 0;
 }
 
 static int WriteData(const char* filename, const WebPData* const webpdata) {
   int ok = 0;
-  FILE* fout = WSTRCMP(filename, "-") ? WFOPEN(filename, "wb")
-                                      : ImgIoUtilSetBinaryMode(stdout);
+  FILE* fout = strcmp(filename, "-") ? fopen(filename, "wb")
+                                     : ExUtilSetBinaryMode(stdout);
   if (fout == NULL) {
-    WFPRINTF(stderr, "Error opening output WebP file %s!\n",
-             (const W_CHAR*)filename);
+    fprintf(stderr, "Error opening output WebP file %s!\n", filename);
     return 0;
   }
   if (fwrite(webpdata->bytes, webpdata->size, 1, fout) != 1) {
-    WFPRINTF(stderr, "Error writing file %s!\n", (const W_CHAR*)filename);
+    fprintf(stderr, "Error writing file %s!\n", filename);
   } else {
-    WFPRINTF(stderr, "Saved file %s (%d bytes)\n",
-             (const W_CHAR*)filename, (int)webpdata->size);
+    fprintf(stderr, "Saved file %s (%d bytes)\n",
+            filename, (int)webpdata->size);
     ok = 1;
   }
   if (fout != stdout) fclose(fout);
@@ -429,45 +414,6 @@ static int WriteWebP(WebPMux* const mux, const char* filename) {
   return ok;
 }
 
-static WebPMux* DuplicateMuxHeader(const WebPMux* const mux) {
-  WebPMux* new_mux = WebPMuxNew();
-  WebPMuxAnimParams p;
-  WebPMuxError err;
-  int i;
-  int ok = 1;
-
-  if (new_mux == NULL) return NULL;
-
-  err = WebPMuxGetAnimationParams(mux, &p);
-  if (err == WEBP_MUX_OK) {
-    err = WebPMuxSetAnimationParams(new_mux, &p);
-    if (err != WEBP_MUX_OK) {
-      ERROR_GOTO2("Error (%s) handling animation params.\n",
-                  ErrorString(err), End);
-    }
-  } else {
-    /* it might not be an animation. Just keep moving. */
-  }
-
-  for (i = 1; i <= 3; ++i) {
-    WebPData metadata;
-    err = WebPMuxGetChunk(mux, kFourccList[i], &metadata);
-    if (err == WEBP_MUX_OK && metadata.size > 0) {
-      err = WebPMuxSetChunk(new_mux, kFourccList[i], &metadata, 1);
-      if (err != WEBP_MUX_OK) {
-        ERROR_GOTO1("Error transferring metadata in DuplicateMux().", End);
-      }
-    }
-  }
-
- End:
-  if (!ok) {
-    WebPMuxDelete(new_mux);
-    new_mux = NULL;
-  }
-  return new_mux;
-}
-
 static int ParseFrameArgs(const char* args, WebPMuxFrameInfo* const info) {
   int dispose_method, dummy;
   char plus_minus, blend_method;
@@ -503,6 +449,13 @@ static int ParseFrameArgs(const char* args, WebPMuxFrameInfo* const info) {
   return 1;
 }
 
+static int ParseFragmentArgs(const char* args, WebPMuxFrameInfo* const info) {
+  const int ok =
+      (sscanf(args, "+%d+%d", &info->x_offset, &info->y_offset) == 2);
+  if (ok) WarnAboutOddOffset(info);
+  return ok;
+}
+
 static int ParseBgcolorArgs(const char* args, uint32_t* const bgcolor) {
   uint32_t a, r, g, b;
   if (sscanf(args, "%u,%u,%u,%u", &a, &r, &g, &b) != 4) return 0;
@@ -514,10 +467,9 @@ static int ParseBgcolorArgs(const char* args, uint32_t* const bgcolor) {
 //------------------------------------------------------------------------------
 // Clean-up.
 
-static void DeleteConfig(Config* const config) {
+static void DeleteConfig(WebPMuxConfig* config) {
   if (config != NULL) {
-    free(config->args_);
-    ExUtilDeleteCommandLineArguments(&config->cmd_args_);
+    free(config->feature_.args_);
     memset(config, 0, sizeof(*config));
   }
 }
@@ -529,39 +481,39 @@ static void DeleteConfig(Config* const 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(const CommandLineArguments* const cmd_args,
+static int ValidateCommandLine(int argc, const char* argv[],
                                int* num_feature_args) {
   int num_frame_args;
+  int num_frgm_args;
   int num_loop_args;
   int num_bgcolor_args;
-  int num_durations_args;
   int ok = 1;
 
   assert(num_feature_args != NULL);
   *num_feature_args = 0;
 
   // Simple checks.
-  if (CountOccurrences(cmd_args, "-get") > 1) {
+  if (CountOccurrences(argv, argc, "-get") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-get' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(cmd_args, "-set") > 1) {
+  if (CountOccurrences(argv, argc, "-set") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-set' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(cmd_args, "-strip") > 1) {
+  if (CountOccurrences(argv, argc, "-strip") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-strip' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(cmd_args, "-info") > 1) {
+  if (CountOccurrences(argv, argc, "-info") > 1) {
     ERROR_GOTO1("ERROR: Multiple '-info' arguments specified.\n", ErrValidate);
   }
-  if (CountOccurrences(cmd_args, "-o") > 1) {
+  if (CountOccurrences(argv, argc, "-o") > 1) {
     ERROR_GOTO1("ERROR: Multiple output files specified.\n", ErrValidate);
   }
 
   // Compound checks.
-  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");
+  num_frame_args = CountOccurrences(argv, argc, "-frame");
+  num_frgm_args = CountOccurrences(argv, argc, "-frgm");
+  num_loop_args = CountOccurrences(argv, argc, "-loop");
+  num_bgcolor_args = CountOccurrences(argv, argc, "-bgcolor");
 
   if (num_loop_args > 1) {
     ERROR_GOTO1("ERROR: Multiple loop counts specified.\n", ErrValidate);
@@ -574,20 +526,22 @@ static int ValidateCommandLine(const CommandLineArguments* const cmd_args,
     ERROR_GOTO1("ERROR: Loop count and background color are relevant only in "
                 "case of animation.\n", ErrValidate);
   }
-  if (num_durations_args > 0 && num_frame_args != 0) {
-    ERROR_GOTO1("ERROR: Can not combine -duration and -frame commands.\n",
-                ErrValidate);
+  if (num_frame_args > 0 && num_frgm_args > 0) {
+    ERROR_GOTO1("ERROR: Only one of frames & fragments can be specified at a "
+                "time.\n", ErrValidate);
   }
 
   assert(ok == 1);
-  if (num_durations_args > 0) {
-    *num_feature_args = num_durations_args;
-  } else if (num_frame_args == 0) {
+  if (num_frame_args == 0 && num_frgm_args == 0) {
     // Single argument ('set' action for ICCP/EXIF/XMP, OR a 'get' action).
     *num_feature_args = 1;
   } else {
-    // Multiple arguments ('set' action for animation)
-    *num_feature_args = num_frame_args + num_loop_args + num_bgcolor_args;
+    // Multiple arguments ('set' action for animation or fragmented image).
+    if (num_frame_args > 0) {
+      *num_feature_args = num_frame_args + num_loop_args + num_bgcolor_args;
+    } else {
+      *num_feature_args = num_frgm_args;
+    }
   }
 
  ErrValidate:
@@ -596,38 +550,31 @@ static int ValidateCommandLine(const CommandLineArguments* const cmd_args,
 
 #define ACTION_IS_NIL (config->action_type_ == NIL_ACTION)
 
-#define FEATURETYPE_IS_NIL (config->type_ == NIL_FEATURE)
+#define FEATURETYPE_IS_NIL (feature->type_ == NIL_FEATURE)
 
-#define CHECK_NUM_ARGS_AT_LEAST(NUM, LABEL)                              \
+#define CHECK_NUM_ARGS_LESS(NUM, LABEL)                                  \
   if (argc < i + (NUM)) {                                                \
     fprintf(stderr, "ERROR: Too few arguments for '%s'.\n", argv[i]);    \
     goto LABEL;                                                          \
   }
 
-#define CHECK_NUM_ARGS_AT_MOST(NUM, LABEL)                               \
-  if (argc > i + (NUM)) {                                                \
+#define CHECK_NUM_ARGS_NOT_EQUAL(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. unicode_argv contains wchar_t arguments or is null.
-static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
+// semantic checks.
+static int ParseCommandLine(int argc, const char* argv[],
+                            WebPMuxConfig* config) {
   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) {
-    FeatureArg* const arg = &config->args_[feature_arg_index];
+    Feature* const feature = &config->feature_;
+    FeatureArg* const arg = &feature->args_[feature_arg_index];
     if (argv[i][0] == '-') {  // One of the action types or output.
       if (!strcmp(argv[i], "-set")) {
         if (ACTION_IS_NIL) {
@@ -636,21 +583,6 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         }
         ++i;
-      } else if (!strcmp(argv[i], "-duration")) {
-        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 || config->type_ == FEATURE_DURATION) {
-          config->type_ = FEATURE_DURATION;
-        } else {
-          ERROR_GOTO1("ERROR: Multiple features specified.\n", ErrParse);
-        }
-        arg->params_ = argv[i + 1];
-        ++feature_arg_index;
-        i += 2;
       } else if (!strcmp(argv[i], "-get")) {
         if (ACTION_IS_NIL) {
           config->action_type_ = ACTION_GET;
@@ -661,20 +593,20 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
       } else if (!strcmp(argv[i], "-strip")) {
         if (ACTION_IS_NIL) {
           config->action_type_ = ACTION_STRIP;
-          config->arg_count_ = 0;
+          feature->arg_count_ = 0;
         } else {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         }
         ++i;
       } else if (!strcmp(argv[i], "-frame")) {
-        CHECK_NUM_ARGS_AT_LEAST(3, ErrParse);
+        CHECK_NUM_ARGS_LESS(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 || config->type_ == FEATURE_ANMF) {
-          config->type_ = FEATURE_ANMF;
+        if (FEATURETYPE_IS_NIL || feature->type_ == FEATURE_ANMF) {
+          feature->type_ = FEATURE_ANMF;
         } else {
           ERROR_GOTO1("ERROR: Multiple features specified.\n", ErrParse);
         }
@@ -684,14 +616,14 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
         ++feature_arg_index;
         i += 3;
       } else if (!strcmp(argv[i], "-loop") || !strcmp(argv[i], "-bgcolor")) {
-        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
+        CHECK_NUM_ARGS_LESS(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 || config->type_ == FEATURE_ANMF) {
-          config->type_ = FEATURE_ANMF;
+        if (FEATURETYPE_IS_NIL || feature->type_ == FEATURE_ANMF) {
+          feature->type_ = FEATURE_ANMF;
         } else {
           ERROR_GOTO1("ERROR: Multiple features specified.\n", ErrParse);
         }
@@ -701,36 +633,34 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
         ++feature_arg_index;
         i += 2;
       } else if (!strcmp(argv[i], "-o")) {
-        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
-        config->output_ = wargv[i + 1];
+        CHECK_NUM_ARGS_LESS(2, ErrParse);
+        config->output_ = argv[i + 1];
         i += 2;
       } else if (!strcmp(argv[i], "-info")) {
-        CHECK_NUM_ARGS_EXACTLY(2, ErrParse);
+        CHECK_NUM_ARGS_NOT_EQUAL(2, ErrParse);
         if (config->action_type_ != NIL_ACTION) {
           ERROR_GOTO1("ERROR: Multiple actions specified.\n", ErrParse);
         } else {
           config->action_type_ = ACTION_INFO;
-          config->arg_count_ = 0;
-          config->input_ = wargv[i + 1];
+          feature->arg_count_ = 0;
+          config->input_ = argv[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_ = wargv[i];
+            config->input_ = argv[i];
           } else {
             ERROR_GOTO2("ERROR at '%s': Multiple input files specified.\n",
                         argv[i], ErrParse);
@@ -748,14 +678,14 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
       if (!strcmp(argv[i], "icc") || !strcmp(argv[i], "exif") ||
           !strcmp(argv[i], "xmp")) {
         if (FEATURETYPE_IS_NIL) {
-          config->type_ = (!strcmp(argv[i], "icc")) ? FEATURE_ICCP :
+          feature->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_AT_LEAST(2, ErrParse);
-          arg->filename_ = wargv[i + 1];
+          CHECK_NUM_ARGS_LESS(2, ErrParse);
+          arg->filename_ = argv[i + 1];
           ++feature_arg_index;
           i += 2;
         } else {
@@ -763,14 +693,15 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
         }
       } else if (!strcmp(argv[i], "frame") &&
                  (config->action_type_ == ACTION_GET)) {
-        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
-        config->type_ = FEATURE_ANMF;
+        CHECK_NUM_ARGS_LESS(2, ErrParse);
+        feature->type_ = (!strcmp(argv[i], "frame")) ? FEATURE_ANMF :
+            FEATURE_FRGM;
         arg->params_ = argv[i + 1];
         ++feature_arg_index;
         i += 2;
       } else {  // Assume input file.
         if (config->input_ == NULL) {
-          config->input_ = wargv[i];
+          config->input_ = argv[i];
         } else {
           ERROR_GOTO2("ERROR at '%s': Multiple input files specified.\n",
                       argv[i], ErrParse);
@@ -784,8 +715,9 @@ static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
 }
 
 // Additional checks after config is filled.
-static int ValidateConfig(Config* const config) {
+static int ValidateConfig(WebPMuxConfig* config) {
   int ok = 1;
+  Feature* const feature = &config->feature_;
 
   // Action.
   if (ACTION_IS_NIL) {
@@ -801,7 +733,8 @@ static int ValidateConfig(Config* const config) {
   if (config->input_ == NULL) {
     if (config->action_type_ != ACTION_SET) {
       ERROR_GOTO1("ERROR: No input file specified.\n", ErrValidate2);
-    } else if (config->type_ != FEATURE_ANMF) {
+    } else if (feature->type_ != FEATURE_ANMF &&
+               feature->type_ != FEATURE_FRGM) {
       ERROR_GOTO1("ERROR: No input file specified.\n", ErrValidate2);
     }
   }
@@ -816,29 +749,28 @@ static int ValidateConfig(Config* const config) {
 }
 
 // Create config object from command-line arguments.
-static int InitializeConfig(int argc, const char* argv[], Config* const config,
-                            const W_CHAR** const unicode_argv) {
+static int InitializeConfig(int argc, const char* argv[],
+                            WebPMuxConfig* config) {
   int num_feature_args = 0;
-  int ok;
+  int ok = 1;
 
+  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(&config->cmd_args_, &num_feature_args)) {
+  if (!ValidateCommandLine(argc, argv, &num_feature_args)) {
     ERROR_GOTO1("Exiting due to command-line parsing error.\n", Err1);
   }
 
-  config->arg_count_ = num_feature_args;
-  config->args_ = (FeatureArg*)calloc(num_feature_args, sizeof(*config->args_));
-  if (config->args_ == NULL) {
+  config->feature_.arg_count_ = num_feature_args;
+  config->feature_.args_ =
+      (FeatureArg*)calloc(num_feature_args, sizeof(*config->feature_.args_));
+  if (config->feature_.args_ == NULL) {
     ERROR_GOTO1("ERROR: Memory allocation error.\n", Err1);
   }
 
   // Parse command-line.
-  if (!ParseCommandLine(config, unicode_argv) || !ValidateConfig(config)) {
+  if (!ParseCommandLine(argc, argv, config) || !ValidateConfig(config)) {
     ERROR_GOTO1("Exiting due to command-line parsing error.\n", Err1);
   }
 
@@ -848,24 +780,24 @@ static int InitializeConfig(int argc, const char* argv[], Config* const config,
 
 #undef ACTION_IS_NIL
 #undef FEATURETYPE_IS_NIL
-#undef CHECK_NUM_ARGS_AT_LEAST
-#undef CHECK_NUM_ARGS_AT_MOST
-#undef CHECK_NUM_ARGS_EXACTLY
+#undef CHECK_NUM_ARGS_LESS
+#undef CHECK_NUM_ARGS_MORE
 
 //------------------------------------------------------------------------------
 // Processing.
 
-static int GetFrame(const WebPMux* mux, const Config* config) {
+static int GetFrameFragment(const WebPMux* mux,
+                            const WebPMuxConfig* config, int is_frame) {
   WebPMuxError err = WEBP_MUX_OK;
   WebPMux* mux_single = NULL;
   int num = 0;
   int ok = 1;
   int parse_error = 0;
-  const WebPChunkId id = WEBP_CHUNK_ANMF;
+  const WebPChunkId id = is_frame ? WEBP_CHUNK_ANMF : WEBP_CHUNK_FRGM;
   WebPMuxFrameInfo info;
   WebPDataInit(&info.bitstream);
 
-  num = ExUtilGetInt(config->args_[0].params_, 10, &parse_error);
+  num = ExUtilGetInt(config->feature_.args_[0].params_, 10, &parse_error);
   if (num < 0) {
     ERROR_GOTO1("ERROR: Frame/Fragment index must be non-negative.\n", ErrGet);
   }
@@ -899,28 +831,31 @@ static int GetFrame(const WebPMux* mux, const Config* config) {
 }
 
 // Read and process config.
-static int Process(const Config* config) {
+static int Process(const WebPMuxConfig* 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 (config->type_) {
+      switch (feature->type_) {
         case FEATURE_ANMF:
-          ok = GetFrame(mux, config);
+        case FEATURE_FRGM:
+          ok = GetFrameFragment(mux, config,
+                                (feature->type_ == FEATURE_ANMF) ? 1 : 0);
           break;
 
         case FEATURE_ICCP:
         case FEATURE_EXIF:
         case FEATURE_XMP:
-          err = WebPMuxGetChunk(mux, kFourccList[config->type_], &chunk);
+          err = WebPMuxGetChunk(mux, kFourccList[feature->type_], &chunk);
           if (err != WEBP_MUX_OK) {
             ERROR_GOTO3("ERROR (%s): Could not get the %s.\n",
-                        ErrorString(err), kDescriptions[config->type_], Err2);
+                        ErrorString(err), kDescriptions[feature->type_], Err2);
           }
           ok = WriteData(config->output_, &chunk);
           break;
@@ -932,7 +867,7 @@ static int Process(const Config* config) {
       break;
     }
     case ACTION_SET: {
-      switch (config->type_) {
+      switch (feature->type_) {
         case FEATURE_ANMF: {
           int i;
           WebPMuxAnimParams params = { 0xFFFFFFFF, 0 };
@@ -941,11 +876,11 @@ static int Process(const Config* config) {
             ERROR_GOTO2("ERROR (%s): Could not allocate a mux object.\n",
                         ErrorString(WEBP_MUX_MEMORY_ERROR), Err2);
           }
-          for (i = 0; i < config->arg_count_; ++i) {
-            switch (config->args_[i].subtype_) {
+          for (i = 0; i < feature->arg_count_; ++i) {
+            switch (feature->args_[i].subtype_) {
               case SUBTYPE_BGCOLOR: {
                 uint32_t bgcolor;
-                ok = ParseBgcolorArgs(config->args_[i].params_, &bgcolor);
+                ok = ParseBgcolorArgs(feature->args_[i].params_, &bgcolor);
                 if (!ok) {
                   ERROR_GOTO1("ERROR: Could not parse the background color \n",
                               Err2);
@@ -956,7 +891,7 @@ static int Process(const Config* config) {
               case SUBTYPE_LOOP: {
                 int parse_error = 0;
                 const int loop_count =
-                    ExUtilGetInt(config->args_[i].params_, 10, &parse_error);
+                    ExUtilGetInt(feature->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
@@ -972,10 +907,10 @@ static int Process(const Config* config) {
               case SUBTYPE_ANMF: {
                 WebPMuxFrameInfo frame;
                 frame.id = WEBP_CHUNK_ANMF;
-                ok = ExUtilReadFileToWebPData(config->args_[i].filename_,
-                                              &frame.bitstream);
+                ok = ReadFileToWebPData(feature->args_[i].filename_,
+                                        &frame.bitstream);
                 if (!ok) goto Err2;
-                ok = ParseFrameArgs(config->args_[i].params_, &frame);
+                ok = ParseFrameArgs(feature->args_[i].params_, &frame);
                 if (!ok) {
                   WebPDataClear(&frame.bitstream);
                   ERROR_GOTO1("ERROR: Could not parse frame properties.\n",
@@ -1003,18 +938,47 @@ static int Process(const Config* config) {
           break;
         }
 
+        case FEATURE_FRGM: {
+          int i;
+          mux = WebPMuxNew();
+          if (mux == NULL) {
+            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) {
+            WebPMuxFrameInfo frgm;
+            frgm.id = WEBP_CHUNK_FRGM;
+            ok = ReadFileToWebPData(feature->args_[i].filename_,
+                                    &frgm.bitstream);
+            if (!ok) goto Err2;
+            ok = ParseFragmentArgs(feature->args_[i].params_, &frgm);
+            if (!ok) {
+              WebPDataClear(&frgm.bitstream);
+              ERROR_GOTO1("ERROR: Could not parse fragment properties.\n",
+                          Err2);
+            }
+            err = WebPMuxPushFrame(mux, &frgm, 1);
+            WebPDataClear(&frgm.bitstream);
+            if (err != WEBP_MUX_OK) {
+              ERROR_GOTO3("ERROR (%s): Could not add a fragment at index %d.\n",
+                          ErrorString(err), i, Err2);
+            }
+          }
+          break;
+        }
+
         case FEATURE_ICCP:
         case FEATURE_EXIF:
         case FEATURE_XMP: {
           ok = CreateMux(config->input_, &mux);
           if (!ok) goto Err2;
-          ok = ExUtilReadFileToWebPData(config->args_[0].filename_, &chunk);
+          ok = ReadFileToWebPData(feature->args_[0].filename_, &chunk);
           if (!ok) goto Err2;
-          err = WebPMuxSetChunk(mux, kFourccList[config->type_], &chunk, 1);
+          err = WebPMuxSetChunk(mux, kFourccList[feature->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[config->type_], Err2);
+                        ErrorString(err), kDescriptions[feature->type_], Err2);
           }
           break;
         }
@@ -1026,98 +990,15 @@ static int Process(const Config* config) {
       ok = WriteWebP(mux, config->output_);
       break;
     }
-    case ACTION_DURATION: {
-      int num_frames;
-      ok = CreateMux(config->input_, &mux);
-      if (!ok) goto Err2;
-      err = WebPMuxNumChunks(mux, WEBP_CHUNK_ANMF, &num_frames);
-      ok = (err == WEBP_MUX_OK);
-      if (!ok) {
-        ERROR_GOTO1("ERROR: can not parse the number of frames.\n", Err2);
-      }
-      if (num_frames == 0) {
-        fprintf(stderr, "Doesn't look like the source is animated. "
-                        "Skipping duration setting.\n");
-        ok = WriteWebP(mux, config->output_);
-        if (!ok) goto Err2;
-      } else {
-        int i;
-        int* durations = NULL;
-        WebPMux* new_mux = DuplicateMuxHeader(mux);
-        if (new_mux == NULL) goto Err2;
-        durations = (int*)malloc((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 < config->arg_count_; ++i) {
-          int k;
-          int args[3];
-          int duration, start, end;
-          const int nb_args = ExUtilGetInts(config->args_[i].params_,
-                                            10, 3, args);
-          ok = (nb_args >= 1);
-          if (!ok) goto Err3;
-          duration = args[0];
-          if (duration < 0) {
-            ERROR_GOTO1("ERROR: duration must be strictly positive.\n", Err3);
-          }
-
-          if (nb_args == 1) {   // only duration is present -> use full interval
-            start = 1;
-            end = num_frames;
-          } else {
-            start = args[1];
-            if (start <= 0) {
-              start = 1;
-            } else if (start > num_frames) {
-              start = num_frames;
-            }
-            end = (nb_args >= 3) ? args[2] : start;
-            if (end == 0 || end > num_frames) end = num_frames;
-          }
-
-          for (k = start; k <= end; ++k) {
-            assert(k >= 1 && k <= num_frames);
-            durations[k - 1] = duration;
-          }
-        }
-
-        // Apply non-negative durations to their destination frames.
-        for (i = 1; i <= num_frames; ++i) {
-          WebPMuxFrameInfo frame;
-          err = WebPMuxGetFrame(mux, i, &frame);
-          if (err != WEBP_MUX_OK || frame.id != WEBP_CHUNK_ANMF) {
-            ERROR_GOTO2("ERROR: can not retrieve frame #%d.\n", i, Err3);
-          }
-          if (durations[i - 1] >= 0) frame.duration = durations[i - 1];
-          err = WebPMuxPushFrame(new_mux, &frame, 1);
-          if (err != WEBP_MUX_OK) {
-            ERROR_GOTO2("ERROR: error push frame data #%d\n", i, Err3);
-          }
-          WebPDataClear(&frame.bitstream);
-        }
-        WebPMuxDelete(mux);
-        ok = WriteWebP(new_mux, config->output_);
-        mux = new_mux;  // transfer for the WebPMuxDelete() call
-        new_mux = NULL;
-
- Err3:
-        free(durations);
-        WebPMuxDelete(new_mux);
-        if (!ok) goto Err2;
-      }
-      break;
-    }
     case ACTION_STRIP: {
       ok = CreateMux(config->input_, &mux);
       if (!ok) goto Err2;
-      if (config->type_ == FEATURE_ICCP || config->type_ == FEATURE_EXIF ||
-          config->type_ == FEATURE_XMP) {
-        err = WebPMuxDeleteChunk(mux, kFourccList[config->type_]);
+      if (feature->type_ == FEATURE_ICCP || feature->type_ == FEATURE_EXIF ||
+          feature->type_ == FEATURE_XMP) {
+        err = WebPMuxDeleteChunk(mux, kFourccList[feature->type_]);
         if (err != WEBP_MUX_OK) {
           ERROR_GOTO3("ERROR (%s): Could not strip the %s.\n",
-                      ErrorString(err), kDescriptions[config->type_], Err2);
+                      ErrorString(err), kDescriptions[feature->type_], Err2);
         }
       } else {
         ERROR_GOTO1("ERROR: Invalid feature for action 'strip'.\n", Err2);
@@ -1147,19 +1028,15 @@ static int Process(const Config* config) {
 // Main.
 
 int main(int argc, const char* argv[]) {
-  Config config;
-  int ok;
-
-  INIT_WARGV(argc, argv);
-
-  ok = InitializeConfig(argc - 1, argv + 1, &config, GET_WARGV_OR_NULL());
+  WebPMuxConfig config;
+  int ok = InitializeConfig(argc - 1, argv + 1, &config);
   if (ok) {
     ok = Process(&config);
   } else {
     PrintHelp();
   }
   DeleteConfig(&config);
-  FREE_WARGV_AND_RETURN(!ok);
+  return !ok;
 }
 
 //------------------------------------------------------------------------------

examples/wicdec.c

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

examples/wicdec.h

@@ -9,8 +9,8 @@
 //
 // Windows Imaging Component (WIC) decode.
 
-#ifndef WEBP_IMAGEIO_WICDEC_H_
-#define WEBP_IMAGEIO_WICDEC_H_
+#ifndef WEBP_EXAMPLES_WICDEC_H_
+#define WEBP_EXAMPLES_WICDEC_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -31,4 +31,4 @@ int ReadPictureWithWIC(const char* const filename,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_IMAGEIO_WICDEC_H_
+#endif  // WEBP_EXAMPLES_WICDEC_H_

extras/Makefile.am

@@ -1,44 +0,0 @@
-AM_CPPFLAGS += -I$(top_builddir) -I$(top_srcdir)
-AM_CPPFLAGS += -I$(top_builddir)/src -I$(top_srcdir)/src
-noinst_LTLIBRARIES = libwebpextras.la
-
-noinst_HEADERS =
-noinst_HEADERS += ../src/webp/types.h
-
-libwebpextras_la_SOURCES =
-libwebpextras_la_SOURCES += extras.c extras.h quality_estimate.c
-
-libwebpextras_la_CPPFLAGS = $(AM_CPPFLAGS)
-libwebpextras_la_LDFLAGS = -lm
-libwebpextras_la_LIBADD = ../src/libwebp.la
-
-noinst_PROGRAMS =
-noinst_PROGRAMS += webp_quality
-if BUILD_DEMUX
-  noinst_PROGRAMS += get_disto
-endif
-if BUILD_VWEBP_SDL
-  noinst_PROGRAMS += vwebp_sdl
-endif
-
-get_disto_SOURCES  = get_disto.c
-get_disto_CPPFLAGS = $(AM_CPPFLAGS)
-get_disto_LDADD =
-get_disto_LDADD += ../imageio/libimageio_util.la
-get_disto_LDADD += ../imageio/libimagedec.la
-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)
-webp_quality_LDADD =
-webp_quality_LDADD += ../imageio/libimageio_util.la
-webp_quality_LDADD += libwebpextras.la
-webp_quality_LDADD += ../src/libwebp.la
-
-vwebp_sdl_SOURCES  = vwebp_sdl.c webp_to_sdl.c webp_to_sdl.h
-vwebp_sdl_CPPFLAGS = $(AM_CPPFLAGS) $(SDL_INCLUDES)
-vwebp_sdl_LDADD =
-vwebp_sdl_LDADD += ../imageio/libimageio_util.la
-vwebp_sdl_LDADD += ../src/libwebp.la
-vwebp_sdl_LDADD += $(SDL_LIBS)

extras/extras.h

@@ -1,70 +0,0 @@
-// Copyright 2015 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.
-// -----------------------------------------------------------------------------
-//
-
-#ifndef WEBP_EXTRAS_EXTRAS_H_
-#define WEBP_EXTRAS_EXTRAS_H_
-
-#include "webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "webp/encode.h"
-
-#define WEBP_EXTRAS_ABI_VERSION 0x0001    // MAJOR(8b) + MINOR(8b)
-
-//------------------------------------------------------------------------------
-
-// Returns the version number of the extras library, packed in hexadecimal using
-// 8bits for each of major/minor/revision. E.g: v2.5.7 is 0x020507.
-WEBP_EXTERN int WebPGetExtrasVersion(void);
-
-//------------------------------------------------------------------------------
-// Ad-hoc colorspace importers.
-
-// Import luma sample (gray scale image) into 'picture'. The 'picture'
-// width and height must be set prior to calling this function.
-WEBP_EXTERN int WebPImportGray(const uint8_t* gray, WebPPicture* picture);
-
-// Import rgb sample in RGB565 packed format into 'picture'. The 'picture'
-// width and height must be set prior to calling this function.
-WEBP_EXTERN int WebPImportRGB565(const uint8_t* rgb565, WebPPicture* pic);
-
-// Import rgb sample in RGB4444 packed format into 'picture'. The 'picture'
-// width and height must be set prior to calling this function.
-WEBP_EXTERN int WebPImportRGB4444(const uint8_t* rgb4444, WebPPicture* pic);
-
-// Import a color mapped image. The number of colors is less or equal to
-// MAX_PALETTE_SIZE. 'pic' must have been initialized. Its content, if any,
-// will be discarded. Returns 'false' in case of error, or if indexed[] contains
-// invalid indices.
-WEBP_EXTERN int
-WebPImportColorMappedARGB(const uint8_t* indexed, int indexed_stride,
-                          const uint32_t palette[], int palette_size,
-                          WebPPicture* pic);
-
-//------------------------------------------------------------------------------
-
-// Parse a bitstream, search for VP8 (lossy) header and report a
-// rough estimation of the quality factor used for compressing the bitstream.
-// If the bitstream is in lossless format, the special value '101' is returned.
-// Otherwise (lossy bitstream), the returned value is in the range [0..100].
-// Any error (invalid bitstream, animated WebP, incomplete header, etc.)
-// will return a value of -1.
-WEBP_EXTERN int VP8EstimateQuality(const uint8_t* const data, size_t size);
-
-//------------------------------------------------------------------------------
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  // WEBP_EXTRAS_EXTRAS_H_

extras/get_disto.c

@@ -1,355 +0,0 @@
-// 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.
-// -----------------------------------------------------------------------------
-//
-// Simple tool to load two webp/png/jpg/tiff files and compute PSNR/SSIM.
-// This is mostly a wrapper around WebPPictureDistortion().
-//
-/*
- gcc -o get_disto get_disto.c -O3 -I../ -L../examples -L../imageio \
-    -lexample_util -limageio_util -limagedec -lwebp -L/opt/local/lib \
-    -lpng -lz -ljpeg -ltiff -lm -lpthread
-*/
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#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) {
-  const uint8_t* data = NULL;
-  size_t data_size = 0;
-  WebPImageReader reader = NULL;
-  int ok = ImgIoUtilReadFile(filename, &data, &data_size);
-  if (!ok) goto End;
-
-  pic->use_argb = 1;  // force ARGB
-
-#ifdef HAVE_WINCODEC_H
-  // Try to decode the file using WIC falling back to the other readers for
-  // e.g., WebP.
-  ok = ReadPictureWithWIC(filename, pic, keep_alpha, NULL);
-  if (ok) goto End;
-#endif
-  reader = WebPGuessImageReader(data, data_size);
-  ok = reader(data, data_size, pic, keep_alpha, NULL);
-
- End:
-  if (!ok) {
-    WFPRINTF(stderr, "Error! Could not process file %s\n",
-             (const W_CHAR*)filename);
-  }
-  free((void*)data);
-  return ok ? data_size : 0;
-}
-
-static void RescalePlane(uint8_t* plane, int width, int height,
-                         int x_stride, int y_stride, int max) {
-  const uint32_t factor = (max > 0) ? (255u << 16) / max : 0;
-  int x, y;
-  for (y = 0; y < height; ++y) {
-    uint8_t* const ptr = plane + y * y_stride;
-    for (x = 0; x < width * x_stride; x += x_stride) {
-      const uint32_t diff = (ptr[x] * factor + (1 << 15)) >> 16;
-      ptr[x] = diff;
-    }
-  }
-}
-
-// Return the max absolute difference.
-static int DiffScaleChannel(uint8_t* src1, int stride1,
-                            const uint8_t* src2, int stride2,
-                            int x_stride, int w, int h, int do_scaling) {
-  int x, y;
-  int max = 0;
-  for (y = 0; y < h; ++y) {
-    uint8_t* const ptr1 = src1 + y * stride1;
-    const uint8_t* const ptr2 = src2 + y * stride2;
-    for (x = 0; x < w * x_stride; x += x_stride) {
-      const int diff = abs(ptr1[x] - ptr2[x]);
-      if (diff > max) max = diff;
-      ptr1[x] = diff;
-    }
-  }
-
-  if (do_scaling) RescalePlane(src1, w, h, x_stride, stride1, max);
-  return max;
-}
-
-//------------------------------------------------------------------------------
-// SSIM calculation. We re-implement these functions here, out of dsp/, to avoid
-// breaking the library's hidden visibility. This code duplication avoids the
-// bigger annoyance of having to open up internal details of libdsp...
-
-#define SSIM_KERNEL 3   // total size of the kernel: 2 * SSIM_KERNEL + 1
-
-// struct for accumulating statistical moments
-typedef struct {
-  uint32_t w;              // sum(w_i) : sum of weights
-  uint32_t xm, ym;         // sum(w_i * x_i), sum(w_i * y_i)
-  uint32_t xxm, xym, yym;  // sum(w_i * x_i * x_i), etc.
-} DistoStats;
-
-// hat-shaped filter. Sum of coefficients is equal to 16.
-static const uint32_t kWeight[2 * SSIM_KERNEL + 1] = { 1, 2, 3, 4, 3, 2, 1 };
-
-static WEBP_INLINE double SSIMCalculation(const DistoStats* const stats) {
-  const uint32_t N = stats->w;
-  const uint32_t w2 =  N * N;
-  const uint32_t C1 = 20 * w2;
-  const uint32_t C2 = 60 * w2;
-  const uint32_t C3 = 8 * 8 * w2;   // 'dark' limit ~= 6
-  const uint64_t xmxm = (uint64_t)stats->xm * stats->xm;
-  const uint64_t ymym = (uint64_t)stats->ym * stats->ym;
-  if (xmxm + ymym >= C3) {
-    const int64_t xmym = (int64_t)stats->xm * stats->ym;
-    const int64_t sxy = (int64_t)stats->xym * N - xmym;    // can be negative
-    const uint64_t sxx = (uint64_t)stats->xxm * N - xmxm;
-    const uint64_t syy = (uint64_t)stats->yym * N - ymym;
-    // we descale by 8 to prevent overflow during the fnum/fden multiply.
-    const uint64_t num_S = (2 * (uint64_t)(sxy < 0 ? 0 : sxy) + C2) >> 8;
-    const uint64_t den_S = (sxx + syy + C2) >> 8;
-    const uint64_t fnum = (2 * xmym + C1) * num_S;
-    const uint64_t fden = (xmxm + ymym + C1) * den_S;
-    const double r = (double)fnum / fden;
-    assert(r >= 0. && r <= 1.0);
-    return r;
-  }
-  return 1.;   // area is too dark to contribute meaningfully
-}
-
-static double SSIMGetClipped(const uint8_t* src1, int stride1,
-                             const uint8_t* src2, int stride2,
-                             int xo, int yo, int W, int H) {
-  DistoStats stats = { 0, 0, 0, 0, 0, 0 };
-  const int ymin = (yo - SSIM_KERNEL < 0) ? 0 : yo - SSIM_KERNEL;
-  const int ymax = (yo + SSIM_KERNEL > H - 1) ? H - 1 : yo + SSIM_KERNEL;
-  const int xmin = (xo - SSIM_KERNEL < 0) ? 0 : xo - SSIM_KERNEL;
-  const int xmax = (xo + SSIM_KERNEL > W - 1) ? W - 1 : xo + SSIM_KERNEL;
-  int x, y;
-  src1 += ymin * stride1;
-  src2 += ymin * stride2;
-  for (y = ymin; y <= ymax; ++y, src1 += stride1, src2 += stride2) {
-    for (x = xmin; x <= xmax; ++x) {
-      const uint32_t w = kWeight[SSIM_KERNEL + x - xo]
-                       * kWeight[SSIM_KERNEL + y - yo];
-      const uint32_t s1 = src1[x];
-      const uint32_t s2 = src2[x];
-      stats.w   += w;
-      stats.xm  += w * s1;
-      stats.ym  += w * s2;
-      stats.xxm += w * s1 * s1;
-      stats.xym += w * s1 * s2;
-      stats.yym += w * s2 * s2;
-    }
-  }
-  return SSIMCalculation(&stats);
-}
-
-// Compute SSIM-score map. Return -1 in case of error, max diff otherwise.
-static int SSIMScaleChannel(uint8_t* src1, int stride1,
-                            const uint8_t* src2, int stride2,
-                            int x_stride, int w, int h, int do_scaling) {
-  int x, y;
-  int max = 0;
-  uint8_t* const plane1 = (uint8_t*)malloc(2 * w * h * sizeof(*plane1));
-  uint8_t* const plane2 = plane1 + w * h;
-  if (plane1 == NULL) return -1;
-
-  // extract plane
-  for (y = 0; y < h; ++y) {
-    for (x = 0; x < w; ++x) {
-      plane1[x + y * w] = src1[x * x_stride + y * stride1];
-      plane2[x + y * w] = src2[x * x_stride + y * stride2];
-    }
-  }
-  for (y = 0; y < h; ++y) {
-    for (x = 0; x < w; ++x) {
-      const double ssim = SSIMGetClipped(plane1, w, plane2, w, x, y, w, h);
-      int diff = (int)(255 * (1. - ssim));
-      if (diff < 0) {
-        diff = 0;
-      } else if (diff > max) {
-        max = diff;
-      }
-      src1[x * x_stride + y * stride1] = (diff > 255) ? 255u : (uint8_t)diff;
-    }
-  }
-  free(plane1);
-
-  if (do_scaling) RescalePlane(src1, w, h, x_stride, stride1, max);
-  return max;
-}
-
-// Convert an argb picture to luminance.
-static void ConvertToGray(WebPPicture* const pic) {
-  int x, y;
-  assert(pic != NULL);
-  assert(pic->use_argb);
-  for (y = 0; y < pic->height; ++y) {
-    uint32_t* const row = &pic->argb[y * pic->argb_stride];
-    for (x = 0; x < pic->width; ++x) {
-      const uint32_t argb = row[x];
-      const uint32_t r = (argb >> 16) & 0xff;
-      const uint32_t g = (argb >>  8) & 0xff;
-      const uint32_t b = (argb >>  0) & 0xff;
-      // We use BT.709 for converting to luminance.
-      const uint32_t Y = (uint32_t)(0.2126 * r + 0.7152 * g + 0.0722 * b + .5);
-      row[x] = (argb & 0xff000000u) | (Y * 0x010101u);
-    }
-  }
-}
-
-static void Help(void) {
-  fprintf(stderr,
-          "Usage: get_disto [-ssim][-psnr][-alpha] compressed.webp orig.webp\n"
-          "  -ssim ..... print SSIM distortion\n"
-          "  -psnr ..... print PSNR distortion (default)\n"
-          "  -alpha .... preserve alpha plane\n"
-          "  -h ........ this message\n"
-          "  -o <file> . save the diff map as a WebP lossless file\n"
-          "  -scale .... scale the difference map to fit [0..255] range\n"
-          "  -gray ..... use grayscale for difference map (-scale)\n"
-          " Also handles PNG, JPG and TIFF files, in addition to WebP.\n");
-}
-
-int main(int argc, const char *argv[]) {
-  WebPPicture pic1, pic2;
-  size_t size1 = 0, size2 = 0;
-  int ret = 1;
-  float disto[5];
-  int type = 0;
-  int c;
-  int help = 0;
-  int keep_alpha = 0;
-  int scale = 0;
-  int use_gray = 0;
-  const char* name1 = NULL;
-  const char* name2 = NULL;
-  const char* output = NULL;
-
-  INIT_WARGV(argc, argv);
-
-  if (!WebPPictureInit(&pic1) || !WebPPictureInit(&pic2)) {
-    fprintf(stderr, "Can't init pictures\n");
-    FREE_WARGV_AND_RETURN(1);
-  }
-
-  for (c = 1; c < argc; ++c) {
-    if (!strcmp(argv[c], "-ssim")) {
-      type = 1;
-    } else if (!strcmp(argv[c], "-psnr")) {
-      type = 0;
-    } else if (!strcmp(argv[c], "-alpha")) {
-      keep_alpha = 1;
-    } else if (!strcmp(argv[c], "-scale")) {
-      scale = 1;
-    } else if (!strcmp(argv[c], "-gray")) {
-      use_gray = 1;
-    } else if (!strcmp(argv[c], "-h")) {
-      help = 1;
-      ret = 0;
-    } else if (!strcmp(argv[c], "-o")) {
-      if (++c == argc) {
-        fprintf(stderr, "missing file name after %s option.\n", argv[c - 1]);
-        goto End;
-      }
-      output = (const char*)GET_WARGV(argv, c);
-    } else if (name1 == NULL) {
-      name1 = (const char*)GET_WARGV(argv, c);
-    } else {
-      name2 = (const char*)GET_WARGV(argv, c);
-    }
-  }
-  if (help || name1 == NULL || name2 == NULL) {
-    if (!help) {
-      fprintf(stderr, "Error: missing arguments.\n");
-    }
-    Help();
-    goto End;
-  }
-  size1 = ReadPicture(name1, &pic1, 1);
-  size2 = ReadPicture(name2, &pic2, 1);
-  if (size1 == 0 || size2 == 0) goto End;
-
-  if (!keep_alpha) {
-    WebPBlendAlpha(&pic1, 0x00000000);
-    WebPBlendAlpha(&pic2, 0x00000000);
-  }
-
-  if (!WebPPictureDistortion(&pic1, &pic2, type, disto)) {
-    fprintf(stderr, "Error while computing the distortion.\n");
-    goto End;
-  }
-  printf("%u %.2f    %.2f %.2f %.2f %.2f [ %.2f bpp ]\n",
-         (unsigned int)size1,
-         disto[4], disto[0], disto[1], disto[2], disto[3],
-         8.f * size1 / pic1.width / pic1.height);
-
-  if (output != NULL) {
-    uint8_t* data = NULL;
-    size_t data_size = 0;
-    if (pic1.use_argb != pic2.use_argb) {
-      fprintf(stderr, "Pictures are not in the same argb format. "
-                      "Can't save the difference map.\n");
-      goto End;
-    }
-    if (pic1.use_argb) {
-      int n;
-      fprintf(stderr, "max differences per channel: ");
-      for (n = 0; n < 3; ++n) {    // skip the alpha channel
-        const int range = (type == 1) ?
-          SSIMScaleChannel((uint8_t*)pic1.argb + n, pic1.argb_stride * 4,
-                           (const uint8_t*)pic2.argb + n, pic2.argb_stride * 4,
-                           4, pic1.width, pic1.height, scale) :
-          DiffScaleChannel((uint8_t*)pic1.argb + n, pic1.argb_stride * 4,
-                           (const uint8_t*)pic2.argb + n, pic2.argb_stride * 4,
-                           4, pic1.width, pic1.height, scale);
-        if (range < 0) fprintf(stderr, "\nError computing diff map\n");
-        fprintf(stderr, "[%d]", range);
-      }
-      fprintf(stderr, "\n");
-      if (use_gray) ConvertToGray(&pic1);
-    } else {
-      fprintf(stderr, "Can only compute the difference map in ARGB format.\n");
-      goto End;
-    }
-#if !defined(WEBP_REDUCE_CSP)
-    data_size = WebPEncodeLosslessBGRA((const uint8_t*)pic1.argb,
-                                       pic1.width, pic1.height,
-                                       pic1.argb_stride * 4,
-                                       &data);
-    if (data_size == 0) {
-      fprintf(stderr, "Error during lossless encoding.\n");
-      goto End;
-    }
-    ret = ImgIoUtilWriteFile(output, data, data_size) ? 0 : 1;
-    WebPFree(data);
-    if (ret) goto End;
-#else
-    (void)data;
-    (void)data_size;
-    fprintf(stderr, "Cannot save the difference map. Please recompile "
-                    "without the WEBP_REDUCE_CSP flag.\n");
-#endif  // WEBP_REDUCE_CSP
-  }
-  ret = 0;
-
- End:
-  WebPPictureFree(&pic1);
-  WebPPictureFree(&pic2);
-  FREE_WARGV_AND_RETURN(ret);
-}

extras/quality_estimate.c

@@ -1,129 +0,0 @@
-// 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.
-// -----------------------------------------------------------------------------
-//
-//  VP8EstimateQuality(): rough encoding quality estimate
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include "extras/extras.h"
-#include "webp/decode.h"
-
-#include <math.h>
-
-//------------------------------------------------------------------------------
-
-#define INVALID_BIT_POS (1ull << 63)
-
-// In most cases, we don't need to use a full arithmetic decoder, since
-// all the header's bits are written using a uniform probability of 128.
-// We can just parse the header as if it was bits (works in 99.999% cases).
-static WEBP_INLINE uint32_t GetBit(const uint8_t* const data, size_t nb,
-                                   uint64_t max_size, uint64_t* const bit_pos) {
-  uint32_t val = 0;
-  if (*bit_pos + nb <= 8 * max_size) {
-    while (nb-- > 0) {
-      const uint64_t p = (*bit_pos)++;
-      const int bit = !!(data[p >> 3] & (128 >> ((p & 7))));
-      val = (val << 1) | bit;
-    }
-  } else {
-    *bit_pos = INVALID_BIT_POS;
-  }
-  return val;
-}
-
-#define GET_BIT(n) GetBit(data, (n), size, &bit_pos)
-#define CONDITIONAL_SKIP(n) (GET_BIT(1) ? GET_BIT((n)) : 0)
-
-int VP8EstimateQuality(const uint8_t* const data, size_t size) {
-  size_t pos = 0;
-  uint64_t bit_pos;
-  uint64_t sig = 0x00;
-  int ok = 0;
-  int Q = -1;
-  WebPBitstreamFeatures features;
-
-  if (data == NULL) return -1;
-
-  if (WebPGetFeatures(data, size, &features) != VP8_STATUS_OK) {
-    return -1;   // invalid file
-  }
-  if (features.format == 2) return 101;  // lossless
-  if (features.format == 0 || features.has_animation) return -1;   // mixed
-
-  while (pos < size) {
-    sig = (sig >> 8) | ((uint64_t)data[pos++] << 40);
-    if ((sig >> 24) == 0x2a019dull) {
-      ok = 1;
-      break;
-    }
-  }
-  if (!ok) return -1;
-  if (pos + 4 > size) return -1;
-
-  // Skip main Header
-  // width  = (data[pos + 0] | (data[pos + 1] << 8)) & 0x3fff;
-  // height = (data[pos + 2] | (data[pos + 3] << 8)) & 0x3fff;
-  pos += 4;
-  bit_pos = pos * 8;
-
-  GET_BIT(2);  // colorspace + clamp type
-
-  // Segment header
-  if (GET_BIT(1)) {       // use_segment_
-    int s;
-    const int update_map = GET_BIT(1);
-    if (GET_BIT(1)) {     // update data
-      const int absolute_delta = GET_BIT(1);
-      int q[4]  = { 0, 0, 0, 0 };
-      for (s = 0; s < 4; ++s) {
-        if (GET_BIT(1)) {
-          q[s] = GET_BIT(7);
-          if (GET_BIT(1)) q[s] = -q[s];   // sign
-        }
-      }
-      if (absolute_delta) Q = q[0];  // just use the first segment's quantizer
-      for (s = 0; s < 4; ++s) CONDITIONAL_SKIP(7);   //  filter strength
-    }
-    if (update_map) {
-      for (s = 0; s < 3; ++s) CONDITIONAL_SKIP(8);
-    }
-  }
-  // Filter header
-  GET_BIT(1 + 6 + 3);     // simple + level + sharpness
-  if (GET_BIT(1)) {       // use_lf_delta
-    if (GET_BIT(1)) {     // update lf_delta?
-      int n;
-      for (n = 0; n < 4 + 4; ++n) CONDITIONAL_SKIP(6);
-    }
-  }
-  // num partitions
-  GET_BIT(2);
-
-  // ParseQuant
-  {
-    const int base_q = GET_BIT(7);
-    /* dqy1_dc = */ CONDITIONAL_SKIP(5);
-    /* dqy2_dc = */ CONDITIONAL_SKIP(5);
-    /* dqy2_ac = */ CONDITIONAL_SKIP(5);
-    /* dquv_dc = */ CONDITIONAL_SKIP(5);
-    /* dquv_ac = */ CONDITIONAL_SKIP(5);
-
-    if (Q < 0) Q = base_q;
-  }
-  if (bit_pos == INVALID_BIT_POS) return -1;
-
-  // base mapping
-  Q = (127 - Q) * 100 / 127;
-  // correction for power-law behavior in low range
-  if (Q < 80) {
-    Q = (int)(pow(Q / 80., 1. / 0.38) * 80);
-  }
-  return Q;
-}

extras/vwebp_sdl.c

@@ -1,101 +0,0 @@
-// Copyright 2017 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.
-// -----------------------------------------------------------------------------
-//
-// Simple SDL-based WebP file viewer.
-// Does not support animation, just static images.
-//
-// Press 'q' to exit.
-//
-// Author: James Zern (jzern@google.com)
-
-#include <stdio.h>
-
-#ifdef HAVE_CONFIG_H
-#include "webp/config.h"
-#endif
-
-#if defined(WEBP_HAVE_SDL)
-
-#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>
-#else
-#include <SDL/SDL.h>
-#endif
-
-static void ProcessEvents(void) {
-  int done = 0;
-  SDL_Event event;
-  while (!done && SDL_WaitEvent(&event)) {
-    switch (event.type) {
-      case SDL_KEYUP:
-        switch (event.key.keysym.sym) {
-          case SDLK_q: done = 1; break;
-          default: break;
-        }
-        break;
-      default: break;
-    }
-  }
-}
-
-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]);
-      FREE_WARGV_AND_RETURN(0);
-    } else {
-      file = (const char*)GET_WARGV(argv, c);
-    }
-    if (file == NULL) continue;
-    if (!ImgIoUtilReadFile(file, &webp, &webp_size)) {
-      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) {
-      WFPRINTF(stderr, "Error decoding file %s\n", (const W_CHAR*)file);
-      goto Error;
-    }
-    ProcessEvents();
-  }
-  ok = 1;
-
- Error:
-  SDL_Quit();
-  FREE_WARGV_AND_RETURN(ok ? 0 : 1);
-}
-
-#else  // !WEBP_HAVE_SDL
-
-int main(int argc, const char *argv[]) {
-  fprintf(stderr, "SDL support not enabled in %s.\n", argv[0]);
-  (void)argc;
-  return 0;
-}
-
-#endif

extras/webp_quality.c

@@ -1,54 +0,0 @@
-// Simple tool to roughly evaluate the quality encoding of a webp bitstream
-//
-// Result is a *rough* estimation of the quality. You should just consider
-// the bucket it's in (q > 80? > 50? > 20?) and not take it for face value.
-/*
- gcc -o webp_quality webp_quality.c -O3 -I../ -L. -L../imageio \
-    -limageio_util -lwebpextras -lwebp -lm -lpthread
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#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");
-      FREE_WARGV_AND_RETURN(0);
-    } else {
-      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) WPRINTF("[%s] ", (const W_CHAR*)filename);
-      if (q < 0) {
-        fprintf(stderr, "Not a WebP file, or not a lossy WebP file.\n");
-        ok = 0;
-      } else {
-        if (!quiet) {
-          printf("Estimated quality factor: %d\n", q);
-        } else {
-          printf("%d\n", q);   // just print the number
-        }
-      }
-      free((void*)data);
-    }
-  }
-  FREE_WARGV_AND_RETURN(ok ? 0 : 1);
-}

extras/webp_to_sdl.c

@@ -1,110 +0,0 @@
-// Copyright 2017 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.
-// -----------------------------------------------------------------------------
-//
-//  Simple WebP-to-SDL wrapper. Useful for emscripten.
-//
-// Author: James Zern (jzern@google.com)
-
-#ifdef HAVE_CONFIG_H
-#include "src/webp/config.h"
-#endif
-
-#if defined(WEBP_HAVE_SDL)
-
-#include "webp_to_sdl.h"
-
-#include <stdio.h>
-#include "src/webp/decode.h"
-
-#if defined(WEBP_HAVE_JUST_SDL_H)
-#include <SDL.h>
-#else
-#include <SDL/SDL.h>
-#endif
-
-static int init_ok = 0;
-int WebpToSDL(const char* data, unsigned int data_size) {
-  int ok = 0;
-  VP8StatusCode status;
-  WebPDecoderConfig config;
-  WebPBitstreamFeatures* const input = &config.input;
-  WebPDecBuffer* const output = &config.output;
-  SDL_Surface* screen = NULL;
-  SDL_Surface* surface = NULL;
-
-  if (!WebPInitDecoderConfig(&config)) {
-    fprintf(stderr, "Library version mismatch!\n");
-    return 0;
-  }
-
-  if (!init_ok) {
-    SDL_Init(SDL_INIT_VIDEO);
-    init_ok = 1;
-  }
-
-  status = WebPGetFeatures((uint8_t*)data, (size_t)data_size, &config.input);
-  if (status != VP8_STATUS_OK) goto Error;
-
-  screen = SDL_SetVideoMode(input->width, input->height, 32, SDL_SWSURFACE);
-  if (screen == NULL) {
-    fprintf(stderr, "Unable to set video mode (32bpp %dx%d)!\n",
-            input->width, input->height);
-    goto Error;
-  }
-
-  surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
-                                 input->width, input->height, 32,
-                                 0x000000ffu,   // R mask
-                                 0x0000ff00u,   // G mask
-                                 0x00ff0000u,   // B mask
-                                 0xff000000u);  // A mask
-
-  if (surface == NULL) {
-    fprintf(stderr, "Unable to create %dx%d RGBA surface!\n",
-            input->width, input->height);
-    goto Error;
-  }
-  if (SDL_MUSTLOCK(surface)) SDL_LockSurface(surface);
-
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-  output->colorspace = MODE_BGRA;
-#else
-  output->colorspace = MODE_RGBA;
-#endif
-  output->width  = surface->w;
-  output->height = surface->h;
-  output->u.RGBA.rgba   = surface->pixels;
-  output->u.RGBA.stride = surface->pitch;
-  output->u.RGBA.size   = surface->pitch * surface->h;
-  output->is_external_memory = 1;
-
-  status = WebPDecode((const uint8_t*)data, (size_t)data_size, &config);
-  if (status != VP8_STATUS_OK) {
-    fprintf(stderr, "Error decoding image (%d)\n", status);
-    goto Error;
-  }
-
-  if (SDL_MUSTLOCK(surface)) SDL_UnlockSurface(surface);
-  if (SDL_BlitSurface(surface, NULL, screen, NULL) ||
-      SDL_Flip(screen)) {
-    goto Error;
-  }
-
-  ok = 1;
-
- Error:
-  SDL_FreeSurface(surface);
-  SDL_FreeSurface(screen);
-  WebPFreeDecBuffer(output);
-  return ok;
-}
-
-//------------------------------------------------------------------------------
-
-#endif  // WEBP_HAVE_SDL

extras/webp_to_sdl.h

@@ -1,22 +0,0 @@
-// Copyright 2017 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.
-// -----------------------------------------------------------------------------
-//
-//  Simple WebP-to-SDL wrapper. Useful for emscripten.
-//
-// Author: James Zern (jzern@google.com)
-
-#ifndef WEBP_EXTRAS_WEBP_TO_SDL_H_
-#define WEBP_EXTRAS_WEBP_TO_SDL_H_
-
-// Exports the method WebpToSDL(const char* data, int data_size) which decodes
-// a WebP bitstream into an RGBA SDL surface.
-// Return false on failure.
-extern int WebpToSDL(const char* data, unsigned int data_size);
-
-#endif  // WEBP_EXTRAS_WEBP_TO_SDL_H_

imageio/Android.mk

@@ -1,54 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-################################################################################
-# libimageio_util
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-    imageio_util.c \
-
-LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
-
-LOCAL_MODULE := imageio_util
-
-include $(BUILD_STATIC_LIBRARY)
-
-################################################################################
-# libimagedec
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-    image_dec.c \
-    jpegdec.c \
-    metadata.c \
-    pngdec.c \
-    pnmdec.c \
-    tiffdec.c \
-    webpdec.c \
-
-LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
-LOCAL_STATIC_LIBRARIES := imageio_util
-
-LOCAL_MODULE := imagedec
-
-include $(BUILD_STATIC_LIBRARY)
-
-################################################################################
-# libimageenc
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-    image_enc.c \
-
-LOCAL_CFLAGS := $(WEBP_CFLAGS)
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
-LOCAL_STATIC_LIBRARIES := imageio_util
-
-LOCAL_MODULE := imageenc
-
-include $(BUILD_STATIC_LIBRARY)

imageio/Makefile.am

@@ -1,32 +0,0 @@
-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 =
-noinst_HEADERS += ../src/webp/decode.h
-noinst_HEADERS += ../src/webp/types.h
-
-libimageio_util_la_SOURCES =
-libimageio_util_la_SOURCES += imageio_util.c imageio_util.h
-
-libimagedec_la_SOURCES  =
-libimagedec_la_SOURCES += image_dec.c image_dec.h
-libimagedec_la_SOURCES += jpegdec.c jpegdec.h
-libimagedec_la_SOURCES += metadata.c metadata.h
-libimagedec_la_SOURCES += pngdec.c pngdec.h
-libimagedec_la_SOURCES += pnmdec.c pnmdec.h
-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)
-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)

imageio/image_enc.c

@@ -1,604 +0,0 @@
-// 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.
-// -----------------------------------------------------------------------------
-//
-// Save image
-
-#include "./image_enc.h"
-
-#include <assert.h>
-#include <string.h>
-
-#ifdef WEBP_HAVE_PNG
-#include <png.h>
-#include <setjmp.h>   // note: this must be included *after* png.h
-#endif
-
-#ifdef HAVE_WINCODEC_H
-#ifdef __MINGW32__
-#define INITGUID  // Without this GUIDs are declared extern and fail to link
-#endif
-#define CINTERFACE
-#define COBJMACROS
-#define _WIN32_IE 0x500  // Workaround bug in shlwapi.h when compiling C++
-                         // 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
-
-#ifdef HAVE_WINCODEC_H
-
-#define IFS(fn)                                                     \
-  do {                                                              \
-    if (SUCCEEDED(hr)) {                                            \
-      hr = (fn);                                                    \
-      if (FAILED(hr)) fprintf(stderr, #fn " failed %08lx\n", hr);   \
-    }                                                               \
-  } while (0)
-
-#ifdef __cplusplus
-#define MAKE_REFGUID(x) (x)
-#else
-#define MAKE_REFGUID(x) &(x)
-#endif
-
-static HRESULT CreateOutputStream(const char* out_file_name,
-                                  int write_to_mem, IStream** stream) {
-  HRESULT hr = S_OK;
-  if (write_to_mem) {
-    // Output to a memory buffer. This is freed when 'stream' is released.
-    IFS(CreateStreamOnHGlobal(NULL, TRUE, stream));
-  } else {
-    IFS(SHCreateStreamOnFile((const LPTSTR)out_file_name,
-                             STGM_WRITE | STGM_CREATE, stream));
-  }
-  if (FAILED(hr)) {
-    _ftprintf(stderr, _T("Error opening output file %s (%08lx)\n"),
-              (const LPTSTR)out_file_name, hr);
-  }
-  return hr;
-}
-
-static HRESULT WriteUsingWIC(const char* out_file_name, int use_stdout,
-                             REFGUID container_guid,
-                             uint8_t* rgb, int stride,
-                             uint32_t width, uint32_t height, int has_alpha) {
-  HRESULT hr = S_OK;
-  IWICImagingFactory* factory = NULL;
-  IWICBitmapFrameEncode* frame = NULL;
-  IWICBitmapEncoder* encoder = NULL;
-  IStream* stream = NULL;
-  WICPixelFormatGUID pixel_format = has_alpha ? GUID_WICPixelFormat32bppBGRA
-                                              : GUID_WICPixelFormat24bppBGR;
-
-  if (out_file_name == NULL || rgb == NULL) return E_INVALIDARG;
-
-  IFS(CoInitialize(NULL));
-  IFS(CoCreateInstance(MAKE_REFGUID(CLSID_WICImagingFactory), NULL,
-                       CLSCTX_INPROC_SERVER,
-                       MAKE_REFGUID(IID_IWICImagingFactory),
-                       (LPVOID*)&factory));
-  if (hr == REGDB_E_CLASSNOTREG) {
-    fprintf(stderr,
-            "Couldn't access Windows Imaging Component (are you running "
-            "Windows XP SP3 or newer?). PNG support not available. "
-            "Use -ppm or -pgm for available PPM and PGM formats.\n");
-  }
-  IFS(CreateOutputStream(out_file_name, use_stdout, &stream));
-  IFS(IWICImagingFactory_CreateEncoder(factory, container_guid, NULL,
-                                       &encoder));
-  IFS(IWICBitmapEncoder_Initialize(encoder, stream,
-                                   WICBitmapEncoderNoCache));
-  IFS(IWICBitmapEncoder_CreateNewFrame(encoder, &frame, NULL));
-  IFS(IWICBitmapFrameEncode_Initialize(frame, NULL));
-  IFS(IWICBitmapFrameEncode_SetSize(frame, width, height));
-  IFS(IWICBitmapFrameEncode_SetPixelFormat(frame, &pixel_format));
-  IFS(IWICBitmapFrameEncode_WritePixels(frame, height, stride,
-                                        height * stride, rgb));
-  IFS(IWICBitmapFrameEncode_Commit(frame));
-  IFS(IWICBitmapEncoder_Commit(encoder));
-
-  if (SUCCEEDED(hr) && use_stdout) {
-    HGLOBAL image;
-    IFS(GetHGlobalFromStream(stream, &image));
-    if (SUCCEEDED(hr)) {
-      HANDLE std_output = GetStdHandle(STD_OUTPUT_HANDLE);
-      DWORD mode;
-      const BOOL update_mode = GetConsoleMode(std_output, &mode);
-      const void* const image_mem = GlobalLock(image);
-      DWORD bytes_written = 0;
-
-      // Clear output processing if necessary, then output the image.
-      if (update_mode) SetConsoleMode(std_output, 0);
-      if (!WriteFile(std_output, image_mem, (DWORD)GlobalSize(image),
-                     &bytes_written, NULL) ||
-          bytes_written != GlobalSize(image)) {
-        hr = E_FAIL;
-      }
-      if (update_mode) SetConsoleMode(std_output, mode);
-      GlobalUnlock(image);
-    }
-  }
-
-  if (frame != NULL) IUnknown_Release(frame);
-  if (encoder != NULL) IUnknown_Release(encoder);
-  if (factory != NULL) IUnknown_Release(factory);
-  if (stream != NULL) IUnknown_Release(stream);
-  return hr;
-}
-
-int WebPWritePNG(const char* out_file_name, int use_stdout,
-                 const WebPDecBuffer* const buffer) {
-  const uint32_t width = buffer->width;
-  const uint32_t height = buffer->height;
-  uint8_t* const rgb = buffer->u.RGBA.rgba;
-  const int stride = buffer->u.RGBA.stride;
-  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
-
-  return SUCCEEDED(WriteUsingWIC(out_file_name, use_stdout,
-                                 MAKE_REFGUID(GUID_ContainerFormatPng),
-                                 rgb, stride, width, height, has_alpha));
-}
-
-#elif defined(WEBP_HAVE_PNG)    // !HAVE_WINCODEC_H
-static void PNGAPI PNGErrorFunction(png_structp png, png_const_charp dummy) {
-  (void)dummy;  // remove variable-unused warning
-  longjmp(png_jmpbuf(png), 1);
-}
-
-int WebPWritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
-  volatile png_structp png;
-  volatile png_infop info;
-
-  if (out_file == NULL || buffer == NULL) return 0;
-
-  png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
-                                NULL, PNGErrorFunction, NULL);
-  if (png == NULL) {
-    return 0;
-  }
-  info = png_create_info_struct(png);
-  if (info == NULL) {
-    png_destroy_write_struct((png_structpp)&png, NULL);
-    return 0;
-  }
-  if (setjmp(png_jmpbuf(png))) {
-    png_destroy_write_struct((png_structpp)&png, (png_infopp)&info);
-    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,
-                 PNG_FILTER_TYPE_DEFAULT);
-    png_write_info(png, info);
-    for (y = 0; y < height; ++y) {
-      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;
-}
-#else    // !HAVE_WINCODEC_H && !WEBP_HAVE_PNG
-int WebPWritePNG(FILE* fout, const WebPDecBuffer* const buffer) {
-  if (fout == NULL || buffer == NULL) return 0;
-
-  fprintf(stderr, "PNG support not compiled. Please install the libpng "
-          "development package before building.\n");
-  fprintf(stderr, "You can run with -ppm flag to decode in PPM format.\n");
-  return 0;
-}
-#endif
-
-//------------------------------------------------------------------------------
-// PPM / PAM
-
-static int WritePPMPAM(FILE* fout, const WebPDecBuffer* const buffer,
-                       int alpha) {
-  if (fout == NULL || buffer == NULL) {
-    return 0;
-  } else {
-    const uint32_t width = buffer->width;
-    const uint32_t height = buffer->height;
-    const uint8_t* row = buffer->u.RGBA.rgba;
-    const int stride = buffer->u.RGBA.stride;
-    const size_t bytes_per_px = alpha ? 4 : 3;
-    uint32_t y;
-
-    if (row == NULL) return 0;
-
-    if (alpha) {
-      fprintf(fout, "P7\nWIDTH %u\nHEIGHT %u\nDEPTH 4\nMAXVAL 255\n"
-                    "TUPLTYPE RGB_ALPHA\nENDHDR\n", width, height);
-    } else {
-      fprintf(fout, "P6\n%u %u\n255\n", width, height);
-    }
-    for (y = 0; y < height; ++y) {
-      if (fwrite(row, width, bytes_per_px, fout) != bytes_per_px) {
-        return 0;
-      }
-      row += stride;
-    }
-  }
-  return 1;
-}
-
-int WebPWritePPM(FILE* fout, const WebPDecBuffer* const buffer) {
-  return WritePPMPAM(fout, buffer, 0);
-}
-
-int WebPWritePAM(FILE* fout, const WebPDecBuffer* const buffer) {
-  return WritePPMPAM(fout, buffer, 1);
-}
-
-//------------------------------------------------------------------------------
-// Raw PGM
-
-// Save 16b mode (RGBA4444, RGB565, ...) for debugging purpose.
-int WebPWrite16bAsPGM(FILE* fout, const WebPDecBuffer* const buffer) {
-  const uint32_t width = buffer->width;
-  const uint32_t height = buffer->height;
-  const uint8_t* rgba = buffer->u.RGBA.rgba;
-  const int stride = buffer->u.RGBA.stride;
-  const uint32_t bytes_per_px = 2;
-  uint32_t y;
-
-  if (fout == NULL || buffer == NULL || rgba == NULL) return 0;
-
-  fprintf(fout, "P5\n%u %u\n255\n", width * bytes_per_px, height);
-  for (y = 0; y < height; ++y) {
-    if (fwrite(rgba, width, bytes_per_px, fout) != bytes_per_px) {
-      return 0;
-    }
-    rgba += stride;
-  }
-  return 1;
-}
-
-//------------------------------------------------------------------------------
-// BMP
-
-static void PutLE16(uint8_t* const dst, uint32_t value) {
-  dst[0] = (value >> 0) & 0xff;
-  dst[1] = (value >> 8) & 0xff;
-}
-
-static void PutLE32(uint8_t* const dst, uint32_t value) {
-  PutLE16(dst + 0, (value >>  0) & 0xffff);
-  PutLE16(dst + 2, (value >> 16) & 0xffff);
-}
-
-#define BMP_HEADER_SIZE 54
-int WebPWriteBMP(FILE* fout, const WebPDecBuffer* const buffer) {
-  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
-  const uint32_t width = buffer->width;
-  const uint32_t height = buffer->height;
-  const uint8_t* rgba = buffer->u.RGBA.rgba;
-  const int stride = buffer->u.RGBA.stride;
-  const uint32_t bytes_per_px = has_alpha ? 4 : 3;
-  uint32_t y;
-  const uint32_t line_size = bytes_per_px * width;
-  const uint32_t bmp_stride = (line_size + 3) & ~3;   // pad to 4
-  const uint32_t total_size = bmp_stride * height + BMP_HEADER_SIZE;
-  uint8_t bmp_header[BMP_HEADER_SIZE] = { 0 };
-
-  if (fout == NULL || buffer == NULL || rgba == NULL) return 0;
-
-  // bitmap file header
-  PutLE16(bmp_header + 0, 0x4d42);                // signature 'BM'
-  PutLE32(bmp_header + 2, total_size);            // size including header
-  PutLE32(bmp_header + 6, 0);                     // reserved
-  PutLE32(bmp_header + 10, BMP_HEADER_SIZE);      // offset to pixel array
-  // bitmap info header
-  PutLE32(bmp_header + 14, 40);                   // DIB header size
-  PutLE32(bmp_header + 18, width);                // dimensions
-  PutLE32(bmp_header + 22, -(int)height);         // vertical flip!
-  PutLE16(bmp_header + 26, 1);                    // number of planes
-  PutLE16(bmp_header + 28, bytes_per_px * 8);     // bits per pixel
-  PutLE32(bmp_header + 30, 0);                    // no compression (BI_RGB)
-  PutLE32(bmp_header + 34, 0);                    // image size (dummy)
-  PutLE32(bmp_header + 38, 2400);                 // x pixels/meter
-  PutLE32(bmp_header + 42, 2400);                 // y pixels/meter
-  PutLE32(bmp_header + 46, 0);                    // number of palette colors
-  PutLE32(bmp_header + 50, 0);                    // important color count
-
-  // TODO(skal): color profile
-
-  // write header
-  if (fwrite(bmp_header, sizeof(bmp_header), 1, fout) != 1) {
-    return 0;
-  }
-
-  // write pixel array
-  for (y = 0; y < height; ++y) {
-    if (fwrite(rgba, line_size, 1, fout) != 1) {
-      return 0;
-    }
-    // write padding zeroes
-    if (bmp_stride != line_size) {
-      const uint8_t zeroes[3] = { 0 };
-      if (fwrite(zeroes, bmp_stride - line_size, 1, fout) != 1) {
-        return 0;
-      }
-    }
-    rgba += stride;
-  }
-  return 1;
-}
-#undef BMP_HEADER_SIZE
-
-//------------------------------------------------------------------------------
-// TIFF
-
-#define NUM_IFD_ENTRIES 15
-#define EXTRA_DATA_SIZE 16
-// 10b for signature/header + n * 12b entries + 4b for IFD terminator:
-#define EXTRA_DATA_OFFSET (10 + 12 * NUM_IFD_ENTRIES + 4)
-#define TIFF_HEADER_SIZE (EXTRA_DATA_OFFSET + EXTRA_DATA_SIZE)
-
-int WebPWriteTIFF(FILE* fout, const WebPDecBuffer* const buffer) {
-  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
-  const uint32_t width = buffer->width;
-  const uint32_t height = buffer->height;
-  const uint8_t* rgba = buffer->u.RGBA.rgba;
-  const int stride = buffer->u.RGBA.stride;
-  const uint8_t bytes_per_px = has_alpha ? 4 : 3;
-  const uint8_t assoc_alpha =
-      WebPIsPremultipliedMode(buffer->colorspace) ? 1 : 2;
-  // For non-alpha case, we omit tag 0x152 (ExtraSamples).
-  const uint8_t num_ifd_entries = has_alpha ? NUM_IFD_ENTRIES
-                                            : NUM_IFD_ENTRIES - 1;
-  uint8_t tiff_header[TIFF_HEADER_SIZE] = {
-    0x49, 0x49, 0x2a, 0x00,   // little endian signature
-    8, 0, 0, 0,               // offset to the unique IFD that follows
-    // IFD (offset = 8). Entries must be written in increasing tag order.
-    num_ifd_entries, 0,       // Number of entries in the IFD (12 bytes each).
-    0x00, 0x01, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,    //  10: Width  (TBD)
-    0x01, 0x01, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,    //  22: Height (TBD)
-    0x02, 0x01, 3, 0, bytes_per_px, 0, 0, 0,     //  34: BitsPerSample: 8888
-        EXTRA_DATA_OFFSET + 0, 0, 0, 0,
-    0x03, 0x01, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0,    //  46: Compression: none
-    0x06, 0x01, 3, 0, 1, 0, 0, 0, 2, 0, 0, 0,    //  58: Photometric: RGB
-    0x11, 0x01, 4, 0, 1, 0, 0, 0,                //  70: Strips offset:
-        TIFF_HEADER_SIZE, 0, 0, 0,               //      data follows header
-    0x12, 0x01, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0,    //  82: Orientation: topleft
-    0x15, 0x01, 3, 0, 1, 0, 0, 0,                //  94: SamplesPerPixels
-        bytes_per_px, 0, 0, 0,
-    0x16, 0x01, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,    // 106: Rows per strip (TBD)
-    0x17, 0x01, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0,    // 118: StripByteCount (TBD)
-    0x1a, 0x01, 5, 0, 1, 0, 0, 0,                // 130: X-resolution
-        EXTRA_DATA_OFFSET + 8, 0, 0, 0,
-    0x1b, 0x01, 5, 0, 1, 0, 0, 0,                // 142: Y-resolution
-        EXTRA_DATA_OFFSET + 8, 0, 0, 0,
-    0x1c, 0x01, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0,    // 154: PlanarConfiguration
-    0x28, 0x01, 3, 0, 1, 0, 0, 0, 2, 0, 0, 0,    // 166: ResolutionUnit (inch)
-    0x52, 0x01, 3, 0, 1, 0, 0, 0,
-        assoc_alpha, 0, 0, 0,                    // 178: ExtraSamples: rgbA/RGBA
-    0, 0, 0, 0,                                  // 190: IFD terminator
-    // EXTRA_DATA_OFFSET:
-    8, 0, 8, 0, 8, 0, 8, 0,      // BitsPerSample
-    72, 0, 0, 0, 1, 0, 0, 0      // 72 pixels/inch, for X/Y-resolution
-  };
-  uint32_t y;
-
-  if (fout == NULL || buffer == NULL || rgba == NULL) return 0;
-
-  // Fill placeholders in IFD:
-  PutLE32(tiff_header + 10 + 8, width);
-  PutLE32(tiff_header + 22 + 8, height);
-  PutLE32(tiff_header + 106 + 8, height);
-  PutLE32(tiff_header + 118 + 8, width * bytes_per_px * height);
-  if (!has_alpha) PutLE32(tiff_header + 178, 0);  // IFD terminator
-
-  // write header
-  if (fwrite(tiff_header, sizeof(tiff_header), 1, fout) != 1) {
-    return 0;
-  }
-  // write pixel values
-  for (y = 0; y < height; ++y) {
-    if (fwrite(rgba, bytes_per_px, width, fout) != width) {
-      return 0;
-    }
-    rgba += stride;
-  }
-
-  return 1;
-}
-
-#undef TIFF_HEADER_SIZE
-#undef EXTRA_DATA_OFFSET
-#undef EXTRA_DATA_SIZE
-#undef NUM_IFD_ENTRIES
-
-//------------------------------------------------------------------------------
-// Raw Alpha
-
-int WebPWriteAlphaPlane(FILE* fout, const WebPDecBuffer* const buffer) {
-  if (fout == NULL || buffer == NULL) {
-    return 0;
-  } else {
-    const uint32_t width = buffer->width;
-    const uint32_t height = buffer->height;
-    const uint8_t* a = buffer->u.YUVA.a;
-    const int a_stride = buffer->u.YUVA.a_stride;
-    uint32_t y;
-
-    if (a == NULL) return 0;
-
-    fprintf(fout, "P5\n%u %u\n255\n", width, height);
-    for (y = 0; y < height; ++y) {
-      if (fwrite(a, width, 1, fout) != 1) return 0;
-      a += a_stride;
-    }
-    return 1;
-  }
-}
-
-//------------------------------------------------------------------------------
-// PGM with IMC4 layout
-
-int WebPWritePGM(FILE* fout, const WebPDecBuffer* const buffer) {
-  if (fout == NULL || buffer == NULL) {
-    return 0;
-  } else {
-    const int width = buffer->width;
-    const int height = buffer->height;
-    const WebPYUVABuffer* const yuv = &buffer->u.YUVA;
-    const uint8_t* src_y = yuv->y;
-    const uint8_t* src_u = yuv->u;
-    const uint8_t* src_v = yuv->v;
-    const uint8_t* src_a = yuv->a;
-    const int uv_width = (width + 1) / 2;
-    const int uv_height = (height + 1) / 2;
-    const int a_height = (src_a != NULL) ? height : 0;
-    int ok = 1;
-    int y;
-
-    if (src_y == NULL || src_u == NULL || src_v == NULL) return 0;
-
-    fprintf(fout, "P5\n%d %d\n255\n",
-            (width + 1) & ~1, height + uv_height + a_height);
-    for (y = 0; ok && y < height; ++y) {
-      ok &= (fwrite(src_y, width, 1, fout) == 1);
-      if (width & 1) fputc(0, fout);    // padding byte
-      src_y += yuv->y_stride;
-    }
-    for (y = 0; ok && y < uv_height; ++y) {
-      ok &= (fwrite(src_u, uv_width, 1, fout) == 1);
-      ok &= (fwrite(src_v, uv_width, 1, fout) == 1);
-      src_u += yuv->u_stride;
-      src_v += yuv->v_stride;
-    }
-    for (y = 0; ok && y < a_height; ++y) {
-      ok &= (fwrite(src_a, width, 1, fout) == 1);
-      if (width & 1) fputc(0, fout);    // padding byte
-      src_a += yuv->a_stride;
-    }
-    return ok;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Raw YUV(A) planes
-
-int WebPWriteYUV(FILE* fout, const WebPDecBuffer* const buffer) {
-  if (fout == NULL || buffer == NULL) {
-    return 0;
-  } else {
-    const int width = buffer->width;
-    const int height = buffer->height;
-    const WebPYUVABuffer* const yuv = &buffer->u.YUVA;
-    const uint8_t* src_y = yuv->y;
-    const uint8_t* src_u = yuv->u;
-    const uint8_t* src_v = yuv->v;
-    const uint8_t* src_a = yuv->a;
-    const int uv_width = (width + 1) / 2;
-    const int uv_height = (height + 1) / 2;
-    const int a_height = (src_a != NULL) ? height : 0;
-    int ok = 1;
-    int y;
-
-    if (src_y == NULL || src_u == NULL || src_v == NULL) return 0;
-
-    for (y = 0; ok && y < height; ++y) {
-      ok &= (fwrite(src_y, width, 1, fout) == 1);
-      src_y += yuv->y_stride;
-    }
-    for (y = 0; ok && y < uv_height; ++y) {
-      ok &= (fwrite(src_u, uv_width, 1, fout) == 1);
-      src_u += yuv->u_stride;
-    }
-    for (y = 0; ok && y < uv_height; ++y) {
-      ok &= (fwrite(src_v, uv_width, 1, fout) == 1);
-      src_v += yuv->v_stride;
-    }
-    for (y = 0; ok && y < a_height; ++y) {
-      ok &= (fwrite(src_a, width, 1, fout) == 1);
-      src_a += yuv->a_stride;
-    }
-    return ok;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Generic top-level call
-
-int WebPSaveImage(const WebPDecBuffer* const buffer,
-                  WebPOutputFileFormat format,
-                  const char* const out_file_name) {
-  FILE* fout = NULL;
-  int needs_open_file = 1;
-  const int use_stdout =
-      (out_file_name != NULL) && !WSTRCMP(out_file_name, "-");
-  int ok = 1;
-
-  if (buffer == NULL || out_file_name == NULL) return 0;
-
-#ifdef HAVE_WINCODEC_H
-  needs_open_file = (format != PNG);
-#endif
-
-  if (needs_open_file) {
-    fout = use_stdout ? ImgIoUtilSetBinaryMode(stdout)
-                      : WFOPEN(out_file_name, "wb");
-    if (fout == NULL) {
-      WFPRINTF(stderr, "Error opening output file %s\n",
-               (const W_CHAR*)out_file_name);
-      return 0;
-    }
-  }
-
-  if (format == PNG ||
-      format == RGBA || format == BGRA || format == ARGB ||
-      format == rgbA || format == bgrA || format == Argb) {
-#ifdef HAVE_WINCODEC_H
-    ok &= WebPWritePNG(out_file_name, use_stdout, buffer);
-#else
-    ok &= WebPWritePNG(fout, buffer);
-#endif
-  } else if (format == PAM) {
-    ok &= WebPWritePAM(fout, buffer);
-  } else if (format == PPM || format == RGB || format == BGR) {
-    ok &= WebPWritePPM(fout, buffer);
-  } else if (format == RGBA_4444 || format == RGB_565 || format == rgbA_4444) {
-    ok &= WebPWrite16bAsPGM(fout, buffer);
-  } else if (format == BMP) {
-    ok &= WebPWriteBMP(fout, buffer);
-  } else if (format == TIFF) {
-    ok &= WebPWriteTIFF(fout, buffer);
-  } else if (format == RAW_YUV) {
-    ok &= WebPWriteYUV(fout, buffer);
-  } else if (format == PGM || format == YUV || format == YUVA) {
-    ok &= WebPWritePGM(fout, buffer);
-  } else if (format == ALPHA_PLANE_ONLY) {
-    ok &= WebPWriteAlphaPlane(fout, buffer);
-  }
-  if (fout != NULL && fout != stdout) {
-    fclose(fout);
-  }
-  return ok;
-}

imageio/image_enc.h

@@ -1,96 +0,0 @@
-// 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.
-// -----------------------------------------------------------------------------
-//
-//  All-in-one library to save PNG/JPEG/WebP/TIFF/WIC images.
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#ifndef WEBP_IMAGEIO_IMAGE_ENC_H_
-#define WEBP_IMAGEIO_IMAGE_ENC_H_
-
-#include <stdio.h>
-
-#ifdef HAVE_CONFIG_H
-#include "webp/config.h"
-#endif
-
-#include "webp/types.h"
-#include "webp/decode.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Output types
-typedef enum {
-  PNG = 0,
-  PAM,
-  PPM,
-  PGM,
-  BMP,
-  TIFF,
-  RAW_YUV,
-  ALPHA_PLANE_ONLY,  // this is for experimenting only
-  // forced colorspace output (for testing, mostly)
-  RGB, RGBA, BGR, BGRA, ARGB,
-  RGBA_4444, RGB_565,
-  rgbA, bgrA, Argb, rgbA_4444,
-  YUV, YUVA
-} WebPOutputFileFormat;
-
-// General all-purpose call.
-// Most formats expect a 'buffer' containing RGBA-like samples, except
-// RAW_YUV, YUV and YUVA formats.
-// If 'out_file_name' is "-", data is saved to stdout.
-// Returns false if an error occurred, true otherwise.
-int WebPSaveImage(const WebPDecBuffer* const buffer,
-                  WebPOutputFileFormat format, const char* const out_file_name);
-
-// Save to PNG.
-#ifdef HAVE_WINCODEC_H
-int WebPWritePNG(const char* out_file_name, int use_stdout,
-                 const struct WebPDecBuffer* const buffer);
-#else
-int WebPWritePNG(FILE* out_file, const WebPDecBuffer* const buffer);
-#endif
-
-// Save to PPM format (RGB, no alpha)
-int WebPWritePPM(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save to PAM format (= PPM + alpha)
-int WebPWritePAM(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save 16b mode (RGBA4444, RGB565, ...) for debugging purposes.
-int WebPWrite16bAsPGM(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save as BMP
-int WebPWriteBMP(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save as TIFF
-int WebPWriteTIFF(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save the ALPHA plane (only) as a PGM
-int WebPWriteAlphaPlane(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save as YUV samples as PGM format (using IMC4 layout).
-// See: http://www.fourcc.org/yuv.php#IMC4.
-// (very convenient format for viewing the samples, esp. for odd dimensions).
-int WebPWritePGM(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save YUV(A) planes sequentially (raw dump)
-int WebPWriteYUV(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-// Save 16b mode (RGBA4444, RGB565, ...) as PGM format, for debugging purposes.
-int WebPWrite16bAsPGM(FILE* fout, const struct WebPDecBuffer* const buffer);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  // WEBP_IMAGEIO_IMAGE_ENC_H_

imageio/imageio_util.c

@@ -1,160 +0,0 @@
-// 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.
-// -----------------------------------------------------------------------------
-//
-//  Utility functions used by the image decoders.
-//
-
-#include "./imageio_util.h"
-
-#if defined(_WIN32)
-#include <fcntl.h>   // for _O_BINARY
-#include <io.h>      // for _setmode()
-#endif
-#include <stdlib.h>
-#include <string.h>
-#include "../examples/unicode.h"
-
-// -----------------------------------------------------------------------------
-// File I/O
-
-FILE* ImgIoUtilSetBinaryMode(FILE* file) {
-#if defined(_WIN32)
-  if (_setmode(_fileno(file), _O_BINARY) == -1) {
-    fprintf(stderr, "Failed to reopen file in O_BINARY mode.\n");
-    return NULL;
-  }
-#endif
-  return file;
-}
-
-int ImgIoUtilReadFromStdin(const uint8_t** data, size_t* data_size) {
-  static const size_t kBlockSize = 16384;  // default initial size
-  size_t max_size = 0;
-  size_t size = 0;
-  uint8_t* input = NULL;
-
-  if (data == NULL || data_size == NULL) return 0;
-  *data = NULL;
-  *data_size = 0;
-
-  if (!ImgIoUtilSetBinaryMode(stdin)) return 0;
-
-  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;
-    // 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;
-    size += fread(input + size, 1, extra_size, stdin);
-    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;
-
- Error:
-  free(input);
-  fprintf(stderr, "Could not read from stdin\n");
-  return 0;
-}
-
-int ImgIoUtilReadFile(const char* const file_name,
-                      const uint8_t** data, size_t* data_size) {
-  int ok;
-  uint8_t* file_data;
-  size_t file_size;
-  FILE* in;
-  const int from_stdin = (file_name == NULL) || !WSTRCMP(file_name, "-");
-
-  if (from_stdin) return ImgIoUtilReadFromStdin(data, data_size);
-
-  if (data == NULL || data_size == NULL) return 0;
-  *data = NULL;
-  *data_size = 0;
-
-  in = WFOPEN(file_name, "rb");
-  if (in == NULL) {
-    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);
-  // 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) {
-    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;
-  }
-  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) || !WSTRCMP(file_name, "-");
-
-  if (data == NULL) {
-    return 0;
-  }
-  out = to_stdout ? ImgIoUtilSetBinaryMode(stdout) : WFOPEN(file_name, "wb");
-  if (out == NULL) {
-    WFPRINTF(stderr, "Error! Cannot open output file '%s'\n",
-             (const W_CHAR*)file_name);
-    return 0;
-  }
-  ok = (fwrite(data, data_size, 1, out) == 1);
-  if (out != stdout) fclose(out);
-  return ok;
-}
-
-// -----------------------------------------------------------------------------
-
-void ImgIoUtilCopyPlane(const uint8_t* src, int src_stride,
-                        uint8_t* dst, int dst_stride, int width, int height) {
-  while (height-- > 0) {
-    memcpy(dst, src, width * sizeof(*dst));
-    src += src_stride;
-    dst += dst_stride;
-  }
-}
-
-// -----------------------------------------------------------------------------
-
-int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t nmemb, size_t size) {
-  const uint64_t total_size = nmemb * size;
-  int ok = (total_size == (size_t)total_size);
-#if defined(WEBP_MAX_IMAGE_SIZE)
-  ok = ok && (total_size <= (uint64_t)WEBP_MAX_IMAGE_SIZE);
-#endif
-  return ok;
-}
-
-// -----------------------------------------------------------------------------

imageio/imageio_util.h

@@ -1,64 +0,0 @@
-// 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.
-// -----------------------------------------------------------------------------
-//
-//  Utility functions used by the image decoders.
-//
-
-#ifndef WEBP_IMAGEIO_IMAGEIO_UTIL_H_
-#define WEBP_IMAGEIO_IMAGEIO_UTIL_H_
-
-#include <stdio.h>
-#include "webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//------------------------------------------------------------------------------
-// File I/O
-
-// Reopen file in binary (O_BINARY) mode.
-// Returns 'file' on success, NULL otherwise.
-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,
-                      const uint8_t** data, size_t* data_size);
-
-// Same as ImgIoUtilReadFile(), but reads until EOF from stdin instead.
-int ImgIoUtilReadFromStdin(const uint8_t** data, size_t* data_size);
-
-// Write a data segment into a file named 'file_name'. Returns true if ok.
-// If 'file_name' is NULL or equal to "-", output is written to stdout.
-int ImgIoUtilWriteFile(const char* const file_name,
-                       const uint8_t* data, size_t data_size);
-
-//------------------------------------------------------------------------------
-
-// Copy width x height pixels from 'src' to 'dst' honoring the strides.
-void ImgIoUtilCopyPlane(const uint8_t* src, int src_stride,
-                        uint8_t* dst, int dst_stride, int width, int height);
-
-//------------------------------------------------------------------------------
-
-// Returns 0 in case of overflow of nmemb * size.
-int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t nmemb, size_t size);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  // WEBP_IMAGEIO_IMAGEIO_UTIL_H_

imageio/pnmdec.c

@@ -1,257 +0,0 @@
-// Copyright 2017 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.
-// -----------------------------------------------------------------------------
-//
-// (limited) PNM decoder
-
-#include "./pnmdec.h"
-
-#include <assert.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "webp/encode.h"
-#include "./imageio_util.h"
-
-typedef enum {
-  WIDTH_FLAG      = 1 << 0,
-  HEIGHT_FLAG     = 1 << 1,
-  DEPTH_FLAG      = 1 << 2,
-  MAXVAL_FLAG     = 1 << 3,
-  TUPLE_FLAG      = 1 << 4,
-  ALL_NEEDED_FLAGS = 0x1f
-} PNMFlags;
-
-typedef struct {
-  const uint8_t* data;
-  size_t data_size;
-  int width, height;
-  int bytes_per_px;   // 1, 3, 4
-  int depth;
-  int max_value;
-  int type;           // 5, 6 or 7
-  int seen_flags;
-} PNMInfo;
-
-// -----------------------------------------------------------------------------
-// PNM decoding
-
-#define MAX_LINE_SIZE 1024
-static const size_t kMinPNMHeaderSize = 3;
-
-static size_t ReadLine(const uint8_t* const data, size_t off, size_t data_size,
-                       char out[MAX_LINE_SIZE + 1], size_t* const out_size) {
-  size_t i = 0;
-  *out_size = 0;
- redo:
-  for (i = 0; i < MAX_LINE_SIZE && off < data_size; ++i) {
-    out[i] = data[off++];
-    if (out[i] == '\n') break;
-  }
-  if (off < data_size) {
-    if (i == 0) goto redo;         // empty line
-    if (out[0] == '#') goto redo;  // skip comment
-  }
-  out[i] = 0;   // safety sentinel
-  *out_size = i;
-  return off;
-}
-
-static size_t FlagError(const char flag[]) {
-  fprintf(stderr, "PAM header error: flags '%s' already seen.\n", flag);
-  return 0;
-}
-
-// inspired from http://netpbm.sourceforge.net/doc/pam.html
-static size_t ReadPAMFields(PNMInfo* const info, size_t off) {
-  char out[MAX_LINE_SIZE + 1];
-  size_t out_size;
-  int tmp;
-  assert(info != NULL);
-  while (1) {
-    off = ReadLine(info->data, off, info->data_size, out, &out_size);
-    if (off == 0) return 0;
-    if (sscanf(out, "WIDTH %d", &tmp) == 1) {
-      if (info->seen_flags & WIDTH_FLAG) return FlagError("WIDTH");
-      info->seen_flags |= WIDTH_FLAG;
-      info->width = tmp;
-    } else if (sscanf(out, "HEIGHT %d", &tmp) == 1) {
-      if (info->seen_flags & HEIGHT_FLAG) return FlagError("HEIGHT");
-      info->seen_flags |= HEIGHT_FLAG;
-      info->height = tmp;
-    } else if (sscanf(out, "DEPTH %d", &tmp) == 1) {
-      if (info->seen_flags & DEPTH_FLAG) return FlagError("DEPTH");
-      info->seen_flags |= DEPTH_FLAG;
-      info->depth = tmp;
-    } else if (sscanf(out, "MAXVAL %d", &tmp) == 1) {
-      if (info->seen_flags & MAXVAL_FLAG) return FlagError("MAXVAL");
-      info->seen_flags |= MAXVAL_FLAG;
-      info->max_value = tmp;
-    } else if (!strcmp(out, "TUPLTYPE RGB_ALPHA")) {
-      info->bytes_per_px = 4;
-      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "TUPLTYPE RGB")) {
-      info->bytes_per_px = 3;
-      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "TUPLTYPE GRAYSCALE")) {
-      info->bytes_per_px = 1;
-      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "ENDHDR")) {
-      break;
-    } else {
-      static const char kEllipsis[] = " ...";
-      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] = ' ';
-      }
-      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->depth != 2) {
-      info->seen_flags |= TUPLE_FLAG;
-      info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
-    } else {
-      fprintf(stderr, "PAM: invalid bitdepth (%d).\n", info->depth);
-      return 0;
-    }
-  }
-  if (info->seen_flags != ALL_NEEDED_FLAGS) {
-    fprintf(stderr, "PAM: incomplete header.\n");
-    return 0;
-  }
-  return off;
-}
-
-static size_t ReadHeader(PNMInfo* const info) {
-  size_t off = 0;
-  char out[MAX_LINE_SIZE + 1];
-  size_t out_size;
-  if (info == NULL) return 0;
-  if (info->data == NULL || info->data_size < kMinPNMHeaderSize) return 0;
-
-  info->width = info->height = 0;
-  info->type = -1;
-  info->seen_flags = 0;
-  info->bytes_per_px = 0;
-  info->depth = 0;
-  info->max_value = 0;
-
-  off = ReadLine(info->data, off, info->data_size, out, &out_size);
-  if (off == 0 || sscanf(out, "P%d", &info->type) != 1) return 0;
-  if (info->type == 7) {
-    off = ReadPAMFields(info, off);
-  } else {
-    off = ReadLine(info->data, off, info->data_size, out, &out_size);
-    if (off == 0 || sscanf(out, "%d %d", &info->width, &info->height) != 2) {
-      return 0;
-    }
-    off = ReadLine(info->data, off, info->data_size, out, &out_size);
-    if (off == 0 || sscanf(out, "%d", &info->max_value) != 1) return 0;
-
-    // finish initializing missing fields
-    info->depth = (info->type == 5) ? 1 : 3;
-    info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
-  }
-  // perform some basic numerical validation
-  if (info->width <= 0 || info->height <= 0 ||
-      info->type <= 0 || info->type >= 9 ||
-      info->depth <= 0 || info->depth == 2 || info->depth > 4 ||
-      info->bytes_per_px < info->depth ||
-      info->max_value <= 0 || info->max_value >= 65536) {
-    return 0;
-  }
-  return off;
-}
-
-int ReadPNM(const uint8_t* const data, size_t data_size,
-            WebPPicture* const pic, int keep_alpha,
-            struct Metadata* const metadata) {
-  int ok = 0;
-  int i, j;
-  uint64_t stride, pixel_bytes;
-  uint8_t* rgb = NULL, *tmp_rgb;
-  size_t offset;
-  PNMInfo info;
-
-  info.data = data;
-  info.data_size = data_size;
-  offset = ReadHeader(&info);
-  if (offset == 0) {
-    fprintf(stderr, "Error parsing PNM header.\n");
-    goto End;
-  }
-
-  if (info.type < 5 || info.type > 7) {
-    fprintf(stderr, "Unsupported P%d PNM format.\n", info.type);
-    goto End;
-  }
-
-  // Some basic validations.
-  if (pic == NULL) goto End;
-  if (info.width > WEBP_MAX_DIMENSION || info.height > WEBP_MAX_DIMENSION) {
-    fprintf(stderr, "Invalid %dx%d dimension for PNM\n",
-                    info.width, info.height);
-    goto End;
-  }
-
-  pixel_bytes = (uint64_t)info.width * info.height * info.bytes_per_px;
-  if (data_size < offset + pixel_bytes) {
-    fprintf(stderr, "Truncated PNM file (P%d).\n", info.type);
-    goto End;
-  }
-  stride =
-      (uint64_t)(info.bytes_per_px < 3 ? 3 : info.bytes_per_px) * info.width;
-  if (stride != (size_t)stride ||
-      !ImgIoUtilCheckSizeArgumentsOverflow(stride, info.height)) {
-    goto End;
-  }
-
-  rgb = (uint8_t*)malloc((size_t)stride * info.height);
-  if (rgb == NULL) goto End;
-
-  // Convert input
-  tmp_rgb = rgb;
-  for (j = 0; j < info.height; ++j) {
-    assert(offset + info.bytes_per_px * info.width <= data_size);
-    if (info.depth == 1) {
-      // convert grayscale -> RGB
-      for (i = 0; i < info.width; ++i) {
-        const uint8_t v = data[offset + i];
-        tmp_rgb[3 * i + 0] = tmp_rgb[3 * i + 1] = tmp_rgb[3 * i + 2] = v;
-      }
-    } else if (info.depth == 3) {   // RGB
-      memcpy(tmp_rgb, data + offset, 3 * info.width * sizeof(*data));
-    } else if (info.depth == 4) {   // RGBA
-      memcpy(tmp_rgb, data + offset, 4 * info.width * sizeof(*data));
-    }
-    offset += info.bytes_per_px * info.width;
-    tmp_rgb += stride;
-  }
-
-  // WebP conversion.
-  pic->width = info.width;
-  pic->height = info.height;
-  ok = (info.depth == 4) ? WebPPictureImportRGBA(pic, rgb, (int)stride)
-                         : WebPPictureImportRGB(pic, rgb, (int)stride);
-  if (!ok) goto End;
-
-  ok = 1;
- End:
-  free((void*)rgb);
-
-  (void)metadata;
-  (void)keep_alpha;
-  return ok;
-}
-
-// -----------------------------------------------------------------------------

imageio/pnmdec.h

@@ -1,37 +0,0 @@
-// Copyright 2017 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.
-// -----------------------------------------------------------------------------
-//
-// partial PNM format decoder (ppm/pgm)
-
-#ifndef WEBP_IMAGEIO_PNMDEC_H_
-#define WEBP_IMAGEIO_PNMDEC_H_
-
-#include "webp/types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct Metadata;
-struct WebPPicture;
-
-// Reads a PNM file from 'data', returning the decoded output in 'pic'.
-// The output is RGB or YUV depending on pic->use_argb value.
-// Returns true on success.
-// 'metadata' has no effect, but is kept for coherence with other signatures
-// for image readers.
-int ReadPNM(const uint8_t* const data, size_t data_size,
-            struct WebPPicture* const pic, int keep_alpha,
-            struct Metadata* const metadata);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  // WEBP_IMAGEIO_PNMDEC_H_

imageio/webpdec.c

@@ -1,244 +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.
-// -----------------------------------------------------------------------------
-//
-// WebP decode.
-
-#ifdef HAVE_CONFIG_H
-#include "webp/config.h"
-#endif
-
-#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"
-
-//------------------------------------------------------------------------------
-// WebP decoding
-
-static const char* const kStatusMessages[VP8_STATUS_NOT_ENOUGH_DATA + 1] = {
-  "OK", "OUT_OF_MEMORY", "INVALID_PARAM", "BITSTREAM_ERROR",
-  "UNSUPPORTED_FEATURE", "SUSPENDED", "USER_ABORT", "NOT_ENOUGH_DATA"
-};
-
-static void PrintAnimationWarning(const WebPDecoderConfig* const config) {
-  if (config->input.has_animation) {
-    fprintf(stderr,
-            "Error! Decoding of an animated WebP file is not supported.\n"
-            "       Use webpmux to extract the individual frames or\n"
-            "       vwebp to view this image.\n");
-  }
-}
-
-void PrintWebPError(const char* const in_file, int status) {
-  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]);
-  }
-  fprintf(stderr, "\n");
-}
-
-int LoadWebP(const char* const in_file,
-             const uint8_t** data, size_t* data_size,
-             WebPBitstreamFeatures* bitstream) {
-  VP8StatusCode status;
-  WebPBitstreamFeatures local_features;
-  if (!ImgIoUtilReadFile(in_file, data, data_size)) return 0;
-
-  if (bitstream == NULL) {
-    bitstream = &local_features;
-  }
-
-  status = WebPGetFeatures(*data, *data_size, bitstream);
-  if (status != VP8_STATUS_OK) {
-    free((void*)*data);
-    *data = NULL;
-    *data_size = 0;
-    PrintWebPError(in_file, status);
-    return 0;
-  }
-  return 1;
-}
-
-//------------------------------------------------------------------------------
-
-VP8StatusCode DecodeWebP(const uint8_t* const data, size_t data_size,
-                         WebPDecoderConfig* const config) {
-  if (config == NULL) return VP8_STATUS_INVALID_PARAM;
-  PrintAnimationWarning(config);
-  return WebPDecode(data, data_size, config);
-}
-
-VP8StatusCode DecodeWebPIncremental(
-    const uint8_t* const data, size_t data_size,
-    WebPDecoderConfig* const config) {
-  VP8StatusCode status = VP8_STATUS_OK;
-  if (config == NULL) return VP8_STATUS_INVALID_PARAM;
-
-  PrintAnimationWarning(config);
-
-  // Decoding call.
-  {
-    WebPIDecoder* const idec = WebPIDecode(data, data_size, config);
-    if (idec == NULL) {
-      fprintf(stderr, "Failed during WebPINewDecoder().\n");
-      return VP8_STATUS_OUT_OF_MEMORY;
-    } else {
-      status = WebPIUpdate(idec, data, data_size);
-      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,
-             WebPPicture* const pic,
-             int keep_alpha, Metadata* const metadata) {
-  int ok = 0;
-  VP8StatusCode status = VP8_STATUS_OK;
-  WebPDecoderConfig config;
-  WebPDecBuffer* const output_buffer = &config.output;
-  WebPBitstreamFeatures* const bitstream = &config.input;
-
-  if (data == NULL || data_size == 0 || pic == NULL) return 0;
-
-  if (!WebPInitDecoderConfig(&config)) {
-    fprintf(stderr, "Library version mismatch!\n");
-    return 0;
-  }
-
-  status = WebPGetFeatures(data, data_size, bitstream);
-  if (status != VP8_STATUS_OK) {
-    PrintWebPError("input data", status);
-    return 0;
-  }
-
-  do {
-    const int has_alpha = keep_alpha && bitstream->has_alpha;
-    uint64_t stride;
-    pic->width = bitstream->width;
-    pic->height = bitstream->height;
-    if (pic->use_argb) {
-      stride = (uint64_t)bitstream->width * 4;
-    } else {
-      stride = (uint64_t)bitstream->width * (has_alpha ? 5 : 3) / 2;
-      pic->colorspace = has_alpha ? WEBP_YUV420A : WEBP_YUV420;
-    }
-
-    if (!ImgIoUtilCheckSizeArgumentsOverflow(stride, bitstream->height)) {
-      status = VP8_STATUS_OUT_OF_MEMORY;
-      break;
-    }
-
-    ok = WebPPictureAlloc(pic);
-    if (!ok) {
-      status = VP8_STATUS_OUT_OF_MEMORY;
-      break;
-    }
-    if (pic->use_argb) {
-#ifdef WORDS_BIGENDIAN
-      output_buffer->colorspace = MODE_ARGB;
-#else
-      output_buffer->colorspace = MODE_BGRA;
-#endif
-      output_buffer->u.RGBA.rgba = (uint8_t*)pic->argb;
-      output_buffer->u.RGBA.stride = pic->argb_stride * sizeof(uint32_t);
-      output_buffer->u.RGBA.size = output_buffer->u.RGBA.stride * pic->height;
-    } else {
-      output_buffer->colorspace = has_alpha ? MODE_YUVA : MODE_YUV;
-      output_buffer->u.YUVA.y = pic->y;
-      output_buffer->u.YUVA.u = pic->u;
-      output_buffer->u.YUVA.v = pic->v;
-      output_buffer->u.YUVA.a = has_alpha ? pic->a : NULL;
-      output_buffer->u.YUVA.y_stride = pic->y_stride;
-      output_buffer->u.YUVA.u_stride = pic->uv_stride;
-      output_buffer->u.YUVA.v_stride = pic->uv_stride;
-      output_buffer->u.YUVA.a_stride = has_alpha ? pic->a_stride : 0;
-      output_buffer->u.YUVA.y_size = pic->height * pic->y_stride;
-      output_buffer->u.YUVA.u_size = (pic->height + 1) / 2 * pic->uv_stride;
-      output_buffer->u.YUVA.v_size = (pic->height + 1) / 2 * pic->uv_stride;
-      output_buffer->u.YUVA.a_size = pic->height * pic->a_stride;
-    }
-    output_buffer->is_external_memory = 1;
-
-    status = DecodeWebP(data, data_size, &config);
-    ok = (status == VP8_STATUS_OK);
-    if (ok && !keep_alpha && pic->use_argb) {
-      // Need to wipe out the alpha value, as requested.
-      int x, y;
-      uint32_t* argb = pic->argb;
-      for (y = 0; y < pic->height; ++y) {
-        for (x = 0; x < pic->width; ++x) argb[x] |= 0xff000000u;
-        argb += pic->argb_stride;
-      }
-    }
-  } while (0);   // <- so we can 'break' out of the loop
-
-  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/webpdec.h

@@ -1,67 +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.
-// -----------------------------------------------------------------------------
-//
-// WebP decode.
-
-#ifndef WEBP_IMAGEIO_WEBPDEC_H_
-#define WEBP_IMAGEIO_WEBPDEC_H_
-
-#include "webp/decode.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct Metadata;
-struct WebPPicture;
-
-//------------------------------------------------------------------------------
-// WebP decoding
-
-// Prints an informative error message regarding decode failure of 'in_file'.
-// 'status' is treated as a VP8StatusCode and if valid will be printed as a
-// text string.
-void PrintWebPError(const char* const in_file, int status);
-
-// Reads a WebP from 'in_file', returning the contents and size in 'data' and
-// 'data_size'. If not NULL, 'bitstream' is populated using WebPGetFeatures().
-// Returns true on success.
-int LoadWebP(const char* const in_file,
-             const uint8_t** data, size_t* data_size,
-             WebPBitstreamFeatures* bitstream);
-
-// Decodes the WebP contained in 'data'.
-// 'config' is a structure previously initialized by WebPInitDecoderConfig().
-// 'config->output' should have the desired colorspace selected.
-// Returns the decoder status. On success 'config->output' will contain the
-// decoded picture.
-VP8StatusCode DecodeWebP(const uint8_t* const data, size_t data_size,
-                         WebPDecoderConfig* const config);
-
-// Same as DecodeWebP(), but using the incremental decoder.
-VP8StatusCode DecodeWebPIncremental(
-    const uint8_t* const data, size_t data_size,
-    WebPDecoderConfig* const config);
-
-//------------------------------------------------------------------------------
-
-// Decodes a WebP contained in 'data', returning the decoded output in 'pic'.
-// Output is RGBA or YUVA, depending on pic->use_argb value.
-// If 'keep_alpha' is true and the WebP has an alpha channel, the output is RGBA
-// or YUVA. Otherwise, alpha channel is dropped and output is RGB or YUV.
-// Returns true on success.
-int ReadWebP(const uint8_t* const data, size_t data_size,
-             struct WebPPicture* const pic,
-             int keep_alpha, struct Metadata* const metadata);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  // WEBP_IMAGEIO_WEBPDEC_H_

iosbuild.sh

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

@@ -3,7 +3,7 @@
 # It will not install the libraries system-wide, but just create the 'cwebp'
 # and 'dwebp' tools in the examples/ directory, along with the static
 # libraries 'src/libwebp.a', 'src/libwebpdecoder.a', 'src/mux/libwebpmux.a',
-# 'src/demux/libwebpdemux.a' and 'extras/libwebpextras.a'.
+# 'src/demux/libwebpdemux.a' and 'src/libwebpextras.a'.
 #
 # To build the library and examples, use:
 #    make -f makefile.unix
@@ -25,26 +25,13 @@ 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
 else
-  EXTRA_FLAGS += -I/usr/local/include
-  EXTRA_LIBS  += -L/usr/local/lib
   GL_LIBS = -lglut -lGL
 endif
 
-# SDL flags: use sdl-config if it exists
-SDL_CONFIG = $(shell sdl-config --version 2> /dev/null)
-ifneq ($(SDL_CONFIG),)
-  SDL_LIBS = $(shell sdl-config --libs)
-  SDL_FLAGS = $(shell sdl-config --cflags)
-else
-  # use best-guess
-  SDL_LIBS = -lSDL
-  SDL_FLAGS =
-endif
 
 # To install libraries on Mac OS X:
 # 1. Install MacPorts (http://www.macports.org/install.php)
@@ -64,8 +51,11 @@ 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
+# EXTRA_FLAGS += -DWEBP_SWAP_16BIT_CSP
 
 # Extra flags to enable multi-threading
 EXTRA_FLAGS += -DWEBP_USE_THREAD
@@ -89,6 +79,12 @@ 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
@@ -105,37 +101,28 @@ endif
 
 AR = ar
 ARFLAGS = r
-CPPFLAGS = -I. -Isrc/ -Wall
-ifeq ($(DEBUG), 1)
-  CFLAGS = -g
-else
-  CFLAGS = -O3 -DNDEBUG
-endif
-CFLAGS += $(EXTRA_FLAGS)
+CPPFLAGS = -Isrc/ -Wall
+CFLAGS = -O3 -DNDEBUG $(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 \
 
 DEC_OBJS = \
-    src/dec/alpha_dec.o \
-    src/dec/buffer_dec.o \
-    src/dec/frame_dec.o \
-    src/dec/idec_dec.o \
-    src/dec/io_dec.o \
-    src/dec/quant_dec.o \
-    src/dec/tree_dec.o \
-    src/dec/vp8_dec.o \
-    src/dec/vp8l_dec.o \
-    src/dec/webp_dec.o \
+    src/dec/alpha.o \
+    src/dec/buffer.o \
+    src/dec/frame.o \
+    src/dec/idec.o \
+    src/dec/io.o \
+    src/dec/quant.o \
+    src/dec/tree.o \
+    src/dec/vp8.o \
+    src/dec/vp8l.o \
+    src/dec/webp.o \
 
 DEMUX_OBJS = \
     src/demux/anim_decode.o \
@@ -144,7 +131,6 @@ DEMUX_OBJS = \
 DSP_DEC_OBJS = \
     src/dsp/alpha_processing.o \
     src/dsp/alpha_processing_mips_dsp_r2.o \
-    src/dsp/alpha_processing_neon.o \
     src/dsp/alpha_processing_sse2.o \
     src/dsp/alpha_processing_sse41.o \
     src/dsp/cpu.o \
@@ -158,92 +144,78 @@ DSP_DEC_OBJS = \
     src/dsp/dec_sse41.o \
     src/dsp/filters.o \
     src/dsp/filters_mips_dsp_r2.o \
-    src/dsp/filters_msa.o \
-    src/dsp/filters_neon.o \
     src/dsp/filters_sse2.o \
     src/dsp/lossless.o \
     src/dsp/lossless_mips_dsp_r2.o \
-    src/dsp/lossless_msa.o \
     src/dsp/lossless_neon.o \
     src/dsp/lossless_sse2.o \
     src/dsp/rescaler.o \
     src/dsp/rescaler_mips32.o \
     src/dsp/rescaler_mips_dsp_r2.o \
-    src/dsp/rescaler_msa.o \
     src/dsp/rescaler_neon.o \
     src/dsp/rescaler_sse2.o \
     src/dsp/upsampling.o \
     src/dsp/upsampling_mips_dsp_r2.o \
-    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/argb.o \
+    src/dsp/argb_mips_dsp_r2.o \
+    src/dsp/argb_sse2.o \
     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 \
     src/dsp/enc_neon.o \
     src/dsp/enc_sse2.o \
     src/dsp/enc_sse41.o \
     src/dsp/lossless_enc.o \
     src/dsp/lossless_enc_mips32.o \
     src/dsp/lossless_enc_mips_dsp_r2.o \
-    src/dsp/lossless_enc_msa.o \
     src/dsp/lossless_enc_neon.o \
     src/dsp/lossless_enc_sse2.o \
     src/dsp/lossless_enc_sse41.o \
-    src/dsp/ssim.o \
-    src/dsp/ssim_sse2.o \
 
 ENC_OBJS = \
-    src/enc/alpha_enc.o \
-    src/enc/analysis_enc.o \
-    src/enc/backward_references_cost_enc.o \
-    src/enc/backward_references_enc.o \
-    src/enc/config_enc.o \
-    src/enc/cost_enc.o \
-    src/enc/filter_enc.o \
-    src/enc/frame_enc.o \
-    src/enc/histogram_enc.o \
-    src/enc/iterator_enc.o \
-    src/enc/near_lossless_enc.o \
-    src/enc/picture_enc.o \
-    src/enc/picture_csp_enc.o \
-    src/enc/picture_psnr_enc.o \
-    src/enc/picture_rescale_enc.o \
-    src/enc/picture_tools_enc.o \
-    src/enc/predictor_enc.o \
-    src/enc/quant_enc.o \
-    src/enc/syntax_enc.o \
-    src/enc/token_enc.o \
-    src/enc/tree_enc.o \
-    src/enc/vp8l_enc.o \
-    src/enc/webp_enc.o \
+    src/enc/alpha.o \
+    src/enc/analysis.o \
+    src/enc/backward_references.o \
+    src/enc/config.o \
+    src/enc/cost.o \
+    src/enc/delta_palettization.o \
+    src/enc/filter.o \
+    src/enc/frame.o \
+    src/enc/histogram.o \
+    src/enc/iterator.o \
+    src/enc/near_lossless.o \
+    src/enc/picture.o \
+    src/enc/picture_csp.o \
+    src/enc/picture_psnr.o \
+    src/enc/picture_rescale.o \
+    src/enc/picture_tools.o \
+    src/enc/quant.o \
+    src/enc/syntax.o \
+    src/enc/token.o \
+    src/enc/tree.o \
+    src/enc/vp8l.o \
+    src/enc/webpenc.o \
 
 EX_FORMAT_DEC_OBJS = \
-    imageio/image_dec.o \
-    imageio/jpegdec.o \
-    imageio/metadata.o \
-    imageio/pngdec.o \
-    imageio/pnmdec.o \
-    imageio/tiffdec.o \
-    imageio/webpdec.o \
-
-EX_FORMAT_ENC_OBJS = \
-    imageio/image_enc.o \
+    examples/image_dec.o \
+    examples/jpegdec.o \
+    examples/metadata.o \
+    examples/pngdec.o \
+    examples/tiffdec.o \
+    examples/webpdec.o \
 
 EX_UTIL_OBJS = \
     examples/example_util.o \
@@ -251,9 +223,6 @@ EX_UTIL_OBJS = \
 GIFDEC_OBJS = \
     examples/gifdec.o \
 
-IMAGE_UTIL_OBJS = \
-    imageio/imageio_util.o \
-
 MUX_OBJS = \
     src/mux/anim_encode.o \
     src/mux/muxedit.o \
@@ -261,24 +230,23 @@ MUX_OBJS = \
     src/mux/muxread.o \
 
 UTILS_DEC_OBJS = \
-    src/utils/bit_reader_utils.o \
-    src/utils/color_cache_utils.o \
-    src/utils/filters_utils.o \
-    src/utils/huffman_utils.o \
-    src/utils/quant_levels_dec_utils.o \
-    src/utils/random_utils.o \
-    src/utils/rescaler_utils.o \
-    src/utils/thread_utils.o \
+    src/utils/bit_reader.o \
+    src/utils/color_cache.o \
+    src/utils/filters.o \
+    src/utils/huffman.o \
+    src/utils/quant_levels_dec.o \
+    src/utils/random.o \
+    src/utils/rescaler.o \
+    src/utils/thread.o \
     src/utils/utils.o \
 
 UTILS_ENC_OBJS = \
-    src/utils/bit_writer_utils.o \
-    src/utils/huffman_encode_utils.o \
-    src/utils/quant_levels_utils.o \
+    src/utils/bit_writer.o \
+    src/utils/huffman_encode.o \
+    src/utils/quant_levels.o \
 
 EXTRA_OBJS = \
-    extras/extras.o \
-    extras/quality_estimate.o \
+    src/extras/extras.o \
 
 LIBWEBPDECODER_OBJS = $(DEC_OBJS) $(DSP_DEC_OBJS) $(UTILS_DEC_OBJS)
 LIBWEBP_OBJS = $(LIBWEBPDECODER_OBJS) $(ENC_OBJS) $(DSP_ENC_OBJS) \
@@ -296,171 +264,115 @@ HDRS_INSTALLED = \
     src/webp/types.h \
 
 HDRS = \
-    src/dec/alphai_dec.h \
-    src/dec/common_dec.h \
-    src/dec/vp8_dec.h \
-    src/dec/vp8i_dec.h \
-    src/dec/vp8li_dec.h \
-    src/dec/webpi_dec.h \
+    src/dec/alphai.h \
+    src/dec/common.h \
+    src/dec/decode_vp8.h \
+    src/dec/vp8i.h \
+    src/dec/vp8li.h \
+    src/dec/webpi.h \
     src/dsp/common_sse2.h \
     src/dsp/dsp.h \
     src/dsp/lossless.h \
-    src/dsp/lossless_common.h \
     src/dsp/mips_macro.h \
     src/dsp/msa_macro.h \
     src/dsp/neon.h \
     src/dsp/yuv.h \
-    src/enc/backward_references_enc.h \
-    src/enc/cost_enc.h \
-    src/enc/histogram_enc.h \
-    src/enc/vp8i_enc.h \
-    src/enc/vp8li_enc.h \
-    src/mux/animi.h \
+    src/enc/backward_references.h \
+    src/enc/cost.h \
+    src/enc/delta_palettization.h \
+    src/enc/histogram.h \
+    src/enc/vp8enci.h \
+    src/enc/vp8li.h \
     src/mux/muxi.h \
-    src/utils/bit_reader_utils.h \
-    src/utils/bit_reader_inl_utils.h \
-    src/utils/bit_writer_utils.h \
-    src/utils/color_cache_utils.h \
-    src/utils/endian_inl_utils.h \
-    src/utils/filters_utils.h \
-    src/utils/huffman_utils.h \
-    src/utils/huffman_encode_utils.h \
-    src/utils/quant_levels_utils.h \
-    src/utils/quant_levels_dec_utils.h \
-    src/utils/random_utils.h \
-    src/utils/rescaler_utils.h \
-    src/utils/thread_utils.h \
+    src/utils/bit_reader.h \
+    src/utils/bit_reader_inl.h \
+    src/utils/bit_writer.h \
+    src/utils/color_cache.h \
+    src/utils/endian_inl.h \
+    src/utils/filters.h \
+    src/utils/huffman.h \
+    src/utils/huffman_encode.h \
+    src/utils/quant_levels.h \
+    src/utils/quant_levels_dec.h \
+    src/utils/random.h \
+    src/utils/rescaler.h \
+    src/utils/thread.h \
     src/utils/utils.h \
     src/webp/format_constants.h \
     $(HDRS_INSTALLED) \
 
-OUT_LIBS = examples/libexample_util.a
-OUT_LIBS += imageio/libimageio_util.a
-OUT_LIBS += imageio/libimagedec.a
-OUT_LIBS += imageio/libimageenc.a
-OUT_LIBS += src/libwebpdecoder.a
-OUT_LIBS += src/libwebp.a
-EXTRA_LIB = extras/libwebpextras.a
+OUT_LIBS = examples/libexample_util.a src/libwebpdecoder.a src/libwebp.a
+EXTRA_LIB = src/libwebpextras.a
 OUT_EXAMPLES = examples/cwebp examples/dwebp
 EXTRA_EXAMPLES = examples/gif2webp examples/vwebp examples/webpmux \
-                 examples/anim_diff examples/anim_dump \
-                 examples/img2webp examples/webpinfo
-OTHER_EXAMPLES = extras/get_disto extras/webp_quality extras/vwebp_sdl
+                 examples/anim_diff
 
 OUTPUT = $(OUT_LIBS) $(OUT_EXAMPLES)
 ifeq ($(MAKECMDGOALS),clean)
-  OUTPUT += $(EXTRA_EXAMPLES) $(OTHER_EXAMPLES)
+  OUTPUT += $(EXTRA_EXAMPLES)
   OUTPUT += src/demux/libwebpdemux.a src/mux/libwebpmux.a $(EXTRA_LIB)
   OUTPUT += examples/libgifdec.a examples/libanim_util.a
 endif
 
 ex: $(OUT_EXAMPLES)
-all: ex $(EXTRA_EXAMPLES) $(OTHER_EXAMPLES)
+all: ex $(EXTRA_EXAMPLES)
 extras: $(EXTRA_LIB)
 
 $(EX_FORMAT_DEC_OBJS): %.o: %.h
 
 # special dependencies:
-#   tree_dec.c/vp8_dec.c/bit_reader_utils.c <->
-#     bit_reader_inl_utils.h, endian_inl_utils.h
-#   bit_writer_utils.c <-> endian_inl_utils.h
-src/dec/tree_dec.o: src/utils/bit_reader_inl_utils.h
-src/dec/tree_dec.o: src/utils/endian_inl_utils.h
-src/dec/vp8_dec.o: src/utils/bit_reader_inl_utils.h src/utils/endian_inl_utils.h
-src/utils/bit_reader_utils.o: src/utils/bit_reader_inl_utils.h
-src/utils/bit_reader_utils.o: src/utils/endian_inl_utils.h
-src/utils/bit_writer_utils.o: src/utils/endian_inl_utils.h
+#   tree.c/vp8.c/bit_reader.c <-> bit_reader_inl.h, endian_inl.h
+#   bit_writer.c <-> endian_inl.h
+src/dec/tree.o: src/utils/bit_reader_inl.h src/utils/endian_inl.h
+src/dec/vp8.o: src/utils/bit_reader_inl.h src/utils/endian_inl.h
+src/utils/bit_reader.o: src/utils/bit_reader_inl.h src/utils/endian_inl.h
+src/utils/bit_writer.o: src/utils/endian_inl.h
 
 %.o: %.c $(HDRS)
-	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@
 
 examples/libanim_util.a: $(ANIM_UTIL_OBJS)
+examples/libexample_dec.a: $(EX_FORMAT_DEC_OBJS)
 examples/libexample_util.a: $(EX_UTIL_OBJS)
 examples/libgifdec.a: $(GIFDEC_OBJS)
-extras/libwebpextras.a: $(LIBWEBPEXTRA_OBJS)
-imageio/libimagedec.a: $(EX_FORMAT_DEC_OBJS)
-imageio/libimageenc.a: $(EX_FORMAT_ENC_OBJS)
-imageio/libimageio_util.a: $(IMAGE_UTIL_OBJS)
 src/libwebpdecoder.a: $(LIBWEBPDECODER_OBJS)
 src/libwebp.a: $(LIBWEBP_OBJS)
 src/mux/libwebpmux.a: $(LIBWEBPMUX_OBJS)
 src/demux/libwebpdemux.a: $(LIBWEBPDEMUX_OBJS)
+src/libwebpextras.a: $(LIBWEBPEXTRA_OBJS)
 
 %.a:
 	$(AR) $(ARFLAGS) $@ $^
 
 examples/anim_diff: examples/anim_diff.o $(ANIM_UTIL_OBJS) $(GIFDEC_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)
 examples/vwebp: examples/vwebp.o
 examples/webpmux: examples/webpmux.o
-examples/img2webp: examples/img2webp.o
-examples/webpinfo: examples/webpinfo.o
 
 examples/anim_diff: examples/libanim_util.a examples/libgifdec.a
 examples/anim_diff: src/demux/libwebpdemux.a examples/libexample_util.a
-examples/anim_diff: imageio/libimageio_util.a src/libwebp.a
-examples/anim_diff: override EXTRA_LIBS += $(GIF_LIBS)
+examples/anim_diff: src/libwebp.a
+examples/anim_diff: EXTRA_LIBS += $(GIF_LIBS)
 examples/anim_diff: EXTRA_FLAGS += -DWEBP_HAVE_GIF
-examples/anim_dump: examples/libanim_util.a examples/libgifdec.a
-examples/anim_dump: src/demux/libwebpdemux.a
-examples/anim_dump: examples/libexample_util.a
-examples/anim_dump: imageio/libimageio_util.a
-examples/anim_dump: imageio/libimageenc.a
-examples/anim_dump: src/libwebp.a
-examples/anim_dump: override EXTRA_LIBS += $(GIF_LIBS) $(DWEBP_LIBS)
-examples/cwebp: examples/libexample_util.a
-examples/cwebp: imageio/libimagedec.a
-examples/cwebp: src/demux/libwebpdemux.a
-examples/cwebp: imageio/libimageio_util.a
+examples/cwebp: examples/libexample_util.a examples/libexample_dec.a
 examples/cwebp: src/libwebp.a
-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: 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: override EXTRA_LIBS += $(GIF_LIBS)
+examples/cwebp: EXTRA_LIBS += $(CWEBP_LIBS)
+examples/dwebp: examples/libexample_util.a src/libwebpdecoder.a
+examples/dwebp: EXTRA_LIBS += $(DWEBP_LIBS)
+examples/gif2webp: examples/libexample_util.a examples/libgifdec.a
+examples/gif2webp: src/mux/libwebpmux.a src/libwebp.a
+examples/gif2webp: EXTRA_LIBS += $(GIF_LIBS)
 examples/gif2webp: EXTRA_FLAGS += -DWEBP_HAVE_GIF
 examples/vwebp: examples/libexample_util.a src/demux/libwebpdemux.a
-examples/vwebp: imageio/libimageio_util.a src/libwebp.a
-examples/vwebp: override EXTRA_LIBS += $(GL_LIBS)
+examples/vwebp: src/libwebp.a
+examples/vwebp: EXTRA_LIBS += $(GL_LIBS)
 examples/vwebp: EXTRA_FLAGS += -DWEBP_HAVE_GL
-examples/webpmux: examples/libexample_util.a imageio/libimageio_util.a
-examples/webpmux: src/mux/libwebpmux.a src/libwebpdecoder.a
-examples/img2webp: examples/libexample_util.a imageio/libimageio_util.a
-examples/img2webp: imageio/libimagedec.a
-examples/img2webp: src/demux/libwebpdemux.a
-examples/img2webp: src/mux/libwebpmux.a src/libwebp.a
-examples/img2webp: override EXTRA_LIBS += $(CWEBP_LIBS)
-examples/webpinfo: examples/libexample_util.a imageio/libimageio_util.a
-examples/webpinfo: src/libwebpdecoder.a
+examples/webpmux: examples/libexample_util.a src/mux/libwebpmux.a
+examples/webpmux: src/libwebpdecoder.a
 
-extras/get_disto: extras/get_disto.o
-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
-extras/webp_quality: $(EXTRA_LIB) src/libwebp.a
-
-extras/vwebp_sdl: extras/vwebp_sdl.o
-extras/vwebp_sdl: extras/webp_to_sdl.o
-extras/vwebp_sdl: imageio/libimageio_util.a
-extras/vwebp_sdl: src/libwebp.a
-extras/vwebp_sdl: EXTRA_FLAGS += -DWEBP_HAVE_SDL $(SDL_FLAGS)
-extras/vwebp_sdl: override EXTRA_LIBS += $(SDL_LIBS)
-
-$(OUT_EXAMPLES) $(EXTRA_EXAMPLES) $(OTHER_EXAMPLES):
+$(OUT_EXAMPLES) $(EXTRA_EXAMPLES):
 	$(CC) -o $@ $^ $(LDFLAGS)
 
 dist: DESTDIR := dist
@@ -474,10 +386,9 @@ dist: all
 	$(INSTALL) -m644 src/demux/libwebpdemux.a $(DESTDIR)/lib
 	$(INSTALL) -m644 src/mux/libwebpmux.a $(DESTDIR)/lib
 	umask 022; \
-	for m in man/[cdv]webp.1 man/gif2webp.1 man/webpmux.1 \
-                 man/img2webp.1 man/webpinfo.1; do \
+	for m in man/[cdv]webp.1 man/gif2webp.1 man/webpmux.1; do \
 	  basenam=$$(basename $$m .1); \
-	  $(GROFF) -t -e -man -T ascii $$m \
+	  $(GROFF) -t -e -man -T utf8 $$m \
 	    | $(COL) -bx >$(DESTDIR)/doc/$${basenam}.txt; \
 	  $(GROFF) -t -e -man -T html $$m \
 	    | $(COL) -bx >$(DESTDIR)/doc/$${basenam}.html; \
@@ -486,12 +397,11 @@ dist: all
 clean:
 	$(RM) $(OUTPUT) *~ \
               examples/*.o examples/*~ \
-              extras/*.o extras/*~ \
-              imageio/*.o imageio/*~ \
               src/dec/*.o src/dec/*~ \
               src/demux/*.o src/demux/*~ \
               src/dsp/*.o src/dsp/*~ \
               src/enc/*.o src/enc/*~ \
+              src/extras/*.o src/extras/*~ \
               src/mux/*.o src/mux/*~ \
               src/utils/*.o src/utils/*~ \
               src/webp/*~ man/*~ doc/*~ swig/*~ \

man/Makefile.am

@@ -1,17 +1,11 @@
 man_MANS = cwebp.1 dwebp.1
-if BUILD_MUX
+if WANT_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
-if BUILD_WEBPINFO
-  man_MANS += webpinfo.1
-endif
 EXTRA_DIST = $(man_MANS)

man/cwebp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH CWEBP 1 "January 11, 2019"
+.TH CWEBP 1 "September 02, 2016"
 .SH NAME
 cwebp \- compress an image file to a WebP file
 .SH SYNOPSIS
@@ -41,12 +41,10 @@ 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
-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.
+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).
 .TP
 .BI \-q " float
 Specify the compression factor for RGB channels between 0 and 100. The default
@@ -100,7 +98,8 @@ Crop the source to a rectangle with top\-left corner at coordinates
 This cropping area must be fully contained within the source rectangle.
 .TP
 .B \-mt
-Use multi\-threading for encoding, if possible.
+Use multi\-threading for encoding, if possible. This option is only effective
+when using lossy compression on a source with a transparency channel.
 .TP
 .B \-low_memory
 Reduce memory usage of lossy encoding by saving four times the compressed
@@ -167,10 +166,6 @@ Use strong filtering (if filtering is being used thanks to the
 Disable strong filtering (if filtering is being used thanks to the
 \fB\-f\fP option) and use simple filtering instead.
 .TP
-.B \-sharp_yuv
-Use more accurate and sharper RGB->YUV conversion if needed. Note that this
-process is slower than the default 'fast' RGB->YUV conversion.
-.TP
 .BI \-sns " int
 Specify the amplitude of the spatial noise shaping. Spatial noise shaping
 (or \fBsns\fP for short) refers to a general collection of built\-in algorithms

man/gif2webp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH GIF2WEBP 1 "January 25, 2018"
+.TH GIF2WEBP 1 "June 23, 2016"
 .SH NAME
 gif2webp \- Convert a GIF image to WebP
 .SH SYNOPSIS
@@ -20,12 +20,6 @@ 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
@@ -74,9 +68,8 @@ Specify the minimum and maximum distance between consecutive key frames
 some key frames into the output animation as needed so that this criteria is
 satisfied.
 .br
-A 'kmax' value of 0 will turn off insertion of key frames. A 'kmax' value of 1
-will result in all frames being key frames. 'kmin' value is not taken into
-account in both these special cases.
+A 'kmin' value of 0 will turn off insertion of key frames. A 'kmax' value of 0
+will result in all frames being key frames.
 Typical values are in the range 3 to 30. Default values are kmin = 9,
 kmax = 17 for lossless compression and kmin = 3, kmax = 5 for lossy compression.
 .br
@@ -114,11 +107,8 @@ the value the smoother the picture will appear. Typical values are usually in
 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.
+Use multi-threading for encoding, if possible. This option is only effective
+when using lossy compression.
 .TP
 .B \-v
 Print extra information.
@@ -143,8 +133,6 @@ 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,105 +0,0 @@
-.\"                                      Hey, EMACS: -*- nroff -*-
-.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
-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.
-.TP
-.BI \-o " string
-Specify the name of the output WebP file.
-.TP
-.BI \-min_size
-Encode images to achieve smallest size. This disables key frame insertion and
-picks the parameters resulting in smallest output for each frame. It uses
-lossless compression by default, but can be combined with \-q, \-m, \-lossy or
-\-mixed options.
-.TP
-.BI \-kmin " int
-.TP
-.BI \-kmax " int
-Specify the minimum and maximum distance between consecutive key frames
-(independently decodable frames) in the output animation. The tool will insert
-some key frames into the output animation as needed so that this criteria is
-satisfied.
-.br
-.B \-mixed
-Mixed compression mode: optimize compression of the image by picking either
-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'.
-.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
-command line. They can be modified any number of times preceding each particular
-input image.
-.TP
-.BI \-d " int
-Specify the image duration in milliseconds.
-.TP
-.B \-lossless, \-lossy
-Compress the next image(s) using lossless or lossy compression mode. The
-default mode is lossless.
-.TP
-.BI \-q " float
-Specify the compression factor between 0 and 100. The default is 75.
-.TP
-.BI \-m " int
-Specify the compression method to use. This parameter controls the
-trade off between encoding speed and the compressed file size and quality.
-Possible values range from 0 to 6. Default value is 4.
-
-.SH EXAMPLE
-img2webp -loop 2 in0.png -lossy in1.jpg -d 80 in2.tiff -o out.webp
-.br
-
-.SH BUGS
-Please report all bugs to the issue tracker:
-https://bugs.chromium.org/p/webp
-.br
-Patches welcome! See this page to get started:
-http://www.webmproject.org/code/contribute/submitting\-patches/
-
-.SH AUTHORS
-\fBimg2webp\fP is a part of libwebp and was written by the WebP team.
-.br
-The latest source tree is available at
-https://chromium.googlesource.com/webm/libwebp
-.PP
-This manual page was written by Pascal Massimino <pascal.massimino@gmail.com>,
-for the Debian project (and may be used by others).
-
-.SH SEE ALSO
-.BR webpmux (1),
-.BR gif2webp (1)
-.br
-Please refer to http://developers.google.com/speed/webp/ for additional
-information.

man/vwebp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH VWEBP 1 "June 5, 2019"
+.TH VWEBP 1 "June 23, 2016"
 .SH NAME
 vwebp \- decompress a WebP file and display it in a window
 .SH SYNOPSIS
@@ -38,10 +38,6 @@ 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
@@ -60,15 +56,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
-.B 'd'
-Disable blending and disposal process, for debugging purposes.
-.TP
 .B 'q' / 'Q' / ESC
 Quit.
 

man/webpinfo.1

@@ -1,80 +0,0 @@
-.\"                                      Hey, EMACS: -*- nroff -*-
-.TH WEBPINFO 1 "November 24, 2017"
-.SH NAME
-webpinfo \- print out the chunk level structure of WebP files
-along with basic integrity checks.
-.SH SYNOPSIS
-.B webpinfo
-.I OPTIONS
-.I INPUT
-.br
-.B webpinfo [\-h|\-help|\-H|\-longhelp]
-.br
-
-.SH DESCRIPTION
-This manual page documents the
-.B webpinfo
-command.
-.PP
-\fBwebpinfo\fP can be used to print out the chunk level structure and bitstream
-header information of WebP files. It can also check if the files are of valid
-WebP format.
-
-.SH OPTIONS
-.TP
-.B \-version
-Print the version number (as major.minor.revision) and exit.
-.TP
-.B \-quiet
-Do not show chunk parsing information.
-.TP
-.B \-diag
-Show parsing error diagnosis.
-.TP
-.B \-summary
-Show chunk stats summary.
-.TP
-.BI \-bitstream_info
-Parse bitstream header.
-.TP
-.B \-h, \-help
-A short usage summary.
-.TP
-.B \-H, \-longhelp
-Detailed usage instructions.
-
-.SH INPUT
-Input files in WebP format. Input files must come last, following
-options (if any). There can be multiple input files.
-
-.SH BUGS
-Please report all bugs to the issue tracker:
-https://bugs.chromium.org/p/webp
-.br
-Patches welcome! See this page to get started:
-http://www.webmproject.org/code/contribute/submitting\-patches/
-
-.SH EXAMPLES
-.br
-webpinfo \-h
-.br
-webpinfo \-diag \-summary input_file.webp
-.br
-webpinfo \-bitstream_info input_file_1.webp input_file_2.webp
-.br
-webpinfo *.webp
-
-.SH AUTHORS
-\fBwebpinfo\fP is a part of libwebp and was written by the WebP team.
-.br
-The latest source tree is available at
-https://chromium.googlesource.com/webm/libwebp
-.PP
-This manual page was written by Hui Su <huisu@google.com>,
-for the Debian project (and may be used by others).
-
-.SH SEE ALSO
-.BR webpmux (1)
-.br
-Please refer to http://developers.google.com/speed/webp/ for additional
-information.

man/webpmux.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH WEBPMUX 1 "April 23, 2018"
+.TH WEBPMUX 1 "June 23, 2016"
 .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.
@@ -35,21 +35,12 @@ frames from animated WebP images, and manage XMP/EXIF metadata and ICC profile.
 .I OUTPUT
 .RE
 .br
-.B webpmux \-duration
-.I DURATION OPTIONS
-.B [ \-duration ... ]
-.I INPUT
-.B \-o
-.I OUTPUT
-.br
 .B webpmux \-info
 .I INPUT
 .br
 .B webpmux [\-h|\-help]
 .br
 .B webpmux \-version
-.br
-.B webpmux argument_file_name
 .SH DESCRIPTION
 This manual page documents the
 .B webpmux
@@ -57,9 +48,6 @@ 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
@@ -103,42 +91,6 @@ Strip EXIF metadata.
 .B xmp
 Strip XMP metadata.
 
-.SS DURATION_OPTIONS (\-duration)
-Amend the duration of a specific interval of frames. This option is only
-effective on animated WebP and has no effect on a single-frame file.
-.TP
-.I duration[,start[,end]]
-Where:
-.br
-.B duration
-is the duration for the interval in milliseconds (mandatory).
-Must be non-negative.
-.br
-.B start
-is the starting frame index of the interval (optional).
-.br
-.B end
-is the ending frame index (inclusive) of the interval (optional).
-.TP
-The three typical usages of this option are:
-.br
-.B -duration d
-     set the duration to 'd' for the whole animation.
-.br
-.B -duration d,f
-     set the duration of frame 'f' to 'd'.
-.br
-.B -duration d,start,end
-     set the duration to 'd' for the whole [start,end] interval.
-.TP
-.P
-Note that the frames outside of the [start, end] interval will remain untouched.
-The 'end' value '0' has the special meaning 'last frame of the animation'.
-.TP
-.I Reminder:
-frame indexing starts at '1'.
-.br
-
 .SS FRAME_OPTIONS (\-frame)
 Create an animated WebP file from multiple (non\-animated) WebP images.
 .TP

src/Makefile.am

@@ -1,12 +1,15 @@
-# The mux and demux libraries depend on libwebp, thus the '.' to force
+# The mux, demux and extras libraries depend on libwebp, thus the '.' to force
 # the build order so it's available to them.
 SUBDIRS = dec enc dsp utils .
-if BUILD_MUX
+if WANT_MUX
   SUBDIRS += mux
 endif
-if BUILD_DEMUX
+if WANT_DEMUX
   SUBDIRS += demux
 endif
+if WANT_EXTRAS
+  SUBDIRS += extras
+endif
 
 lib_LTLIBRARIES = libwebp.la
 
@@ -22,7 +25,6 @@ commondir = $(includedir)/webp
 libwebp_la_SOURCES =
 libwebpinclude_HEADERS =
 libwebpinclude_HEADERS += webp/encode.h
-
 noinst_HEADERS =
 noinst_HEADERS += webp/format_constants.h
 
@@ -36,7 +38,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:5:0
+libwebp_la_LDFLAGS = -no-undefined -version-info 6:2:0
 libwebpincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebp.pc
 
@@ -48,7 +50,7 @@ if BUILD_LIBWEBPDECODER
   libwebpdecoder_la_LIBADD += dsp/libwebpdspdecode.la
   libwebpdecoder_la_LIBADD += utils/libwebputilsdecode.la
 
-  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 3:5:0
+  libwebpdecoder_la_LDFLAGS = -no-undefined -version-info 2:2:0
   pkgconfig_DATA += libwebpdecoder.pc
 endif
 

src/dec/Makefile.am

@@ -1,23 +1,22 @@
-AM_CPPFLAGS += -I$(top_builddir) -I$(top_srcdir)
 noinst_LTLIBRARIES = libwebpdecode.la
 
 libwebpdecode_la_SOURCES =
-libwebpdecode_la_SOURCES += alpha_dec.c
-libwebpdecode_la_SOURCES += alphai_dec.h
-libwebpdecode_la_SOURCES += buffer_dec.c
-libwebpdecode_la_SOURCES += common_dec.h
-libwebpdecode_la_SOURCES += vp8_dec.h
-libwebpdecode_la_SOURCES += frame_dec.c
-libwebpdecode_la_SOURCES += idec_dec.c
-libwebpdecode_la_SOURCES += io_dec.c
-libwebpdecode_la_SOURCES += quant_dec.c
-libwebpdecode_la_SOURCES += tree_dec.c
-libwebpdecode_la_SOURCES += vp8_dec.c
-libwebpdecode_la_SOURCES += vp8i_dec.h
-libwebpdecode_la_SOURCES += vp8l_dec.c
-libwebpdecode_la_SOURCES += vp8li_dec.h
-libwebpdecode_la_SOURCES += webp_dec.c
-libwebpdecode_la_SOURCES += webpi_dec.h
+libwebpdecode_la_SOURCES += alpha.c
+libwebpdecode_la_SOURCES += alphai.h
+libwebpdecode_la_SOURCES += buffer.c
+libwebpdecode_la_SOURCES += common.h
+libwebpdecode_la_SOURCES += decode_vp8.h
+libwebpdecode_la_SOURCES += frame.c
+libwebpdecode_la_SOURCES += idec.c
+libwebpdecode_la_SOURCES += io.c
+libwebpdecode_la_SOURCES += quant.c
+libwebpdecode_la_SOURCES += tree.c
+libwebpdecode_la_SOURCES += vp8.c
+libwebpdecode_la_SOURCES += vp8i.h
+libwebpdecode_la_SOURCES += vp8l.c
+libwebpdecode_la_SOURCES += vp8li.h
+libwebpdecode_la_SOURCES += webp.c
+libwebpdecode_la_SOURCES += webpi.h
 
 libwebpdecodeinclude_HEADERS =
 libwebpdecodeinclude_HEADERS += ../webp/decode.h
@@ -25,5 +24,5 @@ libwebpdecodeinclude_HEADERS += ../webp/types.h
 noinst_HEADERS =
 noinst_HEADERS += ../webp/format_constants.h
 
-libwebpdecode_la_CPPFLAGS = $(AM_CPPFLAGS)
+libwebpdecode_la_CPPFLAGS = $(AM_CPPFLAGS) $(USE_EXPERIMENTAL_CODE)
 libwebpdecodeincludedir = $(includedir)/webp

src/dec/alpha.c

@@ -12,13 +12,13 @@
 // Author: Skal (pascal.massimino@gmail.com)
 
 #include <stdlib.h>
-#include "src/dec/alphai_dec.h"
-#include "src/dec/vp8i_dec.h"
-#include "src/dec/vp8li_dec.h"
-#include "src/dsp/dsp.h"
-#include "src/utils/quant_levels_dec_utils.h"
-#include "src/utils/utils.h"
-#include "src/webp/format_constants.h"
+#include "./alphai.h"
+#include "./vp8i.h"
+#include "./vp8li.h"
+#include "../dsp/dsp.h"
+#include "../utils/quant_levels_dec.h"
+#include "../utils/utils.h"
+#include "../webp/format_constants.h"
 
 //------------------------------------------------------------------------------
 // ALPHDecoder object.

src/dec/alphai.h

@@ -11,11 +11,11 @@
 //
 // Author: Urvang (urvang@google.com)
 
-#ifndef WEBP_DEC_ALPHAI_DEC_H_
-#define WEBP_DEC_ALPHAI_DEC_H_
+#ifndef WEBP_DEC_ALPHAI_H_
+#define WEBP_DEC_ALPHAI_H_
 
-#include "src/dec/webpi_dec.h"
-#include "src/utils/filters_utils.h"
+#include "./webpi.h"
+#include "../utils/filters.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -51,4 +51,4 @@ void WebPDeallocateAlphaMemory(VP8Decoder* const dec);
 }    // extern "C"
 #endif
 
-#endif  // WEBP_DEC_ALPHAI_DEC_H_
+#endif  /* WEBP_DEC_ALPHAI_H_ */

src/dec/buffer.c

@@ -13,15 +13,15 @@
 
 #include <stdlib.h>
 
-#include "src/dec/vp8i_dec.h"
-#include "src/dec/webpi_dec.h"
-#include "src/utils/utils.h"
+#include "./vp8i.h"
+#include "./webpi.h"
+#include "../utils/utils.h"
 
 //------------------------------------------------------------------------------
 // WebPDecBuffer
 
 // Number of bytes per pixel for the different color-spaces.
-static const uint8_t kModeBpp[MODE_LAST] = {
+static const int kModeBpp[MODE_LAST] = {
   3, 4, 3, 4, 4, 2, 2,
   4, 4, 4, 2,    // pre-multiplied modes
   1, 1 };
@@ -36,7 +36,7 @@ static int IsValidColorspace(int webp_csp_mode) {
 // strictly speaking, the very last (or first, if flipped) row
 // doesn't require padding.
 #define MIN_BUFFER_SIZE(WIDTH, HEIGHT, STRIDE)       \
-    ((uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH))
+    (uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH)
 
 static VP8StatusCode CheckDecBuffer(const WebPDecBuffer* const buffer) {
   int ok = 1;
@@ -74,8 +74,7 @@ static VP8StatusCode CheckDecBuffer(const WebPDecBuffer* const buffer) {
   } else {    // RGB checks
     const WebPRGBABuffer* const buf = &buffer->u.RGBA;
     const int stride = abs(buf->stride);
-    const uint64_t size =
-        MIN_BUFFER_SIZE(width * kModeBpp[mode], height, stride);
+    const uint64_t size = MIN_BUFFER_SIZE(width, height, stride);
     ok &= (size <= buf->size);
     ok &= (stride >= width * kModeBpp[mode]);
     ok &= (buf->rgba != NULL);
@@ -99,14 +98,9 @@ static VP8StatusCode AllocateBuffer(WebPDecBuffer* const buffer) {
     uint64_t uv_size = 0, a_size = 0, total_size;
     // We need memory and it hasn't been allocated yet.
     // => initialize output buffer, now that dimensions are known.
-    int stride;
-    uint64_t size;
+    const int stride = w * kModeBpp[mode];
+    const uint64_t size = (uint64_t)stride * h;
 
-    if ((uint64_t)w * kModeBpp[mode] >= (1ull << 32)) {
-      return VP8_STATUS_INVALID_PARAM;
-    }
-    stride = w * kModeBpp[mode];
-    size = (uint64_t)stride * h;
     if (!WebPIsRGBMode(mode)) {
       uv_stride = (w + 1) / 2;
       uv_size = (uint64_t)uv_stride * ((h + 1) / 2);
@@ -175,11 +169,11 @@ VP8StatusCode WebPFlipBuffer(WebPDecBuffer* const buffer) {
   return VP8_STATUS_OK;
 }
 
-VP8StatusCode WebPAllocateDecBuffer(int width, int height,
+VP8StatusCode WebPAllocateDecBuffer(int w, int h,
                                     const WebPDecoderOptions* const options,
-                                    WebPDecBuffer* const buffer) {
+                                    WebPDecBuffer* const out) {
   VP8StatusCode status;
-  if (buffer == NULL || width <= 0 || height <= 0) {
+  if (out == NULL || w <= 0 || h <= 0) {
     return VP8_STATUS_INVALID_PARAM;
   }
   if (options != NULL) {    // First, apply options if there is any.
@@ -188,39 +182,33 @@ VP8StatusCode WebPAllocateDecBuffer(int width, int height,
       const int ch = options->crop_height;
       const int x = options->crop_left & ~1;
       const int y = options->crop_top & ~1;
-      if (x < 0 || y < 0 || cw <= 0 || ch <= 0 ||
-          x + cw > width || y + ch > height) {
+      if (x < 0 || y < 0 || cw <= 0 || ch <= 0 || x + cw > w || y + ch > h) {
         return VP8_STATUS_INVALID_PARAM;   // out of frame boundary.
       }
-      width = cw;
-      height = ch;
+      w = cw;
+      h = ch;
     }
-
     if (options->use_scaling) {
-#if !defined(WEBP_REDUCE_SIZE)
       int scaled_width = options->scaled_width;
       int scaled_height = options->scaled_height;
       if (!WebPRescalerGetScaledDimensions(
-              width, height, &scaled_width, &scaled_height)) {
+              w, h, &scaled_width, &scaled_height)) {
         return VP8_STATUS_INVALID_PARAM;
       }
-      width = scaled_width;
-      height = scaled_height;
-#else
-      return VP8_STATUS_INVALID_PARAM;   // rescaling not supported
-#endif
+      w = scaled_width;
+      h = scaled_height;
     }
   }
-  buffer->width = width;
-  buffer->height = height;
+  out->width = w;
+  out->height = h;
 
   // Then, allocate buffer for real.
-  status = AllocateBuffer(buffer);
+  status = AllocateBuffer(out);
   if (status != VP8_STATUS_OK) return status;
 
   // Use the stride trick if vertical flip is needed.
   if (options != NULL && options->flip) {
-    status = WebPFlipBuffer(buffer);
+    status = WebPFlipBuffer(out);
   }
   return status;
 }

src/dec/common.h

@@ -11,8 +11,8 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
-#ifndef WEBP_DEC_COMMON_DEC_H_
-#define WEBP_DEC_COMMON_DEC_H_
+#ifndef WEBP_DEC_COMMON_H_
+#define WEBP_DEC_COMMON_H_
 
 // intra prediction modes
 enum { B_DC_PRED = 0,   // 4x4 modes
@@ -51,4 +51,4 @@ enum { MB_FEATURE_TREE_PROBS = 3,
        NUM_PROBAS = 11
      };
 
-#endif  // WEBP_DEC_COMMON_DEC_H_
+#endif    // WEBP_DEC_COMMON_H_

src/dec/decode_vp8.h

@@ -11,10 +11,10 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
-#ifndef WEBP_DEC_VP8_DEC_H_
-#define WEBP_DEC_VP8_DEC_H_
+#ifndef WEBP_WEBP_DECODE_VP8_H_
+#define WEBP_WEBP_DECODE_VP8_H_
 
-#include "src/webp/decode.h"
+#include "../webp/decode.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -33,7 +33,7 @@ extern "C" {
 //   /* customize io's functions (setup()/put()/teardown()) if needed. */
 //
 //   VP8Decoder* dec = VP8New();
-//   int ok = VP8Decode(dec, &io);
+//   bool ok = VP8Decode(dec);
 //   if (!ok) printf("Error: %s\n", VP8StatusMessage(dec));
 //   VP8Delete(dec);
 //   return ok;
@@ -157,24 +157,24 @@ void VP8Delete(VP8Decoder* const dec);
 // Miscellaneous VP8/VP8L bitstream probing functions.
 
 // Returns true if the next 3 bytes in data contain the VP8 signature.
-WEBP_EXTERN int VP8CheckSignature(const uint8_t* const data, size_t data_size);
+WEBP_EXTERN(int) VP8CheckSignature(const uint8_t* const data, size_t data_size);
 
 // Validates the VP8 data-header and retrieves basic header information viz
 // width and height. Returns 0 in case of formatting error. *width/*height
 // can be passed NULL.
-WEBP_EXTERN int VP8GetInfo(
+WEBP_EXTERN(int) VP8GetInfo(
     const uint8_t* data,
     size_t data_size,    // data available so far
     size_t chunk_size,   // total data size expected in the chunk
     int* const width, int* const height);
 
 // Returns true if the next byte(s) in data is a VP8L signature.
-WEBP_EXTERN int VP8LCheckSignature(const uint8_t* const data, size_t size);
+WEBP_EXTERN(int) VP8LCheckSignature(const uint8_t* const data, size_t size);
 
 // Validates the VP8L data-header and retrieves basic header information viz
 // width, height and alpha. Returns 0 in case of formatting error.
 // width/height/has_alpha can be passed NULL.
-WEBP_EXTERN int VP8LGetInfo(
+WEBP_EXTERN(int) VP8LGetInfo(
     const uint8_t* data, size_t data_size,  // data available so far
     int* const width, int* const height, int* const has_alpha);
 
@@ -182,4 +182,4 @@ WEBP_EXTERN int VP8LGetInfo(
 }    // extern "C"
 #endif
 
-#endif  // WEBP_DEC_VP8_DEC_H_
+#endif  /* WEBP_WEBP_DECODE_VP8_H_ */

src/dec/frame.c

@@ -12,13 +12,13 @@
 // Author: Skal (pascal.massimino@gmail.com)
 
 #include <stdlib.h>
-#include "src/dec/vp8i_dec.h"
-#include "src/utils/utils.h"
+#include "./vp8i.h"
+#include "../utils/utils.h"
 
 //------------------------------------------------------------------------------
 // Main reconstruction function.
 
-static const uint16_t kScan[16] = {
+static const int kScan[16] = {
   0 +  0 * BPS,  4 +  0 * BPS, 8 +  0 * BPS, 12 +  0 * BPS,
   0 +  4 * BPS,  4 +  4 * BPS, 8 +  4 * BPS, 12 +  4 * BPS,
   0 +  8 * BPS,  4 +  8 * BPS, 8 +  8 * BPS, 12 +  8 * BPS,
@@ -320,7 +320,7 @@ static void PrecomputeFilterStrengths(VP8Decoder* const dec) {
 #define MIN_DITHER_AMP 4
 
 #define DITHER_AMP_TAB_SIZE 12
-static const uint8_t kQuantToDitherAmp[DITHER_AMP_TAB_SIZE] = {
+static const int kQuantToDitherAmp[DITHER_AMP_TAB_SIZE] = {
   // roughly, it's dqm->uv_mat_[1]
   8, 7, 6, 4, 4, 2, 2, 2, 1, 1, 1, 1
 };
@@ -338,6 +338,7 @@ 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;
         }
@@ -399,9 +400,7 @@ 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(void* arg1, void* arg2) {
-  VP8Decoder* const dec = (VP8Decoder*)arg1;
-  VP8Io* const io = (VP8Io*)arg2;
+static int FinishRow(VP8Decoder* const dec, VP8Io* const io) {
   int ok = 1;
   const VP8ThreadContext* const ctx = &dec->thread_ctx_;
   const int cache_id = ctx->id_;
@@ -449,9 +448,10 @@ static int FinishRow(void* arg1, void* arg2) {
     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,6 +558,7 @@ 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.
   //
@@ -568,6 +569,8 @@ 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) {
@@ -648,7 +651,7 @@ static int InitThreadContext(VP8Decoder* const dec) {
     }
     worker->data1 = dec;
     worker->data2 = (void*)&dec->thread_ctx_.io_;
-    worker->hook = FinishRow;
+    worker->hook = (WebPWorkerHook)FinishRow;
     dec->num_caches_ =
       (dec->filter_type_ > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
   } else {
@@ -668,9 +671,15 @@ 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 2;
+  if (width < MIN_WIDTH_FOR_THREADS) return 0;
+  // TODO(skal): tune the heuristic further
+#if 0
+  if (height < 2 * width) return 2;
 #endif
+  return 2;
+#else   // !WEBP_USE_THREAD
   return 0;
+#endif
 }
 
 #undef MT_CACHE_LINES
@@ -714,12 +723,12 @@ static int AllocateMemory(VP8Decoder* const dec) {
       return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                          "no memory during frame initialization.");
     }
-    // down-cast is ok, thanks to WebPSafeMalloc() above.
+    // down-cast is ok, thanks to WebPSafeAlloc() above.
     dec->mem_size_ = (size_t)needed;
   }
 
   mem = (uint8_t*)dec->mem_;
-  dec->intra_t_ = mem;
+  dec->intra_t_ = (uint8_t*)mem;
   mem += intra_pred_mode_size;
 
   dec->yuv_t_ = (VP8TopSamples*)mem;
@@ -741,7 +750,7 @@ static int AllocateMemory(VP8Decoder* const dec) {
 
   mem = (uint8_t*)WEBP_ALIGN(mem);
   assert((yuv_size & WEBP_ALIGN_CST) == 0);
-  dec->yuv_b_ = mem;
+  dec->yuv_b_ = (uint8_t*)mem;
   mem += yuv_size;
 
   dec->mb_data_ = (VP8MBData*)mem;
@@ -757,7 +766,7 @@ static int AllocateMemory(VP8Decoder* const dec) {
     const int extra_rows = kFilterExtraRows[dec->filter_type_];
     const int extra_y = extra_rows * dec->cache_y_stride_;
     const int extra_uv = (extra_rows / 2) * dec->cache_uv_stride_;
-    dec->cache_y_ = mem + extra_y;
+    dec->cache_y_ = ((uint8_t*)mem) + extra_y;
     dec->cache_u_ = dec->cache_y_
                   + 16 * num_caches * dec->cache_y_stride_ + extra_uv;
     dec->cache_v_ = dec->cache_u_
@@ -767,7 +776,7 @@ static int AllocateMemory(VP8Decoder* const dec) {
   mem += cache_size;
 
   // alpha plane
-  dec->alpha_plane_ = alpha_size ? mem : NULL;
+  dec->alpha_plane_ = alpha_size ? (uint8_t*)mem : NULL;
   mem += alpha_size;
   assert(mem <= (uint8_t*)dec->mem_ + dec->mem_size_);
 

src/dec/idec.c

@@ -15,10 +15,10 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include "src/dec/alphai_dec.h"
-#include "src/dec/webpi_dec.h"
-#include "src/dec/vp8i_dec.h"
-#include "src/utils/utils.h"
+#include "./alphai.h"
+#include "./webpi.h"
+#include "./vp8i.h"
+#include "../utils/utils.h"
 
 // In append mode, buffer allocations increase as multiples of this value.
 // Needs to be a power of 2.
@@ -140,9 +140,10 @@ 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 && alph_dec->vp8l_dec_ != NULL) {
+        if (alph_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,
@@ -282,8 +283,10 @@ static void RestoreContext(const MBContext* context, VP8Decoder* const dec,
 
 static VP8StatusCode IDecError(WebPIDecoder* const idec, VP8StatusCode error) {
   if (idec->state_ == STATE_VP8_DATA) {
-    // Synchronize the thread, clean-up and check for errors.
-    VP8ExitCritical((VP8Decoder*)idec->dec_, &idec->io_);
+    VP8Io* const io = &idec->io_;
+    if (io->teardown != NULL) {
+      io->teardown(io);
+    }
   }
   idec->state_ = STATE_ERROR;
   return error;
@@ -448,10 +451,7 @@ static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) {
   VP8Decoder* const dec = (VP8Decoder*)idec->dec_;
   VP8Io* const io = &idec->io_;
 
-  // Make sure partition #0 has been read before, to set dec to ready_.
-  if (!dec->ready_) {
-    return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR);
-  }
+  assert(dec->ready_);
   for (; dec->mb_y_ < dec->mb_h_; ++dec->mb_y_) {
     if (idec->last_mb_y_ != dec->mb_y_) {
       if (!VP8ParseIntraModeRow(&dec->br_, dec)) {
@@ -473,12 +473,6 @@ 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;
       }
@@ -497,7 +491,6 @@ static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) {
   }
   // Synchronize the thread and check for errors.
   if (!VP8ExitCritical(dec, io)) {
-    idec->state_ = STATE_ERROR;  // prevent re-entry in IDecError
     return IDecError(idec, VP8_STATUS_USER_ABORT);
   }
   dec->ready_ = 0;
@@ -578,10 +571,6 @@ static VP8StatusCode IDecode(WebPIDecoder* idec) {
     status = DecodePartition0(idec);
   }
   if (idec->state_ == STATE_VP8_DATA) {
-    const VP8Decoder* const dec = (VP8Decoder*)idec->dec_;
-    if (dec == NULL) {
-      return VP8_STATUS_SUSPENDED;  // can't continue if we have no decoder.
-    }
     status = DecodeRemaining(idec);
   }
   if (idec->state_ == STATE_VP8L_HEADER) {
@@ -684,12 +673,12 @@ void WebPIDelete(WebPIDecoder* idec) {
 //------------------------------------------------------------------------------
 // Wrapper toward WebPINewDecoder
 
-WebPIDecoder* WebPINewRGB(WEBP_CSP_MODE csp, uint8_t* output_buffer,
+WebPIDecoder* WebPINewRGB(WEBP_CSP_MODE mode, uint8_t* output_buffer,
                           size_t output_buffer_size, int output_stride) {
   const int is_external_memory = (output_buffer != NULL) ? 1 : 0;
   WebPIDecoder* idec;
 
-  if (csp >= MODE_YUV) return NULL;
+  if (mode >= MODE_YUV) return NULL;
   if (is_external_memory == 0) {    // Overwrite parameters to sane values.
     output_buffer_size = 0;
     output_stride = 0;
@@ -700,7 +689,7 @@ WebPIDecoder* WebPINewRGB(WEBP_CSP_MODE csp, uint8_t* output_buffer,
   }
   idec = WebPINewDecoder(NULL);
   if (idec == NULL) return NULL;
-  idec->output_.colorspace = csp;
+  idec->output_.colorspace = mode;
   idec->output_.is_external_memory = is_external_memory;
   idec->output_.u.RGBA.rgba = output_buffer;
   idec->output_.u.RGBA.stride = output_stride;

src/dec/io.c

@@ -13,11 +13,11 @@
 
 #include <assert.h>
 #include <stdlib.h>
-#include "src/dec/vp8i_dec.h"
-#include "src/dec/webpi_dec.h"
-#include "src/dsp/dsp.h"
-#include "src/dsp/yuv.h"
-#include "src/utils/utils.h"
+#include "../dec/vp8i.h"
+#include "./webpi.h"
+#include "../dsp/dsp.h"
+#include "../dsp/yuv.h"
+#include "../utils/utils.h"
 
 //------------------------------------------------------------------------------
 // Main YUV<->RGB conversion functions
@@ -212,7 +212,7 @@ static int EmitAlphaRGBA4444(const VP8Io* const io, WebPDecParams* const p,
     int num_rows;
     const int start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
     uint8_t* const base_rgba = buf->rgba + start_y * buf->stride;
-#if (WEBP_SWAP_16BIT_CSP == 1)
+#ifdef WEBP_SWAP_16BIT_CSP
     uint8_t* alpha_dst = base_rgba;
 #else
     uint8_t* alpha_dst = base_rgba + 1;
@@ -241,7 +241,6 @@ static int EmitAlphaRGBA4444(const VP8Io* const io, WebPDecParams* const p,
 //------------------------------------------------------------------------------
 // YUV rescaling (no final RGB conversion needed)
 
-#if !defined(WEBP_REDUCE_SIZE)
 static int Rescale(const uint8_t* src, int src_stride,
                    int new_lines, WebPRescaler* const wrk) {
   int num_lines_out = 0;
@@ -257,7 +256,7 @@ static int Rescale(const uint8_t* src, int src_stride,
 static int EmitRescaledYUV(const VP8Io* const io, WebPDecParams* const p) {
   const int mb_h = io->mb_h;
   const int uv_mb_h = (mb_h + 1) >> 1;
-  WebPRescaler* const scaler = p->scaler_y;
+  WebPRescaler* const scaler = &p->scaler_y;
   int num_lines_out = 0;
   if (WebPIsAlphaMode(p->output->colorspace) && io->a != NULL) {
     // Before rescaling, we premultiply the luma directly into the io->y
@@ -268,28 +267,29 @@ static int EmitRescaledYUV(const VP8Io* const io, WebPDecParams* const p) {
                  io->a, io->width, io->mb_w, mb_h, 0);
   }
   num_lines_out = Rescale(io->y, io->y_stride, mb_h, scaler);
-  Rescale(io->u, io->uv_stride, uv_mb_h, p->scaler_u);
-  Rescale(io->v, io->uv_stride, uv_mb_h, p->scaler_v);
+  Rescale(io->u, io->uv_stride, uv_mb_h, &p->scaler_u);
+  Rescale(io->v, io->uv_stride, uv_mb_h, &p->scaler_v);
   return num_lines_out;
 }
 
 static int EmitRescaledAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
                                 int expected_num_lines_out) {
   const WebPYUVABuffer* const buf = &p->output->u.YUVA;
-  uint8_t* const dst_a = buf->a + p->last_y * buf->a_stride;
   if (io->a != NULL) {
-    uint8_t* const dst_y = buf->y + p->last_y * buf->y_stride;
-    const int num_lines_out = Rescale(io->a, io->width, io->mb_h, p->scaler_a);
+    uint8_t* dst_y = buf->y + p->last_y * buf->y_stride;
+    const uint8_t* src_a = buf->a + p->last_y * buf->a_stride;
+    const int num_lines_out = Rescale(io->a, io->width, io->mb_h, &p->scaler_a);
+    (void)expected_num_lines_out;
     assert(expected_num_lines_out == num_lines_out);
     if (num_lines_out > 0) {   // unmultiply the Y
-      WebPMultRows(dst_y, buf->y_stride, dst_a, buf->a_stride,
-                   p->scaler_a->dst_width, num_lines_out, 1);
+      WebPMultRows(dst_y, buf->y_stride, src_a, buf->a_stride,
+                   p->scaler_a.dst_width, num_lines_out, 1);
     }
   } else if (buf->a != NULL) {
     // the user requested alpha, but there is none, set it to opaque.
     assert(p->last_y + expected_num_lines_out <= io->scaled_height);
-    FillAlphaPlane(dst_a, io->scaled_width, expected_num_lines_out,
-                   buf->a_stride);
+    FillAlphaPlane(buf->a + p->last_y * buf->a_stride,
+                   io->scaled_width, expected_num_lines_out, buf->a_stride);
   }
   return 0;
 }
@@ -305,42 +305,31 @@ static int InitYUVRescaler(const VP8Io* const io, WebPDecParams* const p) {
   const int uv_in_height = (io->mb_h + 1) >> 1;
   const size_t work_size = 2 * out_width;   // scratch memory for luma rescaler
   const size_t uv_work_size = 2 * uv_out_width;  // and for each u/v ones
-  size_t tmp_size, rescaler_size;
+  size_t tmp_size;
   rescaler_t* work;
-  WebPRescaler* scalers;
-  const int num_rescalers = has_alpha ? 4 : 3;
 
   tmp_size = (work_size + 2 * uv_work_size) * sizeof(*work);
   if (has_alpha) {
     tmp_size += work_size * sizeof(*work);
   }
-  rescaler_size = num_rescalers * sizeof(*p->scaler_y) + WEBP_ALIGN_CST;
-
-  p->memory = WebPSafeMalloc(1ULL, tmp_size + rescaler_size);
+  p->memory = WebPSafeMalloc(1ULL, tmp_size);
   if (p->memory == NULL) {
     return 0;   // memory error
   }
   work = (rescaler_t*)p->memory;
-
-  scalers = (WebPRescaler*)WEBP_ALIGN((const uint8_t*)work + tmp_size);
-  p->scaler_y = &scalers[0];
-  p->scaler_u = &scalers[1];
-  p->scaler_v = &scalers[2];
-  p->scaler_a = has_alpha ? &scalers[3] : NULL;
-
-  WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
+  WebPRescalerInit(&p->scaler_y, io->mb_w, io->mb_h,
                    buf->y, out_width, out_height, buf->y_stride, 1,
                    work);
-  WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
+  WebPRescalerInit(&p->scaler_u, uv_in_width, uv_in_height,
                    buf->u, uv_out_width, uv_out_height, buf->u_stride, 1,
                    work + work_size);
-  WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
+  WebPRescalerInit(&p->scaler_v, uv_in_width, uv_in_height,
                    buf->v, uv_out_width, uv_out_height, buf->v_stride, 1,
                    work + work_size + uv_work_size);
   p->emit = EmitRescaledYUV;
 
   if (has_alpha) {
-    WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
+    WebPRescalerInit(&p->scaler_a, io->mb_w, io->mb_h,
                      buf->a, out_width, out_height, buf->a_stride, 1,
                      work + work_size + 2 * uv_work_size);
     p->emit_alpha = EmitRescaledAlphaYUV;
@@ -360,15 +349,15 @@ static int ExportRGB(WebPDecParams* const p, int y_pos) {
   int num_lines_out = 0;
   // For RGB rescaling, because of the YUV420, current scan position
   // U/V can be +1/-1 line from the Y one.  Hence the double test.
-  while (WebPRescalerHasPendingOutput(p->scaler_y) &&
-         WebPRescalerHasPendingOutput(p->scaler_u)) {
+  while (WebPRescalerHasPendingOutput(&p->scaler_y) &&
+         WebPRescalerHasPendingOutput(&p->scaler_u)) {
     assert(y_pos + num_lines_out < p->output->height);
-    assert(p->scaler_u->y_accum == p->scaler_v->y_accum);
-    WebPRescalerExportRow(p->scaler_y);
-    WebPRescalerExportRow(p->scaler_u);
-    WebPRescalerExportRow(p->scaler_v);
-    convert(p->scaler_y->dst, p->scaler_u->dst, p->scaler_v->dst,
-            dst, p->scaler_y->dst_width);
+    assert(p->scaler_u.y_accum == p->scaler_v.y_accum);
+    WebPRescalerExportRow(&p->scaler_y);
+    WebPRescalerExportRow(&p->scaler_u);
+    WebPRescalerExportRow(&p->scaler_v);
+    convert(p->scaler_y.dst, p->scaler_u.dst, p->scaler_v.dst,
+            dst, p->scaler_y.dst_width);
     dst += buf->stride;
     ++num_lines_out;
   }
@@ -382,15 +371,15 @@ static int EmitRescaledRGB(const VP8Io* const io, WebPDecParams* const p) {
   int num_lines_out = 0;
   while (j < mb_h) {
     const int y_lines_in =
-        WebPRescalerImport(p->scaler_y, mb_h - j,
+        WebPRescalerImport(&p->scaler_y, mb_h - j,
                            io->y + j * io->y_stride, io->y_stride);
     j += y_lines_in;
-    if (WebPRescaleNeededLines(p->scaler_u, uv_mb_h - uv_j)) {
+    if (WebPRescaleNeededLines(&p->scaler_u, uv_mb_h - uv_j)) {
       const int u_lines_in =
-          WebPRescalerImport(p->scaler_u, uv_mb_h - uv_j,
+          WebPRescalerImport(&p->scaler_u, uv_mb_h - uv_j,
                              io->u + uv_j * io->uv_stride, io->uv_stride);
       const int v_lines_in =
-          WebPRescalerImport(p->scaler_v, uv_mb_h - uv_j,
+          WebPRescalerImport(&p->scaler_v, uv_mb_h - uv_j,
                              io->v + uv_j * io->uv_stride, io->uv_stride);
       (void)v_lines_in;   // remove a gcc warning
       assert(u_lines_in == v_lines_in);
@@ -411,13 +400,13 @@ static int ExportAlpha(WebPDecParams* const p, int y_pos, int max_lines_out) {
   int num_lines_out = 0;
   const int is_premult_alpha = WebPIsPremultipliedMode(colorspace);
   uint32_t non_opaque = 0;
-  const int width = p->scaler_a->dst_width;
+  const int width = p->scaler_a.dst_width;
 
-  while (WebPRescalerHasPendingOutput(p->scaler_a) &&
+  while (WebPRescalerHasPendingOutput(&p->scaler_a) &&
          num_lines_out < max_lines_out) {
     assert(y_pos + num_lines_out < p->output->height);
-    WebPRescalerExportRow(p->scaler_a);
-    non_opaque |= WebPDispatchAlpha(p->scaler_a->dst, 0, width, 1, dst, 0);
+    WebPRescalerExportRow(&p->scaler_a);
+    non_opaque |= WebPDispatchAlpha(p->scaler_a.dst, 0, width, 1, dst, 0);
     dst += buf->stride;
     ++num_lines_out;
   }
@@ -432,25 +421,25 @@ static int ExportAlphaRGBA4444(WebPDecParams* const p, int y_pos,
                                int max_lines_out) {
   const WebPRGBABuffer* const buf = &p->output->u.RGBA;
   uint8_t* const base_rgba = buf->rgba + y_pos * buf->stride;
-#if (WEBP_SWAP_16BIT_CSP == 1)
+#ifdef WEBP_SWAP_16BIT_CSP
   uint8_t* alpha_dst = base_rgba;
 #else
   uint8_t* alpha_dst = base_rgba + 1;
 #endif
   int num_lines_out = 0;
   const WEBP_CSP_MODE colorspace = p->output->colorspace;
-  const int width = p->scaler_a->dst_width;
+  const int width = p->scaler_a.dst_width;
   const int is_premult_alpha = WebPIsPremultipliedMode(colorspace);
   uint32_t alpha_mask = 0x0f;
 
-  while (WebPRescalerHasPendingOutput(p->scaler_a) &&
+  while (WebPRescalerHasPendingOutput(&p->scaler_a) &&
          num_lines_out < max_lines_out) {
     int i;
     assert(y_pos + num_lines_out < p->output->height);
-    WebPRescalerExportRow(p->scaler_a);
+    WebPRescalerExportRow(&p->scaler_a);
     for (i = 0; i < width; ++i) {
       // Fill in the alpha value (converted to 4 bits).
-      const uint32_t alpha_value = p->scaler_a->dst[i] >> 4;
+      const uint32_t alpha_value = p->scaler_a.dst[i] >> 4;
       alpha_dst[2 * i] = (alpha_dst[2 * i] & 0xf0) | alpha_value;
       alpha_mask &= alpha_value;
     }
@@ -466,7 +455,7 @@ static int ExportAlphaRGBA4444(WebPDecParams* const p, int y_pos,
 static int EmitRescaledAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
                                 int expected_num_out_lines) {
   if (io->a != NULL) {
-    WebPRescaler* const scaler = p->scaler_a;
+    WebPRescaler* const scaler = &p->scaler_a;
     int lines_left = expected_num_out_lines;
     const int y_end = p->last_y + lines_left;
     while (lines_left > 0) {
@@ -488,9 +477,7 @@ static int InitRGBRescaler(const VP8Io* const io, WebPDecParams* const p) {
   const size_t work_size = 2 * out_width;   // scratch memory for one rescaler
   rescaler_t* work;  // rescalers work area
   uint8_t* tmp;   // tmp storage for scaled YUV444 samples before RGB conversion
-  size_t tmp_size1, tmp_size2, total_size, rescaler_size;
-  WebPRescaler* scalers;
-  const int num_rescalers = has_alpha ? 4 : 3;
+  size_t tmp_size1, tmp_size2, total_size;
 
   tmp_size1 = 3 * work_size;
   tmp_size2 = 3 * out_width;
@@ -499,35 +486,26 @@ static int InitRGBRescaler(const VP8Io* const io, WebPDecParams* const p) {
     tmp_size2 += out_width;
   }
   total_size = tmp_size1 * sizeof(*work) + tmp_size2 * sizeof(*tmp);
-  rescaler_size = num_rescalers * sizeof(*p->scaler_y) + WEBP_ALIGN_CST;
-
-  p->memory = WebPSafeMalloc(1ULL, total_size + rescaler_size);
+  p->memory = WebPSafeMalloc(1ULL, total_size);
   if (p->memory == NULL) {
     return 0;   // memory error
   }
   work = (rescaler_t*)p->memory;
   tmp = (uint8_t*)(work + tmp_size1);
-
-  scalers = (WebPRescaler*)WEBP_ALIGN((const uint8_t*)work + total_size);
-  p->scaler_y = &scalers[0];
-  p->scaler_u = &scalers[1];
-  p->scaler_v = &scalers[2];
-  p->scaler_a = has_alpha ? &scalers[3] : NULL;
-
-  WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
+  WebPRescalerInit(&p->scaler_y, io->mb_w, io->mb_h,
                    tmp + 0 * out_width, out_width, out_height, 0, 1,
                    work + 0 * work_size);
-  WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
+  WebPRescalerInit(&p->scaler_u, uv_in_width, uv_in_height,
                    tmp + 1 * out_width, out_width, out_height, 0, 1,
                    work + 1 * work_size);
-  WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
+  WebPRescalerInit(&p->scaler_v, uv_in_width, uv_in_height,
                    tmp + 2 * out_width, out_width, out_height, 0, 1,
                    work + 2 * work_size);
   p->emit = EmitRescaledRGB;
   WebPInitYUV444Converters();
 
   if (has_alpha) {
-    WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
+    WebPRescalerInit(&p->scaler_a, io->mb_w, io->mb_h,
                      tmp + 3 * out_width, out_width, out_height, 0, 1,
                      work + 3 * work_size);
     p->emit_alpha = EmitRescaledAlphaRGB;
@@ -542,8 +520,6 @@ static int InitRGBRescaler(const VP8Io* const io, WebPDecParams* const p) {
   return 1;
 }
 
-#endif  // WEBP_REDUCE_SIZE
-
 //------------------------------------------------------------------------------
 // Default custom functions
 
@@ -564,14 +540,10 @@ static int CustomSetup(VP8Io* io) {
     WebPInitUpsamplers();
   }
   if (io->use_scaling) {
-#if !defined(WEBP_REDUCE_SIZE)
     const int ok = is_rgb ? InitRGBRescaler(io, p) : InitYUVRescaler(io, p);
     if (!ok) {
       return 0;    // memory error
     }
-#else
-    return 0;   // rescaling support not compiled
-#endif
   } else {
     if (is_rgb) {
       WebPInitSamplers();
@@ -605,6 +577,9 @@ static int CustomSetup(VP8Io* io) {
     }
   }
 
+  if (is_rgb) {
+    VP8YUVInit();
+  }
   return 1;
 }
 

src/dec/quant.c

@@ -11,7 +11,7 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
-#include "src/dec/vp8i_dec.h"
+#include "./vp8i.h"
 
 static WEBP_INLINE int clip(int v, int M) {
   return v < 0 ? 0 : v > M ? M : v;
@@ -61,17 +61,12 @@ static const uint16_t kAcTable[128] = {
 
 void VP8ParseQuant(VP8Decoder* const dec) {
   VP8BitReader* const br = &dec->br_;
-  const int base_q0 = VP8GetValue(br, 7, "global-header");
-  const int dqy1_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dqy2_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dqy2_ac = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dquv_dc = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
-  const int dquv_ac = VP8Get(br, "global-header") ?
-       VP8GetSignedValue(br, 4, "global-header") : 0;
+  const int base_q0 = VP8GetValue(br, 7);
+  const int dqy1_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dqy2_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dqy2_ac = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dquv_dc = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
+  const int dquv_ac = VP8Get(br) ? VP8GetSignedValue(br, 4) : 0;
 
   const VP8SegmentHeader* const hdr = &dec->segment_hdr_;
   int i;

src/dec/tree.c

@@ -11,19 +11,12 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
-#include "src/dec/vp8i_dec.h"
-#include "src/utils/bit_reader_inl_utils.h"
+#include "./vp8i.h"
+#include "../utils/bit_reader_inl.h"
 
-#if !defined(USE_GENERIC_TREE)
-#if !defined(__arm__) && !defined(_M_ARM) && !defined(__aarch64__)
-// using a table is ~1-2% slower on ARM. Prefer the coded-tree approach then.
-#define USE_GENERIC_TREE 1   // ALTERNATE_CODE
-#else
-#define USE_GENERIC_TREE 0
-#endif
-#endif  // USE_GENERIC_TREE
+#define USE_GENERIC_TREE
 
-#if (USE_GENERIC_TREE == 1)
+#ifdef USE_GENERIC_TREE
 static const int8_t kYModesIntra4[18] = {
   -B_DC_PRED, 1,
     -B_TM_PRED, 2,
@@ -296,21 +289,20 @@ static void ParseIntraMode(VP8BitReader* const br,
   // to decode more than 1 keyframe.
   if (dec->segment_hdr_.update_map_) {
     // Hardcoded tree parsing
-    block->segment_ = !VP8GetBit(br, dec->proba_.segments_[0], "segments")
-                    ?  VP8GetBit(br, dec->proba_.segments_[1], "segments")
-                    :  VP8GetBit(br, dec->proba_.segments_[2], "segments") + 2;
+    block->segment_ = !VP8GetBit(br, dec->proba_.segments_[0])
+                    ? VP8GetBit(br, dec->proba_.segments_[1])
+                    : 2 + VP8GetBit(br, dec->proba_.segments_[2]);
   } else {
     block->segment_ = 0;  // default for intra
   }
-  if (dec->use_skip_proba_) block->skip_ = VP8GetBit(br, dec->skip_p_, "skip");
+  if (dec->use_skip_proba_) block->skip_ = VP8GetBit(br, dec->skip_p_);
 
-  block->is_i4x4_ = !VP8GetBit(br, 145, "block-size");
+  block->is_i4x4_ = !VP8GetBit(br, 145);   // decide for B_PRED first
   if (!block->is_i4x4_) {
     // Hardcoded 16x16 intra-mode decision tree.
     const int ymode =
-        VP8GetBit(br, 156, "pred-modes") ?
-            (VP8GetBit(br, 128, "pred-modes") ? TM_PRED : H_PRED) :
-            (VP8GetBit(br, 163, "pred-modes") ? V_PRED : DC_PRED);
+        VP8GetBit(br, 156) ? (VP8GetBit(br, 128) ? TM_PRED : H_PRED)
+                           : (VP8GetBit(br, 163) ? V_PRED : DC_PRED);
     block->imodes_[0] = ymode;
     memset(top, ymode, 4 * sizeof(*top));
     memset(left, ymode, 4 * sizeof(*left));
@@ -322,28 +314,25 @@ static void ParseIntraMode(VP8BitReader* const br,
       int x;
       for (x = 0; x < 4; ++x) {
         const uint8_t* const prob = kBModesProba[top[x]][ymode];
-#if (USE_GENERIC_TREE == 1)
+#ifdef USE_GENERIC_TREE
         // Generic tree-parsing
-        int i = kYModesIntra4[VP8GetBit(br, prob[0], "pred-modes")];
+        int i = kYModesIntra4[VP8GetBit(br, prob[0])];
         while (i > 0) {
-          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i], "pred-modes")];
+          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i])];
         }
         ymode = -i;
 #else
         // Hardcoded tree parsing
-        ymode = !VP8GetBit(br, prob[0], "pred-modes") ? B_DC_PRED :
-                  !VP8GetBit(br, prob[1], "pred-modes") ? B_TM_PRED :
-                    !VP8GetBit(br, prob[2], "pred-modes") ? B_VE_PRED :
-                      !VP8GetBit(br, prob[3], "pred-modes") ?
-                        (!VP8GetBit(br, prob[4], "pred-modes") ? B_HE_PRED :
-                          (!VP8GetBit(br, prob[5], "pred-modes") ? B_RD_PRED
-                                                                 : B_VR_PRED)) :
-                        (!VP8GetBit(br, prob[6], "pred-modes") ? B_LD_PRED :
-                          (!VP8GetBit(br, prob[7], "pred-modes") ? B_VL_PRED :
-                            (!VP8GetBit(br, prob[8], "pred-modes") ? B_HD_PRED
-                                                                   : B_HU_PRED))
-                        );
-#endif  // USE_GENERIC_TREE
+        ymode = !VP8GetBit(br, prob[0]) ? B_DC_PRED :
+                  !VP8GetBit(br, prob[1]) ? B_TM_PRED :
+                    !VP8GetBit(br, prob[2]) ? B_VE_PRED :
+                      !VP8GetBit(br, prob[3]) ?
+                        (!VP8GetBit(br, prob[4]) ? B_HE_PRED :
+                          (!VP8GetBit(br, prob[5]) ? B_RD_PRED : B_VR_PRED)) :
+                        (!VP8GetBit(br, prob[6]) ? B_LD_PRED :
+                          (!VP8GetBit(br, prob[7]) ? B_VL_PRED :
+                            (!VP8GetBit(br, prob[8]) ? B_HD_PRED : B_HU_PRED)));
+#endif    // USE_GENERIC_TREE
         top[x] = ymode;
       }
       memcpy(modes, top, 4 * sizeof(*top));
@@ -352,9 +341,9 @@ static void ParseIntraMode(VP8BitReader* const br,
     }
   }
   // Hardcoded UVMode decision tree
-  block->uvmode_ = !VP8GetBit(br, 142, "pred-modes-uv") ? DC_PRED
-                 : !VP8GetBit(br, 114, "pred-modes-uv") ? V_PRED
-                 : VP8GetBit(br, 183, "pred-modes-uv") ? TM_PRED : H_PRED;
+  block->uvmode_ = !VP8GetBit(br, 142) ? DC_PRED
+                 : !VP8GetBit(br, 114) ? V_PRED
+                 : VP8GetBit(br, 183) ? TM_PRED : H_PRED;
 }
 
 int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
@@ -506,7 +495,7 @@ static const uint8_t
 
 // Paragraph 9.9
 
-static const uint8_t kBands[16 + 1] = {
+static const int kBands[16 + 1] = {
   0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7,
   0  // extra entry as sentinel
 };
@@ -518,10 +507,8 @@ void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
     for (b = 0; b < NUM_BANDS; ++b) {
       for (c = 0; c < NUM_CTX; ++c) {
         for (p = 0; p < NUM_PROBAS; ++p) {
-          const int v =
-              VP8GetBit(br, CoeffsUpdateProba[t][b][c][p], "global-header") ?
-                        VP8GetValue(br, 8, "global-header") :
-                        CoeffsProba0[t][b][c][p];
+          const int v = VP8GetBit(br, CoeffsUpdateProba[t][b][c][p]) ?
+                        VP8GetValue(br, 8) : CoeffsProba0[t][b][c][p];
           proba->bands_[t][b].probas_[c][p] = v;
         }
       }
@@ -530,8 +517,9 @@ void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
       proba->bands_ptr_[t][b] = &proba->bands_[t][kBands[b]];
     }
   }
-  dec->use_skip_proba_ = VP8Get(br, "global-header");
+  dec->use_skip_proba_ = VP8Get(br);
   if (dec->use_skip_proba_) {
-    dec->skip_p_ = VP8GetValue(br, 8, "global-header");
+    dec->skip_p_ = VP8GetValue(br, 8);
   }
 }
+

src/dec/vp8.c

@@ -13,12 +13,12 @@
 
 #include <stdlib.h>
 
-#include "src/dec/alphai_dec.h"
-#include "src/dec/vp8i_dec.h"
-#include "src/dec/vp8li_dec.h"
-#include "src/dec/webpi_dec.h"
-#include "src/utils/bit_reader_inl_utils.h"
-#include "src/utils/utils.h"
+#include "./alphai.h"
+#include "./vp8i.h"
+#include "./vp8li.h"
+#include "./webpi.h"
+#include "../utils/bit_reader_inl.h"
+#include "../utils/utils.h"
 
 //------------------------------------------------------------------------------
 
@@ -26,16 +26,6 @@ int WebPGetDecoderVersion(void) {
   return (DEC_MAJ_VERSION << 16) | (DEC_MIN_VERSION << 8) | DEC_REV_VERSION;
 }
 
-//------------------------------------------------------------------------------
-// Signature and pointer-to-function for GetCoeffs() variants below.
-
-typedef int (*GetCoeffsFunc)(VP8BitReader* const br,
-                             const VP8BandProbas* const prob[],
-                             int ctx, const quant_t dq, int n, int16_t* out);
-static volatile GetCoeffsFunc GetCoeffs = NULL;
-
-static void InitGetCoeffs(void);
-
 //------------------------------------------------------------------------------
 // VP8Decoder
 
@@ -61,7 +51,6 @@ VP8Decoder* VP8New(void) {
     WebPGetWorkerInterface()->Init(&dec->worker_);
     dec->ready_ = 0;
     dec->num_parts_minus_one_ = 0;
-    InitGetCoeffs();
   }
   return dec;
 }
@@ -161,26 +150,23 @@ static int ParseSegmentHeader(VP8BitReader* br,
                               VP8SegmentHeader* hdr, VP8Proba* proba) {
   assert(br != NULL);
   assert(hdr != NULL);
-  hdr->use_segment_ = VP8Get(br, "global-header");
+  hdr->use_segment_ = VP8Get(br);
   if (hdr->use_segment_) {
-    hdr->update_map_ = VP8Get(br, "global-header");
-    if (VP8Get(br, "global-header")) {   // update data
+    hdr->update_map_ = VP8Get(br);
+    if (VP8Get(br)) {   // update data
       int s;
-      hdr->absolute_delta_ = VP8Get(br, "global-header");
+      hdr->absolute_delta_ = VP8Get(br);
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->quantizer_[s] = VP8Get(br, "global-header") ?
-            VP8GetSignedValue(br, 7, "global-header") : 0;
+        hdr->quantizer_[s] = VP8Get(br) ? VP8GetSignedValue(br, 7) : 0;
       }
       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
-        hdr->filter_strength_[s] = VP8Get(br, "global-header") ?
-            VP8GetSignedValue(br, 6, "global-header") : 0;
+        hdr->filter_strength_[s] = VP8Get(br) ? VP8GetSignedValue(br, 6) : 0;
       }
     }
     if (hdr->update_map_) {
       int s;
       for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
-        proba->segments_[s] = VP8Get(br, "global-header") ?
-            VP8GetValue(br, 8, "global-header") : 255u;
+        proba->segments_[s] = VP8Get(br) ? VP8GetValue(br, 8) : 255u;
       }
     }
   } else {
@@ -208,7 +194,7 @@ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
   size_t last_part;
   size_t p;
 
-  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2, "global-header")) - 1;
+  dec->num_parts_minus_one_ = (1 << VP8GetValue(br, 2)) - 1;
   last_part = dec->num_parts_minus_one_;
   if (size < 3 * last_part) {
     // we can't even read the sizes with sz[]! That's a failure.
@@ -232,21 +218,21 @@ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
 // Paragraph 9.4
 static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
   VP8FilterHeader* const hdr = &dec->filter_hdr_;
-  hdr->simple_    = VP8Get(br, "global-header");
-  hdr->level_     = VP8GetValue(br, 6, "global-header");
-  hdr->sharpness_ = VP8GetValue(br, 3, "global-header");
-  hdr->use_lf_delta_ = VP8Get(br, "global-header");
+  hdr->simple_    = VP8Get(br);
+  hdr->level_     = VP8GetValue(br, 6);
+  hdr->sharpness_ = VP8GetValue(br, 3);
+  hdr->use_lf_delta_ = VP8Get(br);
   if (hdr->use_lf_delta_) {
-    if (VP8Get(br, "global-header")) {   // update lf-delta?
+    if (VP8Get(br)) {   // update lf-delta?
       int i;
       for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
-        if (VP8Get(br, "global-header")) {
-          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
+        if (VP8Get(br)) {
+          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6);
         }
       }
       for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
-        if (VP8Get(br, "global-header")) {
-          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
+        if (VP8Get(br)) {
+          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6);
         }
       }
     }
@@ -287,14 +273,12 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
     frm_hdr->profile_ = (bits >> 1) & 7;
     frm_hdr->show_ = (bits >> 4) & 1;
     frm_hdr->partition_length_ = (bits >> 5);
-    if (frm_hdr->profile_ > 3) {
+    if (frm_hdr->profile_ > 3)
       return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
                          "Incorrect keyframe parameters.");
-    }
-    if (!frm_hdr->show_) {
+    if (!frm_hdr->show_)
       return VP8SetError(dec, VP8_STATUS_UNSUPPORTED_FEATURE,
                          "Frame not displayable.");
-    }
     buf += 3;
     buf_size -= 3;
   }
@@ -355,8 +339,8 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
   buf_size -= frm_hdr->partition_length_;
 
   if (frm_hdr->key_frame_) {
-    pic_hdr->colorspace_ = VP8Get(br, "global-header");
-    pic_hdr->clamp_type_ = VP8Get(br, "global-header");
+    pic_hdr->colorspace_ = VP8Get(br);
+    pic_hdr->clamp_type_ = VP8Get(br);
   }
   if (!ParseSegmentHeader(br, &dec->segment_hdr_, &dec->proba_)) {
     return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
@@ -381,7 +365,7 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
                        "Not a key frame.");
   }
 
-  VP8Get(br, "global-header");   // ignore the value of update_proba_
+  VP8Get(br);   // ignore the value of update_proba_
 
   VP8ParseProba(br, dec);
 
@@ -406,28 +390,28 @@ static const uint8_t kZigzag[16] = {
 // See section 13-2: http://tools.ietf.org/html/rfc6386#section-13.2
 static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
   int v;
-  if (!VP8GetBit(br, p[3], "coeffs")) {
-    if (!VP8GetBit(br, p[4], "coeffs")) {
+  if (!VP8GetBit(br, p[3])) {
+    if (!VP8GetBit(br, p[4])) {
       v = 2;
     } else {
-      v = 3 + VP8GetBit(br, p[5], "coeffs");
+      v = 3 + VP8GetBit(br, p[5]);
     }
   } else {
-    if (!VP8GetBit(br, p[6], "coeffs")) {
-      if (!VP8GetBit(br, p[7], "coeffs")) {
-        v = 5 + VP8GetBit(br, 159, "coeffs");
+    if (!VP8GetBit(br, p[6])) {
+      if (!VP8GetBit(br, p[7])) {
+        v = 5 + VP8GetBit(br, 159);
       } else {
-        v = 7 + 2 * VP8GetBit(br, 165, "coeffs");
-        v += VP8GetBit(br, 145, "coeffs");
+        v = 7 + 2 * VP8GetBit(br, 165);
+        v += VP8GetBit(br, 145);
       }
     } else {
       const uint8_t* tab;
-      const int bit1 = VP8GetBit(br, p[8], "coeffs");
-      const int bit0 = VP8GetBit(br, p[9 + bit1], "coeffs");
+      const int bit1 = VP8GetBit(br, p[8]);
+      const int bit0 = VP8GetBit(br, p[9 + bit1]);
       const int cat = 2 * bit1 + bit0;
       v = 0;
       for (tab = kCat3456[cat]; *tab; ++tab) {
-        v += v + VP8GetBit(br, *tab, "coeffs");
+        v += v + VP8GetBit(br, *tab);
       }
       v += 3 + (8 << cat);
     }
@@ -436,74 +420,33 @@ static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
 }
 
 // Returns the position of the last non-zero coeff plus one
-static int GetCoeffsFast(VP8BitReader* const br,
-                         const VP8BandProbas* const prob[],
-                         int ctx, const quant_t dq, int n, int16_t* out) {
+static int GetCoeffs(VP8BitReader* const br, const VP8BandProbas* const prob[],
+                     int ctx, const quant_t dq, int n, int16_t* out) {
   const uint8_t* p = prob[n]->probas_[ctx];
   for (; n < 16; ++n) {
-    if (!VP8GetBit(br, p[0], "coeffs")) {
+    if (!VP8GetBit(br, p[0])) {
       return n;  // previous coeff was last non-zero coeff
     }
-    while (!VP8GetBit(br, p[1], "coeffs")) {       // sequence of zero coeffs
+    while (!VP8GetBit(br, p[1])) {       // sequence of zero coeffs
       p = prob[++n]->probas_[0];
       if (n == 16) return 16;
     }
     {        // non zero coeff
       const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas_[0];
       int v;
-      if (!VP8GetBit(br, p[2], "coeffs")) {
+      if (!VP8GetBit(br, p[2])) {
         v = 1;
         p = p_ctx[1];
       } else {
         v = GetLargeValue(br, p);
         p = p_ctx[2];
       }
-      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
+      out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
     }
   }
   return 16;
 }
 
-// This version of GetCoeffs() uses VP8GetBitAlt() which is an alternate version
-// of VP8GetBitAlt() targeting specific platforms.
-static int GetCoeffsAlt(VP8BitReader* const br,
-                        const VP8BandProbas* const prob[],
-                        int ctx, const quant_t dq, int n, int16_t* out) {
-  const uint8_t* p = prob[n]->probas_[ctx];
-  for (; n < 16; ++n) {
-    if (!VP8GetBitAlt(br, p[0], "coeffs")) {
-      return n;  // previous coeff was last non-zero coeff
-    }
-    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], "coeffs")) {
-        v = 1;
-        p = p_ctx[1];
-      } else {
-        v = GetLargeValue(br, p);
-        p = p_ctx[2];
-      }
-      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
-    }
-  }
-  return 16;
-}
-
-static WEBP_TSAN_IGNORE_FUNCTION void InitGetCoeffs(void) {
-  if (GetCoeffs == NULL) {
-    if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
-      GetCoeffs = GetCoeffsAlt;
-    } else {
-      GetCoeffs = GetCoeffsFast;
-    }
-  }
-}
-
 static WEBP_INLINE uint32_t NzCodeBits(uint32_t nz_coeffs, int nz, int dc_nz) {
   nz_coeffs <<= 2;
   nz_coeffs |= (nz > 3) ? 3 : (nz > 1) ? 2 : dc_nz;

src/dec/vp8i.h

@@ -11,16 +11,16 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
-#ifndef WEBP_DEC_VP8I_DEC_H_
-#define WEBP_DEC_VP8I_DEC_H_
+#ifndef WEBP_DEC_VP8I_H_
+#define WEBP_DEC_VP8I_H_
 
 #include <string.h>     // for memcpy()
-#include "src/dec/common_dec.h"
-#include "src/dec/vp8li_dec.h"
-#include "src/utils/bit_reader_utils.h"
-#include "src/utils/random_utils.h"
-#include "src/utils/thread_utils.h"
-#include "src/dsp/dsp.h"
+#include "./common.h"
+#include "./vp8li.h"
+#include "../utils/bit_reader.h"
+#include "../utils/random.h"
+#include "../utils/thread.h"
+#include "../dsp/dsp.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -30,9 +30,9 @@ extern "C" {
 // Various defines and enums
 
 // version numbers
-#define DEC_MAJ_VERSION 1
-#define DEC_MIN_VERSION 0
-#define DEC_REV_VERSION 3
+#define DEC_MAJ_VERSION 0
+#define DEC_MIN_VERSION 5
+#define DEC_REV_VERSION 2
 
 // YUV-cache parameters. Cache is 32-bytes wide (= one cacheline).
 // Constraints are: We need to store one 16x16 block of luma samples (y),
@@ -57,6 +57,7 @@ extern "C" {
 //  '|' = left sample,   '-' = top sample,    '+' = top-left sample
 //  't' = extra top-right sample for 4x4 modes
 #define YUV_SIZE (BPS * 17 + BPS * 9)
+#define Y_SIZE   (BPS * 17)
 #define Y_OFF    (BPS * 1 + 8)
 #define U_OFF    (Y_OFF + BPS * 16 + BPS)
 #define V_OFF    (U_OFF + 16)
@@ -316,4 +317,4 @@ const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_DEC_VP8I_DEC_H_
+#endif  /* WEBP_DEC_VP8I_H_ */

src/dec/vp8l.c

@@ -14,22 +14,21 @@
 
 #include <stdlib.h>
 
-#include "src/dec/alphai_dec.h"
-#include "src/dec/vp8li_dec.h"
-#include "src/dsp/dsp.h"
-#include "src/dsp/lossless.h"
-#include "src/dsp/lossless_common.h"
-#include "src/dsp/yuv.h"
-#include "src/utils/endian_inl_utils.h"
-#include "src/utils/huffman_utils.h"
-#include "src/utils/utils.h"
+#include "./alphai.h"
+#include "./vp8li.h"
+#include "../dsp/dsp.h"
+#include "../dsp/lossless.h"
+#include "../dsp/yuv.h"
+#include "../utils/endian_inl.h"
+#include "../utils/huffman.h"
+#include "../utils/utils.h"
 
 #define NUM_ARGB_CACHE_ROWS          16
 
 static const int kCodeLengthLiterals = 16;
 static const int kCodeLengthRepeatCode = 16;
-static const uint8_t kCodeLengthExtraBits[3] = { 2, 3, 7 };
-static const uint8_t kCodeLengthRepeatOffsets[3] = { 3, 3, 11 };
+static const int kCodeLengthExtraBits[3] = { 2, 3, 7 };
+static const int kCodeLengthRepeatOffsets[3] = { 3, 3, 11 };
 
 // -----------------------------------------------------------------------------
 //  Five Huffman codes are used at each meta code:
@@ -86,7 +85,7 @@ static const uint8_t kCodeToPlane[CODE_TO_PLANE_CODES] = {
 // All values computed for 8-bit first level lookup with Mark Adler's tool:
 // http://www.hdfgroup.org/ftp/lib-external/zlib/zlib-1.2.5/examples/enough.c
 #define FIXED_TABLE_SIZE (630 * 3 + 410)
-static const uint16_t kTableSize[12] = {
+static const int kTableSize[12] = {
   FIXED_TABLE_SIZE + 654,
   FIXED_TABLE_SIZE + 656,
   FIXED_TABLE_SIZE + 658,
@@ -253,11 +252,11 @@ static int ReadHuffmanCodeLengths(
   int symbol;
   int max_symbol;
   int prev_code_len = DEFAULT_CODE_LENGTH;
-  HuffmanCode table[1 << LENGTHS_TABLE_BITS];
+  HuffmanTables tables;
 
-  if (!VP8LBuildHuffmanTable(table, LENGTHS_TABLE_BITS,
-                             code_length_code_lengths,
-                             NUM_CODE_LENGTH_CODES)) {
+  if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables) ||
+      !VP8LBuildHuffmanTable(&tables, LENGTHS_TABLE_BITS,
+                             code_length_code_lengths, NUM_CODE_LENGTH_CODES)) {
     goto End;
   }
 
@@ -277,7 +276,7 @@ static int ReadHuffmanCodeLengths(
     int code_len;
     if (max_symbol-- == 0) break;
     VP8LFillBitWindow(br);
-    p = &table[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
+    p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
     VP8LSetBitPos(br, br->bit_pos_ + p->bits);
     code_len = p->value;
     if (code_len < kCodeLengthLiterals) {
@@ -300,6 +299,7 @@ static int ReadHuffmanCodeLengths(
   ok = 1;
 
  End:
+  VP8LHuffmanTablesDeallocate(&tables);
   if (!ok) dec->status_ = VP8_STATUS_BITSTREAM_ERROR;
   return ok;
 }
@@ -307,7 +307,8 @@ static int ReadHuffmanCodeLengths(
 // 'code_lengths' is pre-allocated temporary buffer, used for creating Huffman
 // tree.
 static int ReadHuffmanCode(int alphabet_size, VP8LDecoder* const dec,
-                           int* const code_lengths, HuffmanCode* const table) {
+                           int* const code_lengths,
+                           HuffmanTables* const table) {
   int ok = 0;
   int size = 0;
   VP8LBitReader* const br = &dec->br_;
@@ -362,8 +363,7 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
   VP8LMetadata* const hdr = &dec->hdr_;
   uint32_t* huffman_image = NULL;
   HTreeGroup* htree_groups = NULL;
-  HuffmanCode* huffman_tables = NULL;
-  HuffmanCode* huffman_table = NULL;
+  HuffmanTables* huffman_tables = &hdr->huffman_tables_;
   int num_htree_groups = 1;
   int num_htree_groups_max = 1;
   int max_alphabet_size = 0;
@@ -372,6 +372,10 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
   int* mapping = NULL;
   int ok = 0;
 
+  // Check the table has been 0 initialized (through InitMetadata).
+  assert(huffman_tables->root.start == NULL);
+  assert(huffman_tables->curr_segment == NULL);
+
   if (allow_recursion && VP8LReadBits(br, 1)) {
     // use meta Huffman codes.
     const int huffman_precision = VP8LReadBits(br, 3) + 2;
@@ -432,18 +436,17 @@ 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));
-  huffman_tables = (HuffmanCode*)WebPSafeMalloc(num_htree_groups * table_size,
-                                                sizeof(*huffman_tables));
-  htree_groups = VP8LHtreeGroupsNew(num_htree_groups);
 
-  if (htree_groups == NULL || code_lengths == NULL || huffman_tables == NULL) {
+  if (htree_groups == NULL || code_lengths == NULL ||
+      !VP8LHuffmanTablesAllocate(num_htree_groups * table_size,
+                                 huffman_tables)) {
     dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
     goto Error;
   }
 
-  huffman_table = huffman_tables;
   for (i = 0; i < num_htree_groups_max; ++i) {
     // If the index "i" is unused in the Huffman image, just make sure the
     // coefficients are valid but do not store them.
@@ -468,19 +471,20 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
       int max_bits = 0;
       for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
         int alphabet_size = kAlphabetSize[j];
-        htrees[j] = huffman_table;
         if (j == 0 && color_cache_bits > 0) {
           alphabet_size += (1 << color_cache_bits);
         }
-        size = ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_table);
+        size =
+            ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables);
+        htrees[j] = huffman_tables->curr_segment->curr_table;
         if (size == 0) {
           goto Error;
         }
         if (is_trivial_literal && kLiteralMap[j] == 1) {
-          is_trivial_literal = (huffman_table->bits == 0);
+          is_trivial_literal = (htrees[j]->bits == 0);
         }
-        total_size += huffman_table->bits;
-        huffman_table += size;
+        total_size += htrees[j]->bits;
+        huffman_tables->curr_segment->curr_table += size;
         if (j <= ALPHA) {
           int local_max_bits = code_lengths[0];
           int k;
@@ -515,14 +519,13 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
   hdr->huffman_image_ = huffman_image;
   hdr->num_htree_groups_ = num_htree_groups;
   hdr->htree_groups_ = htree_groups;
-  hdr->huffman_tables_ = huffman_tables;
 
  Error:
   WebPSafeFree(code_lengths);
   WebPSafeFree(mapping);
   if (!ok) {
     WebPSafeFree(huffman_image);
-    WebPSafeFree(huffman_tables);
+    VP8LHuffmanTablesDeallocate(huffman_tables);
     VP8LHtreeGroupsFree(htree_groups);
   }
   return ok;
@@ -531,7 +534,6 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
 //------------------------------------------------------------------------------
 // Scaling.
 
-#if !defined(WEBP_REDUCE_SIZE)
 static int AllocateAndInitRescaler(VP8LDecoder* const dec, VP8Io* const io) {
   const int num_channels = 4;
   const int in_width = io->mb_w;
@@ -563,13 +565,10 @@ static int AllocateAndInitRescaler(VP8LDecoder* const dec, VP8Io* const io) {
                    out_width, out_height, 0, num_channels, work);
   return 1;
 }
-#endif   // WEBP_REDUCE_SIZE
 
 //------------------------------------------------------------------------------
 // Export to ARGB
 
-#if !defined(WEBP_REDUCE_SIZE)
-
 // We have special "export" function since we need to convert from BGRA
 static int Export(WebPRescaler* const rescaler, WEBP_CSP_MODE colorspace,
                   int rgba_stride, uint8_t* const rgba) {
@@ -598,21 +597,16 @@ static int EmitRescaledRowsRGBA(const VP8LDecoder* const dec,
     uint8_t* const row_out = out + num_lines_out * out_stride;
     const int lines_left = mb_h - num_lines_in;
     const int needed_lines = WebPRescaleNeededLines(dec->rescaler, lines_left);
-    int lines_imported;
     assert(needed_lines > 0 && needed_lines <= lines_left);
     WebPMultARGBRows(row_in, in_stride,
                      dec->rescaler->src_width, needed_lines, 0);
-    lines_imported =
-        WebPRescalerImport(dec->rescaler, lines_left, row_in, in_stride);
-    assert(lines_imported == needed_lines);
-    num_lines_in += lines_imported;
+    WebPRescalerImport(dec->rescaler, lines_left, row_in, in_stride);
+    num_lines_in += needed_lines;
     num_lines_out += Export(dec->rescaler, colorspace, out_stride, row_out);
   }
   return num_lines_out;
 }
 
-#endif   // WEBP_REDUCE_SIZE
-
 // Emit rows without any scaling.
 static int EmitRows(WEBP_CSP_MODE colorspace,
                     const uint8_t* row_in, int in_stride,
@@ -679,12 +673,9 @@ static int EmitRescaledRowsYUVA(const VP8LDecoder* const dec,
   while (num_lines_in < mb_h) {
     const int lines_left = mb_h - num_lines_in;
     const int needed_lines = WebPRescaleNeededLines(dec->rescaler, lines_left);
-    int lines_imported;
     WebPMultARGBRows(in, in_stride, dec->rescaler->src_width, needed_lines, 0);
-    lines_imported =
-        WebPRescalerImport(dec->rescaler, lines_left, in, in_stride);
-    assert(lines_imported == needed_lines);
-    num_lines_in += lines_imported;
+    WebPRescalerImport(dec->rescaler, lines_left, in, in_stride);
+    num_lines_in += needed_lines;
     in += needed_lines * in_stride;
     y_pos += ExportYUVA(dec, y_pos);
   }
@@ -764,15 +755,13 @@ static void ApplyInverseTransforms(VP8LDecoder* const dec, int num_rows,
   uint32_t* const rows_out = dec->argb_cache_;
 
   // Inverse transforms.
+  // TODO: most transforms only need to operate on the cropped region only.
+  memcpy(rows_out, rows_in, cache_pixs * sizeof(*rows_out));
   while (n-- > 0) {
     VP8LTransform* const transform = &dec->transforms_[n];
     VP8LInverseTransform(transform, start_row, end_row, rows_in, rows_out);
     rows_in = rows_out;
   }
-  if (rows_in != rows_out) {
-    // No transform called, hence just copy.
-    memcpy(rows_out, rows_in, cache_pixs * sizeof(*rows_out));
-  }
 }
 
 // Processes (transforms, scales & color-converts) the rows decoded after the
@@ -798,12 +787,9 @@ static void ProcessRows(VP8LDecoder* const dec, int row) {
       if (WebPIsRGBMode(output->colorspace)) {  // convert to RGBA
         const WebPRGBABuffer* const buf = &output->u.RGBA;
         uint8_t* const rgba = buf->rgba + dec->last_out_row_ * buf->stride;
-        const int num_rows_out =
-#if !defined(WEBP_REDUCE_SIZE)
-         io->use_scaling ?
+        const int num_rows_out = io->use_scaling ?
             EmitRescaledRowsRGBA(dec, rows_data, in_stride, io->mb_h,
                                  rgba, buf->stride) :
-#endif  // WEBP_REDUCE_SIZE
             EmitRows(output->colorspace, rows_data, in_stride,
                      io->mb_w, io->mb_h, rgba, buf->stride);
         // Update 'last_out_row_'.
@@ -930,11 +916,7 @@ static WEBP_INLINE void CopyBlock8b(uint8_t* const dst, int dist, int length) {
 #endif
         break;
       case 2:
-#if !defined(WORDS_BIGENDIAN)
         memcpy(&pattern, src, sizeof(uint16_t));
-#else
-        pattern = ((uint32_t)src[0] << 8) | src[1];
-#endif
 #if defined(__arm__) || defined(_M_ARM)
         pattern |= pattern << 16;
 #elif defined(WEBP_USE_MIPS_DSP_R2)
@@ -1071,13 +1053,12 @@ static int DecodeAlphaData(VP8LDecoder* const dec, uint8_t* const data,
       ok = 0;
       goto End;
     }
-    br->eos_ = VP8LIsEndOfStream(br);
+    assert(br->eos_ == VP8LIsEndOfStream(br));
   }
   // Process the remaining rows corresponding to last row-block.
   ExtractPalettedAlphaRows(dec, row > last_row ? last_row : row);
 
  End:
-  br->eos_ = VP8LIsEndOfStream(br);
   if (!ok || (br->eos_ && pos < end)) {
     ok = 0;
     dec->status_ = br->eos_ ? VP8_STATUS_SUSPENDED
@@ -1150,12 +1131,11 @@ static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data,
     VP8LFillBitWindow(br);
     if (htree_group->use_packed_table) {
       code = ReadPackedSymbols(htree_group, br, src);
-      if (VP8LIsEndOfStream(br)) break;
       if (code == PACKED_NON_LITERAL_CODE) goto AdvanceByOne;
     } else {
       code = ReadSymbol(htree_group->htrees[GREEN], br);
     }
-    if (VP8LIsEndOfStream(br)) break;
+    if (br->eos_) break;  // early out
     if (code < NUM_LITERAL_CODES) {  // Literal
       if (htree_group->is_trivial_literal) {
         *src = htree_group->literal_arb | (code << 8);
@@ -1165,7 +1145,7 @@ static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data,
         VP8LFillBitWindow(br);
         blue = ReadSymbol(htree_group->htrees[BLUE], br);
         alpha = ReadSymbol(htree_group->htrees[ALPHA], br);
-        if (VP8LIsEndOfStream(br)) break;
+        if (br->eos_) break;
         *src = ((uint32_t)alpha << 24) | (red << 16) | (code << 8) | blue;
       }
     AdvanceByOne:
@@ -1193,7 +1173,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 (br->eos_) break;
       if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) {
         goto Error;
       } else {
@@ -1230,12 +1210,24 @@ static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data,
     } else {  // Not reached
       goto Error;
     }
+    assert(br->eos_ == VP8LIsEndOfStream(br));
   }
 
   br->eos_ = VP8LIsEndOfStream(br);
-  if (dec->incremental_ && br->eos_ && src < src_end) {
+  // 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) {
     RestoreState(dec);
-  } else if (!br->eos_) {
+  } else if ((dec->incremental_ && src >= src_last) || !br->eos_) {
     // Process the remaining rows corresponding to last row-block.
     if (process_func != NULL) {
       process_func(dec, row > last_row ? last_row : row);
@@ -1280,9 +1272,8 @@ static int ExpandColorMap(int num_colors, VP8LTransform* const transform) {
       // Equivalent to AddPixelEq(), on a byte-basis.
       new_data[i] = (data[i] + new_data[i - 4]) & 0xff;
     }
-    for (; i < 4 * final_num_colors; ++i) {
+    for (; i < 4 * final_num_colors; ++i)
       new_data[i] = 0;  // black tail.
-    }
     WebPSafeFree(transform->data_);
     transform->data_ = new_color_map;
   }
@@ -1354,7 +1345,7 @@ static void ClearMetadata(VP8LMetadata* const hdr) {
   assert(hdr != NULL);
 
   WebPSafeFree(hdr->huffman_image_);
-  WebPSafeFree(hdr->huffman_tables_);
+  VP8LHuffmanTablesDeallocate(&hdr->huffman_tables_);
   VP8LHtreeGroupsFree(hdr->htree_groups_);
   VP8LColorCacheClear(&hdr->color_cache_);
   VP8LColorCacheClear(&hdr->saved_color_cache_);
@@ -1553,8 +1544,9 @@ 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_;
+    int i;
     ApplyInverseTransforms(dec, num_rows_to_process, in);
-    WebPExtractGreen(src, dst, cache_pixs);
+    for (i = 0; i < cache_pixs; ++i) dst[i] = (src[i] >> 8) & 0xff;
     AlphaApplyFilter(alph_dec,
                      cur_row, cur_row + num_rows_to_process, dst, width);
     num_rows -= num_rows_to_process;
@@ -1573,6 +1565,7 @@ 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_;
@@ -1604,12 +1597,11 @@ 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(dec);
+  VP8LDelete(alph_dec->vp8l_dec_);
+  alph_dec->vp8l_dec_ = NULL;
   return 0;
 }
 
@@ -1622,8 +1614,6 @@ int VP8LDecodeAlphaImageStream(ALPHDecoder* const alph_dec, int last_row) {
     return 1;  // done
   }
 
-  if (!alph_dec->use_8b_decode_) WebPInitAlphaProcessing();
-
   // Decode (with special row processing).
   return alph_dec->use_8b_decode_ ?
       DecodeAlphaData(dec, (uint8_t*)dec->pixels_, dec->width_, dec->height_,
@@ -1670,7 +1660,7 @@ int VP8LDecodeImage(VP8LDecoder* const dec) {
   // Sanity checks.
   if (dec == NULL) return 0;
 
-  assert(dec->hdr_.huffman_tables_ != NULL);
+  assert(dec->hdr_.huffman_tables_.root.start != NULL);
   assert(dec->hdr_.htree_groups_ != NULL);
   assert(dec->hdr_.num_htree_groups_ > 0);
 
@@ -1691,19 +1681,12 @@ int VP8LDecodeImage(VP8LDecoder* const dec) {
 
     if (!AllocateInternalBuffers32b(dec, io->width)) goto Err;
 
-#if !defined(WEBP_REDUCE_SIZE)
     if (io->use_scaling && !AllocateAndInitRescaler(dec, io)) goto Err;
-#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.h

@@ -12,14 +12,14 @@
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora(vikaas.arora@gmail.com)
 
-#ifndef WEBP_DEC_VP8LI_DEC_H_
-#define WEBP_DEC_VP8LI_DEC_H_
+#ifndef WEBP_DEC_VP8LI_H_
+#define WEBP_DEC_VP8LI_H_
 
 #include <string.h>     // for memcpy()
-#include "src/dec/webpi_dec.h"
-#include "src/utils/bit_reader_utils.h"
-#include "src/utils/color_cache_utils.h"
-#include "src/utils/huffman_utils.h"
+#include "./webpi.h"
+#include "../utils/bit_reader.h"
+#include "../utils/color_cache.h"
+#include "../utils/huffman.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -51,7 +51,7 @@ typedef struct {
   uint32_t       *huffman_image_;
   int             num_htree_groups_;
   HTreeGroup     *htree_groups_;
-  HuffmanCode    *huffman_tables_;
+  HuffmanTables   huffman_tables_;
 } VP8LMetadata;
 
 typedef struct VP8LDecoder VP8LDecoder;
@@ -132,4 +132,4 @@ void VP8LDelete(VP8LDecoder* const dec);
 }    // extern "C"
 #endif
 
-#endif  // WEBP_DEC_VP8LI_DEC_H_
+#endif  /* WEBP_DEC_VP8LI_H_ */

src/dec/webp.c

@@ -13,11 +13,11 @@
 
 #include <stdlib.h>
 
-#include "src/dec/vp8i_dec.h"
-#include "src/dec/vp8li_dec.h"
-#include "src/dec/webpi_dec.h"
-#include "src/utils/utils.h"
-#include "src/webp/mux_types.h"  // ALPHA_FLAG
+#include "./vp8i.h"
+#include "./vp8li.h"
+#include "./webpi.h"
+#include "../utils/utils.h"
+#include "../webp/mux_types.h"  // ALPHA_FLAG
 
 //------------------------------------------------------------------------------
 // RIFF layout is:
@@ -39,8 +39,8 @@
 //   20..23  VP8X flags bit-map corresponding to the chunk-types present.
 //   24..26  Width of the Canvas Image.
 //   27..29  Height of the Canvas Image.
-// There can be extra chunks after the "VP8X" chunk (ICCP, ANMF, VP8, VP8L,
-// XMP, EXIF  ...)
+// There can be extra chunks after the "VP8X" chunk (ICCP, FRGM, ANMF, VP8,
+// VP8L, XMP, EXIF  ...)
 // All sizes are in little-endian order.
 // Note: chunk data size must be padded to multiple of 2 when written.
 
@@ -289,6 +289,7 @@ static VP8StatusCode ParseHeadersInternal(const uint8_t* data,
   int found_riff = 0;
   int found_vp8x = 0;
   int animation_present = 0;
+  int fragments_present = 0;
   const int have_all_data = (headers != NULL) ? headers->have_all_data : 0;
 
   VP8StatusCode status;
@@ -317,6 +318,7 @@ static VP8StatusCode ParseHeadersInternal(const uint8_t* data,
       return status;  // Wrong VP8X / insufficient data.
     }
     animation_present = !!(flags & ANIMATION_FLAG);
+    fragments_present = !!(flags & FRAGMENTS_FLAG);
     if (!found_riff && found_vp8x) {
       // Note: This restriction may be removed in the future, if it becomes
       // necessary to send VP8X chunk to the decoder.
@@ -328,7 +330,8 @@ static VP8StatusCode ParseHeadersInternal(const uint8_t* data,
 
     image_width = canvas_width;
     image_height = canvas_height;
-    if (found_vp8x && animation_present && headers == NULL) {
+    if (found_vp8x && (animation_present || fragments_present) &&
+        headers == NULL) {
       status = VP8_STATUS_OK;
       goto ReturnWidthHeight;  // Just return features from VP8X header.
     }
@@ -359,7 +362,7 @@ static VP8StatusCode ParseHeadersInternal(const uint8_t* data,
     return VP8_STATUS_BITSTREAM_ERROR;
   }
 
-  if (format != NULL && !animation_present) {
+  if (format != NULL && !(animation_present || fragments_present)) {
     *format = hdrs.is_lossless ? 2 : 1;
   }
 
@@ -421,9 +424,7 @@ VP8StatusCode WebPParseHeaders(WebPHeaderStructure* const headers) {
                                 NULL, NULL, NULL, &has_animation,
                                 NULL, headers);
   if (status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA) {
-    // The WebPDemux API + libwebp can be used to decode individual
-    // uncomposited frames or the WebPAnimDecoder can be used to fully
-    // reconstruct them (see webp/demux.h).
+    // TODO(jzern): full support of animation frames will require API additions.
     if (has_animation) {
       status = VP8_STATUS_UNSUPPORTED_FEATURE;
     }

src/dec/webpi.h

@@ -11,15 +11,15 @@
 //
 // Author: somnath@google.com (Somnath Banerjee)
 
-#ifndef WEBP_DEC_WEBPI_DEC_H_
-#define WEBP_DEC_WEBPI_DEC_H_
+#ifndef WEBP_DEC_WEBPI_H_
+#define WEBP_DEC_WEBPI_H_
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "src/utils/rescaler_utils.h"
-#include "src/dec/vp8_dec.h"
+#include "../utils/rescaler.h"
+#include "./decode_vp8.h"
 
 //------------------------------------------------------------------------------
 // WebPDecParams: Decoding output parameters. Transient internal object.
@@ -38,18 +38,27 @@ struct WebPDecParams {
 
   int last_y;                 // coordinate of the line that was last output
   const WebPDecoderOptions* options;  // if not NULL, use alt decoding features
-
-  WebPRescaler* scaler_y, *scaler_u, *scaler_v, *scaler_a;  // rescalers
+  // rescalers
+  WebPRescaler scaler_y, scaler_u, scaler_v, scaler_a;
   void* memory;                  // overall scratch memory for the output work.
 
   OutputFunc emit;               // output RGB or YUV samples
   OutputAlphaFunc emit_alpha;    // output alpha channel
   OutputRowFunc emit_alpha_row;  // output one line of rescaled alpha values
+
+  WebPDecBuffer* final_output;   // In case the user supplied a slow-memory
+                                 // output, we decode image in temporary buffer
+                                 // (this::output) and copy it here.
+  WebPDecBuffer tmp_buffer;      // this::output will point to this one in case
+                                 // of slow memory.
 };
 
 // Should be called first, before any use of the WebPDecParams object.
 void WebPResetDecParams(WebPDecParams* const params);
 
+// Delete all memory (after an error occurred, for instance)
+void WebPFreeDecParams(WebPDecParams* const params);
+
 //------------------------------------------------------------------------------
 // Header parsing helpers
 
@@ -130,4 +139,4 @@ int WebPAvoidSlowMemory(const WebPDecBuffer* const output,
 }    // extern "C"
 #endif
 
-#endif  // WEBP_DEC_WEBPI_DEC_H_
+#endif  /* WEBP_DEC_WEBPI_H_ */

src/demux/Makefile.am

@@ -1,18 +1,14 @@
-AM_CPPFLAGS += -I$(top_builddir) -I$(top_srcdir)
 lib_LTLIBRARIES = libwebpdemux.la
 
 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:6:0
+libwebpdemux_la_LDFLAGS = -no-undefined -version-info 2:1:0
 libwebpdemuxincludedir = $(includedir)/webp
 pkgconfig_DATA = libwebpdemux.pc

src/demux/anim_decode.c

@@ -11,15 +11,15 @@
 //
 
 #ifdef HAVE_CONFIG_H
-#include "src/webp/config.h"
+#include "../webp/config.h"
 #endif
 
 #include <assert.h>
 #include <string.h>
 
-#include "src/utils/utils.h"
-#include "src/webp/decode.h"
-#include "src/webp/demux.h"
+#include "../utils/utils.h"
+#include "../webp/decode.h"
+#include "../webp/demux.h"
 
 #define NUM_CHANNELS 4