badline 0.15.1 → 0.16.1

data/lib/badline/snapshot/image.rb

@@ -34,7 +34,7 @@ module Badline
     # of a machine in memory (.of).
     class Image
       MACHINE = "BL-MACHINE"
-      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4" }.freeze
+      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET" }.freeze
 
       attr_reader :container
 
@@ -53,15 +53,18 @@ module Badline
         new(Container.new(computer.save_modules, machine: machine_name(computer)))
       end
 
-      # The snapshot with VICE's modules ahead of the BL-* ones for a C64,
-      # so x64sc opens it too. Raises FormatError for a Plus/4, whose
-      # snapshots badline doesn't write for xplus4.
+      # The snapshot with VICE's modules ahead of the BL-* ones for a C64
+      # or a PET, so x64sc or xpet opens it too. Raises FormatError for a
+      # Plus/4, whose snapshots badline doesn't write for xplus4.
       def self.exported(computer)
         raise FormatError, "badline doesn't export a Plus/4's snapshot for VICE" if computer.family == :plus4
 
         computer.settle_for_snapshot!
         sections = computer.save_modules
-        sections = Vice.export(computer) + sections if computer.family == :c64
+        case computer.family
+        when :c64 then sections = Vice.export(computer) + sections
+        when :pet then sections = Vice::PET.export(computer, sections) + sections
+        end
         new(Container.new(sections, machine: machine_name(computer)))
       end
 
@@ -71,6 +74,7 @@ module Badline
         when :vic20 then Container::VIC20
         when :c128 then Container::C128
         when :plus4 then Container::PLUS4
+        when :pet then Container::PET
         else Container::MACHINE
         end
       end
@@ -82,6 +86,7 @@ module Badline
         when "vic20" then Vic20Setup.read_fields(machine)
         when "c128" then C128Setup.read_fields(machine)
         when "plus4" then Plus4Setup.read_fields(machine)
+        when "pet" then PETSetup.read_fields(machine)
         else C64Setup.read_fields(machine)
         end
       end
@@ -97,15 +102,16 @@ module Badline
 
       # A new machine, built as the snapshot's was and restored from it. A
       # badline snapshot restores from its BL-* modules alone, and a VICE
-      # one through the modules badline reads. xvic's, x128's and xplus4's own
-      # modules aren't read. Yields a line for each thing left out, or
-      # warns it without a block. `detached` restores it without the host's
-      # files (Keyed::Modules).
+      # one through the modules badline reads, x64sc's or xpet's. xvic's,
+      # x128's and xplus4's own modules aren't read. Yields a line for
+      # each thing left out, or warns it without a block. `detached`
+      # restores it without the host's files (Keyed::Modules).
       def load(detached: false, &)
         refuse_old_layout
         raise FormatError, "badline reads only its own VIC-20 snapshots, not xvic's" if vic20? && !badline?
         raise FormatError, "badline reads only its own C128 snapshots, not x128's" if c128? && !badline?
         raise FormatError, "badline reads only its own Plus/4 snapshots, not xplus4's" if plus4? && !badline?
+        return load_xpet(&) if pet? && !badline?
         return load_vice(&) unless badline?
 
         modules = Keyed::Modules.new(sections, detached:)
@@ -123,12 +129,18 @@ module Badline
       # Whether the machine is of the 264 series, as the container names it.
       def plus4? = @container.machine == Container::PLUS4
 
+      # Whether the machine is a PET, as the container names it.
+      def pet? = @container.machine == Container::PET
+
       # Restores `computer` from the snapshot, and returns the Report. The
       # snapshot goes into a new machine first, so one that fails, or is of
       # a machine built another way, leaves `computer` as it was.
       def restore(computer, &)
         refuse_old_layout
-        report = badline? ? restore_modules(computer) : Vice::Restore.import(@container, computer)
+        report = if badline? then restore_modules(computer)
+                 elsif pet? then Vice::PET::Restore.import(@container, computer)
+                 else Vice::Restore.import(@container, computer)
+                 end
         tell(report, &)
         report
       end
@@ -141,6 +153,12 @@ module Badline
         computer
       end
 
+      def load_xpet(&)
+        computer = Vice::PET.setup(@container).build
+        tell(Vice::PET::Restore.apply(@container, computer), &)
+        computer
+      end
+
       # The snapshot goes into a new machine first, so one that fails
       # leaves `computer` as it was.
       def restore_modules(computer)

data/lib/badline/snapshot/pet_setup.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # How a PET was built: its model's name, one of PET::Model::ALL, its
+    # RAM below $8000 in K and its editor's frame rate, the arguments
+    # PET.new takes, the ROMs it runs by file: BASIC, the editor, the
+    # KERNAL and the characters, and the 8296 board's jumpers, by name and
+    # comma-separated.
+    PETSetup = Data.define(:model, :ram_kb, :refresh_hz, :basic, :editor, :kernal, :characters, :jumpers)
+
+    class PETSetup
+      MODELS = PET::Model::ALL.map(&:name).freeze
+
+      REFRESH_RATES = [50, 60].freeze
+
+      # The setup of `machine`.
+      def self.of(machine)
+        model = machine.model
+        refresh_hz = machine.refresh_hz
+        new(model: model.name, ram_kb: machine.ram.length >> 10, refresh_hz:, basic: model.basic,
+            editor: model.editor(refresh_hz), kernal: model.kernal, characters: model.characters,
+            jumpers: machine.jumpers.join(","))
+      end
+
+      # The model by name, the RAM, the frame rate, the ROMs and the
+      # jumpers where a board has any, in a keyed snapshot module.
+      def write_fields(out)
+        out.text("model", model).int("ram_kb", ram_kb).int("refresh_hz", refresh_hz)
+        out.text("rom.basic", basic).text("rom.editor", editor).text("rom.kernal", kernal)
+        out.text("rom.characters", characters)
+        out.text("jumpers", jumpers) unless jumpers.empty?
+      end
+
+      # A ROM the snapshot doesn't name is the model's own, and a board
+      # without jumpers named has none fitted.
+      def self.read_fields(input)
+        profile = PET::Model.named(input.choice("model", MODELS, PET::Model::DEFAULT))
+        ram_kb = input.int("ram_kb", profile.ram_kb)
+        unless PET::Model.ram_fits?(profile, ram_kb)
+          raise FormatError, "the snapshot is of a PET with #{ram_kb}K of RAM, which badline doesn't build"
+        end
+
+        refresh_hz = input.int("refresh_hz", profile.crtc? ? 50 : 60)
+        unless REFRESH_RATES.include?(refresh_hz)
+          raise FormatError, "the snapshot is of a PET at #{refresh_hz} Hz, which badline doesn't build"
+        end
+
+        refresh_hz = 60 unless profile.crtc?
+        new(model: profile.name, ram_kb:, refresh_hz:, basic: input.text("rom.basic", profile.basic),
+            editor: input.text("rom.editor", profile.editor(refresh_hz)),
+            kernal: input.text("rom.kernal", profile.kernal),
+            characters: input.text("rom.characters", profile.characters), jumpers: input.text("jumpers", ""))
+      end
+
+      # A machine built this way, at power-on, with the BASIC, editor and
+      # character ROMs PET::ROMSets names for its ROMs.
+      def build
+        version = PET::ROMSets::BASICS.find { |_, roms| roms.first == basic }&.first
+        PET.new(model:, ram_kb:, refresh_hz:, basic: version, editor: PET::ROMSets::EDITORS.key(editor),
+                characters: fitted_characters, jumpers: jumpers.split(","))
+      rescue ArgumentError => e
+        raise FormatError, "the snapshot is of a #{self}, which badline doesn't build: #{e.message}"
+      end
+
+      # The ROMs are named where they aren't the model's own, and the
+      # jumpers where any are fitted.
+      def to_s
+        text = "#{model} with #{ram_kb}K at #{refresh_hz} Hz"
+        text = "#{text} jumpered #{jumpers}" unless jumpers.empty?
+        roms = [basic, editor, kernal, characters]
+        profile = PET::Model.named(model)
+        stock = [profile.basic, profile.editor(refresh_hz), profile.kernal, profile.characters]
+        roms == stock ? text : "#{text} running #{roms.join(', ')}"
+      end
+
+      private
+
+      # The name of a character ROM other than the model's own, nil for its
+      # own.
+      def fitted_characters
+        return nil if characters == PET::Model.named(model).characters
+
+        PET::ROMSets::CHARACTERS.key(characters) || characters
+      end
+    end
+  end
+end

data/lib/badline/snapshot/storage_setup.rb

@@ -11,6 +11,8 @@ module Badline
       D71 = 2
       D81 = 3
       T64_ARCHIVE = 4
+      D80 = 5
+      D82 = 6
 
       module_function
 
@@ -18,6 +20,8 @@ module Badline
         return D71 if image.is_a?(Storage::D71Image)
         return D64 if image.is_a?(Storage::D64Image)
         return D81 if image.is_a?(Storage::D81Image)
+        return D82 if image.is_a?(Storage::D82Image)
+        return D80 if image.is_a?(Storage::D80Image)
 
         raise ArgumentError, "#{image.class} can't go in a snapshot"
       end
@@ -37,7 +41,7 @@ module Badline
         end
       end
 
-      KIND_NAMES = %w[directory d64 d71 d81 t64].freeze
+      KIND_NAMES = %w[directory d64 d71 d81 t64 d80 d82].freeze
 
       # Opens the storage write_fields wrote: the same directory by its
       # path, an archive with the bytes it held, or a disk image with the
@@ -55,6 +59,8 @@ module Badline
         case kind
         when D64 then Storage::D64Image.new(path, read_only:, bytes:)
         when D71 then Storage::D71Image.new(path, read_only:, bytes:)
+        when D80 then Storage::D80Image.new(path, read_only:, bytes:)
+        when D82 then Storage::D82Image.new(path, read_only:, bytes:)
         else Storage::D81Image.new(path, read_only:, bytes:)
         end
       end

data/lib/badline/snapshot/vice/pet.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "badline/snapshot/vice/pet_cpu"
+require "badline/snapshot/vice/pet_mem"
+require "badline/snapshot/vice/pet_pias"
+require "badline/snapshot/vice/pet_via"
+require "badline/snapshot/vice/pet_crtc"
+require "badline/snapshot/vice/pet_restore"
+
+module Badline
+  module Snapshot
+    module Vice
+      # xpet's modules for the PET: the CPU, the RAM, the CRTC, both PIAs
+      # and the VIA, written from badline's machine and read into it. Each
+      # module's file says what maps and what is approximated. They go
+      # through the PET's own keyed fields (Keyed), which a save writes and a
+      # load reads, so they read no chip's insides.
+      module PET
+        # The models badline builds by the board PETMEM names (PETMem): the
+        # discrete board is a 2001's where xpet's settings say so, and a
+        # 3032 otherwise.
+        MODELS = { PETMem::CRTC40 => "4032", PETMem::CRTC80 => "8032", PETMem::CBM8096 => "8096",
+                   PETMem::CBM8296 => "8296" }.freeze
+        # The modules xpet resets the machine without, for the parts badline
+        # doesn't model in VICE's terms, each as xpet leaves them with
+        # nothing attached: no file system drive open, both cassette ports
+        # on with a datasette in #1, and nothing in the user port.
+        PERIPHERALS = [
+          ["FSDRIVE", 0, 0, Array.new(258, 0)], ["TAPEPORT", 1, 0, [0x01, 0x01, 0x01]], ["USERPORT", 1, 0, [0x01, 0x00]]
+        ].freeze
+        # The cycles a frame below which a CRTC editor runs at 60 Hz.
+        SIXTY_HZ_FRAME = 18_333
+        # The 8032's 50 Hz editors by the cycles a line they set up: xpet's
+        # own, 901474-04 dated 0283, sets 64.
+        EDITOR_0283_LINE = 64
+
+        module_function
+
+        # The modules xpet 3.10 needs, in its order, describing `machine`,
+        # which Machine::Settling has brought between instructions, from
+        # its keyed modules, `sections`.
+        def export(machine, sections)
+          readers = {}
+          sections.each { |section| readers[section.name] = Keyed::Reader.parse(section) }
+          [MainCPU.export(machine), CPU6809.export(machine), PETMem.export(machine),
+           CRTC.export(machine, reader(readers, "BL-CRTC"), reader(readers, "BL-VIDEO")),
+           PIAs.export("PIA1", machine.pia1, reader(readers, "BL-PIA1")),
+           PIAs.export("PIA2", machine.pia2, reader(readers, "BL-PIA2")), VIA.export(reader(readers, "BL-VIA"))] +
+            PERIPHERALS.map { |name, major, minor, bytes| FieldWriter.new.bytes(bytes).section(name, major, minor) }
+        end
+
+        def reader(readers, name) = readers[name] || Keyed::Reader.missing(name)
+
+        # How the machine xpet saved was built: the model from PETMEM's
+        # board, the RAM, and on a CRTC board the editor's frame rate, and
+        # for an 8032's 50 Hz editor which one, from the CRTC's registers.
+        # xpet doesn't save the keyboard, the ROMs or an 8296's jumpers, so
+        # a discrete board is a 3032 with the graphics keyboard unless it is
+        # a 2001, each model has its own ROMs, and an 8296 none of its
+        # jumpers, as xpet's own has.
+        def setup(container)
+          memory = memory(container)
+          ram_kb = PETMem.ram_kb(memory)
+          name = model_name(memory)
+          profile = Badline::PET::Model.named(name)
+          unless Badline::PET::Model.ram_fits?(profile, ram_kb)
+            raise FormatError, "#{memory}: a #{name} with #{ram_kb}K of RAM, which badline doesn't build"
+          end
+
+          crtc = container[CRTC::NAME]
+          crtc = nil unless crtc.nil? || CRTC.reads?(crtc)
+          refresh_hz = refresh_hz(crtc, profile)
+          profile = Badline::PET::Model.upgraded(profile, nil, editor(crtc, profile, refresh_hz))
+          PETSetup.new(model: name, ram_kb:, refresh_hz:, basic: profile.basic, editor: profile.editor(refresh_hz),
+                       kernal: profile.kernal, characters: profile.characters, jumpers: "")
+        end
+
+        def memory(container)
+          section = container[PETMem::NAME]
+          raise FormatError, "the snapshot has no #{PETMem::NAME} module" if section.nil?
+          raise FormatError, "#{section}: badline doesn't read this version" unless PETMem.reads?(section)
+
+          section
+        end
+
+        def model_name(memory)
+          board = PETMem.board_of(memory)
+          return PETMem.pet2001?(memory) ? "2001" : "3032" if board == PETMem::DISCRETE
+
+          name = MODELS[board]
+          return name unless name.nil?
+
+          what = board == PETMem::SUPERPET ? "a SuperPET" : "board #{board}"
+          raise FormatError, "#{memory}: #{what}, which badline doesn't build"
+        end
+
+        # The editor's frame rate, from the cycles the CRTC's registers set
+        # up a frame.
+        def refresh_hz(crtc, profile)
+          return 60 unless profile.crtc?
+          return 50 if crtc.nil?
+
+          registers = CRTC.registers(crtc)
+          (registers[0] + 1) * CRTC.frame_lines(registers) > SIXTY_HZ_FRAME ? 50 : 60
+        end
+
+        # The editor by ROMSets' name where the model's own doesn't set up
+        # the CRTC's frame, or nil.
+        def editor(crtc, profile, refresh_hz)
+          return nil if crtc.nil? || refresh_hz != 50 || profile.video != :crtc80
+
+          CRTC.registers(crtc)[0] + 1 == EDITOR_0283_LINE ? "4-80-b-50hz-0283" : nil
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_cpu.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # The 6502 as xpet 3.10 saves it, MAINCPU 1.3: the clock, the
+        # registers, the last opcode and two words after it, then the IRQ
+        # and NMI bookkeeping: five clocks, the IRQ and NMI source counts and
+        # the pending interrupts. xpet's MAINCPU has no BA line to save.
+        #
+        # Written: the clock and the registers, which between instructions
+        # are the whole CPU, with the IRQ sources that pull the line and a
+        # pending IRQ. VICE's interrupt clocks are written as long past.
+        #
+        # Read: the clock and the registers. The CPU starts on an
+        # instruction boundary, as xpet's snapshot is taken on one.
+        module MainCPU
+          NAME = "MAINCPU"
+          MAJOR = 1
+          MINOR = 3
+          IK_IRQ = 0x02
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          def export(machine)
+            cpu = machine.cpu
+            fields = FieldWriter.new.qword(machine.cycles)
+            [cpu.a, cpu.x, cpu.y, cpu.stack_pointer].each { |register| fields.byte(register) }
+            fields.word(cpu.program_counter).byte(cpu.p)
+            fields.dword(0).dword(0).dword(0)
+            5.times { fields.qword(0) }
+            irqs = [machine.pia1.irq?, machine.pia2.irq?, machine.via.irq?].count(true)
+            fields.dword(irqs).dword(0).dword(irqs.positive? ? IK_IRQ : 0)
+            fields.section(NAME, MAJOR, MINOR)
+          end
+
+          # The clock, the registers by their BL-CPU keys, in a keyed
+          # module's writer.
+          def import(section, out)
+            fields = FieldReader.new(section)
+            clock = fields.qword
+            out.int("a", fields.byte).int("x", fields.byte).int("y", fields.byte).int("sp", fields.byte)
+            out.int("pc", fields.word).int("p", fields.byte).int("cycles", clock)
+            clock
+          end
+        end
+
+        # The SuperPET's 6809, CPU6809 1.1, which xpet saves on every model
+        # and won't load a snapshot without: the clock and the registers as
+        # an xpet with no SuperPET board leaves them. badline doesn't read
+        # it.
+        module CPU6809
+          NAME = "CPU6809"
+
+          module_function
+
+          def export(machine)
+            FieldWriter.new.qword(machine.cycles).zeros(11).byte(0x04).zeros(7).section(NAME, 1, 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_crtc.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # CRTC 1.2, which xpet saves on every model, the discrete boards'
+        # video too, as a 6545 with the registers fixed: the board's screen
+        # settings, the registers, the one selected, the beam's character,
+        # row and line in the row, whether the frame is in its vertical
+        # adjust, the row's start in screen RAM, the lines of vertical sync
+        # left, whether the rows show, the picture's size, the lines in the
+        # frame and the line in it, then xpet's picture.
+        #
+        # Written: the registers and the beam as badline's CRTC, or its
+        # discrete video, has them. The picture is left blank, as xpet
+        # paints it again.
+        #
+        # Read: the registers and the beam, with what follows from them: the
+        # memory address, the characters since horizontal sync and whether
+        # the character shows. The picture starts again with the next
+        # frame.
+        module CRTC
+          NAME = "CRTC"
+          MAJOR = 1
+          MINOR = 2
+          # The registers xpet saves, two more than badline's CRTC has.
+          REGISTERS = 20
+          # Where the selected register is in the module, and the beam after
+          # it.
+          SELECTED = 0x23
+          # The board's screen settings xpet saves ahead of the registers:
+          # the screen RAM's masks and the bits of the frame's start address
+          # it latches (BOARD_ATTRIBUTES), then the bytes a character reads
+          # and whether the board is a 2001's.
+          SETTINGS = [0xff, 0x03, 0x00, 0x20, 0x00, 0x20, 0x00, 0x10, 0xff, 0x1f].freeze
+          # The 8296's, whose screen RAM spans 4K.
+          SETTINGS_8296 = [0xff, 0x0f, 0x00, 0x20, 0x00, 0x20, 0xff, 0x0f, 0xff, 0x1f].freeze
+          # The 2001's and 3000 series' video as xpet's CRTC runs it: 64
+          # cycles a line, 32 rows of 8 lines and 4 more, the first 25 rows
+          # shown.
+          DISCRETE_REGISTERS = [0x3f, 0x28, 0x32, 0x08, 0x1f, 0x04, 0x19, 0x1d, 0x00, 0x07, 0x00, 0x00, 0x10, 0x00,
+                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00].freeze
+          DISCRETE_HEIGHT = 216
+          DISCRETE_LINE = 64
+          DISCRETE_FRAME = DISCRETE_LINE * 260
+          # How many cycles badline's beam runs ahead of xpet's, where both
+          # drop the vertical drive line on the same cycle.
+          DISCRETE_LEAD = 20
+          CRTC_LEAD = -3
+          HEIGHT = 272
+          # A byte xpet writes after the picture's size.
+          AFTER_SIZE = 0x20
+          # The memory address's bits that pick a byte of screen RAM.
+          SCREEN_BITS = 0x0fff
+          # The bits above them, which the boards decode as attributes.
+          HIGH_BITS = 0x3000
+
+          # Where the beam is, in xpet's terms: the character, the row and
+          # its line, the lines of vertical sync left, whether the rows show,
+          # the row's start address and the line in the frame.
+          Beam = Data.define(:column, :row, :raster, :vsync, :shown, :start, :frame_line)
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          def width(model) = model.video == :crtc80 ? 704 : 384
+
+          def height(model) = model.video == :discrete ? DISCRETE_HEIGHT : HEIGHT
+
+          def columns(model) = model.video == :crtc80 ? 2 : 1
+
+          # The frame's start address bits xpet latches on the board: MA12,
+          # which inverts the 80-column boards' picture.
+          def attributes(model) = model.video == :crtc80 ? 0x1000 : 0
+
+          def export(machine, crtc_input, video_input)
+            model = machine.model
+            discrete = model.video == :discrete
+            registers = discrete ? DISCRETE_REGISTERS : crtc_registers(crtc_input)
+            beam = if discrete
+                     discrete_beam(video_input)
+                   else
+                     crtc_beam(run_on(machine, crtc_input, -CRTC_LEAD % frame_cycles(registers)), registers)
+                   end
+            fields = FieldWriter.new.bytes(model.cbm8296? ? SETTINGS_8296 : SETTINGS).word(attributes(model))
+            fields.byte(0).byte(columns(model))
+            fields.byte(model.basic1? ? 1 : 0).bytes(registers).byte(discrete ? 0 : crtc_input.int("selected", 0))
+            beam_fields(fields, beam, registers, model)
+            picture(fields, model)
+            fields.section(NAME, MAJOR, MINOR)
+          end
+
+          def crtc_registers(input)
+            registers = input.bytes("registers", "".b).bytes
+            Array.new(REGISTERS) { |index| registers[index] || 0 }
+          end
+
+          def beam_fields(fields, beam, registers, model)
+            fields.byte(beam.column).byte(beam.row).byte(beam.raster).zeros(2).flag(beam.raster.zero?)
+            fields.word(beam.start & attributes(model)).word((beam.start & SCREEN_BITS) * columns(model))
+            fields.byte(beam.vsync).byte(0).flag(beam.shown)
+            fields.word(width(model)).word(height(model)).byte(AFTER_SIZE).zeros(3)
+            shown = registers[6] * (registers[9] + 1)
+            fields.byte([(height(model) - shown) / 2, 0].max).byte(0)
+            fields.word(frame_lines(registers)).word(beam.frame_line).byte(0)
+          end
+
+          # Blank, as xpet paints it again: the line it draws, its size twice
+          # over, and four lines more than it shows.
+          def picture(fields, model)
+            width = width(model)
+            height = height(model)
+            fields.dword(0).dword(width).dword(height).dword(width).zeros(width * (height + 4))
+          end
+
+          def frame_lines(registers) = ((registers[4] + 1) * (registers[9] + 1)) + registers[5]
+
+          def frame_cycles(registers) = (registers[0] + 1) * frame_lines(registers)
+
+          # The BL-CRTC fields of a CRTC loaded with those in `input` and run
+          # `cycles` cycles on its own, in a machine built as `machine` was.
+          def run_on(machine, input, cycles)
+            crtc = PETSetup.of(machine).build.crtc
+            crtc.load_fields(input)
+            cycles.times { crtc.cycle! }
+            Keyed::Reader.parse(Keyed.section("BL-CRTC") { |out| crtc.save_fields(out) })
+          end
+
+          # Writes the BL-CRTC fields `input` holds to `out`.
+          def copy(input, out)
+            out.bytes("registers", input.bytes("registers", "".b)).int("selected", input.int("selected", 0))
+            %w[column since_hsync line row vsync_lines row_start address].each { |key| out.int(key, input.int(key, 0)) }
+            %w[adjusting row_display column_display].each { |key| out.bool(key, input.bool(key, false)) }
+          end
+
+          # Both move a row's start on at R1 of its last line, and badline's
+          # moves it again where the vertical adjust runs past R9 lines,
+          # which xpet's doesn't.
+          def crtc_beam(input, registers)
+            column = input.int("column", 0)
+            row = input.int("row", 0)
+            line = input.int("line", 0)
+            adjusting = input.bool("adjusting", false)
+            start = input.int("row_start", 0)
+            start = (start - registers[1]) & 0x3fff if adjusting && moved?(line, column, registers)
+            rows = registers[4] + 1
+            lines = registers[9] + 1
+            Beam.new(column:, row: adjusting ? rows : row, raster: adjusting ? 0 : line,
+                     vsync: input.int("vsync_lines", 0), shown: input.bool("row_display", true), start:,
+                     frame_line: adjusting ? (rows * lines) + line : (row * lines) + line)
+          end
+
+          # Whether the row's start has moved on by `column` of `line`.
+          def moved?(line, column, registers)
+            line > registers[9] || (line == registers[9] && column > registers[1])
+          end
+
+          # The discrete video's line in the frame, in xpet's fixed rows: the
+          # rows show until line 200, vertical sync runs from row 29 for 16
+          # lines, and the 4 lines past row 31 are the vertical adjust.
+          def discrete_beam(input)
+            cycle = ((input.int("line", 0) * DISCRETE_LINE) + input.int("column", 0) - DISCRETE_LEAD) % DISCRETE_FRAME
+            line = cycle / DISCRETE_LINE
+            row = [line >> 3, 32].min
+            adjusting = row == 32
+            raster = adjusting ? 0 : line & 0x07
+            column = cycle % DISCRETE_LINE
+            sync = line - (DISCRETE_REGISTERS[7] * 8)
+            moved = !adjusting && moved?(raster, column, DISCRETE_REGISTERS)
+            Beam.new(column:, row:, raster:, vsync: sync.between?(0, 15) ? 16 - sync : 0, shown: line < 200,
+                     start: 0x1000 + ((moved ? row + 1 : row) * 40), frame_line: line)
+          end
+
+          # The beam the module holds, with the row's start as the module
+          # has it: the attribute bits latched in the high word and the
+          # offset into screen RAM, in bytes, in the low.
+          def beam(section)
+            fields = FieldReader.new(section).skip(SELECTED + 1)
+            column, row, raster = fields.bytes(3)
+            fields.skip(3)
+            latched = fields.word
+            offset = fields.word
+            vsync = fields.byte
+            fields.skip(1)
+            shown = fields.flag?
+            fields.skip(12)
+            Beam.new(column:, row:, raster:, vsync:, shown:, start: (latched << 16) | offset,
+                     frame_line: fields.word)
+          end
+
+          def registers(section) = FieldReader.new(section).skip(SETTINGS.length + 5).bytes(REGISTERS)
+
+          def selected(section) = FieldReader.new(section).skip(SELECTED).byte
+
+          # How many cycles into its line xpet's beam is. A beam whose line
+          # has moved on a cycle before it starts holds -1.
+          def column_of(section)
+            column = beam(section).column
+            column < 0x80 ? column : column - 0x100
+          end
+
+          # The CRTC's fields by their BL-CRTC keys at the start of the line
+          # the module's beam is in (#column_of), in a keyed module's writer,
+          # for a board that reads `columns` bytes a character with
+          # `attributes` latched from the frame's start.
+          def import(section, out, columns, attributes)
+            registers = registers(section)
+            beam = beam(section)
+            rows = registers[4] + 1
+            adjusting = beam.row >= rows
+            line = adjusting ? beam.frame_line - (rows * (registers[9] + 1)) : beam.raster
+            start = start_address(beam.start, registers, columns, attributes)
+            if adjusting
+              start += registers[1] if line > registers[9]
+            elsif moved?(line, column_of(section), registers)
+              start -= registers[1]
+            end
+            start &= 0x3fff
+            out.bytes("registers", registers.first(Chips::CRTC::MASKS.length)).int("selected", selected(section) & 0x1f)
+            out.int("column", 0).int("line", [line, 0].max).int("row", adjusting ? rows - 1 : beam.row)
+            out.int("since_hsync", registers[0] + 1 - registers[2]).int("vsync_lines", beam.vsync)
+            out.bool("adjusting", adjusting).bool("row_display", beam.shown).bool("column_display", true)
+            out.int("row_start", start).int("address", start)
+          end
+
+          # The row's start address from the module's (#beam): the bits
+          # that pick screen RAM from its offset, the attribute bits the
+          # board latches from its high word, and those above from R12.
+          def start_address(start, registers, columns, attributes)
+            high = (registers[12] << 8) & HIGH_BITS & ~attributes
+            high | ((start >> 16) & attributes) | (((start & 0xffff) / columns) & SCREEN_BITS)
+          end
+
+          # The discrete video's fields by their BL-VIDEO keys, in a keyed
+          # module's writer.
+          def import_discrete(section, out)
+            cycle = ((beam(section).frame_line * DISCRETE_LINE) + column_of(section) + DISCRETE_LEAD) % DISCRETE_FRAME
+            out.int("column", cycle % DISCRETE_LINE).int("line", cycle / DISCRETE_LINE)
+          end
+        end
+      end
+    end
+  end
+end