LCOV - code coverage report
Current view: top level - usr/include/webp - decode.h (source / functions) Hit Total Coverage
Test: allegro_auto.info Lines: 2 2 100.0 %
Date: 2018-08-11 00:50:28 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       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:
     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.
     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.
     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.
     427             : static WEBP_INLINE VP8StatusCode WebPGetFeatures(
     428             :     const uint8_t* data, size_t data_size,
     429             :     WebPBitstreamFeatures* features) {
     430           6 :   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.
     465             : static WEBP_INLINE int WebPInitDecoderConfig(WebPDecoderConfig* config) {
     466           6 :   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_ */

Generated by: LCOV version 1.13