Merge pull request #5 from StreamUI/070124-streaming

Streaming to youtube is not fun

Author: Jonovono

Sources/StreamUI/Recorders/Recorder.swift

@@ -29,22 +29,22 @@ public class Recorder {
     public var renderSettings: RenderSettings
     public var assetWriter: AVAssetWriter?
 
-    private var hud: HUD
+   private var hud: HUD
 
     public init(renderSettings: RenderSettings) {
         self.controlledClock = ControlledClock()
         self.frameTimer = FrameTimer(frameRate: Double(renderSettings.fps))
 
         self.renderSettings = renderSettings
-        self.hud = HUD()
+       self.hud = HUD()
 
         self.videoRecorder = VideoRecorder(renderSettings: renderSettings)
         self.audioRecorder = AudioRecorder(renderSettings: renderSettings, frameTimer: frameTimer)
         self.rtmpStreaming = RTMPStreaming(renderSettings: renderSettings)
 
         videoRecorder.setParentRecorder(self)
         audioRecorder.setParentRecorder(self)
-        hud.setRecorder(recorder: self)
+       hud.setRecorder(recorder: self)
     }
 
     @MainActor
@@ -100,27 +100,29 @@ public class Recorder {
                     let start = clock.now
 
                     await captureFrame()
-                    let end = clock.now
-                    let elapsed = end - start
 
                     await controlledClock.advance(by: frameDuration)
+                    let end = clock.now
+                    let elapsed = end - start
                     let sleepDuration = frameDuration - elapsed
 
                     if sleepDuration > .zero {
+//                        try await Task.sleep(for: .seconds(0.1))
                         try await Task.sleep(for: sleepDuration)
+//                        try await Task.sleep(for: frameDuration)
                     }
-                    self.hud.render()
+                   self.hud.render()
 
                 case .paused:
-                    self.hud.render()
+                   self.hud.render()
                     try await Task.sleep(for: frameDuration)
 
                 case .finished, .idle:
                     break
                 }
             }
 
-            self.hud.render()
+           self.hud.render()
             await finishRecording()
         }
     }

Sources/StreamUI/Streaming/RTMPStreaming.swift

@@ -18,7 +18,13 @@ public class RTMPStreaming: ObservableObject {
 
     private var rtmpStreams: [RTMPStream] = []
     private var rtmpConnections: [RTMPConnection] = []
+    private var lastSampleBufferTimestamp: CMTime?
 
+    // Properties for frame rate logging
+    private var frameCount: Int = 0
+    private var startTime: Date?
+    private let logInterval: TimeInterval = 5.0 // Log every 5 seconds
+
     public init(renderSettings: RenderSettings) {
         self.renderSettings = renderSettings
         setupRTMPStreams()
@@ -42,11 +48,34 @@ public class RTMPStreaming: ObservableObject {
     }
 
     private func configureRTMPStream(_ rtmpStream: RTMPStream, with streamSettings: LivestreamSettings) {
-        rtmpStream.videoSettings.videoSize = CGSize(width: CGFloat(renderSettings.width), height: CGFloat(renderSettings.height))
-        rtmpStream.videoSettings.profileLevel = streamSettings.profileLevel ?? kVTProfileLevel_H264_Main_AutoLevel as String
-        rtmpStream.videoSettings.bitRate = streamSettings.bitRate ?? renderSettings.getDefaultBitrate()
-        rtmpStream.videoSettings.maxKeyFrameIntervalDuration = 2
-        rtmpStream.videoSettings.scalingMode = .trim
+//        rtmpStream.videoSettings.videoSize = CGSize(width: CGFloat(renderSettings.width), height: CGFloat(renderSettings.height))
+//        rtmpStream.videoSettings.profileLevel = streamSettings.profileLevel ?? kVTProfileLevel_H264_Main_AutoLevel as String
+//        rtmpStream.videoSettings.bitRate = streamSettings.bitRate ?? renderSettings.getDefaultBitrate()
+//        rtmpStream.videoSettings.profileLevel = kVTProfileLevel_H264_Baseline_AutoLevel as String
+//        rtmpStream.videoSettings.bitRate = 1200 * 1000
+//        rtmpStream.videoSettings.maxKeyFrameIntervalDuration = 2
+//        rtmpStream.videoSettings.scalingMode = .trim
+        
+        let bitrate = renderSettings.getDefaultBitrate()
+        rtmpStream.frameRate = Double(renderSettings.fps)
+//        stream.videoSettings.bitRateMode = .constant
+//        rtmpStream.sessionPreset = .hd1920x1080
+        rtmpStream.sessionPreset = .hd1920x1080
+//        let bitrate = 6800 * 1000 // 6800 Kbps in bps
+        
+        rtmpStream.videoSettings = VideoCodecSettings(
+            videoSize: CGSize(width: renderSettings.width, height: renderSettings.height),
+            bitRate: bitrate,
+            // renderSettings.getDefaultBitrate(),
+//            profileLevel: kVTProfileLevel_H264_Baseline_5_2 as String,
+//            profileLevel: kVTProfileLevel_H264_Baseline_AutoLevel as String,
+            profileLevel: kVTProfileLevel_H264_Main_AutoLevel as String,
+            scalingMode: .trim,
+            bitRateMode: .constant,
+            maxKeyFrameIntervalDuration: 2
+        )
+        
+//        rtmpStream.bitrateStrategy = VideoAdaptiveNetBitRateStrategy(mamimumVideoBitrate: VideoCodecSettings.default.bitRate)
     }
 
     public func startStreaming() {
@@ -60,6 +89,7 @@ public class RTMPStreaming: ObservableObject {
         }
 
         isStreaming = true
+        // resetFrameRateLogging()
     }
 
     public func stopStreaming() {
@@ -77,17 +107,39 @@ public class RTMPStreaming: ObservableObject {
 
     public func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer) {
         guard isStreaming else { return }
-        
+       
         for rtmpStream in rtmpStreams {
             rtmpStream.append(sampleBuffer)
         }
+        
+        // logFrameRate()
     }
 
     @objc private func rtmpStatusHandler(_ notification: Notification) {
         // Handle RTMP status
+        print("RTMP STATUS", notification)
     }
 
     @objc private func rtmpErrorHandler(_ notification: Notification) {
+        print("RTMP ERROR", notification)
         // Handle RTMP error
     }
+    
+    private func resetFrameRateLogging() {
+        frameCount = 0
+        startTime = Date()
+    }
+    
+    private func logFrameRate() {
+        frameCount += 1
+        
+        guard let startTime = startTime else { return }
+        
+        let elapsedTime = Date().timeIntervalSince(startTime)
+        if elapsedTime >= logInterval {
+            let frameRate = Double(frameCount) / elapsedTime
+            print("Current frame rate: \(frameRate) fps")
+            resetFrameRateLogging()
+        }
+    }
 }