ascii85_native 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29b779e3fe160aeafcecd06d79f661f9a4b0a992dd053af39515eacfa7e2f367
+  data.tar.gz: bbc6085d316adaea46f93095dbf738aea1441fb682c32736152c0674c33f7df2
+SHA512:
+  metadata.gz: 0a4267955d024d17a5a540961e583bb498c4c70eddc9073d680925e3a8b9c10aeaed73a9ea07dbef6455c6dec62d308c61e465739312e67c5ff575f75de3bc4e
+  data.tar.gz: af7a04720ee115222ad4897af241ee305486bc2494aa9925acdddaefcb10aa8c5be8bcc723e92818237c04385207137a678cef777a8362dd8b7b9dff8db9c359

data/ext/ascii85_native/ascii85_native.c

@@ -0,0 +1,103 @@
+// a85.cpp
+//
+// Ascii85 C++ implementation pulled from https://github.com/larskholte/a85
+// Original C++ Code License: Copy and use as you please. No attribution necessary.
+//
+// Adapted to C language
+
+#include "ascii85_native.h"
+
+int size_for_a85(int binlen, bool append_null) {
+    return (binlen * 5 + 3) / 4 + !!append_null;
+}
+
+void to_a85(const u8* data, int binlen, char* text, bool append_null) {
+    // Go to end of data and text buffers
+    data += binlen;
+    text += size_for_a85(binlen,append_null);
+    // Append null if requested
+    if (append_null) {
+        *(--text) = 0;
+    }
+    // If number of bytes is not divisible by 4, act as if null bytes were added to end of buffer
+    int rem = binlen & 3;
+    if (rem) {
+        u32 val = 0;
+        for (int i = 4 - rem; i < 4; i++) {
+            val |= *(--data) << (8 * i);
+        }
+        int i;
+        for (i = 0; i < 4 - rem; i++) {
+            val /= 85;
+        }
+        for (; i <= 4; i++) {
+            *(--text) = val % 85 + 33;
+            val /= 85;
+        }
+        binlen &= ~3;
+    }
+    while (binlen) {
+        // Process chunks of 4 bytes as 32-bit values
+        u32 val = *(--data);
+        val |= *(--data) << 8;
+        val |= *(--data) << 16;
+        val |= *(--data) << 24;
+        // Convert to base 85
+        *(--text) = val % 85 + 33;
+        val /= 85;
+        *(--text) = val % 85 + 33;
+        val /= 85;
+        *(--text) = val % 85 + 33;
+        val /= 85;
+        *(--text) = val % 85 + 33;
+        val /= 85;
+        *(--text) = val % 85 + 33;
+        binlen -= 4;
+    }
+}
+
+int size_for_bin(int textlen) {
+    return (textlen * 4) / 5;
+}
+
+void from_a85(const char* text, int textlen, u8* data) {
+    while (textlen) {
+
+        while (*text == 0 || (*text >= 10 && *text <= 13)) { text++; textlen--; }
+
+        if (textlen < 5) {
+            // Determine represented value in base 85
+            u32 val = 0;
+            int factor = 52200625; // 85^4
+            int i;
+            for (i = 0; i < textlen; i++) {
+                val += (*(text++) - 33) * factor;
+                factor /= 85;
+            }
+            for (; i < 5; i++) {
+                val += 'u' * factor;
+                factor /= 85;
+            }
+            int shift = 24;
+            for (i = 0; i < textlen - 1; i++) {
+                *(data++) = val >> shift;
+                shift -= 8;
+            }
+            break;
+        }
+
+        // Determine represented value in base 85
+        u32 val = (*(text++) - 33) * 52200625; // 85^4
+        val += (*(text++) - 33) * 614125; // 85^3
+        val += (*(text++) - 33) * 7225; // 85^2
+        val += (*(text++) - 33) * 85; // 85^1
+        val += (*(text++) - 33); // 85^0
+
+        // Write out in big-endian order
+        *(data++) = val >> 24;
+        *(data++) = val >> 16;
+        *(data++) = val >> 8;
+        *(data++) = val;
+        textlen -= 5;
+    }
+}

data/ext/ascii85_native/ascii85_native.h

@@ -0,0 +1,27 @@
+// a85.h
+//
+// Ascii85 C++ implementation pulled from https://github.com/larskholte/a85
+// Original C++ Code License: Copy and use as you please. No attribution necessary.
+//
+// Adapted to C language
+
+#include <stdint.h>
+
+typedef _Bool bool;
+typedef uint8_t u8;
+typedef uint32_t u32;
+
+// Returns size of buffer required for to_a85 function.
+int size_for_a85(int binlen, bool append_null);
+
+// Translates the given binary data of the given size to Ascii85.
+// Can translate in-place.
+// Optionally appends a null character.
+void to_a85(const u8* data, int binlen, char* text, bool append_null);
+
+// Returns the size of buffer required for from_a85 function.
+int size_for_bin(int textlen);
+
+// Translates the given Ascii85 text to binary data.
+// Can translate in-place.
+void from_a85(const char* text, int textlen, u8* data);

data/ext/ascii85_native/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile "ascii85_native"

data/lib/ascii85_native.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Ascii85Native
+  extend FFI::Library
+
+  ffi_lib File.join(File.dirname(__FILE__), 'ascii85_native.so')
+
+  #void to_a85(const u8* data, int binlen, char* text, bool append_null);
+  attach_function :to_a85, [:buffer_in, :int, :buffer_out, :bool], :void
+
+  #int size_for_a85(int binlen, bool append_null);
+  attach_function :size_for_a85, [:int, :bool], :int
+
+  #void from_a85(const char* text, int textlen, u8* data);
+  attach_function :from_a85, [:buffer_in, :int, :buffer_out], :void
+
+  #int size_for_bin(int textlen)
+  attach_function :size_for_bin, [:int], :int
+
+
+  def self.encode(input, include_delimiter=false)
+    if input.nil?
+      return '<~~>' if include_delimiter
+      return ''
+    end
+
+    if input.class == String
+      input_data = []
+      input.each_byte { |byte| input_data << byte }
+    else
+      input_data = input
+    end
+
+    FFI::MemoryPointer.new(:uint8, input_data.size) do |in_uint8|
+      in_uint8.write_array_of_type(FFI::TYPE_UINT8, :put_uint8, input_data)
+      out_size = self.size_for_a85(input_data.size, true)
+
+      FFI::MemoryPointer.new(:uint8, out_size) do |output|
+        self.to_a85(in_uint8, input_data.size, output, true)
+        if include_delimiter
+          return '<~' + (output.read_string() || '') + '~>'
+        else
+          return output.read_string()
+        end
+      end
+    end
+  end
+
+
+  def self.decode(input)
+    return "" if input.nil?
+
+    if input[0] == '<' && input[1] == '~' && input[-2] == '~' && input[-1] == '>'
+      input = input[2..-3]
+    end
+
+    FFI::MemoryPointer.new(:char, input.size) do |in_char|
+      in_char.write_string(input)
+      out_size = self.size_for_bin(input.size)
+
+      FFI::MemoryPointer.new(:uint8, out_size) do |output|
+        self.from_a85(in_char, input.size, output)
+        return output.read_string()
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: ascii85_native
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jason Crossfield
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+description: A faster implementation of the Ascii85 Encode & Decode methods using
+  native C extensions to do the heavy lifting.
+email: jason.crossfield@gmail.com
+executables: []
+extensions:
+- ext/ascii85_native/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/ascii85_native/ascii85_native.c
+- ext/ascii85_native/ascii85_native.h
+- ext/ascii85_native/extconf.rb
+- lib/ascii85_native.rb
+homepage: https://github.com/AnomalousBit/ascii85_native
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- ext/ascii85_native
+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: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Ascii85 Encoder / Decoder with Native C Extensions
+test_files: []