alsa-backup 0.0.8

data/lib/alsa_backup.rb

@@ -0,0 +1,37 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'active_support'
+require 'logger'
+
+module AlsaBackup
+  VERSION = '0.0.8'
+
+  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
+
+require 'alsa_backup/core_ext'
+require 'alsa_backup/length_controller'
+require 'alsa_backup/writer'
+require 'alsa_backup/recorder'
+
+
+

data/lib/alsa_backup/cli.rb

@@ -0,0 +1,56 @@
+require 'optparse'
+require 'daemons'
+
+module AlsaBackup
+  class CLI
+    def self.execute(stdout, *arguments)
+      options = {}
+      mandatory_options = %w()
+
+      OptionParser.new do |opts|
+        opts.banner = <<-BANNER.gsub(/^          /,'')
+          AlsaBackup : 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("-p", "--pid=PID_FILE", String,
+                "File to write the process pid") { |arg| options[:pid] = arg }
+        opts.on("-b", "--background", nil,
+                "Daemonize the process") { |arg| options[:daemonize] = true }
+        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]
+
+      pid_file = File.expand_path(options[:pid]) if options[:pid]
+
+      Daemonize.daemonize(nil, "alsa-backup") if options[:daemonize]
+      File.write(pid_file, $$) if pid_file
+      
+      length = options[:length].to_i if options[:length]
+      AlsaBackup.recorder.start(length)
+    rescue Exception => e
+      AlsaBackup.logger.fatal(e)
+    end
+  end
+end

data/lib/alsa_backup/core_ext.rb

@@ -0,0 +1,34 @@
+class Time
+
+  def floor(attribute, modulo)
+    actual = self.send(attribute)
+    self.change(attribute => actual - actual%modulo)
+  end
+
+end
+
+class File
+
+  def self.suffix_basename(file, suffix)
+    dirname = File.dirname(file)
+    
+    dirname = 
+      case dirname
+      when "/": "/"
+      when ".": ""
+      else
+        dirname + "/"
+      end
+
+    extension = File.extname(file)
+    dirname +
+      File.basename(file, extension) +
+      suffix +
+      extension
+  end
+
+  def self.write(file, content)
+    File.open(file, "w") { |f| f.puts content }
+  end
+
+end

data/lib/alsa_backup/length_controller.rb

@@ -0,0 +1,21 @@
+module AlsaBackup
+  module LengthController
+    class Loop
+      def continue_after?(frame_count)
+        true
+      end
+    end
+
+    class FrameCount
+      attr_reader :frame_count
+
+      def initialize(frame_count)
+        @frame_count = frame_count
+      end
+
+      def continue_after?(frame_count)
+        (@frame_count -= frame_count) > 0
+      end
+    end
+  end
+end

data/lib/alsa_backup/recorder.rb

@@ -0,0 +1,91 @@
+require 'alsa'
+
+module AlsaBackup
+  class Recorder
+
+    def initialize(file = "record.wav")
+      @file = File.basename(file)
+      @directory = File.dirname(file)
+
+      @device = "hw:0"
+      @sample_rate = 44100
+      @channels = 2
+
+      @error_handler = Proc.new { |e| true }
+    end
+
+    attr_accessor :file, :directory, :error_handler
+    attr_accessor :device, :sample_rate, :channels
+
+    def start(seconds_to_record = nil)
+      length_controller = self.length_controller(seconds_to_record)
+
+      open_writer do |writer|
+        open_capture do |capture|
+          capture.read do |buffer, frame_count|
+            writer.write buffer, frame_count*format[:channels]
+            length_controller.continue_after? frame_count
+          end
+        end
+      end
+    rescue Exception => e
+      retry if handle_error(e, seconds_to_record.nil?)
+    end
+
+    def open_writer(&block)
+      writer_options = { :directory => directory, :file => file, :format => format(:format => "wav pcm_16") }
+      writer_options[:on_close] = @on_close if @on_close
+      Writer.open(writer_options, &block)
+    end
+
+    def open_capture(&block)
+      ALSA::PCM::Capture.open(device, format(:sample_format => :s16_le), &block)      
+    end
+
+    def handle_error(e, try_to_continue = true)
+      if Interrupt === e or SignalException === e
+        AlsaBackup.logger.debug('recorder interrupted')      
+        return false 
+      end
+
+      AlsaBackup.logger.error(e)
+      AlsaBackup.logger.debug { e.backtrace.join("\n") }
+
+      if try_to_continue and continue_on_error?(e)
+        return true
+      else
+        raise e
+      end
+    end
+
+    def continue_on_error?(e)
+      error_handler_response = @error_handler.call(e) if @error_handler
+
+      if error_handler_response
+        sleep_time = Numeric === error_handler_response ? error_handler_response : 5
+        AlsaBackup.logger.warn("sleep #{sleep_time}s before retrying")
+        sleep sleep_time
+      end
+
+      error_handler_response
+    end
+
+    def format(additional_parameters = {})
+      {:sample_rate => sample_rate, :channels => channels}.merge(additional_parameters)
+    end
+
+    def length_controller(seconds_to_record)
+      if seconds_to_record
+        AlsaBackup::LengthController::FrameCount.new format[:sample_rate] * seconds_to_record 
+      else
+        AlsaBackup::LengthController::Loop.new
+      end
+    end
+
+    def on_close(&block)
+      @on_close = block
+    end
+
+  end
+
+end

data/lib/alsa_backup/writer.rb

@@ -0,0 +1,124 @@
+require 'sndfile'
+require 'fileutils'
+
+module AlsaBackup
+  class Writer
+
+    attr_accessor :directory, :file, :format, :on_close_callbacks
+
+    def self.default_format
+      {:sample_rate => 44100, :channels => 2, :format => "wav pcm_16"}
+    end
+
+    def initialize(options = {})
+      options = { 
+        :format => Writer.default_format 
+      }.update(options)
+
+      @directory = options[:directory]
+      @file = options[:file]
+      @format = options[:format]
+
+      @on_close_callbacks = [ Proc.new do |file| 
+                                Writer.delete_empty_file(file)
+                              end ]
+      @on_close_callbacks << options[:on_close] if options[:on_close]
+    end
+
+    def self.open(options, &block)
+      writer = Writer.new(options)
+      begin
+        writer.prepare
+        yield writer
+      ensure
+        writer.close
+      end
+    end
+
+    def prepare
+      # prepare sndfile
+      self.sndfile
+      self
+    end
+
+    def write(*arguments)
+      self.sndfile.write *arguments
+    end
+
+    def close
+      close_file
+    end
+
+    def close_file
+      if @sndfile
+        on_close(@sndfile.path)
+        @sndfile.close
+      end
+      @sndfile = nil
+    end
+
+    def on_close(file)
+      AlsaBackup.logger.info('close current file')
+      @on_close_callbacks.each do |callback|
+        begin
+          callback.call(file) 
+        rescue Exception => e
+          AlsaBackup.logger.error("error in on_close callback : #{e}")
+          AlsaBackup.logger.debug { e.backtrace.join("\n") }
+        end
+      end
+    end
+
+    def file
+      case @file
+      when Proc
+        @file.call
+      else
+        @file
+      end
+    end
+
+    def target_file
+      File.join self.directory, self.file
+    end
+
+    def sndfile
+      target_file = self.target_file
+      raise "no recording file" unless target_file
+
+      unless @sndfile and @sndfile.path == target_file
+        close_file
+
+        Writer.rename_existing_file(target_file)
+        AlsaBackup.logger.info{"new file #{File.expand_path target_file}"}
+
+        FileUtils.mkdir_p File.dirname(target_file)
+        @sndfile = Sndfile::File.new(target_file, "w", self.format)
+      end
+      @sndfile
+    end
+
+    def self.delete_empty_file(file)
+      if File.exists?(file) and File.size(file) <= 44
+        AlsaBackup.logger.warn("remove empty file #{file}")
+        File.delete file
+      end
+    end
+
+    def self.rename_existing_file(file)
+      if File.exists?(file)
+        index = 1
+
+        while File.exists?(new_file = File.suffix_basename(file, "-#{index}"))
+          index += 1
+
+          raise "can't find a free file for #{file}" if index > 1000
+        end
+
+        AlsaBackup.logger.warn "rename existing file #{File.basename(file)} into #{new_file}"
+        File.rename(file, new_file)
+      end
+    end
+
+  end
+end

data/lib/sndfile.rb

@@ -0,0 +1,138 @@
+require 'ffi'
+
+require 'logger'
+
+module Sndfile
+
+  def self.logger
+    unless @logger
+      @logger = Logger.new(STDERR)
+      @logger.level = Logger::WARN
+    end
+
+    @logger
+  end
+
+  def self.logger=(logger); @logger = logger; end
+
+  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.null?
+        raise "Not able to open output file " + self.error
+      end
+      @path = path
+    end
+
+    def write(buffer, frame_count)
+      ALSA.logger.debug { "write #{frame_count} frames in #{path}" }
+      write_count = Sndfile::Native::write_short(@handle, buffer, frame_count) 
+
+      unless write_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
+
+    # TODO off_t won't work on windows
+    attach_function :write_int, :sf_write_int, [ :pointer, :pointer, :off_t ], :off_t
+    attach_function :write_short, :sf_write_short, [ :pointer, :pointer, :off_t ], :off_t
+
+    attach_function :strerror, :sf_strerror, [ :pointer ], :string
+  end
+end