Fix invalid incremental decoding check.

(cherry picked from commit 95ea5226c8)

Change-Id: I80c2165aa9fdf43077db155d2d00e0e99db73eab

.gitattributes

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

.gitignore

@@ -1,11 +1,8 @@
 *.l[ao]
 *.[ao]
 *.pc
-.DS_Store
 .deps
-.idea
 .libs
-.vscode
 /aclocal.m4
 /ar-lib
 /autom4te.cache
@@ -23,11 +20,8 @@
 Makefile
 Makefile.in
 examples/anim_diff
-examples/anim_dump
 examples/[cdv]webp
 examples/gif2webp
-examples/img2webp
-examples/webpinfo
 examples/webpmux
 src/webp/config.h*
 src/webp/stamp-h1
@@ -36,21 +30,7 @@ src/webp/stamp-h1
 *.idb
 *.pdb
 /iosbuild
-/xcframeworkbuild
-/WebP*.*framework
+/WebP.framework
 CMakeCache.txt
 CMakeFiles/
 cmake_install.cmake
-.gradle
-/build
-extras/get_disto
-extras/vwebp_sdl
-extras/webp_quality
-tests/fuzzer/advanced_api_fuzzer
-tests/fuzzer/animation_api_fuzzer
-tests/fuzzer/animdecoder_fuzzer
-tests/fuzzer/animencoder_fuzzer
-tests/fuzzer/demux_api_fuzzer
-tests/fuzzer/enc_dec_fuzzer
-tests/fuzzer/mux_demux_api_fuzzer
-tests/fuzzer/simple_api_fuzzer

.mailmap

@@ -1,18 +1,12 @@
-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>
 <slobodan.prijic@imgtec.com> <Slobodan.Prijic@imgtec.com>
 <vrabaud@google.com> <vincent.rabaud@gmail.com>
-Vincent Rabaud <vrabaud@google.com>
 Tamar Levy <tamar.levy@intel.com>
 <qrczak@google.com> <qrczak>
 Hui Su <huisu@google.com>
-James Zern <jzern@google.com>
-Roberto Alanis <alanisbaez@google.com>
-Brian Ledger <brianpl@google.com>
-Maryla Ustarroz-Calonge <maryla@google.com>

.pylintrc

@@ -1,441 +0,0 @@
-# This Pylint rcfile contains a best-effort configuration to uphold the
-# best-practices and style described in the Google Python style guide:
-#   https://google.github.io/styleguide/pyguide.html
-#
-# Its canonical open-source location is:
-#   https://google.github.io/styleguide/pylintrc
-
-[MASTER]
-
-# Files or directories to be skipped. They should be base names, not paths.
-ignore=third_party
-
-# Files or directories matching the regex patterns are skipped. The regex
-# matches against base names, not paths.
-ignore-patterns=
-
-# Pickle collected data for later comparisons.
-persistent=no
-
-# List of plugins (as comma separated values of python modules names) to load,
-# usually to register additional checkers.
-load-plugins=
-
-# Use multiple processes to speed up Pylint.
-jobs=4
-
-# Allow loading of arbitrary C extensions. Extensions are imported into the
-# active Python interpreter and may run arbitrary code.
-unsafe-load-any-extension=no
-
-
-[MESSAGES CONTROL]
-
-# Only show warnings with the listed confidence levels. Leave empty to show
-# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
-confidence=
-
-# Enable the message, report, category or checker with the given id(s). You can
-# either give multiple identifier separated by comma (,) or put this option
-# multiple time (only on the command line, not in the configuration file where
-# it should appear only once). See also the "--disable" option for examples.
-#enable=
-
-# Disable the message, report, category or checker with the given id(s). You
-# can either give multiple identifiers separated by comma (,) or put this
-# option multiple times (only on the command line, not in the configuration
-# file where it should appear only once).You can also use "--disable=all" to
-# disable everything first and then reenable specific checks. For example, if
-# you want to run only the similarities checker, you can use "--disable=all
-# --enable=similarities". If you want to run only the classes checker, but have
-# no Warning level messages displayed, use"--disable=all --enable=classes
-# --disable=W"
-disable=abstract-method,
-        apply-builtin,
-        arguments-differ,
-        attribute-defined-outside-init,
-        backtick,
-        bad-option-value,
-        basestring-builtin,
-        buffer-builtin,
-        c-extension-no-member,
-        consider-using-enumerate,
-        cmp-builtin,
-        cmp-method,
-        coerce-builtin,
-        coerce-method,
-        delslice-method,
-        div-method,
-        duplicate-code,
-        eq-without-hash,
-        execfile-builtin,
-        file-builtin,
-        filter-builtin-not-iterating,
-        fixme,
-        getslice-method,
-        global-statement,
-        hex-method,
-        idiv-method,
-        implicit-str-concat-in-sequence,
-        import-error,
-        import-self,
-        import-star-module-level,
-        inconsistent-return-statements,
-        input-builtin,
-        intern-builtin,
-        invalid-str-codec,
-        locally-disabled,
-        long-builtin,
-        long-suffix,
-        map-builtin-not-iterating,
-        misplaced-comparison-constant,
-        missing-function-docstring,
-        metaclass-assignment,
-        next-method-called,
-        next-method-defined,
-        no-absolute-import,
-        no-else-break,
-        no-else-continue,
-        no-else-raise,
-        no-else-return,
-        no-init,  # added
-        no-member,
-        no-name-in-module,
-        no-self-use,
-        nonzero-method,
-        oct-method,
-        old-division,
-        old-ne-operator,
-        old-octal-literal,
-        old-raise-syntax,
-        parameter-unpacking,
-        print-statement,
-        raising-string,
-        range-builtin-not-iterating,
-        raw_input-builtin,
-        rdiv-method,
-        reduce-builtin,
-        relative-import,
-        reload-builtin,
-        round-builtin,
-        setslice-method,
-        signature-differs,
-        standarderror-builtin,
-        suppressed-message,
-        sys-max-int,
-        too-few-public-methods,
-        too-many-ancestors,
-        too-many-arguments,
-        too-many-boolean-expressions,
-        too-many-branches,
-        too-many-instance-attributes,
-        too-many-locals,
-        too-many-nested-blocks,
-        too-many-public-methods,
-        too-many-return-statements,
-        too-many-statements,
-        trailing-newlines,
-        unichr-builtin,
-        unicode-builtin,
-        unnecessary-pass,
-        unpacking-in-except,
-        useless-else-on-loop,
-        useless-object-inheritance,
-        useless-suppression,
-        using-cmp-argument,
-        wrong-import-order,
-        xrange-builtin,
-        zip-builtin-not-iterating,
-
-
-[REPORTS]
-
-# Set the output format. Available formats are text, parseable, colorized, msvs
-# (visual studio) and html. You can also give a reporter class, eg
-# mypackage.mymodule.MyReporterClass.
-output-format=text
-
-# Put messages in a separate file for each module / package specified on the
-# command line instead of printing them on stdout. Reports (if any) will be
-# written in a file name "pylint_global.[txt|html]". This option is deprecated
-# and it will be removed in Pylint 2.0.
-files-output=no
-
-# Tells whether to display a full report or only the messages
-reports=no
-
-# Python expression which should return a note less than 10 (10 is the highest
-# note). You have access to the variables errors warning, statement which
-# respectively contain the number of errors / warnings messages and the total
-# number of statements analyzed. This is used by the global evaluation report
-# (RP0004).
-evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
-
-# Template used to display messages. This is a python new-style format string
-# used to format the message information. See doc for all details
-#msg-template=
-
-
-[BASIC]
-
-# Good variable names which should always be accepted, separated by a comma
-good-names=main,_,PRESUBMIT
-
-# Bad variable names which should always be refused, separated by a comma
-bad-names=
-
-# Colon-delimited sets of names that determine each other's naming style when
-# the name regexes allow several styles.
-name-group=
-
-# Include a hint for the correct naming format with invalid-name
-include-naming-hint=no
-
-# List of decorators that produce properties, such as abc.abstractproperty. Add
-# to this list to register other decorators that produce valid properties.
-property-classes=abc.abstractproperty,cached_property.cached_property,cached_property.threaded_cached_property,cached_property.cached_property_with_ttl,cached_property.threaded_cached_property_with_ttl
-
-# Regular expression matching correct function names
-function-rgx=^(?:(?P<exempt>setUp|tearDown|setUpModule|tearDownModule)|(?P<camel_case>_?[A-Z][a-zA-Z0-9]*)|(?P<snake_case>_?[a-z][a-z0-9_]*))$
-
-# Regular expression matching correct variable names
-variable-rgx=^[a-z][a-z0-9_]*$
-
-# Regular expression matching correct constant names
-const-rgx=^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$
-
-# Regular expression matching correct attribute names
-attr-rgx=^_{0,2}[a-z][a-z0-9_]*$
-
-# Regular expression matching correct argument names
-argument-rgx=^[a-z][a-z0-9_]*$
-
-# Regular expression matching correct class attribute names
-class-attribute-rgx=^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$
-
-# Regular expression matching correct inline iteration names
-inlinevar-rgx=^[a-z][a-z0-9_]*$
-
-# Regular expression matching correct class names
-class-rgx=^_?[A-Z][a-zA-Z0-9]*$
-
-# Regular expression matching correct module names
-module-rgx=^(_?[a-z][a-z0-9_]*|__init__)$
-
-# Regular expression matching correct method names
-method-rgx=(?x)^(?:(?P<exempt>_[a-z0-9_]+__|runTest|setUp|tearDown|setUpTestCase|tearDownTestCase|setupSelf|tearDownClass|setUpClass|(test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|next)|(?P<camel_case>_{0,2}[A-Z][a-zA-Z0-9_]*)|(?P<snake_case>_{0,2}[a-z][a-z0-9_]*))$
-
-# Regular expression which should only match function or class names that do
-# not require a docstring.
-no-docstring-rgx=(__.*__|main|test.*|.*test|.*Test)$
-
-# Minimum line length for functions/classes that require docstrings, shorter
-# ones are exempt.
-docstring-min-length=10
-
-
-[TYPECHECK]
-
-# List of decorators that produce context managers, such as
-# contextlib.contextmanager. Add to this list to register other decorators that
-# produce valid context managers.
-contextmanager-decorators=contextlib.contextmanager,contextlib2.contextmanager
-
-# Tells whether missing members accessed in mixin class should be ignored. A
-# mixin class is detected if its name ends with "mixin" (case insensitive).
-ignore-mixin-members=yes
-
-# List of module names for which member attributes should not be checked
-# (useful for modules/projects where namespaces are manipulated during runtime
-# and thus existing member attributes cannot be deduced by static analysis. It
-# supports qualified module names, as well as Unix pattern matching.
-ignored-modules=
-
-# List of class names for which member attributes should not be checked (useful
-# for classes with dynamically set attributes). This supports the use of
-# qualified names.
-ignored-classes=optparse.Values,thread._local,_thread._local
-
-# List of members which are set dynamically and missed by pylint inference
-# system, and so shouldn't trigger E1101 when accessed. Python regular
-# expressions are accepted.
-generated-members=
-
-
-[FORMAT]
-
-# Maximum number of characters on a single line.
-max-line-length=80
-
-# TODO(https://github.com/PyCQA/pylint/issues/3352): Direct pylint to exempt
-# lines made too long by directives to pytype.
-
-# Regexp for a line that is allowed to be longer than the limit.
-ignore-long-lines=(?x)(
-  ^\s*(\#\ )?<?https?://\S+>?$|
-  ^\s*(from\s+\S+\s+)?import\s+.+$)
-
-# Allow the body of an if to be on the same line as the test if there is no
-# else.
-single-line-if-stmt=yes
-
-# List of optional constructs for which whitespace checking is disabled. `dict-
-# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
-# `trailing-comma` allows a space between comma and closing bracket: (a, ).
-# `empty-line` allows space-only lines.
-no-space-check=
-
-# Maximum number of lines in a module
-max-module-lines=99999
-
-# String used as indentation unit.  The internal Google style guide mandates 2
-# spaces.  Google's externaly-published style guide says 4, consistent with
-# PEP 8.  Here, we use 2 spaces, for conformity with many open-sourced Google
-# projects (like TensorFlow).
-indent-string='  '
-
-# Number of spaces of indent required inside a hanging  or continued line.
-indent-after-paren=4
-
-# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
-expected-line-ending-format=
-
-
-[MISCELLANEOUS]
-
-# List of note tags to take in consideration, separated by a comma.
-notes=TODO
-
-
-[STRING]
-
-# This flag controls whether inconsistent-quotes generates a warning when the
-# character used as a quote delimiter is used inconsistently within a module.
-check-quote-consistency=yes
-
-
-[VARIABLES]
-
-# Tells whether we should check for unused import in __init__ files.
-init-import=no
-
-# A regular expression matching the name of dummy variables (i.e. expectedly
-# not used).
-dummy-variables-rgx=^\*{0,2}(_$|unused_|dummy_)
-
-# List of additional names supposed to be defined in builtins. Remember that
-# you should avoid to define new builtins when possible.
-additional-builtins=
-
-# List of strings which can identify a callback function by name. A callback
-# name must start or end with one of those strings.
-callbacks=cb_,_cb
-
-# List of qualified module names which can have objects that can redefine
-# builtins.
-redefining-builtins-modules=six,six.moves,past.builtins,future.builtins,functools
-
-
-[LOGGING]
-
-# Logging modules to check that the string format arguments are in logging
-# function parameter format
-logging-modules=logging,absl.logging,tensorflow.io.logging
-
-
-[SIMILARITIES]
-
-# Minimum lines number of a similarity.
-min-similarity-lines=4
-
-# Ignore comments when computing similarities.
-ignore-comments=yes
-
-# Ignore docstrings when computing similarities.
-ignore-docstrings=yes
-
-# Ignore imports when computing similarities.
-ignore-imports=no
-
-
-[SPELLING]
-
-# Spelling dictionary name. Available dictionaries: none. To make it working
-# install python-enchant package.
-spelling-dict=
-
-# List of comma separated words that should not be checked.
-spelling-ignore-words=
-
-# A path to a file that contains private dictionary; one word per line.
-spelling-private-dict-file=
-
-# Tells whether to store unknown words to indicated private dictionary in
-# --spelling-private-dict-file option instead of raising a message.
-spelling-store-unknown-words=no
-
-
-[IMPORTS]
-
-# Deprecated modules which should not be used, separated by a comma
-deprecated-modules=regsub,
-                   TERMIOS,
-                   Bastion,
-                   rexec,
-                   sets
-
-# Create a graph of every (i.e. internal and external) dependencies in the
-# given file (report RP0402 must not be disabled)
-import-graph=
-
-# Create a graph of external dependencies in the given file (report RP0402 must
-# not be disabled)
-ext-import-graph=
-
-# Create a graph of internal dependencies in the given file (report RP0402 must
-# not be disabled)
-int-import-graph=
-
-# Force import order to recognize a module as part of the standard
-# compatibility libraries.
-known-standard-library=
-
-# Force import order to recognize a module as part of a third party library.
-known-third-party=enchant, absl
-
-# Analyse import fallback blocks. This can be used to support both Python 2 and
-# 3 compatible code, which means that the block might have code that exists
-# only in one or another interpreter, leading to false positives when analysed.
-analyse-fallback-blocks=no
-
-
-[CLASSES]
-
-# List of method names used to declare (i.e. assign) instance attributes.
-defining-attr-methods=__init__,
-                      __new__,
-                      setUp
-
-# List of member names, which should be excluded from the protected access
-# warning.
-exclude-protected=_asdict,
-                  _fields,
-                  _replace,
-                  _source,
-                  _make
-
-# List of valid names for the first argument in a class method.
-valid-classmethod-first-arg=cls,
-                            class_
-
-# List of valid names for the first argument in a metaclass class method.
-valid-metaclass-classmethod-first-arg=mcs
-
-
-[EXCEPTIONS]
-
-# Exceptions that will emit a warning when being caught. Defaults to
-# "Exception"
-overgeneral-exceptions=StandardError,
-                       Exception,
-                       BaseException

.style.yapf

@@ -1,2 +0,0 @@
-[style]
-based_on_style = chromium

AUTHORS

@@ -1,42 +1,26 @@
 Contributors:
-- Aidan O'Loan (aidanol at gmail dot com)
-- Alan Browning (browning at google dot com)
-- Alexandru Ardelean (ardeleanalex at gmail dot com)
-- Brian Ledger (brianpl at google dot com)
 - Charles Munger (clm at google dot com)
-- Cheng Yi (cyi at google dot com)
 - Christian Duvivier (cduvivier at google dot com)
-- Christopher Degawa (ccom at randomderp dot com)
-- Clement Courbet (courbet at google dot com)
 - Djordje Pesut (djordje dot pesut at imgtec dot com)
-- Frank Barchard (fbarchard at google dot com)
 - Hui Su (huisu at google dot com)
-- Ilya Kurdyukov (jpegqs at gmail dot com)
-- Ingvar Stepanyan (rreverser at google dot com)
 - James Zern (jzern at google dot com)
 - Jan Engelhardt (jengelh at medozas dot de)
-- Jehan (jehan at girinstud dot io)
-- 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)
 - Marcin Kowalczyk (qrczak at google dot com)
 - Martin Olsson (mnemo at minimum dot se)
-- Maryla Ustarroz-Calonge (maryla at google dot com)
 - Mikołaj Zalewski (mikolajz at google dot com)
 - Mislav Bradac (mislavm at google dot com)
 - Nico Weber (thakis at chromium dot org)
 - Noel Chromium (noel at chromium dot org)
-- Oliver Wolff (oliver dot wolff at qt dot io)
-- Owen Rodley (orodley at google dot com)
 - Parag Salasakar (img dot mips1 at gmail dot com)
 - Pascal Massimino (pascal dot massimino at gmail dot com)
 - Paweł Hajdan, Jr (phajdan dot jr at chromium dot org)
 - Pierre Joye (pierre dot php at gmail dot com)
-- Roberto Alanis (alanisbaez at google dot com)
 - Sam Clegg (sbc at chromium dot org)
 - Scott Hancher (seh at google dot com)
 - Scott LaVarnway (slavarnway at google dot com)
@@ -49,8 +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)
-- Wan-Teh Chang (wtc at google dot com)
 - Yang Zhang (yang dot zhang at arm dot com)
-- Yannis Guyon (yguyon at google dot com)
-- Zhi An Ng (zhin at chromium dot org)

Android.mk

@@ -11,47 +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
 
-sharpyuv_srcs := \
-    sharpyuv/sharpyuv.c \
-    sharpyuv/sharpyuv_csp.c \
-    sharpyuv/sharpyuv_dsp.c \
-    sharpyuv/sharpyuv_gamma.c \
-    sharpyuv/sharpyuv_neon.$(NEON) \
-    sharpyuv/sharpyuv_sse2.c \
-
 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 \
@@ -60,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 \
@@ -74,81 +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/lossless_sse41.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 \
@@ -157,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
@@ -183,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
@@ -212,13 +180,12 @@ endif  # ENABLE_SHARED=1
 include $(CLEAR_VARS)
 
 LOCAL_SRC_FILES := \
-    $(sharpyuv_srcs) \
     $(dsp_enc_srcs) \
     $(enc_srcs) \
     $(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
@@ -241,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
@@ -264,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
@@ -281,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,780 +1,151 @@
-#  Copyright (c) 2020 Google LLC.
-#
-#  Use of this source code is governed by a BSD-style license
-#  that can be found in the LICENSE file in the root of the source
-#  tree. An additional intellectual property rights grant can be found
-#  in the file PATENTS.  All contributing project authors may
-#  be found in the AUTHORS file in the root of the source tree.
+cmake_minimum_required(VERSION 2.8.7)
 
-cmake_minimum_required(VERSION 3.7)
-
-if(POLICY CMP0072)
-  cmake_policy(SET CMP0072 NEW)
-endif()
-
-project(WebP C)
+project(libwebp C)
 
 # Options for coder / decoder executables.
-if(BUILD_SHARED_LIBS)
-  set(WEBP_LINK_STATIC_DEFAULT OFF)
-else()
-  set(WEBP_LINK_STATIC_DEFAULT ON)
-endif()
-option(WEBP_LINK_STATIC
-       "Link using static libraries. If OFF, use dynamic libraries."
-       ${WEBP_LINK_STATIC_DEFAULT})
-if(NOT EMSCRIPTEN)
-  # Disable SIMD on Emscripten by default, as it's a new unstable Wasm feature.
-  # Users can still explicitly opt-in to make a SIMD-enabled build.
-  set(WEBP_ENABLE_SIMD_DEFAULT ON)
-endif()
-option(WEBP_ENABLE_SIMD "Enable any SIMD optimization."
-       ${WEBP_ENABLE_SIMD_DEFAULT})
-option(WEBP_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_LIBWEBPMUX "Build the libwebpmux library." ON)
-option(WEBP_BUILD_WEBPMUX "Build the webpmux command line tool." ON)
-option(WEBP_BUILD_EXTRAS "Build extras." ON)
-option(WEBP_BUILD_WEBP_JS "Emscripten build of webp.js." OFF)
-option(WEBP_USE_THREAD "Enable threading support" ON)
-option(WEBP_NEAR_LOSSLESS "Enable near-lossless encoding" ON)
-option(WEBP_ENABLE_SWAP_16BIT_CSP "Enable byte swap for 16 bit colorspaces."
-       OFF)
-set(WEBP_BITTRACE "0" CACHE STRING "Bit trace mode (0=none, 1=bit, 2=bytes)")
-set_property(CACHE WEBP_BITTRACE PROPERTY STRINGS 0 1 2)
-
-if(WEBP_LINK_STATIC)
-  if(WIN32)
-    SET(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
-  else()
-    SET(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
-  endif()
-  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-  # vwebp does not compile on Ubuntu with static libraries so disabling it for
-  # now.
-  set(WEBP_BUILD_VWEBP OFF)
-endif()
-
-# 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_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)
-  set(WEBP_USE_THREAD OFF)
-
-  if(WEBP_ENABLE_SIMD)
-    message("wasm2js does not support SIMD, disabling webp.js generation.")
-  endif()
-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 STRING "Build type: Release, Debug, MinSizeRel or RelWithDebInfo"
-      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)
-
-set(CMAKE_C_VISIBILITY_PRESET hidden)
-
-# ##############################################################################
+################################################################################
 # 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.
-
-# Creates a source file with an unused stub function in $CMAKE_BINARY_DIR and
-# adds it to the specified target. Currently used only with Xcode.
-#
-# See also:
-# https://cmake.org/cmake/help/v3.18/command/add_library.html#object-libraries
-# "Some native build systems (such as Xcode) may not like targets that have
-# only object files, so consider adding at least one real source file to any
-# target that references $<TARGET_OBJECTS:objlib>."
-function(libwebp_add_stub_file TARGET)
-  set(stub_source_dir "${CMAKE_BINARY_DIR}")
-  set(stub_source_file
-      "${stub_source_dir}/libwebp_${TARGET}_stub.c")
-  set(stub_source_code
-      "// Generated file. DO NOT EDIT!\n"
-      "// C source file created for target ${TARGET}.\n"
-      "void libwebp_${TARGET}_stub_function(void)\;\n"
-      "void libwebp_${TARGET}_stub_function(void) {}\n")
-  file(WRITE "${stub_source_file}" ${stub_source_code})
-
-  target_sources(${TARGET} PRIVATE ${stub_source_file})
-endfunction()
-
-parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/sharpyuv "WEBP_SHARPYUV_SRCS"
-                  "")
-add_library(sharpyuv OBJECT ${WEBP_SHARPYUV_SRCS})
-target_include_directories(sharpyuv
-                            PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
-                            ${CMAKE_CURRENT_SOURCE_DIR})
-set_target_properties(
-  sharpyuv
-  PROPERTIES PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/sharpyuv/sharpyuv.h;\
-${CMAKE_CURRENT_SOURCE_DIR}/sharpyuv/sharpyuv_csp.h;\
-${CMAKE_CURRENT_SOURCE_DIR}/src/webp/types.h")
-
-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>)
-if(XCODE)
-  libwebp_add_stub_file(webpdecoder)
-endif()
-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:sharpyuv>
-            $<TARGET_OBJECTS:webpdecode>
-            $<TARGET_OBJECTS:webpdsp>
-            $<TARGET_OBJECTS:webpencode>
-            $<TARGET_OBJECTS:webputils>)
-if(XCODE)
-  libwebp_add_stub_file(webp)
-endif()
+# 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 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-         $<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(sharpyuv
-                      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.
-macro(set_version FILE TARGET_NAME NAME_IN_MAKEFILE)
-  file(READ ${CMAKE_CURRENT_SOURCE_DIR}/src/${FILE} SOURCE_FILE)
-  string(REGEX MATCH
-               "${NAME_IN_MAKEFILE}_la_LDFLAGS[^\n]* -version-info [0-9:]+"
-               TMP
-               ${SOURCE_FILE})
-  string(REGEX MATCH
-               "[0-9:]+"
-               TMP
-               ${TMP})
-  string(REGEX
-         REPLACE ":"
-                 " "
-                 LT_VERSION
-                 ${TMP})
-
-  # See the libtool docs for more information:
-  # https://www.gnu.org/software/libtool/manual/libtool.html#Updating-version-info
-  #
-  # c=<current>, a=<age>, r=<revision>
-  #
-  # libtool generates a .so file as .so.[c-a].a.r, while -version-info c:r:a is
-  # passed to libtool.
-  #
-  # We set FULL = [c-a].a.r and MAJOR = [c-a].
-  separate_arguments(LT_VERSION)
-  list(GET LT_VERSION 0 LT_CURRENT)
-  list(GET LT_VERSION 1 LT_REVISION)
-  list(GET LT_VERSION 2 LT_AGE)
-  math(EXPR LT_CURRENT_MINUS_AGE "${LT_CURRENT} - ${LT_AGE}")
-
-  set_target_properties(
-    ${TARGET_NAME}
-    PROPERTIES VERSION
-               ${LT_CURRENT_MINUS_AGE}.${LT_AGE}.${LT_REVISION}
-               SOVERSION
-               ${LT_CURRENT_MINUS_AGE})
-endmacro()
-set_version(Makefile.am webp webp)
-set_version(Makefile.am webpdecoder webpdecoder)
-set_version(demux/Makefile.am webpdemux webpdemux)
-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(NOT WEBP_BUILD_LIBWEBPMUX)
-  set(WEBP_BUILD_GIF2WEBP OFF)
-  set(WEBP_BUILD_IMG2WEBP OFF)
-  set(WEBP_BUILD_WEBPMUX OFF)
-endif()
-
-if(WEBP_BUILD_GIF2WEBP AND NOT GIF_FOUND)
-  set(WEBP_BUILD_GIF2WEBP OFF)
-endif()
-
-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
-   OR WEBP_BUILD_WEBPMUX
-   OR WEBP_BUILD_WEBPINFO)
+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 STATIC ${EXAMPLEUTIL_SRCS})
-  target_include_directories(
-    exampleutil
-    PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
-
-  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEIOUTILS_SRCS"
-                    "imageio_util_[^ ]*")
-  add_library(imageioutil STATIC ${IMAGEIOUTILS_SRCS})
-  target_link_libraries(imageioutil webp)
-  target_link_libraries(exampleutil imageioutil)
+  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 STATIC ${IMAGEDEC_SRCS})
-  target_link_libraries(imagedec
-                        imageioutil
-                        webpdemux
-                        webp
-                        ${WEBP_DEP_IMG_LIBRARIES})
-
-  # Image-encoding utility library.
-  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/imageio "IMAGEENC_SRCS"
-                    "imageenc_[^ ]*")
-  add_library(imageenc STATIC ${IMAGEENC_SRCS})
-  target_link_libraries(imageenc imageioutil webp)
-
-  set_property(TARGET exampleutil
-                      imageioutil
-                      imagedec
-                      imageenc
-               PROPERTY INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/src
-                        ${CMAKE_CURRENT_BINARY_DIR}/src)
+  set(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_LIBWEBPMUX)
-  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/src/mux "WEBP_MUX_SRCS" "")
-  add_library(webpmux ${WEBP_MUX_SRCS})
-  target_link_libraries(webpmux webp)
-  target_include_directories(webpmux
-                             PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
-                                     ${CMAKE_CURRENT_SOURCE_DIR})
-  set_version(mux/Makefile.am webpmux webpmux)
-  set_target_properties(webpmux
-                        PROPERTIES PUBLIC_HEADER
-                                   "${CMAKE_CURRENT_SOURCE_DIR}/src/webp/mux.h;\
-${CMAKE_CURRENT_SOURCE_DIR}/src/webp/mux_types.h;\
-${CMAKE_CURRENT_SOURCE_DIR}/src/webp/types.h;")
-  list(APPEND INSTALLED_LIBRARIES webpmux)
-  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
-                        webpmux
-                        ${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
-                        webpmux)
-  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_LIBRARY}
-                          imageioutil
-                          webp
-                          webpdemux)
-    target_include_directories(vwebp
-                               PRIVATE ${GLUT_INCLUDE_DIR}
-                                       ${CMAKE_CURRENT_BINARY_DIR}/src
-                                       ${OPENGL_INCLUDE_DIR})
-    install(TARGETS vwebp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-    if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-      check_c_compiler_flag("-Wno-deprecated-declarations" HAS_NO_DEPRECATED)
-      if(HAS_NO_DEPRECATED)
-        target_compile_options(vwebp PRIVATE "-Wno-deprecated-declarations")
-      endif()
-    endif()
-  endif()
-endif()
-
-if(WEBP_BUILD_WEBPINFO)
-  # webpinfo
-  include_directories(${WEBP_DEP_IMG_INCLUDE_DIRS})
-  parse_makefile_am(${CMAKE_CURRENT_SOURCE_DIR}/examples "WEBPINFO_SRCS"
-                    "webpinfo")
-  add_executable(webpinfo ${WEBPINFO_SRCS})
-  target_link_libraries(webpinfo exampleutil imageioutil)
-  target_include_directories(webpinfo
-                             PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src
-                                     ${CMAKE_CURRENT_SOURCE_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_app ${WEBPMUX_SRCS})
-  set_target_properties(webpmux_app PROPERTIES OUTPUT_NAME webpmux)
-  target_link_libraries(webpmux_app exampleutil imageioutil webpmux webp)
-  target_include_directories(webpmux_app
-                             PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
-  install(TARGETS webpmux_app 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")
-
-  # libextras
-  add_library(extras STATIC ${WEBP_EXTRAS_SRCS})
-  target_include_directories(extras
-                             PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
-                             ${CMAKE_CURRENT_SOURCE_DIR}
-                             ${CMAKE_CURRENT_SOURCE_DIR}/src)
-
-  # 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_BINARY_DIR}/src)
-
-  # webp_quality
-  add_executable(webp_quality ${WEBP_QUALITY_SRCS})
-  target_link_libraries(webp_quality exampleutil imagedec extras)
-  target_include_directories(webp_quality
-                             PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
-                                     ${CMAKE_CURRENT_BINARY_DIR})
-
-  # vwebp_sdl
-  find_package(SDL)
-  if(WEBP_BUILD_VWEBP AND 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_BINARY_DIR}
-                                       ${CMAKE_CURRENT_BINARY_DIR}/src
-                                       ${SDL_INCLUDE_DIR})
-    set(WEBP_HAVE_SDL 1)
-    target_compile_definitions(vwebp_sdl PUBLIC WEBP_HAVE_SDL)
-  endif()
-endif()
-
-if(WEBP_BUILD_WEBP_JS)
-  # wasm2js does not support SIMD.
-  if(NOT WEBP_ENABLE_SIMD)
-    # JavaScript version
-    add_executable(webp_js ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
-    target_link_libraries(webp_js webpdecoder SDL)
-    target_include_directories(webp_js PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-    set(WEBP_HAVE_SDL 1)
-    set_target_properties(
-      webp_js
-      PROPERTIES LINK_FLAGS "-s WASM=0 \
-         -s EXPORTED_FUNCTIONS='[\"_WebpToSDL\"]' -s INVOKE_RUN=0 \
-         -s EXPORTED_RUNTIME_METHODS='[\"cwrap\"]'")
-    set_target_properties(webp_js PROPERTIES OUTPUT_NAME webp)
-    target_compile_definitions(webp_js PUBLIC EMSCRIPTEN WEBP_HAVE_SDL)
-  endif()
-
-  # WASM version
-  add_executable(webp_wasm ${CMAKE_CURRENT_SOURCE_DIR}/extras/webp_to_sdl.c)
-  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 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
-                        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
-                        webpdemux
-                        ${WEBP_DEP_GIF_LIBRARIES})
-  target_include_directories(anim_dump PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/src)
-endif()
-
-# Install the different headers and libraries.
-install(TARGETS ${INSTALLED_LIBRARIES}
-        EXPORT ${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()

CONTRIBUTING.md

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

Makefile.am

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

Makefile.vc

@@ -28,16 +28,15 @@ PLATFORM_LDFLAGS = /SAFESEH
 
 NOLOGO     = /nologo
 CCNODBG    = cl.exe $(NOLOGO) /O2 /DNDEBUG
-CCDEBUG    = cl.exe $(NOLOGO) /Od /Zi /D_DEBUG /RTC1
-CFLAGS     = /I. /Isrc $(NOLOGO) /W3 /EHsc /c
+CCDEBUG    = cl.exe $(NOLOGO) /Od /Gm /Zi /D_DEBUG /RTC1
+CFLAGS     = /Isrc $(NOLOGO) /W3 /EHsc /c
 CFLAGS     = $(CFLAGS) /DWIN32 /D_CRT_SECURE_NO_WARNINGS /DWIN32_LEAN_AND_MEAN
-LDFLAGS    = /LARGEADDRESSAWARE /MANIFEST:EMBED /NXCOMPAT /DYNAMICBASE
+LDFLAGS    = /LARGEADDRESSAWARE /MANIFEST /NXCOMPAT /DYNAMICBASE
 LDFLAGS    = $(LDFLAGS) $(PLATFORM_LDFLAGS)
 LNKDLL     = link.exe /DLL $(NOLOGO)
 LNKEXE     = link.exe $(NOLOGO)
 LNKLIB     = lib.exe $(NOLOGO)
-RCNODBG    = rc.exe $(NOLOGO) /l"0x0409"  # 0x409 = U.S. English
-RCDEBUG    = $(RCNODBG) /D_DEBUG
+MT         = mt.exe $(NOLOGO)
 
 !IF "$(ARCH)" == "ARM"
 CFLAGS = $(CFLAGS) /DWINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP /DWEBP_USE_THREAD
@@ -52,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"
@@ -78,10 +82,7 @@ OUTPUT_DIRS = $(DIRBIN) $(DIRINC) $(DIRLIB) \
               $(DIROBJ)\dsp \
               $(DIROBJ)\enc \
               $(DIROBJ)\examples \
-              $(DIROBJ)\extras \
-              $(DIROBJ)\imageio \
               $(DIROBJ)\mux \
-              $(DIROBJ)\sharpyuv \
               $(DIROBJ)\utils \
 
 # Target configuration
@@ -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.
@@ -174,25 +168,17 @@ CFLAGS = $(CFLAGS) /D_UNICODE /DUNICODE
 # A config was provided, so the library can be built.
 #
 
-SHARPYUV_OBJS = \
-    $(DIROBJ)\sharpyuv\sharpyuv.obj \
-    $(DIROBJ)\sharpyuv\sharpyuv_csp.obj \
-    $(DIROBJ)\sharpyuv\sharpyuv_dsp.obj \
-    $(DIROBJ)\sharpyuv\sharpyuv_gamma.obj \
-    $(DIROBJ)\sharpyuv\sharpyuv_neon.obj \
-    $(DIROBJ)\sharpyuv\sharpyuv_sse2.obj \
-
 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 \
@@ -201,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 \
@@ -215,72 +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\lossless_sse41.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 \
@@ -289,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 \
@@ -327,24 +290,24 @@ 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) $(SHARPYUV_OBJS) $(ENC_OBJS) \
-               $(DSP_ENC_OBJS) $(UTILS_ENC_OBJS) $(DLL_OBJS)
+LIBWEBP_OBJS = $(LIBWEBPDECODER_OBJS) $(ENC_OBJS) $(DSP_ENC_OBJS) \
+               $(UTILS_ENC_OBJS) $(DLL_OBJS)
 LIBWEBPMUX_OBJS = $(MUX_OBJS) $(LIBWEBPMUX_OBJS)
 LIBWEBPDEMUX_OBJS = $(DEMUX_OBJS) $(LIBWEBPDEMUX_OBJS)
 
@@ -354,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)
@@ -365,58 +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)
-# EXTRA_OBJS requires private symbols from dsp. Explicitly add those when
-# building libwebp as a dll.
-!IF "$(DLLBUILD)" == "TRUE"
-$(DIRBIN)\webp_quality.exe: $(DSP_DEC_OBJS)
-!ENDIF
-$(DIRBIN)\webp_quality.exe: $(LIBWEBP)
-$(DIRBIN)\webpinfo.exe: $(DIROBJ)\examples\webpinfo.obj
-$(DIRBIN)\webpinfo.exe: $(IMAGEIO_DEC_OBJS)
-$(DIRBIN)\webpinfo.exe: $(EX_UTIL_OBJS) $(IMAGEIO_UTIL_OBJS)
-$(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)
@@ -431,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) $**
@@ -462,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
@@ -486,12 +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\ $<
-{sharpyuv}.c{$(DIROBJ)\sharpyuv}.obj::
-	$(CC) $(CFLAGS) /Fd$(DIROBJ)\sharpyuv\ /Fo$(DIROBJ)\sharpyuv\ $<
 {src\dec}.c{$(DIROBJ)\dec}.obj::
 	$(CC) $(CFLAGS) /Fd$(LIBWEBP_PDBNAME) /Fo$(DIROBJ)\dec\ $<
 {src\demux}.c{$(DIROBJ)\demux}.obj::
@@ -505,16 +419,11 @@ $(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)
-
-{$(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
 
 clean::
 	@-erase /s $(DIROBJ)\*.dll 2> NUL

NEWS

@@ -1,124 +1,3 @@
-- 6/30/2022: version 1.2.3
-  This is a binary compatible release.
-  * security fix for lossless encoder (#565, chromium:1313709)
-  * improved progress granularity in WebPReportProgress() when using lossless
-  * improved precision in Sharp YUV (-sharp_yuv) conversion
-  * many corrections to webp-lossless-bitstream-spec.txt (#551)
-  * crash/leak fixes on error/OOM and other bug fixes (#558, #563, #569, #573)
-
-- 1/11/2022: version 1.2.2
-  This is a binary compatible release.
-  * webpmux: add "-set bgcolor A,R,G,B"
-  * add ARM64 NEON support for MSVC builds (#539)
-  * fix duplicate include error in Xcode when using multiple XCFrameworks in a
-    project (#542)
-  * doc updates and bug fixes (#538, #544, #548, #550)
-
-- 7/20/2021: version 1.2.1
-  This is a binary compatible release.
-  * minor lossless encoder improvements and x86 color conversion speed up
-  * add ARM64 simulator support to xcframeworkbuild.sh (#510)
-  * further security related hardening in libwebp & examples
-    (issues: #497, #508, #518)
-    (chromium: #1196480, #1196773, #1196775, #1196777, #1196778, #1196850)
-    (oss-fuzz: #28658, #28978)
-  * toolchain updates and bug fixes (#498, #501, #502, #504, #505, #506, #509,
-                                     #533)
-  * use more inclusive language within the source (#507)
-
-- 12/23/2020: version 1.2.0
-  * API changes:
-    - libwebp:
-      encode.h: add a qmin / qmax range for quality factor (cwebp adds -qrange)
-  * lossless encoder improvements
-  * SIMD support for Wasm builds
-  * add xcframeworkbuild.sh, supports Mac Catalyst builds
-  * import fuzzers from oss-fuzz & chromium (#409)
-  * webpmux: add an '-set loop <value>' option (#494)
-  * toolchain updates and bug fixes (#449, #463, #470, #475, #477, #478, #479,
-    #488, #491)
-
-- 12/18/2019: version 1.1.0
-  * API changes:
-    - libwebp:
-      WebPMalloc (issue #442)
-    - extras:
-      WebPUnmultiplyARGB
-  * alpha decode fix (issue #439)
-  * toolchain updates and bug fixes
-    (chromium: #1026858, #1027136, #1027409, #1028620, #1028716, #995200)
-    (oss-fuzz: #19430, #19447)
-
-- 7/4/2019: version 1.0.3
-  This is a binary compatible release.
-  * resize fixes for Nx1 sizes and the addition of non-opaque alpha values for
-    odd sizes (issues #418, #434)
-  * lossless encode/decode performance improvements
-  * lossy compression performance improvement at low quality levels with flat
-    content (issue #432)
-  * python swig files updated to support python 3
-  Tool updates:
-    vwebp will now preserve the aspect ratio of images that exceed monitor
-    resolution by scaling the image to fit (issue #433)
-
-- 1/14/2019: version 1.0.2
-  This is a binary compatible release.
-  * (Windows) unicode file support in the tools (linux and mac already had
-    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.

PRESUBMIT.py

@@ -1,245 +0,0 @@
-# Copyright (c) 2021, Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#   * Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-#
-#   * Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in
-#     the documentation and/or other materials provided with the
-#     distribution.
-#
-#   * Neither the name of Google nor the names of its contributors may
-#     be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""Top-level presubmit script for libwebp.
-
-See https://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts for
-details on the presubmit API built into depot_tools.
-"""
-
-import re
-import subprocess2
-
-USE_PYTHON3 = True
-_BASH_INDENTATION = "2"
-_GIT_COMMIT_SUBJECT_LENGTH = 65
-_INCLUDE_BASH_FILES_ONLY = [r".*\.sh$"]
-_INCLUDE_MAN_FILES_ONLY = [r"man/.+\.1$"]
-_INCLUDE_SOURCE_FILES_ONLY = [r".*\.[ch]$"]
-_LIBWEBP_MAX_LINE_LENGTH = 80
-
-
-def _CheckCommitSubjectLength(input_api, output_api):
-  """Ensures commit's subject length is no longer than 65 chars."""
-  name = "git-commit subject"
-  cmd = ["git", "log", "-1", "--pretty=%s"]
-  start = input_api.time.time()
-  proc = subprocess2.Popen(
-      cmd,
-      stderr=subprocess2.PIPE,
-      stdout=subprocess2.PIPE,
-      universal_newlines=True)
-
-  stdout, _ = proc.communicate()
-  duration = input_api.time.time() - start
-
-  if not re.match(r"^Revert",
-                  stdout) and (len(stdout) - 1) > _GIT_COMMIT_SUBJECT_LENGTH:
-    failure_msg = (
-        "The commit subject: %s is too long (%d chars)\n"
-        "Try to keep this to 50 or less (up to 65 is permitted for "
-        "non-reverts).\n"
-        "https://www.git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-"
-        "Project#_commit_guidelines") % (stdout, len(stdout) - 1)
-    return output_api.PresubmitError("%s\n (%4.2fs) failed\n%s" %
-                                     (name, duration, failure_msg))
-
-  return output_api.PresubmitResult("%s\n (%4.2fs) success" % (name, duration))
-
-
-def _CheckDuplicateFiles(input_api, output_api):
-  """Ensures there are not repeated filenames."""
-  all_files = []
-  for f in input_api.change.AllFiles():
-    for include_file in _INCLUDE_SOURCE_FILES_ONLY:
-      if re.match(include_file, f):
-        all_files.append(f)
-        break
-
-  basename_to_path = {}
-  for f in all_files:
-    basename_file = input_api.basename(f)
-    if basename_file in basename_to_path:
-      basename_to_path[basename_file].append(f)
-    else:
-      basename_to_path[basename_file] = [f]
-
-  dupes = []
-  for files in basename_to_path.values():
-    if len(files) > 1:
-      dupes.extend(files)
-
-  if dupes:
-    return output_api.PresubmitError(
-        "Duplicate source files, rebase or rename some to make them unique:\n%s"
-        % dupes)
-  return output_api.PresubmitResult("No duplicates, success\n")
-
-
-def _GetFilesToSkip(input_api):
-  return list(input_api.DEFAULT_FILES_TO_SKIP) + [
-      r"swig/.*\.py$",
-      r"\.pylintrc$",
-  ]
-
-
-def _RunManCmd(input_api, output_api, man_file):
-  """man command wrapper."""
-  cmd = ["man", "--warnings", "-EUTF-8", "-l", "-Tutf8", "-Z", man_file]
-  name = "Check %s file." % man_file
-  start = input_api.time.time()
-  output, _ = subprocess2.communicate(
-      cmd, stdout=None, stderr=subprocess2.PIPE, universal_newlines=True)
-  duration = input_api.time.time() - start
-  if output[1]:
-    return output_api.PresubmitError("%s\n%s (%4.2fs) failed\n%s" %
-                                     (name, " ".join(cmd), duration, output[1]))
-  return output_api.PresubmitResult("%s\n%s (%4.2fs)\n" %
-                                    (name, " ".join(cmd), duration))
-
-
-def _RunShellCheckCmd(input_api, output_api, bash_file):
-  """shellcheck command wrapper."""
-  cmd = ["shellcheck", "-x", "-oall", "-sbash", bash_file]
-  name = "Check %s file." % bash_file
-  start = input_api.time.time()
-  output, rc = subprocess2.communicate(
-      cmd, stdout=None, stderr=subprocess2.PIPE, universal_newlines=True)
-  duration = input_api.time.time() - start
-  if rc == 0:
-    return output_api.PresubmitResult("%s\n%s (%4.2fs)\n" %
-                                      (name, " ".join(cmd), duration))
-  return output_api.PresubmitError("%s\n%s (%4.2fs) failed\n%s" %
-                                   (name, " ".join(cmd), duration, output[1]))
-
-
-def _RunShfmtCheckCmd(input_api, output_api, bash_file):
-  """shfmt command wrapper."""
-  cmd = [
-      "shfmt", "-i", _BASH_INDENTATION, "-bn", "-ci", "-sr", "-kp", "-d",
-      bash_file
-  ]
-  name = "Check %s file." % bash_file
-  start = input_api.time.time()
-  output, rc = subprocess2.communicate(
-      cmd, stdout=None, stderr=subprocess2.PIPE, universal_newlines=True)
-  duration = input_api.time.time() - start
-  if rc == 0:
-    return output_api.PresubmitResult("%s\n%s (%4.2fs)\n" %
-                                      (name, " ".join(cmd), duration))
-  return output_api.PresubmitError("%s\n%s (%4.2fs) failed\n%s" %
-                                   (name, " ".join(cmd), duration, output[1]))
-
-
-def _RunCmdOnCheckedFiles(input_api, output_api, run_cmd, files_to_check):
-  """Ensure that libwebp/ files are clean."""
-  file_filter = lambda x: input_api.FilterSourceFile(
-      x, files_to_check=files_to_check, files_to_skip=None)
-
-  affected_files = input_api.change.AffectedFiles(file_filter=file_filter)
-  results = [
-      run_cmd(input_api, output_api, f.AbsoluteLocalPath())
-      for f in affected_files
-  ]
-  return results
-
-
-def _CommonChecks(input_api, output_api):
-  """Ensures this patch does not have trailing spaces, extra EOLs,
-     or long lines.
-  """
-  results = []
-  results.extend(
-      input_api.canned_checks.CheckChangeHasNoCrAndHasOnlyOneEol(
-          input_api, output_api))
-  results.extend(
-      input_api.canned_checks.CheckChangeHasNoTabs(input_api, output_api))
-  results.extend(
-      input_api.canned_checks.CheckChangeHasNoStrayWhitespace(
-          input_api, output_api))
-  results.append(_CheckCommitSubjectLength(input_api, output_api))
-  results.append(_CheckDuplicateFiles(input_api, output_api))
-
-  source_file_filter = lambda x: input_api.FilterSourceFile(
-      x, files_to_skip=_GetFilesToSkip(input_api))
-  results.extend(
-      input_api.canned_checks.CheckLongLines(
-          input_api,
-          output_api,
-          maxlen=_LIBWEBP_MAX_LINE_LENGTH,
-          source_file_filter=source_file_filter))
-
-  results.extend(
-      input_api.canned_checks.CheckPatchFormatted(
-          input_api,
-          output_api,
-          check_clang_format=False,
-          check_python=True,
-          result_factory=output_api.PresubmitError))
-  results.extend(
-      _RunCmdOnCheckedFiles(input_api, output_api, _RunManCmd,
-                            _INCLUDE_MAN_FILES_ONLY))
-  # Run pylint.
-  results.extend(
-      input_api.canned_checks.RunPylint(
-          input_api,
-          output_api,
-          files_to_skip=_GetFilesToSkip(input_api),
-          pylintrc=".pylintrc",
-          version="2.7"))
-
-  # Binaries shellcheck and shfmt are not installed in depot_tools.
-  # Installation is needed
-  try:
-    subprocess2.communicate(["shellcheck", "--version"])
-    results.extend(
-        _RunCmdOnCheckedFiles(input_api, output_api, _RunShellCheckCmd,
-                              _INCLUDE_BASH_FILES_ONLY))
-    print("shfmt")
-    subprocess2.communicate(["shfmt", "-version"])
-    results.extend(
-        _RunCmdOnCheckedFiles(input_api, output_api, _RunShfmtCheckCmd,
-                              _INCLUDE_BASH_FILES_ONLY))
-  except OSError as os_error:
-    results.append(
-        output_api.PresubmitPromptWarning(
-            "%s\nPlease install missing binaries locally." % os_error.args[0]))
-  return results
-
-
-def CheckChangeOnUpload(input_api, output_api):
-  results = []
-  results.extend(_CommonChecks(input_api, output_api))
-  return results
-
-
-def CheckChangeOnCommit(input_api, output_api):
-  results = []
-  results.extend(_CommonChecks(input_api, output_api))
-  return results

README

@@ -0,0 +1,717 @@
+          __   __  ____  ____  ____
+         /  \\/  \/  _ \/  _ )/  _ \
+         \       /   __/  _  \   __/
+          \__\__/\____/\_____/__/ ____  ___
+                / _/ /    \    \ /  _ \/ _/
+               /  \_/   / /   \ \   __/  \__
+               \____/____/\_____/_____/____/v0.5.2
+
+Description:
+============
+
+WebP codec: library to encode and decode images in WebP format. This package
+contains the library that can be used in other programs to add WebP support,
+as well as the command line tools 'cwebp' and 'dwebp'.
+
+See http://developers.google.com/speed/webp
+
+The latest source tree is available at
+https://chromium.googlesource.com/webm/libwebp
+
+It is released under the same license as the WebM project.
+See http://www.webmproject.org/license/software/ or the
+"COPYING" file for details. An additional intellectual
+property rights grant can be found in the file PATENTS.
+
+Building:
+=========
+
+Windows build:
+--------------
+
+By running:
+
+  nmake /f Makefile.vc CFG=release-static RTLIBCFG=static OBJDIR=output
+
+the directory output\release-static\(x64|x86)\bin will contain the tools
+cwebp.exe and dwebp.exe. The directory output\release-static\(x64|x86)\lib will
+contain the libwebp static library.
+The target architecture (x86/x64) is detected by Makefile.vc from the Visual
+Studio compiler (cl.exe) available in the system path.
+
+Unix build using makefile.unix:
+-------------------------------
+
+On platforms with GNU tools installed (gcc and make), running
+
+  make -f makefile.unix
+
+will build the binaries examples/cwebp and examples/dwebp, along
+with the static library src/libwebp.a. No system-wide installation
+is supplied, as this is a simple alternative to the full installation
+system based on the autoconf tools (see below).
+Please refer to makefile.unix for additional details and customizations.
+
+Using autoconf tools:
+---------------------
+Prerequisites:
+A compiler (e.g., gcc), make, autoconf, automake, libtool.
+On a Debian-like system the following should install everything you need for a
+minimal build:
+$ sudo apt-get install gcc make autoconf automake libtool
+
+When building from git sources, you will need to run autogen.sh to generate the
+configure script.
+
+./configure
+make
+make install
+
+should be all you need to have the following files
+
+/usr/local/include/webp/decode.h
+/usr/local/include/webp/encode.h
+/usr/local/include/webp/types.h
+/usr/local/lib/libwebp.*
+/usr/local/bin/cwebp
+/usr/local/bin/dwebp
+
+installed.
+
+Note: A decode-only library, libwebpdecoder, is available using the
+'--enable-libwebpdecoder' flag. The encode library is built separately and can
+be installed independently using a minor modification in the corresponding
+Makefile.am configure files (see comments there). See './configure --help' for
+more options.
+
+Building for MIPS Linux:
+------------------------
+MIPS Linux toolchain stable available releases can be found at:
+https://community.imgtec.com/developers/mips/tools/codescape-mips-sdk/available-releases/
+
+# Add toolchain to PATH
+export PATH=$PATH:/path/to/toolchain/bin
+
+# 32-bit build for mips32r5 (p5600)
+HOST=mips-mti-linux-gnu
+MIPS_CFLAGS="-O3 -mips32r5 -mabi=32 -mtune=p5600 -mmsa -mfp64 \
+  -msched-weight -mload-store-pairs -fPIE"
+MIPS_LDFLAGS="-mips32r5 -mabi=32 -mmsa -mfp64 -pie"
+
+# 64-bit build for mips64r6 (i6400)
+HOST=mips-img-linux-gnu
+MIPS_CFLAGS="-O3 -mips64r6 -mabi=64 -mtune=i6400 -mmsa -mfp64 \
+  -msched-weight -mload-store-pairs -fPIE"
+MIPS_LDFLAGS="-mips64r6 -mabi=64 -mmsa -mfp64 -pie"
+
+./configure --host=${HOST} --build=`config.guess` \
+  CC="${HOST}-gcc -EL" \
+  CFLAGS="$MIPS_CFLAGS" \
+  LDFLAGS="$MIPS_LDFLAGS"
+make
+make install
+
+CMake:
+------
+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.
+On a Debian-like system the following should install everything you need for a
+minimal build:
+$ sudo apt-get install build-essential cmake
+
+When building from git sources, you will need to run cmake to generate the
+configure script.
+
+mkdir build && cd build && cmake ../
+make
+make install
+
+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).
+
+Gradle:
+-------
+The support for Gradle is minimal: it only helps you compile libwebp, cwebp and
+dwebp and webpmux_example.
+
+Prerequisites:
+A compiler (e.g., gcc with autotools) and gradle.
+On a Debian-like system the following should install everything you need for a
+minimal build:
+$ sudo apt-get install build-essential gradle
+
+When building from git sources, you will need to run the Gradle wrapper with the
+appropriate target, e.g. :
+
+./gradlew buildAllExecutables
+
+SWIG bindings:
+--------------
+
+To generate language bindings from swig/libwebp.swig at least swig-1.3
+(http://www.swig.org) is required.
+
+Currently the following functions are mapped:
+Decode:
+  WebPGetDecoderVersion
+  WebPGetInfo
+  WebPDecodeRGBA
+  WebPDecodeARGB
+  WebPDecodeBGRA
+  WebPDecodeBGR
+  WebPDecodeRGB
+
+Encode:
+  WebPGetEncoderVersion
+  WebPEncodeRGBA
+  WebPEncodeBGRA
+  WebPEncodeRGB
+  WebPEncodeBGR
+  WebPEncodeLosslessRGBA
+  WebPEncodeLosslessBGRA
+  WebPEncodeLosslessRGB
+  WebPEncodeLosslessBGR
+
+See swig/README for more detailed build instructions.
+
+Java bindings:
+
+To build the swig-generated JNI wrapper code at least JDK-1.5 (or equivalent)
+is necessary for enum support. The output is intended to be a shared object /
+DLL that can be loaded via System.loadLibrary("webp_jni").
+
+Python bindings:
+
+To build the swig-generated Python extension code at least Python 2.6 is
+required. Python < 2.6 may build with some minor changes to libwebp.swig or the
+generated code, but is untested.
+
+Encoding tool:
+==============
+
+The examples/ directory contains tools for encoding (cwebp) and
+decoding (dwebp) images.
+
+The easiest use should look like:
+  cwebp input.png -q 80 -o output.webp
+which will convert the input file to a WebP file using a quality factor of 80
+on a 0->100 scale (0 being the lowest quality, 100 being the best. Default
+value is 75).
+You might want to try the -lossless flag too, which will compress the source
+(in RGBA format) without any loss. The -q quality parameter will in this case
+control the amount of processing time spent trying to make the output file as
+small as possible.
+
+A longer list of options is available using the -longhelp command line flag:
+
+> cwebp -longhelp
+Usage:
+ cwebp [-preset <...>] [options] in_file [-o out_file]
+
+If input size (-s) for an image is not specified, it is
+assumed to be a PNG, JPEG, TIFF or WebP file.
+
+Options:
+  -h / -help ............. short help
+  -H / -longhelp ......... long help
+  -q <float> ............. quality factor (0:small..100:big), default=75
+  -alpha_q <int> ......... transparency-compression quality (0..100),
+                           default=100
+  -preset <string> ....... preset setting, one of:
+                            default, photo, picture,
+                            drawing, icon, text
+     -preset must come first, as it overwrites other parameters
+  -z <int> ............... activates lossless preset with given
+                           level in [0:fast, ..., 9:slowest]
+
+  -m <int> ............... compression method (0=fast, 6=slowest), default=4
+  -segments <int> ........ number of segments to use (1..4), default=4
+  -size <int> ............ target size (in bytes)
+  -psnr <float> .......... target PSNR (in dB. typically: 42)
+
+  -s <int> <int> ......... input size (width x height) for YUV
+  -sns <int> ............. spatial noise shaping (0:off, 100:max), default=50
+  -f <int> ............... filter strength (0=off..100), default=60
+  -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
+  -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)
+  -crop <x> <y> <w> <h> .. crop picture with the given rectangle
+  -resize <w> <h> ........ resize picture (after any cropping)
+  -mt .................... use multi-threading if available
+  -low_memory ............ reduce memory usage (slower encoding)
+  -map <int> ............. print map of extra info
+  -print_psnr ............ prints averaged PSNR distortion
+  -print_ssim ............ prints averaged SSIM distortion
+  -print_lsim ............ prints local-similarity distortion
+  -d <file.pgm> .......... dump the compressed output (PGM file)
+  -alpha_method <int> .... transparency-compression method (0..1), default=1
+  -alpha_filter <string> . predictive filtering for alpha plane,
+                           one of: none, fast (default) or best
+  -exact ................. preserve RGB values in transparent area, default=off
+  -blend_alpha <hex> ..... blend colors against background color
+                           expressed as RGB values written in
+                           hexadecimal, e.g. 0xc0e0d0 for red=0xc0
+                           green=0xe0 and blue=0xd0
+  -noalpha ............... discard any transparency information
+  -lossless .............. encode image losslessly, default=off
+  -near_lossless <int> ... use near-lossless image
+                           preprocessing (0..100=off), default=100
+  -hint <string> ......... specify image characteristics hint,
+                           one of: photo, picture or graph
+
+  -metadata <string> ..... comma separated list of metadata to
+                           copy from the input to the output if present.
+                           Valid values: all, none (default), exif, icc, xmp
+
+  -short ................. condense printed message
+  -quiet ................. don't print anything
+  -version ............... print version number and exit
+  -noasm ................. disable all assembly optimizations
+  -v ..................... verbose, e.g. print encoding/decoding times
+  -progress .............. report encoding progress
+
+Experimental Options:
+  -jpeg_like ............. roughly match expected JPEG size
+  -af .................... auto-adjust filter strength
+  -pre <int> ............. pre-processing filter
+
+The main options you might want to try in order to further tune the
+visual quality are:
+ -preset
+ -sns
+ -f
+ -m
+
+Namely:
+  * 'preset' will set up a default encoding configuration targeting a
+     particular type of input. It should appear first in the list of options,
+     so that subsequent options can take effect on top of this preset.
+     Default value is 'default'.
+  * 'sns' will progressively turn on (when going from 0 to 100) some additional
+     visual optimizations (like: segmentation map re-enforcement). This option
+     will balance the bit allocation differently. It tries to take bits from the
+     "easy" parts of the picture and use them in the "difficult" ones instead.
+     Usually, raising the sns value (at fixed -q value) leads to larger files,
+     but with better quality.
+     Typical value is around '75'.
+  * 'f' option directly links to the filtering strength used by the codec's
+     in-loop processing. The higher the value, the smoother the
+     highly-compressed area will look. This is particularly useful when aiming
+     at very small files. Typical values are around 20-30. Note that using the
+     option -strong/-nostrong will change the type of filtering. Use "-f 0" to
+     turn filtering off.
+  * 'm' controls the trade-off between encoding speed and quality. Default is 4.
+     You can try -m 5 or -m 6 to explore more (time-consuming) encoding
+     possibilities. A lower value will result in faster encoding at the expense
+     of quality.
+
+Decoding tool:
+==============
+
+There is a decoding sample in examples/dwebp.c which will take
+a .webp file and decode it to a PNG image file (amongst other formats).
+This is simply to demonstrate the use of the API. You can verify the
+file test.webp decodes to exactly the same as test_ref.ppm by using:
+
+ cd examples
+ ./dwebp test.webp -ppm -o test.ppm
+ diff test.ppm test_ref.ppm
+
+The full list of options is available using -h:
+
+> dwebp -h
+Usage: dwebp in_file [options] [-o out_file]
+
+Decodes the WebP image file to PNG format [Default]
+Use following options to convert into alternate image formats:
+  -pam ......... save the raw RGBA samples as a color PAM
+  -ppm ......... save the raw RGB samples as a color PPM
+  -bmp ......... save as uncompressed BMP format
+  -tiff ........ save as uncompressed TIFF format
+  -pgm ......... save the raw YUV samples as a grayscale PGM
+                 file with IMC4 layout
+  -yuv ......... save the raw YUV samples in flat layout
+
+ Other options are:
+  -version ..... print version number and exit
+  -nofancy ..... don't use the fancy YUV420 upscaler
+  -nofilter .... disable in-loop filtering
+  -nodither .... disable dithering
+  -dither <d> .. dithering strength (in 0..100)
+  -alpha_dither  use alpha-plane dithering if needed
+  -mt .......... use multi-threading
+  -crop <x> <y> <w> <h> ... crop output with the given rectangle
+  -resize <w> <h> ......... scale the output (*after* any cropping)
+  -flip ........ flip the output vertically
+  -alpha ....... only save the alpha plane
+  -incremental . use incremental decoding (useful for tests)
+  -h ........... this help message
+  -v ........... verbose (e.g. print encoding/decoding times)
+  -quiet ....... quiet mode, don't print anything
+  -noasm ....... disable all assembly optimizations
+
+Visualization tool:
+===================
+
+There's a little self-serve visualization tool called 'vwebp' under the
+examples/ directory. It uses OpenGL to open a simple drawing window and show
+a decoded WebP file. It's not yet integrated in the automake build system, but
+you can try to manually compile it using the recommendations below.
+
+Usage: vwebp in_file [options]
+
+Decodes the WebP image file and visualize it using OpenGL
+Options are:
+  -version ..... print version number and exit
+  -noicc ....... don't use the icc profile if present
+  -nofancy ..... don't use the fancy YUV420 upscaler
+  -nofilter .... disable in-loop filtering
+  -dither <int>  dithering strength (0..100), default=50
+  -noalphadither disable alpha plane dithering
+  -mt .......... use multi-threading
+  -info ........ print info
+  -h ........... this help message
+
+Keyboard shortcuts:
+  'c' ................ toggle use of color profile
+  'i' ................ overlay file information
+  'q' / 'Q' / ESC .... quit
+
+Building:
+---------
+
+Prerequisites:
+1) OpenGL & OpenGL Utility Toolkit (GLUT)
+  Linux:
+    $ sudo apt-get install freeglut3-dev mesa-common-dev
+  Mac + XCode:
+    - These libraries should be available in the OpenGL / GLUT frameworks.
+  Windows:
+    http://freeglut.sourceforge.net/index.php#download
+
+2) (Optional) qcms (Quick Color Management System)
+  i. Download qcms from Mozilla / Chromium:
+    http://hg.mozilla.org/mozilla-central/file/0e7639e3bdfb/gfx/qcms
+    http://src.chromium.org/viewvc/chrome/trunk/src/third_party/qcms
+  ii. Build and archive the source files as libqcms.a / qcms.lib
+  iii. Update makefile.unix / Makefile.vc
+    a) Define WEBP_HAVE_QCMS
+    b) Update include / library paths to reference the qcms directory.
+
+Build using makefile.unix / Makefile.vc:
+$ make -f makefile.unix examples/vwebp
+> nmake /f Makefile.vc CFG=release-static \
+    ../obj/x64/release-static/bin/vwebp.exe
+
+Animated GIF conversion:
+========================
+Animated GIF files can be converted to WebP files with animation using the
+gif2webp utility available under examples/. The files can then be viewed using
+vwebp.
+
+Usage:
+ gif2webp [options] gif_file -o webp_file
+Options:
+  -h / -help ............. this help
+  -lossy ................. encode image using lossy compression
+  -mixed ................. for each frame in the image, pick lossy
+                           or lossless compression heuristically
+  -q <float> ............. quality factor (0:small..100:big)
+  -m <int> ............... compression method (0=fast, 6=slowest)
+  -min_size .............. minimize output size (default:off)
+                           lossless compression by default; can be
+                           combined with -q, -m, -lossy or -mixed
+                           options
+  -kmin <int> ............ min distance between key frames
+  -kmax <int> ............ max distance between key frames
+  -f <int> ............... filter strength (0=off..100)
+  -metadata <string> ..... comma separated list of metadata to
+                           copy from the input to the output if present
+                           Valid values: all, none, icc, xmp (default)
+  -mt .................... use multi-threading if available
+
+  -version ............... print version number and exit
+  -v ..................... verbose
+  -quiet ................. don't print anything
+
+Building:
+---------
+With the libgif development files installed, gif2webp can be built using
+makefile.unix:
+$ make -f makefile.unix examples/gif2webp
+
+or using autoconf:
+$ ./configure --enable-everything
+$ make
+
+Comparison of animated images:
+==============================
+Test utility anim_diff under examples/ can be used to compare two animated
+images (each can be GIF or WebP).
+
+Usage: anim_diff <image1> <image2> [options]
+
+Options:
+  -dump_frames <folder> dump decoded frames in PAM format
+  -min_psnr <float> ... minimum per-frame PSNR
+  -raw_comparison ..... if this flag is not used, RGB is
+                        premultiplied before comparison
+
+Building:
+---------
+With the libgif development files and a C++ compiler installed, anim_diff can
+be built using makefile.unix:
+$ make -f makefile.unix examples/anim_diff
+
+or using autoconf:
+$ ./configure --enable-everything
+$ make
+
+Encoding API:
+=============
+
+The main encoding functions are available in the header src/webp/encode.h
+The ready-to-use ones are:
+size_t WebPEncodeRGB(const uint8_t* rgb, int width, int height, int stride,
+                     float quality_factor, uint8_t** output);
+size_t WebPEncodeBGR(const uint8_t* bgr, int width, int height, int stride,
+                     float quality_factor, uint8_t** output);
+size_t WebPEncodeRGBA(const uint8_t* rgba, int width, int height, int stride,
+                      float quality_factor, uint8_t** output);
+size_t WebPEncodeBGRA(const uint8_t* bgra, int width, int height, int stride,
+                      float quality_factor, uint8_t** output);
+
+They will convert raw RGB samples to a WebP data. The only control supplied
+is the quality factor.
+
+There are some variants for using the lossless format:
+
+size_t WebPEncodeLosslessRGB(const uint8_t* rgb, int width, int height,
+                             int stride, uint8_t** output);
+size_t WebPEncodeLosslessBGR(const uint8_t* bgr, int width, int height,
+                             int stride, uint8_t** output);
+size_t WebPEncodeLosslessRGBA(const uint8_t* rgba, int width, int height,
+                              int stride, uint8_t** output);
+size_t WebPEncodeLosslessBGRA(const uint8_t* bgra, int width, int height,
+                              int stride, uint8_t** output);
+
+Of course in this case, no quality factor is needed since the compression
+occurs without loss of the input values, at the expense of larger output sizes.
+
+Advanced encoding API:
+----------------------
+
+A more advanced API is based on the WebPConfig and WebPPicture structures.
+
+WebPConfig contains the encoding settings and is not tied to a particular
+picture.
+WebPPicture contains input data, on which some WebPConfig will be used for
+compression.
+The encoding flow looks like:
+
+-------------------------------------- BEGIN PSEUDO EXAMPLE
+
+#include <webp/encode.h>
+
+  // Setup a config, starting form a preset and tuning some additional
+  // parameters
+  WebPConfig config;
+  if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor))
+    return 0;   // version error
+  }
+  // ... additional tuning
+  config.sns_strength = 90;
+  config.filter_sharpness = 6;
+  config_error = WebPValidateConfig(&config);  // not mandatory, but useful
+
+  // Setup the input data
+  WebPPicture pic;
+  if (!WebPPictureInit(&pic)) {
+    return 0;  // version error
+  }
+  pic.width = width;
+  pic.height = height;
+  // allocated picture of dimension width x height
+  if (!WebPPictureAllocate(&pic)) {
+    return 0;   // memory error
+  }
+  // at this point, 'pic' has been initialized as a container,
+  // and can receive the Y/U/V samples.
+  // Alternatively, one could use ready-made import functions like
+  // WebPPictureImportRGB(), which will take care of memory allocation.
+  // In any case, past this point, one will have to call
+  // WebPPictureFree(&pic) to reclaim memory.
+
+  // Set up a byte-output write method. WebPMemoryWriter, for instance.
+  WebPMemoryWriter wrt;
+  WebPMemoryWriterInit(&wrt);     // initialize 'wrt'
+
+  pic.writer = MyFileWriter;
+  pic.custom_ptr = my_opaque_structure_to_make_MyFileWriter_work;
+
+  // Compress!
+  int ok = WebPEncode(&config, &pic);   // ok = 0 => error occurred!
+  WebPPictureFree(&pic);  // must be called independently of the 'ok' result.
+
+  // output data should have been handled by the writer at that point.
+  // -> compressed data is the memory buffer described by wrt.mem / wrt.size
+
+  // deallocate the memory used by compressed data
+  WebPMemoryWriterClear(&wrt);
+
+-------------------------------------- END PSEUDO EXAMPLE
+
+Decoding API:
+=============
+
+This is mainly just one function to call:
+
+#include "webp/decode.h"
+uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size,
+                       int* width, int* height);
+
+Please have a look at the file src/webp/decode.h for the details.
+There are variants for decoding in BGR/RGBA/ARGB/BGRA order, along with
+decoding to raw Y'CbCr samples. One can also decode the image directly into a
+pre-allocated buffer.
+
+To detect a WebP file and gather the picture's dimensions, the function:
+  int WebPGetInfo(const uint8_t* data, size_t data_size,
+                  int* width, int* height);
+is supplied. No decoding is involved when using it.
+
+Incremental decoding API:
+=========================
+
+In the case when data is being progressively transmitted, pictures can still
+be incrementally decoded using a slightly more complicated API. Decoder state
+is stored into an instance of the WebPIDecoder object. This object can be
+created with the purpose of decoding either RGB or Y'CbCr samples.
+For instance:
+
+  WebPDecBuffer buffer;
+  WebPInitDecBuffer(&buffer);
+  buffer.colorspace = MODE_BGR;
+  ...
+  WebPIDecoder* idec = WebPINewDecoder(&buffer);
+
+As data is made progressively available, this incremental-decoder object
+can be used to decode the picture further. There are two (mutually exclusive)
+ways to pass freshly arrived data:
+
+either by appending the fresh bytes:
+
+  WebPIAppend(idec, fresh_data, size_of_fresh_data);
+
+or by just mentioning the new size of the transmitted data:
+
+  WebPIUpdate(idec, buffer, size_of_transmitted_buffer);
+
+Note that 'buffer' can be modified between each call to WebPIUpdate, in
+particular when the buffer is resized to accommodate larger data.
+
+These functions will return the decoding status: either VP8_STATUS_SUSPENDED if
+decoding is not finished yet or VP8_STATUS_OK when decoding is done. Any other
+status is an error condition.
+
+The 'idec' object must always be released (even upon an error condition) by
+calling: WebPDelete(idec).
+
+To retrieve partially decoded picture samples, one must use the corresponding
+method: WebPIDecGetRGB or WebPIDecGetYUVA.
+It will return the last displayable pixel row.
+
+Lastly, note that decoding can also be performed into a pre-allocated pixel
+buffer. This buffer must be passed when creating a WebPIDecoder, calling
+WebPINewRGB() or WebPINewYUVA().
+
+Please have a look at the src/webp/decode.h header for further details.
+
+Advanced Decoding API:
+======================
+
+WebP decoding supports an advanced API which provides on-the-fly cropping and
+rescaling, something of great usefulness on memory-constrained environments like
+mobile phones. Basically, the memory usage will scale with the output's size,
+not the input's, when one only needs a quick preview or a zoomed in portion of
+an otherwise too-large picture. Some CPU can be saved too, incidentally.
+
+-------------------------------------- BEGIN PSEUDO EXAMPLE
+     // A) Init a configuration object
+     WebPDecoderConfig config;
+     CHECK(WebPInitDecoderConfig(&config));
+
+     // B) optional: retrieve the bitstream's features.
+     CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK);
+
+     // C) Adjust 'config' options, if needed
+     config.options.no_fancy_upsampling = 1;
+     config.options.use_scaling = 1;
+     config.options.scaled_width = scaledWidth();
+     config.options.scaled_height = scaledHeight();
+     // etc.
+
+     // D) Specify 'config' output options for specifying output colorspace.
+     // Optionally the external image decode buffer can also be specified.
+     config.output.colorspace = MODE_BGRA;
+     // Optionally, the config.output can be pointed to an external buffer as
+     // well for decoding the image. This externally supplied memory buffer
+     // should be big enough to store the decoded picture.
+     config.output.u.RGBA.rgba = (uint8_t*) memory_buffer;
+     config.output.u.RGBA.stride = scanline_stride;
+     config.output.u.RGBA.size = total_size_of_the_memory_buffer;
+     config.output.is_external_memory = 1;
+
+     // E) Decode the WebP image. There are two variants w.r.t decoding image.
+     // The first one (E.1) decodes the full image and the second one (E.2) is
+     // used to incrementally decode the image using small input buffers.
+     // Any one of these steps can be used to decode the WebP image.
+
+     // E.1) Decode full image.
+     CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
+
+     // E.2) Decode image incrementally.
+     WebPIDecoder* const idec = WebPIDecode(NULL, NULL, &config);
+     CHECK(idec != NULL);
+     while (bytes_remaining > 0) {
+       VP8StatusCode status = WebPIAppend(idec, input, bytes_read);
+       if (status == VP8_STATUS_OK || status == VP8_STATUS_SUSPENDED) {
+         bytes_remaining -= bytes_read;
+       } else {
+         break;
+       }
+     }
+     WebPIDelete(idec);
+
+     // F) Decoded image is now in config.output (and config.output.u.RGBA).
+     // It can be saved, displayed or otherwise processed.
+
+     // G) Reclaim memory allocated in config's object. It's safe to call
+     // this function even if the memory is external and wasn't allocated
+     // by WebPDecode().
+     WebPFreeDecBuffer(&config.output);
+
+-------------------------------------- END PSEUDO EXAMPLE
+
+Bugs:
+=====
+
+Please report all bugs to the issue tracker:
+    https://bugs.chromium.org/p/webp
+Patches welcome! See this page to get started:
+    http://www.webmproject.org/code/contribute/submitting-patches/
+
+Discuss:
+========
+
+Email: webp-discuss@webmproject.org
+Web: http://groups.google.com/a/webmproject.org/group/webp-discuss

README.md

@@ -1,53 +0,0 @@
-# WebP Codec
-
-```
-      __   __  ____  ____  ____
-     /  \\/  \/  _ \/  _ )/  _ \
-     \       /   __/  _  \   __/
-      \__\__/\____/\_____/__/ ____  ___
-            / _/ /    \    \ /  _ \/ _/
-           /  \_/   / /   \ \   __/  \__
-           \____/____/\_____/_____/____/v1.2.3
-```
-
-WebP codec is a library to encode and decode images in WebP format. This package
-contains the library that can be used in other programs to add WebP support, as
-well as the command line tools 'cwebp' and 'dwebp' to compress and decompress
-images respectively.
-
-See https://developers.google.com/speed/webp for details on the image format.
-
-The latest source tree is available at
-https://chromium.googlesource.com/webm/libwebp
-
-It is released under the same license as the WebM project. See
-https://www.webmproject.org/license/software/ or the "COPYING" file for details.
-An additional intellectual property rights grant can be found in the file
-PATENTS.
-
-## Building
-
-See the [building documentation](doc/building.md).
-
-## Encoding and Decoding Tools
-
-The examples/ directory contains tools to encode and decode images and
-animations, view information about WebP images, and more. See the
-[tools documentation](doc/tools.md).
-
-## APIs
-
-See the [APIs documentation](doc/api.md), and API usage examples in the
-`examples/` directory.
-
-## Bugs
-
-Please report all bugs to the issue tracker: https://bugs.chromium.org/p/webp
-
-Patches welcome! See [how to contribute](CONTRIBUTING.md).
-
-## Discuss
-
-Email: webp-discuss@webmproject.org
-
-Web: https://groups.google.com/a/webmproject.org/group/webp-discuss

README.mux

@@ -0,0 +1,210 @@
+          __   __  ____  ____  ____  __ __  _     __ __
+         /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
+         \       /   __/  _  \   __/      /  /  (_/  /__
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v0.3.2
+
+
+Description:
+============
+
+WebPMux: set of two libraries 'Mux' and 'Demux' for creation, extraction and
+manipulation of an extended format WebP file, which can have features like
+color profile, metadata and animation. Reference command-line tools 'webpmux'
+and 'vwebp' as well as the WebP container specification
+'doc/webp-container-spec.txt' are also provided in this package.
+
+WebP Mux tool:
+==============
+
+The examples/ directory contains a tool (webpmux) for manipulating WebP
+files. The webpmux tool can be used to create an extended format WebP file and
+also to extract or strip relevant data from such a file.
+
+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 -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
+
+GET_OPTIONS:
+ Extract relevant data:
+   icc       get ICC profile
+   exif      get EXIF metadata
+   xmp       get XMP metadata
+   frame n   get nth frame
+
+SET_OPTIONS:
+ Set color profile/metadata:
+   icc  file.icc     set ICC profile
+   exif file.exif    set EXIF metadata
+   xmp  file.xmp     set XMP metadata
+   where:    'file.icc' contains the ICC profile to be set,
+             'file.exif' contains the EXIF metadata to be set
+             'file.xmp' contains the XMP metadata to be set
+
+STRIP_OPTIONS:
+ Strip color profile/metadata:
+   icc       strip ICC profile
+   exif      strip EXIF metadata
+   xmp       strip XMP metadata
+
+FRAME_OPTIONS(i):
+ Create animation:
+   file_i +di+[xi+yi[+mi[bi]]]
+   where:    'file_i' is the i'th animation frame (WebP format),
+             'di' is the pause duration before next frame,
+             'xi','yi' specify the image offset for this frame,
+             'mi' is the dispose method for this frame (0 or 1),
+             'bi' is the blending method for this frame (+b or -b)
+
+LOOP_COUNT:
+ Number of times to repeat the animation.
+ Valid range is 0 to 65535 [Default: 0 (infinite)].
+
+BACKGROUND_COLOR:
+ Background color of the canvas.
+  A,R,G,B
+  where:    'A', 'R', 'G' and 'B' are integers in the range 0 to 255 specifying
+            the Alpha, Red, Green and Blue component values respectively
+            [Default: 255,255,255,255]
+
+INPUT & OUTPUT are in WebP format.
+
+Note: The nature of EXIF, XMP and ICC data is not checked and is assumed to be
+valid.
+
+Visualization tool:
+===================
+
+The examples/ directory also contains a tool (vwebp) for viewing WebP files.
+It decodes the image and visualizes it using OpenGL. See the libwebp README
+for details on building and running this program.
+
+Mux API:
+========
+The Mux API contains methods for adding data to and reading data from WebP
+files. This API currently supports XMP/EXIF metadata, ICC profile and animation.
+Other features may be added in subsequent releases.
+
+Example#1 (pseudo code): Creating a WebPMux object with image data, color
+profile and XMP metadata.
+
+  int copy_data = 0;
+  WebPMux* mux = WebPMuxNew();
+  // ... (Prepare image data).
+  WebPMuxSetImage(mux, &image, copy_data);
+  // ... (Prepare ICC profile data).
+  WebPMuxSetChunk(mux, "ICCP", &icc_profile, copy_data);
+  // ... (Prepare XMP metadata).
+  WebPMuxSetChunk(mux, "XMP ", &xmp, copy_data);
+  // Get data from mux in WebP RIFF format.
+  WebPMuxAssemble(mux, &output_data);
+  WebPMuxDelete(mux);
+  // ... (Consume output_data; e.g. write output_data.bytes to file).
+  WebPDataClear(&output_data);
+
+
+Example#2 (pseudo code): Get image and color profile data from a WebP file.
+
+  int copy_data = 0;
+  // ... (Read data from file).
+  WebPMux* mux = WebPMuxCreate(&data, copy_data);
+  WebPMuxGetFrame(mux, 1, &image);
+  // ... (Consume image; e.g. call WebPDecode() to decode the data).
+  WebPMuxGetChunk(mux, "ICCP", &icc_profile);
+  // ... (Consume icc_profile).
+  WebPMuxDelete(mux);
+  free(data);
+
+
+For a detailed Mux API reference, please refer to the header file
+(src/webp/mux.h).
+
+Demux API:
+==========
+The Demux API enables extraction of images and extended format data from
+WebP files. This API currently supports reading of XMP/EXIF metadata, ICC
+profile and animated images. Other features may be added in subsequent
+releases.
+
+Code example: Demuxing WebP data to extract all the frames, ICC profile
+and EXIF/XMP metadata.
+
+  WebPDemuxer* demux = WebPDemux(&webp_data);
+  uint32_t width = WebPDemuxGetI(demux, WEBP_FF_CANVAS_WIDTH);
+  uint32_t height = WebPDemuxGetI(demux, WEBP_FF_CANVAS_HEIGHT);
+  // ... (Get information about the features present in the WebP file).
+  uint32_t flags = WebPDemuxGetI(demux, WEBP_FF_FORMAT_FLAGS);
+
+  // ... (Iterate over all frames).
+  WebPIterator iter;
+  if (WebPDemuxGetFrame(demux, 1, &iter)) {
+    do {
+      // ... (Consume 'iter'; e.g. Decode 'iter.fragment' with WebPDecode(),
+      // ... and get other frame properties like width, height, offsets etc.
+      // ... see 'struct WebPIterator' below for more info).
+    } while (WebPDemuxNextFrame(&iter));
+    WebPDemuxReleaseIterator(&iter);
+  }
+
+  // ... (Extract metadata).
+  WebPChunkIterator chunk_iter;
+  if (flags & ICCP_FLAG) WebPDemuxGetChunk(demux, "ICCP", 1, &chunk_iter);
+  // ... (Consume the ICC profile in 'chunk_iter.chunk').
+  WebPDemuxReleaseChunkIterator(&chunk_iter);
+  if (flags & EXIF_FLAG) WebPDemuxGetChunk(demux, "EXIF", 1, &chunk_iter);
+  // ... (Consume the EXIF metadata in 'chunk_iter.chunk').
+  WebPDemuxReleaseChunkIterator(&chunk_iter);
+  if (flags & XMP_FLAG) WebPDemuxGetChunk(demux, "XMP ", 1, &chunk_iter);
+  // ... (Consume the XMP metadata in 'chunk_iter.chunk').
+  WebPDemuxReleaseChunkIterator(&chunk_iter);
+  WebPDemuxDelete(demux);
+
+
+For a detailed Demux API reference, please refer to the header file
+(src/webp/demux.h).
+
+AnimEncoder API:
+================
+The AnimEncoder API can be used to create animated WebP images.
+
+Code example:
+
+  WebPAnimEncoderOptions enc_options;
+  WebPAnimEncoderOptionsInit(&enc_options);
+  // ... (Tune 'enc_options' as needed).
+  WebPAnimEncoder* enc = WebPAnimEncoderNew(width, height, &enc_options);
+  while(<there are more frames>) {
+    WebPConfig config;
+    WebPConfigInit(&config);
+    // ... (Tune 'config' as needed).
+    WebPAnimEncoderAdd(enc, frame, duration, &config);
+  }
+  WebPAnimEncoderAssemble(enc, webp_data);
+  WebPAnimEncoderDelete(enc);
+  // ... (Write the 'webp_data' to a file, or re-mux it further).
+
+
+For a detailed AnimEncoder API reference, please refer to the header file
+(src/webp/mux.h).
+
+
+Bugs:
+=====
+
+Please report all bugs to the issue tracker:
+    https://bugs.chromium.org/p/webp
+Patches welcome! See this page to get started:
+    http://www.webmproject.org/code/contribute/submitting-patches/
+
+Discuss:
+========
+
+Email: webp-discuss@webmproject.org
+Web: http://groups.google.com/a/webmproject.org/group/webp-discuss

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) {
@@ -105,30 +95,25 @@ model {
       sources {
         c {
           source {
-            srcDir "sharpyuv"
-            include "sharpyuv.c"
-            include "sharpyuv_csp.c"
-            include "sharpyuv_dsp.c"
-            include "sharpyuv_gamma.c"
-            include "sharpyuv_neon.c"
-            include "sharpyuv_sse2.c"
             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"
@@ -140,93 +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 "lossless_sse41.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"
@@ -278,7 +250,7 @@ model {
       }
     }
 
-    imageio_util(NativeLibrarySpec) {
+    example_dec(NativeLibrarySpec) {
       binaries {
         all {
           lib library: "webp", linkage: "static"
@@ -287,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"
         }
       }
@@ -358,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"
         }
       }
@@ -379,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"
         }
@@ -393,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.
@@ -440,3 +330,8 @@ model {
     }
   }
 }
+
+// Task to generate the wrapper.
+task wrapper(type: Wrapper) {
+  gradleVersion = '2.13'
+}

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 "@CMAKE_INSTALL_FULL_INCLUDEDIR@")
-set(WEBP_INCLUDE_DIRS ${WebP_INCLUDE_DIRS})
-set(WebP_LIBRARIES "@INSTALLED_LIBRARIES@")
-set(WEBP_LIBRARIES "${WebP_LIBRARIES}")

cmake/config.h.cmake

@@ -0,0 +1,141 @@
+# Generate the config.h to compile with specific intrinsics / libs.
+
+## Check for compiler options.
+include(CheckCSourceCompiles)
+check_c_source_compiles("
+    int main(void) {
+      (void)__builtin_bswap16(0);
+      return 0;
+    }
+  "
+  HAVE_BUILTIN_BSWAP16
+)
+check_c_source_compiles("
+    int main(void) {
+      (void)__builtin_bswap32(0);
+      return 0;
+    }
+  "
+  HAVE_BUILTIN_BSWAP32
+)
+check_c_source_compiles("
+    int main(void) {
+      (void)__builtin_bswap64(0);
+      return 0;
+    }
+  "
+  HAVE_BUILTIN_BSWAP64
+)
+
+## Check for libraries.
+find_package(Threads)
+if(Threads_FOUND)
+  if(CMAKE_USE_PTHREADS_INIT)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread")
+  endif()
+  foreach(PTHREAD_TEST HAVE_PTHREAD_PRIO_INHERIT PTHREAD_CREATE_UNDETACHED)
+    check_c_source_compiles("
+        #include <pthread.h>
+        int main (void) {
+          int attr = ${PTHREAD_TEST};
+          return attr;
+        }
+      " ${PTHREAD_TEST}
+    )
+  endforeach()
+  list(APPEND WEBP_DEP_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
+endif()
+set(WEBP_USE_THREAD ${Threads_FOUND})
+
+# TODO: this seems unused, check with autotools.
+set(LT_OBJDIR ".libs/")
+
+# Only useful for vwebp, so useless for now.
+# find_package(OpenGL)
+# set(WEBP_HAVE_GL ${OPENGL_FOUND})
+# set(WEBP_DEP_INCLUDE_DIRS ${WEBP_DEP_INCLUDE_DIRS} ${OPENGL_INCLUDE_DIRS})
+# set(WEBP_DEP_LIBRARIES ${WEBP_DEP_LIBRARIES} ${OPENGL_LIBRARIES})
+
+# Find 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 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_DIRS})
+  endif()
+endforeach()
+
+## 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)
+check_include_files(GLUT/glut.h HAVE_GLUT_GLUT_H)
+check_include_files(GL/glut.h HAVE_GL_GLUT_H)
+check_include_files(inttypes.h HAVE_INTTYPES_H)
+check_include_files(memory.h HAVE_MEMORY_H)
+check_include_files(OpenGL/glut.h HAVE_OPENGL_GLUT_H)
+check_include_files(shlwapi.h HAVE_SHLWAPI_H)
+check_include_files(stdint.h HAVE_STDINT_H)
+check_include_files(stdlib.h HAVE_STDLIB_H)
+check_include_files(strings.h HAVE_STRINGS_H)
+check_include_files(string.h HAVE_STRING_H)
+check_include_files(sys/stat.h HAVE_SYS_STAT_H)
+check_include_files(sys/types.h HAVE_SYS_TYPES_H)
+check_include_files(unistd.h HAVE_UNISTD_H)
+check_include_files(wincodec.h HAVE_WINCODEC_H)
+check_include_files(windows.h HAVE_WINDOWS_H)
+
+# Windows specifics
+if(HAVE_WINCODEC_H)
+  list(APPEND WEBP_DEP_LIBRARIES shlwapi ole32 windowscodecs)
+endif()
+
+## Check for SIMD extensions.
+include(${CMAKE_CURRENT_LIST_DIR}/cpu.cmake)
+
+## 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}
+)
+function(strip_bracket VAR)
+  string(LENGTH ${${VAR}} TMP_LEN)
+  math(EXPR TMP_LEN ${TMP_LEN}-2)
+  string(SUBSTRING ${${VAR}} 1 ${TMP_LEN} TMP_SUB)
+  set(${VAR} ${TMP_SUB} PARENT_SCOPE)
+endfunction()
+
+list(GET CONFIGURE_AC_PACKAGE_INFO 1 PACKAGE_VERSION)
+strip_bracket(PACKAGE_VERSION)
+list(GET CONFIGURE_AC_PACKAGE_INFO 2 PACKAGE_BUGREPORT)
+strip_bracket(PACKAGE_BUGREPORT)
+list(GET CONFIGURE_AC_PACKAGE_INFO 3 PACKAGE_URL)
+strip_bracket(PACKAGE_URL)
+
+# Build more info.
+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
 
@@ -93,12 +90,25 @@
 /* Define to the version of this package. */
 #cmakedefine PACKAGE_VERSION "@PACKAGE_VERSION@"
 
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+#cmakedefine PTHREAD_CREATE_JOINABLE 1
+
 /* Define to 1 if you have the ANSI C header files. */
 #cmakedefine STDC_HEADERS 1
 
 /* 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
 
@@ -108,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
 
@@ -130,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,23 +1,7 @@
-#  Copyright (c) 2021 Google LLC.
-#
-#  Use of this source code is governed by a BSD-style license
-#  that can be found in the LICENSE file in the root of the source
-#  tree. An additional intellectual property rights grant can be found
-#  in the file PATENTS.  All contributing project authors may
-#  be found in the AUTHORS file in the root of the source tree.
+## Check for SIMD extensions.
 
-# Check for SIMD extensions.
-include(CMakePushCheckState)
-
-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) {
@@ -26,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()
@@ -36,26 +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")
-if(MSVC AND CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-  # With at least Visual Studio 12 (2013)+ /arch is not necessary to build SSE2
-  # or SSE4 code unless a lesser /arch is forced. MSVC does not have a SSE4
-  # flag, but an AVX one. Using that with SSE4 code risks generating illegal
-  # instructions when used on machines with SSE4 only. The flags are left for
-  # older (untested) versions to avoid any potential compatibility issues.
-  if(MSVC_VERSION GREATER_EQUAL 1800 AND NOT CMAKE_C_FLAGS MATCHES "/arch:")
-    set(SIMD_ENABLE_FLAGS)
-  else()
-    set(SIMD_ENABLE_FLAGS "/arch:AVX;/arch:SSE2;;;;")
-  endif()
+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 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)
@@ -64,9 +38,10 @@ 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()
@@ -75,40 +50,25 @@ list(LENGTH WEBP_SIMD_FLAGS WEBP_SIMD_FLAGS_LENGTH)
 math(EXPR WEBP_SIMD_FLAGS_RANGE "${WEBP_SIMD_FLAGS_LENGTH} - 1")
 
 foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
-  # With Emscripten 2.0.9 -msimd128 -mfpu=neon will enable NEON, but the
-  # source will fail to compile.
-  if(EMSCRIPTEN AND ${I_SIMD} GREATER_EQUAL 2)
-    break()
-  endif()
-
   list(GET WEBP_SIMD_FLAGS ${I_SIMD} WEBP_SIMD_FLAG)
 
   # First try with no extra flag added as the compiler might have default flags
   # (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)
-    if(EMSCRIPTEN)
-      set(SIMD_COMPILE_FLAG "-msimd128 ${SIMD_COMPILE_FLAG}")
-    endif()
     set(CMAKE_REQUIRED_FLAGS ${SIMD_COMPILE_FLAG})
-    webp_check_compiler_flag(${WEBP_SIMD_FLAG} ${WEBP_ENABLE_SIMD})
+    webp_check_compiler_flag(${WEBP_SIMD_FLAG})
   else()
-    if(MSVC AND SIMD_ENABLE_FLAGS)
-      # The detection for SSE2/SSE4 support under MSVC is based on the compiler
-      # version so e.g., clang-cl will require flags to enable the assembly.
-      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})
     # Memorize the file and flags.
     foreach(FILE ${SIMD_FILES})
@@ -125,38 +85,12 @@ foreach(I_SIMD RANGE ${WEBP_SIMD_FLAGS_RANGE})
       list(GET SIMD_DISABLE_FLAGS ${I_SIMD} SIMD_COMPILE_FLAG)
       include(CheckCCompilerFlag)
       if(SIMD_COMPILE_FLAG)
-        # Between 3.17.0 and 3.18.2 check_cxx_compiler_flag() sets a normal
-        # variable at parent scope while check_cxx_source_compiles() continues
-        # to set an internal cache variable, so we unset both to avoid the
-        # failure / success state persisting between checks. See
-        # https://gitlab.kitware.com/cmake/cmake/-/issues/21207.
-        unset(HAS_COMPILE_FLAG)
         unset(HAS_COMPILE_FLAG CACHE)
         check_c_compiler_flag(${SIMD_COMPILE_FLAG} HAS_COMPILE_FLAG)
-        if(HAS_COMPILE_FLAG)
-          # 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)
-            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()

cmake/deps.cmake

@@ -1,185 +0,0 @@
-#  Copyright (c) 2021 Google LLC.
-#
-#  Use of this source code is governed by a BSD-style license
-#  that can be found in the LICENSE file in the root of the source
-#  tree. An additional intellectual property rights grant can be found
-#  in the file PATENTS.  All contributing project authors may
-#  be found in the AUTHORS file in the root of the source tree.
-
-# Generate the config.h to compile with specific intrinsics / libs.
-
-# Check for compiler options.
-include(CheckCSourceCompiles)
-check_c_source_compiles("
-    int main(void) {
-      (void)__builtin_bswap16(0);
-      return 0;
-    }
-  " HAVE_BUILTIN_BSWAP16)
-check_c_source_compiles("
-    int main(void) {
-      (void)__builtin_bswap32(0);
-      return 0;
-    }
-  " HAVE_BUILTIN_BSWAP32)
-check_c_source_compiles("
-    int main(void) {
-      (void)__builtin_bswap64(0);
-      return 0;
-    }
-  " HAVE_BUILTIN_BSWAP64)
-
-# Check for libraries.
-if(WEBP_USE_THREAD)
-  find_package(Threads)
-  if(Threads_FOUND)
-    # work around cmake bug on QNX (https://cmake.org/Bug/view.php?id=11333)
-    if(CMAKE_USE_PTHREADS_INIT AND NOT CMAKE_SYSTEM_NAME STREQUAL "QNX")
-      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread")
-    endif()
-    check_c_source_compiles("
-        #include <pthread.h>
-        int main (void) {
-          int attr = PTHREAD_PRIO_INHERIT;
-          return attr;
-        }
-      " FLAG_HAVE_PTHREAD_PRIO_INHERIT)
-    set(HAVE_PTHREAD_PRIO_INHERIT ${FLAG_HAVE_PTHREAD_PRIO_INHERIT})
-    list(APPEND WEBP_DEP_LIBRARIES Threads::Threads)
-  endif()
-  set(WEBP_USE_THREAD ${Threads_FOUND})
-endif()
-
-# TODO: this seems unused, check with autotools.
-set(LT_OBJDIR ".libs/")
-
-# Only useful for vwebp, so useless for now.
-find_package(OpenGL)
-set(WEBP_HAVE_GL ${OPENGL_FOUND})
-
-# Check if we need to link to the C math library. We do not look for it as it is
-# not found when cross-compiling, while it is here.
-check_c_source_compiles("
-    #include <math.h>
-    int main(int argc, char** argv) {
-      return (int)pow(argc, 2.5);
-    }
-  " HAVE_MATH_LIBRARY)
-if(NOT HAVE_MATH_LIBRARY)
-  message(STATUS "Adding -lm flag.")
-  list(APPEND WEBP_DEP_LIBRARIES m)
-endif()
-
-# Find the standard image libraries.
-set(WEBP_DEP_IMG_LIBRARIES)
-set(WEBP_DEP_IMG_INCLUDE_DIRS)
-foreach(I_LIB PNG JPEG TIFF)
-  # Disable tiff when compiling in static mode as it is failing on Ubuntu.
-  if(WEBP_LINK_STATIC AND ${I_LIB} STREQUAL "TIFF")
-    message("TIFF is disabled when statically linking.")
-    continue()
-  endif()
-  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})
-  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.
-include(CheckIncludeFiles)
-check_include_files("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS)
-check_include_files(dlfcn.h HAVE_DLFCN_H)
-check_include_files(GLUT/glut.h HAVE_GLUT_GLUT_H)
-check_include_files(GL/glut.h HAVE_GL_GLUT_H)
-check_include_files(inttypes.h HAVE_INTTYPES_H)
-check_include_files(memory.h HAVE_MEMORY_H)
-check_include_files(OpenGL/glut.h HAVE_OPENGL_GLUT_H)
-check_include_files(shlwapi.h HAVE_SHLWAPI_H)
-check_include_files(stdint.h HAVE_STDINT_H)
-check_include_files(stdlib.h HAVE_STDLIB_H)
-check_include_files(strings.h HAVE_STRINGS_H)
-check_include_files(string.h HAVE_STRING_H)
-check_include_files(sys/stat.h HAVE_SYS_STAT_H)
-check_include_files(sys/types.h HAVE_SYS_TYPES_H)
-check_include_files(unistd.h HAVE_UNISTD_H)
-check_include_files(wincodec.h HAVE_WINCODEC_H)
-check_include_files(windows.h HAVE_WINDOWS_H)
-
-# Windows specifics
-if(HAVE_WINCODEC_H)
-  list(APPEND WEBP_DEP_LIBRARIES
-              shlwapi
-              ole32
-              windowscodecs)
-endif()
-
-# Check for SIMD extensions.
-include(${CMAKE_CURRENT_LIST_DIR}/cpu.cmake)
-
-# 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})
-function(strip_bracket VAR)
-  string(LENGTH ${${VAR}} TMP_LEN)
-  math(EXPR TMP_LEN ${TMP_LEN}-2)
-  string(SUBSTRING ${${VAR}}
-                   1
-                   ${TMP_LEN}
-                   TMP_SUB)
-  set(${VAR} ${TMP_SUB} PARENT_SCOPE)
-endfunction()
-
-list(GET CONFIGURE_AC_PACKAGE_INFO 1 PACKAGE_VERSION)
-strip_bracket(PACKAGE_VERSION)
-list(GET CONFIGURE_AC_PACKAGE_INFO 2 PACKAGE_BUGREPORT)
-strip_bracket(PACKAGE_BUGREPORT)
-list(GET CONFIGURE_AC_PACKAGE_INFO 3 PACKAGE_URL)
-strip_bracket(PACKAGE_URL)
-
-# Build more info.
-set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-set(PACKAGE_TARNAME ${PACKAGE_NAME})
-set(VERSION ${PACKAGE_VERSION})

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,6 +1,6 @@
-AC_INIT([libwebp], [1.2.3],
+AC_INIT([libwebp], [0.5.2],
         [https://bugs.chromium.org/p/webp],,
-        [https://developers.google.com/speed/webp])
+        [http://developers.google.com/speed/webp])
 AC_CANONICAL_HOST
 AC_PREREQ([2.60])
 AM_INIT_AUTOMAKE([-Wall foreign subdir-objects])
@@ -9,8 +9,7 @@ dnl === automake >= 1.12 requires this for 'unusual archivers' support.
 dnl === it must occur before LT_INIT (AC_PROG_LIBTOOL).
 m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
 
-dnl === AC_PROG_LIBTOOL is deprecated.
-m4_ifdef([LT_INIT], [LT_INIT], [AC_PROG_LIBTOOL])
+AC_PROG_LIBTOOL
 AC_PROG_SED
 AM_PROG_CC_C_O
 
@@ -28,46 +27,11 @@ AC_ARG_ENABLE([everything],
               AS_HELP_STRING([--enable-everything],
                              [Enable all optional targets. These can still be
                               disabled with --disable-target]),
-              [SET_IF_UNSET([enable_libsharpyuv], [$enableval])
-               SET_IF_UNSET([enable_libwebpdecoder], [$enableval])
+              [SET_IF_UNSET([enable_libwebpdecoder], [$enableval])
                SET_IF_UNSET([enable_libwebpdemux], [$enableval])
                SET_IF_UNSET([enable_libwebpextras], [$enableval])
                SET_IF_UNSET([enable_libwebpmux], [$enableval])])
 
-dnl === Check whether libwebpmux should be built
-AC_MSG_CHECKING(whether libwebpmux is to be built)
-AC_ARG_ENABLE([libwebpmux],
-              AS_HELP_STRING([--disable-libwebpmux],
-                             [Disable libwebpmux @<:@default=no@:>@]),
-              [], [enable_libwebpmux=yes])
-AC_MSG_RESULT(${enable_libwebpmux-no})
-AM_CONDITIONAL([BUILD_MUX], [test "$enable_libwebpmux" = "yes"])
-
-dnl === Check whether libwebpdemux should be built
-AC_MSG_CHECKING(whether libwebpdemux is to be built)
-AC_ARG_ENABLE([libwebpdemux],
-              AS_HELP_STRING([--disable-libwebpdemux],
-                             [Disable libwebpdemux @<:@default=no@:>@]),
-              [], [enable_libwebpdemux=yes])
-AC_MSG_RESULT(${enable_libwebpdemux-no})
-AM_CONDITIONAL([BUILD_DEMUX], [test "$enable_libwebpdemux" = "yes"])
-
-dnl === Check whether decoder library should be built.
-AC_MSG_CHECKING(whether decoder library is to be built)
-AC_ARG_ENABLE([libwebpdecoder],
-              AS_HELP_STRING([--enable-libwebpdecoder],
-                             [Build libwebpdecoder @<:@default=no@:>@]))
-AC_MSG_RESULT(${enable_libwebpdecoder-no})
-AM_CONDITIONAL([BUILD_LIBWEBPDECODER], [test "$enable_libwebpdecoder" = "yes"])
-
-dnl === Check whether libwebpextras should be built
-AC_MSG_CHECKING(whether libwebpextras is to be built)
-AC_ARG_ENABLE([libwebpextras],
-              AS_HELP_STRING([--enable-libwebpextras],
-                             [Build libwebpextras @<:@default=no@:>@]))
-AC_MSG_RESULT(${enable_libwebpextras-no})
-AM_CONDITIONAL([BUILD_EXTRAS], [test "$enable_libwebpextras" = "yes"])
-
 dnl === If --enable-asserts is not defined, define NDEBUG
 
 AC_MSG_CHECKING(whether asserts are enabled)
@@ -103,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])
@@ -112,11 +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-aggressive])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunreachable-code])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused-but-set-variable])
 TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused])
@@ -159,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
@@ -256,16 +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
-      ;;
-    aarch64*|arm64*)
-      AC_DEFINE(WEBP_HAVE_NEON, [1], [Set to 1 if NEON is supported])
-      ;;
-  esac
-  AC_SUBST([NEON_FLAGS])])
+        ;;
+    esac
+    AC_SUBST([NEON_FLAGS])])
 
 dnl === CLEAR_LIBVARS([var_pfx])
 dnl ===   Clears <var_pfx>_{INCLUDES,LIBS}.
@@ -362,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
 
@@ -448,75 +424,10 @@ AS_IF([test "x$enable_gl" != "xno"], [
 
   if test "$glut_support" = "yes" -a "$enable_libwebpdemux" = "yes"; then
     build_vwebp=yes
-  else
-    AC_MSG_NOTICE(
-      m4_normalize([Not building vwebp.
-                    OpenGL libraries and --enable-libwebpdemux are required.]))
   fi
 ])
 AM_CONDITIONAL([BUILD_VWEBP], [test "$build_vwebp" = "yes"])
 
-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_NOTICE([Not building vwebp-sdl. SDL library is required.])
-  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],
@@ -634,39 +545,17 @@ AS_IF([test "x$enable_gif" != "xno"], [
 
   if test "$gif_support" = "yes" -a \
           "$enable_libwebpdemux" = "yes"; then
-    build_anim_diff=yes
-  else
-    AC_MSG_NOTICE(
-      [Not building anim_diff. libgif and --enable-libwebpdemux are required.])
+    build_animdiff=yes
   fi
 
   if test "$gif_support" = "yes" -a \
           "$enable_libwebpmux" = "yes"; then
     build_gif2webp=yes
-  else
-    AC_MSG_NOTICE(
-      [Not building gif2webp. libgif and --enable-libwebpmux are required.])
   fi
 ])
-AM_CONDITIONAL([BUILD_ANIMDIFF], [test "${build_anim_diff}" = "yes"])
+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
-else
-  AC_MSG_NOTICE(
-    m4_normalize([Not building img2webp.
-                  --enable-libwebpdemux & --enable-libwebpmux are required.]))
-fi
-AM_CONDITIONAL([BUILD_IMG2WEBP], [test "${build_img2webp}" = "yes"])
-
-if test "$enable_libwebpmux" = "yes"; then
-  build_webpinfo=yes
-else
-  AC_MSG_NOTICE([Not building webpinfo. --enable-libwebpdemux is required.])
-fi
-AM_CONDITIONAL([BUILD_WEBPINFO], [test "${build_webpinfo}" = "yes"])
-
 dnl === check for WIC support ===
 
 AC_ARG_ENABLE([wic],
@@ -719,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)
@@ -727,38 +629,68 @@ 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)
+AC_ARG_ENABLE([libwebpmux],
+              AS_HELP_STRING([--enable-libwebpmux],
+                             [Build libwebpmux @<:@default=no@:>@]))
+AC_MSG_RESULT(${enable_libwebpmux-no})
+AM_CONDITIONAL([WANT_MUX], [test "$enable_libwebpmux" = "yes"])
+
+dnl === Check whether libwebpdemux should be built
+AC_MSG_CHECKING(whether libwebpdemux is to be built)
+AC_ARG_ENABLE([libwebpdemux],
+              AS_HELP_STRING([--enable-libwebpdemux],
+                             [Build libwebpdemux @<:@default=no@:>@]))
+AC_MSG_RESULT(${enable_libwebpdemux-no})
+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)
+AC_ARG_ENABLE([libwebpdecoder],
+              AS_HELP_STRING([--enable-libwebpdecoder],
+                             [Build libwebpdecoder @<:@default=no@:>@]))
+AC_MSG_RESULT(${enable_libwebpdecoder-no})
+AM_CONDITIONAL([BUILD_LIBWEBPDECODER], [test "$enable_libwebpdecoder" = "yes"])
+
+dnl === Check whether libwebpextras should be built
+AC_MSG_CHECKING(whether libwebpextras is to be built)
+AC_ARG_ENABLE([libwebpextras],
+              AS_HELP_STRING([--enable-libwebpextras],
+                             [Build libwebpextras @<:@default=no@:>@]))
+AC_MSG_RESULT(${enable_libwebpextras-no})
+AM_CONDITIONAL([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 \
-                 sharpyuv/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
@@ -777,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/README

@@ -0,0 +1,29 @@
+
+Generate libwebp Container Spec Docs from Text Source
+=====================================================
+
+HTML generation requires kramdown [1], easily installed as a
+rubygem [2].  Rubygems installation should satisfy dependencies
+automatically.
+
+[1]: http://kramdown.rubyforge.org/
+[2]: http://rubygems.org/
+
+HTML generation can then be done from the project root:
+
+$ kramdown doc/webp-container-spec.txt --template doc/template.html > \
+  doc/output/webp-container-spec.html
+
+kramdown can optionally syntax highlight code blocks, using CodeRay [3],
+a dependency of kramdown that rubygems will install automatically.  The
+following will apply inline CSS styling; an external stylesheet is not
+needed.
+
+$ kramdown doc/webp-lossless-bitstream-spec.txt --template \
+  doc/template.html --coderay-css style --coderay-line-numbers ' ' \
+  --coderay-default-lang c > \
+  doc/output/webp-lossless-bitstream-spec.html
+
+Optimally, use kramdown 0.13.7 or newer if syntax highlighting desired.
+
+[3]: http://coderay.rubychan.de/

doc/api.md

@@ -1,385 +0,0 @@
-# WebP APIs
-
-## Encoding API
-
-The main encoding functions are available in the header src/webp/encode.h
-
-The ready-to-use ones are:
-
-```c
-size_t WebPEncodeRGB(const uint8_t* rgb, int width, int height, int stride,
-                     float quality_factor, uint8_t** output);
-size_t WebPEncodeBGR(const uint8_t* bgr, int width, int height, int stride,
-                     float quality_factor, uint8_t** output);
-size_t WebPEncodeRGBA(const uint8_t* rgba, int width, int height, int stride,
-                      float quality_factor, uint8_t** output);
-size_t WebPEncodeBGRA(const uint8_t* bgra, int width, int height, int stride,
-                      float quality_factor, uint8_t** output);
-```
-
-They will convert raw RGB samples to a WebP data. The only control supplied is
-the quality factor.
-
-There are some variants for using the lossless format:
-
-```c
-size_t WebPEncodeLosslessRGB(const uint8_t* rgb, int width, int height,
-                             int stride, uint8_t** output);
-size_t WebPEncodeLosslessBGR(const uint8_t* bgr, int width, int height,
-                             int stride, uint8_t** output);
-size_t WebPEncodeLosslessRGBA(const uint8_t* rgba, int width, int height,
-                              int stride, uint8_t** output);
-size_t WebPEncodeLosslessBGRA(const uint8_t* bgra, int width, int height,
-                              int stride, uint8_t** output);
-```
-
-Of course in this case, no quality factor is needed since the compression occurs
-without loss of the input values, at the expense of larger output sizes.
-
-### Advanced encoding API
-
-A more advanced API is based on the WebPConfig and WebPPicture structures.
-
-WebPConfig contains the encoding settings and is not tied to a particular
-picture. WebPPicture contains input data, on which some WebPConfig will be used
-for compression. The encoding flow looks like:
-
-```c
-#include <webp/encode.h>
-
-// Setup a config, starting form a preset and tuning some additional
-// parameters
-WebPConfig config;
-if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor)) {
-  return 0;   // version error
-}
-// ... additional tuning
-config.sns_strength = 90;
-config.filter_sharpness = 6;
-config_error = WebPValidateConfig(&config);  // not mandatory, but useful
-
-// Setup the input data
-WebPPicture pic;
-if (!WebPPictureInit(&pic)) {
-  return 0;  // version error
-}
-pic.width = width;
-pic.height = height;
-// allocated picture of dimension width x height
-if (!WebPPictureAlloc(&pic)) {
-  return 0;   // memory error
-}
-// at this point, 'pic' has been initialized as a container,
-// and can receive the Y/U/V samples.
-// Alternatively, one could use ready-made import functions like
-// WebPPictureImportRGB(), which will take care of memory allocation.
-// In any case, past this point, one will have to call
-// WebPPictureFree(&pic) to reclaim memory.
-
-// Set up a byte-output write method. WebPMemoryWriter, for instance.
-WebPMemoryWriter wrt;
-WebPMemoryWriterInit(&wrt);     // initialize 'wrt'
-
-pic.writer = MyFileWriter;
-pic.custom_ptr = my_opaque_structure_to_make_MyFileWriter_work;
-
-// Compress!
-int ok = WebPEncode(&config, &pic);   // ok = 0 => error occurred!
-WebPPictureFree(&pic);  // must be called independently of the 'ok' result.
-
-// output data should have been handled by the writer at that point.
-// -> compressed data is the memory buffer described by wrt.mem / wrt.size
-
-// deallocate the memory used by compressed data
-WebPMemoryWriterClear(&wrt);
-```
-
-## Decoding API
-
-This is mainly just one function to call:
-
-```c
-#include "webp/decode.h"
-uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size,
-                       int* width, int* height);
-```
-
-Please have a look at the file src/webp/decode.h for the details. There are
-variants for decoding in BGR/RGBA/ARGB/BGRA order, along with decoding to raw
-Y'CbCr samples. One can also decode the image directly into a pre-allocated
-buffer.
-
-To detect a WebP file and gather the picture's dimensions, the function:
-
-```c
-int WebPGetInfo(const uint8_t* data, size_t data_size,
-                int* width, int* height);
-```
-
-is supplied. No decoding is involved when using it.
-
-### Incremental decoding API
-
-In the case when data is being progressively transmitted, pictures can still be
-incrementally decoded using a slightly more complicated API. Decoder state is
-stored into an instance of the WebPIDecoder object. This object can be created
-with the purpose of decoding either RGB or Y'CbCr samples. For instance:
-
-```c
-WebPDecBuffer buffer;
-WebPInitDecBuffer(&buffer);
-buffer.colorspace = MODE_BGR;
-...
-WebPIDecoder* idec = WebPINewDecoder(&buffer);
-```
-
-As data is made progressively available, this incremental-decoder object can be
-used to decode the picture further. There are two (mutually exclusive) ways to
-pass freshly arrived data:
-
-either by appending the fresh bytes:
-
-```c
-WebPIAppend(idec, fresh_data, size_of_fresh_data);
-```
-
-or by just mentioning the new size of the transmitted data:
-
-```c
-WebPIUpdate(idec, buffer, size_of_transmitted_buffer);
-```
-
-Note that 'buffer' can be modified between each call to WebPIUpdate, in
-particular when the buffer is resized to accommodate larger data.
-
-These functions will return the decoding status: either VP8_STATUS_SUSPENDED if
-decoding is not finished yet or VP8_STATUS_OK when decoding is done. Any other
-status is an error condition.
-
-The 'idec' object must always be released (even upon an error condition) by
-calling: WebPDelete(idec).
-
-To retrieve partially decoded picture samples, one must use the corresponding
-method: WebPIDecGetRGB or WebPIDecGetYUVA. It will return the last displayable
-pixel row.
-
-Lastly, note that decoding can also be performed into a pre-allocated pixel
-buffer. This buffer must be passed when creating a WebPIDecoder, calling
-WebPINewRGB() or WebPINewYUVA().
-
-Please have a look at the src/webp/decode.h header for further details.
-
-### Advanced Decoding API
-
-WebP decoding supports an advanced API which provides on-the-fly cropping and
-rescaling, something of great usefulness on memory-constrained environments like
-mobile phones. Basically, the memory usage will scale with the output's size,
-not the input's, when one only needs a quick preview or a zoomed in portion of
-an otherwise too-large picture. Some CPU can be saved too, incidentally.
-
-```c
-// A) Init a configuration object
-WebPDecoderConfig config;
-CHECK(WebPInitDecoderConfig(&config));
-
-// B) optional: retrieve the bitstream's features.
-CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK);
-
-// C) Adjust 'config' options, if needed
-config.options.no_fancy_upsampling = 1;
-config.options.use_scaling = 1;
-config.options.scaled_width = scaledWidth();
-config.options.scaled_height = scaledHeight();
-// etc.
-
-// D) Specify 'config' output options for specifying output colorspace.
-// Optionally the external image decode buffer can also be specified.
-config.output.colorspace = MODE_BGRA;
-// Optionally, the config.output can be pointed to an external buffer as
-// well for decoding the image. This externally supplied memory buffer
-// should be big enough to store the decoded picture.
-config.output.u.RGBA.rgba = (uint8_t*) memory_buffer;
-config.output.u.RGBA.stride = scanline_stride;
-config.output.u.RGBA.size = total_size_of_the_memory_buffer;
-config.output.is_external_memory = 1;
-
-// E) Decode the WebP image. There are two variants w.r.t decoding image.
-// The first one (E.1) decodes the full image and the second one (E.2) is
-// used to incrementally decode the image using small input buffers.
-// Any one of these steps can be used to decode the WebP image.
-
-// E.1) Decode full image.
-CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
-
-// E.2) Decode image incrementally.
-WebPIDecoder* const idec = WebPIDecode(NULL, NULL, &config);
-CHECK(idec != NULL);
-while (bytes_remaining > 0) {
-  VP8StatusCode status = WebPIAppend(idec, input, bytes_read);
-  if (status == VP8_STATUS_OK || status == VP8_STATUS_SUSPENDED) {
-    bytes_remaining -= bytes_read;
-  } else {
-    break;
-  }
-}
-WebPIDelete(idec);
-
-// F) Decoded image is now in config.output (and config.output.u.RGBA).
-// It can be saved, displayed or otherwise processed.
-
-// G) Reclaim memory allocated in config's object. It's safe to call
-// this function even if the memory is external and wasn't allocated
-// by WebPDecode().
-WebPFreeDecBuffer(&config.output);
-```
-
-## Webp Mux
-
-WebPMux is a set of two libraries 'Mux' and 'Demux' for creation, extraction and
-manipulation of an extended format WebP file, which can have features like color
-profile, metadata and animation. Reference command-line tools `webpmux` and
-`vwebp` as well as the WebP container specification
-'doc/webp-container-spec.txt' are also provided in this package, see the
-[tools documentation](tools.md).
-
-### Mux API
-
-The Mux API contains methods for adding data to and reading data from WebP
-files. This API currently supports XMP/EXIF metadata, ICC profile and animation.
-Other features may be added in subsequent releases.
-
-Example#1 (pseudo code): Creating a WebPMux object with image data, color
-profile and XMP metadata.
-
-```c
-int copy_data = 0;
-WebPMux* mux = WebPMuxNew();
-// ... (Prepare image data).
-WebPMuxSetImage(mux, &image, copy_data);
-// ... (Prepare ICC profile data).
-WebPMuxSetChunk(mux, "ICCP", &icc_profile, copy_data);
-// ... (Prepare XMP metadata).
-WebPMuxSetChunk(mux, "XMP ", &xmp, copy_data);
-// Get data from mux in WebP RIFF format.
-WebPMuxAssemble(mux, &output_data);
-WebPMuxDelete(mux);
-// ... (Consume output_data; e.g. write output_data.bytes to file).
-WebPDataClear(&output_data);
-```
-
-Example#2 (pseudo code): Get image and color profile data from a WebP file.
-
-```c
-int copy_data = 0;
-// ... (Read data from file).
-WebPMux* mux = WebPMuxCreate(&data, copy_data);
-WebPMuxGetFrame(mux, 1, &image);
-// ... (Consume image; e.g. call WebPDecode() to decode the data).
-WebPMuxGetChunk(mux, "ICCP", &icc_profile);
-// ... (Consume icc_profile).
-WebPMuxDelete(mux);
-free(data);
-```
-
-For a detailed Mux API reference, please refer to the header file
-(src/webp/mux.h).
-
-### Demux API
-
-The Demux API enables extraction of images and extended format data from WebP
-files. This API currently supports reading of XMP/EXIF metadata, ICC profile and
-animated images. Other features may be added in subsequent releases.
-
-Code example: Demuxing WebP data to extract all the frames, ICC profile and
-EXIF/XMP metadata.
-
-```c
-WebPDemuxer* demux = WebPDemux(&webp_data);
-uint32_t width = WebPDemuxGetI(demux, WEBP_FF_CANVAS_WIDTH);
-uint32_t height = WebPDemuxGetI(demux, WEBP_FF_CANVAS_HEIGHT);
-// ... (Get information about the features present in the WebP file).
-uint32_t flags = WebPDemuxGetI(demux, WEBP_FF_FORMAT_FLAGS);
-
-// ... (Iterate over all frames).
-WebPIterator iter;
-if (WebPDemuxGetFrame(demux, 1, &iter)) {
-  do {
-    // ... (Consume 'iter'; e.g. Decode 'iter.fragment' with WebPDecode(),
-    // ... and get other frame properties like width, height, offsets etc.
-    // ... see 'struct WebPIterator' below for more info).
-  } while (WebPDemuxNextFrame(&iter));
-  WebPDemuxReleaseIterator(&iter);
-}
-
-// ... (Extract metadata).
-WebPChunkIterator chunk_iter;
-if (flags & ICCP_FLAG) WebPDemuxGetChunk(demux, "ICCP", 1, &chunk_iter);
-// ... (Consume the ICC profile in 'chunk_iter.chunk').
-WebPDemuxReleaseChunkIterator(&chunk_iter);
-if (flags & EXIF_FLAG) WebPDemuxGetChunk(demux, "EXIF", 1, &chunk_iter);
-// ... (Consume the EXIF metadata in 'chunk_iter.chunk').
-WebPDemuxReleaseChunkIterator(&chunk_iter);
-if (flags & XMP_FLAG) WebPDemuxGetChunk(demux, "XMP ", 1, &chunk_iter);
-// ... (Consume the XMP metadata in 'chunk_iter.chunk').
-WebPDemuxReleaseChunkIterator(&chunk_iter);
-WebPDemuxDelete(demux);
-```
-
-For a detailed Demux API reference, please refer to the header file
-(src/webp/demux.h).
-
-## AnimEncoder API
-
-The AnimEncoder API can be used to create animated WebP images.
-
-Code example:
-
-```c
-WebPAnimEncoderOptions enc_options;
-WebPAnimEncoderOptionsInit(&enc_options);
-// ... (Tune 'enc_options' as needed).
-WebPAnimEncoder* enc = WebPAnimEncoderNew(width, height, &enc_options);
-while(<there are more frames>) {
-  WebPConfig config;
-  WebPConfigInit(&config);
-  // ... (Tune 'config' as needed).
-  WebPAnimEncoderAdd(enc, frame, duration, &config);
-}
-WebPAnimEncoderAssemble(enc, webp_data);
-WebPAnimEncoderDelete(enc);
-// ... (Write the 'webp_data' to a file, or re-mux it further).
-```
-
-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:
-
-```c
-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).

doc/building.md

@@ -1,213 +0,0 @@
-# Building
-
-## Windows build
-
-By running:
-
-```batch
-nmake /f Makefile.vc CFG=release-static RTLIBCFG=static OBJDIR=output
-```
-
-the directory `output\release-static\(x64|x86)\bin` will contain the tools
-cwebp.exe and dwebp.exe. The directory `output\release-static\(x64|x86)\lib`
-will contain the libwebp static library. The target architecture (x86/x64) is
-detected by Makefile.vc from the Visual Studio compiler (cl.exe) available in
-the system path.
-
-## Unix build using makefile.unix
-
-On platforms with GNU tools installed (gcc and make), running
-
-```shell
-make -f makefile.unix
-```
-
-will build the binaries examples/cwebp and examples/dwebp, along with the static
-library src/libwebp.a. No system-wide installation is supplied, as this is a
-simple alternative to the full installation system based on the autoconf tools
-(see below). Please refer to makefile.unix for additional details and
-customizations.
-
-## Using autoconf tools
-
-Prerequisites: a compiler (e.g., gcc), make, autoconf, automake, libtool.
-
-On a Debian-like system the following should install everything you need for a
-minimal build:
-
-```shell
-$ sudo apt-get install gcc make autoconf automake libtool
-```
-
-When building from git sources, you will need to run autogen.sh to generate the
-configure script.
-
-```shell
-./configure
-make
-make install
-```
-
-should be all you need to have the following files
-
-```
-/usr/local/include/webp/decode.h
-/usr/local/include/webp/encode.h
-/usr/local/include/webp/types.h
-/usr/local/lib/libwebp.*
-/usr/local/bin/cwebp
-/usr/local/bin/dwebp
-```
-
-installed.
-
-Note: A decode-only library, libwebpdecoder, is available using the
-`--enable-libwebpdecoder` flag. The encode library is built separately and can
-be installed independently using a minor modification in the corresponding
-Makefile.am configure files (see comments there). See `./configure --help` for
-more options.
-
-## Building for MIPS Linux
-
-MIPS Linux toolchain stable available releases can be found at:
-https://community.imgtec.com/developers/mips/tools/codescape-mips-sdk/available-releases/
-
-```shell
-# Add toolchain to PATH
-export PATH=$PATH:/path/to/toolchain/bin
-
-# 32-bit build for mips32r5 (p5600)
-HOST=mips-mti-linux-gnu
-MIPS_CFLAGS="-O3 -mips32r5 -mabi=32 -mtune=p5600 -mmsa -mfp64 \
-  -msched-weight -mload-store-pairs -fPIE"
-MIPS_LDFLAGS="-mips32r5 -mabi=32 -mmsa -mfp64 -pie"
-
-# 64-bit build for mips64r6 (i6400)
-HOST=mips-img-linux-gnu
-MIPS_CFLAGS="-O3 -mips64r6 -mabi=64 -mtune=i6400 -mmsa -mfp64 \
-  -msched-weight -mload-store-pairs -fPIE"
-MIPS_LDFLAGS="-mips64r6 -mabi=64 -mmsa -mfp64 -pie"
-
-./configure --host=${HOST} --build=`config.guess` \
-  CC="${HOST}-gcc -EL" \
-  CFLAGS="$MIPS_CFLAGS" \
-  LDFLAGS="$MIPS_LDFLAGS"
-make
-make install
-```
-
-## CMake
-
-With CMake, you can compile libwebp, cwebp, dwebp, gif2webp, img2webp, webpinfo
-and the JS bindings.
-
-Prerequisites: a compiler (e.g., gcc with autotools) and CMake.
-
-On a Debian-like system the following should install everything you need for a
-minimal build:
-
-```shell
-$ sudo apt-get install build-essential cmake
-```
-
-When building from git sources, you will need to run cmake to generate the
-makefiles.
-
-```shell
-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.:
-
-```shell
-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:
-
-```cmake
-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
-dwebp and webpmux_example.
-
-Prerequisites: a compiler (e.g., gcc with autotools) and gradle.
-
-On a Debian-like system the following should install everything you need for a
-minimal build:
-
-```shell
-$ sudo apt-get install build-essential gradle
-```
-
-When building from git sources, you will need to run the Gradle wrapper with the
-appropriate target, e.g. :
-
-```shell
-./gradlew buildAllExecutables
-```
-
-## SWIG bindings
-
-To generate language bindings from swig/libwebp.swig at least swig-1.3
-(http://www.swig.org) is required.
-
-Currently the following functions are mapped:
-
-Decode:
-
-```
-WebPGetDecoderVersion
-WebPGetInfo
-WebPDecodeRGBA
-WebPDecodeARGB
-WebPDecodeBGRA
-WebPDecodeBGR
-WebPDecodeRGB
-```
-
-Encode:
-
-```
-WebPGetEncoderVersion
-WebPEncodeRGBA
-WebPEncodeBGRA
-WebPEncodeRGB
-WebPEncodeBGR
-WebPEncodeLosslessRGBA
-WebPEncodeLosslessBGRA
-WebPEncodeLosslessRGB
-WebPEncodeLosslessBGR
-```
-
-See also the [swig documentation](../swig/README.md) for more detailed build
-instructions and usage examples.
-
-### Java bindings
-
-To build the swig-generated JNI wrapper code at least JDK-1.5 (or equivalent) is
-necessary for enum support. The output is intended to be a shared object / DLL
-that can be loaded via `System.loadLibrary("webp_jni")`.
-
-### Python bindings
-
-To build the swig-generated Python extension code at least Python 2.6 is
-required. Python < 2.6 may build with some minor changes to libwebp.swig or the
-generated code, but is untested.
-
-## Javascript decoder
-
-Libwebp can be compiled into a JavaScript decoder using Emscripten and CMake.
-See the [corresponding documentation](../README.md)

doc/specs_generation.md

@@ -1,26 +0,0 @@
-# Generate libwebp Container Spec Docs from Text Source
-
-HTML generation requires [kramdown](https://kramdown.gettalong.org/), easily
-installed as a [rubygem](https://rubygems.org/). Rubygems installation should
-satisfy dependencies automatically.
-
-HTML generation can then be done from the project root:
-
-```shell
-$ kramdown doc/webp-container-spec.txt --template doc/template.html > \
-  doc/output/webp-container-spec.html
-```
-
-kramdown can optionally syntax highlight code blocks, using
-[CodeRay](https://github.com/rubychan/coderay), a dependency of kramdown that
-rubygems will install automatically. The following will apply inline CSS
-styling; an external stylesheet is not needed.
-
-```shell
-$ kramdown doc/webp-lossless-bitstream-spec.txt --template \
-  doc/template.html --coderay-css style --coderay-line-numbers ' ' \
-  --coderay-default-lang c > \
-  doc/output/webp-lossless-bitstream-spec.html
-```
-
-Optimally, use kramdown 0.13.7 or newer if syntax highlighting desired.

doc/tools.md

@@ -1,512 +0,0 @@
-# WebP tools
-
-## Encoding tool
-
-The examples/ directory contains tools for encoding (cwebp) and decoding (dwebp)
-images.
-
-The easiest use should look like:
-
-```shell
-cwebp input.png -q 80 -o output.webp
-```
-
-which will convert the input file to a WebP file using a quality factor of 80 on
-a 0->100 scale (0 being the lowest quality, 100 being the best. Default value is
-75).
-
-You might want to try the `-lossless` flag too, which will compress the source
-(in RGBA format) without any loss. The `-q` quality parameter will in this case
-control the amount of processing time spent trying to make the output file as
-small as possible.
-
-A longer list of options is available using the `-longhelp` command line flag:
-
-```shell
-> cwebp -longhelp
-Usage:
- cwebp [-preset <...>] [options] in_file [-o out_file]
-```
-
-If input size (-s) for an image is not specified, it is assumed to be a PNG,
-JPEG, TIFF or WebP file. Note: Animated PNG and WebP files are not supported.
-
-Options:
-
-```
--h / -help ............. short help
--H / -longhelp ......... long help
--q <float> ............. quality factor (0:small..100:big), default=75
--alpha_q <int> ......... transparency-compression quality (0..100),
-                         default=100
--preset <string> ....... preset setting, one of:
-                          default, photo, picture,
-                          drawing, icon, text
-   -preset must come first, as it overwrites other parameters
--z <int> ............... activates lossless preset with given
-                         level in [0:fast, ..., 9:slowest]
-
--m <int> ............... compression method (0=fast, 6=slowest), default=4
--segments <int> ........ number of segments to use (1..4), default=4
--size <int> ............ target size (in bytes)
--psnr <float> .......... target PSNR (in dB. typically: 42)
-
--s <int> <int> ......... input size (width x height) for YUV
--sns <int> ............. spatial noise shaping (0:off, 100:max), default=50
--f <int> ............... filter strength (0=off..100), default=60
--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)
--qrange <min> <max> .... specifies the permissible quality range
-                         (default: 0 100)
--crop <x> <y> <w> <h> .. crop picture with the given rectangle
--resize <w> <h> ........ resize picture (*after* any cropping)
--mt .................... use multi-threading if available
--low_memory ............ reduce memory usage (slower encoding)
--map <int> ............. print map of extra info
--print_psnr ............ prints averaged PSNR distortion
--print_ssim ............ prints averaged SSIM distortion
--print_lsim ............ prints local-similarity distortion
--d <file.pgm> .......... dump the compressed output (PGM file)
--alpha_method <int> .... transparency-compression method (0..1), default=1
--alpha_filter <string> . predictive filtering for alpha plane,
-                         one of: none, fast (default) or best
--exact ................. preserve RGB values in transparent area, default=off
--blend_alpha <hex> ..... blend colors against background color
-                         expressed as RGB values written in
-                         hexadecimal, e.g. 0xc0e0d0 for red=0xc0
-                         green=0xe0 and blue=0xd0
--noalpha ............... discard any transparency information
--lossless .............. encode image losslessly, default=off
--near_lossless <int> ... use near-lossless image
-                         preprocessing (0..100=off), default=100
--hint <string> ......... specify image characteristics hint,
-                         one of: photo, picture or graph
-
--metadata <string> ..... comma separated list of metadata to
-                         copy from the input to the output if present.
-                         Valid values: all, none (default), exif, icc, xmp
-
--short ................. condense printed message
--quiet ................. don't print anything
--version ............... print version number and exit
--noasm ................. disable all assembly optimizations
--v ..................... verbose, e.g. print encoding/decoding times
--progress .............. report encoding progress
-```
-
-Experimental Options:
-
-```
--jpeg_like ............. roughly match expected JPEG size
--af .................... auto-adjust filter strength
--pre <int> ............. pre-processing filter
-```
-
-The main options you might want to try in order to further tune the visual
-quality are:
-
--preset -sns -f -m
-
-Namely:
-
-*   `preset` will set up a default encoding configuration targeting a particular
-    type of input. It should appear first in the list of options, so that
-    subsequent options can take effect on top of this preset. Default value is
-    'default'.
-*   `sns` will progressively turn on (when going from 0 to 100) some additional
-    visual optimizations (like: segmentation map re-enforcement). This option
-    will balance the bit allocation differently. It tries to take bits from the
-    "easy" parts of the picture and use them in the "difficult" ones instead.
-    Usually, raising the sns value (at fixed -q value) leads to larger files,
-    but with better quality. Typical value is around '75'.
-*   `f` option directly links to the filtering strength used by the codec's
-    in-loop processing. The higher the value, the smoother the highly-compressed
-    area will look. This is particularly useful when aiming at very small files.
-    Typical values are around 20-30. Note that using the option
-    -strong/-nostrong will change the type of filtering. Use "-f 0" to turn
-    filtering off.
-*   `m` controls the trade-off between encoding speed and quality. Default is 4.
-    You can try -m 5 or -m 6 to explore more (time-consuming) encoding
-    possibilities. A lower value will result in faster encoding at the expense
-    of quality.
-
-## Decoding tool
-
-There is a decoding sample in examples/dwebp.c which will take a .webp file and
-decode it to a PNG image file (amongst other formats). This is simply to
-demonstrate the use of the API. You can verify the file test.webp decodes to
-exactly the same as test_ref.ppm by using:
-
-```shell
-cd examples
-./dwebp test.webp -ppm -o test.ppm
-diff test.ppm test_ref.ppm
-```
-
-The full list of options is available using -h:
-
-```shell
-> dwebp -h
-Usage: dwebp in_file [options] [-o out_file]
-```
-
-Decodes the WebP image file to PNG format [Default]. Note: Animated WebP files
-are not supported.
-
-Use following options to convert into alternate image formats:
-
-```
--pam ......... save the raw RGBA samples as a color PAM
--ppm ......... save the raw RGB samples as a color PPM
--bmp ......... save as uncompressed BMP format
--tiff ........ save as uncompressed TIFF format
--pgm ......... save the raw YUV samples as a grayscale PGM
-               file with IMC4 layout
--yuv ......... save the raw YUV samples in flat layout
-```
-
-Other options are:
-
-```
--version ..... print version number and exit
--nofancy ..... don't use the fancy YUV420 upscaler
--nofilter .... disable in-loop filtering
--nodither .... disable dithering
--dither <d> .. dithering strength (in 0..100)
--alpha_dither  use alpha-plane dithering if needed
--mt .......... use multi-threading
--crop <x> <y> <w> <h> ... crop output with the given rectangle
--resize <w> <h> ......... resize output (*after* any cropping)
--flip ........ flip the output vertically
--alpha ....... only save the alpha plane
--incremental . use incremental decoding (useful for tests)
--h ........... this help message
--v ........... verbose (e.g. print encoding/decoding times)
--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:
-
-```shell
-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
-
-There's a little self-serve visualization tool called 'vwebp' under the
-examples/ directory. It uses OpenGL to open a simple drawing window and show a
-decoded WebP file. It's not yet integrated in the automake build system, but you
-can try to manually compile it using the recommendations below.
-
-Usage:
-
-```shell
-vwebp in_file [options]
-```
-
-Decodes the WebP image file and visualize it using OpenGL
-
-Options are:
-
-```
--version ..... print version number and exit
--noicc ....... don't use the icc profile if present
--nofancy ..... don't use the fancy YUV420 upscaler
--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
-
-Prerequisites:
-
-1.  OpenGL & OpenGL Utility Toolkit (GLUT)
-
-    Linux: `sudo apt-get install freeglut3-dev mesa-common-dev`
-
-    Mac + Xcode: These libraries should be available in the OpenGL / GLUT
-    frameworks.
-
-    Windows: http://freeglut.sourceforge.net/index.php#download
-
-2.  (Optional) qcms (Quick Color Management System)
-
-    1.  Download qcms from Mozilla / Chromium:
-        https://hg.mozilla.org/mozilla-central/file/0e7639e3bdfb/gfx/qcms
-        https://source.chromium.org/chromium/chromium/src/+/main:third_party/qcms/;drc=d4a2f8e1ed461d8fc05ed88d1ae2dc94c9773825
-    2.  Build and archive the source files as libqcms.a / qcms.lib
-    3.  Update makefile.unix / Makefile.vc
-        1.  Define WEBP_HAVE_QCMS
-        2.  Update include / library paths to reference the qcms directory.
-
-Build using makefile.unix / Makefile.vc:
-
-```shell
-$ 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:
-
-```shell
-img2webp [file_options] [[frame_options] frame_file]...
-```
-
-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
-gif2webp utility available under examples/. The files can then be viewed using
-vwebp.
-
-Usage:
-
-```shell
-gif2webp [options] gif_file -o webp_file
-```
-
-Options:
-
-```
--h / -help ............. this help
--lossy ................. encode image using lossy compression
--mixed ................. for each frame in the image, pick lossy
-                         or lossless compression heuristically
--q <float> ............. quality factor (0:small..100:big)
--m <int> ............... compression method (0=fast, 6=slowest)
--min_size .............. minimize output size (default:off)
-                         lossless compression by default; can be
-                         combined with -q, -m, -lossy or -mixed
-                         options
--kmin <int> ............ min distance between key frames
--kmax <int> ............ max distance between key frames
--f <int> ............... filter strength (0=off..100)
--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
--v ..................... verbose
--quiet ................. don't print anything
-```
-
-### Building
-
-With the libgif development files installed, gif2webp can be built using
-makefile.unix:
-
-```shell
-$ make -f makefile.unix examples/gif2webp
-```
-
-or using autoconf:
-
-```shell
-$ ./configure --enable-everything
-$ make
-```
-
-## Comparison of animated images
-
-Test utility anim_diff under examples/ can be used to compare two animated
-images (each can be GIF or WebP).
-
-Usage:
-
-```shell
-anim_diff <image1> <image2> [options]
-```
-
-Options:
-
-```
--dump_frames <folder> dump decoded frames in PAM format
--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
-
-With the libgif development files installed, anim_diff can be built using
-makefile.unix:
-
-```shell
-$ make -f makefile.unix examples/anim_diff
-```
-
-or using autoconf:
-
-```shell
-$ ./configure --enable-everything
-$ make
-```
-
-## WebP Mux tool
-
-The examples/ directory contains a tool (webpmux) for manipulating WebP files.
-The webpmux tool can be used to create an extended format WebP file and also to
-extract or strip relevant data from such a file.
-
-A list of options is available using the -help command line flag:
-
-```shell
-> 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:
-   icc       get ICC profile
-   exif      get EXIF metadata
-   xmp       get XMP metadata
-   frame n   get nth frame
-
-SET_OPTIONS:
- Set color profile/metadata/parameters:
-   loop LOOP_COUNT            set the loop count
-   bgcolor BACKGROUND_COLOR   set the animation background color
-   icc  file.icc              set ICC profile
-   exif file.exif             set EXIF metadata
-   xmp  file.xmp              set XMP metadata
-   where:    'file.icc' contains the ICC profile to be set,
-             '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 all 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
-   exif      strip EXIF metadata
-   xmp       strip XMP metadata
-
-FRAME_OPTIONS(i):
- Create animation:
-   file_i +di[+xi+yi[+mi[bi]]]
-   where:    'file_i' is the i'th animation frame (WebP format),
-             'di' is the pause duration before next frame,
-             'xi','yi' specify the image offset for this frame,
-             'mi' is the dispose method for this frame (0 or 1),
-             'bi' is the blending method for this frame (+b or -b)
-
-LOOP_COUNT:
- Number of times to repeat the animation.
- Valid range is 0 to 65535 [Default: 0 (infinite)].
-
-BACKGROUND_COLOR:
- Background color of the canvas.
-  A,R,G,B
-  where:    'A', 'R', 'G' and 'B' are integers in the range 0 to 255 specifying
-            the Alpha, Red, Green and Blue component values respectively
-            [Default: 255,255,255,255]
-
-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 '-'.
-```

doc/webp-container-spec.txt

@@ -2,10 +2,10 @@
 
 Although you may be viewing an alternate representation, this document
 is sourced in Markdown, a light-duty markup scheme, and is optimized for
-the [kramdown](https://kramdown.gettalong.org/) transformer.
+the [kramdown](http://kramdown.rubyforge.org/) transformer.
 
-See the accompanying specs_generation.md. External link targets are referenced
-at the end of this file.
+See the accompanying README. External link targets are referenced at the
+end of this file.
 
 -->
 
@@ -36,7 +36,7 @@ for:
   * **Lossless compression.** An image can be losslessly compressed, using the
     WebP Lossless Format.
 
-  * **Metadata.** An image may have metadata stored in Exif or XMP formats.
+  * **Metadata.** An image may have metadata stored in EXIF or XMP formats.
 
   * **Transparency.** An image may have transparency, i.e., an alpha channel.
 
@@ -53,6 +53,10 @@ document are to be interpreted as described in [RFC 2119][].
 Bit numbering in chunk diagrams starts at `0` for the most significant bit
 ('MSB 0') as described in [RFC 1166][].
 
+**Note:** Out of the features mentioned above, lossy compression, lossless
+compression, transparency, metadata, color profile and animation are finalized
+and are to be considered stable.
+
 Terminology & Basics
 ------------------------
 
@@ -94,7 +98,7 @@ _1-based_
 RIFF File Format
 ----------------
 
-The WebP file format is based on the RIFF (Resource Interchange File Format)
+The WebP file format is based on the RIFF (resource interchange file format)
 document format.
 
 The basic element of a RIFF file is a _chunk_. It consists of:
@@ -261,11 +265,11 @@ An extended format file consists of:
 
   * Image data.
 
-  * An optional 'EXIF' chunk with Exif metadata.
+  * An optional 'EXIF' chunk with EXIF metadata.
 
   * An optional 'XMP ' chunk with XMP metadata.
 
-  * An optional list of [unknown chunks](#unknown-chunks).
+  * An optional list of [unknown chunks](#unknown-chunks). _\[status: experimental\]_
 
 For a _still image_, the _image data_ consists of a single frame, which is made
 up of:
@@ -317,9 +321,9 @@ Alpha (L): 1 bit
 : Set if any of the frames of the image contain transparency information
   ("alpha").
 
-Exif metadata (E): 1 bit
+EXIF metadata (E): 1 bit
 
-: Set if the file contains Exif metadata.
+: Set if the file contains EXIF metadata.
 
 XMP metadata (X): 1 bit
 
@@ -341,12 +345,12 @@ Reserved: 24 bits
 Canvas Width Minus One: 24 bits
 
 : _1-based_ width of the canvas in pixels.
-  The actual canvas width is `1 + Canvas Width Minus One`.
+  The actual canvas width is '1 + Canvas Width Minus One'
 
 Canvas Height Minus One: 24 bits
 
 : _1-based_ height of the canvas in pixels.
-  The actual canvas height is `1 + Canvas Height Minus One`.
+  The actual canvas height is '1 + Canvas Height Minus One'
 
 The product of _Canvas Width_ and _Canvas Height_ MUST be at most `2^32 - 1`.
 
@@ -423,28 +427,27 @@ If the _Animation flag_ is not set, then this chunk SHOULD NOT be present.
 
 Frame X: 24 bits (_uint24_)
 
-: The X coordinate of the upper left corner of the frame is `Frame X * 2`.
+: The X coordinate of the upper left corner of the frame is `Frame X * 2`
 
 Frame Y: 24 bits (_uint24_)
 
-: The Y coordinate of the upper left corner of the frame is `Frame Y * 2`.
+: The Y coordinate of the upper left corner of the frame is `Frame Y * 2`
 
 Frame Width Minus One: 24 bits (_uint24_)
 
 : The _1-based_ width of the frame.
-  The frame width is `1 + Frame Width Minus One`.
+  The frame width is `1 + Frame Width Minus One`
 
 Frame Height Minus One: 24 bits (_uint24_)
 
 : The _1-based_ height of the frame.
-  The frame height is `1 + Frame Height Minus One`.
+  The frame height is `1 + Frame Height Minus One`
 
 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
 
@@ -677,12 +680,12 @@ EXIF chunk:
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                      ChunkHeader('EXIF')                      |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-    |                        Exif Metadata                          |
+    |                        EXIF Metadata                          |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
-Exif Metadata: _Chunk Size_ bytes
+EXIF Metadata: _Chunk Size_ bytes
 
-: image metadata in Exif format.
+: image metadata in EXIF format.
 
 XMP chunk:
 
@@ -701,7 +704,7 @@ XMP Metadata: _Chunk Size_ bytes
 Additional guidance about handling metadata can be found in the
 Metadata Working Group's [Guidelines for Handling Metadata][metadata].
 
-#### Unknown Chunks
+#### Unknown Chunks _\[status: experimental\]_
 
 A RIFF chunk (described in [this](#terminology-amp-basics) section) whose _chunk
 tag_ is different from any of the chunks described in this document, is
@@ -798,7 +801,7 @@ RIFF/WEBP
 +- XMP  (metadata)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-An animated image with Exif metadata may look as follows:
+An animated image with EXIF metadata may look as follows:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 RIFF/WEBP
@@ -811,9 +814,9 @@ RIFF/WEBP
 +- EXIF (metadata)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-[vp8spec]:  https://datatracker.ietf.org/doc/html/rfc6386
-[webpllspec]: https://chromium.googlesource.com/webm/libwebp/+/HEAD/doc/webp-lossless-bitstream-spec.txt
-[iccspec]: https://www.color.org/icc_specs2.xalter
-[metadata]: https://web.archive.org/web/20180919181934/http://www.metadataworkinggroup.org/pdf/mwg_guidance.pdf
-[rfc 1166]: https://datatracker.ietf.org/doc/html/rfc1166
-[rfc 2119]: https://datatracker.ietf.org/doc/html/rfc2119
+[vp8spec]:  http://tools.ietf.org/html/rfc6386
+[webpllspec]: https://chromium.googlesource.com/webm/libwebp/+/master/doc/webp-lossless-bitstream-spec.txt
+[iccspec]: http://www.color.org/icc_specs2.xalter
+[metadata]: http://www.metadataworkinggroup.org/pdf/mwg_guidance.pdf
+[rfc 1166]: http://tools.ietf.org/html/rfc1166
+[rfc 2119]: http://tools.ietf.org/html/rfc2119

doc/webp-lossless-bitstream-spec.txt

@@ -2,10 +2,10 @@
 
 Although you may be viewing an alternate representation, this document
 is sourced in Markdown, a light-duty markup scheme, and is optimized for
-the [kramdown](https://kramdown.gettalong.org/) transformer.
+the [kramdown](http://kramdown.rubyforge.org/) transformer.
 
-See the accompanying specs_generation.md. External link targets are referenced
-at the end of this file.
+See the accompanying README. External link targets are referenced at the
+end of this file.
 
 -->
 
@@ -16,8 +16,6 @@ _Jyrki Alakuijala, Ph.D., Google, Inc., 2012-06-19_
 
 Paragraphs marked as \[AMENDED\] were amended on 2014-09-16.
 
-Paragraphs marked as \[AMENDED2\] were amended on 2022-05-13.
-
 Abstract
 --------
 
@@ -27,7 +25,7 @@ exactly, including the color values for zero alpha pixels. The
 format uses subresolution images, recursively embedded into the format
 itself, for storing statistical data about the images, such as the used
 entropy codes, spatial predictors, color space conversion, and color
-table. LZ77, prefix coding, and a color cache are used for compression
+table. LZ77, Huffman coding, and a color cache are used for compression
 of the bulk data. Decoding speeds faster than PNG have been
 demonstrated, as well as 25% denser compression than can be achieved
 using today's PNG format.
@@ -65,9 +63,9 @@ distance mapping
 entropy image
 : A two-dimensional subresolution image indicating which entropy coding
   should be used in a respective square in the image, i.e., each pixel
-  is a meta prefix code.
+  is a meta Huffman code.
 
-prefix code
+Huffman code
 : A classic way to do entropy coding where a smaller number of bits are
   used for more frequent codes.
 
@@ -75,9 +73,9 @@ LZ77
 : Dictionary-based sliding window compression algorithm that either
   emits symbols or describes them as sequences of past symbols.
 
-meta prefix code
+meta Huffman code
 : A small integer (up to 16 bits) that indexes an element in the meta
-  prefix table.
+  Huffman table.
 
 predictor image
 : A two-dimensional subresolution image indicating which spatial
@@ -237,7 +235,7 @@ transform, the current pixel value is predicted from the pixels already
 decoded (in scan-line order) and only the residual value (actual -
 predicted) is encoded. The _prediction mode_ determines the type of
 prediction to use. We divide the image into squares and all the pixels
-in a square use the same prediction mode.
+in a square use same prediction mode.
 
 The first 3 bits of prediction data define the block width and height in
 number of bits. The number of block columns, `block_xsize`, is used in
@@ -369,17 +367,15 @@ the predicted value for the left-topmost pixel of the image is
 0xff000000, L-pixel for all pixels on the top row, and T-pixel for all
 pixels on the leftmost column.
 
-\[AMENDED2\]
 Addressing the TR-pixel for pixels on the rightmost column is
 exceptional. The pixels on the rightmost column are predicted by using
-the modes \[0..13\] just like pixels not on the border, but the leftmost pixel
-on the same row as the current pixel is instead used as the TR-pixel.
+the modes \[0..13\] just like pixels not on border, but by using the
+leftmost pixel on the same row as the current TR-pixel. The TR-pixel
+offset in memory is the same for border and non-border pixels.
 
 
 ### Color Transform
 
-\[AMENDED2\]
-
 The goal of the color transform is to decorrelate the R, G and B values
 of each pixel. Color transform keeps the green (G) value as it is,
 transforms red (R) based on green and transforms blue (B) based on green
@@ -400,8 +396,8 @@ typedef struct {
 The actual color transformation is done by defining a color transform
 delta. The color transform delta depends on the `ColorTransformElement`,
 which is the same for all the pixels in a particular block. The delta is
-subtracted during color transform. The inverse color transform then is just
-adding those deltas.
+added during color transform. The inverse color transform then is just
+subtracting those deltas.
 
 The color transform function is defined as follows:
 
@@ -410,13 +406,13 @@ void ColorTransform(uint8 red, uint8 blue, uint8 green,
                     ColorTransformElement *trans,
                     uint8 *new_red, uint8 *new_blue) {
   // Transformed values of red and blue components
-  int tmp_red = red;
-  int tmp_blue = blue;
+  uint32 tmp_red = red;
+  uint32 tmp_blue = blue;
 
-  // Applying the transform is just subtracting the transform deltas
-  tmp_red  -= ColorTransformDelta(p->green_to_red_,  green);
-  tmp_blue -= ColorTransformDelta(p->green_to_blue_, green);
-  tmp_blue -= ColorTransformDelta(p->red_to_blue_, red);
+  // Applying transform is just adding the transform deltas
+  tmp_red  += ColorTransformDelta(trans->green_to_red, green);
+  tmp_blue += ColorTransformDelta(trans->green_to_blue, green);
+  tmp_blue += ColorTransformDelta(trans->red_to_blue, red);
 
   *new_red = tmp_red & 0xff;
   *new_blue = tmp_blue & 0xff;
@@ -434,7 +430,7 @@ int8 ColorTransformDelta(int8 t, int8 c) {
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A conversion from the 8-bit unsigned representation (uint8) to the 8-bit
-signed one (int8) is required before calling `ColorTransformDelta()`.
+signed one (int8) is required before calling ColorTransformDelta().
 It should be performed using 8-bit two's complement (that is: uint8 range
 \[128-255\] is mapped to the \[-128, -1\] range of its converted int8 value).
 
@@ -472,18 +468,14 @@ channels.
 void InverseTransform(uint8 red, uint8 green, uint8 blue,
                       ColorTransformElement *p,
                       uint8 *new_red, uint8 *new_blue) {
-  // Transformed values of red and blue components
-  int tmp_red = red;
-  int tmp_blue = blue;
-
-  // Applying inverse transform is just adding the
+  // Applying inverse transform is just subtracting the
   // color transform deltas
-  tmp_red  += ColorTransformDelta(trans->green_to_red, green);
-  tmp_blue += ColorTransformDelta(trans->green_to_blue, green);
-  tmp_blue += ColorTransformDelta(trans->red_to_blue, tmp_red & 0xff);
+  red  -= ColorTransformDelta(p->green_to_red_,  green);
+  blue -= ColorTransformDelta(p->green_to_blue_, green);
+  blue -= ColorTransformDelta(p->red_to_blue_, red & 0xff);
 
-  *new_red = tmp_red & 0xff;
-  *new_blue = tmp_blue & 0xff;
+  *new_red = red & 0xff;
+  *new_blue = blue & 0xff;
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -598,12 +590,12 @@ The values are packed into the green component as follows:
     4 most-significant bits of the green value at x / 2.
   * `width_bits` = 2: for every x value where x ≡ 0 (mod 4), a green
     value at x is positioned into the 2 least-significant bits of the
-    green value at x / 4, green values at x + 1 to x + 3 are positioned in order
-    to the more significant bits of the green value at x / 4.
+    green value at x / 4, green values at x + 1 to x + 3 in order to the
+    more significant bits of the green value at x / 4.
   * `width_bits` = 3: for every x value where x ≡ 0 (mod 8), a green
     value at x is positioned into the least-significant bit of the green
-    value at x / 8, green values at x + 1 to x + 7 are positioned in order to
-    the more significant bits of the green value at x / 8.
+    value at x / 8, green values at x + 1 to x + 7 in order to the more
+    significant bits of the green value at x / 8.
 
 
 4 Image Data
@@ -617,8 +609,8 @@ We use image data in five different roles:
 
   1. ARGB image: Stores the actual pixels of the image.
   1. Entropy image: Stores the
-     [meta prefix codes](#decoding-of-meta-prefix-codes). The red and green
-     components of a pixel define the meta prefix code used in a particular
+     [meta Huffman codes](#decoding-of-meta-huffman-codes). The red and green
+     components of a pixel define the meta Huffman code used in a particular
      block of the ARGB image.
   1. Predictor image: Stores the metadata for [Predictor
      Transform](#predictor-transform). The green component of a pixel defines
@@ -629,7 +621,7 @@ We use image data in five different roles:
      the image. Each `ColorTransformElement` `'cte'` is treated as a pixel whose
      alpha component is `255`, red component is `cte.red_to_blue`, green
      component is `cte.green_to_blue` and blue component is `cte.green_to_red`.
-  1. Color indexing image: An array of size `color_table_size` (up to 256
+  1. Color indexing image: An array of of size `color_table_size` (up to 256
      ARGB values) storing the metadata for the
      [Color Indexing Transform](#color-indexing-transform). This is stored as an
      image of width `color_table_size` and height `1`.
@@ -651,7 +643,7 @@ the image.
 
 Each pixel is encoded using one of the three possible methods:
 
-  1. prefix coded literal: each channel (green, red, blue and alpha) is
+  1. Huffman coded literal: each channel (green, red, blue and alpha) is
      entropy-coded independently;
   2. LZ77 backward reference: a sequence of pixels are copied from elsewhere
      in the image; or
@@ -660,9 +652,9 @@ Each pixel is encoded using one of the three possible methods:
 
 The following sub-sections describe each of these in detail.
 
-#### 4.2.1 Prefix Coded Literals
+#### 4.2.1 Huffman Coded Literals
 
-The pixel is stored as prefix coded values of green, red, blue and alpha (in
+The pixel is stored as Huffman coded values of green, red, blue and alpha (in
 that order). See [this section](#decoding-entropy-coded-image-data) for details.
 
 #### 4.2.2 LZ77 Backward Reference
@@ -686,7 +678,7 @@ very few values in the image. Thus, this approach results in a better
 compression overall.
 
 The following table denotes the prefix codes and extra bits used for storing
-different ranges of values.
+different range of values.
 
 Note: The maximum backward reference length is limited to 4096. Hence, only the
 first 24 prefix codes (with the respective extra bits) are meaningful for length
@@ -761,13 +753,13 @@ The mapping between distance code `i` and the neighboring pixel offset
 (-6, 7), (7, 6),  (-7, 6), (8, 5),  (7, 7),  (-7, 7), (8, 6),  (8, 7)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-For example, distance code `1` indicates an offset of `(0, 1)` for the
-neighboring pixel, that is, the pixel above the current pixel (0 pixel
-difference in X-direction and 1 pixel difference in Y-direction). Similarly,
-distance code `3` indicates left-top pixel.
+For example, distance code `1` indicates offset of `(0, 1)` for the neighboring
+pixel, that is, the pixel above the current pixel (0-pixel difference in
+X-direction and 1 pixel difference in Y-direction). Similarly, distance code
+`3` indicates left-top pixel.
 
-The decoder can convert a distance code `i` to a scan-line order distance
-`dist` as follows:
+The decoder can convert a distances code 'i' to a scan-line order distance
+'dist' as follows:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 (xi, yi) = distance_map[i]
@@ -777,22 +769,21 @@ if (dist < 1) {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-where `distance_map` is the mapping noted above and `xsize` is the width of the
+where 'distance_map' is the mapping noted above and `xsize` is the width of the
 image in pixels.
 
 
 #### 4.2.3 Color Cache Coding
-{:#color-cache-code}
 
 Color cache stores a set of colors that have been recently used in the image.
 
 **Rationale:** This way, the recently used colors can sometimes be referred to
-more efficiently than emitting them using the other two methods (described in
-[4.2.1](#prefix-coded-literals) and [4.2.2](#lz77-backward-reference)).
+more efficiently than emitting them using other two methods (described in
+[4.2.1](#huffman-coded-literals) and [4.2.2](#lz77-backward-reference)).
 
 Color cache codes are stored as follows. First, there is a 1-bit value that
 indicates if the color cache is used. If this bit is 0, no color cache codes
-exist, and they are not transmitted in the prefix code that decodes the green
+exist, and they are not transmitted in the Huffman code that decodes the green
 symbols and the length prefix codes. However, if this bit is 1, the color cache
 size is read next:
 
@@ -823,245 +814,130 @@ literals, into the cache in the order they appear in the stream.
 
 ### 5.1 Overview
 
-Most of the data is coded using a [canonical prefix code][canonical_huff].
-Hence, the codes are transmitted by sending the _prefix code lengths_, as
-opposed to the actual _prefix codes_.
+Most of the data is coded using [canonical Huffman code][canonical_huff]. Hence,
+the codes are transmitted by sending the _Huffman code lengths_, as opposed to
+the actual _Huffman codes_.
 
-In particular, the format uses **spatially-variant prefix coding**. In other
+In particular, the format uses **spatially-variant Huffman coding**. In other
 words, different blocks of the image can potentially use different entropy
 codes.
 
-**Rationale**: Different areas of the image may have different characteristics.
-So, allowing them to use different entropy codes provides more flexibility and
-potentially better compression.
+**Rationale**: Different areas of the image may have different characteristics. So, allowing them to use different entropy codes provides more flexibility and
+potentially a better compression.
 
 ### 5.2 Details
 
-The encoded image data consists of several parts:
+The encoded image data consists of two parts:
 
-  1. Decoding and building the prefix codes \[AMENDED2\]
-  1. Meta prefix codes
+  1. Meta Huffman codes
   1. Entropy-coded image data
 
-#### 5.2.1 Decoding and Building the Prefix Codes
+#### 5.2.1 Decoding of Meta Huffman Codes
 
-There are several steps in decoding the prefix codes.
+As noted earlier, the format allows the use of different Huffman codes for
+different blocks of the image. _Meta Huffman codes_ are indexes identifying
+which Huffman codes to use in different parts of the image.
 
-**Decoding the Code Lengths:**
-{:#decoding-the-code-lengths}
-
-This section describes how to read the prefix code lengths from the bitstream.
-
-The prefix code lengths can be coded in two ways. The method used is specified
-by a 1-bit value.
-
-  * If this bit is 1, it is a _simple code length code_, and
-  * If this bit is 0, it is a _normal code length code_.
-
-In both cases, there can be unused code lengths that are still part of the
-stream. This may be inefficient, but it is allowed by the format.
-
-**(i) Simple Code Length Code:**
-
-\[AMENDED2\]
-
-This variant is used in the special case when only 1 or 2 prefix symbols are
-in the range \[0..255\] with code length `1`. All other prefix code lengths
-are implicitly zeros.
-
-The first bit indicates the number of symbols:
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int num_symbols = ReadBits(1) + 1;
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Following are the symbol values.
-This first symbol is coded using 1 or 8 bits depending on the value of
-`is_first_8bits`. The range is \[0..1\] or \[0..255\], respectively.
-The second symbol, if present, is always assumed to be in the range \[0..255\]
-and coded using 8 bits.
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int is_first_8bits = ReadBits(1);
-symbol0 = ReadBits(1 + 7 * is_first_8bits);
-code_lengths[symbol0] = 1;
-if (num_symbols == 2) {
-  symbol1 = ReadBits(8);
-  code_lengths[symbol1] = 1;
-}
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-**Note:** Another special case is when _all_ prefix code lengths are _zeros_
-(an empty prefix code). For example, a prefix code for distance can be empty
-if there are no backward references. Similarly, prefix codes for alpha, red,
-and blue can be empty if all pixels within the same meta prefix code are
-produced using the color cache. However, this case doesn't need a special
-handling, as empty prefix codes can be coded as those containing a single
-symbol `0`.
-
-**(ii) Normal Code Length Code:**
-
-The code lengths of the prefix code fit in 8 bits and are read as follows.
-First, `num_code_lengths` specifies the number of code lengths.
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int num_code_lengths = 4 + ReadBits(4);
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If `num_code_lengths` is > 18, the bitstream is invalid.
-
-The code lengths are themselves encoded using prefix codes: lower level code
-lengths `code_length_code_lengths` first have to be read. The rest of those
-`code_length_code_lengths` (according to the order in `kCodeLengthCodeOrder`)
-are zeros.
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int kCodeLengthCodes = 19;
-int kCodeLengthCodeOrder[kCodeLengthCodes] = {
-  17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
-};
-int code_length_code_lengths[kCodeLengthCodes] = { 0 };  // All zeros.
-for (i = 0; i < num_code_lengths; ++i) {
-  code_length_code_lengths[kCodeLengthCodeOrder[i]] = ReadBits(3);
-}
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Next, if `ReadBits(1) == 0`, the maximum number of different read symbols is
-`num_code_lengths`. Otherwise, it is defined as:
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int length_nbits = 2 + 2 * ReadBits(3);
-int max_symbol = 2 + ReadBits(length_nbits);
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-A prefix table is then built from `code_length_code_lengths` and used to read
-up to `max_symbol` code lengths.
-
-  * Code \[0..15\] indicates literal code lengths.
-    * Value 0 means no symbols have been coded.
-    * Values \[1..15\] indicate the bit length of the respective code.
-  * Code 16 repeats the previous non-zero value \[3..6\] times, i.e.,
-    `3 + ReadBits(2)` times. If code 16 is used before a non-zero
-    value has been emitted, a value of 8 is repeated.
-  * Code 17 emits a streak of zeros \[3..10\], i.e., `3 + ReadBits(3)`
-    times.
-  * Code 18 emits a streak of zeros of length \[11..138\], i.e.,
-    `11 + ReadBits(7)` times.
-
-Once code lengths are read, a prefix code for each symbol type (A, R, G, B,
-distance) is formed using their respective alphabet sizes:
-
-  * G channel: 256 + 24 + `color_cache_size`
-  * other literals (A,R,B): 256
-  * distance code: 40
-
-#### 5.2.2 Decoding of Meta Prefix Codes
-
-As noted earlier, the format allows the use of different prefix codes for
-different blocks of the image. _Meta prefix codes_ are indexes identifying
-which prefix codes to use in different parts of the image.
-
-Meta prefix codes may be used _only_ when the image is being used in the
+Meta Huffman codes may be used _only_ when the image is being used in the
 [role](#roles-of-image-data) of an _ARGB image_.
 
-There are two possibilities for the meta prefix codes, indicated by a 1-bit
+There are two possibilities for the meta Huffman codes, indicated by a 1-bit
 value:
 
-  * If this bit is zero, there is only one meta prefix code used everywhere in
+  * If this bit is zero, there is only one meta Huffman code used everywhere in
     the image. No more data is stored.
-  * If this bit is one, the image uses multiple meta prefix codes. These meta
-    prefix codes are stored as an _entropy image_ (described below).
+  * If this bit is one, the image uses multiple meta Huffman codes. These meta
+    Huffman codes are stored as an _entropy image_ (described below).
 
 **Entropy image:**
 
-The entropy image defines which prefix codes are used in different parts of the
+The entropy image defines which Huffman codes are used in different parts of the
 image, as described below.
 
-The first 3-bits contain the `prefix_bits` value. The dimensions of the entropy
-image are derived from 'prefix_bits'.
+The first 3-bits contain the `huffman_bits` value. The dimensions of the entropy
+image are derived from 'huffman_bits'.
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int prefix_bits = ReadBits(3) + 2;
-int prefix_xsize = DIV_ROUND_UP(xsize, 1 << prefix_bits);
-int prefix_ysize = DIV_ROUND_UP(ysize, 1 << prefix_bits);
+int huffman_bits = ReadBits(3) + 2;
+int huffman_xsize = DIV_ROUND_UP(xsize, 1 << huffman_bits);
+int huffman_ysize = DIV_ROUND_UP(ysize, 1 << huffman_bits);
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 where `DIV_ROUND_UP` is as defined [earlier](#predictor-transform).
 
-The next bits contain an entropy image of width `prefix_xsize` and height
-`prefix_ysize`.
+Next bits contain an entropy image of width `huffman_xsize` and height
+`huffman_ysize`.
 
-**Interpretation of Meta Prefix Codes:**
+**Interpretation of Meta Huffman Codes:**
 
-For any given pixel (x, y), there is a set of five prefix codes associated with
+For any given pixel (x, y), there is a set of five Huffman codes associated with
 it. These codes are (in bitstream order):
 
-  * **prefix code #1**: used for green channel, backward-reference length and
+  * **Huffman code #1**: used for green channel, backward-reference length and
     color cache
-  * **prefix code #2, #3 and #4**: used for red, blue and alpha channels
+  * **Huffman code #2, #3 and #4**: used for red, blue and alpha channels
     respectively.
-  * **prefix code #5**: used for backward-reference distance.
+  * **Huffman code #5**: used for backward-reference distance.
 
-From here on, we refer to this set as a **prefix code group**.
+From here on, we refer to this set as a **Huffman code group**.
 
-The number of prefix code groups in the ARGB image can be obtained by finding
-the _largest meta prefix code_ from the entropy image:
+The number of Huffman code groups in the ARGB image can be obtained by finding
+the _largest meta Huffman code_ from the entropy image:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int num_prefix_groups = max(entropy image) + 1;
+int num_huff_groups = max(entropy image) + 1;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-where `max(entropy image)` indicates the largest prefix code stored in the
+where `max(entropy image)` indicates the largest Huffman code stored in the
 entropy image.
 
-As each prefix code group contains five prefix codes, the total number of
-prefix codes is:
+As each Huffman code groups contains five Huffman codes, the total number of
+Huffman codes is:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int num_prefix_codes = 5 * num_prefix_groups;
+int num_huff_codes = 5 * num_huff_groups;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Given a pixel (x, y) in the ARGB image, we can obtain the corresponding prefix
+Given a pixel (x, y) in the ARGB image, we can obtain the corresponding Huffman
 codes to be used as follows:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-int position = (y >> prefix_bits) * prefix_xsize + (x >> prefix_bits);
-int meta_prefix_code = (entropy_image[pos] >> 8) & 0xffff;
-PrefixCodeGroup prefix_group = prefix_code_groups[meta_prefix_code];
+int position = (y >> huffman_bits) * huffman_xsize + (x >> huffman_bits);
+int meta_huff_code = (entropy_image[pos] >> 8) & 0xffff;
+HuffmanCodeGroup huff_group = huffman_code_groups[meta_huff_code];
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-where, we have assumed the existence of `PrefixCodeGroup` structure, which
-represents a set of five prefix codes. Also, `prefix_code_groups` is an array
-of `PrefixCodeGroup` (of size `num_prefix_groups`).
+where, we have assumed the existence of `HuffmanCodeGroup` structure, which
+represents a set of five Huffman codes. Also, `huffman_code_groups` is an array
+of `HuffmanCodeGroup` (of size `num_huff_groups`).
 
-The decoder then uses prefix code group `prefix_group` to decode the pixel
+The decoder then uses Huffman code group `huff_group` to decode the pixel
 (x, y) as explained in the [next section](#decoding-entropy-coded-image-data).
 
-#### 5.2.3 Decoding Entropy-coded Image Data
-
-\[AMENDED2\]
+#### 5.2.2 Decoding Entropy-coded Image Data
 
 For the current position (x, y) in the image, the decoder first identifies the
-corresponding prefix code group (as explained in the last section). Given the
-prefix code group, the pixel is read and decoded as follows:
+corresponding Huffman code group (as explained in the last section). Given the
+Huffman code group, the pixel is read and decoded as follows:
 
-Read next symbol S from the bitstream using prefix code #1. Note that S is any
-integer in the range `0` to
-`(256 + 24 + ` [`color_cache_size`](#color-cache-code)` - 1)`.
+Read next symbol S from the bitstream using Huffman code #1. \[See
+[next section](#decoding-the-code-lengths) for details on decoding the Huffman
+code lengths\]. Note that S is any integer in the range `0` to
+`(256 + 24 + ` [`color_cache_size`](#color-cache-code)`- 1)`.
 
 The interpretation of S depends on its value:
 
   1. if S < 256
-     1. Use S as the green component.
-     1. Read red from the bitstream using prefix code #2.
-     1. Read blue from the bitstream using prefix code #3.
-     1. Read alpha from the bitstream using prefix code #4.
-  1. if S >= 256 && S < 256 + 24
-     1. Use S - 256 as a length prefix code.
-     1. Read extra bits for length from the bitstream.
+     1. Use S as the green component
+     1. Read red from the bitstream using Huffman code #2
+     1. Read blue from the bitstream using Huffman code #3
+     1. Read alpha from the bitstream using Huffman code #4
+  1. if S < 256 + 24
+     1. Use S - 256 as a length prefix code
+     1. Read extra bits for length from the bitstream
      1. Determine backward-reference length L from length prefix code and the
         extra bits read.
-     1. Read distance prefix code from the bitstream using prefix code #5.
-     1. Read extra bits for distance from the bitstream.
+     1. Read distance prefix code from the bitstream using Huffman code #5
+     1. Read extra bits for distance from the bitstream
      1. Determine backward-reference distance D from distance prefix code and
         the extra bits read.
      1. Copy the L pixels (in scan-line order) from the sequence of pixels
@@ -1071,6 +947,80 @@ The interpretation of S depends on its value:
      1. Get ARGB color from the color cache at that index.
 
 
+**Decoding the Code Lengths:**
+{:#decoding-the-code-lengths}
+
+This section describes the details about reading a symbol from the bitstream by
+decoding the Huffman code length.
+
+The Huffman code lengths can be coded in two ways. The method used is specified
+by a 1-bit value.
+
+  * If this bit is 1, it is a _simple code length code_, and
+  * If this bit is 0, it is a _normal code length code_.
+
+**(i) Simple Code Length Code:**
+
+This variant is used in the special case when only 1 or 2 Huffman code lengths
+are non-zero, and are in the range of \[0, 255\]. All other Huffman code lengths
+are implicitly zeros.
+
+The first bit indicates the number of non-zero code lengths:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int num_code_lengths = ReadBits(1) + 1;
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The first code length is stored either using a 1-bit code for values of 0 and 1,
+or using an 8-bit code for values in range \[0, 255\]. The second code length,
+when present, is coded as an 8-bit code.
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int is_first_8bits = ReadBits(1);
+code_lengths[0] = ReadBits(1 + 7 * is_first_8bits);
+if (num_code_lengths == 2) {
+  code_lengths[1] = ReadBits(8);
+}
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+**Note:** Another special case is when _all_ Huffman code lengths are _zeros_
+(an empty Huffman code). For example, a Huffman code for distance can be empty
+if there are no backward references. Similarly, Huffman codes for alpha, red,
+and blue can be empty if all pixels within the same meta Huffman code are
+produced using the color cache. However, this case doesn't need a special
+handling, as empty Huffman codes can be coded as those containing a single
+symbol `0`.
+
+**(ii) Normal Code Length Code:**
+
+The code lengths of a Huffman code are read as follows: `num_code_lengths`
+specifies the number of code lengths; the rest of the code lengths
+(according to the order in `kCodeLengthCodeOrder`) are zeros.
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int kCodeLengthCodes = 19;
+int kCodeLengthCodeOrder[kCodeLengthCodes] = {
+  17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+};
+int code_lengths[kCodeLengthCodes] = { 0 };  // All zeros.
+int num_code_lengths = 4 + ReadBits(4);
+for (i = 0; i < num_code_lengths; ++i) {
+  code_lengths[kCodeLengthCodeOrder[i]] = ReadBits(3);
+}
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  * Code length code \[0..15\] indicates literal code lengths.
+    * Value 0 means no symbols have been coded.
+    * Values \[1..15\] indicate the bit length of the respective code.
+  * Code 16 repeats the previous non-zero value \[3..6\] times, i.e.,
+    3 + `ReadBits(2)` times.  If code 16 is used before a non-zero
+    value has been emitted, a value of 8 is repeated.
+  * Code 17 emits a streak of zeros \[3..10\], i.e., 3 + `ReadBits(3)`
+    times.
+  * Code 18 emits a streak of zeros of length \[11..138\], i.e.,
+    11 + `ReadBits(7)` times.
+
+
 6 Overall Structure of the Format
 ---------------------------------
 
@@ -1106,26 +1056,23 @@ of pixels (xsize * ysize).
 
 #### Structure of the Image Data
 
-\[AMENDED2\]
-
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-<spatially-coded image> ::= <color cache info><meta prefix><data>
-<entropy-coded image> ::= <color cache info><data>
+<spatially-coded image> ::= <meta huffman><entropy-coded image>
+<entropy-coded image> ::= <color cache info><huffman codes><lz77-coded image>
+<meta huffman> ::= 1-bit value 0 |
+                   (1-bit value 1; <entropy image>)
+<entropy image> ::= 3-bit subsample value; <entropy-coded image>
 <color cache info> ::= 1 bit value 0 |
                        (1-bit value 1; 4-bit value for color cache size)
-<meta prefix> ::= 1-bit value 0 |
-                  (1-bit value 1; <entropy image>)
-<data> ::= <prefix codes><lz77-coded image>
-<entropy image> ::= 3-bit subsample value; <entropy-coded image>
-<prefix codes> ::= <prefix code group> | <prefix code group><prefix codes>
-<prefix code group> ::= <prefix code><prefix code><prefix code>
-                        <prefix code><prefix code>
-                        See "Interpretation of Meta Prefix Codes" to
-                        understand what each of these five prefix codes are
-                        for.
-<prefix code> ::= <simple prefix code> | <normal prefix code>
-<simple prefix code> ::= see "Simple code length code" for details
-<normal prefix code> ::= <code length code>; encoded code lengths
+<huffman codes> ::= <huffman code group> | <huffman code group><huffman codes>
+<huffman code group> ::= <huffman code><huffman code><huffman code>
+                         <huffman code><huffman code>
+                         See "Interpretation of Meta Huffman codes" to
+                         understand what each of these five Huffman codes are
+                         for.
+<huffman code> ::= <simple huffman code> | <normal huffman code>
+<simple huffman code> ::= see "Simple code length code" for details
+<normal huffman code> ::= <code length code>; encoded code lengths
 <code length code> ::= see section "Normal code length code"
 <lz77-coded image> ::= ((<argb-pixel> | <lz77-copy> | <color-cache-code>)
                        <lz77-coded image>) | ""
@@ -1135,8 +1082,9 @@ A possible example sequence:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 <RIFF header><image size>1-bit value 1<subtract-green-tx>
-1-bit value 1<predictor-tx>1-bit value 0<color cache info>1-bit value 0
-<prefix codes><lz77-coded image>
+1-bit value 1<predictor-tx>1-bit value 0<meta huffman>
+<color cache info><huffman codes>
+<lz77-coded image>
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-[canonical_huff]: https://en.wikipedia.org/wiki/Canonical_Huffman_code
+[canonical_huff]: http://en.wikipedia.org/wiki/Canonical_Huffman_code

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);
@@ -60,15 +55,15 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
       !CheckSizeForOverflow(total_frame_size)) {
     return 0;
   }
-  mem = (uint8_t*)WebPMalloc((size_t)total_size);
-  frames = (DecodedFrame*)WebPMalloc((size_t)total_frame_size);
+  mem = (uint8_t*)malloc((size_t)total_size);
+  frames = (DecodedFrame*)malloc((size_t)total_frame_size);
 
   if (mem == NULL || frames == NULL) {
-    WebPFree(mem);
-    WebPFree(frames);
+    free(mem);
+    free(frames);
     return 0;
   }
-  WebPFree(image->raw_mem);
+  free(image->raw_mem);
   image->num_frames = num_frames;
   image->frames = frames;
   for (i = 0; i < num_frames; ++i) {
@@ -82,15 +77,14 @@ static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
 
 void ClearAnimatedImage(AnimatedImage* const image) {
   if (image != NULL) {
-    WebPFree(image->raw_mem);
-    WebPFree(image->frames);
+    free(image->raw_mem);
+    free(image->frames);
     image->num_frames = 0;
     image->frames = NULL;
     image->raw_mem = NULL;
   }
 }
 
-#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,50 +147,46 @@ 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*)WebPMalloc(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:
   if (f != NULL) fclose(f);
-  WebPFree(file_name);
+  free(file_name);
   return ok;
 }
 
@@ -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;
   }
 
@@ -241,7 +230,7 @@ static int ReadAnimatedWebP(const char filename[],
   image->bgcolor = anim_info.bgcolor;
 
   // Allocate frames.
-  if (!AllocateFrames(image, anim_info.frame_count)) goto End;
+  if (!AllocateFrames(image, anim_info.frame_count)) return 0;
 
   // Decode frames.
   while (WebPAnimDecoderHasMoreFrames(dec)) {
@@ -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) {
@@ -405,7 +413,7 @@ static uint32_t GetBackgroundColorGIF(GifFileType* gif) {
     return 0xffffffff;  // Invalid: assume white.
   } else {
     const GifColorType color = color_map->Colors[gif->SBackGroundColor];
-    return (0xffu << 24) |
+    return (0xff << 24) |
            (color.Red << 16) |
            (color.Green << 8) |
            (color.Blue << 0);
@@ -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;
@@ -558,10 +560,7 @@ static int ReadAnimatedGIF(const char filename[], AnimatedImage* const image,
     }
   }
   // Allocate frames.
-  if (!AllocateFrames(image, frame_count)) {
-    DGifCloseFile(gif, NULL);
-    return 0;
-  }
+  AllocateFrames(image, frame_count);
 
   canvas_width = image->canvas_width;
   canvas_height = image->canvas_height;
@@ -580,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;
@@ -674,7 +670,6 @@ static int ReadAnimatedGIF(const char filename[], AnimatedImage* const image,
       }
     }
   }
-  image->format = ANIM_GIF;
   DGifCloseFile(gif, NULL);
   return 1;
 }
@@ -709,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;
   }
 
@@ -720,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);
@@ -748,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);
@@ -774,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

@@ -12,7 +12,6 @@
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
-#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -21,12 +20,9 @@
 #include "webp/config.h"
 #endif
 
-#include "../examples/example_util.h"
-#include "../imageio/image_dec.h"
-#include "../imageio/imageio_util.h"
-#include "../imageio/webpdec.h"
+#include "./example_util.h"
+#include "./image_dec.h"
 #include "./stopwatch.h"
-#include "./unicode.h"
 #include "webp/encode.h"
 
 #ifndef WEBP_DLL
@@ -63,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;
 }
 
@@ -80,21 +76,20 @@ 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);
   }
-  WebPFree((void*)data);
+  free((void*)data);
   return ok;
 }
 
@@ -106,22 +101,21 @@ 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);
   }
-  WebPFree((void*)data);
+  free((void*)data);
   return ok;
 }
 
@@ -130,8 +124,7 @@ static int ReadPicture(const char* const filename, WebPPicture* const pic,
 static void AllocExtraInfo(WebPPicture* const pic) {
   const int mb_w = (pic->width + 15) / 16;
   const int mb_h = (pic->height + 15) / 16;
-  pic->extra_info =
-      (uint8_t*)WebPMalloc(mb_w * mb_h * sizeof(*pic->extra_info));
+  pic->extra_info = (uint8_t*)malloc(mb_w * mb_h * sizeof(*pic->extra_info));
 }
 
 static void PrintByteCount(const int bytes[4], int total_size,
@@ -146,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, "|     %3d%%", (int)(100. * counts[s] / total + .5));
+    fprintf(stderr, "|      %2d%%", 100 * counts[s] / total);
   }
   fprintf(stderr, "| %7d\n", total);
 }
@@ -191,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");
   }
 }
@@ -210,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",
@@ -250,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:  ");
@@ -308,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;
@@ -474,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);
@@ -498,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);
 }
 
 //------------------------------------------------------------------------------
@@ -527,7 +510,6 @@ static void HelpLong(void) {
   printf(" cwebp [-preset <...>] [options] in_file [-o out_file]\n\n");
   printf("If input size (-s) for an image is not specified, it is\n"
          "assumed to be a PNG, JPEG, TIFF or WebP file.\n");
-  printf("Note: Animated PNG and WebP files are not supported.\n");
 #ifdef HAVE_WINCODEC_H
   printf("Windows builds can take as input any of the files handled by WIC.\n");
 #endif
@@ -562,16 +544,12 @@ 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");
   printf("  -pass <int> ............ analysis pass number (1..10)\n");
-  printf("  -qrange <min> <max> .... specifies the permissible quality range\n"
-         "                           (default: 0 100)\n");
   printf("  -crop <x> <y> <w> <h> .. crop picture with the given rectangle\n");
-  printf("  -resize <w> <h> ........ resize picture (*after* any cropping)\n");
+  printf("  -resize <w> <h> ........ resize picture (after any cropping)\n");
   printf("  -mt .................... use multi-threading if available\n");
   printf("  -low_memory ............ reduce memory usage (slower encoding)\n");
   printf("  -map <int> ............. print map of extra info\n");
@@ -594,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");
 
@@ -620,7 +601,6 @@ static void HelpLong(void) {
   printf("  -af .................... auto-adjust filter strength\n");
   printf("  -pre <int> ............. pre-processing filter\n");
   printf("\n");
-  printf("Supported input formats:\n  %s\n", WebPGetEnabledInputFileFormats());
 }
 
 //------------------------------------------------------------------------------
@@ -647,10 +627,10 @@ static const char* const kErrorMessages[VP8_ENC_ERROR_LAST] = {
 
 //------------------------------------------------------------------------------
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   int return_value = -1;
-  const char* in_file = NULL, *out_file = NULL, *dump_file = NULL;
-  FILE* out = NULL;
+  const char *in_file = NULL, *out_file = NULL, *dump_file = NULL;
+  FILE *out = NULL;
   int c;
   int short_output = 0;
   int quiet = 0;
@@ -670,38 +650,35 @@ int main(int argc, const char* argv[]) {
   WebPConfig config;
   WebPAuxStats stats;
   WebPMemoryWriter memory_writer;
-  int use_memory_writer;
   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);
-    } else if (!strcmp(argv[c], "-o") && c + 1 < argc) {
-      out_file = (const char*)GET_WARGV(argv, ++c);
-    } else if (!strcmp(argv[c], "-d") && c + 1 < argc) {
-      dump_file = (const char*)GET_WARGV(argv, ++c);
+      return 0;
+    } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
+      out_file = argv[++c];
+    } else if (!strcmp(argv[c], "-d") && c < argc - 1) {
+      dump_file = argv[++c];
       config.show_compressed = 1;
     } else if (!strcmp(argv[c], "-print_psnr")) {
       config.show_compressed = 1;
@@ -714,7 +691,7 @@ int main(int argc, const char* argv[]) {
       print_distortion = 2;
     } else if (!strcmp(argv[c], "-short")) {
       ++short_output;
-    } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
+    } else if (!strcmp(argv[c], "-s") && c < argc - 2) {
       picture.width = ExUtilGetInt(argv[++c], 0, &parse_error);
       picture.height = ExUtilGetInt(argv[++c], 0, &parse_error);
       if (picture.width > WEBP_MAX_DIMENSION || picture.width < 0 ||
@@ -724,30 +701,30 @@ int main(int argc, const char* argv[]) {
                 picture.width, picture.height);
         goto Error;
       }
-    } else if (!strcmp(argv[c], "-m") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-m") && c < argc - 1) {
       config.method = ExUtilGetInt(argv[++c], 0, &parse_error);
       use_lossless_preset = 0;   // disable -z option
-    } else if (!strcmp(argv[c], "-q") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-q") && c < argc - 1) {
       config.quality = ExUtilGetFloat(argv[++c], &parse_error);
       use_lossless_preset = 0;   // disable -z option
-    } else if (!strcmp(argv[c], "-z") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-z") && c < argc - 1) {
       lossless_preset = ExUtilGetInt(argv[++c], 0, &parse_error);
       if (use_lossless_preset != 0) use_lossless_preset = 1;
-    } else if (!strcmp(argv[c], "-alpha_q") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-alpha_q") && c < argc - 1) {
       config.alpha_quality = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-alpha_method") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-alpha_method") && c < argc - 1) {
       config.alpha_compression = ExUtilGetInt(argv[++c], 0, &parse_error);
     } else if (!strcmp(argv[c], "-alpha_cleanup")) {
       // This flag is obsolete, does opposite of -exact.
       config.exact = 0;
     } else if (!strcmp(argv[c], "-exact")) {
       config.exact = 1;
-    } else if (!strcmp(argv[c], "-blend_alpha") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-blend_alpha") && c < argc - 1) {
       blend_alpha = 1;
       // background color is given in hex with an optional '0x' prefix
       background_color = ExUtilGetInt(argv[++c], 16, &parse_error);
       background_color = background_color & 0x00ffffffu;
-    } else if (!strcmp(argv[c], "-alpha_filter") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-alpha_filter") && c < argc - 1) {
       ++c;
       if (!strcmp(argv[c], "none")) {
         config.alpha_filtering = 0;
@@ -763,10 +740,15 @@ int main(int argc, const char* argv[]) {
       keep_alpha = 0;
     } else if (!strcmp(argv[c], "-lossless")) {
       config.lossless = 1;
-    } else if (!strcmp(argv[c], "-near_lossless") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-near_lossless") && c < argc - 1) {
       config.near_lossless = ExUtilGetInt(argv[++c], 0, &parse_error);
       config.lossless = 1;  // use near-lossless only with lossless
-    } else if (!strcmp(argv[c], "-hint") && c + 1 < argc) {
+#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")) {
         config.image_hint = WEBP_HINT_PHOTO;
@@ -778,13 +760,13 @@ int main(int argc, const char* argv[]) {
         fprintf(stderr, "Error! Unrecognized image hint: %s\n", argv[c]);
         goto Error;
       }
-    } else if (!strcmp(argv[c], "-size") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-size") && c < argc - 1) {
       config.target_size = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-psnr") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-psnr") && c < argc - 1) {
       config.target_PSNR = ExUtilGetFloat(argv[++c], &parse_error);
-    } else if (!strcmp(argv[c], "-sns") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-sns") && c < argc - 1) {
       config.sns_strength = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-f") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-f") && c < argc - 1) {
       config.filter_strength = ExUtilGetInt(argv[++c], 0, &parse_error);
     } else if (!strcmp(argv[c], "-af")) {
       config.autofilter = 1;
@@ -798,32 +780,25 @@ int main(int argc, const char* argv[]) {
       config.filter_type = 1;
     } else if (!strcmp(argv[c], "-nostrong")) {
       config.filter_type = 0;
-    } else if (!strcmp(argv[c], "-sharpness") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-sharpness") && c < argc - 1) {
       config.filter_sharpness = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-sharp_yuv")) {
-      config.use_sharp_yuv = 1;
-    } else if (!strcmp(argv[c], "-pass") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-pass") && c < argc - 1) {
       config.pass = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-qrange") && c + 2 < argc) {
-      config.qmin = ExUtilGetInt(argv[++c], 0, &parse_error);
-      config.qmax = ExUtilGetInt(argv[++c], 0, &parse_error);
-      if (config.qmin < 0) config.qmin = 0;
-      if (config.qmax > 100) config.qmax = 100;
-    } else if (!strcmp(argv[c], "-pre") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-pre") && c < argc - 1) {
       config.preprocessing = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-segments") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-segments") && c < argc - 1) {
       config.segments = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-partition_limit") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-partition_limit") && c < argc - 1) {
       config.partition_limit = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-map") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-map") && c < argc - 1) {
       picture.extra_info_type = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-crop") && c + 4 < argc) {
+    } else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
       crop = 1;
       crop_x = ExUtilGetInt(argv[++c], 0, &parse_error);
       crop_y = ExUtilGetInt(argv[++c], 0, &parse_error);
       crop_w = ExUtilGetInt(argv[++c], 0, &parse_error);
       crop_h = ExUtilGetInt(argv[++c], 0, &parse_error);
-    } else if (!strcmp(argv[c], "-resize") && c + 2 < argc) {
+    } else if (!strcmp(argv[c], "-resize") && c < argc - 2) {
       resize_w = ExUtilGetInt(argv[++c], 0, &parse_error);
       resize_h = ExUtilGetInt(argv[++c], 0, &parse_error);
 #ifndef WEBP_DLL
@@ -834,12 +809,12 @@ 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")) {
       quiet = 1;
-    } else if (!strcmp(argv[c], "-preset") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-preset") && c < argc - 1) {
       WebPPreset preset;
       ++c;
       if (!strcmp(argv[c], "default")) {
@@ -862,7 +837,7 @@ int main(int argc, const char* argv[]) {
         fprintf(stderr, "Error! Could initialize configuration with preset.\n");
         goto Error;
       }
-    } else if (!strcmp(argv[c], "-metadata") && c + 1 < argc) {
+    } else if (!strcmp(argv[c], "-metadata") && c < argc - 1) {
       static const struct {
         const char* option;
         int flag;
@@ -896,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;
       }
@@ -910,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 + 1 < argc) 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) {
@@ -964,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;
@@ -986,41 +960,28 @@ int main(int argc, const char* argv[]) {
     const double read_time = StopwatchReadAndReset(&stop_watch);
     fprintf(stderr, "Time to read input: %.3fs\n", read_time);
   }
-  // The bitstream should be kept in memory when metadata must be appended
-  // before writing it to a file/stream, and/or when the near-losslessly encoded
-  // bitstream must be decoded for distortion computation (lossy will modify the
-  // 'picture' but not the lossless pipeline).
-  // Otherwise directly write the bitstream to a file.
-  use_memory_writer = (out_file != NULL && keep_metadata) ||
-                      (!quiet && print_distortion >= 0 && config.lossless &&
-                       config.near_lossless < 100);
 
   // Open the output
   if (out_file != NULL) {
-    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 (use_memory_writer) {
-      picture.writer = WebPMemoryWrite;
-      picture.custom_ptr = (void*)&memory_writer;
-    } else {
+    if (keep_metadata == 0) {
       picture.writer = MyWriter;
       picture.custom_ptr = (void*)out;
+    } else {
+      picture.writer = WebPMemoryWrite;
+      picture.custom_ptr = (void*)&memory_writer;
     }
   } else {
     out = NULL;
-    if (use_memory_writer) {
-      picture.writer = WebPMemoryWrite;
-      picture.custom_ptr = (void*)&memory_writer;
-    }
     if (!quiet && !short_output) {
       fprintf(stderr, "No output file specified (no -o flag). Encoding will\n");
       fprintf(stderr, "be performed, but its results discarded.\n\n");
@@ -1043,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);
@@ -1099,12 +1017,8 @@ int main(int argc, const char* argv[]) {
   if (picture.extra_info_type > 0) {
     AllocExtraInfo(&picture);
   }
-  // Save original picture for later comparison. Only for lossy as lossless does
-  // not modify 'picture' (even near-lossless).
-  if (print_distortion >= 0 && !config.lossless &&
-      !WebPPictureCopy(&picture, &original_picture)) {
-    fprintf(stderr, "Error! Cannot copy temporary picture\n");
-    goto Error;
+  if (print_distortion >= 0) {  // Save original picture for later comparison
+    WebPPictureCopy(&picture, &original_picture);
   }
 
   // Compress.
@@ -1122,71 +1036,40 @@ int main(int argc, const char* argv[]) {
     fprintf(stderr, "Time to encode picture: %.3fs\n", encode_time);
   }
 
-  // Get the decompressed image for the lossless pipeline.
-  if (!quiet && print_distortion >= 0 && config.lossless) {
-    if (config.near_lossless == 100) {
-      // Pure lossless: image was not modified, make 'original_picture' a view
-      // of 'picture' by copying all members except the freeable pointers.
-      original_picture = picture;
-      original_picture.memory_ = original_picture.memory_argb_ = NULL;
-    } else {
-      // Decode the bitstream stored in 'memory_writer' to get the altered image
-      // to 'picture'; save the 'original_picture' beforehand.
-      assert(use_memory_writer);
-      original_picture = picture;
-      if (!WebPPictureInit(&picture)) {  // Do not free 'picture'.
-        fprintf(stderr, "Error! Version mismatch!\n");
-        goto Error;
-      }
-
-      picture.use_argb = 1;
-      if (!ReadWebP(memory_writer.mem, memory_writer.size, &picture,
-                    /*keep_alpha=*/WebPPictureHasTransparency(&picture),
-                    /*metadata=*/NULL)) {
-        fprintf(stderr, "Error! Cannot decode encoded WebP bitstream\n");
-        fprintf(stderr, "Error code: %d (%s)\n", picture.error_code,
-                kErrorMessages[picture.error_code]);
-        goto Error;
-      }
-      picture.stats = original_picture.stats;
-    }
-    original_picture.stats = NULL;
-  }
-
-  // Write the YUV planes to a PGM file. Only available for lossy.
+  // Write info
   if (dump_file) {
     if (picture.use_argb) {
-      fprintf(stderr, "Warning: can't dump file (-d option) "
-                      "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);
     }
   }
 
-  if (use_memory_writer && out != NULL &&
-      !WriteWebPWithMetadata(out, &picture, &memory_writer, &metadata,
-                             keep_metadata, &metadata_written)) {
-    fprintf(stderr, "Error writing WebP file!\n");
-    goto Error;
-  }
+  if (keep_metadata != 0) {
+    if (out != NULL) {
+      if (!WriteWebPWithMetadata(out, &picture, &memory_writer,
+                                 &metadata, keep_metadata, &metadata_written)) {
+        fprintf(stderr, "Error writing WebP file with metadata!\n");
+        goto Error;
+      }
+    } else {  // output is disabled, just display the metadata stats.
+      const struct {
+        const MetadataPayload* const payload;
+        int flag;
+      } *iter, info[] = {
+        { &metadata.exif, METADATA_EXIF },
+        { &metadata.iccp, METADATA_ICC },
+        { &metadata.xmp, METADATA_XMP },
+        { NULL, 0 }
+      };
+      uint32_t unused1 = 0;
+      uint64_t unused2 = 0;
 
-  if (out == NULL && keep_metadata) {
-    // output is disabled, just display the metadata stats.
-    const struct {
-      const MetadataPayload* const payload;
-      int flag;
-    } *iter, info[] = {{&metadata.exif, METADATA_EXIF},
-                       {&metadata.iccp, METADATA_ICC},
-                       {&metadata.xmp, METADATA_XMP},
-                       {NULL, 0}};
-    uint32_t unused1 = 0;
-    uint64_t unused2 = 0;
-
-    for (iter = info; iter->payload != NULL; ++iter) {
-      if (UpdateFlagsAndSize(iter->payload, !!(keep_metadata & iter->flag),
-                             /*flag=*/0, &unused1, &unused2)) {
-        metadata_written |= iter->flag;
+      for (iter = info; iter->payload != NULL; ++iter) {
+        if (UpdateFlagsAndSize(iter->payload, !!(keep_metadata & iter->flag),
+                               0, &unused1, &unused2)) {
+          metadata_written |= iter->flag;
+        }
       }
     }
   }
@@ -1205,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");
@@ -1212,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]);
       }
@@ -1226,7 +1128,7 @@ int main(int argc, const char* argv[]) {
 
  Error:
   WebPMemoryWriterClear(&memory_writer);
-  WebPFree(picture.extra_info);
+  free(picture.extra_info);
   MetadataFree(&metadata);
   WebPPictureFree(&picture);
   WebPPictureFree(&original_picture);
@@ -1234,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;
@@ -76,8 +561,7 @@ static int SaveOutput(const WebPDecBuffer* const buffer,
 
 static void Help(void) {
   printf("Usage: dwebp in_file [options] [-o out_file]\n\n"
-         "Decodes the WebP image file to PNG format [Default].\n"
-         "Note: Animated WebP files are not supported.\n\n"
+         "Decodes the WebP image file to PNG format [Default]\n"
          "Use following options to convert into alternate image formats:\n"
          "  -pam ......... save the raw RGBA samples as a color PAM\n"
          "  -ppm ......... save the raw RGB samples as a color PPM\n"
@@ -96,7 +580,7 @@ static void Help(void) {
          "  -alpha_dither  use alpha-plane dithering if needed\n"
          "  -mt .......... use multi-threading\n"
          "  -crop <x> <y> <w> <h> ... crop output with the given rectangle\n"
-         "  -resize <w> <h> ......... resize output (*after* any cropping)\n"
+         "  -resize <w> <h> ......... scale the output (*after* any cropping)\n"
          "  -flip ........ flip the output vertically\n"
          "  -alpha ....... only save the alpha plane\n"
          "  -incremental . use incremental decoding (useful for tests)\n"
@@ -114,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;
@@ -133,7 +617,7 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
                      format == RGB_565) ? 2
                   : 4;
     uint32_t stride = bpp * w + 7;   // <- just for exercising
-    external_buffer = (uint8_t*)WebPMalloc(stride * h);
+    external_buffer = (uint8_t*)malloc(stride * h);
     if (external_buffer == NULL) return NULL;
     output_buffer->u.RGBA.stride = stride;
     output_buffer->u.RGBA.size = stride * h;
@@ -146,7 +630,7 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
     uint32_t total_size = stride * h * (has_alpha ? 2 : 1)
                         + 2 * uv_stride * (h + 1) / 2;
     assert(format >= YUV && format <= YUVA);
-    external_buffer = (uint8_t*)WebPMalloc(total_size);
+    external_buffer = (uint8_t*)malloc(total_size);
     if (external_buffer == NULL) return NULL;
     tmp = external_buffer;
     output_buffer->u.YUVA.y = tmp;
@@ -177,15 +661,15 @@ static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
   return external_buffer;
 }
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   int ok = 0;
-  const char* in_file = NULL;
-  const char* out_file = NULL;
+  const char *in_file = NULL;
+  const char *out_file = NULL;
 
   WebPDecoderConfig config;
   WebPDecBuffer* const output_buffer = &config.output;
   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;
@@ -193,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")) {
@@ -227,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")) {
@@ -288,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;
@@ -315,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) {
@@ -336,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:
@@ -369,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; "
@@ -413,9 +887,9 @@ int main(int argc, const char* argv[]) {
   }
  Exit:
   WebPFreeDecBuffer(output_buffer);
-  WebPFree((void*)external_buffer);
-  WebPFree((void*)data);
-  FREE_WARGV_AND_RETURN(ok ? 0 : -1);
+  free((void*)external_buffer);
+  free((void*)data);
+  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,79 +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_) {
-      WebPFree((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**)WebPMalloc(MAX_ARGC * sizeof(*args->argv_));
-    if (args->argv_ == NULL) {
-      ExUtilDeleteCommandLineArguments(args);
-      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);
-        ExUtilDeleteCommandLineArguments(args);
-        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");
@@ -96,12 +83,13 @@ static void Help(void) {
 
 //------------------------------------------------------------------------------
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   int verbose = 0;
   int gif_error = GIF_ERROR;
   WebPMuxError err = WEBP_MUX_OK;
   int ok = 0;
-  const W_CHAR* in_file = NULL, *out_file = NULL;
+  const 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);
           }
@@ -314,11 +301,8 @@ int main(int argc, const char* argv[]) {
           frame.use_argb = 1;
           if (!WebPPictureAlloc(&frame)) goto End;
           GIFClearPic(&frame, NULL);
-          if (!(WebPPictureCopy(&frame, &curr_canvas) &&
-                WebPPictureCopy(&frame, &prev_canvas))) {
-            fprintf(stderr, "Error allocating canvas.\n");
-            goto End;
-          }
+          WebPPictureCopy(&frame, &curr_canvas);
+          WebPPictureCopy(&frame, &prev_canvas);
 
           // Background color.
           GIFGetBackgroundColor(gif->SColorMap, gif->SBackGroundColor,
@@ -334,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.
@@ -350,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;
 
@@ -382,7 +355,7 @@ int main(int argc, const char* argv[]) {
       }
       case EXTENSION_RECORD_TYPE: {
         int extension;
-        GifByteType* data = NULL;
+        GifByteType *data = NULL;
         if (DGifGetExtension(gif, &extension, &data) == GIF_ERROR) {
           goto End;
         }
@@ -412,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.
@@ -468,25 +441,6 @@ int main(int argc, const char* argv[]) {
     fprintf(stderr, "%s\n", WebPAnimEncoderGetError(enc));
     goto End;
   }
-  // If there's only one frame, we don't need to handle loop count.
-  if (frame_number == 1) {
-    loop_count = 0;
-  } else if (!loop_compatibility) {
-    if (!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.
@@ -547,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) {
@@ -581,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);
@@ -593,12 +542,12 @@ int main(int argc, const char* argv[]) {
 #endif
   }
 
-  FREE_WARGV_AND_RETURN(!ok);
+  return !ok;
 }
 
 #else  // !WEBP_HAVE_GIF
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   fprintf(stderr, "GIF support not enabled in %s.\n", argv[0]);
   (void)argc;
   return 0;

examples/gifdec.c

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

examples/image_dec.c

@@ -11,24 +11,6 @@
 
 #include "./image_dec.h"
 
-const char* WebPGetEnabledInputFileFormats(void) {
-  return "WebP"
-#ifdef WEBP_HAVE_JPEG
-         ", JPEG"
-#endif
-#ifdef WEBP_HAVE_PNG
-         ", PNG"
-#endif
-         ", PNM (PGM, PPM, PAM)"
-#ifdef WEBP_HAVE_TIFF
-         ", TIFF"
-#endif
-#ifdef HAVE_WINCODEC_H
-         ", Windows Imaging Component (WIC)"
-#endif
-         "";
-}
-
 static WEBP_INLINE uint32_t GetBE32(const uint8_t buf[]) {
   return ((uint32_t)buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 }
@@ -47,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,13 +36,9 @@ typedef enum {
   WEBP_JPEG_FORMAT,
   WEBP_TIFF_FORMAT,
   WEBP_WEBP_FORMAT,
-  WEBP_PNM_FORMAT,
   WEBP_UNSUPPORTED_FORMAT
 } WebPInputFileFormat;
 
-// Returns a comma separated list of enabled input formats.
-const char* WebPGetEnabledInputFileFormats(void);
-
 // Try to infer the image format. 'data_size' should be larger than 12.
 // Returns WEBP_UNSUPPORTED_FORMAT if format can't be guess safely.
 WebPInputFileFormat WebPGuessImageType(const uint8_t* const data,
@@ -54,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);
 
@@ -67,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,325 +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_options] [[frame_options] frame_file]...\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");
-  printf("\nSupported input formats:\n  %s\n",
-         WebPGetEnabledInputFileFormats());
-}
-
-//------------------------------------------------------------------------------
-
-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);
-  WebPFree((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();
-        FREE_WARGV_AND_RETURN(0);
-      } 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,14 +266,12 @@ 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;
   ctx.data_size = data_size;
 
-  memset((j_decompress_ptr)&dinfo, 0, sizeof(dinfo));   // for setjmp safety
+  memset((j_decompress_ptr)&dinfo, 0, sizeof(dinfo));   // for setjmp sanity
   dinfo.err = jpeg_std_error(&jerr.pub);
   jerr.pub.error_exit = my_error_exit;
 
@@ -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;
   }
@@ -336,11 +333,7 @@ int ReadJPEG(const uint8_t* const data, size_t data_size,
   pic->width = width;
   pic->height = height;
   ok = WebPPictureImportRGB(pic, rgb, (int)stride);
-  if (!ok) {
-    pic->width = 0;   // WebPPictureImportRGB() barely touches 'pic' on failure.
-    pic->height = 0;  // Just reset dimensions but keep any 'custom_ptr' etc.
-    MetadataFree(metadata);  // In case the caller forgets to free it on error.
-  }
+  if (!ok) goto Error;
 
  End:
   free(rgb);

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,
@@ -133,7 +108,7 @@ static const struct {
                  MetadataPayload* const payload);
   size_t storage_offset;
 } kPNGMetadataMap[] = {
-  // https://exiftool.org/TagNames/PNG.html#TextualData
+  // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/PNG.html#TextualData
   // See also: ExifTool on CPAN.
   { "Raw profile type exif", ProcessRawProfile, METADATA_OFFSET(exif) },
   { "Raw profile type xmp",  ProcessRawProfile, METADATA_OFFSET(xmp) },
@@ -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);
@@ -259,15 +233,6 @@ int ReadPNG(const uint8_t* const data, size_t data_size,
     goto End;
   }
 
-#if LOCAL_PNG_PREREQ(1,5) || \
-    (LOCAL_PNG_PREREQ(1,4) && PNG_LIBPNG_VER_RELEASE >= 1)
-  // If it looks like the bitstream is going to need more memory than libpng's
-  // internal limit (default: 8M), try to (reasonably) raise it.
-  if (data_size > png_get_chunk_malloc_max(png) && data_size < (1u << 24)) {
-    png_set_chunk_malloc_max(png, data_size);
-  }
-#endif
-
   info = png_create_info_struct(png);
   if (info == NULL) goto Error;
   end_info = png_create_info_struct(png);
@@ -298,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;
@@ -325,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 {
@@ -46,7 +45,7 @@ static int ExtractMetadataFromTIFF(TIFF* const tif, Metadata* const metadata) {
         (MetadataPayload*)((uint8_t*)metadata +
                            kTIFFMetadataMap[i].storage_offset);
     void* tag_data;
-    uint32_t tag_data_len;
+    uint32 tag_data_len;
 
     if (TIFFGetField(tif, kTIFFMetadataMap[i].tag, &tag_data_len, &tag_data) &&
         !MetadataCopy((const char*)tag_data, tag_data_len, payload)) {
@@ -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,62 +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 image_width, image_height, tile_width, tile_height;
-  uint64_t stride;
-  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;
@@ -184,77 +140,35 @@ 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 == 1 || samples_per_px == 3 || samples_per_px == 4)) {
-    goto End;  // not supported
-  }
 
-  if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &image_width) &&
-        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &image_height))) {
+  if (!(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) &&
+        TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))) {
     fprintf(stderr, "Error! Cannot retrieve TIFF image dimensions.\n");
     goto End;
   }
-  stride = (uint64_t)image_width * sizeof(*raster);
-  if (!ImgIoUtilCheckSizeArgumentsOverflow(stride, image_height)) {
-    fprintf(stderr, "Error! TIFF image dimension (%d x %d) is too large.\n",
-            image_width, image_height);
+
+  if (!ImgIoUtilCheckSizeArgumentsOverflow((uint64_t)width * height,
+                                           sizeof(*raster))) {
     goto End;
   }
-
-  // According to spec, a tile can be bigger than the image. However it should
-  // be a multiple of 16 and not way too large, so check that it's not more
-  // than twice the image size, for dimensions above some arbitrary minimum
-  // 32. We also check that they respect WebP's dimension and memory limit.
-  // Note that a tile can be 6byte/px in some cases. Here we assume
-  // 4byte/px with sizeof(*raster), to be conservative.
-  if (TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width) &&
-      TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height)) {
-    if ((tile_width > 32 && tile_width / 2 > image_width) ||
-        (tile_height > 32 && tile_height / 2 > image_height) ||
-        !ImgIoUtilCheckSizeArgumentsOverflow(
-            (uint64_t)tile_width * sizeof(*raster), tile_height)) {
-      fprintf(stderr, "Error! TIFF tile dimension (%d x %d) is too large.\n",
-              tile_width, tile_height);
-      goto End;
-    }
-  }
-
-  if (samples_per_px > 3 && !TIFFGetField(tif, TIFFTAG_EXTRASAMPLES,
-                                          &extra_samples, &extra_samples_ptr)) {
-    fprintf(stderr, "Error! Cannot retrieve TIFF ExtraSamples info.\n");
-    goto End;
-  }
-
   // _Tiffmalloc uses a signed type for size.
-  alloc_size = (int64_t)(stride * image_height);
+  alloc_size = (int64_t)((uint64_t)width * height * sizeof(*raster));
   if (alloc_size < 0 || alloc_size != (tsize_t)alloc_size) goto End;
 
-  raster = (uint32_t*)_TIFFmalloc((tsize_t)alloc_size);
+  raster = (uint32*)_TIFFmalloc((tsize_t)alloc_size);
   if (raster != NULL) {
-    if (TIFFReadRGBAImageOriented(tif, image_width, image_height, raster,
+    if (TIFFReadRGBAImageOriented(tif, width, height, raster,
                                   ORIENTATION_TOPLEFT, 1)) {
-      pic->width = image_width;
-      pic->height = image_height;
+      const int stride = width * sizeof(*raster);
+      pic->width = width;
+      pic->height = height;
       // TIFF data is ABGR
 #ifdef WORDS_BIGENDIAN
-      TIFFSwabArrayOfLong(raster, image_width * image_height);
+      TIFFSwabArrayOfLong(raster, width * height);
 #endif
-      // if we have an alpha channel, we must un-multiply from rgbA to RGBA
-      if (extra_samples == 1 && extra_samples_ptr != NULL &&
-          extra_samples_ptr[0] == EXTRASAMPLE_ASSOCALPHA) {
-        uint32_t y;
-        uint8_t* tmp = (uint8_t*)raster;
-        for (y = 0; y < image_height; ++y) {
-          MultARGBRow(tmp, image_width);
-          tmp += stride;
-        }
-      }
       ok = keep_alpha
-         ? WebPPictureImportRGBA(pic, (const uint8_t*)raster, (int)stride)
-         : WebPPictureImportRGBX(pic, (const uint8_t*)raster, (int)stride);
+         ? WebPPictureImportRGBA(pic, (const uint8_t*)raster, stride)
+         : WebPPictureImportRGBX(pic, (const uint8_t*)raster, stride);
     }
     _TIFFfree(raster);
   } else {

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,116 +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_
-
-#include <stdio.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 <fcntl.h>
-#include <io.h>
-#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 WFPRINTF(STREAM, STR, ...)                    \
-  do {                                                \
-    int prev_mode;                                    \
-    fflush(STREAM);                                   \
-    prev_mode = _setmode(_fileno(STREAM), _O_U8TEXT); \
-    fwprintf(STREAM, TO_W_CHAR(STR), __VA_ARGS__);    \
-    fflush(STREAM);                                   \
-    (void)_setmode(_fileno(STREAM), prev_mode);       \
-  } while (0)
-#define WPRINTF(STR, ...) WFPRINTF(stdout, 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
-
-#include <string.h>
-
-// 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(STREAM, STR, ...) fprintf(STREAM, 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,76 +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();
@@ -292,21 +275,8 @@ static void PrintString(const char* const text) {
   }
 }
 
-static void PrintStringW(const char* const text) {
-#if defined(_WIN32) && defined(_UNICODE)
-  void* const font = GLUT_BITMAP_9_BY_15;
-  const W_CHAR* const wtext = (const W_CHAR*)text;
-  int i;
-  for (i = 0; wtext[i]; ++i) {
-    glutBitmapCharacter(font, wtext[i]);
-  }
-#else
-  PrintString(text);
-#endif
-}
-
 static float GetColorf(uint32_t color, int shift) {
-  return ((color >> shift) & 0xff) / 255.f;
+  return (color >> shift) / 255.f;
 }
 
 static void DrawCheckerBoard(void) {
@@ -329,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;
@@ -381,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;
@@ -409,7 +357,7 @@ static void HandleDisplay(void) {
 
     glColor4f(0.90f, 0.0f, 0.90f, 1.0f);
     glRasterPos2f(-0.95f, 0.90f);
-    PrintStringW(kParams.file_name);
+    PrintString(kParams.file_name);
 
     snprintf(tmp, sizeof(tmp), "Dimension:%d x %d", pic->width, pic->height);
     glColor4f(0.90f, 0.0f, 0.90f, 1.0f);
@@ -423,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);
@@ -461,59 +386,56 @@ 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[]) {
+int main(int argc, char *argv[]) {
   int c;
   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")) {
@@ -522,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);
@@ -536,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;
   }
 
@@ -578,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) {
@@ -634,16 +558,16 @@ 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
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   fprintf(stderr, "OpenGL support not enabled in %s.\n", argv[0]);
   (void)argc;
   return 0;

examples/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/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;
 }
@@ -134,10 +131,7 @@ static HRESULT ExtractICCP(IWICImagingFactory* const factory,
   IWICColorContext** color_contexts;
 
   IFS(IWICBitmapFrameDecode_GetColorContexts(frame, 0, NULL, &count));
-  if (FAILED(hr) || count == 0) {
-    // Treat unsupported operation as a non-fatal error. See crbug.com/webp/506.
-    return (hr == WINCODEC_ERR_UNSUPPORTEDOPERATION) ? S_OK : hr;
-  }
+  if (FAILED(hr) || count == 0) return hr;
 
   color_contexts = (IWICColorContext**)calloc(count, sizeof(*color_contexts));
   if (color_contexts == NULL) return E_OUTOFMEMORY;
@@ -273,22 +267,15 @@ int ReadPictureWithWIC(const char* const filename,
   WICPixelFormatGUID src_pixel_format = GUID_WICPixelFormatUndefined;
   const WICFormatImporter* importer = NULL;
   GUID src_container_format = GUID_NULL_;
-  // From Windows Kits\10\Include\10.0.19041.0\um\wincodec.h
-  WEBP_DEFINE_GUID(GUID_ContainerFormatWebp_,
-                   0xe094b0e2, 0x67f2, 0x45b3,
-                   0xb0, 0xea, 0x11, 0x53, 0x37, 0xca, 0x7c, 0xf3);
   static const GUID* kAlphaContainers[] = {
     &GUID_ContainerFormatBmp,
     &GUID_ContainerFormatPng,
     &GUID_ContainerFormatTiff,
-    &GUID_ContainerFormatWebp_,
     NULL
   };
   int has_alpha = 0;
   int64_t stride;
 
-  if (filename == NULL || pic == NULL) return 0;
-
   IFS(CoInitialize(NULL));
   IFS(CoCreateInstance(MAKE_REFGUID(CLSID_WICImagingFactory), NULL,
                        CLSCTX_INPROC_SERVER,
@@ -306,15 +293,9 @@ int ReadPictureWithWIC(const char* const filename,
           factory, stream, NULL,
           WICDecodeMetadataCacheOnDemand, &decoder));
   IFS(IWICBitmapDecoder_GetFrameCount(decoder, &frame_count));
-  if (SUCCEEDED(hr)) {
-    if (frame_count == 0) {
-      fprintf(stderr, "No frame found in input file.\n");
-      hr = E_FAIL;
-    } else if (frame_count > 1) {
-      // WIC will be tried before native WebP decoding so avoid duplicating the
-      // error message.
-      hr = E_FAIL;
-    }
+  if (SUCCEEDED(hr) && frame_count == 0) {
+    fprintf(stderr, "No frame found in input file.\n");
+    hr = E_FAIL;
   }
   IFS(IWICBitmapDecoder_GetFrame(decoder, 0, &frame));
   IFS(IWICBitmapFrameDecode_GetPixelFormat(frame, &src_pixel_format));

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,77 +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 0x0002    // 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);
-
-// Convert the ARGB content of 'pic' from associated to unassociated.
-// 'pic' can be for instance the result of calling of some WebPPictureImportXXX
-// functions, with pic->use_argb set to 'true'. It is assumed (and not checked)
-// that the pre-multiplied r/g/b values as less or equal than the alpha value.
-// Return false in case of error (invalid parameter, ...).
-WEBP_EXTERN int WebPUnmultiplyARGB(WebPPicture* pic);
-
-//------------------------------------------------------------------------------
-
-// Parse a bitstream, search for VP8 (lossy) header and report a
-// 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,356 +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"
-          "\nSupported input formats:\n  %s\n",
-          WebPGetEnabledInputFileFormats());
-}
-
-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_

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Thu May 12 17:06:25 CEST 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-bin.zip

gradlew

@@ -1,20 +1,4 @@
-#!/usr/bin/env sh
-
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
+#!/usr/bin/env bash
 
 ##############################################################################
 ##
@@ -44,16 +28,16 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+DEFAULT_JVM_OPTS=""
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
-warn () {
+warn ( ) {
     echo "$*"
 }
 
-die () {
+die ( ) {
     echo
     echo "$*"
     echo
@@ -125,8 +109,8 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
     JAVACMD=`cygpath --unix "$JAVACMD"`
@@ -154,30 +138,27 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=`expr $i + 1`
+        i=$((i+1))
     done
     case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
 }
-APP_ARGS=`save "$@"`
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-exec "$JAVACMD" "$@"
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

@@ -1,19 +1,3 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -30,7 +14,7 @@ set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+set DEFAULT_JVM_OPTS=
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
@@ -65,6 +49,7 @@ goto fail
 @rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -75,6 +60,11 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

imageio/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,615 +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 unused) {
-  (void)unused;  // 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 (see https://en.wikipedia.org/wiki/BMP_file_format#Pixel_storage)
-
-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
-#define BMP_HEADER_ALPHA_EXTRA_SIZE 16  // for alpha info
-int WebPWriteBMP(FILE* fout, const WebPDecBuffer* const buffer) {
-  const int has_alpha = WebPIsAlphaMode(buffer->colorspace);
-  const int header_size =
-      BMP_HEADER_SIZE + (has_alpha ? BMP_HEADER_ALPHA_EXTRA_SIZE : 0);
-  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 image_size = bmp_stride * height;
-  const uint32_t total_size =  image_size + header_size;
-  uint8_t bmp_header[BMP_HEADER_SIZE + BMP_HEADER_ALPHA_EXTRA_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, header_size);          // offset to pixel array
-  // bitmap info header
-  PutLE32(bmp_header + 14, header_size - 14);     // DIB header size
-  PutLE32(bmp_header + 18, width);                // dimensions
-  PutLE32(bmp_header + 22, height);               // no 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, has_alpha ? 3 : 0);    // BI_BITFIELDS or BI_RGB
-  PutLE32(bmp_header + 34, image_size);
-  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
-  if (has_alpha) {  // BITMAPV3INFOHEADER complement
-    PutLE32(bmp_header + 54, 0x00ff0000);         // red mask
-    PutLE32(bmp_header + 58, 0x0000ff00);         // green mask
-    PutLE32(bmp_header + 62, 0x000000ff);         // blue mask
-    PutLE32(bmp_header + 66, 0xff000000);         // alpha mask
-  }
-
-  // TODO(skal): color profile
-
-  // write header
-  if (fwrite(bmp_header, header_size, 1, fout) != 1) {
-    return 0;
-  }
-
-  // write pixel array, bottom to top
-  for (y = 0; y < height; ++y) {
-    const uint8_t* const src = &rgba[(uint64_t)(height - 1 - y) * stride];
-    if (fwrite(src, 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
-#undef BMP_HEADER_ALPHA_EXTRA_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: https://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,162 +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*)WebPMalloc(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);
-    WebPFree(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 stride, size_t height) {
-  const uint64_t total_size = stride * height;
-  int ok = (total_size == (size_t)total_size);
-  // check that 'stride' is representable as int:
-  ok = ok && ((uint64_t)(int)stride == stride);
-#if defined(WEBP_MAX_IMAGE_SIZE)
-  ok = ok && (total_size <= (uint64_t)WEBP_MAX_IMAGE_SIZE);
-#endif
-  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 WebPFree().
-// 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, memory over-allocation or excessive dimension.
-int ImgIoUtilCheckSizeArgumentsOverflow(uint64_t stride, size_t height);
-
-#ifdef __cplusplus
-}    // extern "C"
-#endif
-
-#endif  // WEBP_IMAGEIO_IMAGEIO_UTIL_H_

imageio/pnmdec.c

@@ -1,296 +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 = WIDTH_FLAG | HEIGHT_FLAG | DEPTH_FLAG | MAXVAL_FLAG
-} PNMFlags;
-
-typedef struct {
-  const uint8_t* data;
-  size_t data_size;
-  int width, height;
-  int bytes_per_px;
-  int depth;          // 1 (grayscale), 2 (grayscale + alpha), 3 (rgb), 4 (rgba)
-  int 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;
-  int expected_depth = -1;
-  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")) {
-      expected_depth = 4;
-      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "TUPLTYPE RGB")) {
-      expected_depth = 3;
-      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "TUPLTYPE GRAYSCALE_ALPHA")) {
-      expected_depth = 2;
-      info->seen_flags |= TUPLE_FLAG;
-    } else if (!strcmp(out, "TUPLTYPE GRAYSCALE")) {
-      expected_depth = 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) {
-        // isprint() might trigger a "char-subscripts" warning if given a char.
-        if (!isprint((int)out[i])) out[i] = ' ';
-      }
-      fprintf(stderr, "PAM header error: unrecognized entry [%s]\n", out);
-      return 0;
-    }
-  }
-  if (!(info->seen_flags & ALL_NEEDED_FLAGS)) {
-    fprintf(stderr, "PAM header error: missing tags%s%s%s%s\n",
-            (info->seen_flags & WIDTH_FLAG) ? "" : " WIDTH",
-            (info->seen_flags & HEIGHT_FLAG) ? "" : " HEIGHT",
-            (info->seen_flags & DEPTH_FLAG) ? "" : " DEPTH",
-            (info->seen_flags & MAXVAL_FLAG) ? "" : " MAXVAL");
-    return 0;
-  }
-  if (expected_depth != -1 && info->depth != expected_depth) {
-    fprintf(stderr, "PAM header error: expected DEPTH %d but got DEPTH %d\n",
-            expected_depth, info->depth);
-    return 0;
-  }
-  return off;
-}
-
-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;
-  }
-  // perform some basic numerical validation
-  if (info->width <= 0 || info->height <= 0 ||
-      info->type <= 0 || info->type >= 9 ||
-      info->depth <= 0 || info->depth > 4 ||
-      info->max_value <= 0 || info->max_value >= 65536) {
-    return 0;
-  }
-  info->bytes_per_px = info->depth * (info->max_value > 255 ? 2 : 1);
-  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, sample_size, depth;
-  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;
-  }
-  sample_size = (info.max_value > 255) ? 2 : 1;
-  // final depth
-  depth = (info.depth == 1 || info.depth == 3 || !keep_alpha) ? 3 : 4;
-  stride = depth * info.width;
-  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.
-  // We only optimize for the sample_size=1, max_value=255, depth=1 case.
-  tmp_rgb = rgb;
-  for (j = 0; j < info.height; ++j) {
-    const uint8_t* in = data + offset;
-    offset += info.bytes_per_px * info.width;
-    assert(offset <= data_size);
-    if (info.max_value == 255 && info.depth >= 3) {
-      // RGB or RGBA
-      if (info.depth == 3 || keep_alpha) {
-        memcpy(tmp_rgb, in, info.depth * info.width * sizeof(*in));
-      } else {
-        assert(info.depth == 4 && !keep_alpha);
-        for (i = 0; i < info.width; ++i) {
-          tmp_rgb[3 * i + 0] = in[4 * i + 0];
-          tmp_rgb[3 * i + 1] = in[4 * i + 1];
-          tmp_rgb[3 * i + 2] = in[4 * i + 2];
-        }
-      }
-    } else {
-      // Unoptimized case, we need to handle non-trivial operations:
-      //   * convert 16b to 8b (if max_value > 255)
-      //   * rescale to [0..255] range (if max_value != 255)
-      //   * drop the alpha channel (if keep_alpha is false)
-      const uint32_t round = info.max_value / 2;
-      int k = 0;
-      for (i = 0; i < info.width * info.depth; ++i) {
-        uint32_t v = (sample_size == 2) ? 256u * in[2 * i + 0] + in[2 * i + 1]
-                   : in[i];
-        if (info.max_value != 255) v = (v * 255u + round) / info.max_value;
-        if (v > 255u) v = 255u;
-        if (info.depth > 2) {
-          if (!keep_alpha && info.depth == 4 && (i % 4) == 3) {
-            // skip alpha
-          } else {
-            tmp_rgb[k] = v;
-            k += 1;
-          }
-        } else if (info.depth == 1 || (i % 2) == 0) {
-          tmp_rgb[k + 0] = tmp_rgb[k + 1] = tmp_rgb[k + 2] = v;
-          k += 3;
-        } else if (keep_alpha && info.depth == 2) {
-          tmp_rgb[k] = v;
-          k += 1;
-        } else {
-          // skip alpha
-        }
-      }
-    }
-    tmp_rgb += stride;
-  }
-
-  // WebP conversion.
-  pic->width = info.width;
-  pic->height = info.height;
-  ok = (depth == 4) ? WebPPictureImportRGBA(pic, rgb, (int)stride)
-                    : WebPPictureImportRGB(pic, rgb, (int)stride);
-  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) {
-    WebPFree((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 WebPIDecode().\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_

infra/common.sh

@@ -1,106 +0,0 @@
-# Copyright (c) 2021, Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#   * Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-#
-#   * Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in
-#     the documentation and/or other materials provided with the
-#     distribution.
-#
-#   * Neither the name of Google nor the names of its contributors may
-#     be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-log_err() {
-  echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')]: $*" >&2
-}
-
-#######################################
-# Create build directory. Build directory will be deleted if it exists.
-# Arguments:
-#   None.
-# Returns:
-#   mkdir result.
-#######################################
-make_build_dir() {
-  if [[ "$#" -ne 1 ]]; then
-    return 1
-  fi
-
-  local build_dir
-  build_dir="$1"
-  rm -rf "${build_dir}"
-  mkdir -p "${build_dir}"
-}
-
-#######################################
-# Cleanup files from the build directory.
-# Globals:
-#   LIBWEBP_ROOT repository's root path.
-# Arguments:
-#   $1 build directory.
-#######################################
-cleanup() {
-  # $1 is not completely removed to allow for binary artifacts to be
-  # extracted.
-  find "${1:?"Build directory not defined"}" \
-    \( -name "*.[ao]" -o -name "*.l[ao]" \) -exec rm -f {} +
-}
-
-#######################################
-# Setup ccache for toolchain.
-# Globals:
-#   PATH
-# Arguments:
-#   None.
-#######################################
-setup_ccache() {
-  if [[ -x "$(command -v ccache)" ]]; then
-    export CCACHE_CPP2=yes
-    export PATH="/usr/lib/ccache:${PATH}"
-  fi
-}
-
-#######################################
-# Detects whether test block should be run in the current test shard.
-# Globals:
-#   TEST_TOTAL_SHARDS: Valid range: [1, N]. Defaults to 1.
-#   TEST_SHARD_INDEX: Valid range: [0, TEST_TOTAL_SHARDS). Defaults to 0.
-#   libwebp_test_id: current test number; incremented with each call.
-# Arguments:
-#   None
-# Returns:
-#   true if the shard is active
-#   false if the shard is inactive
-#######################################
-shard_should_run() {
-  TEST_TOTAL_SHARDS=${TEST_TOTAL_SHARDS:=1}
-  TEST_SHARD_INDEX=${TEST_SHARD_INDEX:=0}
-  libwebp_test_id=${libwebp_test_id:=-1}
-  : $((libwebp_test_id += 1))
-
-  if [[ "${TEST_SHARD_INDEX}" -lt 0 ||
-    "${TEST_SHARD_INDEX}" -ge "${TEST_TOTAL_SHARDS}" ]]; then
-    log_err "Invalid TEST_SHARD_INDEX (${TEST_SHARD_INDEX})!" \
-      "Expected [0, ${TEST_TOTAL_SHARDS})."
-  fi
-
-  [[ "$((libwebp_test_id % TEST_TOTAL_SHARDS))" -eq "${TEST_SHARD_INDEX}" ]]
-}

infra/compile.sh

@@ -1,401 +0,0 @@
-#!/bin/bash
-# Copyright (c) 2021, Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#   * Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-#
-#   * Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in
-#     the documentation and/or other materials provided with the
-#     distribution.
-#
-#   * Neither the name of Google nor the names of its contributors may
-#     be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-set -xe
-LIBWEBP_ROOT="$(realpath "$(dirname "$0")/..")"
-WORKSPACE=${WORKSPACE:-"$(mktemp -d -t webp.XXX)"}
-
-# shellcheck source=infra/common.sh
-source "${LIBWEBP_ROOT}/infra/common.sh"
-
-usage() {
-  cat << EOF
-Usage: compile.sh BUILD_TYPE TARGET
-Options:
-BUILD_TYPE  supported build type: (shared, static, static-debug)
-TARGET      supported target platforms:
-              aarch64-linux-clang
-              aarch64-linux-gnu
-              arm-linux-gnueabi
-              arm-neon-linux-gnueabi
-              cmake
-              cmake-aarch64
-              cmake-arm
-              cmake-clang
-              disable-near-lossless
-              disable-sse4.1
-              disable-stats
-              force-aligned-32
-              force-aligned-64
-              gradle
-              i686-linux-asan
-              i686-linux-clang
-              i686-linux-gnu
-              i686-w64-mingw32
-              mips2el-linux-gnu
-              mips32dspr2el-linux-gnu
-              mips32eb-linux-gnu
-              mips32el-linux-gnu
-              mips32r2el-linux-gnu
-              mips32r5el-linux-gnu
-              mips64r2el-linux-gnu
-              mips64r6el-linux-gnu
-              native
-              reduce-csp
-              reduce-size
-              reduce-size-disable-stats
-              visibility-default-gnu
-              visibility-hidden-clang
-              visibility-hidden-gnu
-              wasm
-              x86_64-linux-clang
-              x86_64-linux-gnu
-              x86_64-linux-msan
-              x86_64-w64-mingw32
-Environment variables:
-WORKSPACE   directory where the build is done
-EOF
-}
-
-################################################################################
-echo "Building libwebp in ${WORKSPACE}"
-
-if [[ ! -d "${WORKSPACE}" ]]; then
-  log_err "${WORKSPACE} directory does not exist"
-  exit 1
-fi
-
-BUILD_TYPE=${1:?"Build type not defined.$(
-  echo
-  usage
-)"}
-TARGET=${2:?"Target not defined.$(
-  echo
-  usage
-)"}
-readonly BUILD_DIR="${WORKSPACE}/build-${BUILD_TYPE}"
-
-trap 'cleanup ${BUILD_DIR}' EXIT
-make_build_dir "${BUILD_DIR}"
-
-config_flags=()
-case "${BUILD_TYPE}" in
-  shared*) ;;  # Valid BUILD_TYPE but no setup required
-  static*) config_flags+=("--disable-shared") ;;
-  experimental) config_flags+=("--enable-experimental") ;;
-  *)
-    log_err "Invalid BUILD_TYPE"
-    usage
-    exit 1
-    ;;
-esac
-
-if grep -m 1 -q "enable-asserts" "${LIBWEBP_ROOT}/configure.ac"; then
-  config_flags+=("--enable-asserts")
-fi
-
-case "${TARGET}" in
-  aarch64-linux-clang)
-    TARGET="aarch64-linux-gnu"
-    CC="clang"
-    CC="${CC} --target=aarch64-linux-gnu"
-    export CC
-    export CFLAGS="-isystem /usr/aarch64-linux-gnu/include"
-    ;;
-  arm-linux-gnueabi)
-    export CFLAGS="-O3 -march=armv7-a -mfloat-abi=softfp -ftree-vectorize"
-    ;;
-  arm-neon-linux-gnueabi)
-    TARGET="arm-linux-gnueabi"
-    CFLAGS="-O3 -march=armv7-a -mfpu=neon -mfloat-abi=softfp -ftree-vectorize"
-    export CFLAGS
-    ;;
-  mips2el-linux-gnu)
-    export CFLAGS="-EL -O2 -mips2"
-    TARGET="mipsel-linux-gnu"
-    ;;
-  mips32el-linux-gnu)
-    export CFLAGS="-EL -O2 -mips32"
-    TARGET="mipsel-linux-gnu"
-    ;;
-  mips32r2el-linux-gnu)
-    export CFLAGS="-EL -O2 -mips32r2"
-    TARGET="mipsel-linux-gnu"
-    ;;
-  mips32dspr2el-linux-gnu)
-    export CFLAGS="-EL -O2 -mdspr2"
-    TARGET="mipsel-linux-gnu"
-    ;;
-  mips32r5el-linux-gnu)
-    export CFLAGS="-EL -O2 -mips32r5 -mmsa"
-    TARGET="mipsel-linux-gnu"
-    ;;
-  mips32eb-linux-gnu)
-    export CFLAGS="-EB -O2 -mips32"
-    TARGET="mips-linux-gnu"
-    ;;
-  mips64r2el-linux-gnu)
-    export CFLAGS="-EL -O2 -mips64r2 -mabi=64"
-    TARGET="mips64el-linux-gnuabi64"
-    ;;
-  mips64r6el-linux-gnu)
-    export CFLAGS="-EL -O2 -mips64r6 -mabi=64 -mmsa"
-    TARGET="mips-img-linux-gnu"
-    ;;
-  i686-linux-gnu)
-    export CC="gcc -m32"
-    ;;
-  i686-linux-clang)
-    TARGET="i686-linux-gnu"
-    export CC="clang -m32"
-    ;;
-  i686-linux-asan)
-    TARGET="i686-linux-gnu"
-    export CC="clang -m32 -fsanitize=address"
-    ;;
-  i686-linux-msan)
-    TARGET="i686-linux-gnu"
-    export CC="clang -m32 -fsanitize=memory"
-    ;;
-  x86_64-linux-clang)
-    TARGET="x86_64-linux-gnu"
-    export CC=clang
-    ;;
-  x86_64-linux-msan)
-    TARGET="x86_64-linux-gnu"
-    export CC="clang -fsanitize=memory"
-    ;;
-  force-aligned-32)
-    config_flags+=("--enable-aligned")
-    TARGET="i686-linux-gnu"
-    export CC="gcc -m32"
-    ;;
-  force-aligned-64)
-    config_flags+=("--enable-aligned")
-    TARGET="x86_64-linux-gnu"
-    ;;
-  visibility-default-*)
-    export CFLAGS="-O2 -g -fvisibility=default"
-    TARGET="x86_64-linux-gnu"
-    ;;
-  visibility-hidden-*)
-    export CFLAGS="-O2 -g -fvisibility=hidden"
-    if [[ "${TARGET}" = "visibility-hidden-clang" ]]; then
-      export CC=clang
-    fi
-    TARGET="x86_64-linux-gnu"
-    ;;
-  disable-sse4.1)
-    grep "${TARGET}" "${LIBWEBP_ROOT}/configure.ac" || exit 0
-    config_flags+=("--${TARGET}")
-    TARGET="x86_64-linux-gnu"
-    ;;
-  disable-near-lossless)
-    grep "${TARGET}" "${LIBWEBP_ROOT}/configure.ac" || exit 0
-    config_flags+=("--${TARGET}")
-    TARGET="x86_64-linux-gnu"
-    ;;
-  disable-stats)
-    git -C "${LIBWEBP_ROOT}" grep WEBP_DISABLE_STATS || exit 0
-    export CFLAGS="-O2 -g -DWEBP_DISABLE_STATS"
-    TARGET="x86_64-linux-gnu"
-    ;;
-  reduce-size)
-    git -C "${LIBWEBP_ROOT}" grep WEBP_REDUCE_SIZE || exit 0
-    export CFLAGS="-O2 -g -DWEBP_REDUCE_SIZE"
-    TARGET="x86_64-linux-gnu"
-    ;;
-  reduce-size-disable-stats)
-    git -C "${LIBWEBP_ROOT}" grep -e WEBP_DISABLE_STATS -e WEBP_REDUCE_SIZE \
-      || exit 0
-    export CFLAGS="-O2 -g -DWEBP_DISABLE_STATS -DWEBP_REDUCE_SIZE"
-    TARGET="x86_64-linux-gnu"
-    ;;
-  reduce-csp)
-    git -C "${LIBWEBP_ROOT}" grep WEBP_REDUCE_CSP || exit 0
-    export CFLAGS="-O2 -g -DWEBP_REDUCE_CSP"
-    TARGET="x86_64-linux-gnu"
-    ;;
-  x86_64-linux-gnu | *mingw32 | aarch64*) ;;  # Default target configuration
-  # non-configure based builds
-  native)
-    setup_ccache
-    # exercise makefile.unix then quit
-    make -C "${LIBWEBP_ROOT}" -f makefile.unix -j all
-    for tgt in extras examples/anim_diff; do
-      grep -q -m 1 "${tgt}" "${LIBWEBP_ROOT}/makefile.unix" \
-        && make -C "${LIBWEBP_ROOT}" -f makefile.unix -j "${tgt}"
-    done
-    [[ -d "${LIBWEBP_ROOT}/tests/fuzzer" ]] \
-      && make -j -C "${LIBWEBP_ROOT}/tests/fuzzer" -f makefile.unix
-    exit 0
-    ;;
-  cmake*)
-    setup_ccache
-    # exercise cmake then quit
-    opts=()
-    case "${TARGET}" in
-      cmake-clang)
-        opts+=("-DCMAKE_C_COMPILER=clang")
-        ;;
-      cmake-arm)
-        opts+=("-DCMAKE_C_COMPILER=arm-linux-gnueabi-gcc")
-        case "${GERRIT_BRANCH:-}" in
-          portable-intrinsics | 0.6.1) exit 0 ;;
-          *) ;;  # Skip configuration
-        esac
-        ;;
-      cmake-aarch64)
-        opts+=("-DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc")
-        case "${GERRIT_BRANCH:-}" in
-          portable-intrinsics | 0.6.1) exit 0 ;;
-          *) ;;  # Skip configuration
-        esac
-        ;;
-      *) ;;  # Skip configuration
-    esac
-    case "${BUILD_TYPE}" in
-      static*)
-        opts+=("-DBUILD_SHARED_LIBS=OFF")
-        ;;
-      experimental)
-        opts+=("-DWEBP_EXPERIMENTAL_FEATURES=ON" "-DBUILD_SHARED_LIBS=ON")
-        ;;
-      *)
-        opts+=("-DBUILD_SHARED_LIBS=ON")
-        ;;
-    esac
-    case "${BUILD_TYPE}" in
-      *debug) opts+=("-DCMAKE_BUILD_TYPE=Debug") ;;
-      *) opts+=("-DCMAKE_BUILD_TYPE=RelWithDebInfo") ;;
-    esac
-    cd "${BUILD_DIR}"
-    opts+=("-DWEBP_BUILD_CWEBP=ON" "-DWEBP_BUILD_DWEBP=ON")
-    grep -m 1 -q WEBP_BUILD_GIF2WEBP "${LIBWEBP_ROOT}/CMakeLists.txt" \
-      && opts+=("-DWEBP_BUILD_GIF2WEBP=ON")
-    grep -m 1 -q WEBP_BUILD_IMG2WEBP "${LIBWEBP_ROOT}/CMakeLists.txt" \
-      && opts+=("-DWEBP_BUILD_IMG2WEBP=ON")
-    cmake "${opts[@]}" "${LIBWEBP_ROOT}"
-    make VERBOSE=1 -j
-    case "${BUILD_TYPE}" in
-      static)
-        mkdir -p examples
-        cp [cd]webp examples
-        ;;
-      *) ;;  # Skip configuration.
-    esac
-
-    grep "install" "${LIBWEBP_ROOT}/CMakeLists.txt" || exit 0
-
-    make DESTDIR="${BUILD_DIR}/webp-install" install/strip
-    mkdir tmp
-    cd tmp
-    cat > CMakeLists.txt << EOF
-cmake_minimum_required(VERSION 2.8.7)
-
-project(libwebp C)
-
-find_package(WebP)
-if (NOT WebP_FOUND)
-  message(FATAL_ERROR "WebP package not found")
-endif ()
-message("WebP_FOUND: \${WebP_FOUND}")
-message("WebP_INCLUDE_DIRS: \${WebP_INCLUDE_DIRS}")
-message("WebP_LIBRARIES: \${WebP_LIBRARIES}")
-message("WEBP_INCLUDE_DIRS: \${WEBP_INCLUDE_DIRS}")
-message("WEBP_LIBRARIES: \${WEBP_LIBRARIES}")
-EOF
-    cmake . "${opts[@]}" \
-      "-DCMAKE_PREFIX_PATH=${BUILD_DIR}/webp-install/usr/local"
-    exit 0
-    ;;
-  gradle)
-    setup_ccache
-    # exercise gradle then quit
-    [[ -f "${LIBWEBP_ROOT}/gradlew" ]] || exit 0
-
-    cd "${BUILD_DIR}"
-    # TODO -g / --gradle-user-home could be used if there's a race between jobs
-    "${LIBWEBP_ROOT}/gradlew" -p "${LIBWEBP_ROOT}" buildAllExecutables
-    exit 0
-    ;;
-  wasm)
-    grep -m 1 -q WEBP_ENABLE_WASM "${LIBWEBP_ROOT}/CMakeLists.txt" || exit 0
-    opts+=("-DCMAKE_C_COMPILER=clang" "-DWEBP_ENABLE_WASM=ON")
-    opts+=("-DWEBP_BUILD_CWEBP=ON" "-DWEBP_BUILD_DWEBP=ON")
-    case "${BUILD_TYPE}" in
-      *debug) opts+=("-DCMAKE_BUILD_TYPE=Debug") ;;
-      *) opts+=("-DCMAKE_BUILD_TYPE=RelWithDebInfo") ;;
-    esac
-    cd "${BUILD_DIR}"
-    cmake "${opts[@]}" "${LIBWEBP_ROOT}"
-    make VERBOSE=1 -j
-    mkdir examples
-    case "${BUILD_TYPE}" in
-      static)
-        mkdir -p examples
-        cp [cd]webp examples
-        ;;
-      *) ;;  # Skip configuration
-    esac
-    exit 0
-    ;;
-  *)
-    log_err "Invalid TARGET"
-    usage
-    exit 1
-    ;;
-esac
-
-case "${TARGET}" in
-  *mingw32) ;;  # Skip configuration
-  *)
-    case "${TARGET}-${CC}" in
-      static-debug-gcc* | static-debug-)
-        CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage -O0 -g"
-        CXXFLAGS="${CXXFLAGS} -fprofile-arcs -ftest-coverage -O0 -g"
-        export CFLAGS CXXFLAGS
-        ;;
-      *) ;;  # This case should not be reached.
-    esac
-    ;;
-esac
-
-setup_ccache
-
-cd "${LIBWEBP_ROOT}"
-./autogen.sh
-
-cd "${BUILD_DIR}"
-"${LIBWEBP_ROOT}/configure" \
-  --host "${TARGET}" --build "$("${LIBWEBP_ROOT}/config.guess")" \
-  --enable-everything "${config_flags[@]}"
-make -j V=1

infra/compile_android.sh

@@ -1,224 +0,0 @@
-#!/bin/bash
-# Copyright (c) 2021, Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#   * Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-#
-#   * Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in
-#     the documentation and/or other materials provided with the
-#     distribution.
-#
-#   * Neither the name of Google nor the names of its contributors may
-#     be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-set -xe
-LIBWEBP_ROOT="$(realpath "$(dirname "$0")/..")"
-readonly LIBWEBP_ROOT
-readonly WORKSPACE=${WORKSPACE:-"$(mktemp -d -t webp.android.XXX)"}
-# shellcheck source=infra/common.sh
-source "${LIBWEBP_ROOT}/infra/common.sh"
-
-usage() {
-  cat << EOF
-Usage: $(basename "$0") BUILD_TYPE APP_ABI
-Options:
-BUILD_TYPE  supported build types:
-              static
-              static-debug
-              shared
-              shared-debug
-APP_ABI     supported application binary interfaces:
-              armeabi-v7a
-              arm64-v8a
-              x86
-              x86_64
-Environment variables:
-WORKSPACE   directory where the build is done.
-ANDROID_NDK_DIR directory where the android ndk tools are.
-EOF
-}
-
-################################################################################
-echo "Building libwebp for Android in ${WORKSPACE}"
-
-if [[ ! -d "${WORKSPACE}" ]]; then
-  log_err "${WORKSPACE} directory does not exist."
-  exit 1
-fi
-
-readonly BUILD_TYPE=${1:?"BUILD_TYPE is not defined.$(
-  echo
-  usage
-)"}
-readonly APP_ABI=${2:?"APP_ABI not defined.$(
-  echo
-  usage
-)"}
-readonly ANDROID_NDK_DIR=${ANDROID_NDK_DIR:?"ANDROID_NDK_DIR is not defined.$(
-  echo
-  usage
-)"}
-readonly BUILD_DIR="${WORKSPACE}/build-${BUILD_TYPE}"
-readonly STANDALONE_ANDROID_DIR="${WORKSPACE}/android"
-
-if [[ ! -x "${ANDROID_NDK_DIR}/ndk-build" ]]; then
-  log_err "unable to find ndk-build in ANDROID_NDK_DIR: ${ANDROID_NDK_DIR}."
-  exit 1
-fi
-
-CFLAGS=
-LDFLAGS=
-opts=()
-case "${BUILD_TYPE}" in
-  *debug)
-    readonly APP_OPTIM="debug"
-    CFLAGS="-O0 -g"
-    opts+=("--enable-asserts")
-    ;;
-  static* | shared*)
-    readonly APP_OPTIM="release"
-    CFLAGS="-O2 -g"
-    ;;
-  *)
-    usage
-    exit 1
-    ;;
-esac
-
-case "${BUILD_TYPE}" in
-  shared*) readonly SHARED="1" ;;
-  *)
-    readonly SHARED="0"
-    CFLAGS="${CFLAGS} -fPIE"
-    LDFLAGS="${LDFLAGS} -Wl,-pie"
-    opts+=("--disable-shared")
-    ;;
-esac
-
-# Create a fresh build directory
-make_build_dir "${BUILD_DIR}"
-cd "${BUILD_DIR}"
-ln -s "${LIBWEBP_ROOT}" jni
-
-"${ANDROID_NDK_DIR}/ndk-build" -j2 \
-  APP_ABI="${APP_ABI}" \
-  APP_OPTIM="${APP_OPTIM}" \
-  ENABLE_SHARED="${SHARED}"
-
-cd "${LIBWEBP_ROOT}"
-./autogen.sh
-
-case "${APP_ABI}" in
-  armeabi*) arch="arm" ;;
-  arm64*) arch="arm64" ;;
-  *) arch="${APP_ABI}" ;;
-esac
-# TODO(b/185520507): remove this and use the binaries from
-# toolchains/llvm/prebuilt/ directly.
-rm -rf "${STANDALONE_ANDROID_DIR}"
-"${ANDROID_NDK_DIR}/build/tools/make_standalone_toolchain.py" \
-  --api 24 --arch "${arch}" --stl gnustl --install-dir \
-  "${STANDALONE_ANDROID_DIR}"
-export PATH="${STANDALONE_ANDROID_DIR}/bin:${PATH}"
-
-rm -rf "${BUILD_DIR}"
-make_build_dir "${BUILD_DIR}"
-cd "${BUILD_DIR}"
-
-case "${arch}" in
-  arm)
-    host="arm-linux-androideabi"
-    case "${APP_ABI}" in
-      armeabi) ;;
-      armeabi-v7a)
-        CFLAGS="${CFLAGS} -march=armv7-a -mfpu=neon -mfloat-abi=softfp"
-        ;;
-      *) ;;  # No configuration needed
-    esac
-    ;;
-  arm64)
-    host="aarch64-linux-android"
-    ;;
-  x86)
-    host="i686-linux-android"
-    ;;
-  x86_64)
-    host="x86_64-linux-android"
-    ;;
-  *) ;;  # Skip configuration
-esac
-
-setup_ccache
-CC="clang"
-
-"${LIBWEBP_ROOT}/configure" --host "${host}" --build \
-  "$("${LIBWEBP_ROOT}/config.guess")" CC="${CC}" CFLAGS="${CFLAGS}" \
-  LDFLAGS="${LDFLAGS}" "${opts[@]}"
-make -j
-
-if [[ "${GERRIT_REFSPEC:-}" = "refs/heads/portable-intrinsics" ]] \
-  || [[ "${GERRIT_BRANCH:-}" = "portable-intrinsics" ]]; then
-  cd "${WORKSPACE}"
-  rm -rf build && mkdir build
-  cd build
-  standalone="${WORKSPACE}/android"
-  cmake ../libwebp \
-    -DWEBP_BUILD_DWEBP=1 \
-    -DCMAKE_C_COMPILER="${standalone}/bin/clang" \
-    -DCMAKE_PREFIX_PATH="${standalone}/sysroot/usr/lib" \
-    -DCMAKE_C_FLAGS=-fPIE \
-    -DCMAKE_EXE_LINKER_FLAGS=-Wl,-pie \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DWEBP_ENABLE_WASM=1
-  make -j2
-
-  cd "${WORKSPACE}"
-  make_build_dir "${BUILD_DIR}"
-  cd "${BUILD_DIR}"
-  case "${APP_ABI}" in
-    armeabi-v7a | arm64*)
-      cmake "${LIBWEBP_ROOT}" \
-        -DWEBP_BUILD_DWEBP=1 \
-        -DCMAKE_C_COMPILER="${standalone}/bin/clang" \
-        -DCMAKE_PREFIX_PATH="${standalone}/sysroot/usr/lib" \
-        -DCMAKE_C_FLAGS='-fPIE -DENABLE_NEON_BUILTIN_MULHI_INT16X8' \
-        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-pie \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DWEBP_ENABLE_WASM=1
-      make -j2
-      ;;
-    x86*)
-      cmake "${LIBWEBP_ROOT}" \
-        -DWEBP_BUILD_DWEBP=1 \
-        -DCMAKE_C_COMPILER="${standalone}/bin/clang" \
-        -DCMAKE_PREFIX_PATH="${standalone}/sysroot/usr/lib" \
-        -DCMAKE_C_FLAGS='-fPIE -DENABLE_X86_BUILTIN_MULHI_INT16X8' \
-        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-pie \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DWEBP_ENABLE_WASM=1
-      make -j2
-      ;;
-    *)
-      log_err "APP_ABI not supported."
-      exit 1
-      ;;
-  esac
-fi

infra/compile_js.sh

@@ -1,75 +0,0 @@
-#!/bin/bash
-# Copyright (c) 2021, Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#   * Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-#
-#   * Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in
-#     the documentation and/or other materials provided with the
-#     distribution.
-#
-#   * Neither the name of Google nor the names of its contributors may
-#     be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-set -ex
-
-readonly WORKSPACE="${WORKSPACE:-"$(mktemp -d -t webp.js.XXX)"}"
-readonly BUILD_DIR="${WORKSPACE}/webp_js/"
-readonly LIBWEBP_ROOT="$(realpath "$(dirname "$0")/..")"
-
-# shellcheck source=infra/common.sh
-source "${LIBWEBP_ROOT}/infra/common.sh"
-
-usage() {
-  cat << EOF
-Usage: $(basename "$0")
-Environment variables:
-WORKSPACE directory where the build is done
-EMSDK_DIR directory where emsdk is installed
-EOF
-}
-
-[[ -d "${EMSDK_DIR:?Not defined}" ]] \
-  || (log_err "${EMSDK_DIR} is not a valid directory." && exit 1)
-
-# shellcheck source=/opt/emsdk/emsdk_env.sh
-source "${EMSDK_DIR}/emsdk_env.sh"
-
-readonly EMSCRIPTEN=${EMSCRIPTEN:-"${EMSDK}/upstream/emscripten"}
-readonly \
-  EMSCRIPTEN_CMAKE_FILE="${EMSCRIPTEN}/cmake/Modules/Platform/Emscripten.cmake"
-make_build_dir "${BUILD_DIR}"
-
-pushd "${BUILD_DIR}"
-opts=("-GUnix Makefiles" "-DWEBP_BUILD_WEBP_JS=ON")
-if [[ -z "$(command -v emcmake)" ]]; then
-  opts+=("-DCMAKE_TOOLCHAIN_FILE=${EMSCRIPTEN_CMAKE_FILE}")
-  cmake \
-    "${opts[@]}" \
-    "${LIBWEBP_ROOT}"
-  make -j
-else
-  emcmake cmake \
-    "${opts[@]}" \
-    "${LIBWEBP_ROOT}"
-  emmake make -j
-fi
-popd

infra/run_static_analysis.sh

@@ -1,98 +0,0 @@
-#!/bin/bash
-# Copyright (c) 2021, Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#   * Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-#
-#   * Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in
-#     the documentation and/or other materials provided with the
-#     distribution.
-#
-#   * Neither the name of Google nor the names of its contributors may
-#     be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-set -xe
-
-LIBWEBP_ROOT="$(realpath "$(dirname "$0")/..")"
-readonly LIBWEBP_ROOT
-readonly WORKSPACE=${WORKSPACE:-"$(mktemp -d -t webp.scanbuild.XXX)"}
-
-# shellcheck source=infra/common.sh
-source "${LIBWEBP_ROOT}/infra/common.sh"
-
-usage() {
-  cat << EOF
-Usage: $(basename "$0") MODE
-Options:
-MODE supported scan modes: (shallow|deep)
-Environment variables:
-WORKSPACE directory where the build is done.
-EOF
-}
-
-#######################################
-# Wrap clang-tools scan-build.
-# Globals:
-#   OUTPUT_DIR target directory where scan-build report is generated.
-#   MODE scan-build mode
-# Arguments:
-#   $* scan-build additional args.
-# Returns:
-#   scan-build retcode
-#######################################
-scan_build() {
-  scan-build -o "${OUTPUT_DIR}" --use-analyzer="$(command -v clang)" \
-    -analyzer-config mode="${MODE}" "$*"
-}
-
-MODE=${1:?"MODE is not specified.$(
-  echo
-  usage
-)"}
-
-readonly OUTPUT_DIR="${WORKSPACE}/output-${MODE}"
-readonly BUILD_DIR="${WORKSPACE}/build"
-
-make_build_dir "${OUTPUT_DIR}"
-make_build_dir "${BUILD_DIR}"
-
-cd "${LIBWEBP_ROOT}"
-./autogen.sh
-
-cd "${BUILD_DIR}"
-grep -m 1 -q 'enable-asserts' "${LIBWEBP_ROOT}/configure.ac" \
-    && args='--enable-asserts'
-scan_build "${LIBWEBP_ROOT}/configure" --enable-everything "${args}"
-scan_build make -j4
-
-index="$(find "${OUTPUT_DIR}" -name index.html)"
-if [[ -f "${index}" ]]; then
-  mv "$(dirname "${index}")/"* "${OUTPUT_DIR}"
-else
-  # make a empty report to wipe out any old bug reports.
-  cat << EOT > "${OUTPUT_DIR}/index.html"
-<html>
-<body>
-No bugs reported.
-</body>
-</html>
-EOT
-fi

iosbuild.sh

@@ -1,21 +1,17 @@
 #!/bin/bash
 #
-# This script generates 'WebP.framework' and 'WebPDecoder.framework',
-# 'WebPDemux.framework' and 'WebPMux.framework'.
-# An iOS app can decode WebP images by including 'WebPDecoder.framework' and
-# both encode and decode WebP images by including 'WebP.framework'.
+# This script generates 'WebP.framework' and 'WebPDecoder.framework'. An iOS
+# app can decode WebP images by including 'WebPDecoder.framework' and both
+# encode and decode WebP images by including 'WebP.framework'.
 #
 # Run ./iosbuild.sh to generate the frameworks under the current directory
 # (the previous build will be erased if it exists).
 #
 # This script is inspired by the build script written by Carson McDonald.
-# (https://www.ioncannon.net/programming/1483/using-webp-to-reduce-native-ios-app-size/).
+# (http://www.ioncannon.net/programming/1483/using-webp-to-reduce-native-ios-app-size/).
 
 set -e
 
-# Set this variable based on the desired minimum deployment target.
-readonly IOS_MIN_VERSION=6.0
-
 # Extract the latest SDK version from the final field of the form: iphoneosX.Y
 readonly SDK=$(xcodebuild -showsdks \
   | grep iphoneos | sort | tail -n 1 | awk '{print substr($NF, 9)}'
@@ -39,55 +35,35 @@ readonly TOPDIR=$(pwd)
 readonly BUILDDIR="${TOPDIR}/iosbuild"
 readonly TARGETDIR="${TOPDIR}/WebP.framework"
 readonly DECTARGETDIR="${TOPDIR}/WebPDecoder.framework"
-readonly MUXTARGETDIR="${TOPDIR}/WebPMux.framework"
-readonly DEMUXTARGETDIR="${TOPDIR}/WebPDemux.framework"
 readonly DEVELOPER=$(xcode-select --print-path)
 readonly PLATFORMSROOT="${DEVELOPER}/Platforms"
 readonly LIPO=$(xcrun -sdk iphoneos${SDK} -find lipo)
 LIBLIST=''
 DECLIBLIST=''
-MUXLIBLIST=''
-DEMUXLIBLIST=''
 
 if [[ -z "${SDK}" ]]; then
   echo "iOS SDK not available"
   exit 1
 elif [[ ${SDK%%.*} -gt 8 ]]; then
   EXTRA_CFLAGS="-fembed-bitcode"
-elif [[ ${SDK%%.*} -le 6 ]]; then
+elif [[ ${SDK} < 6.0 ]]; then
   echo "You need iOS SDK version 6.0 or above"
   exit 1
+else
+  echo "iOS SDK Version ${SDK}"
 fi
 
-echo "Xcode Version: ${XCODE}"
-echo "iOS SDK Version: ${SDK}"
-
-if [[ -e "${BUILDDIR}" || -e "${TARGETDIR}" || -e "${DECTARGETDIR}" \
-      || -e "${MUXTARGETDIR}" || -e "${DEMUXTARGETDIR}" ]]; then
-  cat << EOF
-WARNING: The following directories will be deleted:
-WARNING:   ${BUILDDIR}
-WARNING:   ${TARGETDIR}
-WARNING:   ${DECTARGETDIR}
-WARNING:   ${MUXTARGETDIR}
-WARNING:   ${DEMUXTARGETDIR}
-WARNING: The build will continue in 5 seconds...
-EOF
-  sleep 5
-fi
-rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR} \
-    ${MUXTARGETDIR} ${DEMUXTARGETDIR}
-mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/ \
-    ${MUXTARGETDIR}/Headers/ ${DEMUXTARGETDIR}/Headers/
+rm -rf ${BUILDDIR} ${TARGETDIR} ${DECTARGETDIR}
+mkdir -p ${BUILDDIR} ${TARGETDIR}/Headers/ ${DECTARGETDIR}/Headers/
 
 if [[ ! -e ${SRCDIR}/configure ]]; then
   if ! (cd ${SRCDIR} && sh autogen.sh); then
-    cat << EOF
+    cat <<EOT
 Error creating configure script!
 This script requires the autoconf/automake and libtool to build. MacPorts can
 be used to obtain these:
-https://www.macports.org/install.php
-EOF
+http://www.macports.org/install.php
+EOT
     exit 1
   fi
 fi
@@ -121,7 +97,7 @@ for PLATFORM in ${PLATFORMS}; do
   SDKROOT="${PLATFORMSROOT}/"
   SDKROOT+="${PLATFORM}.platform/Developer/SDKs/${PLATFORM}${SDK}.sdk/"
   CFLAGS="-arch ${ARCH2:-${ARCH}} -pipe -isysroot ${SDKROOT} -O3 -DNDEBUG"
-  CFLAGS+=" -miphoneos-version-min=${IOS_MIN_VERSION} ${EXTRA_CFLAGS}"
+  CFLAGS+=" -miphoneos-version-min=6.0 ${EXTRA_CFLAGS}"
 
   set -x
   export PATH="${DEVROOT}/usr/bin:${OLDPATH}"
@@ -129,40 +105,25 @@ 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
 
-  # Build only the libraries, skip the examples.
-  make V=0 -C sharpyuv
-  make V=0 -C src install
+  # run make only in the src/ directory to create libwebp.a/libwebpdecoder.a
+  cd src/
+  make V=0
+  make install
 
   LIBLIST+=" ${ROOTDIR}/lib/libwebp.a"
   DECLIBLIST+=" ${ROOTDIR}/lib/libwebpdecoder.a"
-  MUXLIBLIST+=" ${ROOTDIR}/lib/libwebpmux.a"
-  DEMUXLIBLIST+=" ${ROOTDIR}/lib/libwebpdemux.a"
 
   make clean
+  cd ..
 
   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
-
-echo  "SUCCESS"

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,29 +25,16 @@ 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 (https://www.macports.org/install.php)
+# 1. Install MacPorts (http://www.macports.org/install.php)
 # 2. Run "sudo port install jpeg"
 # 3. Run "sudo port install libpng"
 # 4. Run "sudo port install tiff"
@@ -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,45 +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 \
 
-SHARPYUV_OBJS = \
-    sharpyuv/sharpyuv.o \
-    sharpyuv/sharpyuv_csp.o \
-    sharpyuv/sharpyuv_dsp.o \
-    sharpyuv/sharpyuv_gamma.o \
-    sharpyuv/sharpyuv_neon.o \
-    sharpyuv/sharpyuv_sse2.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 \
@@ -152,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 \
@@ -166,93 +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/lossless_sse41.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 \
@@ -260,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 \
@@ -270,28 +230,27 @@ 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 = $(SHARPYUV_OBJS) $(LIBWEBPDECODER_OBJS) $(ENC_OBJS) \
-               $(DSP_ENC_OBJS) $(UTILS_ENC_OBJS)
+LIBWEBP_OBJS = $(LIBWEBPDECODER_OBJS) $(ENC_OBJS) $(DSP_ENC_OBJS) \
+               $(UTILS_ENC_OBJS)
 LIBWEBPMUX_OBJS = $(MUX_OBJS)
 LIBWEBPDEMUX_OBJS = $(DEMUX_OBJS)
 LIBWEBPEXTRA_OBJS = $(EXTRA_OBJS)
@@ -305,172 +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/cpu.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
@@ -484,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; \
@@ -496,13 +397,11 @@ dist: all
 clean:
 	$(RM) $(OUTPUT) *~ \
               examples/*.o examples/*~ \
-              extras/*.o extras/*~ \
-              imageio/*.o imageio/*~ \
-              sharpyuv/*.o sharpyuv/*~ \
               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 "March 17, 2022"
+.TH CWEBP 1 "September 02, 2016"
 .SH NAME
 cwebp \- compress an image file to a WebP file
 .SH SYNOPSIS
@@ -13,7 +13,6 @@ command.
 .PP
 \fBcwebp\fP compresses an image using the WebP format.
 Input format can be either PNG, JPEG, TIFF, WebP or raw Y'CbCr samples.
-Note: Animated PNG and WebP files are not supported.
 .SH OPTIONS
 The basic options are:
 .TP
@@ -42,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
@@ -90,20 +87,19 @@ additional encoding possibilities and decide on the quality gain.
 Lower value can result in faster processing time at the expense of
 larger file size and lower compression quality.
 .TP
+.BI \-resize " width height
+Resize the source to a rectangle with size \fBwidth\fP x \fBheight\fP.
+If either (but not both) of the \fBwidth\fP or \fBheight\fP parameters is 0,
+the value will be calculated preserving the aspect\-ratio.
+.TP
 .BI \-crop " x_position y_position width height
 Crop the source to a rectangle with top\-left corner at coordinates
 (\fBx_position\fP, \fBy_position\fP) and size \fBwidth\fP x \fBheight\fP.
 This cropping area must be fully contained within the source rectangle.
-Note: the cropping is applied \fIbefore\fP any scaling.
-.TP
-.BI \-resize " width height
-Resize the source to a rectangle with size \fBwidth\fP x \fBheight\fP.
-If either (but not both) of the \fBwidth\fP or \fBheight\fP parameters is 0,
-the value will be calculated preserving the aspect\-ratio. Note: scaling
-is applied \fIafter\fP cropping.
 .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
@@ -137,13 +133,6 @@ options \fB\-size\fP or \fB\-psnr\fP. Maximum value is 10, default is 1.
 If options \fB\-size\fP or \fB\-psnr\fP were used, but \fB\-pass\fP wasn't
 specified, a default value of '6' passes will be used.
 .TP
-.BI \-qrange " int int
-Specifies the permissible interval for the quality factor. This is particularly
-useful when using multi-pass (\fB\-size\fP or \fB\-psnr\fP options).
-Default is 0 100.
-If the quality factor is outside this range, it will be clamped.
-If the minimum value must be less or equal to the maximum one.
-.TP
 .B \-af
 Turns auto\-filter on. This algorithm will spend additional time optimizing
 the filtering strength to reach a well\-balanced quality.
@@ -177,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
@@ -224,7 +209,7 @@ Compute and report average PSNR (Peak\-Signal\-To\-Noise ratio).
 .TP
 .B \-print_ssim
 Compute and report average SSIM (structural similarity
-metric, see https://en.wikipedia.org/wiki/SSIM for additional details).
+metric, see http://en.wikipedia.org/wiki/SSIM for additional details).
 .TP
 .B \-print_lsim
 Compute and report local similarity metric (sum of lowest error amongst the
@@ -300,7 +285,7 @@ Please report all bugs to the issue tracker:
 https://bugs.chromium.org/p/webp
 .br
 Patches welcome! See this page to get started:
-https://www.webmproject.org/code/contribute/submitting\-patches/
+http://www.webmproject.org/code/contribute/submitting\-patches/
 
 .SH EXAMPLES
 cwebp \-q 50 -lossless picture.png \-o picture_lossless.webp
@@ -324,5 +309,5 @@ for the Debian project (and may be used by others).
 .BR dwebp (1),
 .BR gif2webp (1)
 .br
-Please refer to https://developers.google.com/speed/webp/ for additional
+Please refer to http://developers.google.com/speed/webp/ for additional
 information.

man/dwebp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH DWEBP 1 "November 17, 2021"
+.TH DWEBP 1 "June 23, 2016"
 .SH NAME
 dwebp \- decompress a WebP file to an image file
 .SH SYNOPSIS
@@ -12,7 +12,6 @@ This manual page documents the
 command.
 .PP
 \fBdwebp\fP decompresses WebP files into PNG, PAM, PPM or PGM images.
-Note: Animated WebP files are not supported.
 .SH OPTIONS
 The basic options are:
 .TP
@@ -113,7 +112,7 @@ Please report all bugs to the issue tracker:
 https://bugs.chromium.org/p/webp
 .br
 Patches welcome! See this page to get started:
-https://www.webmproject.org/code/contribute/submitting\-patches/
+http://www.webmproject.org/code/contribute/submitting-patches/
 
 .SH EXAMPLES
 dwebp picture.webp \-o output.png
@@ -138,7 +137,7 @@ for the Debian project (and may be used by others).
 .BR gif2webp (1),
 .BR webpmux (1)
 .br
-Please refer to https://developers.google.com/speed/webp/ for additional
+Please refer to http://developers.google.com/speed/webp/ for additional
 information.
 .SS Output file format details
 PAM: http://netpbm.sourceforge.net/doc/pam.html

man/gif2webp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH GIF2WEBP 1 "November 17, 2021"
+.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
@@ -62,9 +56,9 @@ larger file size and lower compression quality.
 .TP
 .BI \-min_size
 Encode image to achieve smallest size. This disables key frame insertion and
-picks the dispose method resulting in the smallest output for each frame. It
-uses lossless compression by default, but can be combined with \-q, \-m,
-\-lossy or \-mixed options.
+picks the dispose method resulting in smallest output for each frame. It uses
+lossless compression by default, but can be combined with \-q, \-m, \-lossy or
+\-mixed options.
 .TP
 .BI \-kmin " int
 .TP
@@ -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.
@@ -131,7 +121,7 @@ Please report all bugs to the issue tracker:
 https://bugs.chromium.org/p/webp
 .br
 Patches welcome! See this page to get started:
-https://www.webmproject.org/code/contribute/submitting\-patches/
+http://www.webmproject.org/code/contribute/submitting-patches/
 
 .SH EXAMPLES
 gif2webp picture.gif \-o picture.webp
@@ -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.
@@ -160,5 +148,5 @@ Debian project (and may be used by others).
 .BR dwebp (1),
 .BR webpmux (1)
 .br
-Please refer to https://developers.google.com/speed/webp/ for additional
+Please refer to http://developers.google.com/speed/webp/ for additional
 information.

man/img2webp.1

@@ -1,105 +0,0 @@
-.\"                                      Hey, EMACS: -*- nroff -*-
-.TH IMG2WEBP 1 "January 5, 2022"
-.SH NAME
-img2webp \- create animated WebP file from a sequence of input images.
-.SH SYNOPSIS
-.B img2webp
-[file_options] [[frame_options] frame_file]...
-.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 arguments are actually tokenized from this file.
-This allows for easy scripting or using a 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 the 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:
-https://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 https://developers.google.com/speed/webp/ for additional
-information.

man/vwebp.1

@@ -1,5 +1,5 @@
 .\"                                      Hey, EMACS: -*- nroff -*-
-.TH VWEBP 1 "November 17, 2021"
+.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.
 
@@ -77,7 +67,7 @@ Please report all bugs to the issue tracker:
 https://bugs.chromium.org/p/webp
 .br
 Patches welcome! See this page to get started:
-https://www.webmproject.org/code/contribute/submitting\-patches/
+http://www.webmproject.org/code/contribute/submitting-patches/
 
 .SH EXAMPLES
 vwebp picture.webp
@@ -97,5 +87,5 @@ This manual page was written for the Debian project (and may be used by others).
 .SH SEE ALSO
 .BR dwebp (1)
 .br
-Please refer to https://developers.google.com/speed/webp/ for additional
+Please refer to http://developers.google.com/speed/webp/ for additional
 information.