Esta página foi traduzida pela API Cloud Translation.

Documentação da API WebP Container

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

API Mux

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

Exemplos de código

Crie um MUX com dados de imagem, perfil de cor 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);

Vida útil 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, empacotada em hexadecimal usando 8 bits para cada principal/secundária/revisão. Por exemplo, 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: o 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: (in) os dados do bitstream no formato WebP RIFF; copy_data: (in) o valor 1 indica que os dados serão copiados para o mux, 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 a partir de dados fornecidos, em caso de sucesso.; NULL: em caso de dados inválidos ou erro de memória.

Pedaços que não são de imagem

`WebPMuxSetChunk()`

Adiciona um bloco com ID fourcc e dados chunk_data no objeto mux. Todos os blocos existentes 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 APIs de bloco. (Os blocos relacionados às imagens são: "ANMF", "FRGM", "VP8 ", "VP8L" e "ALPH"). Para adicionar, receber e excluir imagens, use 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 o quatrocc do bloco especificado. Por exemplo, "ICCP", "XMP ", "EXIF" etc.; chunk_data: (in) o bloco de dados a ser adicionado; copy_data: (in) o valor 1 indica que os dados serão copiados para o mux, 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 quatrocc corresponde a um bloco de imagem.; WEBP_MUX_MEMORY_ERROR: em erro de alocação de memória.; WEBP_MUX_OK -- em caso de sucesso.

`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: objeto (in) do qual os dados do bloco serão buscados; fourcc: (in) uma matriz de caracteres contendo o quatrocc do bloco. Por exemplo, "ICCP", "XMP ", "EXIF" etc.; chunk_data: retorna os dados de bloco
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux, Fourcc ou chunk_data for NULL ou se quatrocc corresponde a um bloco de imagem.; WEBP_MUX_NOT_FOUND: se o mux não tiver um bloco com o ID fornecido.; WEBP_MUX_OK -- em caso de sucesso.

`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 o quatrocc do bloco. Por exemplo, "ICCP", "XMP ", "EXIF" etc.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux ou Fourcc for NULL ou se Fourcc corresponder a um bloco de imagem.; WEBP_MUX_NOT_FOUND: se o mux não tiver um bloco com o fourcc especificado.; WEBP_MUX_OK -- em caso de sucesso.

Imagens

Encapsula os 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 (entrada/saída) em que a imagem será definida; bitstream: pode ser um bitstream VP8/VP8L bruto ou um arquivo WebP de imagem única (sem animação e não fragmentado).; copy_data: (in) o valor 1 indica que os dados serão copiados para o mux, 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: em erro de alocação de memória.; WEBP_MUX_OK -- em caso de sucesso.

`WebPMuxPushFrame()`

Adiciona um frame ao final do objeto mux.

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

Notes:

O frame.id precisa ser WEBP_CHUNK_ANMF ou WEBP_CHUNK_FRGM
Para definir uma imagem não fragmentada e não animada, use WebPMuxSetImage().
O tipo de frame sendo empurrado deve ser o mesmo que os frames no mux.
Como o WebP só oferece suporte a deslocamentos pares, qualquer deslocamento ímpar será ajustado a um local par usando: offset &= ~1

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

`WebPMuxGetFrame()`

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

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

Parâmetros: mux: objeto (em) em que as informações serão buscadas; nth: índice (in) do frame no objeto mux; frame: dados (fora) do frame retornado.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se o multiplex ou o frame for NULL.; WEBP_MUX_NOT_FOUND: se houver menos de enésimos frames no objeto mux.; WEBP_MUX_BAD_DATA: se o enésimo fragmento do frame no mux for inválido.; WEBP_MUX_OK -- em caso de sucesso.

`WebPMuxDeleteFrame()`

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

WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);

Parâmetros: mux: o objeto (entrada/saída) do qual um frame será excluído.; nth: (in) a posição em que o frame será excluído.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se o mux for NULL.; WEBP_MUX_NOT_FOUND: se houver menos de enésimos frames no objeto mux antes da exclusão.; WEBP_MUX_OK -- em caso de sucesso.

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. Os blocos ANIM atuais serão removidos.

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

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

`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: parâmetros de animação (out) extraídos do bloco ANIM
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux ou params for NULL.; WEBP_MUX_NOT_FOUND: se um fragmento de ANIM não estiver presente no objeto mux.; WEBP_MUX_OK -- em caso de sucesso.

Utilitários diversos

`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 (em) em que o tamanho da tela será buscado.; width: largura (fora) da tela; height: altura (fora) da tela
Retorna: WEBP_MUX_INVALID_ARGUMENT: se o mux, a largura ou a altura for NULL.; WEBP_MUX_BAD_DATA: se o tamanho do bloco ou da tela VP8X/VP8/VP8L for inválido.; WEBP_MUX_OK -- em caso de sucesso.

`WebPMuxGetFeatures()`

Recebe as flags de recursos do objeto mux.

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

Parâmetros: mux: (em) objeto em que os recursos serão buscados; flags: (fora) as flags que especificam quais recursos estão presentes no objeto mux. Esse valor será um OR de vários valores de sinalização. O enumeração WebPFeatureFlags pode ser usado para testar valores de sinalização individuais.
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux ou flags for NULL.; WEBP_MUX_BAD_DATA: se o tamanho do bloco ou da tela VP8X/VP8/VP8L for inválido.; WEBP_MUX_OK -- em caso de sucesso.

`WebPMuxNumChunks()`

Recebe o número de blocos que têm o valor da tag especificado no objeto mux.

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

Parâmetros: mux: objeto (em) em que as informações serão buscadas; id -- ID do bloco (in) especificando o tipo de bloco; num_elements: número (out) de blocos com o ID de bloco especificado
Retorna: WEBP_MUX_INVALID_ARGUMENT: se mux ou num_elementos forem NULL.; WEBP_MUX_OK -- em caso de sucesso.

`WebPMuxAssemble()`

Monta 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 NÃO pertencente ao objeto mux. Ele PRECISA ser desalocado pelo autor da chamada chamando WebPDataClear().

Parâmetros: mux: o objeto (de entrada/saída) cujos pedaços serão montados; assembled_data: (out) dados WebP reunidos
Retorna: WEBP_MUX_BAD_DATA: se o objeto mux for inválido.; WEBP_MUX_INVALID_ARGUMENT: se mux ou assembled_data for NULL.; WEBP_MUX_MEMORY_ERROR: em erro de alocação de memória.; WEBP_MUX_OK -- em caso de sucesso.

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 uma nova estrutura WebPAnimEncoderOptions antes da modificação. Retorna falso em caso de incompatibilidade de versão. WebPAnimEncoderOptionsInit() precisa ser bem-sucedido antes de usar o objeto enc_options.

Parâmetros: enc_options: opções (in/out) usadas para codificar animação
Retorna: Verdadeiro em caso de sucesso.

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

Cria e inicializa um objeto WebPAnimEncoder.

Parâmetros: width/height: (pol) largura e altura da tela da animação.; enc_options: (in) opções de codificação. Pode ser transmitido como NULL para escolher padrões razoáveis.
Retorna: Um ponteiro para o objeto WebPAnimEncoder recém-criado ou NULL em caso de erro de memória.

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

`WebPAnimEncoderAdd()`

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

A última chamada para WebPAnimEncoderAdd precisa ser usando frame = NULL, o que indica que não há mais frames a serem adicionados. Essa chamada também é usada para determinar a duração do último frame.

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

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

`WebPAnimEncoderAssemble()`

Monte todos os frames adicionados até agora em um bitstream WebP. Essa chamada precisa ser precedida por uma chamada para WebPAnimEncoderAdd com frame = NULL. Caso contrário, a duração do último frame será estimada internamente.

Parâmetros: enc: o objeto (de entrada/saída) do qual os frames serão montados.; webp_data: (out) gerado o bitstream WebP.
Retorna: Verdadeiro em caso de sucesso.

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(), WebPAnimEncoderAssemble() ou WebPAnimEncoderDelete().

Parâmetros: enc: objeto (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 a última chamada para enc tiver um erro ou uma string vazia se a última chamada tiver sido bem-sucedida.

const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);

`WebPAnimEncoderDelete()`

Exclui o objeto WebPAnimEncoder.

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

void WebPAnimEncoderDelete(WebPAnimEncoder* enc);

API Demux

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

Exemplos de código

Usar dados WebP para extrair todos os frames, o perfil ICC e os 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, empacotada em hexadecimal usando 8 bits para cada principal/secundária/revisão. Por exemplo, 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 não for 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 em uma análise bem-sucedida.

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

`WebPDemuxDelete()`

Libera a memória associada ao 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()`

Encontre o valor de feature no dmux.

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

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

Iteração do frame

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 de dmux.

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

iter->fragment aponta para o primeiro fragmento quando essa função é retornada. Fragmentos individuais podem ser extraídos usando WebPDemuxSelectFragment(). Definir frame_number igual a 0 retornará o último frame da imagem.

Retorna "false" se dmux é NULL ou se o frame_number do frame não está presente. Chame WebPDemuxReleaseIterator() quando o uso do iterador for concluído.

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

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

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

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

Retorna verdadeiro em caso de sucesso. Caso contrário, retorna falso.

`WebPDemuxSelectFragment()`

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

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

Retorna verdadeiro se o fragmento fragment_num estiver presente. Caso contrário, será falso.

`WebPDemuxReleaseIterator()`

Libera qualquer memória associada a iter.

void WebPDemuxReleaseIterator(WebPIterator* iter);

Precisa ser chamado antes de qualquer chamada subsequente para WebPDemuxGetChunk() no mesmo iteração. Além disso, ele precisa ser chamado antes de destruir o WebPDemuxer associado com WebPDemuxDelete().

Iteração em 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 de dmux.

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

fourcc é uma matriz de caracteres contendo o 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 verdadeiro se o bloco for encontrado. Caso contrário, retorna falso. Os payloads de blocos relacionados à imagem são acessados por meio de WebPDemuxGetFrame() e funções relacionadas. Chame WebPDemuxReleaseChunkIterator() quando o uso do iterador for concluído.

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

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

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

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

Retorna verdadeiro em caso de sucesso. Caso contrário, retorna falso.

`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 decodificar (possivelmente) 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 uma nova estrutura WebPAnimDecoderOptions antes da modificação. Retorna falso em caso de incompatibilidade de versão. WebPAnimDecoderOptionsInit() precisa ser bem-sucedido antes de usar o objeto dec_options.

Parâmetros

dec_options: opções (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 precisa permanecer inalterado durante o ciclo de vida do objeto WebPAnimDecoder de saída.; dec_options -- (in) opções de decodificação. Pode ser transmitido como NULL para escolher padrões razoáveis. Em particular, o modo de cor MODE_RGBA será escolhido.
Retorna: Um ponteiro para o objeto WebPAnimDecoder recém-criado ou NULL em caso 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()`

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

Parâmetros: dec: (in) instância do decodificador da qual receber informações.; info: informações globais (fora) buscadas na animação.
Retorna: Verdadeiro em caso de sucesso.

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

`WebPAnimDecoderGetNext()`

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

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

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

`WebPAnimDecoderHasMoreFrames()`

Verifique se restam mais frames para decodificar.

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

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

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

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

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

Pegue o objeto de multiplexador interno.

Conseguir o objeto de multiplexador pode ser útil se você quiser usar operações disponíveis apenas por meio do demuxer, por exemplo, para receber metadados XMP/EXIF/ICC. O objeto demuxer retornado pertence a dec e é válido somente até a próxima chamada para WebPAnimDecoderDelete().

Parâmetros: dec: é a instância (in) do decodificador de onde o objeto de multiplexador será buscado.

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

Exclui o objeto WebPAnimDecoder.

Parâmetros: dec: a instância do decodificador (entrada/saída) a ser excluída.
Retorna: Verdadeiro em caso de sucesso.

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 desaloca 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 verdadeiro em caso de sucesso.

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

Documentação da API WebP Container

API Mux

Exemplos de código

Crie um MUX com dados de imagem, perfil de cor e metadados XMP.

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

Vida útil de um objeto Mux

Enums

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

Criação de Mux

WebPMuxCreate()

Pedaços que não são de imagem

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

Imagens

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

Animação

Parâmetros de animação

WebPMuxSetAnimationParams()

WebPMuxGetAnimationParams()

Utilitários diversos

WebPMuxGetCanvasSize()

WebPMuxGetFeatures()

WebPMuxNumChunks()

WebPMuxAssemble()

API WebPAnimEncoder

WebPAnimEncoderOptionsInit()

WebPAnimEncoderNew()

WebPAnimEncoderAdd()

WebPAnimEncoderAssemble()

WebPAnimEncoderGetError()

WebPAnimEncoderDelete()

API Demux

Exemplos de código

Usar dados WebP para extrair todos os frames, o perfil ICC e os metadados EXIF/XMP

A vida de um objeto Demux

Enums

WebPGetDemuxVersion()

WebPDemux()

WebPDemuxPartial()

WebPDemuxDelete()

Extração de dados/informações

WebPDemuxGetI()

Iteração do frame

WebPDemuxGetFrame()

WebPDemuxNextFrame(), WebPDemuxPrevFrame()

WebPDemuxSelectFragment()

WebPDemuxReleaseIterator()

Iteração em 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()`