WebP API ドキュメント

decode.h encode.h types.h 

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

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

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

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

#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. 

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] }; 

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; 

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. 

WebPFreeDecBuffer(&config.output); 

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

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

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

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

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

// 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. 

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