badline 0.6.0 → 0.6.1

data/lib/badline/frontend/gamepads.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Host game controllers wired onto the control ports: the first
+    # controller found drives joystick 2, the port most games read, and a
+    # second one joystick 1. PadPort holds the mapping.
+    #
+    # The controllers are polled every frame, and rescanned whenever SDL
+    # reports one added or removed.
+    class Gamepads
+      PORTS = [2, 1].freeze
+
+      def initialize(computer, verbose)
+        @verbose = verbose
+        @controllers = []
+        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+        @buttons = Array.new(PadPort::BUTTON_COUNT, 0)
+        @available = SDL.SDL_InitSubSystem(SDL::INIT_GAMECONTROLLER).zero?
+        puts "No game controllers: #{SDL.SDL_GetError}" if @verbose && !@available
+      end
+
+      # Wires the controllers to another machine's joysticks, which take
+      # what they hold on the next poll.
+      def computer=(computer)
+        @ports.each(&:release)
+        @ports = [PadPort.new(computer.joystick2), PadPort.new(computer.joystick1)]
+      end
+
+      def rescan
+        return unless @available
+
+        close
+        index = 0
+        count = SDL.SDL_NumJoysticks
+        while index < count && @controllers.size < PORTS.size
+          open_controller(index) if SDL.SDL_IsGameController(index) != 0
+          index += 1
+        end
+      end
+
+      def poll
+        @controllers.each_with_index { |controller, index| @ports[index].update(active(controller)) }
+      end
+
+      def close
+        @controllers.each { |controller| SDL.SDL_GameControllerClose(controller) }
+        @controllers = []
+        @ports.each(&:release)
+      end
+
+      private
+
+      def open_controller(index)
+        controller = SDL.SDL_GameControllerOpen(index)
+        # SDL returns NULL when the controller won't open, which Spinel's FFI
+        # reads as nil.
+        return if controller.nil?
+
+        puts "Gamepad on joystick #{PORTS[@controllers.size]}: #{SDL.SDL_GameControllerName(controller)}" if @verbose
+        @controllers << controller
+      end
+
+      def active(controller)
+        buttons = @buttons
+        button = 0
+        while button < PadPort::BUTTON_COUNT
+          buttons[button] = SDL.SDL_GameControllerGetButton(controller, button)
+          button += 1
+        end
+        PadPort.active(buttons, SDL.SDL_GameControllerGetAxis(controller, PadPort::LEFT_X),
+                       SDL.SDL_GameControllerGetAxis(controller, PadPort::LEFT_Y))
+      end
+    end
+  end
+end

data/lib/badline/frontend/keys.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # SDL scancodes follow key positions on a US layout. They map onto the C64
+    # keys and, in joystick mode, the joystick directions.
+    module Keys
+      TAB = 43
+
+      LETTERS = %i[a b c d e f g h i j k l m n o p q r s t u v w x y z].freeze
+      DIGITS = %i[1 2 3 4 5 6 7 8 9 0].freeze
+
+      OTHERS = {
+        40 => :return, 41 => :run_stop, 42 => :delete, 44 => :space,
+        45 => :-, 46 => :"=", 49 => :"@", 51 => :";", 52 => :":",
+        48 => :up, 53 => :left, 54 => :",", 55 => :".", 56 => :/,
+        58 => :f1, 60 => :f3, 62 => :f5, 64 => :f7,
+        74 => :clr_home, 75 => :restore, 77 => :£, 79 => :cursor_h, 80 => :cursor_left,
+        81 => :cursor_v, 82 => :cursor_up, 85 => :*, 87 => :+,
+        224 => :control, 225 => :lshift, 226 => :cbm, 229 => :rshift
+      }.freeze
+
+      F9 = 66
+      F10 = 67
+      F11 = 68
+      F12 = 69
+
+      ARROWS = { 44 => :fire, 228 => :fire, 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
+      WASD = { 225 => :fire, 7 => :right, 4 => :left, 22 => :down, 26 => :up }.freeze
+
+      def self.c64_key(scancode)
+        if scancode.between?(4, 29)
+          LETTERS[scancode - 4]
+        elsif scancode.between?(30, 39)
+          DIGITS[scancode - 30]
+        else
+          OTHERS[scancode] || :none
+        end
+      end
+
+      def self.arrows(scancode) = ARROWS[scancode] || :none
+
+      def self.wasd(scancode) = WASD[scancode] || :none
+
+      def self.joystick?(scancode) = ARROWS.key?(scancode) || WASD.key?(scancode)
+    end
+  end
+end

data/lib/badline/frontend/pacer.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Decides how many cycles each frame clocks and how long it waits.
+    #
+    # With vsync, a frame lasts one display refresh (see FrameRate), and
+    # presenting it waits for the display, so #wait has nothing left to do.
+    # While the sound plays, each frame's cycles are trimmed to keep the
+    # audio queue at Sound::AHEAD. If presenting doesn't wait, as when the
+    # display's driver has vsync off, #check falls back to the timer, and
+    # until then the sound holds any frame that would take its queue past
+    # 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.
+    # 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
+      # The frame after which the app first checks that vsync holds.
+      EARLY_CHECK = 10
+      SAFETY = Sound::AHEAD * 2
+
+      attr_reader :rate
+
+      def initialize(paced:, vsync:, verbose:, region: Region::PAL)
+        @paced = paced
+        @verbose = verbose
+        @vsync = paced && vsync
+        @region = region
+        @rate = FrameRate.machine(region)
+        @deadline = 0.0
+        @measured_frames = 0
+        @measured_seconds = 0.0
+      end
+
+      def vsync? = @vsync
+
+      # 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)
+        puts "Display #{@rate.refresh} Hz, vsync: #{@rate.base_cycles} cycles a frame" if @verbose
+      end
+
+      def start(at)
+        @deadline = at
+      end
+
+      def cycles(sound)
+        return @rate.base_cycles unless @vsync && sound.playing?
+
+        @rate.cycles(sound.level, Sound::AHEAD)
+      end
+
+      def wait(sound)
+        return unless @paced
+
+        if sound.playing?
+          sound.wait(@vsync ? SAFETY : Sound::AHEAD)
+        elsif !@vsync
+          wait_for_timer
+        end
+      end
+
+      # Adds `frames` presented over `elapsed` seconds to the measure of the
+      # display's rate, and fits the frames to the rate measured so far.
+      def measure(frames, elapsed)
+        return unless @vsync
+
+        @measured_frames += frames
+        @measured_seconds += elapsed
+        @rate.refit(@measured_frames, @measured_seconds)
+      end
+
+      # Falls back to the timer if the last `frames`, presented over
+      # `elapsed` seconds up to `at`, didn't wait for the display.
+      def check(frames, elapsed, at)
+        return if !@vsync || @rate.vsync_holds?(frames, elapsed)
+
+        puts "Vsync doesn't hold the display's #{@rate.refresh} Hz, so a timer paces the frames instead." if @verbose
+        @vsync = false
+        @deadline = at
+      end
+
+      private
+
+      def wait_for_timer
+        @deadline += @rate.seconds
+        started = now
+        @deadline = started if @deadline < started - @rate.seconds
+        left = @deadline - started
+        SDL.SDL_Delay((left * 1000).to_i) if left > 0.001
+        nil while now < @deadline
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/frontend/pad_port.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # One game controller's state wired onto a joystick: the D-pad and the
+    # left stick both steer, and every face and shoulder button fires. It
+    # only releases directions it pressed itself, so the keyboard's joystick
+    # keys keep working with a controller connected.
+    class PadPort
+      DEADZONE = 8_000
+
+      # SDL_GameControllerButton values.
+      BUTTON_COUNT = 15
+      BUTTONS = {
+        up: [11], down: [12], left: [13], right: [14],
+        fire: [0, 1, 2, 3, 9, 10] # A, B, X, Y and the shoulders
+      }.freeze
+
+      # SDL_GameControllerAxis values, and the sign that steers each way.
+      LEFT_X = 0
+      LEFT_Y = 1
+      AXES = { up: [LEFT_Y, -1], down: [LEFT_Y, 1], left: [LEFT_X, -1], right: [LEFT_X, 1] }.freeze
+
+      DIRECTIONS = %i[up down left right fire].freeze
+
+      attr_reader :pressed
+
+      def initialize(joystick)
+        @joystick = joystick
+        @pressed = []
+      end
+
+      # The directions a controller holds, from its `buttons` (0 or 1 for
+      # each SDL button) and its left stick.
+      def self.active(buttons, left_x, left_y)
+        DIRECTIONS.select do |direction|
+          BUTTONS[direction].any? { |button| buttons[button] != 0 } ||
+            tilted?(direction, left_x, left_y)
+        end
+      end
+
+      def self.tilted?(direction, left_x, left_y)
+        return false if direction == :fire
+
+        axis, sign = AXES[direction]
+        (axis == LEFT_X ? left_x : left_y) * sign > DEADZONE
+      end
+
+      # Presses what the controller holds and releases what it let go of.
+      def update(active)
+        @pressed.each { |direction| @joystick.release(direction) unless active.include?(direction) }
+        active.each { |direction| @joystick.press(direction) }
+        @pressed = active
+      end
+
+      def release
+        update([])
+      end
+    end
+  end
+end

data/lib/badline/frontend/screen.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The visible part of the VIC's display, the crop of the machine's
+    # region, repacked for an SDL texture in XRGB8888. Spinel hands an
+    # Array of Integers to C as 64-bit words, as badline/ffi does on CRuby,
+    # so each word carries two neighbouring pixels, the left one in the low
+    # half. The texture is PAL's crop, 384x272, and a region with fewer
+    # lines to show sits in the middle of it, between black bands.
+    class Screen
+      WIDTH = Region::PAL.crop[2]
+      HEIGHT = Region::PAL.crop[3]
+      ROW_BYTES = WIDTH * 4
+      ROW_WORDS = WIDTH / 2
+
+      COLORS = [
+        0x000000, 0xffffff, 0x924a40, 0x84c5cc,
+        0x9351b6, 0x72b14b, 0x483aaa, 0xd5df7c,
+        0x675200, 0xc33d00, 0xc18178, 0x606060,
+        0x8a8a8a, 0xb3ec91, 0x867ade, 0xb3b3b3
+      ].freeze
+
+      PAIRS = Array.new(256) { |pair| COLORS[pair & 0x0f] | (COLORS[pair >> 4] << 32) }.freeze
+
+      attr_reader :pixels
+
+      def initialize(vic)
+        @vic = vic
+        crop = vic.region.crop
+        @col_offset = crop[0]
+        @row_offset = crop[1]
+        @height = crop[3]
+        @band = (HEIGHT - @height) / 2
+        @pixels = Array.new(HEIGHT * ROW_WORDS, 0)
+      end
+
+      # Repacks only the lines the VIC has changed since the last frame.
+      def update
+        dirty = @vic.dirty_lines
+        row = 0
+        while row < @height
+          pack_row(row) if dirty[row + @row_offset]
+          row += 1
+        end
+        @vic.clear_dirty_lines!
+      end
+
+      private
+
+      def pack_row(row)
+        display = @vic.display
+        pixels = @pixels
+        from = ((row + @row_offset) * @vic.width) + @col_offset
+        to = (row + @band) * ROW_WORDS
+        last = to + ROW_WORDS
+        while to < last
+          pixels[to] = PAIRS[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
+          from += 2
+          to += 1
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/screenshot.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # --screenshot's frame: what the renderer drew, read back before it is
+    # presented and saved as a BMP.
+    module Screenshot
+      def self.write(renderer, path)
+        SDL.SDL_GetRendererOutputSize(renderer, SDL.output_w, SDL.output_h)
+        width = SDL.read_i32(SDL.output_w)
+        height = SDL.read_i32(SDL.output_h)
+        data = LibC.malloc(width * height * 4)
+        SDL.SDL_RenderReadPixels(renderer, nil, SDL::PIXELFORMAT_RGB888, data, width * 4)
+        surface = SDL.SDL_CreateRGBSurfaceWithFormatFrom(data, width, height, 32, width * 4, SDL::PIXELFORMAT_RGB888)
+        SDL.SDL_SaveBMP_RW(surface, SDL.SDL_RWFromFile(path, "wb"), 1)
+        SDL.SDL_FreeSurface(surface)
+        LibC.free(data)
+        puts "wrote #{path}, #{width}x#{height}"
+      end
+    end
+  end
+end

data/lib/badline/frontend/snapshots.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The window's snapshots: F11 saves the machine to a new
+    # badline-<date>-<time>.vsf in the working directory, and F12 goes back
+    # to the snapshot last saved or opened, in a new machine. --save-snapshot
+    # saves one after the last frame.
+    class Snapshots
+      KEYS = [Keys::F11, Keys::F12].freeze
+
+      # The machine running, which F12 replaces with the restored one.
+      attr_reader :computer
+
+      def initialize(computer, options)
+        @computer = computer
+        @last = options.snapshot? ? options.media_path.to_s : ""
+        @at_finish = options.save_snapshot
+      end
+
+      # Saves or restores for F11 or F12, and says whether a restored
+      # machine now runs in place of the one before.
+      def key(scancode)
+        return restore if scancode == Keys::F12
+
+        save if scancode == Keys::F11
+        false
+      end
+
+      # Saves the machine, and warns when it can't.
+      def save(path = "badline-#{Time.now.strftime('%Y%m%d-%H%M%S')}.vsf")
+        @computer.save_snapshot(path)
+        @last = path
+        puts "Saved #{path}"
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+      end
+
+      # Restores the snapshot last saved or opened into a new machine, and
+      # warns when it fails, leaving the machine running as it was.
+      def restore
+        if @last.empty?
+          puts "No snapshot to restore, F11 saves one"
+          return false
+        end
+
+        @computer = Snapshot.load(@last) { |line| puts line }
+        puts "Restored #{@last}"
+        true
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{@last}: #{e.message}"
+        false
+      end
+
+      def finish
+        save(@at_finish) unless @at_finish.empty?
+      end
+    end
+  end
+end

data/lib/badline/frontend/sound.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID's output on SDL's audio queue, as mono signed 16-bit samples.
+    # Once the device plays, it is the clock: #wait holds each frame until
+    # the queue is down to `AHEAD`, so the machine runs at the device's pace.
+    #
+    # The device starts once the queue holds AHEAD. 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. A
+    # frame that would take the queue past LIMIT is dropped whole, which
+    # only happens unpaced.
+    #
+    # Each frame's samples go to SDL through an IO::Buffer of 16-bit values.
+    class Sound
+      RATE = 44_100
+      AHEAD = 0.08
+      LIMIT = 0.25
+
+      attr_reader :rate, :underruns, :dropped, :queued, :low, :high
+
+      def initialize(sid, wanted, verbose)
+        @sid = sid
+        @verbose = verbose
+        @device = 0
+        @rate = RATE
+        @started = false
+        @muted = false
+        @underruns = 0
+        @dropped = 0
+        @queued = 0
+        @buffer = IO::Buffer.new(4096)
+        reset_levels
+        open_device if wanted
+      end
+
+      def on? = @device != 0
+
+      # Plays another machine's SID from here on.
+      def sid=(sid)
+        @sid = sid
+        sid.record(rate: @rate) if on?
+      end
+
+      def muted? = @muted
+
+      def playing? = @started
+
+      def feed
+        return unless on?
+
+        samples = @sid.drain_samples
+        return if @muted || samples.empty?
+
+        level = queued_seconds
+        if level + (samples.size.to_f / @rate) > LIMIT
+          @dropped += samples.size
+        else
+          play(samples, level)
+        end
+      end
+
+      # How much the audio queue holds, in seconds.
+      def level = queued_seconds
+
+      # Waits until the queue is down to `level` seconds.
+      def wait(level = AHEAD)
+        SDL.SDL_Delay(1) while queued_seconds > level
+      end
+
+      def toggle_mute
+        @muted = !@muted
+        return unless @muted
+
+        halt
+        SDL.SDL_ClearQueuedAudio(@device)
+      end
+
+      def reset_levels
+        @low = LIMIT
+        @high = 0.0
+      end
+
+      def close
+        SDL.SDL_CloseAudioDevice(@device) if on?
+      end
+
+      private
+
+      def open_device
+        unless SDL.SDL_InitSubSystem(SDL::INIT_AUDIO).zero?
+          puts "No sound: #{SDL.SDL_GetError}"
+          return
+        end
+
+        SDL.spec_freq(SDL.wanted, RATE)
+        SDL.spec_format(SDL.wanted, SDL::AUDIO_S16LSB)
+        SDL.spec_channels(SDL.wanted, 1)
+        SDL.spec_samples(SDL.wanted, 512)
+        @device = SDL.SDL_OpenAudioDevice(nil, 0, SDL.wanted, SDL.obtained, SDL::ALLOW_FREQUENCY_CHANGE)
+        return puts "No sound: #{SDL.SDL_GetError}" unless on?
+
+        @rate = SDL.read_i32(SDL.obtained)
+        @sid.record(rate: @rate)
+        puts "Sound at #{@rate} Hz" if @verbose
+      end
+
+      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
+
+      def play(samples, level)
+        @low = level if level < @low
+        underrun! if @started && level.zero?
+        queue(samples)
+        level = queued_seconds
+        @high = level if level > @high
+        start if level >= AHEAD
+      end
+
+      def queue(samples)
+        count = samples.size
+        bytes = count * 2
+        @buffer.resize(bytes) if bytes > @buffer.size
+        buffer = @buffer
+        i = 0
+        while i < count
+          buffer.set_value(:s16, i * 2, samples[i])
+          i += 1
+        end
+        SDL.SDL_QueueAudio(@device, buffer, bytes)
+        @queued += count
+      end
+
+      def start
+        return if @started
+
+        @started = true
+        SDL.SDL_PauseAudioDevice(@device, 0)
+      end
+
+      def halt
+        @started = false
+        SDL.SDL_PauseAudioDevice(@device, 1)
+      end
+
+      def underrun!
+        @underruns += 1
+        puts "Running below real time, so the sound will stutter." if @underruns == 1
+        halt
+      end
+    end
+  end
+end