badline 0.3.0 → 0.4.1

data/lib/badline/audio/console.rb

@@ -5,70 +5,24 @@ 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
-
+    # The terminal of `badline-ruby --headless`, put in raw mode with
+    # io/console.
+    class Console < Terminal
       private
 
-      def close_input(seconds)
-        @closed = true
-        idle(seconds)
+      # Ctrl-C still raises Interrupt.
+      def raw!
+        mode = @input.console_mode
+        @input.raw!(intr: true)
+        mode
       end
 
-      def idle(seconds)
-        sleep(seconds)
-        []
+      def restore(mode)
+        @input.console_mode = mode
       end
 
-      def clock(seconds)
-        whole = seconds.floor
-        format("%<minutes>d:%<seconds>02d", minutes: whole / 60, seconds: whole % 60)
+      def readable?(seconds)
+        !@input.wait_readable(seconds).nil?
       end
     end
   end

data/lib/badline/audio/playback.rb

@@ -12,6 +12,9 @@ module Badline
     # real time lets the queue run dry and the audio stutters; `on_underrun`
     # hears about the first time.
     class Playback
+      # What a sink raises when the audio device won't open.
+      class DeviceError < StandardError; end
+
       AHEAD = 0.15
 
       def initialize(sink, ahead: AHEAD, sleeper: ->(seconds) { sleep(seconds) }, on_underrun: nil)

data/lib/badline/audio/sdl_sink.rb

@@ -4,98 +4,66 @@ module Badline
   module Audio
     # The host's audio device, fed through SDL's queue: mono signed 16-bit
     # samples go in at the device's rate and SDL plays them out behind us.
-    #
-    # ruby-sdl2 only wraps SDL_mixer, which can't stream raw samples, so the
-    # queue API is called through Fiddle on the libSDL2 the extension has
-    # already loaded.
     class SDLSink
-      class Error < StandardError; end
-
-      INIT_AUDIO = 0x10
-
-      AUDIO_S16SYS = [1].pack("s").getbyte(0) == 1 ? 0x8010 : 0x9010
-
-      ALLOW_FREQUENCY_CHANGE = 0x01
+      class Error < Playback::DeviceError; end
 
       # int freq; Uint16 format; Uint8 channels, silence; Uint16 samples,
       # padding; Uint32 size; then the callback and userdata pointers.
       SPEC_LAYOUT = "lSCCSSLQQ"
 
-      FUNCTIONS = {
-        SDL_InitSubSystem: [%i[uint32], :int],
-        SDL_QuitSubSystem: [%i[uint32], :void],
-        SDL_GetError: [[], :string],
-        SDL_OpenAudioDevice: [%i[pointer int pointer pointer int], :uint32],
-        SDL_CloseAudioDevice: [%i[uint32], :void],
-        SDL_PauseAudioDevice: [%i[uint32 int], :void],
-        SDL_QueueAudio: [%i[uint32 pointer uint32], :int],
-        SDL_GetQueuedAudioSize: [%i[uint32], :uint32],
-        SDL_ClearQueuedAudio: [%i[uint32], :void]
-      }.freeze
-
       attr_reader :rate
 
       # With `exact_rate` false SDL may pick the device's own rate instead,
       # which #rate then reports.
       def initialize(rate:, exact_rate: false, buffer: 1024)
         load_sdl
-        check(sdl(:SDL_InitSubSystem, INIT_AUDIO))
-        @device = open_device(rate, exact_rate ? 0 : ALLOW_FREQUENCY_CHANGE, buffer)
+        check(SDL::InitSubSystem.call(SDL::INIT_AUDIO))
+        @device = open_device(rate, exact_rate ? 0 : SDL::AUDIO_ALLOW_FREQUENCY_CHANGE, buffer)
       end
 
       def queue(samples)
         data = samples.pack("s*")
-        check(sdl(:SDL_QueueAudio, @device, data, data.bytesize))
+        check(SDL::QueueAudio.call(@device, data, data.bytesize))
       end
 
-      def queued_seconds = sdl(:SDL_GetQueuedAudioSize, @device).fdiv(2 * rate)
+      def queued_seconds = SDL::GetQueuedAudioSize.call(@device).fdiv(2 * rate)
 
-      def start = sdl(:SDL_PauseAudioDevice, @device, 0)
+      def start = SDL::PauseAudioDevice.call(@device, 0)
 
-      def pause = sdl(:SDL_PauseAudioDevice, @device, 1)
+      def pause = SDL::PauseAudioDevice.call(@device, 1)
 
-      def clear = sdl(:SDL_ClearQueuedAudio, @device)
+      def clear = SDL::ClearQueuedAudio.call(@device)
 
       def close
         return unless @device
 
-        sdl(:SDL_CloseAudioDevice, @device)
-        sdl(:SDL_QuitSubSystem, INIT_AUDIO)
+        SDL::CloseAudioDevice.call(@device)
+        SDL::QuitSubSystem.call(SDL::INIT_AUDIO)
         @device = nil
       end
 
       private
 
       def open_device(rate, allowed_changes, buffer)
-        wanted = [rate, AUDIO_S16SYS, 1, 0, buffer, 0, 0, 0, 0].pack(SPEC_LAYOUT)
+        wanted = [rate, SDL::AUDIO_S16SYS, 1, 0, buffer, 0, 0, 0, 0].pack(SPEC_LAYOUT)
         obtained = "\0".b * 32
-        device = sdl(:SDL_OpenAudioDevice, nil, 0, wanted, obtained, allowed_changes)
-        raise Error, sdl(:SDL_GetError) if device.zero?
+        device = SDL::OpenAudioDevice.call(nil, 0, wanted, obtained, allowed_changes)
+        raise Error, SDL.error if device.zero?
 
         @rate = obtained.unpack1("l")
         device
       end
 
-      def check(result)
-        raise Error, sdl(:SDL_GetError) if result.negative?
-
-        result
-      end
-
-      def sdl(name, *) = @functions.fetch(name).call(*)
-
       def load_sdl
-        require "fiddle"
-        require "sdl2"
-        @functions = FUNCTIONS.to_h do |name, (arguments, result)|
-          [name, Fiddle::Function.new(Fiddle::Handle::DEFAULT[name.to_s],
-                                      arguments.map { |type| fiddle_type(type) }, fiddle_type(result))]
-        end
+        require "badline/sdl"
+      rescue SDL::Error => e
+        raise Error, e.message
       end
 
-      def fiddle_type(type)
-        { uint32: Fiddle::TYPE_UINT32_T, int: Fiddle::TYPE_INT, void: Fiddle::TYPE_VOID,
-          pointer: Fiddle::TYPE_VOIDP, string: Fiddle::TYPE_CONST_STRING }.fetch(type)
+      def check(result)
+        raise Error, SDL.error if result.negative?
+
+        result
       end
     end
   end

data/lib/badline/audio/terminal.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # The terminal face of `--headless`: the tune's header, a status line
+    # redrawn in place, and single keypresses read without waiting for
+    # Return. Ctrl-C still interrupts. A subclass puts the terminal in raw
+    # mode with #raw! and #restore and waits for keys with #readable?:
+    # Console with io/console for badline-ruby, and Native::Console with
+    # stty and poll(2) for the native badline.
+    class Terminal
+      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"
+        mode = raw! if @input.tty?
+        yield
+      ensure
+        restore(mode) if mode
+        @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 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
+
+      # A subclass puts the terminal in raw mode and returns the mode to
+      # restore afterwards.
+      def raw! = nil
+
+      def restore(mode) = mode
+
+      # A subclass waits up to `seconds` for input and says whether any
+      # came.
+      def readable?(seconds)
+        sleep(seconds)
+        false
+      end
+
+      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

data/lib/badline/audio.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "badline/audio/options"
 require "badline/audio/pcm_writer"
 require "badline/audio/wav"
 require "badline/audio/aiff"
 require "badline/audio/bare_player"
 require "badline/audio/machine_player"
 require "badline/audio/renderer"
-require "badline/audio/sdl_sink"
 require "badline/audio/playback"
+require "badline/audio/sdl_sink"
 require "badline/audio/stream"
+require "badline/audio/terminal"
 require "badline/audio/console"
 require "badline/audio/jukebox"
 require "badline/audio/cli"

data/lib/badline/cartridge/geo_ram.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Badline
+  class Cartridge
+    # GEO-RAM: a RAM expansion on the expansion port, seen through a 256-byte
+    # window at $DE00-$DEFF. Two write-only registers pick the page the
+    # window shows: $DFFE selects one of the 64 pages of a 16K block, and
+    # $DFFF selects the block. As in VICE, the registers answer at every
+    # address from $DF80 up, even for $DFFE and odd for $DFFF, and the block
+    # number wraps at the number of blocks the RAM holds. Reads of I/O 2 are
+    # open bus. It leaves EXROM and GAME high, and RES clears both
+    # registers.
+    class GeoRAM < Cartridge
+      SIZES = [64, 128, 256, 512, 1024, 2048, 4096].freeze
+      BLOCK_SIZE = 0x4000
+      PAGE_MASK = 0x3f
+
+      attr_reader :size
+
+      # size is the RAM in kilobytes.
+      def initialize(size: 512)
+        raise ArgumentError, "Unsupported GEO-RAM size #{size}K" unless SIZES.include?(size)
+
+        @size = size
+        @block_mask = ((size * 1024) / BLOCK_SIZE) - 1
+        super(Storage::CRTFile::Image.new(hardware_type: nil, subtype: 0, exrom: 1, game: 1,
+                                          name: "GEO-RAM", chips: []))
+      end
+
+      def readable_io_pages
+        [0xde]
+      end
+
+      def peek(addr)
+        @ram_data[@window + (addr & 0xff)]
+      end
+
+      def poke(addr, value)
+        if addr <= 0xdeff
+          @ram_data[@window + (addr & 0xff)] = value
+        elsif addr >= 0xdf80
+          if addr.odd?
+            @block = value & @block_mask
+          else
+            @page = value & PAGE_MASK
+          end
+          @window = (@block * BLOCK_SIZE) + (@page * 0x100)
+        end
+      end
+
+      def reset
+        @block = @page = @window = 0
+      end
+
+      private
+
+      def install_chips(_chips)
+        @ram_data = Array.new(@size * 1024, 0)
+        reset
+      end
+    end
+  end
+end

data/lib/badline/cartridge.rb

@@ -26,6 +26,7 @@ require "badline/cartridge/atomic_power"
 require "badline/cartridge/final_cartridge3"
 require "badline/cartridge/retro_replay"
 require "badline/cartridge/kcs_power"
+require "badline/cartridge/geo_ram"
 
 module Badline
   class Cartridge

data/lib/badline/cia/interrupt_register.rb

@@ -8,7 +8,9 @@ module Badline
     class InterruptRegister
       attr_reader :status, :mask, :quiet
 
-      def initialize
+      # The 6526A is the faster of the two: see the rules below.
+      def initialize(model = :mos6526)
+        @fast = model == :mos6526a
         @mask = InterruptFlags.new([:timer_a, :timer_b, :alarm, :serial, :flag, 0, 0, 0])
         @status = InterruptFlags.new([:timer_a, :timer_b, :alarm, :serial, :flag, 0, 0, :interrupt])
         @pending = 0
@@ -32,37 +34,51 @@ module Badline
 
       def interrupted? = status.value >= 0x80
 
+      # Raises IR on this cycle.
+      def assert_now
+        status.interrupt = true
+        @pending = 0
+      end
+
       # Schedules IR to rise after delay cycles, keeping an earlier one.
       def assert!(delay = 1)
         @pending = @pending.positive? ? [@pending, delay].min : delay
         @quiet = false
       end
 
-      # Latch a source, pulling the interrupt line if it is armed.
+      # Latch a source, pulling the interrupt line if it is armed. The 6526
+      # raises IR a cycle after the flag. The 6526A raises it on the flag's
+      # own cycle, unless the ICR was read on the cycle before.
       def flag(source)
         bit = source_bit(source)
         @status.value |= bit
-        assert! if mask.value.anybits?(bit)
+        return unless mask.value.anybits?(bit)
+
+        @fast && @read_last_cycle.nil? ? assert_now : assert!
       end
 
       # The 6526 timer B bug: an underflow on the cycle after a read still
-      # raises the flag, but the next read drops it unseen.
+      # raises the flag, but the next read drops it unseen. The 6526A has
+      # no such bug.
       def timer_b_underflow!
-        @timer_b_bug = !@read_last_cycle.nil?
+        @timer_b_bug = !@fast && !@read_last_cycle.nil?
         flag(:timer_b)
       end
 
       # A read releases the interrupt line at once, and cancels an assert
-      # due on the next cycle, but on the 6526 its IR acknowledge lands a
-      # cycle late: the next cycle still reads IR set if it was set, or
-      # about to be.
+      # due on the next cycle, but its acknowledge lands a cycle late. On
+      # the 6526 that holds only IR: the next cycle still reads IR set if it
+      # was set, or about to be. The 6526A reads an IR about to rise as set
+      # at once, and holds every bit it read: the next cycle reads them all
+      # again, along with anything flagged since.
       def read
         status.timer_b = false if @timer_b_bug
         @timer_b_bug = false
         value = status.value
+        value |= 0x80 if @fast && @pending == 1
         @read = @pending == 1 ? value | 0x80 : value
         @quiet = false
-        value |= 0x80 if @read_last_cycle&.anybits?(0x80)
+        value |= held(@read_last_cycle) if @read_last_cycle
         status.value = 0x0
         @pending = 0
         value
@@ -76,7 +92,7 @@ module Badline
           @mask.value |= (value & 0x1f)
         end
         if mask.value.anybits?(status.value & 0x1f)
-          assert!(2) unless interrupted?
+          assert!(arm_delay) unless interrupted?
         elsif @pending == 1 && @read_two_cycles_ago
           # On the 6526, masking the pending source cancels the assert due
           # on the next cycle only while a read two cycles back is
@@ -87,6 +103,14 @@ module Badline
 
       private
 
+      # Arming a pending source raises IR two cycles later on the 6526,
+      # and one cycle later on the 6526A.
+      def arm_delay = @fast ? 1 : 2
+
+      # What a read on the cycle before still holds: IR on the 6526, and
+      # every bit it read on the 6526A.
+      def held(last) = @fast ? last : last & 0x80
+
       def source_bit(source)
         case source
         when :timer_a then 0x01

data/lib/badline/cia.rb

@@ -9,7 +9,11 @@ module Badline
   class CIA
     include Addressable
 
-    attr_reader :start, :control_a, :control_b, :peripheral, :serial
+    # The original NMOS 6526 of the breadbin C64, and the HMOS 6526A of the
+    # C64C, which differs from it only in its interrupt control register.
+    MODELS = %i[mos6526 mos6526a].freeze
+
+    attr_reader :start, :control_a, :control_b, :peripheral, :serial, :model
 
     def interrupt_status = @icr.status
 
@@ -43,9 +47,15 @@ module Badline
       @tb.latch = value
     end
 
-    def initialize(start: 0, peripheral: nil)
+    def initialize(start: 0, peripheral: nil, model: :mos6526, region: Region::PAL)
+      raise ArgumentError, "unknown CIA model #{model}" unless MODELS.include?(model)
+
       addressable_at(start, length: 2**8)
 
+      @model = model
+      @clock_hz = region.clock_hz
+      @mains_hz = region.mains_hz
+
       @peripheral = peripheral
       @port_b4_handler = nil
       @port_b4_high = true
@@ -63,8 +73,8 @@ module Badline
       @port_b4_driven_high = true
       @cnt_high = true
       @cnt_rise = false
-      @tod = TimeOfDay.new
-      @icr = InterruptRegister.new
+      @tod = TimeOfDay.new(clock_hz: @clock_hz, mains_hz: @mains_hz)
+      @icr = InterruptRegister.new(@model)
       @icr_status = @icr.status
       @control_a = ControlRegister.new(%i[start output out_mode run_mode load
                                           in_mode serial_mode clock_frequency])
@@ -223,10 +233,7 @@ module Badline
         else underflowed && @cnt_high
         end
       )
-      if underflowed
-        interrupt_status.timer_a = true
-        interrupt! if interrupt_control.timer_a?
-      end
+      @icr.flag(:timer_a) if underflowed
       @icr.timer_b_underflow! if @tb.underflowed
       underflowed
     end

data/lib/badline/computer.rb

@@ -7,6 +7,8 @@ module Badline
 
     attr_reader :address_bus, :cpu, :cycles
 
+    def region = address_bus.region
+
     def vic = address_bus.vic
 
     def cia1 = address_bus.cia1
@@ -29,8 +31,12 @@ module Badline
 
     def install_debug_register(&) = address_bus.install_debug_register(&)
 
-    def initialize(debug: false, sid_model: :mos6581)
-      @address_bus = AddressBus.new(sid_model:)
+    # The machine options (sid_model:, cia_model:, vic_model:, region: and
+    # ram_expansion:) configure the AddressBus. The region sets the clock,
+    # the VIC's raster and the mains frequency the CIAs' TOD clocks count.
+    # Only PAL runs as yet.
+    def initialize(debug: false, **machine)
+      @address_bus = AddressBus.new(**machine)
       @cpu = CPU.new(@address_bus, debug:)
       @vic = @address_bus.vic
       @vic.open_bus = -> { @address_bus.ram.peek(@cpu.program_counter) }
@@ -41,6 +47,7 @@ module Badline
       @cycles = 0
       @nmi_asserted = false
       @cartridge_nmi = false
+      @restore_pulse = false
       @freezing = false
       @freeze_writes = 0
       @init_handlers = []
@@ -94,10 +101,10 @@ module Badline
     end
 
     # The RES line reaches the CPU and its port, both CIAs, the SID, the
-    # cartridge port and, through the serial bus's RESET line, the drive.
-    # The VIC has no reset pin.
+    # cartridge port, a RAM expansion and, through the serial bus's RESET
+    # line, the drive. The VIC has no reset pin.
     def reset!
-      address_bus.reset_port!
+      address_bus.reset!
       @cia1.reset!
       @cia2.reset!
       @sid.reset!
@@ -123,15 +130,22 @@ module Badline
       address_bus.cartridge&.release_button
     end
 
-    # A disk swap keeps the drive's RAM, which only a drive reset clears.
+    # RESTORE isn't in the key matrix. It fires a one-shot that pulses the
+    # NMI line however long the key is held, modelled here as one cycle.
+    def press_restore
+      @restore_pulse = true
+    end
+
+    # Puts the storage in device 8. Mounting again swaps the disk at any
+    # point while the machine runs: the drive keeps its RAM, which only a
+    # drive reset clears, and its status.
     def mount(storage)
-      @drive_memory ||= KernalTrap::Drive::Memory.new
-      @drive = KernalTrap::Drive.new(storage, @drive_memory)
+      return @drive.insert(storage) if @drive
+
+      @drive = KernalTrap::Drive.new(storage)
       load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, drive: @drive)
       cpu.install_trap(KernalTrap::Load::ADDRESS) { load_trap.call }
       KernalTrap::Serial.new(cpu:, bus: address_bus, drive: @drive).install
-      return unless storage.respond_to?(:write_file)
-
       save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, drive: @drive)
       cpu.install_trap(KernalTrap::Save::ADDRESS) { save_trap.call }
     end
@@ -156,10 +170,11 @@ module Badline
 
     private
 
-    # The NMI line is wired-OR between CIA 2 and the cartridge, and the CPU
-    # takes an interrupt on its falling edge.
+    # The NMI line is wired-OR between CIA 2, the cartridge and the RESTORE
+    # key, and the CPU takes an interrupt on its falling edge.
     def drive_nmi
-      nmi = @cia2.interrupted? || @cartridge_nmi
+      nmi = @cia2.interrupted? || @cartridge_nmi || @restore_pulse
+      @restore_pulse = false
       @cpu.nmi = true if nmi && !@nmi_asserted
       @nmi_asserted = nmi
     end