audio-playback 0.0.6 → 0.0.8

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

@@ -17,7 +17,7 @@ module AudioPlayback
       end
 
       # Truncate the frame to the given size
-      # @param [Fixnum] num
+      # @param [Integer] num
       # @return [Frame]
       def truncate(num)
         @frame.slice!(num..-1)
@@ -26,10 +26,10 @@ module AudioPlayback
 
       # 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 [Integer] 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)
+      # @option options [Array<Integer>] :channels (required if :num_channels is provided)
+      # @option options [Integer] :num_channels (required if :channels is provided)
       # @return [Boolean]
       def fill(num, options = {})
         if (channels = options[:channels]).nil?
@@ -43,8 +43,8 @@ module AudioPlayback
       private
 
       # Zero out the given number of channels in the frame starting with the given index
-      # @param [Fixnum] index
-      # @param [Fixnum] num_channels
+      # @param [Integer] index
+      # @param [Integer] num_channels
       # @return [Frame]
       def silence_channels(index, num_channels)
         @frame.fill(0, index, num_channels)
@@ -52,8 +52,8 @@ module AudioPlayback
       end
 
       # Fill the entire frame for the given channels
-      # @param [Fixnum] num_channels
-      # @param [Array<Fixnum>] channels
+      # @param [Integer] num_channels
+      # @param [Array<Integer>] channels
       # @return [Boolean]
       def fill_for_channels(num_channels, channels)
         values = @frame.dup

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

@@ -7,7 +7,7 @@ module AudioPlayback
 
       extend Forwardable
 
-      def_delegators :@data, :[], :[]=, :flatten, :slice, :to_ary, :unshift
+      def_delegators :@data, :[], :[]=, :flatten, :length, :size, :slice, :to_ary, :unshift
 
       # @param [Playback::Action] playback
       def initialize(playback)
@@ -83,9 +83,9 @@ module AudioPlayback
       # 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 [Integer] num_channels
       # @param [Hash] options
-      # @option options [Array<Fixnum>] :channels
+      # @option options [Array<Integer>] :channels
       # @return [Array<Frame>]
       def ensure_num_channels(data, num_channels, options = {})
         data.each do |frame|

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

@@ -6,21 +6,21 @@ module AudioPlayback
     class Mixer
 
       # Mix multiple sounds at equal amplitude
-      # @param [Array<Array<Array<Fixnum>>>] sounds_data
-      # @return [Array<Array<Fixnum>>]
+      # @param [Array<Array<Array<Integer>>>] sounds_data
+      # @return [Array<Array<Integer>>]
       def self.mix(sounds_data)
         mixer = new(sounds_data)
         mixer.mix
       end
 
-      # @param [Array<Array<Array<Fixnum>>>] sounds_data
+      # @param [Array<Array<Array<Integer>>>] sounds_data
       def initialize(sounds_data)
         @data = sounds_data
         populate
       end
 
       # Mix multiple sounds at equal amplitude
-      # @return [Array<Array<Fixnum>>]
+      # @return [Array<Array<Integer>>]
       def mix
         (0..@length-1).to_a.map { |index| mix_frame(index) }
       end
@@ -37,8 +37,8 @@ module AudioPlayback
 
       # Get all of the data frames for the given index
       # For example for index 3, two two channel sounds, frames(3) might give you [[1, 3], [2, 3]]
-      # @param [Fixnum] index
-      # @return [Array<Array<Fixnum>>]
+      # @param [Integer] index
+      # @return [Array<Array<Integer>>]
       def frames(index)
         @data.map { |sound_data| sound_data[index] }
       end
@@ -46,8 +46,8 @@ module AudioPlayback
       # Mix the frame with the given index
       # whereas frames(3) might give you [[1, 3], [2, 3]]
       # mix_frame(3) might give you [1.5, 3]
-      # @param [Fixnum] index
-      # @return [Array<Fixnum>]
+      # @param [Integer] index
+      # @return [Array<Integer>]
       def mix_frame(index)
         totals = frames(index).compact.transpose.map { |x| x && x.reduce(:+) || 0 }
         totals.map { |frame| frame / @depth }

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

@@ -5,6 +5,11 @@ module AudioPlayback
     # Playback data for the Device::Stream
     class StreamData
 
+      extend Forwardable
+
+      attr_reader :num_frames
+      def_delegators :@data, :[], :at, :length, :size
+
       # A C pointer version of the audio data
       # @param [Playback::Action] playback
       # @return [FFI::Pointer]
@@ -22,28 +27,40 @@ module AudioPlayback
       # Reset the stream metadata
       # @param [Boolean]
       def reset
-        indexes = [
-          Playback::METADATA.index(:pointer),
-          Playback::METADATA.index(:is_eof)
-        ]
-        indexes.each { |index| @data[index] = 0.0 }
+        [:is_eof, :pointer].each { |key| set_metadata(key, 0.0) }
         true
       end
 
       # A C pointer version of the audio data
       # @return [FFI::Pointer]
       def to_pointer
-        @pointer ||= FFI::LibC.malloc(@playback.data_size)
-        @pointer.write_array_of_float(@data.flatten)
+        if @pointer.nil?
+          @pointer = FFI::LibC.malloc(@playback.data_size)
+          @pointer.write_array_of_float(@data.flatten)
+        end
         @pointer
       end
 
       private
 
+      # Set the metadata value with the given key to the given value
+      # @param [Symbol] key
+      # @param [Object] value
+      # @return [Object]
+      def set_metadata(key, value)
+        index = Playback::METADATA.index(key)
+        @data[index] = value
+        unless @pointer.nil?
+          @pointer.put_float32(index * Playback::FRAME_SIZE, value)
+        end
+        value
+      end
+
       # Populate the playback stream data
       # @return [FrameSet]
       def populate
         @data = FrameSet.new(@playback)
+        @num_frames = @data.size
         add_metadata
         @data
       end
@@ -51,10 +68,18 @@ module AudioPlayback
       # Add playback metadata to the stream data
       # @return [FrameSet]
       def add_metadata
-        @data.unshift(0.0) # 3. is_eof
-        @data.unshift(0.0) # 2. counter
+        if @playback.truncate?
+          end_frame = @playback.truncate[:end_frame]
+          start_frame = @playback.truncate[:start_frame]
+        end
+        @data.unshift(0.0) # 6. is_eof
+        @data.unshift(start_frame || 0.0) # 5. counter
+        loop_value = @playback.looping? ? 1.0 : 0.0
+        @data.unshift(loop_value) # 4. is_looping
+        @data.unshift(end_frame || @num_frames.to_f) # 3. end frame
+        @data.unshift(start_frame || 0.0) # 2. start frame
         @data.unshift(@playback.output.num_channels.to_f) # 1. num_channels
-        @data.unshift(@playback.size.to_f) # 0. sample size
+        @data.unshift(@num_frames.to_f) # 0. frame set size (without metadata)
         @data
       end
 

data/lib/audio-playback/position.rb

@@ -0,0 +1,89 @@
+module AudioPlayback
+
+  # A time position in a sound
+  class Position
+
+    class InvalidTime < RuntimeError
+    end
+
+    extend Forwardable
+
+    UNITS = [
+      1, # second
+      60, # minute
+      3600 # hour
+    ].freeze
+
+    # Time format like (hh:)(mm:)ss(.ss)
+    FORMAT = /((\d+\:)(\d{2}\:)|(\d{2}\:))?\d{1,2}(\.\d+)?/.freeze
+
+    attr_reader :seconds
+    alias_method :to_seconds, :seconds
+    def_delegators :@seconds, :to_f
+
+    # @param [Numeric, String] seconds_or_time Time as (hh:)(mm:)ss(.ss)
+    def initialize(seconds_or_time)
+      seconds_or_time = seconds_or_time.to_s
+      validate_time(seconds_or_time)
+      populate(seconds_or_time)
+    end
+
+    # Multiply the seconds value of this Position by the given value
+    # @param [Numeric, Position] another
+    # @return [Float]
+    def *(another)
+      @seconds * another.to_f
+    end
+
+    # Add the seconds value of this Position to the given value
+    # @param [Numeric, Position] another
+    # @return [Float]
+    def +(another)
+      @seconds + another.to_f
+    end
+
+    private
+
+    # Validate that the time that was passed into the constructor is in the correct
+    # format. Raises InvalidTime error if not
+    # @param [Numeric, String] seconds_or_time Time as (hh:)(mm:)ss(.ss)
+    # @return [Boolean]
+    def validate_time(seconds_or_time)
+      unless seconds_or_time.match(FORMAT)
+        raise(InvalidTime)
+      end
+      true
+    end
+
+    # Validate that the segments of the time that was passed into the constructor
+    # are valid. For example that the minutes and or seconds values are below 60.
+    # Raises InvalidTime error if not
+    # @param [Array<String>] segments Time as [(hh), (mm), ss(.ss)]
+    # @return [Boolean]
+    def validate_segments(segments)
+      seconds = segments[0]
+      minutes = segments[1]
+      [seconds, minutes].compact.each do |segment|
+        if segment >= 60
+          raise(InvalidTime)
+        end
+      end
+      true
+    end
+
+    # Populate the seconds ivar using the time that was passed into the constructor
+    # @param [Numeric, String] seconds_or_time Time as (hh:)(mm:)ss(.ss)
+    # @return [Float]
+    def populate(seconds_or_time)
+      segments = seconds_or_time.split(":").map(&:to_f).reverse
+      validate_segments(segments)
+      @seconds = 0
+      segments.each_with_index do |segment, i|
+        @seconds += segment * UNITS[i]
+      end
+      @seconds
+    end
+
+  end
+
+end

data/test/device/output_test.rb

@@ -47,7 +47,7 @@ class AudioPlayback::Device::OutputTest < Minitest::Test
 
       should "populate id" do
         refute_nil @output.id
-        assert_kind_of Fixnum, @output.id
+        assert_kind_of Integer, @output.id
       end
 
       should "populate latency" do
@@ -57,7 +57,7 @@ class AudioPlayback::Device::OutputTest < Minitest::Test
 
       should "populate number of channels" do
         refute_nil @output.num_channels
-        assert_kind_of Fixnum, @output.num_channels
+        assert_kind_of Integer, @output.num_channels
       end
 
       should "populate name" do
@@ -115,7 +115,7 @@ class AudioPlayback::Device::OutputTest < Minitest::Test
 
       should "return correct num_channels" do
         refute_nil @output.num_channels
-        assert_kind_of Fixnum, @output.num_channels
+        assert_kind_of Integer, @output.num_channels
         assert_equal @test_info[:maxOutputChannels], @output.num_channels
       end
 
@@ -130,7 +130,7 @@ class AudioPlayback::Device::OutputTest < Minitest::Test
 
       should "return correct id" do
         refute_nil @output.id
-        assert_kind_of Fixnum, @output.id
+        assert_kind_of Integer, @output.id
         assert_equal @test_id, @output.id
       end
 

data/test/playback/stream_data_test.rb

@@ -4,20 +4,108 @@ class AudioPlayback::Playback::StreamDataTest < Minitest::Test
 
   context "StreamData" do
 
+    setup do
+      @path = "test/media/1-mono-44100.wav"
+      @file = AudioPlayback::File.new(@path)
+      @sound = AudioPlayback::Sound.new(@file)
+      @output = MockOutput.new(1, :num_channels => 1)
+      @playback = AudioPlayback::Playback.new(@sound, @output, :stream => MockStream.new(@output))
+    end
+
+    context "#add_metadata" do
+
+      setup do
+        @data = AudioPlayback::Playback::StreamData.new(@playback)
+      end
+
+      should "add default metadata" do
+        assert_equal 0.0, @data[AudioPlayback::Playback::METADATA.index(:is_eof)]
+        assert_equal 0.0, @data[AudioPlayback::Playback::METADATA.index(:start_frame)]
+        assert_equal 0.0, @data[AudioPlayback::Playback::METADATA.index(:pointer)]
+        assert_equal @data.num_frames.to_f, @data[AudioPlayback::Playback::METADATA.index(:end_frame)]
+        assert_equal @data.num_frames.to_f, @data[AudioPlayback::Playback::METADATA.index(:size)]
+        assert_equal @playback.output.num_channels.to_f, @data[AudioPlayback::Playback::METADATA.index(:num_channels)]
+      end
+
+    end
+
+    context "#set_metadata" do
+
+      setup do
+        @data = AudioPlayback::Playback::StreamData.new(@playback)
+
+        # Validate
+        @pointer_index = AudioPlayback::Playback::METADATA.index(:pointer)
+        @eof_index = AudioPlayback::Playback::METADATA.index(:is_eof)
+
+        assert_equal 0.0, @data[@pointer_index]
+        assert_equal 0.0, @data[@eof_index]
+
+        # Set metadata to non zero values
+        @data.send(:set_metadata, :pointer, 4.0)
+        @data.send(:set_metadata, :is_eof, 1.0)
+      end
+
+      should "change values" do
+        assert_equal 4.0, @data[@pointer_index]
+        assert_equal 1.0, @data[@eof_index]
+      end
+
+    end
+
+    context "#reset" do
+
+      setup do
+        @data = AudioPlayback::Playback::StreamData.new(@playback)
+
+        # Set metadata to non zero values
+        @data.send(:set_metadata, :pointer, 4.0)
+        @data.send(:set_metadata, :is_eof, 1.0)
+
+        # Validate metadata
+        indexes = [:pointer, :is_eof].map do |key|
+          AudioPlayback::Playback::METADATA.index(key)
+        end
+        @nonzero_values = indexes.map { |index| @data[index] }
+        assert @nonzero_values.all? { |value| value > 0.0 }
+
+        # Run reset
+        @data.reset
+
+        # Collect metadata
+        @reset_values = indexes.map { |index| @data[index] }
+      end
+
+      should "reset data" do
+        refute_empty @reset_values
+        assert @reset_values.all? { |value| value == 0.0 }
+      end
+
+    end
+
     context "#to_pointer" do
 
       setup do
-        @path = "test/media/1-mono-44100.wav"
-        @file = AudioPlayback::File.new(@path)
-        @sound = AudioPlayback::Sound.new(@file)
-        @output = MockOutput.new(1, :num_channels => 1)
-        @playback = AudioPlayback::Playback.new(@sound, @output, :stream => MockStream.new(@output))
-        @data = @playback.data
+        @data = AudioPlayback::Playback::StreamData.new(@playback)
+        @pointer = @data.to_pointer
+      end
+
+      should "return a ffi pointer" do
+        refute_nil @pointer
+        assert_kind_of FFI::Pointer, @pointer
+      end
+
+    end
+
+    context ".to_pointer" do
+
+      setup do
+        @pointer = AudioPlayback::Playback::StreamData.to_pointer(@playback)
       end
 
-      should "return a stream data object" do
-        refute_nil @data
-        assert_kind_of AudioPlayback::Playback::StreamData, @data
+      should "return a ffi pointer" do
+        refute_nil @pointer
+        assert_kind_of FFI::Pointer, @pointer
       end
 
     end

data/test/playback_test.rb

@@ -5,15 +5,225 @@ class AudioPlayback::PlaybackTest < Minitest::Test
   context "Playback" do
 
     setup do
-      @path = "test/media/1-mono-44100.wav"
+      @sample_rate = 44100
+      @path = "test/media/1-mono-#{@sample_rate}.wav"
       @sound = AudioPlayback::Sound.load(@path)
       @output = AudioPlayback::Device::Output.by_id(0)
     end
 
+    context "#initialize" do
+
+      context "with no truncation" do
+
+        setup do
+          @playback = AudioPlayback::Playback.new(@sound, @output)
+        end
+
+        should "have no truncation params" do
+          assert_nil @playback.truncate
+        end
+
+      end
+
+      context "with truncation" do
+
+        context "with seek only" do
+
+          setup do
+            @seek = 0.1
+            @playback = AudioPlayback::Playback.new(@sound, @output, seek: @seek)
+          end
+
+          should "have truncation params" do
+            refute_nil @playback.truncate
+            assert_kind_of Hash, @playback.truncate
+          end
+
+          should "have correct start frame value" do
+            refute_nil @playback.truncate[:start_frame]
+            assert_equal (@seek * @sample_rate).to_i, @playback.truncate[:start_frame]
+          end
+
+          should "have no duration value" do
+            assert_nil @playback.truncate[:end_frame]
+          end
+
+        end
+
+        context "with duration only" do
+
+          setup do
+            @duration = 0.2
+            @playback = AudioPlayback::Playback.new(@sound, @output, duration: @duration)
+          end
+
+          should "have truncation params" do
+            refute_nil @playback.truncate
+            assert_kind_of Hash, @playback.truncate
+          end
+
+          should "have no start frame value" do
+            assert_nil @playback.truncate[:start_frame]
+          end
+
+          should "have correct end frame value" do
+            refute_nil @playback.truncate[:end_frame]
+            assert_equal (@duration * @sample_rate).to_i, @playback.truncate[:end_frame]
+          end
+
+        end
+
+        context "with end position only" do
+
+          setup do
+            @end_position = 0.3
+            @playback = AudioPlayback::Playback.new(@sound, @output, end_position: @end_position)
+          end
+
+          should "have truncation params" do
+            refute_nil @playback.truncate
+            assert_kind_of Hash, @playback.truncate
+          end
+
+          should "have no start frame value" do
+            assert_nil @playback.truncate[:start_frame]
+          end
+
+          should "have correct end frame value" do
+            refute_nil @playback.truncate[:end_frame]
+            assert_equal (@end_position * @sample_rate).to_i, @playback.truncate[:end_frame]
+          end
+
+        end
+
+        context "with seek and duration" do
+
+          setup do
+            @seek = 0.4
+            @duration = 0.5
+            @playback = AudioPlayback::Playback.new(@sound, @output, seek: @seek, duration: @duration)
+          end
+
+          should "have truncation params" do
+            refute_nil @playback.truncate
+            assert_kind_of Hash, @playback.truncate
+          end
+
+          should "have correct start frame value" do
+            refute_nil @playback.truncate[:start_frame]
+            assert_equal (@seek * @sample_rate).to_i, @playback.truncate[:start_frame]
+          end
+
+          should "have correct end frame value" do
+            refute_nil @playback.truncate[:end_frame]
+            assert_equal ((@duration + @seek) * @sample_rate).to_i, @playback.truncate[:end_frame]
+          end
+
+        end
+
+        context "with seek and end position" do
+
+          context "valid" do
+
+            setup do
+              @seek = 0.4
+              @end_position = 0.5
+              @playback = AudioPlayback::Playback.new(@sound, @output, seek: @seek, end_position: @end_position)
+            end
+
+            should "have truncation params" do
+              refute_nil @playback.truncate
+              assert_kind_of Hash, @playback.truncate
+            end
+
+            should "have correct start frame value" do
+              refute_nil @playback.truncate[:start_frame]
+              assert_equal (@seek * @sample_rate).to_i, @playback.truncate[:start_frame]
+            end
+
+            should "have correct end frame value" do
+              refute_nil @playback.truncate[:end_frame]
+              assert_equal (@end_position * @sample_rate).to_i, @playback.truncate[:end_frame]
+            end
+
+          end
+
+          context "invalid" do
+
+            setup do
+              @seek = 0.7
+              @end_position = 0.6
+            end
+
+            should "raise exception" do
+              assert_raises AudioPlayback::Playback::InvalidTruncation do
+                @playback = AudioPlayback::Playback.new(@sound, @output, seek: @seek, end_position: @end_position)
+              end
+            end
+
+          end
+
+        end
+
+        context "with duration and end position" do
+
+          setup do
+            @duration = 0.8
+            @end_position = 0.9
+            @playback = AudioPlayback::Playback.new(@sound, @output, duration: @duration, end_position: @end_position)
+          end
+
+          should "have truncation params" do
+            refute_nil @playback.truncate
+            assert_kind_of Hash, @playback.truncate
+          end
+
+          should "have no start frame value" do
+            assert_nil @playback.truncate[:start_frame]
+          end
+
+          should "ignore end_position, use duration" do
+            refute_nil @playback.truncate[:end_frame]
+            assert_equal (@duration * @sample_rate).to_i, @playback.truncate[:end_frame]
+          end
+
+        end
+
+        context "with seek, duration and end position" do
+
+          setup do
+            @duration = 1.0
+            @seek = 1.1
+            @end_position = 1.2
+            @playback = AudioPlayback::Playback.new(@sound, @output, seek: @seek, duration: @duration, end_position: @end_position)
+          end
+
+          should "have truncation params" do
+            refute_nil @playback.truncate
+            assert_kind_of Hash, @playback.truncate
+          end
+
+          should "have correct start frame value" do
+            refute_nil @playback.truncate[:start_frame]
+            assert_equal (@seek * @sample_rate).to_i, @playback.truncate[:start_frame]
+          end
+
+          should "ignore end_position, use duration" do
+            refute_nil @playback.truncate[:end_frame]
+            assert_equal ((@duration + @seek) * @sample_rate).to_i, @playback.truncate[:end_frame]
+          end
+
+        end
+
+      end
+
+    end
+
     context ".play" do
 
       setup do
         AudioPlayback::Device::Stream.any_instance.expects(:start).once.returns(true)
+        @playback = AudioPlayback::Playback.play(@sound, @output)
       end
 
       teardown do
@@ -21,11 +231,14 @@ class AudioPlayback::PlaybackTest < Minitest::Test
       end
 
       should "start playback" do
-        @playback = AudioPlayback::Playback.play(@sound, @output)
         refute_nil @playback
         assert_kind_of AudioPlayback::Playback::Action, @playback
       end
 
+      should "not have truncation params" do
+        assert_nil @playback.truncate
+      end
+
     end
 
     context "#start" do
@@ -81,6 +294,49 @@ class AudioPlayback::PlaybackTest < Minitest::Test
 
     end
 
+    context "#number_of_seconds_to_number_of_frames" do
+
+      setup do
+        @playback = AudioPlayback::Playback.new(@sound, @output)
+      end
+
+      should "convert seconds to frames" do
+        assert_equal 3 * 44100, @playback.send(:number_of_seconds_to_number_of_frames, 3)
+        assert_equal 10 * 44100, @playback.send(:number_of_seconds_to_number_of_frames, 10)
+        assert_equal 30 * 44100, @playback.send(:number_of_seconds_to_number_of_frames, 30)
+        assert_equal 5000 * 44100, @playback.send(:number_of_seconds_to_number_of_frames, 5000)
+      end
+
+    end
+
+    context "#truncate_requested?" do
+
+      context "with truncation" do
+
+        setup do
+          @playback = AudioPlayback::Playback.new(@sound, @output)
+        end
+
+        should "have truncation params" do
+          assert @playback.send(:truncate_requested?, seek: 3, duration: 2)
+        end
+
+      end
+
+      context "without truncation" do
+
+        setup do
+          @playback = AudioPlayback::Playback.new(@sound, @output)
+        end
+
+        should "have truncation params" do
+          refute @playback.send(:truncate_requested?, {})
+        end
+
+      end
+
+    end
+
     context "#data_size" do
 
       setup do