badline 0.9.0 → 0.10.0

data/lib/badline/frontend/boot.rb

@@ -21,7 +21,7 @@ module Badline
       rescue Media::TrueDrive::Error, Storage::SIDFile::FormatError, Storage::T64::FormatError,
              Storage::TAP::FormatError, Storage::CRTFile::FormatError, Storage::G64Image::FormatError,
              Cartridge::UnsupportedTypeError, Snapshot::FormatError, Media::DiskList::Error,
-             Datasette::Missing => e
+             Datasette::Missing, Unsupported => e
         warn "#{options.program}: #{options.media_path}: #{e.message}"
         return 1
       end
@@ -45,14 +45,11 @@ module Badline
 
     # A new machine built from the options, with `media`, if not nil,
     # attached and started as the command line does, its disk writable if
-    # `writable`. The model gives the chips, and a .sid tune or --sid the
-    # SID.
+    # `writable`. The family and model give the machine, and a .sid tune
+    # or --sid the SID. The VIC-20 raises Unsupported for a .sid
+    # tune.
     def self.start(options, media, writable)
-      model = Model.named(options.model)
-      computer = Computer.new(vic_model: model.vic_model, cia_model: model.cia_model,
-                              sid_model: options.sid_model || Media.sid_model(media, otherwise: model.sid_model),
-                              region: model.region, reu: options.reu, kernal: model.kernal,
-                              datasette: model.datasette)
+      computer = options.family == :vic20 ? vic20(options, media) : c64(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
@@ -60,5 +57,33 @@ module Badline
       end
       computer
     end
+
+    def self.c64(options, media)
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
+    end
+
+    # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
+    # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
+    # media a VIC-20 doesn't take.
+    def self.vic20(options, media)
+      ram = options.ram
+      unless media.nil?
+        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
+        raise Unsupported, "doesn't go in a VIC-20" if unsupported
+
+        ram ||= vic20_ram(media)
+      end
+      Machine.build(:vic20, model: options.model, ram:)
+    end
+
+    def self.vic20_ram(media)
+      ram = Media::Vic20Media.ram_for(media)
+      puts "RAM expansion: #{ram}"
+      ram
+    end
+
+    # Media the machine the options name doesn't take.
+    class Unsupported < ArgumentError; end
   end
 end

data/lib/badline/frontend/controls.rb

@@ -4,11 +4,11 @@ module Badline
   module Frontend
     # Routes host input to the machine. Two settings decide where it goes:
     #
-    # - The keys: every host key goes to the C64 keyboard, or, as Tab
+    # - The keys: every host key goes to the machine's keyboard, or, as Tab
     #   switches, the arrow cluster and space drive one joystick and WASD
     #   and left shift the other. The arrows start on joystick 2, and
-    #   #swap_ports swaps them.
-    # - A pot device the pause menu plugs into a control port: a 1351
+    #   #swap_ports swaps them. The VIC-20's one joystick takes both.
+    # - A pot device the pause menu plugs into a C64 control port: a 1351
     #   mouse or a pair of paddles, which the host mouse drives. Motion
     #   turns the paddles or moves the mouse, and the host's left and right
     #   buttons go to whichever lines the device puts them on.
@@ -65,7 +65,7 @@ module Badline
       # The title bar's tag for the settings, empty for the keyboard alone.
       def tag
         tags = []
-        tags << "JOY #{@arrows_port}" if @joystick
+        tags << (@computer.family == :vic20 ? "JOY" : "JOY #{@arrows_port}") if @joystick
         tags << TAGS[POTS.index(@pot)] if pot_device?
         tags.join(", ")
       end
@@ -105,7 +105,7 @@ module Badline
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
       def c64_key(key, down)
         if key == :restore
-          @computer.press_restore if down
+          down ? @computer.press_restore : @computer.release_restore
         else
           down ? @computer.keyboard.press(key) : @computer.keyboard.release(key)
         end
@@ -113,9 +113,15 @@ module Badline
 
       def paddles? = POTS.index(@pot) >= 3
 
-      # A fresh pot device on its port, and none on the other.
+      # A fresh pot device on its port, and none on the other. A machine
+      # without the ports takes none.
       def attach_pot_device
         ports = @computer.control_ports
+        if ports.nil?
+          @pot = :none
+          return
+        end
+
         ports.device1 = nil
         ports.device2 = nil
         return unless pot_device?

data/lib/badline/frontend/drive_led.rb

@@ -8,8 +8,6 @@ module Badline
     class DriveLed
       WIDTH = 12
       HEIGHT = 4
-      LEFT = Screen::WIDTH - WIDTH - 8
-      TOP = Screen::HEIGHT - HEIGHT - 6
 
       LIT = [0xff, 0x20, 0x20].freeze
       DARK = [0x40, 0x00, 0x00].freeze
@@ -20,11 +18,12 @@ module Badline
         drive ? new(drive) : nil
       end
 
-      # Sets SDL.led_rect to where the LED goes.
-      def self.place
+      # Sets SDL.led_rect to where the LED goes on a screen `width` by
+      # `height`.
+      def self.place(width, height)
         rect = SDL.led_rect
-        SDL.rect_x(rect, LEFT)
-        SDL.rect_y(rect, TOP)
+        SDL.rect_x(rect, width - WIDTH - 8)
+        SDL.rect_y(rect, height - HEIGHT - 6)
         SDL.rect_w(rect, WIDTH)
         SDL.rect_h(rect, HEIGHT)
       end
@@ -37,10 +36,10 @@ module Badline
 
       def color = lit? ? LIT : DARK
 
-      # Fills the LED's rectangle in its colour, then puts back the black
-      # that RenderClear clears with.
-      def draw(renderer)
-        DriveLed.place
+      # Fills the LED's rectangle on a screen `width` by `height` in its
+      # colour, then puts back the black that RenderClear clears with.
+      def draw(renderer, width, height)
+        DriveLed.place(width, height)
         rgb = color
         SDL.SDL_SetRenderDrawColor(renderer, rgb[0], rgb[1], rgb[2], 255)
         SDL.SDL_RenderFillRect(renderer, SDL.led_rect)

data/lib/badline/frontend/frame_rate.rb

@@ -31,10 +31,10 @@ module Badline
 
       attr_reader :base_cycles, :seconds, :refresh, :trim
 
-      # One frame of the region's raster.
-      def self.machine(region)
-        cycles = region.cycles_per_line * region.lines_per_frame
-        new(cycles, cycles.to_f / region.clock_hz, 0, region.clock_hz)
+      # One frame of the machine's raster, from its Timing.
+      def self.machine(timing)
+        cycles = timing.cycles_per_line * timing.lines_per_frame
+        new(cycles, cycles.to_f / timing.clock_hz, 0, timing.clock_hz)
       end
 
       def self.display(refresh, clock_hz)

data/lib/badline/frontend/machine_window.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The emulator's SDL window, its renderer and the streaming texture a
+    # Screen's pixels go into. The renderer's logical size is the screen's,
+    # with each of its pixels `pixel_width` square pixels wide, so the
+    # picture keeps the machine's aspect while the menu and the drive LED
+    # draw in square pixels over it. The window opens at SCALE times that.
+    class MachineWindow
+      SCALE = 2
+      TITLE = "Badline"
+
+      # The logical size, in square pixels.
+      attr_reader :width, :height
+
+      attr_reader :renderer, :texture
+
+      # Opens the window for `screen`, presenting in step with the display
+      # when `vsync`.
+      def initialize(screen, pixel_width, vsync:)
+        abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
+
+        SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
+        SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
+        measure(screen, pixel_width)
+        @window = SDL.SDL_CreateWindow(
+          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED, @width * SCALE, @height * SCALE,
+          SDL::WINDOW_RESIZABLE
+        )
+        flags = SDL::RENDERER_ACCELERATED
+        flags |= SDL::RENDERER_PRESENTVSYNC if vsync
+        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
+        create_texture
+      end
+
+      # The refresh rate of the display the window is on, in Hz.
+      def refresh_rate
+        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
+        SDL.mode_refresh(SDL.display_mode)
+      end
+
+      # Fits the texture, the logical size and the window to another
+      # machine's screen, unless it measures the same.
+      def fit(screen, pixel_width)
+        before = [@width, @height, @texture_width]
+        measure(screen, pixel_width)
+        return if before == [@width, @height, @texture_width]
+
+        SDL.SDL_DestroyTexture(@texture)
+        create_texture
+        SDL.SDL_SetWindowSize(@window, @width * SCALE, @height * SCALE)
+      end
+
+      def upload(screen)
+        SDL.SDL_UpdateTexture(@texture, nil, screen.pixels, screen.row_bytes)
+      end
+
+      # Titles the window, TITLE followed by `tags` in brackets.
+      def title(tags)
+        SDL.SDL_SetWindowTitle(@window, ([TITLE] + tags.map { |tag| "[#{tag}]" }).join(" "))
+      end
+
+      def close
+        SDL.SDL_DestroyTexture(@texture)
+        SDL.SDL_DestroyRenderer(@renderer)
+        SDL.SDL_DestroyWindow(@window)
+        SDL.SDL_Quit
+      end
+
+      private
+
+      def measure(screen, pixel_width)
+        @texture_width = screen.width
+        @width = screen.width * pixel_width
+        @height = screen.height
+      end
+
+      def create_texture
+        SDL.SDL_RenderSetLogicalSize(@renderer, @width, @height)
+        @texture = SDL.SDL_CreateTexture(
+          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, @texture_width, @height
+        )
+      end
+    end
+  end
+end

data/lib/badline/frontend/menu_media.rb

@@ -4,17 +4,17 @@ module Badline
   module Frontend
     # What the pause menu puts in the machine and takes out: disks, tapes
     # and cartridges, whether disks are writable, which carries over from
-    # one disk to the next, and the disk's set, which PREVIOUS and NEXT step
-    # through: the .m3u or .vfl list it came from, while that lists it, or
-    # the set DiskSet finds. It keeps what last went wrong for the page to
-    # show.
+    # one disk to the next, and the set of the disk in device 8, which
+    # PREVIOUS and NEXT step through: the .m3u or .vfl list it came from,
+    # while that lists it, or the set DiskSet finds. It keeps what last went
+    # wrong for the page to show.
     class MenuMedia
-      attr_reader :disk_path, :problem
+      attr_reader :problem
       attr_writer :computer
 
-      # Starts on the disk the command line's `media_path` put in.
+      # Takes the disk set from the command line's `media_path` when it's a
+      # list.
       def initialize(media_path, writable)
-        @disk_path = PauseMenu.disk_path(media_path)
         @list = Media::DiskList.list?(media_path) ? media_path : ""
         @writable = writable
         @set_path = ""
@@ -25,26 +25,40 @@ module Badline
 
       def writable? = @writable
 
+      # The expanded path of the disk in device 8, however it went in, or
+      # an empty one.
+      def disk_path
+        drive = @computer.drive1541
+        unless drive.nil?
+          disk = drive.disk
+          return disk.nil? ? "" : disk.path.to_s
+        end
+
+        path = @computer.mounted_path
+        path.empty? ? path : File.expand_path(path)
+      end
+
       def inserted?
         drive = @computer.drive1541
         drive.nil? ? @computer.mounted? : !drive.disk.nil?
       end
 
       # Puts a disk in device 8 or a tape in the datasette, `kind` :disk or
-      # :tape. A list puts its first disk in.
+      # :tape, and says whether it went in. A list puts its first disk in.
       def insert(kind, path)
         @problem = ""
         if kind == :disk
           disk = Media::DiskList.disk(path)
           Media.insert_disk(@computer, disk, read_only: !@writable)
           list(path)
-          @disk_path = disk
         else
           @computer.datasette.insert(Storage::TAP.new(path))
         end
+        true
       rescue ArgumentError, SystemCallError, Storage::TAP::FormatError, Storage::T64::FormatError,
              Storage::G64Image::FormatError => e
         @problem = e.message
+        false
       end
 
       # Does what the Drive page's :eject_disk, :previous_disk, :next_disk,
@@ -61,24 +75,25 @@ module Badline
       def eject_disk
         drive = @computer.drive1541
         drive.nil? ? @computer.unmount : drive.insert(nil)
-        @disk_path = ""
       end
 
       # Sets whether disks are writable, for the disk in the drive too,
       # which goes in again as the notch now says.
       def writable(writable)
         @writable = writable
-        insert(:disk, @disk_path) if inserted? && !@disk_path.empty?
+        path = disk_path
+        insert(:disk, path) if inserted? && !path.empty?
       end
 
       # The disks of the set the disk in the drive belongs to.
       def disk_set
-        return [] if @disk_path.empty?
+        path = disk_path
+        return [] if path.empty?
 
-        unless @set_path == @disk_path
-          listed = @list.empty? ? [] : Media::DiskList.disks(@list)
-          @set = listed.include?(@disk_path) ? listed : Media::DiskSet.around(@disk_path)
-          @set_path = @disk_path
+        unless @set_path == path
+          listed = @list.empty? ? [] : expanded(Media::DiskList.disks(@list))
+          @set = listed.include?(path) ? listed : expanded(Media::DiskSet.around(path))
+          @set_path = path
         end
         @set
       end
@@ -87,7 +102,7 @@ module Badline
       # drive, if there is one.
       def step_disk(step)
         set = disk_set
-        index = set.index(@disk_path)
+        index = set.index(disk_path)
         return if index.nil? || !(index + step).between?(0, set.size - 1)
 
         insert(:disk, set[index + step])
@@ -105,14 +120,23 @@ module Badline
       end
 
       # What a save of the machine is named after: the cartridge, the disk,
-      # the tape, or BASIC, without the bracketed parts of a file's name.
+      # the tape, or BASIC, without the bracketed parts of a file's name. A
+      # VIC-20's are named after its disk, or else the machine.
       def game_name
-        name = cartridge_name
-        name = File.basename(@disk_path, File.extname(@disk_path)) if name.empty? && !@disk_path.empty?
-        tape = @computer.datasette.tape
-        name = File.basename(tape.path, File.extname(tape.path)) if name.empty? && !tape.nil?
+        vic20 = @computer.family == :vic20
+        name = vic20 ? "" : cartridge_name
+        disk = disk_path
+        name = File.basename(disk, File.extname(disk)) if name.empty? && !disk.empty?
+        name = tape_name if name.empty? && !vic20
         name = name.sub(/\s*[(\[].*\z/, "").strip
-        name.empty? ? "BASIC" : name
+        return name unless name.empty?
+
+        vic20 ? "VIC-20" : "BASIC"
+      end
+
+      def tape_name
+        tape = @computer.datasette.tape
+        tape.nil? ? "" : File.basename(tape.path, File.extname(tape.path))
       end
 
       # The name the cartridge in the expansion port gives itself, or an
@@ -133,7 +157,6 @@ module Badline
       def start(options, path)
         @problem = ""
         computer = Frontend.start(options, path, @writable)
-        @disk_path = PauseMenu.disk_path(path)
         list(path)
         computer
       rescue ArgumentError, SystemCallError, Media::TrueDrive::Error, Storage::SIDFile::FormatError,
@@ -152,6 +175,8 @@ module Badline
         @list = path
         @set_path = ""
       end
+
+      def expanded(paths) = paths.map { |path| File.expand_path(path) }
     end
   end
 end

data/lib/badline/frontend/menu_pages.rb

@@ -7,6 +7,8 @@ module Badline
     # row for each thing to do, a setting showing its value on the right,
     # which a press steps on.
     class MenuPages
+      include MenuPorts
+
       TEXT = PauseMenu::TEXT
       DIM = PauseMenu::DIM
       LINE = 12
@@ -16,10 +18,11 @@ module Badline
       WARNING = 0xff7a6b
       RECENT = %i[recent0 recent1 recent2 recent3 recent4 recent5 recent6 recent7].freeze
 
-      PORT_DEVICES = %i[joystick mouse paddles].freeze
-      PORT_NAMES = %w[JOY MOUSE PADDLES].freeze
-      PORT_ACTIONS = [%i[port1_joystick port1_mouse port1_paddles], %i[port2_joystick port2_mouse port2_paddles]].freeze
-      POTS = [%i[none mouse1 paddles1], %i[none mouse2 paddles2]].freeze
+      SID_MODELS = %i[mos6581 mos8580].freeze
+      RAM_NAMES = {
+        unexpanded: "", "3k": "3K", "8k": "8K", "16k": "16K", "24k": "24K", "32k": "32K",
+        all: "35K, ALL BLOCKS"
+      }.freeze
 
       # The disks, tapes and cartridges the pages put in and take out.
       attr_reader :media
@@ -75,7 +78,7 @@ module Badline
         when :keys_c64, :keys_joystick then keys(action == :keys_c64 ? :keyboard : :joystick)
         when :swap then @controls.swap_ports
         when :sound_on, :mute then @sound.toggle_mute unless @sound.muted? == (action == :mute)
-        when :sid6581, :sid8580 then @computer.sid.model = action == :sid8580 ? :mos8580 : :mos6581
+        when :sid6581, :sid8580 then @computer.sound_source.model = action == :sid8580 ? :mos8580 : :mos6581
         when :reset then @computer.reset!
         when :power_cycle then @computer.power_cycle!
         else pick_port(action)
@@ -84,6 +87,14 @@ module Badline
 
       private
 
+      def vic20? = @computer.family == :vic20
+
+      # Says in the dim colour that the VIC-20 hasn't got what the page
+      # shows.
+      def note
+        @painter.text(@left, @top, "NOT ON THE VIC-20 YET", DIM)
+      end
+
       def draw_drive
         media = @media
         inserted = media.inserted?
@@ -114,6 +125,8 @@ module Badline
       end
 
       def draw_expansion
+        return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
+
         cartridge = @computer.address_bus.cartridge
         info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
         row("INSERT...", :insert_cartridge)
@@ -125,27 +138,17 @@ module Badline
         info("RAM EXPANSION", "REU, #{@reu_kb} KB")
       end
 
-      def draw_ports
-        toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
-        toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
-        joystick = @controls.joystick_mode?
-        toggle("KEYS", :keys, [%w[C64 JOYSTICK], %i[keys_c64 keys_joystick], joystick ? 1 : 0])
-        return unless joystick
-
-        row("SWAP JOYSTICKS", :swap)
-        skip
-        arrows = @controls.arrows_port
-        info("ARROWS, SPACE", "PORT #{arrows}")
-        info("WASD, LEFT SHIFT", "PORT #{3 - arrows}")
-      end
-
+      # The SID's model is a setting, and other sound chips have none.
       def draw_sound
         if @sound.on?
           toggle("OUTPUT", :output, [%w[ON MUTED], %i[sound_on mute], @sound.muted? ? 1 : 0])
         else
           info("OUTPUT", "OFF")
         end
-        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], @computer.sid.model == :mos8580 ? 1 : 0])
+        model = @computer.sound_source.model
+        return unless SID_MODELS.include?(model)
+
+        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
       end
 
       # Saving now and by name, loading a named save, and the quicksaves
@@ -195,26 +198,6 @@ module Badline
       def skip
         @top += LINE
       end
-
-      def keys(mode) = @controls.joystick_mode = mode == :joystick
-
-      def port_device(port)
-        index = POTS[port - 1].index(@controls.pot)
-        index.nil? ? :joystick : PORT_DEVICES[index]
-      end
-
-      # Plugs the device a choice such as :port1_mouse names into its port.
-      def pick_port(action)
-        index = PORT_ACTIONS[0].include?(action) ? 0 : 1
-        choice = PORT_ACTIONS[index].index(action)
-        plug_device(index + 1, choice) unless choice.nil? || choice == PORT_DEVICES.index(port_device(index + 1))
-      end
-
-      # Plugs PORT_DEVICES[choice] into the port. A joystick there takes out
-      # the pot device.
-      def plug_device(port, choice)
-        @controls.plug(POTS[port - 1][choice])
-      end
     end
   end
 end

data/lib/badline/frontend/menu_ports.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's PORTS page, which MenuPages draws: what each C64
+    # control port has plugged in, a joystick or a pot device, and whether
+    # the keys type or drive the joysticks. The VIC-20 has one port, a
+    # joystick's.
+    module MenuPorts
+      PORT_DEVICES = %i[joystick mouse paddles].freeze
+      PORT_NAMES = %w[JOY MOUSE PADDLES].freeze
+      PORT_ACTIONS = [%i[port1_joystick port1_mouse port1_paddles], %i[port2_joystick port2_mouse port2_paddles]].freeze
+      POTS = [%i[none mouse1 paddles1], %i[none mouse2 paddles2]].freeze
+
+      private
+
+      def draw_ports
+        return draw_vic20_port if @computer.family == :vic20
+
+        toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
+        toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
+        return unless draw_keys("C64")
+
+        row("SWAP JOYSTICKS", :swap)
+        skip
+        arrows = @controls.arrows_port
+        info("ARROWS, SPACE", "PORT #{arrows}")
+        info("WASD, LEFT SHIFT", "PORT #{3 - arrows}")
+      end
+
+      # The VIC-20's one joystick, which both sets of keys drive.
+      def draw_vic20_port
+        return unless draw_keys("VIC-20")
+
+        skip
+        info("ARROWS, SPACE", "JOYSTICK")
+        info("WASD, LEFT SHIFT", "JOYSTICK")
+      end
+
+      # The toggle between the keyboard named and the joysticks, and
+      # whether the keys drive the joysticks.
+      def draw_keys(keyboard)
+        joystick = @controls.joystick_mode?
+        toggle("KEYS", :keys, [[keyboard, "JOYSTICK"], %i[keys_c64 keys_joystick], joystick ? 1 : 0])
+        joystick
+      end
+
+      def keys(mode) = @controls.joystick_mode = mode == :joystick
+
+      def port_device(port)
+        index = POTS[port - 1].index(@controls.pot)
+        index.nil? ? :joystick : PORT_DEVICES[index]
+      end
+
+      # Plugs the device a choice such as :port1_mouse names into its port.
+      def pick_port(action)
+        index = PORT_ACTIONS[0].include?(action) ? 0 : 1
+        choice = PORT_ACTIONS[index].index(action)
+        plug_device(index + 1, choice) unless choice.nil? || choice == PORT_DEVICES.index(port_device(index + 1))
+      end
+
+      # Plugs PORT_DEVICES[choice] into the port. A joystick there takes out
+      # the pot device.
+      def plug_device(port, choice)
+        @controls.plug(POTS[port - 1][choice])
+      end
+    end
+  end
+end

data/lib/badline/frontend/pacer.rb

@@ -13,7 +13,8 @@ module Badline
     # SAFETY, so no samples are dropped. #measure fits the frames to the
     # rate the display presents at, measured over the whole run.
     #
-    # Without vsync, a frame is one of the machine's frames, 20 ms on PAL.
+    # Without vsync, a frame is one of the machine's frames, as its Timing
+    # gives them, 20 ms on PAL.
     # With the sound playing, #wait lasts until the audio queue is down to
     # Sound::AHEAD; otherwise it waits out the rest of the frame.
     class Pacer
@@ -23,12 +24,12 @@ module Badline
 
       attr_reader :rate
 
-      def initialize(paced:, vsync:, verbose:, region: Region::PAL)
+      def initialize(paced:, vsync:, verbose:, timing:)
         @paced = paced
         @verbose = verbose
         @vsync = paced && vsync
-        @region = region
-        @rate = FrameRate.machine(region)
+        @timing = timing
+        @rate = FrameRate.machine(timing)
         @deadline = 0.0
         @measured_frames = 0
         @measured_seconds = 0.0
@@ -39,7 +40,7 @@ module Badline
       # Fits the frames to the display's refresh rate, once the window has
       # been opened with vsync.
       def fit(refresh)
-        @rate = FrameRate.display(refresh, @region.clock_hz)
+        @rate = FrameRate.display(refresh, @timing.clock_hz)
         puts "Display #{@rate.refresh} Hz, vsync: #{@rate.base_cycles} cycles a frame" if @verbose
       end