lame 0.0.1

data/spec/decoding/single_frame_decoder_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+module LAME
+  module Decoding
+    describe SingleFrameDecoder do
+
+      subject(:decoder) { SingleFrameDecoder.new(decode_flags, mp3_data) }
+
+      let(:decode_flags) { stub("decode flags") }
+      let(:mp3_data) { stub("mp3 data") }
+      let(:data) { "a"*1024 }
+
+      it "always checks if there is a decoded frame in the internal buffer" do
+        # initial decoded frame
+        LAME.should_receive(:hip_decode1_headers) do |flags, in_buffer, in_size, out_left, out_right, mp3_data_arg|
+          flags.should          eql decode_flags
+          in_buffer.size.should eql 0
+          in_size.should        eql 0
+          out_left.size.should  eql 1152*2 # short is 2 bytes
+          out_right.size.should eql 1152*2
+          mp3_data_arg.should   eql mp3_data
+          0
+        end
+        # new data
+        LAME.stub(:hip_decode1_headers).and_return(0)
+
+        decoder.decode(data)
+      end
+
+      it "writes the input data into the LAME decoder" do
+        # initial
+        LAME.should_receive(:hip_decode1_headers) do |_, in_buffer, _, _ , _, _|
+          in_buffer.size.should eql 0
+          0
+        end
+        # new data
+        LAME.should_receive(:hip_decode1_headers) do |flags, in_buffer, in_size, out_left, out_right, mp3_data_arg|
+          flags.should          eql decode_flags
+          in_buffer.size.should eql 1024
+          in_size.should        eql 1024
+          out_left.size.should  eql 1152*2 # short is 2 bytes
+          out_right.size.should eql 1152*2
+          mp3_data_arg.should   eql mp3_data
+          0
+        end
+
+        decoder.decode(data)
+      end
+
+      it "decodes until no more frames were decoded" do
+        LAME.stub(:hip_decode1_headers).and_return(0, 1, 1, 0)
+        LAME.should_receive(:hip_decode1_headers).exactly(4).times
+
+        decoder.decode(data) {}
+      end
+
+      it "yields decoded frames if one is left in internal buffer" do
+        LAME.stub(:hip_decode1_headers).and_return(1, 0)
+
+        expect { |block|
+          decoder.decode(data, &block)
+        }.to yield_successive_args(DecodedFrame)
+      end
+
+      it "yields decoded frames for new data" do
+        LAME.stub(:hip_decode1_headers).and_return(0, 1, 1, 0)
+
+        expect { |block|
+          decoder.decode(data, &block)
+        }.to yield_successive_args(DecodedFrame, DecodedFrame)
+      end
+
+      it "raises an error if decoding failed" do
+        LAME.stub(:hip_decode1_headers).and_return(-1)
+
+        expect {
+          decoder.decode(data)
+        }.to raise_error(DecodingError)
+      end
+
+      # Enable these tests once next rspec-expectations has been released
+      xit "yields until no more data is decoded" do
+        LAME.stub(:hip_decode1_headers).and_return(0, 1, 1, 0)
+
+        LAME.should_receive(:hip_decode1_headers).exactly(4).times
+
+        expect {
+          decoder.decode(data)
+        }.to yield_control.exactly(2).times
+      end
+
+      xit "yields if the decoder had a decoded frame " do
+        LAME.stub(:hip_decode1_headers).and_return(1, 1, 1, 0)
+
+        LAME.should_receive(:hip_decode1_headers).exactly(4).times
+
+        expect {
+          decoder.decode(data)
+        }.to yield_control.exactly(3).times
+      end
+
+    end
+  end
+end

data/spec/decoding/stream_decoder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module LAME
+  module Decoding
+    describe StreamDecoder do
+
+      subject(:decoder) { StreamDecoder.new(decode_flags, mp3_data, stream) }
+
+      let(:decode_flags) { stub("decode flags") }
+      let(:mp3_data) { stub("mp3 data") }
+
+      let(:stream) { StringIO.new(stream_string) }
+      let(:stream_string) { "a" * 1024 + "b" * 1024}
+
+      it "creates a single frame decoder" do
+        SingleFrameDecoder.should_receive(:new).with(decode_flags, mp3_data)
+        decoder
+      end
+
+      it "it passes chunks of stream into the single frame decoder" do
+        single_frame_decoder = stub
+        SingleFrameDecoder.stub(:new).and_return(single_frame_decoder)
+
+        single_frame_decoder.should_receive(:decode).exactly(:twice)
+
+        decoder.each_decoded_frame
+      end
+
+      it "yields the decoded frame" do
+        single_frame_decoder = stub
+        SingleFrameDecoder.stub(:new).and_return(single_frame_decoder)
+
+        single_frame_decoder.stub(:decode).with("a"*1024).and_yield(:one)
+        single_frame_decoder.stub(:decode).with("b"*1024).and_yield(:two).and_yield(:three)
+
+        expect { |block|
+          decoder.each_decoded_frame(&block)
+        }.to yield_successive_args(:one, :two, :three)
+      end
+
+    end
+  end
+end

data/spec/delegation_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+module LAME
+
+  class FakeEncoder
+    extend Delegation
+
+    attr_accessor :global_flags
+
+    delegate_alias_to_lame :foo => :bar
+    delegate_to_lame :baz
+    delegate_id3_to_lame :qux
+  end
+
+  describe Delegation do
+
+    let(:global_flags) { stub }
+    subject { FakeEncoder.new }
+
+    before do
+      subject.global_flags = global_flags
+    end
+
+    context "#delegate_alias_to_lame" do
+      it "delegates #foo= to LAME" do
+        LAME.should_receive(:lame_set_bar).with(global_flags, anything)
+        subject.foo = stub
+      end
+
+      it "delegates #foo to LAME" do
+        LAME.should_receive(:lame_get_bar).with(global_flags)
+        subject.foo
+      end
+
+      it "delegates #foo? to LAME" do
+        LAME.should_receive(:lame_get_bar).with(global_flags)
+        subject.foo?
+      end
+    end
+
+    context "#delegate_to_lame" do
+      it "delegates #baz= to LAME" do
+        LAME.should_receive(:lame_set_baz).with(global_flags, anything)
+        subject.baz = stub
+      end
+
+      it "delegates #baz to LAME" do
+        LAME.should_receive(:lame_get_baz).with(global_flags)
+        subject.baz
+      end
+
+      it "delegates #baz? to LAME" do
+        LAME.should_receive(:lame_get_baz).with(global_flags)
+        subject.baz?
+      end
+    end
+
+    context "#delegate_id3_to_lame" do
+      it "delegates #qux= to LAME" do
+        LAME.should_receive(:id3tag_set_qux).with(global_flags, anything)
+        subject.qux = stub
+      end
+    end
+
+    context "type conversion" do
+      it "converts the input type" do
+        value = stub
+        Delegation::TypeConvertor.should_receive(:convert).with(value)
+        LAME.stub(:lame_set_baz)
+        subject.baz = value
+      end
+
+      it "passes on converted value to setter" do
+        value = stub
+        converted_value = stub
+        Delegation::TypeConvertor.stub(:convert).and_return(converted_value)
+        LAME.should_receive(:lame_set_baz).with(global_flags, converted_value)
+        subject.baz = value
+      end
+
+      it "converts question mark style getters to return booleans" do
+        LAME.stub(:lame_get_baz).and_return(0)
+        Delegation::TypeConvertor.should_receive(:convert_return).with(0)
+        subject.baz?
+      end
+
+      it "converts question mark style getters to return booleans" do
+        LAME.stub(:lame_get_baz)
+        Delegation::TypeConvertor.stub(:convert_return).and_return(false)
+        subject.baz?.should eql false
+      end
+    end
+
+  end
+
+  describe Delegation::TypeConvertor do
+
+    subject(:converter) { Delegation::TypeConvertor }
+
+    describe "#convert" do
+      it "converts true to 1" do
+        converter.convert(true).should eql 1
+      end
+
+      it "converts false to 0" do
+        converter.convert(false).should eql 0
+      end
+
+      it "converts a string to a pointer with correct value" do
+        input = "some string"
+        value = converter.convert(input)
+        value.should be_a(::FFI::MemoryPointer)
+        value.get_string(0).should eql input
+      end
+
+      it "does not convert other values" do
+        converter.convert(:foo).should eql :foo
+        converter.convert(1.2).should eql 1.2
+      end
+    end
+
+    describe "#convert_return" do
+      it "converts 1 to true" do
+        converter.convert_return(1).should eql true
+      end
+
+      it "converts 0 to false" do
+        converter.convert_return(0).should eql false
+      end
+
+      it "converts 0.0 to false" do
+        converter.convert_return(0.0).should eql false
+      end
+
+      it "returns truthy to true" do
+        converter.convert_return(:truthy).should eql true
+        converter.convert_return("truthy").should eql true
+        converter.convert_return(Object).should eql true
+        converter.convert_return(Object.new).should eql true
+        converter.convert_return(4.2).should eql true
+      end
+    end
+
+  end
+
+end

data/spec/encoder_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+module LAME
+  describe Encoder do
+
+    subject(:encoder) { Encoder.new }
+
+    context "initialization" do
+
+      it "initializes GlobalFlags" do
+        FFI::GlobalFlags.should_receive(:new)
+        Encoder.new
+      end
+
+    end
+
+    context "configuration" do
+
+      let(:configuration) { stub(Configuration).as_null_object }
+
+      before do
+        Configuration.stub(:new).and_return(configuration)
+      end
+
+      it "initializes a Configuration object" do
+        Configuration.should_receive(:new).with(kind_of(GlobalFlags))
+        encoder.configure { }
+      end
+
+      it "yields the Configuration object" do
+        expect { |block|
+          encoder.configure(&block)
+        }.to yield_with_args(configuration)
+      end
+
+      it "assigns the Configuration object" do
+        encoder.configure { }
+        encoder.configuration.should eql configuration
+      end
+
+      it "applies the configuration" do
+        configuration.stub(:applied?).and_return(false)
+        configuration.should_receive(:apply!)
+        encoder.configure { }
+      end
+
+      it "gets the framesize" do
+        configuration.should_receive(:framesize).and_return(1234)
+        encoder.framesize.should eql 1234
+      end
+    end
+
+    context "encoding" do
+
+      let(:left) { [0] }
+      let(:right) { [0] }
+      let(:global_flags) { subject.global_flags }
+      let(:configuration) { stub(Configuration, :framesize => 100) }
+
+      before do
+        Configuration.stub(:new).and_return(configuration)
+        configuration.stub(:applied?).and_return(true)
+        Encoding::EncodeShortBuffer.stub(:new).and_return(stub.as_null_object)
+      end
+
+      it "applies the configuration if not done already" do
+        configuration.stub(:applied?).and_return(false)
+        configuration.should_receive(:apply!)
+        encoder.encode_short(left, right) { }
+      end
+
+      it "does not apply the configuration if already applied" do
+        configuration.stub(:applied?).and_return(true)
+        configuration.should_not_receive(:apply!)
+        encoder.encode_short(left, right) { }
+      end
+
+      context "delegation" do
+        let(:short_encoder) { stub.as_null_object }
+
+        before do
+          Encoding::EncodeShortBuffer.stub(:new).and_return(short_encoder)
+        end
+
+        it "create a short encoder with configuration" do
+          Encoding::EncodeShortBuffer.should_receive(:new).with(configuration)
+
+          encoder.encode_short(left, right) { }
+        end
+
+        it "delegates encoding to the short encoder" do
+          left.stub(:length => 100) # exactly framesize
+          short_encoder.should_receive(:encode_frame).with(left, right)
+
+          encoder.encode_short(left, right) { }
+        end
+
+        it "yields the encoder results" do
+          mp3_data = stub
+          short_encoder.stub(:encode_frame).and_return(mp3_data)
+
+          expect { |block|
+            encoder.encode_short(left, right, &block)
+          }.to yield_with_args(mp3_data)
+        end
+
+        it "delegates multiple times for large input" do
+          right = left = [0]*150 # larger than framesize
+
+          short_encoder.should_receive(:encode_frame) do |left_frame, right_frame|
+            left_frame.length.should eql 100
+            right_frame.length.should eql 100
+          end
+
+          short_encoder.should_receive(:encode_frame) do |left_frame, right_frame|
+            left_frame.length.should eql 50
+            right_frame.length.should eql 50
+          end
+
+          encoder.encode_short(left, right) { }
+        end
+
+        it "yields multiple times for large input" do
+          mp3_data1 = stub("frame1")
+          mp3_data2 = stub("frame2")
+
+          left = [0]*150 # larger than framesize
+
+          short_encoder.stub(:encode_frame).and_return(mp3_data1, mp3_data2)
+
+          expect { |block|
+            encoder.encode_short(left, right, &block)
+          }.to yield_successive_args(mp3_data1, mp3_data2)
+        end
+
+      end
+    end
+
+    context "flushing" do
+
+      let(:global_flags) { subject.global_flags }
+      let(:configuration) { stub(Configuration) }
+      let(:flusher) { stub(Encoding::Flusher).as_null_object }
+
+      before do
+        Configuration.stub(:new).and_return(configuration)
+        configuration.stub(:applied?).and_return(true)
+        Encoding::Flusher.stub(:new).and_return(flusher)
+      end
+
+      it "creates a flusher" do
+        Encoding::Flusher.should_receive(:new).with(configuration)
+        encoder.flush { }
+      end
+
+      it "flushes the final frame" do
+        flusher.should_receive(:flush)
+        encoder.flush { }
+      end
+
+      it "yields the flushed mp3 data" do
+        mp3_data = stub
+        flusher.stub(:flush).and_return(mp3_data)
+
+        expect { |block|
+          encoder.flush(&block)
+        }.to yield_with_args(mp3_data)
+      end
+
+      it "returns the flushed data if no block was given" do
+        mp3_data = stub
+        flusher.stub(:flush).and_return(mp3_data)
+        encoder.flush.should eql mp3_data
+      end
+
+    end
+
+    context "lametag frame" do
+
+      let(:global_flags) { subject.global_flags }
+      let(:configuration) { stub(Configuration) }
+      let(:vbr_info) { stub(Encoding::VBRInfo).as_null_object }
+
+      before do
+        Configuration.stub(:new).and_return(configuration)
+        configuration.stub(:applied?).and_return(true)
+        Encoding::VBRInfo.stub(:new).and_return(vbr_info)
+      end
+
+      it "creates vbr info" do
+        Encoding::VBRInfo.should_receive(:new).with(configuration)
+        encoder.vbr_frame { }
+      end
+
+      it "creates the vbr frame" do
+        vbr_info.should_receive(:frame)
+        encoder.vbr_frame { }
+      end
+
+      it "yields the vbr frame" do
+        mp3_data = stub
+        vbr_info.stub(:frame).and_return(mp3_data)
+
+        expect { |block|
+          encoder.vbr_frame(&block)
+        }.to yield_with_args(mp3_data)
+      end
+
+      it "returns the vbr frame if no block was given" do
+        mp3_data = stub
+        vbr_info.stub(:frame).and_return(mp3_data)
+        encoder.vbr_frame.should eql mp3_data
+      end
+
+    end
+
+    context "id3" do
+      let(:global_flags) { subject.global_flags }
+      let(:configuration) { stub(Configuration) }
+      let(:id3) { stub(Encoding::Id3).as_null_object }
+
+      before do
+        Configuration.stub(:new).and_return(configuration)
+        configuration.stub(:applied?).and_return(true)
+        Encoding::Id3.stub(:new).and_return(id3)
+      end
+
+      it "creates vbr info" do
+        Encoding::Id3.should_receive(:new).with(configuration)
+        encoder.id3v1 { }
+      end
+
+      context "v1" do
+        it "creates the id3v1 frame" do
+          id3.should_receive(:v1)
+          encoder.id3v1 { }
+        end
+
+        it "yields the vbr frame" do
+          mp3_data = stub
+          id3.stub(:v1).and_return(mp3_data)
+
+          expect { |block|
+            encoder.id3v1(&block)
+          }.to yield_with_args(mp3_data)
+        end
+
+        it "returns the vbr frame if no block was given" do
+          mp3_data = stub
+          id3.stub(:v1).and_return(mp3_data)
+          encoder.id3v1.should eql mp3_data
+        end
+      end
+
+      context "v2" do
+        it "creates the id3v2 frame" do
+          id3.should_receive(:v2)
+          encoder.id3v2 { }
+        end
+
+        it "yields the vbr frame" do
+          mp3_data = stub
+          id3.stub(:v2).and_return(mp3_data)
+
+          expect { |block|
+            encoder.id3v2(&block)
+          }.to yield_with_args(mp3_data)
+        end
+
+        it "returns the vbr frame if no block was given" do
+          mp3_data = stub
+          id3.stub(:v2).and_return(mp3_data)
+          encoder.id3v2.should eql mp3_data
+        end
+      end
+    end
+
+  end
+end