// ----------------------------------------------------------
void ofxAudioUnitNetReceive::connectToHost(const std::string &address, unsigned long port)
// ----------------------------------------------------------
{
stringstream ss;
ss << address << ":" << port;
CFStringRef hostName = CFStringCreateWithCString(kCFAllocatorDefault,
ss.str().c_str(),
kCFStringEncodingUTF8);
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAUNetReceiveProperty_Hostname,
kAudioUnitScope_Global,
0,
&hostName,
sizeof(hostName)),
"setting net receive host name");
// setting net send disconnect to 0 to connect net receive because that makes sense
UInt32 connect = 0;
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAUNetSendProperty_Disconnect,
kAudioUnitScope_Global,
0,
&connect,
sizeof(connect)),
"connecting net receive");
CFRelease(hostName);
}
// ----------------------------------------------------------
ofxAudioUnit& ofxAudioUnitInput::connectTo(ofxAudioUnit &otherUnit, int destinationBus, int sourceBus)
// ----------------------------------------------------------
{
AudioStreamBasicDescription ASBD;
UInt32 ASBDSize = sizeof(ASBD);
OFXAU_PRINT(AudioUnitGetProperty(otherUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
destinationBus,
&ASBD,
&ASBDSize),
"getting hardware input destination's format");
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output,
1,
&ASBD,
sizeof(ASBD)),
"setting hardware input's output format");
AURenderCallbackStruct callback = {PullCallback, &_impl->ctx};
otherUnit.setRenderCallback(callback, destinationBus);
return otherUnit;
}
std::vector<UInt32> ofxAudioUnitMatrixMixer::getBusCount() const
{
std::vector<UInt32> busCount;
UInt32 inputBusCount, outputBusCount, inputSize, outputSize;
inputBusCount = outputBusCount = 0;
inputSize = outputSize = sizeof(UInt32);
OFXAU_PRINT(AudioUnitGetProperty(*_unit,
kAudioUnitProperty_ElementCount,
kAudioUnitScope_Input,
0,
&inputBusCount,
&inputSize),
"getting matrix mixer input bus count");
OFXAU_PRINT(AudioUnitGetProperty(*_unit,
kAudioUnitProperty_ElementCount,
kAudioUnitScope_Output,
0,
&outputBusCount,
&outputSize),
"getting matrix mixer output bus count");
busCount.push_back(inputBusCount);
busCount.push_back(outputBusCount);
return busCount;
}
std::vector<AudioStreamBasicDescription> ofxAudioUnitMatrixMixer::getASBDs() const
{
std::vector<AudioStreamBasicDescription> ASBDs;
AudioStreamBasicDescription inputASBD, outputASBD;
UInt32 inputSize, outputSize;
inputSize = outputSize = sizeof(UInt32);
OFXAU_PRINT(AudioUnitGetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
0,
&inputASBD,
&inputSize),
"getting matrix mixer input ASBD");
OFXAU_PRINT(AudioUnitGetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output,
0,
&outputASBD,
&outputSize),
"getting matrix mixer output ASBD");
ASBDs.push_back(inputASBD);
ASBDs.push_back(outputASBD);
return ASBDs;
}
// ----------------------------------------------------------
ofxAudioUnitInput::ofxAudioUnitInput(unsigned int samplesToBuffer)
: _impl(new InputImpl)
// ----------------------------------------------------------
{
_desc = inputDesc;
initUnit();
AudioStreamBasicDescription ASBD = {0};
UInt32 ASBD_size = sizeof(ASBD);
OFXAU_PRINT(AudioUnitGetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output,
1,
&ASBD,
&ASBD_size),
"getting input ASBD");
_impl->ctx.inputUnit = _unit;
_impl->ctx.bufferList = AudioBufferListRef(AudioBufferListAlloc(ASBD.mChannelsPerFrame, 1024), AudioBufferListRelease);
_impl->ctx.circularBuffers.resize(ASBD.mChannelsPerFrame);
_impl->isReady = false;
#if !TARGET_OS_IPHONE
_impl->inputDeviceID = DefaultAudioInputDevice();
#endif
for(int i = 0; i < ASBD.mChannelsPerFrame; i++) {
TPCircularBufferInit(&_impl->ctx.circularBuffers[i], samplesToBuffer * sizeof(Float32));
}
}
// ----------------------------------------------------------
OSStatus RenderCallback(void *inRefCon,
AudioUnitRenderActionFlags *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList *ioData)
// ----------------------------------------------------------
{
InputContext * ctx = static_cast<InputContext *>(inRefCon);
OSStatus s = AudioUnitRender(*(ctx->inputUnit),
ioActionFlags,
inTimeStamp,
inBusNumber,
inNumberFrames,
ctx->bufferList.get());
OFXAU_PRINT(s, "rendering audio input");
if(s == noErr) {
size_t buffersToCopy = std::min<size_t>(ctx->bufferList->mNumberBuffers, ctx->circularBuffers.size());
for(int i = 0; i < buffersToCopy; i++) {
TPCircularBuffer * circBuffer = &ctx->circularBuffers[i];
if(circBuffer) {
TPCircularBufferProduceBytes(circBuffer,
ctx->bufferList->mBuffers[i].mData,
inNumberFrames * sizeof(Float32));
}
}
}
return s;
}
// ----------------------------------------------------------
bool ofxAudioUnitSampler::setSamples(const std::vector<std::string> &samplePaths)
// ----------------------------------------------------------
{
CFURLRef sampleURLs[samplePaths.size()];
for(int i = 0; i < samplePaths.size(); i++)
{
sampleURLs[i] = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)samplePaths[i].c_str(),
samplePaths[i].length(),
NULL);
}
CFArrayRef samples = CFArrayCreate(NULL, (const void **)&sampleURLs, samplePaths.size(), &kCFTypeArrayCallBacks);
OSStatus s = AudioUnitSetProperty(*_unit,
kAUSamplerProperty_LoadAudioFiles,
kAudioUnitScope_Global,
0,
&samples,
sizeof(samples));
OFXAU_PRINT(s, "setting ofxAudioUnitSampler's source samples");
for(int i = 0; i < samplePaths.size(); i++) CFRelease(sampleURLs[i]);
CFRelease(samples);
return s == noErr;
}
void ofxAudioUnitMatrixMixer::initWithLayout(UInt32 inputBusCount, UInt32 outputBusCount, AudioStreamBasicDescription * inASBD, AudioStreamBasicDescription * outASBD)
{
_desc = matrixMixerDesc;
_unit = allocUnit(_desc);
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ElementCount,
kAudioUnitScope_Input,
0,
&inputBusCount,
sizeof(inputBusCount)),
"setting number of input busses");
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ElementCount,
kAudioUnitScope_Output,
0,
&outputBusCount,
sizeof(outputBusCount)),
"setting number of output busses");
if(inASBD) {
for(int i = 0; i < inputBusCount; i++) {
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
i,
inASBD,
sizeof(AudioStreamBasicDescription)),
"setting matrix mixer input ASBD");
}
}
if(outASBD) {
for(int i = 0; i < outputBusCount; i++) {
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output,
i,
outASBD,
sizeof(AudioStreamBasicDescription)),
"setting matrix mixer output ASBD");
}
}
OFXAU_PRINT(AudioUnitInitialize(*_unit), "initializing matrix mixer unit");
}
// ----------------------------------------------------------
ofxAudioUnitMidiReceiver::ofxAudioUnitMidiReceiver(string clientName)
: _client(NULL), _endpoint(NULL), _port(NULL), _unit(NULL)
// ----------------------------------------------------------
{
CFStringRef cName = CFStringCreateWithCString(kCFAllocatorDefault, clientName.c_str(), kCFStringEncodingUTF8);
OFXAU_PRINT(MIDIClientCreate(cName, ofxAudioUnitMidiInputProc, this, &_client),
"creating MIDI client");
CFRelease(cName);
}
// ----------------------------------------------------------
void ofxAudioUnitNetReceive::disconnect()
// ----------------------------------------------------------
{
UInt32 disconnect = 1;
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAUNetSendProperty_Disconnect,
kAudioUnitScope_Global,
0,
&disconnect,
sizeof(disconnect)),
"disconnecting net receive");
}
AudioTimeStamp ofxAudioUnitFilePlayer::getCurrentTimestamp() const {
AudioTimeStamp timeStamp = {0};
UInt32 timeStampSize = sizeof(AudioTimeStamp);
OFXAU_PRINT(AudioUnitGetProperty(*_unit,
kAudioUnitProperty_CurrentPlayTime,
kAudioUnitScope_Global,
0,
&timeStamp,
&timeStampSize),
"getting time stamp from file player");
return timeStamp;
}
// ----------------------------------------------------------
ofxAudioUnitSpeechSynth::ofxAudioUnitSpeechSynth()
// ----------------------------------------------------------
{
_desc = speechDesc;
initUnit();
UInt32 dataSize = sizeof(SpeechChannel);
OFXAU_PRINT(AudioUnitGetProperty(*_unit,
kAudioUnitProperty_SpeechChannel,
kAudioUnitScope_Global,
0,
&_channel,
&dataSize),
"getting speech channel");
}
// ----------------------------------------------------------
OSStatus ofxAudioUnitInput::renderCallback(void *inRefCon,
AudioUnitRenderActionFlags *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList *ioData)
// ----------------------------------------------------------
{
RenderContext * ctx = reinterpret_cast<RenderContext *>(inRefCon);
OSStatus s = AudioUnitRender(*(ctx->inputUnit),
ioActionFlags,
inTimeStamp,
inBusNumber,
inNumberFrames,
ctx->ringBuffer->writeHead());
OFXAU_PRINT(s, "rendering audio input");
if(s == noErr) ctx->ringBuffer->advanceWriteHead();
return s;
}
// ----------------------------------------------------------
bool ofxAudioUnitSampler::setSample(const std::string &samplePath)
// ----------------------------------------------------------
{
CFURLRef sampleURL[1] = {CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)samplePath.c_str(),
samplePath.length(),
NULL)};
CFArrayRef sample = CFArrayCreate(NULL, (const void **)&sampleURL, 1, &kCFTypeArrayCallBacks);
OFXAU_PRINT(AudioUnitSetProperty(*_unit,
kAUSamplerProperty_LoadAudioFiles,
kAudioUnitScope_Global,
0,
&sample,
sizeof(sample)),
"setting ofxAudioUnitSampler's source sample");
CFRelease(sample);
CFRelease(sampleURL[0]);
return true;
}
// ----------------------------------------------------------
void ofxAudioUnitMidiReceiver::disconnectFromMidiSource(unsigned long midiSourceIndex)
// ----------------------------------------------------------
{
OFXAU_PRINT(MIDIPortDisconnectSource(_port, MIDIGetSource(midiSourceIndex)),
"disconnecting from MIDI source");
}
