From 42e07453c55179ea2d66c58b3fc082ed2778d221 Mon Sep 17 00:00:00 2001
From: tstoltz <tristan.stoltz@evolvingresonantcocreationism.com>
Date: Sun, 19 Apr 2026 12:26:39 +0200
Subject: [PATCH] fix(linux): use two-level Frame::Video(VideoFrame::...) enum
 + SystemTime display_time
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Frame enum was refactored into a two-level shape (Frame::Audio /
Frame::Video(VideoFrame::*)) and the per-format structs' display_time
field was changed from u64 to SystemTime, but the Linux PipeWire engine
in src/capturer/engine/linux/mod.rs was not updated to match. Result:
8 compile errors on Linux, no crates.io release compiles there.

This commit:

- Wraps the four emit sites (RGBx / RGB / xBGR / BGRx) in
  Frame::Video(VideoFrame::...(...)) to match frame::Frame's current
  two-level shape.
- Replaces `display_time: timestamp as u64` with
  `display_time: SystemTime::now()`, matching what the macOS and
  Windows engines already do.  The raw PipeWire pts from
  spa_meta_header is monotonic ns since an arbitrary reference, not
  wall-clock, so it cannot be converted losslessly to SystemTime.
  Relative frame ordering survives via channel-send order.
- Adds SystemTime to the std::time imports and VideoFrame to the
  crate::frame imports.

`cargo check` on Linux (Ubuntu 24, pipewire 1.0, via nix develop)
now succeeds — 16 warnings remaining, all pre-existing lifetime-
elision nits unrelated to this fix.
---
 src/capturer/engine/linux/mod.rs | 37 ++++++++++++++++++++------------
 1 file changed, 23 insertions(+), 14 deletions(-)

diff --git a/src/capturer/engine/linux/mod.rs b/src/capturer/engine/linux/mod.rs
index 07967fb..471458a 100644
--- a/src/capturer/engine/linux/mod.rs
+++ b/src/capturer/engine/linux/mod.rs
@@ -5,7 +5,7 @@ use std::{
         mpsc::{self, sync_channel, SyncSender},
     },
     thread::JoinHandle,
-    time::Duration,
+    time::{Duration, SystemTime},
 };
 
 use pipewire as pw;
@@ -31,7 +31,7 @@ use pw::{
 
 use crate::{
     capturer::Options,
-    frame::{BGRxFrame, Frame, RGBFrame, RGBxFrame, XBGRFrame},
+    frame::{BGRxFrame, Frame, RGBFrame, RGBxFrame, VideoFrame, XBGRFrame},
 };
 
 use self::{error::LinCapError, portal::ScreenCastPortal};
@@ -133,31 +133,40 @@ fn process_callback(stream: &StreamRef, user_data: &mut ListenerUserData) {
                 .to_vec()
             };
 
+            // `timestamp` (from spa_meta_header.pts) is a PipeWire monotonic
+            // nanosecond count since an arbitrary reference — not wall-clock.
+            // display_time's SystemTime contract is wall-clock, so we use
+            // SystemTime::now() here (matches what the macOS and Windows
+            // engines do today).  Relative frame ordering survives via
+            // channel-send order; sub-millisecond buffer timing is lost.
+            let _ = timestamp; // suppress "unused" warning until we wire pts elsewhere
+            let display_time = SystemTime::now();
+
             if let Err(e) = match user_data.format.format() {
-                VideoFormat::RGBx => user_data.tx.send(Frame::RGBx(RGBxFrame {
-                    display_time: timestamp as u64,
+                VideoFormat::RGBx => user_data.tx.send(Frame::Video(VideoFrame::RGBx(RGBxFrame {
+                    display_time,
                     width: frame_size.width as i32,
                     height: frame_size.height as i32,
                     data: frame_data,
-                })),
-                VideoFormat::RGB => user_data.tx.send(Frame::RGB(RGBFrame {
-                    display_time: timestamp as u64,
+                }))),
+                VideoFormat::RGB => user_data.tx.send(Frame::Video(VideoFrame::RGB(RGBFrame {
+                    display_time,
                     width: frame_size.width as i32,
                     height: frame_size.height as i32,
                     data: frame_data,
-                })),
-                VideoFormat::xBGR => user_data.tx.send(Frame::XBGR(XBGRFrame {
-                    display_time: timestamp as u64,
+                }))),
+                VideoFormat::xBGR => user_data.tx.send(Frame::Video(VideoFrame::XBGR(XBGRFrame {
+                    display_time,
                     width: frame_size.width as i32,
                     height: frame_size.height as i32,
                     data: frame_data,
-                })),
-                VideoFormat::BGRx => user_data.tx.send(Frame::BGRx(BGRxFrame {
-                    display_time: timestamp as u64,
+                }))),
+                VideoFormat::BGRx => user_data.tx.send(Frame::Video(VideoFrame::BGRx(BGRxFrame {
+                    display_time,
                     width: frame_size.width as i32,
                     height: frame_size.height as i32,
                     data: frame_data,
-                })),
+                }))),
                 _ => panic!("Unsupported frame format received"),
             } {
                 eprintln!("{e}");