Support for sticker, bugfix

Added support for tg stickers (converted into png images)

Fixed a bug in where a tg user without surname would send message with "null" as surname

WebPConverter/libwebp-0.4.1-linux-x86-64/README

@@ -0,0 +1,482 @@
+          __   __  ____  ____  ____
+         /  \\/  \/  _ \/  _ )/  _ \
+         \       /   __/  _  \   __/
+          \__\__/\____/\_____/__/ ____  ___
+                / _/ /    \    \ /  _ \/ _/
+               /  \_/   / /   \ \   __/  \__
+               \____/____/\_____/_____/____/v0.4.1
+
+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
+
+Latest sources are available from http://www.webmproject.org/code/
+
+It is released under the same license as the WebM project.
+See http://www.webmproject.org/license/software/ or the
+file "COPYING" file for details. An additional intellectual
+property rights grant can be found in the file PATENTS.
+
+Files:
+======
+cwebp        : encoding tool
+dwebp        : decoding tool
+gif2webp     : gif conversion tool
+vwebp        : webp visualization tool
+lib/         : static libraries
+include/webp : headers
+
+Encoding tool:
+==============
+
+The package 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)
+  -alpha_q <int> ......... transparency-compression quality (0..100)
+  -preset <string> ....... preset setting, one of:
+                            default, photo, picture,
+                            drawing, icon, text
+     -preset must come first, as it overwrites other parameters
+
+  -m <int> ............... compression method (0=fast, 6=slowest)
+  -segments <int> ........ number of segments to use (1..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)
+  -f <int> ............... filter strength (0=off..100)
+  -sharpness <int> ....... filter sharpness (0:most .. 7:least sharp)
+  -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)
+  -alpha_filter <string> . predictive filtering for alpha plane,
+                           one of: none, fast (default) or best
+  -alpha_cleanup ......... clean RGB values in transparent area
+  -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
+  -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:
+==============
+
+The sample decoding program dwebp 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:
+
+ ./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)
+  -mt .......... use multi-threading
+  -crop <x> <y> <w> <h> ... crop output with the given rectangle
+  -scale <w> <h> .......... scale the output (*after* any cropping)
+  -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)
+  -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
+  -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
+
+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)
+  -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
+
+Encoding API:
+=============
+
+The main encoding functions are available in the header 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 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 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 our issue tracker:
+    http://code.google.com/p/webp/issues
+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

WebPConverter/libwebp-0.4.1-linux-x86-64/README.mux

@@ -0,0 +1,186 @@
+          __   __  ____  ____  ____  __ __  _     __ __
+         /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
+         \       /   __/  _  \   __/      /  /  (_/  /__
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v0.2.1
+
+
+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).
+
+
+Bugs:
+=====
+
+Please report all bugs to our issue tracker:
+    http://code.google.com/p/webp/issues
+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

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/cwebp.html

@@ -0,0 +1,564 @@
+<!-- Creator     : groff version 1.21 -->
+<!-- CreationDate: Mon Jul 28 19:46:48 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p       { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       pre     { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       table   { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       h1      { text-align: center }
+</style>
+<title>CWEBP</title>
+
+</head>
+<body>
+
+<h1 align="center">CWEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#ADDITIONAL OPTIONS">ADDITIONAL OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<h2>NAME
+<a name="NAME"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">cwebp &minus;
+compress an image file to a WebP file</p>
+
+<h2>SYNOPSIS
+<a name="SYNOPSIS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>
+[<i>options</i>] <i>input_file &minus;o
+output_file.webp</i></p>
+
+<h2>DESCRIPTION
+<a name="DESCRIPTION"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>cwebp</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>
+compresses an image using the WebP format. Input format can
+be either PNG, JPEG, TIFF, WebP or raw Y&rsquo;CbCr
+samples.</p>
+
+<h2>OPTIONS
+<a name="OPTIONS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">The basic
+options are: <b><br>
+&minus;o</b> <i>string</i></p>
+
+<p style="margin-left:22%;">Specify the name of the output
+WebP file. If omitted, <b>cwebp</b> will perform compression
+but only report statistics. Using &quot;&minus;&quot; as
+output name will direct output to &rsquo;stdout&rsquo;.</p>
+
+<p style="margin-left:11%;"><b>&minus;&minus;</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Explicitly specify the input
+file. This option is useful if the input file starts with an
+&rsquo;&minus;&rsquo; for instance. This option must appear
+<b>last</b>. Any other options afterward will be
+ignored.</p>
+
+<p style="margin-left:11%;"><b>&minus;h,
+&minus;help</b></p>
+
+<p style="margin-left:22%;">A short usage summary.</p>
+
+<p style="margin-left:11%;"><b>&minus;H,
+&minus;longhelp</b></p>
+
+<p style="margin-left:22%;">A summary of all the possible
+options.</p>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print the version number (as
+major.minor.revision) and exit.</p>
+
+<p style="margin-left:11%;"><b>&minus;q</b>
+<i>float</i></p>
+
+<p style="margin-left:22%;">Specify the compression factor
+for RGB channels between 0 and 100. The default is 75.</p>
+
+<p style="margin-left:11%;"><b>&minus;alpha_q</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify the compression factor
+for alpha compression between 0 and 100. Lossless
+compression of alpha is achieved using a value of 100, while
+the lower values result in a lossy compression. The default
+is 100.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;f</b> <i>int</i></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Specify the strength of the deblocking filter, between 0
+(no filtering) and 100 (maximum filtering). A value of 0
+will turn off any filtering. Higher value will increase the
+strength of the filtering process applied after decoding the
+picture. The higher the value the smoother the picture will
+appear. Typical values are usually in the range of 20 to
+50.</p> </td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;preset</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify a set of pre-defined
+parameters to suit a particular type of source material.
+Possible values are: <b>default</b>, <b>photo</b>,
+<b>picture</b>, <b>drawing</b>, <b>icon</b>, <b>text</b>.
+Since <b>&minus;preset</b> overwrites the other
+parameters&rsquo; values (except the <b>&minus;q</b> one),
+this option should preferably appear first in the order of
+the arguments.</p>
+
+<p style="margin-left:11%;"><b>&minus;sns</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify the amplitude of the
+spatial noise shaping. Spatial noise shaping (or <b>sns</b>
+for short) refers to a general collection of built-in
+algorithms used to decide which area of the picture should
+use relatively less bits, and where else to better transfer
+these bits. The possible range goes from 0 (algorithm is
+off) to 100 (the maximal effect). The default value is
+80.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;m</b> <i>int</i></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>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. When higher values are used, the
+encoder will spend more time inspecting 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.</p></td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;jpeg_like</b></p>
+
+<p style="margin-left:22%;">Change the internal parameter
+mapping to better match the expected size of JPEG
+compression. This flag will generally produce an output file
+of similar size to its JPEG equivalent (for the same
+<b>&minus;q</b> setting), but with less visual
+distortion.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+<p><b>&minus;mt</b></p></td>
+<td width="7%"></td>
+<td width="78%">
+
+
+<p>Use multi-threading for encoding, if possible. This
+option is only effective when using lossy compression on a
+source with a transparency channel.</p></td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;low_memory</b></p>
+
+<p style="margin-left:22%;">Reduce memory usage of lossy
+encoding by saving four times the compressed size
+(typically). This will make the encoding slower and the
+output slightly different in size and distortion. This flag
+is only effective for methods 3 and up, and is off by
+default. Note that leaving this flag off will have some side
+effects on the bitstream: it forces certain bitstream
+features like number of partitions (forced to 1). Note that
+a more detailed report of bitstream size is printed by
+<b>cwebp</b> when using this option.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+<p><b>&minus;af</b></p></td>
+<td width="7%"></td>
+<td width="78%">
+
+
+<p>Turns auto-filter on. This algorithm will spend
+additional time optimizing the filtering strength to reach a
+well-balanced quality.</p></td></tr>
+</table>
+
+<h2>ADDITIONAL OPTIONS
+<a name="ADDITIONAL OPTIONS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">More advanced
+options are: <b><br>
+&minus;sharpness</b> <i>int</i></p>
+
+<p style="margin-left:22%;">Specify the sharpness of the
+filtering (if used). Range is 0 (sharpest) to 7 (least
+sharp). Default is 0.</p>
+
+<p style="margin-left:11%;"><b>&minus;strong</b></p>
+
+<p style="margin-left:22%;">Use strong filtering (if
+filtering is being used thanks to the <b>&minus;f</b>
+option). Strong filtering is on by default.</p>
+
+<p style="margin-left:11%;"><b>&minus;nostrong</b></p>
+
+<p style="margin-left:22%;">Disable strong filtering (if
+filtering is being used thanks to the <b>&minus;f</b>
+option) and use simple filtering instead.</p>
+
+<p style="margin-left:11%;"><b>&minus;segments</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Change the number of partitions
+to use during the segmentation of the sns algorithm.
+Segments should be in range 1 to 4. Default value is 4. This
+option has no effect for methods 3 and up, unless
+<b>&minus;low_memory</b> is used.</p>
+
+<p style="margin-left:11%;"><b>&minus;partition_limit</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Degrade quality by limiting the
+number of bits used by some macroblocks. Range is 0 (no
+degradation, the default) to 100 (full degradation). Useful
+values are usually around 30-70 for moderately large images.
+In the VP8 format, the so-called control partition has a
+limit of 512k and is used to store the following
+information: whether the macroblock is skipped, which
+segment it belongs to, whether it is coded as intra 4x4 or
+intra 16x16 mode, and finally the prediction modes to use
+for each of the sub-blocks. For a very large image, 512k
+only leaves room to few bits per 16x16 macroblock. The
+absolute minimum is 4 bits per macroblock. Skip, segment,
+and mode information can use up almost all these 4 bits
+(although the case is unlikely), which is problematic for
+very large images. The partition_limit factor controls how
+frequently the most bit-costly mode (intra 4x4) will be
+used. This is useful in case the 512k limit is reached and
+the following message is displayed: <i>Error code: 6
+(PARTITION0_OVERFLOW: Partition #0 is too big to fit
+512k)</i>. If using <b>-partition_limit</b> is not enough to
+meet the 512k constraint, one should use less segments in
+order to save more header bits per macroblock. See the
+<b>-segments</b> option.</p>
+
+<p style="margin-left:11%;"><b>&minus;size</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify a target size (in
+bytes) to try and reach for the compressed output.
+Compressor will make several pass of partial encoding in
+order to get as close as possible to this target.</p>
+
+<p style="margin-left:11%;"><b>&minus;psnr</b>
+<i>float</i></p>
+
+<p style="margin-left:22%;">Specify a target PSNR (in dB)
+to try and reach for the compressed output. Compressor will
+make several pass of partial encoding in order to get as
+close as possible to this target.</p>
+
+<p style="margin-left:11%;"><b>&minus;pass</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Set a maximum number of passes
+to use during the dichotomy used by options
+<b>&minus;size</b> or <b>&minus;psnr</b>. Maximum value is
+10.</p>
+
+<p style="margin-left:11%;"><b>&minus;resize</b> <i>width
+height</i></p>
+
+<p style="margin-left:22%;">Resize the source to a
+rectangle with size <b>width</b> x <b>height</b>. If either
+(but not both) of the <b>width</b> or <b>height</b>
+parameters is 0, the value will be calculated preserving the
+aspect-ratio.</p>
+
+<p style="margin-left:11%;"><b>&minus;crop</b>
+<i>x_position y_position width height</i></p>
+
+<p style="margin-left:22%;">Crop the source to a rectangle
+with top-left corner at coordinates (<b>x_position</b>,
+<b>y_position</b>) and size <b>width</b> x <b>height</b>.
+This cropping area must be fully contained within the source
+rectangle.</p>
+
+<p style="margin-left:11%;"><b>&minus;s</b> <i>width
+height</i></p>
+
+<p style="margin-left:22%;">Specify that the input file
+actually consists of raw Y&rsquo;CbCr samples following the
+ITU-R BT.601 recommendation, in 4:2:0 linear format. The
+luma plane has size <b>width</b> x <b>height</b>.</p>
+
+<p style="margin-left:11%;"><b>&minus;map</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Output additional ASCII-map of
+encoding information. Possible map values range from 1 to 6.
+This is only meant to help debugging.</p>
+
+<p style="margin-left:11%;"><b>&minus;pre</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify some pre-processing
+steps. Using a value of &rsquo;2&rsquo; will trigger
+quality-dependent pseudo-random dithering during
+RGBA-&gt;YUVA conversion (lossy compression only).</p>
+
+<p style="margin-left:11%;"><b>&minus;alpha_filter</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify the predictive
+filtering method for the alpha plane. One of
+&rsquo;none&rsquo;, &rsquo;fast&rsquo; or
+&rsquo;best&rsquo;, in increasing complexity and slowness
+order. Default is &rsquo;fast&rsquo;. Internally, alpha
+filtering is performed using four possible predictions
+(none, horizontal, vertical, gradient). The
+&rsquo;best&rsquo; mode will try each mode in turn and pick
+the one which gives the smaller size. The &rsquo;fast&rsquo;
+mode will just try to form an a-priori guess without testing
+all modes.</p>
+
+<p style="margin-left:11%;"><b>&minus;alpha_method</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify the algorithm used for
+alpha compression: 0 or 1. Algorithm 0 denotes no
+compression, 1 uses WebP lossless format for compression.
+The default is 1.</p>
+
+
+<p style="margin-left:11%;"><b>&minus;alpha_cleanup</b></p>
+
+<p style="margin-left:22%;">Modify unseen RGB values under
+fully transparent area, to help compressibility. The default
+is off.</p>
+
+<p style="margin-left:11%;"><b>&minus;blend_alpha</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">This option blends the alpha
+channel (if present) with the source using the background
+color specified in hexadecimal as 0xrrggbb. The alpha
+channel is afterward reset to the opaque value 255.</p>
+
+<p style="margin-left:11%;"><b>&minus;noalpha</b></p>
+
+<p style="margin-left:22%;">Using this option will discard
+the alpha channel.</p>
+
+<p style="margin-left:11%;"><b>&minus;lossless</b></p>
+
+<p style="margin-left:22%;">Encode the image without any
+loss.</p>
+
+<p style="margin-left:11%;"><b>&minus;hint</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify the hint about input
+image type. Possible values are: <b>photo</b>,
+<b>picture</b> or <b>graph</b>.</p>
+
+<p style="margin-left:11%;"><b>&minus;metadata</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">A comma separated list of
+metadata to copy from the input to the output if present.
+Valid values: <b>all</b>, <b>none</b>, <b>exif</b>,
+<b>icc</b>, <b>xmp</b>. The default is <b>none</b>.</p>
+
+<p style="margin-left:22%; margin-top: 1em">Note: each
+input format may not support all combinations.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;noasm</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Disable all assembly optimizations.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;v</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Print extra information (encoding time in
+particular).</p> </td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;print_psnr</b></p>
+
+<p style="margin-left:22%;">Compute and report average PSNR
+(Peak-Signal-To-Noise ratio).</p>
+
+<p style="margin-left:11%;"><b>&minus;print_ssim</b></p>
+
+<p style="margin-left:22%;">Compute and report average SSIM
+(structural similarity metric, see
+http://en.wikipedia.org/wiki/SSIM for additional
+details).</p>
+
+<p style="margin-left:11%;"><b>&minus;print_lsim</b></p>
+
+<p style="margin-left:22%;">Compute and report local
+similarity metric (sum of lowest error amongst the
+collocated pixel neighbors).</p>
+
+<p style="margin-left:11%;"><b>&minus;progress</b></p>
+
+<p style="margin-left:22%;">Report encoding progress in
+percent.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;quiet</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Do not print anything.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;short</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Only print brief information (output file size and PSNR)
+for testing purpose.</p></td></tr>
+</table>
+
+<h2>BUGS
+<a name="BUGS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<h2>EXAMPLES
+<a name="EXAMPLES"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">cwebp &minus;q
+50 -lossless picture.png &minus;o picture_lossless.webp <br>
+cwebp &minus;q 70 picture_with_alpha.png &minus;o
+picture_with_alpha.webp <br>
+cwebp &minus;sns 70 &minus;f 50 &minus;size 60000
+picture.png &minus;o picture.webp <br>
+cwebp &minus;o picture.webp &minus;&minus;
+&minus;&minus;&minus;picture.png</p>
+
+<h2>AUTHORS
+<a name="AUTHORS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Pascal Massimino
+&lt;pascal.massimino@gmail.com&gt;, for the Debian project
+(and may be used by others).</p>
+
+<h2>SEE ALSO
+<a name="SEE ALSO"></a>
+</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>(1),
+<b>gif2webp</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/cwebp.txt

@@ -0,0 +1,284 @@
+CWEBP(1)                                                              CWEBP(1)
+
+
+
+NAME
+       cwebp - compress an image file to a WebP file
+
+SYNOPSIS
+       cwebp [options] input_file -o output_file.webp
+
+DESCRIPTION
+       This manual page documents the cwebp command.
+
+       cwebp  compresses  an image using the WebP format.  Input format can be
+       either PNG, JPEG, TIFF, WebP or raw Y'CbCr samples.
+
+OPTIONS
+       The basic options are:
+
+       -o string
+              Specify the name of the output WebP file. If omitted, cwebp will
+              perform  compression  but  only report statistics.  Using "-" as
+              output name will direct output to 'stdout'.
+
+       -- string
+              Explicitly specify the input file. This option is useful if  the
+              input  file  starts  with  an '-' for instance. This option must
+              appear last.  Any other options afterward will be ignored.
+
+       -h, -help
+              A short usage summary.
+
+       -H, -longhelp
+              A summary of all the possible options.
+
+       -version
+              Print the version number (as major.minor.revision) and exit.
+
+       -q float
+              Specify the compression factor for RGB channels  between  0  and
+              100. The default is 75.
+
+       -alpha_q int
+              Specify  the  compression factor for alpha compression between 0
+              and 100.  Lossless compression of  alpha  is  achieved  using  a
+              value  of 100, while the lower values result in a lossy compres‐
+              sion. The default is 100.
+
+       -f int Specify the strength of the deblocking  filter,  between  0  (no
+              filtering)  and  100 (maximum filtering). A value of 0 will turn
+              off any filtering.  Higher value will increase the  strength  of
+              the  filtering  process  applied after decoding the picture. The
+              higher the value the smoother the picture will  appear.  Typical
+              values are usually in the range of 20 to 50.
+
+       -preset string
+              Specify  a  set  of  pre-defined parameters to suit a particular
+              type of source material. Possible values are:   default,  photo,
+              picture, drawing, icon, text. Since -preset overwrites the other
+              parameters' values (except  the  -q  one),  this  option  should
+              preferably appear first in the order of the arguments.
+
+       -sns int
+              Specify  the  amplitude  of  the  spatial noise shaping. Spatial
+              noise shaping (or sns for short) refers to a general  collection
+              of  built-in algorithms used to decide which area of the picture
+              should use relatively less bits, and where else to better trans‐
+              fer  these  bits.  The  possible range goes from 0 (algorithm is
+              off) to 100 (the maximal effect). The default value is 80.
+
+       -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.  When higher values are used, the encoder will spend
+              more  time  inspecting  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.
+
+       -jpeg_like
+              Change  the  internal  parameter  mapping  to  better  match the
+              expected size of JPEG compression. This flag will generally pro‐
+              duce  an output file of similar size to its JPEG equivalent (for
+              the same -q setting), but with less visual distortion.
+
+       -mt    Use multi-threading for encoding, if possible.  This  option  is
+              only  effective  when using lossy compression on a source with a
+              transparency channel.
+
+       -low_memory
+              Reduce memory usage of lossy encoding by saving four  times  the
+              compressed  size (typically). This will make the encoding slower
+              and the output slightly different in size and  distortion.  This
+              flag  is  only  effective  for  methods  3 and up, and is off by
+              default. Note that leaving this flag off  will  have  some  side
+              effects  on  the bitstream: it forces certain bitstream features
+              like number of partitions  (forced  to  1).  Note  that  a  more
+              detailed report of bitstream size is printed by cwebp when using
+              this option.
+
+       -af    Turns auto-filter on. This algorithm will spend additional  time
+              optimizing the filtering strength to reach a well-balanced qual‐
+              ity.
+
+
+ADDITIONAL OPTIONS
+       More advanced options are:
+
+       -sharpness int
+              Specify the sharpness of the filtering (if used).   Range  is  0
+              (sharpest) to 7 (least sharp). Default is 0.
+
+       -strong
+              Use  strong  filtering (if filtering is being used thanks to the
+              -f option). Strong filtering is on by default.
+
+       -nostrong
+              Disable strong filtering (if filtering is being used  thanks  to
+              the -f option) and use simple filtering instead.
+
+       -segments int
+              Change  the  number of partitions to use during the segmentation
+              of the sns algorithm. Segments  should  be  in  range  1  to  4.
+              Default value is 4.  This option has no effect for methods 3 and
+              up, unless -low_memory is used.
+
+       -partition_limit int
+              Degrade quality by limiting the number of bits used by some mac‐
+              roblocks.  Range is 0 (no degradation, the default) to 100 (full
+              degradation).  Useful values are usually around 30-70 for moder‐
+              ately  large  images.   In the VP8 format, the so-called control
+              partition has a limit of 512k and is used to store the following
+              information: whether the macroblock is skipped, which segment it
+              belongs to, whether it is coded as  intra  4x4  or  intra  16x16
+              mode,  and  finally  the prediction modes to use for each of the
+              sub-blocks.  For a very large image, 512k only  leaves  room  to
+              few  bits  per 16x16 macroblock.  The absolute minimum is 4 bits
+              per macroblock. Skip, segment, and mode information can  use  up
+              almost  all  these 4 bits (although the case is unlikely), which
+              is problematic for very large images. The partition_limit factor
+              controls  how  frequently  the  most bit-costly mode (intra 4x4)
+              will be used. This is useful in case the 512k limit  is  reached
+              and  the  following  message is displayed: Error code: 6 (PARTI‐
+              TION0_OVERFLOW: Partition #0 is too big to fit 512k).  If  using
+              -partition_limit  is not enough to meet the 512k constraint, one
+              should use less segments in order to save more header  bits  per
+              macroblock.  See the -segments option.
+
+       -size int
+              Specify  a  target size (in bytes) to try and reach for the com‐
+              pressed output.  Compressor will make several  pass  of  partial
+              encoding in order to get as close as possible to this target.
+
+       -psnr float
+              Specify  a  target  PSNR  (in  dB) to try and reach for the com‐
+              pressed output.  Compressor will make several  pass  of  partial
+              encoding in order to get as close as possible to this target.
+
+       -pass int
+              Set  a maximum number of passes to use during the dichotomy used
+              by options -size or -psnr. Maximum value is 10.
+
+       -resize width height
+              Resize the source to a rectangle with size width x  height.   If
+              either  (but  not  both) of the width or height parameters is 0,
+              the value will be calculated preserving the aspect-ratio.
+
+       -crop x_position y_position width height
+              Crop the source to a rectangle with top-left corner  at  coordi‐
+              nates  (x_position,  y_position)  and size width x height.  This
+              cropping area must be fully contained within the source  rectan‐
+              gle.
+
+       -s width height
+              Specify that the input file actually consists of raw Y'CbCr sam‐
+              ples following the ITU-R BT.601 recommendation, in 4:2:0  linear
+              format.  The luma plane has size width x height.
+
+       -map int
+              Output  additional  ASCII-map  of encoding information. Possible
+              map values range from 1 to 6. This is only meant to help  debug‐
+              ging.
+
+       -pre int
+              Specify  some  pre-processing  steps.  Using a value of '2' will
+              trigger   quality-dependent   pseudo-random   dithering   during
+              RGBA->YUVA conversion (lossy compression only).
+
+       -alpha_filter string
+              Specify the predictive filtering method for the alpha plane. One
+              of 'none', 'fast' or 'best', in increasing complexity and  slow‐
+              ness  order.  Default  is 'fast'. Internally, alpha filtering is
+              performed using four  possible  predictions  (none,  horizontal,
+              vertical,  gradient). The 'best' mode will try each mode in turn
+              and pick the one which gives the smaller size. The  'fast'  mode
+              will  just  try  to  form  an a-priori guess without testing all
+              modes.
+
+       -alpha_method int
+              Specify the algorithm used for alpha compression: 0 or 1.  Algo‐
+              rithm  0 denotes no compression, 1 uses WebP lossless format for
+              compression. The default is 1.
+
+       -alpha_cleanup
+              Modify unseen RGB values under fully transparent area,  to  help
+              compressibility.  The default is off.
+
+       -blend_alpha int
+              This  option  blends  the  alpha  channel  (if present) with the
+              source using the background color specified  in  hexadecimal  as
+              0xrrggbb.  The  alpha  channel  is afterward reset to the opaque
+              value 255.
+
+       -noalpha
+              Using this option will discard the alpha channel.
+
+       -lossless
+              Encode the image without any loss.
+
+       -hint string
+              Specify the hint about input image type.  Possible  values  are:
+              photo, picture or graph.
+
+       -metadata string
+              A comma separated list of metadata to copy from the input to the
+              output if present.  Valid values: all,  none,  exif,  icc,  xmp.
+              The default is none.
+
+              Note: each input format may not support all combinations.
+
+       -noasm Disable all assembly optimizations.
+
+       -v     Print extra information (encoding time in particular).
+
+       -print_psnr
+              Compute and report average PSNR (Peak-Signal-To-Noise ratio).
+
+       -print_ssim
+              Compute  and  report average SSIM (structural similarity metric,
+              see http://en.wikipedia.org/wiki/SSIM for additional details).
+
+       -print_lsim
+              Compute and report local similarity metric (sum of lowest  error
+              amongst the collocated pixel neighbors).
+
+       -progress
+              Report encoding progress in percent.
+
+       -quiet Do not print anything.
+
+       -short Only  print  brief  information  (output file size and PSNR) for
+              testing purpose.
+
+
+BUGS
+       Please    report     all     bugs     to     our     issue     tracker:
+       http://code.google.com/p/webp/issues
+       Patches  welcome!  See  this  page  to get started: http://www.webmpro‐
+       ject.org/code/contribute/submitting-patches/
+
+
+EXAMPLES
+       cwebp -q 50 -lossless picture.png -o picture_lossless.webp
+       cwebp -q 70 picture_with_alpha.png -o picture_with_alpha.webp
+       cwebp -sns 70 -f 50 -size 60000 picture.png -o picture.webp
+       cwebp -o picture.webp -- ---picture.png
+
+
+AUTHORS
+       cwebp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This  manual  page  was  written  by  Pascal   Massimino   <pascal.mas‐
+       simino@gmail.com>, for the Debian project (and may be used by others).
+
+
+SEE ALSO
+       dwebp(1), gif2webp(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                                 July 22, 2014                        CWEBP(1)

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/dwebp.html

@@ -0,0 +1,337 @@
+<!-- Creator     : groff version 1.21 -->
+<!-- CreationDate: Mon Jul 28 19:46:48 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p       { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       pre     { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       table   { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       h1      { text-align: center }
+</style>
+<title>DWEBP</title>
+
+</head>
+<body>
+
+<h1 align="center">DWEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<h2>NAME
+<a name="NAME"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">dwebp &minus;
+decompress a WebP file to an image file</p>
+
+<h2>SYNOPSIS
+<a name="SYNOPSIS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>
+[<i>options</i>] <i>input_file.webp</i></p>
+
+<h2>DESCRIPTION
+<a name="DESCRIPTION"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>dwebp</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>
+decompresses WebP files into PNG, PAM, PPM or PGM
+images.</p>
+
+<h2>OPTIONS
+<a name="OPTIONS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">The basic
+options are:</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="3%">
+
+
+<p><b>&minus;h</b></p></td>
+<td width="8%"></td>
+<td width="30%">
+
+
+<p>Print usage summary.</p></td>
+<td width="48%">
+</td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print the version number (as
+major.minor.revision) and exit.</p>
+
+<p style="margin-left:11%;"><b>&minus;o</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify the name of the output
+file (as PNG format by default). Using &quot;-&quot; as
+output name will direct output to &rsquo;stdout&rsquo;.</p>
+
+<p style="margin-left:11%;"><b>&minus;&minus;</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Explicitly specify the input
+file. This option is useful if the input file starts with an
+&rsquo;&minus;&rsquo; for instance. This option must appear
+<b>last</b>. Any other options afterward will be ignored. If
+the input file is &quot;&minus;&quot;, the data will be read
+from <i>stdin</i> instead of a file.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;bmp</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Change the output format to uncompressed BMP.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;tiff</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Change the output format to uncompressed TIFF.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;pam</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Change the output format to PAM (retains alpha).</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;ppm</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Change the output format to PPM (discards alpha).</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;pgm</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Change the output format to PGM. The output consists of
+luma/chroma samples instead of RGB, using the IMC4 layout.
+This option is mainly for verification and debugging
+purposes.</p> </td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;yuv</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Change the output format to raw YUV. The output consists
+of luma/chroma-U/chroma-V samples instead of RGB, saved
+sequentially as individual planes. This option is mainly for
+verification and debugging purposes.</p></td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;nofancy</b></p>
+
+<p style="margin-left:22%;">Don&rsquo;t use the fancy
+upscaler for YUV420. This may lead to jaggy edges
+(especially the red ones), but should be faster.</p>
+
+<p style="margin-left:11%;"><b>&minus;nofilter</b></p>
+
+<p style="margin-left:22%;">Don&rsquo;t use the in-loop
+filtering process even if it is required by the bitstream.
+This may produce visible blocks on the non-compliant output,
+but it will make the decoding faster.</p>
+
+<p style="margin-left:11%;"><b>&minus;dither</b>
+<i>strength</i></p>
+
+<p style="margin-left:22%;">Specify a dithering
+<b>strength</b> between 0 and 100. Dithering is a
+post-processing effect applied to chroma components in lossy
+compression. It helps by smoothing gradients and avoiding
+banding artifacts.</p>
+
+<p style="margin-left:11%;"><b>&minus;nodither</b></p>
+
+<p style="margin-left:22%;">Disable all dithering
+(default).</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+<p><b>&minus;mt</b></p></td>
+<td width="7%"></td>
+<td width="70%">
+
+
+<p>Use multi-threading for decoding, if possible.</p></td>
+<td width="8%">
+</td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;crop</b>
+<i>x_position y_position width height</i></p>
+
+<p style="margin-left:22%;">Crop the decoded picture to a
+rectangle with top-left corner at coordinates
+(<b>x_position</b>, <b>y_position</b>) and size <b>width</b>
+x <b>height</b>. This cropping area must be fully contained
+within the source rectangle. The top-left corner will be
+snapped to even coordinates if needed. This option is meant
+to reduce the memory needed for cropping large images. Note:
+the cropping is applied <i>before</i> any scaling.</p>
+
+<p style="margin-left:11%;"><b>&minus;scale</b> <i>width
+height</i></p>
+
+<p style="margin-left:22%;">Rescale the decoded picture to
+dimension <b>width</b> x <b>height</b>. This option is
+mostly intended to reducing the memory needed to decode
+large images, when only a small version is needed
+(thumbnail, preview, etc.). Note: scaling is applied
+<i>after</i> cropping.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;v</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Print extra information (decoding time in
+particular).</p> </td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;noasm</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Disable all assembly optimizations.</p></td></tr>
+</table>
+
+<h2>BUGS
+<a name="BUGS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<h2>EXAMPLES
+<a name="EXAMPLES"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">dwebp
+picture.webp &minus;o output.png <br>
+dwebp picture.webp &minus;ppm &minus;o output.ppm <br>
+dwebp &minus;o output.ppm &minus;&minus;
+&minus;&minus;&minus;picture.webp <br>
+cat picture.webp | dwebp &minus;o &minus; &minus;&minus;
+&minus; &gt; output.ppm</p>
+
+<h2>AUTHORS
+<a name="AUTHORS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Pascal Massimino
+&lt;pascal.massimino@gmail.com&gt;, for the Debian project
+(and may be used by others).</p>
+
+<h2>SEE ALSO
+<a name="SEE ALSO"></a>
+</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>(1),
+<b>gif2webp</b>(1), <b>webpmux</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>Output file
+format details</b> <br>
+PAM: http://netpbm.sourceforge.net/doc/pam.html <br>
+PGM: http://netpbm.sourceforge.net/doc/pgm.html <br>
+PPM: http://netpbm.sourceforge.net/doc/ppm.html <br>
+PNG: http://www.libpng.org/pub/png/png-sitemap.html#info</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/dwebp.txt

@@ -0,0 +1,127 @@
+DWEBP(1)                                                              DWEBP(1)
+
+
+
+NAME
+       dwebp - decompress a WebP file to an image file
+
+SYNOPSIS
+       dwebp [options] input_file.webp
+
+DESCRIPTION
+       This manual page documents the dwebp command.
+
+       dwebp decompresses WebP files into PNG, PAM, PPM or PGM images.
+
+OPTIONS
+       The basic options are:
+
+       -h     Print usage summary.
+
+       -version
+              Print the version number (as major.minor.revision) and exit.
+
+       -o string
+              Specify  the name of the output file (as PNG format by default).
+              Using "-" as output name will direct output to 'stdout'.
+
+       -- string
+              Explicitly specify the input file. This option is useful if  the
+              input  file  starts  with  an '-' for instance. This option must
+              appear last.  Any other options afterward will  be  ignored.  If
+              the  input file is "-", the data will be read from stdin instead
+              of a file.
+
+       -bmp   Change the output format to uncompressed BMP.
+
+       -tiff  Change the output format to uncompressed TIFF.
+
+       -pam   Change the output format to PAM (retains alpha).
+
+       -ppm   Change the output format to PPM (discards alpha).
+
+       -pgm   Change  the  output  format  to  PGM.  The  output  consists  of
+              luma/chroma  samples instead of RGB, using the IMC4 layout. This
+              option is mainly for verification and debugging purposes.
+
+       -yuv   Change the output format to raw  YUV.  The  output  consists  of
+              luma/chroma-U/chroma-V  samples  instead  of  RGB, saved sequen‐
+              tially as individual planes. This option is mainly for verifica‐
+              tion and debugging purposes.
+
+       -nofancy
+              Don't  use the fancy upscaler for YUV420. This may lead to jaggy
+              edges (especially the red ones), but should be faster.
+
+       -nofilter
+              Don't use the in-loop filtering process even if it  is  required
+              by  the  bitstream.  This may produce visible blocks on the non-
+              compliant output, but it will make the decoding faster.
+
+       -dither strength
+              Specify a dithering strength between 0 and 100. Dithering  is  a
+              post-processing  effect  applied  to  chroma components in lossy
+              compression.  It helps by smoothing gradients and avoiding band‐
+              ing artifacts.
+
+       -nodither
+              Disable all dithering (default).
+
+       -mt    Use multi-threading for decoding, if possible.
+
+       -crop x_position y_position width height
+              Crop  the decoded picture to a rectangle with top-left corner at
+              coordinates (x_position, y_position) and size  width  x  height.
+              This  cropping  area  must  be fully contained within the source
+              rectangle.  The top-left corner will be snapped to even  coordi‐
+              nates  if  needed.   This  option  is meant to reduce the memory
+              needed for cropping large images.  Note: the cropping is applied
+              before any scaling.
+
+       -scale width height
+              Rescale  the  decoded  picture to dimension width x height. This
+              option is mostly intended  to  reducing  the  memory  needed  to
+              decode large images, when only a small version is needed (thumb‐
+              nail, preview, etc.).  Note: scaling is applied after cropping.
+
+       -v     Print extra information (decoding time in particular).
+
+       -noasm Disable all assembly optimizations.
+
+
+BUGS
+       Please    report     all     bugs     to     our     issue     tracker:
+       http://code.google.com/p/webp/issues
+       Patches  welcome!  See  this  page  to get started: http://www.webmpro‐
+       ject.org/code/contribute/submitting-patches/
+
+
+EXAMPLES
+       dwebp picture.webp -o output.png
+       dwebp picture.webp -ppm -o output.ppm
+       dwebp -o output.ppm -- ---picture.webp
+       cat picture.webp | dwebp -o - -- - > output.ppm
+
+
+AUTHORS
+       dwebp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This  manual  page  was  written  by  Pascal   Massimino   <pascal.mas‐
+       simino@gmail.com>, for the Debian project (and may be used by others).
+
+
+SEE ALSO
+       cwebp(1), gif2webp(1), webpmux(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+   Output file format details
+       PAM: http://netpbm.sourceforge.net/doc/pam.html
+       PGM: http://netpbm.sourceforge.net/doc/pgm.html
+       PPM: http://netpbm.sourceforge.net/doc/ppm.html
+       PNG: http://www.libpng.org/pub/png/png-sitemap.html#info
+
+
+
+                                 July 22, 2014                        DWEBP(1)

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/gif2webp.html

@@ -0,0 +1,299 @@
+<!-- Creator     : groff version 1.21 -->
+<!-- CreationDate: Mon Jul 28 19:46:48 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p       { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       pre     { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       table   { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       h1      { text-align: center }
+</style>
+<title>GIF2WEBP</title>
+
+</head>
+<body>
+
+<h1 align="center">GIF2WEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<h2>NAME
+<a name="NAME"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">gif2webp
+&minus; Convert a GIF image to WebP</p>
+
+<h2>SYNOPSIS
+<a name="SYNOPSIS"></a>
+</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>gif2webp</b>
+[<i>options</i>] <i>input_file.gif &minus;o
+output_file.webp</i></p>
+
+<h2>DESCRIPTION
+<a name="DESCRIPTION"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>gif2webp</b> command.</p>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>gif2webp</b>
+converts a GIF image to a WebP image.</p>
+
+<h2>OPTIONS
+<a name="OPTIONS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">The basic
+options are: <b><br>
+&minus;o</b> <i>string</i></p>
+
+<p style="margin-left:22%;">Specify the name of the output
+WebP file. If omitted, <b>gif2webp</b> will perform
+conversion but only report statistics. Using
+&quot;&minus;&quot; as output name will direct output to
+&rsquo;stdout&rsquo;.</p>
+
+<p style="margin-left:11%;"><b>&minus;h,
+&minus;help</b></p>
+
+<p style="margin-left:22%;">Usage information.</p>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print the version number (as
+major.minor.revision) and exit.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;lossy</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Encode the image using lossy compression.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;mixed</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Mixed compression mode: optimize compression of the
+image by picking either lossy or lossless compression for
+each frame heuristically.</p></td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;q</b>
+<i>float</i></p>
+
+<p style="margin-left:22%;">Specify the compression factor
+for RGB channels between 0 and 100. The default is 75. <br>
+In case of lossless compression (default), a small factor
+enables faster compression speed, but produces a larger
+file. Maximum compression is achieved by using a value of
+100. <br>
+In case of lossy compression (specified by the &minus;lossy
+option), a small factor produces a smaller file with lower
+quality. Best quality is achieved by using a value of
+100.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;m</b> <i>int</i></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>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. When higher values are used, the
+encoder will spend more time inspecting additional encoding
+possibilities and decide on the quality gain. Lower value
+can result is faster processing time at the expense of
+larger file size and lower compression quality.</p></td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;kmin</b> <i>int</i>
+<b><br>
+&minus;kmax</b> <i>int</i></p>
+
+<p style="margin-left:22%;">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>
+A &rsquo;kmin&rsquo; value of 0 will turn off insertion of
+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>
+These two options are relevant only for animated images with
+large number of frames (&gt;50). <br>
+When lower values are used, more frames will be converted to
+key frames. This may lead to smaller number of frames
+required to decode a frame on average, thereby improving the
+decoding performance. But this may lead to slightly bigger
+file sizes. Higher values may lead to worse decoding
+performance, but smaller file sizes. <br>
+Some restrictions: <br>
+(i) kmin &lt; kmax, <br>
+(ii) kmin &gt;= kmax / 2 + 1 and <br>
+(iii) kmax - kmin &lt;= 30. <br>
+If any of these restrictions are not met, they will be
+enforced automatically.</p>
+
+<p style="margin-left:11%;"><b>&minus;metadata</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">A comma separated list of
+metadata to copy from the input to the output if present.
+Valid values: <b>all</b>, <b>none</b>, <b>icc</b>,
+<b>xmp</b>. The default is <b>xmp</b>.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;f</b> <i>int</i></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>For lossy encoding only (specified by the &minus;lossy
+option). Specify the strength of the deblocking filter,
+between 0 (no filtering) and 100 (maximum filtering). A
+value of 0 will turn off any filtering. Higher value will
+increase the strength of the filtering process applied after
+decoding the picture. The higher the value the smoother the
+picture will appear. Typical values are usually in the range
+of 20 to 50.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;mt</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Use multi-threading for encoding, if possible. This
+option is only effective when using lossy compression.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;v</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Print extra information.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;quiet</b></p></td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p>Do not print anything.</p></td></tr>
+</table>
+
+<h2>BUGS
+<a name="BUGS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<h2>EXAMPLES
+<a name="EXAMPLES"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">gif2webp
+picture.gif &minus;o picture.webp <br>
+gif2webp &minus;q 70 picture.gif &minus;o picture.webp <br>
+gif2webp &minus;lossy &minus;m 3 picture.gif &minus;o
+picture_lossy.webp <br>
+gif2webp &minus;lossy &minus;f 50 picture.gif &minus;o
+picture.webp <br>
+gif2webp &minus;q 70 &minus;o picture.webp &minus;&minus;
+&minus;&minus;&minus;picture.gif</p>
+
+<h2>AUTHORS
+<a name="AUTHORS"></a>
+</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>gif2webp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Urvang Joshi &lt;urvang@google.com&gt;,
+for the Debian project (and may be used by others).</p>
+
+<h2>SEE ALSO
+<a name="SEE ALSO"></a>
+</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>(1),
+<b>dwebp</b>(1), <b>webpmux</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/gif2webp.txt

@@ -0,0 +1,132 @@
+GIF2WEBP(1)                                                        GIF2WEBP(1)
+
+
+
+NAME
+       gif2webp - Convert a GIF image to WebP
+
+SYNOPSIS
+       gif2webp [options] input_file.gif -o output_file.webp
+
+DESCRIPTION
+       This manual page documents the gif2webp command.
+
+       gif2webp converts a GIF image to a WebP image.
+
+OPTIONS
+       The basic options are:
+
+       -o string
+              Specify  the  name of the output WebP file. If omitted, gif2webp
+              will perform conversion but only report statistics.   Using  "-"
+              as output name will direct output to 'stdout'.
+
+       -h, -help
+              Usage information.
+
+       -version
+              Print the version number (as major.minor.revision) and exit.
+
+       -lossy Encode the image using lossy compression.
+
+       -mixed Mixed  compression  mode:  optimize  compression of the image by
+              picking either lossy or  lossless  compression  for  each  frame
+              heuristically.
+
+       -q float
+              Specify  the  compression  factor for RGB channels between 0 and
+              100. The default is 75.
+              In case  of  lossless  compression  (default),  a  small  factor
+              enables  faster  compression  speed, but produces a larger file.
+              Maximum compression is achieved by using a value of 100.
+              In case of lossy compression (specified by the -lossy option), a
+              small  factor  produces  a smaller file with lower quality. Best
+              quality is achieved by using a value of 100.
+
+       -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.  When higher values are used, the encoder will spend
+              more  time  inspecting  additional  encoding  possibilities  and
+              decide  on  the  quality gain.  Lower value can result is faster
+              processing time at the expense of larger  file  size  and  lower
+              compression quality.
+
+       -kmin int
+
+       -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.
+              A 'kmin' value of 0 will turn off insertion of key frames.  Typ‐
+              ical  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.
+              These  two  options  are  relevant only for animated images with
+              large number of frames (>50).
+              When lower values are used, more frames will be converted to key
+              frames.  This  may  lead to smaller number of frames required to
+              decode a frame on average, thereby improving the  decoding  per‐
+              formance.  But  this  may  lead  to  slightly bigger file sizes.
+              Higher values  may  lead  to  worse  decoding  performance,  but
+              smaller file sizes.
+              Some restrictions:
+              (i) kmin < kmax,
+              (ii) kmin >= kmax / 2 + 1 and
+              (iii) kmax - kmin <= 30.
+              If  any of these restrictions are not met, they will be enforced
+              automatically.
+
+       -metadata string
+              A comma separated list of metadata to copy from the input to the
+              output  if  present.   Valid  values:  all, none, icc, xmp.  The
+              default is xmp.
+
+       -f int For lossy encoding only (specified by the -lossy option).  Spec‐
+              ify the strength of the deblocking filter, between 0 (no filter‐
+              ing) and 100 (maximum filtering).  A value of 0  will  turn  off
+              any  filtering.  Higher  value will increase the strength of the
+              filtering process applied after decoding the picture. The higher
+              the  value  the smoother the picture will appear. Typical values
+              are usually in the range of 20 to 50.
+
+       -mt    Use multi-threading for encoding, if possible.  This  option  is
+              only effective when using lossy compression.
+
+       -v     Print extra information.
+
+       -quiet Do not print anything.
+
+
+BUGS
+       Please     report     all     bugs     to     our     issue    tracker:
+       http://code.google.com/p/webp/issues
+       Patches welcome! See this  page  to  get  started:  http://www.webmpro‐
+       ject.org/code/contribute/submitting-patches/
+
+
+EXAMPLES
+       gif2webp picture.gif -o picture.webp
+       gif2webp -q 70 picture.gif -o picture.webp
+       gif2webp -lossy -m 3 picture.gif -o picture_lossy.webp
+       gif2webp -lossy -f 50 picture.gif -o picture.webp
+       gif2webp -q 70 -o picture.webp -- ---picture.gif
+
+
+AUTHORS
+       gif2webp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This  manual  page was written by Urvang Joshi <urvang@google.com>, for
+       the Debian project (and may be used by others).
+
+
+SEE ALSO
+       cwebp(1), dwebp(1), webpmux(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                                 March 7, 2014                     GIF2WEBP(1)

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/vwebp.html

@@ -0,0 +1,250 @@
+<!-- Creator     : groff version 1.21 -->
+<!-- CreationDate: Mon Jul 28 19:46:48 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p       { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       pre     { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       table   { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       h1      { text-align: center }
+</style>
+<title>VWEBP</title>
+
+</head>
+<body>
+
+<h1 align="center">VWEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#KEYBOARD SHORTCUTS">KEYBOARD SHORTCUTS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<h2>NAME
+<a name="NAME"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">vwebp &minus;
+decompress a WebP file and display it in a window</p>
+
+<h2>SYNOPSIS
+<a name="SYNOPSIS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>vwebp</b>
+[<i>options</i>] <i>input_file.webp</i></p>
+
+<h2>DESCRIPTION
+<a name="DESCRIPTION"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>vwebp</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>vwebp</b>
+decompresses a WebP file and displays it in a window using
+OpenGL.</p>
+
+<h2>OPTIONS
+<a name="OPTIONS"></a>
+</h2>
+
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="3%">
+
+
+<p style="margin-top: 1em"><b>&minus;h</b></p></td>
+<td width="8%"></td>
+<td width="30%">
+
+
+<p style="margin-top: 1em">Print usage summary.</p></td>
+<td width="48%">
+</td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print version number and
+exit.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p><b>&minus;noicc</b></p></td>
+<td width="2%"></td>
+<td width="56%">
+
+
+<p>Don&rsquo;t use the ICC profile if present.</p></td>
+<td width="22%">
+</td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;nofancy</b></p>
+
+<p style="margin-left:22%;">Don&rsquo;t use the fancy
+YUV420 upscaler.</p>
+
+<p style="margin-left:11%;"><b>&minus;nofilter</b></p>
+
+<p style="margin-left:22%;">Disable in-loop filtering.</p>
+
+<p style="margin-left:11%;"><b>&minus;dither</b>
+<i>strength</i></p>
+
+<p style="margin-left:22%;">Specify a dithering
+<b>strength</b> between 0 and 100. Dithering is a
+post-processing effect applied to chroma components in lossy
+compression. It helps by smoothing gradients and avoiding
+banding artifacts. Default: 50.</p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;mt</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Use multi-threading for decoding, if possible.</p></td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+<p><b>&minus;info</b></p></td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p>Display image information on top of the decoded
+image.</p> </td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;&minus;</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Explicitly specify the input
+file. This option is useful if the input file starts with an
+&rsquo;&minus;&rsquo; for instance. This option must appear
+<b>last</b>. Any other options afterward will be ignored. If
+the input file is &quot;&minus;&quot;, the data will be read
+from <i>stdin</i> instead of a file.</p>
+
+<h2>KEYBOARD SHORTCUTS
+<a name="KEYBOARD SHORTCUTS"></a>
+</h2>
+
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+<p style="margin-top: 1em"><b>&rsquo;c&rsquo;</b></p></td>
+<td width="7%"></td>
+<td width="43%">
+
+
+<p style="margin-top: 1em">Toggle use of color profile.</p></td>
+<td width="35%">
+</td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+<p><b>&rsquo;i&rsquo;</b></p></td>
+<td width="7%"></td>
+<td width="43%">
+
+
+<p>Overlay file information.</p></td>
+<td width="35%">
+</td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>&rsquo;q&rsquo; /
+&rsquo;Q&rsquo; / ESC</b></p>
+
+<p style="margin-left:22%;">Quit.</p>
+
+<h2>BUGS
+<a name="BUGS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<h2>EXAMPLES
+<a name="EXAMPLES"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">vwebp
+picture.webp <br>
+vwebp picture.webp -mt -dither 0 <br>
+vwebp &minus;&minus; &minus;&minus;&minus;picture.webp</p>
+
+<h2>AUTHORS
+<a name="AUTHORS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>vwebp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written for the Debian project (and may be used by
+others).</p>
+
+<h2>SEE ALSO
+<a name="SEE ALSO"></a>
+</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>(1)
+<br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/vwebp.txt

@@ -0,0 +1,88 @@
+VWEBP(1)                                                              VWEBP(1)
+
+
+
+NAME
+       vwebp - decompress a WebP file and display it in a window
+
+SYNOPSIS
+       vwebp [options] input_file.webp
+
+DESCRIPTION
+       This manual page documents the vwebp command.
+
+       vwebp  decompresses  a  WebP  file  and  displays  it in a window using
+       OpenGL.
+
+OPTIONS
+       -h     Print usage summary.
+
+       -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 strength
+              Specify a dithering strength between 0 and 100. Dithering  is  a
+              post-processing  effect  applied  to  chroma components in lossy
+              compression.  It helps by smoothing gradients and avoiding band‐
+              ing artifacts. Default: 50.
+
+       -mt    Use multi-threading for decoding, if possible.
+
+       -info  Display image information on top of the decoded image.
+
+       -- string
+              Explicitly  specify the input file. This option is useful if the
+              input file starts with an '-' for  instance.  This  option  must
+              appear  last.   Any  other options afterward will be ignored. If
+              the input file is "-", the data will be read from stdin  instead
+              of a file.
+
+
+
+       KEYBOARD SHORTCUTS
+
+       'c'    Toggle use of color profile.
+
+       'i'    Overlay file information.
+
+       'q' / 'Q' / ESC
+              Quit.
+
+
+BUGS
+       Please     report     all     bugs     to     our     issue    tracker:
+       http://code.google.com/p/webp/issues
+       Patches welcome! See this  page  to  get  started:  http://www.webmpro‐
+       ject.org/code/contribute/submitting-patches/
+
+
+EXAMPLES
+       vwebp picture.webp
+       vwebp picture.webp -mt -dither 0
+       vwebp -- ---picture.webp
+
+
+AUTHORS
+       vwebp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This manual page was written for the Debian project (and may be used by
+       others).
+
+
+SEE ALSO
+       dwebp(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                                 July 23, 2014                        VWEBP(1)

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/webpmux.html

@@ -0,0 +1,337 @@
+<!-- Creator     : groff version 1.21 -->
+<!-- CreationDate: Mon Jul 28 19:46:49 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p       { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       pre     { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       table   { margin-top: 0; margin-bottom: 0; vertical-align: top }
+       h1      { text-align: center }
+</style>
+<title>WEBPMUX</title>
+
+</head>
+<body>
+
+<h1 align="center">WEBPMUX</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<h2>NAME
+<a name="NAME"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">webpmux &minus;
+command line tool to create WebP Mux/container file.</p>
+
+<h2>SYNOPSIS
+<a name="SYNOPSIS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>webpmux
+&minus;get</b> <i>GET_OPTIONS INPUT</i> <b>&minus;o</b>
+<i>OUTPUT</i> <b><br>
+webpmux &minus;set</b> <i>SET_OPTIONS INPUT</i>
+<b>&minus;o</b> <i>OUTPUT</i> <b><br>
+webpmux &minus;strip</b> <i>STRIP_OPTIONS INPUT</i>
+<b>&minus;o</b> <i>OUTPUT</i> <b><br>
+webpmux &minus;frame</b> <i>FRAME_OPTIONS</i> <b>[
+&minus;frame ... ] [ &minus;loop</b> <i>LOOP_COUNT</i>
+<b>]</b></p>
+
+<p style="margin-left:23%;"><b>[ &minus;bgcolor</b>
+<i>BACKGROUND_COLOR</i> <b>] &minus;o</b> <i>OUTPUT</i></p>
+
+<p style="margin-left:11%;"><b>webpmux &minus;info</b>
+<i>INPUT</i> <b><br>
+webpmux [&minus;h|&minus;help] <br>
+webpmux &minus;version</b></p>
+
+<h2>DESCRIPTION
+<a name="DESCRIPTION"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>webpmux</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>webpmux</b>
+can be used to create a WebP container file and
+extract/strip relevant data from the container file.</p>
+
+<h2>OPTIONS
+<a name="OPTIONS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>GET_OPTIONS
+(&minus;get):</b></p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p><b>icc</b></p></td>
+<td width="5%"></td>
+<td width="27%">
+
+
+<p>Get ICC profile.</p></td>
+<td width="51%">
+</td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p><b>exif</b></p></td>
+<td width="5%"></td>
+<td width="27%">
+
+
+<p>Get EXIF metadata.</p></td>
+<td width="51%">
+</td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p><b>xmp</b></p></td>
+<td width="5%"></td>
+<td width="27%">
+
+
+<p>Get XMP metadata.</p></td>
+<td width="51%">
+</td></tr>
+</table>
+
+<p style="margin-left:11%;"><b>frame</b> <i>n</i></p>
+
+<p style="margin-left:22%;">Get nth frame.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>SET_OPTIONS
+(&minus;set) <br>
+icc</b> <i>file.icc</i></p>
+
+<p style="margin-left:22%;">Set ICC profile.</p>
+
+<p style="margin-left:11%; margin-top: 1em">Where:
+&rsquo;file.icc&rsquo; contains the ICC profile to be set.
+<b><br>
+exif</b> <i>file.exif</i></p>
+
+<p style="margin-left:22%;">Set EXIF metadata.</p>
+
+<p style="margin-left:11%; margin-top: 1em">Where:
+&rsquo;file.exif&rsquo; contains the EXIF metadata to be
+set. <b><br>
+xmp</b> <i>file.xmp</i></p>
+
+<p style="margin-left:22%;">Set XMP metadata.</p>
+
+<p style="margin-left:11%; margin-top: 1em">Where:
+&rsquo;file.xmp&rsquo; contains the XMP metadata to be
+set.</p>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>STRIP_OPTIONS
+(&minus;strip)</b></p>
+
+<table width="100%" border="0" rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p><b>icc</b></p></td>
+<td width="5%"></td>
+<td width="30%">
+
+
+<p>Strip ICC profile.</p></td>
+<td width="48%">
+</td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p><b>exif</b></p></td>
+<td width="5%"></td>
+<td width="30%">
+
+
+<p>Strip EXIF metadata.</p></td>
+<td width="48%">
+</td></tr>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p><b>xmp</b></p></td>
+<td width="5%"></td>
+<td width="30%">
+
+
+<p>Strip XMP metadata.</p></td>
+<td width="48%">
+</td></tr>
+</table>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>FRAME_OPTIONS
+(&minus;frame)</b> <i><br>
+file_i +di[+xi+yi[+mi[bi]]]</i></p>
+
+<p style="margin-left:22%;">Where: &rsquo;file_i&rsquo; is
+the i&rsquo;th frame (WebP format),
+&rsquo;xi&rsquo;,&rsquo;yi&rsquo; specify the image offset
+for this frame, &rsquo;di&rsquo; is the pause duration
+before next frame, &rsquo;mi&rsquo; is the dispose method
+for this frame (0 for NONE or 1 for BACKGROUND) and
+&rsquo;bi&rsquo; is the blending method for this frame (+b
+for BLEND or -b for NO_BLEND). Argument &rsquo;bi&rsquo; can
+be omitted and will default to +b (BLEND). Also,
+&rsquo;mi&rsquo; can be omitted if &rsquo;bi&rsquo; is
+omitted and will default to 0 (NONE). Finally, if
+&rsquo;mi&rsquo; and &rsquo;bi&rsquo; are omitted then
+&rsquo;xi&rsquo; and &rsquo;yi&rsquo; can be omitted and
+will default to +0+0.</p>
+
+<p style="margin-left:11%;"><b>&minus;loop</b> <i>n</i></p>
+
+<p style="margin-left:22%;">Loop the frames n number of
+times. 0 indicates the frames should loop forever. Valid
+range is 0 to 65535 [Default: 0 (infinite)].</p>
+
+<p style="margin-left:11%;"><b>&minus;bgcolor</b>
+<i>A,R,G,B</i></p>
+
+<p style="margin-left:22%;">Background color of the canvas.
+<br>
+where: &rsquo;A&rsquo;, &rsquo;R&rsquo;, &rsquo;G&rsquo; and
+&rsquo;B&rsquo; are integers in the range 0 to 255
+specifying the Alpha, Red, Green and Blue component values
+respectively [Default: 255,255,255,255].</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>INPUT</b>
+<br>
+Input file in WebP format.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>OUTPUT
+(&minus;o)</b> <br>
+Output file in WebP format.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>Note:</b>
+<br>
+The nature of EXIF, XMP and ICC data is not checked and is
+assumed to <br>
+be valid.</p>
+
+<h2>BUGS
+<a name="BUGS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<h2>EXAMPLES
+<a name="EXAMPLES"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">webpmux
+&minus;set icc image_profile.icc in.webp &minus;o
+icc_container.webp <br>
+webpmux &minus;get icc icc_container.webp &minus;o
+image_profile.icc <br>
+webpmux &minus;strip icc icc_container.webp &minus;o
+without_icc.webp <br>
+webpmux &minus;set xmp image_metadata.xmp in.webp &minus;o
+xmp_container.webp <br>
+webpmux &minus;get xmp xmp_container.webp &minus;o
+image_metadata.xmp <br>
+webpmux &minus;strip xmp xmp_container.webp &minus;o
+without_xmp.webp <br>
+webpmux &minus;set exif image_metadata.exif in.webp &minus;o
+exif_container.webp <br>
+webpmux &minus;get exif exif_container.webp &minus;o
+image_metadata.exif <br>
+webpmux &minus;strip exif exif_container.webp &minus;o
+without_exif.webp <br>
+webpmux &minus;frame anim_1.webp +100 &minus;frame
+anim_2.webp +100+50+50</p>
+
+<p style="margin-left:23%;">&minus;frame anim_2.webp
++100+50+50+1+b &minus;loop 10 &minus;bgcolor
+255,255,255,255</p>
+
+<p style="margin-left:35%;">&minus;o
+anim_container.webp</p>
+
+<p style="margin-left:23%;">webpmux &minus;get frame 2
+anim_container.webp &minus;o frame_2.webp <br>
+webpmux &minus;set icc image_profile.icc &minus;o
+icc_container.webp &minus;&minus;
+&minus;&minus;&minus;in.webp <br>
+webpmux &minus;get icc &minus;o image_profile.icc
+&minus;&minus; &minus;&minus;&minus;icc_container.webp <br>
+webpmux &minus;strip icc &minus;o without_icc.webp
+&minus;&minus; &minus;&minus;&minus;icc_container.webp</p>
+
+<h2>AUTHORS
+<a name="AUTHORS"></a>
+</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>webpmux</b>
+is written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Vikas Arora
+&lt;vikaas.arora@gmail.com&gt;, for the Debian project (and
+may be used by others).</p>
+
+<h2>SEE ALSO
+<a name="SEE ALSO"></a>
+</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>(1),
+<b>dwebp</b>(1), <b>gif2webp</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-linux-x86-64/doc/webpmux.txt

@@ -0,0 +1,141 @@
+WEBPMUX(1)                                                          WEBPMUX(1)
+
+
+
+NAME
+       webpmux - command line tool to create WebP Mux/container file.
+
+SYNOPSIS
+       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
+
+DESCRIPTION
+       This manual page documents the webpmux command.
+
+       webpmux  can  be used to create a WebP container file and extract/strip
+       relevant data from the container file.
+
+OPTIONS
+   GET_OPTIONS (-get):
+       icc    Get ICC profile.
+
+       exif   Get EXIF metadata.
+
+       xmp    Get XMP metadata.
+
+       frame n
+              Get nth frame.
+
+
+   SET_OPTIONS (-set)
+       icc file.icc
+              Set ICC profile.
+
+       Where: 'file.icc' contains the ICC profile to be set.
+
+       exif file.exif
+              Set EXIF metadata.
+
+       Where: 'file.exif' contains the EXIF metadata to be set.
+
+       xmp file.xmp
+              Set XMP metadata.
+
+       Where: 'file.xmp' contains the XMP metadata to be set.
+
+
+   STRIP_OPTIONS (-strip)
+       icc    Strip ICC profile.
+
+       exif   Strip EXIF metadata.
+
+       xmp    Strip XMP metadata.
+
+
+   FRAME_OPTIONS (-frame)
+       file_i +di[+xi+yi[+mi[bi]]]
+              Where: 'file_i' is the i'th frame (WebP format), 'xi','yi' spec‐
+              ify  the image offset for this frame, 'di' is the pause duration
+              before next frame, 'mi' is the dispose method for this frame  (0
+              for  NONE  or  1 for BACKGROUND) and 'bi' is the blending method
+              for this frame (+b for BLEND or -b for NO_BLEND).  Argument 'bi'
+              can  be  omitted and will default to +b (BLEND).  Also, 'mi' can
+              be omitted if 'bi' is omitted and  will  default  to  0  (NONE).
+              Finally,  if 'mi' and 'bi' are omitted then 'xi' and 'yi' can be
+              omitted and will default to +0+0.
+
+       -loop n
+              Loop the frames n number of times. 0 indicates the frames should
+              loop  forever.   Valid  range  is  0 to 65535 [Default: 0 (infi‐
+              nite)].
+
+       -bgcolor A,R,G,B
+              Background color of the canvas.
+              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
+       Input file in WebP format.
+
+
+   OUTPUT (-o)
+       Output file in WebP format.
+
+
+   Note:
+       The nature of EXIF, XMP and ICC data is not checked and is  assumed  to
+       be valid.
+
+
+BUGS
+       Please     report     all     bugs     to     our     issue    tracker:
+       http://code.google.com/p/webp/issues
+       Patches welcome! See this  page  to  get  started:  http://www.webmpro‐
+       ject.org/code/contribute/submitting-patches/
+
+
+EXAMPLES
+       webpmux -set icc image_profile.icc in.webp -o icc_container.webp
+       webpmux -get icc icc_container.webp -o image_profile.icc
+       webpmux -strip icc icc_container.webp -o without_icc.webp
+       webpmux -set xmp image_metadata.xmp in.webp -o xmp_container.webp
+       webpmux -get xmp xmp_container.webp -o image_metadata.xmp
+       webpmux -strip xmp xmp_container.webp -o without_xmp.webp
+       webpmux -set exif image_metadata.exif in.webp -o exif_container.webp
+       webpmux -get exif exif_container.webp -o image_metadata.exif
+       webpmux -strip exif exif_container.webp -o without_exif.webp
+       webpmux -frame anim_1.webp +100 -frame anim_2.webp +100+50+50
+               -frame    anim_2.webp    +100+50+50+1+b   -loop   10   -bgcolor
+               255,255,255,255
+                       -o anim_container.webp
+               webpmux -get frame 2 anim_container.webp -o frame_2.webp
+               webpmux -set icc  image_profile.icc  -o  icc_container.webp  --
+               ---in.webp
+               webpmux -get icc -o image_profile.icc -- ---icc_container.webp
+               webpmux -strip icc -o without_icc.webp -- ---icc_container.webp
+
+
+AUTHORS
+       webpmux is written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This  manual  page was written by Vikas Arora <vikaas.arora@gmail.com>,
+       for the Debian project (and may be used by others).
+
+
+SEE ALSO
+       cwebp(1), dwebp(1), gif2webp(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                               December 17, 2013                    WEBPMUX(1)

WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/decode.h

@@ -0,0 +1,499 @@
+// Copyright 2010 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.
+// -----------------------------------------------------------------------------
+//
+//  Main decoding functions for WebP images.
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_DECODE_H_
+#define WEBP_WEBP_DECODE_H_
+
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_DECODER_ABI_VERSION 0x0203    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum VP8StatusCode VP8StatusCode;
+// typedef enum WEBP_CSP_MODE WEBP_CSP_MODE;
+typedef struct WebPRGBABuffer WebPRGBABuffer;
+typedef struct WebPYUVABuffer WebPYUVABuffer;
+typedef struct WebPDecBuffer WebPDecBuffer;
+typedef struct WebPIDecoder WebPIDecoder;
+typedef struct WebPBitstreamFeatures WebPBitstreamFeatures;
+typedef struct WebPDecoderOptions WebPDecoderOptions;
+typedef struct WebPDecoderConfig WebPDecoderConfig;
+
+// Return the decoder's version number, packed in hexadecimal using 8bits for
+// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetDecoderVersion(void);
+
+// Retrieve basic header information: width, height.
+// This function will also validate the header and return 0 in
+// case of formatting error.
+// Pointers 'width' and 'height' can be passed NULL if deemed irrelevant.
+WEBP_EXTERN(int) WebPGetInfo(const uint8_t* data, size_t data_size,
+                             int* width, int* height);
+
+// Decodes WebP images pointed to by 'data' and returns RGBA samples, along
+// with the dimensions in *width and *height. The ordering of samples in
+// memory is R, G, B, A, R, G, B, A... in scan order (endian-independent).
+// The returned pointer should be deleted calling free().
+// Returns NULL in case of error.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGBA(const uint8_t* data, size_t data_size,
+                                     int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning A, R, G, B, A, R, G, B... ordered data.
+WEBP_EXTERN(uint8_t*) WebPDecodeARGB(const uint8_t* data, size_t data_size,
+                                     int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning B, G, R, A, B, G, R, A... ordered data.
+WEBP_EXTERN(uint8_t*) WebPDecodeBGRA(const uint8_t* data, size_t data_size,
+                                     int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning R, G, B, R, G, B... ordered data.
+// If the bitstream contains transparency, it is ignored.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGB(const uint8_t* data, size_t data_size,
+                                    int* width, int* height);
+
+// Same as WebPDecodeRGB, but returning B, G, R, B, G, R... ordered data.
+WEBP_EXTERN(uint8_t*) WebPDecodeBGR(const uint8_t* data, size_t data_size,
+                                    int* width, int* height);
+
+
+// Decode WebP images pointed to by 'data' to Y'UV format(*). The pointer
+// returned is the Y samples buffer. Upon return, *u and *v will point to
+// the U and V chroma data. These U and V buffers need NOT be free()'d,
+// unlike the returned Y luma one. The dimension of the U and V planes
+// are both (*width + 1) / 2 and (*height + 1)/ 2.
+// Upon return, the Y buffer has a stride returned as '*stride', while U and V
+// have a common stride returned as '*uv_stride'.
+// Return NULL in case of error.
+// (*) Also named Y'CbCr. See: http://en.wikipedia.org/wiki/YCbCr
+WEBP_EXTERN(uint8_t*) WebPDecodeYUV(const uint8_t* data, size_t data_size,
+                                    int* width, int* height,
+                                    uint8_t** u, uint8_t** v,
+                                    int* stride, int* uv_stride);
+
+// These five functions are variants of the above ones, that decode the image
+// directly into a pre-allocated buffer 'output_buffer'. The maximum storage
+// available in this buffer is indicated by 'output_buffer_size'. If this
+// storage is not sufficient (or an error occurred), NULL is returned.
+// Otherwise, output_buffer is returned, for convenience.
+// The parameter 'output_stride' specifies the distance (in bytes)
+// between scanlines. Hence, output_buffer_size is expected to be at least
+// output_stride x picture-height.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGBAInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN(uint8_t*) WebPDecodeARGBInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN(uint8_t*) WebPDecodeBGRAInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// RGB and BGR variants. Here too the transparency information, if present,
+// will be dropped and ignored.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGBInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN(uint8_t*) WebPDecodeBGRInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// WebPDecodeYUVInto() is a variant of WebPDecodeYUV() that operates directly
+// into pre-allocated luma/chroma plane buffers. This function requires the
+// strides to be passed: one for the luma plane and one for each of the
+// chroma ones. The size of each plane buffer is passed as 'luma_size',
+// 'u_size' and 'v_size' respectively.
+// Pointer to the luma plane ('*luma') is returned or NULL if an error occurred
+// during decoding (or because some buffers were found to be too small).
+WEBP_EXTERN(uint8_t*) WebPDecodeYUVInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride);
+
+//------------------------------------------------------------------------------
+// Output colorspaces and buffer
+
+// Colorspaces
+// Note: the naming describes the byte-ordering of packed samples in memory.
+// For instance, MODE_BGRA relates to samples ordered as B,G,R,A,B,G,R,A,...
+// Non-capital names (e.g.:MODE_Argb) relates to pre-multiplied RGB channels.
+// RGBA-4444 and RGB-565 colorspaces are represented by following byte-order:
+// RGBA-4444: [r3 r2 r1 r0 g3 g2 g1 g0], [b3 b2 b1 b0 a3 a2 a1 a0], ...
+// RGB-565: [r4 r3 r2 r1 r0 g5 g4 g3], [g2 g1 g0 b4 b3 b2 b1 b0], ...
+// In the case WEBP_SWAP_16BITS_CSP is defined, the bytes are swapped for
+// these two modes:
+// RGBA-4444: [b3 b2 b1 b0 a3 a2 a1 a0], [r3 r2 r1 r0 g3 g2 g1 g0], ...
+// RGB-565: [g2 g1 g0 b4 b3 b2 b1 b0], [r4 r3 r2 r1 r0 g5 g4 g3], ...
+
+typedef enum WEBP_CSP_MODE {
+  MODE_RGB = 0, MODE_RGBA = 1,
+  MODE_BGR = 2, MODE_BGRA = 3,
+  MODE_ARGB = 4, MODE_RGBA_4444 = 5,
+  MODE_RGB_565 = 6,
+  // RGB-premultiplied transparent modes (alpha value is preserved)
+  MODE_rgbA = 7,
+  MODE_bgrA = 8,
+  MODE_Argb = 9,
+  MODE_rgbA_4444 = 10,
+  // YUV modes must come after RGB ones.
+  MODE_YUV = 11, MODE_YUVA = 12,  // yuv 4:2:0
+  MODE_LAST = 13
+} WEBP_CSP_MODE;
+
+// Some useful macros:
+static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
+  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
+          mode == MODE_rgbA_4444);
+}
+
+static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
+  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
+          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
+          WebPIsPremultipliedMode(mode));
+}
+
+static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
+  return (mode < MODE_YUV);
+}
+
+//------------------------------------------------------------------------------
+// WebPDecBuffer: Generic structure for describing the output sample buffer.
+
+struct WebPRGBABuffer {    // view as RGBA
+  uint8_t* rgba;    // pointer to RGBA samples
+  int stride;       // stride in bytes from one scanline to the next.
+  size_t size;      // total size of the *rgba buffer.
+};
+
+struct WebPYUVABuffer {              // view as YUVA
+  uint8_t* y, *u, *v, *a;     // pointer to luma, chroma U/V, alpha samples
+  int y_stride;               // luma stride
+  int u_stride, v_stride;     // chroma strides
+  int a_stride;               // alpha stride
+  size_t y_size;              // luma plane size
+  size_t u_size, v_size;      // chroma planes size
+  size_t a_size;              // alpha-plane size
+};
+
+// Output buffer
+struct WebPDecBuffer {
+  WEBP_CSP_MODE colorspace;  // Colorspace.
+  int width, height;         // Dimensions.
+  int is_external_memory;    // If true, 'internal_memory' pointer is not used.
+  union {
+    WebPRGBABuffer RGBA;
+    WebPYUVABuffer YUVA;
+  } u;                       // Nameless union of buffer parameters.
+  uint32_t       pad[4];     // padding for later use
+
+  uint8_t* private_memory;   // Internally allocated memory (only when
+                             // is_external_memory is false). Should not be used
+                             // externally, but accessed via the buffer union.
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPInitDecBufferInternal(WebPDecBuffer*, int);
+
+// Initialize the structure as empty. Must be called before any other use.
+// Returns false in case of version mismatch
+static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
+  return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
+}
+
+// Free any memory associated with the buffer. Must always be called last.
+// Note: doesn't free the 'buffer' structure itself.
+WEBP_EXTERN(void) WebPFreeDecBuffer(WebPDecBuffer* buffer);
+
+//------------------------------------------------------------------------------
+// Enumeration of the status codes
+
+typedef enum VP8StatusCode {
+  VP8_STATUS_OK = 0,
+  VP8_STATUS_OUT_OF_MEMORY,
+  VP8_STATUS_INVALID_PARAM,
+  VP8_STATUS_BITSTREAM_ERROR,
+  VP8_STATUS_UNSUPPORTED_FEATURE,
+  VP8_STATUS_SUSPENDED,
+  VP8_STATUS_USER_ABORT,
+  VP8_STATUS_NOT_ENOUGH_DATA
+} VP8StatusCode;
+
+//------------------------------------------------------------------------------
+// Incremental decoding
+//
+// This API allows streamlined decoding of partial data.
+// Picture can be incrementally decoded as data become available thanks to the
+// WebPIDecoder object. This object can be left in a SUSPENDED state if the
+// picture is only partially decoded, pending additional input.
+// Code example:
+//
+//   WebPInitDecBuffer(&buffer);
+//   buffer.colorspace = mode;
+//   ...
+//   WebPIDecoder* idec = WebPINewDecoder(&buffer);
+//   while (has_more_data) {
+//     // ... (get additional data)
+//     status = WebPIAppend(idec, new_data, new_data_size);
+//     if (status != VP8_STATUS_SUSPENDED ||
+//       break;
+//     }
+//
+//     // The above call decodes the current available buffer.
+//     // Part of the image can now be refreshed by calling to
+//     // WebPIDecGetRGB()/WebPIDecGetYUVA() etc.
+//   }
+//   WebPIDelete(idec);
+
+// Creates a new incremental decoder with the supplied buffer parameter.
+// This output_buffer can be passed NULL, in which case a default output buffer
+// is used (with MODE_RGB). Otherwise, an internal reference to 'output_buffer'
+// is kept, which means that the lifespan of 'output_buffer' must be larger than
+// that of the returned WebPIDecoder object.
+// The supplied 'output_buffer' content MUST NOT be changed between calls to
+// WebPIAppend() or WebPIUpdate() unless 'output_buffer.is_external_memory' is
+// set to 1. In such a case, it is allowed to modify the pointers, size and
+// stride of output_buffer.u.RGBA or output_buffer.u.YUVA, provided they remain
+// within valid bounds.
+// All other fields of WebPDecBuffer MUST remain constant between calls.
+// Returns NULL if the allocation failed.
+WEBP_EXTERN(WebPIDecoder*) WebPINewDecoder(WebPDecBuffer* output_buffer);
+
+// This function allocates and initializes an incremental-decoder object, which
+// will output the RGB/A samples specified by 'csp' into a preallocated
+// buffer 'output_buffer'. The size of this buffer is at least
+// 'output_buffer_size' and the stride (distance in bytes between two scanlines)
+// is specified by 'output_stride'.
+// Additionally, output_buffer can be passed NULL in which case the output
+// buffer will be allocated automatically when the decoding starts. The
+// colorspace 'csp' is taken into account for allocating this buffer. All other
+// parameters are ignored.
+// Returns NULL if the allocation failed, or if some parameters are invalid.
+WEBP_EXTERN(WebPIDecoder*) WebPINewRGB(
+    WEBP_CSP_MODE csp,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// This function allocates and initializes an incremental-decoder object, which
+// will output the raw luma/chroma samples into a preallocated planes if
+// supplied. The luma plane is specified by its pointer 'luma', its size
+// 'luma_size' and its stride 'luma_stride'. Similarly, the chroma-u plane
+// is specified by the 'u', 'u_size' and 'u_stride' parameters, and the chroma-v
+// plane by 'v' and 'v_size'. And same for the alpha-plane. The 'a' pointer
+// can be pass NULL in case one is not interested in the transparency plane.
+// Conversely, 'luma' can be passed NULL if no preallocated planes are supplied.
+// In this case, the output buffer will be automatically allocated (using
+// MODE_YUVA) when decoding starts. All parameters are then ignored.
+// Returns NULL if the allocation failed or if a parameter is invalid.
+WEBP_EXTERN(WebPIDecoder*) WebPINewYUVA(
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride,
+    uint8_t* a, size_t a_size, int a_stride);
+
+// Deprecated version of the above, without the alpha plane.
+// Kept for backward compatibility.
+WEBP_EXTERN(WebPIDecoder*) WebPINewYUV(
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride);
+
+// Deletes the WebPIDecoder object and associated memory. Must always be called
+// if WebPINewDecoder, WebPINewRGB or WebPINewYUV succeeded.
+WEBP_EXTERN(void) WebPIDelete(WebPIDecoder* idec);
+
+// Copies and decodes the next available data. Returns VP8_STATUS_OK when
+// the image is successfully decoded. Returns VP8_STATUS_SUSPENDED when more
+// data is expected. Returns error in other cases.
+WEBP_EXTERN(VP8StatusCode) WebPIAppend(
+    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+
+// A variant of the above function to be used when data buffer contains
+// partial data from the beginning. In this case data buffer is not copied
+// to the internal memory.
+// Note that the value of the 'data' pointer can change between calls to
+// WebPIUpdate, for instance when the data buffer is resized to fit larger data.
+WEBP_EXTERN(VP8StatusCode) WebPIUpdate(
+    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+
+// Returns the RGB/A image decoded so far. Returns NULL if output params
+// are not initialized yet. The RGB/A output type corresponds to the colorspace
+// specified during call to WebPINewDecoder() or WebPINewRGB().
+// *last_y is the index of last decoded row in raster scan order. Some pointers
+// (*last_y, *width etc.) can be NULL if corresponding information is not
+// needed.
+WEBP_EXTERN(uint8_t*) WebPIDecGetRGB(
+    const WebPIDecoder* idec, int* last_y,
+    int* width, int* height, int* stride);
+
+// Same as above function to get a YUVA image. Returns pointer to the luma
+// plane or NULL in case of error. If there is no alpha information
+// the alpha pointer '*a' will be returned NULL.
+WEBP_EXTERN(uint8_t*) WebPIDecGetYUVA(
+    const WebPIDecoder* idec, int* last_y,
+    uint8_t** u, uint8_t** v, uint8_t** a,
+    int* width, int* height, int* stride, int* uv_stride, int* a_stride);
+
+// Deprecated alpha-less version of WebPIDecGetYUVA(): it will ignore the
+// alpha information (if present). Kept for backward compatibility.
+static WEBP_INLINE uint8_t* WebPIDecGetYUV(
+    const WebPIDecoder* idec, int* last_y, uint8_t** u, uint8_t** v,
+    int* width, int* height, int* stride, int* uv_stride) {
+  return WebPIDecGetYUVA(idec, last_y, u, v, NULL, width, height,
+                         stride, uv_stride, NULL);
+}
+
+// Generic call to retrieve information about the displayable area.
+// If non NULL, the left/right/width/height pointers are filled with the visible
+// rectangular area so far.
+// Returns NULL in case the incremental decoder object is in an invalid state.
+// Otherwise returns the pointer to the internal representation. This structure
+// is read-only, tied to WebPIDecoder's lifespan and should not be modified.
+WEBP_EXTERN(const WebPDecBuffer*) WebPIDecodedArea(
+    const WebPIDecoder* idec, int* left, int* top, int* width, int* height);
+
+//------------------------------------------------------------------------------
+// Advanced decoding parametrization
+//
+//  Code sample for using the advanced decoding API
+/*
+     // 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', if needed
+     config.no_fancy_upsampling = 1;
+     config.output.colorspace = MODE_BGRA;
+     // etc.
+
+     // Note that you can also make config.output point to an externally
+     // supplied memory buffer, provided it's big enough to store the decoded
+     // picture. Otherwise, config.output will just be used to allocate memory
+     // and store the decoded picture.
+
+     // D) Decode!
+     CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
+
+     // E) Decoded image is now in config.output (and config.output.u.RGBA)
+
+     // F) 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);
+*/
+
+// Features gathered from the bitstream
+struct WebPBitstreamFeatures {
+  int width;          // Width in pixels, as read from the bitstream.
+  int height;         // Height in pixels, as read from the bitstream.
+  int has_alpha;      // True if the bitstream contains an alpha channel.
+  int has_animation;  // True if the bitstream is an animation.
+  int format;         // 0 = undefined (/mixed), 1 = lossy, 2 = lossless
+
+  // Unused for now:
+  int no_incremental_decoding;  // if true, using incremental decoding is not
+                                // recommended.
+  int rotate;                   // TODO(later)
+  int uv_sampling;              // should be 0 for now. TODO(later)
+  uint32_t pad[2];              // padding for later use
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(VP8StatusCode) WebPGetFeaturesInternal(
+    const uint8_t*, size_t, WebPBitstreamFeatures*, int);
+
+// Retrieve features from the bitstream. The *features structure is filled
+// with information gathered from the bitstream.
+// Returns VP8_STATUS_OK when the features are successfully retrieved. Returns
+// VP8_STATUS_NOT_ENOUGH_DATA when more data is needed to retrieve the
+// features from headers. Returns error in other cases.
+static WEBP_INLINE VP8StatusCode WebPGetFeatures(
+    const uint8_t* data, size_t data_size,
+    WebPBitstreamFeatures* features) {
+  return WebPGetFeaturesInternal(data, data_size, features,
+                                 WEBP_DECODER_ABI_VERSION);
+}
+
+// Decoding options
+struct WebPDecoderOptions {
+  int bypass_filtering;               // if true, skip the in-loop filtering
+  int no_fancy_upsampling;            // if true, use faster pointwise upsampler
+  int use_cropping;                   // if true, cropping is applied _first_
+  int crop_left, crop_top;            // top-left position for cropping.
+                                      // Will be snapped to even values.
+  int crop_width, crop_height;        // dimension of the cropping area
+  int use_scaling;                    // if true, scaling is applied _afterward_
+  int scaled_width, scaled_height;    // final resolution
+  int use_threads;                    // if true, use multi-threaded decoding
+  int dithering_strength;             // dithering strength (0=Off, 100=full)
+#if WEBP_DECODER_ABI_VERSION > 0x0203
+  int flip;                           // flip output vertically
+  int alpha_dithering_strength;       // alpha dithering strength in [0..100]
+#endif
+
+  // Unused for now:
+  int force_rotation;                 // forced rotation (to be applied _last_)
+  int no_enhancement;                 // if true, discard enhancement layer
+#if WEBP_DECODER_ABI_VERSION > 0x0203
+  uint32_t pad[3];                    // padding for later use
+#else
+  uint32_t pad[5];                    // padding for later use
+#endif
+};
+
+// Main object storing the configuration for advanced decoding.
+struct WebPDecoderConfig {
+  WebPBitstreamFeatures input;  // Immutable bitstream features (optional)
+  WebPDecBuffer output;         // Output buffer (can point to external mem)
+  WebPDecoderOptions options;   // Decoding options
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPInitDecoderConfigInternal(WebPDecoderConfig*, int);
+
+// Initialize the configuration as empty. This function must always be
+// called first, unless WebPGetFeatures() is to be called.
+// Returns false in case of mismatched version.
+static WEBP_INLINE int WebPInitDecoderConfig(WebPDecoderConfig* config) {
+  return WebPInitDecoderConfigInternal(config, WEBP_DECODER_ABI_VERSION);
+}
+
+// Instantiate a new incremental decoder object with the requested
+// configuration. The bitstream can be passed using 'data' and 'data_size'
+// parameter, in which case the features will be parsed and stored into
+// config->input. Otherwise, 'data' can be NULL and no parsing will occur.
+// Note that 'config' can be NULL too, in which case a default configuration
+// is used.
+// The return WebPIDecoder object must always be deleted calling WebPIDelete().
+// Returns NULL in case of error (and config->status will then reflect
+// the error condition).
+WEBP_EXTERN(WebPIDecoder*) WebPIDecode(const uint8_t* data, size_t data_size,
+                                       WebPDecoderConfig* config);
+
+// Non-incremental version. This version decodes the full data at once, taking
+// 'config' into account. Returns decoding status (which should be VP8_STATUS_OK
+// if the decoding was successful).
+WEBP_EXTERN(VP8StatusCode) WebPDecode(const uint8_t* data, size_t data_size,
+                                      WebPDecoderConfig* config);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_DECODE_H_ */

WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/demux.h

@@ -0,0 +1,224 @@
+// Copyright 2012 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.
+// -----------------------------------------------------------------------------
+//
+// Demux API.
+// Enables extraction of image and extended format data from WebP files.
+
+// 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);
+*/
+
+#ifndef WEBP_WEBP_DEMUX_H_
+#define WEBP_WEBP_DEMUX_H_
+
+#include "./mux_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_DEMUX_ABI_VERSION 0x0101    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPDemuxState WebPDemuxState;
+// typedef enum WebPFormatFeature WebPFormatFeature;
+typedef struct WebPDemuxer WebPDemuxer;
+typedef struct WebPIterator WebPIterator;
+typedef struct WebPChunkIterator WebPChunkIterator;
+
+//------------------------------------------------------------------------------
+
+// Returns the version number of the demux library, packed in hexadecimal using
+// 8bits for each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetDemuxVersion(void);
+
+//------------------------------------------------------------------------------
+// Life of a Demux object
+
+typedef enum WebPDemuxState {
+  WEBP_DEMUX_PARSE_ERROR    = -1,  // An error occurred while parsing.
+  WEBP_DEMUX_PARSING_HEADER =  0,  // Not enough data to parse full header.
+  WEBP_DEMUX_PARSED_HEADER  =  1,  // Header parsing complete,
+                                   // data may be available.
+  WEBP_DEMUX_DONE           =  2   // Entire file has been parsed.
+} WebPDemuxState;
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(WebPDemuxer*) WebPDemuxInternal(
+    const WebPData*, int, WebPDemuxState*, int);
+
+// Parses the full WebP file given by 'data'.
+// Returns a WebPDemuxer object on successful parse, NULL otherwise.
+static WEBP_INLINE WebPDemuxer* WebPDemux(const WebPData* data) {
+  return WebPDemuxInternal(data, 0, NULL, WEBP_DEMUX_ABI_VERSION);
+}
+
+// Parses the possibly incomplete WebP file given by 'data'.
+// If 'state' is non-NULL it will be set to indicate the status of the demuxer.
+// Returns NULL in case of error or if there isn't enough data to start parsing;
+// and a WebPDemuxer object on successful parse.
+// Note that WebPDemuxer keeps internal pointers to 'data' memory segment.
+// If this data is volatile, the demuxer object should be deleted (by calling
+// WebPDemuxDelete()) and WebPDemuxPartial() called again on the new data.
+// This is usually an inexpensive operation.
+static WEBP_INLINE WebPDemuxer* WebPDemuxPartial(
+    const WebPData* data, WebPDemuxState* state) {
+  return WebPDemuxInternal(data, 1, state, WEBP_DEMUX_ABI_VERSION);
+}
+
+// Frees memory associated with 'dmux'.
+WEBP_EXTERN(void) WebPDemuxDelete(WebPDemuxer* dmux);
+
+//------------------------------------------------------------------------------
+// Data/information extraction.
+
+typedef enum WebPFormatFeature {
+  WEBP_FF_FORMAT_FLAGS,  // Extended format flags present in the 'VP8X' chunk.
+  WEBP_FF_CANVAS_WIDTH,
+  WEBP_FF_CANVAS_HEIGHT,
+  WEBP_FF_LOOP_COUNT,
+  WEBP_FF_BACKGROUND_COLOR,
+  WEBP_FF_FRAME_COUNT    // Number of frames present in the demux object.
+                         // In case of a partial demux, this is the number of
+                         // frames seen so far, with the last frame possibly
+                         // being partial.
+} WebPFormatFeature;
+
+// Get the 'feature' value from the 'dmux'.
+// NOTE: values are only valid if WebPDemux() was used or WebPDemuxPartial()
+// returned a state > WEBP_DEMUX_PARSING_HEADER.
+WEBP_EXTERN(uint32_t) WebPDemuxGetI(
+    const WebPDemuxer* dmux, WebPFormatFeature feature);
+
+//------------------------------------------------------------------------------
+// Frame iteration.
+
+struct WebPIterator {
+  int frame_num;
+  int num_frames;          // equivalent to WEBP_FF_FRAME_COUNT.
+  int fragment_num;
+  int num_fragments;
+  int x_offset, y_offset;  // offset relative to the canvas.
+  int width, height;       // dimensions of this frame or fragment.
+  int duration;            // display duration in milliseconds.
+  WebPMuxAnimDispose dispose_method;  // dispose method for the frame.
+  int complete;   // true if 'fragment' contains a full frame. partial images
+                  // may still be decoded with the WebP incremental decoder.
+  WebPData fragment;  // The frame or fragment given by 'frame_num' and
+                      // 'fragment_num'.
+  int has_alpha;      // True if the frame or fragment contains transparency.
+  WebPMuxAnimBlend blend_method;  // Blend operation for the frame.
+
+  uint32_t pad[2];         // padding for later use.
+  void* private_;          // for internal use only.
+};
+
+// Retrieves frame 'frame_number' from 'dmux'.
+// 'iter->fragment' points to the first fragment on return from this function.
+// Individual fragments may be extracted using WebPDemuxSelectFragment().
+// Setting 'frame_number' equal to 0 will return the last frame of the image.
+// Returns false if 'dmux' is NULL or frame 'frame_number' is not present.
+// Call WebPDemuxReleaseIterator() when use of the iterator is complete.
+// NOTE: 'dmux' must persist for the lifetime of 'iter'.
+WEBP_EXTERN(int) WebPDemuxGetFrame(
+    const WebPDemuxer* dmux, int frame_number, WebPIterator* iter);
+
+// Sets 'iter->fragment' to point to the next ('iter->frame_num' + 1) or
+// previous ('iter->frame_num' - 1) frame. These functions do not loop.
+// Returns true on success, false otherwise.
+WEBP_EXTERN(int) WebPDemuxNextFrame(WebPIterator* iter);
+WEBP_EXTERN(int) WebPDemuxPrevFrame(WebPIterator* iter);
+
+// Sets 'iter->fragment' to reflect fragment number 'fragment_num'.
+// Returns true if fragment 'fragment_num' is present, false otherwise.
+WEBP_EXTERN(int) WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);
+
+// Releases any memory associated with 'iter'.
+// Must be called before any subsequent calls to WebPDemuxGetChunk() on the same
+// iter. Also, must be called before destroying the associated WebPDemuxer with
+// WebPDemuxDelete().
+WEBP_EXTERN(void) WebPDemuxReleaseIterator(WebPIterator* iter);
+
+//------------------------------------------------------------------------------
+// Chunk iteration.
+
+struct WebPChunkIterator {
+  // The current and total number of chunks with the fourcc given to
+  // WebPDemuxGetChunk().
+  int chunk_num;
+  int num_chunks;
+  WebPData chunk;    // The payload of the chunk.
+
+  uint32_t pad[6];   // padding for later use
+  void* private_;
+};
+
+// Retrieves the 'chunk_number' instance of the chunk with id 'fourcc' from
+// 'dmux'.
+// 'fourcc' is a character array containing the fourcc of the chunk to return,
+// e.g., "ICCP", "XMP ", "EXIF", etc.
+// Setting 'chunk_number' equal to 0 will return the last chunk in a set.
+// Returns true if the chunk is found, false otherwise. Image related chunk
+// payloads are accessed through WebPDemuxGetFrame() and related functions.
+// Call WebPDemuxReleaseChunkIterator() when use of the iterator is complete.
+// NOTE: 'dmux' must persist for the lifetime of the iterator.
+WEBP_EXTERN(int) WebPDemuxGetChunk(const WebPDemuxer* dmux,
+                                   const char fourcc[4], int chunk_number,
+                                   WebPChunkIterator* iter);
+
+// Sets 'iter->chunk' to point to the next ('iter->chunk_num' + 1) or previous
+// ('iter->chunk_num' - 1) chunk. These functions do not loop.
+// Returns true on success, false otherwise.
+WEBP_EXTERN(int) WebPDemuxNextChunk(WebPChunkIterator* iter);
+WEBP_EXTERN(int) WebPDemuxPrevChunk(WebPChunkIterator* iter);
+
+// Releases any memory associated with 'iter'.
+// Must be called before destroying the associated WebPDemuxer with
+// WebPDemuxDelete().
+WEBP_EXTERN(void) WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_DEMUX_H_ */

WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/encode.h

@@ -0,0 +1,508 @@
+// Copyright 2011 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 encoder: main interface
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_ENCODE_H_
+#define WEBP_WEBP_ENCODE_H_
+
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_ENCODER_ABI_VERSION 0x0202    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPImageHint WebPImageHint;
+// typedef enum WebPEncCSP WebPEncCSP;
+// typedef enum WebPPreset WebPPreset;
+// typedef enum WebPEncodingError WebPEncodingError;
+typedef struct WebPConfig WebPConfig;
+typedef struct WebPPicture WebPPicture;   // main structure for I/O
+typedef struct WebPAuxStats WebPAuxStats;
+typedef struct WebPMemoryWriter WebPMemoryWriter;
+
+// Return the encoder's version number, packed in hexadecimal using 8bits for
+// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetEncoderVersion(void);
+
+//------------------------------------------------------------------------------
+// One-stop-shop call! No questions asked:
+
+// Returns the size of the compressed data (pointed to by *output), or 0 if
+// an error occurred. The compressed data must be released by the caller
+// using the call 'free(*output)'.
+// These functions compress using the lossy format, and the quality_factor
+// can go from 0 (smaller output, lower quality) to 100 (best quality,
+// larger output).
+WEBP_EXTERN(size_t) WebPEncodeRGB(const uint8_t* rgb,
+                                  int width, int height, int stride,
+                                  float quality_factor, uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeBGR(const uint8_t* bgr,
+                                  int width, int height, int stride,
+                                  float quality_factor, uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeRGBA(const uint8_t* rgba,
+                                   int width, int height, int stride,
+                                   float quality_factor, uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeBGRA(const uint8_t* bgra,
+                                   int width, int height, int stride,
+                                   float quality_factor, uint8_t** output);
+
+// These functions are the equivalent of the above, but compressing in a
+// lossless manner. Files are usually larger than lossy format, but will
+// not suffer any compression loss.
+WEBP_EXTERN(size_t) WebPEncodeLosslessRGB(const uint8_t* rgb,
+                                          int width, int height, int stride,
+                                          uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeLosslessBGR(const uint8_t* bgr,
+                                          int width, int height, int stride,
+                                          uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeLosslessRGBA(const uint8_t* rgba,
+                                           int width, int height, int stride,
+                                           uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeLosslessBGRA(const uint8_t* bgra,
+                                           int width, int height, int stride,
+                                           uint8_t** output);
+
+//------------------------------------------------------------------------------
+// Coding parameters
+
+// Image characteristics hint for the underlying encoder.
+typedef enum WebPImageHint {
+  WEBP_HINT_DEFAULT = 0,  // default preset.
+  WEBP_HINT_PICTURE,      // digital picture, like portrait, inner shot
+  WEBP_HINT_PHOTO,        // outdoor photograph, with natural lighting
+  WEBP_HINT_GRAPH,        // Discrete tone image (graph, map-tile etc).
+  WEBP_HINT_LAST
+} WebPImageHint;
+
+// Compression parameters.
+struct WebPConfig {
+  int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
+  float quality;          // between 0 (smallest file) and 100 (biggest)
+  int method;             // quality/speed trade-off (0=fast, 6=slower-better)
+
+  WebPImageHint image_hint;  // Hint for image type (lossless only for now).
+
+  // Parameters related to lossy compression only:
+  int target_size;        // if non-zero, set the desired target size in bytes.
+                          // Takes precedence over the 'compression' parameter.
+  float target_PSNR;      // if non-zero, specifies the minimal distortion to
+                          // try to achieve. Takes precedence over target_size.
+  int segments;           // maximum number of segments to use, in [1..4]
+  int sns_strength;       // Spatial Noise Shaping. 0=off, 100=maximum.
+  int filter_strength;    // range: [0 = off .. 100 = strongest]
+  int filter_sharpness;   // range: [0 = off .. 7 = least sharp]
+  int filter_type;        // filtering type: 0 = simple, 1 = strong (only used
+                          // if filter_strength > 0 or autofilter > 0)
+  int autofilter;         // Auto adjust filter's strength [0 = off, 1 = on]
+  int alpha_compression;  // Algorithm for encoding the alpha plane (0 = none,
+                          // 1 = compressed with WebP lossless). Default is 1.
+  int alpha_filtering;    // Predictive filtering method for alpha plane.
+                          //  0: none, 1: fast, 2: best. Default if 1.
+  int alpha_quality;      // Between 0 (smallest size) and 100 (lossless).
+                          // Default is 100.
+  int pass;               // number of entropy-analysis passes (in [1..10]).
+
+  int show_compressed;    // if true, export the compressed picture back.
+                          // In-loop filtering is not applied.
+  int preprocessing;      // preprocessing filter:
+                          // 0=none, 1=segment-smooth, 2=pseudo-random dithering
+  int partitions;         // log2(number of token partitions) in [0..3]. Default
+                          // is set to 0 for easier progressive decoding.
+  int partition_limit;    // quality degradation allowed to fit the 512k limit
+                          // on prediction modes coding (0: no degradation,
+                          // 100: maximum possible degradation).
+  int emulate_jpeg_size;  // If true, compression parameters will be remapped
+                          // to better match the expected output size from
+                          // JPEG compression. Generally, the output size will
+                          // be similar but the degradation will be lower.
+  int thread_level;       // If non-zero, try and use multi-threaded encoding.
+  int low_memory;         // If set, reduce memory usage (but increase CPU use).
+
+  uint32_t pad[5];        // padding for later use
+};
+
+// Enumerate some predefined settings for WebPConfig, depending on the type
+// of source picture. These presets are used when calling WebPConfigPreset().
+typedef enum WebPPreset {
+  WEBP_PRESET_DEFAULT = 0,  // default preset.
+  WEBP_PRESET_PICTURE,      // digital picture, like portrait, inner shot
+  WEBP_PRESET_PHOTO,        // outdoor photograph, with natural lighting
+  WEBP_PRESET_DRAWING,      // hand or line drawing, with high-contrast details
+  WEBP_PRESET_ICON,         // small-sized colorful images
+  WEBP_PRESET_TEXT          // text-like
+} WebPPreset;
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPConfigInitInternal(WebPConfig*, WebPPreset, float, int);
+
+// Should always be called, to initialize a fresh WebPConfig structure before
+// modification. Returns false in case of version mismatch. WebPConfigInit()
+// must have succeeded before using the 'config' object.
+// Note that the default values are lossless=0 and quality=75.
+static WEBP_INLINE int WebPConfigInit(WebPConfig* config) {
+  return WebPConfigInitInternal(config, WEBP_PRESET_DEFAULT, 75.f,
+                                WEBP_ENCODER_ABI_VERSION);
+}
+
+// This function will initialize the configuration according to a predefined
+// set of parameters (referred to by 'preset') and a given quality factor.
+// This function can be called as a replacement to WebPConfigInit(). Will
+// return false in case of error.
+static WEBP_INLINE int WebPConfigPreset(WebPConfig* config,
+                                        WebPPreset preset, float quality) {
+  return WebPConfigInitInternal(config, preset, quality,
+                                WEBP_ENCODER_ABI_VERSION);
+}
+
+#if WEBP_ENCODER_ABI_VERSION > 0x0202
+// Activate the lossless compression mode with the desired efficiency level
+// between 0 (fastest, lowest compression) and 9 (slower, best compression).
+// A good default level is '6', providing a fair tradeoff between compression
+// speed and final compressed size.
+// This function will overwrite several fields from config: 'method', 'quality'
+// and 'lossless'. Returns false in case of parameter error.
+WEBP_EXTERN(int) WebPConfigLosslessPreset(WebPConfig* config, int level);
+#endif
+
+// Returns true if 'config' is non-NULL and all configuration parameters are
+// within their valid ranges.
+WEBP_EXTERN(int) WebPValidateConfig(const WebPConfig* config);
+
+//------------------------------------------------------------------------------
+// Input / Output
+// Structure for storing auxiliary statistics (mostly for lossy encoding).
+
+struct WebPAuxStats {
+  int coded_size;         // final size
+
+  float PSNR[5];          // peak-signal-to-noise ratio for Y/U/V/All/Alpha
+  int block_count[3];     // number of intra4/intra16/skipped macroblocks
+  int header_bytes[2];    // approximate number of bytes spent for header
+                          // and mode-partition #0
+  int residual_bytes[3][4];  // approximate number of bytes spent for
+                             // DC/AC/uv coefficients for each (0..3) segments.
+  int segment_size[4];    // number of macroblocks in each segments
+  int segment_quant[4];   // quantizer values for each segments
+  int segment_level[4];   // filtering strength for each segments [0..63]
+
+  int alpha_data_size;    // size of the transparency data
+  int layer_data_size;    // size of the enhancement layer data
+
+  // lossless encoder statistics
+  uint32_t lossless_features;  // bit0:predictor bit1:cross-color transform
+                               // bit2:subtract-green bit3:color indexing
+  int histogram_bits;          // number of precision bits of histogram
+  int transform_bits;          // precision bits for transform
+  int cache_bits;              // number of bits for color cache lookup
+  int palette_size;            // number of color in palette, if used
+  int lossless_size;           // final lossless size
+
+  uint32_t pad[4];        // padding for later use
+};
+
+// Signature for output function. Should return true if writing was successful.
+// data/data_size is the segment of data to write, and 'picture' is for
+// reference (and so one can make use of picture->custom_ptr).
+typedef int (*WebPWriterFunction)(const uint8_t* data, size_t data_size,
+                                  const WebPPicture* picture);
+
+// WebPMemoryWrite: a special WebPWriterFunction that writes to memory using
+// the following WebPMemoryWriter object (to be set as a custom_ptr).
+struct WebPMemoryWriter {
+  uint8_t* mem;       // final buffer (of size 'max_size', larger than 'size').
+  size_t   size;      // final size
+  size_t   max_size;  // total capacity
+  uint32_t pad[1];    // padding for later use
+};
+
+// The following must be called first before any use.
+WEBP_EXTERN(void) WebPMemoryWriterInit(WebPMemoryWriter* writer);
+
+#if WEBP_ENCODER_ABI_VERSION > 0x0202
+// The following must be called to deallocate writer->mem memory. The 'writer'
+// object itself is not deallocated.
+WEBP_EXTERN(void) WebPMemoryWriterClear(WebPMemoryWriter* writer);
+#endif
+// The custom writer to be used with WebPMemoryWriter as custom_ptr. Upon
+// completion, writer.mem and writer.size will hold the coded data.
+#if WEBP_ENCODER_ABI_VERSION > 0x0202
+// writer.mem must be freed by calling WebPMemoryWriterClear.
+#else
+// writer.mem must be freed by calling 'free(writer.mem)'.
+#endif
+WEBP_EXTERN(int) WebPMemoryWrite(const uint8_t* data, size_t data_size,
+                                 const WebPPicture* picture);
+
+// Progress hook, called from time to time to report progress. It can return
+// false to request an abort of the encoding process, or true otherwise if
+// everything is OK.
+typedef int (*WebPProgressHook)(int percent, const WebPPicture* picture);
+
+// Color spaces.
+typedef enum WebPEncCSP {
+  // chroma sampling
+  WEBP_YUV420  = 0,        // 4:2:0
+  WEBP_YUV420A = 4,        // alpha channel variant
+  WEBP_CSP_UV_MASK = 3,    // bit-mask to get the UV sampling factors
+  WEBP_CSP_ALPHA_BIT = 4   // bit that is set if alpha is present
+} WebPEncCSP;
+
+// Encoding error conditions.
+typedef enum WebPEncodingError {
+  VP8_ENC_OK = 0,
+  VP8_ENC_ERROR_OUT_OF_MEMORY,            // memory error allocating objects
+  VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY,  // memory error while flushing bits
+  VP8_ENC_ERROR_NULL_PARAMETER,           // a pointer parameter is NULL
+  VP8_ENC_ERROR_INVALID_CONFIGURATION,    // configuration is invalid
+  VP8_ENC_ERROR_BAD_DIMENSION,            // picture has invalid width/height
+  VP8_ENC_ERROR_PARTITION0_OVERFLOW,      // partition is bigger than 512k
+  VP8_ENC_ERROR_PARTITION_OVERFLOW,       // partition is bigger than 16M
+  VP8_ENC_ERROR_BAD_WRITE,                // error while flushing bytes
+  VP8_ENC_ERROR_FILE_TOO_BIG,             // file is bigger than 4G
+  VP8_ENC_ERROR_USER_ABORT,               // abort request by user
+  VP8_ENC_ERROR_LAST                      // list terminator. always last.
+} WebPEncodingError;
+
+// maximum width/height allowed (inclusive), in pixels
+#define WEBP_MAX_DIMENSION 16383
+
+// Main exchange structure (input samples, output bytes, statistics)
+struct WebPPicture {
+  //   INPUT
+  //////////////
+  // Main flag for encoder selecting between ARGB or YUV input.
+  // It is recommended to use ARGB input (*argb, argb_stride) for lossless
+  // compression, and YUV input (*y, *u, *v, etc.) for lossy compression
+  // since these are the respective native colorspace for these formats.
+  int use_argb;
+
+  // YUV input (mostly used for input to lossy compression)
+  WebPEncCSP colorspace;     // colorspace: should be YUV420 for now (=Y'CbCr).
+  int width, height;         // dimensions (less or equal to WEBP_MAX_DIMENSION)
+  uint8_t *y, *u, *v;        // pointers to luma/chroma planes.
+  int y_stride, uv_stride;   // luma/chroma strides.
+  uint8_t* a;                // pointer to the alpha plane
+  int a_stride;              // stride of the alpha plane
+  uint32_t pad1[2];          // padding for later use
+
+  // ARGB input (mostly used for input to lossless compression)
+  uint32_t* argb;            // Pointer to argb (32 bit) plane.
+  int argb_stride;           // This is stride in pixels units, not bytes.
+  uint32_t pad2[3];          // padding for later use
+
+  //   OUTPUT
+  ///////////////
+  // Byte-emission hook, to store compressed bytes as they are ready.
+  WebPWriterFunction writer;  // can be NULL
+  void* custom_ptr;           // can be used by the writer.
+
+  // map for extra information (only for lossy compression mode)
+  int extra_info_type;    // 1: intra type, 2: segment, 3: quant
+                          // 4: intra-16 prediction mode,
+                          // 5: chroma prediction mode,
+                          // 6: bit cost, 7: distortion
+  uint8_t* extra_info;    // if not NULL, points to an array of size
+                          // ((width + 15) / 16) * ((height + 15) / 16) that
+                          // will be filled with a macroblock map, depending
+                          // on extra_info_type.
+
+  //   STATS AND REPORTS
+  ///////////////////////////
+  // Pointer to side statistics (updated only if not NULL)
+  WebPAuxStats* stats;
+
+  // Error code for the latest error encountered during encoding
+  WebPEncodingError error_code;
+
+  // If not NULL, report progress during encoding.
+  WebPProgressHook progress_hook;
+
+  void* user_data;        // this field is free to be set to any value and
+                          // used during callbacks (like progress-report e.g.).
+
+  uint32_t pad3[3];       // padding for later use
+
+  // Unused for now
+  uint8_t *pad4, *pad5;
+  uint32_t pad6[8];       // padding for later use
+
+  // PRIVATE FIELDS
+  ////////////////////
+  void* memory_;          // row chunk of memory for yuva planes
+  void* memory_argb_;     // and for argb too.
+  void* pad7[2];          // padding for later use
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPPictureInitInternal(WebPPicture*, int);
+
+// Should always be called, to initialize the structure. Returns false in case
+// of version mismatch. WebPPictureInit() must have succeeded before using the
+// 'picture' object.
+// Note that, by default, use_argb is false and colorspace is WEBP_YUV420.
+static WEBP_INLINE int WebPPictureInit(WebPPicture* picture) {
+  return WebPPictureInitInternal(picture, WEBP_ENCODER_ABI_VERSION);
+}
+
+//------------------------------------------------------------------------------
+// WebPPicture utils
+
+// Convenience allocation / deallocation based on picture->width/height:
+// Allocate y/u/v buffers as per colorspace/width/height specification.
+// Note! This function will free the previous buffer if needed.
+// Returns false in case of memory error.
+WEBP_EXTERN(int) WebPPictureAlloc(WebPPicture* picture);
+
+// Release the memory allocated by WebPPictureAlloc() or WebPPictureImport*().
+// Note that this function does _not_ free the memory used by the 'picture'
+// object itself.
+// Besides memory (which is reclaimed) all other fields of 'picture' are
+// preserved.
+WEBP_EXTERN(void) WebPPictureFree(WebPPicture* picture);
+
+// Copy the pixels of *src into *dst, using WebPPictureAlloc. Upon return, *dst
+// will fully own the copied pixels (this is not a view). The 'dst' picture need
+// not be initialized as its content is overwritten.
+// Returns false in case of memory allocation error.
+WEBP_EXTERN(int) WebPPictureCopy(const WebPPicture* src, WebPPicture* dst);
+
+// Compute PSNR, SSIM or LSIM distortion metric between two pictures.
+// Result is in dB, stores in result[] in the Y/U/V/Alpha/All order.
+// Returns false in case of error (src and ref don't have same dimension, ...)
+// Warning: this function is rather CPU-intensive.
+WEBP_EXTERN(int) WebPPictureDistortion(
+    const WebPPicture* src, const WebPPicture* ref,
+    int metric_type,           // 0 = PSNR, 1 = SSIM, 2 = LSIM
+    float result[5]);
+
+// self-crops a picture to the rectangle defined by top/left/width/height.
+// Returns false in case of memory allocation error, or if the rectangle is
+// outside of the source picture.
+// The rectangle for the view is defined by the top-left corner pixel
+// coordinates (left, top) as well as its width and height. This rectangle
+// must be fully be comprised inside the 'src' source picture. If the source
+// picture uses the YUV420 colorspace, the top and left coordinates will be
+// snapped to even values.
+WEBP_EXTERN(int) WebPPictureCrop(WebPPicture* picture,
+                                 int left, int top, int width, int height);
+
+// Extracts a view from 'src' picture into 'dst'. The rectangle for the view
+// is defined by the top-left corner pixel coordinates (left, top) as well
+// as its width and height. This rectangle must be fully be comprised inside
+// the 'src' source picture. If the source picture uses the YUV420 colorspace,
+// the top and left coordinates will be snapped to even values.
+// Picture 'src' must out-live 'dst' picture. Self-extraction of view is allowed
+// ('src' equal to 'dst') as a mean of fast-cropping (but note that doing so,
+// the original dimension will be lost). Picture 'dst' need not be initialized
+// with WebPPictureInit() if it is different from 'src', since its content will
+// be overwritten.
+// Returns false in case of memory allocation error or invalid parameters.
+WEBP_EXTERN(int) WebPPictureView(const WebPPicture* src,
+                                 int left, int top, int width, int height,
+                                 WebPPicture* dst);
+
+// Returns true if the 'picture' is actually a view and therefore does
+// not own the memory for pixels.
+WEBP_EXTERN(int) WebPPictureIsView(const WebPPicture* picture);
+
+// Rescale a picture to new dimension width x height.
+// Now gamma correction is applied.
+// Returns false in case of error (invalid parameter or insufficient memory).
+WEBP_EXTERN(int) WebPPictureRescale(WebPPicture* pic, int width, int height);
+
+// Colorspace conversion function to import RGB samples.
+// Previous buffer will be free'd, if any.
+// *rgb buffer should have a size of at least height * rgb_stride.
+// Returns false in case of memory error.
+WEBP_EXTERN(int) WebPPictureImportRGB(
+    WebPPicture* picture, const uint8_t* rgb, int rgb_stride);
+// Same, but for RGBA buffer.
+WEBP_EXTERN(int) WebPPictureImportRGBA(
+    WebPPicture* picture, const uint8_t* rgba, int rgba_stride);
+// Same, but for RGBA buffer. Imports the RGB direct from the 32-bit format
+// input buffer ignoring the alpha channel. Avoids needing to copy the data
+// to a temporary 24-bit RGB buffer to import the RGB only.
+WEBP_EXTERN(int) WebPPictureImportRGBX(
+    WebPPicture* picture, const uint8_t* rgbx, int rgbx_stride);
+
+// Variants of the above, but taking BGR(A|X) input.
+WEBP_EXTERN(int) WebPPictureImportBGR(
+    WebPPicture* picture, const uint8_t* bgr, int bgr_stride);
+WEBP_EXTERN(int) WebPPictureImportBGRA(
+    WebPPicture* picture, const uint8_t* bgra, int bgra_stride);
+WEBP_EXTERN(int) WebPPictureImportBGRX(
+    WebPPicture* picture, const uint8_t* bgrx, int bgrx_stride);
+
+// Converts picture->argb data to the YUVA format specified by 'colorspace'.
+// Upon return, picture->use_argb is set to false. The presence of real
+// non-opaque transparent values is detected, and 'colorspace' will be
+// adjusted accordingly. Note that this method is lossy.
+// Returns false in case of error.
+WEBP_EXTERN(int) WebPPictureARGBToYUVA(WebPPicture* picture,
+                                       WebPEncCSP colorspace);
+
+// Same as WebPPictureARGBToYUVA(), but the conversion is done using
+// pseudo-random dithering with a strength 'dithering' between
+// 0.0 (no dithering) and 1.0 (maximum dithering). This is useful
+// for photographic picture.
+WEBP_EXTERN(int) WebPPictureARGBToYUVADithered(
+    WebPPicture* picture, WebPEncCSP colorspace, float dithering);
+
+// Converts picture->yuv to picture->argb and sets picture->use_argb to true.
+// The input format must be YUV_420 or YUV_420A.
+// Note that the use of this method is discouraged if one has access to the
+// raw ARGB samples, since using YUV420 is comparatively lossy. Also, the
+// conversion from YUV420 to ARGB incurs a small loss too.
+// Returns false in case of error.
+WEBP_EXTERN(int) WebPPictureYUVAToARGB(WebPPicture* picture);
+
+// Helper function: given a width x height plane of RGBA or YUV(A) samples
+// clean-up the YUV or RGB samples under fully transparent area, to help
+// compressibility (no guarantee, though).
+WEBP_EXTERN(void) WebPCleanupTransparentArea(WebPPicture* picture);
+
+// Scan the picture 'picture' for the presence of non fully opaque alpha values.
+// Returns true in such case. Otherwise returns false (indicating that the
+// alpha plane can be ignored altogether e.g.).
+WEBP_EXTERN(int) WebPPictureHasTransparency(const WebPPicture* picture);
+
+// Remove the transparency information (if present) by blending the color with
+// the background color 'background_rgb' (specified as 24bit RGB triplet).
+// After this call, all alpha values are reset to 0xff.
+WEBP_EXTERN(void) WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb);
+
+//------------------------------------------------------------------------------
+// Main call
+
+// Main encoding call, after config and picture have been initialized.
+// 'picture' must be less than 16384x16384 in dimension (cf WEBP_MAX_DIMENSION),
+// and the 'config' object must be a valid one.
+// Returns false in case of error, true otherwise.
+// In case of error, picture->error_code is updated accordingly.
+// 'picture' can hold the source samples in both YUV(A) or ARGB input, depending
+// on the value of 'picture->use_argb'. It is highly recommended to use
+// the former for lossy encoding, and the latter for lossless encoding
+// (when config.lossless is true). Automatic conversion from one format to
+// another is provided but they both incur some loss.
+WEBP_EXTERN(int) WebPEncode(const WebPConfig* config, WebPPicture* picture);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_ENCODE_H_ */

WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/mux.h

@@ -0,0 +1,399 @@
+// Copyright 2011 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.
+// -----------------------------------------------------------------------------
+//
+//  RIFF container manipulation for WebP images.
+//
+// Authors: Urvang (urvang@google.com)
+//          Vikas (vikasa@google.com)
+
+// This API allows manipulation of WebP container images containing features
+// like color profile, metadata, animation and fragmented images.
+//
+// Code Example#1: Create 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 ICCP color 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);
+*/
+
+// Code Example#2: 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_data).
+  WebPMuxDelete(mux);
+  free(data);
+*/
+
+#ifndef WEBP_WEBP_MUX_H_
+#define WEBP_WEBP_MUX_H_
+
+#include "./mux_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_MUX_ABI_VERSION 0x0101        // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPMuxError WebPMuxError;
+// typedef enum WebPChunkId WebPChunkId;
+typedef struct WebPMux WebPMux;   // main opaque object.
+typedef struct WebPMuxFrameInfo WebPMuxFrameInfo;
+typedef struct WebPMuxAnimParams WebPMuxAnimParams;
+
+// Error codes
+typedef enum WebPMuxError {
+  WEBP_MUX_OK                 =  1,
+  WEBP_MUX_NOT_FOUND          =  0,
+  WEBP_MUX_INVALID_ARGUMENT   = -1,
+  WEBP_MUX_BAD_DATA           = -2,
+  WEBP_MUX_MEMORY_ERROR       = -3,
+  WEBP_MUX_NOT_ENOUGH_DATA    = -4
+} WebPMuxError;
+
+// IDs for different types of chunks.
+typedef enum WebPChunkId {
+  WEBP_CHUNK_VP8X,     // VP8X
+  WEBP_CHUNK_ICCP,     // ICCP
+  WEBP_CHUNK_ANIM,     // ANIM
+  WEBP_CHUNK_ANMF,     // ANMF
+  WEBP_CHUNK_FRGM,     // FRGM
+  WEBP_CHUNK_ALPHA,    // ALPH
+  WEBP_CHUNK_IMAGE,    // VP8/VP8L
+  WEBP_CHUNK_EXIF,     // EXIF
+  WEBP_CHUNK_XMP,      // XMP
+  WEBP_CHUNK_UNKNOWN,  // Other chunks.
+  WEBP_CHUNK_NIL
+} WebPChunkId;
+
+//------------------------------------------------------------------------------
+
+// Returns the version number of the mux library, packed in hexadecimal using
+// 8bits for each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetMuxVersion(void);
+
+//------------------------------------------------------------------------------
+// Life of a Mux object
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(WebPMux*) WebPNewInternal(int);
+
+// Creates an empty mux object.
+// Returns:
+//   A pointer to the newly created empty mux object.
+//   Or NULL in case of memory error.
+static WEBP_INLINE WebPMux* WebPMuxNew(void) {
+  return WebPNewInternal(WEBP_MUX_ABI_VERSION);
+}
+
+// Deletes the mux object.
+// Parameters:
+//   mux - (in/out) object to be deleted
+WEBP_EXTERN(void) WebPMuxDelete(WebPMux* mux);
+
+//------------------------------------------------------------------------------
+// Mux creation.
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(WebPMux*) WebPMuxCreateInternal(const WebPData*, int, int);
+
+// Creates a mux object from raw data given in WebP RIFF format.
+// Parameters:
+//   bitstream - (in) the bitstream data in WebP RIFF format
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   A pointer to the mux object created from given data - on success.
+//   NULL - In case of invalid data or memory error.
+static WEBP_INLINE WebPMux* WebPMuxCreate(const WebPData* bitstream,
+                                          int copy_data) {
+  return WebPMuxCreateInternal(bitstream, copy_data, WEBP_MUX_ABI_VERSION);
+}
+
+//------------------------------------------------------------------------------
+// Non-image chunks.
+
+// Note: Only non-image related chunks should be managed through chunk APIs.
+// (Image related chunks are: "ANMF", "FRGM", "VP8 ", "VP8L" and "ALPH").
+// To add, get and delete images, use WebPMuxSetImage(), WebPMuxPushFrame(),
+// WebPMuxGetFrame() and WebPMuxDeleteFrame().
+
+// Adds a chunk with id 'fourcc' and data 'chunk_data' in the mux object.
+// Any existing chunk(s) with the same id will be removed.
+// Parameters:
+//   mux - (in/out) object to which the chunk is to be added
+//   fourcc - (in) a character array containing the fourcc of the given chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+//   chunk_data - (in) the chunk data to be added
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, fourcc or chunk_data is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetChunk(
+    WebPMux* mux, const char fourcc[4], const WebPData* chunk_data,
+    int copy_data);
+
+// Gets a reference to the data of the chunk with id 'fourcc' in the mux object.
+// The caller should NOT free the returned data.
+// Parameters:
+//   mux - (in) object from which the chunk data is to be fetched
+//   fourcc - (in) a character array containing the fourcc of the chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+//   chunk_data - (out) returned chunk data
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, fourcc or chunk_data is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_NOT_FOUND - If mux does not contain a chunk with the given id.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetChunk(
+    const WebPMux* mux, const char fourcc[4], WebPData* chunk_data);
+
+// Deletes the chunk with the given 'fourcc' from the mux object.
+// Parameters:
+//   mux - (in/out) object from which the chunk is to be deleted
+//   fourcc - (in) a character array containing the fourcc of the chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or fourcc is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_NOT_FOUND - If mux does not contain a chunk with the given fourcc.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxDeleteChunk(
+    WebPMux* mux, const char fourcc[4]);
+
+//------------------------------------------------------------------------------
+// Images.
+
+// Encapsulates data about a single frame/fragment.
+struct WebPMuxFrameInfo {
+  WebPData    bitstream;  // image data: can be a raw VP8/VP8L bitstream
+                          // or a single-image WebP file.
+  int         x_offset;   // x-offset of the frame.
+  int         y_offset;   // y-offset of the frame.
+  int         duration;   // duration of the frame (in milliseconds).
+
+  WebPChunkId id;         // frame type: should be one of WEBP_CHUNK_ANMF,
+                          // WEBP_CHUNK_FRGM or WEBP_CHUNK_IMAGE
+  WebPMuxAnimDispose dispose_method;  // Disposal method for the frame.
+  WebPMuxAnimBlend   blend_method;    // Blend operation for the frame.
+  uint32_t    pad[1];     // padding for later use
+};
+
+// Sets the (non-animated and non-fragmented) image in the mux object.
+// Note: Any existing images (including frames/fragments) will be removed.
+// Parameters:
+//   mux - (in/out) object in which the image is to be set
+//   bitstream - (in) can be a raw VP8/VP8L bitstream or a single-image
+//               WebP file (non-animated and non-fragmented)
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL or bitstream is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetImage(
+    WebPMux* mux, const WebPData* bitstream, int copy_data);
+
+// Adds a frame at the end of the mux object.
+// Notes: (1) frame.id should be one of WEBP_CHUNK_ANMF or WEBP_CHUNK_FRGM
+//        (2) For setting a non-animated non-fragmented image, use
+//            WebPMuxSetImage() instead.
+//        (3) Type of frame being pushed must be same as the frames in mux.
+//        (4) As WebP only supports even offsets, any odd offset will be snapped
+//            to an even location using: offset &= ~1
+// Parameters:
+//   mux - (in/out) object to which the frame is to be added
+//   frame - (in) frame data.
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or frame is NULL
+//                               or if content of 'frame' is invalid.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxPushFrame(
+    WebPMux* mux, const WebPMuxFrameInfo* frame, int copy_data);
+
+// Gets the nth frame from the mux object.
+// The content of 'frame->bitstream' is allocated using malloc(), and NOT
+// owned by the 'mux' object. It MUST be deallocated by the caller by calling
+// WebPDataClear().
+// nth=0 has a special meaning - last position.
+// Parameters:
+//   mux - (in) object from which the info is to be fetched
+//   nth - (in) index of the frame in the mux object
+//   frame - (out) data of the returned frame
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or frame is NULL.
+//   WEBP_MUX_NOT_FOUND - if there are less than nth frames in the mux object.
+//   WEBP_MUX_BAD_DATA - if nth frame chunk in mux is invalid.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetFrame(
+    const WebPMux* mux, uint32_t nth, WebPMuxFrameInfo* frame);
+
+// Deletes a frame from the mux object.
+// nth=0 has a special meaning - last position.
+// Parameters:
+//   mux - (in/out) object from which a frame is to be deleted
+//   nth - (in) The position from which the frame is to be deleted
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL.
+//   WEBP_MUX_NOT_FOUND - If there are less than nth frames in the mux object
+//                        before deletion.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);
+
+//------------------------------------------------------------------------------
+// Animation.
+
+// Animation parameters.
+struct WebPMuxAnimParams {
+  uint32_t bgcolor;  // Background color of the canvas stored (in MSB order) as:
+                     // Bits 00 to 07: Alpha.
+                     // Bits 08 to 15: Red.
+                     // Bits 16 to 23: Green.
+                     // Bits 24 to 31: Blue.
+  int loop_count;    // Number of times to repeat the animation [0 = infinite].
+};
+
+// Sets the animation parameters in the mux object. Any existing ANIM chunks
+// will be removed.
+// Parameters:
+//   mux - (in/out) object in which ANIM chunk is to be set/added
+//   params - (in) animation parameters.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or params is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetAnimationParams(
+    WebPMux* mux, const WebPMuxAnimParams* params);
+
+// Gets the animation parameters from the mux object.
+// Parameters:
+//   mux - (in) object from which the animation parameters to be fetched
+//   params - (out) animation parameters extracted from the ANIM chunk
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or params is NULL.
+//   WEBP_MUX_NOT_FOUND - if ANIM chunk is not present in mux object.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetAnimationParams(
+    const WebPMux* mux, WebPMuxAnimParams* params);
+
+//------------------------------------------------------------------------------
+// Misc Utilities.
+
+#if WEBP_MUX_ABI_VERSION > 0x0101
+// Sets the canvas size for the mux object. The width and height can be
+// specified explicitly or left as zero (0, 0).
+// * When width and height are specified explicitly, then this frame bound is
+//   enforced during subsequent calls to WebPMuxAssemble() and an error is
+//   reported if any animated frame does not completely fit within the canvas.
+// * When unspecified (0, 0), the constructed canvas will get the frame bounds
+//   from the bounding-box over all frames after calling WebPMuxAssemble().
+// Parameters:
+//   mux - (in) object to which the canvas size is to be set
+//   width - (in) canvas width
+//   height - (in) canvas height
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL; or
+//                               width or height are invalid or out of bounds
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetCanvasSize(WebPMux* mux,
+                                               int width, int height);
+#endif
+
+// Gets the canvas size from the mux object.
+// Note: This method assumes that the VP8X chunk, if present, is up-to-date.
+// That is, the mux object hasn't been modified since the last call to
+// WebPMuxAssemble() or WebPMuxCreate().
+// Parameters:
+//   mux - (in) object from which the canvas size is to be fetched
+//   width - (out) canvas width
+//   height - (out) canvas height
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, width or height is NULL.
+//   WEBP_MUX_BAD_DATA - if VP8X/VP8/VP8L chunk or canvas size is invalid.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetCanvasSize(const WebPMux* mux,
+                                               int* width, int* height);
+
+// Gets the feature flags from the mux object.
+// Note: This method assumes that the VP8X chunk, if present, is up-to-date.
+// That is, the mux object hasn't been modified since the last call to
+// WebPMuxAssemble() or WebPMuxCreate().
+// Parameters:
+//   mux - (in) object from which the features are to be fetched
+//   flags - (out) the flags specifying which features are present in the
+//           mux object. This will be an OR of various flag values.
+//           Enum 'WebPFeatureFlags' can be used to test individual flag values.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or flags is NULL.
+//   WEBP_MUX_BAD_DATA - if VP8X/VP8/VP8L chunk or canvas size is invalid.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetFeatures(const WebPMux* mux,
+                                             uint32_t* flags);
+
+// Gets number of chunks with the given 'id' in the mux object.
+// Parameters:
+//   mux - (in) object from which the info is to be fetched
+//   id - (in) chunk id specifying the type of chunk
+//   num_elements - (out) number of chunks with the given chunk id
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, or num_elements is NULL.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxNumChunks(const WebPMux* mux,
+                                           WebPChunkId id, int* num_elements);
+
+// Assembles all chunks in WebP RIFF format and returns in 'assembled_data'.
+// This function also validates the mux object.
+// Note: The content of 'assembled_data' will be ignored and overwritten.
+// Also, the content of 'assembled_data' is allocated using malloc(), and NOT
+// owned by the 'mux' object. It MUST be deallocated by the caller by calling
+// WebPDataClear(). It's always safe to call WebPDataClear() upon return,
+// even in case of error.
+// Parameters:
+//   mux - (in/out) object whose chunks are to be assembled
+//   assembled_data - (out) assembled WebP data
+// Returns:
+//   WEBP_MUX_BAD_DATA - if mux object is invalid.
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or assembled_data is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxAssemble(WebPMux* mux,
+                                          WebPData* assembled_data);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_MUX_H_ */

WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/mux_types.h

@@ -0,0 +1,97 @@
+// Copyright 2012 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.
+// -----------------------------------------------------------------------------
+//
+// Data-types common to the mux and demux libraries.
+//
+// Author: Urvang (urvang@google.com)
+
+#ifndef WEBP_WEBP_MUX_TYPES_H_
+#define WEBP_WEBP_MUX_TYPES_H_
+
+#include <stdlib.h>  // free()
+#include <string.h>  // memset()
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPFeatureFlags WebPFeatureFlags;
+// typedef enum WebPMuxAnimDispose WebPMuxAnimDispose;
+// typedef enum WebPMuxAnimBlend WebPMuxAnimBlend;
+typedef struct WebPData WebPData;
+
+// VP8X Feature Flags.
+typedef enum WebPFeatureFlags {
+  FRAGMENTS_FLAG  = 0x00000001,
+  ANIMATION_FLAG  = 0x00000002,
+  XMP_FLAG        = 0x00000004,
+  EXIF_FLAG       = 0x00000008,
+  ALPHA_FLAG      = 0x00000010,
+  ICCP_FLAG       = 0x00000020
+} WebPFeatureFlags;
+
+// Dispose method (animation only). Indicates how the area used by the current
+// frame is to be treated before rendering the next frame on the canvas.
+typedef enum WebPMuxAnimDispose {
+  WEBP_MUX_DISPOSE_NONE,       // Do not dispose.
+  WEBP_MUX_DISPOSE_BACKGROUND  // Dispose to background color.
+} WebPMuxAnimDispose;
+
+// Blend operation (animation only). Indicates how transparent pixels of the
+// current frame are blended with those of the previous canvas.
+typedef enum WebPMuxAnimBlend {
+  WEBP_MUX_BLEND,              // Blend.
+  WEBP_MUX_NO_BLEND            // Do not blend.
+} WebPMuxAnimBlend;
+
+// Data type used to describe 'raw' data, e.g., chunk data
+// (ICC profile, metadata) and WebP compressed image data.
+struct WebPData {
+  const uint8_t* bytes;
+  size_t size;
+};
+
+// Initializes the contents of the 'webp_data' object with default values.
+static WEBP_INLINE void WebPDataInit(WebPData* webp_data) {
+  if (webp_data != NULL) {
+    memset(webp_data, 0, sizeof(*webp_data));
+  }
+}
+
+// Clears the contents of the 'webp_data' object by calling free(). Does not
+// deallocate the object itself.
+static WEBP_INLINE void WebPDataClear(WebPData* webp_data) {
+  if (webp_data != NULL) {
+    free((void*)webp_data->bytes);
+    WebPDataInit(webp_data);
+  }
+}
+
+// Allocates necessary storage for 'dst' and copies the contents of 'src'.
+// Returns true on success.
+static WEBP_INLINE int WebPDataCopy(const WebPData* src, WebPData* dst) {
+  if (src == NULL || dst == NULL) return 0;
+  WebPDataInit(dst);
+  if (src->bytes != NULL && src->size != 0) {
+    dst->bytes = (uint8_t*)malloc(src->size);
+    if (dst->bytes == NULL) return 0;
+    memcpy((void*)dst->bytes, src->bytes, src->size);
+    dst->size = src->size;
+  }
+  return 1;
+}
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_MUX_TYPES_H_ */

WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/types.h

@@ -0,0 +1,47 @@
+// Copyright 2010 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.
+// -----------------------------------------------------------------------------
+//
+//  Common types
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_TYPES_H_
+#define WEBP_WEBP_TYPES_H_
+
+#include <stddef.h>  // for size_t
+
+#ifndef _MSC_VER
+#include <inttypes.h>
+#ifdef __STRICT_ANSI__
+#define WEBP_INLINE
+#else  /* __STRICT_ANSI__ */
+#define WEBP_INLINE inline
+#endif
+#else
+typedef signed   char int8_t;
+typedef unsigned char uint8_t;
+typedef signed   short int16_t;
+typedef unsigned short uint16_t;
+typedef signed   int int32_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long int uint64_t;
+typedef long long int int64_t;
+#define WEBP_INLINE __forceinline
+#endif  /* _MSC_VER */
+
+#ifndef WEBP_EXTERN
+// This explicitly marks library functions and allows for changing the
+// signature for e.g., Windows DLL builds.
+#define WEBP_EXTERN(type) extern type
+#endif  /* WEBP_EXTERN */
+
+// Macro to check ABI compatibility (same major revision number)
+#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
+
+#endif  /* WEBP_WEBP_TYPES_H_ */

WebPConverter/libwebp-0.4.1-mac-10.8/README

@@ -0,0 +1,482 @@
+          __   __  ____  ____  ____
+         /  \\/  \/  _ \/  _ )/  _ \
+         \       /   __/  _  \   __/
+          \__\__/\____/\_____/__/ ____  ___
+                / _/ /    \    \ /  _ \/ _/
+               /  \_/   / /   \ \   __/  \__
+               \____/____/\_____/_____/____/v0.4.1
+
+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
+
+Latest sources are available from http://www.webmproject.org/code/
+
+It is released under the same license as the WebM project.
+See http://www.webmproject.org/license/software/ or the
+file "COPYING" file for details. An additional intellectual
+property rights grant can be found in the file PATENTS.
+
+Files:
+======
+cwebp        : encoding tool
+dwebp        : decoding tool
+gif2webp     : gif conversion tool
+vwebp        : webp visualization tool
+lib/         : static libraries
+include/webp : headers
+
+Encoding tool:
+==============
+
+The package 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)
+  -alpha_q <int> ......... transparency-compression quality (0..100)
+  -preset <string> ....... preset setting, one of:
+                            default, photo, picture,
+                            drawing, icon, text
+     -preset must come first, as it overwrites other parameters
+
+  -m <int> ............... compression method (0=fast, 6=slowest)
+  -segments <int> ........ number of segments to use (1..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)
+  -f <int> ............... filter strength (0=off..100)
+  -sharpness <int> ....... filter sharpness (0:most .. 7:least sharp)
+  -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)
+  -alpha_filter <string> . predictive filtering for alpha plane,
+                           one of: none, fast (default) or best
+  -alpha_cleanup ......... clean RGB values in transparent area
+  -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
+  -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:
+==============
+
+The sample decoding program dwebp 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:
+
+ ./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)
+  -mt .......... use multi-threading
+  -crop <x> <y> <w> <h> ... crop output with the given rectangle
+  -scale <w> <h> .......... scale the output (*after* any cropping)
+  -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)
+  -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
+  -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
+
+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)
+  -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
+
+Encoding API:
+=============
+
+The main encoding functions are available in the header 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 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 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 our issue tracker:
+    http://code.google.com/p/webp/issues
+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

WebPConverter/libwebp-0.4.1-mac-10.8/README.mux

@@ -0,0 +1,186 @@
+          __   __  ____  ____  ____  __ __  _     __ __
+         /  \\/  \/  _ \/  _ \/  _ \/  \  \/ \___/_ / _\
+         \       /   __/  _  \   __/      /  /  (_/  /__
+          \__\__/\_____/_____/__/  \__//_/\_____/__/___/v0.2.1
+
+
+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).
+
+
+Bugs:
+=====
+
+Please report all bugs to our issue tracker:
+    http://code.google.com/p/webp/issues
+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

WebPConverter/libwebp-0.4.1-mac-10.8/doc/cwebp.html

@@ -0,0 +1,567 @@
+<!-- Creator     : groff version 1.19.2 -->
+<!-- CreationDate: Fri Sep 19 17:51:06 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p     { margin-top: 0; margin-bottom: 0; }
+       pre   { margin-top: 0; margin-bottom: 0; }
+       table { margin-top: 0; margin-bottom: 0; }
+</style>
+<title>CWEBP</title>
+
+</head>
+<body>
+
+<h1 align=center>CWEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#ADDITIONAL OPTIONS">ADDITIONAL OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<a name="NAME"></a>
+<h2>NAME</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">cwebp &minus;
+compress an image file to a WebP file</p>
+
+<a name="SYNOPSIS"></a>
+<h2>SYNOPSIS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>
+[<i>options</i>] <i>input_file &minus;o
+output_file.webp</i></p>
+
+<a name="DESCRIPTION"></a>
+<h2>DESCRIPTION</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>cwebp</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>
+compresses an image using the WebP format. Input format can
+be either PNG, JPEG, TIFF, WebP or raw Y&rsquo;CbCr
+samples.</p>
+
+<a name="OPTIONS"></a>
+<h2>OPTIONS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">The basic
+options are: <b><br>
+&minus;o</b> <i>string</i></p>
+
+<p style="margin-left:22%;">Specify the name of the output
+WebP file. If omitted, <b>cwebp</b> will perform compression
+but only report statistics. Using &quot;&minus;&quot; as
+output name will direct output to &rsquo;stdout&rsquo;.</p>
+
+<p style="margin-left:11%;"><b>&minus;&minus;</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Explicitly specify the input
+file. This option is useful if the input file starts with an
+&rsquo;&minus;&rsquo; for instance. This option must appear
+<b>last</b>. Any other options afterward will be
+ignored.</p>
+
+<p style="margin-left:11%;"><b>&minus;h,
+&minus;help</b></p>
+
+<p style="margin-left:22%;">A short usage summary.</p>
+
+<p style="margin-left:11%;"><b>&minus;H,
+&minus;longhelp</b></p>
+
+<p style="margin-left:22%;">A summary of all the possible
+options.</p>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print the version number (as
+major.minor.revision) and exit.</p>
+
+<p style="margin-left:11%;"><b>&minus;q</b>
+<i>float</i></p>
+
+<p style="margin-left:22%;">Specify the compression factor
+for RGB channels between 0 and 100. The default is 75.</p>
+
+<p style="margin-left:11%;"><b>&minus;alpha_q</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify the compression factor
+for alpha compression between 0 and 100. Lossless
+compression of alpha is achieved using a value of 100, while
+the lower values result in a lossy compression. The default
+is 100.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;f</b>
+<i>int</i></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Specify the
+strength of the deblocking filter, between 0 (no filtering)
+and 100 (maximum filtering). A value of 0 will turn off any
+filtering. Higher value will increase the strength of the
+filtering process applied after decoding the picture. The
+higher the value the smoother the picture will appear.
+Typical values are usually in the range of 20 to 50.</p></td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;preset</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify a set of pre-defined
+parameters to suit a particular type of source material.
+Possible values are: <b>default</b>, <b>photo</b>,
+<b>picture</b>, <b>drawing</b>, <b>icon</b>, <b>text</b>.
+Since <b>&minus;preset</b> overwrites the other
+parameters&rsquo; values (except the <b>&minus;q</b> one),
+this option should preferably appear first in the order of
+the arguments.</p>
+
+<p style="margin-left:11%;"><b>&minus;sns</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify the amplitude of the
+spatial noise shaping. Spatial noise shaping (or <b>sns</b>
+for short) refers to a general collection of built-in
+algorithms used to decide which area of the picture should
+use relatively less bits, and where else to better transfer
+these bits. The possible range goes from 0 (algorithm is
+off) to 100 (the maximal effect). The default value is
+80.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;m</b>
+<i>int</i></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">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. When higher values are used, the encoder will spend more
+time inspecting 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.</p></td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;jpeg_like</b></p>
+
+<p style="margin-left:22%;">Change the internal parameter
+mapping to better match the expected size of JPEG
+compression. This flag will generally produce an output file
+of similar size to its JPEG equivalent (for the same
+<b>&minus;q</b> setting), but with less visual
+distortion.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;mt</b></p> </td>
+<td width="7%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Use multi-threading
+for encoding, if possible. This option is only effective
+when using lossy compression on a source with a transparency
+channel.</p> </td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;low_memory</b></p>
+
+<p style="margin-left:22%;">Reduce memory usage of lossy
+encoding by saving four times the compressed size
+(typically). This will make the encoding slower and the
+output slightly different in size and distortion. This flag
+is only effective for methods 3 and up, and is off by
+default. Note that leaving this flag off will have some side
+effects on the bitstream: it forces certain bitstream
+features like number of partitions (forced to 1). Note that
+a more detailed report of bitstream size is printed by
+<b>cwebp</b> when using this option.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;af</b></p> </td>
+<td width="7%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Turns auto-filter
+on. This algorithm will spend additional time optimizing the
+filtering strength to reach a well-balanced quality.</p></td>
+</table>
+
+<a name="ADDITIONAL OPTIONS"></a>
+<h2>ADDITIONAL OPTIONS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">More advanced
+options are: <b><br>
+&minus;sharpness</b> <i>int</i></p>
+
+<p style="margin-left:22%;">Specify the sharpness of the
+filtering (if used). Range is 0 (sharpest) to 7 (least
+sharp). Default is 0.</p>
+
+<p style="margin-left:11%;"><b>&minus;strong</b></p>
+
+<p style="margin-left:22%;">Use strong filtering (if
+filtering is being used thanks to the <b>&minus;f</b>
+option). Strong filtering is on by default.</p>
+
+<p style="margin-left:11%;"><b>&minus;nostrong</b></p>
+
+<p style="margin-left:22%;">Disable strong filtering (if
+filtering is being used thanks to the <b>&minus;f</b>
+option) and use simple filtering instead.</p>
+
+<p style="margin-left:11%;"><b>&minus;segments</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Change the number of partitions
+to use during the segmentation of the sns algorithm.
+Segments should be in range 1 to 4. Default value is 4. This
+option has no effect for methods 3 and up, unless
+<b>&minus;low_memory</b> is used.</p>
+
+<p style="margin-left:11%;"><b>&minus;partition_limit</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Degrade quality by limiting the
+number of bits used by some macroblocks. Range is 0 (no
+degradation, the default) to 100 (full degradation). Useful
+values are usually around 30-70 for moderately large images.
+In the VP8 format, the so-called control partition has a
+limit of 512k and is used to store the following
+information: whether the macroblock is skipped, which
+segment it belongs to, whether it is coded as intra 4x4 or
+intra 16x16 mode, and finally the prediction modes to use
+for each of the sub-blocks. For a very large image, 512k
+only leaves room to few bits per 16x16 macroblock. The
+absolute minimum is 4 bits per macroblock. Skip, segment,
+and mode information can use up almost all these 4 bits
+(although the case is unlikely), which is problematic for
+very large images. The partition_limit factor controls how
+frequently the most bit-costly mode (intra 4x4) will be
+used. This is useful in case the 512k limit is reached and
+the following message is displayed: <i>Error code: 6
+(PARTITION0_OVERFLOW: Partition #0 is too big to fit
+512k)</i>. If using <b>-partition_limit</b> is not enough to
+meet the 512k constraint, one should use less segments in
+order to save more header bits per macroblock. See the
+<b>-segments</b> option.</p>
+
+<p style="margin-left:11%;"><b>&minus;size</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify a target size (in
+bytes) to try and reach for the compressed output.
+Compressor will make several pass of partial encoding in
+order to get as close as possible to this target.</p>
+
+<p style="margin-left:11%;"><b>&minus;psnr</b>
+<i>float</i></p>
+
+<p style="margin-left:22%;">Specify a target PSNR (in dB)
+to try and reach for the compressed output. Compressor will
+make several pass of partial encoding in order to get as
+close as possible to this target.</p>
+
+<p style="margin-left:11%;"><b>&minus;pass</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Set a maximum number of passes
+to use during the dichotomy used by options
+<b>&minus;size</b> or <b>&minus;psnr</b>. Maximum value is
+10.</p>
+
+<p style="margin-left:11%;"><b>&minus;resize</b> <i>width
+height</i></p>
+
+<p style="margin-left:22%;">Resize the source to a
+rectangle with size <b>width</b> x <b>height</b>. If either
+(but not both) of the <b>width</b> or <b>height</b>
+parameters is 0, the value will be calculated preserving the
+aspect-ratio.</p>
+
+<p style="margin-left:11%;"><b>&minus;crop</b>
+<i>x_position y_position width height</i></p>
+
+<p style="margin-left:22%;">Crop the source to a rectangle
+with top-left corner at coordinates (<b>x_position</b>,
+<b>y_position</b>) and size <b>width</b> x <b>height</b>.
+This cropping area must be fully contained within the source
+rectangle.</p>
+
+<p style="margin-left:11%;"><b>&minus;s</b> <i>width
+height</i></p>
+
+<p style="margin-left:22%;">Specify that the input file
+actually consists of raw Y&rsquo;CbCr samples following the
+ITU-R BT.601 recommendation, in 4:2:0 linear format. The
+luma plane has size <b>width</b> x <b>height</b>.</p>
+
+<p style="margin-left:11%;"><b>&minus;map</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Output additional ASCII-map of
+encoding information. Possible map values range from 1 to 6.
+This is only meant to help debugging.</p>
+
+<p style="margin-left:11%;"><b>&minus;pre</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify some pre-processing
+steps. Using a value of &rsquo;2&rsquo; will trigger
+quality-dependent pseudo-random dithering during
+RGBA-&gt;YUVA conversion (lossy compression only).</p>
+
+<p style="margin-left:11%;"><b>&minus;alpha_filter</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify the predictive
+filtering method for the alpha plane. One of
+&rsquo;none&rsquo;, &rsquo;fast&rsquo; or
+&rsquo;best&rsquo;, in increasing complexity and slowness
+order. Default is &rsquo;fast&rsquo;. Internally, alpha
+filtering is performed using four possible predictions
+(none, horizontal, vertical, gradient). The
+&rsquo;best&rsquo; mode will try each mode in turn and pick
+the one which gives the smaller size. The &rsquo;fast&rsquo;
+mode will just try to form an a-priori guess without testing
+all modes.</p>
+
+<p style="margin-left:11%;"><b>&minus;alpha_method</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">Specify the algorithm used for
+alpha compression: 0 or 1. Algorithm 0 denotes no
+compression, 1 uses WebP lossless format for compression.
+The default is 1.</p>
+
+
+<p style="margin-left:11%;"><b>&minus;alpha_cleanup</b></p>
+
+<p style="margin-left:22%;">Modify unseen RGB values under
+fully transparent area, to help compressibility. The default
+is off.</p>
+
+<p style="margin-left:11%;"><b>&minus;blend_alpha</b>
+<i>int</i></p>
+
+<p style="margin-left:22%;">This option blends the alpha
+channel (if present) with the source using the background
+color specified in hexadecimal as 0xrrggbb. The alpha
+channel is afterward reset to the opaque value 255.</p>
+
+<p style="margin-left:11%;"><b>&minus;noalpha</b></p>
+
+<p style="margin-left:22%;">Using this option will discard
+the alpha channel.</p>
+
+<p style="margin-left:11%;"><b>&minus;lossless</b></p>
+
+<p style="margin-left:22%;">Encode the image without any
+loss.</p>
+
+<p style="margin-left:11%;"><b>&minus;hint</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify the hint about input
+image type. Possible values are: <b>photo</b>,
+<b>picture</b> or <b>graph</b>.</p>
+
+<p style="margin-left:11%;"><b>&minus;metadata</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">A comma separated list of
+metadata to copy from the input to the output if present.
+Valid values: <b>all</b>, <b>none</b>, <b>exif</b>,
+<b>icc</b>, <b>xmp</b>. The default is <b>none</b>.</p>
+
+<p style="margin-left:22%; margin-top: 1em">Note: each
+input format may not support all combinations.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;noasm</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Disable all
+assembly optimizations.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;v</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Print extra
+information (encoding time in particular).</p></td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;print_psnr</b></p>
+
+<p style="margin-left:22%;">Compute and report average PSNR
+(Peak-Signal-To-Noise ratio).</p>
+
+<p style="margin-left:11%;"><b>&minus;print_ssim</b></p>
+
+<p style="margin-left:22%;">Compute and report average SSIM
+(structural similarity metric, see
+http://en.wikipedia.org/wiki/SSIM for additional
+details).</p>
+
+<p style="margin-left:11%;"><b>&minus;print_lsim</b></p>
+
+<p style="margin-left:22%;">Compute and report local
+similarity metric (sum of lowest error amongst the
+collocated pixel neighbors).</p>
+
+<p style="margin-left:11%;"><b>&minus;progress</b></p>
+
+<p style="margin-left:22%;">Report encoding progress in
+percent.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;quiet</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Do not print
+anything.</p> </td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;short</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Only print brief
+information (output file size and PSNR) for testing
+purpose.</p> </td>
+</table>
+
+<a name="BUGS"></a>
+<h2>BUGS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<a name="EXAMPLES"></a>
+<h2>EXAMPLES</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">cwebp &minus;q
+50 -lossless picture.png &minus;o picture_lossless.webp <br>
+cwebp &minus;q 70 picture_with_alpha.png &minus;o
+picture_with_alpha.webp <br>
+cwebp &minus;sns 70 &minus;f 50 &minus;size 60000
+picture.png &minus;o picture.webp <br>
+cwebp &minus;o picture.webp &minus;&minus;
+&minus;&minus;&minus;picture.png</p>
+
+<a name="AUTHORS"></a>
+<h2>AUTHORS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Pascal Massimino
+&lt;pascal.massimino@gmail.com&gt;, for the Debian project
+(and may be used by others).</p>
+
+<a name="SEE ALSO"></a>
+<h2>SEE ALSO</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>(1),
+<b>gif2webp</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-mac-10.8/doc/cwebp.txt

@@ -0,0 +1,284 @@
+CWEBP(1)                                                              CWEBP(1)
+
+
+
+NAME
+       cwebp  compress an image file to a WebP file
+
+SYNOPSIS
+       cwebp [options] input_file o output_file.webp
+
+DESCRIPTION
+       This manual page documents the cwebp command.
+
+       cwebp  compresses  an image using the WebP format.  Input format can be
+       either PNG, JPEG, TIFF, WebP or raw YCbCr samples.
+
+OPTIONS
+       The basic options are:
+
+      o string
+              Specify the name of the output WebP file. If omitted, cwebp will
+              perform  compression  but  only report statistics.  Using "" as
+              output name will direct output to stdout.
+
+      string
+              Explicitly specify the input file. This option is useful if  the
+              input  file  starts  with  an  for instance. This option must
+              appear last.  Any other options afterward will be ignored.
+
+      h,help
+              A short usage summary.
+
+      H,longhelp
+              A summary of all the possible options.
+
+      version
+              Print the version number (as major.minor.revision) and exit.
+
+      q float
+              Specify the compression factor for RGB channels  between  0  and
+              100. The default is 75.
+
+      alpha_q int
+              Specify  the  compression factor for alpha compression between 0
+              and 100.  Lossless compression of  alpha  is  achieved  using  a
+              value  of 100, while the lower values result in a lossy compres
+              sion. The default is 100.
+
+      f int Specify the strength of the deblocking  filter,  between  0  (no
+              filtering)  and  100 (maximum filtering). A value of 0 will turn
+              off any filtering.  Higher value will increase the  strength  of
+              the  filtering  process  applied after decoding the picture. The
+              higher the value the smoother the picture will  appear.  Typical
+              values are usually in the range of 20 to 50.
+
+      preset string
+              Specify  a  set  of  predefined parameters to suit a particular
+              type of source material. Possible values are:   default,  photo,
+              picture, drawing, icon, text. Sincepreset overwrites the other
+              parameters values (except  the q  one),  this  option  should
+              preferably appear first in the order of the arguments.
+
+      sns int
+              Specify  the  amplitude  of  the  spatial noise shaping. Spatial
+              noise shaping (or sns for short) refers to a general  collection
+              of  builtin algorithms used to decide which area of the picture
+              should use relatively less bits, and where else to better trans
+              fer  these  bits.  The  possible range goes from 0 (algorithm is
+              off) to 100 (the maximal effect). The default value is 80.
+
+      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.  When higher values are used, the encoder will spend
+              more  time  inspecting  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.
+
+      jpeg_like
+              Change  the  internal  parameter  mapping  to  better  match the
+              expected size of JPEG compression. This flag will generally pro
+              duce  an output file of similar size to its JPEG equivalent (for
+              the sameq setting), but with less visual distortion.
+
+      mt    Use multithreading for encoding, if possible.  This  option  is
+              only  effective  when using lossy compression on a source with a
+              transparency channel.
+
+      low_memory
+              Reduce memory usage of lossy encoding by saving four  times  the
+              compressed  size (typically). This will make the encoding slower
+              and the output slightly different in size and  distortion.  This
+              flag  is  only  effective  for  methods  3 and up, and is off by
+              default. Note that leaving this flag off  will  have  some  side
+              effects  on  the bitstream: it forces certain bitstream features
+              like number of partitions  (forced  to  1).  Note  that  a  more
+              detailed report of bitstream size is printed by cwebp when using
+              this option.
+
+      af    Turns autofilter on. This algorithm will spend additional  time
+              optimizing the filtering strength to reach a wellbalanced qual
+              ity.
+
+
+ADDITIONAL OPTIONS
+       More advanced options are:
+
+      sharpness int
+              Specify the sharpness of the filtering (if used).   Range  is  0
+              (sharpest) to 7 (least sharp). Default is 0.
+
+      strong
+              Use  strong  filtering (if filtering is being used thanks to the
+             f option). Strong filtering is on by default.
+
+      nostrong
+              Disable strong filtering (if filtering is being used  thanks  to
+              thef option) and use simple filtering instead.
+
+      segments int
+              Change  the  number of partitions to use during the segmentation
+              of the sns algorithm. Segments  should  be  in  range  1  to  4.
+              Default value is 4.  This option has no effect for methods 3 and
+              up, unlesslow_memory is used.
+
+      partition_limit int
+              Degrade quality by limiting the number of bits used by some mac
+              roblocks.  Range is 0 (no degradation, the default) to 100 (full
+              degradation).  Useful values are usually around 3070 for moder
+              ately  large  images.   In the VP8 format, the socalled control
+              partition has a limit of 512k and is used to store the following
+              information: whether the macroblock is skipped, which segment it
+              belongs to, whether it is coded as  intra  4x4  or  intra  16x16
+              mode,  and  finally  the prediction modes to use for each of the
+              subblocks.  For a very large image, 512k only  leaves  room  to
+              few  bits  per 16x16 macroblock.  The absolute minimum is 4 bits
+              per macroblock. Skip, segment, and mode information can  use  up
+              almost  all  these 4 bits (although the case is unlikely), which
+              is problematic for very large images. The partition_limit factor
+              controls  how  frequently  the  most bitcostly mode (intra 4x4)
+              will be used. This is useful in case the 512k limit  is  reached
+              and  the  following  message is displayed: Error code: 6 (PARTI_
+              TION0_OVERFLOW: Partition #0 is too big to fit 512k).  If  using
+             partition_limit  is not enough to meet the 512k constraint, one
+              should use less segments in order to save more header  bits  per
+              macroblock.  See thesegments option.
+
+      size int
+              Specify  a  target size (in bytes) to try and reach for the com
+              pressed output.  Compressor will make several  pass  of  partial
+              encoding in order to get as close as possible to this target.
+
+      psnr float
+              Specify  a  target  PSNR  (in  dB) to try and reach for the com
+              pressed output.  Compressor will make several  pass  of  partial
+              encoding in order to get as close as possible to this target.
+
+      pass int
+              Set  a maximum number of passes to use during the dichotomy used
+              by optionssize orpsnr. Maximum value is 10.
+
+      resize width height
+              Resize the source to a rectangle with size width x  height.   If
+              either  (but  not  both) of the width or height parameters is 0,
+              the value will be calculated preserving the aspectratio.
+
+      crop x_position y_position width height
+              Crop the source to a rectangle with topleft corner  at  coordi
+              nates  (x_position,  y_position)  and size width x height.  This
+              cropping area must be fully contained within the source  rectan
+              gle.
+
+      s width height
+              Specify that the input file actually consists of raw YCbCr sam
+              ples following the ITUR BT.601 recommendation, in 4:2:0  linear
+              format.  The luma plane has size width x height.
+
+      map int
+              Output  additional  ASCIImap  of encoding information. Possible
+              map values range from 1 to 6. This is only meant to help  debug
+              ging.
+
+      pre int
+              Specify  some  preprocessing  steps.  Using a value of 2 will
+              trigger   qualitydependent   pseudorandom   dithering   during
+              RGBA>YUVA conversion (lossy compression only).
+
+      alpha_filter string
+              Specify the predictive filtering method for the alpha plane. One
+              of none, fast or best, in increasing complexity and  slow
+              ness  order.  Default  is fast. Internally, alpha filtering is
+              performed using four  possible  predictions  (none,  horizontal,
+              vertical,  gradient). The best mode will try each mode in turn
+              and pick the one which gives the smaller size. The  fast  mode
+              will  just  try  to  form  an apriori guess without testing all
+              modes.
+
+      alpha_method int
+              Specify the algorithm used for alpha compression: 0 or 1.  Algo
+              rithm  0 denotes no compression, 1 uses WebP lossless format for
+              compression. The default is 1.
+
+      alpha_cleanup
+              Modify unseen RGB values under fully transparent area,  to  help
+              compressibility.  The default is off.
+
+      blend_alpha int
+              This  option  blends  the  alpha  channel  (if present) with the
+              source using the background color specified  in  hexadecimal  as
+              0xrrggbb.  The  alpha  channel  is afterward reset to the opaque
+              value 255.
+
+      noalpha
+              Using this option will discard the alpha channel.
+
+      lossless
+              Encode the image without any loss.
+
+      hint string
+              Specify the hint about input image type.  Possible  values  are:
+              photo, picture or graph.
+
+      metadata string
+              A comma separated list of metadata to copy from the input to the
+              output if present.  Valid values: all,  none,  exif,  icc,  xmp.
+              The default is none.
+
+              Note: each input format may not support all combinations.
+
+      noasm Disable all assembly optimizations.
+
+      v     Print extra information (encoding time in particular).
+
+      print_psnr
+              Compute and report average PSNR (PeakSignalToNoise ratio).
+
+      print_ssim
+              Compute  and  report average SSIM (structural similarity metric,
+              see http://en.wikipedia.org/wiki/SSIM for additional details).
+
+      print_lsim
+              Compute and report local similarity metric (sum of lowest  error
+              amongst the collocated pixel neighbors).
+
+      progress
+              Report encoding progress in percent.
+
+      quiet Do not print anything.
+
+      short Only  print  brief  information  (output file size and PSNR) for
+              testing purpose.
+
+
+BUGS
+       Please    report     all     bugs     to     our     issue     tracker:
+       http://code.google.com/p/webp/issues
+       Patches  welcome!  See  this  page  to get started: http://www.webmpro
+       ject.org/code/contribute/submittingpatches/
+
+
+EXAMPLES
+       cwebp q 50 lossless picture.png o picture_lossless.webp
+       cwebp q 70 picture_with_alpha.png o picture_with_alpha.webp
+       cwebp sns 70 f 50 size 60000 picture.png o picture.webp
+       cwebp o picture.webp  picture.png
+
+
+AUTHORS
+       cwebp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This  manual  page  was  written  by  Pascal   Massimino   <pascal.mas
+       simino@gmail.com>,  for the Debian project (and may be used by others).
+
+
+SEE ALSO
+       dwebp(1), gif2webp(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                                 July 22, 2014                        CWEBP(1)

WebPConverter/libwebp-0.4.1-mac-10.8/doc/dwebp.html

@@ -0,0 +1,346 @@
+<!-- Creator     : groff version 1.19.2 -->
+<!-- CreationDate: Fri Sep 19 17:51:06 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p     { margin-top: 0; margin-bottom: 0; }
+       pre   { margin-top: 0; margin-bottom: 0; }
+       table { margin-top: 0; margin-bottom: 0; }
+</style>
+<title>DWEBP</title>
+
+</head>
+<body>
+
+<h1 align=center>DWEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<a name="NAME"></a>
+<h2>NAME</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">dwebp &minus;
+decompress a WebP file to an image file</p>
+
+<a name="SYNOPSIS"></a>
+<h2>SYNOPSIS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>
+[<i>options</i>] <i>input_file.webp</i></p>
+
+<a name="DESCRIPTION"></a>
+<h2>DESCRIPTION</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>dwebp</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>
+decompresses WebP files into PNG, PAM, PPM or PGM
+images.</p>
+
+<a name="OPTIONS"></a>
+<h2>OPTIONS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">The basic
+options are:</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="3%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;h</b></p> </td>
+<td width="8%"></td>
+<td width="30%">
+
+
+<p style="margin-top: 1em" valign="top">Print usage
+summary.</p> </td>
+<td width="48%">
+</td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print the version number (as
+major.minor.revision) and exit.</p>
+
+<p style="margin-left:11%;"><b>&minus;o</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Specify the name of the output
+file (as PNG format by default). Using &quot;-&quot; as
+output name will direct output to &rsquo;stdout&rsquo;.</p>
+
+<p style="margin-left:11%;"><b>&minus;&minus;</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Explicitly specify the input
+file. This option is useful if the input file starts with an
+&rsquo;&minus;&rsquo; for instance. This option must appear
+<b>last</b>. Any other options afterward will be ignored. If
+the input file is &quot;&minus;&quot;, the data will be read
+from <i>stdin</i> instead of a file.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;bmp</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Change the output
+format to uncompressed BMP.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;tiff</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Change the output
+format to uncompressed TIFF.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;pam</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Change the output
+format to PAM (retains alpha).</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;ppm</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Change the output
+format to PPM (discards alpha).</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;pgm</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Change the output
+format to PGM. The output consists of luma/chroma samples
+instead of RGB, using the IMC4 layout. This option is mainly
+for verification and debugging purposes.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;yuv</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Change the output
+format to raw YUV. The output consists of
+luma/chroma-U/chroma-V samples instead of RGB, saved
+sequentially as individual planes. This option is mainly for
+verification and debugging purposes.</p></td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;nofancy</b></p>
+
+<p style="margin-left:22%;">Don&rsquo;t use the fancy
+upscaler for YUV420. This may lead to jaggy edges
+(especially the red ones), but should be faster.</p>
+
+<p style="margin-left:11%;"><b>&minus;nofilter</b></p>
+
+<p style="margin-left:22%;">Don&rsquo;t use the in-loop
+filtering process even if it is required by the bitstream.
+This may produce visible blocks on the non-compliant output,
+but it will make the decoding faster.</p>
+
+<p style="margin-left:11%;"><b>&minus;dither</b>
+<i>strength</i></p>
+
+<p style="margin-left:22%;">Specify a dithering
+<b>strength</b> between 0 and 100. Dithering is a
+post-processing effect applied to chroma components in lossy
+compression. It helps by smoothing gradients and avoiding
+banding artifacts.</p>
+
+<p style="margin-left:11%;"><b>&minus;nodither</b></p>
+
+<p style="margin-left:22%;">Disable all dithering
+(default).</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;mt</b></p> </td>
+<td width="7%"></td>
+<td width="70%">
+
+
+<p style="margin-top: 1em" valign="top">Use multi-threading
+for decoding, if possible.</p></td>
+<td width="8%">
+</td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;crop</b>
+<i>x_position y_position width height</i></p>
+
+<p style="margin-left:22%;">Crop the decoded picture to a
+rectangle with top-left corner at coordinates
+(<b>x_position</b>, <b>y_position</b>) and size <b>width</b>
+x <b>height</b>. This cropping area must be fully contained
+within the source rectangle. The top-left corner will be
+snapped to even coordinates if needed. This option is meant
+to reduce the memory needed for cropping large images. Note:
+the cropping is applied <i>before</i> any scaling.</p>
+
+<p style="margin-left:11%;"><b>&minus;scale</b> <i>width
+height</i></p>
+
+<p style="margin-left:22%;">Rescale the decoded picture to
+dimension <b>width</b> x <b>height</b>. This option is
+mostly intended to reducing the memory needed to decode
+large images, when only a small version is needed
+(thumbnail, preview, etc.). Note: scaling is applied
+<i>after</i> cropping.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;v</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Print extra
+information (decoding time in particular).</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;noasm</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Disable all
+assembly optimizations.</p></td>
+</table>
+
+<a name="BUGS"></a>
+<h2>BUGS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<a name="EXAMPLES"></a>
+<h2>EXAMPLES</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">dwebp
+picture.webp &minus;o output.png <br>
+dwebp picture.webp &minus;ppm &minus;o output.ppm <br>
+dwebp &minus;o output.ppm &minus;&minus;
+&minus;&minus;&minus;picture.webp <br>
+cat picture.webp | dwebp &minus;o &minus; &minus;&minus;
+&minus; &gt; output.ppm</p>
+
+<a name="AUTHORS"></a>
+<h2>AUTHORS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Pascal Massimino
+&lt;pascal.massimino@gmail.com&gt;, for the Debian project
+(and may be used by others).</p>
+
+<a name="SEE ALSO"></a>
+<h2>SEE ALSO</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>(1),
+<b>gif2webp</b>(1), <b>webpmux</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>Output file
+format details</b> <br>
+PAM: http://netpbm.sourceforge.net/doc/pam.html <br>
+PGM: http://netpbm.sourceforge.net/doc/pgm.html <br>
+PPM: http://netpbm.sourceforge.net/doc/ppm.html <br>
+PNG: http://www.libpng.org/pub/png/png-sitemap.html#info</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-mac-10.8/doc/dwebp.txt

@@ -0,0 +1,127 @@
+DWEBP(1)                                                              DWEBP(1)
+
+
+
+NAME
+       dwebp  decompress a WebP file to an image file
+
+SYNOPSIS
+       dwebp [options] input_file.webp
+
+DESCRIPTION
+       This manual page documents the dwebp command.
+
+       dwebp decompresses WebP files into PNG, PAM, PPM or PGM images.
+
+OPTIONS
+       The basic options are:
+
+      h     Print usage summary.
+
+      version
+              Print the version number (as major.minor.revision) and exit.
+
+      o string
+              Specify  the name of the output file (as PNG format by default).
+              Using "" as output name will direct output to stdout.
+
+      string
+              Explicitly specify the input file. This option is useful if  the
+              input  file  starts  with  an  for instance. This option must
+              appear last.  Any other options afterward will  be  ignored.  If
+              the  input file is "", the data will be read from stdin instead
+              of a file.
+
+      bmp   Change the output format to uncompressed BMP.
+
+      tiff  Change the output format to uncompressed TIFF.
+
+      pam   Change the output format to PAM (retains alpha).
+
+      ppm   Change the output format to PPM (discards alpha).
+
+      pgm   Change  the  output  format  to  PGM.  The  output  consists  of
+              luma/chroma  samples instead of RGB, using the IMC4 layout. This
+              option is mainly for verification and debugging purposes.
+
+      yuv   Change the output format to raw  YUV.  The  output  consists  of
+              luma/chromaU/chromaV  samples  instead  of  RGB, saved sequen
+              tially as individual planes. This option is mainly for verifica
+              tion and debugging purposes.
+
+      nofancy
+              Dont  use the fancy upscaler for YUV420. This may lead to jaggy
+              edges (especially the red ones), but should be faster.
+
+      nofilter
+              Dont use the inloop filtering process even if it  is  required
+              by  the  bitstream.  This may produce visible blocks on the non
+              compliant output, but it will make the decoding faster.
+
+      dither strength
+              Specify a dithering strength between 0 and 100. Dithering  is  a
+              postprocessing  effect  applied  to  chroma components in lossy
+              compression.  It helps by smoothing gradients and avoiding band
+              ing artifacts.
+
+      nodither
+              Disable all dithering (default).
+
+      mt    Use multithreading for decoding, if possible.
+
+      crop x_position y_position width height
+              Crop  the decoded picture to a rectangle with topleft corner at
+              coordinates (x_position, y_position) and size  width  x  height.
+              This  cropping  area  must  be fully contained within the source
+              rectangle.  The topleft corner will be snapped to even  coordi
+              nates  if  needed.   This  option  is meant to reduce the memory
+              needed for cropping large images.  Note: the cropping is applied
+              before any scaling.
+
+      scale width height
+              Rescale  the  decoded  picture to dimension width x height. This
+              option is mostly intended  to  reducing  the  memory  needed  to
+              decode large images, when only a small version is needed (thumb
+              nail, preview, etc.).  Note: scaling is applied after  cropping.
+
+      v     Print extra information (decoding time in particular).
+
+      noasm Disable all assembly optimizations.
+
+
+BUGS
+       Please     report     all     bugs     to     our     issue    tracker:
+       http://code.google.com/p/webp/issues
+       Patches welcome! See this  page  to  get  started:  http://www.webmpro
+       ject.org/code/contribute/submittingpatches/
+
+
+EXAMPLES
+       dwebp picture.webp o output.png
+       dwebp picture.webp ppm o output.ppm
+       dwebp o output.ppm  picture.webp
+       cat picture.webp | dwebp o    > output.ppm
+
+
+AUTHORS
+       dwebp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This   manual   page  was  written  by  Pascal  Massimino  <pascal.mas
+       simino@gmail.com>, for the Debian project (and may be used by  others).
+
+
+SEE ALSO
+       cwebp(1), gif2webp(1), webpmux(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+   Output file format details
+       PAM: http://netpbm.sourceforge.net/doc/pam.html
+       PGM: http://netpbm.sourceforge.net/doc/pgm.html
+       PPM: http://netpbm.sourceforge.net/doc/ppm.html
+       PNG: http://www.libpng.org/pub/png/pngsitemap.html#info
+
+
+
+                                 July 22, 2014                        DWEBP(1)

WebPConverter/libwebp-0.4.1-mac-10.8/doc/gif2webp.html

@@ -0,0 +1,303 @@
+<!-- Creator     : groff version 1.19.2 -->
+<!-- CreationDate: Fri Sep 19 17:51:07 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p     { margin-top: 0; margin-bottom: 0; }
+       pre   { margin-top: 0; margin-bottom: 0; }
+       table { margin-top: 0; margin-bottom: 0; }
+</style>
+<title>GIF2WEBP</title>
+
+</head>
+<body>
+
+<h1 align=center>GIF2WEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<a name="NAME"></a>
+<h2>NAME</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">gif2webp
+&minus; Convert a GIF image to WebP</p>
+
+<a name="SYNOPSIS"></a>
+<h2>SYNOPSIS</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>gif2webp</b>
+[<i>options</i>] <i>input_file.gif &minus;o
+output_file.webp</i></p>
+
+<a name="DESCRIPTION"></a>
+<h2>DESCRIPTION</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>gif2webp</b> command.</p>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>gif2webp</b>
+converts a GIF image to a WebP image.</p>
+
+<a name="OPTIONS"></a>
+<h2>OPTIONS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">The basic
+options are: <b><br>
+&minus;o</b> <i>string</i></p>
+
+<p style="margin-left:22%;">Specify the name of the output
+WebP file. If omitted, <b>gif2webp</b> will perform
+conversion but only report statistics. Using
+&quot;&minus;&quot; as output name will direct output to
+&rsquo;stdout&rsquo;.</p>
+
+<p style="margin-left:11%;"><b>&minus;h,
+&minus;help</b></p>
+
+<p style="margin-left:22%;">Usage information.</p>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print the version number (as
+major.minor.revision) and exit.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;lossy</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Encode the image
+using lossy compression.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;mixed</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Mixed compression
+mode: optimize compression of the image by picking either
+lossy or lossless compression for each frame
+heuristically.</p> </td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;q</b>
+<i>float</i></p>
+
+<p style="margin-left:22%;">Specify the compression factor
+for RGB channels between 0 and 100. The default is 75. <br>
+In case of lossless compression (default), a small factor
+enables faster compression speed, but produces a larger
+file. Maximum compression is achieved by using a value of
+100. <br>
+In case of lossy compression (specified by the &minus;lossy
+option), a small factor produces a smaller file with lower
+quality. Best quality is achieved by using a value of
+100.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;m</b>
+<i>int</i></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">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. When higher values are used, the encoder will spend more
+time inspecting additional encoding possibilities and decide
+on the quality gain. Lower value can result is faster
+processing time at the expense of larger file size and lower
+compression quality.</p></td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;kmin</b> <i>int</i>
+<b><br>
+&minus;kmax</b> <i>int</i></p>
+
+<p style="margin-left:22%;">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>
+A &rsquo;kmin&rsquo; value of 0 will turn off insertion of
+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>
+These two options are relevant only for animated images with
+large number of frames (&gt;50). <br>
+When lower values are used, more frames will be converted to
+key frames. This may lead to smaller number of frames
+required to decode a frame on average, thereby improving the
+decoding performance. But this may lead to slightly bigger
+file sizes. Higher values may lead to worse decoding
+performance, but smaller file sizes. <br>
+Some restrictions: <br>
+(i) kmin &lt; kmax, <br>
+(ii) kmin &gt;= kmax / 2 + 1 and <br>
+(iii) kmax - kmin &lt;= 30. <br>
+If any of these restrictions are not met, they will be
+enforced automatically.</p>
+
+<p style="margin-left:11%;"><b>&minus;metadata</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">A comma separated list of
+metadata to copy from the input to the output if present.
+Valid values: <b>all</b>, <b>none</b>, <b>icc</b>,
+<b>xmp</b>. The default is <b>xmp</b>.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;f</b>
+<i>int</i></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">For lossy encoding
+only (specified by the &minus;lossy option). Specify the
+strength of the deblocking filter, between 0 (no filtering)
+and 100 (maximum filtering). A value of 0 will turn off any
+filtering. Higher value will increase the strength of the
+filtering process applied after decoding the picture. The
+higher the value the smoother the picture will appear.
+Typical values are usually in the range of 20 to 50.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;mt</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Use multi-threading
+for encoding, if possible. This option is only effective
+when using lossy compression.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;v</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Print extra
+information.</p> </td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;quiet</b></p> </td>
+<td width="2%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Do not print
+anything.</p> </td>
+</table>
+
+<a name="BUGS"></a>
+<h2>BUGS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<a name="EXAMPLES"></a>
+<h2>EXAMPLES</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">gif2webp
+picture.gif &minus;o picture.webp <br>
+gif2webp &minus;q 70 picture.gif &minus;o picture.webp <br>
+gif2webp &minus;lossy &minus;m 3 picture.gif &minus;o
+picture_lossy.webp <br>
+gif2webp &minus;lossy &minus;f 50 picture.gif &minus;o
+picture.webp <br>
+gif2webp &minus;q 70 &minus;o picture.webp &minus;&minus;
+&minus;&minus;&minus;picture.gif</p>
+
+<a name="AUTHORS"></a>
+<h2>AUTHORS</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>gif2webp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Urvang Joshi &lt;urvang@google.com&gt;,
+for the Debian project (and may be used by others).</p>
+
+<a name="SEE ALSO"></a>
+<h2>SEE ALSO</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>(1),
+<b>dwebp</b>(1), <b>webpmux</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-mac-10.8/doc/gif2webp.txt

@@ -0,0 +1,132 @@
+GIF2WEBP(1)                                                        GIF2WEBP(1)
+
+
+
+NAME
+       gif2webp  Convert a GIF image to WebP
+
+SYNOPSIS
+       gif2webp [options] input_file.gif o output_file.webp
+
+DESCRIPTION
+       This manual page documents the gif2webp command.
+
+       gif2webp converts a GIF image to a WebP image.
+
+OPTIONS
+       The basic options are:
+
+      o string
+              Specify  the  name of the output WebP file. If omitted, gif2webp
+              will perform conversion but only report statistics.   Using  ""
+              as output name will direct output to stdout.
+
+      h,help
+              Usage information.
+
+      version
+              Print the version number (as major.minor.revision) and exit.
+
+      lossy Encode the image using lossy compression.
+
+      mixed Mixed  compression  mode:  optimize  compression of the image by
+              picking either lossy or  lossless  compression  for  each  frame
+              heuristically.
+
+      q float
+              Specify  the  compression  factor for RGB channels between 0 and
+              100. The default is 75.
+              In case  of  lossless  compression  (default),  a  small  factor
+              enables  faster  compression  speed, but produces a larger file.
+              Maximum compression is achieved by using a value of 100.
+              In case of lossy compression (specified by the lossy option), a
+              small  factor  produces  a smaller file with lower quality. Best
+              quality is achieved by using a value of 100.
+
+      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.  When higher values are used, the encoder will spend
+              more  time  inspecting  additional  encoding  possibilities  and
+              decide  on  the  quality gain.  Lower value can result is faster
+              processing time at the expense of larger  file  size  and  lower
+              compression quality.
+
+      kmin int
+
+      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.
+              A kmin value of 0 will turn off insertion of key frames.  Typ
+              ical  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.
+              These  two  options  are  relevant only for animated images with
+              large number of frames (>50).
+              When lower values are used, more frames will be converted to key
+              frames.  This  may  lead to smaller number of frames required to
+              decode a frame on average, thereby improving the  decoding  per
+              formance.  But  this  may  lead  to  slightly bigger file sizes.
+              Higher values  may  lead  to  worse  decoding  performance,  but
+              smaller file sizes.
+              Some restrictions:
+              (i) kmin < kmax,
+              (ii) kmin >= kmax / 2 + 1 and
+              (iii) kmax  kmin <= 30.
+              If  any of these restrictions are not met, they will be enforced
+              automatically.
+
+      metadata string
+              A comma separated list of metadata to copy from the input to the
+              output  if  present.   Valid  values:  all, none, icc, xmp.  The
+              default is xmp.
+
+      f int For lossy encoding only (specified by the lossy option).  Spec
+              ify the strength of the deblocking filter, between 0 (no filter
+              ing) and 100 (maximum filtering).  A value of 0  will  turn  off
+              any  filtering.  Higher  value will increase the strength of the
+              filtering process applied after decoding the picture. The higher
+              the  value  the smoother the picture will appear. Typical values
+              are usually in the range of 20 to 50.
+
+      mt    Use multithreading for encoding, if possible.  This  option  is
+              only effective when using lossy compression.
+
+      v     Print extra information.
+
+      quiet Do not print anything.
+
+
+BUGS
+       Please     report     all     bugs     to     our     issue    tracker:
+       http://code.google.com/p/webp/issues
+       Patches welcome! See this  page  to  get  started:  http://www.webmpro
+       ject.org/code/contribute/submittingpatches/
+
+
+EXAMPLES
+       gif2webp picture.gif o picture.webp
+       gif2webp q 70 picture.gif o picture.webp
+       gif2webp lossy m 3 picture.gif o picture_lossy.webp
+       gif2webp lossy f 50 picture.gif o picture.webp
+       gif2webp q 70 o picture.webp  picture.gif
+
+
+AUTHORS
+       gif2webp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This  manual  page was written by Urvang Joshi <urvang@google.com>, for
+       the Debian project (and may be used by others).
+
+
+SEE ALSO
+       cwebp(1), dwebp(1), webpmux(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                                 March 7, 2014                     GIF2WEBP(1)

WebPConverter/libwebp-0.4.1-mac-10.8/doc/vwebp.html

@@ -0,0 +1,251 @@
+<!-- Creator     : groff version 1.19.2 -->
+<!-- CreationDate: Fri Sep 19 17:51:07 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p     { margin-top: 0; margin-bottom: 0; }
+       pre   { margin-top: 0; margin-bottom: 0; }
+       table { margin-top: 0; margin-bottom: 0; }
+</style>
+<title>VWEBP</title>
+
+</head>
+<body>
+
+<h1 align=center>VWEBP</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#KEYBOARD SHORTCUTS">KEYBOARD SHORTCUTS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<a name="NAME"></a>
+<h2>NAME</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">vwebp &minus;
+decompress a WebP file and display it in a window</p>
+
+<a name="SYNOPSIS"></a>
+<h2>SYNOPSIS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>vwebp</b>
+[<i>options</i>] <i>input_file.webp</i></p>
+
+<a name="DESCRIPTION"></a>
+<h2>DESCRIPTION</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>vwebp</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>vwebp</b>
+decompresses a WebP file and displays it in a window using
+OpenGL.</p>
+
+<a name="OPTIONS"></a>
+<h2>OPTIONS</h2>
+
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="3%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;h</b></p> </td>
+<td width="8%"></td>
+<td width="30%">
+
+
+<p style="margin-top: 1em" valign="top">Print usage
+summary.</p> </td>
+<td width="48%">
+</td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;version</b></p>
+
+<p style="margin-left:22%;">Print version number and
+exit.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="9%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;noicc</b></p> </td>
+<td width="2%"></td>
+<td width="56%">
+
+
+<p style="margin-top: 1em" valign="top">Don&rsquo;t use the
+ICC profile if present.</p></td>
+<td width="22%">
+</td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;nofancy</b></p>
+
+<p style="margin-left:22%;">Don&rsquo;t use the fancy
+YUV420 upscaler.</p>
+
+<p style="margin-left:11%;"><b>&minus;nofilter</b></p>
+
+<p style="margin-left:22%;">Disable in-loop filtering.</p>
+
+<p style="margin-left:11%;"><b>&minus;dither</b>
+<i>strength</i></p>
+
+<p style="margin-left:22%;">Specify a dithering
+<b>strength</b> between 0 and 100. Dithering is a
+post-processing effect applied to chroma components in lossy
+compression. It helps by smoothing gradients and avoiding
+banding artifacts. Default: 50.</p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;mt</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Use multi-threading
+for decoding, if possible.</p></td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="7%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&minus;info</b></p> </td>
+<td width="4%"></td>
+<td width="78%">
+
+
+<p style="margin-top: 1em" valign="top">Display image
+information on top of the decoded image.</p></td>
+</table>
+
+<p style="margin-left:11%;"><b>&minus;&minus;</b>
+<i>string</i></p>
+
+<p style="margin-left:22%;">Explicitly specify the input
+file. This option is useful if the input file starts with an
+&rsquo;&minus;&rsquo; for instance. This option must appear
+<b>last</b>. Any other options afterward will be ignored. If
+the input file is &quot;&minus;&quot;, the data will be read
+from <i>stdin</i> instead of a file.</p>
+
+<a name="KEYBOARD SHORTCUTS"></a>
+<h2>KEYBOARD SHORTCUTS</h2>
+
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&rsquo;c&rsquo;</b></p> </td>
+<td width="7%"></td>
+<td width="43%">
+
+
+<p style="margin-top: 1em" valign="top">Toggle use of color
+profile.</p> </td>
+<td width="35%">
+</td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="4%">
+
+
+
+<p style="margin-top: 1em" valign="top"><b>&rsquo;i&rsquo;</b></p> </td>
+<td width="7%"></td>
+<td width="43%">
+
+
+<p style="margin-top: 1em" valign="top">Overlay file
+information.</p> </td>
+<td width="35%">
+</td>
+</table>
+
+<p style="margin-left:11%;"><b>&rsquo;q&rsquo; /
+&rsquo;Q&rsquo; / ESC</b></p>
+
+<p style="margin-left:22%;">Quit.</p>
+
+<a name="BUGS"></a>
+<h2>BUGS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<a name="EXAMPLES"></a>
+<h2>EXAMPLES</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">vwebp
+picture.webp <br>
+vwebp picture.webp -mt -dither 0 <br>
+vwebp &minus;&minus; &minus;&minus;&minus;picture.webp</p>
+
+<a name="AUTHORS"></a>
+<h2>AUTHORS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>vwebp</b>
+was written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written for the Debian project (and may be used by
+others).</p>
+
+<a name="SEE ALSO"></a>
+<h2>SEE ALSO</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>dwebp</b>(1)
+<br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-mac-10.8/doc/vwebp.txt

@@ -0,0 +1,88 @@
+VWEBP(1)                                                              VWEBP(1)
+
+
+
+NAME
+       vwebp  decompress a WebP file and display it in a window
+
+SYNOPSIS
+       vwebp [options] input_file.webp
+
+DESCRIPTION
+       This manual page documents the vwebp command.
+
+       vwebp  decompresses  a  WebP  file  and  displays  it in a window using
+       OpenGL.
+
+OPTIONS
+      h     Print usage summary.
+
+      version
+              Print version number and exit.
+
+      noicc Dont use the ICC profile if present.
+
+      nofancy
+              Dont use the fancy YUV420 upscaler.
+
+      nofilter
+              Disable inloop filtering.
+
+      dither strength
+              Specify a dithering strength between 0 and 100. Dithering  is  a
+              postprocessing  effect  applied  to  chroma components in lossy
+              compression.  It helps by smoothing gradients and avoiding band
+              ing artifacts. Default: 50.
+
+      mt    Use multithreading for decoding, if possible.
+
+      info  Display image information on top of the decoded image.
+
+      string
+              Explicitly  specify the input file. This option is useful if the
+              input file starts with an  for  instance.  This  option  must
+              appear  last.   Any  other options afterward will be ignored. If
+              the input file is "", the data will be read from stdin  instead
+              of a file.
+
+
+
+       KEYBOARD SHORTCUTS
+
+      c   Toggle use of color profile.
+
+      i   Overlay file information.
+
+      q/Q/ ESC
+              Quit.
+
+
+BUGS
+       Please     report     all     bugs     to     our     issue    tracker:
+       http://code.google.com/p/webp/issues
+       Patches welcome! See this  page  to  get  started:  http://www.webmpro
+       ject.org/code/contribute/submittingpatches/
+
+
+EXAMPLES
+       vwebp picture.webp
+       vwebp picture.webp mt dither 0
+       vwebp  picture.webp
+
+
+AUTHORS
+       vwebp was written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This manual page was written for the Debian project (and may be used by
+       others).
+
+
+SEE ALSO
+       dwebp(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                                 July 23, 2014                        VWEBP(1)

WebPConverter/libwebp-0.4.1-mac-10.8/doc/webpmux.html

@@ -0,0 +1,332 @@
+<!-- Creator     : groff version 1.19.2 -->
+<!-- CreationDate: Fri Sep 19 17:51:07 2014 -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta name="generator" content="groff -Thtml, see www.gnu.org">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta name="Content-Style" content="text/css">
+<style type="text/css">
+       p     { margin-top: 0; margin-bottom: 0; }
+       pre   { margin-top: 0; margin-bottom: 0; }
+       table { margin-top: 0; margin-bottom: 0; }
+</style>
+<title>WEBPMUX</title>
+
+</head>
+<body>
+
+<h1 align=center>WEBPMUX</h1>
+
+<a href="#NAME">NAME</a><br>
+<a href="#SYNOPSIS">SYNOPSIS</a><br>
+<a href="#DESCRIPTION">DESCRIPTION</a><br>
+<a href="#OPTIONS">OPTIONS</a><br>
+<a href="#BUGS">BUGS</a><br>
+<a href="#EXAMPLES">EXAMPLES</a><br>
+<a href="#AUTHORS">AUTHORS</a><br>
+<a href="#SEE ALSO">SEE ALSO</a><br>
+
+<hr>
+
+
+<a name="NAME"></a>
+<h2>NAME</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">webpmux &minus;
+command line tool to create WebP Mux/container file.</p>
+
+<a name="SYNOPSIS"></a>
+<h2>SYNOPSIS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>webpmux
+&minus;get</b> <i>GET_OPTIONS INPUT</i> <b>&minus;o</b>
+<i>OUTPUT</i> <b><br>
+webpmux &minus;set</b> <i>SET_OPTIONS INPUT</i>
+<b>&minus;o</b> <i>OUTPUT</i> <b><br>
+webpmux &minus;strip</b> <i>STRIP_OPTIONS INPUT</i>
+<b>&minus;o</b> <i>OUTPUT</i> <b><br>
+webpmux &minus;frame</b> <i>FRAME_OPTIONS</i> <b>[
+&minus;frame ... ] [ &minus;loop</b> <i>LOOP_COUNT</i>
+<b>]</b></p>
+
+<p style="margin-left:23%;"><b>[ &minus;bgcolor</b>
+<i>BACKGROUND_COLOR</i> <b>] &minus;o</b> <i>OUTPUT</i></p>
+
+<p style="margin-left:11%;"><b>webpmux &minus;info</b>
+<i>INPUT</i> <b><br>
+webpmux [&minus;h|&minus;help] <br>
+webpmux &minus;version</b></p>
+
+<a name="DESCRIPTION"></a>
+<h2>DESCRIPTION</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page documents the <b>webpmux</b> command.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>webpmux</b>
+can be used to create a WebP container file and
+extract/strip relevant data from the container file.</p>
+
+<a name="OPTIONS"></a>
+<h2>OPTIONS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>GET_OPTIONS
+(&minus;get):</b></p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p valign="top"><b>icc</b></p></td>
+<td width="5%"></td>
+<td width="27%">
+
+
+<p valign="top">Get ICC profile.</p></td>
+<td width="51%">
+</td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p style="margin-top: 1em" valign="top"><b>exif</b></p></td>
+<td width="5%"></td>
+<td width="27%">
+
+
+<p style="margin-top: 1em" valign="top">Get EXIF
+metadata.</p> </td>
+<td width="51%">
+</td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p style="margin-top: 1em" valign="top"><b>xmp</b></p></td>
+<td width="5%"></td>
+<td width="27%">
+
+
+<p style="margin-top: 1em" valign="top">Get XMP
+metadata.</p> </td>
+<td width="51%">
+</td>
+</table>
+
+<p style="margin-left:11%;"><b>frame</b> <i>n</i></p>
+
+<p style="margin-left:22%;">Get nth frame.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>SET_OPTIONS
+(&minus;set) <br>
+icc</b> <i>file.icc</i></p>
+
+<p style="margin-left:22%;">Set ICC profile.</p>
+
+<p style="margin-left:11%; margin-top: 1em">Where:
+&rsquo;file.icc&rsquo; contains the ICC profile to be set.
+<b><br>
+exif</b> <i>file.exif</i></p>
+
+<p style="margin-left:22%;">Set EXIF metadata.</p>
+
+<p style="margin-left:11%; margin-top: 1em">Where:
+&rsquo;file.exif&rsquo; contains the EXIF metadata to be
+set. <b><br>
+xmp</b> <i>file.xmp</i></p>
+
+<p style="margin-left:22%;">Set XMP metadata.</p>
+
+<p style="margin-left:11%; margin-top: 1em">Where:
+&rsquo;file.xmp&rsquo; contains the XMP metadata to be
+set.</p>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>STRIP_OPTIONS
+(&minus;strip)</b></p>
+
+<table width="100%" border=0 rules="none" frame="void"
+       cellspacing="0" cellpadding="0">
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p valign="top"><b>icc</b></p></td>
+<td width="5%"></td>
+<td width="30%">
+
+
+<p valign="top">Strip ICC profile.</p></td>
+<td width="48%">
+</td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p style="margin-top: 1em" valign="top"><b>exif</b></p></td>
+<td width="5%"></td>
+<td width="30%">
+
+
+<p style="margin-top: 1em" valign="top">Strip EXIF
+metadata.</p> </td>
+<td width="48%">
+</td>
+<tr valign="top" align="left">
+<td width="11%"></td>
+<td width="6%">
+
+
+<p style="margin-top: 1em" valign="top"><b>xmp</b></p></td>
+<td width="5%"></td>
+<td width="30%">
+
+
+<p style="margin-top: 1em" valign="top">Strip XMP
+metadata.</p> </td>
+<td width="48%">
+</td>
+</table>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>FRAME_OPTIONS
+(&minus;frame)</b> <i><br>
+file_i +di[+xi+yi[+mi[bi]]]</i></p>
+
+<p style="margin-left:22%;">Where: &rsquo;file_i&rsquo; is
+the i&rsquo;th frame (WebP format),
+&rsquo;xi&rsquo;,&rsquo;yi&rsquo; specify the image offset
+for this frame, &rsquo;di&rsquo; is the pause duration
+before next frame, &rsquo;mi&rsquo; is the dispose method
+for this frame (0 for NONE or 1 for BACKGROUND) and
+&rsquo;bi&rsquo; is the blending method for this frame (+b
+for BLEND or -b for NO_BLEND). Argument &rsquo;bi&rsquo; can
+be omitted and will default to +b (BLEND). Also,
+&rsquo;mi&rsquo; can be omitted if &rsquo;bi&rsquo; is
+omitted and will default to 0 (NONE). Finally, if
+&rsquo;mi&rsquo; and &rsquo;bi&rsquo; are omitted then
+&rsquo;xi&rsquo; and &rsquo;yi&rsquo; can be omitted and
+will default to +0+0.</p>
+
+<p style="margin-left:11%;"><b>&minus;loop</b> <i>n</i></p>
+
+<p style="margin-left:22%;">Loop the frames n number of
+times. 0 indicates the frames should loop forever. Valid
+range is 0 to 65535 [Default: 0 (infinite)].</p>
+
+<p style="margin-left:11%;"><b>&minus;bgcolor</b>
+<i>A,R,G,B</i></p>
+
+<p style="margin-left:22%;">Background color of the canvas.
+<br>
+where: &rsquo;A&rsquo;, &rsquo;R&rsquo;, &rsquo;G&rsquo; and
+&rsquo;B&rsquo; are integers in the range 0 to 255
+specifying the Alpha, Red, Green and Blue component values
+respectively [Default: 255,255,255,255].</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>INPUT</b>
+<br>
+Input file in WebP format.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>OUTPUT
+(&minus;o)</b> <br>
+Output file in WebP format.</p>
+
+<p style="margin-left:11%; margin-top: 1em"><b>Note:</b>
+<br>
+The nature of EXIF, XMP and ICC data is not checked and is
+assumed to <br>
+be valid.</p>
+
+<a name="BUGS"></a>
+<h2>BUGS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">Please report
+all bugs to our issue tracker:
+http://code.google.com/p/webp/issues <br>
+Patches welcome! See this page to get started:
+http://www.webmproject.org/code/contribute/submitting-patches/</p>
+
+<a name="EXAMPLES"></a>
+<h2>EXAMPLES</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em">webpmux
+&minus;set icc image_profile.icc in.webp &minus;o
+icc_container.webp <br>
+webpmux &minus;get icc icc_container.webp &minus;o
+image_profile.icc <br>
+webpmux &minus;strip icc icc_container.webp &minus;o
+without_icc.webp <br>
+webpmux &minus;set xmp image_metadata.xmp in.webp &minus;o
+xmp_container.webp <br>
+webpmux &minus;get xmp xmp_container.webp &minus;o
+image_metadata.xmp <br>
+webpmux &minus;strip xmp xmp_container.webp &minus;o
+without_xmp.webp <br>
+webpmux &minus;set exif image_metadata.exif in.webp &minus;o
+exif_container.webp <br>
+webpmux &minus;get exif exif_container.webp &minus;o
+image_metadata.exif <br>
+webpmux &minus;strip exif exif_container.webp &minus;o
+without_exif.webp <br>
+webpmux &minus;frame anim_1.webp +100 &minus;frame
+anim_2.webp +100+50+50</p>
+
+<p style="margin-left:23%;">&minus;frame anim_2.webp
++100+50+50+1+b &minus;loop 10 &minus;bgcolor
+255,255,255,255</p>
+
+<p style="margin-left:35%;">&minus;o
+anim_container.webp</p>
+
+<p style="margin-left:23%;">webpmux &minus;get frame 2
+anim_container.webp &minus;o frame_2.webp <br>
+webpmux &minus;set icc image_profile.icc &minus;o
+icc_container.webp &minus;&minus;
+&minus;&minus;&minus;in.webp <br>
+webpmux &minus;get icc &minus;o image_profile.icc
+&minus;&minus; &minus;&minus;&minus;icc_container.webp <br>
+webpmux &minus;strip icc &minus;o without_icc.webp
+&minus;&minus; &minus;&minus;&minus;icc_container.webp</p>
+
+<a name="AUTHORS"></a>
+<h2>AUTHORS</h2>
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>webpmux</b>
+is written by the WebP team. <br>
+The latest source tree is available at
+http://www.webmproject.org/code</p>
+
+<p style="margin-left:11%; margin-top: 1em">This manual
+page was written by Vikas Arora
+&lt;vikaas.arora@gmail.com&gt;, for the Debian project (and
+may be used by others).</p>
+
+<a name="SEE ALSO"></a>
+<h2>SEE ALSO</h2>
+
+
+
+<p style="margin-left:11%; margin-top: 1em"><b>cwebp</b>(1),
+<b>dwebp</b>(1), <b>gif2webp</b>(1) <br>
+Please refer to http://developers.google.com/speed/webp/ for
+additional information.</p>
+<hr>
+</body>
+</html>

WebPConverter/libwebp-0.4.1-mac-10.8/doc/webpmux.txt

@@ -0,0 +1,141 @@
+WEBPMUX(1)                                                          WEBPMUX(1)
+
+
+
+NAME
+       webpmux  command line tool to create WebP Mux/container file.
+
+SYNOPSIS
+       webpmuxget GET_OPTIONS INPUTo OUTPUT
+       webpmuxset SET_OPTIONS INPUTo OUTPUT
+       webpmuxstrip STRIP_OPTIONS INPUTo OUTPUT
+       webpmuxframe FRAME_OPTIONS [frame ... ] [loop LOOP_COUNT ]
+               [bgcolor BACKGROUND_COLOR ]o OUTPUT
+       webpmuxinfo INPUT
+       webpmux hhelp]
+       webpmuxversion
+
+DESCRIPTION
+       This manual page documents the webpmux command.
+
+       webpmux  can  be used to create a WebP container file and extract/strip
+       relevant data from the container file.
+
+OPTIONS
+   GET_OPTIONS get):
+       icc    Get ICC profile.
+
+       exif   Get EXIF metadata.
+
+       xmp    Get XMP metadata.
+
+       frame n
+              Get nth frame.
+
+
+   SET_OPTIONS set)
+       icc file.icc
+              Set ICC profile.
+
+       Where: file.icc contains the ICC profile to be set.
+
+       exif file.exif
+              Set EXIF metadata.
+
+       Where: file.exif contains the EXIF metadata to be set.
+
+       xmp file.xmp
+              Set XMP metadata.
+
+       Where: file.xmp contains the XMP metadata to be set.
+
+
+   STRIP_OPTIONS strip)
+       icc    Strip ICC profile.
+
+       exif   Strip EXIF metadata.
+
+       xmp    Strip XMP metadata.
+
+
+   FRAME_OPTIONS frame)
+       file_i +di[+xi+yi[+mi[bi]]]
+              Where: file_i is the ith frame (WebP format), xi,yi spec
+              ify  the image offset for this frame, di is the pause duration
+              before next frame, mi is the dispose method for this frame  (0
+              for  NONE  or  1 for BACKGROUND) and bi is the blending method
+              for this frame (+b for BLEND or b for NO_BLEND).  Argument bi
+              can  be  omitted and will default to +b (BLEND).  Also, mi can
+              be omitted if bi is omitted and  will  default  to  0  (NONE).
+              Finally,  if mi and bi are omitted then xi and yi can be
+              omitted and will default to +0+0.
+
+      loop n
+              Loop the frames n number of times. 0 indicates the frames should
+              loop  forever.   Valid  range  is  0 to 65535 [Default: 0 (infi
+              nite)].
+
+      bgcolor A,R,G,B
+              Background color of the canvas.
+              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
+       Input file in WebP format.
+
+
+   OUTPUT o)
+       Output file in WebP format.
+
+
+   Note:
+       The nature of EXIF, XMP and ICC data is not checked and is  assumed  to
+       be valid.
+
+
+BUGS
+       Please    report     all     bugs     to     our     issue     tracker:
+       http://code.google.com/p/webp/issues
+       Patches  welcome!  See  this  page  to get started: http://www.webmpro
+       ject.org/code/contribute/submittingpatches/
+
+
+EXAMPLES
+       webpmux set icc image_profile.icc in.webp o icc_container.webp
+       webpmux get icc icc_container.webp o image_profile.icc
+       webpmux strip icc icc_container.webp o without_icc.webp
+       webpmux set xmp image_metadata.xmp in.webp o xmp_container.webp
+       webpmux get xmp xmp_container.webp o image_metadata.xmp
+       webpmux strip xmp xmp_container.webp o without_xmp.webp
+       webpmux set exif image_metadata.exif in.webp o exif_container.webp
+       webpmux get exif exif_container.webp o image_metadata.exif
+       webpmux strip exif exif_container.webp o without_exif.webp
+       webpmux frame anim_1.webp +100 frame anim_2.webp +100+50+50
+               frame   anim_2.webp   +100+50+50+1+b   loop    10    bgcolor
+               255,255,255,255
+                       o anim_container.webp
+               webpmux get frame 2 anim_container.webp o frame_2.webp
+               webpmux  set  icc  image_profile.icc  o icc_container.webp
+               in.webp
+               webpmux get icc o image_profile.icc  icc_container.webp
+               webpmux strip icc o without_icc.webp  icc_container.webp
+
+
+AUTHORS
+       webpmux is written by the WebP team.
+       The latest source tree is available at http://www.webmproject.org/code
+
+       This  manual  page was written by Vikas Arora <vikaas.arora@gmail.com>,
+       for the Debian project (and may be used by others).
+
+
+SEE ALSO
+       cwebp(1), dwebp(1), gif2webp(1)
+       Please refer to http://developers.google.com/speed/webp/ for additional
+       information.
+
+
+
+                               December 17, 2013                    WEBPMUX(1)

WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/decode.h

@@ -0,0 +1,499 @@
+// Copyright 2010 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.
+// -----------------------------------------------------------------------------
+//
+//  Main decoding functions for WebP images.
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_DECODE_H_
+#define WEBP_WEBP_DECODE_H_
+
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_DECODER_ABI_VERSION 0x0203    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum VP8StatusCode VP8StatusCode;
+// typedef enum WEBP_CSP_MODE WEBP_CSP_MODE;
+typedef struct WebPRGBABuffer WebPRGBABuffer;
+typedef struct WebPYUVABuffer WebPYUVABuffer;
+typedef struct WebPDecBuffer WebPDecBuffer;
+typedef struct WebPIDecoder WebPIDecoder;
+typedef struct WebPBitstreamFeatures WebPBitstreamFeatures;
+typedef struct WebPDecoderOptions WebPDecoderOptions;
+typedef struct WebPDecoderConfig WebPDecoderConfig;
+
+// Return the decoder's version number, packed in hexadecimal using 8bits for
+// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetDecoderVersion(void);
+
+// Retrieve basic header information: width, height.
+// This function will also validate the header and return 0 in
+// case of formatting error.
+// Pointers 'width' and 'height' can be passed NULL if deemed irrelevant.
+WEBP_EXTERN(int) WebPGetInfo(const uint8_t* data, size_t data_size,
+                             int* width, int* height);
+
+// Decodes WebP images pointed to by 'data' and returns RGBA samples, along
+// with the dimensions in *width and *height. The ordering of samples in
+// memory is R, G, B, A, R, G, B, A... in scan order (endian-independent).
+// The returned pointer should be deleted calling free().
+// Returns NULL in case of error.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGBA(const uint8_t* data, size_t data_size,
+                                     int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning A, R, G, B, A, R, G, B... ordered data.
+WEBP_EXTERN(uint8_t*) WebPDecodeARGB(const uint8_t* data, size_t data_size,
+                                     int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning B, G, R, A, B, G, R, A... ordered data.
+WEBP_EXTERN(uint8_t*) WebPDecodeBGRA(const uint8_t* data, size_t data_size,
+                                     int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning R, G, B, R, G, B... ordered data.
+// If the bitstream contains transparency, it is ignored.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGB(const uint8_t* data, size_t data_size,
+                                    int* width, int* height);
+
+// Same as WebPDecodeRGB, but returning B, G, R, B, G, R... ordered data.
+WEBP_EXTERN(uint8_t*) WebPDecodeBGR(const uint8_t* data, size_t data_size,
+                                    int* width, int* height);
+
+
+// Decode WebP images pointed to by 'data' to Y'UV format(*). The pointer
+// returned is the Y samples buffer. Upon return, *u and *v will point to
+// the U and V chroma data. These U and V buffers need NOT be free()'d,
+// unlike the returned Y luma one. The dimension of the U and V planes
+// are both (*width + 1) / 2 and (*height + 1)/ 2.
+// Upon return, the Y buffer has a stride returned as '*stride', while U and V
+// have a common stride returned as '*uv_stride'.
+// Return NULL in case of error.
+// (*) Also named Y'CbCr. See: http://en.wikipedia.org/wiki/YCbCr
+WEBP_EXTERN(uint8_t*) WebPDecodeYUV(const uint8_t* data, size_t data_size,
+                                    int* width, int* height,
+                                    uint8_t** u, uint8_t** v,
+                                    int* stride, int* uv_stride);
+
+// These five functions are variants of the above ones, that decode the image
+// directly into a pre-allocated buffer 'output_buffer'. The maximum storage
+// available in this buffer is indicated by 'output_buffer_size'. If this
+// storage is not sufficient (or an error occurred), NULL is returned.
+// Otherwise, output_buffer is returned, for convenience.
+// The parameter 'output_stride' specifies the distance (in bytes)
+// between scanlines. Hence, output_buffer_size is expected to be at least
+// output_stride x picture-height.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGBAInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN(uint8_t*) WebPDecodeARGBInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN(uint8_t*) WebPDecodeBGRAInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// RGB and BGR variants. Here too the transparency information, if present,
+// will be dropped and ignored.
+WEBP_EXTERN(uint8_t*) WebPDecodeRGBInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN(uint8_t*) WebPDecodeBGRInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// WebPDecodeYUVInto() is a variant of WebPDecodeYUV() that operates directly
+// into pre-allocated luma/chroma plane buffers. This function requires the
+// strides to be passed: one for the luma plane and one for each of the
+// chroma ones. The size of each plane buffer is passed as 'luma_size',
+// 'u_size' and 'v_size' respectively.
+// Pointer to the luma plane ('*luma') is returned or NULL if an error occurred
+// during decoding (or because some buffers were found to be too small).
+WEBP_EXTERN(uint8_t*) WebPDecodeYUVInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride);
+
+//------------------------------------------------------------------------------
+// Output colorspaces and buffer
+
+// Colorspaces
+// Note: the naming describes the byte-ordering of packed samples in memory.
+// For instance, MODE_BGRA relates to samples ordered as B,G,R,A,B,G,R,A,...
+// Non-capital names (e.g.:MODE_Argb) relates to pre-multiplied RGB channels.
+// RGBA-4444 and RGB-565 colorspaces are represented by following byte-order:
+// RGBA-4444: [r3 r2 r1 r0 g3 g2 g1 g0], [b3 b2 b1 b0 a3 a2 a1 a0], ...
+// RGB-565: [r4 r3 r2 r1 r0 g5 g4 g3], [g2 g1 g0 b4 b3 b2 b1 b0], ...
+// In the case WEBP_SWAP_16BITS_CSP is defined, the bytes are swapped for
+// these two modes:
+// RGBA-4444: [b3 b2 b1 b0 a3 a2 a1 a0], [r3 r2 r1 r0 g3 g2 g1 g0], ...
+// RGB-565: [g2 g1 g0 b4 b3 b2 b1 b0], [r4 r3 r2 r1 r0 g5 g4 g3], ...
+
+typedef enum WEBP_CSP_MODE {
+  MODE_RGB = 0, MODE_RGBA = 1,
+  MODE_BGR = 2, MODE_BGRA = 3,
+  MODE_ARGB = 4, MODE_RGBA_4444 = 5,
+  MODE_RGB_565 = 6,
+  // RGB-premultiplied transparent modes (alpha value is preserved)
+  MODE_rgbA = 7,
+  MODE_bgrA = 8,
+  MODE_Argb = 9,
+  MODE_rgbA_4444 = 10,
+  // YUV modes must come after RGB ones.
+  MODE_YUV = 11, MODE_YUVA = 12,  // yuv 4:2:0
+  MODE_LAST = 13
+} WEBP_CSP_MODE;
+
+// Some useful macros:
+static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
+  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
+          mode == MODE_rgbA_4444);
+}
+
+static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
+  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
+          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
+          WebPIsPremultipliedMode(mode));
+}
+
+static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
+  return (mode < MODE_YUV);
+}
+
+//------------------------------------------------------------------------------
+// WebPDecBuffer: Generic structure for describing the output sample buffer.
+
+struct WebPRGBABuffer {    // view as RGBA
+  uint8_t* rgba;    // pointer to RGBA samples
+  int stride;       // stride in bytes from one scanline to the next.
+  size_t size;      // total size of the *rgba buffer.
+};
+
+struct WebPYUVABuffer {              // view as YUVA
+  uint8_t* y, *u, *v, *a;     // pointer to luma, chroma U/V, alpha samples
+  int y_stride;               // luma stride
+  int u_stride, v_stride;     // chroma strides
+  int a_stride;               // alpha stride
+  size_t y_size;              // luma plane size
+  size_t u_size, v_size;      // chroma planes size
+  size_t a_size;              // alpha-plane size
+};
+
+// Output buffer
+struct WebPDecBuffer {
+  WEBP_CSP_MODE colorspace;  // Colorspace.
+  int width, height;         // Dimensions.
+  int is_external_memory;    // If true, 'internal_memory' pointer is not used.
+  union {
+    WebPRGBABuffer RGBA;
+    WebPYUVABuffer YUVA;
+  } u;                       // Nameless union of buffer parameters.
+  uint32_t       pad[4];     // padding for later use
+
+  uint8_t* private_memory;   // Internally allocated memory (only when
+                             // is_external_memory is false). Should not be used
+                             // externally, but accessed via the buffer union.
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPInitDecBufferInternal(WebPDecBuffer*, int);
+
+// Initialize the structure as empty. Must be called before any other use.
+// Returns false in case of version mismatch
+static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
+  return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
+}
+
+// Free any memory associated with the buffer. Must always be called last.
+// Note: doesn't free the 'buffer' structure itself.
+WEBP_EXTERN(void) WebPFreeDecBuffer(WebPDecBuffer* buffer);
+
+//------------------------------------------------------------------------------
+// Enumeration of the status codes
+
+typedef enum VP8StatusCode {
+  VP8_STATUS_OK = 0,
+  VP8_STATUS_OUT_OF_MEMORY,
+  VP8_STATUS_INVALID_PARAM,
+  VP8_STATUS_BITSTREAM_ERROR,
+  VP8_STATUS_UNSUPPORTED_FEATURE,
+  VP8_STATUS_SUSPENDED,
+  VP8_STATUS_USER_ABORT,
+  VP8_STATUS_NOT_ENOUGH_DATA
+} VP8StatusCode;
+
+//------------------------------------------------------------------------------
+// Incremental decoding
+//
+// This API allows streamlined decoding of partial data.
+// Picture can be incrementally decoded as data become available thanks to the
+// WebPIDecoder object. This object can be left in a SUSPENDED state if the
+// picture is only partially decoded, pending additional input.
+// Code example:
+//
+//   WebPInitDecBuffer(&buffer);
+//   buffer.colorspace = mode;
+//   ...
+//   WebPIDecoder* idec = WebPINewDecoder(&buffer);
+//   while (has_more_data) {
+//     // ... (get additional data)
+//     status = WebPIAppend(idec, new_data, new_data_size);
+//     if (status != VP8_STATUS_SUSPENDED ||
+//       break;
+//     }
+//
+//     // The above call decodes the current available buffer.
+//     // Part of the image can now be refreshed by calling to
+//     // WebPIDecGetRGB()/WebPIDecGetYUVA() etc.
+//   }
+//   WebPIDelete(idec);
+
+// Creates a new incremental decoder with the supplied buffer parameter.
+// This output_buffer can be passed NULL, in which case a default output buffer
+// is used (with MODE_RGB). Otherwise, an internal reference to 'output_buffer'
+// is kept, which means that the lifespan of 'output_buffer' must be larger than
+// that of the returned WebPIDecoder object.
+// The supplied 'output_buffer' content MUST NOT be changed between calls to
+// WebPIAppend() or WebPIUpdate() unless 'output_buffer.is_external_memory' is
+// set to 1. In such a case, it is allowed to modify the pointers, size and
+// stride of output_buffer.u.RGBA or output_buffer.u.YUVA, provided they remain
+// within valid bounds.
+// All other fields of WebPDecBuffer MUST remain constant between calls.
+// Returns NULL if the allocation failed.
+WEBP_EXTERN(WebPIDecoder*) WebPINewDecoder(WebPDecBuffer* output_buffer);
+
+// This function allocates and initializes an incremental-decoder object, which
+// will output the RGB/A samples specified by 'csp' into a preallocated
+// buffer 'output_buffer'. The size of this buffer is at least
+// 'output_buffer_size' and the stride (distance in bytes between two scanlines)
+// is specified by 'output_stride'.
+// Additionally, output_buffer can be passed NULL in which case the output
+// buffer will be allocated automatically when the decoding starts. The
+// colorspace 'csp' is taken into account for allocating this buffer. All other
+// parameters are ignored.
+// Returns NULL if the allocation failed, or if some parameters are invalid.
+WEBP_EXTERN(WebPIDecoder*) WebPINewRGB(
+    WEBP_CSP_MODE csp,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// This function allocates and initializes an incremental-decoder object, which
+// will output the raw luma/chroma samples into a preallocated planes if
+// supplied. The luma plane is specified by its pointer 'luma', its size
+// 'luma_size' and its stride 'luma_stride'. Similarly, the chroma-u plane
+// is specified by the 'u', 'u_size' and 'u_stride' parameters, and the chroma-v
+// plane by 'v' and 'v_size'. And same for the alpha-plane. The 'a' pointer
+// can be pass NULL in case one is not interested in the transparency plane.
+// Conversely, 'luma' can be passed NULL if no preallocated planes are supplied.
+// In this case, the output buffer will be automatically allocated (using
+// MODE_YUVA) when decoding starts. All parameters are then ignored.
+// Returns NULL if the allocation failed or if a parameter is invalid.
+WEBP_EXTERN(WebPIDecoder*) WebPINewYUVA(
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride,
+    uint8_t* a, size_t a_size, int a_stride);
+
+// Deprecated version of the above, without the alpha plane.
+// Kept for backward compatibility.
+WEBP_EXTERN(WebPIDecoder*) WebPINewYUV(
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride);
+
+// Deletes the WebPIDecoder object and associated memory. Must always be called
+// if WebPINewDecoder, WebPINewRGB or WebPINewYUV succeeded.
+WEBP_EXTERN(void) WebPIDelete(WebPIDecoder* idec);
+
+// Copies and decodes the next available data. Returns VP8_STATUS_OK when
+// the image is successfully decoded. Returns VP8_STATUS_SUSPENDED when more
+// data is expected. Returns error in other cases.
+WEBP_EXTERN(VP8StatusCode) WebPIAppend(
+    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+
+// A variant of the above function to be used when data buffer contains
+// partial data from the beginning. In this case data buffer is not copied
+// to the internal memory.
+// Note that the value of the 'data' pointer can change between calls to
+// WebPIUpdate, for instance when the data buffer is resized to fit larger data.
+WEBP_EXTERN(VP8StatusCode) WebPIUpdate(
+    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+
+// Returns the RGB/A image decoded so far. Returns NULL if output params
+// are not initialized yet. The RGB/A output type corresponds to the colorspace
+// specified during call to WebPINewDecoder() or WebPINewRGB().
+// *last_y is the index of last decoded row in raster scan order. Some pointers
+// (*last_y, *width etc.) can be NULL if corresponding information is not
+// needed.
+WEBP_EXTERN(uint8_t*) WebPIDecGetRGB(
+    const WebPIDecoder* idec, int* last_y,
+    int* width, int* height, int* stride);
+
+// Same as above function to get a YUVA image. Returns pointer to the luma
+// plane or NULL in case of error. If there is no alpha information
+// the alpha pointer '*a' will be returned NULL.
+WEBP_EXTERN(uint8_t*) WebPIDecGetYUVA(
+    const WebPIDecoder* idec, int* last_y,
+    uint8_t** u, uint8_t** v, uint8_t** a,
+    int* width, int* height, int* stride, int* uv_stride, int* a_stride);
+
+// Deprecated alpha-less version of WebPIDecGetYUVA(): it will ignore the
+// alpha information (if present). Kept for backward compatibility.
+static WEBP_INLINE uint8_t* WebPIDecGetYUV(
+    const WebPIDecoder* idec, int* last_y, uint8_t** u, uint8_t** v,
+    int* width, int* height, int* stride, int* uv_stride) {
+  return WebPIDecGetYUVA(idec, last_y, u, v, NULL, width, height,
+                         stride, uv_stride, NULL);
+}
+
+// Generic call to retrieve information about the displayable area.
+// If non NULL, the left/right/width/height pointers are filled with the visible
+// rectangular area so far.
+// Returns NULL in case the incremental decoder object is in an invalid state.
+// Otherwise returns the pointer to the internal representation. This structure
+// is read-only, tied to WebPIDecoder's lifespan and should not be modified.
+WEBP_EXTERN(const WebPDecBuffer*) WebPIDecodedArea(
+    const WebPIDecoder* idec, int* left, int* top, int* width, int* height);
+
+//------------------------------------------------------------------------------
+// Advanced decoding parametrization
+//
+//  Code sample for using the advanced decoding API
+/*
+     // 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', if needed
+     config.no_fancy_upsampling = 1;
+     config.output.colorspace = MODE_BGRA;
+     // etc.
+
+     // Note that you can also make config.output point to an externally
+     // supplied memory buffer, provided it's big enough to store the decoded
+     // picture. Otherwise, config.output will just be used to allocate memory
+     // and store the decoded picture.
+
+     // D) Decode!
+     CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
+
+     // E) Decoded image is now in config.output (and config.output.u.RGBA)
+
+     // F) 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);
+*/
+
+// Features gathered from the bitstream
+struct WebPBitstreamFeatures {
+  int width;          // Width in pixels, as read from the bitstream.
+  int height;         // Height in pixels, as read from the bitstream.
+  int has_alpha;      // True if the bitstream contains an alpha channel.
+  int has_animation;  // True if the bitstream is an animation.
+  int format;         // 0 = undefined (/mixed), 1 = lossy, 2 = lossless
+
+  // Unused for now:
+  int no_incremental_decoding;  // if true, using incremental decoding is not
+                                // recommended.
+  int rotate;                   // TODO(later)
+  int uv_sampling;              // should be 0 for now. TODO(later)
+  uint32_t pad[2];              // padding for later use
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(VP8StatusCode) WebPGetFeaturesInternal(
+    const uint8_t*, size_t, WebPBitstreamFeatures*, int);
+
+// Retrieve features from the bitstream. The *features structure is filled
+// with information gathered from the bitstream.
+// Returns VP8_STATUS_OK when the features are successfully retrieved. Returns
+// VP8_STATUS_NOT_ENOUGH_DATA when more data is needed to retrieve the
+// features from headers. Returns error in other cases.
+static WEBP_INLINE VP8StatusCode WebPGetFeatures(
+    const uint8_t* data, size_t data_size,
+    WebPBitstreamFeatures* features) {
+  return WebPGetFeaturesInternal(data, data_size, features,
+                                 WEBP_DECODER_ABI_VERSION);
+}
+
+// Decoding options
+struct WebPDecoderOptions {
+  int bypass_filtering;               // if true, skip the in-loop filtering
+  int no_fancy_upsampling;            // if true, use faster pointwise upsampler
+  int use_cropping;                   // if true, cropping is applied _first_
+  int crop_left, crop_top;            // top-left position for cropping.
+                                      // Will be snapped to even values.
+  int crop_width, crop_height;        // dimension of the cropping area
+  int use_scaling;                    // if true, scaling is applied _afterward_
+  int scaled_width, scaled_height;    // final resolution
+  int use_threads;                    // if true, use multi-threaded decoding
+  int dithering_strength;             // dithering strength (0=Off, 100=full)
+#if WEBP_DECODER_ABI_VERSION > 0x0203
+  int flip;                           // flip output vertically
+  int alpha_dithering_strength;       // alpha dithering strength in [0..100]
+#endif
+
+  // Unused for now:
+  int force_rotation;                 // forced rotation (to be applied _last_)
+  int no_enhancement;                 // if true, discard enhancement layer
+#if WEBP_DECODER_ABI_VERSION > 0x0203
+  uint32_t pad[3];                    // padding for later use
+#else
+  uint32_t pad[5];                    // padding for later use
+#endif
+};
+
+// Main object storing the configuration for advanced decoding.
+struct WebPDecoderConfig {
+  WebPBitstreamFeatures input;  // Immutable bitstream features (optional)
+  WebPDecBuffer output;         // Output buffer (can point to external mem)
+  WebPDecoderOptions options;   // Decoding options
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPInitDecoderConfigInternal(WebPDecoderConfig*, int);
+
+// Initialize the configuration as empty. This function must always be
+// called first, unless WebPGetFeatures() is to be called.
+// Returns false in case of mismatched version.
+static WEBP_INLINE int WebPInitDecoderConfig(WebPDecoderConfig* config) {
+  return WebPInitDecoderConfigInternal(config, WEBP_DECODER_ABI_VERSION);
+}
+
+// Instantiate a new incremental decoder object with the requested
+// configuration. The bitstream can be passed using 'data' and 'data_size'
+// parameter, in which case the features will be parsed and stored into
+// config->input. Otherwise, 'data' can be NULL and no parsing will occur.
+// Note that 'config' can be NULL too, in which case a default configuration
+// is used.
+// The return WebPIDecoder object must always be deleted calling WebPIDelete().
+// Returns NULL in case of error (and config->status will then reflect
+// the error condition).
+WEBP_EXTERN(WebPIDecoder*) WebPIDecode(const uint8_t* data, size_t data_size,
+                                       WebPDecoderConfig* config);
+
+// Non-incremental version. This version decodes the full data at once, taking
+// 'config' into account. Returns decoding status (which should be VP8_STATUS_OK
+// if the decoding was successful).
+WEBP_EXTERN(VP8StatusCode) WebPDecode(const uint8_t* data, size_t data_size,
+                                      WebPDecoderConfig* config);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_DECODE_H_ */

WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/demux.h

@@ -0,0 +1,224 @@
+// Copyright 2012 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.
+// -----------------------------------------------------------------------------
+//
+// Demux API.
+// Enables extraction of image and extended format data from WebP files.
+
+// 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);
+*/
+
+#ifndef WEBP_WEBP_DEMUX_H_
+#define WEBP_WEBP_DEMUX_H_
+
+#include "./mux_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_DEMUX_ABI_VERSION 0x0101    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPDemuxState WebPDemuxState;
+// typedef enum WebPFormatFeature WebPFormatFeature;
+typedef struct WebPDemuxer WebPDemuxer;
+typedef struct WebPIterator WebPIterator;
+typedef struct WebPChunkIterator WebPChunkIterator;
+
+//------------------------------------------------------------------------------
+
+// Returns the version number of the demux library, packed in hexadecimal using
+// 8bits for each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetDemuxVersion(void);
+
+//------------------------------------------------------------------------------
+// Life of a Demux object
+
+typedef enum WebPDemuxState {
+  WEBP_DEMUX_PARSE_ERROR    = -1,  // An error occurred while parsing.
+  WEBP_DEMUX_PARSING_HEADER =  0,  // Not enough data to parse full header.
+  WEBP_DEMUX_PARSED_HEADER  =  1,  // Header parsing complete,
+                                   // data may be available.
+  WEBP_DEMUX_DONE           =  2   // Entire file has been parsed.
+} WebPDemuxState;
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(WebPDemuxer*) WebPDemuxInternal(
+    const WebPData*, int, WebPDemuxState*, int);
+
+// Parses the full WebP file given by 'data'.
+// Returns a WebPDemuxer object on successful parse, NULL otherwise.
+static WEBP_INLINE WebPDemuxer* WebPDemux(const WebPData* data) {
+  return WebPDemuxInternal(data, 0, NULL, WEBP_DEMUX_ABI_VERSION);
+}
+
+// Parses the possibly incomplete WebP file given by 'data'.
+// If 'state' is non-NULL it will be set to indicate the status of the demuxer.
+// Returns NULL in case of error or if there isn't enough data to start parsing;
+// and a WebPDemuxer object on successful parse.
+// Note that WebPDemuxer keeps internal pointers to 'data' memory segment.
+// If this data is volatile, the demuxer object should be deleted (by calling
+// WebPDemuxDelete()) and WebPDemuxPartial() called again on the new data.
+// This is usually an inexpensive operation.
+static WEBP_INLINE WebPDemuxer* WebPDemuxPartial(
+    const WebPData* data, WebPDemuxState* state) {
+  return WebPDemuxInternal(data, 1, state, WEBP_DEMUX_ABI_VERSION);
+}
+
+// Frees memory associated with 'dmux'.
+WEBP_EXTERN(void) WebPDemuxDelete(WebPDemuxer* dmux);
+
+//------------------------------------------------------------------------------
+// Data/information extraction.
+
+typedef enum WebPFormatFeature {
+  WEBP_FF_FORMAT_FLAGS,  // Extended format flags present in the 'VP8X' chunk.
+  WEBP_FF_CANVAS_WIDTH,
+  WEBP_FF_CANVAS_HEIGHT,
+  WEBP_FF_LOOP_COUNT,
+  WEBP_FF_BACKGROUND_COLOR,
+  WEBP_FF_FRAME_COUNT    // Number of frames present in the demux object.
+                         // In case of a partial demux, this is the number of
+                         // frames seen so far, with the last frame possibly
+                         // being partial.
+} WebPFormatFeature;
+
+// Get the 'feature' value from the 'dmux'.
+// NOTE: values are only valid if WebPDemux() was used or WebPDemuxPartial()
+// returned a state > WEBP_DEMUX_PARSING_HEADER.
+WEBP_EXTERN(uint32_t) WebPDemuxGetI(
+    const WebPDemuxer* dmux, WebPFormatFeature feature);
+
+//------------------------------------------------------------------------------
+// Frame iteration.
+
+struct WebPIterator {
+  int frame_num;
+  int num_frames;          // equivalent to WEBP_FF_FRAME_COUNT.
+  int fragment_num;
+  int num_fragments;
+  int x_offset, y_offset;  // offset relative to the canvas.
+  int width, height;       // dimensions of this frame or fragment.
+  int duration;            // display duration in milliseconds.
+  WebPMuxAnimDispose dispose_method;  // dispose method for the frame.
+  int complete;   // true if 'fragment' contains a full frame. partial images
+                  // may still be decoded with the WebP incremental decoder.
+  WebPData fragment;  // The frame or fragment given by 'frame_num' and
+                      // 'fragment_num'.
+  int has_alpha;      // True if the frame or fragment contains transparency.
+  WebPMuxAnimBlend blend_method;  // Blend operation for the frame.
+
+  uint32_t pad[2];         // padding for later use.
+  void* private_;          // for internal use only.
+};
+
+// Retrieves frame 'frame_number' from 'dmux'.
+// 'iter->fragment' points to the first fragment on return from this function.
+// Individual fragments may be extracted using WebPDemuxSelectFragment().
+// Setting 'frame_number' equal to 0 will return the last frame of the image.
+// Returns false if 'dmux' is NULL or frame 'frame_number' is not present.
+// Call WebPDemuxReleaseIterator() when use of the iterator is complete.
+// NOTE: 'dmux' must persist for the lifetime of 'iter'.
+WEBP_EXTERN(int) WebPDemuxGetFrame(
+    const WebPDemuxer* dmux, int frame_number, WebPIterator* iter);
+
+// Sets 'iter->fragment' to point to the next ('iter->frame_num' + 1) or
+// previous ('iter->frame_num' - 1) frame. These functions do not loop.
+// Returns true on success, false otherwise.
+WEBP_EXTERN(int) WebPDemuxNextFrame(WebPIterator* iter);
+WEBP_EXTERN(int) WebPDemuxPrevFrame(WebPIterator* iter);
+
+// Sets 'iter->fragment' to reflect fragment number 'fragment_num'.
+// Returns true if fragment 'fragment_num' is present, false otherwise.
+WEBP_EXTERN(int) WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);
+
+// Releases any memory associated with 'iter'.
+// Must be called before any subsequent calls to WebPDemuxGetChunk() on the same
+// iter. Also, must be called before destroying the associated WebPDemuxer with
+// WebPDemuxDelete().
+WEBP_EXTERN(void) WebPDemuxReleaseIterator(WebPIterator* iter);
+
+//------------------------------------------------------------------------------
+// Chunk iteration.
+
+struct WebPChunkIterator {
+  // The current and total number of chunks with the fourcc given to
+  // WebPDemuxGetChunk().
+  int chunk_num;
+  int num_chunks;
+  WebPData chunk;    // The payload of the chunk.
+
+  uint32_t pad[6];   // padding for later use
+  void* private_;
+};
+
+// Retrieves the 'chunk_number' instance of the chunk with id 'fourcc' from
+// 'dmux'.
+// 'fourcc' is a character array containing the fourcc of the chunk to return,
+// e.g., "ICCP", "XMP ", "EXIF", etc.
+// Setting 'chunk_number' equal to 0 will return the last chunk in a set.
+// Returns true if the chunk is found, false otherwise. Image related chunk
+// payloads are accessed through WebPDemuxGetFrame() and related functions.
+// Call WebPDemuxReleaseChunkIterator() when use of the iterator is complete.
+// NOTE: 'dmux' must persist for the lifetime of the iterator.
+WEBP_EXTERN(int) WebPDemuxGetChunk(const WebPDemuxer* dmux,
+                                   const char fourcc[4], int chunk_number,
+                                   WebPChunkIterator* iter);
+
+// Sets 'iter->chunk' to point to the next ('iter->chunk_num' + 1) or previous
+// ('iter->chunk_num' - 1) chunk. These functions do not loop.
+// Returns true on success, false otherwise.
+WEBP_EXTERN(int) WebPDemuxNextChunk(WebPChunkIterator* iter);
+WEBP_EXTERN(int) WebPDemuxPrevChunk(WebPChunkIterator* iter);
+
+// Releases any memory associated with 'iter'.
+// Must be called before destroying the associated WebPDemuxer with
+// WebPDemuxDelete().
+WEBP_EXTERN(void) WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_DEMUX_H_ */

WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/encode.h

@@ -0,0 +1,508 @@
+// Copyright 2011 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 encoder: main interface
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_ENCODE_H_
+#define WEBP_WEBP_ENCODE_H_
+
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_ENCODER_ABI_VERSION 0x0202    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPImageHint WebPImageHint;
+// typedef enum WebPEncCSP WebPEncCSP;
+// typedef enum WebPPreset WebPPreset;
+// typedef enum WebPEncodingError WebPEncodingError;
+typedef struct WebPConfig WebPConfig;
+typedef struct WebPPicture WebPPicture;   // main structure for I/O
+typedef struct WebPAuxStats WebPAuxStats;
+typedef struct WebPMemoryWriter WebPMemoryWriter;
+
+// Return the encoder's version number, packed in hexadecimal using 8bits for
+// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetEncoderVersion(void);
+
+//------------------------------------------------------------------------------
+// One-stop-shop call! No questions asked:
+
+// Returns the size of the compressed data (pointed to by *output), or 0 if
+// an error occurred. The compressed data must be released by the caller
+// using the call 'free(*output)'.
+// These functions compress using the lossy format, and the quality_factor
+// can go from 0 (smaller output, lower quality) to 100 (best quality,
+// larger output).
+WEBP_EXTERN(size_t) WebPEncodeRGB(const uint8_t* rgb,
+                                  int width, int height, int stride,
+                                  float quality_factor, uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeBGR(const uint8_t* bgr,
+                                  int width, int height, int stride,
+                                  float quality_factor, uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeRGBA(const uint8_t* rgba,
+                                   int width, int height, int stride,
+                                   float quality_factor, uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeBGRA(const uint8_t* bgra,
+                                   int width, int height, int stride,
+                                   float quality_factor, uint8_t** output);
+
+// These functions are the equivalent of the above, but compressing in a
+// lossless manner. Files are usually larger than lossy format, but will
+// not suffer any compression loss.
+WEBP_EXTERN(size_t) WebPEncodeLosslessRGB(const uint8_t* rgb,
+                                          int width, int height, int stride,
+                                          uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeLosslessBGR(const uint8_t* bgr,
+                                          int width, int height, int stride,
+                                          uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeLosslessRGBA(const uint8_t* rgba,
+                                           int width, int height, int stride,
+                                           uint8_t** output);
+WEBP_EXTERN(size_t) WebPEncodeLosslessBGRA(const uint8_t* bgra,
+                                           int width, int height, int stride,
+                                           uint8_t** output);
+
+//------------------------------------------------------------------------------
+// Coding parameters
+
+// Image characteristics hint for the underlying encoder.
+typedef enum WebPImageHint {
+  WEBP_HINT_DEFAULT = 0,  // default preset.
+  WEBP_HINT_PICTURE,      // digital picture, like portrait, inner shot
+  WEBP_HINT_PHOTO,        // outdoor photograph, with natural lighting
+  WEBP_HINT_GRAPH,        // Discrete tone image (graph, map-tile etc).
+  WEBP_HINT_LAST
+} WebPImageHint;
+
+// Compression parameters.
+struct WebPConfig {
+  int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
+  float quality;          // between 0 (smallest file) and 100 (biggest)
+  int method;             // quality/speed trade-off (0=fast, 6=slower-better)
+
+  WebPImageHint image_hint;  // Hint for image type (lossless only for now).
+
+  // Parameters related to lossy compression only:
+  int target_size;        // if non-zero, set the desired target size in bytes.
+                          // Takes precedence over the 'compression' parameter.
+  float target_PSNR;      // if non-zero, specifies the minimal distortion to
+                          // try to achieve. Takes precedence over target_size.
+  int segments;           // maximum number of segments to use, in [1..4]
+  int sns_strength;       // Spatial Noise Shaping. 0=off, 100=maximum.
+  int filter_strength;    // range: [0 = off .. 100 = strongest]
+  int filter_sharpness;   // range: [0 = off .. 7 = least sharp]
+  int filter_type;        // filtering type: 0 = simple, 1 = strong (only used
+                          // if filter_strength > 0 or autofilter > 0)
+  int autofilter;         // Auto adjust filter's strength [0 = off, 1 = on]
+  int alpha_compression;  // Algorithm for encoding the alpha plane (0 = none,
+                          // 1 = compressed with WebP lossless). Default is 1.
+  int alpha_filtering;    // Predictive filtering method for alpha plane.
+                          //  0: none, 1: fast, 2: best. Default if 1.
+  int alpha_quality;      // Between 0 (smallest size) and 100 (lossless).
+                          // Default is 100.
+  int pass;               // number of entropy-analysis passes (in [1..10]).
+
+  int show_compressed;    // if true, export the compressed picture back.
+                          // In-loop filtering is not applied.
+  int preprocessing;      // preprocessing filter:
+                          // 0=none, 1=segment-smooth, 2=pseudo-random dithering
+  int partitions;         // log2(number of token partitions) in [0..3]. Default
+                          // is set to 0 for easier progressive decoding.
+  int partition_limit;    // quality degradation allowed to fit the 512k limit
+                          // on prediction modes coding (0: no degradation,
+                          // 100: maximum possible degradation).
+  int emulate_jpeg_size;  // If true, compression parameters will be remapped
+                          // to better match the expected output size from
+                          // JPEG compression. Generally, the output size will
+                          // be similar but the degradation will be lower.
+  int thread_level;       // If non-zero, try and use multi-threaded encoding.
+  int low_memory;         // If set, reduce memory usage (but increase CPU use).
+
+  uint32_t pad[5];        // padding for later use
+};
+
+// Enumerate some predefined settings for WebPConfig, depending on the type
+// of source picture. These presets are used when calling WebPConfigPreset().
+typedef enum WebPPreset {
+  WEBP_PRESET_DEFAULT = 0,  // default preset.
+  WEBP_PRESET_PICTURE,      // digital picture, like portrait, inner shot
+  WEBP_PRESET_PHOTO,        // outdoor photograph, with natural lighting
+  WEBP_PRESET_DRAWING,      // hand or line drawing, with high-contrast details
+  WEBP_PRESET_ICON,         // small-sized colorful images
+  WEBP_PRESET_TEXT          // text-like
+} WebPPreset;
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPConfigInitInternal(WebPConfig*, WebPPreset, float, int);
+
+// Should always be called, to initialize a fresh WebPConfig structure before
+// modification. Returns false in case of version mismatch. WebPConfigInit()
+// must have succeeded before using the 'config' object.
+// Note that the default values are lossless=0 and quality=75.
+static WEBP_INLINE int WebPConfigInit(WebPConfig* config) {
+  return WebPConfigInitInternal(config, WEBP_PRESET_DEFAULT, 75.f,
+                                WEBP_ENCODER_ABI_VERSION);
+}
+
+// This function will initialize the configuration according to a predefined
+// set of parameters (referred to by 'preset') and a given quality factor.
+// This function can be called as a replacement to WebPConfigInit(). Will
+// return false in case of error.
+static WEBP_INLINE int WebPConfigPreset(WebPConfig* config,
+                                        WebPPreset preset, float quality) {
+  return WebPConfigInitInternal(config, preset, quality,
+                                WEBP_ENCODER_ABI_VERSION);
+}
+
+#if WEBP_ENCODER_ABI_VERSION > 0x0202
+// Activate the lossless compression mode with the desired efficiency level
+// between 0 (fastest, lowest compression) and 9 (slower, best compression).
+// A good default level is '6', providing a fair tradeoff between compression
+// speed and final compressed size.
+// This function will overwrite several fields from config: 'method', 'quality'
+// and 'lossless'. Returns false in case of parameter error.
+WEBP_EXTERN(int) WebPConfigLosslessPreset(WebPConfig* config, int level);
+#endif
+
+// Returns true if 'config' is non-NULL and all configuration parameters are
+// within their valid ranges.
+WEBP_EXTERN(int) WebPValidateConfig(const WebPConfig* config);
+
+//------------------------------------------------------------------------------
+// Input / Output
+// Structure for storing auxiliary statistics (mostly for lossy encoding).
+
+struct WebPAuxStats {
+  int coded_size;         // final size
+
+  float PSNR[5];          // peak-signal-to-noise ratio for Y/U/V/All/Alpha
+  int block_count[3];     // number of intra4/intra16/skipped macroblocks
+  int header_bytes[2];    // approximate number of bytes spent for header
+                          // and mode-partition #0
+  int residual_bytes[3][4];  // approximate number of bytes spent for
+                             // DC/AC/uv coefficients for each (0..3) segments.
+  int segment_size[4];    // number of macroblocks in each segments
+  int segment_quant[4];   // quantizer values for each segments
+  int segment_level[4];   // filtering strength for each segments [0..63]
+
+  int alpha_data_size;    // size of the transparency data
+  int layer_data_size;    // size of the enhancement layer data
+
+  // lossless encoder statistics
+  uint32_t lossless_features;  // bit0:predictor bit1:cross-color transform
+                               // bit2:subtract-green bit3:color indexing
+  int histogram_bits;          // number of precision bits of histogram
+  int transform_bits;          // precision bits for transform
+  int cache_bits;              // number of bits for color cache lookup
+  int palette_size;            // number of color in palette, if used
+  int lossless_size;           // final lossless size
+
+  uint32_t pad[4];        // padding for later use
+};
+
+// Signature for output function. Should return true if writing was successful.
+// data/data_size is the segment of data to write, and 'picture' is for
+// reference (and so one can make use of picture->custom_ptr).
+typedef int (*WebPWriterFunction)(const uint8_t* data, size_t data_size,
+                                  const WebPPicture* picture);
+
+// WebPMemoryWrite: a special WebPWriterFunction that writes to memory using
+// the following WebPMemoryWriter object (to be set as a custom_ptr).
+struct WebPMemoryWriter {
+  uint8_t* mem;       // final buffer (of size 'max_size', larger than 'size').
+  size_t   size;      // final size
+  size_t   max_size;  // total capacity
+  uint32_t pad[1];    // padding for later use
+};
+
+// The following must be called first before any use.
+WEBP_EXTERN(void) WebPMemoryWriterInit(WebPMemoryWriter* writer);
+
+#if WEBP_ENCODER_ABI_VERSION > 0x0202
+// The following must be called to deallocate writer->mem memory. The 'writer'
+// object itself is not deallocated.
+WEBP_EXTERN(void) WebPMemoryWriterClear(WebPMemoryWriter* writer);
+#endif
+// The custom writer to be used with WebPMemoryWriter as custom_ptr. Upon
+// completion, writer.mem and writer.size will hold the coded data.
+#if WEBP_ENCODER_ABI_VERSION > 0x0202
+// writer.mem must be freed by calling WebPMemoryWriterClear.
+#else
+// writer.mem must be freed by calling 'free(writer.mem)'.
+#endif
+WEBP_EXTERN(int) WebPMemoryWrite(const uint8_t* data, size_t data_size,
+                                 const WebPPicture* picture);
+
+// Progress hook, called from time to time to report progress. It can return
+// false to request an abort of the encoding process, or true otherwise if
+// everything is OK.
+typedef int (*WebPProgressHook)(int percent, const WebPPicture* picture);
+
+// Color spaces.
+typedef enum WebPEncCSP {
+  // chroma sampling
+  WEBP_YUV420  = 0,        // 4:2:0
+  WEBP_YUV420A = 4,        // alpha channel variant
+  WEBP_CSP_UV_MASK = 3,    // bit-mask to get the UV sampling factors
+  WEBP_CSP_ALPHA_BIT = 4   // bit that is set if alpha is present
+} WebPEncCSP;
+
+// Encoding error conditions.
+typedef enum WebPEncodingError {
+  VP8_ENC_OK = 0,
+  VP8_ENC_ERROR_OUT_OF_MEMORY,            // memory error allocating objects
+  VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY,  // memory error while flushing bits
+  VP8_ENC_ERROR_NULL_PARAMETER,           // a pointer parameter is NULL
+  VP8_ENC_ERROR_INVALID_CONFIGURATION,    // configuration is invalid
+  VP8_ENC_ERROR_BAD_DIMENSION,            // picture has invalid width/height
+  VP8_ENC_ERROR_PARTITION0_OVERFLOW,      // partition is bigger than 512k
+  VP8_ENC_ERROR_PARTITION_OVERFLOW,       // partition is bigger than 16M
+  VP8_ENC_ERROR_BAD_WRITE,                // error while flushing bytes
+  VP8_ENC_ERROR_FILE_TOO_BIG,             // file is bigger than 4G
+  VP8_ENC_ERROR_USER_ABORT,               // abort request by user
+  VP8_ENC_ERROR_LAST                      // list terminator. always last.
+} WebPEncodingError;
+
+// maximum width/height allowed (inclusive), in pixels
+#define WEBP_MAX_DIMENSION 16383
+
+// Main exchange structure (input samples, output bytes, statistics)
+struct WebPPicture {
+  //   INPUT
+  //////////////
+  // Main flag for encoder selecting between ARGB or YUV input.
+  // It is recommended to use ARGB input (*argb, argb_stride) for lossless
+  // compression, and YUV input (*y, *u, *v, etc.) for lossy compression
+  // since these are the respective native colorspace for these formats.
+  int use_argb;
+
+  // YUV input (mostly used for input to lossy compression)
+  WebPEncCSP colorspace;     // colorspace: should be YUV420 for now (=Y'CbCr).
+  int width, height;         // dimensions (less or equal to WEBP_MAX_DIMENSION)
+  uint8_t *y, *u, *v;        // pointers to luma/chroma planes.
+  int y_stride, uv_stride;   // luma/chroma strides.
+  uint8_t* a;                // pointer to the alpha plane
+  int a_stride;              // stride of the alpha plane
+  uint32_t pad1[2];          // padding for later use
+
+  // ARGB input (mostly used for input to lossless compression)
+  uint32_t* argb;            // Pointer to argb (32 bit) plane.
+  int argb_stride;           // This is stride in pixels units, not bytes.
+  uint32_t pad2[3];          // padding for later use
+
+  //   OUTPUT
+  ///////////////
+  // Byte-emission hook, to store compressed bytes as they are ready.
+  WebPWriterFunction writer;  // can be NULL
+  void* custom_ptr;           // can be used by the writer.
+
+  // map for extra information (only for lossy compression mode)
+  int extra_info_type;    // 1: intra type, 2: segment, 3: quant
+                          // 4: intra-16 prediction mode,
+                          // 5: chroma prediction mode,
+                          // 6: bit cost, 7: distortion
+  uint8_t* extra_info;    // if not NULL, points to an array of size
+                          // ((width + 15) / 16) * ((height + 15) / 16) that
+                          // will be filled with a macroblock map, depending
+                          // on extra_info_type.
+
+  //   STATS AND REPORTS
+  ///////////////////////////
+  // Pointer to side statistics (updated only if not NULL)
+  WebPAuxStats* stats;
+
+  // Error code for the latest error encountered during encoding
+  WebPEncodingError error_code;
+
+  // If not NULL, report progress during encoding.
+  WebPProgressHook progress_hook;
+
+  void* user_data;        // this field is free to be set to any value and
+                          // used during callbacks (like progress-report e.g.).
+
+  uint32_t pad3[3];       // padding for later use
+
+  // Unused for now
+  uint8_t *pad4, *pad5;
+  uint32_t pad6[8];       // padding for later use
+
+  // PRIVATE FIELDS
+  ////////////////////
+  void* memory_;          // row chunk of memory for yuva planes
+  void* memory_argb_;     // and for argb too.
+  void* pad7[2];          // padding for later use
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(int) WebPPictureInitInternal(WebPPicture*, int);
+
+// Should always be called, to initialize the structure. Returns false in case
+// of version mismatch. WebPPictureInit() must have succeeded before using the
+// 'picture' object.
+// Note that, by default, use_argb is false and colorspace is WEBP_YUV420.
+static WEBP_INLINE int WebPPictureInit(WebPPicture* picture) {
+  return WebPPictureInitInternal(picture, WEBP_ENCODER_ABI_VERSION);
+}
+
+//------------------------------------------------------------------------------
+// WebPPicture utils
+
+// Convenience allocation / deallocation based on picture->width/height:
+// Allocate y/u/v buffers as per colorspace/width/height specification.
+// Note! This function will free the previous buffer if needed.
+// Returns false in case of memory error.
+WEBP_EXTERN(int) WebPPictureAlloc(WebPPicture* picture);
+
+// Release the memory allocated by WebPPictureAlloc() or WebPPictureImport*().
+// Note that this function does _not_ free the memory used by the 'picture'
+// object itself.
+// Besides memory (which is reclaimed) all other fields of 'picture' are
+// preserved.
+WEBP_EXTERN(void) WebPPictureFree(WebPPicture* picture);
+
+// Copy the pixels of *src into *dst, using WebPPictureAlloc. Upon return, *dst
+// will fully own the copied pixels (this is not a view). The 'dst' picture need
+// not be initialized as its content is overwritten.
+// Returns false in case of memory allocation error.
+WEBP_EXTERN(int) WebPPictureCopy(const WebPPicture* src, WebPPicture* dst);
+
+// Compute PSNR, SSIM or LSIM distortion metric between two pictures.
+// Result is in dB, stores in result[] in the Y/U/V/Alpha/All order.
+// Returns false in case of error (src and ref don't have same dimension, ...)
+// Warning: this function is rather CPU-intensive.
+WEBP_EXTERN(int) WebPPictureDistortion(
+    const WebPPicture* src, const WebPPicture* ref,
+    int metric_type,           // 0 = PSNR, 1 = SSIM, 2 = LSIM
+    float result[5]);
+
+// self-crops a picture to the rectangle defined by top/left/width/height.
+// Returns false in case of memory allocation error, or if the rectangle is
+// outside of the source picture.
+// The rectangle for the view is defined by the top-left corner pixel
+// coordinates (left, top) as well as its width and height. This rectangle
+// must be fully be comprised inside the 'src' source picture. If the source
+// picture uses the YUV420 colorspace, the top and left coordinates will be
+// snapped to even values.
+WEBP_EXTERN(int) WebPPictureCrop(WebPPicture* picture,
+                                 int left, int top, int width, int height);
+
+// Extracts a view from 'src' picture into 'dst'. The rectangle for the view
+// is defined by the top-left corner pixel coordinates (left, top) as well
+// as its width and height. This rectangle must be fully be comprised inside
+// the 'src' source picture. If the source picture uses the YUV420 colorspace,
+// the top and left coordinates will be snapped to even values.
+// Picture 'src' must out-live 'dst' picture. Self-extraction of view is allowed
+// ('src' equal to 'dst') as a mean of fast-cropping (but note that doing so,
+// the original dimension will be lost). Picture 'dst' need not be initialized
+// with WebPPictureInit() if it is different from 'src', since its content will
+// be overwritten.
+// Returns false in case of memory allocation error or invalid parameters.
+WEBP_EXTERN(int) WebPPictureView(const WebPPicture* src,
+                                 int left, int top, int width, int height,
+                                 WebPPicture* dst);
+
+// Returns true if the 'picture' is actually a view and therefore does
+// not own the memory for pixels.
+WEBP_EXTERN(int) WebPPictureIsView(const WebPPicture* picture);
+
+// Rescale a picture to new dimension width x height.
+// Now gamma correction is applied.
+// Returns false in case of error (invalid parameter or insufficient memory).
+WEBP_EXTERN(int) WebPPictureRescale(WebPPicture* pic, int width, int height);
+
+// Colorspace conversion function to import RGB samples.
+// Previous buffer will be free'd, if any.
+// *rgb buffer should have a size of at least height * rgb_stride.
+// Returns false in case of memory error.
+WEBP_EXTERN(int) WebPPictureImportRGB(
+    WebPPicture* picture, const uint8_t* rgb, int rgb_stride);
+// Same, but for RGBA buffer.
+WEBP_EXTERN(int) WebPPictureImportRGBA(
+    WebPPicture* picture, const uint8_t* rgba, int rgba_stride);
+// Same, but for RGBA buffer. Imports the RGB direct from the 32-bit format
+// input buffer ignoring the alpha channel. Avoids needing to copy the data
+// to a temporary 24-bit RGB buffer to import the RGB only.
+WEBP_EXTERN(int) WebPPictureImportRGBX(
+    WebPPicture* picture, const uint8_t* rgbx, int rgbx_stride);
+
+// Variants of the above, but taking BGR(A|X) input.
+WEBP_EXTERN(int) WebPPictureImportBGR(
+    WebPPicture* picture, const uint8_t* bgr, int bgr_stride);
+WEBP_EXTERN(int) WebPPictureImportBGRA(
+    WebPPicture* picture, const uint8_t* bgra, int bgra_stride);
+WEBP_EXTERN(int) WebPPictureImportBGRX(
+    WebPPicture* picture, const uint8_t* bgrx, int bgrx_stride);
+
+// Converts picture->argb data to the YUVA format specified by 'colorspace'.
+// Upon return, picture->use_argb is set to false. The presence of real
+// non-opaque transparent values is detected, and 'colorspace' will be
+// adjusted accordingly. Note that this method is lossy.
+// Returns false in case of error.
+WEBP_EXTERN(int) WebPPictureARGBToYUVA(WebPPicture* picture,
+                                       WebPEncCSP colorspace);
+
+// Same as WebPPictureARGBToYUVA(), but the conversion is done using
+// pseudo-random dithering with a strength 'dithering' between
+// 0.0 (no dithering) and 1.0 (maximum dithering). This is useful
+// for photographic picture.
+WEBP_EXTERN(int) WebPPictureARGBToYUVADithered(
+    WebPPicture* picture, WebPEncCSP colorspace, float dithering);
+
+// Converts picture->yuv to picture->argb and sets picture->use_argb to true.
+// The input format must be YUV_420 or YUV_420A.
+// Note that the use of this method is discouraged if one has access to the
+// raw ARGB samples, since using YUV420 is comparatively lossy. Also, the
+// conversion from YUV420 to ARGB incurs a small loss too.
+// Returns false in case of error.
+WEBP_EXTERN(int) WebPPictureYUVAToARGB(WebPPicture* picture);
+
+// Helper function: given a width x height plane of RGBA or YUV(A) samples
+// clean-up the YUV or RGB samples under fully transparent area, to help
+// compressibility (no guarantee, though).
+WEBP_EXTERN(void) WebPCleanupTransparentArea(WebPPicture* picture);
+
+// Scan the picture 'picture' for the presence of non fully opaque alpha values.
+// Returns true in such case. Otherwise returns false (indicating that the
+// alpha plane can be ignored altogether e.g.).
+WEBP_EXTERN(int) WebPPictureHasTransparency(const WebPPicture* picture);
+
+// Remove the transparency information (if present) by blending the color with
+// the background color 'background_rgb' (specified as 24bit RGB triplet).
+// After this call, all alpha values are reset to 0xff.
+WEBP_EXTERN(void) WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb);
+
+//------------------------------------------------------------------------------
+// Main call
+
+// Main encoding call, after config and picture have been initialized.
+// 'picture' must be less than 16384x16384 in dimension (cf WEBP_MAX_DIMENSION),
+// and the 'config' object must be a valid one.
+// Returns false in case of error, true otherwise.
+// In case of error, picture->error_code is updated accordingly.
+// 'picture' can hold the source samples in both YUV(A) or ARGB input, depending
+// on the value of 'picture->use_argb'. It is highly recommended to use
+// the former for lossy encoding, and the latter for lossless encoding
+// (when config.lossless is true). Automatic conversion from one format to
+// another is provided but they both incur some loss.
+WEBP_EXTERN(int) WebPEncode(const WebPConfig* config, WebPPicture* picture);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_ENCODE_H_ */

WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/mux.h

@@ -0,0 +1,399 @@
+// Copyright 2011 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.
+// -----------------------------------------------------------------------------
+//
+//  RIFF container manipulation for WebP images.
+//
+// Authors: Urvang (urvang@google.com)
+//          Vikas (vikasa@google.com)
+
+// This API allows manipulation of WebP container images containing features
+// like color profile, metadata, animation and fragmented images.
+//
+// Code Example#1: Create 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 ICCP color 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);
+*/
+
+// Code Example#2: 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_data).
+  WebPMuxDelete(mux);
+  free(data);
+*/
+
+#ifndef WEBP_WEBP_MUX_H_
+#define WEBP_WEBP_MUX_H_
+
+#include "./mux_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_MUX_ABI_VERSION 0x0101        // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPMuxError WebPMuxError;
+// typedef enum WebPChunkId WebPChunkId;
+typedef struct WebPMux WebPMux;   // main opaque object.
+typedef struct WebPMuxFrameInfo WebPMuxFrameInfo;
+typedef struct WebPMuxAnimParams WebPMuxAnimParams;
+
+// Error codes
+typedef enum WebPMuxError {
+  WEBP_MUX_OK                 =  1,
+  WEBP_MUX_NOT_FOUND          =  0,
+  WEBP_MUX_INVALID_ARGUMENT   = -1,
+  WEBP_MUX_BAD_DATA           = -2,
+  WEBP_MUX_MEMORY_ERROR       = -3,
+  WEBP_MUX_NOT_ENOUGH_DATA    = -4
+} WebPMuxError;
+
+// IDs for different types of chunks.
+typedef enum WebPChunkId {
+  WEBP_CHUNK_VP8X,     // VP8X
+  WEBP_CHUNK_ICCP,     // ICCP
+  WEBP_CHUNK_ANIM,     // ANIM
+  WEBP_CHUNK_ANMF,     // ANMF
+  WEBP_CHUNK_FRGM,     // FRGM
+  WEBP_CHUNK_ALPHA,    // ALPH
+  WEBP_CHUNK_IMAGE,    // VP8/VP8L
+  WEBP_CHUNK_EXIF,     // EXIF
+  WEBP_CHUNK_XMP,      // XMP
+  WEBP_CHUNK_UNKNOWN,  // Other chunks.
+  WEBP_CHUNK_NIL
+} WebPChunkId;
+
+//------------------------------------------------------------------------------
+
+// Returns the version number of the mux library, packed in hexadecimal using
+// 8bits for each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN(int) WebPGetMuxVersion(void);
+
+//------------------------------------------------------------------------------
+// Life of a Mux object
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(WebPMux*) WebPNewInternal(int);
+
+// Creates an empty mux object.
+// Returns:
+//   A pointer to the newly created empty mux object.
+//   Or NULL in case of memory error.
+static WEBP_INLINE WebPMux* WebPMuxNew(void) {
+  return WebPNewInternal(WEBP_MUX_ABI_VERSION);
+}
+
+// Deletes the mux object.
+// Parameters:
+//   mux - (in/out) object to be deleted
+WEBP_EXTERN(void) WebPMuxDelete(WebPMux* mux);
+
+//------------------------------------------------------------------------------
+// Mux creation.
+
+// Internal, version-checked, entry point
+WEBP_EXTERN(WebPMux*) WebPMuxCreateInternal(const WebPData*, int, int);
+
+// Creates a mux object from raw data given in WebP RIFF format.
+// Parameters:
+//   bitstream - (in) the bitstream data in WebP RIFF format
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   A pointer to the mux object created from given data - on success.
+//   NULL - In case of invalid data or memory error.
+static WEBP_INLINE WebPMux* WebPMuxCreate(const WebPData* bitstream,
+                                          int copy_data) {
+  return WebPMuxCreateInternal(bitstream, copy_data, WEBP_MUX_ABI_VERSION);
+}
+
+//------------------------------------------------------------------------------
+// Non-image chunks.
+
+// Note: Only non-image related chunks should be managed through chunk APIs.
+// (Image related chunks are: "ANMF", "FRGM", "VP8 ", "VP8L" and "ALPH").
+// To add, get and delete images, use WebPMuxSetImage(), WebPMuxPushFrame(),
+// WebPMuxGetFrame() and WebPMuxDeleteFrame().
+
+// Adds a chunk with id 'fourcc' and data 'chunk_data' in the mux object.
+// Any existing chunk(s) with the same id will be removed.
+// Parameters:
+//   mux - (in/out) object to which the chunk is to be added
+//   fourcc - (in) a character array containing the fourcc of the given chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+//   chunk_data - (in) the chunk data to be added
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, fourcc or chunk_data is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetChunk(
+    WebPMux* mux, const char fourcc[4], const WebPData* chunk_data,
+    int copy_data);
+
+// Gets a reference to the data of the chunk with id 'fourcc' in the mux object.
+// The caller should NOT free the returned data.
+// Parameters:
+//   mux - (in) object from which the chunk data is to be fetched
+//   fourcc - (in) a character array containing the fourcc of the chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+//   chunk_data - (out) returned chunk data
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, fourcc or chunk_data is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_NOT_FOUND - If mux does not contain a chunk with the given id.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetChunk(
+    const WebPMux* mux, const char fourcc[4], WebPData* chunk_data);
+
+// Deletes the chunk with the given 'fourcc' from the mux object.
+// Parameters:
+//   mux - (in/out) object from which the chunk is to be deleted
+//   fourcc - (in) a character array containing the fourcc of the chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or fourcc is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_NOT_FOUND - If mux does not contain a chunk with the given fourcc.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxDeleteChunk(
+    WebPMux* mux, const char fourcc[4]);
+
+//------------------------------------------------------------------------------
+// Images.
+
+// Encapsulates data about a single frame/fragment.
+struct WebPMuxFrameInfo {
+  WebPData    bitstream;  // image data: can be a raw VP8/VP8L bitstream
+                          // or a single-image WebP file.
+  int         x_offset;   // x-offset of the frame.
+  int         y_offset;   // y-offset of the frame.
+  int         duration;   // duration of the frame (in milliseconds).
+
+  WebPChunkId id;         // frame type: should be one of WEBP_CHUNK_ANMF,
+                          // WEBP_CHUNK_FRGM or WEBP_CHUNK_IMAGE
+  WebPMuxAnimDispose dispose_method;  // Disposal method for the frame.
+  WebPMuxAnimBlend   blend_method;    // Blend operation for the frame.
+  uint32_t    pad[1];     // padding for later use
+};
+
+// Sets the (non-animated and non-fragmented) image in the mux object.
+// Note: Any existing images (including frames/fragments) will be removed.
+// Parameters:
+//   mux - (in/out) object in which the image is to be set
+//   bitstream - (in) can be a raw VP8/VP8L bitstream or a single-image
+//               WebP file (non-animated and non-fragmented)
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL or bitstream is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetImage(
+    WebPMux* mux, const WebPData* bitstream, int copy_data);
+
+// Adds a frame at the end of the mux object.
+// Notes: (1) frame.id should be one of WEBP_CHUNK_ANMF or WEBP_CHUNK_FRGM
+//        (2) For setting a non-animated non-fragmented image, use
+//            WebPMuxSetImage() instead.
+//        (3) Type of frame being pushed must be same as the frames in mux.
+//        (4) As WebP only supports even offsets, any odd offset will be snapped
+//            to an even location using: offset &= ~1
+// Parameters:
+//   mux - (in/out) object to which the frame is to be added
+//   frame - (in) frame data.
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or frame is NULL
+//                               or if content of 'frame' is invalid.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxPushFrame(
+    WebPMux* mux, const WebPMuxFrameInfo* frame, int copy_data);
+
+// Gets the nth frame from the mux object.
+// The content of 'frame->bitstream' is allocated using malloc(), and NOT
+// owned by the 'mux' object. It MUST be deallocated by the caller by calling
+// WebPDataClear().
+// nth=0 has a special meaning - last position.
+// Parameters:
+//   mux - (in) object from which the info is to be fetched
+//   nth - (in) index of the frame in the mux object
+//   frame - (out) data of the returned frame
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or frame is NULL.
+//   WEBP_MUX_NOT_FOUND - if there are less than nth frames in the mux object.
+//   WEBP_MUX_BAD_DATA - if nth frame chunk in mux is invalid.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetFrame(
+    const WebPMux* mux, uint32_t nth, WebPMuxFrameInfo* frame);
+
+// Deletes a frame from the mux object.
+// nth=0 has a special meaning - last position.
+// Parameters:
+//   mux - (in/out) object from which a frame is to be deleted
+//   nth - (in) The position from which the frame is to be deleted
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL.
+//   WEBP_MUX_NOT_FOUND - If there are less than nth frames in the mux object
+//                        before deletion.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);
+
+//------------------------------------------------------------------------------
+// Animation.
+
+// Animation parameters.
+struct WebPMuxAnimParams {
+  uint32_t bgcolor;  // Background color of the canvas stored (in MSB order) as:
+                     // Bits 00 to 07: Alpha.
+                     // Bits 08 to 15: Red.
+                     // Bits 16 to 23: Green.
+                     // Bits 24 to 31: Blue.
+  int loop_count;    // Number of times to repeat the animation [0 = infinite].
+};
+
+// Sets the animation parameters in the mux object. Any existing ANIM chunks
+// will be removed.
+// Parameters:
+//   mux - (in/out) object in which ANIM chunk is to be set/added
+//   params - (in) animation parameters.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or params is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetAnimationParams(
+    WebPMux* mux, const WebPMuxAnimParams* params);
+
+// Gets the animation parameters from the mux object.
+// Parameters:
+//   mux - (in) object from which the animation parameters to be fetched
+//   params - (out) animation parameters extracted from the ANIM chunk
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or params is NULL.
+//   WEBP_MUX_NOT_FOUND - if ANIM chunk is not present in mux object.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetAnimationParams(
+    const WebPMux* mux, WebPMuxAnimParams* params);
+
+//------------------------------------------------------------------------------
+// Misc Utilities.
+
+#if WEBP_MUX_ABI_VERSION > 0x0101
+// Sets the canvas size for the mux object. The width and height can be
+// specified explicitly or left as zero (0, 0).
+// * When width and height are specified explicitly, then this frame bound is
+//   enforced during subsequent calls to WebPMuxAssemble() and an error is
+//   reported if any animated frame does not completely fit within the canvas.
+// * When unspecified (0, 0), the constructed canvas will get the frame bounds
+//   from the bounding-box over all frames after calling WebPMuxAssemble().
+// Parameters:
+//   mux - (in) object to which the canvas size is to be set
+//   width - (in) canvas width
+//   height - (in) canvas height
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL; or
+//                               width or height are invalid or out of bounds
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxSetCanvasSize(WebPMux* mux,
+                                               int width, int height);
+#endif
+
+// Gets the canvas size from the mux object.
+// Note: This method assumes that the VP8X chunk, if present, is up-to-date.
+// That is, the mux object hasn't been modified since the last call to
+// WebPMuxAssemble() or WebPMuxCreate().
+// Parameters:
+//   mux - (in) object from which the canvas size is to be fetched
+//   width - (out) canvas width
+//   height - (out) canvas height
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, width or height is NULL.
+//   WEBP_MUX_BAD_DATA - if VP8X/VP8/VP8L chunk or canvas size is invalid.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetCanvasSize(const WebPMux* mux,
+                                               int* width, int* height);
+
+// Gets the feature flags from the mux object.
+// Note: This method assumes that the VP8X chunk, if present, is up-to-date.
+// That is, the mux object hasn't been modified since the last call to
+// WebPMuxAssemble() or WebPMuxCreate().
+// Parameters:
+//   mux - (in) object from which the features are to be fetched
+//   flags - (out) the flags specifying which features are present in the
+//           mux object. This will be an OR of various flag values.
+//           Enum 'WebPFeatureFlags' can be used to test individual flag values.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or flags is NULL.
+//   WEBP_MUX_BAD_DATA - if VP8X/VP8/VP8L chunk or canvas size is invalid.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxGetFeatures(const WebPMux* mux,
+                                             uint32_t* flags);
+
+// Gets number of chunks with the given 'id' in the mux object.
+// Parameters:
+//   mux - (in) object from which the info is to be fetched
+//   id - (in) chunk id specifying the type of chunk
+//   num_elements - (out) number of chunks with the given chunk id
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, or num_elements is NULL.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxNumChunks(const WebPMux* mux,
+                                           WebPChunkId id, int* num_elements);
+
+// Assembles all chunks in WebP RIFF format and returns in 'assembled_data'.
+// This function also validates the mux object.
+// Note: The content of 'assembled_data' will be ignored and overwritten.
+// Also, the content of 'assembled_data' is allocated using malloc(), and NOT
+// owned by the 'mux' object. It MUST be deallocated by the caller by calling
+// WebPDataClear(). It's always safe to call WebPDataClear() upon return,
+// even in case of error.
+// Parameters:
+//   mux - (in/out) object whose chunks are to be assembled
+//   assembled_data - (out) assembled WebP data
+// Returns:
+//   WEBP_MUX_BAD_DATA - if mux object is invalid.
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or assembled_data is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN(WebPMuxError) WebPMuxAssemble(WebPMux* mux,
+                                          WebPData* assembled_data);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_MUX_H_ */

WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/mux_types.h

@@ -0,0 +1,97 @@
+// Copyright 2012 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.
+// -----------------------------------------------------------------------------
+//
+// Data-types common to the mux and demux libraries.
+//
+// Author: Urvang (urvang@google.com)
+
+#ifndef WEBP_WEBP_MUX_TYPES_H_
+#define WEBP_WEBP_MUX_TYPES_H_
+
+#include <stdlib.h>  // free()
+#include <string.h>  // memset()
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPFeatureFlags WebPFeatureFlags;
+// typedef enum WebPMuxAnimDispose WebPMuxAnimDispose;
+// typedef enum WebPMuxAnimBlend WebPMuxAnimBlend;
+typedef struct WebPData WebPData;
+
+// VP8X Feature Flags.
+typedef enum WebPFeatureFlags {
+  FRAGMENTS_FLAG  = 0x00000001,
+  ANIMATION_FLAG  = 0x00000002,
+  XMP_FLAG        = 0x00000004,
+  EXIF_FLAG       = 0x00000008,
+  ALPHA_FLAG      = 0x00000010,
+  ICCP_FLAG       = 0x00000020
+} WebPFeatureFlags;
+
+// Dispose method (animation only). Indicates how the area used by the current
+// frame is to be treated before rendering the next frame on the canvas.
+typedef enum WebPMuxAnimDispose {
+  WEBP_MUX_DISPOSE_NONE,       // Do not dispose.
+  WEBP_MUX_DISPOSE_BACKGROUND  // Dispose to background color.
+} WebPMuxAnimDispose;
+
+// Blend operation (animation only). Indicates how transparent pixels of the
+// current frame are blended with those of the previous canvas.
+typedef enum WebPMuxAnimBlend {
+  WEBP_MUX_BLEND,              // Blend.
+  WEBP_MUX_NO_BLEND            // Do not blend.
+} WebPMuxAnimBlend;
+
+// Data type used to describe 'raw' data, e.g., chunk data
+// (ICC profile, metadata) and WebP compressed image data.
+struct WebPData {
+  const uint8_t* bytes;
+  size_t size;
+};
+
+// Initializes the contents of the 'webp_data' object with default values.
+static WEBP_INLINE void WebPDataInit(WebPData* webp_data) {
+  if (webp_data != NULL) {
+    memset(webp_data, 0, sizeof(*webp_data));
+  }
+}
+
+// Clears the contents of the 'webp_data' object by calling free(). Does not
+// deallocate the object itself.
+static WEBP_INLINE void WebPDataClear(WebPData* webp_data) {
+  if (webp_data != NULL) {
+    free((void*)webp_data->bytes);
+    WebPDataInit(webp_data);
+  }
+}
+
+// Allocates necessary storage for 'dst' and copies the contents of 'src'.
+// Returns true on success.
+static WEBP_INLINE int WebPDataCopy(const WebPData* src, WebPData* dst) {
+  if (src == NULL || dst == NULL) return 0;
+  WebPDataInit(dst);
+  if (src->bytes != NULL && src->size != 0) {
+    dst->bytes = (uint8_t*)malloc(src->size);
+    if (dst->bytes == NULL) return 0;
+    memcpy((void*)dst->bytes, src->bytes, src->size);
+    dst->size = src->size;
+  }
+  return 1;
+}
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  /* WEBP_WEBP_MUX_TYPES_H_ */

WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/types.h

@@ -0,0 +1,47 @@
+// Copyright 2010 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.
+// -----------------------------------------------------------------------------
+//
+//  Common types
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_TYPES_H_
+#define WEBP_WEBP_TYPES_H_
+
+#include <stddef.h>  // for size_t
+
+#ifndef _MSC_VER
+#include <inttypes.h>
+#ifdef __STRICT_ANSI__
+#define WEBP_INLINE
+#else  /* __STRICT_ANSI__ */
+#define WEBP_INLINE inline
+#endif
+#else
+typedef signed   char int8_t;
+typedef unsigned char uint8_t;
+typedef signed   short int16_t;
+typedef unsigned short uint16_t;
+typedef signed   int int32_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long int uint64_t;
+typedef long long int int64_t;
+#define WEBP_INLINE __forceinline
+#endif  /* _MSC_VER */
+
+#ifndef WEBP_EXTERN
+// This explicitly marks library functions and allows for changing the
+// signature for e.g., Windows DLL builds.
+#define WEBP_EXTERN(type) extern type
+#endif  /* WEBP_EXTERN */
+
+// Macro to check ABI compatibility (same major revision number)
+#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
+
+#endif  /* WEBP_WEBP_TYPES_H_ */

src/com/em/miguelbridge/botmatrix/MatrixBot.java

@@ -129,9 +129,9 @@ public class MatrixBot {
     }
 
     public synchronized String sendFile(String roomAddress, File file,
-            String nomeFile, boolean isImage) throws IOException, URISyntaxException, ParseException {
+            String nomeFile, String type) throws IOException, URISyntaxException, ParseException {
         String requestUrl;
-        if (isImage) {
+        if (type.equals("jpg")) {
             requestUrl = homeUrl + String.format("media/r0/upload?filename=%s&access_token=%s",
                     file.getName()+".jpg", accessToken);
         }
@@ -140,7 +140,7 @@ public class MatrixBot {
                     nomeFile, accessToken);
         }
         
-        String[] risposta = RequestHandler.postRequestFile(requestUrl, file, isImage);
+        String[] risposta = RequestHandler.postRequestFile(requestUrl, file, type);
 
         JSONObject uriFileObj = (JSONObject) new JSONParser().parse(risposta[1]);
         String uriFile = (String) uriFileObj.get("content_uri");
@@ -154,7 +154,7 @@ public class MatrixBot {
         requestUrl = homeUrl + String.format("client/r0/rooms/%s/send/m.room.message?access_token=%s",
                 roomAddress, accessToken);
 
-        if (isImage) {
+        if (type.equals("jpg")) {
             JSONObject reqParams = new JSONObject();
             JSONObject objInfo = new JSONObject();
             JSONObject thumb = new JSONObject();
@@ -185,6 +185,37 @@ public class MatrixBot {
             return risposta[0] + " - " + risposta[1];
         }
         
+        if (type.equals("png")) {
+            JSONObject reqParams = new JSONObject();
+            JSONObject objInfo = new JSONObject();
+            JSONObject thumb = new JSONObject();
+            BufferedImage bimg = ImageIO.read(file);
+            int width = bimg.getWidth();
+            int height = bimg.getHeight();
+
+            thumb.put("mimetype", "image/png");
+            thumb.put("h", height);
+            thumb.put("w", width);
+            thumb.put("size", file.length());
+
+            objInfo.put("mimetype", "image/png");
+            objInfo.put("size", file.length());
+            //objInfo.put("thumbnail_info", thumb);
+            //objInfo.put("thumbnail_url", uriFile);
+            objInfo.put("h", height);
+            objInfo.put("w", width);
+            //objInfo.put("orientation", 0);
+
+            reqParams.put("info", objInfo);
+            reqParams.put("msgtype", "m.image");
+            reqParams.put("body", file.getName());
+            reqParams.put("url", uriFile);
+
+            risposta = RequestHandler.postRequestJSON(requestUrl, reqParams);
+
+            return risposta[0] + " - " + risposta[1];
+        }
+        
         else {
             JSONObject reqParams = new JSONObject();
             JSONObject objInfo = new JSONObject();

src/com/em/miguelbridge/botmatrix/RequestHandler.java

@@ -69,11 +69,13 @@ public class RequestHandler {
         return risposta;
     }
 
-    public static String[] postRequestFile(String inUrl, File file, boolean isImage) throws IOException {
+    public static String[] postRequestFile(String inUrl, File file, String type) throws IOException {
         CloseableHttpClient httpClient = HttpClients.createDefault();
         HttpPost httpPost = new HttpPost(inUrl);
-        if (isImage)
+        if (type.equals("jpg"))
             httpPost.setHeader("Content-Type", "image/jpeg");
+        else if (type.equals("png"))
+            httpPost.setHeader("Content-Type", "image/png");
         else
             httpPost.setHeader("Content-Type", "text/plain");
 

src/com/em/miguelbridge/telegrambot/TGBot.java

@@ -17,6 +17,7 @@ import org.telegram.telegrambots.api.methods.send.*;
 import org.telegram.telegrambots.api.objects.Document;
 import org.telegram.telegrambots.api.objects.PhotoSize;
 import org.telegram.telegrambots.api.objects.Update;
+import org.telegram.telegrambots.api.objects.stickers.Sticker;
 import org.telegram.telegrambots.bots.TelegramLongPollingBot;
 import org.telegram.telegrambots.exceptions.TelegramApiException;
 
@@ -55,9 +56,15 @@ public class TGBot extends TelegramLongPollingBot {
                 //Testo e mittente
                 String testoMessaggio = update.getMessage().getText();
                 String chat_id = "" + update.getMessage().getChatId();
-                String sender = update.getMessage().getFrom().getFirstName() + " "
-                        + update.getMessage().getFrom().getLastName();
+                String sender;
                 String destination;
+                
+                if (update.getMessage().getFrom().getLastName() != null)
+                    sender = update.getMessage().getFrom().getFirstName() + " "
+                        + update.getMessage().getFrom().getLastName();
+                else
+                    sender = update.getMessage().getFrom().getFirstName();
+                
                 try {
                     destination = getDestinationRoom(chat_id);
                     if (destination == null)
@@ -69,6 +76,7 @@ public class TGBot extends TelegramLongPollingBot {
             }
         }
 
+        //Photo
         else if (update.hasMessage() && update.getMessage().hasPhoto()) {
             String chat_id = "" + update.getMessage().getChatId();
             String sender;
@@ -113,13 +121,14 @@ public class TGBot extends TelegramLongPollingBot {
                 if (destination == null)
                     throw new Exception();
                 matrixBot.sendMessage(sender + " ha inviato una foto:", destination);
-                matrixBot.sendFile(destination, downloadedFile, null, true);
+                matrixBot.sendFile(destination, downloadedFile, null, "jpg");
             } catch (Exception ex) {
                 cEcho(chat_id, "Errore: questa chat non è collegata a matrix.");
                 ex.printStackTrace(System.err);
             }
         }
         
+        //Generic file
         else if (update.hasMessage() && update.getMessage().hasDocument()) {
             String chat_id = "" + update.getMessage().getChatId();
             String sender;
@@ -157,12 +166,70 @@ public class TGBot extends TelegramLongPollingBot {
                 if (destination == null)
                     throw new Exception();
                 matrixBot.sendMessage(sender + " ha inviato un file:", destination);
-                matrixBot.sendFile(destination, downloadedFile, nomeFile, false);
+                matrixBot.sendFile(destination, downloadedFile, nomeFile, "file");
             } catch (Exception ex) {
                 cEcho(chat_id, "Errore: questa chat non è collegata a matrix.");
                 ex.printStackTrace(System.err);
             }
         }
+        
+        //Sticker
+        else if (update.hasMessage()) {
+            String chat_id = "" + update.getMessage().getChatId();
+            String sender = null;
+            String destination;
+            String nomeFile = "sticker.png";
+            Sticker sticker = null;
+            File convertedImage = null;
+            
+            java.io.File downloadedFile = null;
+            
+            try {
+                if (update.getMessage().getFrom().getLastName() != null)
+                    sender = update.getMessage().getFrom().getFirstName() + " "
+                            + update.getMessage().getFrom().getLastName();
+                else
+                    sender = update.getMessage().getFrom().getFirstName();
+
+                sticker = update.getMessage().getSticker();
+                String filePath;
+
+                // We create a GetFile method and set the file_id from the photo
+                GetFile getFileMethod = new GetFile();
+                getFileMethod.setFileId(sticker.getFileId());
+                
+                // We execute the method using AbsSender::execute method.
+                final org.telegram.telegrambots.api.objects.File file = execute(getFileMethod);
+                // We now have the file_path
+                filePath = file.getFilePath();
+                // Download the file calling AbsSender::downloadFile method
+                downloadedFile = downloadFile(filePath);
+                
+                if (WebPConverter.convert(downloadedFile.getAbsolutePath(), nomeFile) == 0) {
+                    System.out.println("Done converting");
+                    convertedImage = new File(nomeFile);
+                }
+                else
+                    throw new Exception();
+                //System.out.println("Ho scaricato lo sticker");
+            }
+            catch (Exception ex) {
+                ex.printStackTrace(System.err);
+            }
+
+            try {
+                destination = getDestinationRoom(chat_id);
+                if (destination == null)
+                    throw new Exception();
+                matrixBot.sendMessage(sender + " ha inviato uno sticker " + sticker.getEmoji() + ":", destination);
+                matrixBot.sendFile(destination, convertedImage, nomeFile, "png");
+                convertedImage.delete();
+            } catch (Exception ex) {
+                cEcho(chat_id, "Errore: questa chat non è collegata a matrix.");
+                ex.printStackTrace(System.err);
+                convertedImage.delete();
+            }
+        }
     }
 
     @Override

src/com/em/miguelbridge/telegrambot/WebPConverter.java

@@ -0,0 +1,22 @@
+package com.em.miguelbridge.telegrambot;
+
+import java.io.IOException;
+
+public class WebPConverter {
+    public static int convert(String iPath, String oPath) {
+        //the "dwebp"'s path
+        String binPath = "WebPConverter/libwebp-0.4.1-linux-x86-64/bin/dwebp";
+        
+        String[] args = new String[]{binPath, iPath, "-o", oPath};
+
+        try {
+            Runtime.getRuntime().exec(args);
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace(System.err);
+            return 1;
+        }
+        
+        return 0;
+    }
+}

test/test/WebPTest.java

@@ -0,0 +1,15 @@
+package test;
+
+import com.em.miguelbridge.telegrambot.WebPConverter;
+
+public class WebPTest {
+    public static void main(String args[]) {
+        String iFile = "sticker.webp";
+        String oFile = "sticker.png";
+        
+        if (WebPConverter.convert(iFile, oFile) == 0)
+            System.out.println("Done");
+        else
+            System.err.println("Error");
+    }
+}