sound 0.0.6 → 0.0.7

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MmUyZGIzMWJmMGRmZTA5MmVlMjAwNWEyOTc3M2I4NmVkZGRkOTBkOA==
+    MjJmMzc0MDMzOTQ5ZjdjNDk4NzI0ZGMyYmM3NWE0NjdhZjA4YTI0Yw==
   data.tar.gz: !binary |-
-    NWU1Zjk0Yjk4ZGQ1OTdiOTRkY2MyZTY2NmQ3NmY0YzUyOTBmOTFhMA==
+    YjIxMDAwMTgwMDMzNTdhOTZiNzQzNTk1MTNkMDEwYjAxMGZkNmQ5OQ==
 SHA512:
   metadata.gz: !binary |-
-    ZDdkNjVjZmVhOTFiZWE3ZWRiMDIyMDljMGU5ZTFkZmJlMzYzOTcxYjVmYTRh
-    OGE0ZTcyNGNlODM5NmFiYjNkZWY5NjM5NjBkNDE4NzgyY2RlM2YyMTA5ODA0
-    NDI4YjFjNGI5YmU5MGJkNDg5Mjc4OTE0YTA3MDRmNDdjNmEyNmQ=
+    MjJlYjk0NDc5NTdiOWNlYjhjMGE2NTIxODNjZDE3YjU2OWYxMGUyOTZlMTU5
+    MTU1Y2UzNjRhNTA1MGZhNzgxYzlmOTAwZDBjMjBjMzhmMThhYmMzOTkxYzQy
+    OGNhN2U5ZTRkZTYwNGE2ZmE4OThjYmU4MWJlNzgyMDQzZDEwY2M=
   data.tar.gz: !binary |-
-    N2UxOWQxZjRlMTEwYTJlNDZhNjgwZTNlNzNlMDY1YTc4YjFmNWRhODE3NDRl
-    MDlhMTM5NjUwYzJlOWFhNzI1NjQ0YjdkZTM1NzBhY2U0OGQxNjg3OGM3MWNk
-    NzU4YzYwY2MxODBlY2E3NDY3MmIyYWJmMjIzOTBlMTZiNTdkMzA=
+    ZTJjZjJmN2EyMzcyN2RkNDdiN2VlNDNhZDMxM2E2OGRkNTgwMzQ3NDE2ZTQ0
+    NzE3MWYwNzYyMGM1NzA3YWJmOWNkY2MxYjU1ODY3NGI2NzhkNzQyODRiYzMz
+    NTRmMmY4MDM3YzE0MGYwYjE0NzI4YzE1YWQzZGI2OWQ0YmI1Nzg=

data/examples/example.rb

@@ -1,21 +1,154 @@
 require 'sound'
-Sound.verbose = true
 
+# this will alert you when various events occur
+# such as when a device is opened or closed, when
+# data is added to the queue, etc.
+Sound.verbose = true
 # Don't trust these examples.  The readme is more up to date.
 
 # Example of opening a device, writing to it, and closing it up
 
+# opens a device for writing
+device = Sound::Device.new("w")
+
+# creates a PCM format object
+format = Sound::Format.new(Sound::Format::PCM)
+
+# creates a new Sound Data object with a PCM format
+data = Sound::Data.new(format)
+
+# writes a sine wave to the data object with
+# a frequency of 440 Hz, a duration of 500 ms
+# and a volume of 1 (full volume)
+data.generate_sine_wave(880, 500, 1)
+
+# writes data to the message queue
+device.write data
+
+# flushes the message queue
+device.flush
+
+# responsibly closes the device
+device.close
+
+# with sensible defaults, you can ignore some of this
+
 device = Sound::Device.new
-data = Sound::Data.new(device.format)
+data = Sound::Data.new
 data.generate_sine_wave(440, 500, 1)
-device.write data
+device.play data
 device.close
 
-# This will close the device on its own after the block finishes
+# note the lack of specifying a format or explicitly writing the data
+# to the message queue.  the #play method writes the data to the queue
+# and flushes it automatically.
+
+# with the block form, which uses #open instead of #new, it's even more
+# cogent, since it will close the device for you
+
+Sound::Device.new {|d| d.play Sound::Data.new.sine_wave(440, 500, 1)}
+
+# Let's play a little melody!  It starts to get out of sync about halfway through
+
+threads = []
+
+threads << Thread.new do
+  Sound::Device.new do |device|
+    device.write Sound::Data.new.sine_wave(440, 1200, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(4/12.0), 600, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(7/12.0), 600, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(-1/12.0), 900, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(0/12.0), 150, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(2/12.0), 150, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(0/12.0), 1200, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(9/12.0), 1200, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(7/12.0), 600, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(12/12.0), 600, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(7/12.0), 600, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(5/12.0), 70, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(7/12.0), 70, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(5/12.0), 70, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(7/12.0), 70, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(5/12.0), 170, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(4/12.0), 150, 0.4)
+    device.write Sound::Data.new.sine_wave(440*2**(4/12.0), 1200, 0.4)
+    Thread.pass
+    Thread.pass
+  end
+end
+
+threads << Thread.new do
+  Sound::Device.new do |device|
+    device.write Sound::Data.new.sine_wave(220*2**(0/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(4/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    
+    device.write Sound::Data.new.sine_wave(220*2**(0/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(4/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    
+    device.write Sound::Data.new.sine_wave(220*2**(-1/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(5/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    
+    device.write Sound::Data.new.sine_wave(220*2**(0/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(4/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    
+    device.write Sound::Data.new.sine_wave(220*2**(0/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(9/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(5/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(9/12.0), 300, 0.4)
+    
+    device.write Sound::Data.new.sine_wave(220*2**(0/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(4/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    
+    device.write Sound::Data.new.sine_wave(220*2**(-1/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(5/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    
+    device.write Sound::Data.new.sine_wave(220*2**(0/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(4/12.0), 300, 0.4)
+    device.write Sound::Data.new.sine_wave(220*2**(7/12.0), 300, 0.4)
+    Thread.pass
+  end
+end
+
+threads.each {|t| t.join}
+#example of asynchronous playback
+
+Sound::Device.new do |device|
+  device.write_async Sound::Data.new.sine_wave(440, 300, 1)
+  device.write_async Sound::Data.new.sine_wave(660, 300, 1)
+  device.write Sound::Data.new.sine_wave(660, 300, 1)
+  device.write_async Sound::Data.new.sine_wave(440, 300, 1), true
+  device.write_async Sound::Data.new.sine_wave(880, 300, 1)
+  device.write_async Sound::Data.new.sine_wave(440, 300, 1), true
+  device.write_async Sound::Data.new.sine_wave(880*2**(4/12.0), 300, 1)
+  
+end
+
+threads = []
 
+threads << Thread.new do
+  Sound::Device.new do |device|
+    device.write Sound::Data.new.sine_wave(440, 500, 1)
+    Thread.pass
+  end
+end
+threads << Thread.new do
+  Sound::Device.new do |device|
+    device.write Sound::Data.new.sine_wave(660, 500, 1)
+    Thread.pass
+  end
+end
 
-#data = WaveData.new
-#
-#device = Device.open
-#device.write(data)
-#device.close
+threads.each {|t| t.join}

data/lib/sound.rb

@@ -3,14 +3,45 @@ require 'ffi'
 require 'pry'
 require 'os/os'
 
+module Sound
+
+  @verbose = false
+  @no_device = false
+  @platform_supported = false
+  
+  class << self
+    attr_accessor :verbose, :no_device, :platform_supported
+  end
+  
+  class NoDeviceError < RuntimeError; end
+  class NoDependencyError < RuntimeError; end
+  
+end
+
 if OS.windows?
-  require 'sound/win32/sound'
+  require 'sound/win32'
+  module Sound
+    class Device
+      include Win32
+    end
+  end
+  Sound.platform_supported = true
 elsif OS.linux?
-  require 'sound/linux/sound'
+  libasound_present = !(`which aplay`.eql? "")
+  unless libasound_present
+    warn("warning: sound output requires libasound2, libasound2-dev, and alsa-utils packages")
+  end
+  require 'sound/alsa'
+  module Sound
+    class Device
+      include ALSA
+    end
+  end
+  Sound.platform_supported = true
 else
   warn("warning: Sound output not yet implemented for this platform: #{OS.os}")
 end
 
+require 'sound/device'
 require 'sound/data'
 require 'sound/format'
-require 'sound/device'

data/lib/sound/alsa.rb

@@ -0,0 +1,211 @@
+require 'ffi'
+
+module Sound
+  module ALSA
+    
+    class Handle
+      def initialize
+        @handle = FFI::MemoryPointer.new(:pointer)
+      end
+      def pointer
+        @handle
+      end
+      def id
+        @handle.read_pointer
+      end
+    end
+
+    SND_PCM_STREAM_PLAYBACK = 0
+    SND_PCM_STREAM_CAPTURE = 1
+    DEFAULT_DEVICE_ID = "default"
+    
+    extend FFI::Library
+    ffi_lib 'asound'
+    ffi_convention :stdcall
+    
+    attach_function :snd_pcm_open, [:pointer, :string, :int, :int], :int
+    attach_function :snd_pcm_close, [:pointer], :int
+    attach_function :snd_pcm_drain, [:pointer], :int
+    attach_function :snd_pcm_prepare, [:pointer], :int
+    attach_function :write_noninterleaved, :snd_pcm_writen, [:pointer, :pointer, :ulong], :long
+    attach_function :snd_pcm_writei, [:pointer, :pointer, :ulong], :long
+    attach_function :snd_pcm_hw_params_malloc, [:pointer], :int
+    attach_function :snd_pcm_hw_params_any, [:pointer, :pointer], :int
+    attach_function :snd_pcm_hw_params_set_access, [:pointer, :pointer, :int], :int
+    attach_function :snd_pcm_hw_params_set_format, [:pointer, :pointer, :int], :int
+    attach_function :snd_pcm_hw_params_set_rate, [:pointer, :pointer, :uint, :int], :int
+    attach_function :snd_pcm_hw_params_set_channels, [:pointer, :pointer, :int], :int
+    attach_function :snd_pcm_hw_params, [:pointer, :pointer], :int
+    attach_function :snd_pcm_hw_params_free, [:pointer], :void
+    
+    def snd_pcm_open(*args)
+      output = `aplay -l 2>&1`
+      if output.match(/no soundcard/m)
+        raise NoDeviceError, "No sound devices present"
+      elsif output.match(/not found/m)
+        raise NoDependencyError, "aplay is not present in your environment. Install alsa-utils package for audio playback."
+      else
+        snd_pcm_open(*args)
+      end
+    end
+    
+    def open_device
+      begin
+        snd_pcm_open(handle.pointer, id, 0, ASYNC)
+      rescue NoDeviceError
+        Sound.no_device = true
+      end
+    end
+    
+    def prepare_buffer
+      
+      unless Sound.no_device
+        buffer_length
+        
+        snd_pcm_hw_params_malloc(params_handle.pointer)
+        snd_pcm_hw_params_any(handle.id, params_handle.id)
+        
+        snd_pcm_hw_params_set_access(handle.id, params_handle.id, SND_PCM_ACCESS_RW_INTERLEAVED)
+        set_formsnd_pcm_hw_params_set_formatat(handle.id, params_handle.id, SND_PCM_FORMAT_S16_LE)
+        # need to change this to set_rate_near at some point
+        snd_pcm_hw_params_set_rate(handle.id, params_handle.id, data.format.sample_rate, 0)
+        snd_pcm_hw_params_set_channels(handle.id, params_handle.id, 1)
+        
+        snd_pcm_hw_params(handle.id, params_handle.id)
+        snd_pcm_hw_params_free(params_handle.id)
+        
+        snd_pcm_prepare(handle.id)
+      end
+      
+    end
+    
+    def write_to_device
+      snd_pcm_writei(handle.id, data_buffer, buffer_length) unless Sound.no_device
+    end
+    
+    def unprepare_buffer
+      snd_pcm_drain(handle.id) unless Sound.no_device
+    end
+    
+    def close_device
+      snd_pcm_close(handle.id) unless Sound.no_device
+    end
+    
+    def handle
+      Thread.current[:handle] ||= Handle.new
+    end
+    
+    def params_handle
+      Thread.current[:params_handle] ||= Handle.new
+    end
+    
+    def data
+      Thread.current[:data]
+    end
+    
+    def data_buffer
+      Thread.current[:data_buffer] ||= FFI::MemoryPointer.new(:int, data.pcm_data.size).write_array_of_int data.pcm_data
+    end
+    
+    def buffer_length
+      Thread.current[:buffer_length] ||= data_buffer.size/2
+    end
+    
+    SND_PCM_ASYNC = 2
+    ASYNC = SND_PCM_ASYNC
+    #snd_pcm formats
+    # Unknown 
+    SND_PCM_FORMAT_UNKNOWN = -1
+    # Signed 8 bit 
+    SND_PCM_FORMAT_S8 = 0
+    # Unsigned 8 bit 
+    SND_PCM_FORMAT_U8 = 1
+    # Signed 16 bit Little Endian 
+    SND_PCM_FORMAT_S16_LE = 2
+    # Signed 16 bit Big Endian 
+    SND_PCM_FORMAT_S16_BE = 3
+    # Unsigned 16 bit Little Endian 
+    SND_PCM_FORMAT_U16_LE = 4
+    # Unsigned 16 bit Big Endian 
+    SND_PCM_FORMAT_U16_BE = 5
+    # Signed 24 bit Little Endian using low three bytes in 32-bit word 
+    SND_PCM_FORMAT_S24_LE = 6
+    # Signed 24 bit Big Endian using low three bytes in 32-bit word 
+    SND_PCM_FORMAT_S24_BE = 7
+    # Unsigned 24 bit Little Endian using low three bytes in 32-bit word 
+    SND_PCM_FORMAT_U24_LE = 8
+    # Unsigned 24 bit Big Endian using low three bytes in 32-bit word 
+    SND_PCM_FORMAT_U24_BE = 9
+    # Signed 32 bit Little Endian 
+    SND_PCM_FORMAT_S32_LE = 10
+    # Signed 32 bit Big Endian 
+    SND_PCM_FORMAT_S32_BE = 11
+    # Unsigned 32 bit Little Endian 
+    SND_PCM_FORMAT_U32_LE = 12
+    # Unsigned 32 bit Big Endian 
+    SND_PCM_FORMAT_U32_BE = 13
+    # Float 32 bit Little Endian, Range -1.0 to 1.0 
+    SND_PCM_FORMAT_FLOAT_LE = 14
+    # Float 32 bit Big Endian, Range -1.0 to 1.0 
+    SND_PCM_FORMAT_FLOAT_BE = 15
+    # Float 64 bit Little Endian, Range -1.0 to 1.0 
+    SND_PCM_FORMAT_FLOAT64_LE = 16
+    # Float 64 bit Big Endian, Range -1.0 to 1.0 
+    SND_PCM_FORMAT_FLOAT64_BE = 17
+    # IEC-958 Little Endian 
+    SND_PCM_FORMAT_IEC958_SUBFRAME_LE = 18
+    # IEC-958 Big Endian 
+    SND_PCM_FORMAT_IEC958_SUBFRAME_BE = 19
+    # Mu-Law 
+    SND_PCM_FORMAT_MU_LAW = 20
+    # A-Law 
+    SND_PCM_FORMAT_A_LAW = 21
+    # Ima-ADPCM 
+    SND_PCM_FORMAT_IMA_ADPCM = 22
+    # MPEG 
+    SND_PCM_FORMAT_MPEG = 23
+    # GSM 
+    SND_PCM_FORMAT_GSM = 24
+    # Special 
+    SND_PCM_FORMAT_SPECIAL = 31
+    # Signed 24bit Little Endian in 3bytes format 
+    SND_PCM_FORMAT_S24_3LE = 32
+    # Signed 24bit Big Endian in 3bytes format 
+    SND_PCM_FORMAT_S24_3BE = 33
+    # Unsigned 24bit Little Endian in 3bytes format 
+    SND_PCM_FORMAT_U24_3LE = 34
+    # Unsigned 24bit Big Endian in 3bytes format 
+    SND_PCM_FORMAT_U24_3BE = 35
+    # Signed 20bit Little Endian in 3bytes format 
+    SND_PCM_FORMAT_S20_3LE = 36
+    # Signed 20bit Big Endian in 3bytes format 
+    SND_PCM_FORMAT_S20_3BE = 37
+    # Unsigned 20bit Little Endian in 3bytes format 
+    SND_PCM_FORMAT_U20_3LE = 38
+    # Unsigned 20bit Big Endian in 3bytes format 
+    SND_PCM_FORMAT_U20_3BE = 39
+    # Signed 18bit Little Endian in 3bytes format 
+    SND_PCM_FORMAT_S18_3LE = 40
+    # Signed 18bit Big Endian in 3bytes format 
+    SND_PCM_FORMAT_S18_3BE = 41
+    # Unsigned 18bit Little Endian in 3bytes format 
+    SND_PCM_FORMAT_U18_3LE = 42
+    # Unsigned 18bit Big Endian in 3bytes format 
+    SND_PCM_FORMAT_U18_3BE = 43
+    SND_PCM_FORMAT_LAST = SND_PCM_FORMAT_U18_3BE
+    
+    #snd_pcm access
+    # mmap access with simple interleaved channels
+    SND_PCM_ACCESS_MMAP_INTERLEAVED = 0
+    # mmap access with simple non interleaved channels
+    SND_PCM_ACCESS_MMAP_NONINTERLEAVED = 1
+    # mmap access with complex placement
+    SND_PCM_ACCESS_MMAP_COMPLEX = 2
+    # snd_pcm_readi/snd_pcm_writei access
+    SND_PCM_ACCESS_RW_INTERLEAVED = 3
+    # snd_pcm_readn/snd_pcm_writen access
+    SND_PCM_ACCESS_RW_NONINTERLEAVED = 4
+    SND_PCM_ACCESS_LAST = SND_PCM_ACCESS_RW_NONINTERLEAVED
+    
+  end
+end

data/lib/sound/data.rb

@@ -2,13 +2,16 @@
 module Sound
 
   class Data
-    attr_reader :data, :duration
-    def initialize(format)
+    attr_reader :pcm_data, :duration, :format
+    def initialize(format = Format.new)
       @format = format
-      @data = []
+      @pcm_data = []
+    end
+    def to_s
+      puts "#<Sound::Data:#{object_id}>"
     end
     def generate_sine_wave(freq, duration, volume)
-      @data = []
+      @pcm_data = []
       @duration = duration
       ramp = 200.0
       samples = (@format.sample_rate/2*duration/1000.0).floor
@@ -26,11 +29,12 @@ module Sound
           x *= (samples - sample)/ramp
         end
 
-        @data << x.floor
+        @pcm_data << x.floor
       end
 
       self
     end
+    alias :sine_wave :generate_sine_wave
   end
   
 end

data/lib/sound/device.rb

@@ -1,55 +1,50 @@
 
 module Sound
-
-  @verbose = false
-  
-  class << self
-    attr_accessor :verbose
-  end
-  
-  WAVE_MAPPER = -1
   
   class Device
     
-    class Handle
-      def initialize
-        if OS.windows?
-          @handle = Win32::HWAVEOUT.new
-        elsif OS.linux?
-          @handle = FFI::MemoryPointer.new(:pointer)
-        end
-      end
-      def pointer
-        if OS.windows?
-          @handle.pointer
-        elsif OS.linux?
-          @handle
-        end
-      end
-      def id
-        if OS.windows?
-          @handle[:i]
-        elsif OS.linux?
-          @handle.read_pointer
-        end
-      end
-    end
+    class Buffer < Array; end
   
-    attr_accessor :closed, :id, :handle, :format
+    attr_reader :status, :id
     
-    def initialize(format = Format::PCM, direction = "w", id = nil)
-      if OS.windows?
-        id ||= WAVE_MAPPER
-      elsif OS.linux?
-        id ||= "default"
-      end
+    # creates a new device for writing by default.  default id is set by
+    # whatever device interface was included (Win32 or ALSA, e.g.)
+    # if a block is passed, it executes the code in the block, passing
+    # the newly created device, and then closes the device.
+    #
+    def initialize(direction = "w", id = DEFAULT_DEVICE_ID, &block)
+      
       @id = id
-      closed = false
-      @queue = []
+      @status = :open
+      @queue = Device::Buffer.new
       @mutex = Mutex.new
-      @handle = Device::Handle.new
-      @format = format
       @direction = direction
+      
+      puts "opening device: '#{id}'" if Sound.verbose
+      
+      if block_given?
+        block.call(self)
+        close
+      end
+      
+    end
+    
+    # checks if the current status of the device is :open
+    #
+    def open?
+      status == :open
+    end
+    
+    # checks if the current status of the device is :closed
+    #
+    def closed?
+      status == :closed
+    end
+    
+    # returns the current queue.  should be used for debugging only.
+    #
+    def queue
+      @queue.dup.freeze
     end
   
     class << self
@@ -58,114 +53,132 @@ module Sound
       # direction is reading or writing or both
       # format is MIDI vs PCM or others
       # this method can take a block and if so closes the device after execution
-      def open(device = Device::DEFAULT, direction = "w", format = Format::PCM, &block)
-        device.format = format
-        puts "opening device_#{device.id}" if Sound.verbose
+      #
+      def open(device = Device.new, direction = "w", &block)
+        puts "opening device: '#{device.id}'" if Sound.verbose
         if block_given?
           block.call(device)
           device.close
         else
-          device.closed = false
+          device.open
           device
         end
       end
     end
     
-    def play(data = "beep boop")
+    # opens the device.
+    #
+    def open
+      @status = :open
+      self
+    end
+    
+    # writes data to the queue and immediately flushes the queue.
+    #
+    def play(data = Sound::Data.new)
       write(data)
       flush
     end
-  
-    def write(data = "beep boop")
+    
+    # writes given Data to the queue as a data block thread.  Threads pause
+    # after preperation, and during flushing they get started back up. If a
+    # thread isn't done preparing when flushed, it finished preparing and
+    # immediately writes data to the device.
+    #
+    def write(data = Sound::Data.new)
       if closed?
         puts "cannot write to a closed device"
       else
         @mutex.lock
         @queue << Thread.new do
-          write_thread(data)
+          Thread.current[:async] = false
+          Thread.current[:data] = data
+          write_thread
         end
         @mutex.unlock
-        puts "writing to device_#{id}_queue: #{data.class}" if Sound.verbose
+        puts "writing to queue of device '#{id}': #{data}" if Sound.verbose
       end
+      self
     end
     
+    # starts up data block threads that get played back at the same time.  Need
+    # to make all threads wait until others are finished preparing the buffer.
+    #
+    def write_async(data = Sound::Data.new, new_queue_elem = false)
+      if closed?
+        puts "cannot write to a closed device"
+      else
+        @mutex.lock
+        if new_queue_elem || @queue.empty? || @queue.last.kind_of?(Thread)
+          threads = []
+          threads << Thread.new do
+            Thread.current[:async] = true
+            Thread.current[:data] = data
+            write_thread
+          end
+          @queue << threads
+        else
+          @queue.last << Thread.new do
+            Thread.current[:async] = true
+            Thread.current[:data] = data
+            write_thread
+          end
+        end
+        @mutex.unlock
+        puts "writing async to queue of device '#{id}': #{data}" if Sound.verbose
+      end
+    end
+    
+    # should make a close! method that ignores any pending queue data blocks,
+    # but still safely closes the device as quickly as possible.
+    #
     def close
       if closed?
         puts "cannot close a closed device"
       else
         flush
-        puts "device is closing now" if Sound.verbose
-        closed = true
+        puts "device '#{id}' is closing now" if Sound.verbose
+        @status = :closed
       end
     end
     
+    # flushes each block after previous finishes.  Should make other options,
+    # like flush each block after a specified amount of time.
+    #
     def flush
       until @queue.empty?
         output = @queue.shift
-        output[:stop] = false
-        puts "writing to device_#{id}: #{output}" if Sound.verbose
-        output.run.join
+        if output.kind_of? Thread
+          output[:stop] = false
+          puts "writing to device '#{id}': #{output[:data].class}" if Sound.verbose #this may be NilClass if parent thread is too fast
+          output.run.join
+        else
+          output.each do |thread|
+            thread[:stop] = false
+            puts "writing to device '#{id}': #{thread[:data].class}" if Sound.verbose
+            thread.run
+          end
+          output.last.join if output.last.alive?
+        end
       end
     end
     
-    def closed?
-      closed
-    end
+    private
     
-    def write_thread(data)
+    def write_thread
       Thread.current[:stop] = true if Thread.current[:stop].nil?
-      if OS.windows?
-        windows_write_thread(data)
-      elsif OS.linux?
-        linux_write_thread(data)
+      if Sound.platform_supported
+        open_device
+        prepare_buffer
+        Thread.stop if Thread.current[:stop]
+        Thread.pass if Thread.current[:async]
+        write_to_device
+        unprepare_buffer
+        close_device
       else
         warn("warning: playback is not yet supported on this platform")
       end
     end
-    
-    def windows_write_thread(data)
-      handle = Handle.new
-      Win32::Sound.waveOutOpen(handle.pointer, id, format.pointer, 0, 0, 0)
-      data_buffer = FFI::MemoryPointer.new(:int, data.data.size)
-      data_buffer.write_array_of_int data.data
-      buffer_length = format.avg_bps*data.duration/1000
-      header = Win32::WAVEHDR.new(data_buffer, buffer_length)
-      Win32::Sound.waveOutPrepareHeader(handle.id, header.pointer, header.size)
-      Thread.stop if Thread.current[:stop]
-      Win32::Sound.waveOutWrite(handle.id, header.pointer, header.size)
-      while Win32::Sound.waveOutUnprepareHeader(handle.id, header.pointer, header.size) == 33
-        sleep 0.001
-      end
-      Win32::Sound.waveOutClose(handle.id)
-    end
-    
-    def linux_write_thread(data)
-      handle = Handle.new
-      AlsaPCM::Sound.snd_pcm_open(handle.pointer, id, 0, 0)
-      data_buffer = FFI::MemoryPointer.new(:int, data.data.size)
-      data_buffer.write_array_of_int data.data
-      buffer_length = data_buffer.size/2
-      params = FFI::MemoryPointer.new(:pointer)
-      AlsaPCM::Sound.snd_pcm_hw_params_malloc(params)
-      AlsaPCM::Sound.snd_pcm_hw_params_any(handle.id, params.read_pointer)
-      
-      AlsaPCM::Sound.snd_pcm_hw_params_set_access(handle.id, params.read_pointer, 3)
-      AlsaPCM::Sound.snd_pcm_hw_params_set_format(handle.id, params.read_pointer, 2)
-      AlsaPCM::Sound.snd_pcm_hw_params_set_rate(handle.id, params.read_pointer, 44100, 0)
-      AlsaPCM::Sound.snd_pcm_hw_params_set_channels(handle.id, params.read_pointer, 1)
-      
-      AlsaPCM::Sound.snd_pcm_hw_params(handle.id, params.read_pointer)
-      AlsaPCM::Sound.snd_pcm_hw_params_free(params.read_pointer)
-      
-      AlsaPCM::Sound.snd_pcm_prepare(handle.id)
-      Thread.stop if Thread.current[:stop]
-      AlsaPCM::Sound.snd_pcm_writei(handle.id, data_buffer, buffer_length)
-      
-      
-      AlsaPCM::Sound.snd_pcm_drain(handle.id)
-      AlsaPCM::Sound.snd_pcm_close(handle.id)
-      
-    end
   end
 
 end

data/lib/sound/format.rb

@@ -5,8 +5,10 @@ module Sound
   WAVE_FORMAT_PCM = 1
   
   class Format
-    attr_accessor :channels, :sample_rate, :bps
-    def initialize(format_type = WAVE_FORMAT_PCM)
+  
+    PCM = WAVE_FORMAT_PCM
+    attr_accessor :channels, :sample_rate, :bps, :alsa_format
+    def initialize(format_type = PCM)
       @channels = 1
       @sample_rate = 44100
       @bps = 16
@@ -32,7 +34,6 @@ module Sound
         @wfx.pointer
       end
     end
-    PCM = self.new
   end
   
 end

data/lib/sound/{win32/sound.rb → win32.rb}

@@ -1,24 +1,79 @@
+require 'ffi'
 
 module Sound
   module Win32
+    
+    class Handle
+      def initialize
+        @handle = HWAVEOUT.new
+      end
+      def pointer
+        @handle.pointer
+      end
+      def id
+        @handle[:i]
+      end
+    end
 
-    class Sound
-      extend FFI::Library
+    extend FFI::Library
 
-      typedef :ulong, :dword
-      typedef :uintptr_t, :hwaveout
-      typedef :uint, :mmresult
-      
-      ffi_lib :winmm
+    typedef :ulong, :dword
+    typedef :uintptr_t, :hwaveout
+    typedef :uint, :mmresult
     
-      attach_function :waveOutOpen, [:pointer, :uint, :pointer, :dword, :dword, :dword], :mmresult
-      attach_function :waveOutPrepareHeader, [:hwaveout, :pointer, :uint], :mmresult
-      attach_function :waveOutWrite, [:hwaveout, :pointer, :uint], :mmresult
-      attach_function :waveOutUnprepareHeader, [:hwaveout, :pointer, :uint], :mmresult
-      attach_function :waveOutClose, [:hwaveout], :mmresult
-    end
+    ffi_lib :winmm
+  
+    attach_function :waveOutOpen, [:pointer, :uint, :pointer, :dword, :dword, :dword], :mmresult
+    attach_function :waveOutPrepareHeader, [:hwaveout, :pointer, :uint], :mmresult
+    attach_function :waveOutWrite, [:hwaveout, :pointer, :uint], :mmresult
+    attach_function :waveOutUnprepareHeader, [:hwaveout, :pointer, :uint], :mmresult
+    attach_function :waveOutClose, [:hwaveout], :mmresult
     
     WAVE_FORMAT_PCM = 1
+    WAVE_MAPPER = -1
+    DEFAULT_DEVICE_ID = WAVE_MAPPER
+    
+    def open_device
+      waveOutOpen(handle.pointer, id, data.format.pointer, 0, 0, 0)
+    end
+    
+    def prepare_buffer
+      waveOutPrepareHeader(handle.id, header.pointer, header.size)
+    end
+    
+    def write_to_device
+      waveOutWrite(handle.id, header.pointer, header.size)
+    end
+    
+    def unprepare_buffer
+      while waveOutUnprepareHeader(handle.id, header.pointer, header.size) == 33
+        sleep 0.001
+      end
+    end
+    
+    def close_device
+      waveOutClose(handle.id)
+    end
+    
+    def handle
+      Thread.current[:handle] ||= Handle.new
+    end
+    
+    def data
+      Thread.current[:data]
+    end
+    
+    def header
+      Thread.current[:header] ||= WAVEHDR.new(data_buffer, buffer_length)
+    end
+    
+    def data_buffer
+      Thread.current[:data_buffer] ||= FFI::MemoryPointer.new(:int, data.pcm_data.size).write_array_of_int data.pcm_data
+    end
+    
+    def buffer_length
+      Thread.current[:buffer_length] ||= data.format.avg_bps*data.duration/1000
+    end
     
     # Define an HWAVEOUT struct for use by all the waveOut functions.
     # It is a handle to a waveOut stream, so starting up multiple

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: sound
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Dominic Muller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-10 00:00:00.000000000 Z
-dependencies: []
+date: 2014-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Allows for effiecent cross-platform sound libraries in pure Ruby by tapping
   into native libraries.
 email: nicklink483@gmail.com
@@ -20,11 +48,11 @@ files:
 - examples/example.rb
 - lib/os/os.rb
 - lib/sound.rb
+- lib/sound/alsa.rb
 - lib/sound/data.rb
 - lib/sound/device.rb
 - lib/sound/format.rb
-- lib/sound/linux/sound.rb
-- lib/sound/win32/sound.rb
+- lib/sound/win32.rb
 homepage: https://github.com/RSMP/sound
 licenses:
 - MIT

data/lib/sound/linux/sound.rb

@@ -1,25 +0,0 @@
-require 'ffi'
-
-module AlsaPCM
-  class Sound
-    extend FFI::Library
-    ffi_lib 'asound'
-    ffi_convention :stdcall
-    
-    attach_function :snd_pcm_open, [:pointer, :string, :int, :int], :int
-    attach_function :snd_pcm_close, [:pointer], :int
-    attach_function :snd_pcm_drain, [:pointer], :int
-    attach_function :snd_pcm_prepare, [:pointer], :int
-    attach_function :snd_pcm_writen, [:pointer, :pointer, :ulong], :long
-    attach_function :snd_pcm_writei, [:pointer, :pointer, :ulong], :long
-    attach_function :snd_pcm_hw_params_malloc, [:pointer], :int
-    attach_function :snd_pcm_hw_params_any, [:pointer, :pointer], :int
-    attach_function :snd_pcm_hw_params_set_access, [:pointer, :pointer, :int], :int
-    attach_function :snd_pcm_hw_params_set_format, [:pointer, :pointer, :int], :int
-    attach_function :snd_pcm_hw_params_set_rate, [:pointer, :pointer, :uint, :int], :int
-    attach_function :snd_pcm_hw_params_set_channels, [:pointer, :pointer, :int], :int
-    attach_function :snd_pcm_hw_params, [:pointer, :pointer], :int
-    attach_function :snd_pcm_hw_params_free, [:pointer], :void
-    
-  end
-end