audio 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f7750670a7a9f4d0554765012808dbe2f6477c9
-  data.tar.gz: a9e49107f1c2d316f416ecacc9a0f4ede1df1e66
+  metadata.gz: f3cab4fbb003f03b5a3803b5c7df3b59cebc5d23
+  data.tar.gz: b9be9609b5ba0bae0f4bc73d45e535a343ad253a
 SHA512:
-  metadata.gz: 8a813230ad12d52963266b54ab57dfef88728af3fc6b6883bc19a1c71b783e9fcae205b2f06dfcecb2f06869e91185dfb2c47c2defbdec07d286b61c2a8ab414
-  data.tar.gz: a6dbf92c29fbce40913e41e099f549b9f314e1c7bed5f50eeaf73f2d79a73a41cf847b94e870c609cc0bc71bb2029d7cddbf21d081d43e9e100a7e148902c6bb
+  metadata.gz: 1a79f5be46891faa3ac670afcc4f151f5c8deb57bac77dd3a6a1041dc6c1efb5084c941a4ffac0037215cb9f9590e84be9b75949b0162a715a14c7e26d831e5d
+  data.tar.gz: 7341e4f79c1f4bdddcb8cfd9ee30c2ee56cd620d68e89e97f953f08549b6872546a98ad3a6ab19c57f48900ef5d2e9bc903f8f3ecf7dec5f1bad9f25d25e63c9

data/README.md

@@ -40,6 +40,15 @@ Device Name: Built-in Output
 Device Name: Blue Snowball
 ```
 
+### Using the default Audio Devices
+
+If you just want to use a default device, Audio has you covered.
+
+```ruby
+Audio.default_input     # => Device Name: Built-in Microphone
+Audio.default_output    # => Device Name: Built-in Output
+```
+
 ### Recording Audio
 
 You can record audio from a particular device by calling its `start` method.
@@ -48,8 +57,7 @@ called. If you provide a block parameter to `start`, it will be called whenever
 the host OS provides a new buffer of audio samples.
 
 ```ruby
-device = Audio.devices.last     # Hopefully that's an input device
-device.start do |*args|
+Audio.default_input.start do |*args|
     # Do something fancy
 end
 

data/audio.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
     spec.name          = "audio"
-    spec.version       = '0.1'
+    spec.version       = '0.2'
     spec.authors       = ["Brandon Fosdick"]
     spec.email         = ["bfoz@bfoz.net"]
     spec.summary       = %q{Cross-platform Audio Device Input and Output}

data/lib/audio.rb

@@ -1,4 +1,5 @@
-require_relative 'core_audio'
+require_relative 'macos/core_audio'
+require_relative 'macos/audio_toolbox'
 
 module Audio
     # @return [Array<Device>]  the list of available audio devices

data/lib/macos/audio_toolbox.rb

@@ -0,0 +1,55 @@
+require 'ffi'
+
+require_relative 'audio_toolbox/audio_converter'
+require_relative 'core_foundation'
+require_relative 'core_audio/audio_stream'
+
+module AudioToolbox
+    extend FFI::Library
+    ffi_lib '/System/Library/Frameworks/AudioToolbox.framework/AudioToolbox'
+
+    OSStatus = CoreFoundation::OSStatus
+    AudioStreamBasicDescription = CoreAudio::AudioStreamBasicDescription
+
+    typedef :pointer, :AudioConverterRef
+
+    # OSStatus (*AudioConverterComplexInputDataProc)(AudioConverterRef               inAudioConverter,
+    #						     UInt32*                         ioNumberDataPackets,
+    #						     AudioBufferList*                ioData,
+    #						     AudioStreamPacketDescription**  outDataPacketDescription,
+    #						     void*                           inUserData)
+    callback :AudioConverterComplexInputDataProc, [:AudioConverterRef, :pointer, :pointer, :pointer, :pointer], OSStatus
+
+    # OSStatus AudioConverterNew(const AudioStreamBasicDescription*  inSourceFormat,
+    #				 const AudioStreamBasicDescription*  inDestinationFormat,
+    #				 AudioConverterRef*                  outAudioConverter)
+    attach_function :AudioConverterNew, [AudioStreamBasicDescription.by_ref, AudioStreamBasicDescription.by_ref, :pointer], OSStatus
+
+    # OSStatus AudioConverterFillComplexBuffer(AudioConverterRef                   inAudioConverter,
+    #					       AudioConverterComplexInputDataProc  inInputDataProc,
+    #					       void*                               inInputDataProcUserData,
+    #					       UInt32*                             ioOutputDataPacketSize,
+    #					       AudioBufferList*                    outOutputData,
+    #					       AudioStreamPacketDescription*       outPacketDescription)
+    attach_function :AudioConverterFillComplexBuffer, [:AudioConverterRef, :AudioConverterComplexInputDataProc, :pointer, :pointer, :pointer, :pointer], OSStatus
+
+    # OSStatus AudioConverterSetProperty(AudioConverterRef           inAudioConverter,
+    #					 AudioConverterPropertyID    inPropertyID,
+    #					 UInt32                      inPropertyDataSize,
+    #					 const void*                 inPropertyData)
+    attach_function :AudioConverterSetProperty, [:AudioConverterRef, :uint32, :uint32, :pointer], OSStatus
+
+    # Create a new {AudioConverter} that convertes between the given stream formats
+    # @param from   [AudioStreamBasicDescription]   the stream format to convert from
+    # @param to	    [AudioStreamBasicDescription]   the stream format to convert to
+    # @return [AudioConverterRef]
+    def self.converter(from, to)
+	reference = FFI::MemoryPointer.new(AudioConverterRef)
+	status = AudioToolbox.AudioConverterNew(from, to, reference)
+	raise "No converter '#{[status].pack('L').reverse}'" unless status.zero?
+	AudioConverterRef.new(reference.get_pointer(0)).tap do |converter|
+	    converter.from = from
+	    converter.to = to
+	end
+    end
+end

data/lib/macos/audio_toolbox/audio_converter.rb

@@ -0,0 +1,55 @@
+module AudioToolbox
+    class AudioConverterRef < FFI::Pointer
+	attr_accessor :from
+	attr_accessor :to
+
+	# @group AudioConverter.h
+	PrimeMethod                          = 'prmm'
+	# @endgroup
+
+	# @param buffer	[AudioBufferList]   the list of buffers to be converted
+	# @return [AudioBufferList] the converted data
+	def convert(buffer)
+	    num_from_packets = (buffer.bytesize / from[:mBytesPerPacket]).floor
+	    remaining_packets = num_from_packets
+
+	    block = Proc.new do |_, num_packets, buffer_list, _|
+		unless remaining_packets.zero?
+		    buffer_list = CoreAudio::AudioBufferList.new(buffer_list)
+		    buffer_list.buffers.first[:mData] = buffer.buffers.first[:mData]
+		    buffer_list.buffers.first[:mDataByteSize] = buffer.buffers.first[:mDataByteSize]
+		end
+
+		# Report the number of packets actually sent
+		num_packets.put_uint32(0, remaining_packets)
+
+		remaining_packets = 0   # No more packets remaining
+
+		0   # All is well
+	    end
+
+	    bytes_per_packet = to[:mBytesPerPacket]
+	    num_output_packets = (num_from_packets * to.sample_rate / from.sample_rate).floor
+
+	    output_list = CoreAudio::AudioBufferList.buffer_list(size:bytes_per_packet * num_output_packets)
+	    raise("No buffer list") unless output_list
+
+	    num_packets = FFI::MemoryPointer.new(:uint32).put_uint32(0, num_output_packets)
+	    status = AudioToolbox.AudioConverterFillComplexBuffer(self, block, nil, num_packets, output_list, nil)
+	    raise("Convert failed: '#{[status].pack('L').reverse}'") unless status.zero?
+
+	    output_list
+	end
+
+	# @param method	[Symbol]    :pre, :normal, or :none
+	def prime_method=(method=:normal)
+	    method = case method
+		when :pre	then 0
+		when :normal	then 1
+		when :none	then 2
+	    end
+	    data = FFI::MemoryPointer.new(:uint32).put_uint32(0, method)
+	    AudioToolbox.AudioConverterSetProperty(self, PrimeMethod.reverse.unpack('L').first, 4, data)
+	end
+    end
+end

data/lib/{core_audio.rb → macos/core_audio.rb}

@@ -1,34 +1,18 @@
 require 'ffi'
 
+require_relative 'core_audio/audio_types'
+
 module CoreAudio
     extend FFI::Library
     ffi_lib '/System/Library/Frameworks/CoreAudio.framework/CoreAudio'
 
     typedef :uint32, :OSStatus
-
-    # @group CoreAudioTypes.h
-    class AudioBuffer < FFI::Struct
-	layout :mNumberChannels, :uint32,
-	       :mDataByteSize, :uint32,
-	       :mData, :pointer
-
-	# @return [String]  the raw bytes
-	def bytes
-	    self[:mData].get_bytes(0, self[:mDataByteSize])
-	end
-    end
-
-    class AudioBufferList < FFI::Struct
-	layout :mNumberBuffers, :uint32,
-	       :mBuffers, AudioBuffer
-    end
-    # @endgroup
 end
 
 require_relative 'core_audio/audio_device'
 
 module CoreAudio
-    # AudioHardware.h
+    # @group AudioHardware.h
     # OSStatus AudioObjectGetPropertyDataSize(AudioObjectID			inObjectID,
     #					      const AudioObjectPropertyAddress* inAddress,
     #					      UInt32                            inQualifierDataSize,
@@ -44,6 +28,15 @@ module CoreAudio
     #					  void*                             outData)
     attach_function :AudioObjectGetPropertyData, [AudioObject::ObjectID, AudioObject::PropertyAddress.by_ref, :uint32, :pointer, :pointer, :pointer], :OSStatus
 
+    # OSStatus AudioObjectSetPropertyData(AudioObjectID                       inObjectID,
+    #					  const AudioObjectPropertyAddress*   inAddress,
+    #					  UInt32                              inQualifierDataSize,
+    #					  const void*                         inQualifierData,
+    #					  UInt32                              inDataSize,
+    #					  const void*                         inData)
+    attach_function :AudioObjectSetPropertyData, [AudioObject::ObjectID, AudioObject::PropertyAddress.by_ref, :uint32, :pointer, :uint32, :pointer], :OSStatus
+    # @endgroup
+
     # @return [Array<AudioObject>]  the list of available audio devices
     def self.devices
 	address = AudioObject::PropertyAddress.global_master(AudioHardware::PropertyDevices)
@@ -51,4 +44,18 @@ module CoreAudio
 	device_IDs = buffer.get_array_of_int32(0, buffer.size/4)
 	device_IDs.map {|id| AudioDevice.new(id)}
     end
+
+    # @return [AudioDevice] the default input device
+    def self.default_input
+	address = AudioObject::PropertyAddress.global_master(AudioHardware::PropertyDefaultInputDevice)
+	buffer = AudioObject.system.get_property(address)
+	AudioDevice.new(buffer.get_uint32(0))
+    end
+
+    # @return [AudioDevice] the default output device
+    def self.default_output
+	address = AudioObject::PropertyAddress.global_master(AudioHardware::PropertyDefaultOutputDevice)
+	buffer = AudioObject.system.get_property(address)
+	AudioDevice.new(buffer.get_uint32(0))
+    end
 end

data/lib/{core_audio → macos/core_audio}/audio_device.rb

@@ -35,8 +35,35 @@ module CoreAudio
 
     # @endgroup
 
+    # Split the constants so that AudioStream can see 'PropertyLatency'
     class AudioDevice < AudioObject
+	# @group AudioHardwareBase.h: AudioDevice Properties
+	PropertyConfigurationApplication        = 'capp'
+	PropertyDeviceUID                       = 'uid '
+	PropertyModelUID                        = 'muid'
+	PropertyTransportType                   = 'tran'
+	PropertyRelatedDevices                  = 'akin'
+	PropertyClockDomain                     = 'clkd'
+	PropertyDeviceIsAlive                   = 'livn'
+	PropertyDeviceIsRunning                 = 'goin'
+	PropertyDeviceCanBeDefaultDevice        = 'dflt'
+	PropertyDeviceCanBeDefaultSystemDevice  = 'sflt'
+	PropertyLatency                         = 'ltnc'
+	PropertyStreams                         = 'stm#'
+	PropertyControlList                     = 'ctrl'
+	PropertySafetyOffset                    = 'saft'
+	PropertyNominalSampleRate               = 'nsrt'
+	PropertyAvailableNominalSampleRates     = 'nsr#'
+	PropertyIcon                            = 'icon'
+	PropertyIsHidden                        = 'hidn'
+	PropertyPreferredChannelsForStereo      = 'dch2'
+	PropertyPreferredChannelLayout          = 'srnd'
+	# @endgroup
+    end
 
+    require_relative 'audio_stream'
+
+    class AudioDevice
 	# @group AudioHardware.h: AudioDevice Properties
 	PropertyPlugIn                          = 'plug'
 	PropertyDeviceHasChanged                = 'diff'
@@ -54,20 +81,63 @@ module CoreAudio
 	# @endgroup
 
 	# @group Properties
-	def actual_sample_rate
-	    address = PropertyAddress.global_master(PropertyActualSampleRate)
-	    get_property(address).get_float64(0)
-	end
 
 	def buffer_frame_size
 	    address = PropertyAddress.global_master(PropertyBufferFrameSize)
 	    get_property(address).get_uint32(0)
 	end
 
+	# @return [Bool]    true if the device is running
+	def running?
+	    address = PropertyAddress.global_master(PropertyDeviceIsRunning)
+	    0 != get_property(address).get_uint32(0)
+	end
+
 	def running_somewhere?
 	    address = PropertyAddress.global_master(PropertyDeviceIsRunningSomewhere)
 	    0 != get_property(address).get_uint32(0)
 	end
+
+	# @return [Array<AudioStream>]	an array of {AudioStream}s, one for each stream provided by the device
+	def streams
+	    address = PropertyAddress.global_master(PropertyStreams)
+	    buffer = get_property(address)
+	    buffer.get_array_of_uint32(0, buffer.size/FFI::Type::UINT32.size).map {|stream_id| AudioStream.new(stream_id)}
+	end
+
+	# @group Sample Rate
+
+	# @return [Float]   the measured sample rate in Hertz
+	def actual_sample_rate
+	    address = PropertyAddress.global_master(PropertyActualSampleRate)
+	    get_property(address).get_float64(0)
+	end
+
+	# @return [Array<Number,Range>]	the available sampling rates, or sample-rate-ranges
+	def available_sample_rates
+	    address = PropertyAddress.global_master(PropertyAvailableNominalSampleRates)
+	    buffer = get_property(address)
+	    buffer = buffer.get_array_of_float64(0, buffer.size / FFI::Type::DOUBLE.size)
+
+	    # Convert the range pairs into actual Ranges, unless the Range is empty
+	    buffer.each_slice(2).map {|a,b| (a==b) ? a : (a..b)}
+	end
+
+	# @return [Float]   the device's nominal sample rate
+	def sample_rate
+	    address = PropertyAddress.global_master(PropertyNominalSampleRate)
+	    get_property(address).get_float64(0)
+	end
+
+	# @param rate [Float]	the new sample rate in Hertz
+	def sample_rate=(rate)
+	    address = PropertyAddress.global_master(PropertyNominalSampleRate)
+	    ffi_rate = FFI::MemoryPointer.new(:double)
+	    ffi_rate.put_float64(0, rate)
+	    status = set_property(address, ffi_rate)
+	    raise "status #{status} => '#{[status].pack('L').reverse}'" unless 0 == status
+	end
+	# @endgroup
 	# @endgroup
 
 	# Start the AudioDevice

data/lib/{core_audio → macos/core_audio}/audio_object.rb

@@ -51,21 +51,6 @@ module CoreAudio
 	PropertyUserSessionIsActiveOrHeadless       = 'user'
 	PropertyServiceRestarted                    = 'srst'
 	PropertyPowerHint                           = 'powh'
-
-	# AudioHardware.h: AudioDevice Properties
-	AudioDevicePropertyPlugIn                          = 'plug'
-	AudioDevicePropertyDeviceHasChanged                = 'diff'
-	AudioDevicePropertyDeviceIsRunningSomewhere        = 'gone'
-	AudioDeviceProcessorOverload                       = 'over'
-	AudioDevicePropertyIOStoppedAbnormally             = 'stpd'
-	AudioDevicePropertyHogMode                         = 'oink'
-	AudioDevicePropertyBufferFrameSize                 = 'fsiz'
-	AudioDevicePropertyBufferFrameSizeRange            = 'fsz#'
-	AudioDevicePropertyUsesVariableBufferFrameSizes    = 'vfsz'
-	AudioDevicePropertyIOCycleUsage                    = 'ncyc'
-	AudioDevicePropertyStreamConfiguration             = 'slay'
-	AudioDevicePropertyIOProcStreamUsage               = 'suse'
-	AudioDevicePropertyActualSampleRate                = 'asrt'
     end
 
     class AudioObject
@@ -123,6 +108,11 @@ module CoreAudio
 	    buffer
 	end
 
+	def set_property(address, buffer, qualifier=nil)
+	    qualifier_size = qualifier.size rescue 0
+	    CoreAudio.AudioObjectSetPropertyData(id, address, 0, nil, buffer.size, buffer)
+	end
+
 	# @group Convenience Attributes
 	def external?
 	    not internal?

data/lib/macos/core_audio/audio_stream.rb

@@ -0,0 +1,95 @@
+module CoreAudio
+    class AudioStreamBasicDescription < FFI::Struct
+	# @group CoreAudioTypes.h
+	FormatFlagIsFloat	    = (1 << 0)
+	FormatFlagIsSignedInteger   = (1 << 2)
+	# @endgroup
+
+	layout	:mSampleRate, :double,
+		:mFormatID, :uint32,
+		:mFormatFlags, :uint32,
+		:mBytesPerPacket, :uint32,
+		:mFramesPerPacket, :uint32,
+		:mBytesPerFrame, :uint32,
+		:mChannelsPerFrame, :uint32,
+		:mBitsPerChannel, :uint32,
+		:mReserved, :uint32
+
+	# @!attribute channels
+	#   @return [Integer]  the number of channels per frame
+	def channels
+	    self[:mChannelsPerFrame]
+	end
+
+	# @param number	[Integer]   the number of channels per frame
+	def channels=(number)
+	    self[:mChannelsPerFrame] = number.to_i
+	end
+
+	# @!attribute channel_width
+	#   @return [Integer]  the number of bits per channel
+	def channel_width=(bits)
+	    self[:mBitsPerChannel] = bits
+	    self[:mBytesPerFrame] = self[:mChannelsPerFrame] * bits / 8
+	    self[:mBytesPerPacket] = self[:mBytesPerFrame] * self[:mFramesPerPacket]
+	end
+
+	# @!attribute float?
+	#   @return [Bool]  true if the stream samples are {Float}
+	def float?
+	    (self[:mFormatFlags] & FormatFlagIsFloat) != 0
+	end
+
+	def integer
+	    self[:mFormatFlags] &= ~FormatFlagIsFloat
+	    self[:mFormatFlags] |= FormatFlagIsSignedInteger
+	end
+
+	# @!attribute sample_rate
+	#   @return [Float]  the number of sample frames per second
+	def sample_rate;    self[:mSampleRate];	end
+	def sample_rate=(rate)
+	    self[:mSampleRate] = rate
+	end
+    end
+
+    class AudioValueRange < FFI::Struct
+	layout	:minimum, :double,
+		:maximum, :double
+    end
+
+    class AudioStreamRangedDescription < FFI::Struct
+	layout	:mFormat, AudioStreamBasicDescription,
+		:mSampleRateRange, AudioValueRange
+    end
+
+    class AudioStream < AudioObject
+	PropertyIsActive                    = 'sact',
+	PropertyDirection                   = 'sdir',
+	PropertyTerminalType                = 'term',
+	PropertyStartingChannel             = 'schn',
+	PropertyLatency                     = CoreAudio::AudioDevice::PropertyLatency,
+	PropertyVirtualFormat               = 'sfmt',
+	PropertyAvailableVirtualFormats     = 'sfma',
+	PropertyPhysicalFormat              = 'pft ',
+	PropertyAvailablePhysicalFormats    = 'pfta'
+
+	def virtual_format
+	    address = PropertyAddress.global_master(PropertyVirtualFormat)
+	    buffer = get_property(address)
+	    AudioStreamBasicDescription.new(buffer)
+	end
+
+	def virtual_formats
+	    address = PropertyAddress.global_master(PropertyAvailableVirtualFormats)
+	    buffer = get_property(address)
+	    count = buffer.size/AudioStreamRangedDescription.size
+	    output = []
+	    count.times do |i|
+		output << AudioStreamRangedDescription.new(buffer)
+		buffer += AudioStreamRangedDescription.size
+	    end
+	    output
+	end
+    end
+end

data/lib/macos/core_audio/audio_types.rb

@@ -0,0 +1,73 @@
+module CoreAudio
+    class AudioBuffer < FFI::Struct
+	layout :mNumberChannels, :uint32,
+	       :mDataByteSize, :uint32,
+	       :mData, :pointer
+
+	# @return [String]  the raw bytes
+	def bytes
+	    self[:mData].get_bytes(0, self[:mDataByteSize])
+	end
+
+	def bytesize
+	    self[:mDataByteSize]
+	end
+
+	# @return [Array<Integer>]  an array of samples, converted to signed integers
+	def samples_int(bytes_per_channel)
+	    self[:mData].get_array_of_int16(0, self[:mDataByteSize]/bytes_per_channel)
+	end
+
+	# @return [Array<Float>]    an array of samples, converted to {Float}
+	def samples_float(bytes_per_channel)
+	    self[:mData].get_array_of_float32(0, self[:mDataByteSize]/bytes_per_channel)
+	end
+    end
+
+    class AudioBufferList < FFI::Struct
+	layout :mNumberBuffers, :uint32,
+	       :mBuffers, AudioBuffer
+
+	def self.buffer_list(channels:1, size:nil)
+	    self.new.tap do |list|
+		list[:mNumberBuffers] = 1
+		list[:mBuffers][:mNumberChannels] = channels
+
+		if( size )
+		    list[:mBuffers][:mData] = FFI::MemoryPointer.new(size)
+		    list[:mBuffers][:mDataByteSize] = size
+		else
+		    list[:mBuffers][:mDataByteSize] = 0
+		end
+	    end
+	end
+
+	# @return [Array]   the buffers
+	def buffers
+	    raise("Can't handle multiple buffers yet") if self[:mNumberBuffers] > 1
+	    [self[:mBuffers]]
+	end
+
+	# @return [String]  the raw bytes
+	def bytes
+	    buffers.map(&:bytes).join
+	end
+
+	# @return [Number]  the total number of bytes in the buffer list
+	def bytesize
+	    buffers.map(&:bytesize).reduce(&:+)
+	end
+
+	# Retrieve the samples as an {Array}, after converting to the requested type
+	# @param type		    [Symbol]    :float or :int. Convert the samples to the given type.
+	# @param bytes_per_channel  [Number]	the number of bytes for each sample
+	# @return [Array<Float,Integer>]	an array of samples, converted to {Float} or {Integer}
+	def samples(type, bytes_per_channel)
+	    if type == :float
+		buffers.map {|buffer| buffer.samples_float(bytes_per_channel)}.flatten
+	    else
+		buffers.map {|buffer| buffer.samples_int(bytes_per_channel)}.flatten
+	    end
+	end
+    end
+end

data/lib/{core_foundation.rb → macos/core_foundation.rb}

@@ -6,6 +6,8 @@ module CoreFoundation
 
     typedef :pointer, :CFStringRef
 
+    OSStatus = typedef :uint32, :OSStatus
+
     if FFI::Platform::ARCH == 'x86_64'
 	CFIndex = FFI::Type::LONG_LONG
     else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: audio
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Brandon Fosdick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-23 00:00:00.000000000 Z
+date: 2015-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -51,10 +51,14 @@ files:
 - Rakefile
 - audio.gemspec
 - lib/audio.rb
-- lib/core_audio.rb
-- lib/core_audio/audio_device.rb
-- lib/core_audio/audio_object.rb
-- lib/core_foundation.rb
+- lib/macos/audio_toolbox.rb
+- lib/macos/audio_toolbox/audio_converter.rb
+- lib/macos/core_audio.rb
+- lib/macos/core_audio/audio_device.rb
+- lib/macos/core_audio/audio_object.rb
+- lib/macos/core_audio/audio_stream.rb
+- lib/macos/core_audio/audio_types.rb
+- lib/macos/core_foundation.rb
 homepage: http://github.com/bfoz/audio-ruby
 licenses:
 - BSD