badline 0.8.0 → 0.10.0

data/lib/badline/audio/renderer.rb

@@ -35,10 +35,15 @@ module Badline
 
       # Where #stream starts: the frames before it are rendered as fast as
       # they go and yielded without their samples, so the seconds rendered
-      # still count up to it. Set while streaming, it skips ahead from the
-      # frame rendered last.
+      # still count up to it. Rendering picks up from the latest of the
+      # checkpoints at or before it, without the frames before that. Set
+      # while streaming, it skips ahead from the frame rendered last.
       attr_writer :from
 
+      # The Checkpoints this subtune's renderers keep as they go and start
+      # from, for a player that seeks. Without them nothing is kept.
+      attr_writer :checkpoints
+
       def initialize(tune, seconds:, subtune: nil, rate: DEFAULT_RATE, sid_models: tune.sid_models)
         @tune = tune
         @seconds = seconds
@@ -52,6 +57,8 @@ module Badline
         @rendered = 0.0
         @observer = ->(_samples, _rendered) {}
         @from = 0.0
+        @played = 0
+        @checkpoints = nil
       end
 
       def silence=(seconds)
@@ -65,7 +72,6 @@ module Badline
       # Yields the seconds rendered so far after every frame.
       def render(path)
         container = container_for(path)
-        player.start
         container.open(path, rate: @rate, channels: 2) do |writer|
           each_frame do |samples, seconds|
             samples.each { |sample| writer << sample }
@@ -76,9 +82,16 @@ module Badline
 
       # Starts the tune, then yields each frame's samples along with the
       # seconds rendered so far.
-      def stream(&)
-        player.start
-        each_frame(&)
+      def stream(&) = each_frame(&)
+
+      # Whether the latest checkpoint at or before `seconds` lies past the
+      # frame rendered last, so that a seek there gets there sooner from it
+      # than on from here.
+      def checkpoint_ahead?(seconds)
+        checkpoints = @checkpoints
+        return false if checkpoints.nil?
+
+        checkpoints.reach((seconds * player.clock_hz).round) > @played
       end
 
       private
@@ -101,19 +114,77 @@ module Badline
       end
 
       def each_frame
-        player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
+        clock_hz = player.clock_hz
         total = total_cycles
-        remaining = total
+        @played = start((@from * clock_hz).round)
+        remaining = total - @played
         while remaining.positive?
           samples = []
           remaining -= player.frame(remaining) { |sample| samples << sample }
-          @rendered = (total - remaining).fdiv(player.clock_hz)
+          played = total - remaining
+          @played = played
+          @rendered = played.fdiv(clock_hz)
           @observer.call(samples, @rendered)
           yield(@rendered < @from ? [] : samples, @rendered)
           break if fallen_silent?(samples)
+
+          save_checkpoint(played, clock_hz)
         end
       end
 
+      # Starts the player and its recording, from the latest checkpoint at
+      # or before `cycles` if there is one, and returns the cycles into the
+      # subtune it starts at.
+      def start(cycles)
+        state = @checkpoints&.latest(cycles)
+        return start_afresh if state.nil?
+
+        input = Snapshot::StateReader.new(state)
+        played = input.int
+        resume(input)
+        record
+        player.stereo.sids.each { |sid| sid.load_recording(input) }
+        @level = input.int
+        @still = input.int
+        played
+      end
+
+      def start_afresh
+        player.start
+        record
+        0
+      end
+
+      def record = player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
+
+      # Restores the player as it was, then puts back the SID models chosen
+      # for this renderer.
+      def resume(input)
+        sids = player.stereo.sids
+        chosen = sids.map(&:model)
+        sids.each { |sid| refit(sid, Snapshot::Setup::SID_MODELS.fetch(input.int)) }
+        player.load_state(input)
+        sids.each_with_index { |sid, index| refit(sid, chosen[index]) }
+      end
+
+      def refit(sid, model)
+        sid.model = model unless sid.model == model
+      end
+
+      def save_checkpoint(played, clock_hz)
+        checkpoints = @checkpoints
+        return if checkpoints.nil? || !checkpoints.due?(played, clock_hz)
+
+        sids = player.stereo.sids
+        out = Snapshot::StateWriter.new
+        out.int(played)
+        sids.each { |sid| out.int(Snapshot::Setup::SID_MODELS.index(sid.model) || 0) }
+        player.save_state(out)
+        sids.each { |sid| sid.save_recording(out) }
+        out.int(@level).int(@still)
+        checkpoints.keep(played, out.state)
+      end
+
       # Counts the samples since the output last strayed more than QUIET
       # from where it settled.
       def fallen_silent?(samples)

data/lib/badline/audio/stereo.rb

@@ -65,11 +65,9 @@ module Badline
       private
 
       def both(samples)
-        i = 0
-        while i < samples.size
-          yield samples[i]
-          yield samples[i]
-          i += 1
+        samples.each do |sample|
+          yield sample
+          yield sample
         end
       end
 

data/lib/badline/audio.rb

@@ -6,6 +6,7 @@ require "badline/audio/aiff"
 require "badline/audio/stereo"
 require "badline/audio/bare_player"
 require "badline/audio/machine_player"
+require "badline/audio/checkpoints"
 require "badline/audio/renderer"
 require "badline/audio/playback"
 require "badline/audio/terminal"

data/lib/badline/chrout_trap.rb

@@ -2,7 +2,7 @@
 
 module Badline
   # Observe-only PC trap on the KERNAL CHROUT routine ($FFD2). Records each
-  # character written while the KERNAL is banked in, then lets execution fall
+  # character written while the layout finds the KERNAL mapped in, then lets execution fall
   # through to the ROM, so the screen output is unaffected. Used for headless
   # capture of program output.
   class ChroutTrap
@@ -10,14 +10,15 @@ module Badline
 
     attr_reader :output
 
-    def initialize(cpu:, bus:)
+    def initialize(cpu:, bus:, layout:)
       @cpu = cpu
       @bus = bus
+      @layout = layout
       @output = +""
     end
 
     def call
-      @output << ascii(@cpu.a) if @bus.io_port.kernal?
+      @output << ascii(@cpu.a) if @layout.kernal_mapped?(@bus)
     end
 
     def inspect

data/lib/badline/computer/attachments.rb

@@ -22,11 +22,13 @@ module Badline
         return @drive.insert(storage) if @drive
 
         @drive = KernalTrap::Drive.new(storage)
-        load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, drive: @drive)
-        cpu.install_trap(KernalTrap::Load::ADDRESS) { load_trap.call }
-        @serial_trap = KernalTrap::Serial.new(cpu:, bus: address_bus, drive: @drive, device: serial_trap_device).install
-        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, drive: @drive)
-        cpu.install_trap(KernalTrap::Save::ADDRESS) { save_trap.call }
+        layout = KernalTrap::C64_LAYOUT
+        load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, layout:, drive: @drive)
+        cpu.install_trap(layout.load) { load_trap.call }
+        @serial_trap = KernalTrap::Serial.new(cpu:, bus: address_bus, layout:, drive: @drive,
+                                              device: serial_trap_device).install
+        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, layout:, drive: @drive)
+        cpu.install_trap(layout.save) { save_trap.call }
       end
 
       # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
@@ -35,8 +37,8 @@ module Badline
       def unmount
         return unless @drive
 
-        cpu.remove_trap(KernalTrap::Load::ADDRESS)
-        cpu.remove_trap(KernalTrap::Save::ADDRESS)
+        cpu.remove_trap(KernalTrap::C64_LAYOUT.load)
+        cpu.remove_trap(KernalTrap::C64_LAYOUT.save)
         @serial_trap.device = nil
         @serial_trap = nil
         @save_trap = nil
@@ -46,17 +48,55 @@ module Badline
       # Whether device 8 serves a disk or directory through the traps.
       def mounted? = !@drive.nil?
 
+      # The serial bus, which CIA 2's port A drives through the C64's own
+      # inverters and reads back on PA6 and PA7, with or without a drive on
+      # it.
+      attr_reader :iec_bus
+
+      # Plugs in a Drive1541, which then runs alongside the C64 on its own
+      # clock and talks to it over the serial bus. The serial traps stop
+      # answering the drive's device number, so the KERNAL's TALK, LISTEN and
+      # byte transfers reach the drive. The LOAD and SAVE traps stay, and
+      # still serve a mounted image.
+      def attach_drive1541(drive)
+        @iec_bus.detach(@drive1541) if @drive1541
+        drive.host_clock_hz = region.clock_hz
+        @drive1541 = drive
+        drive.connect(iec_bus)
+        @serial_trap&.device = serial_trap_device
+      end
+
       # Unplugs the Drive1541, leaving the serial bus with nothing on it.
       def detach_drive1541
         return unless @drive1541
 
-        @iec_bus&.detach(@drive1541)
+        @iec_bus.detach(@drive1541)
         @drive1541 = nil
         @serial_trap&.device = serial_trap_device
       end
 
       private
 
+      # The device number the serial traps answer: device 8, unless a true
+      # drive is on the bus as device 8.
+      def serial_trap_device
+        @drive1541&.device == KernalTrap::Routine::DEVICE ? nil : KernalTrap::Routine::DEVICE
+      end
+
+      # CIA 2's port A drives the serial bus, which reads CLK and DATA back
+      # into it.
+      def plug_serial_bus
+        @iec_bus = IECBus.new
+        @cia2.peripheral = @iec_bus
+        @cia2.on_port_a_write { push_serial_lines }
+        push_serial_lines
+      end
+
+      # Pushes the lines CIA 2's port A pulls into the serial bus.
+      def push_serial_lines
+        @iec_bus.host_lines = @cia2.port_a_lines
+      end
+
       def save_cartridge(out)
         cartridge = address_bus.cartridge
         out.boolean(!cartridge.nil?)
@@ -95,10 +135,10 @@ module Badline
         @save_trap.load_state(input)
       end
 
-      # The serial bus, whose presence decides what CIA 2's port A reads,
-      # and a true 1541 on it.
+      # A true 1541 on the serial bus. The leading flag is the bus itself,
+      # which every machine now has, kept so older snapshots still load.
       def save_serial_bus(out)
-        out.boolean(!@iec_bus.nil?).boolean(!@drive1541.nil?)
+        out.boolean(true).boolean(!@drive1541.nil?)
         return unless @drive1541
 
         out.int(@drive1541.device)
@@ -106,7 +146,7 @@ module Badline
       end
 
       def load_serial_bus(input)
-        iec_bus if input.boolean?
+        input.boolean?
         return detach_drive1541 unless input.boolean?
 
         device = input.int

data/lib/badline/computer/saved_state.rb

@@ -97,6 +97,7 @@ module Badline
         @init_handlers_lost = [input.int - @init_handlers.length, 0].max
         load_cartridge(input)
         address_bus.load_state(input)
+        push_serial_lines
         @cpu.load_state(input)
         load_trap_drive(input)
         load_serial_bus(input)

data/lib/badline/computer.rb

@@ -12,6 +12,12 @@ module Badline
 
     attr_reader :address_bus, :cpu, :cycles, :drive1541
 
+    # The path of the disk or directory device 8 serves through the traps
+    # (Attachments), or an empty one.
+    def mounted_path = @drive.nil? ? "" : @drive.path
+
+    def family = :c64
+
     def region = address_bus.region
 
     def vic = address_bus.vic
@@ -42,9 +48,13 @@ module Badline
     # TOD clocks count. The KERNAL tells PAL from NTSC by the raster, so
     # every region boots the same ROMs. reu plugs an REU of that many K
     # into the expansion port, where it drives the IRQ line and takes the
-    # bus for its transfers.
-    def initialize(debug: false, reu: nil, **machine)
+    # bus for its transfers. kernal: names the KERNAL ROM
+    # (AddressBus::ROMs::KERNALS), and datasette: false leaves the cassette port
+    # empty, as on the SX-64.
+    def initialize(debug: false, reu: nil, kernal: :c64, datasette: true, **machine)
       @address_bus = AddressBus.new(**machine)
+      @address_bus.kernal = kernal unless kernal == :c64
+      @address_bus.datasette.disconnect! unless datasette
       @cpu = CPU.new(@address_bus, debug:)
       @vic = @address_bus.vic
       @vic.open_bus = -> { @address_bus.ram.peek(@cpu.program_counter) }
@@ -66,7 +76,7 @@ module Badline
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
-      @iec_bus = nil
+      plug_serial_bus
       @reu = reu ? plug_reu(reu) : nil
     end
 
@@ -94,6 +104,40 @@ module Badline
       @cycles += 1
     end
 
+    # Runs `count` cycles, one #cycle! after another.
+    def run_cycles(count)
+      i = 0
+      while i < count
+        cycle!
+        i += 1
+      end
+    end
+
+    # Runs cycles until the block returns true or the cycle count passes
+    # `limit`, checking before each cycle.
+    def run_until(limit)
+      cycle! until yield || @cycles > limit
+    end
+
+    # The cycle at which #on_init's handlers run, once the KERNAL has booted.
+    def init_threshold
+      INIT_THRESHOLD
+    end
+
+    # The clock, the raster and the crop of the machine's region, a pixel
+    # to a window pixel.
+    def timing
+      region = address_bus.region
+      Timing.new(clock_hz: region.clock_hz, cycles_per_line: region.cycles_per_line,
+                 lines_per_frame: region.lines_per_frame, crop: region.crop, pixel_width: 1)
+    end
+
+    # The chip whose #display a front end shows.
+    def video = @vic
+
+    # The chip a front end records the machine's sound from.
+    def sound_source = @sid
+
     def load_prg(data)
       uint16(data[0], data[1]).tap do |load_addr|
         ram.write(load_addr, data[2..])
@@ -155,28 +199,11 @@ module Badline
       @restore_pulse = true
     end
 
-    # Plugs in a Drive1541, which then runs alongside the C64 on its own
-    # clock and talks to it over the serial bus. The serial traps stop
-    # answering the drive's device number, so the KERNAL's TALK, LISTEN and
-    # byte transfers reach the drive. The LOAD and SAVE traps stay, and
-    # still serve a mounted image.
-    def attach_drive1541(drive)
-      @iec_bus.detach(@drive1541) if @iec_bus && @drive1541
-      drive.host_clock_hz = region.clock_hz
-      @drive1541 = drive
-      drive.connect(iec_bus)
-      @serial_trap&.device = serial_trap_device
-    end
-
-    # The serial bus. CIA 2's port A joins it the first time it's asked
-    # for, which plugging in a drive does. Until then port A's serial
-    # inputs float high.
-    def iec_bus
-      @iec_bus ||= IECBus.new(host: @cia2).tap(&:plug_in!)
-    end
+    # The one-shot has pulsed already, so letting go does nothing.
+    def release_restore; end
 
     def capture_output
-      @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus).tap do |trap|
+      @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus, layout: KernalTrap::C64_LAYOUT).tap do |trap|
         cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
       end
     end
@@ -195,12 +222,6 @@ module Badline
 
     private
 
-    # The device number the serial traps answer: device 8, unless a true
-    # drive is on the bus as device 8.
-    def serial_trap_device
-      @drive1541&.device == KernalTrap::Routine::DEVICE ? nil : KernalTrap::Routine::DEVICE
-    end
-
     # The NMI line is wired-OR between CIA 2, the cartridge and the RESTORE
     # key, and the CPU takes an interrupt on its falling edge.
     def drive_nmi
@@ -256,9 +277,5 @@ module Badline
     def handle_init
       @init_handlers.each(&:call)
     end
-
-    def init_threshold
-      INIT_THRESHOLD
-    end
   end
 end

data/lib/badline/control_ports.rb

@@ -16,13 +16,19 @@ module Badline
   # resistances; close neither and the lines float high. Reading a pot asks the
   # CIA for the current select lines, since a program sets them and then goes
   # straight to SID without touching the ports again.
+  #
+  # A matrix may have rows beyond port A's eight. Their select lines come from
+  # outside the CIA and are pushed into +extra_rows+, bit 0 for the ninth row
+  # upwards, active low like port A; idle, every line is high and none of
+  # those rows is selected. They settle with port A's lines as rows 8 and up,
+  # so their keys reach port B, but port A reads only its own eight.
   class ControlPorts
     PORT1_POTS = 0x40
     PORT2_POTS = 0x80
     FIRE = 0x10
 
     attr_reader :keyboard, :joystick1, :joystick2
-    attr_accessor :device1, :device2, :port_a_source
+    attr_accessor :device1, :device2, :port_a_source, :extra_rows
 
     def initialize(keyboard:, joystick1:, joystick2:)
       @keyboard = keyboard
@@ -31,9 +37,10 @@ module Badline
       @device1 = nil
       @device2 = nil
       @port_a_source = nil
+      @extra_rows = 0xff
     end
 
-    def read_a(port_a, port_b) = scan(port_a, port_b).first
+    def read_a(port_a, port_b) = scan(port_a, port_b).first & 0xff
 
     def read_b(port_a, port_b) = scan(port_a, port_b).last
 
@@ -58,7 +65,7 @@ module Badline
     end
 
     def scan(port_a, port_b)
-      keyboard.scan(port_a & port_bits(@joystick2, @device2),
+      keyboard.scan((port_a & port_bits(@joystick2, @device2)) | (@extra_rows << 8),
                     port_b & port_bits(@joystick1, @device1))
     end
 

data/lib/badline/core.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# The emulator core: the machine, its chips, media and traps, and the
+# snapshot state Computer saves and restores with, without the options,
+# the rest of the snapshot code, audio or front end. lib/badline.rb and
+# the Spinel harnesses in spinel/ load it, so a file the core needs is
+# added here.
+require "badline/version"
+require "badline/integer_helper"
+require "badline/region"
+require "badline/timing"
+require "badline/model"
+require "badline/addressable"
+require "badline/memory"
+require "badline/color_memory"
+require "badline/rom"
+require "badline/ram_expansion"
+require "badline/address_bus"
+require "badline/instruction"
+require "badline/instruction_set"
+require "badline/status"
+require "badline/keyboard"
+require "badline/joystick"
+require "badline/control_ports"
+require "badline/input"
+require "badline/cycleable"
+require "badline/datasette"
+require "badline/time_of_day"
+require "badline/cia"
+require "badline/via"
+require "badline/sid"
+require "badline/debug_register"
+require "badline/reu"
+require "badline/interrupts"
+require "badline/traps"
+require "badline/cpu"
+require "badline/vic"
+require "badline/keyboard_buffer"
+require "badline/iec_bus"
+require "badline/drive1541"
+require "badline/snapshot/state"
+require "badline/snapshot/setup"
+require "badline/computer"
+require "badline/vic20"
+require "badline/checkpoint"
+require "badline/storage"
+require "badline/cartridge"
+require "badline/kernal_trap"
+require "badline/chrout_trap"
+require "badline/media"
+require "badline/machine"

data/lib/badline/data_path.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Badline
+  class << self
+    attr_writer :data_path
+
+    # The per-user folder badline keeps its own files in. Defaults to
+    # $BADLINE_DATA_PATH, then to the platform's folder for application
+    # data. Assigning nil restores the default. Nothing is created until
+    # data_folder is asked for a subfolder.
+    def data_path
+      @data_path ||= ENV.fetch("BADLINE_DATA_PATH", nil) || default_data_path(RUBY_PLATFORM)
+    end
+
+    # ~/Library/Application Support/badline on macOS, and
+    # $XDG_DATA_HOME/badline or ~/.local/share/badline elsewhere.
+    def default_data_path(platform)
+      return File.join(Dir.home, "Library", "Application Support", "badline") if platform.include?("darwin")
+
+      xdg = ENV.fetch("XDG_DATA_HOME", nil)
+      xdg = File.join(Dir.home, ".local", "share") if xdg.nil? || !xdg.start_with?("/")
+      File.join(xdg, "badline")
+    end
+
+    # The quicksaves, autosaves or saves subfolder of data_path, created
+    # along with data_path if it doesn't exist yet.
+    def data_folder(name)
+      raise ArgumentError, "unknown data folder: #{name}" unless %w[quicksaves autosaves saves].include?(name)
+
+      path = File.join(data_path, name)
+      FileUtils.mkdir_p(path)
+      path
+    end
+  end
+end