badline 0.2.1 → 0.3.0

data/lib/badline/sid/catch_up.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    # Running the DSP over the cycles that have passed since it last caught
+    # up, in spans that fast-forward the voices and end on a whole cycle.
+    module CatchUp
+      private
+
+      # Runs the cycles that have passed, landing each queued write on the
+      # cycle the CPU wrote it on.
+      def catch_up
+        replayed = 0
+        i = 0
+        while i < @deferred_writes.length
+          cycle = @deferred_writes[i]
+          run(cycle - replayed)
+          replayed = cycle
+          apply_write(@deferred_writes[i + 1], @deferred_writes[i + 2])
+          i += 3
+        end
+        run(@pending_cycles - replayed)
+        @deferred_writes.clear
+        @pending_cycles = 0
+      end
+
+      def run(cycles)
+        while cycles != 0
+          span = span(cycles)
+          fast_forward(span - 1) if span > 1
+          clock!(span)
+          cycles -= span
+        end
+      end
+
+      # The longest stretch that can be fast-forwarded. A combined waveform
+      # feeding back into its own oscillator steps cycle by cycle, and a span
+      # never runs past an MSB rise that hard-syncs the next voice, so both
+      # land on a whole cycle.
+      def span(cycles)
+        return 1 if @stepped
+
+        span = @synthesizing ? synthesis_span(cycles) : cycles
+        return span unless @synced
+
+        span = sync_span(@waveform1, span)
+        span = sync_span(@waveform2, span)
+        sync_span(@waveform3, span)
+      end
+
+      # The filter steps at most @filter_chunk cycles at a time, and never
+      # across the end of a recorded sample.
+      def synthesis_span(cycles)
+        span = [cycles, @filter_chunk].min
+        return span unless @decimator
+
+        [@decimator.cycles_to_close, span].min
+      end
+
+      # Whether a span has to step, or watch for hard sync, only changes with
+      # a voice's control register.
+      def update_span_rules
+        @stepped = @voices.any? { |voice| voice.waveform.stepped?(@synthesizing) }
+        @synced = @voices.any? { |voice| voice.waveform.sync? }
+      end
+
+      def sync_span(waveform, span)
+        return span unless waveform.sync_dest.sync?
+
+        rise = waveform.cycles_to_msb_rise
+        rise && rise < span ? rise : span
+      end
+
+      # Unrolled over the three voices: the per-cycle block calls cost
+      # measurably on the synthesis path.
+      def fast_forward(cycles)
+        @voice1.fast_forward(cycles)
+        @voice2.fast_forward(cycles)
+        @voice3.fast_forward(cycles)
+      end
+
+      # The last cycle of a span, run whole. The filter integrates the span
+      # from the voices' output at its end.
+      def clock!(span)
+        @voice1.cycle!
+        @voice2.cycle!
+        @voice3.cycle!
+        @waveform1.synchronize!
+        @waveform2.synchronize!
+        @waveform3.synchronize!
+        return unless @synthesizing
+
+        @filter.cycle!(@voices, span)
+        record_sample(span) if @decimator
+      end
+
+      def record_sample(span)
+        sample = @decimator.push(current_sample, span)
+        @samples << sample if sample
+      end
+
+      def current_sample
+        sample = @filter.output / SAMPLE_DIVISOR
+        return sample unless sample < -0x8000 || sample > 0x7fff
+
+        sample.clamp(-0x8000, 0x7fff)
+      end
+    end
+  end
+end

data/lib/badline/sid/decimator.rb

@@ -16,10 +16,11 @@ module Badline
         @phase = 0
         @sum = 0
         @count = 0
+        @cycles_to_close = window_cycles
       end
 
       # Cycles until the current window closes, counting the next one as 1.
-      def cycles_to_close = (@clock_hz - @phase + @rate - 1) / @rate
+      attr_reader :cycles_to_close
 
       # Returns the averaged sample when these cycles close a window, and
       # nil otherwise. They must not run past the window's end.
@@ -27,14 +28,18 @@ module Badline
         @sum += sample * cycles
         @count += cycles
         @phase += @rate * cycles
+        @cycles_to_close -= cycles
         return unless @phase >= @clock_hz
 
         @phase -= @clock_hz
+        @cycles_to_close = window_cycles
         average
       end
 
       private
 
+      def window_cycles = (@clock_hz - @phase + @rate - 1) / @rate
+
       def average
         value = @sum.fdiv(@count).round
         @sum = 0

data/lib/badline/sid/filter.rb

@@ -182,7 +182,7 @@ module Badline
         @unfiltered = 0
         route_voice(voice1.output >> 7, 0x1)
         route_voice(voice2.output >> 7, 0x2)
-        if @routing.anybits?(0x4)
+        if @routing & 0x4 != 0
           @input += voice3.output >> 7
         elsif !@voice3_off
           @unfiltered += voice3.output >> 7
@@ -190,7 +190,7 @@ module Badline
       end
 
       def route_voice(output, bit)
-        if @routing.anybits?(bit)
+        if @routing & bit == bit
           @input += output
         else
           @unfiltered += output
@@ -203,9 +203,9 @@ module Badline
 
       def filtered
         value = 0
-        value += @lowpass  if @mode.anybits?(0x1)
-        value += @bandpass if @mode.anybits?(0x2)
-        value += @highpass if @mode.anybits?(0x4)
+        value += @lowpass  if @mode & 0x1 != 0
+        value += @bandpass if @mode & 0x2 != 0
+        value += @highpass if @mode & 0x4 != 0
         value
       end
     end

data/lib/badline/sid/waveform/fast_forward.rb

@@ -14,11 +14,11 @@ module Badline
           if @test
             bleed_shift_register(cycles)
           else
-            while @shift_pipeline.positive? && cycles.positive?
+            while @shift_pipeline != 0 && cycles != 0
               advance
               cycles -= 1
             end
-            skip_ahead(cycles) if cycles.positive?
+            skip_ahead(cycles) if cycles != 0 && @frequency != 0
             compare_pulse(((@accumulator - @frequency) & 0xffffff) >> 12)
           end
           @stale = true
@@ -59,9 +59,9 @@ module Badline
           previous = @accumulator
           @accumulator += @frequency * cycles
           rises = bit19_rises(previous, @accumulator)
-          if rises.positive?
+          if rises != 0
             @shift_pipeline = pipeline_after(cycles)
-            rises -= 1 if @shift_pipeline.positive?
+            rises -= 1 if @shift_pipeline != 0
             rises.times { shift_noise }
           end
           @accumulator &= 0xffffff
@@ -74,27 +74,27 @@ module Badline
         # How far a rise on one of the last two cycles has come.
         def pipeline_after(cycles)
           last = @accumulator - @frequency
-          return 2 if bit19_rises(last, @accumulator).positive?
-          return 1 if cycles > 1 && bit19_rises(last - @frequency, last).positive?
+          return 2 if bit19_rises(last, @accumulator) != 0
+          return 1 if cycles > 1 && bit19_rises(last - @frequency, last) != 0
 
           0
         end
 
         def drain_floating(cycles)
-          return unless @floating_ttl.positive?
+          return if @floating_ttl.zero?
 
           @floating_ttl -= cycles
-          return if @floating_ttl.positive?
+          return unless @floating_ttl <= 0
 
           @floating_ttl = 0
           @floating = 0x000
         end
 
         def bleed_shift_register(cycles = 1)
-          return unless @shift_register_reset.positive?
+          return if @shift_register_reset.zero?
 
           @shift_register_reset -= cycles
-          return if @shift_register_reset.positive?
+          return unless @shift_register_reset <= 0
 
           @shift_register_reset = 0
           @shift_register = SHIFT_REGISTER_RESET

data/lib/badline/sid/waveform.rb

@@ -218,7 +218,7 @@ module Badline
       def compare_pulse(phase = @accumulator >> 12) = (@pulse = @test || phase >= @pulse_width ? 0xfff : 0x000)
 
       # More than one bit set in the selection.
-      def combined?(selected) = selected.anybits?(selected - 1)
+      def combined?(selected) = selected & (selected - 1) != 0
 
       # The one point in the cycle where the waveform selector drives the DAC:
       # either it latches a fresh value, or nothing drives the line and the
@@ -259,10 +259,10 @@ module Badline
       def advance
         previous = @accumulator
         @accumulator = (previous + @frequency) & 0xffffff
-        @msb_rising = previous.nobits?(MSB) && @accumulator.anybits?(MSB)
-        if previous.nobits?(0x080000) && @accumulator.anybits?(0x080000)
+        @msb_rising = @accumulator & ~previous & MSB != 0
+        if @accumulator & ~previous & 0x080000 != 0
           @shift_pipeline = 2
-        elsif @shift_pipeline.positive? && (@shift_pipeline -= 1).zero?
+        elsif @shift_pipeline != 0 && (@shift_pipeline -= 1).zero?
           write_shift_register(write_back(@selected, @output)) if release_writes_back?(@selected, @selected)
           shift_noise
         end
@@ -277,12 +277,12 @@ module Badline
       # TriXOR = !Saw & ((!V3 & Ring) ^ bit23), where V3 is the modulating
       # voice's MSB (SID/ringmod).
       def inverted?(selected)
-        return false if selected.anybits?(0x2)
+        return false if selected & 0x2 != 0
 
-        msb = @accumulator.anybits?(MSB)
+        msb = @accumulator & MSB != 0
         return msb unless @ring
 
-        msb != @sync_source.accumulator.nobits?(MSB)
+        msb == (@sync_source.accumulator & MSB != 0)
       end
     end
   end

data/lib/badline/sid.rb

@@ -5,6 +5,7 @@ require "badline/sid/envelope"
 require "badline/sid/voice"
 require "badline/sid/filter"
 require "badline/sid/decimator"
+require "badline/sid/catch_up"
 
 module Badline
   # SID (Sound Interface Device) chip, in either the 6581 or the 8580
@@ -31,6 +32,7 @@ module Badline
   # DC offset that the RC network on the C64 board filters out.
   class SID
     include Addressable
+    include CatchUp
 
     VOICES = 3
 
@@ -58,6 +60,7 @@ module Badline
       @bus_ttl_reset = BUS_TTL.fetch(model)
       @filter = Filter.new(model:)
       @synthesizing = false
+      @stepped = @synced = false
       @pending_cycles = 0
       @deferred_writes = []
       @decimator = nil
@@ -78,6 +81,7 @@ module Badline
       @bus_ttl = 0
       @voices.each(&:reset!)
       @filter.reset
+      update_span_rules
     end
 
     # The DSP only counts cycles as they pass. Whatever asks for its state
@@ -90,17 +94,19 @@ module Badline
       return if @synthesizing
 
       @synthesizing = true
+      update_span_rules
       catch_up
     end
 
     # Starts collecting the output, averaged down to `rate` samples a
     # second, for #drain_samples. `filter_chunk` overrides the one the SID
-    # was built with, for a machine that built its own.
-    def record(rate:, filter_chunk: @filter_chunk)
+    # was built with, for a machine that built its own. `clock_hz` is the
+    # rate the SID's cycles are taken to run at.
+    def record(rate:, filter_chunk: @filter_chunk, clock_hz: TimeOfDay::CLOCK_HZ)
       synthesize!
       catch_up
       @filter_chunk = filter_chunk
-      @decimator = Decimator.new(clock_hz: TimeOfDay::CLOCK_HZ, rate:)
+      @decimator = Decimator.new(clock_hz:, rate:)
       @samples = []
     end
 
@@ -152,7 +158,7 @@ module Badline
     end
 
     def peek(addr)
-      case index(addr) % (2**5)
+      case offset_of(addr) % (2**5)
       when 0x19 then latch(pots ? pots.pot_x : 0xff)
       when 0x1a then latch(pots ? pots.pot_y : 0xff)
       when 0x1b then latch(osc3)
@@ -162,7 +168,7 @@ module Badline
     end
 
     def poke(addr, value)
-      reg = index(addr) % (2**5)
+      reg = offset_of(addr) % (2**5)
       write_register(reg, value) if reg <= 0x18
       latch(value)
     end
@@ -172,90 +178,6 @@ module Badline
 
     private
 
-    # Runs the cycles that have passed, landing each queued write on the
-    # cycle the CPU wrote it on.
-    def catch_up
-      replayed = 0
-      @deferred_writes.each do |cycle, reg, value|
-        run(cycle - replayed)
-        replayed = cycle
-        apply_write(reg, value)
-      end
-      run(@pending_cycles - replayed)
-      @deferred_writes.clear
-      @pending_cycles = 0
-    end
-
-    def run(cycles)
-      while cycles.positive?
-        span = span(cycles)
-        fast_forward(span - 1) if span > 1
-        clock!(span)
-        cycles -= span
-      end
-    end
-
-    # The longest stretch that can be fast-forwarded. A combined waveform
-    # feeding back into its own oscillator steps cycle by cycle, and a span
-    # never runs past an MSB rise that hard-syncs the next voice, so both
-    # land on a whole cycle.
-    def span(cycles)
-      synthesizing = @synthesizing
-      return 1 if @waveform1.stepped?(synthesizing) || @waveform2.stepped?(synthesizing) ||
-                  @waveform3.stepped?(synthesizing)
-
-      span = synthesizing ? synthesis_span(cycles) : cycles
-      span = sync_span(@waveform1, span)
-      span = sync_span(@waveform2, span)
-      sync_span(@waveform3, span)
-    end
-
-    # The filter steps at most @filter_chunk cycles at a time, and never
-    # across the end of a recorded sample.
-    def synthesis_span(cycles)
-      span = [cycles, @filter_chunk].min
-      return span unless @decimator
-
-      [@decimator.cycles_to_close, span].min
-    end
-
-    def sync_span(waveform, span)
-      return span unless waveform.sync_dest.sync?
-
-      rise = waveform.cycles_to_msb_rise
-      rise && rise < span ? rise : span
-    end
-
-    # Unrolled over the three voices: the per-cycle block calls cost
-    # measurably on the synthesis path.
-    def fast_forward(cycles)
-      @voice1.fast_forward(cycles)
-      @voice2.fast_forward(cycles)
-      @voice3.fast_forward(cycles)
-    end
-
-    # The last cycle of a span, run whole. The filter integrates the span
-    # from the voices' output at its end.
-    def clock!(span)
-      @voice1.cycle!
-      @voice2.cycle!
-      @voice3.cycle!
-      @waveform1.synchronize!
-      @waveform2.synchronize!
-      @waveform3.synchronize!
-      return unless @synthesizing
-
-      @filter.cycle!(@voices, span)
-      record_sample(span) if @decimator
-    end
-
-    def record_sample(span)
-      sample = @decimator.push(current_sample, span)
-      @samples << sample if sample
-    end
-
-    def current_sample = (@filter.output / SAMPLE_DIVISOR).clamp(-0x8000, 0x7fff)
-
     def latch(value)
       @bus_ttl = @bus_ttl_reset
       @bus_value = value
@@ -268,8 +190,8 @@ module Badline
 
     def write_register(reg, value)
       @registers.poke(reg, value)
-      catch_up if @deferred_writes.length == DEFERRED_WRITES
-      @deferred_writes << [@pending_cycles, reg, value]
+      catch_up if @deferred_writes.length == DEFERRED_WRITES * 3
+      @deferred_writes.push(@pending_cycles, reg, value)
     end
 
     def apply_write(reg, value)
@@ -283,7 +205,9 @@ module Badline
       when 1 then voice.waveform.frequency_high = value
       when 2 then voice.waveform.pulse_width_low = value
       when 3 then voice.waveform.pulse_width_high = value
-      when 4 then voice.control = value
+      when 4
+        voice.control = value
+        update_span_rules
       when 5 then voice.envelope.attack_decay = value
       when 6 then voice.envelope.sustain_release = value
       end

data/lib/badline/storage/disk_image.rb

@@ -42,6 +42,28 @@ module Badline
         nil
       end
 
+      # The track and sector a file's chain starts at.
+      def first_block(name, type: :prg)
+        entry = find_entry(name, type)
+        [entry[:track], entry[:sector]] if entry
+      end
+
+      # The bytes of the chain that starts at the block, or nil when the
+      # block is outside the image's geometry.
+      def read_file_at(track, sector)
+        read_chain(track, sector) if block?(track, sector)
+      end
+
+      # The track and sector of the last block in a file's chain.
+      def last_block(name, type: :prg)
+        entry = find_entry(name, type)
+        return unless entry
+
+        last = nil
+        each_sector(entry[:track], entry[:sector]) { |_data, track, sector| last = [track, sector] }
+        last
+      end
+
       # Raw block access for the DOS `U1` command. Returns nil for blocks
       # outside the image's geometry.
       def read_block(track, sector)

data/lib/badline/storage/host_directory.rb

@@ -3,9 +3,12 @@
 module Badline
   module Storage
     # A host directory served as a drive: .prg files by their host name,
-    # .p00 and .t64 entries by their embedded names. A host file that can't
-    # be read is left out, and a failed write reports false.
+    # .p00 and .t64 entries by their embedded names. A .prg the host can't
+    # read is still listed but fails to read, a .p00 or .t64 whose names
+    # can't be read is left out, and a failed write reports false.
     class HostDirectory
+      NO_SYNC = 21
+
       def initialize(path)
         @path = path
       end
@@ -15,7 +18,16 @@ module Badline
         return unless entry
 
         archive = entry[:archive]
-        archive ? archive.read_file(entry[:name]) : file_bytes(entry[:file])
+        archive ? archive.read_file(entry[:name]) : file_bytes(entry[:file]) || []
+      end
+
+      # A listed file the host can't read fails before its first byte, as
+      # a 1541 does on a disk it finds no sync on.
+      def read_error(name, **)
+        entry = find(name)
+        return unless entry && entry[:file] && !file_bytes(entry[:file])
+
+        { error: NO_SYNC, track: 0, sector: 0, offset: 0 }
       end
 
       def write_file(name, bytes)

data/lib/badline/storage/sid_file.rb

@@ -13,6 +13,9 @@ module Badline
 
       V1_HEADER_SIZE = 0x76
 
+      # 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,
       # 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
@@ -171,6 +174,10 @@ module Badline
       # code.
       def mus? = psid? && flags[0] == 1
 
+      # Flag bit 1 marks an RSID body as a BASIC program, which RUN starts
+      # instead of a call to init.
+      def basic? = !psid? && flags[1] == 1
+
       # 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.
@@ -185,16 +192,22 @@ module Badline
       # 10 the 8580, 11 either and 00 unknown. Only an 8580-only tune gets one.
       def sid_model = flags[4, 2] == 0b10 ? :mos8580 : :mos6581
 
+      # 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.
       def md5 = @md5 ||= Digest::MD5.hexdigest(@bytes.pack("C*"))
 
       # The `$01` value a routine at `address` has to run under, following
       # libsidplayfp's iomap: RAM under BASIC from `$a000`, RAM under both
       # ROMs and no I/O for a routine in the I/O window itself, RAM under the
-      # KERNAL from `$e000`. An RSID tune banks itself and gets nil.
+      # KERNAL from `$e000`. A routine below `$a000` still gets BASIC banked
+      # out when the image reaches into it, as VSID does, since it may call
+      # into the part that lies there. An RSID tune banks itself and gets nil.
       def bank_for(address)
         return unless psid?
-        return 0x37 if address < 0xa000
+        return (under_basic? ? 0x36 : 0x37) if address < 0xa000
         return 0x36 if address < 0xd000
         return 0x34 if address < 0xe000
 
@@ -227,6 +240,23 @@ module Badline
         Driver.new(self, song: song.clamp(1, songs) - 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
+      # tune reads it with PEEK(780).
+      def boot_memory(song: start_song)
+        return { driver_address => driver(song:) } unless basic?
+
+        { 0x2d => [low_byte(end_address), high_byte(end_address)],
+          0x030c => [song.clamp(1, songs) - 1] * 3 }
+      end
+
+      def boot_command = basic? ? "run\r" : "sys#{driver_address}\r"
+
+      # Where the CPU first lands once `boot_command` has started the tune.
+      def entry_address = basic? ? BASIC_RUN : driver_address
+
       private
 
       def truncated?
@@ -237,6 +267,10 @@ module Badline
         @body ||= @bytes[data_offset..] || []
       end
 
+      def under_basic?
+        load_address < 0xc000 && end_address > 0xa000
+      end
+
       # The tape buffer and the free block below the stack page, neither
       # of which BASIC touches.
       def candidates

data/lib/badline/storage.rb

@@ -36,8 +36,10 @@ module Badline
       end
 
       # CBM-style filename pattern: "*" and "?" wildcards, case-insensitive.
+      # The DOS stops comparing at the first "*", so whatever follows it
+      # is ignored.
       def matcher(name)
-        escaped = Regexp.escape(name.downcase)
+        escaped = Regexp.escape(name.downcase.sub(/\*.*/m, "*"))
                         .gsub('\*', ".*")
                         .gsub('\?', ".")
         Regexp.new("\\A#{escaped}\\z")

data/lib/badline/time_of_day.rb

@@ -49,6 +49,13 @@ module Badline
       @latch[:hours]
     end
 
+    # The clock and alarm as stored, read without latching the clock.
+    def registers
+      [@clock[:tenths], @clock[:seconds], @clock[:minutes], @clock[:hours],
+       @alarm[:tenths], @alarm[:seconds], @alarm[:minutes], @alarm[:hours],
+       @stopped ? 1 : 0, @latch ? 1 : 0]
+    end
+
     def write(field, value, alarm:)
       # The frequency counter is held clear while the clock is stopped, and
       # starts counting again from the write to tenths that restarts it.

data/lib/badline/version.rb

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

data/lib/badline/vic/graphics_shifter.rb

@@ -9,7 +9,8 @@ module Badline
     #
     # The byte a group draws loads at pixel XSCROLL. ECM and BMM take hold at
     # pixel 4 as they rise and at pixel 6 as they fall (the 6569's colour
-    # latency). MCM takes hold at pixel 4 for the colour lookup but only at
+    # latency), except that BMM falls at pixel 5 out of any mode but hi-res
+    # bitmap. MCM takes hold at pixel 4 for the colour lookup but only at
     # pixel 7 for how the register is read, where a rising MCM also resets
     # the multicolour flip-flop. An MCM that falls out of the invalid
     # ECM+MCM mode is a pixel later on both counts: the lookup changes at
@@ -67,7 +68,7 @@ module Badline
         case pixel
         when 0 then end_late_read
         when 4 then step_lookup(mode)
-        when 5 then @mode_lookup &= ~1 if @late_mcm
+        when 5 then step_early_fall(mode)
         when 6 then @mode_lookup &= mode | 1
         when 7 then step_read
         end
@@ -78,6 +79,11 @@ module Badline
         @mode_lookup = (@mode_lookup & ~1) | (mode & 1) | (@late_mcm ? 1 : 0) | (mode & ECM_BMM)
       end
 
+      def step_early_fall(mode)
+        @mode_lookup &= ~1 if @late_mcm
+        @mode_lookup &= mode | ~BMM unless @mode_lookup == BMM
+      end
+
       def step_read
         return @late_read = true if @late_mcm