wavesync 1.0.0.alpha2 → 1.0.0.alpha4

data/lib/wavesync/python_venv.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'shellwords'
+
+module Wavesync
+  module PythonVenv
+    PYTHON_PATH = File.expand_path('~/.wavesync-venv/bin/python3').freeze
+
+    #: () -> bool
+    def self.available?
+      File.executable?(PYTHON_PATH)
+    end
+
+    #: () -> bool?
+    def self.essentia_available?
+      available? && system("#{PYTHON_PATH} -c 'import essentia' > /dev/null 2>&1")
+    end
+
+    #: (String script, String file_path) -> String
+    def self.run_script(script, file_path)
+      `#{PYTHON_PATH} -c #{Shellwords.escape(script)} #{Shellwords.escape(file_path)} 2>/dev/null`
+    end
+  end
+end

data/lib/wavesync/scanner.rb

@@ -1,20 +1,27 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'fileutils'
-require 'streamio-ffmpeg'
+require 'pathname'
+require 'tempfile'
+require_relative 'logger'
 require_relative 'file_converter'
 
 module Wavesync
   class Scanner
+    #: (String source_library_path) -> void
     def initialize(source_library_path)
-      @source_library_path = File.expand_path(source_library_path)
-      @audio_files = find_audio_files
-      @ui = Wavesync::UI.new
-      @converter = FileConverter.new
-      FFMPEG.logger = Logger.new(File::NULL)
+      @source_library_path = File.expand_path(source_library_path) #: String
+      Logger.configure(@source_library_path)
+      @audio_files = find_audio_files #: Array[String]
+      @ui = Wavesync::UI.new #: UI
+      @converter = FileConverter.new #: FileConverter
     end
 
-    def sync(target_library_path, device, pad: false)
+    #: (String target_library_path, Device device, ?pad: bool, ?staged: bool, ?mp3_bitrate: Integer) ?{ (String) -> void } -> void
+    def sync(target_library_path, device, pad: false, staged: false, mp3_bitrate: 192, &on_file_synced)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      target_library_pathname = Pathname.new(target_library_path)
       path_resolver = PathResolver.new(@source_library_path, target_library_path, device)
       skipped_count = 0
       conversion_count = 0
@@ -22,58 +29,124 @@ module Wavesync
 
       @audio_files.each_with_index do |file, index|
         audio = Audio.new(file)
+        bpm = audio.bpm
 
         source_format = audio.format
         target_format = device.target_format(source_format, file)
+        target_format = target_format.with(sample_rate: nil, bit_depth: nil) if source_format.file_type == 'mp3' && target_format.file_type.nil?
 
-        padding_seconds = nil
-        original_bars = nil
-        target_bars = nil
+        padding_seconds = nil #: Numeric?
+        original_bars = nil #: Integer?
+        target_bars = nil #: Integer?
         if pad && device.bar_multiple
-          padding_seconds = TrackPadding.compute(audio.duration, audio.bpm, device.bar_multiple)
-          original_bars, target_bars = TrackPadding.bar_counts(audio.duration, audio.bpm, device.bar_multiple) unless padding_seconds.zero?
+          padding_seconds = TrackPadding.compute(audio.duration, bpm, device.bar_multiple)
+          original_bars, target_bars = TrackPadding.bar_counts(audio.duration, bpm, device.bar_multiple) unless padding_seconds.zero?
           padding_seconds = nil if padding_seconds.zero?
         end
 
-        @ui.bpm(audio.bpm, original_bars: original_bars, target_bars: target_bars)
+        @ui.bpm(bpm, original_bars: original_bars, target_bars: target_bars)
         @ui.file_progress(file)
 
         if target_format.file_type || target_format.sample_rate || target_format.bit_depth || padding_seconds
+          target_ext = target_format.file_type || source_format.file_type
+          transliterated_metadata = {} #: Hash[String, String]
+          transliterated_metadata = audio.transliterated_tag_changes if device.transliterate_metadata && target_ext == 'mp3'
           converted = @converter.convert(audio, file, path_resolver, source_format, target_format,
-                                         padding_seconds: padding_seconds) do
-            @ui.conversion_progress(source_format, target_format)
+                                         padding_seconds: padding_seconds,
+                                         metadata: transliterated_metadata,
+                                         mp3_bitrate: mp3_bitrate,
+                                         before_transcode: -> { @ui.conversion_progress(source_format, target_format, mp3_bitrate) }) do |local_temp_path|
+            inject_acid_bpm(local_temp_path, bpm, device)
+            inject_cue_points(local_temp_path, audio, source_format, target_format)
           end
-          target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+          converted_target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+          verify_written(converted_target_path, source: file) if converted
+          final_target_path = converted_target_path
         else
-          copied = copy_file(audio, file, path_resolver)
+          if device.bpm_source == :acid_chunk && bpm && File.extname(file).downcase == '.wav'
+            target_path = path_resolver.resolve(file, audio)
+            files_to_cleanup = path_resolver.find_files_to_cleanup(target_path, audio)
+            files_to_cleanup.each { |cleanup_file| FileUtils.rm_f(cleanup_file) }
+            if target_path.exist?
+              copied = false
+            else
+              target_path.dirname.mkpath
+              AcidChunk.write_bpm(file, target_path.to_s, bpm)
+              verify_written(target_path, source: file)
+              copied = true
+            end
+          else
+            copied = copy_file(audio, file, path_resolver)
+            target_path = path_resolver.resolve(file, audio)
+            if copied
+              verify_written(target_path, source: file)
+              inject_transliterated_metadata(target_path.to_s, device)
+            end
+          end
+          final_target_path = target_path
           @ui.copy(source_format)
-          target_path = path_resolver.resolve(file, audio)
-        end
-
-        if (copied || converted) && device.bpm_source == :acid_chunk && audio.bpm && target_path.extname.downcase == '.wav'
-          temp_path = "#{target_path}.tmp"
-          AcidChunk.write_bpm(target_path.to_s, temp_path, audio.bpm)
-          FileUtils.mv(temp_path, target_path.to_s)
         end
 
         if !copied && !converted
           skipped_count += 1
-          @ui.skip
+          @ui.skip(staged: staged)
         end
 
         conversion_count += 1 if converted
         @ui.sync_progress(index, @audio_files.size, device)
+
+        if on_file_synced && final_target_path
+          relative_path = final_target_path.relative_path_from(target_library_pathname).to_s
+          on_file_synced.call(relative_path)
+        end
       end
 
       puts
+      system('sync')
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      Logger.log_run_time(elapsed)
+    end
+
+    #: (String target_library_path, Device device) -> void
+    def pull_cue_points(target_library_path, device)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      path_resolver = PathResolver.new(@source_library_path, target_library_path, device)
+      @ui.pull_progress(0, @audio_files.size, device)
+
+      @audio_files.each_with_index do |file, index|
+        audio = Audio.new(file)
+        source_format = audio.format
+        @ui.file_progress(file)
+
+        if source_format.file_type == 'wav'
+          target_format = device.target_format(source_format, file)
+          target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+          if target_path.extname.downcase == '.wav' && target_path.exist?
+            target_cue_points = CueChunk.read(target_path.to_s)
+            if target_cue_points.any?
+              source_cue_points = audio.cue_points
+              audio.write_cue_points(target_cue_points) unless CueChunk.same?(source_cue_points, target_cue_points)
+            end
+          end
+        end
+
+        @ui.pull_progress(index, @audio_files.size, device)
+      end
+
+      puts
+      system('sync')
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      Logger.log_run_time(elapsed)
     end
 
     private
 
+    #: () -> Array[String]
     def find_audio_files
       Audio.find_all(@source_library_path)
     end
 
+    #: (Audio audio, String source_file_path, PathResolver path_resolver) -> bool
     def copy_file(audio, source_file_path, path_resolver)
       target_path = path_resolver.resolve(source_file_path, audio)
 
@@ -88,10 +161,53 @@ module Wavesync
       end
     end
 
+    #: (String path, Device device) -> void
+    def inject_transliterated_metadata(path, device)
+      return unless device.transliterate_metadata
+
+      Audio.new(path).transliterate_tags
+    end
+
+    #: (String local_temp_path, (Integer | Float | String)? bpm, Device device) -> void
+    def inject_acid_bpm(local_temp_path, bpm, device)
+      return unless device.bpm_source == :acid_chunk && bpm && File.extname(local_temp_path).downcase == '.wav'
+
+      AcidChunk.write_bpm_in_place(local_temp_path, bpm)
+    end
+
+    #: (String local_temp_path, Audio audio, AudioFormat source_format, AudioFormat target_format) -> void
+    def inject_cue_points(local_temp_path, audio, source_format, target_format)
+      return unless source_format.file_type == 'wav' && File.extname(local_temp_path).downcase == '.wav'
+
+      source_cue_points = audio.cue_points
+      return unless source_cue_points.any?
+
+      rescaled_cue_points = rescale_cue_points(source_cue_points, audio.sample_rate, target_format.sample_rate || audio.sample_rate)
+      CueChunk.append_to_file(local_temp_path, rescaled_cue_points)
+    end
+
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points, Integer? source_sample_rate, Integer? target_sample_rate) -> Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+    def rescale_cue_points(cue_points, source_sample_rate, target_sample_rate)
+      return cue_points if source_sample_rate == target_sample_rate || source_sample_rate.nil? || target_sample_rate.nil?
+
+      cue_points.map do |cue_point|
+        cue_point.merge(sample_offset: (cue_point[:sample_offset] * target_sample_rate / source_sample_rate.to_f).round) #: {identifier: Integer, sample_offset: Integer, label: String?}
+      end
+    end
+
+    #: (String source, Pathname target) -> void
     def safe_copy(source, target)
       FileUtils.install(source, target)
-    rescue Errno::ENOENT
-      puts 'Errno::ENOENT'
+    rescue Errno::ENOENT => e
+      Logger.log_error(e, call_site: 'Scanner#safe_copy', arguments: { source:, target: })
+    end
+
+    #: (Pathname target_path, source: String) -> void
+    def verify_written(target_path, source:)
+      return if target_path.exist?
+
+      error = RuntimeError.new('target file missing after write')
+      Logger.log_error(error, call_site: 'Scanner#verify_written', arguments: { source:, target: target_path.to_s })
     end
   end
 end

data/lib/wavesync/{set.rb → setlist.rb}

@@ -1,29 +1,36 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'yaml'
 require 'fileutils'
 
 module Wavesync
-  class Set
-    SETS_FOLDER = '.sets'
+  class Setlist
+    SETLISTS_FOLDER = '.setlists'
 
-    attr_reader :name, :tracks, :library_path
+    attr_reader :name #: String
+    attr_reader :tracks #: Array[String]
+    attr_reader :library_path #: String
 
-    def self.sets_path(library_path)
-      File.join(library_path, SETS_FOLDER)
+    #: (String library_path) -> String
+    def self.setlists_path(library_path)
+      File.join(library_path, SETLISTS_FOLDER)
     end
 
-    def self.set_path(library_path, name)
-      File.join(sets_path(library_path), "#{name}.yml")
+    #: (String library_path, String name) -> String
+    def self.setlist_path(library_path, name)
+      File.join(setlists_path(library_path), "#{name}.yml")
     end
 
+    #: (String library_path, String name) -> Setlist
     def self.load(library_path, name)
-      data = YAML.load_file(set_path(library_path, name))
+      data = YAML.load_file(setlist_path(library_path, name))
       new(library_path, data['name'], expand_tracks(library_path, data['tracks']))
     end
 
+    #: (String library_path) -> Array[Setlist]
     def self.all(library_path)
-      path = sets_path(library_path)
+      path = setlists_path(library_path)
       return [] unless Dir.exist?(path)
 
       Dir.glob(File.join(path, '*.yml')).map do |file|
@@ -32,48 +39,57 @@ module Wavesync
       end.sort_by(&:name)
     end
 
+    #: (String library_path, String name) -> bool
     def self.exists?(library_path, name)
-      File.exist?(set_path(library_path, name))
+      File.exist?(setlist_path(library_path, name))
     end
 
+    #: (String library_path, String name, ?Array[String] tracks) -> void
     def initialize(library_path, name, tracks = [])
       @library_path = library_path
       @name = name
       @tracks = tracks.dup
     end
 
+    #: (String path) -> void
     def add_track(path)
       @tracks << path
     end
 
+    #: (Integer index) -> String?
     def remove_track(index)
       @tracks.delete_at(index)
     end
 
+    #: (Integer index) -> void
     def move_up(index)
       return if index <= 0
 
       @tracks[index], @tracks[index - 1] = @tracks[index - 1], @tracks[index]
     end
 
+    #: (Integer index) -> void
     def move_down(index)
       return if index >= @tracks.size - 1
 
       @tracks[index], @tracks[index + 1] = @tracks[index + 1], @tracks[index]
     end
 
+    #: () -> void
     def save
-      FileUtils.mkdir_p(self.class.sets_path(@library_path))
-      File.write(self.class.set_path(@library_path, @name), to_yaml)
+      FileUtils.mkdir_p(self.class.setlists_path(@library_path))
+      File.write(self.class.setlist_path(@library_path, @name), to_yaml)
     end
 
     private
 
+    #: (String library_path, Array[String]? tracks) -> Array[String]
     def self.expand_tracks(library_path, tracks)
       (tracks || []).map { |t| File.join(library_path, t) }
     end
     private_class_method :expand_tracks
 
+    #: () -> String
     def to_yaml
       relative_tracks = @tracks.map { |t| t.sub("#{@library_path}/", '') }
       { 'name' => @name, 'tracks' => relative_tracks }.to_yaml