badline 0.6.1 → 0.8.0

data/lib/badline/audio/queued_tune.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # A .sid tune in the player's Media::Queue, read only once the queue or
+    # the player first asks about it, so a queue of a whole collection
+    # starts at once. Its subtunes, SID model and lengths follow the options:
+    # --subtune picks the subtune to start on, --sid the model and --seconds the
+    # length, and without them the tune's own header and HVSC's database
+    # decide.
+    #
+    # A file that won't read as a tune, or lacks the subtune asked for, gets
+    # an #error and a single subtune.
+    class QueuedTune < Media::Queue::Entry
+      def initialize(path, options, subtune: nil)
+        super(path)
+        @options = options
+        @subtune = subtune
+        @tune = nil
+        @read = false
+        @error = ""
+        @lengths = nil
+        @lengths_read = false
+      end
+
+      def part
+        read
+        @part
+      end
+
+      def parts
+        read
+        @parts
+      end
+
+      # Why the tune can't play, or "" when it can.
+      def error
+        read
+        @error
+      end
+
+      def tune = @tune ||= Storage::SIDFile.new(path)
+
+      # Lets go of the tune's data, which #tune reads again if asked.
+      def release = @tune = nil
+
+      # Each SID's model, SID 1's first: the one --sid names for all of
+      # them, or each one's own.
+      def sid_models
+        forced = @options.sid_model
+        forced ? Array.new(tune.sids, forced) : tune.sid_models
+      end
+
+      def model_name = sid_models.map { |model| model.to_s.delete_prefix("mos") }.join(" + ")
+
+      def length(subtune) = @options.seconds || songlengths&.at(subtune - 1) || @options.fallback_seconds
+
+      # How long the subtune may stay silent before it ends, or nil when its
+      # length is known rather than the fallback.
+      def silence(subtune) = @options.seconds || songlengths&.at(subtune - 1) ? nil : @options.silence_seconds
+
+      # The header's name, author and release, those it fills in.
+      def header = [tune.name, tune.author, tune.released].reject(&:empty?)
+
+      private
+
+      def read
+        return if @read
+
+        @read = true
+        @parts = tune.subtunes
+        @part = @subtune || tune.start_subtune
+        @error = "no subtune #{@part}: the tune has #{@parts}" if @part > @parts
+      rescue Storage::SIDFile::FormatError => e
+        @error = e.message
+      end
+
+      # HVSC's database is keyed by the tune's MD5 and lists one length per
+      # subtune.
+      def songlengths
+        return @lengths if @lengths_read
+
+        @lengths_read = true
+        database = @options.songlengths || Storage::SongLengths.locate(path)
+        @lengths = database && Storage::SongLengths.new(database).lengths(tune.md5)
+      end
+    end
+  end
+end

data/lib/badline/audio/renderer.rb

@@ -3,40 +3,70 @@
 module Badline
   module Audio
     # Renders a .sid tune to a PCM file, or streams its samples to whoever
-    # plays them. A PSID tune with a play address runs on the bare rig;
-    # anything else drives its own interrupts and needs the whole machine.
+    # plays them, in stereo with the left and right interleaved (Stereo).
+    # A PSID tune with a play address runs on the bare rig; anything else
+    # drives its own interrupts and needs the whole machine.
     #
     # A .sid file carries no length, so the caller says how many seconds to
-    # render.
+    # render. For a tune whose length is a guess, #silence= also ends it
+    # once the output has held still for that many seconds.
     class Renderer
       class UnknownFormatError < StandardError; end
 
       DEFAULT_RATE = 44_100
 
+      # How far a sample may stray from where the output settled and still
+      # count as silence. A 6581 settles at a DC offset rather than at zero.
+      QUIET = 16
+
       CONTAINERS = { ".wav" => WAV, ".aiff" => AIFF, ".aif" => AIFF }.freeze
 
       # The cycles the SID's filter integrates at a time; 1 renders the
       # filter cycle by cycle, exactly.
       attr_writer :filter_chunk
 
-      def initialize(tune, seconds:, song: nil, rate: DEFAULT_RATE, sid_model: tune.sid_model)
+      # The seconds rendered so far, short of the length once the tune has
+      # fallen silent.
+      attr_reader :rendered, :tune, :rate
+
+      # Hears each frame's samples and the seconds rendered by its end, as
+      # they are rendered.
+      attr_writer :observer
+
+      # Where #stream starts: the frames before it are rendered as fast as
+      # they go and yielded without their samples, so the seconds rendered
+      # still count up to it. Set while streaming, it skips ahead from the
+      # frame rendered last.
+      attr_writer :from
+
+      def initialize(tune, seconds:, subtune: nil, rate: DEFAULT_RATE, sid_models: tune.sid_models)
         @tune = tune
         @seconds = seconds
-        @song = song
+        @subtune = subtune
         @rate = rate
-        @sid_model = sid_model
+        @sid_models = sid_models
         @filter_chunk = SID::FILTER_CHUNK
+        @silent_samples = 0
+        @level = 0
+        @still = 0
+        @rendered = 0.0
+        @observer = ->(_samples, _rendered) {}
+        @from = 0.0
+      end
+
+      def silence=(seconds)
+        @silent_samples = (seconds * @rate).round
       end
 
       def player
-        @player ||= (bare? ? BarePlayer : MachinePlayer).new(@tune, song: @song, sid_model: @sid_model)
+        @player ||= (bare? ? BarePlayer : MachinePlayer).new(@tune, subtune: @subtune, sid_models: @sid_models)
       end
 
       # Yields the seconds rendered so far after every frame.
       def render(path)
         container = container_for(path)
         player.start
-        container.open(path, rate: @rate) do |writer|
+        container.open(path, rate: @rate, channels: 2) do |writer|
           each_frame do |samples, seconds|
             samples.each { |sample| writer << sample }
             yield seconds if block_given?
@@ -71,14 +101,31 @@ module Badline
       end
 
       def each_frame
-        player.sid.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
+        player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
         total = total_cycles
         remaining = total
         while remaining.positive?
           samples = []
           remaining -= player.frame(remaining) { |sample| samples << sample }
-          yield samples, (total - remaining).fdiv(player.clock_hz)
+          @rendered = (total - remaining).fdiv(player.clock_hz)
+          @observer.call(samples, @rendered)
+          yield(@rendered < @from ? [] : samples, @rendered)
+          break if fallen_silent?(samples)
+        end
+      end
+
+      # Counts the samples since the output last strayed more than QUIET
+      # from where it settled.
+      def fallen_silent?(samples)
+        return false if @silent_samples.zero? || samples.empty?
+
+        if samples.max - @level > QUIET || @level - samples.min > QUIET
+          @level = samples.last
+          @still = 0
+        else
+          @still += samples.length / 2
         end
+        @still >= @silent_samples
       end
     end
   end

data/lib/badline/audio/stereo.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # The SIDs a tune plays on, the bus's own first and the extra ones at
+    # the addresses the tune's header gives, each on its own model. Their
+    # output mixes to interleaved stereo: SID 1 on the left, SID 2 on the
+    # right and SID 3 in the centre, at half on each side. A tune on one SID
+    # plays the same on both channels.
+    class Stereo
+      # The SIDs, in the order the header numbers them.
+      attr_reader :sids
+
+      # Each SID's own samples, as the last #mix drained them.
+      attr_reader :outputs
+
+      def initialize(bus, tune, models)
+        @sids = [bus.sid]
+        @extras = []
+        tune.sid_addresses.each do |address|
+          sid = SID.new(model: models[@sids.size], at: address)
+          bus.add_sid(sid)
+          @sids << sid
+          @extras << sid
+        end
+        @fitted = models
+        @outputs = []
+      end
+
+      # The SIDs past the bus's own, which the player clocks itself.
+      attr_reader :extras
+
+      def synthesize! = @sids.each(&:synthesize!)
+
+      # The model each SID plays on.
+      def models = @sids.map(&:model)
+
+      # Puts every SID on `model`, or with :auto each back on the one it was
+      # fitted with.
+      def refit(model)
+        @sids.size.times do |index|
+          wanted = model == :auto ? @fitted[index] : model
+          sid = @sids[index]
+          sid.model = wanted unless sid.model == wanted
+        end
+      end
+
+      def record(rate:, filter_chunk:, clock_hz:)
+        @sids.each { |sid| sid.record(rate:, filter_chunk:, clock_hz:) }
+      end
+
+      # Drains every SID and yields the left and the right of each sample
+      # in turn.
+      def mix(&)
+        outputs = @outputs
+        outputs.clear
+        @sids.each { |sid| outputs << sid.drain_samples }
+        case outputs.size
+        when 1 then both(outputs[0], &)
+        when 2 then pair(outputs[0], outputs[1], &)
+        else centred(outputs[0], outputs[1], outputs[2], &)
+        end
+      end
+
+      private
+
+      def both(samples)
+        i = 0
+        while i < samples.size
+          yield samples[i]
+          yield samples[i]
+          i += 1
+        end
+      end
+
+      def pair(left, right)
+        count = [left.size, right.size].min
+        i = 0
+        while i < count
+          yield left[i]
+          yield right[i]
+          i += 1
+        end
+      end
+
+      def centred(left, right, centre)
+        count = [left.size, right.size, centre.size].min
+        i = 0
+        while i < count
+          yield ((2 * left[i]) + centre[i]) / 3
+          yield ((2 * right[i]) + centre[i]) / 3
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/badline/audio/terminal.rb

@@ -10,9 +10,13 @@ module Badline
     # stty and poll(2) for the native badline.
     class Terminal
       KEYS = {
-        "n" => :next, "\e[C" => :next,
-        "p" => :previous, "\e[D" => :previous,
+        "n" => :next, "p" => :previous,
+        "\e[C" => :next_subtune, "\e[D" => :previous_subtune,
         " " => :pause,
+        "s" => :shuffle,
+        "l" => :loop,
+        "a" => :all_subtunes,
+        "," => :back, "." => :forward,
         "q" => :quit
       }.freeze
 
@@ -20,6 +24,8 @@ module Badline
         @input = input
         @output = output
         @closed = false
+        @tune = 1
+        @tunes = 1
       end
 
       # Raw input and a hidden cursor for the length of the block.
@@ -46,12 +52,39 @@ module Badline
 
       def header(lines)
         lines.each { |line| @output.print "#{line}\r\n" }
-        @output.print "n/→ next  p/← previous  space pause  q quit\r\n"
+        @output.print "←/→ subtune  n/p tune  ,/. seek  space pause  s shuffle  l loop  a all subtunes  q quit\r\n"
       end
 
-      def status(song:, songs:, elapsed:, length:, notes: [])
-        line = format("song %<song>d/%<songs>d  %<elapsed>s / %<length>s",
-                      song:, songs:, elapsed: clock(elapsed), length: clock(length))
+      # Prints lines above the status line, such as the next tune's header.
+      def announce(lines)
+        lines.each { |line| @output.print "\r\e[K#{line}\r\n" }
+      end
+
+      # The tune's place in the queue, which the status line shows once
+      # there is more than one.
+      def place(tune, tunes)
+        @tune = tune
+        @tunes = tunes
+      end
+
+      # Where :seek asks the subtune to play from, in seconds. Only a window
+      # asks for it, by a click on the time the subtune has played.
+      def seek_to = 0.0
+
+      # The files dropped on a window since it last said :drop.
+      def dropped = []
+
+      # Hears of the STIL fields for the tune and for the subtune starting,
+      # which the terminal prints as the CLI announces them.
+      def stil(fields, subtune, subtune_fields) = [fields, subtune, subtune_fields]
+
+      # Hears of each subtune's renderer as it starts playing.
+      def playing(renderer) = renderer
+
+      def status(subtune:, subtunes:, elapsed:, length:, notes: [])
+        line = format("subtune %<subtune>d/%<subtunes>d  %<elapsed>s / %<length>s",
+                      subtune:, subtunes:, elapsed: clock(elapsed), length: clock(length))
+        line = format("tune %<tune>d/%<tunes>d  %<line>s", tune: @tune, tunes: @tunes, line:) if @tunes > 1
         @output.print "\r\e[K#{([line] + notes).join('  ')}"
         @output.flush
       end

data/lib/badline/audio/wav.rb

@@ -10,7 +10,7 @@ module Badline
 
       def header
         ["RIFF", 0, "WAVE",
-         "fmt ", 16, 1, 1, rate, rate * 2, 2, 16,
+         "fmt ", 16, 1, channels, rate, rate * channels * 2, channels * 2, 16,
          "data", 0].pack("a4Va4a4VvvVVvva4V")
       end
 

data/lib/badline/audio.rb

@@ -3,10 +3,12 @@
 require "badline/audio/pcm_writer"
 require "badline/audio/wav"
 require "badline/audio/aiff"
+require "badline/audio/stereo"
 require "badline/audio/bare_player"
 require "badline/audio/machine_player"
 require "badline/audio/renderer"
 require "badline/audio/playback"
 require "badline/audio/terminal"
 require "badline/audio/jukebox"
+require "badline/audio/queued_tune"
 require "badline/audio/cli"

data/lib/badline/cartridge/freezer.rb

@@ -8,6 +8,8 @@ module Badline
     # cartridge ROM in Ultimax mode. The cartridge lets go of NMI when its
     # software acknowledges the freeze.
     module Freezer
+      def freezer? = true
+
       def press_button
         @button = true
         self.nmi = true if freeze_allowed?

data/lib/badline/cartridge.rb

@@ -179,6 +179,9 @@ module Badline
     # The RES line on the expansion port.
     def reset; end
 
+    # Whether the cartridge has a freeze button.
+    def freezer? = false
+
     # The freeze button, which cartridges without one ignore.
     def press_button; end
 

data/lib/badline/frontend/app.rb

@@ -7,8 +7,8 @@ module Badline
     # changed lines, present and wait. Pacer decides the cycles and the wait.
     class App
       SCALE = 2
+      DROPFILE = 0x1000
       TITLE = "Badline"
-      STAGES = %w[events emulate audio blit present wait].freeze
 
       # Takes the frame limit, the pacing, the snapshot path, the sound and
       # the verbosity from Options, and runs the timeline's events.
@@ -22,11 +22,11 @@ module Badline
         @screen = Screen.new(computer.vic)
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
-        @spent = Array.new(STAGES.size, 0.0)
-        @slowest = 0.0
         open_window
         @sound = Sound.new(computer.sid, options.sound?, @verbose)
         @gamepads = Gamepads.new(computer, @verbose)
+        @frame_report = FrameReport.new(@sound)
+        @menu = PauseMenu.new(Painter.new(@renderer), options)
       end
 
       def run
@@ -34,8 +34,7 @@ module Badline
         @running = true
         @started = @reported = now
         @pacer.start(@started)
-        @reported_samples = 0
-        frame while @running
+        @menu.open? ? paused_frame : frame while @running
         @snapshots.finish
         @computer.drive1541&.flush
         @gamepads.close
@@ -64,9 +63,7 @@ module Badline
       end
 
       def finish_frame(stamps)
-        STAGES.size.times { |stage| @spent[stage] += stamps[stage + 1] - stamps[stage] }
-        took = stamps[-2] - stamps.first
-        @slowest = took if took > @slowest
+        @frame_report.add(stamps) if @verbose
         @frames += 1
         @timeline.run(@computer, @frames)
         @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
@@ -95,8 +92,6 @@ module Badline
         @texture = SDL.SDL_CreateTexture(
           @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, Screen::WIDTH, Screen::HEIGHT
         )
-        SDL.rect_w(SDL.rect, Screen::WIDTH)
-        SDL.rect_h(SDL.rect, Screen::HEIGHT)
       end
 
       def close_window
@@ -107,7 +102,7 @@ module Badline
       end
 
       def handle_events
-        handle_event(SDL.event_type(SDL.event)) while SDL.SDL_PollEvent(SDL.event) != 0
+        handle_event(SDL.event_type(SDL.event)) while !@menu.open? && SDL.SDL_PollEvent(SDL.event) != 0
       end
 
       def handle_event(type)
@@ -122,6 +117,7 @@ module Badline
           @controls.mouse_button(SDL.event_button(SDL.event), type == SDL::MOUSEBUTTONDOWN)
         when SDL::CONTROLLERDEVICEADDED, SDL::CONTROLLERDEVICEREMOVED
           @gamepads.rescan
+        when DROPFILE then resume(false) unless @menu.drop(@computer, @controls, @sound)
         end
       end
 
@@ -145,20 +141,45 @@ module Badline
         @controls.computer = computer
         @gamepads.computer = computer
         @sound.sid = computer.sid
+        @snapshots.computer = computer
       end
 
       def handle_toggle(scancode)
         if scancode == Keys::TAB
-          @controls.cycle_mode(SDL.event_mod(SDL.event).anybits?(SDL::KMOD_SHIFT) ? -1 : 1)
-          SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
+          @controls.toggle_keys
         elsif scancode == Keys::F9
-          @controls.swap_ports
+          return open_menu
         else
           @sound.toggle_mute
         end
         update_title
       end
 
+      def open_menu = @menu.show(@computer, @controls, @sound)
+
+      # Closes the menu and runs the machine on from where it stood,
+      # pressing the cartridge's freeze button if asked.
+      def resume(freeze)
+        @menu.close
+        SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
+        @timeline.press_freeze(@computer, @frames) if freeze
+        @reported = now
+        @pacer.start(@reported)
+        update_title
+      end
+
+      # Runs a frame of the menu, which has the keys and the mouse while the
+      # machine stands still.
+      def paused_frame
+        action = @menu.frame(@renderer, @texture, @controls)
+        if action == :quit
+          @running = false
+        elsif !action.nil?
+          swap(@menu.computer) if action == :swap
+          resume(action == :freeze)
+        end
+      end
+
       def update_title
         title = TITLE
         title += " [#{@controls.tag}]" unless @controls.tag.empty?
@@ -183,12 +204,12 @@ module Badline
 
       def upload
         @screen.update
-        SDL.SDL_UpdateTexture(@texture, SDL.rect, @screen.pixels, Screen::ROW_BYTES)
+        SDL.SDL_UpdateTexture(@texture, nil, @screen.pixels, Screen::ROW_BYTES)
       end
 
       def draw
         SDL.SDL_RenderClear(@renderer)
-        SDL.SDL_RenderCopy(@renderer, @texture, SDL.rect, SDL.rect)
+        SDL.SDL_RenderCopy(@renderer, @texture, nil, nil)
         @led&.draw(@renderer)
         @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(@renderer, path) }
         SDL.SDL_RenderPresent(@renderer)
@@ -197,28 +218,10 @@ module Badline
       def report(at)
         @pacer.check(50, at - @reported, at)
         @pacer.measure(50, at - @reported)
-        report_frames(at) if @verbose
-        @spent = Array.new(STAGES.size, 0.0)
-        @slowest = 0.0
+        @frame_report.show(at - @reported) if @verbose
         @reported = at
       end
 
-      def report_frames(at)
-        fps = 50 / (at - @reported)
-        stages = STAGES.each_with_index.map { |name, stage| "#{name} #{(@spent[stage] * 20).round(2)}" }
-        puts "#{fps.round(1)} fps, per frame ms: #{stages.join(' ')}, slowest work #{(@slowest * 1000).round(2)}"
-        report_sound(at) if @sound.on?
-      end
-
-      def report_sound(at)
-        sound = @sound
-        rate = (sound.queued - @reported_samples) / (at - @reported)
-        queue = sound.high.zero? ? "empty" : "#{(sound.low * 1000).round(1)}-#{(sound.high * 1000).round(1)} ms"
-        puts "  sound #{rate.round} samples/s, queue #{queue}, #{sound.underruns} underruns, #{sound.dropped} dropped"
-        sound.reset_levels
-        @reported_samples = sound.queued
-      end
-
       def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end

data/lib/badline/frontend/audio_sink.rb

@@ -2,9 +2,10 @@
 
 module Badline
   module Frontend
-    # The host's audio device for --headless, fed through SDL's queue: mono
-    # signed 16-bit samples go in at the device's rate and SDL plays them
-    # out behind us. It answers what Audio::Playback asks of a sink.
+    # The host's audio device for --headless and the SID player, fed through
+    # SDL's queue: stereo signed 16-bit samples, the left and right
+    # interleaved, go in at the device's rate and SDL plays them out behind
+    # us. It answers what Audio::Playback asks of a sink.
     class AudioSink
       class Error < Audio::Playback::DeviceError; end
 
@@ -33,7 +34,7 @@ module Badline
         check(SDL.SDL_QueueAudio(@device, buffer, bytes))
       end
 
-      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
+      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (4.0 * @rate)
 
       def start = SDL.SDL_PauseAudioDevice(@device, 0)
 
@@ -54,7 +55,7 @@ module Badline
       def open_device(rate, allowed_changes, buffer)
         SDL.spec_freq(SDL.wanted, rate)
         SDL.spec_format(SDL.wanted, SDL::AUDIO_S16LSB)
-        SDL.spec_channels(SDL.wanted, 1)
+        SDL.spec_channels(SDL.wanted, 2)
         SDL.spec_samples(SDL.wanted, buffer)
         @device = SDL.SDL_OpenAudioDevice(nil, 0, SDL.wanted, SDL.obtained, allowed_changes)
         raise Error, SDL.SDL_GetError if @device.zero?

data/lib/badline/frontend/boot.rb

@@ -39,12 +39,19 @@ module Badline
         return computer
       end
 
+      start(options, media, options.writable?)
+    end
+
+    # A new machine built from the options, with `media`, if not nil,
+    # attached and started as the command line does, its disk writable if
+    # `writable`.
+    def self.start(options, media, writable)
       computer = Computer.new(sid_model: options.sid_model || Media.sid_model(media), reu: options.reu,
                               region: options.ntsc? ? Region::NTSC : Region::PAL)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
-        puts Media.attach(computer, media, autostart: options.autostart?, song: options.song,
-                                           disk: { read_only: options.read_only? })
+        puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
+                                           disk: { read_only: !writable })
       end
       computer
     end