Se usó la API de Cloud Translation para traducir esta página.

Documentación de la API de contenedores de WebP

Manipulación del contenedor RIFF para imágenes WebP.

API de Mux

Permite la manipulación de imágenes de contenedor WebP, con funciones como el color. perfiles, metadatos, imágenes fragmentadas y animaciones.

Ejemplos de código

Cómo crear un MUX con datos de imagen, perfil de color y metadatos 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);

Cómo obtener datos de perfil de imagen y color de un archivo 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);

La vida de un objeto Mux

Enumeraciones

// 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()`

Devuelve el número de versión de la biblioteca mux, empaquetado en hexadecimales mediante de 8 bits para cada instancia mayor/menor/revisión. P.ej., v2.5.7 es 0x020507.

int WebPGetMuxVersion(void);

`WebPMuxNew()`

Crea un objeto mux vacío.

WebPMux* WebPMuxNew(void);

Muestra: Es un puntero al objeto mux vacío que se acaba de crear.

`WebPMuxDelete()`

Borra el objeto mux.

void WebPMuxDelete(WebPMux* mux);

Parámetros: mux: objeto (dentro o fuera) que se borrará

Creación de Mux

`WebPMuxCreate()`

Crea un objeto mux a partir de datos sin procesar proporcionados en formato WebP RIFF.

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

Parámetros: bitstream: (en) los datos de flujo de bits en formato WebP RIFF; copy_data -- (dentro) el valor 1 indica que los datos dados se copiarán en el mux y el valor 0 indica que los datos NO se copiarán en el objeto mux.
Muestra: Un puntero al objeto mux creado a partir de datos determinados, en caso de éxito.; NULL: en caso de datos no válidos o error de memoria.

Fragmentos que no son imágenes

`WebPMuxSetChunk()`

Agrega un bloque con el ID fourcc y los datos chunk_data en el objeto mux. Cualquiera se eliminarán los fragmentos existentes con el mismo ID.

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

Nota: Solo los fragmentos no relacionados con imágenes se deben administrar a través de las APIs de fragmentos. (Los fragmentos relacionados con la imagen son los siguientes: "ANMF", "FRGM", "VP8", "VP8L" y "ALPH"). Para agregar, para obtener y borrar imágenes, usa WebPMuxSetImage() WebPMuxPushFrame(), WebPMuxGetFrame() y WebPMuxDeleteFrame().

Parámetros: mux: Es el objeto (entrada/salida) al que se agregará el fragmento.; fourcc: (in) es un array de caracteres que contiene el fourcc del elemento. chunk; p.ej., "ICCP", "XMP", "EXIF" etcétera; chunk_data: (dentro) del bloque de datos que se va a agregar; copy_data -- (dentro) el valor 1 indica que los datos dados se copiarán en el mux y el valor 0 indica que los datos NO se copiarán en el objeto mux.
Muestra: WEBP_MUX_INVALID_ARGUMENT: si mux, cuatrocc o compile_data es NULL o si {4}cc corresponde a un bloque de imagen.; WEBP_MUX_MEMORY_ERROR: en un error de asignación de memoria; WEBP_MUX_OK: en caso de éxito.

`WebPMuxGetChunk()`

Obtiene una referencia a los datos del bloque con el ID fourcc en el objeto mux. El llamador NO debe liberar los datos que se muestran.

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

Parámetros: mux: Es el objeto (dentro) desde el que se recuperarán los datos del fragmento.; fourcc: (in) un array de caracteres que contiene el fourcc del bloque p.ej., "ICCP", "XMP", "EXIF" etcétera; chunk_data: (fuera) los datos del fragmento devueltos
Muestra: WEBP_MUX_INVALID_ARGUMENT: si mux, cuatrocc o compile_data es NULL o si {4}cc corresponde a un bloque de imagen.; WEBP_MUX_NOT_FOUND: si mux no contiene un fragmento con la ID.; WEBP_MUX_OK: en caso de éxito.

`WebPMuxDeleteChunk()`

Borra el fragmento con el fourcc especificado del objeto mux.

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

Parámetros: mux: Es el objeto (entrada/salida) del que se borrará el fragmento.; fourcc: (in) un array de caracteres que contiene el fourcc del bloque p.ej., "ICCP", "XMP", "EXIF" etcétera
Muestra: WEBP_MUX_INVALID_ARGUMENT: si mux o cuatrocc es NULL o si cuatrocc corresponde a un bloque de imagen.; WEBP_MUX_NOT_FOUND: si mux no contiene un fragmento con la cuatro cc.; WEBP_MUX_OK: en caso de éxito.

Imágenes

Encapsula datos sobre un solo marco o 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()`

Establece la imagen (no animada y no fragmentada) en el objeto mux. Nota: Se quitarán todas las imágenes existentes (incluidos los marcos o fragmentos).

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

Parámetros: mux: Es el objeto (entrada y salida) en el que se debe establecer la imagen.; Flujo de bits: (dentro) puede ser un flujo de bits VP8/VP8L sin procesar o un WebP de una sola imagen. archivo (no animado ni fragmentado); copy_data -- (dentro) el valor 1 indica que los datos dados se copiarán en el mux y el valor 0 indica que los datos NO se copiarán en el objeto mux.
Muestra: WEBP_MUX_INVALID_ARGUMENT: Si mux es NULO o el flujo de bits es NULO.; WEBP_MUX_MEMORY_ERROR: en un error de asignación de memoria; WEBP_MUX_OK: en caso de éxito.

`WebPMuxPushFrame()`

Agrega un marco al final del objeto mux.

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

Notas:

fotograma.id debe ser uno de WEBP_CHUNK_ANMF o WEBP_CHUNK_FRGM.
Para configurar una imagen no animada no fragmentada, usa WebPMuxSetImage() en su lugar.
El tipo de marco que se inserta debe ser el mismo que los marcos de mux.
Como WebP solo admite desplazamientos pares, cualquier desplazamiento impar se ajustará a una ubicación par con: offset &= ~1

Parámetros: mux: Es el objeto (de entrada y salida) al que se agregará el marco.; frame: datos de marco (dentro).; copy_data -- (dentro) el valor 1 indica que los datos dados se copiarán en el mux y el valor 0 indica que los datos NO se copiarán en el objeto mux.
Muestra: WEBP_MUX_INVALID_ARGUMENT: si mux o marco es NULO o si el contenido de frame no es válido.; WEBP_MUX_MEMORY_ERROR: en un error de asignación de memoria; WEBP_MUX_OK: en caso de éxito.; WEBP_MUX_MEMORY_ERROR: en un error de asignación de memoria

`WebPMuxGetFrame()`

Obtiene el enésimo fotograma del objeto mux. El contenido de frame->bitstream es asignada con malloc(), y NO que sea propiedad del objeto mux. DEBE ser desasignada el llamador llamando a WebPDataClear(). enésimo=0 tiene un significado especial: última posición.

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

Parámetros: mux: Es un objeto (dentro) desde el que se recuperará la información.; nth: Es el índice (dentro) del marco del objeto mux.; frame: datos (fuera) del fotograma devuelto
Muestra: WEBP_MUX_INVALID_ARGUMENT -- if mux or frame is NULL.; WEBP_MUX_NOT_FOUND: si hay menos de enésimas tramas en el multiplexor .; WEBP_MUX_BAD_DATA: Si el bloque enésimo del fotograma de mux no es válido.; WEBP_MUX_OK: en caso de éxito.

`WebPMuxDeleteFrame()`

Elimina un fotograma del objeto mux. nth=0 tiene un significado especial: último posición.

WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);

Parámetros: mux: Es un objeto (de entrada y salida) del que se borrará un marco.; nth: (in) La posición de la que se borrará el marco
Muestra: WEBP_MUX_INVALID_ARGUMENT -- if mux is NULL.; WEBP_MUX_NOT_FOUND: si hay menos de enésimas tramas en el multiplexor el objeto antes de su eliminación.; WEBP_MUX_OK: en caso de éxito.

Animación

Parámetros de animación

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()`

Establece los parámetros de animación en el objeto mux. Cualquier bloque de ANIM existente eliminar.

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

Parámetros: mux: Es el objeto (entrada/salida) en el que se debe configurar o agregar el bloque ANIM.; params: Son parámetros de animación (dentro).
Muestra: WEBP_MUX_INVALID_ARGUMENT: Si mux o parámetros es NULO.; WEBP_MUX_MEMORY_ERROR: en un error de asignación de memoria; WEBP_MUX_OK: en caso de éxito.

`WebPMuxGetAnimationParams()`

Obtiene los parámetros de la animación del objeto mux.

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

Parámetros: mux: Es el objeto (in) desde el que se recuperarán los parámetros de la animación.; params: -- (fuera) parámetros de animación extraídos del bloque ANIM
Muestra: WEBP_MUX_INVALID_ARGUMENT: Si mux o parámetros es NULO.; WEBP_MUX_NOT_FOUND: Si el bloque ANIM no está presente en el objeto mux.; WEBP_MUX_OK: en caso de éxito.

Otros Servicios

`WebPMuxGetCanvasSize()`

Obtiene el tamaño del lienzo del objeto mux.

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

Nota: Este método supone que el fragmento de VP8X, si está presente, está actualizado. Es decir, el objeto mux no se ha modificado desde la última llamada a WebPMuxAssemble() o WebPMuxCreate().

Parámetros: mux: Es un objeto (dentro) desde el que se recuperará el tamaño del lienzo.; width: Ancho del lienzo (fuera); height: Altura del lienzo (fuera)
Muestra: WEBP_MUX_INVALID_ARGUMENT -- if mux, width or height is NULL.; WEBP_MUX_BAD_DATA: Si el tamaño del lienzo o fragmento VP8X/VP8/VP8L no es válido.; WEBP_MUX_OK: en caso de éxito.

`WebPMuxGetFeatures()`

Obtiene las marcas de función del objeto mux.

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

Parámetros: mux: Es un objeto (dentro) desde el que se recuperarán los atributos.; flags: (fuera) las marcas que especifican los atributos que están presentes en la combinación . Este será un operador OR de varios valores de marca. Enum WebPFeatureFlags para probar valores de marcas individuales.
Muestra: WEBP_MUX_INVALID_ARGUMENT -- if mux or flags is NULL.; WEBP_MUX_BAD_DATA: Si el tamaño del lienzo o fragmento VP8X/VP8/VP8L no es válido.; WEBP_MUX_OK: en caso de éxito.

`WebPMuxNumChunks()`

Obtiene el número de fragmentos que tienen el valor de etiqueta dado en el objeto mux.

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

Parámetros: mux: Es un objeto (dentro) desde el que se recuperará la información.; id: (dentro) es el ID del fragmento que especifica el tipo de fragmento.; num_elements -- (fuera) número de fragmentos con el ID de fragmento especificado
Muestra: WEBP_MUX_INVALID_ARGUMENT -- if mux, or num_elements is NULL.; WEBP_MUX_OK: en caso de éxito.

`WebPMuxAssemble()`

Ensambla todos los fragmentos en formato WebP RIFF y los muestra en assembled_data. Esta función también valida el objeto mux.

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

Nota: Se ignorará y reemplazará el contenido de seed_data. Además, el contenido de assembled_data se asigna usando malloc() y NOT que son propiedad del objeto mux. El emisor DEBE desasignarla llamando WebPDataClear()

Parámetros: mux: Es un objeto (de entrada y salida) cuyos fragmentos se deben ensamblar.; assembled_data: datos de WebP ensamblados (fuera)
Muestra: WEBP_MUX_BAD_DATA: Si el objeto mux no es válido.; WEBP_MUX_INVALID_ARGUMENT -- if mux or assembled_data is NULL.; WEBP_MUX_MEMORY_ERROR: en un error de asignación de memoria; WEBP_MUX_OK: en caso de éxito.

API de WebPAnimEncoder

Esta API permite codificar (posiblemente) imágenes WebP animadas.

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

Opciones globales

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()`

Siempre se debe llamar para inicializar un WebPAnimEncoderOptions nuevo. estructura antes de la modificación. Muestra el valor "false" en caso de que la versión no coincida. WebPAnimEncoderOptionsInit() debe funcionar correctamente antes de usar la enc_options.

Parámetros: enc_options: Opciones (entrada y salida) utilizadas para codificar animaciones
Muestra: Verdadero en caso de éxito.

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

Crea e inicializa un objeto WebPAnimEncoder.

Parámetros: width/height: (pulgadas) el ancho y la altura del lienzo de la animación.; enc_options: opciones de codificación (dentro) se le puede pasar NULL para elegir valores predeterminados razonables.
Muestra: Un puntero al objeto WebPAnimEncoder recién creado, o NULL en caso de memoria.

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

`WebPAnimEncoderAdd()`

Optimiza un fotograma determinado para WebP, codifícalo y agrégalo al WebPAnimEncoder.

La última llamada a WebPAnimEncoderAdd debe ser con frame = NULL, que indica que no se deben agregar más marcos. Esta llamada también se usa para determinar la duración del último fotograma.

Parámetros: enc: Es el objeto (de entrada y salida) al que se agregará el marco.; frame: Datos de fotogramas (de entrada y salida) en formato ARGB o YUV(A). Si está en YUV(A), se convertirá a ARGB, lo que genera una pérdida pequeña.; timestamp_ms: marca de tiempo (in) de este fotograma en milisegundos. Duración de un fotograma se calcularía como “marca de tiempo del siguiente fotograma - marca de tiempo de este marco". Por lo tanto, las marcas de tiempo no deben tener un orden decreciente.; config: opciones de codificación (dentro) se le puede pasar un valor NULL para elegir los valores predeterminados.
Muestra: Si se produce un error, muestra el valor "false" y frame->error_code está configurado correctamente. De lo contrario, muestra el valor true.

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

`WebPAnimEncoderAssemble()`

Ensambla todos los marcos agregados hasta el momento en un flujo de bits WebP. Esta llamada debería ser precedido por una llamada a WebPAnimEncoderAdd con frame = NULL De lo contrario, la duración del último fotograma se estimará internamente.

Parámetros: enc: Es el objeto (de entrada y salida) a partir del cual se deben ensamblar los marcos.; webp_data: (out) flujo de bits WebP generado.
Muestra: Verdadero en caso de éxito.

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

`WebPAnimEncoderGetError()`

Obtiene la cadena del error correspondiente a la llamada más reciente con enc. El string mostrada es propiedad de enc y es válida solo hasta que la próxima llamada a WebPAnimEncoderAdd() o WebPAnimEncoderAssemble() o WebPAnimEncoderDelete().

Parámetros: enc: Es un objeto (de entrada y salida) desde el que se debe recuperar la string de error.
Muestra: NULL if enc is NULL. De lo contrario, muestra la cadena de error si el último llamada a enc tiene un error, o una cadena vacía si la última llamada fue un el éxito.

const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);

`WebPAnimEncoderDelete()`

Borra el objeto WebPAnimEncoder.

Parámetros: enc -- (entrada/salida) que se borrará

void WebPAnimEncoderDelete(WebPAnimEncoder* enc);

API de Demux

Permite la extracción de datos de imágenes y formato extendido de archivos WebP.

Ejemplos de código

Demuxing de datos WebP para extraer todos los marcos, el perfil ICC y los metadatos 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);

La vida de un objeto Demux

Enumeraciones

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()`

Muestra el número de versión de la biblioteca demux, empaquetado en hexadecimal mediante el uso de de 8 bits para cada instancia mayor/menor/revisión. P. ej., v2.5.7 es 0x020507.

int WebPGetDemuxVersion(void);

`WebPDemux()`

Analiza el archivo WebP completo proporcionado por data.

WebPDemuxer WebPDemux(const WebPData* data);

Muestra un objeto WebPDemuxer cuando el análisis se realiza correctamente; de lo contrario, muestra NULL.

`WebPDemuxPartial()`

Analiza el archivo WebP posiblemente incompleto proporcionado por data. Si el estado es no NULL, se fijará para indicar el estado del demuxer.

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

Devuelve NULL en caso de error o si no hay suficientes datos para empezar el análisis. y un objeto WebPDemuxer tras el análisis correcto.

Ten en cuenta que WebPDemuxer mantiene punteros internos al segmento de memoria de datos. Si estos datos son volátiles, el objeto demuxer se debe eliminar (llamando a WebPDemuxDelete()) y Se volvió a llamar a WebPDemuxPartial() en los datos nuevos. Este es suele ser una operación económica.

`WebPDemuxDelete()`

Libera memoria asociada con dmux.

void WebPDemuxDelete(WebPDemuxer* dmux);

Extracción de datos/información

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()`

Obtén el valor de atributo de dmux.

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

Nota: Los valores solo son válidos si se usó WebPDemux() o WebPDemuxPartial() mostró un estado > WEBP_DEMUX_PARSING_HEADER

Iteración de fotogramas

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 el fotograma frame_number de dmux.

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

iter->fragment apunta al primer fragmento cuando se muestra de esta función. Se pueden extraer fragmentos individuales usando WebPDemuxSelectFragment() Parámetro de configuración frame_number igual a 0 mostrará el último fotograma de la imagen.

Muestra falso si dmux es NULL o el marco dmux no está presente. Llama a WebPDemuxReleaseIterator() cuando uses el el iterador esté completo.

Nota: dmux debe persistir durante la vida útil de iter.

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

Configura iter->fragment para que apunte al siguiente (iter->fragment + 1) o fotograma anterior (iter->frame_num - 1). Estas funciones no se repiten indefinidamente.

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

Muestra true si tiene éxito; de lo contrario, false.

`WebPDemuxSelectFragment()`

Configura iter->fragment para reflejar el número de fragmento iter->fragment.

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

Muestra true si el fragmento fragment_num está presente; de lo contrario, muestra false.

`WebPDemuxReleaseIterator()`

Libera cualquier memoria asociada con iter.

void WebPDemuxReleaseIterator(WebPIterator* iter);

Se debe llamar antes de cualquier llamada posterior a WebPDemuxGetChunk() en el mismo iter. Además, se deben llamado antes de destruir el objeto WebPDemuxer asociado con WebPDemuxDelete()

Iteración de fragmentos

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 la instancia chunk_number del bloque con el ID fourcc de dmux.

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

fourcc es un array de caracteres que contiene el fourcc del bloque que se desea mostrar. p.ej., "ICCP", "XMP", "EXIF", etcétera

Establecer chunk_number en 0 mostrará el último fragmento de un conjunto.

Devuelve el mensaje true si se encuentra el fragmento. De lo contrario, muestra false. Fragmento relacionado con la imagen se accede a las cargas útiles a través de WebPDemuxGetFrame() y funciones relacionadas. Llamada WebPDemuxReleaseChunkIterator() cuando se use del iterador esté completo.

Nota: dmux debe persistir durante la vida útil del iterador.

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

Configura iter->chunk para que apunte al siguiente (iter->chunk_num + 1). fragmento anterior (iter->chunk_num - 1). Estas funciones no se repiten indefinidamente.

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

Muestra true si tiene éxito; de lo contrario, false.

`WebPDemuxReleaseChunkIterator()`

Libera cualquier memoria asociada con iter.

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);

Se debe llamar antes de destruir el WebPDemuxer asociado con WebPDemuxDelete()

API de WebPAnimDecoder

Esta API permite decodificar (posiblemente) imágenes WebP animadas.

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

Opciones globales

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()`

Se debe llamar siempre para inicializar un WebPAnimDecoderOptions nuevo. estructura antes de la modificación. Muestra el valor "false" en caso de que la versión no coincida. WebPAnimDecoderOptionsInit() debe haberse realizado correctamente antes de usar la dec_options.

Parámetros

dec_options: Indica las opciones (entrada y salida) utilizadas para decodificar animación.

Muestra: Verdadero en caso de éxito

int WebPAnimDecoderOptionsInit(
    WebPAnimDecoderOptions* dec_options);

`WebPAnimDecoderNew()`

Crea y, luego, inicializa un objeto WebPAnimDecoder.

Parámetros: webp_data: Flujo de bits de WebP (dentro) Esto debería permanecer sin cambios durante la vida útil del objeto WebPAnimDecoder de salida; dec_options: Opciones de decodificación (dentro) Se puede pasar NULL para elegir valores predeterminados razonables (en particular, se elegirá el modo de color MODE_RGBA).
Muestra: Un puntero al objeto WebPAnimDecoder recién creado, o NULL en caso de análisis, opción no válida o error de memoria.

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

Información global sobre la animación.

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

`WebPAnimDecoderGetInfo()`

Obtener información global sobre la animación

Parámetros: dec: Es la instancia de decodificador (dentro) de la que se obtiene información.; info: (fuera) información global recuperada de la animación.
Muestra: Verdadero en caso de éxito.

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

`WebPAnimDecoderGetNext()`

Obtener el siguiente fotograma de dec según las opciones suministradas a WebPAnimDecoderNew() Esta será una experiencia lienzo reconstruido de un tamaño de canvas_width * 4 * canvas_height, y no solo el subrectángulo del marco. El buf del búfer que se muestra es válido solo hasta que la próxima llamada a WebPAnimDecoderGetNext(), WebPAnimDecoderReset() o WebPAnimDecoderDelete()

Parámetros: dec: instancia de decodificador (entrada/salida) desde la que se debe transmitir la siguiente trama recuperados.; buf: marco decodificado (fuera); timestamp: Es la marca de tiempo (fuera) del fotograma en milisegundos.
Muestra: Falso si alguno de los argumentos es NULO o si hay un error de análisis un error de decodificación o si no hay más tramas. De lo contrario, muestra el valor true.

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

`WebPAnimDecoderHasMoreFrames()`

Comprueba si quedan más fotogramas para decodificar.

Parámetros: dec: Es la instancia de decodificador (en) que se debe verificar.
Muestra: Verdadero si dec no es NULL y algunos marcos aún no se decodificarán. De lo contrario, muestra “false”.

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

Restablece el objeto WebPAnimDecoder, de modo que la siguiente llamada a WebPAnimDecoderGetNext() reiniciará la decodificación a partir del primer fotograma. Esto sería útil cuando es necesario decodificar todos los fotogramas varias veces (p.ej., info.loop_count, veces) sin destruir y recrear el objeto dec.

Parámetros: dec: Instancia de decodificador (entrada/salida) que se restablecerá

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

Toma el objeto demuxer interno.

Obtener el objeto demuxer puede ser útil si uno quiere usar solo operaciones disponible a través de demuxer; p.ej., para obtener metadatos XMP/EXIF/ICC. El valor devuelto el objeto demuxer es propiedad de dec y es válido solo hasta la siguiente llamada a WebPAnimDecoderDelete()

Parámetros: dec: Instancia de decodificador (en) desde la que se debe desconectar el objeto de demuxer. recuperados.

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

Borra el objeto WebPAnimDecoder.

Parámetros: dec: Instancia de decodificador (entrada/salida) que se borrará
Muestra: Verdadero en caso de éxito.

void WebPAnimDecoderDelete(WebPAnimDecoder* dec);

Tipos de datos comunes

Enumeraciones

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 el contenido del objeto webp_data con valores predeterminados.

void WebPDataInit(WebPData* webp_data);

`WebPDataClear()`

Borra el contenido del objeto webp_data llamando a free(). No anular la asignación del objeto en sí.

void WebPDataClear(WebPData* webp_data);

`WebPDataCopy()`

Asigna el almacenamiento necesario para dst y copia el contenido de src. Muestra true si tiene éxito.

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

Documentación de la API de contenedores de WebP

API de Mux

Ejemplos de código

Cómo crear un MUX con datos de imagen, perfil de color y metadatos XMP

Cómo obtener datos de perfil de imagen y color de un archivo WebP

La vida de un objeto Mux

Enumeraciones

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

Creación de Mux

WebPMuxCreate()

Fragmentos que no son imágenes

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

Imágenes

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

Animación

Parámetros de animación

WebPMuxSetAnimationParams()

WebPMuxGetAnimationParams()

Otros Servicios

WebPMuxGetCanvasSize()

WebPMuxGetFeatures()

WebPMuxNumChunks()

WebPMuxAssemble()

API de WebPAnimEncoder

WebPAnimEncoderOptionsInit()

WebPAnimEncoderNew()

WebPAnimEncoderAdd()

WebPAnimEncoderAssemble()

WebPAnimEncoderGetError()

WebPAnimEncoderDelete()

API de Demux

Ejemplos de código

Demuxing de datos WebP para extraer todos los marcos, el perfil ICC y los metadatos EXIF/XMP

La vida de un objeto Demux

Enumeraciones

WebPGetDemuxVersion()

WebPDemux()

WebPDemuxPartial()

WebPDemuxDelete()

Extracción de datos/información

WebPDemuxGetI()

Iteración de fotogramas

WebPDemuxGetFrame()

WebPDemuxNextFrame(), WebPDemuxPrevFrame()

WebPDemuxSelectFragment()

WebPDemuxReleaseIterator()

Iteración de fragmentos

WebPDemuxGetChunk()

WebPDemuxNextChunk(), WebPDemuxPrevChunk()

WebPDemuxReleaseChunkIterator()

API de WebPAnimDecoder

WebPAnimDecoderOptionsInit()

WebPAnimDecoderNew()

WebPAnimDecoderGetInfo()

WebPAnimDecoderGetNext()

WebPAnimDecoderHasMoreFrames()

WebPAnimDecoderReset()

WebPAnimDecoderGetDemuxer()

WebPAnimDecoderDelete()

Tipos de datos comunes

Enumeraciones

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()`