sound 0.0.9 → 0.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzdkMGRkZDM3ODkxZTM4NDNkY2FhMjU3M2JiYTE2Y2MwM2M2Y2MzOQ==
+    YjA0NGNiZGY0MzRkN2IzMjMyY2JhZDhhMzM0OWI2ZDFiN2QzN2EyMQ==
   data.tar.gz: !binary |-
-    NmUxZmE3NGMyZjQ1ZTExZjhmMmMyMTNhYmYyMTQ3ZDJmY2I3NjlmZg==
+    MmRkM2IyYjY4NTlhZjRkNDZiODc4ODhiN2RiN2ZiY2I1YjIxNDVmNw==
 SHA512:
   metadata.gz: !binary |-
-    N2MyNDZkYzE4Y2U4YjU4ZTBiN2YwOTRmNjk5OTFmMTMxMmZmNjI3NzljMTBk
-    YmIxNmU1NzU0MDgxNzQ5NGQwZTQxNTQ4NjE0ODE4MmY4MDFjMzgyMjVlYWVl
-    NjgyZjY3ZDQzZGQxYTZkZGUwYThiZmEwMWIzNTZlNzkxNmZjZTM=
+    Y2ExM2QwNDg5NjI2MjM1NmE2MzE0YTVmODdjMGFiMjNiZjM4ZDRiMzRlNTA4
+    ZTQwNjBmZTE1OGJiZmExZWQyNjA1Nzc1ZDk1YzM2NzViNWQ0NzM1NDdkMWMz
+    M2ExNDM3ODlhZjAyZWMwY2JiZmE1ZWFmYWZmZWFkYTAxNzQ2ODM=
   data.tar.gz: !binary |-
-    ODJlYzA5MzQyYjljYzZjODY5OGM2NGUzMTBlODNjZTE0NDZmOWZmNzEwNDU0
-    MWM3OWU3MDI3YzU3NzA3ODc2NzMwODJlMTE1NGExYWMyMGU3M2M5MmM4ZmU0
-    NTFhMzEyNTM4ZGE3YTdkODVmNzkxOTgyYzY0NjU5ZDEwMzBmYmU=
+    Njk3N2I3NjY1Y2Q4ODk4ODYxMzU3NjA2ODIwZWI2ZmJhMWUwM2ZlMTA4Zjgz
+    NjdhNjQzZjA0OWY1YjdkZjc4ODk4YTEwM2RkZTM4N2ZlOWJmOTk1ZmZhOWNl
+    ZTA4NjllZGQ3ZmE0YTI2MTE2OTJhMjZjNWZmMTU2MTA3Yjg5MWY=

data/examples/example.rb

@@ -12,7 +12,7 @@ Sound.verbose = true
 device = Sound::Device.new("w")
 
 # creates a PCM format object
-format = Sound::Format.new(Sound::Format::PCM)
+format = Sound::Format.new#(Sound::Format::PCM)
 
 # creates a new Sound Data object with a PCM format
 data = Sound::Data.new(format)

data/lib/os/os.rb

@@ -1,5 +1,9 @@
 module OS
 
+  class << self
+    attr_accessor :os
+  end
+
   def OS.windows?
     os == :windows
   end
@@ -17,21 +21,22 @@ module OS
   end
   
   def OS.os
-    @os ||= (
-      host_os = RbConfig::CONFIG['host_os']
-      case host_os
-      when /mswin|msys|mingw|cygwin|bccwin|wince|emc|emx/
-        :windows
-      when /darwin|mac os/
-        :mac
-      when /linux/
-        :linux
-      when /solaris|bsd/
-        :unix
-      else
-        raise Error::WebDriverError, "unknown os: #{host_os.inspect}"
-      end
-    )
+    @os ||= OS.host_os
+  end
+  
+  def OS.host_os
+    case RbConfig::CONFIG['host_os']
+    when /mswin|msys|mingw|cygwin|bccwin|wince|emc|emx/
+      :windows
+    when /darwin|mac os/
+      :mac
+    when /linux/
+      :linux
+    when /solaris|bsd/
+      :unix
+    else
+      raise Error::WebDriverError, "unknown os: #{RbConfig::CONFIG['host_os'].inspect}"
+    end
   end
 
 end

data/lib/sound.rb

@@ -1,5 +1,3 @@
-
-require 'ffi'
 require 'pry'
 require 'os/os'
 
@@ -7,10 +5,10 @@ module Sound
 
   @verbose = false
   @no_device = false
-  @platform_supported = false
+  @platform_supported = true
   
   class << self
-    attr_accessor :verbose, :no_device, :platform_supported
+    attr_accessor :verbose, :no_device, :platform_supported, :device_library, :format_library
   end
   
   class NoDeviceError < RuntimeError; end
@@ -19,29 +17,29 @@ module Sound
 end
 
 if OS.windows?
-  require 'sound/win32'
-  module Sound
-    class Device
-      include Win32
-    end
-  end
-  Sound.platform_supported = true
+  require 'sound/device_library/mmlib'
+  require 'sound/format_library/mmlib'
+  Sound.device_library = Sound::DeviceLibrary::MMLib
+  Sound.format_library = Sound::FormatLibrary::MMLib
 elsif OS.linux?
   libasound_present = !(`which aplay`.eql? "")
-  unless libasound_present
+  if libasound_present
+    require 'sound/device_library/alsa'
+    require 'sound/format_library/alsa'
+    Sound.device_library = Sound::DeviceLibrary::ALSA
+    Sound.format_library = Sound::FormatLibrary::ALSA
+  else
     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
+  Sound.device_library = Sound::DeviceLibrary::Base
+  Sound.format_library = Sound::FormatLibrary::Base
   warn("warning: Sound output not yet implemented for this platform: #{OS.os}")
+  Sound.platform_supported = false
 end
 
+require 'sound/device_library'
+require 'sound/format_library'
 require 'sound/device'
 require 'sound/data'
 require 'sound/format'

data/lib/sound/data.rb

@@ -7,9 +7,6 @@ module Sound
       @format = format
       @pcm_data = []
     end
-    def to_s
-      puts "#<Sound::Data:#{object_id}>"
-    end
     def generate_sine_wave(freq, duration, volume)
       @pcm_data = []
       @duration = duration

data/lib/sound/device.rb

@@ -2,8 +2,14 @@
 module Sound
   
   class Device
+    include DeviceLibrary
     
-    class Buffer < Array; end
+    class Buffer < Array
+      attr_accessor :force
+      def new_block
+        self.force || self.empty? || self.last.kind_of?(Thread)
+      end
+    end
   
     attr_reader :status, :id
     
@@ -12,7 +18,7 @@ module Sound
     # 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)
+    def initialize(direction = "w", id = DeviceLibrary::DEFAULT_DEVICE_ID, &block)
       
       @id = id
       @status = :open
@@ -87,7 +93,7 @@ module Sound
     #
     def write(data = Sound::Data.new)
       if closed?
-        puts "cannot write to a closed device"
+        warn("warning: cannot write to a closed device")
       else
         @mutex.lock
         @queue << Thread.new do
@@ -104,42 +110,49 @@ module Sound
     # 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)
+    def write_async(data = Sound::Data.new, force_new = false)
       if closed?
-        puts "cannot write to a closed device"
+        warn("warning: 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
+        @queue.force = force_new
+        if @queue.new_block
+          @queue << [new_async_thread_for(data)]
         else
-          @queue.last << Thread.new do
-            Thread.current[:async] = true
-            Thread.current[:data] = data
-            write_thread
-          end
+          @queue.last << new_async_thread_for(data)
         end
         @mutex.unlock
         puts "writing async to queue of device '#{id}': #{data}" if Sound.verbose
       end
+      self
     end
     
-    # should make a close! method that ignores any pending queue data blocks,
-    # but still safely closes the device as quickly as possible.
+    # flushes any pending queue data blocks, waits for them to finish playing,
+    # and then closes the device.
     #
     def close
       if closed?
-        puts "cannot close a closed device"
+        warn("warning: device is already closed")
       else
         flush
         puts "device '#{id}' is closing now" if Sound.verbose
         @status = :closed
       end
+      self
+    end
+    
+    # closes the device as quickly as possible without flushing the
+    # data buffer.
+    #
+    def close!
+      if closed?
+        warn("warning: device is already closed")
+      else
+        flush!
+        puts "device '#{id}' is closing immediately now" if Sound.verbose
+        @status = :closed
+      end
+      self
     end
     
     # flushes each block after previous finishes.  Should make other options,
@@ -149,36 +162,62 @@ module Sound
       until @queue.empty?
         output = @queue.shift
         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
+          finish_up(output).join
         else
           output.each do |thread|
-            thread[:stop] = false
-            puts "writing to device '#{id}': #{thread[:data].class}" if Sound.verbose
-            thread.run
+            finish_up(thread)
           end
           output.last.join if output.last.alive?
         end
       end
     end
     
+    # works like #flush, but empties the buffer without playing any sounds and
+    # closes the physical device as quickly as possible for its platform.
+    #
+    def flush!
+      @queue = Device::Buffer.new
+      self
+    end
+    
     private
     
     def write_thread
       Thread.current[:stop] = true if Thread.current[:stop].nil?
       if Sound.platform_supported
-        open_device
-        prepare_buffer
-        Thread.stop if Thread.current[:stop]
-        Thread.pass if Thread.current[:async]
+        set_up
         write_to_device
-        unprepare_buffer
-        close_device
+        tear_down
       else
         warn("warning: playback is not yet supported on this platform")
       end
     end
+    
+    def set_up
+      open_device(self)
+      prepare_buffer
+      Thread.stop if Thread.current[:stop]
+      Thread.pass if Thread.current[:async]
+    end
+    
+    def tear_down
+      unprepare_buffer
+      close_device
+    end
+    
+    def new_async_thread_for(data)
+      Thread.new do
+        Thread.current[:async] = true
+        Thread.current[:data] = data
+        write_thread
+      end
+    end
+    
+    def finish_up(thread)
+      thread[:stop] = false
+      puts "writing to device '#{id}': #{thread[:data].class}" if Sound.verbose #this may be NilClass if parent thread is too fast
+      thread.run
+    end
   end
 
 end

data/lib/sound/device_library.rb

@@ -0,0 +1,19 @@
+require 'forwardable'
+
+module Sound
+  module DeviceLibrary
+    extend Forwardable
+    DEFAULT_DEVICE_ID = Sound.device_library::DEFAULT_DEVICE_ID
+    duties = [
+      :open_device,
+      :prepare_buffer,
+      :write_to_device,
+      :unprepare_buffer,
+      :close_device
+    ]
+    duties.each do |duty|
+      delegate duty => Sound.device_library
+      private duty
+    end
+  end
+end

data/lib/sound/device_library/alsa.rb

@@ -0,0 +1,240 @@
+require 'ffi'
+
+module Sound
+  module DeviceLibrary
+    module ALSA
+      extend self
+      
+      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 self.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(device)
+        begin
+          self.snd_pcm_open(handle.pointer, device.id, 0, ASYNC)
+        rescue NoDeviceError
+          Sound.no_device = true
+        end
+      end
+      
+      def prepare_buffer
+        
+        unless Sound.no_device
+          buffer_length
+          set_params
+          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 params_handle
+        Thread.current[:params_handle] ||= Handle.new
+      end
+      
+      def buffer_length
+        Thread.current[:buffer_length] ||= data_buffer.size/2
+      end
+      
+      def handle
+        Thread.current[:handle] ||= Handle.new
+      end
+      
+      def data
+        Thread.current[:data] ||= Sound::Data.new
+      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 set_params
+        allocate_param_memory
+        alter_allocated_param_memory
+        free_param_memory
+      end
+      
+      def allocate_param_memory
+        snd_pcm_hw_params_malloc(params_handle.pointer)
+      end
+      
+      def free_param_memory
+        snd_pcm_hw_params_free(params_handle.id)
+      end
+      
+      def alter_allocated_param_memory
+        set_up_to_change_any_params
+        modify_desired_params
+        set_params_on_hw_buffer
+      end
+      
+      def set_up_to_change_any_params
+        snd_pcm_hw_params_any(handle.id, params_handle.id)
+      end
+      
+      def modify_desired_params
+        # I think these can happen in any order
+        snd_pcm_hw_params_set_access(handle.id, params_handle.id, SND_PCM_ACCESS_RW_INTERLEAVED)
+        snd_pcm_hw_params_set_format(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, data.format.channels)
+      end
+      
+      def set_params_on_hw_buffer
+        snd_pcm_hw_params(handle.id, params_handle.id)
+      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
+end