ruby-alsa 0.0.3 → 0.0.4

data/COPYRIGHT

@@ -0,0 +1,14 @@
+Copyright © 2010 Alban Peignier, Florent Peyraud
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General public License for more details.
+
+You should have received a copy of the GNU General public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Manifest.txt

@@ -1,13 +1,37 @@
+.autotest
+COPYING
+COPYRIGHT
 Gemfile
 History.txt
 Manifest.txt
 README.rdoc
 Rakefile
 lib/alsa.rb
+lib/alsa/logger.rb
+lib/alsa/native.rb
+lib/alsa/pcm/capture.rb
+lib/alsa/pcm/hw_parameters.rb
+lib/alsa/pcm/native.rb
+lib/alsa/pcm/playback.rb
+lib/alsa/pcm/stream.rb
+log/test.log
+ruby-alsa.gemspec
 script/console
 script/destroy
 script/generate
+script/play
+script/record
+spec.html
+spec/alsa/logger_spec.rb
+spec/alsa/native_spec.rb
+spec/alsa/pcm/capture_spec.rb
+spec/alsa/pcm/native_spec.rb
+spec/alsa/pcm/playback_spec.rb
+spec/alsa/pcm/stream_spec.rb
 spec/alsa/pcm_spec.rb
+spec/alsa_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
+spec/support/logger.rb
+tasks/buildbot.rake
 tasks/rspec.rake

data/Rakefile

@@ -4,6 +4,12 @@ require 'hoe'
 require 'fileutils'
 require 'lib/alsa.rb'
 
+rubyforge_user_config = File.expand_path("~/.rubyforge/user-config.yml")
+unless File.exists?(rubyforge_user_config)
+  mkdir_p File.dirname(rubyforge_user_config)
+  touch rubyforge_user_config
+end
+
 Hoe.plugin :newgem
 # Hoe.plugin :website
 # Hoe.plugin :cucumberfeatures

data/lib/alsa.rb

@@ -2,11 +2,10 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'ffi'
-require 'ffi_ext'
 
 module ALSA
 
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 
 end
 
@@ -15,7 +14,9 @@ require 'alsa/logger'
 require 'alsa/native'
 require 'alsa/pcm/native'
 require 'alsa/pcm/hw_parameters'
+require 'alsa/pcm/stream'
 require 'alsa/pcm/capture'
+require 'alsa/pcm/playback'
 
 module ALSA
 

data/lib/alsa/logger.rb

@@ -0,0 +1,12 @@
+module ALSA
+  def self.logger
+    unless @logger
+      @logger = Logger.new(STDERR)
+      @logger.level = Logger::WARN
+    end
+
+    @logger
+  end
+
+  def self.logger=(logger); @logger = logger; end
+end

data/lib/alsa/native.rb

@@ -0,0 +1,12 @@
+module ALSA
+  module Native
+    extend FFI::Library
+    ffi_lib "libasound.so.2"
+
+    attach_function :strerror, :snd_strerror, [:int], :string
+
+    def self.error_code?(response)
+      response and response < 0
+    end
+  end
+end

data/lib/alsa/pcm/capture.rb

@@ -0,0 +1,46 @@
+module ALSA::PCM
+  class Capture < Stream
+
+    def native_constant
+      ALSA::PCM::Native::STREAM_CAPTURE
+    end
+
+    def read
+      check_handle!
+
+      ALSA.logger.debug { "start read with #{hw_params.sample_rate}, #{hw_params.channels} channels"}
+
+      # use an 500ms buffer
+      frame_count = hw_params.sample_rate / 2
+      ALSA.logger.debug { "allocate #{hw_params.buffer_size_for(frame_count)} bytes for #{frame_count} frames" }
+      FFI::MemoryPointer.new(:char, hw_params.buffer_size_for(frame_count)) do |buffer|
+        begin
+          read_buffer buffer, frame_count
+        end while yield buffer, frame_count
+      end
+    end
+
+    def read_buffer(buffer, frame_count)
+      check_handle!
+
+      read_count = ALSA::try_to "read from audio interface" do
+        response = ALSA::PCM::Native::readi(self.handle, buffer, frame_count)
+        if ALSA::Native::error_code?(response)
+          ALSA.logger.warn { "try to recover '#{ALSA::Native::strerror(response)}' on read"}
+          ALSA::PCM::Native::pcm_recover(self.handle, response, 1)
+        else
+          response
+        end
+      end
+
+      missing_frame_count = frame_count - read_count
+      if missing_frame_count > 0
+        ALSA.logger.debug { "re-read missing frame count: #{missing_frame_count}"}
+        read_buffer_size = hw_params.buffer_size_for(read_count)
+        # buffer[read_buffer_size] doesn't return a MemoryPointer
+        read_buffer(buffer + read_buffer_size, missing_frame_count)
+      end
+    end
+
+  end
+end

data/lib/alsa/pcm/hw_parameters.rb

@@ -0,0 +1,124 @@
+module ALSA::PCM
+  class HwParameters
+
+    attr_accessor :handle, :device
+
+    def initialize(device = nil)
+      hw_params_pointer = FFI::MemoryPointer.new :pointer
+
+      ALSA::PCM::Native::hw_params_malloc hw_params_pointer        
+      self.handle = hw_params_pointer.read_pointer
+
+      self.device = device if device
+    end
+
+    def update_attributes(attributes)
+      attributes.each_pair { |name, value| send("#{name}=", value) }
+    end
+
+    def default_for_device
+      ALSA::try_to "initialize hardware parameter structure" do
+        ALSA::PCM::Native::hw_params_any device.handle, self.handle
+      end
+      self
+    end
+
+    def current_for_device
+      ALSA::try_to "retrieve current hardware parameters" do
+        ALSA::PCM::Native::hw_params_current device.handle, self.handle
+      end
+      self
+    end
+
+    def access=(access)
+      ALSA::try_to "set access type" do
+        ALSA::PCM::Native::hw_params_set_access self.device.handle, self.handle, ALSA::PCM::Native::Access.const_get(access.to_s.upcase)
+      end
+    end
+
+    def channels=(channels)
+      ALSA::try_to "set channel count : #{channels}" do
+        ALSA::PCM::Native::hw_params_set_channels self.device.handle, self.handle, channels
+      end
+    end
+
+    def sample_rate=(sample_rate)
+      ALSA::try_to "set sample rate" do
+        rate = FFI::MemoryPointer.new(:int)
+        rate.write_int(sample_rate)
+
+        dir = FFI::MemoryPointer.new(:int)
+        dir.write_int(0)
+
+        error_code = ALSA::PCM::Native::hw_params_set_rate_near self.device.handle, self.handle, rate, dir
+
+        rate.free
+        dir.free
+
+        error_code
+      end
+    end
+
+    def sample_rate
+      rate = nil
+      ALSA::try_to "get sample rate" do
+        rate_pointer = FFI::MemoryPointer.new(:int)
+        dir_pointer = FFI::MemoryPointer.new(:int)
+        dir_pointer.write_int(0)
+
+        error_code = ALSA::PCM::Native::hw_params_get_rate self.handle, rate_pointer, dir_pointer
+
+        rate = rate_pointer.read_int
+
+        rate_pointer.free
+        dir_pointer.free
+
+        error_code
+      end
+      rate
+    end
+
+    def sample_format=(sample_format)
+      ALSA::try_to "set sample format" do
+        ALSA::PCM::Native::hw_params_set_format self.device.handle, self.handle, ALSA::PCM::Native::Format.const_get(sample_format.to_s.upcase)
+      end
+    end
+
+    def sample_format
+      format = nil
+      FFI::MemoryPointer.new(:int) do |format_pointer|
+        ALSA::try_to "get sample format" do
+          ALSA::PCM::Native::hw_params_get_format self.handle, format_pointer
+        end
+        format = format_pointer.read_int
+      end
+      format
+    end
+
+    def channels
+      channels = nil
+      FFI::MemoryPointer.new(:int) do |channels_pointer|
+        ALSA::try_to "get channels" do
+          ALSA::PCM::Native::hw_params_get_channels self.handle, channels_pointer
+        end
+        channels = channels_pointer.read_int
+      end
+      channels
+    end
+
+    def buffer_size_for(frame_count)
+      ALSA::PCM::Native::format_size(self.sample_format, frame_count) * self.channels
+    end
+
+    def frame_count_for(byte_count)
+      ALSA::PCM::Native::bytes_to_frames(self.device.handle, byte_count)
+    end
+
+    def free
+      ALSA::try_to "unallocate hw_params" do
+        ALSA::PCM::Native::hw_params_free self.handle
+      end
+    end
+
+  end
+end

data/lib/alsa/pcm/native.rb

@@ -0,0 +1,52 @@
+module ALSA::PCM
+
+  module Native
+    extend FFI::Library
+    ffi_lib "libasound.so.2"
+
+    STREAM_PLAYBACK = 0
+    STREAM_CAPTURE = 1
+
+    BLOCK = 0
+    attach_function :open, :snd_pcm_open, [:pointer, :string, :int, :int], :int
+    attach_function :prepare, :snd_pcm_prepare, [ :pointer ], :int
+    attach_function :close, :snd_pcm_close, [:pointer], :int
+
+    attach_function :readi, :snd_pcm_readi, [ :pointer, :pointer, :ulong ], :long
+    attach_function :writei, :snd_pcm_writei, [ :pointer, :pointer, :ulong ], :long
+
+    attach_function :pcm_recover, :snd_pcm_recover, [ :pointer, :int, :int ], :int
+
+    attach_function :hw_params_malloc, :snd_pcm_hw_params_malloc, [:pointer], :int
+    attach_function :hw_params_free, :snd_pcm_hw_params_free, [:pointer], :int
+
+    attach_function :hw_params, :snd_pcm_hw_params, [ :pointer, :pointer ], :int
+    attach_function :hw_params_any, :snd_pcm_hw_params_any, [:pointer, :pointer], :int
+    attach_function :hw_params_current, :snd_pcm_hw_params_current, [ :pointer, :pointer ], :int
+
+    module Access
+      MMAP_INTERLEAVED = 0
+      MMAP_NONINTERLEAVED = 1
+      MMAP_COMPLEX = 2
+      RW_INTERLEAVED = 3
+      RW_NONINTERLEAVED = 4
+    end
+
+    attach_function :hw_params_set_access, :snd_pcm_hw_params_set_access, [ :pointer, :pointer, :int ], :int
+
+    module Format
+      S16_LE = 2
+    end
+    
+    attach_function :hw_params_set_format, :snd_pcm_hw_params_set_format, [ :pointer, :pointer, :int ], :int
+    attach_function :hw_params_get_format, :snd_pcm_hw_params_get_format, [ :pointer, :pointer ], :int
+    attach_function :hw_params_get_rate, :snd_pcm_hw_params_get_rate, [ :pointer, :pointer, :pointer ], :int
+    attach_function :hw_params_set_rate_near, :snd_pcm_hw_params_set_rate_near, [ :pointer, :pointer, :pointer, :pointer ], :int
+    attach_function :hw_params_set_channels, :snd_pcm_hw_params_set_channels, [ :pointer, :pointer, :uint ], :int
+    attach_function :hw_params_get_channels, :snd_pcm_hw_params_get_format, [ :pointer, :pointer ], :int
+    attach_function :hw_params_set_periods, :snd_pcm_hw_params_set_periods, [ :pointer, :pointer, :uint, :int ], :int
+
+    attach_function :format_size, :snd_pcm_format_size, [ :int, :uint ], :int
+    attach_function :bytes_to_frames, :snd_pcm_bytes_to_frames, [ :pointer, :int ], :int
+  end
+end

data/lib/alsa/pcm/playback.rb

@@ -0,0 +1,48 @@
+module ALSA::PCM
+  class Playback < Stream
+
+    def native_constant
+      ALSA::PCM::Native::STREAM_PLAYBACK
+    end
+
+    def write_buffer(buffer, frame_count)
+      check_handle!
+      
+      write_count = ALSA::try_to "write in audio interface" do
+        response = ALSA::PCM::Native::writei(self.handle, buffer, frame_count)
+        if ALSA::Native::error_code?(response)
+          ALSA.logger.warn { "try to recover '#{ALSA::Native::strerror(response)}' on read"}
+          ALSA::PCM::Native::pcm_recover(self.handle, response, 1)
+        else
+          response
+        end
+      end
+
+      missing_frame_count = frame_count - write_count
+      if missing_frame_count > 0
+        ALSA.logger.debug { "missing wroted frame count: #{missing_frame_count}"}
+      end
+    end
+
+    def write
+      check_handle!
+
+      frame_count = hw_params.sample_rate / 2
+      FFI::MemoryPointer.new(:char, hw_params.buffer_size_for(frame_count)) do |buffer|
+        while audio_content = yield(buffer.size)
+          buffer.write_string audio_content
+
+          read_frame_count = 
+            if audio_content.size == buffer.size 
+              frame_count 
+            else
+              hw_params.frame_count_for(audio_content.size)
+            end
+
+          write_buffer buffer, read_frame_count
+        end
+      end
+    end
+
+  end
+end

data/lib/alsa/pcm/stream.rb

@@ -0,0 +1,76 @@
+module ALSA::PCM
+  class Stream
+
+    attr_accessor :handle
+
+    def self.open(device = "default", hardware_attributes = {}, &block)
+      new.open(device, hardware_attributes, &block)
+    end
+
+    def open(device = "default", hardware_attributes = {}, &block)
+      handle_pointer = FFI::MemoryPointer.new :pointer
+      ALSA::try_to "open audio device #{device}" do
+        ALSA::PCM::Native::open handle_pointer, device, native_constant, ALSA::PCM::Native::BLOCK
+      end
+      self.handle = handle_pointer.read_pointer
+
+      self.hardware_parameters = hardware_attributes
+
+      if block_given?
+        begin
+          yield self 
+        ensure
+          self.close
+        end
+      end
+    end
+
+    def change_hardware_parameters
+      hw_params = ALSA::PCM::HwParameters.new(self).default_for_device
+
+      begin
+        yield hw_params
+
+        ALSA::try_to "set hw parameters" do
+          ALSA::PCM::Native::hw_params self.handle, hw_params.handle
+        end
+      ensure
+        hw_params.free
+      end
+    end
+
+    def hardware_parameters
+      ALSA::PCM::HwParameters.new(self).current_for_device
+    end
+    alias_method :hw_params, :hardware_parameters
+
+    def hardware_parameters=(attributes= {})
+      attributes = { 
+        :access => :rw_interleaved, 
+        :channels => 2, 
+        :sample_format => :s16_le, 
+        :sample_rate => 44100 
+      }.update(attributes)
+
+      change_hardware_parameters do |hw_params|
+        hw_params.update_attributes(attributes)
+      end
+    end
+
+    def opened?
+      not self.handle.nil?
+    end
+
+    def check_handle!
+      raise "Stream isn't opened" unless opened?
+    end
+
+    def close
+      ALSA::try_to "close audio device" do
+        ALSA::PCM::Native::close self.handle
+        self.handle = nil
+      end
+    end
+
+  end
+end