albanpeignier-alsa-backup 0.0.1

data/.autotest

@@ -0,0 +1,3 @@
+Autotest.add_hook :initialize do |autotest|
+  autotest.add_exception(/tmp/)
+end

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-05-14
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,26 @@
+.autotest
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+alsa-backup.gemspec
+bin/alsa.backup
+config.sample
+lib/alsa.rb
+lib/alsa_backup.rb
+lib/alsa_backup/cli.rb
+lib/alsa_backup/recorder.rb
+lib/sndfile.rb
+script/console
+script/destroy
+script/generate
+spec/alsa/pcm_spec.rb
+spec/alsa_backup/cli_spec.rb
+spec/alsa_backup/recorder_spec.rb
+spec/alsa_backup_spec.rb
+spec/fixtures/config_test.rb
+spec/sndfile/info_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on alsa_backup, see http://alsa_backup.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,72 @@
+= AlsaBackup
+
+* http://github.com/alban.peignier/alsa-backup
+
+== DESCRIPTION:
+
+ALSA client to perform continuous recording
+
+== FEATURES/PROBLEMS:
+
+* configurable file name strategy
+
+== SYNOPSIS:
+
+By using the default settings :
+
+  alsa.backup 
+
+will record in record.wav the default alsa device
+
+By using command line arguments :
+
+  alsa.backup --directoy=/tmp --file=test.wav --length=2
+
+will record 2 seconds in /tmp/test.wav
+
+By loading a configuration :
+
+  alsa.backup --config=/path/to/config
+
+will load the specified configuration
+
+== CONFIGURATION:
+
+See config.sample for the moment.
+
+== REQUIREMENTS:
+
+* alsa library (http://www.alsa-project.org/)
+* libsndfile library (http://www.mega-nerd.com/libsndfile/)
+
+== INSTALL:
+
+* sudo apt-get install libasound2 libsndfile1
+* sudo gem install ruby-ffi
+
+* sudo gem install --source http://gems.github.com albanpeignier-alsa-backup
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME Alban Peignier 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+%w[rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/alsa_backup'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('alsa-backup', AlsaBackup::VERSION) do |p|
+  p.developer('Alban Peignier', 'alban.peignier@free.fr')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name # TODO this is default value
+  p.extra_deps         = [
+    ['ffi','>= 0.3.5'],
+  ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default => :spec

data/alsa-backup.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{alsa-backup}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alban Peignier"]
+  s.date = %q{2009-05-18}
+  s.default_executable = %q{alsa.backup}
+  s.description = %q{ALSA client to perform continuous recording}
+  s.email = ["alban.peignier@free.fr"]
+  s.executables = ["alsa.backup"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc"]
+  s.files = [".autotest", "History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "alsa-backup.gemspec", "bin/alsa.backup", "config.sample", "lib/alsa.rb", "lib/alsa_backup.rb", "lib/alsa_backup/cli.rb", "lib/alsa_backup/recorder.rb", "lib/sndfile.rb", "script/console", "script/destroy", "script/generate", "spec/alsa/pcm_spec.rb", "spec/alsa_backup/cli_spec.rb", "spec/alsa_backup/recorder_spec.rb", "spec/alsa_backup_spec.rb", "spec/fixtures/config_test.rb", "spec/sndfile/info_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/rspec.rake"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/alban.peignier/alsa-backup}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{alsa-backup}
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{ALSA client to perform continuous recording}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ffi>, [">= 0.3.5"])
+      s.add_development_dependency(%q<newgem>, [">= 1.4.1"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<ffi>, [">= 0.3.5"])
+      s.add_dependency(%q<newgem>, [">= 1.4.1"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<ffi>, [">= 0.3.5"])
+    s.add_dependency(%q<newgem>, [">= 1.4.1"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/bin/alsa.backup

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2009-5-14.
+#  Copyright (c) 2009. All rights reserved.
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/alsa_backup")
+
+require 'alsa_backup'
+require 'alsa_backup/cli'
+
+AlsaBackup::CLI.execute(STDOUT, *ARGV)

data/config.sample

@@ -0,0 +1,43 @@
+#
+# Config sample for Alsa.Backup
+#
+# Usage: 
+#   alsa-backup --config /path/to/this/file
+#
+
+#
+# To use syslog
+#
+#require 'syslog_logger'
+#AlsaBackup.logger = SyslogLogger.new('alsa.backup').tap do |logger|
+#  logger.level = Logger::INFO
+#end
+
+AlsaBackup.logger.info("load config #{__FILE__}")
+
+AlsaBackup.config do |recorder|
+  #
+  # To use files named like this :
+  # - 2009/05-May/17-Sun/19h.wav
+  # - 2009/05-May/17-Sun/20h.wav
+  #
+  #recorder.file = Proc.new {
+  #  Time.now.strftime("%Y/%m-%b/%d-%a/%Hh.wav")
+  #}
+
+  #
+  # To use files named like this :
+  # - 2009/05-May/17-Sun/19h00.wav
+  # - 2009/05-May/17-Sun/19h15.wav
+  #
+  #recorder.file = Proc.new {
+  #  Time.now.floor(:min, 15).strftime("%Y/%m-%b/%d-%a/%Hh%M.wav")
+  #}
+
+  #
+  # Define where the files are created
+  #
+  #recorder.directory = "/var/lib/alsa.backup"
+end
+
+

data/lib/alsa.rb

@@ -0,0 +1,278 @@
+require 'rubygems'
+require 'ffi'
+
+require 'logger'
+
+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
+
+  def self.try_to(message, &block)
+    logger.debug('alsa') { message }
+    if (response = yield) < 0
+      raise "cannot #{message} (#{ALSA::Native::strerror(response)})"
+    else
+      response
+    end
+  end
+
+  module Native
+    extend FFI::Library
+    ffi_lib "libasound.so"
+
+    attach_function :strerror, :snd_strerror, [:int], :string
+  end
+
+  module PCM
+
+    class Capture
+
+      attr_accessor :handle
+
+      def self.open(device, hardware_attributes = {}, &block)
+        Capture.new.open(device, hardware_attributes, &block)
+      end
+
+      def open(device, hardware_attributes = {}, &block)
+        capture_handle = FFI::MemoryPointer.new :pointer
+        ALSA::try_to "open audio device #{device}" do
+          ALSA::PCM::Native::open capture_handle, device, ALSA::PCM::Native::STREAM_CAPTURE, ALSA::PCM::Native::BLOCK
+        end
+        self.handle = capture_handle.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 = 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
+        HwParameters.new(self).current_for_device
+      end
+
+      def hardware_parameters=(attributes= {})
+        attributes = {:access => :rw_interleaved}.update(attributes)
+        change_hardware_parameters do |hw_params|
+          hw_params.update_attributes(attributes)
+        end
+      end
+
+      def read
+        frame_count = hardware_parameters.sample_rate
+        buffer = FFI::MemoryPointer.new(hardware_parameters.buffer_size_for(frame_count))
+
+        continue = true
+        while continue
+          read_count = ALSA::try_to "read from audio interface" do
+            ALSA::PCM::Native::readi(self.handle, buffer, frame_count)
+          end
+
+          raise "can't read expected frame count (#{read_count}/#{frame_count})" unless read_count == frame_count
+          
+          continue = yield buffer, read_count
+        end
+
+        buffer.free
+      end
+
+      def close
+        ALSA::try_to "close audio device" do
+          ALSA::PCM::Native::close self.handle
+        end
+      end
+
+      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 free
+          ALSA::try_to "unallocate hw_params" do
+            ALSA::PCM::Native::hw_params_free self.handle
+          end
+        end
+
+      end
+
+    end
+
+    module Native
+      extend FFI::Library
+      ffi_lib "libasound.so"
+
+      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 :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
+    end
+  end
+end

data/lib/alsa_backup.rb

@@ -0,0 +1,48 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'activesupport'
+require 'logger'
+
+module AlsaBackup
+  VERSION = '0.0.1'
+
+  def self.recorder
+    @recorder ||= AlsaBackup::Recorder.new
+  end
+
+  def self.config
+    yield self.recorder
+  end
+
+  def self.logger
+    unless @logger
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+    end
+
+    @logger
+  end
+
+  def self.logger=(logger); @logger = logger; end
+
+end
+
+class Time
+
+  def floor(attribute, modulo)
+    actual = self.send(attribute)
+    self.change(attribute => actual - actual%modulo)
+  end
+
+end
+
+require 'alsa_backup/recorder'
+
+
+

data/lib/alsa_backup/cli.rb

@@ -0,0 +1,44 @@
+require 'optparse'
+
+module AlsaBackup
+  class CLI
+    def self.execute(stdout, *arguments)
+      options = {}
+      mandatory_options = %w()
+
+      OptionParser.new do |opts|
+        opts.banner = <<-BANNER.gsub(/^          /,'')
+          Alsa.Backup : continuous recording with alsa
+
+          Usage: #{File.basename($0)} [options]
+
+          Options are:
+        BANNER
+        opts.separator ""
+        opts.on("-f", "--file=FILE", String,
+                "Recording file") { |arg| options[:file] = arg }
+        opts.on("-l", "--length=LENGTH", String,
+                "Length in seconds") { |arg| options[:length] = arg }
+        opts.on("-d", "--directory=DIRECTORY", String,
+                "Base directory") { |arg| options[:directory] = arg }
+        opts.on("-c", "--config=CONFIG", String,
+                "Configuration file") { |arg| options[:config] = arg }
+        opts.on("-h", "--help",
+                "Show this help message.") { stdout.puts opts; exit }
+        opts.parse!(arguments)
+
+        if mandatory_options && mandatory_options.find { |option| options[option.to_sym].nil? }
+          stdout.puts opts; exit
+        end
+      end
+
+      load File.expand_path(options[:config]) if options[:config]
+
+      AlsaBackup.recorder.file = options[:file] if options[:file]
+      AlsaBackup.recorder.directory = options[:directory] if options[:directory]
+      
+      length = options[:length].to_i if options[:length]
+      AlsaBackup.recorder.start(length)
+    end
+  end
+end

data/lib/alsa_backup/recorder.rb

@@ -0,0 +1,71 @@
+require 'alsa'
+require 'sndfile'
+
+require 'fileutils'
+
+module AlsaBackup
+  class Recorder
+
+    def initialize(file = "record.wav")
+      @file = file
+      @directory = "."
+    end
+
+    attr_accessor :file, :directory
+
+    def start(seconds_to_record = nil)
+      frames_to_record = format[:sample_rate] * seconds_to_record if seconds_to_record
+
+      # prepare sndfile
+      self.sndfile
+
+      ALSA::PCM::Capture.open("hw:0", self.format(:sample_format => :s16_le)) do |capture|
+        capture.read do |buffer, frame_count|
+          self.sndfile.write buffer, frame_count
+          if frames_to_record
+            (frames_to_record -= frame_count) > 0
+          else
+            true
+          end
+        end
+      end
+    rescue Exception => e
+      AlsaBackup.logger.error(e)
+      raise e
+    ensure
+      @sndfile.close if @sndfile
+    end
+
+    def file
+      case @file
+      when Proc
+        @file.call
+      else
+        @file
+      end
+    end
+
+    def target_file
+      File.join self.directory, self.file
+    end
+
+    def format(additional_parameters = {})
+      {:sample_rate => 44100, :channels => 2}.merge(additional_parameters)
+    end
+
+    def sndfile
+      target_file = self.target_file
+      raise "no recording file" unless target_file
+
+      unless @sndfile and @sndfile.path == target_file
+        @sndfile.close if @sndfile
+        AlsaBackup.logger.info "new file #{target_file}"
+
+        FileUtils.mkdir_p File.dirname(target_file)
+        @sndfile = Sndfile::File.new(target_file, "w", self.format(:format => "wav pcm_16"))
+      end
+      @sndfile
+    end
+    
+  end
+end

data/lib/sndfile.rb

@@ -0,0 +1,121 @@
+require 'rubygems'
+require 'ffi'
+
+module Sndfile
+
+  class File
+
+    attr_reader :path
+
+    def self.open(path, mode, info)
+      file = self.new(path, mode, info)
+
+      begin
+        yield file
+      ensure
+        file.close
+      end
+    end
+
+    def initialize(path, mode, info)
+      info = (Hash === info ? Info.new(info) : info)
+      @handle = Sndfile::Native::open path, File.native_mode(mode), info.to_native
+      if @handle.is_a?(FFI::NullPointer)
+        raise "Not able to open output file " + self.error
+      end
+      @path = path
+    end
+
+    def write(buffer, frame_count)
+      unless Sndfile::Native::write_int(@handle, buffer, frame_count) == frame_count
+        raise self.error
+      end
+    end
+
+    def close
+      Sndfile::Native::close @handle
+    end
+
+    def error
+      Sndfile::Native::strerror @handle
+    end
+
+    def self.native_mode(mode)
+      case mode 
+      when "w": Sndfile::Native::MODE_WRITE
+      else
+        raise "Unknown mode: #{mode}"
+      end
+    end
+
+  end
+
+  class Info
+
+    attr_accessor :sample_rate, :channels, :format
+
+    def initialize(attributes = {})
+      update_attributes(attributes)
+    end
+
+    def update_attributes(attributes)
+      attributes.each_pair { |name, value| send("#{name}=", value) }
+    end
+
+    def to_native
+      Sndfile::Native::Info.new.tap do |native|
+        native[:samplerate] = self.sample_rate
+        native[:channels] = self.channels
+        native[:format] = self.native_format
+      end
+    end
+
+    def format=(format)
+      @format = Info.normalized_format(format)
+    end
+
+    def native_format
+      self.format.inject(0) do |native_format, format_part|
+        native_format | Sndfile::Native::Format.const_get(format_part.upcase)
+      end
+    end
+
+    def self.normalized_format(format)
+      Array(format).join(' ').downcase.scan(/[a-z0-9_]+/)      
+    end
+
+  end
+
+  module Native
+    extend FFI::Library
+    ffi_lib "libsndfile.so"
+
+    module Format
+      WAV = 0x010000
+      PCM_16 = 0x0002
+      PCM_24 = 0x0003
+    end
+
+    MODE_READ = 0x10
+    MODE_WRITE = 0x20
+    MODE_RDWR = 0x30
+
+    class Info < FFI::Struct
+      layout(
+             :frames, :int64,
+             :samplerate, :int,
+             :channels, :int,
+             :format, :int,
+             :sections, :int,
+             :seekable, :int
+             )
+    end
+
+    attach_function :open, :sf_open, [ :string, :int, :pointer ], :pointer
+    attach_function :close, :sf_close, [ :pointer ], :int
+
+    attach_function :write_int, :sf_write_int, [ :pointer, :pointer, :int ], :int
+
+    attach_function :strerror, :sf_strerror, [ :pointer ], :string
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/alsa_backup.rb'}"
+puts "Loading alsa_backup gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/alsa/pcm_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'alsa'
+
+describe ALSA::PCM do
+  
+end

data/spec/alsa_backup/cli_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'alsa_backup/cli'
+
+describe AlsaBackup::CLI, "execute" do
+  before(:each) do
+    @stdout_io = StringIO.new
+    @file = test_file
+
+    @recorder = AlsaBackup::Recorder.new(@file)
+    @recorder.stub!(:start)
+    AlsaBackup.stub!(:recorder).and_return(@recorder)
+  end
+
+  def execute_cli(options = {})
+    options = { :file => @file, :length => 2 }.update(options)
+    arguments = options.collect do |key,value| 
+      "--#{key}=#{value}" if value
+    end.compact
+    
+    AlsaBackup::CLI.execute(@stdout_io, *arguments)
+    @stdout_io.rewind
+    @stdout = @stdout_io.read
+  end
+  
+  it "should use AlsaBackup.recorder" do
+    AlsaBackup.should_receive(:recorder).and_return(@recorder)
+    execute_cli
+  end
+
+  it "should set the record file with specified one" do
+    @recorder.should_receive(:file=).with(file = "dummy")
+    execute_cli :file => file
+  end
+
+  it "should start the AlsaBackup.recorder" do
+    @recorder.should_receive(:start)
+    execute_cli
+  end
+
+  it "should start the recorder with specified length" do
+    @recorder.should_receive(:start).with(length = 60)
+    execute_cli :length => length
+  end
+
+  it "should start the record without length if not specified" do
+    @recorder.should_receive(:start).with(nil)
+    execute_cli :length => nil
+  end
+
+  it "should execute specified config file" do
+    execute_cli :config => fixture_file('config_test.rb'), :file => nil
+    AlsaBackup.recorder.file.should == "config_test_ok"
+  end
+
+  it "should override config file values with command line arguments" do
+    argument_file = "dummy"
+    execute_cli :config => fixture_file('config_test.rb'), :file => argument_file
+    AlsaBackup.recorder.file.should == argument_file
+  end
+
+end

data/spec/alsa_backup/recorder_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'alsa_backup/recorder'
+
+describe AlsaBackup::Recorder do
+
+  before(:each) do
+    @file = test_file
+    @recorder = AlsaBackup::Recorder.new(@file)
+  end
+
+  it "should not raise an error on start" do
+    lambda { @recorder.start(2) }.should_not raise_error
+  end
+
+  describe "file" do
+    
+    it "should accept file as string" do
+      @recorder.file = file_name = "dummy"
+      @recorder.file.should == file_name
+    end
+
+    it "should accept file as Proc" do
+      file_name = "dummy"
+      @recorder.file = Proc.new { file_name }
+      @recorder.file.should == file_name
+    end
+    
+  end
+
+end

data/spec/alsa_backup_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "Place your specs here" do
+  
+  it "find this spec in spec directory" do
+    # violated "Be sure to write your specs"
+  end
+  
+end

data/spec/fixtures/config_test.rb

@@ -0,0 +1,3 @@
+AlsaBackup.config do |recorder|
+    recorder.file = "config_test_ok"
+end

data/spec/sndfile/info_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'sndfile'
+
+describe Sndfile::Info do
+
+  before(:each) do
+    @info = Sndfile::Info.new
+  end
+  
+  describe "normalized_format" do
+    
+    it "should transform 'wav pcm_16' into [wav, pcm_16]" do
+      Sndfile::Info.normalized_format('wav pcm_16').should == %w{wav pcm_16}
+    end
+
+  end
+
+  describe "format" do
+    
+    it "should be normalized when set" do
+      @info.format = 'wav pcm_16'
+      @info.format.should == %w{wav pcm_16}
+    end
+
+  end
+
+  describe "native_format" do
+    
+    it "should return (Format::WAV|Format::PCM_16) for 'wav pcm_16'" do
+      @info.format = 'wav pcm_16'
+      @info.native_format.should == Sndfile::Native::Format::WAV | Sndfile::Native::Format::PCM_16
+    end
+
+  end
+
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'alsa_backup'
+
+def test_file(name = 'test.wav')
+  File.dirname(__FILE__) + '/../tmp/' + name
+end
+
+def fixture_file(name)
+  File.dirname(__FILE__) + '/fixtures/' + name
+end
+
+ALSA::logger = AlsaBackup.logger = 
+  Logger.new(File.dirname(__FILE__) + '/../log/test.log') 

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: albanpeignier-alsa-backup
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alban Peignier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-18 00:00:00 -07:00
+default_executable: alsa.backup
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: ALSA client to perform continuous recording
+email: 
+- alban.peignier@free.fr
+executables: 
+- alsa.backup
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- alsa-backup.gemspec
+- bin/alsa.backup
+- config.sample
+- lib/alsa.rb
+- lib/alsa_backup.rb
+- lib/alsa_backup/cli.rb
+- lib/alsa_backup/recorder.rb
+- lib/sndfile.rb
+- script/console
+- script/destroy
+- script/generate
+- spec/alsa/pcm_spec.rb
+- spec/alsa_backup/cli_spec.rb
+- spec/alsa_backup/recorder_spec.rb
+- spec/alsa_backup_spec.rb
+- spec/fixtures/config_test.rb
+- spec/sndfile/info_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: true
+homepage: http://github.com/alban.peignier/alsa-backup
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: alsa-backup
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: ALSA client to perform continuous recording
+test_files: []
+