badline 0.13.0 → 0.15.0

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      class Sound
+        # The sound's fields in a keyed snapshot module (Snapshot::Keyed,
+        # BL-TEDSOUND): each voice's output and when it next toggles, in
+        # cycles from the machine's clock, absent while it never will, the
+        # noise's shift register, and how far behind the clock the voices
+        # last ran. The frequencies, the volume and the reload bit come from
+        # the TED's registers on load (#restored!), and the output's level
+        # from those.
+        module KeyedState
+          def save_fields(out)
+            now = @clock.cycles
+            run_to(now)
+            VOICES.times do |voice|
+              due = @next_toggles[voice]
+              out.int("voice#{voice + 1}.phase", @phases[voice])
+              out.optional_int("voice#{voice + 1}.toggle_in", due >= NEVER ? nil : due - now)
+            end
+            out.int("noise", @noise).int("ran_ago", now - @time)
+          end
+
+          def load_fields(input)
+            now = @clock.cycles
+            VOICES.times do |voice|
+              @phases[voice] = input.masked("voice#{voice + 1}.phase", @phases[voice], 0x01)
+              due = input.optional_int("voice#{voice + 1}.toggle_in")
+              @next_toggles[voice] = due.nil? ? NEVER : now + due
+            end
+            @noise = input.byte("noise", @noise)
+            @time = now - input.int("ran_ago", now - @time)
+          end
+
+          # The frequencies, the volume and the reload bit as `ted`'s
+          # registers $FF0E-$FF12 hold them, and the level they give.
+          def restored!(ted)
+            @frequencies[0] = ted.peek(0xff0e) | ((ted.peek(0xff12) & 0x03) << 8)
+            @frequencies[1] = ted.peek(0xff0f) | ((ted.peek(0xff10) & 0x03) << 8)
+            VOICES.times { |voice| @intervals[voice] = interval_for(@frequencies[voice]) }
+            control = ted.peek(0xff11)
+            @control = control
+            @reloading = control >= 0x80
+            @volume = [control & 0x0f, 8].min
+            @level = level_now
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The DMA a line makes, as a snapshot names it, in Beam's order.
+      DMA_KINDS = %w[none attributes pointers].freeze
+
+      # The shape of the line going out, as the picture paints it. A
+      # snapshot whose line.layout differs repaints the line from its
+      # start.
+      LINE_LAYOUT = 1
+
+      # The TED's fields in a keyed snapshot module (Snapshot::Keyed,
+      # BL-TED): the registers as written, the interrupt flags, the keyboard
+      # latch, the blink counter, the timers, the beam and the clock it gave
+      # the CPU last, the fetches' buffers and counters, and the picture:
+      # where the scanline is, whether the window is open, how far the line
+      # going out is painted (line.*), and the picture itself. The interrupt
+      # mask and the raster compare come from $FF0A and $FF0B on load.
+      module KeyedState
+        def save_fields(out)
+          out.bytes("registers", @registers).int("interrupt_flags", @interrupt_flags).int("key_latch", @key_latch)
+          out.int("blink", @blink).bool("blink_on", @blink_on)
+          save_timer_fields(out)
+          out.int("column", @column).int("line", @line).bool("ba", @ba_low).int("cpu_slots", @cpu_slots)
+          save_fetch_fields(out)
+          out.int("scanline", @scanline).bool("window_open", @window_open)
+          out.int("line.layout", LINE_LAYOUT).int("line.painted", @painted).bytes("display", @display)
+        end
+
+        def load_fields(input)
+          input.bytes_into("registers", @registers)
+          @interrupt_flags = input.byte("interrupt_flags", @interrupt_flags)
+          @key_latch = input.byte("key_latch", @key_latch)
+          @blink = input.masked("blink", @blink, 0x0f)
+          @blink_on = input.bool("blink_on", @blink_on)
+          load_timer_fields(input)
+          @column = input.int("column", @column) % Beam::CYCLES_PER_LINE
+          @line = input.masked("line", @line, 0x1ff)
+          @ba_low = input.bool("ba", @ba_low)
+          @cpu_slots = input.int("cpu_slots", @cpu_slots).clamp(0, 2)
+          load_fetch_fields(input)
+          @scanline = input.int("scanline", @scanline)
+          @window_open = input.bool("window_open", @window_open)
+          load_line_fields(input)
+          input.bytes_into("display", @display)
+        end
+
+        # The interrupt mask and the raster compare from $FF0A and $FF0B,
+        # and every line of the picture changed.
+        def restored!
+          mask = @registers[0x0a]
+          @interrupt_mask = mask & 0x5f
+          @raster_compare = ((mask & 0x01) << 8) | @registers[0x0b]
+          @dirty_lines.fill(true)
+        end
+
+        private
+
+        def save_timer_fields(out)
+          3.times do |index|
+            out.int("timer#{index + 1}.count", @timer_counts[index])
+            out.bool("timer#{index + 1}.running", @timer_running[index])
+          end
+          out.int("timer1.reload", @timer1_reload)
+        end
+
+        def load_timer_fields(input)
+          3.times do |index|
+            @timer_counts[index] = input.word("timer#{index + 1}.count", @timer_counts[index])
+            @timer_running[index] = input.bool("timer#{index + 1}.running", @timer_running[index])
+          end
+          @timer1_reload = input.word("timer1.reload", @timer1_reload)
+        end
+
+        def save_fetch_fields(out)
+          out.bytes("fetch.patterns", @patterns).bytes("fetch.pointers", @pointers)
+          out.bytes("fetch.attributes", @attributes).bytes("fetch.next_attributes", @fetched_attributes)
+          out.int("fetch.char_position", @char_position).int("fetch.line_position", @line_position)
+          out.int("fetch.row_line", @row_line).bool("fetch.row_active", @row_active)
+          out.text("fetch.dma", DMA_KINDS.fetch(@dma_kind)).bool("fetch.patterns_on", @pattern_fetches)
+        end
+
+        def load_fetch_fields(input)
+          input.bytes_into("fetch.patterns", @patterns)
+          input.bytes_into("fetch.pointers", @pointers)
+          input.bytes_into("fetch.attributes", @attributes)
+          input.bytes_into("fetch.next_attributes", @fetched_attributes)
+          @char_position = input.masked("fetch.char_position", @char_position, 0x3ff)
+          @line_position = input.masked("fetch.line_position", @line_position, 0x3ff)
+          @row_line = input.masked("fetch.row_line", @row_line, 0x07)
+          @row_active = input.bool("fetch.row_active", @row_active)
+          @dma_kind = DMA_KINDS.index(input.choice("fetch.dma", DMA_KINDS, DMA_KINDS.fetch(@dma_kind))) || 0
+          @pattern_fetches = input.bool("fetch.patterns_on", @pattern_fetches)
+        end
+
+        def load_line_fields(input)
+          line = input.int("line.layout", 0) == LINE_LAYOUT
+          input.adjust("line in progress from another renderer, restarted") unless line || input.missing?
+          @painted = line ? input.int("line.painted", @painted).clamp(0, Picture::WIDTH) : 0
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      # The colours a character's pixels take in each mode, by $FF06 bits 5
+      # (bitmap) and 6 (extended colour) and $FF07 bit 4 (multicolour), with
+      # a pattern byte's set bits as 1 (the datasheet's "Character modes"
+      # and "Bit map mode", Härsfalvi's "Talking to TED"). Each was checked
+      # against xplus4 screenshots of the same registers and memory.
+      #
+      # - Text: 1 is the attribute's colour and luminance, bits 0-6, and 0
+      #   the background, $FF15. With $FF07 bit 7 clear a pointer's bit 7
+      #   reverses the character. The cursor ($FF0C-$FF0D, a character
+      #   position) reverses its character, and an attribute's bit 7 makes
+      #   its character flash to the background, each in turns of 16 frames
+      #   of the blink counter.
+      # - Multicolour text: a character whose attribute has bit 3 set takes
+      #   its bits in pairs of double-width pixels, 00 the background, 01
+      #   $FF16, 10 $FF17 and 11 the attribute's bits 0-2 and 4-6. Other
+      #   characters show as in text. No reverse, cursor or flash.
+      # - Extended colour: the pointer's bits 6-7 pick the background,
+      #   $FF15-$FF18. No reverse, cursor or flash.
+      # - Bitmap: 0 takes its colour from the video matrix's low nibble and
+      #   its luminance from the attribute's bits 4-6, 1 from the matrix's
+      #   high nibble and the attribute's bits 0-2.
+      # - Multicolour bitmap: 00 the background, 01 the bitmap's 1, 10 its
+      #   0, 11 $FF16, as xplus4 shows them. The datasheet gives 01 the
+      #   luminance of bits 4-6 as well.
+      # - Extended colour with either of the others: black.
+      module Modes
+        TEXT = 0x00
+        MULTICOLOR_TEXT = 0x10
+        BITMAP = 0x20
+        MULTICOLOR_BITMAP = 0x30
+        EXTENDED_COLOR = 0x40
+
+        private
+
+        def reset_modes
+          @pixel_bits = 0
+          @pixel_colors = Array.new(4, 0)
+          @multicolor_pixels = false
+          @blink_on = false
+        end
+
+        # The mode, $FF06 bits 5 and 6 with $FF07 bit 4.
+        def mode = (@registers[0x06] & 0x60) | (@registers[0x07] & 0x10)
+
+        # Sets the pixel bits and colours of character +index+ in +mode+.
+        def character_colors(index, mode)
+          pattern = @patterns[index]
+          pointer = @pointers[index]
+          attribute = @attributes[index]
+          case mode
+          when TEXT then text_colors(index, pattern, pointer, attribute)
+          when MULTICOLOR_TEXT then multicolor_text_colors(pattern, attribute)
+          when BITMAP then bitmap_colors(pattern, pointer, attribute)
+          when MULTICOLOR_BITMAP then multicolor_bitmap_colors(pattern, pointer, attribute)
+          when EXTENDED_COLOR then hires(pattern, @registers[0x15 + (pointer >> 6)] & 0x7f, attribute & 0x7f)
+          else hires(0, 0, 0)
+          end
+        end
+
+        # Paints pixels +from+ to +to+ of the line at +base+, of a character
+        # whose first pixel is +origin+, in the colours last set.
+        def paint_pixels(base, from, to, origin)
+          display = @display
+          bits = @pixel_bits
+          colors = @pixel_colors
+          multicolor = @multicolor_pixels
+          x = from
+          while x < to
+            offset = x - origin
+            color = multicolor ? colors[(bits >> (6 - (offset & 0x06))) & 0x03] : colors[(bits >> (7 - offset)) & 0x01]
+            display[base + x] = color
+            x += 1
+          end
+        end
+
+        def hires(pattern, background, foreground)
+          @pixel_bits = pattern
+          @pixel_colors[0] = background
+          @pixel_colors[1] = foreground
+          @multicolor_pixels = false
+        end
+
+        def multicolor(pattern, color1, color2, color3)
+          @pixel_bits = pattern
+          colors = @pixel_colors
+          colors[0] = @registers[0x15] & 0x7f
+          colors[1] = color1
+          colors[2] = color2
+          colors[3] = color3
+          @multicolor_pixels = true
+        end
+
+        def text_colors(index, pattern, pointer, attribute)
+          pattern ^= 0xff if pointer >= 0x80 && !@registers[0x07].anybits?(0x80)
+          if @blink_on
+            pattern ^= 0xff if ((@line_position + index) & 0x3ff) == cursor_position
+          elsif attribute >= 0x80
+            pattern = 0
+          end
+          hires(pattern, @registers[0x15] & 0x7f, attribute & 0x7f)
+        end
+
+        def cursor_position = ((@registers[0x0c] & 0x03) << 8) | @registers[0x0d]
+
+        def multicolor_text_colors(pattern, attribute)
+          if attribute.anybits?(0x08)
+            multicolor(pattern, @registers[0x16] & 0x7f, @registers[0x17] & 0x7f, attribute & 0x77)
+          else
+            hires(pattern, @registers[0x15] & 0x7f, attribute & 0x7f)
+          end
+        end
+
+        def bitmap_colors(pattern, pointer, attribute)
+          hires(pattern, (pointer & 0x0f) | (attribute & 0x70), (pointer >> 4) | ((attribute & 0x07) << 4))
+        end
+
+        def multicolor_bitmap_colors(pattern, pointer, attribute)
+          multicolor(pattern, (pointer >> 4) | ((attribute & 0x07) << 4), (pointer & 0x0f) | (attribute & 0x70),
+                     @registers[0x16] & 0x7f)
+        end
+
+        # The blink counter's carry turns the cursor and flash over.
+        def blink_carry
+          @blink_on = !@blink_on
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class TED
+      # The TED's 128 colours.
+      module Palette
+        # The colours by index, (luminance << 4) | colour, as RGB, from the
+        # Plus/4 hardware manual's TED chapter. Luma comes from each
+        # luminance level's voltage (4.4.3): level 0, 2.0 V, is black, the
+        # eight luminances are levels 1-8, and 4.8 V is white. Chroma takes
+        # the PAL column's hue phase (4.4.4), with U along 0 degrees and V
+        # along 90, at an amplitude of half CHROMA OUT's 1 Vp-p over the
+        # 2.8 V from black to white (4.4.2). Colour 0 is black at every
+        # luminance and colour 1 has no chroma. BT.601 turns them into RGB,
+        # B-Y = U / 0.492 and R-Y = V / 0.877, clamped. NTSC machines take
+        # the same palette. The datasheet's NTSC column is the PAL one less
+        # 33 degrees, but for orange, which it gives 129 on PAL and 90 on
+        # NTSC.
+        PALETTE = [
+          0x000000, 0x242424, 0x570f10, 0x003a39, 0x4e045c, 0x004400, 0x19197f, 0x303000,
+          0x4d1b00, 0x402600, 0x173d00, 0x580830, 0x00401c, 0x05266e, 0x390a7a, 0x084200,
+          0x000000, 0x323232, 0x651c1d, 0x004847, 0x5c126a, 0x055205, 0x26278c, 0x3e3e00,
+          0x5a2900, 0x4e3300, 0x254a00, 0x66163d, 0x004e2a, 0x13347c, 0x461787, 0x165000,
+          0x000000, 0x404040, 0x722a2b, 0x0d5555, 0x692077, 0x126013, 0x34349a, 0x4b4b00,
+          0x683706, 0x5b4100, 0x325800, 0x73234b, 0x0c5c38, 0x21418a, 0x542595, 0x235d00,
+          0x000000, 0x525252, 0x853c3d, 0x1f6867, 0x7b328a, 0x257225, 0x4646ac, 0x5e5e00,
+          0x7a4918, 0x6d5303, 0x456a00, 0x85365d, 0x1e6e4a, 0x33549c, 0x6637a7, 0x366f04,
+          0x000000, 0x767676, 0xa96162, 0x448c8b, 0xa056ae, 0x49964a, 0x6b6bd1, 0x82821c,
+          0x9f6d3c, 0x927828, 0x698f1d, 0xaa5a82, 0x43926e, 0x5778c0, 0x8b5ccc, 0x5a9429,
+          0x000000, 0x929292, 0xc47c7d, 0x5fa7a7, 0xbb72c9, 0x64b265, 0x8686ec, 0x9d9d38,
+          0xba8857, 0xad9343, 0x84aa38, 0xc5759d, 0x5eae8a, 0x7293dc, 0xa677e7, 0x75af44,
+          0x000000, 0xbfbfbf, 0xf2aaaa, 0x8dd5d4, 0xe99ff7, 0x92df92, 0xb4b4ff, 0xcbcb65,
+          0xe8b685, 0xdbc071, 0xb2d766, 0xf3a3cb, 0x8cdbb7, 0xa0c1ff, 0xd4a4ff, 0xa3dd72,
+          0x000000, 0xffffff, 0xffe9ea, 0xccffff, 0xffdfff, 0xd2ffd2, 0xf3f3ff, 0xffffa5,
+          0xfff6c5, 0xffffb1, 0xf2ffa6, 0xffe3ff, 0xcbfff7, 0xe0ffff, 0xffe4ff, 0xe3ffb1
+        ].freeze
+
+        def palette = PALETTE
+      end
+    end
+  end
+end

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