fmod-ruby 0.0.1 → 0.1.1

data/README.md

@@ -1,22 +1,9 @@
-<!-- Efficient, realtime audio for Ruby
-==================================
-
-Ruby is too slow to do realtime audio, but C is not. The best way to give Ruby robust audio capabilities is to use a native C/C++ library. The primary problem then is which library to choose and how to wire it into Ruby.
-
-So how do you choose an audio library? Aside from writing one from scratch, there are a number of widely used preexisting C/C++ audio libraries. At the lowest level, there are projects like PortAudio which handle direct interfacing with the hardware only, requiring a programmer to feed it a stream of numbers representing a waveform. At the highest level, projects like CLAM, CSL, FMOD and others provide a full framework complete with voice management, sound file playback, and even synthesis. In these frameworks, the low level number pushing is well abstracted, leaving the programmer with a coarse interface to predefined functionality.
-
-This Ruby library has chosen a high level framework as a basis for realtime audio. While it certainly is possible to get Ruby to push waveform representations to a low level API like PortAudio, doing so 44100 times a second is not playing to Ruby's strengths. By using a high level library, we trade flexible synthesis for a limited set of fast, efficient audio routines.
-
-To get Ruby to use external native libraries, there are a few ways to go about it. You can write a C external, use the DL library available in the Ruby standard distribution, or you can use FFI. Having tried all three methods of interfacing with C, FFI is a clear winner. It is efficient, predictable, effortlessly cross platform, and decently well documented.
-
-Ruby has been sorely lacking an audio framework, and an FMOD wrapper is a great place to start. This library is ultimately meant to be the basis of audio DSLs written in Ruby.  -->
-
 FMOD for Ruby
 -------------
 
 *ruby-fmod* wraps the excellent [FMOD](http://www.fmod.org) C/C++ libraries using the equally excellent [FFI](http://github.com/ffi/ffi).
 
-It is far from finished, but all the basic techniques for interfacing Ruby with the FMOD library are outlined. If you want to contribute to this project, please get in touch.
+It is far from complete, but all the basic techniques for interfacing Ruby with the FMOD library are outlined. The authors have (so far) fleshed out only the parts needed for their own projects.  Please do fork this project and contribute to it.
 
 FMOD?
 =====
@@ -28,7 +15,7 @@ FMOD is not free, nor is it open source, but it does have a very [liberal licens
 Installation
 ============
 
-To use this Ruby library, you must have the FMOD on you machine. [Go get it](http://www.fmod.org/index.php/download). At the moment, only Mac OS X is supported, but adding Linux or Windows is likely as easy as pointing to the library locations.
+To use this Ruby library, you must have the FMOD on you machine. [Go get it](http://www.fmod.org/index.php/download). 
 
 That being said:
 
@@ -38,7 +25,18 @@ or, in a Gemfile
 
   gem "fmod-ruby", :require => "fmod"
 
+Testing
+=======
+
+No formal test suite yet.  However, the +examples/+ directory includes several examples that should all work.
+
+History
+=======
 
+* release 0.1.1 - added Channel#set_volume, Sound#release
+* release 0.1.0 - added keyword options to System#initialize and whatnot to support offline wav creation (examples write.rb and contact.rb)
+
+* release 0.0.1 - initial gemification
   
 Usage
 =====
@@ -49,3 +47,5 @@ Usage
   sound = FMOD::Sound.new(file)
   sound.play
 
+See +examples/*+ for more examples
+

data/Rakefile

@@ -1,2 +1,12 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "array_floe #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/examples/concat.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler'
+Bundler.require
+require 'fmod'
+
+DIR = File.dirname(__FILE__)
+PROG = File.basename(__FILE__, '.*')
+
+
+infile1 = (ARGV.empty?) ? "#{DIR}/ComputerMagic.mp3" : ARGV.shift
+infile2 = (ARGV.empty?) ? "#{DIR}/Flute3.wav" : ARGV.shift
+outfile = "#{DIR}/output/#{PROG}.wav"
+puts "writing to #{outfile}"
+
+puts "calling FMOD.init"
+FMOD.init(:output_wav => outfile)
+
+sound1 = FMOD::Sound.new(infile1)
+puts "#{infile1} length=#{sound1.length}ms"
+sound2 = FMOD::Sound.new(infile2)
+puts "#{infile2} length=#{sound2.length}ms"
+
+puts "scheduleing play..."
+sound1.play
+sound2.play(:paused => true)
+sound2.channel.set_delay(FMOD::Convert.ms_to_samples(sound1.length), :delaytype => :FMOD_DELAYTYPE_DSPCLOCK_START)
+sound2.channel.set_paused(false)
+
+samples = FMOD::Convert.ms_to_samples(sound1.length + sound2.length)
+puts "updating to #{samples} samples"
+
+while (dsp_clock = FMOD.system.dsp_clock) < samples
+  pct = (100.0*dsp_clock/samples).round
+  puts "  dsp_clock = #{dsp_clock} (#{pct}% of #{samples})" if pct % 10 == 0
+  FMOD.system.update
+end
+
+puts "done.  releasing."
+FMOD.system.release

data/examples/play.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler'
+Bundler.require
+require 'fmod'
+DIR = File.dirname(__FILE__)
+
+puts "calling FMOD.init..."
+FMOD.init
+
+file = (ARGV.empty?) ? "#{DIR}/ComputerMagic.mp3" : ARGV[0]
+
+puts "creating sound #{file}..."
+sound = FMOD::Sound.new(file)
+puts "#{file} length=#{sound.length}ms"
+sound.play
+puts "scheduled play.  now starting to sleep"
+sleep (sound.length/1000.0).ceil

data/examples/play2.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler'
+Bundler.require
+require 'fmod'
+
+DIR = File.dirname(__FILE__)
+PROG = File.basename(__FILE__, '.*')
+
+
+infile1 = (ARGV.empty?) ? "#{DIR}/ComputerMagic.mp3" : ARGV.shift
+infile2 = (ARGV.empty?) ? "#{DIR}/Flute3.wav" : ARGV.shift
+
+puts "calling FMOD.init"
+FMOD.init
+
+sound1 = FMOD::Sound.new(infile1)
+puts "#{infile1} length=#{sound1.length}ms"
+sound2 = FMOD::Sound.new(infile2)
+puts "#{infile2} length=#{sound2.length}ms"
+
+puts "scheduling play..."
+sound1.play
+sound2.play
+puts "scheduled play.  now starting to sleep"
+sleep ([sound1.length,sound2.length].max/1000.0).ceil

data/{scratch.rb → examples/scratch.rb}

@@ -1,4 +1,9 @@
-require 'lib/fmod'
+#!/usr/bin/env ruby
+#
+require 'rubygems'
+require 'bundler'
+Bundler.require
+require 'fmod'
 
 start_time = Time.now
 puts "initializing FMOD ..."
@@ -6,7 +11,9 @@ FMOD.init
 end_time = Time.new - start_time
 puts "done in #{end_time} seconds."
 
-file = (ARGV.empty?) ? "Kids.mp3" : ARGV[0]
+DIR = File.dirname(__FILE__)
+
+file = (ARGV.empty?) ? "#{DIR}/ComputerMagic.mp3" : ARGV[0]
 
 
 puts "initializing a sound ..."
@@ -17,6 +24,7 @@ puts "done in #{end_time} seconds."
 sound.play
 puts FMOD.system.version
 puts sound.channel.frequency
+puts "sound length=#{sound.length}ms"
 sleep 2
 # sound.channel.frequency = 11050.0
 # puts sound.channel.frequency
@@ -46,4 +54,4 @@ end
 # block
 while true
   sleep 5
-end
+end

data/examples/volume.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler'
+Bundler.require
+require 'fmod'
+DIR = File.dirname(__FILE__)
+
+puts "calling FMOD.init..."
+FMOD.init
+
+file = (ARGV.empty?) ? "#{DIR}/Flute3.wav" : ARGV[0]
+
+puts "creating sound #{file}..."
+sound = FMOD::Sound.new(file)
+puts "#{file} length=#{sound.length}ms"
+puts "playing at full volume:"
+sound.play
+sleep (sound.length/1000.0).ceil
+
+puts "playing at quarter volume:"
+sound.play(:paused => true)
+sound.channel.set_volume(0.25)
+sound.channel.set_paused(false)
+sleep (sound.length/1000.0).ceil

data/examples/write.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler'
+Bundler.require
+require 'fmod'
+
+DIR = File.dirname(__FILE__)
+PROG = File.basename(__FILE__, '.*')
+
+
+infile = (ARGV.empty?) ? "#{DIR}/ComputerMagic.mp3" : ARGV[0]
+outfile = "#{DIR}/output/#{PROG}.wav"
+puts "writing to #{outfile}"
+
+puts "calling FMOD.init"
+FMOD.init(:output_wav => outfile)
+
+puts "creating sound #{infile}"
+sound = FMOD::Sound.new(infile)
+puts "#{infile} length=#{sound.length}ms"
+
+puts "scheduling play..."
+sound.play
+
+samples = FMOD::Convert.ms_to_samples(sound.length)
+puts "updating until #{samples} samples"
+
+while (dsp_clock = FMOD.system.dsp_clock) < samples
+  pct = (100.0*dsp_clock/samples).round
+  puts "  dsp_clock = #{dsp_clock} (#{pct}% of #{samples})" if pct % 10 == 0
+  FMOD.system.update
+end
+
+puts "done.  releasing."
+FMOD.system.release

data/fmod-ruby.gemspec

@@ -16,4 +16,5 @@ Gem::Specification.new do |gem|
   gem.version       = Fmod::VERSION
 
   gem.add_dependency("ffi")
+  gem.add_dependency("hash_keyword_args")
 end

data/lib/fmod.rb

@@ -1,4 +1,5 @@
 require 'ffi'
+require 'hash_keyword_args'
 
 require 'fmod/version'
 
@@ -6,13 +7,14 @@ require 'fmod/constants'
 require 'fmod/enums'
 require 'fmod/functions'
          
-require 'fmod/system'
-require 'fmod/sound'
+require 'fmod/convert'
 require 'fmod/channel'
+require 'fmod/sound'
+require 'fmod/system'
 
 module FMOD
-  def self.init
-    @system = System.new
+  def self.init(*args)
+    @system = System.new(*args)
   end
   
   # Ruby version of the system

data/lib/fmod/channel.rb

@@ -6,50 +6,82 @@ module FMOD
     
     # TODO: Need to find a way to reliably destroy this pointer
     def initialize(options = {})
-      @system_pointer = FMOD.system.pointer
-      @pointer = FFI::MemoryPointer.new(:pointer)
+      @memory = FFI::MemoryPointer.new(:pointer)
     end
+
+    def pointer
+      @memory.read_pointer
+    end
+
+    def pointer_addr
+      @memory
+    end
+
     
     # result = FMOD_Channel_IsPlaying(channel, &playing);
     def playing?
       FFI::MemoryPointer.new(:int) do |ptr|
-        error_check FMOD_Channel_IsPlaying(@pointer.read_pointer, ptr)
-        return playing_ptr.read_int == 1
+        error_check FMOD_Channel_IsPlaying(pointer, ptr)
+        return ptr.read_int == 1
       end
     end
     
     def pause
-      error_check FMOD_Channel_SetPaused(@pointer.read_pointer, ((paused?) ? 0 : 1))
-      true
+      error_check FMOD_Channel_SetPaused(pointer, ((paused?) ? 0 : 1))
+    end
+
+    def set_paused(bool)
+      error_check FMOD_Channel_SetPaused(pointer, (bool ? 1 : 0))
     end
     
     def paused?
       FFI::MemoryPointer.new(:int) do |ptr|
-        error_check FMOD_Channel_GetPaused(@pointer.read_pointer, ptr)
+        error_check FMOD_Channel_GetPaused(pointer, ptr)
         return ptr.read_int == 1
       end
     end
     
     def set_position(int = 0)
-      error_check FMOD_Channel_SetPosition(@pointer.read_pointer, int, FMOD_TIMEUNIT_MS)
+      error_check FMOD_Channel_SetPosition(pointer, int, FMOD_TIMEUNIT_MS)
     end
     
     def pan=(float)
       float = 1.0 if float > 1.0
       float = 0.0 if float < 0.0
-      error_check FMOD_Channel_SetPan(@pointer.read_pointer, float)
+      error_check FMOD_Channel_SetPan(pointer, float)
     end
     
     def frequency
       FFI::MemoryPointer.new(:float) do |ptr|
-        error_check FMOD_Channel_GetFrequency(@pointer.read_pointer, ptr)
+        error_check FMOD_Channel_GetFrequency(pointer, ptr)
         return ptr.read_float
       end
     end
     
     def frequency=(float)
-      error_check FMOD_Channel_SetFrequency(@pointer.read_pointer, float)
+      error_check FMOD_Channel_SetFrequency(pointer, float)
     end
-    
+
+    def set_delay(samples, opts={})
+      opts = opts.keyword_args(:delaytype => :required)
+      hi, lo = Convert.int64_to_32(samples)
+      error_check FMOD_Channel_SetDelay(pointer, opts.delaytype, hi, lo)
+    end
+
+    def get_delay(opts={})
+      opts = opts.keyword_args(:delaytype => :required)
+
+      FFI::MemoryPointer.new(:int) { |hi|
+        FFI::MemoryPointer.new(:int) { |lo|
+          error_check FMOD_Channel_GetDelay(pointer, opts.delaytype, hi, lo)
+          return Convert.int32_to_64(hi.read_int, lo.read_int)
+        }
+      }
+    end
+
+    def set_volume(volume)
+      error_check FMOD_Channel_SetVolume(pointer, volume)
+    end
+
   end
-end
+end

data/lib/fmod/convert.rb

@@ -0,0 +1,19 @@
+module FMOD
+  module Convert
+
+    # since ruby will automatically convert to a Bignum if needed, this
+    # should work fine even on 32-bit platforms
+    def self.int32_to_64(hi32, lo32)
+      (hi32 << 32) | lo32
+    end
+
+    def self.int64_to_32(int64)
+      [(int64 & 0xFFFFFFFF00000000) >> 32, int64 & 0xFFFFFFFF]
+    end
+
+    def self.ms_to_samples(ms, opts={})
+      opts = opts.keyword_args(:sample_rate => FMOD.system.sample_rate) # samples per second
+      ms * opts.sample_rate / 1000
+    end
+  end
+end

data/lib/fmod/enums.rb

@@ -3,8 +3,8 @@ module FMOD
     extend FFI::Library
     
     FMOD_CHANNELINDEX = enum(
-      :FMOD_CHANNEL_FREE, 
-      :FMOD_CHANNEL_REUSE
+      :FMOD_CHANNEL_FREE, -1,
+      :FMOD_CHANNEL_REUSE, -2
     )
 
     FMOD_RESULT = enum(
@@ -132,5 +132,74 @@ module FMOD
       :FMOD_DSP_TYPE_DELAY, 
       :FMOD_DSP_TYPE_TREMOLO
     )
+
+    FMOD_OUTPUTTYPE = enum(
+      :FMOD_OUTPUTTYPE_AUTODETECT,
+      :FMOD_OUTPUTTYPE_UNKNOWN,
+      :FMOD_OUTPUTTYPE_NOSOUND,
+      :FMOD_OUTPUTTYPE_WAVWRITER,
+      :FMOD_OUTPUTTYPE_NOSOUND_NRT,
+      :FMOD_OUTPUTTYPE_WAVWRITER_NRT,
+      :FMOD_OUTPUTTYPE_DSOUND,
+      :FMOD_OUTPUTTYPE_WINMM,
+      :FMOD_OUTPUTTYPE_WASAPI,
+      :FMOD_OUTPUTTYPE_ASIO,
+      :FMOD_OUTPUTTYPE_OSS,
+      :FMOD_OUTPUTTYPE_ALSA,
+      :FMOD_OUTPUTTYPE_ESD,
+      :FMOD_OUTPUTTYPE_PULSEAUDIO,
+      :FMOD_OUTPUTTYPE_COREAUDIO,
+      :FMOD_OUTPUTTYPE_XBOX360,
+      :FMOD_OUTPUTTYPE_PSP,
+      :FMOD_OUTPUTTYPE_PS3,
+      :FMOD_OUTPUTTYPE_NGP,
+      :FMOD_OUTPUTTYPE_WII,
+      :FMOD_OUTPUTTYPE_3DS,
+      :FMOD_OUTPUTTYPE_AUDIOTRACK,
+      :FMOD_OUTPUTTYPE_OPENSL,
+      :FMOD_OUTPUTTYPE_NACL,
+      :FMOD_OUTPUTTYPE_MAX,
+      :FMOD_OUTPUTTYPE_FORCEINT, 65536
+    )
+
+    FMOD_SOUND_FORMAT = enum(
+      :FMOD_SOUND_FORMAT_NONE,
+      :FMOD_SOUND_FORMAT_PCM8,
+      :FMOD_SOUND_FORMAT_PCM16,
+      :FMOD_SOUND_FORMAT_PCM24,
+      :FMOD_SOUND_FORMAT_PCM32,
+      :FMOD_SOUND_FORMAT_PCMFLOAT,
+      :FMOD_SOUND_FORMAT_GCADPCM,
+      :FMOD_SOUND_FORMAT_IMAADPCM,
+      :FMOD_SOUND_FORMAT_VAG,
+      :FMOD_SOUND_FORMAT_HEVAG,
+      :FMOD_SOUND_FORMAT_XMA,
+      :FMOD_SOUND_FORMAT_MPEG,
+      :FMOD_SOUND_FORMAT_CELT,
+      :FMOD_SOUND_FORMAT_AT9,
+      :FMOD_SOUND_FORMAT_XWMA,
+      :FMOD_SOUND_FORMAT_MAX,
+      :FMOD_SOUND_FORMAT_FORCEINT, 65536
+    )
+
+    FMOD_DSP_RESAMPLER = enum(
+      :FMOD_DSP_RESAMPLER_NOINTERP,
+      :FMOD_DSP_RESAMPLER_LINEAR,
+      :FMOD_DSP_RESAMPLER_CUBIC,
+      :FMOD_DSP_RESAMPLER_SPLINE,
+      :FMOD_DSP_RESAMPLER_MAX,
+      :FMOD_DSP_RESAMPLER_FORCEINT, 65536
+    )
+
+    FMOD_DELAYTYPE = enum(
+      :FMOD_DELAYTYPE_END_MS,
+      :FMOD_DELAYTYPE_DSPCLOCK_START,
+      :FMOD_DELAYTYPE_DSPCLOCK_END,
+      :FMOD_DELAYTYPE_DSPCLOCK_PAUSE,
+
+      :FMOD_DELAYTYPE_MAX,
+      :FMOD_DELAYTYPE_FORCEINT, 65536
+    )
+
   end
-end
+end

data/lib/fmod/functions.rb

@@ -31,10 +31,15 @@ module FMOD
     attach_function :FMOD_System_Create, [:pointer], FMOD_RESULT
     attach_function :FMOD_System_GetVersion, [:pointer, :pointer], FMOD_RESULT
     attach_function :FMOD_System_Init, [:pointer, :int, :int, :pointer], FMOD_RESULT
+    attach_function :FMOD_System_Update, [:pointer], FMOD_RESULT
+    attach_function :FMOD_System_Release, [:pointer], FMOD_RESULT
+    attach_function :FMOD_System_GetDSPClock, [:pointer, :pointer, :pointer], FMOD_RESULT
+    attach_function :FMOD_System_GetDSPBufferSize, [:pointer, :pointer, :pointer], FMOD_RESULT
+    attach_function :FMOD_System_SetSoftwareFormat, [:pointer, :int, FMOD_SOUND_FORMAT, :int, :int, FMOD_DSP_RESAMPLER], FMOD_RESULT
   
     attach_function :FMOD_System_CreateSound, [:pointer, :string, :int, :int, :pointer], FMOD_RESULT
     attach_function :FMOD_System_CreateStream, [:pointer, :string, :int, :int, :pointer], FMOD_RESULT
-    attach_function :FMOD_System_PlaySound, [:pointer, :int, :pointer, :int, :pointer], FMOD_RESULT
+    attach_function :FMOD_System_PlaySound, [:pointer, FMOD_CHANNELINDEX, :pointer, :int, :pointer], FMOD_RESULT
   
     # FMOD_RESULT FMOD_System_GetDriverInfo(FMOD_SYSTEM * system, int id, char * name, int namelen, FMOD_GUID * guid);
     # attach_function :FMOD_System_GetDriverInfo
@@ -48,6 +53,13 @@ module FMOD
     # FMOD_RESULT FMOD_System_GetSoftwareChannels(FMOD_SYSTEM * system, int * numsoftwarechannels);
     attach_function :FMOD_System_GetSoftwareChannels, [:pointer, :pointer], FMOD_RESULT
 
+    # FMOD_RESULT F_API FMOD_System_SetOutput              (FMOD_SYSTEM *system, FMOD_OUTPUTTYPE output);
+    attach_function :FMOD_System_SetOutput, [:pointer, FMOD_OUTPUTTYPE], FMOD_RESULT
+    
+    # FMOD_RESULT F_API FMOD_System_GetOutput              (FMOD_SYSTEM *system, FMOD_OUTPUTTYPE *output);
+    attach_function :FMOD_System_GetOutput, [:pointer, :pointer], FMOD_RESULT
+
+
     # FMOD_RESULT FMOD_Channel_IsPlaying(FMOD_CHANNEL *  channel, FMOD_BOOL *  isplaying);
     attach_function :FMOD_Channel_IsPlaying, [:pointer, :pointer], FMOD_RESULT
     
@@ -69,6 +81,19 @@ module FMOD
     # FMOD_RESULT FMOD_Channel_SetFrequency(FMOD_CHANNEL *  channel, float  frequency);    
     attach_function :FMOD_Channel_SetFrequency, [:pointer, :float], FMOD_RESULT  
 
+    # FMOD_RESULT FMOD_Channel_SetDelay(FMOD_CHANNEL *channel, FMOD_DELAYTYPE delaytype, unsigned int delayhi, unsigned int delaylo);
+    attach_function :FMOD_Channel_SetDelay, [:pointer, FMOD_DELAYTYPE, :int, :int], FMOD_RESULT
+
+    # FMOD_RESULT FMOD_Channel_GetDelay(FMOD_CHANNEL *channel, FMOD_DELAYTYPE delaytype, unsigned int *delayhi, unsigned int *delaylo);
+    attach_function :FMOD_Channel_GetDelay, [:pointer, FMOD_DELAYTYPE, :pointer, :pointer], FMOD_RESULT
+
+    attach_function :FMOD_Channel_SetVolume, [:pointer, :float], FMOD_RESULT
+
+
+    # FMOD_RESULT F_API FMOD_Sound_GetLength               (FMOD_SOUND *sound, unsigned int *length, FMOD_TIMEUNIT lengthtype);
+    attach_function :FMOD_Sound_GetLength, [:pointer, :pointer, :FMOD_TIMEUNIT], FMOD_RESULT  
+    attach_function :FMOD_Sound_Release, [:pointer], FMOD_RESULT  
+
     
     def error_check(result)
       raise "FMOD error! #{result}" if result != :FMOD_OK

data/lib/fmod/sound.rb

@@ -7,31 +7,41 @@ module FMOD
       @system_pointer  = FMOD.system.pointer
       @channel = options[:channel] || Channel.new
       @file = file
+      @sound_ptr = nil
     end
-    
-    def play
-      play_stream
+
+    def length(unit = FMOD_TIMEUNIT_MS)
+      FFI::MemoryPointer.new(:int) do |ptr|
+        error_check FMOD_Sound_GetLength(sound_ptr, ptr, FMOD_TIMEUNIT_MS)
+        return ptr.read_int
+      end
     end
     
-    def play_sound
-      sound_ptr = FFI::MemoryPointer.new(:pointer)
-      # FMOD_RESULT = FMOD_System_CreateStream(system, "wave.mp3", FMOD_DEFAULT, 0, &sound);
-      error_check FMOD_System_CreateStream(@system_pointer.read_pointer, @file, FMOD_DEFAULT, 0, sound_ptr);
-
+    def play(opts={})
+      opts = opts.keyword_args(:paused)
       # FMOD_RESULT = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, 0, &channel);
-      error_check FMOD_System_PlaySound(@system_pointer.read_pointer, FMOD_CHANNELINDEX[:FMOD_CHANNEL_FREE], sound_ptr.read_pointer, 0, @channel.pointer);
+      error_check FMOD_System_PlaySound(FMOD.system.pointer, :FMOD_CHANNEL_FREE, sound_ptr, opts.paused ? 1 : 0, @channel.pointer_addr);
       true
     end
-    
-    def play_stream  
-      sound_ptr = FFI::MemoryPointer.new(:pointer)
+
+    def release
+      return unless @sound_ptr
+      error_check FMOD_Sound_Release(@sound_ptr)
+      @sound_ptr = nil
+    end
+
+    private
+
+    def sound_ptr
+      return @sound_ptr if @sound_ptr
+
+      @memory = FFI::MemoryPointer.new(:pointer)
       # FMOD_RESULT = FMOD_System_CreateSound(system, "drumloop.wav", FMOD_SOFTWARE, 0, &sound);
-      error_check FMOD_System_CreateSound(@system_pointer.read_pointer, @file, FMOD_DEFAULT, 0, sound_ptr);
+      error_check FMOD_System_CreateSound(@system_pointer, @file, FMOD_DEFAULT, 0, @memory);
 
-      # FMOD_RESULT = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, 0, &channel);
-      error_check FMOD_System_PlaySound(@system_pointer.read_pointer, FMOD_CHANNELINDEX[:FMOD_CHANNEL_FREE], sound_ptr.read_pointer, 0, @channel.pointer);
-      true
+      @sound_ptr = @memory.read_pointer
     end
+
     
   end 
-end
+end

data/lib/fmod/system.rb

@@ -3,51 +3,91 @@ module FMOD
     include Functions
     # pointer to the system instance
     attr_reader :pointer
+    attr_reader :sample_rate
         
-    def initialize
-      # FMOD_SYSTEM *system;      
-      # result = FMOD_System_Create(&system);
-      # result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL);
-      @pointer = FFI::MemoryPointer.new(:pointer)
-      error_check FMOD_System_Create(@pointer)  
-      error_check FMOD_System_Init(@pointer.read_pointer, 32, FMOD_INIT_NORMAL, nil)
+    def initialize(opts={})
+      opts = opts.keyword_args(:output_wav,
+                               :sample_rate => 44100)
+
+      @sample_rate = opts.sample_rate
+
+      @memory = FFI::MemoryPointer.new(:pointer)
+      error_check FMOD_System_Create(@memory)  
+      @pointer = @memory.read_pointer
+
+      case
+      when opts.output_wav
+        error_check FMOD_System_SetOutput(@pointer, :FMOD_OUTPUTTYPE_WAVWRITER_NRT)
+        error_check FMOD_System_SetSoftwareFormat(@pointer, sample_rate, :FMOD_SOUND_FORMAT_PCM16, 2, 6, :FMOD_DSP_RESAMPLER_LINEAR)
+        error_check FMOD_System_Init(@pointer, 100,  FMOD_INIT_STREAM_FROM_UPDATE, opts.output_wav)
+      else
+        error_check FMOD_System_Init(@pointer, 32, FMOD_INIT_NORMAL, nil)
+      end
     end
     
     def version
       # unsigned int version;
       # result = FMOD_System_GetVersion(system, &version);
-      FFI::MemoryPointer.new(:int) do |version_ptr|
-        error_check FMOD_System_GetVersion(@pointer.read_pointer, version_ptr);
+      FFI::MemoryPointer.new(:int) { |version_ptr|
+        error_check FMOD_System_GetVersion(@pointer, version_ptr);
         return version_ptr.read_int
-      end
+      }
     end
     
-    
     def driver_count
       # unsigned int numdrivers;
       # result = FMOD_System_GetNumDrivers(system, &numdrivers);
-      count_ptr = FFI::MemoryPointer.new(:int)
-      error_check FMOD_System_GetNumDrivers(@pointer.read_pointer, count_ptr)
-      count_ptr.read_int
+      FFI::MemoryPointer.new(:int) { |count_ptr|
+        error_check FMOD_System_GetNumDrivers(@pointer, count_ptr)
+        count_ptr.read_int
+      }
     end
     
     def software_channels
-      num_ptr = FFI::MemoryPointer.new(:int)
-      error_check FMOD_System_GetSoftwareChannels(@pointer.read_pointer, num_ptr)
-      num_ptr.read_int
+      FFI::MemoryPointer.new(:int) { |num_ptr|
+        error_check FMOD_System_GetSoftwareChannels(@pointer, num_ptr)
+        num_ptr.read_int
+      }
     end
     
     def hardware_channels
-      num2d = FFI::MemoryPointer.new(:int)
-      num3d = FFI::MemoryPointer.new(:int)
-      total = FFI::MemoryPointer.new(:int)
-      error_check FMOD_System_GetHardwareChannels(@pointer.read_pointer, num2d, num3d, total)
-      
-      {
-        :num2d => num2d.read_int,
-        :num3d => num3d.read_int,
-        :total => total.read_int,
+      FFI::MemoryPointer.new(:int) { |num2d|
+        FFI::MemoryPointer.new(:int) { |num3d|
+          FFI::MemoryPointer.new(:int) { |total|
+            error_check FMOD_System_GetHardwareChannels(@pointer, num2d, num3d, total)
+
+            {
+              :num2d => num2d.read_int,
+              :num3d => num3d.read_int,
+              :total => total.read_int,
+            }
+          }
+        }
       }
     end
+
+    def dsp_clock
+      FFI::MemoryPointer.new(:int) { |hi|
+        FFI::MemoryPointer.new(:int) { |lo|
+          error_check FMOD_System_GetDSPClock(@pointer, hi, lo)
+          return Convert.int32_to_64(hi.read_int, lo.read_int)
+        }
+      }
+    end
+
+    def buffer_size
+      FFI::MemoryPointer.new(:int) { |size|
+        error_check FMOD_System_GetDSPBufferSize(@pointer, size, nil)
+        return size.read_int
+      }
+    end
+
+    def update
+      error_check FMOD_System_Update(@pointer)
+    end
+
+    def release
+      error_check FMOD_System_Release(@pointer)
+    end
   end
-end
+end

data/lib/fmod/version.rb

@@ -1,3 +1,3 @@
 module Fmod
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fmod-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-16 00:00:00.000000000 Z
+date: 2011-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &70253800274800 !ruby/object:Gem::Requirement
+  requirement: &70344468616080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,18 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70253800274800
+  version_requirements: *70344468616080
+- !ruby/object:Gem::Dependency
+  name: hash_keyword_args
+  requirement: &70344468151240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70344468151240
 description: Wrapper for the FMOD audio library
 email:
 - ronen@barzel.org
@@ -33,17 +44,27 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- examples/ComputerMagic.mp3
+- examples/ComputerMagic.wav
+- examples/Flute3.wav
+- examples/concat.rb
+- examples/output/concat.wav
+- examples/output/write.wav
+- examples/play.rb
+- examples/play2.rb
+- examples/scratch.rb
+- examples/volume.rb
+- examples/write.rb
 - fmod-ruby.gemspec
 - lib/fmod.rb
 - lib/fmod/channel.rb
 - lib/fmod/constants.rb
+- lib/fmod/convert.rb
 - lib/fmod/enums.rb
 - lib/fmod/functions.rb
-- lib/fmod/pointer_helper.rb
 - lib/fmod/sound.rb
 - lib/fmod/system.rb
 - lib/fmod/version.rb
-- scratch.rb
 homepage: https://github.com/ronen/fmod-ruby
 licenses: []
 post_install_message: 
@@ -64,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.12
 signing_key: 
 specification_version: 3
 summary: Wrapper for the FMOD audio library

data/lib/fmod/pointer_helper.rb

@@ -1,8 +0,0 @@
-module FMOD
-class PointerHelper
-  def self.release(pointer)
-
-  end
-end
-
-# p = AutoPointer.new(other_pointer, PointerHelper.method(:release))