badline 0.5.1 → 0.6.1

data/lib/badline/reu/saved_state.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  class REU
+    # The REU's state for a snapshot: the REC's registers and the values
+    # its counters start from, an armed or running transfer, the IRQ line,
+    # the transfer's own state and the RAM. The size is the machine's
+    # setup (Snapshot::Setup), so a restore finds an REU of the same size.
+    module SavedState
+      def size_kb = @size_kb
+
+      def save_state(out)
+        out.marker("REU")
+        [@status, @command, @c64, @c64_start, @expansion, @expansion_start, @bank, @bank_start, @length,
+         @length_start, @interrupt_mask, @address_control].each { |value| out.int(value) }
+        out.boolean(@armed).boolean(@requested).boolean(@running).boolean(@irq).boolean(@ba_was_low)
+        @dma.save_state(out)
+        @ram.save_state(out)
+      end
+
+      # The IRQ line comes back as it was without calling back into the
+      # machine, which reads it again afterwards.
+      def load_state(input)
+        input.marker("REU")
+        load_registers(input)
+        @armed = input.boolean?
+        @requested = input.boolean?
+        @running = input.boolean?
+        @irq = input.boolean?
+        @ba_was_low = input.boolean?
+        @dma.load_state(input)
+        @ram.load_state(input)
+      end
+
+      private
+
+      def load_registers(input)
+        @status = input.int
+        @command = input.int
+        @c64 = input.int
+        @c64_start = input.int
+        @expansion = input.int
+        @expansion_start = input.int
+        @bank = input.int
+        @bank_start = input.int
+        @length = input.int
+        @length_start = input.int
+        @interrupt_mask = input.int
+        @address_control = input.int
+      end
+    end
+  end
+end

data/lib/badline/reu.rb

@@ -3,6 +3,7 @@
 require "badline/reu/ram"
 require "badline/reu/dma"
 require "badline/reu/trigger"
+require "badline/reu/saved_state"
 
 module Badline
   # A RAM Expansion Unit: the Commodore 1700 (128K), 1764 (256K) and 1750
@@ -18,6 +19,8 @@ module Badline
   # waits for the CPU's next read cycle with BA high, and Computer then
   # clocks it through #dma_cycle! until it hands the bus back.
   class REU
+    include SavedState
+
     SIZES_KB = [128, 256, 512, 1024, 2048, 4096, 8192, 16_384].freeze
 
     # The registers, by offset.
@@ -74,6 +77,7 @@ module Badline
 
       # The 1700's REC counts 17 address bits, the others' 19.
       span = size_kb == 128 ? 0x20000 : 0x80000
+      @size_kb = size_kb
       size = size_kb * 1024
       @address_mask = [size, span].max - 1
       @bank_bits = size > span ? 0xff : 0x07
@@ -102,9 +106,8 @@ module Badline
     # From the moment the REC asks for the bus until it hands it back.
     def dma? = @requested || @running
 
-    # Whether the REC held the bus on the last cycle clocked. The CPU keeps
-    # it while the REC waits to start, and has it back from the cycle the
-    # REC lets go.
+    # Whether the REC ran a transfer on the last cycle clocked, which it
+    # goes on doing until the cycle it lets go of the bus.
     def holds_bus? = @running
 
     def reset!
@@ -116,7 +119,7 @@ module Badline
       @length = @length_start = 0xffff
       @interrupt_mask = 0x1f
       @address_control = 0x3f
-      @armed = @requested = @running = false
+      @armed = @requested = @running = @ba_was_low = false
       interrupt(false)
     end
 
@@ -154,16 +157,20 @@ module Badline
       request_bus
     end
 
-    # Clocks the REC for a cycle, given the VIC's BA line and whether the
-    # CPU writes on it. A requested transfer starts on the first cycle the
-    # CPU reads with BA high.
-    def dma_cycle!(ba_low, cpu_writing)
+    # Clocks the REC for a cycle, given the VIC's BA line. A requested
+    # transfer starts on the first cycle with BA high as the REC sees it,
+    # even one the CPU writes on. Pinned by REU/rmw-trigger. A fetch
+    # requested on the cycle before BA falls writes its first byte on the
+    # first BA-low cycle as well, and again when it starts. Pinned by
+    # REU/badoublewrite.
+    def dma_cycle!(ba_low)
+      late = ba_low && @vic.reu_ba_late?
       if @requested
-        return if cpu_writing || ba_low
+        return hold_off if ba_low && !late
 
         start_transfer
       end
-      @dma.cycle!(ba_low)
+      @dma.cycle!(ba_low, late, ba_low && @vic.reu_ba_handed_on?)
       end_transfer unless @dma.holds_bus?
     end
 
@@ -235,9 +242,15 @@ module Badline
 
     def request_bus
       @requested = true
+      @ba_was_low = @vic.ba_low?
       @on_dma&.call
     end
 
+    def hold_off
+      @dma.write_ahead(@command & TRANSFER_TYPE, @c64, @expansion | (@bank << 16)) unless @ba_was_low
+      @ba_was_low = true
+    end
+
     def start_transfer
       @requested = false
       @running = true

data/lib/badline/sdl.rb

@@ -1,67 +1,139 @@
 # frozen_string_literal: true
 
-require "fiddle"
-
 module Badline
-  # The libSDL2 calls the window, the gamepads and the audio sink make,
-  # bound through Fiddle, so nothing has to compile against SDL at install
-  # time. Only the library itself has to be present.
-  #
-  # Each function is a constant named after its C name without the prefix:
-  # SDL::RenderClear.call(renderer) calls SDL_RenderClear. They're built
-  # with need_gvl, which skips releasing Ruby's lock around the call: none
-  # of these block for long, and releasing it costs more than most of them.
+  # libSDL2 through Spinel's FFI DSL, the one binding both builds use. The
+  # native build compiles the declarations, and finds the library's
+  # directory (see NativeBuild.sdl2_flags). badline-ruby loads badline/ffi
+  # first, which implements them over Fiddle, so only the library itself
+  # has to be present.
   module SDL
-    class Error < StandardError; end
+    ffi_lib "SDL2"
 
-    # Where package managers put the shared library. dlopen searches the
-    # system paths for the bare names, but not Homebrew's.
-    LIBRARIES = %w[
-      libSDL2-2.0.so.0 libSDL2.so
-      libSDL2-2.0.0.dylib /opt/homebrew/lib/libSDL2-2.0.0.dylib /usr/local/lib/libSDL2-2.0.0.dylib
-      SDL2.dll
-    ].freeze
+    ffi_func :SDL_Init, [:uint32], :int
+    ffi_func :SDL_Quit, [], :void
+    ffi_func :SDL_GetError, [], :str
+    ffi_func :SDL_SetHint, %i[str str], :int
+    ffi_func :SDL_CreateWindow, %i[str int int int int uint32], :ptr
+    ffi_func :SDL_SetWindowTitle, %i[ptr str], :void
+    ffi_func :SDL_DestroyWindow, [:ptr], :void
+    ffi_func :SDL_CreateRenderer, %i[ptr int uint32], :ptr
+    ffi_func :SDL_GetWindowDisplayMode, %i[ptr ptr], :int
+    ffi_func :SDL_DestroyRenderer, [:ptr], :void
+    ffi_func :SDL_RenderSetLogicalSize, %i[ptr int int], :int
+    ffi_func :SDL_CreateTexture, %i[ptr uint32 int int int], :ptr
+    ffi_func :SDL_DestroyTexture, [:ptr], :void
+    ffi_func :SDL_UpdateTexture, %i[ptr ptr int_array int], :int
+    ffi_func :SDL_RenderClear, [:ptr], :int
+    ffi_func :SDL_SetRenderDrawColor, %i[ptr int int int int], :int
+    ffi_func :SDL_RenderFillRect, %i[ptr ptr], :int
+    ffi_func :SDL_RenderCopy, %i[ptr ptr ptr ptr], :int
+    ffi_func :SDL_RenderPresent, [:ptr], :void
+    ffi_func :SDL_PollEvent, [:ptr], :int
+    ffi_func :SDL_SetRelativeMouseMode, [:int], :int
+    ffi_func :SDL_Delay, [:uint32], :void
+    ffi_func :SDL_GetRendererOutputSize, %i[ptr ptr ptr], :int
+    ffi_func :SDL_RenderReadPixels, %i[ptr ptr uint32 ptr int], :int
+    ffi_func :SDL_CreateRGBSurfaceWithFormatFrom, %i[ptr int int int int uint32], :ptr
+    ffi_func :SDL_FreeSurface, [:ptr], :void
+    ffi_func :SDL_RWFromFile, %i[str str], :ptr
+    ffi_func :SDL_SaveBMP_RW, %i[ptr ptr int], :int
+    ffi_func :SDL_InitSubSystem, [:uint32], :int
+    ffi_func :SDL_QuitSubSystem, [:uint32], :void
+    ffi_func :SDL_OpenAudioDevice, %i[ptr int ptr ptr int], :uint32
+    ffi_func :SDL_CloseAudioDevice, [:uint32], :void
+    ffi_func :SDL_PauseAudioDevice, %i[uint32 int], :void
+    ffi_func :SDL_QueueAudio, %i[uint32 buffer_in uint32], :int
+    ffi_func :SDL_GetQueuedAudioSize, [:uint32], :uint32
+    ffi_func :SDL_NumJoysticks, [], :int
+    ffi_func :SDL_IsGameController, [:int], :int
+    ffi_func :SDL_GameControllerOpen, [:int], :ptr
+    ffi_func :SDL_GameControllerClose, [:ptr], :void
+    ffi_func :SDL_GameControllerName, [:ptr], :str
+    ffi_func :SDL_GameControllerGetButton, %i[ptr int], :uint8
+    ffi_func :SDL_GameControllerGetAxis, %i[ptr int], :int16
+    ffi_func :SDL_ClearQueuedAudio, [:uint32], :void
+    ffi_func :SDL_GetCurrentDisplayMode, %i[int ptr], :int
+    ffi_func :SDL_CreateRGBSurfaceFrom, %i[ptr int int int int uint32 uint32 uint32 uint32], :ptr
+    ffi_func :SDL_CreateTextureFromSurface, %i[ptr ptr], :ptr
+    ffi_func :SDL_PushEvent, [:ptr], :int
+    ffi_func :SDL_GetKeyName, [:int], :str
 
-    def self.open_library
-      LIBRARIES.each do |name|
-        return Fiddle.dlopen(name)
-      rescue Fiddle::DLError
-        next
-      end
-      raise Error, "can't find libSDL2 (tried #{LIBRARIES.join(', ')})"
-    end
+    ffi_buffer :event, 56
+    ffi_read_u32 :event_type, 0
+    ffi_read_u8 :event_repeat, 13
+    ffi_read_i32 :event_scancode, 16
+    ffi_read_i32 :event_sym, 20
+    ffi_read_u16 :event_mod, 24
+    # SDL_MouseMotionEvent's xrel and yrel, and SDL_MouseButtonEvent's
+    # button.
+    ffi_read_i32 :event_xrel, 28
+    ffi_read_i32 :event_yrel, 32
+    ffi_read_u8 :event_button, 16
 
-    LIBRARY = open_library
+    ffi_buffer :rect, 16
+    ffi_write_i32 :rect_x, 0
+    ffi_write_i32 :rect_y, 4
+    ffi_write_i32 :rect_w, 8
+    ffi_write_i32 :rect_h, 12
+    # Where the drive LED goes.
+    ffi_buffer :led_rect, 16
 
-    VOID = Fiddle::TYPE_VOID
-    INT = Fiddle::TYPE_INT
-    UINT8 = Fiddle::TYPE_UINT8_T
-    INT16 = Fiddle::TYPE_INT16_T
-    UINT32 = Fiddle::TYPE_UINT32_T
-    POINTER = Fiddle::TYPE_VOIDP
-    STRING = Fiddle::TYPE_CONST_STRING
+    # SDL_DisplayMode: Uint32 format; int w, h, refresh_rate; then a pointer.
+    ffi_buffer :display_mode, 24
+    ffi_read_i32 :mode_refresh, 12
 
-    def self.function(name, arguments, result)
-      Fiddle::Function.new(LIBRARY[name], arguments, result, name:, need_gvl: true)
-    end
+    ffi_buffer :output_w, 4
+    ffi_buffer :output_h, 4
+    ffi_read_i32 :read_i32, 0
 
-    def self.error = GetError.call
+    # SDL_AudioSpec: int freq; Uint16 format; Uint8 channels, silence;
+    # Uint16 samples, padding; Uint32 size; then two pointers.
+    ffi_buffer :wanted, 32
+    ffi_buffer :obtained, 32
+    ffi_write_i32 :spec_freq, 0
+    ffi_write_u16 :spec_format, 4
+    ffi_write_u8 :spec_channels, 6
+    ffi_write_u16 :spec_samples, 8
 
-    # A negative result from SDL is an error, and SDL_GetError says which.
-    def self.check(result)
-      raise Error, error if result.negative?
+    ffi_const :INIT_AUDIO, 0x10
+    ffi_const :INIT_VIDEO, 0x20
+    ffi_const :INIT_GAMECONTROLLER, 0x2000
+    ffi_const :INIT_EVENTS, 0x4000
+    ffi_const :WINDOWPOS_CENTERED, 0x2fff0000
+    ffi_const :WINDOW_RESIZABLE, 0x20
+    ffi_const :RENDERER_ACCELERATED, 0x02
+    ffi_const :RENDERER_PRESENTVSYNC, 0x04
+    ffi_const :PIXELFORMAT_RGB888, 0x16161804
+    ffi_const :TEXTUREACCESS_STREAMING, 1
+    ffi_const :QUIT, 0x100
+    ffi_const :KEYDOWN, 0x300
+    ffi_const :KEYUP, 0x301
+    ffi_const :MOUSEMOTION, 0x400
+    ffi_const :MOUSEBUTTONDOWN, 0x401
+    ffi_const :MOUSEBUTTONUP, 0x402
+    ffi_const :KMOD_SHIFT, 0x0003
+    ffi_const :CONTROLLERDEVICEADDED, 0x653
+    ffi_const :CONTROLLERDEVICEREMOVED, 0x654
+    ffi_const :CONTROLLERDEVICEREMAPPED, 0x655
+    ffi_const :AUDIO_S16LSB, 0x8010
+    ffi_const :ALLOW_FREQUENCY_CHANGE, 0x01
+    ffi_const :KEY_TAB, 0x09
+    ffi_const :KEY_F10, 0x4000_0043
+    ffi_const :KEY_F11, 0x4000_0044
+    ffi_const :KEY_F12, 0x4000_0045
+  end
 
-      result
-    end
+  # The few C library calls the native front end makes.
+  module LibC
+    ffi_func :malloc, [:size_t], :ptr
+    ffi_func :free, [:ptr], :void
+    ffi_func :poll, %i[ptr size_t int], :int
 
-    # So is a null handle.
-    def self.check_pointer(pointer)
-      raise Error, error if pointer.null?
+    ffi_const :POLLIN, 0x01
 
-      pointer
-    end
+    # struct pollfd: int fd; short events, revents.
+    ffi_buffer :pollfd, 8
+    ffi_write_i32 :pollfd_fd, 0
+    ffi_write_i16 :pollfd_events, 4
   end
 end
-
-require "badline/sdl/functions"
-require "badline/sdl/events"

data/lib/badline/sid/envelope/state.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    class Envelope
+      # A snapshot of an envelope: its rates, the gate, the state and the
+      # counters and pipelines between them, and the same fields as reSID
+      # keeps them, for VICE's SIDEXTENDED module.
+      module State
+        # The fields reSID keeps for an envelope between cycles: the rate and
+        # exponential counters, the level, the state as an index into STATES,
+        # whether it holds at zero, the two periods and the pipeline.
+        def resid_fields
+          [@rate_counter, @exponential_counter, @counter, STATES.index(@state).to_i, @hold_zero ? 1 : 0,
+           @rate_period, @exponential_period, @envelope_pipeline]
+        end
+
+        # Takes the fields resid_fields gives from `fields`, from `at` on.
+        def restore_resid_fields(fields, at)
+          @rate_counter = fields[at]
+          @exponential_counter = fields[at + 1]
+          @counter = @env3 = fields[at + 2]
+          state = fields[at + 3]
+          @state = @next_state = STATES.fetch(state.clamp(0, STATES.length - 1)).to_sym
+          @hold_zero = fields[at + 4] != 0
+          @rate_period = fields[at + 5]
+          @exponential_period = fields[at + 6]
+          @envelope_pipeline = fields[at + 7]
+        end
+
+        def save_state(out)
+          [@attack, @decay, @sustain, @release].each { |rate| out.int(rate) }
+          out.boolean(@gate).int(STATES.index(@state)).int(STATES.index(@next_state))
+          out.int(@counter).int(@env3).int(@rate_counter).int(@rate_period).boolean(@reset_rate_counter)
+          out.int(@exponential_counter).int(@exponential_period)
+          out.int(@state_pipeline).int(@envelope_pipeline).int(@exponential_pipeline).boolean(@hold_zero)
+        end
+
+        def load_state(input)
+          @attack = input.int
+          @decay = input.int
+          @sustain = input.int
+          @release = input.int
+          @gate = input.boolean?
+          @state = STATES.fetch(input.int).to_sym
+          @next_state = STATES.fetch(input.int).to_sym
+          load_counters(input)
+        end
+
+        private
+
+        def load_counters(input)
+          @counter = input.int
+          @env3 = input.int
+          @rate_counter = input.int
+          @rate_period = input.int
+          @reset_rate_counter = input.boolean?
+          @exponential_counter = input.int
+          @exponential_period = input.int
+          @state_pipeline = input.int
+          @envelope_pipeline = input.int
+          @exponential_pipeline = input.int
+          @hold_zero = input.boolean?
+        end
+      end
+    end
+  end
+end

data/lib/badline/sid/envelope.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/sid/envelope/state"
+
 module Badline
   class SID
     # ADSR envelope generator.
@@ -25,6 +27,11 @@ module Badline
       EXPONENTIAL_PERIODS = { 0xff => 1, 0x5d => 2, 0x36 => 4, 0x1a => 8,
                               0x0e => 16, 0x06 => 30, 0x00 => 1 }.freeze
 
+      # The states a snapshot names by index.
+      STATES = %i[attack decay_sustain release].freeze
+
+      include State
+
       attr_reader :state, :counter, :env3
 
       def initialize

data/lib/badline/sid/filter.rb

@@ -90,6 +90,16 @@ module Badline
           @output = 0
         end
 
+        def save_state(out)
+          out.int(@lowpass).int(@highpass).int(@output)
+        end
+
+        def load_state(input)
+          @lowpass = input.int
+          @highpass = input.int
+          @output = input.int
+        end
+
         # Takes the input in 1/2^Filter::FRACTION units, and reads the
         # output out in whole ones.
         def cycle!(input, cycles = 1)
@@ -124,6 +134,25 @@ module Badline
         @input = @unfiltered = 0
       end
 
+      # The registers as the filter decoded them and its integrators. The
+      # W0 table is the model's.
+      def save_state(out)
+        out.int(@cutoff).int(@routing).int(@mode).int(@volume).boolean(@voice3_off).int(@w0).int(@resonance)
+        [@highpass, @bandpass, @lowpass, @unfiltered, @input].each { |value| out.int(value) }
+        @external.save_state(out)
+      end
+
+      def load_state(input)
+        @cutoff = input.int
+        @routing = input.int
+        @mode = input.int
+        @volume = input.int
+        @voice3_off = input.boolean?
+        @w0 = input.int
+        @resonance = input.int
+        load_integrators(input)
+      end
+
       def write(reg, value)
         case reg
         when 0x15 then self.cutoff = (@cutoff & 0x7f8) | (value & 0x07)
@@ -163,6 +192,15 @@ module Badline
 
       private
 
+      def load_integrators(input)
+        @highpass = input.int
+        @bandpass = input.int
+        @lowpass = input.int
+        @unfiltered = input.int
+        @input = input.int
+        @external.load_state(input)
+      end
+
       def write_resonance(value)
         @routing = value & 0x0f
         @resonance = RESONANCE[(value >> 4) & 0x0f]

data/lib/badline/sid/voice.rb

@@ -38,6 +38,16 @@ module Badline
         @envelope = Envelope.new
       end
 
+      def save_state(out)
+        @waveform.save_state(out)
+        @envelope.save_state(out)
+      end
+
+      def load_state(input)
+        @waveform.load_state(input)
+        @envelope.load_state(input)
+      end
+
       def control=(value)
         @waveform.control = value
         @envelope.control = value

data/lib/badline/sid/waveform/noise_writeback.rb

@@ -20,11 +20,12 @@ module Badline
         # so they lose a different number of bits. The 8580's pair is the one
         # that reproduces SID/wf12nsr's pulse+noise row (it reads $f8, and the
         # writeback leaves $fc behind), and SID/wb_testsuite's C->9 and C->E
-        # rows need that same $fc written at release. On the 6581 the read is
-        # the $fc of SID/wf12nsr's readme (VICE bug #1037), and the writeback
-        # pulls nothing: wb_testsuite's 8/9/A/B->C rows run pulse+noise and
-        # leave the register alone.
-        PULSE_NOISE_READ = { mos6581: 0xfc0, mos8580: 0xf80 }.freeze
+        # rows need that same $fc written at release. The 6581 reads $00 of a
+        # full register (SID/wf12nsr's pulse+noise row) and pulls nothing
+        # while the register holds: wb_testsuite's 8->C and C->C rows run
+        # pulse+noise and leave the register alone. Its lines only land
+        # part way through a shift (#write_back_shift).
+        PULSE_NOISE_READ = { mos6581: 0x000, mos8580: 0xf80 }.freeze
         PULSE_NOISE_WRITE = { mos6581: 0xff0, mos8580: 0xfc0 }.freeze
 
         # What a 6581 writes back when the test bit falls with only pulse+noise
@@ -40,24 +41,45 @@ module Badline
         # (SID/wf12nsr's noise+triangle and noise+sawtooth rows).
         def write_back(selected, value)
           return value & ((value << 1) | (value >> 1)) unless selected == 0xc
-          return value if value.zero?
+          return 0x000 if @pulse.zero?
 
           noise & @pulse_noise_write
         end
 
+        # What the lines write while the register is part way through a
+        # shift, where the 6581's pulse+noise writes its output as read.
+        def write_back_mid_shift(selected, value)
+          return value if pulse_noise_mid_shift?(selected)
+
+          write_back(selected, value)
+        end
+
+        def pulse_noise_mid_shift?(selected) = @topbit_feedback && selected == 0xc
+
         def write_shift_register(value)
           NOISE_TAPS.each { |bit, line| @shift_register &= ~bit if value.nobits?(line) }
         end
 
-        # Setting the test bit starts the bleed, and writes the output of a
-        # noise combination back first, from the accumulator it had. Only
-        # SID/noiselfsrinit sets the bit onto such a combination from outside
-        # it: its $f8/$80 pairs go from noise alone to all four.
+        # The second phase of a shift writes back by the test bit release
+        # rule with the waveform left alone. The 6581's pulse+noise, which
+        # that rule leaves out, writes its lines too (SID/wf12nsr's
+        # pulse+noise row).
+        def write_back_shift
+          return unless pulse_noise_mid_shift?(@selected) || release_writes_back?(@selected, @selected)
+
+          write_shift_register(write_back_mid_shift(@selected, @output))
+        end
+
+        # Setting the test bit starts the bleed, and stalls the register part
+        # way through a shift, where a noise combination writes its output
+        # back first, from the accumulator it had. SID/noiselfsrinit's
+        # $f8/$80 pairs set the bit onto all four from noise alone, and
+        # SID/wf12nsr's pulse+noise row sets it onto pulse+noise.
         def raise_test
           @shift_register_reset = @shift_register_reset_delay
           return unless @selected.anybits?(0x8) && combined?(@selected) && @shift_pipeline != 1
 
-          write_shift_register(write_back(@selected, shape(@selected)))
+          write_shift_register(write_back_mid_shift(@selected, shape(@selected)))
         end
 
         # Releasing the test bit finishes the shift it interrupted: the old

data/lib/badline/sid/waveform/state.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    class Waveform
+      # A snapshot of an oscillator: its phase, the noise register and the
+      # output latch, and the same fields as reSID keeps them, for VICE's
+      # SIDEXTENDED module. The model's tables and the voices it syncs with
+      # are the SID's wiring.
+      module State
+        # The fields reSID keeps for an oscillator between cycles: the phase,
+        # the noise register, its shift pipeline and reset countdown, the
+        # floating output's countdown and the pulse level.
+        def resid_fields
+          [@accumulator, @shift_register, @shift_pipeline, @shift_register_reset, @floating_ttl, @pulse]
+        end
+
+        # Takes the fields resid_fields gives from `fields`, from `at` on.
+        def restore_resid_fields(fields, at)
+          @accumulator = fields[at]
+          @shift_register = fields[at + 1]
+          @shift_pipeline = fields[at + 2]
+          @shift_register_reset = fields[at + 3]
+          @floating_ttl = fields[at + 4]
+          @pulse = fields[at + 5]
+          @stale = true
+        end
+
+        def save_state(out)
+          out.int(@accumulator).int(@delayed_triangle).int(@delayed_sawtooth)
+          out.int(@shift_register).int(@shift_register_reset).int(@shift_pipeline)
+          out.int(@frequency).int(@pulse_width).int(@selected)
+          [@test, @ring, @sync, @msb_rising].each { |flag| out.boolean(flag) }
+          out.int(@floating).int(@floating_ttl).int(@pulse).int(@output).boolean(@stale)
+        end
+
+        def load_state(input)
+          @accumulator = input.int
+          @delayed_triangle = input.int
+          @delayed_sawtooth = input.int
+          @shift_register = input.int
+          @shift_register_reset = input.int
+          @shift_pipeline = input.int
+          @frequency = input.int
+          @pulse_width = input.int
+          @selected = input.int
+          load_latches(input)
+        end
+
+        private
+
+        def load_latches(input)
+          @test = input.boolean?
+          @ring = input.boolean?
+          @sync = input.boolean?
+          @msb_rising = input.boolean?
+          @floating = input.int
+          @floating_ttl = input.int
+          @pulse = input.int
+          @output = input.int
+          @stale = input.boolean?
+        end
+      end
+    end
+  end
+end

data/lib/badline/sid/waveform.rb

@@ -3,6 +3,7 @@
 require "badline/sid/waveform/combined"
 require "badline/sid/waveform/fast_forward"
 require "badline/sid/waveform/noise_writeback"
+require "badline/sid/waveform/state"
 
 module Badline
   class SID
@@ -27,6 +28,7 @@ module Badline
     class Waveform
       include FastForward
       include NoiseWriteback
+      include State
 
       # All bits high at power up, odd ones stored inverted (SID/oscinit).
       POWER_ON_ACCUMULATOR = 0x555555
@@ -254,8 +256,7 @@ module Badline
       # A rise of bit 19 starts a shift that takes two more cycles
       # (SID/noisewriteback's noise_writeback_test2, after libresidfp's shift
       # pipeline). The first phase latches the output, and the second writes
-      # it over the taps, by the test bit release rule with the waveform left
-      # alone, before the register shifts.
+      # it over the taps before the register shifts.
       def advance
         previous = @accumulator
         @accumulator = (previous + @frequency) & 0xffffff
@@ -263,7 +264,7 @@ module Badline
         if @accumulator & ~previous & 0x080000 != 0
           @shift_pipeline = 2
         elsif @shift_pipeline != 0 && (@shift_pipeline -= 1).zero?
-          write_shift_register(write_back(@selected, @output)) if release_writes_back?(@selected, @selected)
+          write_back_shift
           shift_noise
         end
       end