Tighten video compression budgets and temp-space checks

Lower the Writer video compression size targets to 7 Mbps for 1080p, 4 Mbps for 720p, and 2 Mbps for 480p, and log the resulting bitrate/file-length budget used for each export.

Fix the preflight storage gate to account for multipass export scratch space, filter compression options that do not fit current temporary disk capacity, and report the required temp-space budget in the disk-space alert. Add Technotes/VideoCompression.md to document the current presets, sizing rules, bitrate assumptions, and export pipeline.

Author: livid

Planet/Writer/VideoCompressionJob.swift

@@ -51,6 +51,26 @@ private func videoCompressionFormatString(_ value: String?) -> String {
     value ?? "nil"
 }
 
+private func videoCompressionFormatBitrate(_ value: Double?) -> String {
+    guard let value, value > 0 else {
+        return "nil"
+    }
+    if value >= 1_000_000 {
+        return String(format: "%.3fMbps", value / 1_000_000)
+    }
+    if value >= 1_000 {
+        return String(format: "%.1fKbps", value / 1_000)
+    }
+    return String(format: "%.0fbps", value)
+}
+
+private func videoCompressionFormatBitrate(_ value: Int64?) -> String {
+    guard let value else {
+        return "nil"
+    }
+    return videoCompressionFormatBitrate(Double(value))
+}
+
 private func videoCompressionDescribeError(_ error: Error) -> String {
     let nsError = error as NSError
     return "domain=\(nsError.domain) code=\(nsError.code) description=\(nsError.localizedDescription)"
@@ -136,6 +156,20 @@ struct VideoCompressionJob {
             usesHEVC ? AVAssetExportPresetHEVCHighestQuality : AVAssetExportPresetHighestQuality
         }
 
+        fileprivate var targetVideoBitrate: Int64 {
+            switch self {
+            case .h264FitInside1080p, .h265FitInside1080p:
+                return 7_000_000
+            case .h264FitInside720p, .h265FitInside720p:
+                return 4_000_000
+            case .h264FitInside480p, .h265FitInside480p:
+                return 2_000_000
+            }
+        }
+
+        private static let containerOverheadMultiplier = 1.03
+        private static let conservativeAudioBitrateBudget: Int64 = 192_000
+
         fileprivate var landscapeBoundingSize: CGSize {
             switch self {
             case .h264FitInside1080p, .h265FitInside1080p:
@@ -181,11 +215,73 @@ struct VideoCompressionJob {
             return max(2, roundedDown)
         }
 
+        fileprivate func audioBitrateBudget(sourceAudioBitrate: Double?) -> Int64 {
+            let fallbackAudioBitrate: Int64 = 128_000
+            guard let sourceAudioBitrate, sourceAudioBitrate > 0 else {
+                return fallbackAudioBitrate
+            }
+
+            let rounded = Int64(sourceAudioBitrate.rounded())
+            return min(max(rounded, 96_000), 192_000)
+        }
+
+        fileprivate func fileLengthLimit(
+            duration: CMTime,
+            sourceAudioBitrate: Double?
+        ) -> Int64? {
+            let durationSeconds = CMTimeGetSeconds(duration)
+            guard durationSeconds.isFinite, durationSeconds > 0 else {
+                return nil
+            }
+
+            let totalBitrate = targetVideoBitrate + audioBitrateBudget(
+                sourceAudioBitrate: sourceAudioBitrate
+            )
+            return Int64(
+                ceil(durationSeconds * Double(totalBitrate) / 8 * Self.containerOverheadMultiplier)
+            )
+        }
+
+        func estimatedMultipassTemporaryCapacityBytes(
+            durationSeconds: Double?,
+            sourceFileSizeBytes: Int64?
+        ) -> Int64? {
+            let outputBudgetBytes = estimatedOutputBudgetBytes(durationSeconds: durationSeconds)
+            let exportUnitBytes = [sourceFileSizeBytes, outputBudgetBytes]
+                .compactMap { $0 }
+                .max()
+
+            guard let exportUnitBytes, exportUnitBytes > 0 else {
+                return nil
+            }
+
+            let doubled = exportUnitBytes.multipliedReportingOverflow(by: 2)
+            return doubled.overflow ? Int64.max : doubled.partialValue
+        }
+
+        private func estimatedOutputBudgetBytes(durationSeconds: Double?) -> Int64? {
+            guard let durationSeconds, durationSeconds.isFinite, durationSeconds > 0 else {
+                return nil
+            }
+
+            let totalBitrate = targetVideoBitrate + audioBitrateBudget(
+                sourceAudioBitrate: Double(Self.conservativeAudioBitrateBudget)
+            )
+            return Int64(
+                ceil(durationSeconds * Double(totalBitrate) / 8 * Self.containerOverheadMultiplier)
+            )
+        }
+
         var debugDescription: String {
-            "id=\(id) title=\(title) preset=\(exportPresetName) usesHEVC=\(usesHEVC) boundingSize=\(videoCompressionFormatSize(landscapeBoundingSize))"
+            "id=\(id) title=\(title) preset=\(exportPresetName) usesHEVC=\(usesHEVC) boundingSize=\(videoCompressionFormatSize(landscapeBoundingSize)) targetVideoBitrate=\(videoCompressionFormatBitrate(targetVideoBitrate))"
         }
     }
 
+    private struct PreparedVideoComposition {
+        let composition: AVMutableVideoComposition
+        let duration: CMTime
+    }
+
     struct PreparedExport {
         let session: AVAssetExportSession
         let outputURL: URL
@@ -244,10 +340,31 @@ struct VideoCompressionJob {
             session.outputURL = outputURL
             session.outputFileType = outputFileType
             session.shouldOptimizeForNetworkUse = true
-            session.videoComposition = try await makeVideoComposition(for: asset)
+            session.canPerformMultiplePassesOverSourceMediaData = true
+            session.directoryForTemporaryFiles = FileManager.default.temporaryDirectory
+
+            let preparedVideoComposition = try await makeVideoComposition(for: asset)
+            session.videoComposition = preparedVideoComposition.composition
+
+            let sourceAudioBitrate = await estimatedAudioBitrate(for: asset)
+            let targetVideoBitrate = option.targetVideoBitrate
+            let audioBitrateBudget = option.audioBitrateBudget(
+                sourceAudioBitrate: sourceAudioBitrate
+            )
+            let fileLengthLimit = option.fileLengthLimit(
+                duration: preparedVideoComposition.duration,
+                sourceAudioBitrate: sourceAudioBitrate
+            )
+            if let fileLengthLimit {
+                session.fileLengthLimit = fileLengthLimit
+            }
 
             VideoLogger.log(
-                "[VideoCompressionJob] prepareExport ready outputURL=\(outputURL.path) outputFileType=\(outputFileType.rawValue) renderSize=\(videoCompressionFormatSize(session.videoComposition?.renderSize ?? .zero)) frameDurationSeconds=\(videoCompressionFormatSeconds(session.videoComposition?.frameDuration ?? .invalid)) optimizeForNetworkUse=\(session.shouldOptimizeForNetworkUse)"
+                "[VideoCompressionJob] configured bitrate budget targetVideoBitrate=\(videoCompressionFormatBitrate(targetVideoBitrate)) sourceAudioBitrate=\(videoCompressionFormatBitrate(sourceAudioBitrate)) audioBitrateBudget=\(videoCompressionFormatBitrate(audioBitrateBudget)) fileLengthLimitBytes=\(videoCompressionFormatBytes(fileLengthLimit)) multiplePasses=\(session.canPerformMultiplePassesOverSourceMediaData)"
+            )
+
+            VideoLogger.log(
+                "[VideoCompressionJob] prepareExport ready outputURL=\(outputURL.path) outputFileType=\(outputFileType.rawValue) renderSize=\(videoCompressionFormatSize(session.videoComposition?.renderSize ?? .zero)) frameDurationSeconds=\(videoCompressionFormatSeconds(session.videoComposition?.frameDuration ?? .invalid)) optimizeForNetworkUse=\(session.shouldOptimizeForNetworkUse) fileLengthLimitBytes=\(videoCompressionFormatBytes(fileLengthLimit))"
             )
 
             return PreparedExport(session: session, outputURL: outputURL)
@@ -298,7 +415,7 @@ struct VideoCompressionJob {
         }
     }
 
-    private func makeVideoComposition(for asset: AVAsset) async throws -> AVMutableVideoComposition {
+    private func makeVideoComposition(for asset: AVAsset) async throws -> PreparedVideoComposition {
         guard let videoTrack = try await asset.loadTracks(withMediaType: .video).first else {
             VideoLogger.log(
                 "[VideoCompressionJob] asset has no readable video track source=\(sourceURL.path)"
@@ -363,7 +480,10 @@ struct VideoCompressionJob {
         VideoLogger.log(
             "[VideoCompressionJob] video composition prepared renderSize=\(videoCompressionFormatSize(renderSize)) frameDurationSeconds=\(videoCompressionFormatSeconds(videoComposition.frameDuration)) transform=\(videoCompressionFormatTransform(transform)) instructionDurationSeconds=\(videoCompressionFormatSeconds(duration))"
         )
-        return videoComposition
+        return PreparedVideoComposition(
+            composition: videoComposition,
+            duration: duration
+        )
     }
 
     private func preferredOutputFileType(for session: AVAssetExportSession) throws -> AVFileType {
@@ -426,6 +546,17 @@ struct VideoCompressionJob {
         }
     }
 
+    private func estimatedAudioBitrate(for asset: AVAsset) async -> Double? {
+        guard let audioTrack = try? await asset.loadTracks(withMediaType: .audio).first,
+              let estimatedDataRate = try? await audioTrack.load(.estimatedDataRate),
+              estimatedDataRate > 0
+        else {
+            return nil
+        }
+
+        return Double(estimatedDataRate)
+    }
+
     private func scaledTransform(
         naturalSize: CGSize,
         preferredTransform: CGAffineTransform,

Planet/Writer/VideoInfoRow.swift

@@ -11,6 +11,14 @@ private enum CompressionStorageDecision {
     case compressWithBackup
 }
 
+private struct CompressionStorageAssessment {
+    let decision: CompressionStorageDecision
+    let videoSizeBytes: Int64?
+    let requiredCapacityBytes: Int64?
+    let requiredCapacityWithBackupBytes: Int64?
+    let availableCapacityBytes: Int64?
+}
+
 struct VideoInfoRow: View {
     @ObservedObject var videoAttachment: Attachment
     @ObservedObject var viewModel: WriterViewModel
@@ -24,6 +32,7 @@ struct VideoInfoRow: View {
     @State private var compressionStartedAt: Date?
     @State private var compressionFramesPerSecond: Double?
     @State private var lastLoggedCompressionProgressStep: Int = -1
+    @State private var presentableCompressionOptions: [VideoCompressionJob.Option] = []
     @State private var isCompressing: Bool = false
     @State private var isShowingCompressionOptions: Bool = false
 
@@ -161,19 +170,30 @@ struct VideoInfoRow: View {
 
     @MainActor
     private func openCompressionOptions() {
-        let assessment = compressionStorageDecision(for: videoAttachment.path)
-        logStorageAssessment(assessment, context: "openCompressionOptions")
-        guard assessment.decision != .blocked else {
+        let assessments = availableCompressionOptions.map {
+            ($0, compressionStorageAssessment(for: videoAttachment.path, option: $0))
+        }
+        let feasibleOptions = assessments.compactMap { option, assessment in
+            assessment.decision == .blocked ? nil : option
+        }
+        presentableCompressionOptions = feasibleOptions
+        guard !feasibleOptions.isEmpty else {
+            let blockingAssessment = assessments
+                .map(\.1)
+                .min { lhs, rhs in
+                    (lhs.requiredCapacityBytes ?? .max) < (rhs.requiredCapacityBytes ?? .max)
+                } ?? compressionStorageAssessment(for: videoAttachment.path, option: nil)
+            logStorageAssessment(blockingAssessment, context: "openCompressionOptions")
             log("compression options blocked because temporary disk space is insufficient")
             showInsufficientDiskSpaceAlert(
-                videoSizeBytes: assessment.videoSizeBytes,
-                availableCapacityBytes: assessment.availableCapacityBytes
+                requiredCapacityBytes: blockingAssessment.requiredCapacityBytes,
+                availableCapacityBytes: blockingAssessment.availableCapacityBytes
             )
             return
         }
 
         log(
-            "showing compression options availableOptions=\(availableCompressionOptions.map(\.id).joined(separator: ",")) videoInfoLoaded=\(videoInfo != nil)"
+            "showing compression options availableOptions=\(feasibleOptions.map(\.id).joined(separator: ",")) videoInfoLoaded=\(videoInfo != nil)"
         )
         isShowingCompressionOptions = true
     }
@@ -185,13 +205,13 @@ struct VideoInfoRow: View {
             return
         }
 
-        let assessment = compressionStorageDecision(for: videoAttachment.path)
+        let assessment = compressionStorageAssessment(for: videoAttachment.path, option: option)
         logStorageAssessment(assessment, context: "startCompression")
         guard assessment.decision != .blocked else {
             isShowingCompressionOptions = false
             log("compression blocked before starting export")
             showInsufficientDiskSpaceAlert(
-                videoSizeBytes: assessment.videoSizeBytes,
+                requiredCapacityBytes: assessment.requiredCapacityBytes,
                 availableCapacityBytes: assessment.availableCapacityBytes
             )
             return
@@ -455,7 +475,7 @@ struct VideoInfoRow: View {
             }
 
             VStack(spacing: 10) {
-                ForEach(availableCompressionOptions) { option in
+                ForEach(presentableCompressionOptions) { option in
                     Button {
                         startCompression(using: option)
                     } label: {
@@ -479,27 +499,63 @@ struct VideoInfoRow: View {
         .frame(width: 360)
     }
 
-    private func compressionStorageDecision(
-        for sourceURL: URL
-    ) -> (decision: CompressionStorageDecision, videoSizeBytes: Int64?, availableCapacityBytes: Int64?) {
-        guard let videoSizeBytes = fileSizeBytes(for: sourceURL), videoSizeBytes > 0 else {
-            return (.compressWithoutBackup, nil, temporaryDirectoryAvailableCapacityBytes())
+    private func compressionStorageAssessment(
+        for sourceURL: URL,
+        option: VideoCompressionJob.Option?
+    ) -> CompressionStorageAssessment {
+        let videoSizeBytes = fileSizeBytes(for: sourceURL)
+        let requiredCapacityBytes =
+            option?.estimatedMultipassTemporaryCapacityBytes(
+                durationSeconds: videoInfo?.durationSecondsValue,
+                sourceFileSizeBytes: videoSizeBytes
+            )
+            ?? videoSizeBytes?.multipliedReportingOverflow(by: 2).partialValue
+        let requiredCapacityWithBackupBytes: Int64?
+        if let requiredCapacityBytes, let videoSizeBytes {
+            let sum = requiredCapacityBytes.addingReportingOverflow(videoSizeBytes)
+            requiredCapacityWithBackupBytes = sum.overflow ? Int64.max : sum.partialValue
+        } else {
+            requiredCapacityWithBackupBytes = nil
         }
 
         guard let availableCapacityBytes = temporaryDirectoryAvailableCapacityBytes() else {
-            return (.compressWithoutBackup, videoSizeBytes, nil)
+            return CompressionStorageAssessment(
+                decision: .compressWithoutBackup,
+                videoSizeBytes: videoSizeBytes,
+                requiredCapacityBytes: requiredCapacityBytes,
+                requiredCapacityWithBackupBytes: requiredCapacityWithBackupBytes,
+                availableCapacityBytes: nil
+            )
         }
 
-        if availableCapacityBytes < videoSizeBytes {
-            return (.blocked, videoSizeBytes, availableCapacityBytes)
+        if let requiredCapacityBytes, availableCapacityBytes < requiredCapacityBytes {
+            return CompressionStorageAssessment(
+                decision: .blocked,
+                videoSizeBytes: videoSizeBytes,
+                requiredCapacityBytes: requiredCapacityBytes,
+                requiredCapacityWithBackupBytes: requiredCapacityWithBackupBytes,
+                availableCapacityBytes: availableCapacityBytes
+            )
         }
 
-        let tenTimesVideoSize = videoSizeBytes.multipliedReportingOverflow(by: 10)
-        if !tenTimesVideoSize.overflow, availableCapacityBytes >= tenTimesVideoSize.partialValue {
-            return (.compressWithBackup, videoSizeBytes, availableCapacityBytes)
+        if let requiredCapacityWithBackupBytes,
+           availableCapacityBytes >= requiredCapacityWithBackupBytes {
+            return CompressionStorageAssessment(
+                decision: .compressWithBackup,
+                videoSizeBytes: videoSizeBytes,
+                requiredCapacityBytes: requiredCapacityBytes,
+                requiredCapacityWithBackupBytes: requiredCapacityWithBackupBytes,
+                availableCapacityBytes: availableCapacityBytes
+            )
         }
 
-        return (.compressWithoutBackup, videoSizeBytes, availableCapacityBytes)
+        return CompressionStorageAssessment(
+            decision: .compressWithoutBackup,
+            videoSizeBytes: videoSizeBytes,
+            requiredCapacityBytes: requiredCapacityBytes,
+            requiredCapacityWithBackupBytes: requiredCapacityWithBackupBytes,
+            availableCapacityBytes: availableCapacityBytes
+        )
     }
 
     private func fileSizeBytes(for url: URL) -> Int64? {
@@ -567,14 +623,14 @@ struct VideoInfoRow: View {
     }
 
     private func showInsufficientDiskSpaceAlert(
-        videoSizeBytes: Int64?,
+        requiredCapacityBytes: Int64?,
         availableCapacityBytes: Int64?
     ) {
         let message: String
-        if let videoSizeBytes, let availableCapacityBytes {
-            message = "Planet needs at least \(formattedByteCount(videoSizeBytes)) of free temporary disk space to compress this video. Only \(formattedByteCount(availableCapacityBytes)) is currently available."
+        if let requiredCapacityBytes, let availableCapacityBytes {
+            message = "Planet needs at least \(formattedByteCount(requiredCapacityBytes)) of free temporary disk space to compress this video. Only \(formattedByteCount(availableCapacityBytes)) is currently available."
         } else {
-            message = "Planet needs at least as much free temporary disk space as the source video size to compress this video."
+            message = "Planet needs more free temporary disk space to compress this video."
         }
 
         PlanetStore.shared.alert(
@@ -674,11 +730,11 @@ struct VideoInfoRow: View {
     }
 
     private func logStorageAssessment(
-        _ assessment: (decision: CompressionStorageDecision, videoSizeBytes: Int64?, availableCapacityBytes: Int64?),
+        _ assessment: CompressionStorageAssessment,
         context: String
     ) {
         log(
-            "\(context) decision=\(describeStorageDecision(assessment.decision)) videoSizeBytes=\(formatBytes(assessment.videoSizeBytes)) availableCapacityBytes=\(formatBytes(assessment.availableCapacityBytes))"
+            "\(context) decision=\(describeStorageDecision(assessment.decision)) videoSizeBytes=\(formatBytes(assessment.videoSizeBytes)) requiredCapacityBytes=\(formatBytes(assessment.requiredCapacityBytes)) requiredCapacityWithBackupBytes=\(formatBytes(assessment.requiredCapacityWithBackupBytes)) availableCapacityBytes=\(formatBytes(assessment.availableCapacityBytes))"
         )
     }
 

Planet/versioning.xcconfig

@@ -1 +1 @@
-CURRENT_PROJECT_VERSION = 2749
+CURRENT_PROJECT_VERSION = 2750