fmod-ruby 0.0.1

data/.gitignore

@@ -0,0 +1,41 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+#*~
+#\#*
+#.\#*
+#
+# For vim:
+#*.swp
+

data/Gemfile

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

data/README.md

@@ -0,0 +1,51 @@
+<!-- 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.
+
+FMOD?
+=====
+
+"FMOD is a programming library and toolkit for the creation and playback of interactive audio. It supports all leading operating systems and game platforms." And now Ruby too. FMOD supports all sorts of audio file playback, surround sound and multichannel, as well as effects, VST plugins, 3D sound, and wavetable synthesis.
+
+FMOD is not free, nor is it open source, but it does have a very [liberal license](http://www.fmod.org/index.php/sales). While commercial use is quite expensive, it is free to use in your non-commercial projects.
+
+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.
+
+That being said:
+
+  gem install fmod-ruby
+
+or, in a Gemfile
+
+  gem "fmod-ruby", :require => "fmod"
+
+
+  
+Usage
+=====
+
+  require "fmod"
+
+  FMOD.init
+  sound = FMOD::Sound.new(file)
+  sound.play
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/fmod-ruby.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/fmod/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["ronen barzel"]
+  gem.email         = ["ronen@barzel.org"]
+  gem.description   = %q{Wrapper for the FMOD audio library}
+  gem.summary       = %q{Wrapper for the FMOD audio library}
+  gem.homepage      = "https://github.com/ronen/fmod-ruby"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "fmod-ruby"
+  gem.require_paths = ["lib"]
+  gem.version       = Fmod::VERSION
+
+  gem.add_dependency("ffi")
+end

data/lib/fmod.rb

@@ -0,0 +1,27 @@
+require 'ffi'
+
+require 'fmod/version'
+
+require 'fmod/constants'
+require 'fmod/enums'
+require 'fmod/functions'
+         
+require 'fmod/system'
+require 'fmod/sound'
+require 'fmod/channel'
+
+module FMOD
+  def self.init
+    @system = System.new
+  end
+  
+  # Ruby version of the system
+  def self.system
+    @system
+  end
+  
+  # This pointer is used by many of the sound functions
+  def self.system_pointer
+    @system.pointer
+  end
+end

data/lib/fmod/channel.rb

@@ -0,0 +1,55 @@
+module FMOD
+  class Channel
+    include Functions
+    # pointer to the channel instance
+    attr_reader :pointer
+    
+    # TODO: Need to find a way to reliably destroy this pointer
+    def initialize(options = {})
+      @system_pointer = FMOD.system.pointer
+      @pointer = FFI::MemoryPointer.new(:pointer)
+    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
+      end
+    end
+    
+    def pause
+      error_check FMOD_Channel_SetPaused(@pointer.read_pointer, ((paused?) ? 0 : 1))
+      true
+    end
+    
+    def paused?
+      FFI::MemoryPointer.new(:int) do |ptr|
+        error_check FMOD_Channel_GetPaused(@pointer.read_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)
+    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)
+    end
+    
+    def frequency
+      FFI::MemoryPointer.new(:float) do |ptr|
+        error_check FMOD_Channel_GetFrequency(@pointer.read_pointer, ptr)
+        return ptr.read_float
+      end
+    end
+    
+    def frequency=(float)
+      error_check FMOD_Channel_SetFrequency(@pointer.read_pointer, float)
+    end
+    
+  end
+end

data/lib/fmod/constants.rb

@@ -0,0 +1,80 @@
+module FMOD
+  module Constants
+    # FMOD_INITFLAGS
+    FMOD_INIT_NORMAL = 0x00000000
+    FMOD_INIT_STREAM_FROM_UPDATE = 0x00000001
+    FMOD_INIT_3D_RIGHTHANDED = 0x00000002
+    FMOD_INIT_SOFTWARE_DISABLE = 0x00000004
+    FMOD_INIT_SOFTWARE_OCCLUSION = 0x00000008
+    FMOD_INIT_SOFTWARE_HRTF = 0x00000010
+    FMOD_INIT_SOFTWARE_REVERB_LOWMEM = 0x00000040
+    FMOD_INIT_ENABLE_PROFILE = 0x00000020
+    FMOD_INIT_VOL0_BECOMES_VIRTUAL = 0x00000080
+    FMOD_INIT_WASAPI_EXCLUSIVE = 0x00000100
+    FMOD_INIT_DSOUND_HRTFNONE = 0x00000200
+    FMOD_INIT_DSOUND_HRTFLIGHT = 0x00000400
+    FMOD_INIT_DSOUND_HRTFFULL = 0x00000800
+    FMOD_INIT_PS2_DISABLECORE0REVERB = 0x00010000
+    FMOD_INIT_PS2_DISABLECORE1REVERB = 0x00020000
+    FMOD_INIT_PS2_DONTUSESCRATCHPAD = 0x00040000
+    FMOD_INIT_PS2_SWAPDMACHANNELS = 0x00080000
+    FMOD_INIT_PS3_PREFERDTS = 0x00800000
+    FMOD_INIT_PS3_FORCE2CHLPCM = 0x01000000
+    FMOD_INIT_XBOX_REMOVEHEADROOM = 0x00100000
+    FMOD_INIT_SYSTEM_MUSICMUTENOTPAUSE = 0x00200000
+    FMOD_INIT_SYNCMIXERWITHUPDATE = 0x00400000
+    FMOD_INIT_DTS_NEURALSURROUND = 0x02000000
+    FMOD_INIT_GEOMETRY_USECLOSEST = 0x04000000
+    FMOD_INIT_DISABLE_MYEARS = 0x08000000
+
+    # FMOD_MODE
+    FMOD_DEFAULT = 0x00000000
+    FMOD_LOOP_OFF = 0x00000001
+    FMOD_LOOP_NORMAL = 0x00000002
+    FMOD_LOOP_BIDI = 0x00000004
+    FMOD_2D = 0x00000008
+    FMOD_3D = 0x00000010
+    FMOD_HARDWARE = 0x00000020
+    FMOD_SOFTWARE = 0x00000040
+    FMOD_CREATESTREAM = 0x00000080
+    FMOD_CREATESAMPLE = 0x00000100
+    FMOD_CREATECOMPRESSEDSAMPLE = 0x00000200
+    FMOD_OPENUSER = 0x00000400
+    FMOD_OPENMEMORY = 0x00000800
+    FMOD_OPENMEMORY_POINT = 0x10000000
+    FMOD_OPENRAW = 0x00001000
+    FMOD_OPENONLY = 0x00002000
+    FMOD_ACCURATETIME = 0x00004000
+    FMOD_MPEGSEARCH = 0x00008000
+    FMOD_NONBLOCKING = 0x00010000
+    FMOD_UNIQUE = 0x00020000
+    FMOD_3D_HEADRELATIVE = 0x00040000
+    FMOD_3D_WORLDRELATIVE = 0x00080000
+    FMOD_3D_LOGROLLOFF = 0x00100000
+    FMOD_3D_LINEARROLLOFF = 0x00200000
+    FMOD_3D_CUSTOMROLLOFF = 0x04000000
+    FMOD_3D_IGNOREGEOMETRY = 0x40000000
+    FMOD_CDDA_FORCEASPI = 0x00400000
+    FMOD_CDDA_JITTERCORRECT = 0x00800000
+    FMOD_UNICODE = 0x01000000
+    FMOD_IGNORETAGS = 0x02000000
+    FMOD_LOWMEM = 0x08000000
+    FMOD_LOADSECONDARYRAM = 0x20000000
+    FMOD_VIRTUAL_PLAYFROMSTART = 0x80000000
+
+    # FMOD_TIMEUNIT
+    FMOD_TIMEUNIT_MS = 0x00000001
+    FMOD_TIMEUNIT_PCM = 0x00000002
+    FMOD_TIMEUNIT_PCMBYTES = 0x00000004
+    FMOD_TIMEUNIT_RAWBYTES = 0x00000008
+    FMOD_TIMEUNIT_MODORDER = 0x00000100
+    FMOD_TIMEUNIT_MODROW = 0x00000200
+    FMOD_TIMEUNIT_MODPATTERN = 0x00000400
+    FMOD_TIMEUNIT_SENTENCE_MS = 0x00010000
+    FMOD_TIMEUNIT_SENTENCE_PCM = 0x00020000
+    FMOD_TIMEUNIT_SENTENCE_PCMBYTES = 0x00040000
+    FMOD_TIMEUNIT_SENTENCE = 0x00080000
+    FMOD_TIMEUNIT_SENTENCE_SUBSOUND = 0x00100000
+    FMOD_TIMEUNIT_BUFFERED = 0x10000000
+  end
+end

data/lib/fmod/enums.rb

@@ -0,0 +1,136 @@
+module FMOD
+  module Enums
+    extend FFI::Library
+    
+    FMOD_CHANNELINDEX = enum(
+      :FMOD_CHANNEL_FREE, 
+      :FMOD_CHANNEL_REUSE
+    )
+
+    FMOD_RESULT = enum(
+      :FMOD_OK, 
+      :FMOD_ERR_ALREADYLOCKED, 
+      :FMOD_ERR_BADCOMMAND, 
+      :FMOD_ERR_CDDA_DRIVERS, 
+      :FMOD_ERR_CDDA_INIT, 
+      :FMOD_ERR_CDDA_INVALID_DEVICE, 
+      :FMOD_ERR_CDDA_NOAUDIO, 
+      :FMOD_ERR_CDDA_NODEVICES, 
+      :FMOD_ERR_CDDA_NODISC, 
+      :FMOD_ERR_CDDA_READ, 
+      :FMOD_ERR_CHANNEL_ALLOC, 
+      :FMOD_ERR_CHANNEL_STOLEN, 
+      :FMOD_ERR_COM, 
+      :FMOD_ERR_DMA, 
+      :FMOD_ERR_DSP_CONNECTION, 
+      :FMOD_ERR_DSP_FORMAT, 
+      :FMOD_ERR_DSP_NOTFOUND, 
+      :FMOD_ERR_DSP_RUNNING, 
+      :FMOD_ERR_DSP_TOOMANYCONNECTIONS, 
+      :FMOD_ERR_FILE_BAD, 
+      :FMOD_ERR_FILE_COULDNOTSEEK, 
+      :FMOD_ERR_FILE_DISKEJECTED, 
+      :FMOD_ERR_FILE_EOF, 
+      :FMOD_ERR_FILE_NOTFOUND, 
+      :FMOD_ERR_FILE_UNWANTED, 
+      :FMOD_ERR_FORMAT, 
+      :FMOD_ERR_HTTP, 
+      :FMOD_ERR_HTTP_ACCESS, 
+      :FMOD_ERR_HTTP_PROXY_AUTH, 
+      :FMOD_ERR_HTTP_SERVER_ERROR, 
+      :FMOD_ERR_HTTP_TIMEOUT, 
+      :FMOD_ERR_INITIALIZATION, 
+      :FMOD_ERR_INITIALIZED, 
+      :FMOD_ERR_INTERNAL, 
+      :FMOD_ERR_INVALID_ADDRESS, 
+      :FMOD_ERR_INVALID_FLOAT, 
+      :FMOD_ERR_INVALID_HANDLE, 
+      :FMOD_ERR_INVALID_PARAM, 
+      :FMOD_ERR_INVALID_POSITION, 
+      :FMOD_ERR_INVALID_SPEAKER, 
+      :FMOD_ERR_INVALID_SYNCPOINT, 
+      :FMOD_ERR_INVALID_VECTOR, 
+      :FMOD_ERR_IRX, 
+      :FMOD_ERR_MAXAUDIBLE, 
+      :FMOD_ERR_MEMORY, 
+      :FMOD_ERR_MEMORY_CANTPOINT, 
+      :FMOD_ERR_MEMORY_IOP, 
+      :FMOD_ERR_MEMORY_SRAM, 
+      :FMOD_ERR_NEEDS2D, 
+      :FMOD_ERR_NEEDS3D, 
+      :FMOD_ERR_NEEDSHARDWARE, 
+      :FMOD_ERR_NEEDSSOFTWARE, 
+      :FMOD_ERR_NET_CONNECT, 
+      :FMOD_ERR_NET_SOCKET_ERROR, 
+      :FMOD_ERR_NET_URL, 
+      :FMOD_ERR_NET_WOULD_BLOCK, 
+      :FMOD_ERR_NOTREADY, 
+      :FMOD_ERR_OUTPUT_ALLOCATED, 
+      :FMOD_ERR_OUTPUT_CREATEBUFFER, 
+      :FMOD_ERR_OUTPUT_DRIVERCALL, 
+      :FMOD_ERR_OUTPUT_ENUMERATION, 
+      :FMOD_ERR_OUTPUT_FORMAT, 
+      :FMOD_ERR_OUTPUT_INIT, 
+      :FMOD_ERR_OUTPUT_NOHARDWARE, 
+      :FMOD_ERR_OUTPUT_NOSOFTWARE, 
+      :FMOD_ERR_PAN, 
+      :FMOD_ERR_PLUGIN, 
+      :FMOD_ERR_PLUGIN_INSTANCES, 
+      :FMOD_ERR_PLUGIN_MISSING, 
+      :FMOD_ERR_PLUGIN_RESOURCE, 
+      :FMOD_ERR_PRELOADED, 
+      :FMOD_ERR_PROGRAMMERSOUND, 
+      :FMOD_ERR_RECORD, 
+      :FMOD_ERR_REVERB_INSTANCE, 
+      :FMOD_ERR_SUBSOUND_ALLOCATED, 
+      :FMOD_ERR_SUBSOUND_CANTMOVE, 
+      :FMOD_ERR_SUBSOUND_MODE, 
+      :FMOD_ERR_SUBSOUNDS, 
+      :FMOD_ERR_TAGNOTFOUND, 
+      :FMOD_ERR_TOOMANYCHANNELS, 
+      :FMOD_ERR_UNIMPLEMENTED, 
+      :FMOD_ERR_UNINITIALIZED, 
+      :FMOD_ERR_UNSUPPORTED, 
+      :FMOD_ERR_UPDATE, 
+      :FMOD_ERR_VERSION, 
+      :FMOD_ERR_EVENT_FAILED, 
+      :FMOD_ERR_EVENT_INFOONLY, 
+      :FMOD_ERR_EVENT_INTERNAL, 
+      :FMOD_ERR_EVENT_MAXSTREAMS, 
+      :FMOD_ERR_EVENT_MISMATCH, 
+      :FMOD_ERR_EVENT_NAMECONFLICT, 
+      :FMOD_ERR_EVENT_NOTFOUND, 
+      :FMOD_ERR_EVENT_NEEDSSIMPLE, 
+      :FMOD_ERR_EVENT_GUIDCONFLICT, 
+      :FMOD_ERR_EVENT_ALREADY_LOADED, 
+      :FMOD_ERR_MUSIC_UNINITIALIZED, 
+      :FMOD_ERR_MUSIC_NOTFOUND, 
+      :FMOD_ERR_MUSIC_NOCALLBACK
+    )
+  
+    FMOD_DSP_TYPE = enum(
+      :FMOD_DSP_TYPE_UNKNOWN, 
+      :FMOD_DSP_TYPE_MIXER, 
+      :FMOD_DSP_TYPE_OSCILLATOR, 
+      :FMOD_DSP_TYPE_LOWPASS, 
+      :FMOD_DSP_TYPE_ITLOWPASS, 
+      :FMOD_DSP_TYPE_HIGHPASS, 
+      :FMOD_DSP_TYPE_ECHO, 
+      :FMOD_DSP_TYPE_FLANGE, 
+      :FMOD_DSP_TYPE_DISTORTION, 
+      :FMOD_DSP_TYPE_NORMALIZE, 
+      :FMOD_DSP_TYPE_PARAMEQ, 
+      :FMOD_DSP_TYPE_PITCHSHIFT, 
+      :FMOD_DSP_TYPE_CHORUS, 
+      :FMOD_DSP_TYPE_REVERB, 
+      :FMOD_DSP_TYPE_VSTPLUGIN, 
+      :FMOD_DSP_TYPE_WINAMPPLUGIN, 
+      :FMOD_DSP_TYPE_ITECHO, 
+      :FMOD_DSP_TYPE_COMPRESSOR, 
+      :FMOD_DSP_TYPE_SFXREVERB, 
+      :FMOD_DSP_TYPE_LOWPASS_SIMPLE, 
+      :FMOD_DSP_TYPE_DELAY, 
+      :FMOD_DSP_TYPE_TREMOLO
+    )
+  end
+end

data/lib/fmod/functions.rb

@@ -0,0 +1,77 @@
+module FMOD
+  module Functions
+    extend  FFI::Library
+    include Constants
+    include Enums
+    
+    ffi_lib 'libfmodex'
+    
+    typedef :int,  :FMOD_BOOL                       
+    typedef :uint, :FMOD_TIMEUNIT
+    typedef :uint, :FMOD_MODE
+    typedef :uint, :FMOD_INITFLAGS
+    typedef :uint, :FMOD_CAPS
+    typedef :uint, :FMOD_DEBUGLEVEL
+    typedef :uint, :FMOD_MEMORY_TYPE
+    
+    # typedef struct FMOD_SYSTEM        FMOD_SYSTEM;
+    # typedef struct FMOD_SOUND         FMOD_SOUND;
+    # typedef struct FMOD_CHANNEL       FMOD_CHANNEL;
+    # typedef struct FMOD_CHANNELGROUP  FMOD_CHANNELGROUP;
+    # typedef struct FMOD_SOUNDGROUP    FMOD_SOUNDGROUP;
+    # typedef struct FMOD_REVERB        FMOD_REVERB;
+    # typedef struct FMOD_DSP           FMOD_DSP;
+    # typedef struct FMOD_DSPCONNECTION FMOD_DSPCONNECTION;
+    # typedef struct FMOD_POLYGON     FMOD_POLYGON;
+    # typedef struct FMOD_GEOMETRY    FMOD_GEOMETRY;
+    # typedef struct FMOD_SYNCPOINT   FMOD_SYNCPOINT;
+
+
+    # SYSTEM FUNCTIONS
+    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_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
+  
+    # FMOD_RESULT FMOD_System_GetDriverInfo(FMOD_SYSTEM * system, int id, char * name, int namelen, FMOD_GUID * guid);
+    # attach_function :FMOD_System_GetDriverInfo
+
+    # FMOD_RESULT FMOD_System_GetNumDrivers(FMOD_SYSTEM * system, int * numdrivers);
+    attach_function :FMOD_System_GetNumDrivers, [:pointer, :pointer], FMOD_RESULT
+
+    # FMOD_RESULT FMOD_System_GetHardwareChannels(FMOD_SYSTEM * system, int * num2d, int * num3d, int * total);
+    attach_function :FMOD_System_GetHardwareChannels, [:pointer, :pointer, :pointer, :pointer], FMOD_RESULT
+
+    # FMOD_RESULT FMOD_System_GetSoftwareChannels(FMOD_SYSTEM * system, int * numsoftwarechannels);
+    attach_function :FMOD_System_GetSoftwareChannels, [:pointer, :pointer], FMOD_RESULT
+
+    # FMOD_RESULT FMOD_Channel_IsPlaying(FMOD_CHANNEL *  channel, FMOD_BOOL *  isplaying);
+    attach_function :FMOD_Channel_IsPlaying, [:pointer, :pointer], FMOD_RESULT
+    
+    # FMOD_RESULT FMOD_Channel_SetPaused(FMOD_CHANNEL * channel, FMOD_BOOL paused);
+    attach_function :FMOD_Channel_SetPaused, [:pointer, :int], FMOD_RESULT
+    
+    # FMOD_RESULT FMOD_Channel_GetPaused(FMOD_CHANNEL * channel, FMOD_BOOL * paused);
+    attach_function :FMOD_Channel_GetPaused, [:pointer, :pointer], FMOD_RESULT
+
+    # FMOD_RESULT FMOD_Channel_SetPosition(FMOD_CHANNEL *  channel, unsigned int position, FMOD_TIMEUNIT postype);
+    attach_function :FMOD_Channel_SetPosition, [:pointer, :int, :FMOD_TIMEUNIT], FMOD_RESULT
+    
+    # FMOD_RESULT FMOD_Channel_SetPan(FMOD_CHANNEL * channel, float pan);  
+    attach_function :FMOD_Channel_SetPan, [:pointer, :float], FMOD_RESULT  
+    
+    # FMOD_RESULT FMOD_Channel_GetFrequency(FMOD_CHANNEL * channel, float * frequency);    
+    attach_function :FMOD_Channel_GetFrequency, [:pointer, :pointer], FMOD_RESULT  
+
+    # FMOD_RESULT FMOD_Channel_SetFrequency(FMOD_CHANNEL *  channel, float  frequency);    
+    attach_function :FMOD_Channel_SetFrequency, [:pointer, :float], FMOD_RESULT  
+
+    
+    def error_check(result)
+      raise "FMOD error! #{result}" if result != :FMOD_OK
+    end
+  end
+end

data/lib/fmod/pointer_helper.rb

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

data/lib/fmod/sound.rb

@@ -0,0 +1,37 @@
+module FMOD
+  class Sound
+    include Functions
+    attr_reader :channel
+    
+    def initialize(file, options = {})
+      @system_pointer  = FMOD.system.pointer
+      @channel = options[:channel] || Channel.new
+      @file = file
+    end
+    
+    def play
+      play_stream
+    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);
+
+      # 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
+    end
+    
+    def play_stream  
+      sound_ptr = 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);
+
+      # 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
+    end
+    
+  end 
+end

data/lib/fmod/system.rb

@@ -0,0 +1,53 @@
+module FMOD
+  class System
+    include Functions
+    # pointer to the system instance
+    attr_reader :pointer
+        
+    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)
+    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);
+        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
+    end
+    
+    def software_channels
+      num_ptr = FFI::MemoryPointer.new(:int)
+      error_check FMOD_System_GetSoftwareChannels(@pointer.read_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,
+      }
+    end
+  end
+end

data/lib/fmod/version.rb

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

data/scratch.rb

@@ -0,0 +1,49 @@
+require 'lib/fmod'
+
+start_time = Time.now
+puts "initializing FMOD ..."
+FMOD.init
+end_time = Time.new - start_time
+puts "done in #{end_time} seconds."
+
+file = (ARGV.empty?) ? "Kids.mp3" : ARGV[0]
+
+
+puts "initializing a sound ..."
+start_time = Time.now
+sound = FMOD::Sound.new(file)
+end_time = Time.new - start_time
+puts "done in #{end_time} seconds."
+sound.play
+puts FMOD.system.version
+puts sound.channel.frequency
+sleep 2
+# sound.channel.frequency = 11050.0
+# puts sound.channel.frequency
+# 10.times do |i|
+#   sound.channel.set_position(i + 1000)
+#   sleep 0.1
+# end
+
+# sleep 2
+
+1000.times do |i|
+  sound.channel.set_position(i * (rand*1000).to_i)
+  sleep rand
+end
+# 
+# sr   = 100  
+# step = 1.0/sr
+# time = 0.0
+# 
+# loop do
+#   time += step
+#   val = Math.cos(time * 2 * Math::PI * 440.0) * Math.cos(time * 2 * Math::PI)
+#   sound.channel.frequency = val * 20000
+#   sleep step
+# end
+
+# block
+while true
+  sleep 5
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: fmod-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ronen barzel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &70253800274800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70253800274800
+description: Wrapper for the FMOD audio library
+email:
+- ronen@barzel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- fmod-ruby.gemspec
+- lib/fmod.rb
+- lib/fmod/channel.rb
+- lib/fmod/constants.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: 
+rdoc_options: []
+require_paths:
+- lib
+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.10
+signing_key: 
+specification_version: 3
+summary: Wrapper for the FMOD audio library
+test_files: []