Added brotli enc/ and tools/ directories.

third_party/brotli/dec/decode.c

 /* 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 "./decode.h"
 
 #ifdef __ARM_NEON__
 #include <arm_neon.h>
@@ skipping 817 matching lines @@
    of Y values, and reinitialize only first elements in L.
 
    Most of input values are 0 and 1. To reduce number of branches, we replace
    inner for loop with do-while.
  */
 static BROTLI_NOINLINE void InverseMoveToFrontTransform(uint8_t* v,
     uint32_t v_len, BrotliState* state) {
   /* 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;
   memcpy(&pattern, &b0123, 4);
 
   /* Initialize list using 4 consequent values pattern. */
   *(uint32_t*)mtf = pattern;
   do {
     pattern += 0x04040404; /* Advance all 4 values by 4. */
     *(uint32_t*)(mtf + i) = pattern;
     i += 4;
   } while (i <= upper_bound);
 
   /* Transform the input. */
   upper_bound = 0;
   for (i = 0; i < v_len; ++i) {
     int index = v[i];
     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) {
   if (s->substate_tree_group != BROTLI_STATE_TREE_GROUP_LOOP) {
     s->next = group->codes;
@@ skipping 398 matching lines @@
   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 */
         is_last = 1;
       }
     }
   }
 
-  /* Limit custom dictionary size to stream window size. */
-  if (s->custom_dict_size >= window_size) {
-    s->custom_dict += s->custom_dict_size - window_size;
-    s->custom_dict_size = window_size;
-  }
-
   /* We need at least 2 bytes of ring buffer size to get the last two
      bytes for context from there */
   if (is_last) {
     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;
     }
   }
 
   s->ringbuffer_mask = s->ringbuffer_size - 1;
@@ skipping 595 matching lines @@
           break;
         }
         /* Decode window size. */
         s->window_bits = DecodeWindowBits(br); /* Reads 1..7 bits. */
         BROTLI_LOG_UINT(s->window_bits);
         if (s->window_bits == 9) {
           /* Value 9 is reserved for future use. */
           result = BROTLI_FAILURE();
           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,
             sizeof(HuffmanCode) * 3 *
                 (BROTLI_HUFFMAN_MAX_SIZE_258 + BROTLI_HUFFMAN_MAX_SIZE_26));
         if (s->block_type_trees == 0) {
           result = BROTLI_FAILURE();
           break;
@@ skipping 287 matching lines @@
           }
         }
         return result;
     }
   }
   return 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;
 }
 
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }  /* extern "C" */
 #endif