badline 0.6.0 → 0.7.0

data/lib/badline/audio/terminal.rb

@@ -10,9 +10,13 @@ module Badline
     # stty and poll(2) for the native badline.
     class Terminal
       KEYS = {
-        "n" => :next, "\e[C" => :next,
-        "p" => :previous, "\e[D" => :previous,
+        "n" => :next, "p" => :previous,
+        "\e[C" => :next_subtune, "\e[D" => :previous_subtune,
         " " => :pause,
+        "s" => :shuffle,
+        "l" => :loop,
+        "a" => :all_subtunes,
+        "," => :back, "." => :forward,
         "q" => :quit
       }.freeze
 
@@ -20,6 +24,8 @@ module Badline
         @input = input
         @output = output
         @closed = false
+        @tune = 1
+        @tunes = 1
       end
 
       # Raw input and a hidden cursor for the length of the block.
@@ -46,12 +52,39 @@ module Badline
 
       def header(lines)
         lines.each { |line| @output.print "#{line}\r\n" }
-        @output.print "n/→ next  p/← previous  space pause  q quit\r\n"
+        @output.print "←/→ subtune  n/p tune  ,/. seek  space pause  s shuffle  l loop  a all subtunes  q quit\r\n"
       end
 
-      def status(song:, songs:, elapsed:, length:, notes: [])
-        line = format("song %<song>d/%<songs>d  %<elapsed>s / %<length>s",
-                      song:, songs:, elapsed: clock(elapsed), length: clock(length))
+      # Prints lines above the status line, such as the next tune's header.
+      def announce(lines)
+        lines.each { |line| @output.print "\r\e[K#{line}\r\n" }
+      end
+
+      # The tune's place in the queue, which the status line shows once
+      # there is more than one.
+      def place(tune, tunes)
+        @tune = tune
+        @tunes = tunes
+      end
+
+      # Where :seek asks the subtune to play from, in seconds. Only a window
+      # asks for it, by a click on the time the subtune has played.
+      def seek_to = 0.0
+
+      # The files dropped on a window since it last said :drop.
+      def dropped = []
+
+      # Hears of the STIL fields for the tune and for the subtune starting,
+      # which the terminal prints as the CLI announces them.
+      def stil(fields, subtune, subtune_fields) = [fields, subtune, subtune_fields]
+
+      # Hears of each subtune's renderer as it starts playing.
+      def playing(renderer) = renderer
+
+      def status(subtune:, subtunes:, elapsed:, length:, notes: [])
+        line = format("subtune %<subtune>d/%<subtunes>d  %<elapsed>s / %<length>s",
+                      subtune:, subtunes:, elapsed: clock(elapsed), length: clock(length))
+        line = format("tune %<tune>d/%<tunes>d  %<line>s", tune: @tune, tunes: @tunes, line:) if @tunes > 1
         @output.print "\r\e[K#{([line] + notes).join('  ')}"
         @output.flush
       end

data/lib/badline/audio/wav.rb

@@ -10,7 +10,7 @@ module Badline
 
       def header
         ["RIFF", 0, "WAVE",
-         "fmt ", 16, 1, 1, rate, rate * 2, 2, 16,
+         "fmt ", 16, 1, channels, rate, rate * channels * 2, channels * 2, 16,
          "data", 0].pack("a4Va4a4VvvVVvva4V")
       end
 

data/lib/badline/audio.rb

@@ -3,13 +3,12 @@
 require "badline/audio/pcm_writer"
 require "badline/audio/wav"
 require "badline/audio/aiff"
+require "badline/audio/stereo"
 require "badline/audio/bare_player"
 require "badline/audio/machine_player"
 require "badline/audio/renderer"
 require "badline/audio/playback"
-require "badline/audio/sdl_sink"
-require "badline/audio/stream"
 require "badline/audio/terminal"
-require "badline/audio/console"
 require "badline/audio/jukebox"
+require "badline/audio/queued_tune"
 require "badline/audio/cli"

data/lib/badline/computer.rb

@@ -226,12 +226,15 @@ module Badline
       @cpu.pending_write? || !@vic.ba_low? ? @cpu.cycle! : @cpu.stall!
     end
 
+    # The REU's /DMA line takes the bus from the CPU from the cycle after
+    # it asks for it, even while it waits for BA, but RDY only halts the
+    # CPU on a read, so a write it makes then goes nowhere.
     def dma_cycle!
       writing = @cpu.pending_write?
-      @reu.dma_cycle!(@vic.reu_ba_low?, writing)
-      return @cpu.stall! if @reu.holds_bus?
+      @reu.dma_cycle!(@vic.ba_low?)
+      return writing ? @address_bus.cycle_cpu_off_bus(@cpu) : @cpu.stall! if @reu.dma?
 
-      @dma = @reu.dma?
+      @dma = false
       writing || !@vic.ba_low? ? @cpu.cycle! : @cpu.stall!
     end
 

data/lib/badline/cpu/boundary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Badline
+  class CPU
+    # The steps at an instruction boundary: the opcode fetch that starts
+    # an instruction, and the ends of one.
+    module Boundary
+      private
+
+      # The first cycle of every instruction. Starts an interrupt if one was
+      # pending when the previous instruction ended. Otherwise reads the
+      # opcode and switches to its plan.
+      def op_fetch
+        return start_interrupt if @boundary_nmi || @boundary_irq
+
+        run_traps
+        opcode = @memory.peek(@program_counter)
+        log(opcode) if @debug
+        micro = MICROCODE[opcode]
+        @operation = micro.operation
+        @plan = micro.plan
+        @writes = micro.writes
+        @optional_dummy = micro.optional_dummy
+        @index = 1
+        @boundary_crossed = false
+        @program_counter = (@program_counter + 1) & 0xffff
+      end
+
+      def end_instruction
+        @instructions += 1
+        end_sequence
+      end
+
+      # Makes the next cycle an opcode fetch, and saves the pending interrupt
+      # flags for op_fetch. The next cycle polls before op_fetch runs, which
+      # updates the live flags.
+      def end_sequence
+        @plan = FETCH_PLAN
+        @writes = FETCH_WRITES
+        @index = 0
+        @boundary_irq = @irq_pending
+        @boundary_nmi = @nmi_pending
+      end
+
+      def log(opcode)
+        instruction = Instruction.find(opcode)
+        puts(
+          "#{@cycles}: PC: #{format16(@program_counter)} - " \
+          "#{instruction.name.upcase} #{instruction.addressing_mode}"
+        )
+      end
+    end
+  end
+end

data/lib/badline/cpu/core.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "badline/cpu/microcode"
+require "badline/cpu/addressing"
+require "badline/cpu/operations"
+require "badline/cpu/stack_operations"
+require "badline/cpu/boundary"
+require "badline/cpu/saved_state"
+
+module Badline
+  class CPU
+    STATUS_FLAGS = [:carry, :zero, :interrupt, :decimal, :break, 1, :overflow, :negative].freeze
+
+    # The 6502 core, on whatever bus +memory+ is. The C64's 6510 (CPU) and
+    # the 1541's 6502 (Drive1541::CPU) each include it.
+    module Core
+      include IntegerHelper
+      include InstructionSet
+      include Interrupts
+      include Traps
+      include Addressing
+      include Operations
+      include StackOperations
+      include Boundary
+      include SavedState
+
+      attr_reader :memory, :instructions, :boundary_crossed, :cycles, :pending_write
+      attr_accessor :program_counter, :stack_pointer, :status, :a, :x, :y, :nmi, :irq
+
+      alias pending_write? pending_write
+
+      # +ane_constant+ is ANE's magic constant, which varies from chip to
+      # chip. The default is the C64 6510's.
+      def initialize(memory, debug: false, ane_constant: 0xef)
+        @debug = debug
+        @ane_constant = ane_constant
+        @memory = memory
+        @status = CPUStatus.new(STATUS_FLAGS, value: 0b00100000)
+        reset_registers
+
+        @nmi = @irq = false
+        @irq_sample = @irq_pending = false
+        @nmi_sample = @nmi_pending = false
+        @skip_poll = false
+        @boundary_crossed = false
+        @interrupt = nil
+        @brk = false
+        @pending_write = false
+        @stalled_at = nil
+        @so_high = true
+
+        @cycles = 0
+        @instructions = 0
+        @traps = nil
+        end_sequence
+      end
+
+      def reset!
+        status.interrupt = true
+        reset_registers
+        @nmi = false
+        @irq_sample = @irq_pending = false
+        @nmi_sample = @nmi_pending = false
+        @skip_poll = false
+        @pending_write = false
+        end_sequence
+      end
+
+      def p
+        status.value
+      end
+
+      def p=(new_value)
+        status.value = new_value
+      end
+
+      def cycle!
+        poll # the interrupt lines
+
+        # Run the next step
+        index = @index
+        @index = index + 1
+        send(@plan[index])
+        @cycles += 1
+
+        # Record if the next step writes to memory
+        @pending_write = @writes[@index]
+        nil
+      end
+
+      # Called instead of #cycle! on a cycle the VIC holds the CPU through
+      # BA. Records which cycle the CPU was stalled before, and keeps
+      # sampling the interrupt lines.
+      def stall!
+        @stalled_at = @cycles
+        sample_while_stalled
+      end
+
+      # The 6502's SO (set overflow) pin, which the 6510 leaves out, so the
+      # C64 never drives it. A falling edge sets V and a held level does
+      # nothing more.
+      def so=(high)
+        @status.overflow = true if @so_high && !high
+        @so_high = high
+      end
+
+      # Pulses SO: pulls it low, which sets V, and releases it.
+      def so!
+        @status.overflow = true
+        @so_high = true
+      end
+
+      def jammed?
+        @plan.equal?(JAMMED_PLAN)
+      end
+
+      # Runs to the end of the instruction, or until the CPU jams.
+      def step!
+        cycle!
+        cycle! until @plan.equal?(FETCH_PLAN) || jammed?
+        nil
+      end
+
+      # Whether the next cycle fetches an opcode.
+      def boundary? = @index.zero? && @plan.equal?(FETCH_PLAN)
+
+      def trapped? = !@traps.nil?
+
+      def inspect
+        "Cycles: #{@cycles}, PC: #{format16(program_counter)}, " \
+          "SP: #{format8(stack_pointer)}, A: #{format8(a)}, X: #{format8(x)}, " \
+          "Y: #{format8(y)}, P: #{format8(p)}"
+      end
+
+      private
+
+      # True when the CPU was stalled right before this cycle.
+      def stalled_before_this_cycle?
+        @stalled_at == @cycles
+      end
+
+      # True when the CPU was stalled right before the cycle that preceded
+      # this one.
+      def stalled_before_previous_cycle?
+        @stalled_at == @cycles - 1
+      end
+
+      def write_byte(addr, value)
+        @memory.poke(addr, value)
+      end
+
+      def stack_address(offset = 0)
+        0x0100 | ((@stack_pointer + offset) & 0xff)
+      end
+
+      def reset_registers
+        # The program counter is initialized from the reset vector
+        @program_counter = @memory.peek16(0xfffc)
+        # Stack pointer starts at 0x01ff and grows down
+        @stack_pointer = 0xff
+        @a = @x = @y = 0x0
+      end
+    end
+  end
+end

data/lib/badline/cpu.rb

@@ -1,221 +1,10 @@
 # frozen_string_literal: true
 
-require "badline/cpu/microcode"
-require "badline/cpu/addressing"
-require "badline/cpu/operations"
-require "badline/cpu/stack_operations"
-require "badline/cpu/saved_state"
+require "badline/cpu/core"
 
 module Badline
+  # The C64's 6510, on the AddressBus.
   class CPU
-    STATUS_FLAGS = [:carry, :zero, :interrupt, :decimal, :break, 1, :overflow, :negative].freeze
-
-    include IntegerHelper
-    include InstructionSet
-    include Interrupts
-    include Traps
-    include Addressing
-    include Operations
-    include StackOperations
-    include SavedState
-
-    attr_reader :memory, :instructions, :boundary_crossed, :cycles, :pending_write
-    attr_accessor :program_counter, :stack_pointer, :status, :a, :x, :y, :nmi, :irq
-
-    alias pending_write? pending_write
-
-    # +ane_constant+ is ANE's magic constant, which varies from chip to
-    # chip. The default is the C64 6510's.
-    def initialize(memory, debug: false, ane_constant: 0xef)
-      @debug = debug
-      @ane_constant = ane_constant
-      @memory = memory
-      @status = CPUStatus.new(STATUS_FLAGS, value: 0b00100000)
-      reset_registers
-
-      @nmi = @irq = false
-      @irq_sample = @irq_pending = false
-      @nmi_sample = @nmi_pending = false
-      @skip_poll = false
-      @boundary_crossed = false
-      @interrupt = nil
-      @brk = false
-      @pending_write = false
-      @stalled_at = nil
-      @so_high = true
-
-      @cycles = 0
-      @instructions = 0
-      @traps = nil
-      end_sequence
-    end
-
-    def reset!
-      status.interrupt = true
-      reset_registers
-      @nmi = false
-      @irq_sample = @irq_pending = false
-      @nmi_sample = @nmi_pending = false
-      @skip_poll = false
-      @pending_write = false
-      end_sequence
-    end
-
-    def p
-      status.value
-    end
-
-    def p=(new_value)
-      status.value = new_value
-    end
-
-    def cycle!
-      poll # the interrupt lines
-
-      # Run the next step
-      index = @index
-      @index = index + 1
-      send(@plan[index])
-      @cycles += 1
-
-      # Record if the next step writes to memory
-      @pending_write = @writes[@index]
-      nil
-    end
-
-    # Called instead of #cycle! on a cycle the VIC holds the CPU through
-    # BA. Records which cycle the CPU was stalled before, and keeps
-    # sampling the interrupt lines.
-    def stall!
-      @stalled_at = @cycles
-      sample_while_stalled
-    end
-
-    # The 6502's SO (set overflow) pin, which the 6510 leaves out, so the
-    # C64 never drives it. A falling edge sets V and a held level does
-    # nothing more.
-    def so=(high)
-      @status.overflow = true if @so_high && !high
-      @so_high = high
-    end
-
-    # Pulses SO: pulls it low, which sets V, and releases it.
-    def so!
-      @status.overflow = true
-      @so_high = true
-    end
-
-    def jammed?
-      @plan.equal?(JAMMED_PLAN)
-    end
-
-    # Runs to the end of the instruction, or until the CPU jams.
-    def step!
-      cycle!
-      cycle! until @plan.equal?(FETCH_PLAN) || jammed?
-      nil
-    end
-
-    # Whether the next cycle fetches an opcode.
-    def boundary? = @index.zero? && @plan.equal?(FETCH_PLAN)
-
-    def trapped? = !@traps.nil?
-
-    # Everything the CPU holds but its cycle and instruction counts: the
-    # registers, the interrupt lines and pipeline, and what the last
-    # instruction left in its working registers. Drive1541::Idle compares
-    # it at two instruction boundaries.
-    def idle_state
-      [@program_counter, @stack_pointer, @a, @x, @y, @status.value,
-       @irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll,
-       @boundary_irq, @boundary_nmi, @so_high, @interrupt, @brk, @pending_write, @stalled_at, @traps,
-       @operation, @optional_dummy, @boundary_crossed, @branch_taken,
-       @address, @pointer, @dummy_address, @value, @rmw_result]
-    end
-
-    # Counts +cycles+ cycles and +instructions+ instructions that ran
-    # without changing anything idle_state holds.
-    def fast_forward(cycles, instructions)
-      @cycles += cycles
-      @instructions += instructions
-    end
-
-    def inspect
-      "Cycles: #{@cycles}, PC: #{format16(program_counter)}, " \
-        "SP: #{format8(stack_pointer)}, A: #{format8(a)}, X: #{format8(x)}, " \
-        "Y: #{format8(y)}, P: #{format8(p)}"
-    end
-
-    private
-
-    # The first cycle of every instruction. Starts an interrupt if one was
-    # pending when the previous instruction ended. Otherwise reads the
-    # opcode and switches to its plan.
-    def op_fetch
-      return start_interrupt if @boundary_nmi || @boundary_irq
-
-      run_traps
-      opcode = @memory.peek(@program_counter)
-      log(opcode) if @debug
-      micro = MICROCODE[opcode]
-      @operation = micro.operation
-      @plan = micro.plan
-      @writes = micro.writes
-      @optional_dummy = micro.optional_dummy
-      @index = 1
-      @boundary_crossed = false
-      @program_counter = (@program_counter + 1) & 0xffff
-    end
-
-    def end_instruction
-      @instructions += 1
-      end_sequence
-    end
-
-    # Makes the next cycle an opcode fetch, and saves the pending interrupt
-    # flags for op_fetch. The next cycle polls before op_fetch runs, which
-    # updates the live flags.
-    def end_sequence
-      @plan = FETCH_PLAN
-      @writes = FETCH_WRITES
-      @index = 0
-      @boundary_irq = @irq_pending
-      @boundary_nmi = @nmi_pending
-    end
-
-    # True when the CPU was stalled right before this cycle.
-    def stalled_before_this_cycle?
-      @stalled_at == @cycles
-    end
-
-    # True when the CPU was stalled right before the cycle that preceded
-    # this one.
-    def stalled_before_previous_cycle?
-      @stalled_at == @cycles - 1
-    end
-
-    def write_byte(addr, value)
-      @memory.poke(addr, value)
-    end
-
-    def stack_address(offset = 0)
-      0x0100 | ((@stack_pointer + offset) & 0xff)
-    end
-
-    def reset_registers
-      # The program counter is initialized from the reset vector
-      @program_counter = @memory.peek16(0xfffc)
-      # Stack pointer starts at 0x01ff and grows down
-      @stack_pointer = 0xff
-      @a = @x = @y = 0x0
-    end
-
-    def log(opcode)
-      instruction = Instruction.find(opcode)
-      puts(
-        "#{@cycles}: PC: #{format16(@program_counter)} - " \
-        "#{instruction.name.upcase} #{instruction.addressing_mode}"
-      )
-    end
+    include Core
   end
 end

data/lib/badline/drive1541/cpu.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # The drive's 6502, on the drive's Bus.
+    class CPU
+      include Badline::CPU::Core
+
+      # Everything the CPU holds but its cycle and instruction counts: the
+      # registers, the interrupt lines and pipeline, and what the last
+      # instruction left in its working registers. Drive1541::Idle compares
+      # it at two instruction boundaries.
+      def idle_state
+        [@program_counter, @stack_pointer, @a, @x, @y, @status.value,
+         @irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll,
+         @boundary_irq, @boundary_nmi, @so_high, @interrupt, @brk, @pending_write, @stalled_at, @traps,
+         @operation, @optional_dummy, @boundary_crossed, @branch_taken,
+         @address, @pointer, @dummy_address, @value, @rmw_result]
+      end
+
+      # Counts +cycles+ cycles and +instructions+ instructions that ran
+      # without changing anything idle_state holds.
+      def fast_forward(cycles, instructions)
+        @cycles += cycles
+        @instructions += instructions
+      end
+    end
+  end
+end

data/lib/badline/drive1541.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/drive1541/bus"
+require "badline/drive1541/cpu"
 require "badline/drive1541/serial_port"
 require "badline/drive1541/gcr"
 require "badline/drive1541/track"