badline 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d667997df6e72a7efd6d8789896402ef09b757c49ac0e1890f9041a22d37d83b
-  data.tar.gz: ca5e42cebc1e7c1b4879062fab85bd97961242213f6701db86fa57717b270e8d
+  metadata.gz: 41235fb28f9f33c9a88333beec1c09cd9825d45875f24d22b8cb5f66f9528467
+  data.tar.gz: c214b37efce97c404dcd0838283e65e0f42aaa86a8376f18ef2323933b01b2f2
 SHA512:
-  metadata.gz: 8965b452eb8836de285dc76e7d8220a3b302b81341ee277ab9738ea334e5d27f108b14e1b162b3fe28e88f7aa2fba1e1e30e4dd5fe2b4f7c579643c45e820070
-  data.tar.gz: 6603b0599428aef7a8bd0b1b5b99300281d02dbde1bd327895dc055a30ce16f2bdfc758b37661bca18eca256b0e98e5080926426dabbf0997c6a96762d7e3793
+  metadata.gz: ab2c530282a35d8ac65c217d6901d46c6f844cde1d7c7ca143acb8ea8f05ac08d1da6b8ee290fb41bd016ce2079e308bfd5c5f338be18ed269be693612e07a50
+  data.tar.gz: 6c27c6d41e73e495bb27e536fae7424b5524c12b9c1d12cdb3bccc2efb3a73be6137e5209c4356394594d71ceaa205309989f193344003a3ed65245df0ec74fa

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [0.7.0](https://github.com/elektronaut/badline/compare/v0.6.1...v0.7.0) (2026-10-02)
+
+
+### ⚠ BREAKING CHANGES
+
+* call a .sid tune's parts subtunes everywhere
+
+### Features
+
+* add a badline sid subcommand that plays tunes and directories ([7dfc21b](https://github.com/elektronaut/badline/commit/7dfc21b5e4ba47cd37a4593da61e95bb1d2329ab))
+* drop .sid files and folders on the SID player to queue them ([cc1f434](https://github.com/elektronaut/badline/commit/cc1f434b7404ded067ef43d1d3d5aa53d338de4c))
+* end a subtune with no known length when it falls silent ([46c4f10](https://github.com/elektronaut/badline/commit/46c4f1064f6382872ec22989253bc9c159f78dcf))
+* open a .sid tune, or no tune at all, in the SID player ([396c010](https://github.com/elektronaut/badline/commit/396c010ee626f95fbb71ced8bf3905909c470c8e))
+* play 2SID and 3SID tunes in stereo in the SID player ([7c72eef](https://github.com/elektronaut/badline/commit/7c72eeff7e5e7b1c56286f9bf6030ae3408f7176))
+* play a queue of tunes, with shuffle, loop and play-all subtunes ([d163106](https://github.com/elektronaut/badline/commit/d163106eea99d90f6ffe74fb91474a2aca4c64eb))
+* play sid tunes in a window that shows what the SID is doing ([60bfd3f](https://github.com/elektronaut/badline/commit/60bfd3f75fe82d928afa374d257d3d21e5ac29ad))
+* seek forward from where the subtune is, not from its start ([34059e8](https://github.com/elektronaut/badline/commit/34059e8f9b12cab44c94124e6455fef9c915d8eb))
+* seek within a subtune, and let the slow warning lapse ([b98ac6e](https://github.com/elektronaut/badline/commit/b98ac6eb6f9c0ce088545f55cc5f2445dd38dd2d))
+* show a tune's STIL entry in the SID player ([82d9dca](https://github.com/elektronaut/badline/commit/82d9dca26d7cefe853a6af41e50fc723a3e90170))
+* show each voice's live output in the SID view ([c61a128](https://github.com/elektronaut/badline/commit/c61a1289983887c0175fca3dc4c37b470e96de92))
+* show HVSC's STIL in the SID player ([bd55c0c](https://github.com/elektronaut/badline/commit/bd55c0c87695ba8cc84dbfd51ab2119a97eccded))
+* show where a seek is headed on the SID player's bar ([1a84b37](https://github.com/elektronaut/badline/commit/1a84b3746a960dba28dc9c789b3d2cd1520d2f94))
+* step subtunes and tunes on separate keys, add --all-subtunes ([eaef338](https://github.com/elektronaut/badline/commit/eaef3384e6205163e2a4b63f5aa8d9204fe5190f))
+* switch a SID between the 6581 and 8580 while it runs ([5920391](https://github.com/elektronaut/badline/commit/592039123d7936b8d22c8fd5f144a9bc9a8f383b))
+
+
+### Bug Fixes
+
+* build the native badline with a Spinel that keeps an array joined mid-expression alive ([d2c4eb2](https://github.com/elektronaut/badline/commit/d2c4eb20d6b80494fb2a20105c0532f3778b205c))
+* build the native badline with a Spinel that reports render progress ([58524ea](https://github.com/elektronaut/badline/commit/58524eaf4881661e7e0e9dd38c32071545bf1fae))
+* show non-ASCII text from a .sid header in the native badline ([959bb6f](https://github.com/elektronaut/badline/commit/959bb6f7d07de4c90ac50ae51ae63f3c66601a78))
+
+
+### Performance Improvements
+
+* draw the SID player's traces in one call each ([afcae15](https://github.com/elektronaut/badline/commit/afcae15ed273aa7a6dd49cb31e0f7180c56feb75))
+
 ## [0.6.1](https://github.com/elektronaut/badline/compare/v0.6.0...v0.6.1) (2026-09-30)
 
 

data/README.md

@@ -56,46 +56,53 @@ badline game.prg       # Load and run a program
 badline game.d64       # Mount a disk image as device 8 and load it
 badline game.tap       # Insert a tape and load it
 badline game.crt       # Attach a cartridge
-badline tune.sid       # Play a SID tune
+badline tune.sid       # Play a SID tune in the SID player
 badline game.vsf       # Restore a snapshot, from badline or VICE
 badline ~/c64          # Mount a directory as device 8
 ```
 
-`badline-ruby` takes the same media and the same options, with the
-differences noted below.
-
 Programs, disk and tape images and SID tunes start automatically, and
 a cartridge starts itself. A mounted directory waits for you to `LOAD`
-from it. `--no-autostart` attaches the media and stops at `READY.`, so
-you can type the `LOAD` yourself. `--read-only` mounts a disk image
-write-protected, so the drive reports `26,WRITE PROTECT ON` for any
-write and the image file stays as it was. `--song N` picks a subtune of a
-`.sid` file, `--sid 8580` fits the newer SID and `--reu 512` plugs in a
-512K RAM Expansion Unit. `--ntsc` runs an NTSC C64, with the 6567R8
-VIC-II, instead of a PAL one. `badline-ruby` also
-takes `--disable-jit`, which runs without YJIT, otherwise switched on at
-startup. `--help` lists the options.
+from it.
 
-The KERNAL, BASIC and character ROMs come with the gem. To run other
-images, such as a patched KERNAL, point `BADLINE_ROM_PATH` at a
-directory that holds `kernal.rom`, `basic.rom` and `character.rom`,
-plus `eapi/eapi-am29f040-14` if you attach EasyFlash cartridges. From
-Ruby, `Badline.rom_path = dir` does the same before a
-`Badline::Computer` is built, and `nil` restores the bundled set.
+`badline-ruby` takes the same media and the same options, with the
+differences noted in the table. `--help` lists the options for either.
+
+### Options
+
+| Option | Effect |
+| --- | --- |
+| `--no-autostart` | Attach the media and stop at `READY.`, so you can type the `LOAD` yourself |
+| `--read-only` | Mount a disk image write-protected. The drive reports `26,WRITE PROTECT ON` for any write and the image file stays as it was |
+| `--true-drive` | Put an emulated 1541 on device 8 instead of the KERNAL traps. See [Media](#media) |
+| `-s`, `--subtune N` | Pick a subtune of a `.sid` file, counting from 1 |
+| `--sid 6581`, `--sid 8580` | Fit the older or newer SID. `--sid auto`, the default, takes a `.sid` tune's own |
+| `--reu SIZE` | Plug in a RAM Expansion Unit of `SIZE` K: 128, 256, 512 (a 1750) or up to 16384 |
+| `--ntsc` | Run an NTSC C64, with the 6567R8 VIC-II, instead of a PAL one |
+| `--no-sound` | Don't play the SID (`badline` only, where sound is on by default) |
+| `--sound` | Play the SID (`badline-ruby`, where sound is off by default) |
+| `--no-vsync` | Pace the window by a timer, or by the sound while it plays, instead of the display's vsync |
+| `--verbose` | Print the display's refresh rate, the sound's sample rate and the game controllers found as the window opens, then the frame rate and the time each frame takes, once a second |
+| `--disable-jit` | Run without YJIT, otherwise switched on at startup (`badline-ruby` only) |
+| `--version` | Show the version and what built it (`badline` only) |
+| `-h`, `--help` | List the options |
 
 Both run the same window. `badline` plays the SID through the host's
-audio device, and `F10` mutes and unmutes it. `--no-sound` turns it
-off. The window is paced by the display's vsync; `--no-vsync` paces it
-by a timer, or by the sound while it plays.
-
-`--verbose` prints the display's refresh rate, the sound's sample rate
-and the game controllers found as the window opens, then the frame rate
-and the time each frame takes, once a second.
-
-For a scripted run, `--frames N` quits after N frames, `--unpaced` runs
-as fast as it can and `--at FRAME:EVENT` presses keys, types, swaps
-media and takes screenshots once that many frames have run. `--script
-FILE` takes one `FRAME:EVENT` a line:
+audio device, and `F10` mutes and unmutes it. In `badline-ruby` the
+machine runs below real time, so the sound stutters: it plays in bursts
+with silent gaps between them, at the right pitch, and never slows the
+emulation down.
+
+### Scripted runs
+
+| Option | Effect |
+| --- | --- |
+| `--frames N` | Quit after N frames |
+| `--unpaced` | Run as fast as it can, without vsync or pacing |
+| `--at FRAME:EVENT` | Press keys, type, swap media or take a screenshot once `FRAME` frames have run |
+| `--script FILE` | Run the events in `FILE`, one `FRAME:EVENT` a line |
+| `--screenshot FILE` | Save the last frame as a `.bmp` |
+| `--save-snapshot FILE` | Save the machine as a `.vsf` snapshot after the last frame |
 
 ```sh
 badline --unpaced --frames 12000 --true-drive disk1.d64 \
@@ -106,10 +113,14 @@ badline --unpaced --frames 12000 --true-drive disk1.d64 \
 `--help` lists the events, and [native/README.md](native/README.md#running)
 describes them.
 
-In `badline-ruby` sound is off by default, and `--sound` turns it on.
-The machine runs below real time there, so the sound stutters: it plays
-in bursts with silent gaps between them, at the right pitch, and never
-slows the emulation down.
+### ROMs
+
+The KERNAL, BASIC and character ROMs come with the gem. To run other
+images, such as a patched KERNAL, point `BADLINE_ROM_PATH` at a
+directory that holds `kernal.rom`, `basic.rom` and `character.rom`,
+plus `eapi/eapi-am29f040-14` if you attach EasyFlash cartridges. From
+Ruby, `Badline.rom_path = dir` does the same before a
+`Badline::Computer` is built, and `nil` restores the bundled set.
 
 ## Media
 
@@ -215,39 +226,107 @@ out and switches the machine off and on.
 
 `badline-ruby --headless` plays a `.sid` tune on the host's audio
 device without opening the window, and `--audio-out` renders it to a
-16-bit PCM file instead. The file's extension picks the format, `.wav`
+16-bit stereo PCM file instead. The file's extension picks the format, `.wav`
 or `.aiff`. The native `badline` has both modes too.
 
 ```sh
+badline sid ~/C64Music/MUSICIANS/H/Hubbard_Rob               # play every tune below a directory
+badline sid tune.sid other.sid                               # play a queue of tunes
 badline-ruby --headless tune.sid                             # play, length from HVSC
 badline-ruby --headless -s 3 tune.sid                        # play the third subtune
+badline-ruby --headless --all-subtunes tune.sid                 # play on through every subtune
 badline-ruby --seconds 180 tune.sid --audio-out out.aiff
 badline-ruby -s 3 --rate 48000 tune.sid --audio-out out.wav
 badline-ruby --headless --sid 8580 tune.sid
 badline-ruby --filter-chunk 1 tune.sid --audio-out out.wav   # exact filter, slower
 ```
 
+`badline sid FILE|DIR...` plays a queue of tunes in the SID player's
+window, in the order given, and a directory adds every `.sid` tune below
+it in path order. `badline sid --headless` plays the queue in the
+terminal instead. `badline sid` on its own opens the window with an
+empty queue. Dropping `.sid` files or folders on the window adds them
+to the end of the queue, and an empty queue starts playing them. It
+takes
+the options below except `--audio-out`, and `--subtune` picks the first
+tune's subtune. `--sid auto`, the default, fits each of a tune's SIDs
+the model its header names. A tune written for 2 or 3 SIDs plays on as
+many, at the addresses its header gives, in stereo: SID 1 on the left,
+SID 2 on the right and SID 3 in the centre. A tune on one SID plays the
+same on both channels. A file that isn't a tune is skipped.
+`badline tune.sid` plays the tune in the SID player too, unless an
+option of the emulator's window, such as `--ntsc` or `--reu`, asks for
+the machine: then a tune for one SID runs on the emulated C64, started
+through a small driver after boot.
+
 Both modes take the same options. The window's own, `--no-autostart`,
 `--read-only`, `--sound`, `--true-drive`, `--reu`, `--ntsc` and
-`--verbose`, don't apply to them. `--song` (or `-s`) picks the subtune, counting from 1 as HVSC
-does, and defaults to the tune's own start song. Playback asks the
+`--verbose`, don't apply to them. `--subtune` (or `-s`) picks the subtune, counting from 1 as HVSC
+does, and defaults to the tune's own start subtune. Playback asks the
 device for 44.1 kHz and takes whatever rate it offers, unless `--rate`
 says otherwise. Ctrl-C stops it.
 
-Played on a terminal, `--headless` shows the tune's name, author and
-release, the song number and the time played against the song's
-length. When a song reaches its length it goes on to the next, and it
-stops after the last. `n` or → skips to the next song, `p` or ← goes
-back one, space pauses and `q` quits. `--no-tui`, or output that isn't a
-terminal, gives plain progress output instead and plays just the one
-song, as `--audio-out` renders just the one.
+Played on a terminal, `--headless` and `sid` show each tune's name,
+author and release as it starts, then the tune's place in the queue,
+the subtune number and the time played against the subtune's length. `--headless`
+queues just the one tune. Each tune plays its own subtune: `--subtune`, or
+the tune's start subtune. When that subtune ends the player goes on to the next
+tune, and it stops after the last. `a`, or `--all-subtunes`, turns on
+playing all subtunes, so that a subtune that ends goes on to the tune's next
+subtune, and a tune stepped to starts on its first subtune.
+
+→ and ← step to the tune's next and previous subtune, stopping at its
+first and last. `n` and `p` step to the next and previous tune. `s`
+turns shuffle on and off, which plays the queue's tunes in a random
+order, and `l` turns looping on and off, so that the end of the queue
+goes on to its start. `,` and `.` seek 10 seconds back and forward
+within the subtune, which plays it again from its start and runs silently
+up to the point asked for. Space pauses and `q` quits. The status line
+shows which modes are on, and they last until the player quits.
+
+![The SID player's visualizer playing Rob Hubbard's Delta](doc/images/sid-player.png)
+
+The SID player's window is worked with the mouse. Its header shows the
+tune's name, author and release, the tune the subtune covers at the
+moment when HVSC's STIL credits one, following the times STIL gives, and
+buttons that switch between three views and between the tune's own SID
+model, the 6581 and the 8580, which changes the chips playing on the
+spot. Its footer shows the time played on a bar you can click to seek,
+and buttons that pause, step between tunes and between a tune's
+subtunes, and turn shuffle, looping and all subtunes on and off. The
+visualizer view shows each voice's note, and how far off it is in cents,
+over a scope of the voice's output, and the mixed output below them. A
+tune on more than one SID gets a row of voices for each SID, and the mix
+splits into its left and right. The SID view shows one SID at a time,
+and for a tune on more than one, a row of SID 1, 2 and 3 buttons at its
+top picks which. It shows each voice's waveforms and the shape
+they make, its control bits, pulse width, envelope settings, and the
+envelope's level and stage, and the filter's modes, cutoff, resonance,
+volume and its response on the chip playing. The INFO view shows the
+tune's STIL entry and the subtune's, with a scroll bar, the mouse wheel
+or the up and down keys for the long ones. The terminal's keys work in
+the window too, along with Tab to switch views and `c` to step through
+the SID models.
+
+`--no-tui`, or output that isn't a terminal, gives plain progress
+output instead and plays through the queue without the keys, while
+`--audio-out` renders just the one subtune.
 
 A `.sid` file doesn't store its length, so `badline-ruby` looks the
 tune up by MD5 in HVSC's `Songlengths.md5`. It finds the database
 through `--songlengths`, in a `DOCUMENTS` directory in any of the
 tune's parent directories (the layout of an HVSC collection), or under
 `$HVSC_BASE/DOCUMENTS`. Without a database or `--seconds` it runs for
-60 seconds.
+60 seconds, but a subtune that falls silent for 5 seconds before then
+ends there, when played and when rendered alike. Silent means the
+output holds within 16 steps of one level, since a 6581 idles at a DC
+offset rather than at zero. A subtune with a known length plays to its
+length whatever it sounds like.
+
+A tune in an HVSC collection also gets its entry in HVSC's `STIL.txt`,
+found the same way: comments, covers, and subtune names and composers.
+The tune's own fields follow its header, and each subtune's print as it
+starts.
 
 PSID tunes run on a CPU and RAM with only the SID clocked, at about
 twice real time, so they play smoothly. RSID tunes set up their own

data/exe/badline-ruby

@@ -36,13 +36,21 @@ end
 
 if options.headless?
   require "badline/audio/console"
+  console = if options.player_window?
+              lambda do |input:, output:|
+                load_sdl
+                Badline::Frontend::PlayerWindow.new(input:, output:)
+              end
+            else
+              Badline::Audio::Console.method(:new)
+            end
   sink = lambda do |rate:, exact_rate:|
     load_sdl
     Badline::Frontend::AudioSink.new(rate:, exact_rate:)
   rescue Badline::FFI::Error => e
     raise Badline::Audio::Playback::DeviceError, e.message
   end
-  exit Badline::Audio::CLI.run(options, sink:, console: Badline::Audio::Console.method(:new))
+  exit Badline::Audio::CLI.run(options, sink:, console:)
 end
 
 begin

data/lib/badline/address_bus/extra_sids.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Badline
+  class AddressBus
+    # The second and third SIDs the SID player fits for a tune written for
+    # them, each over its 32 bytes of the I/O area (SIDSlots). The SID
+    # player's machine has nothing else in I/O 1 and 2, so the rest of a
+    # page there reads the open bus.
+    module ExtraSIDs
+      # Fits a SID at the address it was built at, where it takes its 32
+      # bytes over from whatever maps there.
+      def add_sid(sid)
+        page = sid.start >> 8
+        slots = @sid_slots.find { |candidate| candidate.page == page }
+        if slots.nil?
+          slots = SIDSlots.new(page, @sid, @open_bus)
+          @sid_slots << slots
+        end
+        slots.place(sid)
+        update_overlays!
+      end
+
+      private
+
+      def map_extra_sids
+        @sid_slots.each { |slots| @read_pages[slots.page] = @write_pages[slots.page] = slots }
+      end
+    end
+  end
+end

data/lib/badline/address_bus/sid_slots.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  class AddressBus
+    # Stands in for a page of I/O that a second or third SID shares: each 32
+    # bytes of it go to the SID placed there, or else to the first SID's
+    # mirrors in `$d400-$d7ff`, and to the open bus in I/O 1 and 2.
+    class SIDSlots
+      attr_reader :page
+
+      def initialize(page, first, open_bus)
+        @page = page
+        @io = page >= 0xde
+        @first = first
+        @open_bus = open_bus
+        @sids = []
+        @slots = Array.new(8, -1)
+      end
+
+      def place(sid)
+        @slots[(sid.start >> 5) & 7] = @sids.size
+        @sids << sid
+      end
+
+      def peek(addr)
+        index = @slots[(addr >> 5) & 7]
+        return @sids[index].peek(addr) unless index.negative?
+
+        @io ? @open_bus.peek(addr) : @first.peek(addr)
+      end
+
+      def poke(addr, value)
+        index = @slots[(addr >> 5) & 7]
+        if !index.negative?
+          @sids[index].poke(addr, value)
+        elsif !@io
+          @first.poke(addr, value)
+        end
+      end
+    end
+  end
+end

data/lib/badline/address_bus.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "badline/address_bus/saved_state"
+require "badline/address_bus/sid_slots"
+require "badline/address_bus/extra_sids"
 require "badline/address_bus/ultimax_pages"
 
 module Badline
@@ -32,6 +34,7 @@ module Badline
   class AddressBus
     include Addressable
     include UltimaxPages
+    include ExtraSIDs
 
     # I/O 1 and 2, and the Ultimax holes, with nothing on the bus. A read
     # picks up the byte the VIC fetched in the preceding phi1 half-cycle,
@@ -82,6 +85,7 @@ module Badline
       @control_ports.port_a_source = @cia1
       @cia1.on_port_b4_change { |high| @vic.lightpen_level(high) }
       @sid = SID.new(model: sid_model, pots: @control_ports)
+      @sid_slots = []
 
       @datasette = Datasette.new
       @datasette.on_flag { @cia1.flag! }
@@ -252,6 +256,7 @@ module Badline
       @read_pages[0xd7] = @write_pages[0xd7] = @debug_register if @debug_register
       @read_pages[0xdf] = @write_pages[0xdf] = @reu if @reu
       map_cartridge_io if @cartridge
+      map_extra_sids unless @sid_slots.empty?
     end
 
     def map_cartridge_io

data/lib/badline/audio/aiff.rb

@@ -13,14 +13,14 @@ module Badline
 
       def header
         ["FORM", 0, "AIFF",
-         "COMM", 18, 1, 0, 16].pack("a4Na4a4NnNn") +
+         "COMM", 18, channels, 0, 16].pack("a4Na4a4NnNn") +
           extended(rate) +
           ["SSND", 0, 0, 0].pack("a4NNN")
       end
 
       def patch
         write_at(4, [46 + data_size].pack("N"))
-        write_at(22, [samples].pack("N"))
+        write_at(22, [frames].pack("N"))
         write_at(42, [8 + data_size].pack("N"))
       end
 

data/lib/badline/audio/bare_player.rb

@@ -44,12 +44,12 @@ module Badline
       # The KERNAL's PAL/NTSC flag, 1 for PAL.
       VIDEO_STANDARD = 0x02a6
 
-      attr_reader :sid
+      attr_reader :sid, :stereo
 
-      def initialize(tune, song: nil, sid_model: tune.sid_model)
+      def initialize(tune, subtune: nil, sid_models: tune.sid_models)
         @tune = tune
-        @song = (song || tune.start_song).clamp(1, tune.songs) - 1
-        @bus = AddressBus.new(sid_model:)
+        @subtune = (subtune || tune.start_subtune).clamp(1, tune.subtunes) - 1
+        @bus = AddressBus.new(sid_model: sid_models[0])
         # The CPU port as the KERNAL leaves it, which a PSID tune expects.
         @bus.poke(0x00, 0x2f)
         @bus.poke(0x01, 0x37)
@@ -57,28 +57,38 @@ module Badline
         @bus.cia1.timer_a_latch = tune.ntsc? ? NTSC_KERNAL_TIMER : KERNAL_TIMER
         @cpu = CPU.new(@bus)
         @sid = @bus.sid
+        @stereo = Stereo.new(@bus, tune, sid_models)
+        @extras = @stereo.extras
+        @multi = !@extras.empty?
         @idle = false
       end
 
       def start
         @bus.ram.write(@tune.load_address, @tune.data)
         @bus.ram.write(stub_address, stub)
-        @sid.synthesize!
+        @stereo.synthesize!
         @cpu.status.interrupt = true
         @cpu.program_counter = idle_address
         install_dispatch
-        call(@tune.init_address, @song)
+        call(@tune.init_address, @subtune)
         settle
       end
 
       # Advances one call of play, or `budget` cycles if that is shorter,
-      # then yields whatever the SID recorded over it. Returns the cycles
-      # advanced.
+      # then yields whatever the SIDs recorded over it, in stereo. Returns
+      # the cycles advanced.
       def frame(budget, &)
         call(@tune.play_address)
         cycles = [budget, period].min
-        cycles.times { step }
-        @sid.drain_samples.each(&)
+        if @multi
+          cycles.times { step }
+        else
+          cycles.times do
+            @sid.cycle!
+            @cpu.cycle!
+          end
+        end
+        @stereo.mix(&)
         cycles
       end
 
@@ -86,10 +96,10 @@ module Badline
 
       private
 
-      # A video frame, or for a CIA-timed song one period of CIA 1 timer A,
+      # A video frame, or for a CIA-timed subtune one period of CIA 1 timer A,
       # which init and play are both free to reprogram.
       def period
-        return (@tune.ntsc? ? NTSC_FRAME_CYCLES : FRAME_CYCLES) unless @tune.cia_timed?(@song + 1)
+        return (@tune.ntsc? ? NTSC_FRAME_CYCLES : FRAME_CYCLES) unless @tune.cia_timed?(@subtune + 1)
 
         @bus.cia1.timer_a_latch + 1
       end
@@ -117,6 +127,7 @@ module Badline
 
       def step
         @sid.cycle!
+        @extras.each(&:cycle!) if @multi
         @cpu.cycle!
       end