Multichannel: Made external controller classes multi-channel aware

julianstorer · julianstorer · commit e8f06017a1f9 · 2026-04-09T17:14:46.000+01:00
diff --git a/modules/tracktion_engine/control_surfaces/tracktion_ControlSurface.h b/modules/tracktion_engine/control_surfaces/tracktion_ControlSurface.h
@@ -142,18 +142,17 @@ class ControlSurface   : public Selectable
 
     // if the device has per-channel level meters, this should update one of them.
     // the channel number is the physical channel on the device, regardless of bank selection
-    // if the channel is mono then l == r
-    // level is 0 to 1.0
-    virtual void channelLevelChanged ([[maybe_unused]] int channel, [[maybe_unused]] float l, [[maybe_unused]] float r) {}
+    // levels are 0 to 1.0, one per channel
+    virtual void channelLevelChanged ([[maybe_unused]] int channel, [[maybe_unused]] std::span<const float> levels) {}
 
     // when a track is selected or deselected
     virtual void trackSelectionChanged ([[maybe_unused]] int channel, [[maybe_unused]] bool isSelected) {}
 
     virtual void trackRecordEnabled ([[maybe_unused]] int channel, [[maybe_unused]] bool isEnabled) {}
 
     // if the device has a master level readout, this should update it.
-    virtual void masterLevelsChanged ([[maybe_unused]] float leftLevel,
-                                      [[maybe_unused]] float rightLevel) {}
+    // levels are 0 to 1.0, one per channel
+    virtual void masterLevelsChanged ([[maybe_unused]] std::span<const float> levels) {}
 
     // tells the device that the playback position has changed, so if it has a timecode
     // display, it should update it.
diff --git a/modules/tracktion_engine/control_surfaces/tracktion_CustomControlSurface.cpp b/modules/tracktion_engine/control_surfaces/tracktion_CustomControlSurface.cpp
@@ -821,7 +821,7 @@ void CustomControlSurface::faderBankChanged (int newStartChannelNumber, const ju
     }
 }
 
-void CustomControlSurface::channelLevelChanged (int, float, float) {}
+void CustomControlSurface::channelLevelChanged (int, std::span<const float>) {}
 
 void CustomControlSurface::trackSelectionChanged (int faderIndex, bool isSelected)
 {
@@ -833,7 +833,7 @@ void CustomControlSurface::trackRecordEnabled (int faderIndex, bool recordEnable
     sendCommandToControllerForActionID (armTrackId + faderIndex, recordEnabled);
 }
 
-void CustomControlSurface::masterLevelsChanged (float, float) {}
+void CustomControlSurface::masterLevelsChanged (std::span<const float>) {}
 
 void CustomControlSurface::timecodeChanged (int barsOrHours, int beatsOrMinutes,
                                             int ticksOrSeconds, int millisecs, bool isBarsBeats, bool isFrames)
diff --git a/modules/tracktion_engine/control_surfaces/tracktion_CustomControlSurface.h b/modules/tracktion_engine/control_surfaces/tracktion_CustomControlSurface.h
@@ -220,10 +220,10 @@ class CustomControlSurface  : public ControlSurface,
     void automationReadModeChanged (bool isReading) override;
     void automationWriteModeChanged (bool isWriting) override;
     void faderBankChanged (int newStartChannelNumber, const juce::StringArray& trackNames) override;
-    void channelLevelChanged (int channel, float l, float r) override;
+    void channelLevelChanged (int channel, std::span<const float> levels) override;
     void trackSelectionChanged (int channel, bool isSelected) override;
     void trackRecordEnabled (int channel, bool isEnabled) override;
-    void masterLevelsChanged (float leftLevel, float rightLevel) override;
+    void masterLevelsChanged (std::span<const float> levels) override;
     void timecodeChanged (int barsOrHours, int beatsOrMinutes, int ticksOrSeconds, int millisecs, bool isBarsBeats, bool isFrames) override;
     void clickOnOffChanged (bool isClickOn) override;
     void snapOnOffChanged (bool isSnapOn) override;
diff --git a/modules/tracktion_engine/control_surfaces/tracktion_ExternalController.cpp b/modules/tracktion_engine/control_surfaces/tracktion_ExternalController.cpp
@@ -549,18 +549,18 @@ void ExternalController::clickChanged (bool isOn)
         getControlSurface().clickOnOffChanged (isOn);
 }
 
-void ExternalController::channelLevelChanged (int channelNum, float l, float r)
+void ExternalController::channelLevelChanged (int channelNum, std::span<const float> levels)
 {
     int i = getFaderIndexInActiveRegion (channelNum);
 
     if (i >= 0)
-        getControlSurface().channelLevelChanged (i, l, r);
+        getControlSurface().channelLevelChanged (i, levels);
 }
 
-void ExternalController::masterLevelsChanged (float leftLevel, float rightLevel)
+void ExternalController::masterLevelsChanged (std::span<const float> levels)
 {
     if (controlSurface != nullptr)
-        getControlSurface().masterLevelsChanged (leftLevel, rightLevel);
+        getControlSurface().masterLevelsChanged (levels);
 }
 
 void ExternalController::timecodeChanged (int barsOrHours,
@@ -1244,7 +1244,7 @@ void ExternalController::updateDeviceState()
 
                         updateSoloAndMute (chan, t->getMuteAndSoloLightState(), true);
 
-                        channelLevelChanged (chan, 0.0f, 0.0f);
+                        channelLevelChanged (chan, {});
 
                         if (auto sm = ecm.getSelectionManager())
                             trackSelected (chan, sm->isSelected (t));
@@ -1254,7 +1254,7 @@ void ExternalController::updateDeviceState()
                         moveFader (chan, decibelsToVolumeFaderPosition (0.0f));
                         movePanPot (chan, 0.0f);
                         updateSoloAndMute (chan, {}, false);
-                        channelLevelChanged (chan, 0.0f, 0.0f);
+                        channelLevelChanged (chan, {});
                         trackSelected (chan, false);
                     }
                 }
@@ -1318,7 +1318,7 @@ void ExternalController::updateDeviceState()
                 cs.punchOnOffChanged (edit->recordingPunchInOut);
                 cs.slaveOnOffChanged (edit->isTimecodeSyncEnabled());
 
-                masterLevelsChanged (0.0f, 0.0f);
+                masterLevelsChanged ({});
 
                 updateTrackRecordLights();
                 cs.auxBankChanged (auxBank);
diff --git a/modules/tracktion_engine/control_surfaces/tracktion_ExternalController.h b/modules/tracktion_engine/control_surfaces/tracktion_ExternalController.h
@@ -84,8 +84,8 @@ class ExternalController  : private juce::AsyncUpdater,
     void snapChanged (bool isOn);
     void loopChanged (bool isOn);
     void clickChanged (bool isOn);
-    void channelLevelChanged (int channel, float l, float r);
-    void masterLevelsChanged (float leftLevel, float rightLevel);
+    void channelLevelChanged (int channel, std::span<const float> levels);
+    void masterLevelsChanged (std::span<const float> levels);
     void timecodeChanged (int barsOrHours, int beatsOrMinutes, int ticksOrSeconds, int millisecs, bool isBarsBeats, bool isFrames);
     void trackSelected (int channel, bool isSelected);
     void selectOtherObject (SelectableClass::Relationship, bool moveFromCurrentPlugin);
diff --git a/modules/tracktion_engine/control_surfaces/tracktion_ExternalControllerManager.cpp b/modules/tracktion_engine/control_surfaces/tracktion_ExternalControllerManager.cpp
@@ -233,11 +233,13 @@ ExternalControllerManager::ExternalControllerManager (Engine& e) : engine (e)
             masterLevelState->measurer->addClient (masterLevelState->client);
         }
 
-        auto dBL = masterLevelState->client.getAndClearAudioLevel (0).dB;
-        auto dBR = masterLevelState->client.getNumChannelsUsed() > 1
-                       ? masterLevelState->client.getAndClearAudioLevel (1).dB : dBL;
+        auto numChans = masterLevelState->client.getNumChannelsUsed();
+        float gains[32];
 
-        masterLevelsChanged (dbToGain (dBL), dbToGain (dBR));
+        for (int i = 0; i < numChans; ++i)
+            gains[i] = dbToGain (masterLevelState->client.getAndClearAudioLevel (i).dB);
+
+        masterLevelsChanged ({ gains, (size_t) numChans });
     });
 }
 
@@ -741,7 +743,7 @@ void ExternalControllerManager::automationModeChanged (bool isReading, bool isWr
     FOR_EACH_ACTIVE_DEVICE (automationModeChanged (isReading, isWriting));
 }
 
-void ExternalControllerManager::channelLevelChanged (int channel, float l, float r)
+void ExternalControllerManager::channelLevelChanged (int channel, std::span<const float> levels)
 {
     CRASH_TRACER
     // This is an optimisation that avoids calling mapTrackNumToChannelNum if there are no enabled/active devices
@@ -758,13 +760,13 @@ void ExternalControllerManager::channelLevelChanged (int channel, float l, float
         return *channelNum;
     };
 
-    FOR_EACH_ACTIVE_DEVICE (channelLevelChanged (getChannelNum(), l, r));
+    FOR_EACH_ACTIVE_DEVICE (channelLevelChanged (getChannelNum(), levels));
 }
 
-void ExternalControllerManager::masterLevelsChanged (float leftLevel, float rightLevel)
+void ExternalControllerManager::masterLevelsChanged (std::span<const float> levels)
 {
     CRASH_TRACER
-    FOR_EACH_ACTIVE_DEVICE (masterLevelsChanged (leftLevel, rightLevel));
+    FOR_EACH_ACTIVE_DEVICE (masterLevelsChanged (levels));
 }
 
 void ExternalControllerManager::timecodeChanged (int barsOrHours, int beatsOrMinutes, int ticksOrSeconds,
diff --git a/modules/tracktion_engine/control_surfaces/tracktion_ExternalControllerManager.h b/modules/tracktion_engine/control_surfaces/tracktion_ExternalControllerManager.h
@@ -111,8 +111,8 @@ class ExternalControllerManager  : public juce::ChangeBroadcaster,
     void playStateChanged (bool isPlaying);
     void recordStateChanged (bool isRecording);
     void automationModeChanged (bool isReading, bool isWriting);
-    void channelLevelChanged (int channel, float l, float r);
-    void masterLevelsChanged (float leftLevel, float rightLevel);
+    void channelLevelChanged (int channel, std::span<const float> levels);
+    void masterLevelsChanged (std::span<const float> levels);
     void timecodeChanged (int barsOrHours, int beatsOrMinutes, int ticksOrSeconds,
                           int millisecs, bool isBarsBeats, bool isFrames);
     void editPositionChanged (Edit*, TimePosition newCursorPosition);
diff --git a/modules/tracktion_engine/control_surfaces/types/tracktion_MackieC4.cpp b/modules/tracktion_engine/control_surfaces/types/tracktion_MackieC4.cpp
@@ -974,17 +974,21 @@ void MackieC4::clearAux (int channel, int)
     }
 }
 
-void MackieC4::channelLevelChanged (int channel, float l, float r)
+void MackieC4::channelLevelChanged (int channel, std::span<const float> levels)
 {
     if (mode == MixerMode)
     {
         CRASH_TRACER
 
+        float peak = 0.0f;
+        for (auto v : levels)
+            peak = std::max (peak, v);
+
         char midi[256];
         int midiLen = 0;
 
         if (c4->C4LCDSetMeterLevelTxString (midi, &midiLen, channel * 2 + 1,
-                                            juce::jlimit (0, 12, (juce::roundToInt (12.0f * std::max (l, r))))))
+                                            juce::jlimit (0, 12, (juce::roundToInt (12.0f * peak)))))
             sendMidiCommandToController (0, midi, midiLen);
     }
 }
@@ -1003,7 +1007,7 @@ void MackieC4::loopOnOffChanged (bool)                { updateButtonLights(); }
 void MackieC4::slaveOnOffChanged (bool)               { updateButtonLights(); }
 void MackieC4::punchOnOffChanged (bool)               { updateButtonLights(); }
 
-void MackieC4::masterLevelsChanged (float, float) {}
+void MackieC4::masterLevelsChanged (std::span<const float>) {}
 void MackieC4::timecodeChanged (int, int, int, int, bool, bool) {}
 void MackieC4::trackRecordEnabled (int, bool) {}
 
diff --git a/modules/tracktion_engine/control_surfaces/types/tracktion_MackieC4.h b/modules/tracktion_engine/control_surfaces/types/tracktion_MackieC4.h
@@ -34,7 +34,7 @@ class MackieC4  : public ControlSurface,
     void faderBankChanged (int newStartChannelNumber, const juce::StringArray& trackNames) override;
     void moveAux (int channelNum, int auxNum, const char* bus, float newPos) override;
     void clearAux (int channel, int auxNum) override;
-    void channelLevelChanged (int channel, float l, float r) override;
+    void channelLevelChanged (int channel, std::span<const float> levels) override;
     void updateSoloAndMute (int channelNum, Track::MuteAndSoloLightState, bool isBright) override;
     void soloCountChanged (bool) override;
     void trackSelectionChanged (int channel, bool isSelected) override;
@@ -47,7 +47,7 @@ class MackieC4  : public ControlSurface,
     void loopOnOffChanged (bool isLoopOn) override;
     void slaveOnOffChanged (bool isSlaving) override;
     void punchOnOffChanged (bool isPunching) override;
-    void masterLevelsChanged (float leftLevel, float rightLevel) override;
+    void masterLevelsChanged (std::span<const float> levels) override;
     void timecodeChanged (int barsOrHours, int beatsOrMinutes, int ticksOrSeconds, int millisecs, bool isBarsBeats, bool isFrames) override;
     void trackRecordEnabled (int channel, bool isEnabled) override;
     bool canChangeSelectedPlugin() override;
diff --git a/modules/tracktion_engine/control_surfaces/types/tracktion_MackieMCU.cpp b/modules/tracktion_engine/control_surfaces/types/tracktion_MackieMCU.cpp
@@ -1284,14 +1284,18 @@ void MackieMCU::faderBankChanged (int newStartChannelNumber, const juce::StringA
     }
 }
 
-void MackieMCU::channelLevelChanged (int channelNum_, float l , float r)
+void MackieMCU::channelLevelChanged (int channelNum_, std::span<const float> levels)
 {
     int channel = channelNum_ % 8;
     int dev     = channelNum_ / 8;
 
     if (assignmentMode == PanMode)
     {
-        auto newValue = (uint8_t) juce::jlimit (0, 13, juce::roundToInt (13.0f * std::max (l, r)));
+        float peak = 0.0f;
+        for (auto v : levels)
+            peak = std::max (peak, v);
+
+        auto newValue = (uint8_t) juce::jlimit (0, 13, juce::roundToInt (13.0f * peak));
 
         if (lastChannelLevels[channelNum_] != newValue)
         {
@@ -1306,7 +1310,7 @@ void MackieMCU::channelLevelChanged (int channelNum_, float l , float r)
     }
 }
 
-void MackieMCU::masterLevelsChanged (float, float)
+void MackieMCU::masterLevelsChanged (std::span<const float>)
 {
 }
 
diff --git a/modules/tracktion_engine/control_surfaces/types/tracktion_MackieMCU.h b/modules/tracktion_engine/control_surfaces/types/tracktion_MackieMCU.h
@@ -72,8 +72,8 @@ class MackieMCU  : public ControlSurface,
     void parameterChanged (int parameterNumber, const ParameterSetting&) override;
     void clearParameter (int parameterNumber) override;
     void faderBankChanged (int newStartChannelNumber, const juce::StringArray& trackNames) override;
-    void channelLevelChanged (int channel, float l, float r) override;
-    void masterLevelsChanged (float leftLevel, float rightLevel) override;
+    void channelLevelChanged (int channel, std::span<const float> levels) override;
+    void masterLevelsChanged (std::span<const float> levels) override;
     void updateTCDisplay (const char* newDigits);
     void timecodeChanged (int barsOrHours, int beatsOrMinutes, int ticksOrSeconds,
                           int millisecs, bool isBarsBeats, bool isFrames) override;
diff --git a/modules/tracktion_engine/plugins/internal/tracktion_LevelMeter.cpp b/modules/tracktion_engine/plugins/internal/tracktion_LevelMeter.cpp
@@ -82,11 +82,13 @@ void LevelMeterPlugin::timerCallback()
 
         if (ecm.isAttachedToEdit (edit))
         {
-            auto dBL = controllerLevelClient.getAndClearAudioLevel (0).dB;
-            auto dBR = controllerLevelClient.getNumChannelsUsed() > 1
-                           ? controllerLevelClient.getAndClearAudioLevel (1).dB : dBL;
+            auto numChans = controllerLevelClient.getNumChannelsUsed();
+            float gains[32];
 
-            ecm.channelLevelChanged (controllerTrack, dbToGain (dBL), dbToGain (dBR));
+            for (int i = 0; i < numChans; ++i)
+                gains[i] = dbToGain (controllerLevelClient.getAndClearAudioLevel (i).dB);
+
+            ecm.channelLevelChanged (controllerTrack, { gains, (size_t) numChans });
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -821,7 +821,7 @@ void CustomControlSurface::faderBankChanged (int newStartChannelNumber, const ju`
`821`	`821`	`}`
`822`	`822`	`}`
`823`	`823`
`824`		`-void CustomControlSurface::channelLevelChanged (int, float, float) {}`
	`824`	`+void CustomControlSurface::channelLevelChanged (int, std::span<const float>) {}`
`825`	`825`
`826`	`826`	`void CustomControlSurface::trackSelectionChanged (int faderIndex, bool isSelected)`
`827`	`827`	`{`
`@@ -833,7 +833,7 @@ void CustomControlSurface::trackRecordEnabled (int faderIndex, bool recordEnable`
`833`	`833`	`sendCommandToControllerForActionID (armTrackId + faderIndex, recordEnabled);`
`834`	`834`	`}`
`835`	`835`
`836`		`-void CustomControlSurface::masterLevelsChanged (float, float) {}`
	`836`	`+void CustomControlSurface::masterLevelsChanged (std::span<const float>) {}`
`837`	`837`
`838`	`838`	`void CustomControlSurface::timecodeChanged (int barsOrHours, int beatsOrMinutes,`
`839`	`839`	`int ticksOrSeconds, int millisecs, bool isBarsBeats, bool isFrames)`
Original file line number	Diff line number	Diff line change
`@@ -549,18 +549,18 @@ void ExternalController::clickChanged (bool isOn)`
`549`	`549`	`getControlSurface().clickOnOffChanged (isOn);`
`550`	`550`	`}`
`551`	`551`
`552`		`-void ExternalController::channelLevelChanged (int channelNum, float l, float r)`
	`552`	`+void ExternalController::channelLevelChanged (int channelNum, std::span<const float> levels)`
`553`	`553`	`{`
`554`	`554`	`int i = getFaderIndexInActiveRegion (channelNum);`
`555`	`555`
`556`	`556`	`if (i >= 0)`
`557`		`- getControlSurface().channelLevelChanged (i, l, r);`
	`557`	`+ getControlSurface().channelLevelChanged (i, levels);`
`558`	`558`	`}`
`559`	`559`
`560`		`-void ExternalController::masterLevelsChanged (float leftLevel, float rightLevel)`
	`560`	`+void ExternalController::masterLevelsChanged (std::span<const float> levels)`
`561`	`561`	`{`
`562`	`562`	`if (controlSurface != nullptr)`
`563`		`- getControlSurface().masterLevelsChanged (leftLevel, rightLevel);`
	`563`	`+ getControlSurface().masterLevelsChanged (levels);`
`564`	`564`	`}`
`565`	`565`
`566`	`566`	`void ExternalController::timecodeChanged (int barsOrHours,`
`@@ -1244,7 +1244,7 @@ void ExternalController::updateDeviceState()`
`1244`	`1244`
`1245`	`1245`	`updateSoloAndMute (chan, t->getMuteAndSoloLightState(), true);`
`1246`	`1246`
`1247`		`- channelLevelChanged (chan, 0.0f, 0.0f);`
	`1247`	`+ channelLevelChanged (chan, {});`
`1248`	`1248`
`1249`	`1249`	`if (auto sm = ecm.getSelectionManager())`
`1250`	`1250`	`trackSelected (chan, sm->isSelected (t));`
`@@ -1254,7 +1254,7 @@ void ExternalController::updateDeviceState()`
`1254`	`1254`	`moveFader (chan, decibelsToVolumeFaderPosition (0.0f));`
`1255`	`1255`	`movePanPot (chan, 0.0f);`
`1256`	`1256`	`updateSoloAndMute (chan, {}, false);`
`1257`		`- channelLevelChanged (chan, 0.0f, 0.0f);`
	`1257`	`+ channelLevelChanged (chan, {});`
`1258`	`1258`	`trackSelected (chan, false);`
`1259`	`1259`	`}`
`1260`	`1260`	`}`
`@@ -1318,7 +1318,7 @@ void ExternalController::updateDeviceState()`
`1318`	`1318`	`cs.punchOnOffChanged (edit->recordingPunchInOut);`
`1319`	`1319`	`cs.slaveOnOffChanged (edit->isTimecodeSyncEnabled());`
`1320`	`1320`
`1321`		`- masterLevelsChanged (0.0f, 0.0f);`
	`1321`	`+ masterLevelsChanged ({});`
`1322`	`1322`
`1323`	`1323`	`updateTrackRecordLights();`
`1324`	`1324`	`cs.auxBankChanged (auxBank);`
Original file line number	Diff line number	Diff line change
`@@ -233,11 +233,13 @@ ExternalControllerManager::ExternalControllerManager (Engine& e) : engine (e)`
`233`	`233`	`masterLevelState->measurer->addClient (masterLevelState->client);`
`234`	`234`	`}`
`235`	`235`
`236`		`- auto dBL = masterLevelState->client.getAndClearAudioLevel (0).dB;`
`237`		`- auto dBR = masterLevelState->client.getNumChannelsUsed() > 1`
`238`		`- ? masterLevelState->client.getAndClearAudioLevel (1).dB : dBL;`
	`236`	`+ auto numChans = masterLevelState->client.getNumChannelsUsed();`
	`237`	`+ float gains[32];`
`239`	`238`
`240`		`- masterLevelsChanged (dbToGain (dBL), dbToGain (dBR));`
	`239`	`+ for (int i = 0; i < numChans; ++i)`
	`240`	`+ gains[i] = dbToGain (masterLevelState->client.getAndClearAudioLevel (i).dB);`
	`241`	`+`
	`242`	`+ masterLevelsChanged ({ gains, (size_t) numChans });`
`241`	`243`	`});`
`242`	`244`	`}`
`243`	`245`
`@@ -741,7 +743,7 @@ void ExternalControllerManager::automationModeChanged (bool isReading, bool isWr`
`741`	`743`	`FOR_EACH_ACTIVE_DEVICE (automationModeChanged (isReading, isWriting));`
`742`	`744`	`}`
`743`	`745`
`744`		`-void ExternalControllerManager::channelLevelChanged (int channel, float l, float r)`
	`746`	`+void ExternalControllerManager::channelLevelChanged (int channel, std::span<const float> levels)`
`745`	`747`	`{`
`746`	`748`	`CRASH_TRACER`
`747`	`749`	`// This is an optimisation that avoids calling mapTrackNumToChannelNum if there are no enabled/active devices`
`@@ -758,13 +760,13 @@ void ExternalControllerManager::channelLevelChanged (int channel, float l, float`
`758`	`760`	`return *channelNum;`
`759`	`761`	`};`
`760`	`762`
`761`		`- FOR_EACH_ACTIVE_DEVICE (channelLevelChanged (getChannelNum(), l, r));`
	`763`	`+ FOR_EACH_ACTIVE_DEVICE (channelLevelChanged (getChannelNum(), levels));`
`762`	`764`	`}`
`763`	`765`
`764`		`-void ExternalControllerManager::masterLevelsChanged (float leftLevel, float rightLevel)`
	`766`	`+void ExternalControllerManager::masterLevelsChanged (std::span<const float> levels)`
`765`	`767`	`{`
`766`	`768`	`CRASH_TRACER`
`767`		`- FOR_EACH_ACTIVE_DEVICE (masterLevelsChanged (leftLevel, rightLevel));`
	`769`	`+ FOR_EACH_ACTIVE_DEVICE (masterLevelsChanged (levels));`
`768`	`770`	`}`
`769`	`771`
`770`	`772`	`void ExternalControllerManager::timecodeChanged (int barsOrHours, int beatsOrMinutes, int ticksOrSeconds,`
Original file line number	Diff line number	Diff line change
`@@ -974,17 +974,21 @@ void MackieC4::clearAux (int channel, int)`
`974`	`974`	`}`
`975`	`975`	`}`
`976`	`976`
`977`		`-void MackieC4::channelLevelChanged (int channel, float l, float r)`
	`977`	`+void MackieC4::channelLevelChanged (int channel, std::span<const float> levels)`
`978`	`978`	`{`
`979`	`979`	`if (mode == MixerMode)`
`980`	`980`	`{`
`981`	`981`	`CRASH_TRACER`
`982`	`982`
	`983`	`+ float peak = 0.0f;`
	`984`	`+ for (auto v : levels)`
	`985`	`+ peak = std::max (peak, v);`
	`986`	`+`
`983`	`987`	`char midi[256];`
`984`	`988`	`int midiLen = 0;`
`985`	`989`
`986`	`990`	`if (c4->C4LCDSetMeterLevelTxString (midi, &midiLen, channel * 2 + 1,`
`987`		`- juce::jlimit (0, 12, (juce::roundToInt (12.0f * std::max (l, r))))))`
	`991`	`+ juce::jlimit (0, 12, (juce::roundToInt (12.0f * peak)))))`
`988`	`992`	`sendMidiCommandToController (0, midi, midiLen);`
`989`	`993`	`}`
`990`	`994`	`}`
`@@ -1003,7 +1007,7 @@ void MackieC4::loopOnOffChanged (bool) { updateButtonLights(); }`
`1003`	`1007`	`void MackieC4::slaveOnOffChanged (bool) { updateButtonLights(); }`
`1004`	`1008`	`void MackieC4::punchOnOffChanged (bool) { updateButtonLights(); }`
`1005`	`1009`
`1006`		`-void MackieC4::masterLevelsChanged (float, float) {}`
	`1010`	`+void MackieC4::masterLevelsChanged (std::span<const float>) {}`
`1007`	`1011`	`void MackieC4::timecodeChanged (int, int, int, int, bool, bool) {}`
`1008`	`1012`	`void MackieC4::trackRecordEnabled (int, bool) {}`
`1009`	`1013`
Original file line number	Diff line number	Diff line change
`@@ -1284,14 +1284,18 @@ void MackieMCU::faderBankChanged (int newStartChannelNumber, const juce::StringA`
`1284`	`1284`	`}`
`1285`	`1285`	`}`
`1286`	`1286`
`1287`		`-void MackieMCU::channelLevelChanged (int channelNum_, float l , float r)`
	`1287`	`+void MackieMCU::channelLevelChanged (int channelNum_, std::span<const float> levels)`
`1288`	`1288`	`{`
`1289`	`1289`	`int channel = channelNum_ % 8;`
`1290`	`1290`	`int dev = channelNum_ / 8;`
`1291`	`1291`
`1292`	`1292`	`if (assignmentMode == PanMode)`
`1293`	`1293`	`{`
`1294`		`- auto newValue = (uint8_t) juce::jlimit (0, 13, juce::roundToInt (13.0f * std::max (l, r)));`
	`1294`	`+ float peak = 0.0f;`
	`1295`	`+ for (auto v : levels)`
	`1296`	`+ peak = std::max (peak, v);`
	`1297`	`+`
	`1298`	`+ auto newValue = (uint8_t) juce::jlimit (0, 13, juce::roundToInt (13.0f * peak));`
`1295`	`1299`
`1296`	`1300`	`if (lastChannelLevels[channelNum_] != newValue)`
`1297`	`1301`	`{`
`@@ -1306,7 +1310,7 @@ void MackieMCU::channelLevelChanged (int channelNum_, float l , float r)`
`1306`	`1310`	`}`
`1307`	`1311`	`}`
`1308`	`1312`
`1309`		`-void MackieMCU::masterLevelsChanged (float, float)`
	`1313`	`+void MackieMCU::masterLevelsChanged (std::span<const float>)`
`1310`	`1314`	`{`
`1311`	`1315`	`}`
`1312`	`1316`