Build Unix usando makefile.unix:

Su piattaforme con strumenti GNU installati (gcc e make), eseguendo

make -f makefile.unix

verranno compilati i binari examples/cwebp e examples/dwebp, insieme alla libreria statica src/libwebp.a. Non viene fornita un'installazione a livello di sistema, poiché questa è una semplice alternativa al sistema di installazione completo basato sugli strumenti autoconf (vedi sotto). Si prega di fare riferimento a makefile.unix per ulteriori dettagli e personalizzazioni.

Utilizzo degli strumenti autoconf:

Prerequisiti: Un compilatore (es. gcc), make, autoconf, automake, libtool. Su un sistema Debian-like, quanto segue dovrebbe installare tutto il necessario per una compilazione minima: $ sudo apt-get install gcc make autoconf automake libtool

Quando si compila da sorgenti git, sarà necessario eseguire autogen.sh per generare lo script configure.

./configure make make install

dovrebbe essere tutto ciò che serve per avere i seguenti file

/usr/local/include/webp/decode.h /usr/local/include/webp/encode.h /usr/local/include/webp/types.h /usr/local/lib/libwebp.* /usr/local/bin/cwebp /usr/local/bin/dwebp

installati.

Nota: È disponibile una libreria solo per decodifica, libwebpdecoder, utilizzando il flag '--enable-libwebpdecoder'. La libreria di codifica viene compilata separatamente e può essere installata indipendentemente con una piccola modifica nei corrispondenti file Makefile.am configure (vedi commenti lì). Vedi './configure --help' per ulteriori opzioni.

Compilazione per MIPS Linux:

I rilasci stabili di toolchain MIPS Linux sono disponibili su: https://community.imgtec.com/developers/mips/tools/codescape-mips-sdk/available-releases/

Aggiungi toolchain al PATH

export PATH=$PATH:/path/to/toolchain/bin

Build 32-bit per mips32r5 (p5600)

HOST=mips-mti-linux-gnu MIPS_CFLAGS="-O3 -mips32r5 -mabi=32 -mtune=p5600 -mmsa -mfp64
-msched-weight -mload-store-pairs -fPIE" MIPS_LDFLAGS="-mips32r5 -mabi=32 -mmsa -mfp64 -pie"

Build 64-bit per mips64r6 (i6400)

HOST=mips-img-linux-gnu MIPS_CFLAGS="-O3 -mips64r6 -mabi=64 -mtune=i6400 -mmsa -mfp64
-msched-weight -mload-store-pairs -fPIE" MIPS_LDFLAGS="-mips64r6 -mabi=64 -mmsa -mfp64 -pie"

./configure --host=${HOST} --build=config.guess
CC="${HOST}-gcc -EL"
CFLAGS="$MIPS_CFLAGS"
LDFLAGS="$MIPS_LDFLAGS" make make install

CMake:

Con CMake puoi compilare libwebp, cwebp, dwebp, gif2web, img2webp, webpinfo e i binding JS.

Prerequisiti: Un compilatore (es. gcc con autotools) e CMake. Su un sistema Debian-like, quanto segue dovrebbe installare tutto il necessario per una compilazione minima: $ sudo apt-get install build-essential cmake

Quando si compila da sorgenti git, sarà necessario eseguire cmake per generare i makefile.

mkdir build && cd build && cmake ../ make make install

Se desideri anche uno qualsiasi degli eseguibili, dovrai abilitarli tramite CMake, ad es.:

cmake -DWEBP_BUILD_CWEBP=ON -DWEBP_BUILD_DWEBP=ON ../

o tramite la tua interfaccia preferita (come ccmake o cmake-qt-gui).

Usa l'opzione -DWEBP_UNICODE=ON per il supporto Unicode su Windows (con chcp 65001).

Infine, una volta installato, puoi anche utilizzare WebP nel tuo progetto CMake facendo:

find_package(WebP)

che definirà le variabili CMake WebP_INCLUDE_DIRS e WebP_LIBRARIES.

Gradle:

Il supporto per Gradle è minimale: ti aiuta solo a compilare libwebp, cwebp, dwebp e webpmux_example.

Prerequisiti: Un compilatore (es. gcc con autotools) e gradle. Su un sistema Debian-like, quanto segue dovrebbe installare tutto il necessario per una compilazione minima: $ sudo apt-get install build-essential gradle

Quando si compila da sorgenti git, sarà necessario eseguire il wrapper Gradle con il target appropriato, ad es. :

./gradlew buildAllExecutables

Binding SWIG:

Per generare i binding linguistici da swig/libwebp.swig è necessario almeno swig-1.3 (http://www.swig.org).

Attualmente sono mappate le seguenti funzioni: Decodifica: WebPGetDecoderVersion WebPGetInfo WebPDecodeRGBA WebPDecodeARGB WebPDecodeBGRA WebPDecodeBGR WebPDecodeRGB

Codifica: WebPGetEncoderVersion WebPEncodeRGBA WebPEncodeBGRA WebPEncodeRGB WebPEncodeBGR WebPEncodeLosslessRGBA WebPEncodeLosslessBGRA WebPEncodeLosslessRGB WebPEncodeLosslessBGR

Vedi swig/README per istruzioni di compilazione più dettagliate.

Binding Java:

Per compilare il codice wrapper JNI generato da swig è necessario almeno JDK-1.5 (o equivalente) per il supporto enum. L'output è pensato per essere un oggetto condiviso / DLL che può essere caricato tramite System.loadLibrary("webp_jni").

Binding Python:

Per compilare il codice di estensione Python generato da swig è necessario almeno Python 2.6. Python < 2.6 potrebbe essere compilato con piccole modifiche a libwebp.swig o al codice generato, ma non è stato testato.

Strumento di codifica:

La directory examples/ contiene strumenti per la codifica (cwebp) e decodifica (dwebp) di immagini.

L'uso più semplice dovrebbe essere: cwebp input.png -q 80 -o output.webp che convertirà il file di input in un file WebP utilizzando un fattore di qualità di 80 su una scala da 0 a 100 (0 è la qualità più bassa, 100 è la migliore. Il valore predefinito è 75). Potresti voler provare anche il flag -lossless, che comprimerà la sorgente (in formato RGBA) senza alcuna perdita. Il parametro di qualità -q in questo caso controllerà la quantità di tempo di elaborazione speso per cercare di rendere il file di output il più piccolo possibile.

Un elenco più lungo di opzioni è disponibile utilizzando il flag da riga di comando -longhelp:

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 ............. quality factor (0:small..100:big), default=75 -alpha_q ......... transparency-compression quality (0..100), default=100 -preset ....... preset setting, one of: default, photo, picture, drawing, icon, text -preset must come first, as it overwrites other parameters -z ............... activates lossless preset with given level in [0:fast, ..., 9:slowest]

-m ............... compression method (0=fast, 6=slowest), default=4 -segments ........ number of segments to use (1..4), default=4 -size ............ target size (in bytes) -psnr .......... target PSNR (in dB. typically: 42)

-s ......... input size (width x height) for YUV -sns ............. spatial noise shaping (0:off, 100:max), default=50 -f ............... filter strength (0=off..100), default=60 -sharpness ....... filter sharpness (0:most .. 7:least sharp), default=0 -strong ................ use strong filter instead of simple (default) -nostrong .............. use simple filter instead of strong -sharp_yuv ............. use sharper (and slower) RGB->YUV conversion -partition_limit . limit quality to fit the 512k limit on the first partition (0=no degradation ... 100=full) -pass ............ analysis pass number (1..10) -crop .. crop picture with the given rectangle -resize ........ resize picture (after any cropping) -mt .................... use multi-threading if available -low_memory ............ reduce memory usage (slower encoding) -map ............. 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 .... transparency-compression method (0..1), default=1 -alpha_filter . predictive filtering for alpha plane, one of: none, fast (default) or best -exact ................. preserve RGB values in transparent area, default=off -blend_alpha ..... blend colors against background color expressed as RGB values written in hexadecimal, e.g. 0xc0e0d0 for red=0xc0 green=0xe0 and blue=0xd0 -noalpha ............... discard any transparency information -lossless .............. encode image losslessly, default=off -near_lossless ... use near-lossless image preprocessing (0..100=off), default=100 -hint ......... specify image characteristics hint, one of: photo, picture or graph

-metadata ..... 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 ............. 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.

Strumento di decodifica:

C'è un esempio di decodifica in examples/dwebp.c che prenderà un file .webp e lo decodificherà in un file immagine PNG (tra gli altri formati). Questo serve semplicemente a dimostrare l'uso dell'API. Puoi verificare che il file test.webp venga decodificato esattamente come test_ref.ppm usando:

cd examples ./dwebp test.webp -ppm -o test.ppm diff test.ppm test_ref.ppm

L'elenco completo delle opzioni è disponibile usando -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 .. dithering strength (in 0..100) -alpha_dither use alpha-plane dithering if needed -mt .......... use multi-threading -crop ... crop output with the given rectangle -resize ......... scale the output (after any cropping) -flip ........ flip the output vertically -alpha ....... only save the alpha plane -incremental . use incremental decoding (useful for tests) -h ........... this help message -v ........... verbose (e.g. print encoding/decoding times) -quiet ....... quiet mode, don't print anything -noasm ....... disable all assembly optimizations

Strumento di analisi dei file WebP:

'webpinfo' può essere utilizzato per stampare la struttura a livello di chunk e le informazioni dell'intestazione del bitstream dei file WebP. Può anche verificare se i file sono in formato WebP valido.

Usage: webpinfo [options] in_files Note: there could be multiple input files; options must come before input files. Options: -version ........... Print version number and exit. -quiet ............. Do not show chunk parsing information. -diag .............. Show parsing error diagnosis. -summary ........... Show chunk stats summary. -bitstream_info .... Parse bitstream header.

Strumento di visualizzazione:

C'è un piccolo strumento di visualizzazione autonomo chiamato 'vwebp' nella directory examples/. Utilizza OpenGL per aprire una semplice finestra di disegno e mostrare un file WebP decodificato. Non è ancora integrato nel sistema di build automake, ma puoi provare a compilarlo manualmente utilizzando le raccomandazioni seguenti.

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 dithering strength (0..100), default=50 -noalphadither disable alpha plane dithering -usebgcolor .. display background color -mt .......... use multi-threading -info ........ print info -h ........... this help message

Keyboard shortcuts: 'c' ................ toggle use of color profile 'b' ................ toggle background color display 'i' ................ overlay file information 'd' ................ disable blending & disposal (debug) 'q' / 'Q' / ESC .... quit

Compilazione:

Prerequisiti:

1. OpenGL & OpenGL Utility Toolkit (GLUT) Linux: $ sudo apt-get install freeglut3-dev mesa-common-dev Mac + XCode:

   • These libraries should be available in the OpenGL / GLUT frameworks. Windows: http://freeglut.sourceforge.net/index.php#download

2. (Opzionale) qcms (Quick Color Management System) i. Scarica qcms da Mozilla / Chromium: http://hg.mozilla.org/mozilla-central/file/0e7639e3bdfb/gfx/qcms http://src.chromium.org/viewvc/chrome/trunk/src/third_party/qcms ii. Compila e archivia i file sorgente come libqcms.a / qcms.lib iii. Aggiorna makefile.unix / Makefile.vc a) Definisci WEBP_HAVE_QCMS b) Aggiorna i percorsi di include / libreria per fare riferimento alla directory qcms.

Compila usando makefile.unix / Makefile.vc: $ make -f makefile.unix examples/vwebp

nmake /f Makefile.vc CFG=release-static
../obj/x64/release-static/bin/vwebp.exe

Strumento per la creazione di animazioni:

L'utilità 'img2webp' può trasformare una sequenza di immagini di input (PNG, JPEG, ...) in un file WebP animato. Offre un controllo preciso sulla durata, le modalità di codifica, ecc.

Utilizzo:

img2webp [file-level options] [image files...] [per-frame options...]

File-level options (only used at the start of compression): -min_size ............ minimize size -loop .......... loop count (default: 0, = infinite loop) -kmax .......... maximum number of frame between key-frames (0=only keyframes) -kmin .......... minimum number of frame between key-frames (0=disable key-frames altogether) -mixed ............... use mixed lossy/lossless automatic mode -v ................... verbose mode -h ................... this help -version ............. print version number and exit

Per-frame options (only used for subsequent images input): -d ............. frame duration in ms (default: 100) -lossless ........... use lossless mode (default) -lossy ... ........... use lossy mode -q ........... quality -m ............. method to use

example: img2webp -loop 2 in0.png -lossy in1.jpg -d 80 in2.tiff -o out.webp

Nota: se viene passato un singolo nome file come argomento, gli argomenti verranno tokenizzati da questo file. Il nome del file non deve iniziare con il carattere '-'.

Conversione di GIF animate:

I file GIF animati possono essere convertiti in file WebP con animazione utilizzando l'utilità gif2webp disponibile in examples/. I file possono quindi essere visualizzati usando vwebp.

Utilizzo: 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 ............. quality factor (0:small..100:big) -m ............... compression method (0=fast, 6=slowest) -min_size .............. minimize output size (default:off) lossless compression by default; can be combined with -q, -m, -lossy or -mixed options -kmin ............ min distance between key frames -kmax ............ max distance between key frames -f ............... filter strength (0=off..100) -metadata ..... comma separated list of metadata to copy from the input to the output if present Valid values: all, none, icc, xmp (default) -loop_compatibility .... use compatibility mode for Chrome version prior to M62 (inclusive) -mt .................... use multi-threading if available

-version ............... print version number and exit -v ..................... verbose -quiet ................. don't print anything

Compilazione:

Con i file di sviluppo libgif installati, gif2webp può essere compilato usando makefile.unix: $ make -f makefile.unix examples/gif2webp

o usando autoconf: $ ./configure --enable-everything $ make

Confronto di immagini animate:

L'utilità di test anim_diff sotto examples/ può essere utilizzata per confrontare due immagini animate (ciascuna può essere GIF o WebP).Utilizzo: anim_diff [options]

Opzioni: -dump_frames scarica i frame decodificati in formato PAM -min_psnr ... PSNR minimo per fotogramma -raw_comparison ..... se questo flag non viene utilizzato, l'RGB viene premoltiplicato prima del confronto -max_diff ..... differenza massima consentita per canale tra pixel corrispondenti in fotogrammi successivi -h .................. questo aiuto -version ............ stampa il numero di versione ed esce

Compilazione:

Con i file di sviluppo di libgif e un compilatore C++ installati, anim_diff può essere compilato usando makefile.unix: $ make -f makefile.unix examples/anim_diff

oppure usando autoconf: $ ./configure --enable-everything $ make

API di codifica:

Le principali funzioni di codifica sono disponibili nell'header src/webp/encode.h Quelle pronte all'uso sono: 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);

Convertiranno campioni RGB grezzi in dati WebP. L'unico controllo fornito è il fattore di qualità.

Esistono alcune varianti per l'uso del formato lossless:

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

Naturalmente in questo caso non è necessario alcun fattore di qualità poiché la compressione avviene senza perdita dei valori di input, a scapito di dimensioni di output maggiori.

API di codifica avanzata:

Un'API più avanzata si basa sulle strutture WebPConfig e WebPPicture.

WebPConfig contiene le impostazioni di codifica e non è legato a una particolare immagine. WebPPicture contiene i dati di input, su cui verrà utilizzato un WebPConfig per la compressione. Il flusso di codifica è il seguente:

-------------------------------------- BEGIN PSEUDO EXAMPLE

#include <webp/encode.h>

// Imposta una configurazione, partendo da un preset e regolando alcuni // parametri aggiuntivi WebPConfig config; if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor)) return 0; // errore di versione } // ... regolazioni aggiuntive config.sns_strength = 90; config.filter_sharpness = 6; config_error = WebPValidateConfig(&config); // non obbligatorio, ma utile

// Imposta i dati di input WebPPicture pic; if (!WebPPictureInit(&pic)) { return 0; // errore di versione } pic.width = width; pic.height = height; // immagine allocata di dimensioni larghezza x altezza if (!WebPPictureAllocate(&pic)) { return 0; // errore di memoria } // a questo punto, 'pic' è stato inizializzato come contenitore, // e può ricevere i campioni Y/U/V. // In alternativa, si potrebbero usare funzioni di import già pronte come // WebPPictureImportRGB(), che si occuperà dell'allocazione della memoria. // In ogni caso, dopo questo punto, si dovrà chiamare // WebPPictureFree(&pic) per recuperare la memoria.

// Imposta un metodo di scrittura di output in byte. WebPMemoryWriter, ad esempio. WebPMemoryWriter wrt; WebPMemoryWriterInit(&wrt); // inizializza 'wrt'

pic.writer = MyFileWriter; pic.custom_ptr = my_opaque_structure_to_make_MyFileWriter_work;

// Comprimi! int ok = WebPEncode(&config, &pic); // ok = 0 => errore! WebPPictureFree(&pic); // deve essere chiamato indipendentemente dal risultato di 'ok'.

// i dati di output dovrebbero essere stati gestiti dal writer a questo punto. // -> i dati compressi sono il buffer di memoria descritto da wrt.mem / wrt.size

// dealloca la memoria usata dai dati compressi WebPMemoryWriterClear(&wrt);

-------------------------------------- END PSEUDO EXAMPLE

API di decodifica:

Questa è principalmente una sola funzione da chiamare:

#include "webp/decode.h" uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size, int* width, int* height);

Si prega di dare un'occhiata al file src/webp/decode.h per i dettagli. Esistono varianti per la decodifica in ordine BGR/RGBA/ARGB/BGRA, insieme alla decodifica in campioni Y'CbCr grezzi. Si può anche decodificare l'immagine direttamente in un buffer pre-allocato.

Per rilevare un file WebP e ottenere le dimensioni dell'immagine, la funzione: int WebPGetInfo(const uint8_t* data, size_t data_size, int* width, int* height); è fornita. Non è coinvolta alcuna decodifica quando la si utilizza.

API di decodifica incrementale:

Nel caso in cui i dati vengano trasmessi progressivamente, le immagini possono ancora essere decodificate in modo incrementale utilizzando un'API leggermente più complicata. Lo stato del decodificatore viene archiviato in un'istanza dell'oggetto WebPIDecoder. Questo oggetto può essere creato con lo scopo di decodificare campioni RGB o Y'CbCr. Ad esempio:

WebPDecBuffer buffer; WebPInitDecBuffer(&buffer); buffer.colorspace = MODE_BGR; ... WebPIDecoder* idec = WebPINewDecoder(&buffer);

Man mano che i dati diventano progressivamente disponibili, questo oggetto decodificatore incrementale può essere utilizzato per decodificare ulteriormente l'immagine. Esistono due modi (mutuamente esclusivi) per passare i dati appena arrivati:

sia aggiungendo i nuovi byte:

WebPIAppend(idec, fresh_data, size_of_fresh_data);

oppure semplicemente menzionando la nuova dimensione dei dati trasmessi:

WebPIUpdate(idec, buffer, size_of_transmitted_buffer);

Nota che 'buffer' può essere modificato tra ogni chiamata a WebPIUpdate, in particolare quando il buffer viene ridimensionato per contenere dati più grandi.

Queste funzioni restituiranno lo stato di decodifica: VP8_STATUS_SUSPENDED se la decodifica non è ancora terminata o VP8_STATUS_OK quando la decodifica è terminata. Qualsiasi altro stato è una condizione di errore.

L'oggetto 'idec' deve essere sempre rilasciato (anche in caso di errore) chiamando: WebPDelete(idec).

Per recuperare campioni di immagine parzialmente decodificati, è necessario utilizzare il metodo corrispondente: WebPIDecGetRGB o WebPIDecGetYUVA. Restituirà l'ultima riga di pixel visualizzabile.

Infine, nota che la decodifica può anche essere eseguita in un buffer di pixel pre-allocato. Questo buffer deve essere passato quando si crea un WebPIDecoder, chiamando WebPINewRGB() o WebPINewYUVA().

Si prega di consultare l'header src/webp/decode.h per ulteriori dettagli.

API di decodifica avanzata:

La decodifica WebP supporta un'API avanzata che fornisce ritaglio e ridimensionamento al volo, qualcosa di grande utilità in ambienti con memoria limitata come i telefoni cellulari. Fondamentalmente, l'utilizzo della memoria si ridimensionerà in base alla dimensione dell'output, non dell'input, quando si ha bisogno solo di un'anteprima rapida o di una porzione ingrandita di un'immagine altrimenti troppo grande. Si può risparmiare anche della CPU, incidentalmente.

-------------------------------------- BEGIN PSEUDO EXAMPLE // A) Inizializza un oggetto di configurazione WebPDecoderConfig config; CHECK(WebPInitDecoderConfig(&config));

-------------------------------------- END PSEUDO EXAMPLE

Bug:

Segnala tutti i bug al tracker dei problemi: https://bugs.chromium.org/p/webp I contributi sono benvenuti! Vedi questa pagina per iniziare: http://www.webmproject.org/code/contribute/submitting-patches/

Discussione:

Email: [email protected] Web: http://groups.google.com/a/webmproject.org/group/webp-discuss