emagon/MiguelBridge
1
1
Fork 0
mirror of https://github.com/ahabhyde/miguelbridge synced 2025-01-10 06:24:20 +01:00
Code Releases Activity

Support for sticker, bugfix

Browse Source 
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
This commit is contained in:
Ahab Hyde 2018-05-24 12:41:45 +02:00
parent e544ddebd7
commit c835732151
58 changed files with 10161 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

482
WebPConverter/libwebp-0.4.1-linux-x86-64/README Normal file
View File

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

186
WebPConverter/libwebp-0.4.1-linux-x86-64/README.mux Normal file
View File

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

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/bin/cwebp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/bin/dwebp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/bin/gif2webp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/bin/vwebp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/bin/webpmux Executable file
View File

Binary file not shown.

564
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/cwebp.html Normal file
View File

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

284
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/cwebp.txt Normal file
View File

@ -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)

337
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/dwebp.html Normal file
View File

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

127
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/dwebp.txt Normal file
View File

@ -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)

299
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/gif2webp.html Normal file
View File

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

132
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/gif2webp.txt Normal file
View File

@ -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)

250
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/vwebp.html Normal file
View File

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

88
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/vwebp.txt Normal file
View File

@ -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)

337
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/webpmux.html Normal file
View File

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

141
WebPConverter/libwebp-0.4.1-linux-x86-64/doc/webpmux.txt Normal file
View File

@ -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)

499
WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/decode.h Normal file
View File

@ -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_ */

224
WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/demux.h Normal file
View File

@ -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_ */

508
WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/encode.h Normal file
View File

@ -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_ */

399
WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/mux.h Normal file
View File

@ -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_ */

97
WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/mux_types.h Normal file
View File

@ -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_ */

47
WebPConverter/libwebp-0.4.1-linux-x86-64/include/webp/types.h Normal file
View File

@ -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_ */

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/lib/libwebp.a Normal file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/lib/libwebpdemux.a Normal file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-linux-x86-64/lib/libwebpmux.a Normal file
View File

Binary file not shown.

482
WebPConverter/libwebp-0.4.1-mac-10.8/README Normal file
View File

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

186
WebPConverter/libwebp-0.4.1-mac-10.8/README.mux Normal file
View File

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

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/bin/cwebp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/bin/dwebp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/bin/gif2webp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/bin/vwebp Executable file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/bin/webpmux Executable file
View File

Binary file not shown.

567
WebPConverter/libwebp-0.4.1-mac-10.8/doc/cwebp.html Normal file
View File

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

284
WebPConverter/libwebp-0.4.1-mac-10.8/doc/cwebp.txt Normal file
View File

@ -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)

346
WebPConverter/libwebp-0.4.1-mac-10.8/doc/dwebp.html Normal file
View File

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

127
WebPConverter/libwebp-0.4.1-mac-10.8/doc/dwebp.txt Normal file
View File

@ -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)

303
WebPConverter/libwebp-0.4.1-mac-10.8/doc/gif2webp.html Normal file
View File

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

132
WebPConverter/libwebp-0.4.1-mac-10.8/doc/gif2webp.txt Normal file
View File

@ -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)

251
WebPConverter/libwebp-0.4.1-mac-10.8/doc/vwebp.html Normal file
View File

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

88
WebPConverter/libwebp-0.4.1-mac-10.8/doc/vwebp.txt Normal file
View File

@ -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)

332
WebPConverter/libwebp-0.4.1-mac-10.8/doc/webpmux.html Normal file
View File

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

141
WebPConverter/libwebp-0.4.1-mac-10.8/doc/webpmux.txt Normal file
View File

@ -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)

499
WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/decode.h Normal file
View File

@ -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_ */

224
WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/demux.h Normal file
View File

@ -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_ */

508
WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/encode.h Normal file
View File

@ -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_ */

399
WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/mux.h Normal file
View File

@ -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_ */

97
WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/mux_types.h Normal file
View File

@ -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_ */

47
WebPConverter/libwebp-0.4.1-mac-10.8/include/webp/types.h Normal file
View File

@ -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_ */

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/lib/libwebp.a Normal file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/lib/libwebpdemux.a Normal file
View File

Binary file not shown.

BIN
WebPConverter/libwebp-0.4.1-mac-10.8/lib/libwebpmux.a Normal file
View File

Binary file not shown.

39
src/com/em/miguelbridge/botmatrix/MatrixBot.java
View File

@ -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();

6
src/com/em/miguelbridge/botmatrix/RequestHandler.java
View File

@ -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");

75
src/com/em/miguelbridge/telegrambot/TGBot.java
View File

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

22
src/com/em/miguelbridge/telegrambot/WebPConverter.java Normal file
View File

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

BIN
sticker.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

15
test/test/WebPTest.java Normal file
View File

@ -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");
}
}