badline 0.12.1 → 0.14.0

data/lib/badline/drives/model1581.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "badline/drives/engine"
+require "badline/drives/model1581/track"
+require "badline/drives/model1581/track_bytes"
+require "badline/drives/model1581/disk"
+require "badline/drives/model1581/mechanism"
+require "badline/drives/model1581/wd1772"
+require "badline/drives/model1581/cpu"
+require "badline/drives/model1581/serial_port"
+require "badline/drives/model1581/bus"
+require "badline/drives/model1581/keyed_state"
+require "badline/drives/model1581/slot"
+
+module Badline
+  module Drives
+    # The 1581 3.5" disk drive: a 6502 at 2 MHz with 8 KB of RAM, an 8520
+    # for the serial bus and the mechanism's lines, a WD1772 for the MFM
+    # disk, and the DOS in 32 KB of ROM (1581 Service Manual). Drives::Engine::Core
+    # clocks it against the host.
+    #
+    # The 8520's port B faces the serial bus as VIA 1's does on the 1541,
+    # with the same bits, and ATN reaches its FLAG pin, so ATN going low
+    # interrupts the DOS. Its SP and CNT carry fast serial on DATA and SRQ,
+    # through buffers PB5 turns round (Drives::Engine::FastSerial), as the 1571's
+    # 6526 does. The ATN acknowledge differs: a NAND of ATN IN and
+    # ATN ACK pulls DATA, so DATA follows ATN only while ATN is asserted
+    # and PB4 is high, where the 1541's XOR pulls it whenever the two
+    # differ (Drives::SerialBus::DRIVE_ATN_GATED). Port A drives the motor, the side
+    # and the two LEDs, and reads the switches and the mechanism's /RDY and
+    # /DISK CHNG (SerialPort). Timer B interrupts every 10 ms for the
+    # controller code that runs the WD1772.
+    #
+    # The 8520 differs from the 6526 in its TOD, a 24-bit binary event
+    # counter where the 6526 keeps a BCD clock. The 1581 holds the TOD pin
+    # high when it carries a WD1772 (jumper J1 out), so the counter never
+    # counts, and the DOS's one use of it, writing $00 to the low byte and
+    # reading it back 20 µs later to tell a WD1770 from a WD1772, reads $00
+    # on either chip: the drive's CIA gets no TOD pulses (CIA's tod_hz).
+    class Model1581
+      include Engine::Core
+      include Engine::FastSerial
+
+      CLOCK_HZ = 2_000_000
+
+      # Where the DOS's idle loop starts over (see Drives::Engine::Idle).
+      IDLE_LOOP = 0xb105
+
+      # The host cycles, at about 1 MHz, by which a 1581 switched on with the
+      # machine has run its DOS's reset, the RAM test, the ROM checksum and
+      # the controller's half-second wait, and waits on the bus: 2.32 s,
+      # with a margin.
+      BOOT_CYCLES = 2_700_000
+
+      # The 8520's port A outputs.
+      SIDE = 0x01
+      MOTOR = 0x04
+      POWER_LED = 0x20
+      ACTIVITY_LED = 0x40
+
+      # Port B's ATN acknowledge, and the fast serial direction.
+      ATN_ACK = 0x10
+      FAST_SERIAL_OUT = 0x20
+
+      def cia
+        settle!
+        @cia
+      end
+
+      def fdc
+        settle!
+        @fdc
+      end
+
+      def model_name = "1581"
+
+      # +rom+ covers $8000-$FFFF, and defaults to the DOS image in the ROM
+      # path. +device+ is the number the switches on port A's PA3 and PA4
+      # set, 8 to 11.
+      def initialize(rom: nil, host_clock_hz: Model1541::CLOCK_HZ, device: 8, debug: false)
+        @device = device
+        @clock_hz = CLOCK_HZ
+        @mechanism = Mechanism.new
+        @fdc = WD1772.new(@mechanism)
+        @serial_port = SerialPort.new(@mechanism, device:)
+        @cia = Chips::CIA.new(start: 0x4000, peripheral: @serial_port, tod_hz: 0)
+        @bus = Bus.new(rom: rom || ROM.load("dos1581.rom", 0x8000), cia: @cia, fdc: @fdc, drive: self)
+        @cpu = CPU.new(@bus, debug:)
+        @idle_loop = IDLE_LOOP
+        @host_clock_hz = host_clock_hz
+        @phase = 0
+        @cycles = 0
+        @serial_bus = nil
+        @atn = false
+        @activity = false
+        @power = false
+        init_fast_serial
+        init_idle(debug)
+        ports_written
+        connect(SerialBus.new)
+      end
+
+      # The serial bus's RESET line reaches the CPU, the 8520 and the
+      # WD1772. RAM keeps its contents.
+      def reset!
+        settle!
+        @cia.reset!
+        @fdc.reset!
+        ports_written
+        @cpu.reset!
+      end
+
+      def insert(disk)
+        settle!
+        @mechanism.insert(disk, @fdc.now)
+        @fdc.spin_changed
+      end
+
+      # Puts in a Disk from the .d81 image at +path+, write-protected with
+      # `read_only`.
+      def insert_image(path, read_only: false)
+        insert(Disk.open(path, read_only:))
+      end
+
+      # Whether the activity LED is lit. The power LED stays lit, and
+      # flashes on an error.
+      def led_on? = @activity
+
+      def power_led_on? = @power
+
+      # The 8520's port B as it drives the serial bus, in VIA 1's bits, the
+      # ATN acknowledge turned round for the NAND that gates it, with the
+      # fast serial pins above it. It holds still while the drive sleeps, so
+      # reading it leaves the drive asleep.
+      def serial_output
+        lines = @cia.port_b_lines
+        output = (lines & (SerialBus::DRIVE_DATA_OUT | SerialBus::DRIVE_CLK_OUT)) | SerialBus::DRIVE_ATN_GATED |
+                 @fast_output
+        lines.anybits?(ATN_ACK) ? output : output | SerialBus::DRIVE_ATNA
+      end
+
+      # The 8520's ports drive the motor, the side, the LEDs and the fast
+      # serial buffers: the drive follows them after every write to a port
+      # or direction register.
+      def ports_written
+        fast_serial_out = @cia.port_b_lines.anybits?(FAST_SERIAL_OUT)
+        turn_fast_serial(fast_serial_out) if fast_serial_out != @fast_serial_out
+        lines = @cia.port_a_lines
+        @mechanism.side = lines.anybits?(SIDE) ? 1 : 0
+        @activity = lines.anybits?(ACTIVITY_LED)
+        @power = lines.anybits?(POWER_LED)
+        motor = lines.nobits?(MOTOR)
+        return if motor == @mechanism.motor_on?
+
+        @mechanism.motor(motor, @fdc.now)
+        @fdc.spin_changed
+      end
+
+      private
+
+      # One drive cycle: ATN going low pulls FLAG, the WD1772 and the 8520
+      # clock ahead of the CPU, and the 8520 alone pulls IRQ.
+      def step
+        atn = @serial_port.atn_low?
+        if atn != @atn
+          @atn = atn
+          @cia.flag! if atn
+        end
+        @fdc.cycle!
+        @cia.cycle!
+        drive_fast_serial if @fast_serial_out
+        @cpu.irq = @cia.interrupted?
+        @cpu.cycle!
+        @cycles += 1
+      end
+
+      def hear_atn
+        @atn = @serial_port.atn_low?
+      end
+
+      # A pass of the idle loop reads and writes RAM alone, so it repeats
+      # while the 8520 pulls no IRQ, for as long as the 8520's counters and
+      # the WD1772's next phase leave room: until timer B's next interrupt
+      # for the controller code. Neither chip changes but by the clock, so
+      # only the CPU is compared.
+      def busy_for_pass? = @cia.interrupted?
+
+      def quiet_cycles = [@cia.quiet_cycles, @fdc.quiet_cycles].min
+
+      def idle_state = [*@cpu.idle_state, @bus.data, @atn]
+
+      def fast_forward_chips(cycles)
+        @cia.fast_forward(cycles)
+        @fdc.fast_forward(cycles)
+      end
+
+      # Every timer B interrupt reads the 8520, so no orbit (Drives::Engine::Orbit)
+      # comes round, and the drive keeps no anchors.
+      def anchor = nil
+
+      def counter_state(_touched) = []
+
+      def skip_chip_orbits(_cycles, _touched) = nil
+    end
+  end
+end

data/lib/badline/drives/serial_bus.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    # The serial bus between the C64 and its drives: ATN, CLK and DATA, each
+    # an open-collector line with a pull-up. A line is low while any device
+    # pulls it (wired-AND), and high otherwise. Every read works the levels
+    # out from what each side drives now.
+    #
+    # The C64 drives the lines from CIA 2's port A through 7406 inverters, so
+    # an output bit of 1 pulls its line low: PA3 ATN, PA4 CLK and PA5 DATA.
+    # The machine pushes those bits into the bus (host_lines=), which holds
+    # them. PA6 and PA7 read CLK and DATA directly, 1 for a released line.
+    # The bus stands in as CIA 2's peripheral for those two inputs.
+    #
+    # 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. 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
+    # SP, through buffers each side turns towards the bus to send. A pin low
+    # pulls its line low. Each side pushes the lines it pulls when they
+    # move: the host through host_fast_lines=, which tells the drives
+    # (fast_lines_moved), and a drive through drives_fast_moved!, which
+    # tells the host (on_fast_change).
+    class SerialBus
+      # CIA 2 port A
+      HOST_ATN_OUT = 0x08
+      HOST_CLK_OUT = 0x10
+      HOST_DATA_OUT = 0x20
+      HOST_CLK_IN = 0x40
+      HOST_DATA_IN = 0x80
+
+      # VIA 1 port B
+      DRIVE_DATA_OUT = 0x02
+      DRIVE_CLK_OUT = 0x08
+      DRIVE_ATNA = 0x10
+
+      # The lines pulled low, as ATN, CLK, DATA and SRQ bits
+      ATN = 0x01
+      CLK = 0x02
+      DATA = 0x04
+      SRQ = 0x08
+
+      # A drive's serial_output bits above VIA 1's port B: its fast serial
+      # pins pulling DATA and SRQ.
+      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.
+      attr_reader :host_fast_lines
+
+      def initialize
+        @drives = []
+        @host_lines = 0
+        @host_fast_lines = 0
+        @drive_fast_lines = 0
+        @on_fast_change = nil
+      end
+
+      # The host's fast serial pins moved: +low+ is the lines they pull, as
+      # DATA and SRQ bits.
+      def host_fast_lines=(low)
+        return if low == @host_fast_lines
+
+        @host_fast_lines = low
+        @drives.each(&:fast_lines_moved)
+      end
+
+      # A drive's fast serial pins moved (serial_output's fast bits).
+      def drives_fast_moved!
+        low = 0
+        @drives.each do |drive|
+          output = drive.serial_output
+          low |= DATA if output.anybits?(DRIVE_FAST_DATA)
+          low |= SRQ if output.anybits?(DRIVE_FAST_SRQ)
+        end
+        return if low == @drive_fast_lines
+
+        @drive_fast_lines = low
+        @on_fast_change&.call
+      end
+
+      # Calls the block whenever the drives move their fast serial pins.
+      def on_fast_change(&block)
+        @on_fast_change = block
+      end
+
+      # The machine pushes the lines it pulls, as port A bits, whenever they
+      # may have moved: its output bits, with input bits floating high as the
+      # 7406 inputs see them. A bus with only drives on it keeps 0.
+      def host_lines=(lines)
+        @host_lines = lines
+        @drives.each(&:host_written!)
+      end
+
+      def attach(drive)
+        @drives << drive unless @drives.include?(drive)
+      end
+
+      def detach(drive)
+        @drives.delete(drive)
+      end
+
+      # One pass over everything on the bus, for a reader that wants more
+      # than one line, SRQ included. +host+ is the C64's port A lines as the
+      # reader sees them, which a drive takes a cycle late (see
+      # Drives::Engine::SerialLines).
+      def low_lines(host = @host_lines)
+        atn = host.anybits?(HOST_ATN_OUT)
+        low = @host_fast_lines | @drive_fast_lines
+        low |= ATN if atn
+        low |= CLK if host.anybits?(HOST_CLK_OUT)
+        low |= DATA if host.anybits?(HOST_DATA_OUT)
+        i = 0
+        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) || acknowledging?(drive, atn)
+          i += 1
+        end
+        low
+      end
+
+      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)
+
+      # CIA 2's port A pins as the bus leaves them: CLK IN and DATA IN low
+      # while their lines are.
+      def read_a(_port_a, _port_b)
+        low = low_lines
+        value = 0xff
+        value &= ~HOST_CLK_IN if low.anybits?(CLK)
+        value &= ~HOST_DATA_IN if low.anybits?(DATA)
+        value
+      end
+
+      # Port B goes to the user port, not the serial bus.
+      def read_b(_port_a, _port_b) = 0xff
+    end
+  end
+end

data/lib/badline/drives.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# The drives and the serial bus badline/core's machines share. The C128's
+# 1571 stays out of the core: badline/c128 requires it.
+require "badline/drives/datasette"
+require "badline/drives/serial_bus"
+require "badline/drives/model1541"
+require "badline/drives/model1581"

data/lib/badline/frontend/app.rb

@@ -21,7 +21,7 @@ module Badline
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
         @screens = Screens.new(computer)
-        @led = DriveLed.for(computer)
+        @led = DriveLed.new(computer)
         @controls = Controls.new(computer)
         @window = MachineWindow.new(@screens.screen, vsync: @pacer.vsync?)
         @pacer.fit(@window.refresh_rate) if @pacer.vsync?
@@ -128,7 +128,7 @@ module Badline
         @computer = computer
         @screens.computer = computer
         fit_window
-        @led = DriveLed.for(computer)
+        @led = DriveLed.new(computer)
         @controls.computer = computer
         @gamepads.computer = computer
         @sound.switch(computer.sound_source, computer.timing.clock_hz)
@@ -220,7 +220,7 @@ module Badline
         renderer = @window.renderer
         SDL.SDL_RenderClear(renderer)
         SDL.SDL_RenderCopy(renderer, @window.texture, nil, nil)
-        @led&.draw(renderer, @window.width, @window.height)
+        @led.draw(renderer, @window.width, @window.height)
         @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) }
         SDL.SDL_RenderPresent(renderer)
       end

data/lib/badline/frontend/boot.rb

@@ -10,7 +10,7 @@ module Badline
     # attach, an --at key names nothing or an event fails, which it warns
     # about.
     def self.run(options)
-      error = Timeline.error(options.timeline)
+      error = Timeline.error(options.timeline, options.family)
       unless error.empty?
         warn "#{options.program}: #{error}"
         return 1
@@ -33,9 +33,9 @@ module Badline
     def self.media_problem
       yield
       ""
-    rescue Machine::Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Datasette::Missing,
-           SystemCallError, Storage::SIDFile::FormatError, Storage::T64::FormatError, Storage::TAP::FormatError,
-           Storage::CRTFile::FormatError, Storage::G64Image::FormatError, Cartridge::UnsupportedTypeError,
+    rescue Machine::Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Drives::Datasette::Missing,
+           SystemCallError, SIDTune::File::FormatError, Storage::T64::FormatError, Storage::TAP::FormatError,
+           Storage::CRTFile::FormatError, Storage::G64Image::FormatError, C64::Cartridge::UnsupportedTypeError,
            Snapshot::FormatError => e
       e.message
     end

data/lib/badline/frontend/controls.rb

@@ -29,6 +29,7 @@ module Badline
         @arrows_port = 2
         @mouse = Input::Mouse1351.new
         @paddles = Input::Paddles.new
+        @held = {}
       end
 
       # Routes the input to another machine, the pot device going into its
@@ -73,10 +74,8 @@ module Badline
       def key(scancode, down)
         if joystick_mode? && Keys.joystick?(scancode)
           joystick_key(scancode, down)
-        elsif @computer.family == :c128
-          c128_key(Keys.c128_key(scancode, @computer.mode), down)
         else
-          c64_key(Keys.c64_key(scancode), down)
+          machine_key(scancode, down)
         end
       end
 
@@ -104,6 +103,23 @@ module Badline
 
       private
 
+      # A host key lets go of the key it pressed, though the C128 has
+      # switched between C64 and C128 mode since and maps it elsewhere.
+      def machine_key(scancode, down)
+        @held[scancode] = host_key(scancode) if down || !@held.key?(scancode)
+        key = @held[scancode]
+        @held.delete(scancode) unless down
+        if @computer.family == :c128
+          c128_key(key, down)
+        else
+          c64_key(key, down)
+        end
+      end
+
+      def host_key(scancode)
+        @computer.family == :c128 ? Keys.c128_key(scancode, @computer.mode) : Keys.c64_key(scancode)
+      end
+
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
       def c64_key(key, down)
         if key == :restore

data/lib/badline/frontend/drive_led.rb

@@ -2,48 +2,71 @@
 
 module Badline
   module Frontend
-    # The true drive's red LED, drawn over the bottom right corner of the
-    # border: bright while the DOS lights it, as it does while a file is
-    # open or after an error, and dim otherwise.
+    # The true drive's LEDs, drawn over the bottom right corner of the
+    # border: the red activity LED, bright while the DOS lights it, as it
+    # does while a file is open or after an error, and dim otherwise, and
+    # left of it the green power LED, which a 1581 flashes after an error.
+    # They follow whichever true drive the machine has, one plugged in
+    # after start among them, and are drawn only while it has one.
     class DriveLed
       WIDTH = 12
       HEIGHT = 4
 
+      # The power LED's distance left of the activity LED.
+      POWER_OFFSET = WIDTH + 4
+
       LIT = [0xff, 0x20, 0x20].freeze
       DARK = [0x40, 0x00, 0x00].freeze
+      POWER_LIT = [0x20, 0xff, 0x20].freeze
+      POWER_DARK = [0x00, 0x40, 0x00].freeze
 
-      # The LED of the machine's true drive, or nil without one.
-      def self.for(computer)
-        drive = computer.true_drive
-        drive ? new(drive) : nil
-      end
-
-      # Sets SDL.led_rect to where the LED goes on a screen `width` by
-      # `height`.
-      def self.place(width, height)
+      # Sets SDL.led_rect to where the activity LED goes on a screen `width`
+      # by `height`, or with `offset` that many pixels left of it.
+      def self.place(width, height, offset = 0)
         rect = SDL.led_rect
-        SDL.rect_x(rect, width - WIDTH - 8)
+        SDL.rect_x(rect, width - WIDTH - 8 - offset)
         SDL.rect_y(rect, height - HEIGHT - 6)
         SDL.rect_w(rect, WIDTH)
         SDL.rect_h(rect, HEIGHT)
       end
 
-      def initialize(drive)
-        @drive = drive
+      def initialize(computer)
+        @computer = computer
       end
 
-      def lit? = @drive.led_on?
+      # Whether the machine has a true drive, and so LEDs to draw.
+      def shown? = !@computer.true_drive.nil?
+
+      def lit?
+        drive = @computer.true_drive
+        drive.nil? ? false : drive.led_on?
+      end
+
+      def power_lit?
+        drive = @computer.true_drive
+        drive.nil? ? false : drive.power_led_on?
+      end
 
       def color = lit? ? LIT : DARK
 
-      # Fills the LED's rectangle on a screen `width` by `height` in its
-      # colour, then puts back the black that RenderClear clears with.
+      def power_color = power_lit? ? POWER_LIT : POWER_DARK
+
+      # Fills the LEDs' rectangles on a screen `width` by `height` in their
+      # colours, then puts back the black that RenderClear clears with.
       def draw(renderer, width, height)
-        DriveLed.place(width, height)
-        rgb = color
+        return unless shown?
+
+        fill(renderer, width, height, 0, color)
+        fill(renderer, width, height, POWER_OFFSET, power_color)
+        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
+      end
+
+      private
+
+      def fill(renderer, width, height, offset, rgb)
+        DriveLed.place(width, height, offset)
         SDL.SDL_SetRenderDrawColor(renderer, rgb[0], rgb[1], rgb[2], 255)
         SDL.SDL_RenderFillRect(renderer, SDL.led_rect)
-        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
       end
     end
   end

data/lib/badline/frontend/machine_window.rb

@@ -17,7 +17,8 @@ module Badline
       attr_reader :renderer, :texture
 
       # Opens the window for `screen`, presenting in step with the display
-      # when `vsync`.
+      # when `vsync`. Text input stays off, so a dead key such as ´ on a Mac
+      # arrives as a key press, as every other key does.
       def initialize(screen, vsync:)
         abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
 
@@ -28,6 +29,7 @@ module Badline
           TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED, @width * SCALE, @height * SCALE,
           SDL::WINDOW_RESIZABLE
         )
+        SDL.SDL_StopTextInput
         flags = SDL::RENDERER_ACCELERATED
         flags |= SDL::RENDERER_PRESENTVSYNC if vsync
         @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)

data/lib/badline/frontend/menu/menu_dialogs.rb

@@ -8,8 +8,8 @@ module Badline
     # name. A disk or tape picked goes straight in, and a save loads.
     class MenuDialogs
       EXTENSIONS = {
-        disk: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl], tape: %w[.tap], cartridge: %w[.crt],
-        program: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl .tap .crt .prg .p00 .sid], snapshot: %w[.vsf]
+        disk: Media::Extensions::DEVICE8, tape: Media::Extensions.of(%i[tape]),
+        cartridge: Media::Extensions.of(%i[cartridge]), program: Media::Extensions::ALL, snapshot: %w[.vsf]
       }.freeze
       TITLES = { disk: "INSERT A DISK", tape: "INSERT A TAPE", cartridge: "INSERT A CARTRIDGE",
                  program: "QUICK OPEN", snapshot: "LOAD A SAVE" }.freeze

data/lib/badline/frontend/player/filter_view.rb

@@ -31,7 +31,7 @@ module Badline
         cutoff = (history.register(frame, 0x15) & 0x07) | (history.register(frame, 0x16) << 3)
         resonance = history.register(frame, 0x17) >> 4
         mode_volume = history.register(frame, 0x18)
-        hertz = SID::Filter::W0.fetch(model)[cutoff] / (2 * Math::PI * SID::Filter::SCALE)
+        hertz = Chips::SID::Filter::W0.fetch(model)[cutoff] / (2 * Math::PI * Chips::SID::Filter::SCALE)
         paint = @painter
         paint.text(LEFT, top, "FILTER", BRIGHT)
         x = LEFT + 64

data/lib/badline/frontend/player/player_controller.rb

@@ -106,7 +106,7 @@ module Badline
       # Keeps the subtune's STIL credits for the header and the whole entry
       # for the INFO view.
       def stil(fields, subtune, subtune_fields)
-        @credits = Storage::STIL::Credit.list(subtune_fields.empty? ? fields : subtune_fields)
+        @credits = SIDTune::STIL::Credit.list(subtune_fields.empty? ? fields : subtune_fields)
         @stil = fields
         @stil_subtune = subtune
         @subtune_stil = subtune_fields
@@ -211,7 +211,7 @@ module Badline
 
       def draw
         @next_draw = now + FRAME
-        @screen.draw(@state, @player, @history, @tune_file, Storage::STIL::Credit.at(@credits, @state.played))
+        @screen.draw(@state, @player, @history, @tune_file, SIDTune::STIL::Credit.at(@credits, @state.played))
       end
 
       def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)

data/lib/badline/frontend/player/player_screen.rb

@@ -31,6 +31,7 @@ module Badline
         SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
         @window = SDL.SDL_CreateWindow(TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
                                        WIDTH * SCALE, height(view) * SCALE, SDL::WINDOW_RESIZABLE)
+        SDL.SDL_StopTextInput
         @renderer = SDL.SDL_CreateRenderer(@window, -1, SDL::RENDERER_ACCELERATED)
         SDL.SDL_RenderSetLogicalSize(@renderer, WIDTH, height(view))
         build

data/lib/badline/frontend/player/theme.rb

@@ -6,13 +6,13 @@ module Badline
     # C64's palette: one for each voice, and light blue on blue as on the
     # machine's screen.
     module PlayerTheme
-      TEXT = VIC::PALETTE[14]
-      BRIGHT = VIC::PALETTE[1]
-      DIM = VIC::PALETTE[11]
-      BOX = VIC::PALETTE[0]
-      BACKGROUND = VIC::PALETTE[6]
-      WARNING = VIC::PALETTE[10]
-      VOICE_COLORS = [VIC::PALETTE[7], VIC::PALETTE[13], VIC::PALETTE[3]].freeze
+      TEXT = Chips::VIC::PALETTE[14]
+      BRIGHT = Chips::VIC::PALETTE[1]
+      DIM = Chips::VIC::PALETTE[11]
+      BOX = Chips::VIC::PALETTE[0]
+      BACKGROUND = Chips::VIC::PALETTE[6]
+      WARNING = Chips::VIC::PALETTE[10]
+      VOICE_COLORS = [Chips::VIC::PALETTE[7], Chips::VIC::PALETTE[13], Chips::VIC::PALETTE[3]].freeze
     end
   end
 end