badline 0.6.1 → 0.8.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

@@ -10,7 +10,7 @@ module Badline
       KEYS = [Keys::F11, Keys::F12].freeze
 
       # The machine running, which F12 replaces with the restored one.
-      attr_reader :computer
+      attr_accessor :computer
 
       def initialize(computer, options)
         @computer = computer

data/lib/badline/frontend/sound.rb

@@ -145,7 +145,6 @@ module Badline
 
       def underrun!
         @underruns += 1
-        puts "Running below real time, so the sound will stutter." if @underruns == 1
         halt
       end
     end

data/lib/badline/frontend/timeline.rb

@@ -15,7 +15,7 @@ module Badline
         unless options.screenshot.empty? || options.frames.zero?
           @events += [Options::Event.new(options.frames, "screenshot", options.screenshot)]
         end
-        @read_only = options.read_only?
+        @read_only = !options.writable?
         @program = options.program
         @releases = []
         @failed = false
@@ -63,6 +63,10 @@ module Badline
                .map { |event| Timeline.path(event.argument, frame) }
       end
 
+      # Presses the freeze button after `frame`, and lets go of it as the
+      # events do.
+      def press_freeze(computer, frame) = freeze(computer, Options::Event.new(frame, "freeze", ""))
+
       # 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" }
 

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

@@ -11,8 +11,29 @@ require "badline/frontend/screenshot"
 require "badline/frontend/timeline"
 require "badline/frontend/sound"
 require "badline/frontend/pacer"
+require "badline/frontend/frame_report"
 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"
+require "badline/frontend/pause_menu"
+require "badline/frontend/file_browser"
+require "badline/frontend/confirmation"
+require "badline/frontend/menu_dialogs"
+require "badline/frontend/menu_media"
+require "badline/frontend/menu_pages"

data/lib/badline/media/disk_set.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # The disks of a set a disk image belongs to, found by name in its
+    # folder: images whose names differ only in their disk, side or part
+    # markers, such as "Disk 1", "Side B", "d2", "(Disk 1 of 3)", ordered
+    # by those markers. A name with no marker can end in a number or a
+    # letter, as in game_1.d64 and game_2.d64, which counts only when the
+    # folder has the first of the set too.
+    module DiskSet
+      KINDS = %w[disk disc side part].freeze
+      EXTENSIONS = %w[.d64 .d71 .d81 .g64].freeze
+
+      # The paths of the set's disks in order, or just `path` when it
+      # belongs to none.
+      def self.around(path)
+        extension = File.extname(path).downcase
+        return [path] unless EXTENSIONS.include?(extension)
+
+        marked = !parse(stem(path))[1].negative?
+        base = key(stem(path), marked)[0]
+        found = siblings(File.dirname(path), extension, base, marked)
+        return [path] if found.size < 2 || (!marked && found.none? { |pair| pair[0] == 1 })
+
+        found.sort_by { |pair| pair[0] }.map { |pair| File.join(File.dirname(path), pair[1]) }
+      end
+
+      # The name's words without their markers, joined, and the order the
+      # markers give it, -1 for none.
+      def self.parse(stem)
+        words = words(stem)
+        base = []
+        values = []
+        index = 0
+        index = take(words, index, base, values) while index < words.size
+        [base.join(" "), order(values)]
+      end
+
+      # The words before a trailing number or letter, joined, and its
+      # order, -1 for a name that doesn't end in one.
+      def self.trailing(stem)
+        words = words(stem)
+        last = words.last.to_s
+        return ["", -1] if words.size < 2 || !value?(last) || last.length > 2
+
+        [words[0, words.size - 1].join(" "), value(last)]
+      end
+
+      def self.words(stem) = stem.downcase.split(/[^a-z0-9]+/).reject(&:empty?)
+
+      def self.stem(path) = File.basename(path, File.extname(path))
+
+      def self.key(stem, marked) = marked ? parse(stem) : trailing(stem)
+
+      # The order and name of each image in the folder in the set.
+      def self.siblings(directory, extension, base, marked)
+        found = []
+        children(directory).each do |name|
+          next unless File.extname(name).downcase == extension
+
+          name_key = key(stem(name), marked)
+          found << [name_key[1], name] if name_key[0] == base && !name_key[1].negative?
+        end
+        found
+      end
+
+      # Adds the word at `index` to the base, or its marker's value to the
+      # values, and returns the index of the next word.
+      def self.take(words, index, base, values)
+        word = words[index]
+        following = words[index + 1].to_s
+        if KINDS.include?(word) && value?(following)
+          values << value(following)
+          index += 2
+          index += 2 if words[index] == "of" && words[index + 1].to_s.match?(/\A\d+\z/)
+          index
+        elsif marker?(word)
+          values << value(word.sub(/\A(disk|disc|side|part|d|s)/, ""))
+          index + 1
+        else
+          base << word
+          index + 1
+        end
+      end
+
+      def self.marker?(word) = word.match?(/\A(disk|disc|side|part)(\d+|[a-z])\z/) || word.match?(/\A[ds]\d+\z/)
+
+      def self.value?(word) = word.match?(/\A(\d+|[a-z])\z/)
+
+      # A number counts as itself and a letter by its place in the
+      # alphabet, so side A is 1.
+      def self.value(word) = word.match?(/\A\d+\z/) ? word.to_i : word.ord - 96
+
+      def self.order(values)
+        return -1 if values.empty?
+
+        values.reduce(0) { |order, value| (order * 1000) + value }
+      end
+
+      def self.children(directory)
+        Dir.children(directory)
+      rescue SystemCallError
+        []
+      end
+    end
+  end
+end

data/lib/badline/media/queue.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # An ordered list of media files to go through one at a time, such as
+    # the tunes of a player. Each entry is a file and the part of it to
+    # start on, counting from 1, out of the parts the file holds: a .sid
+    # tune's subtunes, say, or 1 of 1 for media with no parts.
+    #
+    # #next_entry and #previous_entry step through the entries, and
+    # #next_part and #previous_part through the current entry's parts,
+    # stopping at its ends. Each returns the entry it moved to, or nil
+    # where it stays put. With #loop? the entry steps wrap around at
+    # either end, and with #shuffle? they follow a shuffled order that
+    # starts from the current entry. #all_parts? decides where #advance
+    # goes once a part has played out: on through the entry's parts, or
+    # to the next entry. An entry stepped to starts on its first part
+    # with #all_parts?, otherwise on its own.
+    #
+    # `shuffle`, if given, returns the entry indices it's given in a new
+    # order in place of Array#shuffle. `build`, if given, turns the paths
+    # #add is given into entries.
+    class Queue
+      # A file and the part of it to start on.
+      class Entry
+        attr_reader :path, :part, :parts
+
+        def initialize(path, part: 1, parts: 1)
+          @path = path
+          @part = part
+          @parts = parts
+        end
+      end
+
+      attr_reader :part
+
+      # The files `paths` name, in order: a file as given, and a directory
+      # as every file below it with the extension, in path order.
+      def self.files(paths, extension)
+        paths.flat_map { |path| File.directory?(path) ? below(path, extension).sort : [path] }
+      end
+
+      def self.below(directory, extension)
+        paths = []
+        Dir.children(directory).each do |name|
+          path = File.join(directory, name)
+          if File.directory?(path)
+            paths.concat(below(path, extension))
+          elsif File.extname(name).casecmp?(extension)
+            paths << path
+          end
+        end
+        paths
+      end
+      private_class_method :below
+
+      def initialize(entries, all_parts: false, shuffle: nil, build: nil)
+        @entries = entries
+        @shuffler = shuffle
+        @builder = build
+        @order = (0...entries.size).to_a
+        @position = 0
+        @part = entries.empty? ? 0 : entries.first.part
+        @all_parts = all_parts
+        @shuffle = false
+        @loop = false
+      end
+
+      def size = @entries.size
+
+      def empty? = @entries.empty?
+
+      # Where the current entry stands in the order played, from 1.
+      def position = empty? ? 0 : @position + 1
+
+      def entry = empty? ? nil : @entries[@order[@position]]
+
+      def all_parts? = @all_parts
+
+      def shuffle? = @shuffle
+
+      def loop? = @loop
+
+      # Puts the entries `build` makes of the paths at the end of the order,
+      # shuffled or not. An empty queue starts on the first of them.
+      def add(paths)
+        return if @builder.nil?
+
+        started = empty?
+        first = @entries.size
+        @entries.concat(@builder.call(paths))
+        @order.concat((first...@entries.size).to_a)
+        @part = entry.part if started && !empty?
+      end
+
+      def toggle_all_parts = @all_parts = !@all_parts
+
+      def toggle_loop = @loop = !@loop
+
+      def toggle_shuffle
+        return @shuffle = !@shuffle if empty?
+
+        current = @order[@position]
+        @shuffle = !@shuffle
+        @order = (0...size).to_a
+        @order = [current] + shuffled(@order - [current]) if @shuffle
+        @position = @order.index(current)
+        @shuffle
+      end
+
+      def next_entry
+        return if empty?
+
+        move(@position + 1)
+      end
+
+      def previous_entry
+        return if empty?
+
+        move(@position - 1)
+      end
+
+      def next_part
+        return if empty? || @part >= entry.parts
+
+        @part += 1
+        entry
+      end
+
+      def previous_part
+        return if empty? || @part <= 1
+
+        @part -= 1
+        entry
+      end
+
+      # Where to go once the current part has played to its end: the
+      # entry's next part with #all_parts?, otherwise the next entry.
+      def advance
+        return next_part if @all_parts && !empty? && @part < entry.parts
+
+        next_entry
+      end
+
+      private
+
+      def move(position)
+        return unless position.between?(0, size - 1) || @loop
+
+        @position = position % size
+        @part = @all_parts ? 1 : entry.part
+        entry
+      end
+
+      def shuffled(indices) = @shuffler ? @shuffler.call(indices) : indices.shuffle
+    end
+  end
+end

data/lib/badline/media.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "badline/media/true_drive"
+require "badline/media/queue"
+require "badline/media/disk_set"
 
 module Badline
   module Media
@@ -25,7 +27,7 @@ module Badline
       # A .g64 plugs in a true drive as device 8 (TrueDrive), and with one
       # there, a .d64 goes into it instead of the KERNAL traps too. The
       # autostart then loads through it.
-      def attach(computer, path, autostart: true, song: nil, **options)
+      def attach(computer, path, autostart: true, subtune: nil, **options)
         if TrueDrive.takes?(computer, path)
           attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
         elsif File.directory?(path)
@@ -34,7 +36,7 @@ module Badline
         elsif File.extname(path).downcase == ".crt"
           attach_cartridge(computer, path, options.fetch(:cartridge, {}))
         elsif File.extname(path).downcase == ".sid"
-          attach_sid(computer, path, autostart:, song:)
+          attach_sid(computer, path, autostart:, subtune:)
         elsif File.extname(path).downcase == ".tap"
           attach_tape(computer, path, autostart:)
         elsif MOUNT_TYPES.key?(File.extname(path).downcase)
@@ -91,18 +93,22 @@ module Badline
         "Attached cartridge #{path}"
       end
 
-      def attach_sid(computer, path, autostart:, song:)
+      def attach_sid(computer, path, autostart:, subtune:)
         tune = Storage::SIDFile.new(path)
-        song = (song || tune.start_song).clamp(1, tune.songs)
-        computer.on_init { start_tune(computer, tune, autostart:, song:) }
+        if tune.sids > 1
+          raise Storage::SIDFile::FormatError, "Written for #{tune.sids} SIDs, which only the SID player plays"
+        end
+
+        subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes)
+        computer.on_init { start_tune(computer, tune, autostart:, subtune:) }
         title = tune.name.empty? ? path : tune.name
-        title += " (song #{song})" if tune.songs > 1
+        title += " (subtune #{subtune})" if tune.subtunes > 1
         autostart ? "Playing #{title}" : "Loaded #{title}"
       end
 
-      def start_tune(computer, tune, autostart:, song:)
+      def start_tune(computer, tune, autostart:, subtune:)
         computer.ram.write(tune.load_address, tune.data)
-        tune.boot_memory(song:).each { |address, bytes| computer.ram.write(address, bytes) }
+        tune.boot_memory(subtune:).each { |address, bytes| computer.ram.write(address, bytes) }
         computer.type_text(tune.boot_command) if autostart
       end