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