badline 0.6.0 → 0.7.0

data/exe/badline-ruby

@@ -26,39 +26,43 @@ RubyVM::YJIT.enable if options.jit? && jit_available
 
 require "badline"
 
+# Quiets IO::Buffer's experimental warning.
+Warning[:experimental] = false
+
+def load_sdl
+  require "badline/ffi"
+  require "badline/frontend"
+end
+
 if options.headless?
-  begin
-    Badline::Audio::CLI.new(options, sink: Badline::Audio::SDLSink.method(:new),
-                                     console: Badline::Audio::Console.method(:new)).run
-  rescue Badline::Audio::CLI::Error => e
-    warn "badline-ruby: #{e.message}"
-    exit 1
-  rescue Interrupt
-    exit 130
+  require "badline/audio/console"
+  console = if options.player_window?
+              lambda do |input:, output:|
+                load_sdl
+                Badline::Frontend::PlayerWindow.new(input:, output:)
+              end
+            else
+              Badline::Audio::Console.method(:new)
+            end
+  sink = lambda do |rate:, exact_rate:|
+    load_sdl
+    Badline::Frontend::AudioSink.new(rate:, exact_rate:)
+  rescue Badline::FFI::Error => e
+    raise Badline::Audio::Playback::DeviceError, e.message
   end
-  exit
+  exit Badline::Audio::CLI.run(options, sink:, console:)
 end
 
 begin
-  require "badline/gui"
-rescue Badline::SDL::Error => e
+  load_sdl
+rescue Badline::FFI::Error => e
   warn "badline-ruby: can't open the window: #{e.message}. " \
        "Install SDL2 with 'brew install sdl2' or 'apt install libsdl2-2.0-0'."
   exit 1
 end
 
 begin
-  application = Badline::GUI::Application.new(media_path: options.media_path, autostart: options.autostart?,
-                                              song: options.song, sound: options.sound?, verbose: options.verbose?,
-                                              machine: { sid_model: options.sid_model, reu: options.reu,
-                                                         true_drive: options.true_drive?, ntsc: options.ntsc? },
-                                              disk: { read_only: options.read_only? })
-rescue Badline::Media::TrueDrive::Error, Badline::Storage::SIDFile::FormatError, Badline::Storage::T64::FormatError,
-       Badline::Storage::TAP::FormatError, Badline::Storage::CRTFile::FormatError,
-       Badline::Storage::G64Image::FormatError, Badline::Cartridge::UnsupportedTypeError,
-       Badline::Snapshot::FormatError => e
-  warn "badline-ruby: #{options.media_path}: #{e.message}"
-  exit 1
+  exit Badline::Frontend.run(options)
+rescue Interrupt
+  exit 130
 end
-
-application.run

data/lib/badline/address_bus/extra_sids.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Badline
+  class AddressBus
+    # The second and third SIDs the SID player fits for a tune written for
+    # them, each over its 32 bytes of the I/O area (SIDSlots). The SID
+    # player's machine has nothing else in I/O 1 and 2, so the rest of a
+    # page there reads the open bus.
+    module ExtraSIDs
+      # Fits a SID at the address it was built at, where it takes its 32
+      # bytes over from whatever maps there.
+      def add_sid(sid)
+        page = sid.start >> 8
+        slots = @sid_slots.find { |candidate| candidate.page == page }
+        if slots.nil?
+          slots = SIDSlots.new(page, @sid, @open_bus)
+          @sid_slots << slots
+        end
+        slots.place(sid)
+        update_overlays!
+      end
+
+      private
+
+      def map_extra_sids
+        @sid_slots.each { |slots| @read_pages[slots.page] = @write_pages[slots.page] = slots }
+      end
+    end
+  end
+end

data/lib/badline/address_bus/sid_slots.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  class AddressBus
+    # Stands in for a page of I/O that a second or third SID shares: each 32
+    # bytes of it go to the SID placed there, or else to the first SID's
+    # mirrors in `$d400-$d7ff`, and to the open bus in I/O 1 and 2.
+    class SIDSlots
+      attr_reader :page
+
+      def initialize(page, first, open_bus)
+        @page = page
+        @io = page >= 0xde
+        @first = first
+        @open_bus = open_bus
+        @sids = []
+        @slots = Array.new(8, -1)
+      end
+
+      def place(sid)
+        @slots[(sid.start >> 5) & 7] = @sids.size
+        @sids << sid
+      end
+
+      def peek(addr)
+        index = @slots[(addr >> 5) & 7]
+        return @sids[index].peek(addr) unless index.negative?
+
+        @io ? @open_bus.peek(addr) : @first.peek(addr)
+      end
+
+      def poke(addr, value)
+        index = @slots[(addr >> 5) & 7]
+        if !index.negative?
+          @sids[index].poke(addr, value)
+        elsif !@io
+          @first.poke(addr, value)
+        end
+      end
+    end
+  end
+end

data/lib/badline/address_bus.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "badline/address_bus/saved_state"
+require "badline/address_bus/sid_slots"
+require "badline/address_bus/extra_sids"
 require "badline/address_bus/ultimax_pages"
 
 module Badline
@@ -32,6 +34,7 @@ module Badline
   class AddressBus
     include Addressable
     include UltimaxPages
+    include ExtraSIDs
 
     # I/O 1 and 2, and the Ultimax holes, with nothing on the bus. A read
     # picks up the byte the VIC fetched in the preceding phi1 half-cycle,
@@ -82,6 +85,7 @@ module Badline
       @control_ports.port_a_source = @cia1
       @cia1.on_port_b4_change { |high| @vic.lightpen_level(high) }
       @sid = SID.new(model: sid_model, pots: @control_ports)
+      @sid_slots = []
 
       @datasette = Datasette.new
       @datasette.on_flag { @cia1.flag! }
@@ -89,6 +93,7 @@ module Badline
 
       @color_ram = ColorMemory.new(@vic)
       @open_bus = OpenBus.new(@vic)
+      @cpu_off_bus = false
 
       @port_ddr = 0x00
       @port_out = 0x00
@@ -154,11 +159,19 @@ module Badline
         @ram.poke(addr, @vic.phi1_data)
         addr.zero? ? @port_ddr = value : @port_out = value
         update_port!
-      else
+      elsif !@cpu_off_bus
         @write_pages[addr >> 8].poke(addr, value)
       end
     end
 
+    # Runs a CPU cycle with the CPU off the bus, as an REU's /DMA line
+    # holds it: a write it makes reaches nothing but its own port.
+    def cycle_cpu_off_bus(cpu)
+      @cpu_off_bus = true
+      cpu.cycle!
+      @cpu_off_bus = false
+    end
+
     def inspect
       "#<#{self.class.name} port=#{format('0x%02x', @io_port.value)} " \
         "cartridge=#{@cartridge ? @cartridge.class.name : 'none'} " \
@@ -243,6 +256,7 @@ module Badline
       @read_pages[0xd7] = @write_pages[0xd7] = @debug_register if @debug_register
       @read_pages[0xdf] = @write_pages[0xdf] = @reu if @reu
       map_cartridge_io if @cartridge
+      map_extra_sids unless @sid_slots.empty?
     end
 
     def map_cartridge_io

data/lib/badline/audio/aiff.rb

@@ -13,14 +13,14 @@ module Badline
 
       def header
         ["FORM", 0, "AIFF",
-         "COMM", 18, 1, 0, 16].pack("a4Na4a4NnNn") +
+         "COMM", 18, channels, 0, 16].pack("a4Na4a4NnNn") +
           extended(rate) +
           ["SSND", 0, 0, 0].pack("a4NNN")
       end
 
       def patch
         write_at(4, [46 + data_size].pack("N"))
-        write_at(22, [samples].pack("N"))
+        write_at(22, [frames].pack("N"))
         write_at(42, [8 + data_size].pack("N"))
       end
 

data/lib/badline/audio/bare_player.rb

@@ -44,12 +44,12 @@ module Badline
       # The KERNAL's PAL/NTSC flag, 1 for PAL.
       VIDEO_STANDARD = 0x02a6
 
-      attr_reader :sid
+      attr_reader :sid, :stereo
 
-      def initialize(tune, song: nil, sid_model: tune.sid_model)
+      def initialize(tune, subtune: nil, sid_models: tune.sid_models)
         @tune = tune
-        @song = (song || tune.start_song).clamp(1, tune.songs) - 1
-        @bus = AddressBus.new(sid_model:)
+        @subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes) - 1
+        @bus = AddressBus.new(sid_model: sid_models[0])
         # The CPU port as the KERNAL leaves it, which a PSID tune expects.
         @bus.poke(0x00, 0x2f)
         @bus.poke(0x01, 0x37)
@@ -57,28 +57,38 @@ module Badline
         @bus.cia1.timer_a_latch = tune.ntsc? ? NTSC_KERNAL_TIMER : KERNAL_TIMER
         @cpu = CPU.new(@bus)
         @sid = @bus.sid
+        @stereo = Stereo.new(@bus, tune, sid_models)
+        @extras = @stereo.extras
+        @multi = !@extras.empty?
         @idle = false
       end
 
       def start
         @bus.ram.write(@tune.load_address, @tune.data)
         @bus.ram.write(stub_address, stub)
-        @sid.synthesize!
+        @stereo.synthesize!
         @cpu.status.interrupt = true
         @cpu.program_counter = idle_address
         install_dispatch
-        call(@tune.init_address, @song)
+        call(@tune.init_address, @subtune)
         settle
       end
 
       # Advances one call of play, or `budget` cycles if that is shorter,
-      # then yields whatever the SID recorded over it. Returns the cycles
-      # advanced.
+      # then yields whatever the SIDs recorded over it, in stereo. Returns
+      # the cycles advanced.
       def frame(budget, &)
         call(@tune.play_address)
         cycles = [budget, period].min
-        cycles.times { step }
-        @sid.drain_samples.each(&)
+        if @multi
+          cycles.times { step }
+        else
+          cycles.times do
+            @sid.cycle!
+            @cpu.cycle!
+          end
+        end
+        @stereo.mix(&)
         cycles
       end
 
@@ -86,10 +96,10 @@ module Badline
 
       private
 
-      # A video frame, or for a CIA-timed song one period of CIA 1 timer A,
+      # A video frame, or for a CIA-timed subtune one period of CIA 1 timer A,
       # which init and play are both free to reprogram.
       def period
-        return (@tune.ntsc? ? NTSC_FRAME_CYCLES : FRAME_CYCLES) unless @tune.cia_timed?(@song + 1)
+        return (@tune.ntsc? ? NTSC_FRAME_CYCLES : FRAME_CYCLES) unless @tune.cia_timed?(@subtune + 1)
 
         @bus.cia1.timer_a_latch + 1
       end
@@ -117,6 +127,7 @@ module Badline
 
       def step
         @sid.cycle!
+        @extras.each(&:cycle!) if @multi
         @cpu.cycle!
       end
 

data/lib/badline/audio/cli.rb

@@ -2,73 +2,115 @@
 
 module Badline
   module Audio
-    # Runs `badline-ruby --headless` or `--audio-out` once its options have
-    # parsed: picks the song and its length, then plays it or renders it
-    # to a file. Played on a terminal, the console lets the listener step
-    # between songs.
+    # Runs `--headless`, `--audio-out` or `sid`, in either build, once its
+    # options have parsed: queues the tunes, each with its subtune and length,
+    # then plays them or renders the one to a file. Played on a terminal,
+    # the console lets the listener step through the queue.
     class CLI
       class Error < StandardError; end
 
+      # Plays or renders the tunes as #run does, reports an error on stderr
+      # under the program's name, and returns the exit status.
+      def self.run(options, sink:, console:)
+        new(options, sink:, console:).run
+        0
+      rescue Error => e
+        warn "#{options.program}: #{e.message}"
+        1
+      rescue Interrupt
+        130
+      end
+
       # Playing needs `sink`, which builds the audio device given the rate
       # to ask for and whether it has to be exact, and, on a terminal,
       # `console`, which builds the terminal to play on given the input and
-      # output. The front end hands them in, so the native badline can hand
-      # in its own: badline-ruby's are SDLSink and Console.
+      # output. Each build's entry point hands them in: both builds' sink is
+      # Frontend::AudioSink, and the console is badline-ruby's Console or
+      # the native badline's Native::Console.
       def initialize(options, sink: nil, console: nil, out: $stdout, input: $stdin)
         @options = options
         @out = out
         @input = input
         @sink = sink
         @console = console
-        @lengths = {}
+        @announced = nil
+        @terminal = nil
+        @stil_lists = {}
       end
 
       def run
         @options.render? ? render : play
-      rescue Renderer::UnknownFormatError, Storage::SIDFile::FormatError => e
+      rescue Renderer::UnknownFormatError => e
         raise Error, e.message
       end
 
-      def tune
-        @tune ||= Storage::SIDFile.new(@options.tune_path)
-      rescue Storage::SIDFile::FormatError => e
-        raise Error, "#{@options.tune_path}: #{e.message}"
-      end
+      # The tunes to play, in the order given. --subtune picks the first
+      # one's subtune.
+      def queue
+        @queue ||= begin
+          paths = @options.tune_paths
+          queue = Media::Queue.new(entries(paths, @options.subtune), all_parts: @options.all_subtunes?,
+                                                                     build: ->(dropped) { entries(dropped) })
+          raise Error, "no .sid tunes in #{paths.join(', ')}" if queue.empty? && !paths.empty?
 
-      def song
-        @song ||= (@options.song || tune.start_song).tap do |song|
-          raise Error, "no song #{song}: the tune has #{tune.songs}" if song > tune.songs
+          queue
         end
       end
 
-      def seconds = length(song)
+      def tune = checked(queue.entry).tune
 
-      def length(song)
-        @lengths[song] ||= @options.seconds || songlength(song) || @options.fallback_seconds
-      end
+      def subtune = checked(queue.entry).part
+
+      def seconds = length(subtune)
 
-      def sid_model = @options.sid_model || tune.sid_model
+      def length(subtune) = queue.entry.length(subtune)
 
-      def interactive? = @options.tui? && @input.tty? && @out.tty?
+      def silence(subtune) = queue.entry.silence(subtune)
+
+      def sid_models = queue.entry.sid_models
+
+      def interactive? = @options.player_window? || (@options.tui? && @input.tty? && @out.tty?)
 
       private
 
-      def renderer(song, rate)
-        Renderer.new(tune, seconds: length(song), song:, rate:, sid_model:).tap do |renderer|
-          renderer.filter_chunk = @options.filter_chunk if @options.filter_chunk
+      # The tunes in the paths, the files themselves and the .sid files
+      # below the directories, the first starting on `subtune` if given.
+      def entries(paths, subtune = nil)
+        tunes = []
+        Media::Queue.files(paths, ".sid").each do |path|
+          tunes << QueuedTune.new(path, @options, subtune: tunes.empty? ? subtune : nil)
         end
+        tunes
+      end
+
+      # A tune on its own has to play, where one of many is skipped.
+      def checked(entry)
+        raise Error, "#{entry.path}: #{entry.error}" unless entry.error.empty?
+
+        entry
+      end
+
+      def renderer(entry, subtune, rate)
+        renderer = Renderer.new(entry.tune, seconds: entry.length(subtune), subtune:, rate:,
+                                            sid_models: entry.sid_models)
+        renderer.filter_chunk = @options.filter_chunk if @options.filter_chunk
+        renderer.silence = entry.silence(subtune) if entry.silence(subtune)
+        renderer
       end
 
       def render
-        renderer = renderer(song, @options.rate)
-        @out.puts describe
-        @out.puts "Rendering #{seconds}s for the #{model_name} to #{@options.audio_out} at #{@options.rate} Hz..."
+        entry = checked(queue.entry)
+        renderer = renderer(entry, subtune, @options.rate)
+        @out.puts describe(entry, subtune)
+        @out.puts "Rendering #{seconds}s for the #{entry.model_name} to #{@options.audio_out} " \
+                  "at #{@options.rate} Hz..."
         started = now
-        renderer.render(@options.audio_out) { |done| progress(done) }
-        report(now - started)
+        renderer.render(@options.audio_out) { |done| progress(done, seconds) }
+        report(renderer.rendered, now - started)
       end
 
       def play
+        checked(queue.entry) if queue.size == 1
         sink = open_sink
         interactive? ? play_interactively(sink) : play_plainly(sink)
       ensure
@@ -76,23 +118,85 @@ module Badline
       end
 
       def play_plainly(sink)
-        @out.puts describe
-        @out.puts "Playing #{seconds}s on the #{model_name} at #{sink.rate} Hz. Ctrl-C stops."
-        playback = Playback.new(sink, on_underrun: -> { @out.puts "\rRunning below real time, so it will stutter." })
-        result = playback.play(renderer(song, sink.rate)) { |played| progress(played) }
-        progress(seconds) if result == :finished
+        loop do
+          result = play_subtune(sink, queue.entry, queue.part)
+          break unless %i[finished skipped].include?(result) && queue.advance
+        end
+      end
+
+      def play_subtune(sink, entry, subtune)
+        return skip(entry) unless entry.error.empty?
+
+        announce(entry, subtune)
+        subtune_comments(entry, subtune).each { |line| @out.puts line }
+        length = entry.length(subtune)
+        @out.puts "Playing #{length}s on the #{entry.model_name} at #{sink.rate} Hz. Ctrl-C stops."
+        @warned = false
+        playback = Playback.new(sink, on_underrun: -> { warn_below_real_time })
+        renderer = renderer(entry, subtune, sink.rate)
+        result = playback.play(renderer) { |played| progress(played, length) }
+        progress(renderer.rendered, length) if result == :finished
         @out.print "\n" unless @options.quiet?
         @out.puts(result == :finished ? "Done." : "Stopped.")
+        result
+      end
+
+      def warn_below_real_time
+        return if @warned
+
+        @warned = true
+        @out.puts "\rRunning below real time, so it will stutter."
+      end
+
+      def skip(entry)
+        @out.puts "Skipping #{entry.path}: #{entry.error}"
+        :skipped
+      end
+
+      def announce(entry, subtune)
+        @out.puts describe(entry, subtune)
+        return if entry.equal?(@announced)
+
+        @announced&.release
+        @announced = entry
+        comments(entry).each { |line| @out.puts line }
       end
 
       def play_interactively(sink)
-        console = @console.call(input: @input, output: @out)
-        jukebox = Jukebox.new(sink, console, songs: tune.songs, renderer: method(:renderer), length: method(:length))
-        console.session do
-          console.header([tune.name, tune.author, tune.released].reject(&:empty?) +
-                         ["#{model_name} at #{sink.rate} Hz"])
-          jukebox.run(song)
-        end
+        @terminal = @console.call(input: @input, output: @out)
+        jukebox = Jukebox.new(sink, @terminal, queue:,
+                                               renderer: ->(entry, subtune, rate) { playable(entry, subtune, rate) },
+                                               length: ->(entry, subtune) { entry.length(subtune) })
+        @terminal.session { jukebox.run }
+      end
+
+      # The renderer for the subtune, or nil for a tune the jukebox skips.
+      def playable(entry, subtune, rate)
+        introduce(entry, rate) unless entry.equal?(@announced)
+        return nil unless entry.error.empty?
+
+        comments = subtune_comments(entry, subtune)
+        @terminal.announce(comments) unless comments.empty?
+        renderer = renderer(entry, subtune, rate)
+        found = stil(entry)
+        @terminal.stil(found ? found.fields : [], subtune, found ? found.subtune(subtune) : [])
+        @terminal.playing(renderer)
+        renderer
+      end
+
+      # Shows the tune's header above the status line as it starts, below
+      # the keys the first time.
+      def introduce(entry, rate)
+        @announced&.release
+        lines = introduction(entry, rate)
+        @announced.nil? ? @terminal.header(lines) : @terminal.announce(lines)
+        @announced = entry
+      end
+
+      def introduction(entry, rate)
+        return ["Skipping #{entry.path}: #{entry.error}"] unless entry.error.empty?
+
+        entry.header + ["#{entry.model_name} at #{rate} Hz"] + comments(entry)
       end
 
       def open_sink
@@ -101,36 +205,40 @@ module Badline
         raise Error, "can't open the audio device: #{e.message}"
       end
 
-      def describe
-        header = [tune.name, tune.author, tune.released].reject(&:empty?).join(" / ")
-        header.empty? ? "song #{song}" : "#{header} (song #{song})"
+      def describe(entry, subtune)
+        header = entry.header.join(" / ")
+        header.empty? ? "subtune #{subtune}" : "#{header} (subtune #{subtune})"
       end
 
-      # HVSC's database is keyed by the tune's MD5 and lists one length per
-      # song.
-      def songlength(song) = songlengths&.at(song - 1)
-
-      def songlengths
-        return @songlengths if @songlengths_read
+      # The tune's entry in HVSC's STIL, as STIL.txt lays it out.
+      def comments(entry)
+        found = stil(entry)
+        found ? found.fields.flat_map(&:lines) : []
+      end
 
-        @songlengths_read = true
-        path = @options.songlengths || Storage::SongLengths.locate(@options.tune_path)
-        @songlengths = path && Storage::SongLengths.new(path).lengths(tune.md5)
+      def subtune_comments(entry, subtune)
+        found = stil(entry)
+        lines = found ? found.subtune(subtune).flat_map(&:lines) : []
+        lines.empty? ? lines : ["(##{subtune})"] + lines
       end
 
-      def model_name = sid_model.to_s.delete_prefix("mos")
+      def stil(entry)
+        list = Storage::STIL.locate(entry.path)
+        hvsc_path = list && Storage::HVSC.path(entry.path, list)
+        hvsc_path && (@stil_lists[list] ||= Storage::STIL.new(list)).entry(hvsc_path)
+      end
 
-      def progress(done)
+      def progress(done, total)
         return if @options.quiet?
 
-        @out.print format("\r%<done>6.1fs / %<total>.1fs", done:, total: seconds)
+        @out.print format("\r%<done>6.1fs / %<total>.1fs", done:, total:)
         @out.flush
       end
 
-      def report(elapsed)
+      def report(rendered, elapsed)
         @out.print "\r" unless @options.quiet?
         @out.puts format("Wrote %<path>s in %<elapsed>.1fs (%<speed>.2fx real time).",
-                         path: @options.audio_out, elapsed:, speed: seconds / elapsed)
+                         path: @options.audio_out, elapsed:, speed: rendered / elapsed)
       end
 
       def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)

data/lib/badline/audio/console.rb

@@ -6,7 +6,8 @@ require "io/wait"
 module Badline
   module Audio
     # The terminal of `badline-ruby --headless`, put in raw mode with
-    # io/console.
+    # io/console. It is badline-ruby's side of the console seam, and
+    # exe/badline-ruby requires it: the native badline's is Native::Console.
     class Console < Terminal
       private