hornetseye-alsa 0.1.0

data/README.md

@@ -0,0 +1,4 @@
+hornetseye-alsa
+======
+This Ruby extension provides an interface for playing audio data using ALSA.
+

data/Rakefile

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+require 'date'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/loaders/makefile'
+require 'rbconfig'
+
+PKG_NAME = 'hornetseye-alsa'
+PKG_VERSION = '0.1.0'
+CXX = ENV[ 'CXX' ] || 'g++'
+STRIP = ENV[ 'STRIP' ] || 'strip'
+RB_FILES = FileList[ 'lib/**/*.rb' ]
+CC_FILES = FileList[ 'ext/*.cc' ]
+HH_FILES = FileList[ 'ext/*.hh' ] + FileList[ 'ext/*.tcc' ]
+TC_FILES = FileList[ 'test/tc_*.rb' ]
+TS_FILES = FileList[ 'test/ts_*.rb' ]
+SO_FILE = "ext/#{PKG_NAME.tr '\-', '_'}.so"
+PKG_FILES = [ 'Rakefile', 'README.md', 'COPYING', '.document' ] +
+            RB_FILES + CC_FILES + HH_FILES + TS_FILES + TC_FILES
+BIN_FILES = [ 'README.md', 'COPYING', '.document', SO_FILE ] +
+            RB_FILES + TS_FILES + TC_FILES
+SUMMARY = %q{Play audio data using libalsa}
+DESCRIPTION = %q{This Ruby extension provides an interface for playing audio data using ALSA.}
+AUTHOR = %q{Jan Wedekind}
+EMAIL = %q{jan@wedesoft.de}
+HOMEPAGE = %q{http://wedesoft.github.com/hornetseye-alsa/}
+
+OBJ = CC_FILES.ext 'o'
+$CXXFLAGS = ENV[ 'CXXFLAGS' ] || ''
+$CXXFLAGS = "#{$CXXFLAGS} -fPIC -DNDEBUG"
+if RbConfig::CONFIG[ 'rubyhdrdir' ]
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{RbConfig::CONFIG[ 'rubyhdrdir' ]} " +
+             "-I#{RbConfig::CONFIG[ 'rubyhdrdir' ]}/#{RbConfig::CONFIG[ 'arch' ]}"
+else
+  $CXXFLAGS += "#{$CXXFLAGS} -I#{RbConfig::CONFIG[ 'archdir' ]}"
+end
+$LIBRUBYARG = RbConfig::CONFIG[ 'LIBRUBYARG' ]
+$SITELIBDIR = RbConfig::CONFIG[ 'sitelibdir' ]
+$SITEARCHDIR = RbConfig::CONFIG[ 'sitearchdir' ]
+
+task :default => :all
+
+desc 'Compile Ruby extension (default)'
+task :all => [ SO_FILE ]
+
+file SO_FILE => OBJ do |t|
+   sh "#{CXX} -shared -o #{t.name} #{OBJ} -lasound #{$LIBRUBYARG}"
+   sh "#{STRIP} --strip-all #{t.name}"
+end
+
+task :test => [ SO_FILE ]
+
+desc 'Install Ruby extension'
+task :install => :all do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.mkdir_p "#{$SITELIBDIR}/#{File.dirname f.gsub( /^lib\//, '' )}"
+      FileUtils.cp_r f, "#{$SITELIBDIR}/#{f.gsub( /^lib\//, '' )}"
+    end
+    FileUtils.mkdir_p $SITEARCHDIR
+    FileUtils.cp SO_FILE, "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+desc 'Uninstall Ruby extension'
+task :uninstall do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.rm_f "#{$SITELIBDIR}/#{f.gsub /^lib\//, ''}"
+    end
+    FileUtils.rm_f "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'ext'
+  t.test_files = TC_FILES
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new :yard do |y|
+    y.options << '--no-private'
+    y.files << FileList[ 'lib/**/*.rb' ]
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'yard\' if you want to generate documentation'
+end
+
+Rake::PackageTask.new PKG_NAME, PKG_VERSION do |p|
+  p.need_tar = true
+  p.package_files = PKG_FILES
+end
+
+begin
+  require 'rubygems'
+  require 'rubygems/builder'
+  $SPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::RUBY
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = PKG_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.rubyforge_project = %q{hornetseye}
+    s.extensions = %w{Rakefile}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_dependency %<malloc>, [ '~> 1.2' ]
+    s.add_dependency %<multiarray>, [ '~> 0.11' ]
+    s.add_dependency %<hornetseye-frame>, [ '~> 0.7' ]
+    s.add_development_dependency %q{rake}
+  end
+  GEM_SOURCE = "#{PKG_NAME}-#{PKG_VERSION}.gem"
+  $BINSPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::CURRENT
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = BIN_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.rubyforge_project = %q{hornetseye}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_dependency %<malloc>, [ '~> 1.2' ]
+    s.add_dependency %<multiarray>, [ '~> 0.11' ]
+  end
+  GEM_BINARY = "#{PKG_NAME}-#{PKG_VERSION}-#{$BINSPEC.platform}.gem"
+  desc "Build the gem file #{GEM_SOURCE}"
+  task :gem => [ "pkg/#{GEM_SOURCE}" ]
+  file "pkg/#{GEM_SOURCE}" => [ 'pkg' ] + $SPEC.files do
+    when_writing 'Creating GEM' do
+      Gem::Builder.new( $SPEC ).build
+      verbose true do
+        FileUtils.mv GEM_SOURCE, "pkg/#{GEM_SOURCE}"
+      end
+    end
+  end
+  desc "Build the gem file #{GEM_BINARY}"
+  task :gem_binary => [ "pkg/#{GEM_BINARY}" ]
+  file "pkg/#{GEM_BINARY}" => [ 'pkg' ] + $BINSPEC.files do
+    when_writing 'Creating binary GEM' do
+      Gem::Builder.new( $BINSPEC ).build
+      verbose true do
+        FileUtils.mv GEM_BINARY, "pkg/#{GEM_BINARY}"
+      end
+    end
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'rubygems\' if you want to create Gem packages'
+end
+
+rule '.o' => '.cc' do |t|
+   sh "#{CXX} #{$CXXFLAGS} -c -o #{t.name} #{t.source}"
+end
+
+file ".depends.mf" do |t|
+  sh "g++ -MM #{$CXXFLAGS} #{CC_FILES.join ' '} | " +
+    "sed -e :a -e N -e 's/\\n/\\$/g' -e ta | " +
+    "sed -e 's/ *\\\\\\$ */ /g' -e 's/\\$/\\n/g' | sed -e 's/^/ext\\//' > #{t.name}"
+end
+CC_FILES.each do |t|
+  file t.ext(".o") => t
+end
+import ".depends.mf"
+
+CLEAN.include 'ext/*.o'
+CLOBBER.include SO_FILE, 'doc', '.yardoc', '.depends.mf'
+

data/ext/alsaoutput.cc

@@ -0,0 +1,285 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009, 2010   Jan Wedekind
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+#include "alsaoutput.hh"
+
+using namespace std;
+
+VALUE AlsaOutput::cRubyClass = Qnil;
+
+AlsaOutput::AlsaOutput( const string &pcmName, unsigned int rate,
+                        unsigned int channels, int periods,
+                        int frames ) throw (Error):
+  m_pcmHandle(NULL), m_pcmName( pcmName ), m_rate( rate ), m_channels( channels ),
+  m_frames( frames )
+{
+  try {
+    snd_pcm_hw_params_t *hwParams;
+    snd_pcm_hw_params_alloca( &hwParams );
+    int err = snd_pcm_open( &m_pcmHandle, m_pcmName.c_str(), SND_PCM_STREAM_PLAYBACK,
+                            SND_PCM_NONBLOCK );
+    ERRORMACRO( err >= 0, Error, , "Error opening PCM device \"" << m_pcmName
+                << "\": " << snd_strerror( err ) );
+    err = snd_pcm_hw_params_any( m_pcmHandle, hwParams );
+    ERRORMACRO( err >= 0, Error, , "Unable to configure the PCM device \""
+                << m_pcmName << "\": " << snd_strerror( err ) );
+    err = snd_pcm_hw_params_set_access( m_pcmHandle, hwParams,
+                                        SND_PCM_ACCESS_RW_INTERLEAVED );
+    ERRORMACRO( err >= 0, Error, , "Error setting PCM device \""
+                << m_pcmName << "\" to interlaced access: " << snd_strerror( err ) );
+    err = snd_pcm_hw_params_set_format( m_pcmHandle, hwParams,
+                                        SND_PCM_FORMAT_S16_LE );
+    ERRORMACRO( err >= 0, Error, , "Error setting PCM device \"" << m_pcmName
+                << "\" to 16-bit signed integer format: " << snd_strerror( err ) );
+    err = snd_pcm_hw_params_set_rate_near( m_pcmHandle, hwParams, &m_rate, 0 );
+    ERRORMACRO( err >= 0, Error, , "Error setting sampling rate of PCM device \""
+                << m_pcmName << "\" to " << rate << " Hz: " << snd_strerror( err ) );
+    err = snd_pcm_hw_params_set_channels( m_pcmHandle, hwParams, channels );
+    ERRORMACRO( err >= 0, Error, , "Error setting number of channels of PCM device \""
+                << m_pcmName << "\" to " << channels << ": " << snd_strerror( err ) );
+    err = snd_pcm_hw_params_set_periods( m_pcmHandle, hwParams, periods, 0 );
+    ERRORMACRO( err >= 0, Error, , "Error setting number of periods of PCM device \""
+                << m_pcmName << "\" to " << periods << ": " << snd_strerror( err ) );
+    err = snd_pcm_hw_params_set_buffer_size_near( m_pcmHandle, hwParams, &m_frames );
+    ERRORMACRO( err >= 0, Error, , "Error setting buffer size of PCM device \""
+                << m_pcmName << "\" to " << m_frames << " frames: "
+                << snd_strerror( err ) );
+    err = snd_pcm_hw_params( m_pcmHandle, hwParams );
+    ERRORMACRO( err >= 0, Error, , "Error setting parameters of PCM device \""
+                << m_pcmName << "\": " << snd_strerror( err ) );
+  } catch ( Error &e ) {
+    close();
+    throw e;
+  };
+}
+
+AlsaOutput::~AlsaOutput(void)
+{
+  close();
+}
+
+void AlsaOutput::close(void)
+{
+  if ( m_pcmHandle != NULL ) {
+    drop();
+    snd_pcm_close( m_pcmHandle );
+    m_pcmHandle = NULL;
+  };
+}
+
+void AlsaOutput::write( SequencePtr frame ) throw (Error)
+{
+  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+              << "\" is not open. Did you call \"close\" before?" );
+  int err = snd_pcm_writei( m_pcmHandle, (short int *)frame->data(),
+                            frame->size() / ( 2 * m_channels ) );
+  ERRORMACRO( err >= 0, Error, , "Error writing audio frames to PCM device \""
+              << m_pcmName << "\": " << snd_strerror( err ) );
+}
+
+void AlsaOutput::drop(void) throw (Error)
+{
+  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+              << "\" is not open. Did you call \"close\" before?" );
+  snd_pcm_drop( m_pcmHandle );
+}
+
+void AlsaOutput::drain(void) throw (Error)
+{
+  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+              << "\" is not open. Did you call \"close\" before?" );
+  snd_pcm_drain( m_pcmHandle );
+}
+
+unsigned int AlsaOutput::rate(void)
+{
+  return m_rate;
+}
+
+unsigned int AlsaOutput::channels(void)
+{
+  return m_channels;
+}
+
+unsigned int AlsaOutput::frames(void)
+{
+  return m_frames;
+}
+
+int AlsaOutput::avail(void) throw (Error)
+{
+  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+              << "\" is not open. Did you call \"close\" before?" );
+  snd_pcm_sframes_t frames = snd_pcm_avail( m_pcmHandle );
+  ERRORMACRO( frames >= 0, Error, , "Error querying number of available frames for "
+              "update of PCM device \"" << m_pcmName << "\": "
+              << snd_strerror( frames ) );
+  return frames;
+}
+
+int AlsaOutput::delay(void) throw (Error)
+{
+  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+              << "\" is not open. Did you call \"close\" before?" );
+  snd_pcm_sframes_t frames;
+  int err = snd_pcm_delay( m_pcmHandle, &frames );
+  ERRORMACRO( err >= 0, Error, , "Error querying number of available frames for "
+              "update of PCM device \"" << m_pcmName << "\": "
+              << snd_strerror( err ) );
+  return frames;
+}
+
+void AlsaOutput::prepare(void) throw (Error)
+{
+  ERRORMACRO( m_pcmHandle != NULL, Error, , "PCM device \"" << m_pcmName
+              << "\" is not open. Did you call \"close\" before?" );
+  int err = snd_pcm_prepare( m_pcmHandle );
+  ERRORMACRO( err >= 0, Error, , "Error preparing PCM device \"" << m_pcmName
+              << "\": " << snd_strerror( err ) );
+}
+
+VALUE AlsaOutput::registerRubyClass( VALUE rbModule )
+{
+  cRubyClass = rb_define_class_under( rbModule, "AlsaOutput", rb_cObject );
+  rb_define_singleton_method( cRubyClass, "new",
+                              RUBY_METHOD_FUNC( wrapNew ), 5 );
+  rb_define_method( cRubyClass, "close", RUBY_METHOD_FUNC( wrapClose ), 0 );
+  rb_define_method( cRubyClass, "write", RUBY_METHOD_FUNC( wrapWrite ), 1 );
+  rb_define_method( cRubyClass, "drop", RUBY_METHOD_FUNC( wrapDrop ), 0 );
+  rb_define_method( cRubyClass, "drain", RUBY_METHOD_FUNC( wrapDrain ), 0 );
+  rb_define_method( cRubyClass, "rate", RUBY_METHOD_FUNC( wrapRate ), 0 );
+  rb_define_method( cRubyClass, "channels", RUBY_METHOD_FUNC( wrapChannels ), 0 );
+  rb_define_method( cRubyClass, "frames", RUBY_METHOD_FUNC( wrapFrames ), 0 );
+  rb_define_method( cRubyClass, "avail", RUBY_METHOD_FUNC( wrapAvail ), 0 );
+  rb_define_method( cRubyClass, "delay", RUBY_METHOD_FUNC( wrapDelay ), 0 );
+  rb_define_method( cRubyClass, "prepare", RUBY_METHOD_FUNC( wrapPrepare ), 0 );
+}
+
+void AlsaOutput::deleteRubyObject( void *ptr )
+{
+  delete (AlsaOutputPtr *)ptr;
+}
+
+VALUE AlsaOutput::wrapNew( VALUE rbClass, VALUE rbPCMName, VALUE rbRate,
+                           VALUE rbChannels, VALUE rbPeriods, VALUE rbFrames )
+{
+  VALUE retVal = Qnil;
+  try {
+    rb_check_type( rbPCMName, T_STRING );
+    AlsaOutputPtr ptr( new AlsaOutput( StringValuePtr( rbPCMName ),
+                                       NUM2UINT( rbRate ), NUM2UINT( rbChannels ),
+                                       NUM2INT( rbPeriods ), NUM2INT( rbFrames ) ) );
+    retVal = Data_Wrap_Struct( rbClass, 0, deleteRubyObject,
+                               new AlsaOutputPtr( ptr ) );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AlsaOutput::wrapClose( VALUE rbSelf )
+{
+  AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+  (*self)->close();
+  return rbSelf;
+}
+
+VALUE AlsaOutput::wrapWrite( VALUE rbSelf, VALUE rbSequence )
+{
+  try {
+    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+    SequencePtr sequence( new Sequence( rbSequence ) );
+    (*self)->write( sequence );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbSequence;
+}
+
+VALUE AlsaOutput::wrapDrop( VALUE rbSelf )
+{
+  try {
+    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+    (*self)->drop();
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbSelf;
+}
+
+VALUE AlsaOutput::wrapDrain( VALUE rbSelf )
+{
+  try {
+    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+    (*self)->drain();
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbSelf;
+}
+
+VALUE AlsaOutput::wrapRate( VALUE rbSelf )
+{
+  AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+  return UINT2NUM( (*self)->rate() );
+}
+
+VALUE AlsaOutput::wrapChannels( VALUE rbSelf )
+{
+  AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+  return UINT2NUM( (*self)->channels() );
+}
+
+VALUE AlsaOutput::wrapFrames( VALUE rbSelf )
+{
+  AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+  return UINT2NUM( (*self)->frames() );
+}
+
+VALUE AlsaOutput::wrapAvail( VALUE rbSelf )
+{
+  VALUE rbRetVal = Qnil;
+  try {
+    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+    rbRetVal = INT2NUM( (*self)->avail() );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbRetVal;
+}
+
+VALUE AlsaOutput::wrapDelay( VALUE rbSelf )
+{
+  VALUE rbRetVal = Qnil;
+  try {
+    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+    rbRetVal = INT2NUM( (*self)->delay() );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbRetVal;
+}
+
+VALUE AlsaOutput::wrapPrepare( VALUE rbSelf )
+{
+  try {
+    AlsaOutputPtr *self; Data_Get_Struct( rbSelf, AlsaOutputPtr, self );
+    (*self)->prepare();
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbSelf;
+}
+