badline 0.6.1 → 0.7.0

data/lib/badline/frontend/player_window.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID player's window, which `sid` plays in, drawn by PlayerScreen:
+    # a header with the tune, its STIL credit, the views and the SID model,
+    # and a footer with the time and the buttons that step through the
+    # queue, framing one of three views: the visualizer, with each voice's
+    # note and output and the mix, the SID view, with everything the chip
+    # is doing, and the tune's STIL entry. The window's height follows the
+    # view, and .sid files and folders dropped on it join the queue.
+    #
+    # It stands in for the terminal, so Audio::Jukebox drives it the same
+    # way: #wait handles the window's clicks, keys and drops between frames
+    # and redraws it at the display's pace. The SID model buttons switch
+    # the chips playing on the spot, and each tune after it starts on the
+    # same choice. AUTO gives each of a tune's SIDs its own model.
+    class PlayerWindow < Audio::Terminal
+      FRAME = 1.0 / 50
+
+      MOUSEWHEEL = 0x403
+      DROPFILE = 0x1000
+      UP = 82
+      DOWN = 81
+
+      WARNING = Screen::COLORS[10]
+
+      CHIPS = PlayerHeader::CHIPS
+
+      KEYS = {
+        17 => :next, 19 => :previous,
+        79 => :next_subtune, 80 => :previous_subtune,
+        44 => :pause, 22 => :shuffle, 15 => :loop, 4 => :all_subtunes,
+        20 => :quit, 41 => :quit,
+        54 => :back, 55 => :forward,
+        43 => :view, 6 => :chip
+      }.freeze
+
+      def initialize(input:, output:)
+        super
+        @screen = PlayerScreen.new
+        @player = nil
+        @tune_file = nil
+        @history = SIDHistory.new(Audio::Renderer::DEFAULT_RATE)
+        @state = PlayerState.new
+        @commands = PlayerCommands.new(@state)
+        @next_draw = 0.0
+        @seek_left = 0
+        @dropped = []
+        @credits = []
+        @stil = []
+        @stil_subtune = 0
+        @subtune_stil = []
+        @scrolling = false
+      end
+
+      # The seconds into the subtune the last click on the bar asked for.
+      def seek_to = PlayerFooter.seek(@seek_left, @state.length)
+
+      # The files dropped on the window since it last said :drop.
+      def dropped
+        paths = @dropped
+        @dropped = []
+        paths
+      end
+
+      def session
+        @screen.open(@state.view)
+        @screen.info.show(@stil, @stil_subtune, @subtune_stil)
+        yield
+      ensure
+        @screen.close
+      end
+
+      # Handles the window's clicks, keys and drops and redraws it until
+      # `seconds` are up, returning early with those that ask the jukebox
+      # for something.
+      def wait(seconds)
+        actions = poll
+        deadline = now + seconds
+        loop do
+          draw if now >= @next_draw
+          left = deadline - now
+          break if left <= 0 || !actions.empty?
+
+          SDL.SDL_Delay([([left, @next_draw - now].min * 1000).floor, 1].max)
+          actions.concat(poll)
+        end
+        actions
+      end
+
+      def header(lines) = lines
+
+      def announce(lines) = lines
+
+      def place(tune, tunes)
+        @state.stop_seeking unless tune == @state.tune
+        @state.tune = tune
+        @state.tunes = tunes
+      end
+
+      def status(subtune:, subtunes:, elapsed:, length:, notes: [])
+        state = @state
+        state.stop_seeking unless subtune == state.subtune
+        state.subtune = subtune
+        state.subtunes = subtunes
+        state.elapsed = elapsed
+        state.length = length
+        state.notes = notes
+      end
+
+      # Keeps the subtune's STIL credits for the header and the whole entry
+      # for the INFO view.
+      def stil(fields, subtune, subtune_fields)
+        @credits = Storage::STIL::Credit.list(subtune_fields.empty? ? fields : subtune_fields)
+        @stil = fields
+        @stil_subtune = subtune
+        @subtune_stil = subtune_fields
+        @screen.info.show(fields, subtune, subtune_fields) if @screen.open?
+      end
+
+      # Follows the renderer's SIDs from here on, on the model chosen.
+      def playing(renderer)
+        @player = renderer.player
+        @tune_file = renderer.tune
+        stereo = @player.stereo
+        @history = SIDHistory.new(renderer.rate, stereo.sids.size)
+        stereo.sids.each(&:record_voices!)
+        renderer.observer = ->(samples, rendered) { @history.record(stereo.sids, stereo.outputs, samples, rendered) }
+        choose_model
+        @screen.fit_sids(@state.view, stereo.sids.size)
+        @screen.title(renderer.tune.name)
+      end
+
+      private
+
+      def poll
+        actions = []
+        while SDL.SDL_PollEvent(SDL.event) != 0
+          case SDL.event_type(SDL.event)
+          when SDL::QUIT then actions << :quit
+          when SDL::KEYDOWN then key(SDL.event_scancode(SDL.event), actions) if SDL.event_repeat(SDL.event).zero?
+          when SDL::MOUSEMOTION then point
+          when SDL::MOUSEBUTTONDOWN then click(actions) if SDL.event_button(SDL.event) == 1
+          when SDL::MOUSEBUTTONUP then @scrolling = false
+          when MOUSEWHEEL then @screen.info.scroll(-3 * SDL.event_x(SDL.event))
+          when DROPFILE then drop(actions)
+          end
+        end
+        actions
+      end
+
+      def drop(actions)
+        file = SDL.event_file(SDL.event)
+        @dropped << LibC.strstr(file, "")
+        LibC.free(file)
+        actions << :drop unless actions.include?(:drop)
+      end
+
+      def point
+        top = SDL.event_y(SDL.event)
+        @screen.buttons.point(SDL.event_x(SDL.event), top)
+        @screen.info.scroll_along(top) if @scrolling
+      end
+
+      def key(scancode, actions)
+        return @screen.info.scroll(scancode == UP ? -1 : 1) if [UP, DOWN].include?(scancode)
+
+        action = KEYS[scancode]
+        command(action, actions) unless action.nil?
+      end
+
+      def click(actions)
+        left = SDL.event_x(SDL.event)
+        action = @screen.buttons.action_at(left, SDL.event_y(SDL.event))
+        return if action.nil?
+
+        @seek_left = left if action == :seek
+        return scroll_along if action == :scroll
+
+        command(action, actions)
+      end
+
+      # Lets PlayerCommands handle the action, then follows a change of view
+      # or SID model it made.
+      def command(action, actions)
+        view = @state.view
+        chip = @state.chip
+        passed = @commands.handle(action)
+        follow_seek(passed) if %i[seek forward back].include?(passed)
+        actions << passed unless passed.nil?
+        resize unless view == @state.view
+        choose_model unless chip == @state.chip
+      end
+
+      # Notes where a seek is headed, as the jukebox will take it.
+      def follow_seek(action)
+        state = @state
+        step = Audio::Jukebox::SEEK_STEP
+        seconds = { seek: seek_to, forward: state.played + step, back: state.played - step }.fetch(action)
+        state.seek(seconds.clamp(0.0, [state.length - 1.0, 0.0].max))
+      end
+
+      def scroll_along
+        @scrolling = true
+        @screen.info.scroll_along(SDL.event_y(SDL.event))
+      end
+
+      def resize
+        @screen.resize(@state.view)
+        @next_draw = 0.0
+      end
+
+      def choose_model
+        return if @player.nil?
+
+        @player.stereo.refit(CHIPS[@state.chip])
+      end
+
+      def draw
+        @next_draw = now + FRAME
+        @screen.draw(@state, @player, @history, @tune_file, Storage::STIL::Credit.at(@credits, @state.played))
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/frontend/scope.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # An oscilloscope in a box: one channel of SIDHistory's samples, as
+    # heard, with the trace held still on a rising edge. `box` is its left,
+    # top, width and height, `span` how many samples fit its width and
+    # `range` the swing that fills its height. The trace is centred on the
+    # middle of the samples' range when `centred`, and on zero otherwise.
+    class Scope
+      def initialize(painter, box, span:, range:, centred: false)
+        @painter = painter
+        @left = box[0]
+        @top = box[1]
+        @width = box[2]
+        @height = box[3]
+        @span = span
+        @range = range
+        @centred = centred
+        @points = Array.new(@width + 1, 0)
+      end
+
+      def draw(history, played, channel, rgb)
+        @painter.box(@left, @top, @width, @height, SIDView::BOX)
+        span = @span
+        range = @range
+        start = history.scope_start(played, span, channel)
+        middle = @centred ? history.middle(start, span, channel) : 0
+        centre = @top + (@height / 2)
+        points = @points
+        x = 0
+        while x <= @width
+          value = history.sample_at(start + (x * span / @width), channel) - middle
+          top = (centre - (value * (@height - 4) / range)).clamp(@top, @top + @height - 1)
+          points[x] = Painter.point(@left + x, top)
+          x += 1
+        end
+        @painter.polyline(points, rgb)
+      end
+    end
+  end
+end

data/lib/badline/frontend/sid_history.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Each SID's state at the end of each frame rendered, and the samples
+    # rendered, kept for long enough that the SID player can show what is
+    # being heard rather than what was last rendered: rendering runs ahead
+    # of the audio device by the queue in between.
+    #
+    # The samples come in four channels a SID, 0 to 3 for SID 1, 4 to 7 for
+    # SID 2 and so on: each voice's own output, when the SID records them,
+    # then the SID's own output (#output). The left and right of the mix
+    # follow them all (#left and #right).
+    class SIDHistory
+      FRAMES = 64
+      SAMPLES = 16_384
+
+      # Per frame: the 25 write registers, then each voice's envelope level,
+      # then each voice's envelope state as an index into STATES.
+      FIELDS = 31
+      LEVELS = 25
+      PHASES = 28
+
+      STATES = %i[attack decay_sustain release].freeze
+
+      # SID 1's own output, which is the mix with only one SID.
+      MIX = 3
+
+      attr_reader :rate, :sid_count
+
+      def initialize(rate, sid_count = 1)
+        @rate = rate
+        @sid_count = sid_count
+        @channels = (sid_count * 4) + 2
+        @times = Array.new(FRAMES, 0.0)
+        @states = Array.new(FRAMES * FIELDS * sid_count, 0)
+        @frames = 0
+        @samples = Array.new(SAMPLES * @channels, 0)
+        @written = 0
+        @rendered = 0.0
+      end
+
+      # Keeps the frame that ends at `rendered` seconds: the state of each of
+      # `sids`, each one's own samples in `outputs`, and the stereo mix in
+      # `samples`, the left and right interleaved.
+      def record(sids, outputs, samples, rendered)
+        slot = @frames % FRAMES
+        @times[slot] = rendered
+        sids.size.times { |index| keep_state(sids[index], ((slot * @sid_count) + index) * FIELDS) }
+        @frames += 1
+        keep(sids, outputs, samples)
+        @rendered = rendered
+      end
+
+      def empty? = @frames.zero?
+
+      def output(sid) = (sid * 4) + MIX
+
+      def left = @sid_count * 4
+
+      def right = left + 1
+
+      # Where the fields of SID `sid` in the frame heard at `played` seconds
+      # start: the latest frame rendered by then, or the oldest kept.
+      def frame(played, sid = 0)
+        kept = [@frames, FRAMES].min
+        newest = @frames - 1
+        age = 0
+        while age < kept - 1
+          break if @times[(newest - age) % FRAMES] <= played
+
+          age += 1
+        end
+        ((((newest - age) % FRAMES) * @sid_count) + sid) * FIELDS
+      end
+
+      def register(frame, reg) = @states[frame + reg]
+
+      # The voice's oscillator frequency in hertz, at the SID's clock.
+      def hertz(frame, voice, clock_hz)
+        base = voice * 7
+        (register(frame, base) | (register(frame, base + 1) << 8)) * clock_hz / 16_777_216.0
+      end
+
+      def level(frame, voice) = @states[frame + LEVELS + voice]
+
+      def state(frame, voice) = STATES[@states[frame + PHASES + voice]]
+
+      # The first of `count` samples of `channel` heard up to `played`
+      # seconds, moved back to where the wave last rose through its middle,
+      # so a steady tone holds still from one frame to the next.
+      def scope_start(played, count, channel = MIX)
+        last = @written - ((@rendered - played) * @rate).round
+        last = @written if last > @written
+        earliest = [@written - SAMPLES, 0].max
+        start = last - count
+        return earliest if start < earliest
+
+        rising(start, [start - count, earliest].max, channel)
+      end
+
+      def sample_at(index, channel = MIX) = @samples[((index % SAMPLES) * @channels) + channel]
+
+      # The middle of the range `channel` covers over `count` samples from
+      # `start`, which a voice's scope centres on.
+      def middle(start, count, channel)
+        low = high = sample_at(start, channel)
+        index = start + 1
+        while index < start + count
+          value = sample_at(index, channel)
+          low = value if value < low
+          high = value if value > high
+          index += 1
+        end
+        (low + high) / 2
+      end
+
+      private
+
+      def keep_state(sid, base)
+        states = @states
+        25.times { |reg| states[base + reg] = sid.register(reg) }
+        voices = sid.voices
+        3.times do |voice|
+          envelope = voices[voice].envelope
+          states[base + LEVELS + voice] = envelope.counter
+          states[base + PHASES + voice] = STATES.index(envelope.state) || 0
+        end
+      end
+
+      def keep(sids, outputs, samples)
+        first = @written
+        sids.size.times { |index| keep_sid(first, index * 4, outputs[index], sids[index].drain_voice_samples) }
+        stored = @samples
+        channels = @channels
+        left = channels - 2
+        i = 0
+        while (i * 2) + 1 < samples.size
+          slot = ((@written % SAMPLES) * channels) + left
+          stored[slot] = samples[i * 2]
+          stored[slot + 1] = samples[(i * 2) + 1]
+          @written += 1
+          i += 1
+        end
+      end
+
+      def keep_sid(first, channel, output, voices)
+        stored = @samples
+        channels = @channels
+        i = 0
+        while i < output.size
+          slot = (((first + i) % SAMPLES) * channels) + channel
+          stored[slot + MIX] = output[i]
+          if voices.size > (i * 3) + 2
+            stored[slot] = voices[i * 3]
+            stored[slot + 1] = voices[(i * 3) + 1]
+            stored[slot + 2] = voices[(i * 3) + 2]
+          end
+          i += 1
+        end
+      end
+
+      def rising(start, limit, channel)
+        middle = middle(limit, start - limit + 1, channel)
+        index = start
+        while index > limit
+          return index if sample_at(index - 1, channel) < middle && sample_at(index, channel) >= middle
+
+          index -= 1
+        end
+        start
+      end
+    end
+  end
+end

data/lib/badline/frontend/sid_view.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID player's detailed view of one SID: each voice's note,
+    # registers and envelope over a scope of its output, then the filter (FilterView) and the scope of
+    # the SID's own output. `sid` picks which of a tune's SIDs it shows, and
+    # a tune on more than one gets a row of buttons above the voices that
+    # pick it, which makes the view PICKER taller.
+    class SIDView
+      COLORS = Screen::COLORS
+      TEXT = COLORS[14]
+      BRIGHT = COLORS[1]
+      DIM = COLORS[11]
+      BOX = COLORS[0]
+      VOICE_COLORS = [COLORS[7], COLORS[13], COLORS[3]].freeze
+
+      NOTES = %w[C C# D D# E F F# G G# A A# B].freeze
+      WAVES = %w[TRI SAW PUL NOI].freeze
+      FLAGS = %w[GATE SYNC RING TEST].freeze
+      PHASES = { attack: "ATTACK", decay_sustain: "DECAY/SUSTAIN", release: "RELEASE" }.freeze
+
+      LEFT = 16
+      WAVE_LEFT = 432
+      WAVE_WIDTH = 192
+      VOICE_HEIGHT = 64
+      PANEL_HEIGHT = 72
+      HEIGHT = (3 * VOICE_HEIGHT) + PANEL_HEIGHT + 12
+      PICKER = 20
+
+      SID_NAMES = ["SID 1", "SID 2", "SID 3"].freeze
+      SIDS = %i[sid1 sid2 sid3].freeze
+
+      # The nearest note to `hertz` and how many cents off it it is.
+      def self.note(hertz)
+        return "---" if hertz < 16.0
+
+        midi = 69 + (12 * Math.log(hertz / 440.0) / Math.log(2))
+        key = midi.round
+        cents = ((midi - key) * 100).round
+        name = NOTES[key % 12] + ((key / 12) - 1).to_s
+        name.ljust(3) + format("%<sign>s%<cents>02d", sign: cents.negative? ? "-" : "+", cents: cents.abs)
+      end
+
+      # The view's height for a tune on `sids` SIDs.
+      def self.height(sids) = sids > 1 ? HEIGHT + PICKER : HEIGHT
+
+      def initialize(painter, buttons, top)
+        @painter = painter
+        @buttons = buttons
+        @top = top
+        @filter = FilterView.new(painter)
+        @voices = Array.new(2) do |picker|
+          Array.new(3) do |voice|
+            Scope.new(painter, [WAVE_LEFT, top + (picker * PICKER) + (voice * VOICE_HEIGHT), WAVE_WIDTH,
+                                VOICE_HEIGHT - 12], span: 512, range: 9216, centred: true)
+          end
+        end
+        @outputs = Array.new(2) do |picker|
+          Scope.new(painter, [WAVE_LEFT, top + (picker * PICKER) + (3 * VOICE_HEIGHT) + 4, WAVE_WIDTH, PANEL_HEIGHT],
+                    span: 1024, range: 65_536)
+        end
+      end
+
+      def draw(history, played, clock_hz:, model:, sid: 0)
+        return if history.empty?
+
+        picker = history.sid_count > 1 ? 1 : 0
+        draw_picker(history.sid_count, sid) if picker == 1
+        top = @top + (picker * PICKER)
+        frame = history.frame(played, sid)
+        3.times { |voice| draw_voice(history, frame, voice, top + (voice * VOICE_HEIGHT), clock_hz) }
+        3.times { |voice| @voices[picker][voice].draw(history, played, (sid * 4) + voice, VOICE_COLORS[voice]) }
+        @filter.draw(history, frame, top + (3 * VOICE_HEIGHT) + 4, model)
+        @outputs[picker].draw(history, played, history.output(sid), BRIGHT)
+      end
+
+      private
+
+      def draw_picker(sids, shown)
+        x = LEFT
+        sids.times do |sid|
+          x += @buttons.text(x, @top, SID_NAMES[sid], SIDS[sid], on: sid == shown) + 4
+        end
+      end
+
+      def draw_voice(history, frame, voice, top, clock_hz)
+        base = voice * 7
+        color = VOICE_COLORS[voice]
+        control = history.register(frame, base + 4)
+        hertz = history.hertz(frame, voice, clock_hz)
+        paint = @painter
+        paint.text(LEFT, top, "VOICE #{voice + 1}", color)
+        paint.text(LEFT, top + 12, SIDView.note(hertz), history.level(frame, voice).zero? ? DIM : color, scale: 2)
+        paint.text(LEFT + 112, top + 12, format("%<hertz>.1f HZ", hertz:), TEXT)
+        draw_waves(control, top, color)
+        draw_flags(history, frame, voice, control, top + 24)
+        draw_envelope(history, frame, voice, top + 36, color)
+      end
+
+      def draw_waves(control, top, color)
+        x = LEFT + 224
+        WAVES.each_with_index do |wave, bit|
+          x += @painter.text(x, top, wave, control[bit + 4] == 1 ? color : DIM) + 8
+        end
+      end
+
+      def draw_flags(history, frame, voice, control, top)
+        x = LEFT + 112
+        FLAGS.each_with_index do |flag, bit|
+          x += @painter.text(x, top, flag, control[bit] == 1 ? BRIGHT : DIM) + 8
+        end
+        filtered = history.register(frame, 0x17)[voice] == 1
+        @painter.text(x, top, "FILT", filtered ? BRIGHT : DIM)
+      end
+
+      def draw_envelope(history, frame, voice, top, color)
+        base = voice * 7
+        attack_decay = history.register(frame, base + 5)
+        sustain_release = history.register(frame, base + 6)
+        paint = @painter
+        paint.text(LEFT + 112, top, format("PW %<pw>5.1f%%", pw: pulse_width(history, frame, voice) * 100.0 / 4096),
+                   TEXT)
+        rates = "A#{hex(attack_decay >> 4)} D#{hex(attack_decay & 0x0f)} " \
+                "S#{hex(sustain_release >> 4)} R#{hex(sustain_release & 0x0f)}"
+        paint.text(LEFT + 224, top, rates, TEXT)
+        paint.box(LEFT, top + 12, 128, 6, BOX)
+        paint.box(LEFT, top + 12, history.level(frame, voice) / 2, 6, color)
+        paint.box(LEFT + ((sustain_release >> 4) * 17 / 2), top + 10, 1, 10, BRIGHT)
+        paint.text(LEFT + 136, top + 12, PHASES.fetch(history.state(frame, voice), ""), DIM)
+      end
+
+      def hex(nibble) = nibble.to_s(16).upcase
+
+      def pulse_width(history, frame, voice)
+        history.register(frame, (voice * 7) + 2) | ((history.register(frame, (voice * 7) + 3) & 0x0f) << 8)
+      end
+    end
+  end
+end

data/lib/badline/frontend/visualizer_view.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID player's main view: each voice's note over a scope of its own
+    # output, and the mix below them. A tune on more than one SID gets a
+    # row of voices for each, shrunk to fit and labelled with the SID's
+    # number, and the mix split into its left and right.
+    class VisualizerView
+      HEIGHT = 176
+      VOICE_WIDTH = 192
+      VOICE_GAP = 16
+      MIX_WIDTH = 608
+      ROW_GAP = 4
+
+      # The height of each voice's scope, by how many SIDs there are.
+      VOICE_SCOPES = [64, 40, 28].freeze
+
+      def initialize(painter, top)
+        @painter = painter
+        @top = top
+        @voices = Array.new(VOICE_SCOPES.size) { |index| voice_scopes(index + 1) }
+        @mix = Scope.new(painter, [SIDView::LEFT, mix_top(1), MIX_WIDTH, mix_height(1)],
+                         span: 1024, range: 32_768, centred: true)
+        @sides = Array.new(VOICE_SCOPES.size - 1) { |index| side_scopes(index + 2) }
+      end
+
+      def draw(history, played, clock_hz:)
+        return if history.empty?
+
+        count = history.sid_count
+        count.times { |sid| draw_row(history, played, sid, clock_hz) }
+        draw_mix(history, played, count)
+      end
+
+      private
+
+      def left(voice) = SIDView::LEFT + (voice * (VOICE_WIDTH + VOICE_GAP))
+
+      # The height of a row's notes, in glyphs twice the size for one SID.
+      def note_height(count) = count == 1 ? 20 : 10
+
+      def row_height(count) = note_height(count) + VOICE_SCOPES[count - 1] + ROW_GAP
+
+      def row_top(count, sid) = @top + (sid * row_height(count))
+
+      def mix_top(count) = row_top(count, count) + 4
+
+      def mix_height(count) = @top + HEIGHT - 8 - mix_top(count)
+
+      def voice_scopes(count)
+        Array.new(count * 3) do |index|
+          Scope.new(@painter, [left(index % 3), row_top(count, index / 3) + note_height(count), VOICE_WIDTH,
+                               VOICE_SCOPES[count - 1]], span: 512, range: 9216, centred: true)
+        end
+      end
+
+      def side_scopes(count)
+        width = (MIX_WIDTH - VOICE_GAP) / 2
+        Array.new(2) do |side|
+          Scope.new(@painter, [SIDView::LEFT + (side * (width + VOICE_GAP)), mix_top(count), width, mix_height(count)],
+                    span: 1024, range: 32_768, centred: true)
+        end
+      end
+
+      def draw_row(history, played, sid, clock_hz)
+        count = history.sid_count
+        frame = history.frame(played, sid)
+        top = row_top(count, sid)
+        scopes = @voices[count - 1]
+        3.times do |voice|
+          color = SIDView::VOICE_COLORS[voice]
+          note = SIDView.note(history.hertz(frame, voice, clock_hz))
+          silent = history.level(frame, voice).zero?
+          @painter.text(left(voice), top, note, silent ? SIDView::DIM : color, scale: count == 1 ? 2 : 1)
+          scopes[(sid * 3) + voice].draw(history, played, (sid * 4) + voice, color)
+        end
+        draw_label(top, sid) if count > 1
+      end
+
+      def draw_label(top, sid)
+        label = "SID #{sid + 1}"
+        @painter.text(SIDView::LEFT + MIX_WIDTH - Painter.width(label), top, label, SIDView::TEXT)
+      end
+
+      def draw_mix(history, played, count)
+        if count == 1
+          @mix.draw(history, played, SIDHistory::MIX, SIDView::BRIGHT)
+          return
+        end
+
+        sides = @sides[count - 2]
+        sides[0].draw(history, played, history.left, SIDView::BRIGHT)
+        sides[1].draw(history, played, history.right, SIDView::BRIGHT)
+        top = mix_top(count) + 2
+        @painter.text(SIDView::LEFT + 2, top, "L", SIDView::DIM)
+        @painter.text(SIDView::LEFT + MIX_WIDTH - 10, top, "R", SIDView::DIM)
+      end
+    end
+  end
+end