badline 0.6.0 → 0.6.1

data/lib/badline/frontend/app.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Opens the window, then runs the machine a frame at a time: poll
+    # events, clock the frame's cycles, queue the SID's samples, upload the
+    # changed lines, present and wait. Pacer decides the cycles and the wait.
+    class App
+      SCALE = 2
+      TITLE = "Badline"
+      STAGES = %w[events emulate audio blit present wait].freeze
+
+      # Takes the frame limit, the pacing, the snapshot path, the sound and
+      # the verbosity from Options, and runs the timeline's events.
+      def initialize(computer, options, timeline)
+        @computer = computer
+        @frame_limit = options.frames
+        @verbose = options.verbose?
+        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, region: computer.region)
+        @timeline = timeline
+        @snapshots = Snapshots.new(computer, options)
+        @screen = Screen.new(computer.vic)
+        @led = DriveLed.for(computer)
+        @controls = Controls.new(computer)
+        @spent = Array.new(STAGES.size, 0.0)
+        @slowest = 0.0
+        open_window
+        @sound = Sound.new(computer.sid, options.sound?, @verbose)
+        @gamepads = Gamepads.new(computer, @verbose)
+      end
+
+      def run
+        @frames = 0
+        @running = true
+        @started = @reported = now
+        @pacer.start(@started)
+        @reported_samples = 0
+        frame while @running
+        @snapshots.finish
+        @computer.drive1541&.flush
+        @gamepads.close
+        @sound.close
+        close_window
+      end
+
+      private
+
+      def frame
+        stamps = [now]
+        handle_events
+        @gamepads.poll
+        stamps << now
+        emulate
+        stamps << now
+        @sound.feed
+        stamps << now
+        upload
+        stamps << now
+        draw
+        stamps << now
+        @pacer.wait(@sound)
+        stamps << now
+        finish_frame(stamps)
+      end
+
+      def finish_frame(stamps)
+        STAGES.size.times { |stage| @spent[stage] += stamps[stage + 1] - stamps[stage] }
+        took = stamps[-2] - stamps.first
+        @slowest = took if took > @slowest
+        @frames += 1
+        @timeline.run(@computer, @frames)
+        @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
+        @pacer.check(Pacer::EARLY_CHECK, stamps.last - @started, stamps.last) if @frames == Pacer::EARLY_CHECK
+        report(stamps.last) if (@frames % 50).zero?
+      end
+
+      def open_window
+        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")
+        @window = SDL.SDL_CreateWindow(
+          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
+          Screen::WIDTH * SCALE, Screen::HEIGHT * SCALE, SDL::WINDOW_RESIZABLE
+        )
+        flags = SDL::RENDERER_ACCELERATED
+        flags |= SDL::RENDERER_PRESENTVSYNC if @pacer.vsync?
+        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
+        fit_display if @pacer.vsync?
+        SDL.SDL_RenderSetLogicalSize(@renderer, Screen::WIDTH, Screen::HEIGHT)
+        create_texture
+      end
+
+      def create_texture
+        @texture = SDL.SDL_CreateTexture(
+          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, Screen::WIDTH, Screen::HEIGHT
+        )
+        SDL.rect_w(SDL.rect, Screen::WIDTH)
+        SDL.rect_h(SDL.rect, Screen::HEIGHT)
+      end
+
+      def close_window
+        SDL.SDL_DestroyTexture(@texture)
+        SDL.SDL_DestroyRenderer(@renderer)
+        SDL.SDL_DestroyWindow(@window)
+        SDL.SDL_Quit
+      end
+
+      def handle_events
+        handle_event(SDL.event_type(SDL.event)) while SDL.SDL_PollEvent(SDL.event) != 0
+      end
+
+      def handle_event(type)
+        case type
+        when SDL::QUIT
+          @running = false
+        when SDL::KEYDOWN, SDL::KEYUP
+          handle_key(SDL.event_scancode(SDL.event), type == SDL::KEYDOWN) if SDL.event_repeat(SDL.event).zero?
+        when SDL::MOUSEMOTION
+          @controls.mouse_motion(SDL.event_xrel(SDL.event), SDL.event_yrel(SDL.event))
+        when SDL::MOUSEBUTTONDOWN, SDL::MOUSEBUTTONUP
+          @controls.mouse_button(SDL.event_button(SDL.event), type == SDL::MOUSEBUTTONDOWN)
+        when SDL::CONTROLLERDEVICEADDED, SDL::CONTROLLERDEVICEREMOVED
+          @gamepads.rescan
+        end
+      end
+
+      def handle_key(scancode, down)
+        if [Keys::TAB, Keys::F9, Keys::F10].include?(scancode)
+          handle_toggle(scancode) if down
+        elsif down && @snapshots.key(scancode)
+          swap(@snapshots.computer)
+        elsif !Snapshots::KEYS.include?(scancode)
+          @controls.key(scancode, down)
+        end
+      end
+
+      # Runs the restored machine in place of the one before: the screen,
+      # the drive LED, the controls, the gamepads and the sound go over to
+      # it.
+      def swap(computer)
+        @computer = computer
+        @screen = Screen.new(computer.vic)
+        @led = DriveLed.for(computer)
+        @controls.computer = computer
+        @gamepads.computer = computer
+        @sound.sid = computer.sid
+      end
+
+      def handle_toggle(scancode)
+        if scancode == Keys::TAB
+          @controls.cycle_mode(SDL.event_mod(SDL.event).anybits?(SDL::KMOD_SHIFT) ? -1 : 1)
+          SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
+        elsif scancode == Keys::F9
+          @controls.swap_ports
+        else
+          @sound.toggle_mute
+        end
+        update_title
+      end
+
+      def update_title
+        title = TITLE
+        title += " [#{@controls.tag}]" unless @controls.tag.empty?
+        title += " [MUTED]" if @sound.muted?
+        SDL.SDL_SetWindowTitle(@window, title)
+      end
+
+      def fit_display
+        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
+        @pacer.fit(SDL.mode_refresh(SDL.display_mode))
+      end
+
+      def emulate
+        computer = @computer
+        cycles = @pacer.cycles(@sound)
+        i = 0
+        while i < cycles
+          computer.cycle!
+          i += 1
+        end
+      end
+
+      def upload
+        @screen.update
+        SDL.SDL_UpdateTexture(@texture, SDL.rect, @screen.pixels, Screen::ROW_BYTES)
+      end
+
+      def draw
+        SDL.SDL_RenderClear(@renderer)
+        SDL.SDL_RenderCopy(@renderer, @texture, SDL.rect, SDL.rect)
+        @led&.draw(@renderer)
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(@renderer, path) }
+        SDL.SDL_RenderPresent(@renderer)
+      end
+
+      def report(at)
+        @pacer.check(50, at - @reported, at)
+        @pacer.measure(50, at - @reported)
+        report_frames(at) if @verbose
+        @spent = Array.new(STAGES.size, 0.0)
+        @slowest = 0.0
+        @reported = at
+      end
+
+      def report_frames(at)
+        fps = 50 / (at - @reported)
+        stages = STAGES.each_with_index.map { |name, stage| "#{name} #{(@spent[stage] * 20).round(2)}" }
+        puts "#{fps.round(1)} fps, per frame ms: #{stages.join(' ')}, slowest work #{(@slowest * 1000).round(2)}"
+        report_sound(at) if @sound.on?
+      end
+
+      def report_sound(at)
+        sound = @sound
+        rate = (sound.queued - @reported_samples) / (at - @reported)
+        queue = sound.high.zero? ? "empty" : "#{(sound.low * 1000).round(1)}-#{(sound.high * 1000).round(1)} ms"
+        puts "  sound #{rate.round} samples/s, queue #{queue}, #{sound.underruns} underruns, #{sound.dropped} dropped"
+        sound.reset_levels
+        @reported_samples = sound.queued
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/frontend/audio_sink.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The host's audio device for --headless, fed through SDL's queue: mono
+    # signed 16-bit samples go in at the device's rate and SDL plays them
+    # out behind us. It answers what Audio::Playback asks of a sink.
+    class AudioSink
+      class Error < Audio::Playback::DeviceError; end
+
+      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)
+        @device = 0
+        @rate = rate
+        @buffer = IO::Buffer.new(4096)
+        check(SDL.SDL_InitSubSystem(SDL::INIT_AUDIO))
+        open_device(rate, exact_rate ? 0 : SDL::ALLOW_FREQUENCY_CHANGE, buffer)
+      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
+        check(SDL.SDL_QueueAudio(@device, buffer, bytes))
+      end
+
+      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
+
+      def start = SDL.SDL_PauseAudioDevice(@device, 0)
+
+      def pause = SDL.SDL_PauseAudioDevice(@device, 1)
+
+      def clear = SDL.SDL_ClearQueuedAudio(@device)
+
+      def close
+        return if @device.zero?
+
+        SDL.SDL_CloseAudioDevice(@device)
+        SDL.SDL_QuitSubSystem(SDL::INIT_AUDIO)
+        @device = 0
+      end
+
+      private
+
+      def open_device(rate, allowed_changes, buffer)
+        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, buffer)
+        @device = SDL.SDL_OpenAudioDevice(nil, 0, SDL.wanted, SDL.obtained, allowed_changes)
+        raise Error, SDL.SDL_GetError if @device.zero?
+
+        @rate = SDL.read_i32(SDL.obtained)
+      end
+
+      def check(result)
+        raise Error, SDL.SDL_GetError if result.negative?
+
+        result
+      end
+    end
+  end
+end

data/lib/badline/frontend/boot.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  # The window both builds play the machine in, badline-ruby on CRuby and
+  # the native badline compiled with Spinel, so it stays inside the subset
+  # of Ruby Spinel compiles. On CRuby, require badline/ffi before it.
+  module Frontend
+    # Builds the machine the options ask for and plays it in the window
+    # until it closes, and returns the exit status: 1 when the media won't
+    # attach, an --at key names nothing or an event fails, which it warns
+    # about.
+    def self.run(options)
+      error = Timeline.error(options.timeline)
+      unless error.empty?
+        warn "#{options.program}: #{error}"
+        return 1
+      end
+
+      begin
+        computer = boot(options)
+      rescue Media::TrueDrive::Error, Storage::SIDFile::FormatError, Storage::T64::FormatError,
+             Storage::TAP::FormatError, Storage::CRTFile::FormatError, Storage::G64Image::FormatError,
+             Cartridge::UnsupportedTypeError, Snapshot::FormatError => e
+        warn "#{options.program}: #{options.media_path}: #{e.message}"
+        return 1
+      end
+      timeline = Timeline.new(options)
+      App.new(computer, options, timeline).run
+      timeline.failed? ? 1 : 0
+    end
+
+    # The machine a .vsf snapshot holds, built as the saved one was, or a
+    # new one built from the options with the media attached.
+    def self.boot(options)
+      media = options.media_path
+      if options.snapshot?
+        computer = Snapshot.load(media) { |line| puts line }
+        puts "Restored #{media}"
+        return computer
+      end
+
+      computer = Computer.new(sid_model: options.sid_model || Media.sid_model(media), reu: options.reu,
+                              region: options.ntsc? ? Region::NTSC : Region::PAL)
+      Media::TrueDrive.plug(computer) if options.true_drive?
+      unless media.nil?
+        puts Media.attach(computer, media, autostart: options.autostart?, song: options.song,
+                                           disk: { read_only: options.read_only? })
+      end
+      computer
+    end
+  end
+end

data/lib/badline/frontend/controls.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Routes host input to the machine in one of the input modes, which Tab
+    # steps through and shift-Tab steps back through:
+    #
+    # - keyboard: every host key goes to the C64 keyboard.
+    # - joystick: the arrow cluster and space drive one joystick and WASD
+    #   and left shift the other. The arrows start on joystick 2, and F9
+    #   swaps them.
+    # - mouse1, mouse2: the host mouse is a 1351 mouse on control port 1 or
+    #   2, and paddles1, paddles2 a pair of paddles there. 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.
+    class Controls
+      MODES = %i[keyboard joystick mouse1 mouse2 paddles1 paddles2].freeze
+      TAGS = ["", "JOY", "MOUSE 1", "MOUSE 2", "PADDLE 1", "PADDLE 2"].freeze
+
+      # SDL mouse button numbers.
+      MOUSE_BUTTONS = { 1 => :left, 3 => :right }.freeze
+
+      attr_reader :mode, :arrows_port
+
+      def initialize(computer)
+        @computer = computer
+        @mode = :keyboard
+        @arrows_port = 2
+        @mouse = Input::Mouse1351.new
+        @paddles = Input::Paddles.new
+      end
+
+      # Routes the input to another machine, the mode's mouse or paddles
+      # going into its port.
+      def computer=(computer)
+        release_all
+        @computer = computer
+        attach_pot_device
+      end
+
+      def joystick_mode? = @mode == :joystick
+
+      # Whether the host mouse drives a pot device, and so should be held
+      # in relative mode.
+      def pot_device? = MODES.index(@mode) >= 2
+
+      # The title bar's tag for the mode, empty for the keyboard.
+      def tag
+        return "JOY #{@arrows_port}" if joystick_mode?
+
+        TAGS[MODES.index(@mode)]
+      end
+
+      def key(scancode, down)
+        if joystick_mode? && Keys.joystick?(scancode)
+          joystick_key(scancode, down)
+        else
+          c64_key(Keys.c64_key(scancode), down)
+        end
+      end
+
+      # Steps to the next mode, or back with a negative step.
+      def cycle_mode(step)
+        @mode = MODES[(MODES.index(@mode) + step) % MODES.size]
+        release_all
+        attach_pot_device
+      end
+
+      def swap_ports
+        @arrows_port = 3 - @arrows_port
+        release_all
+      end
+
+      def mouse_motion(delta_x, delta_y)
+        return unless pot_device?
+
+        paddles? ? @paddles.move(delta_x, delta_y) : @mouse.move(delta_x, delta_y)
+      end
+
+      def mouse_button(button, down)
+        name = MOUSE_BUTTONS[button]
+        return unless name && pot_device?
+
+        if paddles?
+          down ? @paddles.press(name) : @paddles.release(name)
+        else
+          down ? @mouse.press(name) : @mouse.release(name)
+        end
+      end
+
+      private
+
+      # 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
+        else
+          down ? @computer.keyboard.press(key) : @computer.keyboard.release(key)
+        end
+      end
+
+      def paddles? = MODES.index(@mode) >= 4
+
+      # A fresh device on the mode's port, and none on the other.
+      def attach_pot_device
+        ports = @computer.control_ports
+        ports.device1 = nil
+        ports.device2 = nil
+        return unless pot_device?
+
+        if paddles?
+          @paddles = Input::Paddles.new
+          attach_paddles(ports)
+        else
+          @mouse = Input::Mouse1351.new
+          attach_mouse(ports)
+        end
+      end
+
+      def attach_paddles(ports)
+        if port_one?
+          ports.device1 = @paddles
+        else
+          ports.device2 = @paddles
+        end
+      end
+
+      def attach_mouse(ports)
+        if port_one?
+          ports.device1 = @mouse
+        else
+          ports.device2 = @mouse
+        end
+      end
+
+      def port_one? = %i[mouse1 paddles1].include?(@mode)
+
+      def joystick_key(scancode, down)
+        direction = Keys.arrows(scancode)
+        if direction == :none
+          move(joystick(3 - @arrows_port), Keys.wasd(scancode), down)
+        else
+          move(joystick(@arrows_port), direction, down)
+        end
+      end
+
+      def joystick(port) = port == 1 ? @computer.joystick1 : @computer.joystick2
+
+      def move(joystick, direction, down)
+        down ? joystick.press(direction) : joystick.release(direction)
+      end
+
+      def release_all
+        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
+        Keys::WASD.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
+        Keys::ARROWS.each_value do |direction|
+          @computer.joystick1.release(direction)
+          @computer.joystick2.release(direction)
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/drive_led.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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.
+    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
+
+      # The LED of the machine's true drive, or nil without one.
+      def self.for(computer)
+        drive = computer.drive1541
+        drive ? new(drive) : nil
+      end
+
+      # Sets SDL.led_rect to where the LED goes.
+      def self.place
+        rect = SDL.led_rect
+        SDL.rect_x(rect, LEFT)
+        SDL.rect_y(rect, TOP)
+        SDL.rect_w(rect, WIDTH)
+        SDL.rect_h(rect, HEIGHT)
+      end
+
+      def initialize(drive)
+        @drive = drive
+      end
+
+      def lit? = @drive.led_on?
+
+      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
+        rgb = color
+        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
+end

data/lib/badline/frontend/frame_rate.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # How many cycles a frame clocks and how long it lasts. Without vsync a
+    # frame is one of the machine's frames: on PAL 312 lines of 63 cycles
+    # over 19.95 ms. With vsync a frame lasts one display refresh and clocks as
+    # many cycles as the machine runs in that time, so a 60 Hz display
+    # shows 60 PAL frames of 16,420 cycles a second.
+    #
+    # A display's reported refresh rate is a whole number, and can be some
+    # way off the rate it presents at. #refit sizes the frames to the rate
+    # measured instead, as long as that is within REFIT of the reported one.
+    #
+    # While the sound plays under vsync, the display paces the frames but
+    # the audio device consumes the samples, and the two clocks still drift
+    # apart. #cycles steers the audio queue towards its target: it trims
+    # each frame by up to PROPORTIONAL of the queue's error, and by a trim
+    # that builds up by INTEGRAL a frame while the error lasts, up to
+    # MAX_TRIM, so the queue settles at the target instead of beside it.
+    class FrameRate
+      # A display that reports no refresh rate is taken to run at this.
+      DEFAULT_REFRESH = 60
+      PROPORTIONAL = 0.02
+      INTEGRAL = 0.0001
+      MAX_TRIM = 0.05
+      # Presenting faster than this many times the refresh rate means vsync
+      # isn't waiting for the display.
+      VSYNC_SLACK = 1.5
+      REFIT = 0.1
+
+      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)
+      end
+
+      def self.display(refresh, clock_hz)
+        refresh = DEFAULT_REFRESH unless refresh.positive?
+        cycles = clock_hz / refresh
+        new(cycles, cycles.to_f / clock_hz, refresh, clock_hz)
+      end
+
+      def initialize(base_cycles, seconds, refresh, clock_hz)
+        @base_cycles = base_cycles
+        @seconds = seconds
+        @refresh = refresh
+        @clock_hz = clock_hz
+        @trim = 0.0
+      end
+
+      # The cycles for the next frame, steering the audio queue's `level`
+      # towards `target` (both in seconds).
+      def cycles(level, target)
+        error = (target - level) / target
+        error = 1.0 if error > 1.0
+        error = -1.0 if error < -1.0
+        @trim += INTEGRAL * error
+        @trim = MAX_TRIM if @trim > MAX_TRIM
+        @trim = -MAX_TRIM if @trim < -MAX_TRIM
+        (@base_cycles * (1.0 + @trim + (PROPORTIONAL * error))).round
+      end
+
+      # Sizes the frames to `frames` that lasted `elapsed` seconds.
+      def refit(frames, elapsed)
+        return unless frames.positive? && elapsed.positive?
+        return if ((frames / elapsed) - @refresh).abs > @refresh * REFIT
+
+        @base_cycles = (@clock_hz * elapsed / frames).round
+        @seconds = @base_cycles.to_f / @clock_hz
+      end
+
+      # Whether `frames` presented in `elapsed` seconds kept to the display.
+      def vsync_holds?(frames, elapsed)
+        return true unless elapsed.positive?
+
+        frames / elapsed <= @refresh * VSYNC_SLACK
+      end
+    end
+  end
+end