godot/thirdparty/libwebp/src/utils/bit_writer_utils.c

// Copyright 2011 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.
// -----------------------------------------------------------------------------
//
// Bit writing and boolean coder
//
// Author: Skal ([email protected])
//         Vikas Arora ([email protected])

#include <assert.h>
#include <string.h>   // for memcpy()
#include <stdlib.h>

#include "src/utils/bit_writer_utils.h"
#include "src/utils/endian_inl_utils.h"
#include "src/utils/utils.h"

//------------------------------------------------------------------------------
// VP8BitWriter

static int BitWriterResize(VP8BitWriter* const bw, size_t extra_size) { … }

static void Flush(VP8BitWriter* const bw) { … }

//------------------------------------------------------------------------------
// renormalization

static const uint8_t kNorm[128] = …;

// range = ((range + 1) << kVP8Log2Range[range]) - 1
static const uint8_t kNewRange[128] = …;

int VP8PutBit(VP8BitWriter* const bw, int bit, int prob) { … }

int VP8PutBitUniform(VP8BitWriter* const bw, int bit) { … }

void VP8PutBits(VP8BitWriter* const bw, uint32_t value, int nb_bits) { … }

void VP8PutSignedBits(VP8BitWriter* const bw, int value, int nb_bits) { … }

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

int VP8BitWriterInit(VP8BitWriter* const bw, size_t expected_size) { … }

uint8_t* VP8BitWriterFinish(VP8BitWriter* const bw) { … }

int VP8BitWriterAppend(VP8BitWriter* const bw,
                       const uint8_t* data, size_t size) { … }

void VP8BitWriterWipeOut(VP8BitWriter* const bw) { … }

//------------------------------------------------------------------------------
// VP8LBitWriter

// This is the minimum amount of size the memory buffer is guaranteed to grow
// when extra space is needed.
#define MIN_EXTRA_SIZE …

// Returns 1 on success.
static int VP8LBitWriterResize(VP8LBitWriter* const bw, size_t extra_size) { … }

int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size) { … }

int VP8LBitWriterClone(const VP8LBitWriter* const src,
                       VP8LBitWriter* const dst) { … }

void VP8LBitWriterWipeOut(VP8LBitWriter* const bw) { … }

void VP8LBitWriterReset(const VP8LBitWriter* const bw_init,
                        VP8LBitWriter* const bw) { … }

void VP8LBitWriterSwap(VP8LBitWriter* const src, VP8LBitWriter* const dst) { … }

void VP8LPutBitsFlushBits(VP8LBitWriter* const bw) { … }

void VP8LPutBitsInternal(VP8LBitWriter* const bw, uint32_t bits, int n_bits) { … }

uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw) { … }

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