badline 0.14.0 → 0.15.0

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      # The picture: a palette index a pixel (Palette), 384 pixels a line
+      # and every line of the frame. A line's pixels start at horizontal
+      # count 419, so the 40-column window, counts 451-315, runs from pixel
+      # 32 to 351, as in xplus4's screenshots.
+      #
+      # The picture's lines are the scanlines of the frame as they go out,
+      # which follow the line count until a write to $FF1C-$FF1D moves it:
+      # the frame's scanlines start over where the line count wraps to 0 at
+      # the end of the frame, and step with each line otherwise, as in
+      # xplus4's screenshots of TED/write-scanline-coarse.
+      #
+      # A line is painted at column 44, once its last pixel is out, from
+      # what the line fetched (Fetches) in the colours of its mode (Modes).
+      # A write to a register the picture reads paints the line up to the
+      # pixel the write lands on first, so the old value holds to there and
+      # the new one from there.
+      #
+      # Outside the window the border colour ($FF19) shows: above and below
+      # it, from the line count reaching line 4 to its reaching line 204 with
+      # $FF06 bit 3 set (25 rows), or 8 and 200 (24 rows), so a line count
+      # moved past line 4 leaves the frame's window shut;
+      # beside it, the 38-column window ($FF07 bit 3 clear) is pixels 39 to
+      # 342, as in xplus4's screenshots, where the datasheet's counts would
+      # make it 40 to 343. $FF06 bit 4 clear blanks the whole picture to the
+      # border colour. A line of the window with no row under way shows the
+      # background colour, $FF15.
+      #
+      # $FF07 bits 0-2 move the characters right by as many pixels, the
+      # window's pixels before the first character showing the background.
+      module Picture
+        WIDTH = 384
+
+        # The horizontal count of a line's first pixel.
+        FIRST_COUNT = 419
+
+        # The column whose cycle paints the line, and the first whose writes
+        # land on the next line.
+        PAINT_COLUMN = 44
+        NEXT_LINE_COLUMN = 52
+
+        WINDOW_LEFT = 32
+        WINDOW_RIGHT = 352
+        NARROW_LEFT = 39
+        NARROW_RIGHT = 343
+
+        # How many dots after its cycle's first a register write takes hold:
+        # where xplus4 shows a raster interrupt's colour change, a cell
+        # boundary with no horizontal scroll.
+        WRITE_DELAY = 19
+
+        # The picture, a palette index a pixel.
+        attr_reader :display
+
+        # Whether each line has been painted since the front end last
+        # cleared them.
+        attr_reader :dirty_lines
+
+        # Whether the TED paints its picture. It fetches either way.
+        attr_reader :render
+
+        def width = WIDTH
+
+        def height = lines_per_frame
+
+        def clear_dirty_lines!
+          @dirty_lines.fill(false)
+        end
+
+        def render=(value)
+          @render = value
+        end
+
+        private
+
+        def reset_picture
+          @display = Array.new(WIDTH * 312, 0)
+          @dirty_lines = Array.new(312, true)
+          @render = true
+          @painted = 0
+          @scanline = 0
+          @window_open = false
+          reset_modes
+        end
+
+        # The line count steps to +line+: the next scanline, and the
+        # window opens or shuts on its first and last lines.
+        def step_scanline(line)
+          @scanline = (@scanline + 1) % 312
+          rows25 = @registers[0x06].anybits?(0x08)
+          if line == (rows25 ? 4 : 8)
+            @window_open = true
+          elsif line == (rows25 ? 204 : 200)
+            @window_open = false
+          end
+        end
+
+        # The line count wraps to 0: the frame's first scanline.
+        def end_picture_frame
+          @scanline = -1
+        end
+
+        # The picture's part of a cycle in +column+.
+        def picture_cycle(column)
+          return unless column == PAINT_COLUMN
+
+          paint(WIDTH) if @render
+          @painted = 0
+        end
+
+        # Paints the line up to the pixel a register write lands on.
+        def paint_to_write
+          return unless @render
+
+          column = @column
+          return if column >= PAINT_COLUMN && column < NEXT_LINE_COLUMN
+
+          x = ((column * 8) + WRITE_DELAY - FIRST_COUNT) % 456
+          x = WIDTH if x > WIDTH
+          paint(x)
+        end
+
+        # Paints the line's pixels from where it was left up to +stop+.
+        def paint(stop)
+          start = @painted
+          return if stop <= start
+
+          @painted = stop
+          scanline = @scanline
+          @dirty_lines[scanline] = true
+          base = scanline * WIDTH
+          border = @registers[0x19] & 0x7f
+          return fill_span(base, start, stop, border) unless @window_open && @registers[0x06].anybits?(0x10)
+
+          narrow = !@registers[0x07].anybits?(0x08)
+          left = narrow ? NARROW_LEFT : WINDOW_LEFT
+          right = narrow ? NARROW_RIGHT : WINDOW_RIGHT
+          fill_span(base, start, stop.clamp(..left), border)
+          paint_window(base, start.clamp(left..), stop.clamp(..right))
+          fill_span(base, start.clamp(right..), stop, border)
+        end
+
+        def fill_span(base, start, stop, color)
+          @display.fill(color, base + start, stop - start) if stop > start
+        end
+
+        def paint_window(base, start, stop)
+          return if stop <= start
+
+          background = @registers[0x15] & 0x7f
+          return fill_span(base, start, stop, background) unless @pattern_fetches
+
+          first = WINDOW_LEFT + (@registers[0x07] & 0x07)
+          if start < first
+            fill_span(base, start, stop.clamp(..first), background)
+            start = first
+          end
+          paint_characters(base, start, stop, first)
+        end
+
+        # Paints the characters' pixels +start+ to +stop+, the first
+        # character's first pixel at +first+.
+        def paint_characters(base, start, stop, first)
+          mode = self.mode
+          x = start
+          while x < stop
+            index = (x - first) >> 3
+            origin = first + (index << 3)
+            to = (origin + 8).clamp(..stop)
+            character_colors(index, mode)
+            paint_pixels(base, x, to, origin)
+            x = to
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      class Sound
+        # The sound's level averaged over each sample of the audio rate,
+        # which integrates the SND pin as the board's RC network does, then
+        # through the network's coupling capacitor, a one-pole high-pass at
+        # 2.7 Hz run at the audio rate.
+        #
+        # The corner comes from the Plus/4 schematic (310164, sheet 2): SND
+        # reaches the video connector through R10 (1K) and C18 (10 uF) into
+        # R11 (12K) and R12 (10K) beside Q3's emitter follower. The
+        # network's low-pass, C19 (2,700 pF) at about 70 kHz, is far above
+        # any audio rate.
+        class Output
+          HIGH_PASS_HZ = 2.7
+
+          # Scales the loudest level, both voices high at volume 8, to the
+          # top of a signed 16-bit sample.
+          SCALE = 32_767.0 / 19_976
+
+          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
+            @drift = level.to_f
+            @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(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
+            average = @sum.fdiv(@window)
+            @drift += @high_pass * (average - @drift)
+            sample = ((average - @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/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.rb

@@ -2,14 +2,21 @@
 
 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 and the clock it gives the CPU (Beam). It paints no
-    # picture and plays no sound yet: those registers keep what is written
-    # to them.
+    # 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)
@@ -23,10 +30,16 @@ module Badline
     # 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.
+    # 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
@@ -42,6 +55,10 @@ module Badline
       # 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).
@@ -50,10 +67,15 @@ module Badline
       # 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
 
@@ -63,16 +85,22 @@ module Badline
         @interrupt_mask = 0
         @raster_compare = 0
         @key_latch = 0xff
+        @blink = 0
         reset_timers
+        reset_fetches
+        reset_picture
         reset_beam
       end
 
-      # Counts the timers and moves the beam on a cycle, unless $FF07's
-      # freeze bit holds them, then decides the CPU's clock for the cycle.
+      # 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
@@ -92,9 +120,12 @@ module Badline
         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
@@ -103,6 +134,7 @@ module Badline
         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)
@@ -110,8 +142,12 @@ module Badline
         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
 
@@ -125,6 +161,17 @@ module Badline
         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)