3dtours/SonicForgeStudio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

G2: JUCE VST3 hosting + latency that qua FxLatReport - probe pureComp 2108

Browse Source
This commit is contained in:
Lộc Phạm
2026-08-28 15:28:06 +07:00
parent 091abe5a91
commit c72362e088
6 changed files with 255 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
native_bridge/juce_fx/JuceFxEngine.cpp
+160 -5
View File
@@ -1,19 +1,96 @@
// native_bridge/juce_fx/JuceFxEngine.cpp
// Implementation: AudioProcessorGraph với input/output node — chain rỗng G1.
// G2: nạp VST3 theo fx_chain (path, preset_b64, bypass), chèn node giữa
// input/output; latency thật = graph.getLatencySamples() (PDC nội bộ graph).
#include "JuceFxEngine.h"
#include <juce_audio_processors/juce_audio_processors.h>
#include "sheredom_json.h"
#include <algorithm>
#include <array>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
namespace {
// --- base64 decode (RFC 4648) — như RenderFxJob.cpp -------------------------
int b64val(unsigned char c) {
if (c >= 'A' && c <= 'Z') return (int)(c - 'A');
if (c >= 'a' && c <= 'z') return (int)(c - 'a') + 26;
if (c >= '0' && c <= '9') return (int)(c - '0') + 52;
if (c == '+') return 62;
if (c == '/') return 63;
return -1;
}
bool base64Decode(const std::string& in, std::vector<uint8_t>& out) {
out.clear();
out.reserve((in.size() / 4) * 3);
uint32_t acc = 0;
int bits = 0;
for (unsigned char ch : in) {
if (ch == '=' || ch == '\n' || ch == '\r' || ch == ' ') continue;
int v = b64val(ch);
if (v < 0) return false;
acc = (acc << 6) | (uint32_t)v;
bits += 6;
if (bits >= 8) {
bits -= 8;
out.push_back((uint8_t)((acc >> bits) & 0xFF));
}
}
return true;
}
// --- sheredom helpers (giống RenderFxJob.cpp) -------------------------------
const json_object_element_s* jMember(const json_object_s* o, const char* key) {
for (const json_object_element_s* e = o ? o->start : nullptr; e; e = e->next)
if (e->name && e->name->string && std::strcmp(e->name->string, key) == 0)
return e;
return nullptr;
}
std::string jString(const json_object_s* o, const char* key, const std::string& def) {
const json_object_element_s* m = jMember(o, key);
if (m && m->value && m->value->type == json_type_string) {
const auto* s = static_cast<const json_string_s*>(m->value->payload);
return std::string(s->string, s->string_size);
}
return def;
}
bool jBool(const json_object_s* o, const char* key, bool def) {
const json_object_element_s* m = jMember(o, key);
if (m && m->value) {
if (m->value->type == json_type_true) return true;
if (m->value->type == json_type_false) return false;
}
return def;
}
} // namespace
struct JuceFxEngine::Slot {
std::string type;
std::string path;
std::string presetB64;
bool bypass = false;
};
struct JuceFxEngine::Impl {
juce::AudioProcessorGraph graph;
juce::AudioBuffer<float> buf;
uint32_t sampleRate = 0;
uint32_t blockSize = 0;
bool prepared = false;
std::vector<Slot> slots; // chain đã parse (thứ tự slot)
std::vector<juce::AudioProcessorGraph::Node::Ptr> pluginNodes; // node theo slot (null = bỏ qua)
std::vector<uint32_t> slotLatencies; // latency thật từng slot (0 = skip/bypass/fail)
uint32_t totalLatency = 0;
};
JuceFxEngine::JuceFxEngine() : impl_(std::make_unique<Impl>()) {}
@@ -28,6 +105,30 @@ void JuceFxEngine::shutdown() {
impl_->sampleRate = 0;
impl_->blockSize = 0;
}
impl_->pluginNodes.clear();
impl_->slotLatencies.assign(impl_->slots.size(), 0);
impl_->totalLatency = 0;
}
void JuceFxEngine::setChain(const std::string& chainJson) {
// Parse mảng JSON fx_chain: [ {type,path,preset_b64,bypass}, ... ].
impl_->slots.clear();
json_value_s* root = json_parse(chainJson.data(), chainJson.size());
if (root && root->type == json_type_array) {
const auto* arr = static_cast<const json_array_s*>(root->payload);
for (const json_array_element_s* el = arr->start; el; el = el->next) {
const json_value_s* v = el->value;
if (!v || v->type != json_type_object) continue;
const auto* o = static_cast<const json_object_s*>(v->payload);
Slot s;
s.type = jString(o, "type", "");
s.path = jString(o, "path", "");
s.presetB64 = jString(o, "preset_b64", "");
s.bypass = jBool(o, "bypass", false);
impl_->slots.push_back(std::move(s));
}
}
if (root) free(root);
}
void JuceFxEngine::prepare(uint32_t sampleRate, uint32_t blockSize) {
@@ -40,8 +141,6 @@ void JuceFxEngine::prepare(uint32_t sampleRate, uint32_t blockSize) {
impl_->blockSize = blockSize;
impl_->graph.setPlayConfigDetails(2, 2, (double)sampleRate, (int)blockSize);
// Chain rỗng G1: audio input -> audio output (passthrough). G2: chèn
// plugin node giữa hai node này theo fx_chain.
auto& g = impl_->graph;
const auto inNode = g.addNode(std::make_unique<
juce::AudioProcessorGraph::AudioGraphIOProcessor>(
@@ -51,14 +150,66 @@ void JuceFxEngine::prepare(uint32_t sampleRate, uint32_t blockSize) {
juce::AudioProcessorGraph::AudioGraphIOProcessor::audioOutputNode));
using NCh = juce::AudioProcessorGraph::NodeAndChannel;
using Conn = juce::AudioProcessorGraph::Connection;
// G2: nạp VST3 theo chain — nối nối tiếp in -> p0 -> p1 -> ... -> out.
// Slot bypass / type khác vst3 / load fail → passthrough (latency 0).
impl_->pluginNodes.assign(impl_->slots.size(), nullptr);
impl_->slotLatencies.assign(impl_->slots.size(), 0);
juce::AudioProcessorGraph::Node::Ptr prev = inNode;
for (size_t i = 0; i < impl_->slots.size(); ++i) {
const Slot& s = impl_->slots[i];
if (s.bypass || (s.type != "vst3" && s.type != "vst") || s.path.empty())
continue;
juce::VST3PluginFormat fmt;
juce::OwnedArray<juce::PluginDescription> descs;
fmt.findAllTypesForFile(descs, juce::File(s.path).getFullPathName());
if (descs.isEmpty()) {
std::cerr << "[JuceFxEngine] slot " << i << " no VST3 desc: "
<< s.path << std::endl;
continue;
}
auto inst = fmt.createInstanceFromDescription(*descs.getFirst(),
(double)sampleRate,
(int)blockSize);
if (!inst) {
std::cerr << "[JuceFxEngine] slot " << i << " createInstance fail: "
<< s.path << std::endl;
continue;
}
if (!s.presetB64.empty()) {
std::vector<uint8_t> bytes;
if (base64Decode(s.presetB64, bytes) && !bytes.empty()) {
juce::MemoryBlock mb(bytes.data(), bytes.size());
if (juce::VST3PluginFormat::setStateFromVSTPresetFile(inst.get(), mb))
std::cerr << "[JuceFxEngine] slot " << i << " preset applied" << std::endl;
else
std::cerr << "[JuceFxEngine] slot " << i << " preset FAILED" << std::endl;
}
}
auto node = g.addNode(std::unique_ptr<juce::AudioProcessor>(std::move(inst)));
impl_->pluginNodes[i] = node;
for (int ch = 0; ch < 2; ++ch) {
NCh src; src.nodeID = prev->nodeID; src.channelIndex = ch;
NCh dst; dst.nodeID = node->nodeID; dst.channelIndex = ch;
g.addConnection(Conn(src, dst));
}
prev = node;
}
for (int ch = 0; ch < 2; ++ch) {
NCh src; src.nodeID = inNode->nodeID; src.channelIndex = ch;
NCh src; src.nodeID = prev->nodeID; src.channelIndex = ch;
NCh dst; dst.nodeID = outNode->nodeID; dst.channelIndex = ch;
g.addConnection(Conn(src, dst));
}
g.prepareToPlay((double)sampleRate, (int)(blockSize * 4)); // batch tối đa 4 block
impl_->buf.setSize(2, (int)(blockSize * 4), false, false, true);
// Latency thật từng slot sau prepareToPlay (plugin set trong prepare).
for (size_t i = 0; i < impl_->pluginNodes.size(); ++i)
if (impl_->pluginNodes[i])
impl_->slotLatencies[i] =
(uint32_t)impl_->pluginNodes[i]->getProcessor()->getLatencySamples();
impl_->totalLatency = (uint32_t)g.getLatencySamples();
impl_->prepared = true;
}
@@ -70,7 +221,7 @@ void JuceFxEngine::process(float* inL, float* inR, uint32_t n) {
b.copyFrom(1, 0, inR, (int)n);
juce::MidiBuffer midi;
impl_->graph.processBlock(b, midi);
// G1 passthrough: copy kết quả về buffer đầu vào (in-place như contract).
// Graph PDC nội bộ: output đã align dry/wet — copy về in-place như contract.
const auto* outL = b.getReadPointer(0);
const auto* outR = b.getReadPointer(1);
std::copy(outL, outL + n, inL);
@@ -78,5 +229,9 @@ void JuceFxEngine::process(float* inL, float* inR, uint32_t n) {
}
uint32_t JuceFxEngine::latencySamples() const {
return impl_->prepared ? (uint32_t)impl_->graph.getLatencySamples() : 0u;
return impl_->prepared ? impl_->totalLatency : 0u;
}
std::vector<uint32_t> JuceFxEngine::entryLatencies() const {
return impl_->slotLatencies;
}