Compilação no Unix usando makefile.unix:

Em plataformas com ferramentas GNU instaladas (gcc e make), executar

make -f makefile.unix

compilará os binários examples/cwebp e examples/dwebp, juntamente com a biblioteca estática src/libwebp.a. Não é fornecida instalação em todo o sistema, pois esta é uma alternativa simples ao sistema de instalação completo baseado nas ferramentas autoconf (veja abaixo). Consulte makefile.unix para obter detalhes e personalizações adicionais.

Usando ferramentas autoconf:

Pré-requisitos: Um compilador (por exemplo, gcc), make, autoconf, automake, libtool. Em um sistema Debian-like, o seguinte deve instalar tudo que você precisa para uma compilação mínima: $ sudo apt-get install gcc make autoconf automake libtool

Ao compilar a partir das fontes git, você precisará executar autogen.sh para gerar o script configure.

./configure make make install

deve ser tudo que você precisa para ter os seguintes arquivos

/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: Uma biblioteca apenas de decodificação, libwebpdecoder, está disponível usando a flag '--enable-libwebpdecoder'. A biblioteca de codificação é compilada separadamente e pode ser instalada independentemente usando uma pequena modificação nos arquivos configure Makefile.am correspondentes (veja comentários lá). Consulte './configure --help' para mais opções.

Compilação para MIPS Linux:

Versões estáveis disponíveis do toolchain MIPS Linux podem ser encontradas em: https://community.imgtec.com/developers/mips/tools/codescape-mips-sdk/available-releases/

Add toolchain to PATH

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

32-bit build for 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"

64-bit build for 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:

Com CMake, você pode compilar libwebp, cwebp, dwebp, gif2web, img2webp, webpinfo e os bindings JS.

Pré-requisitos: Um compilador (por exemplo, gcc com autotools) e CMake. Em um sistema Debian-like, o seguinte deve instalar tudo que você precisa para uma compilação mínima: $ sudo apt-get install build-essential cmake

Ao compilar a partir das fontes git, você precisará executar cmake para gerar os makefiles.

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

Se você também quiser algum dos executáveis, precisará habilitá-los através do CMake, por exemplo:

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

ou através da sua interface favorita (como ccmake ou cmake-qt-gui).

Use a opção -DWEBP_UNICODE=ON para suporte a Unicode no Windows (com chcp 65001).

Finalmente, uma vez instalado, você também pode usar WebP em seu projeto CMake fazendo:

find_package(WebP)

que definirá as variáveis do CMake WebP_INCLUDE_DIRS e WebP_LIBRARIES.

Gradle:

O suporte para Gradle é mínimo: ele apenas ajuda você a compilar libwebp, cwebp e dwebp e webpmux_example.

Pré-requisitos: Um compilador (por exemplo, gcc com autotools) e gradle. Em um sistema Debian-like, o seguinte deve instalar tudo que você precisa para uma compilação mínima: $ sudo apt-get install build-essential gradle

Ao compilar a partir das fontes git, você precisará executar o wrapper do Gradle com o alvo apropriado, por exemplo:

./gradlew buildAllExecutables

Bindings SWIG:

Para gerar bindings de linguagem a partir de swig/libwebp.swig, pelo menos swig-1.3 (http://www.swig.org) é necessário.

Atualmente, as seguintes funções são mapeadas: Decodificar: WebPGetDecoderVersion WebPGetInfo WebPDecodeRGBA WebPDecodeARGB WebPDecodeBGRA WebPDecodeBGR WebPDecodeRGB

Codificar: WebPGetEncoderVersion WebPEncodeRGBA WebPEncodeBGRA WebPEncodeRGB WebPEncodeBGR WebPEncodeLosslessRGBA WebPEncodeLosslessBGRA WebPEncodeLosslessRGB WebPEncodeLosslessBGR

Consulte swig/README para instruções de compilação mais detalhadas.

Bindings Java:

Para compilar o código wrapper JNI gerado por swig, pelo menos JDK-1.5 (ou equivalente) é necessário para suporte a enum. A saída é destinada a ser um objeto compartilhado / DLL que pode ser carregado via System.loadLibrary("webp_jni").

Bindings Python:

Para compilar o código de extensão Python gerado por swig, pelo menos Python 2.6 é necessário. Python < 2.6 pode compilar com algumas pequenas alterações no libwebp.swig ou no código gerado, mas não foi testado.

Ferramenta de codificação:

O diretório examples/ contém ferramentas para codificar (cwebp) e decodificar (dwebp) imagens.

O uso mais fácil deve ser assim: cwebp input.png -q 80 -o output.webp que converterá o arquivo de entrada para um arquivo WebP usando um fator de qualidade de 80 em uma escala de 0 a 100 (0 sendo a qualidade mais baixa, 100 a melhor. O valor padrão é 75). Você também pode querer experimentar a flag -lossless, que comprimirá a fonte (no formato RGBA) sem qualquer perda. O parâmetro de qualidade -q neste caso controlará a quantidade de tempo de processamento gasto tentando tornar o arquivo de saída o menor possível.

Uma lista mais longa de opções está disponível usando a flag de linha de comando -longhelp:

cwebp -longhelp Uso: cwebp [-preset <...>] [opções] arquivo_entrada [-o arquivo_saída]

Se o tamanho de entrada (-s) de uma imagem não for especificado, assume-se que seja um arquivo PNG, JPEG, TIFF ou WebP.

Opções: -h / -help ............. ajuda rápida -H / -longhelp ......... ajuda completa -q ............. fator de qualidade (0:pequeno..100:grande), padrão=75 -alpha_q ......... qualidade da compressão de transparência (0..100), padrão=100 -preset ....... configuração predefinida, uma de: default, photo, picture, drawing, icon, text -preset deve vir primeiro, pois sobrescreve outros parâmetros -z ............... ativa predefinição lossless com determinado nível em [0:rápido, ..., 9:mais lento]

-m ............... método de compressão (0=rápido, 6=mais lento), padrão=4 -segments ........ número de segmentos a usar (1..4), padrão=4 -size ............ tamanho alvo (em bytes) -psnr .......... PSNR alvo (em dB. tipicamente: 42)

-s ......... tamanho de entrada (largura x altura) para YUV -sns ............. modelagem de ruído espacial (0:desligado, 100:máximo), padrão=50 -f ............... intensidade do filtro (0=desligado..100), padrão=60 -sharpness ....... nitidez do filtro (0:mais suave .. 7:menos suave), padrão=0 -strong ................ usar filtro forte em vez de simples (padrão) -nostrong .............. usar filtro simples em vez de forte -sharp_yuv ............. usar conversão RGB->YUV mais nítida (e mais lenta) -partition_limit . limitar qualidade para caber no limite de 512k na primeira partição (0=sem degradação ... 100=completo) -pass ............ número de passos de análise (1..10) -crop .. recortar imagem com o retângulo dado -resize ........ redimensionar imagem (após qualquer recorte) -mt .................... usar multithreading se disponível -low_memory ............ reduzir uso de memória (codificação mais lenta) -map ............. imprimir mapa de informações extras -print_psnr ............ imprime distorção PSNR média -print_ssim ............ imprime distorção SSIM média -print_lsim ............ imprime distorção de similaridade local -d <file.pgm> .......... despejar saída compactada (arquivo PGM) -alpha_method .... método de compressão de transparência (0..1), padrão=1 -alpha_filter . filtragem preditiva para plano alfa, uma de: none, fast (padrão) ou best -exact ................. preservar valores RGB em área transparente, padrão=desligado -blend_alpha ..... misturar cores com cor de fundo expresso como valores RGB escritos em hexadecimal, por exemplo, 0xc0e0d0 para vermelho=0xc0 verde=0xe0 e azul=0xd0 -noalpha ............... descartar qualquer informação de transparência -lossless .............. codificar imagem sem perdas, padrão=desligado -near_lossless ... usar pré-processamento de imagem quase sem perdas (0..100=desligado), padrão=100 -hint ......... especificar dica de características da imagem, uma de: photo, picture ou graph

-metadata ..... lista separada por vírgulas de metadados para copiar da entrada para a saída, se presente. Valores válidos: all, none (padrão), exif, icc, xmp

-short ................. condensar mensagem impressa -quiet ................. não imprimir nada -version ............... imprimir número da versão e sair -noasm ................. desabilitar todas as otimizações de assembly -v ..................... verboso, por exemplo, imprimir tempos de codificação/decodificação -progress .............. relatar progresso da codificação

Opções Experimentais: -jpeg_like ............. corresponder aproximadamente ao tamanho esperado de JPEG -af .................... ajustar automaticamente a intensidade do filtro -pre ............. filtro de pré-processamento

As principais opções que você pode querer experimentar para ajustar ainda mais a qualidade visual são: -preset -sns -f -m

Nomeadamente:

• 'preset' configurará uma configuração de codificação padrão direcionada a um tipo específico de entrada. Deve aparecer primeiro na lista de opções, para que opções subsequentes possam ter efeito sobre esta predefinição. O valor padrão é 'default'.
• 'sns' ativará progressivamente (ao ir de 0 a 100) algumas otimizações visuais adicionais (como: reforço do mapa de segmentação). Esta opção equilibrará a alocação de bits de forma diferente. Tenta tirar bits das partes "fáceis" da imagem e usá-los nas partes "difíceis" em vez disso. Normalmente, aumentar o valor sns (com valor fixo de -q) leva a arquivos maiores, mas com melhor qualidade. O valor típico é por volta de '75'.
• A opção 'f' está diretamente ligada à intensidade de filtragem usada pelo processamento em loop do codec. Quanto maior o valor, mais suave a área altamente comprimida parecerá. Isto é particularmente útil quando se visa arquivos muito pequenos. Valores típicos são por volta de 20-30. Note que usar a opção -strong/-nostrong alterará o tipo de filtragem. Use "-f 0" para desligar a filtragem.
• 'm' controla o trade-off entre velocidade de codificação e qualidade. O padrão é 4. Você pode tentar -m 5 ou -m 6 para explorar mais possibilidades de codificação (que consomem mais tempo). Um valor menor resultará em codificação mais rápida às custas da qualidade.

Ferramenta de decodificação:

Há um exemplo de decodificação em examples/dwebp.c que pegará um arquivo .webp e o decodificará para um arquivo de imagem PNG (entre outros formatos). Isto é simplesmente para demonstrar o uso da API. Você pode verificar se o arquivo test.webp decodifica exatamente igual ao test_ref.ppm usando:

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

A lista completa de opções está disponível usando -h:

dwebp -h Uso: dwebp arquivo_entrada [opções] [-o arquivo_saída]

Decodifica o arquivo de imagem WebP para o formato PNG [Padrão] Use as seguintes opções para converter para formatos de imagem alternativos: -pam ......... salvar as amostras RGBA brutas como um PAM colorido -ppm ......... salvar as amostras RGB brutas como um PPM colorido -bmp ......... salvar como formato BMP não comprimido -tiff ........ salvar como formato TIFF não comprimido -pgm ......... salvar as amostras YUV brutas como um PGM em escala de cinza com layout IMC4 -yuv ......... salvar as amostras YUV brutas em layout plano

Outras opções são: -version ..... imprimir número da versão e sair -nofancy ..... não usar o upscaler YUV420 sofisticado -nofilter .... desabilitar filtragem em loop -nodither .... desabilitar dithering -dither .. intensidade de dithering (em 0..100) -alpha_dither usar dithering do plano alfa se necessário -mt .......... usar multithreading -crop ... recortar saída com o retângulo dado -resize ......... redimensionar a saída (após qualquer recorte) -flip ........ inverter a saída verticalmente -alpha ....... salvar apenas o plano alfa -incremental . usar decodificação incremental (útil para testes) -h ........... esta mensagem de ajuda -v ........... verboso (por exemplo, imprimir tempos de codificação/decodificação) -quiet ....... modo silencioso, não imprimir nada -noasm ....... desabilitar todas as otimizações de assembly

Ferramenta de análise de arquivos WebP:

'webpinfo' pode ser usado para imprimir a estrutura no nível de chunk e informações do cabeçalho do bitstream de arquivos WebP. Também pode verificar se os arquivos estão no formato WebP válido.

Uso: webpinfo [opções] arquivos_entrada Nota: pode haver múltiplos arquivos de entrada; as opções devem vir antes dos arquivos de entrada. Opções: -version ........... Imprimir número da versão e sair. -quiet ............. Não mostrar informações de análise de chunk. -diag .............. Mostrar diagnóstico de erro de análise. -summary ........... Mostrar resumo de estatísticas de chunks. -bitstream_info .... Analisar cabeçalho do bitstream.

Ferramenta de visualização:

Há uma pequena ferramenta de visualização auto-serviço chamada 'vwebp' no diretório examples/. Ela usa OpenGL para abrir uma janela de desenho simples e mostrar um arquivo WebP decodificado. Ainda não está integrada no sistema de compilação automake, mas você pode tentar compilá-la manualmente usando as recomendações abaixo.

Uso: vwebp arquivo_entrada [opções]

Decodifica o arquivo de imagem WebP e o visualiza usando OpenGL Opções são: -version ..... imprimir número da versão e sair -noicc ....... não usar o perfil icc se presente -nofancy ..... não usar o upscaler YUV420 sofisticado -nofilter .... desabilitar filtragem em loop -dither intensidade de dithering (0..100), padrão=50 -noalphadither desabilitar dithering do plano alfa -usebgcolor .. exibir cor de fundo -mt .......... usar multithreading -info ........ imprimir informações -h ........... esta mensagem de ajuda

Atalhos de teclado: 'c' ................ alternar uso de perfil de cor 'b' ................ alternar exibição de cor de fundo 'i' ................ sobrepor informações do arquivo 'd' ................ desabilitar blending & disposal (depuração) 'q' / 'Q' / ESC .... sair

Compilação:

Pré-requisitos:

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

   • Estas bibliotecas devem estar disponíveis nos frameworks OpenGL / GLUT. Windows: http://freeglut.sourceforge.net/index.php#download

2. (Opcional) qcms (Quick Color Management System) i. Baixar qcms do 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 e arquivar os arquivos fonte como libqcms.a / qcms.lib iii. Atualizar makefile.unix / Makefile.vc a) Definir WEBP_HAVE_QCMS b) Atualizar caminhos de inclusão / biblioteca para referenciar o diretório 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

Ferramenta de criação de animação:

O utilitário 'img2webp' pode transformar uma sequência de imagens de entrada (PNG, JPEG, ...) em um arquivo WebP animado. Ele oferece controle fino sobre duração, modos de codificação, etc.

Uso:

img2webp [opções de nível de arquivo] [arquivos de imagem...] [opções por quadro...]

Opções de nível de arquivo (usadas apenas no início da compressão): -min_size ............ minimizar tamanho -loop .......... contagem de loops (padrão: 0, = loop infinito) -kmax .......... número máximo de quadros entre quadros-chave (0=apenas quadros-chave) -kmin .......... número mínimo de quadros entre quadros-chave (0=desabilitar quadros-chave completamente) -mixed ............... usar modo automático misto com perdas/sem perdas -v ................... modo verboso -h ................... esta ajuda -version ............. imprimir número da versão e sair

Opções por quadro (usadas apenas para imagens de entrada subsequentes): -d ............. duração do quadro em ms (padrão: 100) -lossless ........... usar modo sem perdas (padrão) -lossy ... ........... usar modo com perdas -q ........... qualidade -m ............. método a usar

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

Nota: se um único nome de arquivo for passado como argumento, os argumentos serão tokenizados a partir deste arquivo. O nome do arquivo não deve começar com o caractere '-'.

Conversão de GIF animado:

Arquivos GIF animados podem ser convertidos para arquivos WebP com animação usando o utilitário gif2webp disponível em examples/. Os arquivos podem então ser visualizados usando vwebp.

Uso: gif2webp [opções] arquivo_gif -o arquivo_webp Opções: -h / -help ............. esta ajuda -lossy ................. codificar imagem usando compressão com perdas -mixed ................. para cada quadro na imagem, escolher compressão com perdas ou sem perdas heuristicamente -q ............. fator de qualidade (0:pequeno..100:grande) -m ............... método de compressão (0=rápido, 6=mais lento) -min_size .............. minimizar tamanho de saída (padrão:desligado) compressão sem perdas por padrão; pode ser combinada com opções -q, -m, -lossy ou -mixed -kmin ............ distância mínima entre quadros-chave -kmax ............ distância máxima entre quadros-chave -f ............... intensidade do filtro (0=desligado..100) -metadata ..... lista separada por vírgulas de metadados para copiar da entrada para a saída, se presente Valores válidos: all, none, icc, xmp (padrão) -loop_compatibility .... usar modo de compatibilidade para Chrome versão anterior ao M62 (inclusive) -mt .................... usar multithreading se disponível

-version ............... imprimir número da versão e sair -v ..................... verboso -quiet ................. não imprimir nada

Compilação:

Com os arquivos de desenvolvimento libgif instalados, gif2webp pode ser compilado usando makefile.unix: $ make -f makefile.unix examples/gif2webp

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

Comparação de imagens animadas:

Utilitário de teste anim_diff em examples/ pode ser usado para comparar duas imagens animadas (cada uma pode ser GIF ou WebP).Uso: anim_diff [opções]

Opções: -dump_frames despejar frames decodificados em formato PAM -min_psnr ... PSNR mínimo por frame -raw_comparison ..... se esta flag não for usada, RGB é pré-multiplicado antes da comparação -max_diff ..... diferença máxima permitida por canal entre pixels correspondentes em frames subsequentes -h .................. esta ajuda -version ............ imprimir número da versão e sair

Compilação:

Com os arquivos de desenvolvimento libgif e um compilador C++ instalados, anim_diff pode ser compilado usando makefile.unix: $ make -f makefile.unix examples/anim_diff

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

API de Codificação:

As principais funções de codificação estão disponíveis no cabeçalho src/webp/encode.h As prontas para uso são: 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);

Elas converterão amostras RGB brutas para dados WebP. O único controle fornecido é o fator de qualidade.

Existem algumas variantes para usar o formato sem perdas:

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

Claro que neste caso, nenhum fator de qualidade é necessário, pois a compressão ocorre sem perda dos valores de entrada, ao custo de tamanhos de saída maiores.

API de Codificação Avançada:

Uma API mais avançada é baseada nas estruturas WebPConfig e WebPPicture.

WebPConfig contém as configurações de codificação e não está vinculada a uma imagem específica. WebPPicture contém dados de entrada, sobre os quais algum WebPConfig será usado para compressão. O fluxo de codificação é assim:

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

API de Decodificação:

Esta é basicamente apenas uma função a ser chamada:

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

Por favor, dê uma olhada no arquivo src/webp/decode.h para os detalhes. Existem variantes para decodificar na ordem BGR/RGBA/ARGB/BGRA, junto com decodificação para amostras Y'CbCr brutas. Também é possível decodificar a imagem diretamente em um buffer pré-alocado.

Para detectar um arquivo WebP e obter as dimensões da imagem, a função: int WebPGetInfo(const uint8_t* data, size_t data_size, int* width, int* height); é fornecida. Nenhuma decodificação está envolvida ao usá-la.

API de Decodificação Incremental:

No caso de dados serem transmitidos progressivamente, as imagens ainda podem ser decodificadas incrementalmente usando uma API um pouco mais complicada. O estado do decodificador é armazenado em uma instância do objeto WebPIDecoder. Este objeto pode ser criado com o propósito de decodificar amostras RGB ou Y'CbCr. Por exemplo:

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

À medida que os dados se tornam progressivamente disponíveis, este objeto decodificador incremental pode ser usado para decodificar a imagem ainda mais. Existem duas maneiras (mutuamente exclusivas) de passar os dados recém-chegados:

seja anexando os bytes frescos:

WebPIAppend(idec, fresh_data, size_of_fresh_data);

ou apenas mencionando o novo tamanho dos dados transmitidos:

WebPIUpdate(idec, buffer, size_of_transmitted_buffer);

Note que 'buffer' pode ser modificado entre cada chamada a WebPIUpdate, em particular quando o buffer é redimensionado para acomodar dados maiores.

Estas funções retornarão o status da decodificação: VP8_STATUS_SUSPENDED se a decodificação ainda não terminou ou VP8_STATUS_OK quando a decodificação estiver concluída. Qualquer outro status é uma condição de erro.

O objeto 'idec' deve sempre ser liberado (mesmo em condição de erro) chamando: WebPDelete(idec).

Para recuperar amostras de imagem parcialmente decodificadas, deve-se usar o método correspondente: WebPIDecGetRGB ou WebPIDecGetYUVA. Ele retornará a última linha de pixel exibível.

Por último, note que a decodificação também pode ser realizada em um buffer de pixels pré-alocado. Este buffer deve ser passado ao criar um WebPIDecoder, chamando WebPINewRGB() ou WebPINewYUVA().

Por favor, consulte o cabeçalho src/webp/decode.h para mais detalhes.

API de Decodificação Avançada:

A decodificação WebP suporta uma API avançada que fornece corte e redimensionamento em tempo real, algo de grande utilidade em ambientes com memória restrita, como telefones celulares. Basicamente, o uso de memória será dimensionado com o tamanho da saída, não com a entrada, quando se precisa apenas de uma pré-visualização rápida ou de uma porção ampliada de uma imagem que de outra forma seria muito grande. Algum CPU pode ser economizado também, incidentalmente.

-------------------------------------- BEGIN PSEUDO EXAMPLE // A) Init a configuration object WebPDecoderConfig config; CHECK(WebPInitDecoderConfig(&config));

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

Bugs:

Por favor, reporte todos os bugs para o rastreador de problemas: https://bugs.chromium.org/p/webp Patches são bem-vindos! Veja esta página para começar: http://www.webmproject.org/code/contribute/submitting-patches/

Discussão:

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