badline 0.8.0 → 0.10.0

data/lib/badline/vic20/saved_state.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    MARKER = "VIC20"
+
+    # The RAM expansion of the machine a State from #snapshot was taken
+    # of, a key of Bus::RAM_CONFIGURATIONS.
+    def self.setup(state)
+      input = Snapshot::StateReader.new(state)
+      input.marker(MARKER)
+      input.check_stamp
+      SavedState.read_ram(input)
+    end
+
+    # A new machine, built as the one a State from #snapshot was taken of,
+    # at that state.
+    def self.restored(state) = new(ram: setup(state)).apply_state(state)
+
+    # The whole machine's state for a snapshot, as Computer's: the
+    # machine's own latches, the bus with its RAM and cartridge ROM, the
+    # VIC with its sound, both VIAs, the CPU, the datasette and its tape,
+    # the disk device 8 serves through the traps, and a true 1541. The
+    # serial lines go back into the bus from the restored VIAs. What the
+    # host holds stays out: the keyboard, the joystick, RESTORE, the traps
+    # and callbacks, whether the display renders, whether the sound
+    # records, and whether the datasette records.
+    module SavedState
+      RAM_CONFIGURATIONS = Bus::RAM_CONFIGURATIONS.keys.freeze
+
+      def self.read_ram(input)
+        RAM_CONFIGURATIONS.fetch(input.int)
+      rescue IndexError
+        raise Snapshot::FormatError, "the state names a VIC-20 RAM expansion badline doesn't know"
+      end
+
+      # How many more on_init handlers the machine a State was taken of had
+      # yet to run than this one has. Nil until the machine is restored.
+      attr_reader :init_handlers_lost
+
+      def snapshot
+        out = Snapshot::StateWriter.new
+        save_state(out)
+        out.state
+      end
+
+      # Takes the machine back to a State from #snapshot, trying it on a new
+      # machine first, so one that fails leaves this machine as it was.
+      # Raises Snapshot::FormatError for a state of another machine or RAM
+      # expansion.
+      def restore(state)
+        check_ram(Vic20.setup(state))
+        Vic20.restored(state)
+        apply_state(state)
+      end
+
+      # Puts a State into the machine without trying it on a new one first.
+      def apply_state(state)
+        input = Snapshot::StateReader.new(state)
+        load_state(input)
+        raise Snapshot::FormatError, "the state goes on past the machine" unless input.finished?
+
+        self
+      end
+
+      def save_state(out)
+        out.marker(MARKER).stamp
+        out.int(RAM_CONFIGURATIONS.index(@ram_configuration))
+        out.int(@cycles).boolean(@nmi_asserted).boolean(!@pending_keys.nil?)
+        out.ints(@pending_keys) if @pending_keys
+        out.int(@cycles <= @init_threshold ? @init_handlers.length : 0)
+        @bus.save_state(out)
+        @vic.save_state(out)
+        @sound.save_state(out)
+        @via1.save_state(out)
+        @via2.save_state(out)
+        @cpu.save_state(out)
+        @datasette.save_state(out)
+        save_trap_drive(out)
+        save_drive1541(out)
+      end
+
+      def load_state(input)
+        input.marker(MARKER)
+        input.check_stamp
+        check_ram(SavedState.read_ram(input))
+        @cycles = input.int
+        @nmi_asserted = input.boolean?
+        @pending_keys = nil
+        @pending_keys = input.ints if input.boolean?
+        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
+        @bus.load_state(input)
+        @vic.load_state(input)
+        @sound.load_state(input)
+        @via1.load_state(input)
+        @via2.load_state(input)
+        @cpu.load_state(input)
+        via_written
+        @datasette.load_state(input)
+        load_trap_drive(input)
+        load_drive1541(input)
+      end
+
+      private
+
+      # The disk device 8 serves through the traps, with its channels.
+      def save_trap_drive(out)
+        out.boolean(!@drive.nil?)
+        return unless @drive
+
+        @drive.save_state(out)
+        @serial_trap.save_state(out)
+        @save_trap.save_state(out)
+      end
+
+      def load_trap_drive(input)
+        return unmount unless input.boolean?
+
+        storage = Storage.reopen(input)
+        unmount
+        mount(storage)
+        @drive.load_state(input)
+        @serial_trap.load_state(input)
+        @save_trap.load_state(input)
+      end
+
+      # A true 1541 on the serial bus, with its device number.
+      def save_drive1541(out)
+        out.boolean(!@drive1541.nil?)
+        return unless @drive1541
+
+        out.int(@drive1541.device)
+        @drive1541.save_state(out)
+      end
+
+      def load_drive1541(input)
+        return detach_drive1541 unless input.boolean?
+
+        device = input.int
+        detach_drive1541 if @drive1541 && @drive1541.device != device
+        attach_drive1541(Drive1541.new(device:)) unless @drive1541
+        @drive1541.load_state(input)
+      end
+
+      def check_ram(ram)
+        return if ram == @ram_configuration
+
+        raise Snapshot::FormatError, "the state is of a VIC-20 with #{ram} RAM, not #{@ram_configuration}"
+      end
+    end
+  end
+end

data/lib/badline/vic20/sound/output.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class Sound
+      # The sound's level averaged over each sample of the audio rate, then
+      # through the machine's output stage: a one-pole low-pass at 1,420 Hz
+      # and a one-pole high-pass at 158 Hz, both run at the audio rate.
+      #
+      # The two corners are fitted to xvic's step response: a voice turned
+      # on at volume 15 rises and decays back to the line as those two RC
+      # stages do, within 6 parts in 11,000.
+      class Output
+        LOW_PASS_HZ = 1_420
+        HIGH_PASS_HZ = 158
+
+        # Scales the loudest level, four voices high at volume 15, to the
+        # top of a signed 16-bit sample.
+        SCALE = 32_767.0 / 570
+
+        attr_reader :samples
+
+        # `level` is the sound's level as the recording starts, which the
+        # stage takes as settled.
+        def initialize(clock_hz:, rate:, level:)
+          @clock_hz = clock_hz
+          @rate = rate
+          @remainder = 0
+          @window = next_window
+          @left = @window
+          @sum = 0
+          @low = @drift = level.to_f
+          @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 = []
+        end
+
+        # Adds `cycles` cycles at `level`, closing every sample they finish.
+        def hold(level, cycles)
+          left = @left
+          while cycles >= left
+            @sum += level * left
+            cycles -= left
+            close
+            left = @left
+          end
+          @sum += level * cycles
+          @left = left - cycles
+        end
+
+        # The samples closed since the last drain.
+        def drain
+          samples = @samples
+          @samples = []
+          samples
+        end
+
+        private
+
+        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
+end

data/lib/badline/vic20/sound.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "badline/vic20/sound/output"
+
+module Badline
+  class Vic20
+    # The VIC-I's sound: three square-wave voices, bass, alto and soprano at
+    # $900A-$900C, a noise voice at $900D, and the volume in $900E bits 0-3.
+    #
+    # Each voice has a 7-bit counter, ticked every 16, 8, 4 or 2 cycles from
+    # bass to noise. It counts up from the low 7 bits of its register, and
+    # on the tick it would reach 127 it reloads from the register instead.
+    # So a voice's counter comes round every 128 - ((value + 1) & 127)
+    # ticks, and the register's new value takes hold at the next reload.
+    #
+    # A tone voice's counter shifts an 8-bit shift register at each reload,
+    # bit 7 out and back into bit 0 inverted while bit 7 of the register
+    # enables the voice, and a zero while it doesn't. Bit 0 is the voice's
+    # output: a square wave of 16 shifts while the voice is on, which a
+    # voice turned off shifts out to silence.
+    #
+    # The noise voice's counter shifts a 16-bit LFSR instead, bit 0 in from
+    # the XOR of bits 3, 12, 14 and 15 while the voice is on and a one
+    # while it's off. Each time the LFSR's bit 0 rises, it shifts the noise
+    # voice's own 8-bit shift register, bit 7 back into bit 0, inverted
+    # while the voice is on. Its bit 0 is the voice's output while the voice
+    # is on, and it is silent while it's off.
+    #
+    # The output is the voices that are high, plus a little more, times the
+    # volume, so a volume write steps the output even with every voice off.
+    #
+    # The voices only run while #record collects the output: nothing the
+    # CPU reads depends on them. Until then a write only sets the register.
+    # While recording, the voices catch up to the current cycle whenever a
+    # write lands or the samples are drained, one shift at a time.
+    class Sound
+      VOICES = 4
+      NOISE = 3
+
+      # The cycles between ticks of each voice's counter.
+      DIVIDERS = [16, 8, 4, 2].freeze
+
+      # What a voice that is high adds to the output's level, and what the
+      # output carries with every voice low, before the volume.
+      VOICE_LEVEL = 9
+      IDLE_LEVEL = 2
+
+      attr_reader :volume
+
+      # `clock` answers the machine's cycles, `clock_hz` the rate they run at.
+      def initialize(clock, clock_hz)
+        @clock = clock
+        @clock_hz = clock_hz
+        @output = nil
+        @time = 0
+        @shift_registers = Array.new(VOICES, 0)
+        @next_shifts = Array.new(VOICES, 0)
+        @frequencies = Array.new(VOICES, 0)
+        @enabled = Array.new(VOICES, false)
+        power_on!
+      end
+
+      def model = :mos6561
+
+      # The power-on state: every register clear and the tone voices' shift
+      # registers empty. The noise voice's LFSR and shift register start full
+      # of ones, as a noise voice left off fills them.
+      def power_on!
+        now = @clock.cycles
+        run_to(now)
+        @volume = 0
+        VOICES.times do |voice|
+          @frequencies[voice] = 0
+          @enabled[voice] = false
+          @shift_registers[voice] = 0
+          divider = DIVIDERS[voice]
+          @next_shifts[voice] = ((now / divider) + 128) * divider
+        end
+        @shift_registers[NOISE] = 0xff
+        @lfsr = 0xffff
+        @level = level_now
+      end
+
+      # Starts collecting the output, averaged down to `rate` samples a
+      # second, for #drain_samples. `clock_hz` is the rate the cycles are
+      # taken to run at.
+      def record(rate:, clock_hz: @clock_hz)
+        now = @clock.cycles
+        run_to(now)
+        resume(now)
+        @output = Output.new(clock_hz:, rate:, level: @level)
+      end
+
+      def recording? = !@output.nil?
+
+      # The samples recorded since the last drain.
+      def drain_samples
+        output = @output
+        return [] if output.nil?
+
+        run_to(@clock.cycles)
+        output.drain
+      end
+
+      # A write to $900A-$900E, which takes hold from the next cycle.
+      def write(register, value)
+        run_to(@clock.cycles + 1)
+        if register == 0x0e
+          @volume = value & 0x0f
+        else
+          voice = register - 0x0a
+          @frequencies[voice] = value & 0x7f
+          @enabled[voice] = value >= 0x80
+        end
+        @level = level_now
+      end
+
+      # The registers and the voices as they last ran, for a snapshot.
+      # Recording is the host's, and starts the voices again from the
+      # cycle it starts at.
+      def save_state(out)
+        run_to(@clock.cycles)
+        out.marker("VIC20 SOUND").int(@volume).ints(@frequencies).booleans(@enabled)
+        out.ints(@shift_registers).ints(@next_shifts).int(@lfsr).int(@level).int(@time)
+      end
+
+      def load_state(input)
+        input.marker("VIC20 SOUND")
+        @volume = input.int
+        input.ints_into(@frequencies)
+        input.booleans_into(@enabled)
+        input.ints_into(@shift_registers)
+        input.ints_into(@next_shifts)
+        @lfsr = input.int
+        @level = input.int
+        @time = input.int
+        resume(@clock.cycles) if recording?
+      end
+
+      # A voice's shift register as of the current cycle, while recording.
+      def shift_register(voice)
+        run_to(@clock.cycles)
+        @shift_registers[voice]
+      end
+
+      def lfsr
+        run_to(@clock.cycles)
+        @lfsr
+      end
+
+      private
+
+      # Moves each shift that the cycles since the voices last ran have
+      # passed to its next turn from `now`, keeping its phase.
+      def resume(now)
+        @time = now
+        VOICES.times do |voice|
+          due = @next_shifts[voice]
+          next if due >= now
+
+          interval = period(voice) * DIVIDERS[voice]
+          @next_shifts[voice] = due + ((now - due + interval - 1) / interval * interval)
+        end
+      end
+
+      # Runs the voices up to the start of cycle `target`, the output holding
+      # each level for the cycles it lasts.
+      def run_to(target)
+        time = @time
+        output = @output
+        return if output.nil? || target <= time
+
+        following = next_shift
+        while following < target
+          output.hold(@level, following - time)
+          time = following
+          shift_due(time)
+          @level = level_now
+          following = next_shift
+        end
+        output.hold(@level, target - time)
+        @time = target
+      end
+
+      def next_shift
+        shifts = @next_shifts
+        following = shifts[0]
+        following = shifts[1] if shifts[1] < following
+        following = shifts[2] if shifts[2] < following
+        following = shifts[3] if shifts[3] < following
+        following
+      end
+
+      def shift_due(time)
+        shifts = @next_shifts
+        VOICES.times do |voice|
+          next unless shifts[voice] == time
+
+          voice == NOISE ? step_noise : shift_tone(voice)
+          shifts[voice] = time + (period(voice) * DIVIDERS[voice])
+        end
+      end
+
+      def shift_tone(voice)
+        bits = @shift_registers[voice]
+        fill = @enabled[voice] && bits < 0x80 ? 1 : 0
+        @shift_registers[voice] = ((bits << 1) | fill) & 0xff
+      end
+
+      def step_noise
+        lfsr = @lfsr
+        enabled = @enabled[NOISE]
+        fill = enabled ? ((lfsr >> 3) ^ (lfsr >> 12) ^ (lfsr >> 14) ^ (lfsr >> 15)) & 1 : 1
+        @lfsr = ((lfsr << 1) | fill) & 0xffff
+        return unless fill == 1 && lfsr.even?
+
+        bits = @shift_registers[NOISE]
+        fill = (bits >> 7) ^ (enabled ? 1 : 0)
+        @shift_registers[NOISE] = ((bits << 1) | fill) & 0xff
+      end
+
+      # The ticks between two reloads of a voice's counter.
+      def period(voice) = 128 - ((@frequencies[voice] + 1) & 0x7f)
+
+      def level_now
+        registers = @shift_registers
+        high = (registers[0] & 1) + (registers[1] & 1) + (registers[2] & 1)
+        high += registers[NOISE] & 1 if @enabled[NOISE]
+        ((high * VOICE_LEVEL) + IDLE_LEVEL) * @volume
+      end
+    end
+  end
+end

data/lib/badline/vic20/user_via_ports.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    # What VIA 1's ports read from outside the chip. Port A carries the
+    # serial bus's CLK and DATA on PA0 and PA1, which read 1 while a line
+    # is released, the joystick's up, down and left switches on PA2-PA4,
+    # its fire button on PA5, the line the light pen shares, and the
+    # cassette sense switch on PA6, low while a key is down on the deck.
+    # The right switch is on VIA 2 (see KeyboardVIAPorts). PA7 drives ATN
+    # out and reads back what it drives. Port B is the user port, with
+    # nothing plugged in.
+    #
+    # CA2 drives the cassette motor, which runs while CA2 is low, and the
+    # RESTORE key pulls CA1 (see Vic20#press_restore).
+    class UserVIAPorts
+      attr_reader :joystick
+
+      def initialize(joystick:, serial_bus:, datasette:)
+        @joystick = joystick
+        @serial_bus = serial_bus
+        @datasette = datasette
+      end
+
+      # The joystick's up, down and left bits (0-2) move up two, and its
+      # fire bit (4) up one.
+      def read_a(_lines)
+        bits = @joystick.port_bits
+        value = 0x80 | ((bits & 0x07) << 2) | ((bits & 0x10) << 1)
+        value |= 0x40 unless @datasette.sense_low?
+        value | serial_inputs
+      end
+
+      def read_b(_lines) = 0xff
+
+      private
+
+      def serial_inputs
+        low = @serial_bus.low_lines
+        value = 0x03
+        value &= ~0x01 if low.anybits?(IECBus::CLK)
+        value &= ~0x02 if low.anybits?(IECBus::DATA)
+        value
+      end
+    end
+  end
+end