Carla: Share process rack code between engine types

c++/carla-backend/carla_engine.cpp

@@ -425,6 +425,93 @@ void CarlaEngine::idlePluginGuis()
     }
 }
 
+#ifndef BUILD_BRIDGE
+void CarlaEngine::processRack(float* inBuf[2], float* outBuf[2], uint32_t frames)
+{
+    // initialize outputs (zero)
+    zeroF(outBuf[0], frames);
+    zeroF(outBuf[1], frames);
+    memset(rackControlEventsOut, 0, sizeof(CarlaEngineControlEvent)*MAX_ENGINE_CONTROL_EVENTS);
+    memset(rackMidiEventsOut, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
+
+    bool processed = false;
+
+    // process plugins
+    for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)
+    {
+        CarlaPlugin* const plugin = getPluginUnchecked(i);
+
+        if (plugin && plugin->enabled())
+        {
+            if (processed)
+            {
+                // initialize inputs (from previous outputs)
+                memcpy(inBuf[0], outBuf[0], sizeof(float)*frames);
+                memcpy(inBuf[1], outBuf[1], sizeof(float)*frames);
+                memcpy(rackMidiEventsIn, rackMidiEventsOut, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
+
+                // initialize outputs (zero)
+                zeroF(outBuf[0], frames);
+                zeroF(outBuf[1], frames);
+                memset(rackMidiEventsOut, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
+            }
+
+            // process
+            plugin->engineProcessLock();
+
+            plugin->initBuffers();
+
+            if (carlaOptions.processHighPrecision)
+            {
+                float* inBuf2[2];
+                float* outBuf2[2];
+
+                for (uint32_t j=0; j < frames; j += 8)
+                {
+                    inBuf2[0] = inBuf[0] + j;
+                    inBuf2[1] = inBuf[1] + j;
+
+                    outBuf2[0] = outBuf[0] + j;
+                    outBuf2[1] = outBuf[1] + j;
+
+                    plugin->process(inBuf2, outBuf2, 8, j);
+                }
+            }
+            else
+                plugin->process(inBuf, outBuf, frames);
+
+            plugin->engineProcessUnlock();
+
+            // if plugin has no audio inputs, add previous buffers
+            if (plugin->audioInCount() == 0)
+            {
+                for (uint32_t j=0; j < frames; j++)
+                {
+                    outBuf[0][j] += inBuf[0][j];
+                    outBuf[1][j] += inBuf[1][j];
+                }
+            }
+
+            // if plugin has no midi output, add previous midi input
+            if (plugin->midiOutCount() == 0)
+            {
+                memcpy(rackMidiEventsOut, rackMidiEventsIn, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
+            }
+
+            processed = true;
+        }
+    }
+
+    // if no plugins in the rack, copy inputs over outputs
+    if (! processed)
+    {
+        memcpy(outBuf[0], inBuf[0], sizeof(float)*frames);
+        memcpy(outBuf[1], inBuf[1], sizeof(float)*frames);
+        memcpy(rackMidiEventsOut, rackMidiEventsIn, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
+    }
+}
+#endif
+
 // -----------------------------------------------------------------------
 // Information (base)
 

c++/carla-backend/carla_engine.h

@@ -223,6 +223,9 @@ public:
     bool  removePlugin(const unsigned short id);
     void  removeAllPlugins();
     void  idlePluginGuis();
+#ifndef BUILD_BRIDGE
+    void  processRack(float* inBuf[2], float* outBuf[2], uint32_t frames);
+#endif
 
     // bridge, internal use only
     void __bridgePluginRegister(const unsigned short id, CarlaPlugin* const plugin)

c++/carla-backend/carla_engine_jack.cpp

@@ -342,24 +342,15 @@ void CarlaEngineJack::handleProcessCallback(uint32_t nframes)
         CARLA_ASSERT(midiIn);
         CARLA_ASSERT(midiOut);
 
-        // create temporary audio buffers
-        float ains_tmp_buf1[nframes];
-        float ains_tmp_buf2[nframes];
-        float aouts_tmp_buf1[nframes];
-        float aouts_tmp_buf2[nframes];
-
-        float* ains_tmp[2]  = { ains_tmp_buf1, ains_tmp_buf2 };
-        float* aouts_tmp[2] = { aouts_tmp_buf1, aouts_tmp_buf2 };
-
-        // initialize audio input
-        memcpy(ains_tmp_buf1, audioIn1, sizeof(float)*nframes);
-        memcpy(ains_tmp_buf2, audioIn2, sizeof(float)*nframes);
+        // create audio buffers
+        float* inBuf[2]  = { audioIn1, audioIn2 };
+        float* outBuf[2] = { audioOut1, audioOut2 };
 
         // initialize control input
         memset(rackControlEventsIn, 0, sizeof(CarlaEngineControlEvent)*MAX_ENGINE_CONTROL_EVENTS);
         {
             jackbridge_midi_event_t jackEvent;
-            const uint32_t    jackEventCount = jackbridge_midi_get_event_count(controlIn);
+            const uint32_t jackEventCount = jackbridge_midi_get_event_count(controlIn);
 
             uint32_t carlaEventIndex = 0;
 
@@ -432,91 +423,8 @@ void CarlaEngineJack::handleProcessCallback(uint32_t nframes)
             }
         }
 
-        // initialize outputs (zero)
-        zeroF(aouts_tmp_buf1, nframes);
-        zeroF(aouts_tmp_buf2, nframes);
-        memset(rackControlEventsOut, 0, sizeof(CarlaEngineControlEvent)*MAX_ENGINE_CONTROL_EVENTS);
-        memset(rackMidiEventsOut, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
-
-        bool processed = false;
-
-        // process plugins
-        for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)
-        {
-            CarlaPlugin* const plugin = getPluginUnchecked(i);
-
-            if (plugin && plugin->enabled())
-            {
-                if (processed)
-                {
-                    // initialize inputs (from previous outputs)
-                    memcpy(ains_tmp_buf1, aouts_tmp_buf1, sizeof(float)*nframes);
-                    memcpy(ains_tmp_buf2, aouts_tmp_buf2, sizeof(float)*nframes);
-                    memcpy(rackMidiEventsIn, rackMidiEventsOut, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
-
-                    // initialize outputs (zero)
-                    zeroF(aouts_tmp_buf1, nframes);
-                    zeroF(aouts_tmp_buf2, nframes);
-                    memset(rackMidiEventsOut, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
-                }
-
-                // process
-                plugin->engineProcessLock();
-
-                plugin->initBuffers();
-
-                if (carlaOptions.processHighPrecision)
-                {
-                    float* ains_buffer2[2];
-                    float* aouts_buffer2[2];
-
-                    for (uint32_t j=0; j < nframes; j += 8)
-                    {
-                        ains_buffer2[0] = ains_tmp_buf1 + j;
-                        ains_buffer2[1] = ains_tmp_buf2 + j;
-
-                        aouts_buffer2[0] = aouts_tmp_buf1 + j;
-                        aouts_buffer2[1] = aouts_tmp_buf2 + j;
-
-                        plugin->process(ains_buffer2, aouts_buffer2, 8, j);
-                    }
-                }
-                else
-                    plugin->process(ains_tmp, aouts_tmp, nframes);
-
-                plugin->engineProcessUnlock();
-
-                // if plugin has no audio inputs, add previous buffers
-                if (plugin->audioInCount() == 0)
-                {
-                    for (uint32_t j=0; j < nframes; j++)
-                    {
-                        aouts_tmp_buf1[j] += ains_tmp_buf1[j];
-                        aouts_tmp_buf2[j] += ains_tmp_buf2[j];
-                    }
-                }
-
-                // if plugin has no midi output, add previous midi input
-                if (plugin->midiOutCount() == 0)
-                {
-                    memcpy(rackMidiEventsOut, rackMidiEventsIn, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
-                }
-
-                processed = true;
-            }
-        }
-
-        // if no plugins in the rack, copy inputs over outputs
-        if (! processed)
-        {
-            memcpy(aouts_tmp_buf1, ains_tmp_buf1, sizeof(float)*nframes);
-            memcpy(aouts_tmp_buf2, ains_tmp_buf2, sizeof(float)*nframes);
-            memcpy(rackMidiEventsOut, rackMidiEventsIn, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
-        }
-
-        // output audio
-        memcpy(audioOut1, aouts_tmp_buf1, sizeof(float)*nframes);
-        memcpy(audioOut2, aouts_tmp_buf2, sizeof(float)*nframes);
+        // process rack
+        processRack(inBuf, outBuf, nframes);
 
         // output control
         {