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 (at) 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: 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 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 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 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. The values in these pointers are only valid on successful (non-NULL) 344 // return. 345 WEBP_EXTERN uint8_t* WebPIDecGetRGB( 346 const WebPIDecoder* idec, int* last_y, 347 int* width, int* height, int* stride); 348 349 // Same as above function to get a YUVA image. Returns pointer to the luma 350 // plane or NULL in case of error. If there is no alpha information 351 // the alpha pointer '*a' will be returned NULL. 352 WEBP_EXTERN uint8_t* WebPIDecGetYUVA( 353 const WebPIDecoder* idec, int* last_y, 354 uint8_t** u, uint8_t** v, uint8_t** a, 355 int* width, int* height, int* stride, int* uv_stride, int* a_stride); 356 357 // Deprecated alpha-less version of WebPIDecGetYUVA(): it will ignore the 358 // alpha information (if present). Kept for backward compatibility. 359 static WEBP_INLINE uint8_t* WebPIDecGetYUV( 360 const WebPIDecoder* idec, int* last_y, uint8_t** u, uint8_t** v, 361 int* width, int* height, int* stride, int* uv_stride) { 362 return WebPIDecGetYUVA(idec, last_y, u, v, NULL, width, height, 363 stride, uv_stride, NULL); 364 } 365 366 // Generic call to retrieve information about the displayable area. 367 // If non NULL, the left/right/width/height pointers are filled with the visible 368 // rectangular area so far. 369 // Returns NULL in case the incremental decoder object is in an invalid state. 370 // Otherwise returns the pointer to the internal representation. This structure 371 // is read-only, tied to WebPIDecoder's lifespan and should not be modified. 372 WEBP_EXTERN const WebPDecBuffer* WebPIDecodedArea( 373 const WebPIDecoder* idec, int* left, int* top, int* width, int* height); 374 375 //------------------------------------------------------------------------------ 376 // Advanced decoding parametrization 377 // 378 // Code sample for using the advanced decoding API 379 /* 380 // A) Init a configuration object 381 WebPDecoderConfig config; 382 CHECK(WebPInitDecoderConfig(&config)); 383 384 // B) optional: retrieve the bitstream's features. 385 CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK); 386 387 // C) Adjust 'config', if needed 388 config.no_fancy_upsampling = 1; 389 config.output.colorspace = MODE_BGRA; 390 // etc. 391 392 // Note that you can also make config.output point to an externally 393 // supplied memory buffer, provided it's big enough to store the decoded 394 // picture. Otherwise, config.output will just be used to allocate memory 395 // and store the decoded picture. 396 397 // D) Decode! 398 CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK); 399 400 // E) Decoded image is now in config.output (and config.output.u.RGBA) 401 402 // F) Reclaim memory allocated in config's object. It's safe to call 403 // this function even if the memory is external and wasn't allocated 404 // by WebPDecode(). 405 WebPFreeDecBuffer(&config.output); 406 */ 407 408 // Features gathered from the bitstream 409 struct WebPBitstreamFeatures { 410 int width; // Width in pixels, as read from the bitstream. 411 int height; // Height in pixels, as read from the bitstream. 412 int has_alpha; // True if the bitstream contains an alpha channel. 413 int has_animation; // True if the bitstream is an animation. 414 int format; // 0 = undefined (/mixed), 1 = lossy, 2 = lossless 415 416 uint32_t pad[5]; // padding for later use 417 }; 418 419 // Internal, version-checked, entry point 420 WEBP_EXTERN VP8StatusCode WebPGetFeaturesInternal( 421 const uint8_t*, size_t, WebPBitstreamFeatures*, int); 422 423 // Retrieve features from the bitstream. The *features structure is filled 424 // with information gathered from the bitstream. 425 // Returns VP8_STATUS_OK when the features are successfully retrieved. Returns 426 // VP8_STATUS_NOT_ENOUGH_DATA when more data is needed to retrieve the 427 // features from headers. Returns error in other cases. 428 static WEBP_INLINE VP8StatusCode WebPGetFeatures( 429 const uint8_t* data, size_t data_size, 430 WebPBitstreamFeatures* features) { 431 return WebPGetFeaturesInternal(data, data_size, features, 432 WEBP_DECODER_ABI_VERSION); 433 } 434 435 // Decoding options 436 struct WebPDecoderOptions { 437 int bypass_filtering; // if true, skip the in-loop filtering 438 int no_fancy_upsampling; // if true, use faster pointwise upsampler 439 int use_cropping; // if true, cropping is applied _first_ 440 int crop_left, crop_top; // top-left position for cropping. 441 // Will be snapped to even values. 442 int crop_width, crop_height; // dimension of the cropping area 443 int use_scaling; // if true, scaling is applied _afterward_ 444 int scaled_width, scaled_height; // final resolution 445 int use_threads; // if true, use multi-threaded decoding 446 int dithering_strength; // dithering strength (0=Off, 100=full) 447 int flip; // flip output vertically 448 int alpha_dithering_strength; // alpha dithering strength in [0..100] 449 450 uint32_t pad[5]; // padding for later use 451 }; 452 453 // Main object storing the configuration for advanced decoding. 454 struct WebPDecoderConfig { 455 WebPBitstreamFeatures input; // Immutable bitstream features (optional) 456 WebPDecBuffer output; // Output buffer (can point to external mem) 457 WebPDecoderOptions options; // Decoding options 458 }; 459 460 // Internal, version-checked, entry point 461 WEBP_EXTERN int WebPInitDecoderConfigInternal(WebPDecoderConfig*, int); 462 463 // Initialize the configuration as empty. This function must always be 464 // called first, unless WebPGetFeatures() is to be called. 465 // Returns false in case of mismatched version. 466 static WEBP_INLINE int WebPInitDecoderConfig(WebPDecoderConfig* config) { 467 return WebPInitDecoderConfigInternal(config, WEBP_DECODER_ABI_VERSION); 468 } 469 470 // Instantiate a new incremental decoder object with the requested 471 // configuration. The bitstream can be passed using 'data' and 'data_size' 472 // parameter, in which case the features will be parsed and stored into 473 // config->input. Otherwise, 'data' can be NULL and no parsing will occur. 474 // Note that 'config' can be NULL too, in which case a default configuration 475 // is used. If 'config' is not NULL, it must outlive the WebPIDecoder object 476 // as some references to its fields will be used. No internal copy of 'config' 477 // is made. 478 // The return WebPIDecoder object must always be deleted calling WebPIDelete(). 479 // Returns NULL in case of error (and config->status will then reflect 480 // the error condition, if available). 481 WEBP_EXTERN WebPIDecoder* WebPIDecode(const uint8_t* data, size_t data_size, 482 WebPDecoderConfig* config); 483 484 // Non-incremental version. This version decodes the full data at once, taking 485 // 'config' into account. Returns decoding status (which should be VP8_STATUS_OK 486 // if the decoding was successful). Note that 'config' cannot be NULL. 487 WEBP_EXTERN VP8StatusCode WebPDecode(const uint8_t* data, size_t data_size, 488 WebPDecoderConfig* config); 489 490 #ifdef __cplusplus 491 } // extern "C" 492 #endif 493 494 #endif /* WEBP_WEBP_DECODE_H_ */ 495