wavify 0.1.0

data/benchmarks/benchmark_helper.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "fileutils"
+require_relative "../lib/wavify"
+
+module WavifyBenchmarks
+  module Helper
+    module_function
+
+    TMP_DIR = File.expand_path("../tmp/benchmarks", __dir__)
+
+    def int_env(name, default)
+      value = ENV.fetch(name, nil)
+      return default if value.nil? || value.empty?
+
+      Integer(value)
+    rescue ArgumentError
+      default
+    end
+
+    def float_env(name, default)
+      value = ENV.fetch(name, nil)
+      return default if value.nil? || value.empty?
+
+      Float(value)
+    rescue ArgumentError
+      default
+    end
+
+    def bool_env(name, default: false)
+      value = ENV.fetch(name, nil)
+      return default if value.nil?
+
+      %w[1 true yes on].include?(value.downcase)
+    end
+
+    def tmp_dir
+      FileUtils.mkdir_p(TMP_DIR)
+      TMP_DIR
+    end
+
+    def banner(title)
+      puts
+      puts "== #{title} =="
+    end
+
+    def measure(label)
+      result = nil
+      elapsed = Benchmark.realtime do
+        result = yield
+      end
+      puts format("  %<label>-32s %<elapsed>8.4fs", label: label, elapsed: elapsed)
+      [elapsed, result]
+    end
+
+    def rss_kb
+      value = `ps -o rss= -p #{Process.pid}`.to_s.strip
+      return nil if value.empty?
+
+      Integer(value)
+    rescue StandardError
+      nil
+    end
+
+    def file_size_mb(path)
+      return 0.0 unless File.file?(path)
+
+      File.size(path) / (1024.0 * 1024.0)
+    end
+
+    def float_stereo_format(sample_rate: 44_100)
+      Wavify::Core::Format.new(channels: 2, sample_rate: sample_rate, bit_depth: 32, sample_format: :float)
+    end
+
+    def pcm_stereo_format(sample_rate: 44_100)
+      Wavify::Core::Format.new(channels: 2, sample_rate: sample_rate, bit_depth: 16, sample_format: :pcm)
+    end
+
+    def demo_audio(duration_seconds:, format: float_stereo_format)
+      raise ArgumentError, "duration_seconds must be > 0" unless duration_seconds.is_a?(Numeric) && duration_seconds.positive?
+
+      lead = Wavify::Audio.tone(frequency: 220.0, duration: duration_seconds, waveform: :sawtooth, format: format).gain(-14)
+      harmony = Wavify::Audio.tone(frequency: 330.0, duration: duration_seconds, waveform: :triangle, format: format).gain(-18)
+      noise = Wavify::Audio.tone(frequency: 1.0, duration: duration_seconds, waveform: :white_noise, format: format).gain(-34)
+
+      Wavify::Audio.mix(lead, harmony, noise)
+                   .apply(Wavify::Effects::Chorus.new(rate: 0.25, depth: 0.2, mix: 0.15))
+                   .normalize(target_db: -3.0)
+    end
+
+    def print_config(config)
+      config.each do |key, value|
+        puts "  #{key}: #{value}"
+      end
+    end
+
+    def maybe_cleanup(*paths)
+      return if bool_env("KEEP_BENCH_FILES", default: false)
+
+      paths.each do |path|
+        File.delete(path) if File.file?(path)
+      end
+    end
+
+    def gain_chunk_processor(db)
+      lambda do |chunk|
+        Wavify::Audio.new(chunk).gain(db).buffer
+      end
+    end
+  end
+end

data/benchmarks/dsp_effects_benchmark.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+helper = WavifyBenchmarks::Helper
+iterations = helper.int_env("DSP_BENCH_ITERATIONS", 8)
+duration_seconds = helper.float_env("DSP_BENCH_DURATION", 2.0)
+format = helper.float_stereo_format
+audio = helper.demo_audio(duration_seconds: duration_seconds, format: format)
+buffer = audio.buffer
+
+helper.banner("DSP effects benchmark")
+helper.print_config(
+  iterations: iterations,
+  duration_seconds: duration_seconds,
+  sample_rate: buffer.format.sample_rate,
+  channels: buffer.format.channels,
+  frames: buffer.sample_frame_count
+)
+
+effects = {
+  delay: -> { Wavify::Effects::Delay.new(time: 0.18, feedback: 0.35, mix: 0.25) },
+  reverb: -> { Wavify::Effects::Reverb.new(room_size: 0.6, damping: 0.4, mix: 0.2) },
+  chorus: -> { Wavify::Effects::Chorus.new(rate: 0.8, depth: 0.35, mix: 0.3) },
+  distortion: -> { Wavify::Effects::Distortion.new(drive: 0.45, tone: 0.6, mix: 0.4) },
+  compressor: -> { Wavify::Effects::Compressor.new(threshold: -16, ratio: 3.0, attack: 0.005, release: 0.1) }
+}.freeze
+
+effects.each do |name, factory|
+  helper.measure("#{name} x#{iterations}") do
+    iterations.times do
+      effect = factory.call
+      effect.process(buffer)
+    end
+  end
+end
+
+helper.measure("audio chain x#{iterations}") do
+  iterations.times do
+    audio
+      .apply(Wavify::Effects::Compressor.new(threshold: -16, ratio: 2.5, attack: 0.005, release: 0.08))
+      .apply(Wavify::Effects::Chorus.new(rate: 0.7, depth: 0.2, mix: 0.2))
+      .apply(Wavify::Effects::Reverb.new(room_size: 0.4, damping: 0.5, mix: 0.15))
+  end
+end

data/benchmarks/flac_benchmark.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+helper = WavifyBenchmarks::Helper
+iterations = helper.int_env("FLAC_BENCH_ITERATIONS", 4)
+duration_seconds = helper.float_env("FLAC_BENCH_DURATION", 3.0)
+chunk_size = helper.int_env("FLAC_BENCH_CHUNK", 4096)
+format = helper.pcm_stereo_format
+
+source_audio = helper.demo_audio(duration_seconds: duration_seconds, format: helper.float_stereo_format)
+source_audio = source_audio.convert(format)
+
+wav_source_path = File.join(helper.tmp_dir, "flac_bench_source.wav")
+flac_path = File.join(helper.tmp_dir, "flac_bench_audio_write.flac")
+flac_stream_path = File.join(helper.tmp_dir, "flac_bench_stream_write.flac")
+
+helper.banner("FLAC encode/decode benchmark")
+helper.print_config(
+  iterations: iterations,
+  duration_seconds: duration_seconds,
+  chunk_size: chunk_size,
+  sample_rate: format.sample_rate,
+  channels: format.channels,
+  bit_depth: format.bit_depth
+)
+
+helper.measure("prepare wav source") do
+  source_audio.write(wav_source_path, format: format)
+end
+
+helper.measure("audio.write(.flac) x#{iterations}") do
+  iterations.times do
+    source_audio.write(flac_path, format: format)
+  end
+end
+
+helper.measure("audio.read(.flac) x#{iterations}") do
+  iterations.times { Wavify::Audio.read(flac_path) }
+end
+
+helper.measure("stream wav->flac x#{iterations}") do
+  iterations.times do
+    Wavify::Codecs::Flac.stream_write(flac_stream_path, format: format) do |writer|
+      Wavify::Codecs::Wav.stream_read(wav_source_path, chunk_size: chunk_size) do |chunk|
+        writer.call(chunk)
+      end
+    end
+  end
+end
+
+helper.measure("stream read flac x#{iterations}") do
+  iterations.times do
+    total_frames = 0
+    Wavify::Codecs::Flac.stream_read(flac_stream_path, chunk_size: chunk_size) do |chunk|
+      total_frames += chunk.sample_frame_count
+    end
+    total_frames
+  end
+end
+
+metadata = Wavify::Codecs::Flac.metadata(flac_path)
+wav_size_mb = helper.file_size_mb(wav_source_path)
+flac_size_mb = helper.file_size_mb(flac_path)
+ratio = wav_size_mb.zero? ? 0.0 : (flac_size_mb / wav_size_mb)
+
+puts "  source frames:       #{source_audio.sample_frame_count}"
+puts "  wav source size:     #{wav_size_mb.round(2)} MB"
+puts "  flac write size:     #{flac_size_mb.round(2)} MB"
+puts "  flac/wav ratio:      #{ratio.round(3)}"
+puts "  flac block size:     #{metadata[:min_block_size]}..#{metadata[:max_block_size]}"
+
+helper.maybe_cleanup(wav_source_path, flac_path, flac_stream_path)

data/benchmarks/streaming_memory_benchmark.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+helper = WavifyBenchmarks::Helper
+duration_seconds = helper.float_env("STREAM_BENCH_DURATION", 30.0)
+chunk_frames = helper.int_env("STREAM_BENCH_CHUNK", 4096)
+format = helper.pcm_stereo_format
+float_chunk_format = format.with(sample_format: :float, bit_depth: 32)
+source_path = File.join(helper.tmp_dir, "streaming_source.wav")
+output_path = File.join(helper.tmp_dir, "streaming_processed.wav")
+
+def build_large_source(path, duration_seconds:, chunk_frames:, format:, float_chunk_format:)
+  total_frames = (duration_seconds * format.sample_rate).round
+  remaining = total_frames
+
+  tone = Wavify::DSP::Oscillator.new(waveform: :sine, frequency: 110.0, amplitude: 0.45)
+  noise = Wavify::DSP::Oscillator.new(waveform: :white_noise, frequency: 1.0, amplitude: 0.08)
+  tone_enum = tone.each_sample(format: float_chunk_format)
+  noise_enum = noise.each_sample(format: float_chunk_format)
+
+  Wavify::Codecs::Wav.stream_write(path, format: format) do |writer|
+    while remaining.positive?
+      frames = [remaining, chunk_frames].min
+      samples = Array.new(frames * float_chunk_format.channels)
+
+      frames.times do |frame_index|
+        value = tone_enum.next + noise_enum.next
+        base = frame_index * float_chunk_format.channels
+        float_chunk_format.channels.times do |channel_index|
+          samples[base + channel_index] = value.clamp(-1.0, 1.0)
+        end
+      end
+
+      writer.call(Wavify::Core::SampleBuffer.new(samples, float_chunk_format))
+      remaining -= frames
+    end
+  end
+
+  total_frames
+end
+
+helper.banner("Streaming memory benchmark")
+helper.print_config(
+  duration_seconds: duration_seconds,
+  chunk_frames: chunk_frames,
+  sample_rate: format.sample_rate,
+  channels: format.channels
+)
+
+generated_frames = nil
+helper.measure("generate streamed source") do
+  generated_frames = build_large_source(
+    source_path,
+    duration_seconds: duration_seconds,
+    chunk_frames: chunk_frames,
+    format: format,
+    float_chunk_format: float_chunk_format
+  )
+end
+
+rss_before = helper.rss_kb
+rss_peak = rss_before
+probe_counter = 0
+
+probe = lambda do |chunk|
+  probe_counter += 1
+  if (probe_counter % 25).zero?
+    current_rss = helper.rss_kb
+    rss_peak = [rss_peak, current_rss].compact.max
+  end
+  chunk
+end
+
+helper.measure("stream process pipeline") do
+  Wavify::Audio.stream(source_path, chunk_size: chunk_frames)
+               .pipe(probe)
+               .pipe(Wavify::Effects::Compressor.new(threshold: -18, ratio: 3.0, attack: 0.003, release: 0.08))
+               .pipe(Wavify::Effects::Chorus.new(rate: 0.5, depth: 0.2, mix: 0.12))
+               .pipe(helper.gain_chunk_processor(-2.0))
+               .write_to(output_path, format: format)
+end
+
+rss_after = helper.rss_kb
+
+puts "  source frames:       #{generated_frames}"
+puts "  source file size:    #{helper.file_size_mb(source_path).round(2)} MB"
+puts "  output file size:    #{helper.file_size_mb(output_path).round(2)} MB"
+puts "  rss before:          #{rss_before || 'n/a'} KB"
+puts "  rss peak (sampled):  #{rss_peak || 'n/a'} KB"
+puts "  rss after:           #{rss_after || 'n/a'} KB"
+
+helper.maybe_cleanup(source_path, output_path)

data/benchmarks/wav_io_benchmark.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+helper = WavifyBenchmarks::Helper
+iterations = helper.int_env("WAV_IO_ITERATIONS", 5)
+duration_seconds = helper.float_env("WAV_IO_DURATION", 3.0)
+chunk_size = helper.int_env("WAV_IO_CHUNK", 4096)
+
+wavefile_loaded = begin
+  require "wavefile"
+  true
+rescue LoadError
+  false
+end
+
+def wavefile_format_for(format)
+  channels = case format.channels
+             when 1 then :mono
+             when 2 then :stereo
+             else format.channels
+             end
+
+  sample_format = if format.sample_format == :pcm
+                    :"pcm_#{format.bit_depth}"
+                  elsif format.sample_format == :float && format.bit_depth == 32
+                    :float
+                  else
+                    raise ArgumentError, "unsupported WaveFile benchmark format: #{format.sample_format}/#{format.bit_depth}"
+                  end
+
+  WaveFile::Format.new(channels, sample_format, format.sample_rate)
+end
+
+def wavefile_buffer_for(audio)
+  format = audio.format
+  frame_samples = audio.buffer.samples.each_slice(format.channels).map(&:dup)
+  WaveFile::Buffer.new(frame_samples, wavefile_format_for(format))
+end
+
+helper.banner("WAV IO benchmark")
+helper.print_config(
+  iterations: iterations,
+  duration_seconds: duration_seconds,
+  chunk_size: chunk_size,
+  wavefile_compare: wavefile_loaded
+)
+
+source_audio = helper.demo_audio(duration_seconds: duration_seconds, format: helper.float_stereo_format)
+source_audio = source_audio.convert(helper.pcm_stereo_format)
+
+source_path = File.join(helper.tmp_dir, "wav_io_source.wav")
+processed_path = File.join(helper.tmp_dir, "wav_io_processed.wav")
+wavefile_path = File.join(helper.tmp_dir, "wav_io_wavefile.wav")
+
+wavify_write_elapsed, = helper.measure("write source x#{iterations}") do
+  iterations.times { source_audio.write(source_path) }
+end
+
+wavify_read_elapsed, = helper.measure("read source x#{iterations}") do
+  iterations.times { Wavify::Audio.read(source_path) }
+end
+
+helper.measure("stream read+write x#{iterations}") do
+  iterations.times do
+    Wavify::Audio.stream(source_path, chunk_size: chunk_size)
+                 .pipe(helper.gain_chunk_processor(-3.0))
+                 .pipe(Wavify::Effects::Compressor.new(threshold: -16, ratio: 2.0, attack: 0.005, release: 0.05))
+                 .write_to(processed_path, format: helper.pcm_stereo_format)
+  end
+end
+
+puts "  source file size:    #{helper.file_size_mb(source_path).round(2)} MB"
+puts "  processed file size: #{helper.file_size_mb(processed_path).round(2)} MB"
+
+if wavefile_loaded
+  wavefile_format = wavefile_format_for(source_audio.format)
+  wavefile_buffer = wavefile_buffer_for(source_audio)
+
+  wavefile_write_elapsed, = helper.measure("WaveFile write x#{iterations}") do
+    iterations.times do
+      WaveFile::Writer.new(wavefile_path, wavefile_format) do |writer|
+        writer.write(wavefile_buffer)
+      end
+    end
+  end
+
+  wavefile_read_elapsed, = helper.measure("WaveFile read x#{iterations}") do
+    iterations.times do
+      WaveFile::Reader.new(wavefile_path) do |reader|
+        reader.each_buffer(chunk_size) { |_buffer| }
+      end
+    end
+  end
+
+  if wavify_write_elapsed.positive?
+    puts format("  Wavify/WaveFile write speed: %7.2f%%",
+                (wavefile_write_elapsed / wavify_write_elapsed) * 100.0)
+  end
+  if wavify_read_elapsed.positive?
+    puts format("  Wavify/WaveFile read speed:  %7.2f%%",
+                (wavefile_read_elapsed / wavify_read_elapsed) * 100.0)
+  end
+else
+  puts "  WaveFile comparison skipped (optional gem not installed)"
+  puts "  Install with: gem install wavefile"
+end
+
+helper.maybe_cleanup(source_path, processed_path, wavefile_path)

data/examples/audio_processing.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../lib/wavify"
+
+OUTPUT_DIR = File.expand_path("../tmp/examples", __dir__)
+
+def float_format
+  Wavify::Core::Format.new(channels: 2, sample_rate: 44_100, bit_depth: 32, sample_format: :float)
+end
+
+def build_demo_recording
+  format = float_format
+  lead = Wavify::Audio.tone(frequency: 220.0, duration: 1.0, waveform: :sine, format: format).gain(-12)
+  harmony = Wavify::Audio.tone(frequency: 330.0, duration: 1.0, waveform: :triangle, format: format).gain(-16)
+  body = Wavify::Audio.mix(lead, harmony)
+
+  noise = Wavify::Audio.tone(frequency: 1.0, duration: body.duration.total_seconds, waveform: :white_noise, format: format).gain(-30)
+  signal = Wavify::Audio.mix(body, noise)
+
+  head = Wavify::Audio.silence(0.15, format: format)
+  tail = Wavify::Audio.silence(0.2, format: format)
+  Wavify::Audio.new(head.buffer + signal.buffer + tail.buffer)
+end
+
+def process(audio)
+  audio
+    .trim(threshold: 0.02)
+    .fade_in(0.01)
+    .fade_out(0.08)
+    .apply(Wavify::Effects::Compressor.new(threshold: -18, ratio: 3.5, attack: 0.005, release: 0.08))
+    .apply(Wavify::Effects::Distortion.new(drive: 0.2, tone: 0.65, mix: 0.12))
+    .normalize(target_db: -1.0)
+end
+
+def process_file(input_path, output_path)
+  source = Wavify::Audio.read(input_path)
+  processed = process(source)
+  processed.convert(Wavify::Core::Format::CD_QUALITY).write(output_path)
+
+  puts "Processed #{input_path} -> #{output_path}"
+  puts "  source duration:    #{source.duration}"
+  puts "  processed duration: #{processed.duration}"
+  puts "  source peak:        #{source.peak_amplitude.round(4)}"
+  puts "  output peak:        #{processed.peak_amplitude.round(4)}"
+end
+
+def run_demo
+  FileUtils.mkdir_p(OUTPUT_DIR)
+  source_path = File.join(OUTPUT_DIR, "audio_processing_source.wav")
+  output_path = File.join(OUTPUT_DIR, "audio_processing_output.wav")
+
+  source = build_demo_recording
+  source.convert(Wavify::Core::Format::CD_QUALITY).write(source_path)
+  process(source).convert(Wavify::Core::Format::CD_QUALITY).write(output_path)
+
+  puts "Generated demo processing files:"
+  puts "  #{source_path}"
+  puts "  #{output_path}"
+end
+
+if ARGV.include?("-h") || ARGV.include?("--help")
+  puts "Usage: ruby examples/audio_processing.rb [INPUT_PATH OUTPUT_PATH]"
+  puts "When no args are given, a self-contained demo is written to tmp/examples/."
+  exit(0)
+end
+
+if ARGV.length >= 2
+  process_file(ARGV[0], ARGV[1])
+else
+  run_demo
+end

data/examples/cinematic_transition.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../lib/wavify"
+
+OUTPUT_DIR = File.expand_path("../tmp/examples", __dir__)
+OUTPUT_PATH = File.join(OUTPUT_DIR, "cinematic_transition.wav")
+
+def render_format
+  Wavify::Core::Format.new(channels: 2, sample_rate: 48_000, bit_depth: 32, sample_format: :float)
+end
+
+def place(audio, at:, total_length:, format:)
+  head = Wavify::Audio.silence(at, format: format)
+  clip = Wavify::Audio.new(head.buffer + audio.buffer)
+  remaining = total_length - clip.duration.total_seconds
+  return clip if remaining <= 0.0
+
+  Wavify::Audio.new(clip.buffer + Wavify::Audio.silence(remaining, format: format).buffer)
+end
+
+def drone_layer(frequency, duration, format)
+  base = Wavify::Audio.tone(frequency: frequency, duration: duration, waveform: :triangle, format: format)
+               .gain(-22)
+               .fade_in(1.2)
+               .fade_out(1.5)
+  shimmer = Wavify::Audio.tone(frequency: frequency * 2.0, duration: duration, waveform: :sine, format: format)
+                  .gain(-30)
+                  .fade_in(1.5)
+                  .fade_out(1.2)
+  Wavify::Audio.mix(base, shimmer)
+end
+
+def riser(duration, format)
+  steps = [220.0, 330.0, 440.0, 660.0, 880.0]
+  segment = duration / steps.length
+  layers = steps.map do |frequency|
+    Wavify::Audio.tone(frequency: frequency, duration: segment, waveform: :sawtooth, format: format)
+                 .gain(-24)
+                 .fade_in(0.03)
+                 .fade_out(0.04)
+  end
+
+  combined = layers.reduce { |memo, audio| Wavify::Audio.new(memo.buffer + audio.buffer) }
+  noise = Wavify::Audio.tone(frequency: 1.0, duration: duration, waveform: :white_noise, format: format)
+                .gain(-33)
+                .fade_in(duration * 0.7)
+                .fade_out(duration * 0.1)
+                .apply(Wavify::DSP::Filter.highpass(cutoff: 2_500.0))
+  Wavify::Audio.mix(combined, noise).apply(Wavify::Effects::Chorus.new(rate: 0.5, depth: 0.35, mix: 0.25))
+end
+
+def impact(format)
+  low = Wavify::Audio.tone(frequency: 55.0, duration: 0.5, waveform: :sine, format: format)
+              .gain(-10)
+              .fade_out(0.45)
+  noise = Wavify::Audio.tone(frequency: 1.0, duration: 0.38, waveform: :white_noise, format: format)
+                .gain(-17)
+                .apply(Wavify::DSP::Filter.bandpass(center: 1_600.0, bandwidth: 900.0))
+                .fade_out(0.32)
+  click = Wavify::Audio.tone(frequency: 2_000.0, duration: 0.02, waveform: :triangle, format: format)
+                .gain(-20)
+                .fade_out(0.015)
+
+  Wavify::Audio.mix(low, noise, click)
+               .apply(Wavify::Effects::Distortion.new(drive: 0.18, tone: 0.6, mix: 0.16))
+               .normalize(target_db: -3.5)
+end
+
+def reverse_tail(format)
+  source = Wavify::Audio.tone(frequency: 480.0, duration: 1.1, waveform: :triangle, format: format)
+                 .gain(-28)
+                 .apply(Wavify::Effects::Reverb.new(room_size: 0.72, damping: 0.48, mix: 0.44))
+                 .fade_out(1.0)
+  source.reverse.fade_in(0.6).fade_out(0.2)
+end
+
+def master(audio)
+  audio
+    .apply(Wavify::Effects::Compressor.new(threshold: -16, ratio: 3.2, attack: 0.004, release: 0.1))
+    .apply(Wavify::Effects::Reverb.new(room_size: 0.45, damping: 0.5, mix: 0.18))
+    .normalize(target_db: -1.0)
+    .fade_in(0.08)
+    .fade_out(1.2)
+end
+
+def build_scene
+  format = render_format
+  total_length = 12.0
+
+  base_drone = Wavify::Audio.mix(
+    drone_layer(110.0, total_length, format).pan(-0.15),
+    drone_layer(146.83, total_length, format).pan(0.14)
+  )
+  pulse = Wavify::Audio.tone(frequency: 2.0, duration: 3.2, waveform: :sine, format: format)
+                 .apply(Wavify::DSP::Filter.lowpass(cutoff: 180.0))
+                 .gain(-31)
+                 .fade_in(0.4)
+                 .fade_out(0.5)
+  build = place(riser(2.8, format), at: 6.2, total_length: total_length, format: format)
+  hit = place(impact(format), at: 9.05, total_length: total_length, format: format)
+  tail = place(reverse_tail(format), at: 8.15, total_length: total_length, format: format)
+  pulse_layer = place(pulse, at: 4.9, total_length: total_length, format: format)
+
+  Wavify::Audio.mix(base_drone, pulse_layer, build, tail, hit)
+end
+
+FileUtils.mkdir_p(OUTPUT_DIR)
+
+raw = build_scene
+final = master(raw).convert(Wavify::Core::Format::CD_QUALITY)
+final.write(OUTPUT_PATH)
+
+puts "Wrote #{OUTPUT_PATH}"
+puts "  duration: #{final.duration}"
+puts "  peak:     #{final.peak_amplitude.round(4)}"
+puts "  rms:      #{final.rms_amplitude.round(4)}"