brotli 0.2.0 → 0.4.0

data/ext/brotli/buffer.c

@@ -34,13 +34,7 @@ static
 buffer_t*
 expand_buffer(buffer_t* const buffer, const size_t need) {
     size_t size = need * buffer->expand_ratio / 100;
-    uint8_t* ptr = malloc(size);
-    if (ptr == NULL) {
-        return NULL;
-    }
-    memcpy(ptr, buffer->ptr, buffer->size);
-    free(buffer->ptr);
-    buffer->ptr = ptr;
+    buffer->ptr = realloc(buffer->ptr, size);
     buffer->size = size;
     buffer->expand_count += 1;
     return buffer;

data/ext/brotli/buffer.h

@@ -5,7 +5,7 @@
 #include <string.h>
 
 typedef struct {
-    uint8_t* ptr;
+    char* ptr;
     size_t size;
     size_t used;
     size_t expand_ratio;

data/ext/brotli/extconf.rb

@@ -1,32 +1,51 @@
-require 'mkmf'
-require 'fileutils'
-require 'rbconfig'
+require "mkmf"
+require "fileutils"
+require "rbconfig"
 
-$CPPFLAGS << ' -DOS_MACOSX' if RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-$INCFLAGS << ' -I$(srcdir)/enc -I$(srcdir)/dec -I$(srcdir)/common -I$(srcdir)/include'
-create_makefile('brotli/brotli')
+dir_config("brotli")
 
-__DIR__ = File.expand_path(File.dirname __FILE__)
+# libbrotli-dev
+have_dev_pkg = [
+  have_header("brotli/decode.h"),
+  have_header("brotli/encode.h"),
+  pkg_config("libbrotlicommon"),
+  pkg_config("libbrotlidec"),
+  pkg_config("libbrotlienc")
+].all? { |e| e }
 
-%w[enc dec common include].each do |dirname|
-  FileUtils.mkdir_p dirname
-  FileUtils.cp_r File.expand_path(File.join(__DIR__, '..', '..', 'vendor', 'brotli', 'c', dirname), __DIR__), __DIR__, verbose: true
-end
+$CPPFLAGS << " -DOS_MACOSX" if RbConfig::CONFIG["host_os"] =~ /darwin|mac os/
+$INCFLAGS << " -I$(srcdir)/enc -I$(srcdir)/dec -I$(srcdir)/common -I$(srcdir)/include" unless have_dev_pkg
 
-srcs = []
-objs = []
-Dir[File.expand_path(File.join('{enc,dec,common,include}', '**', '*.c'), __DIR__)].sort.each do |file|
-  file[__DIR__ + File::SEPARATOR] = ''
-  srcs << file
-  objs << file.sub(/\.c\z/, '.' + RbConfig::CONFIG['OBJEXT'])
-end
+create_makefile("brotli/brotli")
+
+unless have_dev_pkg
+  __DIR__ = File.expand_path(File.dirname(__FILE__))
+
+  %w[enc dec common include].each do |dirname|
+    FileUtils.mkdir_p dirname
+    FileUtils.cp_r(
+      File.expand_path(File.join(__DIR__, "..", "..", "vendor", "brotli", "c", dirname), __DIR__),
+      __DIR__,
+      verbose: true
+    )
+  end
+
+  srcs = []
+  objs = []
+  Dir[File.expand_path(File.join("{enc,dec,common,include}", "**", "*.c"), __DIR__)].sort.each do |file|
+    file[__DIR__ + File::SEPARATOR] = ""
+    srcs << file
+    objs << file.sub(/\.c\z/, "." + RbConfig::CONFIG["OBJEXT"])
+  end
 
-File.open('Makefile', 'r+') do |f|
-  src = 'ORIG_SRCS = brotli.c buffer.c'
-  obj = 'OBJS = brotli.o buffer.o'
-  txt = f.read
-        .sub(/^ORIG_SRCS = .*$/, src + ' ' + srcs.join(' '))
-        .sub(/^OBJS = .*$/, obj + ' ' + objs.join(' '))
-  f.rewind
-  f.write txt
+  File.open("Makefile", "r+") do |f|
+    obj_ext = RbConfig::CONFIG["OBJEXT"]
+    src = "ORIG_SRCS = brotli.c buffer.c"
+    obj = "OBJS = brotli.#{obj_ext} buffer.#{obj_ext}"
+    txt = f.read
+           .sub(/^ORIG_SRCS = .*$/, "#{src} #{srcs.join(" ")}")
+           .sub(/^OBJS = .*$/, "#{obj} #{objs.join(" ")}")
+    f.rewind
+    f.write txt
+  end
 end

data/lib/brotli/version.rb

@@ -1,3 +1,3 @@
 module Brotli
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

data/smoke.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 gem list | grep brotli && gem uninstall --force brotli
 bundle exec rake clobber build
-gem install --force --local --no-ri --no-rdoc "$(ls pkg/brotli-*.gem)"
+gem install --force --local "$(ls pkg/brotli-*.gem)"
 cat <<EOF | ruby
 require 'brotli'
 abort if Brotli.inflate(Brotli.deflate(File.read('smoke.sh'))) != File.read('smoke.sh')

data/test/brotli_test.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class BrotliTest < Test::Unit::TestCase
+  def testdata
+    @testdata ||= File.binread(
+      File.expand_path(File.join("..", "vendor", "brotli", "tests", "testdata", "alice29.txt"), __dir__)
+    )
+  end
+
+  test "VERSION" do
+    assert do
+      ::Brotli.const_defined?(:VERSION)
+    end
+  end
+
+  test "well done" do
+    property_of { string }.check do |string|
+      assert_equal string, Brotli.inflate(Brotli.deflate(string.dup))
+    end
+  end
+
+  sub_test_case ".version" do
+    test "returns string" do
+      assert_equal "1.0.9", Brotli.version
+    end
+  end
+
+  sub_test_case ".deflate" do
+    test "works" do
+      property_of {
+        [choose(nil, :generic, :text, :font), range(0, 11), range(10, 24), range(16, 24)]
+      }.check do |(mode, quality, lgwin, lgblock)|
+        assert_nothing_raised ArgumentError do
+          Brotli.deflate(
+            testdata,
+            mode: mode, quality: quality, lgwin: lgwin, lgblock: lgblock
+          )
+        end
+      end
+    end
+
+    test "raise ArgumentError if given invalid options" do
+      assert_raise ArgumentError do
+        Brotli.deflate(testdata, mode: "generic")
+      end
+      assert_raise ArgumentError do
+        Brotli.deflate(testdata, quality: 12)
+      end
+      assert_raise ArgumentError do
+        Brotli.deflate(testdata, lgwin: 9)
+      end
+      assert_raise ArgumentError do
+        Brotli.deflate(testdata, lgwin: 25)
+      end
+      assert_raise ArgumentError do
+        Brotli.deflate(testdata, lgblock: 15)
+      end
+      assert_raise ArgumentError do
+        Brotli.deflate(testdata, lgblock: 25)
+      end
+    end
+  end
+
+  sub_test_case ".inflate" do
+    def testdata2
+      @testdata2 ||= File.binread(
+        File.expand_path(File.join("..", "vendor", "brotli", "tests", "testdata", "alice29.txt.compressed"), __dir__)
+      )
+    end
+
+    test "works" do
+      assert_equal testdata, Brotli.inflate(testdata2)
+    end
+
+    test "raise error when pass insufficient data" do
+      assert_raise Brotli::Error do
+        Brotli.inflate(testdata2[0, 64])
+      end
+    end
+
+    test "raise error when pass invalid data" do
+      assert_raise Brotli::Error do
+        Brotli.inflate(testdata2.reverse)
+      end
+    end
+  end
+
+  sub_test_case "Ractor safe" do
+    test "able to invoke non-main ractor" do
+      unless defined? ::Ractor
+        notify "Ractor not defined"
+        omit
+      end
+      ractors = Array.new(2) do
+        Ractor.new(testdata) do |testdata|
+          Brotli.inflate(Brotli.deflate(testdata)) == testdata
+        end
+      end
+      assert_equal [true, true], ractors.map(&:take)
+    end
+  end
+end

data/test/brotli_writer_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "tempfile"
+
+class BrotliWriterTest < Test::Unit::TestCase
+  def setup
+    @tempfile = Tempfile.new
+  end
+
+  def cleanup
+    @tempfile.close!
+  end
+
+  def testdata
+    @testdata ||= File.binread(
+      File.expand_path(File.join("..", "vendor", "brotli", "tests", "testdata", "alice29.txt"), __dir__)
+    )
+  end
+
+  test "works" do
+    writer = Brotli::Writer.new @tempfile
+    assert_equal testdata.bytesize, writer.write(testdata)
+    assert_equal @tempfile, writer.close
+    assert_equal true, @tempfile.closed?
+
+    @tempfile.open
+    assert_equal testdata, Brotli.inflate(@tempfile.read)
+  end
+
+  test "raise" do
+    assert_raise do
+      Brotli::Writer.new nil
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "brotli"
+
+require "test-unit"
+require "test/unit/rr"
+require "rantly/testunit_extensions"

data/vendor/brotli/c/common/constants.c

@@ -0,0 +1,15 @@
+/* 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 "./constants.h"
+
+const BrotliPrefixCodeRange
+    _kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS] = {
+        {1, 2},     {5, 2},     {9, 2},   {13, 2},    {17, 3},    {25, 3},
+        {33, 3},    {41, 3},    {49, 4},  {65, 4},    {81, 4},    {97, 4},
+        {113, 5},   {145, 5},   {177, 5}, {209, 5},   {241, 6},   {305, 6},
+        {369, 7},   {497, 8},   {753, 9}, {1265, 10}, {2289, 11}, {4337, 12},
+        {8433, 13}, {16625, 24}};

data/vendor/brotli/c/common/constants.h

@@ -4,9 +4,18 @@
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
+/**
+ * @file
+ * Common constants used in decoder and encoder API.
+ */
+
 #ifndef BROTLI_COMMON_CONSTANTS_H_
 #define BROTLI_COMMON_CONSTANTS_H_
 
+#include "./platform.h"
+#include <brotli/port.h>
+#include <brotli/types.h>
+
 /* Specification: 7.3. Encoding of the context map */
 #define BROTLI_CONTEXT_MAP_MAX_RLE 16
 
@@ -28,19 +37,58 @@
 /* "code length of 8 is repeated" */
 #define BROTLI_INITIAL_REPEATED_CODE_LENGTH 8
 
+/* "Large Window Brotli" */
+
+/**
+ * The theoretical maximum number of distance bits specified for large window
+ * brotli, for 64-bit encoders and decoders. Even when in practice 32-bit
+ * encoders and decoders only support up to 30 max distance bits, the value is
+ * set to 62 because it affects the large window brotli file format.
+ * Specifically, it affects the encoding of simple huffman tree for distances,
+ * see Specification RFC 7932 chapter 3.4.
+ */
+#define BROTLI_LARGE_MAX_DISTANCE_BITS 62U
+#define BROTLI_LARGE_MIN_WBITS 10
+/**
+ * The maximum supported large brotli window bits by the encoder and decoder.
+ * Large window brotli allows up to 62 bits, however the current encoder and
+ * decoder, designed for 32-bit integers, only support up to 30 bits maximum.
+ */
+#define BROTLI_LARGE_MAX_WBITS 30
+
 /* Specification: 4. Encoding of distances */
 #define BROTLI_NUM_DISTANCE_SHORT_CODES 16
+/**
+ * Maximal number of "postfix" bits.
+ *
+ * Number of "postfix" bits is stored as 2 bits in meta-block header.
+ */
 #define BROTLI_MAX_NPOSTFIX 3
 #define BROTLI_MAX_NDIRECT 120
 #define BROTLI_MAX_DISTANCE_BITS 24U
-/* BROTLI_NUM_DISTANCE_SYMBOLS == 520 */
-#define BROTLI_NUM_DISTANCE_SYMBOLS (BROTLI_NUM_DISTANCE_SHORT_CODES + \
-                                     BROTLI_MAX_NDIRECT +              \
-                                     (BROTLI_MAX_DISTANCE_BITS <<      \
-                                      (BROTLI_MAX_NPOSTFIX + 1)))
-/* Distance that is guaranteed to be representable in any stream. */
+#define BROTLI_DISTANCE_ALPHABET_SIZE(NPOSTFIX, NDIRECT, MAXNBITS) ( \
+    BROTLI_NUM_DISTANCE_SHORT_CODES + (NDIRECT) +                    \
+    ((MAXNBITS) << ((NPOSTFIX) + 1)))
+/* BROTLI_NUM_DISTANCE_SYMBOLS == 1128 */
+#define BROTLI_NUM_DISTANCE_SYMBOLS \
+    BROTLI_DISTANCE_ALPHABET_SIZE(  \
+        BROTLI_MAX_NDIRECT, BROTLI_MAX_NPOSTFIX, BROTLI_LARGE_MAX_DISTANCE_BITS)
+
+/* ((1 << 26) - 4) is the maximal distance that can be expressed in RFC 7932
+   brotli stream using NPOSTFIX = 0 and NDIRECT = 0. With other NPOSTFIX and
+   NDIRECT values distances up to ((1 << 29) + 88) could be expressed. */
 #define BROTLI_MAX_DISTANCE 0x3FFFFFC
 
+/* ((1 << 31) - 4) is the safe distance limit. Using this number as a limit
+   allows safe distance calculation without overflows, given the distance
+   alphabet size is limited to corresponding size
+   (see kLargeWindowDistanceCodeLimits). */
+#define BROTLI_MAX_ALLOWED_DISTANCE 0x7FFFFFFC
+
+
+/* Specification: 4. Encoding of Literal Insertion Lengths and Copy Lengths */
+#define BROTLI_NUM_INS_COPY_CODES 24
+
 /* 7.1. Context modes and context ID lookup for literals */
 /* "context IDs for literals are in the range of 0..63" */
 #define BROTLI_LITERAL_CONTEXT_BITS 6
@@ -54,4 +102,99 @@
 #define BROTLI_WINDOW_GAP 16
 #define BROTLI_MAX_BACKWARD_LIMIT(W) (((size_t)1 << (W)) - BROTLI_WINDOW_GAP)
 
+typedef struct BrotliDistanceCodeLimit {
+  uint32_t max_alphabet_size;
+  uint32_t max_distance;
+} BrotliDistanceCodeLimit;
+
+/* This function calculates maximal size of distance alphabet, such that the
+   distances greater than the given values can not be represented.
+
+   This limits are designed to support fast and safe 32-bit decoders.
+   "32-bit" means that signed integer values up to ((1 << 31) - 1) could be
+   safely expressed.
+
+   Brotli distance alphabet symbols do not represent consecutive distance
+   ranges. Each distance alphabet symbol (excluding direct distances and short
+   codes), represent interleaved (for NPOSTFIX > 0) range of distances.
+   A "group" of consecutive (1 << NPOSTFIX) symbols represent non-interleaved
+   range. Two consecutive groups require the same amount of "extra bits".
+
+   It is important that distance alphabet represents complete "groups".
+   To avoid complex logic on encoder side about interleaved ranges
+   it was decided to restrict both sides to complete distance code "groups".
+ */
+BROTLI_UNUSED_FUNCTION BrotliDistanceCodeLimit BrotliCalculateDistanceCodeLimit(
+    uint32_t max_distance, uint32_t npostfix, uint32_t ndirect) {
+  BrotliDistanceCodeLimit result;
+  /* Marking this function as unused, because not all files
+     including "constants.h" use it -> compiler warns about that. */
+  BROTLI_UNUSED(&BrotliCalculateDistanceCodeLimit);
+  if (max_distance <= ndirect) {
+    /* This case never happens / exists only for the sake of completeness. */
+    result.max_alphabet_size = max_distance + BROTLI_NUM_DISTANCE_SHORT_CODES;
+    result.max_distance = max_distance;
+    return result;
+  } else {
+    /* The first prohibited value. */
+    uint32_t forbidden_distance = max_distance + 1;
+    /* Subtract "directly" encoded region. */
+    uint32_t offset = forbidden_distance - ndirect - 1;
+    uint32_t ndistbits = 0;
+    uint32_t tmp;
+    uint32_t half;
+    uint32_t group;
+    /* Postfix for the last dcode in the group. */
+    uint32_t postfix = (1u << npostfix) - 1;
+    uint32_t extra;
+    uint32_t start;
+    /* Remove postfix and "head-start". */
+    offset = (offset >> npostfix) + 4;
+    /* Calculate the number of distance bits. */
+    tmp = offset / 2;
+    /* Poor-man's log2floor, to avoid extra dependencies. */
+    while (tmp != 0) {ndistbits++; tmp = tmp >> 1;}
+    /* One bit is covered with subrange addressing ("half"). */
+    ndistbits--;
+    /* Find subrange. */
+    half = (offset >> ndistbits) & 1;
+    /* Calculate the "group" part of dcode. */
+    group = ((ndistbits - 1) << 1) | half;
+    /* Calculated "group" covers the prohibited distance value. */
+    if (group == 0) {
+      /* This case is added for correctness; does not occur for limit > 128. */
+      result.max_alphabet_size = ndirect + BROTLI_NUM_DISTANCE_SHORT_CODES;
+      result.max_distance = ndirect;
+      return result;
+    }
+    /* Decrement "group", so it is the last permitted "group". */
+    group--;
+    /* After group was decremented, ndistbits and half must be recalculated. */
+    ndistbits = (group >> 1) + 1;
+    /* The last available distance in the subrange has all extra bits set. */
+    extra = (1u << ndistbits) - 1;
+    /* Calculate region start. NB: ndistbits >= 1. */
+    start = (1u << (ndistbits + 1)) - 4;
+    /* Move to subregion. */
+    start += (group & 1) << ndistbits;
+    /* Calculate the alphabet size. */
+    result.max_alphabet_size = ((group << npostfix) | postfix) + ndirect +
+        BROTLI_NUM_DISTANCE_SHORT_CODES + 1;
+    /* Calculate the maximal distance representable by alphabet. */
+    result.max_distance = ((start + extra) << npostfix) + postfix + ndirect + 1;
+    return result;
+  }
+}
+
+/* Represents the range of values belonging to a prefix code:
+   [offset, offset + 2^nbits) */
+typedef struct {
+  uint16_t offset;
+  uint8_t nbits;
+} BrotliPrefixCodeRange;
+
+/* "Soft-private", it is exported, but not "advertised" as API. */
+BROTLI_COMMON_API extern const BrotliPrefixCodeRange
+    _kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
+
 #endif  /* BROTLI_COMMON_CONSTANTS_H_ */