audio/coreaudio.c

   1 /*
   2  * QEMU OS X CoreAudio audio driver
   3  *
   4  * Copyright (c) 2005 Mike Kronenberg
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include <CoreAudio/CoreAudio.h>
  27 #include <pthread.h>            /* pthread_X */
  28
  29 #include "qemu/module.h"
  30 #include "audio.h"
  31
  32 #define AUDIO_CAP "coreaudio"
  33 #include "audio_int.h"
  34
  35 #ifndef MAC_OS_X_VERSION_10_6
  36 #define MAC_OS_X_VERSION_10_6 1060
  37 #endif
  38
  39 typedef struct coreaudioVoiceOut {
  40     HWVoiceOut hw;
  41     pthread_mutex_t mutex;
  42     AudioDeviceID outputDeviceID;
  43     UInt32 audioDevicePropertyBufferFrameSize;
  44     AudioStreamBasicDescription outputStreamBasicDescription;
  45     AudioDeviceIOProcID ioprocid;
  46     size_t live;
  47     size_t decr;
  48     size_t rpos;
  49 } coreaudioVoiceOut;
  50
  51 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
  52 /* The APIs used here only become available from 10.6 */
  53
  54 static OSStatus coreaudio_get_voice(AudioDeviceID *id)
  55 {
  56     UInt32 size = sizeof(*id);
  57     AudioObjectPropertyAddress addr = {
  58         kAudioHardwarePropertyDefaultOutputDevice,
  59         kAudioObjectPropertyScopeGlobal,
  60         kAudioObjectPropertyElementMaster
  61     };
  62
  63     return AudioObjectGetPropertyData(kAudioObjectSystemObject,
  64                                       &addr,
  65                                       0,
  66                                       NULL,
  67                                       &size,
  68                                       id);
  69 }
  70
  71 static OSStatus coreaudio_get_framesizerange(AudioDeviceID id,
  72                                              AudioValueRange *framerange)
  73 {
  74     UInt32 size = sizeof(*framerange);
  75     AudioObjectPropertyAddress addr = {
  76         kAudioDevicePropertyBufferFrameSizeRange,
  77         kAudioDevicePropertyScopeOutput,
  78         kAudioObjectPropertyElementMaster
  79     };
  80
  81     return AudioObjectGetPropertyData(id,
  82                                       &addr,
  83                                       0,
  84                                       NULL,
  85                                       &size,
  86                                       framerange);
  87 }
  88
  89 static OSStatus coreaudio_get_framesize(AudioDeviceID id, UInt32 *framesize)
  90 {
  91     UInt32 size = sizeof(*framesize);
  92     AudioObjectPropertyAddress addr = {
  93         kAudioDevicePropertyBufferFrameSize,
  94         kAudioDevicePropertyScopeOutput,
  95         kAudioObjectPropertyElementMaster
  96     };
  97
  98     return AudioObjectGetPropertyData(id,
  99                                       &addr,
 100                                       0,
 101                                       NULL,
 102                                       &size,
 103                                       framesize);
 104 }
 105
 106 static OSStatus coreaudio_set_framesize(AudioDeviceID id, UInt32 *framesize)
 107 {
 108     UInt32 size = sizeof(*framesize);
 109     AudioObjectPropertyAddress addr = {
 110         kAudioDevicePropertyBufferFrameSize,
 111         kAudioDevicePropertyScopeOutput,
 112         kAudioObjectPropertyElementMaster
 113     };
 114
 115     return AudioObjectSetPropertyData(id,
 116                                       &addr,
 117                                       0,
 118                                       NULL,
 119                                       size,
 120                                       framesize);
 121 }
 122
 123 static OSStatus coreaudio_get_streamformat(AudioDeviceID id,
 124                                            AudioStreamBasicDescription *d)
 125 {
 126     UInt32 size = sizeof(*d);
 127     AudioObjectPropertyAddress addr = {
 128         kAudioDevicePropertyStreamFormat,
 129         kAudioDevicePropertyScopeOutput,
 130         kAudioObjectPropertyElementMaster
 131     };
 132
 133     return AudioObjectGetPropertyData(id,
 134                                       &addr,
 135                                       0,
 136                                       NULL,
 137                                       &size,
 138                                       d);
 139 }
 140
 141 static OSStatus coreaudio_set_streamformat(AudioDeviceID id,
 142                                            AudioStreamBasicDescription *d)
 143 {
 144     UInt32 size = sizeof(*d);
 145     AudioObjectPropertyAddress addr = {
 146         kAudioDevicePropertyStreamFormat,
 147         kAudioDevicePropertyScopeOutput,
 148         kAudioObjectPropertyElementMaster
 149     };
 150
 151     return AudioObjectSetPropertyData(id,
 152                                       &addr,
 153                                       0,
 154                                       NULL,
 155                                       size,
 156                                       d);
 157 }
 158
 159 static OSStatus coreaudio_get_isrunning(AudioDeviceID id, UInt32 *result)
 160 {
 161     UInt32 size = sizeof(*result);
 162     AudioObjectPropertyAddress addr = {
 163         kAudioDevicePropertyDeviceIsRunning,
 164         kAudioDevicePropertyScopeOutput,
 165         kAudioObjectPropertyElementMaster
 166     };
 167
 168     return AudioObjectGetPropertyData(id,
 169                                       &addr,
 170                                       0,
 171                                       NULL,
 172                                       &size,
 173                                       result);
 174 }
 175 #else
 176 /* Legacy versions of functions using deprecated APIs */
 177
 178 static OSStatus coreaudio_get_voice(AudioDeviceID *id)
 179 {
 180     UInt32 size = sizeof(*id);
 181
 182     return AudioHardwareGetProperty(
 183         kAudioHardwarePropertyDefaultOutputDevice,
 184         &size,
 185         id);
 186 }
 187
 188 static OSStatus coreaudio_get_framesizerange(AudioDeviceID id,
 189                                              AudioValueRange *framerange)
 190 {
 191     UInt32 size = sizeof(*framerange);
 192
 193     return AudioDeviceGetProperty(
 194         id,
 195         0,
 196         0,
 197         kAudioDevicePropertyBufferFrameSizeRange,
 198         &size,
 199         framerange);
 200 }
 201
 202 static OSStatus coreaudio_get_framesize(AudioDeviceID id, UInt32 *framesize)
 203 {
 204     UInt32 size = sizeof(*framesize);
 205
 206     return AudioDeviceGetProperty(
 207         id,
 208         0,
 209         false,
 210         kAudioDevicePropertyBufferFrameSize,
 211         &size,
 212         framesize);
 213 }
 214
 215 static OSStatus coreaudio_set_framesize(AudioDeviceID id, UInt32 *framesize)
 216 {
 217     UInt32 size = sizeof(*framesize);
 218
 219     return AudioDeviceSetProperty(
 220         id,
 221         NULL,
 222         0,
 223         false,
 224         kAudioDevicePropertyBufferFrameSize,
 225         size,
 226         framesize);
 227 }
 228
 229 static OSStatus coreaudio_get_streamformat(AudioDeviceID id,
 230                                            AudioStreamBasicDescription *d)
 231 {
 232     UInt32 size = sizeof(*d);
 233
 234     return AudioDeviceGetProperty(
 235         id,
 236         0,
 237         false,
 238         kAudioDevicePropertyStreamFormat,
 239         &size,
 240         d);
 241 }
 242
 243 static OSStatus coreaudio_set_streamformat(AudioDeviceID id,
 244                                            AudioStreamBasicDescription *d)
 245 {
 246     UInt32 size = sizeof(*d);
 247
 248     return AudioDeviceSetProperty(
 249         id,
 250         0,
 251         0,
 252         0,
 253         kAudioDevicePropertyStreamFormat,
 254         size,
 255         d);
 256 }
 257
 258 static OSStatus coreaudio_get_isrunning(AudioDeviceID id, UInt32 *result)
 259 {
 260     UInt32 size = sizeof(*result);
 261
 262     return AudioDeviceGetProperty(
 263         id,
 264         0,
 265         0,
 266         kAudioDevicePropertyDeviceIsRunning,
 267         &size,
 268         result);
 269 }
 270 #endif
 271
 272 static void coreaudio_logstatus (OSStatus status)
 273 {
 274     const char *str = "BUG";
 275
 276     switch(status) {
 277     case kAudioHardwareNoError:
 278         str = "kAudioHardwareNoError";
 279         break;
 280
 281     case kAudioHardwareNotRunningError:
 282         str = "kAudioHardwareNotRunningError";
 283         break;
 284
 285     case kAudioHardwareUnspecifiedError:
 286         str = "kAudioHardwareUnspecifiedError";
 287         break;
 288
 289     case kAudioHardwareUnknownPropertyError:
 290         str = "kAudioHardwareUnknownPropertyError";
 291         break;
 292
 293     case kAudioHardwareBadPropertySizeError:
 294         str = "kAudioHardwareBadPropertySizeError";
 295         break;
 296
 297     case kAudioHardwareIllegalOperationError:
 298         str = "kAudioHardwareIllegalOperationError";
 299         break;
 300
 301     case kAudioHardwareBadDeviceError:
 302         str = "kAudioHardwareBadDeviceError";
 303         break;
 304
 305     case kAudioHardwareBadStreamError:
 306         str = "kAudioHardwareBadStreamError";
 307         break;
 308
 309     case kAudioHardwareUnsupportedOperationError:
 310         str = "kAudioHardwareUnsupportedOperationError";
 311         break;
 312
 313     case kAudioDeviceUnsupportedFormatError:
 314         str = "kAudioDeviceUnsupportedFormatError";
 315         break;
 316
 317     case kAudioDevicePermissionsError:
 318         str = "kAudioDevicePermissionsError";
 319         break;
 320
 321     default:
 322         AUD_log (AUDIO_CAP, "Reason: status code %" PRId32 "\n", (int32_t)status);
 323         return;
 324     }
 325
 326     AUD_log (AUDIO_CAP, "Reason: %s\n", str);
 327 }
 328
 329 static void GCC_FMT_ATTR (2, 3) coreaudio_logerr (
 330     OSStatus status,
 331     const char *fmt,
 332     ...
 333     )
 334 {
 335     va_list ap;
 336
 337     va_start (ap, fmt);
 338     AUD_log (AUDIO_CAP, fmt, ap);
 339     va_end (ap);
 340
 341     coreaudio_logstatus (status);
 342 }
 343
 344 static void GCC_FMT_ATTR (3, 4) coreaudio_logerr2 (
 345     OSStatus status,
 346     const char *typ,
 347     const char *fmt,
 348     ...
 349     )
 350 {
 351     va_list ap;
 352
 353     AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
 354
 355     va_start (ap, fmt);
 356     AUD_vlog (AUDIO_CAP, fmt, ap);
 357     va_end (ap);
 358
 359     coreaudio_logstatus (status);
 360 }
 361
 362 static inline UInt32 isPlaying (AudioDeviceID outputDeviceID)
 363 {
 364     OSStatus status;
 365     UInt32 result = 0;
 366     status = coreaudio_get_isrunning(outputDeviceID, &result);
 367     if (status != kAudioHardwareNoError) {
 368         coreaudio_logerr(status,
 369                          "Could not determine whether Device is playing\n");
 370     }
 371     return result;
 372 }
 373
 374 static int coreaudio_lock (coreaudioVoiceOut *core, const char *fn_name)
 375 {
 376     int err;
 377
 378     err = pthread_mutex_lock (&core->mutex);
 379     if (err) {
 380         dolog ("Could not lock voice for %s\nReason: %s\n",
 381                fn_name, strerror (err));
 382         return -1;
 383     }
 384     return 0;
 385 }
 386
 387 static int coreaudio_unlock (coreaudioVoiceOut *core, const char *fn_name)
 388 {
 389     int err;
 390
 391     err = pthread_mutex_unlock (&core->mutex);
 392     if (err) {
 393         dolog ("Could not unlock voice for %s\nReason: %s\n",
 394                fn_name, strerror (err));
 395         return -1;
 396     }
 397     return 0;
 398 }
 399
 400 static size_t coreaudio_run_out(HWVoiceOut *hw, size_t live)
 401 {
 402     size_t decr;
 403     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
 404
 405     if (coreaudio_lock (core, "coreaudio_run_out")) {
 406         return 0;
 407     }
 408
 409     if (core->decr > live) {
 410         ldebug ("core->decr %d live %d core->live %d\n",
 411                 core->decr,
 412                 live,
 413                 core->live);
 414     }
 415
 416     decr = MIN (core->decr, live);
 417     core->decr -= decr;
 418
 419     core->live = live - decr;
 420     hw->rpos = core->rpos;
 421
 422     coreaudio_unlock (core, "coreaudio_run_out");
 423     return decr;
 424 }
 425
 426 /* callback to feed audiooutput buffer */
 427 static OSStatus audioDeviceIOProc(
 428     AudioDeviceID inDevice,
 429     const AudioTimeStamp* inNow,
 430     const AudioBufferList* inInputData,
 431     const AudioTimeStamp* inInputTime,
 432     AudioBufferList* outOutputData,
 433     const AudioTimeStamp* inOutputTime,
 434     void* hwptr)
 435 {
 436     UInt32 frame, frameCount;
 437     float *out = outOutputData->mBuffers[0].mData;
 438     HWVoiceOut *hw = hwptr;
 439     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hwptr;
 440     int rpos, live;
 441     struct st_sample *src;
 442 #ifndef FLOAT_MIXENG
 443 #ifdef RECIPROCAL
 444     const float scale = 1.f / UINT_MAX;
 445 #else
 446     const float scale = UINT_MAX;
 447 #endif
 448 #endif
 449
 450     if (coreaudio_lock (core, "audioDeviceIOProc")) {
 451         inInputTime = 0;
 452         return 0;
 453     }
 454
 455     frameCount = core->audioDevicePropertyBufferFrameSize;
 456     live = core->live;
 457
 458     /* if there are not enough samples, set signal and return */
 459     if (live < frameCount) {
 460         inInputTime = 0;
 461         coreaudio_unlock (core, "audioDeviceIOProc(empty)");
 462         return 0;
 463     }
 464
 465     rpos = core->rpos;
 466     src = hw->mix_buf + rpos;
 467
 468     /* fill buffer */
 469     for (frame = 0; frame < frameCount; frame++) {
 470 #ifdef FLOAT_MIXENG
 471         *out++ = src[frame].l; /* left channel */
 472         *out++ = src[frame].r; /* right channel */
 473 #else
 474 #ifdef RECIPROCAL
 475         *out++ = src[frame].l * scale; /* left channel */
 476         *out++ = src[frame].r * scale; /* right channel */
 477 #else
 478         *out++ = src[frame].l / scale; /* left channel */
 479         *out++ = src[frame].r / scale; /* right channel */
 480 #endif
 481 #endif
 482     }
 483
 484     rpos = (rpos + frameCount) % hw->samples;
 485     core->decr += frameCount;
 486     core->rpos = rpos;
 487
 488     coreaudio_unlock (core, "audioDeviceIOProc");
 489     return 0;
 490 }
 491
 492 static int coreaudio_init_out(HWVoiceOut *hw, struct audsettings *as,
 493                               void *drv_opaque)
 494 {
 495     OSStatus status;
 496     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
 497     int err;
 498     const char *typ = "playback";
 499     AudioValueRange frameRange;
 500     Audiodev *dev = drv_opaque;
 501     AudiodevCoreaudioPerDirectionOptions *cpdo = dev->u.coreaudio.out;
 502     int frames;
 503
 504     /* create mutex */
 505     err = pthread_mutex_init(&core->mutex, NULL);
 506     if (err) {
 507         dolog("Could not create mutex\nReason: %s\n", strerror (err));
 508         return -1;
 509     }
 510
 511     audio_pcm_init_info (&hw->info, as);
 512
 513     status = coreaudio_get_voice(&core->outputDeviceID);
 514     if (status != kAudioHardwareNoError) {
 515         coreaudio_logerr2 (status, typ,
 516                            "Could not get default output Device\n");
 517         return -1;
 518     }
 519     if (core->outputDeviceID == kAudioDeviceUnknown) {
 520         dolog ("Could not initialize %s - Unknown Audiodevice\n", typ);
 521         return -1;
 522     }
 523
 524     /* get minimum and maximum buffer frame sizes */
 525     status = coreaudio_get_framesizerange(core->outputDeviceID,
 526                                           &frameRange);
 527     if (status != kAudioHardwareNoError) {
 528         coreaudio_logerr2 (status, typ,
 529                            "Could not get device buffer frame range\n");
 530         return -1;
 531     }
 532
 533     frames = audio_buffer_frames(
 534         qapi_AudiodevCoreaudioPerDirectionOptions_base(cpdo), as, 11610);
 535     if (frameRange.mMinimum > frames) {
 536         core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMinimum;
 537         dolog ("warning: Upsizing Buffer Frames to %f\n", frameRange.mMinimum);
 538     } else if (frameRange.mMaximum < frames) {
 539         core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMaximum;
 540         dolog ("warning: Downsizing Buffer Frames to %f\n", frameRange.mMaximum);
 541     }
 542     else {
 543         core->audioDevicePropertyBufferFrameSize = frames;
 544     }
 545
 546     /* set Buffer Frame Size */
 547     status = coreaudio_set_framesize(core->outputDeviceID,
 548                                      &core->audioDevicePropertyBufferFrameSize);
 549     if (status != kAudioHardwareNoError) {
 550         coreaudio_logerr2 (status, typ,
 551                            "Could not set device buffer frame size %" PRIu32 "\n",
 552                            (uint32_t)core->audioDevicePropertyBufferFrameSize);
 553         return -1;
 554     }
 555
 556     /* get Buffer Frame Size */
 557     status = coreaudio_get_framesize(core->outputDeviceID,
 558                                      &core->audioDevicePropertyBufferFrameSize);
 559     if (status != kAudioHardwareNoError) {
 560         coreaudio_logerr2 (status, typ,
 561                            "Could not get device buffer frame size\n");
 562         return -1;
 563     }
 564     hw->samples = (cpdo->has_buffer_count ? cpdo->buffer_count : 4) *
 565         core->audioDevicePropertyBufferFrameSize;
 566
 567     /* get StreamFormat */
 568     status = coreaudio_get_streamformat(core->outputDeviceID,
 569                                         &core->outputStreamBasicDescription);
 570     if (status != kAudioHardwareNoError) {
 571         coreaudio_logerr2 (status, typ,
 572                            "Could not get Device Stream properties\n");
 573         core->outputDeviceID = kAudioDeviceUnknown;
 574         return -1;
 575     }
 576
 577     /* set Samplerate */
 578     core->outputStreamBasicDescription.mSampleRate = (Float64) as->freq;
 579     status = coreaudio_set_streamformat(core->outputDeviceID,
 580                                         &core->outputStreamBasicDescription);
 581     if (status != kAudioHardwareNoError) {
 582         coreaudio_logerr2 (status, typ, "Could not set samplerate %d\n",
 583                            as->freq);
 584         core->outputDeviceID = kAudioDeviceUnknown;
 585         return -1;
 586     }
 587
 588     /* set Callback */
 589     core->ioprocid = NULL;
 590     status = AudioDeviceCreateIOProcID(core->outputDeviceID,
 591                                        audioDeviceIOProc,
 592                                        hw,
 593                                        &core->ioprocid);
 594     if (status != kAudioHardwareNoError || core->ioprocid == NULL) {
 595         coreaudio_logerr2 (status, typ, "Could not set IOProc\n");
 596         core->outputDeviceID = kAudioDeviceUnknown;
 597         return -1;
 598     }
 599
 600     /* start Playback */
 601     if (!isPlaying(core->outputDeviceID)) {
 602         status = AudioDeviceStart(core->outputDeviceID, core->ioprocid);
 603         if (status != kAudioHardwareNoError) {
 604             coreaudio_logerr2 (status, typ, "Could not start playback\n");
 605             AudioDeviceDestroyIOProcID(core->outputDeviceID, core->ioprocid);
 606             core->outputDeviceID = kAudioDeviceUnknown;
 607             return -1;
 608         }
 609     }
 610
 611     return 0;
 612 }
 613
 614 static void coreaudio_fini_out (HWVoiceOut *hw)
 615 {
 616     OSStatus status;
 617     int err;
 618     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
 619
 620     if (!audio_is_cleaning_up()) {
 621         /* stop playback */
 622         if (isPlaying(core->outputDeviceID)) {
 623             status = AudioDeviceStop(core->outputDeviceID, core->ioprocid);
 624             if (status != kAudioHardwareNoError) {
 625                 coreaudio_logerr (status, "Could not stop playback\n");
 626             }
 627         }
 628
 629         /* remove callback */
 630         status = AudioDeviceDestroyIOProcID(core->outputDeviceID,
 631                                             core->ioprocid);
 632         if (status != kAudioHardwareNoError) {
 633             coreaudio_logerr (status, "Could not remove IOProc\n");
 634         }
 635     }
 636     core->outputDeviceID = kAudioDeviceUnknown;
 637
 638     /* destroy mutex */
 639     err = pthread_mutex_destroy(&core->mutex);
 640     if (err) {
 641         dolog("Could not destroy mutex\nReason: %s\n", strerror (err));
 642     }
 643 }
 644
 645 static int coreaudio_ctl_out (HWVoiceOut *hw, int cmd, ...)
 646 {
 647     OSStatus status;
 648     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
 649
 650     switch (cmd) {
 651     case VOICE_ENABLE:
 652         /* start playback */
 653         if (!isPlaying(core->outputDeviceID)) {
 654             status = AudioDeviceStart(core->outputDeviceID, core->ioprocid);
 655             if (status != kAudioHardwareNoError) {
 656                 coreaudio_logerr (status, "Could not resume playback\n");
 657             }
 658         }
 659         break;
 660
 661     case VOICE_DISABLE:
 662         /* stop playback */
 663         if (!audio_is_cleaning_up()) {
 664             if (isPlaying(core->outputDeviceID)) {
 665                 status = AudioDeviceStop(core->outputDeviceID,
 666                                          core->ioprocid);
 667                 if (status != kAudioHardwareNoError) {
 668                     coreaudio_logerr (status, "Could not pause playback\n");
 669                 }
 670             }
 671         }
 672         break;
 673     }
 674     return 0;
 675 }
 676
 677 static void *coreaudio_audio_init(Audiodev *dev)
 678 {
 679     return dev;
 680 }
 681
 682 static void coreaudio_audio_fini (void *opaque)
 683 {
 684 }
 685
 686 static struct audio_pcm_ops coreaudio_pcm_ops = {
 687     .init_out = coreaudio_init_out,
 688     .fini_out = coreaudio_fini_out,
 689     .run_out  = coreaudio_run_out,
 690     .ctl_out  = coreaudio_ctl_out
 691 };
 692
 693 static struct audio_driver coreaudio_audio_driver = {
 694     .name           = "coreaudio",
 695     .descr          = "CoreAudio http://developer.apple.com/audio/coreaudio.html",
 696     .init           = coreaudio_audio_init,
 697     .fini           = coreaudio_audio_fini,
 698     .pcm_ops        = &coreaudio_pcm_ops,
 699     .can_be_default = 1,
 700     .max_voices_out = 1,
 701     .max_voices_in  = 0,
 702     .voice_size_out = sizeof (coreaudioVoiceOut),
 703     .voice_size_in  = 0
 704 };
 705
 706 static void register_audio_coreaudio(void)
 707 {
 708     audio_driver_register(&coreaudio_audio_driver);
 709 }
 710 type_init(register_audio_coreaudio);