badline 0.17.0 → 0.18.0

data/lib/badline/storage/kim_tape.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A KIM-1 cassette, held as the times its signal crosses zero, in
+    # microseconds from the start of the tape, which are the KIM-1's
+    # cycles. The KIM-1 writes the tape as a square wave on U2's PB7, each
+    # bit 3,700 Hz then 2,400 Hz, and reads it back through a 565 PLL and a
+    # 311 comparator, which hold PB7 high through the 2,400 Hz tone and low
+    # through the 3,700 Hz one (User Manual, appendix E). edges gives the
+    # times PB7 changes as the tape plays.
+    #
+    # A tape reads from a .wav file, 8-bit or 16-bit PCM, its first
+    # channel only, and writes one back as a square wave.
+    class KIMTape
+      class FormatError < StandardError; end
+
+      # A period longer than this many microseconds is the 2,400 Hz tone:
+      # the split between the tones, at the geometric mean of the two.
+      SPLIT = 336
+
+      # The time constants, in seconds, of the detector's DC level and of
+      # its envelope, which sets the hysteresis.
+      DC_TIME = 0.002
+      ENVELOPE_TIME = 0.005
+
+      # The signal crosses the DC level once it swings this fraction of the
+      # envelope past it, and not for an envelope smaller than SILENCE, of
+      # full scale.
+      HYSTERESIS = 0.3
+      SILENCE = 0.03
+
+      # A gap this many microseconds long between crossings plays as
+      # silence in the .wav a tape writes.
+      GAP = 2_000
+
+      # The file the tape reads from and writes back to, or "" for none.
+      attr_reader :path, :crossings
+
+      # The tape in the .wav file at `path`.
+      def self.read(path) = new(path, crossings: from_wav(File.binread(path).bytes))
+
+      # A blank tape at `path`, written to the host file.
+      def self.create(path)
+        tape = new(path)
+        tape.save
+        tape
+      end
+
+      # The zero crossings of the .wav file in `bytes`.
+      def self.from_wav(bytes)
+        raise FormatError, "Not a RIFF WAVE file" unless bytes[0, 4] == "RIFF".bytes && bytes[8, 4] == "WAVE".bytes
+
+        format = nil
+        pos = 12
+        while pos + 8 <= bytes.length
+          id = bytes[pos, 4].pack("C*")
+          size = little_endian(bytes, pos + 4, 4)
+          format = bytes[pos + 8, 16] if id == "fmt "
+          return Detector.new(Format.new(format)).crossings(bytes, pos + 8, size) if id == "data" && format
+
+          pos += 8 + size + (size & 1)
+        end
+        raise FormatError, "No PCM data in the WAVE file"
+      end
+
+      def self.little_endian(bytes, pos, count)
+        value = 0
+        count.times { |i| value |= bytes[pos + i].to_i << (8 * i) }
+        value
+      end
+
+      def initialize(path = "", crossings: [])
+        @path = path
+        @crossings = crossings
+      end
+
+      # The time of the last crossing.
+      def duration = @crossings.empty? ? 0 : @crossings.last
+
+      # Erases the tape from `time` on, as a deck recording from there
+      # does.
+      def erase_from(time)
+        @crossings.pop while !@crossings.empty? && @crossings.last >= time
+      end
+
+      # Records a crossing at `time`, after the last one.
+      def record(time)
+        @crossings << time
+      end
+
+      # The times PB7 changes as the tape plays, from high at its start: to
+      # low where a period is the 3,700 Hz tone and back to high where one
+      # is the 2,400 Hz tone. Each period runs over two crossings, and two
+      # in a row must agree before PB7 follows, so that one crossing out of
+      # place doesn't split a bit. The period that straddles the change
+      # lies between the tones, so PB7 changes half way through it.
+      def edges
+        crossings = @crossings
+        edges = []
+        high = true
+        disagree = 0
+        i = 2
+        while i < crossings.length
+          low_tone = crossings[i] - crossings[i - 2] > SPLIT
+          if low_tone == high
+            disagree = 0
+          else
+            disagree += 1
+            if disagree == 2
+              high = low_tone
+              edges << ((crossings[i - 3] + crossings[i - 2]) / 2)
+              disagree = 0
+            end
+          end
+          i += 1
+        end
+        edges
+      end
+
+      # Writes the tape back to its host file.
+      def save
+        write_wav(@path)
+      end
+
+      # Writes the tape to `path` as a .wav file, a square wave of `bits`
+      # (8 or 16) at `rate` samples a second.
+      def write_wav(path, rate: 44_100, bits: 8)
+        samples = square_wave(rate, bits == 8 ? 96 : 24_000)
+        bytes = bits == 8 ? samples.map { |sample| sample + 128 } : samples.flat_map { |s| [s & 0xff, (s >> 8) & 0xff] }
+        File.binwrite(path, (wav_header(rate, bits, bytes.length) + bytes).pack("C*"))
+      end
+
+      private
+
+      # The tape as samples of `amplitude`: silent up to the first
+      # crossing, after a GAP and at the end, and otherwise each crossing
+      # turning the wave over.
+      def square_wave(rate, amplitude)
+        samples = []
+        crossings = @crossings
+        count = crossings.empty? ? 0 : (((crossings.last + GAP) * rate) / 1_000_000) + 1
+        index = 0
+        level = -amplitude
+        count.times do |n|
+          time = (n * 1_000_000) / rate
+          while index < crossings.length && crossings[index] <= time
+            level = -level
+            index += 1
+          end
+          samples << (index.zero? || time - crossings[index - 1] > GAP ? 0 : level)
+        end
+        samples
+      end
+
+      def wav_header(rate, bits, size)
+        bytes_per_sample = bits / 8
+        "RIFF".bytes + le(36 + size, 4) + "WAVEfmt ".bytes + le(16, 4) + le(1, 2) + le(1, 2) +
+          le(rate, 4) + le(rate * bytes_per_sample, 4) + le(bytes_per_sample, 2) + le(bits, 2) +
+          "data".bytes + le(size, 4)
+      end
+
+      def le(value, count) = Array.new(count) { |i| (value >> (8 * i)) & 0xff }
+
+      # A WAVE file's fmt chunk: PCM, 8-bit unsigned or 16-bit signed.
+      class Format
+        attr_reader :channels, :rate, :bits
+
+        def initialize(chunk)
+          tag = KIMTape.little_endian(chunk, 0, 2)
+          @channels = KIMTape.little_endian(chunk, 2, 2)
+          @rate = KIMTape.little_endian(chunk, 4, 4)
+          @bits = KIMTape.little_endian(chunk, 14, 2)
+          return if [1, 0xfffe].include?(tag) && [8, 16].include?(@bits) && @channels.positive?
+
+          raise FormatError, "Only 8-bit and 16-bit PCM WAVE files are supported"
+        end
+
+        def frame_size = @channels * @bits / 8
+
+        # The first channel's sample at `pos`, from -1 to 1.
+        def level_at(bytes, pos)
+          return (bytes[pos] - 128) / 128.0 if @bits == 8
+
+          value = bytes[pos] | (bytes[pos + 1] << 8)
+          (value >= 0x8000 ? value - 0x10000 : value) / 32_768.0
+        end
+      end
+
+      # Finds where a recording crosses zero. A cassette's signal wanders
+      # off its centre and fades, so the detector follows its DC level and
+      # its envelope, and counts a crossing only once the signal swings past
+      # the DC level by HYSTERESIS of the envelope, timing it where it
+      # crossed the DC level, between two samples.
+      class Detector
+        def initialize(format)
+          @format = format
+          rate = format.rate
+          @dc_step = 1.0 / (rate * DC_TIME)
+          @decay = Math.exp(-1.0 / (rate * ENVELOPE_TIME))
+          @scale = 1_000_000.0 / rate
+          @dc = @envelope = @previous = @rose = @fell = 0.0
+          @high = false
+          @found = []
+        end
+
+        # The crossings, in microseconds, of the samples in `bytes` from
+        # `pos`, `size` bytes of them.
+        def crossings(bytes, pos, size)
+          format = @format
+          frame = format.frame_size
+          last = [pos + size, bytes.length].min - frame
+          n = 0
+          while pos <= last
+            follow(format.level_at(bytes, pos), n)
+            pos += frame
+            n += 1
+          end
+          @found
+        end
+
+        private
+
+        # Takes the sample `sample`, the `index`th.
+        def follow(sample, index)
+          @dc += (sample - @dc) * @dc_step
+          level = sample - @dc
+          @envelope *= @decay
+          @envelope = level.abs if level.abs > @envelope
+          previous = @previous
+          if previous <= 0 && level.positive?
+            @rose = index - 1 + (previous / (previous - level))
+          elsif previous >= 0 && level.negative?
+            @fell = index - 1 + (previous / (previous - level))
+          end
+          @previous = level
+          swing(level) if @envelope > SILENCE
+        end
+
+        # Turns over at a `level` far enough past the DC level.
+        def swing(level)
+          swing = @envelope * HYSTERESIS
+          if !@high && level > swing
+            @high = true
+            @found << (@rose * @scale).round
+          elsif @high && level < -swing
+            @high = false
+            @found << (@fell * @scale).round
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/papertape.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A MOS papertape, the .ptp or .pap the KIM-1 monitor's Q command
+    # punches and its L command reads (User Manual, appendix F). Each
+    # record is a semicolon, then in hex its count of data bytes, its
+    # address, high byte first, the bytes and a 16-bit checksum, the sum
+    # of every byte before it, high byte first. The last record has a
+    # count of 0, the number of records before it where the address goes,
+    # and its checksum, which the monitor checks without counting the
+    # records. What comes between records, a line's end, NULs
+    # and the XOFF that ends a dump, the monitor skips, as this does.
+    class Papertape
+      class FormatError < StandardError; end
+
+      # One record's data: its bytes and where they go.
+      class Record
+        attr_reader :address, :bytes
+
+        def initialize(address, bytes)
+          @address = address
+          @bytes = bytes
+        end
+      end
+
+      HEX = "0123456789ABCDEFabcdef"
+
+      # The Records, in the tape's order.
+      attr_reader :records
+
+      # The tape's text from its start to the last record's end, which a
+      # teletype sends for the L command.
+      attr_reader :text
+
+      def self.read(path) = new(File.binread(path))
+
+      def initialize(text)
+        @records = []
+        @text = text.b
+        @position = 0
+        read_records
+      end
+
+      # Where the first record goes.
+      def start_address = @records.first.address
+
+      private
+
+      def read_records
+        loop do
+          start = @text.index(";", @position)
+          raise FormatError, "no last record" if start.nil?
+
+          @position = start + 1
+          count = byte
+          address = word
+          data = Array.new(count) { byte }
+          check(count, address, data)
+          return finish if count.zero?
+
+          @records << Record.new(address, data)
+        end
+      end
+
+      def check(count, address, data)
+        sum = (count + (address >> 8) + (address & 0xff) + data.sum) & 0xffff
+        raise FormatError, "bad checksum in the record at $#{address.to_s(16).rjust(4, '0')}" unless word == sum
+      end
+
+      def finish
+        raise FormatError, "no records" if @records.empty?
+
+        @text = @text[0, @position]
+      end
+
+      def byte
+        digits = @text[@position, 2].to_s
+        unless digits.size == 2 && HEX.include?(digits[0]) && HEX.include?(digits[1])
+          raise FormatError, "not a hex byte at offset #{@position}"
+        end
+
+        @position += 2
+        digits.to_i(16)
+      end
+
+      def word = (byte << 8) | byte
+    end
+  end
+end

data/lib/badline/storage.rb

@@ -5,13 +5,17 @@ require "badline/storage/p00"
 require "badline/storage/host_directory"
 require "badline/storage/disk_image"
 require "badline/storage/d64_image"
+require "badline/storage/d67_image"
 require "badline/storage/d71_image"
 require "badline/storage/d81_image"
 require "badline/storage/d80_image"
 require "badline/storage/d82_image"
+require "badline/storage/d90_image"
 require "badline/storage/g64_image"
 require "badline/storage/t64"
 require "badline/storage/tap"
+require "badline/storage/papertape"
+require "badline/storage/kim_tape"
 require "badline/storage/crt_file"
 require "badline/storage/unavailable"
 

data/lib/badline/support/kim1_checkpoint.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a KIM-1: its CPU, the 1K of RAM, each 6530's RAM,
+    # ports and timer, the panel's held key and what its digits show, and
+    # what the teletype has printed and its line's level.
+    module KIM1Checkpoint
+      COMPONENTS = %w[cpu ram u2 u3 panel tty].freeze
+
+      def self.take(machine)
+        ram = machine.ram
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(ram, ram.length)),
+                         Checkpoint.fnv1a(rriot_state(machine.u2)),
+                         Checkpoint.fnv1a(rriot_state(machine.u3)),
+                         Checkpoint.fnv1a(panel_state(machine.panel)),
+                         Checkpoint.fnv1a(teletype_state(machine.teletype))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.rriot_state(rriot) = rriot.idle_state.map { |value| bit(value) } + [rriot.timer.counter]
+
+      def self.panel_state(panel)
+        held = panel.held
+        [held.nil? ? -1 : KIM1::Panel::KEYS.index(held), *panel.display]
+      end
+
+      def self.teletype_state(teletype) = teletype.output.bytes + [teletype.line_high? ? 1 : 0]
+
+      def self.bit(value)
+        return value if value.is_a?(Integer)
+
+        value ? 1 : 0
+      end
+    end
+  end
+end

data/lib/badline/support/superpet_checkpoint.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "pet_checkpoint"
+
+module Badline
+  module Support
+    # A Checkpoint of a SuperPET: the PET's components (PETCheckpoint), the
+    # board's latches and bank RAM, the 6702, the ACIA, the 6809 with
+    # whether it has the bus, and the traps on the Waterloo ROM's IEEE-488
+    # routines, empty without a disk on device 8.
+    module SuperPETCheckpoint
+      COMPONENTS = (PETCheckpoint::COMPONENTS + %w[board dongle acia m6809 waterloo]).freeze
+
+      def self.take(machine)
+        pet = PETCheckpoint.take(machine)
+        board = machine.board
+        dongle = machine.dongle
+        acia = machine.acia
+        Checkpoint.new(machine.cycles, pet.digests + [
+          Checkpoint.fnv1a([board.bank_latch, board.system_latch, board.socket, *board.cells]),
+          Checkpoint.fnv1a(dongle.registers + [dongle.latch, dongle.shift_at]),
+          Checkpoint.fnv1a([acia.command, acia.control, acia.status, acia.due]),
+          Checkpoint.fnv1a(m6809_state(machine.m6809) + [machine.m6809_running? ? 1 : 0]),
+          Checkpoint.fnv1a(machine.waterloo_traps&.state || [])
+        ], COMPONENTS)
+      end
+
+      def self.m6809_state(cpu)
+        [cpu.a, cpu.b, cpu.x, cpu.y, cpu.u, cpu.s, cpu.pc, cpu.dp, cpu.cc, cpu.cycles]
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+    end
+  end
+end

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.17.0"
+  VERSION = "0.18.0"
 end

data/lib/badline/vic20/keyed_modules.rb

@@ -28,7 +28,7 @@ module Badline
       end
 
       # Raises Snapshot::FormatError for the modules of a VIC-20 with
-      # another RAM expansion.
+      # another RAM expansion or of another model.
       def load_modules(modules)
         machine = modules.machine
         check_snapshot_setup(Snapshot::Vic20Setup.read_fields(machine))
@@ -62,9 +62,12 @@ module Badline
       end
 
       def check_snapshot_setup(setup)
-        return if setup.ram == @ram_configuration
+        unless setup.ram == @ram_configuration
+          raise Snapshot::FormatError, "the snapshot is of a VIC-20 with #{setup.ram} RAM, not #{@ram_configuration}"
+        end
+        return if setup.model == @model
 
-        raise Snapshot::FormatError, "the snapshot is of a VIC-20 with #{setup.ram} RAM, not #{@ram_configuration}"
+        raise Snapshot::FormatError, "the snapshot is of a #{setup.model.upcase} VIC-20, not a #{@model.upcase} one"
       end
     end
 

data/lib/badline/vic20/keyed_state.rb

@@ -3,9 +3,9 @@
 module Badline
   class Vic20
     # The machine's own fields in a keyed snapshot module (Snapshot::Keyed,
-    # BL-MACHINE): the family, its RAM expansion by name, the cycle count,
-    # the RESTORE key's NMI, and the host's typing still to feed and on_init
-    # handlers still to run under host.*.
+    # BL-MACHINE): the family, its RAM expansion and model by name, the
+    # cycle count, the RESTORE key's NMI, and the host's typing still to
+    # feed and on_init handlers still to run under host.*.
     module KeyedState
       # How many more on_init handlers the machine a snapshot was taken of had
       # yet to run than this one has. Nil until the machine is restored.
@@ -20,10 +20,11 @@ module Badline
 
       def save_machine_fields(out)
         out.text("family", "vic20").text("written_by", VERSION)
-        Snapshot::Vic20Setup.new(ram: @ram_configuration).write_fields(out)
+        Snapshot::Vic20Setup.new(ram: @ram_configuration, model: @model).write_fields(out)
         out.int("cycles", @cycles).bool("nmi_asserted", @nmi_asserted)
         pending = @pending_keys
         out.ints("host.pending_keys", pending) if pending
+        save_init_keys(out)
         out.int("host.init_pending", @cycles <= @init_threshold ? @init_handlers.length : 0)
       end
 
@@ -32,6 +33,7 @@ module Badline
         @nmi_asserted = input.bool("nmi_asserted", @nmi_asserted)
         pending = input.ints("host.pending_keys", [])
         @pending_keys = pending.empty? ? nil : pending.dup
+        load_init_keys(input)
         @init_handlers_lost = [input.int("host.init_pending", 0) - @init_handlers.length, 0].max
       end
 

data/lib/badline/vic20.rb

@@ -11,8 +11,8 @@ require "badline/vic20/keyed_state"
 require "badline/vic20/keyed_modules"
 
 module Badline
-  # The Commodore VIC-20 with the PAL 6561: a 6502 at the VIC's clock, the
-  # VIC-I and two 6522 VIAs. VIA 1, at $9110, pulls NMI, and VIA 2, at
+  # The Commodore VIC-20, with the PAL 6561 or the NTSC 6560: a 6502 at
+  # the VIC's clock, the VIC-I and two 6522 VIAs. VIA 1, at $9110, pulls NMI, and VIA 2, at
   # $9120, pulls IRQ. Nothing else interrupts the CPU, and nothing halts
   # it: the VIC fetches in the half of the cycle the CPU leaves alone.
   #
@@ -34,6 +34,14 @@ module Badline
     # The RAM expansion it was built with, a key of Bus::RAM_CONFIGURATIONS.
     attr_reader :ram_configuration
 
+    # The model it was built as, one of MODELS.
+    attr_reader :model
+
+    # The models, by xvic's names for its video standards: the PAL one with
+    # the 6561 and KERNAL 901486-07, and the NTSC one with the 6560 and
+    # KERNAL 901486-06.
+    MODELS = %w[pal ntsc].freeze
+
     def ram = @bus.ram
 
     # Reads and writes memory as the CPU sees it, through the bus.
@@ -50,10 +58,14 @@ module Badline
     # No pot device plugs in yet.
     def control_ports = nil
 
-    # +ram+ names the RAM expansion, one of Bus::RAM_CONFIGURATIONS.
-    def initialize(ram: :unexpanded, debug: false)
+    # +ram+ names the RAM expansion, one of Bus::RAM_CONFIGURATIONS, and
+    # +model+ the model, one of MODELS.
+    def initialize(ram: :unexpanded, model: "pal", debug: false)
       @ram_configuration = ram
-      @vic = Chips::VICI.new
+      @model = model
+      raise ArgumentError, "no VIC-20 model named #{model}" unless MODELS.include?(model)
+
+      @vic = Chips::VICI.new(model == "ntsc" ? Chips::VICI::NTSC : Chips::VICI::PAL)
       @keyboard = Input::Keyboard.new(matrix: KeyboardVIAPorts::MATRIX)
       @joystick1 = Input::Joystick.new
       @iec_bus = Drives::SerialBus.new
@@ -63,7 +75,8 @@ module Badline
       keyboard_ports = KeyboardVIAPorts.new(keyboard: @keyboard, joystick: @joystick1)
       @via2 = Chips::VIA.new(start: 0x9000, peripheral: keyboard_ports)
       keyboard_ports.connect(@via2)
-      @bus = Bus.new(vic: @vic, via1: @via1, via2: @via2, blocks: Bus::RAM_CONFIGURATIONS.fetch(ram))
+      @bus = Bus.new(vic: @vic, via1: @via1, via2: @via2, blocks: Bus::RAM_CONFIGURATIONS.fetch(ram),
+                     kernal: "vic20/kernal-#{model}.rom")
       @vic.connect(@bus)
       @cpu = CPU.new(@bus, debug:)
       @cycles = 0
@@ -72,6 +85,7 @@ module Badline
       @nmi_asserted = false
       @init_handlers = []
       @pending_keys = nil
+      @init_keys = nil
       @dos = nil
       @serial_trap = nil
       @save_trap = nil
@@ -109,18 +123,18 @@ module Badline
     # #drain_samples.
     def sound_source = @sound
 
-    # The PAL clock and raster, and the part of the display xvic shows: all
-    # 284 pixels of a line, from line 28, below the VIC's vertical blank.
-    # The VIC draws 4 pixels a cycle, half as many as the C64's VIC-II on
-    # about the same clock, so each pixel shows two window pixels wide, as
-    # xvic draws them.
+    # The VIC's clock and raster, and the part of the display xvic shows:
+    # every pixel of a line, from line 28, below the VIC's vertical blank,
+    # 284 lines on PAL and 233 on NTSC. The VIC draws 4 pixels a cycle,
+    # half as many as the C64's VIC-II on about the same clock, so each
+    # pixel shows two window pixels wide, as xvic draws them.
     def timing
       profile = @vic.profile
       width = profile.cycles_per_line * Chips::VICI::PIXELS_PER_CYCLE
       blanked = profile.blanked_lines
       Timing.new(clock_hz: profile.clock_hz, cycles_per_line: profile.cycles_per_line,
                  lines_per_frame: profile.lines_per_frame,
-                 crop: [0, blanked, width, profile.lines_per_frame - blanked], pixel_width: 2, dots: 1)
+                 crop: [0, blanked, width, profile.shown_lines], pixel_width: 2, dots: 1)
     end
 
     # The RESTORE key pulls VIA 1's CA1 low while it is held. The KERNAL

data/lib/badline.rb

@@ -4,6 +4,7 @@ require "badline/core"
 require "badline/c128"
 require "badline/plus4"
 require "badline/cbm2"
+require "badline/kim1"
 require "badline/options"
 require "badline/data_path"
 require "badline/snapshot"