mirror of https://github.com/AxioDL/amuse.git
349 lines
10 KiB
C++
349 lines
10 KiB
C++
#include "VSTBackend.hpp"
|
|
#include "audiodev/AudioVoiceEngine.hpp"
|
|
#include "logvisor/logvisor.hpp"
|
|
#include <Shlobj.h>
|
|
|
|
#undef min
|
|
#undef max
|
|
|
|
struct VSTVoiceEngine : boo::BaseAudioVoiceEngine {
|
|
std::vector<float> m_interleavedBuf;
|
|
float** m_outputData = nullptr;
|
|
size_t m_renderFrames = 0;
|
|
size_t m_curBufFrame = 0;
|
|
|
|
boo::AudioChannelSet _getAvailableSet() { return boo::AudioChannelSet::Stereo; }
|
|
|
|
std::vector<std::pair<std::string, std::string>> enumerateMIDIDevices() const { return {}; }
|
|
|
|
boo::ReceiveFunctor* m_midiReceiver = nullptr;
|
|
|
|
struct MIDIIn : public boo::IMIDIIn {
|
|
MIDIIn(bool virt, boo::ReceiveFunctor&& receiver) : IMIDIIn(virt, std::move(receiver)) {}
|
|
|
|
std::string description() const { return "VST MIDI"; }
|
|
};
|
|
|
|
std::unique_ptr<boo::IMIDIIn> newVirtualMIDIIn(boo::ReceiveFunctor&& receiver) {
|
|
std::unique_ptr<boo::IMIDIIn> ret = std::make_unique<MIDIIn>(true, std::move(receiver));
|
|
m_midiReceiver = &ret->m_receiver;
|
|
return ret;
|
|
}
|
|
|
|
std::unique_ptr<boo::IMIDIOut> newVirtualMIDIOut() { return {}; }
|
|
|
|
std::unique_ptr<boo::IMIDIInOut> newVirtualMIDIInOut(boo::ReceiveFunctor&& receiver) { return {}; }
|
|
|
|
std::unique_ptr<boo::IMIDIIn> newRealMIDIIn(const char* name, boo::ReceiveFunctor&& receiver) { return {}; }
|
|
|
|
std::unique_ptr<boo::IMIDIOut> newRealMIDIOut(const char* name) { return {}; }
|
|
|
|
std::unique_ptr<boo::IMIDIInOut> newRealMIDIInOut(const char* name, boo::ReceiveFunctor&& receiver) { return {}; }
|
|
|
|
bool useMIDILock() const { return false; }
|
|
|
|
VSTVoiceEngine() {
|
|
m_mixInfo.m_periodFrames = 1024;
|
|
m_mixInfo.m_sampleRate = 44100.0;
|
|
m_mixInfo.m_sampleFormat = SOXR_FLOAT32_I;
|
|
m_mixInfo.m_bitsPerSample = 32;
|
|
_buildAudioRenderClient();
|
|
}
|
|
|
|
void _buildAudioRenderClient() {
|
|
m_mixInfo.m_channels = _getAvailableSet();
|
|
unsigned chCount = ChannelCount(m_mixInfo.m_channels);
|
|
|
|
m_5msFrames = m_mixInfo.m_sampleRate * 5 / 1000;
|
|
m_curBufFrame = m_5msFrames;
|
|
m_mixInfo.m_periodFrames = m_5msFrames;
|
|
m_interleavedBuf.resize(m_5msFrames * 2);
|
|
|
|
boo::ChannelMap& chMapOut = m_mixInfo.m_channelMap;
|
|
chMapOut.m_channelCount = 2;
|
|
chMapOut.m_channels[0] = boo::AudioChannel::FrontLeft;
|
|
chMapOut.m_channels[1] = boo::AudioChannel::FrontRight;
|
|
|
|
while (chMapOut.m_channelCount < chCount)
|
|
chMapOut.m_channels[chMapOut.m_channelCount++] = boo::AudioChannel::Unknown;
|
|
}
|
|
|
|
void _rebuildAudioRenderClient(double sampleRate, size_t periodFrames) {
|
|
m_mixInfo.m_periodFrames = periodFrames;
|
|
m_mixInfo.m_sampleRate = sampleRate;
|
|
_buildAudioRenderClient();
|
|
|
|
for (boo::AudioVoice* vox : m_activeVoices)
|
|
vox->_resetSampleRate(vox->m_sampleRateIn);
|
|
for (boo::AudioSubmix* smx : m_activeSubmixes)
|
|
smx->_resetOutputSampleRate();
|
|
}
|
|
|
|
void pumpAndMixVoices() {
|
|
for (size_t f = 0; f < m_renderFrames;) {
|
|
if (m_curBufFrame == m_5msFrames) {
|
|
_pumpAndMixVoices(m_5msFrames, m_interleavedBuf.data());
|
|
m_curBufFrame = 0;
|
|
}
|
|
|
|
size_t remRenderFrames = std::min(m_renderFrames - f, m_5msFrames - m_curBufFrame);
|
|
if (remRenderFrames) {
|
|
for (size_t i = 0; i < 2; ++i) {
|
|
float* bufOut = m_outputData[i];
|
|
for (size_t lf = 0; lf < remRenderFrames; ++lf)
|
|
bufOut[f + lf] = m_interleavedBuf[(m_curBufFrame + lf) * 2 + i];
|
|
}
|
|
m_curBufFrame += remRenderFrames;
|
|
f += remRenderFrames;
|
|
}
|
|
}
|
|
}
|
|
|
|
double getCurrentSampleRate() const { return m_mixInfo.m_sampleRate; }
|
|
};
|
|
|
|
namespace amuse {
|
|
|
|
#define kBackendID CCONST('a', 'm', 'u', 's')
|
|
|
|
static logvisor::Module Log("amuse::AudioUnitBackend");
|
|
|
|
VSTBackend::VSTBackend(audioMasterCallback cb) : AudioEffectX(cb, 0, 0), m_filePresenter(*this), m_editor(*this) {
|
|
isSynth();
|
|
setUniqueID(kBackendID);
|
|
setNumInputs(0);
|
|
setNumOutputs(2);
|
|
setEditor(&m_editor);
|
|
sizeWindow(600, 420);
|
|
programsAreChunks();
|
|
|
|
m_booBackend = std::make_unique<VSTVoiceEngine>();
|
|
m_voxAlloc.emplace(*m_booBackend);
|
|
m_engine.emplace(*m_voxAlloc);
|
|
|
|
WCHAR path[MAX_PATH];
|
|
if (SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, path))) {
|
|
m_userDir = std::wstring(path) + L"\\Amuse";
|
|
CreateDirectory(m_userDir.c_str(), nullptr);
|
|
}
|
|
|
|
m_filePresenter.update();
|
|
}
|
|
|
|
VSTBackend::~VSTBackend() { editor = nullptr; }
|
|
|
|
AEffEditor* VSTBackend::getEditor() { return &m_editor; }
|
|
|
|
VstInt32 VSTBackend::processEvents(VstEvents* events) {
|
|
std::unique_lock<std::mutex> lk(m_lock);
|
|
VSTVoiceEngine& engine = static_cast<VSTVoiceEngine&>(*m_booBackend);
|
|
|
|
/* Handle group load request */
|
|
if (m_curGroup != m_reqGroup) {
|
|
m_curGroup = m_reqGroup;
|
|
if (m_curSeq)
|
|
m_curSeq->kill();
|
|
m_curSeq = m_engine->seqPlay(m_reqGroup, -1, nullptr);
|
|
m_editor.reselectPage();
|
|
}
|
|
|
|
if (engine.m_midiReceiver) {
|
|
for (VstInt32 i = 0; i < events->numEvents; ++i) {
|
|
VstMidiEvent* evt = reinterpret_cast<VstMidiEvent*>(events->events[i]);
|
|
if (evt->type == kVstMidiType) {
|
|
if (m_routeChannel != -1) {
|
|
evt->midiData[0] &= ~0xf;
|
|
evt->midiData[0] |= m_routeChannel & 0xf;
|
|
}
|
|
(*engine.m_midiReceiver)(
|
|
std::vector<uint8_t>(std::cbegin(evt->midiData), std::cbegin(evt->midiData) + evt->byteSize),
|
|
(m_curFrame + evt->deltaFrames) / sampleRate);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void VSTBackend::processReplacing(float**, float** outputs, VstInt32 sampleFrames) {
|
|
std::unique_lock<std::mutex> lk(m_lock);
|
|
VSTVoiceEngine& engine = static_cast<VSTVoiceEngine&>(*m_booBackend);
|
|
|
|
/* Output buffers */
|
|
engine.m_renderFrames = sampleFrames;
|
|
engine.m_outputData = outputs;
|
|
m_engine->pumpEngine();
|
|
|
|
m_curFrame += sampleFrames;
|
|
}
|
|
|
|
VstInt32 VSTBackend::canDo(char* text) {
|
|
VstInt32 returnCode = 0;
|
|
|
|
if (!strcmp(text, "receiveVstEvents"))
|
|
returnCode = 1;
|
|
else if (!strcmp(text, "receiveVstMidiEvent"))
|
|
returnCode = 1;
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
VstPlugCategory VSTBackend::getPlugCategory() { return kPlugCategSynth; }
|
|
|
|
bool VSTBackend::getEffectName(char* text) {
|
|
strcpy(text, "Amuse");
|
|
return true;
|
|
}
|
|
|
|
bool VSTBackend::getProductString(char* text) {
|
|
strcpy(text, "Amuse");
|
|
return true;
|
|
}
|
|
|
|
bool VSTBackend::getVendorString(char* text) {
|
|
strcpy(text, "AxioDL");
|
|
return true;
|
|
}
|
|
|
|
bool VSTBackend::getProgramNameIndexed(VstInt32 category, VstInt32 index, char* text) {
|
|
strcpy(text, "Sampler");
|
|
return true;
|
|
}
|
|
|
|
bool VSTBackend::getOutputProperties(VstInt32 index, VstPinProperties* properties) {
|
|
bool returnCode = false;
|
|
if (index == 0) {
|
|
strcpy(properties->label, "Amuse Out");
|
|
properties->flags = kVstPinIsStereo | kVstPinIsActive;
|
|
properties->arrangementType = kSpeakerArrStereo;
|
|
returnCode = true;
|
|
}
|
|
return returnCode;
|
|
}
|
|
|
|
VstInt32 VSTBackend::getNumMidiInputChannels() { return 1; }
|
|
|
|
void VSTBackend::setSampleRate(float sampleRate) {
|
|
AudioEffectX::setSampleRate(sampleRate);
|
|
VSTVoiceEngine& engine = static_cast<VSTVoiceEngine&>(*m_booBackend);
|
|
engine._rebuildAudioRenderClient(sampleRate, engine.mixInfo().m_periodFrames);
|
|
}
|
|
|
|
void VSTBackend::setBlockSize(VstInt32 blockSize) {
|
|
AudioEffectX::setBlockSize(blockSize);
|
|
VSTVoiceEngine& engine = static_cast<VSTVoiceEngine&>(*m_booBackend);
|
|
engine._rebuildAudioRenderClient(engine.mixInfo().m_sampleRate, blockSize);
|
|
}
|
|
|
|
void VSTBackend::loadGroupFile(int collectionIdx, int fileIdx) {
|
|
std::unique_lock<std::mutex> lk(m_lock);
|
|
|
|
if (m_curSeq) {
|
|
m_curSeq->kill();
|
|
m_curSeq.reset();
|
|
m_curGroup = -1;
|
|
m_reqGroup = -1;
|
|
}
|
|
|
|
if (collectionIdx < m_filePresenter.m_iteratorVec.size()) {
|
|
AudioGroupFilePresenter::CollectionIterator& it = m_filePresenter.m_iteratorVec[collectionIdx];
|
|
if (fileIdx < it->second->m_iteratorVec.size()) {
|
|
AudioGroupCollection::GroupIterator& git = it->second->m_iteratorVec[fileIdx];
|
|
if (m_curData)
|
|
m_curData->removeFromEngine(*m_engine);
|
|
git->second->addToEngine(*m_engine);
|
|
m_curData = git->second.get();
|
|
}
|
|
}
|
|
}
|
|
|
|
void VSTBackend::setGroup(int groupIdx, bool immediate) {
|
|
std::unique_lock<std::mutex> lk(m_lock);
|
|
|
|
if (!m_curData)
|
|
return;
|
|
|
|
if (groupIdx < m_curData->m_groupTokens.size()) {
|
|
const AudioGroupDataCollection::GroupToken& groupTok = m_curData->m_groupTokens[groupIdx];
|
|
m_reqGroup = groupTok.m_groupId;
|
|
if (immediate) {
|
|
if (m_curSeq)
|
|
m_curSeq->kill();
|
|
m_curSeq = m_engine->seqPlay(groupTok.m_groupId, -1, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
void VSTBackend::_setNormalProgram(int programNo) {
|
|
if (!m_curSeq)
|
|
return;
|
|
m_curSeq->setChanProgram(0, programNo);
|
|
m_routeChannel = 0;
|
|
}
|
|
|
|
void VSTBackend::setNormalProgram(int programNo) {
|
|
std::unique_lock<std::mutex> lk(m_lock);
|
|
_setNormalProgram(programNo);
|
|
}
|
|
|
|
void VSTBackend::_setDrumProgram(int programNo) {
|
|
if (!m_curSeq)
|
|
return;
|
|
m_curSeq->setChanProgram(9, programNo);
|
|
m_routeChannel = 9;
|
|
}
|
|
|
|
void VSTBackend::setDrumProgram(int programNo) {
|
|
std::unique_lock<std::mutex> lk(m_lock);
|
|
_setDrumProgram(programNo);
|
|
}
|
|
|
|
VstInt32 VSTBackend::getChunk(void** data, bool) {
|
|
size_t allocSz = 14;
|
|
if (m_curData)
|
|
allocSz += (m_curData->m_path.size() - m_userDir.size() - 1) * 2;
|
|
|
|
uint8_t* buf = new uint8_t[allocSz];
|
|
if (m_curData)
|
|
memmove(buf, m_curData->m_path.data() + m_userDir.size() + 1, allocSz - 12);
|
|
else
|
|
*reinterpret_cast<wchar_t*>(buf) = L'\0';
|
|
uint32_t* intVals = reinterpret_cast<uint32_t*>(buf + allocSz - 12);
|
|
intVals[0] = 0;
|
|
intVals[1] = m_editor.m_selGroupIdx;
|
|
intVals[2] = m_editor.m_selPageIdx;
|
|
*data = buf;
|
|
return allocSz;
|
|
}
|
|
|
|
VstInt32 VSTBackend::setChunk(void* data, VstInt32 byteSize, bool) {
|
|
if (byteSize < 14)
|
|
return 0;
|
|
|
|
wchar_t* path = reinterpret_cast<wchar_t*>(data);
|
|
uint32_t* intVals = reinterpret_cast<uint32_t*>(path + wcslen(path) + 1);
|
|
std::wstring targetPath = m_userDir + L'\\' + path;
|
|
uint32_t groupIdx = intVals[1];
|
|
uint32_t pageIdx = intVals[2];
|
|
|
|
size_t colIdx = 0;
|
|
for (auto& collection : m_filePresenter.m_audioGroupCollections) {
|
|
size_t fileIdx = 0;
|
|
for (auto& file : collection.second->m_groups) {
|
|
if (file.second->m_path == targetPath) {
|
|
m_editor.selectCollection(LPARAM(0x80000000 | (colIdx << 16) | fileIdx));
|
|
m_editor.selectGroup(groupIdx);
|
|
m_editor.selectPage(pageIdx);
|
|
m_editor._reselectColumns();
|
|
}
|
|
++fileIdx;
|
|
}
|
|
++colIdx;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
} // namespace amuse
|
|
|
|
AudioEffect* createEffectInstance(audioMasterCallback audioMaster) { return new amuse::VSTBackend(audioMaster); }
|