feat: export resolution and quality options

Export was locked to source resolution at a fixed 0.1 bits-per-pixel.
A new options popover next to Export offers resolution (full/75%/50%)
and quality (low/medium/high bpp). The compositor renders straight into
the scaled destination buffer, so downscaling rides the existing GPU
video-quad sampling, and overlays — positioned in normalized space —
scale with the frame for free.

Author: jasonzh0

CineScreen/Editor/Sidebar/SidebarView.swift

@@ -10,6 +10,11 @@ struct SidebarView: View {
     /// Live pipeline while an export runs — kept so the Cancel button can
     /// reach it. Nil outside an export.
     @State private var exportPipeline: ExportPipeline?
+    @State private var showExportOptions = false
+    /// Output size as a fraction of the source (1.0 = native).
+    @State private var exportScale: Double = 1.0
+    /// H.264 bits-per-pixel budget; 0.10 matches the previous fixed value.
+    @State private var exportBitsPerPixel: Double = 0.10
 
     var body: some View {
         VStack(alignment: .leading, spacing: 14) {
@@ -88,6 +93,44 @@ struct SidebarView: View {
 
             Spacer()
 
+            Button {
+                showExportOptions = true
+            } label: {
+                Image(systemName: "slider.horizontal.3")
+                    .font(.system(size: 12, weight: .medium))
+                    .frame(width: 32, height: 32)
+                    .foregroundStyle(CTheme.textSecondary)
+                    .background(
+                        RoundedRectangle(cornerRadius: CTheme.Radius.sm, style: .continuous)
+                            .fill(CTheme.surface)
+                    )
+                    .overlay(
+                        RoundedRectangle(cornerRadius: CTheme.Radius.sm, style: .continuous)
+                            .strokeBorder(CTheme.stroke, lineWidth: 1)
+                    )
+            }
+            .buttonStyle(.plain)
+            .disabled(isExporting)
+            .help("Export options")
+            .popover(isPresented: $showExportOptions, arrowEdge: .bottom) {
+                VStack(alignment: .leading, spacing: 12) {
+                    Picker("Resolution", selection: $exportScale) {
+                        Text("Full").tag(1.0)
+                        Text("75%").tag(0.75)
+                        Text("50%").tag(0.5)
+                    }
+                    .pickerStyle(.segmented)
+                    Picker("Quality", selection: $exportBitsPerPixel) {
+                        Text("Low").tag(0.05)
+                        Text("Medium").tag(0.10)
+                        Text("High").tag(0.16)
+                    }
+                    .pickerStyle(.segmented)
+                }
+                .padding(14)
+                .frame(width: 240)
+            }
+
             Button {
                 startExport()
             } label: {
@@ -744,7 +787,9 @@ struct SidebarView: View {
                     canvas: vm.canvasStyle,
                     webcamURL: vm.webcamURL,
                     webcamLayout: webcamLayout,
-                    webcamOffsetMs: vm.metadata?.webcamOffsetMs ?? 0
+                    webcamOffsetMs: vm.metadata?.webcamOffsetMs ?? 0,
+                    outputScale: exportScale,
+                    bitsPerPixel: exportBitsPerPixel
                 )) { progress in
                     progressCont.yield(progress)
                 }

CineScreen/Export/ExportPipeline.swift

@@ -66,6 +66,11 @@ final class ExportPipeline {
         /// Camera warm-up offset (screenT = webcamT + offsetMs) — shifts the
         /// webcam read window so the overlay is time-aligned with the screen.
         var webcamOffsetMs: Double = 0
+        /// Output size as a fraction of the source (1.0 = native). Overlays
+        /// are positioned in normalized space, so they scale with the frame.
+        var outputScale: Double = 1.0
+        /// H.264 bits-per-pixel budget (bitrate = w*h*fps*bpp).
+        var bitsPerPixel: Double = 0.10
     }
 
     enum Progress {
@@ -167,11 +172,18 @@ final class ExportPipeline {
             .appendingPathComponent(".cinescreen-export-\(UUID().uuidString).mp4")
         let writer = try AVAssetWriter(outputURL: tempURL, fileType: .mp4)
 
-        let videoBitrate = Int(Double(Int(outputSize.width) * Int(outputSize.height)) * Double(fps) * 0.10)
+        // Scaled output dimensions (even, for the encoder). The compositor
+        // renders into the destination buffer, so downscaling happens on the
+        // GPU as part of the normal video-quad sampling.
+        let scale = min(1.0, max(0.1, input.outputScale))
+        let scaledW = max(2, (Int(outputSize.width * scale) / 2) * 2)
+        let scaledH = max(2, (Int(outputSize.height * scale) / 2) * 2)
+
+        let videoBitrate = Int(Double(scaledW * scaledH) * Double(fps) * input.bitsPerPixel)
         let videoSettings: [String: Any] = [
             AVVideoCodecKey: AVVideoCodecType.h264,
-            AVVideoWidthKey: Int(outputSize.width),
-            AVVideoHeightKey: Int(outputSize.height),
+            AVVideoWidthKey: scaledW,
+            AVVideoHeightKey: scaledH,
             AVVideoCompressionPropertiesKey: [
                 AVVideoAverageBitRateKey: videoBitrate,
                 AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
@@ -186,8 +198,8 @@ final class ExportPipeline {
 
         let pixelBufferAttrs: [String: Any] = [
             kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
-            kCVPixelBufferWidthKey as String: Int(outputSize.width),
-            kCVPixelBufferHeightKey as String: Int(outputSize.height),
+            kCVPixelBufferWidthKey as String: scaledW,
+            kCVPixelBufferHeightKey as String: scaledH,
             kCVPixelBufferMetalCompatibilityKey as String: true,
             kCVPixelBufferIOSurfacePropertiesKey as String: [:],
         ]