Alc/backends/coreaudio.c

   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., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "alMain.h"
  28 #include "AL/al.h"
  29 #include "AL/alc.h"
  30
  31 #include <CoreServices/CoreServices.h>
  32 #include <unistd.h>
  33 #include <AudioUnit/AudioUnit.h>
  34 #include <AudioToolbox/AudioToolbox.h>
  35
  36
  37 typedef struct {
  38     AudioUnit audioUnit;
  39
  40     ALuint frameSize;
  41     ALdouble sampleRateRatio;              // Ratio of hardware sample rate / requested sample rate
  42     AudioStreamBasicDescription format;    // This is the OpenAL format as a CoreAudio ASBD
  43
  44     AudioConverterRef audioConverter;      // Sample rate converter if needed
  45     AudioBufferList *bufferList;           // Buffer for data coming from the input device
  46     ALCvoid *resampleBuffer;               // Buffer for returned RingBuffer data when resampling
  47
  48     RingBuffer *ring;
  49 } ca_data;
  50
  51 static const ALCchar ca_device[] = "CoreAudio Default";
  52
  53
  54 static void destroy_buffer_list(AudioBufferList* list)
  55 {
  56     if(list)
  57     {
  58         UInt32 i;
  59         for(i = 0;i < list->mNumberBuffers;i++)
  60             free(list->mBuffers[i].mData);
  61         free(list);
  62     }
  63 }
  64
  65 static AudioBufferList* allocate_buffer_list(UInt32 channelCount, UInt32 byteSize)
  66 {
  67     AudioBufferList *list;
  68
  69     list = calloc(1, sizeof(AudioBufferList) + sizeof(AudioBuffer));
  70     if(list)
  71     {
  72         list->mNumberBuffers = 1;
  73
  74         list->mBuffers[0].mNumberChannels = channelCount;
  75         list->mBuffers[0].mDataByteSize = byteSize;
  76         list->mBuffers[0].mData = malloc(byteSize);
  77         if(list->mBuffers[0].mData == NULL)
  78         {
  79             free(list);
  80             list = NULL;
  81         }
  82     }
  83     return list;
  84 }
  85
  86 static OSStatus ca_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp,
  87                             UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
  88 {
  89     ALCdevice *device = (ALCdevice*)inRefCon;
  90     ca_data *data = (ca_data*)device->ExtraData;
  91
  92     aluMixData(device, ioData->mBuffers[0].mData,
  93                ioData->mBuffers[0].mDataByteSize / data->frameSize);
  94
  95     return noErr;
  96 }
  97
  98 static OSStatus ca_capture_conversion_callback(AudioConverterRef inAudioConverter, UInt32 *ioNumberDataPackets,
  99         AudioBufferList *ioData, AudioStreamPacketDescription **outDataPacketDescription, void* inUserData)
 100 {
 101     ALCdevice *device = (ALCdevice*)inUserData;
 102     ca_data *data = (ca_data*)device->ExtraData;
 103
 104     // Read from the ring buffer and store temporarily in a large buffer
 105     ReadRingBuffer(data->ring, data->resampleBuffer, (ALsizei)(*ioNumberDataPackets));
 106
 107     // Set the input data
 108     ioData->mNumberBuffers = 1;
 109     ioData->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
 110     ioData->mBuffers[0].mData = data->resampleBuffer;
 111     ioData->mBuffers[0].mDataByteSize = (*ioNumberDataPackets) * data->format.mBytesPerFrame;
 112
 113     return noErr;
 114 }
 115
 116 static OSStatus ca_capture_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags,
 117                                     const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber,
 118                                     UInt32 inNumberFrames, AudioBufferList *ioData)
 119 {
 120     ALCdevice *device = (ALCdevice*)inRefCon;
 121     ca_data *data = (ca_data*)device->ExtraData;
 122     AudioUnitRenderActionFlags flags = 0;
 123     OSStatus err;
 124
 125     // fill the bufferList with data from the input device
 126     err = AudioUnitRender(data->audioUnit, &flags, inTimeStamp, 1, inNumberFrames, data->bufferList);
 127     if(err != noErr)
 128     {
 129         ERR("AudioUnitRender error: %d\n", err);
 130         return err;
 131     }
 132
 133     WriteRingBuffer(data->ring, data->bufferList->mBuffers[0].mData, inNumberFrames);
 134
 135     return noErr;
 136 }
 137
 138 static ALCenum ca_open_playback(ALCdevice *device, const ALCchar *deviceName)
 139 {
 140     ComponentDescription desc;
 141     Component comp;
 142     ca_data *data;
 143     OSStatus err;
 144
 145     if(!deviceName)
 146         deviceName = ca_device;
 147     else if(strcmp(deviceName, ca_device) != 0)
 148         return ALC_INVALID_VALUE;
 149
 150     /* open the default output unit */
 151     desc.componentType = kAudioUnitType_Output;
 152     desc.componentSubType = kAudioUnitSubType_DefaultOutput;
 153     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 154     desc.componentFlags = 0;
 155     desc.componentFlagsMask = 0;
 156
 157     comp = FindNextComponent(NULL, &desc);
 158     if(comp == NULL)
 159     {
 160         ERR("FindNextComponent failed\n");
 161         return ALC_INVALID_VALUE;
 162     }
 163
 164     data = calloc(1, sizeof(*data));
 165     device->ExtraData = data;
 166
 167     err = OpenAComponent(comp, &data->audioUnit);
 168     if(err != noErr)
 169     {
 170         ERR("OpenAComponent failed\n");
 171         free(data);
 172         device->ExtraData = NULL;
 173         return ALC_INVALID_VALUE;
 174     }
 175
 176     return ALC_NO_ERROR;
 177 }
 178
 179 static void ca_close_playback(ALCdevice *device)
 180 {
 181     ca_data *data = (ca_data*)device->ExtraData;
 182
 183     CloseComponent(data->audioUnit);
 184
 185     free(data);
 186     device->ExtraData = NULL;
 187 }
 188
 189 static ALCboolean ca_reset_playback(ALCdevice *device)
 190 {
 191     ca_data *data = (ca_data*)device->ExtraData;
 192     AudioStreamBasicDescription streamFormat;
 193     AURenderCallbackStruct input;
 194     OSStatus err;
 195     UInt32 size;
 196
 197     /* init and start the default audio unit... */
 198     err = AudioUnitInitialize(data->audioUnit);
 199     if(err != noErr)
 200     {
 201         ERR("AudioUnitInitialize failed\n");
 202         return ALC_FALSE;
 203     }
 204
 205     err = AudioOutputUnitStart(data->audioUnit);
 206     if(err != noErr)
 207     {
 208         ERR("AudioOutputUnitStart failed\n");
 209         return ALC_FALSE;
 210     }
 211
 212     /* retrieve default output unit's properties (output side) */
 213     size = sizeof(AudioStreamBasicDescription);
 214     err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &streamFormat, &size);
 215     if(err != noErr || size != sizeof(AudioStreamBasicDescription))
 216     {
 217         ERR("AudioUnitGetProperty failed\n");
 218         return ALC_FALSE;
 219     }
 220
 221 #if 0
 222     TRACE("Output streamFormat of default output unit -\n");
 223     TRACE("  streamFormat.mFramesPerPacket = %d\n", streamFormat.mFramesPerPacket);
 224     TRACE("  streamFormat.mChannelsPerFrame = %d\n", streamFormat.mChannelsPerFrame);
 225     TRACE("  streamFormat.mBitsPerChannel = %d\n", streamFormat.mBitsPerChannel);
 226     TRACE("  streamFormat.mBytesPerPacket = %d\n", streamFormat.mBytesPerPacket);
 227     TRACE("  streamFormat.mBytesPerFrame = %d\n", streamFormat.mBytesPerFrame);
 228     TRACE("  streamFormat.mSampleRate = %5.0f\n", streamFormat.mSampleRate);
 229 #endif
 230
 231     /* set default output unit's input side to match output side */
 232     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, size);
 233     if(err != noErr)
 234     {
 235         ERR("AudioUnitSetProperty failed\n");
 236         return ALC_FALSE;
 237     }
 238
 239     if(device->Frequency != streamFormat.mSampleRate)
 240     {
 241         if((device->Flags&DEVICE_FREQUENCY_REQUEST))
 242             ERR("CoreAudio does not support changing sample rates (wanted %dhz, got %dhz)\n", device->Frequency, streamFormat.mSampleRate);
 243         device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
 244
 245         device->UpdateSize = (ALuint)((ALuint64)device->UpdateSize *
 246                                       streamFormat.mSampleRate /
 247                                       device->Frequency);
 248         device->Frequency = streamFormat.mSampleRate;
 249     }
 250
 251     /* FIXME: How to tell what channels are what in the output device, and how
 252      * to specify what we're giving?  eg, 6.0 vs 5.1 */
 253     switch(streamFormat.mChannelsPerFrame)
 254     {
 255         case 1:
 256             if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
 257                device->FmtChans != DevFmtMono)
 258             {
 259                 ERR("Failed to set %s, got Mono instead\n", DevFmtChannelsString(device->FmtChans));
 260                 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
 261             }
 262             device->FmtChans = DevFmtMono;
 263             break;
 264         case 2:
 265             if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
 266                device->FmtChans != DevFmtStereo)
 267             {
 268                 ERR("Failed to set %s, got Stereo instead\n", DevFmtChannelsString(device->FmtChans));
 269                 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
 270             }
 271             device->FmtChans = DevFmtStereo;
 272             break;
 273         case 4:
 274             if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
 275                device->FmtChans != DevFmtQuad)
 276             {
 277                 ERR("Failed to set %s, got Quad instead\n", DevFmtChannelsString(device->FmtChans));
 278                 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
 279             }
 280             device->FmtChans = DevFmtQuad;
 281             break;
 282         case 6:
 283             if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
 284                device->FmtChans != DevFmtX51)
 285             {
 286                 ERR("Failed to set %s, got 5.1 Surround instead\n", DevFmtChannelsString(device->FmtChans));
 287                 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
 288             }
 289             device->FmtChans = DevFmtX51;
 290             break;
 291         case 7:
 292             if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
 293                device->FmtChans != DevFmtX61)
 294             {
 295                 ERR("Failed to set %s, got 6.1 Surround instead\n", DevFmtChannelsString(device->FmtChans));
 296                 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
 297             }
 298             device->FmtChans = DevFmtX61;
 299             break;
 300         case 8:
 301             if((device->Flags&DEVICE_CHANNELS_REQUEST) &&
 302                device->FmtChans != DevFmtX71)
 303             {
 304                 ERR("Failed to set %s, got 7.1 Surround instead\n", DevFmtChannelsString(device->FmtChans));
 305                 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
 306             }
 307             device->FmtChans = DevFmtX71;
 308             break;
 309         default:
 310             ERR("Unhandled channel count (%d), using Stereo\n", streamFormat.mChannelsPerFrame);
 311             device->Flags &= ~DEVICE_CHANNELS_REQUEST;
 312             device->FmtChans = DevFmtStereo;
 313             streamFormat.mChannelsPerFrame = 2;
 314             break;
 315     }
 316     SetDefaultWFXChannelOrder(device);
 317
 318     /* use channel count and sample rate from the default output unit's current
 319      * parameters, but reset everything else */
 320     streamFormat.mFramesPerPacket = 1;
 321     switch(device->FmtType)
 322     {
 323         case DevFmtUByte:
 324             device->FmtType = DevFmtByte;
 325             /* fall-through */
 326         case DevFmtByte:
 327             streamFormat.mBitsPerChannel = 8;
 328             streamFormat.mBytesPerPacket = streamFormat.mChannelsPerFrame;
 329             streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame;
 330             break;
 331         case DevFmtUShort:
 332         case DevFmtFloat:
 333             device->FmtType = DevFmtShort;
 334             /* fall-through */
 335         case DevFmtShort:
 336             streamFormat.mBitsPerChannel = 16;
 337             streamFormat.mBytesPerPacket = 2 * streamFormat.mChannelsPerFrame;
 338             streamFormat.mBytesPerFrame = 2 * streamFormat.mChannelsPerFrame;
 339             break;
 340     }
 341     streamFormat.mFormatID = kAudioFormatLinearPCM;
 342     streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger |
 343                                 kAudioFormatFlagsNativeEndian |
 344                                 kLinearPCMFormatFlagIsPacked;
 345
 346     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, sizeof(AudioStreamBasicDescription));
 347     if(err != noErr)
 348     {
 349         ERR("AudioUnitSetProperty failed\n");
 350         return ALC_FALSE;
 351     }
 352
 353     /* setup callback */
 354     data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 355     input.inputProc = ca_callback;
 356     input.inputProcRefCon = device;
 357
 358     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(AURenderCallbackStruct));
 359     if(err != noErr)
 360     {
 361         ERR("AudioUnitSetProperty failed\n");
 362         return ALC_FALSE;
 363     }
 364
 365     return ALC_TRUE;
 366 }
 367
 368 static void ca_stop_playback(ALCdevice *device)
 369 {
 370     ca_data *data = (ca_data*)device->ExtraData;
 371     OSStatus err;
 372
 373     AudioOutputUnitStop(data->audioUnit);
 374     err = AudioUnitUninitialize(data->audioUnit);
 375     if(err != noErr)
 376         ERR("-- AudioUnitUninitialize failed.\n");
 377 }
 378
 379 static ALCenum ca_open_capture(ALCdevice *device, const ALCchar *deviceName)
 380 {
 381     AudioStreamBasicDescription requestedFormat;  // The application requested format
 382     AudioStreamBasicDescription hardwareFormat;   // The hardware format
 383     AudioStreamBasicDescription outputFormat;     // The AudioUnit output format
 384     AURenderCallbackStruct input;
 385     ComponentDescription desc;
 386     AudioDeviceID inputDevice;
 387     UInt32 outputFrameCount;
 388     UInt32 propertySize;
 389     UInt32 enableIO;
 390     Component comp;
 391     ca_data *data;
 392     OSStatus err;
 393
 394     desc.componentType = kAudioUnitType_Output;
 395     desc.componentSubType = kAudioUnitSubType_HALOutput;
 396     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 397     desc.componentFlags = 0;
 398     desc.componentFlagsMask = 0;
 399
 400     // Search for component with given description
 401     comp = FindNextComponent(NULL, &desc);
 402     if(comp == NULL)
 403     {
 404         ERR("FindNextComponent failed\n");
 405         return ALC_INVALID_VALUE;
 406     }
 407
 408     data = calloc(1, sizeof(*data));
 409     device->ExtraData = data;
 410
 411     // Open the component
 412     err = OpenAComponent(comp, &data->audioUnit);
 413     if(err != noErr)
 414     {
 415         ERR("OpenAComponent failed\n");
 416         goto error;
 417     }
 418
 419     // Turn off AudioUnit output
 420     enableIO = 0;
 421     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(ALuint));
 422     if(err != noErr)
 423     {
 424         ERR("AudioUnitSetProperty failed\n");
 425         goto error;
 426     }
 427
 428     // Turn on AudioUnit input
 429     enableIO = 1;
 430     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(ALuint));
 431     if(err != noErr)
 432     {
 433         ERR("AudioUnitSetProperty failed\n");
 434         goto error;
 435     }
 436
 437     // Get the default input device
 438     propertySize = sizeof(AudioDeviceID);
 439     err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &inputDevice);
 440     if(err != noErr)
 441     {
 442         ERR("AudioHardwareGetProperty failed\n");
 443         goto error;
 444     }
 445
 446     if(inputDevice == kAudioDeviceUnknown)
 447     {
 448         ERR("No input device found\n");
 449         goto error;
 450     }
 451
 452     // Track the input device
 453     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &inputDevice, sizeof(AudioDeviceID));
 454     if(err != noErr)
 455     {
 456         ERR("AudioUnitSetProperty failed\n");
 457         goto error;
 458     }
 459
 460     // set capture callback
 461     input.inputProc = ca_capture_callback;
 462     input.inputProcRefCon = device;
 463
 464     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &input, sizeof(AURenderCallbackStruct));
 465     if(err != noErr)
 466     {
 467         ERR("AudioUnitSetProperty failed\n");
 468         goto error;
 469     }
 470
 471     // Initialize the device
 472     err = AudioUnitInitialize(data->audioUnit);
 473     if(err != noErr)
 474     {
 475         ERR("AudioUnitInitialize failed\n");
 476         goto error;
 477     }
 478
 479     // Get the hardware format
 480     propertySize = sizeof(AudioStreamBasicDescription);
 481     err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &hardwareFormat, &propertySize);
 482     if(err != noErr || propertySize != sizeof(AudioStreamBasicDescription))
 483     {
 484         ERR("AudioUnitGetProperty failed\n");
 485         goto error;
 486     }
 487
 488     // Set up the requested format description
 489     switch(device->FmtType)
 490     {
 491         case DevFmtUByte:
 492             requestedFormat.mBitsPerChannel = 8;
 493             requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
 494             break;
 495         case DevFmtShort:
 496             requestedFormat.mBitsPerChannel = 16;
 497             requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
 498             break;
 499         case DevFmtFloat:
 500             requestedFormat.mBitsPerChannel = 32;
 501             requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
 502             break;
 503         case DevFmtByte:
 504         case DevFmtUShort:
 505             ERR("%s samples not supported\n", DevFmtTypeString(device->FmtType));
 506             goto error;
 507     }
 508
 509     switch(device->FmtChans)
 510     {
 511         case DevFmtMono:
 512             requestedFormat.mChannelsPerFrame = 1;
 513             break;
 514         case DevFmtStereo:
 515             requestedFormat.mChannelsPerFrame = 2;
 516             break;
 517
 518         case DevFmtQuad:
 519         case DevFmtX51:
 520         case DevFmtX51Side:
 521         case DevFmtX61:
 522         case DevFmtX71:
 523             ERR("%s not supported\n", DevFmtChannelsString(device->FmtChans));
 524             goto error;
 525     }
 526
 527     requestedFormat.mBytesPerFrame = requestedFormat.mChannelsPerFrame * requestedFormat.mBitsPerChannel / 8;
 528     requestedFormat.mBytesPerPacket = requestedFormat.mBytesPerFrame;
 529     requestedFormat.mSampleRate = device->Frequency;
 530     requestedFormat.mFormatID = kAudioFormatLinearPCM;
 531     requestedFormat.mReserved = 0;
 532     requestedFormat.mFramesPerPacket = 1;
 533
 534     // save requested format description for later use
 535     data->format = requestedFormat;
 536     data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 537
 538     // Use intermediate format for sample rate conversion (outputFormat)
 539     // Set sample rate to the same as hardware for resampling later
 540     outputFormat = requestedFormat;
 541     outputFormat.mSampleRate = hardwareFormat.mSampleRate;
 542
 543     // Determine sample rate ratio for resampling
 544     data->sampleRateRatio = outputFormat.mSampleRate / device->Frequency;
 545
 546     // The output format should be the requested format, but using the hardware sample rate
 547     // This is because the AudioUnit will automatically scale other properties, except for sample rate
 548     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, (void *)&outputFormat, sizeof(outputFormat));
 549     if(err != noErr)
 550     {
 551         ERR("AudioUnitSetProperty failed\n");
 552         goto error;
 553     }
 554
 555     // Set the AudioUnit output format frame count
 556     outputFrameCount = device->UpdateSize * data->sampleRateRatio;
 557     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Output, 0, &outputFrameCount, sizeof(outputFrameCount));
 558     if(err != noErr)
 559     {
 560         ERR("AudioUnitSetProperty failed: %d\n", err);
 561         goto error;
 562     }
 563
 564     // Set up sample converter
 565     err = AudioConverterNew(&outputFormat, &requestedFormat, &data->audioConverter);
 566     if(err != noErr)
 567     {
 568         ERR("AudioConverterNew failed: %d\n", err);
 569         goto error;
 570     }
 571
 572     // Create a buffer for use in the resample callback
 573     data->resampleBuffer = malloc(device->UpdateSize * data->frameSize * data->sampleRateRatio);
 574
 575     // Allocate buffer for the AudioUnit output
 576     data->bufferList = allocate_buffer_list(outputFormat.mChannelsPerFrame, device->UpdateSize * data->frameSize * data->sampleRateRatio);
 577     if(data->bufferList == NULL)
 578     {
 579         alcSetError(device, ALC_OUT_OF_MEMORY);
 580         goto error;
 581     }
 582
 583     data->ring = CreateRingBuffer(data->frameSize, (device->UpdateSize * data->sampleRateRatio) * device->NumUpdates);
 584     if(data->ring == NULL)
 585     {
 586         alcSetError(device, ALC_OUT_OF_MEMORY);
 587         goto error;
 588     }
 589
 590     return ALC_NO_ERROR;
 591
 592 error:
 593     DestroyRingBuffer(data->ring);
 594     free(data->resampleBuffer);
 595     destroy_buffer_list(data->bufferList);
 596
 597     if(data->audioConverter)
 598         AudioConverterDispose(data->audioConverter);
 599     if(data->audioUnit)
 600         CloseComponent(data->audioUnit);
 601
 602     free(data);
 603     device->ExtraData = NULL;
 604
 605     return ALC_INVALID_VALUE;
 606 }
 607
 608 static void ca_close_capture(ALCdevice *device)
 609 {
 610     ca_data *data = (ca_data*)device->ExtraData;
 611
 612     DestroyRingBuffer(data->ring);
 613     free(data->resampleBuffer);
 614     destroy_buffer_list(data->bufferList);
 615
 616     AudioConverterDispose(data->audioConverter);
 617     CloseComponent(data->audioUnit);
 618
 619     free(data);
 620     device->ExtraData = NULL;
 621 }
 622
 623 static void ca_start_capture(ALCdevice *device)
 624 {
 625     ca_data *data = (ca_data*)device->ExtraData;
 626     OSStatus err = AudioOutputUnitStart(data->audioUnit);
 627     if(err != noErr)
 628         ERR("AudioOutputUnitStart failed\n");
 629 }
 630
 631 static void ca_stop_capture(ALCdevice *device)
 632 {
 633     ca_data *data = (ca_data*)device->ExtraData;
 634     OSStatus err = AudioOutputUnitStop(data->audioUnit);
 635     if(err != noErr)
 636         ERR("AudioOutputUnitStop failed\n");
 637 }
 638
 639 static ALCuint ca_available_samples(ALCdevice *device)
 640 {
 641     ca_data *data = device->ExtraData;
 642     return RingBufferSize(data->ring) / data->sampleRateRatio;
 643 }
 644
 645 static void ca_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
 646 {
 647     ca_data *data = (ca_data*)device->ExtraData;
 648
 649     if(samples <= ca_available_samples(device))
 650     {
 651         AudioBufferList *list;
 652         UInt32 frameCount;
 653         OSStatus err;
 654
 655         // If no samples are requested, just return
 656         if(samples == 0)
 657             return;
 658
 659         // Allocate a temporary AudioBufferList to use as the return resamples data
 660         list = alloca(sizeof(AudioBufferList) + sizeof(AudioBuffer));
 661
 662         // Point the resampling buffer to the capture buffer
 663         list->mNumberBuffers = 1;
 664         list->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
 665         list->mBuffers[0].mDataByteSize = samples * data->frameSize;
 666         list->mBuffers[0].mData = buffer;
 667
 668         // Resample into another AudioBufferList
 669         frameCount = samples;
 670         err = AudioConverterFillComplexBuffer(data->audioConverter, ca_capture_conversion_callback, device,
 671                                               &frameCount, list, NULL);
 672         if(err != noErr)
 673         {
 674             ERR("AudioConverterFillComplexBuffer error: %d\n", err);
 675             alcSetError(device, ALC_INVALID_VALUE);
 676         }
 677     }
 678     else
 679         alcSetError(device, ALC_INVALID_VALUE);
 680 }
 681
 682 static const BackendFuncs ca_funcs = {
 683     ca_open_playback,
 684     ca_close_playback,
 685     ca_reset_playback,
 686     ca_stop_playback,
 687     ca_open_capture,
 688     ca_close_capture,
 689     ca_start_capture,
 690     ca_stop_capture,
 691     ca_capture_samples,
 692     ca_available_samples
 693 };
 694
 695 ALCboolean alc_ca_init(BackendFuncs *func_list)
 696 {
 697     *func_list = ca_funcs;
 698     return ALC_TRUE;
 699 }
 700
 701 void alc_ca_deinit(void)
 702 {
 703 }
 704
 705 void alc_ca_probe(enum DevProbe type)
 706 {
 707     switch(type)
 708     {
 709         case DEVICE_PROBE:
 710             AppendDeviceList(ca_device);
 711             break;
 712         case ALL_DEVICE_PROBE:
 713             AppendAllDeviceList(ca_device);
 714             break;
 715         case CAPTURE_DEVICE_PROBE:
 716             AppendCaptureDeviceList(ca_device);
 717             break;
 718     }
 719 }