sound 0.0.4 → 0.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YWI0OThmZTUxYjUyYmJkZDBiNzM4N2MwNDE3ZWQzODdkMTRmNjgwNg==
+    ZDQzMDA4MjZkZWY3ODQ1YTVmOWJkYzFkOWYxZGUyMWQxMTViZDY5MQ==
   data.tar.gz: !binary |-
-    MjM5NjE3OTM3YTc3MzNjNTQ2ODcwYmFjNWU2YWM5ZmFlOGJlNjM0Zg==
+    ZDU0NDk4ZTBmNjQ5ZmIxOGUyNDI4N2NmOWE5MGMzNWU2ZDQwYTZiOQ==
 SHA512:
   metadata.gz: !binary |-
-    ZGE1MjU2MjQ4YmJmMzgxMGFkMDg1YThjZGNkZGE3ODE3YmUwNmYzYjA2YmY2
-    ZjZlNGFhMmVlMGYwMmJlMGUxYTIyYmMzYjM2NjNhYTM3NWQwNTdkMGE0ZGYz
-    ZGQxYzliNGZhODM3OTlmOGE1NDE4YzMwNTczZmQwMTczZTVjM2I=
+    YTk5MWFlNmRmZGIwYmM5MzBkNmU2NGYyYjViYjY2NWY1YTc1ZjdiOTU1Y2U3
+    MjdmMmMzMGQ1NDhkZjczMjFhMzM2ZTc2YjNjOWU1OTJiODc1YmQ5ODI5MDJh
+    MzBhOTAxYzU1MWQwNzdiYmNkNGY2YTJmNjM2NGU2Mjg5NjdlNmQ=
   data.tar.gz: !binary |-
-    NWU3YjE1YjI1OTQyNWExZjZiMjQyM2MyNDg4YmI1YTI2ZDYwMjc0ZTk0ODMx
-    MmY0OTAxMzgxNDJlNWI2NDk0Yzk5MjJiYjk4MDg2MTZjZDUwM2JmMjcxZTdk
-    MzJjYTM1ZDI0ZjljZDFlYWMxZDMzMzJhM2NhMjU3YzE0YTk0MGE=
+    NmZmMzIxNmQ1NDIyOWYyZDk2MzEwNmNiMzAxOWU2MGMwNWE2ZGRkYWJmZDBl
+    OWI4NTM1MDQxNmU0ZDM2OTRiMzQ4MWI0Yzc3NGMwMjQ0MWZhNDg0NTZlOGY3
+    NmI5ZjMzZTJhZTE3Y2EwMGZmZDA3NDkyZGQ3ZTg3ZTYwYjdjN2M=

data/examples/example.rb

@@ -0,0 +1,21 @@
+require 'sound'
+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
+
+device = Sound::Device.new
+data = Sound::Data.new(device.format)
+data.generate_sine_wave(440, 500, 1)
+device.write data
+device.close
+
+# This will close the device on its own after the block finishes
+
+
+#data = WaveData.new
+#
+#device = Device.open
+#device.write(data)
+#device.close

data/lib/sound.rb

@@ -1,10 +1,16 @@
-require_relative 'os/os'
+
+require 'ffi'
+require 'pry'
+require 'os/os'
 
 if OS.windows?
-  require 'win32/sound'
+  require 'sound/win32/sound'
+elsif OS.linux?
+  require 'sound/linux/sound'
 else
-  warn("Sound output not yet implemented for this platform: #{OS.os}")
+  warn("warning: Sound output not yet implemented for this platform: #{OS.os}")
 end
 
-require_relative 'sound/sound'
-require_relative 'sound/out'
+require 'sound/data'
+require 'sound/format'
+require 'sound/device'

data/lib/sound/data.rb

@@ -0,0 +1,36 @@
+
+module Sound
+
+  class Data
+    attr_reader :data, :duration
+    def initialize(format)
+      @format = format
+      @data = []
+    end
+    def generate_sine_wave(freq, duration, volume)
+      @data = []
+      @duration = duration
+      ramp = 200.0
+      samples = (@format.sample_rate/2*duration/1000.0).floor
+
+      samples.times do |sample|
+
+        angle = (2.0*Math::PI*freq) * sample/samples * duration/1000
+        factor = Math.sin(angle)
+        x = 32768.0*factor*volume
+
+        if sample < ramp
+          x *= sample/ramp
+        end
+        if samples - sample < ramp
+          x *= (samples - sample)/ramp
+        end
+
+        @data << x.floor
+      end
+
+      self
+    end
+  end
+  
+end

data/lib/sound/device.rb

@@ -0,0 +1,172 @@
+
+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
+  
+    attr_accessor :closed, :id, :handle, :format
+    
+    def initialize(format = Format::PCM, direction = "w", id = nil)
+      if OS.windows?
+        id ||= WAVE_MAPPER
+      elsif OS.linux?
+        id ||= "default"
+      end
+      @id = id
+      closed = false
+      @queue = []
+      @mutex = Mutex.new
+      @handle = Device::Handle.new
+      @format = format
+      @direction = direction
+    end
+  
+    class << self
+      # Opens a sound device for reading or writing
+      # device is one of several devices, usually defined by a constant
+      # 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
+        if block_given?
+          block.call(device)
+          device.close
+        else
+          device.closed = false
+          device
+        end
+      end
+    end
+    
+    def play(data = "beep boop")
+      write(data)
+      flush
+    end
+  
+    def write(data = "beep boop")
+      if closed?
+        puts "cannot write to a closed device"
+      else
+        @mutex.lock
+        @queue << Thread.new do
+          write_thread(data)
+        end
+        @mutex.unlock
+        puts "writing to device_#{id}_queue: #{data.class}" if Sound.verbose
+      end
+    end
+    
+    def close
+      if closed?
+        puts "cannot close a closed device"
+      else
+        flush
+        puts "device is closing now" if Sound.verbose
+        closed = true
+      end
+    end
+    
+    def flush
+      until @queue.empty?
+        output = @queue.shift
+        output[:stop] = false
+        puts "writing to device_#{id}: #{output}" if Sound.verbose
+        output.run.join
+      end
+    end
+    
+    def closed?
+      closed
+    end
+    
+    def write_thread(data)
+      Thread.current[:stop] = true if Thread.current[:stop].nil?
+      if OS.windows?
+        windows_write_thread(data)
+      elsif OS.linux?
+        linux_write_thread(data)
+      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
+      puts buffer_length
+      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

@@ -0,0 +1,38 @@
+
+
+module Sound
+
+  WAVE_FORMAT_PCM = 1
+  
+  class Format
+    attr_accessor :channels, :sample_rate, :bps
+    def initialize(format_type = WAVE_FORMAT_PCM)
+      @channels = 1
+      @sample_rate = 44100
+      @bps = 16
+      if OS.windows?
+        @wfx = Win32::WAVEFORMATEX.new
+        @wfx[:wFormatTag] = format_type
+        @wfx[:nChannels] = channels
+        @wfx[:nSamplesPerSec] = sample_rate
+        @wfx[:wBitsPerSample] = bps
+        @wfx[:cbSize] = 0
+        @wfx[:nBlockAlign] = block_align
+        @wfx[:nAvgBytesPerSec] = avg_bps
+      end
+    end
+    def block_align
+      (bps >> 3) * channels
+    end
+    def avg_bps
+      block_align * sample_rate
+    end
+    def pointer
+      if OS.windows?
+        @wfx.pointer
+      end
+    end
+    PCM = self.new
+  end
+  
+end

data/lib/sound/linux/sound.rb

@@ -0,0 +1,25 @@
+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

data/lib/sound/win32/sound.rb

@@ -0,0 +1,95 @@
+
+module Sound
+  module Win32
+
+    class Sound
+      extend FFI::Library
+
+      typedef :ulong, :dword
+      typedef :uintptr_t, :hwaveout
+      typedef :uint, :mmresult
+      
+      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
+    end
+    
+    WAVE_FORMAT_PCM = 1
+    
+    # Define an HWAVEOUT struct for use by all the waveOut functions.
+    # It is a handle to a waveOut stream, so starting up multiple
+    # streams using different handles allows for simultaneous playback.
+    # You never need to actually look at the struct, C takes care of
+    # its value.
+    #
+    class HWAVEOUT < FFI::Struct
+      layout :i, :int
+    end
+
+    # Define WAVEFORMATEX which defines the format (PCM in this case)
+    # and various properties like sampling rate, number of channels, etc.
+    #
+    class WAVEFORMATEX < FFI::Struct
+  
+      # Initializes struct with sensible defaults for most commonly used
+      # values.  While setting these manually is possible, please be
+      # sure you know what changes will result in, as an incorrectly
+      # set struct will result in unpredictable behavior.
+      #
+      def initialize(nSamplesPerSec = 44100, wBitsPerSample = 16, nChannels = 1, cbSize = 0)
+        self[:wFormatTag] = WAVE_FORMAT_PCM
+        self[:nChannels] = nChannels
+        self[:nSamplesPerSec] = nSamplesPerSec
+        self[:wBitsPerSample] = wBitsPerSample
+        self[:cbSize] = cbSize
+        self[:nBlockAlign] = (self[:wBitsPerSample] >> 3) * self[:nChannels]
+        self[:nAvgBytesPerSec] = self[:nBlockAlign] * self[:nSamplesPerSec]
+      end
+    
+      layout(
+        :wFormatTag,      :ushort,
+        :nChannels,       :ushort,
+        :nSamplesPerSec,  :ulong,
+        :nAvgBytesPerSec, :ulong,
+        :nBlockAlign,     :ushort,
+        :wBitsPerSample,  :ushort,
+        :cbSize,          :ushort
+      )
+    end
+
+    #define WAVEHDR which is a header to a block of audio
+    #lpData is a pointer to the block of native memory that,
+    # in this case, is an integer array of PCM data
+
+    class WAVEHDR < FFI::Struct
+    
+      # Initializes struct with sensible defaults for most commonly used
+      # values.  While setting these manually is possible, please be
+      # sure you know what changes will result in, as an incorrectly
+      # set struct will result in unpredictable behavior.
+      #
+      def initialize(lpData, dwBufferLength, dwFlags = 0, dwLoops = 1)
+        self[:lpData] = lpData
+        self[:dwBufferLength] = dwBufferLength
+        self[:dwFlags] = dwFlags
+        self[:dwLoops] = dwLoops
+      end
+      
+      layout(
+        :lpData,          :pointer,
+        :dwBufferLength,  :ulong,
+        :dwBytesRecorded, :ulong,
+        :dwUser,          :ulong,
+        :dwFlags,         :ulong,
+        :dwLoops,         :ulong,
+        :lpNext,          :pointer,
+        :reserved,        :ulong
+      )
+    end
+    
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sound
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Dominic Muller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-03 00:00:00.000000000 Z
+date: 2014-08-10 00:00:00.000000000 Z
 dependencies: []
 description: Allows for effiecent cross-platform sound libraries in pure Ruby by tapping
   into native libraries.
@@ -17,10 +17,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- examples/example.rb
 - lib/os/os.rb
 - lib/sound.rb
-- lib/sound/out.rb
-- lib/sound/sound.rb
+- lib/sound/data.rb
+- lib/sound/device.rb
+- lib/sound/format.rb
+- lib/sound/linux/sound.rb
+- lib/sound/win32/sound.rb
 homepage: https://github.com/RSMP/sound
 licenses:
 - MIT
@@ -39,8 +43,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-requirements:
-- win32-sound, '>= 0.6.0' on Windows
+requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
 signing_key: 

data/lib/sound/out.rb

@@ -1,17 +0,0 @@
-
-module Sound
-
-  module Out
-  
-    def self.play_freq(frequency = 440, duration = 1000, volume = 1, immediate_playback = true)
-      if OS.windows?
-        Win32::Sound.play_freq(frequency, duration, volume, immediate_playback)
-      else
-        warn("play_freq not implemented for this platform: #{RUBY_PLATFORM}")
-      end
-    
-    end
-    
-  end
-  
-end

data/lib/sound/sound.rb

@@ -1,4 +0,0 @@
-
-module Sound
-
-end