lame 0.0.1

data/spec/decoder_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+module LAME
+  describe Decoder do
+
+    let(:decode_flags)           { stub("decode flags") }
+    let(:mp3_file)               { stub("mp3 file") }
+    let(:id3_tag_parser)         { stub("id3 tag parser", :skip! => nil) }
+    let(:mp3_data_header_parser) { stub("mp3 data header parser", :parse! => nil) }
+
+    # Stub away all collaborators:
+    before do
+      Decoding::Id3TagParser.stub(:new).and_return(id3_tag_parser)
+      Decoding::Mp3DataHeaderParser.stub(:new).and_return(mp3_data_header_parser)
+      FFI::DecodeFlags.stub(:new).and_return(decode_flags)
+    end
+
+    subject(:decoder) { Decoder.new(mp3_file) }
+
+    context "initialization" do
+
+      it "initializes DecodeFlags" do
+        FFI::DecodeFlags.should_receive(:new)
+        Decoder.new(mp3_file)
+      end
+
+      it "has the DecodeFlags" do
+        decode_flags = stub
+        FFI::DecodeFlags.stub(:new).and_return(decode_flags)
+        decoder.decode_flags.should eql decode_flags
+      end
+
+      it "has the mp3 file path" do
+        decoder.mp3_file.should eql mp3_file
+      end
+
+      it "skips the id3 offset" do
+        Decoding::Id3TagParser.should_receive(:new).with(mp3_file)
+        id3_tag_parser.should_receive(:skip!)
+
+        decoder
+      end
+
+      it "parses the mp3 data header" do
+        parser = stub
+        mp3_data = stub
+        Decoding::Mp3DataHeaderParser.should_receive(:new).with(decode_flags, mp3_file).and_return(parser)
+        parser.should_receive(:parse!).and_return(mp3_data)
+
+        decoder.mp3_data.should eql mp3_data
+      end
+
+    end
+
+    context "after initialization" do
+
+      let(:mp3_data) { stub("mp3 data") }
+
+      # stubbing galore!
+      before do
+        FFI::DecodeFlags.stub(:new).and_return(decode_flags)
+
+        parser = stub
+        Decoding::Mp3DataHeaderParser.stub(:new).and_return(parser)
+        parser.stub(:parse!).and_return(mp3_data)
+      end
+
+      describe "#each_decoded_frame" do
+
+        let(:stream_decoder) { stub }
+        before do
+          Decoding::StreamDecoder.stub(:new).and_return(stream_decoder)
+        end
+
+        it "initializes a stream decoder with mp3 file and mp3 data" do
+          stream_decoder.stub(:each_decoded_frame)
+
+          Decoding::StreamDecoder.should_receive(:new).with(decode_flags, mp3_data, mp3_file)
+
+          decoder.each_decoded_frame
+        end
+
+        it "delegates to a stream decoder" do
+          stream_decoder.should_receive(:each_decoded_frame)
+
+          decoder.each_decoded_frame
+        end
+
+        it "re-yields the stream decoder's yield" do
+          stream_decoder.stub(:each_decoded_frame).and_yield(:one).and_yield(:two)
+
+          expect { |block|
+            decoder.each_decoded_frame(&block)
+          }.to yield_successive_args(:one, :two)
+        end
+
+      end
+
+      describe "#channel_mode" do
+
+        it "delegates to mp3_data" do
+          mp3_data.should_receive(:channel_mode).and_return(:stereo)
+          decoder.channel_mode.should eql :stereo
+        end
+
+      end
+
+      describe "#sample_rate" do
+
+        it "delegates to mp3_data" do
+          mp3_data.should_receive(:sample_rate).and_return(44100)
+          decoder.sample_rate.should eql 44100
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/decoding/decoded_frame_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module LAME
+  module Decoding
+    describe DecodedFrame do
+
+      it "is initialized with left and right samples" do
+        left = stub
+        right = stub
+
+        decoded_frame = DecodedFrame.new(left, right)
+
+        decoded_frame.left.should eql left
+        decoded_frame.right.should eql right
+      end
+
+      it "can be built with FFI Buffers" do
+        left_buffer = ::FFI::MemoryPointer.new(:short, 4)
+        right_buffer = ::FFI::MemoryPointer.new(:short, 4)
+
+        left_buffer.put_array_of_short(0, [1,2,3,4])
+        right_buffer.put_array_of_short(0, [5,6,7,8])
+
+        decoded_frame = DecodedFrame.from_short_buffers(left_buffer, right_buffer)
+
+        decoded_frame.left.should eql [1,2,3,4]
+        decoded_frame.right.should eql [5,6,7,8]
+      end
+
+      describe "#samples" do
+
+        it "returns zipped version of samples" do
+          left = [1,2,3,4]
+          right = [5,6,7,8]
+
+          decoded_frame = DecodedFrame.new(left, right)
+
+          decoded_frame.samples.should eql [[1,5],[2,6],[3,7],[4,8]]
+        end
+      end
+
+    end
+  end
+end

data/spec/decoding/id3_tag_parser_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module LAME
+  module Decoding
+    describe Id3TagParser do
+
+      let(:stream) { StringIO.new(stream_string) }
+      let(:parser) { Id3TagParser.new(stream) }
+
+      describe "#skip!" do
+
+        context "valid header" do
+          let(:stream_string) do
+            header = "ID3   "
+            header << 0b00000000
+            header << 0b00000000
+            header << 0b00000010
+            header << 0b01010101
+            header << " "*341 # the above bits are '341'
+          end
+
+          it "seeks the file until after the id3 tag" do
+            parser.skip!
+            stream.pos.should eql 351
+          end
+
+          it "start from the start of the stream" do
+            stream.seek(42)
+            parser.skip!
+            stream.pos.should eql 351
+          end
+        end
+
+
+        context "no id3 tag" do
+          let(:stream_string) { " "*1024 }
+
+          it "does not crash if id3 tag is not present" do
+            expect {
+              parser.skip!
+            }.not_to raise_error
+          end
+
+          it "does not seek the stream if no header is present" do
+            parser.skip!
+            stream.pos.should eql 0
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/decoding/mp3_data_header_parser_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module LAME
+  module Decoding
+    describe Mp3DataHeaderParser do
+
+      subject(:parser) { Mp3DataHeaderParser.new(decode_flags, stream) }
+
+      let(:decode_flags) { stub("decode flags") }
+      let(:stream) { StringIO.new(stream_string) }
+      let(:mpeg_finder) { stub }
+
+      let(:stream_string) { "a"*100 }
+
+      before do
+        LAME.stub(:hip_decode1_headersB) do |_, _, _, _, _, mp3_data, _, _|
+          # fake that the header was found
+          mp3_data[:header_parsed] = 1
+        end
+      end
+
+      it "seeks the input stream until the first mpeg frame" do
+        MPEGAudioFrameFinder.should_receive(:new).with(stream).and_return(mpeg_finder)
+        mpeg_finder.should_receive(:find!)
+
+        parser.parse!
+      end
+
+      context "decoding headers" do
+
+        before do
+          MPEGAudioFrameFinder.stub(:new => stub.as_null_object)
+        end
+
+        it "reads 100 bytes from the stream" do
+          stream.should_receive(:read).with(100).and_return("a"*100)
+          parser.parse!
+        end
+
+        it "parses headers with LAME" do
+          LAME.should_receive(:hip_decode1_headersB) do |decode_flags, in_buffer, size, _, _, mp3_data, _, _|
+            decode_flags.should            eql decode_flags
+            in_buffer.get_string(0).should eql "a"*100
+            size.should                    eql 100
+            mp3_data.should                be_a(LAME::FFI::MP3Data)
+
+            # fake that the header was found
+            mp3_data[:header_parsed] = 1
+          end
+          parser.parse!
+        end
+
+        context "larger input" do
+          let(:stream_string) { "a"*1000 }
+          let(:expected_reads) { 5 }
+
+          it "reads 100 bytes until a header was parsed" do
+            decode_count = 0
+
+            LAME.should_receive(:hip_decode1_headersB).exactly(expected_reads).times
+
+            LAME.stub(:hip_decode1_headersB) do |_, _, _, _, _, mp3_data, _, _|
+              decode_count += 1
+
+              # simulate parsed header after 5 reads:
+              mp3_data[:header_parsed] = (decode_count == expected_reads) ? 1 : 0
+            end
+
+            parser.parse!
+          end
+        end
+
+        it "returns the parsed mp3 data if a header was parsed" do
+          mp3_data = stub("mp3 data", :header_parsed? => true)
+          LAME::FFI::MP3Data.stub(:new).and_return(mp3_data)
+          LAME.stub(:hip_decode1_headersB)
+
+          parser.parse!.should eql mp3_data
+        end
+
+        it "raises an error if the header could not be parsed" do
+          mp3_data = stub("mp3 data", :header_parsed? => false)
+          LAME::FFI::MP3Data.stub(:new).and_return(mp3_data)
+          LAME.stub(:hip_decode1_headersB)
+
+          expect {
+            parser.parse!
+          }.to raise_error(Mp3DataHeaderNotFoundError)
+        end
+
+      end
+
+    end
+  end
+end

data/spec/decoding/mpeg_audio_frame_finder_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module LAME
+  module Decoding
+    describe MPEGAudioFrameFinder do
+
+      subject(:finder) { MPEGAudioFrameFinder.new(stream) }
+
+      let(:stream) { StringIO.new(stream_string) }
+      let(:stream_string) { "1234567890" }
+
+      it "tries to find the mpeg frame 4 bytes at a time until a header is found" do
+        matcher1 = stub("matcher", :match? => false)
+        matcher2 = stub("matcher", :match? => false)
+        matcher3 = stub("matcher", :match? => true)
+
+        MPEGAudioFrameMatcher.should_receive(:new).with("1234").and_return(matcher1)
+        MPEGAudioFrameMatcher.should_receive(:new).with("2345").and_return(matcher2)
+        MPEGAudioFrameMatcher.should_receive(:new).with("3456").and_return(matcher3)
+
+        finder.find!
+      end
+
+      it "seeks the stream at the position of the found frame" do
+        matcher1 = stub("matcher", :match? => false)
+        matcher2 = stub("matcher", :match? => false)
+        matcher3 = stub("matcher", :match? => true)
+
+        MPEGAudioFrameMatcher.stub(:new).with("1234").and_return(matcher1)
+        MPEGAudioFrameMatcher.stub(:new).with("2345").and_return(matcher2)
+        MPEGAudioFrameMatcher.stub(:new).with("3456").and_return(matcher3)
+
+        finder.find!
+
+        stream.pos.should eql 2
+      end
+
+      it "raises an error if no header could be found" do
+        matcher = stub("matcher", :match? => false)
+
+        MPEGAudioFrameMatcher.stub(:new).and_return(matcher)
+
+        expect {
+          finder.find!
+        }.to raise_error(MPEGAudioFrameNotFoundError)
+      end
+
+    end
+  end
+end

data/spec/decoding/mpeg_audio_frame_matcher_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+module LAME
+  module Decoding
+    describe MPEGAudioFrameMatcher do
+
+      B_EMPTY      = 0b00000000
+
+      B1_LEADING   = 0b11111111
+      B2_LEADING   = 0b11100000
+      B2_MPEG25    = 0b00000000
+      B2_MPEG_RESV = 0b00001000
+      B2_MPEG2     = 0b00010000
+      B2_MPEG1     = 0b00011000
+      B2_LAYER0    = 0b00000000 # reserved
+      B2_LAYER3    = 0b00000010 # Layer III
+      B2_LAYER2    = 0b00000100 # Layer II
+      B2_LAYER1    = 0b00000110 # Layer I
+
+      # Comments below are for MP3
+      B3_BITRATE0  = 0b00000000
+      B3_BITRATE1  = 0b00010000 # lowest (32 in MP3)
+      B3_BITRATE9  = 0b10010000 # 128kbit in MP3
+      B3_BITRATE11 = 0b10110000 # 192kbit in MP3
+      B3_BITRATE14 = 0b11100000 # highest (320 in MP3)
+      B3_BITRATE15 = 0b11110000
+      B3_SMPRATE0  = 0b00000000 # 44100
+      B3_SMPRATE1  = 0b00000100 # 48000
+      B3_SMPRATE2  = 0b00001000 # 32000
+      B3_SMPRATE3  = 0b00001100 # reserved
+
+      B4_STEREO    = 0b00000000
+      B4_JOINT     = 0b01000000
+      B4_DUAL      = 0b10000000
+      B4_MONO      = 0b11000000
+      B4_EMPH_NONE = 0b00000000
+      B4_EMPH_5015 = 0b00000001
+      B4_EMPH_RESV = 0b00000010 # reserved
+      B4_EMPH_CCIT = 0b00000011
+
+      shared_examples_for "4 valid bytes" do
+        it "matches" do
+          bytes = [b1, b2, b3, b4].pack("C*")
+          MPEGAudioFrameMatcher.new(bytes).match?.should be_true
+        end
+      end
+
+      shared_examples_for "4 invalid bytes" do
+        it "does not match" do
+          bytes = [b1, b2, b3, b4].pack("C*")
+          MPEGAudioFrameMatcher.new(bytes).match?.should be_false
+        end
+      end
+
+      context "MPEG1, Layer III, 128kbit, 44khz, stereo, no-emph" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER3 }
+        let(:b3) { B3_BITRATE9 | B3_SMPRATE0 }
+        let(:b4) { B4_STEREO | B4_EMPH_NONE }
+
+        it_behaves_like "4 valid bytes"
+      end
+
+      context "MPEG2, Layer II, 160kbit, 24khz, mono, 50/15ms emph" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG2 | B2_LAYER2 }
+        let(:b3) { B3_BITRATE14 | B3_SMPRATE1 }
+        let(:b4) { B4_MONO | B4_EMPH_5015 }
+
+        it_behaves_like "4 valid bytes"
+      end
+
+      context "all 0 bites" do
+        let(:b1) { B_EMPTY }
+        let(:b2) { B_EMPTY }
+        let(:b3) { B_EMPTY }
+        let(:b4) { B_EMPTY }
+
+        it_behaves_like "4 invalid bytes"
+      end
+
+      context "reserved MPEG" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG_RESV | B2_LAYER3 } # <-- B2_MPEG_RESV
+        let(:b3) { B3_BITRATE9 | B3_SMPRATE0 }
+        let(:b4) { B4_STEREO | B4_EMPH_NONE }
+
+        it_behaves_like "4 invalid bytes"
+      end
+
+      context "reserved Layer" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER0 } # <-- B2_LAYER0
+        let(:b3) { B3_BITRATE9 | B3_SMPRATE0 }
+        let(:b4) { B4_STEREO | B4_EMPH_NONE }
+
+        it_behaves_like "4 invalid bytes"
+      end
+
+      context "reserved bitrate" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER3 }
+        let(:b3) { B3_BITRATE15 | B3_SMPRATE0 } # <-- B3_BITRATE15
+        let(:b4) { B4_STEREO | B4_EMPH_NONE }
+
+        it_behaves_like "4 invalid bytes"
+      end
+
+      context "reserved sampling rate" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER3 }
+        let(:b3) { B3_BITRATE9 | B3_SMPRATE3 } # <-- B3_SMPRATE3
+        let(:b4) { B4_STEREO | B4_EMPH_NONE }
+
+        it_behaves_like "4 invalid bytes"
+      end
+
+      context "valid MPEG1 Layer II bitrate/channel mode combination" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER2 }
+        let(:b3) { B3_BITRATE1 | B3_SMPRATE2 }
+        let(:b4) { B4_MONO | B4_EMPH_NONE }
+
+        # bitrate '1' and 'mono' is valid
+        it_behaves_like "4 valid bytes"
+      end
+
+      context "another valid MPEG1 Layer II bitrate/channel mode combination" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER2 }
+        let(:b3) { B3_BITRATE11 | B3_SMPRATE2 }
+        let(:b4) { B4_JOINT | B4_EMPH_NONE }
+
+        # bitrate '11' and 'joint_stereo' is valid
+        it_behaves_like "4 valid bytes"
+      end
+
+      context "yet another valid MPEG1 Layer II bitrate/channel mode combination" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER2 }
+        let(:b3) { B3_BITRATE9 | B3_SMPRATE2 }
+        let(:b4) { B4_JOINT | B4_EMPH_NONE }
+
+        # bitrate '9' and 'joint_stereo' is valid
+        it_behaves_like "4 valid bytes"
+      end
+
+      context "invalid MPEG1 Layer II bitrate/channel mode combination" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER2 }
+        let(:b3) { B3_BITRATE1 | B3_SMPRATE2 }
+        let(:b4) { B4_STEREO | B4_EMPH_NONE }
+
+        # bitrate '1' and 'stereo' is invalid
+        it_behaves_like "4 invalid bytes"
+      end
+
+      context "another invalid MPEG1 Layer II bitrate/channel mode combination" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER2 }
+        let(:b3) { B3_BITRATE11 | B3_SMPRATE2 }
+        let(:b4) { B4_MONO | B4_EMPH_NONE }
+
+        # bitrate '11' and 'mono' is invalid
+        it_behaves_like "4 invalid bytes"
+      end
+
+      context "invalid emphasis" do
+        let(:b1) { B1_LEADING }
+        let(:b2) { B2_LEADING | B2_MPEG1 | B2_LAYER3 }
+        let(:b3) { B3_BITRATE9 | B3_SMPRATE0 }
+        let(:b4) { B4_STEREO | B4_EMPH_RESV }
+
+        it_behaves_like "4 invalid bytes"
+      end
+
+    end
+  end
+end