badline 0.6.1 → 0.7.0

data/lib/badline/audio/queued_tune.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # A .sid tune in the player's Media::Queue, read only once the queue or
+    # the player first asks about it, so a queue of a whole collection
+    # starts at once. Its subtunes, SID model and lengths follow the options:
+    # --subtune picks the subtune to start on, --sid the model and --seconds the
+    # length, and without them the tune's own header and HVSC's database
+    # decide.
+    #
+    # A file that won't read as a tune, or lacks the subtune asked for, gets
+    # an #error and a single subtune.
+    class QueuedTune < Media::Queue::Entry
+      def initialize(path, options, subtune: nil)
+        super(path)
+        @options = options
+        @subtune = subtune
+        @tune = nil
+        @read = false
+        @error = ""
+        @lengths = nil
+        @lengths_read = false
+      end
+
+      def part
+        read
+        @part
+      end
+
+      def parts
+        read
+        @parts
+      end
+
+      # Why the tune can't play, or "" when it can.
+      def error
+        read
+        @error
+      end
+
+      def tune = @tune ||= Storage::SIDFile.new(path)
+
+      # Lets go of the tune's data, which #tune reads again if asked.
+      def release = @tune = nil
+
+      # Each SID's model, SID 1's first: the one --sid names for all of
+      # them, or each one's own.
+      def sid_models
+        forced = @options.sid_model
+        forced ? Array.new(tune.sids, forced) : tune.sid_models
+      end
+
+      def model_name = sid_models.map { |model| model.to_s.delete_prefix("mos") }.join(" + ")
+
+      def length(subtune) = @options.seconds || songlengths&.at(subtune - 1) || @options.fallback_seconds
+
+      # How long the subtune may stay silent before it ends, or nil when its
+      # length is known rather than the fallback.
+      def silence(subtune) = @options.seconds || songlengths&.at(subtune - 1) ? nil : @options.silence_seconds
+
+      # The header's name, author and release, those it fills in.
+      def header = [tune.name, tune.author, tune.released].reject(&:empty?)
+
+      private
+
+      def read
+        return if @read
+
+        @read = true
+        @parts = tune.subtunes
+        @part = @subtune || tune.start_subtune
+        @error = "no subtune #{@part}: the tune has #{@parts}" if @part > @parts
+      rescue Storage::SIDFile::FormatError => e
+        @error = e.message
+      end
+
+      # HVSC's database is keyed by the tune's MD5 and lists one length per
+      # subtune.
+      def songlengths
+        return @lengths if @lengths_read
+
+        @lengths_read = true
+        database = @options.songlengths || Storage::SongLengths.locate(path)
+        @lengths = database && Storage::SongLengths.new(database).lengths(tune.md5)
+      end
+    end
+  end
+end

data/lib/badline/audio/renderer.rb

@@ -3,40 +3,70 @@
 module Badline
   module Audio
     # Renders a .sid tune to a PCM file, or streams its samples to whoever
-    # plays them. A PSID tune with a play address runs on the bare rig;
-    # anything else drives its own interrupts and needs the whole machine.
+    # plays them, in stereo with the left and right interleaved (Stereo).
+    # A PSID tune with a play address runs on the bare rig; anything else
+    # drives its own interrupts and needs the whole machine.
     #
     # A .sid file carries no length, so the caller says how many seconds to
-    # render.
+    # render. For a tune whose length is a guess, #silence= also ends it
+    # once the output has held still for that many seconds.
     class Renderer
       class UnknownFormatError < StandardError; end
 
       DEFAULT_RATE = 44_100
 
+      # How far a sample may stray from where the output settled and still
+      # count as silence. A 6581 settles at a DC offset rather than at zero.
+      QUIET = 16
+
       CONTAINERS = { ".wav" => WAV, ".aiff" => AIFF, ".aif" => AIFF }.freeze
 
       # The cycles the SID's filter integrates at a time; 1 renders the
       # filter cycle by cycle, exactly.
       attr_writer :filter_chunk
 
-      def initialize(tune, seconds:, song: nil, rate: DEFAULT_RATE, sid_model: tune.sid_model)
+      # The seconds rendered so far, short of the length once the tune has
+      # fallen silent.
+      attr_reader :rendered, :tune, :rate
+
+      # Hears each frame's samples and the seconds rendered by its end, as
+      # they are rendered.
+      attr_writer :observer
+
+      # Where #stream starts: the frames before it are rendered as fast as
+      # they go and yielded without their samples, so the seconds rendered
+      # still count up to it. Set while streaming, it skips ahead from the
+      # frame rendered last.
+      attr_writer :from
+
+      def initialize(tune, seconds:, subtune: nil, rate: DEFAULT_RATE, sid_models: tune.sid_models)
         @tune = tune
         @seconds = seconds
-        @song = song
+        @subtune = subtune
         @rate = rate
-        @sid_model = sid_model
+        @sid_models = sid_models
         @filter_chunk = SID::FILTER_CHUNK
+        @silent_samples = 0
+        @level = 0
+        @still = 0
+        @rendered = 0.0
+        @observer = ->(_samples, _rendered) {}
+        @from = 0.0
+      end
+
+      def silence=(seconds)
+        @silent_samples = (seconds * @rate).round
       end
 
       def player
-        @player ||= (bare? ? BarePlayer : MachinePlayer).new(@tune, song: @song, sid_model: @sid_model)
+        @player ||= (bare? ? BarePlayer : MachinePlayer).new(@tune, subtune: @subtune, sid_models: @sid_models)
       end
 
       # Yields the seconds rendered so far after every frame.
       def render(path)
         container = container_for(path)
         player.start
-        container.open(path, rate: @rate) do |writer|
+        container.open(path, rate: @rate, channels: 2) do |writer|
           each_frame do |samples, seconds|
             samples.each { |sample| writer << sample }
             yield seconds if block_given?
@@ -71,14 +101,31 @@ module Badline
       end
 
       def each_frame
-        player.sid.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
+        player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
         total = total_cycles
         remaining = total
         while remaining.positive?
           samples = []
           remaining -= player.frame(remaining) { |sample| samples << sample }
-          yield samples, (total - remaining).fdiv(player.clock_hz)
+          @rendered = (total - remaining).fdiv(player.clock_hz)
+          @observer.call(samples, @rendered)
+          yield(@rendered < @from ? [] : samples, @rendered)
+          break if fallen_silent?(samples)
+        end
+      end
+
+      # Counts the samples since the output last strayed more than QUIET
+      # from where it settled.
+      def fallen_silent?(samples)
+        return false if @silent_samples.zero? || samples.empty?
+
+        if samples.max - @level > QUIET || @level - samples.min > QUIET
+          @level = samples.last
+          @still = 0
+        else
+          @still += samples.length / 2
         end
+        @still >= @silent_samples
       end
     end
   end

data/lib/badline/audio/stereo.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Badline
+  module Audio
+    # The SIDs a tune plays on, the bus's own first and the extra ones at
+    # the addresses the tune's header gives, each on its own model. Their
+    # output mixes to interleaved stereo: SID 1 on the left, SID 2 on the
+    # right and SID 3 in the centre, at half on each side. A tune on one SID
+    # plays the same on both channels.
+    class Stereo
+      # The SIDs, in the order the header numbers them.
+      attr_reader :sids
+
+      # Each SID's own samples, as the last #mix drained them.
+      attr_reader :outputs
+
+      def initialize(bus, tune, models)
+        @sids = [bus.sid]
+        @extras = []
+        tune.sid_addresses.each do |address|
+          sid = SID.new(model: models[@sids.size], at: address)
+          bus.add_sid(sid)
+          @sids << sid
+          @extras << sid
+        end
+        @fitted = models
+        @outputs = []
+      end
+
+      # The SIDs past the bus's own, which the player clocks itself.
+      attr_reader :extras
+
+      def synthesize! = @sids.each(&:synthesize!)
+
+      # The model each SID plays on.
+      def models = @sids.map(&:model)
+
+      # Puts every SID on `model`, or with :auto each back on the one it was
+      # fitted with.
+      def refit(model)
+        @sids.size.times do |index|
+          wanted = model == :auto ? @fitted[index] : model
+          sid = @sids[index]
+          sid.model = wanted unless sid.model == wanted
+        end
+      end
+
+      def record(rate:, filter_chunk:, clock_hz:)
+        @sids.each { |sid| sid.record(rate:, filter_chunk:, clock_hz:) }
+      end
+
+      # Drains every SID and yields the left and the right of each sample
+      # in turn.
+      def mix(&)
+        outputs = @outputs
+        outputs.clear
+        @sids.each { |sid| outputs << sid.drain_samples }
+        case outputs.size
+        when 1 then both(outputs[0], &)
+        when 2 then pair(outputs[0], outputs[1], &)
+        else centred(outputs[0], outputs[1], outputs[2], &)
+        end
+      end
+
+      private
+
+      def both(samples)
+        i = 0
+        while i < samples.size
+          yield samples[i]
+          yield samples[i]
+          i += 1
+        end
+      end
+
+      def pair(left, right)
+        count = [left.size, right.size].min
+        i = 0
+        while i < count
+          yield left[i]
+          yield right[i]
+          i += 1
+        end
+      end
+
+      def centred(left, right, centre)
+        count = [left.size, right.size, centre.size].min
+        i = 0
+        while i < count
+          yield ((2 * left[i]) + centre[i]) / 3
+          yield ((2 * right[i]) + centre[i]) / 3
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/badline/audio/terminal.rb

@@ -10,9 +10,13 @@ module Badline
     # stty and poll(2) for the native badline.
     class Terminal
       KEYS = {
-        "n" => :next, "\e[C" => :next,
-        "p" => :previous, "\e[D" => :previous,
+        "n" => :next, "p" => :previous,
+        "\e[C" => :next_subtune, "\e[D" => :previous_subtune,
         " " => :pause,
+        "s" => :shuffle,
+        "l" => :loop,
+        "a" => :all_subtunes,
+        "," => :back, "." => :forward,
         "q" => :quit
       }.freeze
 
@@ -20,6 +24,8 @@ module Badline
         @input = input
         @output = output
         @closed = false
+        @tune = 1
+        @tunes = 1
       end
 
       # Raw input and a hidden cursor for the length of the block.
@@ -46,12 +52,39 @@ module Badline
 
       def header(lines)
         lines.each { |line| @output.print "#{line}\r\n" }
-        @output.print "n/→ next  p/← previous  space pause  q quit\r\n"
+        @output.print "←/→ subtune  n/p tune  ,/. seek  space pause  s shuffle  l loop  a all subtunes  q quit\r\n"
       end
 
-      def status(song:, songs:, elapsed:, length:, notes: [])
-        line = format("song %<song>d/%<songs>d  %<elapsed>s / %<length>s",
-                      song:, songs:, elapsed: clock(elapsed), length: clock(length))
+      # Prints lines above the status line, such as the next tune's header.
+      def announce(lines)
+        lines.each { |line| @output.print "\r\e[K#{line}\r\n" }
+      end
+
+      # The tune's place in the queue, which the status line shows once
+      # there is more than one.
+      def place(tune, tunes)
+        @tune = tune
+        @tunes = tunes
+      end
+
+      # Where :seek asks the subtune to play from, in seconds. Only a window
+      # asks for it, by a click on the time the subtune has played.
+      def seek_to = 0.0
+
+      # The files dropped on a window since it last said :drop.
+      def dropped = []
+
+      # Hears of the STIL fields for the tune and for the subtune starting,
+      # which the terminal prints as the CLI announces them.
+      def stil(fields, subtune, subtune_fields) = [fields, subtune, subtune_fields]
+
+      # Hears of each subtune's renderer as it starts playing.
+      def playing(renderer) = renderer
+
+      def status(subtune:, subtunes:, elapsed:, length:, notes: [])
+        line = format("subtune %<subtune>d/%<subtunes>d  %<elapsed>s / %<length>s",
+                      subtune:, subtunes:, elapsed: clock(elapsed), length: clock(length))
+        line = format("tune %<tune>d/%<tunes>d  %<line>s", tune: @tune, tunes: @tunes, line:) if @tunes > 1
         @output.print "\r\e[K#{([line] + notes).join('  ')}"
         @output.flush
       end

data/lib/badline/audio/wav.rb

@@ -10,7 +10,7 @@ module Badline
 
       def header
         ["RIFF", 0, "WAVE",
-         "fmt ", 16, 1, 1, rate, rate * 2, 2, 16,
+         "fmt ", 16, 1, channels, rate, rate * channels * 2, channels * 2, 16,
          "data", 0].pack("a4Va4a4VvvVVvva4V")
       end
 

data/lib/badline/audio.rb

@@ -3,10 +3,12 @@
 require "badline/audio/pcm_writer"
 require "badline/audio/wav"
 require "badline/audio/aiff"
+require "badline/audio/stereo"
 require "badline/audio/bare_player"
 require "badline/audio/machine_player"
 require "badline/audio/renderer"
 require "badline/audio/playback"
 require "badline/audio/terminal"
 require "badline/audio/jukebox"
+require "badline/audio/queued_tune"
 require "badline/audio/cli"

data/lib/badline/frontend/audio_sink.rb

@@ -2,9 +2,10 @@
 
 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.
+    # 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
 
@@ -33,7 +34,7 @@ module Badline
         check(SDL.SDL_QueueAudio(@device, buffer, bytes))
       end
 
-      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
+      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (4.0 * @rate)
 
       def start = SDL.SDL_PauseAudioDevice(@device, 0)
 
@@ -54,7 +55,7 @@ module Badline
       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_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?

data/lib/badline/frontend/boot.rb

@@ -43,7 +43,7 @@ module Badline
                               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,
+        puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
                                            disk: { read_only: options.read_only? })
       end
       computer

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

data/lib/badline/frontend/filter_view.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Draws the SID's filter as the player shows it: its modes, cutoff,
+    # resonance and volume, and its response across the audible range on
+    # the chip playing, whose cutoff curve the two models don't share.
+    class FilterView
+      TEXT = SIDView::TEXT
+      BRIGHT = SIDView::BRIGHT
+      DIM = SIDView::DIM
+      BOX = SIDView::BOX
+
+      MODES = ["LP", "BP", "HP", "3 OFF"].freeze
+
+      LEFT = SIDView::LEFT
+      CURVE_LEFT = 224
+      WIDTH = SIDView::WAVE_WIDTH
+      HEIGHT = SIDView::PANEL_HEIGHT
+
+      # The lowest and highest frequencies on the curve's axis.
+      LOW_HZ = 30.0
+      HIGH_HZ = 16_000.0
+
+      def initialize(painter)
+        @painter = painter
+        @curve = Array.new(WIDTH + 1, 0)
+      end
+
+      def draw(history, frame, top, model)
+        cutoff = (history.register(frame, 0x15) & 0x07) | (history.register(frame, 0x16) << 3)
+        resonance = history.register(frame, 0x17) >> 4
+        mode_volume = history.register(frame, 0x18)
+        hertz = SID::Filter::W0.fetch(model)[cutoff] / (2 * Math::PI * SID::Filter::SCALE)
+        paint = @painter
+        paint.text(LEFT, top, "FILTER", BRIGHT)
+        x = LEFT + 64
+        MODES.each_with_index do |name, bit|
+          x += paint.text(x, top, name, mode_volume[bit + 4] == 1 ? BRIGHT : DIM) + 8
+        end
+        paint.text(LEFT, top + 16, format("CUTOFF $%<cutoff>03X", cutoff:), TEXT)
+        paint.text(LEFT, top + 28, format("  %<hertz>d HZ", hertz: hertz.round), TEXT)
+        paint.text(LEFT, top + 40, format("RES %<res>X  VOL %<vol>X", res: resonance, vol: mode_volume & 0x0f), TEXT)
+        draw_curve(hertz, resonance, mode_volume, top)
+      end
+
+      private
+
+      # The gain for the modes selected on a logarithmic axis, with the
+      # cutoff marked.
+      def draw_curve(cutoff_hertz, resonance, mode_volume, top)
+        paint = @painter
+        paint.box(CURVE_LEFT, top, WIDTH, HEIGHT, BOX)
+        return paint.text(CURVE_LEFT + 8, top + 8, "NO MODE", DIM) if mode_volume.nobits?(0x70)
+
+        quality = 0.707 + (resonance / 15.0)
+        cutoff = [cutoff_hertz, 1.0].max
+        points = @curve
+        x = 0
+        while x <= WIDTH
+          hertz = LOW_HZ * ((HIGH_HZ / LOW_HZ)**(x.to_f / WIDTH))
+          decibels = gain(hertz / cutoff, quality, mode_volume).clamp(-36.0, 12.0)
+          points[x] = Painter.point(CURVE_LEFT + x, top + 8 + (((12.0 - decibels) * (HEIGHT - 12)) / 48.0).round)
+          x += 1
+        end
+        paint.polyline(points, BRIGHT)
+        marker = (WIDTH * Math.log(cutoff / LOW_HZ) / Math.log(HIGH_HZ / LOW_HZ)).round
+        paint.box(CURVE_LEFT + marker, top, 1, HEIGHT, DIM) if marker.between?(0, WIDTH)
+      end
+
+      # The gain in decibels of a two-pole state-variable filter at `ratio`
+      # of its cutoff, summing the low-, band- and high-pass outputs chosen.
+      def gain(ratio, quality, mode_volume)
+        real = 1.0 - (ratio * ratio)
+        imaginary = ratio / quality
+        denominator = (real * real) + (imaginary * imaginary)
+        out_real = 0.0
+        out_imaginary = 0.0
+        if mode_volume.anybits?(0x10)
+          out_real += real / denominator
+          out_imaginary -= imaginary / denominator
+        end
+        if mode_volume.anybits?(0x20)
+          out_real += ratio * imaginary / denominator
+          out_imaginary += ratio * real / denominator
+        end
+        if mode_volume.anybits?(0x40)
+          out_real -= ratio * ratio * real / denominator
+          out_imaginary += ratio * ratio * imaginary / denominator
+        end
+        magnitude = Math.sqrt((out_real * out_real) + (out_imaginary * out_imaginary))
+        20.0 * Math.log([magnitude, 1.0e-6].max) / Math.log(10)
+      end
+    end
+  end
+end