badline 0.13.0 → 0.15.0

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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require "badline/chips/ted/sound/output"
+
+module Badline
+  module Chips
+    class TED
+      # The TED's sound: two voices, the second a square wave or noise.
+      # Voice 1's 10-bit frequency is $FF0E with $FF12 bits 0-1 above it,
+      # voice 2's $FF0F with $FF10 bits 0-1. $FF11 holds the volume in bits
+      # 0-3 (0 silent, 8 and above the loudest), voice 1 on in bit 4, voice
+      # 2's square wave in bit 5 and its noise in bit 6 (the square wins if
+      # both are set), and the reload bit in bit 7.
+      #
+      # Each voice counts once every 4 cycles, and its output toggles every
+      # 1023 - x counts for a frequency x, so a square wave of the clock
+      # over 8 * (1023 - x). $3FF counts 1,024 between toggles, and $3FE
+      # stops the voice after its next toggle, with its output high. A new
+      # frequency takes hold at the next toggle. The voices count whether
+      # they are on or not.
+      #
+      # The noise is an 8-bit shift register that shifts at each of voice
+      # 2's toggles: bits 1, 4, 5 and 7 XORed go in at bit 0, and bit 1 is
+      # the noise's output.
+      #
+      # While the reload bit is set, the counters hold at their frequencies,
+      # the outputs stay high and the noise's register holds all ones, with
+      # the noise silent. Writing it clear starts each voice on a full high
+      # half-wave. Samples play this way, with the voices held high and the
+      # volume as a 9-level D/A converter.
+      #
+      # The output takes a level from the volume and how many voices are on
+      # and high. The levels are measured from xplus4 recordings, whose two
+      # voices together come out above twice one.
+      #
+      # The voices catch up to the current cycle whenever a write lands, the
+      # samples are drained or #catch_up! asks, whether or not #record
+      # collects the output, so their state doesn't depend on whether the
+      # host plays it.
+      class Sound
+        VOICES = 2
+        CYCLES_PER_COUNT = 4
+
+        # The frequency that stops a voice with its output high.
+        HELD = 0x3fe
+
+        NOISE_TAPS = 0xb2
+        NOISE_PERIOD = 255
+
+        # The output's level for each volume 0-8, with no voice, one voice
+        # and both voices high.
+        LEVELS = [
+          0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 586, 1610, 2634, 3658, 4682, 5706, 6730, 7754,
+          0, 1172, 3284, 5526, 7984, 10_658, 13_548, 16_654, 19_976
+        ].freeze
+
+        # Far enough ahead that a voice stopped at $3FE, or held by the
+        # reload bit, never toggles.
+        NEVER = 1 << 60
+
+        attr_reader :volume, :control
+
+        # `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
+          @frequencies = [0, 0]
+          @intervals = [0, 0]
+          @phases = [1, 1]
+          @next_toggles = [0, 0]
+          power_on!
+        end
+
+        def model = :mos7360
+
+        # The power-on state: every register clear, both voices starting on
+        # a high half-wave and the noise's register full of ones.
+        def power_on!
+          now = @clock.cycles
+          run_to(now)
+          @volume = 0
+          @control = 0
+          @reloading = false
+          @noise = 0xff
+          VOICES.times do |voice|
+            @frequencies[voice] = 0
+            @intervals[voice] = interval_for(0)
+            @phases[voice] = 1
+            @next_toggles[voice] = now + @intervals[voice]
+          end
+          @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 $FF0E-$FF12, which takes hold from the next cycle.
+        def write(register, value)
+          run_to(@clock.cycles + 1)
+          case register
+          when 0x0e then tune(0, (@frequencies[0] & 0x300) | value)
+          when 0x0f then tune(1, (@frequencies[1] & 0x300) | value)
+          when 0x10 then tune(1, (@frequencies[1] & 0xff) | ((value & 0x03) << 8))
+          when 0x11 then write_control(value)
+          when 0x12 then tune(0, (@frequencies[0] & 0xff) | ((value & 0x03) << 8))
+          end
+          @level = level_now
+        end
+
+        def frequency(voice) = @frequencies[voice]
+
+        def reloading? = @reloading
+
+        # A voice's square-wave output as of the current cycle, 1 high.
+        def phase(voice)
+          run_to(@clock.cycles)
+          @phases[voice]
+        end
+
+        # The noise's shift register as of the current cycle.
+        def noise
+          run_to(@clock.cycles)
+          @noise
+        end
+
+        # The output's level as of the current cycle.
+        def level
+          run_to(@clock.cycles)
+          @level
+        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?
+
+          following = next_toggle
+          while following < target
+            output.hold_level(@level, following - time)
+            time = following
+            toggle_due(time)
+            @level = level_now
+            following = next_toggle
+          end
+          output.hold_level(@level, target - time)
+          @time = target
+        end
+
+        # Moves each voice through its toggles before `target` at once,
+        # the noise by as many shifts as voice 2 toggles, less whole turns
+        # of its sequence.
+        def skip_to(target)
+          VOICES.times do |voice|
+            due = @next_toggles[voice]
+            next if due >= target
+
+            interval = @intervals[voice]
+            toggles = ((target - 1 - due) / interval) + 1
+            @next_toggles[voice] = due + (toggles * interval)
+            @phases[voice] ^= toggles & 1
+            next unless voice == 1
+
+            (toggles % NOISE_PERIOD).times { shift_noise }
+          end
+          @level = level_now
+          @time = target
+        end
+
+        def next_toggle
+          toggles = @next_toggles
+          following = toggles[0]
+          following = toggles[1] if toggles[1] < following
+          following
+        end
+
+        def toggle_due(time)
+          toggles = @next_toggles
+          VOICES.times do |voice|
+            next unless toggles[voice] == time
+
+            @phases[voice] ^= 1
+            toggles[voice] = time + @intervals[voice]
+            shift_noise if voice == 1
+          end
+        end
+
+        def shift_noise
+          noise = @noise
+          taps = noise & NOISE_TAPS
+          taps ^= taps >> 4
+          taps ^= taps >> 2
+          taps ^= taps >> 1
+          @noise = ((noise << 1) | (taps & 1)) & 0xff
+        end
+
+        # The cycles between a voice's toggles at frequency `value`, and
+        # never again after the next one at $3FE.
+        def interval_for(value)
+          return NEVER if value == HELD
+
+          (((HELD - value) & 0x3ff) + 1) * CYCLES_PER_COUNT
+        end
+
+        # A new frequency for `voice`, which takes hold at its next toggle. A
+        # voice stopped at $3FE starts counting now.
+        def tune(voice, value)
+          @frequencies[voice] = value
+          @intervals[voice] = interval_for(value)
+          return if @reloading || @next_toggles[voice] < NEVER
+
+          @next_toggles[voice] = @time + @intervals[voice]
+        end
+
+        def write_control(value)
+          reload = value >= 0x80
+          if reload && !@reloading
+            hold_voices
+          elsif !reload && @reloading
+            release_voices
+          end
+          @reloading = reload
+          @control = value
+          volume = value & 0x0f
+          volume = 8 if volume > 8
+          @volume = volume
+        end
+
+        def hold_voices
+          @phases[0] = 1
+          @phases[1] = 1
+          @noise = 0xff
+          @next_toggles[0] = NEVER
+          @next_toggles[1] = NEVER
+        end
+
+        def release_voices
+          VOICES.times { |voice| @next_toggles[voice] = @time + @intervals[voice] }
+        end
+
+        def level_now
+          control = @control
+          high = 0
+          high += 1 if control.anybits?(0x10) && high?(0)
+          if control.anybits?(0x20)
+            high += 1 if high?(1)
+          elsif control.anybits?(0x40) && !@reloading
+            high += 1 if @noise.anybits?(0x02) || @frequencies[1] == HELD
+          end
+          LEVELS[(high * 9) + @volume]
+        end
+
+        def high?(voice) = @phases[voice] == 1 || @frequencies[voice] == HELD
+      end
+    end
+  end
+end

data/lib/badline/chips/ted/timers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      # The three 16-bit timers at $FF00-$FF05, which count down once a
+      # single clock cycle whatever clock the CPU runs at. Each raises its
+      # interrupt flag as it counts down to zero. Timer 1's next count then
+      # loads the value last written to it, and timers 2 and 3 roll over to
+      # $FFFF.
+      #
+      # A write to a timer's low byte stops it until its high byte is
+      # written. Timer 1's writes set its reload value and its count
+      # together, and timers 2 and 3's set the count.
+      module Timers
+        # The interrupt flag each timer raises in $FF09.
+        TIMER_FLAGS = [0x08, 0x10, 0x40].freeze
+
+        # The counts, the reload value of timer 1, and which timers run.
+        attr_reader :timer_counts, :timer_running
+
+        private
+
+        def reset_timers
+          @timer_counts = [0, 0, 0]
+          @timer_running = [false, false, false]
+          @timer1_reload = 0
+        end
+
+        def count_timers
+          i = 0
+          while i < 3
+            count_timer(i) if @timer_running[i]
+            i += 1
+          end
+        end
+
+        def count_timer(index)
+          count = @timer_counts[index]
+          if count.zero? && index.zero?
+            @timer_counts[0] = @timer1_reload
+            return
+          end
+
+          count = (count - 1) & 0xffff
+          @timer_counts[index] = count
+          @interrupt_flags |= TIMER_FLAGS[index] if count.zero?
+        end
+
+        def read_timer(register)
+          count = @timer_counts[register >> 1]
+          register.even? ? count & 0xff : count >> 8
+        end
+
+        def write_timer(register, value)
+          index = register >> 1
+          count = @timer_counts[index]
+          count = register.even? ? (count & 0xff00) | value : (count & 0x00ff) | (value << 8)
+          @timer_counts[index] = count
+          @timer1_reload = count if index.zero?
+          @timer_running[index] = register.odd?
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/ted.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "badline/chips/ted/timers"
+require "badline/chips/ted/beam"
+require "badline/chips/ted/fetches"
+require "badline/chips/ted/palette"
+require "badline/chips/ted/modes"
+require "badline/chips/ted/picture"
+require "badline/chips/ted/sound"
+require "badline/chips/ted/keyed_state"
+
+module Badline
+  module Chips
+    # The TED of the Commodore 264 series, the 7360 and 8360: its registers
+    # at $FF00-$FF1F, the raster, the three timers, the interrupt, the
+    # keyboard latch, the clock it gives the CPU (Beam), what it fetches
+    # for the picture (Fetches) and the picture (Picture). Writes to the
+    # sound's registers, $FF0E-$FF12, go on to the Sound attached as
+    # #sound.
+    #
+    # The machine clocks it once a single clock cycle, 57 to a line, and
+    # asks it then how many cycles the CPU runs in that one (#cpu_slots)
+    # and whether BA is low (#ba_low?).
+    #
+    # $FF08 is the keyboard latch: a write latches the K0-K7 inputs, which
+    # the keyboard port answers for the byte written (KeyboardPort#latch),
+    # and a read returns them. $FF09 holds the interrupt flags, each
+    # cleared by writing a 1 to it, with bit 7 set while the interrupt
+    # line is pulled. $FF0A holds the mask and bit 8 of the raster compare,
+    # and $FF0B the compare's low byte. $FF13 bit 0 reads whether the CPU
+    # sees ROM at $8000-$FFFF (#rom_selected=). $FF1C and $FF1D read and
+    # set the raster line, and $FF1E reads the horizontal position's top 8
+    # bits. $FF1A and $FF1B read and set the character position reload,
+    # and $FF1F the row's line in bits 0-2 and in bits 3-6 the blink
+    # counter, which counts frames.
+    class TED
+      include Timers
+      include Beam
+      include Fetches
+      include Palette
+      include Modes
+      include Picture
+
+      # The clock a TED is fed, its single clock: the crystal divided by 20
+      # on PAL machines and by 16 on NTSC ones (the Plus/4 hardware manual's
+      # TED datasheet).
+      Profile = Data.define(:name, :clock_hz)
+
+      PAL = Profile.new(name: :pal, clock_hz: 886_724)
+      NTSC = Profile.new(name: :ntsc, clock_hz: 894_886)
+
+      RASTER_FLAG = 0x02
+
+      # The interrupt sources a mask bit can enable: the raster, the light
+      # pen and the three timers.
+      SOURCES = 0x5e
+
+      # The registers the picture reads as it paints: $FF06, $FF07, the
+      # cursor and the five colours.
+      PICTURE_REGISTERS = 0x03e030c0
+
+      attr_reader :profile, :interrupt_flags, :interrupt_mask
+
+      # What answers the keyboard latch: an object with #latch(value).
+      attr_writer :keyboard_port
+
+      # Whether the CPU sees ROM at $8000-$FFFF, which $FF13 bit 0 reads.
+      attr_writer :rom_selected
+
+      # The Sound the sound's registers drive.
+      attr_accessor :sound
+
+      def initialize(profile = PAL)
+        @profile = profile
+        @keyboard_port = nil
+        @rom_selected = true
+        @bus = nil
+        @sound = nil
+        power_on!
+      end
+
+      def power_on!
+        @registers = Array.new(0x20, 0)
+        @interrupt_flags = 0
+        @interrupt_mask = 0
+        @raster_compare = 0
+        @key_latch = 0xff
+        @blink = 0
+        reset_timers
+        reset_fetches
+        reset_picture
+        reset_beam
+      end
+
+      # Counts the timers, moves the beam on a cycle and makes the cycle's
+      # fetches, unless $FF07's freeze bit holds them, then decides the
+      # CPU's clock for the cycle.
+      def cycle!
+        unless frozen?
+          count_timers
+          move_beam
+          fetch(@column)
+          picture_cycle(@column)
+        end
+        decide_clock
+      end
+
+      # Whether the interrupt line is pulled: a flag raised whose mask bit
+      # is set.
+      def irq? = @interrupt_flags.anybits?(@interrupt_mask & SOURCES)
+
+      def peek(addr)
+        register = addr & 0x3f
+        return 0xff if register >= 0x20
+
+        case register
+        when 0x00..0x05 then read_timer(register)
+        when 0x08 then @key_latch
+        when 0x09 then read_interrupt_flags
+        when 0x0a then @interrupt_mask | 0xa0
+        when 0x0b then @raster_compare & 0xff
+        when 0x13 then (@registers[0x13] & 0xfe) | (@rom_selected ? 1 : 0)
+        when 0x1a then 0xfc | (@char_position >> 8)
+        when 0x1b then @char_position & 0xff
+        when 0x1c then 0xfe | (@line >> 8)
+        when 0x1d then @line & 0xff
+        when 0x1e then @column << 2
+        when 0x1f then 0x80 | (@blink << 3) | @row_line
+        else @registers[register]
+        end
+      end
+
+      def poke(addr, value)
+        register = addr & 0x3f
+        return if register >= 0x20
+
+        paint_to_write if (PICTURE_REGISTERS >> register).anybits?(1)
+        @registers[register] = value
+        case register
+        when 0x00..0x05 then write_timer(register, value)
+        when 0x08 then @key_latch = @keyboard_port ? @keyboard_port.latch(value) : 0xff
+        when 0x09 then @interrupt_flags &= ~value
+        when 0x0a then write_interrupt_mask(value)
+        when 0x0b then @raster_compare = (@raster_compare & 0x100) | value
+        when 0x0e..0x12 then @sound&.write(register, value)
+        when 0x1a then @char_position = (@char_position & 0xff) | ((value & 0x03) << 8)
+        when 0x1b then @char_position = (@char_position & 0x300) | value
+        when 0x1c then self.line = (@line & 0xff) | ((value & 0x01) << 8)
+        when 0x1d then self.line = (@line & 0x100) | value
+        when 0x1f then write_row_line(value)
+        end
+      end
+
+      private
+
+      # $FF07 bit 5 stops the beam and the timers.
+      def frozen? = @registers[0x07].anybits?(0x20)
+
+      def read_interrupt_flags
+        value = @interrupt_flags | 0x21
+        irq? ? value | 0x80 : value
+      end
+
+      def write_row_line(value)
+        @row_line = value & 0x07
+        @blink = (value >> 3) & 0x0f
+      end
+
+      # The end of a frame: the fetches' counters start over.
+      def end_frame
+        end_fetch_frame
+        end_picture_frame
+      end
+
+      def write_interrupt_mask(value)
+        @interrupt_mask = value & 0x5f
+        @raster_compare = (@raster_compare & 0xff) | ((value & 0x01) << 8)
+      end
+
+      def line=(value)
+        @line = value
+        raster_reached
+      end
+
+      def raster_reached
+        @interrupt_flags |= RASTER_FLAG if @line == @raster_compare
+      end
+    end
+  end
+end

data/lib/badline/chips/tia.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    # The 6523 TIA, a tri-port interface adapter: three 8-bit ports, A, B
+    # and C at registers 0-2, each with its direction register at 3-5, a 1
+    # making the pin an output. Its three address lines repeat the
+    # registers every 8 bytes, and registers 6 and 7 read $FF.
+    #
+    # A pin read as an output returns what the port drives, and one read as
+    # an input returns what the other side drives, #inputs, per port.
+    class TIA
+      attr_reader :ports, :directions
+
+      # What the other side drives onto each port's pins.
+      attr_reader :inputs
+
+      def initialize
+        @inputs = [0, 0, 0]
+        reset!
+      end
+
+      def reset!
+        @ports = [0, 0, 0]
+        @directions = [0, 0, 0]
+      end
+
+      def peek(addr)
+        register = addr & 0x07
+        return 0xff if register > 5
+        return @directions[register - 3] if register >= 3
+
+        direction = @directions[register]
+        (@ports[register] & direction) | (@inputs[register] & ~direction & 0xff)
+      end
+
+      def poke(addr, value)
+        register = addr & 0x07
+        return if register > 5
+
+        if register >= 3
+          @directions[register - 3] = value
+        else
+          @ports[register] = value
+        end
+      end
+
+      # The ports, their directions and what the other side drives, in a
+      # keyed snapshot module (Snapshot::Keyed, BL-TIA1 and BL-TIA2).
+      def save_fields(out)
+        out.ints("ports", @ports).ints("directions", @directions).ints("inputs", @inputs)
+      end
+
+      def load_fields(input)
+        input.ints_into("ports", @ports)
+        input.ints_into("directions", @directions)
+        input.ints_into("inputs", @inputs)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VDC
+      class Raster
+        # The raster's fields in a keyed snapshot module, under `prefix`:
+        # the frame count, where the beam is in the character rows and the
+        # frame, and the frame's size and sync as it latched them.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.int("#{prefix}frame", @frame).int("#{prefix}row", @row).int("#{prefix}row_line", @row_line)
+            out.bool("#{prefix}adjusting", @adjusting).int("#{prefix}frame_line", @frame_line)
+            out.int("#{prefix}frame_lines", @frame_lines).int("#{prefix}sync_start", @sync_start)
+            out.int("#{prefix}sync_lines", @sync_lines)
+          end
+
+          def load_fields(input, prefix)
+            @frame = input.int("#{prefix}frame", @frame)
+            @row = input.int("#{prefix}row", @row)
+            @row_line = input.int("#{prefix}row_line", @row_line)
+            @adjusting = input.bool("#{prefix}adjusting", @adjusting)
+            @frame_line = input.int("#{prefix}frame_line", @frame_line)
+            @frame_lines = input.int("#{prefix}frame_lines", @frame_lines)
+            @sync_start = input.int("#{prefix}sync_start", @sync_start)
+            @sync_lines = input.int("#{prefix}sync_lines", @sync_lines)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Window
+        # The start addresses the frame latched, under `prefix`.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.int("#{prefix}display_start", @display_start).int("#{prefix}attribute_start", @attribute_start)
+          end
+
+          def load_fields(input, prefix)
+            @display_start = input.word("#{prefix}display_start", @display_start)
+            @attribute_start = input.word("#{prefix}attribute_start", @attribute_start)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Painter
+        # The display's size, as the frame latched it, and the window's
+        # start addresses. The picture is painted again.
+        module KeyedState
+          def save_fields(out)
+            out.int("display.width", @width).int("display.height", @height)
+            @window.save_fields(out, "window.")
+          end
+
+          def load_fields(input)
+            resize(input.int("display.width", @width), input.int("display.height", @height))
+            @window.load_fields(input, "window.")
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The VDC's fields in a keyed snapshot module (Snapshot::Keyed): the
+      # registers, the RAM, the register selected, the data latches, the
+      # dot clock's phase and the line's length in the same units
+      # (dots·Hz, the line latched at its start), how long an access or
+      # block operation stays busy from now, the raster under raster.* and
+      # the display's size and window under display.* and window.*. The
+      # RAM's layout comes from R28 on load.
+      module KeyedState
+        def save_fields(out)
+          out.bytes("registers", @registers).bytes("ram", @memory.ram).int("selected", @selected)
+          out.int("read_latch", @read_latch).int("write_data", @write_data).int("phase", @phase)
+          out.int("line_units", @line_units).int("busy_for", @busy_until - @phase)
+          @raster.save_fields(out, "raster.")
+          @painter.save_fields(out)
+          out
+        end
+
+        def load_fields(input)
+          input.bytes_into("registers", @registers)
+          input.bytes_into("ram", @memory.ram)
+          @selected = input.masked("selected", @selected, 0x3f)
+          @read_latch = input.byte("read_latch", @read_latch)
+          @write_data = input.byte("write_data", @write_data)
+          @phase = input.int("phase", @phase)
+          @line_units = input.int("line_units", @line_units)
+          @busy_until = @phase + input.int("busy_for", @busy_until - @phase)
+          @raster.load_fields(input, "raster.")
+          @painter.load_fields(input)
+        end
+
+        def restored!
+          @memory.mode64 = @registers[28].anybits?(0x10)
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end