heatshrink 0.1.0

data/ext/heatshrink/heatshrink_encoder.h

@@ -0,0 +1,109 @@
+#ifndef HEATSHRINK_ENCODER_H
+#define HEATSHRINK_ENCODER_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "heatshrink_common.h"
+#include "heatshrink_config.h"
+
+typedef enum {
+    HSER_SINK_OK,               /* data sunk into input buffer */
+    HSER_SINK_ERROR_NULL=-1,    /* NULL argument */
+    HSER_SINK_ERROR_MISUSE=-2,  /* API misuse */
+} HSE_sink_res;
+
+typedef enum {
+    HSER_POLL_EMPTY,            /* input exhausted */
+    HSER_POLL_MORE,             /* poll again for more output  */
+    HSER_POLL_ERROR_NULL=-1,    /* NULL argument */
+    HSER_POLL_ERROR_MISUSE=-2,  /* API misuse */
+} HSE_poll_res;
+
+typedef enum {
+    HSER_FINISH_DONE,           /* encoding is complete */
+    HSER_FINISH_MORE,           /* more output remaining; use poll */
+    HSER_FINISH_ERROR_NULL=-1,  /* NULL argument */
+} HSE_finish_res;
+
+#if HEATSHRINK_DYNAMIC_ALLOC
+#define HEATSHRINK_ENCODER_WINDOW_BITS(HSE) \
+    ((HSE)->window_sz2)
+#define HEATSHRINK_ENCODER_LOOKAHEAD_BITS(HSE) \
+    ((HSE)->lookahead_sz2)
+#define HEATSHRINK_ENCODER_INDEX(HSE) \
+    ((HSE)->search_index)
+struct hs_index {
+    uint16_t size;
+    int16_t index[];
+};
+#else
+#define HEATSHRINK_ENCODER_WINDOW_BITS(_) \
+    (HEATSHRINK_STATIC_WINDOW_BITS)
+#define HEATSHRINK_ENCODER_LOOKAHEAD_BITS(_) \
+    (HEATSHRINK_STATIC_LOOKAHEAD_BITS)
+#define HEATSHRINK_ENCODER_INDEX(HSE) \
+    (&(HSE)->search_index)
+struct hs_index {
+    uint16_t size;
+    int16_t index[2 << HEATSHRINK_STATIC_WINDOW_BITS];
+};
+#endif
+
+typedef struct {
+    uint16_t input_size;        /* bytes in input buffer */
+    uint16_t match_scan_index;
+    uint16_t match_length;
+    uint16_t match_pos;
+    uint16_t outgoing_bits;     /* enqueued outgoing bits */
+    uint8_t outgoing_bits_count;
+    uint8_t flags;
+    uint8_t state;              /* current state machine node */
+    uint8_t current_byte;       /* current byte of output */
+    uint8_t bit_index;          /* current bit index */
+#if HEATSHRINK_DYNAMIC_ALLOC
+    uint8_t window_sz2;         /* 2^n size of window */
+    uint8_t lookahead_sz2;      /* 2^n size of lookahead */
+#if HEATSHRINK_USE_INDEX
+    struct hs_index *search_index;
+#endif
+    /* input buffer and / sliding window for expansion */
+    uint8_t buffer[];
+#else
+    #if HEATSHRINK_USE_INDEX
+        struct hs_index search_index;
+    #endif
+    /* input buffer and / sliding window for expansion */
+    uint8_t buffer[2 << HEATSHRINK_ENCODER_WINDOW_BITS(_)];
+#endif
+} heatshrink_encoder;
+
+#if HEATSHRINK_DYNAMIC_ALLOC
+/* Allocate a new encoder struct and its buffers.
+ * Returns NULL on error. */
+heatshrink_encoder *heatshrink_encoder_alloc(uint8_t window_sz2,
+    uint8_t lookahead_sz2);
+
+/* Free an encoder. */
+void heatshrink_encoder_free(heatshrink_encoder *hse);
+#endif
+
+/* Reset an encoder. */
+void heatshrink_encoder_reset(heatshrink_encoder *hse);
+
+/* Sink up to SIZE bytes from IN_BUF into the encoder.
+ * INPUT_SIZE is set to the number of bytes actually sunk (in case a
+ * buffer was filled.). */
+HSE_sink_res heatshrink_encoder_sink(heatshrink_encoder *hse,
+    uint8_t *in_buf, size_t size, size_t *input_size);
+
+/* Poll for output from the encoder, copying at most OUT_BUF_SIZE bytes into
+ * OUT_BUF (setting *OUTPUT_SIZE to the actual amount copied). */
+HSE_poll_res heatshrink_encoder_poll(heatshrink_encoder *hse,
+    uint8_t *out_buf, size_t out_buf_size, size_t *output_size);
+
+/* Notify the encoder that the input stream is finished.
+ * If the return value is HSER_FINISH_MORE, there is still more output, so
+ * call heatshrink_encoder_poll and repeat. */
+HSE_finish_res heatshrink_encoder_finish(heatshrink_encoder *hse);
+
+#endif

data/ext/heatshrink/heatshrink_ruby.c

@@ -0,0 +1,98 @@
+#include <ruby.h>
+// TODO: debug
+#include <stdio.h>
+
+#include "heatshrink_encoder.h"
+#include "heatshrink_decoder.h"
+
+#define INPUT_BUFFER_SIZE 256
+
+struct Buffer {
+  uint8_t *p;
+  size_t n;
+};
+
+// sink data from src buffer into xcoder
+#define HSRUBY_SINK(K, kind, src, hsd)                                         \
+  do {                                                                         \
+    size_t nread;                                                              \
+    HS##K##_sink_res sres =                                                    \
+        heatshrink_##kind##_sink(hsx, src.p, src.n, &nread);                   \
+    if (sres < 0)                                                              \
+      rb_raise(rb_eRuntimeError, "Failed to sink data " #kind " %d.", sres);   \
+    src.p += nread;                                                            \
+    src.n -= nread;                                                            \
+  } while (0);
+
+// poll data from xcoder and append it to ruby string
+#define HSRUBY_POLL_CAT(K, kind, hsx, str)                                     \
+  HS##K##_poll_res pres;                                                       \
+  do {                                                                         \
+    size_t nread;                                                              \
+    uint8_t buf[1024];                                                         \
+    pres = heatshrink_##kind##_poll(hsx, buf, sizeof(buf), &nread);            \
+    if (pres < 0)                                                              \
+      rb_raise(rb_eRuntimeError, "Failed to poll data %d.", pres);             \
+    rb_str_cat(res, (char *)buf, nread);                                       \
+  } while (pres == HS##K##R_POLL_MORE);
+
+// finish xcoder
+#define HSRUBY_FINISH(X, xcoder, hsx, res)                                     \
+  HS##X##_finish_res fres;                                                     \
+  while (1) {                                                                  \
+    fres = heatshrink_##xcoder##_finish(hsx);                                  \
+    if (fres == HS##X##R_FINISH_DONE)                                          \
+      break;                                                                   \
+    if (fres < 0)                                                              \
+      rb_raise(rb_eRuntimeError, "Failed to finish %d.", fres);                \
+    HSRUBY_POLL_CAT(X, xcoder, hsx, res);                                      \
+  }
+
+// alloc a decoder
+#define HSRUBY_ALLOC_D(ibs, wsz2, lasz2)                                       \
+  heatshrink_decoder_alloc(ibs, wsz2, lasz2)
+// alloc an encoder
+#define HSRUBY_ALLOC_E(ibs, wsz2, lasz2) heatshrink_encoder_alloc(wsz2, lasz2)
+// free an xcoder
+#define HSRUBY_FREE(X, xcoder, hsx) heatshrink_##xcoder##_free(hsx)
+
+// encode/decode implementation
+#define HSRUBY_IMPL(X, xcoder)                                                 \
+  Check_Type(data, T_STRING);                                                  \
+  Check_Type(window_sz2, T_FIXNUM);                                            \
+  Check_Type(lookahead_sz2, T_FIXNUM);                                         \
+                                                                               \
+  struct Buffer src = {(uint8_t *)RSTRING_PTR(data), RSTRING_LEN(data)};       \
+  VALUE res = rb_str_new(NULL, 0);                                             \
+                                                                               \
+  int wsz2 = FIX2INT(window_sz2);                                              \
+  int lasz2 = FIX2INT(lookahead_sz2);                                          \
+                                                                               \
+  heatshrink_##xcoder *hsx = HSRUBY_ALLOC_##X(INPUT_BUFFER_SIZE, wsz2, lasz2); \
+  if (hsx == NULL)                                                             \
+    rb_raise(rb_eRuntimeError, "Failed to allocate " #xcoder ".");             \
+                                                                               \
+  while (src.n) {                                                              \
+    HSRUBY_SINK(X, xcoder, src, hsx);                                          \
+    HSRUBY_POLL_CAT(X, xcoder, hsx, res);                                      \
+  }                                                                            \
+  HSRUBY_FINISH(X, xcoder, hsx, res);                                          \
+  HSRUBY_FREE(X, xcoder, hsx);                                                 \
+  return res;
+
+static VALUE compress(VALUE self, VALUE data, VALUE window_sz2,
+                      VALUE lookahead_sz2) {
+  HSRUBY_IMPL(E, encoder);
+}
+
+static VALUE uncompress(VALUE self, VALUE data, VALUE window_sz2,
+                        VALUE lookahead_sz2) {
+  HSRUBY_IMPL(D, decoder);
+}
+
+void Init_heatshrink(void) {
+  VALUE mod = rb_define_module("Heatshrink");
+  mod = rb_define_module_under(mod, "Internal");
+  rb_define_module_function(mod, "compress", &compress, 3);
+  rb_define_module_function(mod, "uncompress", &uncompress, 3);
+}

data/lib/heatshrink.rb

@@ -0,0 +1,14 @@
+require 'heatshrink/heatshrink'
+
+module Heatshrink
+  DEF_WINDOW_SZ2 = 11
+  DEF_LOOKAHEAD_SZ2 = 4
+
+  def self.compress data, window_sz2=DEF_WINDOW_SZ2, lookahead_sz2=DEF_LOOKAHEAD_SZ2
+    Internal.compress data, window_sz2, lookahead_sz2
+  end
+
+  def self.uncompress data, window_sz2=DEF_WINDOW_SZ2, lookahead_sz2=DEF_LOOKAHEAD_SZ2
+    Internal.uncompress data, window_sz2, lookahead_sz2
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: heatshrink
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Scott Vokes
+- Martin Nowak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: code@dawg.eu
+executables: []
+extensions:
+- ext/heatshrink/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/heatshrink/extconf.rb
+- ext/heatshrink/heatshrink_common.h
+- ext/heatshrink/heatshrink_config.h
+- ext/heatshrink/heatshrink_decoder.c
+- ext/heatshrink/heatshrink_decoder.h
+- ext/heatshrink/heatshrink_encoder.c
+- ext/heatshrink/heatshrink_encoder.h
+- ext/heatshrink/heatshrink_ruby.c
+- lib/heatshrink.rb
+homepage: http://github.com/MartinNowak/heatshrink-ruby
+licenses:
+- ICS
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: data compression library for embedded/real-time systems
+test_files: []