lame 0.0.1

data/lame.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lame/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "lame"
+  gem.version       = LAME::VERSION
+  gem.authors       = ["Roel van Dijk"]
+  gem.email         = ["roel@rustradio.org"]
+  gem.description   = %q{FFI powered library for the LAME MP3 encoder.}
+  gem.summary       = %q{Easily encode MP3 files using the LAME MP3 encoder.}
+  gem.homepage      = "http://github.com/rdvdijk/lame"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "ffi"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "wavefile"
+  gem.add_development_dependency "ruby-mp3info"
+  gem.add_development_dependency "coveralls"
+end

data/lib/lame.rb

@@ -0,0 +1,31 @@
+require "ffi"
+require "lame/version"
+require "lame/ffi"
+require "lame/error"
+require "lame/delegation"
+require "lame/configuration"
+require "lame/buffer"
+
+require "lame/encoding/encode_short_buffer"
+require "lame/encoding/flusher"
+require "lame/encoding/id3"
+require "lame/encoding/vbr_info"
+require "lame/encoder"
+
+require "lame/decoding/id3_tag_parser"
+require "lame/decoding/mp3_data_header_parser"
+require "lame/decoding/mpeg_audio_frame_matcher"
+require "lame/decoding/mpeg_audio_frame_finder"
+require "lame/decoding/single_frame_decoder"
+require "lame/decoding/stream_decoder"
+require "lame/decoding/decoded_frame"
+require "lame/decoder"
+
+module LAME
+
+  extend ::FFI::Library
+  ffi_lib "libmp3lame"
+
+  include FFI
+
+end

data/lib/lame/buffer.rb

@@ -0,0 +1,21 @@
+module LAME
+  class Buffer
+
+    def self.create(type, input)
+      buffer = ::FFI::MemoryPointer.new(type, input.size)
+      buffer.put_array_of_short(0, input)
+      buffer
+    end
+
+    def self.create_uchar(input)
+      buffer = ::FFI::MemoryPointer.new(:uchar, input.size)
+      buffer.put_array_of_uchar(0, input.bytes.to_a)
+      buffer
+    end
+
+    def self.create_empty(type, size)
+      ::FFI::MemoryPointer.new(type, size)
+    end
+
+  end
+end

data/lib/lame/configuration.rb

@@ -0,0 +1,228 @@
+module LAME
+  class ConfigurationBase
+    extend Delegation
+
+    attr_reader :global_flags
+
+    def initialize(global_flags)
+      @global_flags = global_flags
+    end
+
+    private
+
+    def boolean_to_int(value)
+      Delegation::TypeConvertor.convert(value)
+    end
+  end
+
+  class Configuration < ConfigurationBase
+
+    delegate_alias_to_lame :number_of_samples => :num_samples,
+      :number_of_channels          => :num_channels,
+      :input_samplerate            => :in_samplerate,
+      :output_samplerate           => :out_samplerate,
+      :force_mid_side              => :force_ms,
+      :replay_gain                 => :findReplayGain,
+      :bitrate                     => :brate,
+      :strict_iso                  => :strict_ISO,
+      :allow_different_block_types => :allow_diff_short,
+      :temporal_masking            => :useTemporal,
+      :inter_channel_ratio         => :interChRatio,
+      :disable_short_blocks        => :no_short_blocks
+
+    delegate_to_lame :scale, :scale_left, :scale_right, :analysis,
+      :decode_only, :quality, :mode, :free_format, :decode_on_the_fly,
+      :preset, :copyright, :original, :error_protection, :extension,
+      :force_short_blocks, :emphasis
+
+    def apply!
+      init_return = LAME.lame_init_params(global_flags)
+      if init_return == -1
+        raise ConfigurationError
+      else
+        @applied = true
+      end
+    end
+
+    def applied?
+      @applied
+    end
+
+    def framesize
+      raise ConfigurationError unless applied?
+      LAME.lame_get_framesize(global_flags)
+    end
+
+    def output_buffer_size
+      ((framesize * 1.25) + 7200).ceil
+    end
+
+    def asm_optimization
+      @asm_optimization ||= AsmOptimization.new(global_flags)
+    end
+
+    def id3
+      @id3 ||= Id3.new(global_flags)
+    end
+
+    def quantization
+      @quantization ||= Quantization.new(global_flags)
+    end
+
+    def vbr
+      @vbr ||= VBR.new(global_flags)
+    end
+
+    def filtering
+      @filtering ||= Filtering.new(global_flags)
+    end
+
+    def psycho_acoustics
+      @psycho_acoustics ||= PsychoAcoustics.new(global_flags)
+    end
+
+    class AsmOptimization < ConfigurationBase
+      def mmx=(value)
+        LAME.lame_set_asm_optimizations(global_flags, :MMX, boolean_to_int(value))
+      end
+
+      def amd_3dnow=(value)
+        LAME.lame_set_asm_optimizations(global_flags, :AMD_3DNOW, boolean_to_int(value))
+      end
+
+      def sse=(value)
+        LAME.lame_set_asm_optimizations(global_flags, :SSE, boolean_to_int(value))
+      end
+    end
+
+    class Id3 < ConfigurationBase
+
+      delegate_alias_to_lame :write_automatic => :write_id3tag_automatic
+
+      delegate_id3_to_lame :title, :artist, :album, :year, :comment
+
+      def initialize(global_flags)
+        super(global_flags)
+        LAME.id3tag_init(global_flags)
+      end
+
+      def v2=(value)
+        LAME.id3tag_add_v2(global_flags) if value
+      end
+
+      def v1_only=(value)
+        LAME.id3tag_v1_only(global_flags) if value
+      end
+
+      def v2_only=(value)
+        LAME.id3tag_v2_only(global_flags) if value
+      end
+
+      def v1_space=(value)
+        LAME.id3tag_space_v1(global_flags) if value
+      end
+
+      def v2_padding=(value)
+        LAME.id3tag_pad_v2(global_flags) if value
+      end
+
+      def v2_padding_size=(size)
+        LAME.id3tag_set_pad(global_flags, size)
+      end
+
+      def track=(value)
+        LAME.id3tag_set_track(global_flags, value)
+      end
+
+      def genre=(value)
+        genre_id = find_genre_id_by_name(value)
+        genre_id_string = ::FFI::MemoryPointer.from_string(genre_id.to_s)
+
+        LAME.id3tag_set_genre(global_flags, genre_id_string)
+      end
+
+      private
+
+      def find_genre_id_by_name(name)
+        genres[name] || name
+      end
+
+      def genres
+        @genres ||= begin
+                      genres = {}
+
+                      genre_collector_callback = ::FFI::Function.new(:void, [:int, :string, :pointer]) do |id, name, _|
+                        genres[name] = id
+                      end
+                      LAME.id3tag_genre_list(genre_collector_callback, nil)
+
+                      genres
+                    end
+      end
+    end
+
+    class Quantization < ConfigurationBase
+      delegate_alias_to_lame :comp => :quant_comp,
+        :comp_short     => :quant_comp_short,
+        :experimental_x => :experimentalX,
+        :experimental_y => :experimentalY,
+        :experimental_z => :experimentalZ,
+        :naoki          => :exp_nspsytune
+
+      delegate_to_lame :msfix
+
+      def reservoir=(value)
+        LAME.lame_set_disable_reservoir(global_flags, boolean_to_int(!value))
+      end
+
+      def reservoir
+        LAME.lame_get_disable_reservoir(global_flags)
+      end
+
+      def reservoir?
+        Delegation::TypeConvertor.convert_return(reservoir)
+      end
+    end
+
+    class VBR < ConfigurationBase
+      delegate_alias_to_lame :write_tag => :bWriteVbrTag,
+        :mode                => :VBR,
+        :q                   => :VBR_q,
+        :quality             => :VBR_quality,
+        :mean_bitrate        => :VBR_mean_bitrate_kbps,
+        :min_bitrate         => :VBR_min_bitrate_kbps,
+        :max_bitrate         => :VBR_max_bitrate_kbps,
+        :enforce_min_bitrate => :VBR_hard_min
+    end
+
+    class Filtering < ConfigurationBase
+      delegate_alias_to_lame :low_pass_frequency => :lowpassfreq,
+        :low_pass_width      => :lowpasswidth,
+        :high_pass_frequency => :highpassfreq,
+        :high_pass_width     => :highpasswidth
+    end
+
+    class PsychoAcoustics < ConfigurationBase
+      delegate_alias_to_lame :ath_only => :ATHonly,
+        :ath_short => :ATHshort,
+        :ath_type => :ATHtype,
+        :ath_lower => :ATHlower
+
+      delegate_to_lame :athaa_type, :athaa_sensitivity
+
+      def ath=(value)
+        LAME.lame_set_noATH(global_flags, boolean_to_int(!value))
+      end
+
+      def ath
+        LAME.lame_get_noATH(global_flags)
+      end
+
+      def ath?
+        !Delegation::TypeConvertor.convert_return(ath)
+      end
+
+    end
+
+  end
+end

data/lib/lame/decoder.rb

@@ -0,0 +1,38 @@
+module LAME
+  class Decoder
+    extend Forwardable
+
+    attr_reader :decode_flags, :mp3_file, :mp3_data
+
+    def_delegators :mp3_data, :channel_mode, :sample_rate
+
+    def initialize(mp3_file)
+      @decode_flags = FFI::DecodeFlags.new
+      @mp3_file = mp3_file
+
+      skip_id3_tag
+      @mp3_data = parse_mp3_data
+    end
+
+    def each_decoded_frame
+      stream_decoder.each_decoded_frame do |decoded_frame|
+        yield decoded_frame
+      end
+    end
+
+    private
+
+    def stream_decoder
+      @stream_decoder ||= Decoding::StreamDecoder.new(decode_flags, mp3_data, mp3_file)
+    end
+
+    def skip_id3_tag
+      Decoding::Id3TagParser.new(mp3_file).skip!
+    end
+
+    def parse_mp3_data
+      Decoding::Mp3DataHeaderParser.new(decode_flags, mp3_file).parse!
+    end
+
+  end
+end

data/lib/lame/decoding/decoded_frame.rb

@@ -0,0 +1,25 @@
+module LAME
+  module Decoding
+    class DecodedFrame
+
+      attr_reader :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def self.from_short_buffers(left_buffer, right_buffer)
+        left  = left_buffer.read_array_of_short(left_buffer.size/2)
+        right = right_buffer.read_array_of_short(right_buffer.size/2)
+
+        new(left, right)
+      end
+
+      def samples
+        left.zip(right)
+      end
+
+    end
+  end
+end

data/lib/lame/decoding/id3_tag_parser.rb

@@ -0,0 +1,53 @@
+module LAME
+  module Decoding
+
+    # http://id3.org/id3v2.4.0-structure
+    # Section 3.1. ID3v2 header
+    #
+    # 10 bytes header:
+    # - "ID3"
+    # - "xx" version (2 bytes)
+    # - "x" flags (1 byte)
+    # - "xxxx" size (4 bytes)
+    class Id3TagParser
+
+      HEADER_SIZE = 10
+
+      def initialize(file)
+        @file = file
+      end
+
+      def skip!
+        @file.seek(0)
+        @file.seek(id3_length)
+      end
+
+      private
+
+      def id3_length
+        header = @file.read(HEADER_SIZE)
+
+        if id3?(header)
+          HEADER_SIZE + parse_id3_tag_length(header[-4..-1])
+        else
+          0
+        end
+      end
+
+      def parse_id3_tag_length(size_bits)
+        b0 = size_bits[0].ord
+        b1 = size_bits[1].ord
+        b2 = size_bits[2].ord
+        b3 = size_bits[3].ord
+
+        # rubify this sometime:
+        (((((b0 << 7) + b1) << 7) + b2) << 7) + b3
+      end
+
+      def id3?(header)
+        header.start_with?("ID3")
+      end
+
+    end
+  end
+end

data/lib/lame/decoding/mp3_data_header_parser.rb

@@ -0,0 +1,64 @@
+module LAME
+  module Decoding
+    class Mp3DataHeaderParser
+
+      SIZE = 100
+
+      def initialize(decode_flags, stream)
+        @decode_flags = decode_flags
+        @stream = stream
+        @mp3_data = LAME::FFI::MP3Data.new
+      end
+
+      def parse!
+        find_first_mpeg_audio_frame!
+        parse_mp3_data_header!
+      end
+
+      private
+
+      def find_first_mpeg_audio_frame!
+        MPEGAudioFrameFinder.new(@stream).find!
+      end
+
+      def parse_mp3_data_header!
+        begin
+          @data = @stream.read(SIZE)
+          parse_headers
+        end until parsed? || end_of_stream?
+
+        if parsed?
+          @mp3_data
+        else
+          raise Mp3DataHeaderNotFoundError
+        end
+      end
+
+      def parse_headers
+        return if !@data
+
+        in_buffer = LAME::Buffer.create_uchar(@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)
+
+        LAME.hip_decode1_headersB(@decode_flags,
+                                  in_buffer, @data.length,
+                                  out_left, out_right,
+                                  @mp3_data,
+                                  enc_delay, enc_padding)
+      end
+
+      def parsed?
+        @mp3_data.header_parsed?
+      end
+
+      def end_of_stream?
+        !@data
+      end
+
+    end
+  end
+end