badline 0.6.0 → 0.7.0

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/snapshots.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The window's snapshots: F11 saves the machine to a new
+    # badline-<date>-<time>.vsf in the working directory, and F12 goes back
+    # to the snapshot last saved or opened, in a new machine. --save-snapshot
+    # saves one after the last frame.
+    class Snapshots
+      KEYS = [Keys::F11, Keys::F12].freeze
+
+      # The machine running, which F12 replaces with the restored one.
+      attr_reader :computer
+
+      def initialize(computer, options)
+        @computer = computer
+        @last = options.snapshot? ? options.media_path.to_s : ""
+        @at_finish = options.save_snapshot
+      end
+
+      # Saves or restores for F11 or F12, and says whether a restored
+      # machine now runs in place of the one before.
+      def key(scancode)
+        return restore if scancode == Keys::F12
+
+        save if scancode == Keys::F11
+        false
+      end
+
+      # Saves the machine, and warns when it can't.
+      def save(path = "badline-#{Time.now.strftime('%Y%m%d-%H%M%S')}.vsf")
+        @computer.save_snapshot(path)
+        @last = path
+        puts "Saved #{path}"
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+      end
+
+      # Restores the snapshot last saved or opened into a new machine, and
+      # warns when it fails, leaving the machine running as it was.
+      def restore
+        if @last.empty?
+          puts "No snapshot to restore, F11 saves one"
+          return false
+        end
+
+        @computer = Snapshot.load(@last) { |line| puts line }
+        puts "Restored #{@last}"
+        true
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{@last}: #{e.message}"
+        false
+      end
+
+      def finish
+        save(@at_finish) unless @at_finish.empty?
+      end
+    end
+  end
+end

data/lib/badline/frontend/sound.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID's output on SDL's audio queue, as mono signed 16-bit samples.
+    # Once the device plays, it is the clock: #wait holds each frame until
+    # the queue is down to `AHEAD`, so the machine runs at the device's pace.
+    #
+    # The device starts once the queue holds AHEAD. Below real time the
+    # queue runs dry, and the device then stops until it holds AHEAD again,
+    # so the sound stutters with silent gaps rather than slowing down. A
+    # frame that would take the queue past LIMIT is dropped whole, which
+    # only happens unpaced.
+    #
+    # Each frame's samples go to SDL through an IO::Buffer of 16-bit values.
+    class Sound
+      RATE = 44_100
+      AHEAD = 0.08
+      LIMIT = 0.25
+
+      attr_reader :rate, :underruns, :dropped, :queued, :low, :high
+
+      def initialize(sid, wanted, verbose)
+        @sid = sid
+        @verbose = verbose
+        @device = 0
+        @rate = RATE
+        @started = false
+        @muted = false
+        @underruns = 0
+        @dropped = 0
+        @queued = 0
+        @buffer = IO::Buffer.new(4096)
+        reset_levels
+        open_device if wanted
+      end
+
+      def on? = @device != 0
+
+      # Plays another machine's SID from here on.
+      def sid=(sid)
+        @sid = sid
+        sid.record(rate: @rate) if on?
+      end
+
+      def muted? = @muted
+
+      def playing? = @started
+
+      def feed
+        return unless on?
+
+        samples = @sid.drain_samples
+        return if @muted || samples.empty?
+
+        level = queued_seconds
+        if level + (samples.size.to_f / @rate) > LIMIT
+          @dropped += samples.size
+        else
+          play(samples, level)
+        end
+      end
+
+      # How much the audio queue holds, in seconds.
+      def level = queued_seconds
+
+      # Waits until the queue is down to `level` seconds.
+      def wait(level = AHEAD)
+        SDL.SDL_Delay(1) while queued_seconds > level
+      end
+
+      def toggle_mute
+        @muted = !@muted
+        return unless @muted
+
+        halt
+        SDL.SDL_ClearQueuedAudio(@device)
+      end
+
+      def reset_levels
+        @low = LIMIT
+        @high = 0.0
+      end
+
+      def close
+        SDL.SDL_CloseAudioDevice(@device) if on?
+      end
+
+      private
+
+      def open_device
+        unless SDL.SDL_InitSubSystem(SDL::INIT_AUDIO).zero?
+          puts "No sound: #{SDL.SDL_GetError}"
+          return
+        end
+
+        SDL.spec_freq(SDL.wanted, RATE)
+        SDL.spec_format(SDL.wanted, SDL::AUDIO_S16LSB)
+        SDL.spec_channels(SDL.wanted, 1)
+        SDL.spec_samples(SDL.wanted, 512)
+        @device = SDL.SDL_OpenAudioDevice(nil, 0, SDL.wanted, SDL.obtained, SDL::ALLOW_FREQUENCY_CHANGE)
+        return puts "No sound: #{SDL.SDL_GetError}" unless on?
+
+        @rate = SDL.read_i32(SDL.obtained)
+        @sid.record(rate: @rate)
+        puts "Sound at #{@rate} Hz" if @verbose
+      end
+
+      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
+
+      def play(samples, level)
+        @low = level if level < @low
+        underrun! if @started && level.zero?
+        queue(samples)
+        level = queued_seconds
+        @high = level if level > @high
+        start if level >= AHEAD
+      end
+
+      def queue(samples)
+        count = samples.size
+        bytes = count * 2
+        @buffer.resize(bytes) if bytes > @buffer.size
+        buffer = @buffer
+        i = 0
+        while i < count
+          buffer.set_value(:s16, i * 2, samples[i])
+          i += 1
+        end
+        SDL.SDL_QueueAudio(@device, buffer, bytes)
+        @queued += count
+      end
+
+      def start
+        return if @started
+
+        @started = true
+        SDL.SDL_PauseAudioDevice(@device, 0)
+      end
+
+      def halt
+        @started = false
+        SDL.SDL_PauseAudioDevice(@device, 1)
+      end
+
+      def underrun!
+        @underruns += 1
+        puts "Running below real time, so the sound will stutter." if @underruns == 1
+        halt
+      end
+    end
+  end
+end

data/lib/badline/frontend/timeline.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The events of --at and --script. Each runs once its number of frames
+    # has run: a screenshot saves that frame, and the rest act on the
+    # machine before the next frame is clocked. A key or the freeze button
+    # is let go Options::Event::HOLD frames after it is pressed. An event
+    # that fails ends the run.
+    class Timeline
+      # Takes the events, --screenshot's at the last frame and whether to
+      # insert disks write-protected from Options.
+      def initialize(options)
+        @events = options.timeline
+        unless options.screenshot.empty? || options.frames.zero?
+          @events += [Options::Event.new(options.frames, "screenshot", options.screenshot)]
+        end
+        @read_only = options.read_only?
+        @program = options.program
+        @releases = []
+        @failed = false
+      end
+
+      # What's wrong with the events, the first key that names nothing,
+      # or an empty string.
+      def self.error(events)
+        event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument) }
+        event.nil? ? "" : "no such key: #{event.argument}"
+      end
+
+      def self.key?(name) = name == "restore" || !keyboard_key(name).nil? || !joystick_direction(name).nil?
+
+      # The Keyboard's key for a name such as space, return or a.
+      def self.keyboard_key(name)
+        key = Keyboard.new.matrix.flatten.find { |candidate| candidate.to_s == name }
+        key.nil? ? Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name } : key
+      end
+
+      # The direction of joy1-NAME or joy2-NAME, such as up or fire.
+      def self.joystick_direction(name)
+        return nil unless name.start_with?("joy1-") || name.start_with?("joy2-")
+
+        Joystick::DIRECTIONS.keys.find { |direction| direction.to_s == name[5, name.size - 5] }
+      end
+
+      # The screenshot's file name, with the frame's number in place of %d,
+      # or of %Nd or %0Nd padded to N digits.
+      def self.path(pattern, frame)
+        start = pattern.index("%")
+        finish = start.nil? ? nil : pattern.index("d", start)
+        return pattern if finish.nil?
+
+        width = pattern[start + 1, finish - start - 1]
+        return pattern unless width.match?(/\A\d*\z/)
+
+        number = frame.to_s.rjust(width.to_i, width.start_with?("0") ? "0" : " ")
+        pattern[0, start] + number + pattern[finish + 1, pattern.size - finish - 1]
+      end
+
+      # The files the frame's screenshots go to.
+      def screenshots(frame)
+        @events.select { |event| event.frame == frame && event.action == "screenshot" }
+               .map { |event| Timeline.path(event.argument, frame) }
+      end
+
+      # Whether the run ends at the frame: at a quit, or once an event failed.
+      def quit?(frame) = @failed || @events.any? { |event| event.frame == frame && event.action == "quit" }
+
+      # Whether an event failed, which ends the run.
+      def failed? = @failed
+
+      # Lets go of what was held until this frame, then runs its events, up
+      # to one that fails.
+      def run(computer, frame)
+        @releases.each { |event| release(computer, event) if event.frame == frame }
+        @releases.reject! { |event| event.frame == frame }
+        @events.each { |event| perform(computer, event) if event.frame == frame && !@failed }
+      end
+
+      private
+
+      def perform(computer, event)
+        case event.action
+        when "key" then press(computer, event)
+        when "type" then computer.type_text(event.argument.gsub("\\n", "\r").gsub("\\r", "\r"))
+        when "insert" then insert(computer, event.argument)
+        when "eject" then eject(computer, event.argument)
+        when "reset" then computer.reset!
+        when "freeze" then freeze(computer, event)
+        end
+      end
+
+      def press(computer, event)
+        name = event.argument
+        if name == "restore"
+          computer.press_restore
+          return
+        end
+
+        direction = Timeline.joystick_direction(name)
+        if direction.nil?
+          computer.keyboard.press(Timeline.keyboard_key(name))
+        else
+          joystick(computer, name).press(direction)
+        end
+        hold(event)
+      end
+
+      def freeze(computer, event)
+        computer.press_cartridge_button
+        hold(event)
+      end
+
+      def hold(event)
+        @releases << Options::Event.new(event.frame + Options::Event::HOLD, event.action, event.argument)
+      end
+
+      def release(computer, event)
+        return computer.release_cartridge_button if event.action == "freeze"
+
+        name = event.argument
+        direction = Timeline.joystick_direction(name)
+        if direction.nil?
+          computer.keyboard.release(Timeline.keyboard_key(name))
+        else
+          joystick(computer, name).release(direction)
+        end
+      end
+
+      def joystick(computer, name) = name.start_with?("joy1-") ? computer.joystick1 : computer.joystick2
+
+      def insert(computer, path)
+        puts Media.attach(computer, path, autostart: false, disk: { read_only: @read_only })
+      rescue StandardError => e
+        warn "#{@program}: #{path}: #{e.message}"
+        @failed = true
+      end
+
+      def eject(computer, what)
+        return puts "No #{what} to eject" unless inserted?(computer, what)
+
+        if what == "disk"
+          eject_disk(computer)
+        elsif what == "tape"
+          computer.datasette.eject
+        else
+          computer.address_bus.detach_cartridge
+          computer.power_cycle!
+        end
+        puts "Ejected the #{what}"
+      end
+
+      def inserted?(computer, what)
+        return !computer.datasette.tape.nil? if what == "tape"
+        return !computer.address_bus.cartridge.nil? if what == "cartridge"
+
+        drive = Media::TrueDrive.drive(computer)
+        drive.nil? ? computer.mounted? : !drive.disk.nil?
+      end
+
+      def eject_disk(computer)
+        drive = Media::TrueDrive.drive(computer)
+        if drive.nil?
+          computer.unmount
+        else
+          drive.insert(nil)
+        end
+      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

data/lib/badline/frontend.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "badline/sdl"
+require "badline/frontend/boot"
+require "badline/frontend/frame_rate"
+require "badline/frontend/screen"
+require "badline/frontend/drive_led"
+require "badline/frontend/keys"
+require "badline/frontend/snapshots"
+require "badline/frontend/screenshot"
+require "badline/frontend/timeline"
+require "badline/frontend/sound"
+require "badline/frontend/pacer"
+require "badline/frontend/controls"
+require "badline/frontend/pad_port"
+require "badline/frontend/gamepads"
+require "badline/frontend/app"
+require "badline/frontend/audio_sink"
+require "badline/frontend/painter"
+require "badline/frontend/sid_history"
+require "badline/frontend/sid_view"
+require "badline/frontend/filter_view"
+require "badline/frontend/scope"
+require "badline/frontend/visualizer_view"
+require "badline/frontend/buttons"
+require "badline/frontend/player_state"
+require "badline/frontend/player_header"
+require "badline/frontend/player_footer"
+require "badline/frontend/info_view"
+require "badline/frontend/player_commands"
+require "badline/frontend/player_screen"
+require "badline/frontend/player_window"