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