badline 0.12.1 → 0.13.0

data/lib/badline/chips/vic_i/painter/saved_state.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VICI
+      class Painter
+        # The painter's state for a snapshot.
+        module SavedState
+          # 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
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "badline/chips/vic_i/painter/saved_state"
+
 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
@@ -26,6 +28,8 @@ module Badline
       # nibble's low three bits) and 11 the auxiliary colour, whatever
       # $900F bit 3 says (MOS 6560/6561 datasheet, "Color operating modes").
       class Painter
+        include SavedState
+
         # The characters a line holds room for. A line fetches at most 34.
         SLOTS = 40
 
@@ -70,34 +74,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/{vic20/vic → chips/vic_i}/saved_state.rb

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

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,235 @@
+# 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 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
+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,11 @@
 # 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/saved_state"
 
 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,7 +39,7 @@ 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
 

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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class Z80
+      # The CB page: rotates and shifts (quarter 0), BIT (1), RES (2) and SET
+      # (3) of the bit the row names, on the column's register or (HL). After
+      # DD or FD the operand is always (IX+d): the displacement comes before
+      # the opcode, and an opcode that names a register other than (HL) also
+      # copies the result into it.
+      module BitPage
+        private
+
+        def execute_bits(opcode)
+          operation = opcode >> 6
+          number = (opcode >> 3) & 7
+          index = opcode & 7
+          return bits_in_memory(operation, number, hl) if index == 6
+
+          value = register(index)
+          if operation == 1
+            bit(number, value, value)
+          else
+            set_register(index, bit_result(operation, number, value))
+          end
+        end
+
+        def execute_index_bits
+          displaced
+          opcode = fetch_byte
+          @cycles += 2
+          result = bits_in_memory(opcode >> 6, (opcode >> 3) & 7, @wz)
+          index = opcode & 7
+          set_plain_register(index, result) unless index == 6 || (opcode >> 6) == 1
+        end
+
+        def bits_in_memory(operation, number, address)
+          value = read_byte(address)
+          @cycles += 1
+          return bit(number, value, @wz >> 8) if operation == 1
+
+          result = bit_result(operation, number, value)
+          write_byte(address, result)
+          result
+        end
+
+        def bit_result(operation, number, value)
+          case operation
+          when 0 then shift(number, value)
+          when 2 then value & ~(1 << number) & 0xff
+          else value | (1 << number)
+          end
+        end
+      end
+    end
+  end
+end