wavesync 1.0.0.alpha1 → 1.0.0.alpha3

data/lib/wavesync/device.rb

@@ -1,10 +1,17 @@
 # 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?
 
+    #: (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 = name
       @sample_rates = sample_rates
@@ -14,18 +21,22 @@ module Wavesync
       @bar_multiple = bar_multiple
     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|
@@ -40,6 +51,7 @@ module Wavesync
       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,19 +60,23 @@ 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)
 

data/lib/wavesync/essentia_bpm_detector.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'json'
+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
+      nil
+    end
+  end
+end

data/lib/wavesync/file_converter.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 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)
       needs_format_conversion = target_format.file_type || target_format.sample_rate || target_format.bit_depth
       return false unless needs_format_conversion || padding_seconds&.positive?

data/lib/wavesync/path_resolver.rb

@@ -1,26 +1,33 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'pathname'
 
 module Wavesync
   class PathResolver
     BPM_PATTERN = / \d+ bpm/
 
+    #: (String source_library_path, String target_library_path, Device device) -> void
     def initialize(source_library_path, target_library_path, device)
-      @source_library_path = Pathname(File.expand_path(source_library_path))
-      @target_library_path = Pathname(File.expand_path(target_library_path))
-      @device = device
+      @source_library_path = Pathname(File.expand_path(source_library_path)) #: Pathname
+      @target_library_path = Pathname(File.expand_path(target_library_path)) #: Pathname
+      @device = device #: Device
     end
 
+    #: (String source_file_path, Audio audio, ?target_file_type: String?) -> Pathname
     def resolve(source_file_path, audio, target_file_type: nil)
       relative_path = Pathname(source_file_path).relative_path_from(@source_library_path)
       target_path = @target_library_path.join(relative_path)
 
       target_path = target_path.sub_ext(".#{target_file_type}") if target_file_type
 
-      target_path = add_bpm_to_filename(target_path, audio.bpm) if @device.bpm_source == :filename && audio.bpm
+      bpm = audio.bpm
+      target_path = add_bpm_to_filename(target_path, bpm) if @device.bpm_source == :filename && bpm
 
       target_path
     end
 
+    #: (Pathname target_path, Audio audio) -> Array[Pathname]
     def find_files_to_cleanup(target_path, audio)
       return [] unless @device.bpm_source == :filename && audio.bpm
 
@@ -29,11 +36,12 @@ module Wavesync
 
       pattern = target_path.dirname.join("#{basename}{, * bpm}#{ext}")
       Dir.glob(pattern.to_s).map { |f| Pathname(f) }
-         .reject { |path| path == target_path }
+                            .reject { |path| path == target_path }
     end
 
     private
 
+    #: (Pathname path, String | Integer bpm) -> Pathname
     def add_bpm_to_filename(path, bpm)
       ext = path.extname
       basename = path.basename(ext).to_s
@@ -44,6 +52,7 @@ module Wavesync
       path.dirname.join(new_basename)
     end
 
+    #: (Pathname path) -> Pathname
     def remove_bpm_from_filename(path)
       ext = path.extname
       basename = path.basename(ext).to_s

data/lib/wavesync/percival_bpm_detector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative 'python_venv'
+
+module Wavesync
+  class PercivalBpmDetector
+    PYTHON_SCRIPT = <<~PYTHON
+      import essentia.standard as es, sys
+      audio = es.MonoLoader(filename=sys.argv[1], sampleRate=44100)()
+      bpm = es.PercivalBpmEstimator()(audio)
+      print(round(float(bpm)))
+    PYTHON
+
+    #: () -> bool?
+    def self.available?
+      PythonVenv.essentia_available?
+    end
+
+    #: (String file_path) -> Integer?
+    def self.detect(file_path)
+      output = PythonVenv.run_script(PYTHON_SCRIPT, file_path)
+      bpm = output.strip.to_f
+      bpm.positive? ? bpm.round : nil
+    rescue StandardError
+      nil
+    end
+  end
+end

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,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'fileutils'
 require 'streamio-ffmpeg'
@@ -6,14 +7,16 @@ 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
+      @source_library_path = File.expand_path(source_library_path) #: String
+      @audio_files = find_audio_files #: Array[String]
+      @ui = Wavesync::UI.new #: UI
+      @converter = FileConverter.new #: FileConverter
       FFMPEG.logger = Logger.new(File::NULL)
     end
 
+    #: (String target_library_path, Device device, ?pad: bool) -> void
     def sync(target_library_path, device, pad: false)
       path_resolver = PathResolver.new(@source_library_path, target_library_path, device)
       skipped_count = 0
@@ -26,9 +29,9 @@ module Wavesync
         source_format = audio.format
         target_format = device.target_format(source_format, file)
 
-        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?
@@ -38,6 +41,17 @@ module Wavesync
         @ui.bpm(audio.bpm, original_bars: original_bars, target_bars: target_bars)
         @ui.file_progress(file)
 
+        if source_format.file_type == 'wav'
+          prospective_target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+          if prospective_target_path.extname.downcase == '.wav' && prospective_target_path.exist?
+            target_cue_points = CueChunk.read(prospective_target_path.to_s)
+            if target_cue_points.any?
+              source_cue_points = audio.cue_points
+              audio.write_cue_points(target_cue_points) unless same_cue_points?(source_cue_points, target_cue_points)
+            end
+          end
+        end
+
         if target_format.file_type || target_format.sample_rate || target_format.bit_depth || padding_seconds
           converted = @converter.convert(audio, file, path_resolver, source_format, target_format,
                                          padding_seconds: padding_seconds) do
@@ -50,12 +64,23 @@ module Wavesync
           target_path = path_resolver.resolve(file, audio)
         end
 
-        if (copied || converted) && device.bpm_source == :acid_chunk && audio.bpm && target_path.extname.downcase == '.wav'
+        bpm = audio.bpm
+        if (copied || converted) && device.bpm_source == :acid_chunk && bpm && target_path.extname.downcase == '.wav'
           temp_path = "#{target_path}.tmp"
-          AcidChunk.write_bpm(target_path.to_s, temp_path, audio.bpm)
+          AcidChunk.write_bpm(target_path.to_s, temp_path, bpm)
           FileUtils.mv(temp_path, target_path.to_s)
         end
 
+        if converted && source_format.file_type == 'wav' && target_path.extname.downcase == '.wav'
+          source_cue_points = audio.cue_points
+          if source_cue_points.any?
+            rescaled_cue_points = rescale_cue_points(source_cue_points, audio.sample_rate, target_format.sample_rate || audio.sample_rate)
+            temp_path = "#{target_path}.tmp"
+            CueChunk.write(target_path.to_s, temp_path, rescaled_cue_points)
+            FileUtils.mv(temp_path, target_path.to_s)
+          end
+        end
+
         if !copied && !converted
           skipped_count += 1
           @ui.skip
@@ -66,14 +91,17 @@ module Wavesync
       end
 
       puts
+      system('sync')
     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,6 +116,27 @@ module Wavesync
       end
     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 same_cue_points?(cue_points_a, cue_points_b)
+      comparable_cue_points(cue_points_a) == comparable_cue_points(cue_points_b)
+    end
+
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> Array[{sample_offset: Integer, label: String?}]
+    def comparable_cue_points(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
+
+    #: (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

data/lib/wavesync/set.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'yaml'
 require 'fileutils'
@@ -7,21 +8,27 @@ module Wavesync
   class Set
     SETS_FOLDER = '.sets'
 
-    attr_reader :name, :tracks, :library_path
+    attr_reader :name #: String
+    attr_reader :tracks #: Array[String]
+    attr_reader :library_path #: String
 
+    #: (String library_path) -> String
     def self.sets_path(library_path)
       File.join(library_path, SETS_FOLDER)
     end
 
+    #: (String library_path, String name) -> String
     def self.set_path(library_path, name)
       File.join(sets_path(library_path), "#{name}.yml")
     end
 
+    #: (String library_path, String name) -> Set
     def self.load(library_path, name)
       data = YAML.load_file(set_path(library_path, name))
       new(library_path, data['name'], expand_tracks(library_path, data['tracks']))
     end
 
+    #: (String library_path) -> Array[Set]
     def self.all(library_path)
       path = sets_path(library_path)
       return [] unless Dir.exist?(path)
@@ -32,36 +39,43 @@ 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))
     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)
@@ -69,11 +83,13 @@ module Wavesync
 
     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