Alc/backends/coreaudio.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "backends/coreaudio.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "alMain.h"
  30 #include "alu.h"
  31 #include "ringbuffer.h"
  32
  33 #include <unistd.h>
  34 #include <AudioUnit/AudioUnit.h>
  35 #include <AudioToolbox/AudioToolbox.h>
  36
  37
  38 static const ALCchar ca_device[] = "CoreAudio Default";
  39
  40
  41 struct ALCcoreAudioPlayback final : public ALCbackend {
  42     AudioUnit AudioUnit;
  43
  44     ALuint FrameSize;
  45     AudioStreamBasicDescription Format;    // This is the OpenAL format as a CoreAudio ASBD
  46 };
  47
  48 static void ALCcoreAudioPlayback_Construct(ALCcoreAudioPlayback *self, ALCdevice *device);
  49 static void ALCcoreAudioPlayback_Destruct(ALCcoreAudioPlayback *self);
  50 static ALCenum ALCcoreAudioPlayback_open(ALCcoreAudioPlayback *self, const ALCchar *name);
  51 static ALCboolean ALCcoreAudioPlayback_reset(ALCcoreAudioPlayback *self);
  52 static ALCboolean ALCcoreAudioPlayback_start(ALCcoreAudioPlayback *self);
  53 static void ALCcoreAudioPlayback_stop(ALCcoreAudioPlayback *self);
  54 static DECLARE_FORWARD2(ALCcoreAudioPlayback, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
  55 static DECLARE_FORWARD(ALCcoreAudioPlayback, ALCbackend, ALCuint, availableSamples)
  56 static DECLARE_FORWARD(ALCcoreAudioPlayback, ALCbackend, ClockLatency, getClockLatency)
  57 static DECLARE_FORWARD(ALCcoreAudioPlayback, ALCbackend, void, lock)
  58 static DECLARE_FORWARD(ALCcoreAudioPlayback, ALCbackend, void, unlock)
  59 DECLARE_DEFAULT_ALLOCATORS(ALCcoreAudioPlayback)
  60
  61 DEFINE_ALCBACKEND_VTABLE(ALCcoreAudioPlayback);
  62
  63
  64 static void ALCcoreAudioPlayback_Construct(ALCcoreAudioPlayback *self, ALCdevice *device)
  65 {
  66     new (self) ALCcoreAudioPlayback{};
  67     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
  68     SET_VTABLE2(ALCcoreAudioPlayback, ALCbackend, self);
  69
  70     self->FrameSize = 0;
  71     memset(&self->Format, 0, sizeof(self->Format));
  72 }
  73
  74 static void ALCcoreAudioPlayback_Destruct(ALCcoreAudioPlayback *self)
  75 {
  76     AudioUnitUninitialize(self->AudioUnit);
  77     AudioComponentInstanceDispose(self->AudioUnit);
  78
  79     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
  80     self->~ALCcoreAudioPlayback();
  81 }
  82
  83
  84 static OSStatus ALCcoreAudioPlayback_MixerProc(void *inRefCon,
  85   AudioUnitRenderActionFlags* UNUSED(ioActionFlags), const AudioTimeStamp* UNUSED(inTimeStamp),
  86   UInt32 UNUSED(inBusNumber), UInt32 UNUSED(inNumberFrames), AudioBufferList *ioData)
  87 {
  88     ALCcoreAudioPlayback *self = static_cast<ALCcoreAudioPlayback*>(inRefCon);
  89     ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
  90
  91     ALCcoreAudioPlayback_lock(self);
  92     aluMixData(device, ioData->mBuffers[0].mData,
  93                ioData->mBuffers[0].mDataByteSize / self->FrameSize);
  94     ALCcoreAudioPlayback_unlock(self);
  95
  96     return noErr;
  97 }
  98
  99
 100 static ALCenum ALCcoreAudioPlayback_open(ALCcoreAudioPlayback *self, const ALCchar *name)
 101 {
 102     ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
 103     AudioComponentDescription desc;
 104     AudioComponent comp;
 105     OSStatus err;
 106
 107     if(!name)
 108         name = ca_device;
 109     else if(strcmp(name, ca_device) != 0)
 110         return ALC_INVALID_VALUE;
 111
 112     /* open the default output unit */
 113     desc.componentType = kAudioUnitType_Output;
 114 #if TARGET_OS_IOS
 115     desc.componentSubType = kAudioUnitSubType_RemoteIO;
 116 #else
 117     desc.componentSubType = kAudioUnitSubType_DefaultOutput;
 118 #endif
 119     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 120     desc.componentFlags = 0;
 121     desc.componentFlagsMask = 0;
 122
 123     comp = AudioComponentFindNext(NULL, &desc);
 124     if(comp == NULL)
 125     {
 126         ERR("AudioComponentFindNext failed\n");
 127         return ALC_INVALID_VALUE;
 128     }
 129
 130     err = AudioComponentInstanceNew(comp, &self->AudioUnit);
 131     if(err != noErr)
 132     {
 133         ERR("AudioComponentInstanceNew failed\n");
 134         return ALC_INVALID_VALUE;
 135     }
 136
 137     /* init and start the default audio unit... */
 138     err = AudioUnitInitialize(self->AudioUnit);
 139     if(err != noErr)
 140     {
 141         ERR("AudioUnitInitialize failed\n");
 142         AudioComponentInstanceDispose(self->AudioUnit);
 143         return ALC_INVALID_VALUE;
 144     }
 145
 146     device->DeviceName = name;
 147     return ALC_NO_ERROR;
 148 }
 149
 150 static ALCboolean ALCcoreAudioPlayback_reset(ALCcoreAudioPlayback *self)
 151 {
 152     ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
 153     AudioStreamBasicDescription streamFormat;
 154     AURenderCallbackStruct input;
 155     OSStatus err;
 156     UInt32 size;
 157
 158     err = AudioUnitUninitialize(self->AudioUnit);
 159     if(err != noErr)
 160         ERR("-- AudioUnitUninitialize failed.\n");
 161
 162     /* retrieve default output unit's properties (output side) */
 163     size = sizeof(AudioStreamBasicDescription);
 164     err = AudioUnitGetProperty(self->AudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &streamFormat, &size);
 165     if(err != noErr || size != sizeof(AudioStreamBasicDescription))
 166     {
 167         ERR("AudioUnitGetProperty failed\n");
 168         return ALC_FALSE;
 169     }
 170
 171 #if 0
 172     TRACE("Output streamFormat of default output unit -\n");
 173     TRACE("  streamFormat.mFramesPerPacket = %d\n", streamFormat.mFramesPerPacket);
 174     TRACE("  streamFormat.mChannelsPerFrame = %d\n", streamFormat.mChannelsPerFrame);
 175     TRACE("  streamFormat.mBitsPerChannel = %d\n", streamFormat.mBitsPerChannel);
 176     TRACE("  streamFormat.mBytesPerPacket = %d\n", streamFormat.mBytesPerPacket);
 177     TRACE("  streamFormat.mBytesPerFrame = %d\n", streamFormat.mBytesPerFrame);
 178     TRACE("  streamFormat.mSampleRate = %5.0f\n", streamFormat.mSampleRate);
 179 #endif
 180
 181     /* set default output unit's input side to match output side */
 182     err = AudioUnitSetProperty(self->AudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, size);
 183     if(err != noErr)
 184     {
 185         ERR("AudioUnitSetProperty failed\n");
 186         return ALC_FALSE;
 187     }
 188
 189     if(device->Frequency != streamFormat.mSampleRate)
 190     {
 191         device->NumUpdates = (ALuint)((ALuint64)device->NumUpdates *
 192                                       streamFormat.mSampleRate /
 193                                       device->Frequency);
 194         device->Frequency = streamFormat.mSampleRate;
 195     }
 196
 197     /* FIXME: How to tell what channels are what in the output device, and how
 198      * to specify what we're giving?  eg, 6.0 vs 5.1 */
 199     switch(streamFormat.mChannelsPerFrame)
 200     {
 201         case 1:
 202             device->FmtChans = DevFmtMono;
 203             break;
 204         case 2:
 205             device->FmtChans = DevFmtStereo;
 206             break;
 207         case 4:
 208             device->FmtChans = DevFmtQuad;
 209             break;
 210         case 6:
 211             device->FmtChans = DevFmtX51;
 212             break;
 213         case 7:
 214             device->FmtChans = DevFmtX61;
 215             break;
 216         case 8:
 217             device->FmtChans = DevFmtX71;
 218             break;
 219         default:
 220             ERR("Unhandled channel count (%d), using Stereo\n", streamFormat.mChannelsPerFrame);
 221             device->FmtChans = DevFmtStereo;
 222             streamFormat.mChannelsPerFrame = 2;
 223             break;
 224     }
 225     SetDefaultWFXChannelOrder(device);
 226
 227     /* use channel count and sample rate from the default output unit's current
 228      * parameters, but reset everything else */
 229     streamFormat.mFramesPerPacket = 1;
 230     streamFormat.mFormatFlags = 0;
 231     switch(device->FmtType)
 232     {
 233         case DevFmtUByte:
 234             device->FmtType = DevFmtByte;
 235             /* fall-through */
 236         case DevFmtByte:
 237             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
 238             streamFormat.mBitsPerChannel = 8;
 239             break;
 240         case DevFmtUShort:
 241             device->FmtType = DevFmtShort;
 242             /* fall-through */
 243         case DevFmtShort:
 244             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
 245             streamFormat.mBitsPerChannel = 16;
 246             break;
 247         case DevFmtUInt:
 248             device->FmtType = DevFmtInt;
 249             /* fall-through */
 250         case DevFmtInt:
 251             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
 252             streamFormat.mBitsPerChannel = 32;
 253             break;
 254         case DevFmtFloat:
 255             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsFloat;
 256             streamFormat.mBitsPerChannel = 32;
 257             break;
 258     }
 259     streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame *
 260                                   streamFormat.mBitsPerChannel / 8;
 261     streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame;
 262     streamFormat.mFormatID = kAudioFormatLinearPCM;
 263     streamFormat.mFormatFlags |= kAudioFormatFlagsNativeEndian |
 264                                  kLinearPCMFormatFlagIsPacked;
 265
 266     err = AudioUnitSetProperty(self->AudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, sizeof(AudioStreamBasicDescription));
 267     if(err != noErr)
 268     {
 269         ERR("AudioUnitSetProperty failed\n");
 270         return ALC_FALSE;
 271     }
 272
 273     /* setup callback */
 274     self->FrameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->mAmbiOrder);
 275     input.inputProc = ALCcoreAudioPlayback_MixerProc;
 276     input.inputProcRefCon = self;
 277
 278     err = AudioUnitSetProperty(self->AudioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(AURenderCallbackStruct));
 279     if(err != noErr)
 280     {
 281         ERR("AudioUnitSetProperty failed\n");
 282         return ALC_FALSE;
 283     }
 284
 285     /* init the default audio unit... */
 286     err = AudioUnitInitialize(self->AudioUnit);
 287     if(err != noErr)
 288     {
 289         ERR("AudioUnitInitialize failed\n");
 290         return ALC_FALSE;
 291     }
 292
 293     return ALC_TRUE;
 294 }
 295
 296 static ALCboolean ALCcoreAudioPlayback_start(ALCcoreAudioPlayback *self)
 297 {
 298     OSStatus err = AudioOutputUnitStart(self->AudioUnit);
 299     if(err != noErr)
 300     {
 301         ERR("AudioOutputUnitStart failed\n");
 302         return ALC_FALSE;
 303     }
 304
 305     return ALC_TRUE;
 306 }
 307
 308 static void ALCcoreAudioPlayback_stop(ALCcoreAudioPlayback *self)
 309 {
 310     OSStatus err = AudioOutputUnitStop(self->AudioUnit);
 311     if(err != noErr)
 312         ERR("AudioOutputUnitStop failed\n");
 313 }
 314
 315
 316 struct ALCcoreAudioCapture final : public ALCbackend {
 317     AudioUnit AudioUnit;
 318
 319     ALuint FrameSize;
 320     ALdouble SampleRateRatio;              // Ratio of hardware sample rate / requested sample rate
 321     AudioStreamBasicDescription Format;    // This is the OpenAL format as a CoreAudio ASBD
 322
 323     AudioConverterRef AudioConverter;      // Sample rate converter if needed
 324     AudioBufferList *BufferList;           // Buffer for data coming from the input device
 325     ALCvoid *ResampleBuffer;               // Buffer for returned RingBuffer data when resampling
 326
 327     ll_ringbuffer_t *Ring;
 328 };
 329
 330 static void ALCcoreAudioCapture_Construct(ALCcoreAudioCapture *self, ALCdevice *device);
 331 static void ALCcoreAudioCapture_Destruct(ALCcoreAudioCapture *self);
 332 static ALCenum ALCcoreAudioCapture_open(ALCcoreAudioCapture *self, const ALCchar *name);
 333 static DECLARE_FORWARD(ALCcoreAudioCapture, ALCbackend, ALCboolean, reset)
 334 static ALCboolean ALCcoreAudioCapture_start(ALCcoreAudioCapture *self);
 335 static void ALCcoreAudioCapture_stop(ALCcoreAudioCapture *self);
 336 static ALCenum ALCcoreAudioCapture_captureSamples(ALCcoreAudioCapture *self, ALCvoid *buffer, ALCuint samples);
 337 static ALCuint ALCcoreAudioCapture_availableSamples(ALCcoreAudioCapture *self);
 338 static DECLARE_FORWARD(ALCcoreAudioCapture, ALCbackend, ClockLatency, getClockLatency)
 339 static DECLARE_FORWARD(ALCcoreAudioCapture, ALCbackend, void, lock)
 340 static DECLARE_FORWARD(ALCcoreAudioCapture, ALCbackend, void, unlock)
 341 DECLARE_DEFAULT_ALLOCATORS(ALCcoreAudioCapture)
 342
 343 DEFINE_ALCBACKEND_VTABLE(ALCcoreAudioCapture);
 344
 345
 346 static AudioBufferList *allocate_buffer_list(UInt32 channelCount, UInt32 byteSize)
 347 {
 348     AudioBufferList *list;
 349
 350     list = static_cast<AudioBufferList*>(calloc(1,
 351         FAM_SIZE(AudioBufferList, mBuffers, 1) + byteSize));
 352     if(list)
 353     {
 354         list->mNumberBuffers = 1;
 355
 356         list->mBuffers[0].mNumberChannels = channelCount;
 357         list->mBuffers[0].mDataByteSize = byteSize;
 358         list->mBuffers[0].mData = &list->mBuffers[1];
 359     }
 360     return list;
 361 }
 362
 363 static void destroy_buffer_list(AudioBufferList *list)
 364 {
 365     free(list);
 366 }
 367
 368
 369 static void ALCcoreAudioCapture_Construct(ALCcoreAudioCapture *self, ALCdevice *device)
 370 {
 371     new (self) ALCcoreAudioCapture{};
 372     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 373     SET_VTABLE2(ALCcoreAudioCapture, ALCbackend, self);
 374
 375     self->AudioUnit = 0;
 376     self->AudioConverter = NULL;
 377     self->BufferList = NULL;
 378     self->ResampleBuffer = NULL;
 379     self->Ring = NULL;
 380 }
 381
 382 static void ALCcoreAudioCapture_Destruct(ALCcoreAudioCapture *self)
 383 {
 384     ll_ringbuffer_free(self->Ring);
 385     self->Ring = NULL;
 386
 387     free(self->ResampleBuffer);
 388     self->ResampleBuffer = NULL;
 389
 390     destroy_buffer_list(self->BufferList);
 391     self->BufferList = NULL;
 392
 393     if(self->AudioConverter)
 394         AudioConverterDispose(self->AudioConverter);
 395     self->AudioConverter = NULL;
 396
 397     if(self->AudioUnit)
 398         AudioComponentInstanceDispose(self->AudioUnit);
 399     self->AudioUnit = 0;
 400
 401     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
 402     self->~ALCcoreAudioCapture();
 403 }
 404
 405
 406 static OSStatus ALCcoreAudioCapture_RecordProc(void *inRefCon,
 407   AudioUnitRenderActionFlags* UNUSED(ioActionFlags),
 408   const AudioTimeStamp *inTimeStamp, UInt32 UNUSED(inBusNumber),
 409   UInt32 inNumberFrames, AudioBufferList* UNUSED(ioData))
 410 {
 411     ALCcoreAudioCapture *self = static_cast<ALCcoreAudioCapture*>(inRefCon);
 412     AudioUnitRenderActionFlags flags = 0;
 413     OSStatus err;
 414
 415     // fill the BufferList with data from the input device
 416     err = AudioUnitRender(self->AudioUnit, &flags, inTimeStamp, 1, inNumberFrames, self->BufferList);
 417     if(err != noErr)
 418     {
 419         ERR("AudioUnitRender error: %d\n", err);
 420         return err;
 421     }
 422
 423     ll_ringbuffer_write(self->Ring, self->BufferList->mBuffers[0].mData, inNumberFrames);
 424     return noErr;
 425 }
 426
 427 static OSStatus ALCcoreAudioCapture_ConvertCallback(AudioConverterRef UNUSED(inAudioConverter),
 428   UInt32 *ioNumberDataPackets, AudioBufferList *ioData,
 429   AudioStreamPacketDescription** UNUSED(outDataPacketDescription),
 430   void *inUserData)
 431 {
 432     ALCcoreAudioCapture *self = reinterpret_cast<ALCcoreAudioCapture*>(inUserData);
 433
 434     // Read from the ring buffer and store temporarily in a large buffer
 435     ll_ringbuffer_read(self->Ring, self->ResampleBuffer, *ioNumberDataPackets);
 436
 437     // Set the input data
 438     ioData->mNumberBuffers = 1;
 439     ioData->mBuffers[0].mNumberChannels = self->Format.mChannelsPerFrame;
 440     ioData->mBuffers[0].mData = self->ResampleBuffer;
 441     ioData->mBuffers[0].mDataByteSize = (*ioNumberDataPackets) * self->Format.mBytesPerFrame;
 442
 443     return noErr;
 444 }
 445
 446
 447 static ALCenum ALCcoreAudioCapture_open(ALCcoreAudioCapture *self, const ALCchar *name)
 448 {
 449     ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
 450     AudioStreamBasicDescription requestedFormat;  // The application requested format
 451     AudioStreamBasicDescription hardwareFormat;   // The hardware format
 452     AudioStreamBasicDescription outputFormat;     // The AudioUnit output format
 453     AURenderCallbackStruct input;
 454     AudioComponentDescription desc;
 455     UInt32 outputFrameCount;
 456     UInt32 propertySize;
 457     AudioObjectPropertyAddress propertyAddress;
 458     UInt32 enableIO;
 459     AudioComponent comp;
 460     OSStatus err;
 461
 462     if(!name)
 463         name = ca_device;
 464     else if(strcmp(name, ca_device) != 0)
 465         return ALC_INVALID_VALUE;
 466
 467     desc.componentType = kAudioUnitType_Output;
 468 #if TARGET_OS_IOS
 469     desc.componentSubType = kAudioUnitSubType_RemoteIO;
 470 #else
 471     desc.componentSubType = kAudioUnitSubType_HALOutput;
 472 #endif
 473     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 474     desc.componentFlags = 0;
 475     desc.componentFlagsMask = 0;
 476
 477     // Search for component with given description
 478     comp = AudioComponentFindNext(NULL, &desc);
 479     if(comp == NULL)
 480     {
 481         ERR("AudioComponentFindNext failed\n");
 482         return ALC_INVALID_VALUE;
 483     }
 484
 485     // Open the component
 486     err = AudioComponentInstanceNew(comp, &self->AudioUnit);
 487     if(err != noErr)
 488     {
 489         ERR("AudioComponentInstanceNew failed\n");
 490         goto error;
 491     }
 492
 493     // Turn off AudioUnit output
 494     enableIO = 0;
 495     err = AudioUnitSetProperty(self->AudioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(ALuint));
 496     if(err != noErr)
 497     {
 498         ERR("AudioUnitSetProperty failed\n");
 499         goto error;
 500     }
 501
 502     // Turn on AudioUnit input
 503     enableIO = 1;
 504     err = AudioUnitSetProperty(self->AudioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(ALuint));
 505     if(err != noErr)
 506     {
 507         ERR("AudioUnitSetProperty failed\n");
 508         goto error;
 509     }
 510
 511 #if !TARGET_OS_IOS
 512     {
 513         // Get the default input device
 514         AudioDeviceID inputDevice = kAudioDeviceUnknown;
 515
 516         propertySize = sizeof(AudioDeviceID);
 517         propertyAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
 518         propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
 519         propertyAddress.mElement = kAudioObjectPropertyElementMaster;
 520
 521         err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, NULL, &propertySize, &inputDevice);
 522         if(err != noErr)
 523         {
 524             ERR("AudioObjectGetPropertyData failed\n");
 525             goto error;
 526         }
 527         if(inputDevice == kAudioDeviceUnknown)
 528         {
 529             ERR("No input device found\n");
 530             goto error;
 531         }
 532
 533         // Track the input device
 534         err = AudioUnitSetProperty(self->AudioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &inputDevice, sizeof(AudioDeviceID));
 535         if(err != noErr)
 536         {
 537             ERR("AudioUnitSetProperty failed\n");
 538             goto error;
 539         }
 540     }
 541 #endif
 542
 543     // set capture callback
 544     input.inputProc = ALCcoreAudioCapture_RecordProc;
 545     input.inputProcRefCon = self;
 546
 547     err = AudioUnitSetProperty(self->AudioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &input, sizeof(AURenderCallbackStruct));
 548     if(err != noErr)
 549     {
 550         ERR("AudioUnitSetProperty failed\n");
 551         goto error;
 552     }
 553
 554     // Initialize the device
 555     err = AudioUnitInitialize(self->AudioUnit);
 556     if(err != noErr)
 557     {
 558         ERR("AudioUnitInitialize failed\n");
 559         goto error;
 560     }
 561
 562     // Get the hardware format
 563     propertySize = sizeof(AudioStreamBasicDescription);
 564     err = AudioUnitGetProperty(self->AudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &hardwareFormat, &propertySize);
 565     if(err != noErr || propertySize != sizeof(AudioStreamBasicDescription))
 566     {
 567         ERR("AudioUnitGetProperty failed\n");
 568         goto error;
 569     }
 570
 571     // Set up the requested format description
 572     switch(device->FmtType)
 573     {
 574         case DevFmtUByte:
 575             requestedFormat.mBitsPerChannel = 8;
 576             requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
 577             break;
 578         case DevFmtShort:
 579             requestedFormat.mBitsPerChannel = 16;
 580             requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
 581             break;
 582         case DevFmtInt:
 583             requestedFormat.mBitsPerChannel = 32;
 584             requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
 585             break;
 586         case DevFmtFloat:
 587             requestedFormat.mBitsPerChannel = 32;
 588             requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
 589             break;
 590         case DevFmtByte:
 591         case DevFmtUShort:
 592         case DevFmtUInt:
 593             ERR("%s samples not supported\n", DevFmtTypeString(device->FmtType));
 594             goto error;
 595     }
 596
 597     switch(device->FmtChans)
 598     {
 599         case DevFmtMono:
 600             requestedFormat.mChannelsPerFrame = 1;
 601             break;
 602         case DevFmtStereo:
 603             requestedFormat.mChannelsPerFrame = 2;
 604             break;
 605
 606         case DevFmtQuad:
 607         case DevFmtX51:
 608         case DevFmtX51Rear:
 609         case DevFmtX61:
 610         case DevFmtX71:
 611         case DevFmtAmbi3D:
 612             ERR("%s not supported\n", DevFmtChannelsString(device->FmtChans));
 613             goto error;
 614     }
 615
 616     requestedFormat.mBytesPerFrame = requestedFormat.mChannelsPerFrame * requestedFormat.mBitsPerChannel / 8;
 617     requestedFormat.mBytesPerPacket = requestedFormat.mBytesPerFrame;
 618     requestedFormat.mSampleRate = device->Frequency;
 619     requestedFormat.mFormatID = kAudioFormatLinearPCM;
 620     requestedFormat.mReserved = 0;
 621     requestedFormat.mFramesPerPacket = 1;
 622
 623     // save requested format description for later use
 624     self->Format = requestedFormat;
 625     self->FrameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->mAmbiOrder);
 626
 627     // Use intermediate format for sample rate conversion (outputFormat)
 628     // Set sample rate to the same as hardware for resampling later
 629     outputFormat = requestedFormat;
 630     outputFormat.mSampleRate = hardwareFormat.mSampleRate;
 631
 632     // Determine sample rate ratio for resampling
 633     self->SampleRateRatio = outputFormat.mSampleRate / device->Frequency;
 634
 635     // The output format should be the requested format, but using the hardware sample rate
 636     // This is because the AudioUnit will automatically scale other properties, except for sample rate
 637     err = AudioUnitSetProperty(self->AudioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, (void *)&outputFormat, sizeof(outputFormat));
 638     if(err != noErr)
 639     {
 640         ERR("AudioUnitSetProperty failed\n");
 641         goto error;
 642     }
 643
 644     // Set the AudioUnit output format frame count
 645     outputFrameCount = device->UpdateSize * self->SampleRateRatio;
 646     err = AudioUnitSetProperty(self->AudioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Output, 0, &outputFrameCount, sizeof(outputFrameCount));
 647     if(err != noErr)
 648     {
 649         ERR("AudioUnitSetProperty failed: %d\n", err);
 650         goto error;
 651     }
 652
 653     // Set up sample converter
 654     err = AudioConverterNew(&outputFormat, &requestedFormat, &self->AudioConverter);
 655     if(err != noErr)
 656     {
 657         ERR("AudioConverterNew failed: %d\n", err);
 658         goto error;
 659     }
 660
 661     // Create a buffer for use in the resample callback
 662     self->ResampleBuffer = malloc(device->UpdateSize * self->FrameSize * self->SampleRateRatio);
 663
 664     // Allocate buffer for the AudioUnit output
 665     self->BufferList = allocate_buffer_list(outputFormat.mChannelsPerFrame, device->UpdateSize * self->FrameSize * self->SampleRateRatio);
 666     if(self->BufferList == NULL)
 667         goto error;
 668
 669     self->Ring = ll_ringbuffer_create(
 670         (size_t)ceil(device->UpdateSize*self->SampleRateRatio*device->NumUpdates),
 671         self->FrameSize, false
 672     );
 673     if(!self->Ring) goto error;
 674
 675     device->DeviceName = name;
 676     return ALC_NO_ERROR;
 677
 678 error:
 679     ll_ringbuffer_free(self->Ring);
 680     self->Ring = NULL;
 681     free(self->ResampleBuffer);
 682     self->ResampleBuffer = NULL;
 683     destroy_buffer_list(self->BufferList);
 684     self->BufferList = NULL;
 685
 686     if(self->AudioConverter)
 687         AudioConverterDispose(self->AudioConverter);
 688     self->AudioConverter = NULL;
 689     if(self->AudioUnit)
 690         AudioComponentInstanceDispose(self->AudioUnit);
 691     self->AudioUnit = 0;
 692
 693     return ALC_INVALID_VALUE;
 694 }
 695
 696
 697 static ALCboolean ALCcoreAudioCapture_start(ALCcoreAudioCapture *self)
 698 {
 699     OSStatus err = AudioOutputUnitStart(self->AudioUnit);
 700     if(err != noErr)
 701     {
 702         ERR("AudioOutputUnitStart failed\n");
 703         return ALC_FALSE;
 704     }
 705     return ALC_TRUE;
 706 }
 707
 708 static void ALCcoreAudioCapture_stop(ALCcoreAudioCapture *self)
 709 {
 710     OSStatus err = AudioOutputUnitStop(self->AudioUnit);
 711     if(err != noErr)
 712         ERR("AudioOutputUnitStop failed\n");
 713 }
 714
 715 static ALCenum ALCcoreAudioCapture_captureSamples(ALCcoreAudioCapture *self, ALCvoid *buffer, ALCuint samples)
 716 {
 717     union {
 718         ALbyte _[sizeof(AudioBufferList) + sizeof(AudioBuffer)];
 719         AudioBufferList list;
 720     } audiobuf = { { 0 } };
 721     UInt32 frameCount;
 722     OSStatus err;
 723
 724     // If no samples are requested, just return
 725     if(samples == 0) return ALC_NO_ERROR;
 726
 727     // Point the resampling buffer to the capture buffer
 728     audiobuf.list.mNumberBuffers = 1;
 729     audiobuf.list.mBuffers[0].mNumberChannels = self->Format.mChannelsPerFrame;
 730     audiobuf.list.mBuffers[0].mDataByteSize = samples * self->FrameSize;
 731     audiobuf.list.mBuffers[0].mData = buffer;
 732
 733     // Resample into another AudioBufferList
 734     frameCount = samples;
 735     err = AudioConverterFillComplexBuffer(self->AudioConverter,
 736         ALCcoreAudioCapture_ConvertCallback, self, &frameCount, &audiobuf.list, NULL
 737     );
 738     if(err != noErr)
 739     {
 740         ERR("AudioConverterFillComplexBuffer error: %d\n", err);
 741         return ALC_INVALID_VALUE;
 742     }
 743     return ALC_NO_ERROR;
 744 }
 745
 746 static ALCuint ALCcoreAudioCapture_availableSamples(ALCcoreAudioCapture *self)
 747 {
 748     return ll_ringbuffer_read_space(self->Ring) / self->SampleRateRatio;
 749 }
 750
 751
 752 BackendFactory &CoreAudioBackendFactory::getFactory()
 753 {
 754     static CoreAudioBackendFactory factory{};
 755     return factory;
 756 }
 757
 758 bool CoreAudioBackendFactory::init() { return true; }
 759
 760 bool CoreAudioBackendFactory::querySupport(ALCbackend_Type type)
 761 { return (type == ALCbackend_Playback || ALCbackend_Capture); }
 762
 763 void CoreAudioBackendFactory::probe(enum DevProbe type, std::string *outnames)
 764 {
 765     switch(type)
 766     {
 767         case ALL_DEVICE_PROBE:
 768         case CAPTURE_DEVICE_PROBE:
 769             /* Includes null char. */
 770             outnames->append(ca_device, sizeof(ca_device));
 771             break;
 772     }
 773 }
 774
 775 ALCbackend *CoreAudioBackendFactory::createBackend(ALCdevice *device, ALCbackend_Type type)
 776 {
 777     if(type == ALCbackend_Playback)
 778     {
 779         ALCcoreAudioPlayback *backend;
 780         NEW_OBJ(backend, ALCcoreAudioPlayback)(device);
 781         if(!backend) return nullptr;
 782         return STATIC_CAST(ALCbackend, backend);
 783     }
 784     if(type == ALCbackend_Capture)
 785     {
 786         ALCcoreAudioCapture *backend;
 787         NEW_OBJ(backend, ALCcoreAudioCapture)(device);
 788         if(!backend) return nullptr;
 789         return STATIC_CAST(ALCbackend, backend);
 790     }
 791
 792     return nullptr;
 793 }