wavesync 1.0.0.beta1 → 1.0.0.beta2

data/lib/wavesync/cue_chunk.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
+require_relative 'timing'
+
 module Wavesync
   class CueChunk
     RIFF_HEADER_SIZE = 12
@@ -10,122 +12,157 @@ module Wavesync
     LIST_CHUNK_ID = 'LIST'
     ADTL_LIST_TYPE = 'adtl'
     LABL_CHUNK_ID = 'labl'
+    NOTE_CHUNK_ID = 'note'
     DATA_CHUNK_ID = 'data'
     CUE_HEADER_SIZE = 4
     BYTES_PER_CUE_POINT = 24
 
+    LOOP_START_NOTE = 'start'
+    LOOP_END_NOTE = 'end'
+
     UINT32_LE = 'V'
 
-    #: (String filepath) -> Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+    #: (String filepath) -> Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}]
     def self.read(filepath)
-      cue_points = [] #: Array[{identifier: Integer, sample_offset: Integer, label: String?}]
-      labels = {} #: Hash[Integer, String]
+      Timing.current.measure(:wav_chunks) do
+        cue_points = [] #: Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}]
+        labels = {} #: Hash[Integer, String]
+        notes = {} #: Hash[Integer, String]
 
-      File.open(filepath, 'rb') do |file|
-        file.seek(RIFF_HEADER_SIZE)
+        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
+          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)
-          break if chunk_size_bytes.nil?
+            chunk_size_bytes = file.read(CHUNK_SIZE_FIELD_SIZE)
+            break if chunk_size_bytes.nil?
 
-          chunk_size = chunk_size_bytes.unpack1(UINT32_LE).to_i
-          chunk_data_start = file.tell
+            chunk_size = chunk_size_bytes.unpack1(UINT32_LE).to_i
+            chunk_data_start = file.tell
 
-          if chunk_id == CUE_CHUNK_ID
-            num_cues = file.read(4)&.unpack1(UINT32_LE).to_i
-            num_cues.times do
-              identifier = file.read(4)&.unpack1(UINT32_LE)&.to_i
-              file.read(16) # skip position, fcc_chunk, chunk_start, block_start
-              sample_offset = file.read(4)&.unpack1(UINT32_LE)&.to_i
-              cue_points << { identifier: identifier, sample_offset: sample_offset, label: nil } if identifier && sample_offset
+            if chunk_id == CUE_CHUNK_ID
+              num_cues = file.read(4)&.unpack1(UINT32_LE).to_i
+              num_cues.times do
+                identifier = file.read(4)&.unpack1(UINT32_LE)&.to_i
+                file.read(16) # skip position, fcc_chunk, chunk_start, block_start
+                sample_offset = file.read(4)&.unpack1(UINT32_LE)&.to_i
+                cue_points << { identifier: identifier, sample_offset: sample_offset, label: nil, note: nil } if identifier && sample_offset
+              end
+            elsif chunk_id == LIST_CHUNK_ID && chunk_size >= 4
+              list_type = file.read(4)
+              read_adtl_entries(file, chunk_data_start + chunk_size, labels, notes) if list_type == ADTL_LIST_TYPE
             end
-          elsif chunk_id == LIST_CHUNK_ID && chunk_size >= 4
-            list_type = file.read(4)
-            read_adtl_labels(file, chunk_data_start + chunk_size, labels) if list_type == ADTL_LIST_TYPE
+
+            chunk_padding = chunk_size.odd? ? 1 : 0
+            file.seek(chunk_data_start + chunk_size + chunk_padding)
           end
+        end
 
-          chunk_padding = chunk_size.odd? ? 1 : 0
-          file.seek(chunk_data_start + chunk_size + chunk_padding)
+        cue_points.map do |cue_point|
+          {
+            identifier: cue_point[:identifier],
+            sample_offset: cue_point[:sample_offset],
+            label: labels[cue_point[:identifier]],
+            note: notes[cue_point[:identifier]]
+          }
         end
       end
-
-      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
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points_a, Array[{identifier: Integer, sample_offset: Integer, label: String?, note: 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?}]
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points) -> Array[{sample_offset: Integer, label: String?, note: 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 = cue_points.map { |cp| { sample_offset: cp[:sample_offset], label: cp[:label], note: cp[:note] } } #: Array[{sample_offset: Integer, label: String?, note: 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
+    #: ({identifier: Integer, sample_offset: Integer, label: String?, note: String?} cue_point) -> bool
+    def self.loop_marker?(cue_point)
+      note = cue_point[:note]
+      return false if note.nil?
 
-      update_riff_size(filepath)
+      [LOOP_START_NOTE, LOOP_END_NOTE].include?(note)
     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|
-        File.open(output_filepath, 'wb') do |output|
-          output.write(input.read(RIFF_HEADER_SIZE))
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points) -> Array[{start_sample: Integer, end_sample: Integer}]
+    def self.loops(cue_points)
+      starts = cue_points.select { |cue_point| cue_point[:note] == LOOP_START_NOTE }.sort_by { |cue_point| cue_point[:sample_offset] }
+      ends = cue_points.select { |cue_point| cue_point[:note] == LOOP_END_NOTE }.sort_by { |cue_point| cue_point[:sample_offset] }
+      starts.zip(ends).filter_map do |loop_start, loop_end|
+        next nil unless loop_start && loop_end && loop_end[:sample_offset] > loop_start[:sample_offset]
 
-          until input.eof?
-            chunk_id = input.read(CHUNK_ID_SIZE)
-            break if chunk_id.nil? || chunk_id.length < CHUNK_ID_SIZE
+        { start_sample: loop_start[:sample_offset], end_sample: loop_end[:sample_offset] }
+      end
+    end
 
-            chunk_size_bytes = input.read(CHUNK_SIZE_FIELD_SIZE)
-            break if chunk_size_bytes.nil?
+    #: (String filepath, Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points) -> void
+    def self.append_to_file(filepath, cue_points)
+      return if cue_points.empty?
 
-            chunk_size = chunk_size_bytes.unpack1(UINT32_LE).to_i
-            chunk_padding = chunk_size.odd? ? 1 : 0
+      Timing.current.measure(:wav_chunks) do
+        File.open(filepath, 'ab') do |file|
+          write_cue_chunk(file, cue_points)
+          write_adtl_chunk(file, cue_points) if cue_points.any? { |cue_point| cue_point[:label] || cue_point[:note] }
+        end
 
-            if chunk_id == CUE_CHUNK_ID
-              input.read(chunk_size + chunk_padding)
-            elsif chunk_id == LIST_CHUNK_ID && chunk_size >= 4
-              list_type = input.read(4)
-              if list_type == ADTL_LIST_TYPE
-                input.read(chunk_size - 4 + chunk_padding)
+        update_riff_size(filepath)
+      end
+    end
+
+    #: (String source_filepath, String output_filepath, Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points) -> void
+    def self.write(source_filepath, output_filepath, cue_points)
+      Timing.current.measure(:wav_chunks) do
+        File.open(source_filepath, 'rb') do |input|
+          File.open(output_filepath, 'wb') do |output|
+            output.write(input.read(RIFF_HEADER_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)
+              break if chunk_size_bytes.nil?
+
+              chunk_size = chunk_size_bytes.unpack1(UINT32_LE).to_i
+              chunk_padding = chunk_size.odd? ? 1 : 0
+
+              if chunk_id == CUE_CHUNK_ID
+                input.read(chunk_size + chunk_padding)
+              elsif chunk_id == LIST_CHUNK_ID && chunk_size >= 4
+                list_type = input.read(4)
+                if list_type == ADTL_LIST_TYPE
+                  input.read(chunk_size - 4 + chunk_padding)
+                else
+                  output.write(chunk_id)
+                  output.write(chunk_size_bytes)
+                  output.write(list_type)
+                  output.write(input.read(chunk_size - 4 + chunk_padding))
+                end
               else
                 output.write(chunk_id)
                 output.write(chunk_size_bytes)
-                output.write(list_type)
-                output.write(input.read(chunk_size - 4 + chunk_padding))
+                output.write(input.read(chunk_size + chunk_padding))
               end
-            else
-              output.write(chunk_id)
-              output.write(chunk_size_bytes)
-              output.write(input.read(chunk_size + chunk_padding))
             end
-          end
 
-          unless cue_points.empty?
-            write_cue_chunk(output, cue_points)
-            labeled_cue_points = cue_points.select { |cue_point| cue_point[:label] }
-            write_adtl_chunk(output, labeled_cue_points) if labeled_cue_points.any?
+            unless cue_points.empty?
+              write_cue_chunk(output, cue_points)
+              write_adtl_chunk(output, cue_points) if cue_points.any? { |cue_point| cue_point[:label] || cue_point[:note] }
+            end
           end
         end
-      end
 
-      update_riff_size(output_filepath)
+        update_riff_size(output_filepath)
+      end
     end
 
-    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points) -> void
     def self.write_cue_chunk(output, cue_points)
       chunk_size = CUE_HEADER_SIZE + (cue_points.size * BYTES_PER_CUE_POINT)
       output.write(CUE_CHUNK_ID)
@@ -142,22 +179,21 @@ module Wavesync
       end
     end
 
-    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: String?, note: String?}] cue_points) -> void
     def self.write_adtl_chunk(output, cue_points)
-      labl_entries = cue_points.map do |cue_point|
-        text = "#{cue_point[:label]}\x00"
-        data_size = 4 + text.length
-        pad = data_size.odd? ? 1 : 0
-        { identifier: cue_point[:identifier], text: text, data_size: data_size, pad: pad }
-      end #: Array[{identifier: Integer, text: String, data_size: Integer, pad: Integer}]
-
-      adtl_data_size = 4 + labl_entries.sum { |entry| 8 + entry[:data_size] + entry[:pad] }
+      entries = [] #: Array[{sub_id: String, identifier: Integer, text: String, data_size: Integer, pad: Integer}]
+      cue_points.each do |cue_point|
+        entries << build_adtl_entry(LABL_CHUNK_ID, cue_point[:identifier], cue_point[:label]) if cue_point[:label]
+        entries << build_adtl_entry(NOTE_CHUNK_ID, cue_point[:identifier], cue_point[:note]) if cue_point[:note]
+      end
+
+      adtl_data_size = 4 + entries.sum { |entry| 8 + entry[:data_size] + entry[:pad] }
       output.write(LIST_CHUNK_ID)
       output.write([adtl_data_size].pack(UINT32_LE))
       output.write(ADTL_LIST_TYPE)
 
-      labl_entries.each do |entry|
-        output.write(LABL_CHUNK_ID)
+      entries.each do |entry|
+        output.write(entry[:sub_id])
         output.write([entry[:data_size]].pack(UINT32_LE))
         output.write([entry[:identifier]].pack(UINT32_LE))
         output.write(entry[:text])
@@ -165,8 +201,16 @@ module Wavesync
       end
     end
 
-    #: (untyped file, Integer list_end, Hash[Integer, String] labels) -> void
-    def self.read_adtl_labels(file, list_end, labels)
+    #: (String sub_id, Integer identifier, String text_content) -> {sub_id: String, identifier: Integer, text: String, data_size: Integer, pad: Integer}
+    def self.build_adtl_entry(sub_id, identifier, text_content)
+      text = "#{text_content}\x00"
+      data_size = 4 + text.length
+      pad = data_size.odd? ? 1 : 0
+      { sub_id: sub_id, identifier: identifier, text: text, data_size: data_size, pad: pad }
+    end
+
+    #: (untyped file, Integer list_end, Hash[Integer, String] labels, Hash[Integer, String] notes) -> void
+    def self.read_adtl_entries(file, list_end, labels, notes)
       while file.tell < list_end - 8
         sub_id = file.read(CHUNK_ID_SIZE)
         break if sub_id.nil? || sub_id.length < CHUNK_ID_SIZE
@@ -177,11 +221,12 @@ module Wavesync
         sub_size = sub_size_bytes.unpack1(UINT32_LE).to_i
         sub_data_start = file.tell
 
-        if sub_id == LABL_CHUNK_ID && sub_size >= 4
+        if [LABL_CHUNK_ID, NOTE_CHUNK_ID].include?(sub_id) && sub_size >= 4
           identifier = file.read(4)&.unpack1(UINT32_LE)&.to_i
           text_size = sub_size - 4
           text = text_size.positive? ? (file.read(text_size) || '') : ''
-          labels[identifier] = text.delete("\x00") if identifier
+          target = sub_id == LABL_CHUNK_ID ? labels : notes
+          target[identifier] = text.delete("\x00") if identifier
         end
 
         sub_padding = sub_size.odd? ? 1 : 0

data/lib/wavesync/device.rb

@@ -12,10 +12,11 @@ module Wavesync
     attr_reader :bar_multiple #: Integer?
     attr_reader :unsupported_characters #: Array[String]
     attr_reader :transliterate_metadata #: bool
+    attr_reader :transliterate_paths #: bool
     attr_reader :uppercase_paths #: bool
 
-    #: (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: 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, ?transliterate_paths: 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, transliterate_paths: false, uppercase_paths: false)
       @name = name
       @sample_rates = sample_rates
       @bit_depths = bit_depths
@@ -24,6 +25,7 @@ module Wavesync
       @bar_multiple = bar_multiple
       @unsupported_characters = unsupported_characters
       @transliterate_metadata = transliterate_metadata
+      @transliterate_paths = transliterate_paths
       @uppercase_paths = uppercase_paths
     end
 
@@ -55,6 +57,7 @@ module Wavesync
           bar_multiple: attrs['bar_multiple'],
           unsupported_characters: attrs['unsupported_characters'] || [],
           transliterate_metadata: attrs['transliterate_metadata'] || false,
+          transliterate_paths: attrs['transliterate_paths'] || false,
           uppercase_paths: attrs['uppercase_paths'] || false
         )
       end

data/lib/wavesync/essentia_bpm_detector.rb

@@ -15,6 +15,16 @@ module Wavesync
       loader.audio >> rhythm.signal
       rhythm.bpm >> (pool, 'bpm')
       rhythm.confidence >> (pool, 'confidence')
+      rhythm.beats_position >> None
+      rhythm.bpm_estimates >> None
+      rhythm.bpm_intervals >> None
+      rhythm.first_peak_bpm >> None
+      rhythm.first_peak_spread >> None
+      rhythm.first_peak_weight >> None
+      rhythm.second_peak_bpm >> None
+      rhythm.second_peak_spread >> None
+      rhythm.second_peak_weight >> None
+      rhythm.histogram >> None
       essentia.run(loader)
       print(json.dumps({'bpm': round(float(pool['bpm'])), 'confidence': round(float(pool['confidence']), 2)}))
     PYTHON

data/lib/wavesync/ffmpeg/probe.rb

@@ -3,6 +3,7 @@
 
 require 'open3'
 require 'json'
+require_relative '../timing'
 
 module Wavesync
   class FFMPEG
@@ -52,10 +53,13 @@ module Wavesync
       #: () -> 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
-        )
+        stdout = Timing.current.measure(:probe) do
+          out, _stderr, _status = Open3.capture3(
+            ffprobe, '-v', 'quiet', '-print_format', 'json',
+            '-show_streams', '-show_format', @file_path
+          )
+          out
+        end
         JSON.parse(stdout)
       end
 

data/lib/wavesync/logger.rb

@@ -49,12 +49,13 @@ module Wavesync
       File.open(path, 'a') { |file| file.write(entry) }
     end
 
-    #: (Float seconds) -> void
-    def self.log_run_time(seconds)
+    #: (Float seconds, ?timings: Hash[Symbol, Float]) -> void
+    def self.log_run_time(seconds, timings: {})
       path = log_path
       return unless path
 
       entry = "[#{timestamp}] Run time: #{format_duration(seconds)}\n"
+      entry += format_timings(seconds, timings) unless timings.empty?
       File.open(path, 'a') { |file| file.write(entry) }
     end
 
@@ -80,5 +81,18 @@ module Wavesync
       end
     end
     private_class_method :format_duration
+
+    #: (Float total_seconds, Hash[Symbol, Float] timings) -> String
+    def self.format_timings(total_seconds, timings)
+      tracked = timings.values.sum
+      other = [total_seconds - tracked, 0.0].max
+      rows = timings.merge(other: other).select { |_, value| value.positive? }
+      label_width = rows.keys.map { |key| key.to_s.length }.max || 0
+      rows.map do |bucket, seconds|
+        percentage = total_seconds.positive? ? (seconds / total_seconds * 100) : 0.0
+        format("  %-#{label_width}s  %6.1fs  %5.1f%%\n", bucket, seconds, percentage)
+      end.join
+    end
+    private_class_method :format_timings
   end
 end