wavesync 1.0.0.alpha1 → 1.0.0.alpha3

data/lib/wavesync/cli.rb

@@ -1,159 +1,22 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
-require 'optparse'
+require_relative 'commands'
 
 module Wavesync
   class CLI
+    #: () -> void
     def self.start
-      command = ARGV.first && !ARGV.first.start_with?('-') ? ARGV.shift : 'sync'
+      command_name = ARGV.first && !ARGV.first.start_with?('-') ? ARGV.shift : 'sync'
+      command_class = Commands::ALL.find { |cmd| command_name == cmd.name }
 
-      case command
-      when 'sync'
-        start_sync
-      when 'analyze'
-        start_analyze
-      when 'set'
-        start_set
+      if command_class
+        command_class.new.run
       else
-        puts "Unknown command: #{command}"
-        puts 'Available commands: sync, analyze, set'
+        puts "Unknown command: #{command_name}"
+        puts "Available commands: #{Commands::ALL.map(&:name).join(', ')}"
         exit 1
       end
     end
-
-    def self.start_sync
-      options = {}
-      parser = OptionParser.new do |opts|
-        opts.banner = 'Usage: wavesync sync [options]'
-
-        opts.on('-d', '--device NAME', 'Name of device to sync (as defined in config)') do |value|
-          options[:device] = value
-        end
-
-        opts.on('-c', '--config PATH', 'Path to wavesync config YAML file') do |value|
-          options[:config] = value
-        end
-
-        opts.on('-p', '--pad', 'Pad tracks with silence so total length is a multiple of 64 bars (Octatrack only)') do
-          options[:pad] = true
-        end
-      end
-
-      parser.parse!
-
-      config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
-      config = load_config(config_path)
-
-      device_configs = config.device_configs
-      if options[:device]
-        device_configs = device_configs.select { |device_config| device_config[:name] == options[:device] }
-        if device_configs.empty?
-          known = config.device_configs.map { |device_config| device_config[:name] }.join(', ')
-          puts "Unknown device \"#{options[:device]}\". Devices in config: #{known}"
-          exit 1
-        end
-      end
-
-      device_configs.each do |device_config|
-        next if Wavesync::Device.find_by(name: device_config[:model])
-
-        supported = Wavesync::Device.all.map(&:name).join(', ')
-        puts "Unknown device model \"#{device_config[:model]}\" in config. Supported models: #{supported}"
-        exit 1
-      end
-
-      scanner = Wavesync::Scanner.new(config.library)
-
-      device_configs.each do |device_config|
-        scanner.sync(device_config[:path], Wavesync::Device.find_by(name: device_config[:model]),
-                     pad: options[:pad] || false)
-      end
-    end
-
-    def self.start_set
-      subcommand = ARGV.shift
-
-      options = {}
-      parser = OptionParser.new do |opts|
-        opts.banner = 'Usage: wavesync set <subcommand> [options]'
-
-        opts.on('-c', '--config PATH', 'Path to wavesync config YAML file') do |value|
-          options[:config] = value
-        end
-      end
-
-      parser.parse!
-
-      config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
-      config = load_config(config_path)
-
-      case subcommand
-      when 'create'
-        name = require_set_name('create')
-        if Wavesync::Set.exists?(config.library, name)
-          puts "Set '#{name}' already exists. Use 'wavesync set edit #{name}' to edit it."
-          exit 1
-        end
-        set = Wavesync::Set.new(config.library, name)
-        Wavesync::SetEditor.new(set, config.library).run
-      when 'edit'
-        name = require_set_name('edit')
-        unless Wavesync::Set.exists?(config.library, name)
-          puts "Set '#{name}' not found. Use 'wavesync set create #{name}' to create it."
-          exit 1
-        end
-        set = Wavesync::Set.load(config.library, name)
-        Wavesync::SetEditor.new(set, config.library).run
-      when 'list'
-        sets = Wavesync::Set.all(config.library)
-        if sets.empty?
-          puts 'No sets found.'
-        else
-          sets.each { |s| puts "#{s.name} (#{s.tracks.size} tracks)" }
-        end
-      else
-        puts "Unknown subcommand: #{subcommand || '(none)'}"
-        puts 'Available subcommands: create, edit, list'
-        exit 1
-      end
-    end
-
-    def self.load_config(path)
-      Wavesync::Config.load(path)
-    rescue Wavesync::ConfigError => e
-      puts "Configuration error: #{e.message}"
-      exit 1
-    end
-
-    def self.require_set_name(subcommand)
-      name = ARGV.shift
-      unless name
-        puts "Usage: wavesync set #{subcommand} <name>"
-        exit 1
-      end
-      name
-    end
-
-    def self.start_analyze
-      options = {}
-      parser = OptionParser.new do |opts|
-        opts.banner = 'Usage: wavesync analyze [options]'
-
-        opts.on('-c', '--config PATH', 'Path to wavesync config YAML file') do |value|
-          options[:config] = value
-        end
-
-        opts.on('-f', '--force', 'Overwrite existing BPM values') do
-          options[:overwrite] = true
-        end
-      end
-
-      parser.parse!
-
-      config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
-      config = load_config(config_path)
-
-      Wavesync::Analyzer.new(config.library).analyze(overwrite: options[:overwrite] || false)
-    end
   end
 end

data/lib/wavesync/commands/analyze.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Analyze < Command
+      FORCE_OPTION = Option.new(short: '-f', long: '--force', description: 'Overwrite existing BPM values')
+
+      self.name = 'analyze'
+      self.description = 'Detect and write BPM metadata to library tracks'
+      self.options = [FORCE_OPTION].freeze
+
+      #: () -> void
+      def run
+        options, config = parse_options(banner: 'Usage: wavesync analyze [options]') 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)
+      end
+    end
+  end
+end

data/lib/wavesync/commands/command.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Command
+      class << self
+        attr_accessor :name, :description
+        attr_writer :options, :subcommands
+
+        def options = @options || []
+        def subcommands = @subcommands || []
+      end
+
+      #: (banner: String) ?{ (OptionParser, Hash[Symbol, untyped]) -> void } -> [Hash[Symbol, untyped], Config]
+      def parse_options(banner:)
+        options = {} #: Hash[Symbol, untyped]
+        OptionParser.new do |opts|
+          opts.banner = banner
+          opts.on(*CONFIG_OPTION.to_a) { |value| options[:config] = value }
+          yield opts, options if block_given?
+        end.parse!
+        config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
+        config = Commands.load_config(config_path)
+        [options, config]
+      end
+    end
+  end
+end

data/lib/wavesync/commands/help.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+require 'rainbow'
+
+module Wavesync
+  module Commands
+    class Help < Command
+      self.name = 'help'
+      self.description = 'Show this help message'
+
+      DESCRIPTION_COLUMN = 23
+
+      #: () -> void
+      def run
+        subcommand_name = ARGV.shift
+
+        if subcommand_name
+          command = ALL.find { |cmd| subcommand_name == cmd.name }
+          if command
+            show_command_help(command)
+          else
+            puts "Unknown command: #{subcommand_name}"
+            puts "Available commands: #{ALL.map(&:name).reject { |cmd_name| cmd_name == self.class.name }.join(', ')}"
+            exit 1
+          end
+        else
+          show_general_help
+        end
+      end
+
+      private
+
+      #: () -> void
+      def show_general_help
+        puts 'Usage: wavesync [command] [options]'
+        puts ''
+        puts 'Commands:'
+        ALL.each do |command|
+          if command.subcommands.any?
+            command.subcommands.each { |subcommand| puts format_command_line(subcommand.usage, subcommand.description) }
+          else
+            puts format_command_line(command.name, command.description)
+            command.options.each { |option| puts format_option_line(option, indent: 4) }
+          end
+          puts ''
+        end
+        puts 'Options:'
+        GLOBAL_OPTIONS.each { |option| puts format_option_line(option, indent: 2) }
+      end
+
+      #: (untyped command) -> void
+      def show_command_help(command)
+        if command.subcommands.any?
+          puts "Usage: wavesync #{command.name} <subcommand> [options]"
+          puts ''
+          puts 'Subcommands:'
+          command.subcommands.each do |subcommand|
+            subcommand_key = subcommand.usage.delete_prefix("#{command.name} ")
+            puts "  #{subcommand_key.ljust(DESCRIPTION_COLUMN - 2)}#{subcommand.description}"
+          end
+          puts ''
+          puts 'Options:'
+          GLOBAL_OPTIONS.each { |option| puts "  #{option.short}, #{option.long}  #{option.description}" }
+        else
+          OptionParser.new do |opts|
+            opts.banner = "Usage: wavesync #{command.name} [options]"
+            (command.options + GLOBAL_OPTIONS).each { |option| opts.on(*option.to_a) }
+            puts opts
+          end
+        end
+      end
+
+      #: (String name, String description) -> String
+      def format_command_line(name, description)
+        "  #{name.ljust(DESCRIPTION_COLUMN - 2)}#{description}"
+      end
+
+      #: (untyped option, indent: Integer) -> String
+      def format_option_line(option, indent:)
+        key = "#{option.short}, #{option.long}"
+        Rainbow("#{' ' * indent}#{key.ljust(DESCRIPTION_COLUMN - indent)}#{option.description}").darkgray
+      end
+    end
+  end
+end

data/lib/wavesync/commands/set.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Set < Command
+      self.name = 'set'
+      self.subcommands = [
+        Subcommand.new(usage: 'set create NAME', description: 'Create a new track set'),
+        Subcommand.new(usage: 'set edit NAME', description: 'Edit an existing track set'),
+        Subcommand.new(usage: 'set list', description: 'List all track sets')
+      ].freeze
+
+      #: () -> void
+      def run
+        subcommand = ARGV.shift
+
+        _options, config = parse_options(banner: 'Usage: wavesync set <subcommand> [options]')
+
+        case subcommand
+        when 'create'
+          name = require_name('create')
+          if Wavesync::Set.exists?(config.library, name)
+            puts "Set '#{name}' already exists. Use 'wavesync set edit #{name}' to edit it."
+            exit 1
+          end
+          set = Wavesync::Set.new(config.library, name)
+          Wavesync::SetEditor.new(set, config.library).run
+        when 'edit'
+          name = require_name('edit')
+          unless Wavesync::Set.exists?(config.library, name)
+            puts "Set '#{name}' not found. Use 'wavesync set create #{name}' to create it."
+            exit 1
+          end
+          set = Wavesync::Set.load(config.library, name)
+          Wavesync::SetEditor.new(set, config.library).run
+        when 'list'
+          sets = Wavesync::Set.all(config.library)
+          if sets.empty?
+            puts 'No sets found.'
+          else
+            sets.each { |set| puts "#{set.name} (#{set.tracks.size} tracks)" }
+          end
+        else
+          puts "Unknown subcommand: #{subcommand || '(none)'}"
+          puts 'Available subcommands: create, edit, list'
+          exit 1
+        end
+      end
+
+      private
+
+      #: (String subcommand) -> String
+      def require_name(subcommand)
+        name = ARGV.shift
+        unless name
+          puts "Usage: wavesync set #{subcommand} <name>"
+          exit 1
+        end
+        name
+      end
+    end
+  end
+end

data/lib/wavesync/commands/sync.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Sync < Command
+      DEVICE_OPTION = Option.new(short: '-d', long: '--device NAME', description: 'Name of device to sync (as defined in config)')
+      PAD_OPTION = Option.new(short: '-p', long: '--pad', description: 'Pad tracks with silence so total length is a multiple of 64 bars (Octatrack only)')
+
+      self.name = 'sync'
+      self.description = 'Sync music library to a device'
+      self.options = [DEVICE_OPTION, PAD_OPTION].freeze
+
+      #: () -> void
+      def run
+        options, config = parse_options(banner: 'Usage: wavesync sync [options]') do |opts, opts_hash|
+          opts.on(*DEVICE_OPTION.to_a) { |value| opts_hash[:device] = value }
+          opts.on(*PAD_OPTION.to_a) { opts_hash[:pad] = true }
+        end
+
+        device_configs = config.device_configs
+        if options[:device]
+          device_configs = device_configs.select { |device_config| device_config[:name] == options[:device] }
+          if device_configs.empty?
+            known = config.device_configs.map { |device_config| device_config[:name] }.join(', ')
+            puts "Unknown device \"#{options[:device]}\". Devices in config: #{known}"
+            exit 1
+          end
+        elsif device_configs.size > 1
+          device_names = device_configs.map { |device_config| device_config[:name] }
+          selected_name = Wavesync::UI.new.select('Select device', device_names)
+          device_configs = device_configs.select { |device_config| device_config[:name] == selected_name }
+        end
+
+        device_pairs = device_configs.map do |device_config|
+          device = Wavesync::Device.find_by(name: device_config[:model])
+          unless device
+            supported = Wavesync::Device.all.map(&:name).join(', ')
+            puts "Unknown device model \"#{device_config[:model]}\" in config. Supported models: #{supported}"
+            exit 1
+          end
+          [device_config, device]
+        end #: Array[untyped]
+
+        scanner = Wavesync::Scanner.new(config.library)
+
+        device_pairs.each do |pair|
+          device_config = pair[0] #: { name: String, model: String, path: String }
+          device = pair[1] #: Wavesync::Device
+          scanner.sync(device_config[:path], device, pad: options[:pad] || false)
+        end
+      end
+    end
+  end
+end

data/lib/wavesync/commands.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wavesync
+  module Commands
+    Option = Struct.new(:short, :long, :description)
+    Subcommand = Struct.new(:usage, :description)
+
+    CONFIG_OPTION = Option.new(short: '-c', long: '--config PATH', description: 'Path to wavesync config YAML file')
+    GLOBAL_OPTIONS = [CONFIG_OPTION].freeze
+
+    #: (String path) -> Config
+    def self.load_config(path)
+      Wavesync::Config.load(path)
+    rescue Wavesync::ConfigError => e
+      puts "Configuration error: #{e.message}"
+      exit 1
+    end
+
+    require_relative 'commands/command'
+    require_relative 'commands/sync'
+    require_relative 'commands/analyze'
+    require_relative 'commands/set'
+    require_relative 'commands/help'
+
+    ALL = [Sync, Analyze, Set, Help].freeze
+  end
+end

data/lib/wavesync/config.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'yaml'
 
@@ -12,8 +13,10 @@ module Wavesync
     DEVICE_SUPPORTED_KEYS = %w[name model path].freeze
     DEVICE_REQUIRED_KEYS = %w[name model path].freeze
 
-    attr_reader :library, :device_configs
+    attr_reader :library #: String
+    attr_reader :device_configs #: Array[{ name: String, model: String, path: String }]
 
+    #: (?String path) -> Config
     def self.load(path = DEFAULT_PATH)
       expanded = File.expand_path(path)
       begin
@@ -26,6 +29,7 @@ module Wavesync
       new(data)
     end
 
+    #: (untyped data) -> void
     def initialize(data)
       validate!(data)
       @library = File.expand_path(data['library'])
@@ -37,6 +41,7 @@ module Wavesync
 
     private
 
+    #: (untyped data) -> void
     def validate!(data)
       raise ConfigError, 'Config file must contain a YAML mapping' unless data.is_a?(Hash)
 
@@ -52,6 +57,7 @@ module Wavesync
       raise ConfigError, "'devices' must contain at least one device" if data['devices'].empty?
     end
 
+    #: (untyped device, Integer index) -> void
     def validate_device!(device, index)
       raise ConfigError, "Device #{index + 1} must be a YAML mapping" unless device.is_a?(Hash)
 

data/lib/wavesync/cue_chunk.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wavesync
+  class CueChunk
+    RIFF_HEADER_SIZE = 12
+    CHUNK_ID_SIZE = 4
+    CHUNK_SIZE_FIELD_SIZE = 4
+    CUE_CHUNK_ID = 'cue '
+    LIST_CHUNK_ID = 'LIST'
+    ADTL_LIST_TYPE = 'adtl'
+    LABL_CHUNK_ID = 'labl'
+    DATA_CHUNK_ID = 'data'
+    CUE_HEADER_SIZE = 4
+    BYTES_PER_CUE_POINT = 24
+
+    UINT32_LE = 'V'
+
+    #: (String filepath) -> Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+    def self.read(filepath)
+      cue_points = [] #: Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+      labels = {} #: Hash[Integer, String]
+
+      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_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
+
+          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
+            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
+          end
+
+          chunk_padding = chunk_size.odd? ? 1 : 0
+          file.seek(chunk_data_start + chunk_size + chunk_padding)
+        end
+      end
+
+      cue_points.map { |cue_point| { identifier: cue_point[:identifier], sample_offset: cue_point[:sample_offset], label: labels[cue_point[:identifier]] } }
+    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))
+
+          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(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?
+          end
+        end
+      end
+
+      update_riff_size(output_filepath)
+    end
+
+    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: 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)
+      output.write([chunk_size].pack(UINT32_LE))
+      output.write([cue_points.size].pack(UINT32_LE))
+      cue_points.each_with_index do |cue_point, index|
+        identifier = cue_point[:identifier] || (index + 1)
+        output.write([identifier].pack(UINT32_LE))
+        output.write([0].pack(UINT32_LE))
+        output.write(DATA_CHUNK_ID)
+        output.write([0].pack(UINT32_LE))
+        output.write([0].pack(UINT32_LE))
+        output.write([cue_point[:sample_offset]].pack(UINT32_LE))
+      end
+    end
+
+    #: (untyped output, Array[{identifier: Integer, sample_offset: Integer, label: 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] }
+      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)
+        output.write([entry[:data_size]].pack(UINT32_LE))
+        output.write([entry[:identifier]].pack(UINT32_LE))
+        output.write(entry[:text])
+        output.write("\x00") if entry[:pad] == 1
+      end
+    end
+
+    #: (untyped file, Integer list_end, Hash[Integer, String] labels) -> void
+    def self.read_adtl_labels(file, list_end, labels)
+      while file.tell < list_end - 8
+        sub_id = file.read(CHUNK_ID_SIZE)
+        break if sub_id.nil? || sub_id.length < CHUNK_ID_SIZE
+
+        sub_size_bytes = file.read(CHUNK_SIZE_FIELD_SIZE)
+        break if sub_size_bytes.nil?
+
+        sub_size = sub_size_bytes.unpack1(UINT32_LE).to_i
+        sub_data_start = file.tell
+
+        if sub_id == LABL_CHUNK_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
+        end
+
+        sub_padding = sub_size.odd? ? 1 : 0
+        file.seek(sub_data_start + sub_size + sub_padding)
+      end
+    end
+
+    #: (String filepath) -> void
+    def self.update_riff_size(filepath)
+      File.open(filepath, 'r+b') do |file|
+        file.seek(0, IO::SEEK_END)
+        file_size = file.tell
+        riff_size = file_size - 8
+        file.seek(4)
+        file.write([riff_size].pack(UINT32_LE))
+      end
+    end
+  end
+end