Esta página foi traduzida pela API Cloud Translation.

Documentação da API WebP Container

Manipulação de contêiner RIFF para imagens WebP.

API Mux

Permite a manipulação de imagens de contêiner WebP, contendo recursos como cor metadados, animação e imagens fragmentadas.

Exemplos de código

Criar um MUX com dados de imagem, perfil de cores e metadados XMP

int copy_data = 0;
WebPMux* mux = WebPMuxNew();
// ... (Prepare image data).
WebPMuxSetImage(mux, &image, copy_data);
// ... (Prepare ICCP color profile data).
WebPMuxSetChunk(mux, "ICCP", &icc_profile, copy_data);
// ... (Prepare XMP metadata).
WebPMuxSetChunk(mux, "XMP ", &xmp, copy_data);
// Get data from mux in WebP RIFF format.
WebPMuxAssemble(mux, &output_data);
WebPMuxDelete(mux);
// ... (Consume output_data; e.g. write output_data.bytes to file).
WebPDataClear(&output_data);

Obter dados de perfil de imagem e cor de um arquivo WebP

int copy_data = 0;
// ... (Read data from file).
WebPMux* mux = WebPMuxCreate(&data, copy_data);
WebPMuxGetFrame(mux, 1, &image);
// ... (Consume image; e.g. call WebPDecode() to decode the data).
WebPMuxGetChunk(mux, "ICCP", &icc_profile);
// ... (Consume icc_data).
WebPMuxDelete(mux);
free(data);

A vida de um objeto Mux

Enums

// Error codes
typedef enum WebPMuxError {
  WEBP_MUX_OK                 =  1,
  WEBP_MUX_NOT_FOUND          =  0,
  WEBP_MUX_INVALID_ARGUMENT   = -1,
  WEBP_MUX_BAD_DATA           = -2,
  WEBP_MUX_MEMORY_ERROR       = -3,
  WEBP_MUX_NOT_ENOUGH_DATA    = -4
} WebPMuxError;

// IDs for different types of chunks.
typedef enum WebPChunkId {
  WEBP_CHUNK_VP8X,     // VP8X
  WEBP_CHUNK_ICCP,     // ICCP
  WEBP_CHUNK_ANIM,     // ANIM
  WEBP_CHUNK_ANMF,     // ANMF
  WEBP_CHUNK_ALPHA,    // ALPH
  WEBP_CHUNK_IMAGE,    // VP8/VP8L
  WEBP_CHUNK_EXIF,     // EXIF
  WEBP_CHUNK_XMP,      // XMP
  WEBP_CHUNK_UNKNOWN,  // Other chunks.
  WEBP_CHUNK_NIL
} WebPChunkId;

`WebPGetMuxVersion()`

Retorna o número da versão da biblioteca mux, empacotado em hexadecimal usando 8 bits para cada principal/secundária/revisão. Por exemplo, a v2.5.7 é 0x020507.

int WebPGetMuxVersion(void);

`WebPMuxNew()`

Cria um objeto mux vazio.

WebPMux* WebPMuxNew(void);

Retorna: Um ponteiro para o objeto mux vazio recém-criado.

`WebPMuxDelete()`

Exclui o objeto mux.

void WebPMuxDelete(WebPMux* mux);

Parâmetros: mux: objeto (de entrada/saída) a ser excluído

Criação de mux

`WebPMuxCreate()`

Cria um objeto mux de dados brutos fornecidos no formato WebP RIFF.

WebPMux* WebPMuxCreate(const WebPData* bitstream, int copy_data);

Parâmetros: bitstream: (nos) dados de bitstream no formato WebP RIFF; copy_data: o valor (in) 1 indica que os dados fornecidos serão copiados para o multiplexador e o valor 0 indica que os dados NÃO serão copiados para o objeto mux.
Retorna: Um ponteiro para o objeto mux criado com base em dados fornecidos (se for bem-sucedido).; NULL: em caso de dados inválidos ou erro de memória.

Blocos que não são imagem

`WebPMuxSetChunk()`

Adiciona um bloco com ID fourcc e dados chunk_data no objeto mux. Qualquer um bloco(s) existente(s) com o mesmo ID serão removidos.

WebPMuxError WebPMuxSetChunk(WebPMux* mux,
                             const char fourcc[4],
                             const WebPData* chunk_data,
                             int copy_data);

Observação: somente blocos não relacionados a imagens devem ser gerenciados por meio de APIs de bloco. (Os blocos relacionados à imagem são: "ANMF", "FRGM", "VP8 ", "VP8L" e "ALPH"). Para adicionar, acessar e excluir imagens, usar WebPMuxSetImage(), WebPMuxPushFrame(), WebPMuxGetFrame() e WebPMuxDeleteFrame()

Parâmetros: mux: objeto (de entrada/saída) ao qual o bloco será adicionado; fourcc: (in) uma matriz de caracteres contendo os quatrocc do chunk; Por exemplo: "ICCP", "XMP", "EXIF" etc.; chunk_data -- (in) os dados de blocos a serem adicionados; copy_data: o valor (in) 1 indica que os dados fornecidos serão copiados para o multiplexador e o valor 0 indica que os dados NÃO serão copiados para o objeto mux.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux, Fourcc ou chunk_data for NULL ou se Fourcc corresponde a um bloco de imagem.; WEBP_MUX_MEMORY_ERROR: no erro de alocação de memória.; WEBP_MUX_OK – se der certo.

`WebPMuxGetChunk()`

Recebe uma referência aos dados do bloco com o ID fourcc no objeto mux. O autor da chamada NÃO deve liberar os dados retornados.

WebPMuxError WebPMuxGetChunk(const WebPMux* mux,
                             const char fourcc[4],
                             WebPData* chunk_data);

Parâmetros: mux: (in) objeto em que os dados do bloco serão buscados; fourcc: (in) uma matriz de caracteres contendo os quatrocc do bloco. Por exemplo: "ICCP", "XMP", "EXIF" etc.; chunk_data -- (out) retornou dados de blocos
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux, Fourcc ou chunk_data for NULL ou se Fourcc corresponde a um bloco de imagem.; WEBP_MUX_NOT_FOUND: se o mux não contiver um bloco com o tipo ID.; WEBP_MUX_OK – se der certo.

`WebPMuxDeleteChunk()`

Exclui o bloco com o fourcc especificado do objeto mux.

WebPMuxError WebPMuxDeleteChunk(WebPMux* mux, const char fourcc[4]);

Parâmetros: mux: objeto (de entrada/saída) do qual o bloco será excluído.; fourcc: (in) uma matriz de caracteres contendo os quatrocc do bloco. Por exemplo: "ICCP", "XMP", "EXIF" etc.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux ou Fourcc for NULL ou se Fourcc for NULL. corresponde a um bloco de imagem.; WEBP_MUX_NOT_FOUND: se o mux não contiver um bloco com o tipo 4cc; WEBP_MUX_OK – se der certo.

Imagens

Encapsula dados sobre um único frame/fragmento.

struct WebPMuxFrameInfo {
  WebPData    bitstream;  // image data: can be a raw VP8/VP8L bitstream
                          // or a single-image WebP file.
  int         x_offset;   // x-offset of the frame.
  int         y_offset;   // y-offset of the frame.
  int         duration;   // duration of the frame (in milliseconds).

  WebPChunkId id;         // frame type: should be one of WEBP_CHUNK_ANMF,
                          // WEBP_CHUNK_FRGM or WEBP_CHUNK_IMAGE
  WebPMuxAnimDispose dispose_method;  // Disposal method for the frame.
  WebPMuxAnimBlend   blend_method;    // Blend operation for the frame.
};

`WebPMuxSetImage()`

Define a imagem (não animada e não fragmentada) no objeto mux. Observação:todas as imagens atuais (incluindo frames/fragmentos) vão ser removidas.

WebPMuxError WebPMuxSetImage(WebPMux* mux,
                             const WebPData* bitstream,
                             int copy_data);

Parâmetros: mux: objeto (de entrada/saída) em que a imagem será definida.; bitstream: (in) pode ser um bitstream VP8/VP8L bruto ou um WebP de imagem única arquivo (não animado e não fragmentado); copy_data: o valor (in) 1 indica que os dados fornecidos serão copiados para o multiplexador e o valor 0 indica que os dados NÃO serão copiados para o objeto mux.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se o mux for NULL ou o bitstream for NULL.; WEBP_MUX_MEMORY_ERROR: no erro de alocação de memória.; WEBP_MUX_OK – se der certo.

`WebPMuxPushFrame()`

Adiciona um frame ao final do objeto mux.

WebPMuxError WebPMuxPushFrame(WebPMux* mux,
                              const WebPMuxFrameInfo* frame,
                              int copy_data);

Observações:

O frame.id precisa ser WEBP_CHUNK_ANMF ou WEBP_CHUNK_FRGM.
Para definir uma imagem não animada e não fragmentada, use WebPMuxSetImage().
O tipo de frame enviado precisa ser o mesmo dos frames do mux.
Como o WebP aceita apenas deslocamentos pares, todos os deslocamentos ímpares serão direcionados até um local uniforme usando: deslocamento &= ~1

Parâmetros: mux: objeto (de entrada/saída) ao qual o frame será adicionado.; frame: dados (dentro) do frame.; copy_data: o valor (in) 1 indica que os dados fornecidos serão copiados para o multiplexador e o valor 0 indica que os dados NÃO serão copiados para o objeto mux.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se o mux ou o frame for NULL ou se o conteúdo de frame é inválido.; WEBP_MUX_MEMORY_ERROR: no erro de alocação de memória.; WEBP_MUX_OK – se der certo.; WEBP_MUX_MEMORY_ERROR: no erro de alocação de memória.

`WebPMuxGetFrame()`

Recebe o enésimo frame do objeto mux. O conteúdo de frame->bitstream é alocada usando shoppingoc() e NÃO pertence ao objeto mux. DEVE ser desalocado pelo autor da chamada chamando WebPDataClear(). nth=0 tem um significado especial: a última posição.

WebPMuxError WebPMuxGetFrame(const WebPMux* mux,
                             uint32_t nth,
                             WebPMuxFrameInfo* frame);

Parâmetros: mux: objeto (in) em que as informações serão buscadas; nth: índice (in) do frame no objeto mux; frame: (out) dados do frame retornado
Retorna: WEBP_MUX_INVALID_ARGUMENT -- if mux or frame is NULL.; WEBP_MUX_NOT_FOUND: se houver menos de enésimo frames no multiplexador objeto.; WEBP_MUX_BAD_DATA: se o enésimo bloco do frame no mux for inválido.; WEBP_MUX_OK – se der certo.

`WebPMuxDeleteFrame()`

Exclui um frame do objeto mux. nth=0 tem um significado especial: último posição

WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);

Parâmetros: mux: objeto (de entrada/saída) do qual um frame será excluído.; nth: (in) A posição da qual o frame será excluído.
Retorna: WEBP_MUX_INVALID_ARGUMENT -- if mux is NULL.; WEBP_MUX_NOT_FOUND: se houver menos de um enésimo frames no multiplexador antes da exclusão.; WEBP_MUX_OK – se der certo.

Animação

Parâmetros de animação

struct WebPMuxAnimParams {
  uint32_t bgcolor;  // Background color of the canvas stored (in MSB order) as:
                     // Bits 00 to 07: Alpha.
                     // Bits 08 to 15: Red.
                     // Bits 16 to 23: Green.
                     // Bits 24 to 31: Blue.
  int loop_count;    // Number of times to repeat the animation [0 = infinite].
};

`WebPMuxSetAnimationParams()`

Define os parâmetros de animação no objeto mux. Todos os blocos ANIM existentes serão ser removidos.

WebPMuxError WebPMuxSetAnimationParams(WebPMux* mux,
                                       const WebPMuxAnimParams* params);

Parâmetros: mux: objeto (de entrada/saída) em que o bloco de ANIM será definido/adicionado.; params: (in) parâmetros de animação.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux ou params forem NULL.; WEBP_MUX_MEMORY_ERROR: no erro de alocação de memória.; WEBP_MUX_OK – se der certo.

`WebPMuxGetAnimationParams()`

Recebe os parâmetros de animação do objeto mux.

WebPMuxError WebPMuxGetAnimationParams(const WebPMux* mux,
                                       WebPMuxAnimParams* params);

Parâmetros: mux: objeto (in) em que os parâmetros de animação serão buscados; params: (out) parâmetros de animação extraídos do bloco ANIM
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux ou params forem NULL.; WEBP_MUX_NOT_FOUND: se o bloco ANIM não estiver presente no objeto mux.; WEBP_MUX_OK – se der certo.

Diversos Serviços públicos

`WebPMuxGetCanvasSize()`

Recebe o tamanho da tela do objeto mux.

WebPMuxError WebPMuxGetCanvasSize(const WebPMux* mux,
                                  int* width,
                                  int* height);

Observação:esse método pressupõe que o bloco VP8X, se presente, está atualizado. Ou seja, o objeto mux não foi modificado desde a última chamada para WebPMuxAssemble() ou WebPMuxCreate().

Parâmetros: mux: objeto (in) em que o tamanho da tela será buscado.; width: (out) largura da tela; height: (out) altura da tela.
Retorna: WEBP_MUX_INVALID_ARGUMENT -- if mux, width or height is NULL.; WEBP_MUX_BAD_DATA: se o tamanho da tela ou do bloco VP8X/VP8/VP8L for inválido.; WEBP_MUX_OK – se der certo.

`WebPMuxGetFeatures()`

Recebe as sinalizações de recursos do objeto mux.

WebPMuxError WebPMuxGetFeatures(const WebPMux* mux, uint32_t* flags);

Parâmetros: mux: objeto (in) em que os atributos serão buscados; flags: (out) as sinalizações que especificam quais recursos estão presentes no mux objeto. Será um OR de vários valores de sinalização. Enumerado WebPFeatureFlags pode ser usada para testar valores de sinalizações individuais.
Retorna: WEBP_MUX_INVALID_ARGUMENT -- if mux or flags is NULL.; WEBP_MUX_BAD_DATA: se o tamanho da tela ou do bloco VP8X/VP8/VP8L for inválido.; WEBP_MUX_OK – se der certo.

`WebPMuxNumChunks()`

Recebe o número de blocos com o valor de tag especificado no objeto mux.

WebPMuxError WebPMuxNumChunks(const WebPMux* mux,
                              WebPChunkId id,
                              int* num_elements);

Parâmetros: mux: objeto (in) em que as informações serão buscadas; id -- (in) ID de bloco especificando o tipo de bloco; num_elements: (out) número de blocos com o ID de bloco especificado
Retorna: WEBP_MUX_INVALID_ARGUMENT -- if mux, or num_elements is NULL.; WEBP_MUX_OK – se der certo.

`WebPMuxAssemble()`

Reúne todos os blocos no formato WebP RIFF e retorna em assembled_data. Essa função também valida o objeto mux.

WebPMuxError WebPMuxAssemble(WebPMux* mux, WebPData* assembled_data);

Observação:o conteúdo de assembled_data será ignorado e substituído. Além disso, o conteúdo de assembled_data é alocado usando Malloc(), e NOT de propriedade do objeto mux. Ele PRECISA ser desalocado pelo autor da chamada chamando WebPDataClear()

Parâmetros: mux: objeto (de entrada/saída) cujos blocos serão montados; assembled_data: (out) dados WebP montados
Retorna: WEBP_MUX_BAD_DATA: se o objeto mux for inválido.; WEBP_MUX_INVALID_ARGUMENT -- if mux or assembled_data is NULL.; WEBP_MUX_MEMORY_ERROR: no erro de alocação de memória.; WEBP_MUX_OK – se der certo.

API WebPAnimEncoder

Essa API permite codificar (possivelmente) imagens WebP animadas.

Exemplo de código

WebPAnimEncoderOptions enc_options;
WebPAnimEncoderOptionsInit(&enc_options);
// Tune 'enc_options' as needed.
WebPAnimEncoder* enc = WebPAnimEncoderNew(width, height, &enc_options);
while(<there are more frames>) {
  WebPConfig config;
  WebPConfigInit(&config);
  // Tune 'config' as needed.
  WebPAnimEncoderAdd(enc, frame, timestamp_ms, &config);
}
WebPAnimEncoderAdd(enc, NULL, timestamp_ms, NULL);
WebPAnimEncoderAssemble(enc, webp_data);
WebPAnimEncoderDelete(enc);
// Write the 'webp_data' to a file, or re-mux it further.

typedef struct WebPAnimEncoder WebPAnimEncoder;  // Main opaque object.

Opções globais

struct WebPAnimEncoderOptions {
  WebPMuxAnimParams anim_params;  // Animation parameters.
  int minimize_size;    // If true, minimize the output size (slow). Implicitly
                        // disables key-frame insertion.
  int kmin;
  int kmax;             // Minimum and maximum distance between consecutive key
                        // frames in the output. The library may insert some key
                        // frames as needed to satisfy this criteria.
                        // Note that these conditions should hold: kmax > kmin
                        // and kmin >= kmax / 2 + 1. Also, if kmax <= 0, then
                        // key-frame insertion is disabled; and if kmax == 1,
                        // then all frames will be key-frames (kmin value does
                        // not matter for these special cases).
  int allow_mixed;      // If true, use mixed compression mode; may choose
                        // either lossy and lossless for each frame.
  int verbose;          // If true, print info and warning messages to stderr.
};

`WebPAnimEncoderOptionsInit()`

Precisa ser sempre chamado para inicializar um novo WebPAnimEncoderOptions. antes da modificação. Retorna "false" em caso de incompatibilidade de versão. WebPAnimEncoderOptionsInit() deve ter êxito antes de usar o objeto enc_options.

Parâmetros: enc_options: opções de entrada/saída usadas para codificar animações
Retorna: Verdadeiro se o sucesso for positivo.

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

Cria e inicializa um objeto WebPAnimEncoder.

Parâmetros: largura/altura: (pol.) largura e altura da tela da animação.; enc_options -- (in) opções de codificação pode receber NULL para selecionar padrões razoáveis e razoáveis.
Retorna: Um ponteiro para o objeto WebPAnimEncoder recém-criado, ou NULL no caso de de erros de memória.

WebPAnimEncoder* WebPAnimEncoderNew(
    int width, int height, const WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderAdd()`

Otimize o frame fornecido para WebP, codifique-o e adicione-o ao objeto WebPAnimEncoder.

A última chamada para WebPAnimEncoderAdd é feita com frame = NULL, que indica que não devem mais ser adicionados frames. Essa chamada também é usada para determina a duração do último frame.

Parâmetros: enc: objeto (de entrada/saída) ao qual o frame será adicionado.; frame: (entrada/saída) dos dados do frame no formato ARGB ou YUV(A). Se estiver em YUV(A), ele será convertido para ARGB, o que causa uma pequena perda.; timestamp_ms: (in) carimbo de data/hora deste frame em milissegundos. Duração de um frame seria calculado como "timestamp do próximo frame - carimbo de data/hora de neste frame". Portanto, os carimbos de data/hora precisam estar em ordem não decrescente.; config -- (in) opções de codificação podem ser passados NULL para selecionar valores razoáveis padrão.
Retorna: Em caso de erro, retorna falso e frame->error_code está definido corretamente. Caso contrário, retorna verdadeiro.

int WebPAnimEncoderAdd(
    WebPAnimEncoder* enc, struct WebPPicture* frame, int timestamp_ms,
    const struct WebPConfig* config);

`WebPAnimEncoderAssemble()`

Junte todos os frames adicionados até agora em um bitstream do WebP. Esta chamada deve ser precedido por uma chamada para WebPAnimEncoderAdd com frame = NULL Caso contrário, o do último frame serão estimadas internamente.

Parâmetros: enc: objeto (de entrada/saída) a partir do qual os frames serão montados.; webp_data: (out) bitstream do WebP gerado.
Retorna: Verdadeiro se for bem-sucedido.

int WebPAnimEncoderAssemble(WebPAnimEncoder* enc, WebPData* webp_data);

`WebPAnimEncoderGetError()`

Receba a string de erro correspondente à chamada mais recente usando enc. A string retornada é de propriedade de enc e é válida somente até a próxima chamada para WebPAnimEncoderAdd() ou WebPAnimEncoderAssemble() ou WebPAnimEncoderDelete().

Parâmetros: enc: objeto (de entrada/saída) em que a string de erro será buscada.
Retorna: NULL if enc is NULL. Caso contrário, retorna a string de erro se o último que a chamada para enc tivesse um erro ou uma string vazia se a última chamada foi um o sucesso.

const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);

`WebPAnimEncoderDelete()`

Exclui o objeto WebPAnimEncoder.

Parâmetros: enc: objeto (de entrada/saída) a ser excluído

void WebPAnimEncoderDelete(WebPAnimEncoder* enc);

API Demux

Permite a extração de dados de imagem e de formato estendido de arquivos WebP.

Exemplos de código

Demuxing de dados WebP para extrair todos os frames, perfil ICC e metadados EXIF/XMP

WebPDemuxer* demux = WebPDemux(&webp_data);

uint32_t width = WebPDemuxGetI(demux, WEBP_FF_CANVAS_WIDTH);
uint32_t height = WebPDemuxGetI(demux, WEBP_FF_CANVAS_HEIGHT);
// ... (Get information about the features present in the WebP file).
uint32_t flags = WebPDemuxGetI(demux, WEBP_FF_FORMAT_FLAGS);

// ... (Iterate over all frames).
WebPIterator iter;
if (WebPDemuxGetFrame(demux, 1, &iter)) {
  do {
    // ... (Consume 'iter'; e.g. Decode 'iter.fragment' with WebPDecode(),
    // ... and get other frame properties like width, height, offsets etc.
    // ... see 'struct WebPIterator' below for more info).
  } while (WebPDemuxNextFrame(&iter));
  WebPDemuxReleaseIterator(&iter);
}

// ... (Extract metadata).
WebPChunkIterator chunk_iter;
if (flags & ICCP_FLAG) WebPDemuxGetChunk(demux, "ICCP", 1, &chunk_iter);
// ... (Consume the ICC profile in 'chunk_iter.chunk').
WebPDemuxReleaseChunkIterator(&chunk_iter);
if (flags & EXIF_FLAG) WebPDemuxGetChunk(demux, "EXIF", 1, &chunk_iter);
// ... (Consume the EXIF metadata in 'chunk_iter.chunk').
WebPDemuxReleaseChunkIterator(&chunk_iter);
if (flags & XMP_FLAG) WebPDemuxGetChunk(demux, "XMP ", 1, &chunk_iter);
// ... (Consume the XMP metadata in 'chunk_iter.chunk').
WebPDemuxReleaseChunkIterator(&chunk_iter);
WebPDemuxDelete(demux);

A vida de um objeto Demux

Enums

typedef enum WebPDemuxState {
  WEBP_DEMUX_PARSE_ERROR    = -1,  // An error occurred while parsing.
  WEBP_DEMUX_PARSING_HEADER =  0,  // Not enough data to parse full header.
  WEBP_DEMUX_PARSED_HEADER  =  1,  // Header parsing complete,
                                   // data may be available.
  WEBP_DEMUX_DONE           =  2   // Entire file has been parsed.
} WebPDemuxState;

`WebPGetDemuxVersion()`

Retorna o número da versão da biblioteca demux, empacotado em hexadecimal usando 8 bits para cada principal/secundária/revisão. Por exemplo, a v2.5.7 é 0x020507.

int WebPGetDemuxVersion(void);

`WebPDemux()`

Analisa o arquivo WebP completo fornecido por data.

WebPDemuxer WebPDemux(const WebPData* data);

Retorna um objeto WebPDemuxer em uma análise bem-sucedida. Caso contrário, retorna NULL.

`WebPDemuxPartial()`

Analisa o arquivo WebP possivelmente incompleto fornecido por data. Se state for não NULL, ele será definido para indicar o status do demuxer.

WebPDemuxer WebPDemuxPartial(const WebPData* data, WebPDemuxState* state);

Retorna NULL em caso de erro ou se não houver dados suficientes para iniciar a análise. e um objeto WebPDemuxer na análise.

Observe que WebPDemuxer mantém ponteiros internos para o segmento de memória data. Se esses dados forem voláteis, o objeto demuxer deverá ser excluído (chamando WebPDemuxDelete()) e WebPDemuxPartial() chamado novamente nos novos dados. Isso é geralmente uma operação de baixo custo.

`WebPDemuxDelete()`

Libera a memória associada a dmux.

void WebPDemuxDelete(WebPDemuxer* dmux);

Extração de dados/informações

typedef enum WebPFormatFeature {
  WEBP_FF_FORMAT_FLAGS,      // bit-wise combination of WebPFeatureFlags
                             // corresponding to the 'VP8X' chunk (if present).
  WEBP_FF_CANVAS_WIDTH,
  WEBP_FF_CANVAS_HEIGHT,
  WEBP_FF_LOOP_COUNT,        // only relevant for animated file
  WEBP_FF_BACKGROUND_COLOR,  // idem.
  WEBP_FF_FRAME_COUNT        // Number of frames present in the demux object.
                             // In case of a partial demux, this is the number
                             // of frames seen so far, with the last frame
                             // possibly being partial.
} WebPFormatFeature;

`WebPDemuxGetI()`

Receba o valor de feature do dmux.

uint32_t WebPDemuxGetI(const WebPDemuxer* dmux, WebPFormatFeature feature);

Observação:os valores são válidos apenas se WebPDemux() tiver sido usado ou WebPDemuxPartial() retornou um estado > WEBP_DEMUX_PARSING_HEADER.

Iteração de frames

struct WebPIterator {
  int frame_num;
  int num_frames;          // equivalent to WEBP_FF_FRAME_COUNT.
  int fragment_num;
  int num_fragments;
  int x_offset, y_offset;  // offset relative to the canvas.
  int width, height;       // dimensions of this frame or fragment.
  int duration;            // display duration in milliseconds.
  WebPMuxAnimDispose dispose_method;  // dispose method for the frame.
  int complete;   // true if 'fragment' contains a full frame. partial images
                  // may still be decoded with the WebP incremental decoder.
  WebPData fragment;  // The frame or fragment given by 'frame_num' and
                      // 'fragment_num'.
  int has_alpha;      // True if the frame or fragment contains transparency.
  WebPMuxAnimBlend blend_method;  // Blend operation for the frame.
};

`WebPDemuxGetFrame()`

Recupera o frame frame_number do dmux.

int WebPDemuxGetFrame(const WebPDemuxer* dmux,
                      int frame_number,
                      WebPIterator* iter);

iter->fragment aponta para o primeiro fragmento no retorno dessa função. Fragmentos individuais podem ser extraídos usando WebPDemuxSelectFragment() Ambiente frame_number igual a 0 retorna o último frame da imagem.

Retorna "false" se dmux é NULL ou o frame dmux não está presente. Chame WebPDemuxReleaseIterator() quando o iterador está completo.

Observação:o dmux precisa persistir durante o ciclo de vida do iter.

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

Define iter->fragment para apontar para o próximo (iter->fragment + 1) ou frame anterior (iter->frame_num - 1). Essas funções não se repetem.

int WebPDemuxNextFrame(WebPIterator* iter);
int WebPDemuxPrevFrame(WebPIterator* iter);

Retorna "true" em caso de sucesso. Caso contrário, retorna "false".

`WebPDemuxSelectFragment()`

Define iter->fragment para refletir o número de fragmento iter->fragment.

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

Retorna "true" se o fragmento fragment_num estiver presente. Caso contrário, o resultado será "false".

`WebPDemuxReleaseIterator()`

Libera qualquer memória associada a iter.

void WebPDemuxReleaseIterator(WebPIterator* iter);

Deve ser chamado antes de qualquer chamada subsequente para WebPDemuxGetChunk() no mesmo iterador. Além disso, devem ser chamado antes de destruir o WebPDemuxer associado com WebPDemuxDelete().

Iteração de pedaços

struct WebPChunkIterator {
  // The current and total number of chunks with the fourcc given to
  // WebPDemuxGetChunk().
  int chunk_num;
  int num_chunks;
  WebPData chunk;    // The payload of the chunk.
};

`WebPDemuxGetChunk()`

Recupera a instância chunk_number do bloco com o ID fourcc do dmux.

int WebPDemuxGetChunk(const WebPDemuxer* dmux,
                      const char fourcc[4], int chunk_number,
                      WebPChunkIterator* iter);

fourcc é uma matriz de caracteres que contém os quatrocc do bloco a ser retornado. Por exemplo: "ICCP", "XMP", "EXIF" etc.

Definir chunk_number igual a 0 retornará a última parte de um conjunto.

Retorna true se o bloco for encontrado; caso contrário, retorna false. Bloco relacionado à imagem payloads são acessados por WebPDemuxGetFrame() e funções relacionadas. Ligação WebPDemuxReleaseChunkIterator() quando usar do iterador está completo.

Observação: dmux precisa persistir durante todo o ciclo de vida do iterador.

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

Define iter->chunk para apontar para o próximo (iter->chunk_num + 1) ou bloco anterior (iter->chunk_num - 1). Essas funções não se repetem.

int WebPDemuxNextChunk(WebPChunkIterator* iter);
int WebPDemuxPrevChunk(WebPChunkIterator* iter);

Retorna "true" em caso de sucesso. Caso contrário, retorna "false".

`WebPDemuxReleaseChunkIterator()`

Libera qualquer memória associada a iter.

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);

Precisa ser chamado antes de destruir o WebPDemuxer associado com WebPDemuxDelete().

API WebPAnimDecoder

Essa API permite a decodificação (possivelmente) de imagens WebP animadas.

Exemplo de código

WebPAnimDecoderOptions dec_options;
WebPAnimDecoderOptionsInit(&dec_options);
// Tune 'dec_options' as needed.
WebPAnimDecoder* dec = WebPAnimDecoderNew(webp_data, &dec_options);
WebPAnimInfo anim_info;
WebPAnimDecoderGetInfo(dec, &anim_info);
for (uint32_t i = 0; i < anim_info.loop_count; ++i) {
  while (WebPAnimDecoderHasMoreFrames(dec)) {
    uint8_t* buf;
    int timestamp;
    WebPAnimDecoderGetNext(dec, &buf, &timestamp);
    // ... (Render 'buf' based on 'timestamp').
    // ... (Do NOT free 'buf', as it is owned by 'dec').
  }
  WebPAnimDecoderReset(dec);
}
const WebPDemuxer* demuxer = WebPAnimDecoderGetDemuxer(dec);
// ... (Do something using 'demuxer'; e.g. get EXIF/XMP/ICC data).
WebPAnimDecoderDelete(dec);

typedef struct WebPAnimDecoder WebPAnimDecoder;  // Main opaque object.

Opções globais

struct WebPAnimDecoderOptions {
  // Output colorspace. Only the following modes are supported:
  // MODE_RGBA, MODE_BGRA, MODE_rgbA and MODE_bgrA.
  WEBP_CSP_MODE color_mode;
  int use_threads;           // If true, use multi-threaded decoding.
};

`WebPAnimDecoderOptionsInit()`

Precisa ser sempre chamado para inicializar um novo WebPAnimDecoderOptions. antes da modificação. Retorna "false" em caso de incompatibilidade de versão. WebPAnimDecoderOptionsInit() deve ter sido bem-sucedido antes de usar o dec_options.

Parâmetros

dec_options: opções de entrada/saída usadas para decodificar animação

Retorna: Verdadeiro em caso de sucesso

int WebPAnimDecoderOptionsInit(
    WebPAnimDecoderOptions* dec_options);

`WebPAnimDecoderNew()`

Cria e inicializa um objeto WebPAnimDecoder.

Parâmetros: webp_data: (in) bitstream do WebP. Isso deve permanecer inalterado durante a vida útil do objeto de saída WebPAnimDecoder.; dec_options: (in) opções de decodificação. Pode receber NULL para escolher padrões razoáveis (em especial, o modo de cor MODE_RGBA é escolhido).
Retorna: Um ponteiro para o objeto WebPAnimDecoder recém-criado, ou NULL no caso de de erro de análise, opção inválida ou erro de memória.

WebPAnimDecoder* WebPAnimDecoderNew(
    const WebPData* webp_data, const WebPAnimDecoderOptions* dec_options);

Informações globais sobre a animação.

struct WebPAnimInfo {
  uint32_t canvas_width;
  uint32_t canvas_height;
  uint32_t loop_count;
  uint32_t bgcolor;
  uint32_t frame_count;
};

`WebPAnimDecoderGetInfo()`

Recebe informações globais sobre a animação.

Parâmetros: dec -- (in) instância do decodificador da qual as informações serão recebidas.; info: (saída) informações globais buscadas na animação.
Retorna: Verdadeiro se for bem-sucedido.

int WebPAnimDecoderGetInfo(const WebPAnimDecoder* dec,
                           WebPAnimInfo* info);

`WebPAnimDecoderGetNext()`

Busca o próximo frame em dec com base nas opções fornecidas para WebPAnimDecoderNew(). Este será um tela reconstruída de canvas_width * 4 * canvas_height, e não apenas no sub-retângulo do frame. O buffer buf retornado é válido somente até que o na próxima chamada para WebPAnimDecoderGetNext(), WebPAnimDecoderReset() ou WebPAnimDecoderDelete().

Parâmetros: dec: (entrada/saída) da instância do decodificador a partir da qual o próximo frame será usado. buscada.; buf: (out) frame decodificado.; timestamp: (out) carimbo de data/hora do frame em milissegundos.
Retorna: Falso se algum dos argumentos for NULL, ou se houver análise ou erro de decodificação ou se não houver mais frames. Caso contrário, retorna verdadeiro.

int WebPAnimDecoderGetNext(WebPAnimDecoder* dec,
                           uint8_t** buf, int* timestamp);

`WebPAnimDecoderHasMoreFrames()`

Verifique se restam mais frames para decodificar.

Parâmetros: dec: (in) instância do decodificador a ser verificada.
Retorna: Verdadeiro se dec não for NULL e alguns frames ainda não foram decodificados. Caso contrário, retorna false.

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

Redefine o objeto WebPAnimDecoder para que a próxima chamada ao WebPAnimDecoderGetNext() vai reiniciar a decodificação do primeiro frame. Isso é útil quando todos os frames precisam ser decodificados várias vezes (por exemplo, info.loop_count vezes) sem destruir e recriar objeto dec.

Parâmetros: dec: (entrada/saída) da instância do decodificador a ser redefinida

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

Pegue o objeto demuxer interno.

Conseguir o objeto demuxer pode ser útil se você quiser usar apenas operações pelo demuxer. Por exemplo: para obter metadados XMP/EXIF/ICC. O demuxer pertence a dec e é válido apenas até a próxima chamada para WebPAnimDecoderDelete().

Parâmetros: dec: (in) instância do decodificador a partir da qual o objeto demuxer será usado buscada.

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

Exclui o objeto WebPAnimDecoder.

Parâmetros: dec: (entrada/saída) da instância do decodificador a ser excluída.
Retorna: Verdadeiro se o sucesso for positivo.

void WebPAnimDecoderDelete(WebPAnimDecoder* dec);

Tipos de dados comuns

Enums

typedef enum WebPFeatureFlags {
  FRAGMENTS_FLAG  = 0x00000001,
  ANIMATION_FLAG  = 0x00000002,
  XMP_FLAG        = 0x00000004,
  EXIF_FLAG       = 0x00000008,
  ALPHA_FLAG      = 0x00000010,
  ICCP_FLAG       = 0x00000020
} WebPFeatureFlags;

// Dispose method (animation only). Indicates how the area used by the current
// frame is to be treated before rendering the next frame on the canvas.
typedef enum WebPMuxAnimDispose {
  WEBP_MUX_DISPOSE_NONE,       // Do not dispose.
  WEBP_MUX_DISPOSE_BACKGROUND  // Dispose to background color.
} WebPMuxAnimDispose;

// Blend operation (animation only). Indicates how transparent pixels of the
// current frame are blended with those of the previous canvas.
typedef enum WebPMuxAnimBlend {
  WEBP_MUX_BLEND,              // Blend.
  WEBP_MUX_NO_BLEND            // Do not blend.
} WebPMuxAnimBlend;

`WebPDataInit()`

Inicializa o conteúdo do objeto webp_data com valores padrão.

void WebPDataInit(WebPData* webp_data);

`WebPDataClear()`

Limpa o conteúdo do objeto webp_data chamando free(). Não desalocar o objeto em si.

void WebPDataClear(WebPData* webp_data);

`WebPDataCopy()`

Aloca o armazenamento necessário para dst e copia o conteúdo de src. Retorna "true" em caso de sucesso.

int WebPDataCopy(const WebPData* src, WebPData* dst);

Documentação da API WebP Container

API Mux

Exemplos de código

Criar um MUX com dados de imagem, perfil de cores e metadados XMP

Obter dados de perfil de imagem e cor de um arquivo WebP

A vida de um objeto Mux

Enums

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

Criação de mux

WebPMuxCreate()

Blocos que não são imagem

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

Imagens

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

Animação

Parâmetros de animação

WebPMuxSetAnimationParams()

WebPMuxGetAnimationParams()

Diversos Serviços públicos

WebPMuxGetCanvasSize()

WebPMuxGetFeatures()

WebPMuxNumChunks()

WebPMuxAssemble()

API WebPAnimEncoder

WebPAnimEncoderOptionsInit()

WebPAnimEncoderNew()

WebPAnimEncoderAdd()

WebPAnimEncoderAssemble()

WebPAnimEncoderGetError()

WebPAnimEncoderDelete()

API Demux

Exemplos de código

Demuxing de dados WebP para extrair todos os frames, perfil ICC e metadados EXIF/XMP

A vida de um objeto Demux

Enums

WebPGetDemuxVersion()

WebPDemux()

WebPDemuxPartial()

WebPDemuxDelete()

Extração de dados/informações

WebPDemuxGetI()

Iteração de frames

WebPDemuxGetFrame()

WebPDemuxNextFrame(), WebPDemuxPrevFrame()

WebPDemuxSelectFragment()

WebPDemuxReleaseIterator()

Iteração de pedaços

WebPDemuxGetChunk()

WebPDemuxNextChunk(), WebPDemuxPrevChunk()

WebPDemuxReleaseChunkIterator()

API WebPAnimDecoder

WebPAnimDecoderOptionsInit()

WebPAnimDecoderNew()

WebPAnimDecoderGetInfo()

WebPAnimDecoderGetNext()

WebPAnimDecoderHasMoreFrames()

WebPAnimDecoderReset()

WebPAnimDecoderGetDemuxer()

WebPAnimDecoderDelete()

Tipos de dados comuns

Enums

WebPDataInit()

WebPDataClear()

WebPDataCopy()

`WebPGetMuxVersion()`

`WebPMuxNew()`

`WebPMuxDelete()`

`WebPMuxCreate()`

`WebPMuxSetChunk()`

`WebPMuxGetChunk()`

`WebPMuxDeleteChunk()`

`WebPMuxSetImage()`

`WebPMuxPushFrame()`

`WebPMuxGetFrame()`

`WebPMuxDeleteFrame()`

`WebPMuxSetAnimationParams()`

`WebPMuxGetAnimationParams()`

`WebPMuxGetCanvasSize()`

`WebPMuxGetFeatures()`

`WebPMuxNumChunks()`

`WebPMuxAssemble()`

`WebPAnimEncoderOptionsInit()`

`WebPAnimEncoderNew()`

`WebPAnimEncoderAdd()`

`WebPAnimEncoderAssemble()`

`WebPAnimEncoderGetError()`

`WebPAnimEncoderDelete()`

`WebPGetDemuxVersion()`

`WebPDemux()`

`WebPDemuxPartial()`

`WebPDemuxDelete()`

`WebPDemuxGetI()`

`WebPDemuxGetFrame()`

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

`WebPDemuxSelectFragment()`

`WebPDemuxReleaseIterator()`

`WebPDemuxGetChunk()`

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

`WebPDemuxReleaseChunkIterator()`

`WebPAnimDecoderOptionsInit()`

`WebPAnimDecoderNew()`

`WebPAnimDecoderGetInfo()`

`WebPAnimDecoderGetNext()`

`WebPAnimDecoderHasMoreFrames()`

`WebPAnimDecoderReset()`

`WebPAnimDecoderGetDemuxer()`

`WebPAnimDecoderDelete()`

`WebPDataInit()`

`WebPDataClear()`

`WebPDataCopy()`