badline 0.2.1 → 0.4.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/noise_writeback.rb

@@ -49,29 +49,47 @@ module Badline
           NOISE_TAPS.each { |bit, line| @shift_register &= ~bit if value.nobits?(line) }
         end
 
+        # Setting the test bit starts the bleed, and writes the output of a
+        # noise combination back first, from the accumulator it had. Only
+        # SID/noiselfsrinit sets the bit onto such a combination from outside
+        # it: its $f8/$80 pairs go from noise alone to all four.
+        def raise_test
+          @shift_register_reset = @shift_register_reset_delay
+          return unless @selected.anybits?(0x8) && combined?(@selected) && @shift_pipeline != 1
+
+          write_shift_register(write_back(@selected, shape(@selected)))
+        end
+
         # Releasing the test bit finishes the shift it interrupted: the old
         # waveform's output may be written back first, then a bit clocks in
-        # over the forced-high bit 22. On the 6581, a change that keeps only
-        # pulse+noise of the old waveform writes the lowest noise lines low.
+        # over the forced-high bit 22.
         def release_test(previous)
-          if @topbit_feedback && previous != 0xc && (previous & @selected) == 0xc
-            write_shift_register(noise & PULSE_NOISE_RELEASE)
-          elsif release_writes_back?(previous, @selected)
-            write_shift_register(write_back(previous, shape(previous)))
-          end
+          value = release_write(previous)
+          write_shift_register(value) if value
           shift_noise(1)
         end
 
+        # What the release writes over the taps, or nil. On the 6581, a change
+        # that keeps only pulse+noise of the old waveform writes the lowest
+        # noise lines low. On the 8580, a change from pulse+noise to all four
+        # writes every line low.
+        def release_write(previous)
+          if @topbit_feedback
+            return noise & PULSE_NOISE_RELEASE if previous != 0xc && (previous & @selected) == 0xc
+          elsif previous == 0xc && @selected == 0xf
+            return 0x000
+          end
+          write_back(previous, shape(previous)) if release_writes_back?(previous, @selected)
+        end
+
         # Which waveform changes write the old output back as the test bit
         # falls (SID/wb_testsuite, after libresidfp's do_writeback). Noise has
-        # to have been combined before and still be selected after. Dropping
-        # to noise alone writes nothing back unless all four were selected,
-        # nor does changing to pulse+noise or from pulse+noise to
-        # sawtooth+noise, nor, on the 6581, trading triangle for sawtooth or
-        # back.
+        # to have been combined before and still be combined after. Nothing
+        # is written back on changing to pulse+noise or from pulse+noise to
+        # sawtooth+noise, nor, on the 6581, on trading triangle for sawtooth
+        # or back.
         def release_writes_back?(previous, selected)
-          return false if previous <= 0x8 || selected < 0x8
-          return previous == 0xf if selected == 0x8
+          return false if previous <= 0x8 || selected <= 0x8
           return false if selected == 0xc || (previous == 0xc && selected == 0xa)
 
           !(@topbit_feedback && [previous & 0x3, selected & 0x3].sort == [0x1, 0x2])

data/lib/badline/sid/waveform.rb

@@ -114,10 +114,10 @@ module Badline
         @sync = value.anybits?(0x02)
         test = value.anybits?(0x08)
         if test
+          raise_test unless @test
           @accumulator = 0x000000
           @pulse = 0xfff
           @shift_pipeline = 0
-          @shift_register_reset = @shift_register_reset_delay unless @test
         elsif @test
           release_test(previous)
         end
@@ -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,13 +32,16 @@ module Badline
   # DC offset that the RC network on the C64 board filters out.
   class SID
     include Addressable
+    include CatchUp
 
     VOICES = 3
 
     # Cycles the data bus holds a value, measured through SID/bitfade.
     BUS_TTL = { mos6581: 0x1d00, mos8580: 0xa2000 }.freeze
 
-    # Scales the filter's 20-bit mix down to a signed 16-bit sample.
+    # Scales the filter's 20-bit mix down to a signed 16-bit sample, as
+    # reSID 0.16 does: three voices at full swing and volume 15 span the
+    # whole range, on either chip.
     SAMPLE_DIVISOR = ((0xfff * 0xff) >> 7) * 3 * 15 * 2 / (2**16)
 
     # Writes the DSP queues between catch-ups. A full queue catches up
@@ -58,6 +62,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 +83,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 +96,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 +160,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 +170,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 +180,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 +192,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 +207,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/d64_image.rb

@@ -13,6 +13,16 @@ module Badline
 
       def directory_track = 18
       def directory_sector = 1
+      def directory_interleave = 3
+      def interleave = 10
+      def reserved_tracks = [18]
+
+      # The BAM in the header block covers the 35 tracks of a standard
+      # disk. The layouts that extend it to 40 tracks differ between DOS
+      # versions, so the tracks past 35 stay unused.
+      def bam_tracks = 1..35
+      def bam_count(track) = [18, 0, 4 * track]
+      def bam_bitmap(track) = [18, 0, (4 * track) + 1]
 
       def sectors_in(track)
         case track

data/lib/badline/storage/d71_image.rb

@@ -9,6 +9,18 @@ module Badline
 
       def error_tables = ERROR_TABLES
 
+      def interleave = 6
+      def reserved_tracks = [18, 53]
+
+      # The header block flags a double-sided disk. The second side's free
+      # counts follow the first side's BAM there, and its bitmaps take the
+      # first block of track 53.
+      def bam_tracks = double_sided? ? 1..70 : super
+      def bam_count(track) = track > 35 ? [18, 0, 0xdd + track - 36] : super
+      def bam_bitmap(track) = track > 35 ? [53, 0, 3 * (track - 36)] : super
+
+      def double_sided? = @bytes[sector_offset(18, 0) + 3].anybits?(0x80)
+
       def sectors_in(track)
         track > 35 ? super(track - 35) : super
       end

data/lib/badline/storage/d81_image.rb

@@ -11,6 +11,15 @@ module Badline
 
       def directory_track = 40
       def directory_sector = 3
+      def directory_interleave = 1
+      def interleave = 1
+      def reserved_tracks = [40]
+
+      # Blocks 1 and 2 of track 40 hold the BAM for tracks 1 to 40 and 41
+      # to 80, six bytes a track from offset 16.
+      def bam_tracks = 1..80
+      def bam_count(track) = [40, track > 40 ? 2 : 1, 0x10 + (((track - 1) % 40) * 6)]
+      def bam_bitmap(track) = [40, track > 40 ? 2 : 1, 0x11 + (((track - 1) % 40) * 6)]
 
       def sectors_in(_track) = 40
     end