1 // Copyright 2011 Google Inc. All Rights Reserved.
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 // -----------------------------------------------------------------------------
10 // WebP encoder: main interface
12 // Author: Skal (pascal.massimino@gmail.com)
14 #ifndef WEBP_WEBP_ENCODE_H_
15 #define WEBP_WEBP_ENCODE_H_
19 #if defined(__cplusplus) || defined(c_plusplus)
23 #define WEBP_ENCODER_ABI_VERSION 0x0201 // MAJOR(8b) + MINOR(8b)
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;
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);
40 //------------------------------------------------------------------------------
41 // One-stop-shop call! No questions asked:
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,
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);
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,
68 WEBP_EXTERN(size_t) WebPEncodeLosslessBGR(const uint8_t* bgr,
69 int width, int height, int stride,
71 WEBP_EXTERN(size_t) WebPEncodeLosslessRGBA(const uint8_t* rgba,
72 int width, int height, int stride,
74 WEBP_EXTERN(size_t) WebPEncodeLosslessBGRA(const uint8_t* bgra,
75 int width, int height, int stride,
78 //------------------------------------------------------------------------------
81 // Image characteristics hint for the underlying encoder.
82 typedef 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).
90 // Compression parameters.
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)
96 WebPImageHint image_hint; // Hint for image type (lossless only for now).
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).
116 int pass; // number of entropy-analysis passes (in [1..10]).
118 int show_compressed; // if true, export the compressed picture back.
119 // In-loop filtering is not applied.
120 int preprocessing; // preprocessing filter (0=none, 1=segment-smooth)
121 int partitions; // log2(number of token partitions) in [0..3]. Default
122 // is set to 0 for easier progressive decoding.
123 int partition_limit; // quality degradation allowed to fit the 512k limit
124 // on prediction modes coding (0: no degradation,
125 // 100: maximum possible degradation).
126 int emulate_jpeg_size; // If true, compression parameters will be remapped
127 // to better match the expected output size from
128 // JPEG compression. Generally, the output size will
129 // be similar but the degradation will be lower.
130 int thread_level; // If non-zero, try and use multi-threaded encoding.
131 int low_memory; // If set, reduce memory usage (but increase CPU use).
133 uint32_t pad[5]; // padding for later use
136 // Enumerate some predefined settings for WebPConfig, depending on the type
137 // of source picture. These presets are used when calling WebPConfigPreset().
138 typedef enum WebPPreset {
139 WEBP_PRESET_DEFAULT = 0, // default preset.
140 WEBP_PRESET_PICTURE, // digital picture, like portrait, inner shot
141 WEBP_PRESET_PHOTO, // outdoor photograph, with natural lighting
142 WEBP_PRESET_DRAWING, // hand or line drawing, with high-contrast details
143 WEBP_PRESET_ICON, // small-sized colorful images
144 WEBP_PRESET_TEXT // text-like
147 // Internal, version-checked, entry point
148 WEBP_EXTERN(int) WebPConfigInitInternal(WebPConfig*, WebPPreset, float, int);
150 // Should always be called, to initialize a fresh WebPConfig structure before
151 // modification. Returns false in case of version mismatch. WebPConfigInit()
152 // must have succeeded before using the 'config' object.
153 // Note that the default values are lossless=0 and quality=75.
154 static WEBP_INLINE int WebPConfigInit(WebPConfig* config) {
155 return WebPConfigInitInternal(config, WEBP_PRESET_DEFAULT, 75.f,
156 WEBP_ENCODER_ABI_VERSION);
159 // This function will initialize the configuration according to a predefined
160 // set of parameters (referred to by 'preset') and a given quality factor.
161 // This function can be called as a replacement to WebPConfigInit(). Will
162 // return false in case of error.
163 static WEBP_INLINE int WebPConfigPreset(WebPConfig* config,
164 WebPPreset preset, float quality) {
165 return WebPConfigInitInternal(config, preset, quality,
166 WEBP_ENCODER_ABI_VERSION);
169 // Returns true if 'config' is non-NULL and all configuration parameters are
170 // within their valid ranges.
171 WEBP_EXTERN(int) WebPValidateConfig(const WebPConfig* config);
173 //------------------------------------------------------------------------------
175 // Structure for storing auxiliary statistics (mostly for lossy encoding).
177 struct WebPAuxStats {
178 int coded_size; // final size
180 float PSNR[5]; // peak-signal-to-noise ratio for Y/U/V/All/Alpha
181 int block_count[3]; // number of intra4/intra16/skipped macroblocks
182 int header_bytes[2]; // approximate number of bytes spent for header
183 // and mode-partition #0
184 int residual_bytes[3][4]; // approximate number of bytes spent for
185 // DC/AC/uv coefficients for each (0..3) segments.
186 int segment_size[4]; // number of macroblocks in each segments
187 int segment_quant[4]; // quantizer values for each segments
188 int segment_level[4]; // filtering strength for each segments [0..63]
190 int alpha_data_size; // size of the transparency data
191 int layer_data_size; // size of the enhancement layer data
193 // lossless encoder statistics
194 uint32_t lossless_features; // bit0:predictor bit1:cross-color transform
195 // bit2:subtract-green bit3:color indexing
196 int histogram_bits; // number of precision bits of histogram
197 int transform_bits; // precision bits for transform
198 int cache_bits; // number of bits for color cache lookup
199 int palette_size; // number of color in palette, if used
200 int lossless_size; // final lossless size
202 uint32_t pad[4]; // padding for later use
205 // Signature for output function. Should return true if writing was successful.
206 // data/data_size is the segment of data to write, and 'picture' is for
207 // reference (and so one can make use of picture->custom_ptr).
208 typedef int (*WebPWriterFunction)(const uint8_t* data, size_t data_size,
209 const WebPPicture* picture);
211 // WebPMemoryWrite: a special WebPWriterFunction that writes to memory using
212 // the following WebPMemoryWriter object (to be set as a custom_ptr).
213 struct WebPMemoryWriter {
214 uint8_t* mem; // final buffer (of size 'max_size', larger than 'size').
215 size_t size; // final size
216 size_t max_size; // total capacity
217 uint32_t pad[1]; // padding for later use
220 // The following must be called first before any use.
221 WEBP_EXTERN(void) WebPMemoryWriterInit(WebPMemoryWriter* writer);
223 // The custom writer to be used with WebPMemoryWriter as custom_ptr. Upon
224 // completion, writer.mem and writer.size will hold the coded data.
225 // writer.mem must be freed using the call 'free(writer.mem)'.
226 WEBP_EXTERN(int) WebPMemoryWrite(const uint8_t* data, size_t data_size,
227 const WebPPicture* picture);
229 // Progress hook, called from time to time to report progress. It can return
230 // false to request an abort of the encoding process, or true otherwise if
232 typedef int (*WebPProgressHook)(int percent, const WebPPicture* picture);
235 typedef enum WebPEncCSP {
237 WEBP_YUV420 = 0, // 4:2:0
238 WEBP_YUV422 = 1, // 4:2:2
239 WEBP_YUV444 = 2, // 4:4:4
240 WEBP_YUV400 = 3, // grayscale
241 WEBP_CSP_UV_MASK = 3, // bit-mask to get the UV sampling factors
242 // alpha channel variants
246 WEBP_YUV400A = 7, // grayscale + alpha
247 WEBP_CSP_ALPHA_BIT = 4 // bit that is set if alpha is present
250 // Encoding error conditions.
251 typedef enum WebPEncodingError {
253 VP8_ENC_ERROR_OUT_OF_MEMORY, // memory error allocating objects
254 VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY, // memory error while flushing bits
255 VP8_ENC_ERROR_NULL_PARAMETER, // a pointer parameter is NULL
256 VP8_ENC_ERROR_INVALID_CONFIGURATION, // configuration is invalid
257 VP8_ENC_ERROR_BAD_DIMENSION, // picture has invalid width/height
258 VP8_ENC_ERROR_PARTITION0_OVERFLOW, // partition is bigger than 512k
259 VP8_ENC_ERROR_PARTITION_OVERFLOW, // partition is bigger than 16M
260 VP8_ENC_ERROR_BAD_WRITE, // error while flushing bytes
261 VP8_ENC_ERROR_FILE_TOO_BIG, // file is bigger than 4G
262 VP8_ENC_ERROR_USER_ABORT, // abort request by user
263 VP8_ENC_ERROR_LAST // list terminator. always last.
266 // maximum width/height allowed (inclusive), in pixels
267 #define WEBP_MAX_DIMENSION 16383
269 // Main exchange structure (input samples, output bytes, statistics)
273 // Main flag for encoder selecting between ARGB or YUV input.
274 // It is recommended to use ARGB input (*argb, argb_stride) for lossless
275 // compression, and YUV input (*y, *u, *v, etc.) for lossy compression
276 // since these are the respective native colorspace for these formats.
279 // YUV input (mostly used for input to lossy compression)
280 WebPEncCSP colorspace; // colorspace: should be YUV420 for now (=Y'CbCr).
281 int width, height; // dimensions (less or equal to WEBP_MAX_DIMENSION)
282 uint8_t *y, *u, *v; // pointers to luma/chroma planes.
283 int y_stride, uv_stride; // luma/chroma strides.
284 uint8_t* a; // pointer to the alpha plane
285 int a_stride; // stride of the alpha plane
286 uint32_t pad1[2]; // padding for later use
288 // ARGB input (mostly used for input to lossless compression)
289 uint32_t* argb; // Pointer to argb (32 bit) plane.
290 int argb_stride; // This is stride in pixels units, not bytes.
291 uint32_t pad2[3]; // padding for later use
295 // Byte-emission hook, to store compressed bytes as they are ready.
296 WebPWriterFunction writer; // can be NULL
297 void* custom_ptr; // can be used by the writer.
299 // map for extra information (only for lossy compression mode)
300 int extra_info_type; // 1: intra type, 2: segment, 3: quant
301 // 4: intra-16 prediction mode,
302 // 5: chroma prediction mode,
303 // 6: bit cost, 7: distortion
304 uint8_t* extra_info; // if not NULL, points to an array of size
305 // ((width + 15) / 16) * ((height + 15) / 16) that
306 // will be filled with a macroblock map, depending
307 // on extra_info_type.
310 ///////////////////////////
311 // Pointer to side statistics (updated only if not NULL)
314 // Error code for the latest error encountered during encoding
315 WebPEncodingError error_code;
317 // If not NULL, report progress during encoding.
318 WebPProgressHook progress_hook;
320 void* user_data; // this field is free to be set to any value and
321 // used during callbacks (like progress-report e.g.).
323 uint32_t pad3[3]; // padding for later use
325 // Unused for now: original samples (for non-YUV420 modes)
329 uint32_t pad4[7]; // padding for later use
333 void* memory_; // row chunk of memory for yuva planes
334 void* memory_argb_; // and for argb too.
335 void* pad5[2]; // padding for later use
338 // Internal, version-checked, entry point
339 WEBP_EXTERN(int) WebPPictureInitInternal(WebPPicture*, int);
341 // Should always be called, to initialize the structure. Returns false in case
342 // of version mismatch. WebPPictureInit() must have succeeded before using the
344 // Note that, by default, use_argb is false and colorspace is WEBP_YUV420.
345 static WEBP_INLINE int WebPPictureInit(WebPPicture* picture) {
346 return WebPPictureInitInternal(picture, WEBP_ENCODER_ABI_VERSION);
349 //------------------------------------------------------------------------------
352 // Convenience allocation / deallocation based on picture->width/height:
353 // Allocate y/u/v buffers as per colorspace/width/height specification.
354 // Note! This function will free the previous buffer if needed.
355 // Returns false in case of memory error.
356 WEBP_EXTERN(int) WebPPictureAlloc(WebPPicture* picture);
358 // Release the memory allocated by WebPPictureAlloc() or WebPPictureImport*().
359 // Note that this function does _not_ free the memory used by the 'picture'
361 // Besides memory (which is reclaimed) all other fields of 'picture' are
363 WEBP_EXTERN(void) WebPPictureFree(WebPPicture* picture);
365 // Copy the pixels of *src into *dst, using WebPPictureAlloc. Upon return, *dst
366 // will fully own the copied pixels (this is not a view). The 'dst' picture need
367 // not be initialized as its content is overwritten.
368 // Returns false in case of memory allocation error.
369 WEBP_EXTERN(int) WebPPictureCopy(const WebPPicture* src, WebPPicture* dst);
371 // Compute PSNR, SSIM or LSIM distortion metric between two pictures.
372 // Result is in dB, stores in result[] in the Y/U/V/Alpha/All order.
373 // Returns false in case of error (src and ref don't have same dimension, ...)
374 // Warning: this function is rather CPU-intensive.
375 WEBP_EXTERN(int) WebPPictureDistortion(
376 const WebPPicture* src, const WebPPicture* ref,
377 int metric_type, // 0 = PSNR, 1 = SSIM, 2 = LSIM
380 // self-crops a picture to the rectangle defined by top/left/width/height.
381 // Returns false in case of memory allocation error, or if the rectangle is
382 // outside of the source picture.
383 // The rectangle for the view is defined by the top-left corner pixel
384 // coordinates (left, top) as well as its width and height. This rectangle
385 // must be fully be comprised inside the 'src' source picture. If the source
386 // picture uses the YUV420 colorspace, the top and left coordinates will be
387 // snapped to even values.
388 WEBP_EXTERN(int) WebPPictureCrop(WebPPicture* picture,
389 int left, int top, int width, int height);
391 // Extracts a view from 'src' picture into 'dst'. The rectangle for the view
392 // is defined by the top-left corner pixel coordinates (left, top) as well
393 // as its width and height. This rectangle must be fully be comprised inside
394 // the 'src' source picture. If the source picture uses the YUV420 colorspace,
395 // the top and left coordinates will be snapped to even values.
396 // Picture 'src' must out-live 'dst' picture. Self-extraction of view is allowed
397 // ('src' equal to 'dst') as a mean of fast-cropping (but note that doing so,
398 // the original dimension will be lost). Picture 'dst' need not be initialized
399 // with WebPPictureInit() if it is different from 'src', since its content will
401 // Returns false in case of memory allocation error or invalid parameters.
402 WEBP_EXTERN(int) WebPPictureView(const WebPPicture* src,
403 int left, int top, int width, int height,
406 // Returns true if the 'picture' is actually a view and therefore does
407 // not own the memory for pixels.
408 WEBP_EXTERN(int) WebPPictureIsView(const WebPPicture* picture);
410 // Rescale a picture to new dimension width x height.
411 // Now gamma correction is applied.
412 // Returns false in case of error (invalid parameter or insufficient memory).
413 WEBP_EXTERN(int) WebPPictureRescale(WebPPicture* pic, int width, int height);
415 // Colorspace conversion function to import RGB samples.
416 // Previous buffer will be free'd, if any.
417 // *rgb buffer should have a size of at least height * rgb_stride.
418 // Returns false in case of memory error.
419 WEBP_EXTERN(int) WebPPictureImportRGB(
420 WebPPicture* picture, const uint8_t* rgb, int rgb_stride);
421 // Same, but for RGBA buffer.
422 WEBP_EXTERN(int) WebPPictureImportRGBA(
423 WebPPicture* picture, const uint8_t* rgba, int rgba_stride);
424 // Same, but for RGBA buffer. Imports the RGB direct from the 32-bit format
425 // input buffer ignoring the alpha channel. Avoids needing to copy the data
426 // to a temporary 24-bit RGB buffer to import the RGB only.
427 WEBP_EXTERN(int) WebPPictureImportRGBX(
428 WebPPicture* picture, const uint8_t* rgbx, int rgbx_stride);
430 // Variants of the above, but taking BGR(A|X) input.
431 WEBP_EXTERN(int) WebPPictureImportBGR(
432 WebPPicture* picture, const uint8_t* bgr, int bgr_stride);
433 WEBP_EXTERN(int) WebPPictureImportBGRA(
434 WebPPicture* picture, const uint8_t* bgra, int bgra_stride);
435 WEBP_EXTERN(int) WebPPictureImportBGRX(
436 WebPPicture* picture, const uint8_t* bgrx, int bgrx_stride);
438 // Converts picture->argb data to the YUVA format specified by 'colorspace'.
439 // Upon return, picture->use_argb is set to false. The presence of real
440 // non-opaque transparent values is detected, and 'colorspace' will be
441 // adjusted accordingly. Note that this method is lossy.
442 // Returns false in case of error.
443 WEBP_EXTERN(int) WebPPictureARGBToYUVA(WebPPicture* picture,
444 WebPEncCSP colorspace);
446 // Converts picture->yuv to picture->argb and sets picture->use_argb to true.
447 // The input format must be YUV_420 or YUV_420A.
448 // Note that the use of this method is discouraged if one has access to the
449 // raw ARGB samples, since using YUV420 is comparatively lossy. Also, the
450 // conversion from YUV420 to ARGB incurs a small loss too.
451 // Returns false in case of error.
452 WEBP_EXTERN(int) WebPPictureYUVAToARGB(WebPPicture* picture);
454 // Helper function: given a width x height plane of YUV(A) samples
455 // (with stride 'stride'), clean-up the YUV samples under fully transparent
456 // area, to help compressibility (no guarantee, though).
457 WEBP_EXTERN(void) WebPCleanupTransparentArea(WebPPicture* picture);
459 // Scan the picture 'picture' for the presence of non fully opaque alpha values.
460 // Returns true in such case. Otherwise returns false (indicating that the
461 // alpha plane can be ignored altogether e.g.).
462 WEBP_EXTERN(int) WebPPictureHasTransparency(const WebPPicture* picture);
464 //------------------------------------------------------------------------------
467 // Main encoding call, after config and picture have been initialized.
468 // 'picture' must be less than 16384x16384 in dimension (cf WEBP_MAX_DIMENSION),
469 // and the 'config' object must be a valid one.
470 // Returns false in case of error, true otherwise.
471 // In case of error, picture->error_code is updated accordingly.
472 // 'picture' can hold the source samples in both YUV(A) or ARGB input, depending
473 // on the value of 'picture->use_argb'. It is highly recommended to use
474 // the former for lossy encoding, and the latter for lossless encoding
475 // (when config.lossless is true). Automatic conversion from one format to
476 // another is provided but they both incur some loss.
477 WEBP_EXTERN(int) WebPEncode(const WebPConfig* config, WebPPicture* picture);
479 //------------------------------------------------------------------------------
481 #if defined(__cplusplus) || defined(c_plusplus)
485 #endif /* WEBP_WEBP_ENCODE_H_ */