1// Copyright 2011 Google Inc. All Rights Reserved. 2// 3// Use of this source code is governed by a BSD-style license 4// that can be found in the COPYING file in the root of the source 5// tree. An additional intellectual property rights grant can be found 6// in the file PATENTS. All contributing project authors may 7// be found in the AUTHORS file in the root of the source tree. 8// ----------------------------------------------------------------------------- 9// 10// WebP encoder: main interface 11// 12// Author: Skal (pascal.massimino@gmail.com) 13 14#ifndef WEBP_WEBP_ENCODE_H_ 15#define WEBP_WEBP_ENCODE_H_ 16 17#include "./types.h" 18 19#ifdef __cplusplus 20extern "C" { 21#endif 22 23#define WEBP_ENCODER_ABI_VERSION 0x0202 // MAJOR(8b) + MINOR(8b) 24 25// Note: forward declaring enumerations is not allowed in (strict) C and C++, 26// the types are left here for reference. 27// typedef enum WebPImageHint WebPImageHint; 28// typedef enum WebPEncCSP WebPEncCSP; 29// typedef enum WebPPreset WebPPreset; 30// typedef enum WebPEncodingError WebPEncodingError; 31typedef struct WebPConfig WebPConfig; 32typedef struct WebPPicture WebPPicture; // main structure for I/O 33typedef struct WebPAuxStats WebPAuxStats; 34typedef struct WebPMemoryWriter WebPMemoryWriter; 35 36// Return the encoder's version number, packed in hexadecimal using 8bits for 37// each of major/minor/revision. E.g: v2.5.7 is 0x020507. 38WEBP_EXTERN(int) WebPGetEncoderVersion(void); 39 40//------------------------------------------------------------------------------ 41// One-stop-shop call! No questions asked: 42 43// Returns the size of the compressed data (pointed to by *output), or 0 if 44// an error occurred. The compressed data must be released by the caller 45// using the call 'free(*output)'. 46// These functions compress using the lossy format, and the quality_factor 47// can go from 0 (smaller output, lower quality) to 100 (best quality, 48// larger output). 49WEBP_EXTERN(size_t) WebPEncodeRGB(const uint8_t* rgb, 50 int width, int height, int stride, 51 float quality_factor, uint8_t** output); 52WEBP_EXTERN(size_t) WebPEncodeBGR(const uint8_t* bgr, 53 int width, int height, int stride, 54 float quality_factor, uint8_t** output); 55WEBP_EXTERN(size_t) WebPEncodeRGBA(const uint8_t* rgba, 56 int width, int height, int stride, 57 float quality_factor, uint8_t** output); 58WEBP_EXTERN(size_t) WebPEncodeBGRA(const uint8_t* bgra, 59 int width, int height, int stride, 60 float quality_factor, uint8_t** output); 61 62// These functions are the equivalent of the above, but compressing in a 63// lossless manner. Files are usually larger than lossy format, but will 64// not suffer any compression loss. 65WEBP_EXTERN(size_t) WebPEncodeLosslessRGB(const uint8_t* rgb, 66 int width, int height, int stride, 67 uint8_t** output); 68WEBP_EXTERN(size_t) WebPEncodeLosslessBGR(const uint8_t* bgr, 69 int width, int height, int stride, 70 uint8_t** output); 71WEBP_EXTERN(size_t) WebPEncodeLosslessRGBA(const uint8_t* rgba, 72 int width, int height, int stride, 73 uint8_t** output); 74WEBP_EXTERN(size_t) WebPEncodeLosslessBGRA(const uint8_t* bgra, 75 int width, int height, int stride, 76 uint8_t** output); 77 78//------------------------------------------------------------------------------ 79// Coding parameters 80 81// Image characteristics hint for the underlying encoder. 82typedef enum WebPImageHint { 83 WEBP_HINT_DEFAULT = 0, // default preset. 84 WEBP_HINT_PICTURE, // digital picture, like portrait, inner shot 85 WEBP_HINT_PHOTO, // outdoor photograph, with natural lighting 86 WEBP_HINT_GRAPH, // Discrete tone image (graph, map-tile etc). 87 WEBP_HINT_LAST 88} WebPImageHint; 89 90// Compression parameters. 91struct WebPConfig { 92 int lossless; // Lossless encoding (0=lossy(default), 1=lossless). 93 float quality; // between 0 (smallest file) and 100 (biggest) 94 int method; // quality/speed trade-off (0=fast, 6=slower-better) 95 96 WebPImageHint image_hint; // Hint for image type (lossless only for now). 97 98 // Parameters related to lossy compression only: 99 int target_size; // if non-zero, set the desired target size in bytes. 100 // Takes precedence over the 'compression' parameter. 101 float target_PSNR; // if non-zero, specifies the minimal distortion to 102 // try to achieve. Takes precedence over target_size. 103 int segments; // maximum number of segments to use, in [1..4] 104 int sns_strength; // Spatial Noise Shaping. 0=off, 100=maximum. 105 int filter_strength; // range: [0 = off .. 100 = strongest] 106 int filter_sharpness; // range: [0 = off .. 7 = least sharp] 107 int filter_type; // filtering type: 0 = simple, 1 = strong (only used 108 // if filter_strength > 0 or autofilter > 0) 109 int autofilter; // Auto adjust filter's strength [0 = off, 1 = on] 110 int alpha_compression; // Algorithm for encoding the alpha plane (0 = none, 111 // 1 = compressed with WebP lossless). Default is 1. 112 int alpha_filtering; // Predictive filtering method for alpha plane. 113 // 0: none, 1: fast, 2: best. Default if 1. 114 int alpha_quality; // Between 0 (smallest size) and 100 (lossless). 115 // Default is 100. 116 int pass; // number of entropy-analysis passes (in [1..10]). 117 118 int show_compressed; // if true, export the compressed picture back. 119 // In-loop filtering is not applied. 120 int preprocessing; // preprocessing filter: 121 // 0=none, 1=segment-smooth, 2=pseudo-random dithering 122 int partitions; // log2(number of token partitions) in [0..3]. Default 123 // is set to 0 for easier progressive decoding. 124 int partition_limit; // quality degradation allowed to fit the 512k limit 125 // on prediction modes coding (0: no degradation, 126 // 100: maximum possible degradation). 127 int emulate_jpeg_size; // If true, compression parameters will be remapped 128 // to better match the expected output size from 129 // JPEG compression. Generally, the output size will 130 // be similar but the degradation will be lower. 131 int thread_level; // If non-zero, try and use multi-threaded encoding. 132 int low_memory; // If set, reduce memory usage (but increase CPU use). 133 134 uint32_t pad[5]; // padding for later use 135}; 136 137// Enumerate some predefined settings for WebPConfig, depending on the type 138// of source picture. These presets are used when calling WebPConfigPreset(). 139typedef enum WebPPreset { 140 WEBP_PRESET_DEFAULT = 0, // default preset. 141 WEBP_PRESET_PICTURE, // digital picture, like portrait, inner shot 142 WEBP_PRESET_PHOTO, // outdoor photograph, with natural lighting 143 WEBP_PRESET_DRAWING, // hand or line drawing, with high-contrast details 144 WEBP_PRESET_ICON, // small-sized colorful images 145 WEBP_PRESET_TEXT // text-like 146} WebPPreset; 147 148// Internal, version-checked, entry point 149WEBP_EXTERN(int) WebPConfigInitInternal(WebPConfig*, WebPPreset, float, int); 150 151// Should always be called, to initialize a fresh WebPConfig structure before 152// modification. Returns false in case of version mismatch. WebPConfigInit() 153// must have succeeded before using the 'config' object. 154// Note that the default values are lossless=0 and quality=75. 155static WEBP_INLINE int WebPConfigInit(WebPConfig* config) { 156 return WebPConfigInitInternal(config, WEBP_PRESET_DEFAULT, 75.f, 157 WEBP_ENCODER_ABI_VERSION); 158} 159 160// This function will initialize the configuration according to a predefined 161// set of parameters (referred to by 'preset') and a given quality factor. 162// This function can be called as a replacement to WebPConfigInit(). Will 163// return false in case of error. 164static WEBP_INLINE int WebPConfigPreset(WebPConfig* config, 165 WebPPreset preset, float quality) { 166 return WebPConfigInitInternal(config, preset, quality, 167 WEBP_ENCODER_ABI_VERSION); 168} 169 170#if WEBP_ENCODER_ABI_VERSION > 0x0202 171// Activate the lossless compression mode with the desired efficiency level 172// between 0 (fastest, lowest compression) and 9 (slower, best compression). 173// A good default level is '6', providing a fair tradeoff between compression 174// speed and final compressed size. 175// This function will overwrite several fields from config: 'method', 'quality' 176// and 'lossless'. Returns false in case of parameter error. 177WEBP_EXTERN(int) WebPConfigLosslessPreset(WebPConfig* config, int level); 178#endif 179 180// Returns true if 'config' is non-NULL and all configuration parameters are 181// within their valid ranges. 182WEBP_EXTERN(int) WebPValidateConfig(const WebPConfig* config); 183 184//------------------------------------------------------------------------------ 185// Input / Output 186// Structure for storing auxiliary statistics (mostly for lossy encoding). 187 188struct WebPAuxStats { 189 int coded_size; // final size 190 191 float PSNR[5]; // peak-signal-to-noise ratio for Y/U/V/All/Alpha 192 int block_count[3]; // number of intra4/intra16/skipped macroblocks 193 int header_bytes[2]; // approximate number of bytes spent for header 194 // and mode-partition #0 195 int residual_bytes[3][4]; // approximate number of bytes spent for 196 // DC/AC/uv coefficients for each (0..3) segments. 197 int segment_size[4]; // number of macroblocks in each segments 198 int segment_quant[4]; // quantizer values for each segments 199 int segment_level[4]; // filtering strength for each segments [0..63] 200 201 int alpha_data_size; // size of the transparency data 202 int layer_data_size; // size of the enhancement layer data 203 204 // lossless encoder statistics 205 uint32_t lossless_features; // bit0:predictor bit1:cross-color transform 206 // bit2:subtract-green bit3:color indexing 207 int histogram_bits; // number of precision bits of histogram 208 int transform_bits; // precision bits for transform 209 int cache_bits; // number of bits for color cache lookup 210 int palette_size; // number of color in palette, if used 211 int lossless_size; // final lossless size 212 213 uint32_t pad[4]; // padding for later use 214}; 215 216// Signature for output function. Should return true if writing was successful. 217// data/data_size is the segment of data to write, and 'picture' is for 218// reference (and so one can make use of picture->custom_ptr). 219typedef int (*WebPWriterFunction)(const uint8_t* data, size_t data_size, 220 const WebPPicture* picture); 221 222// WebPMemoryWrite: a special WebPWriterFunction that writes to memory using 223// the following WebPMemoryWriter object (to be set as a custom_ptr). 224struct WebPMemoryWriter { 225 uint8_t* mem; // final buffer (of size 'max_size', larger than 'size'). 226 size_t size; // final size 227 size_t max_size; // total capacity 228 uint32_t pad[1]; // padding for later use 229}; 230 231// The following must be called first before any use. 232WEBP_EXTERN(void) WebPMemoryWriterInit(WebPMemoryWriter* writer); 233 234#if WEBP_ENCODER_ABI_VERSION > 0x0202 235// The following must be called to deallocate writer->mem memory. The 'writer' 236// object itself is not deallocated. 237WEBP_EXTERN(void) WebPMemoryWriterClear(WebPMemoryWriter* writer); 238#endif 239// The custom writer to be used with WebPMemoryWriter as custom_ptr. Upon 240// completion, writer.mem and writer.size will hold the coded data. 241#if WEBP_ENCODER_ABI_VERSION > 0x0202 242// writer.mem must be freed by calling WebPMemoryWriterClear. 243#else 244// writer.mem must be freed by calling 'free(writer.mem)'. 245#endif 246WEBP_EXTERN(int) WebPMemoryWrite(const uint8_t* data, size_t data_size, 247 const WebPPicture* picture); 248 249// Progress hook, called from time to time to report progress. It can return 250// false to request an abort of the encoding process, or true otherwise if 251// everything is OK. 252typedef int (*WebPProgressHook)(int percent, const WebPPicture* picture); 253 254// Color spaces. 255typedef enum WebPEncCSP { 256 // chroma sampling 257 WEBP_YUV420 = 0, // 4:2:0 258 WEBP_YUV420A = 4, // alpha channel variant 259 WEBP_CSP_UV_MASK = 3, // bit-mask to get the UV sampling factors 260 WEBP_CSP_ALPHA_BIT = 4 // bit that is set if alpha is present 261} WebPEncCSP; 262 263// Encoding error conditions. 264typedef enum WebPEncodingError { 265 VP8_ENC_OK = 0, 266 VP8_ENC_ERROR_OUT_OF_MEMORY, // memory error allocating objects 267 VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY, // memory error while flushing bits 268 VP8_ENC_ERROR_NULL_PARAMETER, // a pointer parameter is NULL 269 VP8_ENC_ERROR_INVALID_CONFIGURATION, // configuration is invalid 270 VP8_ENC_ERROR_BAD_DIMENSION, // picture has invalid width/height 271 VP8_ENC_ERROR_PARTITION0_OVERFLOW, // partition is bigger than 512k 272 VP8_ENC_ERROR_PARTITION_OVERFLOW, // partition is bigger than 16M 273 VP8_ENC_ERROR_BAD_WRITE, // error while flushing bytes 274 VP8_ENC_ERROR_FILE_TOO_BIG, // file is bigger than 4G 275 VP8_ENC_ERROR_USER_ABORT, // abort request by user 276 VP8_ENC_ERROR_LAST // list terminator. always last. 277} WebPEncodingError; 278 279// maximum width/height allowed (inclusive), in pixels 280#define WEBP_MAX_DIMENSION 16383 281 282// Main exchange structure (input samples, output bytes, statistics) 283struct WebPPicture { 284 // INPUT 285 ////////////// 286 // Main flag for encoder selecting between ARGB or YUV input. 287 // It is recommended to use ARGB input (*argb, argb_stride) for lossless 288 // compression, and YUV input (*y, *u, *v, etc.) for lossy compression 289 // since these are the respective native colorspace for these formats. 290 int use_argb; 291 292 // YUV input (mostly used for input to lossy compression) 293 WebPEncCSP colorspace; // colorspace: should be YUV420 for now (=Y'CbCr). 294 int width, height; // dimensions (less or equal to WEBP_MAX_DIMENSION) 295 uint8_t *y, *u, *v; // pointers to luma/chroma planes. 296 int y_stride, uv_stride; // luma/chroma strides. 297 uint8_t* a; // pointer to the alpha plane 298 int a_stride; // stride of the alpha plane 299 uint32_t pad1[2]; // padding for later use 300 301 // ARGB input (mostly used for input to lossless compression) 302 uint32_t* argb; // Pointer to argb (32 bit) plane. 303 int argb_stride; // This is stride in pixels units, not bytes. 304 uint32_t pad2[3]; // padding for later use 305 306 // OUTPUT 307 /////////////// 308 // Byte-emission hook, to store compressed bytes as they are ready. 309 WebPWriterFunction writer; // can be NULL 310 void* custom_ptr; // can be used by the writer. 311 312 // map for extra information (only for lossy compression mode) 313 int extra_info_type; // 1: intra type, 2: segment, 3: quant 314 // 4: intra-16 prediction mode, 315 // 5: chroma prediction mode, 316 // 6: bit cost, 7: distortion 317 uint8_t* extra_info; // if not NULL, points to an array of size 318 // ((width + 15) / 16) * ((height + 15) / 16) that 319 // will be filled with a macroblock map, depending 320 // on extra_info_type. 321 322 // STATS AND REPORTS 323 /////////////////////////// 324 // Pointer to side statistics (updated only if not NULL) 325 WebPAuxStats* stats; 326 327 // Error code for the latest error encountered during encoding 328 WebPEncodingError error_code; 329 330 // If not NULL, report progress during encoding. 331 WebPProgressHook progress_hook; 332 333 void* user_data; // this field is free to be set to any value and 334 // used during callbacks (like progress-report e.g.). 335 336 uint32_t pad3[3]; // padding for later use 337 338 // Unused for now 339 uint8_t *pad4, *pad5; 340 uint32_t pad6[8]; // padding for later use 341 342 // PRIVATE FIELDS 343 //////////////////// 344 void* memory_; // row chunk of memory for yuva planes 345 void* memory_argb_; // and for argb too. 346 void* pad7[2]; // padding for later use 347}; 348 349// Internal, version-checked, entry point 350WEBP_EXTERN(int) WebPPictureInitInternal(WebPPicture*, int); 351 352// Should always be called, to initialize the structure. Returns false in case 353// of version mismatch. WebPPictureInit() must have succeeded before using the 354// 'picture' object. 355// Note that, by default, use_argb is false and colorspace is WEBP_YUV420. 356static WEBP_INLINE int WebPPictureInit(WebPPicture* picture) { 357 return WebPPictureInitInternal(picture, WEBP_ENCODER_ABI_VERSION); 358} 359 360//------------------------------------------------------------------------------ 361// WebPPicture utils 362 363// Convenience allocation / deallocation based on picture->width/height: 364// Allocate y/u/v buffers as per colorspace/width/height specification. 365// Note! This function will free the previous buffer if needed. 366// Returns false in case of memory error. 367WEBP_EXTERN(int) WebPPictureAlloc(WebPPicture* picture); 368 369// Release the memory allocated by WebPPictureAlloc() or WebPPictureImport*(). 370// Note that this function does _not_ free the memory used by the 'picture' 371// object itself. 372// Besides memory (which is reclaimed) all other fields of 'picture' are 373// preserved. 374WEBP_EXTERN(void) WebPPictureFree(WebPPicture* picture); 375 376// Copy the pixels of *src into *dst, using WebPPictureAlloc. Upon return, *dst 377// will fully own the copied pixels (this is not a view). The 'dst' picture need 378// not be initialized as its content is overwritten. 379// Returns false in case of memory allocation error. 380WEBP_EXTERN(int) WebPPictureCopy(const WebPPicture* src, WebPPicture* dst); 381 382// Compute PSNR, SSIM or LSIM distortion metric between two pictures. 383// Result is in dB, stores in result[] in the Y/U/V/Alpha/All order. 384// Returns false in case of error (src and ref don't have same dimension, ...) 385// Warning: this function is rather CPU-intensive. 386WEBP_EXTERN(int) WebPPictureDistortion( 387 const WebPPicture* src, const WebPPicture* ref, 388 int metric_type, // 0 = PSNR, 1 = SSIM, 2 = LSIM 389 float result[5]); 390 391// self-crops a picture to the rectangle defined by top/left/width/height. 392// Returns false in case of memory allocation error, or if the rectangle is 393// outside of the source picture. 394// The rectangle for the view is defined by the top-left corner pixel 395// coordinates (left, top) as well as its width and height. This rectangle 396// must be fully be comprised inside the 'src' source picture. If the source 397// picture uses the YUV420 colorspace, the top and left coordinates will be 398// snapped to even values. 399WEBP_EXTERN(int) WebPPictureCrop(WebPPicture* picture, 400 int left, int top, int width, int height); 401 402// Extracts a view from 'src' picture into 'dst'. The rectangle for the view 403// is defined by the top-left corner pixel coordinates (left, top) as well 404// as its width and height. This rectangle must be fully be comprised inside 405// the 'src' source picture. If the source picture uses the YUV420 colorspace, 406// the top and left coordinates will be snapped to even values. 407// Picture 'src' must out-live 'dst' picture. Self-extraction of view is allowed 408// ('src' equal to 'dst') as a mean of fast-cropping (but note that doing so, 409// the original dimension will be lost). Picture 'dst' need not be initialized 410// with WebPPictureInit() if it is different from 'src', since its content will 411// be overwritten. 412// Returns false in case of memory allocation error or invalid parameters. 413WEBP_EXTERN(int) WebPPictureView(const WebPPicture* src, 414 int left, int top, int width, int height, 415 WebPPicture* dst); 416 417// Returns true if the 'picture' is actually a view and therefore does 418// not own the memory for pixels. 419WEBP_EXTERN(int) WebPPictureIsView(const WebPPicture* picture); 420 421// Rescale a picture to new dimension width x height. 422// Now gamma correction is applied. 423// Returns false in case of error (invalid parameter or insufficient memory). 424WEBP_EXTERN(int) WebPPictureRescale(WebPPicture* pic, int width, int height); 425 426// Colorspace conversion function to import RGB samples. 427// Previous buffer will be free'd, if any. 428// *rgb buffer should have a size of at least height * rgb_stride. 429// Returns false in case of memory error. 430WEBP_EXTERN(int) WebPPictureImportRGB( 431 WebPPicture* picture, const uint8_t* rgb, int rgb_stride); 432// Same, but for RGBA buffer. 433WEBP_EXTERN(int) WebPPictureImportRGBA( 434 WebPPicture* picture, const uint8_t* rgba, int rgba_stride); 435// Same, but for RGBA buffer. Imports the RGB direct from the 32-bit format 436// input buffer ignoring the alpha channel. Avoids needing to copy the data 437// to a temporary 24-bit RGB buffer to import the RGB only. 438WEBP_EXTERN(int) WebPPictureImportRGBX( 439 WebPPicture* picture, const uint8_t* rgbx, int rgbx_stride); 440 441// Variants of the above, but taking BGR(A|X) input. 442WEBP_EXTERN(int) WebPPictureImportBGR( 443 WebPPicture* picture, const uint8_t* bgr, int bgr_stride); 444WEBP_EXTERN(int) WebPPictureImportBGRA( 445 WebPPicture* picture, const uint8_t* bgra, int bgra_stride); 446WEBP_EXTERN(int) WebPPictureImportBGRX( 447 WebPPicture* picture, const uint8_t* bgrx, int bgrx_stride); 448 449// Converts picture->argb data to the YUVA format specified by 'colorspace'. 450// Upon return, picture->use_argb is set to false. The presence of real 451// non-opaque transparent values is detected, and 'colorspace' will be 452// adjusted accordingly. Note that this method is lossy. 453// Returns false in case of error. 454WEBP_EXTERN(int) WebPPictureARGBToYUVA(WebPPicture* picture, 455 WebPEncCSP colorspace); 456 457// Same as WebPPictureARGBToYUVA(), but the conversion is done using 458// pseudo-random dithering with a strength 'dithering' between 459// 0.0 (no dithering) and 1.0 (maximum dithering). This is useful 460// for photographic picture. 461WEBP_EXTERN(int) WebPPictureARGBToYUVADithered( 462 WebPPicture* picture, WebPEncCSP colorspace, float dithering); 463 464// Converts picture->yuv to picture->argb and sets picture->use_argb to true. 465// The input format must be YUV_420 or YUV_420A. 466// Note that the use of this method is discouraged if one has access to the 467// raw ARGB samples, since using YUV420 is comparatively lossy. Also, the 468// conversion from YUV420 to ARGB incurs a small loss too. 469// Returns false in case of error. 470WEBP_EXTERN(int) WebPPictureYUVAToARGB(WebPPicture* picture); 471 472// Helper function: given a width x height plane of RGBA or YUV(A) samples 473// clean-up the YUV or RGB samples under fully transparent area, to help 474// compressibility (no guarantee, though). 475WEBP_EXTERN(void) WebPCleanupTransparentArea(WebPPicture* picture); 476 477// Scan the picture 'picture' for the presence of non fully opaque alpha values. 478// Returns true in such case. Otherwise returns false (indicating that the 479// alpha plane can be ignored altogether e.g.). 480WEBP_EXTERN(int) WebPPictureHasTransparency(const WebPPicture* picture); 481 482// Remove the transparency information (if present) by blending the color with 483// the background color 'background_rgb' (specified as 24bit RGB triplet). 484// After this call, all alpha values are reset to 0xff. 485WEBP_EXTERN(void) WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb); 486 487//------------------------------------------------------------------------------ 488// Main call 489 490// Main encoding call, after config and picture have been initialized. 491// 'picture' must be less than 16384x16384 in dimension (cf WEBP_MAX_DIMENSION), 492// and the 'config' object must be a valid one. 493// Returns false in case of error, true otherwise. 494// In case of error, picture->error_code is updated accordingly. 495// 'picture' can hold the source samples in both YUV(A) or ARGB input, depending 496// on the value of 'picture->use_argb'. It is highly recommended to use 497// the former for lossy encoding, and the latter for lossless encoding 498// (when config.lossless is true). Automatic conversion from one format to 499// another is provided but they both incur some loss. 500WEBP_EXTERN(int) WebPEncode(const WebPConfig* config, WebPPicture* picture); 501 502//------------------------------------------------------------------------------ 503 504#ifdef __cplusplus 505} // extern "C" 506#endif 507 508#endif /* WEBP_WEBP_ENCODE_H_ */ 509