main: WiP: Calculate delay based on rtt and jitter

.gitignore

@@ -1,4 +1,4 @@
 build*
 subprojects
 .clang_complete
-.vscode
+sandbox

include/buffer-pool.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Andri Yngvason
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include "buffer.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct buffer_pool;
+struct buffer;
+
+struct buffer_pool* buffer_pool_create(enum buffer_type type, uint16_t width,
+		uint16_t height, uint32_t format, uint16_t stride, int scale);
+void buffer_pool_destroy(struct buffer_pool* self);
+
+bool buffer_pool_resize(struct buffer_pool* self, uint16_t width,
+		uint16_t height, uint32_t format, uint16_t stride, int scale);
+
+struct buffer* buffer_pool_acquire(struct buffer_pool* self);
+
+void buffer_pool_damage_all(struct buffer_pool* self,
+		struct pixman_region16* damage);

include/buffer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Andri Yngvason
+ * Copyright (c) 2022 - 2023 Andri Yngvason
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include "sys/queue.h"
+
 #include <stdbool.h>
 #include <unistd.h>
 #include <stdint.h>
@@ -31,6 +33,17 @@ enum buffer_type {
 };
 
 struct buffer {
+	int ref;
+	int hold;
+
+	TAILQ_ENTRY(buffer) queue_link;
+
+	LIST_ENTRY(buffer) registry_link;
+	TAILQ_ENTRY(buffer) pool_link;
+
+	void (*release_fn)(struct buffer*, void* ud);
+	void* release_ud;
+
 	enum buffer_type type;
 
 	int width, height;
@@ -38,10 +51,10 @@ struct buffer {
 	size_t size;
 	uint32_t format;
 	struct wl_buffer* wl_buffer;
-	bool is_attached;
-	bool please_clean_up;
 	struct pixman_region16 damage;
 
+	int32_t pts;
+
 	// wl_shm:
 	void* pixels;
 	int stride;
@@ -53,3 +66,12 @@ struct buffer {
 struct buffer* buffer_create_shm(int width, int height, int stride, uint32_t format);
 struct buffer* buffer_create_dmabuf(int width, int height, uint32_t format);
 void buffer_destroy(struct buffer* self);
+
+void buffer_ref(struct buffer*);
+void buffer_unref(struct buffer*);
+
+void buffer_set_release_fn(struct buffer*, void (*)(struct buffer*, void* ud),
+		void* userdata);
+
+void buffer_hold(struct buffer*);
+void buffer_release(struct buffer*);

include/data-control.h

@@ -1,24 +0,0 @@
-#include "wlr-data-control-unstable-v1.h"
-#include "seat.h"
-
-typedef void (*vnc_write_clipboard_t)(char* text, size_t size);
-
-struct data_control {
-	struct wl_display* wl_display;
-	struct nvnc* server;
-	struct zwlr_data_control_manager_v1* manager;
-	struct zwlr_data_control_device_v1* device;
-	struct zwlr_data_control_source_v1* selection;
-	struct zwlr_data_control_source_v1* primary_selection;
-	struct zwlr_data_control_offer_v1* offer;
-	const char* mime_type;
-	char* cb_data;
-	size_t cb_len;
-	vnc_write_clipboard_t vnc_write_clipboard;
-};
-
-void data_control_init(struct data_control* self, struct seat* seat, struct zwlr_data_control_manager_v1 *manager);
-void data_control_to_clipboard(struct data_control* self, const char* text, size_t len);
-void data_control_destroy(struct data_control* self);
-
-#pragma once

include/ntp.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023 Andri Yngvason
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define NTP_SAMPLE_PERIOD 1000000 // µs
+#define NTP_MIN_SAMPLE_COUNT 3
+#define NTP_SAMPLE_SIZE 16
+
+struct aml_ticker;
+struct ntp_client;
+
+typedef void (*ntp_client_ping_fn)(struct ntp_client*, uint32_t t0, uint32_t t1,
+		uint32_t t2, uint32_t t3);
+
+struct ntp_sample {
+	int32_t theta;
+	uint32_t delta;
+};
+
+struct ntp_client {
+	struct ntp_sample samples[NTP_SAMPLE_SIZE];
+	int sample_index;
+	int sample_count;
+
+	struct aml_ticker* ping_ticker;
+
+	ntp_client_ping_fn send_ping;
+	void* userdata;
+};
+
+int ntp_client_init(struct ntp_client*, ntp_client_ping_fn send_ping,
+                void* userdata);
+void ntp_client_deinit(struct ntp_client*);
+
+void ntp_client_process_pong(struct ntp_client*, uint32_t t0, uint32_t t1,
+                uint32_t t2, uint32_t t3);
+
+bool ntp_client_get_best_sample(const struct ntp_client* self,
+		struct ntp_sample* sample);
+
+bool ntp_client_translate_server_time(const struct ntp_client* self,
+		uint32_t* dst, const uint32_t t);
+
+uint32_t ntp_client_get_jitter(const struct ntp_client* self);

include/performance.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#define PERF_FRAME_LATENCY_SAMPLE_SIZE 60
+
+struct perf_sample_stats {
+	double min, max, average;
+};
+
+struct perf_sample_buffer {
+	int length;
+	int count;
+	int index;
+	double samples[];
+};
+
+struct perf {
+	struct perf_sample_buffer* frame_latency;
+};
+
+struct perf_sample_buffer* perf_sample_buffer_create(int length);
+
+void perf_sample_buffer_add(struct perf_sample_buffer* self, double sample);
+
+void perf_sample_buffer_get_stats(const struct perf_sample_buffer* self,
+		struct perf_sample_stats* stats);
+
+void perf_init(struct perf*);
+void perf_deinit(struct perf*);
+
+void perf_dump_latency_report(const struct perf*);

include/renderer-egl.h

@@ -11,4 +11,6 @@ void render_image_egl(struct buffer* dst, const struct image* src, double scale,
 		int pos_x, int pos_y);
 void render_av_frames_egl(struct buffer* dst, struct vnc_av_frame** src,
 		int n_av_frames, double scale, int x_pos, int y_pos);
+void render_buffer_egl(struct buffer* dst, const struct buffer* src,
+		double scale, int x_pos, int y_pos);
 

include/rfbclient.h

@@ -225,6 +225,9 @@ typedef char* (*GetUserProc)(struct _rfbClient* client);
 typedef char* (*GetSASLMechanismProc)(struct _rfbClient* client, char* mechlist);
 #endif /* LIBVNCSERVER_HAVE_SASL */
 
+typedef void (*NtpEventProc)(struct _rfbClient* client, uint32_t t0,
+                uint32_t t1, uint32_t t2, uint32_t t3);
+
 typedef struct _rfbClient {
 	uint8_t* frameBuffer;
 	int width, height;
@@ -467,6 +470,8 @@ typedef struct _rfbClient {
 
 	StartingFrameBufferUpdateProc StartingFrameBufferUpdate;
 	CancelledFrameBufferUpdateProc CancelledFrameBufferUpdate;
+
+	NtpEventProc NtpEvent;
 } rfbClient;
 
 /* cursor.c */
@@ -612,6 +617,9 @@ extern rfbBool HandleRFBServerMessage(rfbClient* client);
 
 extern rfbBool ReadToBuffer(rfbClient* client);
 
+extern rfbBool SendClientNtpEvent(rfbClient* client, uint32_t t0, uint32_t t1,
+		uint32_t t2, uint32_t t3);
+
 /**
  * Sends a text chat message to the server.
  * @param client The client through which to send the message

include/rfbproto.h

@@ -398,8 +398,7 @@ typedef struct {
 #define rfbSetDesktopSize 251
 #define rfbQemuEvent 255
 
-
-
+#define rfbNtpEvent 160
 
 /*****************************************************************************
  *
@@ -498,6 +497,8 @@ typedef struct {
 #define rfbEncodingSupportedEncodings 0xFFFE0002
 #define rfbEncodingServerIdentity     0xFFFE0003
 
+#define rfbEncodingPts -1000
+#define rfbEncodingNtp -1001
 
 /*****************************************************************************
  *
@@ -1138,6 +1139,12 @@ typedef struct rfbExtDesktopScreen {
     uint32_t flags;
 } rfbExtDesktopScreen;
 
+struct rfbNtpMsg {
+	uint8_t type;
+	uint8_t padding[3];
+	uint32_t t0, t1, t2, t3;
+};
+
 #define sz_rfbExtDesktopSizeMsg (4)
 #define sz_rfbExtDesktopScreen (16)
 
@@ -1228,6 +1235,7 @@ typedef union {
 	rfbTextChatMsg tc;
 	rfbXvpMsg xvp;
 	rfbExtDesktopSizeMsg eds;
+	struct rfbNtpMsg ntp;
 } rfbServerToClientMsg;
 
 

include/vnc.h

@@ -17,7 +17,6 @@
 #pragma once
 
 #include "rfbclient.h"
-#include "data-control.h"
 
 #include <stdbool.h>
 #include <unistd.h>
@@ -37,7 +36,6 @@ struct vnc_av_frame {
 struct vnc_client {
 	rfbClient* client;
 
-	struct data_control* data_control;
 	struct open_h264* open_h264;
 	bool current_rect_is_av_frame;
 	struct vnc_av_frame* av_frames[VNC_CLIENT_MAX_AV_FRAMES];
@@ -47,6 +45,8 @@ struct vnc_client {
 	int (*alloc_fb)(struct vnc_client*);
 	void (*update_fb)(struct vnc_client*);
 	void (*cut_text)(struct vnc_client*, const char*, size_t);
+        void (*ntp_event)(struct vnc_client*, uint32_t t0, uint32_t t1,
+                        uint32_t t2, uint32_t t3);
 
 	void* userdata;
 	struct pixman_region16 damage;
@@ -55,7 +55,7 @@ struct vnc_client {
 	bool is_updating;
 };
 
-struct vnc_client* vnc_client_create(struct data_control* data_control);
+struct vnc_client* vnc_client_create(void);
 void vnc_client_destroy(struct vnc_client* self);
 
 int vnc_client_connect(struct vnc_client* self, const char* address, int port);
@@ -81,5 +81,5 @@ void vnc_client_set_compression_level(struct vnc_client* self, int value);
 void vnc_client_send_cut_text(struct vnc_client* self, const char* text,
 		size_t len);
 void vnc_client_clear_av_frames(struct vnc_client* self);
-rfbCredential* handle_vnc_authentication(struct _rfbClient *client, int credentialType);
-void cut_text (struct vnc_client* self, const char* text, size_t size);
+void vnc_client_send_ntp_event(struct vnc_client* self, uint32_t t0,
+                uint32_t t1, uint32_t t2, uint32_t t3);

meson.build

@@ -70,7 +70,6 @@ sources = [
 	'src/pointer.c',
 	'src/keyboard.c',
 	'src/vnc.c',
-	'src/data-control.c',
 	'src/strlcpy.c',
 	'src/evdev-to-qnum.c',
 	'src/pixels.c',
@@ -78,11 +77,14 @@ sources = [
 	'src/renderer.c',
 	'src/renderer-egl.c',
 	'src/buffer.c',
+	'src/buffer-pool.c',
 	'src/open-h264.c',
 	'src/cursor.c',
 	'src/rfbproto.c',
 	'src/sockets.c',
 	'src/vncviewer.c',
+	'src/ntp.c',
+	'src/performance.c',
 ]
 
 dependencies = [

protocols/meson.build

@@ -16,7 +16,6 @@ wayland_scanner_client = generator(
 client_protocols = [
 	'xdg-shell.xml',
 	'linux-dmabuf-unstable-v1.xml',
-	'wlr-data-control-unstable-v1.xml'
 ]
 
 client_protos_src = []

protocols/wlr-data-control-unstable-v1.xml

@@ -1,278 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="wlr_data_control_unstable_v1">
-  <copyright>
-    Copyright © 2018 Simon Ser
-    Copyright © 2019 Ivan Molodetskikh
-
-    Permission to use, copy, modify, distribute, and sell this
-    software and its documentation for any purpose is hereby granted
-    without fee, provided that the above copyright notice appear in
-    all copies and that both that copyright notice and this permission
-    notice appear in supporting documentation, and that the name of
-    the copyright holders not be used in advertising or publicity
-    pertaining to distribution of the software without specific,
-    written prior permission.  The copyright holders make no
-    representations about the suitability of this software for any
-    purpose.  It is provided "as is" without express or implied
-    warranty.
-
-    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
-    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
-    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-    THIS SOFTWARE.
-  </copyright>
-
-  <description summary="control data devices">
-    This protocol allows a privileged client to control data devices. In
-    particular, the client will be able to manage the current selection and take
-    the role of a clipboard manager.
-
-    Warning! The protocol described in this file is experimental and
-    backward incompatible changes may be made. Backward compatible changes
-    may be added together with the corresponding interface version bump.
-    Backward incompatible changes are done by bumping the version number in
-    the protocol and interface names and resetting the interface version.
-    Once the protocol is to be declared stable, the 'z' prefix and the
-    version number in the protocol and interface names are removed and the
-    interface version number is reset.
-  </description>
-
-  <interface name="zwlr_data_control_manager_v1" version="2">
-    <description summary="manager to control data devices">
-      This interface is a manager that allows creating per-seat data device
-      controls.
-    </description>
-
-    <request name="create_data_source">
-      <description summary="create a new data source">
-        Create a new data source.
-      </description>
-      <arg name="id" type="new_id" interface="zwlr_data_control_source_v1"
-        summary="data source to create"/>
-    </request>
-
-    <request name="get_data_device">
-      <description summary="get a data device for a seat">
-        Create a data device that can be used to manage a seat's selection.
-      </description>
-      <arg name="id" type="new_id" interface="zwlr_data_control_device_v1"/>
-      <arg name="seat" type="object" interface="wl_seat"/>
-    </request>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the manager">
-        All objects created by the manager will still remain valid, until their
-        appropriate destroy request has been called.
-      </description>
-    </request>
-  </interface>
-
-  <interface name="zwlr_data_control_device_v1" version="2">
-    <description summary="manage a data device for a seat">
-      This interface allows a client to manage a seat's selection.
-
-      When the seat is destroyed, this object becomes inert.
-    </description>
-
-    <request name="set_selection">
-      <description summary="copy data to the selection">
-        This request asks the compositor to set the selection to the data from
-        the source on behalf of the client.
-
-        The given source may not be used in any further set_selection or
-        set_primary_selection requests. Attempting to use a previously used
-        source is a protocol error.
-
-        To unset the selection, set the source to NULL.
-      </description>
-      <arg name="source" type="object" interface="zwlr_data_control_source_v1"
-        allow-null="true"/>
-    </request>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy this data device">
-        Destroys the data device object.
-      </description>
-    </request>
-
-    <event name="data_offer">
-      <description summary="introduce a new wlr_data_control_offer">
-        The data_offer event introduces a new wlr_data_control_offer object,
-        which will subsequently be used in either the
-        wlr_data_control_device.selection event (for the regular clipboard
-        selections) or the wlr_data_control_device.primary_selection event (for
-        the primary clipboard selections). Immediately following the
-        wlr_data_control_device.data_offer event, the new data_offer object
-        will send out wlr_data_control_offer.offer events to describe the MIME
-        types it offers.
-      </description>
-      <arg name="id" type="new_id" interface="zwlr_data_control_offer_v1"/>
-    </event>
-
-    <event name="selection">
-      <description summary="advertise new selection">
-        The selection event is sent out to notify the client of a new
-        wlr_data_control_offer for the selection for this device. The
-        wlr_data_control_device.data_offer and the wlr_data_control_offer.offer
-        events are sent out immediately before this event to introduce the data
-        offer object. The selection event is sent to a client when a new
-        selection is set. The wlr_data_control_offer is valid until a new
-        wlr_data_control_offer or NULL is received. The client must destroy the
-        previous selection wlr_data_control_offer, if any, upon receiving this
-        event.
-
-        The first selection event is sent upon binding the
-        wlr_data_control_device object.
-      </description>
-      <arg name="id" type="object" interface="zwlr_data_control_offer_v1"
-        allow-null="true"/>
-    </event>
-
-    <event name="finished">
-      <description summary="this data control is no longer valid">
-        This data control object is no longer valid and should be destroyed by
-        the client.
-      </description>
-    </event>
-
-    <!-- Version 2 additions -->
-
-    <event name="primary_selection" since="2">
-      <description summary="advertise new primary selection">
-        The primary_selection event is sent out to notify the client of a new
-        wlr_data_control_offer for the primary selection for this device. The
-        wlr_data_control_device.data_offer and the wlr_data_control_offer.offer
-        events are sent out immediately before this event to introduce the data
-        offer object. The primary_selection event is sent to a client when a
-        new primary selection is set. The wlr_data_control_offer is valid until
-        a new wlr_data_control_offer or NULL is received. The client must
-        destroy the previous primary selection wlr_data_control_offer, if any,
-        upon receiving this event.
-
-        If the compositor supports primary selection, the first
-        primary_selection event is sent upon binding the
-        wlr_data_control_device object.
-      </description>
-      <arg name="id" type="object" interface="zwlr_data_control_offer_v1"
-        allow-null="true"/>
-    </event>
-
-    <request name="set_primary_selection" since="2">
-      <description summary="copy data to the primary selection">
-        This request asks the compositor to set the primary selection to the
-        data from the source on behalf of the client.
-
-        The given source may not be used in any further set_selection or
-        set_primary_selection requests. Attempting to use a previously used
-        source is a protocol error.
-
-        To unset the primary selection, set the source to NULL.
-
-        The compositor will ignore this request if it does not support primary
-        selection.
-      </description>
-      <arg name="source" type="object" interface="zwlr_data_control_source_v1"
-        allow-null="true"/>
-    </request>
-
-    <enum name="error" since="2">
-      <entry name="used_source" value="1"
-        summary="source given to set_selection or set_primary_selection was already used before"/>
-    </enum>
-  </interface>
-
-  <interface name="zwlr_data_control_source_v1" version="1">
-    <description summary="offer to transfer data">
-      The wlr_data_control_source object is the source side of a
-      wlr_data_control_offer. It is created by the source client in a data
-      transfer and provides a way to describe the offered data and a way to
-      respond to requests to transfer the data.
-    </description>
-
-    <enum name="error">
-      <entry name="invalid_offer" value="1"
-        summary="offer sent after wlr_data_control_device.set_selection"/>
-    </enum>
-
-    <request name="offer">
-      <description summary="add an offered MIME type">
-        This request adds a MIME type to the set of MIME types advertised to
-        targets. Can be called several times to offer multiple types.
-
-        Calling this after wlr_data_control_device.set_selection is a protocol
-        error.
-      </description>
-      <arg name="mime_type" type="string"
-        summary="MIME type offered by the data source"/>
-    </request>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy this source">
-        Destroys the data source object.
-      </description>
-    </request>
-
-    <event name="send">
-      <description summary="send the data">
-        Request for data from the client. Send the data as the specified MIME
-        type over the passed file descriptor, then close it.
-      </description>
-      <arg name="mime_type" type="string" summary="MIME type for the data"/>
-      <arg name="fd" type="fd" summary="file descriptor for the data"/>
-    </event>
-
-    <event name="cancelled">
-      <description summary="selection was cancelled">
-        This data source is no longer valid. The data source has been replaced
-        by another data source.
-
-        The client should clean up and destroy this data source.
-      </description>
-    </event>
-  </interface>
-
-  <interface name="zwlr_data_control_offer_v1" version="1">
-    <description summary="offer to transfer data">
-      A wlr_data_control_offer represents a piece of data offered for transfer
-      by another client (the source client). The offer describes the different
-      MIME types that the data can be converted to and provides the mechanism
-      for transferring the data directly from the source client.
-    </description>
-
-    <request name="receive">
-      <description summary="request that the data is transferred">
-        To transfer the offered data, the client issues this request and
-        indicates the MIME type it wants to receive. The transfer happens
-        through the passed file descriptor (typically created with the pipe
-        system call). The source client writes the data in the MIME type
-        representation requested and then closes the file descriptor.
-
-        The receiving client reads from the read end of the pipe until EOF and
-        then closes its end, at which point the transfer is complete.
-
-        This request may happen multiple times for different MIME types.
-      </description>
-      <arg name="mime_type" type="string"
-        summary="MIME type desired by receiver"/>
-      <arg name="fd" type="fd" summary="file descriptor for data transfer"/>
-    </request>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy this offer">
-        Destroys the data offer object.
-      </description>
-    </request>
-
-    <event name="offer">
-      <description summary="advertise offered MIME type">
-        Sent immediately after creating the wlr_data_control_offer object.
-        One event per offered MIME type.
-      </description>
-      <arg name="mime_type" type="string" summary="offered MIME type"/>
-    </event>
-  </interface>
-</protocol>

src/buffer-pool.c

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2023 Andri Yngvason
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "buffer-pool.h"
+#include "buffer.h"
+
+#include "sys/queue.h"
+
+#include <stdlib.h>
+#include <assert.h>
+
+LIST_HEAD(buffer_list, buffer);
+TAILQ_HEAD(bufferq, buffer);
+
+struct buffer_pool {
+	int ref;
+
+	struct buffer_list registry;
+	struct bufferq buffers;
+
+	enum buffer_type type;
+	uint16_t width;
+	uint16_t height;
+	int32_t stride;
+	uint32_t format;
+	int scale;
+};
+
+struct buffer_pool* buffer_pool_create(enum buffer_type type, uint16_t width,
+		uint16_t height, uint32_t format, uint16_t stride, int scale)
+{
+	struct buffer_pool* self = calloc(1, sizeof(*self));
+	if (!self)
+		return NULL;
+
+	self->ref = 1;
+
+	LIST_INIT(&self->registry);
+	TAILQ_INIT(&self->buffers);
+	self->type = type;
+	self->width = width;
+	self->height = height;
+	self->stride = stride;
+	self->format = format;
+	self->scale = scale;
+
+	return self;
+}
+
+static void buffer_pool__unref_buffers(struct buffer_pool* self)
+{
+	while (!LIST_EMPTY(&self->registry)) {
+		struct buffer* buffer = LIST_FIRST(&self->registry);
+		LIST_REMOVE(buffer, registry_link);
+		buffer_set_release_fn(buffer, NULL, NULL);
+		buffer_unref(buffer);
+	}
+	TAILQ_INIT(&self->buffers);
+}
+
+void buffer_pool_destroy(struct buffer_pool* self)
+{
+	buffer_pool__unref_buffers(self);
+	free(self);
+}
+
+bool buffer_pool_resize(struct buffer_pool* self, uint16_t width,
+		uint16_t height, uint32_t format, uint16_t stride, int scale)
+{
+	if (width == self->width && height == self->height &&
+			format == self->format && stride == self->stride &&
+			scale == self->scale)
+		return false;
+
+	buffer_pool__unref_buffers(self);
+
+	self->width = width;
+	self->height = height;
+	self->stride = stride;
+	self->format = format;
+	self->scale = scale;
+
+	return true;
+}
+
+static void buffer_pool__on_buffer_release(struct buffer* buffer, void* userdata)
+{
+	struct buffer_pool* self = userdata;
+
+	if (buffer->width != self->width || buffer->height != self->height ||
+			buffer->format != self->format ||
+			(buffer->type == BUFFER_WL_SHM && buffer->stride != self->stride) ||
+			buffer->scale != self->scale) {
+		buffer_unref(buffer);
+	} else {
+		TAILQ_INSERT_TAIL(&self->buffers, buffer, pool_link);
+	}
+}
+
+static struct buffer* buffer_pool__acquire_new(struct buffer_pool* self)
+{
+	struct buffer* buffer;
+	switch (self->type) {
+	case BUFFER_WL_SHM:
+		buffer = buffer_create_shm(self->width, self->height,
+				self->stride, self->format);
+		break;
+	case BUFFER_DMABUF:
+		buffer = buffer_create_dmabuf(self->width, self->height,
+				self->format);
+		break;
+	case BUFFER_UNSPEC:
+		abort();
+	}
+	if (!buffer)
+		return NULL;
+
+	buffer->scale = self->scale;
+
+	LIST_INSERT_HEAD(&self->registry, buffer, registry_link);
+	buffer_set_release_fn(buffer, buffer_pool__on_buffer_release, self);
+
+	return buffer;
+}
+
+static struct buffer* buffer_pool__acquire_from_list(struct buffer_pool* self)
+{
+	struct buffer* buffer = TAILQ_FIRST(&self->buffers);
+	assert(buffer);
+
+	TAILQ_REMOVE(&self->buffers, buffer, pool_link);
+
+	return buffer;
+}
+
+struct buffer* buffer_pool_acquire(struct buffer_pool* self)
+{
+	return TAILQ_EMPTY(&self->buffers) ?
+		buffer_pool__acquire_new(self) :
+		buffer_pool__acquire_from_list(self);
+}
+
+void buffer_pool_damage_all(struct buffer_pool* self,
+		struct pixman_region16* damage)
+{
+	struct buffer* buffer;
+	LIST_FOREACH(buffer, &self->registry, registry_link) {
+		pixman_region_union(&buffer->damage, damage, damage);
+	}
+}

src/buffer.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Andri Yngvason
+ * Copyright (c) 2022 - 2023 Andri Yngvason
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -25,24 +25,22 @@
 #include <gbm.h>
 #include <assert.h>
 
+// TODO: Some buffers needn't be wayland buffers.
+
 /* Origin: main.c */
 extern struct wl_shm* wl_shm;
 extern struct gbm_device* gbm_device;
 extern struct zwp_linux_dmabuf_v1* zwp_linux_dmabuf_v1;
 
-static void buffer_release(void* data, struct wl_buffer* wl_buffer)
+static void buffer_wl_release(void* data, struct wl_buffer* wl_buffer)
 {
 	(void)wl_buffer;
 	struct buffer* self = data;
-	self->is_attached = false;
-
-	if (self->please_clean_up) {
-		buffer_destroy(self);
-	}
+	buffer_release(self);
 }
 
 static const struct wl_buffer_listener buffer_listener = {
-	.release = buffer_release,
+	.release = buffer_wl_release,
 };
 
 struct buffer* buffer_create_shm(int width, int height, int stride,
@@ -54,6 +52,7 @@ struct buffer* buffer_create_shm(int width, int height, int stride,
 	if (!self)
 		return NULL;
 
+	self->ref = 1;
 	self->type = BUFFER_WL_SHM;
 	self->width = width;
 	self->height = height;
@@ -106,6 +105,7 @@ struct buffer* buffer_create_dmabuf(int width, int height, uint32_t format)
 	if (!self)
 		return NULL;
 
+	self->ref = 1;
 	self->type = BUFFER_DMABUF;
 	self->width = width;
 	self->height = height;
@@ -159,9 +159,6 @@ void buffer_destroy(struct buffer* self)
 	if (!self)
 		return;
 
-	if (self->is_attached)
-		self->please_clean_up = true;
-
 	pixman_region_fini(&self->damage);
 	wl_buffer_destroy(self->wl_buffer);
 
@@ -179,3 +176,41 @@ void buffer_destroy(struct buffer* self)
 
 	free(self);
 }
+
+void buffer_ref(struct buffer* self)
+{
+	++self->ref;
+}
+
+void buffer_unref(struct buffer* self)
+{
+	if (self && --self->ref == 0)
+		buffer_destroy(self);
+}
+
+void buffer_set_release_fn(struct buffer* self,
+		void (*fn)(struct buffer*, void* ud), void* userdata)
+{
+	self->release_fn = fn;
+	self->release_ud = userdata;
+}
+
+void buffer_hold(struct buffer* self)
+{
+	assert(self);
+	++self->hold;
+}
+
+void buffer_release(struct buffer* self)
+{
+	assert(self);
+
+	int hold = --self->hold;
+	if (hold != 0)
+	       return;
+
+	if (self->release_fn)
+		self->release_fn(self, self->release_ud);
+	else
+		buffer_unref(self);
+}

src/data-control.c

@@ -1,308 +0,0 @@
-#include "data-control.h"
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <errno.h>
-#include <signal.h>
-#include <getopt.h>
-#include <aml.h>
-#include <seat.h>
-#include <vnc.h>
-
-struct receive_context {
-	//struct data_control* data_control;
-	struct zwlr_data_control_offer_v1* offer;
-	int fd;
-	FILE* mem_fp;
-	size_t mem_size;
-	char* mem_data;
-	struct data_control* self;
-};
-
-static char* mime_type = "text/plain;charset=utf-8";
-
-static bool isStringEqual(int lena, char* a, int lenb, char* b) {
-	if (lena != lenb) {
-		return false;
-	}
-
-	// Compare every character
-	for (size_t i = 0; i < lena; ++i) {
-		if (a[i] != b[i]) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-static void on_receive(void* handler)
-{
-	struct receive_context* ctx = aml_get_userdata(handler);
-	int fd = aml_get_fd(handler);
-	assert(ctx->fd == fd);
-
-	char buf[4096];
-
-	ssize_t ret = read(fd, &buf, sizeof(buf));
-	if (ret > 0) {
-		fwrite(&buf, 1, ret, ctx->mem_fp);
-		return;
-	}
-
-	fclose(ctx->mem_fp);
-	ctx->mem_fp = NULL;
-
-	if (ctx->mem_size && ctx->self->vnc_write_clipboard) {
-		// If we receive clipboard data from the VNC server, we set the clipboard of the client.
-		// This "change" of clipboard data results into this "on_receive" event. That would leed
-		// to an endless loop...
-		// So we check if we send exactle that clipboard string to avoid an loop
-		if (!ctx->self->cb_data || !isStringEqual(ctx->self->cb_len, ctx->self->cb_data, strlen(ctx->mem_data), ctx->mem_data)) {
-			//printf("Received data FROM clipboard: %s\n", ctx->mem_data);
-			ctx->self->vnc_write_clipboard(ctx->mem_data, ctx->mem_size);
-		} 
-	}
-
-	aml_stop(aml_get_default(), handler);
-}
-
-static void destroy_receive_context(void* raw_ctx)
-{
-	struct receive_context* ctx = raw_ctx;
-	int fd = ctx->fd;
-
-	if (ctx->mem_fp)
-		fclose(ctx->mem_fp);
-	free(ctx->mem_data);
-	zwlr_data_control_offer_v1_destroy(ctx->offer);
-	close(fd);
-	free(ctx);
-}
-
-static void receive_data(void* data,
-	struct zwlr_data_control_offer_v1* offer)
-{
-	struct data_control* self = data;
-	int pipe_fd[2];
-
-	if (pipe(pipe_fd) == -1) {
-		printf("pipe() failed");
-		return;
-	}
-
-	struct receive_context* ctx = calloc(1, sizeof(*ctx));
-	if (!ctx) {
-		printf("OOM");
-		close(pipe_fd[0]);
-		close(pipe_fd[1]);
-		return;
-	}
-
-	zwlr_data_control_offer_v1_receive(self->offer, mime_type, pipe_fd[1]);
-	//wl_display_flush(self->wl_display);
-	close(pipe_fd[1]);
-
-	ctx->self = self;
-	ctx->fd = pipe_fd[0];
-	//ctx->data_control = self;
-	ctx->offer = self->offer;
-	ctx->mem_fp = open_memstream(&ctx->mem_data, &ctx->mem_size);
-	if (!ctx->mem_fp) {
-		close(ctx->fd);
-		free(ctx);
-		printf("open_memstream() failed");
-		return;
-	}
-
-	struct aml_handler* handler = aml_handler_new(ctx->fd, on_receive,
-			ctx, destroy_receive_context);
-	if (!handler) {
-		close(ctx->fd);
-		free(ctx);
-		return;
-	}
-
-	aml_start(aml_get_default(), handler);
-	aml_unref(handler);
-}
-
-static void data_control_offer(void* data,
-	struct zwlr_data_control_offer_v1* zwlr_data_control_offer_v1,
-	const char* mime_type)
-{
-	struct data_control* self = data;
-
-	if (self->offer)
-		return;
-	if (strcmp(mime_type, mime_type) != 0) {
-		return;
-	}
-
-	self->offer = zwlr_data_control_offer_v1;
-}
-
-struct zwlr_data_control_offer_v1_listener data_control_offer_listener = {
-	data_control_offer
-};
-
-static void data_control_device_offer(void* data,
-	struct zwlr_data_control_device_v1* zwlr_data_control_device_v1,
-	struct zwlr_data_control_offer_v1* id)
-{
-	if (!id)
-		return;
-
-	zwlr_data_control_offer_v1_add_listener(id, &data_control_offer_listener, data);
-}
-
-static void data_control_device_selection(void* data,
-	struct zwlr_data_control_device_v1* zwlr_data_control_device_v1,
-	struct zwlr_data_control_offer_v1* id)
-{
-	struct data_control* self = data;
-	if (id && self->offer == id) {
-		receive_data(data, id);
-		self->offer = NULL;
-	}
-}
-
-static void data_control_device_primary_selection(void* data,
-	struct zwlr_data_control_device_v1* zwlr_data_control_device_v1,
-	struct zwlr_data_control_offer_v1* id)
-{
-	struct data_control* self = data;
-	if (id && self->offer == id) {
-		receive_data(data, id);
-		self->offer = NULL;
-		return;
-	}
-}
-
-static void data_control_device_finished(void* data,
-	struct zwlr_data_control_device_v1* zwlr_data_control_device_v1)
-{
-	zwlr_data_control_device_v1_destroy(zwlr_data_control_device_v1);
-}
-
-static struct zwlr_data_control_device_v1_listener data_control_device_listener = {
-	.data_offer = data_control_device_offer,
-	.selection = data_control_device_selection,
-	.finished = data_control_device_finished,
-	.primary_selection = data_control_device_primary_selection
-};
-
-
-static void
-data_control_source_send(void* data,
-	struct zwlr_data_control_source_v1* zwlr_data_control_source_v1,
-	const char* mime_type,
-	int32_t fd)
-{
-	struct data_control* self = data;
-	char* d = self->cb_data;
-	size_t len = self->cb_len;
-	int ret;
-
-	assert(d);
-
-	ret = write(fd, d, len);
-
-	if (ret < (int)len)
-		printf("write from clipboard incomplete");
-
-	close(fd);
-}
-
-static void data_control_source_cancelled(void* data,
-	struct zwlr_data_control_source_v1* zwlr_data_control_source_v1)
-{
-	struct data_control* self = data;
-
-	if (self->selection == zwlr_data_control_source_v1) {
-		self->selection = NULL;
-	}
-	if (self->primary_selection == zwlr_data_control_source_v1) {
-		self->primary_selection = NULL;
-	}
-	zwlr_data_control_source_v1_destroy(zwlr_data_control_source_v1);
-}
-
-struct zwlr_data_control_source_v1_listener data_control_source_listener = {
-	.send = data_control_source_send,
-	.cancelled = data_control_source_cancelled
-};
-
-static struct zwlr_data_control_source_v1* set_selection(struct data_control* self, bool primary) {
-	struct zwlr_data_control_source_v1* selection;
-	selection = zwlr_data_control_manager_v1_create_data_source(self->manager);
-	if (selection == NULL) {
-		printf("zwlr_data_control_manager_v1_create_data_source() failed");
-		free(self->cb_data);
-		self->cb_data = NULL;
-		return NULL;
-	}
-
-	zwlr_data_control_source_v1_add_listener(selection, &data_control_source_listener, self);
-	zwlr_data_control_source_v1_offer(selection, mime_type);
-
-	if (primary)
-		zwlr_data_control_device_v1_set_primary_selection(self->device, selection);
-	else
-		zwlr_data_control_device_v1_set_selection(self->device, selection);
-
-	return selection;
-}
-
-void data_control_init(struct data_control* self, struct seat* seat, struct zwlr_data_control_manager_v1 *manager) {
-	self->manager = manager;
-	self->device = zwlr_data_control_manager_v1_get_data_device(self->manager, seat->wl_seat);
-	self->cb_data = NULL;
-	self->cb_len = 0;
-
-	zwlr_data_control_device_v1_add_listener(self->device, &data_control_device_listener, self);
-}
-
-void data_control_to_clipboard(struct data_control* self, const char* text, size_t len)
-{
-	//printf("Writing text TO CLIPBOARD: %s\n", text);
-	if (!len) {
-		printf("%s called with 0 length", __func__);
-		return;
-	}
-	if (self->cb_data) {
-		free(self->cb_data);
-	}
-	
-
-	self->cb_data = malloc(len);
-	if (!self->cb_data) {
-		printf("OOM");
-		return;
-	}
-
-	memcpy(self->cb_data, text, len);
-	self->cb_len = len;
-	// Set copy/paste buffer
-	self->selection = set_selection(self, false);
-	// Set highlight/middle_click buffer
-	self->primary_selection = set_selection(self, true);
-}
-
-void data_control_destroy(struct data_control* self)
-{
-	if (self->selection) {
-		zwlr_data_control_source_v1_destroy(self->selection);
-		self->selection = NULL;
-	}
-	if (self->primary_selection) {
-		zwlr_data_control_source_v1_destroy(self->primary_selection);
-		self->primary_selection = NULL;
-	}
-	zwlr_data_control_device_v1_destroy(self->device);
-	free(self->cb_data);
-}

src/main.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 - 2022 Andri Yngvason
+ * Copyright (c) 2020 - 2023 Andri Yngvason
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -42,35 +42,44 @@
 #include "pixels.h"
 #include "region.h"
 #include "buffer.h"
+#include "buffer-pool.h"
 #include "renderer.h"
 #include "renderer-egl.h"
 #include "linux-dmabuf-unstable-v1.h"
 #include "time-util.h"
 #include "output.h"
-#include "data-control.h"
+#include "ntp.h"
+#include "performance.h"
 
 #define CANARY_TICK_PERIOD INT64_C(100000) // us
 #define CANARY_LETHALITY_LEVEL INT64_C(8000) // us
+#define LATENCY_REPORT_PERIOD INT64_C(250000) // us
 
 struct point {
 	double x, y;
 };
 
+TAILQ_HEAD(frame_queue, buffer);
+
 struct window {
 	struct wl_surface* wl_surface;
 	struct xdg_surface* xdg_surface;
 	struct xdg_toplevel* xdg_toplevel;
 
-	struct buffer* buffers[3];
+	struct buffer_pool* buffers;
 	struct buffer* back_buffer;
-	int buffer_index;
 
 	struct pixman_region16 current_damage;
 
+	struct buffer_pool* frame_pool;
+	struct frame_queue frame_queue;
+
 	struct vnc_client* vnc;
 	void* vnc_fb;
 
 	bool is_frame_committed;
+	bool is_frame_callback_registered;
+	bool is_not_first_frame;
 };
 
 static void register_frame_callback(void);
@@ -88,9 +97,8 @@ struct pointer_collection* pointers;
 struct keyboard_collection* keyboards;
 static int drm_fd = -1;
 static uint64_t last_canary_tick;
-static struct data_control* data_control;
-static struct zwlr_data_control_manager_v1 *manager;
-static struct vnc_client* vnc;
+static struct ntp_client ntp;
+static struct perf perf;
 
 static bool have_egl = false;
 
@@ -118,9 +126,6 @@ static void on_seat_capability_change(struct seat* seat)
 		struct wl_keyboard* wl_keyboard =
 			wl_seat_get_keyboard(seat->wl_seat);
 		keyboard_collection_add_wl_keyboard(keyboards, wl_keyboard);
-
-		data_control = malloc(sizeof(data_control));
-		data_control_init(data_control, seat, manager);
 	} else {
 		// TODO Remove
 	}
@@ -162,8 +167,6 @@ static void registry_add(void* data, struct wl_registry* registry, uint32_t id,
 		}
 
 		wl_list_insert(&outputs, &output->link);
-	} else if (strcmp(interface, zwlr_data_control_manager_v1_interface.name) == 0) {
-		manager = wl_registry_bind(registry, id, &zwlr_data_control_manager_v1_interface, 2);
 	}
 }
 
@@ -247,8 +250,10 @@ void on_wayland_event(void* obj)
 		}
 	}
 
-	if (wl_display_dispatch_pending(wl_display) < 0)
+	if (wl_display_dispatch_pending(wl_display) < 0) {
 		fprintf(stderr, "Failed to dispatch pending\n");
+		abort();
+	}
 }
 
 static int init_wayland_event_handler(void)
@@ -283,7 +288,7 @@ static int init_signal_handler(void)
 
 static void window_attach(struct window* w, int x, int y)
 {
-	w->back_buffer->is_attached = true;
+	buffer_hold(w->back_buffer);
 	wl_surface_attach(w->wl_surface, w->back_buffer->wl_buffer, x, y);
 	wl_surface_set_buffer_scale(window->wl_surface,
 			window->back_buffer->scale);
@@ -374,8 +379,9 @@ static void window_commit(struct window* w)
 
 static void window_swap(struct window* w)
 {
-	w->buffer_index = (w->buffer_index + 1) % 3;
-	w->back_buffer = w->buffers[w->buffer_index];
+	buffer_unref(w->back_buffer);
+	w->back_buffer = buffer_pool_acquire(w->buffers);
+	buffer_ref(w->back_buffer);
 }
 
 static void window_damage(struct window* w, int x, int y, int width, int height)
@@ -405,24 +411,19 @@ static void window_resize(struct window* w, int width, int height, int scale)
 	if (width == 0 || height == 0 || scale == 0)
 		return;
 
-	if (w->back_buffer && w->back_buffer->width == width &&
-			w->back_buffer->height == height &&
-			w->back_buffer->scale == scale)
-		return;
-
-	for (int i = 0; i < 3; ++i)
-		buffer_destroy(w->buffers[i]);
-
-	for (int i = 0; i < 3; ++i) {
-		w->buffers[i] = have_egl
-			? buffer_create_dmabuf(scale * width, scale * height,
-					dmabuf_format)
-			: buffer_create_shm(scale * width, scale * height,
-					scale * 4 * width, shm_format);
-		w->buffers[i]->scale = scale;
+	uint32_t format = have_egl ? dmabuf_format : shm_format;
+	if (!w->buffers) {
+		enum buffer_type type = have_egl ? BUFFER_DMABUF : BUFFER_WL_SHM;
+		w->buffers = buffer_pool_create(type, scale * width,
+				scale * height, format, scale * 4 * width,
+				scale);
+	} else {
+		buffer_pool_resize(w->buffers, scale * width, scale * height,
+				format, scale * 4 * width, scale);
 	}
 
-	w->back_buffer = w->buffers[0];
+	w->back_buffer = buffer_pool_acquire(w->buffers);
+	buffer_ref(w->back_buffer);
 }
 
 static void xdg_toplevel_configure(void* data, struct xdg_toplevel* toplevel,
@@ -483,9 +484,8 @@ wl_surface_failure:
 
 static void window_destroy(struct window* w)
 {
-	for (int i = 0; i < 3; ++i)
-		buffer_destroy(w->buffers[i]);
-
+	buffer_unref(w->back_buffer);
+	buffer_pool_destroy(w->buffers);
 	free(w->vnc_fb);
 	xdg_toplevel_destroy(w->xdg_toplevel);
 	xdg_surface_destroy(w->xdg_surface);
@@ -569,6 +569,8 @@ int on_vnc_client_alloc_fb(struct vnc_client* client)
 		window = window_create(app_id, vnc_client_get_desktop_name(client));
 		window->vnc = client;
 
+		TAILQ_INIT(&window->frame_queue);
+
 		int32_t scale = output_list_get_max_scale(&outputs);
 		window_resize(window, width, height, scale);
 	}
@@ -596,9 +598,7 @@ static void get_frame_damage(struct vnc_client* client,
 
 static void apply_buffer_damage(struct pixman_region16* damage)
 {
-	for (int i = 0; i < 3; ++i)
-		pixman_region_union(&window->buffers[i]->damage,
-				&window->buffers[i]->damage, damage);
+	buffer_pool_damage_all(window->buffers, damage);
 }
 
 static void window_damage_region(struct window* w,
@@ -617,6 +617,20 @@ static void window_damage_region(struct window* w,
 	}
 }
 
+static void update_frame_latency_stats(void)
+{
+	uint32_t server_pts = window->vnc->pts;
+
+	uint32_t client_pts = 0;
+	if (!ntp_client_translate_server_time(&ntp, &client_pts, server_pts))
+		return;
+
+	uint32_t now = gettime_us();
+	int32_t latency = (int32_t)(now - client_pts);
+
+	perf_sample_buffer_add(perf.frame_latency, latency);
+}
+
 static void render_from_vnc(void)
 {
 	if (!pixman_region_not_empty(&window->current_damage) &&
@@ -626,9 +640,6 @@ static void render_from_vnc(void)
 	if (window->is_frame_committed)
 		return;
 
-	if (window->back_buffer->is_attached)
-		fprintf(stderr, "Oops, back-buffer is still attached.\n");
-
 	window_attach(window, 0, 0);
 
 	double scale;
@@ -662,18 +673,98 @@ static void render_from_vnc(void)
 	window_commit(window);
 	window_swap(window);
 
+	update_frame_latency_stats();
+
 	pixman_region_clear(&window->current_damage);
 	vnc_client_clear_av_frames(window->vnc);
 }
 
-void on_vnc_client_update_fb(struct vnc_client* client)
+void on_vnc_client_update_fb_immediate(struct vnc_client* client)
 {
 	get_frame_damage(window->vnc, &window->current_damage);
 	render_from_vnc();
 }
 
-static void handle_frame_callback(void* data, struct wl_callback* callback,
-		uint32_t time)
+void on_vnc_client_update_fb_queued(struct vnc_client* client)
+{
+	struct window* w = window;
+	struct pixman_region16 damage;
+	pixman_region_init(&damage);
+
+	get_frame_damage(w->vnc, &damage);
+	if (!pixman_region_not_empty(&damage)) {
+		return;
+	}
+
+	int width = vnc_client_get_width(client);
+	int height = vnc_client_get_height(client);
+	int stride = vnc_client_get_stride(client);
+
+	if (!w->frame_pool) {
+		// TODO: Delete this pool somewhere
+		enum buffer_type type = have_egl ? BUFFER_DMABUF : BUFFER_WL_SHM;
+		uint32_t format = have_egl ? dmabuf_format : shm_format;
+		int scale = 1;
+		w->frame_pool = buffer_pool_create(type, width, height, format,
+				stride, scale);
+	}
+
+	struct buffer* frame = buffer_pool_acquire(w->frame_pool);
+	assert(frame);
+
+	// TODO: Implement damage tracking
+	pixman_region_union_rect(&damage, &damage, 0, 0, frame->width, frame->height);
+
+	buffer_pool_damage_all(w->frame_pool, &damage);
+
+	if (!w->is_not_first_frame) {
+		w->is_not_first_frame = true;
+		pixman_region_union(&w->current_damage, &w->current_damage,
+				&damage);
+		render_from_vnc();
+	}
+
+	if (w->vnc->n_av_frames != 0) {
+		assert(have_egl);
+
+		render_av_frames_egl(frame, w->vnc->av_frames,
+				w->vnc->n_av_frames, 1.0, 0, 0);
+	} else {
+		struct image image = {
+			.pixels = w->vnc_fb,
+			.width = width,
+			.height = height,
+			.stride = stride,
+			// TODO: Get the format from the vnc module
+			.format = frame->format,
+			.damage = &frame->damage,
+		};
+
+		if (have_egl)
+			render_image_egl(frame, &image, 1.0, 0, 0);
+		else
+			render_image(frame, &image, 1.0, 0, 0);
+	}
+
+	uint32_t pts;
+	if (ntp_client_translate_server_time(&ntp, &pts, client->pts)) {
+		frame->pts = pts;
+	} else {
+		frame->pts = gettime_us();
+	}
+
+	buffer_ref(frame);
+	buffer_hold(frame);
+	TAILQ_INSERT_TAIL(&window->frame_queue, frame, queue_link);
+
+	register_frame_callback();
+
+	pixman_region_fini(&damage);
+	vnc_client_clear_av_frames(window->vnc);
+}
+
+static void handle_frame_callback_immediate(void* data,
+		struct wl_callback* callback, uint32_t time)
 {
 	wl_callback_destroy(callback);
 	window->is_frame_committed = false;
@@ -682,14 +773,129 @@ static void handle_frame_callback(void* data, struct wl_callback* callback,
 		render_from_vnc();
 }
 
-static const struct wl_callback_listener frame_listener = {
-	.done = handle_frame_callback
+static const struct wl_callback_listener frame_listener_immediate = {
+	.done = handle_frame_callback_immediate
 };
 
+static int32_t abs32(int32_t v)
+{
+	return v >= 0 ? v : -v;
+}
+
+static struct buffer* choose_frame(struct window* w)
+{
+	int32_t delay = 0;
+
+	struct ntp_sample best_sample;
+	if (ntp_client_get_best_sample(&ntp, &best_sample)) {
+		// Half rtt + jitter
+		delay = ntp_client_get_jitter(&ntp) + best_sample.theta / 2;
+	}
+
+	int32_t now_us = gettime_us();
+
+	int32_t smallest_diff = INT32_MAX;
+	struct buffer* chosen_frame = NULL;
+	struct buffer* frame;
+	TAILQ_FOREACH(frame, &w->frame_queue, queue_link) {
+		int32_t diff = abs32(now_us - (frame->pts + delay));
+		if (diff >= smallest_diff) {
+			continue;
+		}
+
+		smallest_diff = diff;
+		chosen_frame = frame;
+	}
+
+	return chosen_frame;
+}
+
+// TODO: Discard all queued frames on exit
+static void discard_older_frames(struct window* w, struct buffer* chosen)
+{
+	while (!TAILQ_EMPTY(&w->frame_queue)) {
+		struct buffer* frame = TAILQ_FIRST(&w->frame_queue);
+		int32_t diff = frame->pts - chosen->pts;
+		if (diff >= 0) {
+			return;
+		}
+
+		pixman_region_union(&chosen->damage, &chosen->damage,
+				&frame->damage);
+
+		TAILQ_REMOVE(&w->frame_queue, frame, queue_link);
+		buffer_release(frame);
+		buffer_unref(frame);
+	}
+}
+
+static void handle_frame_callback_queued(void* data,
+		struct wl_callback* callback, uint32_t time)
+{
+	wl_callback_destroy(callback);
+	window->is_frame_callback_registered = false;
+
+	struct buffer* frame = choose_frame(window);
+	if (!frame)
+		return;
+
+	discard_older_frames(window, frame);
+	pixman_region_union(&window->current_damage, &window->current_damage,
+			&frame->damage);
+
+	// TODO: Try not to render frames that are already rendered.
+
+	window_attach(window, 0, 0);
+
+	register_frame_callback();
+
+	// TODO: Consolidate all this scaling and translating
+	double scale;
+	int x_pos, y_pos;
+	window_calculate_transform(window, &scale, &x_pos, &y_pos);
+
+	struct pixman_region16 damage_scaled = { 0 }, buffer_damage = { 0 },
+			       surface_damage = { 0 };
+	region_scale(&damage_scaled, &window->current_damage, scale);
+	region_translate(&buffer_damage, &damage_scaled, x_pos, y_pos);
+	pixman_region_clear(&damage_scaled);
+
+	double output_scale = output_list_get_max_scale(&outputs);
+	struct point scoord = buffer_coord_to_surface_coord(x_pos, y_pos);
+	region_scale(&damage_scaled, &window->current_damage,
+			scale / output_scale);
+	region_translate(&surface_damage, &damage_scaled, scoord.x, scoord.y);
+	pixman_region_fini(&damage_scaled);
+
+	apply_buffer_damage(&buffer_damage);
+	window_damage_region(window, &surface_damage);
+
+	pixman_region_fini(&surface_damage);
+	pixman_region_fini(&buffer_damage);
+
+	// TODO: Implement software rendering
+	render_buffer_egl(window->back_buffer, frame, scale, x_pos, y_pos);
+
+	window_commit(window);
+	window_swap(window);
+
+	pixman_region_clear(&window->current_damage);
+}
+
+static const struct wl_callback_listener frame_listener_queued = {
+	.done = handle_frame_callback_queued
+};
+
+// TODO: Maybe try avoid leaking the callback on exit
 static void register_frame_callback(void)
 {
+	if (window->is_frame_callback_registered)
+		return;
+	window->is_frame_callback_registered = true;
+
 	struct wl_callback* callback = wl_surface_frame(window->wl_surface);
-	wl_callback_add_listener(callback, &frame_listener, NULL);
+	//wl_callback_add_listener(callback, &frame_listener_immediate, NULL);
+	wl_callback_add_listener(callback, &frame_listener_queued, NULL);
 }
 
 void on_vnc_client_event(void* obj)
@@ -813,6 +1019,18 @@ static void on_canary_tick(void* obj)
 				delay);
 }
 
+static void send_ntp_ping(struct ntp_client* ntp_client, uint32_t t0,
+		uint32_t t1, uint32_t t2, uint32_t t3)
+{
+	vnc_client_send_ntp_event(window->vnc, t0, t1, t2, t3);
+}
+
+static void on_ntp_event(struct vnc_client* vnc, uint32_t t0, uint32_t t1,
+		uint32_t t2, uint32_t t3)
+{
+	ntp_client_process_pong(&ntp, t0, t1, t2, t3);
+}
+
 static void create_canary_ticker(void)
 {
 	last_canary_tick = gettime_us();
@@ -824,8 +1042,20 @@ static void create_canary_ticker(void)
 	aml_unref(ticker);
 }
 
-static void vnc_send_clipboard(char* text, size_t size) {
-	vnc_client_send_cut_text(vnc, text, size);
+static void on_latency_report_tick(void* handler)
+{
+	(void)handler;
+
+	perf_dump_latency_report(&perf);
+}
+
+static void create_latency_report_ticker(void)
+{
+	struct aml* aml = aml_get_default();
+	struct aml_ticker* ticker = aml_ticker_new(LATENCY_REPORT_PERIOD,
+			on_latency_report_tick, NULL, NULL);
+	aml_start(aml, ticker);
+	aml_unref(ticker);
 }
 
 void run_main_loop_once(void)
@@ -977,13 +1207,16 @@ int main(int argc, char* argv[])
 	wl_display_roundtrip(wl_display);
 	wl_display_roundtrip(wl_display);
 
-	vnc = vnc_client_create(data_control);
+	struct vnc_client* vnc = vnc_client_create();
 	if (!vnc)
 		goto vnc_failure;
 
+	vnc->userdata = window;
+
 	vnc->alloc_fb = on_vnc_client_alloc_fb;
-	vnc->update_fb = on_vnc_client_update_fb;
-	data_control->vnc_write_clipboard = vnc_send_clipboard;
+	//vnc->update_fb = on_vnc_client_update_fb_immediate;
+	vnc->update_fb = on_vnc_client_update_fb_queued;
+	vnc->ntp_event = on_ntp_event;
 
 	if (vnc_client_set_pixel_format(vnc, shm_format) < 0) {
 		fprintf(stderr, "Unsupported pixel format\n");
@@ -1022,12 +1255,16 @@ int main(int argc, char* argv[])
 		goto vnc_setup_failure;
 	}
 
+	perf_init(&perf);
+	ntp_client_init(&ntp, send_ntp_ping, window);
+
 	pointers->userdata = vnc;
 	keyboards->userdata = vnc;
 
 	wl_display_dispatch(wl_display);
 
 	create_canary_ticker();
+	//create_latency_report_ticker();
 
 	while (do_run)
 		run_main_loop_once();
@@ -1035,6 +1272,10 @@ int main(int argc, char* argv[])
 	rc = 0;
 	if (window)
 		window_destroy(window);
+
+	ntp_client_deinit(&ntp);
+	perf_deinit(&perf);
+
 vnc_setup_failure:
 	vnc_client_destroy(vnc);
 vnc_failure:
@@ -1063,9 +1304,5 @@ display_failure:
 signal_handler_failure:
 	aml_unref(aml);
 	printf("Exiting...\n");
-
-	// @TODO this will throw an segfault (can't determine proxy version, but why?)
-	if (data_control)
-		data_control_destroy(data_control);
 	return rc;
 }

src/ntp.c

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2023 Andri Yngvason
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "ntp.h"
+#include "time-util.h"
+
+#include <assert.h>
+#include <aml.h>
+#include <stdio.h>
+
+static inline int32_t clamp_to_zero(int32_t v)
+{
+	return v >= 0 ? v : 0;
+}
+
+void ntp_client__tick(void* handler)
+{
+	struct ntp_client* self = aml_get_userdata(handler);
+	assert(self);
+	assert(self->send_ping);
+
+	uint32_t t0 = gettime_us();
+	self->send_ping(self, t0, 0, 0, 0);
+}
+
+int ntp_client_init(struct ntp_client* self, ntp_client_ping_fn send_ping,
+		void* userdata)
+{
+	self->send_ping = send_ping;
+	self->userdata = userdata;
+
+	struct aml_ticker* ticker = aml_ticker_new(NTP_SAMPLE_PERIOD,
+			ntp_client__tick, self, NULL);
+	if (!ticker)
+		return -1;
+
+	int rc = aml_start(aml_get_default(), ticker);
+	if (rc >= 0)
+		self->ping_ticker = ticker;
+	else
+		aml_unref(ticker);
+
+	return rc;
+}
+
+void ntp_client_deinit(struct ntp_client* self)
+{
+	if (self->ping_ticker) {
+		aml_stop(aml_get_default(), self->ping_ticker);
+		aml_unref(self->ping_ticker);
+	}
+}
+
+void ntp_client_process_pong(struct ntp_client* self, uint32_t t0, uint32_t t1,
+                uint32_t t2, uint32_t t3)
+{
+	t3 = gettime_us();
+
+	int32_t theta = ((int32_t)(t1 - t0) + (int32_t)(t2 - t3)) / 2;
+	uint32_t delta = clamp_to_zero((int32_t)(t3 - t0) - (int32_t)(t2 - t1));
+
+	struct ntp_sample sample = {
+		.theta = theta,
+		.delta = delta,
+	};
+
+	self->samples[self->sample_index] = sample;
+	self->sample_index = (self->sample_index + 1) % NTP_SAMPLE_SIZE;
+
+	if (self->sample_count < NTP_SAMPLE_SIZE)
+		self->sample_count++;
+
+//	printf("%.3f %.3f\n", delta / 1e3, theta / 1e3);
+}
+
+bool ntp_client_get_best_sample(const struct ntp_client* self,
+		struct ntp_sample* out)
+{
+	if (self->sample_count < NTP_MIN_SAMPLE_COUNT)
+		return false;
+
+	struct ntp_sample result = {
+		.theta = 0,
+		.delta = UINT32_MAX,
+	};
+
+	for (int i = 0; i < self->sample_count; ++i) {
+		const struct ntp_sample *sample = &self->samples[i];
+		if (sample->delta < result.delta) {
+			result = *sample;
+		}
+	}
+
+	*out = result;
+	return true;
+}
+
+bool ntp_client_translate_server_time(const struct ntp_client* self,
+		uint32_t* dst, const uint32_t t)
+{
+	struct ntp_sample sample;
+	if (!ntp_client_get_best_sample(self, &sample))
+		return false;
+
+	*dst = (int32_t)t - sample.theta;
+	return true;
+}
+
+uint32_t ntp_client_get_jitter(const struct ntp_client* self)
+{
+	uint32_t max_delta = 0;
+	for (int i = 0; i < self->sample_count; ++i) {
+		const struct ntp_sample *sample = &self->samples[i];
+		if (sample->delta > max_delta) {
+			max_delta = sample->delta;
+		}
+	}
+	return max_delta;
+}

src/open-h264.c

@@ -153,9 +153,6 @@ static void reset_all_contexts(struct open_h264* self)
 
 struct open_h264* open_h264_create(rfbClient* client)
 {
-	// Use this to enable debug logs
-	// av_log_set_level(AV_LOG_DEBUG);
-
 	struct open_h264* self = calloc(1, sizeof(*self));
 	if (!self)
 		return NULL;

src/performance.c

@@ -0,0 +1,72 @@
+#include "performance.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+struct perf_sample_buffer* perf_sample_buffer_create(int length)
+{
+	struct perf_sample_buffer* self = malloc(sizeof(*self)
+			+ length * sizeof(self->samples[0]));
+	self->count = 0;
+	self->index = 0;
+	self->length = length;
+	return self;
+}
+
+void perf_sample_buffer_add(struct perf_sample_buffer* self, double sample)
+{
+	self->samples[self->index] = sample;
+	self->index = (self->index + 1) % self->length;
+	if (self->count < self->length)
+		self->count += 1;
+}
+
+void perf_sample_buffer_get_stats(const struct perf_sample_buffer* self,
+		struct perf_sample_stats* stats)
+{
+	memset(stats, 0, sizeof(*stats));
+
+	double sum = 0;
+	double minimum = INFINITY;
+	double maximum = 0;
+
+	for (int i = 0; i < self->count; ++i) {
+		double sample = self->samples[i];
+
+		sum += sample;
+
+		if (sample < minimum)
+			minimum = sample;
+
+		if (sample > maximum)
+			maximum = sample;
+	}
+
+	stats->min = minimum;
+	stats->max = maximum;
+	stats->average = sum / (double)self->count;
+}
+
+void perf_init(struct perf* self)
+{
+	memset(self, 0, sizeof(*self));
+
+	self->frame_latency =
+		perf_sample_buffer_create(PERF_FRAME_LATENCY_SAMPLE_SIZE);
+}
+
+void perf_deinit(struct perf* self)
+{
+	free(self->frame_latency);
+}
+
+void perf_dump_latency_report(const struct perf* self)
+{
+	struct perf_sample_stats stats;
+	perf_sample_buffer_get_stats(self->frame_latency, &stats);
+
+	printf("Latency report: frame-latency (min, avg, max): %.1f, %.1f, %.1f\n",
+			stats.min / 1e3, stats.average / 1e3, stats.max / 1e3);
+}

src/renderer-egl.c

@@ -374,6 +374,47 @@ static GLuint texture_from_av_frame(const struct AVFrame* frame)
 	return tex;
 }
 
+static GLuint texture_from_buffer(const struct buffer* buffer)
+{
+	int index = 0;
+	EGLint attr[128];
+
+	append_attr(attr, &index, EGL_WIDTH, buffer->width);
+	append_attr(attr, &index, EGL_HEIGHT, buffer->height);
+	append_attr(attr, &index, EGL_LINUX_DRM_FOURCC_EXT, buffer->format);
+	append_attr(attr, &index, EGL_IMAGE_PRESERVED_KHR, EGL_TRUE);
+
+	struct gbm_bo* bo = buffer->bo;
+	int fd = gbm_bo_get_fd(bo);
+
+	append_attr(attr, &index, plane_fd_key(0), fd);
+	append_attr(attr, &index, plane_offset_key(0), gbm_bo_get_offset(bo, 0));
+	append_attr(attr, &index, plane_pitch_key(0), gbm_bo_get_stride(bo));
+
+	uint64_t mod = gbm_bo_get_modifier(buffer->bo);
+	append_attr(attr, &index, plane_modifier_lo_key(0), mod & UINT32_MAX);
+	append_attr(attr, &index, plane_modifier_hi_key(0), mod >> 32);
+
+	attr[index++] = EGL_NONE;
+
+	EGLImageKHR image = eglCreateImageKHR(egl_display, EGL_NO_CONTEXT,
+				EGL_LINUX_DMA_BUF_EXT, NULL, attr);
+	assert(image != EGL_NO_IMAGE_KHR);
+
+	GLuint tex = 0;
+	glGenTextures(1, &tex);
+
+	glBindTexture(GL_TEXTURE_EXTERNAL_OES, tex);
+
+	glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, image);
+
+	eglDestroyImageKHR(egl_display, image);
+
+	glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
+	close(fd);
+	return tex;
+}
+
 void gl_draw(void)
 {
 	static const GLfloat s_vertices[4][2] = {
@@ -542,3 +583,42 @@ void render_av_frames_egl(struct buffer* dst, struct vnc_av_frame** src,
 
 	pixman_region_clear(&dst->damage);
 }
+
+void render_buffer_egl(struct buffer* dst, const struct buffer* src,
+		double scale, int x_pos, int y_pos)
+{
+	struct fbo_info fbo;
+	fbo_from_gbm_bo(&fbo, dst->bo);
+
+	// Make sure we've completed drawing into the source buffer:
+	glFinish();
+
+	glBindFramebuffer(GL_FRAMEBUFFER, fbo.fbo);
+
+	struct pixman_box16* ext = pixman_region_extents(&dst->damage);
+	glScissor(ext->x1, ext->y1, ext->x2 - ext->x1, ext->y2 - ext->y1);
+	glEnable(GL_SCISSOR_TEST);
+
+	glUseProgram(shader_program_ext);
+
+	int width = round((double)src->width * scale);
+	int height = round((double)src->height * scale);
+	glViewport(x_pos, y_pos, width, height);
+
+	GLuint tex = texture_from_buffer(src);
+	glBindTexture(GL_TEXTURE_EXTERNAL_OES, tex);
+
+	gl_draw();
+
+	glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
+
+	glDisable(GL_SCISSOR_TEST);
+
+	glFlush();
+
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glDeleteFramebuffers(1, &fbo.fbo);
+	glDeleteRenderbuffers(1, &fbo.rbo);
+
+	pixman_region_clear(&dst->damage);
+}

src/rfbproto.c

@@ -524,34 +524,10 @@ static rfbBool ReadSupportedSecurityType(rfbClient* client, uint32_t* result,
 static rfbBool HandleVncAuth(rfbClient* client)
 {
 	uint8_t challenge[CHALLENGESIZE];
-	char* passwd = NULL;
-	int i;
 
 	if (!ReadFromRFBServer(client, (char*)challenge, CHALLENGESIZE))
 		return FALSE;
 
-	if (client->GetPassword)
-		passwd = client->GetPassword(client);
-
-	if ((!passwd) || (strlen(passwd) == 0)) {
-		rfbClientLog("Reading password failed\n");
-		return FALSE;
-	}
-	if (strlen(passwd) > 8) {
-		passwd[8] = '\0';
-	}
-
-	rfbClientEncryptBytes(challenge, passwd);
-
-	/* Lose the password from memory */
-	for (i = strlen(passwd); i >= 0; i--) {
-		passwd[i] = '\0';
-	}
-	free(passwd);
-
-	if (!WriteToRFBServer(client, (char*)challenge, CHALLENGESIZE))
-		return FALSE;
-
 	/* Handle the SecurityResult message */
 	if (!rfbHandleAuthResult(client))
 		return FALSE;
@@ -1420,7 +1396,11 @@ rfbBool SetFormatAndEncodings(rfbClient* client)
 
 	/* pts */
 	if (se->nEncodings < MAX_ENCODINGS)
-		encs[se->nEncodings++] = rfbClientSwap32IfLE(-1000);
+		encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingPts);
+
+	/* ntp */
+	if (se->nEncodings < MAX_ENCODINGS)
+		encs[se->nEncodings++] = rfbClientSwap32IfLE(rfbEncodingNtp);
 
 	len = sz_rfbSetEncodingsMsg + se->nEncodings * 4;
 
@@ -1766,6 +1746,22 @@ rfbBool SendClientCutText(rfbClient* client, char* str, int len)
 	        WriteToRFBServer(client, str, len));
 }
 
+rfbBool SendClientNtpEvent(rfbClient* client, uint32_t t0, uint32_t t1,
+		uint32_t t2, uint32_t t3)
+{
+	if (!SupportsClient2Server(client, rfbNtpEvent))
+		return FALSE;
+
+	struct rfbNtpMsg msg = {
+		.type = rfbNtpEvent,
+		.t0 = rfbClientSwap32IfLE(t0),
+		.t1 = rfbClientSwap32IfLE(t1),
+		.t2 = rfbClientSwap32IfLE(t2),
+		.t3 = rfbClientSwap32IfLE(t3),
+	};
+	return WriteToRFBServer(client, (char*)&msg, sizeof(msg));
+}
+
 static rfbBool HandleFramebufferUpdate(rfbClient* client,
                                        rfbServerToClientMsg* msg)
 {
@@ -2324,6 +2320,10 @@ static rfbBool HandleFramebufferUpdate(rfbClient* client,
 			SetClient2Server(client, rfbQemuEvent);
 			break;
 
+		case rfbEncodingNtp:
+			SetClient2Server(client, rfbNtpEvent);
+			break;
+
 		default: {
 			rfbBool handled = FALSE;
 			rfbClientProtocolExtension* e;
@@ -2363,6 +2363,22 @@ failure:
 	return FALSE;
 }
 
+rfbBool handleNtpEvent(rfbClient* client, struct rfbNtpMsg* msg)
+{
+	if (!ReadFromRFBServer(client, (char*)msg + 1, sizeof(*msg) - 1))
+		return FALSE;
+
+	uint32_t t0 = rfbClientSwap32IfLE(msg->t0);
+	uint32_t t1 = rfbClientSwap32IfLE(msg->t1);
+	uint32_t t2 = rfbClientSwap32IfLE(msg->t2);
+	uint32_t t3 = rfbClientSwap32IfLE(msg->t3);
+
+	if (client->NtpEvent)
+		client->NtpEvent(client, t0, t1, t2, t3);
+
+	return TRUE;
+}
+
 /*
  * HandleRFBServerMessage.
  */
@@ -2551,6 +2567,9 @@ rfbBool HandleRFBServerMessage(rfbClient* client)
 		break;
 	}
 
+	case rfbNtpEvent:
+		return handleNtpEvent(client, &msg.ntp);
+
 	default: {
 		rfbBool handled = FALSE;
 		rfbClientProtocolExtension* e;

src/tls_gnutls.c

@@ -25,7 +25,7 @@
 #include <gnutls/x509.h>
 #include <errno.h>
 
-static const char *rfbTLSPriority = "NORMAL:+DHE-DSS:+RSA:+DHE-RSA";
+static const char *rfbTLSPriority = "NORMAL:+DHE-DSS:+RSA:+DHE-RSA:+SRP";
 static const char *rfbAnonTLSPriority= "NORMAL:+ANON-DH";
 
 #define DH_BITS 1024
@@ -112,13 +112,12 @@ verify_certificate_callback (gnutls_session_t session)
       return GNUTLS_E_CERTIFICATE_ERROR;
     }
 
-  // Hostname verification does NOT work
-  //if (!gnutls_x509_crt_check_hostname (cert, hostname))
-  //  {
-  //    rfbClientLog("The certificate's owner does not match hostname '%s'\n",
-  //            hostname);
-  //    return GNUTLS_E_CERTIFICATE_ERROR;
-  //  }
+  if (!gnutls_x509_crt_check_hostname (cert, hostname))
+    {
+      rfbClientLog("The certificate's owner does not match hostname '%s'\n",
+              hostname);
+      return GNUTLS_E_CERTIFICATE_ERROR;
+    }
 
   gnutls_x509_crt_deinit (cert);
 
@@ -338,9 +337,6 @@ FreeX509Credential(rfbCredential *cred)
 static gnutls_certificate_credentials_t
 CreateX509CertCredential(rfbCredential *cred)
 {
-  // Use this to enable debug logs
-  //gnutls_global_set_log_level(GNUTLS_DEBUG_LEVEL);
-
   gnutls_certificate_credentials_t x509_cred;
   int ret;
 

src/vnc.c

@@ -23,8 +23,6 @@
 #include <pixman.h>
 #include <libdrm/drm_fourcc.h>
 #include <libavutil/frame.h>
-#include <stdio.h>
-#include <data-control.h>
 
 #include "rfbclient.h"
 #include "vnc.h"
@@ -136,9 +134,16 @@ static void vnc_client_got_cut_text(rfbClient* client, const char* text,
 
 	if (self->cut_text)
 		self->cut_text(self, text, len);
-	else {
-		printf("Cut text is not defined!\n");
 }
+
+static void vnc_client_ntp_event(rfbClient* client, uint32_t t0, uint32_t t1,
+		uint32_t t2, uint32_t t3)
+{
+	struct vnc_client* self = rfbClientGetClientData(client, NULL);
+	assert(self);
+
+	if (self->ntp_event)
+		self->ntp_event(self, t0, t1, t2, t3);
 }
 
 static rfbBool vnc_client_handle_open_h264_rect(rfbClient* client,
@@ -221,7 +226,7 @@ static void vnc_client_init_pts_ext(void)
 	rfbClientRegisterExtension(&ext);
 }
 
-struct vnc_client* vnc_client_create(struct data_control* data_control)
+struct vnc_client* vnc_client_create(void)
 {
 	vnc_client_init_open_h264();
 	vnc_client_init_pts_ext();
@@ -243,7 +248,6 @@ struct vnc_client* vnc_client_create(struct data_control* data_control)
 		goto failure;
 
 	self->client = client;
-	self->data_control = data_control;
 	rfbClientSetClientData(client, NULL, self);
 
 	client->MallocFrameBuffer = vnc_client_alloc_fb;
@@ -252,13 +256,10 @@ struct vnc_client* vnc_client_create(struct data_control* data_control)
 	client->StartingFrameBufferUpdate = vnc_client_start_update;
 	client->CancelledFrameBufferUpdate = vnc_client_cancel_update;
 	client->GotXCutText = vnc_client_got_cut_text;
-	self->cut_text = cut_text;
+	client->NtpEvent = vnc_client_ntp_event;
 
 	self->pts = NO_PTS;
 
-	// Handle authentication
-	client->GetCredential = handle_vnc_authentication;
-
 	return self;
 
 failure:
@@ -266,36 +267,6 @@ failure:
 	return NULL;
 }
 
-rfbCredential* handle_vnc_authentication(struct _rfbClient *client, int credentialType) {
-	rfbCredential* creds = (rfbCredential*) malloc(sizeof(rfbCredential));
-
-	if (client->authScheme == rfbVeNCrypt && credentialType == rfbCredentialTypeX509) {
-		char* path = getenv("TLS_CA");
-		rfbClientLog("Using TLS CA certificate from env 'TLS_CA': %s\n", path);
-
-		creds->x509Credential.x509CACertFile = malloc(strlen(path) + 1);
-		strcpy(creds->x509Credential.x509CACertFile, path);
-		creds->x509Credential.x509CrlVerifyMode = rfbX509CrlVerifyAll;
-	} else if (client->authScheme == rfbVeNCrypt && credentialType == rfbCredentialTypeUser) {
-		const* username = getenv("VNC_USERNAME");
-		const* password =  getenv("VNC_PASSWORD");
-		rfbClientLog("Using username and password for VNC authentication 'VNC_USERNAME', 'VNC_PASSWORD'\n");
-
-    	creds->userCredential.password = malloc(strlen(password) + 1);
-		creds->userCredential.username = malloc(strlen(username) + 1);
-		strcpy(creds->userCredential.password, password);
-		strcpy(creds->userCredential.username, username);
-	} else {
-
-	}
-	return creds;
-}
-
-void cut_text (struct vnc_client* self, const char* text, size_t size) {
-	data_control_to_clipboard(self->data_control, text, size);
-	//printf("Received string FROM vnc_server: %s\n", text);
-}
-
 void vnc_client_destroy(struct vnc_client* self)
 {
 	vnc_client_clear_av_frames(self);
@@ -483,3 +454,9 @@ void vnc_client_send_cut_text(struct vnc_client* self, const char* text,
 	// libvncclient doesn't modify text, so typecast is OK.
 	SendClientCutText(self->client, (char*)text, len);
 }
+
+void vnc_client_send_ntp_event(struct vnc_client* self, uint32_t t0,
+                uint32_t t1, uint32_t t2, uint32_t t3)
+{
+	SendClientNtpEvent(self->client, t0, t1, t2, t3);
+}