wavesync 1.0.0.beta1 → 1.0.0.beta2

data/lib/wavesync/mp4_tmpo.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'fileutils'
+require_relative 'timing'
+
+module Wavesync
+  # Reads and writes the iTunes `tmpo` atom (BPM) in MP4/M4A files.
+  #
+  # ffmpeg/ffprobe cannot read or write `tmpo`, so we parse the atom tree
+  # directly — the same hand-rolled approach used for WAV in `AcidChunk` and
+  # `CueChunk`. `tmpo` lives at moov → udta → meta → ilst → tmpo → data, where
+  # the value is a big-endian integer. This is the form Apple Music writes and
+  # the one `AVFoundation` (and thus audioplayer) reads.
+  class Mp4Tmpo
+    HEADER_SIZE = 8         # box size (4) + type (4)
+    TYPE_SIZE = 4
+    FULLBOX_FLAGS_SIZE = 4  # version (1) + flags (3)
+    LOCALE_SIZE = 4         # `data` atom locale field
+    DATA_TYPE_UTF8 = 1
+    DATA_TYPE_INTEGER = 21
+
+    UINT16 = 'n'            # iTunes stores BPM as a 16-bit big-endian integer
+    UINT32 = 'N'
+    UINT64 = 'Q>'
+    ZERO_FLAGS = [0].pack(UINT32).freeze
+
+    #: (String filepath) -> Integer?
+    def self.read_bpm(filepath)
+      Timing.current.measure(:mp4_chunks) do
+        data = File.binread(filepath).b
+        ilst = locate_ilst(data)
+        next nil unless ilst
+
+        value = tmpo_value(data, ilst[0], ilst[1])
+        value&.positive? ? value : nil
+      end
+    end
+
+    #: (String filepath, Integer | Float | String bpm) -> void
+    def self.write_bpm(filepath, bpm)
+      Timing.current.measure(:mp4_chunks) do
+        data = File.binread(filepath).b
+        updated = set_tmpo(data, bpm.to_i)
+        next if updated.equal?(data)
+
+        temp_path = "#{filepath}.tmp"
+        File.binwrite(temp_path, updated)
+        FileUtils.mv(temp_path, filepath)
+      end
+    end
+
+    # --- reading -------------------------------------------------------------
+
+    #: (String data, Integer ilst_start, Integer ilst_finish) -> Integer?
+    def self.tmpo_value(data, ilst_start, ilst_finish)
+      tmpo = find_box(data, 'tmpo', ilst_start, ilst_finish)
+      return nil unless tmpo
+
+      t_off, t_size, t_hdr = tmpo
+      box = find_box(data, 'data', t_off + t_hdr, t_off + t_size)
+      return nil unless box
+
+      d_off, d_size, d_hdr = box
+      type_flag = u32(data, d_off + d_hdr) & 0xFFFFFF
+      value_start = d_off + d_hdr + FULLBOX_FLAGS_SIZE + LOCALE_SIZE
+      bytes = data[value_start, (d_off + d_size) - value_start] || ''
+      decode_value(bytes, type_flag)
+    end
+
+    #: (String bytes, Integer type_flag) -> Integer?
+    def self.decode_value(bytes, type_flag)
+      return bytes.to_i if type_flag == DATA_TYPE_UTF8
+
+      bytes.bytes.reduce(0) { |acc, byte| (acc << 8) | byte }
+    end
+
+    # Returns the byte range [start, finish) spanning the ilst children, or nil.
+    #: (String data) -> [Integer, Integer]?
+    def self.locate_ilst(data)
+      moov = find_box(data, 'moov', 0, data.bytesize)
+      return nil unless moov
+
+      udta = find_box(data, 'udta', moov[0] + moov[2], moov[0] + moov[1])
+      return nil unless udta
+
+      meta = find_box(data, 'meta', udta[0] + udta[2], udta[0] + udta[1])
+      return nil unless meta
+
+      meo, mes, meh = meta
+      children_start = meo + meh + meta_prefix_size(data[meo + meh, mes - meh] || '')
+      ilst = find_box(data, 'ilst', children_start, meo + mes)
+      return nil unless ilst
+
+      io, isz, ih = ilst
+      [io + ih, io + isz]
+    end
+
+    # --- writing -------------------------------------------------------------
+
+    # Rebuilds the moov atom with `tmpo` set to `bpm`, fixing up chunk offsets
+    # if moov precedes mdat. Returns the same object unchanged when there is no
+    # moov atom (not an MP4 we understand).
+    #: (String data, Integer bpm) -> String
+    def self.set_tmpo(data, bpm)
+      moov = find_box(data, 'moov', 0, data.bytesize)
+      return data unless moov
+
+      mo, ms, = moov
+      new_moov = rebuild_moov(data[mo, ms] || '', build_tmpo(bpm))
+      delta = new_moov.bytesize - ms
+
+      mdat = find_box(data, 'mdat', 0, data.bytesize)
+      new_moov = patch_chunk_offsets(new_moov, delta) if delta != 0 && mdat && mo < mdat[0]
+
+      "#{data[0, mo]}#{new_moov}#{data[(mo + ms)..]}"
+    end
+
+    #: (String moov, String tmpo_box) -> String
+    def self.rebuild_moov(moov, tmpo_box)
+      hdr = box_header_size(moov, 0)
+      payload = moov[hdr..] || ''
+
+      new_payload = update_container(payload, 'udta') do |udta|
+        update_container(udta, 'meta') do |meta|
+          prefix = meta_prefix(meta)
+          body = meta[prefix.bytesize..] || ''
+          prefix + update_container(body, 'ilst') { |ilst| set_tmpo_box(ilst, tmpo_box) }
+        end
+      end
+
+      box('moov', new_payload)
+    end
+
+    # Replaces the child of `type` in `payload` with the result of the block
+    # (called with the child's payload), or appends a new child if absent.
+    #: (String payload, String type) { (String) -> String } -> String
+    def self.update_container(payload, type)
+      found = find_box(payload, type, 0, payload.bytesize)
+      if found
+        off, size, hdr = found
+        new_child = yield(payload[off + hdr, size - hdr] || '')
+        "#{payload[0, off]}#{box(type, new_child)}#{payload[(off + size)..]}"
+      else
+        payload + box(type, yield(''))
+      end
+    end
+
+    #: (String ilst, String tmpo_box) -> String
+    def self.set_tmpo_box(ilst, tmpo_box)
+      found = find_box(ilst, 'tmpo', 0, ilst.bytesize)
+      return ilst + tmpo_box unless found
+
+      off, size, = found
+      "#{ilst[0, off]}#{tmpo_box}#{ilst[(off + size)..]}"
+    end
+
+    #: (Integer bpm) -> String
+    def self.build_tmpo(bpm)
+      value = [clamp_uint16(bpm)].pack(UINT16)
+      data_payload = [DATA_TYPE_INTEGER].pack(UINT32) + [0].pack(UINT32) + value
+      box('tmpo', box('data', data_payload))
+    end
+
+    # Adds `delta` to every stco/co64 chunk offset, so audio data references
+    # stay valid after moov grows ahead of mdat.
+    #: (String moov, Integer delta) -> String
+    def self.patch_chunk_offsets(moov, delta)
+      moov = moov.b
+      each_descendant(moov, 0, moov.bytesize, %w[moov trak mdia minf stbl]) do |type, off, _size, hdr|
+        next unless %w[stco co64].include?(type)
+
+        count = u32(moov, off + hdr + FULLBOX_FLAGS_SIZE)
+        base = off + hdr + FULLBOX_FLAGS_SIZE + 4
+        count.times do |i|
+          if type == 'stco'
+            pos = base + (i * 4)
+            moov[pos, 4] = [(u32(moov, pos) + delta) & 0xFFFFFFFF].pack(UINT32)
+          else
+            pos = base + (i * 8)
+            moov[pos, 8] = [u64(moov, pos) + delta].pack(UINT64)
+          end
+        end
+      end
+      moov
+    end
+
+    # --- atom helpers --------------------------------------------------------
+
+    #: (String type, String payload) -> String
+    def self.box(type, payload)
+      [HEADER_SIZE + payload.bytesize].pack(UINT32) + type + payload
+    end
+
+    # `meta` is a FullBox in MP4 (4-byte version/flags before its children) but
+    # a plain box in some QuickTime files. Detect which, and synthesize a valid
+    # FullBox header (with an `mdir` handler) when creating `meta` from scratch.
+    #: (String meta_payload) -> String
+    def self.meta_prefix(meta_payload)
+      return ZERO_FLAGS + hdlr_mdir_box if meta_payload.empty?
+      return '' if non_fullbox_meta?(meta_payload)
+
+      meta_payload[0, FULLBOX_FLAGS_SIZE] || ''
+    end
+
+    #: (String meta_payload) -> Integer
+    def self.meta_prefix_size(meta_payload)
+      meta_prefix(meta_payload).bytesize
+    end
+
+    # A plain (non-FullBox) meta starts with a child box, so a known child type
+    # ('hdlr') appears at the type offset of the first box.
+    #: (String meta_payload) -> bool
+    def self.non_fullbox_meta?(meta_payload)
+      meta_payload[TYPE_SIZE, TYPE_SIZE] == 'hdlr'
+    end
+
+    #: () -> String
+    def self.hdlr_mdir_box
+      payload = "#{ZERO_FLAGS}#{[0].pack(UINT32)}mdirappl#{[0].pack(UINT32) * 2}\u0000" # empty name, null-terminated
+      box('hdlr', payload)
+    end
+
+    # Returns [offset, size, header_size] of the first direct child of `type`
+    # within [start, finish), or nil.
+    #: (String data, String type, Integer start, Integer finish) -> [Integer, Integer, Integer]?
+    def self.find_box(data, type, start, finish)
+      result = nil #: [Integer, Integer, Integer]?
+      each_box(data, start, finish) do |t, off, size, hdr|
+        if t == type
+          result = [off, size, hdr]
+          break
+        end
+      end
+      result
+    end
+
+    #: (String data, Integer start, Integer finish) { (String, Integer, Integer, Integer) -> void } -> void
+    def self.each_box(data, start, finish)
+      pos = start
+      while pos + HEADER_SIZE <= finish
+        size = u32(data, pos)
+        hdr = HEADER_SIZE
+        if size == 1
+          size = u64(data, pos + HEADER_SIZE)
+          hdr = 16
+        elsif size.zero?
+          size = finish - pos
+        end
+        break if size < hdr || pos + size > finish
+
+        yield data[pos + 4, TYPE_SIZE] || '', pos, size, hdr
+        pos += size
+      end
+    end
+
+    #: (String data, Integer start, Integer finish, Array[String] containers) { (String, Integer, Integer, Integer) -> void } -> void
+    def self.each_descendant(data, start, finish, containers, &block)
+      each_box(data, start, finish) do |type, off, size, hdr|
+        block.call(type, off, size, hdr)
+        each_descendant(data, off + hdr, off + size, containers, &block) if containers.include?(type)
+      end
+    end
+
+    #: (String data, Integer offset) -> Integer
+    def self.box_header_size(data, offset)
+      u32(data, offset) == 1 ? 16 : HEADER_SIZE
+    end
+
+    #: (Integer value) -> Integer
+    def self.clamp_uint16(value)
+      value.clamp(0, 0xFFFF)
+    end
+
+    #: (String data, Integer offset) -> Integer
+    def self.u32(data, offset)
+      value = (data[offset, 4] || '').unpack1(UINT32)
+      value.is_a?(Integer) ? value : 0
+    end
+
+    #: (String data, Integer offset) -> Integer
+    def self.u64(data, offset)
+      value = (data[offset, 8] || '').unpack1(UINT64)
+      value.is_a?(Integer) ? value : 0
+    end
+  end
+end

data/lib/wavesync/path_resolver.rb

@@ -2,6 +2,7 @@
 # rbs_inline: enabled
 
 require 'pathname'
+require_relative 'transliterator'
 
 module Wavesync
   class PathResolver
@@ -25,6 +26,7 @@ module Wavesync
       target_path = add_bpm_to_filename(target_path, bpm) if @device.bpm_source == :filename && bpm
 
       target_path = strip_unsupported_characters(target_path)
+      target_path = transliterate_relative_path(target_path)
       uppercase_relative_path(target_path)
     end
 
@@ -60,6 +62,15 @@ module Wavesync
       Pathname(path.to_s.delete(@device.unsupported_characters.join))
     end
 
+    #: (Pathname path) -> Pathname
+    def transliterate_relative_path(path)
+      return path unless @device.transliterate_paths
+
+      relative = path.relative_path_from(@target_library_path)
+      transliterated = relative.each_filename.map { |filename| Transliterator.transliterate(filename) }.join('/')
+      @target_library_path.join(transliterated)
+    end
+
     #: (Pathname path) -> Pathname
     def uppercase_relative_path(path)
       return path unless @device.uppercase_paths

data/lib/wavesync/scanner.rb

@@ -20,6 +20,7 @@ module Wavesync
 
     #: (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)
+      Timing.reset
       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)
@@ -102,9 +103,9 @@ module Wavesync
       end
 
       puts
-      system('sync')
+      Timing.current.measure(:filesystem) { system('sync') }
       elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-      Logger.log_run_time(elapsed)
+      Logger.log_run_time(elapsed, timings: Timing.current.totals)
     end
 
     #: (String target_library_path, Device device) -> void
@@ -186,19 +187,19 @@ module Wavesync
       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?}]
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points, Integer? source_sample_rate, Integer? target_sample_rate) -> Array[{identifier: Integer, sample_offset: Integer, label: String?, note: 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?}
+        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?, note: String?}
       end
     end
 
     #: (String source, Pathname target) -> void
     def safe_copy(source, target)
-      FileUtils.install(source, target)
-    rescue Errno::ENOENT => e
+      Timing.current.measure(:copy) { FileUtils.install(source, target) }
+    rescue SystemCallError => e
       Logger.log_error(e, call_site: 'Scanner#safe_copy', arguments: { source:, target: })
     end
 

data/lib/wavesync/setlist_editor.rb

@@ -5,6 +5,7 @@ require 'tty-prompt'
 require 'io/console'
 require 'stringio'
 require_relative 'logger'
+require_relative 'cue_chunk'
 
 module Wavesync
   class SetlistEditor
@@ -87,26 +88,26 @@ module Wavesync
       end
     end
 
+    EMPTY_MARKERS = { cues: [], loops: [] }.freeze # steep:ignore UnannotatedEmptyCollection
+
     #: (String? path) -> Array[Float]
     def track_cue_fractions(path)
-      return [] if path.nil?
+      track_markers(path)[:cues]
+    end
 
-      @track_cue_fractions ||= {} #: Hash[String, Array[Float]]
-      return @track_cue_fractions[path] if @track_cue_fractions.key?(path)
+    #: (String? path) -> Array[{start_fraction: Float, end_fraction: Float}]
+    def track_loop_fractions(path)
+      track_markers(path)[:loops]
+    end
 
-      @track_cue_fractions[path] = begin
-        audio = Audio.new(path)
-        sample_rate = audio.sample_rate
-        duration = audio.duration
-        if sample_rate && duration&.positive?
-          audio.cue_points.map { |cue_point| cue_point[:sample_offset].to_f / sample_rate / duration }
-        else
-          [] #: Array[Float]
-        end
-      rescue StandardError => e
-        Logger.log_error(e, call_site: 'SetlistEditor#track_cue_fractions', arguments: { path: })
-        [] #: Array[Float]
-      end
+    #: (String? path) -> {cues: Array[Float], loops: Array[{start_fraction: Float, end_fraction: Float}]}
+    def track_markers(path)
+      return EMPTY_MARKERS if path.nil?
+
+      @track_markers ||= {} #: Hash[String, {cues: Array[Float], loops: Array[{start_fraction: Float, end_fraction: Float}]}]
+      return @track_markers[path] if @track_markers.key?(path)
+
+      @track_markers[path] = compute_track_markers(path)
     end
 
     #: ((String | Integer)? source_bpm, (String | Integer)? target_bpm) -> Float?
@@ -128,6 +129,29 @@ module Wavesync
 
     private
 
+    #: (String path) -> {cues: Array[Float], loops: Array[{start_fraction: Float, end_fraction: Float}]}
+    def compute_track_markers(path)
+      audio = Audio.new(path)
+      sample_rate = audio.sample_rate
+      duration = audio.duration
+      return EMPTY_MARKERS unless sample_rate && duration&.positive?
+
+      cue_points = audio.cue_points
+      divisor = sample_rate.to_f * duration
+
+      cues = cue_points.reject { |cue_point| CueChunk.loop_marker?(cue_point) }
+                       .map { |cue_point| cue_point[:sample_offset].to_f / divisor }
+
+      loops = CueChunk.loops(cue_points).map do |loop_range|
+        loop_hash = { start_fraction: loop_range[:start_sample].to_f / divisor, end_fraction: loop_range[:end_sample].to_f / divisor }
+        loop_hash #: {start_fraction: Float, end_fraction: Float}
+      end
+      { cues: cues, loops: loops }
+    rescue StandardError => e
+      Logger.log_error(e, call_site: 'SetlistEditor#track_cue_fractions', arguments: { path: })
+      EMPTY_MARKERS
+    end
+
     #: () -> void
     def enter_fullscreen
       print "\e[?1049h" # enter alternate screen buffer
@@ -212,30 +236,44 @@ module Wavesync
       string.gsub(/\e\[[0-9;]*[A-Za-z]/, '').length
     end
 
-    #: (Float elapsed, Float total_duration, Integer bar_width, ?cue_fractions: Array[Float]) -> String
-    def playback_bar(elapsed, total_duration, bar_width, cue_fractions: [])
+    #: (Float elapsed, Float total_duration, Integer bar_width, ?cue_fractions: Array[Float], ?loop_fractions: Array[{start_fraction: Float, end_fraction: Float}]) -> String
+    def playback_bar(elapsed, total_duration, bar_width, cue_fractions: [], loop_fractions: [])
       ratio = total_duration.positive? ? [elapsed / total_duration, 1.0].min : 0.0
       filled = (ratio * bar_width).round
 
       bar = Array.new(bar_width) { |i| i < filled ? '█' : '░' }
+      cell_colors = Array.new(bar_width, :surface) #: Array[Symbol]
+      marker_positions = {} #: Hash[Integer, bool]
+
+      loop_fractions.each do |loop_range|
+        loop_start_position = (loop_range[:start_fraction] * (bar_width - 1)).round.clamp(0, bar_width - 1)
+        loop_end_position = (loop_range[:end_fraction] * (bar_width - 1)).round.clamp(0, bar_width - 1)
+        next if loop_end_position <= loop_start_position
+
+        (loop_start_position..loop_end_position).each { |position| cell_colors[position] = :extra }
+        bar[loop_start_position] = '⟨'
+        bar[loop_end_position] = '⟩'
+        marker_positions[loop_start_position] = true
+        marker_positions[loop_end_position] = true
+      end
 
-      cue_position_colors = {} #: Hash[Integer, Symbol]
       cue_fractions.each do |fraction|
         position = (fraction * (bar_width - 1)).round.clamp(0, bar_width - 1)
-        cue_position_colors[position] = position == filled ? :highlight : :surface
+        bar[position] = '◆'
+        cell_colors[position] = position == filled ? :highlight : :surface
+        marker_positions[position] = true
       end
-      cue_position_colors.each_key { |position| bar[position] = '◆' }
 
       result = +''
       run_start = 0
       while run_start < bar_width
-        if cue_position_colors.key?(run_start)
-          result << @ui.color(bar[run_start], cue_position_colors[run_start])
+        if marker_positions[run_start]
+          result << @ui.color(bar[run_start], cell_colors[run_start])
           run_start += 1
         else
-          run_end = run_start
-          run_end += 1 while run_end < bar_width && !cue_position_colors.key?(run_end)
-          result << @ui.color((bar[run_start...run_end] || []).join, :surface)
+          run_end = run_start + 1
+          run_end += 1 while run_end < bar_width && !marker_positions[run_end] && cell_colors[run_end] == cell_colors[run_start]
+          result << @ui.color((bar[run_start...run_end] || []).join, cell_colors[run_start])
           run_start = run_end
         end
       end
@@ -289,7 +327,8 @@ module Wavesync
           pitch_shift = pitch_shift_semitones(current_bpm, track_bpm(@setlist.tracks[i + 1]))
           render_track(i, relative_path(track), i == @selected, i == @player_index,
                        bpm: current_bpm, pitch_shift: pitch_shift, duration: current_duration,
-                       duration_col_width: duration_col_width, cue_fractions: track_cue_fractions(track))
+                       duration_col_width: duration_col_width, cue_fractions: track_cue_fractions(track),
+                       loop_fractions: track_loop_fractions(track))
         end
       end
 
@@ -301,8 +340,8 @@ module Wavesync
       flush_render(buffer)
     end
 
-    #: (Integer index, String relative, bool selected, bool playing, ?bpm: (String | Integer)?, ?pitch_shift: Float?, ?duration: Float?, ?duration_col_width: Integer, ?cue_fractions: Array[Float]) -> void
-    def render_track(index, relative, selected, playing, bpm: nil, pitch_shift: nil, duration: nil, duration_col_width: 0, cue_fractions: [])
+    #: (Integer index, String relative, bool selected, bool playing, ?bpm: (String | Integer)?, ?pitch_shift: Float?, ?duration: Float?, ?duration_col_width: Integer, ?cue_fractions: Array[Float], ?loop_fractions: Array[{start_fraction: Float, end_fraction: Float}]) -> void
+    def render_track(index, relative, selected, playing, bpm: nil, pitch_shift: nil, duration: nil, duration_col_width: 0, cue_fractions: [], loop_fractions: [])
       name = display_name(relative)
       folder = File.dirname(relative)
       icon = if playing
@@ -350,7 +389,7 @@ module Wavesync
 
       if playing && @player_state != :stopped && duration
         bar_width = [terminal_width - 5, 20].max
-        puts "     #{playback_bar(playback_elapsed, duration, bar_width, cue_fractions: cue_fractions)}"
+        puts "     #{playback_bar(playback_elapsed, duration, bar_width, cue_fractions: cue_fractions, loop_fractions: loop_fractions)}"
       end
 
       return unless pitch_shift

data/lib/wavesync/timing.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wavesync
+  class Timing
+    BUCKETS = %i[transcode probe ffmpeg_metadata copy wav_chunks mp4_chunks filesystem].freeze
+
+    #: () -> Timing
+    def self.current
+      @current ||= new
+    end
+
+    #: () -> void
+    def self.reset
+      @current = new
+    end
+
+    #: () -> void
+    def initialize
+      @totals = Hash.new(0.0) #: Hash[Symbol, Float]
+    end
+
+    #: (Symbol bucket) { () -> untyped } -> untyped
+    def measure(bucket)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      yield
+    ensure
+      @totals[bucket] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+    end
+
+    #: () -> Hash[Symbol, Float]
+    def totals
+      @totals.dup
+    end
+  end
+end

data/lib/wavesync/transliterator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wavesync
+  module Transliterator
+    COMBINING_MARKS = /\p{Mn}/
+
+    #: (String string) -> String
+    def self.transliterate(string)
+      string
+        .unicode_normalize(:nfd)
+        .gsub(COMBINING_MARKS, '')
+    end
+  end
+end

data/lib/wavesync/transport/mtp.rb

@@ -40,8 +40,8 @@ module Wavesync
         FileUtils.mkdir_p(@working_directory)
       end
 
-      #: () ?{ (Integer, Integer, String) -> void } -> void
-      def prepare!(&progress)
+      #: (?stop_when: ^() -> bool) ?{ (Integer, Integer, String) -> void } -> void
+      def prepare!(stop_when: nil, &progress)
         device_files = @libmtp.files
         folder_paths = build_folder_paths(@libmtp.folders)
 
@@ -57,6 +57,8 @@ module Wavesync
 
         Dir.mktmpdir('wavesync_mtp_pull') do |tmpdir|
           candidates.each_with_index do |candidate, index|
+            break if stop_when&.call
+
             progress&.call(index, candidates.size, candidate[:relative_path])
             pull_if_cues_differ(candidate, tmpdir)
           end
@@ -271,14 +273,18 @@ module Wavesync
         local_path = candidate[:local_path]
         tmp_path = File.join(tmpdir, "#{device_file.id}.wav")
 
-        @libmtp.get_file(id: device_file.id, local_path: tmp_path)
+        begin
+          @libmtp.get_file(id: device_file.id, local_path: tmp_path)
 
-        device_cues = CueChunk.read(tmp_path)
-        local_cues = File.exist?(local_path) ? CueChunk.read(local_path) : [] #: Array[{identifier: Integer, sample_offset: Integer, label: String?}]
-        return if CueChunk.same?(device_cues, local_cues)
+          device_cues = CueChunk.read(tmp_path)
+          local_cues = File.exist?(local_path) ? CueChunk.read(local_path) : [] #: Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}]
+          return if CueChunk.same?(device_cues, local_cues)
 
-        FileUtils.mkdir_p(File.dirname(local_path))
-        FileUtils.mv(tmp_path, local_path)
+          FileUtils.mkdir_p(File.dirname(local_path))
+          FileUtils.mv(tmp_path, local_path)
+        ensure
+          FileUtils.rm_f(tmp_path)
+        end
       end
     end
   end

data/lib/wavesync/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Wavesync
-  VERSION = '1.0.0.beta1'
+  VERSION = '1.0.0.beta2'
 end

data/lib/wavesync.rb

@@ -4,9 +4,11 @@ module Wavesync
 end
 
 require 'wavesync/logger'
+require 'wavesync/timing'
 require 'wavesync/version'
 require 'wavesync/acid_chunk'
 require 'wavesync/cue_chunk'
+require 'wavesync/mp4_tmpo'
 require 'wavesync/audio_format'
 require 'wavesync/ffmpeg'
 require 'wavesync/audio'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wavesync
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta1
+  version: 1.0.0.beta2
 platform: ruby
 authors:
 - Andreas Zecher
@@ -98,13 +98,16 @@ files:
 - lib/wavesync/file_converter.rb
 - lib/wavesync/libmtp.rb
 - lib/wavesync/logger.rb
+- lib/wavesync/mp4_tmpo.rb
 - lib/wavesync/path_resolver.rb
 - lib/wavesync/percival_bpm_detector.rb
 - lib/wavesync/python_venv.rb
 - lib/wavesync/scanner.rb
 - lib/wavesync/setlist.rb
 - lib/wavesync/setlist_editor.rb
+- lib/wavesync/timing.rb
 - lib/wavesync/track_padding.rb
+- lib/wavesync/transliterator.rb
 - lib/wavesync/transport.rb
 - lib/wavesync/transport/filesystem.rb
 - lib/wavesync/transport/mtp.rb