इस पेज का अनुवाद Cloud Translation API से किया गया है.

WebP कंटेनर एपीआई दस्तावेज़

WebP इमेज के लिए RIFF कंटेनर में बदलाव.

Max API

कलर प्रोफ़ाइल, मेटाडेटा, ऐनिमेशन, और फ़्रैगमेंट वाली इमेज जैसी सुविधाओं वाली WebP कंटेनर इमेज में बदलाव करने की अनुमति देता है.

कोड के उदाहरण

इमेज डेटा, कलर प्रोफ़ाइल, और XMP मेटाडेटा की मदद से MUX बनाना

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

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

मक्स ऑब्जेक्ट की ज़िंदगी

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

हर मेजर/माइनर/रिविज़न के लिए 8 बिट का इस्तेमाल करके, हेक्साडेसिमल में पैक की गई मक्स लाइब्रेरी का वर्शन नंबर दिखाता है. उदाहरण के लिए, v2.5.7 0x020507 है.

int WebPGetMuxVersion(void);

`WebPMuxNew()`

एक खाली मक्स ऑब्जेक्ट बनाता है.

WebPMux* WebPMuxNew(void);

रिटर्न: नए बनाए गए खाली मक्स ऑब्जेक्ट के लिए पॉइंटर.

`WebPMuxDelete()`

मक्स ऑब्जेक्ट को मिटाता है.

void WebPMuxDelete(WebPMux* mux);

पैरामीटर: mux -- (in/out) ऑब्जेक्ट मिटाया जाना है

म्यूक्स क्रिएशन

`WebPMuxCreate()`

यह WebP RIFF फ़ॉर्मैट में दिए गए रॉ डेटा से, एक मल्टीप्लेक्स ऑब्जेक्ट बनाता है.

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

पैरामीटर: बिटस्ट्रीम -- (इन) WebP RIFF फ़ॉर्मैट में बिटस्ट्रीम डेटा; copy_data -- (in) वैल्यू 1 से पता चलता है कि दिए गए डेटा को मल्टीप्लेक्स में कॉपी किया जाएगा और वैल्यू 0 से पता चलता है कि डेटा को mux ऑब्जेक्ट में कॉपी नहीं किया जाएगा.
रिटर्न: दिए गए डेटा से बनाए गए मक्स ऑब्जेक्ट के लिए पॉइंटर - सफलता पर.; NULL -- अमान्य डेटा या मेमोरी की गड़बड़ी के मामले में.

बिना इमेज वाले हिस्से

`WebPMuxSetChunk()`

म्यूज़िक ऑब्जेक्ट में fourcc आईडी और डेटा chunk_data के साथ सेगमेंट जोड़ता है. एक ही आईडी वाले मौजूदा हिस्सों को हटा दिया जाएगा.

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

ध्यान दें: चंक एपीआई की मदद से, सिर्फ़ उन ही सेगमेंट को मैनेज किया जाना चाहिए जो इमेज से नहीं जुड़े हैं. (इमेज से जुड़े हिस्से ये हैं: "ANMF", "FRGM", "VP8 ", "VP8L", और "ALPH"). इमेज जोड़ने, पाने, और मिटाने के लिए, WebPMuxSetImage(), WebPMuxPushFrame(), WebPMuxGetFrame(), और WebPMuxDeleteFrame() का इस्तेमाल करें.

पैरामीटर: mux -- (in/out) ऑब्जेक्ट, जिसमें खंड जोड़ा जाना है; fourcc -- (in) एक वर्ण अरे है, जिसमें दिए गए हिस्से के फ़ोरक्सीसी हैं; उदाहरण, "ICCP", "XMP ", "EXIF" वगैरह.; chunk_data -- (in) जोड़ा जाने वाला डेटा समूह; copy_data -- (in) वैल्यू 1 से पता चलता है कि दिए गए डेटा को मल्टीप्लेक्स में कॉपी किया जाएगा और वैल्यू 0 से पता चलता है कि डेटा को mux ऑब्जेक्ट में कॉपी नहीं किया जाएगा.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक्स, forcecc या chunk_data, NULL है या if fourcc किसी इमेज हिस्से से मेल खाता है.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन से जुड़ी गड़बड़ी पर.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxGetChunk()`

मक्स ऑब्जेक्ट में fourcc आईडी वाले हिस्से के डेटा की जानकारी देता है. कॉल करने वाले (कॉलर) को वापस मिला डेटा खाली नहीं करना चाहिए.

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

पैरामीटर: mux -- (in) ऑब्जेक्ट, जिससे डेटा का डेटा फ़ेच किया जाना है; fourcc -- (in) वर्ण की ऐसी कैटगरी जिसमें पूरे डेटा का फोरसीसी होता है; उदाहरण के लिए, "ICCP", "XMP ", "EXIF" वगैरह.; chunk_data -- (out) समूह का डेटा दिखाया गया
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक्स, forcecc या chunk_data, NULL है या if fourcc किसी इमेज हिस्से से मेल खाता है.; WEBP_MUX_NOT_FOUND -- अगर मक्स में दिए गए आईडी वाला हिस्सा नहीं है.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxDeleteChunk()`

म्यूज़िक ऑब्जेक्ट से दिए गए fourcc वाले हिस्से को मिटाता है.

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

पैरामीटर: mux -- (in/out) ऑब्जेक्ट, जिससे खंड हटाया जाना है; fourcc -- (in) वर्ण की ऐसी कैटगरी जिसमें पूरे डेटा का फोरसीसी होता है; उदाहरण के लिए, "ICCP", "XMP ", "EXIF" वगैरह.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक्स या फ़ोरसीसी, NULL है या फ़ोरसीसी, इमेज के हिस्से के हिसाब से है.; WEBP_MUX_NOT_FOUND -- अगर मक्स में दिए गए फ़ोरसी वाला कोई हिस्सा नहीं है.; WEBP_MUX_OK -- सफलता पर.

इमेज

किसी एक फ़्रेम/फ़्रैगमेंट का डेटा एनकैप्सुलेट करता है.

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

यह टूल, mux ऑब्जेक्ट में (बिना ऐनिमेशन वाली और बिना फ़्रैगमेंट वाली) इमेज सेट करता है. ध्यान दें: सभी मौजूदा इमेज (इनमें फ़्रेम/फ़्रैगमेंट शामिल हैं) हटा दी जाएंगी.

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

पैरामीटर: mux -- (in/out) ऑब्जेक्ट, जिसमें इमेज सेट की जानी है; बिटस्ट्रीम -- (इन) एक रॉ VP8/VP8L बिटस्ट्रीम या सिंगल-इमेज WebP फ़ाइल हो सकती है. इसमें बिना ऐनिमेशन वाली और बिना फ़्रैगमेंट वाली फ़ाइल हो सकती है; copy_data -- (in) वैल्यू 1 से पता चलता है कि दिए गए डेटा को मल्टीप्लेक्स में कॉपी किया जाएगा और वैल्यू 0 से पता चलता है कि डेटा को mux ऑब्जेक्ट में कॉपी नहीं किया जाएगा.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर mux NULL है या बिटस्ट्रीम NULL है.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन से जुड़ी गड़बड़ी पर.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxPushFrame()`

मल्टीप्लेक्स ऑब्जेक्ट के आखिर में फ़्रेम जोड़ता है.

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

Notes:

Frame.id, WEBP_CHUNK_ANMF या WEBP_CHUNK_FRGM में से एक होना चाहिए
बिना फ़्रैगमेंट वाली, बिना फ़्रैगमेंट वाली इमेज सेट करने के लिए WebPMuxSetImage() का इस्तेमाल करें.
पुश किया जाने वाला फ़्रेम और मल्टीप्लेक्स में दिया गया फ़्रेम एक ही होना चाहिए.
WebP सिर्फ़ सम ऑफ़सेट के साथ काम करता है. इसलिए, किसी भी ऑड ऑफ़सेट को ऑफ़सेट &= ~1 का इस्तेमाल करके, सम जगह पर स्नैप किया जाएगा

पैरामीटर: mux -- (in/out) ऑब्जेक्ट, जिसमें फ़्रेम जोड़ा जाना है; frame -- (इन) फ़्रेम डेटा के साथ.; copy_data -- (in) वैल्यू 1 से पता चलता है कि दिए गए डेटा को मल्टीप्लेक्स में कॉपी किया जाएगा और वैल्यू 0 से पता चलता है कि डेटा को mux ऑब्जेक्ट में कॉपी नहीं किया जाएगा.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक्स या फ़्रेम NULL है या frame का कॉन्टेंट अमान्य है.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन से जुड़ी गड़बड़ी पर.; WEBP_MUX_OK -- सफलता पर.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन से जुड़ी गड़बड़ी पर.

`WebPMuxGetFrame()`

mux ऑब्जेक्ट से nवां फ़्रेम लेता है. frame->बिटस्ट्रीम का कॉन्टेंट,maloc() का इस्तेमाल करके इकट्ठा किया जाता है. इसका मालिकाना हक mux ऑब्जेक्ट के पास नहीं होता. कॉल करने वाले व्यक्ति को WebPDataClear() पर कॉल करके, इसका पता लगाना चाहिए. nth=0 का एक खास मतलब है - आखिरी पोज़िशन.

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

पैरामीटर: mux -- (in) ऑब्जेक्ट, जिससे जानकारी फ़ेच की जानी है; nth -- (in) म्यूक्स ऑब्जेक्ट में फ़्रेम के इंडेक्स; frame -- वापस आए फ़्रेम का (बाहर) डेटा
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक्स या फ़्रेम NULL है.; WEBP_MUX_NOT_FOUND -- अगर मक्स ऑब्जेक्ट में nवें फ़्रेम से कम फ़्रेम हों, तो.; WEBP_MUX_BAD_DATA -- अगर मल्टीप्लेक्स में एनवें फ़्रेम का हिस्सा अमान्य है.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxDeleteFrame()`

mux ऑब्जेक्ट से फ़्रेम मिटाता है. nth=0 का एक खास मतलब है - आखिरी स्थिति.

WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);

पैरामीटर: mux -- (in/out) ऑब्जेक्ट, जिससे फ़्रेम मिटाया जाना है; nth -- (in) वह पोज़िशन जहां से फ़्रेम को मिटाना है
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर mux NULL है.; WEBP_MUX_NOT_FOUND -- अगर मक्स ऑब्जेक्ट में मिटाने से पहले nवें से कम फ़्रेम हैं, तो.; WEBP_MUX_OK -- सफलता पर.

Animation

एनिमेशन पैरामीटर

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

यह मल्टीप्लेक्स ऑब्जेक्ट में ऐनिमेशन पैरामीटर सेट करता है. एनिमस के पहले से मौजूद हिस्सों को हटा दिया जाएगा.

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

पैरामीटर: mux -- (in/out) ऑब्जेक्ट, जिसमें एनिम हिस्सा सेट करना/जोड़ना है; params -- (in) ऐनिमेशन पैरामीटर.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर mux या params NULL है.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन से जुड़ी गड़बड़ी पर.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxGetAnimationParams()`

मक्स ऑब्जेक्ट से ऐनिमेशन पैरामीटर हासिल करता है.

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

पैरामीटर: mux -- (in) ऑब्जेक्ट, जिससे ऐनिमेशन पैरामीटर फ़ेच किए जाने हैं; params -- (आउट) एनिम हिस्से से निकाले गए ऐनिमेशन पैरामीटर
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर mux या params NULL है.; WEBP_MUX_NOT_FOUND -- अगर मल्टीमीडिया ऑब्जेक्ट में एनीम का टुकड़ा मौजूद नहीं है.; WEBP_MUX_OK -- सफलता पर.

अन्य सुविधाएं

`WebPMuxGetCanvasSize()`

म्यूक्स ऑब्जेक्ट से कैनवस के साइज़ की जानकारी मिलती है.

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

ध्यान दें: इस तरीके का इस्तेमाल करने पर यह माना जाएगा कि अगर VP8X का हिस्सा मौजूद है, तो वह अप-टू-डेट है. इसका मतलब है कि WebPMuxAssemble() या WebPMuxCreate() पर किए गए पिछले कॉल के बाद से, mux ऑब्जेक्ट में कोई बदलाव नहीं किया गया है.

पैरामीटर: mux -- (in) ऑब्जेक्ट, जिससे कैनवस का साइज़ फ़ेच किया जाना है; width -- (बाहर) कैनवस की चौड़ाई; height -- (बाहर) कैनवस की ऊंचाई
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मल्टीप्लेक्स, चौड़ाई या ऊंचाई शून्य है.; WEBP_MUX_BAD_DATA -- अगर VP8X/VP8/VP8L हिस्से या कैनवस का साइज़ अमान्य है.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxGetFeatures()`

Max ऑब्जेक्ट से, फ़ीचर फ़्लैग की जानकारी मिलती है.

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

पैरामीटर: mux -- (in) ऑब्जेक्ट, जिससे सुविधाएं फ़ेच की जाती हैं; flags - (out) वे फ़्लैग होते हैं जिनसे यह तय होता है कि mux ऑब्जेक्ट में कौनसी सुविधाएं मौजूद हैं. यह अलग-अलग फ़्लैग वैल्यू का OR होगा. Enum WebPFeatureFlags का इस्तेमाल, अलग-अलग फ़्लैग वैल्यू की जांच करने के लिए किया जा सकता है.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक्स या फ़्लैग की वैल्यू NULL है.; WEBP_MUX_BAD_DATA -- अगर VP8X/VP8/VP8L हिस्से या कैनवस का साइज़ अमान्य है.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxNumChunks()`

mux ऑब्जेक्ट में दिए गए टैग मान वाले हिस्सों की संख्या दिखाता है.

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

पैरामीटर: mux -- (in) ऑब्जेक्ट, जिससे जानकारी फ़ेच की जानी है; id -- (in) सेगमेंट आईडी, जो खंड का टाइप तय करता है; num_elements -- (out) दिए गए खंड आईडी के साथ हिस्सों की संख्या
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर mux या num_elements NULL हैं.; WEBP_MUX_OK -- सफलता पर.

`WebPMuxAssemble()`

WebP RIFF फ़ॉर्मैट में सभी हिस्सों को इकट्ठा करता है और assembled_data में लौटाता है. यह फ़ंक्शन, मक्स ऑब्जेक्ट की भी पुष्टि करता है.

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

ध्यान दें: assembled_data की सामग्री को अनदेखा कर दिया जाएगा और ओवरराइट कर दिया जाएगा. इसके अलावा, assembled_data की सामग्री को mailoc() का इस्तेमाल करके, mux ऑब्जेक्ट के मालिकाना हक वाला नहीं है. कॉल करने वाले को WebPDataClear() पर कॉल करके इसका पता लगाना चाहिए.

पैरामीटर: mux -- (in/out) ऑब्जेक्ट जिसके खंडों को असेंबल करना है; assembled_data -- (आउट) इकट्ठा किया गया WebP डेटा
रिटर्न: WEBP_MUX_BAD_DATA -- अगर mux ऑब्जेक्ट अमान्य है.; WEBP_MUX_INVALID_ARGUMENT -- अगर mux या Assembled_data, शून्य है.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन से जुड़ी गड़बड़ी पर.; WEBP_MUX_OK -- सफलता पर.

WebPAnimEncoder एपीआई

यह एपीआई, ऐनिमेशन वाली WebP इमेज को कोड में बदलने (शायद) की अनुमति देता है.

कोड का उदाहरण

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.

ग्लोबल विकल्प

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

बदलाव से पहले, नए WebPAnimEncoderOptions स्ट्रक्चर को शुरू करने के लिए इसे हमेशा कॉल किया जाना चाहिए. वर्शन के मेल न खाने पर 'गलत' दिखाता है. enc_options ऑब्जेक्ट का इस्तेमाल करने से पहले, WebPAnimEncoderOptionsInit() पूरा होना ज़रूरी है.

पैरामीटर: enc_options -- (इन/आउट) विकल्प, जिसका इस्तेमाल ऐनिमेशन को कोड में बदलने के लिए किया जाता है
रिटर्न: सफलता पर सही.

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

WebPAnimEncoder ऑब्जेक्ट बनाता है और उसे शुरू करता है.

पैरामीटर: width/height -- (in) कैनवस की चौड़ाई और ऐनिमेशन की ऊंचाई.; enc_options -- (in) एन्कोडिंग विकल्प; सही डिफ़ॉल्ट चुनने के लिए NULL पास किया जा सकता है.
रिटर्न: नए बनाए गए WebPAnimEncoder ऑब्जेक्ट के लिए पॉइंटर या मेमोरी की गड़बड़ी होने पर शून्य.

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

`WebPAnimEncoderAdd()`

WebP के लिए दिए गए फ़्रेम को ऑप्टिमाइज़ करें, उसे कोड में बदलें, और उसे WebPAnimEncoder ऑब्जेक्ट में जोड़ें.

WebPAnimEncoderAdd का आखिरी कॉल frame = NULL के साथ होना चाहिए. इससे पता चलता है कि अब और फ़्रेम नहीं जोड़े जाने चाहिए. इस कॉल का इस्तेमाल आखिरी फ़्रेम की अवधि तय करने के लिए भी किया जाता है.

पैरामीटर: enc -- (in/out) ऑब्जेक्ट है, जिसमें फ़्रेम जोड़ा जाना है.; frame -- ARGB या YUV(A) फ़ॉर्मैट में(इन/आउट) फ़्रेम डेटा. अगर यह YUV(A) फ़ॉर्मैट में है, तो यह ARGB में बदल दिया जाएगा. इसमें कुछ हद तक नुकसान होगा.; timestamp_ms -- (in) इस फ़्रेम का टाइमस्टैंप मिलीसेकंड में. फ़्रेम की अवधि की गिनती, "अगले फ़्रेम के टाइमस्टैंप - इस फ़्रेम के टाइमस्टैंप" से की जाएगी. इसलिए, टाइमस्टैंप कम न होने वाले क्रम में होने चाहिए.; config -- (in) एन्कोडिंग विकल्प; उचित डिफ़ॉल्ट चुनने के लिए NULL पास किया जा सकता है.
रिटर्न: गड़बड़ी होने पर, 'गलत' दिखाता है और frame->error_code सही तरीके से सेट होता है. अगर ऐसा नहीं है, तो 'सही' दिखाता है.

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

`WebPAnimEncoderAssemble()`

WebP बिटस्ट्रीम में, अब तक जोड़े गए सभी फ़्रेम इकट्ठा करें. इस कॉल से पहले WebPAnimEncoderAdd पर frame = NULL कॉल किया जाना चाहिए. अगर ऐसा नहीं है, तो आखिरी फ़्रेम की अवधि अंदरूनी तौर पर अनुमान लगाई जाएगी.

पैरामीटर: enc -- (in/out) ऑब्जेक्ट, जिससे फ़्रेम असेंबल होने वाले हैं.; webp_data -- (आउट) किया गया WebP बिटस्ट्रीम.
रिटर्न: सफलता पर सही.

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

`WebPAnimEncoderGetError()`

enc का इस्तेमाल करके, हाल ही के कॉल से जुड़ी गड़बड़ी वाली स्ट्रिंग पाएं. वापस की गई स्ट्रिंग का मालिकाना हक enc के पास है. यह सिर्फ़ WebPAnimEncoderAdd() या WebPAnimEncoderAssemble() या WebPAnimEncoderDelete() पर अगले कॉल तक मान्य है.

पैरामीटर: enc -- (in/out) ऑब्जेक्ट, जिससे गड़बड़ी वाली स्ट्रिंग को फ़ेच करना है.
रिटर्न: NULL if enc is NULL. नहीं तो, अगर आखिरी बार enc पर किए गए कॉल में कोई गड़बड़ी हुई थी, तो गड़बड़ी वाली स्ट्रिंग दिखती है. अगर आखिरी कॉल सफल हो गया था, तो वह खाली स्ट्रिंग दिखाता है.

const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);

`WebPAnimEncoderDelete()`

WebPAnimEncoder ऑब्जेक्ट को मिटाता है.

पैरामीटर: enc -- (in/out) ऑब्जेक्ट मिटाया जाना है

void WebPAnimEncoderDelete(WebPAnimEncoder* enc);

Demux API

WebP फ़ाइलों से इमेज और एक्सटेंडेड फ़ॉर्मैट के डेटा को निकालने की सुविधा चालू करता है.

कोड के उदाहरण

सभी फ़्रेम, ICC प्रोफ़ाइल, और EXIF/XMP मेटाडेटा को एक्सट्रैक्ट करने के लिए, WebP डेटा को डीमक्स करना

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

डीमक्स ऑब्जेक्ट की ज़िंदगी

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

हर मेजर/माइनर/रिविज़न के लिए 8 बिट का इस्तेमाल करके, हेक्साडेसिमल में पैक की गई डीमक्स लाइब्रेरी का वर्शन नंबर दिखाता है. उदाहरण के लिए, v2.5.7 0x020507 है.

int WebPGetDemuxVersion(void);

`WebPDemux()`

data से दी गई पूरी WebP फ़ाइल को पार्स करता है.

WebPDemuxer WebPDemux(const WebPData* data);

सफल पार्स पर WebPDemuxer ऑब्जेक्ट देता है, नहीं तो NULL देता है.

`WebPDemuxPartial()`

डेटा से दी गई संभावित अधूरी WebP फ़ाइल को पार्स करता है. अगर state फ़ंक्शन शून्य नहीं है, तो इसे डीमक्सर की स्थिति दिखाने के लिए सेट किया जाएगा.

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

गड़बड़ी होने पर या पार्स करने के लिए ज़रूरी डेटा मौजूद न होने पर NULL देता है; और पार्स करने के बाद, WebPDemuxer ऑब्जेक्ट दिखाता है.

ध्यान दें कि WebPDemuxer, इंटरनल पॉइंटर को डेटा मेमोरी सेगमेंट में सेव रखता है. अगर यह डेटा बार-बार बदला जा सकता है, तो डीमक्सर ऑब्जेक्ट को WebPDemuxDelete() पर कॉल करके मिटाया जाना चाहिए. इसके बाद, WebPDemuxPartial() नए डेटा पर फिर से कॉल किया जाना चाहिए. आम तौर पर, यह काफ़ी सस्ता काम है.

`WebPDemuxDelete()`

dmux से जुड़ी मेमोरी को खाली करता है.

void WebPDemuxDelete(WebPDemuxer* dmux);

डेटा/जानकारी निकालना

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

dmux से feature वैल्यू पाएं.

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

ध्यान दें: वैल्यू सिर्फ़ तब मान्य होती हैं, जब WebPDemux() का इस्तेमाल किया गया हो या WebPDemuxPartial() ने कोई स्टेटस दिखाया हो > WEBP_DEMUX_PARSING_HEADER.

फ़्रेम इटरेशन

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

dmux से फ़्रेम frame_number पाता है.

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

iter->fragment इस फ़ंक्शन से रिटर्न मिलने पर, पहले फ़्रैगमेंट को पॉइंट करता है. WebPDemuxSelectFragment() का इस्तेमाल करके, अलग-अलग फ़्रैगमेंट निकाले जा सकते हैं. frame_number को 0 के बराबर सेट करने से, इमेज का आखिरी फ़्रेम दिखेगा.

अगर dmux NULL है या फ़्रेम frame_number मौजूद नहीं है, तो 'गलत' दिखाता है. इटरेटर का इस्तेमाल पूरा होने के बाद, WebPDemuxReleaseIterator() को कॉल करें.

ध्यान दें: dmux हमेशा iter के हिसाब से बना होना चाहिए.

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

अगले (iter->fragment + 1) या पिछले (iter->fragment - 1) फ़्रेम पर ले जाने के लिए iter->fragment सेट करता है. ये फ़ंक्शन लूप नहीं करते.

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

सही होने पर 'सही' दिखाता है, नहीं तो 'गलत' दिखाता है.

`WebPDemuxSelectFragment()`

फ़्रैगमेंट नंबर iter->fragment दिखाने के लिए, iter->fragment सेट करता है.

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

फ़्रैगमेंट fragment_num मौजूद होने पर 'सही' दिखाता है. ऐसा न होने पर 'गलत' दिखाता है.

`WebPDemuxReleaseIterator()`

iter से जुड़ी किसी भी 'यादें' को रिलीज़ करता है.

void WebPDemuxReleaseIterator(WebPIterator* iter);

उसी इटर पर WebPDemuxGetChunk() पर किसी भी बाद के कॉल से पहले कॉल किया जाना चाहिए. साथ ही, WebPDemuxDelete() से जुड़े WebPDemuxer को बंद करने से पहले इसे कॉल करना होगा.

चंक इटरेशन

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

dmux से fourcc आईडी वाले हिस्से के chunk_number इंस्टेंस को फिर से हासिल किया जाता है.

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

फ़ोरसीसी, वर्ण का एक कलेक्शन है. इसमें दिए गए हिस्से को दिखाने के लिए फ़ोरसीसी होते हैं, उदाहरण के लिए, "ICCP", "XMP ", "EXIF" वगैरह.

chunk_number को 0 के बराबर सेट करने से किसी सेट का पिछला हिस्सा वापस मिलेगा.

डेटा का हिस्सा मिलने पर 'सही' दिखाता है. ऐसा न होने पर 'गलत' दिखाता है. इमेज से जुड़े डेटा के हिस्से को WebPDemuxGetFrame() और उससे जुड़े फ़ंक्शन से ऐक्सेस किया जाता है. इटरेटर का इस्तेमाल पूरा होने के बाद, WebPDemuxReleaseChunkIterator() को कॉल करें.

ध्यान दें: dmux, फिर से चलाने वाले के पूरे समय के लिए मौजूद होना चाहिए.

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

iter->chunk को अगले (iter->chunk_num + 1) या पिछले (iter->chunk_num - 1) हिस्से पर ले जाने के लिए सेट किया जाता है. ये फ़ंक्शन लूप नहीं करते.

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

सही होने पर 'सही' दिखाता है, नहीं तो 'गलत' दिखाता है.

`WebPDemuxReleaseChunkIterator()`

iter से जुड़ी किसी भी 'यादें' को रिलीज़ करता है.

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);

WebPDemuxDelete() से जुड़े WebPDemuxer को मिटाने से पहले, इसे कॉल किया जाना चाहिए.

WebPAnimDecoder एपीआई

यह एपीआई, ऐनिमेशन वाली WebP इमेज को डिकोड करने (शायद) की अनुमति देता है.

कोड का उदाहरण

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.

ग्लोबल विकल्प

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

बदलाव से पहले, नए WebPAnimDecoderOptions स्ट्रक्चर को शुरू करने के लिए इसे हमेशा कॉल किया जाना चाहिए. वर्शन के मेल न खाने पर 'गलत' दिखाता है. dec_options ऑब्जेक्ट का इस्तेमाल करने से पहले, WebPAnimDecoderOptionsInit() पूरा होना ज़रूरी है.

पैरामीटर

dec_options -- (इन/आउट) विकल्प, जिसका इस्तेमाल ऐनिमेशन को डिकोड करने के लिए किया जाता है

रिटर्न: सफलता पर सही

int WebPAnimDecoderOptionsInit(
    WebPAnimDecoderOptions* dec_options);

`WebPAnimDecoderNew()`

WebPAnimDecoder ऑब्जेक्ट को बनाता है और उसे शुरू करता है.

पैरामीटर: webp_data -- (in) WebP बिटस्ट्रीम. आउटपुट WebPAnimDecoder ऑब्जेक्ट के दौरान, इसमें कोई बदलाव नहीं होगा.; dec_options -- (in) डिकोड करने के विकल्प. उचित डिफ़ॉल्ट चुनने के लिए NULL को भेजा जा सकता है (खास तौर पर, रंग मोड MODE_RGBA चुना जाएगा).
रिटर्न: नए बनाए गए WebPAnimDecoder ऑब्जेक्ट के लिए पॉइंटर या पार्स करने में गड़बड़ी, अमान्य विकल्प या मेमोरी की गड़बड़ी के मामले में शून्य.

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

ऐनिमेशन के बारे में सभी देशों में जानकारी.

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

`WebPAnimDecoderGetInfo()`

ऐनिमेशन के बारे में दुनिया भर में जानकारी पाएं.

पैरामीटर: dec -- (in) डिकोडर इंस्टेंस से जानकारी पाने के लिए.; info -- ऐनिमेशन से मिली वैश्विक जानकारी.
रिटर्न: सफलता पर सही.

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

`WebPAnimDecoderGetNext()`

WebPAnimDecoderNew() को दिए गए विकल्पों के आधार पर, डेक से अगला फ़्रेम फ़ेच करें. यह सिर्फ़ फ़्रेम सब-रेक्टैंगल नहीं, बल्कि पूरी तरह से फिर से बनाया गया canvas_width * 4 * canvas_height साइज़ का कैनवस होगा. लौटाया गया बफ़र बफ़ सिर्फ़ तब तक मान्य है, जब तक WebPAnimDecoderGetNext(), WebPAnimDecoderReset() या WebPAnimDecoderDelete() को अगला कॉल नहीं किया जाता.

पैरामीटर: dec -- (इन/आउट) डिकोडर इंस्टेंस जिससे अगले फ़्रेम को फ़ेच करना है.; buf -- (आउट) डिकोड किया गया फ़्रेम.; timestamp -- (आउट) फ़्रेम का टाइमस्टैंप मिलीसेकंड में.
रिटर्न: अगर कोई भी तर्क NULL है या पार्स या डिकोड करने में कोई गड़बड़ी हुई है या कोई फ़्रेम नहीं है, तो वैल्यू 'गलत' है. अगर ऐसा नहीं है, तो 'सही' दिखाता है.

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

`WebPAnimDecoderHasMoreFrames()`

देखें कि क्या डिकोड करने के लिए और फ़्रेम बचे हैं.

पैरामीटर: dec -- (in) डिकोडर इंस्टेंस चुनना है.
रिटर्न: अगर dec शून्य नहीं है और कुछ फ़्रेम अभी डिकोड नहीं हुए हैं, तो वैल्यू सही है. नहीं तो, 'गलत' दिखाता है.

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

WebPAnimDecoder ऑब्जेक्ट को रीसेट करता है. इससे WebPAnimDecoderGetNext() पर होने वाला अगला कॉल, पहले फ़्रेम से डीकोडिंग को फिर से शुरू कर देगा. यह तब मददगार होता है, जब सभी फ़्रेम को dec ऑब्जेक्ट को नष्ट किए बिना और फिर से बनाए बिना, कई बार डिकोड करना होता है. जैसे, info.loop_count बार.

पैरामीटर: dec -- (इन/आउट) डिकोडर इंस्टेंस रीसेट करना है

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

इंटरनल डीमक्सर ऑब्जेक्ट को पकड़ें.

अगर कोई व्यक्ति, सिर्फ़ demuxer के ज़रिए उपलब्ध कार्रवाइयों का इस्तेमाल करना चाहता है, तो Demuxer ऑब्जेक्ट पाना फ़ायदेमंद हो सकता है. उदाहरण के लिए, XMP/EXIF/ICC मेटाडेटा पाना. दिखाए गए डिमक्सर ऑब्जेक्ट का मालिकाना हक dec है और यह सिर्फ़ WebPAnimDecoderDelete() पर अगला कॉल आने तक मान्य है.

पैरामीटर: dec -- (in) डिकोडर इंस्टेंस, जिससे डीमक्सर ऑब्जेक्ट को फ़ेच करना है.

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

WebPAnimDecoder ऑब्जेक्ट को मिटाता है.

पैरामीटर: dec -- (in/out) डिकोडर इंस्टेंस मिटाना है.
रिटर्न: सफलता पर सही.

void WebPAnimDecoderDelete(WebPAnimDecoder* dec);

सामान्य डेटा टाइप

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

webp_data ऑब्जेक्ट के कॉन्टेंट को डिफ़ॉल्ट वैल्यू के साथ शुरू करता है.

void WebPDataInit(WebPData* webp_data);

`WebPDataClear()`

free() को कॉल करके, webp_data ऑब्जेक्ट का कॉन्टेंट मिटाता है. ऑब्जेक्ट को खुद से डील नहीं करता.

void WebPDataClear(WebPData* webp_data);

`WebPDataCopy()`

dst के लिए ज़रूरी स्टोरेज तय करता है और src के कॉन्टेंट को कॉपी करता है. सफल होने पर 'सही' दिखाता है.

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

WebP कंटेनर एपीआई दस्तावेज़

Max API

कोड के उदाहरण

इमेज डेटा, कलर प्रोफ़ाइल, और XMP मेटाडेटा की मदद से MUX बनाना

WebP फ़ाइल से इमेज और कलर प्रोफ़ाइल का डेटा पाना

मक्स ऑब्जेक्ट की ज़िंदगी

Enums

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

म्यूक्स क्रिएशन

WebPMuxCreate()

बिना इमेज वाले हिस्से

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

इमेज

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

Animation

एनिमेशन पैरामीटर

WebPMuxSetAnimationParams()

WebPMuxGetAnimationParams()

अन्य सुविधाएं

WebPMuxGetCanvasSize()

WebPMuxGetFeatures()

WebPMuxNumChunks()

WebPMuxAssemble()

WebPAnimEncoder एपीआई

WebPAnimEncoderOptionsInit()

WebPAnimEncoderNew()

WebPAnimEncoderAdd()

WebPAnimEncoderAssemble()

WebPAnimEncoderGetError()

WebPAnimEncoderDelete()

Demux API

कोड के उदाहरण

सभी फ़्रेम, ICC प्रोफ़ाइल, और EXIF/XMP मेटाडेटा को एक्सट्रैक्ट करने के लिए, WebP डेटा को डीमक्स करना

डीमक्स ऑब्जेक्ट की ज़िंदगी

Enums

WebPGetDemuxVersion()

WebPDemux()

WebPDemuxPartial()

WebPDemuxDelete()

डेटा/जानकारी निकालना

WebPDemuxGetI()

फ़्रेम इटरेशन

WebPDemuxGetFrame()

WebPDemuxNextFrame(), WebPDemuxPrevFrame()

WebPDemuxSelectFragment()

WebPDemuxReleaseIterator()

चंक इटरेशन

WebPDemuxGetChunk()

WebPDemuxNextChunk(), WebPDemuxPrevChunk()

WebPDemuxReleaseChunkIterator()

WebPAnimDecoder एपीआई

WebPAnimDecoderOptionsInit()

WebPAnimDecoderNew()

WebPAnimDecoderGetInfo()

WebPAnimDecoderGetNext()

WebPAnimDecoderHasMoreFrames()

WebPAnimDecoderReset()

WebPAnimDecoderGetDemuxer()

WebPAnimDecoderDelete()

सामान्य डेटा टाइप

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