lame 0.0.1

data/spec/ffi/id3tag_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+module LAME
+  describe "FFI calls to id3tag setters" do
+
+    before do
+      @flags_pointer = LAME.lame_init
+    end
+
+    after do
+      LAME.lame_close(@flags_pointer)
+    end
+
+    it "has all the genres" do
+      genres = {}
+
+      genre_collector_callback = ::FFI::Function.new(:void, [:int, :string, :pointer]) do |id, name, _|
+        genres[id] = name
+      end
+
+      LAME.id3tag_genre_list(genre_collector_callback, nil)
+
+      genres.should have(148).items
+      genres[0].should eql "Blues"
+      genres[147].should eql "SynthPop"
+    end
+
+    it "initializes" do
+      LAME.id3tag_init(@flags_pointer).should eql nil
+    end
+
+    it "adds v2" do
+      LAME.id3tag_add_v2(@flags_pointer).should eql nil
+    end
+
+    it "set v1 only" do
+      LAME.id3tag_v1_only(@flags_pointer).should eql nil
+    end
+
+    it "set v2 only" do
+      LAME.id3tag_v2_only(@flags_pointer).should eql nil
+    end
+
+    it "pads with spaces" do
+      LAME.id3tag_space_v1(@flags_pointer).should eql nil
+    end
+
+    it "pads v2 with 128 extra bytes" do
+      LAME.id3tag_pad_v2(@flags_pointer).should eql nil
+    end
+
+    it "pads v2 with extra bytes" do
+      LAME.id3tag_set_pad(@flags_pointer, 256).should eql nil
+    end
+
+    it "sets the title" do
+      LAME.id3tag_set_title(@flags_pointer, pointer_from_string("foo")).should eql nil
+    end
+
+    it "sets the artist" do
+      LAME.id3tag_set_artist(@flags_pointer, pointer_from_string("foo")).should eql nil
+    end
+
+    it "sets the album" do
+      LAME.id3tag_set_album(@flags_pointer, pointer_from_string("foo")).should eql nil
+    end
+
+    it "sets the year" do
+      LAME.id3tag_set_year(@flags_pointer, pointer_from_string("foo")).should eql nil
+    end
+
+    it "sets the comment" do
+      LAME.id3tag_set_comment(@flags_pointer, pointer_from_string("foo")).should eql nil
+    end
+
+    it "sets the track" do
+      LAME.id3tag_set_track(@flags_pointer, pointer_from_string("1")).should eql 0
+    end
+
+    it "ignores out of range track numbers for id3" do
+      LAME.id3tag_set_track(@flags_pointer, pointer_from_string("256")).should eql -1
+    end
+
+    it "sets the genre" do
+      LAME.id3tag_set_genre(@flags_pointer, pointer_from_string("Rock")).should eql 0
+    end
+
+    # There is a fixed set of allowed fields (see id3tag.c)
+    # LAME 3.99.4 fixed some bugs in setting field values, this could crash for certain tags.
+    it "sets the fieldvalue" do
+      LAME.id3tag_set_fieldvalue(@flags_pointer, pointer_from_string("TIT2=foofoo")).should eql 0
+    end
+
+    # it "sets the fieldvalue (utf16)" do
+    #   LAME.id3tag_set_fieldvalue_utf16(@flags_pointer, "LINK=foofoo".encode("UTF-16")).should eql 0
+    # end
+
+    it "sets album art" do
+      buffer_size = 1024
+
+      # fake JPG image
+      buffer = ::FFI::MemoryPointer.new(:char, buffer_size)
+      buffer.put_char(0, 0xff)
+      buffer.put_char(1, 0xd8)
+
+      LAME.id3tag_set_albumart(@flags_pointer, buffer, buffer_size).should eql 0
+    end
+
+    it "creates id3v1 tag" do
+      buffer_size = 1024
+      buffer = ::FFI::MemoryPointer.new(:uchar, buffer_size)
+      LAME.id3tag_set_title(@flags_pointer, pointer_from_string("foo"))
+      LAME.id3tag_set_album(@flags_pointer, pointer_from_string("bar"))
+      LAME.lame_get_id3v1_tag(@flags_pointer, buffer, buffer_size).should eql 128
+    end
+
+    it "creates id3v2 tag" do
+      buffer_size = 1024
+      buffer = ::FFI::MemoryPointer.new(:uchar, buffer_size)
+      LAME.id3tag_add_v2(@flags_pointer)
+      LAME.id3tag_set_title(@flags_pointer, pointer_from_string("foo"))
+      LAME.id3tag_set_album(@flags_pointer, pointer_from_string("bar"))
+      LAME.lame_get_id3v2_tag(@flags_pointer, buffer, buffer_size).should eql 38
+    end
+
+    it "sets id3tag automatic" do
+      LAME.should have_flag(:write_id3tag_automatic).with_value(1).for(@flags_pointer)
+    end
+
+    it "gets id3tag automatic" do
+      LAME.should be_able_to_set(:write_id3tag_automatic).to(0).for(@flags_pointer).and_return(nil)
+    end
+
+  end
+end

data/spec/ffi/mp3_data_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module LAME
+  module FFI
+    describe MP3Data do
+
+      subject(:mp3_data) { MP3Data.new }
+
+      it "is stereo for two channels" do
+        mp3_data[:stereo] = 2
+        mp3_data.channel_mode.should eql :stereo
+      end
+
+      it "is mono for one channel" do
+        mp3_data[:stereo] = 1
+        mp3_data.channel_mode.should eql :mono
+      end
+
+      it "has a sample rate" do
+        mp3_data[:samplerate] = 44100
+        mp3_data.sample_rate.should eql 44100
+      end
+
+    end
+  end
+end

data/spec/integration/decoding_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'wavefile'
+
+describe "Decoding", :slow => true do
+
+  let(:mp3_file_path) { File.expand_path(File.join(File.dirname(__FILE__), '../files/dies-irae-cli-id3v2.mp3')) }
+  let(:mp3_file)      { File.open(mp3_file_path, "r") }
+
+  it "decodes an MP3 file by api" do
+    decoder = LAME::Decoder.new(mp3_file)
+
+    format = WaveFile::Format.new(decoder.channel_mode, :pcm_16, decoder.sample_rate)
+
+    WaveFile::Writer.new("output1.wav", format) do |writer|
+
+      decoder.each_decoded_frame do |decoded_frame|
+        buffer = WaveFile::Buffer.new(decoded_frame.samples, format)
+
+        writer.write(buffer)
+      end
+
+    end
+  end
+
+  it "decodes an MP3 file" do
+    # id3
+    id3_length = id3_length(mp3_file)
+    puts "ID3 length: #{id3_length} bytes"
+    mp3_file.read(id3_length)
+
+    # aid TODO (ignored for now)
+
+    # find MP3 sync frame
+
+    mp3_offset = mpeg_audio_offset(mp3_file, id3_length)
+    puts "offset: #{mp3_offset}"
+
+    @decode_flags = LAME::FFI::DecodeFlags.new
+    @mp3_data = LAME::FFI::MP3Data.new
+
+    # Decode until we have parsed an MP3 header
+    mp3_file.seek(mp3_offset)
+    begin
+      find_header(mp3_file)
+    end until @mp3_data.header_parsed?
+
+    # Results:
+    if @mp3_data.header_parsed?
+      puts "stereo:      #{@mp3_data[:stereo]}"
+      puts "samplerate:  #{@mp3_data[:samplerate]}"
+      puts "bitrate:     #{@mp3_data[:bitrate]}"
+      puts "mode:        #{@mp3_data[:mode]}"
+      puts "mod_ext:     #{@mp3_data[:mod_ext]}"
+      puts "framesize:   #{@mp3_data[:framesize]}"
+      puts "nsamp:       #{@mp3_data[:nsamp]}"
+      puts "totalframes: #{@mp3_data[:totalframes]}"
+      puts "framenum:    #{@mp3_data[:framenum]}"
+    end
+
+    # read mp3_data (number of frames etc)
+    format = WaveFile::Format.new(:stereo, :pcm_16, 44100)
+    WaveFile::Writer.new("output2.wav", format) do |writer|
+
+      # See get_audio.c:2082 #lame_decode_fromfile
+      #
+      # Read until we have decode some MP3 data:
+      @result = 0
+      begin
+        @result = decode(mp3_file)
+
+        if @result && @result.any?
+          left = @result[0].read_array_of_short(@result[0].size/2)
+          right = @result[1].read_array_of_short(@result[1].size/2)
+          buffer = WaveFile::Buffer.new(left.zip(right), format)
+
+          writer.write(buffer)
+        end
+      end until !@result
+    end
+  end
+
+  def find_header(mp3_file)
+    size = 100 # arbitrary, taken from get_audio.c#lame_decode_initfile
+    in_data = mp3_file.read(size)
+
+    in_buffer = LAME::Buffer.create_uchar(in_data)
+    out_left  = LAME::Buffer.create_empty(:short, 0)
+    out_right = LAME::Buffer.create_empty(:short, 0)
+
+    enc_delay   = ::FFI::MemoryPointer.new(:int, 1)
+    enc_padding = ::FFI::MemoryPointer.new(:int, 1)
+
+    result = LAME.hip_decode1_headersB(@decode_flags, in_buffer, size, out_left, out_right, @mp3_data, enc_delay, enc_padding)
+
+    if @mp3_data.header_parsed?
+      puts "header parsed @ #{mp3_file.pos}"
+      puts "enc_delay:   #{enc_delay.read_array_of_int(1)}"
+      puts "enc_padding: #{enc_padding.read_array_of_int(1)}"
+    end
+  end
+
+  def decode(mp3_file)
+    size = 1024 # arbitrary, taken from get_audio.c#lame_decode_fromfile
+    out_left  = LAME::Buffer.create_empty(:short, 1152)
+    out_right = LAME::Buffer.create_empty(:short, 1152)
+
+    in_buffer = LAME::Buffer.create_empty(:uchar, 0)
+
+    # see if we have anything left in the internal decode buffer
+    result = LAME.hip_decode1_headers(@decode_flags, in_buffer, 0, out_left, out_right, @mp3_data)
+
+    case result
+    when -1
+      raise "decoding error (a)"
+    when 0
+      # need more data
+    else
+      return [out_left, out_right]
+    end
+
+    in_data = mp3_file.read(size)
+    if !in_data
+      return nil
+    end
+
+    in_buffer = LAME::Buffer.create_uchar(in_data)
+
+    # else read more data and try again
+    result = LAME.hip_decode1_headers(@decode_flags, in_buffer, size, out_left, out_right, @mp3_data)
+
+    case result
+    when -1
+      raise "decoding error (b)"
+    when 0
+      # need more data
+    else
+      return [out_left, out_right]
+    end
+
+    []
+  end
+
+  def mpeg_audio_offset(mp3_file, offset = 0)
+    mp3_file.seek(offset)
+
+    window_size = 4
+    begin
+      in_data = mp3_file.read(window_size)
+
+      if LAME::Decoding::MPEGAudioFrameMatcher.new(in_data).match?
+        puts "match offset @ #{offset} : #{in_data.bytes.to_a[0].to_s(2)} #{in_data.bytes.to_a[1].to_s(2)} #{in_data.bytes.to_a[2].to_s(2)} #{in_data.bytes.to_a[3].to_s(2)}"
+        return offset
+      end
+
+      offset += 1
+      mp3_file.seek(offset)
+    end while in_data.length == window_size
+  end
+
+  def id3_length(file)
+    header = file.read(10)
+    if id3?(header)
+      size = header[-4..-1]
+
+      b0 = size[0].ord
+      b1 = size[1].ord
+      b2 = size[2].ord
+      b3 = size[3].ord
+
+      # rubify this sometime:
+      (((((b0 << 7) + b1) << 7) + b2) << 7) + b3
+    end
+  end
+
+  def id3?(header)
+    header.start_with?("ID3")
+  end
+
+end

data/spec/integration/encoding_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+require 'wavefile'
+# require 'digest'
+
+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_reader) { WaveFile::Reader.new(wav_path) }
+
+  # This test serves as an example how to use the LAME API
+  it "encodes a wav file" do
+
+   # setup
+    flags_pointer = LAME.lame_init
+    LAME.lame_init_params(flags_pointer)
+
+    # LAME.id3tag_init(flags_pointer) # needed?
+    # LAME.id3tag_set_title(flags_pointer, "foo")
+
+    # number of samples to read
+    framesize = LAME.lame_get_framesize(flags_pointer)
+
+    # input buffers
+    left_buffer  = ::FFI::MemoryPointer.new(:short, framesize)
+    right_buffer = ::FFI::MemoryPointer.new(:short, framesize)
+
+    # output buffer
+    buffer_size = (128*1024)+16384
+    buffer = ::FFI::MemoryPointer.new(:uchar, buffer_size)
+
+    File.open(mp3_path_raw, "wb") do |file|
+      wav_reader.each_buffer(framesize) do |read_buffer|
+
+        # read samples (ranges from -32k to +32k)
+        read_buffer.samples.each.with_index do |(left, right), index|
+          byte_offset = index * 2
+          left_buffer.put_short(byte_offset, left)
+          right_buffer.put_short(byte_offset, right)
+        end
+
+        input_buffer_size = read_buffer.samples.size
+
+        # encode to mp3 frame
+        size = LAME.lame_encode_buffer(
+          flags_pointer,
+          left_buffer, right_buffer, input_buffer_size,
+          buffer, buffer_size
+        )
+
+        # write to file
+        file.write buffer.get_bytes(0, size)
+      end
+
+      # flush final frame
+      size = LAME.lame_encode_flush(flags_pointer, buffer, buffer_size)
+      file.write buffer.get_bytes(0, size)
+
+      # write "lametag" frame with extra info
+      size = LAME.lame_get_lametag_frame(flags_pointer, buffer, buffer_size)
+      file.seek(0)
+      file.write buffer.get_bytes(0, size)
+    end
+
+    # close
+    LAME.lame_close(flags_pointer)
+
+    # TODO: Need a better way to test output..
+    # 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