← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/libwebp/src/webp/encode.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

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