brotli 0.1.1 → 0.1.2

data/vendor/brotli/dec/decode.c

@@ -4,38 +4,35 @@
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "./bit_reader.h"
-#include "./context.h"
 #include "./decode.h"
-#include "./dictionary.h"
-#include "./port.h"
-#include "./transform.h"
-#include "./huffman.h"
-#include "./prefix.h"
 
 #ifdef __ARM_NEON__
 #include <arm_neon.h>
 #endif
 
+#include <stdlib.h>  /* free, malloc */
+#include <string.h>  /* memcpy, memset */
+
+#include "./bit_reader.h"
+#include "./context.h"
+#include "./dictionary.h"
+#include "./huffman.h"
+#include "./port.h"
+#include "./prefix.h"
+#include "./state.h"
+#include "./transform.h"
+
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-#ifdef BROTLI_DECODE_DEBUG
-#define BROTLI_LOG_UINT(name)                                    \
-  printf("[%s] %s = %lu\n", __func__, #name, (unsigned long)(name))
-#define BROTLI_LOG_ARRAY_INDEX(array_name, idx)                  \
-  printf("[%s] %s[%lu] = %lu\n", __func__, #array_name, \
-         (unsigned long)(idx), (unsigned long)array_name[idx])
-#define BROTLI_LOG(x) printf x
-#else
-#define BROTLI_LOG_UINT(name)
-#define BROTLI_LOG_ARRAY_INDEX(array_name, idx)
-#define BROTLI_LOG(x)
-#endif
+#define BROTLI_FAILURE(CODE) (BROTLI_DUMP(), CODE)
+
+#define BROTLI_LOG_UINT(name)                                       \
+  BROTLI_LOG(("[%s] %s = %lu\n", __func__, #name, (unsigned long)(name)))
+#define BROTLI_LOG_ARRAY_INDEX(array_name, idx)                     \
+  BROTLI_LOG(("[%s] %s[%lu] = %lu\n", __func__, #array_name,        \
+         (unsigned long)(idx), (unsigned long)array_name[idx]))
 
 static const uint32_t kDefaultCodeLength = 8;
 static const uint32_t kCodeLengthRepeatCode = 16;
@@ -45,8 +42,8 @@ static const uint32_t kNumBlockLengthCodes = 26;
 static const int kLiteralContextBits = 6;
 static const int kDistanceContextBits = 2;
 
-#define HUFFMAN_TABLE_BITS      8U
-#define HUFFMAN_TABLE_MASK      0xff
+#define HUFFMAN_TABLE_BITS 8U
+#define HUFFMAN_TABLE_MASK 0xff
 
 #define CODE_LENGTH_CODES 18
 static const uint8_t kCodeLengthCodeOrder[CODE_LENGTH_CODES] = {
@@ -73,10 +70,11 @@ BrotliState* BrotliCreateState(
     state = (BrotliState*)alloc_func(opaque, sizeof(BrotliState));
   }
   if (state == 0) {
-    (void)BROTLI_FAILURE();
+    BROTLI_DUMP();
     return 0;
   }
   BrotliStateInitWithCustomAllocators(state, alloc_func, free_func, opaque);
+  state->error_code = BROTLI_NO_ERROR;
   return state;
 }
 
@@ -92,6 +90,18 @@ void BrotliDestroyState(BrotliState* state) {
   }
 }
 
+/* Saves error code and converts it to BrotliResult */
+static BROTLI_NOINLINE BrotliResult SaveErrorCode(
+    BrotliState* s, BrotliErrorCode e) {
+  s->error_code = (int)e;
+  switch (e) {
+    case BROTLI_SUCCESS: return BROTLI_RESULT_SUCCESS;
+    case BROTLI_NEEDS_MORE_INPUT: return BROTLI_RESULT_NEEDS_MORE_INPUT;
+    case BROTLI_NEEDS_MORE_OUTPUT: return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+    default: return BROTLI_RESULT_ERROR;
+  }
+}
+
 /* Decodes a number in the range [9..24], by reading 1 - 7 bits.
    Precondition: bit-reader accumulator has at least 7 bits. */
 static uint32_t DecodeWindowBits(BrotliBitReader* br) {
@@ -111,51 +121,40 @@ static uint32_t DecodeWindowBits(BrotliBitReader* br) {
   return 17;
 }
 
-static BROTLI_INLINE BROTLI_NO_ASAN void memmove16(
-    uint8_t* dst, uint8_t* src) {
-#if BROTLI_SAFE_MEMMOVE
-  /* For x86 this compiles to the same binary as signle memcpy.
-     On ARM memcpy is not inlined, so it works slower.
-     This implementation makes decompression 1% slower than regular one,
-     and 2% slower than NEON implementation.
-   */
+static BROTLI_INLINE void memmove16(uint8_t* dst, uint8_t* src) {
+#if defined(__ARM_NEON__)
+  vst1q_u8(dst, vld1q_u8(src));
+#else
   uint32_t buffer[4];
   memcpy(buffer, src, 16);
   memcpy(dst, buffer, 16);
-#elif defined(__ARM_NEON__)
-  vst1q_u8(dst, vld1q_u8(src));
-#else
-  /* memcpy is unsafe for overlapping regions and ASAN detects this.
-     But, because of optimizations, it works exactly as memmove:
-     copies data to registers first, and then stores them to dst. */
-  memcpy(dst, src, 16);
 #endif
 }
 
 /* Decodes a number in the range [0..255], by reading 1 - 11 bits. */
-static BROTLI_NOINLINE BrotliResult DecodeVarLenUint8(BrotliState* s,
+static BROTLI_NOINLINE BrotliErrorCode DecodeVarLenUint8(BrotliState* s,
     BrotliBitReader* br, uint32_t* value) {
   uint32_t bits;
   switch (s->substate_decode_uint8) {
     case BROTLI_STATE_DECODE_UINT8_NONE:
       if (PREDICT_FALSE(!BrotliSafeReadBits(br, 1, &bits))) {
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
       if (bits == 0) {
         *value = 0;
-        return BROTLI_RESULT_SUCCESS;
+        return BROTLI_SUCCESS;
       }
       /* No break, transit to the next state. */
 
     case BROTLI_STATE_DECODE_UINT8_SHORT:
       if (PREDICT_FALSE(!BrotliSafeReadBits(br, 3, &bits))) {
         s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_SHORT;
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
       if (bits == 0) {
         *value = 1;
         s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
-        return BROTLI_RESULT_SUCCESS;
+        return BROTLI_SUCCESS;
       }
       /* Use output value as a temporary storage. It MUST be persisted. */
       *value = bits;
@@ -164,27 +163,27 @@ static BROTLI_NOINLINE BrotliResult DecodeVarLenUint8(BrotliState* s,
     case BROTLI_STATE_DECODE_UINT8_LONG:
       if (PREDICT_FALSE(!BrotliSafeReadBits(br, *value, &bits))) {
         s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_LONG;
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
       *value = (1U << *value) + bits;
       s->substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE;
-      return BROTLI_RESULT_SUCCESS;
+      return BROTLI_SUCCESS;
 
     default:
-      return BROTLI_FAILURE();
+      return BROTLI_FAILURE(BROTLI_ERROR_UNREACHABLE);
   }
 }
 
 /* Decodes a metablock length and flags by reading 2 - 31 bits. */
-static BrotliResult BROTLI_NOINLINE DecodeMetaBlockLength(BrotliState* s,
-                                                          BrotliBitReader* br) {
+static BrotliErrorCode BROTLI_NOINLINE DecodeMetaBlockLength(
+    BrotliState* s, BrotliBitReader* br) {
   uint32_t bits;
   int i;
   for (;;) {
     switch (s->substate_metablock_header) {
       case BROTLI_STATE_METABLOCK_HEADER_NONE:
         if (!BrotliSafeReadBits(br, 1, &bits)) {
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         s->is_last_metablock = (uint8_t)bits;
         s->meta_block_remaining_len = 0;
@@ -199,18 +198,18 @@ static BrotliResult BROTLI_NOINLINE DecodeMetaBlockLength(BrotliState* s,
 
       case BROTLI_STATE_METABLOCK_HEADER_EMPTY:
         if (!BrotliSafeReadBits(br, 1, &bits)) {
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         if (bits) {
           s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-          return BROTLI_RESULT_SUCCESS;
+          return BROTLI_SUCCESS;
         }
         s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NIBBLES;
         /* No break, transit to the next state. */
 
       case BROTLI_STATE_METABLOCK_HEADER_NIBBLES:
         if (!BrotliSafeReadBits(br, 2, &bits)) {
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         s->size_nibbles = (uint8_t)(bits + 4);
         s->loop_counter = 0;
@@ -227,10 +226,10 @@ static BrotliResult BROTLI_NOINLINE DecodeMetaBlockLength(BrotliState* s,
         for (; i < s->size_nibbles; ++i) {
           if (!BrotliSafeReadBits(br, 4, &bits)) {
             s->loop_counter = i;
-            return BROTLI_RESULT_NEEDS_MORE_INPUT;
+            return BROTLI_NEEDS_MORE_INPUT;
           }
           if (i + 1 == s->size_nibbles && s->size_nibbles > 4 && bits == 0) {
-            return BROTLI_FAILURE();
+            return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_EXUBERANT_NIBBLE);
           }
           s->meta_block_remaining_len |= (int)(bits << (i * 4));
         }
@@ -239,33 +238,33 @@ static BrotliResult BROTLI_NOINLINE DecodeMetaBlockLength(BrotliState* s,
         /* No break, transit to the next state. */
 
       case BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED:
-        if (!s->is_last_metablock && !s->is_metadata) {
+        if (!s->is_last_metablock) {
           if (!BrotliSafeReadBits(br, 1, &bits)) {
-            return BROTLI_RESULT_NEEDS_MORE_INPUT;
+            return BROTLI_NEEDS_MORE_INPUT;
           }
           s->is_uncompressed = (uint8_t)bits;
         }
         ++s->meta_block_remaining_len;
         s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-        return BROTLI_RESULT_SUCCESS;
+        return BROTLI_SUCCESS;
 
       case BROTLI_STATE_METABLOCK_HEADER_RESERVED:
         if (!BrotliSafeReadBits(br, 1, &bits)) {
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         if (bits != 0) {
-          return BROTLI_FAILURE();
+          return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_RESERVED);
         }
         s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_BYTES;
         /* No break, transit to the next state. */
 
       case BROTLI_STATE_METABLOCK_HEADER_BYTES:
         if (!BrotliSafeReadBits(br, 2, &bits)) {
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         if (bits == 0) {
           s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
-          return BROTLI_RESULT_SUCCESS;
+          return BROTLI_SUCCESS;
         }
         s->size_nibbles = (uint8_t)bits;
         s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_METADATA;
@@ -276,19 +275,19 @@ static BrotliResult BROTLI_NOINLINE DecodeMetaBlockLength(BrotliState* s,
         for (; i < s->size_nibbles; ++i) {
           if (!BrotliSafeReadBits(br, 8, &bits)) {
             s->loop_counter = i;
-            return BROTLI_RESULT_NEEDS_MORE_INPUT;
+            return BROTLI_NEEDS_MORE_INPUT;
           }
           if (i + 1 == s->size_nibbles && s->size_nibbles > 1 && bits == 0) {
-            return BROTLI_FAILURE();
+            return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_EXUBERANT_META_NIBBLE);
           }
           s->meta_block_remaining_len |= (int)(bits << (i * 8));
         }
-        s->substate_metablock_header =
-            BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED;
-        break;
+        ++s->meta_block_remaining_len;
+        s->substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE;
+        return BROTLI_SUCCESS;
 
       default:
-        return BROTLI_FAILURE();
+        return BROTLI_FAILURE(BROTLI_ERROR_UNREACHABLE);
     }
   }
 }
@@ -371,7 +370,6 @@ static BROTLI_INLINE int SafeReadSymbol(const HuffmanCode* table,
   return SafeDecodeSymbol(table, br, result);
 }
 
-
 /* Makes a look-up in first level Huffman table. Peeks 8 bits. */
 static BROTLI_INLINE void PreloadSymbol(int safe,
                                         const HuffmanCode* table,
@@ -421,8 +419,8 @@ static BROTLI_INLINE uint32_t Log2Floor(uint32_t x) {
    Totally 1..4 symbols are read, 1..10 bits each.
    The list of symbols MUST NOT contain duplicates.
  */
-static BrotliResult ReadSimpleHuffmanSymbols(uint32_t alphabet_size,
-                                             BrotliState* s) {
+static BrotliErrorCode ReadSimpleHuffmanSymbols(uint32_t alphabet_size,
+                                                BrotliState* s) {
   /* max_bits == 1..10; symbol == 0..3; 1..40 bits will be read. */
   BrotliBitReader* br = &s->br;
   uint32_t max_bits = Log2Floor(alphabet_size - 1);
@@ -433,10 +431,10 @@ static BrotliResult ReadSimpleHuffmanSymbols(uint32_t alphabet_size,
     if (PREDICT_FALSE(!BrotliSafeReadBits(br, max_bits, &v))) {
       s->sub_loop_counter = i;
       s->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_READ;
-      return BROTLI_RESULT_NEEDS_MORE_INPUT;
+      return BROTLI_NEEDS_MORE_INPUT;
     }
     if (v >= alphabet_size) {
-      return BROTLI_FAILURE();
+      return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET);
     }
     s->symbols_lists_array[i] = (uint16_t)v;
     BROTLI_LOG_UINT(s->symbols_lists_array[i]);
@@ -447,12 +445,12 @@ static BrotliResult ReadSimpleHuffmanSymbols(uint32_t alphabet_size,
     uint32_t k = i + 1;
     for (; k <= num_symbols; ++k) {
       if (s->symbols_lists_array[i] == s->symbols_lists_array[k]) {
-        return BROTLI_FAILURE();
+        return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME);
       }
     }
   }
 
-  return BROTLI_RESULT_SUCCESS;
+  return BROTLI_SUCCESS;
 }
 
 /* Process single decoded symbol code length:
@@ -473,6 +471,7 @@ static BROTLI_INLINE void ProcessSingleCodeLength(uint32_t code_len,
     *prev_code_len = code_len;
     *space -= 32768U >> code_len;
     code_length_histo[code_len]++;
+    BROTLI_LOG(("[ReadHuffmanCode] code_length[%d] = %d\n", *symbol, code_len));
   }
   (*symbol)++;
 }
@@ -508,11 +507,13 @@ static BROTLI_INLINE void ProcessRepeatedCodeLength(uint32_t code_len,
   *repeat += repeat_delta + 3U;
   repeat_delta = *repeat - old_repeat;
   if (*symbol + repeat_delta > alphabet_size) {
-    (void)BROTLI_FAILURE();
+    BROTLI_DUMP();
     *symbol = alphabet_size;
     *space = 0xFFFFF;
     return;
   }
+  BROTLI_LOG(("[ReadHuffmanCode] code_length[%d..%d] = %d\n",
+              *symbol, *symbol + repeat_delta - 1, *repeat_code_len));
   if (*repeat_code_len != 0) {
     unsigned last = *symbol + repeat_delta;
     int next = next_symbol[*repeat_code_len];
@@ -522,15 +523,15 @@ static BROTLI_INLINE void ProcessRepeatedCodeLength(uint32_t code_len,
     } while (++(*symbol) != last);
     next_symbol[*repeat_code_len] = next;
     *space -= repeat_delta << (15 - *repeat_code_len);
-    code_length_histo[*repeat_code_len] = (uint16_t)
-        (code_length_histo[*repeat_code_len] + repeat_delta);
+    code_length_histo[*repeat_code_len] =
+        (uint16_t)(code_length_histo[*repeat_code_len] + repeat_delta);
   } else {
     *symbol += repeat_delta;
   }
 }
 
 /* Reads and decodes symbol codelengths. */
-static BrotliResult ReadSymbolCodeLengths(
+static BrotliErrorCode ReadSymbolCodeLengths(
     uint32_t alphabet_size, BrotliState* s) {
   BrotliBitReader* br = &s->br;
   uint32_t symbol = s->symbol;
@@ -542,7 +543,7 @@ static BrotliResult ReadSymbolCodeLengths(
   uint16_t* code_length_histo = s->code_length_histo;
   int* next_symbol = s->next_symbol;
   if (!BrotliWarmupBitReader(br)) {
-    return BROTLI_RESULT_NEEDS_MORE_INPUT;
+    return BROTLI_NEEDS_MORE_INPUT;
   }
   while (symbol < alphabet_size && space > 0) {
     const HuffmanCode* p = s->table;
@@ -553,13 +554,13 @@ static BrotliResult ReadSymbolCodeLengths(
       s->prev_code_len = prev_code_len;
       s->repeat_code_len = repeat_code_len;
       s->space = space;
-      return BROTLI_RESULT_NEEDS_MORE_INPUT;
+      return BROTLI_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 */
+    BrotliDropBits(br, p->bits);  /* Use 1..5 bits */
+    code_len = p->value;  /* code_len == 0..17 */
     if (code_len < kCodeLengthRepeatCode) {
       ProcessSingleCodeLength(code_len, &symbol, &repeat, &space,
           &prev_code_len, symbol_lists, code_length_histo, next_symbol);
@@ -573,10 +574,10 @@ static BrotliResult ReadSymbolCodeLengths(
     }
   }
   s->space = space;
-  return BROTLI_RESULT_SUCCESS;
+  return BROTLI_SUCCESS;
 }
 
-static BrotliResult SafeReadSymbolCodeLengths(
+static BrotliErrorCode SafeReadSymbolCodeLengths(
     uint32_t alphabet_size, BrotliState* s) {
   BrotliBitReader* br = &s->br;
   while (s->symbol < alphabet_size && s->space > 0) {
@@ -609,15 +610,15 @@ static BrotliResult SafeReadSymbolCodeLengths(
 
 pullMoreInput:
     if (!BrotliPullByte(br)) {
-      return BROTLI_RESULT_NEEDS_MORE_INPUT;
+      return BROTLI_NEEDS_MORE_INPUT;
     }
   }
-  return BROTLI_RESULT_SUCCESS;
+  return BROTLI_SUCCESS;
 }
 
 /* Reads and decodes 15..18 codes using static prefix code.
    Each code is 2..4 bits long. In total 30..72 bits are used. */
-static BrotliResult ReadCodeLengthCodeLengths(BrotliState* s) {
+static BrotliErrorCode ReadCodeLengthCodeLengths(BrotliState* s) {
   BrotliBitReader* br = &s->br;
   uint32_t num_codes = s->repeat;
   unsigned space = s->space;
@@ -638,7 +639,7 @@ static BrotliResult ReadCodeLengthCodeLengths(BrotliState* s) {
         s->repeat = num_codes;
         s->space = space;
         s->substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX;
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
     }
     v = kCodeLengthPrefixValue[ix];
@@ -656,9 +657,9 @@ static BrotliResult ReadCodeLengthCodeLengths(BrotliState* s) {
     }
   }
   if (!(num_codes == 1 || space == 0)) {
-    return BROTLI_FAILURE();
+    return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_CL_SPACE);
   }
-  return BROTLI_RESULT_SUCCESS;
+  return BROTLI_SUCCESS;
 }
 
 /* Decodes the Huffman tables.
@@ -673,10 +674,10 @@ static BrotliResult ReadCodeLengthCodeLengths(BrotliState* s) {
     B.2) Decoded table is used to decode code lengths of symbols in resulting
          Huffman table. In worst case 3520 bits are read.
 */
-static BrotliResult ReadHuffmanCode(uint32_t alphabet_size,
-                                    HuffmanCode* table,
-                                    uint32_t* opt_table_size,
-                                    BrotliState* s) {
+static BrotliErrorCode ReadHuffmanCode(uint32_t alphabet_size,
+                                       HuffmanCode* table,
+                                       uint32_t* opt_table_size,
+                                       BrotliState* s) {
   BrotliBitReader* br = &s->br;
   /* Unnecessary masking, but might be good for safety. */
   alphabet_size &= 0x3ff;
@@ -684,7 +685,7 @@ static BrotliResult ReadHuffmanCode(uint32_t alphabet_size,
   switch (s->substate_huffman) {
     case BROTLI_STATE_HUFFMAN_NONE:
       if (!BrotliSafeReadBits(br, 2, &s->sub_loop_counter)) {
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
       BROTLI_LOG_UINT(s->sub_loop_counter);
       /* The value is used as follows:
@@ -706,13 +707,13 @@ static BrotliResult ReadHuffmanCode(uint32_t alphabet_size,
       /* Read symbols, codes & code lengths directly. */
       if (!BrotliSafeReadBits(br, 2, &s->symbol)) { /* num_symbols */
         s->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_SIZE;
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
       s->sub_loop_counter = 0;
       /* No break, transit to the next state. */
     case BROTLI_STATE_HUFFMAN_SIMPLE_READ: {
-      BrotliResult result = ReadSimpleHuffmanSymbols(alphabet_size, s);
-      if (result != BROTLI_RESULT_SUCCESS) {
+      BrotliErrorCode result = ReadSimpleHuffmanSymbols(alphabet_size, s);
+      if (result != BROTLI_SUCCESS) {
         return result;
       }
       /* No break, transit to the next state. */
@@ -723,7 +724,7 @@ static BrotliResult ReadHuffmanCode(uint32_t alphabet_size,
         uint32_t bits;
         if (!BrotliSafeReadBits(br, 1, &bits)) {
           s->substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_BUILD;
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         s->symbol += bits;
       }
@@ -734,14 +735,14 @@ static BrotliResult ReadHuffmanCode(uint32_t alphabet_size,
         *opt_table_size = table_size;
       }
       s->substate_huffman = BROTLI_STATE_HUFFMAN_NONE;
-      return BROTLI_RESULT_SUCCESS;
+      return BROTLI_SUCCESS;
     }
 
 Complex: /* Decode Huffman-coded code lengths. */
     case BROTLI_STATE_HUFFMAN_COMPLEX: {
       uint32_t i;
-      BrotliResult result = ReadCodeLengthCodeLengths(s);
-      if (result != BROTLI_RESULT_SUCCESS) {
+      BrotliErrorCode result = ReadCodeLengthCodeLengths(s);
+      if (result != BROTLI_SUCCESS) {
         return result;
       }
       BrotliBuildCodeLengthsHuffmanTable(s->table,
@@ -763,29 +764,29 @@ Complex: /* Decode Huffman-coded code lengths. */
     }
     case BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS: {
       uint32_t table_size;
-      BrotliResult result = ReadSymbolCodeLengths(alphabet_size, s);
-      if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
+      BrotliErrorCode result = ReadSymbolCodeLengths(alphabet_size, s);
+      if (result == BROTLI_NEEDS_MORE_INPUT) {
         result = SafeReadSymbolCodeLengths(alphabet_size, s);
       }
-      if (result != BROTLI_RESULT_SUCCESS) {
+      if (result != BROTLI_SUCCESS) {
         return result;
       }
 
       if (s->space != 0) {
         BROTLI_LOG(("[ReadHuffmanCode] space = %d\n", s->space));
-        return BROTLI_FAILURE();
+        return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_HUFFMAN_SPACE);
       }
-      table_size = BrotliBuildHuffmanTable(table, HUFFMAN_TABLE_BITS,
-          s->symbol_lists, s->code_length_histo);
+      table_size = BrotliBuildHuffmanTable(
+          table, HUFFMAN_TABLE_BITS, s->symbol_lists, s->code_length_histo);
       if (opt_table_size) {
         *opt_table_size = table_size;
       }
       s->substate_huffman = BROTLI_STATE_HUFFMAN_NONE;
-      return BROTLI_RESULT_SUCCESS;
+      return BROTLI_SUCCESS;
     }
 
     default:
-      return BROTLI_FAILURE();
+      return BROTLI_FAILURE(BROTLI_ERROR_UNREACHABLE);
   }
 }
 
@@ -847,7 +848,7 @@ static BROTLI_NOINLINE void InverseMoveToFrontTransform(uint8_t* v,
   /* Reinitialize elements that could have been changed. */
   uint32_t i = 4;
   uint32_t upper_bound = state->mtf_upper_bound;
-  uint8_t* mtf = state->mtf;
+  uint8_t* mtf = &state->mtf[4];  /* Make mtf[-1] addressable. */
   /* Load endian-aware constant. */
   const uint8_t b0123[4] = {0, 1, 2, 3};
   uint32_t pattern;
@@ -868,20 +869,19 @@ static BROTLI_NOINLINE void InverseMoveToFrontTransform(uint8_t* v,
     uint8_t value = mtf[index];
     upper_bound |= v[i];
     v[i] = value;
+    mtf[-1] = value;
     do {
       index--;
       mtf[index + 1] = mtf[index];
-    } while (index > 0);
-    mtf[0] = value;
+    } while (index >= 0);
   }
   /* Remember amount of elements to be reinitialized. */
   state->mtf_upper_bound = upper_bound;
 }
 
-
 /* Decodes a series of Huffman table using ReadHuffmanCode function. */
-static BrotliResult HuffmanTreeGroupDecode(HuffmanTreeGroup* group,
-                                           BrotliState* s) {
+static BrotliErrorCode HuffmanTreeGroupDecode(HuffmanTreeGroup* group,
+                                              BrotliState* s) {
   if (s->substate_tree_group != BROTLI_STATE_TREE_GROUP_LOOP) {
     s->next = group->codes;
     s->htree_index = 0;
@@ -889,15 +889,15 @@ static BrotliResult HuffmanTreeGroupDecode(HuffmanTreeGroup* group,
   }
   while (s->htree_index < group->num_htrees) {
     uint32_t table_size;
-    BrotliResult result =
+    BrotliErrorCode result =
         ReadHuffmanCode(group->alphabet_size, s->next, &table_size, s);
-    if (result != BROTLI_RESULT_SUCCESS) return result;
+    if (result != BROTLI_SUCCESS) return result;
     group->htrees[s->htree_index] = s->next;
     s->next += table_size;
     ++s->htree_index;
   }
   s->substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE;
-  return BROTLI_RESULT_SUCCESS;
+  return BROTLI_SUCCESS;
 }
 
 /* Decodes a context map.
@@ -909,17 +909,17 @@ static BrotliResult HuffmanTreeGroupDecode(HuffmanTreeGroup* group,
     3) Read context map items; "0" values could be run-length encoded.
     4) Optionally, apply InverseMoveToFront transform to the resulting map.
  */
-static BrotliResult DecodeContextMap(uint32_t context_map_size,
-                                     uint32_t* num_htrees,
-                                     uint8_t** context_map_arg,
-                                     BrotliState* s) {
+static BrotliErrorCode DecodeContextMap(uint32_t context_map_size,
+                                        uint32_t* num_htrees,
+                                        uint8_t** context_map_arg,
+                                        BrotliState* s) {
   BrotliBitReader* br = &s->br;
-  BrotliResult result = BROTLI_RESULT_SUCCESS;
+  BrotliErrorCode result = BROTLI_SUCCESS;
 
-  switch((int)s->substate_context_map) {
+  switch ((int)s->substate_context_map) {
     case BROTLI_STATE_CONTEXT_MAP_NONE:
       result = DecodeVarLenUint8(s, br, num_htrees);
-      if (result != BROTLI_RESULT_SUCCESS) {
+      if (result != BROTLI_SUCCESS) {
         return result;
       }
       (*num_htrees)++;
@@ -928,11 +928,11 @@ static BrotliResult DecodeContextMap(uint32_t context_map_size,
       BROTLI_LOG_UINT(*num_htrees);
       *context_map_arg = (uint8_t*)BROTLI_ALLOC(s, (size_t)context_map_size);
       if (*context_map_arg == 0) {
-        return BROTLI_FAILURE();
+        return BROTLI_FAILURE(BROTLI_ERROR_ALLOC_CONTEXT_MAP);
       }
       if (*num_htrees <= 1) {
         memset(*context_map_arg, 0, (size_t)context_map_size);
-        return BROTLI_RESULT_SUCCESS;
+        return BROTLI_SUCCESS;
       }
       s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_READ_PREFIX;
       /* No break, continue to next state. */
@@ -941,7 +941,7 @@ static BrotliResult DecodeContextMap(uint32_t context_map_size,
       /* In next stage ReadHuffmanCode uses at least 4 bits, so it is safe
          to peek 4 bits ahead. */
       if (!BrotliSafeGetBits(br, 5, &bits)) {
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
       if ((bits & 1) != 0) { /* Use RLE for zeroes. */
         s->max_run_length_prefix = (bits >> 1) + 1;
@@ -957,7 +957,7 @@ static BrotliResult DecodeContextMap(uint32_t context_map_size,
     case BROTLI_STATE_CONTEXT_MAP_HUFFMAN:
       result = ReadHuffmanCode(*num_htrees + s->max_run_length_prefix,
                                s->context_map_table, NULL, s);
-      if (result != BROTLI_RESULT_SUCCESS) return result;
+      if (result != BROTLI_SUCCESS) return result;
       s->code = 0xFFFF;
       s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_DECODE;
       /* No break, continue to next state. */
@@ -973,7 +973,7 @@ static BrotliResult DecodeContextMap(uint32_t context_map_size,
         if (!SafeReadSymbol(s->context_map_table, br, &code)) {
           s->code = 0xFFFF;
           s->context_index = context_index;
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         BROTLI_LOG_UINT(code);
 
@@ -992,12 +992,12 @@ rleCode:
           if (!BrotliSafeReadBits(br, code, &reps)) {
             s->code = code;
             s->context_index = context_index;
-            return BROTLI_RESULT_NEEDS_MORE_INPUT;
+            return BROTLI_NEEDS_MORE_INPUT;
           }
           reps += 1U << code;
           BROTLI_LOG_UINT(reps);
           if (context_index + reps > context_map_size) {
-            return BROTLI_FAILURE();
+            return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_CONTEXT_MAP_REPEAT);
           }
           do {
             context_map[context_index++] = 0;
@@ -1010,17 +1010,17 @@ rleCode:
       uint32_t bits;
       if (!BrotliSafeReadBits(br, 1, &bits)) {
         s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_TRANSFORM;
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
+        return BROTLI_NEEDS_MORE_INPUT;
       }
       if (bits != 0) {
         InverseMoveToFrontTransform(*context_map_arg, context_map_size, s);
       }
       s->substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE;
-      return BROTLI_RESULT_SUCCESS;
+      return BROTLI_SUCCESS;
     }
+    default:
+      return BROTLI_FAILURE(BROTLI_ERROR_UNREACHABLE);
   }
-
-  return BROTLI_FAILURE();
 }
 
 /* Decodes a command or literal and updates block type ringbuffer.
@@ -1028,9 +1028,10 @@ rleCode:
 static BROTLI_INLINE int DecodeBlockTypeAndLength(int safe,
     BrotliState* s, int tree_type) {
   uint32_t max_block_type = s->num_block_types[tree_type];
-  int tree_offset = tree_type * BROTLI_HUFFMAN_MAX_TABLE_SIZE;
-  const HuffmanCode* type_tree = &s->block_type_trees[tree_offset];
-  const HuffmanCode* len_tree = &s->block_len_trees[tree_offset];
+  const HuffmanCode* type_tree = &s->block_type_trees[
+      tree_type * BROTLI_HUFFMAN_MAX_SIZE_258];
+  const HuffmanCode* len_tree = &s->block_len_trees[
+      tree_type * BROTLI_HUFFMAN_MAX_SIZE_26];
   BrotliBitReader* br = &s->br;
   uint32_t* ringbuffer = &s->block_type_rb[tree_type * 2];
   uint32_t block_type;
@@ -1065,22 +1066,45 @@ static BROTLI_INLINE int DecodeBlockTypeAndLength(int safe,
   return 1;
 }
 
+static BROTLI_INLINE void DetectTrivialLiteralBlockTypes(BrotliState* s) {
+  size_t i;
+  for (i = 0; i < 8; ++i) s->trivial_literal_contexts[i] = 0;
+  for (i = 0; i < s->num_block_types[0]; i++) {
+    size_t offset = i << kLiteralContextBits;
+    size_t error = 0;
+    size_t sample = s->context_map[offset];
+    size_t j;
+    for (j = 0; j < (1u << kLiteralContextBits);) {
+      BROTLI_REPEAT(4, error |= s->context_map[offset + j++] ^ sample;)
+    }
+    if (error == 0) {
+      s->trivial_literal_contexts[i >> 5] |= 1u << (i & 31);
+    }
+  }
+}
+
+static BROTLI_INLINE void PrepareLiteralDecoding(BrotliState* s) {
+  uint8_t context_mode;
+  size_t trivial;
+  uint32_t block_type = s->block_type_rb[1];
+  uint32_t context_offset = block_type << kLiteralContextBits;
+  s->context_map_slice = s->context_map + context_offset;
+  trivial = s->trivial_literal_contexts[block_type >> 5];
+  s->trivial_literal_context = (trivial >> (block_type & 31)) & 1;
+  s->literal_htree = s->literal_hgroup.htrees[s->context_map_slice[0]];
+  context_mode = s->context_modes[block_type];
+  s->context_lookup1 = &kContextLookup[kContextLookupOffsets[context_mode]];
+  s->context_lookup2 = &kContextLookup[kContextLookupOffsets[context_mode + 1]];
+}
+
 /* Decodes the block type and updates the state for literal context.
    Reads 3..54 bits. */
 static BROTLI_INLINE int DecodeLiteralBlockSwitchInternal(int safe,
     BrotliState* s) {
-  uint8_t context_mode;
-  uint32_t context_offset;
   if (!DecodeBlockTypeAndLength(safe, s, 0)) {
     return 0;
   }
-  context_offset = s->block_type_rb[1] << kLiteralContextBits;
-  s->context_map_slice = s->context_map + context_offset;
-  s->literal_htree_index = s->context_map_slice[0];
-  s->literal_htree = s->literal_hgroup.htrees[s->literal_htree_index];
-  context_mode = s->context_modes[s->block_type_rb[1]];
-  s->context_lookup1 = &kContextLookup[kContextLookupOffsets[context_mode]];
-  s->context_lookup2 = &kContextLookup[kContextLookupOffsets[context_mode + 1]];
+  PrepareLiteralDecoding(s);
   return 1;
 }
 
@@ -1131,38 +1155,81 @@ static int BROTLI_NOINLINE SafeDecodeDistanceBlockSwitch(BrotliState* s) {
   return DecodeDistanceBlockSwitchInternal(1, s);
 }
 
-static BrotliResult WriteRingBuffer(size_t* available_out, uint8_t** next_out,
-    size_t* total_out, BrotliState* s) {
-  size_t pos = (s->pos > s->ringbuffer_size) ?
-      (size_t)s->ringbuffer_size : (size_t)(s->pos);
-  uint8_t* start = s->ringbuffer
-      + (s->partial_pos_out & (size_t)s->ringbuffer_mask);
-  size_t partial_pos_rb =
-      (s->rb_roundtrips * (size_t)s->ringbuffer_size) + pos;
+static BrotliErrorCode BROTLI_NOINLINE WriteRingBuffer(size_t* available_out,
+    uint8_t** next_out, size_t* total_out, BrotliState* s) {
+  size_t pos = (s->pos > s->ringbuffer_size) ? (size_t)s->ringbuffer_size
+                                             : (size_t)(s->pos);
+  uint8_t* start =
+      s->ringbuffer + (s->partial_pos_out & (size_t)s->ringbuffer_mask);
+  size_t partial_pos_rb = (s->rb_roundtrips * (size_t)s->ringbuffer_size) + pos;
   size_t to_write = (partial_pos_rb - s->partial_pos_out);
   size_t num_written = *available_out;
   if (num_written > to_write) {
     num_written = to_write;
   }
   if (s->meta_block_remaining_len < 0) {
-    return BROTLI_FAILURE();
+    return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_BLOCK_LENGTH_1);
   }
   memcpy(*next_out, start, num_written);
   *next_out += num_written;
   *available_out -= num_written;
   BROTLI_LOG_UINT(to_write);
   BROTLI_LOG_UINT(num_written);
-  s->partial_pos_out += (size_t)num_written;
-  *total_out = s->partial_pos_out;
+  s->partial_pos_out += num_written;
+  if (total_out) *total_out = s->partial_pos_out;
   if (num_written < to_write) {
-    return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+    return BROTLI_NEEDS_MORE_OUTPUT;
   }
-  return BROTLI_RESULT_SUCCESS;
+
+  if (s->pos >= s->ringbuffer_size) {
+    s->pos -= s->ringbuffer_size;
+    s->rb_roundtrips++;
+  }
+  return BROTLI_SUCCESS;
 }
 
-static BrotliResult BROTLI_NOINLINE CopyUncompressedBlockToOutput(
+/* Allocates ringbuffer.
+
+  s->ringbuffer_size MUST be updated by BrotliCalculateRingBufferSize before
+  this function is called.
+
+   Last two bytes of ringbuffer are initialized to 0, so context calculation
+   could be done uniformly for the first two and all other positions.
+
+   Custom dictionary, if any, is copied to the end of ringbuffer.
+*/
+static int BROTLI_NOINLINE BrotliAllocateRingBuffer(BrotliState* s) {
+  /* 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) */
+  static const int kRingBufferWriteAheadSlack = 42;
+  s->ringbuffer = (uint8_t*)BROTLI_ALLOC(s, (size_t)(s->ringbuffer_size +
+      kRingBufferWriteAheadSlack));
+  if (s->ringbuffer == 0) {
+    return 0;
+  }
+
+  s->ringbuffer_end = s->ringbuffer + s->ringbuffer_size;
+
+  s->ringbuffer[s->ringbuffer_size - 2] = 0;
+  s->ringbuffer[s->ringbuffer_size - 1] = 0;
+
+  if (s->custom_dict) {
+    memcpy(&s->ringbuffer[(-s->custom_dict_size) & s->ringbuffer_mask],
+           s->custom_dict, (size_t)s->custom_dict_size);
+  }
+
+  return 1;
+}
+
+static BrotliErrorCode BROTLI_NOINLINE CopyUncompressedBlockToOutput(
     size_t* available_out, uint8_t** next_out, size_t* total_out,
     BrotliState* s) {
+  /* TODO: avoid allocation for single uncompressed block. */
+  if (!s->ringbuffer && !BrotliAllocateRingBuffer(s)) {
+    return BROTLI_FAILURE(BROTLI_ERROR_ALLOC_RING_BUFFER_1);
+  }
+
   /* State machine */
   for (;;) {
     switch (s->substate_uncompressed) {
@@ -1180,29 +1247,26 @@ static BrotliResult BROTLI_NOINLINE CopyUncompressedBlockToOutput(
         s->meta_block_remaining_len -= nbytes;
         if (s->pos < s->ringbuffer_size) {
           if (s->meta_block_remaining_len == 0) {
-            return BROTLI_RESULT_SUCCESS;
+            return BROTLI_SUCCESS;
           }
-          return BROTLI_RESULT_NEEDS_MORE_INPUT;
+          return BROTLI_NEEDS_MORE_INPUT;
         }
         s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_WRITE;
-        /*s->partial_pos_rb += (size_t)s->ringbuffer_size;*/
         /* No break, continue to next state */
       }
       case BROTLI_STATE_UNCOMPRESSED_WRITE: {
-        BrotliResult result = WriteRingBuffer(
-            available_out, next_out, total_out, s);
-        if (result != BROTLI_RESULT_SUCCESS) {
+        BrotliErrorCode result =
+            WriteRingBuffer(available_out, next_out, total_out, s);
+        if (result != BROTLI_SUCCESS) {
           return result;
         }
-        s->pos = 0;
-        s->rb_roundtrips++;
         s->max_distance = s->max_backward_distance;
         s->substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_NONE;
         break;
       }
     }
   }
-  return BROTLI_FAILURE();
+  BROTLI_DCHECK(0);  /* Unreachable */
 }
 
 int BrotliDecompressedSize(size_t encoded_size,
@@ -1217,7 +1281,7 @@ int BrotliDecompressedSize(size_t encoded_size,
     return 0;
   }
   DecodeWindowBits(&s.br);
-  if (DecodeMetaBlockLength(&s, &s.br) != BROTLI_RESULT_SUCCESS) {
+  if (DecodeMetaBlockLength(&s, &s.br) != BROTLI_SUCCESS) {
     return 0;
   }
   *decoded_size = (size_t)s.meta_block_remaining_len;
@@ -1231,29 +1295,24 @@ int BrotliDecompressedSize(size_t encoded_size,
   return (next_block_header != -1) && ((next_block_header & 3) == 3);
 }
 
-/* Allocates the smallest feasible ring buffer.
+/* Calculates the smallest feasible ring buffer.
 
    If we know the data size is small, do not allocate more ringbuffer
    size than needed to reduce memory usage.
 
-   This method is called before the first non-empty non-metadata block is
-   processed. When this method is called, metablock size and flags MUST be
-   decoded.
+   When this method is called, metablock size and flags MUST be decoded.
 */
-static int BROTLI_NOINLINE BrotliAllocateRingBuffer(BrotliState* s,
+static void BROTLI_NOINLINE BrotliCalculateRingBufferSize(BrotliState* s,
     BrotliBitReader* br) {
-  /* 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) */
-  static const int kRingBufferWriteAheadSlack = 42;
   int is_last = s->is_last_metablock;
-  s->ringbuffer_size = 1 << s->window_bits;
+  int window_size = 1 << s->window_bits;
+  s->ringbuffer_size = window_size;
 
   if (s->is_uncompressed) {
-    int next_block_header = BrotliPeekByte(br,
-        (size_t)s->meta_block_remaining_len);
-    if (next_block_header != -1) { /* Peek succeeded */
-      if ((next_block_header & 3) == 3) { /* ISLAST and ISEMPTY */
+    int next_block_header =
+        BrotliPeekByte(br, (size_t)s->meta_block_remaining_len);
+    if (next_block_header != -1) {  /* Peek succeeded */
+      if ((next_block_header & 3) == 3) {  /* ISLAST and ISEMPTY */
         is_last = 1;
       }
     }
@@ -1262,36 +1321,17 @@ static int BROTLI_NOINLINE BrotliAllocateRingBuffer(BrotliState* s,
   /* We need at least 2 bytes of ring buffer size to get the last two
      bytes for context from there */
   if (is_last) {
-    while (s->ringbuffer_size >= s->meta_block_remaining_len * 2
-        && s->ringbuffer_size > 32) {
+    int min_size_x2 = (s->meta_block_remaining_len + s->custom_dict_size) * 2;
+    while (s->ringbuffer_size >= min_size_x2 && s->ringbuffer_size > 32) {
       s->ringbuffer_size >>= 1;
     }
   }
 
-  /* But make it fit the custom dictionary if there is one. */
-  while (s->ringbuffer_size < s->custom_dict_size) {
-    s->ringbuffer_size <<= 1;
-  }
-
   s->ringbuffer_mask = s->ringbuffer_size - 1;
-  s->ringbuffer = (uint8_t*)BROTLI_ALLOC(s, (size_t)(s->ringbuffer_size +
-      kRingBufferWriteAheadSlack + kBrotliMaxDictionaryWordLength));
-  if (s->ringbuffer == 0) {
-    return 0;
-  }
-  s->ringbuffer_end = s->ringbuffer + s->ringbuffer_size;
-  s->ringbuffer[s->ringbuffer_size - 2] = 0;
-  s->ringbuffer[s->ringbuffer_size - 1] = 0;
-  if (s->custom_dict) {
-    memcpy(&s->ringbuffer[(-s->custom_dict_size) & s->ringbuffer_mask],
-                          s->custom_dict, (size_t)s->custom_dict_size);
-  }
-
-  return 1;
 }
 
 /* Reads 1..256 2-bit context modes. */
-static BrotliResult ReadContextModes(BrotliState* s) {
+static BrotliErrorCode ReadContextModes(BrotliState* s) {
   BrotliBitReader* br = &s->br;
   int i = s->loop_counter;
 
@@ -1299,13 +1339,13 @@ static BrotliResult ReadContextModes(BrotliState* s) {
     uint32_t bits;
     if (!BrotliSafeReadBits(br, 2, &bits)) {
       s->loop_counter = i;
-      return BROTLI_RESULT_NEEDS_MORE_INPUT;
+      return BROTLI_NEEDS_MORE_INPUT;
     }
     s->context_modes[i] = (uint8_t)(bits << 1);
     BROTLI_LOG_ARRAY_INDEX(s->context_modes, i);
     i++;
   }
-  return BROTLI_RESULT_SUCCESS;
+  return BROTLI_SUCCESS;
 }
 
 static BROTLI_INLINE void TakeDistanceFromRingBuffer(BrotliState* s) {
@@ -1378,8 +1418,8 @@ static BROTLI_INLINE int ReadDistanceInternal(int safe,
     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);
+      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;
@@ -1461,13 +1501,6 @@ static BROTLI_INLINE int SafeReadCommand(BrotliState* s, BrotliBitReader* br,
   return ReadCommandInternal(1, s, br, insert_length);
 }
 
-static BROTLI_INLINE int WarmupBitReader(int safe, BrotliBitReader* const br) {
-  if (safe) {
-    return 1;
-  }
-  return BrotliWarmupBitReader(br);
-}
-
 static BROTLI_INLINE int CheckInputAmount(int safe,
     BrotliBitReader* const br, size_t num) {
   if (safe) {
@@ -1476,28 +1509,32 @@ static BROTLI_INLINE int CheckInputAmount(int safe,
   return BrotliCheckInputAmount(br, num);
 }
 
-#define BROTLI_SAFE(METHOD) { \
-  if (safe) { \
-    if (! Safe ## METHOD ) { \
-      result = BROTLI_RESULT_NEEDS_MORE_INPUT; \
-      goto saveStateAndReturn; \
-    } \
-  } else { \
-    METHOD ; \
-  } \
-}
+#define BROTLI_SAFE(METHOD)               \
+  {                                       \
+    if (safe) {                           \
+      if (!Safe##METHOD) {                \
+        result = BROTLI_NEEDS_MORE_INPUT; \
+        goto saveStateAndReturn;          \
+      }                                   \
+    } else {                              \
+      METHOD;                             \
+    }                                     \
+  }
 
-static BROTLI_INLINE BrotliResult ProcessCommandsInternal(int safe,
+static BROTLI_INLINE BrotliErrorCode ProcessCommandsInternal(int safe,
     BrotliState* s) {
   int pos = s->pos;
   int i = s->loop_counter;
-  BrotliResult result = BROTLI_RESULT_SUCCESS;
+  BrotliErrorCode result = BROTLI_SUCCESS;
   BrotliBitReader* br = &s->br;
 
-  if (!CheckInputAmount(safe, br, 28) || !WarmupBitReader(safe, br)) {
-    result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+  if (!CheckInputAmount(safe, br, 28)) {
+    result = BROTLI_NEEDS_MORE_INPUT;
     goto saveStateAndReturn;
   }
+  if (!safe) {
+    BROTLI_UNUSED(BrotliWarmupBitReader(br));
+  }
 
   /* Jump into state machine. */
   if (s->state == BROTLI_STATE_COMMAND_BEGIN) {
@@ -1509,7 +1546,7 @@ static BROTLI_INLINE BrotliResult ProcessCommandsInternal(int safe,
   } else if (s->state == BROTLI_STATE_COMMAND_POST_WRAP_COPY) {
     goto CommandPostWrapCopy;
   } else {
-    return BROTLI_FAILURE();
+    return BROTLI_FAILURE(BROTLI_ERROR_UNREACHABLE);
   }
 
 CommandBegin:
@@ -1518,7 +1555,7 @@ CommandBegin:
   }
   if (!CheckInputAmount(safe, br, 28)) { /* 156 bits + 7 bytes */
     s->state = BROTLI_STATE_COMMAND_BEGIN;
-    result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+    result = BROTLI_NEEDS_MORE_INPUT;
     goto saveStateAndReturn;
   }
   if (PREDICT_FALSE(s->block_length[1] == 0)) {
@@ -1527,9 +1564,8 @@ CommandBegin:
   }
   /* Read the insert/copy length in the command */
   BROTLI_SAFE(ReadCommand(s, br, &i));
-  BROTLI_LOG_UINT(i);
-  BROTLI_LOG_UINT(s->copy_length);
-  BROTLI_LOG_UINT(s->distance_code);
+  BROTLI_LOG(("[ProcessCommandsInternal] pos = %d insert = %d copy = %d\n",
+              pos, i, s->copy_length));
   if (i == 0) {
     goto CommandPostDecodeLiterals;
   }
@@ -1547,26 +1583,26 @@ CommandInner:
     do {
       if (!CheckInputAmount(safe, br, 28)) { /* 162 bits + 7 bytes */
         s->state = BROTLI_STATE_COMMAND_INNER;
-        result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+        result = BROTLI_NEEDS_MORE_INPUT;
         goto saveStateAndReturn;
       }
       if (PREDICT_FALSE(s->block_length[0] == 0)) {
         BROTLI_SAFE(DecodeLiteralBlockSwitch(s));
         PreloadSymbol(safe, s->literal_htree, br, &bits, &value);
+        if (!s->trivial_literal_context) goto CommandInner;
       }
       if (!safe) {
-        s->ringbuffer[pos] = (uint8_t)ReadPreloadedSymbol(
-            s->literal_htree, br, &bits, &value);
+        s->ringbuffer[pos] =
+            (uint8_t)ReadPreloadedSymbol(s->literal_htree, br, &bits, &value);
       } else {
         uint32_t literal;
         if (!SafeReadSymbol(s->literal_htree, br, &literal)) {
-          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+          result = BROTLI_NEEDS_MORE_INPUT;
           goto saveStateAndReturn;
         }
         s->ringbuffer[pos] = (uint8_t)literal;
       }
       --s->block_length[0];
-      BROTLI_LOG_UINT(s->literal_htree_index);
       BROTLI_LOG_ARRAY_INDEX(s->ringbuffer, pos);
       ++pos;
       if (PREDICT_FALSE(pos == s->ringbuffer_size)) {
@@ -1583,11 +1619,12 @@ CommandInner:
       uint8_t context;
       if (!CheckInputAmount(safe, br, 28)) { /* 162 bits + 7 bytes */
         s->state = BROTLI_STATE_COMMAND_INNER;
-        result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+        result = BROTLI_NEEDS_MORE_INPUT;
         goto saveStateAndReturn;
       }
       if (PREDICT_FALSE(s->block_length[0] == 0)) {
         BROTLI_SAFE(DecodeLiteralBlockSwitch(s));
+        if (s->trivial_literal_context) goto CommandInner;
       }
       context = s->context_lookup1[p1] | s->context_lookup2[p2];
       BROTLI_LOG_UINT(context);
@@ -1598,7 +1635,7 @@ CommandInner:
       } else {
         uint32_t literal;
         if (!SafeReadSymbol(hc, br, &literal)) {
-          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+          result = BROTLI_NEEDS_MORE_INPUT;
           goto saveStateAndReturn;
         }
         p1 = (uint8_t)literal;
@@ -1615,7 +1652,8 @@ CommandInner:
       }
     } while (--i != 0);
   }
-  if (s->meta_block_remaining_len <= 0) {
+  BROTLI_LOG_UINT(s->meta_block_remaining_len);
+  if (PREDICT_FALSE(s->meta_block_remaining_len <= 0)) {
     s->state = BROTLI_STATE_METABLOCK_DONE;
     goto saveStateAndReturn;
   }
@@ -1635,7 +1673,8 @@ CommandPostDecodeLiterals:
   }
   BROTLI_SAFE(ReadDistance(s, br));
 postReadDistance:
-  BROTLI_LOG_UINT(s->distance_code);
+  BROTLI_LOG(("[ProcessCommandsInternal] pos = %d distance = %d\n",
+              pos, s->distance_code));
   if (s->max_distance != s->max_backward_distance) {
     if (pos < s->max_backward_distance_minus_custom_dict_size) {
       s->max_distance = pos + s->custom_dict_size;
@@ -1649,7 +1688,7 @@ postReadDistance:
   if (s->distance_code > s->max_distance) {
     if (i >= kBrotliMinDictionaryWordLength &&
         i <= kBrotliMaxDictionaryWordLength) {
-      int offset = kBrotliDictionaryOffsetsByLength[i];
+      int offset = (int)kBrotliDictionaryOffsetsByLength[i];
       int word_id = s->distance_code - s->max_distance - 1;
       uint32_t shift = kBrotliDictionarySizeBitsByLength[i];
       int mask = (int)BitMask(shift);
@@ -1674,54 +1713,38 @@ postReadDistance:
         }
       } else {
         BROTLI_LOG(("Invalid backward reference. pos: %d distance: %d "
-               "len: %d bytes left: %d\n",
-            pos, s->distance_code, i,
-            s->meta_block_remaining_len));
-        return BROTLI_FAILURE();
+            "len: %d bytes left: %d\n",
+            pos, s->distance_code, i, s->meta_block_remaining_len));
+        return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_TRANSFORM);
       }
     } else {
       BROTLI_LOG(("Invalid backward reference. pos: %d distance: %d "
-             "len: %d bytes left: %d\n", pos, s->distance_code, i,
-             s->meta_block_remaining_len));
-      return BROTLI_FAILURE();
+          "len: %d bytes left: %d\n",
+          pos, s->distance_code, i, s->meta_block_remaining_len));
+      return BROTLI_FAILURE(BROTLI_ERROR_FORMAT_DICTIONARY);
     }
   } else {
-    const uint8_t *ringbuffer_end_minus_copy_length =
-        s->ringbuffer_end - i;
-    uint8_t* copy_src = &s->ringbuffer[
-        (pos - s->distance_code) & s->ringbuffer_mask];
+    int src_start = (pos - s->distance_code) & s->ringbuffer_mask;
     uint8_t* copy_dst = &s->ringbuffer[pos];
+    uint8_t* copy_src = &s->ringbuffer[src_start];
+    int dst_end = pos + i;
+    int src_end = src_start + i;
     /* update the recent distances cache */
     s->dist_rb[s->dist_rb_idx & 3] = s->distance_code;
     ++s->dist_rb_idx;
     s->meta_block_remaining_len -= i;
-    if (PREDICT_FALSE(s->meta_block_remaining_len < 0)) {
-      BROTLI_LOG(("Invalid backward reference. pos: %d distance: %d "
-             "len: %d bytes left: %d\n", pos, s->distance_code, i,
-             s->meta_block_remaining_len));
-      return BROTLI_FAILURE();
-    }
-    /* There is 128+ bytes of slack in the ringbuffer allocation.
+    /* There are 32+ bytes of slack in the ringbuffer allocation.
        Also, we have 16 short codes, that make these 16 bytes irrelevant
        in the ringbuffer. Let's copy over them as a first guess.
      */
     memmove16(copy_dst, copy_src);
-    /* Now check if the copy extends over the ringbuffer end,
-       or if the copy overlaps with itself, if yes, do wrap-copy. */
-    if (copy_src < copy_dst) {
-      if (copy_dst >= ringbuffer_end_minus_copy_length) {
-        goto CommandPostWrapCopy;
-      }
-      if (copy_src + i > copy_dst) {
-        goto postSelfintersecting;
-      }
-    } else {
-      if (copy_src >= ringbuffer_end_minus_copy_length) {
-        goto CommandPostWrapCopy;
-      }
-      if (copy_dst + i > copy_src) {
-        goto postSelfintersecting;
-      }
+    if (src_end > pos && dst_end > src_start) {
+      /* Regions intersect. */
+      goto CommandPostWrapCopy;
+    }
+    if (dst_end >= s->ringbuffer_size || src_end >= s->ringbuffer_size) {
+      /* At least one region wraps. */
+      goto CommandPostWrapCopy;
     }
     pos += i;
     if (i > 16) {
@@ -1734,6 +1757,7 @@ postReadDistance:
       }
     }
   }
+  BROTLI_LOG_UINT(s->meta_block_remaining_len);
   if (s->meta_block_remaining_len <= 0) {
     /* Next metablock, if any */
     s->state = BROTLI_STATE_METABLOCK_DONE;
@@ -1741,30 +1765,17 @@ postReadDistance:
   } else {
     goto CommandBegin;
   }
-postSelfintersecting:
-  while (--i >= 0) {
-    s->ringbuffer[pos] =
-        s->ringbuffer[(pos - s->distance_code) & s->ringbuffer_mask];
-    ++pos;
-  }
-  if (s->meta_block_remaining_len <= 0) {
-    /* Next metablock, if any */
-    s->state = BROTLI_STATE_METABLOCK_DONE;
-    goto saveStateAndReturn;
-  } else {
-    goto CommandBegin;
-  }
-
 CommandPostWrapCopy:
-  s->state = BROTLI_STATE_COMMAND_POST_WRAP_COPY;
-  while (--i >= 0) {
-    s->ringbuffer[pos] =
-        s->ringbuffer[(pos - s->distance_code) & s->ringbuffer_mask];
-    ++pos;
-    if (pos == s->ringbuffer_size) {
-      /*s->partial_pos_rb += (size_t)s->ringbuffer_size;*/
-      s->state = BROTLI_STATE_COMMAND_POST_WRITE_2;
-      goto saveStateAndReturn;
+  {
+    int wrap_guard = s->ringbuffer_size - pos;
+    while (--i >= 0) {
+      s->ringbuffer[pos] =
+          s->ringbuffer[(pos - s->distance_code) & s->ringbuffer_mask];
+      ++pos;
+      if (PREDICT_FALSE(--wrap_guard == 0)) {
+        s->state = BROTLI_STATE_COMMAND_POST_WRITE_2;
+        goto saveStateAndReturn;
+      }
     }
   }
   if (s->meta_block_remaining_len <= 0) {
@@ -1783,11 +1794,11 @@ saveStateAndReturn:
 
 #undef BROTLI_SAFE
 
-static BROTLI_NOINLINE BrotliResult ProcessCommands(BrotliState* s) {
+static BROTLI_NOINLINE BrotliErrorCode ProcessCommands(BrotliState* s) {
   return ProcessCommandsInternal(0, s);
 }
 
-static BROTLI_NOINLINE BrotliResult SafeProcessCommands(BrotliState* s) {
+static BROTLI_NOINLINE BrotliErrorCode SafeProcessCommands(BrotliState* s) {
   return ProcessCommandsInternal(1, s);
 }
 
@@ -1813,113 +1824,6 @@ BrotliResult BrotliDecompressBuffer(size_t encoded_size,
   return result;
 }
 
-BrotliResult BrotliDecompress(BrotliInput input, BrotliOutput output) {
-  BrotliState s;
-  BrotliResult result;
-  BrotliStateInit(&s);
-  result = BrotliDecompressStreaming(input, output, 1, &s);
-  if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
-    /* Not ok: it didn't finish even though this is a non-streaming function. */
-    result = BROTLI_FAILURE();
-  }
-  BrotliStateCleanup(&s);
-  return result;
-}
-
-BrotliResult BrotliDecompressBufferStreaming(size_t* available_in,
-                                             const uint8_t** next_in,
-                                             int finish,
-                                             size_t* available_out,
-                                             uint8_t** next_out,
-                                             size_t* total_out,
-                                             BrotliState* s) {
-  BrotliResult result = BrotliDecompressStream(available_in, next_in,
-      available_out, next_out, total_out, s);
-  if (finish && result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
-    result = BROTLI_FAILURE();
-  }
-  return result;
-}
-
-BrotliResult BrotliDecompressStreaming(BrotliInput input, BrotliOutput output,
-                                       int finish, BrotliState* s) {
-  const size_t kBufferSize = 65536;
-  BrotliResult result;
-  uint8_t* input_buffer;
-  uint8_t* output_buffer;
-  size_t avail_in;
-  const uint8_t* next_in;
-  size_t total_out;
-
-  if (s->legacy_input_buffer == 0) {
-    s->legacy_input_buffer = (uint8_t*)BROTLI_ALLOC(s, kBufferSize);
-  }
-  if (s->legacy_output_buffer == 0) {
-    s->legacy_output_buffer = (uint8_t*)BROTLI_ALLOC(s, kBufferSize);
-  }
-  if (s->legacy_input_buffer == 0 || s->legacy_output_buffer == 0) {
-    return BROTLI_FAILURE();
-  }
-  input_buffer = s->legacy_input_buffer;
-  output_buffer = s->legacy_output_buffer;
-
-  /* Push remaining output. */
-  if (s->legacy_output_len > s->legacy_output_pos) {
-    size_t to_write = s->legacy_output_len - s->legacy_output_pos;
-    int num_written = BrotliWrite(
-        output, output_buffer + s->legacy_output_pos, to_write);
-    if (num_written < 0) {
-      return BROTLI_FAILURE();
-    }
-    s->legacy_output_pos += (size_t)num_written;
-    if ((size_t)num_written < to_write) {
-      return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
-    }
-  }
-  s->legacy_output_pos = 0;
-
-  avail_in = s->legacy_input_len - s->legacy_input_pos;
-  next_in = input_buffer + s->legacy_input_pos;
-
-  while (1) {
-    size_t to_write;
-    int num_written;
-    size_t avail_out = kBufferSize;
-    uint8_t* next_out = output_buffer;
-    result = BrotliDecompressStream(&avail_in, &next_in,
-        &avail_out, &next_out, &total_out, s);
-    s->legacy_input_pos = (size_t)(next_out - input_buffer);
-    to_write = (size_t)(next_out - output_buffer);
-    num_written = BrotliWrite(output, output_buffer, to_write);
-    if (num_written < 0) {
-      return BROTLI_FAILURE();
-    }
-    if ((size_t)num_written < to_write) {
-      s->legacy_output_len = to_write;
-      s->legacy_output_pos = (size_t)num_written;
-      return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
-    }
-    if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
-      int num_read = BrotliRead(input, input_buffer, kBufferSize);
-      if (num_read < 0 || (num_read == 0 && finish)) {
-        return BROTLI_FAILURE();
-      }
-      if (num_read == 0) {
-        s->legacy_input_len = 0;
-        s->legacy_input_pos = 0;
-        return BROTLI_RESULT_NEEDS_MORE_INPUT;
-      }
-      avail_in = (size_t)num_read;
-      next_in = input_buffer;
-      s->legacy_input_len = avail_in;
-      s->legacy_input_pos = 0;
-    } else if (result != BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
-      /* Success or failure. */
-      return result;
-    }
-  }
-}
-
 /* Invariant: input stream is never overconsumed:
     * invalid input implies that the whole stream is invalid -> any amount of
       input could be read and discarded
@@ -1935,7 +1839,7 @@ BrotliResult BrotliDecompressStreaming(BrotliInput input, BrotliOutput output,
 BrotliResult BrotliDecompressStream(size_t* available_in,
     const uint8_t** next_in, size_t* available_out, uint8_t** next_out,
     size_t* total_out, BrotliState* s) {
-  BrotliResult result = BROTLI_RESULT_SUCCESS;
+  BrotliErrorCode result = BROTLI_SUCCESS;
   BrotliBitReader* br = &s->br;
   if (s->buffer_length == 0) { /* Just connect bit reader to input stream. */
     br->avail_in = *available_in;
@@ -1944,13 +1848,13 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
     /* At least one byte of input is required. More than one byte of input may
        be required to complete the transaction -> reading more data must be
        done in a loop -> do it in a main loop. */
-    result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+    result = BROTLI_NEEDS_MORE_INPUT;
     br->next_in = &s->buffer.u8[0];
   }
   /* State machine */
   for (;;) {
-    if (result != BROTLI_RESULT_SUCCESS) { /* Error | needs more input/output */
-      if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
+    if (result != BROTLI_SUCCESS) { /* Error | needs more input/output */
+      if (result == BROTLI_NEEDS_MORE_INPUT) {
         if (s->ringbuffer != 0) { /* Proactively push output. */
           WriteRingBuffer(available_out, next_out, total_out, s);
         }
@@ -1960,14 +1864,14 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
                is expanded byte-by-byte until it is enough to complete read. */
             s->buffer_length = 0;
             /* Switch to input stream and restart. */
-            result = BROTLI_RESULT_SUCCESS;
+            result = BROTLI_SUCCESS;
             br->avail_in = *available_in;
             br->next_in = *next_in;
             continue;
           } else if (*available_in != 0) {
             /* Not enough data in buffer, but can take one more byte from
                input stream. */
-            result = BROTLI_RESULT_SUCCESS;
+            result = BROTLI_SUCCESS;
             s->buffer.u8[s->buffer_length] = **next_in;
             s->buffer_length++;
             br->avail_in = s->buffer_length;
@@ -2013,7 +1917,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
       case BROTLI_STATE_UNINITED:
         /* Prepare to the first read. */
         if (!BrotliWarmupBitReader(br)) {
-          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+          result = BROTLI_NEEDS_MORE_INPUT;
           break;
         }
         /* Decode window size. */
@@ -2021,22 +1925,29 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
         BROTLI_LOG_UINT(s->window_bits);
         if (s->window_bits == 9) {
           /* Value 9 is reserved for future use. */
-          result = BROTLI_FAILURE();
+          result = BROTLI_FAILURE(BROTLI_ERROR_FORMAT_WINDOW_BITS);
           break;
         }
+        /* Maximum distance, see section 9.1. of the spec. */
         s->max_backward_distance = (1 << s->window_bits) - 16;
+        /* Limit custom dictionary size. */
+        if (s->custom_dict_size >= s->max_backward_distance) {
+          s->custom_dict += s->custom_dict_size - s->max_backward_distance;
+          s->custom_dict_size = s->max_backward_distance;
+        }
         s->max_backward_distance_minus_custom_dict_size =
             s->max_backward_distance - s->custom_dict_size;
 
         /* Allocate memory for both block_type_trees and block_len_trees. */
         s->block_type_trees = (HuffmanCode*)BROTLI_ALLOC(s,
-            6 * BROTLI_HUFFMAN_MAX_TABLE_SIZE * sizeof(HuffmanCode));
+            sizeof(HuffmanCode) * 3 *
+                (BROTLI_HUFFMAN_MAX_SIZE_258 + BROTLI_HUFFMAN_MAX_SIZE_26));
         if (s->block_type_trees == 0) {
-          result = BROTLI_FAILURE();
+          result = BROTLI_FAILURE(BROTLI_ERROR_ALLOC_BLOCK_TYPE_TREES);
           break;
         }
-        s->block_len_trees = s->block_type_trees +
-            3 * BROTLI_HUFFMAN_MAX_TABLE_SIZE;
+        s->block_len_trees =
+            s->block_type_trees + 3 * BROTLI_HUFFMAN_MAX_SIZE_258;
 
         s->state = BROTLI_STATE_METABLOCK_BEGIN;
         /* No break, continue to next state */
@@ -2047,7 +1958,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
         /* No break, continue to next state */
       case BROTLI_STATE_METABLOCK_HEADER:
         result = DecodeMetaBlockLength(s, br); /* Reads 2 - 31 bits. */
-        if (result != BROTLI_RESULT_SUCCESS) {
+        if (result != BROTLI_SUCCESS) {
           break;
         }
         BROTLI_LOG_UINT(s->is_last_metablock);
@@ -2056,7 +1967,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
         BROTLI_LOG_UINT(s->is_uncompressed);
         if (s->is_metadata || s->is_uncompressed) {
           if (!BrotliJumpToByteBoundary(br)) {
-            result = BROTLI_FAILURE();
+            result = BROTLI_FAILURE(BROTLI_ERROR_FORMAT_PADDING_1);
             break;
           }
         }
@@ -2069,10 +1980,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
           break;
         }
         if (!s->ringbuffer) {
-          if (!BrotliAllocateRingBuffer(s, br)) {
-            result = BROTLI_FAILURE();
-            break;
-          }
+          BrotliCalculateRingBufferSize(s, br);
         }
         if (s->is_uncompressed) {
           s->state = BROTLI_STATE_UNCOMPRESSED;
@@ -2086,7 +1994,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
         result = CopyUncompressedBlockToOutput(
             available_out, next_out, total_out, s);
         bytes_copied -= s->meta_block_remaining_len;
-        if (result != BROTLI_RESULT_SUCCESS) {
+        if (result != BROTLI_SUCCESS) {
           break;
         }
         s->state = BROTLI_STATE_METABLOCK_DONE;
@@ -2097,11 +2005,11 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
           uint32_t bits;
           /* Read one byte and ignore it. */
           if (!BrotliSafeReadBits(br, 8, &bits)) {
-            result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+            result = BROTLI_NEEDS_MORE_INPUT;
             break;
           }
         }
-        if (result == BROTLI_RESULT_SUCCESS) {
+        if (result == BROTLI_SUCCESS) {
           s->state = BROTLI_STATE_METABLOCK_DONE;
         }
         break;
@@ -2112,7 +2020,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
         }
         /* Reads 1..11 bits. */
         result = DecodeVarLenUint8(s, br, &s->num_block_types[s->loop_counter]);
-        if (result != BROTLI_RESULT_SUCCESS) {
+        if (result != BROTLI_SUCCESS) {
           break;
         }
         s->num_block_types[s->loop_counter]++;
@@ -2124,26 +2032,26 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
         s->state = BROTLI_STATE_HUFFMAN_CODE_1;
         /* No break, continue to next state */
       case BROTLI_STATE_HUFFMAN_CODE_1: {
-        int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_TABLE_SIZE;
+        int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_SIZE_258;
         result = ReadHuffmanCode(s->num_block_types[s->loop_counter] + 2,
             &s->block_type_trees[tree_offset], NULL, s);
-        if (result != BROTLI_RESULT_SUCCESS) break;
+        if (result != BROTLI_SUCCESS) break;
         s->state = BROTLI_STATE_HUFFMAN_CODE_2;
         /* No break, continue to next state */
       }
       case BROTLI_STATE_HUFFMAN_CODE_2: {
-        int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_TABLE_SIZE;
+        int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_SIZE_26;
         result = ReadHuffmanCode(kNumBlockLengthCodes,
             &s->block_len_trees[tree_offset], NULL, s);
-        if (result != BROTLI_RESULT_SUCCESS) break;
+        if (result != BROTLI_SUCCESS) break;
         s->state = BROTLI_STATE_HUFFMAN_CODE_3;
         /* No break, continue to next state */
       }
       case BROTLI_STATE_HUFFMAN_CODE_3: {
-        int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_TABLE_SIZE;
+        int tree_offset = s->loop_counter * BROTLI_HUFFMAN_MAX_SIZE_26;
         if (!SafeReadBlockLength(s, &s->block_length[s->loop_counter],
             &s->block_len_trees[tree_offset], br)) {
-          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+          result = BROTLI_NEEDS_MORE_INPUT;
           break;
         }
         BROTLI_LOG_UINT(s->block_length[s->loop_counter]);
@@ -2154,20 +2062,20 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
       case BROTLI_STATE_METABLOCK_HEADER_2: {
         uint32_t bits;
         if (!BrotliSafeReadBits(br, 6, &bits)) {
-          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+          result = BROTLI_NEEDS_MORE_INPUT;
           break;
         }
         s->distance_postfix_bits = bits & BitMask(2);
         bits >>= 2;
-        s->num_direct_distance_codes = NUM_DISTANCE_SHORT_CODES +
-            (bits << s->distance_postfix_bits);
+        s->num_direct_distance_codes =
+            NUM_DISTANCE_SHORT_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_ALLOC(s, (size_t)s->num_block_types[0]);
         if (s->context_modes == 0) {
-          result = BROTLI_FAILURE();
+          result = BROTLI_FAILURE(BROTLI_ERROR_ALLOC_CONTEXT_MODES);
           break;
         }
         s->loop_counter = 0;
@@ -2176,28 +2084,21 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
       }
       case BROTLI_STATE_CONTEXT_MODES:
         result = ReadContextModes(s);
-        if (result != BROTLI_RESULT_SUCCESS) {
+        if (result != BROTLI_SUCCESS) {
           break;
         }
         s->state = BROTLI_STATE_CONTEXT_MAP_1;
         /* No break, continue to next state */
-      case BROTLI_STATE_CONTEXT_MAP_1: {
-        uint32_t j;
-        result = DecodeContextMap(s->num_block_types[0] << kLiteralContextBits,
-                                  &s->num_literal_htrees, &s->context_map, s);
-        if (result != BROTLI_RESULT_SUCCESS) {
+      case BROTLI_STATE_CONTEXT_MAP_1:
+        result = DecodeContextMap(
+            s->num_block_types[0] << kLiteralContextBits,
+            &s->num_literal_htrees, &s->context_map, s);
+        if (result != BROTLI_SUCCESS) {
           break;
         }
-        s->trivial_literal_context = 1;
-        for (j = 0; j < s->num_block_types[0] << kLiteralContextBits; j++) {
-          if (s->context_map[j] != j >> kLiteralContextBits) {
-            s->trivial_literal_context = 0;
-            break;
-          }
-        }
+        DetectTrivialLiteralBlockTypes(s);
         s->state = BROTLI_STATE_CONTEXT_MAP_2;
         /* No break, continue to next state */
-      }
       case BROTLI_STATE_CONTEXT_MAP_2:
         {
           uint32_t num_distance_codes =
@@ -2205,20 +2106,21 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
           result = DecodeContextMap(
               s->num_block_types[2] << kDistanceContextBits,
               &s->num_dist_htrees, &s->dist_context_map, s);
-          if (result != BROTLI_RESULT_SUCCESS) {
+          if (result != BROTLI_SUCCESS) {
             break;
           }
           BrotliHuffmanTreeGroupInit(s, &s->literal_hgroup, kNumLiteralCodes,
                                      s->num_literal_htrees);
           BrotliHuffmanTreeGroupInit(s, &s->insert_copy_hgroup,
                                      kNumInsertAndCopyCodes,
-              s->num_block_types[1]);
+                                     s->num_block_types[1]);
           BrotliHuffmanTreeGroupInit(s, &s->distance_hgroup, num_distance_codes,
                                      s->num_dist_htrees);
           if (s->literal_hgroup.codes == 0 ||
               s->insert_copy_hgroup.codes == 0 ||
               s->distance_hgroup.codes == 0) {
-            return BROTLI_FAILURE();
+            return SaveErrorCode(s,
+                BROTLI_FAILURE(BROTLI_ERROR_ALLOC_TREE_GROUPS));
           }
         }
         s->loop_counter = 0;
@@ -2237,21 +2139,22 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
             case 2:
               hgroup = &s->distance_hgroup;
               break;
+            default:
+              return SaveErrorCode(s,
+                  BROTLI_FAILURE(BROTLI_ERROR_UNREACHABLE));
           }
           result = HuffmanTreeGroupDecode(hgroup, s);
         }
-        if (result != BROTLI_RESULT_SUCCESS) break;
+        if (result != BROTLI_SUCCESS) break;
         s->loop_counter++;
         if (s->loop_counter >= 3) {
-          uint8_t context_mode = s->context_modes[s->block_type_rb[1]];
-          s->context_map_slice = s->context_map;
+          PrepareLiteralDecoding(s);
           s->dist_context_map_slice = s->dist_context_map;
-          s->context_lookup1 =
-              &kContextLookup[kContextLookupOffsets[context_mode]];
-          s->context_lookup2 =
-              &kContextLookup[kContextLookupOffsets[context_mode + 1]];
           s->htree_command = s->insert_copy_hgroup.htrees[0];
-          s->literal_htree = s->literal_hgroup.htrees[s->literal_htree_index];
+          if (!s->ringbuffer && !BrotliAllocateRingBuffer(s)) {
+            result = BROTLI_FAILURE(BROTLI_ERROR_ALLOC_RING_BUFFER_2);
+            break;
+          }
           s->state = BROTLI_STATE_COMMAND_BEGIN;
         }
         break;
@@ -2260,7 +2163,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
       case BROTLI_STATE_COMMAND_POST_DECODE_LITERALS:
       case BROTLI_STATE_COMMAND_POST_WRAP_COPY:
         result = ProcessCommands(s);
-        if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
+        if (result == BROTLI_NEEDS_MORE_INPUT) {
           result = SafeProcessCommands(s);
         }
         break;
@@ -2268,15 +2171,13 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
       case BROTLI_STATE_COMMAND_POST_WRITE_1:
       case BROTLI_STATE_COMMAND_POST_WRITE_2:
         result = WriteRingBuffer(available_out, next_out, total_out, s);
-        if (result != BROTLI_RESULT_SUCCESS) {
+        if (result != BROTLI_SUCCESS) {
           break;
         }
-        s->pos -= s->ringbuffer_size;
-        s->rb_roundtrips++;
         s->max_distance = s->max_backward_distance;
         if (s->state == BROTLI_STATE_COMMAND_POST_WRITE_1) {
           memcpy(s->ringbuffer, s->ringbuffer_end, (size_t)s->pos);
-          if (s->meta_block_remaining_len <= 0) {
+          if (s->meta_block_remaining_len == 0) {
             /* Next metablock, if any */
             s->state = BROTLI_STATE_METABLOCK_DONE;
           } else {
@@ -2287,7 +2188,7 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
           s->state = BROTLI_STATE_COMMAND_POST_WRAP_COPY;
         } else {  /* BROTLI_STATE_COMMAND_INNER_WRITE */
           if (s->loop_counter == 0) {
-            if (s->meta_block_remaining_len <= 0) {
+            if (s->meta_block_remaining_len == 0) {
               s->state = BROTLI_STATE_METABLOCK_DONE;
             } else {
               s->state = BROTLI_STATE_COMMAND_POST_DECODE_LITERALS;
@@ -2298,13 +2199,18 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
         }
         break;
       case BROTLI_STATE_METABLOCK_DONE:
+        if (s->meta_block_remaining_len < 0) {
+          result = BROTLI_FAILURE(BROTLI_ERROR_FORMAT_BLOCK_LENGTH_2);
+          break;
+        }
         BrotliStateCleanupAfterMetablock(s);
         if (!s->is_last_metablock) {
           s->state = BROTLI_STATE_METABLOCK_BEGIN;
           break;
         }
         if (!BrotliJumpToByteBoundary(br)) {
-          result = BROTLI_FAILURE();
+          result = BROTLI_FAILURE(BROTLI_ERROR_FORMAT_PADDING_2);
+          break;
         }
         if (s->buffer_length == 0) {
           BrotliBitReaderUnload(br);
@@ -2316,23 +2222,41 @@ BrotliResult BrotliDecompressStream(size_t* available_in,
       case BROTLI_STATE_DONE:
         if (s->ringbuffer != 0) {
           result = WriteRingBuffer(available_out, next_out, total_out, s);
-          if (result != BROTLI_RESULT_SUCCESS) {
+          if (result != BROTLI_SUCCESS) {
             break;
           }
         }
-        return result;
+        return SaveErrorCode(s, result);
     }
   }
-  return result;
+  return SaveErrorCode(s, result);
 }
 
 void BrotliSetCustomDictionary(
     size_t size, const uint8_t* dict, BrotliState* s) {
+  if (size > (1u << 24)) {
+    return;
+  }
   s->custom_dict = dict;
-  s->custom_dict_size = (int) size;
+  s->custom_dict_size = (int)size;
+}
+
+BrotliErrorCode BrotliGetErrorCode(const BrotliState* s) {
+  return (BrotliErrorCode)s->error_code;
 }
 
+const char* BrotliErrorString(BrotliErrorCode c) {
+  switch (c) {
+#define _BROTLI_ERROR_CODE_CASE(PREFIX, NAME, CODE) \
+    case BROTLI ## PREFIX ## NAME: return #NAME;
+#define _BROTLI_NOTHING
+    BROTLI_ERROR_CODES_LIST(_BROTLI_ERROR_CODE_CASE, _BROTLI_NOTHING)
+#undef _BROTLI_ERROR_CODE_CASE
+#undef _BROTLI_NOTHING
+    default: return "INVALID";
+  }
+}
 
 #if defined(__cplusplus) || defined(c_plusplus)
-}    /* extern "C" */
+}  /* extern "C" */
 #endif