308 lines
8.5 KiB
C++
308 lines
8.5 KiB
C++
/*
|
|
Simple Core Audio backend for osx (and maybe ios?)
|
|
Based off various audio core samples and dolphin's code
|
|
|
|
This is part of the Reicast project, please consult the
|
|
LICENSE file for licensing & related information
|
|
|
|
This could do with some locking logic to avoid
|
|
race conditions, and some variable length buffer
|
|
logic to support chunk sizes other than 512 bytes
|
|
|
|
It does work on my macmini though
|
|
*/
|
|
#if defined(__APPLE__)
|
|
#include "audiostream.h"
|
|
#include "stdclass.h"
|
|
|
|
#include <atomic>
|
|
|
|
#include <AudioUnit/AudioUnit.h>
|
|
#include <AudioToolbox/AudioQueue.h>
|
|
|
|
class CoreAudioBackend : public AudioBackend
|
|
{
|
|
AudioUnit audioUnit;
|
|
|
|
u32 BUFSIZE = 0;
|
|
u8 *samples_temp = nullptr;
|
|
|
|
std::atomic<int> samples_wptr;
|
|
std::atomic<int> samples_rptr;
|
|
cResetEvent bufferEmpty;
|
|
|
|
// input buffer and indexes
|
|
u8 samples_input[2400];
|
|
static constexpr size_t InputBufSize = sizeof(samples_input);
|
|
std::atomic<int> input_wptr;
|
|
std::atomic<int> input_rptr;
|
|
AudioQueueRef recordQueue;
|
|
|
|
static OSStatus renderCallback(void* ctx, AudioUnitRenderActionFlags* flags, const AudioTimeStamp* ts,
|
|
UInt32 bus, UInt32 frames, AudioBufferList* abl)
|
|
{
|
|
CoreAudioBackend *backend = (CoreAudioBackend *)ctx;
|
|
for (int i = 0; i < abl->mNumberBuffers; i++)
|
|
{
|
|
int size = abl->mBuffers[i].mDataByteSize;
|
|
u8 *outBuffer = (u8 *)abl->mBuffers[i].mData;
|
|
while (size != 0)
|
|
{
|
|
int avail = (backend->samples_wptr - backend->samples_rptr + backend->BUFSIZE) % backend->BUFSIZE;
|
|
if (avail == 0)
|
|
{
|
|
//printf("Core Audio: buffer underrun %d bytes (%d)", size, abl->mBuffers[i].mDataByteSize);
|
|
memset(outBuffer, '\0', size);
|
|
return noErr;
|
|
}
|
|
avail = std::min(avail, size);
|
|
avail = std::min(avail, (int)backend->BUFSIZE - backend->samples_rptr);
|
|
memcpy(outBuffer, backend->samples_temp + backend->samples_rptr, avail);
|
|
backend->samples_rptr = (backend->samples_rptr + avail) % backend->BUFSIZE;
|
|
size -= avail;
|
|
outBuffer += avail;
|
|
// Set the mutex to allow writing
|
|
backend->bufferEmpty.Set();
|
|
}
|
|
}
|
|
|
|
return noErr;
|
|
}
|
|
|
|
public:
|
|
CoreAudioBackend()
|
|
: AudioBackend("coreaudio", "Core Audio") {}
|
|
|
|
bool init() override
|
|
{
|
|
OSStatus err;
|
|
AURenderCallbackStruct callback_struct;
|
|
AudioStreamBasicDescription format;
|
|
AudioComponentDescription desc;
|
|
AudioComponent component;
|
|
|
|
desc.componentType = kAudioUnitType_Output;
|
|
#if !defined(TARGET_IPHONE)
|
|
desc.componentSubType = kAudioUnitSubType_DefaultOutput;
|
|
#else
|
|
desc.componentSubType = kAudioUnitSubType_RemoteIO;
|
|
#endif
|
|
desc.componentFlags = 0;
|
|
desc.componentFlagsMask = 0;
|
|
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
|
|
component = AudioComponentFindNext(nullptr, &desc);
|
|
|
|
if (component == nullptr) {
|
|
ERROR_LOG(AUDIO, "coreaudio: AudioComponentFindNext failed");
|
|
return false;
|
|
}
|
|
|
|
err = AudioComponentInstanceNew(component, &audioUnit);
|
|
if (err != noErr) {
|
|
ERROR_LOG(AUDIO, "coreaudio: AudioComponentInstanceNew failed");
|
|
return false;
|
|
}
|
|
|
|
FillOutASBDForLPCM(format, 44100,
|
|
2, 16, 16, false, false, false);
|
|
err = AudioUnitSetProperty(audioUnit,
|
|
kAudioUnitProperty_StreamFormat,
|
|
kAudioUnitScope_Input, 0, &format,
|
|
sizeof(AudioStreamBasicDescription));
|
|
if (err != noErr)
|
|
{
|
|
ERROR_LOG(AUDIO, "coreaudio: AudioUnitSetProperty(kAudioUnitProperty_StreamFormat) failed");
|
|
AudioComponentInstanceDispose(audioUnit);
|
|
return false;
|
|
}
|
|
|
|
callback_struct.inputProc = renderCallback;
|
|
callback_struct.inputProcRefCon = this;
|
|
err = AudioUnitSetProperty(audioUnit,
|
|
kAudioUnitProperty_SetRenderCallback,
|
|
kAudioUnitScope_Input, 0, &callback_struct,
|
|
sizeof callback_struct);
|
|
if (err != noErr)
|
|
{
|
|
ERROR_LOG(AUDIO, "coreaudio: AudioUnitSetProperty(kAudioUnitProperty_SetRenderCallback) failed");
|
|
AudioComponentInstanceDispose(audioUnit);
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
err = AudioUnitSetParameter(audioUnit,
|
|
kHALOutputParam_Volume,
|
|
kAudioUnitParameterFlag_Output, 0,
|
|
1, 0);
|
|
verify(err == noErr);
|
|
*/
|
|
|
|
err = AudioUnitInitialize(audioUnit);
|
|
if (err != noErr)
|
|
{
|
|
ERROR_LOG(AUDIO, "coreaudio: AudioUnitInitialize failed");
|
|
AudioComponentInstanceDispose(audioUnit);
|
|
return false;
|
|
}
|
|
|
|
BUFSIZE = config::AudioBufferSize * 4;
|
|
samples_temp = new u8[BUFSIZE]();
|
|
samples_rptr = 0;
|
|
samples_wptr = 0;
|
|
|
|
err = AudioOutputUnitStart(audioUnit);
|
|
if (err != noErr)
|
|
{
|
|
ERROR_LOG(AUDIO, "coreaudio: AudioOutputUnitStart failed");
|
|
AudioUnitUninitialize(audioUnit);
|
|
AudioComponentInstanceDispose(audioUnit);
|
|
return false;
|
|
}
|
|
|
|
bufferEmpty.Set();
|
|
|
|
return true;
|
|
}
|
|
|
|
u32 push(const void* frame, u32 samples, bool wait) override
|
|
{
|
|
int size = samples * 4;
|
|
while (size != 0)
|
|
{
|
|
int avail = (samples_rptr - samples_wptr - 4 + BUFSIZE) % BUFSIZE;
|
|
if (avail == 0)
|
|
{
|
|
if (!wait)
|
|
break;
|
|
bufferEmpty.Wait();
|
|
continue;
|
|
}
|
|
avail = std::min(avail, size);
|
|
avail = std::min(avail, (int)BUFSIZE - samples_wptr);
|
|
memcpy(&samples_temp[samples_wptr], frame, avail);
|
|
samples_wptr = (samples_wptr + avail) % BUFSIZE;
|
|
frame = (u8 *)frame + avail;
|
|
size -= avail;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void term() override
|
|
{
|
|
AudioOutputUnitStop(audioUnit);
|
|
AudioUnitUninitialize(audioUnit);
|
|
AudioComponentInstanceDispose(audioUnit);
|
|
bufferEmpty.Set();
|
|
delete [] samples_temp;
|
|
samples_temp = nullptr;
|
|
}
|
|
|
|
static void recordCallback(void *inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer,
|
|
const AudioTimeStamp *inStartTime, UInt32 frameSize, const AudioStreamPacketDescription *dataFormat)
|
|
{
|
|
//DEBUG_LOG(AUDIO, "AudioQueue callback: wptr %d rptr %d bytes %d", (int)input_wptr, (int)input_rptr, inBuffer->mAudioDataByteSize);
|
|
CoreAudioBackend *backend = (CoreAudioBackend *)inUserData;
|
|
UInt32 size = inBuffer->mAudioDataByteSize;
|
|
UInt32 freeSpace = (backend->input_rptr - backend->input_wptr - 2 + InputBufSize) % InputBufSize;
|
|
if (size > freeSpace)
|
|
{
|
|
DEBUG_LOG(AUDIO, "coreaudio: record overrun %d bytes", size - freeSpace);
|
|
size = freeSpace;
|
|
}
|
|
while (size != 0)
|
|
{
|
|
UInt32 chunk = std::min(size, (UInt32)(InputBufSize - backend->input_wptr));
|
|
memcpy(backend->samples_input + backend->input_wptr, inBuffer->mAudioData, chunk);
|
|
backend->input_wptr = (backend->input_wptr + chunk) % InputBufSize;
|
|
size -= chunk;
|
|
}
|
|
AudioQueueEnqueueBuffer(backend->recordQueue, inBuffer, 0, nullptr);
|
|
}
|
|
|
|
void termRecord() override
|
|
{
|
|
if (recordQueue != nullptr)
|
|
{
|
|
AudioQueueStop(recordQueue, true);
|
|
AudioQueueDispose(recordQueue, true);
|
|
recordQueue = nullptr;
|
|
}
|
|
}
|
|
|
|
bool initRecord(u32 sampling_freq) override
|
|
{
|
|
AudioStreamBasicDescription desc{};
|
|
desc.mFormatID = kAudioFormatLinearPCM;
|
|
desc.mSampleRate = (double)sampling_freq;
|
|
desc.mChannelsPerFrame = 1;
|
|
desc.mBitsPerChannel = 16;
|
|
desc.mBytesPerPacket = desc.mBytesPerFrame = 2;
|
|
desc.mFramesPerPacket = 1;
|
|
desc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
|
|
desc.mReserved = 0;
|
|
|
|
OSStatus err = AudioQueueNewInput(&desc,
|
|
recordCallback,
|
|
this,
|
|
nullptr,
|
|
kCFRunLoopCommonModes,
|
|
0,
|
|
&recordQueue);
|
|
if (err != noErr)
|
|
{
|
|
ERROR_LOG(AUDIO, "AudioQueueNewInput failed: %d", err);
|
|
return false;
|
|
}
|
|
|
|
AudioQueueBufferRef buffers[2];
|
|
for (UInt32 i = 0; i < ARRAY_SIZE(buffers) && err == noErr; i++)
|
|
{
|
|
err = AudioQueueAllocateBuffer(recordQueue, 480, &buffers[i]);
|
|
if (err == noErr)
|
|
err = AudioQueueEnqueueBuffer(recordQueue, buffers[i], 0, nullptr);
|
|
}
|
|
input_wptr = 0;
|
|
input_rptr = 0;
|
|
if (err == noErr)
|
|
err = AudioQueueStart(recordQueue, nullptr);
|
|
if (err != noErr)
|
|
{
|
|
ERROR_LOG(AUDIO, "AudioQueue init failed: %d", err);
|
|
termRecord();
|
|
return false;
|
|
}
|
|
INFO_LOG(AUDIO, "AudioQueue initialized - sample rate %f", desc.mSampleRate);
|
|
|
|
return true;
|
|
}
|
|
|
|
u32 record(void* frame, u32 samples) override
|
|
{
|
|
// DEBUG_LOG(AUDIO, "coreaudio_record: wptr %d rptr %d", (int)input_wptr, (int)input_rptr);
|
|
u32 size = samples * 2;
|
|
while (size != 0)
|
|
{
|
|
u32 avail = (input_wptr - input_rptr + InputBufSize) % InputBufSize;
|
|
if (avail == 0)
|
|
{
|
|
DEBUG_LOG(AUDIO, "coreaudio: record underrun %d bytes", size);
|
|
break;
|
|
}
|
|
avail = std::min(avail, size);
|
|
avail = std::min(avail, (u32)(InputBufSize - input_rptr));
|
|
|
|
memcpy(frame, &samples_input[input_rptr], avail);
|
|
frame = (u8 *)frame + avail;
|
|
input_rptr = (input_rptr + avail) % InputBufSize;
|
|
size -= avail;
|
|
}
|
|
|
|
return samples - size / 2;
|
|
}
|
|
};
|
|
static CoreAudioBackend coreAudioBackend;
|
|
|
|
|
|
#endif
|