brotli 0.1.1 → 0.1.2

data/vendor/brotli/enc/command.h

@@ -15,21 +15,21 @@
 
 namespace brotli {
 
-static int insbase[] =   { 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 int insextra[] =  { 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 int copybase[] =  { 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 int copyextra[] = { 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(int insertlen) {
+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) {
   if (insertlen < 6) {
     return static_cast<uint16_t>(insertlen);
   } else if (insertlen < 130) {
     insertlen -= 2;
-    int nbits = Log2FloorNonZero(insertlen) - 1;
+    uint32_t nbits = Log2FloorNonZero(insertlen) - 1u;
     return static_cast<uint16_t>((nbits << 1) + (insertlen >> nbits) + 2);
   } else if (insertlen < 2114) {
     return static_cast<uint16_t>(Log2FloorNonZero(insertlen - 66) + 10);
@@ -42,12 +42,12 @@ static inline uint16_t GetInsertLengthCode(int insertlen) {
   }
 }
 
-static inline uint16_t GetCopyLengthCode(int copylen) {
+static inline uint16_t GetCopyLengthCode(size_t copylen) {
   if (copylen < 10) {
     return static_cast<uint16_t>(copylen - 2);
   } else if (copylen < 134) {
     copylen -= 6;
-    int nbits = Log2FloorNonZero(copylen) - 1;
+    uint32_t nbits = Log2FloorNonZero(copylen) - 1u;
     return static_cast<uint16_t>((nbits << 1) + (copylen >> nbits) + 4);
   } else if (copylen < 2118) {
     return static_cast<uint16_t>(Log2FloorNonZero(copylen - 70) + 12);
@@ -71,61 +71,84 @@ static inline uint16_t CombineLengthCodes(
   }
 }
 
-static inline void GetLengthCode(int insertlen, int copylen,
+static inline void GetLengthCode(size_t insertlen, size_t copylen,
                                  bool use_last_distance,
-                                 uint16_t* code, uint64_t* extra) {
+                                 uint16_t* code) {
   uint16_t inscode = GetInsertLengthCode(insertlen);
   uint16_t copycode = GetCopyLengthCode(copylen);
-  uint64_t insnumextra = insextra[inscode];
-  uint64_t numextra = insnumextra + copyextra[copycode];
-  uint64_t insextraval = insertlen - insbase[inscode];
-  uint64_t copyextraval = copylen - copybase[copycode];
   *code = CombineLengthCodes(inscode, copycode, use_last_distance);
-  *extra = (numextra << 48) | (copyextraval << insnumextra) | insextraval;
+}
+
+static inline uint32_t GetInsertBase(uint16_t inscode) {
+  return kInsBase[inscode];
+}
+
+static inline uint32_t GetInsertExtra(uint16_t inscode) {
+  return kInsExtra[inscode];
+}
+
+static inline uint32_t GetCopyBase(uint16_t copycode) {
+  return kCopyBase[copycode];
+}
+
+static 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(int insertlen, int copylen, int copylen_code, int distance_code)
-      : insert_len_(insertlen), copy_len_(copylen) {
+  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_, &cmd_extra_);
+                  &cmd_prefix_);
   }
 
-  Command(int insertlen)
-      : insert_len_(insertlen), copy_len_(0), dist_prefix_(16), dist_extra_(0) {
-    GetLengthCode(insertlen, 4, dist_prefix_ == 0, &cmd_prefix_, &cmd_extra_);
+  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_);
   }
 
-  int DistanceCode() const {
+  uint32_t DistanceCode(void) const {
     if (dist_prefix_ < 16) {
       return dist_prefix_;
     }
-    int nbits = dist_extra_ >> 24;
-    int extra = dist_extra_ & 0xffffff;
-    int prefix = dist_prefix_ - 12 - 2 * nbits;
+    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;
   }
 
-  int DistanceContext() const {
-    int r = cmd_prefix_ >> 6;
-    int c = cmd_prefix_ & 7;
+  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;
   }
 
-  int insert_len_;
-  int copy_len_;
+  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);
+  }
+
+  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_;
-  uint64_t cmd_extra_;
-  uint32_t dist_extra_;
 };
 
 }  // namespace brotli