2005-10-30 19:58:22 +01:00
|
|
|
/*
|
|
|
|
* QEMU OS X CoreAudio audio driver
|
|
|
|
*
|
|
|
|
* 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 <CoreAudio/CoreAudio.h>
|
|
|
|
#include <string.h> /* strerror */
|
|
|
|
#include <pthread.h> /* pthread_X */
|
|
|
|
|
|
|
|
#include "vl.h"
|
|
|
|
|
|
|
|
#define AUDIO_CAP "coreaudio"
|
|
|
|
#include "audio_int.h"
|
|
|
|
|
|
|
|
struct {
|
|
|
|
int buffer_frames;
|
2005-11-20 19:53:42 +01:00
|
|
|
int nbuffers;
|
2005-11-20 17:24:09 +01:00
|
|
|
int isAtexit;
|
2005-10-30 19:58:22 +01:00
|
|
|
} conf = {
|
2005-11-20 17:24:09 +01:00
|
|
|
.buffer_frames = 512,
|
2005-11-20 19:53:42 +01:00
|
|
|
.nbuffers = 4,
|
2005-11-20 17:24:09 +01:00
|
|
|
.isAtexit = 0
|
2005-10-30 19:58:22 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct coreaudioVoiceOut {
|
|
|
|
HWVoiceOut hw;
|
|
|
|
pthread_mutex_t mutex;
|
2005-11-20 17:24:09 +01:00
|
|
|
int isAtexit;
|
2005-10-30 19:58:22 +01:00
|
|
|
AudioDeviceID outputDeviceID;
|
2005-11-20 17:24:09 +01:00
|
|
|
UInt32 audioDevicePropertyBufferFrameSize;
|
2005-10-30 19:58:22 +01:00
|
|
|
AudioStreamBasicDescription outputStreamBasicDescription;
|
|
|
|
int live;
|
|
|
|
int decr;
|
|
|
|
int rpos;
|
|
|
|
} coreaudioVoiceOut;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2005-11-05 19:55:28 +01:00
|
|
|
AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
|
2005-10-30 19:58:22 +01:00
|
|
|
|
|
|
|
va_start (ap, fmt);
|
|
|
|
AUD_vlog (AUDIO_CAP, fmt, ap);
|
|
|
|
va_end (ap);
|
|
|
|
|
|
|
|
coreaudio_logstatus (status);
|
|
|
|
}
|
|
|
|
|
2005-11-20 17:24:09 +01:00
|
|
|
static inline UInt32 isPlaying (AudioDeviceID outputDeviceID)
|
|
|
|
{
|
|
|
|
OSStatus status;
|
|
|
|
UInt32 result = 0;
|
|
|
|
UInt32 propertySize = sizeof(outputDeviceID);
|
|
|
|
status = AudioDeviceGetProperty(
|
|
|
|
outputDeviceID, 0, 0,
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2005-10-30 19:58:22 +01:00
|
|
|
static int coreaudio_lock (coreaudioVoiceOut *core, const char *fn_name)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = pthread_mutex_lock (&core->mutex);
|
|
|
|
if (err) {
|
2005-11-05 19:55:28 +01:00
|
|
|
dolog ("Could not lock voice for %s\nReason: %s\n",
|
2005-10-30 19:58:22 +01:00
|
|
|
fn_name, strerror (err));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coreaudio_unlock (coreaudioVoiceOut *core, const char *fn_name)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = pthread_mutex_unlock (&core->mutex);
|
|
|
|
if (err) {
|
2005-11-05 19:55:28 +01:00
|
|
|
dolog ("Could not unlock voice for %s\nReason: %s\n",
|
2005-10-30 19:58:22 +01:00
|
|
|
fn_name, strerror (err));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coreaudio_run_out (HWVoiceOut *hw)
|
|
|
|
{
|
|
|
|
int live, decr;
|
|
|
|
coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
|
|
|
|
|
|
|
|
if (coreaudio_lock (core, "coreaudio_run_out")) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
live = audio_pcm_hw_get_live_out (hw);
|
|
|
|
|
|
|
|
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->rpos;
|
|
|
|
|
|
|
|
coreaudio_unlock (core, "coreaudio_run_out");
|
|
|
|
return decr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* callback to feed audiooutput buffer */
|
|
|
|
static OSStatus audioDeviceIOProc(
|
|
|
|
AudioDeviceID inDevice,
|
|
|
|
const AudioTimeStamp* inNow,
|
|
|
|
const AudioBufferList* inInputData,
|
|
|
|
const AudioTimeStamp* inInputTime,
|
|
|
|
AudioBufferList* outOutputData,
|
|
|
|
const AudioTimeStamp* inOutputTime,
|
|
|
|
void* hwptr)
|
|
|
|
{
|
2005-11-20 17:24:09 +01:00
|
|
|
UInt32 frame, frameCount;
|
2005-10-30 19:58:22 +01:00
|
|
|
float *out = outOutputData->mBuffers[0].mData;
|
|
|
|
HWVoiceOut *hw = hwptr;
|
|
|
|
coreaudioVoiceOut *core = (coreaudioVoiceOut *) hwptr;
|
|
|
|
int rpos, live;
|
|
|
|
st_sample_t *src;
|
|
|
|
#ifndef FLOAT_MIXENG
|
|
|
|
#ifdef RECIPROCAL
|
|
|
|
const float scale = 1.f / UINT_MAX;
|
|
|
|
#else
|
|
|
|
const float scale = UINT_MAX;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (coreaudio_lock (core, "audioDeviceIOProc")) {
|
|
|
|
inInputTime = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-20 17:24:09 +01:00
|
|
|
frameCount = core->audioDevicePropertyBufferFrameSize;
|
2005-10-30 19:58:22 +01:00
|
|
|
live = core->live;
|
|
|
|
|
|
|
|
/* if there are not enough samples, set signal and return */
|
|
|
|
if (live < frameCount) {
|
|
|
|
inInputTime = 0;
|
|
|
|
coreaudio_unlock (core, "audioDeviceIOProc(empty)");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
rpos = core->rpos;
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cleanup */
|
|
|
|
mixeng_clear (src, frameCount);
|
|
|
|
rpos = (rpos + frameCount) % hw->samples;
|
2005-11-20 17:24:09 +01:00
|
|
|
core->decr += frameCount;
|
2005-10-30 19:58:22 +01:00
|
|
|
core->rpos = rpos;
|
|
|
|
|
|
|
|
coreaudio_unlock (core, "audioDeviceIOProc");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coreaudio_write (SWVoiceOut *sw, void *buf, int len)
|
|
|
|
{
|
|
|
|
return audio_pcm_sw_write (sw, buf, len);
|
|
|
|
}
|
|
|
|
|
2005-11-05 19:55:28 +01:00
|
|
|
static int coreaudio_init_out (HWVoiceOut *hw, audsettings_t *as)
|
2005-10-30 19:58:22 +01:00
|
|
|
{
|
|
|
|
OSStatus status;
|
|
|
|
coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
|
|
|
|
UInt32 propertySize;
|
|
|
|
int err;
|
|
|
|
int bits = 8;
|
|
|
|
int endianess = 0;
|
2005-11-20 17:24:09 +01:00
|
|
|
const char *typ = "playback";
|
|
|
|
AudioValueRange frameRange;
|
2005-10-30 19:58:22 +01:00
|
|
|
|
|
|
|
/* create mutex */
|
|
|
|
err = pthread_mutex_init(&core->mutex, NULL);
|
|
|
|
if (err) {
|
2005-11-05 19:55:28 +01:00
|
|
|
dolog("Could not create mutex\nReason: %s\n", strerror (err));
|
2005-10-30 19:58:22 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-11-05 19:55:28 +01:00
|
|
|
if (as->fmt == AUD_FMT_S16 || as->fmt == AUD_FMT_U16) {
|
2005-10-30 19:58:22 +01:00
|
|
|
bits = 16;
|
|
|
|
endianess = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
audio_pcm_init_info (
|
|
|
|
&hw->info,
|
2005-11-05 19:55:28 +01:00
|
|
|
as,
|
2005-10-30 19:58:22 +01:00
|
|
|
/* Following is irrelevant actually since we do not use
|
|
|
|
mixengs clipping routines */
|
|
|
|
audio_need_to_swap_endian (endianess)
|
|
|
|
);
|
|
|
|
|
|
|
|
/* open default output device */
|
|
|
|
propertySize = sizeof(core->outputDeviceID);
|
|
|
|
status = AudioHardwareGetProperty(
|
|
|
|
kAudioHardwarePropertyDefaultOutputDevice,
|
|
|
|
&propertySize,
|
|
|
|
&core->outputDeviceID);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
|
|
|
coreaudio_logerr2 (status, typ,
|
2005-11-05 19:55:28 +01:00
|
|
|
"Could not get default output Device\n");
|
2005-10-30 19:58:22 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (core->outputDeviceID == kAudioDeviceUnknown) {
|
2005-11-05 19:55:28 +01:00
|
|
|
dolog ("Could not initialize %s - Unknown Audiodevice\n", typ);
|
2005-10-30 19:58:22 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-11-20 17:24:09 +01:00
|
|
|
/* get minimum and maximum buffer frame sizes */
|
|
|
|
propertySize = sizeof(frameRange);
|
|
|
|
status = AudioDeviceGetProperty(
|
|
|
|
core->outputDeviceID,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
kAudioDevicePropertyBufferFrameSizeRange,
|
|
|
|
&propertySize,
|
|
|
|
&frameRange);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
|
|
|
coreaudio_logerr2 (status, typ,
|
|
|
|
"Could not get device buffer frame range\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (frameRange.mMinimum > conf.buffer_frames) {
|
|
|
|
core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMinimum;
|
|
|
|
dolog ("warning: Upsizing Buffer Frames to %f\n", frameRange.mMinimum);
|
|
|
|
}
|
|
|
|
else if (frameRange.mMaximum < conf.buffer_frames) {
|
|
|
|
core->audioDevicePropertyBufferFrameSize = (UInt32) frameRange.mMaximum;
|
|
|
|
dolog ("warning: Downsizing Buffer Frames to %f\n", frameRange.mMaximum);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
core->audioDevicePropertyBufferFrameSize = conf.buffer_frames;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set Buffer Frame Size */
|
|
|
|
propertySize = sizeof(core->audioDevicePropertyBufferFrameSize);
|
2005-10-30 19:58:22 +01:00
|
|
|
status = AudioDeviceSetProperty(
|
|
|
|
core->outputDeviceID,
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
false,
|
2005-11-20 17:24:09 +01:00
|
|
|
kAudioDevicePropertyBufferFrameSize,
|
2005-10-30 19:58:22 +01:00
|
|
|
propertySize,
|
2005-11-20 17:24:09 +01:00
|
|
|
&core->audioDevicePropertyBufferFrameSize);
|
2005-10-30 19:58:22 +01:00
|
|
|
if (status != kAudioHardwareNoError) {
|
|
|
|
coreaudio_logerr2 (status, typ,
|
2005-11-20 17:24:09 +01:00
|
|
|
"Could not set device buffer frame size %ld\n",
|
|
|
|
core->audioDevicePropertyBufferFrameSize);
|
2005-10-30 19:58:22 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-11-20 17:24:09 +01:00
|
|
|
/* get Buffer Frame Size */
|
|
|
|
propertySize = sizeof(core->audioDevicePropertyBufferFrameSize);
|
2005-10-30 19:58:22 +01:00
|
|
|
status = AudioDeviceGetProperty(
|
|
|
|
core->outputDeviceID,
|
|
|
|
0,
|
|
|
|
false,
|
2005-11-20 17:24:09 +01:00
|
|
|
kAudioDevicePropertyBufferFrameSize,
|
2005-10-30 19:58:22 +01:00
|
|
|
&propertySize,
|
2005-11-20 17:24:09 +01:00
|
|
|
&core->audioDevicePropertyBufferFrameSize);
|
2005-10-30 19:58:22 +01:00
|
|
|
if (status != kAudioHardwareNoError) {
|
2005-11-20 17:24:09 +01:00
|
|
|
coreaudio_logerr2 (status, typ,
|
|
|
|
"Could not get device buffer frame size\n");
|
2005-10-30 19:58:22 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2005-11-20 19:53:42 +01:00
|
|
|
hw->samples = conf.nbuffers * core->audioDevicePropertyBufferFrameSize;
|
2005-10-30 19:58:22 +01:00
|
|
|
|
|
|
|
/* get StreamFormat */
|
|
|
|
propertySize = sizeof(core->outputStreamBasicDescription);
|
|
|
|
status = AudioDeviceGetProperty(
|
|
|
|
core->outputDeviceID,
|
|
|
|
0,
|
|
|
|
false,
|
|
|
|
kAudioDevicePropertyStreamFormat,
|
|
|
|
&propertySize,
|
|
|
|
&core->outputStreamBasicDescription);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
|
|
|
coreaudio_logerr2 (status, typ,
|
2005-11-05 19:55:28 +01:00
|
|
|
"Could not get Device Stream properties\n");
|
2005-10-30 19:58:22 +01:00
|
|
|
core->outputDeviceID = kAudioDeviceUnknown;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set Samplerate */
|
2005-11-20 17:24:09 +01:00
|
|
|
core->outputStreamBasicDescription.mSampleRate = (Float64) as->freq;
|
2005-10-30 19:58:22 +01:00
|
|
|
propertySize = sizeof(core->outputStreamBasicDescription);
|
|
|
|
status = AudioDeviceSetProperty(
|
|
|
|
core->outputDeviceID,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
kAudioDevicePropertyStreamFormat,
|
|
|
|
propertySize,
|
|
|
|
&core->outputStreamBasicDescription);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
2005-11-11 01:03:20 +01:00
|
|
|
coreaudio_logerr2 (status, typ, "Could not set samplerate %d\n",
|
|
|
|
as->freq);
|
2005-10-30 19:58:22 +01:00
|
|
|
core->outputDeviceID = kAudioDeviceUnknown;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set Callback */
|
|
|
|
status = AudioDeviceAddIOProc(core->outputDeviceID, audioDeviceIOProc, hw);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
2005-11-05 19:55:28 +01:00
|
|
|
coreaudio_logerr2 (status, typ, "Could not set IOProc\n");
|
2005-10-30 19:58:22 +01:00
|
|
|
core->outputDeviceID = kAudioDeviceUnknown;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* start Playback */
|
2005-11-20 17:24:09 +01:00
|
|
|
if (!isPlaying(core->outputDeviceID)) {
|
2005-10-30 19:58:22 +01:00
|
|
|
status = AudioDeviceStart(core->outputDeviceID, audioDeviceIOProc);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
2005-11-05 19:55:28 +01:00
|
|
|
coreaudio_logerr2 (status, typ, "Could not start playback\n");
|
2005-10-30 19:58:22 +01:00
|
|
|
AudioDeviceRemoveIOProc(core->outputDeviceID, audioDeviceIOProc);
|
|
|
|
core->outputDeviceID = kAudioDeviceUnknown;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void coreaudio_fini_out (HWVoiceOut *hw)
|
|
|
|
{
|
|
|
|
OSStatus status;
|
|
|
|
int err;
|
|
|
|
coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
|
|
|
|
|
2005-11-20 17:24:09 +01:00
|
|
|
if (!conf.isAtexit) {
|
|
|
|
/* stop playback */
|
|
|
|
if (isPlaying(core->outputDeviceID)) {
|
|
|
|
status = AudioDeviceStop(core->outputDeviceID, audioDeviceIOProc);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
|
|
|
coreaudio_logerr (status, "Could not stop playback\n");
|
|
|
|
}
|
2005-10-30 19:58:22 +01:00
|
|
|
}
|
|
|
|
|
2005-11-20 17:24:09 +01:00
|
|
|
/* remove callback */
|
|
|
|
status = AudioDeviceRemoveIOProc(core->outputDeviceID,
|
|
|
|
audioDeviceIOProc);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
|
|
|
coreaudio_logerr (status, "Could not remove IOProc\n");
|
|
|
|
}
|
2005-10-30 19:58:22 +01:00
|
|
|
}
|
|
|
|
core->outputDeviceID = kAudioDeviceUnknown;
|
|
|
|
|
|
|
|
/* destroy mutex */
|
|
|
|
err = pthread_mutex_destroy(&core->mutex);
|
|
|
|
if (err) {
|
2005-11-05 19:55:28 +01:00
|
|
|
dolog("Could not destroy mutex\nReason: %s\n", strerror (err));
|
2005-10-30 19:58:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coreaudio_ctl_out (HWVoiceOut *hw, int cmd, ...)
|
|
|
|
{
|
|
|
|
OSStatus status;
|
|
|
|
coreaudioVoiceOut *core = (coreaudioVoiceOut *) hw;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case VOICE_ENABLE:
|
|
|
|
/* start playback */
|
2005-11-20 17:24:09 +01:00
|
|
|
if (!isPlaying(core->outputDeviceID)) {
|
2005-10-30 19:58:22 +01:00
|
|
|
status = AudioDeviceStart(core->outputDeviceID, audioDeviceIOProc);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
2005-11-20 17:24:09 +01:00
|
|
|
coreaudio_logerr (status, "Could not resume playback\n");
|
2005-10-30 19:58:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VOICE_DISABLE:
|
|
|
|
/* stop playback */
|
2005-11-20 17:24:09 +01:00
|
|
|
if (!conf.isAtexit) {
|
|
|
|
if (isPlaying(core->outputDeviceID)) {
|
|
|
|
status = AudioDeviceStop(core->outputDeviceID, audioDeviceIOProc);
|
|
|
|
if (status != kAudioHardwareNoError) {
|
|
|
|
coreaudio_logerr (status, "Could not pause playback\n");
|
|
|
|
}
|
2005-10-30 19:58:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *coreaudio_audio_init (void)
|
|
|
|
{
|
2005-11-20 17:24:09 +01:00
|
|
|
atexit(coreaudio_atexit);
|
2005-10-30 19:58:22 +01:00
|
|
|
return &coreaudio_audio_init;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void coreaudio_audio_fini (void *opaque)
|
|
|
|
{
|
|
|
|
(void) opaque;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct audio_option coreaudio_options[] = {
|
|
|
|
{"BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_frames,
|
|
|
|
"Size of the buffer in frames", NULL, 0},
|
2005-11-20 19:53:42 +01:00
|
|
|
{"BUFFER_COUNT", AUD_OPT_INT, &conf.nbuffers,
|
|
|
|
"Number of buffers", NULL, 0},
|
2005-10-30 19:58:22 +01:00
|
|
|
{NULL, 0, NULL, NULL, NULL, 0}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct audio_pcm_ops coreaudio_pcm_ops = {
|
|
|
|
coreaudio_init_out,
|
|
|
|
coreaudio_fini_out,
|
|
|
|
coreaudio_run_out,
|
|
|
|
coreaudio_write,
|
|
|
|
coreaudio_ctl_out,
|
|
|
|
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
struct audio_driver coreaudio_audio_driver = {
|
|
|
|
INIT_FIELD (name = ) "coreaudio",
|
|
|
|
INIT_FIELD (descr = )
|
|
|
|
"CoreAudio http://developer.apple.com/audio/coreaudio.html",
|
|
|
|
INIT_FIELD (options = ) coreaudio_options,
|
|
|
|
INIT_FIELD (init = ) coreaudio_audio_init,
|
|
|
|
INIT_FIELD (fini = ) coreaudio_audio_fini,
|
|
|
|
INIT_FIELD (pcm_ops = ) &coreaudio_pcm_ops,
|
|
|
|
INIT_FIELD (can_be_default = ) 1,
|
|
|
|
INIT_FIELD (max_voices_out = ) 1,
|
|
|
|
INIT_FIELD (max_voices_in = ) 0,
|
|
|
|
INIT_FIELD (voice_size_out = ) sizeof (coreaudioVoiceOut),
|
|
|
|
INIT_FIELD (voice_size_in = ) 0
|
|
|
|
};
|