control room app vu meters following live music from logic pro

Author: nickfox

AIplayer/AIplayer/Source/PluginProcessor.cpp

@@ -802,6 +802,13 @@ void AIplayerAudioProcessor::oscMessageReceived (const juce::OSCMessage& message
                {
                    logMessage(LogLevel::Info, "Sent UUID assignment confirmation for track " + this->logicTrackUUID);
                }
+               
+               // Start RMS telemetry timer if we have a port and it's not already running
+               if (portState == PortState::Bound && !isTimerRunning())
+               {
+                   logMessage(LogLevel::Info, "Starting RMS telemetry timer after UUID assignment");
+                   startTimerHz(24); // 24 Hz for smooth VU meter updates
+               }
            }
            else if (!matched)
            {
@@ -1258,7 +1265,8 @@ void AIplayerAudioProcessor::sendRMSTelemetry()
         {
             // Ensure connected flag is set
             senderConnected = true;
-            // Don't log successful sends - they happen 24 times per second!
+            // Log RMS sends for debugging (now only 1 Hz)
+            logMessage(LogLevel::Info, "Sent RMS: " + addressPatternString + " [" + idToSend + "] = " + juce::String(rmsValue));
         }
     }
     catch (const std::bad_alloc& e)
@@ -1474,6 +1482,7 @@ bool AIplayerAudioProcessor::bindToAssignedPort(int port)
                 }
 
                 // Now we can start sending RMS telemetry
+                logMessage(LogLevel::Info, "Starting RMS telemetry timer at 24 Hz");
                 startTimerHz(24); // 24 Hz for smooth VU meter updates
 
                 return true;

ChattyChannels/ChattyChannels/Models/AudioLevel.swift

@@ -75,8 +75,10 @@ public struct AudioLevel: Identifiable {
 
     /// Convert current RMS value to dBFS.
     public var dbfsValue: Float {
-        guard rmsValue > 0 else { return -Float.infinity } // or a very low dB value like -120.0
-        return 20 * log10(rmsValue)
+        guard rmsValue > 0 else { return -120.0 } // Return -120 dB for silence instead of -infinity
+        let db = 20 * log10(rmsValue)
+        // Clamp to reasonable range to avoid extreme values
+        return max(-120.0, min(6.0, db))
     }
 
     /// Convert raw value to dB (v0.6 compatibility)

ChattyChannels/ChattyChannels/OSCService.swift

@@ -417,13 +417,29 @@ public final class OSCService: ObservableObject {
             return
         }
 
+        // Apply 10x amplification to the RMS value
+        let amplifiedRMS = amplifyRMS(rmsValue, amplificationFactor: 10.0)
+        
+        // Commented out verbose logging to reduce console spam at 24 Hz
+        // print("[OSCService] Processing identified RMS: \(logicTrackUUID) = \(rmsValue) (amplified to \(amplifiedRMS))")
+        
         // Dispatch to MainActor as LevelMeterService.updateLevel is @MainActor isolated
         Task { @MainActor in
-            levelMeterService.updateLevel(logicTrackUUID: logicTrackUUID, rmsValue: rmsValue)
-            // Removed verbose logging - these messages come in continuously
+            levelMeterService.updateLevel(logicTrackUUID: logicTrackUUID, rmsValue: amplifiedRMS)
+            // print("[OSCService] Updated LevelMeterService for \(logicTrackUUID)")
         }
     }
 
+    /// Amplifies an RMS value by a given factor and clamps to 0.0-1.0 range
+    /// - Parameters:
+    ///   - rmsValue: The original RMS value
+    ///   - amplificationFactor: The factor to multiply the RMS value by
+    /// - Returns: The amplified and clamped RMS value
+    private func amplifyRMS(_ rmsValue: Float, amplificationFactor: Float) -> Float {
+        let amplified = rmsValue * amplificationFactor
+        return min(1.0, max(0.0, amplified))
+    }
+    
     /// Processes an incoming port-based RMS message.
     /// - Parameters:
     ///   - tempID: The temporary instance ID from the plugin.

ChattyChannels/ChattyChannels/Services/LevelMeterService.swift

@@ -17,6 +17,9 @@ public class LevelMeterService: ObservableObject {
     /// Published current track name for compatibility with v0.6 UI
     @Published public var currentTrack: String = "Master Bus"
 
+    /// Dedicated published property for TR1 (kick drum) to ensure VU meter updates
+    @Published public var tr1Level = AudioLevel(id: "TR1", rmsValue: 0.0, peakRmsValue: 0.0, trackName: "Kick")
+    
     /// Compatibility properties for v0.6 UI - mapping between old channel-based and new track-based system
     @Published public var leftChannel = AudioLevel(id: "LEFT", rmsValue: 0.0, peakRmsValue: 0.0, trackName: "Master Bus")
     @Published public var rightChannel = AudioLevel(id: "RIGHT", rmsValue: 0.0, peakRmsValue: 0.0, trackName: "Master Bus")
@@ -36,6 +39,7 @@ public class LevelMeterService: ObservableObject {
         logger.info("LevelMeterService initialized")
         // Set up default master bus audio level
         audioLevels[masterBusUUID] = AudioLevel(id: masterBusUUID, rmsValue: 0.0, peakRmsValue: 0.0, trackName: "Master Bus")
+        audioLevels["TR1"] = tr1Level // Initialize TR1 in the dictionary
         startPeakDecayTimer()
 
         // Start a timer to update the v0.6 compatibility properties from the master bus data
@@ -49,7 +53,7 @@ public class LevelMeterService: ObservableObject {
     ///   - rmsValue: The new RMS value (0.0 to 1.0).
     ///   - peakRmsValueOverride: Optional peak value if provided directly by the source.
     public func updateLevel(logicTrackUUID: String, rmsValue: Float, peakRmsValueOverride: Float? = nil) {
-        var level = audioLevels[logicTrackUUID] ?? AudioLevel(id: logicTrackUUID)
+        var level = audioLevels[logicTrackUUID] ?? AudioLevel(id: logicTrackUUID, rmsValue: 0.0, peakRmsValue: 0.0, trackName: logicTrackUUID)
 
         level.rmsValue = max(0.0, min(1.0, rmsValue)) // Clamp value
 
@@ -62,6 +66,22 @@ public class LevelMeterService: ObservableObject {
 
         audioLevels[logicTrackUUID] = level
 
+        // CRITICAL FIX: Update the dedicated TR1 property when TR1 data arrives
+        if logicTrackUUID == "TR1" {
+            tr1Level = level
+            // Commented out to reduce console spam at 24 Hz
+            // logger.info("Updated TR1 dedicated property: RMS \(level.rmsValue, privacy: .public), Peak \(level.peakRmsValue, privacy: .public)")
+        }
+        
+        // Force SwiftUI to detect the change by replacing the entire dictionary
+        let newDict = audioLevels
+        audioLevels = newDict
+        
+        // Force objectWillChange to fire to ensure SwiftUI updates
+        DispatchQueue.main.async {
+            self.objectWillChange.send()
+        }
+        
         // If this is the master bus, update the current track name for UI compatibility
         if logicTrackUUID == masterBusUUID {
             if let trackName = level.trackName {
@@ -72,8 +92,9 @@ public class LevelMeterService: ObservableObject {
             updateCompatibilityChannels(from: level)
         }
 
-        // Removed excessive debug logging - this was generating thousands of log entries per second
-        // logger.debug("Updated level for \(logicTrackUUID, privacy: .public): RMS \(level.rmsValue, privacy: .public), Peak \(level.peakRmsValue, privacy: .public)")
+        // Commented out verbose logging to reduce console spam at 24 Hz
+        // logger.info("Updated level for \(logicTrackUUID, privacy: .public): RMS \(level.rmsValue, privacy: .public), Peak \(level.peakRmsValue, privacy: .public)")
+        
     }
 
     /// Updates the v0.6 compatibility channel properties from the master bus data
@@ -82,9 +103,44 @@ public class LevelMeterService: ObservableObject {
         rightChannel = AudioLevel(id: "RIGHT", rmsValue: masterLevel.rmsValue, peakRmsValue: masterLevel.peakRmsValue, trackName: masterLevel.trackName)
     }
 
+    /// Updates the master bus level with the sum of all track levels
+    private func updateMasterBusLevel() {
+        // Calculate RMS sum of all tracks (excluding master bus itself)
+        var sumOfSquares: Float = 0.0
+        var peakValue: Float = 0.0
+        var trackCount = 0
+        
+        for (uuid, level) in audioLevels {
+            if uuid != masterBusUUID {
+                // RMS values are summed as power (squared values)
+                sumOfSquares += level.rmsValue * level.rmsValue
+                peakValue = max(peakValue, level.peakRmsValue)
+                trackCount += 1
+            }
+        }
+        
+        // Calculate combined RMS (square root of sum of squares)
+        let combinedRMS = trackCount > 0 ? sqrt(sumOfSquares) : 0.0
+        
+        // Apply 10x amplification and clamp to valid range
+        let amplifiedRMS = min(1.0, combinedRMS * 10.0)
+        let amplifiedPeak = min(1.0, peakValue * 10.0)
+        
+        // Update master bus level
+        var masterLevel = audioLevels[masterBusUUID] ?? AudioLevel(id: masterBusUUID, rmsValue: 0.0, peakRmsValue: 0.0, trackName: "Master Bus")
+        masterLevel.rmsValue = amplifiedRMS
+        masterLevel.peakRmsValue = max(masterLevel.peakRmsValue, amplifiedPeak)
+        masterLevel.lastUpdateTime = Date()
+        
+        audioLevels[masterBusUUID] = masterLevel
+        
+        // Update compatibility channels
+        updateCompatibilityChannels(from: masterLevel)
+    }
+    
     /// Starts a timer to update the v0.6 compatibility properties from the master bus data
     private func startCompatibilityTimer() {
-        Timer.scheduledTimer(withTimeInterval: 1.0/30.0, repeats: true) { [weak self] _ in
+        Timer.scheduledTimer(withTimeInterval: 1.0/24.0, repeats: true) { [weak self] _ in
             guard let self = self else { return }
             Task { @MainActor in
                 if let masterLevel = self.audioLevels[self.masterBusUUID] {
@@ -121,6 +177,11 @@ public class LevelMeterService: ObservableObject {
             audioLevels[logicTrackUUID]?.peakRmsValue = audioLevels[logicTrackUUID]?.rmsValue ?? 0.0
             logger.info("Peak value reset for track: \(logicTrackUUID, privacy: .public)")
 
+            // If this is TR1, also update the dedicated property
+            if logicTrackUUID == "TR1", let level = audioLevels[logicTrackUUID] {
+                tr1Level = level
+            }
+            
             // If this is the master bus, also update the compatibility channels
             if logicTrackUUID == masterBusUUID {
                 leftChannel.peakValue = leftChannel.value
@@ -140,7 +201,7 @@ public class LevelMeterService: ObservableObject {
     /// Starts a timer to handle peak value decay.
     private func startPeakDecayTimer() {
         peakDecayTimer?.invalidate() // Invalidate existing timer if any
-        peakDecayTimer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { [weak self] _ in
+        peakDecayTimer = Timer.scheduledTimer(withTimeInterval: 1.0/24.0, repeats: true) { [weak self] _ in
             guard let strongSelf = self else { return }
 
             Task { @MainActor in
@@ -155,16 +216,14 @@ public class LevelMeterService: ObservableObject {
                             }
                             strongSelf.audioLevels[uuid] = level
 
-                            // If this is the master bus, also update compatibility channels
-                            if uuid == strongSelf.masterBusUUID {
-                                strongSelf.leftChannel.peakValue *= strongSelf.peakDecayRate
-                                strongSelf.rightChannel.peakValue *= strongSelf.peakDecayRate
-                                if strongSelf.leftChannel.peakValue < 0.001 {
-                                    strongSelf.leftChannel.peakValue = 0.0
-                                }
-                                if strongSelf.rightChannel.peakValue < 0.001 {
-                                    strongSelf.rightChannel.peakValue = 0.0
-                                }
+                            // Update TR1 dedicated property if needed
+                            if uuid == "TR1" {
+                                strongSelf.tr1Level = level
+                            }
+                            
+                            // Update master bus level after individual track decay
+                            if uuid != strongSelf.masterBusUUID {
+                                strongSelf.updateMasterBusLevel()
                             }
                         }
                     }

ChattyChannels/ChattyChannels/Services/OSCListener.swift

@@ -202,6 +202,9 @@ public class OSCListener: ObservableObject, @unchecked Sendable {
             return
         }
 
+        // Commented out to reduce console spam at 24 Hz
+        // logger.info("Received identified RMS: \(logicTrackUUID) = \(rmsValue)")
+        
         oscService.processIdentifiedRMS(logicTrackUUID: logicTrackUUID, rmsValue: rmsValue)
     }
 

ChattyChannels/ChattyChannels/Views/VUMeter/SingleMeterView.swift

@@ -60,13 +60,23 @@ struct SingleMeterView: View {
                     activeColor: .red,
                     inactiveColor: .red.opacity(0.15)
                 )
-                .position(x: geometry.size.width * 0.77, // Use geometry
-                          y: geometry.size.height * 0.3) // Use geometry
+                .position(x: geometry.size.width * 0.88, // Moved slightly left
+                          y: geometry.size.height * 0.55) // Moved down considerably
             }
             // Removed .clipped()
             .onReceive(timer) { _ in
                 updateMeter()
             }
+            .onChange(of: audioLevel.rmsValue) { _, newValue in
+                // Force update when RMS value changes
+                // Commented out to reduce console spam at 24 Hz
+                // print("[VU Meter] RMS value changed to: \(newValue) for \(audioLevel.id)")
+                updateMeter()
+            }
+            .onAppear {
+                // Initialize needle position on appear
+                updateMeter()
+            }
         }
     }
 
@@ -80,9 +90,19 @@ struct SingleMeterView: View {
         let dbValue = audioLevel.dbfsValue
         let constrainedDb = min(max(dbValue, -20), 3) // Standard VU range -20dB to +3dB
 
+        // Debug logging - commented out to reduce console spam at 24 Hz
+        // if audioLevel.id == "TR1" {
+        //     print("[VU Meter TR1] RMS: \(audioLevel.rmsValue), dB: \(dbValue), constrained: \(constrainedDb)")
+        // }
+        
         // Map dB to rotation angle
         needleTarget = mapDbToRotation(db: constrainedDb)
 
+        // Debug needle position - commented out to reduce console spam at 24 Hz
+        // if audioLevel.id == "TR1" {
+        //     print("[VU Meter TR1] Needle target: \(needleTarget)°, current: \(needleRotation)°")
+        // }
+        
         // Apply VU meter ballistics (300ms integration time)
         // This coefficient adjusted for 24 Hz timing (was 0.15 for 60 Hz)
         needleRotation += (needleTarget - needleRotation) * 0.35

ChattyChannels/ChattyChannels/Views/VUMeter/VUMeterView.swift

@@ -14,49 +14,9 @@ struct VUMeterView: View {
     /// The service that provides audio level data
     @ObservedObject var levelService: LevelMeterService
 
-    // Get the most recently active track (for v0.7 OSC integration)
-    // This allows VU meters to automatically follow whichever track is sending RMS data
-    private var activeTrackUUID: String {
-        // Find the track with the most recent update time
-        let sortedTracks = levelService.audioLevels.sorted { lhs, rhs in
-            let lhsTime = lhs.value.lastUpdateTime
-            let rhsTime = rhs.value.lastUpdateTime
-            return lhsTime > rhsTime
-        }
-        
-        // Return the most recently updated track UUID, or a default
-        return sortedTracks.first?.key ?? "NO_ACTIVE_TRACK"
-    }
-    
-    // Computed properties for compatibility with v0.7 data model
-    private var leftChannelBinding: Binding<AudioLevel> {
-        Binding<AudioLevel>(
-            get: {
-                // Get the AudioLevel for the most active track or create a default one
-                let activeLevel = levelService.audioLevels[activeTrackUUID] ?? 
-                    AudioLevel(id: activeTrackUUID, rmsValue: 0.0, peakRmsValue: 0.0, trackName: "No Active Track")
-                
-                // For demo and backward compatibility - we'll treat the same level as both L and R channels
-                return activeLevel
-            },
-            set: { newLevel in
-                // We don't actually modify the level here as it's managed by LevelMeterService
-            }
-        )
-    }
-    
-    private var rightChannelBinding: Binding<AudioLevel> {
-        // We're using the same binding for both channels for now
-        // In a future version, we could map to different tracks for L/R channels
-        return leftChannelBinding
-    }
-    
-    // Current track name - defaults to "No Active Track" if not available
+    // Current track name - always shows "Master Bus"
     private var currentTrackName: String {
-        if let track = levelService.audioLevels[activeTrackUUID]?.trackName {
-            return track
-        }
-        return "No Active Track"
+        return "Master Bus"
     }
 
     var body: some View {
@@ -75,12 +35,12 @@ struct VUMeterView: View {
 
                         // Meters with spacing between them matching the right padding
                         HStack(spacing: 26) { // Increased spacing to match right padding
-                            // Left channel meter
-                            SingleMeterView(audioLevel: leftChannelBinding)
+                            // Left channel meter - now using direct binding to tr1Level
+                            SingleMeterView(audioLevel: $levelService.tr1Level)
                                 .frame(width: 112, height: 69) // Re-applying frame, 112, 69
 
-                            // Right channel meter
-                            SingleMeterView(audioLevel: rightChannelBinding)
+                            // Right channel meter - also using tr1Level (both meters show kick drum)
+                            SingleMeterView(audioLevel: $levelService.tr1Level)
                                 .frame(width: 112, height: 69) // Re-applying frame, 112, 69
                         }
                         .frame(width: 250) // Adjusted width for new meter size (112 + 26 + 112)
@@ -127,20 +87,19 @@ struct VUMeterView: View {
 struct VUMeterPreviewWrapper: View {
     @StateObject var levelServiceInstance = LevelMeterService()
 
-    init(populateData: Bool = true) {
-        if populateData {
-            let kickTrackUUID = "KICK_TRACK_UUID"
-            levelServiceInstance.audioLevels[kickTrackUUID] = AudioLevel(id: kickTrackUUID, rmsValue: 0.6, peakRmsValue: 0.9, trackName: "Kick")
-        }
-    }
-
     var body: some View {
         VUMeterView(levelService: levelServiceInstance)
+            .onAppear {
+                // Set up TR1 with test data
+                Task { @MainActor in
+                    levelServiceInstance.updateLevel(logicTrackUUID: "TR1", rmsValue: 0.6, peakRmsValueOverride: 0.9)
+                }
+            }
     }
 }
 
 #Preview("VU Meter View - Kick Track", traits: .sizeThatFitsLayout) {
-    VUMeterPreviewWrapper(populateData: true)
+    VUMeterPreviewWrapper()
         .frame(width: 300, height: 150)
         .padding()
         .background(Color.gray.opacity(0.2))