summaryrefslogtreecommitdiff
path: root/rotord/vampHost.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'rotord/vampHost.cpp')
-rw-r--r--rotord/vampHost.cpp281
1 files changed, 281 insertions, 0 deletions
diff --git a/rotord/vampHost.cpp b/rotord/vampHost.cpp
new file mode 100644
index 0000000..8423c54
--- /dev/null
+++ b/rotord/vampHost.cpp
@@ -0,0 +1,281 @@
+#include "vampHost.h"
+
+int vampHost::runPlugin(string myname, string soname, string id,
+ string output, int outputNo, string wavname,
+ string outfilename, bool useFrames)
+{
+ PluginLoader *loader = PluginLoader::getInstance();
+
+ PluginLoader::PluginKey key = loader->composePluginKey(soname, id);
+
+ SNDFILE *sndfile;
+ SF_INFO sfinfo;
+ memset(&sfinfo, 0, sizeof(SF_INFO));
+
+ sndfile = sf_open(wavname.c_str(), SFM_READ, &sfinfo);
+ if (!sndfile) {
+ cerr << myname << ": ERROR: Failed to open input file \""
+ << wavname << "\": " << sf_strerror(sndfile) << endl;
+ return 1;
+ }
+
+ ofstream *out = 0;
+ if (outfilename != "") {
+ out = new ofstream(outfilename.c_str(), ios::out);
+ if (!*out) {
+ cerr << myname << ": ERROR: Failed to open output file \""
+ << outfilename << "\" for writing" << endl;
+ delete out;
+ return 1;
+ }
+ }
+
+ Plugin *plugin = loader->loadPlugin
+ (key, sfinfo.samplerate, PluginLoader::ADAPT_ALL_SAFE);
+ if (!plugin) {
+ cerr << myname << ": ERROR: Failed to load plugin \"" << id
+ << "\" from library \"" << soname << "\"" << endl;
+ sf_close(sndfile);
+ if (out) {
+ out->close();
+ delete out;
+ }
+ return 1;
+ }
+
+ cerr << "Running plugin: \"" << plugin->getIdentifier() << "\"..." << endl;
+
+ // Note that the following would be much simpler if we used a
+ // PluginBufferingAdapter as well -- i.e. if we had passed
+ // PluginLoader::ADAPT_ALL to loader->loadPlugin() above, instead
+ // of ADAPT_ALL_SAFE. Then we could simply specify our own block
+ // size, keep the step size equal to the block size, and ignore
+ // the plugin's bleatings. However, there are some issues with
+ // using a PluginBufferingAdapter that make the results sometimes
+ // technically different from (if effectively the same as) the
+ // un-adapted plugin, so we aren't doing that here. See the
+ // PluginBufferingAdapter documentation for details.
+
+ int blockSize = plugin->getPreferredBlockSize();
+ int stepSize = plugin->getPreferredStepSize();
+
+ if (blockSize == 0) {
+ blockSize = 1024;
+ }
+ if (stepSize == 0) {
+ if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
+ stepSize = blockSize/2;
+ } else {
+ stepSize = blockSize;
+ }
+ } else if (stepSize > blockSize) {
+ cerr << "WARNING: stepSize " << stepSize << " > blockSize " << blockSize << ", resetting blockSize to ";
+ if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
+ blockSize = stepSize * 2;
+ } else {
+ blockSize = stepSize;
+ }
+ cerr << blockSize << endl;
+ }
+ int overlapSize = blockSize - stepSize;
+ sf_count_t currentStep = 0;
+ int finalStepsRemaining = max(1, (blockSize / stepSize) - 1); // at end of file, this many part-silent frames needed after we hit EOF
+
+ int channels = sfinfo.channels;
+
+ float *filebuf = new float[blockSize * channels];
+ float **plugbuf = new float*[channels];
+ for (int c = 0; c < channels; ++c) plugbuf[c] = new float[blockSize + 2];
+
+ cerr << "Using block size = " << blockSize << ", step size = "
+ << stepSize << endl;
+
+ // The channel queries here are for informational purposes only --
+ // a PluginChannelAdapter is being used automatically behind the
+ // scenes, and it will take case of any channel mismatch
+
+ int minch = plugin->getMinChannelCount();
+ int maxch = plugin->getMaxChannelCount();
+ cerr << "Plugin accepts " << minch << " -> " << maxch << " channel(s)" << endl;
+ cerr << "Sound file has " << channels << " (will mix/augment if necessary)" << endl;
+
+ Plugin::OutputList outputs = plugin->getOutputDescriptors();
+ Plugin::OutputDescriptor od;
+
+ int returnValue = 1;
+ int progress = 0;
+
+ RealTime rt;
+ PluginWrapper *wrapper = 0;
+ RealTime adjustment = RealTime::zeroTime;
+
+ if (outputs.empty()) {
+ cerr << "ERROR: Plugin has no outputs!" << endl;
+ goto done;
+ }
+
+ if (outputNo < 0) {
+
+ for (size_t oi = 0; oi < outputs.size(); ++oi) {
+ if (outputs[oi].identifier == output) {
+ outputNo = oi;
+ break;
+ }
+ }
+
+ if (outputNo < 0) {
+ cerr << "ERROR: Non-existent output \"" << output << "\" requested" << endl;
+ goto done;
+ }
+
+ } else {
+
+ if (int(outputs.size()) <= outputNo) {
+ cerr << "ERROR: Output " << outputNo << " requested, but plugin has only " << outputs.size() << " output(s)" << endl;
+ goto done;
+ }
+ }
+
+ od = outputs[outputNo];
+ cerr << "Output is: \"" << od.identifier << "\"" << endl;
+
+ if (!plugin->initialise(channels, stepSize, blockSize)) {
+ cerr << "ERROR: Plugin initialise (channels = " << channels
+ << ", stepSize = " << stepSize << ", blockSize = "
+ << blockSize << ") failed." << endl;
+ goto done;
+ }
+
+ wrapper = dynamic_cast<PluginWrapper *>(plugin);
+ if (wrapper) {
+ // See documentation for
+ // PluginInputDomainAdapter::getTimestampAdjustment
+ PluginInputDomainAdapter *ida =
+ wrapper->getWrapper<PluginInputDomainAdapter>();
+ if (ida) adjustment = ida->getTimestampAdjustment();
+ }
+
+ // Here we iterate over the frames, avoiding asking the numframes in case it's streaming input.
+ do {
+
+ int count;
+
+ if ((blockSize==stepSize) || (currentStep==0)) {
+ // read a full fresh block
+ if ((count = sf_readf_float(sndfile, filebuf, blockSize)) < 0) {
+ cerr << "ERROR: sf_readf_float failed: " << sf_strerror(sndfile) << endl;
+ break;
+ }
+ if (count != blockSize) --finalStepsRemaining;
+ } else {
+ // otherwise shunt the existing data down and read the remainder.
+ memmove(filebuf, filebuf + (stepSize * channels), overlapSize * channels * sizeof(float));
+ if ((count = sf_readf_float(sndfile, filebuf + (overlapSize * channels), stepSize)) < 0) {
+ cerr << "ERROR: sf_readf_float failed: " << sf_strerror(sndfile) << endl;
+ break;
+ }
+ if (count != stepSize) --finalStepsRemaining;
+ count += overlapSize;
+ }
+
+ for (int c = 0; c < channels; ++c) {
+ int j = 0;
+ while (j < count) {
+ plugbuf[c][j] = filebuf[j * sfinfo.channels + c];
+ ++j;
+ }
+ while (j < blockSize) {
+ plugbuf[c][j] = 0.0f;
+ ++j;
+ }
+ }
+
+ rt = RealTime::frame2RealTime(currentStep * stepSize, sfinfo.samplerate);
+
+ printFeatures
+ (RealTime::realTime2Frame(rt + adjustment, sfinfo.samplerate),
+ sfinfo.samplerate, outputNo, plugin->process(plugbuf, rt),
+ out, useFrames);
+
+ if (sfinfo.frames > 0){
+ int pp = progress;
+ progress = lrintf((float(currentStep * stepSize) / sfinfo.frames) * 100.f);
+ if (progress != pp && out) {
+ cerr << "\r" << progress << "%";
+ }
+ }
+
+ ++currentStep;
+
+ } while (finalStepsRemaining > 0);
+
+ if (out) cerr << "\rDone" << endl;
+
+ rt = RealTime::frame2RealTime(currentStep * stepSize, sfinfo.samplerate);
+
+ printFeatures(RealTime::realTime2Frame(rt + adjustment, sfinfo.samplerate),
+ sfinfo.samplerate, outputNo,
+ plugin->getRemainingFeatures(), out, useFrames);
+
+ returnValue = 0;
+
+done:
+ delete plugin;
+ if (out) {
+ out->close();
+ delete out;
+ }
+ sf_close(sndfile);
+ return returnValue;
+}
+
+void vampHost::printFeatures(int frame, int sr, int output,
+ Plugin::FeatureSet features, ofstream *out, bool useFrames)
+{
+ for (unsigned int i = 0; i < features[output].size(); ++i) {
+
+ if (useFrames) {
+
+ int displayFrame = frame;
+
+ if (features[output][i].hasTimestamp) {
+ displayFrame = RealTime::realTime2Frame
+ (features[output][i].timestamp, sr);
+ }
+
+ (out ? *out : cout) << displayFrame;
+
+ if (features[output][i].hasDuration) {
+ displayFrame = RealTime::realTime2Frame
+ (features[output][i].duration, sr);
+ (out ? *out : cout) << "," << displayFrame;
+ }
+
+ (out ? *out : cout) << ":";
+
+ } else {
+
+ RealTime rt = RealTime::frame2RealTime(frame, sr);
+
+ if (features[output][i].hasTimestamp) {
+ rt = features[output][i].timestamp;
+ }
+
+ (out ? *out : cout) << rt.toString();
+
+ if (features[output][i].hasDuration) {
+ rt = features[output][i].duration;
+ (out ? *out : cout) << "," << rt.toString();
+ }
+
+ (out ? *out : cout) << ":";
+ }
+
+ for (unsigned int j = 0; j < features[output][i].values.size(); ++j) {
+ (out ? *out : cout) << " " << features[output][i].values[j];
+ }
+ (out ? *out : cout) << " " << features[output][i].label;
+
+ (out ? *out : cout) << endl;
+ }
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-06 18:33:33 +0000