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