badline 0.12.1 → 0.14.0

data/lib/badline/chips/vic_i/keyed_parts.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VICI
+      class Sound
+        # The sound's fields in a keyed snapshot module, under `prefix`:
+        # the voices' shift registers, the noise LFSR, the level, and when
+        # each voice next shifts, in cycles from the machine's clock, with
+        # how far behind the clock the voices last ran. The volume and the
+        # voices' frequencies come from the VIC's registers on load.
+        module KeyedState
+          def save_fields(out, prefix)
+            now = @clock.cycles
+            run_to(now)
+            out.ints("#{prefix}shift_registers", @shift_registers).int("#{prefix}lfsr", @lfsr)
+            out.int("#{prefix}level", @level).int("#{prefix}ran_ago", now - @time)
+            out.ints("#{prefix}next_shifts", @next_shifts.map { |due| due - now })
+          end
+
+          def load_fields(input, prefix)
+            now = @clock.cycles
+            input.ints_into("#{prefix}shift_registers", @shift_registers)
+            @lfsr = input.masked("#{prefix}lfsr", @lfsr, 0xffff)
+            @level = input.int("#{prefix}level", @level)
+            @time = now - input.int("#{prefix}ran_ago", now - @time)
+            relative = input.ints("#{prefix}next_shifts", @next_shifts.map { |due| due - now })
+            VOICES.times { |voice| @next_shifts[voice] = now + relative.fetch(voice, 0) }
+          end
+
+          # $900A to $900E as written.
+          def restore_registers(registers)
+            @volume = registers[0x0e] & 0x0f
+            VOICES.times do |voice|
+              value = registers[0x0a + voice]
+              @frequencies[voice] = value & 0x7f
+              @enabled[voice] = value >= 0x80
+            end
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Painter
+        # The lines' fetches and the line going out, as this painter lays
+        # them out (VICI::LINE_LAYOUT), and the picture.
+        module KeyedState
+          def save_fields(out)
+            out.int("line.row", @row).int("line.painted", @painted).bool("line.written", @written)
+            out.bytes("line.patterns", @patterns).bytes("line.colors", @colors)
+            out.ints("line.counts", @counts).ints("line.starts", @starts).bytes("display", @display)
+          end
+
+          def load_fields(input, layout)
+            input.bytes_into("display", @display)
+            return unless layout
+
+            @row = input.int("line.row", @row)
+            @painted = input.int("line.painted", @painted)
+            @written = input.bool("line.written", @written)
+            input.bytes_into("line.patterns", @patterns)
+            input.bytes_into("line.colors", @colors)
+            input.ints_into("line.counts", @counts)
+            input.ints_into("line.starts", @starts)
+          end
+
+          # The colours as $900E and $900F hold them, every line to be
+          # painted afresh, and the whole display changed.
+          def restored!(registers)
+            @border = registers[0x0f] & 0x07
+            @background = registers[0x0f] >> 4
+            @reverse = registers[0x0f].nobits?(0x08)
+            @aux = registers[0x0e] >> 4
+            @stale.fill(true)
+            @memo_keys.fill(-1)
+            @dirty_lines.fill(true)
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The shape of the painter's per-line fields. A snapshot whose
+      # line.layout differs leaves them at power-on.
+      LINE_LAYOUT = 1
+
+      # The VIC-I's fields in a keyed snapshot module (Snapshot::Keyed): the
+      # registers, the beam, the text window's counters and the fetch in
+      # flight, the painter's lines under line.*, the picture, and the sound
+      # under sound.* What the registers decode to, where the line's fetches
+      # end and the next event are worked out on load.
+      module KeyedState
+        def save_fields(out)
+          out.bytes("registers", @registers).int("raster", @rasterline).int("column", @column)
+          out.bool("window_open", @window_open).bool("window_done", @window_done).int("row_start", @row_start)
+          out.int("matrix", @matrix).int("char_line", @char_line).int("text_rows", @text_rows)
+          out.int("fetch_from", @fetch_from).int("fetched", @fetched).int("code", @code)
+          out.int("line.layout", LINE_LAYOUT)
+          @painter.save_fields(out)
+          @sound&.save_fields(out, "sound.")
+          out
+        end
+
+        def load_fields(input)
+          input.bytes_into("registers", @registers)
+          @rasterline = input.int("raster", @rasterline)
+          @column = input.int("column", @column)
+          @window_open = input.bool("window_open", @window_open)
+          @window_done = input.bool("window_done", @window_done)
+          @row_start = input.int("row_start", @row_start)
+          @matrix = input.int("matrix", @matrix)
+          @char_line = input.int("char_line", @char_line)
+          @text_rows = input.int("text_rows", @text_rows)
+          @fetch_from = input.int("fetch_from", @fetch_from)
+          @fetched = input.int("fetched", @fetched)
+          @code = input.byte("code", @code)
+          line = input.int("line.layout", 0) == LINE_LAYOUT
+          input.adjust("line in progress from another renderer, restarted") unless line || input.missing?
+          @painter.load_fields(input, line)
+          @sound&.load_fields(input, "sound.")
+        end
+
+        def restored!
+          @origin_x = @registers[0] & 0x7f
+          @columns = @registers[2] & 0x7f
+          @origin_y = @registers[1]
+          rows_written(@registers[3])
+          bases_written
+          @slot = @rasterline * Painter::SLOTS
+          @fetch_to = 0
+          fetches_end if @window_open
+          schedule
+          @painter.restored!(@registers)
+          @sound&.restore_registers(@registers)
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/{vic20/vic → chips/vic_i}/painter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Badline
-  class Vic20
-    class VIC
+  module Chips
+    class VICI
       # 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
@@ -70,34 +70,6 @@ module Badline
           @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)

data/lib/badline/chips/vic_i/sound/output.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VICI
+      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
+end

data/lib/badline/chips/vic_i/sound.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "badline/chips/vic_i/sound/output"
+
+module Badline
+  module Chips
+    class VICI
+      # 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 catch up to the current cycle whenever a write lands, the
+      # samples are drained or #catch_up! asks, one shift at a time, whether
+      # or not #record collects the output, so their state doesn't depend on
+      # whether the host plays it. Unrecorded, while every voice is off and
+      # shifted out to silence, they skip to the cycle at once.
+      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)
+          run_to(@clock.cycles)
+          @output = Output.new(clock_hz:, rate:, level: @level)
+        end
+
+        def recording? = !@output.nil?
+
+        # Runs the voices up to the current cycle.
+        def catch_up! = run_to(@clock.cycles)
+
+        # 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
+
+        # A voice's shift register as of the current cycle.
+        def shift_register(voice)
+          run_to(@clock.cycles)
+          @shift_registers[voice]
+        end
+
+        def lfsr
+          run_to(@clock.cycles)
+          @lfsr
+        end
+
+        private
+
+        # 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
+          return if target <= time
+
+          output = @output
+          return skip_to(target) if output.nil? && silent?
+
+          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
+
+        # Whether every voice is off and shifted out to where its shifts
+        # change nothing: the tone voices' registers empty and the noise
+        # voice's LFSR full of ones.
+        def silent?
+          enabled = @enabled
+          registers = @shift_registers
+          !(enabled[0] || enabled[1] || enabled[2] || enabled[NOISE]) &&
+            registers[0].zero? && registers[1].zero? && registers[2].zero? && @lfsr == 0xffff
+        end
+
+        # Moves each shift before `target` to its next turn from there,
+        # keeping its phase.
+        def skip_to(target)
+          VOICES.times do |voice|
+            due = @next_shifts[voice]
+            next if due >= target
+
+            interval = period(voice) * DIVIDERS[voice]
+            @next_shifts[voice] = due + ((target - due + interval - 1) / interval * interval)
+          end
+          @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
+end

data/lib/badline/{vic20/vic → chips/vic_i}/text_window.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Badline
-  class Vic20
-    class VIC
+  module Chips
+    class VICI
       # The text window's rows: where it opens and closes, the video matrix
       # counter and the character line, and the registers that place the
       # window and its memory.

data/lib/badline/{vic20/vic.rb → chips/vic_i.rb}

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require "badline/vic20/vic/painter"
-require "badline/vic20/vic/text_window"
-require "badline/vic20/vic/saved_state"
+require "badline/chips/vic_i/painter"
+require "badline/chips/vic_i/text_window"
+require "badline/chips/vic_i/sound"
+require "badline/chips/vic_i/keyed_parts"
 
 module Badline
-  class Vic20
+  module Chips
     # The VIC-I, the 6561 on PAL machines: its sixteen registers, the
     # raster, the text window's fetches over the V-bus and the picture. The
     # writes to the sound's registers, $900A-$900E, go on to the Sound
@@ -39,9 +40,8 @@ module Badline
     # display's lines start 6 cycles after the raster count moves, as
     # xvic's view of the frame does, so the character fetched 16 cycles
     # into the line lands 48 pixels in. Lines 0-27 are blanked.
-    class VIC
+    class VICI
       include TextWindow
-      include SavedState
 
       # What a VIC-I sets for the machine: the clock, the raster's cycles
       # per line and lines per frame, and how many lines at the top of the

data/lib/badline/chips/z80/arithmetic.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class Z80
+      # The ALU's 8- and 16-bit arithmetic. Bits 5 and 3 of F come from the
+      # result, except for CP, which takes them from the operand, and the
+      # 16-bit operations, which take them from the high byte.
+      module Arithmetic
+        private
+
+        # The eight operations an opcode's bits 5-3 pick: ADD ADC SUB SBC AND
+        # XOR OR CP.
+        def alu(operation, value)
+          case operation
+          when 0 then add_a(value, 0)
+          when 1 then add_a(value, @f & CF)
+          when 2 then @a = subtract(value, 0)
+          when 3 then @a = subtract(value, @f & CF)
+          when 4 then logic(@a & value, HF)
+          when 5 then logic(@a ^ value, 0)
+          when 6 then logic(@a | value, 0)
+          else compare(value)
+          end
+        end
+
+        def add_a(value, carry)
+          result = @a + value + carry
+          assign_flags(SZ53[result & 0xff] | (result >> 8) | ((@a ^ value ^ result) & HF) |
+                    (((@a ^ value ^ 0x80) & (@a ^ result) & 0x80) >> 5))
+          @a = result & 0xff
+        end
+
+        def subtract(value, carry)
+          result = @a - value - carry
+          assign_flags(SZ53[result & 0xff] | NF | ((result >> 8) & CF) | ((@a ^ value ^ result) & HF) |
+                    (((@a ^ value) & (@a ^ result) & 0x80) >> 5))
+          result & 0xff
+        end
+
+        def compare(value)
+          subtract(value, 0)
+          assign_flags((@f & ~XYF) | (value & XYF))
+        end
+
+        def logic(result, half)
+          @a = result
+          assign_flags(SZ53P[result] | half)
+        end
+
+        def increment(value)
+          result = (value + 1) & 0xff
+          assign_flags((@f & CF) | SZ53[result] | (result == 0x80 ? PF : 0) | (result.nobits?(0x0f) ? HF : 0))
+          result
+        end
+
+        def decrement(value)
+          result = (value - 1) & 0xff
+          assign_flags((@f & CF) | NF | SZ53[result] | (result == 0x7f ? PF : 0) | (value.nobits?(0x0f) ? HF : 0))
+          result
+        end
+
+        def add16(left, right)
+          result = left + right
+          @wz = (left + 1) & 0xffff
+          assign_flags((@f & (SF | ZF | PF)) | ((result >> 8) & XYF) | (((left ^ right ^ result) >> 8) & HF) |
+                    (result >> 16))
+          result & 0xffff
+        end
+
+        def adc16(right)
+          left = hl
+          result = left + right + (@f & CF)
+          @wz = (left + 1) & 0xffff
+          self.hl = result & 0xffff
+          assign_flags(word_flags(result) | (((left ^ right ^ result) >> 8) & HF) |
+                    (((left ^ right ^ 0x8000) & (left ^ result) & 0x8000) >> 13))
+        end
+
+        def sbc16(right)
+          left = hl
+          result = left - right - (@f & CF)
+          @wz = (left + 1) & 0xffff
+          self.hl = result & 0xffff
+          assign_flags(word_flags(result) | NF | (((left ^ right ^ result) >> 8) & HF) |
+                    (((left ^ right) & (left ^ result) & 0x8000) >> 13))
+        end
+
+        def word_flags(result)
+          ((result >> 8) & (SF | XYF)) | (result.nobits?(0xffff) ? ZF : 0) | ((result >> 16) & CF)
+        end
+
+        def daa
+          low = @a & 0x0f
+          carry = @f.anybits?(CF) || @a > 0x99 ? CF : 0
+          correction = (carry.zero? ? 0 : 0x60) | (@f.anybits?(HF) || low > 9 ? 0x06 : 0)
+          subtracting = @f.anybits?(NF)
+          half = daa_half(low, subtracting)
+          @a = (subtracting ? @a - correction : @a + correction) & 0xff
+          assign_flags(SZ53P[@a] | (@f & NF) | carry | half)
+        end
+
+        def daa_half(low, subtracting)
+          if subtracting
+            @f.anybits?(HF) && low < 6 ? HF : 0
+          else
+            low > 9 ? HF : 0
+          end
+        end
+
+        def neg
+          value = @a
+          @a = 0
+          @a = subtract(value, 0)
+        end
+      end
+    end
+  end
+end