lamer 0.1.2 → 1.0.0

data/lib/lamer/encoder.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+class Lamer
+  class Encoder
+    FLUSH_BUFFER_SIZE = 7200
+    OUTPUT_BUFFER_SAFETY_MARGIN = 1.25
+
+    attr_reader :global_flags
+
+    def initialize(options = {})
+      @global_flags = FFI.lame_init
+      raise Error, "Failed to initialize LAME encoder" if @global_flags.null?
+
+      @initialized = false
+      configure(options)
+
+      ObjectSpace.define_finalizer(self, self.class.release(@global_flags))
+    end
+
+    def self.release(gfp)
+      proc { FFI.lame_close(gfp) unless gfp.null? }
+    end
+
+    def configure(options)
+      raise ConfigurationError, "Cannot configure after encoding has started" if @initialized
+
+      FFI.lame_set_brate(@global_flags, options[:bitrate]) if options[:bitrate]
+      FFI.lame_set_in_samplerate(@global_flags, options[:in_samplerate]) if options[:in_samplerate]
+      FFI.lame_set_out_samplerate(@global_flags, options[:out_samplerate]) if options[:out_samplerate]
+      FFI.lame_set_num_channels(@global_flags, options[:num_channels]) if options[:num_channels]
+      FFI.lame_set_quality(@global_flags, options[:quality]) if options[:quality]
+
+      if options[:mode]
+        mode = case options[:mode]
+               when :mono then :mono
+               when :stereo then :stereo
+               when :joint, :joint_stereo then :joint_stereo
+               when :dual, :dual_channel then :dual_channel
+               else options[:mode]
+               end
+        FFI.lame_set_mode(@global_flags, mode)
+      end
+
+      if options[:vbr]
+        FFI.lame_set_VBR(@global_flags, :vbr_mtrh)
+        FFI.lame_set_VBR_q(@global_flags, options[:vbr_quality]) if options[:vbr_quality]
+      end
+
+      FFI.lame_set_lowpassfreq(@global_flags, options[:lowpass]) if options[:lowpass]
+      FFI.lame_set_highpassfreq(@global_flags, options[:highpass]) if options[:highpass]
+    end
+
+    def apply_id3(id3_options)
+      raise ConfigurationError, "Cannot set ID3 tags after encoding has started" if @initialized
+
+      FFI.id3tag_init(@global_flags)
+      FFI.id3tag_add_v2(@global_flags)
+
+      FFI.id3tag_set_title(@global_flags, id3_options[:title].to_s) if id3_options[:title]
+      FFI.id3tag_set_artist(@global_flags, id3_options[:artist].to_s) if id3_options[:artist]
+      FFI.id3tag_set_album(@global_flags, id3_options[:album].to_s) if id3_options[:album]
+      FFI.id3tag_set_year(@global_flags, id3_options[:year].to_s) if id3_options[:year]
+      FFI.id3tag_set_comment(@global_flags, id3_options[:comment].to_s) if id3_options[:comment]
+      FFI.id3tag_set_track(@global_flags, id3_options[:track_number].to_s) if id3_options[:track_number]
+      FFI.id3tag_set_genre(@global_flags, id3_options[:genre].to_s) if id3_options[:genre]
+
+      if id3_options[:version] == 1
+        FFI.id3tag_v1_only(@global_flags)
+      elsif id3_options[:version] == 2
+        FFI.id3tag_v2_only(@global_flags)
+      end
+    end
+
+    def init_params!
+      return if @initialized
+
+      ret = FFI.lame_init_params(@global_flags)
+      raise ConfigurationError, "Failed to initialize LAME parameters (error code: #{ret})" if ret < 0
+
+      @initialized = true
+    end
+
+    def encode_short(left_samples, right_samples = nil)
+      init_params!
+
+      num_samples = left_samples.size
+      right_samples ||= left_samples
+
+      mp3buf_size = calculate_buffer_size(num_samples)
+      mp3buf = ::FFI::MemoryPointer.new(:uchar, mp3buf_size)
+
+      left_ptr = ::FFI::MemoryPointer.new(:short, num_samples)
+      left_ptr.write_array_of_int16(left_samples)
+
+      right_ptr = ::FFI::MemoryPointer.new(:short, num_samples)
+      right_ptr.write_array_of_int16(right_samples)
+
+      bytes = FFI.lame_encode_buffer(@global_flags, left_ptr, right_ptr, num_samples, mp3buf, mp3buf_size)
+      raise EncodingError, "Encoding failed with error code: #{bytes}" if bytes < 0
+
+      mp3buf.read_bytes(bytes)
+    end
+
+    def encode_short_interleaved(interleaved_samples)
+      init_params!
+
+      num_samples = interleaved_samples.size / 2
+
+      mp3buf_size = calculate_buffer_size(num_samples)
+      mp3buf = ::FFI::MemoryPointer.new(:uchar, mp3buf_size)
+
+      pcm_ptr = ::FFI::MemoryPointer.new(:short, interleaved_samples.size)
+      pcm_ptr.write_array_of_int16(interleaved_samples)
+
+      bytes = FFI.lame_encode_buffer_interleaved(@global_flags, pcm_ptr, num_samples, mp3buf, mp3buf_size)
+      raise EncodingError, "Encoding failed with error code: #{bytes}" if bytes < 0
+
+      mp3buf.read_bytes(bytes)
+    end
+
+    def encode_float(left_samples, right_samples = nil)
+      init_params!
+
+      num_samples = left_samples.size
+      right_samples ||= left_samples
+
+      mp3buf_size = calculate_buffer_size(num_samples)
+      mp3buf = ::FFI::MemoryPointer.new(:uchar, mp3buf_size)
+
+      left_ptr = ::FFI::MemoryPointer.new(:float, num_samples)
+      left_ptr.write_array_of_float(left_samples)
+
+      right_ptr = ::FFI::MemoryPointer.new(:float, num_samples)
+      right_ptr.write_array_of_float(right_samples)
+
+      bytes = FFI.lame_encode_buffer_ieee_float(@global_flags, left_ptr, right_ptr, num_samples, mp3buf, mp3buf_size)
+      raise EncodingError, "Encoding failed with error code: #{bytes}" if bytes < 0
+
+      mp3buf.read_bytes(bytes)
+    end
+
+    def flush
+      init_params!
+
+      mp3buf = ::FFI::MemoryPointer.new(:uchar, FLUSH_BUFFER_SIZE)
+      bytes = FFI.lame_encode_flush(@global_flags, mp3buf, FLUSH_BUFFER_SIZE)
+      raise EncodingError, "Flush failed with error code: #{bytes}" if bytes < 0
+
+      mp3buf.read_bytes(bytes)
+    end
+
+    def encode_file(input_path, output_path, decode_mp3: false)
+      pcm_data = if decode_mp3 || input_path.end_with?(".mp3")
+        read_mp3_file(input_path)
+      else
+        read_wav_file(input_path)
+      end
+
+      File.open(output_path, "wb") do |output|
+        pcm_data[:samples].each_slice(pcm_data[:chunk_size]) do |chunk|
+          if pcm_data[:channels] == 2
+            mp3_data = encode_short_interleaved(chunk)
+          else
+            mp3_data = encode_short(chunk)
+          end
+          output.write(mp3_data)
+        end
+        output.write(flush)
+      end
+    end
+
+    private
+
+    def read_mp3_file(path)
+      decoder = Lamer::Decoder.new
+      result = decoder.decode_buffer(File.binread(path))
+
+      channels = result[:channels] > 0 ? result[:channels] : 2
+      sample_rate = result[:sample_rate] > 0 ? result[:sample_rate] : 44100
+
+      samples = if channels == 2 && result[:right]
+        result[:left].zip(result[:right]).flatten
+      else
+        result[:left]
+      end
+
+      FFI.lame_set_in_samplerate(@global_flags, sample_rate)
+      FFI.lame_set_num_channels(@global_flags, channels)
+
+      {
+        samples: samples,
+        channels: channels,
+        sample_rate: sample_rate,
+        chunk_size: sample_rate * channels
+      }
+    end
+
+    def calculate_buffer_size(num_samples)
+      ((num_samples * OUTPUT_BUFFER_SAFETY_MARGIN) + FLUSH_BUFFER_SIZE).ceil
+    end
+
+    def read_wav_file(path)
+      File.open(path, "rb") do |file|
+        riff = file.read(4)
+        raise Error, "Not a valid WAV file: missing RIFF header" unless riff == "RIFF"
+
+        file.read(4) # file size
+        wave = file.read(4)
+        raise Error, "Not a valid WAV file: missing WAVE format" unless wave == "WAVE"
+
+        fmt_chunk = nil
+        data_chunk = nil
+
+        while !file.eof?
+          chunk_id = file.read(4)
+          break if chunk_id.nil? || chunk_id.size < 4
+
+          chunk_size = file.read(4).unpack1("V")
+
+          case chunk_id
+          when "fmt "
+            fmt_data = file.read(chunk_size)
+            audio_format, channels, sample_rate, byte_rate, block_align, bits_per_sample = fmt_data.unpack("vvVVvv")
+            fmt_chunk = {
+              audio_format: audio_format,
+              channels: channels,
+              sample_rate: sample_rate,
+              byte_rate: byte_rate,
+              block_align: block_align,
+              bits_per_sample: bits_per_sample
+            }
+          when "data"
+            data_chunk = file.read(chunk_size)
+            break
+          else
+            file.seek(chunk_size, IO::SEEK_CUR)
+          end
+        end
+
+        raise Error, "Invalid WAV file: missing fmt chunk" unless fmt_chunk
+        raise Error, "Invalid WAV file: missing data chunk" unless data_chunk
+        raise Error, "Only 16-bit PCM WAV files are supported" unless fmt_chunk[:bits_per_sample] == 16
+
+        FFI.lame_set_in_samplerate(@global_flags, fmt_chunk[:sample_rate])
+        FFI.lame_set_num_channels(@global_flags, fmt_chunk[:channels])
+
+        samples = data_chunk.unpack("s*")
+
+        {
+          samples: samples,
+          channels: fmt_chunk[:channels],
+          sample_rate: fmt_chunk[:sample_rate],
+          chunk_size: fmt_chunk[:sample_rate] * fmt_chunk[:channels]
+        }
+      end
+    end
+  end
+end

data/lib/lamer/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Lamer
+  class Error < StandardError; end
+  class EncodingError < Error; end
+  class DecodingError < Error; end
+  class ConfigurationError < Error; end
+end

data/lib/lamer/ffi/enums.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Lamer
+  module FFI
+    # VBR mode enumeration from lame.h
+    VBR_MODE = enum :vbr_mode, [
+      :vbr_off, 0,
+      :vbr_mt,
+      :vbr_rh,
+      :vbr_abr,
+      :vbr_mtrh,
+      :vbr_max_indicator
+    ]
+
+    # MPEG mode enumeration from lame.h
+    MPEG_MODE = enum :mpeg_mode, [
+      :stereo, 0,
+      :joint_stereo,
+      :dual_channel,
+      :mono,
+      :not_set,
+      :max_indicator
+    ]
+
+    # Preset modes
+    PRESET_MODE = enum :preset_mode, [
+      :v9, 410,
+      :v8, 420,
+      :v7, 430,
+      :v6, 440,
+      :v5, 450,
+      :v4, 460,
+      :v3, 470,
+      :v2, 480,
+      :v1, 490,
+      :v0, 500,
+      :r3mix, 1000,
+      :standard, 1001,
+      :extreme, 1002,
+      :insane, 1003,
+      :standard_fast, 1004,
+      :extreme_fast, 1005,
+      :medium, 1006,
+      :medium_fast, 1007
+    ]
+  end
+end

data/lib/lamer/ffi/functions.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+class Lamer
+  module FFI
+    # Core lifecycle functions
+    attach_function :lame_init, [], :pointer
+    attach_function :lame_init_params, [:pointer], :int
+    attach_function :lame_close, [:pointer], :int
+
+    # Version info
+    attach_function :get_lame_version, [], :string
+    attach_function :get_lame_short_version, [], :string
+
+    # Input settings
+    attach_function :lame_set_num_samples, [:pointer, :ulong], :int
+    attach_function :lame_get_num_samples, [:pointer], :ulong
+    attach_function :lame_set_in_samplerate, [:pointer, :int], :int
+    attach_function :lame_get_in_samplerate, [:pointer], :int
+    attach_function :lame_set_num_channels, [:pointer, :int], :int
+    attach_function :lame_get_num_channels, [:pointer], :int
+
+    # Output settings
+    attach_function :lame_set_out_samplerate, [:pointer, :int], :int
+    attach_function :lame_get_out_samplerate, [:pointer], :int
+
+    # Quality and mode settings
+    attach_function :lame_set_quality, [:pointer, :int], :int
+    attach_function :lame_get_quality, [:pointer], :int
+    attach_function :lame_set_brate, [:pointer, :int], :int
+    attach_function :lame_get_brate, [:pointer], :int
+    attach_function :lame_set_mode, [:pointer, :mpeg_mode], :int
+    attach_function :lame_get_mode, [:pointer], :mpeg_mode
+
+    # VBR settings
+    attach_function :lame_set_VBR, [:pointer, :vbr_mode], :int
+    attach_function :lame_get_VBR, [:pointer], :vbr_mode
+    attach_function :lame_set_VBR_q, [:pointer, :int], :int
+    attach_function :lame_get_VBR_q, [:pointer], :int
+    attach_function :lame_set_VBR_quality, [:pointer, :float], :int
+    attach_function :lame_get_VBR_quality, [:pointer], :float
+    attach_function :lame_set_VBR_min_bitrate_kbps, [:pointer, :int], :int
+    attach_function :lame_set_VBR_max_bitrate_kbps, [:pointer, :int], :int
+
+    # Filtering
+    attach_function :lame_set_lowpassfreq, [:pointer, :int], :int
+    attach_function :lame_get_lowpassfreq, [:pointer], :int
+    attach_function :lame_set_highpassfreq, [:pointer, :int], :int
+    attach_function :lame_get_highpassfreq, [:pointer], :int
+
+    # Psychoacoustic settings
+    attach_function :lame_set_ATHonly, [:pointer, :int], :int
+    attach_function :lame_set_ATHshort, [:pointer, :int], :int
+    attach_function :lame_set_noATH, [:pointer, :int], :int
+
+    # Encoding functions - 16-bit signed integer PCM
+    attach_function :lame_encode_buffer, [
+      :pointer,  # gfp (global flags pointer)
+      :pointer,  # buffer_l (left channel, short*)
+      :pointer,  # buffer_r (right channel, short*)
+      :int,      # nsamples
+      :pointer,  # mp3buf (output buffer)
+      :int       # mp3buf_size
+    ], :int
+
+    attach_function :lame_encode_buffer_interleaved, [
+      :pointer,  # gfp
+      :pointer,  # pcm (interleaved short*)
+      :int,      # nsamples (per channel)
+      :pointer,  # mp3buf
+      :int       # mp3buf_size
+    ], :int
+
+    # Encoding functions - IEEE float PCM
+    attach_function :lame_encode_buffer_ieee_float, [
+      :pointer,  # gfp
+      :pointer,  # buffer_l (float*)
+      :pointer,  # buffer_r (float*)
+      :int,      # nsamples
+      :pointer,  # mp3buf
+      :int       # mp3buf_size
+    ], :int
+
+    attach_function :lame_encode_buffer_interleaved_ieee_float, [
+      :pointer,  # gfp
+      :pointer,  # pcm (interleaved float*)
+      :int,      # nsamples (per channel)
+      :pointer,  # mp3buf
+      :int       # mp3buf_size
+    ], :int
+
+    # Flush encoder
+    attach_function :lame_encode_flush, [
+      :pointer,  # gfp
+      :pointer,  # mp3buf
+      :int       # mp3buf_size
+    ], :int
+
+    attach_function :lame_encode_flush_nogap, [
+      :pointer,  # gfp
+      :pointer,  # mp3buf
+      :int       # mp3buf_size
+    ], :int
+
+    # ID3 tag functions
+    attach_function :id3tag_init, [:pointer], :void
+    attach_function :id3tag_add_v2, [:pointer], :void
+    attach_function :id3tag_v1_only, [:pointer], :void
+    attach_function :id3tag_v2_only, [:pointer], :void
+    attach_function :id3tag_set_title, [:pointer, :string], :void
+    attach_function :id3tag_set_artist, [:pointer, :string], :void
+    attach_function :id3tag_set_album, [:pointer, :string], :void
+    attach_function :id3tag_set_year, [:pointer, :string], :void
+    attach_function :id3tag_set_comment, [:pointer, :string], :void
+    attach_function :id3tag_set_track, [:pointer, :string], :void
+    attach_function :id3tag_set_genre, [:pointer, :string], :void
+
+    # HIP (LAME's Hip Is a Player) decoder functions for MP3 decoding
+    attach_function :hip_decode_init, [], :pointer
+    attach_function :hip_decode_exit, [:pointer], :int
+    attach_function :hip_decode, [
+      :pointer,  # hip (decoder handle)
+      :pointer,  # mp3buf (input)
+      :size_t,   # len (input size)
+      :pointer,  # pcm_l (output left channel, short*)
+      :pointer   # pcm_r (output right channel, short*)
+    ], :int
+    attach_function :hip_decode_headers, [
+      :pointer,  # hip
+      :pointer,  # mp3buf
+      :size_t,   # len
+      :pointer,  # pcm_l
+      :pointer,  # pcm_r
+      :pointer   # mp3data (mp3data_struct*)
+    ], :int
+
+    # MP3 data structure for decoder
+    class Mp3Data < ::FFI::Struct
+      layout :header_parsed, :int,
+             :stereo, :int,
+             :samplerate, :int,
+             :bitrate, :int,
+             :mode, :int,
+             :mode_ext, :int,
+             :framesize, :int,
+             :nsamp, :ulong,
+             :totalframes, :int,
+             :framenum, :int
+    end
+  end
+end

data/lib/lamer/ffi/library.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+class Lamer
+  module FFI
+    extend ::FFI::Library
+
+    LIBRARY_NAMES = case RbConfig::CONFIG["host_os"]
+    when /darwin/
+      %w[libmp3lame.dylib libmp3lame.0.dylib]
+    when /linux/
+      %w[libmp3lame.so.0 libmp3lame.so]
+    when /mswin|mingw/
+      %w[libmp3lame.dll mp3lame.dll lame_enc.dll]
+    else
+      %w[libmp3lame.so libmp3lame.dylib mp3lame]
+    end.freeze
+
+    begin
+      ffi_lib LIBRARY_NAMES
+    rescue LoadError => e
+      raise LoadError, "Could not load libmp3lame. Please install LAME (e.g., `brew install lame` on macOS). Original error: #{e.message}"
+    end
+  end
+end

data/lib/lamer/ffi.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "ffi/library"
+require_relative "ffi/enums"
+require_relative "ffi/functions"

data/lib/lamer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Lamer
+  VERSION = "1.0.0"
+end