badline 0.7.0 → 0.9.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/cartridge/freezer.rb

@@ -8,6 +8,8 @@ module Badline
     # cartridge ROM in Ultimax mode. The cartridge lets go of NMI when its
     # software acknowledges the freeze.
     module Freezer
+      def freezer? = true
+
       def press_button
         @button = true
         self.nmi = true if freeze_allowed?

data/lib/badline/cartridge.rb

@@ -179,6 +179,9 @@ module Badline
     # The RES line on the expansion port.
     def reset; end
 
+    # Whether the cartridge has a freeze button.
+    def freezer? = false
+
     # The freeze button, which cartridges without one ignore.
     def press_button; end
 

data/lib/badline/computer/attachments.rb

@@ -50,7 +50,7 @@ module Badline
       def detach_drive1541
         return unless @drive1541
 
-        @iec_bus&.detach(@drive1541)
+        @iec_bus.detach(@drive1541)
         @drive1541 = nil
         @serial_trap&.device = serial_trap_device
       end
@@ -95,10 +95,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 +106,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.rb

@@ -42,9 +42,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 +70,7 @@ module Badline
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
-      @iec_bus = nil
+      @iec_bus = IECBus.new(host: @cia2).tap(&:plug_in!)
       @reu = reu ? plug_reu(reu) : nil
     end
 
@@ -161,19 +165,17 @@ module Badline
     # 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
+      @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
 
-    # 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 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
 
     def capture_output
       @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus).tap do |trap|

data/lib/badline/core.rb

@@ -0,0 +1,48 @@
+# 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/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/checkpoint"
+require "badline/storage"
+require "badline/cartridge"
+require "badline/kernal_trap"
+require "badline/chrout_trap"
+require "badline/media"

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

data/lib/badline/datasette.rb

@@ -5,11 +5,15 @@ module Badline
   # motor runs with a key pressed, and reports the keys through the cassette
   # sense line on the $01 port.
   class Datasette
+    # What inserting a tape raises on a machine without a cassette port.
+    class Missing < ArgumentError; end
+
     attr_reader :tape
     attr_writer :motor
 
     def initialize(tape = nil)
       @tape = tape
+      @connected = true
       @playing = false
       @motor = false
       @countdown = 0
@@ -27,7 +31,18 @@ module Badline
       @sense_handler = handler
     end
 
+    # Whether the machine has a datasette at its cassette port. The SX-64
+    # has none: its keys stay up and it takes no tape.
+    def connected? = @connected
+
+    def disconnect!
+      eject
+      @connected = false
+    end
+
     def insert(tape)
+      raise Missing, "this machine has no datasette" unless @connected
+
       @tape = tape
       rewind
     end
@@ -54,18 +69,19 @@ module Badline
 
     def running? = @playing && @motor && !@tape.nil?
 
-    # The keys, the motor, the countdown to the next pulse and the tape: its
-    # path and how far it has played.
+    # The keys, the motor, the countdown to the next pulse and the tape:
+    # its path, its bytes and how far it has played.
     def save_state(out)
       out.marker("DATASETTE")
       out.boolean(@playing).boolean(@motor).int(@countdown).boolean(!@tape.nil?)
       return unless @tape
 
-      out.string(@tape.path).int(@tape.position)
+      out.string(@tape.path).blob(@tape.bytes).int(@tape.position)
     end
 
-    # A tape from another file goes in from its path, and a detached
-    # reader leaves the tape out. The sense and flag handlers don't fire.
+    # The tape goes back in from the bytes the state holds, without its
+    # host file, unless the tape in is the same one. The sense and flag
+    # handlers don't fire.
     def load_state(input)
       input.marker("DATASETTE")
       @playing = input.boolean?
@@ -74,10 +90,9 @@ module Badline
       return @tape = nil unless input.boolean?
 
       path = input.string
+      bytes = input.blob
       position = input.int
-      return @tape = nil if input.detached?
-
-      @tape = Storage::TAP.new(path) unless @tape&.path&.b == path
+      @tape = Storage::TAP.new(path, bytes:) unless @tape&.path&.b == path && @tape.bytes == bytes
       @tape.position = position
     end
 
@@ -99,7 +114,7 @@ module Badline
     private
 
     def press(down)
-      return if down == @playing
+      return if down == @playing || !@connected
 
       @playing = down
       @sense_handler&.call

data/lib/badline/drive1541/disk.rb

@@ -160,9 +160,9 @@ module Badline
       end
 
       # Whether the write-protect notch is covered: the disk's image won't
-      # take writes. A disk without an image takes them, and keeps them
-      # only in its tracks.
-      def write_protected? = !@image.nil? && !@image.writable?
+      # take writes, or a disk without an image was opened read-only. A
+      # disk without an image keeps what it takes only in its tracks.
+      def write_protected? = @image.nil? ? @read_only : !@image.writable?
 
       # A half track the head writes to, blank to begin with: no flux, and
       # as many bytes as a turn holds at the bit rate of the +zone+ it's

data/lib/badline/drive1541/disk_state.rb

@@ -5,7 +5,8 @@ module Badline
     class Disk
       # Saving and restoring a Disk for a snapshot: the image by its path,
       # and every half track as the head sees it, with those written since
-      # the last flush. The image itself is read again from its host file.
+      # the last flush. The image itself is read again from its host file,
+      # where there still is one.
       module State
         # The image's path, expanded, and whether it was opened read-only,
         # for a disk from Disk.open. Nil for a disk made another way.
@@ -25,18 +26,26 @@ module Badline
 
         # The disk a state from save_state describes: +current+ when it was
         # opened from the same image the same way, and otherwise a disk for
-        # the image at the path the state names, or one without an image,
-        # as a detached reader always gets. Either way its tracks come from
-        # the state.
+        # the image at the path the state names. Where no file is at that
+        # path, the disk has no image and is write-protected, and a
+        # detached reader always gets one without an image. Either way its
+        # tracks come from the state.
         def self.load(input, current)
           path = input.optional_string
           read_only = input.boolean?
           disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
-          disk ||= path && !input.detached? ? reopen(path, read_only) : Disk.new
+          disk ||= fresh(path, read_only, input.detached?)
           disk.load_tracks(input)
           disk
         end
 
+        def self.fresh(path, read_only, detached)
+          return Disk.new if path.nil? || detached
+          return Disk.new.opened(path, true) unless File.file?(path)
+
+          reopen(path, read_only)
+        end
+
         # Notes the image's path and how it was opened.
         def opened(path, read_only)
           @path = File.expand_path(path)

data/lib/badline/frontend/app.rb

@@ -7,8 +7,8 @@ module Badline
     # changed lines, present and wait. Pacer decides the cycles and the wait.
     class App
       SCALE = 2
+      DROPFILE = 0x1000
       TITLE = "Badline"
-      STAGES = %w[events emulate audio blit present wait].freeze
 
       # Takes the frame limit, the pacing, the snapshot path, the sound and
       # the verbosity from Options, and runs the timeline's events.
@@ -22,11 +22,11 @@ module Badline
         @screen = Screen.new(computer.vic)
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
-        @spent = Array.new(STAGES.size, 0.0)
-        @slowest = 0.0
         open_window
-        @sound = Sound.new(computer.sid, options.sound?, @verbose)
+        @sound = Sound.new(computer.sid, computer.region.clock_hz, options.sound?, @verbose)
         @gamepads = Gamepads.new(computer, @verbose)
+        @frame_report = FrameReport.new(@sound)
+        @menu = PauseMenu.new(Painter.new(@renderer), options, @snapshots)
       end
 
       def run
@@ -34,8 +34,7 @@ module Badline
         @running = true
         @started = @reported = now
         @pacer.start(@started)
-        @reported_samples = 0
-        frame while @running
+        @menu.open? ? paused_frame : frame while @running
         @snapshots.finish
         @computer.drive1541&.flush
         @gamepads.close
@@ -64,11 +63,10 @@ module Badline
       end
 
       def finish_frame(stamps)
-        STAGES.size.times { |stage| @spent[stage] += stamps[stage + 1] - stamps[stage] }
-        took = stamps[-2] - stamps.first
-        @slowest = took if took > @slowest
+        @frame_report.add(stamps) if @verbose
         @frames += 1
         @timeline.run(@computer, @frames)
+        @snapshots.tick(@frames)
         @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
         @pacer.check(Pacer::EARLY_CHECK, stamps.last - @started, stamps.last) if @frames == Pacer::EARLY_CHECK
         report(stamps.last) if (@frames % 50).zero?
@@ -95,8 +93,6 @@ module Badline
         @texture = SDL.SDL_CreateTexture(
           @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, Screen::WIDTH, Screen::HEIGHT
         )
-        SDL.rect_w(SDL.rect, Screen::WIDTH)
-        SDL.rect_h(SDL.rect, Screen::HEIGHT)
       end
 
       def close_window
@@ -107,7 +103,7 @@ module Badline
       end
 
       def handle_events
-        handle_event(SDL.event_type(SDL.event)) while SDL.SDL_PollEvent(SDL.event) != 0
+        handle_event(SDL.event_type(SDL.event)) while !@menu.open? && SDL.SDL_PollEvent(SDL.event) != 0
       end
 
       def handle_event(type)
@@ -122,6 +118,7 @@ module Badline
           @controls.mouse_button(SDL.event_button(SDL.event), type == SDL::MOUSEBUTTONDOWN)
         when SDL::CONTROLLERDEVICEADDED, SDL::CONTROLLERDEVICEREMOVED
           @gamepads.rescan
+        when DROPFILE then resume(false) unless @menu.drop(@computer, @controls, @sound)
         end
       end
 
@@ -144,21 +141,46 @@ module Badline
         @led = DriveLed.for(computer)
         @controls.computer = computer
         @gamepads.computer = computer
-        @sound.sid = computer.sid
+        @sound.switch(computer.sid, computer.region.clock_hz)
+        @snapshots.computer = computer
       end
 
       def handle_toggle(scancode)
         if scancode == Keys::TAB
-          @controls.cycle_mode(SDL.event_mod(SDL.event).anybits?(SDL::KMOD_SHIFT) ? -1 : 1)
-          SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
+          @controls.toggle_keys
         elsif scancode == Keys::F9
-          @controls.swap_ports
+          return open_menu
         else
           @sound.toggle_mute
         end
         update_title
       end
 
+      def open_menu = @menu.show(@computer, @controls, @sound)
+
+      # Closes the menu and runs the machine on from where it stood,
+      # pressing the cartridge's freeze button if asked.
+      def resume(freeze)
+        @menu.close
+        SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
+        @timeline.press_freeze(@computer, @frames) if freeze
+        @reported = now
+        @pacer.start(@reported)
+        update_title
+      end
+
+      # Runs a frame of the menu, which has the keys and the mouse while the
+      # machine stands still.
+      def paused_frame
+        action = @menu.frame(@renderer, @texture, @controls)
+        if action == :quit
+          @running = false
+        elsif !action.nil?
+          swap(@menu.computer) if action == :swap
+          resume(action == :freeze)
+        end
+      end
+
       def update_title
         title = TITLE
         title += " [#{@controls.tag}]" unless @controls.tag.empty?
@@ -183,12 +205,12 @@ module Badline
 
       def upload
         @screen.update
-        SDL.SDL_UpdateTexture(@texture, SDL.rect, @screen.pixels, Screen::ROW_BYTES)
+        SDL.SDL_UpdateTexture(@texture, nil, @screen.pixels, Screen::ROW_BYTES)
       end
 
       def draw
         SDL.SDL_RenderClear(@renderer)
-        SDL.SDL_RenderCopy(@renderer, @texture, SDL.rect, SDL.rect)
+        SDL.SDL_RenderCopy(@renderer, @texture, nil, nil)
         @led&.draw(@renderer)
         @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(@renderer, path) }
         SDL.SDL_RenderPresent(@renderer)
@@ -197,28 +219,10 @@ module Badline
       def report(at)
         @pacer.check(50, at - @reported, at)
         @pacer.measure(50, at - @reported)
-        report_frames(at) if @verbose
-        @spent = Array.new(STAGES.size, 0.0)
-        @slowest = 0.0
+        @frame_report.show(at - @reported) if @verbose
         @reported = at
       end
 
-      def report_frames(at)
-        fps = 50 / (at - @reported)
-        stages = STAGES.each_with_index.map { |name, stage| "#{name} #{(@spent[stage] * 20).round(2)}" }
-        puts "#{fps.round(1)} fps, per frame ms: #{stages.join(' ')}, slowest work #{(@slowest * 1000).round(2)}"
-        report_sound(at) if @sound.on?
-      end
-
-      def report_sound(at)
-        sound = @sound
-        rate = (sound.queued - @reported_samples) / (at - @reported)
-        queue = sound.high.zero? ? "empty" : "#{(sound.low * 1000).round(1)}-#{(sound.high * 1000).round(1)} ms"
-        puts "  sound #{rate.round} samples/s, queue #{queue}, #{sound.underruns} underruns, #{sound.dropped} dropped"
-        sound.reset_levels
-        @reported_samples = sound.queued
-      end
-
       def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end