portaudio 0.1.0

data/examples/sine_wave_blocking.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "portaudio"
+
+frequency = 440.0
+phase = 0.0
+duration_seconds = 2.0
+
+PortAudio.with_portaudio do
+  output = PortAudio::Device.default_output
+  unless output
+    warn "No default output device available"
+    next
+  end
+
+  sample_rate = output.default_sample_rate
+  frames = 256
+  remaining_frames = (sample_rate * duration_seconds).round
+
+  stream = PortAudio::BlockingStream.new(
+    output: { device: output.index, channels: 1, format: :float32 },
+    sample_rate: sample_rate,
+    frames_per_buffer: frames
+  )
+
+  begin
+    stream.start
+
+    while remaining_frames.positive?
+      frame_count = [remaining_frames, frames].min
+      chunk = Array.new(frame_count) do
+        value = Math.sin(phase * 2.0 * Math::PI)
+        phase += frequency / sample_rate
+        phase -= 1.0 if phase >= 1.0
+        value
+      end
+
+      stream.write(chunk, frame_count)
+      remaining_frames -= frame_count
+    end
+  ensure
+    stream.stop if stream.active?
+    stream.close unless stream.closed?
+  end
+end

data/lib/portaudio/blocking_stream.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module PortAudio
+  class BlockingStream
+    attr_reader :sample_rate,
+                :frames_per_buffer,
+                :input_channels,
+                :output_channels,
+                :input_format,
+                :output_format,
+                :last_warning
+
+    def initialize(
+      input: nil,
+      output: nil,
+      sample_rate:,
+      frames_per_buffer: 1024,
+      flags: C::Constants::PA_NO_FLAG
+    )
+      @stream_ptr = FFI::MemoryPointer.new(:pointer)
+      @input_channels = Integer(input&.fetch(:channels, 1) || 0)
+      @output_channels = Integer(output&.fetch(:channels, 1) || 0)
+      @input_format = input&.fetch(:format, :float32)
+      @output_format = output&.fetch(:format, :float32)
+      @sample_rate = Float(sample_rate)
+      @frames_per_buffer = Integer(frames_per_buffer)
+
+      code = C::Functions.Pa_OpenStream(
+        @stream_ptr,
+        pointer_or_null(StreamParametersBuilder.build(input)),
+        pointer_or_null(StreamParametersBuilder.build(output)),
+        @sample_rate,
+        @frames_per_buffer,
+        Integer(flags),
+        nil,
+        FFI::Pointer::NULL
+      )
+      PortAudio.check_error!(code)
+
+      @handle = @stream_ptr.read_pointer
+      @last_warning = nil
+    end
+
+    def start
+      PortAudio.check_error!(C::Functions.Pa_StartStream(handle))
+    end
+
+    def stop
+      PortAudio.check_error!(C::Functions.Pa_StopStream(handle))
+    end
+
+    def abort
+      PortAudio.check_error!(C::Functions.Pa_AbortStream(handle))
+    end
+
+    def close
+      return if closed?
+
+      PortAudio.check_error!(C::Functions.Pa_CloseStream(handle))
+      @handle = nil
+    end
+
+    def closed?
+      @handle.nil?
+    end
+
+    def active?
+      return false if closed?
+
+      C::Functions.Pa_IsStreamActive(handle) == 1
+    end
+
+    def stopped?
+      return true if closed?
+
+      C::Functions.Pa_IsStreamStopped(handle) == 1
+    end
+
+    def read(frames = @frames_per_buffer, strict: Configuration.strict_warnings)
+      ensure_input_stream!
+
+      frame_count = Integer(frames)
+      sample_size = StreamParametersBuilder.sample_size_for(@input_format)
+      byte_size = frame_count * @input_channels * sample_size
+      buffer = FFI::MemoryPointer.new(:char, byte_size)
+
+      code = C::Functions.Pa_ReadStream(handle, buffer, frame_count)
+      handle_stream_result(code, strict: strict)
+      buffer.read_bytes(byte_size)
+    end
+
+    def write(data, frames = nil, strict: Configuration.strict_warnings)
+      ensure_output_stream!
+
+      payload = coerce_output_data(data)
+      sample_size = StreamParametersBuilder.sample_size_for(@output_format)
+      frame_count = frames || (payload.bytesize / (@output_channels * sample_size))
+      pointer = FFI::MemoryPointer.new(:char, payload.bytesize)
+      pointer.put_bytes(0, payload)
+
+      code = C::Functions.Pa_WriteStream(handle, pointer, Integer(frame_count))
+      handle_stream_result(code, strict: strict)
+      frame_count
+    end
+
+    def read_available
+      C::Functions.Pa_GetStreamReadAvailable(handle)
+    end
+
+    def write_available
+      C::Functions.Pa_GetStreamWriteAvailable(handle)
+    end
+
+    def each_frame(frames = @frames_per_buffer, strict: Configuration.strict_warnings)
+      return enum_for(:each_frame, frames, strict: strict) unless block_given?
+
+      loop do
+        yield read(frames, strict: strict)
+      end
+    end
+
+    private
+
+    def pointer_or_null(stream_parameters)
+      return FFI::Pointer::NULL if stream_parameters.nil?
+
+      stream_parameters.pointer
+    end
+
+    def coerce_output_data(data)
+      return pack_array_data(data) if data.is_a?(Array)
+      return data if data.is_a?(String)
+
+      raise ArgumentError, "write data must be String or Array"
+    end
+
+    def pack_array_data(array)
+      case StreamParametersBuilder.resolve_sample_format(@output_format)
+      when C::Constants::PA_FLOAT32
+        array.pack("e*")
+      when C::Constants::PA_INT16
+        array.map { |value| (Float(value) * 32_767).round.clamp(-32_768, 32_767) }.pack("s<*")
+      when C::Constants::PA_INT32
+        array.map { |value| (Float(value) * 2_147_483_647).round.clamp(-2_147_483_648, 2_147_483_647) }.pack("l<*")
+      when C::Constants::PA_INT8
+        array.map { |value| (Float(value) * 127).round.clamp(-128, 127) }.pack("c*")
+      when C::Constants::PA_UINT8
+        array.map { |value| (Float(value) * 255).round.clamp(0, 255) }.pack("C*")
+      else
+        raise ArgumentError, "Array write is unsupported for format #{@output_format.inspect}"
+      end
+    end
+
+    def handle_stream_result(code, strict:)
+      @last_warning = nil
+
+      return code if code >= 0
+      return PortAudio.check_error!(code) if strict || !Error.warning_code?(code)
+
+      @last_warning = code
+      code
+    end
+
+    def ensure_input_stream!
+      return if @input_channels.positive?
+
+      raise CannotReadFromOutputOnlyStreamError, "input stream is not configured"
+    end
+
+    def ensure_output_stream!
+      return if @output_channels.positive?
+
+      raise CannotWriteToInputOnlyStreamError, "output stream is not configured"
+    end
+
+    def handle
+      raise StreamStoppedError, "stream is closed" if @handle.nil?
+
+      @handle
+    end
+  end
+end

data/lib/portaudio/buffer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module PortAudio
+  class Buffer
+    attr_reader :frames, :channels, :format
+
+    def initialize(frames:, channels:, format: :float32)
+      @frames = Integer(frames)
+      @channels = Integer(channels)
+      @format = format
+      @sample_format = StreamParametersBuilder.resolve_sample_format(format)
+      @sample_size = StreamParametersBuilder.sample_size_for(@sample_format)
+      @data = FFI::MemoryPointer.new(:char, bytesize)
+    end
+
+    def pointer
+      @data
+    end
+
+    def bytesize
+      @frames * @channels * @sample_size
+    end
+
+    def to_float_array
+      total_samples = @frames * @channels
+
+      case @sample_format
+      when C::Constants::PA_FLOAT32
+        @data.read_array_of_float(total_samples)
+      when C::Constants::PA_INT16
+        @data.read_array_of_int16(total_samples).map { |sample| sample / 32_768.0 }
+      when C::Constants::PA_INT32
+        @data.read_array_of_int32(total_samples).map { |sample| sample / 2_147_483_648.0 }
+      else
+        raise ArgumentError, "Unsupported format for to_float_array: #{@format.inspect}"
+      end
+    end
+
+    def write_floats(floats)
+      case @sample_format
+      when C::Constants::PA_FLOAT32
+        @data.write_array_of_float(floats.map(&:to_f))
+      when C::Constants::PA_INT16
+        int_samples = floats.map { |sample| (sample.to_f * 32_767).round.clamp(-32_768, 32_767) }
+        @data.write_array_of_int16(int_samples)
+      when C::Constants::PA_INT32
+        int_samples = floats.map { |sample| (sample.to_f * 2_147_483_647).round.clamp(-2_147_483_648, 2_147_483_647) }
+        @data.write_array_of_int32(int_samples)
+      else
+        raise ArgumentError, "Unsupported format for write_floats: #{@format.inspect}"
+      end
+
+      self
+    end
+
+    def clear
+      @data.put_bytes(0, "\x00" * bytesize)
+      self
+    end
+  end
+end

data/lib/portaudio/c/constants.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PortAudio
+  module C
+    module Constants
+      PA_NO_DEVICE = -1
+      PA_USE_HOST_API_SPECIFIC_DEVICE_SPECIFICATION = -2
+
+      PA_FLOAT32 = 0x00000001
+      PA_INT32 = 0x00000002
+      PA_INT24 = 0x00000004
+      PA_INT16 = 0x00000008
+      PA_INT8 = 0x00000010
+      PA_UINT8 = 0x00000020
+      PA_CUSTOM_FORMAT = 0x00010000
+      PA_NON_INTERLEAVED = 0x80000000
+
+      PA_NO_FLAG = 0
+      PA_CLIP_OFF = 0x00000001
+      PA_DITHER_OFF = 0x00000002
+      PA_NEVER_DROP_INPUT = 0x00000004
+      PA_PRIME_OUTPUT_BUFFERS_USING_STREAM_CALLBACK = 0x00000008
+      PA_PLATFORM_SPECIFIC_FLAGS = 0xFFFF0000
+
+      PA_INPUT_UNDERFLOW = 0x00000001
+      PA_INPUT_OVERFLOW = 0x00000002
+      PA_OUTPUT_UNDERFLOW = 0x00000004
+      PA_OUTPUT_OVERFLOW = 0x00000008
+      PA_PRIMING_OUTPUT = 0x00000010
+
+      PA_FORMAT_IS_SUPPORTED = 0
+      PA_FRAMES_PER_BUFFER_UNSPECIFIED = 0
+
+      SAMPLE_SIZE = {
+        PA_FLOAT32 => 4,
+        PA_INT32 => 4,
+        PA_INT24 => 3,
+        PA_INT16 => 2,
+        PA_INT8 => 1,
+        PA_UINT8 => 1
+      }.freeze
+
+      SYMBOL_TO_SAMPLE_FORMAT = {
+        float32: PA_FLOAT32,
+        int32: PA_INT32,
+        int24: PA_INT24,
+        int16: PA_INT16,
+        int8: PA_INT8,
+        uint8: PA_UINT8
+      }.freeze
+    end
+  end
+end

data/lib/portaudio/c/enums.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module PortAudio
+  module C
+    module Enums
+      extend FFI::Library
+
+      PA_ERROR_CODE_VALUES = [
+        :paNoError, 0,
+        :paNotInitialized, -10000,
+        :paUnanticipatedHostError, -9999,
+        :paInvalidChannelCount, -9998,
+        :paInvalidSampleRate, -9997,
+        :paInvalidDevice, -9996,
+        :paInvalidFlag, -9995,
+        :paSampleFormatNotSupported, -9994,
+        :paBadIODeviceCombination, -9993,
+        :paInsufficientMemory, -9992,
+        :paBufferTooBig, -9991,
+        :paBufferTooSmall, -9990,
+        :paNullCallback, -9989,
+        :paBadStreamPtr, -9988,
+        :paTimedOut, -9987,
+        :paInternalError, -9986,
+        :paDeviceUnavailable, -9985,
+        :paIncompatibleHostApiSpecificStreamInfo, -9984,
+        :paStreamIsStopped, -9983,
+        :paStreamIsNotStopped, -9982,
+        :paInputOverflowed, -9981,
+        :paOutputUnderflowed, -9980,
+        :paHostApiNotFound, -9979,
+        :paInvalidHostApi, -9978,
+        :paCanNotReadFromACallbackStream, -9977,
+        :paCanNotWriteToACallbackStream, -9976,
+        :paCanNotReadFromAnOutputOnlyStream, -9975,
+        :paCanNotWriteToAnInputOnlyStream, -9974,
+        :paIncompatibleStreamHostApi, -9973,
+        :paBadBufferPtr, -9972,
+        :paCanNotInitializeRecursively, -9971
+      ].freeze
+
+      PA_HOST_API_TYPE_VALUES = [
+        :paInDevelopment, 0,
+        :paDirectSound, 1,
+        :paMME, 2,
+        :paASIO, 3,
+        :paSoundManager, 4,
+        :paCoreAudio, 5,
+        :paOSS, 7,
+        :paALSA, 8,
+        :paAL, 9,
+        :paBeOS, 10,
+        :paWDMKS, 11,
+        :paJACK, 12,
+        :paWASAPI, 13,
+        :paAudioScienceHPI, 14,
+        :paAudioIO, 15,
+        :paPulseAudio, 16,
+        :paSndio, 17
+      ].freeze
+
+      PA_STREAM_CALLBACK_RESULT_VALUES = [
+        :paContinue, 0,
+        :paComplete, 1,
+        :paAbort, 2
+      ].freeze
+
+      PaErrorCode = enum(:pa_error_code, PA_ERROR_CODE_VALUES)
+      PaHostApiTypeId = enum(:pa_host_api_type_id, PA_HOST_API_TYPE_VALUES)
+      PaStreamCallbackResult = enum(:pa_stream_callback_result, PA_STREAM_CALLBACK_RESULT_VALUES)
+
+      ERROR_CODE_SYMBOL_TO_CODE = PA_ERROR_CODE_VALUES.each_slice(2).to_h.freeze
+      ERROR_CODE_CODE_TO_SYMBOL = ERROR_CODE_SYMBOL_TO_CODE.invert.freeze
+
+      HOST_API_TYPE_SYMBOL_TO_CODE = PA_HOST_API_TYPE_VALUES.each_slice(2).to_h.freeze
+      HOST_API_TYPE_CODE_TO_SYMBOL = HOST_API_TYPE_SYMBOL_TO_CODE.invert.freeze
+
+      STREAM_CALLBACK_RESULT_SYMBOL_TO_CODE = PA_STREAM_CALLBACK_RESULT_VALUES.each_slice(2).to_h.freeze
+      STREAM_CALLBACK_RESULT_CODE_TO_SYMBOL = STREAM_CALLBACK_RESULT_SYMBOL_TO_CODE.invert.freeze
+    end
+  end
+end

data/lib/portaudio/c/functions.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module PortAudio
+  module C
+    module Functions
+      extend FFI::Library
+      extend PortAudio::C::BindingHelpers
+
+      PaStreamCallback = callback(
+        :pa_stream_callback,
+        %i[pointer pointer ulong pointer ulong pointer],
+        :int
+      )
+
+      PaStreamFinishedCallback = callback(
+        :pa_stream_finished_callback,
+        [:pointer],
+        :void
+      )
+
+      SIGNATURES = [
+        { c_name: :Pa_GetVersion, args: [], returns: :int },
+        { c_name: :Pa_GetVersionText, args: [], returns: :string },
+        { c_name: :Pa_GetVersionInfo, args: [], returns: :pointer },
+
+        { c_name: :Pa_Initialize, args: [], returns: :int },
+        { c_name: :Pa_Terminate, args: [], returns: :int },
+
+        { c_name: :Pa_GetHostApiCount, args: [], returns: :int },
+        { c_name: :Pa_GetDefaultHostApi, args: [], returns: :int },
+        { c_name: :Pa_GetHostApiInfo, args: [:int], returns: :pointer },
+        { c_name: :Pa_HostApiTypeIdToHostApiIndex, args: [:int], returns: :int },
+        { c_name: :Pa_HostApiDeviceIndexToDeviceIndex, args: %i[int int], returns: :int },
+
+        { c_name: :Pa_GetErrorText, args: [:int], returns: :string },
+        { c_name: :Pa_GetLastHostErrorInfo, args: [], returns: :pointer },
+
+        { c_name: :Pa_GetDeviceCount, args: [], returns: :int },
+        { c_name: :Pa_GetDefaultInputDevice, args: [], returns: :int },
+        { c_name: :Pa_GetDefaultOutputDevice, args: [], returns: :int },
+        { c_name: :Pa_GetDeviceInfo, args: [:int], returns: :pointer },
+
+        { c_name: :Pa_IsFormatSupported, args: %i[pointer pointer double], returns: :int },
+        {
+          c_name: :Pa_OpenStream,
+          args: %i[pointer pointer pointer double ulong ulong pa_stream_callback pointer],
+          returns: :int
+        },
+        {
+          c_name: :Pa_OpenDefaultStream,
+          args: %i[pointer int int ulong double ulong pa_stream_callback pointer],
+          returns: :int
+        },
+        { c_name: :Pa_CloseStream, args: [:pointer], returns: :int },
+        {
+          c_name: :Pa_SetStreamFinishedCallback,
+          args: %i[pointer pa_stream_finished_callback],
+          returns: :int
+        },
+        { c_name: :Pa_StartStream, args: [:pointer], returns: :int },
+        { c_name: :Pa_StopStream, args: [:pointer], returns: :int },
+        { c_name: :Pa_AbortStream, args: [:pointer], returns: :int },
+        { c_name: :Pa_IsStreamStopped, args: [:pointer], returns: :int },
+        { c_name: :Pa_IsStreamActive, args: [:pointer], returns: :int },
+        { c_name: :Pa_GetStreamInfo, args: [:pointer], returns: :pointer },
+        { c_name: :Pa_GetStreamTime, args: [:pointer], returns: :double },
+        { c_name: :Pa_GetStreamCpuLoad, args: [:pointer], returns: :double },
+
+        {
+          c_name: :Pa_ReadStream,
+          args: %i[pointer pointer ulong],
+          returns: :int,
+          options: { blocking: true }
+        },
+        {
+          c_name: :Pa_WriteStream,
+          args: %i[pointer pointer ulong],
+          returns: :int,
+          options: { blocking: true }
+        },
+        { c_name: :Pa_GetStreamReadAvailable, args: [:pointer], returns: :long },
+        { c_name: :Pa_GetStreamWriteAvailable, args: [:pointer], returns: :long },
+
+        { c_name: :Pa_GetSampleSize, args: [:ulong], returns: :int },
+        { c_name: :Pa_Sleep, args: [:long], returns: :void }
+      ].freeze
+
+      define_lazy_functions(SIGNATURES)
+    end
+  end
+end

data/lib/portaudio/c/host_api/alsa.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "rbconfig"
+
+module PortAudio
+  module C
+    module HostAPI
+      module ALSA
+        extend FFI::Library
+        extend PortAudio::C::BindingHelpers
+
+        SUPPORTED = /linux/i.match?(RbConfig::CONFIG["host_os"])
+
+        class PaAlsaStreamInfo < FFI::Struct
+          layout :size, :ulong,
+                 :hostApiType, :int,
+                 :version, :ulong,
+                 :deviceString, :string
+        end
+
+        SIGNATURES = [
+          { c_name: :PaAlsa_InitializeStreamInfo, args: [:pointer], returns: :void },
+          { c_name: :PaAlsa_EnableRealtimeScheduling, args: %i[pointer int], returns: :void },
+          { c_name: :PaAlsa_GetStreamInputCard, args: %i[pointer pointer], returns: :int },
+          { c_name: :PaAlsa_GetStreamOutputCard, args: %i[pointer pointer], returns: :int },
+          { c_name: :PaAlsa_SetNumPeriods, args: [:int], returns: :void },
+          { c_name: :PaAlsa_SetRetriesBusy, args: [:int], returns: :void },
+          { c_name: :PaAlsa_SetLibraryPathName, args: [:string], returns: :void }
+        ].freeze
+
+        if SUPPORTED
+          define_lazy_functions(SIGNATURES)
+        else
+          define_unsupported_functions(SIGNATURES, "ALSA extension is available only on Linux")
+        end
+      end
+    end
+  end
+end

data/lib/portaudio/c/host_api/asio.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "rbconfig"
+
+module PortAudio
+  module C
+    module HostAPI
+      module ASIO
+        extend FFI::Library
+        extend PortAudio::C::BindingHelpers
+
+        SUPPORTED = /mingw|mswin/i.match?(RbConfig::CONFIG["host_os"])
+
+        PA_ASIO_USE_CHANNEL_SELECTORS = 0x01
+
+        class PaAsioStreamInfo < FFI::Struct
+          layout :size, :ulong,
+                 :hostApiType, :int,
+                 :version, :ulong,
+                 :flags, :ulong,
+                 :channelSelectors, :pointer
+        end
+
+        SIGNATURES = [
+          {
+            c_name: :PaAsio_GetAvailableBufferSizes,
+            args: %i[int pointer pointer pointer pointer],
+            returns: :int
+          },
+          {
+            c_name: :PaAsio_GetAvailableBufferSizes,
+            ruby_name: :PaAsio_GetAvailableLatencyValues,
+            args: %i[int pointer pointer pointer pointer],
+            returns: :int
+          },
+          { c_name: :PaAsio_ShowControlPanel, args: %i[int pointer], returns: :int },
+          { c_name: :PaAsio_GetInputChannelName, args: %i[int int pointer], returns: :int },
+          { c_name: :PaAsio_GetOutputChannelName, args: %i[int int pointer], returns: :int },
+          { c_name: :PaAsio_SetStreamSampleRate, args: %i[pointer double], returns: :int }
+        ].freeze
+
+        if SUPPORTED
+          define_lazy_functions(SIGNATURES)
+        else
+          define_unsupported_functions(SIGNATURES, "ASIO extension is available only on Windows")
+        end
+      end
+    end
+  end
+end

data/lib/portaudio/c/host_api/core_audio.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "rbconfig"
+
+module PortAudio
+  module C
+    module HostAPI
+      module CoreAudio
+        extend FFI::Library
+        extend PortAudio::C::BindingHelpers
+
+        SUPPORTED = /darwin/i.match?(RbConfig::CONFIG["host_os"])
+
+        PA_MAC_CORE_CHANGE_DEVICE_PARAMETERS = 0x01
+        PA_MAC_CORE_FAIL_IF_CONVERSION_REQUIRED = 0x02
+        PA_MAC_CORE_CONVERSION_QUALITY_MIN = 0x0100
+        PA_MAC_CORE_CONVERSION_QUALITY_MEDIUM = 0x0200
+        PA_MAC_CORE_CONVERSION_QUALITY_LOW = 0x0300
+        PA_MAC_CORE_CONVERSION_QUALITY_HIGH = 0x0400
+        PA_MAC_CORE_CONVERSION_QUALITY_MAX = 0x0000
+        PA_MAC_CORE_PLAY_NICE = 0x00
+        PA_MAC_CORE_PRO = 0x01
+        PA_MAC_CORE_MINIMIZE_CPU_BUT_PLAY_NICE = 0x0100
+        PA_MAC_CORE_MINIMIZE_CPU = 0x0101
+
+        class PaMacCoreStreamInfo < FFI::Struct
+          layout :size, :ulong,
+                 :hostApiType, :int,
+                 :version, :ulong,
+                 :flags, :ulong,
+                 :channelMap, :pointer,
+                 :channelMapSize, :ulong
+        end
+
+        SIGNATURES = [
+          { c_name: :PaMacCore_SetupStreamInfo, args: %i[pointer ulong], returns: :void },
+          { c_name: :PaMacCore_SetupChannelMap, args: %i[pointer pointer ulong], returns: :void },
+          { c_name: :PaMacCore_GetBufferSizeRange, args: %i[int pointer pointer], returns: :int },
+          { c_name: :PaMacCore_GetStreamInputDevice, args: [:pointer], returns: :uint },
+          { c_name: :PaMacCore_GetStreamOutputDevice, args: [:pointer], returns: :uint },
+          { c_name: :PaMacCore_GetChannelName, args: %i[int int int], returns: :string },
+          { c_name: :PaMacCore_GetOSWorkgroup, args: %i[int pointer], returns: :int }
+        ].freeze
+
+        if SUPPORTED
+          define_lazy_functions(SIGNATURES)
+        else
+          define_unsupported_functions(SIGNATURES, "CoreAudio extension is available only on macOS")
+        end
+      end
+    end
+  end
+end

data/lib/portaudio/c/host_api/direct_sound.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "rbconfig"
+
+module PortAudio
+  module C
+    module HostAPI
+      module DirectSound
+        SUPPORTED = /mingw|mswin/i.match?(RbConfig::CONFIG["host_os"])
+
+        PA_WIN_DIRECT_SOUND_USE_LOW_LEVEL_LATENCY_PARAMETERS = 0x01
+        PA_WIN_DIRECT_SOUND_USE_CHANNEL_MASK = 0x04
+
+        class PaWinDirectSoundStreamInfo < FFI::Struct
+          layout :size, :ulong,
+                 :hostApiType, :int,
+                 :version, :ulong,
+                 :flags, :ulong,
+                 :framesPerBuffer, :ulong,
+                 :channelMask, :ulong
+        end
+      end
+    end
+  end
+end