← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/3rdparty/libwebp/webp/encode.h

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/3rdparty/libwebp/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
#if defined(__cplusplus) || defined(c_plusplus)
 
20
extern "C" {
 
21
#endif
 
22
 
 
23
#define WEBP_ENCODER_ABI_VERSION 0x0201    // 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 (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).
 
132
 
 
133
  uint32_t pad[5];        // padding for later use
 
134
};
 
135
 
 
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
 
145
} WebPPreset;
 
146
 
 
147
// Internal, version-checked, entry point
 
148
WEBP_EXTERN(int) WebPConfigInitInternal(WebPConfig*, WebPPreset, float, int);
 
149
 
 
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);
 
157
}
 
158
 
 
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);
 
167
}
 
168
 
 
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);
 
172
 
 
173
//------------------------------------------------------------------------------
 
174
// Input / Output
 
175
// Structure for storing auxiliary statistics (mostly for lossy encoding).
 
176
 
 
177
struct WebPAuxStats {
 
178
  int coded_size;         // final size
 
179
 
 
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]
 
189
 
 
190
  int alpha_data_size;    // size of the transparency data
 
191
  int layer_data_size;    // size of the enhancement layer data
 
192
 
 
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
 
201
 
 
202
  uint32_t pad[4];        // padding for later use
 
203
};
 
204
 
 
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);
 
210
 
 
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
 
218
};
 
219
 
 
220
// The following must be called first before any use.
 
221
WEBP_EXTERN(void) WebPMemoryWriterInit(WebPMemoryWriter* writer);
 
222
 
 
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);
 
228
 
 
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
 
231
// everything is OK.
 
232
typedef int (*WebPProgressHook)(int percent, const WebPPicture* picture);
 
233
 
 
234
// Color spaces.
 
235
typedef enum WebPEncCSP {
 
236
  // chroma sampling
 
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
 
243
  WEBP_YUV420A = 4,
 
244
  WEBP_YUV422A = 5,
 
245
  WEBP_YUV444A = 6,
 
246
  WEBP_YUV400A = 7,   // grayscale + alpha
 
247
  WEBP_CSP_ALPHA_BIT = 4   // bit that is set if alpha is present
 
248
} WebPEncCSP;
 
249
 
 
250
// Encoding error conditions.
 
251
typedef enum WebPEncodingError {
 
252
  VP8_ENC_OK = 0,
 
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.
 
264
} WebPEncodingError;
 
265
 
 
266
// maximum width/height allowed (inclusive), in pixels
 
267
#define WEBP_MAX_DIMENSION 16383
 
268
 
 
269
// Main exchange structure (input samples, output bytes, statistics)
 
270
struct WebPPicture {
 
271
  //   INPUT
 
272
  //////////////
 
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.
 
277
  int use_argb;
 
278
 
 
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
 
287
 
 
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
 
292
 
 
293
  //   OUTPUT
 
294
  ///////////////
 
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.
 
298
 
 
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.
 
308
 
 
309
  //   STATS AND REPORTS
 
310
  ///////////////////////////
 
311
  // Pointer to side statistics (updated only if not NULL)
 
312
  WebPAuxStats* stats;
 
313
 
 
314
  // Error code for the latest error encountered during encoding
 
315
  WebPEncodingError error_code;
 
316
 
 
317
  // If not NULL, report progress during encoding.
 
318
  WebPProgressHook progress_hook;
 
319
 
 
320
  void* user_data;        // this field is free to be set to any value and
 
321
                          // used during callbacks (like progress-report e.g.).
 
322
 
 
323
  uint32_t pad3[3];       // padding for later use
 
324
 
 
325
  // Unused for now: original samples (for non-YUV420 modes)
 
326
  uint8_t *u0, *v0;
 
327
  int uv0_stride;
 
328
 
 
329
  uint32_t pad4[7];       // padding for later use
 
330
 
 
331
  // PRIVATE FIELDS
 
332
  ////////////////////
 
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
 
336
};
 
337
 
 
338
// Internal, version-checked, entry point
 
339
WEBP_EXTERN(int) WebPPictureInitInternal(WebPPicture*, int);
 
340
 
 
341
// Should always be called, to initialize the structure. Returns false in case
 
342
// of version mismatch. WebPPictureInit() must have succeeded before using the
 
343
// 'picture' object.
 
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);
 
347
}
 
348
 
 
349
//------------------------------------------------------------------------------
 
350
// WebPPicture utils
 
351
 
 
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);
 
357
 
 
358
// Release the memory allocated by WebPPictureAlloc() or WebPPictureImport*().
 
359
// Note that this function does _not_ free the memory used by the 'picture'
 
360
// object itself.
 
361
// Besides memory (which is reclaimed) all other fields of 'picture' are
 
362
// preserved.
 
363
WEBP_EXTERN(void) WebPPictureFree(WebPPicture* picture);
 
364
 
 
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);
 
370
 
 
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
 
378
    float result[5]);
 
379
 
 
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);
 
390
 
 
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
 
400
// be overwritten.
 
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,
 
404
                                 WebPPicture* dst);
 
405
 
 
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);
 
409
 
 
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);
 
414
 
 
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);
 
429
 
 
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);
 
437
 
 
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);
 
445
 
 
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);
 
453
 
 
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);
 
458
 
 
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);
 
463
 
 
464
//------------------------------------------------------------------------------
 
465
// Main call
 
466
 
 
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);
 
478
 
 
479
//------------------------------------------------------------------------------
 
480
 
 
481
#if defined(__cplusplus) || defined(c_plusplus)
 
482
}    // extern "C"
 
483
#endif
 
484
 
 
485
#endif  /* WEBP_WEBP_ENCODE_H_ */