Multicam fixes (#851)

Resolves #843 

- Reverts the core part of #833 for multi cam devices, as it may cause
timeout when mixing wrong format vs session type
- Adds `aspectRatio` criterion to minimize cropping
- Fixes `VideoView` jumps when using square formats in fill mode due to
floating point comparisons (flipping between 1+/-eps)

Waiting for a better fix for square cropping (if any).

<img width="1019" height="305" alt="image"
src="https://github.com/user-attachments/assets/0159893e-df35-4b79-bf93-fb0c86584b77"
/>

Author: pblazej

.changes/camera-timeout

@@ -0,0 +1 @@
+patch type="fixed" "Timeouts when publishing camera tracks"

Sources/LiveKit/Extensions/CGFloat.swift

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+extension CGFloat {
+    static let aspectRatioTolerance: Self = 0.01
+}

Sources/LiveKit/Extensions/CustomStringConvertible.swift

@@ -204,7 +204,7 @@ extension AVCaptureDevice.Format {
         var values: [String] = []
         values.append("fps: \(fpsRange())")
         #if os(iOS)
-        values.append("isMulticamSupported: \(isMultiCamSupported)")
+        values.append("isMultiCamSupported: \(isMultiCamSupported)")
         #endif
         return "Format(\(values.joined(separator: ", ")))"
     }

Sources/LiveKit/Track/Capturers/CameraCapturer.swift

@@ -90,6 +90,14 @@ public class CameraCapturer: VideoCapturer, @unchecked Sendable {
         capturer.captureSession
     }
 
+    private var isMultiCamSession: Bool {
+        #if os(iOS) || os(tvOS)
+        captureSession is AVCaptureMultiCamSession
+        #else
+        false
+        #endif
+    }
+
     // RTCCameraVideoCapturer used internally for now
     private lazy var capturer: LKRTCCameraVideoCapturer = .init(delegate: adapter)
 
@@ -154,21 +162,17 @@ public class CameraCapturer: VideoCapturer, @unchecked Sendable {
         var device: AVCaptureDevice? = options.device
 
         if device == nil {
-            #if os(iOS) || os(tvOS)
             var devices: [AVCaptureDevice]
-            if AVCaptureMultiCamSession.isMultiCamSupported {
+            if isMultiCamSession {
                 // Get the list of devices already on the shared multi-cam session.
                 let existingDevices = captureSession.inputs.compactMap { $0 as? AVCaptureDeviceInput }.map(\.device)
-                log("Existing multicam devices: \(existingDevices)")
+                log("Existing multiCam devices: \(existingDevices)")
                 // Compute other multi-cam compatible devices.
                 devices = try await DeviceManager.shared.multiCamCompatibleDevices(for: Set(existingDevices))
-                log("Compabible multicam devices: \(devices)")
+                log("Compatible multiCam devices: \(devices)")
             } else {
                 devices = try await CameraCapturer.captureDevices()
             }
-            #else
-            var devices = try await CameraCapturer.captureDevices()
-            #endif
 
             #if !os(visionOS)
             // Filter by deviceType if specified in options.
@@ -217,26 +221,27 @@ public class CameraCapturer: VideoCapturer, @unchecked Sendable {
 
             let any: (FormatTuple) -> Bool = { _ in true }
             let matchesFps: (FormatTuple) -> Bool = { $0.format.fpsRange().contains(targetFps) }
-            let supportsMulticam: (FormatTuple) -> Bool = { $0.format.filterForMulticamSupport }
+            let matchesAspectRatio: (FormatTuple) -> Bool = {
+                let sourceRatio = Double($0.dimensions.width) / Double($0.dimensions.height)
+                let targetRatio = Double(targetDimensions.width) / Double(targetDimensions.height)
+                return abs(sourceRatio - targetRatio) / targetRatio < CGFloat.aspectRatioTolerance
+            }
+            let supportsMultiCam: (FormatTuple) -> Bool = { $0.format.filterForMultiCamSupport }
             let byManhattanDistance: (FormatTuple, FormatTuple) -> Bool = { manhattanDistance($0) < manhattanDistance($1) }
 
-            #if os(iOS) || os(tvOS)
-            let isMulticamActive = AVCaptureMultiCamSession.isMultiCamSupported && !captureSession.inputs.isEmpty
-            let criteria: [(name: String, filter: (FormatTuple) -> Bool)] = isMulticamActive ? [
-                (name: "fps, multicam", filter: { matchesFps($0) && supportsMulticam($0) }),
-                (name: "multicam", filter: supportsMulticam),
-                (name: "fps", filter: matchesFps),
-                (name: "(fallback)", filter: any),
-            ] : [
-                (name: "fps", filter: matchesFps),
-                (name: "(fallback)", filter: any),
-            ]
-            #else
-            let criteria: [(name: String, filter: (FormatTuple) -> Bool)] = [
+            var criteria: [(name: String, filter: (FormatTuple) -> Bool)] = isMultiCamSession ? [
+                (name: "multiCam, aspectRatio, fps", filter: { supportsMultiCam($0) && matchesAspectRatio($0) && matchesFps($0) }),
+                (name: "multiCam, aspectRatio", filter: { supportsMultiCam($0) && matchesAspectRatio($0) }),
+                (name: "multiCam, fps", filter: { supportsMultiCam($0) && matchesFps($0) }),
+                (name: "multiCam", filter: supportsMultiCam),
+            ] : []
+
+            criteria.append(contentsOf: [
+                (name: "aspectRatio, fps", filter: { matchesAspectRatio($0) && matchesFps($0) }),
+                (name: "aspectRatio", filter: matchesAspectRatio),
                 (name: "fps", filter: matchesFps),
                 (name: "(fallback)", filter: any),
-            ]
-            #endif
+            ])
 
             for (name, filter) in criteria {
                 if let foundFormat = sortedFormats.sorted(by: byManhattanDistance).first(where: filter) {
@@ -384,7 +389,7 @@ extension AVCaptureDevice.Format {
 
     // Used for filtering.
     // Only include multi-cam supported devices if in multi-cam mode. Otherwise, always include the devices.
-    var filterForMulticamSupport: Bool {
+    var filterForMultiCamSupport: Bool {
         #if os(iOS) || os(tvOS)
         return AVCaptureMultiCamSession.isMultiCamSupported ? isMultiCamSupported : true
         #else

Sources/LiveKit/Views/VideoView.swift

@@ -467,10 +467,13 @@ public class VideoView: NativeView, Loggable {
         let hDim = CGFloat(dimensions.height)
         let wRatio = size.width / wDim
         let hRatio = size.height / hDim
+        let ratioDiff = abs(hRatio - wRatio)
 
-        if state.layoutMode == .fill ? hRatio > wRatio : hRatio < wRatio {
+        if ratioDiff < CGFloat.aspectRatioTolerance {
+            // no-op
+        } else if state.layoutMode == .fill ? hRatio > wRatio : hRatio < wRatio {
             size.width = size.height / hDim * wDim
-        } else if state.layoutMode == .fill ? wRatio > hRatio : wRatio < hRatio {
+        } else {
             size.height = size.width / wDim * hDim
         }