Diese Seite wurde von der Cloud Translation API übersetzt.

Dokumentation zur WebP Container API

RIFF-Containerbearbeitung für WebP-Bilder.

Mux-API

Ermöglicht die Bearbeitung von WebP-Container-Images mit Funktionen wie Farbe Profil, Metadaten, Animationen und fragmentierte Bilder.

Codebeispiele

MUX mit Bilddaten, Farbprofil und XMP-Metadaten erstellen

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);

Bild- und Farbprofildaten aus einer WebP-Datei abrufen

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);

Leben eines Mux-Objekts

Enums

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

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

`WebPGetMuxVersion()`

Gibt die Versionsnummer der Mux-Bibliothek zurück, die mithilfe von 8 Bits für jede Haupt-/Nebenversion und jede Überarbeitung. Version 2.5.7 ist beispielsweise 0x020507.

int WebPGetMuxVersion(void);

`WebPMuxNew()`

Erstellt ein leeres Mux-Objekt.

WebPMux* WebPMuxNew(void);

Gibt Folgendes zurück:: Ein Zeiger auf das neu erstellte leere Mux-Objekt.

`WebPMuxDelete()`

Löscht das mux-Objekt.

void WebPMuxDelete(WebPMux* mux);

Parameter: mux – zu löschendes (ein-/ausgeschlossenes) Objekt

Mux-Erstellung

`WebPMuxCreate()`

Erstellt ein mux-Objekt aus Rohdaten, die im WebP RIFF-Format angegeben sind.

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

Parameter: bitstream – (in) die Bitstreamdaten im WebP RIFF-Format; copy_data: (in) Wert 1 gibt an, dass die angegebenen Daten in die Mux-Datei kopiert werden. und der Wert 0 bedeutet, dass Daten NICHT in das mux-Objekt kopiert werden.
Gibt Folgendes zurück:: Zeiger auf das Mux-Objekt, das aus bestimmten Daten erstellt wurde – bei Erfolg.; NULL: bei ungültigen Daten oder Speicherfehlern.

Nicht-Bild-Blöcke

`WebPMuxSetChunk()`

Fügt einen Block mit der ID fourcc und den Daten chunk_data im Mux-Objekt hinzu. Beliebig Vorhandene Blöcke mit derselben ID werden entfernt.

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

Hinweis: Über Chunk APIs sollten nur Blöcke verwaltet werden, die keine Images sind. Bildbezogene Blöcke sind: „ANMF“, „FRGM“, „VP8“, „VP8L“ und „ALPH“. Fügen Sie zum Hinzufügen Bilder abrufen und löschen, WebPMuxSetImage() verwenden, WebPMuxPushFrame(), WebPMuxGetFrame() und WebPMuxDeleteFrame()

Parameter: mux – Objekt (ein/aus), zu dem der Block hinzugefügt werden soll; fourcc – (in) ein Zeichenarray, das die Fourcc des gegebenen chunk; z.B. „ICCP“, „XMP“, „EXIF“ usw.; chunk_data – (in) die Chunk-Daten, die hinzugefügt werden sollen; copy_data: (in) Wert 1 gibt an, dass die angegebenen Daten in die Mux-Datei kopiert werden. und der Wert 0 bedeutet, dass Daten NICHT in das mux-Objekt kopiert werden.
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT – wenn mux, viercc oder chunk_data NULL ist oder wenn Fourcc entspricht einem Bild-Chunk.; WEBP_MUX_MEMORY_ERROR: bei einem Fehler bei der Arbeitsspeicherzuweisung.; WEBP_MUX_OK: bei Erfolg.

`WebPMuxGetChunk()`

Ruft einen Verweis auf die Daten des Chunks mit der ID fourcc im Mux-Objekt ab. Der Aufrufer sollte die zurückgegebenen Daten NICHT freigeben.

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

Parameter: mux – (in) Objekt, aus dem die Blockdaten abgerufen werden sollen; fourcc – (in) ein Zeichenarray, das die Fourcc-Werte des Chunks enthält; z.B. „ICCP“, „XMP“, „EXIF“ usw.; chunk_data – (out) hat Chunk-Daten zurückgegeben
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT – wenn mux, viercc oder chunk_data NULL ist oder wenn Fourcc entspricht einem Bild-Chunk.; WEBP_MUX_NOT_FOUND – wenn mux keinen Chunk mit dem angegebenen id [ID].; WEBP_MUX_OK: bei Erfolg.

`WebPMuxDeleteChunk()`

Löscht den Chunk mit den angegebenen fourcc aus dem Mux-Objekt.

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

Parameter: mux – Objekt (ein/aus), aus dem der Block gelöscht werden soll; fourcc – (in) ein Zeichenarray, das die Fourcc-Werte des Chunks enthält; z.B. „ICCP“, „XMP“, „EXIF“ usw.
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT – wenn mux oder 4cc NULL ist oder wenn Fourcc entspricht einem Bild-Chunk.; WEBP_MUX_NOT_FOUND – wenn mux keinen Chunk mit dem angegebenen Fourcc; WEBP_MUX_OK: bei Erfolg.

Bilder

Kapselt Daten über einen einzelnen Frame/Fragment.

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

Legt das (nicht animierte und nicht fragmentierte) Bild im Mux-Objekt fest. Hinweis:Alle vorhandenen Bilder, einschließlich Frames und Fragmenten, werden entfernt.

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

Parameter: mux – Objekt (in/out), in dem das Bild festgelegt werden soll; bitstream – (in) kann ein VP8/VP8L-Rohbitstream oder ein WebP mit nur einem Bild sein. Datei (nicht animiert und nicht fragmentiert); copy_data: (in) Wert 1 gibt an, dass die angegebenen Daten in die Mux-Datei kopiert werden. und der Wert 0 bedeutet, dass Daten NICHT in das mux-Objekt kopiert werden.
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT: wenn mux NULL oder Bitstream NULL ist.; WEBP_MUX_MEMORY_ERROR: bei einem Fehler bei der Arbeitsspeicherzuweisung.; WEBP_MUX_OK: bei Erfolg.

`WebPMuxPushFrame()`

Fügt am Ende des Mux-Objekts einen Frame hinzu.

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

Hinweise:

Frame.id muss entweder WEBP_CHUNK_ANMF oder WEBP_CHUNK_FRGM sein
Zum Festlegen eines nicht animierten, nicht fragmentierten Bildes verwenden Sie WebPMuxSetImage().
Der Frame-Typ, der verschoben wird, muss mit den Frames in "Mux" übereinstimmen.
Da WebP nur gerade Offsets unterstützt, wird jeder ungerade Offset angedockt. auf eine gerade Position mit: Offset &= ~1

Parameter: mux – Objekt (in/out), zu dem der Frame hinzugefügt werden soll; frame: (in) Frame-Daten; copy_data: (in) Wert 1 gibt an, dass die angegebenen Daten in die Mux-Datei kopiert werden. und der Wert 0 bedeutet, dass Daten NICHT in das mux-Objekt kopiert werden.
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT – wenn Mux oder Frame NULL ist oder der Inhalt von Frame ist ungültig.; WEBP_MUX_MEMORY_ERROR: bei einem Fehler bei der Arbeitsspeicherzuweisung.; WEBP_MUX_OK: bei Erfolg.; WEBP_MUX_MEMORY_ERROR: bei einem Fehler bei der Arbeitsspeicherzuweisung.

`WebPMuxGetFrame()`

Ruft den n-ten Frame aus dem Mux-Objekt ab. Der Inhalt von Frame -> Bitstream ist die mithilfe von "maloc()" zugewiesen werden und NICHT dem mux-Objekt gehören. MÜSSEN vom Anrufer durch Aufrufen von WebPDataClear() freigegeben wurde. nth=0 hat eine besondere Bedeutung: die letzte Position.

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

Parameter: mux – (in) Objekt, von dem die Informationen abgerufen werden sollen; nth: (in) Index des Frames im Mux-Objekt; frame – Daten des zurückgegebenen Frames (out)
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT -- if mux or frame is NULL.; WEBP_MUX_NOT_FOUND – wenn weniger als n-te Frames in der Mux-Datei vorhanden sind -Objekt enthält.; WEBP_MUX_BAD_DATA – wenn der n-te Frame-Chunk in mux ungültig ist.; WEBP_MUX_OK: bei Erfolg.

`WebPMuxDeleteFrame()`

Löscht einen Frame aus dem Mux-Objekt. nth=0 hat eine besondere Bedeutung: letzte .

WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);

Parameter: mux – Objekt (ein/aus), aus dem ein Frame gelöscht werden soll; nth – (in) Die Position, an der der Frame gelöscht werden soll.
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT -- if mux is NULL.; WEBP_MUX_NOT_FOUND: wenn weniger als n-te Frames in der Mux-Datei vorhanden sind -Objekt vor dem Löschen.; WEBP_MUX_OK: bei Erfolg.

Animation

Animationsparameter

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

Legt die Animationsparameter im Mux-Objekt fest. Alle vorhandenen ANIM-Blöcke entfernt werden.

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

Parameter: mux – Objekt (ein-/ausgehen), in dem der ANIM-Chunk festgelegt/hinzugefügt werden soll; params: Animationsparameter (in).
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT – wenn mux oder params NULL ist.; WEBP_MUX_MEMORY_ERROR: bei einem Fehler bei der Arbeitsspeicherzuweisung.; WEBP_MUX_OK: bei Erfolg.

`WebPMuxGetAnimationParams()`

Ruft die Animationsparameter aus dem Mux-Objekt ab.

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

Parameter: mux: (in) Objekt, aus dem die Animationsparameter abgerufen werden; params – (out)-Animationsparameter, die aus dem ANIM-Chunk extrahiert wurden
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT – wenn mux oder params NULL ist.; WEBP_MUX_NOT_FOUND – wenn der ANIM-Chunk nicht im Mux-Objekt vorhanden ist.; WEBP_MUX_OK: bei Erfolg.

Sonstige Versorgungsunternehmen

`WebPMuxGetCanvasSize()`

Ruft die Canvasgröße aus dem Mux-Objekt ab.

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

Hinweis:Bei dieser Methode wird davon ausgegangen, dass der VP8X-Chunk, falls vorhanden, aktuell ist. Das mux-Objekt wurde also seit dem letzten Aufruf von nicht geändert. WebPMuxAssemble() oder WebPMuxCreate()

Parameter: mux – (in) Objekt, von dem die Canvasgröße abgerufen werden soll; width: Canvas-Breite (out); height: Canvas-Höhe (out)
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT -- if mux, width or height is NULL.; WEBP_MUX_BAD_DATA: wenn die Chunk- oder Canvasgröße von VP8X/VP8/VP8L ungültig ist.; WEBP_MUX_OK: bei Erfolg.

`WebPMuxGetFeatures()`

Ruft die Feature-Flags aus dem mux-Objekt ab.

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

Parameter: mux – (in) Objekt, von dem die Funktionen abgerufen werden sollen; flags – (out) die Flags, die angeben, welche Funktionen in der Mux-Datei vorhanden sind -Objekt enthält. Dabei handelt es sich um eine ODER-Verknüpfung verschiedener Flag-Werte. Aufzählung WebPFeatureFlags können zum Testen einzelner Flag-Werte verwendet werden.
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT -- if mux or flags is NULL.; WEBP_MUX_BAD_DATA: wenn die Chunk- oder Canvasgröße von VP8X/VP8/VP8L ungültig ist.; WEBP_MUX_OK: bei Erfolg.

`WebPMuxNumChunks()`

Ruft die Anzahl der Blöcke mit dem angegebenen Tag-Wert im mux-Objekt ab.

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

Parameter: mux – (in) Objekt, von dem die Informationen abgerufen werden sollen; id – (in) Chunk-ID, die den Chunk-Typ angibt; num_elements – (out) Anzahl der Blöcke mit der angegebenen Chunk-ID
Gibt Folgendes zurück:: WEBP_MUX_INVALID_ARGUMENT -- if mux, or num_elements is NULL.; WEBP_MUX_OK: bei Erfolg.

`WebPMuxAssemble()`

Stellt alle Blöcke im WebP-RIFF-Format zusammen und gibt assembled_data zurück. Diese Funktion validiert auch das mux-Objekt.

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

Hinweis:Der Inhalt von assed_data wird ignoriert und überschrieben. Außerdem wird der Inhalt von assembled_data mithilfe von "maloc()" zugewiesen und NICHT dem mux-Objekt gehört. Die Zuordnung MUSS vom Anrufer durch Aufrufen von WebPDataClear()

Parameter: mux – Objekt (in/out), dessen Blöcke zusammengesetzt werden sollen; assembled_data – (out) zusammengestellte WebP-Daten
Gibt Folgendes zurück:: WEBP_MUX_BAD_DATA: wenn das Mux-Objekt ungültig ist.; WEBP_MUX_INVALID_ARGUMENT -- if mux or assembled_data is NULL.; WEBP_MUX_MEMORY_ERROR: bei einem Fehler bei der Arbeitsspeicherzuweisung.; WEBP_MUX_OK: bei Erfolg.

WebPAnimEncoder API

Diese API ermöglicht die Codierung animierter WebP-Bilder (möglicherweise).

Codebeispiel

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.

Globale Optionen

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

Sollte immer aufgerufen werden, um einen neuen WebPAnimEncoderOptions zu initialisieren Struktur vor der Änderung. Gibt "false" zurück, falls Versionen nicht übereinstimmen. WebPAnimEncoderOptionsInit() muss erfolgreich ausgeführt worden sein, bevor die enc_options-Objekt zu erstellen.

Parameter: enc_options: Ein-/Aus-Optionen, die für die Codierung der Animation verwendet werden
Gibt Folgendes zurück:: „True“ im Erfolgsfall.

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

Erstellt und initialisiert ein WebPAnimEncoder-Objekt.

Parameter: width/height: Canvas-Breite und -Höhe der Animation (Zoll).; enc_options – (in) Codierungsoptionen; kann NULL übergeben werden, sinnvolle Standardeinstellungen.
Gibt Folgendes zurück:: Ein Zeiger auf das neu erstellte WebPAnimEncoder-Objekt oder NULL, falls eines Gedächtnisfehlers.

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

`WebPAnimEncoderAdd()`

Optimieren Sie den Frame für WebP, codieren Sie ihn und fügen Sie ihn zum WebPAnimEncoder-Objekt.

Der letzte Aufruf an WebPAnimEncoderAdd sollte über frame = NULL erfolgen, wodurch gibt an, dass keine weiteren Frames hinzugefügt werden sollen. Dieser Anruf wird auch verwendet, um die Dauer des letzten Frames bestimmen.

Parameter: enc – Objekt (in/out), dem der Frame hinzugefügt werden soll.; frame: Framedaten im ARGB- oder YUV(A)-Format(ein-/ausgehen) Wenn es in YUV(A)-Format wird sie in das ARGB-Format konvertiert, was einen geringen Verlust verursacht.; timestamp_ms: (in) Zeitstempel dieses Frames in Millisekunden. Dauer eines Frames wird wie folgt berechnet: "Zeitstempel des nächsten Frames - Zeitstempel des diesen Frame“. Die Reihenfolge der Zeitstempel darf also nicht abnehmend sein.; config – (in) Codierungsoptionen; kann NULL übergeben werden, um sinnvolle Standardeinstellungen.
Gibt Folgendes zurück:: Bei einem Fehler wird „false“ zurückgegeben und frame->error_code ist entsprechend festgelegt. Andernfalls wird „true“ zurückgegeben.

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

`WebPAnimEncoderAssemble()`

Setze alle bisher hinzugefügten Frames zu einem WebP-Bitstream zusammen. Dieser Anruf sollte Einem Aufruf von WebPAnimEncoderAdd mit frame = NULL vorausgehen; Wenn nicht, wird die Dauer des letzten Frames intern geschätzt.

Parameter: enc – Objekt (in/out), aus dem die Frames zusammengesetzt werden sollen.; webp_data – (out) generierter WebP-Bitstream.
Gibt Folgendes zurück:: Wahr im Erfolgsfall.

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

`WebPAnimEncoderGetError()`

Ruft den Fehlerstring für den letzten Aufruf mit enc ab. Die Der zurückgegebene String gehört enc und ist nur bis zum nächsten Aufruf von WebPAnimEncoderAdd() oder WebPAnimEncoderAssemble() oder WebPAnimEncoderDelete()

Parameter: enc – (in/out) Objekt, von dem der Fehlerstring abgerufen werden soll.
Gibt Folgendes zurück:: NULL if enc is NULL. Andernfalls wird der Fehlerstring zurückgegeben, wenn die letzte Der Aufruf von enc weist einen Fehler auf bzw. ein leerer String, wenn der letzte Aufruf eine Erfolg haben.

const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);

`WebPAnimEncoderDelete()`

Löscht das Objekt WebPAnimEncoder.

Parameter: enc – zu löschendes (ein-/ausgehendes) Objekt

void WebPAnimEncoderDelete(WebPAnimEncoder* enc);

Demux API

Ermöglicht das Extrahieren von Bilddaten und Daten im erweiterten Format aus WebP-Dateien.

Codebeispiele

Demuxing von WebP-Daten zum Extrahieren aller Frames, ICC-Profil und EXIF/XMP-Metadaten

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);

Das Leben eines Demux-Objekts

Enums

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

`WebPGetDemuxVersion()`

Gibt die Versionsnummer der Demox-Bibliothek zurück, die mithilfe von 8 Bits für jede Haupt-/Nebenversion und jede Überarbeitung. Version 2.5.7 ist beispielsweise 0x020507.

int WebPGetDemuxVersion(void);

`WebPDemux()`

Analysiert die vollständige WebP-Datei, die von data angegeben wird.

WebPDemuxer WebPDemux(const WebPData* data);

Gibt bei erfolgreichem Parsen ein WebPDemuxer-Objekt zurück, andernfalls NULL.

`WebPDemuxPartial()`

Analysiert die möglicherweise unvollständige WebP-Datei, die von data angegeben wurde. Wenn state nicht NULL ist, wird er gesetzt, um den Status des Demuxers anzugeben.

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

Gibt NULL zurück, wenn ein Fehler auftritt oder nicht genügend Daten vorhanden sind, um mit dem Parsen zu beginnen; und ein WebPDemuxer-Objekt bei erfolgreichem Parsen.

Beachten Sie, dass WebPDemuxer interne Verweise auf das Speichersegment data beibehält. Wenn diese Daten flüchtig sind, sollte das demuxer-Objekt gelöscht werden (durch Aufrufen WebPDemuxDelete()) und WebPDemuxPartial() wird noch einmal für die neuen Daten aufgerufen. Dies ist in der Regel kostengünstig.

`WebPDemuxDelete()`

Gibt Arbeitsspeicher frei, der mit dmux verknüpft ist.

void WebPDemuxDelete(WebPDemuxer* dmux);

Daten-/Informationsextraktion

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

Rufen Sie den feature-Wert aus dmux ab.

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

Hinweis:Werte sind nur gültig, wenn WebPDemux() verwendet wurde oder WebPDemuxPartial() hat einen Status zurückgegeben > WEBP_DEMUX_PARSING_HEADER.

Frame-Iteration

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

Ruft Frame frame_number aus dmux ab.

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

iter->fragment zeigt nach Rückgabe dieser Funktion auf das erste Fragment. Einzelne Fragmente können mithilfe von WebPDemuxSelectFragment() Einstellung frame_number gleich 0 gibt, wird der letzte Frame des Bildes zurückgegeben.

Gibt "false" zurück, wenn dmux NULL ist oder Frame dmux nicht vorhanden ist. Rufen Sie WebPDemuxReleaseIterator() auf, wenn Sie die Iteration abgeschlossen ist.

Hinweis:dmux muss für die Lebensdauer von iter beibehalten werden.

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

Legt iter->fragment so fest, dass es auf das nächste Element (iter->fragment + 1) verweist, oder vorheriges Frame (iter->frame_num - 1) enthält. Diese Funktionen werden nicht wiederholt.

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

Gibt im Erfolgsfall "true" zurück, andernfalls "false".

`WebPDemuxSelectFragment()`

Legt für iter->fragment die Fragmentnummer iter->fragment fest.

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

Gibt „true“ zurück, wenn das Fragment fragment_num vorhanden ist, andernfalls „false“.

`WebPDemuxReleaseIterator()`

Gibt jeden mit iter verknüpften Arbeitsspeicher frei.

void WebPDemuxReleaseIterator(WebPIterator* iter);

Muss vor allen nachfolgenden Aufrufen von aufgerufen werden. WebPDemuxGetChunk() für denselben Iteration Außerdem müssen aufgerufen, bevor die zugehörige WebPDemuxer mit WebPDemuxDelete()

Chunk-Iteration

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

Ruft die chunk_number-Instanz des Blocks mit der ID fourcc von dmux:

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

fourcc ist ein Zeichenarray, das die Fourcc-Werte des zurückzugebenden Blocks enthält. z.B. „ICCP“, „XMP“, „EXIF“ usw.

Wenn Sie chunk_number auf 0 setzen, wird der letzte Block in einem Satz zurückgegeben.

Gibt „true“ zurück, wenn der Block gefunden wird, andernfalls „false“. Bildbezogener Block Auf die Nutzlasten wird über WebPDemuxGetFrame() zugegriffen und damit verbundene Funktionen. Anruf WebPDemuxReleaseChunkIterator() bei Verwendung des Iterators abgeschlossen ist.

Hinweis:dmux muss für die Lebensdauer des Iterators beibehalten werden.

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

Legt iter->chunk so fest, dass er auf den nächsten (iter->chunk_num + 1) verweist, oder vorherigen Chunks (iter->chunk_num - 1) enthält. Diese Funktionen werden nicht wiederholt.

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

Gibt im Erfolgsfall "true" zurück, andernfalls "false".

`WebPDemuxReleaseChunkIterator()`

Gibt jeden mit iter verknüpften Arbeitsspeicher frei.

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);

Muss aufgerufen werden, bevor die zugehörige WebPDemuxer gelöscht wird mit WebPDemuxDelete()

WebPAnimDecoder API

Mit dieser API können animierte WebP-Bilder (möglicherweise) decodiert werden.

Codebeispiel

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.

Globale Optionen

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

Sollte immer aufgerufen werden, um ein neues WebPAnimDecoderOptions-Objekt zu initialisieren Struktur vor der Änderung. Gibt "false" zurück, falls Versionen nicht übereinstimmen. WebPAnimDecoderOptionsInit() muss erfolgreich ausgeführt worden sein, bevor die dec_options-Objekt.

Parameter

dec_options – Ein-/Aus-Optionen, die für die Decodierung der Animation verwendet werden

Gibt Folgendes zurück:: Richtig

int WebPAnimDecoderOptionsInit(
    WebPAnimDecoderOptions* dec_options);

`WebPAnimDecoderNew()`

Erstellt und initialisiert ein WebPAnimDecoder-Objekt.

Parameter: webp_data: (im) WebP-Bitstream. Dies sollte während Die Lebensdauer des WebPAnimDecoder-Ausgabeobjekts.; dec_options – (in) Decodierungsoptionen Kann zur Auswahl NULL übergeben werden Standardeinstellungen angemessen sind (insbesondere wird der Farbmodus MODE_RGBA ausgewählt).
Gibt Folgendes zurück:: Ein Zeiger auf das neu erstellte WebPAnimDecoder-Objekt oder NULL, falls eines Parsing-Fehlers, einer ungültigen Option oder eines Speicherfehlers.

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

Globale Informationen zur Animation.

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

`WebPAnimDecoderGetInfo()`

Rufen Sie globale Informationen zur Animation ab.

Parameter: dec: (in) Decoderinstanz, von der Informationen abgerufen werden sollen; info: (out) globale Informationen, die aus der Animation abgerufen wurden.
Gibt Folgendes zurück:: Wahr im Erfolgsfall.

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

`WebPAnimDecoderGetNext()`

Ruft den nächsten Frame von dec basierend auf den Optionen ab, die für WebPAnimDecoderNew() Dies wird ein vollständig eine rekonstruierte Leinwand der Größe canvas_width * 4 * canvas_height, Unterrechteck des Rahmens. Der zurückgegebene Puffer buf ist nur gültig, bis der nächster Anruf bei WebPAnimDecoderGetNext(), WebPAnimDecoderReset() oder WebPAnimDecoderDelete()

Parameter: dec – Decoderinstanz (ein/aus), von der der nächste Frame gesendet werden soll abgerufen.; buf – (out) decodierter Frame.; timestamp: (out) Zeitstempel des Frames in Millisekunden.
Gibt Folgendes zurück:: Falsch, wenn eines der Argumente NULL ist oder wenn ein Parsing- oder oder wenn keine Frames mehr vorhanden sind. Andernfalls wird „true“ zurückgegeben.

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

`WebPAnimDecoderHasMoreFrames()`

Prüfen Sie, ob noch mehr Frames zu decodieren sind.

Parameter: dec: (in) zu prüfender Decoderinstanz.
Gibt Folgendes zurück:: „True“, wenn dec nicht NULL ist und einige Frames noch decodiert werden müssen. Andernfalls wird "false" zurückgegeben.

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

Setzt das WebPAnimDecoder-Objekt zurück, sodass der nächste Aufruf von WebPAnimDecoderGetNext() startet die Decodierung neu ab dem ersten Frame. Das ist hilfreich, wenn alle Frames decodiert werden müssen. mehrfach (z. B. info.loop_count Mal), ohne sie zu löschen oder neu zu erstellen. dec-Objekt.

Parameter: dec – (ein/aus) Decoderinstanz, die zurückgesetzt werden soll

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

Nehmen Sie das innere Demuxer-Objekt.

Das Demuxer-Objekt kann nützlich sein, wenn nur Operationen verwendet werden sollen. verfügbar über Demuxer; z.B. um XMP-/EXIF-/ICC-Metadaten abzurufen. Die zurückgegebene Das demuxer-Objekt gehört dec und ist nur bis zum nächsten Aufruf von WebPAnimDecoderDelete()

Parameter: dec: (in) Decoderinstanz, aus der das Demuxer-Objekt stammen soll abgerufen.

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

Löscht das WebPAnimDecoder-Objekt.

Parameter: dec: Decoderinstanz (ein/aus), die gelöscht werden soll
Gibt Folgendes zurück:: „True“ im Erfolgsfall.

void WebPAnimDecoderDelete(WebPAnimDecoder* dec);

Gängige Datentypen

Enums

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

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

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

`WebPDataInit()`

Initialisiert den Inhalt des Objekts webp_data mit Standardwerten.

void WebPDataInit(WebPData* webp_data);

`WebPDataClear()`

Löscht den Inhalt des webp_data-Objekts durch Aufrufen von free(). Nicht die Zuweisung des Objekts selbst aufheben.

void WebPDataClear(WebPData* webp_data);

`WebPDataCopy()`

Ordnet den erforderlichen Speicher für dst zu und kopiert den Inhalt von src. Gibt im Erfolgsfall "true" zurück.

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

Dokumentation zur WebP Container API

Mux-API

Codebeispiele

MUX mit Bilddaten, Farbprofil und XMP-Metadaten erstellen

Bild- und Farbprofildaten aus einer WebP-Datei abrufen

Leben eines Mux-Objekts

Enums

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

Mux-Erstellung

WebPMuxCreate()

Nicht-Bild-Blöcke

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

Bilder

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

Animation

Animationsparameter

WebPMuxSetAnimationParams()

WebPMuxGetAnimationParams()

Sonstige Versorgungsunternehmen

WebPMuxGetCanvasSize()

WebPMuxGetFeatures()

WebPMuxNumChunks()

WebPMuxAssemble()

WebPAnimEncoder API

WebPAnimEncoderOptionsInit()

WebPAnimEncoderNew()

WebPAnimEncoderAdd()

WebPAnimEncoderAssemble()

WebPAnimEncoderGetError()

WebPAnimEncoderDelete()

Demux API

Codebeispiele

Demuxing von WebP-Daten zum Extrahieren aller Frames, ICC-Profil und EXIF/XMP-Metadaten

Das Leben eines Demux-Objekts

Enums

WebPGetDemuxVersion()

WebPDemux()

WebPDemuxPartial()

WebPDemuxDelete()

Daten-/Informationsextraktion

WebPDemuxGetI()

Frame-Iteration

WebPDemuxGetFrame()

WebPDemuxNextFrame(), WebPDemuxPrevFrame()

WebPDemuxSelectFragment()

WebPDemuxReleaseIterator()

Chunk-Iteration

WebPDemuxGetChunk()

WebPDemuxNextChunk(), WebPDemuxPrevChunk()

WebPDemuxReleaseChunkIterator()

WebPAnimDecoder API

WebPAnimDecoderOptionsInit()

WebPAnimDecoderNew()

WebPAnimDecoderGetInfo()

WebPAnimDecoderGetNext()

WebPAnimDecoderHasMoreFrames()

WebPAnimDecoderReset()

WebPAnimDecoderGetDemuxer()

WebPAnimDecoderDelete()

Gängige Datentypen

Enums

WebPDataInit()

WebPDataClear()

WebPDataCopy()

`WebPGetMuxVersion()`

`WebPMuxNew()`

`WebPMuxDelete()`

`WebPMuxCreate()`

`WebPMuxSetChunk()`

`WebPMuxGetChunk()`

`WebPMuxDeleteChunk()`

`WebPMuxSetImage()`

`WebPMuxPushFrame()`

`WebPMuxGetFrame()`

`WebPMuxDeleteFrame()`

`WebPMuxSetAnimationParams()`

`WebPMuxGetAnimationParams()`

`WebPMuxGetCanvasSize()`

`WebPMuxGetFeatures()`

`WebPMuxNumChunks()`

`WebPMuxAssemble()`

`WebPAnimEncoderOptionsInit()`

`WebPAnimEncoderNew()`

`WebPAnimEncoderAdd()`

`WebPAnimEncoderAssemble()`

`WebPAnimEncoderGetError()`

`WebPAnimEncoderDelete()`

`WebPGetDemuxVersion()`

`WebPDemux()`

`WebPDemuxPartial()`

`WebPDemuxDelete()`

`WebPDemuxGetI()`

`WebPDemuxGetFrame()`

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

`WebPDemuxSelectFragment()`

`WebPDemuxReleaseIterator()`

`WebPDemuxGetChunk()`

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

`WebPDemuxReleaseChunkIterator()`

`WebPAnimDecoderOptionsInit()`

`WebPAnimDecoderNew()`

`WebPAnimDecoderGetInfo()`

`WebPAnimDecoderGetNext()`

`WebPAnimDecoderHasMoreFrames()`

`WebPAnimDecoderReset()`

`WebPAnimDecoderGetDemuxer()`

`WebPAnimDecoderDelete()`

`WebPDataInit()`

`WebPDataClear()`

`WebPDataCopy()`