Questa pagina è stata tradotta dall'API Cloud Translation.

Documentazione sull'API WebP Container

Manipolazione del container RIFF per le immagini WebP.

API Mux

Consente di manipolare le immagini container WebP, contenenti funzionalità come il colore profilo, metadati, animazione e immagini frammentate.

Esempi di codice

Creazione di un MUX con dati di immagine, profilo di colore e metadati 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);

Recupera i dati dei profili di immagini e colori da un file 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);

Vita di un oggetto Mux

Enum

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

Restituisce il numero di versione della libreria Mux, pacchettizzato in esadecimale utilizzando 8 bit per ciascuna di queste operazioni. Ad esempio, la versione 2.5.7 è 0x020507.

int WebPGetMuxVersion(void);

`WebPMuxNew()`

Crea un oggetto mux vuoto.

WebPMux* WebPMuxNew(void);

Resi: Un puntatore all'oggetto mux vuoto appena creato.

`WebPMuxDelete()`

Elimina l'oggetto mux.

void WebPMuxDelete(WebPMux* mux);

Parametri: mux -- (in/out) oggetto da eliminare

Creazione Mux

`WebPMuxCreate()`

Crea un oggetto mux dai dati non elaborati forniti nel formato WebP RIFF.

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

Parametri: bitstream -- (in) i dati bitstream in formato WebP RIFF; copy_data -- Il valore (in) 1 indica che i dati dati VERRANNO copiati nel mux mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Resi: Un puntatore all'oggetto mux creato da determinati dati, se l'operazione è andata a buon fine.; NULL: in caso di dati non validi o errore di memoria.

Blocchi non immagine

`WebPMuxSetChunk()`

Aggiunge un blocco con ID fourcc e dati chunk_data nell'oggetto mux. Qualsiasi blocchi esistenti con lo stesso ID saranno rimossi.

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

Nota: solo i blocchi non correlati alle immagini devono essere gestiti tramite API di blocchi. I blocchi correlati alle immagini sono: "ANMF", "FRGM", "VP8", "VP8L" e "ALPH". Per aggiungere, scaricare ed eliminare immagini, utilizzare WebPMuxSetImage() WebPMuxPushFrame(), WebPMuxGetFrame() e WebPMuxDeleteFrame().

Parametri: mux -- oggetto (in/out) a cui deve essere aggiunto il blocco; fourcc -- (in) un array di caratteri contenente il fourcc del dato chunk; ad es. "ICCP", "XMP", "EXIF" ecc.; chunk_data: (nel) il blocco di dati da aggiungere; copy_data -- Il valore (in) 1 indica che i dati dati VERRANNO copiati nel mux mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Resi: WEBP_MUX_INVALID_ARGUMENT: se mux, fourcc o chunk_data è NULL o se quattrocc corrisponde a un blocco di immagini.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxGetChunk()`

Restituisce un riferimento ai dati del blocco con ID fourcc nell'oggetto mux. Il chiamante NON deve liberare i dati restituiti.

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

Parametri: mux -- (in) oggetto da cui devono essere recuperati i dati del blocco; fourcc -- (in) un array di caratteri contenente il fourcc del blocco; ad es. "ICCP", "XMP", "EXIF" ecc.; chunk_data -- (out) ha restituito i dati del blocco
Resi: WEBP_MUX_INVALID_ARGUMENT: se mux, fourcc o chunk_data è NULL o se quattrocc corrisponde a un blocco di immagini.; WEBP_MUX_NOT_FOUND -- Se mux non contiene un blocco con il valore specificato ID.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxDeleteChunk()`

Elimina il blocco con il valore fourcc specificato dall'oggetto mux.

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

Parametri: mux -- oggetto (in/out) da cui deve essere eliminato il blocco; fourcc -- (in) un array di caratteri contenente il fourcc del blocco; ad es. "ICCP", "XMP", "EXIF" ecc.
Resi: WEBP_MUX_INVALID_ARGUMENT: se mux o fourcc è NULL o se quattrocc corrisponde a un blocco di immagini.; WEBP_MUX_NOT_FOUND -- Se mux non contiene un blocco con il valore specificato quattro cc.; WEBP_MUX_OK: sulla riuscita.

Immagini

Incapsula i dati relativi a un singolo frame/frammento.

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

Imposta l'immagine (non animata e non frammentata) nell'oggetto mux. Nota: tutte le immagini esistenti (inclusi cornici/frammenti) verranno rimosse.

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

Parametri: mux -- oggetto (in/out) in cui deve essere impostata l'immagine; bitstream: (in) può essere un flusso di bit VP8/VP8L non elaborato o un WebP a immagine singola file (non animato e non frammentato); copy_data -- Il valore (in) 1 indica che i dati dati VERRANNO copiati nel mux mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Resi: WEBP_MUX_INVALID_ARGUMENT: se mux è NULL o bitstream è NULL.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxPushFrame()`

Aggiunge un frame alla fine dell'oggetto mux.

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

Note:

frame.id deve essere WEBP_CHUNK_ANMF o WEBP_CHUNK_FRGM
Per impostare un'immagine non animata non frammentata, utilizza WebPMuxSetImage().
Il tipo di frame sottoposto a push deve essere lo stesso dei frame nel mux.
Poiché WebP supporta solo gli offset pari, qualsiasi offset dispari verrà agganciato in una posizione uniforme utilizzando: offset &= ~1

Parametri: mux -- oggetto (in/out) a cui va aggiunto il frame.; frame: dati del frame (in).; copy_data -- Il valore (in) 1 indica che i dati dati VERRANNO copiati nel mux mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Resi: WEBP_MUX_INVALID_ARGUMENT: se mux o frame sono NULL o se i contenuti di frame non è valido.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: sulla riuscita.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.

`WebPMuxGetFrame()`

Ottiene l'ennesimo frame dall'oggetto mux. Il contenuto di frame->bitstream è allocati utilizzando Malloc() e NON di proprietà dell'oggetto mux. DEVE essere gestito dal chiamante chiamando il numero WebPDataClear(). nth=0 ha un significato speciale: l'ultima posizione.

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

Parametri: mux -- (in) oggetto da cui devono essere recuperate le informazioni; nth -- (in) indice del frame nell'oggetto mux; frame -- dati (out) del frame restituito
Resi: WEBP_MUX_INVALID_ARGUMENT -- if mux or frame is NULL.; WEBP_MUX_NOT_FOUND: se ci sono meno di ennesimi frame nel mux .; WEBP_MUX_BAD_DATA: se l'ennesimo blocco di frame nel mux non è valido.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxDeleteFrame()`

Elimina un frame dall'oggetto mux. nth=0 ha un significato speciale - ultimo posizione.

WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);

Parametri: mux -- oggetto (in/out) dal quale deve essere eliminato un frame.; nth -- (in) La posizione da cui deve essere eliminato il frame.
Resi: WEBP_MUX_INVALID_ARGUMENT -- if mux is NULL.; WEBP_MUX_NOT_FOUND: se il mux contiene meno di n° frame prima dell'eliminazione.; WEBP_MUX_OK: sulla riuscita.

Animazione

Parametri animazione

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

Imposta i parametri di animazione nell'oggetto mux. Eventuali blocchi ANIM esistenti rimosso.

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

Parametri: mux -- (in/out) oggetto in cui deve essere impostato/aggiunto il blocco ANIM; params: parametri dell'animazione (in).
Resi: WEBP_MUX_INVALID_ARGUMENT: se mux o params è NULL.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxGetAnimationParams()`

Restituisce i parametri di animazione dall'oggetto mux.

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

Parametri: mux -- (in) oggetto da cui recuperare i parametri di animazione; params -- parametri dell'animazione (out) estratti dal blocco ANIM
Resi: WEBP_MUX_INVALID_ARGUMENT: se mux o params è NULL.; WEBP_MUX_NOT_FOUND: se il blocco ANIM non è presente nell'oggetto mux.; WEBP_MUX_OK: sulla riuscita.

Varie Utenze

`WebPMuxGetCanvasSize()`

Ottiene le dimensioni del canvas dall'oggetto mux.

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

Nota: questo metodo presuppone che il blocco VP8X, se presente, sia aggiornato. Ciò significa che l'oggetto mux non è stato modificato dall'ultima chiamata a WebPMuxAssemble() oppure WebPMuxCreate().

Parametri: mux -- (in) oggetto da cui deve essere recuperata la dimensione del canvas; width: larghezza (esterno) del canvas; height -- (out) altezza canvas
Resi: WEBP_MUX_INVALID_ARGUMENT -- if mux, width or height is NULL.; WEBP_MUX_BAD_DATA: se la dimensione del blocco o del canvas VP8X/VP8/VP8L non è valida.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxGetFeatures()`

Ottiene i flag delle caratteristiche dall'oggetto mux.

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

Parametri: mux -- (in) oggetto da cui devono essere recuperate le caratteristiche; flags -- (out) i flag che specificano quali caratteristiche sono presenti nel mux . Sarà un OR di vari valori di flag. Enum WebPFeatureFlags può essere usato per testare singoli valori di flag.
Resi: WEBP_MUX_INVALID_ARGUMENT -- if mux or flags is NULL.; WEBP_MUX_BAD_DATA: se la dimensione del blocco o del canvas VP8X/VP8/VP8L non è valida.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxNumChunks()`

Restituisce il numero di blocchi con il valore di tag specificato nell'oggetto mux.

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

Parametri: mux -- (in) oggetto da cui devono essere recuperate le informazioni; id -- (in) ID blocco che specifica il tipo di blocco; num_elements -- (out) numero di blocchi con l'ID blocco specificato
Resi: WEBP_MUX_INVALID_ARGUMENT -- if mux, or num_elements is NULL.; WEBP_MUX_OK: sulla riuscita.

`WebPMuxAssemble()`

Raccoglie tutti i blocchi in formato RIFF WebP e restituisce in assembled_data. Questa funzione convalida anche l'oggetto mux.

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

Nota: i contenuti di assembled_data verranno ignorati e sovrascritti. Inoltre, il contenuto di assembled_data viene allocato utilizzando Malloc() e NON di proprietà dell'oggetto mux. DEVE essere assegnato dal chiamante chiamando WebPDataClear()

Parametri: mux -- oggetto (in/out) i cui blocchi devono essere assemblati; assembled_data: dati WebP assemblati (out)
Resi: WEBP_MUX_BAD_DATA: se l'oggetto mux non è valido.; WEBP_MUX_INVALID_ARGUMENT -- if mux or assembled_data is NULL.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: sulla riuscita.

API WebPAnimEncoder

Questa API consente la codifica (possibilmente) di immagini WebP animate.

Esempio di codice

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.

Opzioni globali

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

Deve sempre essere chiamato per inizializzare una nuova funzione WebPAnimEncoderOptions struttura prima di apportare modifiche. Restituisce false in caso di mancata corrispondenza della versione. WebPAnimEncoderOptionsInit() deve essere riuscito prima di utilizzare la funzione enc_options.

Parametri: enc_options: opzioni (in/out) utilizzate per la codifica dell'animazione
Resi: Vero per il successo.

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

Crea e inizializza un oggetto WebPAnimEncoder.

Parametri: width/height: la larghezza e l'altezza del canvas (in) dell'animazione.; enc_options -- (in) opzioni di codifica; può essere passato NULL per la scelta valori predefiniti ragionevoli.
Resi: Un puntatore all'oggetto WebPAnimEncoder appena creato o NULL in caso di errore di memoria.

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

`WebPAnimEncoderAdd()`

Ottimizza il frame dato per WebP, codificalo e aggiungilo al WebPAnimEncoder.

L'ultima chiamata a WebPAnimEncoderAdd deve essere con frame = NULL, che indica che non è necessario aggiungere altri frame. Questa chiamata viene utilizzata anche determinano la durata dell'ultimo frame.

Parametri: enc -- oggetto (in/out) a cui deve essere aggiunto il frame.; frame: dati del frame (in/out) in formato ARGB o YUV(A). Se è in YUV(A), verrà convertito in ARGB, il che comporta una piccola perdita.; timestamp_ms: (in) timestamp di questo frame in millisecondi. Durata di un frame viene calcolato come "timestamp del frame successivo - timestamp delle questo frame". Pertanto, i timestamp devono essere in ordine non decrescente.; config -- (in) opzioni di codifica; può essere passato NULL per scegliere i valori predefiniti.
Resi: In caso di errore, restituisce false e frame->error_code è impostato correttamente. In caso contrario, restituisce true.

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

`WebPAnimEncoderAssemble()`

Assembla tutti i frame aggiunti finora in un flusso di bit WebP. Questa chiamata deve essere preceduta da una chiamata a WebPAnimEncoderAdd con frame = NULL. In caso contrario, la durata dell'ultimo frame verrà stimata internamente.

Parametri: enc -- (in/out) oggetto da cui devono essere assemblati i frame.; webp_data: bitstream WebP generato (in uscita).
Resi: vero per il successo.

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

`WebPAnimEncoderGetError()`

Ottieni la stringa di errore corrispondente alla chiamata più recente utilizzando enc. La la stringa restituita è di proprietà di enc ed è valida solo fino alla successiva chiamata a WebPAnimEncoderAdd() oppure WebPAnimEncoderAssemble() oppure WebPAnimEncoderDelete()

Parametri: enc -- (in/out) oggetto da cui deve essere recuperata la stringa di errore.
Resi: NULL if enc is NULL. In caso contrario, restituisce la stringa di errore se l'ultima di chiamata a enc contiene un errore oppure una stringa vuota se l'ultima chiamata era successo.

const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);

`WebPAnimEncoderDelete()`

Elimina l'oggetto WebPAnimEncoder.

Parametri: enc -- (in/out) oggetto da eliminare

void WebPAnimEncoderDelete(WebPAnimEncoder* enc);

API Demux

Consente l'estrazione di dati di immagini e formati estesi dai file WebP.

Esempi di codice

Demuxing dei dati WebP per estrarre tutti i frame, il profilo ICC e i metadati 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);

Vita di un oggetto Demux

Enum

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

Restituisce il numero di versione della libreria demux, pacchettizzato in esadecimale utilizzando 8 bit per ciascuna di queste operazioni. Ad esempio, la versione 2.5.7 è 0x020507.

int WebPGetDemuxVersion(void);

`WebPDemux()`

Analizza l'intero file WebP fornito da data.

WebPDemuxer WebPDemux(const WebPData* data);

Restituisce un oggetto WebPDemuxer in caso di analisi riuscita, NULL negli altri casi.

`WebPDemuxPartial()`

Analizza il file WebP potenzialmente incompleto fornito da data. Se stato è non NULL sarà impostato per indicare lo stato del demuxer.

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

Restituisce NULL in caso di errore o se non sono disponibili dati sufficienti per avviare l'analisi. e un oggetto WebPDemuxer all'analisi riuscita.

Tieni presente che WebPDemuxer mantiene i puntatori interni al segmento di memoria dati. Se se sono volatili, l'oggetto demuxer dovrebbe essere eliminato (chiamando WebPDemuxDelete()) e WebPDemuxPartial() ha chiamato di nuovo in base ai nuovi dati. Questo è di solito è un'operazione economica.

`WebPDemuxDelete()`

Libera la memoria associata a dmux.

void WebPDemuxDelete(WebPDemuxer* dmux);

Estrazione di dati/informazioni

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

Ottieni il valore feature da dmux.

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

Nota: i valori sono validi solo se è stato utilizzato WebPDemux() o WebPDemuxPartial() ha restituito uno stato > WEBP_DEMUX_PARSING_HEADER.

Iterazione 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 il frame frame_number da dmux.

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

iter->fragment punta al primo frammento quando viene restituito da questa funzione. I singoli frammenti possono essere estratti utilizzando WebPDemuxSelectFragment() Impostazione frame_number uguale a 0 restituirà l'ultimo frame dell'immagine.

Restituisce false se dmux è NULL o se il frame dmux non è presente. Chiama WebPDemuxReleaseIterator() quando utilizzi completo dell'iteratore.

Nota: dmux deve essere mantenuto per tutta la durata di iter.

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

Imposta iter->fragment per puntare al successivo (iter->fragment + 1) oppure precedente (iter->frame_num - 1). Queste funzioni non sono in loop.

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

Restituisce true in caso di esito positivo, false in caso contrario.

`WebPDemuxSelectFragment()`

Imposta iter->fragment per riflettere il numero di frammento iter->fragment.

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

Restituisce true se è presente il frammento fragment_num, false in caso contrario.

`WebPDemuxReleaseIterator()`

Rilascia qualsiasi memoria associata a iter.

void WebPDemuxReleaseIterator(WebPIterator* iter);

Deve essere richiamata prima di qualsiasi chiamata successiva a WebPDemuxGetChunk() sullo stesso iter. Inoltre, deve essere prima di eliminare l'elemento WebPDemuxer associato WebPDemuxDelete()

Iterazione chunk

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 l'istanza chunk_number del blocco con ID fourcc da dmux.

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

fourcc è un array di caratteri contenente il fourcc del blocco da restituire, ad es. "ICCP", "XMP", "EXIF" e così via.

L'impostazione di chunk_number uguale a 0 restituirà l'ultimo blocco di un insieme.

Restituisce true se il blocco viene trovato, false in caso contrario. Blocco correlato all'immagine i payload sono accessibili tramite WebPDemuxGetFrame() e funzioni correlate. Chiama WebPDemuxReleaseChunkIterator() quando viene utilizzato dell'iteratore è completo.

Nota: dmux deve essere mantenuto per tutta la durata dell'iteratore.

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

Imposta iter->chunk per puntare al successivo (iter->chunk_num + 1) oppure precedente (iter->chunk_num - 1). Queste funzioni non sono in loop.

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

Restituisce true in caso di esito positivo, false in caso contrario.

`WebPDemuxReleaseChunkIterator()`

Rilascia qualsiasi memoria associata a iter.

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);

Deve essere chiamato prima di eliminare l'elemento WebPDemuxer associato con WebPDemuxDelete()

API WebPAnimDecoder

Questa API consente la decodifica (possibilmente) di immagini WebP animate.

Esempio di codice

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.

Opzioni globali

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

Deve sempre essere chiamato per inizializzare una nuova funzione WebPAnimDecoderOptions struttura prima di apportare modifiche. Restituisce false in caso di mancata corrispondenza della versione. WebPAnimDecoderOptionsInit() deve essere riuscito prima di utilizzare la funzione dec_options.

Parametri

dec_options: opzioni (in/out) utilizzate per la decodifica dell'animazione.

Resi: Vero per il successo

int WebPAnimDecoderOptionsInit(
    WebPAnimDecoderOptions* dec_options);

`WebPAnimDecoderNew()`

Crea e inizializza un oggetto WebPAnimDecoder.

Parametri: webp_data -- (in) bitstream WebP. Questo dovrebbe rimanere invariato durante la durata dell'oggetto WebPAnimDecoder di output.; dec_options: opzioni di decodifica (in). Può essere passato NULL per la scelta valori predefiniti ragionevoli (in particolare verrà selezionata la modalità colore MODE_RGBA).
Resi: Un puntatore all'oggetto WebPAnimDecoder appena creato o NULL in caso di errore di errore di analisi, opzione non valida o errore di memoria.

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

Informazioni globali sull'animazione.

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

`WebPAnimDecoderGetInfo()`

Visualizza informazioni globali sull'animazione.

Parametri: dec -- (in) istanza decoder da cui ottenere informazioni.; info: informazioni globali recuperate dall'animazione.
Resi: vero per il successo.

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

`WebPAnimDecoderGetNext()`

Recupera il frame successivo da dec in base alle opzioni fornite a WebPAnimDecoderNew() Si tratta di un'esperienza tela ricostruita di dimensioni canvas_width * 4 * canvas_height e non solo sotto il rettangolo del frame. Il buffer buf restituito è valido solo fino a quando prossima chiamata a WebPAnimDecoderGetNext(), WebPAnimDecoderReset() oppure WebPAnimDecoderDelete()

Parametri: dec -- istanza decoder (in/out) da cui deve essere il frame successivo viene recuperato.; buf: frame decodificato (out).; timestamp -- (out) timestamp del frame in millisecondi.
Resi: False se uno degli argomenti è NULL o se è presente un'analisi di decodifica o se non ci sono altri frame. In caso contrario, restituisce true.

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

`WebPAnimDecoderHasMoreFrames()`

Controlla se ci sono altri frame da decodificare.

Parametri: dec: (in) l'istanza decoder da controllare.
Resi: True se dec non è NULL e alcuni frame devono ancora essere decodificati. In caso contrario, restituisce il valore False.

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

Reimposta l'oggetto WebPAnimDecoder, in modo che la chiamata successiva a WebPAnimDecoderGetNext() riavvierà la decodifica dal primo frame. Questo è utile quando tutti i frame devono essere decodificati più volte (ad es. info.loop_count volte) senza distruggere e ricreare l'oggetto dec.

Parametri: dec -- (in/out) dell'istanza decoder da reimpostare

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

Afferra l'oggetto demuxer interno.

Ottenere l'oggetto demuxer può essere utile se si vuole usare solo le operazioni disponibili tramite demuxer; ad es. per ottenere i metadati XMP/EXIF/ICC. L'oggetto restituito l'oggetto demuxer è di proprietà di dec ed è valido solo fino alla successiva chiamata a WebPAnimDecoderDelete()

Parametri: dec -- (in) istanza decoder da cui deve essere l'oggetto demuxer viene recuperato.

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

Elimina l'oggetto WebPAnimDecoder.

Parametri: dec -- (in/out) dell'istanza decoder da eliminare.
Resi: Vero per il successo.

void WebPAnimDecoderDelete(WebPAnimDecoder* dec);

Tipi di dati comuni

Enum

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

Inizializza i contenuti dell'oggetto webp_data con i valori predefiniti.

void WebPDataInit(WebPData* webp_data);

`WebPDataClear()`

Cancella i contenuti dell'oggetto webp_data richiamando free(). Non deallocare l'oggetto stesso.

void WebPDataClear(WebPData* webp_data);

`WebPDataCopy()`

Alloca lo spazio di archiviazione necessario per dst e copia i contenuti di src. Restituisce true in caso di esito positivo.

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

Documentazione sull'API WebP Container

API Mux

Esempi di codice

Creazione di un MUX con dati di immagine, profilo di colore e metadati XMP

Recupera i dati dei profili di immagini e colori da un file WebP

Vita di un oggetto Mux

Enum

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

Creazione Mux

WebPMuxCreate()

Blocchi non immagine

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

Immagini

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

Animazione

Parametri animazione

WebPMuxSetAnimationParams()

WebPMuxGetAnimationParams()

Varie Utenze

WebPMuxGetCanvasSize()

WebPMuxGetFeatures()

WebPMuxNumChunks()

WebPMuxAssemble()

API WebPAnimEncoder

WebPAnimEncoderOptionsInit()

WebPAnimEncoderNew()

WebPAnimEncoderAdd()

WebPAnimEncoderAssemble()

WebPAnimEncoderGetError()

WebPAnimEncoderDelete()

API Demux

Esempi di codice

Demuxing dei dati WebP per estrarre tutti i frame, il profilo ICC e i metadati EXIF/XMP

Vita di un oggetto Demux

Enum

WebPGetDemuxVersion()

WebPDemux()

WebPDemuxPartial()

WebPDemuxDelete()

Estrazione di dati/informazioni

WebPDemuxGetI()

Iterazione frame

WebPDemuxGetFrame()

WebPDemuxNextFrame(), WebPDemuxPrevFrame()

WebPDemuxSelectFragment()

WebPDemuxReleaseIterator()

Iterazione chunk

WebPDemuxGetChunk()

WebPDemuxNextChunk(), WebPDemuxPrevChunk()

WebPDemuxReleaseChunkIterator()

API WebPAnimDecoder

WebPAnimDecoderOptionsInit()

WebPAnimDecoderNew()

WebPAnimDecoderGetInfo()

WebPAnimDecoderGetNext()

WebPAnimDecoderHasMoreFrames()

WebPAnimDecoderReset()

WebPAnimDecoderGetDemuxer()

WebPAnimDecoderDelete()

Tipi di dati comuni

Enum

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