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