badline 0.2.1 → 0.4.0

data/lib/badline/audio/bare_player.rb

@@ -8,6 +8,10 @@ module Badline
     # which is what makes this path about three times faster than the whole
     # machine.
     #
+    # Nothing on the rig ties it to PAL, so an NTSC tune gets an NTSC
+    # machine: 60 Hz frames, the NTSC KERNAL's timer and `$02a6`, and a
+    # clock of 1022727 Hz for the SID's output.
+    #
     # Calls go through a six-byte stub whose JSR operand the dispatch trap
     # rewrites:
     #
@@ -23,6 +27,11 @@ module Badline
       # 312 raster lines of 63 cycles.
       FRAME_CYCLES = 19_656
 
+      # 263 raster lines of 65 cycles.
+      NTSC_FRAME_CYCLES = 17_095
+
+      NTSC_CLOCK_HZ = 1_022_727
+
       # A tune's init routine is free to unpack itself, but not forever.
       INIT_LIMIT = 10_000_000
 
@@ -30,6 +39,11 @@ module Badline
       # second.
       KERNAL_TIMER = 0x4025
 
+      NTSC_KERNAL_TIMER = 0x4295
+
+      # The KERNAL's PAL/NTSC flag, 1 for PAL.
+      VIDEO_STANDARD = 0x02a6
+
       attr_reader :sid
 
       def initialize(tune, song: nil, sid_model: tune.sid_model)
@@ -39,7 +53,8 @@ module Badline
         # 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
+        @bus.poke(VIDEO_STANDARD, tune.ntsc? ? 0 : 1)
+        @bus.cia1.timer_a_latch = tune.ntsc? ? NTSC_KERNAL_TIMER : KERNAL_TIMER
         @cpu = CPU.new(@bus)
         @sid = @bus.sid
         @idle = false
@@ -67,12 +82,14 @@ module Badline
         cycles
       end
 
+      def clock_hz = @tune.ntsc? ? NTSC_CLOCK_HZ : TimeOfDay::CLOCK_HZ
+
       private
 
-      # A PAL frame, or for a CIA-timed song one period of CIA 1 timer A,
+      # A video 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)
+        return (@tune.ntsc? ? NTSC_FRAME_CYCLES : FRAME_CYCLES) unless @tune.cia_timed?(@song + 1)
 
         @bus.cia1.timer_a_latch + 1
       end

data/lib/badline/audio/cli.rb

@@ -2,19 +2,24 @@
 
 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.
+    # 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.
     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))
+      # 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.
+      def initialize(options, sink: nil, console: nil, out: $stdout, input: $stdin)
         @options = options
         @out = out
         @input = input
         @sink = sink
+        @console = console
         @lengths = {}
       end
 
@@ -39,7 +44,7 @@ module Badline
       def seconds = length(song)
 
       def length(song)
-        @lengths[song] ||= @options.seconds || songlength(song) || Options::FALLBACK_SECONDS
+        @lengths[song] ||= @options.seconds || songlength(song) || @options.fallback_seconds
       end
 
       def sid_model = @options.sid_model || tune.sid_model
@@ -57,9 +62,9 @@ module Badline
       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..."
+        @out.puts "Rendering #{seconds}s for the #{model_name} to #{@options.audio_out} at #{@options.rate} Hz..."
         started = now
-        renderer.render(@options.output) { |done| progress(done) }
+        renderer.render(@options.audio_out) { |done| progress(done) }
         report(now - started)
       end
 
@@ -81,7 +86,7 @@ module Badline
       end
 
       def play_interactively(sink)
-        console = Console.new(input: @input, output: @out)
+        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?) +
@@ -92,7 +97,7 @@ module Badline
 
       def open_sink
         @sink.call(rate: @options.rate, exact_rate: @options.rate_given?)
-      rescue SDLSink::Error => e
+      rescue Playback::DeviceError => e
         raise Error, "can't open the audio device: #{e.message}"
       end
 
@@ -124,7 +129,7 @@ module Badline
       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)
+                         path: @options.audio_out, elapsed:, speed: seconds / elapsed)
       end
 
       def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)

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/machine_player.rb

@@ -4,8 +4,8 @@ module Badline
   module Audio
     # Runs a tune on the whole machine, for the RSID tunes that install their
     # own interrupts and expect a booted C64 underneath. The tune goes in
-    # through the same stub `Media` uses and BASIC SYSes it; rendering starts
-    # when the CPU reaches that stub.
+    # the way `Media` puts it in: BASIC SYSes the driver stub, or RUNs a
+    # BASIC tune. Rendering starts when the CPU gets there.
     class MachinePlayer
       FRAME_CYCLES = BarePlayer::FRAME_CYCLES
 
@@ -22,12 +22,15 @@ module Badline
 
       def start
         @computer.on_init { inject }
-        @computer.cpu.install_trap(@tune.driver_address) { begin_playing }
+        @computer.cpu.install_trap(@tune.entry_address) { begin_playing }
         @computer.cycle! until @started || @computer.cycles > START_LIMIT
       end
 
       def sid = @computer.sid
 
+      # The machine is PAL whatever the tune asks for.
+      def clock_hz = TimeOfDay::CLOCK_HZ
+
       # Advances one PAL frame, or `budget` cycles if that is shorter, then
       # yields whatever the SID recorded over it. Returns the cycles advanced.
       def frame(budget, &)
@@ -41,13 +44,13 @@ module Badline
 
       def inject
         @computer.ram.write(@tune.load_address, @tune.data)
-        @computer.ram.write(@tune.driver_address, @tune.driver(song: @song))
-        @computer.type_text("sys#{@tune.driver_address}\r")
+        @tune.boot_memory(song: @song).each { |address, bytes| @computer.ram.write(address, bytes) }
+        @computer.type_text(@tune.boot_command)
         @injected = true
       end
 
       def begin_playing
-        return unless @injected
+        return if @started || !@injected
 
         @computer.sid.synthesize!
         @started = true

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/renderer.rb

@@ -60,7 +60,7 @@ module Badline
       # The cycles it takes to close exactly `total_samples` windows; the SID
       # records floor(cycles * rate / clock) of them.
       def total_cycles
-        ((total_samples * TimeOfDay::CLOCK_HZ) + @rate - 1) / @rate
+        ((total_samples * player.clock_hz) + @rate - 1) / @rate
       end
 
       def container_for(path)
@@ -71,13 +71,13 @@ module Badline
       end
 
       def each_frame
-        player.sid.record(rate: @rate, filter_chunk: @filter_chunk)
+        player.sid.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(TimeOfDay::CLOCK_HZ)
+          yield samples, (total - remaining).fdiv(player.clock_hz)
         end
       end
     end

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/stream.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # Plays a running machine's SID through a sink, for the window: #feed
+    # queues whatever the SID recorded since the last call, once a frame,
+    # and #pace holds the machine to the device's clock.
+    #
+    # The device starts once the queue holds `ahead` seconds. Below real time
+    # the queue runs dry, and the device then stops until it holds `ahead`
+    # again, so the sound stutters with silent gaps rather than slowing
+    # down; `on_underrun` hears about the first time. A frame that would
+    # take the queue past `limit` seconds, as an unpaced machine above real
+    # time makes, is dropped whole.
+    class Stream
+      AHEAD = 0.08
+      LIMIT = 0.25
+
+      attr_reader :underruns, :dropped
+
+      # What #pace reads the time from and sleeps on: #now and #sleep.
+      attr_writer :clock
+
+      def initialize(sink, sid, ahead: AHEAD, limit: LIMIT, on_underrun: nil)
+        @sink = sink
+        @sid = sid
+        @ahead = ahead
+        @limit = limit
+        @on_underrun = on_underrun
+        @clock = Clock.new
+        @next_frame = nil
+        @started = false
+        @muted = false
+        @underruns = 0
+        @dropped = 0
+        sid.record(rate: sink.rate)
+      end
+
+      def rate = @sink.rate
+
+      def muted? = @muted
+
+      def playing? = @started
+
+      # Muting drops the queue; unmuting fills it to `ahead` again before
+      # the device restarts.
+      def toggle_mute
+        @muted = !@muted
+        return unless @muted
+
+        halt
+        @sink.clear
+      end
+
+      def feed
+        samples = @sid.drain_samples
+        return if @muted || samples.empty?
+
+        queued = @sink.queued_seconds
+        return @dropped += samples.size if queued + samples.size.fdiv(rate) > @limit
+
+        underrun! if @started && queued.zero?
+        @sink.queue(samples)
+        start if @sink.queued_seconds >= @ahead
+      end
+
+      # Waits out the frame just run. While the device plays, that is until
+      # it has played the queue down to `ahead`, so the machine runs at the
+      # device's rate and the queue neither drifts dry nor grows. Muted or
+      # filling up, the clock paces frames `seconds` apart instead.
+      def pace(seconds)
+        return wait_for_device if playing?
+
+        now = @clock.now
+        @next_frame = now if @next_frame.nil? || @next_frame < now
+        @clock.sleep(@next_frame - now)
+        @next_frame += seconds
+      end
+
+      def close = @sink.close
+
+      private
+
+      def start
+        return if @started
+
+        @started = true
+        @sink.start
+      end
+
+      def wait_for_device
+        @next_frame = nil
+        while (excess = @sink.queued_seconds - @ahead).positive?
+          @clock.sleep([excess, 0.001].max)
+        end
+      end
+
+      def halt
+        @started = false
+        @sink.pause
+      end
+
+      def underrun!
+        @underruns += 1
+        @on_underrun&.call if @underruns == 1
+        halt
+      end
+
+      # The host's monotonic clock.
+      class Clock
+        def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        def sleep(seconds) = Kernel.sleep(seconds)
+      end
+    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,14 +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/easy_flash.rb

@@ -18,7 +18,10 @@ module Badline
     class EasyFlash < Cartridge
       BANKS = 64
       EAPI_OFFSET = 0x1800
-      EAPI = File.binread(File.expand_path("../roms/eapi/eapi-am29f040-14", __dir__)).bytes.drop(2).freeze
+
+      def self.eapi
+        @eapi ||= ROM.read("eapi/eapi-am29f040-14").drop(2).freeze
+      end
 
       attr_reader :low_flash, :high_flash
 
@@ -110,7 +113,8 @@ module Badline
       def install_eapi(high)
         return unless high[EAPI_OFFSET, 4] == "eapi".bytes
 
-        high[EAPI_OFFSET, EAPI.length] = EAPI
+        eapi = EasyFlash.eapi
+        high[EAPI_OFFSET, eapi.length] = eapi
       end
 
       def place(flash_data, offset, bytes)

data/lib/badline/cartridge/epyx_fastload.rb

@@ -61,7 +61,7 @@ module Badline
       end
 
       def install_chips(chips)
-        @rom = banks_from(chips).first.compact.first
+        @rom = banks_from(chips).first.compact.first || EMPTY_BANK
         @roml = Window.new(self, @rom)
         @discharged_at = 0
         self.mode = :rom8k