audio-playback 0.0.2

data/lib/audio-playback/device/stream.rb

@@ -0,0 +1,134 @@
+module AudioPlayback
+
+  module Device
+
+    class Stream < FFI::PortAudio::Stream
+
+      # @param [Output] output
+      # @param [Hash] options
+      # @option options [IO] logger
+      def initialize(output, options = {})
+        @is_muted = false
+        @gain = 1.0
+        @input = nil
+        @output = output.resource
+        initialize_exit_callback(:logger => options[:logger])
+      end
+
+      # Perform the given playback
+      # @param [Playback] playback
+      # @param [Hash] options
+      # @option options [IO] logger
+      # @return [Stream]
+      def play(playback, options = {})
+        report(playback, options[:logger]) if options[:logger]
+        open_playback(playback)
+        start
+        self
+      end
+
+      # Is the stream active?
+      # @return [Boolean]
+      def active?
+        FFI::PortAudio::API.Pa_IsStreamActive(@stream.read_pointer) == 1
+      end
+
+      # Block process until the current playback finishes
+      # @return [Boolean]
+      def block
+        while active?
+          sleep(0.0001)
+        end
+        while FFI::PortAudio::API.Pa_IsStreamActive(@stream.read_pointer) != :paNoError
+          sleep(1)
+        end
+        exit
+        true
+      end
+
+      private
+
+      # Initialize the callback that's fired when the stream exits
+      # @return [Stream]
+      def initialize_exit_callback(options = {})
+        at_exit { exit_callback(options) }
+        self
+      end
+
+      # Callback that's fired when the stream exits
+      # @return [Boolean]
+      def exit_callback(options = {})
+        logger = options[:logger]
+        logger.puts("Exit") if logger
+        unless @stream.nil?
+          close
+          FFI::PortAudio::API.Pa_Terminate
+        end
+        true
+      end
+
+      # Initialize the stream for playback
+      # @param [Playback] playback
+      # @return [Boolean]
+      def open_playback(playback)
+        open(@input, @output, playback.sample_rate.to_i, playback.buffer_size, FFI::PortAudio::API::NoFlag, playback.data)
+        true
+      end
+
+      # Report about the stream
+      # @param [Playback] playback
+      # @param [IO] logger
+      # @return [Stream]
+      def report(playback, logger)
+        self
+      end
+
+      # Portaudio stream callback
+      def process(input, output, frames_per_buffer, time_info, status_flags, user_data)
+        #puts "--"
+        #puts "Entering callback at #{Time.now.to_f}"
+        counter = user_data.get_float32(Playback::METADATA.index(:pointer) * Playback::FRAME_SIZE).to_i
+        #puts "Frame: #{counter}"
+        sample_size = user_data.get_float32(Playback::METADATA.index(:size) * Playback::FRAME_SIZE).to_i
+        #puts "Sample size: #{sample_size}"
+        num_channels = user_data.get_float32(Playback::METADATA.index(:num_channels) * Playback::FRAME_SIZE).to_i
+        #puts "Num Channels: #{num_channels}"
+        is_eof = false
+        if counter >= sample_size - frames_per_buffer
+          if counter < sample_size
+            buffer_size = sample_size.divmod(frames_per_buffer).last
+            #puts "Truncated buffer size: #{buffer_size}"
+            difference = frames_per_buffer - buffer_size
+            #puts "Adding #{difference} frames of null audio"
+            extra_data = [0] * difference * num_channels
+            is_eof = true
+          else
+            return :paAbort
+          end
+        end
+        buffer_size ||= frames_per_buffer
+        #puts "Size per buffer per channel: #{frames_per_buffer}"
+        offset = ((counter * num_channels) + Playback::METADATA.count) * Playback::FRAME_SIZE
+        #puts "Starting at location: #{offset}"
+        data = user_data.get_array_of_float32(offset, buffer_size * num_channels)
+        data += extra_data unless extra_data.nil?
+        #puts "This buffer size: #{data.size}"
+        #puts "Writing to output"
+        output.write_array_of_float(data)
+        counter += frames_per_buffer
+        user_data.put_float32(Playback::METADATA.index(:pointer) * Playback::FRAME_SIZE, counter.to_f) # update counter
+        if is_eof
+          #puts "Marking eof"
+          user_data.put_float32(Playback::METADATA.index(:is_eof) * Playback::FRAME_SIZE, 1.0) # mark eof
+          :paComplete
+        else
+          :paContinue
+        end
+        #puts "Exiting callback at #{Time.now.to_f}"
+        result
+      end
+    end
+
+  end
+
+end

data/lib/audio-playback/file.rb

@@ -0,0 +1,37 @@
+module AudioPlayback
+
+  # An audio file
+  class File
+
+    attr_reader :num_channels, :path, :sample_rate, :size
+
+    # @param [::File, String] file_or_path
+    def initialize(file_or_path)
+      @path = file_or_path.kind_of?(::File) ? file_or_path.path : file_or_path
+      @file = RubyAudio::Sound.open(@path)
+      @size = ::File.size(@path)
+      @num_channels = @file.info.channels
+      @sample_rate = @file.info.samplerate
+    end
+
+    # @param [Hash] options
+    # @option options [IO] :logger
+    # @return [Array<Array<Float>>, Array<Float>] File data
+    def read(options = {})
+      if logger = options[:logger]
+        logger.puts("Reading audio file #{@path}")
+      end
+      buffer = RubyAudio::Buffer.float(@size, @num_channels)
+      begin
+        @file.seek(0)
+        @file.read(buffer, @size)
+        data = buffer.to_a
+      rescue RubyAudio::Error
+      end
+      logger.puts("Finished reading audio file #{@path}") if logger
+      data
+    end
+
+  end
+
+end

data/lib/audio-playback/playback.rb

@@ -0,0 +1,152 @@
+require "audio-playback/playback/frame"
+require "audio-playback/playback/frame_set"
+require "audio-playback/playback/stream_data"
+
+module AudioPlayback
+
+  module Playback
+
+    DEFAULT = {
+      :buffer_size => 2**12
+    }.freeze
+
+    FRAME_SIZE = FFI::TYPE_FLOAT32.size
+
+    METADATA = [:size, :num_channels, :pointer, :is_eof].freeze
+
+    # Action of playing back an audio file
+    class Action
+
+      extend Forwardable
+
+      attr_reader :buffer_size, :channels, :data, :output, :num_channels, :sound, :stream
+      def_delegators :@sound, :audio_file, :sample_rate, :size
+
+      # @param [Sound] sound
+      # @param [Output] output
+      # @param [Hash] options
+      # @option options [Fixnum] :buffer_size
+      # @option options [Array<Fixnum>, Fixnum] :channels (or: :channel)
+      # @option options [IO] :logger
+      # @option options [Stream] :stream
+      def initialize(sound, output, options = {})
+        @sound = sound
+        @buffer_size = options[:buffer_size] || DEFAULT[:buffer_size]
+        @output = output
+        @stream = options[:stream] || Device::Stream.new(@output, options)
+        populate(options)
+        report(options[:logger]) if options[:logger]
+      end
+
+      # Start playback
+      # @return [Playback]
+      def start
+        @stream.play(self)
+        self
+      end
+
+      # Block process until playback finishes
+      # @return [Stream]
+      def block
+        @stream.block
+      end
+
+      # Log a report about playback
+      # @param [IO] logger
+      # @return [Boolean]
+      def report(logger)
+        logger.puts("Playback report for #{@sound.audio_file.path}")
+        logger.puts("  Number of channels: #{@num_channels}")
+        logger.puts("  Direct audio to channels #{@channels.to_s}") unless @channels.nil?
+        logger.puts("  Buffer size: #{@buffer_size}")
+        logger.puts("  Latency: #{@output.latency}")
+        true
+      end
+
+      # Total size of the playback's sound frames in bytes
+      # @return [Fixnum]
+      def data_size
+        frames = (@sound.size * @num_channels) + METADATA.count
+        frames * FRAME_SIZE.size
+      end
+
+      def channels_requested?
+        !@channels.nil?
+      end
+
+      private
+
+      # Are the requested channels available in the current environment?
+      # @param [Array<Fixnum>] channels
+      # @return [Boolean]
+      def validate_requested_channels(channels)
+        if channels.count > @output.num_channels
+          raise "Only #{@output.num_channels} channels available on #{@output.name} output"
+          false
+        end
+        true
+      end
+
+      # Validate and populate the variables containing information about the requested channels
+      # @param [Fixnum, Array<Fixnum>] request Channel(s)
+      # @return [Boolean]
+      def populate_requested_channels(request)
+        request = Array(request)
+        requested_channels = request.map(&:to_i).uniq
+        if validate_requested_channels(requested_channels)
+          @num_channels = requested_channels.count
+          @channels = requested_channels
+          true
+        else
+          false
+        end
+      end
+
+      # Populate the playback channels
+      # @param [Hash] options
+      # @option options [Fixnum, Array<Fixnum>] :channels (or: :channel)
+      # @return [Boolean]
+      def populate_channels(options = {})
+        request = options[:channels] || options[:channel]
+        if request.nil?
+          @num_channels = @output.num_channels
+          true
+        else
+          populate_requested_channels(request)
+        end
+      end
+
+      # Populate the playback action
+      # @param [Hash] options
+      # @option options [Fixnum, Array<Fixnum>] :channels (or: :channel)
+      # @return [Playback::Action]
+      def populate(options = {})
+        populate_channels(options)
+        @data = StreamData.to_pointer(self)
+        self
+      end
+
+    end
+
+    # Shortcut to Action.new
+    # @return [Playback::Action]
+    def self.new(*args)
+      Action.new(*args)
+    end
+
+    # @param [Sound] sound
+    # @param [Output] output
+    # @param [Hash] options
+    # @option options [Fixnum] :buffer_size
+    # @option options [Array<Fixnum>, Fixnum] :channels (or: :channel)
+    # @option options [IO] :logger
+    # @option options [Stream] :stream
+    # @return [Playback]
+    def self.play(sound, output, options = {})
+      playback = Action.new(sound, output, options)
+      playback.start
+    end
+
+  end
+
+end

data/lib/audio-playback/playback/frame.rb

@@ -0,0 +1,72 @@
+module AudioPlayback
+
+  module Playback
+
+    # A single frame of audio data in the FrameSet
+    class Frame
+
+      extend Forwardable
+
+      attr_reader :frame
+      def_delegators :@frame, :[], :all?, :any?, :count, :each, :flatten, :map, :size, :to_ary
+
+      # @param [Array<Float>, Frame] frame
+      def initialize(frame)
+        @frame = frame.frame if frame.kind_of?(Frame)
+        @frame ||= frame
+      end
+
+      # Truncate the frame to the given size
+      # @param [Fixnum] num
+      # @return [Frame]
+      def truncate(num)
+        @frame.slice!(num..-1)
+        self
+      end
+
+      # Fill up the given number of channels at the end of the frame with duplicate data from the last
+      #   existing channel
+      # @param [Fixnum] num
+      # @param [Hash] options
+      # @option options [Array<Fixnum>] :channels (required if :num_channels is provided)
+      # @option options [Fixnum] :num_channels (required if :channels is provided)
+      # @return [Boolean]
+      def fill(num, options = {})
+        if (channels = options[:channels]).nil?
+          @frame.fill(@frame.last, @frame.size, num)
+        else
+          fill_for_channels(options[:num_channels], channels)
+        end
+        true
+      end
+
+      private
+
+      # Zero out the given number of channels in the frame starting with the given index
+      # @param [Fixnum] index
+      # @param [Fixnum] num_channels
+      # @return [Frame]
+      def silence_channels(index, num_channels)
+        @frame.fill(0, index, num_channels)
+        self
+      end
+
+      # Fill the entire frame for the given channels
+      # @param [Fixnum] num_channels
+      # @param [Array<Fixnum>] channels
+      # @return [Boolean]
+      def fill_for_channels(num_channels, channels)
+        values = @frame.dup
+        silence_channels(0, num_channels)
+        channels.each do |channel|
+          value = values[channel] || values.first
+          @frame[channel] = value
+        end
+        true
+      end
+
+    end
+
+  end
+
+end

data/lib/audio-playback/playback/frame_set.rb

@@ -0,0 +1,117 @@
+module AudioPlayback
+
+  module Playback
+
+    # Container for playback data
+    class FrameSet
+
+      extend Forwardable
+
+      def_delegators :@data, :flatten, :slice, :to_ary, :unshift
+
+      # @param [Playback::Action] playback
+      def initialize(playback)
+        populate(playback)
+      end
+
+      private
+
+      # Populate the Container
+      # @param [Playback::Action] playback
+      # @return [Array<Array<Float>>]
+      def populate(playback)
+        data = playback.sound.data.dup
+        data = ensure_array_frames(data)
+        data = to_frame_objects(data)
+
+        @data = if channels_match?(playback)
+          data
+        else
+          build_channels(data, playback)
+        end
+      end
+
+      # Does the channel structure of the playback action match the channel structure of the sound?
+      # @param [Playback::Action] playback
+      # @return [Boolean]
+      def channels_match?(playback)
+        playback.sound.num_channels == playback.num_channels && playback.channels.nil?
+      end
+
+      # (Re-)build the channel structure of the frame set
+      # @param [Array<Frame>] data
+      # @param [Playback::Action] playback
+      # @return [Array<Frame>]
+      def build_channels(data, playback)
+        ensure_num_channels(data, playback.num_channels)
+
+        if playback.channels_requested?
+          ensure_requested_channels(data, playback)
+        else
+          ensure_output_channels(data, playback)
+        end
+        data
+      end
+
+      # Build the channel structure of the frame set to what was requested of playback
+      # @param [Array<Frame>] data
+      # @param [Playback::Action] playback
+      # @return [Array<Frame>]
+      def ensure_requested_channels(data, playback)
+        ensure_num_channels(data, playback.output.num_channels, :channels => playback.channels)
+      end
+
+      # Build the channel structure of the frameset to that of the playback output device
+      # @param [Array<Frame>] data
+      # @param [Playback::Action] playback
+      # @return [Array<Frame>]
+      def ensure_output_channels(data, playback)
+        if playback.num_channels != playback.output.num_channels
+          ensure_num_channels(data, playback.output.num_channels)
+        end
+      end
+
+      # Ensure that the channel structure of the frameset is according to the given number of channels
+      #    and to the given particular channels when provided
+      # @param [Array<Frame>] data
+      # @param [Fixnum] num_channels
+      # @param [Hash] options
+      # @option options [Array<Fixnum>] :channels
+      # @return [Array<Frame>]
+      def ensure_num_channels(data, num_channels, options = {})
+        data.each do |frame|
+          difference = num_channels - frame.size
+          if difference > 0
+            frame.fill(difference, :channels => options[:channels], :num_channels => num_channels)
+          else
+            frame.truncate(num_channels)
+          end
+        end
+        data
+      end
+
+      # Ensure that the input data is Array<Array<Float>>. Single channel audio will be provided as
+      #   Array<Float> and is converted here so that the frame set data structure can be built in a
+      #   uniform way
+      # @param [Array<Float>, Array<Array<Float>>] data
+      # @return [Array<Array<Float>>]
+      def ensure_array_frames(data)
+        if data.sample.kind_of?(Array)
+          data
+        else
+          data.map { |frame| Array(frame) }
+        end
+      end
+
+      # Convert the raw sound data to Frame objects
+      # @param [Array<Array<Float>>] data
+      # @return [Array<Frame>]
+      def to_frame_objects(data)
+        data.map { |frame| Frame.new(frame) }
+      end
+
+    end
+
+  end
+
+end