hallon-openal 0.0.2

data/.gitignore

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

data/.rspec

@@ -0,0 +1,4 @@
+-fs
+--colour
+-Iext
+-Ilib

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# v0.0.2
+- Update dependency information; Hallon v0.12 or higher is required.
+
+# v0.0.1
+- Initial release.

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Kim Burgestrand
+
+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,17 @@
+# OpenAL audio drivers for [Hallon](http://rubygems.org/gems/hallon)
+
+This gem supplies Hallon with the ability to stream audio through your
+speakers using OpenAL.
+
+## Installation
+
+    gem install hallon-openal
+
+## Issues? Bugs? Feedback?
+
+I’d be happy to discuss any and all of these with you. Feel free to [create an issue](https://github.com/Burgestrand/hallon-openal/issues),
+[email me](http://github.com/Burgestrand) or [tweet me at @Burgestrand](http://twitter.com/Burgestrand).
+
+## License
+
+X11 license. See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+task :compile do
+  Dir.chdir('ext/hallon') do
+    sh 'ruby extconf.rb'
+    sh 'make'
+  end
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => [:compile, :spec]

data/ext/hallon/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+def error(message)
+  abort "[ERROR] #{message}"
+end
+
+$CFLAGS << ' -ggdb -O0 -Wextra'
+
+error 'Missing ruby header' unless have_header 'ruby.h'
+error 'Missing OpenAL/alc.h' unless have_header 'OpenAL/alc.h'
+error 'Missing OpenAL/al.h' unless have_header 'OpenAL/al.h'
+
+with_ldflags('-framework OpenAL') { RUBY_PLATFORM =~ /darwin/ }
+
+create_makefile('openal_ext')

data/ext/hallon/openal_ext.c

@@ -0,0 +1,377 @@
+#include <ruby.h>
+#include <OpenAL/alc.h>
+#include <OpenAL/al.h>
+#include <unistd.h>
+
+#if DEBUG_H
+#  define DEBUG printf
+#else
+#  define DEBUG(...) //
+#endif
+
+// How many audio buffers to keep
+#define NUM_BUFFERS 3
+
+// Globals
+ID oa_iv_playing;
+ID oa_iv_format;
+ID oa_id_call;
+ID oa_id_puts;
+VALUE oa_key_channels;
+VALUE oa_key_rate;
+VALUE oa_key_type;
+
+// struct information stored
+// with the OpenAL driver instance
+typedef struct
+{
+  ALCdevice  *device;
+  ALCcontext *context;
+  ALuint buffers[NUM_BUFFERS];
+  ALuint source;
+} oa_struct_t;
+
+// Utility
+
+#define SYM2STR(x) rb_id2name(SYM2ID((x)))
+#define STR2SYM(x) ID2SYM(rb_intern((x)))
+
+#define OA_CHECK_ERRORS(msg) do {                           \
+  ALenum _error;                                            \
+  if ((_error = alGetError()) != AL_NO_ERROR)               \
+  {                                                         \
+    rb_raise(rb_eRuntimeError, "OpenAL error: %u (%s)", _error, (msg)); \
+  }                                                         \
+} while(0)
+
+static inline oa_struct_t* oa_struct(VALUE self)
+{
+  oa_struct_t *data_ptr;
+  Data_Get_Struct(self, oa_struct_t, data_ptr);
+  return data_ptr;
+}
+
+static inline void oa_ensure_playing(VALUE self)
+{
+  ALint state;
+  ALuint source = oa_struct(self)->source;
+  VALUE playing = rb_ivar_get(self, oa_iv_playing);
+
+  alGetSourcei(source, AL_SOURCE_STATE, &state);
+  OA_CHECK_ERRORS("AL_SOURCE_STATE");
+
+  if (RTEST(playing) && state != AL_PLAYING)
+  {
+    alSourcePlay(source);
+    OA_CHECK_ERRORS("alSourcePlay (forced continue)");
+  }
+}
+
+static inline void oa_puts(const char *message)
+{
+  VALUE rbmessage = rb_str_new2(message);
+  rb_funcall(rb_cObject, oa_id_puts, 1, rbmessage);
+}
+
+static VALUE oa_format_get(VALUE self);
+
+static inline int _oa_format_channels(VALUE self)
+{
+  VALUE channels = rb_hash_aref(oa_format_get(self), oa_key_channels);
+  return FIX2INT(channels);
+}
+
+static inline int _oa_format_rate(VALUE self)
+{
+  VALUE rate = rb_hash_aref(oa_format_get(self), oa_key_rate);
+  return FIX2LONG(rate);
+}
+
+static inline VALUE _oa_format_type(VALUE self)
+{
+  VALUE size = rb_hash_aref(oa_format_get(self), oa_key_type);
+  return size;
+}
+
+// implementation
+
+static void oa_free(oa_struct_t *data_ptr)
+{
+  int i;
+
+  // exit early if we have no data_ptr at all
+  if ( ! data_ptr) return;
+
+  // deleting a source stops it from playing and
+  // then destroys it
+  if (data_ptr->source)
+    alDeleteSources(1, &data_ptr->source);
+
+  // now that the source is gone, we can safely delete buffers
+  if (data_ptr->buffers[0])
+    alDeleteBuffers(NUM_BUFFERS, data_ptr->buffers);
+
+  // docs tell us to do this to make sure
+  // our source is not the current one
+  alcMakeContextCurrent(NULL);
+
+  if (data_ptr->context)
+    alcDestroyContext(data_ptr->context);
+
+  if (data_ptr->device)
+    alcCloseDevice(data_ptr->device);
+
+  xfree(data_ptr);
+}
+
+static VALUE oa_allocate(VALUE klass)
+{
+  oa_struct_t *data_ptr;
+  return Data_Make_Struct(klass, oa_struct_t, NULL, oa_free, data_ptr);
+}
+
+static VALUE oa_initialize(VALUE self)
+{
+  oa_struct_t *data_ptr;
+  ALenum error = AL_NO_ERROR;
+
+  // initialize openal
+  Data_Get_Struct(self, oa_struct_t, data_ptr);
+
+  data_ptr->device = alcOpenDevice(NULL);
+  if ( ! data_ptr->device)
+  {
+    rb_raise(rb_eRuntimeError, "failed to open device");
+  }
+
+  data_ptr->context = alcCreateContext(data_ptr->device, NULL);
+  if ( ! data_ptr->context)
+  {
+    rb_raise(rb_eRuntimeError, "failed to create context");
+  }
+
+  // reset error state
+  alGetError();
+
+  alcMakeContextCurrent(data_ptr->context);
+  OA_CHECK_ERRORS("context current");
+
+  // Set some defualt properties
+  alListenerf(AL_GAIN, 1.0f);
+	alDistanceModel(AL_NONE);
+  OA_CHECK_ERRORS("listener/distance");
+
+  // generate some buffers
+	alGenBuffers((ALsizei)NUM_BUFFERS, data_ptr->buffers);
+  OA_CHECK_ERRORS("generate buffers");
+
+  // generate our source
+	alGenSources(1, &data_ptr->source);
+  OA_CHECK_ERRORS("gen sources");
+}
+
+static VALUE oa_play(VALUE self)
+{
+  rb_ivar_set(self, oa_iv_playing, Qtrue);
+  alSourcePlay(oa_struct(self)->source);
+  return self;
+}
+
+static VALUE oa_stop(VALUE self)
+{
+  ALuint source = oa_struct(self)->source;
+  rb_ivar_set(self, oa_iv_playing, Qfalse);
+
+  // remove all buffers from the source
+  alSourcei(source, AL_BUFFER, 0);
+  OA_CHECK_ERRORS("remove buffers!");
+
+  // and stop the source
+  alSourceStop(source);
+  OA_CHECK_ERRORS("stop!");
+
+  return self;
+}
+
+static VALUE oa_pause(VALUE self)
+{
+  rb_ivar_set(self, oa_iv_playing, Qfalse);
+  alSourcePause(oa_struct(self)->source);
+  OA_CHECK_ERRORS("pause!");
+  return self;
+}
+
+static VALUE oa_drops(VALUE self)
+{
+  return INT2NUM(0);
+}
+
+static ALuint find_empty_buffer(VALUE self)
+{
+  ALuint empty_buffer;
+
+  oa_struct_t *data_ptr = oa_struct(self);
+  ALuint source   = data_ptr->source;
+  ALuint *buffers = data_ptr->buffers;
+
+  ALint num_queued = 0;
+  alGetSourcei(source, AL_BUFFERS_QUEUED, &num_queued);
+  OA_CHECK_ERRORS("AL_BUFFERS_QUEUED");
+
+  if (num_queued < NUM_BUFFERS)
+  {
+    empty_buffer = buffers[num_queued];
+  }
+  else
+  {
+    int processed;
+    struct timeval poll_time;
+    poll_time.tv_sec  = 0;
+    poll_time.tv_usec = 100;	/* 0.000100 sec */
+
+    for (processed = 0; processed == 0; rb_thread_wait_for(poll_time))
+    {
+      alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
+      OA_CHECK_ERRORS("AL_BUFFERS_PROCESSED");
+    }
+
+    alSourceUnqueueBuffers(source, 1, &empty_buffer);
+    OA_CHECK_ERRORS("alSourceUnqueueBuffers");
+  }
+
+  return empty_buffer;
+}
+
+static VALUE oa_format_get(VALUE self)
+{
+  return rb_ivar_get(self, oa_iv_format);
+}
+
+static VALUE oa_format_set(VALUE self, VALUE format)
+{
+  rb_ivar_set(self, oa_iv_format, format);
+  return format;
+}
+
+static VALUE oa_stream(VALUE self)
+{
+  VALUE int16ne = STR2SYM("int16");
+  ALuint source = oa_struct(self)->source;
+  signed short *sample_ary = NULL;
+
+  for (;;)
+  {
+    // make sure we have no preattached buffers
+    alSourcei(source, AL_BUFFER, 0);
+    OA_CHECK_ERRORS("detach all buffers from the source");
+
+    // make sure we’re not playing audio
+    alSourceStop(source);
+    OA_CHECK_ERRORS("reset driver");
+
+    // read the format (it never changes in the inner loop)
+    int f_channels = _oa_format_channels(self);
+    int f_rate     = _oa_format_rate(self);
+    VALUE f_type   = _oa_format_type(self);
+    size_t f_size  = 0;
+
+    DEBUG("%d channels %d rate", f_channels, f_rate);
+
+    // each time we buffer down there, it’ll be for about .5s of audio each time
+    int sample_ary_frames = f_rate / 2;
+    int sample_ary_length = sample_ary_frames * f_channels; // integer division
+    xfree(sample_ary); // ruby handles NULL pointer too
+
+    if (rb_eql(f_type, int16ne))
+    {
+      sample_ary = ALLOCA_N(short, sample_ary_length);
+      f_size     = sizeof(short);
+    }
+    else
+    {
+      printf("Hallon::OpenAL#stream -> cannot handle format size %s!", SYM2STR(f_type));
+      rb_notimplement();
+    }
+
+    for (;;)
+    {
+      // pull some audio out of hallon
+      VALUE frames = rb_yield(INT2FIX(sample_ary_frames));
+
+      // if we received nil, it means format changed; the new
+      // format is already in @format, so we reinitialize!
+      if ( ! RTEST(frames))
+      {
+        break;
+      }
+
+      ALuint buffer = find_empty_buffer(self);
+      OA_CHECK_ERRORS("find_empty_buffer");
+
+      // convert the frames from ruby to C
+      int num_current_samples = ((int) RARRAY_LEN(frames)) * f_channels;
+
+      VALUE frame, sample;
+      int i, rb_i, rb_j;
+      for (i = 0; i < num_current_samples; ++i)
+      {
+        rb_i = i / f_channels; // integer division
+        rb_j = i % f_channels;
+
+        frame  = RARRAY_PTR(frames)[rb_i];
+        sample = RARRAY_PTR(frame)[rb_j];
+
+        long value = FIX2LONG(sample);
+
+        sample_ary[i] = (short) value;
+      }
+
+      DEBUG("%d +%d\n", buffer, num_current_samples);
+
+      // pucker up all the params
+      ALenum type  = f_channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
+      ALsizei size = f_size * num_current_samples;
+      ALsizei freq = f_rate;
+
+      // queue the data!
+      alBufferData(buffer, type, sample_ary, size, freq);
+      OA_CHECK_ERRORS("buffer data");
+
+      alSourceQueueBuffers(source, 1, &buffer);
+      OA_CHECK_ERRORS("queue a buffer");
+
+      // OpenAL transitions to :stopped state if we cannot
+      // keep buffers properly feeded — but we want it to
+      // play as soon as it can if we’re playing, so fix it
+      oa_ensure_playing(self);
+    }
+  }
+
+  return Qtrue;
+}
+
+void Init_openal_ext(void)
+{
+  VALUE mHallon = rb_const_get(rb_cObject, rb_intern("Hallon"));
+  VALUE cOpenAL = rb_define_class_under(mHallon, "OpenAL", rb_cObject);
+
+  oa_iv_playing = rb_intern("@playing");
+  oa_id_call    = rb_intern("call");
+  oa_id_puts    = rb_intern("puts");
+  oa_iv_format  = rb_intern("format");
+  oa_key_channels = STR2SYM("channels");
+  oa_key_rate     = STR2SYM("rate");
+  oa_key_type     = STR2SYM("type");
+
+  rb_define_alloc_func(cOpenAL, oa_allocate);
+
+  rb_define_method(cOpenAL, "initialize", oa_initialize, 0);
+  rb_define_method(cOpenAL, "play", oa_play, 0);
+  rb_define_method(cOpenAL, "stop", oa_stop, 0);
+  rb_define_method(cOpenAL, "pause", oa_pause, 0);
+  rb_define_method(cOpenAL, "stream", oa_stream, 0);
+  rb_define_method(cOpenAL, "format=", oa_format_set, 1);
+  rb_define_method(cOpenAL, "format", oa_format_get, 0);
+
+  rb_define_method(cOpenAL, "drops", oa_drops, 0);
+}

data/hallon-openal.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/hallon/openal/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "hallon-openal"
+
+  gem.authors       = ["Kim Burgestrand"]
+  gem.email         = ["kim@burgestrand.se"]
+  gem.summary       = %q{OpenAL audio drivers for Hallon: http://rubygems.org/gems/hallon}
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib", "ext"]
+  gem.extensions    = ["ext/hallon/extconf.rb"]
+  gem.version       = Hallon::OpenAL::VERSION
+
+  gem.add_dependency 'hallon', '~> 0.13'
+  gem.add_development_dependency 'rspec', '~> 2.7'
+end

data/lib/hallon-openal.rb

@@ -0,0 +1 @@
+require 'hallon/openal'

data/lib/hallon/openal.rb

@@ -0,0 +1,3 @@
+require 'hallon'
+require 'hallon/openal/version'
+require 'hallon/openal_ext'

data/lib/hallon/openal/version.rb

@@ -0,0 +1,5 @@
+module Hallon
+  class OpenAL
+    VERSION = '0.0.2'
+  end
+end

data/spec/hallon_openal_spec.rb

@@ -0,0 +1,48 @@
+require 'bundler/setup'
+require 'hallon/openal'
+
+describe Hallon::OpenAL do
+  let(:klass)  { described_class }
+  let(:format) { Hash.new }
+  subject { klass.new(format) }
+
+  describe "#initialize" do
+    it "should raise an error if not given a format" do
+      expect { klass.new {} }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#start" do
+    it "should not raise an error" do
+      expect { subject.start }.to_not raise_error
+    end
+  end
+
+  describe "#stop" do
+    it "should not raise an error" do
+      expect { subject.stop }.to_not raise_error
+    end
+  end
+
+  describe "#pause" do
+    it "should not raise an error" do
+      expect { subject.pause }.to_not raise_error
+    end
+  end
+
+  describe "#drops" do
+    it "should always return zero" do
+      subject.drops.should be_zero
+    end
+  end
+
+  describe "#format" do
+    it "should be settable and gettable" do
+      format = { channels: 1, rate: 44100 }
+
+      subject.format.should == {}
+      subject.format = format
+      subject.format.should eq format
+    end
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: hallon-openal
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Kim Burgestrand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hallon
+  requirement: &70281050669480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70281050669480
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70281050668320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: *70281050668320
+description: 
+email:
+- kim@burgestrand.se
+executables: []
+extensions:
+- ext/hallon/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/hallon/extconf.rb
+- ext/hallon/openal_ext.c
+- hallon-openal.gemspec
+- lib/hallon-openal.rb
+- lib/hallon/openal.rb
+- lib/hallon/openal/version.rb
+- spec/hallon_openal_spec.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: ! 'OpenAL audio drivers for Hallon: http://rubygems.org/gems/hallon'
+test_files:
+- spec/hallon_openal_spec.rb
+has_rdoc: