Update brotli to v1.0.0-snapshot.

third_party/brotli/enc/command.h

 /* Copyright 2013 Google Inc. All Rights Reserved.
 
    Distributed under MIT license.
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-// This class models a sequence of literals and a backward reference copy.
+/* This class models a sequence of literals and a backward reference copy. */
 
 #ifndef BROTLI_ENC_COMMAND_H_
 #define BROTLI_ENC_COMMAND_H_
 
+#include "../common/constants.h"
+#include <brotli/port.h>
+#include <brotli/types.h>
 #include "./fast_log.h"
 #include "./prefix.h"
-#include "./types.h"
 
-namespace brotli {
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
 
 static uint32_t kInsBase[] =   { 0, 1, 2, 3, 4, 5, 6, 8, 10, 14, 18, 26, 34, 50,
     66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594 };
 static uint32_t kInsExtra[] =  { 0, 0, 0, 0, 0, 0, 1, 1,  2,  2,  3,  3,  4,  4,
     5,   5,   6,   7,   8,   9,   10,   12,   14,    24 };
 static uint32_t kCopyBase[] =  { 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 18, 22, 30,
     38, 54,  70, 102, 134, 198, 326,   582, 1094,  2118 };
 static uint32_t kCopyExtra[] = { 0, 0, 0, 0, 0, 0, 0, 0,  1,  1,  2,  2,  3,  3,
      4,  4,   5,   5,   6,   7,   8,     9,   10,    24 };
 
-static inline uint16_t GetInsertLengthCode(size_t insertlen) {
+static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {
   if (insertlen < 6) {
-    return static_cast<uint16_t>(insertlen);
+    return (uint16_t)insertlen;
   } else if (insertlen < 130) {
-    insertlen -= 2;
-    uint32_t nbits = Log2FloorNonZero(insertlen) - 1u;
-    return static_cast<uint16_t>((nbits << 1) + (insertlen >> nbits) + 2);
+    uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;
+    return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);
   } else if (insertlen < 2114) {
-    return static_cast<uint16_t>(Log2FloorNonZero(insertlen - 66) + 10);
+    return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);
   } else if (insertlen < 6210) {
     return 21u;
   } else if (insertlen < 22594) {
     return 22u;
   } else {
     return 23u;
   }
 }
 
-static inline uint16_t GetCopyLengthCode(size_t copylen) {
+static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {
   if (copylen < 10) {
-    return static_cast<uint16_t>(copylen - 2);
+    return (uint16_t)(copylen - 2);
   } else if (copylen < 134) {
-    copylen -= 6;
-    uint32_t nbits = Log2FloorNonZero(copylen) - 1u;
-    return static_cast<uint16_t>((nbits << 1) + (copylen >> nbits) + 4);
+    uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;
+    return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);
   } else if (copylen < 2118) {
-    return static_cast<uint16_t>(Log2FloorNonZero(copylen - 70) + 12);
+    return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);
   } else {
     return 23u;
   }
 }
 
-static inline uint16_t CombineLengthCodes(
-    uint16_t inscode, uint16_t copycode, bool use_last_distance) {
+static BROTLI_INLINE uint16_t CombineLengthCodes(
+    uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {
   uint16_t bits64 =
-      static_cast<uint16_t>((copycode & 0x7u) | ((inscode & 0x7u) << 3));
+      (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3));
   if (use_last_distance && inscode < 8 && copycode < 16) {
     return (copycode < 8) ? bits64 : (bits64 | 64);
   } else {
-    // "To convert an insert-and-copy length code to an insert length code and
-    // a copy length code, the following table can be used"
+    /* "To convert an insert-and-copy length code to an insert length code and
+       a copy length code, the following table can be used" */
     static const uint16_t cells[9] = { 128u, 192u, 384u, 256u, 320u, 512u,
                                        448u, 576u, 640u };
     return cells[(copycode >> 3) + 3 * (inscode >> 3)] | bits64;
   }
 }
 
-static inline void GetLengthCode(size_t insertlen, size_t copylen,
-                                 bool use_last_distance,
-                                 uint16_t* code) {
+static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,
+                                        BROTLI_BOOL use_last_distance,
+                                        uint16_t* code) {
   uint16_t inscode = GetInsertLengthCode(insertlen);
   uint16_t copycode = GetCopyLengthCode(copylen);
   *code = CombineLengthCodes(inscode, copycode, use_last_distance);
 }
 
-static inline uint32_t GetInsertBase(uint16_t inscode) {
+static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {
   return kInsBase[inscode];
 }
 
-static inline uint32_t GetInsertExtra(uint16_t inscode) {
+static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {
   return kInsExtra[inscode];
 }
 
-static inline uint32_t GetCopyBase(uint16_t copycode) {
+static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {
   return kCopyBase[copycode];
 }
 
-static inline uint32_t GetCopyExtra(uint16_t copycode) {
+static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {
   return kCopyExtra[copycode];
 }
 
-struct Command {
-  // distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1.
-  Command(size_t insertlen, size_t copylen, size_t copylen_code,
-          size_t distance_code)
-      : insert_len_(static_cast<uint32_t>(insertlen)) {
-    copy_len_ = static_cast<uint32_t>(
-        copylen | ((copylen_code ^ copylen) << 24));
-    // The distance prefix and extra bits are stored in this Command as if
-    // npostfix and ndirect were 0, they are only recomputed later after the
-    // clustering if needed.
-    PrefixEncodeCopyDistance(distance_code, 0, 0, &dist_prefix_, &dist_extra_);
-    GetLengthCode(insertlen, copylen_code, dist_prefix_ == 0,
-                  &cmd_prefix_);
-  }
-
-  explicit Command(size_t insertlen)
-      : insert_len_(static_cast<uint32_t>(insertlen))
-      , copy_len_(4 << 24), dist_extra_(0), dist_prefix_(16) {
-    GetLengthCode(insertlen, 4, dist_prefix_ == 0, &cmd_prefix_);
-  }
-
-  uint32_t DistanceCode(void) const {
-    if (dist_prefix_ < 16) {
-      return dist_prefix_;
-    }
-    uint32_t nbits = dist_extra_ >> 24;
-    uint32_t extra = dist_extra_ & 0xffffff;
-    uint32_t prefix = dist_prefix_ - 12 - 2 * nbits;
-    return (prefix << nbits) + extra + 12;
-  }
-
-  uint32_t DistanceContext(void) const {
-    uint32_t r = cmd_prefix_ >> 6;
-    uint32_t c = cmd_prefix_ & 7;
-    if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
-      return c;
-    }
-    return 3;
-  }
-
-  inline uint32_t copy_len(void) const {
-    return copy_len_ & 0xFFFFFF;
-  }
-
-  inline uint32_t copy_len_code(void) const {
-    return (copy_len_ & 0xFFFFFF) ^ (copy_len_ >> 24);
-  }
-
+typedef struct Command {
   uint32_t insert_len_;
   /* Stores copy_len in low 24 bits and copy_len XOR copy_code in high 8 bit. */
   uint32_t copy_len_;
   uint32_t dist_extra_;
   uint16_t cmd_prefix_;
   uint16_t dist_prefix_;
-};
+} Command;
 
-}  // namespace brotli
+/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
+static BROTLI_INLINE void InitCommand(Command* self, size_t insertlen,
+    size_t copylen, size_t copylen_code, size_t distance_code) {
+  self->insert_len_ = (uint32_t)insertlen;
+  self->copy_len_ = (uint32_t)(copylen | ((copylen_code ^ copylen) << 24));
+  /* The distance prefix and extra bits are stored in this Command as if
+     npostfix and ndirect were 0, they are only recomputed later after the
+     clustering if needed. */
+  PrefixEncodeCopyDistance(
+      distance_code, 0, 0, &self->dist_prefix_, &self->dist_extra_);
+  GetLengthCode(
+      insertlen, copylen_code, TO_BROTLI_BOOL(self->dist_prefix_ == 0),
+      &self->cmd_prefix_);
+}
 
-#endif  // BROTLI_ENC_COMMAND_H_
+static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
+  self->insert_len_ = (uint32_t)insertlen;
+  self->copy_len_ = 4 << 24;
+  self->dist_extra_ = 0;
+  self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
+  GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
+}
+
+static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(const Command* self) {
+  if (self->dist_prefix_ < BROTLI_NUM_DISTANCE_SHORT_CODES) {
+    return self->dist_prefix_;
+  } else {
+    uint32_t nbits = self->dist_extra_ >> 24;
+    uint32_t extra = self->dist_extra_ & 0xffffff;
+    /* It is assumed that the distance was first encoded with NPOSTFIX = 0 and
+       NDIRECT = 0, so the code itself is of this form:
+         BROTLI_NUM_DISTANCE_SHORT_CODES + 2 * (nbits - 1) + prefix_bit
+       Therefore, the following expression results in (2 + prefix_bit). */
+    uint32_t prefix =
+        self->dist_prefix_ + 4u - BROTLI_NUM_DISTANCE_SHORT_CODES - 2u * nbits;
+    /* Subtract 4 for offset (Chapter 4.) and
+       increase by BROTLI_NUM_DISTANCE_SHORT_CODES - 1  */
+    return (prefix << nbits) + extra + BROTLI_NUM_DISTANCE_SHORT_CODES - 4u;
+  }
+}
+
+static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {
+  uint32_t r = self->cmd_prefix_ >> 6;
+  uint32_t c = self->cmd_prefix_ & 7;
+  if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
+    return c;
+  }
+  return 3;
+}
+
+static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
+  return self->copy_len_ & 0xFFFFFF;
+}
+
+static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
+  return (self->copy_len_ & 0xFFFFFF) ^ (self->copy_len_ >> 24);
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
+
+#endif  /* BROTLI_ENC_COMMAND_H_ */