wavesync 1.0.0.alpha3 → 1.0.0.alpha4

data/lib/wavesync/commands/pull.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+require_relative '../transport'
+
+module Wavesync
+  module Commands
+    class Pull < Command
+      DEVICE_OPTION = Option.new(short: '-d', long: '--device NAME', description: 'Name of device to pull from (as defined in config)')
+
+      self.name = 'pull'
+      self.description = 'Read cue points from device files and write them back into the source library'
+      self.options = [DEVICE_OPTION].freeze
+
+      #: () -> void
+      def run
+        options, config = parse_options(banner: 'Usage: wavesync pull [options]') do |opts, opts_hash|
+          opts.on(*DEVICE_OPTION.to_a) { |value| opts_hash[:device] = value }
+        end
+
+        device_pairs = Commands.resolve_device_pairs(config, device_name: options[:device])
+        scanner = Wavesync::Scanner.new(config.library)
+        ui = Wavesync::UI.new
+
+        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
+            next unless transport.is_a?(Wavesync::Transport::Mtp)
+
+            transport.prepare! do |index, total, relative_path|
+              ui.pull_staging_progress(index, total, device)
+              ui.file_progress(relative_path)
+            end
+          end
+          scanner.pull_cue_points(transport.working_directory, device)
+        end
+      end
+    end
+  end
+end

data/lib/wavesync/commands/setlist.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Setlist < Command
+      self.name = 'setlist'
+      self.subcommands = [
+        Subcommand.new(usage: 'setlist create NAME', description: 'Create a new setlist'),
+        Subcommand.new(usage: 'setlist edit NAME', description: 'Edit an existing setlist'),
+        Subcommand.new(usage: 'setlist list', description: 'List all setlists')
+      ].freeze
+
+      #: () -> void
+      def run
+        subcommand = ARGV.shift
+
+        _options, config = parse_options(banner: 'Usage: wavesync setlist <subcommand> [options]')
+
+        case subcommand
+        when 'create'
+          name = require_name('create')
+          if Wavesync::Setlist.exists?(config.library, name)
+            puts "Setlist '#{name}' already exists. Use 'wavesync setlist edit #{name}' to edit it."
+            exit 1
+          end
+          setlist = Wavesync::Setlist.new(config.library, name)
+          Wavesync::SetlistEditor.new(setlist, config.library).run
+        when 'edit'
+          name = require_name('edit')
+          unless Wavesync::Setlist.exists?(config.library, name)
+            puts "Setlist '#{name}' not found. Use 'wavesync setlist create #{name}' to create it."
+            exit 1
+          end
+          setlist = Wavesync::Setlist.load(config.library, name)
+          Wavesync::SetlistEditor.new(setlist, config.library).run
+        when 'list'
+          setlists = Wavesync::Setlist.all(config.library)
+          if setlists.empty?
+            puts 'No setlists found.'
+          else
+            setlists.each { |setlist| puts "#{setlist.name} (#{setlist.tracks.size} tracks)" }
+          end
+        else
+          puts "Unknown subcommand: #{subcommand || '(none)'}"
+          puts 'Available subcommands: create, edit, list'
+          exit 1
+        end
+      end
+
+      private
+
+      #: (String subcommand) -> String
+      def require_name(subcommand)
+        name = ARGV.shift
+        unless name
+          puts "Usage: wavesync setlist #{subcommand} <name>"
+          exit 1
+        end
+        name
+      end
+    end
+  end
+end

data/lib/wavesync/commands/sync.rb

@@ -2,6 +2,7 @@
 # rbs_inline: enabled
 
 require 'optparse'
+require_relative '../transport'
 
 module Wavesync
   module Commands
@@ -20,36 +21,24 @@ module Wavesync
           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 #: Array[untyped]
-
+        device_pairs = Commands.resolve_device_pairs(config, device_name: options[:device])
         scanner = Wavesync::Scanner.new(config.library)
 
         device_pairs.each do |pair|
-          device_config = pair[0] #: { name: String, model: String, path: String }
+          device_config = pair[0] #: { name: String, model: String, path: String, transport: String, mp3_bitrate: Integer }
           device = pair[1] #: Wavesync::Device
-          scanner.sync(device_config[:path], device, pad: options[:pad] || false)
+          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

@@ -17,12 +17,54 @@ module Wavesync
       exit 1
     end
 
+    #: (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
+
+      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/set'
+    require_relative 'commands/setlist'
+    require_relative 'commands/clear_cache'
     require_relative 'commands/help'
 
-    ALL = [Sync, Analyze, Set, Help].freeze
+    ALL = [Sync, Pull, Analyze, Setlist, ClearCache, Help].freeze
   end
 end

data/lib/wavesync/config.rb

@@ -10,11 +10,14 @@ 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 #: String
-    attr_reader :device_configs #: Array[{ name: String, model: String, path: 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)
@@ -35,7 +38,15 @@ module Wavesync
       @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
 
@@ -71,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

@@ -55,6 +55,30 @@ module Wavesync
       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|

data/lib/wavesync/device.rb

@@ -10,15 +10,21 @@ module Wavesync
     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
 
-    #: (name: String, sample_rates: Array[Integer], bit_depths: Array[Integer], file_types: Array[String], ?bpm_source: Symbol?, ?bar_multiple: Integer?) -> void
-    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
@@ -43,10 +49,13 @@ module Wavesync
         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
@@ -78,7 +87,7 @@ module Wavesync
 
     #: (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

@@ -2,6 +2,7 @@
 # rbs_inline: enabled
 
 require 'json'
+require_relative 'logger'
 require_relative 'python_venv'
 
 module Wavesync
@@ -29,7 +30,8 @@ module Wavesync
       data = JSON.parse(output.strip)
       bpm = data['bpm'].to_f
       bpm.positive? ? { bpm: bpm.round, confidence: data['confidence'].to_f } : nil
-    rescue StandardError
+    rescue StandardError => e
+      Logger.log_error(e, call_site: 'EssentiaBpmDetector.detect', arguments: { file_path: })
       nil
     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

data/lib/wavesync/ffmpeg.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'open3'
+require_relative 'ffmpeg/probe'
+
+module Wavesync
+  class FFMPEG
+    class Error < StandardError; end
+
+    #: () -> String
+    def self.binary
+      @binary ||= locate_binary('ffmpeg')
+    end
+
+    #: () -> String
+    def self.ffplay_binary
+      @ffplay_binary ||= binary.sub('ffmpeg', 'ffplay')
+    end
+
+    #: () -> void
+    def initialize
+      @inputs = [] #: Array[Hash[Symbol, String?]]
+      @options = {} #: Hash[Symbol, untyped]
+      @metadata_pairs = [] #: Array[[String, String]]
+    end
+
+    #: (String source, ?format: String?) -> self
+    def input(source, format: nil)
+      @inputs << { source: source, format: format }
+      self
+    end
+
+    #: (String codec) -> self
+    def audio_codec(codec)
+      @options[:audio_codec] = codec
+      self
+    end
+
+    #: (Integer rate) -> self
+    def sample_rate(rate)
+      @options[:sample_rate] = rate
+      self
+    end
+
+    #: (String bitrate) -> self
+    def audio_bitrate(bitrate)
+      @options[:audio_bitrate] = bitrate
+      self
+    end
+
+    #: (String filter) -> self
+    def audio_filter(filter)
+      @options[:audio_filter] = filter
+      self
+    end
+
+    #: (String graph) -> self
+    def filter_complex(graph)
+      @options[:filter_complex] = graph
+      self
+    end
+
+    #: (String format) -> self
+    def output_format(format)
+      @options[:output_format] = format
+      self
+    end
+
+    #: (Numeric seconds) -> self
+    def duration(seconds)
+      @options[:duration] = seconds
+      self
+    end
+
+    #: () -> self
+    def copy_streams
+      @options[:copy_streams] = true
+      self
+    end
+
+    #: (Integer source_index) -> self
+    def map_metadata(source_index)
+      @options[:map_metadata] = source_index
+      self
+    end
+
+    #: (String key, String value) -> self
+    def metadata(key, value)
+      @metadata_pairs << [key, value]
+      self
+    end
+
+    #: (String flags) -> self
+    def movflags(flags)
+      @options[:movflags] = flags
+      self
+    end
+
+    #: (Integer version) -> self
+    def write_id3v2(version)
+      @options[:write_id3v2] = version
+      self
+    end
+
+    #: (String output_path) -> void
+    def run(output_path)
+      args = ['-y']
+
+      @inputs.each do |input|
+        args += ['-f', input[:format]] if input[:format]
+        args += ['-i', input[:source]]
+      end
+
+      args += ['-loglevel', 'warning', '-nostats', '-hide_banner']
+      args += ['-c', 'copy'] if @options[:copy_streams]
+      args += ['-map_metadata', @options[:map_metadata].to_s] if @options.key?(:map_metadata)
+      @metadata_pairs.each { |key, value| args += ['-metadata', "#{key}=#{value}"] }
+      args += ['-filter_complex', @options[:filter_complex]] if @options[:filter_complex]
+      args += ['-af', @options[:audio_filter]] if @options[:audio_filter]
+      args += ['-acodec', @options[:audio_codec]] if @options[:audio_codec]
+      args += ['-b:a', @options[:audio_bitrate]] if @options[:audio_bitrate]
+      args += ['-ar', @options[:sample_rate].to_s] if @options[:sample_rate]
+      args += ['-t', @options[:duration].to_s] if @options[:duration]
+      args += ['-movflags', @options[:movflags]] if @options[:movflags]
+      args += ['-write_id3v2', @options[:write_id3v2].to_s] if @options[:write_id3v2]
+      args += ['-f', @options[:output_format]] if @options[:output_format]
+      args << output_path
+
+      _stdout, stderr, status = Open3.capture3(self.class.binary, *args)
+      raise Error, "ffmpeg failed: #{stderr}" unless status.success?
+    end
+
+    private
+
+    #: (String binary_name) -> String
+    def self.locate_binary(binary_name)
+      stdout, _stderr, _status = Open3.capture3('which', binary_name)
+      path = stdout.strip
+      path.empty? ? binary_name : path
+    end
+    private_class_method :locate_binary
+  end
+end

data/lib/wavesync/file_converter.rb

@@ -5,8 +5,8 @@ module Wavesync
   class FileConverter
     DURATION_TOLERANCE_SECONDS = 0.5
 
-    #: (Audio audio, String source_file_path, PathResolver path_resolver, AudioFormat source_format, AudioFormat target_format, ?padding_seconds: Numeric?) ?{ () -> void } -> bool
-    def convert(audio, source_file_path, path_resolver, source_format, target_format, padding_seconds: nil, &before_transcode)
+    #: (Audio audio, String source_file_path, PathResolver path_resolver, AudioFormat source_format, AudioFormat target_format, ?padding_seconds: Numeric?, ?before_transcode: (^() -> void)?, ?metadata: Hash[String, String], ?mp3_bitrate: Integer) ?{ (String) -> void } -> bool
+    def convert(audio, source_file_path, path_resolver, source_format, target_format, padding_seconds: nil, before_transcode: nil, metadata: {}, mp3_bitrate: 192, &post_transcode)
       needs_format_conversion = target_format.file_type || target_format.sample_rate || target_format.bit_depth
       return false unless needs_format_conversion || padding_seconds&.positive?
 
@@ -34,7 +34,10 @@ module Wavesync
       audio.transcode(target_path.to_s, target_sample_rate: target_format.sample_rate,
                                         target_file_type: target_format.file_type,
                                         target_bit_depth: target_format.bit_depth || source_format.bit_depth,
-                                        padding_seconds: padding_seconds)
+                                        padding_seconds: padding_seconds,
+                                        metadata: metadata,
+                                        target_bitrate: mp3_bitrate,
+                      &post_transcode)
 
       true
     end