หน้านี้ได้รับการแปลโดย Cloud Translation API

เอกสารประกอบของ WebP API

ส่วนนี้จะอธิบาย API สําหรับโปรแกรมเข้ารหัสและโปรแกรมถอดรหัสที่รวมอยู่ในไลบรารี WebP คําอธิบาย API นี้เกี่ยวข้องกับเวอร์ชัน 1.5.0

ส่วนหัวและไลบรารี

เมื่อคุณติดตั้ง libwebp ระบบจะติดตั้งไดเรกทอรีชื่อ webp/ ในตำแหน่งทั่วไปสำหรับแพลตฟอร์มของคุณ ตัวอย่างเช่น ในแพลตฟอร์ม Unix ระบบจะคัดลอกไฟล์ส่วนหัวต่อไปนี้ไปยัง /usr/local/include/webp/

decode.h
encode.h
types.h

ไลบรารีจะอยู่ในไดเรกทอรีไลบรารีปกติ ไลบรารีแบบคงที่และแบบไดนามิกอยู่ใน /usr/local/lib/ บนแพลตฟอร์ม Unix

Simple Decoding API

หากต้องการเริ่มต้นใช้งานการถอดรหัส API คุณต้องตรวจสอบว่าได้ติดตั้งไลบรารีและไฟล์ส่วนหัวตามที่อธิบายไว้ด้านบน

รวมส่วนหัวของ API สำหรับการถอดรหัสไว้ในโค้ด C/C++ ดังนี้

#include "webp/decode.h"
int WebPGetInfo(const uint8_t* data, size_t data_size, int* width, int* height);

ฟังก์ชันนี้จะตรวจสอบส่วนหัวของรูปภาพ WebP และดึงข้อมูลความกว้างและความสูงของรูปภาพ คุณสามารถส่งเคอร์เซอร์ *width และ *height ไปยัง NULL ได้หากเห็นว่าไม่เกี่ยวข้อง

แอตทริบิวต์อินพุต

ข้อมูล: พอยเตอร์ไปยังข้อมูลรูปภาพ WebP
data_size: นี่คือขนาดของบล็อกหน่วยความจำที่ data ชี้ถึงซึ่งมีข้อมูลรูปภาพ

การคืนสินค้า

เท็จ: รหัสข้อผิดพลาดที่แสดงในกรณีที่ (ก) ข้อผิดพลาดด้านการจัดรูปแบบ
จริง: เมื่อดำเนินการสำเร็จ *width และ *height จะใช้ได้เฉพาะในกรณีที่ส่งคืนสำเร็จเท่านั้น
ความกว้าง: ค่าจำนวนเต็ม ช่วงจะจำกัดอยู่ที่ 1 ถึง 16383
ส่วนสูง: ค่าจำนวนเต็ม ช่วงมีตั้งแต่ 1 ถึง 16383

struct WebPBitstreamFeatures {
  int width;          // Width in pixels.
  int height;         // Height in pixels.
  int has_alpha;      // True if the bitstream contains an alpha channel.
  int has_animation;  // True if the bitstream is an animation.
  int format;         // 0 = undefined (/mixed), 1 = lossy, 2 = lossless
}

VP8StatusCode WebPGetFeatures(const uint8_t* data,
                              size_t data_size,
                              WebPBitstreamFeatures* features);

ฟังก์ชันนี้จะดึงข้อมูลฟีเจอร์จากบิตสตรีม โครงสร้าง *features จะเต็มไปด้วยข้อมูลที่รวบรวมจากบิตสตรีม ดังนี้

แอตทริบิวต์อินพุต

ข้อมูล: พอยเตอร์ไปยังข้อมูลรูปภาพ WebP
data_size: นี่คือขนาดของบล็อกหน่วยความจำที่ data ชี้ถึงซึ่งมีข้อมูลรูปภาพ

การคืนสินค้า

VP8_STATUS_OK: เมื่อดึงข้อมูลฟีเจอร์สําเร็จ
VP8_STATUS_NOT_ENOUGH_DATA: เมื่อต้องการข้อมูลเพิ่มเติมเพื่อดึงข้อมูลฟีเจอร์จากส่วนหัว

ค่าข้อผิดพลาด VP8StatusCode เพิ่มเติมในกรณีอื่นๆ

ฟีเจอร์: พอยเตอร์ไปยังโครงสร้าง WebPBitstreamFeatures

uint8_t* WebPDecodeRGBA(const uint8_t* data, size_t data_size, int* width, int* height);
uint8_t* WebPDecodeARGB(const uint8_t* data, size_t data_size, int* width, int* height);
uint8_t* WebPDecodeBGRA(const uint8_t* data, size_t data_size, int* width, int* height);
uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size, int* width, int* height);
uint8_t* WebPDecodeBGR(const uint8_t* data, size_t data_size, int* width, int* height);

ฟังก์ชันเหล่านี้จะถอดรหัสรูปภาพ WebP ที่ data ชี้ถึง

WebPDecodeRGBA จะแสดงตัวอย่างรูปภาพ RGBA ตามลําดับ [r0, g0, b0, a0, r1, g1, b1, a1, ...]
WebPDecodeARGB จะแสดงตัวอย่างรูปภาพ ARGB ตามลําดับ [a0, r0, g0, b0, a1, r1, g1, b1, ...]
WebPDecodeBGRA จะแสดงตัวอย่างรูปภาพ BGRA ตามลําดับ [b0, g0, r0, a0, b1, g1, r1, a1, ...]
WebPDecodeRGB จะแสดงตัวอย่างรูปภาพ RGB ตามลําดับ [r0, g0, b0, r1, g1, b1, ...]
WebPDecodeBGR จะแสดงตัวอย่างรูปภาพ BGR ตามลําดับ [b0, g0, r0, b1, g1, r1, ...]

โค้ดที่เรียกใช้ฟังก์ชันเหล่านี้ต้องลบบัฟเฟอร์ข้อมูล (uint8_t*) ที่แสดงผลโดยฟังก์ชันเหล่านี้ด้วย WebPFree()

แอตทริบิวต์อินพุต

ข้อมูล: พอยเตอร์ไปยังข้อมูลรูปภาพ WebP
data_size: นี่คือขนาดของบล็อกหน่วยความจำที่ data ชี้ถึงซึ่งมี ข้อมูลรูปภาพ
ความกว้าง: ค่าจำนวนเต็ม ปัจจุบันช่วงของค่าจะจำกัดอยู่ที่ 1 ถึง 16383
ส่วนสูง: ค่าจำนวนเต็ม ปัจจุบันช่วงมีขีดจำกัดอยู่ที่ 1 ถึง 16383

การคืนสินค้า

uint8_t*: พอยเตอร์ไปยังตัวอย่างรูปภาพ WebP ที่ถอดรหัสแล้วในรูปแบบ RGBA/ARGB/BGRA/RGB/BGR แบบเชิงเส้นตามลำดับ

uint8_t* WebPDecodeRGBAInto(const uint8_t* data, size_t data_size,
                            uint8_t* output_buffer, int output_buffer_size, int output_stride);
uint8_t* WebPDecodeARGBInto(const uint8_t* data, size_t data_size,
                            uint8_t* output_buffer, int output_buffer_size, int output_stride);
uint8_t* WebPDecodeBGRAInto(const uint8_t* data, size_t data_size,
                            uint8_t* output_buffer, int output_buffer_size, int output_stride);
uint8_t* WebPDecodeRGBInto(const uint8_t* data, size_t data_size,
                           uint8_t* output_buffer, int output_buffer_size, int output_stride);
uint8_t* WebPDecodeBGRInto(const uint8_t* data, size_t data_size,
                           uint8_t* output_buffer, int output_buffer_size, int output_stride);

ฟังก์ชันเหล่านี้เป็นรูปแบบของฟังก์ชันข้างต้นและจะถอดรหัสรูปภาพโดยตรงลงในบัฟเฟอร์ output_buffer ที่จัดสรรไว้ล่วงหน้า พื้นที่เก็บข้อมูลสูงสุดที่ใช้ได้ในส่วนบัฟเฟอร์นี้ระบุด้วย output_buffer_size หากพื้นที่เก็บข้อมูลนี้ไม่เพียงพอ (หรือเกิดข้อผิดพลาด) ระบบจะแสดงผล NULL มิเช่นนั้น ระบบจะแสดงผล output_buffer เพื่ออำนวยความสะดวก

พารามิเตอร์ output_stride ระบุระยะห่าง (เป็นไบต์) ระหว่างบรรทัดการสแกน ดังนั้น output_buffer_size ควรมีค่าอย่างน้อย output_stride * picture - height

แอตทริบิวต์อินพุต

ข้อมูล: พอยเตอร์ไปยังข้อมูลรูปภาพ WebP
data_size: นี่คือขนาดของบล็อกหน่วยความจำที่ data ชี้ถึงซึ่งมีข้อมูลรูปภาพ
output_buffer_size: ค่าจำนวนเต็ม ขนาดของบัฟเฟอร์ที่จัดสรร
output_stride: ค่าจำนวนเต็ม ระบุระยะห่างระหว่างเส้นสแกน

การคืนสินค้า

output_buffer: พอยเตอร์ไปยังรูปภาพ WebP ที่ถอดรหัสแล้ว
uint8_t*: output_buffer หากฟังก์ชันทำงานสำเร็จ หรือ NULL หากไม่สำเร็จ

Advanced Decoding API

การถอดรหัส WebP รองรับ API ขั้นสูงเพื่อให้สามารถครอบตัดและปรับขนาดใหม่ได้ขณะใช้งาน ซึ่งมีประโยชน์อย่างยิ่งในสภาพแวดล้อมที่มีหน่วยความจำจํากัด เช่น โทรศัพท์มือถือ โดยพื้นฐานแล้ว การใช้งานหน่วยความจำจะปรับตามขนาดของเอาต์พุต ไม่ใช่อินพุตเมื่อผู้ใช้ต้องการแค่ดูตัวอย่างอย่างรวดเร็วหรือดูเฉพาะส่วนที่ซูมเข้าของรูปภาพขนาดใหญ่ นอกจากนี้ คุณยังประหยัดทรัพยากร CPU บางส่วนได้ด้วย

การถอดรหัส WebP มี 2 รูปแบบ ได้แก่ การถอดรหัสรูปภาพทั้งหมดและการถอดรหัสแบบเพิ่มทีละน้อยผ่านบัฟเฟอร์อินพุตขนาดเล็ก ผู้ใช้สามารถระบุบัฟเฟอร์หน่วยความจำภายนอกสำหรับการถอดรหัสรูปภาพได้ ตัวอย่างโค้ดต่อไปนี้จะอธิบายขั้นตอนการใช้ API การถอดรหัสขั้นสูง

ก่อนอื่นเราต้องเริ่มต้นวัตถุการกําหนดค่า

#include "webp/decode.h"

WebPDecoderConfig config;
CHECK(WebPInitDecoderConfig(&config));

// One can adjust some additional decoding options:
config.options.no_fancy_upsampling = 1;
config.options.use_scaling = 1;
config.options.scaled_width = scaledWidth();
config.options.scaled_height = scaledHeight();
// etc.

ระบบจะรวบรวมตัวเลือกการถอดรหัสภายในโครงสร้าง WebPDecoderConfig ดังนี้

struct WebPDecoderOptions {
  int bypass_filtering;             // if true, skip the in-loop filtering
  int no_fancy_upsampling;          // if true, use faster pointwise upsampler
  int use_cropping;                 // if true, cropping is applied first 
  int crop_left, crop_top;          // top-left position for cropping.
                                    // Will be snapped to even values.
  int crop_width, crop_height;      // dimension of the cropping area
  int use_scaling;                  // if true, scaling is applied afterward
  int scaled_width, scaled_height;  // final resolution
  int use_threads;                  // if true, use multi-threaded decoding
  int dithering_strength;           // dithering strength (0=Off, 100=full)
  int flip;                         // if true, flip output vertically
  int alpha_dithering_strength;     // alpha dithering strength in [0..100]
};

คุณเลือกที่จะอ่านฟีเจอร์ของบิตสตรีมลงใน config.input ก็ได้ในกรณีที่เราจำเป็นต้องทราบฟีเจอร์ดังกล่าวล่วงหน้า เช่น การทราบว่ารูปภาพมีความโปร่งใสหรือไม่อาจมีประโยชน์ โปรดทราบว่าการดำเนินการนี้จะแยกวิเคราะห์ส่วนหัวของบิตสตรีมด้วย จึงถือเป็นวิธีที่ดีในการดูว่าบิตสตรีมดูเหมือน WebP ที่ถูกต้องหรือไม่

CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK);

จากนั้นเราต้องตั้งค่าบัฟเฟอร์หน่วยความจำสำหรับการถอดรหัสในกรณีที่เราต้องการจัดหาหน่วยความจำโดยตรงแทนที่จะใช้ตัวถอดรหัส เราเพียงแค่ต้องระบุพอยน์เตอร์ไปยังหน่วยความจำ รวมถึงขนาดทั้งหมดของบัฟเฟอร์และระยะห่างระหว่างบรรทัด (ระยะห่างในหน่วยไบต์ระหว่างเส้นสแกน)

// Specify the desired output colorspace:
config.output.colorspace = MODE_BGRA;
// Have config.output point to an external buffer:
config.output.u.RGBA.rgba = (uint8_t*)memory_buffer;
config.output.u.RGBA.stride = scanline_stride;
config.output.u.RGBA.size = total_size_of_the_memory_buffer;
config.output.is_external_memory = 1;

รูปภาพพร้อมที่จะถอดรหัสแล้ว การสกัดรหัสรูปภาพมี 2 รูปแบบ เราถอดรหัสรูปภาพได้พร้อมกันโดยใช้สิ่งต่อไปนี้

CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);

หรือจะใช้วิธีการแบบเพิ่มทีละน้อยเพื่อถอดรหัสรูปภาพทีละน้อยเมื่อไบต์ใหม่พร้อมใช้งานก็ได้ โดยทำดังนี้

WebPIDecoder* idec = WebPINewDecoder(&config.output);
CHECK(idec != NULL);
while (additional_data_is_available) {
  // ... (get additional data in some new_data[] buffer)
  VP8StatusCode status = WebPIAppend(idec, new_data, new_data_size);
  if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED) {
    break;
  }
  // The above call decodes the current available buffer.
  // Part of the image can now be refreshed by calling
  // WebPIDecGetRGB()/WebPIDecGetYUVA() etc.
}
WebPIDelete(idec);  // the object doesn't own the image memory, so it can
                    // now be deleted. config.output memory is preserved.

ตอนนี้รูปภาพที่ถอดรหัสแล้วอยู่ใน config.output (หรือใน config.output.u.RGBAในกรณีนี้ เนื่องจากพื้นที่สีเอาต์พุตที่ขอคือ MODE_BGRA) รูปภาพสามารถบันทึก แสดง หรือประมวลผลได้ หลังจากนั้น เราจะต้องเรียกคืนหน่วยความจำที่จัดสรรในออบเจ็กต์ของ config เท่านั้น คุณเรียกใช้ฟังก์ชันนี้ได้อย่างปลอดภัยแม้ว่าหน่วยความจำจะเป็นหน่วยความจำภายนอกและไม่ได้จัดสรรโดย WebPDecode() ก็ตาม

WebPFreeDecBuffer(&config.output);

เมื่อใช้ API นี้ รูปภาพยังได้รับการถอดรหัสเป็นรูปแบบ YUV และ YUVA ได้ด้วย โดยใช้ MODE_YUV และ MODE_YUVA ตามลำดับ รูปแบบนี้เรียกอีกอย่างว่า Y'CbCr

Simple Encoding API

มีฟังก์ชันง่ายๆ บางรายการสําหรับการเข้ารหัสอาร์เรย์ของตัวอย่าง RGBA ในเลย์เอาต์ที่พบบ่อยที่สุด โดยประกาศไว้ในwebp/encode.h ส่วนหัวดังนี้

size_t WebPEncodeRGB(const uint8_t* rgb, int width, int height, int stride, float quality_factor, uint8_t** output);
size_t WebPEncodeBGR(const uint8_t* bgr, int width, int height, int stride, float quality_factor, uint8_t** output);
size_t WebPEncodeRGBA(const uint8_t* rgba, int width, int height, int stride, float quality_factor, uint8_t** output);
size_t WebPEncodeBGRA(const uint8_t* bgra, int width, int height, int stride, float quality_factor, uint8_t** output);

ปัจจัยคุณภาพ quality_factor อยู่ในช่วง 0 ถึง 100 และควบคุมการสูญเสียและคุณภาพระหว่างการบีบอัด ค่า 0 แสดงถึงคุณภาพต่ำและขนาดเอาต์พุตขนาดเล็ก ส่วน 100 แสดงถึงคุณภาพสูงสุดและขนาดเอาต์พุตใหญ่ที่สุด หากดำเนินการสำเร็จ ระบบจะวางไบต์ที่บีบอัดไว้ในพอยน์เตอร์ *output และแสดงผลขนาดเป็นไบต์ (หรือจะแสดงผลเป็น 0 ในกรณีที่ดำเนินการไม่สำเร็จ) ผู้เรียกต้องเรียก WebPFree() ใน *output พอยน์เตอร์เพื่อเรียกคืนหน่วยความจำ

อาร์เรย์อินพุตควรเป็นอาร์เรย์ไบต์ที่แพ็กไว้ (1 รายการสำหรับแต่ละช่องตามที่ชื่อของฟังก์ชันระบุไว้) stride สอดคล้องกับจำนวนไบต์ที่จําเป็นในการข้ามจากแถวหนึ่งไปยังแถวถัดไป ตัวอย่างเช่น เลย์เอาต์ BGRA คือ

ฟังก์ชันที่เทียบเท่าสำหรับการเข้ารหัสแบบไม่สูญเสียคุณภาพมีลายเซ็นดังนี้

size_t WebPEncodeLosslessRGB(const uint8_t* rgb, int width, int height, int stride, uint8_t** output);
size_t WebPEncodeLosslessBGR(const uint8_t* bgr, int width, int height, int stride, uint8_t** output);
size_t WebPEncodeLosslessRGBA(const uint8_t* rgba, int width, int height, int stride, uint8_t** output);
size_t WebPEncodeLosslessBGRA(const uint8_t* bgra, int width, int height, int stride, uint8_t** output);

โปรดทราบว่าฟังก์ชันเหล่านี้ เช่น เวอร์ชันที่มีความละเอียดต่ำจะใช้การตั้งค่าเริ่มต้นของไลบรารี สำหรับแบบไม่สูญเสียคุณภาพ หมายความว่า "ตรงทั้งหมด" จะปิดอยู่ ระบบจะแก้ไขค่า RGB ในพื้นที่ทึบแสงเพื่อปรับปรุงการบีบอัด หากต้องการหลีกเลี่ยงปัญหานี้ ให้ใช้ WebPEncode() และตั้งค่า WebPConfig::exact เป็น 1

Advanced Encoding API

ตัวแปลงไฟล์มาพร้อมกับพารามิเตอร์การเข้ารหัสขั้นสูงหลายรายการ ซึ่งอาจมีประโยชน์ในการปรับสมดุลระหว่างประสิทธิภาพการบีบอัดกับเวลาในการประมวลผลให้ดียิ่งขึ้น ระบบจะรวบรวมพารามิเตอร์เหล่านี้ภายในโครงสร้าง WebPConfig ฟิลด์ที่ใช้มากที่สุดของโครงสร้างนี้มีดังนี้

struct WebPConfig {
  int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
  float quality;          // between 0 and 100. For lossy, 0 gives the smallest
                          // size and 100 the largest. For lossless, this
                          // parameter is the amount of effort put into the
                          // compression: 0 is the fastest but gives larger
                          // files compared to the slowest, but best, 100.
  int method;             // quality/speed trade-off (0=fast, 6=slower-better)

  WebPImageHint image_hint;  // Hint for image type (lossless only for now).

  // Parameters related to lossy compression only:
  int target_size;        // if non-zero, set the desired target size in bytes.
                          // Takes precedence over the 'compression' parameter.
  float target_PSNR;      // if non-zero, specifies the minimal distortion to
                          // try to achieve. Takes precedence over target_size.
  int segments;           // maximum number of segments to use, in [1..4]
  int sns_strength;       // Spatial Noise Shaping. 0=off, 100=maximum.
  int filter_strength;    // range: [0 = off .. 100 = strongest]
  int filter_sharpness;   // range: [0 = off .. 7 = least sharp]
  int filter_type;        // filtering type: 0 = simple, 1 = strong (only used
                          // if filter_strength > 0 or autofilter > 0)
  int autofilter;         // Auto adjust filter's strength [0 = off, 1 = on]
  int alpha_compression;  // Algorithm for encoding the alpha plane (0 = none,
                          // 1 = compressed with WebP lossless). Default is 1.
  int alpha_filtering;    // Predictive filtering method for alpha plane.
                          //  0: none, 1: fast, 2: best. Default if 1.
  int alpha_quality;      // Between 0 (smallest size) and 100 (lossless).
                          // Default is 100.
  int pass;               // number of entropy-analysis passes (in [1..10]).

  int show_compressed;    // if true, export the compressed picture back.
                          // In-loop filtering is not applied.
  int preprocessing;      // preprocessing filter (0=none, 1=segment-smooth)
  int partitions;         // log2(number of token partitions) in [0..3]
                          // Default is set to 0 for easier progressive decoding.
  int partition_limit;    // quality degradation allowed to fit the 512k limit on
                          // prediction modes coding (0: no degradation,
                          // 100: maximum possible degradation).
  int use_sharp_yuv;      // if needed, use sharp (and slow) RGB->YUV conversion
};

โปรดทราบว่าพารามิเตอร์ส่วนใหญ่เหล่านี้เข้าถึงได้สำหรับการทดสอบโดยใช้cwebpเครื่องมือบรรทัดคำสั่ง

ตัวอย่างอินพุตควรรวมไว้ในโครงสร้าง WebPPicture โครงสร้างนี้สามารถจัดเก็บตัวอย่างอินพุตในรูปแบบ RGBA หรือ YUVA ก็ได้ ทั้งนี้ขึ้นอยู่กับค่าของ Flag use_argb

โครงสร้างมีดังนี้

struct WebPPicture {
  int use_argb;              // To select between ARGB and YUVA input.

  // YUV input, recommended for lossy compression.
  // Used if use_argb = 0.
  WebPEncCSP colorspace;     // colorspace: should be YUVA420 or YUV420 for now (=Y'CbCr).
  int width, height;         // dimensions (less or equal to WEBP_MAX_DIMENSION)
  uint8_t *y, *u, *v;        // pointers to luma/chroma planes.
  int y_stride, uv_stride;   // luma/chroma strides.
  uint8_t* a;                // pointer to the alpha plane
  int a_stride;              // stride of the alpha plane

  // Alternate ARGB input, recommended for lossless compression.
  // Used if use_argb = 1.
  uint32_t* argb;            // Pointer to argb (32 bit) plane.
  int argb_stride;           // This is stride in pixels units, not bytes.

  // Byte-emission hook, to store compressed bytes as they are ready.
  WebPWriterFunction writer;  // can be NULL
  void* custom_ptr;           // can be used by the writer.

  // Error code for the latest error encountered during encoding
  WebPEncodingError error_code;
};

โครงสร้างนี้ยังมีฟังก์ชันในการส่งไบต์ที่บีบอัดเมื่อพร้อมใช้งานด้วย ดูตัวอย่างที่มีโปรแกรมเขียนในหน่วยความจําได้ที่ด้านล่าง ผู้เขียนคนอื่นๆ สามารถจัดเก็บข้อมูลลงในไฟล์ได้โดยตรง (ดูตัวอย่างที่ examples/cwebp.c)

ขั้นตอนทั่วไปในการเข้ารหัสโดยใช้ API ขั้นสูงมีดังนี้

ก่อนอื่นเราต้องตั้งค่าการกําหนดค่าการเข้ารหัสซึ่งมีพารามิเตอร์การบีบอัด โปรดทราบว่าคุณใช้การกําหนดค่าเดียวกันในการบีบอัดรูปภาพหลายรูปในภายหลังได้

#include "webp/encode.h"

WebPConfig config;
if (!WebPConfigPreset(&config, WEBP_PRESET_PHOTO, quality_factor)) return 0;   // version error

// Add additional tuning:
config.sns_strength = 90;
config.filter_sharpness = 6;
config.alpha_quality = 90;
config_error = WebPValidateConfig(&config);  // will verify parameter ranges (always a good habit)

จากนั้นต้องอ้างอิงตัวอย่างอินพุตใน WebPPicture โดยใช้การอ้างอิงหรือคัดลอก ต่อไปนี้เป็นตัวอย่างการจัดสรรบัฟเฟอร์สำหรับเก็บตัวอย่าง แต่คุณตั้งค่า "มุมมอง" ไปยังอาร์เรย์ตัวอย่างที่จัดสรรไว้แล้วได้ง่ายๆ โปรดดูฟังก์ชัน WebPPictureView()

// Setup the input data, allocating a picture of width x height dimension
WebPPicture pic;
if (!WebPPictureInit(&pic)) return 0;  // version error
pic.width = width;
pic.height = height;
if (!WebPPictureAlloc(&pic)) return 0;   // memory error

// At this point, 'pic' has been initialized as a container, and can receive the YUVA or RGBA samples.
// Alternatively, one could use ready-made import functions like WebPPictureImportRGBA(), which will take
// care of memory allocation. In any case, past this point, one will have to call WebPPictureFree(&pic)
// to reclaim allocated memory.

หากต้องการส่งออกไบต์ที่บีบอัด ระบบจะเรียกใช้ฮุกทุกครั้งที่มีไบต์ใหม่ ต่อไปนี้เป็นตัวอย่างง่ายๆ ที่ประกาศโปรแกรมเขียนหน่วยความจำใน webp/encode.h จำเป็นต้องใช้การเริ่มต้นนี้เพื่อให้รูปภาพแต่ละรูปบีบอัดได้

// Set up a byte-writing method (write-to-memory, in this case):
WebPMemoryWriter writer;
WebPMemoryWriterInit(&writer);
pic.writer = WebPMemoryWrite;
pic.custom_ptr = &writer;

ตอนนี้เราพร้อมที่จะบีบอัดตัวอย่างอินพุต (และเพิ่มพื้นที่ว่างของหน่วยความจำหลังจากนั้น)

int ok = WebPEncode(&config, &pic);
WebPPictureFree(&pic);   // Always free the memory associated with the input.
if (!ok) {
  printf("Encoding error: %d\n", pic.error_code);
} else {
  printf("Output size: %d\n", writer.size);
}

หากต้องการใช้ API และโครงสร้างขั้นสูงมากขึ้น เราขอแนะนำให้ดูเอกสารประกอบในส่วนหัว webp/encode.h การอ่านโค้ดตัวอย่าง examples/cwebp.c อาจมีประโยชน์ในการค้นพบพารามิเตอร์ที่มีการใช้งานน้อย