badline 0.12.0 → 0.13.0

data/lib/badline/chips/vic/display_state.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      # = VIC-II display state
+      #
+      # The bad line condition, the video counters it drives, and the DMA it
+      # starts. A condition that arrives mid-line opens the row late, which is
+      # what makes the screen scroll sideways or lose a column of cells.
+      class DisplayState
+        FIRST_LINE = 0x30 # 48: bad lines and the DEN-at-$30 latch begin here
+        LAST_LINE  = 0xf7 # 247
+        COLUMNS_PER_ROW = 40
+
+        # AEC follows BA three cycles later; the c-accesses before it read
+        # the bus the CPU still drives.
+        BA_DELAY = 3
+
+        # Columns run two ahead of Bauer's cycle numbers: column 10 is his
+        # cycle 12. BA falls on a match in columns 10-52, the c-accesses run
+        # in 13-52 and the g-accesses in 14-53. VC and VMLI reload in column
+        # 12 and the row counter steps in column 56.
+        DMA_FIRST = 10
+        DMA_LAST = 52
+        FETCH_FIRST = 13
+        GRAPHICS_FIRST = 14
+        GRAPHICS_LAST = 53
+        LOAD_COLUMN = 12
+        RC_COLUMN = 56
+
+        GRAPHICS_COLUMNS = Array.new(65) { |column| column.between?(GRAPHICS_FIRST, GRAPHICS_LAST) }.freeze
+
+        attr_reader :vc_base, :vc, :vmli, :rc, :bad_lines_enabled
+
+        # The wrap column is the last column of a rasterline, 62 on the 6569,
+        # which already compares against the line about to start, the same
+        # wrap the raster IRQ latch uses.
+        def initialize(registers, wrap_column = 62)
+          @registers = registers
+          @wrap_column = wrap_column
+          @vc_base = 0
+          @vc = 0
+          @vmli = 0
+          @rc = 0
+          @display = false
+          @bad_lines_enabled = false
+          @matched = false
+          @ba = nil
+          new_line(0)
+        end
+
+        def display? = @display
+
+        # Sets VCBASE, VC, RC and VMLI, in that order, and the display and
+        # bad-line flags, as a VICE snapshot gives them.
+        def restore_counters(counters, display, bad_lines_enabled)
+          @vc_base, @vc, @rc, @vmli = counters
+          @display = display
+          @bad_lines_enabled = bad_lines_enabled
+        end
+
+        def idle? = !@display
+        def bad_line? = !@ba.nil?
+
+        # The bad line condition as the last column compared it.
+        def bad_line_condition? = @matched
+
+        # True once AEC has followed BA down and the VIC owns the bus.
+        def bus_taken?(column) = @ba ? column >= @ba + BA_DELAY : false
+
+        # The CPU kept the bus through the cycle before +column+, so on a bad
+        # line AEC falls BA_DELAY cycles after it at the earliest.
+        def keep_bus(column)
+          @ba &&= column
+        end
+
+        def fetching?(column)
+          @matched && column >= FETCH_FIRST && column <= DMA_LAST
+        end
+
+        def save_state(out)
+          out.int(@vc_base).int(@vc).int(@vmli).int(@rc).boolean(@display).boolean(@bad_lines_enabled)
+          out.boolean(@matched).optional_int(@ba).int(@line_bits).boolean(@den_line).boolean(@in_window)
+        end
+
+        def load_state(input)
+          @vc_base = input.int
+          @vc = input.int
+          @vmli = input.int
+          @rc = input.int
+          @display = input.boolean?
+          @bad_lines_enabled = input.boolean?
+          @matched = input.boolean?
+          @ba = input.optional_int
+          @line_bits = input.int
+          @den_line = input.boolean?
+          @in_window = input.boolean?
+        end
+
+        def new_frame
+          @vc_base = 0
+          @bad_lines_enabled = false
+        end
+
+        def new_line(line)
+          @ba = nil
+          raster_step(line)
+        end
+
+        # The raster counter moved on to +line+, at the line's start or, under
+        # the VIC-IIe's TEST bit, within it.
+        def raster_step(line)
+          @line_bits = line & 0b111
+          @den_line = line == FIRST_LINE
+          @in_window = line.between?(FIRST_LINE, LAST_LINE)
+        end
+
+        # Returns true when this compare opened display state.
+        def cycle(rasterline, column)
+          match = column == @wrap_column ? wrap_match(rasterline + 1) : line_match
+          @matched = match
+          opened = false
+          if match
+            opened = !@display
+            @display = true
+            @ba = column if @ba.nil? && column >= DMA_FIRST && column <= DMA_LAST
+          end
+          load_counters(match) if column == LOAD_COLUMN
+          check_row_counter(match) if column == RC_COLUMN
+          opened
+        end
+
+        # A g-access in display state consumes one buffer cell and one video
+        # matrix address. A row that opens mid-line makes fewer of them, and
+        # the shortfall carries into VCBASE.
+        def graphics_column?(column) = GRAPHICS_COLUMNS[column]
+
+        def graphics_access(column)
+          return unless graphics_column?(column)
+
+          @vc = (@vc + 1) & 0x3ff
+          @vmli += 1
+        end
+
+        private
+
+        def line_match
+          latch_den if @den_line
+          @bad_lines_enabled && @in_window && @line_bits == @registers.yscroll
+        end
+
+        # The wrap column compares against the line about to start. The DEN
+        # latch is level-sensitive across the counter's increment, so this one
+        # column sees both the line ending and the line starting.
+        def wrap_match(line)
+          latch_den if @den_line || line == FIRST_LINE
+          return false unless line.between?(FIRST_LINE, LAST_LINE)
+
+          @bad_lines_enabled && (line & 0b111) == @registers.yscroll
+        end
+
+        def latch_den
+          @bad_lines_enabled = true if @registers.display_enabled?
+        end
+
+        def load_counters(match)
+          @vc = @vc_base
+          @vmli = 0
+          @rc = 0 if match
+        end
+
+        # A condition still standing when the row counter wraps puts the logic
+        # straight back into display state, so a forced row rolls into the
+        # next one instead of leaving the line idle (Bauer 3.7.2 step 5).
+        def check_row_counter(match)
+          if @rc == 7
+            @display = false
+            @vc_base = @vc
+          end
+          @display ||= match
+          @rc = (@rc + 1) & 0b111 if @display
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/vic/graphics_mode.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      module GraphicsMode
+        # Foreground masks depend only on the data byte, so each byte maps to a
+        # precomputed frozen pattern shared by reference instead of being
+        # written out pixel by pixel.
+        HIRES_FG = Array.new(256) do |data|
+          Array.new(8) { |i| data.anybits?(1 << (7 - i)) }.freeze
+        end.freeze
+
+        # The high bit of each 2-bit pair (10/11) is foreground.
+        PAIR_FG = Array.new(256) do |data|
+          Array.new(8) { |i| (data >> (6 - (i & ~1))).allbits?(0b10) }.freeze
+        end.freeze
+
+        # The same patterns as masks, all bits set for a foreground pixel.
+        HIRES_MASK = Array.new(256) do |data|
+          Array.new(8) { |i| data.anybits?(1 << (7 - i)) ? -1 : 0 }.freeze
+        end.freeze
+
+        NO_FG = HIRES_FG[0]
+
+        module Hires
+          def paint_hires(data, color, background, seq)
+            seq.cur_fg = HIRES_FG[data]
+            colors = seq.cur_colors
+            return colors.fill(background) if data.zero?
+
+            mask = HIRES_MASK[data]
+            flip = color ^ background
+            colors[0] = background ^ (flip & mask[0])
+            colors[1] = background ^ (flip & mask[1])
+            colors[2] = background ^ (flip & mask[2])
+            colors[3] = background ^ (flip & mask[3])
+            colors[4] = background ^ (flip & mask[4])
+            colors[5] = background ^ (flip & mask[5])
+            colors[6] = background ^ (flip & mask[6])
+            colors[7] = background ^ (flip & mask[7])
+          end
+        end
+
+        # Decodes 2-bit pixel pairs into double-wide pixels, each pair indexing
+        # the four colours in the mode's palette.
+        module Multicolor
+          def paint_pairs(data, seq)
+            seq.cur_fg = PAIR_FG[data]
+            colors = seq.cur_colors
+            palette = @palette
+            colors[0] = colors[1] = palette[data >> 6]
+            colors[2] = colors[3] = palette[(data >> 4) & 0b11]
+            colors[4] = colors[5] = palette[(data >> 2) & 0b11]
+            colors[6] = colors[7] = palette[data & 0b11]
+          end
+        end
+
+        # Each mode paints the byte a g-access read with the screen byte and
+        # colour nibble it latched. The VIC reads the byte itself, in the
+        # g-access column. #fg gives the foreground mask #paint would leave,
+        # without the colours.
+        class Text
+          include Hires
+
+          def paint(data, _screencode, color, seq)
+            paint_hires(data, color, seq.registers.background, seq)
+          end
+
+          def fg(data, _screencode, _color) = HIRES_FG[data]
+        end
+
+        class MulticolorText
+          include Hires
+          include Multicolor
+
+          def initialize
+            @palette = Array.new(4, 0)
+          end
+
+          def paint(data, _screencode, color, seq)
+            registers = seq.registers
+            if color.anybits?(0x08)
+              palette = @palette
+              palette[0] = registers.background(0)
+              palette[1] = registers.background(1)
+              palette[2] = registers.background(2)
+              palette[3] = color & 0x07
+              paint_pairs(data, seq)
+            else
+              paint_hires(data, color & 0x07, registers.background, seq)
+            end
+          end
+
+          def fg(data, _screencode, color) = color.anybits?(0x08) ? PAIR_FG[data] : HIRES_FG[data]
+        end
+
+        class ExtendedBackgroundText
+          include Hires
+
+          def paint(data, screencode, color, seq)
+            background = seq.registers.background((screencode >> 6) & 0b11)
+            paint_hires(data, color, background, seq)
+          end
+
+          def fg(data, _screencode, _color) = HIRES_FG[data]
+        end
+
+        class Bitmap
+          include Hires
+
+          def paint(data, screencode, _color, seq)
+            foreground = (screencode >> 4) & 0x0f
+            background = screencode & 0x0f
+            paint_hires(data, foreground, background, seq)
+          end
+
+          def fg(data, _screencode, _color) = HIRES_FG[data]
+        end
+
+        class MulticolorBitmap
+          include Multicolor
+
+          def initialize
+            @palette = Array.new(4, 0)
+          end
+
+          def paint(data, screencode, color, seq)
+            palette = @palette
+            palette[0] = seq.registers.background(0)
+            palette[1] = (screencode >> 4) & 0x0f
+            palette[2] = screencode & 0x0f
+            palette[3] = color & 0x0f
+            paint_pairs(data, seq)
+          end
+
+          def fg(data, _screencode, _color) = PAIR_FG[data]
+        end
+
+        class Null
+          def paint(_data, _screencode, _color, seq)
+            seq.cur_fg = NO_FG
+            seq.cur_colors.fill(0)
+          end
+
+          def fg(_data, _screencode, _color) = NO_FG
+        end
+
+        NULL_MODE = Null.new
+
+        # Indexed by ECM/BMM/MCM; the three invalid combinations decode to
+        # black.
+        MODES = [
+          Text.new,                   # 000 standard text
+          MulticolorText.new,         # 001 multicolour text
+          Bitmap.new,                 # 010 standard bitmap
+          MulticolorBitmap.new,       # 011 multicolour bitmap
+          ExtendedBackgroundText.new, # 100 ECM text
+          NULL_MODE,                  # 101 invalid
+          NULL_MODE,                  # 110 invalid
+          NULL_MODE                   # 111 invalid
+        ].freeze
+      end
+    end
+  end
+end

data/lib/badline/chips/vic/graphics_shifter/saved_state.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      class GraphicsShifter
+        # The shifter's state for a snapshot.
+        module SavedState
+          def save_state(out)
+            out.int(@next_ecm_bmm).int(@black_below).ints(@colors).booleans(@fg)
+            out.int(@gbuf).int(@vbuf).int(@cbuf).int(@flop).int(@pixel)
+            out.int(@mode_lookup).int(@mode_read).boolean(@late_mcm).boolean(@late_read)
+          end
+
+          def load_state(input)
+            @next_ecm_bmm = input.int
+            @black_below = input.int
+            input.ints_into(@colors)
+            input.booleans_into(@fg)
+            load_buffers(input)
+            @mode_lookup = input.int
+            @mode_read = input.int
+            @late_mcm = input.boolean?
+            @late_read = input.boolean?
+          end
+
+          private
+
+          def load_buffers(input)
+            @gbuf = input.int
+            @vbuf = input.int
+            @cbuf = input.int
+            @flop = input.int
+            @pixel = input.int
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/vic/graphics_shifter.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "badline/chips/vic/graphics_shifter/saved_state"
+
+module Badline
+  module Chips
+    class VIC
+      # The graphics shift register, pixel by pixel, for the groups where a
+      # mode or XSCROLL change lands (VICE x64sc `draw_graphics`). The
+      # sequencer paints whole bytes everywhere else, which comes to the same
+      # thing while nothing changes.
+      #
+      # The byte a group draws loads at pixel XSCROLL. ECM and BMM take hold at
+      # pixel 4 as they rise and at pixel 6 as they fall (the 6569's colour
+      # latency), except that BMM falls at pixel 5 out of any mode but hi-res
+      # bitmap. MCM takes hold at pixel 4 for the colour lookup but only at
+      # pixel 7 for how the register is read, where a rising MCM also resets
+      # the multicolour flip-flop. An MCM that falls out of the invalid
+      # ECM+MCM mode is a pixel later on both counts: the lookup changes at
+      # pixel 5 and the read at the next group's pixel 0. The mode bits are
+      # the sequencer's: ECM 4, BMM 2, MCM 1.
+      #
+      # The 8565 has no colour latency: ECM and BMM take hold, rising or
+      # falling, at the next group's pixel 0, and an MCM that falls out of
+      # ECM+MCM does so on time. Where that pixel 0 takes the group out of an
+      # invalid mode, it is still black into hi-res text, and so is a
+      # background pixel into multicolour bitmap.
+      class GraphicsShifter
+        include SavedState
+
+        ECM = 0b100
+        ECM_BMM = 0b110
+        MULTICOLOR_BITMAP = 0b011
+        ECM_MCM = 0b101
+        BMM = 0b010
+
+        # The group #draw painted, and which of its pixels are foreground.
+        attr_reader :colors, :fg
+
+        def initialize(registers, model: :mos6569)
+          @registers = registers
+          @latency = model != :mos8565
+          @next_ecm_bmm = 0
+          @black_below = 0
+          @colors = Array.new(8, 0)
+          @fg = Array.new(8, false)
+          @gbuf = 0
+          @vbuf = 0
+          @cbuf = 0
+          @flop = 0
+          @pixel = 0
+          @mode_lookup = 0
+          @mode_read = 0
+          @late_mcm = false
+          @late_read = false
+        end
+
+        # Rebuilds the state at the end of a group that painted whole bytes:
+        # the byte loaded at pixel shift under an unchanging mode.
+        def prime(data, screencode, color, shift, mode)
+          @mode_lookup = mode
+          @next_ecm_bmm = mode & ECM_BMM
+          @mode_read = mode & 1
+          @late_read = false
+          load(data, screencode, color)
+          (8 - shift).times { read_pixel }
+        end
+
+        # Draws one group, loading the byte at pixel shift.
+        def draw(data, screencode, color, shift, mode)
+          i = 0
+          while i < 8
+            step_mode(i, mode)
+            load(data, screencode, color) if i == shift
+            pixel = read_pixel
+            @colors[i] = pixel < @black_below ? 0 : lookup(pixel)
+            @black_below = 0
+            @fg[i] = pixel >= 2
+            i += 1
+          end
+          @next_ecm_bmm = mode & ECM_BMM
+        end
+
+        private
+
+        def step_mode(pixel, mode)
+          case pixel
+          when 0 then start_group
+          when 4 then step_lookup(mode)
+          when 5 then step_early_fall(mode)
+          when 6 then @mode_lookup &= mode | 1 if @latency
+          when 7 then step_read
+          end
+        end
+
+        def start_group
+          end_late_read
+          return if @latency
+
+          invalid = @mode_lookup > ECM
+          @mode_lookup = (@mode_lookup & ~ECM_BMM) | @next_ecm_bmm
+          @black_below = black_pixels_out_of_invalid if invalid
+        end
+
+        # The pixel values below which pixel 0 stays black as the group leaves
+        # an invalid mode: all four into hi-res text, the background ones into
+        # multicolour bitmap.
+        def black_pixels_out_of_invalid
+          case @mode_lookup
+          when 0 then 4
+          when MULTICOLOR_BITMAP then 2
+          else 0
+          end
+        end
+
+        def step_lookup(mode)
+          @late_mcm = @latency && @mode_lookup.allbits?(ECM_MCM) && mode.nobits?(1)
+          rising = @latency ? mode & ECM_BMM : 0
+          @mode_lookup = (@mode_lookup & ~1) | (mode & 1) | (@late_mcm ? 1 : 0) | rising
+        end
+
+        def step_early_fall(mode)
+          @mode_lookup &= ~1 if @late_mcm
+          @mode_lookup &= mode | ~BMM if @latency && @mode_lookup != BMM
+        end
+
+        def step_read
+          return @late_read = true if @late_mcm
+
+          mcm = @mode_lookup & 1
+          @flop = 0 if mcm == 1 && @mode_read.zero?
+          @mode_read = mcm
+        end
+
+        def end_late_read
+          return unless @late_read
+
+          @mode_read = 0
+          @late_read = false
+        end
+
+        def load(data, screencode, color)
+          @gbuf = data
+          @vbuf = screencode
+          @cbuf = color & 0x0f
+          @flop = 1
+        end
+
+        def read_pixel
+          multicolor = multicolor?
+          if @mode_read == 1 && multicolor
+            @pixel = @gbuf >> 6 if @flop == 1
+          elsif @gbuf.anybits?(0x80)
+            @pixel = multicolor && @mode_read.zero? ? 2 : 3
+          else
+            @pixel = 0
+          end
+          @gbuf = (@gbuf << 1) & 0xff
+          @flop ^= 1
+          @pixel
+        end
+
+        def multicolor? = @mode_lookup.anybits?(BMM) || @cbuf.anybits?(0x08)
+
+        def lookup(pixel)
+          case @mode_lookup
+          when 0 then pixel < 2 ? @registers.background : @cbuf
+          when 1 then pixel == 3 ? @cbuf & 0x07 : @registers.background(pixel)
+          when 2 then pixel < 2 ? @vbuf & 0x0f : @vbuf >> 4
+          when 3 then multicolor_bitmap(pixel)
+          when 4 then pixel < 2 ? @registers.background(@vbuf >> 6) : @cbuf
+          else 0
+          end
+        end
+
+        def multicolor_bitmap(pixel)
+          case pixel
+          when 0 then @registers.background
+          when 1 then @vbuf >> 4
+          when 2 then @vbuf & 0x0f
+          else @cbuf
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/vic/register_log.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      # Mid-line writes to the sprite registers, keyed by the pixel at which
+      # they become visible. Compositing replays the line through the log, so
+      # each pixel is drawn with the register values that were in effect when
+      # the VIC reached it.
+      class RegisterLog
+        def initialize(registers)
+          @registers = registers
+          @entries = []
+          @seed = []
+          @values = Array.new(2**6, 0)
+          @cursor = 0
+          @next_x = 0
+        end
+
+        # The pixel at which the next logged write takes effect.
+        attr_reader :next_x
+
+        # The entries as pixel, register and value in turn, the seed with -1
+        # for a register the line hasn't logged, and a next pixel past the
+        # last entry as -1.
+        def save_state(out)
+          out.ints(@entries.flatten)
+          out.ints(@seed.map { |value| value.nil? ? -1 : value })
+          out.ints(@values).int(@cursor).int(@next_x.infinite? ? -1 : @next_x)
+        end
+
+        def load_state(input)
+          @entries.replace(input.ints.each_slice(3).to_a)
+          @seed.replace(input.ints.map { |value| value.negative? ? nil : value })
+          input.ints_into(@values)
+          @cursor = input.int
+          next_x = input.int
+          @next_x = next_x.negative? ? Float::INFINITY : next_x
+        end
+
+        def empty? = @entries.empty?
+        def length = @entries.length
+
+        def clear
+          return if @entries.empty?
+
+          @entries.clear
+          @seed.clear
+        end
+
+        def log(pixel_x, reg, old, value)
+          @seed[reg] = old if @seed[reg].nil?
+          @entries << [pixel_x, reg, value]
+        end
+
+        def prepare
+          @entries.sort_by! { |entry| entry[0] }
+        end
+
+        # Restart the cursor before the line's first pixel, with every logged
+        # register back at the value it held when the line started.
+        def rewind
+          @values.length.times { |reg| @values[reg] = @registers[reg] }
+          @seed.each_with_index { |value, reg| @values[reg] = value unless value.nil? }
+          @cursor = 0
+          @next_x = @entries.empty? ? Float::INFINITY : @entries[0][0]
+        end
+
+        def [](reg) = @values[reg]
+
+        # Apply every write visible at or before pixel_x.
+        def advance(pixel_x)
+          while @cursor < @entries.length && @entries[@cursor][0] <= pixel_x
+            entry = @entries[@cursor]
+            @values[entry[1]] = entry[2]
+            @cursor += 1
+          end
+          @next_x = @cursor < @entries.length ? @entries[@cursor][0] : Float::INFINITY
+        end
+      end
+    end
+  end
+end