csp2: CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/webp/decode.h comparison

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/webp/decode.h @ 69:33d812a61356

planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d

author	jpayne
date	Tue, 18 Mar 2025 17:55:14 -0400
parents
children

comparison

equal deleted inserted replaced

-:0e9998148a16
+:33d812a61356
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+//  Main decoding functions for WebP images.
+//
+// Author: Skal (pascal.massimino@gmail.com)
+#ifndef WEBP_WEBP_DECODE_H_
+#define WEBP_WEBP_DECODE_H_
+#include "./types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define WEBP_DECODER_ABI_VERSION 0x0209    // MAJOR(8b) + MINOR(8b)
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum VP8StatusCode VP8StatusCode;
+// typedef enum WEBP_CSP_MODE WEBP_CSP_MODE;
+typedef struct WebPRGBABuffer WebPRGBABuffer;
+typedef struct WebPYUVABuffer WebPYUVABuffer;
+typedef struct WebPDecBuffer WebPDecBuffer;
+typedef struct WebPIDecoder WebPIDecoder;
+typedef struct WebPBitstreamFeatures WebPBitstreamFeatures;
+typedef struct WebPDecoderOptions WebPDecoderOptions;
+typedef struct WebPDecoderConfig WebPDecoderConfig;
+// Return the decoder's version number, packed in hexadecimal using 8bits for
+// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN int WebPGetDecoderVersion(void);
+// Retrieve basic header information: width, height.
+// This function will also validate the header, returning true on success,
+// false otherwise. '*width' and '*height' are only valid on successful return.
+// Pointers 'width' and 'height' can be passed NULL if deemed irrelevant.
+// Note: The following chunk sequences (before the raw VP8/VP8L data) are
+// considered valid by this function:
+// RIFF + VP8(L)
+// RIFF + VP8X + (optional chunks) + VP8(L)
+// ALPH + VP8 <-- Not a valid WebP format: only allowed for internal purpose.
+// VP8(L)     <-- Not a valid WebP format: only allowed for internal purpose.
+WEBP_NODISCARD WEBP_EXTERN int WebPGetInfo(
+const uint8_t* data, size_t data_size, int* width, int* height);
+// Decodes WebP images pointed to by 'data' and returns RGBA samples, along
+// with the dimensions in *width and *height. The ordering of samples in
+// memory is R, G, B, A, R, G, B, A... in scan order (endian-independent).
+// The returned pointer should be deleted calling WebPFree().
+// Returns NULL in case of error.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeRGBA(
+const uint8_t* data, size_t data_size, int* width, int* height);
+// Same as WebPDecodeRGBA, but returning A, R, G, B, A, R, G, B... ordered data.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeARGB(
+const uint8_t* data, size_t data_size, int* width, int* height);
+// Same as WebPDecodeRGBA, but returning B, G, R, A, B, G, R, A... ordered data.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeBGRA(
+const uint8_t* data, size_t data_size, int* width, int* height);
+// Same as WebPDecodeRGBA, but returning R, G, B, R, G, B... ordered data.
+// If the bitstream contains transparency, it is ignored.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeRGB(
+const uint8_t* data, size_t data_size, int* width, int* height);
+// Same as WebPDecodeRGB, but returning B, G, R, B, G, R... ordered data.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeBGR(
+const uint8_t* data, size_t data_size, int* width, int* height);
+// Decode WebP images pointed to by 'data' to Y'UV format(*). The pointer
+// returned is the Y samples buffer. Upon return, *u and *v will point to
+// the U and V chroma data. These U and V buffers need NOT be passed to
+// WebPFree(), unlike the returned Y luma one. The dimension of the U and V
+// planes are both (*width + 1) / 2 and (*height + 1) / 2.
+// Upon return, the Y buffer has a stride returned as '*stride', while U and V
+// have a common stride returned as '*uv_stride'.
+// 'width' and 'height' may be NULL, the other pointers must not be.
+// Returns NULL in case of error.
+// (*) Also named Y'CbCr. See: https://en.wikipedia.org/wiki/YCbCr
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeYUV(
+const uint8_t* data, size_t data_size, int* width, int* height,
+uint8_t** u, uint8_t** v, int* stride, int* uv_stride);
+// These five functions are variants of the above ones, that decode the image
+// directly into a pre-allocated buffer 'output_buffer'. The maximum storage
+// available in this buffer is indicated by 'output_buffer_size'. If this
+// storage is not sufficient (or an error occurred), NULL is returned.
+// Otherwise, output_buffer is returned, for convenience.
+// The parameter 'output_stride' specifies the distance (in bytes)
+// between scanlines. Hence, output_buffer_size is expected to be at least
+// output_stride x picture-height.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeRGBAInto(
+const uint8_t* data, size_t data_size,
+uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeARGBInto(
+const uint8_t* data, size_t data_size,
+uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeBGRAInto(
+const uint8_t* data, size_t data_size,
+uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+// RGB and BGR variants. Here too the transparency information, if present,
+// will be dropped and ignored.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeRGBInto(
+const uint8_t* data, size_t data_size,
+uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeBGRInto(
+const uint8_t* data, size_t data_size,
+uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+// WebPDecodeYUVInto() is a variant of WebPDecodeYUV() that operates directly
+// into pre-allocated luma/chroma plane buffers. This function requires the
+// strides to be passed: one for the luma plane and one for each of the
+// chroma ones. The size of each plane buffer is passed as 'luma_size',
+// 'u_size' and 'v_size' respectively.
+// Pointer to the luma plane ('*luma') is returned or NULL if an error occurred
+// during decoding (or because some buffers were found to be too small).
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPDecodeYUVInto(
+const uint8_t* data, size_t data_size,
+uint8_t* luma, size_t luma_size, int luma_stride,
+uint8_t* u, size_t u_size, int u_stride,
+uint8_t* v, size_t v_size, int v_stride);
+//------------------------------------------------------------------------------
+// Output colorspaces and buffer
+// Colorspaces
+// Note: the naming describes the byte-ordering of packed samples in memory.
+// For instance, MODE_BGRA relates to samples ordered as B,G,R,A,B,G,R,A,...
+// Non-capital names (e.g.:MODE_Argb) relates to pre-multiplied RGB channels.
+// RGBA-4444 and RGB-565 colorspaces are represented by following byte-order:
+// RGBA-4444: [r3 r2 r1 r0 g3 g2 g1 g0], [b3 b2 b1 b0 a3 a2 a1 a0], ...
+// RGB-565: [r4 r3 r2 r1 r0 g5 g4 g3], [g2 g1 g0 b4 b3 b2 b1 b0], ...
+// In the case WEBP_SWAP_16BITS_CSP is defined, the bytes are swapped for
+// these two modes:
+// RGBA-4444: [b3 b2 b1 b0 a3 a2 a1 a0], [r3 r2 r1 r0 g3 g2 g1 g0], ...
+// RGB-565: [g2 g1 g0 b4 b3 b2 b1 b0], [r4 r3 r2 r1 r0 g5 g4 g3], ...
+typedef enum WEBP_CSP_MODE {
+MODE_RGB = 0, MODE_RGBA = 1,
+MODE_BGR = 2, MODE_BGRA = 3,
+MODE_ARGB = 4, MODE_RGBA_4444 = 5,
+MODE_RGB_565 = 6,
+// RGB-premultiplied transparent modes (alpha value is preserved)
+MODE_rgbA = 7,
+MODE_bgrA = 8,
+MODE_Argb = 9,
+MODE_rgbA_4444 = 10,
+// YUV modes must come after RGB ones.
+MODE_YUV = 11, MODE_YUVA = 12,  // yuv 4:2:0
+MODE_LAST = 13
+} WEBP_CSP_MODE;
+// Some useful macros:
+static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
+return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
+mode == MODE_rgbA_4444);
+}
+static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
+return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
+mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
+WebPIsPremultipliedMode(mode));
+}
+static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
+return (mode < MODE_YUV);
+}
+//------------------------------------------------------------------------------
+// WebPDecBuffer: Generic structure for describing the output sample buffer.
+struct WebPRGBABuffer {    // view as RGBA
+uint8_t* rgba;    // pointer to RGBA samples
+int stride;       // stride in bytes from one scanline to the next.
+size_t size;      // total size of the *rgba buffer.
+};
+struct WebPYUVABuffer {              // view as YUVA
+uint8_t* y, *u, *v, *a;     // pointer to luma, chroma U/V, alpha samples
+int y_stride;               // luma stride
+int u_stride, v_stride;     // chroma strides
+int a_stride;               // alpha stride
+size_t y_size;              // luma plane size
+size_t u_size, v_size;      // chroma planes size
+size_t a_size;              // alpha-plane size
+};
+// Output buffer
+struct WebPDecBuffer {
+WEBP_CSP_MODE colorspace;  // Colorspace.
+int width, height;         // Dimensions.
+int is_external_memory;    // If non-zero, 'internal_memory' pointer is not
+// used. If value is '2' or more, the external
+// memory is considered 'slow' and multiple
+// read/write will be avoided.
+union {
+WebPRGBABuffer RGBA;
+WebPYUVABuffer YUVA;
+} u;                       // Nameless union of buffer parameters.
+uint32_t       pad[4];     // padding for later use
+uint8_t* private_memory;   // Internally allocated memory (only when
+// is_external_memory is 0). Should not be used
+// externally, but accessed via the buffer union.
+};
+// Internal, version-checked, entry point
+WEBP_NODISCARD WEBP_EXTERN int WebPInitDecBufferInternal(WebPDecBuffer*, int);
+// Initialize the structure as empty. Must be called before any other use.
+// Returns false in case of version mismatch
+WEBP_NODISCARD static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
+return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
+}
+// Free any memory associated with the buffer. Must always be called last.
+// Note: doesn't free the 'buffer' structure itself.
+WEBP_EXTERN void WebPFreeDecBuffer(WebPDecBuffer* buffer);
+//------------------------------------------------------------------------------
+// Enumeration of the status codes
+typedef enum WEBP_NODISCARD VP8StatusCode {
+VP8_STATUS_OK = 0,
+VP8_STATUS_OUT_OF_MEMORY,
+VP8_STATUS_INVALID_PARAM,
+VP8_STATUS_BITSTREAM_ERROR,
+VP8_STATUS_UNSUPPORTED_FEATURE,
+VP8_STATUS_SUSPENDED,
+VP8_STATUS_USER_ABORT,
+VP8_STATUS_NOT_ENOUGH_DATA
+} VP8StatusCode;
+//------------------------------------------------------------------------------
+// Incremental decoding
+//
+// This API allows streamlined decoding of partial data.
+// Picture can be incrementally decoded as data become available thanks to the
+// WebPIDecoder object. This object can be left in a SUSPENDED state if the
+// picture is only partially decoded, pending additional input.
+// Code example:
+/*
+WebPInitDecBuffer(&output_buffer);
+output_buffer.colorspace = mode;
+...
+WebPIDecoder* idec = WebPINewDecoder(&output_buffer);
+while (additional_data_is_available) {
+// ... (get additional data in some new_data[] buffer)
+status = WebPIAppend(idec, new_data, new_data_size);
+if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED) {
+break;    // an error occurred.
+}
+// The above call decodes the current available buffer.
+// Part of the image can now be refreshed by calling
+// WebPIDecGetRGB()/WebPIDecGetYUVA() etc.
+}
+WebPIDelete(idec);
+*/
+// Creates a new incremental decoder with the supplied buffer parameter.
+// This output_buffer can be passed NULL, in which case a default output buffer
+// is used (with MODE_RGB). Otherwise, an internal reference to 'output_buffer'
+// is kept, which means that the lifespan of 'output_buffer' must be larger than
+// that of the returned WebPIDecoder object.
+// The supplied 'output_buffer' content MUST NOT be changed between calls to
+// WebPIAppend() or WebPIUpdate() unless 'output_buffer.is_external_memory' is
+// not set to 0. In such a case, it is allowed to modify the pointers, size and
+// stride of output_buffer.u.RGBA or output_buffer.u.YUVA, provided they remain
+// within valid bounds.
+// All other fields of WebPDecBuffer MUST remain constant between calls.
+// Returns NULL if the allocation failed.
+WEBP_NODISCARD WEBP_EXTERN WebPIDecoder* WebPINewDecoder(
+WebPDecBuffer* output_buffer);
+// This function allocates and initializes an incremental-decoder object, which
+// will output the RGB/A samples specified by 'csp' into a preallocated
+// buffer 'output_buffer'. The size of this buffer is at least
+// 'output_buffer_size' and the stride (distance in bytes between two scanlines)
+// is specified by 'output_stride'.
+// Additionally, output_buffer can be passed NULL in which case the output
+// buffer will be allocated automatically when the decoding starts. The
+// colorspace 'csp' is taken into account for allocating this buffer. All other
+// parameters are ignored.
+// Returns NULL if the allocation failed, or if some parameters are invalid.
+WEBP_NODISCARD WEBP_EXTERN WebPIDecoder* WebPINewRGB(
+WEBP_CSP_MODE csp,
+uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+// This function allocates and initializes an incremental-decoder object, which
+// will output the raw luma/chroma samples into a preallocated planes if
+// supplied. The luma plane is specified by its pointer 'luma', its size
+// 'luma_size' and its stride 'luma_stride'. Similarly, the chroma-u plane
+// is specified by the 'u', 'u_size' and 'u_stride' parameters, and the chroma-v
+// plane by 'v' and 'v_size'. And same for the alpha-plane. The 'a' pointer
+// can be pass NULL in case one is not interested in the transparency plane.
+// Conversely, 'luma' can be passed NULL if no preallocated planes are supplied.
+// In this case, the output buffer will be automatically allocated (using
+// MODE_YUVA) when decoding starts. All parameters are then ignored.
+// Returns NULL if the allocation failed or if a parameter is invalid.
+WEBP_NODISCARD WEBP_EXTERN WebPIDecoder* WebPINewYUVA(
+uint8_t* luma, size_t luma_size, int luma_stride,
+uint8_t* u, size_t u_size, int u_stride,
+uint8_t* v, size_t v_size, int v_stride,
+uint8_t* a, size_t a_size, int a_stride);
+// Deprecated version of the above, without the alpha plane.
+// Kept for backward compatibility.
+WEBP_NODISCARD WEBP_EXTERN WebPIDecoder* WebPINewYUV(
+uint8_t* luma, size_t luma_size, int luma_stride,
+uint8_t* u, size_t u_size, int u_stride,
+uint8_t* v, size_t v_size, int v_stride);
+// Deletes the WebPIDecoder object and associated memory. Must always be called
+// if WebPINewDecoder, WebPINewRGB or WebPINewYUV succeeded.
+WEBP_EXTERN void WebPIDelete(WebPIDecoder* idec);
+// Copies and decodes the next available data. Returns VP8_STATUS_OK when
+// the image is successfully decoded. Returns VP8_STATUS_SUSPENDED when more
+// data is expected. Returns error in other cases.
+WEBP_EXTERN VP8StatusCode WebPIAppend(
+WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+// A variant of the above function to be used when data buffer contains
+// partial data from the beginning. In this case data buffer is not copied
+// to the internal memory.
+// Note that the value of the 'data' pointer can change between calls to
+// WebPIUpdate, for instance when the data buffer is resized to fit larger data.
+WEBP_EXTERN VP8StatusCode WebPIUpdate(
+WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+// Returns the RGB/A image decoded so far. Returns NULL if output params
+// are not initialized yet. The RGB/A output type corresponds to the colorspace
+// specified during call to WebPINewDecoder() or WebPINewRGB().
+// *last_y is the index of last decoded row in raster scan order. Some pointers
+// (*last_y, *width etc.) can be NULL if corresponding information is not
+// needed. The values in these pointers are only valid on successful (non-NULL)
+// return.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPIDecGetRGB(
+const WebPIDecoder* idec, int* last_y,
+int* width, int* height, int* stride);
+// Same as above function to get a YUVA image. Returns pointer to the luma
+// plane or NULL in case of error. If there is no alpha information
+// the alpha pointer '*a' will be returned NULL.
+WEBP_NODISCARD WEBP_EXTERN uint8_t* WebPIDecGetYUVA(
+const WebPIDecoder* idec, int* last_y,
+uint8_t** u, uint8_t** v, uint8_t** a,
+int* width, int* height, int* stride, int* uv_stride, int* a_stride);
+// Deprecated alpha-less version of WebPIDecGetYUVA(): it will ignore the
+// alpha information (if present). Kept for backward compatibility.
+WEBP_NODISCARD static WEBP_INLINE uint8_t* WebPIDecGetYUV(
+const WebPIDecoder* idec, int* last_y, uint8_t** u, uint8_t** v,
+int* width, int* height, int* stride, int* uv_stride) {
+return WebPIDecGetYUVA(idec, last_y, u, v, NULL, width, height,
+stride, uv_stride, NULL);
+}
+// Generic call to retrieve information about the displayable area.
+// If non NULL, the left/right/width/height pointers are filled with the visible
+// rectangular area so far.
+// Returns NULL in case the incremental decoder object is in an invalid state.
+// Otherwise returns the pointer to the internal representation. This structure
+// is read-only, tied to WebPIDecoder's lifespan and should not be modified.
+WEBP_NODISCARD WEBP_EXTERN const WebPDecBuffer* WebPIDecodedArea(
+const WebPIDecoder* idec, int* left, int* top, int* width, int* height);
+//------------------------------------------------------------------------------
+// Advanced decoding parametrization
+//
+//  Code sample for using the advanced decoding API
+/*
+// A) Init a configuration object
+WebPDecoderConfig config;
+CHECK(WebPInitDecoderConfig(&config));
+// B) optional: retrieve the bitstream's features.
+CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK);
+// C) Adjust 'config', if needed
+config.options.no_fancy_upsampling = 1;
+config.output.colorspace = MODE_BGRA;
+// etc.
+// Note that you can also make config.output point to an externally
+// supplied memory buffer, provided it's big enough to store the decoded
+// picture. Otherwise, config.output will just be used to allocate memory
+// and store the decoded picture.
+// D) Decode!
+CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
+// E) Decoded image is now in config.output (and config.output.u.RGBA)
+// F) Reclaim memory allocated in config's object. It's safe to call
+// this function even if the memory is external and wasn't allocated
+// by WebPDecode().
+WebPFreeDecBuffer(&config.output);
+*/
+// Features gathered from the bitstream
+struct WebPBitstreamFeatures {
+int width;          // Width in pixels, as read from the bitstream.
+int height;         // Height in pixels, as read from the bitstream.
+int has_alpha;      // True if the bitstream contains an alpha channel.
+int has_animation;  // True if the bitstream is an animation.
+int format;         // 0 = undefined (/mixed), 1 = lossy, 2 = lossless
+uint32_t pad[5];    // padding for later use
+};
+// Internal, version-checked, entry point
+WEBP_EXTERN VP8StatusCode WebPGetFeaturesInternal(
+const uint8_t*, size_t, WebPBitstreamFeatures*, int);
+// Retrieve features from the bitstream. The *features structure is filled
+// with information gathered from the bitstream.
+// Returns VP8_STATUS_OK when the features are successfully retrieved. Returns
+// VP8_STATUS_NOT_ENOUGH_DATA when more data is needed to retrieve the
+// features from headers. Returns error in other cases.
+// Note: The following chunk sequences (before the raw VP8/VP8L data) are
+// considered valid by this function:
+// RIFF + VP8(L)
+// RIFF + VP8X + (optional chunks) + VP8(L)
+// ALPH + VP8 <-- Not a valid WebP format: only allowed for internal purpose.
+// VP8(L)     <-- Not a valid WebP format: only allowed for internal purpose.
+static WEBP_INLINE VP8StatusCode WebPGetFeatures(
+const uint8_t* data, size_t data_size,
+WebPBitstreamFeatures* features) {
+return WebPGetFeaturesInternal(data, data_size, features,
+WEBP_DECODER_ABI_VERSION);
+}
+// Decoding options
+struct WebPDecoderOptions {
+int bypass_filtering;               // if true, skip the in-loop filtering
+int no_fancy_upsampling;            // if true, use faster pointwise upsampler
+int use_cropping;                   // if true, cropping is applied _first_
+int crop_left, crop_top;            // top-left position for cropping.
+// Will be snapped to even values.
+int crop_width, crop_height;        // dimension of the cropping area
+int use_scaling;                    // if true, scaling is applied _afterward_
+int scaled_width, scaled_height;    // final resolution
+int use_threads;                    // if true, use multi-threaded decoding
+int dithering_strength;             // dithering strength (0=Off, 100=full)
+int flip;                           // if true, flip output vertically
+int alpha_dithering_strength;       // alpha dithering strength in [0..100]
+uint32_t pad[5];                    // padding for later use
+};
+// Main object storing the configuration for advanced decoding.
+struct WebPDecoderConfig {
+WebPBitstreamFeatures input;  // Immutable bitstream features (optional)
+WebPDecBuffer output;         // Output buffer (can point to external mem)
+WebPDecoderOptions options;   // Decoding options
+};
+// Internal, version-checked, entry point
+WEBP_NODISCARD WEBP_EXTERN int WebPInitDecoderConfigInternal(WebPDecoderConfig*,
+int);
+// Initialize the configuration as empty. This function must always be
+// called first, unless WebPGetFeatures() is to be called.
+// Returns false in case of mismatched version.
+WEBP_NODISCARD static WEBP_INLINE int WebPInitDecoderConfig(
+WebPDecoderConfig* config) {
+return WebPInitDecoderConfigInternal(config, WEBP_DECODER_ABI_VERSION);
+}
+// Instantiate a new incremental decoder object with the requested
+// configuration. The bitstream can be passed using 'data' and 'data_size'
+// parameter, in which case the features will be parsed and stored into
+// config->input. Otherwise, 'data' can be NULL and no parsing will occur.
+// Note that 'config' can be NULL too, in which case a default configuration
+// is used. If 'config' is not NULL, it must outlive the WebPIDecoder object
+// as some references to its fields will be used. No internal copy of 'config'
+// is made.
+// The return WebPIDecoder object must always be deleted calling WebPIDelete().
+// Returns NULL in case of error (and config->status will then reflect
+// the error condition, if available).
+WEBP_NODISCARD WEBP_EXTERN WebPIDecoder* WebPIDecode(
+const uint8_t* data, size_t data_size, WebPDecoderConfig* config);
+// Non-incremental version. This version decodes the full data at once, taking
+// 'config' into account. Returns decoding status (which should be VP8_STATUS_OK
+// if the decoding was successful). Note that 'config' cannot be NULL.
+WEBP_EXTERN VP8StatusCode WebPDecode(const uint8_t* data, size_t data_size,
+WebPDecoderConfig* config);
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+#endif  // WEBP_WEBP_DECODE_H_

Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/webp/decode.h @ 69:33d812a61356