VST3: Build validator from sdk and extract to a temp file at run time

Author: drowaudio

CLAUDE.md

@@ -100,7 +100,8 @@ pluginval/
 ├── modules/
 │   └── juce/                 # JUCE framework (git submodule)
 ├── cmake/
-│   └── CPM.cmake             # CMake Package Manager
+│   ├── CPM.cmake             # CMake Package Manager
+│   └── GenerateBinaryHeader.cmake  # Binary-to-C-header converter
 ├── tests/
 │   ├── AddPluginvalTests.cmake  # CMake module for CTest integration
 │   ├── test_plugins/         # Test plugin files
@@ -221,23 +222,22 @@ struct Requirements {
 
 ### VST3 Validator Integration
 
-The VST3 validator (Steinberg's vstvalidator) is embedded directly into pluginval when built with `PLUGINVAL_VST3_VALIDATOR=ON` (the default). This eliminates the need to provide an external validator binary path.
+The VST3 validator (Steinberg's vstvalidator) is embedded into pluginval when built with `PLUGINVAL_VST3_VALIDATOR=ON` (the default). This provides single-file distribution while keeping vstvalidator completely isolated from pluginval's link dependencies.
 
 **Architecture:**
 1. The VST3 SDK is fetched via CPM during CMake configure
-2. `VST3ValidatorRunner` (`Source/vst3validator/`) wraps the SDK's validation functionality
-3. When the `VST3validator` test runs, it spawns pluginval with `--vst3-validator-mode`
-4. This subprocess runs the embedded validator code in isolation (crash protection)
+2. The SDK's own `validator` target is built as a separate executable
+3. A CMake script (`cmake/GenerateBinaryHeader.cmake`) converts the compiled binary into a C byte array header
+4. `VST3ValidatorRunner` (`Source/vst3validator/`) extracts the embedded binary to a temp file on first use
+5. When the `VST3validator` test runs, it spawns the extracted validator as a subprocess
 
-**Internal CLI mode:**
-```bash
-# Used internally by the VST3validator test - not for direct use
-pluginval --vst3-validator-mode /path/to/plugin.vst3 [-e] [-v]
-```
+**Key files:**
+- `cmake/GenerateBinaryHeader.cmake` — binary-to-C-header conversion script
+- `Source/vst3validator/VST3ValidatorRunner.h/cpp` — extracts embedded binary, returns `juce::File`
 
 **Disabling embedded validator:**
 ```bash
-cmake -B Builds -DPLUGINAL_VST3_VALIDATOR=OFF .
+cmake -B Builds -DPLUGINVAL_VST3_VALIDATOR=OFF .
 ```
 
 ## Adding New Tests

CMakeLists.txt

@@ -87,12 +87,6 @@ if(PLUGINVAL_VST3_VALIDATOR)
     )
 endif()
 
-option(PLUGINVAL_FETCH_JUCE "Fetch JUCE along with pluginval" ON)
-
-if(PLUGINVAL_FETCH_JUCE)
-    add_subdirectory(modules/juce)
-endif()
-
 if (DEFINED ENV{VST2_SDK_DIR})
     MESSAGE(STATUS "Building with VST2 SDK: $ENV{VST2_SDK_DIR}")
     juce_set_vst2_sdk_path($ENV{VST2_SDK_DIR})
@@ -137,47 +131,14 @@ set(SourceFiles
 target_sources(pluginval PRIVATE ${SourceFiles})
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/Source PREFIX Source FILES ${SourceFiles})
 
-# Add VST3 validator sources if enabled
+# Add VST3 validator runner sources to pluginval (extracts embedded binary at runtime)
 if(PLUGINVAL_VST3_VALIDATOR)
     set(VST3ValidatorFiles
         Source/vst3validator/VST3ValidatorRunner.h
         Source/vst3validator/VST3ValidatorRunner.cpp
     )
-
-    # Add platform-specific module loading sources from the SDK
-    if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-        list(APPEND VST3ValidatorFiles
-            ${vst3sdk_SOURCE_DIR}/public.sdk/source/vst/hosting/module_linux.cpp)
-    elseif(APPLE)
-        set(VST3_MODULE_MAC_FILE ${vst3sdk_SOURCE_DIR}/public.sdk/source/vst/hosting/module_mac.mm)
-        list(APPEND VST3ValidatorFiles ${VST3_MODULE_MAC_FILE})
-        # module_mac.mm requires ARC (Automatic Reference Counting)
-        set_source_files_properties(${VST3_MODULE_MAC_FILE} PROPERTIES
-            COMPILE_FLAGS "-fobjc-arc")
-    elseif(WIN32)
-        set(VST3_MODULE_WIN32_FILE ${vst3sdk_SOURCE_DIR}/public.sdk/source/vst/hosting/module_win32.cpp)
-        list(APPEND VST3ValidatorFiles ${VST3_MODULE_WIN32_FILE})
-        # module_win32.cpp requires C++17 (not C++20) because generic_u8string() returns
-        # std::u8string in C++20 but std::string in C++17, and the SDK code expects std::string.
-        # Also set UNICODE definitions only for this file to avoid affecting JUCE's LV2/lilv code.
-        set_source_files_properties(${VST3_MODULE_WIN32_FILE} PROPERTIES
-            COMPILE_FLAGS "/std:c++17"
-            COMPILE_DEFINITIONS "NOMINMAX;WIN32_LEAN_AND_MEAN;_UNICODE;UNICODE")
-    endif()
-
     target_sources(pluginval PRIVATE ${VST3ValidatorFiles})
     source_group("Source/vst3validator" FILES ${VST3ValidatorFiles})
-
-    target_include_directories(pluginval PRIVATE
-        ${vst3sdk_SOURCE_DIR}
-        ${vst3sdk_SOURCE_DIR}/pluginterfaces
-        ${vst3sdk_SOURCE_DIR}/base
-        ${vst3sdk_SOURCE_DIR}/public.sdk
-        ${vst3sdk_SOURCE_DIR}/public.sdk/source
-        ${vst3sdk_SOURCE_DIR}/public.sdk/source/vst
-        ${vst3sdk_SOURCE_DIR}/public.sdk/source/vst/hosting
-        ${vst3sdk_SOURCE_DIR}/public.sdk/source/vst/utility
-    )
 endif()
 
 if (DEFINED ENV{VST2_SDK_DIR})
@@ -198,15 +159,6 @@ target_compile_definitions(pluginval PRIVATE
     $<$<BOOL:${PLUGINVAL_VST3_VALIDATOR}>:PLUGINVAL_VST3_VALIDATOR=1>
     VERSION="${CURRENT_VERSION}")
 
-# Windows-specific compile definitions for VST3 SDK compatibility
-# Note: _UNICODE and UNICODE are NOT set here - they're set only for module_win32.cpp
-# to avoid breaking JUCE's LV2/lilv code which uses ANSI Windows APIs
-if(WIN32 AND PLUGINVAL_VST3_VALIDATOR)
-    target_compile_definitions(pluginval PRIVATE
-        NOMINMAX
-        WIN32_LEAN_AND_MEAN
-        _CRT_SECURE_NO_WARNINGS)
-endif()
 
 if(MSVC AND NOT CMAKE_MSVC_RUNTIME_LIBRARY)
     # Default to statically linking the runtime libraries
@@ -225,24 +177,20 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
         -static-libstdc++)
 endif()
 
-if (PLUGINVAL_VST3_VALIDATOR)
-    target_link_libraries(pluginval PRIVATE
-        sdk_hosting
-        sdk)
-
-    # Windows needs additional libraries for the module loading code
-    if(WIN32)
-        target_link_libraries(pluginval PRIVATE
-            Ole32
-            Shell32)
-    endif()
-
-    # macOS needs Cocoa framework for module loading
-    if(APPLE)
-        find_library(COCOA_FRAMEWORK Cocoa)
-        target_link_libraries(pluginval PRIVATE
-            ${COCOA_FRAMEWORK})
-    endif()
+# Embed the SDK's validator binary into pluginval
+if(PLUGINVAL_VST3_VALIDATOR)
+    set(VSTVALIDATOR_HEADER "${CMAKE_BINARY_DIR}/generated/vstvalidator_data.h")
+    add_custom_command(
+        OUTPUT "${VSTVALIDATOR_HEADER}"
+        COMMAND ${CMAKE_COMMAND}
+            -DINPUT_FILE=$<TARGET_FILE:validator>
+            -DOUTPUT_FILE=${VSTVALIDATOR_HEADER}
+            -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/GenerateBinaryHeader.cmake
+        DEPENDS validator
+        COMMENT "Embedding vstvalidator binary into header...")
+
+    target_sources(pluginval PRIVATE "${VSTVALIDATOR_HEADER}")
+    target_include_directories(pluginval PRIVATE "${CMAKE_BINARY_DIR}/generated")
 endif()
 
 if (PLUGINVAL_ENABLE_RTCHECK)

Source/CommandLine.cpp

@@ -17,10 +17,6 @@
 #include "CrashHandler.h"
 #include "PluginTests.h"
 
-#if PLUGINVAL_VST3_VALIDATOR
- #include "vst3validator/VST3ValidatorRunner.h"
-#endif
-
 #if JUCE_MAC
  #include <signal.h>
  #include <sys/types.h>
@@ -506,11 +502,7 @@ static juce::ArgumentList createCommandLineArgs (juce::String commandLine)
         const bool hasValidateOrOtherCommand = argList.containsOption ("--validate")
                                                 || argList.containsOption ("--help|-h")
                                                 || argList.containsOption ("--version")
-                                                || argList.containsOption ("--run-tests")
-                                               #if PLUGINVAL_VST3_VALIDATOR
-                                                || argList.containsOption ("--vst3-validator-mode")
-                                               #endif
-                                                ;
+                                                || argList.containsOption ("--run-tests");
 
         if (! hasValidateOrOtherCommand)
             if (isPluginArgument (argList.arguments.getLast().text))
@@ -551,36 +543,6 @@ static void performCommandLine (CommandLineValidator& validator, const juce::Arg
                           printStrictnessHelp (level);
                       }});
 
-   #if PLUGINVAL_VST3_VALIDATOR
-    cli.addCommand ({ "--vst3-validator-mode",
-                      "--vst3-validator-mode [pathToPlugin] [-e] [-v]",
-                      "Runs the embedded VST3 validator on the plugin (internal use).", juce::String(),
-                      [] (const auto& args)
-                      {
-                          auto pluginPath = getOptionValue (args, "--vst3-validator-mode", "",
-                                                            "Expected a plugin path for --vst3-validator-mode").toString();
-
-                          if (pluginPath.isEmpty())
-                          {
-                              std::cerr << "Error: No plugin path specified\n";
-                              juce::JUCEApplication::getInstance()->setApplicationReturnValue (1);
-                              juce::JUCEApplication::getInstance()->quit();
-                              return;
-                          }
-
-                          vst3validator::Options opts;
-                          opts.pluginPath = pluginPath.toStdString();
-                          opts.extendedMode = args.containsOption ("-e");
-                          opts.verbose = args.containsOption ("-v");
-
-                          auto result = vst3validator::runValidator (opts);
-
-                          std::cout << result.output;
-                          juce::JUCEApplication::getInstance()->setApplicationReturnValue (result.exitCode);
-                          juce::JUCEApplication::getInstance()->quit();
-                      }});
-   #endif
-
     if (const auto retValue = cli.findAndRunCommand (args); retValue != 0)
     {
         juce::JUCEApplication::getInstance()->setApplicationReturnValue (retValue);
@@ -605,11 +567,7 @@ bool shouldPerformCommandLine (const juce::String& commandLine)
         || args.containsOption ("--version")
         || args.containsOption ("--validate")
         || args.containsOption ("--run-tests")
-        || args.containsOption ("--strictness-help")
-       #if PLUGINVAL_VST3_VALIDATOR
-        || args.containsOption ("--vst3-validator-mode")
-       #endif
-        ;
+        || args.containsOption ("--strictness-help");
 }
 
 //==============================================================================

Source/Main.cpp

@@ -18,11 +18,6 @@
 #include "CommandLine.h"
 #include "PluginvalLookAndFeel.h"
 
-#if PLUGINVAL_VST3_VALIDATOR
- #include "vst3validator/VST3ValidatorRunner.h"
- #include <cstring>
- #include <iostream>
-#endif
 
 //==============================================================================
 class PluginValidatorApplication  : public juce::JUCEApplication,
@@ -180,61 +175,7 @@ class PluginValidatorApplication  : public juce::JUCEApplication,
 };
 
 //==============================================================================
-#if PLUGINVAL_VST3_VALIDATOR
-// Forward declaration for JUCE application factory
-juce::JUCEApplicationBase* juce_CreateApplication();
-
-// Custom main() to intercept --vst3-validator-mode before JUCE starts.
-// This avoids the "Periodic events are already being generated" crash on macOS
-// that occurs when JUCE's event loop conflicts with the validator subprocess.
-int main (int argc, char* argv[])
-{
-    // Check for --vst3-validator-mode before starting JUCE
-    for (int i = 1; i < argc; ++i)
-    {
-        if (std::strcmp (argv[i], "--vst3-validator-mode") == 0)
-        {
-            // Parse arguments for validator mode
-            vst3validator::Options opts;
-
-            // The plugin path should be the next argument
-            if (i + 1 < argc && argv[i + 1][0] != '-')
-                opts.pluginPath = argv[i + 1];
-
-            // Check for optional flags
-            for (int j = 1; j < argc; ++j)
-            {
-                if (std::strcmp (argv[j], "-e") == 0)
-                    opts.extendedMode = true;
-                else if (std::strcmp (argv[j], "-v") == 0)
-                    opts.verbose = true;
-            }
-
-            if (opts.pluginPath.empty())
-            {
-                std::cerr << "Error: No plugin path specified for --vst3-validator-mode\n";
-                return 1;
-            }
-
-            // Run the validator directly without JUCE
-            auto result = vst3validator::runValidator (opts);
-            std::cout << result.output;
-            return result.exitCode;
-        }
-    }
-
-    // Normal JUCE application startup - must set createInstance before calling main()
-    juce::JUCEApplicationBase::createInstance = &juce_CreateApplication;
-    return juce::JUCEApplicationBase::main (argc, const_cast<const char**> (argv));
-}
-
-// Provide the JUCE application class (required by JUCE's application framework)
-juce::JUCEApplicationBase* juce_CreateApplication() { return new PluginValidatorApplication(); }
-
-#else
-// Standard JUCE application macro when VST3 validator is disabled
 START_JUCE_APPLICATION (PluginValidatorApplication)
-#endif
 
 juce::PropertiesFile& getAppPreferences()
 {

Source/tests/BasicTests.cpp

@@ -16,6 +16,10 @@
 #include "../TestUtilities.h"
 #include "../RTCheck.h"
 
+#if PLUGINVAL_VST3_VALIDATOR
+ #include "../vst3validator/VST3ValidatorRunner.h"
+#endif
+
 #include <future>
 #include <thread>
 #include <chrono>
@@ -895,19 +899,25 @@ struct VST3validator    : public PluginTest
         ut.logMessage ("INFO: Skipping vst3 validator (not built with VST3 validator support)");
         return;
        #else
-        // Use the current pluginval executable with --vst3-validator-mode
-        auto pluginvalExe = juce::File::getSpecialLocation (juce::File::currentExecutableFile);
+        auto tempFile = vst3validator::getValidatorExecutable();
+        auto vstvalidatorExe = tempFile->getFile();
+
+        if (! vstvalidatorExe.existsAsFile())
+        {
+            ut.logMessage ("WARNING: Could not extract vstvalidator binary");
+            return;
+        }
 
         juce::StringArray cmd;
-        cmd.add (pluginvalExe.getFullPathName());
-        cmd.add ("--vst3-validator-mode");
-        cmd.add (ut.getFileOrID());
+        cmd.add (vstvalidatorExe.getFullPathName());
 
         if (ut.getOptions().strictnessLevel > 5)
             cmd.add ("-e");
 
-        if (ut.getOptions().verbose)
-            cmd.add ("-v");
+        if (! ut.getOptions().verbose)
+            cmd.add ("-q");
+
+        cmd.add (ut.getFileOrID());
 
         juce::ChildProcess cp;
         const auto started = cp.start (cmd);
@@ -967,4 +977,4 @@ struct VST3validator    : public PluginTest
     }
 };
 
-static VST3validator vst3validator;
+static VST3validator vst3validatorTest;