pazhanivelmani/webp_android10_r33_cve-2023-1999
/ \\/ \/ _ \/ _ )/ _ \
\ / __/ _ \ __/
\__\__/\____/\_____/__/ ____ ___
/ _/ / \ \ / _ \/ _/
/ \_/ / / \ \ __/ \__
\____/____/\_____/_____/____/v1.0.2
WebP-Codec: Bibliothek zum Kodieren und Dekodieren von Bildern im WebP-Format. Dieses Paket enthält die Bibliothek, die in anderen Programmen verwendet werden kann, um WebP-Unterstützung hinzuzufügen, sowie die Befehlszeilenwerkzeuge 'cwebp' und 'dwebp'.
Siehe http://developers.google.com/speed/webp
Der neueste Quellbaum ist verfügbar unter https://chromium.googlesource.com/webm/libwebp
Es wird unter derselben Lizenz wie das WebM-Projekt veröffentlicht. Einzelheiten finden Sie unter http://www.webmproject.org/license/software/ oder in der Datei „COPYING“. Eine zusätzliche Gewährung geistiger Eigentumsrechte finden Sie in der Datei PATENTS.
Durch Ausführen von:
nmake /f Makefile.vc CFG=release-static RTLIBCFG=static OBJDIR=output
enthält das Verzeichnis output\release-static(x64|x86)\bin die Werkzeuge cwebp.exe und dwebp.exe. Das Verzeichnis output\release-static(x64|x86)\lib enthält die statische Bibliothek libwebp. Die Zielarchitektur (x86/x64) wird von Makefile.vc anhand des im Systempfad verfügbaren Visual-Studio-Compilers (cl.exe) erkannt.
Auf Plattformen mit installierten GNU-Werkzeugen (gcc und make) erzeugt
make -f makefile.unix
die Binärdateien examples/cwebp und examples/dwebp sowie die statische Bibliothek src/libwebp.a. Es wird keine systemweite Installation bereitgestellt, da dies eine einfache Alternative zum vollständigen, auf den autoconf-Werkzeugen basierenden Installationssystem darstellt (siehe unten). Weitere Details und Anpassungsmöglichkeiten finden Sie in makefile.unix.
Voraussetzungen: Ein Compiler (z. B. gcc), make, autoconf, automake, libtool. Auf einem Debian-ähnlichen System sollte Folgendes alles installieren, was Sie für einen minimalen Build benötigen: $ sudo apt-get install gcc make autoconf automake libtool
Wenn Sie aus den Git-Quellen bauen, müssen Sie autogen.sh ausführen, um das configure-Skript zu erzeugen.
./configure make make install
sollte alles sein, was Sie benötigen, um die folgenden Dateien zu erhalten
/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
installiert.
Hinweis: Eine reine Decode-Bibliothek, libwebpdecoder, ist über die Option '--enable-libwebpdecoder' verfügbar. Die Encode-Bibliothek wird separat erstellt und kann mit einer kleinen Änderung in den entsprechenden Makefile.am-Konfigurationsdateien unabhängig installiert werden (siehe dortige Kommentare). Weitere Optionen finden Sie unter './configure --help'.
Stabile verfügbare Versionen der MIPS-Linux-Toolchain finden Sie unter: https://community.imgtec.com/developers/mips/tools/codescape-mips-sdk/available-releases/
export PATH=$PATH:/path/to/toolchain/bin
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"
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
Mit CMake können Sie libwebp, cwebp, dwebp, gif2web, img2webp, webpinfo und die JS-Bindings kompilieren.
Voraussetzungen: Ein Compiler (z. B. gcc mit autotools) und CMake. Auf einem Debian-ähnlichen System sollte Folgendes alles installieren, was Sie für einen minimalen Build benötigen: $ sudo apt-get install build-essential cmake
Wenn Sie aus den Git-Quellen bauen, müssen Sie cmake ausführen, um die Makefiles zu erzeugen.
mkdir build && cd build && cmake ../ make make install
Wenn Sie auch eines der ausführbaren Programme wünschen, müssen Sie diese über CMake aktivieren, z. B.:
cmake -DWEBP_BUILD_CWEBP=ON -DWEBP_BUILD_DWEBP=ON ../
oder über Ihre bevorzugte Oberfläche (wie ccmake oder cmake-qt-gui).
Verwenden Sie die Option -DWEBP_UNICODE=ON für Unicode-Unterstützung unter Windows (mit chcp 65001).
Schließlich können Sie WebP nach der Installation auch in Ihrem CMake-Projekt verwenden, indem Sie Folgendes ausführen:
find_package(WebP)
Dadurch werden die CMake-Variablen WebP_INCLUDE_DIRS und WebP_LIBRARIES definiert.
Die Unterstützung für Gradle ist minimal: Sie hilft Ihnen nur beim Kompilieren von libwebp, cwebp, dwebp und webpmux_example.
Voraussetzungen: Ein Compiler (z. B. gcc mit autotools) und gradle. Auf einem Debian-ähnlichen System sollte Folgendes alles installieren, was Sie für einen minimalen Build benötigen: $ sudo apt-get install build-essential gradle
Wenn Sie aus den Git-Quellen bauen, müssen Sie den Gradle-Wrapper mit dem entsprechenden Ziel ausführen, z. B.:
./gradlew buildAllExecutables
Zum Erzeugen von Sprachbindungen aus swig/libwebp.swig ist mindestens swig-1.3 (http://www.swig.org) erforderlich.
Derzeit werden die folgenden Funktionen zugeordnet: Dekodieren: WebPGetDecoderVersion WebPGetInfo WebPDecodeRGBA WebPDecodeARGB WebPDecodeBGRA WebPDecodeBGR WebPDecodeRGB
Kodieren: WebPGetEncoderVersion WebPEncodeRGBA WebPEncodeBGRA WebPEncodeRGB WebPEncodeBGR WebPEncodeLosslessRGBA WebPEncodeLosslessBGRA WebPEncodeLosslessRGB WebPEncodeLosslessBGR
Weitere detaillierte Build-Anweisungen finden Sie in swig/README.
Zum Erstellen des von SWIG generierten JNI-Wrapper-Codes ist mindestens JDK-1.5 (oder gleichwertig) für die Enum-Unterstützung erforderlich. Die Ausgabe ist als Shared Object / DLL vorgesehen, die über System.loadLibrary("webp_jni") geladen werden kann.
Zum Erstellen des von SWIG generierten Python-Erweiterungscodes ist mindestens Python 2.6 erforderlich. Python < 2.6 lässt sich möglicherweise mit einigen kleineren Änderungen an libwebp.swig oder am generierten Code erstellen, ist aber ungetestet.
Das Verzeichnis examples/ enthält Werkzeuge zum Kodieren (cwebp) und Dekodieren (dwebp) von Bildern.
Die einfachste Verwendung sieht wie folgt aus: cwebp input.png -q 80 -o output.webp Dies wandelt die Eingabedatei mit einem Qualitätsfaktor von 80 auf einer Skala von 0 bis 100 in eine WebP-Datei um (0 ist die niedrigste Qualität, 100 die beste. Der Standardwert ist 75). Sie können auch das Flag -lossless ausprobieren, das die Quelle (im RGBA-Format) ohne Verluste komprimiert. Der Qualitätsparameter -q steuert in diesem Fall den Umfang der Verarbeitungszeit, die aufgewendet wird, um die Ausgabedatei so klein wie möglich zu machen.
Eine längere Liste der Optionen ist über die Befehlszeilenoption -longhelp verfügbar:
cwebp -longhelp Verwendung: cwebp [-preset <...>] [options] in_file [-o out_file]
Wenn die Eingabegröße (-s) für ein Bild nicht angegeben ist, wird angenommen, dass es sich um eine PNG-, JPEG-, TIFF- oder WebP-Datei handelt.
Optionen: -h / -help ............. kurze Hilfe -H / -longhelp ......... lange Hilfe -q ............. Qualitätsfaktor (0:klein..100:groß), Standard=75 -alpha_q ......... Qualität der Transparenzkomprimierung (0..100), Standard=100 -preset ....... Voreinstellung, eine von: default, photo, picture, drawing, icon, text -preset muss zuerst angegeben werden, da es andere Parameter überschreibt -z ............... aktiviert verlustfreie Voreinstellung mit angegebenem Level in [0:schnell, ..., 9:langsamste]
-m ............... Kompressionsmethode (0=schnell, 6=langsamste), Standard=4 -segments ........ Anzahl der zu verwendenden Segmente (1..4), Standard=4 -size ............ Zielgröße (in Bytes) -psnr .......... Ziel-PSNR (in dB. typischerweise: 42)
-s ......... Eingabegröße (Breite x Höhe) für YUV -sns ............. räumliche Rauschformung (0:aus, 100:max), Standard=50 -f ............... Filterstärke (0=aus..100), Standard=60 -sharpness ....... Filtersschärfe (0:am schärfsten .. 7:am wenigsten scharf), Standard=0 -strong ................ starken Filter anstelle des einfachen verwenden (Standard) -nostrong .............. einfachen Filter anstelle des starken verwenden -sharp_yuv ............. schärfere (und langsamere) RGB->YUV-Konvertierung verwenden -partition_limit . Qualität begrenzen, um das 512k-Limit der ersten Partition einzuhalten (0=keine Verschlechterung ... 100=voll) -pass ............ Nummer des Analyse-Durchgangs (1..10) -crop .. Bild mit dem angegebenen Rechteck zuschneiden -resize ........ Bildgröße ändern (nach einem etwaigen Zuschnitt) -mt .................... Multithreading verwenden, falls verfügbar -low_memory ............ Speicherverbrauch reduzieren (langsamere Kodierung) -map ............. Karte mit Zusatzinformationen ausgeben -print_psnr ............ durchschnittliche PSNR-Verzerrung ausgeben -print_ssim ............ durchschnittliche SSIM-Verzerrung ausgeben -print_lsim ............ lokale Ähnlichkeitsverzerrung ausgeben -d <file.pgm> .......... komprimierte Ausgabe ausgeben (PGM-Datei) -alpha_method .... Transparenzkomprimierungsmethode (0..1), Standard=1 -alpha_filter . prädiktive Filterung für die Alpha-Ebene, eine von: none, fast (Standard) oder best -exact ................. RGB-Werte im transparenten Bereich erhalten, Standard=aus -blend_alpha ..... Farben gegen eine Hintergrundfarbe mischen, die als RGB-Werte in Hexadezimal angegeben ist, z. B. 0xc0e0d0 für Rot=0xc0, Grün=0xe0 und Blau=0xd0 -noalpha ............... alle Transparenzinformationen verwerfen -lossless .............. Bild verlustfrei kodieren, Standard=aus -near_lossless ... Near-Lossless-Bildvorverarbeitung verwenden (0..100=aus), Standard=100 -hint ......... Hinweis auf Bildeigenschaften angeben, eine von: photo, picture oder graph
-metadata ..... kommagetrennte Liste von Metadaten, die falls vorhanden von der Eingabe in die Ausgabe kopiert werden. Gültige Werte: all, none (Standard), exif, icc, xmp
-short ................. gedruckte Meldungen verkürzen -quiet ................. nichts ausgeben -version ............... Versionsnummer ausgeben und beenden -noasm ................. alle Assembler-Optimierungen deaktivieren -v ..................... ausführlich, z. B. Kodier-/Dekodierzeiten ausgeben -progress .............. Kodierfortschritt melden
Experimentelle Optionen: -jpeg_like ............. ungefähr die erwartete JPEG-Größe erreichen -af .................... Filterstärke automatisch anpassen -pre ............. Vorverarbeitungsfilter
Die Hauptoptionen, die Sie möglicherweise ausprobieren möchten, um die visuelle Qualität weiter zu optimieren, sind: -preset -sns -f -m
Nämlich:
Es gibt ein Dekodierbeispiel in examples/dwebp.c, das eine .webp-Datei nimmt und sie in eine PNG-Bilddatei (unter anderen Formaten) dekodiert. Dies dient lediglich dazu, die Verwendung der API zu demonstrieren. Sie können überprüfen, dass die Datei test.webp exakt wie test_ref.ppm dekodiert wird, indem Sie Folgendes verwenden:
cd examples ./dwebp test.webp -ppm -o test.ppm diff test.ppm test_ref.ppm
Die vollständige Liste der Optionen ist mit -h verfügbar:
dwebp -h Verwendung: dwebp in_file [options] [-o out_file]
Dekodiert die WebP-Bilddatei in das PNG-Format [Standard] Verwenden Sie die folgenden Optionen, um in alternative Bildformate zu konvertieren: -pam ......... die rohen RGBA-Samples als Farb-PAM speichern -ppm ......... die rohen RGB-Samples als Farb-PPM speichern -bmp ......... als unkomprimiertes BMP-Format speichern -tiff ........ als unkomprimiertes TIFF-Format speichern -pgm ......... die rohen YUV-Samples als Graustufen-PGM Datei mit IMC4-Layout speichern -yuv ......... die rohen YUV-Samples in flachem Layout speichern
Weitere Optionen sind: -version ..... Versionsnummer ausgeben und beenden -nofancy ..... den ausgefallenen YUV420-Upscaler nicht verwenden -nofilter .... In-Loop-Filterung deaktivieren -nodither .... Dithering deaktivieren -dither .. Dithering-Stärke (in 0..100) -alpha_dither bei Bedarf Alpha-Ebenen-Dithering verwenden -mt .......... Multithreading verwenden -crop ... Ausgabe mit dem angegebenen Rechteck zuschneiden -resize ......... Ausgabe skalieren (nach einem etwaigen Zuschnitt) -flip ........ Ausgabe vertikal kippen -alpha ....... nur die Alpha-Ebene speichern -incremental . inkrementelle Dekodierung verwenden (nützlich für Tests) -h ........... diese Hilfemeldung -v ........... ausführlich (z. B. Kodier-/Dekodierzeiten ausgeben) -quiet ....... ruhiger Modus, nichts ausgeben -noasm ....... alle Assembler-Optimierungen deaktivieren
'webpinfo' kann verwendet werden, um die Struktur auf Chunk-Ebene und Bitstream-Header-Informationen von WebP-Dateien auszugeben. Es kann auch prüfen, ob die Dateien ein gültiges WebP-Format haben.
Verwendung: webpinfo [options] in_files Hinweis: Es können mehrere Eingabedateien vorhanden sein; Optionen müssen vor den Eingabedateien stehen. Optionen: -version ........... Versionsnummer ausgeben und beenden. -quiet ............. Chunk-Parsing-Informationen nicht anzeigen. -diag .............. Parsing-Fehlerdiagnose anzeigen. -summary ........... Zusammenfassung der Chunk-Statistiken anzeigen. -bitstream_info .... Bitstream-Header parsen.
Unter dem Verzeichnis examples/ gibt es ein kleines eigenständiges Visualisierungswerkzeug namens 'vwebp'. Es verwendet OpenGL, um ein einfaches Zeichenfenster zu öffnen und eine dekodierte WebP-Datei anzuzeigen. Es ist noch nicht in das automake-Build-System integriert, aber Sie können versuchen, es manuell mit den folgenden Empfehlungen zu kompilieren.
Verwendung: vwebp in_file [options]
Dekodiert die WebP-Bilddatei und visualisiert sie mit OpenGL Optionen sind: -version ..... Versionsnummer ausgeben und beenden -noicc ....... das ICC-Profil nicht verwenden, falls vorhanden -nofancy ..... den ausgefallenen YUV420-Upscaler nicht verwenden -nofilter .... In-Loop-Filterung deaktivieren -dither Dithering-Stärke (0..100), Standard=50 -noalphadither Alpha-Ebenen-Dithering deaktivieren -usebgcolor .. Hintergrundfarbe anzeigen -mt .......... Multithreading verwenden -info ........ Informationen ausgeben -h ........... diese Hilfemeldung
Tastaturkürzel: 'c' ................ Verwendung des Farbprofils umschalten 'b' ................ Anzeige der Hintergrundfarbe umschalten 'i' ................ Dateiinformationen einblenden 'd' ................ Mischen und Verwerfen deaktivieren (Debug) 'q' / 'Q' / ESC .... beenden
Voraussetzungen:
OpenGL & OpenGL Utility Toolkit (GLUT) Linux: $ sudo apt-get install freeglut3-dev mesa-common-dev Mac + XCode:
(Optional) qcms (Quick Color Management System) i. Laden Sie qcms von Mozilla / Chromium herunter: http://hg.mozilla.org/mozilla-central/file/0e7639e3bdfb/gfx/qcms http://src.chromium.org/viewvc/chrome/trunk/src/third_party/qcms ii. Erstellen und archivieren Sie die Quelldateien als libqcms.a / qcms.lib iii. Aktualisieren Sie makefile.unix / Makefile.vc a) Definieren Sie WEBP_HAVE_QCMS b) Aktualisieren Sie die Include-/Bibliothekspfade, um auf das qcms-Verzeichnis zu verweisen.
Build mit makefile.unix / Makefile.vc: $ make -f makefile.unix examples/vwebp
nmake /f Makefile.vc CFG=release-static
../obj/x64/release-static/bin/vwebp.exe
Das Dienstprogramm 'img2webp' kann eine Sequenz von Eingabebildern (PNG, JPEG, ...) in eine animierte WebP-Datei umwandeln. Es bietet eine feine Kontrolle über Dauer, Kodierungsmodi usw.
Verwendung:
img2webp [file-level options] [image files...] [per-frame options...]
Optionen auf Dateiebene (werden nur am Anfang der Komprimierung verwendet): -min_size ............ Größe minimieren -loop .......... Anzahl der Schleifen (Standard: 0, = Endlosschleife) -kmax .......... maximale Anzahl von Frames zwischen Keyframes (0=nur Keyframes) -kmin .......... minimale Anzahl von Frames zwischen Keyframes (0=Keyframes vollständig deaktivieren) -mixed ............... gemischten verlustbehafteten/verlustfreien Automatikmodus verwenden -v ................... ausführlicher Modus -h ................... diese Hilfe -version ............. Versionsnummer ausgeben und beenden
Optionen pro Frame (nur für nachfolgende Bildeingaben verwendet): -d ............. Framedauer in ms (Standard: 100) -lossless ........... verlustfreien Modus verwenden (Standard) -lossy ... ........... verlustbehafteten Modus verwenden -q ........... Qualität -m ............. zu verwendende Methode
Beispiel: img2webp -loop 2 in0.png -lossy in1.jpg -d 80 in2.tiff -o out.webp
Hinweis: Wenn nur ein Dateiname als Argument übergeben wird, werden die Argumente aus dieser Datei tokenisiert. Der Dateiname darf nicht mit dem Zeichen '-' beginnen.
Animierte GIF-Dateien können mit dem Dienstprogramm gif2webp, das unter examples/ verfügbar ist, in animierte WebP-Dateien konvertiert werden. Die Dateien können dann mit vwebp angezeigt werden.
Verwendung: gif2webp [options] gif_file -o webp_file Optionen: -h / -help ............. diese Hilfe -lossy ................. Bild mit verlustbehafteter Komprimierung kodieren -mixed ................. für jeden Frame im Bild heuristisch verlustbehaftete oder verlustfreie Komprimierung wählen -q ............. Qualitätsfaktor (0:klein..100:groß) -m ............... Kompressionsmethode (0=schnell, 6=langsamste) -min_size .............. Ausgabegröße minimieren (Standard: aus) standardmäßig verlustfreie Komprimierung; kann mit den Optionen -q, -m, -lossy oder -mixed kombiniert werden -kmin ............ Mindestabstand zwischen Keyframes -kmax ............ Maximalabstand zwischen Keyframes -f ............... Filterstärke (0=aus..100) -metadata ..... kommagetrennte Liste von Metadaten, die falls vorhanden von der Eingabe in die Ausgabe kopiert werden Gültige Werte: all, none, icc, xmp (Standard) -loop_compatibility .... Kompatibilitätsmodus für Chrome-Versionen vor M62 (einschließlich) verwenden -mt .................... Multithreading verwenden, falls verfügbar
-version ............... Versionsnummer ausgeben und beenden -v ..................... ausführlich -quiet ................. nichts ausgeben
Mit den installierten libgif-Entwicklungsdateien kann gif2webp mit makefile.unix erstellt werden: $ make -f makefile.unix examples/gif2webp
oder mit autoconf: $ ./configure --enable-everything $ make
Das Testdienstprogramm anim_diff unter examples/ kann verwendet werden, um zwei animierte Bilder zu vergleichen (jedes kann GIF oder WebP sein).Verwendung: anim_diff [Optionen]
Optionen: -dump_frames dekodierte Frames im PAM-Format ausgeben -min_psnr ... minimale PSNR pro Frame -raw_comparison ..... wenn dieses Flag nicht verwendet wird, wird RGB vor dem Vergleich vormultipliziert -max_diff ..... maximal zulässige Differenz pro Kanal zwischen entsprechenden Pixeln in nachfolgenden Frames -h .................. diese Hilfe -version ............ Versionsnummer ausgeben und beenden
Mit den libgif-Entwicklungsdateien und einem installierten C++-Compiler kann anim_diff mit makefile.unix erstellt werden: $ make -f makefile.unix examples/anim_diff
oder mit autoconf: $ ./configure --enable-everything $ make
Die wichtigsten Kodierungsfunktionen sind im Header src/webp/encode.h verfügbar. Die gebrauchsfertigen sind: 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);
Sie konvertieren rohe RGB-Samples in WebP-Daten. Die einzige Steuerung ist der Qualitätsfaktor.
Es gibt einige Varianten für das verlustfreie 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);
In diesem Fall ist natürlich kein Qualitätsfaktor erforderlich, da die Kompression ohne Verlust der Eingabewerte erfolgt, allerdings auf Kosten größerer Ausgabegrößen.
Eine erweiterte API basiert auf den Strukturen WebPConfig und WebPPicture.
WebPConfig enthält die Kodierungseinstellungen und ist nicht an ein bestimmtes Bild gebunden. WebPPicture enthält Eingabedaten, auf die eine WebPConfig zur Kompression angewendet wird. Der Kodierungsablauf sieht wie folgt aus:
-------------------------------------- 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
Im Wesentlichen ist dies nur eine aufzurufende Funktion:
#include "webp/decode.h" uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size, int* width, int* height);
Details finden Sie in der Datei src/webp/decode.h. Es gibt Varianten für die Dekodierung in der Reihenfolge BGR/RGBA/ARGB/BGRA sowie für die Dekodierung in rohe Y'CbCr-Samples. Man kann das Bild auch direkt in einen vorab zugewiesenen Puffer dekodieren.
Zur Erkennung einer WebP-Datei und zum Ermitteln der Bildabmessungen wird die Funktion: int WebPGetInfo(const uint8_t* data, size_t data_size, int* width, int* height); bereitgestellt. Bei der Verwendung ist keine Dekodierung beteiligt.
Wenn Daten schrittweise übertragen werden, können Bilder weiterhin mit einer etwas komplexeren API inkrementell dekodiert werden. Der Dekoderzustand wird in einer Instanz des Objekts WebPIDecoder gespeichert. Dieses Objekt kann zum Dekodieren von RGB- oder Y'CbCr-Samples erstellt werden. Zum Beispiel:
WebPDecBuffer buffer; WebPInitDecBuffer(&buffer); buffer.colorspace = MODE_BGR; ... WebPIDecoder* idec = WebPINewDecoder(&buffer);
Sobald die Daten schrittweise verfügbar gemacht werden, kann dieses Objekt des inkrementellen Dekoders verwendet werden, um das Bild weiter zu dekodieren. Es gibt zwei (sich gegenseitig ausschließende) Möglichkeiten, neu eingetroffene Daten zu übergeben:
entweder durch Anhängen der neuen Bytes:
WebPIAppend(idec, fresh_data, size_of_fresh_data);
oder indem man nur die neue Größe der übertragenen Daten angibt:
WebPIUpdate(idec, buffer, size_of_transmitted_buffer);
Beachten Sie, dass 'buffer' zwischen den Aufrufen von WebPIUpdate geändert werden kann, insbesondere wenn der Puffer vergrößert wird, um größere Daten aufzunehmen.
Diese Funktionen geben den Dekodierungsstatus zurück: entweder VP8_STATUS_SUSPENDED, wenn die Dekodierung noch nicht abgeschlossen ist, oder VP8_STATUS_OK, wenn die Dekodierung abgeschlossen ist. Jeder andere Status ist ein Fehlerzustand.
Das Objekt 'idec' muss immer (auch bei einem Fehlerzustand) durch den Aufruf WebPDelete(idec) freigegeben werden.
Um teilweise dekodierte Bild-Samples abzurufen, muss man die entsprechende Methode verwenden: WebPIDecGetRGB oder WebPIDecGetYUVA. Sie gibt die letzte anzeigbare Pixelzeile zurück.
Schließlich kann die Dekodierung auch in einen vorab zugewiesenen Pixelpuffer erfolgen. Dieser Puffer muss beim Erstellen eines WebPIDecoders übergeben werden, indem man WebPINewRGB() oder WebPINewYUVA() aufruft.
Weitere Details finden Sie im Header src/webp/decode.h.
Die WebP-Dekodierung unterstützt eine erweiterte API, die dynamisches Zuschneiden und Neuskalieren ermöglicht, was in speicherbeschränkten Umgebungen wie Mobiltelefonen sehr nützlich ist. Grundsätzlich skaliert der Speicherverbrauch mit der Größe der Ausgabe, nicht der Eingabe, wenn man nur eine schnelle Vorschau oder einen vergrößerten Ausschnitt eines ansonsten zu großen Bildes benötigt. Dabei kann nebenbei auch etwas CPU gespart werden.
-------------------------------------- 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
Bitte melden Sie alle Fehler im Issue-Tracker: https://bugs.chromium.org/p/webp Patches sind willkommen! Eine Anleitung finden Sie auf dieser Seite: http://www.webmproject.org/code/contribute/submitting-patches/
E-Mail: [email protected] Web: http://groups.google.com/a/webmproject.org/group/webp-discuss