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 profilo colore, metadati, animazioni e immagini frammentate.

Esempi di codice

Crea una MUX con dati di immagini, profilo 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);

Ottenere dati di profilo 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, pacchettizzata in formato esadecimale utilizzando 8 bit per ciascuna delle righe principali/minori/revisioni. Ad esempio, la versione 2.5.7 è 0x020507.

int WebPGetMuxVersion(void);

`WebPMuxNew()`

Crea un oggetto mux vuoto.

WebPMux* WebPMuxNew(void);

Ritorni: 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 da dati non elaborati in formato WebP RIFF.

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

Parametri: bitstream -- (nei) dati bitstream in formato WebP RIFF; copy_data: il valore (in) 1 indica che i dati specificati VERRANNO copiati nel mux, mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Ritorni: Un puntatore all'oggetto mux creato a partire da dati specifici, in caso di esito positivo.; NULL: in caso di dati non validi o errore di memoria.

Blocchi non di immagine

`WebPMuxSetChunk()`

Aggiunge un blocco con ID fourcc e i dati chunk_data nell'oggetto mux. Eventuali blocchi esistenti con lo stesso ID verranno 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 per blocchi. (I blocchi correlati all'immagine sono: "ANMF", "FRGM", "VP8 ", "VP8L" e "ALPH"). Per aggiungere, recuperare ed eliminare immagini, utilizza WebPMuxSetImage(), WebPMuxPushFrame(), WebPMuxGetFrame() e WebPMuxDeleteFrame().

Parametri: mux - l'oggetto (in/out) a cui deve essere aggiunto il blocco.; fourcc -- (in) un array di caratteri contenente le quattro cc del blocco specificato; ad es. "ICCP", "XMP ", "EXIF" ecc.; chunk_data . (in) i dati del blocco da aggiungere; copy_data: il valore (in) 1 indica che i dati specificati VERRANNO copiati nel mux, mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux, 4cc o chunk_data è NULL o se fourcc corrisponde a un blocco di immagine.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: al successo.

`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 di dati.; fourcc: (in) un array di caratteri contenente le quattro cc del blocco; ad esempio "ICCP", "XMP ", "EXIF" ecc.; chunk_data - (out) ha restituito dati relativi a blocchi di dati.
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux, 4cc o chunk_data è NULL o se fourcc corrisponde a un blocco di immagine.; WEBP_MUX_NOT_FOUND: se mux non contiene un blocco con l'ID specificato.; WEBP_MUX_OK: al successo.

`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 le quattro cc del blocco; ad esempio "ICCP", "XMP ", "EXIF" ecc.
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux o4cc è NULL o se4cc corrisponde a un blocco di immagine.; WEBP_MUX_NOT_FOUND: se mux non contiene un blocco con la virgola specificata.; WEBP_MUX_OK: al successo.

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 frame/frammenti) verranno rimosse.

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

Parametri: mux: l'oggetto (in/out) in cui deve essere impostata l'immagine.; bitstream -- (in) può essere un flusso di bit VP8/VP8L non elaborato o un file WebP a immagine singola (non animato e non frammentato); copy_data: il valore (in) 1 indica che i dati specificati VERRANNO copiati nel mux, mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Ritorni: 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: al successo.

`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 invece WebPMuxSetImage().
Il tipo di frame caricato deve essere uguale a quello nel mux.
Poiché WebP supporta solo gli offset pari, qualsiasi offset dispari verrà agganciato a una posizione pari utilizzando: offset &= ~1

Parametri: mux : l'oggetto (in/out) a cui deve essere aggiunto il frame.; frame: dati frame (in).; copy_data: il valore (in) 1 indica che i dati specificati VERRANNO copiati nel mux, mentre il valore 0 indica che i dati NON verranno copiati nell'oggetto mux.
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux o frame è NULL o se il contenuto di frame non è valido.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: al successo.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.

`WebPMuxGetFrame()`

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

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

Parametri: mux: l'oggetto (in) dal quale devono essere recuperate le informazioni.; nth -- indice (in) del frame nell'oggetto mux.; frame -- (out) dati del frame restituito.
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux o frame è impostato su NULL.; WEBP_MUX_NOT_FOUND: se ci sono meno di n° frame nell'oggetto mux.; WEBP_MUX_BAD_DATA: se il blocco di frame nth nel mux non è valido.; WEBP_MUX_OK: al successo.

`WebPMuxDeleteFrame()`

Elimina un frame dall'oggetto mux. nth=0 ha un significato speciale: last position.

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
Ritorni: WEBP_MUX_INVALID_ARGUMENT -- se mux è NULL.; WEBP_MUX_NOT_FOUND: se ci sono meno di n° frame nell'oggetto mux prima dell'eliminazione.; WEBP_MUX_OK: al successo.

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 dell'animazione nell'oggetto mux. Tutti i blocchi ANIM esistenti verranno rimossi.

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

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

`WebPMuxGetAnimationParams()`

Restituisce i parametri dell'animazione dall'oggetto mux.

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

Parametri: mux: oggetto (in) da cui recuperare i parametri dell'animazione.; params -- (out) i parametri dell'animazione estratti dal blocco ANIM
Ritorni: 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: al successo.

Utilità varie

`WebPMuxGetCanvasSize()`

Restituisce le dimensioni della tela 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() o WebPMuxCreate().

Parametri: mux: l'oggetto (in) da cui deve essere recuperata la dimensione del canvas.; width -- (out) larghezza del canvas.; height -- (out) altezza canvas
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux, larghezza o altezza è NULL.; WEBP_MUX_BAD_DATA: se le dimensioni del blocco o della tela VP8X/VP8/VP8L non sono valide.; WEBP_MUX_OK: al successo.

`WebPMuxGetFeatures()`

Restituisce i flag funzionalità dall'oggetto mux.

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

Parametri: mux: l'oggetto (in) da cui devono essere recuperate le caratteristiche.; flags -- (fuori) i flag che specificano le caratteristiche presenti nell'oggetto mux. Questo sarà un operatore OR di vari valori di flag. L'enumerazione WebPFeatureFlags può essere utilizzata per testare i singoli valori di flag.
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux o flags è NULL.; WEBP_MUX_BAD_DATA: se le dimensioni del blocco o della tela VP8X/VP8/VP8L non sono valide.; WEBP_MUX_OK: al successo.

`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: l'oggetto (in) dal quale devono essere recuperate le informazioni.; id: l'ID blocco (in) che specifica il tipo di blocco.; num_elements -- (fuori) il numero di blocchi con l'ID blocco specificato
Ritorni: WEBP_MUX_INVALID_ARGUMENT: se mux o num_elements è NULL.; WEBP_MUX_OK: al successo.

`WebPMuxAssemble()`

Assembla tutti i blocchi in formato WebP RIFF e restituisce 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, i contenuti di assembled_data vengono allocati utilizzando Malloc() e NON sono di proprietà dell'oggetto mux. DEVE essere distribuito dal chiamante chiamando WebPDataClear().

Parametri: mux. Oggetto (in/out) i cui blocchi devono essere assemblati.; assembled_data: dati WebP assemblati (fuori)
Ritorni: WEBP_MUX_BAD_DATA: se l'oggetto mux non è valido.; WEBP_MUX_INVALID_ARGUMENT: se mux o assembled_data è NULL.; WEBP_MUX_MEMORY_ERROR: in caso di errore di allocazione della memoria.; WEBP_MUX_OK: al successo.

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 struttura WebPAnimEncoderOptions prima della modifica. Restituisce false in caso di mancata corrispondenza della versione. La funzione WebPAnimEncoderOptionsInit() deve avere esito positivo prima di poter utilizzare l'oggetto enc_options.

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

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

Crea e inizializza un oggetto WebPAnimEncoder.

Parametri: width/height: la larghezza e l'altezza del canvas dell'animazione.; enc_options: opzioni di codifica (in); può essere passato NULL per scegliere valori predefiniti ragionevoli.
Ritorni: 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 specificato per WebP, codificalo e aggiungilo all'oggetto WebPAnimEncoder.

L'ultima chiamata a WebPAnimEncoderAdd deve essere frame = NULL, che indica che non devono essere aggiunti altri frame. Questa chiamata viene utilizzata anche per determinare la durata dell'ultimo frame.

Parametri: enc : l'oggetto (in/out) a cui deve essere aggiunto il frame.; frame -- Dati frame (in/out) in formato ARGB o YUV(A). Se è nel formato YUV(A), verrà convertito in ARGB, il che comporta una piccola perdita.; timestamp_ms: il timestamp (in) di questo frame in millisecondi. La durata di un frame viene calcolata come "timestamp del frame successivo - timestamp di questo frame". Pertanto, i timestamp non devono essere in ordine decrescente.; config: opzioni di codifica (in); può essere passato NULL per scegliere valori predefiniti ragionevoli.
Ritorni: 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 sarà stimata internamente.

Parametri: enc -- (in/out) l'oggetto da cui devono essere assemblati i frame.; webp_data. (out) ha generato un flusso di bit WebP.
Ritorni: Vero per il successo.

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

`WebPAnimEncoderGetError()`

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

Parametri: enc -- oggetto (in/out) da cui deve essere recuperata la stringa di errore.
Ritorni: NULL if enc is NULL. In caso contrario, restituisce la stringa di errore se l'ultima chiamata a enc ha avuto un errore o una stringa vuota se l'ultima chiamata è andata a buon fine.

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 dei 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, pacchettizzata in esadecimale utilizzando 8 bit per ognuna delle opzioni principali/minori/revisioni. Ad esempio, la versione 2.5.7 è 0x020507.

int WebPGetDemuxVersion(void);

`WebPDemux()`

Analizza l'intero file WebP fornito dai dati.

WebPDemuxer WebPDemux(const WebPData* data);

Restituisce un oggetto WebPDemuxer dopo l'analisi riuscita, altrimenti NULL.

`WebPDemuxPartial()`

Analizza il file WebP potenzialmente incompleto fornito dai dati. Se state è non NULL, verrà 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 in caso di analisi riuscita.

Tieni presente che WebPDemuxer mantiene i puntatori interni al segmento di memoria dei dati. Se questi dati sono volatili, l'oggetto demuxer deve essere eliminato (chiamando WebPDemuxDelete()) e WebPDemuxPartial() richiamato in base ai nuovi dati. Si tratta di un'operazione solitamente poco costosa.

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

Recupera il valore feature dal file dmux.

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

Nota: i valori sono validi solo se è stato utilizzato WebPDemux() o se 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 rimanda al primo frammento al ritorno da questa funzione. I singoli frammenti possono essere estratti utilizzando WebPDemuxSelectFragment(). Se imposti il valore frame_number su 0, verrà restituito l'ultimo frame dell'immagine.

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

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

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

Imposta iter->fragment in modo che punti al frame successivo (iter->fragment + 1) o precedente (iter->fragment - 1). Queste funzioni non sono in loop.

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

Restituisce true in caso di successo, false negli altri casi.

`WebPDemuxSelectFragment()`

Imposta iter->fragment in modo che rifletta il numero di frammento fragment_num.

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

Restituisce true se è presente il frammento fragment_num, altrimenti restituisce false.

`WebPDemuxReleaseIterator()`

Rilascia l'eventuale memoria associata a iter.

void WebPDemuxReleaseIterator(WebPIterator* iter);

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

Iterazione del blocco

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 le quattro cc del blocco da restituire, ad esempio "ICCP", "XMP ", "EXIF" ecc.

Impostando il valore chunk_number su 0, verrà restituito l'ultimo blocco di un insieme.

Restituisce true se il blocco viene trovato, altrimenti false. È possibile accedere ai payload dei blocchi di immagini tramite WebPDemuxGetFrame() e le funzioni correlate. Richiama WebPDemuxReleaseChunkIterator() quando l'uso dell'iteratore è completo.

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

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

Imposta iter->chunk in modo che punti al blocco successivo (iter->chunk_num + 1) o precedente (iter->chunk_num - 1). Queste funzioni non sono in loop.

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

Restituisce true in caso di successo, false negli altri casi.

`WebPDemuxReleaseChunkIterator()`

Rilascia l'eventuale memoria associata a iter.

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);

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

API WebPAnimDecoder

Questa API consente di decodificare (possibilmente) 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 struttura WebPAnimDecoderOptions prima della modifica. Restituisce false in caso di mancata corrispondenza della versione. La funzione WebPAnimDecoderOptionsInit() deve avere esito positivo prima di utilizzare l'oggetto dec_options.

Parametri

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

Ritorni: Vero sul successo

int WebPAnimDecoderOptionsInit(
    WebPAnimDecoderOptions* dec_options);

`WebPAnimDecoderNew()`

Crea e inizializza un oggetto WebPAnimDecoder.

Parametri: webp_data -- (in) bitstream WebP. Questo valore dovrebbe rimanere invariato per tutta la durata dell'oggetto WebPAnimDecoder di output.; dec_options: le opzioni di decodifica (in entrata). Può essere passato NULL per scegliere valori predefiniti ragionevoli (in particolare, verrà selezionata la modalità colore MODE_RGBA).
Ritorni: Un puntatore all'oggetto WebPAnimDecoder appena creato o NULL in caso 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 del decoder da cui ottenere informazioni.; info: informazioni globali recuperate dall'animazione.
Ritorni: 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(). Sarà una tela completamente ricostruita di dimensioni canvas_width * 4 * canvas_height, non solo il sub-rettangolo del frame. Il buf del buffer restituito è valido solo fino alla chiamata successiva a WebPAnimDecoderGetNext(), WebPAnimDecoderReset() o WebPAnimDecoderDelete().

Parametri: dec -- (in/out) istanza del decoder da cui deve essere recuperato il frame successivo.; buf -- (out) frame decodificato.; timestamp : il timestamp (out) del frame in millisecondi.
Ritorni: Falso se uno degli argomenti è NULL, se si verifica un errore di analisi o decodifica oppure se non sono presenti altri frame. In caso contrario, restituisce true.

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

`WebPAnimDecoderHasMoreFrames()`

Controlla se sono rimasti altri frame da decodificare.

Parametri: dec -- (in) istanza decoder da controllare.
Ritorni: True se dec non è NULL e alcuni frame devono ancora essere decodificati. In caso contrario, restituisce false.

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

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

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

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

Afferra l'oggetto demuxer interno.

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

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

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

Elimina l'oggetto WebPAnimDecoder.

Parametri: dec -- (in/out) istanza decoder da eliminare.
Ritorni: Vero sul 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 valori predefiniti.

void WebPDataInit(WebPData* webp_data);

`WebPDataClear()`

Cancella i contenuti dell'oggetto webp_data chiamando free(). Non alloca 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

Crea una MUX con dati di immagini, profilo colore e metadati XMP

Ottenere dati di profilo di immagini e colori da un file WebP

Vita di un oggetto Mux

Enum

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

Creazione Mux

WebPMuxCreate()

Blocchi non di immagine

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

Immagini

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

Animazione

Parametri animazione

WebPMuxSetAnimationParams()

WebPMuxGetAnimationParams()

Utilità varie

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

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