VST Host

VSTHost.cpp

#include "../JuceLibraryCode/JuceHeader.h"

class App : public JUCEApplication {
 public:
  App() {}
  ~App() {}

  void initialise(const String& commandLine) override {
    AudioPluginInstance* plugin = findAndCreateVST(commandLine.getIntValue());
    AudioProcessorGraph* graph = buildBasicGraph();
    AudioProcessorGraph::Node* pluginNode = graph->addNode(plugin);

    // Add audio in to pluginNode
    graph->addConnection(graph->getNode(0)->nodeId, 0, pluginNode->nodeId, 0);

    // Add midi in to pluginNode
    graph->addConnection(
        graph->getNode(2)->nodeId, AudioProcessorGraph::midiChannelIndex,
        pluginNode->nodeId, AudioProcessorGraph::midiChannelIndex);

    // Add pluginNode to audio out
    graph->addConnection(pluginNode->nodeId, 0, graph->getNode(1)->nodeId, 0);

    std::cout << "Started\n";
  }

  AudioPluginInstance* findAndCreateVST(int index) {
    std::cout << "You selected plugin number: ";
    std::cout << index;
    std::cout << "\n";

    AudioPluginFormatManager* pluginManager = new AudioPluginFormatManager();
    KnownPluginList* list = loadPlugins(pluginManager);

    PluginDescription* desc = list->getType(index);

    String error;
    AudioPluginInstance* plugin =
        pluginManager->createPluginInstance(*desc, 0, 0, error);

    if (!error.isEmpty()) {
      std::cout << "Could not initialize the specified plugin: ";
      std::cout << desc->name;
      std::cout << "\n";
    }

    return plugin;
  }

  AudioProcessorGraph* buildBasicGraph() {
    AudioDeviceManager* device = new AudioDeviceManager();
    device->initialiseWithDefaultDevices(3, 2);
    device->setMidiInputEnabled("my-midi", true);
    device->addMidiInputCallback("my-midi", player);

    AudioProcessorPlayer* player = new AudioProcessorPlayer();
    AudioProcessorGraph* graph = new AudioProcessorGraph();

    player->setProcessor(graph);
    device->addAudioCallback(player);
    graph->clear();

    AudioProcessorGraph::AudioGraphIOProcessor* in;
    in = new AudioProcessorGraph::AudioGraphIOProcessor(
        AudioProcessorGraph::AudioGraphIOProcessor::audioInputNode);

    AudioProcessorGraph::AudioGraphIOProcessor* out;
    out = new AudioProcessorGraph::AudioGraphIOProcessor(
        AudioProcessorGraph::AudioGraphIOProcessor::audioOutputNode);

    AudioProcessorGraph::AudioGraphIOProcessor* midiIn;
    midiIn = new AudioProcessorGraph::AudioGraphIOProcessor(
        AudioProcessorGraph::AudioGraphIOProcessor::midiInputNode);

    graph->addNode(in);
    graph->addNode(out);
    graph->addNode(midiIn);

    return graph;
  }

  KnownPluginList* loadPlugins(AudioPluginFormatManager* pluginManager) {
    std::cout << "======SCANNING FOR PLUGINS======\n";

    pluginManager->addDefaultFormats();

    KnownPluginList* list = new KnownPluginList();
    File file;

    for (int i = 0; i < pluginManager->getNumFormats(); i++) {
      AudioPluginFormat* format = pluginManager->getFormat(i);

      PluginDirectoryScanner* scanner = new PluginDirectoryScanner(
          *list, *format, format->getDefaultLocationsToSearch(), true, file,
          false);

      String name;
      while (scanner->scanNextFile(true, name)) {
        // Load each plugin and then continue
      }
    }

    std::cout << "=======SCANNING DONE=======\n";
    std::cout << "Loaded a total of ";
    std::cout << list->getNumTypes();
    std::cout << " plugins. \n";

    std::cout << "========PLUGIN LIST========\n";
    for (int i = 0; i < list->getNumTypes(); i++) {
      std::cout << i;
      std::cout << ": ";
      std::cout << list->getType(i)->name;
      std::cout << "\n";
    }

    return list;
  }

  void shutdown() override { std::cout << "Goodbye"; }

  const String getApplicationName() override { return "VST HOST"; }

  const String getApplicationVersion() override { return "1.0"; }
};
// this generates boilerplate code to launch our app class:
START_JUCE_APPLICATION(App)