Download 3rdparty/libwebp/src/utils/bit_reader_inl_utils.h from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 5.89 kB
-
https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/bit_reader_inl_utils.h
- Command line
-
hf download hf://tgollogly/test/3rdparty/libwebp/src/utils/bit_reader_inl_utils.h
-
curl -L -o bit_reader_inl_utils.h https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/bit_reader_inl_utils.h
5.89 kB
| // Copyright 2014 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. | |
| // ----------------------------------------------------------------------------- | |
| // | |
| // Specific inlined methods for boolean decoder [VP8GetBit() ...] | |
| // This file should be included by the .c sources that actually need to call | |
| // these methods. | |
| // | |
| // Author: Skal (pascal.massimino@gmail.com) | |
| extern "C" { | |
| //------------------------------------------------------------------------------ | |
| // Derived type lbit_t = natural type for memory I/O | |
| typedef uint64_t lbit_t; | |
| typedef uint32_t lbit_t; | |
| typedef uint16_t lbit_t; | |
| typedef uint8_t lbit_t; | |
| extern const uint8_t kVP8Log2Range[128]; | |
| extern const uint8_t kVP8NewRange[128]; | |
| // special case for the tail byte-reading | |
| void VP8LoadFinalBytes(VP8BitReader* const br); | |
| //------------------------------------------------------------------------------ | |
| // Inlined critical functions | |
| // makes sure br->value_ has at least BITS bits worth of data | |
| static WEBP_UBSAN_IGNORE_UNDEF WEBP_INLINE | |
| void VP8LoadNewBytes(VP8BitReader* WEBP_RESTRICT const br) { | |
| assert(br != NULL && br->buf_ != NULL); | |
| // Read 'BITS' bits at a time if possible. | |
| if (br->buf_ < br->buf_max_) { | |
| // convert memory type to register type (with some zero'ing!) | |
| bit_t bits; | |
| // This is needed because of un-aligned read. | |
| lbit_t in_bits; | |
| lbit_t* p_buf_ = (lbit_t*)br->buf_; | |
| __asm__ volatile( | |
| ".set push \n\t" | |
| ".set at \n\t" | |
| ".set macro \n\t" | |
| "ulw %[in_bits], 0(%[p_buf_]) \n\t" | |
| ".set pop \n\t" | |
| : [in_bits]"=r"(in_bits) | |
| : [p_buf_]"r"(p_buf_) | |
| : "memory", "at" | |
| ); | |
| lbit_t in_bits; | |
| memcpy(&in_bits, br->buf_, sizeof(in_bits)); | |
| br->buf_ += BITS >> 3; | |
| bits = BSwap64(in_bits); | |
| bits >>= 64 - BITS; | |
| bits = BSwap32(in_bits); | |
| bits >>= (32 - BITS); | |
| bits = BSwap16(in_bits); | |
| bits = (bit_t)in_bits; | |
| bits = (bit_t)in_bits; | |
| if (BITS != 8 * sizeof(bit_t)) bits >>= (8 * sizeof(bit_t) - BITS); | |
| br->value_ = bits | (br->value_ << BITS); | |
| br->bits_ += BITS; | |
| } else { | |
| VP8LoadFinalBytes(br); // no need to be inlined | |
| } | |
| } | |
| // Read a bit with proba 'prob'. Speed-critical function! | |
| static WEBP_INLINE int VP8GetBit(VP8BitReader* WEBP_RESTRICT const br, | |
| int prob, const char label[]) { | |
| // Don't move this declaration! It makes a big speed difference to store | |
| // 'range' *before* calling VP8LoadNewBytes(), even if this function doesn't | |
| // alter br->range_ value. | |
| range_t range = br->range_; | |
| if (br->bits_ < 0) { | |
| VP8LoadNewBytes(br); | |
| } | |
| { | |
| const int pos = br->bits_; | |
| const range_t split = (range * prob) >> 8; | |
| const range_t value = (range_t)(br->value_ >> pos); | |
| const int bit = (value > split); | |
| if (bit) { | |
| range -= split; | |
| br->value_ -= (bit_t)(split + 1) << pos; | |
| } else { | |
| range = split + 1; | |
| } | |
| { | |
| const int shift = 7 ^ BitsLog2Floor(range); | |
| range <<= shift; | |
| br->bits_ -= shift; | |
| } | |
| br->range_ = range - 1; | |
| BT_TRACK(br); | |
| return bit; | |
| } | |
| } | |
| // simplified version of VP8GetBit() for prob=0x80 (note shift is always 1 here) | |
| static WEBP_UBSAN_IGNORE_UNSIGNED_OVERFLOW WEBP_INLINE | |
| int VP8GetSigned(VP8BitReader* WEBP_RESTRICT const br, int v, | |
| const char label[]) { | |
| if (br->bits_ < 0) { | |
| VP8LoadNewBytes(br); | |
| } | |
| { | |
| const int pos = br->bits_; | |
| const range_t split = br->range_ >> 1; | |
| const range_t value = (range_t)(br->value_ >> pos); | |
| const int32_t mask = (int32_t)(split - value) >> 31; // -1 or 0 | |
| br->bits_ -= 1; | |
| br->range_ += (range_t)mask; | |
| br->range_ |= 1; | |
| br->value_ -= (bit_t)((split + 1) & (uint32_t)mask) << pos; | |
| BT_TRACK(br); | |
| return (v ^ mask) - mask; | |
| } | |
| } | |
| static WEBP_INLINE int VP8GetBitAlt(VP8BitReader* WEBP_RESTRICT const br, | |
| int prob, const char label[]) { | |
| // Don't move this declaration! It makes a big speed difference to store | |
| // 'range' *before* calling VP8LoadNewBytes(), even if this function doesn't | |
| // alter br->range_ value. | |
| range_t range = br->range_; | |
| if (br->bits_ < 0) { | |
| VP8LoadNewBytes(br); | |
| } | |
| { | |
| const int pos = br->bits_; | |
| const range_t split = (range * prob) >> 8; | |
| const range_t value = (range_t)(br->value_ >> pos); | |
| int bit; // Don't use 'const int bit = (value > split);", it's slower. | |
| if (value > split) { | |
| range -= split + 1; | |
| br->value_ -= (bit_t)(split + 1) << pos; | |
| bit = 1; | |
| } else { | |
| range = split; | |
| bit = 0; | |
| } | |
| if (range <= (range_t)0x7e) { | |
| const int shift = kVP8Log2Range[range]; | |
| range = kVP8NewRange[range]; | |
| br->bits_ -= shift; | |
| } | |
| br->range_ = range; | |
| BT_TRACK(br); | |
| return bit; | |
| } | |
| } | |
| } // extern "C" | |