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