badline 0.5.1 → 0.6.1

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

data/lib/badline/frontend/timeline.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The events of --at and --script. Each runs once its number of frames
+    # has run: a screenshot saves that frame, and the rest act on the
+    # machine before the next frame is clocked. A key or the freeze button
+    # is let go Options::Event::HOLD frames after it is pressed. An event
+    # that fails ends the run.
+    class Timeline
+      # Takes the events, --screenshot's at the last frame and whether to
+      # insert disks write-protected from Options.
+      def initialize(options)
+        @events = options.timeline
+        unless options.screenshot.empty? || options.frames.zero?
+          @events += [Options::Event.new(options.frames, "screenshot", options.screenshot)]
+        end
+        @read_only = options.read_only?
+        @program = options.program
+        @releases = []
+        @failed = false
+      end
+
+      # What's wrong with the events, the first key that names nothing,
+      # or an empty string.
+      def self.error(events)
+        event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument) }
+        event.nil? ? "" : "no such key: #{event.argument}"
+      end
+
+      def self.key?(name) = name == "restore" || !keyboard_key(name).nil? || !joystick_direction(name).nil?
+
+      # The Keyboard's key for a name such as space, return or a.
+      def self.keyboard_key(name)
+        key = Keyboard.new.matrix.flatten.find { |candidate| candidate.to_s == name }
+        key.nil? ? Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name } : key
+      end
+
+      # The direction of joy1-NAME or joy2-NAME, such as up or fire.
+      def self.joystick_direction(name)
+        return nil unless name.start_with?("joy1-") || name.start_with?("joy2-")
+
+        Joystick::DIRECTIONS.keys.find { |direction| direction.to_s == name[5, name.size - 5] }
+      end
+
+      # The screenshot's file name, with the frame's number in place of %d,
+      # or of %Nd or %0Nd padded to N digits.
+      def self.path(pattern, frame)
+        start = pattern.index("%")
+        finish = start.nil? ? nil : pattern.index("d", start)
+        return pattern if finish.nil?
+
+        width = pattern[start + 1, finish - start - 1]
+        return pattern unless width.match?(/\A\d*\z/)
+
+        number = frame.to_s.rjust(width.to_i, width.start_with?("0") ? "0" : " ")
+        pattern[0, start] + number + pattern[finish + 1, pattern.size - finish - 1]
+      end
+
+      # The files the frame's screenshots go to.
+      def screenshots(frame)
+        @events.select { |event| event.frame == frame && event.action == "screenshot" }
+               .map { |event| Timeline.path(event.argument, frame) }
+      end
+
+      # Whether the run ends at the frame: at a quit, or once an event failed.
+      def quit?(frame) = @failed || @events.any? { |event| event.frame == frame && event.action == "quit" }
+
+      # Whether an event failed, which ends the run.
+      def failed? = @failed
+
+      # Lets go of what was held until this frame, then runs its events, up
+      # to one that fails.
+      def run(computer, frame)
+        @releases.each { |event| release(computer, event) if event.frame == frame }
+        @releases.reject! { |event| event.frame == frame }
+        @events.each { |event| perform(computer, event) if event.frame == frame && !@failed }
+      end
+
+      private
+
+      def perform(computer, event)
+        case event.action
+        when "key" then press(computer, event)
+        when "type" then computer.type_text(event.argument.gsub("\\n", "\r").gsub("\\r", "\r"))
+        when "insert" then insert(computer, event.argument)
+        when "eject" then eject(computer, event.argument)
+        when "reset" then computer.reset!
+        when "freeze" then freeze(computer, event)
+        end
+      end
+
+      def press(computer, event)
+        name = event.argument
+        if name == "restore"
+          computer.press_restore
+          return
+        end
+
+        direction = Timeline.joystick_direction(name)
+        if direction.nil?
+          computer.keyboard.press(Timeline.keyboard_key(name))
+        else
+          joystick(computer, name).press(direction)
+        end
+        hold(event)
+      end
+
+      def freeze(computer, event)
+        computer.press_cartridge_button
+        hold(event)
+      end
+
+      def hold(event)
+        @releases << Options::Event.new(event.frame + Options::Event::HOLD, event.action, event.argument)
+      end
+
+      def release(computer, event)
+        return computer.release_cartridge_button if event.action == "freeze"
+
+        name = event.argument
+        direction = Timeline.joystick_direction(name)
+        if direction.nil?
+          computer.keyboard.release(Timeline.keyboard_key(name))
+        else
+          joystick(computer, name).release(direction)
+        end
+      end
+
+      def joystick(computer, name) = name.start_with?("joy1-") ? computer.joystick1 : computer.joystick2
+
+      def insert(computer, path)
+        puts Media.attach(computer, path, autostart: false, disk: { read_only: @read_only })
+      rescue StandardError => e
+        warn "#{@program}: #{path}: #{e.message}"
+        @failed = true
+      end
+
+      def eject(computer, what)
+        return puts "No #{what} to eject" unless inserted?(computer, what)
+
+        if what == "disk"
+          eject_disk(computer)
+        elsif what == "tape"
+          computer.datasette.eject
+        else
+          computer.address_bus.detach_cartridge
+          computer.power_cycle!
+        end
+        puts "Ejected the #{what}"
+      end
+
+      def inserted?(computer, what)
+        return !computer.datasette.tape.nil? if what == "tape"
+        return !computer.address_bus.cartridge.nil? if what == "cartridge"
+
+        drive = Media::TrueDrive.drive(computer)
+        drive.nil? ? computer.mounted? : !drive.disk.nil?
+      end
+
+      def eject_disk(computer)
+        drive = Media::TrueDrive.drive(computer)
+        if drive.nil?
+          computer.unmount
+        else
+          drive.insert(nil)
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "badline/sdl"
+require "badline/frontend/boot"
+require "badline/frontend/frame_rate"
+require "badline/frontend/screen"
+require "badline/frontend/drive_led"
+require "badline/frontend/keys"
+require "badline/frontend/snapshots"
+require "badline/frontend/screenshot"
+require "badline/frontend/timeline"
+require "badline/frontend/sound"
+require "badline/frontend/pacer"
+require "badline/frontend/controls"
+require "badline/frontend/pad_port"
+require "badline/frontend/gamepads"
+require "badline/frontend/app"
+require "badline/frontend/audio_sink"

data/lib/badline/kernal_trap/channel.rb

@@ -80,6 +80,33 @@ module Badline
         data ? new(data) : new([], error: [Drive::ILLEGAL_TRACK_OR_SECTOR, track, sector])
       end
 
+      # Reads what save_state wrote after the flag that marks a file open
+      # for writing (Drive::Channels.channel_from_state). A buffer channel
+      # takes its block in `ram`, the drive's RAM, again.
+      def self.from_state(input, ram)
+        new.tap { |channel| channel.load_state(input, ram) }
+      end
+
+      # A buffer channel's bytes are the drive's RAM, which the drive
+      # writes itself.
+      def save_state(out)
+        out.boolean(false).boolean(@writable).int(@base).int(@length).int(@pointer)
+        out.optional_int(@lead).optional_int(@buffer).boolean(!@error.nil?)
+        out.ints(@error) if @error
+        out.blob(@bytes) unless @writable
+      end
+
+      def load_state(input, ram)
+        @writable = input.boolean?
+        @base = input.int
+        @length = input.int
+        @pointer = input.int
+        @lead = input.optional_int
+        @buffer = input.optional_int
+        @error = input.boolean? ? input.ints : nil
+        @bytes = @writable ? ram : input.blob
+      end
+
       def replace(bytes, length = bytes.length)
         @bytes = bytes
         rewind(length)

data/lib/badline/kernal_trap/drive/channels.rb

@@ -22,6 +22,31 @@ module Badline
 
         def clear = @channels.clear
 
+        # Each open channel with its secondary address, in the order they
+        # opened.
+        def save_state(out)
+          out.int(@channels.length)
+          @channels.each do |secondary, channel|
+            out.int(secondary)
+            channel.save_state(out)
+          end
+        end
+
+        # Buffer channels take their block in the drive's RAM again.
+        def load_state(input, memory)
+          @channels.clear
+          input.int.times do
+            secondary = input.int
+            @channels[secondary] = Channels.channel_from_state(input, memory.ram)
+          end
+        end
+
+        # A channel save_state wrote: a file open for writing, or a Channel
+        # whose buffer, if it has one, is in `ram`.
+        def self.channel_from_state(input, ram)
+          input.boolean? ? WriteFile.from_state(input) : Channel.from_state(input, ram)
+        end
+
         # Opens a buffer channel on the buffer a "#n" name asks for, or on
         # the highest free one. Returns nil when that buffer isn't free,
         # which leaves a channel asking again for its own buffer open.

data/lib/badline/kernal_trap/drive/memory.rb

@@ -62,6 +62,15 @@ module Badline
           load_buffer(Channels::BAM_BUFFER, block) if block
         end
 
+        def save_state(out)
+          out.blob(@ram).boolean(@bam)
+        end
+
+        def load_state(input)
+          input.blob_into(@ram)
+          @bam = input.boolean?
+        end
+
         # Whether the BAM has been read since the last reset.
         def bam? = @bam
 

data/lib/badline/kernal_trap/drive/status.rb

@@ -37,6 +37,14 @@ module Badline
           nil
         end
 
+        def save_state(out)
+          @channel.save_state(out)
+        end
+
+        def load_state(input)
+          @channel = Channels.channel_from_state(input, [])
+        end
+
         def replace(bytes)
           @channel.replace(bytes)
         end

data/lib/badline/kernal_trap/drive/write_file.rb

@@ -11,6 +11,17 @@ module Badline
         attr_accessor :buffer
         attr_reader :name, :type, :mode
 
+        TYPES = %i[del seq prg usr rel].freeze
+        MODES = %i[write replace append].freeze
+
+        # Reads what save_state wrote after the flag that marks a file
+        # open for writing.
+        def self.from_state(input)
+          name = input.string
+          type = TYPES.fetch(input.int).to_sym
+          new(name, type, mode: MODES.fetch(input.int).to_sym).tap { |file| file.load_state(input) }
+        end
+
         def initialize(name, type, mode: :write)
           @name = name
           @type = type
@@ -18,6 +29,16 @@ module Badline
           @bytes = []
         end
 
+        def save_state(out)
+          out.boolean(true).string(@name).int(TYPES.index(@type)).int(MODES.index(@mode))
+          out.blob(@bytes).optional_int(@buffer)
+        end
+
+        def load_state(input)
+          @bytes = input.blob
+          @buffer = input.optional_int
+        end
+
         def write(bytes) = @bytes.concat(bytes)
 
         def writable? = true

data/lib/badline/kernal_trap/drive.rb

@@ -143,6 +143,25 @@ module Badline
       # vector, as U: does.
       def reset! = reset(cold: true)
 
+      # The mounted storage's setup, for Storage.reopen, then the drive's
+      # RAM, its status and its open channels.
+      def save_state(out)
+        @storage.save_setup(out)
+        out.marker("TRAP DRIVE")
+        @memory.save_state(out)
+        @status.save_state(out)
+        @channels.save_state(out)
+      end
+
+      # Takes the state after the storage's setup, into a drive mounted on
+      # the reopened storage.
+      def load_state(input)
+        input.marker("TRAP DRIVE")
+        @memory.load_state(input)
+        @status.load_state(input)
+        @channels.load_state(input, @memory)
+      end
+
       # Returns the next byte and whether it is the channel's last, or nil
       # when there is nothing left to send.
       def read(secondary)

data/lib/badline/kernal_trap/save.rb

@@ -37,6 +37,14 @@ module Badline
         @saving = false
       end
 
+      def save_state(out)
+        out.boolean(@saving)
+      end
+
+      def load_state(input)
+        @saving = input.boolean?
+      end
+
       def call
         return unless active?
         return finish if @saving

data/lib/badline/kernal_trap/serial.rb

@@ -46,6 +46,22 @@ module Badline
         @buffer = []
       end
 
+      # The frame under way, with the channels and the bytes it gathered.
+      # The device it answers is the machine's to set.
+      def save_state(out)
+        out.boolean(@listening).boolean(@talking).optional_int(@listen_channel).optional_int(@talk_channel)
+        out.int(@frame).blob(@buffer)
+      end
+
+      def load_state(input)
+        @listening = input.boolean?
+        @talking = input.boolean?
+        @listen_channel = input.optional_int
+        @talk_channel = input.optional_int
+        @frame = input.int
+        @buffer = input.blob
+      end
+
       def install
         ROUTINES.each do |address, routine|
           @cpu.install_trap(address) { call_routine(routine) if kernal? }