badline 0.1.0 → 0.2.1

data/exe/badline

@@ -13,7 +13,8 @@ parser = OptionParser.new do |opts|
     Usage: badline [options] [media]
 
     Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image,
-    a .crt cartridge, or a directory to mount as device 8.
+    a .t64 tape archive, a .tap tape, a .crt cartridge, a .sid tune, or
+    a directory to mount as device 8.
 
     Options:
   BANNER
@@ -22,6 +23,15 @@ parser = OptionParser.new do |opts|
     options[:autostart] = false
   end
 
+  opts.on("--song N", Integer, "Subtune of a .sid to play (default: the tune's own)") do |n|
+    options[:song] = n
+  end
+
+  opts.on("--sid MODEL", { "6581" => :mos6581, "8580" => :mos8580 },
+          "SID to fit: 6581 or 8580 (default: a .sid tune's own, else 6581)") do |model|
+    options[:sid_model] = model
+  end
+
   opts.on("--disable-jit", "Run without enabling YJIT") do
     options[:jit] = false
   end
@@ -52,4 +62,14 @@ RubyVM::YJIT.enable if options[:jit] && jit_available
 require "badline"
 require "badline/gui"
 
-Badline::GUI::Application.new(media_path:, autostart: options[:autostart]).run
+begin
+  application = Badline::GUI::Application.new(media_path:, autostart: options[:autostart],
+                                              song: options[:song], sid_model: options[:sid_model])
+rescue Badline::Storage::SIDFile::FormatError, Badline::Storage::T64::FormatError,
+       Badline::Storage::TAP::FormatError, Badline::Storage::CRTFile::FormatError,
+       Badline::Cartridge::UnsupportedTypeError => e
+  warn "badline: #{media_path}: #{e.message}"
+  exit 1
+end
+
+application.run

data/exe/badline-sid

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "badline/audio/options"
+
+begin
+  options = Badline::Audio::Options.parse(ARGV)
+rescue Badline::Audio::Options::Error => e
+  warn "badline-sid: #{e.message}"
+  warn "Try 'badline-sid --help' for more information."
+  exit 1
+end
+
+if options.help?
+  puts options.help
+  exit
+end
+
+jit_available = defined?(RubyVM::YJIT) && !RubyVM::YJIT.enabled?
+RubyVM::YJIT.enable if options.jit? && jit_available
+
+require "badline"
+
+begin
+  Badline::Audio::CLI.new(options).run
+rescue Badline::Audio::CLI::Error => e
+  warn "badline-sid: #{e.message}"
+  exit 1
+rescue Interrupt
+  exit 130
+end

data/lib/badline/address_bus.rb

@@ -29,45 +29,59 @@ module Badline
   class AddressBus
     include Addressable
 
-    # Unmapped address space for Ultimax cartridges.
-    module OpenSpace
-      module_function
+    # 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,
+    # and a write goes nowhere.
+    class OpenBus
+      def initialize(vic)
+        @vic = vic
+      end
 
-      def peek(_addr) = 0xff
+      def peek(_addr) = @vic.phi1_data
       def poke(_addr, _value); end
     end
 
     PORT_PULLUPS  = 0b0001_0111
     PORT_FLOATING = 0b1100_1000
+    TAPE_SENSE    = 0b0001_0000
+
+    RAM_POWER_ON = [0xff, 0x07].freeze
 
     attr_reader :io_port, :ram, :basic_rom, :character_rom, :kernal_rom,
-                :vic, :sid, :color_ram, :cia1, :cia2, :keyboard, :joystick2,
-                :cartridge, :ultimax
+                :vic, :sid, :color_ram, :cia1, :cia2, :keyboard, :joystick1, :joystick2,
+                :control_ports, :cartridge, :ultimax, :phi1_ultimax, :datasette
 
-    def initialize
-      @ram = Memory.new([0xff, 0x07], length: 2**16, start: 0)
+    def initialize(sid_model: :mos6581)
+      @ram = Memory.new(RAM_POWER_ON, length: 2**16, start: 0)
       @cartridge = nil
+      @debug_register = nil
 
       @basic_rom     = ROM.load("basic.rom",     0xa000)
       @character_rom = ROM.load("character.rom", 0xd000)
       @kernal_rom    = ROM.load("kernal.rom",    0xe000)
 
       @keyboard = Keyboard.new
+      @joystick1 = Joystick.new
       @joystick2 = Joystick.new
+      @control_ports = ControlPorts.new(keyboard: @keyboard, joystick1: @joystick1, joystick2: @joystick2)
       @vic  = VIC.new(self)
-      @cia1 = CIA.new(
-        start: 0xdc00,
-        peripheral: ControlPorts.new(keyboard: @keyboard, joystick2: @joystick2)
-      )
+      @cia1 = CIA.new(start: 0xdc00, peripheral: @control_ports)
       @cia2 = CIA.new(start: 0xdd00)
-      @sid  = SID.new
+      @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)
+
+      @datasette = Datasette.new
+      @datasette.on_flag { @cia1.flag! }
+      @datasette.on_sense_change { @io_port.value = port_value }
 
-      @color_ram = ColorMemory.new(start: 0xd800, length: 2**10)
+      @color_ram = ColorMemory.new(@vic)
+      @open_bus = OpenBus.new(@vic)
 
-      @port_ddr = 0x2f
-      @port_out = 0x37
+      @port_ddr = 0x00
+      @port_out = 0x00
       @port_floating = 0x00
-      @io_port = Status.new(%i[basic kernal io tape_out tape_switch tape_motor], value: port_value)
+      @io_port = PortStatus.new(%i[basic kernal io tape_out tape_switch tape_motor], value: port_value)
 
       @read_pages = Array.new(256)
       @write_pages = Array.new(256)
@@ -76,14 +90,33 @@ module Badline
 
     def attach_cartridge(cartridge)
       @cartridge = cartridge
+      cartridge.connect(ram: @ram, open_bus: @open_bus)
       cartridge.on_change { update_overlays! }
       update_overlays!
     end
 
+    def power_on!
+      @ram.clear!(RAM_POWER_ON)
+    end
+
+    # The 6510's RES line clears the port's direction and output registers.
+    # The floating bits keep their charge.
+    def reset_port!
+      @port_ddr = 0x00
+      @port_out = 0x00
+      update_port!
+    end
+
     def disable_overlays!
+      poke(0, 0x2f)
       poke(1, 0)
     end
 
+    def install_debug_register(&)
+      @debug_register = DebugRegister.new(@sid, &)
+      update_overlays!
+    end
+
     def peek(addr)
       return @port_ddr if addr.zero?
       return @io_port.value if addr == 0x01
@@ -112,11 +145,14 @@ module Badline
       driven = @port_ddr & PORT_FLOATING
       @port_floating = (@port_floating & ~driven) | (@port_out & driven)
       @io_port.value = port_value
+      # $01 bit 5 drives the motor through an inverter: low runs it.
+      @datasette.motor = !@io_port.tape_motor?
       update_overlays!
     end
 
     def port_value
       input = PORT_PULLUPS | (@port_floating & PORT_FLOATING)
+      input &= ~TAPE_SENSE if @datasette.sense_low?
       (@port_out & @port_ddr) | (input & ~@port_ddr & 0xff)
     end
 
@@ -125,6 +161,7 @@ module Badline
     # of range checks.
     def update_overlays!
       @ultimax = @cartridge ? @cartridge.ultimax? : false
+      @phi1_ultimax = @cartridge ? @cartridge.phi1_ultimax? : false
       @read_pages.fill(@ram)
       @write_pages.fill(@ram)
 
@@ -133,6 +170,8 @@ module Badline
 
     def map_banked_pages
       map_rom_overlays
+      map_cartridge_ram
+      @write_pages.fill(@cartridge.romh_writes, 0xe0, 0x20) if @cartridge&.romh_writes
 
       if io?
         map_io_pages
@@ -151,28 +190,59 @@ module Badline
       @read_pages.fill(kernal_rom, 0xe0, 0x20) if kernal?
     end
 
+    # Cartridge RAM in the ROML or ROMH window decodes writes itself,
+    # whatever the $01 lines say.
+    def map_cartridge_ram
+      return unless @cartridge&.exrom&.zero?
+
+      map_cartridge_ram_bank(@cartridge.roml, 0x80)
+      map_cartridge_ram_bank(@cartridge.romh, 0xa0) if @cartridge.game.zero?
+    end
+
+    def map_cartridge_ram_bank(bank, first_page)
+      @write_pages.fill(bank, first_page, 0x20) if bank.is_a?(Cartridge::RAMBank)
+    end
+
     # Ultimax cartridges ignore the $01 lines: 4K of RAM, ROML/ROMH windows,
-    # I/O always visible and open address space everywhere else.
+    # I/O always visible and open address space everywhere else. The ROML
+    # and ROMH selects fire on writes as well, so cartridge RAM or flash in
+    # either window takes the writes there.
     def map_ultimax_pages
-      @read_pages.fill(OpenSpace, 0x10, 0xf0)
-      @write_pages.fill(OpenSpace, 0x10, 0xf0)
+      @read_pages.fill(@open_bus, 0x10, 0xf0)
+      @write_pages.fill(@open_bus, 0x10, 0xf0)
       @read_pages.fill(@cartridge.roml, 0x80, 0x20) if @cartridge.roml
+      map_ultimax_writes(@cartridge.roml, 0x80)
       @read_pages.fill(@cartridge.romh, 0xe0, 0x20) if @cartridge.romh
+      map_ultimax_writes(@cartridge.romh, 0xe0)
+      map_ultimax_a000
       map_io_pages
     end
 
+    def map_ultimax_writes(bank, first_page)
+      @write_pages.fill(bank, first_page, 0x20) if bank.respond_to?(:poke)
+    end
+
+    def map_ultimax_a000
+      return unless (window = @cartridge.ultimax_a000)
+
+      @read_pages.fill(window, 0xa0, 0x20)
+      @write_pages.fill(window, 0xa0, 0x20)
+    end
+
     def map_io_pages
       {
         vic => 0xd0..0xd3, sid => 0xd4..0xd7, color_ram => 0xd8..0xdb,
-        cia1 => 0xdc..0xdc, cia2 => 0xdd..0xdd
-        # 0xde/0xdf are open I/O unless a cartridge claims them
+        cia1 => 0xdc..0xdc, cia2 => 0xdd..0xdd, @open_bus => 0xde..0xdf
       }.each do |chip, pages|
         pages.each { |p| @read_pages[p] = @write_pages[p] = chip }
       end
-      return unless @cartridge
+      @read_pages[0xd7] = @write_pages[0xd7] = @debug_register if @debug_register
+      map_cartridge_io if @cartridge
+    end
 
-      @read_pages.fill(@cartridge, 0xde, 2)
+    def map_cartridge_io
       @write_pages.fill(@cartridge, 0xde, 2)
+      @cartridge.readable_io_pages.each { |p| @read_pages[p] = @cartridge }
     end
 
     def basic?
@@ -191,8 +261,9 @@ module Badline
       @cartridge&.romh && @cartridge.exrom.zero? && @cartridge.game.zero? && io_port.kernal?
     end
 
+    # In 16K mode LORAM alone leaves $d000 as RAM, where it still maps I/O.
     def character?
-      (io_port.basic? || io_port.kernal?) && !io_port.io?
+      (io_port.kernal? || (io_port.basic? && game_high?)) && !io_port.io?
     end
 
     def io?

data/lib/badline/audio/aiff.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # AIFF, the same shape as WAV but big-endian, and with the sample rate
+    # stored as an 80-bit IEEE 754 extended float.
+    class AIFF < PCMWriter
+      EXPONENT_BIAS = 16_383
+
+      private
+
+      def pack_format = "s>*"
+
+      def header
+        ["FORM", 0, "AIFF",
+         "COMM", 18, 1, 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(42, [8 + data_size].pack("N"))
+      end
+
+      # Sign bit, 15-bit biased exponent, then a 64-bit mantissa that keeps
+      # its leading one rather than hiding it.
+      def extended(value)
+        exponent = EXPONENT_BIAS + value.bit_length - 1
+        mantissa = value << (64 - value.bit_length)
+        [exponent, mantissa >> 32, mantissa & 0xffff_ffff].pack("nNN")
+      end
+    end
+  end
+end

data/lib/badline/audio/bare_player.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # Runs a PSID tune on a bare rig: a CPU and RAM with the SID clocked
+    # alongside it. The VIC and the CIAs still decode their registers, so a
+    # tune writing to them lands somewhere sane, but neither is ever cycled,
+    # which is what makes this path about three times faster than the whole
+    # machine.
+    #
+    # Calls go through a six-byte stub whose JSR operand the dispatch trap
+    # rewrites:
+    #
+    #   stub: jsr target
+    #   idle: jmp idle
+    #
+    # The CPU spins in the idle loop between calls, so a dispatch always
+    # lands on an instruction boundary and a play routine that overruns its
+    # frame is never re-entered.
+    class BarePlayer
+      include IntegerHelper
+
+      # 312 raster lines of 63 cycles.
+      FRAME_CYCLES = 19_656
+
+      # A tune's init routine is free to unpack itself, but not forever.
+      INIT_LIMIT = 10_000_000
+
+      # The CIA 1 timer A latch the PAL KERNAL leaves, 60 underflows a
+      # second.
+      KERNAL_TIMER = 0x4025
+
+      attr_reader :sid
+
+      def initialize(tune, song: nil, sid_model: tune.sid_model)
+        @tune = tune
+        @song = (song || tune.start_song).clamp(1, tune.songs) - 1
+        @bus = AddressBus.new(sid_model:)
+        # The CPU port as the KERNAL leaves it, which a PSID tune expects.
+        @bus.poke(0x00, 0x2f)
+        @bus.poke(0x01, 0x37)
+        @bus.cia1.timer_a_latch = KERNAL_TIMER
+        @cpu = CPU.new(@bus)
+        @sid = @bus.sid
+        @idle = false
+      end
+
+      def start
+        @bus.ram.write(@tune.load_address, @tune.data)
+        @bus.ram.write(stub_address, stub)
+        @sid.synthesize!
+        @cpu.status.interrupt = true
+        @cpu.program_counter = idle_address
+        install_dispatch
+        call(@tune.init_address, @song)
+        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.
+      def frame(budget, &)
+        call(@tune.play_address)
+        cycles = [budget, period].min
+        cycles.times { step }
+        @sid.drain_samples.each(&)
+        cycles
+      end
+
+      private
+
+      # A PAL frame, or for a CIA-timed song one period of CIA 1 timer A,
+      # which init and play are both free to reprogram.
+      def period
+        return FRAME_CYCLES unless @tune.cia_timed?(@song + 1)
+
+        @bus.cia1.timer_a_latch + 1
+      end
+
+      def stub_address = @stub_address ||= @tune.driver_address
+
+      def idle_address = stub_address + 3
+
+      def stub
+        [0x20, 0x00, 0x00, 0x4c,
+         low_byte(idle_address), high_byte(idle_address)]
+      end
+
+      def call(address, argument = 0)
+        @pending = address
+        @argument = argument
+      end
+
+      # A tune that never returns from init gets cut off and plays with
+      # whatever it managed to set up.
+      def settle
+        limit = @cpu.cycles + INIT_LIMIT
+        step until @idle || @cpu.cycles > limit
+      end
+
+      def step
+        @sid.cycle!
+        @cpu.cycle!
+      end
+
+      def install_dispatch
+        @cpu.install_trap(idle_address) do
+          @idle = true
+          dispatch if @pending
+        end
+      end
+
+      # Tunes live under the ROMs as often as not, so $01 has to bank out
+      # whatever covers the routine about to run. An RSID tune banks itself,
+      # and `SIDFile#bank_for` hands back nil for it.
+      def dispatch
+        bank = @tune.bank_for(@pending)
+        @bus.poke(0x01, bank) if bank
+        @bus.ram.write(stub_address + 1,
+                       [low_byte(@pending), high_byte(@pending)])
+        @cpu.a = @argument
+        @cpu.stack_pointer = 0xff
+        @cpu.program_counter = stub_address
+        @pending = nil
+        @idle = false
+      end
+    end
+  end
+end

data/lib/badline/audio/cli.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # Runs `badline-sid` 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.
+    class CLI
+      class Error < StandardError; end
+
+      # `sink` builds the audio device for playback, given the rate to ask
+      # for and whether it has to be exact.
+      def initialize(options, out: $stdout, input: $stdin, sink: SDLSink.method(:new))
+        @options = options
+        @out = out
+        @input = input
+        @sink = sink
+        @lengths = {}
+      end
+
+      def run
+        @options.render? ? render : play
+      rescue Renderer::UnknownFormatError, Storage::SIDFile::FormatError => 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
+
+      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
+        end
+      end
+
+      def seconds = length(song)
+
+      def length(song)
+        @lengths[song] ||= @options.seconds || songlength(song) || Options::FALLBACK_SECONDS
+      end
+
+      def sid_model = @options.sid_model || tune.sid_model
+
+      def interactive? = @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
+        end
+      end
+
+      def render
+        renderer = renderer(song, @options.rate)
+        @out.puts describe
+        @out.puts "Rendering #{seconds}s for the #{model_name} to #{@options.output} at #{@options.rate} Hz..."
+        started = now
+        renderer.render(@options.output) { |done| progress(done) }
+        report(now - started)
+      end
+
+      def play
+        sink = open_sink
+        interactive? ? play_interactively(sink) : play_plainly(sink)
+      ensure
+        sink&.close
+      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
+        @out.print "\n" unless @options.quiet?
+        @out.puts(result == :finished ? "Done." : "Stopped.")
+      end
+
+      def play_interactively(sink)
+        console = Console.new(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
+      end
+
+      def open_sink
+        @sink.call(rate: @options.rate, exact_rate: @options.rate_given?)
+      rescue SDLSink::Error => e
+        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})"
+      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 defined?(@songlengths)
+
+        path = @options.songlengths || Storage::SongLengths.locate(@options.tune_path)
+        @songlengths = path && Storage::SongLengths.new(path).lengths(tune.md5)
+      end
+
+      def model_name = sid_model.to_s.delete_prefix("mos")
+
+      def progress(done)
+        return if @options.quiet?
+
+        @out.print format("\r%<done>6.1fs / %<total>.1fs", done:, total: seconds)
+        @out.flush
+      end
+
+      def report(elapsed)
+        @out.print "\r" unless @options.quiet?
+        @out.puts format("Wrote %<path>s in %<elapsed>.1fs (%<speed>.2fx real time).",
+                         path: @options.output, elapsed:, speed: seconds / elapsed)
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/audio/console.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "io/wait"
+
+module Badline
+  module Audio
+    # The terminal face of `badline-sid`: the tune's header, a status line
+    # redrawn in place, and single keypresses read without waiting for
+    # Return. Ctrl-C still interrupts.
+    class Console
+      KEYS = {
+        "n" => :next, "\e[C" => :next,
+        "p" => :previous, "\e[D" => :previous,
+        " " => :pause,
+        "q" => :quit
+      }.freeze
+
+      def initialize(input:, output:)
+        @input = input
+        @output = output
+        @closed = false
+      end
+
+      # Raw input and a hidden cursor for the length of the block.
+      def session(&)
+        @output.print "\e[?25l"
+        @input.tty? ? @input.raw(intr: true, &) : yield
+      ensure
+        @output.print "\e[?25h\r\n"
+      end
+
+      # Waits up to `seconds` for keys and returns what they ask for.
+      def wait(seconds)
+        return idle(seconds) if @closed
+        return [] unless @input.wait_readable(seconds)
+
+        case (keys = @input.read_nonblock(64, exception: false))
+        when :wait_readable then []
+        when nil then close_input(seconds)
+        else keys.scan(/\e\[[A-D]|./m).filter_map { |key| KEYS[key] }
+        end
+      end
+
+      def header(lines)
+        lines.each { |line| @output.print "#{line}\r\n" }
+        @output.print "n/→ next  p/← previous  space pause  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))
+        @output.print "\r\e[K#{([line] + notes).join('  ')}"
+        @output.flush
+      end
+
+      private
+
+      def close_input(seconds)
+        @closed = true
+        idle(seconds)
+      end
+
+      def idle(seconds)
+        sleep(seconds)
+        []
+      end
+
+      def clock(seconds)
+        whole = seconds.floor
+        format("%<minutes>d:%<seconds>02d", minutes: whole / 60, seconds: whole % 60)
+      end
+    end
+  end
+end