@desklink/host 0.3.0 → 0.3.1

package/engine/native/agent_overlay_wayland.c

@@ -17,6 +17,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <fontconfig/fontconfig.h>
+#include <ft2build.h>
+#include FT_FREETYPE_H
 
 // Layer-shell v1 protocol (Drew DeVault, 2017; MIT license).
 static const struct wl_interface layer_surface_interface;
@@ -35,6 +38,38 @@ static const struct wl_message surface_requests[] = {
 static const struct wl_message surface_events[] = { {"configure", "uuu", NULL}, {"closed", "", NULL} };
 static const struct wl_interface layer_surface_interface = {"zwlr_layer_surface_v1", 1, 8, surface_requests, 2, surface_events};
 
+/* xdg-output wire signatures: Copyright (c) 2017 Red Hat Inc.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+// xdg-output v2 supplies compositor logical coordinates, including scaled outputs.
+static const struct wl_interface xdg_output_interface;
+static const struct wl_interface *xdg_types[]={&xdg_output_interface,&wl_output_interface};
+static const struct wl_message xdg_requests[]={{"destroy","",NULL},{"get_xdg_output","no",xdg_types}};
+static const struct wl_interface xdg_manager_interface={"zxdg_output_manager_v1",2,2,xdg_requests,0,NULL};
+static const struct wl_message output_requests[]={{"destroy","",NULL}};
+static const struct wl_message output_events[]={{"logical_position","ii",NULL},{"logical_size","ii",NULL},{"done","",NULL},{"name","2s",NULL},{"description","2s",NULL}};
+static const struct wl_interface xdg_output_interface={"zxdg_output_v1",2,1,output_requests,5,output_events};
+struct Output { struct wl_output *handle; struct wl_proxy *logical; int x,y,w,h,valid; };
+static void logical_position(void *data, struct wl_proxy *p,int32_t x,int32_t y){(void)p;struct Output *o=data;o->x=x;o->y=y;o->valid=1;}
+static void logical_size(void *data,struct wl_proxy *p,int32_t w,int32_t h){(void)p;struct Output *o=data;o->w=w;o->h=h;}
+static void logical_done(void *data,struct wl_proxy *p){(void)data;(void)p;}
+static void logical_string(void *data,struct wl_proxy *p,const char *s){(void)data;(void)p;(void)s;}
+static void (*logical_listener[])(void)={(void (*)(void))logical_position,(void (*)(void))logical_size,(void (*)(void))logical_done,(void (*)(void))logical_string,(void (*)(void))logical_string};
+
 int desklink_wayland_geometry(int source_w, int source_h, int surface_w, int surface_h,
                              double px, double py, double *x, double *y) {
     if (source_w<=0||source_h<=0||surface_w<=0||surface_h<=0) return 0;
@@ -50,7 +85,8 @@ struct Overlay {
     struct wl_display *display;
     struct wl_compositor *compositor;
     struct wl_shm *shm;
-    struct wl_proxy *shell, *layer;
+    struct wl_proxy *shell, *layer, *output_manager;
+    struct Output outputs[32]; int output_count;
     struct wl_surface *surface;
     struct Buffer buffers[2];
     int width, height, source_w, source_h, configured, closed;
@@ -58,6 +94,11 @@ struct Overlay {
 static double now(void) { struct timespec t; clock_gettime(CLOCK_MONOTONIC,&t); return t.tv_sec+t.tv_nsec/1e9; }
 static void registry_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
     struct Overlay *o=data;
+    if (!strcmp(interface,"wl_output") && o->output_count<32) {
+        struct Output *out=&o->outputs[o->output_count++];
+        out->handle=wl_registry_bind(registry,name,&wl_output_interface,1);
+    }
+    if (!strcmp(interface,"zxdg_output_manager_v1")) o->output_manager=wl_registry_bind(registry,name,&xdg_manager_interface,version<2?version:2);
     if (!strcmp(interface,"wl_compositor")) o->compositor=wl_registry_bind(registry,name,&wl_compositor_interface,version<4?version:4);
     if (!strcmp(interface,"wl_shm")) o->shm=wl_registry_bind(registry,name,&wl_shm_interface,1);
     if (!strcmp(interface,"zwlr_layer_shell_v1")) o->shell=wl_registry_bind(registry,name,&shell_interface,1);
@@ -65,7 +106,11 @@ static void registry_global(void *data, struct wl_registry *registry, uint32_t n
 static void registry_remove(void *data, struct wl_registry *registry, uint32_t name) { (void)data;(void)registry;(void)name; }
 static const struct wl_registry_listener registry_listener={registry_global,registry_remove};
 static void configured(void *data, struct wl_proxy *layer, uint32_t serial, uint32_t w, uint32_t h) {
-    struct Overlay *o=data; o->width=(int)w; o->height=(int)h; o->configured=1;
+    struct Overlay *o=data;
+    // A source/layout change invalidates this helper; never write new dimensions
+    // into buffers allocated for the old output size.
+    if(o->configured && (o->width!=(int)w || o->height!=(int)h))o->closed=1;
+    o->width=(int)w; o->height=(int)h; o->configured=1;
     wl_proxy_marshal_flags(layer,6,NULL,1,0,serial);
 }
 static void closed(void *data, struct wl_proxy *layer) { (void)layer; ((struct Overlay *)data)->closed=1; }
@@ -117,16 +162,76 @@ static void draw(struct Overlay *o, struct Buffer *b, double x, double y, double
     }
 }
 
-int desklink_agent_overlay_wayland(int source_w, int source_h) {
+static FT_Face point_font(FT_Library *library) {
+    if(FT_Init_FreeType(library))return NULL;
+    FcPattern *pattern=FcNameParse((const FcChar8 *)"monospace");
+    if(!pattern)return NULL;
+    FcConfigSubstitute(NULL,pattern,FcMatchPattern);FcDefaultSubstitute(pattern);
+    FcResult result;FcPattern *match=FcFontMatch(NULL,pattern,&result);FcPatternDestroy(pattern);
+    FcChar8 *path=NULL;FT_Face face=NULL;
+    if(match && FcPatternGetString(match,FC_FILE,0,&path)==FcResultMatch)
+        if(!FT_New_Face(*library,(const char *)path,0,&face))FT_Set_Pixel_Sizes(face,0,13);
+    if(match)FcPatternDestroy(match);
+    return face;
+}
+static void draw_point(struct Overlay *o,struct Buffer *b,double x,double y,const char *label,FT_Face font,int visible) {
+    memset(b->pixels,0,b->length);if(!visible)return;
+    int w=o->width,h=o->height;
+    for(int py=fmax(0,y-21);py<fmin(h,y+22);py++)for(int px=fmax(0,x-21);px<fmin(w,x+22);px++) {
+        double d=hypot(px-x,py-y);
+        if(fabs(d-18)<=2 || d<=3)b->pixels[(size_t)py*w+px]=0xff4c9ed0;
+    }
+    if(!*label)return;
+    int badge_w=16;
+    for(const char *p=label;*p;p++)if(!FT_Load_Char(font,(unsigned char)*p,FT_LOAD_DEFAULT))badge_w+=font->glyph->advance.x>>6;
+    badge_w=fmin(w,badge_w);int bx=fmax(0,fmin(x+30,w-badge_w)),by=fmax(0,fmin(y-14,h-28));
+    for(int py=by;py<fmin(h,by+28);py++)for(int px=bx;px<bx+badge_w;px++)b->pixels[(size_t)py*w+px]=0xff123047;
+    int pen=bx+8;
+    for(const char *p=label;*p;p++)if(!FT_Load_Char(font,(unsigned char)*p,FT_LOAD_RENDER)) {
+        FT_GlyphSlot g=font->glyph;
+        for(unsigned row=0;row<g->bitmap.rows;row++)for(unsigned col=0;col<g->bitmap.width;col++) {
+            int px=pen+g->bitmap_left+col,py=by+18-g->bitmap_top+row;
+            if(px<0||px>=w||py<0||py>=h)continue;
+            unsigned a=g->bitmap.buffer[row*g->bitmap.pitch+col];
+            unsigned r=(18*(255-a)+255*a)/255,green=(48*(255-a)+255*a)/255,blue=(71*(255-a)+255*a)/255;
+            b->pixels[(size_t)py*w+px]=0xff000000|(r<<16)|(green<<8)|blue;
+        }
+        pen+=g->advance.x>>6;
+    }
+}
+
+static int overlay_main(int source_w,int source_h,int point_mode,int origin_known,int origin_x,int origin_y) {
+
     struct Overlay o={.source_w=source_w,.source_h=source_h};
     o.display=wl_display_connect(NULL);
     if(!o.display)return 2;
     struct wl_registry *registry=wl_display_get_registry(o.display);
     wl_registry_add_listener(registry,&registry_listener,&o);
     wl_display_roundtrip(o.display);
-    if(!o.compositor||!o.shm||!o.shell){wl_display_disconnect(o.display);return 2;}
+    if(!o.shell){puts("layer_shell_unavailable");fflush(stdout);wl_display_disconnect(o.display);return 2;}
+    if(!o.compositor||!o.shm){wl_display_disconnect(o.display);return 2;}
+    struct wl_output *selected=NULL;int matches=0;
+    if(point_mode) {
+        if(o.output_manager) {
+            for(int i=0;i<o.output_count;i++) {
+                struct Output *out=&o.outputs[i];
+                out->logical=wl_proxy_marshal_flags(o.output_manager,1,&xdg_output_interface,wl_proxy_get_version(o.output_manager),0,NULL,out->handle);
+                wl_proxy_add_listener(out->logical,logical_listener,out);
+            }
+            if(wl_display_roundtrip(o.display)<0)return 2;
+        }
+        for(int i=0;i<o.output_count;i++) {
+            struct Output *out=&o.outputs[i];
+            if(origin_known && out->valid && origin_x>=out->x && origin_y>=out->y && origin_x<out->x+out->w && origin_y<out->y+out->h){selected=out->handle;matches++;}
+        }
+        if(matches>1)selected=NULL;
+        if(!selected && o.output_count==1 && (!origin_known || !o.output_manager))selected=o.outputs[0].handle;
+        if(!selected){puts("selected_output_unavailable");fflush(stdout);wl_display_disconnect(o.display);return 2;}
+    }
+    FT_Library library=NULL;FT_Face font=point_mode?point_font(&library):NULL;
+    if(point_mode&&!font){wl_display_disconnect(o.display);return 2;}
     o.surface=wl_compositor_create_surface(o.compositor);
-    o.layer=wl_proxy_marshal_flags(o.shell,0,&layer_surface_interface,1,0,NULL,o.surface,NULL,3,"desklink-agent");
+    o.layer=wl_proxy_marshal_flags(o.shell,0,&layer_surface_interface,1,0,NULL,o.surface,selected,3,point_mode?"desklink-point":"desklink-agent");
     wl_proxy_add_listener(o.layer,layer_listener,&o);
     uint32_t anchor,keyboard_focus,empty_input;
     desklink_wayland_policy(&anchor,&keyboard_focus,&empty_input);
@@ -147,7 +252,8 @@ int desklink_agent_overlay_wayland(int source_w, int source_h) {
     puts("READY");fflush(stdout);
     double tx=0,ty=0,x=0,y=0,click=0,typed=0,ending=0;
     int active=0,positioned=0;
-    char pending[128];size_t used=0;
+    double deadline=0;char label[97]={0};int dirty=0,visible=0;
+    char pending[512];size_t used=0;
     while(!o.closed && (!ending||now()-ending<0.6)) {
         struct pollfd fds[2]={{wl_display_get_fd(o.display),POLLIN,0},{STDIN_FILENO,POLLIN|POLLHUP,0}};
         wl_display_flush(o.display);
@@ -155,28 +261,39 @@ int desklink_agent_overlay_wayland(int source_w, int source_h) {
         if(fds[0].revents&POLLIN && wl_display_dispatch(o.display)<0)break;
         else wl_display_dispatch_pending(o.display);
         char bytes[128];ssize_t n=read(STDIN_FILENO,bytes,sizeof(bytes));
-        if(n==0&&!ending)ending=now();
+        if(n==0){if(point_mode)break;if(!ending)ending=now();}
         for(ssize_t i=0;i<n;i++) {
             if(bytes[i]=='\n') {
                 pending[used]=0;char kind=0;double px=0,py=0;
                 if(sscanf(pending,"%c %lf %lf",&kind,&px,&py)>=1) {
-                    if(kind=='S')ending=now();
+                    if(point_mode && kind=='P') {
+                        unsigned timeout=0;int offset=0;
+                        if(sscanf(pending,"P %lf %lf %u %n",&px,&py,&timeout,&offset)==3 && offset && timeout>=1 && timeout<=120000 && strlen(pending+offset)<=96) {
+                            desklink_wayland_geometry(o.source_w,o.source_h,o.width,o.height,px,py,&x,&y);
+                            snprintf(label,sizeof(label),"%s",pending+offset);deadline=now()+timeout/1000.0;active=1;dirty=1;visible=1;
+                        }
+                    }
+                    else if(kind=='S')ending=now();
                     else if(kind=='M'||kind=='C'||kind=='T'||kind=='A') {
                         if(px>=0&&py>=0) {
                             if(desklink_wayland_geometry(o.source_w,o.source_h,o.width,o.height,px,py,&tx,&ty)
                                 && !positioned){x=tx;y=ty;positioned=1;}
                         }
                         active=1;
-                        if(kind=='C')click=now();if(kind=='T')typed=now();
+                        if(kind=='C')click=now();
+                        if(kind=='T')typed=now();
                     }
                 }
                 used=0;
             }else if(used<sizeof(pending)-1)pending[used++]=bytes[i];
         }
-        if(!active)continue;
-        x+=(tx-x)*0.24;y+=(ty-y)*0.24;
+        if(point_mode && visible && now()>=deadline){visible=0;dirty=1;}
+        if(!active || (point_mode&&!dirty))continue;
+        if(!point_mode){x+=(tx-x)*0.24;y+=(ty-y)*0.24;}
         for(int i=0;i<2;i++)if(!o.buffers[i].busy) {
-            draw(&o,&o.buffers[i],x,y,click,typed,ending,positioned);
+            if(point_mode)draw_point(&o,&o.buffers[i],x,y,label,font,visible);
+            else draw(&o,&o.buffers[i],x,y,click,typed,ending,positioned);
+            dirty=0;
             o.buffers[i].busy=1;
             wl_surface_attach(o.surface,o.buffers[i].handle,0,0);
             wl_surface_damage_buffer(o.surface,0,0,o.width,o.height);
@@ -187,6 +304,22 @@ int desklink_agent_overlay_wayland(int source_w, int source_h) {
     wl_surface_attach(o.surface,NULL,0,0);wl_surface_commit(o.surface);wl_display_roundtrip(o.display);
     for(int i=0;i<2;i++){wl_buffer_destroy(o.buffers[i].handle);munmap(o.buffers[i].pixels,o.buffers[i].length);}
     wl_proxy_destroy(o.layer);wl_surface_destroy(o.surface);wl_proxy_destroy(o.shell);
+    if(font)FT_Done_Face(font);
+    if(library)FT_Done_FreeType(library);
     wl_display_disconnect(o.display);
     return 0;
 }
+
+int desklink_agent_overlay_wayland(int w,int h){return overlay_main(w,h,0,0,0,0);}
+int desklink_point_overlay_wayland(int w,int h,int known,int x,int y){return overlay_main(w,h,1,known,x,y);}
+
+// Read-only capability probe for idempotent clear before a helper exists.
+int desklink_wayland_layer_shell_available(void) {
+    struct Overlay o={0};o.display=wl_display_connect(NULL);
+    if(!o.display)return -1;
+    struct wl_registry *registry=wl_display_get_registry(o.display);
+    wl_registry_add_listener(registry,&registry_listener,&o);
+    int ok=wl_display_roundtrip(o.display)>=0;
+    int result=ok?(o.shell!=NULL):-1;
+    wl_display_disconnect(o.display);return result;
+}

package/engine/native/agent_overlay_x11.c

@@ -101,3 +101,75 @@ int desklink_agent_overlay_main(const char *display_name) {
     XcursorImageDestroy(image); XCloseDisplay(d);
     return 0;
 }
+
+// Point cues are independent of the real cursor. A shaped override-redirect
+// window works without a compositor; an empty input shape passes every event
+// through and mapping it never asks for keyboard focus. It intentionally appears
+// in GetImage(root), so the local person and the video observer share the cue.
+#include <X11/extensions/shape.h>
+#include <stdlib.h>
+
+int desklink_point_overlay_main(const char *display_name) {
+    Display *d = XOpenDisplay(display_name);
+    if (!d) return 2;
+    int event_base, error_base;
+    if (!XShapeQueryExtension(d, &event_base, &error_base)) { XCloseDisplay(d); return 2; }
+    int screen = DefaultScreen(d), width = DisplayWidth(d, screen), height = DisplayHeight(d, screen);
+    Window root = RootWindow(d, screen);
+    XSetWindowAttributes attrs = {0};
+    attrs.override_redirect = True;
+    attrs.background_pixel = 0x4c9ed0;
+    Window window = XCreateWindow(d, root, 0, 0, width, height, 0,
+        CopyFromParent, InputOutput, CopyFromParent, CWOverrideRedirect | CWBackPixel, &attrs);
+    XStoreName(d, window, "Desklink point");
+    XShapeCombineRectangles(d, window, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted);
+    Pixmap mask = XCreatePixmap(d, root, width, height, 1);
+    GC shape = XCreateGC(d, mask, 0, NULL), ink = XCreateGC(d, window, 0, NULL);
+    XFontStruct *font = XLoadQueryFont(d, "fixed");
+    if (font) XSetFont(d, ink, font->fid);
+    XSetLineAttributes(d, shape, 4, LineSolid, CapRound, JoinRound);
+    fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL) | O_NONBLOCK);
+    puts("READY"); fflush(stdout);
+    char pending[512]; size_t used = 0;
+    double deadline = 0;
+    for (;;) {
+        char bytes[512]; ssize_t n = read(STDIN_FILENO, bytes, sizeof(bytes));
+        if (n == 0) break;
+        for (ssize_t i = 0; i < n; i++) {
+            if (bytes[i] != '\n') { if (used < sizeof(pending)-1) pending[used++] = bytes[i]; continue; }
+            pending[used] = 0; used = 0;
+            double px, py; unsigned timeout; int offset = 0;
+            if (sscanf(pending, "P %lf %lf %u %n", &px, &py, &timeout, &offset) != 3 || !offset) continue;
+            const char *label = pending + offset;
+            int x = (int)px, y = (int)py, len = (int)strlen(label);
+            int badge_w = font ? XTextWidth(font, label, len) + 16 : len * 6 + 16;
+            if (badge_w > width) badge_w = width;
+            int badge_x = x + 30, badge_y = y - 14;
+            if (badge_x + badge_w > width) badge_x = width - badge_w;
+            if (badge_y < 0) badge_y = 0;
+            if (badge_y + 28 > height) badge_y = height - 28;
+            XUnmapWindow(d, window);
+            XSetForeground(d, shape, 0); XFillRectangle(d, mask, shape, 0, 0, width, height);
+            XSetForeground(d, shape, 1);
+            XDrawArc(d, mask, shape, x-18, y-18, 36, 36, 0, 360*64);
+            XFillArc(d, mask, shape, x-3, y-3, 6, 6, 0, 360*64);
+            if (len) XFillRectangle(d, mask, shape, badge_x, badge_y, badge_w, 28);
+            XShapeCombineMask(d, window, ShapeBounding, 0, 0, mask, ShapeSet);
+            XMapRaised(d, window);
+            XClearWindow(d, window);
+            if (len) {
+                XSetForeground(d, ink, 0x123047);
+                XFillRectangle(d, window, ink, badge_x, badge_y, badge_w, 28);
+                XSetForeground(d, ink, 0xffffff);
+                XDrawString(d, window, ink, badge_x+8, badge_y+18, label, len);
+            }
+            XSync(d, False);
+            deadline = now() + timeout/1000.0;
+        }
+        if (deadline && now() >= deadline) { XUnmapWindow(d, window); XFlush(d); deadline = 0; }
+        usleep(5000);
+    }
+    XDestroyWindow(d, window); XFreeGC(d, shape); XFreeGC(d, ink);
+    XFreePixmap(d, mask); if (font) XFreeFont(d, font); XCloseDisplay(d);
+    return 0;
+}

package/engine/src/capture.rs

@@ -13,7 +13,7 @@ use pw::spa;
 use pw::spa::pod::{serialize::PodSerializer, Pod};
 use std::io::Cursor;
 use std::os::fd::OwnedFd;
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{mpsc, Arc, Mutex};
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
@@ -55,6 +55,7 @@ pub struct Capture {
     quit: pw::channel::Sender<()>,
     thread: Option<JoinHandle<()>>,
     pub source: SelectedSource,
+    cursor_positions: Arc<AtomicBool>,
     geometry: Arc<Mutex<Option<StreamGeometry>>>,
     frames: Arc<AtomicU64>,
     dropped: Arc<AtomicU64>,
@@ -63,6 +64,9 @@ pub struct Capture {
 }
 
 impl Capture {
+    pub fn cursor_positions(&self) -> bool {
+        self.cursor_positions.load(Ordering::Relaxed)
+    }
     pub fn geometry(&self) -> Option<StreamGeometry> {
         self.geometry.lock().ok().and_then(|g| g.clone())
     }
@@ -193,16 +197,29 @@ fn buffer_pod(buffer: &mut Vec<u8>) -> Result<()> {
 }
 
 /// Start capturing `session`'s node, delivering I420 frames to `sink`.
+#[allow(clippy::too_many_arguments)]
 pub fn start(
     session: PortalSession,
     encoded_width: usize,
     encoded_height: usize,
     max_fps: u32,
+    cursor_sink: Option<crate::cursor::CursorSink>,
     sink: FrameSink,
     indicator_position: Option<Arc<Mutex<Option<(i64, i64)>>>>,
     on_stop: Box<dyn Fn(String) + Send>,
 ) -> Result<Capture> {
-    let PortalSession { fd, source, .. } = session;
+    let PortalSession {
+        fd,
+        source,
+        cursor_mode,
+        ..
+    } = session;
+    let cursor_positions = Arc::new(AtomicBool::new(false));
+    let cursor_sink = if cursor_mode == "metadata" {
+        cursor_sink
+    } else {
+        None
+    };
     let geometry = Arc::new(Mutex::new(None));
     let frames = Arc::new(AtomicU64::new(0));
     let dropped = Arc::new(AtomicU64::new(0));
@@ -210,7 +227,9 @@ pub fn start(
     let (ready_tx, ready_rx) = mpsc::channel::<Result<(), String>>();
 
     let node_id = source.node_id;
+    let source_size = (source.width.max(1) as usize, source.height.max(1) as usize);
     let thread = {
+        let cursor_positions = cursor_positions.clone();
         let geometry = geometry.clone();
         let frames = frames.clone();
         let dropped = dropped.clone();
@@ -221,9 +240,12 @@ pub fn start(
                 let result = run_loop(
                     fd,
                     node_id,
+                    source_size,
                     encoded_width,
                     encoded_height,
                     max_fps,
+                    cursor_sink,
+                    cursor_positions,
                     sink,
                     indicator_position,
                     on_stop,
@@ -250,6 +272,7 @@ pub fn start(
         quit,
         thread: Some(thread),
         source,
+        cursor_positions,
         geometry,
         frames,
         dropped,
@@ -268,9 +291,12 @@ pub fn start(
 fn run_loop(
     fd: OwnedFd,
     node_id: u32,
+    source_size: (usize, usize),
     encoded_width: usize,
     encoded_height: usize,
     max_fps: u32,
+    cursor_sink: Option<crate::cursor::CursorSink>,
+    cursor_positions: Arc<AtomicBool>,
     sink: FrameSink,
     indicator_position: Option<Arc<Mutex<Option<(i64, i64)>>>>,
     on_stop: Box<dyn Fn(String) + Send>,
@@ -302,6 +328,8 @@ fn run_loop(
     let stream = pw::stream::StreamBox::new(&core, "desklink-capture", props)
         .context("pw_stream_new failed")?;
 
+    let wants_cursor_meta = cursor_sink.is_some();
+    let mut cursor = cursor_sink.map(crate::cursor::Reporter::new);
     let mut state = StreamState {
         box_w: encoded_width,
         box_h: encoded_height,
@@ -367,6 +395,31 @@ fn run_loop(
             let Some(mut buffer) = stream.dequeue_buffer() else {
                 return;
             };
+            if let Some(cursor) = cursor.as_mut() {
+                if let Some(meta) = buffer.find_meta::<spa::buffer::meta::MetaCursor>() {
+                    cursor_positions.store(true, Ordering::Relaxed);
+                    // The wrapper's size check bounds the bitmap header;
+                    // never follow an unchecked bitmap offset.
+                    let bitmap = buffer
+                        .find_meta::<CursorWithBitmap>()
+                        .filter(|m| {
+                            m.cursor.bitmap_offset as usize
+                                == std::mem::size_of::<spa::sys::spa_meta_cursor>()
+                        })
+                        .map(|m| &m.bitmap);
+                    if state.logical_w == 0 || state.logical_h == 0 {
+                        return;
+                    }
+                    let mut position = *meta.as_raw();
+                    position.position.x = (i64::from(position.position.x) * source_size.0 as i64)
+                        .div_euclid(state.logical_w as i64)
+                        as i32;
+                    position.position.y = (i64::from(position.position.y) * source_size.1 as i64)
+                        .div_euclid(state.logical_h as i64)
+                        as i32;
+                    cursor.update_spa(&position, bitmap, source_size.0, source_size.1);
+                }
+            }
             let Some(format) = state.format else { return };
             let datas = buffer.datas_mut();
             if datas.is_empty() {
@@ -463,10 +516,15 @@ fn run_loop(
     format_pod(&mut format_buf, max_fps)?;
     let mut buffer_buf = Vec::new();
     buffer_pod(&mut buffer_buf)?;
-    let mut params = [
+    let mut cursor_buf = Vec::new();
+    cursor_pod(&mut cursor_buf)?;
+    let mut params = vec![
         Pod::from_bytes(&format_buf).context("invalid EnumFormat pod")?,
         Pod::from_bytes(&buffer_buf).context("invalid Buffers pod")?,
     ];
+    if wants_cursor_meta {
+        params.push(Pod::from_bytes(&cursor_buf).context("invalid Cursor Meta pod")?);
+    }
 
     stream
         .connect(
@@ -658,6 +716,7 @@ mod tests {
                 origin_x: 0,
                 origin_y: 0,
             },
+            cursor_positions: Arc::new(AtomicBool::new(false)),
             geometry: Arc::new(Mutex::new(None)),
             frames: Arc::new(AtomicU64::new(0)),
             dropped: Arc::new(AtomicU64::new(0)),
@@ -678,3 +737,33 @@ mod tests {
             .expect("capture stopped and joined");
     }
 }
+
+fn cursor_pod(buffer: &mut Vec<u8>) -> Result<()> {
+    use spa::pod::{object, property, Value};
+    let obj = object!(
+        spa::utils::SpaTypes::ObjectParamMeta,
+        spa::param::ParamType::Meta,
+        property!(
+            RawKey(spa::sys::SPA_PARAM_META_type),
+            Id,
+            RawKey(spa::sys::SPA_META_Cursor)
+        ),
+        property!(
+            RawKey(spa::sys::SPA_PARAM_META_size),
+            Int,
+            (std::mem::size_of::<CursorWithBitmap>() + 256 * 256 * 4) as i32
+        )
+    );
+    PodSerializer::serialize(Cursor::new(buffer), &Value::Object(obj))
+        .map(|_| ())
+        .map_err(|e| anyhow::anyhow!("failed to build Cursor Meta pod: {e}"))
+}
+
+#[repr(C)]
+struct CursorWithBitmap {
+    cursor: spa::sys::spa_meta_cursor,
+    bitmap: spa::sys::spa_meta_bitmap,
+}
+impl spa::buffer::meta::Metadata for CursorWithBitmap {
+    const META_TYPE: u32 = spa::sys::SPA_META_Cursor;
+}

package/engine/src/capture_win.rs

@@ -0,0 +1,23 @@
+//! Windows desktop capture is deferred; encoded sources never call this adapter.
+use crate::convert::I420;
+use crate::portal::PortalSession;
+use anyhow::{bail, Result};
+
+pub type FrameSink = Box<dyn Fn(I420, u64, Pixels) + Send + 'static>;
+pub type Pixels<'a> = &'a mut dyn FnMut() -> Option<Vec<u8>>;
+pub struct Capture;
+
+pub fn unavailable_reason() -> &'static str {
+    "Windows display capture is not implemented in this build."
+}
+
+pub fn start(
+    _session: PortalSession,
+    _width: usize,
+    _height: usize,
+    _fps: u32,
+    _sink: FrameSink,
+    _status: Box<dyn Fn(bool, String) + Send>,
+) -> Result<Capture> {
+    bail!("{}", unavailable_reason())
+}

package/engine/src/clipboard_win.rs

@@ -0,0 +1,8 @@
+//! Windows clipboard seam. This build never reads or writes the clipboard.
+pub const MAX_CLIPBOARD_BYTES: usize = 256 * 1024;
+pub fn read_or_explain() -> Result<(String, bool), String> {
+    Err("Windows clipboard transfer is not implemented in this build.".into())
+}
+pub fn write(_text: &str) -> anyhow::Result<()> {
+    anyhow::bail!("Windows clipboard transfer is not implemented in this build.")
+}

package/engine/src/cursor.rs

@@ -0,0 +1,118 @@
+//! Cursor metadata is independent of pixel damage and never painted into video.
+use crate::protocol::{timestamp_us, CursorPosition};
+use std::time::Instant;
+
+pub type CursorSink = Box<dyn Fn(CursorPosition) + Send + 'static>;
+
+pub struct Reporter {
+    sink: CursorSink,
+    last: Option<(i32, i32, bool)>,
+    bitmap_visible: bool,
+}
+impl Reporter {
+    pub fn new(sink: CursorSink) -> Self {
+        Self {
+            sink,
+            last: None,
+            bitmap_visible: true,
+        }
+    }
+    pub fn update_spa(
+        &mut self,
+        meta: &pipewire::spa::sys::spa_meta_cursor,
+        bitmap: Option<&pipewire::spa::sys::spa_meta_bitmap>,
+        width: usize,
+        height: usize,
+    ) {
+        // SPA id zero is no new data, not a visibility change.
+        if meta.id == 0 {
+            return;
+        }
+        if let Some(bitmap) = bitmap.filter(|b| b.format != 0) {
+            self.bitmap_visible = bitmap.offset != 0;
+        }
+        let (x, y) = (meta.position.x, meta.position.y);
+        self.update(
+            x,
+            y,
+            self.bitmap_visible
+                && x >= 0
+                && y >= 0
+                && (x as usize) < width
+                && (y as usize) < height,
+        );
+    }
+    pub fn update(&mut self, x: i32, y: i32, visible: bool) {
+        if self.last == Some((x, y, visible)) {
+            return;
+        }
+        self.last = Some((x, y, visible));
+        (self.sink)(CursorPosition {
+            x,
+            y,
+            visible,
+            timestamp_us: timestamp_us(Instant::now()),
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn spa_no_update_off_source_and_invisible_bitmap_are_distinct() {
+        use pipewire::spa::sys::{spa_meta_bitmap, spa_meta_cursor, spa_point, spa_rectangle};
+        let (tx, rx) = std::sync::mpsc::channel();
+        let mut reporter = Reporter::new(Box::new(move |p| {
+            tx.send(p).unwrap();
+        }));
+        let mut meta = spa_meta_cursor {
+            id: 1,
+            flags: 0,
+            position: spa_point { x: 40, y: 60 },
+            hotspot: spa_point { x: 2, y: 3 },
+            bitmap_offset: 0,
+        };
+        reporter.update_spa(&meta, None, 800, 600);
+        meta.id = 0;
+        reporter.update_spa(&meta, None, 800, 600);
+        assert_eq!(rx.try_iter().count(), 1);
+        meta.id = 1;
+        meta.position.x = -1;
+        reporter.update_spa(&meta, None, 800, 600);
+        assert!(!rx.try_recv().unwrap().visible);
+        meta.position.x = 40;
+        let bitmap = spa_meta_bitmap {
+            format: 1,
+            size: spa_rectangle {
+                width: 16,
+                height: 16,
+            },
+            stride: 64,
+            offset: 0,
+        };
+        reporter.update_spa(&meta, Some(&bitmap), 800, 600);
+        assert!(!rx.try_recv().unwrap().visible);
+        reporter.update_spa(&meta, None, 800, 600);
+        assert!(rx.try_recv().is_err(), "no new bitmap retains invisibility");
+    }
+
+    #[test]
+    fn reports_initial_motion_and_visibility_but_not_unchanged_polls() {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let mut reporter = Reporter::new(Box::new(move |p| {
+            tx.send(p).unwrap();
+        }));
+        reporter.update(10, 20, true);
+        reporter.update(10, 20, true);
+        reporter.update(30, 40, true);
+        reporter.update(30, 40, false);
+        let notices: Vec<_> = rx.try_iter().collect();
+        assert_eq!(notices.len(), 3);
+        assert_eq!((notices[1].x, notices[1].y), (30, 40));
+        assert!(!notices[2].visible);
+        assert!(notices
+            .windows(2)
+            .all(|p| p[0].timestamp_us <= p[1].timestamp_us));
+    }
+}