lame 0.0.1

data/lib/lame/decoding/mpeg_audio_frame_finder.rb

@@ -0,0 +1,46 @@
+module LAME
+  module Decoding
+    class MPEGAudioFrameFinder
+
+      MPEG_HEADER_SIZE = 4
+
+      def initialize(stream)
+        @stream = stream
+      end
+
+      def find!
+        begin
+          @data = @stream.read(MPEG_HEADER_SIZE)
+          if MPEGAudioFrameMatcher.new(@data).match?
+            seek_back!
+            return
+          end
+          seek!
+        end until end_of_stream?
+
+        raise MPEGAudioFrameNotFoundError
+      end
+
+      private
+
+      def offset
+        @stream.pos
+      end
+
+      # Move to next 4 bytes.
+      def seek!
+        @stream.seek(offset - (MPEG_HEADER_SIZE-1))
+      end
+
+      # Move back to frame position.
+      def seek_back!
+        @stream.seek(offset - (MPEG_HEADER_SIZE))
+      end
+
+      def end_of_stream?
+        !@data || (@data.size != MPEG_HEADER_SIZE)
+      end
+
+    end
+  end
+end

data/lib/lame/decoding/mpeg_audio_frame_matcher.rb

@@ -0,0 +1,98 @@
+module LAME
+  module Decoding
+
+    # Specification is here:
+    # http://www.codeproject.com/Articles/8295/MPEG-Audio-Frame-Header
+    #
+    # Also see `is_syncword_mp123` in lame-3.99.5/frontend/get_audio.c
+    #
+    # Get ready for some bit-matching magic:
+    class MPEGAudioFrameMatcher
+
+      attr_reader :bytes
+
+      CHANNEL_MODES = [:stereo, :joint_stereo, :dual_channel, :mono]
+
+      def initialize(bytes)
+        @bytes = bytes.unpack("C*")
+      end
+
+      def match?
+        leading_bits? &&
+          mpeg? &&
+          layer? &&
+          bitrate? &&
+          sample_frequency? &&
+          valid_mpeg1_layer2? &&
+          emphasis?
+      end
+
+      private
+
+      # First eleven bits (all 1)
+      def leading_bits?
+        (bytes[0] & 0b11111111) == 0b11111111 &&
+          (bytes[1] & 0b11100000) == 0b11100000
+      end
+
+      # 4th and 5th bit in second byte (01 is reserved)
+      def mpeg?
+        (bytes[1] & 0b11000) != 0b01000
+      end
+
+      # 6th and 7th bit in second byte (00 is reserved)
+      def layer?
+        (bytes[1] & 0b110) != 0b000
+      end
+
+      # first 4 bits in third byte (all 1's is reserved)
+      def bitrate?
+        (bytes[2] & 0b11110000) != 0b11110000
+      end
+
+      # 5th and 6th bit in third byte (all 1's is reserved)
+      def sample_frequency?
+        (bytes[2] & 0b1100) != 0b1100
+      end
+
+      # http://www.codeproject.com/Articles/8295/MPEG-Audio-Frame-Header#Combinations
+      # Only certain combination are valid for MPEG1 Layer II:
+      def valid_mpeg1_layer2?
+        return true if !mpeg1?
+        return true if !layer2?
+
+        bitrate_index = (bytes[2] >> 4)
+
+        case bitrate_index
+        when 1,2,3,5
+          channel_mode == :mono
+        when 11,12,13,14
+          [:stereo, :joint_stereo, :dual_channel].include?(channel_mode)
+        else
+          true
+        end
+      end
+
+      # 7th and 8th bit in fourth byte (10 is reserved)
+      def emphasis?
+        (bytes[3] & 0b11) != 0b10
+      end
+
+      # MPEG1 = 11
+      def mpeg1?
+        (bytes[1] & 0b11000) == 0b11000
+      end
+
+      # Layer II = 10
+      def layer2?
+        (bytes[1] & 0b110) == 0b100
+      end
+
+      # 1st and 2nd bit of fourth byte
+      def channel_mode
+        @channel_mode ||= CHANNEL_MODES[bytes[3] >> 6]
+      end
+
+    end
+  end
+end

data/lib/lame/decoding/single_frame_decoder.rb

@@ -0,0 +1,51 @@
+module LAME
+  module Decoding
+    class SingleFrameDecoder
+
+      def initialize(decode_flags, mp3_data)
+        @decode_flags = decode_flags
+        @mp3_data = mp3_data
+      end
+
+      def decode(data)
+        flush_buffer do |decoded_frame|
+          yield decoded_frame
+        end
+        decode_data(data) do |decoded_frame|
+          yield decoded_frame
+        end
+      end
+
+      private
+
+      def flush_buffer(&block)
+        in_buffer = LAME::Buffer.create_empty(:uchar, 0)
+        decode_buffer(in_buffer, &block)
+      end
+
+      def decode_data(data, &block)
+        in_buffer = LAME::Buffer.create_uchar(data)
+        decode_buffer(in_buffer, &block)
+      end
+
+      def decode_buffer(in_buffer, &block)
+        out_left, out_right = output_buffers
+        result = LAME.hip_decode1_headers(@decode_flags, in_buffer, in_buffer.size, out_left, out_right, @mp3_data)
+
+        if result > 0
+          yield DecodedFrame.from_short_buffers(out_left, out_right)
+          flush_buffer(&block)
+        end
+
+        raise DecodingError if result < 0
+      end
+
+      def output_buffers
+        out_left  = LAME::Buffer.create_empty(:short, 1152)
+        out_right = LAME::Buffer.create_empty(:short, 1152)
+        [out_left, out_right]
+      end
+
+    end
+  end
+end

data/lib/lame/decoding/stream_decoder.rb

@@ -0,0 +1,37 @@
+module LAME
+  module Decoding
+    class StreamDecoder
+
+      # arbitrary, taken from get_audio.c#lame_decode_fromfile
+      DECODE_SIZE = 1024
+
+      def initialize(decode_flags, mp3_data, stream)
+        @stream = stream
+        @single_frame_decoder = SingleFrameDecoder.new(decode_flags, mp3_data)
+      end
+
+      def each_decoded_frame(&block)
+        begin
+          @data = @stream.read(DECODE_SIZE)
+
+          decode &block
+        end until end_of_stream?
+      end
+
+      private
+
+      def decode
+        return if end_of_stream?
+
+        @single_frame_decoder.decode(@data) do |decoded_frame|
+          yield decoded_frame
+        end
+      end
+
+      def end_of_stream?
+        !@data
+      end
+
+    end
+  end
+end

data/lib/lame/delegation.rb

@@ -0,0 +1,68 @@
+module LAME
+  module Delegation
+
+    def delegate_to_lame(*delegations)
+      delegations.each do |flag|
+        define_setter_delegator(flag, flag)
+        define_getter_delegator(flag, flag)
+      end
+    end
+
+    def delegate_alias_to_lame(delegations)
+      delegations.each_pair do |from, to|
+        define_setter_delegator(from, to)
+        define_getter_delegator(from, to)
+      end
+    end
+
+    def delegate_id3_to_lame(*delegations)
+      delegations.each do |flag|
+        define_setter_delegator(flag, flag, "id3tag")
+      end
+    end
+
+    private
+
+    def define_setter_delegator(from, to, preset = "lame")
+      define_method(:"#{from}=") do |value|
+        value = TypeConvertor.convert(value)
+        LAME.send(:"#{preset}_set_#{to}", global_flags, value)
+      end
+    end
+
+    def define_getter_delegator(from, to, preset = "lame")
+      define_method(:"#{from}") do
+        LAME.send(:"#{preset}_get_#{to}", global_flags)
+      end
+      define_method(:"#{from}?") do
+        return_value = send(:"#{from}")
+        TypeConvertor.convert_return(return_value)
+      end
+    end
+
+    class TypeConvertor
+      def self.convert(value)
+        case value
+        when true
+          1
+        when false
+          0
+        when String
+          ::FFI::MemoryPointer.from_string(value)
+        else
+          value
+        end
+      end
+
+      def self.convert_return(value)
+        case value
+        when 0
+          false
+        else
+          !!value
+        end
+      end
+    end
+
+  end
+end

data/lib/lame/encoder.rb

@@ -0,0 +1,73 @@
+module LAME
+  class Encoder
+
+    attr_reader :global_flags
+
+    def initialize
+      @global_flags = FFI::GlobalFlags.new
+    end
+
+    def configure
+      yield configuration
+      apply_configuration
+    end
+
+    def encode_short(left, right)
+      apply_configuration
+
+      each_frame(left, right) do |left_frame, right_frame|
+        mp3_data = Encoding::EncodeShortBuffer.new(configuration).encode_frame(left_frame, right_frame)
+        yield mp3_data
+      end
+    end
+
+    def flush(&block)
+      mp3_data = Encoding::Flusher.new(configuration).flush
+      yield_or_return(mp3_data, &block)
+    end
+
+    def vbr_frame(&block)
+      mp3_data = Encoding::VBRInfo.new(configuration).frame
+      yield_or_return(mp3_data, &block)
+    end
+
+    def id3v1(&block)
+      mp3_data = Encoding::Id3.new(configuration).v1
+      yield_or_return(mp3_data, &block)
+    end
+
+    def id3v2(&block)
+      mp3_data = Encoding::Id3.new(configuration).v2
+      yield_or_return(mp3_data, &block)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new(global_flags)
+    end
+
+    def framesize
+      configuration.framesize
+    end
+
+    private
+
+    def apply_configuration
+      configuration.apply! unless configuration.applied?
+    end
+
+    def each_frame(left, right)
+      left.zip(right).each_slice(framesize) do |slice|
+        yield slice.transpose
+      end
+    end
+
+    def yield_or_return(value)
+      if block_given?
+        yield value
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/lame/encoding/encode_short_buffer.rb

@@ -0,0 +1,26 @@
+module LAME
+  module Encoding
+    class EncodeShortBuffer
+      extend Forwardable
+
+      def_delegators :@configuration, :global_flags, :framesize, :output_buffer_size
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def encode_frame(left, right)
+        left_buffer  = Buffer.create(:short, left)
+        right_buffer = Buffer.create(:short, right)
+        output       = Buffer.create_empty(:uchar, output_buffer_size)
+
+        mp3_size = LAME.lame_encode_buffer(global_flags,
+                                           left_buffer, right_buffer, left.size,
+                                           output, output_buffer_size)
+
+        output.get_bytes(0, mp3_size)
+      end
+
+    end
+  end
+end

data/lib/lame/encoding/flusher.rb

@@ -0,0 +1,22 @@
+module LAME
+  module Encoding
+    class Flusher
+      extend Forwardable
+
+      def_delegators :@configuration, :global_flags, :framesize, :output_buffer_size
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def flush
+        output = Buffer.create_empty(:uchar, output_buffer_size)
+
+        mp3_size = LAME.lame_encode_flush(global_flags, output, output_buffer_size)
+
+        output.get_bytes(0, mp3_size)
+      end
+
+    end
+  end
+end

data/lib/lame/encoding/id3.rb

@@ -0,0 +1,46 @@
+module LAME
+  module Encoding
+    class Id3
+      extend Forwardable
+
+      def_delegators :@configuration, :global_flags, :framesize, :output_buffer_size
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def v1
+        tag_size = v1_tag_size
+        output = output_buffer(tag_size)
+        LAME.lame_get_id3v1_tag(global_flags, output, tag_size)
+        output.get_bytes(0, tag_size)
+      end
+
+      def v2
+        tag_size = v2_tag_size
+        output = output_buffer(tag_size)
+        LAME.lame_get_id3v2_tag(global_flags, output, tag_size)
+        output.get_bytes(0, tag_size)
+      end
+
+      private
+
+      def output_buffer(size)
+        Buffer.create_empty(:uchar, size)
+      end
+
+      # LAME returns the required buffer size if the input buffer is too small.
+      def v1_tag_size
+        small_buffer = output_buffer(0)
+        LAME.lame_get_id3v1_tag(global_flags, small_buffer, 0)
+      end
+
+      # LAME returns the required buffer size if the input buffer is too small.
+      def v2_tag_size
+        small_buffer = output_buffer(0)
+        LAME.lame_get_id3v2_tag(global_flags, small_buffer, 0)
+      end
+
+    end
+  end
+end