badline 0.6.1 → 0.7.0

data/lib/badline/sid/catch_up.rb

@@ -96,7 +96,17 @@ module Badline
 
       def record_sample(span)
         sample = @decimator.push(current_sample, span)
-        @samples << sample if sample
+        return unless sample
+
+        @samples << sample
+        record_voices if @voice_samples
+      end
+
+      def record_voices
+        voice_samples = @voice_samples
+        voice_samples << (@voice1.output >> 7)
+        voice_samples << (@voice2.output >> 7)
+        voice_samples << (@voice3.output >> 7)
       end
 
       def current_sample

data/lib/badline/sid/filter.rb

@@ -122,6 +122,15 @@ module Badline
         reset
       end
 
+      # The integrators and the registers carry over; the cutoff maps
+      # through the new model's curve.
+      def model=(model)
+        @model = model
+        @w0_table = W0.fetch(model)
+        @mixer_dc = MIXER_DC.fetch(model)
+        @w0 = @w0_table[@cutoff]
+      end
+
       def reset
         @cutoff = 0x000
         @routing = 0x0

data/lib/badline/sid/voice.rb

@@ -33,6 +33,12 @@ module Badline
         @dc_offset = DC_OFFSET.fetch(model)
       end
 
+      def model=(model)
+        @waveform.model = model
+        @wave_zero = WAVE_ZERO.fetch(model)
+        @dc_offset = DC_OFFSET.fetch(model)
+      end
+
       def reset!
         @waveform.reset!
         @envelope = Envelope.new

data/lib/badline/sid/waveform.rb

@@ -54,17 +54,24 @@ module Badline
       attr_reader :accumulator, :shift_register, :frequency, :pulse_width, :pulse
 
       def initialize(model: :mos6581)
-        @topbit_feedback = model != :mos8580
+        use_model(model)
         @tri_saw_delay = model == :mos8580
-        @pulse_noise_read = PULSE_NOISE_READ.fetch(model)
-        @pulse_noise_write = PULSE_NOISE_WRITE.fetch(model)
-        @combined = Combined.tables(model)
-        @shift_register_reset_delay = SHIFT_REGISTER_RESET_DELAY.fetch(model)
         @accumulator = POWER_ON_ACCUMULATOR
         @sync_source = @sync_dest = self
         reset!
       end
 
+      # The running state carries over. A 6581 never delays its shapers, so
+      # the 8580's delayed triangle and sawtooth start from the current phase.
+      def model=(model)
+        use_model(model)
+        if model == :mos8580 && !@tri_saw_delay
+          @delayed_sawtooth = sawtooth
+          @delayed_triangle = triangle
+        end
+        @tri_saw_delay = model == :mos8580
+      end
+
       # The RES line clears the registers and reseeds the LFSR, but leaves
       # the accumulator alone (SID/oscinit).
       def reset!
@@ -190,6 +197,14 @@ module Badline
 
       private
 
+      def use_model(model)
+        @topbit_feedback = model != :mos8580
+        @pulse_noise_read = PULSE_NOISE_READ.fetch(model)
+        @pulse_noise_write = PULSE_NOISE_WRITE.fetch(model)
+        @combined = Combined.tables(model)
+        @shift_register_reset_delay = SHIFT_REGISTER_RESET_DELAY.fetch(model)
+      end
+
       def shape(selected, saw = sawtooth, tri = triangle(selected))
         case selected
         when 0x1 then tri

data/lib/badline/sid.rb

@@ -16,7 +16,9 @@ module Badline
   # $D41B-$D41C - Voice 3 oscillator/envelope - read only
   # $D41D-$D41F - Unconnected
   #
-  # The register file mirrors every 32 bytes up to $D7FF.
+  # The register file mirrors every 32 bytes up to $D7FF. A second or
+  # third SID, which only the SID player fits, is built `at` another
+  # address and decodes just the 32 bytes there.
   #
   # Reading a write-only or unconnected register returns the last byte the
   # SID saw on the data bus. That value fades to $00 as the capacitance
@@ -55,8 +57,8 @@ module Badline
     attr_accessor :pots
     attr_reader :model
 
-    def initialize(model: :mos6581, pots: nil, filter_chunk: FILTER_CHUNK)
-      addressable_at(0xd400, length: 2**10)
+    def initialize(model: :mos6581, pots: nil, filter_chunk: FILTER_CHUNK, at: 0xd400)
+      addressable_at(at, length: at == 0xd400 ? 2**10 : 2**5)
       @model = model
       @pots = pots
       @bus_ttl_reset = BUS_TTL.fetch(model)
@@ -67,6 +69,7 @@ module Badline
       @deferred_writes = []
       @decimator = nil
       @samples = []
+      @voice_samples = nil
       @filter_chunk = filter_chunk
       @voices = Voice.linked(VOICES, model:)
       @voice1, @voice2, @voice3 = @voices
@@ -74,6 +77,18 @@ module Badline
       reset!
     end
 
+    # Switches the chip, its filter and its voices to the other model's
+    # values. The cycles already passed run on the old model first, and the
+    # running state carries over.
+    def model=(model)
+      catch_up
+      @model = model
+      @bus_ttl_reset = BUS_TTL.fetch(model)
+      @filter.model = model
+      @voices.each { |voice| voice.model = model }
+      update_span_rules
+    end
+
     # The RES line clears the registers, the data bus, the filter and the
     # voices, all but their accumulators. Recording carries on across it.
     def reset!
@@ -112,6 +127,23 @@ module Badline
       @samples = []
     end
 
+    # Also keeps each voice's own output, before the filter and the volume,
+    # as each recorded sample closes, for #drain_voice_samples.
+    def record_voices!
+      @voice_samples = [] if @voice_samples.nil?
+    end
+
+    # The voices' outputs since the last drain, three to a sample, in voice
+    # order, or nothing unless #record_voices! asked for them.
+    def drain_voice_samples
+      return [] if @voice_samples.nil?
+
+      catch_up
+      samples = @voice_samples
+      @voice_samples = []
+      samples
+    end
+
     # The samples recorded since the last drain.
     def drain_samples
       catch_up

data/lib/badline/storage/hvsc.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # The layout of an HVSC collection: tunes in directories under its root,
+    # and databases about them in `DOCUMENTS`. A tune's HVSC path is its path
+    # from the root, as `/MUSICIANS/H/Hubbard_Rob/Commando.sid`.
+    module HVSC
+      class << self
+        # The named file in the DOCUMENTS directory of a collection above the
+        # tune, or else of the one `$HVSC_BASE` points at.
+        def document(tune_path, name)
+          candidates(tune_path).map { |dir| File.join(dir, "DOCUMENTS", name) }
+                               .find { |path| File.file?(path) }
+        end
+
+        # The tune's HVSC path in the collection that holds the document, or
+        # nil when the tune lies outside it.
+        def path(tune_path, document)
+          root = File.dirname(File.expand_path(document), 2)
+          tune = File.expand_path(tune_path)
+          tune.start_with?("#{root}/") ? tune[root.length..] : nil
+        end
+
+        private
+
+        def candidates(tune_path)
+          dirs = []
+          dir = File.dirname(File.expand_path(tune_path))
+          until dirs.last == dir
+            dirs << dir
+            dir = File.dirname(dir)
+          end
+          base = ENV.fetch("HVSC_BASE", nil)
+          dirs << base if base
+          dirs
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/sid_file.rb

@@ -16,7 +16,7 @@ module Badline
       # BASIC's RUN handler, where a BASIC tune starts.
       BASIC_RUN = 0xa871
 
-      # The 6502 stub that starts a tune: call init with the song number,
+      # The 6502 stub that starts a tune: call init with the subtune number,
       # point the KERNAL's IRQ vector at a raster handler that calls play,
       # and spin. Both calls are wrapped in the `$01` save, bank and restore
       # that puts the tune's own RAM under the CPU.
@@ -41,7 +41,7 @@ module Badline
       #         pha
       #         lda #iomap
       #         sta $01
-      #         lda #song
+      #         lda #subtune
       #         jsr init
       #         pla
       #         sta $01
@@ -70,9 +70,9 @@ module Badline
         CIA1_ICR = 0xdc0d
         RASTER_IRQ_STATUS = 0xd019
 
-        def initialize(tune, song:, base:)
+        def initialize(tune, subtune:, base:)
           @tune = tune
-          @song = song
+          @subtune = subtune
           @base = base
         end
 
@@ -96,7 +96,7 @@ module Badline
 
         def boot
           start = [0x78] +
-                  banked(@tune.init_address, lda_imm(@song) + jsr(@tune.init_address)) +
+                  banked(@tune.init_address, lda_imm(@subtune) + jsr(@tune.init_address)) +
                   raster_irq + [0x58]
           start + jmp(boot_address + start.length)
         end
@@ -153,14 +153,13 @@ module Badline
         raise FormatError, "Truncated header" if truncated?
         raise FormatError, "No tune data" if data.empty?
         raise FormatError, "Sidplayer MUS data, which needs a MUS player" if mus?
-        raise FormatError, "Written for #{sids} SIDs; only one is emulated" if sids > 1
       end
 
       def version = word(0x04)
       def data_offset = word(0x06)
       def play_address = word(0x0c)
-      def songs = [word(0x0e), 1].max
-      def start_song = word(0x10).clamp(1, songs)
+      def subtunes = [word(0x0e), 1].max
+      def start_subtune = word(0x10).clamp(1, subtunes)
       def speed = (word(0x12) << 16) + word(0x14)
       def name = text(0x16)
       def author = text(0x36)
@@ -181,22 +180,38 @@ module Badline
       # A v3 header can place a second SID at `$Dxx0` and a v4 header a
       # third, each given by its middle byte: even, and in `$d420-$d7e0` or
       # `$de00-$dfe0`. Anything else means the SID isn't there.
-      def sids
-        1 + [0x7a, 0x7b].first([version - 2, 0].max).count do |offset|
+      def sids = 1 + sid_addresses.size
+
+      # Where the second and third SIDs sit, those the header places.
+      def sid_addresses
+        addresses = []
+        [0x7a, 0x7b].first([version - 2, 0].max).each do |offset|
           page = @bytes[offset].to_i
-          page.even? && ((0x42..0x7e).cover?(page) || (0xe0..0xfe).cover?(page))
+          next unless page.even? && ((0x42..0x7e).cover?(page) || (0xe0..0xfe).cover?(page))
+
+          addresses << (0xd000 | (page << 4))
         end
+        addresses
       end
 
       # Flag bits 4-5 name the SID the tune was written for: 01 the 6581,
       # 10 the 8580, 11 either and 00 unknown. Only an 8580-only tune gets one.
       def sid_model = flags[4, 2] == 0b10 ? :mos8580 : :mos6581
 
+      # Each SID's model, SID 1's first. Bits 6-7 name the second SID's and
+      # bits 8-9 the third's the same way, and one the header leaves unknown
+      # or open takes SID 1's.
+      def sid_models
+        models = [sid_model]
+        sid_addresses.size.times { |extra| models << model_named(flags[6 + (extra * 2), 2]) }
+        models
+      end
+
       # Flag bits 2-3 name the video standard the same way: 01 PAL, 10 NTSC,
       # 11 either and 00 unknown. Only an NTSC-only tune gets NTSC.
       def ntsc? = flags[2, 2] == 0b10
 
-      # HVSC keys its song length database on the whole file, header and all.
+      # HVSC keys its subtune length database on the whole file, header and all.
       def md5 = @md5 ||= Digest::MD5.hexdigest(@bytes.pack("C*"))
 
       # The `$01` value a routine at `address` has to run under, following
@@ -227,8 +242,8 @@ module Badline
       # A set speed bit asks for CIA timer pacing instead of a raster IRQ.
       # The bare player honours it; the machine driver paces everything off
       # the raster either way.
-      def cia_timed?(song = start_song)
-        speed[[song - 1, 31].min] == 1
+      def cia_timed?(subtune = start_subtune)
+        speed[[subtune - 1, 31].min] == 1
       end
 
       def driver_address
@@ -236,20 +251,20 @@ module Badline
                             raise(FormatError, "No free RAM for the player")
       end
 
-      def driver(song: start_song)
-        Driver.new(self, song: song.clamp(1, songs) - 1, base: driver_address).bytes
+      def driver(subtune: start_subtune)
+        Driver.new(self, subtune: subtune.clamp(1, subtunes) - 1, base: driver_address).bytes
       end
 
       # What a booted machine needs in RAM besides the image before
       # `boot_command` starts the tune, as address => bytes. A BASIC tune
       # gets the end of its program in VARTAB, as LOAD leaves it, and the
-      # song in the A, X and Y that SYS loads from `$030c-$030e`, where the
+      # subtune in the A, X and Y that SYS loads from `$030c-$030e`, where the
       # tune reads it with PEEK(780).
-      def boot_memory(song: start_song)
-        return { driver_address => driver(song:) } unless basic?
+      def boot_memory(subtune: start_subtune)
+        return { driver_address => driver(subtune:) } unless basic?
 
         { 0x2d => [low_byte(end_address), high_byte(end_address)],
-          0x030c => [song.clamp(1, songs) - 1] * 3 }
+          0x030c => [subtune.clamp(1, subtunes) - 1] * 3 }
       end
 
       def boot_command = basic? ? "run\r" : "sys#{driver_address}\r"
@@ -289,14 +304,19 @@ module Badline
       end
 
       def driver_size
-        @driver_size ||= Driver.new(self, song: 0, base: 0).bytes.length
+        @driver_size ||= Driver.new(self, subtune: 0, base: 0).bytes.length
+      end
+
+      def model_named(bits)
+        case bits
+        when 0b01 then :mos6581
+        when 0b10 then :mos8580
+        else sid_model
+        end
       end
 
       def text(offset)
-        @bytes[offset, 32].take_while(&:positive?)
-                          .pack("C*")
-                          .force_encoding(Encoding::ISO_8859_1)
-                          .encode(Encoding::UTF_8)
+        Storage.latin1(@bytes[offset, 32].take_while(&:positive?))
       end
 
       # Header fields are big-endian, unlike everything else the 6502 sees.

data/lib/badline/storage/song_lengths.rb

@@ -2,9 +2,9 @@
 
 module Badline
   module Storage
-    # HVSC's song length database. Each tune gets a comment naming its path
+    # HVSC's subtune length database. Each tune gets a comment naming its path
     # and a line keyed by the MD5 of the whole `.sid` file, holding one
-    # `m:ss` time per song, optionally down to milliseconds:
+    # `m:ss` time per subtune, optionally down to milliseconds:
     #
     #   ; /DEMOS/0-9/12th_Sector_Music.sid
     #   c7c299ce06ec5ccffb2261fb11b42a73=4:33.108
@@ -12,38 +12,15 @@ module Badline
     # The file runs to well over a hundred thousand entries, so a lookup
     # scans for its one key rather than building a table.
     class SongLengths
-      class << self
-        # The database lives in the DOCUMENTS directory of an HVSC
-        # collection, so look for one above the tune, then wherever
-        # `$HVSC_BASE` points.
-        def locate(tune_path)
-          candidates(tune_path).find { |path| File.file?(path) }
-        end
-
-        private
-
-        def candidates(tune_path)
-          ancestors(File.dirname(File.expand_path(tune_path)))
-            .push(ENV.fetch("HVSC_BASE", nil))
-            .compact
-            .map { |dir| File.join(dir, "DOCUMENTS", "Songlengths.md5") }
-        end
-
-        def ancestors(dir)
-          dirs = []
-          until dirs.last == dir
-            dirs << dir
-            dir = File.dirname(dir)
-          end
-          dirs
-        end
-      end
+      # The database lives in the DOCUMENTS directory of an HVSC
+      # collection.
+      def self.locate(tune_path) = HVSC.document(tune_path, "Songlengths.md5")
 
       def initialize(path)
         @path = path
       end
 
-      # The tune's per-song lengths in seconds, or nil when it isn't listed.
+      # The tune's per-subtune lengths in seconds, or nil when it isn't listed.
       def lengths(md5)
         prefix = "#{md5.downcase}="
         File.foreach(@path) do |line|

data/lib/badline/storage/stil/credit.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class STIL
+      # A TITLE in a STIL entry, the tune a subtune covers, with the ARTIST
+      # after it, and the stretch of the subtune it covers when the title
+      # ends in one, such as `(0:53)` or `(1:16-1:32)`. A credit without an
+      # end lasts until the next one takes over.
+      class Credit
+        TIMES = /\s*\((\d+):(\d\d)(?:\.\d+)?(?:-(\d+):(\d\d)(?:\.\d+)?)?\)\s*\z/
+
+        attr_reader :text, :start, :finish
+
+        def initialize(title, artist)
+          match = TIMES.match(title)
+          @start = match ? (match[1].to_i * 60) + match[2].to_i : 0
+          @finish = match && match[3] ? (match[3].to_i * 60) + match[4].to_i : -1
+          name = match ? title[0, match.begin(0)] : title
+          @text = artist.empty? ? name : "#{name} - #{artist}"
+        end
+
+        # The credits in the fields, in the order STIL lists them.
+        def self.list(fields)
+          credits = []
+          fields.each_with_index do |field, index|
+            next unless field.name == "TITLE"
+
+            following = fields[index + 1]
+            artist = following && following.name == "ARTIST" ? following.text : ""
+            credits << new(field.text.tr("\n", " "), artist.tr("\n", " "))
+          end
+          credits
+        end
+
+        # The text of the credit covering `seconds` into the subtune, or ""
+        # when none does: the last one started by then that hasn't ended.
+        def self.at(credits, seconds)
+          text = ""
+          credits.each do |credit|
+            text = credit.text if credit.covers?(seconds)
+          end
+          text
+        end
+
+        def covers?(seconds) = seconds >= @start && (@finish.negative? || seconds <= @finish)
+      end
+    end
+  end
+end

data/lib/badline/storage/stil.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "badline/storage/stil/credit"
+
+module Badline
+  module Storage
+    # HVSC's SID Tune Information List, `DOCUMENTS/STIL.txt`: covers,
+    # subtune names and composers' comments, keyed by each tune's HVSC path.
+    # An entry holds fields for the whole file, then a block per subtune
+    # that has any:
+    #
+    #   /MUSICIANS/C/Crowther_Anthony/From_Ratt_To_You.sid
+    #   COMMENT: The tune names are listed, if they were given a name, the
+    #            remaining tunes were just called Tune 35, Tune 27 etc.
+    #   (#16)
+    #      NAME: G-Bust
+    #     TITLE: Ghostbusters [from the movie]
+    #    ARTIST: Ray Parker, Jr.
+    #
+    # A comment runs on over lines indented by nine spaces, and a blank line
+    # ends the entry. The file is ISO-8859-1.
+    class STIL
+      # One of NAME, AUTHOR, TITLE, ARTIST or COMMENT, with its lines of
+      # text joined by newlines.
+      class Field
+        attr_reader :name, :text
+
+        def initialize(name, text)
+          @name = name
+          @text = text
+        end
+
+        def continue(line)
+          @text = "#{@text}\n#{line}"
+        end
+
+        # The field laid out as STIL.txt does.
+        def lines
+          @text.split("\n").each_with_index.map do |line, index|
+            label = index.zero? ? "#{@name}:" : ""
+            "#{label.rjust(8)} #{line}"
+          end
+        end
+      end
+
+      # A tune's fields for the whole file, and for each subtune by number.
+      class Entry
+        attr_reader :fields
+
+        def initialize
+          @fields = []
+          @subtunes = {}
+          @subtune = 0
+        end
+
+        def subtune(number) = @subtunes.fetch(number, [])
+
+        # Starts the block for a subtune, which the fields read after it
+        # go to.
+        def open_subtune(subtune)
+          @subtune = subtune
+          @subtunes[subtune] = []
+        end
+
+        def add(field)
+          if @subtune.zero?
+            @fields << field
+          else
+            @subtunes[@subtune] << field
+          end
+        end
+
+        # Adds a line to the last field read.
+        def continue(line)
+          last = @subtune.zero? ? @fields.last : @subtunes[@subtune].last
+          last&.continue(line)
+        end
+      end
+
+      # The list lives in the DOCUMENTS directory of an HVSC collection.
+      def self.locate(tune_path) = HVSC.document(tune_path, "STIL.txt")
+
+      def initialize(path)
+        @path = path
+      end
+
+      # The entry for a tune's HVSC path, or nil when the list has none. The
+      # first lookup reads the whole list.
+      def entry(hvsc_path) = entries[hvsc_path]
+
+      def entries
+        @entries ||= parse(Storage.latin1(File.binread(@path).bytes))
+      end
+
+      private
+
+      def parse(text)
+        entries = {}
+        entry = nil
+        text.split("\n").each do |line|
+          line = line.chomp
+          if line.start_with?("/")
+            entry = Entry.new
+            entries[line] = entry
+          elsif entry.nil? || line.empty? || line.start_with?("#")
+            entry = nil
+          else
+            read(entry, line)
+          end
+        end
+        entries
+      end
+
+      def read(entry, line)
+        if line.start_with?("(#")
+          entry.open_subtune(line[2..].to_i)
+        elsif line.start_with?("         ")
+          entry.continue(line[9..])
+        else
+          name, text = line.lstrip.split(": ", 2)
+          entry.add(Field.new(name, text.to_s)) if %w[NAME AUTHOR TITLE ARTIST COMMENT].include?(name)
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage.rb

@@ -12,7 +12,9 @@ require "badline/storage/t64"
 require "badline/storage/tap"
 require "badline/storage/crt_file"
 require "badline/storage/sid_file"
+require "badline/storage/hvsc"
 require "badline/storage/song_lengths"
+require "badline/storage/stil"
 require "badline/storage/unavailable"
 
 module Badline
@@ -62,6 +64,12 @@ module Badline
         bytes.map { |b| b.between?(0xc1, 0xda) ? b - 0x80 : b }.pack("C*")
       end
 
+      # Decodes ISO-8859-1 bytes, the text of .sid headers and HVSC's
+      # documents, to UTF-8.
+      def latin1(bytes)
+        bytes.pack("U*").force_encoding(Encoding::UTF_8)
+      end
+
       # CBM DOS drive prefix: "0:NAME" selects a drive, "@0:NAME" is
       # save-with-replace
       def strip_drive_prefix(name)

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end