fast_osc 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 24934bf4851d8faf6a3f60a298f51519118c5865
+  data.tar.gz: 81d1d5472ae0928587879ffb2ecdee3d265b832f
+SHA512:
+  metadata.gz: 104becd81c316514e4171614079d7aee8ba4d33c5788cfd82558ac834374d127ae468dd64c188e89ce94416cdbb692d40d2de00b67b7987a24018284cec031de
+  data.tar.gz: 4eeef0b840558a8a51fcecea56776b734d3e79793421ab13bbce4f75074fe61affc7fe8adbd2b13da6a2b6066cda07b2f350e360402a8e80205077de8c66a110

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+lib/*.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fast_osc.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,48 @@
+# rtosc licence
+
+Copyright (c) 2012 Mark McCurry
+
+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 (including the next
+paragraph) 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.
+
+# fast_osc gem wrapper licence
+
+Copyright (c) 2016 Xavier Riley
+
+MIT License
+
+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,95 @@
+# FastOsc
+
+`WARNING - Work in progress. Probably not safe for production yet`
+
+A Ruby wrapper around [rtosc](https://github.com/fundamental/rtosc/) to encode and decode OSC messages.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fast_osc'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fast_osc
+
+This will only work on a mac at the moment as that's what the `librtosc.a` was compiled on.
+
+## Is it fast?
+
+Let's see...
+
+Key:
+
+* `fast_osc` - this gem
+* `osc` - [`osc-ruby`](https://github.com/aberant/osc-ruby)
+* `samsosc` - `OSC` classes from Sonic Pi (which are optimised pure Ruby based on `pack` and `unpack`)
+
+### Encoding Benchmark
+
+```
+["/feeooblah", ["beans", 1, 2.0]]
+Calculating -------------------------------------
+            fast_osc    54.101k i/100ms
+                 osc     7.688k i/100ms
+             samsosc    21.406k i/100ms
+-------------------------------------------------
+            fast_osc    909.680k (±21.4%) i/s -      4.328M
+                 osc     94.678k (±14.5%) i/s -    468.968k
+             samsosc    271.908k (±19.3%) i/s -      1.327M
+```
+
+## Decoding Bencmark
+
+```
+["/feeooblah", ["beans", 1, 2.0]]
+Calculating -------------------------------------
+            fast_osc    91.434k i/100ms
+             samsosc    22.095k i/100ms
+             oscruby     3.522k i/100ms
+-------------------------------------------------
+            fast_osc      2.635M (±22.2%) i/s -     12.435M
+             samsosc    264.614k (±16.1%) i/s -      1.304M
+             oscruby     36.362k (±16.3%) i/s -    179.622k
+```
+
+Benchmark adapted from https://github.com/samaaron/sonic-pi/blob/master/app/server/sonicpi/test/performance/test_osc_perf.rb
+
+I'll include a better test in the repo in time.
+
+## Usage
+
+```
+>> FastOsc.serialize("/foo", ["baz", 1, 2.0])
+=> "/foo\x00\x00\x00\x00,sif\x00\x00\x00\x00baz\x00\x00\x00\x00\x01@\x00\x00\x00"
+>> res = _
+>> FastOsc.deserialize(res)
+=> ["baz", 1, 2.0]
+```
+
+## Still todo
+
+* Implement more types
+* return address with `deserialize` (doh!)
+* add tests at the Ruby level (rtosc C code is already tested)
+* figure out build process
+
+## Development notes
+
+    bundle install
+    rake compile
+
+https://gist.github.com/xavriley/507eff0a75d4552fa56e
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/fast_osc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+require 'rake/extensiontask'
+spec = Gem::Specification.load('fast_osc.gemspec')
+Rake::ExtensionTask.new('fast_osc', spec)

data/ext/fast_osc/extconf.rb

@@ -0,0 +1,28 @@
+require 'mkmf'
+
+LIBDIR     = RbConfig::CONFIG['libdir']
+INCLUDEDIR = RbConfig::CONFIG['includedir']
+
+#HEADER_DIRS = ["/Users/xriley/Projects/rtosc/include/rtosc", INCLUDEDIR]
+HEADER_DIRS = [INCLUDEDIR]
+
+# # setup constant that is equal to that of the file path that holds that static libraries that will need to be compiled against
+# LIB_DIRS = [LIBDIR, File.expand_path(File.join(File.dirname(__FILE__), "lib"))]
+LIB_DIRS = [LIBDIR]
+
+# # array of all libraries that the C extension should be compiled against
+# libs = ['-lrtosc']
+
+extension_name = 'fast_osc'
+dir_config(extension_name, HEADER_DIRS, LIB_DIRS)
+
+# iterate though the libs array, and append them to the $LOCAL_LIBS array used for the makefile creation
+# libs.each do |lib|
+#   $LOCAL_LIBS << "#{lib} "
+# end
+
+$srcs = ["fast_osc_wrapper.c"]
+
+$CFLAGS << " -std=c99 -Wall -Wextra -Wno-unused-parameter"
+
+create_makefile(extension_name)

data/ext/fast_osc/fast_osc_wrapper.c

@@ -0,0 +1,155 @@
+#include <ruby.h>
+#include <rtosc.h>
+#include <rtosc.c>
+
+// Allocate VALUE variables to hold the modules we'll create. Ruby values
+// are all of type VALUE. Qnil is the C representation of Ruby's nil.
+VALUE FastOsc = Qnil;
+
+// Declare a couple of functions. The first is initialization code that runs
+// when this file is loaded, and the second is the actual business logic we're
+// implementing.
+void Init_fast_osc();
+VALUE method_fast_osc_deserialize(VALUE self, VALUE msg);
+VALUE method_fast_osc_serialize(VALUE self, VALUE address, VALUE args);
+
+// Initial setup function, takes no arguments and returns nothing. Some API
+// notes:
+//
+// * rb_define_module() creates and returns a top-level module by name
+//
+// * rb_define_module_under() takes a module and a name, and creates a new
+//   module within the given one
+//
+// * rb_define_singleton_method() take a module, the method name, a reference to
+//   a C function, and the method's arity, and exposes the C function as a
+//   single method on the given module
+//
+void Init_fast_osc() {
+  FastOsc = rb_define_module("FastOsc");
+  rb_define_singleton_method(FastOsc, "deserialize", method_fast_osc_deserialize, 1);
+  rb_define_singleton_method(FastOsc, "serialize", method_fast_osc_serialize, 2);
+}
+
+VALUE method_fast_osc_deserialize(VALUE self, VALUE msg) {
+  rtosc_arg_itr_t itr;
+  char* data = StringValuePtr(msg);
+  itr = rtosc_itr_begin(data);
+  VALUE output = rb_ary_new();
+
+  rtosc_arg_val_t next_val;
+
+  while(!rtosc_itr_end(itr)) {
+
+    next_val = rtosc_itr_next(&itr);
+
+    switch(next_val.type) {
+      case 'i' :
+        // INT2FIX() for integers within 31bits.
+        rb_ary_push(output, INT2FIX(next_val.val.i));
+        break;
+      case 'f' :
+        rb_ary_push(output, rb_float_new(next_val.val.f));
+        break;
+      case 's' :
+        rb_ary_push(output, rb_str_new2(next_val.val.s));
+        break;
+      case 'b' :
+        rb_ary_push(output, rb_str_new((const char*)next_val.val.b.data, next_val.val.b.len));
+        break;
+      case 'h' :
+        // INT2NUM() for arbitrary sized integers
+        rb_ary_push(output, INT2NUM(next_val.val.h));
+        break;
+      case 't' :
+        // OSC time tag
+        // not implemented
+        break;
+      case 'd' :
+        rb_ary_push(output, rb_float_new(next_val.val.d));
+        break;
+      case 'S' :
+        rb_ary_push(output, ID2SYM(rb_intern(next_val.val.s)));
+        break;
+      case 'c' :
+        rb_ary_push(output, rb_str_concat(rb_str_new2(""), INT2FIX(next_val.val.i)));
+        break;
+    }
+
+  }
+
+  return output;
+}
+
+int buffer_size_for_ruby_string(VALUE rstring) {
+  int str_bytesize = FIX2INT(LONG2FIX(RSTRING_LEN(rstring)));
+  return (int)((str_bytesize + sizeof(int) - 1) & ~(sizeof(int) - 1));
+}
+
+VALUE method_fast_osc_serialize(VALUE self, VALUE address, VALUE args) {
+  char* c_address = StringValueCStr(address);
+
+  int no_of_args = NUM2INT(LONG2NUM(RARRAY_LEN(args)));
+  int i;
+  int max_buffer_size = 0;
+  VALUE current_arg;
+
+  //output tags and args list
+  VALUE tagstring = rb_str_new2(""); //rtosc will handle comma
+  rtosc_arg_t output_args[no_of_args];
+
+  for(i = 0; i < no_of_args; i++) {
+    current_arg = rb_ary_entry(args, i);
+
+    switch(TYPE(current_arg)) {
+      case T_FIXNUM:
+        // max bytes for a single numeric representation
+        max_buffer_size += 8;
+
+        if(FIX2LONG(current_arg) < ~(1 << 31)) {
+          rb_str_concat(tagstring, rb_str_new2("i"));
+          output_args[i].i = FIX2INT(current_arg);
+        } else {
+          rb_str_concat(tagstring, rb_str_new2("h"));
+          output_args[i].h = FIX2LONG(current_arg);
+        }
+        break;
+      case T_FLOAT:
+        // now align to 4 byte boundary for sizing output buffer
+        max_buffer_size += 8;
+
+        rb_str_concat(tagstring, rb_str_new2("f"));
+        output_args[i].f = NUM2DBL(current_arg);
+        break;
+      case T_STRING:
+        // now align to 4 byte boundary for sizing output buffer
+        max_buffer_size += buffer_size_for_ruby_string(current_arg);
+
+        rb_str_concat(tagstring, rb_str_new2("s"));
+        output_args[i].s = StringValueCStr(current_arg);
+        break;
+    }
+  }
+
+  //add space for the address and tag strings to the buffer
+  max_buffer_size += buffer_size_for_ruby_string(address);
+  max_buffer_size += buffer_size_for_ruby_string(tagstring);
+
+  // Get next largest power of two for buffer
+  max_buffer_size--;
+  max_buffer_size |= max_buffer_size >> 1;
+  max_buffer_size |= max_buffer_size >> 2;
+  max_buffer_size |= max_buffer_size >> 4;
+  max_buffer_size |= max_buffer_size >> 8;
+  max_buffer_size |= max_buffer_size >> 16;
+  max_buffer_size++;
+
+  char buffer[max_buffer_size];
+
+
+  int len = rtosc_amessage(buffer, sizeof(buffer), c_address, StringValueCStr(tagstring), output_args);
+
+  VALUE output = rb_str_new(buffer, len);
+
+  return output;
+}