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.,
  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 <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <alloca.h>
  27
  28 #include "alMain.h"
  29 #include "alu.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
 166     err = OpenAComponent(comp, &data->audioUnit);
 167     if(err != noErr)
 168     {
 169         ERR("OpenAComponent failed\n");
 170         free(data);
 171         return ALC_INVALID_VALUE;
 172     }
 173
 174     /* init and start the default audio unit... */
 175     err = AudioUnitInitialize(data->audioUnit);
 176     if(err != noErr)
 177     {
 178         ERR("AudioUnitInitialize failed\n");
 179         CloseComponent(data->audioUnit);
 180         free(data);
 181         return ALC_INVALID_VALUE;
 182     }
 183
 184     al_string_copy_cstr(&device->DeviceName, deviceName);
 185     device->ExtraData = data;
 186     return ALC_NO_ERROR;
 187 }
 188
 189 static void ca_close_playback(ALCdevice *device)
 190 {
 191     ca_data *data = (ca_data*)device->ExtraData;
 192
 193     AudioUnitUninitialize(data->audioUnit);
 194     CloseComponent(data->audioUnit);
 195
 196     free(data);
 197     device->ExtraData = NULL;
 198 }
 199
 200 static ALCboolean ca_reset_playback(ALCdevice *device)
 201 {
 202     ca_data *data = (ca_data*)device->ExtraData;
 203     AudioStreamBasicDescription streamFormat;
 204     AURenderCallbackStruct input;
 205     OSStatus err;
 206     UInt32 size;
 207
 208     err = AudioUnitUninitialize(data->audioUnit);
 209     if(err != noErr)
 210         ERR("-- AudioUnitUninitialize failed.\n");
 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         device->UpdateSize = (ALuint)((ALuint64)device->UpdateSize *
 242                                       streamFormat.mSampleRate /
 243                                       device->Frequency);
 244         device->Frequency = streamFormat.mSampleRate;
 245     }
 246
 247     /* FIXME: How to tell what channels are what in the output device, and how
 248      * to specify what we're giving?  eg, 6.0 vs 5.1 */
 249     switch(streamFormat.mChannelsPerFrame)
 250     {
 251         case 1:
 252             device->FmtChans = DevFmtMono;
 253             break;
 254         case 2:
 255             device->FmtChans = DevFmtStereo;
 256             break;
 257         case 4:
 258             device->FmtChans = DevFmtQuad;
 259             break;
 260         case 6:
 261             device->FmtChans = DevFmtX51;
 262             break;
 263         case 7:
 264             device->FmtChans = DevFmtX61;
 265             break;
 266         case 8:
 267             device->FmtChans = DevFmtX71;
 268             break;
 269         default:
 270             ERR("Unhandled channel count (%d), using Stereo\n", streamFormat.mChannelsPerFrame);
 271             device->FmtChans = DevFmtStereo;
 272             streamFormat.mChannelsPerFrame = 2;
 273             break;
 274     }
 275     SetDefaultWFXChannelOrder(device);
 276
 277     /* use channel count and sample rate from the default output unit's current
 278      * parameters, but reset everything else */
 279     streamFormat.mFramesPerPacket = 1;
 280     streamFormat.mFormatFlags = 0;
 281     switch(device->FmtType)
 282     {
 283         case DevFmtUByte:
 284             device->FmtType = DevFmtByte;
 285             /* fall-through */
 286         case DevFmtByte:
 287             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
 288             streamFormat.mBitsPerChannel = 8;
 289             break;
 290         case DevFmtUShort:
 291             device->FmtType = DevFmtShort;
 292             /* fall-through */
 293         case DevFmtShort:
 294             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
 295             streamFormat.mBitsPerChannel = 16;
 296             break;
 297         case DevFmtUInt:
 298             device->FmtType = DevFmtInt;
 299             /* fall-through */
 300         case DevFmtInt:
 301             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
 302             streamFormat.mBitsPerChannel = 32;
 303             break;
 304         case DevFmtFloat:
 305             streamFormat.mFormatFlags = kLinearPCMFormatFlagIsFloat;
 306             streamFormat.mBitsPerChannel = 32;
 307             break;
 308     }
 309     streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame *
 310                                   streamFormat.mBitsPerChannel / 8;
 311     streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame;
 312     streamFormat.mFormatID = kAudioFormatLinearPCM;
 313     streamFormat.mFormatFlags |= kAudioFormatFlagsNativeEndian |
 314                                  kLinearPCMFormatFlagIsPacked;
 315
 316     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, sizeof(AudioStreamBasicDescription));
 317     if(err != noErr)
 318     {
 319         ERR("AudioUnitSetProperty failed\n");
 320         return ALC_FALSE;
 321     }
 322
 323     /* setup callback */
 324     data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 325     input.inputProc = ca_callback;
 326     input.inputProcRefCon = device;
 327
 328     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(AURenderCallbackStruct));
 329     if(err != noErr)
 330     {
 331         ERR("AudioUnitSetProperty failed\n");
 332         return ALC_FALSE;
 333     }
 334
 335     /* init the default audio unit... */
 336     err = AudioUnitInitialize(data->audioUnit);
 337     if(err != noErr)
 338     {
 339         ERR("AudioUnitInitialize failed\n");
 340         return ALC_FALSE;
 341     }
 342
 343     return ALC_TRUE;
 344 }
 345
 346 static ALCboolean ca_start_playback(ALCdevice *device)
 347 {
 348     ca_data *data = (ca_data*)device->ExtraData;
 349     OSStatus err;
 350
 351     err = AudioOutputUnitStart(data->audioUnit);
 352     if(err != noErr)
 353     {
 354         ERR("AudioOutputUnitStart failed\n");
 355         return ALC_FALSE;
 356     }
 357
 358     return ALC_TRUE;
 359 }
 360
 361 static void ca_stop_playback(ALCdevice *device)
 362 {
 363     ca_data *data = (ca_data*)device->ExtraData;
 364     OSStatus err;
 365
 366     err = AudioOutputUnitStop(data->audioUnit);
 367     if(err != noErr)
 368         ERR("AudioOutputUnitStop failed\n");
 369 }
 370
 371 static ALCenum ca_open_capture(ALCdevice *device, const ALCchar *deviceName)
 372 {
 373     AudioStreamBasicDescription requestedFormat;  // The application requested format
 374     AudioStreamBasicDescription hardwareFormat;   // The hardware format
 375     AudioStreamBasicDescription outputFormat;     // The AudioUnit output format
 376     AURenderCallbackStruct input;
 377     ComponentDescription desc;
 378     AudioDeviceID inputDevice;
 379     UInt32 outputFrameCount;
 380     UInt32 propertySize;
 381     UInt32 enableIO;
 382     Component comp;
 383     ca_data *data;
 384     OSStatus err;
 385
 386     if(!deviceName)
 387         deviceName = ca_device;
 388     else if(strcmp(deviceName, ca_device) != 0)
 389         return ALC_INVALID_VALUE;
 390
 391     desc.componentType = kAudioUnitType_Output;
 392     desc.componentSubType = kAudioUnitSubType_HALOutput;
 393     desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 394     desc.componentFlags = 0;
 395     desc.componentFlagsMask = 0;
 396
 397     // Search for component with given description
 398     comp = FindNextComponent(NULL, &desc);
 399     if(comp == NULL)
 400     {
 401         ERR("FindNextComponent failed\n");
 402         return ALC_INVALID_VALUE;
 403     }
 404
 405     data = calloc(1, sizeof(*data));
 406     device->ExtraData = data;
 407
 408     // Open the component
 409     err = OpenAComponent(comp, &data->audioUnit);
 410     if(err != noErr)
 411     {
 412         ERR("OpenAComponent failed\n");
 413         goto error;
 414     }
 415
 416     // Turn off AudioUnit output
 417     enableIO = 0;
 418     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(ALuint));
 419     if(err != noErr)
 420     {
 421         ERR("AudioUnitSetProperty failed\n");
 422         goto error;
 423     }
 424
 425     // Turn on AudioUnit input
 426     enableIO = 1;
 427     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(ALuint));
 428     if(err != noErr)
 429     {
 430         ERR("AudioUnitSetProperty failed\n");
 431         goto error;
 432     }
 433
 434     // Get the default input device
 435     propertySize = sizeof(AudioDeviceID);
 436     err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &inputDevice);
 437     if(err != noErr)
 438     {
 439         ERR("AudioHardwareGetProperty failed\n");
 440         goto error;
 441     }
 442
 443     if(inputDevice == kAudioDeviceUnknown)
 444     {
 445         ERR("No input device found\n");
 446         goto error;
 447     }
 448
 449     // Track the input device
 450     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &inputDevice, sizeof(AudioDeviceID));
 451     if(err != noErr)
 452     {
 453         ERR("AudioUnitSetProperty failed\n");
 454         goto error;
 455     }
 456
 457     // set capture callback
 458     input.inputProc = ca_capture_callback;
 459     input.inputProcRefCon = device;
 460
 461     err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &input, sizeof(AURenderCallbackStruct));
 462     if(err != noErr)
 463     {
 464         ERR("AudioUnitSetProperty failed\n");
 465         goto error;
 466     }
 467
 468     // Initialize the device
 469     err = AudioUnitInitialize(data->audioUnit);
 470     if(err != noErr)
 471     {
 472         ERR("AudioUnitInitialize failed\n");
 473         goto error;
 474     }
 475
 476     // Get the hardware format
 477     propertySize = sizeof(AudioStreamBasicDescription);
 478     err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &hardwareFormat, &propertySize);
 479     if(err != noErr || propertySize != sizeof(AudioStreamBasicDescription))
 480     {
 481         ERR("AudioUnitGetProperty failed\n");
 482         goto error;
 483     }
 484
 485     // Set up the requested format description
 486     switch(device->FmtType)
 487     {
 488         case DevFmtUByte:
 489             requestedFormat.mBitsPerChannel = 8;
 490             requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
 491             break;
 492         case DevFmtShort:
 493             requestedFormat.mBitsPerChannel = 16;
 494             requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
 495             break;
 496         case DevFmtInt:
 497             requestedFormat.mBitsPerChannel = 32;
 498             requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
 499             break;
 500         case DevFmtFloat:
 501             requestedFormat.mBitsPerChannel = 32;
 502             requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
 503             break;
 504         case DevFmtByte:
 505         case DevFmtUShort:
 506         case DevFmtUInt:
 507             ERR("%s samples not supported\n", DevFmtTypeString(device->FmtType));
 508             goto error;
 509     }
 510
 511     switch(device->FmtChans)
 512     {
 513         case DevFmtMono:
 514             requestedFormat.mChannelsPerFrame = 1;
 515             break;
 516         case DevFmtStereo:
 517             requestedFormat.mChannelsPerFrame = 2;
 518             break;
 519
 520         case DevFmtQuad:
 521         case DevFmtX51:
 522         case DevFmtX51Rear:
 523         case DevFmtX61:
 524         case DevFmtX71:
 525             ERR("%s not supported\n", DevFmtChannelsString(device->FmtChans));
 526             goto error;
 527     }
 528
 529     requestedFormat.mBytesPerFrame = requestedFormat.mChannelsPerFrame * requestedFormat.mBitsPerChannel / 8;
 530     requestedFormat.mBytesPerPacket = requestedFormat.mBytesPerFrame;
 531     requestedFormat.mSampleRate = device->Frequency;
 532     requestedFormat.mFormatID = kAudioFormatLinearPCM;
 533     requestedFormat.mReserved = 0;
 534     requestedFormat.mFramesPerPacket = 1;
 535
 536     // save requested format description for later use
 537     data->format = requestedFormat;
 538     data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 539
 540     // Use intermediate format for sample rate conversion (outputFormat)
 541     // Set sample rate to the same as hardware for resampling later
 542     outputFormat = requestedFormat;
 543     outputFormat.mSampleRate = hardwareFormat.mSampleRate;
 544
 545     // Determine sample rate ratio for resampling
 546     data->sampleRateRatio = outputFormat.mSampleRate / device->Frequency;
 547
 548     // The output format should be the requested format, but using the hardware sample rate
 549     // This is because the AudioUnit will automatically scale other properties, except for sample rate
 550     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, (void *)&outputFormat, sizeof(outputFormat));
 551     if(err != noErr)
 552     {
 553         ERR("AudioUnitSetProperty failed\n");
 554         goto error;
 555     }
 556
 557     // Set the AudioUnit output format frame count
 558     outputFrameCount = device->UpdateSize * data->sampleRateRatio;
 559     err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Output, 0, &outputFrameCount, sizeof(outputFrameCount));
 560     if(err != noErr)
 561     {
 562         ERR("AudioUnitSetProperty failed: %d\n", err);
 563         goto error;
 564     }
 565
 566     // Set up sample converter
 567     err = AudioConverterNew(&outputFormat, &requestedFormat, &data->audioConverter);
 568     if(err != noErr)
 569     {
 570         ERR("AudioConverterNew failed: %d\n", err);
 571         goto error;
 572     }
 573
 574     // Create a buffer for use in the resample callback
 575     data->resampleBuffer = malloc(device->UpdateSize * data->frameSize * data->sampleRateRatio);
 576
 577     // Allocate buffer for the AudioUnit output
 578     data->bufferList = allocate_buffer_list(outputFormat.mChannelsPerFrame, device->UpdateSize * data->frameSize * data->sampleRateRatio);
 579     if(data->bufferList == NULL)
 580         goto error;
 581
 582     data->ring = CreateRingBuffer(data->frameSize, (device->UpdateSize * data->sampleRateRatio) * device->NumUpdates);
 583     if(data->ring == NULL)
 584         goto error;
 585
 586     al_string_copy_cstr(&device->DeviceName, deviceName);
 587
 588     return ALC_NO_ERROR;
 589
 590 error:
 591     DestroyRingBuffer(data->ring);
 592     free(data->resampleBuffer);
 593     destroy_buffer_list(data->bufferList);
 594
 595     if(data->audioConverter)
 596         AudioConverterDispose(data->audioConverter);
 597     if(data->audioUnit)
 598         CloseComponent(data->audioUnit);
 599
 600     free(data);
 601     device->ExtraData = NULL;
 602
 603     return ALC_INVALID_VALUE;
 604 }
 605
 606 static void ca_close_capture(ALCdevice *device)
 607 {
 608     ca_data *data = (ca_data*)device->ExtraData;
 609
 610     DestroyRingBuffer(data->ring);
 611     free(data->resampleBuffer);
 612     destroy_buffer_list(data->bufferList);
 613
 614     AudioConverterDispose(data->audioConverter);
 615     CloseComponent(data->audioUnit);
 616
 617     free(data);
 618     device->ExtraData = NULL;
 619 }
 620
 621 static void ca_start_capture(ALCdevice *device)
 622 {
 623     ca_data *data = (ca_data*)device->ExtraData;
 624     OSStatus err = AudioOutputUnitStart(data->audioUnit);
 625     if(err != noErr)
 626         ERR("AudioOutputUnitStart failed\n");
 627 }
 628
 629 static void ca_stop_capture(ALCdevice *device)
 630 {
 631     ca_data *data = (ca_data*)device->ExtraData;
 632     OSStatus err = AudioOutputUnitStop(data->audioUnit);
 633     if(err != noErr)
 634         ERR("AudioOutputUnitStop failed\n");
 635 }
 636
 637 static ALCenum ca_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
 638 {
 639     ca_data *data = (ca_data*)device->ExtraData;
 640     AudioBufferList *list;
 641     UInt32 frameCount;
 642     OSStatus err;
 643
 644     // If no samples are requested, just return
 645     if(samples == 0)
 646         return ALC_NO_ERROR;
 647
 648     // Allocate a temporary AudioBufferList to use as the return resamples data
 649     list = alloca(sizeof(AudioBufferList) + sizeof(AudioBuffer));
 650
 651     // Point the resampling buffer to the capture buffer
 652     list->mNumberBuffers = 1;
 653     list->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
 654     list->mBuffers[0].mDataByteSize = samples * data->frameSize;
 655     list->mBuffers[0].mData = buffer;
 656
 657     // Resample into another AudioBufferList
 658     frameCount = samples;
 659     err = AudioConverterFillComplexBuffer(data->audioConverter, ca_capture_conversion_callback,
 660                                           device, &frameCount, list, NULL);
 661     if(err != noErr)
 662     {
 663         ERR("AudioConverterFillComplexBuffer error: %d\n", err);
 664         return ALC_INVALID_VALUE;
 665     }
 666     return ALC_NO_ERROR;
 667 }
 668
 669 static ALCuint ca_available_samples(ALCdevice *device)
 670 {
 671     ca_data *data = device->ExtraData;
 672     return RingBufferSize(data->ring) / data->sampleRateRatio;
 673 }
 674
 675
 676 static const BackendFuncs ca_funcs = {
 677     ca_open_playback,
 678     ca_close_playback,
 679     ca_reset_playback,
 680     ca_start_playback,
 681     ca_stop_playback,
 682     ca_open_capture,
 683     ca_close_capture,
 684     ca_start_capture,
 685     ca_stop_capture,
 686     ca_capture_samples,
 687     ca_available_samples
 688 };
 689
 690 ALCboolean alc_ca_init(BackendFuncs *func_list)
 691 {
 692     *func_list = ca_funcs;
 693     return ALC_TRUE;
 694 }
 695
 696 void alc_ca_deinit(void)
 697 {
 698 }
 699
 700 void alc_ca_probe(enum DevProbe type)
 701 {
 702     switch(type)
 703     {
 704         case ALL_DEVICE_PROBE:
 705             AppendAllDevicesList(ca_device);
 706             break;
 707         case CAPTURE_DEVICE_PROBE:
 708             AppendCaptureDeviceList(ca_device);
 709             break;
 710     }
 711 }