seal 0.1.0

data/mpg123/src/xfermem.h

@@ -0,0 +1,74 @@
+/*
+	xfermem: unidirectional fast pipe
+
+	copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Oliver Fromme
+	old timestamp: Sat Mar 29 04:41:34 MET 1997
+
+	This is a stand-alone module which implements a unidirectional,
+	fast pipe using mmap().  Its primary use is to transfer large
+	amounts of data from a parent process to its child process,
+	with a buffer in between which decouples blocking conditions
+	on both sides.  Control information is transferred between the
+	processes through a socketpair.  See xftest.c for an example on
+	how to use this module.
+
+	note: xftest not there anymore
+*/
+
+#ifndef _XFERMEM_H_
+#define _XFERMEM_H_
+
+#ifndef TRUE
+#define FALSE 0
+#define TRUE  1
+#endif
+
+typedef struct {
+	size_t freeindex;	/* [W] next free index */
+	size_t readindex;	/* [R] next index to read */
+	int fd[2];
+	int wakeme[2];
+	byte *data;
+	byte *metadata;
+	size_t size;
+	size_t metasize;
+	long rate;
+	int  channels;
+	int  format;
+	int justwait;
+} txfermem;
+/*
+ *   [W] -- May be written to by the writing process only!
+ *   [R] -- May be written to by the reading process only!
+ *   All other entries are initialized once.
+ */
+
+void xfermem_init (txfermem **xf, size_t bufsize, size_t msize, size_t skipbuf);
+void xfermem_init_writer (txfermem *xf);
+void xfermem_init_reader (txfermem *xf);
+
+size_t xfermem_get_freespace (txfermem *xf);
+size_t xfermem_get_usedspace (txfermem *xf);
+#define XF_CMD_WAKEUP_INFO  0x04
+#define XF_CMD_WAKEUP    0x02
+#define XF_CMD_TERMINATE 0x03
+#define XF_CMD_AUDIOCAP  0x05
+#define XF_CMD_RESYNC    0x06
+#define XF_CMD_ABORT     0x07
+#define XF_WRITER 0
+#define XF_READER 1
+int xfermem_getcmd (int fd, int block);
+int xfermem_putcmd (int fd, byte cmd);
+int xfermem_block (int fd, txfermem *xf);
+int xfermem_sigblock (int fd, txfermem *xf, int pid, int signal);
+/* returns TRUE for being interrupted */
+int xfermem_write(txfermem *xf, byte *buffer, size_t bytes);
+
+void xfermem_done (txfermem *xf);
+#define xfermem_done_writer xfermem_init_reader
+#define xfermem_done_reader xfermem_init_writer
+
+
+#endif 

data/mpg123/windows-builds.sh

@@ -0,0 +1,137 @@
+#!/bin/sh
+
+# A dirty script to create some windows binaries (shared, static, debug, ...) using the MSYS environment.
+
+# give build type as command line argument
+# x86 or x86_64-cross
+build_type=$1
+test -z "$build_type" && build_type=x86
+
+echo "build type: $build_type"
+case $build_type in
+  x86)
+    decoder=x86
+    strip=strip
+    hostopt=
+  ;;
+  x86_64-cross)
+    decoder=x86-64
+    strip=x86_64-w64-mingw32-strip
+    hostopt="--host=x86_64-w64-mingw32 --build=`./build/config.guess`"
+  ;;
+  *)
+    echo "Unknown build type!"
+    exit 1
+  ;;
+esac
+
+temp="$PWD/tmp"
+final="$PWD/releases"
+txt="README COPYING NEWS"
+# let's try with modules
+opts=""
+#opts="--with-audio=win32 --disable-modules"
+
+# Get the version for the build from configure.ac .
+version=`sed -n 's/^AC_INIT([^,]*, \[\([^,]*\)\], .*$/\1/p' < configure.ac`
+echo "Building binaries for version $version"
+
+prepare_dir()
+{
+	test -e "$final" || mkdir "$final"
+}
+
+prepare_unix2dos()
+{
+	echo "preparing unix2dos tool"
+	# I'll include documentation in DOS-style, with the help of this little unix2dos variant.
+	test -x "unix2dos" || echo "
+#include <unistd.h>
+#include <stdio.h>
+int main()
+{
+	char buf[1000];
+	ssize_t got;
+	while((got=read(0, buf, 1000))>0)
+	{
+		ssize_t end=0;
+		ssize_t pos=0;
+		for(end=0;end<got;++end)
+		{
+			if(buf[end] == '\n')
+			{
+				write(1, buf+pos, end-pos);
+				write(1, \"\r\n\", 2);
+				pos=end+1;
+			}
+		}
+		write(1, buf+pos, end-pos);
+	}
+}" > unix2dos.c && gcc -O -o unix2dos unix2dos.c
+}
+
+mpg123_build()
+{
+	cpu=$1
+	stat=$2
+	debug=$3
+	myopts=$opts
+	if test "$stat" = "y"; then
+		echo "static build (stat=$stat)" &&
+		name=mpg123-$version-static-$cpu
+		myopts="$myopts --disable-shared"
+	else
+		echo "dynamic build (stat=$stat)" &&
+		name=mpg123-$version-$cpu
+	fi &&
+	if test "$debug" = "y"; then
+		echo "Debugging build!"
+		name=$name-debug
+		myopts="$myopts --enable-debug"
+	fi &&
+	tmp=$temp-$name &&
+	echo "REMOVING $tmp!" &&
+	sleep 5 &&
+	if test -e Makefile; then make clean; fi &&
+	rm -rvf $tmp &&
+	./configure $hostopt --prefix=$tmp --with-module-suffix=.dll $myopts --with-cpu=$cpu && make && make install &&
+	rm -rf "$final/$name" &&
+	mkdir  "$final/$name" &&
+	cp -v "$tmp/bin/mpg123.exe" "$final/$name" &&
+	if test "$debug" = y; then
+		echo "Not stripping the debug build..."
+	else
+		$strip --strip-unneeded "$final/$name/"*.exe
+	fi &&
+	if test "$stat" = "y"; then
+		echo "No DLL there..."
+	else
+		cp -v "$tmp/bin/libmpg123"*.dll "$tmp/include/mpg123.h" "$final/$name" &&
+		cp -v "src/libmpg123/.libs/libmpg123"*.dll.def "$final/$name" &&
+		if test "$debug" = y; then
+			echo "Not stripping the debug build..."
+		else
+			$strip --strip-unneeded "$final/$name/"*.dll || exit 1
+		fi
+		for i in $tmp/lib/mpg123/*.dll
+		do
+			if test -e "$i"; then
+				plugdir="$final/$name/plugins"
+				mkdir -p "$plugdir" &&
+				cp -v "$i" "$plugdir"
+			fi
+		done
+	fi &&
+	for i in $txt
+	do
+		echo "text file $i -> $final/$name/$i.txt"
+		./unix2dos < "$i" > "$final/$name/$i.txt"
+	done
+}
+
+prepare_dir &&
+prepare_unix2dos &&
+mpg123_build $decoder y n &&
+mpg123_build $decoder n n &&
+mpg123_build $decoder n y &&
+echo "Hurray! Note: Please do not forget to copy the libltdl DLL from MSYS to the dynamic build directories... " || echo "Bleh..."

data/spec/seal/buffer_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Buffer do
+  it_behaves_like 'an audio object with format'
+
+  describe 'size after reading' do
+    context 'from the WAVE file' do
+      subject { Buffer.new(WAV_PATH) }
+      its(:size) { should eq 2250 }
+    end
+
+    context 'from the Ogg Vorbise file' do
+      subject { Buffer.new(OV_PATH) }
+      its(:size) { should eq 85342 }
+    end
+  end
+
+  it 'cannot be changed if it is being used by a source' do
+    error_pattern = /Invalid operation/
+    source = Source.new
+    another_source = Source.new
+    buffer = Buffer.new(WAV_PATH)
+
+    source.buffer = buffer
+    another_source.buffer = buffer
+    # Being used by two sources.
+    expect { buffer.load(WAV_PATH) }.to raise_error error_pattern
+
+    source.buffer = nil
+    # Still being used by one more source.
+    expect { buffer.load(WAV_PATH) }.to raise_error error_pattern
+
+    another_source.buffer = nil
+    # Not being used by any source.
+    expect { buffer.load(WAV_PATH) }.to_not raise_error
+  end
+end

data/spec/seal/core_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Seal do
+  it 'should initialize and finalize correctly on default device' do
+    expect do
+      Seal.startup
+      Seal.cleanup
+    end.to_not raise_error
+  end
+
+  it 'should fail when trying to initialize non-existing device' do
+    expect { Seal.startup 'foo42' }.to raise_error SealError
+  end
+
+  it 'has only one instance of Listener' do
+    Seal.listener.should be Seal.listener
+    Seal.listener.should be_a Listener
+    expect { Seal::Listener.new }.to raise_error NoMethodError
+    expect { Seal::Listener.allocate }.to raise_error TypeError
+  end
+
+  it 'defines a limit on the number of effect slots per source' do
+    Seal.per_source_effect_limit.should be_an Integer
+  end
+
+  it 'defines a version string' do
+    Seal::VERSION.should match /\d\.\d\.\d/
+  end
+end

data/spec/seal/effect_slot_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe EffectSlot do
+  before(:each) { GC.start }
+
+  describe 'by default' do
+    its(:auto?) { should be_true }
+    its(:effect) { should be_nil }
+    its(:gain) { should eq 1.0 }
+  end
+
+  it_validates 'the boolean attribute', :auto
+  it_validates 'the float attribute', :gain, "[0, 1]"
+
+  it 'can initialize with an effect' do
+    reverb = Reverb.new
+    effect_slot = EffectSlot.new(reverb)
+    effect_slot.effect.should be reverb
+  end
+
+  it 'can set an effect' do
+    effect_slot = subject
+    reverb = Reverb.new
+    effect_slot.effect = reverb
+    effect_slot.effect.should be reverb
+  end
+
+  it 'has a limited number of sources it can feed concurrently' do
+    effect_slot = subject
+    sources = []
+    Seal.per_source_effect_limit.times do |i|
+      sources << Source.new
+      effect_slot.feed(i, sources[-1])
+    end
+    expect { effect_slot.feed(sources.size, Source.new) }.to raise_error \
+      /Invalid parameter value/
+  end
+end

data/spec/seal/listener_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Listener do
+  subject { LISTENER }
+
+  it_behaves_like 'a movable object'
+
+  describe 'by default' do
+    its(:gain) { should eq 1.0 }
+    its(:orientation) { should eq [[0, 0, -1], [0, 1, 0]] }
+  end
+
+  it 'can change its orientation' do
+    old_orientation = LISTENER.orientation
+    LISTENER.orientation = [0, 1, 0], [3, 0, 0]
+    LISTENER.orientation[0].should eq [0, 1, 0]
+    LISTENER.orientation[1].should eq [3, 0, 0]
+    LISTENER.orientation = old_orientation
+  end
+
+  it "validates the float attribute 'gain' is in [0, +inf.)" do
+    old_gain = LISTENER.gain
+    LISTENER.gain = 0.34767
+    LISTENER.gain.should be_within(TOLERANCE).of 0.34767
+    LISTENER.gain = 10
+    error_pattern = /Invalid parameter value/
+    expect { LISTENER.gain = -0.1 }.to raise_error error_pattern
+    expect { LISTENER.gain = -1.3 }.to raise_error error_pattern
+    expect { LISTENER.gain = -3203 }.to raise_error error_pattern
+    LISTENER.gain.should eq 10
+    LISTENER.gain = old_gain
+  end
+end

data/spec/seal/reverb_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Reverb do
+  describe 'by default' do
+    its(:air_absorbtion_hfgain) { should be_within(TOLERANCE).of 0.994 }
+    its(:decay_time) { should be_within(TOLERANCE).of 1.49 }
+    its(:diffusion) { should be_within(TOLERANCE).of 1.0 }
+    its(:density) { should be_within(TOLERANCE).of 1.0 }
+    its(:gain) { should be_within(TOLERANCE).of 0.32 }
+    its(:hfdecay_limited?) { should be_true }
+    its(:hfdecay_ratio) { should be_within(TOLERANCE).of 0.83 }
+    its(:hfgain) { should be_within(TOLERANCE).of 0.89 }
+    its(:late_delay) { should be_within(TOLERANCE).of 0.011 }
+    its(:late_gain) { should be_within(TOLERANCE).of 1.26 }
+    its(:reflections_delay) { should be_within(TOLERANCE).of 0.007 }
+    its(:reflections_gain) { should be_within(TOLERANCE).of 0.05 }
+    its(:room_rolloff_factor) { should be_within(TOLERANCE).of 0 }
+  end
+
+  it_validates 'the boolean attribute', :hfdecay_limited
+  it_validates 'the float attribute', :air_absorbtion_hfgain, '[0.892, 1]'
+  it_validates 'the float attribute', :decay_time, '[0.1, 20]'
+  it_validates 'the float attribute', :density, '[0, 1]'
+  it_validates 'the float attribute', :diffusion, '[0, 1]'
+  it_validates 'the float attribute', :gain, '[0, 1]'
+  it_validates 'the float attribute', :hfdecay_ratio, '[0.1, 2]'
+  it_validates 'the float attribute', :hfgain, '[0, 1]'
+  it_validates 'the float attribute', :late_delay, '[0, 0.1]'
+  it_validates 'the float attribute', :late_gain, '[0, 10]'
+  it_validates 'the float attribute', :reflections_delay, '[0, 0.3]'
+  it_validates 'the float attribute', :reflections_gain, '[0, 3.16]'
+  it_validates 'the float attribute', :room_rolloff_factor, '[0, 10]'
+
+  it 'can load different reverb presets' do
+    test_load_presets = -> a_module do
+      a_module.constants.each do |const_sym|
+        constant = a_module.const_get const_sym
+        case constant
+        when Module
+          test_load_presets.call(constant)
+        else
+          expect do
+            reverb = Reverb.new(constant)
+            reverb.load(constant)
+          end.to_not raise_error
+        end
+      end
+    end
+    test_load_presets.call(Reverb::Preset)
+  end
+end

data/spec/seal/source_spec.rb

@@ -0,0 +1,370 @@
+require 'spec_helper'
+
+include Source::State
+include Source::Type
+
+describe Source do
+  let(:source) { Source.new }
+  let(:stream) { Stream.new(WAV_PATH) }
+  let(:buffer) { Buffer.new(WAV_PATH) }
+
+  it_behaves_like 'a movable object'
+
+  describe 'by default' do
+    its(:auto?) { should be_true }
+    its(:buffer) { should be_nil }
+    its(:chunk_size) { should eq 36864 }
+    its(:gain) { should be_within(TOLERANCE).of(1.0) }
+    its(:looping) { should be_false }
+    its(:pitch) { should be_within(TOLERANCE).of(1.0) }
+    its(:queue_size) { should eq 3 }
+    its(:relative) { should be_false }
+    its(:state) { should be INITIAL }
+    its(:stream) { should be_nil }
+    its (:type) { should be UNDETERMINED }
+  end
+
+  it_validates 'the boolean attribute', :relative
+  it_validates 'the boolean attribute', :auto
+  it_validates 'the float attribute', :pitch, "[0, +inf.)"
+  it_validates 'the float attribute', :gain, "[0, +inf.)"
+
+  it 'validates its queue size is in [2, 63]' do
+    error_pattern = /Invalid parameter value/
+    expect { source.queue_size = -130 }.to raise_error error_pattern
+    expect { source.queue_size = 0 }.to raise_error error_pattern
+    expect { source.queue_size = 1 }.to raise_error error_pattern
+    source.queue_size = 2
+    source.queue_size.should eq 2
+    source.queue_size = 32
+    source.queue_size.should eq 32
+    source.queue_size = 63
+    source.queue_size.should eq 63
+    expect { source.queue_size = 64 }.to raise_error error_pattern
+    expect { source.queue_size = 1203 }.to raise_error error_pattern
+    source.queue_size.should eq 63
+  end
+
+  it 'validates it has an auto-adjusting chunk size in [9216, 16773120]' do
+    error_pattern = /Invalid parameter value/
+    expect { source.chunk_size = 0 }.to raise_error error_pattern
+    expect { source.chunk_size = 432 }.to raise_error error_pattern
+    expect { source.chunk_size = 9215 }.to raise_error error_pattern
+    source.chunk_size = 9216
+    source.chunk_size.should eq 9216
+    # It should be automatically adjusted to a smaller multiple of 9216.
+    source.chunk_size = 9217
+    source.chunk_size.should eq 9216
+    source.chunk_size = 32768
+    source.chunk_size.should eq 27648
+    source.chunk_size = 294912
+    source.chunk_size.should eq 294912
+    source.chunk_size = 16773119
+    source.chunk_size.should eq 16763904
+    source.chunk_size = 16773120
+    source.chunk_size.should eq 16773120
+    expect { source.chunk_size = 16773121 }.to raise_error error_pattern
+    expect { source.chunk_size = 234923428 }.to raise_error error_pattern
+  end
+
+  context 'with a buffer' do
+    before(:each) { source.buffer = buffer }
+
+    it 'cannot also have a stream unless buffer is detached' do
+      error_pattern = /attach a stream to a static source/
+      expect { source.stream = stream }.to raise_error error_pattern
+      source.play
+      expect { source.stream = stream }.to raise_error error_pattern
+      source.pause
+      expect { source.stream = stream }.to raise_error error_pattern
+      source.stop
+      expect { source.stream = stream }.to raise_error error_pattern
+      source.buffer = nil
+      expect { source.stream = stream }.to_not raise_error
+    end
+
+    it 'cannot change its buffer while playing' do
+      source.play
+      expect { source.buffer = buffer }.to raise_error /Invalid operation/
+    end
+
+    it 'cannot change its buffer while paused' do
+      source.play
+      source.pause
+      expect { source.buffer = buffer }.to raise_error /Invalid operation/
+    end
+
+    it 'can change its buffer while stopped' do
+      source.play
+      source.stop
+      expect { source.buffer = buffer }.to_not raise_error
+    end
+
+    it 'can change its buffer while in initial state' do
+      expect { source.buffer = buffer }.to_not raise_error
+    end
+
+    it 'can share its buffer' do
+      expect do
+        another_source = Source.new
+        another_source.buffer = source.buffer
+        another_source.play
+        source.play
+      end.to_not raise_error
+    end
+  end
+
+  context 'with a stream' do
+    let(:another_stream) { Stream.new(WAV_PATH) }
+
+    before(:each) { source.stream = stream }
+
+    it 'can set the same stream to itself' do
+      expect { source.stream = stream }.to_not raise_error
+    end
+
+    it 'cannot also have a buffer unless stream is detached' do
+      error_pattern = /attach a buffer to a streaming source/
+      expect { source.buffer = buffer }.to raise_error error_pattern
+      source.play
+      expect { source.buffer = buffer }.to raise_error error_pattern
+      source.pause
+      expect { source.buffer = buffer }.to raise_error error_pattern
+      source.stop
+      expect { source.buffer = buffer }.to raise_error error_pattern
+      source.stream = nil
+      expect { source.buffer = buffer }.to_not raise_error
+    end
+
+    it 'cannot have a closed stream' do
+      another_stream.close
+      expect { source.stream = another_stream }.to raise_error \
+        /uninitialized stream/
+    end
+
+    it 'can only change its stream to one with compatible format' do
+      expect { source.stream = another_stream }.to_not raise_error
+      expect { source.stream = Stream.new(OV_PATH) }.to raise_error \
+        /different audio format/
+    end
+
+    it 'can change to another stream in any state' do
+      expect do
+        source.stream = another_stream
+        source.play
+        source.stream = another_stream
+        source.pause
+        source.stream = another_stream
+        source.stop
+        source.stream = another_stream
+      end.to_not raise_error
+    end
+
+    it 'can share its stream' do
+      expect do
+        another_source = Source.new
+        another_source.stream = stream
+        another_source.play
+        source.play
+        source.stream = another_stream
+        another_source.stream = another_stream
+      end.to_not raise_error
+    end
+
+    it 'fails to perform if stream is closed' do
+      error_pattern = /uninitialized stream/
+      stream.close
+      expect { source.update }.to raise_error error_pattern
+      expect { source.stop }.to raise_error error_pattern
+      expect { source.play }.to raise_error error_pattern
+    end
+  end
+
+  describe 'automatic streaming' do
+    let(:source) do
+      Source.new.tap do |source|
+        source.stream = Stream.new(OV_PATH)
+        source.looping = true
+        source.pitch = 3
+      end
+    end
+
+    it 'continues in the background' do
+      source.play
+      sleep(0.5)
+      source.state.should be PLAYING
+    end
+
+    it 'can be disabled (taking effect upon the next play call)' do
+      source.play
+      source.auto = false
+      sleep(0.5)
+      # Not stopping streaming until the next play call.
+      source.state.should be PLAYING
+      source.play
+      sleep(0.5)
+      source.state.should be STOPPED
+    end
+  end
+
+  describe 'looping' do
+    example 'as undetermined type' do
+      source.looping?.should be_false
+      source.looping = true
+      source.looping.should be_true
+      source.looping = false
+      source.looping?.should be_false
+    end
+
+    example 'as streaming type' do
+      source.looping = true
+      source.stream = stream
+      source.looping?.should be_true
+      source.looping = false
+      source.looping?.should be_false
+      source.looping = true
+      source.looping?.should be_true
+    end
+
+    example 'as static type' do
+      source.looping = true
+      source.buffer = buffer
+      source.looping?.should be_true
+      source.looping = false
+      source.looping?.should be_false
+      source.looping = true
+      source.looping?.should be_true
+    end
+
+    # This example depends on the length of the test audio file.
+    it 'is true if and only if source repeats' do
+      source.stream = stream
+      source.pitch = 2
+      source.play
+      sleep(0.3)
+      source.state.should be STOPPED
+      source.looping = true
+      source.play
+      sleep(0.3)
+      source.state.should be PLAYING
+    end
+  end
+
+  describe 'type' do
+    it 'should initially be undetermined' do
+      source.type.should be UNDETERMINED
+    end
+
+    it 'should be streaming if it has a stream' do
+      source.stream = stream
+      source.type.should be STREAMING
+    end
+
+    it 'should be static if it has a buffer' do
+      source.buffer = buffer
+      source.type.should be STATIC
+    end
+
+    it 'should be undetermined after detaching' do
+      source.stream = stream
+      source.stream = nil
+      source.type.should be UNDETERMINED
+      source.buffer = buffer
+      source.buffer = nil
+      source.type.should be UNDETERMINED
+    end
+  end
+
+  describe 'state transition' do
+    before :each do
+      source.tap { |source| source.stream = stream }
+    end
+
+    example 'from initial state' do
+      source.state.should be INITIAL
+      source.stop
+      source.state.should be INITIAL
+      source.pause
+      source.state.should be INITIAL
+      source.rewind
+      source.state.should be INITIAL
+      source.play
+      source.state.should be PLAYING
+    end
+
+    example 'from playing state' do
+      source.play
+      source.state.should be PLAYING
+      source.rewind
+      source.state.should be INITIAL
+      source.play
+      source.stop
+      source.state.should be STOPPED
+      source.play
+      source.pause
+      source.state.should be PAUSED
+      source.play
+      source.play
+      source.state.should be PLAYING
+    end
+
+    example 'from paused state' do
+      source.play
+      source.pause
+      source.state.should be PAUSED
+      source.play
+      source.state.should be PLAYING
+      source.pause
+      source.rewind
+      source.state.should be INITIAL
+      source.play
+      source.pause
+      source.stop
+      source.state.should be STOPPED
+    end
+
+    example 'from stopped state' do
+      source.play
+      source.stop
+      source.state.should be STOPPED
+      source.pause
+      source.state.should be STOPPED
+      source.play
+      source.state.should be PLAYING
+      source.stop
+      source.rewind
+      source.state.should be INITIAL
+    end
+
+    context 'when detaching' do
+      example 'from initial state' do
+        source.state.should be INITIAL
+        source.stream = nil
+        source.state.should be INITIAL
+      end
+
+      example 'from playing state' do
+        source.play
+        source.state.should be PLAYING
+        source.stream = nil
+        source.state.should be INITIAL
+      end
+
+      example 'from paused state' do
+        source.play
+        source.pause
+        source.state.should be PAUSED
+        source.stream = nil
+        source.state.should be INITIAL
+      end
+
+      example 'from stopped state' do
+        source.play
+        source.stop
+        source.state.should be STOPPED
+        source.stream = nil
+        source.state.should be INITIAL
+      end
+    end
+  end
+end