/* * QEMU OS X CoreAudio audio driver * * Copyright (c) 2008 The Android Open Source Project * Copyright (c) 2005 Mike Kronenberg * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include #include /* strerror */ #include /* pthread_X */ #include "qemu-common.h" #include "audio.h" #define AUDIO_CAP "coreaudio" #include "audio_int.h" #if 0 # define D(...) fprintf(stderr, __VA_ARGS__) #else # define D(...) ((void)0) #endif struct { int out_buffer_frames; int out_nbuffers; int in_buffer_frames; int in_nbuffers; int isAtexit; } conf = { .out_buffer_frames = 512, .out_nbuffers = 4, .in_buffer_frames = 512, .in_nbuffers = 4, .isAtexit = 0 }; /***************************************************************************************/ /***************************************************************************************/ /*** ***/ /*** U T I L I T Y R O U T I N E S ***/ /*** ***/ /***************************************************************************************/ /***************************************************************************************/ static void coreaudio_logstatus (OSStatus status) { char *str = "BUG"; switch(status) { case kAudioHardwareNoError: str = "kAudioHardwareNoError"; break; case kAudioHardwareNotRunningError: str = "kAudioHardwareNotRunningError"; break; case kAudioHardwareUnspecifiedError: str = "kAudioHardwareUnspecifiedError"; break; case kAudioHardwareUnknownPropertyError: str = "kAudioHardwareUnknownPropertyError"; break; case kAudioHardwareBadPropertySizeError: str = "kAudioHardwareBadPropertySizeError"; break; case kAudioHardwareIllegalOperationError: str = "kAudioHardwareIllegalOperationError"; break; case kAudioHardwareBadDeviceError: str = "kAudioHardwareBadDeviceError"; break; case kAudioHardwareBadStreamError: str = "kAudioHardwareBadStreamError"; break; case kAudioHardwareUnsupportedOperationError: str = "kAudioHardwareUnsupportedOperationError"; break; case kAudioDeviceUnsupportedFormatError: str = "kAudioDeviceUnsupportedFormatError"; break; case kAudioDevicePermissionsError: str = "kAudioDevicePermissionsError"; break; default: AUD_log (AUDIO_CAP, "Reason: status code %ld\n", status); return; } AUD_log (AUDIO_CAP, "Reason: %s\n", str); } static void GCC_FMT_ATTR (2, 3) coreaudio_logerr ( OSStatus status, const char *fmt, ... ) { va_list ap; va_start (ap, fmt); AUD_log (AUDIO_CAP, fmt, ap); va_end (ap); coreaudio_logstatus (status); } static void GCC_FMT_ATTR (3, 4) coreaudio_logerr2 ( OSStatus status, const char *typ, const char *fmt, ... ) { va_list ap; AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ); va_start (ap, fmt); AUD_vlog (AUDIO_CAP, fmt, ap); va_end (ap); coreaudio_logstatus (status); } /***************************************************************************************/ /***************************************************************************************/ /*** ***/ /*** S H A R E D I N / O U T V O I C E ***/ /*** ***/ /***************************************************************************************/ /***************************************************************************************/ typedef struct coreAudioVoice { pthread_mutex_t mutex; AudioDeviceID deviceID; Boolean isInput; UInt32 bufferFrameSize; AudioStreamBasicDescription streamBasicDescription; AudioDeviceIOProc ioproc; int live; int decr; int pos; } coreaudioVoice; static inline UInt32 coreaudio_voice_isPlaying (coreaudioVoice *core) { OSStatus status; UInt32 result = 0; UInt32 propertySize = sizeof(core->deviceID); status = AudioDeviceGetProperty( core->deviceID, 0, core->isInput, kAudioDevicePropertyDeviceIsRunning, &propertySize, &result); if (status != kAudioHardwareNoError) { coreaudio_logerr(status, "Could not determine whether Device is playing\n"); } return result; } static void coreaudio_atexit (void) { conf.isAtexit = 1; } static int coreaudio_voice_lock (coreaudioVoice *core, const char *fn_name) { int err; err = pthread_mutex_lock (&core->mutex); if (err) { dolog ("Could not lock voice for %s\nReason: %s\n", fn_name, strerror (err)); return -1; } return 0; } static int coreaudio_voice_unlock (coreaudioVoice *core, const char *fn_name) { int err; err = pthread_mutex_unlock (&core->mutex); if (err) { dolog ("Could not unlock voice for %s\nReason: %s\n", fn_name, strerror (err)); return -1; } return 0; } static int coreaudio_voice_ctl (coreaudioVoice* core, int cmd) { OSStatus status; switch (cmd) { case VOICE_ENABLE: /* start playback */ D("%s: %s started\n", __FUNCTION__, core->isInput ? "input" : "output"); if (!coreaudio_voice_isPlaying(core)) { status = AudioDeviceStart(core->deviceID, core->ioproc); if (status != kAudioHardwareNoError) { coreaudio_logerr (status, "Could not resume playback\n"); } } break; case VOICE_DISABLE: /* stop playback */ D("%s: %s stopped\n", __FUNCTION__, core->isInput ? "input" : "output"); if (!conf.isAtexit) { if (coreaudio_voice_isPlaying(core)) { status = AudioDeviceStop(core->deviceID, core->ioproc); if (status != kAudioHardwareNoError) { coreaudio_logerr (status, "Could not pause playback\n"); } } } break; } return 0; } static void coreaudio_voice_fini (coreaudioVoice* core) { OSStatus status; int err; if (!conf.isAtexit) { /* stop playback */ coreaudio_voice_ctl(core, VOICE_DISABLE); /* remove callback */ status = AudioDeviceRemoveIOProc(core->deviceID, core->ioproc); if (status != kAudioHardwareNoError) { coreaudio_logerr (status, "Could not remove IOProc\n"); } } core->deviceID = kAudioDeviceUnknown; /* destroy mutex */ err = pthread_mutex_destroy(&core->mutex); if (err) { dolog("Could not destroy mutex\nReason: %s\n", strerror (err)); } } static int coreaudio_voice_init (coreaudioVoice* core, struct audsettings* as, int frameSize, AudioDeviceIOProc ioproc, void* hw, int input) { OSStatus status; UInt32 propertySize; int err; int bits = 8; AudioValueRange frameRange; const char* typ = input ? "input" : "playback"; core->isInput = input ? true : false; /* create mutex */ err = pthread_mutex_init(&core->mutex, NULL); if (err) { dolog("Could not create mutex\nReason: %s\n", strerror (err)); return -1; } if (as->fmt == AUD_FMT_S16 || as->fmt == AUD_FMT_U16) { bits = 16; } // TODO: audio_pcm_init_info (&hw->info, as); /* open default output device */ /* note: we use DefaultSystemOutputDevice because DefaultOutputDevice seems to * always link to the internal speakers, and not the ones selected through system properties * go figure... */ propertySize = sizeof(core->deviceID); status = AudioHardwareGetProperty( input ? kAudioHardwarePropertyDefaultInputDevice : kAudioHardwarePropertyDefaultSystemOutputDevice, &propertySize, &core->deviceID); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not get default %s device\n", typ); return -1; } if (core->deviceID == kAudioDeviceUnknown) { dolog ("Could not initialize %s - Unknown Audiodevice\n", typ); return -1; } /* get minimum and maximum buffer frame sizes */ propertySize = sizeof(frameRange); status = AudioDeviceGetProperty( core->deviceID, 0, core->isInput, kAudioDevicePropertyBufferFrameSizeRange, &propertySize, &frameRange); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not get device buffer frame range\n"); return -1; } if (frameRange.mMinimum > frameSize) { core->bufferFrameSize = (UInt32) frameRange.mMinimum; dolog ("warning: Upsizing Output Buffer Frames to %f\n", frameRange.mMinimum); } else if (frameRange.mMaximum < frameSize) { core->bufferFrameSize = (UInt32) frameRange.mMaximum; dolog ("warning: Downsizing Output Buffer Frames to %f\n", frameRange.mMaximum); } else { core->bufferFrameSize = frameSize; } /* set Buffer Frame Size */ propertySize = sizeof(core->bufferFrameSize); status = AudioDeviceSetProperty( core->deviceID, NULL, 0, core->isInput, kAudioDevicePropertyBufferFrameSize, propertySize, &core->bufferFrameSize); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not set device buffer frame size %ld\n", core->bufferFrameSize); return -1; } /* get Buffer Frame Size */ propertySize = sizeof(core->bufferFrameSize); status = AudioDeviceGetProperty( core->deviceID, 0, core->isInput, kAudioDevicePropertyBufferFrameSize, &propertySize, &core->bufferFrameSize); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not get device buffer frame size\n"); return -1; } // TODO: hw->samples = *pNBuffers * core->bufferFrameSize; /* get StreamFormat */ propertySize = sizeof(core->streamBasicDescription); status = AudioDeviceGetProperty( core->deviceID, 0, core->isInput, kAudioDevicePropertyStreamFormat, &propertySize, &core->streamBasicDescription); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not get Device Stream properties\n"); core->deviceID = kAudioDeviceUnknown; return -1; } /* set Samplerate */ core->streamBasicDescription.mSampleRate = (Float64) as->freq; propertySize = sizeof(core->streamBasicDescription); status = AudioDeviceSetProperty( core->deviceID, 0, 0, core->isInput, kAudioDevicePropertyStreamFormat, propertySize, &core->streamBasicDescription); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not set samplerate %d\n", as->freq); core->deviceID = kAudioDeviceUnknown; return -1; } /* set Callback */ core->ioproc = ioproc; status = AudioDeviceAddIOProc(core->deviceID, ioproc, hw); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not set IOProc\n"); core->deviceID = kAudioDeviceUnknown; return -1; } /* start Playback */ if (!input && !coreaudio_voice_isPlaying(core)) { status = AudioDeviceStart(core->deviceID, core->ioproc); if (status != kAudioHardwareNoError) { coreaudio_logerr2 (status, typ, "Could not start playback\n"); AudioDeviceRemoveIOProc(core->deviceID, core->ioproc); core->deviceID = kAudioDeviceUnknown; return -1; } } return 0; } /***************************************************************************************/ /***************************************************************************************/ /*** ***/ /*** O U T P U T V O I C E ***/ /*** ***/ /***************************************************************************************/ /***************************************************************************************/ typedef struct coreaudioVoiceOut { HWVoiceOut hw; coreaudioVoice core[1]; } coreaudioVoiceOut; #define CORE_OUT(hw) ((coreaudioVoiceOut*)(hw))->core static int coreaudio_run_out (HWVoiceOut *hw, int live) { int decr; coreaudioVoice *core = CORE_OUT(hw); if (coreaudio_voice_lock (core, "coreaudio_run_out")) { return 0; } if (core->decr > live) { ldebug ("core->decr %d live %d core->live %d\n", core->decr, live, core->live); } decr = audio_MIN (core->decr, live); core->decr -= decr; core->live = live - decr; hw->rpos = core->pos; coreaudio_voice_unlock (core, "coreaudio_run_out"); return decr; } /* callback to feed audiooutput buffer */ static OSStatus audioOutDeviceIOProc( AudioDeviceID inDevice, const AudioTimeStamp* inNow, const AudioBufferList* inInputData, const AudioTimeStamp* inInputTime, AudioBufferList* outOutputData, const AudioTimeStamp* inOutputTime, void* hwptr) { UInt32 frame, frameCount; float *out = outOutputData->mBuffers[0].mData; HWVoiceOut *hw = hwptr; coreaudioVoice *core = CORE_OUT(hw); int rpos, live; struct st_sample *src; #ifndef FLOAT_MIXENG #ifdef RECIPROCAL const float scale = 1.f / UINT_MAX; #else const float scale = UINT_MAX; #endif #endif if (coreaudio_voice_lock (core, "audioDeviceIOProc")) { inInputTime = 0; return 0; } frameCount = core->bufferFrameSize; live = core->live; /* if there are not enough samples, set signal and return */ if (live < frameCount) { inInputTime = 0; coreaudio_voice_unlock (core, "audioDeviceIOProc(empty)"); return 0; } rpos = core->pos; src = hw->mix_buf + rpos; /* fill buffer */ for (frame = 0; frame < frameCount; frame++) { #ifdef FLOAT_MIXENG *out++ = src[frame].l; /* left channel */ *out++ = src[frame].r; /* right channel */ #else #ifdef RECIPROCAL *out++ = src[frame].l * scale; /* left channel */ *out++ = src[frame].r * scale; /* right channel */ #else *out++ = src[frame].l / scale; /* left channel */ *out++ = src[frame].r / scale; /* right channel */ #endif #endif } rpos = (rpos + frameCount) % hw->samples; core->decr += frameCount; core->pos = rpos; coreaudio_voice_unlock (core, "audioDeviceIOProc"); return 0; } static int coreaudio_write (SWVoiceOut *sw, void *buf, int len) { return audio_pcm_sw_write (sw, buf, len); } static int coreaudio_init_out (HWVoiceOut *hw, struct audsettings *as) { coreaudioVoice* core = CORE_OUT(hw); int err; audio_pcm_init_info (&hw->info, as); err = coreaudio_voice_init (core, as, conf.out_buffer_frames, audioOutDeviceIOProc, hw, 0); if (err < 0) return err; hw->samples = core->bufferFrameSize * conf.out_nbuffers; return 0; } static void coreaudio_fini_out (HWVoiceOut *hw) { coreaudioVoice *core = CORE_OUT(hw); coreaudio_voice_fini (core); } static int coreaudio_ctl_out (HWVoiceOut *hw, int cmd, ...) { coreaudioVoice *core = CORE_OUT(hw); return coreaudio_voice_ctl (core, cmd); } /***************************************************************************************/ /***************************************************************************************/ /*** ***/ /*** I N P U T V O I C E ***/ /*** ***/ /***************************************************************************************/ /***************************************************************************************/ typedef struct coreaudioVoiceIn { HWVoiceIn hw; coreaudioVoice core[1]; } coreaudioVoiceIn; #define CORE_IN(hw) ((coreaudioVoiceIn *) (hw))->core static int coreaudio_run_in (HWVoiceIn *hw, int live) { int decr; coreaudioVoice *core = CORE_IN(hw); if (coreaudio_voice_lock (core, "coreaudio_run_in")) { return 0; } D("%s: core.decr=%d core.pos=%d\n", __FUNCTION__, core->decr, core->pos); decr = core->decr; core->decr -= decr; hw->wpos = core->pos; coreaudio_voice_unlock (core, "coreaudio_run_in"); return decr; } /* callback to feed audiooutput buffer */ static OSStatus audioInDeviceIOProc( AudioDeviceID inDevice, const AudioTimeStamp* inNow, const AudioBufferList* inInputData, const AudioTimeStamp* inInputTime, AudioBufferList* outOutputData, const AudioTimeStamp* inOutputTime, void* hwptr) { UInt32 frame, frameCount; float *in = inInputData->mBuffers[0].mData; HWVoiceIn *hw = hwptr; coreaudioVoice *core = CORE_IN(hw); int wpos, avail; struct st_sample *dst; #ifndef FLOAT_MIXENG #ifdef RECIPROCAL const float scale = 1.f / UINT_MAX; #else const float scale = UINT_MAX; #endif #endif if (coreaudio_voice_lock (core, "audioDeviceIOProc")) { inInputTime = 0; return 0; } frameCount = core->bufferFrameSize; avail = hw->samples - hw->total_samples_captured - core->decr; D("%s: enter avail=%d core.decr=%d core.pos=%d hw.samples=%d hw.total_samples_captured=%d frameCount=%d\n", __FUNCTION__, avail, core->decr, core->pos, hw->samples, hw->total_samples_captured, (int)frameCount); /* if there are not enough samples, set signal and return */ if (avail < frameCount) { inInputTime = 0; coreaudio_voice_unlock (core, "audioDeviceIOProc(empty)"); return 0; } wpos = core->pos; dst = hw->conv_buf + wpos; /* fill buffer */ for (frame = 0; frame < frameCount; frame++) { #ifdef FLOAT_MIXENG dst[frame].l = *in++; /* left channel */ dst[frame].r = *in++; /* right channel */ #else #ifdef RECIPROCAL dst[frame].l = *in++ * scale; /* left channel */ dst[frame].r = *in++ * scale; /* right channel */ #else dst[frame].l = *in++ / scale; /* left channel */ dst[frame].r = *in++ / scale; /* right channel */ #endif #endif } wpos = (wpos + frameCount) % hw->samples; core->decr += frameCount; core->pos = wpos; D("exit: core.decr=%d core.pos=%d\n", core->decr, core->pos); coreaudio_voice_unlock (core, "audioDeviceIOProc"); return 0; } static int coreaudio_read (SWVoiceIn *sw, void *buf, int len) { int result = audio_pcm_sw_read (sw, buf, len); D("%s: audio_pcm_sw_read(%d) returned %d\n", __FUNCTION__, len, result); return result; } static int coreaudio_init_in (HWVoiceIn *hw, struct audsettings *as) { coreaudioVoice* core = CORE_IN(hw); int err; audio_pcm_init_info (&hw->info, as); err = coreaudio_voice_init (core, as, conf.in_buffer_frames, audioInDeviceIOProc, hw, 1); if (err < 0) { return err; } hw->samples = core->bufferFrameSize * conf.in_nbuffers; return 0; } static void coreaudio_fini_in (HWVoiceIn *hw) { coreaudioVoice* core = CORE_IN(hw); coreaudio_voice_fini(core); } static int coreaudio_ctl_in (HWVoiceIn *hw, int cmd, ...) { coreaudioVoice* core = CORE_IN(hw); return coreaudio_voice_ctl(core, cmd); } static void *coreaudio_audio_init (void) { atexit(coreaudio_atexit); return &coreaudio_audio_init; } static void coreaudio_audio_fini (void *opaque) { (void) opaque; } static struct audio_option coreaudio_options[] = { { .name = "OUT_BUFFER_SIZE", .tag = AUD_OPT_INT, .valp = &conf.out_buffer_frames, .descr = "Size of the output buffer in frames" }, { .name = "OUT_BUFFER_COUNT", .tag = AUD_OPT_INT, .valp = &conf.out_nbuffers, .descr = "Number of output buffers" }, { .name = "IN_BUFFER_SIZE", .tag = AUD_OPT_INT, .valp = &conf.in_buffer_frames, .descr = "Size of the input buffer in frames" }, { .name = "IN_BUFFER_COUNT", .tag = AUD_OPT_INT, .valp = &conf.in_nbuffers, .descr = "Number of input buffers" }, { /* End of list */ } }; static struct audio_pcm_ops coreaudio_pcm_ops = { .init_out = coreaudio_init_out, .fini_out = coreaudio_fini_out, .run_out = coreaudio_run_out, .write = coreaudio_write, .ctl_out = coreaudio_ctl_out .init_in = coreaudio_init_in, .fini_in = coreaudio_fini_in, .run_in = coreaudio_run_in, .read = coreaudio_read, .ctl_in = coreaudio_ctl_in }; struct audio_driver coreaudio_audio_driver = { .name = "coreaudio", .descr = "CoreAudio http://developer.apple.com/audio/coreaudio.html", .options = coreaudio_options, .init = coreaudio_audio_init, .fini = coreaudio_audio_fini, .pcm_ops = &coreaudio_pcm_ops, .can_be_default = 1, .max_voices_out = 1, .max_voices_in = 1, .voice_size_out = sizeof (coreaudioVoiceOut), .voice_size_in = sizeof (coreaudioVoiceIn), };