wavesync 1.0.0.alpha4 → 1.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b3c24cfdb7c1e1e6fe97157437f690995f59a9981b0771f42f1669af101a31a
-  data.tar.gz: 03c846e8a0c9e19d6a6b9f8a6cb72edc426a1db17dcd4cfdbcaa556c643a1eb1
+  metadata.gz: 6a763e53a386112a5a2311cf50108a3a237ae7442d1d9c53b98fb02696315a12
+  data.tar.gz: c9972d69bad12cfd4111067bcc34e9ec646f26e80b97df44a1c5a7762daf8abf
 SHA512:
-  metadata.gz: 7f3ce9462f43a8c1fd453df2eb1919fdf6c21ef5f2efa95aec8effdb737309801f1c94b3ec31353a766e448f7c14148208628f4f0f80c86e0b19079fef6f6ac0
-  data.tar.gz: a51decb6dc314e43c134fa11b5f0332eddbde5616b2051bafa645861b386dc965f88f0d0725fc9a435d5d3206f1e8af8ad38d26b204eb49072b5e2a98daaa763
+  metadata.gz: 4964e829b8b3488f16e8a39857bfd178c624b94bb9739195d987d17cb20c57fb811e6d0a442dc6bf104ff7f18df658b40c038decbcc813a2d0f332e9d1384315
+  data.tar.gz: e96d2143e3667162200af22ffc97738cf36737cc0cd1a7f5ed2f3316b401544986d9a2a44841beb37e1e4059cf351986432a0783cbdfa1e29c9e0f3777b8e401

data/README.md

@@ -27,36 +27,18 @@ Unsupported file types will be ignored when syncing.
 
 ```bash
 brew install ffmpeg
-brew install taglib
-```
-
-3. Install Wavesync
-
-```bash
-gem install wavesync --pre
-```
-
-4. Set up the Python environment for BPM analysis
-
-```bash
+brew install libmtp
 brew install python@3.11
 python3.11 -m venv ~/.wavesync-venv
 ~/.wavesync-venv/bin/pip install essentia
 ```
 
-5. Install libmtp (only required for syncing to TP-7)
+3. Install Wavesync
 
 ```bash
-brew install libmtp
+gem install wavesync --pre
 ```
 
-Recent versions of field kit no longer expose the TP-7 as a filesystem path, so wavesync talks to the device over MTP directly.
-
-Before syncing the TP-7:
-
-- Quit field kit and any other app that may claim the TP-7. They cannot run at the same time as wavesync — only one process can hold the MTP session.
-- Put the TP-7 into MTP mode: hold down the Stop button while turning the TP-7 on, and keep holding until MTP mode is engaged.
-
 ## Configuration
 
 Wavesync is configured via a YAML file. By default it looks for `~/wavesync.yml`. You can also pass a path explicitly with the `-c` flag.
@@ -108,6 +90,12 @@ wavesync analyze
 
 # Overwrite existing BPM values
 wavesync analyze -f
+
+# Analyze a single file instead of the whole library
+wavesync analyze "/path/to/track.m4a"
+
+# Analyze all files in a folder instead of the whole library
+wavesync analyze "/path/to/folder"
 ```
 
 ### Sync
@@ -127,6 +115,11 @@ wavesync sync -p
 
 When a source file's sample rate isn't supported by the target device, Wavesync selects the closest supported rate. Example: If a 96kHz file is synced to an Octatrack (which only supports 44.1kHz), it will be downsampled to 44.1kHz.
 
+Before syncing the TP-7:
+
+- Quit field kit and any other app that may claim the TP-7. They cannot run at the same time as wavesync — only one process can hold the MTP session.
+- Put the TP-7 into MTP mode: hold down the Stop button while turning the TP-7 on, and keep holding until MTP mode is engaged.
+
 ### Pull
 
 ```bash

data/config/devices.yml

@@ -17,6 +17,7 @@ devices:
   unsupported_characters:
     - "™"
     - '"'
+  transliterate_paths: true
   uppercase_paths: true
 
 - name: Octatrack

data/lib/wavesync/acid_chunk.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
+require_relative 'timing'
+
 module Wavesync
   class AcidChunk
     RIFF_HEADER_SIZE = 12 # 'RIFF' (4) + size (4) + 'WAVE' (4)
@@ -30,107 +32,115 @@ module Wavesync
 
     #: (String filepath) -> Float?
     def self.read_bpm(filepath)
-      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 = ((file.read(CHUNK_SIZE_FIELD_SIZE) || '').unpack1(UINT32_LITTLE_ENDIAN) || 0).to_i
-          if chunk_id == ACID_CHUNK_ID
-            file.seek(ACID_TEMPO_OFFSET, IO::SEEK_CUR)
-            return ((file.read(ACID_TEMPO_SIZE) || '').unpack1(FLOAT32_LITTLE_ENDIAN) || 0).to_f
-          else
-            padding = chunk_size.odd? ? 1 : 0
-            file.seek(chunk_size + padding, IO::SEEK_CUR)
+      Timing.current.measure(:wav_chunks) do
+        result = nil #: Float?
+        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 = ((file.read(CHUNK_SIZE_FIELD_SIZE) || '').unpack1(UINT32_LITTLE_ENDIAN) || 0).to_i
+            if chunk_id == ACID_CHUNK_ID
+              file.seek(ACID_TEMPO_OFFSET, IO::SEEK_CUR)
+              result = ((file.read(ACID_TEMPO_SIZE) || '').unpack1(FLOAT32_LITTLE_ENDIAN) || 0).to_f
+              break
+            else
+              padding = chunk_size.odd? ? 1 : 0
+              file.seek(chunk_size + padding, IO::SEEK_CUR)
+            end
           end
         end
+        result
       end
-      nil
     end
 
     #: (String filepath, Integer | Float | String new_bpm) -> void
     def self.write_bpm_in_place(filepath, new_bpm)
-      bpm_bytes = [new_bpm.to_f].pack(FLOAT32_LITTLE_ENDIAN)
+      Timing.current.measure(:wav_chunks) do
+        bpm_bytes = [new_bpm.to_f].pack(FLOAT32_LITTLE_ENDIAN)
 
-      File.open(filepath, 'r+b') do |file|
-        file.seek(RIFF_HEADER_SIZE)
+        File.open(filepath, 'r+b') do |file|
+          file.seek(RIFF_HEADER_SIZE)
 
-        acid_chunk_found = false
+          acid_chunk_found = false
 
-        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) || ''
-          chunk_size = (chunk_size_bytes.unpack1(UINT32_LITTLE_ENDIAN) || 0).to_i
-
-          if chunk_id == ACID_CHUNK_ID
-            file.seek(ACID_TEMPO_OFFSET, IO::SEEK_CUR)
-            file.write(bpm_bytes)
-            acid_chunk_found = true
-            break
-          else
-            padding = chunk_size.odd? ? 1 : 0
-            file.seek(chunk_size + padding, IO::SEEK_CUR)
+          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) || ''
+            chunk_size = (chunk_size_bytes.unpack1(UINT32_LITTLE_ENDIAN) || 0).to_i
+
+            if chunk_id == ACID_CHUNK_ID
+              file.seek(ACID_TEMPO_OFFSET, IO::SEEK_CUR)
+              file.write(bpm_bytes)
+              acid_chunk_found = true
+              break
+            else
+              padding = chunk_size.odd? ? 1 : 0
+              file.seek(chunk_size + padding, IO::SEEK_CUR)
+            end
           end
-        end
 
-        unless acid_chunk_found
-          file.seek(0, IO::SEEK_END)
-          create_acid_chunk(file, new_bpm.to_f)
+          unless acid_chunk_found
+            file.seek(0, IO::SEEK_END)
+            create_acid_chunk(file, new_bpm.to_f)
+          end
         end
-      end
 
-      update_riff_size(filepath)
+        update_riff_size(filepath)
+      end
     end
 
     #: (String source_filepath, String output_filepath, Integer | Float | String new_bpm) -> void
     def self.write_bpm(source_filepath, output_filepath, new_bpm)
-      bpm_bytes = [new_bpm.to_f].pack(FLOAT32_LITTLE_ENDIAN)
-      acid_chunk_found = false
+      Timing.current.measure(:wav_chunks) do
+        bpm_bytes = [new_bpm.to_f].pack(FLOAT32_LITTLE_ENDIAN)
+        acid_chunk_found = false
 
-      File.open(source_filepath, 'rb') do |input|
-        File.open(output_filepath, 'wb') do |output|
-          riff_header = input.read(RIFF_HEADER_SIZE)
-          output.write(riff_header)
+        File.open(source_filepath, 'rb') do |input|
+          File.open(output_filepath, 'wb') do |output|
+            riff_header = input.read(RIFF_HEADER_SIZE)
+            output.write(riff_header)
 
-          until input.eof?
-            chunk_id = input.read(CHUNK_ID_SIZE)
-            break if chunk_id.nil? || chunk_id.length < CHUNK_ID_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) || ''
-            chunk_size = (chunk_size_bytes.unpack1(UINT32_LITTLE_ENDIAN) || 0).to_i
+              chunk_size_bytes = input.read(CHUNK_SIZE_FIELD_SIZE) || ''
+              chunk_size = (chunk_size_bytes.unpack1(UINT32_LITTLE_ENDIAN) || 0).to_i
 
-            output.write(chunk_id)
-            output.write(chunk_size_bytes)
+              output.write(chunk_id)
+              output.write(chunk_size_bytes)
 
-            if chunk_id == ACID_CHUNK_ID
-              acid_chunk_found = true
+              if chunk_id == ACID_CHUNK_ID
+                acid_chunk_found = true
 
-              output.write(input.read(ACID_TEMPO_OFFSET))
+                output.write(input.read(ACID_TEMPO_OFFSET))
 
-              input.read(ACID_TEMPO_SIZE)
+                input.read(ACID_TEMPO_SIZE)
 
-              output.write(bpm_bytes)
+                output.write(bpm_bytes)
 
-              remaining = chunk_size - ACID_TEMPO_OFFSET - ACID_TEMPO_SIZE
-              output.write(input.read(remaining)) if remaining.positive?
+                remaining = chunk_size - ACID_TEMPO_OFFSET - ACID_TEMPO_SIZE
+                output.write(input.read(remaining)) if remaining.positive?
 
-              output.write(input.read(1)) if chunk_size.odd?
-            else
-              padding = chunk_size.odd? ? 1 : 0
-              output.write(input.read(chunk_size + padding))
+                output.write(input.read(1)) if chunk_size.odd?
+              else
+                padding = chunk_size.odd? ? 1 : 0
+                output.write(input.read(chunk_size + padding))
+              end
             end
-          end
 
-          create_acid_chunk(output, new_bpm.to_f) unless acid_chunk_found
+            create_acid_chunk(output, new_bpm.to_f) unless acid_chunk_found
+          end
         end
-      end
 
-      return if acid_chunk_found
+        next if acid_chunk_found
 
-      update_riff_size(output_filepath)
+        update_riff_size(output_filepath)
+      end
     end
 
     #: (untyped output, Float bpm) -> void

data/lib/wavesync/analyzer.rb

@@ -5,7 +5,6 @@ require_relative 'logger'
 
 module Wavesync
   class Analyzer
-    CONFIRM_MESSAGE = 'wavesync analyze will add bpm meta data to files in library. Continue? [y/N] '
     SETUP_INSTRUCTIONS = 'brew install python@3.11 && python3.11 -m venv ~/.wavesync-venv && ~/.wavesync-venv/bin/pip install essentia'
 
     #: (String library_path) -> void
@@ -16,29 +15,30 @@ module Wavesync
       @ui = UI.new #: UI
     end
 
-    #: (?overwrite: bool) -> void
-    def analyze(overwrite: false)
+    #: (?overwrite: bool, ?path: String?) -> void
+    def analyze(overwrite: false, path: nil)
       unless BpmDetector.available?
         puts "Error: essentia is not installed. Set up the Python venv with:\n  #{SETUP_INSTRUCTIONS}"
         exit 1
       end
 
-      return unless @ui.confirm(CONFIRM_MESSAGE)
+      files = files_for(path)
+      return unless @ui.confirm(confirm_message(path))
 
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      @audio_files.each_with_index do |file, index|
+      files.each_with_index do |file, index|
         audio = Audio.new(file)
 
         if audio.bpm && !overwrite
-          @ui.analyze_progress(index, @audio_files.size)
+          @ui.analyze_progress(index, files.size)
           @ui.analyze_skip(file, audio.bpm)
           next
         end
 
         bpm = BpmDetector.detect(file)
         audio.write_bpm(bpm) if bpm
-        @ui.analyze_progress(index, @audio_files.size)
+        @ui.analyze_progress(index, files.size)
         @ui.analyze_result(file, bpm)
       end
 
@@ -48,6 +48,28 @@ module Wavesync
 
     private
 
+    #: (String? path) -> String
+    def confirm_message(path)
+      target =
+        if path.nil?
+          'files in library'
+        elsif File.directory?(File.expand_path(path))
+          'files in folder'
+        else
+          'file'
+        end
+
+      "wavesync analyze will add bpm meta data to #{target}. Continue? [y/N] "
+    end
+
+    #: (String? path) -> Array[String]
+    def files_for(path)
+      return @audio_files unless path
+
+      expanded_path = File.expand_path(path)
+      File.directory?(expanded_path) ? Audio.find_all(expanded_path) : [expanded_path]
+    end
+
     #: () -> Array[String]
     def find_audio_files
       Audio.find_all(@library_path).sort

data/lib/wavesync/audio.rb

@@ -5,6 +5,9 @@ require 'securerandom'
 require 'tmpdir'
 require 'fileutils'
 require_relative 'logger'
+require_relative 'timing'
+require_relative 'transliterator'
+require_relative 'mp4_tmpo'
 
 module Wavesync
   class Audio
@@ -61,14 +64,19 @@ module Wavesync
       )
     end
 
-    #: () -> Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+    #: () -> Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}]
     def cue_points
       return [] unless @file_ext == '.wav'
 
       CueChunk.read(@file_path)
     end
 
-    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    #: () -> Array[{start_sample: Integer, end_sample: Integer}]
+    def loops
+      CueChunk.loops(cue_points)
+    end
+
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points) -> void
     def write_cue_points(cue_points)
       temp_path = "#{@file_path}.tmp"
       CueChunk.write(@file_path, temp_path, cue_points)
@@ -97,8 +105,6 @@ module Wavesync
 
     FFMPEG_KEY_TO_FRAME_ID = FRAME_ID_TO_FFMPEG_KEY.invert.freeze
 
-    COMBINING_MARKS = /\p{Mn}/
-
     #: () -> Hash[String, String]
     def transliterated_tag_changes
       current_tags = @audio.tags
@@ -154,11 +160,11 @@ module Wavesync
           command.audio_filter("apad=whole_dur=#{total_duration.round(6)}")
         end
         metadata.each { |key, value| command.metadata(key, value) }
-        command.run(temp_path)
+        Timing.current.measure(:transcode) { command.run(temp_path) }
         yield temp_path if block_given?
-        FileUtils.install(temp_path, target_path)
+        Timing.current.measure(:copy) { FileUtils.install(temp_path, target_path) }
         true
-      rescue Errno::ENOENT => e
+      rescue SystemCallError => e
         Logger.log_error(e, call_site: 'Audio#transcode', arguments: { target_path:, target_sample_rate:, target_file_type:, target_bit_depth:, padding_seconds:, target_bitrate: })
         false
       ensure
@@ -191,11 +197,7 @@ module Wavesync
 
     #: () -> Integer?
     def bpm_from_m4a
-      value = find_in_tags(@audio.tags, 'BPM')
-      return nil if value.nil?
-
-      int_value = value.to_i
-      int_value.zero? ? nil : int_value
+      Mp4Tmpo.read_bpm(@file_path)
     end
 
     #: () -> String?
@@ -243,7 +245,7 @@ module Wavesync
 
     #: (String | Integer | Float bpm) -> void
     def write_bpm_to_m4a(bpm)
-      write_file_metadata('BPM' => bpm.to_i.to_s)
+      Mp4Tmpo.write_bpm(@file_path, bpm)
     end
 
     #: (String | Integer | Float bpm) -> void
@@ -256,10 +258,9 @@ module Wavesync
       ext = File.extname(@file_path)
       temp_path = File.join(Dir.tmpdir, "wavesync_meta_#{SecureRandom.hex}#{ext}")
       command = FFMPEG.new.input(@file_path).copy_streams.map_metadata(0)
-      command.movflags('+use_metadata_tags') if ext == '.m4a'
       command.write_id3v2(1) if %w[.aif .aiff].include?(ext)
       metadata_hash.each { |key, value| command.metadata(key, value) }
-      command.run(temp_path)
+      Timing.current.measure(:ffmpeg_metadata) { command.run(temp_path) }
       FileUtils.mv(temp_path, @file_path)
     ensure
       FileUtils.rm_f(temp_path)
@@ -267,9 +268,7 @@ module Wavesync
 
     #: (String string) -> String
     def transliterate(string)
-      string
-        .unicode_normalize(:nfd)
-        .gsub(COMBINING_MARKS, '')
+      Transliterator.transliterate(string)
     end
   end
 end

data/lib/wavesync/commands/analyze.rb

@@ -11,14 +11,16 @@ module Wavesync
       self.name = 'analyze'
       self.description = 'Detect and write BPM metadata to library tracks'
       self.options = [FORCE_OPTION].freeze
+      self.positional_args = '[file_or_folder]'
 
       #: () -> void
       def run
-        options, config = parse_options(banner: 'Usage: wavesync analyze [options]') do |opts, opts_hash|
+        options, config = parse_options(banner: 'Usage: wavesync analyze [options] [file_or_folder]') do |opts, opts_hash|
           opts.on(*FORCE_OPTION.to_a) { opts_hash[:overwrite] = true }
         end
 
-        Wavesync::Analyzer.new(config.library).analyze(overwrite: options[:overwrite] || false)
+        path = ARGV.shift
+        Wavesync::Analyzer.new(config.library).analyze(overwrite: options[:overwrite] || false, path: path)
       end
     end
   end

data/lib/wavesync/commands/command.rb

@@ -7,10 +7,11 @@ module Wavesync
     class Command
       class << self
         attr_accessor :name, :description
-        attr_writer :options, :subcommands
+        attr_writer :options, :subcommands, :positional_args
 
         def options = @options || []
         def subcommands = @subcommands || []
+        def positional_args = @positional_args || ''
       end
 
       #: (banner: String) ?{ (OptionParser, Hash[Symbol, untyped]) -> void } -> [Hash[Symbol, untyped], Config]

data/lib/wavesync/commands/help.rb

@@ -65,7 +65,9 @@ module Wavesync
           GLOBAL_OPTIONS.each { |option| puts "  #{option.short}, #{option.long}  #{option.description}" }
         else
           OptionParser.new do |opts|
-            opts.banner = "Usage: wavesync #{command.name} [options]"
+            banner = "Usage: wavesync #{command.name} [options]"
+            banner += " #{command.positional_args}" unless command.positional_args.empty?
+            opts.banner = banner
             (command.options + GLOBAL_OPTIONS).each { |option| opts.on(*option.to_a) }
             puts opts
           end

data/lib/wavesync/commands/pull.rb

@@ -23,19 +23,36 @@ module Wavesync
         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)
+        stop_requested = false
+        original_handler = Signal.trap('INT') do
+          if stop_requested
+            Signal.trap('INT', 'DEFAULT')
+            warn "\nAborting."
+            Process.kill('INT', Process.pid)
+          else
+            stop_requested = true
+            warn "\nFinishing current file then stopping. Press Ctrl+C again to abort immediately."
+          end
+        end
+
+        begin
+          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!(stop_when: -> { stop_requested }) 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)
+            break if stop_requested
           end
-          scanner.pull_cue_points(transport.working_directory, device)
+        ensure
+          Signal.trap('INT', original_handler)
         end
       end
     end