badline 0.6.0 → 0.7.0

data/lib/badline/frontend/player_state.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # What the SID player's window shows about playback: the subtune and the
+    # tune's place in the queue, the time, the modes the jukebox reports
+    # as notes, the view and SID model chosen, which of a tune's SIDs the
+    # SID view shows, and where a seek is headed until playback gets there.
+    class PlayerState
+      attr_accessor :subtune, :subtunes, :tune, :tunes, :length, :notes, :view, :chip, :sid
+      attr_reader :target
+
+      def initialize
+        @subtune = 0
+        @subtunes = 0
+        @tune = 0
+        @tunes = 0
+        @length = 0.0
+        @notes = []
+        @view = 0
+        @chip = 0
+        @sid = 0
+        @elapsed = 0.0
+        @elapsed_at = now
+        @target = 0.0
+        @below = false
+      end
+
+      # The seconds heard as the jukebox last reported them.
+      def elapsed=(seconds)
+        @elapsed = seconds
+        @elapsed_at = now
+        return unless seeking?
+
+        @below ||= seconds < @target
+        stop_seeking if @below && seconds >= @target
+      end
+
+      # Notes a seek to `seconds`, which lasts until playback has come up
+      # to it from below.
+      def seek(seconds)
+        @target = seconds
+        @below = false
+      end
+
+      def stop_seeking = @target = 0.0
+
+      def seeking? = @target.positive?
+
+      # The seconds heard so far: the last reported, carried on by the
+      # clock unless it is paused.
+      def played
+        return @elapsed if paused?
+
+        [@elapsed + (now - @elapsed_at), @length].min
+      end
+
+      def paused? = on?("paused")
+
+      def on?(note) = @notes.include?(note)
+
+      private
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/frontend/player_window.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The SID player's window, which `sid` plays in, drawn by PlayerScreen:
+    # a header with the tune, its STIL credit, the views and the SID model,
+    # and a footer with the time and the buttons that step through the
+    # queue, framing one of three views: the visualizer, with each voice's
+    # note and output and the mix, the SID view, with everything the chip
+    # is doing, and the tune's STIL entry. The window's height follows the
+    # view, and .sid files and folders dropped on it join the queue.
+    #
+    # It stands in for the terminal, so Audio::Jukebox drives it the same
+    # way: #wait handles the window's clicks, keys and drops between frames
+    # and redraws it at the display's pace. The SID model buttons switch
+    # the chips playing on the spot, and each tune after it starts on the
+    # same choice. AUTO gives each of a tune's SIDs its own model.
+    class PlayerWindow < Audio::Terminal
+      FRAME = 1.0 / 50
+
+      MOUSEWHEEL = 0x403
+      DROPFILE = 0x1000
+      UP = 82
+      DOWN = 81
+
+      WARNING = Screen::COLORS[10]
+
+      CHIPS = PlayerHeader::CHIPS
+
+      KEYS = {
+        17 => :next, 19 => :previous,
+        79 => :next_subtune, 80 => :previous_subtune,
+        44 => :pause, 22 => :shuffle, 15 => :loop, 4 => :all_subtunes,
+        20 => :quit, 41 => :quit,
+        54 => :back, 55 => :forward,
+        43 => :view, 6 => :chip
+      }.freeze
+
+      def initialize(input:, output:)
+        super
+        @screen = PlayerScreen.new
+        @player = nil
+        @tune_file = nil
+        @history = SIDHistory.new(Audio::Renderer::DEFAULT_RATE)
+        @state = PlayerState.new
+        @commands = PlayerCommands.new(@state)
+        @next_draw = 0.0
+        @seek_left = 0
+        @dropped = []
+        @credits = []
+        @stil = []
+        @stil_subtune = 0
+        @subtune_stil = []
+        @scrolling = false
+      end
+
+      # The seconds into the subtune the last click on the bar asked for.
+      def seek_to = PlayerFooter.seek(@seek_left, @state.length)
+
+      # The files dropped on the window since it last said :drop.
+      def dropped
+        paths = @dropped
+        @dropped = []
+        paths
+      end
+
+      def session
+        @screen.open(@state.view)
+        @screen.info.show(@stil, @stil_subtune, @subtune_stil)
+        yield
+      ensure
+        @screen.close
+      end
+
+      # Handles the window's clicks, keys and drops and redraws it until
+      # `seconds` are up, returning early with those that ask the jukebox
+      # for something.
+      def wait(seconds)
+        actions = poll
+        deadline = now + seconds
+        loop do
+          draw if now >= @next_draw
+          left = deadline - now
+          break if left <= 0 || !actions.empty?
+
+          SDL.SDL_Delay([([left, @next_draw - now].min * 1000).floor, 1].max)
+          actions.concat(poll)
+        end
+        actions
+      end
+
+      def header(lines) = lines
+
+      def announce(lines) = lines
+
+      def place(tune, tunes)
+        @state.stop_seeking unless tune == @state.tune
+        @state.tune = tune
+        @state.tunes = tunes
+      end
+
+      def status(subtune:, subtunes:, elapsed:, length:, notes: [])
+        state = @state
+        state.stop_seeking unless subtune == state.subtune
+        state.subtune = subtune
+        state.subtunes = subtunes
+        state.elapsed = elapsed
+        state.length = length
+        state.notes = notes
+      end
+
+      # 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)
+        @stil = fields
+        @stil_subtune = subtune
+        @subtune_stil = subtune_fields
+        @screen.info.show(fields, subtune, subtune_fields) if @screen.open?
+      end
+
+      # Follows the renderer's SIDs from here on, on the model chosen.
+      def playing(renderer)
+        @player = renderer.player
+        @tune_file = renderer.tune
+        stereo = @player.stereo
+        @history = SIDHistory.new(renderer.rate, stereo.sids.size)
+        stereo.sids.each(&:record_voices!)
+        renderer.observer = ->(samples, rendered) { @history.record(stereo.sids, stereo.outputs, samples, rendered) }
+        choose_model
+        @screen.fit_sids(@state.view, stereo.sids.size)
+        @screen.title(renderer.tune.name)
+      end
+
+      private
+
+      def poll
+        actions = []
+        while SDL.SDL_PollEvent(SDL.event) != 0
+          case SDL.event_type(SDL.event)
+          when SDL::QUIT then actions << :quit
+          when SDL::KEYDOWN then key(SDL.event_scancode(SDL.event), actions) if SDL.event_repeat(SDL.event).zero?
+          when SDL::MOUSEMOTION then point
+          when SDL::MOUSEBUTTONDOWN then click(actions) if SDL.event_button(SDL.event) == 1
+          when SDL::MOUSEBUTTONUP then @scrolling = false
+          when MOUSEWHEEL then @screen.info.scroll(-3 * SDL.event_x(SDL.event))
+          when DROPFILE then drop(actions)
+          end
+        end
+        actions
+      end
+
+      def drop(actions)
+        file = SDL.event_file(SDL.event)
+        @dropped << LibC.strstr(file, "")
+        LibC.free(file)
+        actions << :drop unless actions.include?(:drop)
+      end
+
+      def point
+        top = SDL.event_y(SDL.event)
+        @screen.buttons.point(SDL.event_x(SDL.event), top)
+        @screen.info.scroll_along(top) if @scrolling
+      end
+
+      def key(scancode, actions)
+        return @screen.info.scroll(scancode == UP ? -1 : 1) if [UP, DOWN].include?(scancode)
+
+        action = KEYS[scancode]
+        command(action, actions) unless action.nil?
+      end
+
+      def click(actions)
+        left = SDL.event_x(SDL.event)
+        action = @screen.buttons.action_at(left, SDL.event_y(SDL.event))
+        return if action.nil?
+
+        @seek_left = left if action == :seek
+        return scroll_along if action == :scroll
+
+        command(action, actions)
+      end
+
+      # Lets PlayerCommands handle the action, then follows a change of view
+      # or SID model it made.
+      def command(action, actions)
+        view = @state.view
+        chip = @state.chip
+        passed = @commands.handle(action)
+        follow_seek(passed) if %i[seek forward back].include?(passed)
+        actions << passed unless passed.nil?
+        resize unless view == @state.view
+        choose_model unless chip == @state.chip
+      end
+
+      # Notes where a seek is headed, as the jukebox will take it.
+      def follow_seek(action)
+        state = @state
+        step = Audio::Jukebox::SEEK_STEP
+        seconds = { seek: seek_to, forward: state.played + step, back: state.played - step }.fetch(action)
+        state.seek(seconds.clamp(0.0, [state.length - 1.0, 0.0].max))
+      end
+
+      def scroll_along
+        @scrolling = true
+        @screen.info.scroll_along(SDL.event_y(SDL.event))
+      end
+
+      def resize
+        @screen.resize(@state.view)
+        @next_draw = 0.0
+      end
+
+      def choose_model
+        return if @player.nil?
+
+        @player.stereo.refit(CHIPS[@state.chip])
+      end
+
+      def draw
+        @next_draw = now + FRAME
+        @screen.draw(@state, @player, @history, @tune_file, Storage::STIL::Credit.at(@credits, @state.played))
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/frontend/scope.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # An oscilloscope in a box: one channel of SIDHistory's samples, as
+    # heard, with the trace held still on a rising edge. `box` is its left,
+    # top, width and height, `span` how many samples fit its width and
+    # `range` the swing that fills its height. The trace is centred on the
+    # middle of the samples' range when `centred`, and on zero otherwise.
+    class Scope
+      def initialize(painter, box, span:, range:, centred: false)
+        @painter = painter
+        @left = box[0]
+        @top = box[1]
+        @width = box[2]
+        @height = box[3]
+        @span = span
+        @range = range
+        @centred = centred
+        @points = Array.new(@width + 1, 0)
+      end
+
+      def draw(history, played, channel, rgb)
+        @painter.box(@left, @top, @width, @height, SIDView::BOX)
+        span = @span
+        range = @range
+        start = history.scope_start(played, span, channel)
+        middle = @centred ? history.middle(start, span, channel) : 0
+        centre = @top + (@height / 2)
+        points = @points
+        x = 0
+        while x <= @width
+          value = history.sample_at(start + (x * span / @width), channel) - middle
+          top = (centre - (value * (@height - 4) / range)).clamp(@top, @top + @height - 1)
+          points[x] = Painter.point(@left + x, top)
+          x += 1
+        end
+        @painter.polyline(points, rgb)
+      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/sid_history.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Each SID's state at the end of each frame rendered, and the samples
+    # rendered, kept for long enough that the SID player can show what is
+    # being heard rather than what was last rendered: rendering runs ahead
+    # of the audio device by the queue in between.
+    #
+    # The samples come in four channels a SID, 0 to 3 for SID 1, 4 to 7 for
+    # SID 2 and so on: each voice's own output, when the SID records them,
+    # then the SID's own output (#output). The left and right of the mix
+    # follow them all (#left and #right).
+    class SIDHistory
+      FRAMES = 64
+      SAMPLES = 16_384
+
+      # Per frame: the 25 write registers, then each voice's envelope level,
+      # then each voice's envelope state as an index into STATES.
+      FIELDS = 31
+      LEVELS = 25
+      PHASES = 28
+
+      STATES = %i[attack decay_sustain release].freeze
+
+      # SID 1's own output, which is the mix with only one SID.
+      MIX = 3
+
+      attr_reader :rate, :sid_count
+
+      def initialize(rate, sid_count = 1)
+        @rate = rate
+        @sid_count = sid_count
+        @channels = (sid_count * 4) + 2
+        @times = Array.new(FRAMES, 0.0)
+        @states = Array.new(FRAMES * FIELDS * sid_count, 0)
+        @frames = 0
+        @samples = Array.new(SAMPLES * @channels, 0)
+        @written = 0
+        @rendered = 0.0
+      end
+
+      # Keeps the frame that ends at `rendered` seconds: the state of each of
+      # `sids`, each one's own samples in `outputs`, and the stereo mix in
+      # `samples`, the left and right interleaved.
+      def record(sids, outputs, samples, rendered)
+        slot = @frames % FRAMES
+        @times[slot] = rendered
+        sids.size.times { |index| keep_state(sids[index], ((slot * @sid_count) + index) * FIELDS) }
+        @frames += 1
+        keep(sids, outputs, samples)
+        @rendered = rendered
+      end
+
+      def empty? = @frames.zero?
+
+      def output(sid) = (sid * 4) + MIX
+
+      def left = @sid_count * 4
+
+      def right = left + 1
+
+      # Where the fields of SID `sid` in the frame heard at `played` seconds
+      # start: the latest frame rendered by then, or the oldest kept.
+      def frame(played, sid = 0)
+        kept = [@frames, FRAMES].min
+        newest = @frames - 1
+        age = 0
+        while age < kept - 1
+          break if @times[(newest - age) % FRAMES] <= played
+
+          age += 1
+        end
+        ((((newest - age) % FRAMES) * @sid_count) + sid) * FIELDS
+      end
+
+      def register(frame, reg) = @states[frame + reg]
+
+      # The voice's oscillator frequency in hertz, at the SID's clock.
+      def hertz(frame, voice, clock_hz)
+        base = voice * 7
+        (register(frame, base) | (register(frame, base + 1) << 8)) * clock_hz / 16_777_216.0
+      end
+
+      def level(frame, voice) = @states[frame + LEVELS + voice]
+
+      def state(frame, voice) = STATES[@states[frame + PHASES + voice]]
+
+      # The first of `count` samples of `channel` heard up to `played`
+      # seconds, moved back to where the wave last rose through its middle,
+      # so a steady tone holds still from one frame to the next.
+      def scope_start(played, count, channel = MIX)
+        last = @written - ((@rendered - played) * @rate).round
+        last = @written if last > @written
+        earliest = [@written - SAMPLES, 0].max
+        start = last - count
+        return earliest if start < earliest
+
+        rising(start, [start - count, earliest].max, channel)
+      end
+
+      def sample_at(index, channel = MIX) = @samples[((index % SAMPLES) * @channels) + channel]
+
+      # The middle of the range `channel` covers over `count` samples from
+      # `start`, which a voice's scope centres on.
+      def middle(start, count, channel)
+        low = high = sample_at(start, channel)
+        index = start + 1
+        while index < start + count
+          value = sample_at(index, channel)
+          low = value if value < low
+          high = value if value > high
+          index += 1
+        end
+        (low + high) / 2
+      end
+
+      private
+
+      def keep_state(sid, base)
+        states = @states
+        25.times { |reg| states[base + reg] = sid.register(reg) }
+        voices = sid.voices
+        3.times do |voice|
+          envelope = voices[voice].envelope
+          states[base + LEVELS + voice] = envelope.counter
+          states[base + PHASES + voice] = STATES.index(envelope.state) || 0
+        end
+      end
+
+      def keep(sids, outputs, samples)
+        first = @written
+        sids.size.times { |index| keep_sid(first, index * 4, outputs[index], sids[index].drain_voice_samples) }
+        stored = @samples
+        channels = @channels
+        left = channels - 2
+        i = 0
+        while (i * 2) + 1 < samples.size
+          slot = ((@written % SAMPLES) * channels) + left
+          stored[slot] = samples[i * 2]
+          stored[slot + 1] = samples[(i * 2) + 1]
+          @written += 1
+          i += 1
+        end
+      end
+
+      def keep_sid(first, channel, output, voices)
+        stored = @samples
+        channels = @channels
+        i = 0
+        while i < output.size
+          slot = (((first + i) % SAMPLES) * channels) + channel
+          stored[slot + MIX] = output[i]
+          if voices.size > (i * 3) + 2
+            stored[slot] = voices[i * 3]
+            stored[slot + 1] = voices[(i * 3) + 1]
+            stored[slot + 2] = voices[(i * 3) + 2]
+          end
+          i += 1
+        end
+      end
+
+      def rising(start, limit, channel)
+        middle = middle(limit, start - limit + 1, channel)
+        index = start
+        while index > limit
+          return index if sample_at(index - 1, channel) < middle && sample_at(index, channel) >= middle
+
+          index -= 1
+        end
+        start
+      end
+    end
+  end
+end