extbrotli 0.0.1.PROTOTYPE

data/contrib/brotli/enc/write_bits.h

@@ -0,0 +1,91 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Write bits into a byte array.
+
+#ifndef BROTLI_ENC_WRITE_BITS_H_
+#define BROTLI_ENC_WRITE_BITS_H_
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "./port.h"
+
+namespace brotli {
+
+//#define BIT_WRITER_DEBUG
+
+// This function writes bits into bytes in increasing addresses, and within
+// a byte least-significant-bit first.
+//
+// The function can write up to 56 bits in one go with WriteBits
+// Example: let's assume that 3 bits (Rs below) have been written already:
+//
+// BYTE-0     BYTE+1       BYTE+2
+//
+// 0000 0RRR    0000 0000    0000 0000
+//
+// Now, we could write 5 or less bits in MSB by just sifting by 3
+// and OR'ing to BYTE-0.
+//
+// For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
+// and locate the rest in BYTE+1, BYTE+2, etc.
+inline void WriteBits(int n_bits,
+                      uint64_t bits,
+                      int * __restrict pos,
+                      uint8_t * __restrict array) {
+#ifdef BIT_WRITER_DEBUG
+  printf("WriteBits  %2d  0x%016llx  %10d\n", n_bits, bits, *pos);
+#endif
+  assert(bits < 1ULL << n_bits);
+#ifdef IS_LITTLE_ENDIAN
+  // This branch of the code can write up to 56 bits at a time,
+  // 7 bits are lost by being perhaps already in *p and at least
+  // 1 bit is needed to initialize the bit-stream ahead (i.e. if 7
+  // bits are in *p and we write 57 bits, then the next write will
+  // access a byte that was never initialized).
+  uint8_t *p = &array[*pos >> 3];
+  uint64_t v = *p;
+  v |= bits << (*pos & 7);
+  BROTLI_UNALIGNED_STORE64(p, v);  // Set some bits.
+  *pos += n_bits;
+#else
+  // implicit & 0xff is assumed for uint8_t arithmetics
+  uint8_t *array_pos = &array[*pos >> 3];
+  const int bits_reserved_in_first_byte = (*pos & 7);
+  bits <<= bits_reserved_in_first_byte;
+  *array_pos++ |= bits;
+  for (int bits_left_to_write = n_bits - 8 + bits_reserved_in_first_byte;
+       bits_left_to_write >= 1;
+       bits_left_to_write -= 8) {
+    bits >>= 8;
+    *array_pos++ = bits;
+  }
+  *array_pos = 0;
+  *pos += n_bits;
+#endif
+}
+
+inline void WriteBitsPrepareStorage(int pos, uint8_t *array) {
+#ifdef BIT_WRITER_DEBUG
+  printf("WriteBitsPrepareStorage            %10d\n", pos);
+#endif
+  assert((pos & 7) == 0);
+  array[pos >> 3] = 0;
+}
+
+}  // namespace brotli
+
+#endif  // BROTLI_ENC_WRITE_BITS_H_

data/ext/extbrotli.cc

@@ -0,0 +1,24 @@
+#include "extbrotli.h"
+
+VALUE mBrotli;
+VALUE mConst;
+VALUE eError;
+VALUE eNeedsMoreInput;
+VALUE eNeedsMoreOutput;
+
+EXTBROTLI_CEXTERN
+void
+Init_extbrotli(void)
+{
+    mBrotli = rb_define_module("Brotli");
+
+    mConst = rb_define_module_under(mBrotli, "Constants");
+    rb_include_module(mBrotli, mConst);
+
+    eError = rb_define_class_under(mBrotli, "Error", rb_eRuntimeError);
+    eNeedsMoreInput = rb_define_class_under(mBrotli, "NeedsMoreInput", eError);
+    eNeedsMoreOutput = rb_define_class_under(mBrotli, "NeedsMoreOutput", eError);
+
+    extbrotli_init_lowlevelencoder();
+    extbrotli_init_lowleveldecoder();
+}

data/ext/extbrotli.h

@@ -0,0 +1,73 @@
+#ifndef EXTBROTLI_H
+#define EXTBROTLI_H 1
+
+#include <ruby.h>
+
+#ifdef __cplusplus
+#   define EXTBROTLI_CEXTERN        extern "C"
+#   define EXTBROTLI_BEGIN_CEXTERN  EXTBROTLI_CEXTERN {
+#   define EXTBROTLI_END_CEXTERN    }
+#else
+#   define EXTBROTLI_CEXTERN
+#   define EXTBROTLI_BEGIN_CEXTERN
+#   define EXTBROTLI_END_CEXTERN
+#endif
+
+#define RDOCFAKE(...)
+
+EXTBROTLI_BEGIN_CEXTERN
+
+extern VALUE mBrotli;
+RDOCFAKE(mBrotli = rb_define_module("Brotli"));
+
+extern VALUE mConst;
+RDOCFAKE(mConst = rb_define_module_under(mBrotli, "Constants"));
+
+extern VALUE eError;
+RDOCFAKE(eError = rb_define_class_under(mBrotli, "Error", rb_eRuntimeError));
+
+extern VALUE eNeedsMoreInput;
+RDOCFAKE(eNeedsMoreInput = rb_define_class_under(mBrotli, "NeedsMoreInput", eError));
+
+extern VALUE eNeedsMoreOutput;
+RDOCFAKE(eNeedsMoreOutput = rb_define_class_under(mBrotli, "NeedsMoreOutput", eError));
+
+void extbrotli_init_lowlevelencoder(void);
+void extbrotli_init_lowleveldecoder(void);
+
+static inline void
+referr(VALUE obj)
+{
+    rb_raise(rb_eTypeError,
+            "invalid reference - #<%s:%p>",
+            rb_obj_classname(obj), (void *)obj);
+}
+
+static inline void
+reiniterror(VALUE obj)
+{
+    rb_raise(rb_eTypeError,
+            "initialized object already - #<%s:%p>",
+            rb_obj_classname(obj), (void *)obj);
+}
+
+static inline void *
+getrefp(VALUE obj, const rb_data_type_t *type)
+{
+    void *p;
+    TypedData_Get_Struct(obj, void, type, p);
+    return p;
+}
+
+static inline void *
+getref(VALUE obj, const rb_data_type_t *type)
+{
+    void *p = getrefp(obj, type);
+    if (!p) { referr(obj); }
+    return p;
+}
+
+
+EXTBROTLI_END_CEXTERN
+
+#endif /* EXTBROTLI_H */

data/ext/extconf.rb

@@ -0,0 +1,35 @@
+#!ruby
+#vim: set fileencoding:utf-8
+
+require "mkmf"
+
+dir = File.dirname(__FILE__).gsub(/[\[\{\?\*]/, "[\\0]")
+
+encfiles = Dir.glob(File.join(dir, "../contrib/brotli/enc/*.cc")).sort
+encsrc = "brotli_encoder.cc"
+File.write encsrc, (encfiles.map {|n| "#include \"#{n}\"" }.join("\n") << "\n")
+decfiles = Dir.glob(File.join(dir, "../contrib/brotli/dec/*.c")).sort
+decsrc = "brotli_decoder.c"
+File.write decsrc, (decfiles.map {|n| "#include \"#{n}\"" }.join("\n") << "\n")
+
+filepattern = "*.c{,c,pp}"
+target = File.join(dir, filepattern)
+files = Dir.glob(target).map { |n| File.basename n }
+rejects = (RbConfig::CONFIG["arch"] =~ /mswin|mingw/) ? /_pthreads_/ : /_win32_/
+files.reject! { |n| n =~ rejects }
+$srcs = files + [encsrc, decsrc]
+
+#$VPATH.push "$(srcdir)/../contrib"
+
+#find_header "brotli/enc/encode.h", "$(srcdir)/../contrib" or abort
+find_header "brotli/dec/decode.h", "$(srcdir)/../contrib" or abort
+
+if RbConfig::CONFIG["arch"] =~ /mingw/
+  $CPPFLAGS << " -D__forceinline=__attribute__\\(\\(always_inline\\)\\)"
+  $CXXFLAGS << " -std=gnu++11"
+  $LDFLAGS << " -static-libgcc -static-libstdc++"
+end
+
+try_link "void main(void){}", " -Wl,-Bsymbolic " and $LDFLAGS << " -Wl,-Bsymbolic "
+
+create_makefile("extbrotli")

data/ext/lldecoder.c

@@ -0,0 +1,220 @@
+#include "extbrotli.h"
+#include <brotli/dec/decode.h>
+
+static VALUE cLLDecoder; /* class Brotli::LowLevelDecoder */
+
+static void
+lldec_free(void *pp)
+{
+    if (pp) {
+        BrotliState *p = (BrotliState *)pp;
+        BrotliStateCleanup(p);
+    }
+}
+
+static const rb_data_type_t lldecoder_type = {
+    .wrap_struct_name = "extbrotli.lowleveldecoder",
+    .function.dmark = NULL,
+    .function.dfree = lldec_free,
+    .function.dsize = NULL,
+};
+
+static inline BrotliState *
+getlldecoderp(VALUE obj)
+{
+    return (BrotliState *)getrefp(obj, &lldecoder_type);
+}
+
+static inline BrotliState *
+getlldecoder(VALUE obj)
+{
+    return (BrotliState *)getref(obj, &lldecoder_type);
+}
+
+static VALUE
+lldec_alloc(VALUE mod)
+{
+    return TypedData_Wrap_Struct(mod, &lldecoder_type, NULL);
+}
+
+static VALUE
+lldec_init(VALUE dec)
+{
+    BrotliState *p = getlldecoderp(dec);
+    if (p) { reiniterror(dec); }
+    DATA_PTR(dec) = p = ALLOC(BrotliState);
+    BrotliStateInit(p);
+    return dec;
+}
+
+/*
+ * call-seq:
+ *  decode(src, dest, maxdest, finish) -> [result_code, src, dest]
+ */
+static VALUE
+lldec_decode(VALUE dec, VALUE src, VALUE dest, VALUE maxdest, VALUE finish)
+{
+    BrotliState *p = getlldecoder(dec);
+
+    char *srcp, *destp;
+    size_t srcsize, destsize;
+    if (NIL_P(src)) {
+        srcp = NULL;
+        srcsize = 0;
+    } else {
+        rb_obj_infect(dec, src);
+        rb_check_type(src, RUBY_T_STRING);
+        RSTRING_GETMEM(src, srcp, srcsize);
+    }
+    if (NIL_P(dest)) {
+        destp = NULL;
+        destsize = 0;
+    } else {
+        rb_check_type(dest, RUBY_T_STRING);
+        destsize = NUM2SIZET(maxdest);
+        rb_str_modify(dest);
+        rb_str_set_len(dest, 0);
+        rb_str_modify_expand(dest, destsize);
+        destp = RSTRING_PTR(dest);
+    }
+    char *srcpp = srcp, *destpp = destp;
+    size_t total;
+    BrotliResult s = BrotliDecompressBufferStreaming(
+            &srcsize, (const uint8_t **)&srcp, NUM2INT(finish),
+            &destsize, (uint8_t **)&destp, &total, p);
+    switch (s) {
+    case BROTLI_RESULT_ERROR:
+        rb_raise(eError, "failed BrotliDecompressBufferStreaming() - #<%s:%p>", rb_obj_classname(dec), (void *)dec);
+    case BROTLI_RESULT_SUCCESS:
+    case BROTLI_RESULT_NEEDS_MORE_INPUT:
+    case BROTLI_RESULT_NEEDS_MORE_OUTPUT:
+        if (destp > destpp) {
+            rb_obj_infect(dest, dec);
+            rb_str_set_len(dest, destp - destpp);
+        }
+        if (srcsize > 0) {
+            src = rb_str_substr(src, srcp - srcpp, srcsize);
+        } else {
+            src = Qnil;
+        }
+        break;
+    default:
+        rb_raise(eError,
+                "failed BrotliDecompressBufferStreaming() - unknown result code (%d) - #<%s:%p>",
+                s, rb_obj_classname(dec), (void *)dec);
+    }
+
+    const VALUE vec[3] = { INT2NUM(s), src, dest };
+    return rb_ary_new4(3, vec);
+}
+
+static void
+lldec_s_decode_args(int argc, VALUE argv[], VALUE *src, VALUE *dest, size_t *srcsize, size_t *destsize, int *partial)
+{
+    if (argc > 0) {
+        *src = argv[0];
+        rb_check_type(*src, RUBY_T_STRING);
+        *srcsize = RSTRING_LEN(*src);
+
+        int s;
+        switch (argc) {
+        case 1:
+            s = BrotliDecompressedSize(*srcsize, (const uint8_t *)RSTRING_PTR(*src), destsize);
+            if (s == 0) { rb_raise(eError, "failed BrotliDecompressedSize()"); }
+            *dest = rb_str_buf_new(*destsize);
+            *partial = 0;
+            return;
+        case 2:
+            *dest = argv[1];
+            if (rb_type_p(*dest, RUBY_T_STRING)) {
+                s = BrotliDecompressedSize(*srcsize, (const uint8_t *)RSTRING_PTR(*src), destsize);
+                if (s == 0) { rb_raise(eError, "failed BrotliDecompressedSize()"); }
+                rb_check_type(*dest, RUBY_T_STRING);
+                rb_str_modify(*dest);
+                rb_str_set_len(*dest, 0);
+                rb_str_modify_expand(*dest, *destsize);
+            } else {
+                *destsize = NUM2SIZET(*dest);
+                *dest = rb_str_buf_new(*destsize);
+            }
+            *partial = 0;
+            return;
+        case 3:
+            *destsize = NUM2SIZET(argv[1]);
+            *dest = argv[2];
+            if (*dest == Qtrue || *dest == Qfalse) {
+                *partial = RTEST(*dest) ? 1 : 0;
+                *dest = rb_str_buf_new(*destsize);
+            } else {
+                rb_check_type(*dest, RUBY_T_STRING);
+                rb_str_modify(*dest);
+                rb_str_set_len(*dest, 0);
+                rb_str_modify_expand(*dest, *destsize);
+                *partial = 0;
+            }
+            return;
+        case 4:
+            *destsize = NUM2SIZET(argv[1]);
+            *dest = argv[2];
+            rb_check_type(*dest, RUBY_T_STRING);
+            rb_str_modify(*dest);
+            rb_str_set_len(*dest, 0);
+            rb_str_modify_expand(*dest, *destsize);
+            *partial = RTEST(argv[3]) ? 1 : 0;
+            return;
+        }
+    }
+
+    rb_error_arity(argc, 1, 4);
+}
+
+/*
+ * call-seq:
+ *  decode(src, dest = "") -> decoded binary string
+ *  decode(src, destsize, partial = false) -> decoded binary string
+ *  decode(src, destsize, dest = "", partial = false) -> decoded binary string
+ */
+static VALUE
+lldec_s_decode(int argc, VALUE argv[], VALUE mod)
+{
+    VALUE src, dest;
+    size_t srcsize, destsize;
+    int partial;
+    lldec_s_decode_args(argc, argv, &src, &dest, &srcsize, &destsize, &partial);
+
+    int s = BrotliDecompressBuffer(srcsize, (const uint8_t *)RSTRING_PTR(src),
+            &destsize, (uint8_t *)RSTRING_PTR(dest));
+
+    if (s == BROTLI_RESULT_NEEDS_MORE_INPUT) {
+        if (!partial) {
+            rb_raise(eNeedsMoreInput, "failed BrotliDecompressBuffer()");
+        }
+    } else if (s == BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
+        if (!partial) {
+            rb_raise(eNeedsMoreOutput, "failed BrotliDecompressBuffer()");
+        }
+    } else if (s != BROTLI_RESULT_SUCCESS) {
+        rb_raise(eError, "failed BrotliDecompressBuffer() - status=%d", s);
+    }
+
+    rb_obj_infect(dest, src);
+    rb_str_set_len(dest, destsize);
+    return dest;
+}
+
+void
+extbrotli_init_lowleveldecoder(void)
+{
+    cLLDecoder = rb_define_class_under(mBrotli, "LowLevelDecoder", rb_cObject);
+    rb_define_singleton_method(cLLDecoder, "decode", RUBY_METHOD_FUNC(lldec_s_decode), -1);
+
+    rb_define_alloc_func(cLLDecoder, lldec_alloc);
+    rb_define_method(cLLDecoder, "initialize", RUBY_METHOD_FUNC(lldec_init), 0);
+    rb_define_method(cLLDecoder, "decode", RUBY_METHOD_FUNC(lldec_decode), 4);
+
+    rb_include_module(cLLDecoder, mConst);
+    rb_define_const(mConst, "RESULT_ERROR",             INT2FIX(BROTLI_RESULT_ERROR));
+    rb_define_const(mConst, "RESULT_SUCCESS",           INT2FIX(BROTLI_RESULT_SUCCESS));
+    rb_define_const(mConst, "RESULT_NEEDS_MORE_INPUT",  INT2FIX(BROTLI_RESULT_NEEDS_MORE_INPUT));
+    rb_define_const(mConst, "RESULT_NEEDS_MORE_OUTPUT", INT2FIX(BROTLI_RESULT_NEEDS_MORE_OUTPUT));
+}