Download 3rdparty/libwebp/src/utils/bit_reader_utils.c from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 9 kB
-
https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/bit_reader_utils.c
- Command line
-
hf download hf://tgollogly/test/3rdparty/libwebp/src/utils/bit_reader_utils.c
-
curl -L -o bit_reader_utils.c https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/bit_reader_utils.c
9 kB
| // 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. | |
| // ----------------------------------------------------------------------------- | |
| // | |
| // Boolean decoder non-inlined methods | |
| // | |
| // Author: Skal (pascal.massimino@gmail.com) | |
| //------------------------------------------------------------------------------ | |
| // VP8BitReader | |
| void VP8BitReaderSetBuffer(VP8BitReader* const br, | |
| const uint8_t* const start, | |
| size_t size) { | |
| br->buf_ = start; | |
| br->buf_end_ = start + size; | |
| br->buf_max_ = | |
| (size >= sizeof(lbit_t)) ? start + size - sizeof(lbit_t) + 1 | |
| : start; | |
| } | |
| void VP8InitBitReader(VP8BitReader* const br, | |
| const uint8_t* const start, size_t size) { | |
| assert(br != NULL); | |
| assert(start != NULL); | |
| assert(size < (1u << 31)); // limit ensured by format and upstream checks | |
| br->range_ = 255 - 1; | |
| br->value_ = 0; | |
| br->bits_ = -8; // to load the very first 8bits | |
| br->eof_ = 0; | |
| VP8BitReaderSetBuffer(br, start, size); | |
| VP8LoadNewBytes(br); | |
| } | |
| void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) { | |
| if (br->buf_ != NULL) { | |
| br->buf_ += offset; | |
| br->buf_end_ += offset; | |
| br->buf_max_ += offset; | |
| } | |
| } | |
| const uint8_t kVP8Log2Range[128] = { | |
| 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, | |
| 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, | |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
| 0 | |
| }; | |
| // range = ((range - 1) << kVP8Log2Range[range]) + 1 | |
| const uint8_t kVP8NewRange[128] = { | |
| 127, 127, 191, 127, 159, 191, 223, 127, | |
| 143, 159, 175, 191, 207, 223, 239, 127, | |
| 135, 143, 151, 159, 167, 175, 183, 191, | |
| 199, 207, 215, 223, 231, 239, 247, 127, | |
| 131, 135, 139, 143, 147, 151, 155, 159, | |
| 163, 167, 171, 175, 179, 183, 187, 191, | |
| 195, 199, 203, 207, 211, 215, 219, 223, | |
| 227, 231, 235, 239, 243, 247, 251, 127, | |
| 129, 131, 133, 135, 137, 139, 141, 143, | |
| 145, 147, 149, 151, 153, 155, 157, 159, | |
| 161, 163, 165, 167, 169, 171, 173, 175, | |
| 177, 179, 181, 183, 185, 187, 189, 191, | |
| 193, 195, 197, 199, 201, 203, 205, 207, | |
| 209, 211, 213, 215, 217, 219, 221, 223, | |
| 225, 227, 229, 231, 233, 235, 237, 239, | |
| 241, 243, 245, 247, 249, 251, 253, 127 | |
| }; | |
| void VP8LoadFinalBytes(VP8BitReader* const br) { | |
| assert(br != NULL && br->buf_ != NULL); | |
| // Only read 8bits at a time | |
| if (br->buf_ < br->buf_end_) { | |
| br->bits_ += 8; | |
| br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8); | |
| } else if (!br->eof_) { | |
| br->value_ <<= 8; | |
| br->bits_ += 8; | |
| br->eof_ = 1; | |
| } else { | |
| br->bits_ = 0; // This is to avoid undefined behaviour with shifts. | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| // Higher-level calls | |
| uint32_t VP8GetValue(VP8BitReader* const br, int bits, const char label[]) { | |
| uint32_t v = 0; | |
| while (bits-- > 0) { | |
| v |= VP8GetBit(br, 0x80, label) << bits; | |
| } | |
| return v; | |
| } | |
| int32_t VP8GetSignedValue(VP8BitReader* const br, int bits, | |
| const char label[]) { | |
| const int value = VP8GetValue(br, bits, label); | |
| return VP8Get(br, label) ? -value : value; | |
| } | |
| //------------------------------------------------------------------------------ | |
| // VP8LBitReader | |
| static const uint32_t kBitMask[VP8L_MAX_NUM_BIT_READ + 1] = { | |
| 0, | |
| 0x000001, 0x000003, 0x000007, 0x00000f, | |
| 0x00001f, 0x00003f, 0x00007f, 0x0000ff, | |
| 0x0001ff, 0x0003ff, 0x0007ff, 0x000fff, | |
| 0x001fff, 0x003fff, 0x007fff, 0x00ffff, | |
| 0x01ffff, 0x03ffff, 0x07ffff, 0x0fffff, | |
| 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff | |
| }; | |
| void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start, | |
| size_t length) { | |
| size_t i; | |
| vp8l_val_t value = 0; | |
| assert(br != NULL); | |
| assert(start != NULL); | |
| assert(length < 0xfffffff8u); // can't happen with a RIFF chunk. | |
| br->len_ = length; | |
| br->val_ = 0; | |
| br->bit_pos_ = 0; | |
| br->eos_ = 0; | |
| if (length > sizeof(br->val_)) { | |
| length = sizeof(br->val_); | |
| } | |
| for (i = 0; i < length; ++i) { | |
| value |= (vp8l_val_t)start[i] << (8 * i); | |
| } | |
| br->val_ = value; | |
| br->pos_ = length; | |
| br->buf_ = start; | |
| } | |
| void VP8LBitReaderSetBuffer(VP8LBitReader* const br, | |
| const uint8_t* const buf, size_t len) { | |
| assert(br != NULL); | |
| assert(buf != NULL); | |
| assert(len < 0xfffffff8u); // can't happen with a RIFF chunk. | |
| br->buf_ = buf; | |
| br->len_ = len; | |
| // pos_ > len_ should be considered a param error. | |
| br->eos_ = (br->pos_ > br->len_) || VP8LIsEndOfStream(br); | |
| } | |
| static void VP8LSetEndOfStream(VP8LBitReader* const br) { | |
| br->eos_ = 1; | |
| br->bit_pos_ = 0; // To avoid undefined behaviour with shifts. | |
| } | |
| // If not at EOS, reload up to VP8L_LBITS byte-by-byte | |
| static void ShiftBytes(VP8LBitReader* const br) { | |
| while (br->bit_pos_ >= 8 && br->pos_ < br->len_) { | |
| br->val_ >>= 8; | |
| br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (VP8L_LBITS - 8); | |
| ++br->pos_; | |
| br->bit_pos_ -= 8; | |
| } | |
| if (VP8LIsEndOfStream(br)) { | |
| VP8LSetEndOfStream(br); | |
| } | |
| } | |
| void VP8LDoFillBitWindow(VP8LBitReader* const br) { | |
| assert(br->bit_pos_ >= VP8L_WBITS); | |
| if (br->pos_ + sizeof(br->val_) < br->len_) { | |
| br->val_ >>= VP8L_WBITS; | |
| br->bit_pos_ -= VP8L_WBITS; | |
| br->val_ |= (vp8l_val_t)HToLE32(WebPMemToUint32(br->buf_ + br->pos_)) << | |
| (VP8L_LBITS - VP8L_WBITS); | |
| br->pos_ += VP8L_LOG8_WBITS; | |
| return; | |
| } | |
| ShiftBytes(br); // Slow path. | |
| } | |
| uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) { | |
| assert(n_bits >= 0); | |
| // Flag an error if end_of_stream or n_bits is more than allowed limit. | |
| if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) { | |
| const uint32_t val = VP8LPrefetchBits(br) & kBitMask[n_bits]; | |
| const int new_bits = br->bit_pos_ + n_bits; | |
| br->bit_pos_ = new_bits; | |
| ShiftBytes(br); | |
| return val; | |
| } else { | |
| VP8LSetEndOfStream(br); | |
| return 0; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| // Bit-tracing tool | |
| static struct { | |
| const char* label; | |
| int size; | |
| int count; | |
| } kLabels[MAX_NUM_LABELS]; | |
| static int last_label = 0; | |
| static int last_pos = 0; | |
| static const uint8_t* buf_start = NULL; | |
| static int init_done = 0; | |
| static void PrintBitTraces(void) { | |
| int i; | |
| int scale = 1; | |
| int total = 0; | |
| const char* units = "bits"; | |
| scale = 8; | |
| units = "bytes"; | |
| for (i = 0; i < last_label; ++i) total += kLabels[i].size; | |
| if (total < 1) total = 1; // avoid rounding errors | |
| printf("=== Bit traces ===\n"); | |
| for (i = 0; i < last_label; ++i) { | |
| const int skip = 16 - (int)strlen(kLabels[i].label); | |
| const int value = (kLabels[i].size + scale - 1) / scale; | |
| assert(skip > 0); | |
| printf("%s \%*s: %6d %s \t[%5.2f%%] [count: %7d]\n", | |
| kLabels[i].label, skip, "", value, units, | |
| 100.f * kLabels[i].size / total, | |
| kLabels[i].count); | |
| } | |
| total = (total + scale - 1) / scale; | |
| printf("Total: %d %s\n", total, units); | |
| } | |
| void BitTrace(const struct VP8BitReader* const br, const char label[]) { | |
| int i, pos; | |
| if (!init_done) { | |
| memset(kLabels, 0, sizeof(kLabels)); | |
| atexit(PrintBitTraces); | |
| buf_start = br->buf_; | |
| init_done = 1; | |
| } | |
| pos = (int)(br->buf_ - buf_start) * 8 - br->bits_; | |
| // if there's a too large jump, we've changed partition -> reset counter | |
| if (abs(pos - last_pos) > 32) { | |
| buf_start = br->buf_; | |
| pos = 0; | |
| last_pos = 0; | |
| } | |
| if (br->range_ >= 0x7f) pos += kVP8Log2Range[br->range_ - 0x7f]; | |
| for (i = 0; i < last_label; ++i) { | |
| if (!strcmp(label, kLabels[i].label)) break; | |
| } | |
| if (i == MAX_NUM_LABELS) abort(); // overflow! | |
| kLabels[i].label = label; | |
| kLabels[i].size += pos - last_pos; | |
| kLabels[i].count += 1; | |
| if (i == last_label) ++last_label; | |
| last_pos = pos; | |
| } | |
| //------------------------------------------------------------------------------ | |