Always set FTZ instead of gating it behind a flag

After a quick round of testing it seems like REAPER doesn't always
enable this on the audio thread, but Bitwig, Ardour, Carla and Renoise
do. So it should be safe to just get rid of the option and to leave this
enabled all the time.

src/common/configuration.cpp

@@ -108,12 +108,6 @@ Configuration::Configuration(const fs::path& config_path,
                 } else {
                     invalid_options.push_back(key);
                 }
-            } else if (key == "force_ftz") {
-                if (const auto parsed_value = value.as_boolean()) {
-                    force_ftz = parsed_value->get();
-                } else {
-                    invalid_options.push_back(key);
-                }
             } else if (key == "frame_rate") {
                 if (const auto parsed_value = value.as_floating_point()) {
                     frame_rate = parsed_value->get();

src/common/configuration.h

@@ -126,15 +126,6 @@ class Configuration {
      */
     bool editor_xembed = false;
 
-    /**
-     * When using this option, we'll enable the flush-to-zero flag during audio
-     * processing. This can be useful when the host passes denormals to a plugin
-     * that doesn't handle those well. An example of such a plugin is REDDI by
-     * Kush Audio. Some hosts, like Bitwig, will already snap denormals to zero
-     * for us so this may not be necessary with every host.
-     */
-    bool force_ftz = false;
-
     /**
      * The number of times per second we'll handle the event loop. In most
      * plugins this also controls the plugin editor GUI's refresh rate.
@@ -214,7 +205,6 @@ class Configuration {
         s.value1b(editor_double_embed);
         s.value1b(editor_force_dnd);
         s.value1b(editor_xembed);
-        s.value1b(force_ftz);
         s.ext(frame_rate, bitsery::ext::StdOptional(),
               [](S& s, auto& v) { s.value4b(v); });
         s.value1b(hide_daw);

src/plugin/bridges/common.h

@@ -187,9 +187,6 @@ class PluginBridge {
         if (config.editor_xembed) {
             other_options.push_back("editor: XEmbed");
         }
-        if (config.force_ftz) {
-            other_options.push_back("hack: force flush-to-zero");
-        }
         if (config.frame_rate) {
             std::ostringstream option;
             option << "frame rate: " << std::setprecision(2)

src/wine-host/bridges/vst2.cpp

@@ -169,6 +169,11 @@ Vst2Bridge::Vst2Bridge(MainContext& main_context,
     });
 
     process_replacing_handler = Win32Thread([&]() {
+        // Most plugins will already enable FTZ, but there are a handful of
+        // plugins that don't that suffer from extreme DSP load increases when
+        // they start producing denormals
+        ScopedFlushToZero ftz_guard;
+
         // These are used as scratch buffers to prevent unnecessary allocations.
         // Since don't know in advance whether the host will call
         // `processReplacing` or `processDoubleReplacing` we'll just create
@@ -180,12 +185,6 @@ Vst2Bridge::Vst2Bridge(MainContext& main_context,
 
         sockets.host_vst_process_replacing.receive_multi<AudioBuffers>(
             [&](AudioBuffers request, std::vector<uint8_t>& buffer) {
-                // HACK: When a plugin doesn't handle denormals properly, we can
-                //       force the FTZ flag to be set to work around this
-                std::optional<ScopedFlushToZero> ftz_guard =
-                    config.force_ftz ? std::make_optional<ScopedFlushToZero>()
-                                     : std::nullopt;
-
                 // As suggested by Jack Winter, we'll synchronize this thread's
                 // audio processing priority with that of the host's audio
                 // thread every once in a while

src/wine-host/bridges/vst3.cpp

@@ -1211,13 +1211,11 @@ size_t Vst3Bridge::register_object_instance(
                     },
                     [&](YaAudioProcessor::Process& request)
                         -> YaAudioProcessor::Process::Response {
-                        // HACK: When a plugin doesn't handle denormals
-                        //       properly, we can force the FTZ flag to be set
-                        //       to work around this
-                        std::optional<ScopedFlushToZero> ftz_guard =
-                            config.force_ftz
-                                ? std::make_optional<ScopedFlushToZero>()
-                                : std::nullopt;
+                        // Most plugins will already enable FTZ, but there are a
+                        // handful of plugins that don't that suffer from
+                        // extreme DSP load increases when they start producing
+                        // denormals
+                        ScopedFlushToZero ftz_guard;
 
                         // As suggested by Jack Winter, we'll synchronize this
                         // thread's audio processing priority with that of the