Restore manual export controls

Author: Bolyki György

TeslaCam/AppState.swift

@@ -327,6 +327,7 @@ final class AppState: ObservableObject {
   @Published var camerasDetected: [Camera] = []
   @Published var duplicatePolicy: DuplicateClipPolicy = .mergeByTime
   @Published var selectedExportCameras: Set<Camera> = Set(Camera.allCases)
+  @Published var exportPreset: ExportPreset = .maxQualityHEVC
   @Published var healthSummary: ExportHealthSummary?
   @Published var layoutProfile: CameraLayoutProfile = .mixedUnknown
   @Published var duplicateSummary = DuplicateResolutionSummary(
@@ -370,11 +371,8 @@ final class AppState: ObservableObject {
       )
     }
   }
-  // Mux-first default: the common export takes the lossless passthrough path
-  // (no re-encode), which is both the fastest and an unaltered "evidence" copy.
-  // Telemetry is always visible in the in-app clip-info dock for review;
-  // burning it into the file (which forces a composite re-encode) is opt-in via
-  // privacy mode, camera cuts, or a loaded layout preset.
+  // Keep telemetry engraving opt-in, but the default export itself stays the
+  // regular encoded grid video users expect from the app.
   @Published var exportOverlayOptions = ExportOverlayOptions(
     telemetryHUD: false,
     routeMap: false,
@@ -914,6 +912,26 @@ final class AppState: ObservableObject {
     )
   }
 
+  @discardableResult
+  func applyTrimStartInput(_ text: String) -> Bool {
+    guard let seconds = parseHMS(text) else { return false }
+    setTrimRange(
+      startSeconds: seconds,
+      endSeconds: trimEndSeconds
+    )
+    return true
+  }
+
+  @discardableResult
+  func applyTrimEndInput(_ text: String) -> Bool {
+    guard let seconds = parseHMS(text) else { return false }
+    setTrimRange(
+      startSeconds: trimStartSeconds,
+      endSeconds: seconds
+    )
+    return true
+  }
+
   func beginSeek() {
     guard !isUserSeeking else { return }
     wasPlayingBeforeSeek = playback.isPlaying
@@ -1101,29 +1119,37 @@ final class AppState: ObservableObject {
   }
 
   /// Whether the export will composite + re-encode (vs. lossless passthrough
-  /// mux). Driven entirely by what rendered content is requested — never a
-  /// manual codec choice.
+  /// mux).
   var exportWillReencode: Bool {
     effectiveExportPreset != .originalTracksMOV
   }
 
-  /// Read-only codec label for the dock indicator ("H.265" / "H.264").
+  /// Human-readable codec label for the active export mode.
   var exportCodecLabel: String {
-    dominantSourceCodec.displayName
+    switch effectiveExportPreset {
+    case .maxQualityH264:
+      return "H.264"
+    case .maxQualityHEVC, .fastHEVC, .socialShareHEVC, .proxyHEVC:
+      return "H.265"
+    case .editFriendlyProRes:
+      return "ProRes"
+    case .originalTracksMOV:
+      return dominantSourceCodec.displayName
+    }
   }
 
-  /// Caption beneath the export cluster, reflecting the automatic mode.
+  /// Caption beneath the export cluster.
   var exportModeCaption: String {
     exportWillReencode
-      ? "Re-encoded · \(exportCodecLabel) · hardware accelerated"
-      : "Muxed · originals preserved · no re-encode"
+      ? "Grid export · \(exportCodecLabel)"
+      : "Muxed · originals preserved"
   }
 
   var effectiveExportPreset: ExportPreset {
-    automaticExportPreset(
+    resolvedExportPreset(
+      requested: exportPreset,
       overlayOptions: effectiveExportOverlayOptions,
-      cameraTrack: cameraTrack,
-      sourceCodec: dominantSourceCodec
+      cameraTrack: cameraTrack
     )
   }
 
@@ -1424,28 +1450,20 @@ final class AppState: ObservableObject {
     )
   }
 
-  /// Fully-automatic export preset selection. No manual codec choice: the app
-  /// muxes losslessly whenever no rendered content is required (the fastest,
-  /// non-destructive path), and otherwise composites and re-encodes, adopting
-  /// the source codec (H.264 footage → H.264, HEVC footage → HEVC) so it never
-  /// needlessly transcodes across codecs.
-  private func automaticExportPreset(
+  private func resolvedExportPreset(
+    requested preset: ExportPreset,
     overlayOptions: ExportOverlayOptions,
-    cameraTrack: CameraTrack,
-    sourceCodec: VideoCodec
+    cameraTrack: CameraTrack
   ) -> ExportPreset {
-    let needsComposite = overlayOptions.telemetryHUD
+    guard preset == .originalTracksMOV else { return preset }
+    if overlayOptions.telemetryHUD
       || overlayOptions.routeMap
       || overlayOptions.privacyMask
       || overlayOptions.needsSidecars
-      || !cameraTrack.isEmpty
-    guard needsComposite else { return .originalTracksMOV }
-    switch sourceCodec {
-    case .h264:
-      return .maxQualityH264
-    case .hevc, .other:
+      || !cameraTrack.isEmpty {
       return .maxQualityHEVC
     }
+    return preset
   }
 
   private func exportRange(to chosenURL: URL, previewOnly: Bool, queued: Bool) {
@@ -1503,11 +1521,7 @@ final class AppState: ObservableObject {
     let sets = selectedSetsForExport
     let startDate = trimStartDate
     let overlayOptions = effectiveExportOverlayOptions
-    let preset = automaticExportPreset(
-      overlayOptions: overlayOptions,
-      cameraTrack: cameraTrack,
-      sourceCodec: dominantSourceCodec
-    )
+    let preset = effectiveExportPreset
     let endDate: Date
     let endSeconds: Double
     let rangeText: String
@@ -1539,6 +1553,19 @@ final class AppState: ObservableObject {
     )
   }
 
+  func setExportPreset(_ preset: ExportPreset) {
+    exportPreset = preset
+    switch preset {
+    case .originalTracksMOV:
+      exportOverlayOptions.telemetryHUD = false
+      exportOverlayOptions.routeMap = false
+      exportOverlayOptions.includeReport = false
+      exportOverlayOptions.includeScreenshot = false
+    case .maxQualityHEVC, .maxQualityH264, .fastHEVC, .socialShareHEVC, .proxyHEVC, .editFriendlyProRes:
+      break
+    }
+  }
+
   private func buildHealthSummary(from sets: [ClipSet]) -> ExportHealthSummary {
     TelemetryProcessor.buildHealthSummary(from: sets, layoutProfile: layoutProfile)
   }

TeslaCam/ContentView.swift

@@ -781,6 +781,10 @@ private struct TimelineExportCard: View {
   @ObservedObject var playbackUI: PlaybackUIState
   let timelineMarkers: [Date]
   let isSingleDayTimeline: Bool
+  @State private var trimStartInput = ""
+  @State private var trimEndInput = ""
+  @FocusState private var focusedTrimField: TrimField?
+  @State private var lastFocusedTrimField: TrimField?
 
   var body: some View {
     let minDate = state.minDate ?? Date()
@@ -793,6 +797,25 @@ private struct TimelineExportCard: View {
     }
     .padding(TeslaCamTheme.Metrics.cardPaddingCompact)
     .teslaCamCard()
+    .onAppear(perform: syncTrimInputs)
+    .onChange(of: state.trimStartSeconds) {
+      guard focusedTrimField != .start else { return }
+      trimStartInput = formatHMS(state.trimStartSeconds)
+    }
+    .onChange(of: state.trimEndSeconds) {
+      guard focusedTrimField != .end else { return }
+      trimEndInput = formatHMS(state.trimEndSeconds)
+    }
+    .onChange(of: focusedTrimField) {
+      let newValue = focusedTrimField
+      if lastFocusedTrimField == .start, newValue != .start {
+        commitTrimStartInput()
+      }
+      if lastFocusedTrimField == .end, newValue != .end {
+        commitTrimEndInput()
+      }
+      lastFocusedTrimField = newValue
+    }
   }
 
   private var timelineDock: some View {
@@ -945,9 +968,8 @@ private struct TimelineExportCard: View {
       .frame(height: TeslaCamTheme.Metrics.compactControlHeight)
 
       HStack(spacing: TeslaCamTheme.Spacing.s) {
-        // Opt-in engraving. Default off keeps the fast, lossless muxed copy;
-        // turning it on burns the telemetry HUD into the file, which forces a
-        // composite re-encode (the caption to the right reflects the switch).
+        // Telemetry burn-in remains optional. The base export stays a regular
+        // encoded grid unless the user explicitly asks for original tracks.
         Toggle(isOn: $state.exportOverlayOptions.telemetryHUD) {
           Text("Engrave telemetry")
             .font(TeslaCamTheme.Typography.label)
@@ -957,7 +979,7 @@ private struct TimelineExportCard: View {
         .tint(TeslaCamTheme.Colors.accent)
         .fixedSize()
         .accessibilityIdentifier("engrave-telemetry-toggle")
-        .accessibilityHint("Burns the telemetry HUD into the exported video. Off keeps a lossless, faster muxed copy.")
+        .accessibilityHint("Burns the telemetry HUD into the exported video.")
 
         Spacer(minLength: 0)
 
@@ -990,17 +1012,17 @@ private struct TimelineExportCard: View {
 
   private func controlTopRow(timeWidth: CGFloat, exportWidth: CGFloat) -> some View {
     HStack(spacing: TeslaCamTheme.Spacing.s) {
-      macTimeField(formatHMS(playbackUI.currentSeconds), alignment: .leading, width: timeWidth)
+      trimInputField("In", text: $trimStartInput, field: .start, width: timeWidth)
 
       transportButtonCluster
 
-      macTimeField(formatHMS(state.totalDuration), alignment: .trailing, width: timeWidth)
+      trimInputField("Out", text: $trimEndInput, field: .end, width: timeWidth)
 
       inOutCluster
 
       Spacer(minLength: 0)
 
-      codecField
+      codecPickerField
 
       Button {
         state.exportRange()
@@ -1015,35 +1037,71 @@ private struct TimelineExportCard: View {
     }
   }
 
-  private func macTimeField(_ value: String, alignment: Alignment, width: CGFloat = 118) -> some View {
+  private func trimInputField(_ title: String, text: Binding<String>, field: TrimField, width: CGFloat = 118) -> some View {
     HStack(spacing: TeslaCamTheme.Spacing.tightGap) {
-      Image(systemName: "timer")
+      Text(title.uppercased())
         .font(TeslaCamTheme.Typography.label)
-      Text(value)
+        .foregroundStyle(TeslaCamTheme.Colors.textTertiary)
+      TextField(title, text: text)
+        .textFieldStyle(.plain)
         .font(TeslaCamTheme.Typography.monoDetail)
+        .foregroundStyle(TeslaCamTheme.Colors.textSecondary)
+        .multilineTextAlignment(.leading)
+        .focused($focusedTrimField, equals: field)
+        .onSubmit {
+          switch field {
+          case .start:
+            commitTrimStartInput()
+          case .end:
+            commitTrimEndInput()
+          }
+        }
         .lineLimit(1)
         .minimumScaleFactor(0.72)
     }
-    .foregroundStyle(TeslaCamTheme.Colors.textSecondary)
     .padding(.horizontal, TeslaCamTheme.Spacing.s)
-    .frame(width: width, height: TeslaCamTheme.Metrics.compactControlHeight, alignment: alignment)
+    .frame(width: width, height: TeslaCamTheme.Metrics.compactControlHeight, alignment: .leading)
     .teslaCamCard(fill: TeslaCamTheme.Colors.surface, radius: TeslaCamTheme.Metrics.controlCorner)
   }
 
-  // Read-only codec indicator. The export codec is fully automatic — adopted
-  // from the source footage (H.264 vs H.265) — so this is informational, not a
-  // menu. A fixed-width segment, so it can never overflow into the timeline the
-  // way the old PRESET dropdown did.
-  private var codecField: some View {
+  private var codecPickerField: some View {
     HStack(spacing: TeslaCamTheme.Spacing.tightGap) {
       Text("Codec".uppercased())
         .font(TeslaCamTheme.Typography.label)
         .foregroundStyle(TeslaCamTheme.Colors.textTertiary)
 
-      CodecSegmentIndicator(activeCodec: state.dominantSourceCodec)
+      Picker("", selection: exportPresetBinding) {
+        Text("H.265").tag(ExportPreset.maxQualityHEVC)
+        Text("H.264").tag(ExportPreset.maxQualityH264)
+      }
+      .labelsHidden()
+      .pickerStyle(.segmented)
+      .frame(width: 132)
     }
   }
 
+  private var exportPresetBinding: Binding<ExportPreset> {
+    Binding(
+      get: { state.exportPreset == .maxQualityH264 ? .maxQualityH264 : .maxQualityHEVC },
+      set: { state.setExportPreset($0) }
+    )
+  }
+
+  private func syncTrimInputs() {
+    trimStartInput = formatHMS(state.trimStartSeconds)
+    trimEndInput = formatHMS(state.trimEndSeconds)
+  }
+
+  private func commitTrimStartInput() {
+    _ = state.applyTrimStartInput(trimStartInput)
+    trimStartInput = formatHMS(state.trimStartSeconds)
+  }
+
+  private func commitTrimEndInput() {
+    _ = state.applyTrimEndInput(trimEndInput)
+    trimEndInput = formatHMS(state.trimEndSeconds)
+  }
+
   private var playbackSecondsBinding: Binding<Double> {
     Binding(
       get: { playbackUI.currentSeconds },
@@ -1100,6 +1158,11 @@ private struct TimelineExportCard: View {
 
     return parts.joined(separator: " • ")
   }
+
+  private enum TrimField: Hashable {
+    case start
+    case end
+  }
 }
 
 private struct ClipInformationPanel: View {

TeslaCam/Utils.swift

@@ -46,6 +46,28 @@ func formatHMS(_ seconds: Double) -> String {
   return String(format: "%02d:%02d:%02d", h, m, s)
 }
 
+func parseHMS(_ text: String) -> Double? {
+  let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+  guard !trimmed.isEmpty else { return nil }
+
+  let rawParts = trimmed.split(separator: ":", omittingEmptySubsequences: false)
+  guard (1...3).contains(rawParts.count) else { return nil }
+
+  let parts = rawParts.compactMap { Int($0) }
+  guard parts.count == rawParts.count, parts.allSatisfy({ $0 >= 0 }) else { return nil }
+
+  switch parts.count {
+  case 1:
+    return Double(parts[0])
+  case 2:
+    return Double(parts[0] * 60 + parts[1])
+  case 3:
+    return Double(parts[0] * 3600 + parts[1] * 60 + parts[2])
+  default:
+    return nil
+  }
+}
+
 func floorToMinute(_ date: Date) -> Date {
   let calendar = Calendar.current
   let comps = calendar.dateComponents([.year, .month, .day, .hour, .minute], from: date)