badline 0.5.1 → 0.6.1

data/lib/badline/drive1541/disk_state.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    class Disk
+      # Saving and restoring a Disk for a snapshot: the image by its path,
+      # and every half track as the head sees it, with those written since
+      # the last flush. The image itself is read again from its host file.
+      module State
+        # The image's path, expanded, and whether it was opened read-only,
+        # for a disk from Disk.open. Nil for a disk made another way.
+        attr_reader :path, :read_only
+
+        # A .g64 image by its name, and anything else a .d64.
+        def self.g64?(path) = File.extname(path).casecmp?(".g64")
+
+        # A disk for the image at the path, its tracks left for the state.
+        def self.reopen(path, read_only)
+          if g64?(path)
+            Disk.new(Storage::G64Image.new(path, read_only:)).opened(path, read_only)
+          else
+            Disk.new(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
+          end
+        end
+
+        # The disk a state from save_state describes: +current+ when it was
+        # opened from the same image the same way, and otherwise a disk for
+        # the image at the path the state names, or one without an image,
+        # as a detached reader always gets. Either way its tracks come from
+        # the state.
+        def self.load(input, current)
+          path = input.optional_string
+          read_only = input.boolean?
+          disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
+          disk ||= path && !input.detached? ? reopen(path, read_only) : Disk.new
+          disk.load_tracks(input)
+          disk
+        end
+
+        # Notes the image's path and how it was opened.
+        def opened(path, read_only)
+          @path = File.expand_path(path)
+          @read_only = read_only
+          self
+        end
+
+        def save_state(out)
+          out.optional_string(@path).boolean(@read_only)
+          @tracks.each do |track|
+            out.boolean(!track.nil?)
+            save_track(track, out) if track
+          end
+          out.ints(@written.keys)
+        end
+
+        def load_tracks(input)
+          @tracks.each_index do |half_track|
+            @tracks[half_track] = input.boolean? ? load_track(input) : nil
+          end
+          @written.clear
+          input.ints.each { |half_track| @written[half_track] = true }
+        end
+
+        private
+
+        def save_track(track, out)
+          out.int(track.zone).boolean(!track.speeds.nil?)
+          out.ints(track.speeds) if track.speeds
+          out.blob(track.bytes)
+        end
+
+        def load_track(input)
+          zone = input.int
+          speeds = input.boolean? ? input.ints : nil
+          Track.new(input.blob, zone, speeds)
+        end
+      end
+    end
+  end
+end

data/lib/badline/drive1541/mechanism.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/drive1541/rotation"
+require "badline/drive1541/mechanism_state"
 
 module Badline
   class Drive1541
@@ -65,6 +66,7 @@ module Badline
     # half track after it.
     class Mechanism
       include Rotation
+      include MechanismState
 
       MOTOR = 0x04
       LED = 0x08

data/lib/badline/drive1541/mechanism_state.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # Saving and restoring the Mechanism for a snapshot.
+    module MechanismState
+      # The disk (Disk#save_state) and everything the head, the motor, the
+      # stepper and the read and write electronics hold, down to the cell
+      # under the head and the read clock's phase.
+      def save_state(out)
+        out.boolean(!@disk.nil?)
+        @disk&.save_state(out)
+        [@half_track, @slip, @zone, @clock, @time, @clock_at, @clocks, @shift, @ones, @bits, @write_shift,
+         @index, @mask, @cell_end, @width, @next].each { |value| out.int(value) }
+        [@motor, @led, @sync, @byte_ready, @writing, @write_gate, @protected, @track_written].each do |flag|
+          out.boolean(flag)
+        end
+        out.optional_int(@write_index)
+      end
+
+      # Puts the state back, reusing the disk in when it's the one the state
+      # names (Disk::State.load). A disk taken out is flushed, as insert
+      # does.
+      def load_state(input)
+        disk = input.boolean? ? Disk::State.load(input, @disk) : nil
+        flush unless disk.equal?(@disk)
+        @disk = disk
+        load_head(input)
+        load_flags(input)
+        @write_index = input.optional_int
+        head_on_track
+      end
+
+      private
+
+      def load_head(input)
+        @half_track = input.int
+        @slip = input.int
+        @zone = input.int
+        @clock = input.int
+        @time = input.int
+        @clock_at = input.int
+        @clocks = input.int
+        @shift = input.int
+        @ones = input.int
+        @bits = input.int
+        @write_shift = input.int
+        @index = input.int
+        @mask = input.int
+        @cell_end = input.int
+        @width = input.int
+        @next = input.int
+      end
+
+      def load_flags(input)
+        @motor = input.boolean?
+        @led = input.boolean?
+        @sync = input.boolean?
+        @byte_ready = input.boolean?
+        @writing = input.boolean?
+        @write_gate = input.boolean?
+        @protected = input.boolean?
+        @track_written = input.boolean?
+      end
+    end
+  end
+end

data/lib/badline/drive1541/rotation.rb

@@ -92,6 +92,16 @@ module Badline
         @writing ? write_bit(at) : read_bit(one)
       end
 
+      # The track under the head and its layout, leaving the head's place
+      # on it as it stands.
+      def head_on_track
+        @track = @disk&.track(@half_track) || BLANK
+        @bytes = @track.bytes
+        @widths = @track.widths
+        @length = @track.length
+        @last = @length - 1
+      end
+
       # The track under the head, from the cell that's under it +time+
       # into the turn.
       def load_track(time = @time)

data/lib/badline/drive1541/serial_port.rb

@@ -44,6 +44,16 @@ module Badline
         @host = @bus ? @bus.host_lines : 0
       end
 
+      # The C64's lines as last latched. The jumpers and the bus are the
+      # drive's wiring.
+      def save_state(out)
+        out.int(@host)
+      end
+
+      def load_state(input)
+        @host = input.int
+      end
+
       # Whether the C64 has moved ATN since the last latch_host.
       def atn_moved?
         lines = @bus ? @bus.host_lines : 0

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"
@@ -180,6 +181,40 @@ module Badline
       step
     end
 
+    # The drive's whole state: its clock phase, the CPU, RAM, both VIAs,
+    # the serial port's latch of the C64's lines and the mechanism with its
+    # disk. The drive settles first, so it is awake and not recording a
+    # pass, and a restored drive starts the same way, its orbits forgotten
+    # from the state it takes: Idle's and Orbit's bookkeeping
+    # isn't stored. The device number, the host's clock rate and whether
+    # the drive may sleep are the machine's wiring.
+    def save_state(out)
+      settle!
+      out.marker("DRIVE1541")
+      out.int(@phase).int(@cycles).boolean(@so_pending)
+      @serial_port.save_state(out)
+      @via1.save_state(out)
+      @via2.save_state(out)
+      @bus.save_state(out)
+      @cpu.save_state(out)
+      @mechanism.save_state(out)
+    end
+
+    def load_state(input)
+      settle!
+      input.marker("DRIVE1541")
+      @phase = input.int
+      @cycles = input.int
+      @so_pending = input.boolean?
+      @serial_port.load_state(input)
+      @via1.load_state(input)
+      @via2.load_state(input)
+      @bus.load_state(input)
+      @cpu.load_state(input)
+      @mechanism.load_state(input)
+      forget_orbits
+    end
+
     def inspect
       "#<#{self.class.name} cycles=#{cycles} cpu=(#{cpu.inspect})>"
     end

data/lib/badline/ffi.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Badline
+  # The part of Spinel's FFI DSL the SDL binding uses, for CRuby, over
+  # Fiddle, so the one binding in badline/sdl serves both builds. Spinel
+  # compiles the declarations itself and never loads this file: require it
+  # before a file that declares a binding.
+  #
+  # The declarations behave as they do in Spinel. ffi_func defines
+  # Module.name(...); a pointer argument takes nil for NULL, a Fiddle
+  # pointer, a String (its bytes) or an IO::Buffer, whose contents C sees
+  # for the call's duration; a NULL pointer comes back as nil. ffi_const
+  # sets Module::NAME, ffi_buffer defines Module.name returning a zeroed
+  # static buffer, and ffi_read_<width> and ffi_write_<width> define field
+  # accessors at a fixed offset into a pointer.
+  module FFI
+    class Error < StandardError; end
+
+    TYPES = {
+      void: Fiddle::TYPE_VOID,
+      int: Fiddle::TYPE_INT, bool: Fiddle::TYPE_INT, long: Fiddle::TYPE_LONG, size_t: Fiddle::TYPE_SIZE_T,
+      int8: Fiddle::TYPE_INT8_T, uint8: Fiddle::TYPE_UINT8_T, int16: Fiddle::TYPE_INT16_T,
+      uint16: Fiddle::TYPE_UINT16_T, int32: Fiddle::TYPE_INT32_T, uint32: Fiddle::TYPE_UINT32_T,
+      float: Fiddle::TYPE_FLOAT, double: Fiddle::TYPE_DOUBLE,
+      str: Fiddle::TYPE_CONST_STRING,
+      ptr: Fiddle::TYPE_VOIDP, buffer_in: Fiddle::TYPE_VOIDP, buffer_out: Fiddle::TYPE_VOIDP,
+      buffer_inout: Fiddle::TYPE_VOIDP, int_array: Fiddle::TYPE_VOIDP, float_array: Fiddle::TYPE_VOIDP
+    }.freeze
+
+    # The argument specs C may write through, so an IO::Buffer passed in one
+    # gets back what C left in it.
+    WRITABLE = %i[ptr buffer_out buffer_inout].freeze
+
+    # pack directives for the accessor widths, in the host's byte order.
+    WIDTHS = {
+      u8: "C", i8: "c", u16: "S", i16: "s", u32: "L", i32: "l", u64: "Q", i64: "q", ptr: "J"
+    }.freeze
+
+    # Where dlopen looks for a library besides its search path, which leaves
+    # out Homebrew's, and the versioned names a runtime package installs
+    # without the development package's unversioned link.
+    DIRECTORIES = [nil, "/opt/homebrew/lib", "/usr/local/lib"].freeze
+    VERSIONED = { "SDL2" => %w[libSDL2-2.0.so.0 libSDL2-2.0.0.dylib] }.freeze
+
+    module_function
+
+    def open_library(name)
+      candidates = library_candidates(name)
+      candidates.each do |candidate|
+        return Fiddle.dlopen(candidate)
+      rescue Fiddle::DLError
+        next
+      end
+      raise Error, "can't find lib#{name} (tried #{candidates.join(', ')})"
+    end
+
+    def library_candidates(name)
+      names = ["lib#{name}.dylib", "lib#{name}.so", *VERSIONED.fetch(name, []), "#{name}.dll"]
+      DIRECTORIES.flat_map { |dir| names.map { |file| dir ? File.join(dir, file) : file } }
+    end
+
+    # The value Fiddle passes for one argument, and a block that copies what
+    # C wrote back into an IO::Buffer once the call returns.
+    def argument(spec, value)
+      case value
+      when IO::Buffer then buffer_argument(spec, value)
+      when Array then [value.pack(spec == :float_array ? "d*" : "q*")]
+      when true, false then [value ? 1 : 0]
+      else [value]
+      end
+    end
+
+    def buffer_argument(spec, buffer)
+      return [nil] if buffer.null? || buffer.empty?
+
+      bytes = buffer.get_string
+      return [bytes] unless WRITABLE.include?(spec) && !buffer.readonly?
+
+      [bytes, -> { buffer.set_string(bytes) }]
+    end
+
+    def result(spec, value)
+      case spec
+      when :ptr then value.null? ? nil : value
+      when :bool then value != 0
+      else value
+      end
+    end
+
+    def read(pointer, offset, width)
+      value = Fiddle::Pointer[pointer][offset, width_size(width)].unpack1(WIDTHS.fetch(width))
+      width == :ptr ? result(:ptr, Fiddle::Pointer.new(value)) : value
+    end
+
+    def write(pointer, offset, width, value)
+      value = value.to_i if width == :ptr
+      Fiddle::Pointer[pointer][offset, width_size(width)] = [value || 0].pack(WIDTHS.fetch(width))
+      value
+    end
+
+    def width_size(width) = [0].pack(WIDTHS.fetch(width)).bytesize
+
+    # The declarations, private methods of every module once this file is
+    # loaded, as they are keywords of a module body in Spinel.
+    module DSL
+      private
+
+      def ffi_lib(name)
+        (@ffi_libraries ||= []) << FFI.open_library(name)
+      end
+
+      def ffi_func(name, arguments, returns, blocking: false)
+        function = Fiddle::Function.new(ffi_symbol(name), arguments.map { |spec| TYPES.fetch(spec) },
+                                        TYPES.fetch(returns), name: name.to_s, need_gvl: !blocking)
+        define_singleton_method(name) do |*values|
+          converted = arguments.zip(values).map { |spec, value| FFI.argument(spec, value) }
+          returned = function.call(*converted.map(&:first))
+          converted.each { |argument| argument[1]&.call }
+          FFI.result(returns, returned)
+        end
+      end
+
+      def ffi_const(name, value)
+        const_set(name, value)
+      end
+
+      def ffi_buffer(name, size)
+        buffer = Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE)
+        buffer[0, size] = "\0" * size
+        define_singleton_method(name) { buffer }
+      end
+
+      WIDTHS.each_key do |width|
+        define_method(:"ffi_read_#{width}") do |name, offset|
+          define_singleton_method(name) { |pointer| FFI.read(pointer, offset, width) }
+        end
+
+        define_method(:"ffi_write_#{width}") do |name, offset|
+          define_singleton_method(name) { |pointer, value| FFI.write(pointer, offset, width, value) }
+        end
+      end
+
+      def ffi_symbol(name)
+        (@ffi_libraries || []).each do |library|
+          return library[name.to_s]
+        rescue Fiddle::DLError
+          next
+        end
+        Fiddle::Handle::DEFAULT[name.to_s]
+      end
+    end
+  end
+end
+
+Module.include(Badline::FFI::DSL)

data/lib/badline/frontend/app.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # Opens the window, then runs the machine a frame at a time: poll
+    # events, clock the frame's cycles, queue the SID's samples, upload the
+    # changed lines, present and wait. Pacer decides the cycles and the wait.
+    class App
+      SCALE = 2
+      TITLE = "Badline"
+      STAGES = %w[events emulate audio blit present wait].freeze
+
+      # Takes the frame limit, the pacing, the snapshot path, the sound and
+      # the verbosity from Options, and runs the timeline's events.
+      def initialize(computer, options, timeline)
+        @computer = computer
+        @frame_limit = options.frames
+        @verbose = options.verbose?
+        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, region: computer.region)
+        @timeline = timeline
+        @snapshots = Snapshots.new(computer, options)
+        @screen = Screen.new(computer.vic)
+        @led = DriveLed.for(computer)
+        @controls = Controls.new(computer)
+        @spent = Array.new(STAGES.size, 0.0)
+        @slowest = 0.0
+        open_window
+        @sound = Sound.new(computer.sid, options.sound?, @verbose)
+        @gamepads = Gamepads.new(computer, @verbose)
+      end
+
+      def run
+        @frames = 0
+        @running = true
+        @started = @reported = now
+        @pacer.start(@started)
+        @reported_samples = 0
+        frame while @running
+        @snapshots.finish
+        @computer.drive1541&.flush
+        @gamepads.close
+        @sound.close
+        close_window
+      end
+
+      private
+
+      def frame
+        stamps = [now]
+        handle_events
+        @gamepads.poll
+        stamps << now
+        emulate
+        stamps << now
+        @sound.feed
+        stamps << now
+        upload
+        stamps << now
+        draw
+        stamps << now
+        @pacer.wait(@sound)
+        stamps << now
+        finish_frame(stamps)
+      end
+
+      def finish_frame(stamps)
+        STAGES.size.times { |stage| @spent[stage] += stamps[stage + 1] - stamps[stage] }
+        took = stamps[-2] - stamps.first
+        @slowest = took if took > @slowest
+        @frames += 1
+        @timeline.run(@computer, @frames)
+        @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
+        @pacer.check(Pacer::EARLY_CHECK, stamps.last - @started, stamps.last) if @frames == Pacer::EARLY_CHECK
+        report(stamps.last) if (@frames % 50).zero?
+      end
+
+      def open_window
+        abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
+
+        SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
+        SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
+        @window = SDL.SDL_CreateWindow(
+          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
+          Screen::WIDTH * SCALE, Screen::HEIGHT * SCALE, SDL::WINDOW_RESIZABLE
+        )
+        flags = SDL::RENDERER_ACCELERATED
+        flags |= SDL::RENDERER_PRESENTVSYNC if @pacer.vsync?
+        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
+        fit_display if @pacer.vsync?
+        SDL.SDL_RenderSetLogicalSize(@renderer, Screen::WIDTH, Screen::HEIGHT)
+        create_texture
+      end
+
+      def create_texture
+        @texture = SDL.SDL_CreateTexture(
+          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, Screen::WIDTH, Screen::HEIGHT
+        )
+        SDL.rect_w(SDL.rect, Screen::WIDTH)
+        SDL.rect_h(SDL.rect, Screen::HEIGHT)
+      end
+
+      def close_window
+        SDL.SDL_DestroyTexture(@texture)
+        SDL.SDL_DestroyRenderer(@renderer)
+        SDL.SDL_DestroyWindow(@window)
+        SDL.SDL_Quit
+      end
+
+      def handle_events
+        handle_event(SDL.event_type(SDL.event)) while SDL.SDL_PollEvent(SDL.event) != 0
+      end
+
+      def handle_event(type)
+        case type
+        when SDL::QUIT
+          @running = false
+        when SDL::KEYDOWN, SDL::KEYUP
+          handle_key(SDL.event_scancode(SDL.event), type == SDL::KEYDOWN) if SDL.event_repeat(SDL.event).zero?
+        when SDL::MOUSEMOTION
+          @controls.mouse_motion(SDL.event_xrel(SDL.event), SDL.event_yrel(SDL.event))
+        when SDL::MOUSEBUTTONDOWN, SDL::MOUSEBUTTONUP
+          @controls.mouse_button(SDL.event_button(SDL.event), type == SDL::MOUSEBUTTONDOWN)
+        when SDL::CONTROLLERDEVICEADDED, SDL::CONTROLLERDEVICEREMOVED
+          @gamepads.rescan
+        end
+      end
+
+      def handle_key(scancode, down)
+        if [Keys::TAB, Keys::F9, Keys::F10].include?(scancode)
+          handle_toggle(scancode) if down
+        elsif down && @snapshots.key(scancode)
+          swap(@snapshots.computer)
+        elsif !Snapshots::KEYS.include?(scancode)
+          @controls.key(scancode, down)
+        end
+      end
+
+      # Runs the restored machine in place of the one before: the screen,
+      # the drive LED, the controls, the gamepads and the sound go over to
+      # it.
+      def swap(computer)
+        @computer = computer
+        @screen = Screen.new(computer.vic)
+        @led = DriveLed.for(computer)
+        @controls.computer = computer
+        @gamepads.computer = computer
+        @sound.sid = computer.sid
+      end
+
+      def handle_toggle(scancode)
+        if scancode == Keys::TAB
+          @controls.cycle_mode(SDL.event_mod(SDL.event).anybits?(SDL::KMOD_SHIFT) ? -1 : 1)
+          SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
+        elsif scancode == Keys::F9
+          @controls.swap_ports
+        else
+          @sound.toggle_mute
+        end
+        update_title
+      end
+
+      def update_title
+        title = TITLE
+        title += " [#{@controls.tag}]" unless @controls.tag.empty?
+        title += " [MUTED]" if @sound.muted?
+        SDL.SDL_SetWindowTitle(@window, title)
+      end
+
+      def fit_display
+        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
+        @pacer.fit(SDL.mode_refresh(SDL.display_mode))
+      end
+
+      def emulate
+        computer = @computer
+        cycles = @pacer.cycles(@sound)
+        i = 0
+        while i < cycles
+          computer.cycle!
+          i += 1
+        end
+      end
+
+      def upload
+        @screen.update
+        SDL.SDL_UpdateTexture(@texture, SDL.rect, @screen.pixels, Screen::ROW_BYTES)
+      end
+
+      def draw
+        SDL.SDL_RenderClear(@renderer)
+        SDL.SDL_RenderCopy(@renderer, @texture, SDL.rect, SDL.rect)
+        @led&.draw(@renderer)
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(@renderer, path) }
+        SDL.SDL_RenderPresent(@renderer)
+      end
+
+      def report(at)
+        @pacer.check(50, at - @reported, at)
+        @pacer.measure(50, at - @reported)
+        report_frames(at) if @verbose
+        @spent = Array.new(STAGES.size, 0.0)
+        @slowest = 0.0
+        @reported = at
+      end
+
+      def report_frames(at)
+        fps = 50 / (at - @reported)
+        stages = STAGES.each_with_index.map { |name, stage| "#{name} #{(@spent[stage] * 20).round(2)}" }
+        puts "#{fps.round(1)} fps, per frame ms: #{stages.join(' ')}, slowest work #{(@slowest * 1000).round(2)}"
+        report_sound(at) if @sound.on?
+      end
+
+      def report_sound(at)
+        sound = @sound
+        rate = (sound.queued - @reported_samples) / (at - @reported)
+        queue = sound.high.zero? ? "empty" : "#{(sound.low * 1000).round(1)}-#{(sound.high * 1000).round(1)} ms"
+        puts "  sound #{rate.round} samples/s, queue #{queue}, #{sound.underruns} underruns, #{sound.dropped} dropped"
+        sound.reset_levels
+        @reported_samples = sound.queued
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/badline/frontend/audio_sink.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The host's audio device for --headless, fed through SDL's queue: mono
+    # signed 16-bit samples go in at the device's rate and SDL plays them
+    # out behind us. It answers what Audio::Playback asks of a sink.
+    class AudioSink
+      class Error < Audio::Playback::DeviceError; end
+
+      attr_reader :rate
+
+      # With `exact_rate` false SDL may pick the device's own rate instead,
+      # which #rate then reports.
+      def initialize(rate:, exact_rate: false, buffer: 1024)
+        @device = 0
+        @rate = rate
+        @buffer = IO::Buffer.new(4096)
+        check(SDL.SDL_InitSubSystem(SDL::INIT_AUDIO))
+        open_device(rate, exact_rate ? 0 : SDL::ALLOW_FREQUENCY_CHANGE, buffer)
+      end
+
+      def queue(samples)
+        count = samples.size
+        bytes = count * 2
+        @buffer.resize(bytes) if bytes > @buffer.size
+        buffer = @buffer
+        i = 0
+        while i < count
+          buffer.set_value(:s16, i * 2, samples[i])
+          i += 1
+        end
+        check(SDL.SDL_QueueAudio(@device, buffer, bytes))
+      end
+
+      def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
+
+      def start = SDL.SDL_PauseAudioDevice(@device, 0)
+
+      def pause = SDL.SDL_PauseAudioDevice(@device, 1)
+
+      def clear = SDL.SDL_ClearQueuedAudio(@device)
+
+      def close
+        return if @device.zero?
+
+        SDL.SDL_CloseAudioDevice(@device)
+        SDL.SDL_QuitSubSystem(SDL::INIT_AUDIO)
+        @device = 0
+      end
+
+      private
+
+      def open_device(rate, allowed_changes, buffer)
+        SDL.spec_freq(SDL.wanted, rate)
+        SDL.spec_format(SDL.wanted, SDL::AUDIO_S16LSB)
+        SDL.spec_channels(SDL.wanted, 1)
+        SDL.spec_samples(SDL.wanted, buffer)
+        @device = SDL.SDL_OpenAudioDevice(nil, 0, SDL.wanted, SDL.obtained, allowed_changes)
+        raise Error, SDL.SDL_GetError if @device.zero?
+
+        @rate = SDL.read_i32(SDL.obtained)
+      end
+
+      def check(result)
+        raise Error, SDL.SDL_GetError if result.negative?
+
+        result
+      end
+    end
+  end
+end