lame 0.0.1 → 0.0.2

data/spec/encoding/interleaved_buffer_encoder_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module LAME
+  module Encoding
+
+    shared_examples_for "a interleaved buffer encoder" do
+      # stubbing galore!
+
+      let(:framesize) { 1152 }
+      let(:samples) { stub(:size => framesize*2) }
+      let(:global_flags) { stub }
+      let(:configuration) { stub(Configuration, :global_flags => global_flags, :framesize => framesize, :output_buffer_size => 8640) }
+
+      subject(:encoder) { described_class.new(configuration) }
+
+      it "creates input buffers" do
+        LAME.stub(lame_function).and_return(0)
+
+        Buffer.should_receive(:create).with(data_type, samples)
+
+        encoder.encode_frame(samples)
+      end
+
+      it "creates output buffer" do
+        LAME.stub(lame_function).and_return(0)
+
+        Buffer.stub(:create)
+        Buffer.should_receive(:create_empty).with(:uchar, 8640).and_return(stub.as_null_object)
+
+        encoder.encode_frame(samples)
+      end
+
+      it "encodes the input" do
+        samples_stub = stub("samples")
+        output_stub = stub("output", :get_bytes => [])
+
+        Buffer.stub(:create).with(data_type, samples).and_return(samples_stub)
+        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output_stub)
+
+        LAME.should_receive(lame_function) do |flags, interleaved_buffer, framesize, output, output_size|
+          flags.should               eql global_flags
+          interleaved_buffer.should  eql samples_stub
+          framesize.should           eql 1152
+          output.should              eql output_stub
+          output_size.should         eql 8640
+
+          0 # return value
+        end
+
+        encoder.encode_frame(samples)
+      end
+
+      it "returns the encoded data" do
+        LAME.stub(lame_function).and_return(512)
+
+        mp3_data = stub
+        output = stub
+        output.stub(:get_bytes).with(0, 512).and_return(mp3_data)
+
+        Buffer.stub(:create)
+        Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output)
+
+        encoder.encode_frame(samples).should eql mp3_data
+      end
+    end
+
+    describe InterleavedShortBufferEncoder do
+      it_should_behave_like "a interleaved buffer encoder" do
+        let(:data_type) { :short }
+        let(:lame_function) { :lame_encode_buffer_interleaved }
+      end
+    end
+
+    describe InterleavedFloatBufferEncoder do
+      it_should_behave_like "a interleaved buffer encoder" do
+        let(:data_type) { :float }
+        let(:lame_function) { :lame_encode_buffer_interleaved_ieee_float }
+      end
+    end
+  end
+end

data/spec/encoding/{encode_short_buffer_spec.rb → stereo_buffer_encoder_spec.rb}

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module LAME
   module Encoding
-    describe EncodeShortBuffer do
 
+    shared_examples_for "a stereo buffer encoder" do
       # stubbing galore!
 
       let(:framesize) { 1152 }
@@ -12,19 +12,19 @@ module LAME
       let(:global_flags) { stub }
       let(:configuration) { stub(Configuration, :global_flags => global_flags, :framesize => framesize, :output_buffer_size => 8640) }
 
-      subject(:encoder) { EncodeShortBuffer.new(configuration) }
+      subject(:encoder) { described_class.new(configuration) }
 
       it "creates input buffers" do
-        LAME.stub(:lame_encode_buffer).and_return(0)
+        LAME.stub(lame_function).and_return(0)
 
-        Buffer.should_receive(:create).with(:short, left)
-        Buffer.should_receive(:create).with(:short, right)
+        Buffer.should_receive(:create).with(data_type, left)
+        Buffer.should_receive(:create).with(data_type, right)
 
         encoder.encode_frame(left, right)
       end
 
       it "creates output buffer" do
-        LAME.stub(:lame_encode_buffer).and_return(0)
+        LAME.stub(lame_function).and_return(0)
 
         Buffer.stub(:create)
         Buffer.should_receive(:create_empty).with(:uchar, 8640).and_return(stub.as_null_object)
@@ -37,11 +37,11 @@ module LAME
         right_stub = stub("right")
         output_stub = stub("output", :get_bytes => [])
 
-        Buffer.stub(:create).with(:short, left).and_return(left_stub)
-        Buffer.stub(:create).with(:short, right).and_return(right_stub)
+        Buffer.stub(:create).with(data_type, left).and_return(left_stub)
+        Buffer.stub(:create).with(data_type, right).and_return(right_stub)
         Buffer.stub(:create_empty).with(:uchar, 8640).and_return(output_stub)
 
-        LAME.should_receive(:lame_encode_buffer) do |flags, left_buffer, right_buffer, framesize, output, output_size|
+        LAME.should_receive(lame_function) do |flags, left_buffer, right_buffer, framesize, output, output_size|
           flags.should        eql global_flags
           left_buffer.should  eql left_stub
           right_buffer.should eql right_stub
@@ -56,7 +56,7 @@ module LAME
       end
 
       it "returns the encoded data" do
-        LAME.stub(:lame_encode_buffer).and_return(512)
+        LAME.stub(lame_function).and_return(512)
 
         mp3_data = stub
         output = stub
@@ -68,5 +68,26 @@ module LAME
         encoder.encode_frame(left, right).should eql mp3_data
       end
     end
+
+    describe ShortBufferEncoder do
+      it_should_behave_like "a stereo buffer encoder" do
+        let(:data_type) { :short }
+        let(:lame_function) { :lame_encode_buffer }
+      end
+    end
+
+    describe FloatBufferEncoder do
+      it_should_behave_like "a stereo buffer encoder" do
+        let(:data_type) { :float }
+        let(:lame_function) { :lame_encode_buffer_ieee_float }
+      end
+    end
+
+    describe LongBufferEncoder do
+      it_should_behave_like "a stereo buffer encoder" do
+        let(:data_type) { :long }
+        let(:lame_function) { :lame_encode_buffer_long2 }
+      end
+    end
   end
 end

data/spec/integration/decoding_spec.rb

@@ -10,8 +10,9 @@ describe "Decoding", :slow => true do
     decoder = LAME::Decoder.new(mp3_file)
 
     format = WaveFile::Format.new(decoder.channel_mode, :pcm_16, decoder.sample_rate)
+    output = Tempfile.new('output.wav')
 
-    WaveFile::Writer.new("output1.wav", format) do |writer|
+    WaveFile::Writer.new(output.path, format) do |writer|
 
       decoder.each_decoded_frame do |decoded_frame|
         buffer = WaveFile::Buffer.new(decoded_frame.samples, format)
@@ -57,9 +58,11 @@ describe "Decoding", :slow => true do
       puts "framenum:    #{@mp3_data[:framenum]}"
     end
 
+    output = Tempfile.new('output.wav')
+
     # read mp3_data (number of frames etc)
     format = WaveFile::Format.new(:stereo, :pcm_16, 44100)
-    WaveFile::Writer.new("output2.wav", format) do |writer|
+    WaveFile::Writer.new(output.path, format) do |writer|
 
       # See get_audio.c:2082 #lame_decode_fromfile
       #

data/spec/integration/encoding_spec.rb

@@ -4,12 +4,65 @@ require 'wavefile'
 
 describe "Encoding", :slow => true do
 
-  let(:wav_path) { File.expand_path(File.join(File.dirname(__FILE__), '../files/dies-irae.wav')) }
-  let(:mp3_path_raw) { File.expand_path(File.join(File.dirname(__FILE__), '../files/dies-irae-raw.mp3')) }
-  let(:mp3_path_api) { File.expand_path(File.join(File.dirname(__FILE__), '../files/dies-irae-api.mp3')) }
+  let(:wav_file) { WaveFileGenerator.new(:length => 2).generate }
+  let(:wav_path) { wav_file.path }
+  let(:mp3_path_raw) { Tempfile.new("output-raw.mp3") }
+  let(:mp3_path_api) { Tempfile.new("output-api.mp3") }
 
   let(:wav_reader) { WaveFile::Reader.new(wav_path) }
 
+  it "encodes a file by api" do
+
+    encoder = LAME::Encoder.new
+
+    encoder.configure do |config|
+      config.id3.write_automatic = false
+      config.id3.v2 = true
+      config.id3.title = "Dies Irae"
+      config.id3.genre = "Classical"
+
+      #config.bitrate = 192
+
+      # config.preset = :V0 # doesn't work?
+      config.vbr.mode = :vbr_default
+      config.vbr.q = 0
+    end
+
+    File.open(mp3_path_api, "wb") do |file|
+
+      id3v2_size = 0
+      encoder.id3v2 do |tag|
+        file.write tag
+        id3v2_size = tag.size
+      end
+
+      wav_reader.each_buffer(encoder.framesize) do |read_buffer|
+        left  = read_buffer.samples.map { |s| s[0] }
+        right = read_buffer.samples.map { |s| s[1] }
+
+        encoder.encode_short(left, right) do |mp3|
+          file.write mp3
+        end
+      end
+      encoder.flush do |flush_frame|
+        file.write(flush_frame)
+      end
+
+      encoder.id3v1 do |tag|
+        file.write tag
+      end
+
+      encoder.vbr_frame do |vbr_frame|
+        file.seek(id3v2_size)
+        file.write(vbr_frame)
+      end
+
+    end
+
+    # TODO: Need a better way to test output..
+    # Digest::MD5.hexdigest(File.read(mp3_path_api)).should eql "d1cd92c106e7aac4f5291fd141a19e10"
+  end
+
   # This test serves as an example how to use the LAME API
   it "encodes a wav file" do
 
@@ -71,56 +124,4 @@ describe "Encoding", :slow => true do
     # Digest::MD5.hexdigest(File.read(mp3_path_raw)).should eql "84a1ce7994bb4a54fc13fb5381ebac40"
   end
 
-  it "encodes a file by api" do
-
-    encoder = LAME::Encoder.new
-
-    encoder.configure do |config|
-      config.id3.write_automatic = false
-      config.id3.v2 = true
-      config.id3.title = "Dies Irae"
-      config.id3.genre = "Classical"
-
-      #config.bitrate = 192
-
-      # config.preset = :V0 # doesn't work?
-      config.vbr.mode = :vbr_default
-      config.vbr.q = 0
-    end
-
-    File.open(mp3_path_api, "wb") do |file|
-
-      id3v2_size = 0
-      encoder.id3v2 do |tag|
-        file.write tag
-        id3v2_size = tag.size
-      end
-
-      wav_reader.each_buffer(encoder.framesize) do |read_buffer|
-        left  = read_buffer.samples.map { |s| s[0] }
-        right = read_buffer.samples.map { |s| s[1] }
-
-        encoder.encode_short(left, right) do |mp3|
-          file.write mp3
-        end
-      end
-      encoder.flush do |flush_frame|
-        file.write(flush_frame)
-      end
-
-      encoder.id3v1 do |tag|
-        file.write tag
-      end
-
-      encoder.vbr_frame do |vbr_frame|
-        file.seek(id3v2_size)
-        file.write(vbr_frame)
-      end
-
-    end
-
-    # TODO: Need a better way to test output..
-    # Digest::MD5.hexdigest(File.read(mp3_path_api)).should eql "d1cd92c106e7aac4f5291fd141a19e10"
-  end
-
 end

data/spec/integration/id3_tags_spec.rb

@@ -4,7 +4,8 @@ require 'mp3info'
 
 describe "ID3 tags", :slow => true do
 
-  let(:wav_path)     { File.expand_path(File.join(File.dirname(__FILE__), '../files/dies-irae.wav')) }
+  let(:wav_file) { WaveFileGenerator.new(:length => 2).generate }
+  let(:wav_path) { wav_file.path }
   let(:mp3_id3_path) { File.expand_path(File.join(File.dirname(__FILE__), '../files/dies-irae-id3-raw.mp3')) }
   let(:wav_reader)   { WaveFile::Reader.new(wav_path) }
 

data/spec/lib/custom_matchers.rb

@@ -0,0 +1,116 @@
+# Validate existence of a getter, setter and the default value.
+RSpec::Matchers.define :have_flag do |expected|
+  include SetterGetter
+
+  chain :for do |flags_pointer|
+    @flags_pointer = flags_pointer
+  end
+
+  chain :with_value do |value|
+    @value = value
+  end
+
+  match do |actual|
+    has_getter?(actual, expected) &&
+      has_setter?(actual, expected) &&
+      has_value?(actual, expected)
+  end
+end
+
+# Validate setting a value.
+RSpec::Matchers.define :be_able_to_set do |expected|
+  include SetterGetter
+
+  chain :for do |flags_pointer|
+    @flags_pointer = flags_pointer
+  end
+
+  chain :to do |value|
+    @value = value
+  end
+
+  chain :and_return do |value|
+    @return = value
+  end
+
+  match do |actual|
+    set_value(actual, expected) &&
+      has_value?(actual, expected)
+  end
+end
+
+# Validate getting a value.
+RSpec::Matchers.define :have_getter do |expected|
+  include SetterGetter
+
+  chain :for do |flags_pointer|
+    @flags_pointer = flags_pointer
+  end
+
+  chain :with_value do |value|
+    @value = value
+  end
+
+  match do |actual|
+    has_getter?(actual, expected) &&
+      has_value?(actual, expected)
+  end
+
+  failure_message_for_should do |actual|
+    if !has_getter?(actual, expected)
+      "expected that #{actual} would have a getter for field :#{expected}"
+    elsif @value && !has_value?(actual, expected)
+      actual_value = actual_value(actual, expected)
+      "expected field :#{expected} to have a value of #{@value}, but got #{actual_value}"
+    end
+  end
+end
+
+# Validate delegation to global_flags.
+RSpec::Matchers.define :delegate do |from|
+  include SetterGetter
+
+  chain :to do |target|
+    @target = target
+  end
+
+  match do |subject|
+    @from = from
+    has_setter?(LAME, target) &&
+      delegates_setter? &&
+      has_getter?(LAME, target) &&
+      delegates_getter?
+  end
+
+  def delegates_setter?
+    LAME.should_receive(:"lame_set_#{target}").with(subject.global_flags, anything)
+    subject.send(:"#{from}=", double)
+    true
+  rescue => e
+    # TODO: save raised exception for better failure message
+    false
+  end
+
+  def delegates_getter?
+    LAME.should_receive(:"lame_get_#{target}").with(subject.global_flags)
+    subject.send(:"#{from}")
+    true
+  rescue => e
+    # TODO: save raised exception for better failure message
+    false
+  end
+
+  failure_message_for_should do |actual|
+    "expected #{subject.class} to delegate :#{from} to LAME.lame_set_#{target}"
+  end
+
+  def target
+    @target || from
+  end
+
+  def from
+    @from
+  end
+
+end
+

data/spec/lib/setter_getter.rb

@@ -0,0 +1,32 @@
+module SetterGetter
+  def has_getter?(lame, flag)
+    lame.respond_to?(:"lame_get_#{flag}")
+  end
+
+  def has_setter?(lame, flag)
+    lame.respond_to?(:"lame_set_#{flag}")
+  end
+
+  def set_value(lame, flag)
+    lame.send(:"lame_set_#{flag}", @flags_pointer, @value) == return_value
+  end
+
+  def return_value
+    defined?(@return) ? @return : 0
+  end
+
+  def has_value?(lame, flag)
+    if @value && @value.is_a?(Float)
+      actual = actual_value(lame, flag)
+      (actual - @value).abs < 0.0001
+    elsif @value
+      actual_value(lame, flag) == @value
+    else
+      true
+    end
+  end
+
+  def actual_value(lame, flag)
+    lame.send(:"lame_get_#{flag}", @flags_pointer)
+  end
+end