badline 0.11.1 → 0.12.1

data/lib/badline/frontend/sound.rb

@@ -14,33 +14,33 @@ module Badline
     # 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.
-    # The chip's cycles are converted at `clock_hz`, the machine's clock, so
-    # an NTSC or Drean machine plays at its own pitch.
+    # Each frame's samples go to a mono AudioDevice. The chip's cycles are
+    # converted at `clock_hz`, the machine's clock, so an NTSC or Drean
+    # machine plays at its own pitch.
     class Sound
       RATE = 44_100
       AHEAD = 0.08
       LIMIT = 0.25
 
-      attr_reader :rate, :underruns, :dropped, :queued, :low, :high
+      attr_reader :underruns, :dropped, :queued, :low, :high
 
       def initialize(source, clock_hz, wanted, verbose)
         @source = source
         @clock_hz = clock_hz
         @verbose = verbose
-        @device = 0
-        @rate = RATE
+        @device = AudioDevice.new(channels: 1, rate: RATE, samples: 512)
         @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
+      def rate = @device.rate
+
+      def on? = @device.open?
 
       # Plays another machine's sound from here on, at that machine's clock.
       def switch(source, clock_hz)
@@ -60,7 +60,7 @@ module Badline
         return if @muted || samples.empty?
 
         level = queued_seconds
-        if level + (samples.size.to_f / @rate) > LIMIT
+        if level + (samples.size.to_f / rate) > LIMIT
           @dropped += samples.size
         else
           play(samples, level)
@@ -80,7 +80,7 @@ module Badline
         return unless @muted
 
         halt
-        SDL.SDL_ClearQueuedAudio(@device)
+        @device.clear
       end
 
       def reset_levels
@@ -89,32 +89,22 @@ module Badline
       end
 
       def close
-        SDL.SDL_CloseAudioDevice(@device) if on?
+        @device.close
       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)
+        @device.open(false)
         return puts "No sound: #{SDL.SDL_GetError}" unless on?
 
-        @rate = SDL.read_i32(SDL.obtained)
         record
-        puts "Sound at #{@rate} Hz" if @verbose
+        puts "Sound at #{rate} Hz" if @verbose
       end
 
-      def record = @source.record(rate: @rate, clock_hz: @clock_hz)
+      def record = @source.record(rate: @device.rate, clock_hz: @clock_hz)
 
-      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
+      def queued_seconds = @device.queued_seconds
 
       def play(samples, level)
         @low = level if level < @low
@@ -126,29 +116,20 @@ module Badline
       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
+        @device.queue(samples)
+        @queued += samples.size
       end
 
       def start
         return if @started
 
         @started = true
-        SDL.SDL_PauseAudioDevice(@device, 0)
+        @device.start
       end
 
       def halt
         @started = false
-        SDL.SDL_PauseAudioDevice(@device, 1)
+        @device.pause
       end
 
       def underrun!

data/lib/badline/frontend/timeline.rb

@@ -183,12 +183,11 @@ module Badline
         return puts "No #{what} to eject" unless ejectable?(computer, what)
 
         if what == "disk"
-          eject_disk(computer)
+          MediaSlots.eject_disk(computer)
         elsif what == "tape"
           computer.datasette.eject
         else
-          computer.address_bus.detach_cartridge
-          computer.power_cycle!
+          MediaSlots.remove_cartridge(computer)
         end
         puts "Ejected the #{what}"
       end
@@ -200,17 +199,7 @@ module Badline
         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
+        MediaSlots.disk?(computer)
       end
     end
   end

data/lib/badline/frontend.rb

@@ -9,7 +9,9 @@ require "badline/frontend/drive_led"
 require "badline/frontend/keys"
 require "badline/frontend/snapshots"
 require "badline/frontend/screenshot"
+require "badline/frontend/media_slots"
 require "badline/frontend/timeline"
+require "badline/frontend/audio_device"
 require "badline/frontend/sound"
 require "badline/frontend/pacer"
 require "badline/frontend/frame_report"
@@ -20,24 +22,26 @@ require "badline/frontend/machine_window"
 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/player/theme"
+require "badline/frontend/player/sid_history"
+require "badline/frontend/player/sid_view"
+require "badline/frontend/player/filter_view"
+require "badline/frontend/player/scope"
+require "badline/frontend/player/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/name_field"
-require "badline/frontend/menu_dialogs"
-require "badline/frontend/menu_media"
-require "badline/frontend/menu_ports"
-require "badline/frontend/menu_pages"
+require "badline/frontend/player/player_state"
+require "badline/frontend/player/player_header"
+require "badline/frontend/player/player_footer"
+require "badline/frontend/player/info_view"
+require "badline/frontend/player/player_commands"
+require "badline/frontend/player/player_screen"
+require "badline/frontend/player/player_controller"
+require "badline/frontend/menu/theme"
+require "badline/frontend/menu/pause_menu"
+require "badline/frontend/menu/file_browser"
+require "badline/frontend/menu/confirmation"
+require "badline/frontend/menu/name_field"
+require "badline/frontend/menu/menu_dialogs"
+require "badline/frontend/menu/menu_media"
+require "badline/frontend/menu/menu_ports"
+require "badline/frontend/menu/menu_pages"

data/lib/badline/iec_bus.rb

@@ -15,7 +15,9 @@ module Badline
   # A drive drives CLK and DATA from VIA 1's PB3 and PB1, the same way. It
   # also pulls DATA while ATN IN differs from its ATN acknowledge on PB4
   # (an XOR gate), which answers ATN in hardware before the DOS gets to it.
-  # SerialPort reads the lines back into VIA 1.
+  # SerialPort reads the lines back into VIA 1. A drive whose
+  # serial_output sets DRIVE_ATN_GATED pulls DATA that way only while
+  # ATN is low, as the 1581's NAND does.
   #
   # Fast serial adds SRQ, which the C64 leaves alone. A C128 and a 1571
   # clock bytes over it from a CIA's CNT, with the bits on DATA from its
@@ -48,6 +50,10 @@ module Badline
     DRIVE_FAST_DATA = 0x100
     DRIVE_FAST_SRQ = 0x200
 
+    # A drive's serial_output bit whose ATN acknowledge pulls DATA only
+    # while ATN is low.
+    DRIVE_ATN_GATED = 0x400
+
     attr_reader :drives, :host_lines
 
     # The lines the host's fast serial pins pull, as DATA and SRQ bits.
@@ -119,7 +125,7 @@ module Badline
       while i < @drives.length
         drive = @drives[i].serial_output
         low |= CLK if drive.anybits?(DRIVE_CLK_OUT)
-        low |= DATA if drive.anybits?(DRIVE_DATA_OUT) || atn != drive.anybits?(DRIVE_ATNA)
+        low |= DATA if drive.anybits?(DRIVE_DATA_OUT) || acknowledging?(drive, atn)
         i += 1
       end
       low
@@ -127,6 +133,12 @@ module Badline
 
     def atn_low?(host = @host_lines) = host.anybits?(HOST_ATN_OUT)
 
+    # Whether a drive's ATN acknowledge pulls DATA, with its serial_output
+    # +drive+, while ATN is +atn+.
+    def acknowledging?(drive, atn)
+      atn != drive.anybits?(DRIVE_ATNA) && (atn || drive.nobits?(DRIVE_ATN_GATED))
+    end
+
     def clk_low? = low_lines.anybits?(CLK)
 
     def data_low? = low_lines.anybits?(DATA)

data/lib/badline/kernal_trap/{file.rb → file_routine.rb}

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class File < Routine
+    class FileRoutine < Routine
       private
 
       def active?

data/lib/badline/kernal_trap/load.rb

@@ -12,7 +12,7 @@ module Badline
     # below $0334, into the zero page, the stack or the KERNAL vectors: the
     # ROM's byte loop then loads it through the serial traps, and a loader
     # that overwrites ISTOP takes over mid-load as it does on a real drive.
-    class Load < File
+    class Load < FileRoutine
       # ST bits at $90
       EOI = 0x40
       VERIFY_MISMATCH = 0x10

data/lib/badline/kernal_trap/save.rb

@@ -15,7 +15,7 @@ module Badline
     # write: the drive stops listening, so ST reads DEVICE NOT PRESENT,
     # and the ROM returns without an error. A "@" before the drive prefix
     # writes over a file of the same name.
-    class Save < File
+    class Save < FileRoutine
       SECONDARY = 0x61
 
       # ST bit at $90

data/lib/badline/kernal_trap.rb

@@ -4,7 +4,7 @@ require "badline/kernal_trap/layout"
 require "badline/kernal_trap/routine"
 require "badline/kernal_trap/channel"
 require "badline/kernal_trap/drive"
-require "badline/kernal_trap/file"
+require "badline/kernal_trap/file_routine"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
 require "badline/kernal_trap/serial"

data/lib/badline/machine/clocking.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # Running a machine from outside its own #cycle!, and the handlers that
+    # wait for its KERNAL to boot. Computer, Vic20 and C128 each include it
+    # and answer #cycle!, #cycles and #init_threshold, the cycle at which
+    # #on_init's handlers run, and keep the handlers in @init_handlers.
+    module Clocking
+      # Runs `count` cycles, one #cycle! after another.
+      def run_cycles(count)
+        i = 0
+        while i < count
+          cycle!
+          i += 1
+        end
+      end
+
+      # Runs cycles until the block returns true or the cycle count passes
+      # `limit`, checking before each cycle.
+      def run_until(limit)
+        cycle! until yield || @cycles > limit
+      end
+
+      # Runs the block once the KERNAL has booted (see init_threshold), or
+      # now if it has.
+      def on_init(&block)
+        if booting?
+          @init_handlers << block
+        else
+          block.call
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name} cycles=#{@cycles} cpu=(#{@cpu.inspect})>"
+      end
+
+      private
+
+      def booting?
+        @cycles < init_threshold
+      end
+
+      def handle_init
+        @init_handlers.each(&:call)
+      end
+    end
+  end
+end

data/lib/badline/machine.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/machine/clocking"
+
 module Badline
   # = Machine
   #
@@ -25,8 +27,9 @@ module Badline
   #   +mounted?+, +datasette+, +attach_cartridge+,
   #   +press_cartridge_button+, +release_cartridge_button+,
   #   +attach_drive1541+, +drive1541+, +true_drive+ and +plug_true_drive+
-  #   for the drive Media::TrueDrive plugs in, and +address_bus+ for its
-  #   +cartridge+ and +detach_cartridge+.
+  #   for the drive Media::TrueDrive plugs in, +attach_drive1581+,
+  #   +drive1581+ and +plug_drive1581+ for a 1581 (Drive1581::Slot), and
+  #   +address_bus+ for its +cartridge+ and +detach_cartridge+.
   # - Snapshots and tests: +snapshot+, +restore+, +save_snapshot+,
   #   +install_debug_register+ and +capture_output+.
   #
@@ -34,8 +37,8 @@ module Badline
   # input parts, with its one joystick as both +joystick1+ and +joystick2+
   # and nil for +control_ports+, and of the rest +ram+, +load_prg+,
   # +type_text+, +mount+, +unmount+, +mounted?+, +datasette+, +attach_cartridge+,
-  # +attach_drive1541+, +drive1541+, +true_drive+, +plug_true_drive+,
-  # +install_debug_register+ and +capture_output+.
+  # +attach_drive1541+, +drive1541+, +true_drive+, +plug_true_drive+, the
+  # 1581's, +install_debug_register+ and +capture_output+.
   #
   # The C128 answers all but the cartridge button, and besides +mode+,
   # :c64, as Machine.build builds it, or :c128, +vdc+, the VDC a front
@@ -43,16 +46,22 @@ module Badline
   # +press_caps_lock+, +release_caps_lock+, +press_display_key+,
   # +release_display_key+, and +attach_drive1571+ and +drive1571+ for the
   # C128D's 1571, its true drive.
+  #
+  # Each machine includes Machine::Clocking for the clocking part.
   module Machine
+    # Media the machine named doesn't take.
+    class Unsupported < ArgumentError; end
+
     # A new machine of `family`, :c64, :vic20 or :c128, the model of it
     # `model` names. A C64's model is one of Model::ALL, with its SID
     # `sid_model` when not nil and an REU of `reu` K when not nil. A
     # VIC-20's is "pal", with the RAM expansion `ram` names
     # (Vic20::Bus::RAM_CONFIGURATIONS), unexpanded when nil. A C128's is
-    # one of C128::Model::ALL, with its SID `sid_model` when not nil.
+    # one of C128::Model::ALL, with its SID `sid_model` when not nil, built
+    # for C64 mode.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
-      return C128.new(model:, sid_model:) if family == :c128
+      return c128(model, sid_model, :c64) if family == :c128
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -61,11 +70,59 @@ module Badline
                    kernal: profile.kernal, datasette: profile.datasette, board: profile.board)
     end
 
+    # The machine the command line's `options` name, to start `media`, a
+    # path or nil. A C64 or a C128 without a SID named takes the one a .sid
+    # tune names. The C128 is built for C128 mode, with C= held through the
+    # reset, so its KERNAL starts C64 mode, for --c64 (+c64_mode?+) or media
+    # only C64 mode runs: a .sid tune or a program that loads at the C64's
+    # BASIC start. A VIC-20 without RAM named gets the expansion the media
+    # needs (Media::Vic20Media.ram_for) and yields a line saying so. Raises
+    # Unsupported for media a VIC-20 doesn't take.
+    def self.for_options(options, media, &)
+      family = options.family
+      return vic20_for(media, options.model, options.ram, &) if family == :vic20
+
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      return build(:c64, model: options.model, sid_model:, reu: options.reu) unless family == :c128
+
+      machine = c128(options.model, sid_model, :c128)
+      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
+      machine
+    end
+
     def self.vic20(model, ram)
       raise ArgumentError, "no VIC-20 model named #{model}" unless model == "pal"
 
       Vic20.new(ram: ram || :unexpanded)
     end
     private_class_method :vic20
+
+    def self.c128(model, sid_model, mode) = C128.new(model:, sid_model:, mode:)
+    private_class_method :c128
+
+    def self.vic20_for(media, model, ram)
+      unless media.nil?
+        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
+        raise Unsupported, "doesn't go in a VIC-20" if unsupported
+
+        unless ram
+          ram = Media::Vic20Media.ram_for(media)
+          yield "RAM expansion: #{ram}"
+        end
+      end
+      build(:vic20, model:, ram:)
+    end
+    private_class_method :vic20_for
+
+    def self.c64_media?(media)
+      return false if media.nil? || !File.file?(media)
+
+      extension = File.extname(media).downcase
+      return true if extension == ".sid"
+      return false unless %w[.prg .p00].include?(extension)
+
+      [Media::BASIC_START, Media::BASIC_START - 1].include?(Storage::P00.load_address(media))
+    end
+    private_class_method :c64_media?
   end
 end

data/lib/badline/media/boot_disk.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A C128 boot disk. At power-on the C128 KERNAL reads track 1, sector 0
+    # of the disk in device 8 and runs it when it starts with "CBM", as boot
+    # games have it. The 1581's DOS first loads and runs a USR file named
+    # COPYRIGHT CBM 86 when the disk has one, which is how CP/M's 1581 disks
+    # hand the KERNAL their boot sector, so a .d81 with that file boots too.
+    #
+    # On a C128 in C128 mode a boot disk goes in a true drive, a 1581 for a
+    # .d81 and the C128D's 1571 otherwise, and nothing is typed, so the
+    # KERNAL boots it. Other disks, and other machines, keep the traps and
+    # the autostart.
+    module BootDisk
+      SIGNATURE = "CBM".bytes.freeze
+      AUTO_BOOT = "copyright cbm 86"
+      TYPES = Extensions.of(%i[disk])
+
+      class << self
+        def takes?(computer, path)
+          computer.family == :c128 && computer.mode == :c128 && boot?(path)
+        end
+
+        # Puts a disk that boots on the computer in a true drive as device
+        # 8, write-protected with `disk: { read_only: true }`, for the KERNAL
+        # to boot at power-on, and says so. Nil for any other disk.
+        def attach(computer, path, disk: {}, **)
+          return unless takes?(computer, path)
+
+          read_only = disk.fetch(:read_only, false)
+          "#{TrueDrive.insert(computer, path, read_only:)}, to boot at power-on"
+        end
+
+        # Whether the disk image at path boots: its boot sector, or on a
+        # .d81 the 1581's auto-boot file.
+        def boot?(path)
+          type = File.extname(path).downcase
+          return false unless TYPES.include?(type) && File.file?(path)
+
+          image = Media.open_storage(path, { read_only: true })
+          block = image.read_block(1, 0)
+          return true if block && block[0, 3] == SIGNATURE
+
+          type == ".d81" && !image.read_file(AUTO_BOOT, type: :usr).nil?
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/disk_list.rb

@@ -11,9 +11,9 @@ module Badline
       # A list naming no disk image that's there.
       class Error < ArgumentError; end
 
-      EXTENSIONS = %w[.m3u .vfl].freeze
+      EXTENSIONS = Extensions.of(%i[disk_list])
 
-      def self.list?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+      def self.list?(path) = Extensions.kind(path) == :disk_list
 
       # The disk `path` puts in the drive: a list's first disk, or the
       # path itself.
@@ -32,7 +32,7 @@ module Badline
         found = []
         entries(list).each do |entry|
           disk = entry.start_with?("/") ? entry : File.join(directory, entry)
-          found << disk if DiskSet::EXTENSIONS.include?(File.extname(disk).downcase) && File.file?(disk)
+          found << disk if Extensions::DISKS.include?(File.extname(disk).downcase) && File.file?(disk)
         end
         found
       end

data/lib/badline/media/disk_set.rb

@@ -13,7 +13,7 @@ module Badline
     # ahead of the names.
     module DiskSet
       KINDS = %w[disk disc side part].freeze
-      EXTENSIONS = %w[.d64 .d71 .d81 .g64].freeze
+      EXTENSIONS = Extensions::DISKS
 
       # The paths of the set's disks in order, or just `path` when it
       # belongs to none. A list's set is the disks it lists.

data/lib/badline/media/extensions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # The kind of medium each file extension names, which every check of a
+    # path's extension reads. A file with any other extension is a program.
+    # It loads on its own, for Options.
+    #
+    # - :disk, a disk image that the traps mount and a true drive reads
+    # - :gcr, a disk's raw GCR, which only a true drive reads
+    # - :archive, a .t64, which the traps mount read-only
+    # - :tape, :cartridge and :tune
+    # - :disk_list, a list of the disks of a set (DiskList)
+    module Extensions
+      KINDS = {
+        ".d64" => :disk, ".d71" => :disk, ".d81" => :disk, ".g64" => :gcr, ".g71" => :gcr, ".t64" => :archive,
+        ".tap" => :tape, ".crt" => :cartridge, ".sid" => :tune, ".m3u" => :disk_list, ".vfl" => :disk_list
+      }.freeze
+
+      # The kind of the medium at `path`, by its extension.
+      def self.kind(path) = KINDS.fetch(File.extname(path).downcase, :program)
+
+      # The extensions of the kinds given.
+      def self.of(kinds) = KINDS.keys.select { |extension| kinds.include?(KINDS[extension]) }.freeze
+
+      # Disk images, which a drive reads.
+      DISKS = of(%i[disk gcr])
+
+      # What goes in device 8 through the traps.
+      MOUNTABLE = of(%i[disk archive])
+    end
+  end
+end

data/lib/badline/media/not_disk.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A file that goes in device 8 but isn't a disk image or a directory.
+    class NotDisk < ArgumentError; end
+  end
+end

data/lib/badline/media/program.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A program loading into a C64 or a C128 once it has booted
+    # (Media.attach). The VIC-20 has its own (Vic20Basic).
+    module Program
+      class << self
+        # Loads the program where it says, and RUNs one that loads at the
+        # start of BASIC.
+        def load(computer, data, autostart:)
+          load_addr = computer.load_prg(data)
+          # Run only makes sense for programs at BASIC start, or a byte ahead
+          # of it, where BASIC keeps the zero before its first line. BASIC 7.0
+          # starts at $1C01 and keeps the end of its text at $1210.
+          start, text_end = computer.family == :c128 && computer.mode == :c128 ? [0x1c01, 0x1210] : [BASIC_START, 0x2d]
+          return unless autostart && (load_addr == start || load_addr == start - 1)
+
+          # The end of the program, where BASIC's variables start, and where
+          # the KERNAL's LOAD leaves its end address.
+          end_addr = load_addr + data.length - 2
+          [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+          computer.type_text("run\r")
+        end
+      end
+    end
+  end
+end