audio-playback 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86feb1c8a53cb706283d6aefbf0cbee23d028ca8
-  data.tar.gz: 8679d8cc6876bedd0cce0a22878b424c2fda5e80
+  metadata.gz: 0040badaf2c68a1886248157f4448ab24609dccf
+  data.tar.gz: f22b0f7d1615d6b863e493ea5744574ea06a9321
 SHA512:
-  metadata.gz: 48cf6147b24c28099b0e32cf04cbadde493405ab99da91a102603850cd5c6588d3485814bccf8ca73c6227ae74f4c9be6f65df9ced1e7554d1440f7d0da78133
-  data.tar.gz: 723554296063b7c2169e7ec20b6197a47c18b5088cc5ef9e45723871a271db2c1dd65ef2565e4ae345dcc8999c9d41547147228168b29dc469d5e9b8dce6c1c6
+  metadata.gz: cfdddbf4c6f4ea7050ddeff2a9ddf2a37d1484d0fe15d2f056f86001b6fed3cb2aefd02ae6488ed2fa08ec06eef0125e280ea1f215eb9f53803d443e5b67e350
+  data.tar.gz: 04f79ca3da8f374692d5a79ace294362ecfa79455f46180ac5d8c9e6eff00d779c2a9647218674d9b2b47ead49e09c7ce5da05e37e497a3ee923321ac02b9760

data/README.md

@@ -35,10 +35,18 @@ Or if you're using Bundler, add this to your Gemfile
 
 * `-c` Output audio to the given channel(s).  Eg `-c 0,1` will direct audio to channels 0 and 1.  Defaults to use channels 0 and 1 on the selected device
 
+* `-d` Duration. Will stop after the given amount of time.  Eg `-d 56` stops after 56 seconds of playback
+
+* `-e` End position. Will stop at the given absolute time, irregardless of seek. Eg `-e 56` stops at 56 seconds. `-s 01:09:30 -e 01:10:00` stops at 1 hour 10 minutes after 30 seconds of playback
+
 * `-o` Output device id or name.  Defaults to the system default
 
+* `-s` Seek  to given time position. Eg `-s 56` seeks to 56 seconds and `-s 01:10:00` seeks to 1 hour 10 min.
+
 * `-v` or `--verbose` Verbose
 
+* `--loop` Loop playback continuously
+
 * `--list-devices` List the available audio output devices
 
 
@@ -94,4 +102,4 @@ More Ruby code examples:
 
 Licensed under Apache 2.0, See the file LICENSE
 
-Copyright (c) 2015-2016 [Ari Russo](http://arirusso.com)
+Copyright (c) 2015-2017 [Ari Russo](http://arirusso.com)

data/bin/playback

@@ -14,12 +14,19 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 #
 # * `-c` Output audio to the given channel(s).  Eg `-c 0,1` will direct audio to channels 0 and 1.  Defaults to use channels 0 and 1 on the selected device
 #
+# * `-d` Duration. Will stop after the given amount of time.  Eg `-d 56` stops after 56 seconds of playback
+#
+# * `-e` End position. Will stop at the given absolute time, irregardless of seek. Eg `-e 56` stops at 56 seconds. `-s 01:09:30 -e 01:10:00` stops at 1 hour 10 minutes after 30 seconds of playback
+#
 # * `-o` Output device id or name.  Defaults to the system default
 #
+# * `-s` Seek  to given time position. Eg `-s 56` seeks to 56 seconds and `-s 01:10:00` seeks to 1 hour 10 min.
+#
 # * `-v` or `--verbose` Verbose
-# 
+#
 # * `--list-devices` List the available audio output devices
 #
+# * `--loop` Loop playback continuously
 #
 
 require "audio-playback"

data/lib/audio-playback.rb

@@ -2,7 +2,7 @@
 # AudioPlayback
 # Play audio files at the command line or with Ruby
 #
-# (c)2015 Ari Russo
+# (c)2015-2017 Ari Russo
 # Apache 2.0 License
 # https://github.com/arirusso/audio-playback
 #
@@ -19,25 +19,31 @@ require "audio-playback/playback"
 
 # classes
 require "audio-playback/file"
+require "audio-playback/position"
 require "audio-playback/sound"
 
 # Play audio files
 module AudioPlayback
 
-  VERSION = "0.0.6"
+  VERSION = "0.0.8"
 
   # Convenience method to play an audio file
   # @param [Array<::File>, Array<String>, ::File, String] file_paths
   # @param [Hash] options
-  # @option options [Fixnum] :buffer_size Buffer size in bytes.  Defaults to 4096
-  # @option options [Array<Fixnum>, Fixnum] :channels (or: :channel) Output audio to the given channel(s).  Eg `:channels => [0,1]` will direct the audio to channels 0 and 1. Defaults to use all available channels
+  # @option options [Integer] :buffer_size Buffer size in bytes.  Defaults to 4096
+  # @option options [Array<Integer>, Integer] :channels (or: :channel) Output audio to the given channel(s).  Eg `:channels => [0,1]` will direct the audio to channels 0 and 1. Defaults to use all available channels
+  # @option options [Numeric] :duration Play for given time in seconds
+  # @option options [Numeric] :end_position Stop at given time position in seconds (will use :duration if both are included)
+  # @option options [Boolean] :is_looping (or :loop) Whether to loop audio
   # @option options [Float] :latency Latency in seconds.  Defaults to use the default latency for the selected output device
   # @option options [IO] :logger Logger object
-  # @option options [Fixnum, String] :output_device (or: :output) Output device id or name
+  # @option options [Numeric] :seek Start at given time position in seconds
+  # @option options [Integer, String] :output_device (or: :output) Output device id or name
   def self.play(file_paths, options = {})
     sounds = Array(file_paths).map { |path| Sound.load(path, options) }
     requested_device = options[:output_device] || options[:output]
     output = Device::Output.by_name(requested_device) || Device::Output.by_id(requested_device) || Device.default_output
+    options[:is_looping] ||= options[:loop]
     Playback.play(sounds, output, options)
   end
 

data/lib/audio-playback/commandline.rb

@@ -18,6 +18,20 @@ module AudioPlayback
         :name => "Direct to channel(s)"
       },
 
+      :duration => {
+        :short => "-d",
+        :long => "--duration [seconds]",
+        :name => "Duration",
+        :type => String
+      },
+
+      :end_position => {
+        :short => "-e",
+        :long => "--end-position [seconds]",
+        :name => "End position",
+        :type => String
+      },
+
       :latency => {
         :short => "-l",
         :long => "--latency [seconds]",
@@ -30,6 +44,18 @@ module AudioPlayback
         :name => "List devices"
       },
 
+      :loop => {
+        :long => "--loop",
+        :name => "Loop"
+      },
+
+      :seek => {
+        :short => "-s",
+        :long => "--seek [seconds]",
+        :name => "Seek",
+        :type => String
+      },
+
       :logger => {
         :short => "-v",
         :long => "--verbose",
@@ -43,7 +69,7 @@ module AudioPlayback
         :type => String,
         :name => "Output device for playback"
       }
-    }
+    }.freeze
 
   end
 

data/lib/audio-playback/device.rb

@@ -21,7 +21,7 @@ module AudioPlayback
     end
 
     # Get a device by its ID
-    # @param [Fixnum] id
+    # @param [Integer] id
     # @return [Output]
     def by_id(id)
       outputs.find { |device| [device, device.id].include?(id) }
@@ -41,7 +41,7 @@ module AudioPlayback
     end
 
     # Get system device info given a device ID
-    # @param [Fixnum] id
+    # @param [Integer] id
     # @return [FFI::PortAudio::API::PaDeviceInfo]
     def device_info(id)
       FFI::PortAudio::API.Pa_GetDeviceInfo(id)
@@ -50,7 +50,7 @@ module AudioPlayback
     private
 
     # Is the device with the given ID an output?
-    # @param [Fixnum] id
+    # @param [Integer] id
     # @return [Boolean]
     def output?(id)
       device_info(id)[:maxOutputChannels] > 0

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

@@ -42,7 +42,7 @@ module AudioPlayback
       end
 
       # Select an output device by ID
-      # @param [Fixnum] id
+      # @param [Integer] id
       # @return [Output]
       def self.by_id(id)
         Device.by_id(id)
@@ -55,7 +55,7 @@ module AudioPlayback
         Device.by_name(name)
       end
 
-      # @param [Fixnum] id
+      # @param [Integer] id
       # @param [Hash] options
       # @option options [Float] :latency Device latency in seconds
       def initialize(id, options = {})
@@ -71,13 +71,13 @@ module AudioPlayback
       end
 
       # Number of channels the device supports
-      # @return [Fixnum]
+      # @return [Integer]
       def num_channels
         @resource[:channelCount]
       end
 
       # ID of the device
-      # @return [Fixnum]
+      # @return [Integer]
       def id
         @resource[:device]
       end
@@ -91,7 +91,7 @@ module AudioPlayback
       end
 
       # Populate the output
-      # @param [Fixnum] id
+      # @param [Integer] id
       # @param [Hash] options
       # @option options [Float] :latency
       # @return [FFI::PortAudio::API::PaStreamParameters]

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

@@ -54,10 +54,10 @@ module AudioPlayback
       def block
         begin
           while active?
-            sleep(0.0001)
+            sleep(0.001)
           end
           while FFI::PortAudio::API.Pa_IsStreamActive(@stream.read_pointer) != :paNoError
-            sleep(1)
+            sleep(0.1)
           end
         rescue SystemExit, Interrupt
           # Control-C
@@ -74,7 +74,7 @@ module AudioPlayback
       # @param [Playback] playback
       # @return [Boolean]
       def open_stream(playback)
-        @userdata = playback.data.to_pointer
+        @userdata ||= playback.data.to_pointer
         FFI::PortAudio::API.Pa_OpenStream(@stream, @input, @output, @freq, @frames, @flags, @method, @userdata)
         true
       end
@@ -112,15 +112,23 @@ module AudioPlayback
       # @param [Playback] playback
       # @return [Boolean]
       def open_playback(playback)
-        @freq = playback.sample_rate.to_i
-        @frames = playback.buffer_size
-        @flags = FFI::PortAudio::API::NoFlag
-        @stream = FFI::Buffer.new(:pointer)
-        @method = method(:process)
+        populate_stream_playback(playback)
         open_stream(playback)
         true
       end
 
+      # Initialize the stream's playback properties
+      # @param [Playback] playback
+      # @return [Boolean]
+      def populate_stream_playback(playback)
+        @freq ||= playback.sample_rate.to_i
+        @frames ||= playback.buffer_size
+        @flags ||= FFI::PortAudio::API::NoFlag
+        @stream ||= FFI::Buffer.new(:pointer)
+        @method ||= method(:process)
+        true
+      end
+
       # Report about the stream
       # @param [Playback] playback
       # @param [IO] logger
@@ -135,41 +143,58 @@ module AudioPlayback
         #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}"
+        audio_data_size = user_data.get_float32(Playback::METADATA.index(:size) * Playback::FRAME_SIZE).to_i
+        #puts "Sample size: #{audio_data_size}"
         num_channels = user_data.get_float32(Playback::METADATA.index(:num_channels) * Playback::FRAME_SIZE).to_i
         #puts "Num Channels: #{num_channels}"
+        start_frame = user_data.get_float32(Playback::METADATA.index(:start_frame) * Playback::FRAME_SIZE).to_i
+        #puts "Start point: #{start_frame}"
+        end_frame = user_data.get_float32(Playback::METADATA.index(:end_frame) * Playback::FRAME_SIZE).to_i
+        #puts "Duration: #{duration}"
+        is_looping = user_data.get_float32(Playback::METADATA.index(:is_looping) * Playback::FRAME_SIZE).to_i > 0
+        #puts "Is looping: #{is_looping}"
+        end_frame = [end_frame, audio_data_size].min
         is_eof = false
-        if counter >= sample_size - frames_per_buffer
-          if counter < sample_size
-            buffer_size = sample_size.divmod(frames_per_buffer).last
+        end_window = end_frame - frames_per_buffer
+        if counter >= end_window
+          if counter == end_frame
+            is_eof = true
+          elsif counter < end_frame
+            buffer_size = end_frame.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
+            # p "Aborting (counter: #{counter}, end_frame: #{end_frame})"
             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
+        offset = (((counter + start_frame) * 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
+        next_counter = counter + frames_per_buffer
         if is_eof
-          #puts "Marking eof"
-          user_data.put_float32(Playback::METADATA.index(:is_eof) * Playback::FRAME_SIZE, 1.0) # mark eof
-          :paComplete
+          if is_looping
+            #puts "Looping to beginning"
+            next_counter = start_frame
+            :paContinue
+          else
+            #puts "Marking eof"
+            user_data.put_float32(Playback::METADATA.index(:is_eof) * Playback::FRAME_SIZE, 1.0) # mark eof
+            :paComplete
+          end
         else
           :paContinue
         end
+        user_data.put_float32(Playback::METADATA.index(:pointer) * Playback::FRAME_SIZE, next_counter.to_f) # update counter
         #puts "Exiting callback at #{Time.now.to_f}"
         result
       end

data/lib/audio-playback/playback.rb

@@ -13,23 +13,41 @@ module AudioPlayback
 
     FRAME_SIZE = FFI::TYPE_FLOAT32.size
 
-    METADATA = [:size, :num_channels, :pointer, :is_eof].freeze
+    METADATA = [:size, :num_channels, :start_frame, :end_frame, :is_looping, :pointer, :is_eof].freeze
+
+    class InvalidChannels < RuntimeError
+    end
+
+    class InvalidTruncation < RuntimeError
+    end
 
     # Action of playing back an audio file
     class Action
 
       extend Forwardable
 
-      attr_reader :buffer_size, :channels, :data, :output, :num_channels, :sounds, :stream
+      attr_reader :buffer_size,
+                  :channels,
+                  :data,
+                  :num_channels,
+                  :output,
+                  :sounds,
+                  :stream,
+                  :truncate
+
       def_delegators :@sounds, :audio_files
-      def_delegators :@data, :reset
+      def_delegators :@data, :reset, :size
 
       # @param [Array<Sound>, Sound] sounds
       # @param [Output] output
       # @param [Hash] options
-      # @option options [Fixnum] :buffer_size
-      # @option options [Array<Fixnum>, Fixnum] :channels (or: :channel)
+      # @option options [Integer] :buffer_size
+      # @option options [Array<Integer>, Integer] :channels (or: :channel)
+      # @option options [Numeric] :duration Play for given time in seconds
+      # @option options [Numeric] :end_position Stop at given time position in seconds (will use :duration if both are included)
+      # @option options [Boolean] :is_looping Whether to loop audio
       # @option options [IO] :logger
+      # @option options [Numeric] :seek Start at given time position in seconds
       # @option options [Stream] :stream
       def initialize(sounds, output, options = {})
         @sounds = Array(sounds)
@@ -41,17 +59,11 @@ module AudioPlayback
       end
 
       # Sample rate of the playback sound
-      # @return [Fixnum]
+      # @return [Integer]
       def sample_rate
         @sounds.last.sample_rate
       end
 
-      # Size of the playback sound
-      # @return [Fixnum]
-      def size
-        @sounds.map(&:size).max
-      end
-
       # Start playback
       # @return [Playback]
       def start
@@ -66,6 +78,13 @@ module AudioPlayback
         @stream.block
       end
 
+      # Should playback be truncated?
+      #  eg :start 3 seconds, :duration 1 second
+      # @return [Boolean]
+      def truncate?
+        !@truncate.nil? && !@truncate.values.empty?
+      end
+
       # Log a report about playback
       # @param [IO] logger
       # @return [Boolean]
@@ -80,9 +99,9 @@ module AudioPlayback
       end
 
       # Total size of the playback's sound frames in bytes
-      # @return [Fixnum]
+      # @return [Integer]
       def data_size
-        frames = (size * @num_channels) + METADATA.count
+        frames = size * @num_channels
         frames * FRAME_SIZE.size
       end
 
@@ -92,21 +111,28 @@ module AudioPlayback
         !@channels.nil?
       end
 
+      # Is audio looping ?
+      # @return [Boolean]
+      def looping?
+        @is_looping
+      end
+
       private
 
       # Are the requested channels available in the current environment?
-      # @param [Array<Fixnum>] channels
+      # @param [Array<Integer>] 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"
+          message = "Only #{@output.num_channels} channels available on #{@output.name} output"
+          raise(InvalidChannels.new(message))
           false
         end
         true
       end
 
       # Validate and populate the variables containing information about the requested channels
-      # @param [Fixnum, Array<Fixnum>] request Channel(s)
+      # @param [Integer, Array<Integer>] request Channel(s)
       # @return [Boolean]
       def populate_requested_channels(request)
         request = Array(request)
@@ -122,7 +148,7 @@ module AudioPlayback
 
       # Populate the playback channels
       # @param [Hash] options
-      # @option options [Fixnum, Array<Fixnum>] :channels (or: :channel)
+      # @option options [Integer, Array<Integer>] :channels (or: :channel)
       # @return [Boolean]
       def populate_channels(options = {})
         request = options[:channels] || options[:channel]
@@ -134,12 +160,92 @@ module AudioPlayback
         end
       end
 
+      # Populate the truncation parameters. Converts the seconds based Position arguments
+      # to number of frames
+      # @param [Position, nil] seek Start at given time position in seconds
+      # @param [Position, nil] duration Play for given time in seconds
+      # @param [Position, nil] end_position Stop at given time position in seconds (will use duration arg if both are included)
+      # @return [Hash]
+      def populate_truncation(seek, duration, end_position)
+        @truncate = {}
+        end_position = if duration.nil?
+          end_position
+        elsif seek.nil?
+          duration || end_position
+        else
+          duration + seek || end_position
+        end
+        unless seek.nil?
+          @truncate[:start_frame] = number_of_seconds_to_number_of_frames(seek)
+        end
+        unless end_position.nil?
+          @truncate[:end_frame] = number_of_seconds_to_number_of_frames(end_position)
+        end
+        @truncate
+      end
+
+      # Convert number of seconds to number of sample frames given the sample rate
+      # @param [Numeric] num_seconds
+      # @return [Integer]
+      def number_of_seconds_to_number_of_frames(num_seconds)
+        (num_seconds * sample_rate).to_i
+      end
+
+      # Are the options for truncation valid? eg is the :end_position option after the
+      # :seek option?
+      # @param [Hash] options
+      # @option options [Numeric] :duration Play for given time in seconds
+      # @option options [Numeric] :end_position Stop at given time position in seconds (will use :duration if both are included)
+      # @option options [Numeric] :seek Start at given time position in seconds
+      # @return [Boolean]
+      def truncate_valid?(options)
+        options[:end_position].nil? || options[:seek].nil? ||
+          options[:end_position] > options[:seek]
+      end
+
+      # Has truncation been requested in the constructor options?
+      # @param [Hash] options
+      # @option options [Numeric] :duration Play for given time in seconds
+      # @option options [Numeric] :end_position Stop at given time position in seconds (will use :duration if both are included)
+      # @option options [Numeric] :seek Start at given time position in seconds
+      # @return [Boolean]
+      def truncate_requested?(options)
+        !options[:seek].nil? || !options[:duration].nil? || !options[:end_position].nil?
+      end
+
+      # Populate Position objects using the the truncation parameters.
+      # @param [Hash] options
+      # @option options [Numeric] :duration Play for given time in seconds
+      # @option options [Numeric] :end_position Stop at given time position in seconds (will use :duration if both are included)
+      # @option options [Numeric] :seek Start at given time position in seconds
+      # @return [Array<Position>]
+      def truncate_options_as_positions(options = {})
+        seek = Position.new(options[:seek]) unless options[:seek].nil?
+        duration = Position.new(options[:duration]) unless options[:duration].nil?
+        end_position = Position.new(options[:end_position]) unless options[:end_position].nil?
+        [seek, duration, end_position]
+      end
+
       # Populate the playback action
       # @param [Hash] options
-      # @option options [Fixnum, Array<Fixnum>] :channels (or: :channel)
+      # @option options [Integer, Array<Integer>] :channels (or: :channel)
+      # @option options [Numeric] :duration Play for given time in seconds
+      # @option options [Numeric] :end_position Stop at given time position in seconds (will use :duration if both are included)
+      # @option options [Boolean] :is_looping Whether to loop audio
+      # @option options [Numeric] :seek Start at given time position in seconds
       # @return [Playback::Action]
       def populate(options = {})
         populate_channels(options)
+        if truncate_requested?(options)
+          if truncate_valid?(options)
+            seek, duration, end_position = *truncate_options_as_positions(options)
+            populate_truncation(seek, duration, end_position)
+          else
+            message = "Truncation options are not valid"
+            raise(InvalidTruncation.new(message))
+          end
+        end
+        @is_looping = !!options[:is_looping]
         @data = StreamData.new(self)
         self
       end
@@ -155,8 +261,8 @@ module AudioPlayback
     # @param [Sound] sound
     # @param [Output] output
     # @param [Hash] options
-    # @option options [Fixnum] :buffer_size
-    # @option options [Array<Fixnum>, Fixnum] :channels (or: :channel)
+    # @option options [Integer] :buffer_size
+    # @option options [Array<Integer>, Integer] :channels (or: :channel)
     # @option options [IO] :logger
     # @option options [Stream] :stream
     # @return [Playback]