badline 0.9.0 → 0.10.0

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

data/lib/badline/vic20/vic/painter.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class VIC
+      # Paints the VIC-I's display a line at a time from what the VIC
+      # fetched for it: each character's pattern byte and colour nibble, the
+      # pixel its first character starts at and how many it fetched. Each
+      # line keeps its own, so the next line's fetches, which can start
+      # before this line's last pixels are out, don't overwrite them, and a
+      # fetch that reads what the same line read a frame ago changes
+      # nothing.
+      #
+      # A line is painted when its last pixel is out, unless a colour
+      # register was written while it was going out: then the pixels up to
+      # the write are painted first, with the old colours. Border,
+      # background and auxiliary colour take hold from the pixel the write
+      # lands on, and the reverse bit two pixels later. A line with the
+      # same fetches and colours as the frame before is left alone.
+      #
+      # A character's colour nibble picks its mode. Below 8 it's a hires
+      # character in that colour: a set bit is the character's colour and a
+      # clear one the background, or the other way round with $900F bit 3
+      # clear. From 8 up it's multicolour, two bits to a double-width pixel:
+      # 00 the background, 01 the border, 10 the character's colour (the
+      # nibble's low three bits) and 11 the auxiliary colour, whatever
+      # $900F bit 3 says (MOS 6560/6561 datasheet, "Color operating modes").
+      class Painter
+        # The characters a line holds room for. A line fetches at most 34.
+        SLOTS = 40
+
+        # What the VIC fetched for each line, SLOTS characters a line, and
+        # whether any of it differs from what the line fetched a frame ago.
+        attr_reader :patterns, :colors, :counts, :starts, :stale
+
+        attr_reader :display, :width, :dirty_lines, :render
+
+        # +blanked+ is the number of lines at the top of the frame that are
+        # never painted.
+        def initialize(lines, width, blanked)
+          @width = width
+          @blanked = blanked
+          @display = Array.new(width * lines, 0)
+          @dirty_lines = Array.new(lines, true)
+          @patterns = Array.new(lines * SLOTS, 0)
+          @colors = Array.new(lines * SLOTS, 0)
+          @counts = Array.new(lines, 0)
+          @starts = Array.new(lines, 0)
+          @stale = Array.new(lines, true)
+          @memo_keys = Array.new(lines, -1)
+          @render = true
+        end
+
+        # Clears the display and starts painting +row+, with the colour
+        # registers at zero.
+        def power_on!(row)
+          @border = @background = @aux = 0
+          @reverse = true
+          @row = row
+          @painted = 0
+          @written = false
+          @counts.fill(0)
+          @stale.fill(true)
+          @memo_keys.fill(-1)
+          @display.fill(0)
+          @dirty_lines.fill(true)
+        end
+
+        def clear_dirty_lines!
+          @dirty_lines.fill(false)
+        end
+
+        # The colours, the line being painted and how far, what each line
+        # fetched, and the display, for a snapshot. Whether it renders is
+        # the host's, and a restored display is all changed.
+        def save_state(out)
+          out.int(@border).int(@background).int(@aux).boolean(@reverse)
+          out.int(@row).int(@painted).boolean(@written)
+          out.blob(@display).blob(@patterns).blob(@colors)
+          out.ints(@counts).ints(@starts).booleans(@stale).ints(@memo_keys)
+        end
+
+        def load_state(input)
+          @border = input.int
+          @background = input.int
+          @aux = input.int
+          @reverse = input.boolean?
+          @row = input.int
+          @painted = input.int
+          @written = input.boolean?
+          input.blob_into(@display)
+          input.blob_into(@patterns)
+          input.blob_into(@colors)
+          input.ints_into(@counts)
+          input.ints_into(@starts)
+          input.booleans_into(@stale)
+          input.ints_into(@memo_keys)
+          @dirty_lines.fill(true)
+        end
+
+        # Painting can be turned off, and once it's back on every line is
+        # painted afresh.
+        def render=(value)
+          @memo_keys.fill(-1)
+          @render = value
+        end
+
+        # $900F written while +position+ of the line is going out.
+        def colors_written(position, value)
+          @written = true
+          paint_to(position)
+          @border = value & 0x07
+          @background = value >> 4
+          paint_to(position + 2)
+          @reverse = value.nobits?(0x08)
+        end
+
+        # The auxiliary colour, $900E bits 7-4, written while +position+ of
+        # the line is going out.
+        def aux_written(position, aux)
+          @written = true
+          paint_to(position)
+          @aux = aux
+        end
+
+        # The current line's last pixel is out: paints what's left of it,
+        # then starts +next_row+.
+        def finish_line(next_row)
+          row = @row
+          if @render && row >= @blanked
+            key = memo_key(row)
+            if @written || @stale[row] || key != @memo_keys[row]
+              paint_to(@width)
+              @memo_keys[row] = @written ? -1 : key
+              @dirty_lines[row] = true
+            end
+          end
+          @stale[row] = false
+          @painted = 0
+          @written = false
+          @row = next_row
+        end
+
+        private
+
+        # The colours and the window's place on +row+, packed into one
+        # Integer.
+        def memo_key(row)
+          count = @counts[row]
+          start = count.zero? ? 0 : @starts[row]
+          @border | (@background << 3) | (@aux << 7) | (@reverse ? 0x800 : 0) | (start << 12) | (count << 24)
+        end
+
+        # Paints the current line's pixels from where it got to up to
+        # +stop+.
+        def paint_to(stop)
+          return unless @render && @row >= @blanked
+
+          x = @painted
+          return if x >= stop
+
+          @painted = stop
+          base = @row * @width
+          border_to = @starts[@row]
+          border_to = stop if border_to > stop
+          x = paint_border(base, x, border_to)
+          x = paint_characters(base, x, stop)
+          paint_border(base, x, stop)
+        end
+
+        # Paints the border from +from+ up to +to+, and returns where it
+        # got to.
+        def paint_border(base, from, to)
+          return from if from >= to
+
+          @display.fill(@border, base + from, to - from)
+          to
+        end
+
+        # Paints the characters from +from+ up to +stop+, and returns where it
+        # got to: +stop+, or the end of the line's characters.
+        def paint_characters(base, from, stop)
+          x = from
+          row = @row
+          start = @starts[row]
+          finish = start + (@counts[row] * 8)
+          slot = row * SLOTS
+          while x < stop && x < finish
+            first = x - start
+            cell = first & ~7
+            last = stop - start - cell
+            last = 8 if last > 8
+            paint_character(base + start + cell, slot + (cell >> 3), first & 7, last)
+            x = start + cell + last
+          end
+          x
+        end
+
+        # Paints pixels +first+ up to +last+ of the character in +slot+,
+        # whose first pixel is at +at+.
+        def paint_character(at, slot, first, last)
+          pattern = @patterns[slot]
+          color = @colors[slot]
+          if color < 8
+            paint_hires(at, pattern, color, first, last)
+          else
+            paint_multicolor(at, pattern, color & 0x07, first, last)
+          end
+        end
+
+        def paint_hires(at, pattern, color, first, last)
+          display = @display
+          set = @reverse ? @background : color
+          clear = @reverse ? color : @background
+          i = first
+          while i < last
+            display[at + i] = pattern.anybits?(0x80 >> i) ? set : clear
+            i += 1
+          end
+        end
+
+        def paint_multicolor(at, pattern, color, first, last)
+          display = @display
+          i = first
+          while i < last
+            pair = (pattern >> (6 - (i & 6))) & 0x03
+            display[at + i] =
+              if pair.zero? then @background
+              elsif pair == 1 then @border
+              elsif pair == 2 then color
+              else @aux
+              end
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic20/vic/saved_state.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class VIC
+      # The VIC's state for a snapshot: the registers and what they set, the
+      # raster, the text window and its fetches, and the picture with what
+      # each line fetched. The sound saves its own.
+      module SavedState
+        def save_state(out)
+          out.marker("VIC20 VIC")
+          out.ints(@registers).int(@rasterline).int(@column).int(@next_event)
+          [@origin_x, @origin_y, @columns, @rows, @char_shift, @screen_base, @char_base].each { |value| out.int(value) }
+          out.boolean(@window_open).boolean(@window_done)
+          [@row_start, @matrix, @char_line, @text_rows].each { |value| out.int(value) }
+          [@fetch_from, @fetch_to, @fetched, @slot, @code].each { |value| out.int(value) }
+          @painter.save_state(out)
+        end
+
+        def load_state(input)
+          input.marker("VIC20 VIC")
+          input.ints_into(@registers)
+          @rasterline = input.int
+          @column = input.int
+          @next_event = input.int
+          load_window(input)
+          @fetch_from = input.int
+          @fetch_to = input.int
+          @fetched = input.int
+          @slot = input.int
+          @code = input.int
+          @painter.load_state(input)
+        end
+
+        private
+
+        def load_window(input)
+          @origin_x = input.int
+          @origin_y = input.int
+          @columns = input.int
+          @rows = input.int
+          @char_shift = input.int
+          @screen_base = input.int
+          @char_base = input.int
+          @window_open = input.boolean?
+          @window_done = input.boolean?
+          @row_start = input.int
+          @matrix = input.int
+          @char_line = input.int
+          @text_rows = input.int
+        end
+      end
+    end
+  end
+end