brotli 0.2.0 → 0.4.0

data/vendor/brotli/c/enc/prefix.h

@@ -11,7 +11,7 @@
 #define BROTLI_ENC_PREFIX_H_
 
 #include "../common/constants.h"
-#include <brotli/port.h>
+#include "../common/platform.h"
 #include <brotli/types.h>
 #include "./fast_log.h"
 
@@ -39,11 +39,10 @@ static BROTLI_INLINE void PrefixEncodeCopyDistance(size_t distance_code,
     size_t prefix = (dist >> bucket) & 1;
     size_t offset = (2 + prefix) << bucket;
     size_t nbits = bucket - postfix_bits;
-    *code = (uint16_t)(
+    *code = (uint16_t)((nbits << 10) |
         (BROTLI_NUM_DISTANCE_SHORT_CODES + num_direct_codes +
          ((2 * (nbits - 1) + prefix) << postfix_bits) + postfix));
-    *extra_bits = (uint32_t)(
-        (nbits << 24) | ((dist - offset) >> postfix_bits));
+    *extra_bits = (uint32_t)((dist - offset) >> postfix_bits);
   }
 }
 

data/vendor/brotli/c/enc/quality.h

@@ -10,7 +10,9 @@
 #ifndef BROTLI_ENC_QUALITY_H_
 #define BROTLI_ENC_QUALITY_H_
 
+#include "../common/platform.h"
 #include <brotli/encode.h>
+#include "./params.h"
 
 #define FAST_ONE_PASS_COMPRESSION_QUALITY 0
 #define FAST_TWO_PASS_COMPRESSION_QUALITY 1
@@ -19,36 +21,16 @@
 
 #define MAX_QUALITY_FOR_STATIC_ENTROPY_CODES 2
 #define MIN_QUALITY_FOR_BLOCK_SPLIT 4
+#define MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS 4
 #define MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS 4
 #define MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH 5
 #define MIN_QUALITY_FOR_CONTEXT_MODELING 5
 #define MIN_QUALITY_FOR_HQ_CONTEXT_MODELING 7
 #define MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING 10
-/* Only for "font" mode. */
-#define MIN_QUALITY_FOR_RECOMPUTE_DISTANCE_PREFIXES 10
 
 /* For quality below MIN_QUALITY_FOR_BLOCK_SPLIT there is no block splitting,
    so we buffer at most this much literals and commands. */
-#define MAX_NUM_DELAYED_SYMBOLS 0x2fff
-
-typedef struct BrotliHasherParams {
-  int type;
-  int bucket_bits;
-  int block_bits;
-  int hash_len;
-  int num_last_distances_to_check;
-} BrotliHasherParams;
-
-/* Encoding parameters */
-typedef struct BrotliEncoderParams {
-  BrotliEncoderMode mode;
-  int quality;
-  int lgwin;
-  int lgblock;
-  size_t size_hint;
-  BROTLI_BOOL disable_literal_context_modeling;
-  BrotliHasherParams hasher;
-} BrotliEncoderParams;
+#define MAX_NUM_DELAYED_SYMBOLS 0x2FFF
 
 /* Returns hash-table size for quality levels 0 and 1. */
 static BROTLI_INLINE size_t MaxHashTableSize(int quality) {
@@ -77,10 +59,15 @@ static BROTLI_INLINE size_t MaxZopfliCandidates(
 static BROTLI_INLINE void SanitizeParams(BrotliEncoderParams* params) {
   params->quality = BROTLI_MIN(int, BROTLI_MAX_QUALITY,
       BROTLI_MAX(int, BROTLI_MIN_QUALITY, params->quality));
+  if (params->quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) {
+    params->large_window = BROTLI_FALSE;
+  }
   if (params->lgwin < BROTLI_MIN_WINDOW_BITS) {
     params->lgwin = BROTLI_MIN_WINDOW_BITS;
-  } else if (params->lgwin > BROTLI_MAX_WINDOW_BITS) {
-    params->lgwin = BROTLI_MAX_WINDOW_BITS;
+  } else {
+    int max_lgwin = params->large_window ? BROTLI_LARGE_MAX_WINDOW_BITS :
+                                           BROTLI_MAX_WINDOW_BITS;
+    if (params->lgwin > max_lgwin) params->lgwin = max_lgwin;
   }
 }
 
@@ -155,6 +142,24 @@ static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
     hparams->num_last_distances_to_check =
         params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
   }
+
+  if (params->lgwin > 24) {
+    /* Different hashers for large window brotli: not for qualities <= 2,
+       these are too fast for large window. Not for qualities >= 10: their
+       hasher already works well with large window. So the changes are:
+       H3 --> H35: for quality 3.
+       H54 --> H55: for quality 4 with size hint > 1MB
+       H6 --> H65: for qualities 5, 6, 7, 8, 9. */
+    if (hparams->type == 3) {
+      hparams->type = 35;
+    }
+    if (hparams->type == 54) {
+      hparams->type = 55;
+    }
+    if (hparams->type == 6) {
+      hparams->type = 65;
+    }
+  }
 }
 
 #endif  /* BROTLI_ENC_QUALITY_H_ */

data/vendor/brotli/c/enc/ringbuffer.h

@@ -11,9 +11,9 @@
 
 #include <string.h>  /* memcpy */
 
+#include "../common/platform.h"
 #include <brotli/types.h>
 #include "./memory.h"
-#include "./port.h"
 #include "./quality.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
@@ -41,9 +41,9 @@ typedef struct RingBuffer {
   uint32_t pos_;
   /* The actual ring buffer containing the copy of the last two bytes, the data,
      and the copy of the beginning as a tail. */
-  uint8_t *data_;
+  uint8_t* data_;
   /* The start of the ring-buffer. */
-  uint8_t *buffer_;
+  uint8_t* buffer_;
 } RingBuffer;
 
 static BROTLI_INLINE void RingBufferInit(RingBuffer* rb) {
@@ -75,7 +75,7 @@ static BROTLI_INLINE void RingBufferInitBuffer(
   uint8_t* new_data = BROTLI_ALLOC(
       m, uint8_t, 2 + buflen + kSlackForEightByteHashingEverywhere);
   size_t i;
-  if (BROTLI_IS_OOM(m)) return;
+  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_data)) return;
   if (rb->data_) {
     memcpy(new_data, rb->data_,
         2 + rb->cur_size_ + kSlackForEightByteHashingEverywhere);
@@ -91,7 +91,7 @@ static BROTLI_INLINE void RingBufferInitBuffer(
 }
 
 static BROTLI_INLINE void RingBufferWriteTail(
-    const uint8_t *bytes, size_t n, RingBuffer* rb) {
+    const uint8_t* bytes, size_t n, RingBuffer* rb) {
   const size_t masked_pos = rb->pos_ & rb->mask_;
   if (BROTLI_PREDICT_FALSE(masked_pos < rb->tail_size_)) {
     /* Just fill the tail buffer with the beginning data. */
@@ -103,7 +103,7 @@ static BROTLI_INLINE void RingBufferWriteTail(
 
 /* Push bytes into the ring buffer. */
 static BROTLI_INLINE void RingBufferWrite(
-    MemoryManager* m, const uint8_t *bytes, size_t n, RingBuffer* rb) {
+    MemoryManager* m, const uint8_t* bytes, size_t n, RingBuffer* rb) {
   if (rb->pos_ == 0 && n < rb->tail_size_) {
     /* Special case for the first write: to process the first block, we don't
        need to allocate the whole ring-buffer and we don't need the tail
@@ -125,6 +125,9 @@ static BROTLI_INLINE void RingBufferWrite(
        later when we copy the last two bytes to the first two positions. */
     rb->buffer_[rb->size_ - 2] = 0;
     rb->buffer_[rb->size_ - 1] = 0;
+    /* Initialize tail; might be touched by "best_len++" optimization when
+       ring buffer is "full". */
+    rb->buffer_[rb->size_] = 241;
   }
   {
     const size_t masked_pos = rb->pos_ & rb->mask_;
@@ -144,12 +147,16 @@ static BROTLI_INLINE void RingBufferWrite(
              n - (rb->size_ - masked_pos));
     }
   }
-  rb->buffer_[-2] = rb->buffer_[rb->size_ - 2];
-  rb->buffer_[-1] = rb->buffer_[rb->size_ - 1];
-  rb->pos_ += (uint32_t)n;
-  if (rb->pos_ > (1u << 30)) {
-    /* Wrap, but preserve not-a-first-lap feature. */
-    rb->pos_ = (rb->pos_ & ((1u << 30) - 1)) | (1u << 30);
+  {
+    BROTLI_BOOL not_first_lap = (rb->pos_ & (1u << 31)) != 0;
+    uint32_t rb_pos_mask = (1u << 31) - 1;
+    rb->buffer_[-2] = rb->buffer_[rb->size_ - 2];
+    rb->buffer_[-1] = rb->buffer_[rb->size_ - 1];
+    rb->pos_ = (rb->pos_ & rb_pos_mask) + (uint32_t)(n & rb_pos_mask);
+    if (not_first_lap) {
+      /* Wrap, but preserve not-a-first-lap feature. */
+      rb->pos_ |= 1u << 31;
+    }
   }
 }
 

data/vendor/brotli/c/enc/static_dict.c

@@ -7,21 +7,17 @@
 #include "./static_dict.h"
 
 #include "../common/dictionary.h"
+#include "../common/platform.h"
+#include "../common/transform.h"
+#include "./encoder_dict.h"
 #include "./find_match_length.h"
-#include "./port.h"
-#include "./static_dict_lut.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-static const uint8_t kUppercaseFirst = 10;
-static const uint8_t kOmitLastNTransforms[10] = {
-  0, 12, 27, 23, 42, 63, 56, 48, 59, 64,
-};
-
-static BROTLI_INLINE uint32_t Hash(const uint8_t *data) {
-  uint32_t h = BROTLI_UNALIGNED_LOAD32(data) * kDictHashMul32;
+static BROTLI_INLINE uint32_t Hash(const uint8_t* data) {
+  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kDictHashMul32;
   /* The higher bits contain more mixture from the multiplication,
      so we take our results from there. */
   return h >> (32 - kDictNumBits);
@@ -79,32 +75,33 @@ static BROTLI_INLINE BROTLI_BOOL IsMatch(const BrotliDictionary* dictionary,
 }
 
 BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
-    const BrotliDictionary* dictionary, const uint8_t* data, size_t min_length,
-    size_t max_length, uint32_t* matches) {
+    const BrotliEncoderDictionary* dictionary, const uint8_t* data,
+    size_t min_length, size_t max_length, uint32_t* matches) {
   BROTLI_BOOL has_found_match = BROTLI_FALSE;
   {
-    size_t offset = kStaticDictionaryBuckets[Hash(data)];
+    size_t offset = dictionary->buckets[Hash(data)];
     BROTLI_BOOL end = !offset;
     while (!end) {
-      DictWord w = kStaticDictionaryWords[offset++];
+      DictWord w = dictionary->dict_words[offset++];
       const size_t l = w.len & 0x1F;
-      const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
+      const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
       const size_t id = w.idx;
       end = !!(w.len & 0x80);
       w.len = (uint8_t)l;
       if (w.transform == 0) {
         const size_t matchlen =
-            DictMatchLength(dictionary, data, id, l, max_length);
+            DictMatchLength(dictionary->words, data, id, l, max_length);
         const uint8_t* s;
         size_t minlen;
         size_t maxlen;
         size_t len;
-        /* Transform "" + kIdentity + "" */
+        /* Transform "" + BROTLI_TRANSFORM_IDENTITY + "" */
         if (matchlen == l) {
           AddMatch(id, l, l, matches);
           has_found_match = BROTLI_TRUE;
         }
-        /* Transforms "" + kOmitLast1 + "" and "" + kOmitLast1 + "ing " */
+        /* Transforms "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "" and
+                      "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "ing " */
         if (matchlen >= l - 1) {
           AddMatch(id + 12 * n, l - 1, l, matches);
           if (l + 2 < max_length &&
@@ -114,19 +111,22 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
           }
           has_found_match = BROTLI_TRUE;
         }
-        /* Transform "" + kOmitLastN + "" (N = 2 .. 9) */
+        /* Transform "" + BROTLI_TRANSFORM_OMIT_LAST_# + "" (# = 2 .. 9) */
         minlen = min_length;
         if (l > 9) minlen = BROTLI_MAX(size_t, minlen, l - 9);
         maxlen = BROTLI_MIN(size_t, matchlen, l - 2);
         for (len = minlen; len <= maxlen; ++len) {
-          AddMatch(id + kOmitLastNTransforms[l - len] * n, len, l, matches);
+          size_t cut = l - len;
+          size_t transform_id = (cut << 2) +
+              (size_t)((dictionary->cutoffTransforms >> (cut * 6)) & 0x3F);
+          AddMatch(id + transform_id * n, len, l, matches);
           has_found_match = BROTLI_TRUE;
         }
         if (matchlen < l || l + 6 >= max_length) {
           continue;
         }
         s = &data[l];
-        /* Transforms "" + kIdentity + <suffix> */
+        /* Transforms "" + BROTLI_TRANSFORM_IDENTITY + <suffix> */
         if (s[0] == ' ') {
           AddMatch(id + n, l + 1, l, matches);
           if (s[1] == 'a') {
@@ -273,12 +273,13 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
           }
         }
       } else {
-        /* Set is_all_caps=0 for kUppercaseFirst and
-               is_all_caps=1 otherwise (kUppercaseAll) transform. */
+        /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and
+               is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL)
+           transform. */
         const BROTLI_BOOL is_all_caps =
-            TO_BROTLI_BOOL(w.transform != kUppercaseFirst);
+            TO_BROTLI_BOOL(w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST);
         const uint8_t* s;
-        if (!IsMatch(dictionary, w, data, max_length)) {
+        if (!IsMatch(dictionary->words, w, data, max_length)) {
           continue;
         }
         /* Transform "" + kUppercase{First,All} + "" */
@@ -323,27 +324,29 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
   /* Transforms with prefixes " " and "." */
   if (max_length >= 5 && (data[0] == ' ' || data[0] == '.')) {
     BROTLI_BOOL is_space = TO_BROTLI_BOOL(data[0] == ' ');
-    size_t offset = kStaticDictionaryBuckets[Hash(&data[1])];
+    size_t offset = dictionary->buckets[Hash(&data[1])];
     BROTLI_BOOL end = !offset;
     while (!end) {
-      DictWord w = kStaticDictionaryWords[offset++];
+      DictWord w = dictionary->dict_words[offset++];
       const size_t l = w.len & 0x1F;
-      const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
+      const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
       const size_t id = w.idx;
       end = !!(w.len & 0x80);
       w.len = (uint8_t)l;
       if (w.transform == 0) {
         const uint8_t* s;
-        if (!IsMatch(dictionary, w, &data[1], max_length - 1)) {
+        if (!IsMatch(dictionary->words, w, &data[1], max_length - 1)) {
           continue;
         }
-        /* Transforms " " + kIdentity + "" and "." + kIdentity + "" */
+        /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + "" and
+                      "." + BROTLI_TRANSFORM_IDENTITY + "" */
         AddMatch(id + (is_space ? 6 : 32) * n, l + 1, l, matches);
         has_found_match = BROTLI_TRUE;
         if (l + 2 >= max_length) {
           continue;
         }
-        /* Transforms " " + kIdentity + <suffix> and "." + kIdentity + <suffix>
+        /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + <suffix> and
+                      "." + BROTLI_TRANSFORM_IDENTITY + <suffix>
         */
         s = &data[l + 1];
         if (s[0] == ' ') {
@@ -370,12 +373,13 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
           }
         }
       } else if (is_space) {
-        /* Set is_all_caps=0 for kUppercaseFirst and
-               is_all_caps=1 otherwise (kUppercaseAll) transform. */
+        /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and
+               is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL)
+           transform. */
         const BROTLI_BOOL is_all_caps =
-            TO_BROTLI_BOOL(w.transform != kUppercaseFirst);
+            TO_BROTLI_BOOL(w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST);
         const uint8_t* s;
-        if (!IsMatch(dictionary, w, &data[1], max_length - 1)) {
+        if (!IsMatch(dictionary->words, w, &data[1], max_length - 1)) {
           continue;
         }
         /* Transforms " " + kUppercase{First,All} + "" */
@@ -411,22 +415,22 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
     }
   }
   if (max_length >= 6) {
-    /* Transforms with prefixes "e ", "s ", ", " and "\xc2\xa0" */
+    /* Transforms with prefixes "e ", "s ", ", " and "\xC2\xA0" */
     if ((data[1] == ' ' &&
          (data[0] == 'e' || data[0] == 's' || data[0] == ',')) ||
-        (data[0] == 0xc2 && data[1] == 0xa0)) {
-      size_t offset = kStaticDictionaryBuckets[Hash(&data[2])];
+        (data[0] == 0xC2 && data[1] == 0xA0)) {
+      size_t offset = dictionary->buckets[Hash(&data[2])];
       BROTLI_BOOL end = !offset;
       while (!end) {
-        DictWord w = kStaticDictionaryWords[offset++];
+        DictWord w = dictionary->dict_words[offset++];
         const size_t l = w.len & 0x1F;
-        const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
+        const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
         const size_t id = w.idx;
         end = !!(w.len & 0x80);
         w.len = (uint8_t)l;
         if (w.transform == 0 &&
-            IsMatch(dictionary, w, &data[2], max_length - 2)) {
-          if (data[0] == 0xc2) {
+            IsMatch(dictionary->words, w, &data[2], max_length - 2)) {
+          if (data[0] == 0xC2) {
             AddMatch(id + 102 * n, l + 2, l, matches);
             has_found_match = BROTLI_TRUE;
           } else if (l + 2 < max_length && data[l + 2] == ' ') {
@@ -444,17 +448,17 @@ BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
          data[3] == 'e' && data[4] == ' ') ||
         (data[0] == '.' && data[1] == 'c' && data[2] == 'o' &&
          data[3] == 'm' && data[4] == '/')) {
-      size_t offset = kStaticDictionaryBuckets[Hash(&data[5])];
+      size_t offset = dictionary->buckets[Hash(&data[5])];
       BROTLI_BOOL end = !offset;
       while (!end) {
-        DictWord w = kStaticDictionaryWords[offset++];
+        DictWord w = dictionary->dict_words[offset++];
         const size_t l = w.len & 0x1F;
-        const size_t n = (size_t)1 << dictionary->size_bits_by_length[l];
+        const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
         const size_t id = w.idx;
         end = !!(w.len & 0x80);
         w.len = (uint8_t)l;
         if (w.transform == 0 &&
-            IsMatch(dictionary, w, &data[5], max_length - 5)) {
+            IsMatch(dictionary->words, w, &data[5], max_length - 5)) {
           AddMatch(id + (data[0] == ' ' ? 41 : 72) * n, l + 5, l, matches);
           has_found_match = BROTLI_TRUE;
           if (l + 5 < max_length) {

data/vendor/brotli/c/enc/static_dict.h

@@ -10,15 +10,16 @@
 #define BROTLI_ENC_STATIC_DICT_H_
 
 #include "../common/dictionary.h"
+#include "../common/platform.h"
 #include <brotli/types.h>
-#include "./port.h"
+#include "./encoder_dict.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
 #define BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN 37
-static const uint32_t kInvalidMatch = 0xfffffff;
+static const uint32_t kInvalidMatch = 0xFFFFFFF;
 
 /* Matches data against static dictionary words, and for each length l,
    for which a match is found, updates matches[l] to be the minimum possible
@@ -28,7 +29,7 @@ static const uint32_t kInvalidMatch = 0xfffffff;
      matches array is at least BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1 long
      all elements are initialized to kInvalidMatch */
 BROTLI_INTERNAL BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
-    const BrotliDictionary* dictionary,
+    const BrotliEncoderDictionary* dictionary,
     const uint8_t* data, size_t min_length, size_t max_length,
     uint32_t* matches);
 

data/vendor/brotli/c/enc/static_dict_lut.h

@@ -23,7 +23,7 @@ typedef struct DictWord {
 } DictWord;
 
 static const int kDictNumBits = 15;
-static const uint32_t kDictHashMul32 = 0x1e35a7bd;
+static const uint32_t kDictHashMul32 = 0x1E35A7BD;
 
 static const uint16_t kStaticDictionaryBuckets[32768] = {
 1,0,0,0,0,0,0,0,0,3,6,0,0,0,0,0,20,0,0,0,21,0,22,0,0,0,0,0,0,0,0,23,0,0,25,0,29,

data/vendor/brotli/c/enc/utf8_util.c

@@ -25,37 +25,37 @@ static size_t BrotliParseAsUTF8(
   }
   /* 2-byte UTF8 */
   if (size > 1u &&
-      (input[0] & 0xe0) == 0xc0 &&
-      (input[1] & 0xc0) == 0x80) {
-    *symbol = (((input[0] & 0x1f) << 6) |
-               (input[1] & 0x3f));
-    if (*symbol > 0x7f) {
+      (input[0] & 0xE0) == 0xC0 &&
+      (input[1] & 0xC0) == 0x80) {
+    *symbol = (((input[0] & 0x1F) << 6) |
+               (input[1] & 0x3F));
+    if (*symbol > 0x7F) {
       return 2;
     }
   }
   /* 3-byte UFT8 */
   if (size > 2u &&
-      (input[0] & 0xf0) == 0xe0 &&
-      (input[1] & 0xc0) == 0x80 &&
-      (input[2] & 0xc0) == 0x80) {
-    *symbol = (((input[0] & 0x0f) << 12) |
-               ((input[1] & 0x3f) << 6) |
-               (input[2] & 0x3f));
-    if (*symbol > 0x7ff) {
+      (input[0] & 0xF0) == 0xE0 &&
+      (input[1] & 0xC0) == 0x80 &&
+      (input[2] & 0xC0) == 0x80) {
+    *symbol = (((input[0] & 0x0F) << 12) |
+               ((input[1] & 0x3F) << 6) |
+               (input[2] & 0x3F));
+    if (*symbol > 0x7FF) {
       return 3;
     }
   }
   /* 4-byte UFT8 */
   if (size > 3u &&
-      (input[0] & 0xf8) == 0xf0 &&
-      (input[1] & 0xc0) == 0x80 &&
-      (input[2] & 0xc0) == 0x80 &&
-      (input[3] & 0xc0) == 0x80) {
+      (input[0] & 0xF8) == 0xF0 &&
+      (input[1] & 0xC0) == 0x80 &&
+      (input[2] & 0xC0) == 0x80 &&
+      (input[3] & 0xC0) == 0x80) {
     *symbol = (((input[0] & 0x07) << 18) |
-               ((input[1] & 0x3f) << 12) |
-               ((input[2] & 0x3f) << 6) |
-               (input[3] & 0x3f));
-    if (*symbol > 0xffff && *symbol <= 0x10ffff) {
+               ((input[1] & 0x3F) << 12) |
+               ((input[2] & 0x3F) << 6) |
+               (input[3] & 0x3F));
+    if (*symbol > 0xFFFF && *symbol <= 0x10FFFF) {
       return 4;
     }
   }
@@ -77,7 +77,7 @@ BROTLI_BOOL BrotliIsMostlyUTF8(
     i += bytes_read;
     if (symbol < 0x110000) size_utf8 += bytes_read;
   }
-  return TO_BROTLI_BOOL(size_utf8 > min_fraction * (double)length);
+  return TO_BROTLI_BOOL((double)size_utf8 > min_fraction * (double)length);
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)