← 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/decode.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/decode.h
1
 
// Copyright 2010 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
 
//  Main decoding functions for WebP images.
11
 
//
12
 
// Author: Skal (pascal.massimino@gmail.com)
13
 
 
14
 
#ifndef WEBP_WEBP_DECODE_H_
15
 
#define WEBP_WEBP_DECODE_H_
16
 
 
17
 
#include "./types.h"
18
 
 
19
 
#ifdef __cplusplus
20
 
extern "C" {
21
 
#endif
22
 
 
23
 
#define WEBP_DECODER_ABI_VERSION 0x0203    // 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 VP8StatusCode VP8StatusCode;
28
 
// typedef enum WEBP_CSP_MODE WEBP_CSP_MODE;
29
 
typedef struct WebPRGBABuffer WebPRGBABuffer;
30
 
typedef struct WebPYUVABuffer WebPYUVABuffer;
31
 
typedef struct WebPDecBuffer WebPDecBuffer;
32
 
typedef struct WebPIDecoder WebPIDecoder;
33
 
typedef struct WebPBitstreamFeatures WebPBitstreamFeatures;
34
 
typedef struct WebPDecoderOptions WebPDecoderOptions;
35
 
typedef struct WebPDecoderConfig WebPDecoderConfig;
36
 
 
37
 
// Return the decoder's version number, packed in hexadecimal using 8bits for
38
 
// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
39
 
WEBP_EXTERN(int) WebPGetDecoderVersion(void);
40
 
 
41
 
// Retrieve basic header information: width, height.
42
 
// This function will also validate the header and return 0 in
43
 
// case of formatting error.
44
 
// Pointers 'width' and 'height' can be passed NULL if deemed irrelevant.
45
 
WEBP_EXTERN(int) WebPGetInfo(const uint8_t* data, size_t data_size,
46
 
                             int* width, int* height);
47
 
 
48
 
// Decodes WebP images pointed to by 'data' and returns RGBA samples, along
49
 
// with the dimensions in *width and *height. The ordering of samples in
50
 
// memory is R, G, B, A, R, G, B, A... in scan order (endian-independent).
51
 
// The returned pointer should be deleted calling free().
52
 
// Returns NULL in case of error.
53
 
WEBP_EXTERN(uint8_t*) WebPDecodeRGBA(const uint8_t* data, size_t data_size,
54
 
                                     int* width, int* height);
55
 
 
56
 
// Same as WebPDecodeRGBA, but returning A, R, G, B, A, R, G, B... ordered data.
57
 
WEBP_EXTERN(uint8_t*) WebPDecodeARGB(const uint8_t* data, size_t data_size,
58
 
                                     int* width, int* height);
59
 
 
60
 
// Same as WebPDecodeRGBA, but returning B, G, R, A, B, G, R, A... ordered data.
61
 
WEBP_EXTERN(uint8_t*) WebPDecodeBGRA(const uint8_t* data, size_t data_size,
62
 
                                     int* width, int* height);
63
 
 
64
 
// Same as WebPDecodeRGBA, but returning R, G, B, R, G, B... ordered data.
65
 
// If the bitstream contains transparency, it is ignored.
66
 
WEBP_EXTERN(uint8_t*) WebPDecodeRGB(const uint8_t* data, size_t data_size,
67
 
                                    int* width, int* height);
68
 
 
69
 
// Same as WebPDecodeRGB, but returning B, G, R, B, G, R... ordered data.
70
 
WEBP_EXTERN(uint8_t*) WebPDecodeBGR(const uint8_t* data, size_t data_size,
71
 
                                    int* width, int* height);
72
 
 
73
 
 
74
 
// Decode WebP images pointed to by 'data' to Y'UV format(*). The pointer
75
 
// returned is the Y samples buffer. Upon return, *u and *v will point to
76
 
// the U and V chroma data. These U and V buffers need NOT be free()'d,
77
 
// unlike the returned Y luma one. The dimension of the U and V planes
78
 
// are both (*width + 1) / 2 and (*height + 1)/ 2.
79
 
// Upon return, the Y buffer has a stride returned as '*stride', while U and V
80
 
// have a common stride returned as '*uv_stride'.
81
 
// Return NULL in case of error.
82
 
// (*) Also named Y'CbCr. See: http://en.wikipedia.org/wiki/YCbCr
83
 
WEBP_EXTERN(uint8_t*) WebPDecodeYUV(const uint8_t* data, size_t data_size,
84
 
                                    int* width, int* height,
85
 
                                    uint8_t** u, uint8_t** v,
86
 
                                    int* stride, int* uv_stride);
87
 
 
88
 
// These five functions are variants of the above ones, that decode the image
89
 
// directly into a pre-allocated buffer 'output_buffer'. The maximum storage
90
 
// available in this buffer is indicated by 'output_buffer_size'. If this
91
 
// storage is not sufficient (or an error occurred), NULL is returned.
92
 
// Otherwise, output_buffer is returned, for convenience.
93
 
// The parameter 'output_stride' specifies the distance (in bytes)
94
 
// between scanlines. Hence, output_buffer_size is expected to be at least
95
 
// output_stride x picture-height.
96
 
WEBP_EXTERN(uint8_t*) WebPDecodeRGBAInto(
97
 
    const uint8_t* data, size_t data_size,
98
 
    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
99
 
WEBP_EXTERN(uint8_t*) WebPDecodeARGBInto(
100
 
    const uint8_t* data, size_t data_size,
101
 
    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
102
 
WEBP_EXTERN(uint8_t*) WebPDecodeBGRAInto(
103
 
    const uint8_t* data, size_t data_size,
104
 
    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
105
 
 
106
 
// RGB and BGR variants. Here too the transparency information, if present,
107
 
// will be dropped and ignored.
108
 
WEBP_EXTERN(uint8_t*) WebPDecodeRGBInto(
109
 
    const uint8_t* data, size_t data_size,
110
 
    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
111
 
WEBP_EXTERN(uint8_t*) WebPDecodeBGRInto(
112
 
    const uint8_t* data, size_t data_size,
113
 
    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
114
 
 
115
 
// WebPDecodeYUVInto() is a variant of WebPDecodeYUV() that operates directly
116
 
// into pre-allocated luma/chroma plane buffers. This function requires the
117
 
// strides to be passed: one for the luma plane and one for each of the
118
 
// chroma ones. The size of each plane buffer is passed as 'luma_size',
119
 
// 'u_size' and 'v_size' respectively.
120
 
// Pointer to the luma plane ('*luma') is returned or NULL if an error occurred
121
 
// during decoding (or because some buffers were found to be too small).
122
 
WEBP_EXTERN(uint8_t*) WebPDecodeYUVInto(
123
 
    const uint8_t* data, size_t data_size,
124
 
    uint8_t* luma, size_t luma_size, int luma_stride,
125
 
    uint8_t* u, size_t u_size, int u_stride,
126
 
    uint8_t* v, size_t v_size, int v_stride);
127
 
 
128
 
//------------------------------------------------------------------------------
129
 
// Output colorspaces and buffer
130
 
 
131
 
// Colorspaces
132
 
// Note: the naming describes the byte-ordering of packed samples in memory.
133
 
// For instance, MODE_BGRA relates to samples ordered as B,G,R,A,B,G,R,A,...
134
 
// Non-capital names (e.g.:MODE_Argb) relates to pre-multiplied RGB channels.
135
 
// RGBA-4444 and RGB-565 colorspaces are represented by following byte-order:
136
 
// RGBA-4444: [r3 r2 r1 r0 g3 g2 g1 g0], [b3 b2 b1 b0 a3 a2 a1 a0], ...
137
 
// RGB-565: [r4 r3 r2 r1 r0 g5 g4 g3], [g2 g1 g0 b4 b3 b2 b1 b0], ...
138
 
// In the case WEBP_SWAP_16BITS_CSP is defined, the bytes are swapped for
139
 
// these two modes:
140
 
// RGBA-4444: [b3 b2 b1 b0 a3 a2 a1 a0], [r3 r2 r1 r0 g3 g2 g1 g0], ...
141
 
// RGB-565: [g2 g1 g0 b4 b3 b2 b1 b0], [r4 r3 r2 r1 r0 g5 g4 g3], ...
142
 
 
143
 
typedef enum WEBP_CSP_MODE {
144
 
  MODE_RGB = 0, MODE_RGBA = 1,
145
 
  MODE_BGR = 2, MODE_BGRA = 3,
146
 
  MODE_ARGB = 4, MODE_RGBA_4444 = 5,
147
 
  MODE_RGB_565 = 6,
148
 
  // RGB-premultiplied transparent modes (alpha value is preserved)
149
 
  MODE_rgbA = 7,
150
 
  MODE_bgrA = 8,
151
 
  MODE_Argb = 9,
152
 
  MODE_rgbA_4444 = 10,
153
 
  // YUV modes must come after RGB ones.
154
 
  MODE_YUV = 11, MODE_YUVA = 12,  // yuv 4:2:0
155
 
  MODE_LAST = 13
156
 
} WEBP_CSP_MODE;
157
 
 
158
 
// Some useful macros:
159
 
static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
160
 
  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
161
 
          mode == MODE_rgbA_4444);
162
 
}
163
 
 
164
 
static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
165
 
  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
166
 
          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
167
 
          WebPIsPremultipliedMode(mode));
168
 
}
169
 
 
170
 
static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
171
 
  return (mode < MODE_YUV);
172
 
}
173
 
 
174
 
//------------------------------------------------------------------------------
175
 
// WebPDecBuffer: Generic structure for describing the output sample buffer.
176
 
 
177
 
struct WebPRGBABuffer {    // view as RGBA
178
 
  uint8_t* rgba;    // pointer to RGBA samples
179
 
  int stride;       // stride in bytes from one scanline to the next.
180
 
  size_t size;      // total size of the *rgba buffer.
181
 
};
182
 
 
183
 
struct WebPYUVABuffer {              // view as YUVA
184
 
  uint8_t* y, *u, *v, *a;     // pointer to luma, chroma U/V, alpha samples
185
 
  int y_stride;               // luma stride
186
 
  int u_stride, v_stride;     // chroma strides
187
 
  int a_stride;               // alpha stride
188
 
  size_t y_size;              // luma plane size
189
 
  size_t u_size, v_size;      // chroma planes size
190
 
  size_t a_size;              // alpha-plane size
191
 
};
192
 
 
193
 
// Output buffer
194
 
struct WebPDecBuffer {
195
 
  WEBP_CSP_MODE colorspace;  // Colorspace.
196
 
  int width, height;         // Dimensions.
197
 
  int is_external_memory;    // If true, 'internal_memory' pointer is not used.
198
 
  union {
199
 
    WebPRGBABuffer RGBA;
200
 
    WebPYUVABuffer YUVA;
201
 
  } u;                       // Nameless union of buffer parameters.
202
 
  uint32_t       pad[4];     // padding for later use
203
 
 
204
 
  uint8_t* private_memory;   // Internally allocated memory (only when
205
 
                             // is_external_memory is false). Should not be used
206
 
                             // externally, but accessed via the buffer union.
207
 
};
208
 
 
209
 
// Internal, version-checked, entry point
210
 
WEBP_EXTERN(int) WebPInitDecBufferInternal(WebPDecBuffer*, int);
211
 
 
212
 
// Initialize the structure as empty. Must be called before any other use.
213
 
// Returns false in case of version mismatch
214
 
static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
215
 
  return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
216
 
}
217
 
 
218
 
// Free any memory associated with the buffer. Must always be called last.
219
 
// Note: doesn't free the 'buffer' structure itself.
220
 
WEBP_EXTERN(void) WebPFreeDecBuffer(WebPDecBuffer* buffer);
221
 
 
222
 
//------------------------------------------------------------------------------
223
 
// Enumeration of the status codes
224
 
 
225
 
typedef enum VP8StatusCode {
226
 
  VP8_STATUS_OK = 0,
227
 
  VP8_STATUS_OUT_OF_MEMORY,
228
 
  VP8_STATUS_INVALID_PARAM,
229
 
  VP8_STATUS_BITSTREAM_ERROR,
230
 
  VP8_STATUS_UNSUPPORTED_FEATURE,
231
 
  VP8_STATUS_SUSPENDED,
232
 
  VP8_STATUS_USER_ABORT,
233
 
  VP8_STATUS_NOT_ENOUGH_DATA
234
 
} VP8StatusCode;
235
 
 
236
 
//------------------------------------------------------------------------------
237
 
// Incremental decoding
238
 
//
239
 
// This API allows streamlined decoding of partial data.
240
 
// Picture can be incrementally decoded as data become available thanks to the
241
 
// WebPIDecoder object. This object can be left in a SUSPENDED state if the
242
 
// picture is only partially decoded, pending additional input.
243
 
// Code example:
244
 
//
245
 
//   WebPInitDecBuffer(&buffer);
246
 
//   buffer.colorspace = mode;
247
 
//   ...
248
 
//   WebPIDecoder* idec = WebPINewDecoder(&buffer);
249
 
//   while (has_more_data) {
250
 
//     // ... (get additional data)
251
 
//     status = WebPIAppend(idec, new_data, new_data_size);
252
 
//     if (status != VP8_STATUS_SUSPENDED ||
253
 
//       break;
254
 
//     }
255
 
//
256
 
//     // The above call decodes the current available buffer.
257
 
//     // Part of the image can now be refreshed by calling to
258
 
//     // WebPIDecGetRGB()/WebPIDecGetYUVA() etc.
259
 
//   }
260
 
//   WebPIDelete(idec);
261
 
 
262
 
// Creates a new incremental decoder with the supplied buffer parameter.
263
 
// This output_buffer can be passed NULL, in which case a default output buffer
264
 
// is used (with MODE_RGB). Otherwise, an internal reference to 'output_buffer'
265
 
// is kept, which means that the lifespan of 'output_buffer' must be larger than
266
 
// that of the returned WebPIDecoder object.
267
 
// The supplied 'output_buffer' content MUST NOT be changed between calls to
268
 
// WebPIAppend() or WebPIUpdate() unless 'output_buffer.is_external_memory' is
269
 
// set to 1. In such a case, it is allowed to modify the pointers, size and
270
 
// stride of output_buffer.u.RGBA or output_buffer.u.YUVA, provided they remain
271
 
// within valid bounds.
272
 
// All other fields of WebPDecBuffer MUST remain constant between calls.
273
 
// Returns NULL if the allocation failed.
274
 
WEBP_EXTERN(WebPIDecoder*) WebPINewDecoder(WebPDecBuffer* output_buffer);
275
 
 
276
 
// This function allocates and initializes an incremental-decoder object, which
277
 
// will output the RGB/A samples specified by 'csp' into a preallocated
278
 
// buffer 'output_buffer'. The size of this buffer is at least
279
 
// 'output_buffer_size' and the stride (distance in bytes between two scanlines)
280
 
// is specified by 'output_stride'.
281
 
// Additionally, output_buffer can be passed NULL in which case the output
282
 
// buffer will be allocated automatically when the decoding starts. The
283
 
// colorspace 'csp' is taken into account for allocating this buffer. All other
284
 
// parameters are ignored.
285
 
// Returns NULL if the allocation failed, or if some parameters are invalid.
286
 
WEBP_EXTERN(WebPIDecoder*) WebPINewRGB(
287
 
    WEBP_CSP_MODE csp,
288
 
    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
289
 
 
290
 
// This function allocates and initializes an incremental-decoder object, which
291
 
// will output the raw luma/chroma samples into a preallocated planes if
292
 
// supplied. The luma plane is specified by its pointer 'luma', its size
293
 
// 'luma_size' and its stride 'luma_stride'. Similarly, the chroma-u plane
294
 
// is specified by the 'u', 'u_size' and 'u_stride' parameters, and the chroma-v
295
 
// plane by 'v' and 'v_size'. And same for the alpha-plane. The 'a' pointer
296
 
// can be pass NULL in case one is not interested in the transparency plane.
297
 
// Conversely, 'luma' can be passed NULL if no preallocated planes are supplied.
298
 
// In this case, the output buffer will be automatically allocated (using
299
 
// MODE_YUVA) when decoding starts. All parameters are then ignored.
300
 
// Returns NULL if the allocation failed or if a parameter is invalid.
301
 
WEBP_EXTERN(WebPIDecoder*) WebPINewYUVA(
302
 
    uint8_t* luma, size_t luma_size, int luma_stride,
303
 
    uint8_t* u, size_t u_size, int u_stride,
304
 
    uint8_t* v, size_t v_size, int v_stride,
305
 
    uint8_t* a, size_t a_size, int a_stride);
306
 
 
307
 
// Deprecated version of the above, without the alpha plane.
308
 
// Kept for backward compatibility.
309
 
WEBP_EXTERN(WebPIDecoder*) WebPINewYUV(
310
 
    uint8_t* luma, size_t luma_size, int luma_stride,
311
 
    uint8_t* u, size_t u_size, int u_stride,
312
 
    uint8_t* v, size_t v_size, int v_stride);
313
 
 
314
 
// Deletes the WebPIDecoder object and associated memory. Must always be called
315
 
// if WebPINewDecoder, WebPINewRGB or WebPINewYUV succeeded.
316
 
WEBP_EXTERN(void) WebPIDelete(WebPIDecoder* idec);
317
 
 
318
 
// Copies and decodes the next available data. Returns VP8_STATUS_OK when
319
 
// the image is successfully decoded. Returns VP8_STATUS_SUSPENDED when more
320
 
// data is expected. Returns error in other cases.
321
 
WEBP_EXTERN(VP8StatusCode) WebPIAppend(
322
 
    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
323
 
 
324
 
// A variant of the above function to be used when data buffer contains
325
 
// partial data from the beginning. In this case data buffer is not copied
326
 
// to the internal memory.
327
 
// Note that the value of the 'data' pointer can change between calls to
328
 
// WebPIUpdate, for instance when the data buffer is resized to fit larger data.
329
 
WEBP_EXTERN(VP8StatusCode) WebPIUpdate(
330
 
    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
331
 
 
332
 
// Returns the RGB/A image decoded so far. Returns NULL if output params
333
 
// are not initialized yet. The RGB/A output type corresponds to the colorspace
334
 
// specified during call to WebPINewDecoder() or WebPINewRGB().
335
 
// *last_y is the index of last decoded row in raster scan order. Some pointers
336
 
// (*last_y, *width etc.) can be NULL if corresponding information is not
337
 
// needed.
338
 
WEBP_EXTERN(uint8_t*) WebPIDecGetRGB(
339
 
    const WebPIDecoder* idec, int* last_y,
340
 
    int* width, int* height, int* stride);
341
 
 
342
 
// Same as above function to get a YUVA image. Returns pointer to the luma
343
 
// plane or NULL in case of error. If there is no alpha information
344
 
// the alpha pointer '*a' will be returned NULL.
345
 
WEBP_EXTERN(uint8_t*) WebPIDecGetYUVA(
346
 
    const WebPIDecoder* idec, int* last_y,
347
 
    uint8_t** u, uint8_t** v, uint8_t** a,
348
 
    int* width, int* height, int* stride, int* uv_stride, int* a_stride);
349
 
 
350
 
// Deprecated alpha-less version of WebPIDecGetYUVA(): it will ignore the
351
 
// alpha information (if present). Kept for backward compatibility.
352
 
static WEBP_INLINE uint8_t* WebPIDecGetYUV(
353
 
    const WebPIDecoder* idec, int* last_y, uint8_t** u, uint8_t** v,
354
 
    int* width, int* height, int* stride, int* uv_stride) {
355
 
  return WebPIDecGetYUVA(idec, last_y, u, v, NULL, width, height,
356
 
                         stride, uv_stride, NULL);
357
 
}
358
 
 
359
 
// Generic call to retrieve information about the displayable area.
360
 
// If non NULL, the left/right/width/height pointers are filled with the visible
361
 
// rectangular area so far.
362
 
// Returns NULL in case the incremental decoder object is in an invalid state.
363
 
// Otherwise returns the pointer to the internal representation. This structure
364
 
// is read-only, tied to WebPIDecoder's lifespan and should not be modified.
365
 
WEBP_EXTERN(const WebPDecBuffer*) WebPIDecodedArea(
366
 
    const WebPIDecoder* idec, int* left, int* top, int* width, int* height);
367
 
 
368
 
//------------------------------------------------------------------------------
369
 
// Advanced decoding parametrization
370
 
//
371
 
//  Code sample for using the advanced decoding API
372
 
/*
373
 
     // A) Init a configuration object
374
 
     WebPDecoderConfig config;
375
 
     CHECK(WebPInitDecoderConfig(&config));
376
 
 
377
 
     // B) optional: retrieve the bitstream's features.
378
 
     CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK);
379
 
 
380
 
     // C) Adjust 'config', if needed
381
 
     config.no_fancy_upsampling = 1;
382
 
     config.output.colorspace = MODE_BGRA;
383
 
     // etc.
384
 
 
385
 
     // Note that you can also make config.output point to an externally
386
 
     // supplied memory buffer, provided it's big enough to store the decoded
387
 
     // picture. Otherwise, config.output will just be used to allocate memory
388
 
     // and store the decoded picture.
389
 
 
390
 
     // D) Decode!
391
 
     CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
392
 
 
393
 
     // E) Decoded image is now in config.output (and config.output.u.RGBA)
394
 
 
395
 
     // F) Reclaim memory allocated in config's object. It's safe to call
396
 
     // this function even if the memory is external and wasn't allocated
397
 
     // by WebPDecode().
398
 
     WebPFreeDecBuffer(&config.output);
399
 
*/
400
 
 
401
 
// Features gathered from the bitstream
402
 
struct WebPBitstreamFeatures {
403
 
  int width;          // Width in pixels, as read from the bitstream.
404
 
  int height;         // Height in pixels, as read from the bitstream.
405
 
  int has_alpha;      // True if the bitstream contains an alpha channel.
406
 
  int has_animation;  // True if the bitstream is an animation.
407
 
  int format;         // 0 = undefined (/mixed), 1 = lossy, 2 = lossless
408
 
 
409
 
  // Unused for now:
410
 
  int no_incremental_decoding;  // if true, using incremental decoding is not
411
 
                                // recommended.
412
 
  int rotate;                   // TODO(later)
413
 
  int uv_sampling;              // should be 0 for now. TODO(later)
414
 
  uint32_t pad[2];              // padding for later use
415
 
};
416
 
 
417
 
// Internal, version-checked, entry point
418
 
WEBP_EXTERN(VP8StatusCode) WebPGetFeaturesInternal(
419
 
    const uint8_t*, size_t, WebPBitstreamFeatures*, int);
420
 
 
421
 
// Retrieve features from the bitstream. The *features structure is filled
422
 
// with information gathered from the bitstream.
423
 
// Returns VP8_STATUS_OK when the features are successfully retrieved. Returns
424
 
// VP8_STATUS_NOT_ENOUGH_DATA when more data is needed to retrieve the
425
 
// features from headers. Returns error in other cases.
426
 
static WEBP_INLINE VP8StatusCode WebPGetFeatures(
427
 
    const uint8_t* data, size_t data_size,
428
 
    WebPBitstreamFeatures* features) {
429
 
  return WebPGetFeaturesInternal(data, data_size, features,
430
 
                                 WEBP_DECODER_ABI_VERSION);
431
 
}
432
 
 
433
 
// Decoding options
434
 
struct WebPDecoderOptions {
435
 
  int bypass_filtering;               // if true, skip the in-loop filtering
436
 
  int no_fancy_upsampling;            // if true, use faster pointwise upsampler
437
 
  int use_cropping;                   // if true, cropping is applied _first_
438
 
  int crop_left, crop_top;            // top-left position for cropping.
439
 
                                      // Will be snapped to even values.
440
 
  int crop_width, crop_height;        // dimension of the cropping area
441
 
  int use_scaling;                    // if true, scaling is applied _afterward_
442
 
  int scaled_width, scaled_height;    // final resolution
443
 
  int use_threads;                    // if true, use multi-threaded decoding
444
 
  int dithering_strength;             // dithering strength (0=Off, 100=full)
445
 
#if WEBP_DECODER_ABI_VERSION > 0x0203
446
 
  int flip;                           // flip output vertically
447
 
  int alpha_dithering_strength;       // alpha dithering strength in [0..100]
448
 
#endif
449
 
 
450
 
  // Unused for now:
451
 
  int force_rotation;                 // forced rotation (to be applied _last_)
452
 
  int no_enhancement;                 // if true, discard enhancement layer
453
 
#if WEBP_DECODER_ABI_VERSION > 0x0203
454
 
  uint32_t pad[3];                    // padding for later use
455
 
#else
456
 
  uint32_t pad[5];                    // padding for later use
457
 
#endif
458
 
};
459
 
 
460
 
// Main object storing the configuration for advanced decoding.
461
 
struct WebPDecoderConfig {
462
 
  WebPBitstreamFeatures input;  // Immutable bitstream features (optional)
463
 
  WebPDecBuffer output;         // Output buffer (can point to external mem)
464
 
  WebPDecoderOptions options;   // Decoding options
465
 
};
466
 
 
467
 
// Internal, version-checked, entry point
468
 
WEBP_EXTERN(int) WebPInitDecoderConfigInternal(WebPDecoderConfig*, int);
469
 
 
470
 
// Initialize the configuration as empty. This function must always be
471
 
// called first, unless WebPGetFeatures() is to be called.
472
 
// Returns false in case of mismatched version.
473
 
static WEBP_INLINE int WebPInitDecoderConfig(WebPDecoderConfig* config) {
474
 
  return WebPInitDecoderConfigInternal(config, WEBP_DECODER_ABI_VERSION);
475
 
}
476
 
 
477
 
// Instantiate a new incremental decoder object with the requested
478
 
// configuration. The bitstream can be passed using 'data' and 'data_size'
479
 
// parameter, in which case the features will be parsed and stored into
480
 
// config->input. Otherwise, 'data' can be NULL and no parsing will occur.
481
 
// Note that 'config' can be NULL too, in which case a default configuration
482
 
// is used.
483
 
// The return WebPIDecoder object must always be deleted calling WebPIDelete().
484
 
// Returns NULL in case of error (and config->status will then reflect
485
 
// the error condition).
486
 
WEBP_EXTERN(WebPIDecoder*) WebPIDecode(const uint8_t* data, size_t data_size,
487
 
                                       WebPDecoderConfig* config);
488
 
 
489
 
// Non-incremental version. This version decodes the full data at once, taking
490
 
// 'config' into account. Returns decoding status (which should be VP8_STATUS_OK
491
 
// if the decoding was successful).
492
 
WEBP_EXTERN(VP8StatusCode) WebPDecode(const uint8_t* data, size_t data_size,
493
 
                                      WebPDecoderConfig* config);
494
 
 
495
 
#ifdef __cplusplus
496
 
}    // extern "C"
497
 
#endif
498
 
 
499
 
#endif  /* WEBP_WEBP_DECODE_H_ */