pazhanivelmani/webp_android10_r33_cve-2023-1999Exploit de prueba de concepto para CVE-2023-1999 dirigido al códec WebP en Android 10 (r33). Demuestra una vulnerabilidad de desbordamiento de búfer en el montón en la librería libwebp, permitiendo la ejecución remota de código a través de una imagen WebP manipulada.
/ \\/ \/ _ \/ _ )/ _ \
\ / __/ _ \ __/
\__\__/\____/\_____/__/ ____ ___
/ _/ / \ \ / _ \/ _/
/ \_/ / / \ \ __/ \__
\____/____/\_____/_____/____/v1.0.2
Códec WebP: biblioteca para codificar y decodificar imágenes en formato WebP. Este paquete contiene la biblioteca que se puede usar en otros programas para añadir soporte WebP, así como las herramientas de línea de comandos 'cwebp' y 'dwebp'.
Consulte http://developers.google.com/speed/webp
El árbol fuente más reciente está disponible en https://chromium.googlesource.com/webm/libwebp
Se publica bajo la misma licencia que el proyecto WebM. Consulte http://www.webmproject.org/license/software/ o el archivo "COPYING" para más detalles. Se puede encontrar una concesión adicional de derechos de propiedad intelectual en el archivo PATENTS.
Ejecutando:
nmake /f Makefile.vc CFG=release-static RTLIBCFG=static OBJDIR=output
el directorio output\release-static(x64|x86)\bin contendrá las herramientas cwebp.exe y dwebp.exe. El directorio output\release-static(x64|x86)\lib contendrá la biblioteca estática libwebp. La arquitectura destino (x86/x64) es detectada por Makefile.vc a partir del compilador de Visual Studio (cl.exe) disponible en la ruta del sistema.
En plataformas con herramientas GNU instaladas (gcc y make), ejecutando
make -f makefile.unix
se construirán los binarios examples/cwebp y examples/dwebp, junto con la biblioteca estática src/libwebp.a. No se proporciona instalación a nivel de sistema, ya que esta es una alternativa simple al sistema de instalación completo basado en las herramientas autoconf (ver más abajo). Consulte makefile.unix para obtener detalles adicionales y personalizaciones.
Requisitos previos: Un compilador (por ejemplo, gcc), make, autoconf, automake, libtool. En un sistema tipo Debian, lo siguiente debería instalar todo lo necesario para una compilación mínima: $ sudo apt-get install gcc make autoconf automake libtool
Al compilar desde fuentes git, necesitará ejecutar autogen.sh para generar el script configure.
./configure make make install
debería ser todo lo necesario para tener los siguientes archivos
/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
instalados.
Nota: Una biblioteca solo de decodificación, libwebpdecoder, está disponible usando el indicador '--enable-libwebpdecoder'. La biblioteca de codificación se construye por separado y puede instalarse de forma independiente usando una modificación menor en los archivos de configuración correspondientes de Makefile.am (consulte los comentarios allí). Consulte './configure --help' para más opciones.
Las versiones estables disponibles del conjunto de herramientas MIPS Linux se pueden encontrar en: 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
Con CMake, puede compilar libwebp, cwebp, dwebp, gif2web, img2webp, webpinfo y los enlaces JS.
Requisitos previos: Un compilador (por ejemplo, gcc con autotools) y CMake. En un sistema tipo Debian, lo siguiente debería instalar todo lo necesario para una compilación mínima: $ sudo apt-get install build-essential cmake
Al compilar desde fuentes git, necesitará ejecutar cmake para generar los archivos make.
mkdir build && cd build && cmake ../ make make install
Si también desea alguno de los ejecutables, deberá habilitarlos a través de CMake, por ejemplo:
cmake -DWEBP_BUILD_CWEBP=ON -DWEBP_BUILD_DWEBP=ON ../
o a través de su interfaz favorita (como ccmake o cmake-qt-gui).
Use la opción -DWEBP_UNICODE=ON para soporte Unicode en Windows (con chcp 65001).
Finalmente, una vez instalado, también puede usar WebP en su proyecto CMake haciendo:
find_package(WebP)
lo que definirá las variables CMake WebP_INCLUDE_DIRS y WebP_LIBRARIES.
El soporte para Gradle es mínimo: solo le ayuda a compilar libwebp, cwebp y dwebp y webpmux_example.
Requisitos previos: Un compilador (por ejemplo, gcc con autotools) y gradle. En un sistema tipo Debian, lo siguiente debería instalar todo lo necesario para una compilación mínima: $ sudo apt-get install build-essential gradle
Al compilar desde fuentes git, necesitará ejecutar el wrapper de Gradle con el objetivo apropiado, por ejemplo:
./gradlew buildAllExecutables
Para generar enlaces de lenguajes a partir de swig/libwebp.swig se requiere al menos swig-1.3 (http://www.swig.org).
Actualmente se asignan las siguientes funciones: Decodificación: WebPGetDecoderVersion WebPGetInfo WebPDecodeRGBA WebPDecodeARGB WebPDecodeBGRA WebPDecodeBGR WebPDecodeRGB
Codificación: WebPGetEncoderVersion WebPEncodeRGBA WebPEncodeBGRA WebPEncodeRGB WebPEncodeBGR WebPEncodeLosslessRGBA WebPEncodeLosslessBGRA WebPEncodeLosslessRGB WebPEncodeLosslessBGR
Consulte swig/README para instrucciones de compilación más detalladas.
Enlaces Java:
Para compilar el código wrapper JNI generado por swig se necesita al menos JDK-1.5 (o equivalente) para el soporte de enumeraciones. La salida está destinada a ser un objeto compartido / DLL que puede cargarse mediante System.loadLibrary("webp_jni").
Enlaces Python:
Para compilar el código de extensión Python generado por swig se requiere al menos Python 2.6. Python < 2.6 puede compilarse con algunos cambios menores en libwebp.swig o el código generado, pero no ha sido probado.
El directorio examples/ contiene herramientas para codificar (cwebp) y decodificar (dwebp) imágenes.
El uso más sencillo debería verse así: cwebp input.png -q 80 -o output.webp lo que convertirá el archivo de entrada a un archivo WebP usando un factor de calidad de 80 en una escala de 0 a 100 (0 es la calidad más baja, 100 es la mejor. El valor predeterminado es 75). Quizás desee probar también el indicador -lossless, que comprimirá la fuente (en formato RGBA) sin ninguna pérdida. El parámetro de calidad -q en este caso controlará la cantidad de tiempo de procesamiento dedicado a intentar hacer que el archivo de salida sea lo más pequeño posible.
Una lista más larga de opciones está disponible usando el indicador de línea de comandos -longhelp:
cwebp -longhelp Uso: cwebp [-preset <...>] [opciones] in_file [-o out_file]
Si no se especifica el tamaño de entrada (-s) para una imagen, se asume que es un archivo PNG, JPEG, TIFF o WebP.
Opciones: -h / -help ............. ayuda breve -H / -longhelp ......... ayuda extensa -q ............. factor de calidad (0:pequeño..100:grande), predeterminado=75 -alpha_q ......... calidad de compresión de transparencia (0..100), predeterminado=100 -preset ....... ajuste preestablecido, uno de: default, photo, picture, drawing, icon, text -preset debe ir primero, ya que sobrescribe otros parámetros -z ............... activa el preset sin pérdida con el nivel dado en [0:rápido, ..., 9:más lento]
-m ............... método de compresión (0=rápido, 6=más lento), predeterminado=4 -segments ........ número de segmentos a usar (1..4), predeterminado=4 -size ............ tamaño objetivo (en bytes) -psnr .......... PSNR objetivo (en dB. típicamente: 42)
-s ......... tamaño de entrada (ancho x alto) para YUV -sns ............. modelado de ruido espacial (0:desactivado, 100:máx), predeterminado=50 -f ............... fuerza del filtro (0=desactivado..100), predeterminado=60 -sharpness ....... nitidez del filtro (0:más .. 7:menos nítido), predeterminado=0 -strong ................ usar filtro fuerte en lugar de simple (predeterminado) -nostrong .............. usar filtro simple en lugar de fuerte -sharp_yuv ............. usar conversión RGB->YUV más nítida (y más lenta) -partition_limit . limitar la calidad para cumplir con el límite de 512k en la primera partición (0=sin degradación ... 100=completo) -pass ............ número de pase de análisis (1..10) -crop .. recortar imagen con el rectángulo dado -resize ........ redimensionar imagen (después de cualquier recorte) -mt .................... usar multiproceso si está disponible -low_memory ............ reducir el uso de memoria (codificación más lenta) -map ............. imprimir mapa de información extra -print_psnr ............ imprimir distorsión PSNR promedio -print_ssim ............ imprimir distorsión SSIM promedio -print_lsim ............ imprimir distorsión de similitud local -d <file.pgm> .......... volcar la salida comprimida (archivo PGM) -alpha_method .... método de compresión de transparencia (0..1), predeterminado=1 -alpha_filter . filtrado predictivo para el canal alfa, uno de: none, fast (predeterminado) o best -exact ................. preservar valores RGB en área transparente, predeterminado=desactivado -blend_alpha ..... mezclar colores con el color de fondo expresado como valores RGB escritos en hexadecimal, p.ej. 0xc0e0d0 para rojo=0xc0 verde=0xe0 y azul=0xd0 -noalpha ............... descartar cualquier información de transparencia -lossless .............. codificar imagen sin pérdida, predeterminado=desactivado -near_lossless ... usar preprocesamiento de imagen casi sin pérdida (0..100=desactivado), predeterminado=100 -hint ......... especificar pista de características de imagen, uno de: photo, picture o graph
-metadata ..... lista separada por comas de metadatos a copiar de la entrada a la salida si están presentes. Valores válidos: all, none (predeterminado), exif, icc, xmp
-short ................. condensar mensaje impreso -quiet ................. no imprimir nada -version ............... imprimir número de versión y salir -noasm ................. deshabilitar todas las optimizaciones de ensamblador -v ..................... verboso, p.ej. imprimir tiempos de codificación/decodificación -progress .............. informar progreso de codificación
Opciones experimentales: -jpeg_like ............. igualar aproximadamente el tamaño JPEG esperado -af .................... ajustar automáticamente la fuerza del filtro -pre ............. filtro de preprocesamiento
Las opciones principales que quizás desee probar para ajustar aún más la calidad visual son: -preset -sns -f -m
A saber:
Hay un ejemplo de decodificación en examples/dwebp.c que tomará un archivo .webp y lo decodificará a un archivo de imagen PNG (entre otros formatos). Esto es simplemente para demostrar el uso de la API. Puede verificar que el archivo test.webp se decodifica exactamente igual que test_ref.ppm usando:
cd examples ./dwebp test.webp -ppm -o test.ppm diff test.ppm test_ref.ppm
La lista completa de opciones está disponible usando -h:
dwebp -h Uso: dwebp in_file [opciones] [-o out_file]
Decodifica el archivo de imagen WebP al formato PNG [Predeterminado] Use las siguientes opciones para convertir a formatos de imagen alternativos: -pam ......... guardar las muestras RGBA sin procesar como PAM de color -ppm ......... guardar las muestras RGB sin procesar como PPM de color -bmp ......... guardar como formato BMP sin comprimir -tiff ........ guardar como formato TIFF sin comprimir -pgm ......... guardar las muestras YUV sin procesar como PGM en escala de grises con diseño IMC4 -yuv ......... guardar las muestras YUV sin procesar en diseño plano
Otras opciones son: -version ..... imprimir número de versión y salir -nofancy ..... no usar el escalador YUV420 fancy -nofilter .... deshabilitar el filtrado en bucle -nodither .... deshabilitar el tramado -dither .. fuerza del tramado (en 0..100) -alpha_dither usar tramado del canal alfa si es necesario -mt .......... usar multiproceso -crop ... recortar la salida con el rectángulo dado -resize ......... escalar la salida (después de cualquier recorte) -flip ........ voltear la salida verticalmente -alpha ....... guardar solo el canal alfa -incremental . usar decodificación incremental (útil para pruebas) -h ........... este mensaje de ayuda -v ........... verboso (p.ej. imprimir tiempos de codificación/decodificación) -quiet ....... modo silencioso, no imprimir nada -noasm ....... deshabilitar todas las optimizaciones de ensamblador
'webpinfo' se puede usar para imprimir la estructura a nivel de fragmentos y la información del encabezado del flujo de bits de archivos WebP. También puede verificar si los archivos tienen formato WebP válido.
Uso: webpinfo [opciones] in_files Nota: puede haber múltiples archivos de entrada; las opciones deben ir antes que los archivos de entrada. Opciones: -version ........... Imprimir número de versión y salir. -quiet ............. No mostrar información de análisis de fragmentos. -diag .............. Mostrar diagnóstico de errores de análisis. -summary ........... Mostrar resumen de estadísticas de fragmentos. -bitstream_info .... Analizar encabezado del flujo de bits.
Hay una pequeña herramienta de visualización autónoma llamada 'vwebp' en el directorio examples/. Utiliza OpenGL para abrir una ventana de dibujo simple y mostrar un archivo WebP decodificado. Aún no está integrada en el sistema de compilación automake, pero puede intentar compilarla manualmente usando las recomendaciones a continuación.
Uso: vwebp in_file [opciones]
Decodifica el archivo de imagen WebP y lo visualiza usando OpenGL Las opciones son: -version ..... imprimir número de versión y salir -noicc ....... no usar el perfil icc si está presente -nofancy ..... no usar el escalador YUV420 fancy -nofilter .... deshabilitar el filtrado en bucle -dither fuerza del tramado (0..100), predeterminado=50 -noalphadither deshabilitar tramado del canal alfa -usebgcolor .. mostrar color de fondo -mt .......... usar multiproceso -info ........ imprimir información -h ........... este mensaje de ayuda
Atajos de teclado: 'c' ................ alternar uso de perfil de color 'b' ................ alternar visualización de color de fondo 'i' ................ superponer información del archivo 'd' ................ deshabilitar mezcla y eliminación (depuración) 'q' / 'Q' / ESC .... salir
Requisitos previos:
OpenGL y OpenGL Utility Toolkit (GLUT) Linux: $ sudo apt-get install freeglut3-dev mesa-common-dev Mac + XCode:
(Opcional) qcms (Quick Color Management System) i. Descargar qcms de Mozilla / Chromium: http://hg.mozilla.org/mozilla-central/file/0e7639e3bdfb/gfx/qcms http://src.chromium.org/viewvc/chrome/trunk/src/third_party/qcms ii. Compilar y archivar los archivos fuente como libqcms.a / qcms.lib iii. Actualizar makefile.unix / Makefile.vc a) Definir WEBP_HAVE_QCMS b) Actualizar rutas de inclusión / bibliotecas para que apunten al directorio qcms.
Compilar 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
La utilidad 'img2webp' puede convertir una secuencia de imágenes de entrada (PNG, JPEG, ...) en un archivo WebP animado. Ofrece control preciso sobre la duración, los modos de codificación, etc.
Uso:
img2webp [opciones a nivel de archivo] [archivos de imagen...] [opciones por fotograma...]
Opciones a nivel de archivo (solo se usan al inicio de la compresión): -min_size ............ minimizar tamaño -loop .......... número de repeticiones (predeterminado: 0, = bucle infinito) -kmax .......... número máximo de fotogramas entre fotogramas clave (0=solo fotogramas clave) -kmin .......... número mínimo de fotogramas entre fotogramas clave (0=deshabilitar fotogramas clave por completo) -mixed ............... usar modo automático mixto con pérdida/sin pérdida -v ................... modo verboso -h ................... esta ayuda -version ............. imprimir número de versión y salir
Opciones por fotograma (solo se usan para imágenes de entrada subsiguientes): -d ............. duración del fotograma en ms (predeterminado: 100) -lossless ........... usar modo sin pérdida (predeterminado) -lossy ... ........... usar modo con pérdida -q ........... calidad -m ............. método a usar
ejemplo: img2webp -loop 2 in0.png -lossy in1.jpg -d 80 in2.tiff -o out.webp
Nota: si se pasa un solo nombre de archivo como argumento, los argumentos se tokenizarán a partir de este archivo. El nombre del archivo no debe comenzar con el carácter '-'.
Los archivos GIF animados se pueden convertir a archivos WebP con animación usando la utilidad gif2webp disponible en examples/. Los archivos se pueden ver luego usando vwebp.
Uso: gif2webp [opciones] gif_file -o webp_file Opciones: -h / -help ............. esta ayuda -lossy ................. codificar imagen usando compresión con pérdida -mixed ................. para cada fotograma de la imagen, elegir heurísticamente compresión con pérdida o sin pérdida -q ............. factor de calidad (0:pequeño..100:grande) -m ............... método de compresión (0=rápido, 6=más lento) -min_size .............. minimizar tamaño de salida (predeterminado:desactivado) compresión sin pérdida por defecto; se puede combinar con las opciones -q, -m, -lossy o -mixed -kmin ............ distancia mínima entre fotogramas clave -kmax ............ distancia máxima entre fotogramas clave -f ............... fuerza del filtro (0=desactivado..100) -metadata ..... lista separada por comas de metadatos a copiar de la entrada a la salida si están presentes Valores válidos: all, none, icc, xmp (predeterminado) -loop_compatibility .... usar modo de compatibilidad para Chrome versiones anteriores a M62 (inclusive) -mt .................... usar multiproceso si está disponible
-version ............... imprimir número de versión y salir -v ..................... verboso -quiet ................. no imprimir nada
Con los archivos de desarrollo de libgif instalados, gif2webp se puede compilar usando makefile.unix: $ make -f makefile.unix examples/gif2webp
o usando autoconf: $ ./configure --enable-everything $ make
La utilidad de prueba anim_diff en examples/ se puede usar para comparar dos imágenes animadas (cada una puede ser GIF o WebP).Usage: anim_diff [opciones]
Opciones: -dump_frames volcar fotogramas decodificados en formato PAM -min_psnr ... PSNR mínimo por fotograma -raw_comparison ..... si no se usa esta opción, RGB se premultiplica antes de la comparación -max_diff ..... diferencia máxima permitida por canal entre píxeles correspondientes en fotogramas posteriores -h .................. esta ayuda -version ............ imprimir número de versión y salir
Con los archivos de desarrollo de libgif y un compilador de C++ instalados, anim_diff se puede compilar usando makefile.unix: $ make -f makefile.unix examples/anim_diff
o usando autoconf: $ ./configure --enable-everything $ make
Las principales funciones de codificación están disponibles en el encabezado src/webp/encode.h Las listas para usar son: 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);
Ellas convertirán muestras RGB sin procesar a datos WebP. El único control proporcionado es el factor de calidad.
Existen algunas variantes para usar el formato sin pérdida:
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);
Por supuesto, en este caso no se necesita factor de calidad ya que la compresión ocurre sin pérdida de los valores de entrada, a costa de tamaños de salida más grandes.
Una API más avanzada se basa en las estructuras WebPConfig y WebPPicture.
WebPConfig contiene la configuración de codificación y no está vinculada a una imagen en particular. WebPPicture contiene datos de entrada, sobre los cuales se usará algún WebPConfig para la compresión. El flujo de codificación se ve así:
-------------------------------------- INICIO EJEMPLO PSEUDO
#include <webp/encode.h>
// Configurar una configuración, comenzando desde un preajuste y ajustando algunos parámetros // adicionales WebPConfig config; if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor)) return 0; // error de versión } // ... ajuste adicional config.sns_strength = 90; config.filter_sharpness = 6; config_error = WebPValidateConfig(&config); // no obligatorio, pero útil
// Configurar los datos de entrada WebPPicture pic; if (!WebPPictureInit(&pic)) { return 0; // error de versión } pic.width = width; pic.height = height; // imagen asignada de dimensiones ancho x alto if (!WebPPictureAllocate(&pic)) { return 0; // error de memoria } // en este punto, 'pic' ha sido inicializado como un contenedor, // y puede recibir las muestras Y/U/V. // Alternativamente, se podrían usar funciones de importación prefabricadas como // WebPPictureImportRGB(), que se encargarán de la asignación de memoria. // En cualquier caso, después de este punto, se deberá llamar a // WebPPictureFree(&pic) para recuperar la memoria.
// Configurar un método de escritura de salida de bytes. WebPMemoryWriter, por ejemplo. WebPMemoryWriter wrt; WebPMemoryWriterInit(&wrt); // inicializar 'wrt'
pic.writer = MyFileWriter; pic.custom_ptr = my_opaque_structure_to_make_MyFileWriter_work;
// ¡Comprimir! int ok = WebPEncode(&config, &pic); // ok = 0 => ¡ocurrió un error! WebPPictureFree(&pic); // debe llamarse independientemente del resultado 'ok'.
// los datos de salida deberían haber sido manejados por el escritor en ese punto. // -> los datos comprimidos son el búfer de memoria descrito por wrt.mem / wrt.size
// desasignar la memoria utilizada por los datos comprimidos WebPMemoryWriterClear(&wrt);
-------------------------------------- FIN EJEMPLO PSEUDO
Esto es principalmente solo una función para llamar:
#include "webp/decode.h" uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size, int* width, int* height);
Por favor, eche un vistazo al archivo src/webp/decode.h para los detalles. Hay variantes para decodificar en orden BGR/RGBA/ARGB/BGRA, junto con decodificación a muestras Y'CbCr sin procesar. También se puede decodificar la imagen directamente en un búfer preasignado.
Para detectar un archivo WebP y obtener las dimensiones de la imagen, se proporciona la función: int WebPGetInfo(const uint8_t* data, size_t data_size, int* width, int* height); No implica decodificación al usarla.
En el caso de que los datos se transmitan progresivamente, las imágenes aún pueden decodificarse incrementalmente utilizando una API ligeramente más compleja. El estado del decodificador se almacena en una instancia del objeto WebPIDecoder. Este objeto se puede crear con el propósito de decodificar muestras RGB o Y'CbCr. Por ejemplo:
WebPDecBuffer buffer; WebPInitDecBuffer(&buffer); buffer.colorspace = MODE_BGR; ... WebPIDecoder* idec = WebPINewDecoder(&buffer);
A medida que los datos estén disponibles progresivamente, este objeto decodificador incremental se puede usar para decodificar la imagen aún más. Hay dos formas (mutuamente excluyentes) de pasar los datos recién llegados:
ya sea agregando los bytes nuevos:
WebPIAppend(idec, fresh_data, size_of_fresh_data);
o simplemente mencionando el nuevo tamaño de los datos transmitidos:
WebPIUpdate(idec, buffer, size_of_transmitted_buffer);
Tenga en cuenta que 'buffer' puede modificarse entre cada llamada a WebPIUpdate, en particular cuando el búfer se redimensiona para acomodar datos más grandes.
Estas funciones devolverán el estado de decodificación: VP8_STATUS_SUSPENDED si la decodificación aún no ha terminado o VP8_STATUS_OK cuando la decodificación haya terminado. Cualquier otro estado es una condición de error.
El objeto 'idec' siempre debe liberarse (incluso en caso de error) llamando a: WebPDelete(idec).
Para recuperar muestras de imagen parcialmente decodificadas, se debe usar el método correspondiente: WebPIDecGetRGB o WebPIDecGetYUVA. Devolverá la última fila de píxeles visible.
Por último, tenga en cuenta que la decodificación también se puede realizar en un búfer de píxeles preasignado. Este búfer debe pasarse al crear un WebPIDecoder, llamando a WebPINewRGB() o WebPINewYUVA().
Por favor, eche un vistazo al encabezado src/webp/decode.h para más detalles.
La decodificación WebP admite una API avanzada que proporciona recorte y reescalado en tiempo real, algo de gran utilidad en entornos con restricciones de memoria como teléfonos móviles. Básicamente, el uso de memoria se escalará con el tamaño de la salida, no con el de la entrada, cuando solo se necesita una vista previa rápida o una porción ampliada de una imagen que de otro modo sería demasiado grande. También se puede ahorrar algo de CPU, incidentalmente.
-------------------------------------- INICIO EJEMPLO PSEUDO // A) Inicializar un objeto de configuración WebPDecoderConfig config; CHECK(WebPInitDecoderConfig(&config));
// B) opcional: recuperar las características del flujo de bits.
CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK);
// C) Ajustar las opciones de 'config', si es necesario
config.options.no_fancy_upsampling = 1;
config.options.use_scaling = 1;
config.options.scaled_width = scaledWidth();
config.options.scaled_height = scaledHeight();
// etc.
// D) Especificar las opciones de salida de 'config' para especificar el espacio de color de salida.
// Opcionalmente, también se puede especificar el búfer de decodificación de imagen externo.
config.output.colorspace = MODE_BGRA;
// Opcionalmente, config.output puede apuntar a un búfer externo como
// también para decodificar la imagen. Este búfer de memoria suministrado externamente
// debe ser lo suficientemente grande para almacenar la imagen decodificada.
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) Decodificar la imagen WebP. Hay dos variantes con respecto a la decodificación de imagen.
// La primera (E.1) decodifica la imagen completa y la segunda (E.2) se
// usa para decodificar incrementalmente la imagen usando búferes de entrada pequeños.
// Cualquiera de estos pasos se puede usar para decodificar la imagen WebP.
// E.1) Decodificar imagen completa.
CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
// E.2) Decodificar imagen incrementalmente.
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) La imagen decodificada ahora está en config.output (y config.output.u.RGBA).
// Se puede guardar, mostrar o procesar de otra manera.
// G) Recuperar la memoria asignada en el objeto de config. Es seguro llamar
// a esta función incluso si la memoria es externa y no fue asignada
// por WebPDecode().
WebPFreeDecBuffer(&config.output);
-------------------------------------- FIN EJEMPLO PSEUDO
Por favor, reporte todos los errores en el rastreador de incidencias: https://bugs.chromium.org/p/webp ¡Los parches son bienvenidos! Vea esta página para comenzar: http://www.webmproject.org/code/contribute/submitting-patches/
Correo electrónico: [email protected] Web: http://groups.google.com/a/webmproject.org/group/webp-discuss