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/main-loop.h"
  30 #include "qemu/module.h"
  31 #include "audio.h"
  32
  33 #define AUDIO_CAP "coreaudio"
  34 #include "audio_int.h"
  35
  36 typedef struct coreaudioVoiceOut {
  37     HWVoiceOut hw;
  38     pthread_mutex_t buf_mutex;
  39     AudioDeviceID outputDeviceID;
  40     int frameSizeSetting;
  41     uint32_t bufferCount;
  42     UInt32 audioDevicePropertyBufferFrameSize;
  43     AudioDeviceIOProcID ioprocid;
  44     bool enabled;
  45 } coreaudioVoiceOut;
  46
  47 static const AudioObjectPropertyAddress voice_addr = {
  48     kAudioHardwarePropertyDefaultOutputDevice,
  49     kAudioObjectPropertyScopeGlobal,
  50     kAudioObjectPropertyElementMaster
  51 };
  52
  53 static OSStatus coreaudio_get_voice(AudioDeviceID *id)
  54 {
  55     UInt32 size = sizeof(*id);
  56
  57     return AudioObjectGetPropertyData(kAudioObjectSystemObject,
  58                                       &voice_addr,
  59                                       0,
  60                                       NULL,
  61                                       &size,
  62                                       id);
  63 }
  64
  65 static OSStatus coreaudio_get_framesizerange(AudioDeviceID id,
  66                                              AudioValueRange *framerange)
  67 {
  68     UInt32 size = sizeof(*framerange);
  69     AudioObjectPropertyAddress addr = {
  70         kAudioDevicePropertyBufferFrameSizeRange,
  71         kAudioDevicePropertyScopeOutput,
  72         kAudioObjectPropertyElementMaster
  73     };
  74
  75     return AudioObjectGetPropertyData(id,
  76                                       &addr,
  77                                       0,
  78                                       NULL,
  79                                       &size,
  80                                       framerange);
  81 }
  82
  83 static OSStatus coreaudio_get_framesize(AudioDeviceID id, UInt32 *framesize)
  84 {
  85     UInt32 size = sizeof(*framesize);
  86     AudioObjectPropertyAddress addr = {
  87         kAudioDevicePropertyBufferFrameSize,
  88         kAudioDevicePropertyScopeOutput,
  89         kAudioObjectPropertyElementMaster
  90     };
  91
  92     return AudioObjectGetPropertyData(id,
  93                                       &addr,
  94                                       0,
  95                                       NULL,
  96                                       &size,
  97                                       framesize);
  98 }
  99
 100 static OSStatus coreaudio_set_framesize(AudioDeviceID id, UInt32 *framesize)
 101 {
 102     UInt32 size = sizeof(*framesize);
 103     AudioObjectPropertyAddress addr = {
 104         kAudioDevicePropertyBufferFrameSize,
 105         kAudioDevicePropertyScopeOutput,
 106         kAudioObjectPropertyElementMaster
 107     };
 108
 109     return AudioObjectSetPropertyData(id,
 110                                       &addr,
 111                                       0,
 112                                       NULL,
 113                                       size,
 114                                       framesize);
 115 }
 116
 117 static OSStatus coreaudio_set_streamformat(AudioDeviceID id,
 118                                            AudioStreamBasicDescription *d)
 119 {
 120     UInt32 size = sizeof(*d);
 121     AudioObjectPropertyAddress addr = {
 122         kAudioDevicePropertyStreamFormat,
 123         kAudioDevicePropertyScopeOutput,
 124         kAudioObjectPropertyElementMaster
 125     };
 126
 127     return AudioObjectSetPropertyData(id,
 128                                       &addr,
 129                                       0,
 130                                       NULL,
 131                                       size,
 132                                       d);
 133 }
 134
 135 static OSStatus coreaudio_get_isrunning(AudioDeviceID id, UInt32 *result)
 136 {
 137     UInt32 size = sizeof(*result);
 138     AudioObjectPropertyAddress addr = {
 139         kAudioDevicePropertyDeviceIsRunning,
 140         kAudioDevicePropertyScopeOutput,
 141         kAudioObjectPropertyElementMaster
 142     };
 143
 144     return AudioObjectGetPropertyData(id,
 145                                       &addr,
 146                                       0,
 147                                       NULL,
 148                                       &size,
 149                                       result);
 150 }
 151
 152 static void coreaudio_logstatus (OSStatus status)
 153 {
 154     const char *str = "BUG";
 155
 156     switch (status) {
 157     case kAudioHardwareNoError:
 158         str = "kAudioHardwareNoError";
 159         break;
 160
 161     case kAudioHardwareNotRunningError:
 162         str = "kAudioHardwareNotRunningError";
 163         break;
 164
 165     case kAudioHardwareUnspecifiedError:
 166         str = "kAudioHardwareUnspecifiedError";
 167         break;
 168
 169     case kAudioHardwareUnknownPropertyError:
 170         str = "kAudioHardwareUnknownPropertyError";
 171         break;
 172
 173     case kAudioHardwareBadPropertySizeError:
 174         str = "kAudioHardwareBadPropertySizeError";
 175         break;
 176
 177     case kAudioHardwareIllegalOperationError:
 178         str = "kAudioHardwareIllegalOperationError";
 179         break;
 180
 181     case kAudioHardwareBadDeviceError:
 182         str = "kAudioHardwareBadDeviceError";
 183         break;
 184
 185     case kAudioHardwareBadStreamError:
 186         str = "kAudioHardwareBadStreamError";
 187         break;
 188
 189     case kAudioHardwareUnsupportedOperationError:
 190         str = "kAudioHardwareUnsupportedOperationError";
 191         break;
 192
 193     case kAudioDeviceUnsupportedFormatError:
 194         str = "kAudioDeviceUnsupportedFormatError";
 195         break;
 196
 197     case kAudioDevicePermissionsError:
 198         str = "kAudioDevicePermissionsError";
 199         break;
 200
 201     default:
 202         AUD_log (AUDIO_CAP, "Reason: status code %" PRId32 "\n", (int32_t)status);
 203         return;
 204     }
 205
 206     AUD_log (AUDIO_CAP, "Reason: %s\n", str);
 207 }
 208
 209 static void GCC_FMT_ATTR (2, 3) coreaudio_logerr (
 210     OSStatus status,
 211     const char *fmt,
 212     ...
 213     )
 214 {
 215     va_list ap;
 216
 217     va_start (ap, fmt);
 218     AUD_log (AUDIO_CAP, fmt, ap);
 219     va_end (ap);
 220
 221     coreaudio_logstatus (status);
 222 }
 223
 224 static void GCC_FMT_ATTR (3, 4) coreaudio_logerr2 (
 225     OSStatus status,
 226     const char *typ,
 227     const char *fmt,
 228     ...
 229     )
 230 {
 231     va_list ap;
 232
 233     AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
 234
 235     va_start (ap, fmt);
 236     AUD_vlog (AUDIO_CAP, fmt, ap);
 237     va_end (ap);
 238
 239     coreaudio_logstatus (status);
 240 }
 241
 242 #define coreaudio_playback_logerr(status, ...) \
 243     coreaudio_logerr2(status, "playback", __VA_ARGS__)
 244
 245 static int coreaudio_buf_lock (coreaudioVoiceOut *core, const char *fn_name)
 246 {
 247     int err;
 248
 249     err = pthread_mutex_lock (&core->buf_mutex);
 250     if (err) {
 251         dolog ("Could not lock voice for %s\nReason: %s\n",
 252                fn_name, strerror (err));
 253         return -1;
 254     }
 255     return 0;
 256 }
 257
 258 static int coreaudio_buf_unlock (coreaudioVoiceOut *core, const char *fn_name)
 259 {
 260     int err;
 261
 262     err = pthread_mutex_unlock (&core->buf_mutex);
 263     if (err) {
 264         dolog ("Could not unlock voice for %s\nReason: %s\n",
 265                fn_name, strerror (err));
 266         return -1;
 267     }
 268     return 0;
 269 }
 270
 271 #define COREAUDIO_WRAPPER_FUNC(name, ret_type, args_decl, args) \
 272     static ret_type glue(coreaudio_, name)args_decl             \
 273     {                                                           \
 274         coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;     \
 275         ret_type ret;                                           \
 276                                                                 \
 277         if (coreaudio_buf_lock(core, "coreaudio_" #name)) {         \
 278             return 0;                                           \
 279         }                                                       \
 280                                                                 \
 281         ret = glue(audio_generic_, name)args;                   \
 282                                                                 \
 283         coreaudio_buf_unlock(core, "coreaudio_" #name);             \
 284         return ret;                                             \
 285     }
 286 COREAUDIO_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
 287                        (hw, size))
 288 COREAUDIO_WRAPPER_FUNC(put_buffer_out, size_t,
 289                        (HWVoiceOut *hw, void *buf, size_t size),
 290                        (hw, buf, size))
 291 COREAUDIO_WRAPPER_FUNC(write, size_t, (HWVoiceOut *hw, void *buf, size_t size),
 292                        (hw, buf, size))
 293 #undef COREAUDIO_WRAPPER_FUNC
 294
 295 /*
 296  * callback to feed audiooutput buffer. called without iothread lock.
 297  * allowed to lock "buf_mutex", but disallowed to have any other locks.
 298  */
 299 static OSStatus audioDeviceIOProc(
 300     AudioDeviceID inDevice,
 301     const AudioTimeStamp *inNow,
 302     const AudioBufferList *inInputData,
 303     const AudioTimeStamp *inInputTime,
 304     AudioBufferList *outOutputData,
 305     const AudioTimeStamp *inOutputTime,
 306     void *hwptr)
 307 {
 308     UInt32 frameCount, pending_frames;
 309     void *out = outOutputData->mBuffers[0].mData;
 310     HWVoiceOut *hw = hwptr;
 311     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hwptr;
 312     size_t len;
 313
 314     if (coreaudio_buf_lock (core, "audioDeviceIOProc")) {
 315         inInputTime = 0;
 316         return 0;
 317     }
 318
 319     if (inDevice != core->outputDeviceID) {
 320         coreaudio_buf_unlock (core, "audioDeviceIOProc(old device)");
 321         return 0;
 322     }
 323
 324     frameCount = core->audioDevicePropertyBufferFrameSize;
 325     pending_frames = hw->pending_emul / hw->info.bytes_per_frame;
 326
 327     /* if there are not enough samples, set signal and return */
 328     if (pending_frames < frameCount) {
 329         inInputTime = 0;
 330         coreaudio_buf_unlock (core, "audioDeviceIOProc(empty)");
 331         return 0;
 332     }
 333
 334     len = frameCount * hw->info.bytes_per_frame;
 335     while (len) {
 336         size_t write_len;
 337         ssize_t start = ((ssize_t) hw->pos_emul) - hw->pending_emul;
 338         if (start < 0) {
 339             start += hw->size_emul;
 340         }
 341         assert(start >= 0 && start < hw->size_emul);
 342
 343         write_len = MIN(MIN(hw->pending_emul, len),
 344                         hw->size_emul - start);
 345
 346         memcpy(out, hw->buf_emul + start, write_len);
 347         hw->pending_emul -= write_len;
 348         len -= write_len;
 349         out += write_len;
 350     }
 351
 352     coreaudio_buf_unlock (core, "audioDeviceIOProc");
 353     return 0;
 354 }
 355
 356 static OSStatus init_out_device(coreaudioVoiceOut *core)
 357 {
 358     OSStatus status;
 359     AudioValueRange frameRange;
 360
 361     AudioStreamBasicDescription streamBasicDescription = {
 362         .mBitsPerChannel = core->hw.info.bits,
 363         .mBytesPerFrame = core->hw.info.bytes_per_frame,
 364         .mBytesPerPacket = core->hw.info.bytes_per_frame,
 365         .mChannelsPerFrame = core->hw.info.nchannels,
 366         .mFormatFlags = kLinearPCMFormatFlagIsFloat,
 367         .mFormatID = kAudioFormatLinearPCM,
 368         .mFramesPerPacket = 1,
 369         .mSampleRate = core->hw.info.freq
 370     };
 371
 372     status = coreaudio_get_voice(&core->outputDeviceID);
 373     if (status != kAudioHardwareNoError) {
 374         coreaudio_playback_logerr (status,
 375                                    "Could not get default output Device\n");
 376         return status;
 377     }
 378     if (core->outputDeviceID == kAudioDeviceUnknown) {
 379         dolog ("Could not initialize playback - Unknown Audiodevice\n");
 380         return status;
 381     }
 382
 383     /* get minimum and maximum buffer frame sizes */
 384     status = coreaudio_get_framesizerange(core->outputDeviceID,
 385                                           &frameRange);
 386     if (status == kAudioHardwareBadObjectError) {
 387         return 0;
 388     }
 389     if (status != kAudioHardwareNoError) {
 390         coreaudio_playback_logerr (status,
 391                                     "Could not get device buffer frame range\n");
 392         return status;
 393     }
 394
 395     if (frameRange.mMinimum > core->frameSizeSetting) {
 396         core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMinimum;
 397         dolog ("warning: Upsizing Buffer Frames to %f\n", frameRange.mMinimum);
 398     } else if (frameRange.mMaximum < core->frameSizeSetting) {
 399         core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMaximum;
 400         dolog ("warning: Downsizing Buffer Frames to %f\n", frameRange.mMaximum);
 401     } else {
 402         core->audioDevicePropertyBufferFrameSize = core->frameSizeSetting;
 403     }
 404
 405     /* set Buffer Frame Size */
 406     status = coreaudio_set_framesize(core->outputDeviceID,
 407                                      &core->audioDevicePropertyBufferFrameSize);
 408     if (status == kAudioHardwareBadObjectError) {
 409         return 0;
 410     }
 411     if (status != kAudioHardwareNoError) {
 412         coreaudio_playback_logerr (status,
 413                                     "Could not set device buffer frame size %" PRIu32 "\n",
 414                                     (uint32_t)core->audioDevicePropertyBufferFrameSize);
 415         return status;
 416     }
 417
 418     /* get Buffer Frame Size */
 419     status = coreaudio_get_framesize(core->outputDeviceID,
 420                                      &core->audioDevicePropertyBufferFrameSize);
 421     if (status == kAudioHardwareBadObjectError) {
 422         return 0;
 423     }
 424     if (status != kAudioHardwareNoError) {
 425         coreaudio_playback_logerr (status,
 426                                     "Could not get device buffer frame size\n");
 427         return status;
 428     }
 429     core->hw.samples = core->bufferCount * core->audioDevicePropertyBufferFrameSize;
 430
 431     /* set Samplerate */
 432     status = coreaudio_set_streamformat(core->outputDeviceID,
 433                                         &streamBasicDescription);
 434     if (status == kAudioHardwareBadObjectError) {
 435         return 0;
 436     }
 437     if (status != kAudioHardwareNoError) {
 438         coreaudio_playback_logerr (status,
 439                                    "Could not set samplerate %lf\n",
 440                                    streamBasicDescription.mSampleRate);
 441         core->outputDeviceID = kAudioDeviceUnknown;
 442         return status;
 443     }
 444
 445     /*
 446      * set Callback.
 447      *
 448      * On macOS 11.3.1, Core Audio calls AudioDeviceIOProc after calling an
 449      * internal function named HALB_Mutex::Lock(), which locks a mutex in
 450      * HALB_IOThread::Entry(void*). HALB_Mutex::Lock() is also called in
 451      * AudioObjectGetPropertyData, which is called by coreaudio driver.
 452      * Therefore, the specified callback must be designed to avoid a deadlock
 453      * with the callers of AudioObjectGetPropertyData.
 454      */
 455     core->ioprocid = NULL;
 456     status = AudioDeviceCreateIOProcID(core->outputDeviceID,
 457                                        audioDeviceIOProc,
 458                                        &core->hw,
 459                                        &core->ioprocid);
 460     if (status == kAudioHardwareBadDeviceError) {
 461         return 0;
 462     }
 463     if (status != kAudioHardwareNoError || core->ioprocid == NULL) {
 464         coreaudio_playback_logerr (status, "Could not set IOProc\n");
 465         core->outputDeviceID = kAudioDeviceUnknown;
 466         return status;
 467     }
 468
 469     return 0;
 470 }
 471
 472 static void fini_out_device(coreaudioVoiceOut *core)
 473 {
 474     OSStatus status;
 475     UInt32 isrunning;
 476
 477     /* stop playback */
 478     status = coreaudio_get_isrunning(core->outputDeviceID, &isrunning);
 479     if (status != kAudioHardwareBadObjectError) {
 480         if (status != kAudioHardwareNoError) {
 481             coreaudio_logerr(status,
 482                              "Could not determine whether Device is playing\n");
 483         }
 484
 485         if (isrunning) {
 486             status = AudioDeviceStop(core->outputDeviceID, core->ioprocid);
 487             if (status != kAudioHardwareBadDeviceError && status != kAudioHardwareNoError) {
 488                 coreaudio_logerr(status, "Could not stop playback\n");
 489             }
 490         }
 491     }
 492
 493     /* remove callback */
 494     status = AudioDeviceDestroyIOProcID(core->outputDeviceID,
 495                                         core->ioprocid);
 496     if (status != kAudioHardwareBadDeviceError && status != kAudioHardwareNoError) {
 497         coreaudio_logerr(status, "Could not remove IOProc\n");
 498     }
 499     core->outputDeviceID = kAudioDeviceUnknown;
 500 }
 501
 502 static void update_device_playback_state(coreaudioVoiceOut *core)
 503 {
 504     OSStatus status;
 505     UInt32 isrunning;
 506
 507     status = coreaudio_get_isrunning(core->outputDeviceID, &isrunning);
 508     if (status != kAudioHardwareNoError) {
 509         if (status != kAudioHardwareBadObjectError) {
 510             coreaudio_logerr(status,
 511                              "Could not determine whether Device is playing\n");
 512         }
 513
 514         return;
 515     }
 516
 517     if (core->enabled) {
 518         /* start playback */
 519         if (!isrunning) {
 520             status = AudioDeviceStart(core->outputDeviceID, core->ioprocid);
 521             if (status != kAudioHardwareBadDeviceError && status != kAudioHardwareNoError) {
 522                 coreaudio_logerr (status, "Could not resume playback\n");
 523             }
 524         }
 525     } else {
 526         /* stop playback */
 527         if (isrunning) {
 528             status = AudioDeviceStop(core->outputDeviceID,
 529                                      core->ioprocid);
 530             if (status != kAudioHardwareBadDeviceError && status != kAudioHardwareNoError) {
 531                 coreaudio_logerr(status, "Could not pause playback\n");
 532             }
 533         }
 534     }
 535 }
 536
 537 /* called without iothread lock. */
 538 static OSStatus handle_voice_change(
 539     AudioObjectID in_object_id,
 540     UInt32 in_number_addresses,
 541     const AudioObjectPropertyAddress *in_addresses,
 542     void *in_client_data)
 543 {
 544     OSStatus status;
 545     coreaudioVoiceOut *core = in_client_data;
 546
 547     qemu_mutex_lock_iothread();
 548
 549     if (core->outputDeviceID) {
 550         fini_out_device(core);
 551     }
 552
 553     status = init_out_device(core);
 554     if (!status) {
 555         update_device_playback_state(core);
 556     }
 557
 558     qemu_mutex_unlock_iothread();
 559     return status;
 560 }
 561
 562 static int coreaudio_init_out(HWVoiceOut *hw, struct audsettings *as,
 563                               void *drv_opaque)
 564 {
 565     OSStatus status;
 566     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
 567     int err;
 568     Audiodev *dev = drv_opaque;
 569     AudiodevCoreaudioPerDirectionOptions *cpdo = dev->u.coreaudio.out;
 570     struct audsettings obt_as;
 571
 572     /* create mutex */
 573     err = pthread_mutex_init(&core->buf_mutex, NULL);
 574     if (err) {
 575         dolog("Could not create mutex\nReason: %s\n", strerror (err));
 576         return -1;
 577     }
 578
 579     obt_as = *as;
 580     as = &obt_as;
 581     as->fmt = AUDIO_FORMAT_F32;
 582     audio_pcm_init_info (&hw->info, as);
 583
 584     core->frameSizeSetting = audio_buffer_frames(
 585         qapi_AudiodevCoreaudioPerDirectionOptions_base(cpdo), as, 11610);
 586
 587     core->bufferCount = cpdo->has_buffer_count ? cpdo->buffer_count : 4;
 588
 589     status = AudioObjectAddPropertyListener(kAudioObjectSystemObject,
 590                                             &voice_addr, handle_voice_change,
 591                                             core);
 592     if (status != kAudioHardwareNoError) {
 593         coreaudio_playback_logerr (status,
 594                                    "Could not listen to voice property change\n");
 595         return -1;
 596     }
 597
 598     if (init_out_device(core)) {
 599         status = AudioObjectRemovePropertyListener(kAudioObjectSystemObject,
 600                                                    &voice_addr,
 601                                                    handle_voice_change,
 602                                                    core);
 603         if (status != kAudioHardwareNoError) {
 604             coreaudio_playback_logerr(status,
 605                                       "Could not remove voice property change listener\n");
 606         }
 607     }
 608
 609     return 0;
 610 }
 611
 612 static void coreaudio_fini_out (HWVoiceOut *hw)
 613 {
 614     OSStatus status;
 615     int err;
 616     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
 617
 618     status = AudioObjectRemovePropertyListener(kAudioObjectSystemObject,
 619                                                &voice_addr,
 620                                                handle_voice_change,
 621                                                core);
 622     if (status != kAudioHardwareNoError) {
 623         coreaudio_logerr(status, "Could not remove voice property change listener\n");
 624     }
 625
 626     fini_out_device(core);
 627
 628     /* destroy mutex */
 629     err = pthread_mutex_destroy(&core->buf_mutex);
 630     if (err) {
 631         dolog("Could not destroy mutex\nReason: %s\n", strerror (err));
 632     }
 633 }
 634
 635 static void coreaudio_enable_out(HWVoiceOut *hw, bool enable)
 636 {
 637     coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
 638
 639     core->enabled = enable;
 640     update_device_playback_state(core);
 641 }
 642
 643 static void *coreaudio_audio_init(Audiodev *dev)
 644 {
 645     return dev;
 646 }
 647
 648 static void coreaudio_audio_fini (void *opaque)
 649 {
 650 }
 651
 652 static struct audio_pcm_ops coreaudio_pcm_ops = {
 653     .init_out = coreaudio_init_out,
 654     .fini_out = coreaudio_fini_out,
 655   /* wrapper for audio_generic_write */
 656     .write    = coreaudio_write,
 657   /* wrapper for audio_generic_get_buffer_out */
 658     .get_buffer_out = coreaudio_get_buffer_out,
 659   /* wrapper for audio_generic_put_buffer_out */
 660     .put_buffer_out = coreaudio_put_buffer_out,
 661     .enable_out = coreaudio_enable_out
 662 };
 663
 664 static struct audio_driver coreaudio_audio_driver = {
 665     .name           = "coreaudio",
 666     .descr          = "CoreAudio http://developer.apple.com/audio/coreaudio.html",
 667     .init           = coreaudio_audio_init,
 668     .fini           = coreaudio_audio_fini,
 669     .pcm_ops        = &coreaudio_pcm_ops,
 670     .can_be_default = 1,
 671     .max_voices_out = 1,
 672     .max_voices_in  = 0,
 673     .voice_size_out = sizeof (coreaudioVoiceOut),
 674     .voice_size_in  = 0
 675 };
 676
 677 static void register_audio_coreaudio(void)
 678 {
 679     audio_driver_register(&coreaudio_audio_driver);
 680 }
 681 type_init(register_audio_coreaudio);