badline 0.12.0 → 0.13.0

data/lib/badline/vic20/sound/output.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Vic20
-    class Sound
-      # The sound's level averaged over each sample of the audio rate, then
-      # through the machine's output stage: a one-pole low-pass at 1,420 Hz
-      # and a one-pole high-pass at 158 Hz, both run at the audio rate.
-      #
-      # The two corners are fitted to xvic's step response: a voice turned
-      # on at volume 15 rises and decays back to the line as those two RC
-      # stages do, within 6 parts in 11,000.
-      class Output
-        LOW_PASS_HZ = 1_420
-        HIGH_PASS_HZ = 158
-
-        # Scales the loudest level, four voices high at volume 15, to the
-        # top of a signed 16-bit sample.
-        SCALE = 32_767.0 / 570
-
-        attr_reader :samples
-
-        # `level` is the sound's level as the recording starts, which the
-        # stage takes as settled.
-        def initialize(clock_hz:, rate:, level:)
-          @clock_hz = clock_hz
-          @rate = rate
-          @remainder = 0
-          @window = next_window
-          @left = @window
-          @sum = 0
-          @low = @drift = level.to_f
-          @low_pass = 1.0 - Math.exp(-2.0 * Math::PI * LOW_PASS_HZ / rate)
-          @high_pass = 1.0 - Math.exp(-2.0 * Math::PI * HIGH_PASS_HZ / rate)
-          @samples = []
-        end
-
-        # Adds `cycles` cycles at `level`, closing every sample they finish.
-        def hold(level, cycles)
-          left = @left
-          while cycles >= left
-            @sum += level * left
-            cycles -= left
-            close
-            left = @left
-          end
-          @sum += level * cycles
-          @left = left - cycles
-        end
-
-        # The samples closed since the last drain.
-        def drain
-          samples = @samples
-          @samples = []
-          samples
-        end
-
-        private
-
-        def close
-          @low += @low_pass * (@sum.fdiv(@window) - @low)
-          @drift += @high_pass * (@low - @drift)
-          sample = ((@low - @drift) * SCALE).round
-          sample = 32_767 if sample > 32_767
-          sample = -32_768 if sample < -32_768
-          @samples << sample
-          @sum = 0
-          @window = next_window
-          @left = @window
-        end
-
-        # Each window is a whole number of cycles, and they add up to the
-        # clock's cycles over a second.
-        def next_window
-          @remainder += @clock_hz
-          cycles = @remainder / @rate
-          @remainder -= cycles * @rate
-          cycles
-        end
-      end
-    end
-  end
-end

data/lib/badline/vic20/sound.rb

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/vic20/sound/output"
-
-module Badline
-  class Vic20
-    # The VIC-I's sound: three square-wave voices, bass, alto and soprano at
-    # $900A-$900C, a noise voice at $900D, and the volume in $900E bits 0-3.
-    #
-    # Each voice has a 7-bit counter, ticked every 16, 8, 4 or 2 cycles from
-    # bass to noise. It counts up from the low 7 bits of its register, and
-    # on the tick it would reach 127 it reloads from the register instead.
-    # So a voice's counter comes round every 128 - ((value + 1) & 127)
-    # ticks, and the register's new value takes hold at the next reload.
-    #
-    # A tone voice's counter shifts an 8-bit shift register at each reload,
-    # bit 7 out and back into bit 0 inverted while bit 7 of the register
-    # enables the voice, and a zero while it doesn't. Bit 0 is the voice's
-    # output: a square wave of 16 shifts while the voice is on, which a
-    # voice turned off shifts out to silence.
-    #
-    # The noise voice's counter shifts a 16-bit LFSR instead, bit 0 in from
-    # the XOR of bits 3, 12, 14 and 15 while the voice is on and a one
-    # while it's off. Each time the LFSR's bit 0 rises, it shifts the noise
-    # voice's own 8-bit shift register, bit 7 back into bit 0, inverted
-    # while the voice is on. Its bit 0 is the voice's output while the voice
-    # is on, and it is silent while it's off.
-    #
-    # The output is the voices that are high, plus a little more, times the
-    # volume, so a volume write steps the output even with every voice off.
-    #
-    # The voices only run while #record collects the output: nothing the
-    # CPU reads depends on them. Until then a write only sets the register.
-    # While recording, the voices catch up to the current cycle whenever a
-    # write lands or the samples are drained, one shift at a time.
-    class Sound
-      VOICES = 4
-      NOISE = 3
-
-      # The cycles between ticks of each voice's counter.
-      DIVIDERS = [16, 8, 4, 2].freeze
-
-      # What a voice that is high adds to the output's level, and what the
-      # output carries with every voice low, before the volume.
-      VOICE_LEVEL = 9
-      IDLE_LEVEL = 2
-
-      attr_reader :volume
-
-      # `clock` answers the machine's cycles, `clock_hz` the rate they run at.
-      def initialize(clock, clock_hz)
-        @clock = clock
-        @clock_hz = clock_hz
-        @output = nil
-        @time = 0
-        @shift_registers = Array.new(VOICES, 0)
-        @next_shifts = Array.new(VOICES, 0)
-        @frequencies = Array.new(VOICES, 0)
-        @enabled = Array.new(VOICES, false)
-        power_on!
-      end
-
-      def model = :mos6561
-
-      # The power-on state: every register clear and the tone voices' shift
-      # registers empty. The noise voice's LFSR and shift register start full
-      # of ones, as a noise voice left off fills them.
-      def power_on!
-        now = @clock.cycles
-        run_to(now)
-        @volume = 0
-        VOICES.times do |voice|
-          @frequencies[voice] = 0
-          @enabled[voice] = false
-          @shift_registers[voice] = 0
-          divider = DIVIDERS[voice]
-          @next_shifts[voice] = ((now / divider) + 128) * divider
-        end
-        @shift_registers[NOISE] = 0xff
-        @lfsr = 0xffff
-        @level = level_now
-      end
-
-      # Starts collecting the output, averaged down to `rate` samples a
-      # second, for #drain_samples. `clock_hz` is the rate the cycles are
-      # taken to run at.
-      def record(rate:, clock_hz: @clock_hz)
-        now = @clock.cycles
-        run_to(now)
-        resume(now)
-        @output = Output.new(clock_hz:, rate:, level: @level)
-      end
-
-      def recording? = !@output.nil?
-
-      # The samples recorded since the last drain.
-      def drain_samples
-        output = @output
-        return [] if output.nil?
-
-        run_to(@clock.cycles)
-        output.drain
-      end
-
-      # A write to $900A-$900E, which takes hold from the next cycle.
-      def write(register, value)
-        run_to(@clock.cycles + 1)
-        if register == 0x0e
-          @volume = value & 0x0f
-        else
-          voice = register - 0x0a
-          @frequencies[voice] = value & 0x7f
-          @enabled[voice] = value >= 0x80
-        end
-        @level = level_now
-      end
-
-      # The registers and the voices as they last ran, for a snapshot.
-      # Recording is the host's, and starts the voices again from the
-      # cycle it starts at.
-      def save_state(out)
-        run_to(@clock.cycles)
-        out.marker("VIC20 SOUND").int(@volume).ints(@frequencies).booleans(@enabled)
-        out.ints(@shift_registers).ints(@next_shifts).int(@lfsr).int(@level).int(@time)
-      end
-
-      def load_state(input)
-        input.marker("VIC20 SOUND")
-        @volume = input.int
-        input.ints_into(@frequencies)
-        input.booleans_into(@enabled)
-        input.ints_into(@shift_registers)
-        input.ints_into(@next_shifts)
-        @lfsr = input.int
-        @level = input.int
-        @time = input.int
-        resume(@clock.cycles) if recording?
-      end
-
-      # A voice's shift register as of the current cycle, while recording.
-      def shift_register(voice)
-        run_to(@clock.cycles)
-        @shift_registers[voice]
-      end
-
-      def lfsr
-        run_to(@clock.cycles)
-        @lfsr
-      end
-
-      private
-
-      # Moves each shift that the cycles since the voices last ran have
-      # passed to its next turn from `now`, keeping its phase.
-      def resume(now)
-        @time = now
-        VOICES.times do |voice|
-          due = @next_shifts[voice]
-          next if due >= now
-
-          interval = period(voice) * DIVIDERS[voice]
-          @next_shifts[voice] = due + ((now - due + interval - 1) / interval * interval)
-        end
-      end
-
-      # Runs the voices up to the start of cycle `target`, the output holding
-      # each level for the cycles it lasts.
-      def run_to(target)
-        time = @time
-        output = @output
-        return if output.nil? || target <= time
-
-        following = next_shift
-        while following < target
-          output.hold(@level, following - time)
-          time = following
-          shift_due(time)
-          @level = level_now
-          following = next_shift
-        end
-        output.hold(@level, target - time)
-        @time = target
-      end
-
-      def next_shift
-        shifts = @next_shifts
-        following = shifts[0]
-        following = shifts[1] if shifts[1] < following
-        following = shifts[2] if shifts[2] < following
-        following = shifts[3] if shifts[3] < following
-        following
-      end
-
-      def shift_due(time)
-        shifts = @next_shifts
-        VOICES.times do |voice|
-          next unless shifts[voice] == time
-
-          voice == NOISE ? step_noise : shift_tone(voice)
-          shifts[voice] = time + (period(voice) * DIVIDERS[voice])
-        end
-      end
-
-      def shift_tone(voice)
-        bits = @shift_registers[voice]
-        fill = @enabled[voice] && bits < 0x80 ? 1 : 0
-        @shift_registers[voice] = ((bits << 1) | fill) & 0xff
-      end
-
-      def step_noise
-        lfsr = @lfsr
-        enabled = @enabled[NOISE]
-        fill = enabled ? ((lfsr >> 3) ^ (lfsr >> 12) ^ (lfsr >> 14) ^ (lfsr >> 15)) & 1 : 1
-        @lfsr = ((lfsr << 1) | fill) & 0xffff
-        return unless fill == 1 && lfsr.even?
-
-        bits = @shift_registers[NOISE]
-        fill = (bits >> 7) ^ (enabled ? 1 : 0)
-        @shift_registers[NOISE] = ((bits << 1) | fill) & 0xff
-      end
-
-      # The ticks between two reloads of a voice's counter.
-      def period(voice) = 128 - ((@frequencies[voice] + 1) & 0x7f)
-
-      def level_now
-        registers = @shift_registers
-        high = (registers[0] & 1) + (registers[1] & 1) + (registers[2] & 1)
-        high += registers[NOISE] & 1 if @enabled[NOISE]
-        ((high * VOICE_LEVEL) + IDLE_LEVEL) * @volume
-      end
-    end
-  end
-end

data/lib/badline/z80/arithmetic.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Z80
-    # The ALU's 8- and 16-bit arithmetic. Bits 5 and 3 of F come from the
-    # result, except for CP, which takes them from the operand, and the
-    # 16-bit operations, which take them from the high byte.
-    module Arithmetic
-      private
-
-      # The eight operations an opcode's bits 5-3 pick: ADD ADC SUB SBC AND
-      # XOR OR CP.
-      def alu(operation, value)
-        case operation
-        when 0 then add_a(value, 0)
-        when 1 then add_a(value, @f & CF)
-        when 2 then @a = subtract(value, 0)
-        when 3 then @a = subtract(value, @f & CF)
-        when 4 then logic(@a & value, HF)
-        when 5 then logic(@a ^ value, 0)
-        when 6 then logic(@a | value, 0)
-        else compare(value)
-        end
-      end
-
-      def add_a(value, carry)
-        result = @a + value + carry
-        assign_flags(SZ53[result & 0xff] | (result >> 8) | ((@a ^ value ^ result) & HF) |
-                  (((@a ^ value ^ 0x80) & (@a ^ result) & 0x80) >> 5))
-        @a = result & 0xff
-      end
-
-      def subtract(value, carry)
-        result = @a - value - carry
-        assign_flags(SZ53[result & 0xff] | NF | ((result >> 8) & CF) | ((@a ^ value ^ result) & HF) |
-                  (((@a ^ value) & (@a ^ result) & 0x80) >> 5))
-        result & 0xff
-      end
-
-      def compare(value)
-        subtract(value, 0)
-        assign_flags((@f & ~XYF) | (value & XYF))
-      end
-
-      def logic(result, half)
-        @a = result
-        assign_flags(SZ53P[result] | half)
-      end
-
-      def increment(value)
-        result = (value + 1) & 0xff
-        assign_flags((@f & CF) | SZ53[result] | (result == 0x80 ? PF : 0) | (result.nobits?(0x0f) ? HF : 0))
-        result
-      end
-
-      def decrement(value)
-        result = (value - 1) & 0xff
-        assign_flags((@f & CF) | NF | SZ53[result] | (result == 0x7f ? PF : 0) | (value.nobits?(0x0f) ? HF : 0))
-        result
-      end
-
-      def add16(left, right)
-        result = left + right
-        @wz = (left + 1) & 0xffff
-        assign_flags((@f & (SF | ZF | PF)) | ((result >> 8) & XYF) | (((left ^ right ^ result) >> 8) & HF) |
-                  (result >> 16))
-        result & 0xffff
-      end
-
-      def adc16(right)
-        left = hl
-        result = left + right + (@f & CF)
-        @wz = (left + 1) & 0xffff
-        self.hl = result & 0xffff
-        assign_flags(word_flags(result) | (((left ^ right ^ result) >> 8) & HF) |
-                  (((left ^ right ^ 0x8000) & (left ^ result) & 0x8000) >> 13))
-      end
-
-      def sbc16(right)
-        left = hl
-        result = left - right - (@f & CF)
-        @wz = (left + 1) & 0xffff
-        self.hl = result & 0xffff
-        assign_flags(word_flags(result) | NF | (((left ^ right ^ result) >> 8) & HF) |
-                  (((left ^ right) & (left ^ result) & 0x8000) >> 13))
-      end
-
-      def word_flags(result)
-        ((result >> 8) & (SF | XYF)) | (result.nobits?(0xffff) ? ZF : 0) | ((result >> 16) & CF)
-      end
-
-      def daa
-        low = @a & 0x0f
-        carry = @f.anybits?(CF) || @a > 0x99 ? CF : 0
-        correction = (carry.zero? ? 0 : 0x60) | (@f.anybits?(HF) || low > 9 ? 0x06 : 0)
-        subtracting = @f.anybits?(NF)
-        half = daa_half(low, subtracting)
-        @a = (subtracting ? @a - correction : @a + correction) & 0xff
-        assign_flags(SZ53P[@a] | (@f & NF) | carry | half)
-      end
-
-      def daa_half(low, subtracting)
-        if subtracting
-          @f.anybits?(HF) && low < 6 ? HF : 0
-        else
-          low > 9 ? HF : 0
-        end
-      end
-
-      def neg
-        value = @a
-        @a = 0
-        @a = subtract(value, 0)
-      end
-    end
-  end
-end

data/lib/badline/z80/bit_page.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Z80
-    # The CB page: rotates and shifts (quarter 0), BIT (1), RES (2) and SET
-    # (3) of the bit the row names, on the column's register or (HL). After
-    # DD or FD the operand is always (IX+d): the displacement comes before
-    # the opcode, and an opcode that names a register other than (HL) also
-    # copies the result into it.
-    module BitPage
-      private
-
-      def execute_bits(opcode)
-        operation = opcode >> 6
-        number = (opcode >> 3) & 7
-        index = opcode & 7
-        return bits_in_memory(operation, number, hl) if index == 6
-
-        value = register(index)
-        if operation == 1
-          bit(number, value, value)
-        else
-          set_register(index, bit_result(operation, number, value))
-        end
-      end
-
-      def execute_index_bits
-        displaced
-        opcode = fetch_byte
-        @cycles += 2
-        result = bits_in_memory(opcode >> 6, (opcode >> 3) & 7, @wz)
-        index = opcode & 7
-        set_plain_register(index, result) unless index == 6 || (opcode >> 6) == 1
-      end
-
-      def bits_in_memory(operation, number, address)
-        value = read_byte(address)
-        @cycles += 1
-        return bit(number, value, @wz >> 8) if operation == 1
-
-        result = bit_result(operation, number, value)
-        write_byte(address, result)
-        result
-      end
-
-      def bit_result(operation, number, value)
-        case operation
-        when 0 then shift(number, value)
-        when 2 then value & ~(1 << number) & 0xff
-        else value | (1 << number)
-        end
-      end
-    end
-  end
-end

data/lib/badline/z80/block_io.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Z80
-    # INI, IND, OUTI, OUTD and their repeating forms. B counts the bytes
-    # and sets S, Z, 5 and 3. The byte's bit 7 sets N, and adding it to C
-    # plus or minus one for INI and IND, or to L for OUTI and OUTD, sets H
-    # and C on a carry out and P/V from the parity of its low 3 bits
-    # exclusive-ored with B.
-    module BlockIO
-      private
-
-      def block_input(step, repeat)
-        @cycles += 1
-        port = bc
-        value = input(port)
-        @wz = (port + step) & 0xffff
-        @b = (@b - 1) & 0xff
-        write_byte(hl, value)
-        self.hl = (hl + step) & 0xffff
-        block_io_flags(value, value + ((@c + step) & 0xff), repeat)
-      end
-
-      def block_output(step, repeat)
-        @cycles += 1
-        value = read_byte(hl)
-        @b = (@b - 1) & 0xff
-        output(bc, value)
-        self.hl = (hl + step) & 0xffff
-        @wz = (bc + step) & 0xffff
-        block_io_flags(value, value + @l, repeat)
-      end
-
-      def block_io_flags(value, sum, repeat)
-        carry = sum > 0xff ? HF | CF : 0
-        assign_flags(SZ53[@b] | ((value >> 6) & NF) | carry | PARITY[(sum & 7) ^ @b])
-        return unless repeat && !@b.zero?
-
-        repeat_block
-        repeat_io_flags(value, carry)
-      end
-
-      def repeat_io_flags(value, carry)
-        flags = @f & ~HF
-        if carry.zero?
-          flags ^= PARITY[@b & 7] ^ PF
-        elsif value.anybits?(0x80)
-          flags ^= PARITY[(@b - 1) & 7] ^ PF
-          flags |= HF if @b.nobits?(0x0f)
-        else
-          flags ^= PARITY[(@b + 1) & 7] ^ PF
-          flags |= HF if @b.allbits?(0x0f)
-        end
-        assign_flags(flags)
-      end
-    end
-  end
-end

data/lib/badline/z80/block_transfers.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Z80
-    # LDI, LDD, CPI, CPD and their repeating forms. A repeating form that
-    # goes round again winds the program counter back to its ED and spends
-    # 5 T-states more, and bits 5 and 3 then come from the program
-    # counter's high byte.
-    module BlockTransfers
-      private
-
-      # ED A0-BB: the column picks LD, CP, IN or OUT, bit 3 counts down, and
-      # bit 4 repeats.
-      def block_operation(opcode)
-        step = opcode.nobits?(0x08) ? 1 : -1
-        repeat = opcode.anybits?(0x10)
-        case opcode & 3
-        when 0 then block_load(step, repeat)
-        when 1 then block_compare(step, repeat)
-        when 2 then block_input(step, repeat)
-        else block_output(step, repeat)
-        end
-      end
-
-      def block_load(step, repeat)
-        value = read_byte(hl)
-        write_byte(de, value)
-        @cycles += 2
-        self.hl = (hl + step) & 0xffff
-        self.de = (de + step) & 0xffff
-        self.bc = (bc - 1) & 0xffff
-        sum = value + @a
-        assign_flags((@f & (SF | ZF | CF)) | (sum & XF) | ((sum & 0x02) << 4) | (bc.zero? ? 0 : PF))
-        repeat_block if repeat && !bc.zero?
-      end
-
-      def block_compare(step, repeat)
-        value = read_byte(hl)
-        @cycles += 5
-        result = (@a - value) & 0xff
-        half = (@a ^ value ^ result) & HF
-        adjusted = result - (half >> 4)
-        self.hl = (hl + step) & 0xffff
-        self.bc = (bc - 1) & 0xffff
-        @wz = (@wz + step) & 0xffff
-        assign_flags((@f & CF) | NF | half | (SZ53[result] & (SF | ZF)) | (adjusted & XF) | ((adjusted & 0x02) << 4) |
-                  (bc.zero? ? 0 : PF))
-        repeat_block if repeat && !bc.zero? && !result.zero?
-      end
-
-      def repeat_block
-        @cycles += 5
-        @pc = (@pc - 2) & 0xffff
-        @wz = (@pc + 1) & 0xffff
-        assign_flags((@f & ~XYF) | ((@pc >> 8) & XYF))
-      end
-    end
-  end
-end