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