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