badline 0.12.1 → 0.14.0

data/lib/badline/chips/sid/keyed_parts.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class SID
+      class Waveform
+        # An oscillator's fields in a keyed snapshot module, under `prefix`:
+        # the phase, the noise register and its pipeline, the delayed
+        # shapers, the sync edge, the floating output and the pulse level.
+        # What the registers set comes from them on load.
+        module KeyedState
+          # The fields reSID keeps for an oscillator between cycles, for VICE's
+          # SIDEXTENDED module: the phase, the noise register, its shift pipeline
+          # and reset countdown, the floating output's countdown and the pulse
+          # level.
+          def resid_fields
+            [@accumulator, @shift_register, @shift_pipeline, @shift_register_reset, @floating_ttl, @pulse]
+          end
+
+          # Takes the fields resid_fields gives from `fields`, from `at` on.
+          def restore_resid_fields(fields, at)
+            @accumulator = fields[at]
+            @shift_register = fields[at + 1]
+            @shift_pipeline = fields[at + 2]
+            @shift_register_reset = fields[at + 3]
+            @floating_ttl = fields[at + 4]
+            @pulse = fields[at + 5]
+            @stale = true
+          end
+
+          def save_fields(out, prefix)
+            out.int("#{prefix}accumulator", @accumulator).int("#{prefix}shift_register", @shift_register)
+            out.int("#{prefix}shift_register_reset", @shift_register_reset)
+            out.int("#{prefix}shift_pipeline", @shift_pipeline).int("#{prefix}delayed_triangle", @delayed_triangle)
+            out.int("#{prefix}delayed_sawtooth", @delayed_sawtooth).bool("#{prefix}msb_rising", @msb_rising)
+            out.int("#{prefix}floating", @floating).int("#{prefix}floating_ttl", @floating_ttl)
+            out.int("#{prefix}pulse", @pulse)
+          end
+
+          def load_fields(input, prefix)
+            @accumulator = input.masked("#{prefix}accumulator", @accumulator, 0xffffff)
+            @shift_register = input.masked("#{prefix}shift_register", @shift_register, 0x7fffff)
+            @shift_register_reset = input.int("#{prefix}shift_register_reset", @shift_register_reset)
+            @shift_pipeline = input.int("#{prefix}shift_pipeline", @shift_pipeline)
+            @delayed_triangle = input.masked("#{prefix}delayed_triangle", @delayed_triangle, 0xfff)
+            @delayed_sawtooth = input.masked("#{prefix}delayed_sawtooth", @delayed_sawtooth, 0xfff)
+            @msb_rising = input.bool("#{prefix}msb_rising", @msb_rising)
+            @floating = input.masked("#{prefix}floating", @floating, 0xfff)
+            @floating_ttl = input.int("#{prefix}floating_ttl", @floating_ttl)
+            @pulse = input.masked("#{prefix}pulse", @pulse, 0xfff)
+          end
+
+          # The frequency, pulse width and control bits as the registers
+          # hold them, without the test bit's or the waveform change's
+          # effects on the noise register, which already happened.
+          def restore_registers(frequency, pulse_width, control)
+            @frequency = frequency
+            @pulse_width = pulse_width & 0xfff
+            @selected = (control >> 4) & 0x0f
+            @test = control.anybits?(0x08)
+            @ring = control.anybits?(0x04)
+            @sync = control.anybits?(0x02)
+            @stale = true
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Envelope
+        # The envelope generator's fields in a keyed snapshot module, under
+        # `prefix`: the state, the counters and pipelines between them. The
+        # rates and the gate come from the registers on load.
+        module KeyedState
+          # The fields reSID keeps for an envelope between cycles, for VICE's
+          # SIDEXTENDED module: the rate and exponential counters, the level, the
+          # state as an index into STATES, whether it holds at zero, the two
+          # periods and the pipeline.
+          def resid_fields
+            [@rate_counter, @exponential_counter, @counter, STATES.index(@state).to_i, @hold_zero ? 1 : 0,
+             @rate_period, @exponential_period, @envelope_pipeline]
+          end
+
+          # Takes the fields resid_fields gives from `fields`, from `at` on.
+          def restore_resid_fields(fields, at)
+            @rate_counter = fields[at]
+            @exponential_counter = fields[at + 1]
+            @counter = @env3 = fields[at + 2]
+            state = fields[at + 3]
+            @state = @next_state = STATES.fetch(state.clamp(0, STATES.length - 1)).to_sym
+            @hold_zero = fields[at + 4] != 0
+            @rate_period = fields[at + 5]
+            @exponential_period = fields[at + 6]
+            @envelope_pipeline = fields[at + 7]
+          end
+
+          def save_fields(out, prefix)
+            out.text("#{prefix}state", @state.to_s).text("#{prefix}next_state", @next_state.to_s)
+            out.int("#{prefix}counter", @counter).int("#{prefix}env3", @env3)
+            out.int("#{prefix}rate_counter", @rate_counter)
+            out.int("#{prefix}rate_period", @rate_period).bool("#{prefix}reset_rate_counter", @reset_rate_counter)
+            out.int("#{prefix}exponential_counter", @exponential_counter)
+            out.int("#{prefix}exponential_period", @exponential_period)
+            out.int("#{prefix}state_pipeline", @state_pipeline).int("#{prefix}envelope_pipeline", @envelope_pipeline)
+            out.int("#{prefix}exponential_pipeline", @exponential_pipeline).bool("#{prefix}hold_zero", @hold_zero)
+          end
+
+          def load_fields(input, prefix)
+            @state = state_named(input.choice("#{prefix}state", STATE_NAMES, @state.to_s))
+            @next_state = state_named(input.choice("#{prefix}next_state", STATE_NAMES, @next_state.to_s))
+            @counter = input.byte("#{prefix}counter", @counter)
+            @env3 = input.byte("#{prefix}env3", @env3)
+            @rate_counter = input.masked("#{prefix}rate_counter", @rate_counter, 0x7fff)
+            @rate_period = input.int("#{prefix}rate_period", @rate_period)
+            @reset_rate_counter = input.bool("#{prefix}reset_rate_counter", @reset_rate_counter)
+            load_pipeline_fields(input, prefix)
+          end
+
+          # The rates and the gate as the registers hold them.
+          def restore_registers(attack_decay, sustain_release, control)
+            @attack = (attack_decay >> 4) & 0x0f
+            @decay = attack_decay & 0x0f
+            @sustain = (sustain_release >> 4) & 0x0f
+            @release = sustain_release & 0x0f
+            @gate = control.anybits?(0x01)
+          end
+
+          private
+
+          def load_pipeline_fields(input, prefix)
+            @exponential_counter = input.int("#{prefix}exponential_counter", @exponential_counter)
+            @exponential_period = input.int("#{prefix}exponential_period", @exponential_period)
+            @state_pipeline = input.int("#{prefix}state_pipeline", @state_pipeline)
+            @envelope_pipeline = input.int("#{prefix}envelope_pipeline", @envelope_pipeline)
+            @exponential_pipeline = input.int("#{prefix}exponential_pipeline", @exponential_pipeline)
+            @hold_zero = input.bool("#{prefix}hold_zero", @hold_zero)
+          end
+
+          def state_named(name)
+            case name
+            when "attack" then :attack
+            when "decay_sustain" then :decay_sustain
+            else :release
+            end
+          end
+        end
+
+        STATE_NAMES = STATES.map(&:to_s).freeze
+
+        include KeyedState
+      end
+
+      class Voice
+        # A voice's oscillator under `prefix`wave. and its envelope under
+        # `prefix`env.
+        module KeyedState
+          def save_fields(out, prefix)
+            @waveform.save_fields(out, "#{prefix}wave.")
+            @envelope.save_fields(out, "#{prefix}env.")
+          end
+
+          def load_fields(input, prefix)
+            @waveform.load_fields(input, "#{prefix}wave.")
+            @envelope.load_fields(input, "#{prefix}env.")
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Filter
+        class External
+          # The output filter's integrators and output, under `prefix`.
+          module KeyedState
+            def save_fields(out, prefix)
+              out.int("#{prefix}lowpass", @lowpass).int("#{prefix}highpass", @highpass).int("#{prefix}output", @output)
+            end
+
+            def load_fields(input, prefix)
+              @lowpass = input.int("#{prefix}lowpass", @lowpass)
+              @highpass = input.int("#{prefix}highpass", @highpass)
+              @output = input.int("#{prefix}output", @output)
+            end
+          end
+
+          include KeyedState
+        end
+
+        # The filter's integrators and its last input, under `prefix`, and
+        # the output filter's under ext. The cutoff, resonance, routing,
+        # mode and volume come from the registers on load.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.int("#{prefix}highpass", @highpass).int("#{prefix}bandpass", @bandpass)
+            out.int("#{prefix}lowpass", @lowpass).int("#{prefix}unfiltered", @unfiltered).int("#{prefix}input", @input)
+            @external.save_fields(out, "ext.")
+          end
+
+          def load_fields(input, prefix)
+            @highpass = input.int("#{prefix}highpass", @highpass)
+            @bandpass = input.int("#{prefix}bandpass", @bandpass)
+            @lowpass = input.int("#{prefix}lowpass", @lowpass)
+            @unfiltered = input.int("#{prefix}unfiltered", @unfiltered)
+            @input = input.int("#{prefix}input", @input)
+            @external.load_fields(input, "ext.")
+          end
+
+          # $D415 to $D418 as written.
+          def restore_registers(cutoff_low, cutoff_high, resonance, mode_volume)
+            self.cutoff = (cutoff_high << 3) | (cutoff_low & 0x07)
+            write_resonance(resonance)
+            write_mode_volume(mode_volume)
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The SID's fields in a keyed snapshot module (Snapshot::Keyed): the
+      # registers as written, the data bus latch and its decay, each
+      # voice's under voice1. to voice3., and the filter's under filter.
+      # and ext. Saving catches the DSP up first, so no span or deferred
+      # write is left to save. What the registers decode to is worked out
+      # from them on load.
+      module KeyedState
+        def save_fields(out)
+          catch_up
+          out.bytes("registers", @registers.read(0, 0x20)).int("bus_value", @bus_value).int("bus_ttl", @bus_ttl)
+          @voice1.save_fields(out, "voice1.")
+          @voice2.save_fields(out, "voice2.")
+          @voice3.save_fields(out, "voice3.")
+          @filter.save_fields(out, "filter.")
+          out
+        end
+
+        def load_fields(input)
+          @registers.write(0, input.bytes_into("registers", @registers.read(0, 0x20)))
+          @bus_value = input.byte("bus_value", @bus_value)
+          @bus_ttl = input.int("bus_ttl", @bus_ttl)
+          @pending_cycles = 0
+          @deferred_writes.clear
+          @voice1.load_fields(input, "voice1.")
+          @voice2.load_fields(input, "voice2.")
+          @voice3.load_fields(input, "voice3.")
+          @filter.load_fields(input, "filter.")
+        end
+
+        # How far the recording has got into the sample it is averaging,
+        # under `prefix`, for a host that carries on recording from a
+        # snapshot: it calls #record, then #load_recording_fields.
+        def save_recording_fields(out, prefix)
+          decimator = @decimator
+          raise ArgumentError, "the SID isn't recording" if decimator.nil?
+
+          decimator.save_fields(out, prefix)
+        end
+
+        def load_recording_fields(input, prefix)
+          decimator = @decimator
+          raise ArgumentError, "the SID isn't recording" if decimator.nil?
+
+          decimator.load_fields(input, prefix)
+        end
+
+        def restored!
+          restore_voice(@voice1, 0x00)
+          restore_voice(@voice2, 0x07)
+          restore_voice(@voice3, 0x0e)
+          @filter.restore_registers(register(0x15), register(0x16), register(0x17), register(0x18))
+          update_span_rules
+        end
+
+        private
+
+        def restore_voice(voice, base)
+          control = register(base + 4)
+          voice.waveform.restore_registers(register(base) | (register(base + 1) << 8),
+                                           register(base + 2) | (register(base + 3) << 8), control)
+          voice.envelope.restore_registers(register(base + 5), register(base + 6), control)
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/chips/sid/voice.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class SID
+      # One of the three voices: a waveform generator amplitude-modulated by
+      # its envelope.
+      #
+      # The 6581 waveform DAC swings around a midpoint well above ground, so
+      # even a silent voice carries a large DC offset into the mixer. The
+      # 8580's is centred and carries none.
+      class Voice
+        WAVE_ZERO = { mos6581: 0x380, mos8580: 0x800 }.freeze
+        DC_OFFSET = { mos6581: 0x800 * 0xff, mos8580: 0 }.freeze
+
+        attr_reader :waveform, :envelope
+
+        # Each voice hard-syncs and ring-modulates against the previous one,
+        # wrapping from the first back round to the last.
+        def self.linked(count, model:)
+          voices = Array.new(count) { new(model:) }
+          waveforms = voices.map(&:waveform)
+          waveforms.each_with_index do |waveform, i|
+            waveform.sync_source = waveforms[i - 1]
+            waveform.sync_dest = waveforms[(i + 1) % count]
+          end
+          voices
+        end
+
+        def initialize(model: :mos6581)
+          @waveform = Waveform.new(model:)
+          @envelope = Envelope.new
+          @wave_zero = WAVE_ZERO.fetch(model)
+          @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
+        end
+
+        def control=(value)
+          @waveform.control = value
+          @envelope.control = value
+        end
+
+        def cycle!
+          @envelope.cycle!
+          @waveform.cycle!
+        end
+
+        def fast_forward(cycles)
+          @envelope.fast_forward(cycles)
+          @waveform.fast_forward(cycles)
+        end
+
+        def output
+          ((@waveform.output - @wave_zero) * @envelope.output) + @dc_offset
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/sid/waveform/combined.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class SID
+      class Waveform
+        # The shapes the chip puts out when more than one waveform is selected.
+        #
+        # Selecting several shapers connects their outputs to the same twelve
+        # DAC lines. Each line settles somewhere between the levels the
+        # shapers drive it to, and couples to the lines around it through the
+        # resistances between them, so a bit reads high only when enough of
+        # its own drive and its neighbours' is high. Modelled here as a
+        # threshold on a weighted sum: each selected shaper adds its bit times
+        # its strength, a high pulse adds its strength to every line, and the
+        # neighbours contribute with one weight per distance below and one per
+        # distance above.
+        #
+        # A low pulse grounds every line.
+        #
+        # The parameters come from bin/sidwavefit, fitted against OSC3 dumps of
+        # real chips in SID/resid-test (oscsample0/1-6581/8580wf30/50/60/70).
+        # The tables are built from them once per chip model.
+        module Combined
+          BITS = 12
+
+          # Per chip and selection (triangle $1, sawtooth $2, pulse $4): the
+          # triangle's strength next to a sawtooth (the sawtooth, or a lone
+          # triangle, has strength 1), the pulse's strength, the threshold as
+          # a fraction of the full drive, then the weights of the lines one to
+          # eleven bits below and one to eleven bits above.
+          PARAMETERS = {
+            mos6581: {
+              0x3 => [0.522, 6.4087, 0.9062,
+                      0.5304, 0.278, 0.1473, 0.0773, 0.0, 0.0184, 0.0113, 0.0251, 0.0594, 0.2001, 0.2001,
+                      0.4103, 0.1756, 0.0687, 0.0282, 0.0115, 0.0047, 0.0031, 0.2001, 0.2001, 0.2001, 0.2001],
+              0x5 => [5.871, 0.0, 0.7485,
+                      0.6522, 0.5913, 0.5404, 0.4828, 0.428, 0.361, 0.2955, 0.2453, 0.1558, 0.0501, 0.0016,
+                      0.7106, 0.6667, 0.6426, 0.6376, 0.5761, 0.6639, 0.7193, 0.4728, 0.4306, 0.392, 0.357],
+              0x6 => [3.8329, 4.7751, 0.9565,
+                      0.815, 0.8302, 0.8204, 0.8107, 0.8511, 0.8416, 0.8322, 0.8728, 0.8636, 0.8545, 0.8954,
+                      0.8071, 0.7979, 0.7465, 0.7771, 0.7643, 0.7572, 0.7054, 0.4585, 0.4159, 0.3773, 0.3421],
+              0x7 => [5.5703, 0.2543, 0.9575,
+                      0.7177, 0.515, 0.3696, 0.2653, 0.1904, 0.1367, 0.0606, 0.0953, 0.0506, 0.0363, 0.2261,
+                      0.6347, 0.286, 0.203, 0.0817, 0.0438, 0.1235, 0.2001, 0.2001, 0.2001, 0.2001, 0.2001]
+            },
+            mos8580: {
+              0x3 => [0.2223, 7.7741, 0.8869,
+                      0.4626, 0.2025, 0.0911, 0.041, 0.0185, 0.0, 0.0008, 0.0, 0.0, 0.0127, 0.0063,
+                      0.5633, 0.311, 0.2099, 0.0881, 0.0255, 0.0, 0.0431, 0.2002, 0.2002, 0.2002, 0.2002],
+              0x5 => [3.1022, 1.1282, 0.9157,
+                      0.2731, 0.2748, 0.0031, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+                      0.6228, 0.7375, 0.6094, 0.6667, 0.4381, 0.4714, 0.3648, 0.2669, 0.2264, 0.2001, 0.2001],
+              0x6 => [0.9477, 0.0012, 0.7837,
+                      0.2565, 0.2289, 0.1095, 0.0805, 0.0282, 0.0281, 0.0, 0.0, 0.0, 0.0, 0.0063,
+                      0.3382, 0.3131, 0.3129, 0.2898, 0.233, 0.1762, 0.2135, 0.2002, 0.2002, 0.2002, 0.2002],
+              0x7 => [1.219, 1.1111, 0.9473,
+                      0.3829, 0.1466, 0.0577, 0.0215, 0.0082, 0.0032, 0.0, 0.0, 0.0, 0.0, 0.0,
+                      0.7273, 0.6845, 0.566, 0.4807, 0.6, 0.1954, 0.4651, 0.2194, 0.2002, 0.2002, 0.2002]
+            }
+          }.freeze
+
+          # A compiled parameter set: the weight matrix, and per line the sum
+          # of its weights and the threshold against the full drive.
+          class Network
+            attr_reader :triangle_strength, :pulse_strength
+
+            def initialize(params)
+              @triangle_strength, @pulse_strength, threshold = params[0, 3]
+              below = [1.0] + params[3, BITS - 1]
+              above = [1.0] + params[3 + BITS - 1, BITS - 1]
+              @weights = Array.new(BITS) do |i|
+                Array.new(BITS) { |j| j <= i ? below[i - j] : above[j - i] }.freeze
+              end.freeze
+              @norms = @weights.map(&:sum).freeze
+              @threshold = threshold
+            end
+
+            # `drives` holds [bits, strength] for each selected shaper; a high
+            # pulse is passed separately, as it drives every line alike.
+            def shape(drives, pulse)
+              total = drives.sum { |_, strength| strength }
+              total += @pulse_strength if pulse
+              out = 0
+              BITS.times do |i|
+                level = pulse ? @pulse_strength * @norms[i] : 0.0
+                weights = @weights[i]
+                drives.each do |bits, strength|
+                  BITS.times { |j| level += weights[j] * strength if bits[j] == 1 }
+                end
+                out |= 1 << i if level >= @threshold * @norms[i] * total
+              end
+              out
+            end
+          end
+
+          module_function
+
+          # The pulse-high shapes of the four combinations without noise.
+          def tables(model)
+            @tables ||= {}
+            @tables[model] ||= PARAMETERS.fetch(model).to_h do |selected, params|
+              [selected, table(selected, params)]
+            end.freeze
+          end
+
+          # One combination's shapes, indexed by the phase (the sawtooth), or
+          # for triangle and pulse by the triangle. A triangle combined with a
+          # sawtooth is never folded, so it is the phase shifted left one bit.
+          def table(selected, params)
+            network = Network.new(params)
+            Array.new(1 << BITS) do |index|
+              triangle = selected == 0x5 ? index : (index << 1) & 0xfff
+              network.shape(drives(selected, network, index, triangle), selected.anybits?(0x4))
+            end.freeze
+          end
+
+          def drives(selected, network, saw, triangle)
+            drives = []
+            drives << [saw, 1.0] if selected.anybits?(0x2)
+            drives << [triangle, selected.anybits?(0x2) ? network.triangle_strength : 1.0] if selected.anybits?(0x1)
+            drives
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class SID
+      class Waveform
+        # Running an oscillator many cycles in one step, for the catch-ups that
+        # fast-forward the voices between whole cycles.
+        module FastForward
+          # Runs `cycles` cycles as #cycle! would, for an oscillator that is not
+          # feeding back. What those cycles latch onto the output is left to the
+          # whole cycle that follows, which latches over it.
+          def fast_forward(cycles)
+            drain_floating(cycles) if @selected.zero?
+            if @test
+              bleed_shift_register(cycles)
+            else
+              while @shift_pipeline != 0 && cycles != 0
+                advance
+                cycles -= 1
+              end
+              skip_ahead(cycles) if cycles != 0 && @frequency != 0
+              compare_pulse(((@accumulator - @frequency) & 0xffffff) >> 12)
+            end
+            @stale = true
+          end
+
+          # The cycle on which the accumulator MSB next rises, counting the next
+          # one as 1, or nil if it never will. The test bit leaves the last
+          # rise standing for as long as it is held.
+          def cycles_to_msb_rise
+            return (@msb_rising ? 1 : nil) if @test
+            return if @frequency.zero?
+
+            distance = (MSB - @accumulator) & 0xffffff
+            distance = 0x1000000 if distance.zero?
+            (distance + @frequency - 1) / @frequency
+          end
+
+          # A combined waveform with sawtooth (on the 6581) or noise in the mix
+          # writes back into the oscillator every cycle, so it cannot be
+          # fast-forwarded. Triangle and pulse alone write nothing back.
+          def feedback?
+            combined_waveform? && (@selected.anybits?(0x8) || (@topbit_feedback && @selected.anybits?(0x2)))
+          end
+
+          # Whether a catch-up has to run this oscillator a cycle at a time.
+          # While synthesizing, every combined waveform does, so the filter
+          # integrates it a cycle at a time.
+          def stepped?(synthesizing) = synthesizing ? combined_waveform? : feedback?
+
+          private
+
+          def combined_waveform? = !@test && combined?(@selected)
+
+          # Advances an accumulator with no shift in flight. Each rise of bit 19
+          # shifts the LFSR two cycles on, so a rise in the last two cycles
+          # leaves its shift pending for the cycles after.
+          def skip_ahead(cycles)
+            previous = @accumulator
+            @accumulator += @frequency * cycles
+            rises = bit19_rises(previous, @accumulator)
+            if rises != 0
+              @shift_pipeline = pipeline_after(cycles)
+              rises -= 1 if @shift_pipeline != 0
+              rises.times { shift_noise }
+            end
+            @accumulator &= 0xffffff
+          end
+
+          # Bit 19 rises at most once a cycle, on each odd multiple of 2^19,
+          # and at most once in any eight.
+          def bit19_rises(from, to) = ((to + 0x80000) >> 20) - ((from + 0x80000) >> 20)
+
+          # 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) != 0
+            return 1 if cycles > 1 && bit19_rises(last - @frequency, last) != 0
+
+            0
+          end
+
+          def drain_floating(cycles)
+            return if @floating_ttl.zero?
+
+            @floating_ttl -= cycles
+            return unless @floating_ttl <= 0
+
+            @floating_ttl = 0
+            @floating = 0x000
+          end
+
+          def bleed_shift_register(cycles = 1)
+            return if @shift_register_reset.zero?
+
+            @shift_register_reset -= cycles
+            return unless @shift_register_reset <= 0
+
+            @shift_register_reset = 0
+            @shift_register = SHIFT_REGISTER_RESET
+          end
+        end
+      end
+    end
+  end
+end