lzfse 0.0.1.pre.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07b55f339ef7d623c2e3c5805f354a6e9b2152e9699d34d8b5fc4fc39e3b177a
+  data.tar.gz: '074309076709dc4772b82de24f005a34c9ab9fa7640ce915ea4086afe0b44f33'
+SHA512:
+  metadata.gz: 4f594884e1eb6d0efe2e04e79544307b1671c27ab2ad65414088e596c88b4cbaad1a4100c30428aa6a75cd9e19c5b5db7ec5e46788380ecfebfba9e447b2a10e
+  data.tar.gz: ba5c1b9c9357dc6776fda37537175ffdc8191cd4ac8f914221c27aa460f4d4d9ecd783a6e5bc22e86775a7e03d4f98e81346e4e615d0d99891374da1ce5aac9a

data/.yardopts

@@ -0,0 +1 @@
+--no-private --markup-provider=redcarpet --markup=markdown - README.md LICENSE ext/lzfse/LICENSE

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 William Woodruff <william @ yossarian.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+lzfse.rb
+========
+
+[![CI](https://github.com/woodruffw/lzfse.rb/actions/workflows/ci.yml/badge.svg)](https://github.com/woodruffw/lzfse.rb/actions/workflows/ci.yml)
+
+Ruby bindings for Apple's reference implementation of [LZFSE](https://github.com/lzfse/lzfse).
+
+Bindings are also provided for the internal LZVN APIs.
+
+## Usage
+
+You'll need the gem:
+
+```bash
+gem install lzfse
+```
+
+Then, use the four public APIs:
+
+```ruby
+require "lzfse"
+
+# LZFSE
+compressed = LZFSE.lzfse_compress "please compress this string"
+LZFSE.lzfse_decompress compressed
+
+# LZVN
+compressed = LZFSE.lzvn_compress "please also compress this string!"
+LZFSE.lzvn_compress compressed
+```
+
+Each API takes a single string and returns a string.
+
+## License
+
+*lzfse.rb* is licensed under the MIT license.
+
+Apple's reference implementation of LZFSE is licensed under the 3-clause BSD license.

data/ext/lzfse/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2015-2016, Apple Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:  
+
+1.  Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder(s) nor the names of any contributors
+    may be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGE.
+

data/ext/lzfse/ext.c

@@ -0,0 +1,194 @@
+#include "ext.h"
+
+VALUE mLZFSE = Qnil;
+VALUE cEncodeError = Qnil;
+VALUE cDecodeError = Qnil;
+
+static VALUE mLZFSE_lzfse_encode_intern(VALUE self, VALUE input) {
+  Check_Type(input, T_STRING);
+
+  size_t input_len = RSTRING_LEN(input);
+  uint8_t *input_buf = (uint8_t *)RSTRING_PTR(input);
+
+  if (input_len <= 0) {
+    rb_raise(cEncodeError, "input buffer must not be empty");
+  }
+
+  size_t output_len = input_len + 4096;
+  uint8_t *output_buf = malloc(output_len);
+
+  output_len = lzfse_encode_buffer(output_buf, output_len, input_buf, input_len, NULL);
+
+  if (output_len <= 0) {
+    rb_raise(cEncodeError, "encode failed (output buffer possibly too small)");
+  }
+
+  VALUE output_str = rb_str_new((char *)output_buf, output_len);
+  free(output_buf);
+
+  return output_str;
+}
+
+static VALUE mLZFSE_lzfse_decode_intern(VALUE self, VALUE input) {
+  Check_Type(input, T_STRING);
+
+  size_t input_len = RSTRING_LEN(input);
+  uint8_t *input_buf = (uint8_t *)RSTRING_PTR(input);
+
+  if (input_len <= 0) {
+    rb_raise(cDecodeError, "input buffer must not be empty");
+  }
+
+  // Educated guess: start with a decompression buffer twice as large and work
+  // from there.
+  size_t output_len = input_len * 2;
+  uint8_t *output_buf = malloc(output_len);
+
+  // NOTE(ww): The public `lzfse_decode_buffer` API is a little bit braindead,
+  // so we use the "internal" `lzfse_decode` API instead. This requires
+  // us to set the decoder state up for ourselves.
+  void *scratch_buffer = malloc(lzfse_decode_scratch_size() + 1);
+  lzfse_decoder_state *state = (lzfse_decoder_state *)scratch_buffer;
+
+  // NOTE(ww): It would be nice if there was an allocate-on-demand API, but
+  // there isn't. So we do things the bad way.
+  do {
+    // We have to update each of these fields with every try, to avoid
+    // mixing-and-matching decompression states between attempts.
+    memset(state, 0x00, sizeof(lzfse_decoder_state));
+    state->src = input_buf;
+    state->src_begin = input_buf;
+    state->src_end = input_buf + input_len;
+    state->dst = output_buf;
+    state->dst_begin = output_buf;
+    state->dst_end = output_buf + output_len;
+
+    int status = lzfse_decode(state);
+    if (status == LZFSE_STATUS_OK) {
+      break;
+    } else if (status == LZFSE_STATUS_DST_FULL) {
+      // Try again. There is almost certainly a better way of doing this
+      // that involves preserving the decoder state and reusing the partially
+      // decoded buffer, but this suffices for now.
+      output_len *= 2;
+      output_buf = realloc(output_buf, output_len);
+    } else {
+      rb_raise(cDecodeError, "internal error while decoding (%d)", status);
+    }
+  } while (true);
+
+  free(scratch_buffer);
+
+  VALUE output_str = rb_str_new((char *)output_buf, state->dst - output_buf);
+  free(output_buf);
+
+  return output_str;
+}
+
+static VALUE mLZFSE_lzvn_encode_intern(VALUE self, VALUE input) {
+  Check_Type(input, T_STRING);
+
+  size_t input_len = RSTRING_LEN(input);
+  uint8_t *input_buf = (uint8_t *)RSTRING_PTR(input);
+
+  if (input_len <= 0) {
+    rb_raise(cEncodeError, "input buffer must not be empty");
+  }
+
+  if (input_len < LZVN_ENCODE_MIN_SRC_SIZE) {
+    rb_raise(cEncodeError, "input is too small for LZVN (%zu < %zu)", input_len,
+             LZVN_ENCODE_MIN_SRC_SIZE);
+  }
+
+  size_t output_len = input_len + 4096;
+  uint8_t *output_buf = malloc(output_len);
+
+  // NOTE(ww): lzvn_encode_buffer takes the same scratch buffer as the LZFSE
+  // APIs. See lzfse_encode_buffer_with_scratch in lzfse_encode.c.
+  void *scratch_buffer = malloc(lzfse_encode_scratch_size() + 1);
+
+  output_len = lzvn_encode_buffer(output_buf, output_len, input_buf, input_len, scratch_buffer);
+  if (output_len <= 0) {
+    rb_raise(cEncodeError, "encode failed (output buffer possibly too small)");
+  }
+
+  free(scratch_buffer);
+  VALUE output_str = rb_str_new((char *)output_buf, output_len);
+  free(output_buf);
+
+  return output_str;
+}
+
+static VALUE mLZFSE_lzvn_decode_intern(VALUE self, VALUE input) {
+  Check_Type(input, T_STRING);
+
+  size_t input_len = RSTRING_LEN(input);
+  uint8_t *input_buf = (uint8_t *)RSTRING_PTR(input);
+
+  if (input_len <= 0) {
+    rb_raise(cDecodeError, "input buffer must not be empty");
+  }
+
+  // Educated guess: start with a decompression buffer twice as large and work
+  // from there.
+  size_t output_len = input_len * 2;
+  uint8_t *output_buf = malloc(output_len);
+
+  // NOTE(ww): Very similar to LZFSE decoding above; the main difference is that
+  // our decoder state is a stack object instead.
+  lzvn_decoder_state state;
+  do {
+    memset(&state, 0x00, sizeof(lzvn_decoder_state));
+    state.src = input_buf;
+    state.src_end = input_buf + input_len;
+    state.dst = output_buf;
+    state.dst_begin = output_buf;
+    state.dst_end = output_buf + output_len;
+
+    lzvn_decode(&state);
+
+    // NOTE(ww): Unlike `lzfse_decode`, `lzvn_decode` doesn't provide a status
+    // API. We need to check various decoder states to determine our next step.
+    // Below is mostly ripped from the internals of `lzfse_decode`, case
+    // `LZFSE_COMPRESSEDLZVN_BLOCK_MAGIC`.
+    size_t src_used = state.src - input_buf;
+    size_t dst_used = state.dst - output_buf;
+
+    // Sanity check: we shouldn't have overrun either buffer.
+    if (src_used > input_len || dst_used > output_len) {
+      rb_raise(cDecodeError, "decode failed: internal buffer mismatch");
+    }
+
+    // If we're in a valid state and we've consumed the entire input, we're
+    // done. Observe that we can't check the validity of dst_used here, since a
+    // raw LZVN stream doesn't include its raw output size.
+    if (src_used == input_len && state.end_of_stream) {
+      break;
+    }
+
+    // If we're in an invalid state, die.
+    if (src_used == input_len || state.end_of_stream) {
+      rb_raise(cDecodeError, "internal error while decoding (lzvn, %zu, %zu)", src_used, dst_used);
+    }
+
+    // Otherwise, our output buffer was too small. Retry.
+    output_len *= 2;
+    output_buf = realloc(output_buf, output_len);
+  } while (true);
+
+  VALUE output_str = rb_str_new((char *)output_buf, state.dst - output_buf);
+  free(output_buf);
+
+  return output_str;
+}
+
+__attribute__((visibility("default"))) void Init_lzfse() {
+  mLZFSE = rb_define_module("LZFSE");
+  cEncodeError = rb_const_get(mLZFSE, rb_intern("EncodeError"));
+  cDecodeError = rb_const_get(mLZFSE, rb_intern("DecodeError"));
+
+  rb_define_singleton_method(mLZFSE, "lzfse_encode_intern", mLZFSE_lzfse_encode_intern, 1);
+  rb_define_singleton_method(mLZFSE, "lzfse_decode_intern", mLZFSE_lzfse_decode_intern, 1);
+  rb_define_singleton_method(mLZFSE, "lzvn_encode_intern", mLZFSE_lzvn_encode_intern, 1);
+  rb_define_singleton_method(mLZFSE, "lzvn_decode_intern", mLZFSE_lzvn_decode_intern, 1);
+}

data/ext/lzfse/ext.h

@@ -0,0 +1,14 @@
+#ifndef LZFSE_RB
+#define LZFSE_RB
+
+#include <ruby.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "lzfse.h"
+#include "lzfse_internal.h"
+#include "lzvn_decode_base.h"
+
+extern VALUE mLZFSE;
+
+#endif

data/ext/lzfse/extconf.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+
+append_cflags %w[-Os -Wno-unknown-pragmas -Wno-unused-variable -DNDEBUG -D_POSIX_C_SOURCE
+                 -std=c99 -fvisibility=hidden -g]
+
+create_makefile "lzfse"

data/ext/lzfse/lzfse.h

@@ -0,0 +1,136 @@
+/*
+Copyright (c) 2015-2016, Apple Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder(s) nor the names of any contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef LZFSE_H
+#define LZFSE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#  define __attribute__(X)
+#  pragma warning(disable : 4068)
+#endif
+
+#if defined(LZFSE_DLL)
+#  if defined(_WIN32) || defined(__CYGWIN__)
+#    if defined(LZFSE_DLL_EXPORTS)
+#      define LZFSE_API __declspec(dllexport)
+#    else
+#      define LZFSE_API __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#if !defined(LZFSE_API)
+#  if __GNUC__ >= 4
+#    define LZFSE_API __attribute__((visibility("default")))
+#  else
+#    define LZFSE_API
+#  endif
+#endif
+
+/*! @abstract Get the required scratch buffer size to compress using LZFSE.   */
+LZFSE_API size_t lzfse_encode_scratch_size();
+
+/*! @abstract Compress a buffer using LZFSE.
+ *
+ *  @param dst_buffer
+ *  Pointer to the first byte of the destination buffer.
+ *
+ *  @param dst_size
+ *  Size of the destination buffer in bytes.
+ *
+ *  @param src_buffer
+ *  Pointer to the first byte of the source buffer.
+ *
+ *  @param src_size
+ *  Size of the source buffer in bytes.
+ *
+ *  @param scratch_buffer
+ *  If non-NULL, a pointer to scratch space for the routine to use as workspace;
+ *  the routine may use up to lzfse_encode_scratch_size( ) bytes of workspace
+ *  during its operation, and will not perform any internal allocations. If
+ *  NULL, the routine may allocate its own memory to use during operation via
+ *  a single call to malloc( ), and will release it by calling free( ) prior
+ *  to returning. For most use, passing NULL is perfectly satisfactory, but if
+ *  you require strict control over allocation, you will want to pass an
+ *  explicit scratch buffer.
+ *
+ *  @return
+ *  The number of bytes written to the destination buffer if the input is
+ *  successfully compressed. If the input cannot be compressed to fit into
+ *  the provided buffer, or an error occurs, zero is returned, and the
+ *  contents of dst_buffer are unspecified.                                   */
+LZFSE_API size_t lzfse_encode_buffer(uint8_t *__restrict dst_buffer,
+                                     size_t dst_size,
+                                     const uint8_t *__restrict src_buffer,
+                                     size_t src_size,
+                                     void *__restrict scratch_buffer);
+
+/*! @abstract Get the required scratch buffer size to decompress using LZFSE. */
+LZFSE_API size_t lzfse_decode_scratch_size();
+
+/*! @abstract Decompress a buffer using LZFSE.
+ *
+ *  @param dst_buffer
+ *  Pointer to the first byte of the destination buffer.
+ *
+ *  @param dst_size
+ *  Size of the destination buffer in bytes.
+ *
+ *  @param src_buffer
+ *  Pointer to the first byte of the source buffer.
+ *
+ *  @param src_size
+ *  Size of the source buffer in bytes.
+ *
+ *  @param scratch_buffer
+ *  If non-NULL, a pointer to scratch space for the routine to use as workspace;
+ *  the routine may use up to lzfse_decode_scratch_size( ) bytes of workspace
+ *  during its operation, and will not perform any internal allocations. If
+ *  NULL, the routine may allocate its own memory to use during operation via
+ *  a single call to malloc( ), and will release it by calling free( ) prior
+ *  to returning. For most use, passing NULL is perfectly satisfactory, but if
+ *  you require strict control over allocation, you will want to pass an
+ *  explicit scratch buffer.
+ *
+ *  @return
+ *  The number of bytes written to the destination buffer if the input is
+ *  successfully decompressed. If there is not enough space in the destination
+ *  buffer to hold the entire expanded output, only the first dst_size bytes
+ *  will be written to the buffer and dst_size is returned. Note that this
+ *  behavior differs from that of lzfse_encode_buffer.                        */
+LZFSE_API size_t lzfse_decode_buffer(uint8_t *__restrict dst_buffer,
+                                     size_t dst_size,
+                                     const uint8_t *__restrict src_buffer,
+                                     size_t src_size,
+                                     void *__restrict scratch_buffer);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LZFSE_H */