godot/thirdparty/libwebp/src/dec/vp8_dec.c

// 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 entry for the decoder
//
// Author: Skal ([email protected])

#include <stdlib.h>

#include "src/dec/alphai_dec.h"
#include "src/dec/vp8i_dec.h"
#include "src/dec/vp8li_dec.h"
#include "src/dec/webpi_dec.h"
#include "src/utils/bit_reader_inl_utils.h"
#include "src/utils/utils.h"

//------------------------------------------------------------------------------

int WebPGetDecoderVersion(void) { … }

//------------------------------------------------------------------------------
// Signature and pointer-to-function for GetCoeffs() variants below.

GetCoeffsFunc;
static volatile GetCoeffsFunc GetCoeffs = …;

static void InitGetCoeffs(void);

//------------------------------------------------------------------------------
// VP8Decoder

static void SetOk(VP8Decoder* const dec) { … }

int VP8InitIoInternal(VP8Io* const io, int version) { … }

VP8Decoder* VP8New(void) { … }

VP8StatusCode VP8Status(VP8Decoder* const dec) { … }

const char* VP8StatusMessage(VP8Decoder* const dec) { … }

void VP8Delete(VP8Decoder* const dec) { … }

int VP8SetError(VP8Decoder* const dec,
                VP8StatusCode error, const char* const msg) { … }

//------------------------------------------------------------------------------

int VP8CheckSignature(const uint8_t* const data, size_t data_size) { … }

int VP8GetInfo(const uint8_t* data, size_t data_size, size_t chunk_size,
               int* const width, int* const height) { … }

//------------------------------------------------------------------------------
// Header parsing

static void ResetSegmentHeader(VP8SegmentHeader* const hdr) { … }

// Paragraph 9.3
static int ParseSegmentHeader(VP8BitReader* br,
                              VP8SegmentHeader* hdr, VP8Proba* proba) { … }

// Paragraph 9.5
// If we don't have all the necessary data in 'buf', this function returns
// VP8_STATUS_SUSPENDED in incremental decoding, VP8_STATUS_NOT_ENOUGH_DATA
// otherwise.
// In incremental decoding, this case is not necessarily an error. Still, no
// bitreader is ever initialized to make it possible to read unavailable memory.
// If we don't even have the partitions' sizes, then VP8_STATUS_NOT_ENOUGH_DATA
// is returned, and this is an unrecoverable error.
// If the partitions were positioned ok, VP8_STATUS_OK is returned.
static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
                                     const uint8_t* buf, size_t size) { … }

// Paragraph 9.4
static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) { … }

// Topmost call
int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) { … }

//------------------------------------------------------------------------------
// Residual decoding (Paragraph 13.2 / 13.3)

static const uint8_t kCat3[] = …;
static const uint8_t kCat4[] = …;
static const uint8_t kCat5[] = …;
static const uint8_t kCat6[] = …;
static const uint8_t* const kCat3456[] = …;
static const uint8_t kZigzag[16] = …;

// See section 13-2: https://datatracker.ietf.org/doc/html/rfc6386#section-13.2
static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) { … }

// Returns the position of the last non-zero coeff plus one
static int GetCoeffsFast(VP8BitReader* const br,
                         const VP8BandProbas* const prob[],
                         int ctx, const quant_t dq, int n, int16_t* out) { … }

// This version of GetCoeffs() uses VP8GetBitAlt() which is an alternate version
// of VP8GetBitAlt() targeting specific platforms.
static int GetCoeffsAlt(VP8BitReader* const br,
                        const VP8BandProbas* const prob[],
                        int ctx, const quant_t dq, int n, int16_t* out) { … }

extern VP8CPUInfo VP8GetCPUInfo;

WEBP_DSP_INIT_FUNC(InitGetCoeffs) { … }

static WEBP_INLINE uint32_t NzCodeBits(uint32_t nz_coeffs, int nz, int dc_nz) { … }

static int ParseResiduals(VP8Decoder* const dec,
                          VP8MB* const mb, VP8BitReader* const token_br) { … }

//------------------------------------------------------------------------------
// Main loop

int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br) { … }

void VP8InitScanline(VP8Decoder* const dec) { … }

static int ParseFrame(VP8Decoder* const dec, VP8Io* io) { … }

// Main entry point
int VP8Decode(VP8Decoder* const dec, VP8Io* const io) { … }

void VP8Clear(VP8Decoder* const dec) { … }

//------------------------------------------------------------------------------