badline 0.6.0 → 0.7.0

data/lib/badline/ffi.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Badline
+  # The part of Spinel's FFI DSL the SDL binding uses, for CRuby, over
+  # Fiddle, so the one binding in badline/sdl serves both builds. Spinel
+  # compiles the declarations itself and never loads this file: require it
+  # before a file that declares a binding.
+  #
+  # The declarations behave as they do in Spinel. ffi_func defines
+  # Module.name(...); a pointer argument takes nil for NULL, a Fiddle
+  # pointer, a String (its bytes) or an IO::Buffer, whose contents C sees
+  # for the call's duration; a NULL pointer comes back as nil. ffi_const
+  # sets Module::NAME, ffi_buffer defines Module.name returning a zeroed
+  # static buffer, and ffi_read_<width> and ffi_write_<width> define field
+  # accessors at a fixed offset into a pointer.
+  module FFI
+    class Error < StandardError; end
+
+    TYPES = {
+      void: Fiddle::TYPE_VOID,
+      int: Fiddle::TYPE_INT, bool: Fiddle::TYPE_INT, long: Fiddle::TYPE_LONG, size_t: Fiddle::TYPE_SIZE_T,
+      int8: Fiddle::TYPE_INT8_T, uint8: Fiddle::TYPE_UINT8_T, int16: Fiddle::TYPE_INT16_T,
+      uint16: Fiddle::TYPE_UINT16_T, int32: Fiddle::TYPE_INT32_T, uint32: Fiddle::TYPE_UINT32_T,
+      float: Fiddle::TYPE_FLOAT, double: Fiddle::TYPE_DOUBLE,
+      str: Fiddle::TYPE_CONST_STRING,
+      ptr: Fiddle::TYPE_VOIDP, buffer_in: Fiddle::TYPE_VOIDP, buffer_out: Fiddle::TYPE_VOIDP,
+      buffer_inout: Fiddle::TYPE_VOIDP, int_array: Fiddle::TYPE_VOIDP, float_array: Fiddle::TYPE_VOIDP
+    }.freeze
+
+    # The argument specs C may write through, so an IO::Buffer passed in one
+    # gets back what C left in it.
+    WRITABLE = %i[ptr buffer_out buffer_inout].freeze
+
+    # pack directives for the accessor widths, in the host's byte order.
+    WIDTHS = {
+      u8: "C", i8: "c", u16: "S", i16: "s", u32: "L", i32: "l", u64: "Q", i64: "q", ptr: "J"
+    }.freeze
+
+    # Where dlopen looks for a library besides its search path, which leaves
+    # out Homebrew's, and the versioned names a runtime package installs
+    # without the development package's unversioned link.
+    DIRECTORIES = [nil, "/opt/homebrew/lib", "/usr/local/lib"].freeze
+    VERSIONED = { "SDL2" => %w[libSDL2-2.0.so.0 libSDL2-2.0.0.dylib] }.freeze
+
+    module_function
+
+    def open_library(name)
+      candidates = library_candidates(name)
+      candidates.each do |candidate|
+        return Fiddle.dlopen(candidate)
+      rescue Fiddle::DLError
+        next
+      end
+      raise Error, "can't find lib#{name} (tried #{candidates.join(', ')})"
+    end
+
+    def library_candidates(name)
+      names = ["lib#{name}.dylib", "lib#{name}.so", *VERSIONED.fetch(name, []), "#{name}.dll"]
+      DIRECTORIES.flat_map { |dir| names.map { |file| dir ? File.join(dir, file) : file } }
+    end
+
+    # The value Fiddle passes for one argument, and a block that copies what
+    # C wrote back into an IO::Buffer once the call returns.
+    def argument(spec, value)
+      case value
+      when IO::Buffer then buffer_argument(spec, value)
+      when Array then [value.pack(spec == :float_array ? "d*" : "q*")]
+      when true, false then [value ? 1 : 0]
+      else [value]
+      end
+    end
+
+    def buffer_argument(spec, buffer)
+      return [nil] if buffer.null? || buffer.empty?
+
+      bytes = buffer.get_string
+      return [bytes] unless WRITABLE.include?(spec) && !buffer.readonly?
+
+      [bytes, -> { buffer.set_string(bytes) }]
+    end
+
+    def result(spec, value)
+      case spec
+      when :ptr then value.null? ? nil : value
+      when :bool then value != 0
+      else value
+      end
+    end
+
+    def read(pointer, offset, width)
+      value = Fiddle::Pointer[pointer][offset, width_size(width)].unpack1(WIDTHS.fetch(width))
+      width == :ptr ? result(:ptr, Fiddle::Pointer.new(value)) : value
+    end
+
+    def write(pointer, offset, width, value)
+      value = value.to_i if width == :ptr
+      Fiddle::Pointer[pointer][offset, width_size(width)] = [value || 0].pack(WIDTHS.fetch(width))
+      value
+    end
+
+    def width_size(width) = [0].pack(WIDTHS.fetch(width)).bytesize
+
+    # The declarations, private methods of every module once this file is
+    # loaded, as they are keywords of a module body in Spinel.
+    module DSL
+      private
+
+      def ffi_lib(name)
+        (@ffi_libraries ||= []) << FFI.open_library(name)
+      end
+
+      def ffi_func(name, arguments, returns, blocking: false)
+        function = Fiddle::Function.new(ffi_symbol(name), arguments.map { |spec| TYPES.fetch(spec) },
+                                        TYPES.fetch(returns), name: name.to_s, need_gvl: !blocking)
+        define_singleton_method(name) do |*values|
+          converted = arguments.zip(values).map { |spec, value| FFI.argument(spec, value) }
+          returned = function.call(*converted.map(&:first))
+          converted.each { |argument| argument[1]&.call }
+          FFI.result(returns, returned)
+        end
+      end
+
+      def ffi_const(name, value)
+        const_set(name, value)
+      end
+
+      def ffi_buffer(name, size)
+        buffer = Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE)
+        buffer[0, size] = "\0" * size
+        define_singleton_method(name) { buffer }
+      end
+
+      WIDTHS.each_key do |width|
+        define_method(:"ffi_read_#{width}") do |name, offset|
+          define_singleton_method(name) { |pointer| FFI.read(pointer, offset, width) }
+        end
+
+        define_method(:"ffi_write_#{width}") do |name, offset|
+          define_singleton_method(name) { |pointer, value| FFI.write(pointer, offset, width, value) }
+        end
+      end
+
+      def ffi_symbol(name)
+        (@ffi_libraries || []).each do |library|
+          return library[name.to_s]
+        rescue Fiddle::DLError
+          next
+        end
+        Fiddle::Handle::DEFAULT[name.to_s]
+      end
+    end
+  end
+end
+
+Module.include(Badline::FFI::DSL)

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,73 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The host's audio device for --headless and the SID player, fed through
+    # SDL's queue: stereo signed 16-bit samples, the left and right
+    # interleaved, 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) / (4.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, 2)
+        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?, subtune: options.subtune,
+                                           disk: { read_only: options.read_only? })
+      end
+      computer
+    end
+  end
+end

data/lib/badline/frontend/buttons.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID player's buttons: each is drawn where it goes on every frame,
+    # and remembers its place, so a click finds the action under it. The
+    # one under the pointer lights up, and one that's on is drawn reversed.
+    class Buttons
+      PAD = 2
+      HEIGHT = Painter::GLYPH + (PAD * 2)
+
+      def initialize(painter)
+        @painter = painter
+        @lefts = []
+        @tops = []
+        @widths = []
+        @heights = []
+        @actions = []
+        @pointer_x = -1
+        @pointer_y = -1
+      end
+
+      def forget
+        @lefts.clear
+        @tops.clear
+        @widths.clear
+        @heights.clear
+        @actions.clear
+      end
+
+      def point(left, top)
+        @pointer_x = left
+        @pointer_y = top
+      end
+
+      # Draws a button labelled `label` with its top left at `left`, `top`,
+      # and returns its width.
+      def text(left, top, label, action, on: false)
+        width = Painter.width(label) + (PAD * 2)
+        place(left, top, width, HEIGHT, action)
+        @painter.box(left, top, width, HEIGHT, SIDView::TEXT) if on
+        @painter.text(left + PAD, top + PAD, label, on ? PlayerScreen::BACKGROUND : color(@actions.size - 1))
+        width
+      end
+
+      # Draws an icon button `scale` times the size of a glyph, and returns
+      # its width.
+      def icon(left, top, name, action, scale: 1)
+        size = (Painter::GLYPH * scale) + (PAD * 2)
+        place(left, top, size, size, action)
+        @painter.icon(name, left + PAD, top + PAD, color(@actions.size - 1), scale:)
+        size
+      end
+
+      # Makes a box drawn elsewhere clickable, such as the bar showing the
+      # time played.
+      def area(box, action)
+        place(box[0], box[1], box[2], box[3], action)
+      end
+
+      # The action of the button at `left`, `top`, or nil.
+      def action_at(left, top)
+        index = 0
+        while index < @actions.size
+          return @actions[index] if inside?(index, left, top)
+
+          index += 1
+        end
+        nil
+      end
+
+      private
+
+      def place(left, top, width, height, action)
+        @lefts << left
+        @tops << top
+        @widths << width
+        @heights << height
+        @actions << action
+      end
+
+      def color(index) = inside?(index, @pointer_x, @pointer_y) ? SIDView::BRIGHT : SIDView::TEXT
+
+      def inside?(index, left, top)
+        left >= @lefts[index] && left < @lefts[index] + @widths[index] &&
+          top >= @tops[index] && top < @tops[index] + @heights[index]
+      end
+    end
+  end
+end