badline 0.15.1 → 0.16.1

data/lib/badline/pet/keyed_modules.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The whole machine as keyed snapshot modules (Snapshot::Keyed), in the
+    # order a load applies them: BL-MACHINE with the setup, the RAM with
+    # the screen RAM, the last byte on the bus and an 8096's board, both
+    # PIAs, the VIA, the CRTC where the model has one, the picture with
+    # the video's beam, the CPU, the datasettes at cassette ports #1 and
+    # #2, a 2031 on the IEEE-488 bus (IEEEDrive), and device 8 through the
+    # traps.
+    #
+    # A load lays the pages out before the chips load, and works out what
+    # each unit derives from its fields once every unit is loaded.
+    module KeyedModules
+      def save_modules
+        bus = @bus
+        sections = [Snapshot::Keyed.section("BL-MACHINE") { |out| save_machine_fields(out) }]
+        sections << Snapshot::Keyed.section("BL-CPU") { |out| @cpu.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-RAM") { |out| bus.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-PIA1") { |out| @pia1.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-PIA2") { |out| @pia2.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-VIA") { |out| @via.save_fields(out) }
+        save_video_modules(sections)
+        cassettes = @cassettes
+        sections << Snapshot::Keyed.section("BL-TAPE1") { |out| cassettes.datasette1.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-TAPE2") { |out| cassettes.datasette2.save_fields(out) }
+        save_drive_modules(sections)
+        sections << Snapshot::Keyed.section("BL-TRAPDOS") { |out| save_trap_dos_fields(out) } if mounted?
+        sections
+      end
+
+      # Raises Snapshot::FormatError for the modules of a machine built
+      # another way.
+      def load_modules(modules)
+        machine = modules.machine
+        check_snapshot_setup(Snapshot::PETSetup.read_fields(machine))
+        load_machine_fields(machine)
+        @bus.load_fields(modules.required("BL-RAM"))
+        @bus.restored!
+        @pia1.load_fields(modules.required("BL-PIA1"))
+        @pia2.load_fields(modules.required("BL-PIA2"))
+        @via.load_fields(modules.required("BL-VIA"))
+        load_video_modules(modules)
+        @cpu.load_fields(modules.required("BL-CPU"))
+        @cassettes.datasette1.load_fields(modules.required("BL-TAPE1"))
+        @cassettes.datasette2.load_fields(modules.required("BL-TAPE2"))
+        load_drive_modules(modules)
+        trap_dos = modules.optional("BL-TRAPDOS")
+        trap_dos ? load_trap_dos_fields(trap_dos, detached: modules.detached?) : unmount
+        @cpu.restored!
+        @via.restored!
+        self
+      end
+
+      private
+
+      # The CRTC and what the CRTC boards paint from it, or what the
+      # discrete boards paint.
+      def save_video_modules(sections)
+        if @crtc_video
+          sections << Snapshot::Keyed.section("BL-CRTC") { |out| @crtc.save_fields(out) }
+          sections << Snapshot::Keyed.section("BL-VIDEO") { |out| @crtc_output.save_fields(out) }
+        else
+          sections << Snapshot::Keyed.section("BL-VIDEO") { |out| @discrete.save_fields(out) }
+        end
+      end
+
+      def load_video_modules(modules)
+        if @crtc_video
+          @crtc.load_fields(modules.required("BL-CRTC"))
+          @crtc_output.load_fields(modules.required("BL-VIDEO"))
+        else
+          @discrete.load_fields(modules.required("BL-VIDEO"))
+        end
+      end
+
+      def check_snapshot_setup(setup)
+        ours = Snapshot::PETSetup.of(self)
+        return if setup == ours
+
+        raise Snapshot::FormatError, "the snapshot is of a #{setup}, not a #{ours}"
+      end
+    end
+
+    include KeyedModules
+  end
+end

data/lib/badline/pet/keyed_parts.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class Canvas
+      # The picture in a keyed snapshot module, under `prefix`: each dot's
+      # palette index, the row each four dots were last painted from, and
+      # each line's span. Every line is drawn again once loaded.
+      module KeyedState
+        def save_fields(out, prefix)
+          out.bytes("#{prefix}dots", @display).ints("#{prefix}painted", @painted)
+          out.ints("#{prefix}span_from", @span_from).ints("#{prefix}span_to", @span_to)
+        end
+
+        def load_fields(input, prefix)
+          input.bytes_into("#{prefix}dots", @display)
+          input.ints_into("#{prefix}painted", @painted)
+          input.ints_into("#{prefix}span_from", @span_from)
+          input.ints_into("#{prefix}span_to", @span_to)
+          @dirty_lines.fill(true)
+        end
+      end
+
+      include KeyedState
+    end
+
+    class CRTCVideo
+      # Where the beam is on the picture and what the frames so far have
+      # framed it by, and the picture under canvas.*, in a keyed snapshot
+      # module (BL-VIDEO).
+      module KeyedState
+        def save_fields(out)
+          out.int("displayed", @displayed).int("frame_displayed", @frame_displayed).bool("line_shown", @line_shown)
+          out.int("y", @y).int("from_y", @from_y).int("to_y", @to_y).int("shown_from", @shown_from)
+          out.int("shown_to", @shown_to).bool("on_canvas", @on_canvas).int("origin", @origin)
+          out.int("from", @from).int("to", @to)
+          @canvas.save_fields(out, "canvas.")
+        end
+
+        def load_fields(input)
+          @displayed = input.int("displayed", @displayed)
+          @frame_displayed = input.int("frame_displayed", @frame_displayed)
+          @line_shown = input.bool("line_shown", @line_shown)
+          @y = input.int("y", @y)
+          @from_y = input.int("from_y", @from_y)
+          @to_y = input.int("to_y", @to_y)
+          @shown_from = input.int("shown_from", @shown_from)
+          @shown_to = input.int("shown_to", @shown_to)
+          @on_canvas = input.bool("on_canvas", @on_canvas)
+          @origin = input.int("origin", @origin)
+          @from = input.int("from", @from)
+          @to = input.int("to", @to)
+          @canvas.load_fields(input, "canvas.")
+        end
+      end
+
+      include KeyedState
+    end
+
+    class DiscreteVideo
+      # The cycle in the line and the line in the frame, and the picture
+      # under canvas.*, in a keyed snapshot module (BL-VIDEO). The row and
+      # the line of the picture follow from the line on load.
+      module KeyedState
+        def save_fields(out)
+          out.int("column", @column).int("line", @line)
+          @canvas.save_fields(out, "canvas.")
+        end
+
+        def load_fields(input)
+          @column = input.int("column", @column) % CYCLES_PER_LINE
+          @line = input.int("line", @line) % LINES_PER_FRAME
+          follow_line
+          @canvas.load_fields(input, "canvas.")
+        end
+      end
+
+      include KeyedState
+    end
+
+    class Bus
+      class Expansion
+        # The control register and the board's 64K, under `prefix`, and
+        # on the 8296 the user port lines its RAM last followed. The banks
+        # are laid over the pages again once the bus is loaded.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.int("#{prefix}control", @control).bytes("#{prefix}ram", @cells)
+            out.int("#{prefix}user_port", @lines) if @board8296
+          end
+
+          def load_fields(input, prefix)
+            @control = input.byte("#{prefix}control", @control)
+            input.bytes_into("#{prefix}ram", @cells)
+            @lines = input.int("#{prefix}user_port", USER_PORT_LINES) & USER_PORT_LINES
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The RAM below $8000, the screen RAM, all 32K from $8000 on an 8296,
+      # the last byte on the bus under bus.* and an 8096's or 8296's board
+      # under expansion.*, in a keyed snapshot module (BL-RAM). The pages
+      # are laid out again once they are loaded (#restored!). The ROMs come
+      # with the model.
+      module KeyedState
+        def save_fields(out)
+          @ram.save_fields(out, "ram")
+          out.bytes("screen", @screen.cells).int("bus.data", @data)
+          @expansion&.save_fields(out, "expansion.")
+        end
+
+        def load_fields(input)
+          @ram.load_fields(input, "ram")
+          @data = input.byte("bus.data", @data)
+          input.bytes_into("screen", @screen.cells)
+          @expansion&.load_fields(input, "expansion.")
+        end
+
+        def restored! = map_pages
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/pet/keyed_state.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The machine's own fields in a keyed snapshot module (Snapshot::Keyed,
+    # BL-MACHINE): the family, its setup by name (Snapshot::PETSetup), the
+    # cycle count, the vertical drive line, and the host's typing still to
+    # feed and on_init handlers still to run under host.*. The badline
+    # version that wrote it is written for reports and never read.
+    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.
+      attr_reader :init_handlers_lost
+
+      # Whether a snapshot saves now (Machine::Settling): the CPU between
+      # instructions or jammed.
+      def settled_for_snapshot? = @cpu.boundary? || @cpu.jammed?
+
+      # Nothing defers its work past the cycle.
+      def settle_chips_for_snapshot = nil
+
+      def save_machine_fields(out)
+        out.text("family", "pet").text("written_by", VERSION)
+        Snapshot::PETSetup.of(self).write_fields(out)
+        out.int("cycles", @cycles).bool("vertical_drive", @vertical_drive)
+        pending = @pending_keys
+        out.ints("host.pending_keys", pending) if pending
+        out.int("host.init_pending", @cycles <= @init_threshold ? @init_handlers.length : 0)
+      end
+
+      def load_machine_fields(input)
+        @cycles = input.int("cycles", @cycles)
+        @vertical_drive = input.bool("vertical_drive", @vertical_drive)
+        pending = input.ints("host.pending_keys", [])
+        @pending_keys = pending.empty? ? nil : pending.dup
+        @init_handlers_lost = [input.int("host.init_pending", 0) - @init_handlers.length, 0].max
+      end
+    end
+
+    include KeyedState
+  end
+end

data/lib/badline/pet/model.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The PETs and CBMs badline builds by name, after xpet's -model names:
+    # the board's RAM, its stock ROM set and video, and whether a 64K
+    # board banked through $FFF0 is fitted, the 8096's or the 8296's own.
+    #
+    # +video+ is :discrete, the fixed 40-column, 60 Hz generator of the
+    # 2001 and 3000 series, :crtc40 or :crtc80, a 6545 the editor ROM
+    # programs. The CRTC editors come in a 50 Hz and a 60 Hz version, and
+    # the discrete ones run at 60 Hz alone, so +editor_50hz+ and
+    # +editor_60hz+ name the same ROM there.
+    #
+    # The 2001's 1K of screen RAM repeats four times through $8000-$8FFF.
+    # Later boards decode $8000-$87FF alone, the 40-column ones with their
+    # 1K twice over and the 80-column ones with 2K. The 8296 has 128K of
+    # dynamic RAM, the 32K below $8000, the 32K above it, of which the
+    # screen is the start and the rest lies under the ROMs, and the 64K
+    # board (Bus::Expansion).
+    module Model
+      Profile = Data.define(:name, :ram_kb, :basic, :editor_50hz, :editor_60hz, :kernal, :characters, :keyboard,
+                            :video, :expansion) do
+        def crtc? = video != :discrete
+
+        def editor(refresh_hz) = refresh_hz == 50 ? editor_50hz : editor_60hz
+
+        # The 8296, whose board decodes its memory in a PLA.
+        def cbm8296? = name == "8296"
+
+        # The screen RAM's bytes, and on the 8296 all 32K of RAM from $8000.
+        def screen_bytes
+          return 0x8000 if cbm8296?
+
+          video == :crtc80 ? 0x800 : 0x400
+        end
+
+        # How many pages from $8000 on the screen RAM answers in.
+        def screen_pages = name == "2001" || cbm8296? ? 0x10 : 0x08
+
+        # The BASIC 1 KERNAL keeps its keyboard buffer and jiffy clock in
+        # page 2; BASIC 2 and 4 keep them where each other does.
+        def basic1? = basic == "pet/basic1.rom"
+
+        # The BASIC's version, "1", "2" or "4" (ROMSets::BASICS).
+        def basic_version = ROMSets::BASICS.find { |_, roms| roms.first == basic }.first
+
+        # Where the KERNAL keeps its IEEE-488 primitives
+        # (KernalTrap::IEEELayout).
+        def trap_layout
+          case kernal
+          when "pet/kernal1.rom" then KernalTrap::PET_BASIC1_LAYOUT
+          when "pet/kernal2.rom" then KernalTrap::PET_BASIC2_LAYOUT
+          else KernalTrap::PET_BASIC4_LAYOUT
+          end
+        end
+      end
+
+      PET2001 = Profile.new(name: "2001", ram_kb: 8, basic: "pet/basic1.rom", editor_50hz: "pet/editor1.rom",
+                            editor_60hz: "pet/editor1.rom", kernal: "pet/kernal1.rom",
+                            characters: "pet/characters1.rom", keyboard: :graphics, video: :discrete,
+                            expansion: false)
+      PET3032 = Profile.new(name: "3032", ram_kb: 32, basic: "pet/basic2.rom", editor_50hz: "pet/editor2-n.rom",
+                            editor_60hz: "pet/editor2-n.rom", kernal: "pet/kernal2.rom",
+                            characters: "pet/characters2.rom", keyboard: :graphics, video: :discrete,
+                            expansion: false)
+      PET3032B = Profile.new(name: "3032b", ram_kb: 32, basic: "pet/basic2.rom", editor_50hz: "pet/editor2-b.rom",
+                             editor_60hz: "pet/editor2-b.rom", kernal: "pet/kernal2.rom",
+                             characters: "pet/characters2.rom", keyboard: :business, video: :discrete,
+                             expansion: false)
+      PET4032 = Profile.new(name: "4032", ram_kb: 32, basic: "pet/basic4.rom",
+                            editor_50hz: "pet/editor4-40-n-50hz.rom", editor_60hz: "pet/editor4-40-n-60hz.rom",
+                            kernal: "pet/kernal4.rom", characters: "pet/characters2.rom", keyboard: :graphics,
+                            video: :crtc40, expansion: false)
+      CBM8032 = Profile.new(name: "8032", ram_kb: 32, basic: "pet/basic4.rom",
+                            editor_50hz: "pet/editor4-80-b-50hz.rom", editor_60hz: "pet/editor4-80-b-60hz.rom",
+                            kernal: "pet/kernal4.rom", characters: "pet/characters2.rom", keyboard: :business,
+                            video: :crtc80, expansion: false)
+      CBM8096 = Profile.new(name: "8096", ram_kb: 32, basic: "pet/basic4.rom",
+                            editor_50hz: "pet/editor4-80-b-50hz.rom", editor_60hz: "pet/editor4-80-b-60hz.rom",
+                            kernal: "pet/kernal4.rom", characters: "pet/characters2.rom", keyboard: :business,
+                            video: :crtc80, expansion: true)
+
+      CBM8296 = Profile.new(name: "8296", ram_kb: 32, basic: "pet/basic4.rom",
+                            editor_50hz: "pet/editor4-80-b-50hz-8296.rom", editor_60hz: "pet/editor4-80-b-60hz.rom",
+                            kernal: "pet/kernal4.rom", characters: "pet/characters2.rom", keyboard: :business,
+                            video: :crtc80, expansion: true)
+
+      ALL = [PET2001, PET3032, PET3032B, PET4032, CBM8032, CBM8096, CBM8296].freeze
+
+      DEFAULT = "8032"
+
+      # The RAM a board can have, in K, below $8000: the 3008, 3016 and
+      # 4016 are 3032s and 4032s with less of it.
+      RAM_SIZES = [4, 8, 16, 32].freeze
+
+      def self.named(name)
+        model = ALL.find { |candidate| candidate.name == name }
+        raise ArgumentError, "no PET model named #{name}" if model.nil?
+
+        model
+      end
+
+      # Whether the +profile+'s board takes +ram_kb+ below $8000: the 8296
+      # has its 32K soldered on.
+      def self.ram_fits?(profile, ram_kb)
+        profile.cbm8296? ? ram_kb == 32 : RAM_SIZES.include?(ram_kb)
+      end
+
+      # The +jumpers+ the +profile+'s board has fitted, which only the
+      # 8296's takes (ROMSets::JUMPERS), in that order. Raises
+      # ArgumentError for any it doesn't have.
+      def self.checked_jumpers(profile, jumpers)
+        known = ROMSets.jumpers(profile.name)
+        unknown = jumpers.reject { |jumper| known.include?(jumper) }
+        raise ArgumentError, "the #{profile.name} has no jumper #{unknown.first}" unless unknown.empty?
+
+        known.select { |jumper| jumpers.include?(jumper) }
+      end
+
+      # The +profile+ with the character ROM ROMSets::CHARACTERS names in
+      # place of its own, nil for its own. Raises ArgumentError for one the
+      # model doesn't take.
+      def self.fitted(profile, characters)
+        return profile if characters.nil?
+
+        name = profile.name
+        unless ROMSets.characters(name).include?(characters)
+          raise ArgumentError, "the #{name} takes no character ROM #{characters}"
+        end
+
+        Profile.new(name:, ram_kb: profile.ram_kb, basic: profile.basic, editor_50hz: profile.editor_50hz,
+                    editor_60hz: profile.editor_60hz, kernal: profile.kernal,
+                    characters: ROMSets::CHARACTERS.fetch(characters), keyboard: profile.keyboard,
+                    video: profile.video, expansion: profile.expansion)
+      end
+
+      # The +profile+ with the BASIC and the editor ROMSets names in place
+      # of its own: +basic+ a key of ROMSets::BASICS and +editor+ one of
+      # ROMSets::EDITORS, each nil for the one that fits. An editor named
+      # serves at either frame rate, so the machine's has to be its own.
+      # Raises ArgumentError for ROMs the model doesn't take.
+      def self.upgraded(profile, basic, editor)
+        return profile if basic.nil? && editor.nil?
+
+        name = profile.name
+        basic ||= ROMSets.stock_basic(name)
+        fitting = ROMSets.editors(name, basic)
+        raise ArgumentError, "the #{name} takes no BASIC #{basic}" if fitting.empty?
+        unless editor.nil? || fitting.include?(editor)
+          raise ArgumentError, "the #{name} with BASIC #{basic} takes no editor #{editor}"
+        end
+
+        basic_rom, kernal = ROMSets::BASICS.fetch(basic)
+        Profile.new(name:, ram_kb: profile.ram_kb, basic: basic_rom,
+                    editor_50hz: ROMSets::EDITORS.fetch(editor || fitting.first),
+                    editor_60hz: ROMSets::EDITORS.fetch(editor || fitting.last), kernal:,
+                    characters: profile.characters, keyboard: profile.keyboard, video: profile.video,
+                    expansion: profile.expansion)
+      end
+    end
+  end
+end

data/lib/badline/pet/rom_sets.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The BASIC and editor ROMs each model's board takes: its own, and the
+    # upgrades Commodore sold for it, BASIC 2 for the 2001 and BASIC 4 for
+    # the 3032s, and the 8296's character ROMs and board jumpers. Options
+    # reads it to check --basic, --editor, --characters and --jumpers, so
+    # it loads nothing else.
+    #
+    # An editor ROM goes with one BASIC, scans one keyboard and drives one
+    # board's video, so a model and a BASIC fit one editor, and on a CRTC
+    # board its 50 Hz and its 60 Hz versions.
+    module ROMSets
+      # BASIC's ROM and its KERNAL's, by version.
+      BASICS = {
+        "1" => %w[pet/basic1.rom pet/kernal1.rom], "2" => %w[pet/basic2.rom pet/kernal2.rom],
+        "4" => %w[pet/basic4.rom pet/kernal4.rom]
+      }.freeze
+
+      # The editors by the names --editor takes: the BASIC, the keyboard,
+      # N or B, and on a CRTC board the columns and the frame rate.
+      EDITORS = {
+        "1" => "pet/editor1.rom", "2-n" => "pet/editor2-n.rom", "2-b" => "pet/editor2-b.rom",
+        "4-n" => "pet/editor4-n.rom", "4-b" => "pet/editor4-b.rom", "4-40-n-50hz" => "pet/editor4-40-n-50hz.rom",
+        "4-40-n-60hz" => "pet/editor4-40-n-60hz.rom", "4-80-b-50hz" => "pet/editor4-80-b-50hz.rom",
+        "4-80-b-50hz-0283" => "pet/editor4-80-b-50hz-0283.rom", "4-80-b-60hz" => "pet/editor4-80-b-60hz.rom",
+        "4-80-b-50hz-8296" => "pet/editor4-80-b-50hz-8296.rom"
+      }.freeze
+
+      # The BASICs each model takes, its own first, and the editors that
+      # fit each, the 50 Hz one first and the 60 Hz one last on a CRTC
+      # board. The 8032's other 50 Hz editor, 901474-04 dated 0283, sits
+      # between them, and the 8296 takes the 8032's as well as its own.
+      FITS = {
+        "2001" => { "1" => %w[1], "2" => %w[2-n] },
+        "3032" => { "2" => %w[2-n], "4" => %w[4-n] },
+        "3032b" => { "2" => %w[2-b], "4" => %w[4-b] },
+        "4032" => { "4" => %w[4-40-n-50hz 4-40-n-60hz] },
+        "8032" => { "4" => %w[4-80-b-50hz 4-80-b-50hz-0283 4-80-b-60hz] },
+        "8096" => { "4" => %w[4-80-b-50hz 4-80-b-50hz-0283 4-80-b-60hz] },
+        "8296" => { "4" => %w[4-80-b-50hz-8296 4-80-b-50hz 4-80-b-50hz-0283 4-80-b-60hz] }
+      }.freeze
+
+      # The character ROMs by the names --characters takes, and the ones
+      # each model's board takes, its own first: the 8296's socket takes
+      # 901447-10, its ASCII one, or the 4K 324242-01, which holds a DIN set
+      # in its first half and 901447-10 in its second.
+      CHARACTERS = { "ascii" => "pet/characters2.rom", "din" => "pet/characters-din.rom" }.freeze
+
+      CHARACTER_FITS = { "8296" => %w[ascii din] }.freeze
+
+      # The jumpers each model's board takes, by the names --jumpers takes
+      # (Bus::Expansion), none on a board not named.
+      JUMPERS = { "8296" => %w[ram9 rama userport] }.freeze
+
+      # The cycles a line and the lines a frame the CRTC editors set up
+      # where they differ from 50-cycle lines, 400 a frame at 50 Hz and 333
+      # at 60 Hz, by the editor's ROM.
+      CRTC_FRAMES = {
+        "pet/editor4-80-b-50hz-0283.rom" => [64, 313], "pet/editor4-80-b-50hz-8296.rom" => [59, 339]
+      }.freeze
+
+      # The cycles a line and the lines a frame the CRTC editor in the ROM
+      # named sets up at +refresh_hz+.
+      def self.crtc_frame(editor, refresh_hz) = CRTC_FRAMES[editor] || [50, refresh_hz == 50 ? 400 : 333]
+
+      # The BASIC the model has, without --basic.
+      def self.stock_basic(model) = FITS.fetch(model).keys.first
+
+      # The editors that fit the model with the BASIC, or an empty list for
+      # a BASIC it doesn't take.
+      def self.editors(model, basic) = FITS.fetch(model).fetch(basic, [])
+
+      # The character ROMs the model takes, by name, none for one that takes
+      # only its own.
+      def self.characters(model) = CHARACTER_FITS.fetch(model, [])
+
+      # The jumpers the model's board takes.
+      def self.jumpers(model) = JUMPERS.fetch(model, [])
+
+      # The editor that fits the model with the BASIC at +refresh_hz+.
+      def self.editor(model, basic, refresh_hz)
+        fitting = editors(model, basic)
+        refresh_hz == 60 ? fitting.last : fitting.first
+      end
+    end
+  end
+end

data/lib/badline/pet/sound.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The PET's sound: the level the VIA drives on CB2, which the 4000 and
+    # 8000 series take to their internal speaker and every model to the
+    # user port's pin M, where the 2001 and 3000 series had their speaker
+    # added. CB2 carries the shift register's bits in its shift-out modes,
+    # mode 4's free-running square wave under timer 2 for the bell and most
+    # PET music, and the PCR's CB2 output otherwise, held high or low by
+    # hand or floating high as an input.
+    #
+    # The machine calls #cycle! once a cycle while #recording?, from #record
+    # on, so a sound nobody records costs only that check. Each sample is
+    # the share of its cycles CB2 spent high, through the output stage: a
+    # one-pole low-pass at 5 kHz and a one-pole high-pass at 100 Hz, so a
+    # line left high or low settles to silence.
+    class Sound
+      LOW_PASS_HZ = 5_000
+      HIGH_PASS_HZ = 100
+
+      # A swing from CB2 low to CB2 high, as a signed 16-bit sample.
+      SCALE = 24_000.0
+
+      def initialize(via)
+        @via = via
+        @recording = false
+        @high = true
+        @run = 0
+        @rate = 0
+        @clock_hz = 0
+        @remainder = 0
+        @window = 0
+        @left = 0
+        @sum = 0
+        @low = 0.0
+        @drift = 0.0
+        @low_pass = 0.0
+        @high_pass = 0.0
+        @samples = []
+      end
+
+      def model = :cb2
+
+      attr_reader :recording
+      alias recording? recording
+
+      # Starts collecting the output, averaged down to `rate` samples a
+      # second at `clock_hz` cycles a second, for #drain_samples. The
+      # output stage takes CB2's level now as settled.
+      def record(rate:, clock_hz: 1_000_000)
+        @rate = rate
+        @clock_hz = clock_hz
+        @remainder = 0
+        @window = next_window
+        @left = @window
+        @sum = 0
+        @high = @via.cb2_output
+        @run = 0
+        @low = @drift = @high ? 1.0 : 0.0
+        @low_pass = 1.0 - Math.exp(-2.0 * Math::PI * LOW_PASS_HZ / rate)
+        @high_pass = 1.0 - Math.exp(-2.0 * Math::PI * HIGH_PASS_HZ / rate)
+        @samples = []
+        @recording = true
+      end
+
+      # Takes CB2's level for this cycle, while recording.
+      def cycle!
+        high = @via.cb2_output
+        if high == @high
+          @run += 1
+        else
+          hold(@high, @run)
+          @high = high
+          @run = 1
+        end
+      end
+
+      # The samples closed since the last drain.
+      def drain_samples
+        return [] unless @recording
+
+        hold(@high, @run)
+        @run = 0
+        samples = @samples
+        @samples = []
+        samples
+      end
+
+      private
+
+      # Adds `cycles` cycles with CB2 high or low, closing every sample
+      # they finish.
+      def hold(high, cycles)
+        left = @left
+        while cycles >= left
+          @sum += left if high
+          cycles -= left
+          close
+          left = @left
+        end
+        @sum += cycles if high
+        @left = left - cycles
+      end
+
+      def close
+        @low += @low_pass * (@sum.fdiv(@window) - @low)
+        @drift += @high_pass * (@low - @drift)
+        sample = ((@low - @drift) * SCALE).round
+        sample = 32_767 if sample > 32_767
+        sample = -32_768 if sample < -32_768
+        @samples << sample
+        @sum = 0
+        @window = next_window
+        @left = @window
+      end
+
+      # Each window is a whole number of cycles, and they add up to the
+      # clock's cycles over a second.
+      def next_window
+        @remainder += @clock_hz
+        cycles = @remainder / @rate
+        @remainder -= cycles * @rate
+        cycles
+      end
+    end
+  end
+end

data/lib/badline/pet/via.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # The PET's 6522 at $E840, a class of its own so its peripheral keeps
+    # one type (PET::VIAPorts), apart from the VIC-20's and the drives'.
+    class VIA < Chips::VIA
+    end
+  end
+end

data/lib/badline/pet/via_ports.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    # What the VIA's ports read from outside the chip. Port B's PB5 is the
+    # vertical drive line, low in the retrace, and PB0, PB6 and PB7 read
+    # the IEEE-488 bus's NDAC, NRFD and DAV (IEEEPorts). The user port on
+    # port A floats high.
+    class VIAPorts
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def read_a(_lines) = 0xff
+
+      def read_b(_lines) = @machine.ieee.via_inputs & (@machine.vertical_drive? ? 0xff : 0xdf)
+    end
+  end
+end