wavesync 1.0.0.alpha2 → 1.0.0.alpha4

data/lib/wavesync/commands/sync.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'optparse'
+require_relative '../transport'
 
 module Wavesync
   module Commands
@@ -12,40 +14,31 @@ module Wavesync
       self.description = 'Sync music library to a device'
       self.options = [DEVICE_OPTION, PAD_OPTION].freeze
 
+      #: () -> void
       def run
         options, config = parse_options(banner: 'Usage: wavesync sync [options]') do |opts, opts_hash|
           opts.on(*DEVICE_OPTION.to_a) { |value| opts_hash[:device] = value }
           opts.on(*PAD_OPTION.to_a) { opts_hash[:pad] = true }
         end
 
-        device_configs = config.device_configs
-        if options[:device]
-          device_configs = device_configs.select { |device_config| device_config[:name] == options[:device] }
-          if device_configs.empty?
-            known = config.device_configs.map { |device_config| device_config[:name] }.join(', ')
-            puts "Unknown device \"#{options[:device]}\". Devices in config: #{known}"
-            exit 1
-          end
-        elsif device_configs.size > 1
-          device_names = device_configs.map { |device_config| device_config[:name] }
-          selected_name = Wavesync::UI.new.select('Select device', device_names)
-          device_configs = device_configs.select { |device_config| device_config[:name] == selected_name }
-        end
-
-        device_pairs = device_configs.map do |device_config|
-          device = Wavesync::Device.find_by(name: device_config[:model])
-          unless device
-            supported = Wavesync::Device.all.map(&:name).join(', ')
-            puts "Unknown device model \"#{device_config[:model]}\" in config. Supported models: #{supported}"
-            exit 1
-          end
-          [device_config, device]
-        end
-
+        device_pairs = Commands.resolve_device_pairs(config, device_name: options[:device])
         scanner = Wavesync::Scanner.new(config.library)
 
-        device_pairs.each do |device_config, device|
-          scanner.sync(device_config[:path], device, pad: options[:pad] || false)
+        device_pairs.each do |pair|
+          device_config = pair[0] #: { name: String, model: String, path: String, transport: String, mp3_bitrate: Integer }
+          device = pair[1] #: Wavesync::Device
+          transport = Wavesync::Transport.for(device_config)
+          Commands.with_mtp_retry(transport, device_config[:name]) do
+            puts "Pushing to #{device_config[:name]} via MTP..." if transport.is_a?(Wavesync::Transport::Mtp)
+            transport.begin_push!
+          end
+          begin
+            scanner.sync(transport.working_directory, device, pad: options[:pad] || false, staged: transport.is_a?(Wavesync::Transport::Mtp), mp3_bitrate: device_config[:mp3_bitrate]) do |relative_path|
+              transport.push_file!(relative_path)
+            end
+          ensure
+            transport.finish_push!
+          end
         end
       end
     end

data/lib/wavesync/commands.rb

@@ -1,30 +1,70 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 module Wavesync
   module Commands
-    Option = Struct.new(:short, :long, :description, keyword_init: true)
-    Subcommand = Struct.new(:usage, :description, keyword_init: true)
+    Option = Struct.new(:short, :long, :description)
+    Subcommand = Struct.new(:usage, :description)
 
     CONFIG_OPTION = Option.new(short: '-c', long: '--config PATH', description: 'Path to wavesync config YAML file')
     GLOBAL_OPTIONS = [CONFIG_OPTION].freeze
 
+    #: (String path) -> Config
     def self.load_config(path)
       Wavesync::Config.load(path)
     rescue Wavesync::ConfigError => e
       puts "Configuration error: #{e.message}"
       exit 1
     end
-  end
-end
 
-require_relative 'commands/command'
-require_relative 'commands/sync'
-require_relative 'commands/analyze'
-require_relative 'commands/set'
-require_relative 'commands/help'
+    #: (Config config, ?device_name: String?) -> Array[untyped]
+    def self.resolve_device_pairs(config, device_name: nil)
+      device_configs = config.device_configs
+      if device_name
+        device_configs = device_configs.select { |device_config| device_config[:name] == device_name }
+        if device_configs.empty?
+          known = config.device_configs.map { |device_config| device_config[:name] }.join(', ')
+          puts "Unknown device \"#{device_name}\". Devices in config: #{known}"
+          exit 1
+        end
+      elsif device_configs.size > 1
+        device_names = device_configs.map { |device_config| device_config[:name] }
+        selected_name = Wavesync::UI.new.select('Select device', device_names)
+        device_configs = device_configs.select { |device_config| device_config[:name] == selected_name }
+      end
 
-module Wavesync
-  module Commands
-    ALL = [Sync, Analyze, Set, Help].freeze
+      device_configs.map do |device_config|
+        device = Wavesync::Device.find_by(name: device_config[:model])
+        unless device
+          supported = Wavesync::Device.all.map(&:name).join(', ')
+          puts "Unknown device model \"#{device_config[:model]}\" in config. Supported models: #{supported}"
+          exit 1
+        end
+        [device_config, device]
+      end
+    end
+
+    #: ((Wavesync::Transport::Filesystem | Wavesync::Transport::Mtp) transport, String device_name) { () -> void } -> void
+    def self.with_mtp_retry(transport, device_name, &block)
+      return block.call unless transport.is_a?(Wavesync::Transport::Mtp)
+
+      begin
+        block.call
+      rescue Wavesync::Libmtp::Error => e
+        puts "Could not reach #{device_name} over MTP (#{e.message}). Put the device in MTP mode, then press Enter to retry (Ctrl+C to abort)."
+        $stdin.gets
+        retry
+      end
+    end
+
+    require_relative 'commands/command'
+    require_relative 'commands/sync'
+    require_relative 'commands/pull'
+    require_relative 'commands/analyze'
+    require_relative 'commands/setlist'
+    require_relative 'commands/clear_cache'
+    require_relative 'commands/help'
+
+    ALL = [Sync, Pull, Analyze, Setlist, ClearCache, Help].freeze
   end
 end

data/lib/wavesync/config.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'yaml'
 
@@ -9,11 +10,16 @@ module Wavesync
     DEFAULT_PATH = File.join(Dir.home, 'wavesync.yml')
 
     SUPPORTED_KEYS = %w[library devices].freeze
-    DEVICE_SUPPORTED_KEYS = %w[name model path].freeze
+    DEVICE_SUPPORTED_KEYS = %w[name model path transport mp3_bitrate].freeze
     DEVICE_REQUIRED_KEYS = %w[name model path].freeze
+    SUPPORTED_TRANSPORTS = %w[filesystem mtp].freeze
+    SUPPORTED_MP3_BITRATES = [96, 128, 160, 192, 256, 320].freeze
+    DEFAULT_MP3_BITRATE = 192
 
-    attr_reader :library, :device_configs
+    attr_reader :library #: String
+    attr_reader :device_configs #: Array[{ name: String, model: String, path: String, transport: String, mp3_bitrate: Integer }]
 
+    #: (?String path) -> Config
     def self.load(path = DEFAULT_PATH)
       expanded = File.expand_path(path)
       begin
@@ -26,17 +32,27 @@ module Wavesync
       new(data)
     end
 
+    #: (untyped data) -> void
     def initialize(data)
       validate!(data)
       @library = File.expand_path(data['library'])
       @device_configs = data['devices'].each_with_index.map do |device, i|
         validate_device!(device, i)
-        { name: device['name'], model: device['model'], path: File.expand_path(device['path']) }
+        transport = device['transport'] || 'filesystem'
+        path = transport == 'filesystem' ? File.expand_path(device['path']) : device['path']
+        {
+          name: device['name'],
+          model: device['model'],
+          path: path,
+          transport: transport,
+          mp3_bitrate: device['mp3_bitrate'] || DEFAULT_MP3_BITRATE
+        }
       end
     end
 
     private
 
+    #: (untyped data) -> void
     def validate!(data)
       raise ConfigError, 'Config file must contain a YAML mapping' unless data.is_a?(Hash)
 
@@ -52,6 +68,7 @@ module Wavesync
       raise ConfigError, "'devices' must contain at least one device" if data['devices'].empty?
     end
 
+    #: (untyped device, Integer index) -> void
     def validate_device!(device, index)
       raise ConfigError, "Device #{index + 1} must be a YAML mapping" unless device.is_a?(Hash)
 
@@ -65,6 +82,29 @@ module Wavesync
       %w[name model path].each do |key|
         raise ConfigError, "Device #{index + 1} '#{key}' must be a string" unless device[key].is_a?(String)
       end
+
+      validate_device_transport!(device, index)
+      validate_device_mp3_bitrate!(device, index)
+    end
+
+    #: (Hash[String, untyped] device, Integer index) -> void
+    def validate_device_transport!(device, index)
+      return unless device.key?('transport')
+
+      raise ConfigError, "Device #{index + 1} 'transport' must be a string" unless device['transport'].is_a?(String)
+      return if SUPPORTED_TRANSPORTS.include?(device['transport'])
+
+      raise ConfigError, "Device #{index + 1} 'transport' must be one of: #{SUPPORTED_TRANSPORTS.join(', ')}"
+    end
+
+    #: (Hash[String, untyped] device, Integer index) -> void
+    def validate_device_mp3_bitrate!(device, index)
+      return unless device.key?('mp3_bitrate')
+
+      raise ConfigError, "Device #{index + 1} 'mp3_bitrate' must be an integer" unless device['mp3_bitrate'].is_a?(Integer)
+      return if SUPPORTED_MP3_BITRATES.include?(device['mp3_bitrate'])
+
+      raise ConfigError, "Device #{index + 1} 'mp3_bitrate' must be one of: #{SUPPORTED_MP3_BITRATES.join(', ')}"
     end
   end
 end

data/lib/wavesync/cue_chunk.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wavesync
+  class CueChunk
+    RIFF_HEADER_SIZE = 12
+    CHUNK_ID_SIZE = 4
+    CHUNK_SIZE_FIELD_SIZE = 4
+    CUE_CHUNK_ID = 'cue '
+    LIST_CHUNK_ID = 'LIST'
+    ADTL_LIST_TYPE = 'adtl'
+    LABL_CHUNK_ID = 'labl'
+    DATA_CHUNK_ID = 'data'
+    CUE_HEADER_SIZE = 4
+    BYTES_PER_CUE_POINT = 24
+
+    UINT32_LE = 'V'
+
+    #: (String filepath) -> Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+    def self.read(filepath)
+      cue_points = [] #: Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+      labels = {} #: Hash[Integer, String]
+
+      File.open(filepath, 'rb') do |file|
+        file.seek(RIFF_HEADER_SIZE)
+
+        until file.eof?
+          chunk_id = file.read(CHUNK_ID_SIZE)
+          break if chunk_id.nil? || chunk_id.length < CHUNK_ID_SIZE
+
+          chunk_size_bytes = file.read(CHUNK_SIZE_FIELD_SIZE)
+          break if chunk_size_bytes.nil?
+
+          chunk_size = chunk_size_bytes.unpack1(UINT32_LE).to_i
+          chunk_data_start = file.tell
+
+          if chunk_id == CUE_CHUNK_ID
+            num_cues = file.read(4)&.unpack1(UINT32_LE).to_i
+            num_cues.times do
+              identifier = file.read(4)&.unpack1(UINT32_LE)&.to_i
+              file.read(16) # skip position, fcc_chunk, chunk_start, block_start
+              sample_offset = file.read(4)&.unpack1(UINT32_LE)&.to_i
+              cue_points << { identifier: identifier, sample_offset: sample_offset, label: nil } if identifier && sample_offset
+            end
+          elsif chunk_id == LIST_CHUNK_ID && chunk_size >= 4
+            list_type = file.read(4)
+            read_adtl_labels(file, chunk_data_start + chunk_size, labels) if list_type == ADTL_LIST_TYPE
+          end
+
+          chunk_padding = chunk_size.odd? ? 1 : 0
+          file.seek(chunk_data_start + chunk_size + chunk_padding)
+        end
+      end
+
+      cue_points.map { |cue_point| { identifier: cue_point[:identifier], sample_offset: cue_point[:sample_offset], label: labels[cue_point[:identifier]] } }
+    end
+
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points_a, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points_b) -> bool
+    def self.same?(cue_points_a, cue_points_b)
+      to_comparable(cue_points_a) == to_comparable(cue_points_b)
+    end
+
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> Array[{sample_offset: Integer, label: String?}]
+    def self.to_comparable(cue_points)
+      mapped = cue_points.map { |cp| { sample_offset: cp[:sample_offset], label: cp[:label] } } #: Array[{sample_offset: Integer, label: String?}]
+      mapped.sort_by { |cp| cp[:sample_offset] }
+    end
+
+    #: (String filepath, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    def self.append_to_file(filepath, cue_points)
+      return if cue_points.empty?
+
+      File.open(filepath, 'ab') do |file|
+        write_cue_chunk(file, cue_points)
+        labeled_cue_points = cue_points.select { |cue_point| cue_point[:label] }
+        write_adtl_chunk(file, labeled_cue_points) if labeled_cue_points.any?
+      end
+
+      update_riff_size(filepath)
+    end
+
+    #: (String source_filepath, String output_filepath, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    def self.write(source_filepath, output_filepath, cue_points)
+      File.open(source_filepath, 'rb') do |input|
+        File.open(output_filepath, 'wb') do |output|
+          output.write(input.read(RIFF_HEADER_SIZE))
+
+          until input.eof?
+            chunk_id = input.read(CHUNK_ID_SIZE)
+            break if chunk_id.nil? || chunk_id.length < CHUNK_ID_SIZE
+
+            chunk_size_bytes = input.read(CHUNK_SIZE_FIELD_SIZE)
+            break if chunk_size_bytes.nil?
+
+            chunk_size = chunk_size_bytes.unpack1(UINT32_LE).to_i
+            chunk_padding = chunk_size.odd? ? 1 : 0
+
+            if chunk_id == CUE_CHUNK_ID
+              input.read(chunk_size + chunk_padding)
+            elsif chunk_id == LIST_CHUNK_ID && chunk_size >= 4
+              list_type = input.read(4)
+              if list_type == ADTL_LIST_TYPE
+                input.read(chunk_size - 4 + chunk_padding)
+              else
+                output.write(chunk_id)
+                output.write(chunk_size_bytes)
+                output.write(list_type)
+                output.write(input.read(chunk_size - 4 + chunk_padding))
+              end
+            else
+              output.write(chunk_id)
+              output.write(chunk_size_bytes)
+              output.write(input.read(chunk_size + chunk_padding))
+            end
+          end
+
+          unless cue_points.empty?
+            write_cue_chunk(output, cue_points)
+            labeled_cue_points = cue_points.select { |cue_point| cue_point[:label] }
+            write_adtl_chunk(output, labeled_cue_points) if labeled_cue_points.any?
+          end
+        end
+      end
+
+      update_riff_size(output_filepath)
+    end
+
+    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    def self.write_cue_chunk(output, cue_points)
+      chunk_size = CUE_HEADER_SIZE + (cue_points.size * BYTES_PER_CUE_POINT)
+      output.write(CUE_CHUNK_ID)
+      output.write([chunk_size].pack(UINT32_LE))
+      output.write([cue_points.size].pack(UINT32_LE))
+      cue_points.each_with_index do |cue_point, index|
+        identifier = cue_point[:identifier] || (index + 1)
+        output.write([identifier].pack(UINT32_LE))
+        output.write([0].pack(UINT32_LE))
+        output.write(DATA_CHUNK_ID)
+        output.write([0].pack(UINT32_LE))
+        output.write([0].pack(UINT32_LE))
+        output.write([cue_point[:sample_offset]].pack(UINT32_LE))
+      end
+    end
+
+    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    def self.write_adtl_chunk(output, cue_points)
+      labl_entries = cue_points.map do |cue_point|
+        text = "#{cue_point[:label]}\x00"
+        data_size = 4 + text.length
+        pad = data_size.odd? ? 1 : 0
+        { identifier: cue_point[:identifier], text: text, data_size: data_size, pad: pad }
+      end #: Array[{identifier: Integer, text: String, data_size: Integer, pad: Integer}]
+
+      adtl_data_size = 4 + labl_entries.sum { |entry| 8 + entry[:data_size] + entry[:pad] }
+      output.write(LIST_CHUNK_ID)
+      output.write([adtl_data_size].pack(UINT32_LE))
+      output.write(ADTL_LIST_TYPE)
+
+      labl_entries.each do |entry|
+        output.write(LABL_CHUNK_ID)
+        output.write([entry[:data_size]].pack(UINT32_LE))
+        output.write([entry[:identifier]].pack(UINT32_LE))
+        output.write(entry[:text])
+        output.write("\x00") if entry[:pad] == 1
+      end
+    end
+
+    #: (untyped file, Integer list_end, Hash[Integer, String] labels) -> void
+    def self.read_adtl_labels(file, list_end, labels)
+      while file.tell < list_end - 8
+        sub_id = file.read(CHUNK_ID_SIZE)
+        break if sub_id.nil? || sub_id.length < CHUNK_ID_SIZE
+
+        sub_size_bytes = file.read(CHUNK_SIZE_FIELD_SIZE)
+        break if sub_size_bytes.nil?
+
+        sub_size = sub_size_bytes.unpack1(UINT32_LE).to_i
+        sub_data_start = file.tell
+
+        if sub_id == LABL_CHUNK_ID && sub_size >= 4
+          identifier = file.read(4)&.unpack1(UINT32_LE)&.to_i
+          text_size = sub_size - 4
+          text = text_size.positive? ? (file.read(text_size) || '') : ''
+          labels[identifier] = text.delete("\x00") if identifier
+        end
+
+        sub_padding = sub_size.odd? ? 1 : 0
+        file.seek(sub_data_start + sub_size + sub_padding)
+      end
+    end
+
+    #: (String filepath) -> void
+    def self.update_riff_size(filepath)
+      File.open(filepath, 'r+b') do |file|
+        file.seek(0, IO::SEEK_END)
+        file_size = file.tell
+        riff_size = file_size - 8
+        file.seek(4)
+        file.write([riff_size].pack(UINT32_LE))
+      end
+    end
+  end
+end

data/lib/wavesync/device.rb

@@ -1,45 +1,66 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'yaml'
 module Wavesync
   class Device
-    attr_reader :name, :sample_rates, :bit_depths, :file_types, :bpm_source, :bar_multiple
+    attr_reader :name #: String
+    attr_reader :sample_rates #: Array[Integer]
+    attr_reader :bit_depths #: Array[Integer]
+    attr_reader :file_types #: Array[String]
+    attr_reader :bpm_source #: Symbol?
+    attr_reader :bar_multiple #: Integer?
+    attr_reader :unsupported_characters #: Array[String]
+    attr_reader :transliterate_metadata #: bool
+    attr_reader :uppercase_paths #: bool
 
-    def initialize(name:, sample_rates:, bit_depths:, file_types:, bpm_source: nil, bar_multiple: nil)
+    #: (name: String, sample_rates: Array[Integer], file_types: Array[String], ?bit_depths: Array[Integer], ?bpm_source: Symbol?, ?bar_multiple: Integer?, ?unsupported_characters: Array[String], ?transliterate_metadata: bool, ?uppercase_paths: bool) -> void
+    def initialize(name:, sample_rates:, file_types:, bit_depths: [], bpm_source: nil, bar_multiple: nil, unsupported_characters: [], transliterate_metadata: false, uppercase_paths: false)
       @name = name
       @sample_rates = sample_rates
       @bit_depths = bit_depths
       @file_types = file_types
       @bpm_source = bpm_source
       @bar_multiple = bar_multiple
+      @unsupported_characters = unsupported_characters
+      @transliterate_metadata = transliterate_metadata
+      @uppercase_paths = uppercase_paths
     end
 
+    #: () -> String
     def self.config_path
-      File.expand_path('../../config/devices.yml', __dir__)
+      File.expand_path('../../config/devices.yml', __dir__ || '')
     end
 
+    #: () -> Array[Device]
     def self.all
       @all ||= load_from_yaml
     end
 
+    #: (name: String) -> Device?
     def self.find_by(name:)
       all.find { |device| device.name == name }
     end
 
+    #: () -> Array[Device]
     def self.load_from_yaml
       data = YAML.load_file(config_path)
       data.fetch('devices').map do |attrs|
         new(
           name: attrs['name'],
           sample_rates: attrs['sample_rates'],
-          bit_depths: attrs['bit_depths'],
+          bit_depths: attrs['bit_depths'] || [],
           file_types: attrs['file_types'],
           bpm_source: attrs['bpm_source']&.to_sym,
-          bar_multiple: attrs['bar_multiple']
+          bar_multiple: attrs['bar_multiple'],
+          unsupported_characters: attrs['unsupported_characters'] || [],
+          transliterate_metadata: attrs['transliterate_metadata'] || false,
+          uppercase_paths: attrs['uppercase_paths'] || false
         )
       end
     end
 
+    #: (AudioFormat source_format, String source_file_path) -> AudioFormat
     def target_format(source_format, source_file_path)
       AudioFormat.new(
         file_type: target_file_type(source_file_path),
@@ -48,21 +69,25 @@ module Wavesync
       )
     end
 
+    #: (String source_file_path) -> String?
     def target_file_type(source_file_path)
-      file_extension = File.extname(source_file_path).downcase[1..]
+      file_extension = File.extname(source_file_path).downcase[1..] || ''
       return nil if file_types.include?(file_extension)
 
       file_types.first
     end
 
+    #: (Integer? source_sample_rate) -> Integer?
     def target_sample_rate(source_sample_rate)
+      return nil if source_sample_rate.nil?
       return nil if sample_rates.include?(source_sample_rate)
 
       sample_rates.min_by { |n| [(n - source_sample_rate).abs, -n] }
     end
 
+    #: (Integer? source_bit_depth) -> Integer?
     def target_bit_depth(source_bit_depth)
-      return nil if source_bit_depth.nil? || bit_depths.include?(source_bit_depth)
+      return nil if source_bit_depth.nil? || bit_depths.empty? || bit_depths.include?(source_bit_depth)
 
       bit_depths.min_by { |n| [(n - source_bit_depth).abs, -n] }
     end

data/lib/wavesync/essentia_bpm_detector.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'json'
+require_relative 'logger'
+require_relative 'python_venv'
+
+module Wavesync
+  class EssentiaBpmDetector
+    PYTHON_SCRIPT = <<~PYTHON
+      import essentia, essentia.streaming as ess, json, sys
+      pool = essentia.Pool()
+      loader = ess.MonoLoader(filename=sys.argv[1], sampleRate=44100)
+      rhythm = ess.RhythmDescriptors()
+      loader.audio >> rhythm.signal
+      rhythm.bpm >> (pool, 'bpm')
+      rhythm.confidence >> (pool, 'confidence')
+      essentia.run(loader)
+      print(json.dumps({'bpm': round(float(pool['bpm'])), 'confidence': round(float(pool['confidence']), 2)}))
+    PYTHON
+
+    #: () -> bool?
+    def self.available?
+      PythonVenv.essentia_available?
+    end
+
+    #: (String file_path) -> {bpm: Integer, confidence: Float}?
+    def self.detect(file_path)
+      output = PythonVenv.run_script(PYTHON_SCRIPT, file_path)
+      data = JSON.parse(output.strip)
+      bpm = data['bpm'].to_f
+      bpm.positive? ? { bpm: bpm.round, confidence: data['confidence'].to_f } : nil
+    rescue StandardError => e
+      Logger.log_error(e, call_site: 'EssentiaBpmDetector.detect', arguments: { file_path: })
+      nil
+    end
+  end
+end

data/lib/wavesync/ffmpeg/probe.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'open3'
+require 'json'
+
+module Wavesync
+  class FFMPEG
+    class Probe
+      #: (String file_path) -> void
+      def initialize(file_path)
+        @file_path = file_path #: String
+      end
+
+      #: () -> Float
+      def duration
+        format_data.fetch('duration', '0').to_f
+      end
+
+      #: () -> Integer?
+      def sample_rate
+        rate = audio_stream&.fetch('sample_rate', nil)
+        rate&.to_i
+      end
+
+      #: () -> Integer?
+      def bit_depth
+        bits = audio_stream&.fetch('bits_per_sample', nil)&.to_i
+        bits&.positive? ? bits : nil
+      end
+
+      #: () -> Integer?
+      def bitrate
+        bits_per_second = audio_stream&.fetch('bit_rate', nil)&.to_i
+        return nil unless bits_per_second&.positive?
+
+        (bits_per_second / 1000.0).round
+      end
+
+      #: () -> Hash[String, String]
+      def tags
+        format_data['tags'] || {}
+      end
+
+      private
+
+      #: () -> Hash[String, untyped]
+      def probe_data
+        @probe_data ||= run_probe
+      end
+
+      #: () -> Hash[String, untyped]
+      def run_probe
+        ffprobe = FFMPEG.binary.sub('ffmpeg', 'ffprobe')
+        stdout, _stderr, _status = Open3.capture3(
+          ffprobe, '-v', 'quiet', '-print_format', 'json',
+          '-show_streams', '-show_format', @file_path
+        )
+        JSON.parse(stdout)
+      end
+
+      #: () -> Hash[String, untyped]
+      def format_data
+        probe_data['format'] || {} #: Hash[String, untyped]
+      end
+
+      #: () -> Hash[String, untyped]?
+      def audio_stream
+        streams = probe_data['streams'] || [] #: Array[Hash[String, untyped]]
+        @audio_stream ||= streams.find { |stream| stream['codec_type'] == 'audio' }
+      end
+    end
+  end
+end