Show detected output format & mono option

Add UI and backend support for reporting the camera backend's detected output format and pixel format. Introduce a detected output label with tooltip and move/rename the "preserve mono" checkbox into an Output row. Store/clear detected_output_format and detected_pixel_format in camera props, read actual_output_format from backends during probing, and set detected_output_format when pixel format indicates Mono. Add a mono indicator to camera list entries and update probe early-return logic to require both resolution and output format before skipping probing.

Author: C-Achard

dlclivegui/gui/camera_config/camera_config_dialog.py

@@ -424,6 +424,8 @@ def _set_detected_labels(self, cam: CameraSettings) -> None:
 
         det_res = ns.get("detected_resolution")
         det_fps = ns.get("detected_fps")
+        det_output_format = ns.get("detected_output_format")
+        det_pixel_format = ns.get("detected_pixel_format")
 
         if isinstance(det_res, (list, tuple)) and len(det_res) == 2:
             try:
@@ -439,6 +441,18 @@ def _set_detected_labels(self, cam: CameraSettings) -> None:
         else:
             self.detected_fps_label.setText("—")
 
+        self.detected_output_format_label.setText(str(det_output_format) if det_output_format else "—")
+
+        tooltip_parts = []
+        if det_output_format:
+            tooltip_parts.append(f"Backend output: {det_output_format}")
+        if det_pixel_format:
+            tooltip_parts.append(f"Camera PixelFormat: {det_pixel_format}")
+
+        self.detected_output_format_label.setToolTip(
+            "\n".join(tooltip_parts) if tooltip_parts else "Backend-reported output frame format emitted to the app."
+        )
+
     def _refresh_camera_labels(self) -> None:
         cam_list = getattr(self, "active_cameras_list", None)
         if not cam_list:
@@ -467,11 +481,12 @@ def _format_camera_label(self, cam: CameraSettings, index: int = -1) -> str:
         status = "✓" if cam.enabled else "○"
         this_id = f"{(cam.backend or '').lower()}:{cam.index}"
         dlc_indicator = " [DLC]" if this_id == self._dlc_camera_id and cam.enabled else ""
+        mono_indicator = " [Mono]" if getattr(cam, "preserve_mono", False) else ""
 
         trigger_role = self._trigger_role_for_label(cam)
         trigger_indicator = "" if trigger_role in {"off", "disabled"} else f" [{trigger_role}]"
 
-        return f"{status} {cam.name} [{cam.backend}:{cam.index}]{trigger_indicator}{dlc_indicator}"
+        return f"{status} {cam.name} [{cam.backend}:{cam.index}]{trigger_indicator}{dlc_indicator}{mono_indicator}"
 
     def _selected_detected_camera(self) -> DetectedCamera | None:
         row = self.available_cameras_list.currentRow()
@@ -1194,6 +1209,8 @@ def _clear_settings_form(self) -> None:
         self.cam_backend_label.setText("")
         self.detected_resolution_label.setText("—")
         self.detected_fps_label.setText("—")
+        self.detected_output_format_label.setText("—")
+        self.detected_output_format_label.setToolTip("Backend-reported output frame format emitted to the app.")
         self.cam_width.setValue(0)
         self.cam_height.setValue(0)
         self.cam_fps.setValue(0.0)
@@ -1301,6 +1318,8 @@ def _reset_selected_camera(self, *, clear_backend_cache: bool = False) -> None:
                 else:
                     ns.pop("detected_resolution", None)
                     ns.pop("detected_fps", None)
+                    ns.pop("detected_pixel_format", None)
+                    ns.pop("detected_output_format", None)
                     ns.pop("last_applied_resolution", None)
 
         # Update UI immediately to show "Auto" while probing
@@ -1372,12 +1391,16 @@ def _start_probe_for_camera(self, cam: CameraSettings, *, apply_to_requested: bo
         ns = props.get(backend, {}) if isinstance(props.get(backend, None), dict) else {}
         if not apply_to_requested:
             det_res = ns.get("detected_resolution")
+            det_output = ns.get("detected_output_format")
+            has_res = False
             if isinstance(det_res, (list, tuple)) and len(det_res) == 2:
                 try:
-                    if int(det_res[0]) > 0 and int(det_res[1]) > 0:
-                        return
+                    has_res = int(det_res[0]) > 0 and int(det_res[1]) > 0
                 except Exception:
-                    pass
+                    has_res = False
+
+            if has_res and det_output:
+                return
 
         # Start probe worker (settings will be opened in GUI thread for safety)
         self._probe_worker = CameraProbeWorker(cam, self)
@@ -1404,6 +1427,7 @@ def _on_probe_success(self, payload) -> None:
             actual_res = getattr(be, "actual_resolution", None)
             actual_fps = getattr(be, "actual_fps", None)
             actual_pixel_format = getattr(be, "actual_pixel_format", None)
+            actual_output_format = getattr(be, "actual_output_format", None)
             recommended_preserve_mono = getattr(be, "recommended_preserve_mono", None)
 
             try:
@@ -1427,8 +1451,6 @@ def _on_probe_success(self, payload) -> None:
                     # Store regardless of "set_*" support. This is just "what device reports".
                     if actual_res and isinstance(actual_res, (list, tuple)) and len(actual_res) == 2:
                         ns["detected_resolution"] = [int(actual_res[0]), int(actual_res[1])]
-                    elif actual_res and isinstance(actual_res, tuple) and len(actual_res) == 2:
-                        ns["detected_resolution"] = [int(actual_res[0]), int(actual_res[1])]
 
                     if isinstance(actual_fps, (int, float)) and float(actual_fps) > 0:
                         ns["detected_fps"] = float(actual_fps)
@@ -1437,6 +1459,10 @@ def _on_probe_success(self, payload) -> None:
                         ns["detected_pixel_format"] = str(actual_pixel_format)
                         self._append_status(f"[Probe] PixelFormat={actual_pixel_format}")
 
+                    if actual_output_format:
+                        ns["detected_output_format"] = str(actual_output_format)
+                        self._append_status(f"[Probe] OutputFormat={actual_output_format}")
+
                     if recommended_preserve_mono is not None:
                         ns["recommended_preserve_mono"] = bool(recommended_preserve_mono)
 
@@ -1450,6 +1476,9 @@ def _on_probe_success(self, payload) -> None:
                             c.preserve_mono = True
                             self._append_status("[Probe] Mono pixel format detected; enabled Preserve mono frames.")
 
+                            if actual_pixel_format and str(actual_pixel_format).startswith("Mono"):
+                                ns["detected_output_format"] = "Mono8"
+
                     # ---- Apply detected -> requested (Reset behavior) ----
                     if self._probe_apply_to_requested and self._probe_target_row == i:
                         # Only apply resolution if we actually got it

dlclivegui/gui/camera_config/ui_blocks.py

@@ -277,13 +277,6 @@ def build_settings_group(dlg: CameraConfigDialog) -> QGroupBox:
     dlg.settings_form.addRow(detected_row)
 
     # --- Requested resolution/output format controls (Auto = 0) ---
-    dlg.cam_preserve_mono_checkbox = QCheckBox("Preserve Mono output")
-    dlg.cam_preserve_mono_checkbox.setToolTip(
-        "For monochrome cameras, keep frames as single-channel Mono8 instead of converting to BGR. "
-        "This reduces memory bandwidth and recording overhead. Display/overlay/DLC may convert later if needed."
-    )
-    dlg.settings_form.addRow(dlg.cam_preserve_mono_checkbox)
-
     dlg.cam_width = QSpinBox()
     dlg.cam_width.setRange(0, 10000)
     dlg.cam_width.setValue(0)
@@ -297,6 +290,30 @@ def build_settings_group(dlg: CameraConfigDialog) -> QGroupBox:
     res_row = make_two_field_row("W", dlg.cam_width, "H", dlg.cam_height, key_width=30)
     dlg.settings_form.addRow("Resolution:", res_row)
 
+    # --- Output format controls ---
+    dlg.cam_preserve_mono_checkbox = QCheckBox("Preserve mono output")
+    dlg.cam_preserve_mono_checkbox.setToolTip(
+        "For monochrome cameras, keep frames as single-channel Mono8 instead of converting to BGR. "
+        "This reduces memory bandwidth and recording overhead. Display/overlay/DLC may convert later if needed."
+    )
+
+    dlg.detected_output_format_label = QLabel("—")
+    dlg.detected_output_format_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
+    dlg.detected_output_format_label.setToolTip(
+        "Backend-reported output frame format emitted to the app, for example Mono8 or BGR8."
+    )
+
+    output_widget = QWidget()
+    output_layout = QHBoxLayout(output_widget)
+    output_layout.setContentsMargins(0, 0, 0, 0)
+    output_layout.setSpacing(8)
+    output_layout.addWidget(dlg.cam_preserve_mono_checkbox)
+    output_layout.addStretch(1)
+    output_layout.addWidget(QLabel("Detected output:"))
+    output_layout.addWidget(dlg.detected_output_format_label)
+
+    dlg.settings_form.addRow("Output:", output_widget)
+
     # --- FPS + Rotation grouped ---
     dlg.cam_fps = QDoubleSpinBox()
     dlg.cam_fps.setRange(0.0, 240.0)