badline 0.2.1 → 0.3.0

data/lib/badline/cartridge.rb

@@ -168,10 +168,18 @@ module Badline
       Bank.new(data)
     end
 
+    # A bank the image leaves out reads as erased ROM.
     def bank(banks, number)
       banks[number] || EMPTY_BANK
     end
 
+    # The bank register bits a ROM decodes. The ROM holds the highest bank
+    # in the image, and has address lines for the power of two that covers
+    # it; the register bits above those lines are ignored.
+    def bank_mask(banks)
+      (1 << (banks.length - 1).bit_length) - 1
+    end
+
     # Sorts the CHIP packets into ROML and ROMH banks by load address. A 16K
     # chip at $8000 spans both.
     def banks_from(chips)

data/lib/badline/checkpoint.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Badline
+  # A digest of the machine's state at one cycle, for comparing two runs of
+  # the same scenario, on two builds or two revisions. Each component is
+  # hashed on its own with 32-bit FNV-1a, so a mismatch names the part of the
+  # machine that went its own way. Nothing is read through a chip's bus
+  # interface, so taking a checkpoint leaves the machine as it was.
+  #
+  # Colour RAM is digested as the four bits each cell stores: the upper
+  # nibble a CPU read sees comes off the open bus.
+  class Checkpoint
+    COMPONENTS = %w[cpu ram color_ram display vic cia1 cia2 sid].freeze
+
+    FNV_OFFSET = 0x811c9dc5
+    FNV_PRIME = 0x01000193
+
+    attr_reader :cycle, :digests
+
+    class << self
+      def take(computer)
+        new(computer.cycles, [
+              fnv1a(cpu_state(computer.cpu)),
+              fnv1a(ram(computer.ram)),
+              fnv1a(color_ram(computer.address_bus.color_ram)),
+              fnv1a(computer.vic.display),
+              fnv1a(vic_state(computer.vic)),
+              fnv1a(cia_state(computer.cia1)),
+              fnv1a(cia_state(computer.cia2)),
+              fnv1a(Array.new(0x20) { |reg| computer.sid.register(reg) })
+            ])
+      end
+
+      # Reads a line written by #to_s.
+      def parse(line)
+        fields = line.split
+        digests = COMPONENTS.map do |name|
+          field = fields.find { |f| f.start_with?("#{name}=") }
+          raise ArgumentError, "no #{name} digest in #{line.inspect}" unless field
+
+          field.split("=").last.to_i(16)
+        end
+        new(fields.first.to_i, digests)
+      end
+
+      def fnv1a(values)
+        hash = FNV_OFFSET
+        values.each { |value| hash = ((hash ^ (value & 0xffffffff)) * FNV_PRIME) & 0xffffffff }
+        hash
+      end
+
+      private
+
+      def cpu_state(cpu)
+        [cpu.program_counter, cpu.a, cpu.x, cpu.y, cpu.stack_pointer, cpu.p, cpu.cycles]
+      end
+
+      def ram(memory)
+        Array.new(0x10000) { |addr| memory.peek(addr) }
+      end
+
+      def color_ram(memory)
+        Array.new(0x400) { |offset| memory.nibble(0xd800 + offset) }
+      end
+
+      def vic_state(vic)
+        vic.register_file + [vic.rasterline, vic.column]
+      end
+
+      def cia_state(cia)
+        start = cia.start
+        [cia.peek(start), cia.peek(start + 1), cia.peek(start + 2), cia.peek(start + 3),
+         cia.timer_a, cia.timer_a_latch, cia.timer_b, cia.timer_b_latch, cia.serial.data,
+         cia.control_a.value, cia.control_b.value, cia.interrupt_status.value,
+         cia.interrupt_control.value] + cia.time_of_day.registers
+      end
+    end
+
+    def initialize(cycle, digests)
+      @cycle = cycle
+      @digests = digests
+    end
+
+    # The components whose digests differ from `other`'s.
+    def differences(other)
+      COMPONENTS.each_index.reject { |i| digests[i] == other.digests[i] }.map { |i| COMPONENTS[i] }
+    end
+
+    def ==(other)
+      other.is_a?(Checkpoint) && cycle == other.cycle && digests == other.digests
+    end
+
+    def to_s
+      fields = COMPONENTS.each_index.map { |i| "#{COMPONENTS[i]}=#{digests[i].to_s(16).rjust(8, '0')}" }
+      "#{cycle} #{fields.join(' ')}"
+    end
+  end
+end

data/lib/badline/cia.rb

@@ -17,6 +17,8 @@ module Badline
 
     def interrupt!(delay = 1) = @icr.assert!(delay)
 
+    def time_of_day = @tod
+
     def timer_a = @ta.counter
 
     def timer_a=(value)
@@ -115,7 +117,7 @@ module Badline
     end
 
     def peek(addr)
-      case index(addr) & 0x0f
+      case offset_of(addr) & 0x0f
       when 0x00 then read_port_a
       when 0x01 then read_port_b
       when 0x02 then @data_dir_a
@@ -136,7 +138,7 @@ module Badline
     end
 
     def poke(addr, value)
-      case index(addr) & 0x0f
+      case offset_of(addr) & 0x0f
       when 0x00 then @data_port_a = value
       when 0x01 then update_port_b { @data_port_b = value }
       when 0x02 then @data_dir_a = value

data/lib/badline/color_memory.rb

@@ -10,7 +10,7 @@ module Badline
     end
 
     def peek(addr)
-      (@vic.phi1_data & 0xf0) | @storage[index(addr)]
+      (@vic.phi1_data & 0xf0) | @storage[offset_of(addr)]
     end
 
     def poke(addr, value)
@@ -19,7 +19,7 @@ module Badline
 
     # The four bits the cell stores, as the VIC's c-access sees them.
     def nibble(addr)
-      @storage[index(addr)]
+      @storage[offset_of(addr)]
     end
   end
 end

data/lib/badline/computer.rb

@@ -45,6 +45,7 @@ module Badline
       @freeze_writes = 0
       @init_handlers = []
       @pending_keys = nil
+      @drive = nil
     end
 
     INIT_THRESHOLD = 2_500_000
@@ -92,14 +93,16 @@ module Badline
       reset!
     end
 
-    # The RES line reaches the CPU and its port, both CIAs, the SID and the
-    # cartridge port. The VIC has no reset pin.
+    # The RES line reaches the CPU and its port, both CIAs, the SID, the
+    # cartridge port and, through the serial bus's RESET line, the drive.
+    # The VIC has no reset pin.
     def reset!
       address_bus.reset_port!
       @cia1.reset!
       @cia2.reset!
       @sid.reset!
       address_bus.cartridge&.reset
+      @drive&.reset!
       @freezing = false
       @nmi_asserted = false
       cpu.reset!
@@ -120,14 +123,16 @@ module Badline
       address_bus.cartridge&.release_button
     end
 
+    # A disk swap keeps the drive's RAM, which only a drive reset clears.
     def mount(storage)
-      drive = KernalTrap::Drive.new(storage)
-      load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, drive:)
+      @drive_memory ||= KernalTrap::Drive::Memory.new
+      @drive = KernalTrap::Drive.new(storage, @drive_memory)
+      load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, drive: @drive)
       cpu.install_trap(KernalTrap::Load::ADDRESS) { load_trap.call }
-      KernalTrap::Serial.new(cpu:, bus: address_bus, drive:).install
+      KernalTrap::Serial.new(cpu:, bus: address_bus, drive: @drive).install
       return unless storage.respond_to?(:write_file)
 
-      save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, storage:)
+      save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, drive: @drive)
       cpu.install_trap(KernalTrap::Save::ADDRESS) { save_trap.call }
     end
 

data/lib/badline/cpu.rb

@@ -24,10 +24,10 @@ module Badline
 
     # +ane_constant+ is ANE's magic constant, which varies from chip to
     # chip. The default is the C64 6510's.
-    def initialize(memory = nil, debug: false, ane_constant: 0xef)
+    def initialize(memory, debug: false, ane_constant: 0xef)
       @debug = debug
       @ane_constant = ane_constant
-      @memory = memory || Memory.new
+      @memory = memory
       @status = CPUStatus.new(STATUS_FLAGS, value: 0b00100000)
       reset_registers
 

data/lib/badline/gui/application.rb

@@ -6,6 +6,7 @@ module Badline
       PAL_CLOCK_HZ = 985_248
       TITLE = "Badline"
       TOGGLE_SYM = SDL2::Key::TAB
+      MUTE_SYM = SDL2::Key::F10
       REVERSE_MOD = SDL2::Key::Mod::SHIFT
 
       SHARED_KEYS = %i[up left cursor_h cursor_v space w a s d lshift].freeze
@@ -28,24 +29,23 @@ module Badline
       }.freeze
       MOUSE_BUTTONS = { 1 => :left, 3 => :right }.freeze
 
-      def initialize(media_path: nil, autostart: true, song: nil, sid_model: nil, debug: false)
-        @computer = Computer.new(debug:, sid_model: sid_model || Media.sid_model(media_path))
+      def initialize(media_path: nil, autostart: true, song: nil, sid_model: nil, sound: false)
+        @computer = Computer.new(sid_model: sid_model || Media.sid_model(media_path))
         puts Media.attach(@computer, media_path, autostart:, song:) if media_path
 
         @mode = :keyboard
         @pot_device = nil
         @panes = [ScreenPane.new(@computer)]
+        @stream = open_stream if sound
+        @paced = ENV["NOVSYNC"].nil?
         @window = Window.new(
           title: TITLE,
           width: canvas_width, height: canvas_height,
-          vsync: ENV["NOVSYNC"].nil?
+          vsync: @paced && !@stream
         )
         @gamepads = Gamepads.new(@computer)
         @gamepads.names.each { |name| puts "Gamepad: #{name}" }
-
-        rate = @window.refresh_rate
-        @cycles_per_frame = PAL_CLOCK_HZ / rate
-        puts "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
+        fit_frame
       end
 
       def run
@@ -54,9 +54,12 @@ module Badline
           handle_events
           @gamepads.poll
           @cycles_per_frame.times { @computer.cycle! }
+          @stream&.feed
           @window.draw(@panes)
+          @stream.pace(@frame_seconds) if @stream && @paced
         end
       ensure
+        @stream&.close
         @gamepads.close
         puts @computer.cpu.inspect
       end
@@ -84,6 +87,7 @@ module Badline
 
       def handle_key_down(event)
         return cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1) if event.sym == TOGGLE_SYM
+        return toggle_mute if event.sym == MUTE_SYM
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
@@ -94,7 +98,7 @@ module Badline
       end
 
       def handle_key_up(event)
-        return if event.sym == TOGGLE_SYM
+        return if [TOGGLE_SYM, MUTE_SYM].include?(event.sym)
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
@@ -123,7 +127,35 @@ module Badline
         @mode = modes[(modes.index(@mode) + step) % modes.size]
         release_inputs
         attach_pot_device
-        @window.title = [TITLE, MODES[@mode] && "[#{MODES[@mode]}]"].compact.join(" ")
+        update_title
+      end
+
+      def toggle_mute
+        return unless @stream
+
+        @stream.toggle_mute
+        update_title
+      end
+
+      def update_title
+        tags = [MODES[@mode], @stream&.muted? && "MUTED"].select(&:itself)
+        @window.title = [TITLE, *tags.map { |tag| "[#{tag}]" }].join(" ")
+      end
+
+      def open_stream
+        sink = Audio::SDLSink.new(rate: Audio::Renderer::DEFAULT_RATE)
+        puts "Sound at #{sink.rate} Hz, F10 mutes"
+        Audio::Stream.new(sink, @computer.sid,
+                          on_underrun: -> { puts "Running below real time, so the sound will stutter." })
+      rescue Audio::SDLSink::Error => e
+        warn "badline: no sound, can't open the audio device: #{e.message}"
+      end
+
+      def fit_frame
+        rate = @window.refresh_rate
+        @cycles_per_frame = PAL_CLOCK_HZ / rate
+        @frame_seconds = @cycles_per_frame.fdiv(PAL_CLOCK_HZ)
+        puts "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
       end
 
       def attach_pot_device

data/lib/badline/kernal_trap/channel.rb

@@ -8,12 +8,31 @@ module Badline
     # channel cut short by a read error never flags one, and holds the
     # error for the drive to report once its bytes run out.
     class Channel
-      attr_accessor :pointer
-      attr_reader :error
+      attr_accessor :buffer
+      attr_reader :error, :pointer
+      attr_writer :lead
 
-      def initialize(bytes = [], error: nil)
+      def initialize(bytes = [], error: nil, writable: false, base: 0)
+        @base = base
         replace(bytes)
         @error = error
+        @writable = writable
+      end
+
+      # A block buffer opened with "#", which reads and writes one of the
+      # drive's buffers in its RAM, so M-R and M-W reach the same bytes. It
+      # hands out the whole block unless a B-R sets a shorter end, and
+      # flags that byte as the last. The DOS opens it with the pointer at 1
+      # and the buffer's number as the byte to send, so the first read
+      # answers with the number and the next one moves on to the third
+      # byte.
+      def self.buffer(memory, number)
+        new(memory.ram, writable: true, base: Drive::Memory.buffer_address(number)).tap do |channel|
+          channel.buffer = number
+          channel.rewind(Drive::BLOCK_SIZE)
+          channel.pointer = 1
+          channel.lead = number
+        end
       end
 
       # A file's bytes, up to the first block its chain can't read. The
@@ -30,22 +49,95 @@ module Badline
         new(data[0, failure[:offset] - 1] || [], error: failure.values_at(:error, :track, :sector))
       end
 
-      def replace(bytes)
+      # The file an open names. The drive keeps the first block of the file
+      # a LOAD (secondary address 0) opens at $7E and $026F of its memory,
+      # and a LOAD of a name starting with "*" reopens that file rather than
+      # the first one on the disk. Loaders write the block there with M-W
+      # to load a file the directory doesn't list.
+      def self.for_name(storage, memory, secondary, name, type)
+        file = Storage.parse_name(name).first
+        return for_file(storage, file, type) unless secondary.zero? && storage.respond_to?(:first_block)
+
+        last = memory.last_program if name.start_with?("*")
+        return at_block(storage, *last) if last
+
+        block = storage.first_block(file, type:)
+        memory.last_program = block if block
+        for_file(storage, file, type)
+      end
+
+      # The file whose chain starts at the block.
+      def self.at_block(storage, track, sector)
+        data = storage.read_file_at(track, sector)
+        data ? new(data) : new([], error: [Drive::ILLEGAL_TRACK_OR_SECTOR, track, sector])
+      end
+
+      def replace(bytes, length = bytes.length)
         @bytes = bytes
-        @pointer = 0
+        rewind(length)
+      end
+
+      def rewind(length)
+        @length = length
+        self.pointer = 0
+      end
+
+      def pointer=(position)
+        @pointer = position
+        @lead = nil
       end
 
+      # A block read into the channel. A buffer channel takes it into its
+      # buffer, a file channel hands it out in place of the file.
+      def load(block, length)
+        return replace(block.dup, length) unless @writable
+
+        @bytes[@base, block.length] = block
+        rewind(length)
+      end
+
+      def writable? = @writable
+
       def exhausted?
-        @pointer >= @bytes.length
+        @pointer >= @length
+      end
+
+      # A file that holds nothing but its error never opened.
+      def failed?
+        exhausted? && !@error.nil?
+      end
+
+      # Each byte lands at the pointer, which wraps within the block.
+      def write(bytes)
+        @lead = nil
+        bytes.each do |byte|
+          @bytes[@base + @pointer] = byte
+          @pointer = (@pointer + 1) & 0xff
+        end
       end
 
       def read
+        return read_buffer if @writable
         return if exhausted?
 
-        byte = @bytes[@pointer]
+        byte = @lead || @bytes[@base + @pointer]
+        @lead = nil
         @pointer += 1
         [byte, exhausted? && !@error]
       end
+
+      private
+
+      # A buffer never runs out. Past its last byte, which goes out with
+      # EOI, the pointer wraps back to the second, and a pointer set past
+      # the end runs on around the block to it.
+      def read_buffer
+        byte = @lead || @bytes[@base + @pointer]
+        @lead = nil
+        last = @pointer == @length - 1
+        @pointer = last ? 1 : (@pointer + 1) & 0xff
+        [byte, last]
+      end
     end
   end
 end

data/lib/badline/kernal_trap/drive/block_commands.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # The commands that read and write a block through a buffer channel,
+      # and B-P, which moves its pointer.
+      module BlockCommands
+        private
+
+        def block_read(arguments, counted: false)
+          channel, _drive, track, sector = arguments
+          data = fetch_block(channel, track, sector)
+          return unless data
+
+          buffer = @channels[channel]
+          buffer.load(data, counted ? data[0] + 1 : data.length)
+          buffer.pointer = 1 if counted
+          report_block_error(track, sector)
+        end
+
+        # The disk is write-protected, so a block write that gets as far as
+        # the disk fails at the block it names.
+        def block_write(arguments, counted: false)
+          channel, _drive, track, sector = arguments
+          return unless fetch_block(channel, track, sector)
+
+          store_count(@channels[channel]) if counted
+          report(WRITE_PROTECT_ON, track, sector)
+        end
+
+        # B-W first stores the index of the last byte written, the pointer
+        # less one but at least 1, as the block's first byte, which leaves
+        # the pointer at 1. B-R reads that count back.
+        def counted_block_write(arguments)
+          block_write(arguments, counted: true)
+        end
+
+        def store_count(buffer)
+          count = [buffer.pointer - 1, 1].max
+          buffer.pointer = 0
+          buffer.write([count])
+        end
+
+        # Block access needs an open buffer channel, a disk and a block on it.
+        # Returns the block, or nil once it has reported why there is none.
+        def fetch_block(channel, track, sector)
+          return report(NO_CHANNEL) unless @channels[channel]
+          return report(DRIVE_NOT_READY) unless @storage.respond_to?(:read_block)
+
+          data = sector && @storage.read_block(track, sector)
+          data || report(ILLEGAL_TRACK_OR_SECTOR, track, sector)
+        end
+
+        # A block the image's error table marks bad still fills the buffer,
+        # but the read reports its error, which copy protection checks for.
+        def report_block_error(track, sector)
+          error = @storage.block_error(track, sector)
+          error ? report(error, track, sector) : report(OK)
+        end
+
+        # B-R takes the block's first byte as the index of its last one, and
+        # hands out the bytes from the second up to there.
+        def counted_block_read(arguments)
+          block_read(arguments, counted: true)
+        end
+
+        def buffer_pointer(arguments)
+          channel, position = arguments
+          buffer = @channels[channel]
+          return report(NO_CHANNEL) unless buffer
+
+          buffer.pointer = position.to_i & 0xff
+          report(OK)
+        end
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/drive/channels.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # The drive's open data channels by secondary address, and the five
+      # buffers they hold. The DOS hands out the highest free buffer.
+      # Reading the BAM when it initializes the disk takes buffer 4, so
+      # channels get 3 down to 0, and the fifth data channel finds none.
+      class Channels
+        BAM_BUFFER = 4
+
+        def initialize
+          @channels = {}
+        end
+
+        def [](secondary) = @channels[secondary]
+
+        def open?(secondary) = @channels.key?(secondary)
+
+        def close(secondary) = @channels.delete(secondary)
+
+        def clear = @channels.clear
+
+        # Opens a buffer channel on the buffer a "#n" name asks for, or on
+        # the highest free one. Returns nil when that buffer isn't free,
+        # which leaves a channel asking again for its own buffer open.
+        def open_buffer(secondary, number, memory)
+          return if number && !free_buffers.include?(number)
+
+          close(secondary)
+          number ||= free_buffers.max
+          @channels[secondary] = Channel.buffer(memory, number) if number
+        end
+
+        # A file that opens takes a buffer, though its bytes don't pass
+        # through drive RAM here. One that fails to open takes none. Returns
+        # nil, leaving the channel closed, when no buffer is free.
+        def open_file(secondary, channel)
+          close(secondary)
+          channel.buffer = free_buffers.max unless channel.failed?
+          @channels[secondary] = channel if channel.failed? || channel.buffer
+        end
+
+        private
+
+        def free_buffers
+          (0...BAM_BUFFER).to_a - @channels.values.map(&:buffer)
+        end
+      end
+    end
+  end
+end