From 71119bb0496b1cb06c80778aaacdb4a8a5c4d287 Mon Sep 17 00:00:00 2001 From: eabdullin Date: Wed, 14 May 2025 15:26:48 +0000 Subject: [PATCH] import UBI brotli-1.1.0-6.el10 --- .brotli.metadata | 1 - .gitignore | 2 +- RHEL-32153-kBrotliBitMask-bounds.patch | 14 + SOURCES/rhbz1881156.patch | 2152 ------------------------ SPECS/brotli.spec | 202 --- brotli.spec | 300 ++++ sources | 1 + 7 files changed, 316 insertions(+), 2356 deletions(-) delete mode 100644 .brotli.metadata create mode 100644 RHEL-32153-kBrotliBitMask-bounds.patch delete mode 100644 SOURCES/rhbz1881156.patch delete mode 100644 SPECS/brotli.spec create mode 100644 brotli.spec create mode 100644 sources diff --git a/.brotli.metadata b/.brotli.metadata deleted file mode 100644 index 1639e56..0000000 --- a/.brotli.metadata +++ /dev/null @@ -1 +0,0 @@ -aa08a912bb560aa6def7b29d91ac6198a6b077f3 SOURCES/v1.0.6.tar.gz diff --git a/.gitignore b/.gitignore index 7a4e9bc..bed4f74 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1 @@ -SOURCES/v1.0.6.tar.gz +brotli-1.1.0.tar.gz diff --git a/RHEL-32153-kBrotliBitMask-bounds.patch b/RHEL-32153-kBrotliBitMask-bounds.patch new file mode 100644 index 0000000..e42fcee --- /dev/null +++ b/RHEL-32153-kBrotliBitMask-bounds.patch @@ -0,0 +1,14 @@ +--- brotli-1.1.0/c/dec/bit_reader.h.RHEL-32153-kBrotliBitMask-bounds 2023-08-29 13:00:29.000000000 +0200 ++++ brotli-1.1.0/c/dec/bit_reader.h 2024-09-11 13:38:21.608972528 +0200 +@@ -32,8 +32,10 @@ static BROTLI_INLINE brotli_reg_t BitMas + /* Masking with this expression turns to a single + "Unsigned Bit Field Extract" UBFX instruction on ARM. */ + return ~(~((brotli_reg_t)0) << n); +- } else { ++ } else if (n < 33) { + return kBrotliBitMask[n]; ++ } else { ++ return 0; + } + } + diff --git a/SOURCES/rhbz1881156.patch b/SOURCES/rhbz1881156.patch deleted file mode 100644 index faf58f4..0000000 --- a/SOURCES/rhbz1881156.patch +++ /dev/null @@ -1,2152 +0,0 @@ -From ce3b0936620b9abb2d6d21d3e608f37f3c7302d9 Mon Sep 17 00:00:00 2001 -From: rpm-build -Date: Thu, 1 Oct 2020 10:34:27 +0200 -Subject: [PATCH] rhbz1881156.patch - ---- - c/common/constants.c | 15 + - c/common/constants.h | 136 ++++++++ - c/common/platform.h | 8 +- - c/dec/bit_reader.c | 28 ++ - c/dec/bit_reader.h | 74 +++- - c/dec/decode.c | 695 ++++++++++++++++++++++---------------- - c/dec/huffman.h | 71 +++- - c/dec/prefix.h | 18 - - c/dec/state.c | 23 +- - c/dec/state.h | 181 ++++++++-- - c/enc/brotli_bit_stream.c | 21 +- - research/brotli_decoder.c | 1 + - scripts/sources.lst | 1 + - setup.py | 1 + - 14 files changed, 865 insertions(+), 408 deletions(-) - create mode 100644 c/common/constants.c - -diff --git a/c/common/constants.c b/c/common/constants.c -new file mode 100644 -index 0000000..6bad9f6 ---- /dev/null -+++ b/c/common/constants.c -@@ -0,0 +1,15 @@ -+/* Copyright 2013 Google Inc. All Rights Reserved. -+ -+ Distributed under MIT license. -+ See file LICENSE for detail or copy at https://opensource.org/licenses/MIT -+*/ -+ -+#include "./constants.h" -+ -+const BrotliPrefixCodeRange -+ _kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS] = { -+ {1, 2}, {5, 2}, {9, 2}, {13, 2}, {17, 3}, {25, 3}, -+ {33, 3}, {41, 3}, {49, 4}, {65, 4}, {81, 4}, {97, 4}, -+ {113, 5}, {145, 5}, {177, 5}, {209, 5}, {241, 6}, {305, 6}, -+ {369, 7}, {497, 8}, {753, 9}, {1265, 10}, {2289, 11}, {4337, 12}, -+ {8433, 13}, {16625, 24}}; -diff --git a/c/common/constants.h b/c/common/constants.h -index d1b88d1..e848195 100644 ---- a/c/common/constants.h -+++ b/c/common/constants.h -@@ -4,9 +4,18 @@ - See file LICENSE for detail or copy at https://opensource.org/licenses/MIT - */ - -+/** -+ * @file -+ * Common constants used in decoder and encoder API. -+ */ -+ - #ifndef BROTLI_COMMON_CONSTANTS_H_ - #define BROTLI_COMMON_CONSTANTS_H_ - -+#include "./platform.h" -+#include -+#include -+ - /* Specification: 7.3. Encoding of the context map */ - #define BROTLI_CONTEXT_MAP_MAX_RLE 16 - -@@ -29,12 +38,31 @@ - #define BROTLI_INITIAL_REPEATED_CODE_LENGTH 8 - - /* "Large Window Brotli" */ -+ -+/** -+ * The theoretical maximum number of distance bits specified for large window -+ * brotli, for 64-bit encoders and decoders. Even when in practice 32-bit -+ * encoders and decoders only support up to 30 max distance bits, the value is -+ * set to 62 because it affects the large window brotli file format. -+ * Specifically, it affects the encoding of simple huffman tree for distances, -+ * see Specification RFC 7932 chapter 3.4. -+ */ - #define BROTLI_LARGE_MAX_DISTANCE_BITS 62U - #define BROTLI_LARGE_MIN_WBITS 10 -+/** -+ * The maximum supported large brotli window bits by the encoder and decoder. -+ * Large window brotli allows up to 62 bits, however the current encoder and -+ * decoder, designed for 32-bit integers, only support up to 30 bits maximum. -+ */ - #define BROTLI_LARGE_MAX_WBITS 30 - - /* Specification: 4. Encoding of distances */ - #define BROTLI_NUM_DISTANCE_SHORT_CODES 16 -+/** -+ * Maximal number of "postfix" bits. -+ * -+ * Number of "postfix" bits is stored as 2 bits in meta-block header. -+ */ - #define BROTLI_MAX_NPOSTFIX 3 - #define BROTLI_MAX_NDIRECT 120 - #define BROTLI_MAX_DISTANCE_BITS 24U -@@ -45,9 +73,22 @@ - #define BROTLI_NUM_DISTANCE_SYMBOLS \ - BROTLI_DISTANCE_ALPHABET_SIZE( \ - BROTLI_MAX_NDIRECT, BROTLI_MAX_NPOSTFIX, BROTLI_LARGE_MAX_DISTANCE_BITS) -+ -+/* ((1 << 26) - 4) is the maximal distance that can be expressed in RFC 7932 -+ brotli stream using NPOSTFIX = 0 and NDIRECT = 0. With other NPOSTFIX and -+ NDIRECT values distances up to ((1 << 29) + 88) could be expressed. */ - #define BROTLI_MAX_DISTANCE 0x3FFFFFC -+ -+/* ((1 << 31) - 4) is the safe distance limit. Using this number as a limit -+ allows safe distance calculation without overflows, given the distance -+ alphabet size is limited to corresponding size -+ (see kLargeWindowDistanceCodeLimits). */ - #define BROTLI_MAX_ALLOWED_DISTANCE 0x7FFFFFFC - -+ -+/* Specification: 4. Encoding of Literal Insertion Lengths and Copy Lengths */ -+#define BROTLI_NUM_INS_COPY_CODES 24 -+ - /* 7.1. Context modes and context ID lookup for literals */ - /* "context IDs for literals are in the range of 0..63" */ - #define BROTLI_LITERAL_CONTEXT_BITS 6 -@@ -61,4 +102,99 @@ - #define BROTLI_WINDOW_GAP 16 - #define BROTLI_MAX_BACKWARD_LIMIT(W) (((size_t)1 << (W)) - BROTLI_WINDOW_GAP) - -+typedef struct BrotliDistanceCodeLimit { -+ uint32_t max_alphabet_size; -+ uint32_t max_distance; -+} BrotliDistanceCodeLimit; -+ -+/* This function calculates maximal size of distance alphabet, such that the -+ distances greater than the given values can not be represented. -+ -+ This limits are designed to support fast and safe 32-bit decoders. -+ "32-bit" means that signed integer values up to ((1 << 31) - 1) could be -+ safely expressed. -+ -+ Brotli distance alphabet symbols do not represent consecutive distance -+ ranges. Each distance alphabet symbol (excluding direct distances and short -+ codes), represent interleaved (for NPOSTFIX > 0) range of distances. -+ A "group" of consecutive (1 << NPOSTFIX) symbols represent non-interleaved -+ range. Two consecutive groups require the same amount of "extra bits". -+ -+ It is important that distance alphabet represents complete "groups". -+ To avoid complex logic on encoder side about interleaved ranges -+ it was decided to restrict both sides to complete distance code "groups". -+ */ -+BROTLI_UNUSED_FUNCTION BrotliDistanceCodeLimit BrotliCalculateDistanceCodeLimit( -+ uint32_t max_distance, uint32_t npostfix, uint32_t ndirect) { -+ BrotliDistanceCodeLimit result; -+ /* Marking this function as unused, because not all files -+ including "constants.h" use it -> compiler warns about that. */ -+ BROTLI_UNUSED(&BrotliCalculateDistanceCodeLimit); -+ if (max_distance <= ndirect) { -+ /* This case never happens / exists only for the sake of completeness. */ -+ result.max_alphabet_size = max_distance + BROTLI_NUM_DISTANCE_SHORT_CODES; -+ result.max_distance = max_distance; -+ return result; -+ } else { -+ /* The first prohibited value. */ -+ uint32_t forbidden_distance = max_distance + 1; -+ /* Subtract "directly" encoded region. */ -+ uint32_t offset = forbidden_distance - ndirect - 1; -+ uint32_t ndistbits = 0; -+ uint32_t tmp; -+ uint32_t half; -+ uint32_t group; -+ /* Postfix for the last dcode in the group. */ -+ uint32_t postfix = (1u << npostfix) - 1; -+ uint32_t extra; -+ uint32_t start; -+ /* Remove postfix and "head-start". */ -+ offset = (offset >> npostfix) + 4; -+ /* Calculate the number of distance bits. */ -+ tmp = offset / 2; -+ /* Poor-man's log2floor, to avoid extra dependencies. */ -+ while (tmp != 0) {ndistbits++; tmp = tmp >> 1;} -+ /* One bit is covered with subrange addressing ("half"). */ -+ ndistbits--; -+ /* Find subrange. */ -+ half = (offset >> ndistbits) & 1; -+ /* Calculate the "group" part of dcode. */ -+ group = ((ndistbits - 1) << 1) | half; -+ /* Calculated "group" covers the prohibited distance value. */ -+ if (group == 0) { -+ /* This case is added for correctness; does not occur for limit > 128. */ -+ result.max_alphabet_size = ndirect + BROTLI_NUM_DISTANCE_SHORT_CODES; -+ result.max_distance = ndirect; -+ return result; -+ } -+ /* Decrement "group", so it is the last permitted "group". */ -+ group--; -+ /* After group was decremented, ndistbits and half must be recalculated. */ -+ ndistbits = (group >> 1) + 1; -+ /* The last available distance in the subrange has all extra bits set. */ -+ extra = (1u << ndistbits) - 1; -+ /* Calculate region start. NB: ndistbits >= 1. */ -+ start = (1u << (ndistbits + 1)) - 4; -+ /* Move to subregion. */ -+ start += (group & 1) << ndistbits; -+ /* Calculate the alphabet size. */ -+ result.max_alphabet_size = ((group << npostfix) | postfix) + ndirect + -+ BROTLI_NUM_DISTANCE_SHORT_CODES + 1; -+ /* Calculate the maximal distance representable by alphabet. */ -+ result.max_distance = ((start + extra) << npostfix) + postfix + ndirect + 1; -+ return result; -+ } -+} -+ -+/* Represents the range of values belonging to a prefix code: -+ [offset, offset + 2^nbits) */ -+typedef struct { -+ uint16_t offset; -+ uint8_t nbits; -+} BrotliPrefixCodeRange; -+ -+/* "Soft-private", it is exported, but not "advertised" as API. */ -+BROTLI_COMMON_API extern const BrotliPrefixCodeRange -+ _kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS]; -+ - #endif /* BROTLI_COMMON_CONSTANTS_H_ */ -diff --git a/c/common/platform.h b/c/common/platform.h -index 0d84b19..94bf773 100755 ---- a/c/common/platform.h -+++ b/c/common/platform.h -@@ -197,6 +197,10 @@ OR: - - #endif /* ARMv8 */ - -+#if defined(__ARM_NEON__) || defined(__ARM_NEON) -+#define BROTLI_TARGET_NEON -+#endif -+ - #if defined(__i386) || defined(_M_IX86) - #define BROTLI_TARGET_X86 - #endif -@@ -456,20 +460,20 @@ static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void* p, uint64_t v) { - #endif - - #if defined(BROTLI_ENABLE_LOG) --#define BROTLI_DCHECK(x) assert(x) - #define BROTLI_LOG(x) printf x - #else --#define BROTLI_DCHECK(x) - #define BROTLI_LOG(x) - #endif - - #if defined(BROTLI_DEBUG) || defined(BROTLI_ENABLE_LOG) -+#define BROTLI_DCHECK(x) assert(x) - static BROTLI_INLINE void BrotliDump(const char* f, int l, const char* fn) { - fprintf(stderr, "%s:%d (%s)\n", f, l, fn); - fflush(stderr); - } - #define BROTLI_DUMP() BrotliDump(__FILE__, __LINE__, __FUNCTION__) - #else -+#define BROTLI_DCHECK(x) - #define BROTLI_DUMP() (void)(0) - #endif - -diff --git a/c/dec/bit_reader.c b/c/dec/bit_reader.c -index 722fd90..7f7b256 100644 ---- a/c/dec/bit_reader.c -+++ b/c/dec/bit_reader.c -@@ -15,6 +15,17 @@ - extern "C" { - #endif - -+const uint32_t kBrotliBitMask[33] = { 0x00000000, -+ 0x00000001, 0x00000003, 0x00000007, 0x0000000F, -+ 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF, -+ 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, -+ 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, -+ 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, -+ 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF, -+ 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, -+ 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF -+}; -+ - void BrotliInitBitReader(BrotliBitReader* const br) { - br->val_ = 0; - br->bit_pos_ = sizeof(br->val_) << 3; -@@ -43,6 +54,23 @@ BROTLI_BOOL BrotliWarmupBitReader(BrotliBitReader* const br) { - return BROTLI_TRUE; - } - -+BROTLI_BOOL BrotliSafeReadBits32Slow(BrotliBitReader* const br, -+ uint32_t n_bits, uint32_t* val) { -+ uint32_t low_val; -+ uint32_t high_val; -+ BrotliBitReaderState memento; -+ BROTLI_DCHECK(n_bits <= 32); -+ BROTLI_DCHECK(n_bits > 24); -+ BrotliBitReaderSaveState(br, &memento); -+ if (!BrotliSafeReadBits(br, 16, &low_val) || -+ !BrotliSafeReadBits(br, n_bits - 16, &high_val)) { -+ BrotliBitReaderRestoreState(br, &memento); -+ return BROTLI_FALSE; -+ } -+ *val = low_val | (high_val << 16); -+ return BROTLI_TRUE; -+} -+ - #if defined(__cplusplus) || defined(c_plusplus) - } /* extern "C" */ - #endif -diff --git a/c/dec/bit_reader.h b/c/dec/bit_reader.h -index c06e914..22bc060 100644 ---- a/c/dec/bit_reader.h -+++ b/c/dec/bit_reader.h -@@ -11,6 +11,7 @@ - - #include /* memcpy */ - -+#include "../common/constants.h" - #include "../common/platform.h" - #include - -@@ -20,16 +21,7 @@ extern "C" { - - #define BROTLI_SHORT_FILL_BIT_WINDOW_READ (sizeof(brotli_reg_t) >> 1) - --static const uint32_t kBitMask[33] = { 0x00000000, -- 0x00000001, 0x00000003, 0x00000007, 0x0000000F, -- 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF, -- 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, -- 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, -- 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, -- 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF, -- 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, -- 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF --}; -+BROTLI_INTERNAL extern const uint32_t kBrotliBitMask[33]; - - static BROTLI_INLINE uint32_t BitMask(uint32_t n) { - if (BROTLI_IS_CONSTANT(n) || BROTLI_HAS_UBFX) { -@@ -37,7 +29,7 @@ static BROTLI_INLINE uint32_t BitMask(uint32_t n) { - "Unsigned Bit Field Extract" UBFX instruction on ARM. */ - return ~((0xFFFFFFFFu) << n); - } else { -- return kBitMask[n]; -+ return kBrotliBitMask[n]; - } - } - -@@ -65,6 +57,12 @@ BROTLI_INTERNAL void BrotliInitBitReader(BrotliBitReader* const br); - reading. */ - BROTLI_INTERNAL BROTLI_BOOL BrotliWarmupBitReader(BrotliBitReader* const br); - -+/* Fallback for BrotliSafeReadBits32. Extracted as noninlined method to unburden -+ the main code-path. Never called for RFC brotli streams, required only for -+ "large-window" mode and other extensions. */ -+BROTLI_INTERNAL BROTLI_NOINLINE BROTLI_BOOL BrotliSafeReadBits32Slow( -+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val); -+ - static BROTLI_INLINE void BrotliBitReaderSaveState( - BrotliBitReader* const from, BrotliBitReaderState* to) { - to->val_ = from->val_; -@@ -87,8 +85,11 @@ static BROTLI_INLINE uint32_t BrotliGetAvailableBits( - } - - /* Returns amount of unread bytes the bit reader still has buffered from the -- BrotliInput, including whole bytes in br->val_. */ -+ BrotliInput, including whole bytes in br->val_. Result is capped with -+ maximal ring-buffer size (larger number won't be utilized anyway). */ - static BROTLI_INLINE size_t BrotliGetRemainingBytes(BrotliBitReader* br) { -+ static const size_t kCap = (size_t)1 << BROTLI_LARGE_MAX_WBITS; -+ if (br->avail_in > kCap) return kCap; - return br->avail_in + (BrotliGetAvailableBits(br) >> 3); - } - -@@ -237,15 +238,17 @@ static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) { - static BROTLI_INLINE void BrotliTakeBits( - BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) { - *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits); -- BROTLI_LOG(("[BrotliReadBits] %d %d %d val: %6x\n", -+ BROTLI_LOG(("[BrotliTakeBits] %d %d %d val: %6x\n", - (int)br->avail_in, (int)br->bit_pos_, (int)n_bits, (int)*val)); - BrotliDropBits(br, n_bits); - } - - /* Reads the specified number of bits from |br| and advances the bit pos. -- Assumes that there is enough input to perform BrotliFillBitWindow. */ --static BROTLI_INLINE uint32_t BrotliReadBits( -+ Assumes that there is enough input to perform BrotliFillBitWindow. -+ Up to 24 bits are allowed to be requested from this method. */ -+static BROTLI_INLINE uint32_t BrotliReadBits24( - BrotliBitReader* const br, uint32_t n_bits) { -+ BROTLI_DCHECK(n_bits <= 24); - if (BROTLI_64_BITS || (n_bits <= 16)) { - uint32_t val; - BrotliFillBitWindow(br, n_bits); -@@ -262,10 +265,32 @@ static BROTLI_INLINE uint32_t BrotliReadBits( - } - } - -+/* Same as BrotliReadBits24, but allows reading up to 32 bits. */ -+static BROTLI_INLINE uint32_t BrotliReadBits32( -+ BrotliBitReader* const br, uint32_t n_bits) { -+ BROTLI_DCHECK(n_bits <= 32); -+ if (BROTLI_64_BITS || (n_bits <= 16)) { -+ uint32_t val; -+ BrotliFillBitWindow(br, n_bits); -+ BrotliTakeBits(br, n_bits, &val); -+ return val; -+ } else { -+ uint32_t low_val; -+ uint32_t high_val; -+ BrotliFillBitWindow(br, 16); -+ BrotliTakeBits(br, 16, &low_val); -+ BrotliFillBitWindow(br, 16); -+ BrotliTakeBits(br, n_bits - 16, &high_val); -+ return low_val | (high_val << 16); -+ } -+} -+ - /* Tries to read the specified amount of bits. Returns BROTLI_FALSE, if there -- is not enough input. |n_bits| MUST be positive. */ -+ is not enough input. |n_bits| MUST be positive. -+ Up to 24 bits are allowed to be requested from this method. */ - static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits( - BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) { -+ BROTLI_DCHECK(n_bits <= 24); - while (BrotliGetAvailableBits(br) < n_bits) { - if (!BrotliPullByte(br)) { - return BROTLI_FALSE; -@@ -275,6 +300,23 @@ static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits( - return BROTLI_TRUE; - } - -+/* Same as BrotliSafeReadBits, but allows reading up to 32 bits. */ -+static BROTLI_INLINE BROTLI_BOOL BrotliSafeReadBits32( -+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) { -+ BROTLI_DCHECK(n_bits <= 32); -+ if (BROTLI_64_BITS || (n_bits <= 24)) { -+ while (BrotliGetAvailableBits(br) < n_bits) { -+ if (!BrotliPullByte(br)) { -+ return BROTLI_FALSE; -+ } -+ } -+ BrotliTakeBits(br, n_bits, val); -+ return BROTLI_TRUE; -+ } else { -+ return BrotliSafeReadBits32Slow(br, n_bits, val); -+ } -+} -+ - /* Advances the bit reader position to the next byte boundary and verifies - that any skipped bits are set to zero. */ - static BROTLI_INLINE BROTLI_BOOL BrotliJumpToByteBoundary(BrotliBitReader* br) { -diff --git a/c/dec/decode.c b/c/dec/decode.c -index 674b829..ae5a3d3 100644 ---- a/c/dec/decode.c -+++ b/c/dec/decode.c -@@ -6,10 +6,6 @@ - - #include - --#if defined(__ARM_NEON__) --#include --#endif -- - #include /* free, malloc */ - #include /* memcpy, memset */ - -@@ -24,6 +20,10 @@ - #include "./prefix.h" - #include "./state.h" - -+#if defined(BROTLI_TARGET_NEON) -+#include -+#endif -+ - #if defined(__cplusplus) || defined(c_plusplus) - extern "C" { - #endif -@@ -41,7 +41,8 @@ extern "C" { - - /* We need the slack region for the following reasons: - - doing up to two 16-byte copies for fast backward copying -- - inserting transformed dictionary word (5 prefix + 24 base + 8 suffix) */ -+ - inserting transformed dictionary word: -+ 5 prefix + 24 base + 8 suffix */ - static const uint32_t kRingBufferWriteAheadSlack = 42; - - static const uint8_t kCodeLengthCodeOrder[BROTLI_CODE_LENGTH_CODES] = { -@@ -167,7 +168,7 @@ static BrotliDecoderErrorCode DecodeWindowBits(BrotliDecoderState* s, - } - - static BROTLI_INLINE void memmove16(uint8_t* dst, uint8_t* src) { --#if defined(__ARM_NEON__) -+#if defined(BROTLI_TARGET_NEON) - vst1q_u8(dst, vld1q_u8(src)); - #else - uint32_t buffer[4]; -@@ -274,7 +275,8 @@ static BrotliDecoderErrorCode BROTLI_NOINLINE DecodeMetaBlockLength( - s->loop_counter = i; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } -- if (i + 1 == s->size_nibbles && s->size_nibbles > 4 && bits == 0) { -+ if (i + 1 == (int)s->size_nibbles && s->size_nibbles > 4 && -+ bits == 0) { - return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE); - } - s->meta_block_remaining_len |= (int)(bits << (i * 4)); -@@ -323,7 +325,8 @@ static BrotliDecoderErrorCode BROTLI_NOINLINE DecodeMetaBlockLength( - s->loop_counter = i; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } -- if (i + 1 == s->size_nibbles && s->size_nibbles > 1 && bits == 0) { -+ if (i + 1 == (int)s->size_nibbles && s->size_nibbles > 1 && -+ bits == 0) { - return BROTLI_FAILURE( - BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE); - } -@@ -347,15 +350,17 @@ static BrotliDecoderErrorCode BROTLI_NOINLINE DecodeMetaBlockLength( - static BROTLI_INLINE uint32_t DecodeSymbol(uint32_t bits, - const HuffmanCode* table, - BrotliBitReader* br) { -- table += bits & HUFFMAN_TABLE_MASK; -- if (table->bits > HUFFMAN_TABLE_BITS) { -- uint32_t nbits = table->bits - HUFFMAN_TABLE_BITS; -+ BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table); -+ BROTLI_HC_ADJUST_TABLE_INDEX(table, bits & HUFFMAN_TABLE_MASK); -+ if (BROTLI_HC_FAST_LOAD_BITS(table) > HUFFMAN_TABLE_BITS) { -+ uint32_t nbits = BROTLI_HC_FAST_LOAD_BITS(table) - HUFFMAN_TABLE_BITS; - BrotliDropBits(br, HUFFMAN_TABLE_BITS); -- table += table->value; -- table += (bits >> HUFFMAN_TABLE_BITS) & BitMask(nbits); -+ BROTLI_HC_ADJUST_TABLE_INDEX(table, -+ BROTLI_HC_FAST_LOAD_VALUE(table) + -+ ((bits >> HUFFMAN_TABLE_BITS) & BitMask(nbits))); - } -- BrotliDropBits(br, table->bits); -- return table->value; -+ BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(table)); -+ return BROTLI_HC_FAST_LOAD_VALUE(table); - } - - /* Reads and decodes the next Huffman code from bit-stream. -@@ -371,19 +376,20 @@ static BROTLI_NOINLINE BROTLI_BOOL SafeDecodeSymbol( - const HuffmanCode* table, BrotliBitReader* br, uint32_t* result) { - uint32_t val; - uint32_t available_bits = BrotliGetAvailableBits(br); -+ BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table); - if (available_bits == 0) { -- if (table->bits == 0) { -- *result = table->value; -+ if (BROTLI_HC_FAST_LOAD_BITS(table) == 0) { -+ *result = BROTLI_HC_FAST_LOAD_VALUE(table); - return BROTLI_TRUE; - } - return BROTLI_FALSE; /* No valid bits at all. */ - } - val = (uint32_t)BrotliGetBitsUnmasked(br); -- table += val & HUFFMAN_TABLE_MASK; -- if (table->bits <= HUFFMAN_TABLE_BITS) { -- if (table->bits <= available_bits) { -- BrotliDropBits(br, table->bits); -- *result = table->value; -+ BROTLI_HC_ADJUST_TABLE_INDEX(table, val & HUFFMAN_TABLE_MASK); -+ if (BROTLI_HC_FAST_LOAD_BITS(table) <= HUFFMAN_TABLE_BITS) { -+ if (BROTLI_HC_FAST_LOAD_BITS(table) <= available_bits) { -+ BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(table)); -+ *result = BROTLI_HC_FAST_LOAD_VALUE(table); - return BROTLI_TRUE; - } else { - return BROTLI_FALSE; /* Not enough bits for the first level. */ -@@ -394,15 +400,15 @@ static BROTLI_NOINLINE BROTLI_BOOL SafeDecodeSymbol( - } - - /* Speculatively drop HUFFMAN_TABLE_BITS. */ -- val = (val & BitMask(table->bits)) >> HUFFMAN_TABLE_BITS; -+ val = (val & BitMask(BROTLI_HC_FAST_LOAD_BITS(table))) >> HUFFMAN_TABLE_BITS; - available_bits -= HUFFMAN_TABLE_BITS; -- table += table->value + val; -- if (available_bits < table->bits) { -+ BROTLI_HC_ADJUST_TABLE_INDEX(table, BROTLI_HC_FAST_LOAD_VALUE(table) + val); -+ if (available_bits < BROTLI_HC_FAST_LOAD_BITS(table)) { - return BROTLI_FALSE; /* Not enough bits for the second level. */ - } - -- BrotliDropBits(br, HUFFMAN_TABLE_BITS + table->bits); -- *result = table->value; -+ BrotliDropBits(br, HUFFMAN_TABLE_BITS + BROTLI_HC_FAST_LOAD_BITS(table)); -+ *result = BROTLI_HC_FAST_LOAD_VALUE(table); - return BROTLI_TRUE; - } - -@@ -425,9 +431,10 @@ static BROTLI_INLINE void PreloadSymbol(int safe, - if (safe) { - return; - } -- table += BrotliGetBits(br, HUFFMAN_TABLE_BITS); -- *bits = table->bits; -- *value = table->value; -+ BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table); -+ BROTLI_HC_ADJUST_TABLE_INDEX(table, BrotliGetBits(br, HUFFMAN_TABLE_BITS)); -+ *bits = BROTLI_HC_FAST_LOAD_BITS(table); -+ *value = BROTLI_HC_FAST_LOAD_VALUE(table); - } - - /* Decodes the next Huffman code using data prepared by PreloadSymbol. -@@ -441,10 +448,11 @@ static BROTLI_INLINE uint32_t ReadPreloadedSymbol(const HuffmanCode* table, - uint32_t val = BrotliGet16BitsUnmasked(br); - const HuffmanCode* ext = table + (val & HUFFMAN_TABLE_MASK) + *value; - uint32_t mask = BitMask((*bits - HUFFMAN_TABLE_BITS)); -+ BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(ext); - BrotliDropBits(br, HUFFMAN_TABLE_BITS); -- ext += (val >> HUFFMAN_TABLE_BITS) & mask; -- BrotliDropBits(br, ext->bits); -- result = ext->value; -+ BROTLI_HC_ADJUST_TABLE_INDEX(ext, (val >> HUFFMAN_TABLE_BITS) & mask); -+ BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(ext)); -+ result = BROTLI_HC_FAST_LOAD_VALUE(ext); - } else { - BrotliDropBits(br, *bits); - } -@@ -465,32 +473,34 @@ static BROTLI_INLINE uint32_t Log2Floor(uint32_t x) { - Totally 1..4 symbols are read, 1..11 bits each. - The list of symbols MUST NOT contain duplicates. */ - static BrotliDecoderErrorCode ReadSimpleHuffmanSymbols( -- uint32_t alphabet_size, uint32_t max_symbol, BrotliDecoderState* s) { -+ uint32_t alphabet_size_max, uint32_t alphabet_size_limit, -+ BrotliDecoderState* s) { - /* max_bits == 1..11; symbol == 0..3; 1..44 bits will be read. */ - BrotliBitReader* br = &s->br; -- uint32_t max_bits = Log2Floor(alphabet_size - 1); -- uint32_t i = s->sub_loop_counter; -- uint32_t num_symbols = s->symbol; -+ BrotliMetablockHeaderArena* h = &s->arena.header; -+ uint32_t max_bits = Log2Floor(alphabet_size_max - 1); -+ uint32_t i = h->sub_loop_counter; -+ uint32_t num_symbols = h->symbol; - while (i <= num_symbols) { - uint32_t v; - if (BROTLI_PREDICT_FALSE(!BrotliSafeReadBits(br, max_bits, &v))) { -- s->sub_loop_counter = i; -- s->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_READ; -+ h->sub_loop_counter = i; -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_READ; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } -- if (v >= max_symbol) { -+ if (v >= alphabet_size_limit) { - return - BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET); - } -- s->symbols_lists_array[i] = (uint16_t)v; -- BROTLI_LOG_UINT(s->symbols_lists_array[i]); -+ h->symbols_lists_array[i] = (uint16_t)v; -+ BROTLI_LOG_UINT(h->symbols_lists_array[i]); - ++i; - } - - for (i = 0; i < num_symbols; ++i) { - uint32_t k = i + 1; - for (; k <= num_symbols; ++k) { -- if (s->symbols_lists_array[i] == s->symbols_lists_array[k]) { -+ if (h->symbols_lists_array[i] == h->symbols_lists_array[k]) { - return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME); - } - } -@@ -583,33 +593,35 @@ static BROTLI_INLINE void ProcessRepeatedCodeLength(uint32_t code_len, - static BrotliDecoderErrorCode ReadSymbolCodeLengths( - uint32_t alphabet_size, BrotliDecoderState* s) { - BrotliBitReader* br = &s->br; -- uint32_t symbol = s->symbol; -- uint32_t repeat = s->repeat; -- uint32_t space = s->space; -- uint32_t prev_code_len = s->prev_code_len; -- uint32_t repeat_code_len = s->repeat_code_len; -- uint16_t* symbol_lists = s->symbol_lists; -- uint16_t* code_length_histo = s->code_length_histo; -- int* next_symbol = s->next_symbol; -+ BrotliMetablockHeaderArena* h = &s->arena.header; -+ uint32_t symbol = h->symbol; -+ uint32_t repeat = h->repeat; -+ uint32_t space = h->space; -+ uint32_t prev_code_len = h->prev_code_len; -+ uint32_t repeat_code_len = h->repeat_code_len; -+ uint16_t* symbol_lists = h->symbol_lists; -+ uint16_t* code_length_histo = h->code_length_histo; -+ int* next_symbol = h->next_symbol; - if (!BrotliWarmupBitReader(br)) { - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } - while (symbol < alphabet_size && space > 0) { -- const HuffmanCode* p = s->table; -+ const HuffmanCode* p = h->table; - uint32_t code_len; -+ BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(p); - if (!BrotliCheckInputAmount(br, BROTLI_SHORT_FILL_BIT_WINDOW_READ)) { -- s->symbol = symbol; -- s->repeat = repeat; -- s->prev_code_len = prev_code_len; -- s->repeat_code_len = repeat_code_len; -- s->space = space; -+ h->symbol = symbol; -+ h->repeat = repeat; -+ h->prev_code_len = prev_code_len; -+ h->repeat_code_len = repeat_code_len; -+ h->space = space; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } - BrotliFillBitWindow16(br); -- p += BrotliGetBitsUnmasked(br) & -- BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH); -- BrotliDropBits(br, p->bits); /* Use 1..5 bits. */ -- code_len = p->value; /* code_len == 0..17 */ -+ BROTLI_HC_ADJUST_TABLE_INDEX(p, BrotliGetBitsUnmasked(br) & -+ BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH)); -+ BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(p)); /* Use 1..5 bits. */ -+ code_len = BROTLI_HC_FAST_LOAD_VALUE(p); /* code_len == 0..17 */ - if (code_len < BROTLI_REPEAT_PREVIOUS_CODE_LENGTH) { - ProcessSingleCodeLength(code_len, &symbol, &repeat, &space, - &prev_code_len, symbol_lists, code_length_histo, next_symbol); -@@ -624,48 +636,52 @@ static BrotliDecoderErrorCode ReadSymbolCodeLengths( - symbol_lists, code_length_histo, next_symbol); - } - } -- s->space = space; -+ h->space = space; - return BROTLI_DECODER_SUCCESS; - } - - static BrotliDecoderErrorCode SafeReadSymbolCodeLengths( - uint32_t alphabet_size, BrotliDecoderState* s) { - BrotliBitReader* br = &s->br; -+ BrotliMetablockHeaderArena* h = &s->arena.header; - BROTLI_BOOL get_byte = BROTLI_FALSE; -- while (s->symbol < alphabet_size && s->space > 0) { -- const HuffmanCode* p = s->table; -+ while (h->symbol < alphabet_size && h->space > 0) { -+ const HuffmanCode* p = h->table; - uint32_t code_len; - uint32_t available_bits; - uint32_t bits = 0; -+ BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(p); - if (get_byte && !BrotliPullByte(br)) return BROTLI_DECODER_NEEDS_MORE_INPUT; - get_byte = BROTLI_FALSE; - available_bits = BrotliGetAvailableBits(br); - if (available_bits != 0) { - bits = (uint32_t)BrotliGetBitsUnmasked(br); - } -- p += bits & BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH); -- if (p->bits > available_bits) { -+ BROTLI_HC_ADJUST_TABLE_INDEX(p, -+ bits & BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH)); -+ if (BROTLI_HC_FAST_LOAD_BITS(p) > available_bits) { - get_byte = BROTLI_TRUE; - continue; - } -- code_len = p->value; /* code_len == 0..17 */ -+ code_len = BROTLI_HC_FAST_LOAD_VALUE(p); /* code_len == 0..17 */ - if (code_len < BROTLI_REPEAT_PREVIOUS_CODE_LENGTH) { -- BrotliDropBits(br, p->bits); -- ProcessSingleCodeLength(code_len, &s->symbol, &s->repeat, &s->space, -- &s->prev_code_len, s->symbol_lists, s->code_length_histo, -- s->next_symbol); -+ BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(p)); -+ ProcessSingleCodeLength(code_len, &h->symbol, &h->repeat, &h->space, -+ &h->prev_code_len, h->symbol_lists, h->code_length_histo, -+ h->next_symbol); - } else { /* code_len == 16..17, extra_bits == 2..3 */ - uint32_t extra_bits = code_len - 14U; -- uint32_t repeat_delta = (bits >> p->bits) & BitMask(extra_bits); -- if (available_bits < p->bits + extra_bits) { -+ uint32_t repeat_delta = (bits >> BROTLI_HC_FAST_LOAD_BITS(p)) & -+ BitMask(extra_bits); -+ if (available_bits < BROTLI_HC_FAST_LOAD_BITS(p) + extra_bits) { - get_byte = BROTLI_TRUE; - continue; - } -- BrotliDropBits(br, p->bits + extra_bits); -+ BrotliDropBits(br, BROTLI_HC_FAST_LOAD_BITS(p) + extra_bits); - ProcessRepeatedCodeLength(code_len, repeat_delta, alphabet_size, -- &s->symbol, &s->repeat, &s->space, &s->prev_code_len, -- &s->repeat_code_len, s->symbol_lists, s->code_length_histo, -- s->next_symbol); -+ &h->symbol, &h->repeat, &h->space, &h->prev_code_len, -+ &h->repeat_code_len, h->symbol_lists, h->code_length_histo, -+ h->next_symbol); - } - } - return BROTLI_DECODER_SUCCESS; -@@ -675,9 +691,10 @@ static BrotliDecoderErrorCode SafeReadSymbolCodeLengths( - Each code is 2..4 bits long. In total 30..72 bits are used. */ - static BrotliDecoderErrorCode ReadCodeLengthCodeLengths(BrotliDecoderState* s) { - BrotliBitReader* br = &s->br; -- uint32_t num_codes = s->repeat; -- unsigned space = s->space; -- uint32_t i = s->sub_loop_counter; -+ BrotliMetablockHeaderArena* h = &s->arena.header; -+ uint32_t num_codes = h->repeat; -+ unsigned space = h->space; -+ uint32_t i = h->sub_loop_counter; - for (; i < BROTLI_CODE_LENGTH_CODES; ++i) { - const uint8_t code_len_idx = kCodeLengthCodeOrder[i]; - uint32_t ix; -@@ -690,21 +707,21 @@ static BrotliDecoderErrorCode ReadCodeLengthCodeLengths(BrotliDecoderState* s) { - ix = 0; - } - if (kCodeLengthPrefixLength[ix] > available_bits) { -- s->sub_loop_counter = i; -- s->repeat = num_codes; -- s->space = space; -- s->substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX; -+ h->sub_loop_counter = i; -+ h->repeat = num_codes; -+ h->space = space; -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } - } - v = kCodeLengthPrefixValue[ix]; - BrotliDropBits(br, kCodeLengthPrefixLength[ix]); -- s->code_length_code_lengths[code_len_idx] = (uint8_t)v; -- BROTLI_LOG_ARRAY_INDEX(s->code_length_code_lengths, code_len_idx); -+ h->code_length_code_lengths[code_len_idx] = (uint8_t)v; -+ BROTLI_LOG_ARRAY_INDEX(h->code_length_code_lengths, code_len_idx); - if (v != 0) { - space = space - (32U >> v); - ++num_codes; -- ++s->code_length_histo[v]; -+ ++h->code_length_histo[v]; - if (space - 1U >= 32U) { - /* space is 0 or wrapped around. */ - break; -@@ -728,49 +745,48 @@ static BrotliDecoderErrorCode ReadCodeLengthCodeLengths(BrotliDecoderState* s) { - encoded with predefined entropy code. 32 - 74 bits are used. - B.2) Decoded table is used to decode code lengths of symbols in resulting - Huffman table. In worst case 3520 bits are read. */ --static BrotliDecoderErrorCode ReadHuffmanCode(uint32_t alphabet_size, -- uint32_t max_symbol, -+static BrotliDecoderErrorCode ReadHuffmanCode(uint32_t alphabet_size_max, -+ uint32_t alphabet_size_limit, - HuffmanCode* table, - uint32_t* opt_table_size, - BrotliDecoderState* s) { - BrotliBitReader* br = &s->br; -- /* Unnecessary masking, but might be good for safety. */ -- alphabet_size &= 0x7FF; -+ BrotliMetablockHeaderArena* h = &s->arena.header; - /* State machine. */ - for (;;) { -- switch (s->substate_huffman) { -+ switch (h->substate_huffman) { - case BROTLI_STATE_HUFFMAN_NONE: -- if (!BrotliSafeReadBits(br, 2, &s->sub_loop_counter)) { -+ if (!BrotliSafeReadBits(br, 2, &h->sub_loop_counter)) { - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } -- BROTLI_LOG_UINT(s->sub_loop_counter); -+ BROTLI_LOG_UINT(h->sub_loop_counter); - /* The value is used as follows: - 1 for simple code; - 0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */ -- if (s->sub_loop_counter != 1) { -- s->space = 32; -- s->repeat = 0; /* num_codes */ -- memset(&s->code_length_histo[0], 0, sizeof(s->code_length_histo[0]) * -+ if (h->sub_loop_counter != 1) { -+ h->space = 32; -+ h->repeat = 0; /* num_codes */ -+ memset(&h->code_length_histo[0], 0, sizeof(h->code_length_histo[0]) * - (BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1)); -- memset(&s->code_length_code_lengths[0], 0, -- sizeof(s->code_length_code_lengths)); -- s->substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX; -+ memset(&h->code_length_code_lengths[0], 0, -+ sizeof(h->code_length_code_lengths)); -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX; - continue; - } - /* Fall through. */ - - case BROTLI_STATE_HUFFMAN_SIMPLE_SIZE: - /* Read symbols, codes & code lengths directly. */ -- if (!BrotliSafeReadBits(br, 2, &s->symbol)) { /* num_symbols */ -- s->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_SIZE; -+ if (!BrotliSafeReadBits(br, 2, &h->symbol)) { /* num_symbols */ -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_SIZE; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } -- s->sub_loop_counter = 0; -+ h->sub_loop_counter = 0; - /* Fall through. */ - - case BROTLI_STATE_HUFFMAN_SIMPLE_READ: { - BrotliDecoderErrorCode result = -- ReadSimpleHuffmanSymbols(alphabet_size, max_symbol, s); -+ ReadSimpleHuffmanSymbols(alphabet_size_max, alphabet_size_limit, s); - if (result != BROTLI_DECODER_SUCCESS) { - return result; - } -@@ -779,21 +795,21 @@ static BrotliDecoderErrorCode ReadHuffmanCode(uint32_t alphabet_size, - - case BROTLI_STATE_HUFFMAN_SIMPLE_BUILD: { - uint32_t table_size; -- if (s->symbol == 3) { -+ if (h->symbol == 3) { - uint32_t bits; - if (!BrotliSafeReadBits(br, 1, &bits)) { -- s->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_BUILD; -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_BUILD; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } -- s->symbol += bits; -+ h->symbol += bits; - } -- BROTLI_LOG_UINT(s->symbol); -+ BROTLI_LOG_UINT(h->symbol); - table_size = BrotliBuildSimpleHuffmanTable( -- table, HUFFMAN_TABLE_BITS, s->symbols_lists_array, s->symbol); -+ table, HUFFMAN_TABLE_BITS, h->symbols_lists_array, h->symbol); - if (opt_table_size) { - *opt_table_size = table_size; - } -- s->substate_huffman = BROTLI_STATE_HUFFMAN_NONE; -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_NONE; - return BROTLI_DECODER_SUCCESS; - } - -@@ -804,44 +820,45 @@ static BrotliDecoderErrorCode ReadHuffmanCode(uint32_t alphabet_size, - if (result != BROTLI_DECODER_SUCCESS) { - return result; - } -- BrotliBuildCodeLengthsHuffmanTable(s->table, -- s->code_length_code_lengths, -- s->code_length_histo); -- memset(&s->code_length_histo[0], 0, sizeof(s->code_length_histo)); -+ BrotliBuildCodeLengthsHuffmanTable(h->table, -+ h->code_length_code_lengths, -+ h->code_length_histo); -+ memset(&h->code_length_histo[0], 0, sizeof(h->code_length_histo)); - for (i = 0; i <= BROTLI_HUFFMAN_MAX_CODE_LENGTH; ++i) { -- s->next_symbol[i] = (int)i - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1); -- s->symbol_lists[s->next_symbol[i]] = 0xFFFF; -+ h->next_symbol[i] = (int)i - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1); -+ h->symbol_lists[h->next_symbol[i]] = 0xFFFF; - } - -- s->symbol = 0; -- s->prev_code_len = BROTLI_INITIAL_REPEATED_CODE_LENGTH; -- s->repeat = 0; -- s->repeat_code_len = 0; -- s->space = 32768; -- s->substate_huffman = BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS; -+ h->symbol = 0; -+ h->prev_code_len = BROTLI_INITIAL_REPEATED_CODE_LENGTH; -+ h->repeat = 0; -+ h->repeat_code_len = 0; -+ h->space = 32768; -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS; - } - /* Fall through. */ - - case BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS: { - uint32_t table_size; -- BrotliDecoderErrorCode result = ReadSymbolCodeLengths(max_symbol, s); -+ BrotliDecoderErrorCode result = ReadSymbolCodeLengths( -+ alphabet_size_limit, s); - if (result == BROTLI_DECODER_NEEDS_MORE_INPUT) { -- result = SafeReadSymbolCodeLengths(max_symbol, s); -+ result = SafeReadSymbolCodeLengths(alphabet_size_limit, s); - } - if (result != BROTLI_DECODER_SUCCESS) { - return result; - } - -- if (s->space != 0) { -- BROTLI_LOG(("[ReadHuffmanCode] space = %d\n", (int)s->space)); -+ if (h->space != 0) { -+ BROTLI_LOG(("[ReadHuffmanCode] space = %d\n", (int)h->space)); - return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE); - } - table_size = BrotliBuildHuffmanTable( -- table, HUFFMAN_TABLE_BITS, s->symbol_lists, s->code_length_histo); -+ table, HUFFMAN_TABLE_BITS, h->symbol_lists, h->code_length_histo); - if (opt_table_size) { - *opt_table_size = table_size; - } -- s->substate_huffman = BROTLI_STATE_HUFFMAN_NONE; -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_NONE; - return BROTLI_DECODER_SUCCESS; - } - -@@ -858,8 +875,8 @@ static BROTLI_INLINE uint32_t ReadBlockLength(const HuffmanCode* table, - uint32_t code; - uint32_t nbits; - code = ReadSymbol(table, br); -- nbits = kBlockLengthPrefixCode[code].nbits; /* nbits == 2..24 */ -- return kBlockLengthPrefixCode[code].offset + BrotliReadBits(br, nbits); -+ nbits = _kBrotliPrefixCodeRanges[code].nbits; /* nbits == 2..24 */ -+ return _kBrotliPrefixCodeRanges[code].offset + BrotliReadBits24(br, nbits); - } - - /* WARNING: if state is not BROTLI_STATE_READ_BLOCK_LENGTH_NONE, then -@@ -877,13 +894,14 @@ static BROTLI_INLINE BROTLI_BOOL SafeReadBlockLength( - } - { - uint32_t bits; -- uint32_t nbits = kBlockLengthPrefixCode[index].nbits; /* nbits == 2..24 */ -+ uint32_t nbits = _kBrotliPrefixCodeRanges[index].nbits; -+ uint32_t offset = _kBrotliPrefixCodeRanges[index].offset; - if (!BrotliSafeReadBits(br, nbits, &bits)) { - s->block_length_index = index; - s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX; - return BROTLI_FALSE; - } -- *result = kBlockLengthPrefixCode[index].offset + bits; -+ *result = offset + bits; - s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE; - return BROTLI_TRUE; - } -@@ -943,22 +961,22 @@ static BROTLI_NOINLINE void InverseMoveToFrontTransform( - /* Decodes a series of Huffman table using ReadHuffmanCode function. */ - static BrotliDecoderErrorCode HuffmanTreeGroupDecode( - HuffmanTreeGroup* group, BrotliDecoderState* s) { -- if (s->substate_tree_group != BROTLI_STATE_TREE_GROUP_LOOP) { -- s->next = group->codes; -- s->htree_index = 0; -- s->substate_tree_group = BROTLI_STATE_TREE_GROUP_LOOP; -+ BrotliMetablockHeaderArena* h = &s->arena.header; -+ if (h->substate_tree_group != BROTLI_STATE_TREE_GROUP_LOOP) { -+ h->next = group->codes; -+ h->htree_index = 0; -+ h->substate_tree_group = BROTLI_STATE_TREE_GROUP_LOOP; - } -- while (s->htree_index < group->num_htrees) { -+ while (h->htree_index < group->num_htrees) { - uint32_t table_size; -- BrotliDecoderErrorCode result = -- ReadHuffmanCode(group->alphabet_size, group->max_symbol, -- s->next, &table_size, s); -+ BrotliDecoderErrorCode result = ReadHuffmanCode(group->alphabet_size_max, -+ group->alphabet_size_limit, h->next, &table_size, s); - if (result != BROTLI_DECODER_SUCCESS) return result; -- group->htrees[s->htree_index] = s->next; -- s->next += table_size; -- ++s->htree_index; -+ group->htrees[h->htree_index] = h->next; -+ h->next += table_size; -+ ++h->htree_index; - } -- s->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE; -+ h->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE; - return BROTLI_DECODER_SUCCESS; - } - -@@ -976,15 +994,16 @@ static BrotliDecoderErrorCode DecodeContextMap(uint32_t context_map_size, - BrotliDecoderState* s) { - BrotliBitReader* br = &s->br; - BrotliDecoderErrorCode result = BROTLI_DECODER_SUCCESS; -+ BrotliMetablockHeaderArena* h = &s->arena.header; - -- switch ((int)s->substate_context_map) { -+ switch ((int)h->substate_context_map) { - case BROTLI_STATE_CONTEXT_MAP_NONE: - result = DecodeVarLenUint8(s, br, num_htrees); - if (result != BROTLI_DECODER_SUCCESS) { - return result; - } - (*num_htrees)++; -- s->context_index = 0; -+ h->context_index = 0; - BROTLI_LOG_UINT(context_map_size); - BROTLI_LOG_UINT(*num_htrees); - *context_map_arg = -@@ -996,7 +1015,7 @@ static BrotliDecoderErrorCode DecodeContextMap(uint32_t context_map_size, - memset(*context_map_arg, 0, (size_t)context_map_size); - return BROTLI_DECODER_SUCCESS; - } -- s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_READ_PREFIX; -+ h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_READ_PREFIX; - /* Fall through. */ - - case BROTLI_STATE_CONTEXT_MAP_READ_PREFIX: { -@@ -1007,38 +1026,38 @@ static BrotliDecoderErrorCode DecodeContextMap(uint32_t context_map_size, - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } - if ((bits & 1) != 0) { /* Use RLE for zeros. */ -- s->max_run_length_prefix = (bits >> 1) + 1; -+ h->max_run_length_prefix = (bits >> 1) + 1; - BrotliDropBits(br, 5); - } else { -- s->max_run_length_prefix = 0; -+ h->max_run_length_prefix = 0; - BrotliDropBits(br, 1); - } -- BROTLI_LOG_UINT(s->max_run_length_prefix); -- s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_HUFFMAN; -+ BROTLI_LOG_UINT(h->max_run_length_prefix); -+ h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_HUFFMAN; - } - /* Fall through. */ - - case BROTLI_STATE_CONTEXT_MAP_HUFFMAN: { -- uint32_t alphabet_size = *num_htrees + s->max_run_length_prefix; -+ uint32_t alphabet_size = *num_htrees + h->max_run_length_prefix; - result = ReadHuffmanCode(alphabet_size, alphabet_size, -- s->context_map_table, NULL, s); -+ h->context_map_table, NULL, s); - if (result != BROTLI_DECODER_SUCCESS) return result; -- s->code = 0xFFFF; -- s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_DECODE; -+ h->code = 0xFFFF; -+ h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_DECODE; - } - /* Fall through. */ - - case BROTLI_STATE_CONTEXT_MAP_DECODE: { -- uint32_t context_index = s->context_index; -- uint32_t max_run_length_prefix = s->max_run_length_prefix; -+ uint32_t context_index = h->context_index; -+ uint32_t max_run_length_prefix = h->max_run_length_prefix; - uint8_t* context_map = *context_map_arg; -- uint32_t code = s->code; -+ uint32_t code = h->code; - BROTLI_BOOL skip_preamble = (code != 0xFFFF); - while (context_index < context_map_size || skip_preamble) { - if (!skip_preamble) { -- if (!SafeReadSymbol(s->context_map_table, br, &code)) { -- s->code = 0xFFFF; -- s->context_index = context_index; -+ if (!SafeReadSymbol(h->context_map_table, br, &code)) { -+ h->code = 0xFFFF; -+ h->context_index = context_index; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } - BROTLI_LOG_UINT(code); -@@ -1059,8 +1078,8 @@ static BrotliDecoderErrorCode DecodeContextMap(uint32_t context_map_size, - { - uint32_t reps; - if (!BrotliSafeReadBits(br, code, &reps)) { -- s->code = code; -- s->context_index = context_index; -+ h->code = code; -+ h->context_index = context_index; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } - reps += 1U << code; -@@ -1080,13 +1099,13 @@ static BrotliDecoderErrorCode DecodeContextMap(uint32_t context_map_size, - case BROTLI_STATE_CONTEXT_MAP_TRANSFORM: { - uint32_t bits; - if (!BrotliSafeReadBits(br, 1, &bits)) { -- s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_TRANSFORM; -+ h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_TRANSFORM; - return BROTLI_DECODER_NEEDS_MORE_INPUT; - } - if (bits != 0) { - InverseMoveToFrontTransform(*context_map_arg, context_map_size, s); - } -- s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE; -+ h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE; - return BROTLI_DECODER_SUCCESS; - } - -@@ -1448,32 +1467,28 @@ static BrotliDecoderErrorCode ReadContextModes(BrotliDecoderState* s) { - } - - static BROTLI_INLINE void TakeDistanceFromRingBuffer(BrotliDecoderState* s) { -- if (s->distance_code == 0) { -- --s->dist_rb_idx; -- s->distance_code = s->dist_rb[s->dist_rb_idx & 3]; -+ int offset = s->distance_code - 3; -+ if (s->distance_code <= 3) { - /* Compensate double distance-ring-buffer roll for dictionary items. */ -- s->distance_context = 1; -+ s->distance_context = 1 >> s->distance_code; -+ s->distance_code = s->dist_rb[(s->dist_rb_idx - offset) & 3]; -+ s->dist_rb_idx -= s->distance_context; - } else { -- int distance_code = s->distance_code << 1; -- /* kDistanceShortCodeIndexOffset has 2-bit values from LSB: -- 3, 2, 1, 0, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 */ -- const uint32_t kDistanceShortCodeIndexOffset = 0xAAAFFF1B; -- /* kDistanceShortCodeValueOffset has 2-bit values from LSB: -- -0, 0,-0, 0,-1, 1,-2, 2,-3, 3,-1, 1,-2, 2,-3, 3 */ -- const uint32_t kDistanceShortCodeValueOffset = 0xFA5FA500; -- int v = (s->dist_rb_idx + -- (int)(kDistanceShortCodeIndexOffset >> distance_code)) & 0x3; -- s->distance_code = s->dist_rb[v]; -- v = (int)(kDistanceShortCodeValueOffset >> distance_code) & 0x3; -- if ((distance_code & 0x3) != 0) { -- s->distance_code += v; -+ int index_delta = 3; -+ int delta; -+ int base = s->distance_code - 10; -+ if (s->distance_code < 10) { -+ base = s->distance_code - 4; - } else { -- s->distance_code -= v; -- if (s->distance_code <= 0) { -- /* A huge distance will cause a BROTLI_FAILURE() soon. -- This is a little faster than failing here. */ -- s->distance_code = 0x7FFFFFFF; -- } -+ index_delta = 2; -+ } -+ /* Unpack one of six 4-bit values. */ -+ delta = ((0x605142 >> (4 * base)) & 0xF) - 3; -+ s->distance_code = s->dist_rb[(s->dist_rb_idx + index_delta) & 0x3] + delta; -+ if (s->distance_code <= 0) { -+ /* A huge distance will cause a BROTLI_FAILURE() soon. -+ This is a little faster than failing here. */ -+ s->distance_code = 0x7FFFFFFF; - } - } - } -@@ -1488,62 +1503,153 @@ static BROTLI_INLINE BROTLI_BOOL SafeReadBits( - } - } - -+static BROTLI_INLINE BROTLI_BOOL SafeReadBits32( -+ BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) { -+ if (n_bits != 0) { -+ return BrotliSafeReadBits32(br, n_bits, val); -+ } else { -+ *val = 0; -+ return BROTLI_TRUE; -+ } -+} -+ -+/* -+ RFC 7932 Section 4 with "..." shortenings and "[]" emendations. -+ -+ Each distance ... is represented with a pair ... -+ The distance code is encoded using a prefix code... The number of extra bits -+ can be 0..24... Two additional parameters: NPOSTFIX (0..3), and ... -+ NDIRECT (0..120) ... are encoded in the meta-block header... -+ -+ The first 16 distance symbols ... reference past distances... ring buffer ... -+ Next NDIRECT distance symbols ... represent distances from 1 to NDIRECT... -+ [For] distance symbols 16 + NDIRECT and greater ... the number of extra bits -+ ... is given by the following formula: -+ -+ [ xcode = dcode - NDIRECT - 16 ] -+ ndistbits = 1 + [ xcode ] >> (NPOSTFIX + 1) -+ -+ ... -+*/ -+ -+/* -+ RFC 7932 Section 9.2 with "..." shortenings and "[]" emendations. -+ -+ ... to get the actual value of the parameter NDIRECT, left-shift this -+ four-bit number by NPOSTFIX bits ... -+*/ -+ -+/* Remaining formulas from RFC 7932 Section 4 could be rewritten as following: -+ -+ alphabet_size = 16 + NDIRECT + (max_distbits << (NPOSTFIX + 1)) -+ -+ half = ((xcode >> NPOSTFIX) & 1) << ndistbits -+ postfix = xcode & ((1 << NPOSTFIX) - 1) -+ range_start = 2 * (1 << ndistbits - 1 - 1) -+ -+ distance = (range_start + half + extra) << NPOSTFIX + postfix + NDIRECT + 1 -+ -+ NB: ndistbits >= 1 -> range_start >= 0 -+ NB: range_start has factor 2, as the range is covered by 2 "halves" -+ NB: extra -1 offset in range_start formula covers the absence of -+ ndistbits = 0 case -+ NB: when NPOSTFIX = 0, NDIRECT is not greater than 15 -+ -+ In other words, xcode has the following binary structure - XXXHPPP: -+ - XXX represent the number of extra distance bits -+ - H selects upper / lower range of distances -+ - PPP represent "postfix" -+ -+ "Regular" distance encoding has NPOSTFIX = 0; omitting the postfix part -+ simplifies distance calculation. -+ -+ Using NPOSTFIX > 0 allows cheaper encoding of regular structures, e.g. where -+ most of distances have the same reminder of division by 2/4/8. For example, -+ the table of int32_t values that come from different sources; if it is likely -+ that 3 highest bytes of values from the same source are the same, then -+ copy distance often looks like 4x + y. -+ -+ Distance calculation could be rewritten to: -+ -+ ndistbits = NDISTBITS(NDIRECT, NPOSTFIX)[dcode] -+ distance = OFFSET(NDIRECT, NPOSTFIX)[dcode] + extra << NPOSTFIX -+ -+ NDISTBITS and OFFSET could be pre-calculated, as NDIRECT and NPOSTFIX could -+ change only once per meta-block. -+*/ -+ -+/* Calculates distance lookup table. -+ NB: it is possible to have all 64 tables precalculated. */ -+static void CalculateDistanceLut(BrotliDecoderState* s) { -+ BrotliMetablockBodyArena* b = &s->arena.body; -+ uint32_t npostfix = s->distance_postfix_bits; -+ uint32_t ndirect = s->num_direct_distance_codes; -+ uint32_t alphabet_size_limit = s->distance_hgroup.alphabet_size_limit; -+ uint32_t postfix = 1u << npostfix; -+ uint32_t j; -+ uint32_t bits = 1; -+ uint32_t half = 0; -+ -+ /* Skip short codes. */ -+ uint32_t i = BROTLI_NUM_DISTANCE_SHORT_CODES; -+ -+ /* Fill direct codes. */ -+ for (j = 0; j < ndirect; ++j) { -+ b->dist_extra_bits[i] = 0; -+ b->dist_offset[i] = j + 1; -+ ++i; -+ } -+ -+ /* Fill regular distance codes. */ -+ while (i < alphabet_size_limit) { -+ uint32_t base = ndirect + ((((2 + half) << bits) - 4) << npostfix) + 1; -+ /* Always fill the complete group. */ -+ for (j = 0; j < postfix; ++j) { -+ b->dist_extra_bits[i] = (uint8_t)bits; -+ b->dist_offset[i] = base + j; -+ ++i; -+ } -+ bits = bits + half; -+ half = half ^ 1; -+ } -+} -+ - /* Precondition: s->distance_code < 0. */ - static BROTLI_INLINE BROTLI_BOOL ReadDistanceInternal( - int safe, BrotliDecoderState* s, BrotliBitReader* br) { -- int distval; -+ BrotliMetablockBodyArena* b = &s->arena.body; -+ uint32_t code; -+ uint32_t bits; - BrotliBitReaderState memento; - HuffmanCode* distance_tree = s->distance_hgroup.htrees[s->dist_htree_index]; - if (!safe) { -- s->distance_code = (int)ReadSymbol(distance_tree, br); -+ code = ReadSymbol(distance_tree, br); - } else { -- uint32_t code; - BrotliBitReaderSaveState(br, &memento); - if (!SafeReadSymbol(distance_tree, br, &code)) { - return BROTLI_FALSE; - } -- s->distance_code = (int)code; - } -+ --s->block_length[2]; - /* Convert the distance code to the actual distance by possibly -- looking up past distances from the s->ringbuffer. */ -+ looking up past distances from the s->dist_rb. */ - s->distance_context = 0; -- if ((s->distance_code & ~0xF) == 0) { -+ if ((code & ~0xFu) == 0) { -+ s->distance_code = (int)code; - TakeDistanceFromRingBuffer(s); -- --s->block_length[2]; - return BROTLI_TRUE; - } -- distval = s->distance_code - (int)s->num_direct_distance_codes; -- if (distval >= 0) { -- uint32_t nbits; -- int postfix; -- int offset; -- if (!safe && (s->distance_postfix_bits == 0)) { -- nbits = ((uint32_t)distval >> 1) + 1; -- offset = ((2 + (distval & 1)) << nbits) - 4; -- s->distance_code = (int)s->num_direct_distance_codes + offset + -- (int)BrotliReadBits(br, nbits); -- } else { -- /* This branch also works well when s->distance_postfix_bits == 0. */ -- uint32_t bits; -- postfix = distval & s->distance_postfix_mask; -- distval >>= s->distance_postfix_bits; -- nbits = ((uint32_t)distval >> 1) + 1; -- if (safe) { -- if (!SafeReadBits(br, nbits, &bits)) { -- s->distance_code = -1; /* Restore precondition. */ -- BrotliBitReaderRestoreState(br, &memento); -- return BROTLI_FALSE; -- } -- } else { -- bits = BrotliReadBits(br, nbits); -- } -- offset = ((2 + (distval & 1)) << nbits) - 4; -- s->distance_code = (int)s->num_direct_distance_codes + -- ((offset + (int)bits) << s->distance_postfix_bits) + postfix; -+ if (!safe) { -+ bits = BrotliReadBits32(br, b->dist_extra_bits[code]); -+ } else { -+ if (!SafeReadBits32(br, b->dist_extra_bits[code], &bits)) { -+ ++s->block_length[2]; -+ BrotliBitReaderRestoreState(br, &memento); -+ return BROTLI_FALSE; - } - } -- s->distance_code = s->distance_code - BROTLI_NUM_DISTANCE_SHORT_CODES + 1; -- --s->block_length[2]; -+ s->distance_code = -+ (int)(b->dist_offset[code] + (bits << s->distance_postfix_bits)); - return BROTLI_TRUE; - } - -@@ -1579,9 +1685,9 @@ static BROTLI_INLINE BROTLI_BOOL ReadCommandInternal( - *insert_length = v.insert_len_offset; - if (!safe) { - if (BROTLI_PREDICT_FALSE(v.insert_len_extra_bits != 0)) { -- insert_len_extra = BrotliReadBits(br, v.insert_len_extra_bits); -+ insert_len_extra = BrotliReadBits24(br, v.insert_len_extra_bits); - } -- copy_length = BrotliReadBits(br, v.copy_len_extra_bits); -+ copy_length = BrotliReadBits24(br, v.copy_len_extra_bits); - } else { - if (!SafeReadBits(br, v.insert_len_extra_bits, &insert_len_extra) || - !SafeReadBits(br, v.copy_len_extra_bits, ©_length)) { -@@ -1926,21 +2032,6 @@ static BROTLI_NOINLINE BrotliDecoderErrorCode SafeProcessCommands( - return ProcessCommandsInternal(1, s); - } - --/* Returns the maximum number of distance symbols which can only represent -- distances not exceeding BROTLI_MAX_ALLOWED_DISTANCE. */ --static uint32_t BrotliMaxDistanceSymbol(uint32_t ndirect, uint32_t npostfix) { -- static const uint32_t bound[BROTLI_MAX_NPOSTFIX + 1] = {0, 4, 12, 28}; -- static const uint32_t diff[BROTLI_MAX_NPOSTFIX + 1] = {73, 126, 228, 424}; -- uint32_t postfix = 1U << npostfix; -- if (ndirect < bound[npostfix]) { -- return ndirect + diff[npostfix] + postfix; -- } else if (ndirect > bound[npostfix] + postfix) { -- return ndirect + diff[npostfix]; -- } else { -- return bound[npostfix] + diff[npostfix] + postfix; -- } --} -- - BrotliDecoderResult BrotliDecoderDecompress( - size_t encoded_size, const uint8_t* encoded_buffer, size_t* decoded_size, - uint8_t* decoded_buffer) { -@@ -2158,33 +2249,23 @@ BrotliDecoderResult BrotliDecoderDecompressStream( - s->state = BROTLI_STATE_UNCOMPRESSED; - break; - } -+ s->state = BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_HEADER; -+ /* Fall through. */ -+ -+ case BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_HEADER: { -+ BrotliMetablockHeaderArena* h = &s->arena.header; - s->loop_counter = 0; -+ /* Initialize compressed metablock header arena. */ -+ h->sub_loop_counter = 0; -+ /* Make small negative indexes addressable. */ -+ h->symbol_lists = -+ &h->symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1]; -+ h->substate_huffman = BROTLI_STATE_HUFFMAN_NONE; -+ h->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE; -+ h->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE; - s->state = BROTLI_STATE_HUFFMAN_CODE_0; -- break; -- -- case BROTLI_STATE_UNCOMPRESSED: { -- result = CopyUncompressedBlockToOutput( -- available_out, next_out, total_out, s); -- if (result != BROTLI_DECODER_SUCCESS) { -- break; -- } -- s->state = BROTLI_STATE_METABLOCK_DONE; -- break; - } -- -- case BROTLI_STATE_METADATA: -- for (; s->meta_block_remaining_len > 0; --s->meta_block_remaining_len) { -- uint32_t bits; -- /* Read one byte and ignore it. */ -- if (!BrotliSafeReadBits(br, 8, &bits)) { -- result = BROTLI_DECODER_NEEDS_MORE_INPUT; -- break; -- } -- } -- if (result == BROTLI_DECODER_SUCCESS) { -- s->state = BROTLI_STATE_METABLOCK_DONE; -- } -- break; -+ /* Fall through. */ - - case BROTLI_STATE_HUFFMAN_CODE_0: - if (s->loop_counter >= 3) { -@@ -2238,6 +2319,30 @@ BrotliDecoderResult BrotliDecoderDecompressStream( - break; - } - -+ case BROTLI_STATE_UNCOMPRESSED: { -+ result = CopyUncompressedBlockToOutput( -+ available_out, next_out, total_out, s); -+ if (result != BROTLI_DECODER_SUCCESS) { -+ break; -+ } -+ s->state = BROTLI_STATE_METABLOCK_DONE; -+ break; -+ } -+ -+ case BROTLI_STATE_METADATA: -+ for (; s->meta_block_remaining_len > 0; --s->meta_block_remaining_len) { -+ uint32_t bits; -+ /* Read one byte and ignore it. */ -+ if (!BrotliSafeReadBits(br, 8, &bits)) { -+ result = BROTLI_DECODER_NEEDS_MORE_INPUT; -+ break; -+ } -+ } -+ if (result == BROTLI_DECODER_SUCCESS) { -+ s->state = BROTLI_STATE_METABLOCK_DONE; -+ } -+ break; -+ - case BROTLI_STATE_METABLOCK_HEADER_2: { - uint32_t bits; - if (!BrotliSafeReadBits(br, 6, &bits)) { -@@ -2246,11 +2351,9 @@ BrotliDecoderResult BrotliDecoderDecompressStream( - } - s->distance_postfix_bits = bits & BitMask(2); - bits >>= 2; -- s->num_direct_distance_codes = BROTLI_NUM_DISTANCE_SHORT_CODES + -- (bits << s->distance_postfix_bits); -+ s->num_direct_distance_codes = bits << s->distance_postfix_bits; - BROTLI_LOG_UINT(s->num_direct_distance_codes); - BROTLI_LOG_UINT(s->distance_postfix_bits); -- s->distance_postfix_mask = (int)BitMask(s->distance_postfix_bits); - s->context_modes = - (uint8_t*)BROTLI_DECODER_ALLOC(s, (size_t)s->num_block_types[0]); - if (s->context_modes == 0) { -@@ -2282,17 +2385,19 @@ BrotliDecoderResult BrotliDecoderDecompressStream( - /* Fall through. */ - - case BROTLI_STATE_CONTEXT_MAP_2: { -- uint32_t num_direct_codes = -- s->num_direct_distance_codes - BROTLI_NUM_DISTANCE_SHORT_CODES; -- uint32_t num_distance_codes = BROTLI_DISTANCE_ALPHABET_SIZE( -- s->distance_postfix_bits, num_direct_codes, -- (s->large_window ? BROTLI_LARGE_MAX_DISTANCE_BITS : -- BROTLI_MAX_DISTANCE_BITS)); -- uint32_t max_distance_symbol = (s->large_window ? -- BrotliMaxDistanceSymbol( -- num_direct_codes, s->distance_postfix_bits) : -- num_distance_codes); -+ uint32_t npostfix = s->distance_postfix_bits; -+ uint32_t ndirect = s->num_direct_distance_codes; -+ uint32_t distance_alphabet_size_max = BROTLI_DISTANCE_ALPHABET_SIZE( -+ npostfix, ndirect, BROTLI_MAX_DISTANCE_BITS); -+ uint32_t distance_alphabet_size_limit = distance_alphabet_size_max; - BROTLI_BOOL allocation_success = BROTLI_TRUE; -+ if (s->large_window) { -+ BrotliDistanceCodeLimit limit = BrotliCalculateDistanceCodeLimit( -+ BROTLI_MAX_ALLOWED_DISTANCE, npostfix, ndirect); -+ distance_alphabet_size_max = BROTLI_DISTANCE_ALPHABET_SIZE( -+ npostfix, ndirect, BROTLI_LARGE_MAX_DISTANCE_BITS); -+ distance_alphabet_size_limit = limit.max_alphabet_size; -+ } - result = DecodeContextMap( - s->num_block_types[2] << BROTLI_DISTANCE_CONTEXT_BITS, - &s->num_dist_htrees, &s->dist_context_map, s); -@@ -2306,8 +2411,8 @@ BrotliDecoderResult BrotliDecoderDecompressStream( - s, &s->insert_copy_hgroup, BROTLI_NUM_COMMAND_SYMBOLS, - BROTLI_NUM_COMMAND_SYMBOLS, s->num_block_types[1]); - allocation_success &= BrotliDecoderHuffmanTreeGroupInit( -- s, &s->distance_hgroup, num_distance_codes, -- max_distance_symbol, s->num_dist_htrees); -+ s, &s->distance_hgroup, distance_alphabet_size_max, -+ distance_alphabet_size_limit, s->num_dist_htrees); - if (!allocation_success) { - return SaveErrorCode(s, - BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS)); -@@ -2329,18 +2434,24 @@ BrotliDecoderResult BrotliDecoderDecompressStream( - result = HuffmanTreeGroupDecode(hgroup, s); - if (result != BROTLI_DECODER_SUCCESS) break; - s->loop_counter++; -- if (s->loop_counter >= 3) { -- PrepareLiteralDecoding(s); -- s->dist_context_map_slice = s->dist_context_map; -- s->htree_command = s->insert_copy_hgroup.htrees[0]; -- if (!BrotliEnsureRingBuffer(s)) { -- result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2); -- break; -- } -- s->state = BROTLI_STATE_COMMAND_BEGIN; -+ if (s->loop_counter < 3) { -+ break; - } -- break; -+ s->state = BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_BODY; - } -+ /* Fall through. */ -+ -+ case BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_BODY: -+ PrepareLiteralDecoding(s); -+ s->dist_context_map_slice = s->dist_context_map; -+ s->htree_command = s->insert_copy_hgroup.htrees[0]; -+ if (!BrotliEnsureRingBuffer(s)) { -+ result = BROTLI_FAILURE(BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2); -+ break; -+ } -+ CalculateDistanceLut(s); -+ s->state = BROTLI_STATE_COMMAND_BEGIN; -+ /* Fall through. */ - - case BROTLI_STATE_COMMAND_BEGIN: - /* Fall through. */ -diff --git a/c/dec/huffman.h b/c/dec/huffman.h -index 521ec6e..a8fbc45 100644 ---- a/c/dec/huffman.h -+++ b/c/dec/huffman.h -@@ -18,12 +18,6 @@ extern "C" { - - #define BROTLI_HUFFMAN_MAX_CODE_LENGTH 15 - --/* Maximum possible Huffman table size for an alphabet size of (index * 32), -- max code length 15 and root table bits 8. */ --static const uint16_t kMaxHuffmanTableSize[] = { -- 256, 402, 436, 468, 500, 534, 566, 598, 630, 662, 694, 726, 758, 790, 822, -- 854, 886, 920, 952, 984, 1016, 1048, 1080, 1112, 1144, 1176, 1208, 1240, 1272, -- 1304, 1336, 1368, 1400, 1432, 1464, 1496, 1528}; - /* BROTLI_NUM_BLOCK_LEN_SYMBOLS == 26 */ - #define BROTLI_HUFFMAN_MAX_SIZE_26 396 - /* BROTLI_MAX_BLOCK_TYPE_SYMBOLS == 258 */ -@@ -33,11 +27,66 @@ static const uint16_t kMaxHuffmanTableSize[] = { - - #define BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH 5 - -+#if ((defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_32)) && \ -+ BROTLI_GNUC_HAS_ATTRIBUTE(aligned, 2, 7, 0)) -+#define BROTLI_HUFFMAN_CODE_FAST_LOAD -+#endif -+ -+#if !defined(BROTLI_HUFFMAN_CODE_FAST_LOAD) -+/* Do not create this struct directly - use the ConstructHuffmanCode -+ * constructor below! */ - typedef struct { - uint8_t bits; /* number of bits used for this symbol */ - uint16_t value; /* symbol value or table offset */ - } HuffmanCode; - -+static BROTLI_INLINE HuffmanCode ConstructHuffmanCode(const uint8_t bits, -+ const uint16_t value) { -+ HuffmanCode h; -+ h.bits = bits; -+ h.value = value; -+ return h; -+} -+ -+/* Please use the following macros to optimize HuffmanCode accesses in hot -+ * paths. -+ * -+ * For example, assuming |table| contains a HuffmanCode pointer: -+ * -+ * BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(table); -+ * BROTLI_HC_ADJUST_TABLE_INDEX(table, index_into_table); -+ * *bits = BROTLI_HC_GET_BITS(table); -+ * *value = BROTLI_HC_GET_VALUE(table); -+ * BROTLI_HC_ADJUST_TABLE_INDEX(table, offset); -+ * *bits2 = BROTLI_HC_GET_BITS(table); -+ * *value2 = BROTLI_HC_GET_VALUE(table); -+ * -+ */ -+ -+#define BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(H) -+#define BROTLI_HC_ADJUST_TABLE_INDEX(H, V) H += (V) -+ -+/* These must be given a HuffmanCode pointer! */ -+#define BROTLI_HC_FAST_LOAD_BITS(H) (H->bits) -+#define BROTLI_HC_FAST_LOAD_VALUE(H) (H->value) -+ -+#else /* BROTLI_HUFFMAN_CODE_FAST_LOAD */ -+ -+typedef BROTLI_ALIGNED(4) uint32_t HuffmanCode; -+ -+static BROTLI_INLINE HuffmanCode ConstructHuffmanCode(const uint8_t bits, -+ const uint16_t value) { -+ return (HuffmanCode) ((value & 0xFFFF) << 16) | (bits & 0xFF); -+} -+ -+#define BROTLI_HC_MARK_TABLE_FOR_FAST_LOAD(H) uint32_t __fastload_##H = (*H) -+#define BROTLI_HC_ADJUST_TABLE_INDEX(H, V) H += (V); __fastload_##H = (*H) -+ -+/* These must be given a HuffmanCode pointer! */ -+#define BROTLI_HC_FAST_LOAD_BITS(H) ((__fastload_##H) & 0xFF) -+#define BROTLI_HC_FAST_LOAD_VALUE(H) ((__fastload_##H) >> 16) -+#endif /* BROTLI_HUFFMAN_CODE_FAST_LOAD */ -+ - /* Builds Huffman lookup table assuming code lengths are in symbol order. */ - BROTLI_INTERNAL void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* root_table, - const uint8_t* const code_lengths, uint16_t* count); -@@ -45,7 +94,7 @@ BROTLI_INTERNAL void BrotliBuildCodeLengthsHuffmanTable(HuffmanCode* root_table, - /* Builds Huffman lookup table assuming code lengths are in symbol order. - Returns size of resulting table. */ - BROTLI_INTERNAL uint32_t BrotliBuildHuffmanTable(HuffmanCode* root_table, -- int root_bits, const uint16_t* const symbol_lists, uint16_t* count_arg); -+ int root_bits, const uint16_t* const symbol_lists, uint16_t* count); - - /* Builds a simple Huffman table. The |num_symbols| parameter is to be - interpreted as follows: 0 means 1 symbol, 1 means 2 symbols, -@@ -55,13 +104,13 @@ BROTLI_INTERNAL uint32_t BrotliBuildSimpleHuffmanTable(HuffmanCode* table, - int root_bits, uint16_t* symbols, uint32_t num_symbols); - - /* Contains a collection of Huffman trees with the same alphabet size. */ --/* max_symbol is needed due to simple codes since log2(alphabet_size) could be -- greater than log2(max_symbol). */ -+/* alphabet_size_limit is needed due to simple codes, since -+ log2(alphabet_size_max) could be greater than log2(alphabet_size_limit). */ - typedef struct { - HuffmanCode** htrees; - HuffmanCode* codes; -- uint16_t alphabet_size; -- uint16_t max_symbol; -+ uint16_t alphabet_size_max; -+ uint16_t alphabet_size_limit; - uint16_t num_htrees; - } HuffmanTreeGroup; - -diff --git a/c/dec/prefix.h b/c/dec/prefix.h -index 3ea062d..481a2c7 100644 ---- a/c/dec/prefix.h -+++ b/c/dec/prefix.h -@@ -13,24 +13,6 @@ - #include "../common/constants.h" - #include - --/* Represents the range of values belonging to a prefix code: -- [offset, offset + 2^nbits) */ --struct PrefixCodeRange { -- uint16_t offset; -- uint8_t nbits; --}; -- --static const struct PrefixCodeRange -- kBlockLengthPrefixCode[BROTLI_NUM_BLOCK_LEN_SYMBOLS] = { -- { 1, 2}, { 5, 2}, { 9, 2}, { 13, 2}, -- { 17, 3}, { 25, 3}, { 33, 3}, { 41, 3}, -- { 49, 4}, { 65, 4}, { 81, 4}, { 97, 4}, -- { 113, 5}, { 145, 5}, { 177, 5}, { 209, 5}, -- { 241, 6}, { 305, 6}, { 369, 7}, { 497, 8}, -- { 753, 9}, { 1265, 10}, {2289, 11}, {4337, 12}, -- {8433, 13}, {16625, 24} --}; -- - typedef struct CmdLutElement { - uint8_t insert_len_extra_bits; - uint8_t copy_len_extra_bits; -diff --git a/c/dec/state.c b/c/dec/state.c -index e0b37c2..f847836 100644 ---- a/c/dec/state.c -+++ b/c/dec/state.c -@@ -33,10 +33,7 @@ BROTLI_BOOL BrotliDecoderStateInit(BrotliDecoderState* s, - s->state = BROTLI_STATE_UNINITED; - s->large_window = 0; - s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE; -- s->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE; -- s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE; - s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_NONE; -- s->substate_huffman = BROTLI_STATE_HUFFMAN_NONE; - s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE; - s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE; - -@@ -59,8 +56,6 @@ BROTLI_BOOL BrotliDecoderStateInit(BrotliDecoderState* s, - s->context_map_slice = NULL; - s->dist_context_map_slice = NULL; - -- s->sub_loop_counter = 0; -- - s->literal_hgroup.codes = NULL; - s->literal_hgroup.htrees = NULL; - s->insert_copy_hgroup.codes = NULL; -@@ -84,9 +79,6 @@ BROTLI_BOOL BrotliDecoderStateInit(BrotliDecoderState* s, - s->block_type_trees = NULL; - s->block_len_trees = NULL; - -- /* Make small negative indexes addressable. */ -- s->symbol_lists = &s->symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1]; -- - s->mtf_upper_bound = 63; - - s->dictionary = BrotliGetDictionary(); -@@ -142,17 +134,20 @@ void BrotliDecoderStateCleanup(BrotliDecoderState* s) { - } - - BROTLI_BOOL BrotliDecoderHuffmanTreeGroupInit(BrotliDecoderState* s, -- HuffmanTreeGroup* group, uint32_t alphabet_size, uint32_t max_symbol, -- uint32_t ntrees) { -- /* Pack two allocations into one */ -- const size_t max_table_size = kMaxHuffmanTableSize[(alphabet_size + 31) >> 5]; -+ HuffmanTreeGroup* group, uint32_t alphabet_size_max, -+ uint32_t alphabet_size_limit, uint32_t ntrees) { -+ /* 376 = 256 (1-st level table) + 4 + 7 + 15 + 31 + 63 (2-nd level mix-tables) -+ This number is discovered "unlimited" "enough" calculator; it is actually -+ a wee bigger than required in several cases (especially for alphabets with -+ less than 16 symbols). */ -+ const size_t max_table_size = alphabet_size_limit + 376; - const size_t code_size = sizeof(HuffmanCode) * ntrees * max_table_size; - const size_t htree_size = sizeof(HuffmanCode*) * ntrees; - /* Pointer alignment is, hopefully, wider than sizeof(HuffmanCode). */ - HuffmanCode** p = (HuffmanCode**)BROTLI_DECODER_ALLOC(s, - code_size + htree_size); -- group->alphabet_size = (uint16_t)alphabet_size; -- group->max_symbol = (uint16_t)max_symbol; -+ group->alphabet_size_max = (uint16_t)alphabet_size_max; -+ group->alphabet_size_limit = (uint16_t)alphabet_size_limit; - group->num_htrees = (uint16_t)ntrees; - group->htrees = p; - group->codes = (HuffmanCode*)(&p[ntrees]); -diff --git a/c/dec/state.h b/c/dec/state.h -index d28b639..54dab69 100644 ---- a/c/dec/state.h -+++ b/c/dec/state.h -@@ -21,6 +21,95 @@ - extern "C" { - #endif - -+/* Graphviz diagram that describes state transitions: -+ -+digraph States { -+ graph [compound=true] -+ concentrate=true -+ node [shape="box"] -+ -+ UNINITED -> {LARGE_WINDOW_BITS -> INITIALIZE} -+ subgraph cluster_metablock_workflow { -+ style="rounded" -+ label=< METABLOCK CYCLE > -+ METABLOCK_BEGIN -> METABLOCK_HEADER -+ METABLOCK_HEADER:sw -> METADATA -+ METABLOCK_HEADER:s -> UNCOMPRESSED -+ METABLOCK_HEADER:se -> METABLOCK_DONE:ne -+ METADATA:s -> METABLOCK_DONE:w -+ UNCOMPRESSED:s -> METABLOCK_DONE:n -+ METABLOCK_DONE:e -> METABLOCK_BEGIN:e [constraint="false"] -+ } -+ INITIALIZE -> METABLOCK_BEGIN -+ METABLOCK_DONE -> DONE -+ -+ subgraph cluster_compressed_metablock { -+ style="rounded" -+ label=< COMPRESSED METABLOCK > -+ -+ subgraph cluster_command { -+ style="rounded" -+ label=< HOT LOOP > -+ -+ _METABLOCK_DONE_PORT_ [shape=point style=invis] -+ -+ { -+ // Set different shape for nodes returning from "compressed metablock". -+ node [shape=invhouse]; CMD_INNER CMD_POST_DECODE_LITERALS; -+ CMD_POST_WRAP_COPY; CMD_INNER_WRITE; CMD_POST_WRITE_1; -+ } -+ -+ CMD_BEGIN -> CMD_INNER -> CMD_POST_DECODE_LITERALS -> CMD_POST_WRAP_COPY -+ -+ // IO ("write") nodes are not in the hot loop! -+ CMD_INNER_WRITE [style=dashed] -+ CMD_INNER -> CMD_INNER_WRITE -+ CMD_POST_WRITE_1 [style=dashed] -+ CMD_POST_DECODE_LITERALS -> CMD_POST_WRITE_1 -+ CMD_POST_WRITE_2 [style=dashed] -+ CMD_POST_WRAP_COPY -> CMD_POST_WRITE_2 -+ -+ CMD_POST_WRITE_1 -> CMD_BEGIN:s [constraint="false"] -+ CMD_INNER_WRITE -> {CMD_INNER CMD_POST_DECODE_LITERALS} -+ [constraint="false"] -+ CMD_BEGIN:ne -> CMD_POST_DECODE_LITERALS [constraint="false"] -+ CMD_POST_WRAP_COPY -> CMD_BEGIN [constraint="false"] -+ CMD_POST_DECODE_LITERALS -> CMD_BEGIN:ne [constraint="false"] -+ CMD_POST_WRITE_2 -> CMD_POST_WRAP_COPY [constraint="false"] -+ {rank=same; CMD_BEGIN; CMD_INNER; CMD_POST_DECODE_LITERALS; -+ CMD_POST_WRAP_COPY} -+ {rank=same; CMD_INNER_WRITE; CMD_POST_WRITE_1; CMD_POST_WRITE_2} -+ -+ {CMD_INNER CMD_POST_DECODE_LITERALS CMD_POST_WRAP_COPY} -> -+ _METABLOCK_DONE_PORT_ [style=invis] -+ {CMD_INNER_WRITE CMD_POST_WRITE_1} -> _METABLOCK_DONE_PORT_ -+ [constraint="false" style=invis] -+ } -+ -+ BEFORE_COMPRESSED_METABLOCK_HEADER:s -> HUFFMAN_CODE_0:n -+ HUFFMAN_CODE_0 -> HUFFMAN_CODE_1 -> HUFFMAN_CODE_2 -> HUFFMAN_CODE_3 -+ HUFFMAN_CODE_0 -> METABLOCK_HEADER_2 -> CONTEXT_MODES -> CONTEXT_MAP_1 -+ CONTEXT_MAP_1 -> CONTEXT_MAP_2 -> TREE_GROUP -+ TREE_GROUP -> BEFORE_COMPRESSED_METABLOCK_BODY:e -+ BEFORE_COMPRESSED_METABLOCK_BODY:s -> CMD_BEGIN:n -+ -+ HUFFMAN_CODE_3:e -> HUFFMAN_CODE_0:ne [constraint="false"] -+ {rank=same; HUFFMAN_CODE_0; HUFFMAN_CODE_1; HUFFMAN_CODE_2; HUFFMAN_CODE_3} -+ {rank=same; METABLOCK_HEADER_2; CONTEXT_MODES; CONTEXT_MAP_1; CONTEXT_MAP_2; -+ TREE_GROUP} -+ } -+ METABLOCK_HEADER:e -> BEFORE_COMPRESSED_METABLOCK_HEADER:n -+ -+ _METABLOCK_DONE_PORT_ -> METABLOCK_DONE:se -+ [constraint="false" ltail=cluster_command] -+ -+ UNINITED [shape=Mdiamond]; -+ DONE [shape=Msquare]; -+} -+ -+ -+ */ -+ - typedef enum { - BROTLI_STATE_UNINITED, - BROTLI_STATE_LARGE_WINDOW_BITS, -@@ -39,6 +128,7 @@ typedef enum { - BROTLI_STATE_METABLOCK_DONE, - BROTLI_STATE_COMMAND_POST_WRITE_1, - BROTLI_STATE_COMMAND_POST_WRITE_2, -+ BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_HEADER, - BROTLI_STATE_HUFFMAN_CODE_0, - BROTLI_STATE_HUFFMAN_CODE_1, - BROTLI_STATE_HUFFMAN_CODE_2, -@@ -46,6 +136,7 @@ typedef enum { - BROTLI_STATE_CONTEXT_MAP_1, - BROTLI_STATE_CONTEXT_MAP_2, - BROTLI_STATE_TREE_GROUP, -+ BROTLI_STATE_BEFORE_COMPRESSED_METABLOCK_BODY, - BROTLI_STATE_DONE - } BrotliRunningState; - -@@ -98,6 +189,50 @@ typedef enum { - BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX - } BrotliRunningReadBlockLengthState; - -+typedef struct BrotliMetablockHeaderArena { -+ BrotliRunningTreeGroupState substate_tree_group; -+ BrotliRunningContextMapState substate_context_map; -+ BrotliRunningHuffmanState substate_huffman; -+ -+ uint32_t sub_loop_counter; -+ -+ uint32_t repeat_code_len; -+ uint32_t prev_code_len; -+ -+ /* For ReadHuffmanCode. */ -+ uint32_t symbol; -+ uint32_t repeat; -+ uint32_t space; -+ -+ /* Huffman table for "histograms". */ -+ HuffmanCode table[32]; -+ /* List of heads of symbol chains. */ -+ uint16_t* symbol_lists; -+ /* Storage from symbol_lists. */ -+ uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + -+ BROTLI_NUM_COMMAND_SYMBOLS]; -+ /* Tails of symbol chains. */ -+ int next_symbol[32]; -+ uint8_t code_length_code_lengths[BROTLI_CODE_LENGTH_CODES]; -+ /* Population counts for the code lengths. */ -+ uint16_t code_length_histo[16]; -+ -+ /* For HuffmanTreeGroupDecode. */ -+ int htree_index; -+ HuffmanCode* next; -+ -+ /* For DecodeContextMap. */ -+ uint32_t context_index; -+ uint32_t max_run_length_prefix; -+ uint32_t code; -+ HuffmanCode context_map_table[BROTLI_HUFFMAN_MAX_SIZE_272]; -+} BrotliMetablockHeaderArena; -+ -+typedef struct BrotliMetablockBodyArena { -+ uint8_t dist_extra_bits[544]; -+ uint32_t dist_offset[544]; -+} BrotliMetablockBodyArena; -+ - struct BrotliDecoderStateStruct { - BrotliRunningState state; - -@@ -110,7 +245,8 @@ struct BrotliDecoderStateStruct { - brotli_free_func free_func; - void* memory_manager_opaque; - -- /* Temporary storage for remaining input. */ -+ /* Temporary storage for remaining input. Brotli stream format is designed in -+ a way, that 64 bits are enough to make progress in decoding. */ - union { - uint64_t u64; - uint8_t u8[8]; -@@ -125,7 +261,6 @@ struct BrotliDecoderStateStruct { - int dist_rb_idx; - int dist_rb[4]; - int error_code; -- uint32_t sub_loop_counter; - uint8_t* ringbuffer; - uint8_t* ringbuffer_end; - HuffmanCode* htree_command; -@@ -153,13 +288,10 @@ struct BrotliDecoderStateStruct { - uint32_t block_type_rb[6]; - uint32_t distance_postfix_bits; - uint32_t num_direct_distance_codes; -- int distance_postfix_mask; - uint32_t num_dist_htrees; - uint8_t* dist_context_map; - HuffmanCode* literal_htree; - uint8_t dist_htree_index; -- uint32_t repeat_code_len; -- uint32_t prev_code_len; - - int copy_length; - int distance_code; -@@ -168,33 +300,6 @@ struct BrotliDecoderStateStruct { - size_t rb_roundtrips; /* how many times we went around the ring-buffer */ - size_t partial_pos_out; /* how much output to the user in total */ - -- /* For ReadHuffmanCode. */ -- uint32_t symbol; -- uint32_t repeat; -- uint32_t space; -- -- HuffmanCode table[32]; -- /* List of heads of symbol chains. */ -- uint16_t* symbol_lists; -- /* Storage from symbol_lists. */ -- uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + -- BROTLI_NUM_COMMAND_SYMBOLS]; -- /* Tails of symbol chains. */ -- int next_symbol[32]; -- uint8_t code_length_code_lengths[BROTLI_CODE_LENGTH_CODES]; -- /* Population counts for the code lengths. */ -- uint16_t code_length_histo[16]; -- -- /* For HuffmanTreeGroupDecode. */ -- int htree_index; -- HuffmanCode* next; -- -- /* For DecodeContextMap. */ -- uint32_t context_index; -- uint32_t max_run_length_prefix; -- uint32_t code; -- HuffmanCode context_map_table[BROTLI_HUFFMAN_MAX_SIZE_272]; -- - /* For InverseMoveToFrontTransform. */ - uint32_t mtf_upper_bound; - uint32_t mtf[64 + 1]; -@@ -203,10 +308,7 @@ struct BrotliDecoderStateStruct { - - /* States inside function calls. */ - BrotliRunningMetablockHeaderState substate_metablock_header; -- BrotliRunningTreeGroupState substate_tree_group; -- BrotliRunningContextMapState substate_context_map; - BrotliRunningUncompressedState substate_uncompressed; -- BrotliRunningHuffmanState substate_huffman; - BrotliRunningDecodeUint8State substate_decode_uint8; - BrotliRunningReadBlockLengthState substate_read_block_length; - -@@ -229,6 +331,11 @@ struct BrotliDecoderStateStruct { - const BrotliTransforms* transforms; - - uint32_t trivial_literal_contexts[8]; /* 256 bits */ -+ -+ union { -+ BrotliMetablockHeaderArena header; -+ BrotliMetablockBodyArena body; -+ } arena; - }; - - typedef struct BrotliDecoderStateStruct BrotliDecoderStateInternal; -@@ -241,8 +348,8 @@ BROTLI_INTERNAL void BrotliDecoderStateMetablockBegin(BrotliDecoderState* s); - BROTLI_INTERNAL void BrotliDecoderStateCleanupAfterMetablock( - BrotliDecoderState* s); - BROTLI_INTERNAL BROTLI_BOOL BrotliDecoderHuffmanTreeGroupInit( -- BrotliDecoderState* s, HuffmanTreeGroup* group, uint32_t alphabet_size, -- uint32_t max_symbol, uint32_t ntrees); -+ BrotliDecoderState* s, HuffmanTreeGroup* group, uint32_t alphabet_size_max, -+ uint32_t alphabet_size_limit, uint32_t ntrees); - - #define BROTLI_DECODER_ALLOC(S, L) S->alloc_func(S->memory_manager_opaque, L) - -diff --git a/c/enc/brotli_bit_stream.c b/c/enc/brotli_bit_stream.c -index aaf2dad..8e68059 100644 ---- a/c/enc/brotli_bit_stream.c -+++ b/c/enc/brotli_bit_stream.c -@@ -34,33 +34,18 @@ extern "C" { - BROTLI_DISTANCE_ALPHABET_SIZE(0, 0, BROTLI_LARGE_MAX_DISTANCE_BITS) - /* MAX_SIMPLE_DISTANCE_ALPHABET_SIZE == 140 */ - --/* Represents the range of values belonging to a prefix code: -- [offset, offset + 2^nbits) */ --typedef struct PrefixCodeRange { -- uint32_t offset; -- uint32_t nbits; --} PrefixCodeRange; -- --static const PrefixCodeRange -- kBlockLengthPrefixCode[BROTLI_NUM_BLOCK_LEN_SYMBOLS] = { -- { 1, 2}, { 5, 2}, { 9, 2}, {13, 2}, {17, 3}, { 25, 3}, { 33, 3}, -- {41, 3}, {49, 4}, {65, 4}, {81, 4}, {97, 4}, {113, 5}, {145, 5}, -- {177, 5}, { 209, 5}, { 241, 6}, { 305, 6}, { 369, 7}, { 497, 8}, -- {753, 9}, {1265, 10}, {2289, 11}, {4337, 12}, {8433, 13}, {16625, 24} --}; -- - static BROTLI_INLINE uint32_t BlockLengthPrefixCode(uint32_t len) { - uint32_t code = (len >= 177) ? (len >= 753 ? 20 : 14) : (len >= 41 ? 7 : 0); - while (code < (BROTLI_NUM_BLOCK_LEN_SYMBOLS - 1) && -- len >= kBlockLengthPrefixCode[code + 1].offset) ++code; -+ len >= _kBrotliPrefixCodeRanges[code + 1].offset) ++code; - return code; - } - - static BROTLI_INLINE void GetBlockLengthPrefixCode(uint32_t len, size_t* code, - uint32_t* n_extra, uint32_t* extra) { - *code = BlockLengthPrefixCode(len); -- *n_extra = kBlockLengthPrefixCode[*code].nbits; -- *extra = len - kBlockLengthPrefixCode[*code].offset; -+ *n_extra = _kBrotliPrefixCodeRanges[*code].nbits; -+ *extra = len - _kBrotliPrefixCodeRanges[*code].offset; - } - - typedef struct BlockTypeCodeCalculator { -diff --git a/research/brotli_decoder.c b/research/brotli_decoder.c -index b1d556d..4b0bc4a 100644 ---- a/research/brotli_decoder.c -+++ b/research/brotli_decoder.c -@@ -38,6 +38,7 @@ void cleanup(Context* ctx) { - - void fail(Context* ctx, const char* message) { - fprintf(stderr, "%s\n", message); -+ cleanup(ctx); - exit(1); - } - -diff --git a/scripts/sources.lst b/scripts/sources.lst -index 5e8e817..cd0b343 100644 ---- a/scripts/sources.lst -+++ b/scripts/sources.lst -@@ -5,6 +5,7 @@ BROTLI_CLI_C = \ - c/tools/brotli.c - - BROTLI_COMMON_C = \ -+ c/common/constants.c \ - c/common/dictionary.c \ - c/common/transform.c - -diff --git a/setup.py b/setup.py -index 1491db3..7bd6314 100644 ---- a/setup.py -+++ b/setup.py -@@ -181,6 +181,7 @@ EXT_MODULES = [ - '_brotli', - sources=[ - 'python/_brotli.cc', -+ 'c/common/constants.c', - 'c/common/dictionary.c', - 'c/common/transform.c', - 'c/dec/bit_reader.c', --- -2.25.4 - diff --git a/SPECS/brotli.spec b/SPECS/brotli.spec deleted file mode 100644 index e201b9c..0000000 --- a/SPECS/brotli.spec +++ /dev/null @@ -1,202 +0,0 @@ -%if 0%{?rhel} > 7 -# Disable python2 build by default -%bcond_with python2 -%else -%bcond_without python2 -%endif - -Name: brotli -Version: 1.0.6 -Release: 3%{?dist} -Summary: Lossless compression algorithm - -License: MIT -URL: https://github.com/google/brotli -Source0: https://github.com/google/brotli/archive/v%{version}.tar.gz - -Patch1: rhbz1881156.patch - -%if %{with python2} -BuildRequires: python2-devel -%endif -BuildRequires: python3-devel -BuildRequires: gcc-c++ gcc cmake - -%description -Brotli is a generic-purpose lossless compression algorithm that compresses -data using a combination of a modern variant of the LZ77 algorithm, Huffman -coding and 2nd order context modeling, with a compression ratio comparable -to the best currently available general-purpose compression methods. -It is similar in speed with deflate but offers more dense compression. - -%if %{with python2} -%package -n python2-%{name} -Summary: Lossless compression algorithm (python 2) -Requires: python2 -%{?python_provide:%python_provide python2-%{name}} - -%description -n python2-%{name} -Brotli is a generic-purpose lossless compression algorithm that compresses -data using a combination of a modern variant of the LZ77 algorithm, Huffman -coding and 2nd order context modeling, with a compression ratio comparable -to the best currently available general-purpose compression methods. -It is similar in speed with deflate but offers more dense compression. -This package installs a Python 2 module. -%endif - -%package -n python3-%{name} -Requires: %{__python3} -Summary: Lossless compression algorithm (python 3) -%{?python_provide:%python_provide python3-%{name}} - -%description -n python3-%{name} -Brotli is a generic-purpose lossless compression algorithm that compresses -data using a combination of a modern variant of the LZ77 algorithm, Huffman -coding and 2nd order context modeling, with a compression ratio comparable -to the best currently available general-purpose compression methods. -It is similar in speed with deflate but offers more dense compression. -This package installs a Python 3 module. - - -%package -n %{name}-devel -Summary: Lossless compression algorithm (development files) -Requires: %{name}%{?_isa} = %{version}-%{release} - -%description -n %{name}-devel -Brotli is a generic-purpose lossless compression algorithm that compresses -data using a combination of a modern variant of the LZ77 algorithm, Huffman -coding and 2nd order context modeling, with a compression ratio comparable -to the best currently available general-purpose compression methods. -It is similar in speed with deflate but offers more dense compression. -This package installs the development files - -%prep -%autosetup -p1 -S git -# fix permissions for -debuginfo -# rpmlint will complain if I create an extra %%files section for -# -debuginfo for this so we'll put it here instead -%{__chmod} 644 c/enc/*.[ch] -%{__chmod} 644 c/include/brotli/*.h -%{__chmod} 644 c/tools/brotli.c - -%build - -mkdir -p build -cd build -%cmake .. -DCMAKE_INSTALL_PREFIX="%{_prefix}" \ - -DCMAKE_INSTALL_LIBDIR="%{_libdir}" -%make_build -cd .. -%if %{with python2} -%py2_build -%endif -%py3_build - -%install -cd build -%make_install - -# I couldn't find the option to not build the static libraries -%__rm "%{buildroot}%{_libdir}/"*.a - -cd .. -# Must do the python2 install first because the scripts in /usr/bin are -# overwritten with every setup.py install, and in general we want the -# python3 version to be the default. If, however, we're installing separate -# executables for python2 and python3, the order needs to be reversed so -# the unversioned executable is the python2 one. -%if %{with python2} -%py2_install -%endif -%py3_install -%{__install} -dm755 "%{buildroot}%{_mandir}/man3" -cd docs -for i in *.3;do -%{__install} -m644 "$i" "%{buildroot}%{_mandir}/man3/${i}brotli" -done - -%ldconfig_scriptlets - -%check -cd build -ctest -V -cd .. -%if %{with python2} -%{__python2} setup.py test -%endif -%{__python3} setup.py test - -%files -%{_bindir}/brotli -%{_libdir}/*.so.* -%license LICENSE - -# Note that there is no %%files section for the unversioned python module -# if we are building for several python runtimes -%if %{with python2} -%files -n python2-%{name} -%{python2_sitearch}/* -%license LICENSE -%endif - -%files -n python3-%{name} -%{python3_sitearch}/* -%license LICENSE - -%files -n %{name}-devel -%{_includedir}/* -%{_libdir}/*.so -%{_libdir}/pkgconfig/* -%{_mandir}/man3/* - - -%changelog -* Thu Oct 01 2020 Eike Rathke - 1.0.6-3 -- Resolves: CVE-2020-8927 - -* Wed Jun 17 2020 Eike Rathke - 1.0.6-2 -- Resolves: rhbz#1737412 bump NRV for build to compose - -* Wed Oct 10 2018 Tomas Popela - 1.0.6-1 -- Update to 1.0.6 -- Resolves: rhbz#1637408 - -* Wed Sep 19 2018 Tomas Orsava - 1.0.5-2 -- Require the Python interpreter directly instead of using the package name -- Related: rhbz#1619153 - -* Mon Jul 16 2018 Tomas Popela - 1.0.5-1 -- Update to 1.0.5 - -* Tue Jun 19 2018 Lumír Balhar - 1.0.1-4 -- Python 2 subpackage disabled - -* Wed Feb 07 2018 Fedora Release Engineering - 1.0.1-3 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild - -* Sat Feb 03 2018 Igor Gnatenko - 1.0.1-2 -- Switch to %%ldconfig_scriptlets - -* Fri Sep 22 2017 Travis Kendrick - 1.0.1-1 -- update to 1.0.1 - -* Wed Aug 02 2017 Fedora Release Engineering - 0.6.0-6 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild - -* Wed Jul 26 2017 Fedora Release Engineering - 0.6.0-5 -- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild - -* Tue May 23 2017 Travis Kendrick - 0.6.0-4 -- add man pages - -* Sun May 14 2017 Travis Kendrick - 0.6.0-3 -- wrong directory for ctest -- LICENSE not needed in -devel -- fix "spurious-executable-perm" -- rpmbuild does the cleaning for us, so 'rm -rf %%{buildroot}' isn't needed - -* Sat May 13 2017 Travis Kendrick - 0.6.0-2 -- include libraries and development files - -* Sat May 06 2017 Travis Kendrick - 0.6.0-1 -- Initial build diff --git a/brotli.spec b/brotli.spec new file mode 100644 index 0000000..efff6fc --- /dev/null +++ b/brotli.spec @@ -0,0 +1,300 @@ +Name: brotli +Version: 1.1.0 +Release: 6%{?dist} +Summary: Lossless compression algorithm + +License: MIT +URL: https://github.com/google/brotli +Source0: %{url}/archive/v%{version}/%{name}-%{version}.tar.gz + +Patch1: RHEL-32153-kBrotliBitMask-bounds.patch + +%if 0%{?rhel} == 7 +BuildRequires: devtoolset-7-toolchain, devtoolset-7-libatomic-devel +BuildRequires: cmake3 +%else +BuildRequires: cmake +%endif +BuildRequires: gcc +BuildRequires: gcc-c++ +BuildRequires: python%{python3_pkgversion}-devel +BuildRequires: python%{python3_pkgversion}-setuptools +Requires: lib%{name}%{?_isa} = %{version}-%{release} + +%description +Brotli is a generic-purpose lossless compression algorithm that compresses +data using a combination of a modern variant of the LZ77 algorithm, Huffman +coding and 2nd order context modeling, with a compression ratio comparable +to the best currently available general-purpose compression methods. +It is similar in speed with deflate but offers more dense compression. + +%package -n libbrotli +Summary: Library for brotli lossless compression algorithm + +%description -n libbrotli +Brotli is a generic-purpose lossless compression algorithm that compresses +data using a combination of a modern variant of the LZ77 algorithm, Huffman +coding and 2nd order context modeling, with a compression ratio comparable +to the best currently available general-purpose compression methods. +It is similar in speed with deflate but offers more dense compression. + + +%package -n python%{python3_pkgversion}-%{name} +Summary: Lossless compression algorithm (python 3) +%{?python_provide:%python_provide python%{python3_pkgversion}-%{name}} + +%description -n python%{python3_pkgversion}-%{name} +Brotli is a generic-purpose lossless compression algorithm that compresses +data using a combination of a modern variant of the LZ77 algorithm, Huffman +coding and 2nd order context modeling, with a compression ratio comparable +to the best currently available general-purpose compression methods. +It is similar in speed with deflate but offers more dense compression. +This package installs a Python 3 module. + + +%package devel +Summary: Lossless compression algorithm (development files) +Requires: %{name}%{?_isa} = %{version}-%{release} +Requires: lib%{name}%{?_isa} = %{version}-%{release} + +%description devel +Brotli is a generic-purpose lossless compression algorithm that compresses +data using a combination of a modern variant of the LZ77 algorithm, Huffman +coding and 2nd order context modeling, with a compression ratio comparable +to the best currently available general-purpose compression methods. +It is similar in speed with deflate but offers more dense compression. +This package installs the development files + +%prep +%autosetup -p1 +# fix permissions for -debuginfo +# rpmlint will complain if I create an extra %%files section for +# -debuginfo for this so we'll put it here instead +chmod 644 c/enc/*.[ch] +chmod 644 c/include/brotli/*.h +chmod 644 c/tools/brotli.c + +%build +%if 0%{?rhel} == 7 +. /opt/rh/devtoolset-7/enable +%cmake3 \ + -DCMAKE_INSTALL_PREFIX="%{_prefix}" \ + -DCMAKE_INSTALL_LIBDIR="%{_libdir}" +%cmake3_build +%else +%cmake \ + -DCMAKE_INSTALL_PREFIX="%{_prefix}" \ + -DCMAKE_INSTALL_LIBDIR="%{_libdir}" +%cmake_build +%endif +%py3_build + +%install +%if 0%{?rhel} == 7 +. /opt/rh/devtoolset-7/enable +%cmake3_install +%else +%cmake_install +%endif + +# I couldn't find the option to not build the static libraries +#rm "%{buildroot}%{_libdir}/"*.a + +%py3_install +install -dm755 "%{buildroot}%{_mandir}/man3" +cd docs +for i in *.3;do +install -m644 "$i" "%{buildroot}%{_mandir}/man3/${i}brotli" +done + +%ldconfig_scriptlets + +%check +%if 0%{?rhel} == 7 +. /opt/rh/devtoolset-7/enable +%ctest3 +%else +%ctest +%endif + +%files +%{_bindir}/brotli + +%files -n libbrotli +%license LICENSE +%{_libdir}/libbrotlicommon.so.1* +%{_libdir}/libbrotlidec.so.1* +%{_libdir}/libbrotlienc.so.1* + +# Note that there is no %%files section for the unversioned python module +# if we are building for several python runtimes +%files -n python%{python3_pkgversion}-%{name} +%license LICENSE +%{python3_sitearch}/brotli.py +%{python3_sitearch}/_brotli.cpython-%{python3_version_nodots}*.so +%{python3_sitearch}/__pycache__/brotli.cpython-%{python3_version_nodots}*.py* +%{python3_sitearch}/Brotli-1.1.0-py%{python3_version}.egg-info/ + +%files devel +%{_includedir}/brotli +%{_libdir}/libbrotlicommon.so +%{_libdir}/libbrotlidec.so +%{_libdir}/libbrotlienc.so +%{_libdir}/pkgconfig/libbrotlicommon.pc +%{_libdir}/pkgconfig/libbrotlidec.pc +%{_libdir}/pkgconfig/libbrotlienc.pc +%{_mandir}/man3/constants.h.3brotli* +%{_mandir}/man3/decode.h.3brotli* +%{_mandir}/man3/encode.h.3brotli* +%{_mandir}/man3/types.h.3brotli* + + +%changelog +* Tue Oct 29 2024 Troy Dawson - 1.1.0-6 +- Bump release for October 2024 mass rebuild: + Resolves: RHEL-64018 + +* Wed Sep 11 2024 Eike Rathke - 1.1.0-5 +- Check BitMask(n) n value for kBrotliBitMask[n] bounds + +* Mon Jun 24 2024 Troy Dawson - 1.1.0-4 +- Bump release for June 2024 mass rebuild + +* Tue Jan 23 2024 Fedora Release Engineering - 1.1.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Fri Jan 19 2024 Fedora Release Engineering - 1.1.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Fri Sep 15 2023 Jonathan Wright - 1.1.0-1 +- Update to 1.1.1 rhbz#2233368 + +* Wed Jul 19 2023 Fedora Release Engineering - 1.0.9-13 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild + +* Tue Jun 13 2023 Python Maint - 1.0.9-12 +- Rebuilt for Python 3.12 + +* Wed Jan 18 2023 Fedora Release Engineering - 1.0.9-11 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild + +* Sat Dec 03 2022 Jonathan Wright - 1.0.9-10 +- Fix EL7 builds + +* Wed Jul 20 2022 Fedora Release Engineering - 1.0.9-9 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_37_Mass_Rebuild + +* Mon Jun 13 2022 Python Maint - 1.0.9-8 +- Rebuilt for Python 3.11 + +* Wed Jan 19 2022 Fedora Release Engineering - 1.0.9-7 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_36_Mass_Rebuild + +* Wed Jul 21 2021 Fedora Release Engineering - 1.0.9-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_35_Mass_Rebuild + +* Thu Jun 03 2021 Python Maint - 1.0.9-5 +- Rebuilt for Python 3.10 + +* Tue Jan 26 2021 Fedora Release Engineering - 1.0.9-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Thu Oct 01 2020 Travis Kendrick - 1.0.9-3 +- Apparently %%autosetup calls %%patch on its own + +* Thu Oct 01 2020 Travis Kendrick - 1.0.9-2 +- Fix pc file (#1884364) + +* Wed Sep 30 2020 Travis Kendrick - 1.0.9-1 +- Update to 1.0.9 (#1872932) + +* Wed Aug 12 2020 Carl George - 1.0.7-14 +- Update cmake invocation rhbz#1863298 + +* Sat Aug 01 2020 Fedora Release Engineering - 1.0.7-13 +- Second attempt - Rebuilt for + https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Mon Jul 27 2020 Fedora Release Engineering - 1.0.7-12 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Sat May 23 2020 Miro Hrončok - 1.0.7-11 +- Rebuilt for Python 3.9 + +* Tue Jan 28 2020 Fedora Release Engineering - 1.0.7-10 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Sat Dec 7 2019 Peter Robinson 1.0.7-9 +- Splil out the libs to a separate package + +* Thu Oct 03 2019 Miro Hrončok - 1.0.7-8 +- Rebuilt for Python 3.8.0rc1 (#1748018) + +* Sat Aug 17 2019 Miro Hrončok - 1.0.7-7 +- Rebuilt for Python 3.8 + +* Wed Jul 24 2019 Fedora Release Engineering - 1.0.7-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Sat Apr 20 2019 Orion Poplawski - 1.0.7-5 +- Build with devtoolset-7 on EPEL7 to fix aarch64 builds + +* Thu Mar 28 2019 Carl George - 1.0.7-4 +- EPEL compatibility + +* Thu Jan 31 2019 Fedora Release Engineering - 1.0.7-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Sun Dec 09 2018 Miro Hrončok - 1.0.7-2 +- Remove last python2 bits + +* Wed Nov 28 2018 Travis Kendrick pouar@pouar.net> - 1.0.7-1 +- Update to 1.0.7 + +* Wed Nov 28 2018 Travis Kendrick pouar@pouar.net> - 1.0.5-2 +- remove Python 2 support https://fedoraproject.org/wiki/Changes/Mass_Python_2_Package_Removal + +* Fri Jul 13 2018 Travis Kendrick pouar@pouar.net> - 1.0.5-1 +- update to 1.0.5 + +* Thu Jul 12 2018 Fedora Release Engineering - 1.0.4-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Mon Jun 18 2018 Miro Hrončok - 1.0.4-3 +- Rebuilt for Python 3.7 + +* Wed Apr 18 2018 Travis Kendrick pouar@pouar.net> - 1.0.4-2 +- update to 1.0.4 + +* Sat Mar 03 2018 Travis Kendrick - 1.0.3-1 +- update to 1.0.3 + +* Wed Feb 07 2018 Fedora Release Engineering - 1.0.1-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Sat Feb 03 2018 Igor Gnatenko - 1.0.1-2 +- Switch to %%ldconfig_scriptlets + +* Fri Sep 22 2017 Travis Kendrick - 1.0.1-1 +- update to 1.0.1 + +* Wed Aug 02 2017 Fedora Release Engineering - 0.6.0-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 0.6.0-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Tue May 23 2017 Travis Kendrick - 0.6.0-4 +- add man pages + +* Sun May 14 2017 Travis Kendrick - 0.6.0-3 +- wrong directory for ctest +- LICENSE not needed in -devel +- fix "spurious-executable-perm" +- rpmbuild does the cleaning for us, so 'rm -rf %%{buildroot}' isn't needed + +* Sat May 13 2017 Travis Kendrick - 0.6.0-2 +- include libraries and development files + +* Sat May 06 2017 Travis Kendrick - 0.6.0-1 +- Initial build diff --git a/sources b/sources new file mode 100644 index 0000000..60257d9 --- /dev/null +++ b/sources @@ -0,0 +1 @@ +SHA512 (brotli-1.1.0.tar.gz) = 6eb280d10d8e1b43d22d00fa535435923c22ce8448709419d676ff47d4a644102ea04f488fc65a179c6c09fee12380992e9335bad8dfebd5d1f20908d10849d9