ส่วนนี้จะอธิบาย API สำหรับโปรแกรมเปลี่ยนไฟล์และตัวถอดรหัสที่มีมาให้ ในคลัง WebP คำอธิบาย API นี้เกี่ยวข้องกับเวอร์ชัน 1.4.0.
ส่วนหัวและไลบรารี
เมื่อคุณติดตั้ง libwebp ไดเรกทอรีชื่อ webp/
จะติดตั้งที่ตำแหน่งทั่วไปสำหรับแพลตฟอร์มของคุณ ตัวอย่างเช่น บน
แพลตฟอร์ม Unix ระบบจะคัดลอกไฟล์ส่วนหัวต่อไปนี้ไปยัง
/usr/local/include/webp/
decode.h
encode.h
types.h
ไลบรารีจะอยู่ในไดเรกทอรีไลบรารีทั่วไป องค์ประกอบ
ไลบรารีแบบไดนามิกอยู่ใน /usr/local/lib/ บนแพลตฟอร์ม Unix
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หรือไม่เช่นนั้น
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) รูปภาพสามารถ จะได้รับการบันทึก แสดง หรือประมวลผลไว้ หลังจากนั้น เราจำเป็นต้องเรียกคืนหน่วยความจำที่จัดสรรในออบเจ็กต์ของการกำหนดค่าเท่านั้น เรียกฟังก์ชันนี้ได้อย่างปลอดภัย แม้ว่าหน่วยความจำจะอยู่นอกระบบและไม่ใช่ จัดสรรโดย WebPDecode():
WebPFreeDecBuffer(&config.output);
เมื่อใช้ API นี้ รูปภาพยังสามารถถอดรหัสเป็นรูปแบบ YUV และ YUVA โดยใช้
MODE_YUV และ MODE_YUVA ตามลำดับ รูปแบบนี้เรียกอีกอย่างว่า
Y'CbCr
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
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.
หากต้องการปล่อยไบต์ที่บีบอัด ระบบจะเรียก Hook ทุกครั้งที่มีการไบต์ใหม่
พร้อมใช้งาน ต่อไปนี้เป็นตัวอย่างง่ายๆ ที่มีการประกาศผู้เขียนหน่วยความจำใน
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 มีประโยชน์
เพื่อหาพารามิเตอร์ที่ใช้น้อย