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

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

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

मुक्स एपीआई

यह 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 -- (इन/आउट) ऑब्जेक्ट को मिटाना है

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

`WebPMuxCreate()`

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

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

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

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

`WebPMuxSetChunk()`

mux ऑब्जेक्ट में 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 -- (इन/आउट) वह ऑब्जेक्ट जिसमें डेटा ग्रुप जोड़ना है; fourcc -- (इसमें) दी गई वर्ण की चौड़ी श्रेणी वाली वर्ण सारणी chunk; उदाहरण, "आईसीसीपी", "XMP", "EXIF" वगैरह; chunk_data -- (इसमें) वह डेटा शामिल करें जिसे जोड़ा जाना है; copy_data -- (in) वैल्यू 1 बताती है कि दिया गया डेटा, mux में कॉपी किया जाएगा वहीं, वैल्यू 0 से पता चलता है कि डेटा को mux ऑब्जेक्ट में कॉपी नहीं किया जाएगा.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर mux, fourcc या chunk_data शून्य है या अगर 4cc की वैल्यू, इमेज के हिस्से से मेल खाती है.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन की गड़बड़ी होने पर.; WEBP_MUX_OK -- सफलता मिलने पर.

`WebPMuxGetChunk()`

mux ऑब्जेक्ट में चौथाई आईडी वाले हिस्से के डेटा का रेफ़रंस मिलता है. कॉलर को लौटाया गया डेटा खाली नहीं करना चाहिए.

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

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

`WebPMuxDeleteChunk()`

मक्स ऑब्जेक्ट से दिए गए फ़ोरसीसी वाले हिस्से को मिटाता है.

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

पैरामीटर: mux -- (इन/आउट) ऑब्जेक्ट जिससे डेटा ग्रुप को मिटाना है; Forcc -- (इसमें) एक वर्ण अरे, जिसमें डेटा को शामिल करने के लिए 'चौथाई' का इस्तेमाल किया गया हो; उदाहरण, "आईसीसीपी", "XMP", "EXIF" वगैरह
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक्स या फ़ोर पास की वैल्यू शून्य है या फ़ोरसीसी है इमेज के हिस्से से मेल खाता हो.; 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()`

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

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

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

`WebPMuxPushFrame()`

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

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

ध्यान दें:

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

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

`WebPMuxGetFrame()`

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

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

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

`WebPMuxDeleteFrame()`

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

WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);

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

ऐनिमेशन

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

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 -- (इन/आउट) वह ऑब्जेक्ट जिसमें Animal चंक को सेट करना/जोड़ना है; params -- (इन) ऐनिमेशन पैरामीटर.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- अगर मक या पैरामीटर शून्य हैं.; WEBP_MUX_MEMORY_ERROR -- मेमोरी ऐलोकेशन की गड़बड़ी होने पर.; WEBP_MUX_OK -- सफलता मिलने पर.

`WebPMuxGetAnimationParams()`

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

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

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

अन्य काम की सेवाएं

`WebPMuxGetCanvasSize()`

मक्स ऑब्जेक्ट से कैनवस का साइज़ लेता है.

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

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

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

`WebPMuxGetFeatures()`

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

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

पैरामीटर: mux -- (in) ऑब्जेक्ट जिससे सुविधाओं को फ़ेच किया जाना है; flags -- (out) वह फ़्लैग जिससे तय होता है कि मल्टीप्लेक्स में कौन सी सुविधाएं मौजूद हैं ऑब्जेक्ट है. यह अलग-अलग फ़्लैग की वैल्यू का एक OR होगा. इनम WebPFeatureFlags का इस्तेमाल करके अलग-अलग फ़्लैग वैल्यू की जांच की जा सकती है.
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- if mux or flags is 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 -- (इसमें) डेटा समूह का प्रकार बताने वाला समूह आईडी; num_elements -- (आउट) दिए गए चंक आईडी के साथ डेटा के हिस्से की संख्या
रिटर्न: WEBP_MUX_INVALID_ARGUMENT -- if mux, or num_elements is NULL.; WEBP_MUX_OK -- सफलता मिलने पर.

`WebPMuxAssemble()`

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

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

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

पैरामीटर: mux -- (इन/आउट) ऑब्जेक्ट जिसके टुकड़ों को जोड़ना है; assembled_data -- (आउट) असेंबल किया गया WebP डेटा
रिटर्न: WEBP_MUX_BAD_DATA -- अगर मक्स ऑब्जेक्ट अमान्य है.; WEBP_MUX_INVALID_ARGUMENT -- if mux or assembled_data is NULL.; 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 ऑब्जेक्ट मौजूद है.

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

int WebPAnimEncoderOptionsInit(
    WebPAnimEncoderOptions* enc_options);

`WebPAnimEncoderNew()`

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

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

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

`WebPAnimEncoderAdd()`

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

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

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

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

`WebPAnimEncoderAssemble()`

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

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

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

`WebPAnimEncoderGetError()`

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

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

const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);

`WebPAnimEncoderDelete()`

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

पैरामीटर: enc -- (इन/आउट) ऑब्जेक्ट मिटाना है

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 ऑब्जेक्ट दिखाता है, नहीं तो शून्य होता.

`WebPDemuxPartial()`

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

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

गड़बड़ी होने पर या पार्स करने के लिए ज़रूरत के मुताबिक डेटा न होने पर, नतीजे शून्य के तौर पर दिखते हैं; और पार्स हो जाने पर 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 से सुविधा का मान पाएं.

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 शून्य है या फ़्रेम dmux मौजूद नहीं है, तो गलत जानकारी देता है. WebPDemuxReleaseIterator() को तब कॉल करें, जब इटरेटर पूरा हो गया है.

ध्यान दें: dmux को iter के लाइफ़टाइम तक बना रहना चाहिए.

`WebPDemuxNextFrame()`, `WebPDemuxPrevFrame()`

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

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

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

`WebPDemuxSelectFragment()`

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

int WebPDemuxSelectFragment(WebPIterator* iter, int fragment_num);

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

`WebPDemuxReleaseIterator()`

इटर से जुड़ी किसी भी मेमोरी को रिलीज़ करता है.

void WebPDemuxReleaseIterator(WebPIterator* iter);

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

एक साथ इटरेशन

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

fourcc आईडी वाले समूह के chunk_number इंस्टेंस को फ़ेच करता है dmux शामिल है.

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

Forcc एक वर्ण सारणी है, जिसमें लौटने के लिए चंक का चौथाई हिस्सा होता है, उदाहरण, "ICCP", "XMP ", "EXIF" वगैरह

chunk_number को 0 के बराबर सेट करने पर, किसी सेट का आखिरी हिस्सा दिखेगा.

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

ध्यान दें: dmux को इटरेटर के लाइफ़टाइम तक बना रहना चाहिए.

`WebPDemuxNextChunk()`, `WebPDemuxPrevChunk()`

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

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

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

`WebPDemuxReleaseChunkIterator()`

इटर से जुड़ी किसी भी मेमोरी को रिलीज़ करता है.

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);

इससे जुड़े WebPDemuxer को बंद करने से पहले कॉल करना ज़रूरी है WebPDemuxDelete().

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 ऑब्जेक्ट का इस्तेमाल करें.

पैरामीटर

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

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

int WebPAnimDecoderOptionsInit(
    WebPAnimDecoderOptions* dec_options);

`WebPAnimDecoderNew()`

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

पैरामीटर: webp_data -- (इन) WebP बिटस्ट्रीम. आप इनमें से किसी भी अवधि के दौरान आउटपुट WebPAnimDecoder ऑब्जेक्ट का लाइफ़टाइम.; dec_options -- (इन) डिकोड करने के विकल्प. विकल्प चुनने के लिए, शून्य को पास किया जा सकता है सही डिफ़ॉल्ट (खास तौर पर, कलर मोड मोड_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 साइज़ का, फिर से बनाया गया कैनवस फ़्रेम के सब-रेक्टैंगल को हाइलाइट कर सकते हैं. लौटाया गया बफ़र buf सिर्फ़ तब तक मान्य है, जब तक WebPAnimDecoderGetNext() को किया गया अगला कॉल, WebPAnimDecoderReset() या WebPAnimDecoderDelete().

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

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

`WebPAnimDecoderHasMoreFrames()`

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

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

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);

`WebPAnimDecoderReset()`

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

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

void WebPAnimDecoderReset(WebPAnimDecoder* dec);

`WebPAnimDecoderGetDemuxer()`

अंदरूनी डीमक्सर ऑब्जेक्ट को लें.

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

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

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec);

`WebPAnimDecoderDelete()`

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

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

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 कंटेनर एपीआई दस्तावेज़

मुक्स एपीआई

कोड के उदाहरण

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

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

एक मुक्स ऑब्जेक्ट का जीवन

Enums

WebPGetMuxVersion()

WebPMuxNew()

WebPMuxDelete()

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

WebPMuxCreate()

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

WebPMuxSetChunk()

WebPMuxGetChunk()

WebPMuxDeleteChunk()

इमेज

WebPMuxSetImage()

WebPMuxPushFrame()

WebPMuxGetFrame()

WebPMuxDeleteFrame()

ऐनिमेशन

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

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