4k 120fps Showing Black Screen on iPhone 16

Hey - I am developing an app that uses the camera for recording video. I put the ability to choose a framerate and resolution and all combinations work perfectly fine, except for 4k 120fps for the new iPhone 16 pro. This just shows black on the preview. I tried to record even though the preview was black, but the recording is also just a black screen. Is there anything special that needs to be done in the camera setup for 4k 120fps to work? I have my camera setup code attached. Is it possible this is a bug in Apple's code, since this works with every other combination (1080p up to 240fps and 4k up to 60fps)?

Thanks so much for the help.

class CameraManager: NSObject {
  enum Errors: Error {
     case noCaptureDevice
     case couldNotAddInput
     case unsupportedConfiguration
}
 
enum Resolution {
    case hd1080p
    case uhd4K
    
    var preset: AVCaptureSession.Preset {
        switch self {
        case .hd1080p:
            return .hd1920x1080
        case .uhd4K:
            return .hd4K3840x2160
        }
    }
    
    var dimensions: CMVideoDimensions {
        switch self {
        case .hd1080p:
            return CMVideoDimensions(width: 1920, height: 1080)
        case .uhd4K:
            return CMVideoDimensions(width: 3840, height: 2160)
        }
    }
}
 
enum CameraType {
    case wide
    case ultraWide
    
    var captureDeviceType: AVCaptureDevice.DeviceType {
        switch self {
        case .wide:
            return .builtInWideAngleCamera
        case .ultraWide:
            return .builtInUltraWideCamera
        }
    }
}
 
enum FrameRate: Int {
    case fps60 = 60
    case fps120 = 120
    case fps240 = 240
}
 
let orientationManager = OrientationManager()
let captureSession: AVCaptureSession
let previewLayer: AVCaptureVideoPreviewLayer
let movieFileOutput = AVCaptureMovieFileOutput()
let videoDataOutput = AVCaptureVideoDataOutput()
private var videoCaptureDevice: AVCaptureDevice?
 
override init() {
    self.captureSession = AVCaptureSession()
    self.previewLayer = AVCaptureVideoPreviewLayer(session: self.captureSession)
    super.init()
    
    self.previewLayer.videoGravity = .resizeAspect
}
 
func configureSession(resolution: Resolution, frameRate: FrameRate, stabilizationEnabled: Bool, cameraType: CameraType, sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate?) throws {
        assert(Thread.isMainThread)
    
    captureSession.beginConfiguration()
    defer { captureSession.commitConfiguration() }
    
    captureSession.sessionPreset = resolution.preset
    
    if captureSession.canAddOutput(movieFileOutput) {
        captureSession.addOutput(movieFileOutput)
    } else {
        throw Errors.couldNotAddInput
    }
    
    videoDataOutput.setSampleBufferDelegate(sampleBufferDelegate, queue: DispatchQueue(label: "VideoDataOutputQueue"))
            if captureSession.canAddOutput(videoDataOutput) {
                captureSession.addOutput(videoDataOutput)
                // Set the video orientation if needed
                if let connection = videoDataOutput.connection(with: .video) {
                    //connection.videoOrientation = .portrait
                }
            } else {
                throw Errors.couldNotAddInput
            }
    
    guard let videoCaptureDevice = AVCaptureDevice.default(cameraType.captureDeviceType, for: .video, position: .back) else {
        throw Errors.noCaptureDevice
    }
    
    let useDimensions = resolution.dimensions
    guard let format = videoCaptureDevice.formats.first(where: { format in
        let dimensions = CMVideoFormatDescriptionGetDimensions(format.formatDescription)
        let isRes = dimensions.width == useDimensions.width && dimensions.height == useDimensions.height
        let frameRates = format.videoSupportedFrameRateRanges
        return isRes && frameRates.contains(where: { $0.maxFrameRate >= Float64(frameRate.rawValue) })
    }) else {
        throw Errors.unsupportedConfiguration
    }
    
    self.videoCaptureDevice = videoCaptureDevice
    
    do {
        let videoInput = try AVCaptureDeviceInput(device: videoCaptureDevice)
        if captureSession.canAddInput(videoInput) {
            captureSession.addInput(videoInput)
        } else {
            throw Errors.couldNotAddInput
        }
        
        try videoCaptureDevice.lockForConfiguration()
        videoCaptureDevice.activeFormat = format
        videoCaptureDevice.activeVideoMinFrameDuration = CMTime(value: 1, timescale: CMTimeScale(frameRate.rawValue))
        videoCaptureDevice.activeVideoMaxFrameDuration = CMTime(value: 1, timescale: CMTimeScale(frameRate.rawValue))
        videoCaptureDevice.activeMaxExposureDuration = CMTime(seconds: 1.0 / 960, preferredTimescale: 1000000)
        videoCaptureDevice.exposureMode = .locked
        videoCaptureDevice.unlockForConfiguration()
    } catch {
        throw error
    }
    
    configureStabilization(enabled: stabilizationEnabled)
}`