@desklink/host 0.2.0 → 0.3.1

package/engine/build.rs

@@ -1,8 +1,8 @@
 //! Native dependencies of the engine.
 //!
-//! The Linux build uses two permissive C libraries, both built or linked from
-//! this machine's own sources — no prebuilt binary is fetched, and nothing is
-//! installed:
+//! The Linux build compiles its native adapters from local sources and links
+//! system libraries for desktop overlays — no prebuilt binary is fetched at
+//! build time, and nothing is installed:
 //!
 //! * libvpx (BSD-3-Clause) — VP9 encode, through `native/vpx_shim.c` so the
 //!   versioned encoder config struct is laid out by a C compiler.
@@ -10,6 +10,12 @@
 //!   over `uinput`/`libevdev`, built by its own CMake project into a static
 //!   library and called through its documented C API.
 //!
+//! H.264 encoding adds no link-time dependency: NVENC and VA-API are loaded with
+//! `dlopen` from the machine's driver at run time, compiled against vendored
+//! MIT headers (`vendor/nv-codec-headers`, `vendor/libva`); openh264 is Cisco's
+//! prebuilt library, fetched by the engine at run time (see `src/h264.rs`). The
+//! macOS build links the VideoToolbox system framework.
+//!
 //! macOS builds only the libvpx shim; ScreenCaptureKit, Quartz input and
 //! AppKit clipboard use native frameworks. Linux runtime input access is still
 //! checked through `/dev/uinput`.
@@ -25,6 +31,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rustc-check-cfg=cfg(desklink_vpx)");
     println!("cargo:rustc-check-cfg=cfg(desklink_macos_cli)");
     println!("cargo:rerun-if-changed=native/vpx_shim.c");
+    println!("cargo:rerun-if-changed=native/nvenc_shim.c");
+    println!("cargo:rerun-if-changed=native/vaapi_shim.c");
+    println!("cargo:rerun-if-changed=native/vt_shim.c");
     println!("cargo:rerun-if-changed=native/inputtino_shim.cpp");
     println!("cargo:rerun-if-changed=native/mac_stream.mm");
     println!("cargo:rerun-if-changed=native/agent_overlay_mac.m");
@@ -39,6 +48,44 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rerun-if-env-changed=DESKLINK_MACOS_CLI");
 
     let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    if target_os == "windows" {
+        if let Some(prefix) = std::env::var_os("DESKLINK_VPX_STATIC_DIR").map(PathBuf::from) {
+            if std::env::var("CARGO_CFG_TARGET_ENV")? != "msvc"
+                || std::env::var("CARGO_CFG_TARGET_ARCH")? != "x86_64"
+            {
+                return Err("Windows libvpx requires x86_64-pc-windows-msvc".into());
+            }
+            if !std::env::var("CARGO_CFG_TARGET_FEATURE")?
+                .split(',')
+                .any(|f| f == "crt-static")
+            {
+                return Err(
+                    "Windows static libvpx requires RUSTFLAGS=-Ctarget-feature=+crt-static (/MT)"
+                        .into(),
+                );
+            }
+            if !prefix.join("include/vpx/vp8cx.h").is_file()
+                || !prefix.join("lib/vpx.lib").is_file()
+            {
+                return Err(
+                    "DESKLINK_VPX_STATIC_DIR must contain include/vpx/vp8cx.h and lib/vpx.lib"
+                        .into(),
+                );
+            }
+            cc::Build::new()
+                .file("native/vpx_shim.c")
+                .include(prefix.join("include"))
+                .static_crt(true)
+                .compile("dlvpx");
+            println!(
+                "cargo:rustc-link-search=native={}",
+                prefix.join("lib").display()
+            );
+            println!("cargo:rustc-link-lib=static=vpx");
+            println!("cargo:rustc-cfg=desklink_vpx");
+        }
+        return Ok(());
+    }
     if let Some(prefix) = std::env::var_os("DESKLINK_VPX_STATIC_DIR").map(PathBuf::from) {
         if !prefix.join("include/vpx/vp8cx.h").exists() || !prefix.join("lib/libvpx.a").exists() {
             return Err(format!("DESKLINK_VPX_STATIC_DIR must be the libvpx install prefix containing include/vpx/vp8cx.h and lib/libvpx.a, not its lib directory: {}", prefix.display()).into());
@@ -69,11 +116,41 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     if target_os == "linux" {
+        // H.264 through NVENC and VA-API: the driver libraries are dlopen'd at
+        // run time, so building needs only their vendored MIT headers, and a
+        // machine without them still runs the engine.
+        cc::Build::new()
+            .file("native/nvenc_shim.c")
+            .include("vendor/nv-codec-headers/include")
+            .compile("dlnvenc");
         cc::Build::new()
+            .file("native/vaapi_shim.c")
+            .include("vendor/libva")
+            .compile("dlvaapi");
+        println!("cargo:rustc-link-lib=dl");
+        let mut overlay = cc::Build::new();
+        let includes = std::process::Command::new("pkg-config")
+            .args(["--cflags", "freetype2", "fontconfig"])
+            .output()?;
+        if !includes.status.success() {
+            return Err("FreeType and Fontconfig development headers are required".into());
+        }
+        for flag in String::from_utf8(includes.stdout)?.split_whitespace() {
+            overlay.flag(flag);
+        }
+        overlay
             .file("native/agent_overlay_x11.c")
             .file("native/agent_overlay_wayland.c")
             .compile("dlagentoverlay");
-        for lib in ["X11", "Xcursor", "wayland-client", "m"] {
+        for lib in [
+            "X11",
+            "Xext",
+            "Xcursor",
+            "wayland-client",
+            "fontconfig",
+            "freetype",
+            "m",
+        ] {
             println!("cargo:rustc-link-lib={lib}");
         }
         cc::Build::new()
@@ -114,6 +191,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             );
             println!("cargo:rustc-link-lib=static=vpx");
             println!("cargo:rustc-cfg=desklink_vpx");
+            // H.264 for receivers that decode it in hardware; VideoToolbox is a
+            // system framework, so linking it adds no dependency.
+            cc::Build::new().file("native/vt_shim.c").compile("dlvt");
+            println!("cargo:rustc-link-lib=framework=VideoToolbox");
+            println!("cargo:rustc-link-lib=framework=CoreFoundation");
         }
         println!("cargo:rustc-link-lib=framework=CoreGraphics");
         println!("cargo:rustc-link-lib=framework=ApplicationServices");

package/engine/native/agent_overlay_mac.m

@@ -3,18 +3,31 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <string.h>
 
 @interface AgentOverlayView : NSView {
     NSPoint target, cursor;
     CFTimeInterval clickAt, typeAt, endingAt;
     BOOL positioned;
+    BOOL pointMode, pointVisible;
+    CFTimeInterval pointDeadline;
+    NSString *pointLabel;
 }
 - (void)event:(char)kind x:(double)x y:(double)y;
 - (void)end;
+- (void)enablePointMode;
+- (void)pointX:(double)x y:(double)y timeout:(unsigned)timeout label:(NSString *)label;
 @end
 
 @implementation AgentOverlayView
 - (BOOL)isOpaque { return NO; }
+- (void)enablePointMode { pointMode = YES; }
+- (void)pointX:(double)x y:(double)y timeout:(unsigned)timeout label:(NSString *)label {
+    cursor = NSMakePoint(x, self.bounds.size.height-y);
+    pointLabel = label; pointVisible = YES;
+    pointDeadline = CACurrentMediaTime() + timeout/1000.0;
+    [self setNeedsDisplay:YES];
+}
 - (void)event:(char)kind x:(double)x y:(double)y {
     if (kind == 'S') { [self end]; return; }
     if (x >= 0 && y >= 0) {
@@ -27,8 +40,12 @@
     if (kind == 'T') typeAt = now;
     [self setNeedsDisplay:YES];
 }
-- (void)end { endingAt = CACurrentMediaTime(); }
+- (void)end { if (pointMode) { [NSApp terminate:nil]; return; } endingAt = CACurrentMediaTime(); }
 - (void)tick {
+    if (pointMode) {
+        if (pointVisible && CACurrentMediaTime() >= pointDeadline) { pointVisible = NO; [self setNeedsDisplay:YES]; }
+        return;
+    }
     if (endingAt && CACurrentMediaTime() - endingAt > 0.7) { [NSApp terminate:nil]; return; }
     cursor.x += (target.x - cursor.x) * 0.24;
     cursor.y += (target.y - cursor.y) * 0.24;
@@ -36,6 +53,23 @@
 }
 - (void)drawRect:(NSRect)rect {
     [[NSColor clearColor] set]; NSRectFillUsingOperation(rect, NSCompositingOperationCopy);
+    if (pointMode) {
+        if (!pointVisible) return;
+        [[NSColor colorWithCalibratedRed:0.30 green:0.62 blue:0.82 alpha:1] set];
+        NSBezierPath *ring = [NSBezierPath bezierPathWithOvalInRect:NSMakeRect(cursor.x-18, cursor.y-18, 36, 36)];
+        ring.lineWidth = 4; [ring stroke];
+        [[NSBezierPath bezierPathWithOvalInRect:NSMakeRect(cursor.x-3,cursor.y-3,6,6)] fill];
+        if (pointLabel.length) {
+            NSDictionary *style = @{NSFontAttributeName: [NSFont systemFontOfSize:13], NSForegroundColorAttributeName: NSColor.whiteColor};
+            NSSize size = [pointLabel sizeWithAttributes:style];
+            CGFloat x = fmax(0, fmin(cursor.x+30, self.bounds.size.width-size.width-16));
+            CGFloat y = fmax(0, fmin(cursor.y-14, self.bounds.size.height-28));
+            [[NSColor colorWithCalibratedRed:0.07 green:0.19 blue:0.28 alpha:1] set];
+            [[NSBezierPath bezierPathWithRoundedRect:NSMakeRect(x,y,size.width+16,28) xRadius:4 yRadius:4] fill];
+            [pointLabel drawAtPoint:NSMakePoint(x+8,y+6) withAttributes:style];
+        }
+        return;
+    }
     CFTimeInterval now = CACurrentMediaTime();
     CGFloat edge = endingAt ? fmax(0, 1 - (now-endingAt)/0.7) : 1;
     if (edge > 0) {
@@ -95,7 +129,7 @@ unsigned char *desklink_image_bgra(CGImageRef image, size_t *length, size_t *str
     return pixels;
 }
 
-int desklink_agent_overlay_main(int display_id) {
+static int overlay_main(int display_id, BOOL point_mode) {
     @autoreleasepool {
         [NSApplication sharedApplication];
         [NSApp setActivationPolicy:NSApplicationActivationPolicyProhibited];
@@ -111,14 +145,24 @@ int desklink_agent_overlay_main(int display_id) {
         window.collectionBehavior = NSWindowCollectionBehaviorCanJoinAllSpaces | NSWindowCollectionBehaviorStationary;
         AgentOverlayView *view = [[AgentOverlayView alloc] initWithFrame:NSMakeRect(0,0,screen.frame.size.width,screen.frame.size.height)];
         window.contentView = view;
+        if (point_mode) [view enablePointMode];
         NSPoint mouse = [NSEvent mouseLocation];
-        [view event:'M' x:mouse.x-screen.frame.origin.x y:NSMaxY(screen.frame)-mouse.y];
+        if (!point_mode) [view event:'M' x:mouse.x-screen.frame.origin.x y:NSMaxY(screen.frame)-mouse.y];
         [window orderFrontRegardless];
         puts("READY"); fflush(stdout);
         [NSTimer scheduledTimerWithTimeInterval:1.0/60 target:view selector:@selector(tick) userInfo:nil repeats:YES];
         dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
-            char line[128];
+            char line[512];
             while (fgets(line, sizeof(line), stdin)) {
+                if (point_mode) {
+                    double x, y; unsigned timeout; int offset = 0;
+                    if (sscanf(line, "P %lf %lf %u %n", &x, &y, &timeout, &offset) == 3 && offset) {
+                        line[strcspn(line, "\n")] = 0;
+                        NSString *label = [NSString stringWithUTF8String:line+offset];
+                        dispatch_async(dispatch_get_main_queue(), ^{ [view pointX:x y:y timeout:timeout label:label]; });
+                    }
+                    continue;
+                }
                 char kind; double x = 0, y = 0;
                 if (sscanf(line, "%c %lf %lf", &kind, &x, &y) >= 1) {
                     dispatch_async(dispatch_get_main_queue(), ^{ [view event:kind x:x y:y]; });
@@ -131,3 +175,6 @@ int desklink_agent_overlay_main(int display_id) {
     }
     return 0;
 }
+
+int desklink_agent_overlay_main(int display_id) { return overlay_main(display_id, NO); }
+int desklink_point_overlay_main(int display_id) { return overlay_main(display_id, YES); }

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;
+}