Download 3rdparty/libwebp/src/utils/bit_writer_utils.h from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 5.95 kB
-
https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/bit_writer_utils.h
- Command line
-
hf download hf://tgollogly/test/3rdparty/libwebp/src/utils/bit_writer_utils.h
-
curl -L -o bit_writer_utils.h https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/bit_writer_utils.h
5.95 kB
| // 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 (pascal.massimino@gmail.com) | |
| extern "C" { | |
| //------------------------------------------------------------------------------ | |
| // Bit-writing | |
| typedef struct VP8BitWriter VP8BitWriter; | |
| struct VP8BitWriter { | |
| int32_t range_; // range-1 | |
| int32_t value_; | |
| int run_; // number of outstanding bits | |
| int nb_bits_; // number of pending bits | |
| uint8_t* buf_; // internal buffer. Re-allocated regularly. Not owned. | |
| size_t pos_; | |
| size_t max_pos_; | |
| int error_; // true in case of error | |
| }; | |
| // Initialize the object. Allocates some initial memory based on expected_size. | |
| int VP8BitWriterInit(VP8BitWriter* const bw, size_t expected_size); | |
| // Finalize the bitstream coding. Returns a pointer to the internal buffer. | |
| uint8_t* VP8BitWriterFinish(VP8BitWriter* const bw); | |
| // Release any pending memory and zeroes the object. Not a mandatory call. | |
| // Only useful in case of error, when the internal buffer hasn't been grabbed! | |
| void VP8BitWriterWipeOut(VP8BitWriter* const bw); | |
| 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); | |
| // Appends some bytes to the internal buffer. Data is copied. | |
| int VP8BitWriterAppend(VP8BitWriter* const bw, | |
| const uint8_t* data, size_t size); | |
| // return approximate write position (in bits) | |
| static WEBP_INLINE uint64_t VP8BitWriterPos(const VP8BitWriter* const bw) { | |
| const uint64_t nb_bits = 8 + bw->nb_bits_; // bw->nb_bits_ is <= 0, note | |
| return (bw->pos_ + bw->run_) * 8 + nb_bits; | |
| } | |
| // Returns a pointer to the internal buffer. | |
| static WEBP_INLINE uint8_t* VP8BitWriterBuf(const VP8BitWriter* const bw) { | |
| return bw->buf_; | |
| } | |
| // Returns the size of the internal buffer. | |
| static WEBP_INLINE size_t VP8BitWriterSize(const VP8BitWriter* const bw) { | |
| return bw->pos_; | |
| } | |
| //------------------------------------------------------------------------------ | |
| // VP8LBitWriter | |
| typedef uint64_t vp8l_atype_t; // accumulator type | |
| typedef uint32_t vp8l_wtype_t; // writing type | |
| typedef uint32_t vp8l_atype_t; | |
| typedef uint16_t vp8l_wtype_t; | |
| typedef struct { | |
| vp8l_atype_t bits_; // bit accumulator | |
| int used_; // number of bits used in accumulator | |
| uint8_t* buf_; // start of buffer | |
| uint8_t* cur_; // current write position | |
| uint8_t* end_; // end of buffer | |
| // After all bits are written (VP8LBitWriterFinish()), the caller must observe | |
| // the state of error_. A value of 1 indicates that a memory allocation | |
| // failure has happened during bit writing. A value of 0 indicates successful | |
| // writing of bits. | |
| int error_; | |
| } VP8LBitWriter; | |
| static WEBP_INLINE size_t VP8LBitWriterNumBytes(const VP8LBitWriter* const bw) { | |
| return (bw->cur_ - bw->buf_) + ((bw->used_ + 7) >> 3); | |
| } | |
| // Returns false in case of memory allocation error. | |
| int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size); | |
| // Returns false in case of memory allocation error. | |
| int VP8LBitWriterClone(const VP8LBitWriter* const src, | |
| VP8LBitWriter* const dst); | |
| // Finalize the bitstream coding. Returns a pointer to the internal buffer. | |
| uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw); | |
| // Release any pending memory and zeroes the object. | |
| void VP8LBitWriterWipeOut(VP8LBitWriter* const bw); | |
| // Resets the cursor of the BitWriter bw to when it was like in bw_init. | |
| void VP8LBitWriterReset(const VP8LBitWriter* const bw_init, | |
| VP8LBitWriter* const bw); | |
| // Swaps the memory held by two BitWriters. | |
| void VP8LBitWriterSwap(VP8LBitWriter* const src, VP8LBitWriter* const dst); | |
| // Internal function for VP8LPutBits flushing 32 bits from the written state. | |
| void VP8LPutBitsFlushBits(VP8LBitWriter* const bw); | |
| // PutBits internal function used in the 16 bit vp8l_wtype_t case. | |
| void VP8LPutBitsInternal(VP8LBitWriter* const bw, uint32_t bits, int n_bits); | |
| // This function writes bits into bytes in increasing addresses (little endian), | |
| // and within a byte least-significant-bit first. | |
| // This function can write up to 32 bits in one go, but VP8LBitReader can only | |
| // read 24 bits max (VP8L_MAX_NUM_BIT_READ). | |
| // VP8LBitWriter's error_ flag is set in case of memory allocation error. | |
| static WEBP_INLINE void VP8LPutBits(VP8LBitWriter* const bw, | |
| uint32_t bits, int n_bits) { | |
| if (sizeof(vp8l_wtype_t) == 4) { | |
| if (n_bits > 0) { | |
| if (bw->used_ >= 32) { | |
| VP8LPutBitsFlushBits(bw); | |
| } | |
| bw->bits_ |= (vp8l_atype_t)bits << bw->used_; | |
| bw->used_ += n_bits; | |
| } | |
| } else { | |
| VP8LPutBitsInternal(bw, bits, n_bits); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| } // extern "C" | |