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