badline 0.1.0 → 0.2.0

data/lib/badline/media.rb

@@ -3,37 +3,75 @@
 module Badline
   module Media
     AUTOSTART = %(lO"*",8,1\rrun\r)
+    TAPE_AUTOSTART = %(lO\rrun\r)
     BASIC_START = 0x0801
 
-    DISK_TYPES = {
+    MOUNT_TYPES = {
       ".d64" => Storage::D64Image,
       ".d71" => Storage::D71Image,
-      ".d81" => Storage::D81Image
+      ".d81" => Storage::D81Image,
+      ".t64" => Storage::T64
     }.freeze
 
     class << self
-      def attach(computer, path, autostart: true)
+      # `cartridge` sets the jumpers of a .crt cartridge that has them, such
+      # as `{ flash_jumper: true }` for the Retro Replay's flash mode.
+      def attach(computer, path, autostart: true, song: nil, cartridge: {})
         if File.directory?(path)
           computer.mount(Storage::HostDirectory.new(path))
           "Mounted #{path} as device 8"
         elsif File.extname(path).downcase == ".crt"
-          attach_cartridge(computer, path)
-        elsif (image = DISK_TYPES[File.extname(path).downcase])
-          attach_disk(computer, image.new(path), path, autostart:)
+          attach_cartridge(computer, path, cartridge)
+        elsif File.extname(path).downcase == ".sid"
+          attach_sid(computer, path, autostart:, song:)
+        elsif File.extname(path).downcase == ".tap"
+          attach_tape(computer, path, autostart:)
+        elsif (storage = MOUNT_TYPES[File.extname(path).downcase])
+          attach_storage(computer, storage.new(path), path, autostart:)
         else
           attach_prg(computer, path, autostart:)
         end
       end
 
+      # The SID a machine for `path` should be built with. A .sid tune names
+      # its own; everything else gets the 6581.
+      def sid_model(path)
+        return :mos6581 unless path && File.extname(path).downcase == ".sid"
+
+        Storage::SIDFile.new(path).sid_model
+      end
+
       private
 
-      def attach_cartridge(computer, path)
-        computer.attach_cartridge(Cartridge.from_file(path))
+      def attach_cartridge(computer, path, options)
+        computer.attach_cartridge(Cartridge.from_file(path, **options))
         "Attached cartridge #{path}"
       end
 
-      def attach_disk(computer, image, path, autostart:)
-        computer.mount(image)
+      def attach_sid(computer, path, autostart:, song:)
+        tune = Storage::SIDFile.new(path)
+        song = (song || tune.start_song).clamp(1, tune.songs)
+        computer.on_init { start_tune(computer, tune, autostart:, song:) }
+        title = tune.name.empty? ? path : tune.name
+        title += " (song #{song})" if tune.songs > 1
+        autostart ? "Playing #{title}" : "Loaded #{title}"
+      end
+
+      def start_tune(computer, tune, autostart:, song:)
+        computer.ram.write(tune.load_address, tune.data)
+        computer.ram.write(tune.driver_address, tune.driver(song:))
+        computer.type_text("sys#{tune.driver_address}\r") if autostart
+      end
+
+      def attach_tape(computer, path, autostart:)
+        computer.datasette.insert(Storage::TAP.new(path))
+        computer.datasette.play!
+        computer.type_text(TAPE_AUTOSTART) if autostart
+        "Inserted #{path} in the datasette"
+      end
+
+      def attach_storage(computer, storage, path, autostart:)
+        computer.mount(storage)
         computer.type_text(AUTOSTART) if autostart
         "Mounted #{path} as device 8"
       end

data/lib/badline/roms/eapi/LICENSE.md

@@ -0,0 +1,15 @@
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

data/lib/badline/roms/eapi/README

@@ -0,0 +1,41 @@
+EasyFlash EAPI for the Am29F040
+===============================
+
+eapi-am29f040-14 is the EasyFlash flash driver (EAPI) for the AMD Am29F040,
+version 1.4, by Thomas 'skoe' Giesel. It is third-party software, not part
+of badline, and is distributed under the zlib licence in LICENSE.md.
+
+It is the unaltered output of assembling the upstream source, a C64 PRG
+(a two-byte load address, $C000, then 768 bytes):
+
+  Source:   https://gitlab.com/easyflash/eapi
+  Revision: 1b4ea15d44974d18f6f82156b935f59d2f85596c
+  File:     eapi-am29f040.s (includes eapi_defs.s)
+  Built:    acme -l out/eapi-am29f040-14.labels -o out/eapi-am29f040-14 eapi-am29f040.s
+            (the repository's Makefile rule, with ACME 0.96.4)
+  SHA-256:  4c32d425d7b0a1f659e007bccad5c43603a93236974ef19743b2eefb812ab9ed
+
+The source file's notice:
+
+  (c) 2009-2010 Thomas 'skoe' Giesel
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+When an EasyFlash image carries an EAPI, as its "eapi" signature at $B800
+in bank 0 of ROMH shows, badline replaces those 768 bytes with this driver
+on attach, the way VICE does, so the image drives the flash chip badline
+emulates.

data/lib/badline/sid/decimator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    # Reduces the SID's one-sample-per-cycle stream to an audio rate by
+    # averaging each window. Point sampling would be cheaper, but the pulse
+    # and noise waveforms carry enough energy above the output Nyquist to
+    # alias audibly.
+    #
+    # A sample can stand for several cycles at once, when the DSP has run
+    # them as one step.
+    class Decimator
+      def initialize(clock_hz:, rate:)
+        @clock_hz = clock_hz
+        @rate = rate
+        @phase = 0
+        @sum = 0
+        @count = 0
+      end
+
+      # Cycles until the current window closes, counting the next one as 1.
+      def cycles_to_close = (@clock_hz - @phase + @rate - 1) / @rate
+
+      # Returns the averaged sample when these cycles close a window, and
+      # nil otherwise. They must not run past the window's end.
+      def push(sample, cycles = 1)
+        @sum += sample * cycles
+        @count += cycles
+        @phase += @rate * cycles
+        return unless @phase >= @clock_hz
+
+        @phase -= @clock_hz
+        average
+      end
+
+      private
+
+      def average
+        value = @sum.fdiv(@count).round
+        @sum = 0
+        @count = 0
+        value
+      end
+    end
+  end
+end

data/lib/badline/sid/envelope.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    # ADSR envelope generator.
+    #
+    # A 15-bit rate counter divides the 1 MHz clock down to one envelope step
+    # per period. Attack steps linearly; decay and release run through a
+    # second, level-dependent divider that approximates an exponential
+    # curve.
+    #
+    # Each stage runs a cycle or more behind the one feeding it, after
+    # reSID 1.0's single-cycle pipeline: the rate counter resets the cycle
+    # after it matches, the envelope counter steps two cycles after that,
+    # and a gate edge only switches the rate over on its second cycle.
+    class Envelope
+      # Rate counter comparison values for each ADSR nibble. The counter
+      # takes a cycle to reset, so the period is one cycle longer (2ms to
+      # 8s over the attack range).
+      PERIODS = [8, 31, 62, 94, 148, 219, 266, 312,
+                 391, 976, 1953, 3125, 3906, 11_719, 19_531, 31_250].freeze
+
+      # Envelope levels where the exponential divider changes, and the
+      # divider it changes to.
+      EXPONENTIAL_PERIODS = { 0xff => 1, 0x5d => 2, 0x36 => 4, 0x1a => 8,
+                              0x0e => 16, 0x06 => 30, 0x00 => 1 }.freeze
+
+      attr_reader :state, :counter, :env3
+
+      def initialize
+        @attack = @decay = @sustain = @release = 0x0
+        @gate = false
+        @state = @next_state = :release
+        @counter = @env3 = 0x00
+        @rate_counter = 0
+        @rate_period = PERIODS[0]
+        @reset_rate_counter = false
+        @exponential_counter = 0
+        @exponential_period = 1
+        @state_pipeline = @envelope_pipeline = @exponential_pipeline = 0
+        @hold_zero = true
+      end
+
+      def output = @counter
+
+      # The gate edge switches the state over two cycles. Rising, it runs
+      # the decay rate for the first of them. The rate counter is left
+      # running, so the first step lands somewhere inside the current
+      # period.
+      def control=(value)
+        gate = value.anybits?(0x01)
+        return if gate == @gate
+
+        @gate = gate
+        gate ? gate_on : gate_off
+      end
+
+      def attack_decay=(value)
+        @attack = (value >> 4) & 0x0f
+        @decay = value & 0x0f
+        @rate_period = PERIODS[@attack] if @state == :attack
+        @rate_period = PERIODS[@decay] if @state == :decay_sustain
+      end
+
+      def sustain_release=(value)
+        @sustain = (value >> 4) & 0x0f
+        @release = value & 0x0f
+        @rate_period = PERIODS[@release] if @state == :release
+      end
+
+      # ENV3 reads the counter as it stood at the start of the cycle.
+      #
+      # Lowering the rate period below the current counter sends it the long
+      # way round through 2^15 before the envelope can step, the ADSR delay
+      # bug that hard restarts rely on. Counting from 0x7fff wraps to 1.
+      def cycle!
+        @env3 = @counter
+        run_pipeline if pipelined?
+        return @reset_rate_counter = true if @rate_counter == @rate_period
+
+        @rate_counter += 1
+        @rate_counter = 1 if @rate_counter == 0x8000
+      end
+
+      # Runs `cycles` cycles as #cycle! would. Between steps only the rate
+      # counter moves, so it jumps from one match to the next and the cycles
+      # around each step run whole. Frozen at zero, a period changes
+      # nothing, so whole periods are counted off at once.
+      def fast_forward(cycles)
+        while cycles.positive?
+          if pipelined?
+            cycle!
+            cycles -= 1
+            next
+          end
+
+          @env3 = @counter
+          idle = cycles_to_match
+          return advance_rate_counter(cycles) if cycles < idle
+
+          advance_rate_counter(idle)
+          cycles = skip_frozen_periods(cycles - idle)
+        end
+      end
+
+      private
+
+      def land_step
+        @envelope_pipeline -= 1
+        step if @envelope_pipeline.zero? && !@hold_zero
+      end
+
+      def gate_on
+        @next_state = :attack
+        @state = :decay_sustain
+        @rate_period = PERIODS[@decay]
+        @state_pipeline = 2
+        if @reset_rate_counter || @exponential_pipeline == 2
+          @envelope_pipeline = @exponential_period == 1 || @exponential_pipeline == 2 ? 2 : 4
+        elsif @exponential_pipeline == 1
+          @state_pipeline = 3
+        end
+      end
+
+      def gate_off
+        @next_state = :release
+        @state_pipeline = @envelope_pipeline.positive? ? 3 : 2
+      end
+
+      def state_change
+        @state_pipeline -= 1
+        if @next_state == :attack
+          enter_attack if @state_pipeline.zero?
+        elsif (@state == :attack && @state_pipeline.zero?) ||
+              (@state == :decay_sustain && @state_pipeline == 1)
+          @state = :release
+          @rate_period = PERIODS[@release]
+        end
+      end
+
+      def enter_attack
+        @state = :attack
+        @rate_period = PERIODS[@attack]
+        @hold_zero = false
+      end
+
+      # The first attack step also resets the exponential divider.
+      def reset_rate_counter
+        @rate_counter = 0
+        @reset_rate_counter = false
+        if @state == :attack
+          @exponential_counter = 0
+          @envelope_pipeline = 2
+        elsif !@hold_zero && (@exponential_counter += 1) == @exponential_period
+          @exponential_pipeline = @exponential_period == 1 ? 1 : 2
+        end
+      end
+
+      def exponential_step
+        @exponential_counter = 0
+        return unless @state == :release || (@state == :decay_sustain && @counter != sustain_level)
+
+        @envelope_pipeline = 1
+      end
+
+      def pipelined?
+        @reset_rate_counter || (@state_pipeline | @envelope_pipeline | @exponential_pipeline) != 0
+      end
+
+      def run_pipeline
+        state_change if @state_pipeline.positive?
+        land_step if @envelope_pipeline.positive?
+        if @exponential_pipeline.positive? && (@exponential_pipeline -= 1).zero?
+          exponential_step
+        elsif @reset_rate_counter
+          reset_rate_counter
+        end
+      end
+
+      # Cycles that only count before the rate counter matches its period.
+      def cycles_to_match
+        return @rate_period - @rate_counter if @rate_counter <= @rate_period
+
+        0x7fff - @rate_counter + @rate_period
+      end
+
+      def advance_rate_counter(cycles)
+        @rate_counter += cycles
+        @rate_counter -= 0x7fff if @rate_counter > 0x7fff
+      end
+
+      # With the counter on its period, a frozen envelope comes back to the
+      # same state every period plus one cycles. Otherwise the next cycle
+      # starts a step.
+      def skip_frozen_periods(cycles)
+        cycles %= @rate_period + 1 if @hold_zero && @state != :attack
+        return cycles unless cycles.positive?
+
+        cycle!
+        cycles - 1
+      end
+
+      def step
+        if @state == :attack
+          attack_step
+        else
+          @counter = (@counter - 1) & 0xff
+        end
+        set_exponential_period
+      end
+
+      def attack_step
+        @counter = (@counter + 1) & 0xff
+        return unless @counter == 0xff
+
+        @state = :decay_sustain
+        @rate_period = PERIODS[@decay]
+      end
+
+      def sustain_level = (@sustain << 4) | @sustain
+
+      # Reaching zero freezes the envelope until the gate is raised again.
+      def set_exponential_period
+        period = EXPONENTIAL_PERIODS[@counter]
+        return unless period
+
+        @exponential_period = period
+        @hold_zero = true if @counter.zero?
+      end
+    end
+  end
+end

data/lib/badline/sid/filter.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    # The SID's multimode filter: a state-variable design integrating low-,
+    # band- and high-pass in parallel, with the mixer and master volume on
+    # its output, and the C64 board's own RC network after that.
+    #
+    # Voices are routed through it or around it per the RES/FILT register,
+    # and the outputs selected by MODE/VOL are summed back together with the
+    # unfiltered ones.
+    class Filter
+      # Cutoff frequency in Hz at each chip's breakpoints. The 6581 curve was
+      # sampled from a real chip by reSID and bends sharply around $300; the
+      # 8580's is close to a straight line from 0 to 12.5 kHz. The curve
+      # between breakpoints is interpolated linearly; reSID fits a spline, so
+      # the two differ by a few Hz mid-segment.
+      CUTOFF_POINTS = {
+        mos6581: [[0, 220], [128, 230], [256, 250], [384, 300],
+                  [512, 420], [640, 780], [768, 1600], [832, 2300],
+                  [896, 3200], [960, 4300], [1024, 5000], [1088, 5400],
+                  [1152, 5800], [1216, 6000], [1280, 6200], [1344, 6400],
+                  [1408, 6600], [1472, 6800], [1536, 7000], [1600, 7200],
+                  [1664, 7400], [1728, 7600], [1792, 7800], [1856, 8000],
+                  [1920, 8200], [1984, 8400], [2047, 8600]].freeze,
+        mos8580: [[0, 0], [128, 800], [256, 1600], [384, 2500],
+                  [512, 3300], [640, 4100], [768, 4800], [896, 5600],
+                  [1024, 6500], [1152, 7500], [1280, 8400], [1408, 9200],
+                  [1536, 9800], [1664, 10_500], [1792, 11_000],
+                  [1920, 11_700], [2047, 12_500]].freeze
+      }.freeze
+
+      # 2^20 / 1 MHz, so one cycle of integration is a plain shift.
+      SCALE = (2**20) / 1_000_000.0
+
+      # The integrator goes unstable above ~16 kHz at a one-cycle step.
+      W0_MAX = (2 * Math::PI * 16_000 * SCALE).to_i
+
+      # A step of several cycles scales w0 by their count. reSID keeps such
+      # a step stable by capping the cutoff at 4 kHz over 8 cycles; this is
+      # the same bound on the product, so a single cycle is never capped.
+      W0_STEP_MAX = (2 * Math::PI * 4_000 * 8 * SCALE).to_i
+
+      def self.build_w0(points)
+        table = Array.new(2048)
+        points.each_cons(2) do |(fc0, hz0), (fc1, hz1)|
+          (fc0..fc1).each do |register|
+            hz = hz0 + (((hz1 - hz0) * (register - fc0)).to_f / (fc1 - fc0))
+            table[register] = [(2 * Math::PI * hz * SCALE).to_i, W0_MAX].min
+          end
+        end
+        table.freeze
+      end
+      private_class_method :build_w0
+
+      W0 = CUTOFF_POINTS.transform_values { |points| build_w0(points) }.freeze
+
+      # 1024/Q, with Q sweeping from 0.707 up to 1.707 across the register.
+      RESONANCE = (0x0..0xf).map { |res| (1024.0 / (0.707 + (res / 15.0))).to_i }.freeze
+
+      # The mixer's own input DC offset, derived by reSID from the 6581's
+      # zero-volume and full-volume output levels. The 8580 has none.
+      MIXER_DC = { mos6581: -((0xfff * 0xff) / 18) >> 7, mos8580: 0 }.freeze
+
+      # Fractional bits carried in the integrators. At low cutoffs a cycle's
+      # step is only a few units, which truncating to whole units would
+      # swallow, and always toward minus infinity.
+      FRACTION = 12
+
+      # The RC network between the SID's audio pin and the C64's output jack:
+      # a 10kΩ/1000pF low-pass at ~16 kHz, then a 1kΩ/10µF high-pass at
+      # ~16 Hz that strips the 6581's DC offset off the mix.
+      class External
+        W0_LOWPASS = (100_000 * SCALE).round
+        W0_HIGHPASS = (100 * SCALE).round
+
+        # The high-pass step is W0_HIGHPASS/2^20 of the gap, so in whole
+        # units it stalls on any gap under ~10k, as reSID's does. Sixteen
+        # fractional bits bring that under one unit.
+        FRACTION = 16
+
+        # Its input arrives with the filter's fractional bits still on.
+        INPUT_SHIFT = FRACTION - Filter::FRACTION
+
+        attr_reader :output
+
+        def initialize
+          @lowpass = 0
+          @highpass = 0
+          @output = 0
+        end
+
+        # Takes the input in 1/2^Filter::FRACTION units, and reads the
+        # output out in whole ones.
+        def cycle!(input, cycles = 1)
+          delta_lowpass = ((W0_LOWPASS >> 8) * cycles * ((input << INPUT_SHIFT) - @lowpass)) >> 12
+          delta_highpass = (W0_HIGHPASS * cycles * (@lowpass - @highpass)) >> 20
+          @output = (@lowpass - @highpass) >> FRACTION
+          @lowpass += delta_lowpass
+          @highpass += delta_highpass
+          @output
+        end
+      end
+
+      attr_reader :model, :cutoff, :routing, :mode, :volume
+
+      def initialize(model: :mos6581)
+        @model = model
+        @w0_table = W0.fetch(model)
+        @mixer_dc = MIXER_DC.fetch(model)
+        @external = External.new
+        reset
+      end
+
+      def reset
+        @cutoff = 0x000
+        @routing = 0x0
+        @mode = 0x0
+        @volume = 0x0
+        @voice3_off = false
+        @w0 = @w0_table[0]
+        @resonance = RESONANCE[0]
+        @lowpass = @bandpass = @highpass = 0
+        @input = @unfiltered = 0
+      end
+
+      def write(reg, value)
+        case reg
+        when 0x15 then self.cutoff = (@cutoff & 0x7f8) | (value & 0x07)
+        when 0x16 then self.cutoff = (value << 3) | (@cutoff & 0x007)
+        when 0x17 then write_resonance(value)
+        when 0x18 then write_mode_volume(value)
+        end
+      end
+
+      def cutoff=(value)
+        @cutoff = value & 0x7ff
+        @w0 = @w0_table[@cutoff]
+      end
+
+      def voice3_off? = @voice3_off
+
+      def lowpass = @lowpass >> FRACTION
+      def bandpass = @bandpass >> FRACTION
+      def highpass = @highpass >> FRACTION
+
+      # Integrates `cycles` cycles in one step, from the voices' output at
+      # the end of them.
+      def cycle!(voices, cycles = 1)
+        route(voices)
+        w0 = @w0 * cycles
+        w0 = W0_STEP_MAX if w0 > W0_STEP_MAX
+        @bandpass -= (w0 * @highpass) >> 20
+        @lowpass -= (w0 * @bandpass) >> 20
+        @highpass = ((@bandpass * @resonance) >> 10) - @lowpass - (@input << FRACTION)
+        @external.cycle!(fine_mix, cycles)
+      end
+
+      # The SID's own audio pin, before the board's RC network.
+      def mix = fine_mix >> FRACTION
+
+      def output = @external.output
+
+      private
+
+      def write_resonance(value)
+        @routing = value & 0x0f
+        @resonance = RESONANCE[(value >> 4) & 0x0f]
+      end
+
+      def write_mode_volume(value)
+        @volume = value & 0x0f
+        @mode = (value >> 4) & 0x07
+        @voice3_off = value.anybits?(0x80)
+      end
+
+      # Unrolled over the three voices, like SID#clock!. Voice 3 is silenced
+      # by MODE/VOL bit 7 only while it bypasses the filter.
+      def route(voices)
+        voice1, voice2, voice3 = voices
+        @input = 0
+        @unfiltered = 0
+        route_voice(voice1.output >> 7, 0x1)
+        route_voice(voice2.output >> 7, 0x2)
+        if @routing.anybits?(0x4)
+          @input += voice3.output >> 7
+        elsif !@voice3_off
+          @unfiltered += voice3.output >> 7
+        end
+      end
+
+      def route_voice(output, bit)
+        if @routing.anybits?(bit)
+          @input += output
+        else
+          @unfiltered += output
+        end
+      end
+
+      # The mix with the integrators' fractional bits kept, so the RC
+      # network isn't fed the filter's output floored to whole units.
+      def fine_mix = (((@unfiltered + @mixer_dc) << FRACTION) + filtered) * @volume
+
+      def filtered
+        value = 0
+        value += @lowpass  if @mode.anybits?(0x1)
+        value += @bandpass if @mode.anybits?(0x2)
+        value += @highpass if @mode.anybits?(0x4)
+        value
+      end
+    end
+  end
+end

data/lib/badline/sid/voice.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    # One of the three voices: a waveform generator amplitude-modulated by
+    # its envelope.
+    #
+    # The 6581 waveform DAC swings around a midpoint well above ground, so
+    # even a silent voice carries a large DC offset into the mixer. The
+    # 8580's is centred and carries none.
+    class Voice
+      WAVE_ZERO = { mos6581: 0x380, mos8580: 0x800 }.freeze
+      DC_OFFSET = { mos6581: 0x800 * 0xff, mos8580: 0 }.freeze
+
+      attr_reader :waveform, :envelope
+
+      # Each voice hard-syncs and ring-modulates against the previous one,
+      # wrapping from the first back round to the last.
+      def self.linked(count, model:)
+        voices = Array.new(count) { new(model:) }
+        waveforms = voices.map(&:waveform)
+        waveforms.each_with_index do |waveform, i|
+          waveform.sync_source = waveforms[i - 1]
+          waveform.sync_dest = waveforms[(i + 1) % count]
+        end
+        voices
+      end
+
+      def initialize(model: :mos6581)
+        @waveform = Waveform.new(model:)
+        @envelope = Envelope.new
+        @wave_zero = WAVE_ZERO.fetch(model)
+        @dc_offset = DC_OFFSET.fetch(model)
+      end
+
+      def reset!
+        @waveform.reset!
+        @envelope = Envelope.new
+      end
+
+      def control=(value)
+        @waveform.control = value
+        @envelope.control = value
+      end
+
+      def cycle!
+        @envelope.cycle!
+        @waveform.cycle!
+      end
+
+      def fast_forward(cycles)
+        @envelope.fast_forward(cycles)
+        @waveform.fast_forward(cycles)
+      end
+
+      def output
+        ((@waveform.output - @wave_zero) * @envelope.output) + @dc_offset
+      end
+    end
+  end
+end