From ce3b0936620b9abb2d6d21d3e608f37f3c7302d9 Mon Sep 17 00:00:00 2001

From: rpm-build <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 <brotli/port.h>

+#include <brotli/types.h>

+

 /* 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 <string.h>  /* memcpy */

+#include "../common/constants.h"

 #include "../common/platform.h"

 #include <brotli/types.h>

@@ -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 <brotli/decode.h>

-#if defined(__ARM_NEON__)

-#include <arm_neon.h>

-#endif

-

 #include <stdlib.h>  /* free, malloc */

 #include <string.h>  /* memcpy, memset */

@@ -24,6 +20,10 @@

 #include "./prefix.h"

 #include "./state.h"

+#if defined(BROTLI_TARGET_NEON)

+#include <arm_neon.h>

+#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);

     }