brotli 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a84cc7be2ff8f77b71c2a257ca25211a9c3ca23
-  data.tar.gz: bb07eb56c3ae937a98b6cd6c80589ca773562a0f
+  metadata.gz: 7de822751d5b3f546404565d93bc0679b0742545
+  data.tar.gz: 47aa47a72c5db72815ab325e832bb38e2b37934f
 SHA512:
-  metadata.gz: 5fe7de8328e763d815eeaf6c031998fecf3a8e1bf85130808207de71a39311eb7c5cae3abc9f0f7fd2a31c5cc93b50184b1c097f76bf9e3a35a669d959647e72
-  data.tar.gz: f4814c98c1066b5aa9f06125d19ccbfe6ff3828abacce332baa39da79bc3eb27bf864d157e33dcc5c30ceec0c3c060b438ffb328d97c0f6d9aab120460ab3b38
+  metadata.gz: c33554e3f20e4fa992bb0a0730f283695c6bf83df73fb194db522de443a3b652eae7dd84d2671a2ddb8d3452c32e1f6ffa71332b4732c02094ca0fc2963d6f36
+  data.tar.gz: 3a07f28a8953211b2d7e6884323e8e48ef568cf1d6242de575d0e12daecb9f002921613f213b5ca6242058528eb1d9a78bcb84a4f22feaa9d197845d3a58ea60

data/ext/brotli/brotli.cc

@@ -1,14 +1,22 @@
 #include "brotli.h"
 
+#define CSTR2SYM(x) ID2SYM(rb_intern(x))
+
 static VALUE rb_mBrotli;
 static VALUE rb_eBrotli;
 
-static int
-brotli_inflate_cb(void* data, const uint8_t* buf, size_t count)
+static void*
+brotli_alloc(void* opaque, size_t size)
+{
+    return xmalloc(size);
+}
+
+static void
+brotli_free(void* opaque, void* address)
 {
-    VALUE dst = (VALUE)data;
-    rb_str_cat(dst, (const char*)buf, count);
-    return count;
+    if (address) {
+        xfree(address);
+    }
 }
 
 static VALUE
@@ -16,34 +24,116 @@ brotli_inflate(VALUE self, VALUE str)
 {
     StringValue(str);
 
-    VALUE dst = rb_str_buf_new(RSTRING_LEN(str));
-    BrotliMemInput memin;
-    BrotliInput in = BrotliInitMemInput((uint8_t*)RSTRING_PTR(str), (size_t)RSTRING_LEN(str), &memin);
-    BrotliOutput out;
-    out.cb_ = &brotli_inflate_cb;
-    out.data_ = (void*)dst;
-
-    switch(BrotliDecompress(in, out)) {
-    case BROTLI_RESULT_SUCCESS:
-        return dst;
-    case BROTLI_RESULT_ERROR:
-        rb_raise(rb_eBrotli, "ERROR");
-        break;
-    case BROTLI_RESULT_NEEDS_MORE_INPUT:
+    uint8_t         output[BUFSIZ];
+    BrotliResult    result = BROTLI_RESULT_ERROR;
+    size_t    available_in = (size_t)RSTRING_LEN(str);
+    const uint8_t* next_in = (uint8_t*)RSTRING_PTR(str);
+    size_t   available_out = BUFSIZ;
+    uint8_t*      next_out = output;
+    size_t       total_out = 0;
+    VALUE            value = rb_str_buf_new(available_in);
+
+    BrotliState* s = BrotliCreateState(brotli_alloc, brotli_free, NULL);
+
+    for (;;) {
+        result = BrotliDecompressStream(&available_in,
+                                        &next_in,
+                                        &available_out,
+                                        &next_out,
+                                        &total_out,
+                                        s);
+        // success, error or needs more input
+        if (result != BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
+            break;
+        }
+        rb_str_buf_cat(value, (const char*)output, BUFSIZ);
+        available_out = BUFSIZ;
+        next_out = output;
+    }
+
+    if (next_out != output) {
+        rb_str_buf_cat(value, (const char*)output, next_out - output);
+    }
+
+    if (result == BROTLI_RESULT_ERROR) {
+        const char* error = BrotliErrorString(BrotliGetErrorCode(s));
+        BrotliDestroyState(s);
+        rb_raise(rb_eBrotli, "%s", error);
+    }
+
+    BrotliDestroyState(s);
+
+    if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
         rb_raise(rb_eBrotli, "Needs more input");
-        break;
-    case BROTLI_RESULT_NEEDS_MORE_OUTPUT:
+    } else if (result == BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
         rb_raise(rb_eBrotli, "Needs more output");
-        break;
+    }
+
+    return value;
+}
+
+static void
+brotli_deflate_parse_options(brotli::BrotliParams& params, VALUE opts)
+{
+    VALUE tmp;
+
+    tmp = rb_hash_aref(opts, CSTR2SYM("mode"));
+    if (!NIL_P(tmp)) {
+        if (tmp == CSTR2SYM("generic")) {
+            params.mode = brotli::BrotliParams::MODE_GENERIC;
+        } else if (tmp == CSTR2SYM("text")) {
+            params.mode = brotli::BrotliParams::MODE_TEXT;
+        } else if (tmp == CSTR2SYM("font")) {
+            params.mode = brotli::BrotliParams::MODE_FONT;
+        } else {
+            rb_raise(rb_eArgError, "invalid mode");
+        }
+    }
+
+    tmp = rb_hash_aref(opts, CSTR2SYM("quality"));
+    if (!NIL_P(tmp)) {
+        int value = NUM2INT(tmp);
+        if (0 <= value && value <= 11) {
+            params.quality = value;
+        } else {
+            rb_raise(rb_eArgError, "invalid quality value. Should be 0 to 11.");
+        }
+    }
+
+    tmp = rb_hash_aref(opts, CSTR2SYM("lgwin"));
+    if (!NIL_P(tmp)) {
+        int value = NUM2INT(tmp);
+        if (10 <= value && value <= 24) {
+            params.lgwin = value;
+        } else {
+            rb_raise(rb_eArgError, "invalid lgwin value. Should be 10 to 24.");
+        }
+    }
+
+    tmp = rb_hash_aref(opts, CSTR2SYM("lgblock"));
+    if (!NIL_P(tmp)) {
+        int value = NUM2INT(tmp);
+        if ((value == 0) || (16 <= value && value <= 24)) {
+            params.lgblock = value;
+        } else {
+            rb_raise(rb_eArgError, "invalid lgblock value. Should be 0 or 16 to 24.");
+        }
     }
 }
 
 static VALUE
-brotli_deflate(VALUE self, VALUE str)
+brotli_deflate(int argc, VALUE *argv, VALUE self)
 {
+    VALUE str, opts;
+    rb_scan_args(argc, argv, "11", &str, &opts);
+
     StringValue(str);
 
     brotli::BrotliParams params;
+    if (!NIL_P(opts)) {
+        brotli_deflate_parse_options(params, opts);
+    }
+
     brotli::BrotliMemIn in(RSTRING_PTR(str), RSTRING_LEN(str));
     std::string buf;
     buf.reserve(RSTRING_LEN(str) * 2 + 1);
@@ -61,7 +151,7 @@ Init_brotli(void)
 {
     rb_mBrotli = rb_define_module("Brotli");
     rb_eBrotli = rb_define_class_under(rb_mBrotli, "Error", rb_eStandardError);
-    rb_define_singleton_method(rb_mBrotli, "deflate", RUBY_METHOD_FUNC(brotli_deflate), 1);
+    rb_define_singleton_method(rb_mBrotli, "deflate", RUBY_METHOD_FUNC(brotli_deflate), -1);
     rb_define_singleton_method(rb_mBrotli, "inflate", RUBY_METHOD_FUNC(brotli_inflate), 1);
 }
 }

data/ext/brotli/brotli.h

@@ -4,6 +4,5 @@
 #include "ruby.h"
 #include "enc/encode.h"
 #include "dec/decode.h"
-#include "dec/streams.h"
 
 #endif /* BROTLI_H */

data/ext/brotli/extconf.rb

@@ -13,61 +13,68 @@ FileUtils.mkdir_p File.join(__dir__, 'dec')
 srcs = []
 objs = []
 [
-  'enc/backward_references.cc',
-  'enc/block_splitter.cc',
-  'enc/brotli_bit_stream.cc',
-  'enc/encode.cc',
-  'enc/entropy_encode.cc',
-  'enc/histogram.cc',
-  'enc/literal_cost.cc',
-  'enc/metablock.cc',
-  'enc/static_dict.cc',
-  'enc/streams.cc',
-  'enc/utf8_util.cc',
   'dec/bit_reader.c',
+  'dec/bit_reader.h',
+  'dec/context.h',
   'dec/decode.c',
+  'dec/decode.h',
   'dec/dictionary.c',
+  'dec/dictionary.h',
   'dec/huffman.c',
-  'dec/streams.c',
+  'dec/huffman.h',
+  'dec/port.h',
+  'dec/prefix.h',
   'dec/state.c',
+  'dec/state.h',
+  'dec/transform.h',
+  'dec/types.h',
+  'enc/backward_references.cc',
   'enc/backward_references.h',
   'enc/bit_cost.h',
+  'enc/block_splitter.cc',
   'enc/block_splitter.h',
+  'enc/brotli_bit_stream.cc',
   'enc/brotli_bit_stream.h',
   'enc/cluster.h',
   'enc/command.h',
+  'enc/compress_fragment.cc',
+  'enc/compress_fragment.h',
+  'enc/compress_fragment_two_pass.cc',
+  'enc/compress_fragment_two_pass.h',
+  'enc/compressor.h',
   'enc/context.h',
+  #'enc/dictionary.cc',
   'enc/dictionary.h',
   'enc/dictionary_hash.h',
+  'enc/encode.cc',
   'enc/encode.h',
+  'enc/encode_parallel.cc',
+  'enc/encode_parallel.h',
+  'enc/entropy_encode.cc',
   'enc/entropy_encode.h',
+  'enc/entropy_encode_static.h',
   'enc/fast_log.h',
   'enc/find_match_length.h',
   'enc/hash.h',
+  'enc/histogram.cc',
   'enc/histogram.h',
+  'enc/literal_cost.cc',
   'enc/literal_cost.h',
+  'enc/metablock.cc',
   'enc/metablock.h',
   'enc/port.h',
   'enc/prefix.h',
   'enc/ringbuffer.h',
+  'enc/static_dict.cc',
   'enc/static_dict.h',
   'enc/static_dict_lut.h',
+  'enc/streams.cc',
   'enc/streams.h',
   'enc/transform.h',
   'enc/types.h',
+  'enc/utf8_util.cc',
   'enc/utf8_util.h',
   'enc/write_bits.h',
-  'dec/bit_reader.h',
-  'dec/context.h',
-  'dec/decode.h',
-  'dec/dictionary.h',
-  'dec/huffman.h',
-  'dec/prefix.h',
-  'dec/port.h',
-  'dec/streams.h',
-  'dec/transform.h',
-  'dec/types.h',
-  'dec/state.h',
 ].each do |file|
   FileUtils.cp(File.expand_path(File.join(__dir__, '..', '..', 'vendor', 'brotli', file)),
                File.expand_path(File.join(__dir__, file)),

data/lib/brotli/version.rb

@@ -1,3 +1,3 @@
 module Brotli
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/vendor/brotli/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009, 2010, 2013-2015 by the Brotli Authors.
+Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/vendor/brotli/dec/Makefile

@@ -4,7 +4,7 @@ include ../shared.mk
 
 CFLAGS += -Wall
 
-OBJS = bit_reader.o decode.o dictionary.o huffman.o state.o streams.o
+OBJS = bit_reader.o decode.o dictionary.o huffman.o state.o
 
 all : $(OBJS)
 

data/vendor/brotli/dec/bit_reader.c

@@ -6,10 +6,10 @@
 
 /* Bit reading helpers */
 
-#include <stdlib.h>
-
 #include "./bit_reader.h"
+
 #include "./port.h"
+#include "./types.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -44,5 +44,5 @@ int BrotliWarmupBitReader(BrotliBitReader* const br) {
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
-}    /* extern "C" */
+}  /* extern "C" */
 #endif

data/vendor/brotli/dec/bit_reader.h

@@ -9,8 +9,8 @@
 #ifndef BROTLI_DEC_BIT_READER_H_
 #define BROTLI_DEC_BIT_READER_H_
 
-#include <stdio.h>
-#include <string.h>
+#include <string.h>  /* memcpy */
+
 #include "./port.h"
 #include "./types.h"
 
@@ -48,27 +48,27 @@ static BROTLI_INLINE uint32_t BitMask(uint32_t n) {
 }
 
 typedef struct {
-  reg_t       val_;          /* pre-fetched bits */
-  uint32_t    bit_pos_;      /* current bit-reading position in val_ */
-  const uint8_t* next_in;    /* the byte we're reading from */
-  size_t      avail_in;
+  reg_t val_;              /* pre-fetched bits */
+  uint32_t bit_pos_;       /* current bit-reading position in val_ */
+  const uint8_t* next_in;  /* the byte we're reading from */
+  size_t avail_in;
 } BrotliBitReader;
 
 typedef struct {
-  reg_t    val_;
+  reg_t val_;
   uint32_t bit_pos_;
   const uint8_t* next_in;
-  size_t   avail_in;
+  size_t avail_in;
 } BrotliBitReaderState;
 
 /* Initializes the bitreader fields. */
-void BrotliInitBitReader(BrotliBitReader* const br);
+BROTLI_INTERNAL void BrotliInitBitReader(BrotliBitReader* const br);
 
 /* Ensures that accumulator is not empty. May consume one byte of input.
    Returns 0 if data is required but there is no input available.
-   For BROTLI_BUILD_PORTABLE this function also prepares bit reader for aligned
+   For BROTLI_ALIGNED_READ this function also prepares bit reader for aligned
    reading. */
-int BrotliWarmupBitReader(BrotliBitReader* const br);
+BROTLI_INTERNAL int BrotliWarmupBitReader(BrotliBitReader* const br);
 
 static BROTLI_INLINE void BrotliBitReaderSaveState(
     BrotliBitReader* const from, BrotliBitReaderState* to) {
@@ -109,9 +109,7 @@ static BROTLI_INLINE uint16_t BrotliLoad16LE(const uint8_t* in) {
     return *((const uint16_t*)in);
   } else if (BROTLI_BIG_ENDIAN) {
     uint16_t value = *((const uint16_t*)in);
-    return (uint16_t)(
-        ((value & 0xFFU) << 8) |
-        ((value & 0xFF00U) >> 8));
+    return (uint16_t)(((value & 0xFFU) << 8) | ((value & 0xFF00U) >> 8));
   } else {
     return (uint16_t)(in[0] | (in[1] << 8));
   }
@@ -228,9 +226,9 @@ static BROTLI_INLINE int BrotliPullByte(BrotliBitReader* const br) {
   }
   br->val_ >>= 8;
 #if (BROTLI_64_BITS)
-    br->val_ |= ((uint64_t)*br->next_in) << 56;
+  br->val_ |= ((uint64_t)*br->next_in) << 56;
 #else
-    br->val_ |= ((uint32_t)*br->next_in) << 24;
+  br->val_ |= ((uint32_t)*br->next_in) << 24;
 #endif
   br->bit_pos_ -= 8;
   --br->avail_in;
@@ -262,7 +260,7 @@ static BROTLI_INLINE uint32_t BrotliGetBits(
 /* Tries to peek the specified amount of bits. Returns 0, if there is not
    enough input. */
 static BROTLI_INLINE int BrotliSafeGetBits(
-  BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
+    BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
   while (BrotliGetAvailableBits(br) < n_bits) {
     if (!BrotliPullByte(br)) {
       return 0;
@@ -283,7 +281,11 @@ static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
   uint32_t unused_bits = unused_bytes << 3;
   br->avail_in += unused_bytes;
   br->next_in -= unused_bytes;
-  br->val_ <<= unused_bits;
+  if (unused_bits == sizeof(br->val_) << 3) {
+    br->val_ = 0;
+  } else {
+    br->val_ <<= unused_bits;
+  }
   br->bit_pos_ += unused_bits;
 }
 
@@ -292,10 +294,8 @@ static BROTLI_INLINE void BrotliBitReaderUnload(BrotliBitReader* br) {
 static BROTLI_INLINE void BrotliTakeBits(
   BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
   *val = (uint32_t)BrotliGetBitsUnmasked(br) & BitMask(n_bits);
-#ifdef BROTLI_DECODE_DEBUG
-  printf("[BrotliReadBits]  %d %d %d val: %6x\n",
-         (int)br->avail_in, (int)br->bit_pos_, n_bits, (int)*val);
-#endif
+  BROTLI_LOG(("[BrotliReadBits]  %d %d %d val: %6x\n",
+      (int)br->avail_in, (int)br->bit_pos_, n_bits, (int)*val));
   BrotliDropBits(br, n_bits);
 }
 
@@ -322,7 +322,7 @@ static BROTLI_INLINE uint32_t BrotliReadBits(
 /* Tries to read the specified amount of bits. Returns 0, if there is not
    enough input. n_bits MUST be positive. */
 static BROTLI_INLINE int BrotliSafeReadBits(
-  BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
+    BrotliBitReader* const br, uint32_t n_bits, uint32_t* val) {
   while (BrotliGetAvailableBits(br) < n_bits) {
     if (!BrotliPullByte(br)) {
       return 0;
@@ -349,9 +349,7 @@ static BROTLI_INLINE int BrotliJumpToByteBoundary(BrotliBitReader* br) {
 static BROTLI_INLINE int BrotliPeekByte(BrotliBitReader* br, size_t offset) {
   uint32_t available_bits = BrotliGetAvailableBits(br);
   size_t bytes_left = available_bits >> 3;
-  if (available_bits & 7) {
-    return -1;
-  }
+  BROTLI_DCHECK((available_bits & 7) == 0);
   if (offset < bytes_left) {
     return (BrotliGetBitsUnmasked(br) >> (unsigned)(offset << 3)) & 0xFF;
   }
@@ -379,7 +377,7 @@ static BROTLI_INLINE void BrotliCopyBytes(uint8_t* dest,
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
-}    /* extern "C" */
+}  /* extern "C" */
 #endif
 
 #endif  /* BROTLI_DEC_BIT_READER_H_ */

data/vendor/brotli/dec/context.h

@@ -102,10 +102,10 @@
 #include "./types.h"
 
 enum ContextType {
-  CONTEXT_LSB6         = 0,
-  CONTEXT_MSB6         = 1,
-  CONTEXT_UTF8         = 2,
-  CONTEXT_SIGNED       = 3
+  CONTEXT_LSB6 = 0,
+  CONTEXT_MSB6 = 1,
+  CONTEXT_UTF8 = 2,
+  CONTEXT_SIGNED = 3
 };
 
 /* Common context lookup table for all context modes. */