[porthole] fix invalid pointer dereference

This is known as 'introspection' in the gnif/qemu repo, it's name is not
final, however porthole is more appropriate but also may not be the
final name.

Note: This branch is experiemental and may never be released if QEMU do
not accept the patch for the new device upstream.

.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: gnif
-patreon: gnif
-open_collective: # Replace with a single Open Collective username
-ko_fi: lookingglass
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/issue_template.md

@@ -8,4 +8,4 @@ Host QEMU version:
 
 Please describe what were you doing when the problem occured. If the Windows host application crashed please check for file named `looking-glass-host.dmp` and attach it to this bug report.
 
-**Reports that do not include this information will be ignored and closed**
+**Reports that do no include this information will be ignored and closed**

.gitignore

@@ -7,4 +7,3 @@ module/modules.order
 *.a
 *.o
 *.exe
-*/build

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "LGMP"]
-	path = repos/LGMP
-	url = https://github.com/gnif/LGMP.git
-[submodule "repos/PureSpice"]
-	path = repos/PureSpice
-	url = https://github.com/gnif/PureSpice

README.md

@@ -1,19 +1,14 @@
 # Looking Glass
 
-An extremely low latency KVMFR (KVM FrameRelay) implementation for guests with
-VGA PCI Passthrough.
+An extremely low latency KVMFR (KVM FrameRelay) implementation for guests with VGA PCI Passthrough.
 
 * Project Website: https://looking-glass.hostfission.com
 
 ## Donations
 
-I (Geoffrey McRae) am the primary developer behind this project and I have
-invested thousands of hours of development time into it.
+I (Geoffrey McRae) am the primary developer behind this project and I have invested thousands of hours of development time into it.
+If you like this project and find it useful and would like to help out you can support me directly using the following platforms.
 
-If you like this project and find it useful and would like to help out you can
-support me directly using the following platforms.
-
-* [GitHub](https://github.com/sponsors/gnif)
 * [Ko-Fi](https://ko-fi.com/lookingglass)
 * [Patreon](https://www.patreon.com/gnif)
 * [Paypal](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=ESQ72XUPGKXRY)
@@ -21,25 +16,19 @@ support me directly using the following platforms.
 
 ## Documentation
 
-** IMPORTANT **
-This project contains submodules that must be checked out if building from the
-git repository!
-
 Please also be sure to see the following files for more information
 
 * [client/README.md](client/README.md)
-* [host/README.md](host/README.md)
+* [c-host/README.md](c-host/README.md)
 * [module/README.md](module/README.md)
 
 ## Obtaining and using Looking Glass
 
-Please see https://looking-glass.hostfission.com/wiki/
+Please see https://looking-glass.hostfission.com/quickstart
 
 ## Latest Version
 
-If you would like to use the latest bleeding edge version of Looking Glass please
-be aware there will be no support at this time.
-
+If you would like to use the latest bleeding edge version of Looking Glass please be aware there will be no support at this time.
 Latest bleeding edge builds of the Windows host application can be obtained from:
 
 https://looking-glass.hostfission.com/downloads

VERSION

@@ -1 +1 @@
-B2-rc3-33-gdc4d1d49fa+1
+B1-43-g83047cbc3e+1

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

arbiter/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.0)
-project(profiler-client C)
+project(looking-glass-arbiter C)
 
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
 
@@ -29,38 +29,34 @@ set(EXE_FLAGS "-Wl,--gc-sections")
 set(CMAKE_C_STANDARD 11)
 
 execute_process(
-	COMMAND			cat ../../VERSION
+	COMMAND			cat ../VERSION
 	WORKING_DIRECTORY	${PROJECT_SOURCE_DIR}
 	OUTPUT_VARIABLE		BUILD_VERSION
 	OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 
 add_definitions(-D BUILD_VERSION='"${BUILD_VERSION}"')
-get_filename_component(PROJECT_TOP "${PROJECT_SOURCE_DIR}/../.." ABSOLUTE)
+get_filename_component(PROJECT_TOP "${PROJECT_SOURCE_DIR}/.." ABSOLUTE)
 
 include_directories(
 	${PROJECT_SOURCE_DIR}/include
 	${CMAKE_BINARY_DIR}/include
 )
 
-link_libraries(
-	rt
-	m
-)
-
 set(SOURCES
 	src/main.c
 )
 
-add_subdirectory("${PROJECT_TOP}/common"          "${CMAKE_BINARY_DIR}/common")
-add_subdirectory("${PROJECT_TOP}/repos/LGMP/lgmp" "${CMAKE_BINARY_DIR}/lgmp"  )
+add_subdirectory("${PROJECT_TOP}/common" "${CMAKE_BINARY_DIR}/common")
+add_subdirectory("${PROJECT_TOP}/porthole" "${CMAKE_BINARY_DIR}/porthole")
 
-add_executable(profiler-client ${SOURCES})
-target_compile_options(profiler-client PUBLIC ${PKGCONFIG_CFLAGS_OTHER})
-target_link_libraries(profiler-client
+add_executable(looking-glass-arbiter ${SOURCES})
+target_link_libraries(looking-glass-arbiter
 	${EXE_FLAGS}
 	lg_common
-	lgmp
+	porthole
 )
 
+install(PROGRAMS ${CMAKE_BINARY_DIR}/looking-glass-arbiter DESTINATION bin/ COMPONENT binary)
+
 feature_summary(WHAT ENABLED_FEATURES DISABLED_FEATURES)

arbiter/src/main.c

@@ -0,0 +1,55 @@
+#include "common/debug.h"
+#include "common/option.h"
+#include "porthole/client.h"
+
+static struct Option options[] =
+{
+  // app options
+  {
+    .module         = "host",
+    .name           = "socket",
+    .description    = "The porthole host socket",
+    .type           = OPTION_TYPE_STRING,
+    .value.x_string = "/var/tmp/porthole",
+  },
+  {0}
+};
+
+static void map_event(uint32_t type, PortholeMap * map)
+{
+  DEBUG_INFO("map_event: %u, %u, %u", type, map->id, map->size);
+}
+
+static void unmap_event(uint32_t id)
+{
+  DEBUG_INFO("unmap_event: %u", id);
+}
+
+static void discon_event()
+{
+  DEBUG_INFO("discon_event");
+}
+
+int main(int argc, char * argv[])
+{
+  option_register(options);
+  if (!option_parse(argc, argv))
+    return -1;
+
+  if (!option_validate())
+    return -1;
+
+  PortholeClient phc;
+  if (!porthole_client_open(
+        &phc,
+        option_get_string("host", "socket"),
+        map_event,
+        unmap_event,
+        discon_event))
+  {
+    return -1;
+  }
+
+  porthole_client_close(&phc);
+  return 0;
+}

c-host/CMakeLists.txt

@@ -41,6 +41,7 @@ get_filename_component(PROJECT_TOP "${PROJECT_SOURCE_DIR}/.." ABSOLUTE)
 include_directories(
 	${PROJECT_SOURCE_DIR}/include
 	${CMAKE_BINARY_DIR}/include
+        ${PROJECT_TOP}/vendor/ivshmem
 	${PKGCONFIG_INCLUDE_DIRS}
 	${GMP_INCLUDE_DIR}
 )
@@ -52,8 +53,7 @@ set(SOURCES
 	src/app.c
 )
 
-add_subdirectory("${PROJECT_TOP}/common"          "${CMAKE_BINARY_DIR}/common")
-add_subdirectory("${PROJECT_TOP}/repos/LGMP/lgmp" "${CMAKE_BINARY_DIR}/lgmp"  )
+add_subdirectory("${PROJECT_TOP}/common" "${CMAKE_BINARY_DIR}/common")
 add_subdirectory(platform)
 
 if(WIN32)
@@ -64,7 +64,6 @@ endif()
 target_link_libraries(looking-glass-host
 	lg_common
 	platform
-	lgmp
 )
 set_target_properties(looking-glass-host PROPERTIES LINK_FLAGS "-Wl,--gc-sections")
 install(PROGRAMS ${CMAKE_BINARY_DIR}/looking-glass-host DESTINATION bin/ COMPONENT binary)

c-host/README.md

@@ -2,26 +2,37 @@
 
 ## What is this?
 
-The Looking Glass Host application for the Guest Virtual Machine.
+This is a rewrite of the host application in pure C using the MinGW toolchain.
 
-## What platforms does this support?
+## Why make this?
 
-Currently only Windows is supported however there is some initial support for Linux at this time.
+Several reasons:
+
+1. The client is written in C and I would like to unify the project's language
+2. The host is currently hard to build using MinGW and is very Windows specific
+3. The host is a jumbled mess of code from all the experimentation going on
+4. I would eventually like to be able to port this to run on Linux guests
+
+## When will it be ready?
+
+Soon :)
+
+## Will it replace the C++ host?
+
+Yes, but only when it is feature complete.
+
+## Why doesn't this use CMake?
+
+It does now...
+~~Because win-builds doesn't distribute it, so to make it easy for everyone to compile we do not require it.~~
 
 ## How do I build it?
 
 #### For Windows on Windows
 
-1. download and install msys2 x86_64 from http://www.msys2.org/ following the setup instructions provided
-3. execute `pacman -Fy` and then `pacman -Sy git make mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake`
-4. run "C:\msys64\mingw64.exe"
-5. checkout the project
-  `git clone https://github.com/gnif/LookingGlass.git`
-6. configure the project and build it
-
 ```
-mkdir LookingGlass/c-host/build
-cd LookingGlass/c-host/build
+mkdir build
+cd build
 cmake -G "MSYS Makefiles" ..
 make
 ```
@@ -44,46 +55,17 @@ cmake -DCMAKE_TOOLCHAIN_FILE=../toolchain-mingw64.cmake ..
 make
 ```
 
-## Building the Windows installer
-
-Install NSIS compiler
-Build the host program, see above sections.
-Build installer with `makensis platform/Windows/installer.nsi`
-The resulting installer will be at
-`platform/Windows/looking-glass-host-setup.exe`
-
 ## Where is the log?
 
 It is in your user's temp directory:
 
     %TEMP%\looking-glass-host.txt
 
-Or if running as a system service it will be located in:
+For example:
 
-    C:\Windows\Temp\looking-glass-host.txt
+    C:\Users\YourUser\AppData\Local\Temp\looking-glass-host.txt
 
-You can find out where the file is by right clicking on the tray icon and
-selecting "Log File Location"
-
-### High priority capture using DXGI and Secure Desktop (UAC) capture support
-
-By default Windows gives priority to the foreground application for any GPU
-work which causes issues with capture if the foreground application is consuming
-100% of the available GPU resources. The looking glass host application is able
-to increase the kernel GPU thread to realtime priority which fixes this, but in
-order to do so it must run as the `SYSTEM` user account. To do this, Looking
-Glass needs to run as a service. This can be accomplished by either using the
-NSIS installer which will do this for you, or you can use the following command
-to Install the service manually:
-
-    looking-glass-host.exe InstallService
-
-To remove the service use the following command:
-
-    looking-glass-host.exe UninstallService
-
-This will also enable the host application to capture the secure desktop which
-includes things like the lock screen and UAC prompts.
+You can also open it by simply right clicking the tray icon and selecting "Open Log File"
 
 ## Why does this version require Administrator privileges
 

c-host/include/interface/capture.h

@@ -61,7 +61,6 @@ CaptureFrame;
 
 typedef struct CapturePointer
 {
-  bool          positionUpdate;
   int           x, y;
   bool          visible;
 
@@ -72,27 +71,21 @@ typedef struct CapturePointer
 }
 CapturePointer;
 
-typedef bool (*CaptureGetPointerBuffer )(void ** data, uint32_t * size);
-typedef void (*CapturePostPointerBuffer)(CapturePointer pointer);
-
 typedef struct CaptureInterface
 {
   const char *  (*getName        )();
   void          (*initOptions    )();
 
-  bool(*create)(
-    CaptureGetPointerBuffer  getPointerBufferFn,
-    CapturePostPointerBuffer postPointerBufferFn
-  );
-
-  bool          (*init           )();
+  bool          (*create         )();
+  bool          (*init           )(void * pointerShape, const unsigned int pointerSize);
   void          (*stop           )();
   bool          (*deinit         )();
   void          (*free           )();
   unsigned int  (*getMaxFrameSize)();
 
   CaptureResult (*capture   )();
-  CaptureResult (*waitFrame )(CaptureFrame * frame);
-  CaptureResult (*getFrame  )(FrameBuffer  * frame);
+  CaptureResult (*waitFrame )(CaptureFrame   * frame  );
+  CaptureResult (*getFrame  )(FrameBuffer      frame  );
+  CaptureResult (*getPointer)(CapturePointer * pointer);
 }
-CaptureInterface;
+CaptureInterface;

c-host/include/interface/platform.h

@@ -0,0 +1,54 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#pragma once
+
+#include <stdbool.h>
+
+int  app_main(int argc, char * argv[]);
+bool app_init();
+void app_quit();
+
+// these must be implemented for each OS
+const char * os_getExecutable();
+
+unsigned int os_shmemSize();
+bool         os_shmemMmap(void **ptr);
+void         os_shmemUnmap();
+
+// os specific thread functions
+
+typedef struct osThreadHandle osThreadHandle;
+typedef int (*osThreadFunction)(void * opaque);
+
+bool         os_createThread(const char * name, osThreadFunction function, void * opaque, osThreadHandle ** handle);
+bool         os_joinThread  (osThreadHandle * handle, int * resultCode);
+
+// os specific event functions
+
+#define TIMEOUT_INFINITE ((unsigned int)~0)
+
+typedef struct osEventHandle osEventHandle;
+
+osEventHandle * os_createEvent(bool autoReset);
+void            os_freeEvent  (osEventHandle * handle);
+bool            os_waitEvent  (osEventHandle * handle, unsigned int timeout);
+bool            os_waitEvents (osEventHandle * handles[], int count, bool waitAll, unsigned int timeout);
+bool            os_signalEvent(osEventHandle * handle);
+bool            os_resetEvent (osEventHandle * handle);

c-host/platform/Linux/capture/XCB/src/xcb.c

@@ -20,7 +20,6 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include "interface/capture.h"
 #include "interface/platform.h"
 #include "common/debug.h"
-#include "common/event.h"
 #include <string.h>
 #include <assert.h>
 #include <stdlib.h>
@@ -38,7 +37,7 @@ struct xcb
   uint32_t           seg;
   int                shmID;
   void             * data;
-  LGEvent          * frameEvent;
+  osEventHandle    * frameEvent;
 
   unsigned int width;
   unsigned int height;
@@ -68,7 +67,7 @@ static bool xcb_create()
   this             = (struct xcb *)calloc(sizeof(struct xcb), 1);
   this->shmID      = -1;
   this->data       = (void *)-1;
-  this->frameEvent = lgCreateEvent(true, 20);
+  this->frameEvent = os_createEvent(true);
 
   if (!this->frameEvent)
   {
@@ -85,7 +84,7 @@ static bool xcb_init()
   assert(this);
   assert(!this->initialized);
 
-  lgResetEvent(this->frameEvent);
+  os_resetEvent(this->frameEvent);
 
   this->xcb = xcb_connect(NULL, NULL);
   if (!this->xcb || xcb_connection_has_error(this->xcb))
@@ -159,7 +158,7 @@ static bool xcb_deinit()
 
 static void xcb_free()
 {
-  lgFreeEvent(this->frameEvent);
+  os_freeEvent(this->frameEvent);
   free(this);
   this = NULL;
 }
@@ -188,29 +187,20 @@ static CaptureResult xcb_capture()
         0);
 
     this->hasFrame  = true;
-    lgSignalEvent(this->frameEvent);
+    os_signalEvent(this->frameEvent);
   }
 
   return CAPTURE_RESULT_OK;
 }
 
-static CaptureResult xcb_waitFrame(CaptureFrame * frame)
-{
-  lgWaitEvent(this->frameEvent, TIMEOUT_INFINITE);
-
-  frame->width  = this->width;
-  frame->height = this->height;
-  frame->pitch  = this->width * 4;
-  frame->stride = this->width;
-  frame->format = CAPTURE_FMT_BGRA;
-
-  return CAPTURE_RESULT_OK;
-}
-
-static CaptureResult xcb_getFrame(FrameBuffer frame)
+static CaptureResult xcb_getFrame(CaptureFrame * frame)
 {
   assert(this);
   assert(this->initialized);
+  assert(frame);
+  assert(frame->data);
+
+  os_waitEvent(this->frameEvent, TIMEOUT_INFINITE);
 
   xcb_shm_get_image_reply_t * img;
   img = xcb_shm_get_image_reply(this->xcb, this->imgC, NULL);
@@ -220,7 +210,12 @@ static CaptureResult xcb_getFrame(FrameBuffer frame)
     return CAPTURE_RESULT_ERROR;
   }
 
-  framebuffer_write(frame, this->data, this->width * this->height * 4);
+  frame->width  = this->width;
+  frame->height = this->height;
+  frame->pitch  = this->width * 4;
+  frame->stride = this->width;
+  frame->format = CAPTURE_FMT_BGRA;
+  memcpy(frame->data, this->data, this->width * this->height * 4);
   free(img);
 
   this->hasFrame = false;
@@ -242,7 +237,6 @@ struct CaptureInterface Capture_XCB =
   .free            = xcb_free,
   .getMaxFrameSize = xcb_getMaxFrameSize,
   .capture         = xcb_capture,
-  .waitFrame       = xcb_waitFrame,
   .getFrame        = xcb_getFrame,
   .getPointer      = xcb_getPointer
 };

c-host/platform/Linux/src/platform.c

@@ -0,0 +1,453 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "interface/platform.h"
+#include "common/debug.h"
+#include "common/option.h"
+
+#include <assert.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <signal.h>
+#include <errno.h>
+
+struct app
+{
+  const char  * executable;
+  unsigned int  shmSize;
+  int           shmFD;
+  void        * shmMap;
+};
+
+static struct app app;
+
+struct osThreadHandle
+{
+  const char       * name;
+  osThreadFunction   function;
+  void             * opaque;
+  pthread_t          handle;
+  int                resultCode;
+};
+
+void sigHandler(int signo)
+{
+  DEBUG_INFO("SIGINT");
+  app_quit();
+}
+
+static int uioOpenFile(const char * shmDevice, const char * file)
+{
+  int    len  = snprintf(NULL, 0, "/sys/class/uio/%s/%s", shmDevice, file);
+  char * path = malloc(len + 1);
+  sprintf(path, "/sys/class/uio/%s/%s", shmDevice, file);
+
+  int fd = open(path, O_RDONLY);
+  if (fd < 0)
+  {
+    free(path);
+    return -1;
+  }
+
+  free(path);
+  return fd;
+}
+
+static char * uioGetName(const char * shmDevice)
+{
+  int fd = uioOpenFile(shmDevice, "name");
+  if (fd < 0)
+    return NULL;
+
+  char * name = malloc(32);
+  int len = read(fd, name, 31);
+  if (len <= 0)
+  {
+    free(name);
+    close(fd);
+    return NULL;
+  }
+  name[len] = '\0';
+  close(fd);
+
+  while(len > 0 && name[len-1] == '\n')
+  {
+    --len;
+    name[len] = '\0';
+  }
+
+  return name;
+}
+
+static int shmOpenDev(const char * shmDevice)
+{
+  int    len  = snprintf(NULL, 0, "/dev/%s", shmDevice);
+  char * path = malloc(len + 1);
+  sprintf(path, "/dev/%s", shmDevice);
+
+  int fd = open(path, O_RDWR, (mode_t)0600);
+  if (fd < 0)
+  {
+    DEBUG_ERROR("Failed to open: %s", path);
+    DEBUG_ERROR("Did you remmeber to modprobe the kvmfr module?");
+    free(path);
+    return -1;
+  }
+
+  free(path);
+  return fd;
+}
+
+static bool shmDeviceValidator(struct Option * opt, const char ** error)
+{
+  char * name = uioGetName(opt->value.x_string);
+  if (!name)
+  {
+    *error = "Failed to get the uio device name";
+    return false;
+  }
+
+  if (strcmp(name, "KVMFR") != 0)
+  {
+    free(name);
+    *error = "Device is not a KVMFR device";
+    return false;
+  }
+
+  free(name);
+  return true;
+}
+
+static StringList shmDeviceGetValues(struct Option * option)
+{
+  StringList sl = stringlist_new(true);
+
+  DIR * d = opendir("/sys/class/uio");
+  if (!d)
+    return sl;
+
+  struct dirent * dir;
+  while((dir = readdir(d)) != NULL)
+  {
+    if (dir->d_name[0] == '.')
+      continue;
+
+    char * name = uioGetName(dir->d_name);
+    if (!name)
+      continue;
+
+    if (strcmp(name, "KVMFR") == 0)
+      stringlist_push(sl, strdup(dir->d_name));
+
+    free(name);
+  }
+
+  closedir(d);
+  return sl;
+}
+
+int main(int argc, char * argv[])
+{
+  app.executable = argv[0];
+
+  struct Option options[] =
+  {
+    {
+      .module         = "os",
+      .name           = "shmDevice",
+      .description    = "The IVSHMEM device to use",
+      .type           = OPTION_TYPE_STRING,
+      .value.x_string = "uio0",
+      .validator      = shmDeviceValidator,
+      .getValues      = shmDeviceGetValues
+    },
+    {0}
+  };
+
+  option_register(options);
+
+  int result = app_main(argc, argv);
+  os_shmemUnmap();
+  close(app.shmFD);
+
+  return result;
+}
+
+bool app_init()
+{
+  const char * shmDevice = option_get_string("os", "shmDevice");
+
+  // get the device size
+  int fd = uioOpenFile(shmDevice, "maps/map0/size");
+  if (fd < 0)
+  {
+    DEBUG_ERROR("Failed to open %s/size", shmDevice);
+    DEBUG_ERROR("Did you remmeber to modprobe the kvmfr module?");
+    return false;
+  }
+
+  char size[32];
+  int  len = read(fd, size, sizeof(size) - 1);
+  if (len <= 0)
+  {
+    DEBUG_ERROR("Failed to read the device size");
+    close(fd);
+    return false;
+  }
+  size[len] = '\0';
+  close(fd);
+
+  app.shmSize = strtoul(size, NULL, 16);
+
+  // open the device
+  app.shmFD  = shmOpenDev(shmDevice);
+  app.shmMap = MAP_FAILED;
+  if (app.shmFD < 0)
+    return false;
+
+  DEBUG_INFO("KVMFR Device     : %s", shmDevice);
+
+  signal(SIGINT, sigHandler);
+  return true;
+}
+
+const char * os_getExecutable()
+{
+  return app.executable;
+}
+
+unsigned int os_shmemSize()
+{
+  return app.shmSize;
+}
+
+bool os_shmemMmap(void **ptr)
+{
+  if (app.shmMap == MAP_FAILED)
+  {
+    app.shmMap = mmap(0, app.shmSize, PROT_READ | PROT_WRITE, MAP_SHARED, app.shmFD, 0);
+    if (app.shmMap == MAP_FAILED)
+    {
+      const char * shmDevice = option_get_string("os", "shmDevice");
+      DEBUG_ERROR("Failed to map the shared memory device: %s", shmDevice);
+      return false;
+    }
+  }
+
+  *ptr = app.shmMap;
+  return true;
+}
+
+void os_shmemUnmap()
+{
+  if (app.shmMap == MAP_FAILED)
+    return;
+
+  munmap(app.shmMap, app.shmSize);
+  app.shmMap = MAP_FAILED;
+}
+
+static void * threadWrapper(void * opaque)
+{
+  osThreadHandle * handle = (osThreadHandle *)opaque;
+  handle->resultCode = handle->function(handle->opaque);
+  return NULL;
+}
+
+bool os_createThread(const char * name, osThreadFunction function, void * opaque, osThreadHandle ** handle)
+{
+  *handle = (osThreadHandle*)malloc(sizeof(osThreadHandle));
+  (*handle)->name     = name;
+  (*handle)->function = function;
+  (*handle)->opaque   = opaque;
+
+  if (pthread_create(&(*handle)->handle, NULL, threadWrapper, *handle) != 0)
+  {
+    DEBUG_ERROR("pthread_create failed for thread: %s", name);
+    free(*handle);
+    *handle = NULL;
+    return false;
+  }
+  return true;
+}
+
+bool os_joinThread(osThreadHandle * handle, int * resultCode)
+{
+  if (pthread_join(handle->handle, NULL) != 0)
+  {
+    DEBUG_ERROR("pthread_join failed for thread: %s", handle->name);
+    free(handle);
+    return false;
+  }
+
+  if (resultCode)
+    *resultCode = handle->resultCode;
+
+  free(handle);
+  return true;
+}
+
+struct osEventHandle
+{
+  pthread_mutex_t mutex;
+  pthread_cond_t  cond;
+  bool            flag;
+  bool            autoReset;
+};
+
+osEventHandle * os_createEvent(bool autoReset)
+{
+  osEventHandle * handle = (osEventHandle *)calloc(sizeof(osEventHandle), 1);
+  if (!handle)
+  {
+    DEBUG_ERROR("Failed to allocate memory");
+    return NULL;
+  }
+
+  if (pthread_mutex_init(&handle->mutex, NULL) != 0)
+  {
+    DEBUG_ERROR("Failed to create the mutex");
+    free(handle);
+    return NULL;
+  }
+
+  if (pthread_cond_init(&handle->cond, NULL) != 0)
+  {
+    pthread_mutex_destroy(&handle->mutex);
+    free(handle);
+    return NULL;
+  }
+
+  handle->autoReset = autoReset;
+
+  return handle;
+}
+
+void os_freeEvent(osEventHandle * handle)
+{
+  assert(handle);
+
+  pthread_cond_destroy (&handle->cond );
+  pthread_mutex_destroy(&handle->mutex);
+  free(handle);
+}
+
+bool os_waitEvent(osEventHandle * handle, unsigned int timeout)
+{
+  assert(handle);
+
+  if (pthread_mutex_lock(&handle->mutex) != 0)
+  {
+    DEBUG_ERROR("Failed to lock the mutex");
+    return false;
+  }
+
+  while(!handle->flag)
+  {
+    if (timeout == TIMEOUT_INFINITE)
+    {
+      if (pthread_cond_wait(&handle->cond, &handle->mutex) != 0)
+      {
+        DEBUG_ERROR("Wait to wait on the condition");
+        return false;
+      }
+    }
+    else
+    {
+      struct timespec ts;
+      ts.tv_sec  = timeout / 1000;
+      ts.tv_nsec = (timeout % 1000) * 1000000;
+      switch(pthread_cond_timedwait(&handle->cond, &handle->mutex, &ts))
+      {
+        case ETIMEDOUT:
+          return false;
+
+        default:
+          DEBUG_ERROR("Timed wait failed");
+          return false;
+      }
+    }
+  }
+
+  if (handle->autoReset)
+    handle->flag = false;
+
+  if (pthread_mutex_unlock(&handle->mutex) != 0)
+  {
+    DEBUG_ERROR("Failed to unlock the mutex");
+    return false;
+  }
+
+  return true;
+}
+
+bool os_signalEvent(osEventHandle * handle)
+{
+  assert(handle);
+
+  if (pthread_mutex_lock(&handle->mutex) != 0)
+  {
+    DEBUG_ERROR("Failed to lock the mutex");
+    return false;
+  }
+
+  handle->flag = true;
+
+  if (pthread_mutex_unlock(&handle->mutex) != 0)
+  {
+    DEBUG_ERROR("Failed to unlock the mutex");
+    return false;
+  }
+
+  if (pthread_cond_signal(&handle->cond) != 0)
+  {
+    DEBUG_ERROR("Failed to signal the condition");
+    return false;
+  }
+
+  return true;
+}
+
+bool os_resetEvent(osEventHandle * handle)
+{
+  assert(handle);
+
+  if (pthread_mutex_lock(&handle->mutex) != 0)
+  {
+    DEBUG_ERROR("Failed to lock the mutex");
+    return false;
+  }
+
+  handle->flag = false;
+
+  if (pthread_mutex_unlock(&handle->mutex) != 0)
+  {
+    DEBUG_ERROR("Failed to unlock the mutex");
+    return false;
+  }
+
+  return true;
+}

c-host/platform/Windows/CMakeLists.txt

@@ -7,7 +7,7 @@ include_directories(
 
 add_library(platform_Windows STATIC
 	src/platform.c
-	src/service.c
+	src/windebug.c
 	src/mousehook.c
 )
 
@@ -24,19 +24,10 @@ target_link_libraries(platform_Windows
 	"${PROJECT_BINARY_DIR}/resource.o"
 	lg_common
 	capture
-
-	userenv
-	wtsapi32
-	psapi
+	setupapi
 )
 
 target_include_directories(platform_Windows
 	PRIVATE
 		src
 )
-
-# these are for the nsis installer generator
-configure_file("${PROJECT_SOURCE_DIR}/installer.nsi" "${PROJECT_BINARY_DIR}/installer.nsi" COPYONLY)
-configure_file("${PROJECT_TOP}/resources/icon.ico"   "${PROJECT_BINARY_DIR}/icon.ico"      COPYONLY)
-configure_file("${PROJECT_TOP}/VERSION"              "${PROJECT_BINARY_DIR}/VERSION"       COPYONLY)
-configure_file("${PROJECT_TOP}/LICENSE"              "${PROJECT_BINARY_DIR}/LICENSE.txt"   COPYONLY)

c-host/platform/Windows/capture/DXGI/src/dxgi.c

@@ -20,10 +20,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include "interface/capture.h"
 #include "interface/platform.h"
 #include "common/debug.h"
-#include "common/windebug.h"
 #include "common/option.h"
-#include "common/locking.h"
-#include "common/event.h"
+#include "windows/debug.h"
 
 #include <assert.h>
 #include <dxgi.h>
@@ -32,20 +30,6 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include "dxgi_extra.h"
 
-typedef enum _D3DKMT_SCHEDULINGPRIORITYCLASS
-{
-  D3DKMT_SCHEDULINGPRIORITYCLASS_IDLE,
-  D3DKMT_SCHEDULINGPRIORITYCLASS_BELOW_NORMAL,
-  D3DKMT_SCHEDULINGPRIORITYCLASS_NORMAL,
-  D3DKMT_SCHEDULINGPRIORITYCLASS_ABOVE_NORMAL,
-  D3DKMT_SCHEDULINGPRIORITYCLASS_HIGH,
-  D3DKMT_SCHEDULINGPRIORITYCLASS_REALTIME
-}
-D3DKMT_SCHEDULINGPRIORITYCLASS;
-typedef NTSTATUS WINAPI (*PD3DKMTSetProcessSchedulingPriorityClass)(HANDLE, D3DKMT_SCHEDULINGPRIORITYCLASS);
-
-#define LOCKED(x) INTERLOCKED_SECTION(this->deviceContextLock, x)
-
 enum TextureState
 {
   TEXTURE_STATE_UNUSED,
@@ -58,36 +42,41 @@ typedef struct Texture
   enum TextureState          state;
   ID3D11Texture2D          * tex;
   D3D11_MAPPED_SUBRESOURCE   map;
+  osEventHandle            * mapped;
+  osEventHandle            * free;
 }
 Texture;
 
+typedef struct Pointer
+{
+  unsigned int  version;
+
+  unsigned int  x, y;
+  unsigned int  w, h;
+  bool          visible;
+  unsigned int  pitch;
+  CaptureFormat format;
+}
+Pointer;
+
 // locals
 struct iface
 {
   bool                       initialized;
-  LARGE_INTEGER              perfFreq;
-  LARGE_INTEGER              frameTime;
   bool                       stop;
-  HDESK                      desktop;
   IDXGIFactory1            * factory;
   IDXGIAdapter1            * adapter;
   IDXGIOutput              * output;
   ID3D11Device             * device;
   ID3D11DeviceContext      * deviceContext;
-  LG_Lock                    deviceContextLock;
-  bool                       useAcquireLock;
   D3D_FEATURE_LEVEL          featureLevel;
   IDXGIOutputDuplication   * dup;
   int                        maxTextures;
   Texture                  * texture;
   int                        texRIndex;
   int                        texWIndex;
-  volatile int               texReady;
   bool                       needsRelease;
-
-  CaptureGetPointerBuffer    getPointerBufferFn;
-  CapturePostPointerBuffer   postPointerBufferFn;
-  LGEvent                  * frameEvent;
+  osEventHandle            * pointerEvent;
 
   unsigned int  width;
   unsigned int  height;
@@ -95,8 +84,14 @@ struct iface
   unsigned int  stride;
   CaptureFormat format;
 
-  int  lastPointerX, lastPointerY;
-  bool lastPointerVisible;
+  // pointer state
+  Pointer lastPointer;
+  Pointer pointer;
+
+  // pointer shape
+  void         * pointerShape;
+  unsigned int   pointerSize;
+  unsigned int   pointerUsed;
 };
 
 static bool           dpiDone = false;
@@ -139,20 +134,13 @@ static void dxgi_initOptions()
       .type           = OPTION_TYPE_INT,
       .value.x_int    = 3
     },
-    {
-      .module         = "dxgi",
-      .name           = "useAcquireLock",
-      .description    = "Enable locking around `AcquireFrame` (EXPERIMENTAL, leave enabled if you're not sure!)",
-      .type           = OPTION_TYPE_BOOL,
-      .value.x_bool   = true
-    },
     {0}
   };
 
   option_register(options);
 }
 
-static bool dxgi_create(CaptureGetPointerBuffer getPointerBufferFn, CapturePostPointerBuffer postPointerBufferFn)
+static bool dxgi_create()
 {
   assert(!this);
   this = calloc(sizeof(struct iface), 1);
@@ -162,10 +150,10 @@ static bool dxgi_create(CaptureGetPointerBuffer getPointerBufferFn, CapturePostP
     return false;
   }
 
-  this->frameEvent = lgCreateEvent(true, 17); // 60Hz = 16.7ms
-  if (!this->frameEvent)
+  this->pointerEvent = os_createEvent(true);
+  if (!this->pointerEvent)
   {
-    DEBUG_ERROR("failed to create the frame event");
+    DEBUG_ERROR("failed to create the pointer event");
     free(this);
     return false;
   }
@@ -174,38 +162,14 @@ static bool dxgi_create(CaptureGetPointerBuffer getPointerBufferFn, CapturePostP
   if (this->maxTextures <= 0)
     this->maxTextures = 1;
 
-  this->useAcquireLock      = option_get_bool("dxgi", "useAcquireLock");
-  this->texture             = calloc(sizeof(struct Texture), this->maxTextures);
-  this->getPointerBufferFn  = getPointerBufferFn;
-  this->postPointerBufferFn = postPointerBufferFn;
+  this->texture = calloc(sizeof(struct Texture), this->maxTextures);
   return true;
 }
 
-static bool dxgi_init()
+static bool dxgi_init(void * pointerShape, const unsigned int pointerSize)
 {
   assert(this);
 
-  this->desktop = OpenInputDesktop(0, FALSE, GENERIC_READ);
-  if (!this->desktop)
-    DEBUG_WINERROR("Failed to open the desktop", GetLastError());
-  else
-  {
-    if (!SetThreadDesktop(this->desktop))
-    {
-      DEBUG_WINERROR("Failed to set thread desktop", GetLastError());
-      CloseDesktop(this->desktop);
-      this->desktop = NULL;
-    }
-  }
-
-  if (!this->desktop)
-  {
-    DEBUG_INFO("The above error(s) will prevent LG from being able to capture the secure desktop (UAC dialogs)");
-    DEBUG_INFO("This is not a failure, please do not report this as an issue.");
-    DEBUG_INFO("To fix this, install and run the Looking Glass host as a service.");
-    DEBUG_INFO("looking-glass-host.exe InstallService");
-  }
-
   // this is required for DXGI 1.5 support to function
   if (!dpiDone)
   {
@@ -225,12 +189,13 @@ static bool dxgi_init()
   HRESULT          status;
   DXGI_OUTPUT_DESC outputDesc;
 
-  this->stop       = false;
-  this->texRIndex  = 0;
-  this->texWIndex  = 0;
-  this->texReady   = 0;
+  this->pointerShape = pointerShape;
+  this->pointerSize  = pointerSize;
+  this->pointerUsed  = 0;
 
-  lgResetEvent(this->frameEvent  );
+  this->stop      = false;
+  this->texRIndex = 0;
+  this->texWIndex = 0;
 
   status = CreateDXGIFactory1(&IID_IDXGIFactory1, (void **)&this->factory);
   if (FAILED(status))
@@ -247,12 +212,7 @@ static bool dxgi_init()
     if (optAdapter)
     {
       DXGI_ADAPTER_DESC1 adapterDesc;
-      status = IDXGIAdapter1_GetDesc1(this->adapter, &adapterDesc);
-      if (FAILED(status))
-      {
-        DEBUG_WINERROR("Failed to get the device description", status);
-        goto fail;
-      }
+      IDXGIAdapter1_GetDesc1(this->adapter, &adapterDesc);
 
       const size_t s = (wcslen(adapterDesc.Description)+1) * 2;
       char * desc = malloc(s);
@@ -314,18 +274,7 @@ static bool dxgi_init()
     goto fail;
   }
 
-  static const D3D_FEATURE_LEVEL win8[] =
-  {
-    D3D_FEATURE_LEVEL_11_1,
-    D3D_FEATURE_LEVEL_11_0,
-    D3D_FEATURE_LEVEL_10_1,
-    D3D_FEATURE_LEVEL_10_0,
-    D3D_FEATURE_LEVEL_9_3,
-    D3D_FEATURE_LEVEL_9_2,
-    D3D_FEATURE_LEVEL_9_1
-  };
-
-  static const D3D_FEATURE_LEVEL win10[] =
+  static const D3D_FEATURE_LEVEL featureLevels[] =
   {
     D3D_FEATURE_LEVEL_12_1,
     D3D_FEATURE_LEVEL_12_0,
@@ -338,19 +287,6 @@ static bool dxgi_init()
     D3D_FEATURE_LEVEL_9_1
   };
 
-  const D3D_FEATURE_LEVEL * featureLevels;
-  unsigned int featureLevelCount;
-  if (IsWindows8())
-  {
-    featureLevels     = win8;
-    featureLevelCount = sizeof(win8) / sizeof(D3D_FEATURE_LEVEL);
-  }
-  else
-  {
-    featureLevels     = win10;
-    featureLevelCount = sizeof(win10) / sizeof(D3D_FEATURE_LEVEL);
-  }
-
   IDXGIAdapter * tmp;
   status = IDXGIAdapter1_QueryInterface(this->adapter, &IID_IDXGIAdapter, (void **)&tmp);
   if (FAILED(status))
@@ -364,14 +300,12 @@ static bool dxgi_init()
     D3D_DRIVER_TYPE_UNKNOWN,
     NULL,
     D3D11_CREATE_DEVICE_VIDEO_SUPPORT,
-    featureLevels, featureLevelCount,
+    featureLevels, sizeof(featureLevels) / sizeof(D3D_FEATURE_LEVEL),
     D3D11_SDK_VERSION,
     &this->device,
     &this->featureLevel,
     &this->deviceContext);
 
-  LG_LOCK_INIT(this->deviceContextLock);
-
   IDXGIAdapter_Release(tmp);
 
   if (FAILED(status))
@@ -393,29 +327,9 @@ static bool dxgi_init()
   DEBUG_INFO("Shared Sys Mem   : %u MiB" , (unsigned)(adapterDesc.SharedSystemMemory    / 1048576));
   DEBUG_INFO("Feature Level    : 0x%x"   , this->featureLevel);
   DEBUG_INFO("Capture Size     : %u x %u", this->width, this->height);
-  DEBUG_INFO("AcquireLock      : %s"     , this->useAcquireLock ? "enabled" : "disabled");
 
   // bump up our priority
   {
-    HMODULE gdi32 = GetModuleHandleA("GDI32");
-    if (gdi32)
-    {
-      PD3DKMTSetProcessSchedulingPriorityClass fn =
-        (PD3DKMTSetProcessSchedulingPriorityClass)GetProcAddress(gdi32, "D3DKMTSetProcessSchedulingPriorityClass");
-
-      if (fn)
-      {
-        status = fn(GetCurrentProcess(), D3DKMT_SCHEDULINGPRIORITYCLASS_REALTIME);
-        if (FAILED(status))
-        {
-          DEBUG_WARN("Failed to set realtime GPU priority.");
-          DEBUG_INFO("This is not a failure, please do not report this as an issue.");
-          DEBUG_INFO("To fix this, install and run the Looking Glass host as a service.");
-          DEBUG_INFO("looking-glass-host.exe InstallService");
-        }
-      }
-    }
-
     IDXGIDevice * dxgi;
     status = ID3D11Device_QueryInterface(this->device, &IID_IDXGIDevice, (void **)&dxgi);
     if (FAILED(status))
@@ -428,20 +342,6 @@ static bool dxgi_init()
     IDXGIDevice_Release(dxgi);
   }
 
-  // try to reduce the latency
-  {
-    IDXGIDevice1 * dxgi;
-    status = ID3D11Device_QueryInterface(this->device, &IID_IDXGIDevice1, (void **)&dxgi);
-    if (FAILED(status))
-    {
-      DEBUG_WINERROR("failed to query DXGI interface from device", status);
-      goto fail;
-    }
-
-    IDXGIDevice1_SetMaximumFrameLatency(dxgi, 1);
-    IDXGIDevice1_Release(dxgi);
-  }
-
   IDXGIOutput5 * output5 = NULL;
   status = IDXGIOutput_QueryInterface(this->output, &IID_IDXGIOutput5, (void **)&output5);
   if (FAILED(status))
@@ -549,6 +449,23 @@ static bool dxgi_init()
       DEBUG_WINERROR("Failed to create texture", status);
       goto fail;
     }
+
+    this->texture[i].free = os_createEvent(true);
+    if (!this->texture[i].free)
+    {
+      DEBUG_ERROR("Failed to create the texture free event");
+      goto fail;
+    }
+
+    // pre-signal the free events to flag as unused
+    os_signalEvent(this->texture[i].free);
+
+    this->texture[i].mapped = os_createEvent(false);
+    if (!this->texture[i].mapped)
+    {
+      DEBUG_ERROR("Failed to create the texture mapped event");
+      goto fail;
+    }
   }
 
   // map the texture simply to get the pitch and stride
@@ -563,8 +480,6 @@ static bool dxgi_init()
   this->stride = mapping.RowPitch / 4;
   ID3D11DeviceContext_Unmap(this->deviceContext, (ID3D11Resource *)this->texture[0].tex, 0);
 
-  QueryPerformanceFrequency(&this->perfFreq) ;
-  QueryPerformanceCounter  (&this->frameTime);
   this->initialized = true;
   return true;
 
@@ -576,6 +491,9 @@ fail:
 static void dxgi_stop()
 {
   this->stop = true;
+
+  os_signalEvent(this->texture[this->texRIndex].mapped);
+  os_signalEvent(this->pointerEvent);
 }
 
 static bool dxgi_deinit()
@@ -597,6 +515,20 @@ static bool dxgi_deinit()
       ID3D11Texture2D_Release(this->texture[i].tex);
       this->texture[i].tex = NULL;
     }
+
+    if (this->texture[i].free)
+    {
+      os_signalEvent(this->texture[i].free);
+      os_freeEvent(this->texture[i].free);
+      this->texture[i].free = NULL;
+    }
+
+    if (this->texture[i].mapped)
+    {
+      os_signalEvent(this->texture[i].mapped);
+      os_freeEvent(this->texture[i].mapped);
+      this->texture[i].mapped = NULL;
+    }
   }
 
   if (this->dup)
@@ -642,14 +574,6 @@ static bool dxgi_deinit()
     }
   }
 
-  LG_LOCK_FREE(this->deviceContextLock);
-
-  if (this->desktop)
-  {
-    CloseDesktop(this->desktop);
-    this->desktop = NULL;
-  }
-
   this->initialized = false;
   return true;
 }
@@ -661,6 +585,7 @@ static void dxgi_free()
   if (this->initialized)
     dxgi_deinit();
 
+  os_freeEvent(this->pointerEvent);
   free(this->texture);
 
   free(this);
@@ -675,12 +600,53 @@ static unsigned int dxgi_getMaxFrameSize()
   return this->height * this->pitch;
 }
 
-static CaptureResult dxgi_hResultToCaptureResult(const HRESULT status)
+static CaptureResult dxgi_capture()
 {
+  assert(this);
+  assert(this->initialized);
+
+  CaptureResult             result;
+  HRESULT                   status;
+  DXGI_OUTDUPL_FRAME_INFO   frameInfo;
+  IDXGIResource           * res;
+
+  // if the read texture is pending a mapping
+  for(int i = 0; i < this->maxTextures; ++i)
+  {
+    if (this->texture[i].state != TEXTURE_STATE_PENDING_MAP)
+      continue;
+
+    Texture * tex = &this->texture[i];
+
+    // try to map the resource, but don't wait for it
+    status = ID3D11DeviceContext_Map(this->deviceContext, (ID3D11Resource*)tex->tex, 0, D3D11_MAP_READ, 0x100000L, &tex->map);
+
+    if (status != DXGI_ERROR_WAS_STILL_DRAWING)
+    {
+      if (FAILED(status))
+      {
+        DEBUG_WINERROR("Failed to map the texture", status);
+        IDXGIResource_Release(res);
+        return CAPTURE_RESULT_ERROR;
+      }
+
+      // successful map, set the state and signal that there is a frame available
+      tex->state = TEXTURE_STATE_MAPPED;
+      os_signalEvent(tex->mapped);
+    }
+  }
+
+  // release the prior frame
+  result = dxgi_releaseFrame();
+  if (result != CAPTURE_RESULT_OK)
+    return result;
+
+  status = IDXGIOutputDuplication_AcquireNextFrame(this->dup, 1, &frameInfo, &res);
   switch(status)
   {
     case S_OK:
-      return CAPTURE_RESULT_OK;
+      this->needsRelease = true;
+      break;
 
     case DXGI_ERROR_WAIT_TIMEOUT:
       return CAPTURE_RESULT_TIMEOUT;
@@ -690,51 +656,25 @@ static CaptureResult dxgi_hResultToCaptureResult(const HRESULT status)
       return CAPTURE_RESULT_REINIT;
 
     default:
+      DEBUG_WINERROR("AcquireNextFrame failed", status);
       return CAPTURE_RESULT_ERROR;
   }
-}
-
-static CaptureResult dxgi_capture()
-{
-  assert(this);
-  assert(this->initialized);
-
-  Texture                 * tex;
-  CaptureResult             result;
-  HRESULT                   status;
-  DXGI_OUTDUPL_FRAME_INFO   frameInfo;
-  IDXGIResource           * res;
-
-  // release the prior frame
-  result = dxgi_releaseFrame();
-  if (result != CAPTURE_RESULT_OK)
-    return result;
-
-  if (this->useAcquireLock)
-  {
-    LOCKED({
-        status = IDXGIOutputDuplication_AcquireNextFrame(this->dup, 1, &frameInfo, &res);
-    });
-  }
-  else
-    status = IDXGIOutputDuplication_AcquireNextFrame(this->dup, 1000, &frameInfo, &res);
-
-  result = dxgi_hResultToCaptureResult(status);
-  if (result != CAPTURE_RESULT_OK)
-  {
-    if (result == CAPTURE_RESULT_ERROR)
-      DEBUG_WINERROR("AcquireNextFrame failed", status);
-    return result;
-  }
-
-  this->needsRelease = true;
 
   if (frameInfo.LastPresentTime.QuadPart != 0)
   {
-    tex = &this->texture[this->texWIndex];
+    Texture * tex = &this->texture[this->texWIndex];
 
     // check if the texture is free, if not skip the frame to keep up
-    if (tex->state == TEXTURE_STATE_UNUSED)
+    if (!os_waitEvent(tex->free, 0))
+    {
+      /*
+      NOTE: This is only informational for when debugging, skipping frames is
+      OK as we are likely getting frames faster then the client can render
+      them (ie, vsync off in a title)
+      */
+      //DEBUG_WARN("Frame skipped");
+    }
+    else
     {
       ID3D11Texture2D * src;
       status = IDXGIResource_QueryInterface(res, &IID_ID3D11Texture2D, (void **)&src);
@@ -745,103 +685,83 @@ static CaptureResult dxgi_capture()
         return CAPTURE_RESULT_ERROR;
       }
 
-      LOCKED({
-        // issue the copy from GPU to CPU RAM and release the src
-        ID3D11DeviceContext_CopyResource(this->deviceContext,
-          (ID3D11Resource *)tex->tex, (ID3D11Resource *)src);
-      });
+      // if the texture was mapped, unmap it
+      if (tex->state == TEXTURE_STATE_MAPPED)
+      {
+        ID3D11DeviceContext_Unmap(this->deviceContext, (ID3D11Resource*)tex->tex, 0);
+        tex->map.pData = NULL;
+      }
 
+      // issue the copy from GPU to CPU RAM and release the src
+      ID3D11DeviceContext_CopyResource(this->deviceContext,
+        (ID3D11Resource *)tex->tex, (ID3D11Resource *)src);
       ID3D11Texture2D_Release(src);
 
-      // set the state, and signal
+      // pending map
       tex->state = TEXTURE_STATE_PENDING_MAP;
-      INTERLOCKED_INC(&this->texReady);
-      lgSignalEvent(this->frameEvent);
 
-      // advance the write index
+      // advance our write pointer
       if (++this->texWIndex == this->maxTextures)
         this->texWIndex = 0;
-
-      // update the last frame time
-      this->frameTime.QuadPart = frameInfo.LastPresentTime.QuadPart;
     }
   }
 
   IDXGIResource_Release(res);
 
   // if the pointer has moved or changed state
-  bool           postPointer      = false;
-  CapturePointer pointer          = { 0 };
-  void *         pointerShape     = NULL;
-  UINT           pointerShapeSize = 0;
-
+  bool signalPointer = false;
   if (frameInfo.LastMouseUpdateTime.QuadPart)
   {
-    /* the pointer position is only valid if the pointer is visible */
-    if (frameInfo.PointerPosition.Visible &&
-      (frameInfo.PointerPosition.Position.x != this->lastPointerX ||
-       frameInfo.PointerPosition.Position.y != this->lastPointerY))
+    if (
+      frameInfo.PointerPosition.Position.x != this->lastPointer.x ||
+      frameInfo.PointerPosition.Position.y != this->lastPointer.y ||
+      frameInfo.PointerPosition.Visible    != this->lastPointer.visible
+      )
     {
-      pointer.positionUpdate = true;
-      pointer.x =
-        this->lastPointerX =
-        frameInfo.PointerPosition.Position.x;
-      pointer.y =
-        this->lastPointerY =
-        frameInfo.PointerPosition.Position.y;
-      postPointer = true;
-    }
-
-    if (this->lastPointerVisible != frameInfo.PointerPosition.Visible)
-    {
-      this->lastPointerVisible = frameInfo.PointerPosition.Visible;
-      postPointer = true;
+      this->pointer.x       = frameInfo.PointerPosition.Position.x;
+      this->pointer.y       = frameInfo.PointerPosition.Position.y;
+      this->pointer.visible = frameInfo.PointerPosition.Visible;
+      signalPointer = true;
     }
   }
 
   // if the pointer shape has changed
   if (frameInfo.PointerShapeBufferSize > 0)
   {
-    uint32_t bufferSize;
-    if(!this->getPointerBufferFn(&pointerShape, &bufferSize))
-      DEBUG_WARN("Failed to obtain a buffer for the pointer shape");
+    // update the buffer
+    if (frameInfo.PointerShapeBufferSize > this->pointerSize)
+      DEBUG_WARN("The pointer shape is too large to fit in the buffer, ignoring the shape");
     else
     {
       DXGI_OUTDUPL_POINTER_SHAPE_INFO shapeInfo;
-
-      LOCKED({status = IDXGIOutputDuplication_GetFramePointerShape(this->dup, bufferSize, pointerShape, &pointerShapeSize, &shapeInfo);});
-      result = dxgi_hResultToCaptureResult(status);
-      if (result != CAPTURE_RESULT_OK)
+      status = IDXGIOutputDuplication_GetFramePointerShape(this->dup, this->pointerSize, this->pointerShape, &this->pointerUsed, &shapeInfo);
+      if (FAILED(status))
       {
-        if (result == CAPTURE_RESULT_ERROR)
-          DEBUG_WINERROR("Failed to get the new pointer shape", status);
-        return result;
+        DEBUG_WINERROR("Failed to get the new pointer shape", status);
+        return CAPTURE_RESULT_ERROR;
       }
 
       switch(shapeInfo.Type)
       {
-        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR       : pointer.format = CAPTURE_FMT_COLOR ; break;
-        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR: pointer.format = CAPTURE_FMT_MASKED; break;
-        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME  : pointer.format = CAPTURE_FMT_MONO  ; break;
+        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR       : this->pointer.format = CAPTURE_FMT_COLOR ; break;
+        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR: this->pointer.format = CAPTURE_FMT_MASKED; break;
+        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME  : this->pointer.format = CAPTURE_FMT_MONO  ; break;
         default:
           DEBUG_ERROR("Unsupported cursor format");
           return CAPTURE_RESULT_ERROR;
       }
 
-      pointer.shapeUpdate = true;
-      pointer.width       = shapeInfo.Width;
-      pointer.height      = shapeInfo.Height;
-      pointer.pitch       = shapeInfo.Pitch;
-      postPointer         = true;
+      this->pointer.w     = shapeInfo.Width;
+      this->pointer.h     = shapeInfo.Height;
+      this->pointer.pitch = shapeInfo.Pitch;
+      ++this->pointer.version;
+      signalPointer = true;
     }
   }
 
-  // post back the pointer information
-  if (postPointer)
-  {
-    pointer.visible = this->lastPointerVisible;
-    this->postPointerBufferFn(pointer);
-  }
+  // signal about the pointer update
+  if (signalPointer)
+    os_signalEvent(this->pointerEvent);
 
   return CAPTURE_RESULT_OK;
 }
@@ -851,31 +771,14 @@ static CaptureResult dxgi_waitFrame(CaptureFrame * frame)
   assert(this);
   assert(this->initialized);
 
-  // NOTE: the event may be signaled when there are no frames available
-  if(this->texReady == 0)
-  {
-    if (!lgWaitEvent(this->frameEvent, 1000))
-      return CAPTURE_RESULT_TIMEOUT;
-
-    if (this->texReady == 0)
-      return CAPTURE_RESULT_TIMEOUT;
-  }
-
   Texture * tex = &this->texture[this->texRIndex];
-
-  // try to map the resource, but don't wait for it
-  HRESULT status;
-  LOCKED({status = ID3D11DeviceContext_Map(this->deviceContext, (ID3D11Resource*)tex->tex, 0, D3D11_MAP_READ, 0x100000L, &tex->map);});
-  if (status == DXGI_ERROR_WAS_STILL_DRAWING)
+  if (!os_waitEvent(tex->mapped, 1000))
     return CAPTURE_RESULT_TIMEOUT;
 
-  if (FAILED(status))
-  {
-    DEBUG_WINERROR("Failed to map the texture", status);
-    return CAPTURE_RESULT_ERROR;
-  }
+  if (this->stop)
+    return CAPTURE_RESULT_REINIT;
 
-  tex->state = TEXTURE_STATE_MAPPED;
+  os_resetEvent(tex->mapped);
 
   frame->width  = this->width;
   frame->height = this->height;
@@ -883,20 +786,17 @@ static CaptureResult dxgi_waitFrame(CaptureFrame * frame)
   frame->stride = this->stride;
   frame->format = this->format;
 
-  INTERLOCKED_DEC(&this->texReady);
   return CAPTURE_RESULT_OK;
 }
 
-static CaptureResult dxgi_getFrame(FrameBuffer * frame)
+static CaptureResult dxgi_getFrame(FrameBuffer frame)
 {
   assert(this);
   assert(this->initialized);
 
   Texture * tex = &this->texture[this->texRIndex];
-
   framebuffer_write(frame, tex->map.pData, this->pitch * this->height);
-  LOCKED({ID3D11DeviceContext_Unmap(this->deviceContext, (ID3D11Resource*)tex->tex, 0);});
-  tex->state = TEXTURE_STATE_UNUSED;
+  os_signalEvent(tex->free);
 
   if (++this->texRIndex == this->maxTextures)
     this->texRIndex = 0;
@@ -904,14 +804,41 @@ static CaptureResult dxgi_getFrame(FrameBuffer * frame)
   return CAPTURE_RESULT_OK;
 }
 
+static CaptureResult dxgi_getPointer(CapturePointer * pointer)
+{
+  assert(this);
+  assert(this->initialized);
+
+  if (!os_waitEvent(this->pointerEvent, 1000))
+    return CAPTURE_RESULT_TIMEOUT;
+
+  if (this->stop)
+    return CAPTURE_RESULT_REINIT;
+
+  Pointer p;
+  memcpy(&p, &this->pointer, sizeof(Pointer));
+
+  pointer->x           = p.x;
+  pointer->y           = p.y;
+  pointer->width       = p.w;
+  pointer->height      = p.h;
+  pointer->pitch       = p.pitch;
+  pointer->visible     = p.visible;
+  pointer->format      = p.format;
+  pointer->shapeUpdate = p.version > this->lastPointer.version;
+
+  memcpy(&this->lastPointer, &p, sizeof(Pointer));
+
+  return CAPTURE_RESULT_OK;
+}
+
 static CaptureResult dxgi_releaseFrame()
 {
   assert(this);
   if (!this->needsRelease)
     return CAPTURE_RESULT_OK;
 
-  HRESULT status;
-  LOCKED({status = IDXGIOutputDuplication_ReleaseFrame(this->dup);});
+  HRESULT status = IDXGIOutputDuplication_ReleaseFrame(this->dup);
   switch(status)
   {
     case S_OK:
@@ -949,5 +876,6 @@ struct CaptureInterface Capture_DXGI =
   .getMaxFrameSize = dxgi_getMaxFrameSize,
   .capture         = dxgi_capture,
   .waitFrame       = dxgi_waitFrame,
-  .getFrame        = dxgi_getFrame
-};
+  .getFrame        = dxgi_getFrame,
+  .getPointer      = dxgi_getPointer
+};

c-host/platform/Windows/capture/NVFBC/src/nvfbc.c

@@ -1,6 +1,6 @@
 /*
 Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
 https://looking-glass.hostfission.com
 
 This program is free software; you can redistribute it and/or modify it under
@@ -19,12 +19,11 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include "interface/capture.h"
 #include "interface/platform.h"
-#include "common/windebug.h"
+#include "windows/platform.h"
+#include "windows/debug.h"
 #include "windows/mousehook.h"
 #include "common/option.h"
 #include "common/framebuffer.h"
-#include "common/event.h"
-#include "common/thread.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <windows.h>
@@ -37,21 +36,18 @@ struct iface
   bool        stop;
   NvFBCHandle nvfbc;
 
-  bool                       seperateCursor;
-  CaptureGetPointerBuffer    getPointerBufferFn;
-  CapturePostPointerBuffer   postPointerBufferFn;
-  LGThread                 * pointerThread;
-
+  bool         seperateCursor;
+  void       * pointerShape;
+  unsigned int pointerSize;
   unsigned int maxWidth, maxHeight;
   unsigned int width   , height;
 
   uint8_t * frameBuffer;
-  uint8_t * diffMap;
 
   NvFBCFrameGrabInfo grabInfo;
 
-  LGEvent * frameEvent;
-  LGEvent * cursorEvents[2];
+  osEventHandle * frameEvent;
+  osEventHandle * cursorEvents[2];
 
   int mouseX, mouseY, mouseHotX, mouseHotY;
   bool mouseVisible;
@@ -60,7 +56,6 @@ struct iface
 static struct iface * this = NULL;
 
 static void nvfbc_free();
-static int pointerThread(void * unused);
 
 static void getDesktopSize(unsigned int * width, unsigned int * height)
 {
@@ -80,7 +75,7 @@ static void on_mouseMove(int x, int y)
 {
   this->mouseX = x;
   this->mouseY = y;
-  lgSignalEvent(this->cursorEvents[0]);
+  os_signalEvent(this->cursorEvents[0]);
 }
 
 static const char * nvfbc_getName()
@@ -105,9 +100,7 @@ static void nvfbc_initOptions()
   option_register(options);
 }
 
-static bool nvfbc_create(
-    CaptureGetPointerBuffer  getPointerBufferFn,
-    CapturePostPointerBuffer postPointerBufferFn)
+static bool nvfbc_create()
 {
   if (!NvFBCInit())
     return false;
@@ -142,7 +135,7 @@ static bool nvfbc_create(
   }
   free(privData);
 
-  this->frameEvent = lgCreateEvent(true, 17);
+  this->frameEvent = os_createEvent(true);
   if (!this->frameEvent)
   {
     DEBUG_ERROR("failed to create the frame event");
@@ -150,18 +143,20 @@ static bool nvfbc_create(
     return false;
   }
 
-  this->seperateCursor      = option_get_bool("nvfbc", "decoupleCursor");
-  this->getPointerBufferFn  = getPointerBufferFn;
-  this->postPointerBufferFn = postPointerBufferFn;
+  this->seperateCursor = option_get_bool("nvfbc", "decoupleCursor");
 
   return true;
 }
 
-static bool nvfbc_init()
+static bool nvfbc_init(void * pointerShape, const unsigned int pointerSize)
 {
-  this->stop = false;
+  this->stop         = false;
+  this->pointerShape = pointerShape;
+  this->pointerSize  = pointerSize;
+
   getDesktopSize(&this->width, &this->height);
-  lgResetEvent(this->frameEvent);
+  os_resetEvent(this->frameEvent);
+
 
   HANDLE event;
   if (!NvFBCToSysSetup(
@@ -169,58 +164,38 @@ static bool nvfbc_init()
     BUFFER_FMT_ARGB,
     !this->seperateCursor,
     this->seperateCursor,
-    true,
-    DIFFMAP_BLOCKSIZE_128X128,
+    false,
+    0,
     (void **)&this->frameBuffer,
-    (void **)&this->diffMap,
+    NULL,
     &event
   ))
   {
     return false;
   }
 
-  this->cursorEvents[0] = lgCreateEvent(true, 10);
+  this->cursorEvents[0] = os_createEvent(true);
   mouseHook_install(on_mouseMove);
 
   if (this->seperateCursor)
-    this->cursorEvents[1] = lgWrapEvent(event);
+    this->cursorEvents[1] = os_wrapEvent(event);
 
   DEBUG_INFO("Cursor mode      : %s", this->seperateCursor ? "decoupled" : "integrated");
 
   Sleep(100);
-
-  if (!lgCreateThread("NvFBCPointer", pointerThread, NULL, &this->pointerThread))
-  {
-    DEBUG_ERROR("Failed to create the NvFBCPointer thread");
-    return false;
-  }
-
   return true;
 }
 
 static void nvfbc_stop()
 {
   this->stop = true;
-  lgSignalEvent(this->cursorEvents[0]);
-  lgSignalEvent(this->frameEvent);
-
-  if (this->pointerThread)
-  {
-    lgJoinThread(this->pointerThread, NULL);
-    this->pointerThread = NULL;
-  }
+  os_signalEvent(this->cursorEvents[0]);
+  os_signalEvent(this->frameEvent);
 }
 
 static bool nvfbc_deinit()
 {
   mouseHook_remove();
-
-  if (this->cursorEvents[0])
-  {
-    lgFreeEvent(this->cursorEvents[0]);
-    this->cursorEvents[0] = NULL;
-  }
-
   return true;
 }
 
@@ -229,7 +204,7 @@ static void nvfbc_free()
   NvFBCToSysRelease(&this->nvfbc);
 
   if (this->frameEvent)
-    lgFreeEvent(this->frameEvent);
+    os_freeEvent(this->frameEvent);
 
   free(this);
   this = NULL;
@@ -257,28 +232,14 @@ static CaptureResult nvfbc_capture()
   if (result != CAPTURE_RESULT_OK)
     return result;
 
-  bool changed = false;
-  const unsigned int h = (this->height + 127) / 128;
-  const unsigned int w = (this->width  + 127) / 128;
-  for(unsigned int y = 0; y < h; ++y)
-    for(unsigned int x = 0; x < w; ++x)
-      if (this->diffMap[(y*w)+x])
-      {
-        changed = true;
-        break;
-      }
-
-  if (!changed)
-    return CAPTURE_RESULT_TIMEOUT;
-
   memcpy(&this->grabInfo, &grabInfo, sizeof(grabInfo));
-  lgSignalEvent(this->frameEvent);
+  os_signalEvent(this->frameEvent);
   return CAPTURE_RESULT_OK;
 }
 
 static CaptureResult nvfbc_waitFrame(CaptureFrame * frame)
 {
-  if (!lgWaitEvent(this->frameEvent, 1000))
+  if (!os_waitEvent(this->frameEvent, 1000))
     return CAPTURE_RESULT_TIMEOUT;
 
   if (this->stop)
@@ -309,7 +270,7 @@ static CaptureResult nvfbc_waitFrame(CaptureFrame * frame)
   return CAPTURE_RESULT_OK;
 }
 
-static CaptureResult nvfbc_getFrame(FrameBuffer * frame)
+static CaptureResult nvfbc_getFrame(FrameBuffer frame)
 {
   framebuffer_write(
     frame,
@@ -319,55 +280,32 @@ static CaptureResult nvfbc_getFrame(FrameBuffer * frame)
   return CAPTURE_RESULT_OK;
 }
 
-static int pointerThread(void * unused)
+static CaptureResult nvfbc_getPointer(CapturePointer * pointer)
 {
-  while(!this->stop)
+  osEventHandle * events[2];
+  memcpy(&events, &this->cursorEvents, sizeof(osEventHandle *) * 2);
+  if (!os_waitEvents(events, this->seperateCursor ? 2 : 1, false, 1000))
+    return CAPTURE_RESULT_TIMEOUT;
+
+  if (this->stop)
+    return CAPTURE_RESULT_REINIT;
+
+  CaptureResult result;
+  pointer->shapeUpdate = false;
+  if (this->seperateCursor && events[1])
   {
-    LGEvent * events[2];
-    memcpy(&events, &this->cursorEvents, sizeof(LGEvent *) * 2);
-    if (!lgWaitEvents(events, this->seperateCursor ? 2 : 1, false, 1000))
-      continue;
-
-    if (this->stop)
-      break;
-
-    CaptureResult  result;
-    CapturePointer pointer = { 0 };
-
-    if (this->seperateCursor && events[1])
-    {
-      void * data;
-      uint32_t size;
-      if (!this->getPointerBufferFn(&data, &size))
-      {
-        DEBUG_WARN("failed to get a pointer buffer");
-        continue;
-      }
-
-      result = NvFBCToSysGetCursor(this->nvfbc, &pointer, data, size);
-      if (result != CAPTURE_RESULT_OK)
-      {
-        DEBUG_WARN("NvFBCToSysGetCursor failed");
-        continue;
-      }
-
-      this->mouseVisible = pointer.visible;
-      this->mouseHotX    = pointer.x;
-      this->mouseHotY    = pointer.y;
-    }
-
-    if (events[0])
-    {
-      pointer.positionUpdate = true;
-      pointer.visible        = this->mouseVisible;
-      pointer.x              = this->mouseX - this->mouseHotX;
-      pointer.y              = this->mouseY - this->mouseHotY;
-    }
-
-    this->postPointerBufferFn(pointer);
+    result = NvFBCToSysGetCursor(this->nvfbc, pointer, this->pointerShape, this->pointerSize);
+    this->mouseVisible = pointer->visible;
+    this->mouseHotX    = pointer->x;
+    this->mouseHotY    = pointer->y;
+    if (result != CAPTURE_RESULT_OK)
+      return result;
   }
 
-  return 0;
+  pointer->visible = this->mouseVisible;
+  pointer->x       = this->mouseX - this->mouseHotX;
+  pointer->y       = this->mouseY - this->mouseHotY;
+  return CAPTURE_RESULT_OK;
 }
 
 struct CaptureInterface Capture_NVFBC =
@@ -383,5 +321,6 @@ struct CaptureInterface Capture_NVFBC =
   .getMaxFrameSize = nvfbc_getMaxFrameSize,
   .capture         = nvfbc_capture,
   .waitFrame       = nvfbc_waitFrame,
-  .getFrame        = nvfbc_getFrame
-};
+  .getFrame        = nvfbc_getFrame,
+  .getPointer      = nvfbc_getPointer
+};

c-host/platform/Windows/capture/NVFBC/src/wrapper.cpp

@@ -1,6 +1,6 @@
 /*
 Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
 https://looking-glass.hostfission.com
 
 This program is free software; you can redistribute it and/or modify it under
@@ -18,7 +18,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 #include "wrapper.h"
-#include "common/windebug.h"
+#include "windows/debug.h"
 #include <windows.h>
 #include <NvFBC/nvFBCToSys.h>
 

c-host/platform/Windows/include/windows/debug.h

@@ -1,6 +1,6 @@
 /*
 Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
 https://looking-glass.hostfission.com
 
 This program is free software; you can redistribute it and/or modify it under
@@ -19,9 +19,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #pragma once
 
-#include "debug.h"
+#include "common/debug.h"
 #include <windows.h>
-#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -31,8 +30,6 @@ void DebugWinError(const char * file, const unsigned int line, const char * func
 
 #define DEBUG_WINERROR(x, y) DebugWinError(STRIPPATH(__FILE__), __LINE__, __FUNCTION__, x, y)
 
-bool IsWindows8();
-
 #ifdef __cplusplus
 }
 #endif

c-host/platform/Windows/include/windows/platform.h

@@ -1,6 +1,6 @@
 /*
 Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
 https://looking-glass.hostfission.com
 
 This program is free software; you can redistribute it and/or modify it under
@@ -17,12 +17,7 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#pragma once
+#include "interface/platform.h"
+#include <windows.h>
 
-#include <stdbool.h>
-
-typedef struct LGThread LGThread;
-typedef int (*LGThreadFunction)(void * opaque);
-
-bool lgCreateThread(const char * name, LGThreadFunction function, void * opaque, LGThread ** handle);
-bool lgJoinThread  (LGThread * handle, int * resultCode);
+osEventHandle * os_wrapEvent(HANDLE event);

c-host/platform/Windows/src/mousehook.c

@@ -18,7 +18,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 #include "windows/mousehook.h"
-#include "common/windebug.h"
+#include "windows/debug.h"
 #include "platform.h"
 
 #include <windows.h>
@@ -29,7 +29,6 @@ struct mouseHook
   bool        installed;
   HHOOK       hook;
   MouseHookFn callback;
-  int         x, y;
 };
 
 static struct mouseHook mouseHook = { 0 };
@@ -93,12 +92,7 @@ static LRESULT WINAPI mouseHook_hook(int nCode, WPARAM wParam, LPARAM lParam)
   if (nCode == HC_ACTION && wParam == WM_MOUSEMOVE)
   {
     MSLLHOOKSTRUCT *msg = (MSLLHOOKSTRUCT *)lParam;
-    if (mouseHook.x != msg->pt.x || mouseHook.y != msg->pt.y)
-    {
-      mouseHook.x = msg->pt.x;
-      mouseHook.y = msg->pt.y;
-      mouseHook.callback(msg->pt.x, msg->pt.y);
-    }
+    mouseHook.callback(msg->pt.x, msg->pt.y);
   }
   return CallNextHookEx(mouseHook.hook, nCode, wParam, lParam);
-}
+}

c-host/platform/Windows/src/platform.c

@@ -0,0 +1,556 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "platform.h"
+#include "windows/platform.h"
+#include "windows/mousehook.h"
+
+#include <windows.h>
+#include <setupapi.h>
+#include <shellapi.h>
+
+#include "interface/platform.h"
+#include "common/debug.h"
+#include "common/option.h"
+#include "windows/debug.h"
+#include "ivshmem.h"
+
+#define ID_MENU_OPEN_LOG 3000
+#define ID_MENU_EXIT     3001
+
+struct AppState
+{
+  HINSTANCE hInst;
+
+  int     argc;
+  char ** argv;
+
+  char         executable[MAX_PATH + 1];
+  HANDLE       shmemHandle;
+  bool         shmemOwned;
+  IVSHMEM_MMAP shmemMap;
+  HWND         messageWnd;
+  HMENU        trayMenu;
+};
+
+static struct AppState app =
+{
+  .shmemHandle = INVALID_HANDLE_VALUE,
+  .shmemOwned  = false,
+  .shmemMap    = {0}
+};
+
+struct osThreadHandle
+{
+  const char       * name;
+  osThreadFunction   function;
+  void             * opaque;
+  HANDLE             handle;
+  DWORD              threadID;
+
+  int                resultCode;
+};
+
+LRESULT CALLBACK DummyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+  switch(msg)
+  {
+    case WM_DESTROY:
+      PostQuitMessage(0);
+      break;
+
+    case WM_CALL_FUNCTION:
+    {
+      struct MSG_CALL_FUNCTION * cf = (struct MSG_CALL_FUNCTION *)lParam;
+      return cf->fn(cf->wParam, cf->lParam);
+    }
+
+    case WM_TRAYICON:
+    {
+      if (lParam == WM_RBUTTONDOWN)
+      {
+        POINT curPoint;
+        GetCursorPos(&curPoint);
+        SetForegroundWindow(hwnd);
+        UINT clicked = TrackPopupMenu(
+          app.trayMenu,
+          TPM_RETURNCMD | TPM_NONOTIFY,
+          curPoint.x,
+          curPoint.y,
+          0,
+          hwnd,
+          NULL
+        );
+
+             if (clicked == ID_MENU_EXIT    ) app_quit();
+        else if (clicked == ID_MENU_OPEN_LOG)
+        {
+          const char * logFile = option_get_string("os", "logFile");
+          if (strcmp(logFile, "stderr") == 0)
+            DEBUG_INFO("Ignoring request to open the logFile, logging to stderr");
+          else
+            ShellExecute(NULL, NULL, logFile, NULL, NULL, SW_SHOWNORMAL);
+        }
+      }
+      break;
+    }
+
+    default:
+      return DefWindowProc(hwnd, msg, wParam, lParam);
+  }
+  return 0;
+}
+
+static int appThread(void * opaque)
+{
+  // register our TrayIcon
+  NOTIFYICONDATA iconData =
+  {
+    .cbSize           = sizeof(NOTIFYICONDATA),
+    .hWnd             = app.messageWnd,
+    .uFlags           = NIF_ICON | NIF_MESSAGE | NIF_TIP,
+    .uCallbackMessage = WM_TRAYICON,
+    .szTip            = "Looking Glass (host)"
+  };
+  iconData.hIcon = LoadIcon(app.hInst, IDI_APPLICATION);
+  Shell_NotifyIcon(NIM_ADD, &iconData);
+
+  int result = app_main(app.argc, app.argv);
+
+  Shell_NotifyIcon(NIM_DELETE, &iconData);
+  mouseHook_remove();
+  SendMessage(app.messageWnd, WM_DESTROY, 0, 0);
+  return result;
+}
+
+LRESULT sendAppMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
+{
+  return SendMessage(app.messageWnd, Msg, wParam, lParam);
+}
+
+static BOOL WINAPI CtrlHandler(DWORD dwCtrlType)
+{
+  if (dwCtrlType == CTRL_C_EVENT)
+  {
+    SendMessage(app.messageWnd, WM_CLOSE, 0, 0);
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
+{
+  int result = 0;
+  app.hInst = hInstance;
+
+  char tempPath[MAX_PATH+1];
+  GetTempPathA(sizeof(tempPath), tempPath);
+  int len = snprintf(NULL, 0, "%slooking-glass-host.txt", tempPath);
+  char * logFilePath = malloc(len + 1);
+  sprintf(logFilePath, "%slooking-glass-host.txt", tempPath);
+
+  struct Option options[] =
+  {
+    {
+      .module         = "os",
+      .name           = "shmDevice",
+      .description    = "The IVSHMEM device to use",
+      .type           = OPTION_TYPE_INT,
+      .value.x_int    = 0
+    },
+    {
+      .module         = "os",
+      .name           = "logFile",
+      .description    = "The log file to write to",
+      .type           = OPTION_TYPE_STRING,
+      .value.x_string = logFilePath
+    },
+    {0}
+  };
+
+  option_register(options);
+  free(logFilePath);
+
+  // convert the command line to the standard argc and argv
+  LPWSTR * wargv = CommandLineToArgvW(GetCommandLineW(), &app.argc);
+  app.argv = malloc(sizeof(char *) * app.argc);
+  for(int i = 0; i < app.argc; ++i)
+  {
+    const size_t s = (wcslen(wargv[i])+1) * 2;
+    app.argv[i] = malloc(s);
+    wcstombs(app.argv[i], wargv[i], s);
+  }
+  LocalFree(wargv);
+
+  GetModuleFileName(NULL, app.executable, sizeof(app.executable));
+
+  // setup a handler for ctrl+c
+  SetConsoleCtrlHandler(CtrlHandler, TRUE);
+
+  // create a message window so that our message pump works
+  WNDCLASSEX wx    = {};
+  wx.cbSize        = sizeof(WNDCLASSEX);
+  wx.lpfnWndProc   = DummyWndProc;
+  wx.hInstance     = hInstance;
+  wx.lpszClassName = "DUMMY_CLASS";
+  wx.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
+  wx.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
+  wx.hCursor       = LoadCursor(NULL, IDC_ARROW);
+  wx.hbrBackground = (HBRUSH)COLOR_APPWORKSPACE;
+  if (!RegisterClassEx(&wx))
+  {
+    DEBUG_ERROR("Failed to register message window class");
+    result = -1;
+    goto finish;
+  }
+  app.messageWnd = CreateWindowEx(0, "DUMMY_CLASS", "DUMMY_NAME", 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
+
+  app.trayMenu = CreatePopupMenu();
+  AppendMenu(app.trayMenu, MF_STRING   , ID_MENU_OPEN_LOG, "Open Log File");
+  AppendMenu(app.trayMenu, MF_SEPARATOR, 0               , NULL           );
+  AppendMenu(app.trayMenu, MF_STRING   , ID_MENU_EXIT    , "Exit"         );
+
+  // create the application thread
+  osThreadHandle * thread;
+  if (!os_createThread("appThread", appThread, NULL, &thread))
+  {
+    DEBUG_ERROR("Failed to create the main application thread");
+    result = -1;
+    goto finish;
+  }
+
+  while(true)
+  {
+    MSG  msg;
+    BOOL bRet = GetMessage(&msg, NULL, 0, 0);
+    if (bRet > 0)
+    {
+      TranslateMessage(&msg);
+      DispatchMessage(&msg);
+      continue;
+    }
+    else if (bRet < 0)
+    {
+      DEBUG_ERROR("Unknown error from GetMessage");
+      result = -1;
+      goto shutdown;
+    }
+
+    break;
+  }
+
+shutdown:
+  DestroyMenu(app.trayMenu);
+  app_quit();
+  if (!os_joinThread(thread, &result))
+  {
+    DEBUG_ERROR("Failed to join the main application thread");
+    result = -1;
+  }
+
+finish:
+  os_shmemUnmap();
+
+  if (app.shmemHandle != INVALID_HANDLE_VALUE)
+    CloseHandle(app.shmemHandle);
+
+  for(int i = 0; i < app.argc; ++i)
+    free(app.argv[i]);
+  free(app.argv);
+
+  return result;
+}
+
+bool app_init()
+{
+  const int    shmDevice = option_get_int   ("os", "shmDevice");
+  const char * logFile   = option_get_string("os", "logFile"  );
+
+  // redirect stderr to a file
+  if (logFile && strcmp(logFile, "stderr") != 0)
+    freopen(logFile, "a", stderr);
+
+  // always flush stderr
+  setbuf(stderr, NULL);
+
+  HDEVINFO                         deviceInfoSet;
+  PSP_DEVICE_INTERFACE_DETAIL_DATA infData = NULL;
+  SP_DEVICE_INTERFACE_DATA         deviceInterfaceData;
+
+  deviceInfoSet = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES | DIGCF_DEVICEINTERFACE);
+  memset(&deviceInterfaceData, 0, sizeof(SP_DEVICE_INTERFACE_DATA));
+  deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+
+  if (SetupDiEnumDeviceInterfaces(deviceInfoSet, NULL, &GUID_DEVINTERFACE_IVSHMEM, shmDevice, &deviceInterfaceData) == FALSE)
+  {
+    DWORD error = GetLastError();
+    if (error == ERROR_NO_MORE_ITEMS)
+    {
+      DEBUG_WINERROR("Unable to enumerate the device, is it attached?", error);
+      return false;
+    }
+
+    DEBUG_WINERROR("SetupDiEnumDeviceInterfaces failed", error);
+    return false;
+  }
+
+  DWORD reqSize = 0;
+  SetupDiGetDeviceInterfaceDetail(deviceInfoSet, &deviceInterfaceData, NULL, 0, &reqSize, NULL);
+  if (!reqSize)
+  {
+    DEBUG_WINERROR("SetupDiGetDeviceInterfaceDetail", GetLastError());
+    return false;
+  }
+
+  infData         = (PSP_DEVICE_INTERFACE_DETAIL_DATA)calloc(reqSize, 1);
+  infData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+  if (!SetupDiGetDeviceInterfaceDetail(deviceInfoSet, &deviceInterfaceData, infData, reqSize, NULL, NULL))
+  {
+    free(infData);
+    DEBUG_WINERROR("SetupDiGetDeviceInterfaceDetail", GetLastError());
+    return false;
+  }
+
+  app.shmemHandle = CreateFile(infData->DevicePath, 0, 0, NULL, OPEN_EXISTING, 0, 0);
+  if (app.shmemHandle == INVALID_HANDLE_VALUE)
+  {
+    SetupDiDestroyDeviceInfoList(deviceInfoSet);
+    free(infData);
+    DEBUG_WINERROR("CreateFile returned INVALID_HANDLE_VALUE", GetLastError());
+    return false;
+  }
+
+  free(infData);
+  SetupDiDestroyDeviceInfoList(deviceInfoSet);
+
+  return true;
+}
+
+const char * os_getExecutable()
+{
+  return app.executable;
+}
+
+unsigned int os_shmemSize()
+{
+  IVSHMEM_SIZE size;
+  if (!DeviceIoControl(app.shmemHandle, IOCTL_IVSHMEM_REQUEST_SIZE, NULL, 0, &size, sizeof(IVSHMEM_SIZE), NULL, NULL))
+  {
+    DEBUG_WINERROR("DeviceIoControl Failed", GetLastError());
+    return 0;
+  }
+
+  return (unsigned int)size;
+}
+
+bool os_shmemMmap(void **ptr)
+{
+  if (app.shmemOwned)
+  {
+    *ptr = app.shmemMap.ptr;
+    return true;
+  }
+
+  IVSHMEM_MMAP_CONFIG config =
+  {
+    .cacheMode = IVSHMEM_CACHE_WRITECOMBINED
+  };
+
+  memset(&app.shmemMap, 0, sizeof(IVSHMEM_MMAP));
+  if (!DeviceIoControl(
+    app.shmemHandle,
+    IOCTL_IVSHMEM_REQUEST_MMAP,
+    &config, sizeof(IVSHMEM_MMAP_CONFIG),
+    &app.shmemMap, sizeof(IVSHMEM_MMAP),
+    NULL, NULL))
+  {
+    DEBUG_WINERROR("DeviceIoControl Failed", GetLastError());
+    return false;
+  }
+
+  *ptr = app.shmemMap.ptr;
+  app.shmemOwned = true;
+  return true;
+}
+
+void os_shmemUnmap()
+{
+  if (!app.shmemOwned)
+    return;
+
+  if (!DeviceIoControl(app.shmemHandle, IOCTL_IVSHMEM_RELEASE_MMAP, NULL, 0, NULL, 0, NULL, NULL))
+    DEBUG_WINERROR("DeviceIoControl failed", GetLastError());
+  else
+    app.shmemOwned = false;
+}
+
+static DWORD WINAPI threadWrapper(LPVOID lpParameter)
+{
+  osThreadHandle * handle = (osThreadHandle *)lpParameter;
+  handle->resultCode = handle->function(handle->opaque);
+  return 0;
+}
+
+bool os_createThread(const char * name, osThreadFunction function, void * opaque, osThreadHandle ** handle)
+{
+  *handle             = (osThreadHandle *)malloc(sizeof(osThreadHandle));
+  (*handle)->name     = name;
+  (*handle)->function = function;
+  (*handle)->opaque   = opaque;
+  (*handle)->handle   = CreateThread(NULL, 0, threadWrapper, *handle, 0, &(*handle)->threadID);
+
+  if (!(*handle)->handle)
+  {
+    free(*handle);
+    *handle = NULL;
+    DEBUG_WINERROR("CreateThread failed", GetLastError());
+    return false;
+  }
+
+  return true;
+}
+
+bool os_joinThread(osThreadHandle * handle, int * resultCode)
+{
+  while(true)
+  {
+    switch(WaitForSingleObject(handle->handle, INFINITE))
+    {
+      case WAIT_OBJECT_0:
+        if (resultCode)
+          *resultCode = handle->resultCode;
+        CloseHandle(handle->handle);
+        free(handle);
+        return true;
+
+      case WAIT_ABANDONED:
+      case WAIT_TIMEOUT:
+        continue;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for thread failed", GetLastError());
+        CloseHandle(handle->handle);
+        free(handle);
+        return false;
+    }
+
+    break;
+  }
+
+  DEBUG_WINERROR("Unknown failure waiting for thread", GetLastError());
+  return false;
+}
+
+osEventHandle * os_createEvent(bool autoReset)
+{
+  HANDLE event = CreateEvent(NULL, autoReset ? FALSE : TRUE, FALSE, NULL);
+  if (!event)
+  {
+    DEBUG_WINERROR("Failed to create the event", GetLastError());
+    return NULL;
+  }
+
+  return (osEventHandle*)event;
+}
+
+osEventHandle * os_wrapEvent(HANDLE event)
+{
+  return (osEventHandle*)event;
+}
+
+void os_freeEvent(osEventHandle * handle)
+{
+  CloseHandle((HANDLE)handle);
+}
+
+bool os_waitEvent(osEventHandle * handle, unsigned int timeout)
+{
+  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
+  while(true)
+  {
+    switch(WaitForSingleObject((HANDLE)handle, to))
+    {
+      case WAIT_OBJECT_0:
+        return true;
+
+      case WAIT_ABANDONED:
+        continue;
+
+      case WAIT_TIMEOUT:
+        if (timeout == TIMEOUT_INFINITE)
+          continue;
+
+        return false;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for event failed", GetLastError());
+        return false;
+    }
+
+    DEBUG_ERROR("Unknown wait event return code");
+    return false;
+  }
+}
+
+bool os_waitEvents(osEventHandle * handles[], int count, bool waitAll, unsigned int timeout)
+{
+  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
+  while(true)
+  {
+    DWORD result = WaitForMultipleObjects(count, (HANDLE*)handles, waitAll, to);
+    if (result >= WAIT_OBJECT_0 && result < count)
+    {
+      // null non signalled events from the handle list
+      for(int i = 0; i < count; ++i)
+        if (i != result && !os_waitEvent(handles[i], 0))
+          handles[i] = NULL;
+      return true;
+    }
+
+    if (result >= WAIT_ABANDONED_0 && result - WAIT_ABANDONED_0 < count)
+      continue;
+
+    switch(result)
+    {
+      case WAIT_TIMEOUT:
+        if (timeout == TIMEOUT_INFINITE)
+          continue;
+
+        return false;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for event failed", GetLastError());
+        return false;
+    }
+
+    DEBUG_ERROR("Unknown wait event return code");
+    return false;
+  }
+}
+
+bool os_signalEvent(osEventHandle * handle)
+{
+  return SetEvent((HANDLE)handle);
+}
+
+bool os_resetEvent(osEventHandle * handle)
+{
+  return ResetEvent((HANDLE)handle);
+}

c-host/platform/Windows/src/platform.h

@@ -30,4 +30,4 @@ struct MSG_CALL_FUNCTION
   LPARAM       lParam;
 };
 
-LRESULT sendAppMessage(UINT Msg, WPARAM wParam, LPARAM lParam);
+LRESULT sendAppMessage(UINT Msg, WPARAM wParam, LPARAM lParam);

c-host/platform/Windows/src/windebug.c

@@ -1,6 +1,6 @@
 /*
 Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
 https://looking-glass.hostfission.com
 
 This program is free software; you can redistribute it and/or modify it under
@@ -17,7 +17,7 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "common/windebug.h"
+#include "windows/debug.h"
 #include <stdio.h>
 
 void DebugWinError(const char * file, const unsigned int line, const char * function, const char * desc, HRESULT status)
@@ -37,30 +37,6 @@ void DebugWinError(const char * file, const unsigned int line, const char * func
     if (buffer[i] == '\n' || buffer[i] == '\r')
       buffer[i] = 0;
 
-  fprintf(stderr, "%12" PRId64 " [E] %20s:%-4u | %-30s | %s: 0x%08x (%s)\n", microtime(), file, line, function, desc, (int)status, buffer);
+  fprintf(stderr, "[E] %20s:%-4u | %-30s | %s: 0x%08x (%s)\n", file, line, function, desc, (int)status, buffer);
   LocalFree(buffer);
-}
-
-/* credit for this function to: https://stackoverflow.com/questions/17399302/how-can-i-detect-windows-8-1-in-a-desktop-application */
-inline static BOOL CompareWindowsVersion(DWORD dwMajorVersion, DWORD dwMinorVersion)
-{
-  OSVERSIONINFOEX ver;
-  DWORDLONG dwlConditionMask = 0;
-
-  ZeroMemory(&ver, sizeof(OSVERSIONINFOEX));
-  ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
-  ver.dwMajorVersion = dwMajorVersion;
-  ver.dwMinorVersion = dwMinorVersion;
-
-  VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, VER_EQUAL);
-  VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, VER_EQUAL);
-
-  return VerifyVersionInfo(&ver, VER_MAJORVERSION | VER_MINORVERSION, dwlConditionMask);
-}
-
-bool IsWindows8()
-{
-  return
-    (CompareWindowsVersion(6, 3) == TRUE) ||
-    (CompareWindowsVersion(6, 2) == TRUE);
-}
+}

c-host/src/app.c

@@ -0,0 +1,475 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "interface/platform.h"
+#include "interface/capture.h"
+#include "dynamic/capture.h"
+#include "common/debug.h"
+#include "common/option.h"
+#include "common/locking.h"
+#include "common/KVMFR.h"
+#include "common/crash.h"
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ALIGN_DN(x) ((uintptr_t)(x) & ~0x7F)
+#define ALIGN_UP(x) ALIGN_DN(x + 0x7F)
+#define MAX_FRAMES 2
+
+struct app
+{
+  unsigned int clientInstance;
+
+  KVMFRHeader * shmHeader;
+  uint8_t     * pointerData;
+  unsigned int  pointerDataSize;
+  unsigned int  pointerOffset;
+
+  CaptureInterface * iface;
+
+  uint8_t     * frames;
+  unsigned int  frameSize;
+  FrameBuffer   frame[MAX_FRAMES];
+  unsigned int  frameOffset[MAX_FRAMES];
+
+  bool             running;
+  bool             reinit;
+  osThreadHandle * pointerThread;
+  osThreadHandle * frameThread;
+};
+
+static struct app app;
+
+static int pointerThread(void * opaque)
+{
+  DEBUG_INFO("Pointer thread started");
+
+  volatile KVMFRCursor * ci = &(app.shmHeader->cursor);
+
+  uint8_t        flags;
+  bool           pointerValid   = false;
+  bool           shapeValid     = false;
+  unsigned int   clientInstance = 0;
+  CapturePointer pointer        = { 0 };
+
+  while(app.running)
+  {
+    bool resend = false;
+
+    pointer.shapeUpdate = false;
+
+    switch(app.iface->getPointer(&pointer))
+    {
+      case CAPTURE_RESULT_OK:
+      {
+        pointerValid = true;
+        break;
+      }
+
+      case CAPTURE_RESULT_REINIT:
+      {
+        app.reinit = true;
+        DEBUG_INFO("Pointer thread reinit");
+        return 0;
+      }
+
+      case CAPTURE_RESULT_ERROR:
+      {
+        DEBUG_ERROR("Failed to get the pointer");
+        return 0;
+      }
+
+      case CAPTURE_RESULT_TIMEOUT:
+      {
+        // if the pointer is valid and the client has restarted, send it
+        if (pointerValid && clientInstance != app.clientInstance)
+        {
+          resend = true;
+          break;
+        }
+
+        continue;
+      }
+    }
+
+    clientInstance = app.clientInstance;
+
+    // wait for the client to finish with the previous update
+    while((ci->flags & ~KVMFR_CURSOR_FLAG_UPDATE) != 0 && app.running)
+      usleep(1000);
+
+    flags  = KVMFR_CURSOR_FLAG_UPDATE;
+    ci->x  = pointer.x;
+    ci->y  = pointer.y;
+    flags |= KVMFR_CURSOR_FLAG_POS;
+    if (pointer.visible)
+      flags |= KVMFR_CURSOR_FLAG_VISIBLE;
+
+    // if we have shape data
+    if (pointer.shapeUpdate || (shapeValid && resend))
+    {
+      switch(pointer.format)
+      {
+        case CAPTURE_FMT_COLOR : ci->type = CURSOR_TYPE_COLOR       ; break;
+        case CAPTURE_FMT_MONO  : ci->type = CURSOR_TYPE_MONOCHROME  ; break;
+        case CAPTURE_FMT_MASKED: ci->type = CURSOR_TYPE_MASKED_COLOR; break;
+        default:
+          DEBUG_ERROR("Invalid pointer format: %d", pointer.format);
+          continue;
+      }
+
+      ci->width   = pointer.width;
+      ci->height  = pointer.height;
+      ci->pitch   = pointer.pitch;
+      ci->dataPos = app.pointerOffset;
+      ++ci->version;
+      shapeValid = true;
+      flags |= KVMFR_CURSOR_FLAG_SHAPE;
+    }
+
+    // update the flags for the client
+    ci->flags = flags;
+  }
+
+  DEBUG_INFO("Pointer thread stopped");
+  return 0;
+}
+
+static int frameThread(void * opaque)
+{
+  DEBUG_INFO("Frame thread started");
+
+  volatile KVMFRFrame * fi = &(app.shmHeader->frame);
+
+  bool         frameValid     = false;
+  int          frameIndex     = 0;
+  unsigned int clientInstance = 0;
+  CaptureFrame frame          = { 0 };
+
+  while(app.running)
+  {
+    switch(app.iface->waitFrame(&frame))
+    {
+      case CAPTURE_RESULT_OK:
+        break;
+
+      case CAPTURE_RESULT_REINIT:
+      {
+        app.reinit = true;
+        DEBUG_INFO("Frame thread reinit");
+        return 0;
+      }
+
+      case CAPTURE_RESULT_ERROR:
+      {
+        DEBUG_ERROR("Failed to get the frame");
+        return 0;
+      }
+
+      case CAPTURE_RESULT_TIMEOUT:
+      {
+        if (frameValid && clientInstance != app.clientInstance)
+        {
+          // resend the last frame
+          if (--frameIndex < 0)
+            frameIndex = MAX_FRAMES - 1;
+          break;
+        }
+
+        continue;
+      }
+    }
+
+    clientInstance = app.clientInstance;
+
+    // wait for the client to finish with the previous frame
+    while(fi->flags & KVMFR_FRAME_FLAG_UPDATE && app.running)
+      usleep(1000);
+
+    switch(frame.format)
+    {
+      case CAPTURE_FMT_BGRA  : fi->type = FRAME_TYPE_BGRA  ; break;
+      case CAPTURE_FMT_RGBA  : fi->type = FRAME_TYPE_RGBA  ; break;
+      case CAPTURE_FMT_RGBA10: fi->type = FRAME_TYPE_RGBA10; break;
+      case CAPTURE_FMT_YUV420: fi->type = FRAME_TYPE_YUV420; break;
+      default:
+        DEBUG_ERROR("Unsupported frame format %d, skipping frame", frame.format);
+        continue;
+    }
+
+    fi->width   = frame.width;
+    fi->height  = frame.height;
+    fi->stride  = frame.stride;
+    fi->pitch   = frame.pitch;
+    fi->dataPos = app.frameOffset[frameIndex];
+    frameValid  = true;
+
+    framebuffer_prepare(app.frame[frameIndex]);
+    INTERLOCKED_OR8(&fi->flags, KVMFR_FRAME_FLAG_UPDATE);
+    app.iface->getFrame(app.frame[frameIndex]);
+
+    if (++frameIndex == MAX_FRAMES)
+      frameIndex = 0;
+  }
+  DEBUG_INFO("Frame thread stopped");
+  return 0;
+}
+
+bool startThreads()
+{
+  app.running = true;
+  if (!os_createThread("CursorThread", pointerThread, NULL, &app.pointerThread))
+  {
+    DEBUG_ERROR("Failed to create the pointer thread");
+    return false;
+  }
+
+  if (!os_createThread("FrameThread", frameThread, NULL, &app.frameThread))
+  {
+    DEBUG_ERROR("Failed to create the frame thread");
+    return false;
+  }
+
+  return true;
+}
+
+bool stopThreads()
+{
+  bool ok = true;
+
+  app.running = false;
+  app.iface->stop();
+
+  if (app.frameThread && !os_joinThread(app.frameThread, NULL))
+  {
+    DEBUG_WARN("Failed to join the frame thread");
+    ok = false;
+  }
+  app.frameThread = NULL;
+
+  if (app.pointerThread && !os_joinThread(app.pointerThread, NULL))
+  {
+    DEBUG_WARN("Failed to join the pointer thread");
+    ok = false;
+  }
+  app.pointerThread = NULL;
+
+  return ok;
+}
+
+static bool captureStart()
+{
+  DEBUG_INFO("Using            : %s", app.iface->getName());
+
+  const unsigned int maxFrameSize = app.iface->getMaxFrameSize();
+  if (maxFrameSize > app.frameSize)
+  {
+    DEBUG_ERROR("Maximum frame size of %d bytes excceds maximum space available", maxFrameSize);
+    return false;
+  }
+  DEBUG_INFO("Capture Size     : %u MiB (%u)", maxFrameSize / 1048576, maxFrameSize);
+
+  DEBUG_INFO("==== [ Capture  Start ] ====");
+  return startThreads();
+}
+
+static bool captureRestart()
+{
+  DEBUG_INFO("==== [ Capture Restart ] ====");
+  if (!stopThreads())
+    return false;
+
+  if (!app.iface->deinit() || !app.iface->init(app.pointerData, app.pointerDataSize))
+  {
+    DEBUG_ERROR("Failed to reinitialize the capture device");
+    return false;
+  }
+
+  if (!captureStart())
+    return false;
+
+  return true;
+}
+
+// this is called from the platform specific startup routine
+int app_main(int argc, char * argv[])
+{
+  if (!installCrashHandler(os_getExecutable()))
+    DEBUG_WARN("Failed to install the crash handler");
+
+  // register capture interface options
+  for(int i = 0; CaptureInterfaces[i]; ++i)
+    if (CaptureInterfaces[i]->initOptions)
+      CaptureInterfaces[i]->initOptions();
+
+  // try load values from a config file
+  option_load("looking-glass-host.ini");
+
+  // parse the command line arguments
+  if (!option_parse(argc, argv))
+  {
+    option_free();
+    DEBUG_ERROR("Failure to parse the command line");
+    return -1;
+  }
+
+  if (!option_validate())
+  {
+    option_free();
+    return -1;
+  }
+
+  // perform platform specific initialization
+  if (!app_init())
+    return -1;
+
+  unsigned int shmemSize = os_shmemSize();
+  uint8_t    * shmemMap  = NULL;
+  int          exitcode  = 0;
+
+  DEBUG_INFO("Looking Glass Host (" BUILD_VERSION ")");
+  DEBUG_INFO("IVSHMEM Size     : %u MiB", shmemSize / 1048576);
+  if (!os_shmemMmap((void **)&shmemMap) || !shmemMap)
+  {
+    DEBUG_ERROR("Failed to map the shared memory");
+    return -1;
+  }
+  DEBUG_INFO("IVSHMEM Address  : 0x%" PRIXPTR, (uintptr_t)shmemMap);
+
+  app.shmHeader        = (KVMFRHeader *)shmemMap;
+  app.pointerData      = (uint8_t *)ALIGN_UP(shmemMap + sizeof(KVMFRHeader));
+  app.pointerDataSize  = 1048576; // 1MB fixed for pointer size, should be more then enough
+  app.pointerOffset    = app.pointerData - shmemMap;
+  app.frames           = (uint8_t *)ALIGN_UP(app.pointerData + app.pointerDataSize);
+  app.frameSize        = ALIGN_DN((shmemSize - (app.frames - shmemMap)) / MAX_FRAMES);
+
+  DEBUG_INFO("Max Cursor Size  : %u MiB", app.pointerDataSize / 1048576);
+  DEBUG_INFO("Max Frame Size   : %u MiB", app.frameSize       / 1048576);
+  DEBUG_INFO("Cursor           : 0x%" PRIXPTR " (0x%08x)", (uintptr_t)app.pointerData, app.pointerOffset);
+
+  for (int i = 0; i < MAX_FRAMES; ++i)
+  {
+    app.frame      [i] = (FrameBuffer)(app.frames + i * app.frameSize);
+    app.frameOffset[i] = (uint8_t *)app.frame[i] - shmemMap;
+    DEBUG_INFO("Frame %d          : 0x%" PRIXPTR " (0x%08x)", i, (uintptr_t)app.frame[i], app.frameOffset[i]);
+  }
+
+  CaptureInterface * iface = NULL;
+  for(int i = 0; CaptureInterfaces[i]; ++i)
+  {
+    iface = CaptureInterfaces[i];
+    DEBUG_INFO("Trying           : %s", iface->getName());
+
+    if (!iface->create())
+    {
+      iface = NULL;
+      continue;
+    }
+
+    if (iface->init(app.pointerData, app.pointerDataSize))
+      break;
+
+    iface->free();
+    iface = NULL;
+  }
+
+  if (!iface)
+  {
+    DEBUG_ERROR("Failed to find a supported capture interface");
+    exitcode = -1;
+    goto fail;
+  }
+
+  app.iface = iface;
+
+  // initialize the shared memory headers
+  memcpy(app.shmHeader->magic, KVMFR_HEADER_MAGIC, sizeof(KVMFR_HEADER_MAGIC));
+  app.shmHeader->version = KVMFR_HEADER_VERSION;
+
+  // zero and notify the client we are starting
+  memset(&(app.shmHeader->frame ), 0, sizeof(KVMFRFrame ));
+  memset(&(app.shmHeader->cursor), 0, sizeof(KVMFRCursor));
+  app.shmHeader->flags &= ~KVMFR_HEADER_FLAG_RESTART;
+
+  if (!captureStart())
+  {
+    exitcode = -1;
+    goto exit;
+  }
+
+  volatile char * flags = (volatile char *)&(app.shmHeader->flags);
+
+  while(app.running)
+  {
+    if (INTERLOCKED_AND8(flags, ~(KVMFR_HEADER_FLAG_RESTART)) & KVMFR_HEADER_FLAG_RESTART)
+    {
+      DEBUG_INFO("Client restarted");
+      ++app.clientInstance;
+    }
+
+    if (app.reinit && !captureRestart())
+    {
+      exitcode = -1;
+      goto exit;
+    }
+    app.reinit = false;
+
+    switch(iface->capture())
+    {
+      case CAPTURE_RESULT_OK:
+        break;
+
+      case CAPTURE_RESULT_TIMEOUT:
+        continue;
+
+      case CAPTURE_RESULT_REINIT:
+        if (!captureRestart())
+        {
+          exitcode = -1;
+          goto exit;
+        }
+        app.reinit = false;
+        continue;
+
+      case CAPTURE_RESULT_ERROR:
+        DEBUG_ERROR("Capture interface reported a fatal error");
+        exitcode = -1;
+        goto finish;
+    }
+  }
+
+finish:
+  stopThreads();
+exit:
+
+  iface->deinit();
+  iface->free();
+fail:
+  os_shmemUnmap();
+  return exitcode;
+}
+
+void app_quit()
+{
+  app.running = false;
+}

client/.gitignore

@@ -0,0 +1,3 @@
+bin/
+build/
+*.swp

client/.vimrc

@@ -0,0 +1,10 @@
+packadd termdebug
+
+function Debug()
+	!cd build && make
+	if v:shell_error == 0
+		TermdebugCommand build/looking-glass-client
+	endif
+endfunction
+
+command Debug call Debug()

client/CMakeLists.txt

@@ -46,10 +46,6 @@ pkg_check_modules(PKGCONFIG REQUIRED
 	x11
 )
 
-pkg_check_modules(PKGCONFIG_OPT
-	xi
-)
-
 execute_process(
 	COMMAND			cat ../VERSION
 	WORKING_DIRECTORY	${PROJECT_SOURCE_DIR}
@@ -67,14 +63,13 @@ get_filename_component(PROJECT_TOP "${PROJECT_SOURCE_DIR}/.." ABSOLUTE)
 include_directories(
 	${PROJECT_SOURCE_DIR}/include
 	${CMAKE_BINARY_DIR}/include
-	${PKGCONFIG_INCLUDE_DIRS} ${PKGCONFIG_OPT_INCLUDE_DIRS}
+	${PKGCONFIG_INCLUDE_DIRS}
 	${GMP_INCLUDE_DIR}
 )
 
 link_libraries(
-	${PKGCONFIG_LIBRARIES} ${PKGCONFIG_OPT_LIBRARIES}
+	${PKGCONFIG_LIBRARIES}
 	${GMP_LIBRARIES}
-	${CMAKE_DL_LIBS}
 	rt
 	m
 )
@@ -88,22 +83,19 @@ set(SOURCES
 	src/utils.c
 )
 
-add_subdirectory("${PROJECT_TOP}/common"          "${CMAKE_BINARY_DIR}/common"   )
-add_subdirectory("${PROJECT_TOP}/repos/LGMP/lgmp" "${CMAKE_BINARY_DIR}/LGMP"     )
-add_subdirectory("${PROJECT_TOP}/repos/PureSpice" "${CMAKE_BINARY_DIR}/PureSpice")
-
+add_subdirectory("${PROJECT_TOP}/common" "${CMAKE_BINARY_DIR}/common")
+add_subdirectory(spice)
 add_subdirectory(renderers)
 add_subdirectory(clipboards)
 add_subdirectory(fonts)
 add_subdirectory(decoders)
 
 add_executable(looking-glass-client ${SOURCES})
-target_compile_options(looking-glass-client PUBLIC ${PKGCONFIG_CFLAGS_OTHER} ${PKGCONFIG_OPT_CFLAGS_OTHER})
+target_compile_options(looking-glass-client PUBLIC ${PKGCONFIG_CFLAGS_OTHER})
 target_link_libraries(looking-glass-client
 	${EXE_FLAGS}
 	lg_common
-	lgmp
-	purespice
+	spice
 	renderers
 	clipboards
 	fonts

client/README.md

@@ -46,7 +46,6 @@ Below are a list of current key bindings:
 | <kbd>ScrLk</kbd>+<kbd>F</kbd>      | Full Screen toggle |
 | <kbd>ScrLk</kbd>+<kbd>I</kbd>      | Spice keyboard & mouse enable toggle |
 | <kbd>ScrLk</kbd>+<kbd>N</kbd>      | Toggle night vision mode (EGL renderer only!) |
-| <kbd>ScrLk</kbd>+<kbd>Q</kbd>      | Quit |
 | <kbd>ScrLk</kbd>+<kbd>Insert</kbd> | Increase mouse sensitivity (in capture mode only) |
 | <kbd>ScrLk</kbd>+<kbd>Del</kbd>    | Decrease mouse sensitivity (in capture mode only) |
 | <kbd>ScrLk</kbd>+<kbd>F1</kbd>     | Send <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>F1</kbd> to the guest |

client/include/interface/renderer.h

@@ -33,7 +33,6 @@ Place, Suite 330, Boston, MA 02111-1307 USA
    (x)->create         && \
    (x)->initialize     && \
    (x)->deinitialize   && \
-   (x)->on_restart     && \
    (x)->on_resize      && \
    (x)->on_mouse_shape && \
    (x)->on_mouse_event && \
@@ -88,11 +87,10 @@ typedef void         (* LG_RendererSetup)();
 typedef bool         (* LG_RendererCreate      )(void ** opaque, const LG_RendererParams params);
 typedef bool         (* LG_RendererInitialize  )(void * opaque, Uint32 * sdlFlags);
 typedef void         (* LG_RendererDeInitialize)(void * opaque);
-typedef void         (* LG_RendererOnRestart   )(void * opaque);
 typedef void         (* LG_RendererOnResize    )(void * opaque, const int width, const int height, const LG_RendererRect destRect);
 typedef bool         (* LG_RendererOnMouseShape)(void * opaque, const LG_RendererCursor cursor, const int width, const int height, const int pitch, const uint8_t * data);
 typedef bool         (* LG_RendererOnMouseEvent)(void * opaque, const bool visible , const int x, const int y);
-typedef bool         (* LG_RendererOnFrameEvent)(void * opaque, const LG_RendererFormat format, const FrameBuffer * frame);
+typedef bool         (* LG_RendererOnFrameEvent)(void * opaque, const LG_RendererFormat format, const FrameBuffer frame);
 typedef void         (* LG_RendererOnAlert     )(void * opaque, const LG_MsgAlert alert, const char * message, bool ** closeFlag);
 typedef bool         (* LG_RendererRender      )(void * opaque, SDL_Window *window);
 typedef void         (* LG_RendererUpdateFPS   )(void * opaque, const float avgUPS, const float avgFPS);
@@ -105,7 +103,6 @@ typedef struct LG_Renderer
   LG_RendererCreate       create;
   LG_RendererInitialize   initialize;
   LG_RendererDeInitialize deinitialize;
-  LG_RendererOnRestart    on_restart;
   LG_RendererOnResize     on_resize;
   LG_RendererOnMouseShape on_mouse_shape;
   LG_RendererOnMouseEvent on_mouse_event;
@@ -115,4 +112,4 @@ typedef struct LG_Renderer
   LG_RendererRender       render;
   LG_RendererUpdateFPS    update_fps;
 }
-LG_Renderer;
+LG_Renderer;

client/include/utils.h

@@ -19,9 +19,81 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #pragma once
 
-#include <stdlib.h>
+#include <time.h>
+#include <stdint.h>
 #include <stdbool.h>
 
+static inline uint64_t microtime()
+{
+  struct timespec time;
+  clock_gettime(CLOCK_MONOTONIC_RAW, &time);
+  return ((uint64_t)time.tv_sec * 1000000) + (time.tv_nsec / 1000);
+}
+
+static inline uint64_t nanotime()
+{
+  struct timespec time;
+  clock_gettime(CLOCK_MONOTONIC_RAW, &time);
+  return ((uint64_t)time.tv_sec * 1e9) + time.tv_nsec;
+}
+
+static inline void nsleep(uint64_t ns)
+{
+  const struct timespec ts =
+  {
+    .tv_sec  = ns / 1e9,
+    .tv_nsec = ns - ((ns / 1e9) * 1e9)
+  };
+  nanosleep(&ts, NULL);
+}
+
+#ifdef ATOMIC_LOCKING
+  #define LG_LOCK_MODE    "Atomic"
+  typedef volatile int LG_Lock;
+  #define LG_LOCK_INIT(x) (x) = 0
+  #define LG_LOCK(x)      while(__sync_lock_test_and_set(&(x), 1)) {nsleep(100);}
+  #define LG_UNLOCK(x)    __sync_lock_release(&x)
+  #define LG_LOCK_FREE(x)
+#else
+  #include <SDL2/SDL.h>
+  #define LG_LOCK_MODE    "Mutex"
+  typedef SDL_mutex * LG_Lock;
+  #define LG_LOCK_INIT(x) (x = SDL_CreateMutex())
+  #define LG_LOCK(x)      SDL_LockMutex(x)
+  #define LG_UNLOCK(x)    SDL_UnlockMutex(x)
+  #define LG_LOCK_FREE(x) SDL_DestroyMutex(x)
+#endif
+
+static inline uint32_t get_bit(const uint8_t * const base, size_t * const offset)
+{
+  uint32_t out = ((*(base + (*offset >> 0x3))) >> (0x7 - (*offset & 0x7))) & 0x1;
+  ++*offset;
+  return out;
+}
+
+static inline uint32_t get_bits(const uint8_t * const base, size_t * const offset, const uint8_t bits)
+{
+  uint32_t value = 0;
+  for (int i = 0; i < bits; ++i)
+    value |= (get_bit(base, offset) ? 1 : 0) << (bits - i - 1);
+  return value;
+}
+
+static inline uint32_t decode_u_golomb(const uint8_t * const base, size_t * const offset)
+{
+  uint32_t i = 0;
+  while(get_bit(base, offset) == 0)
+    ++i;
+
+  return ((1 << i) - 1 + get_bits(base, offset, i));
+}
+
+static inline int32_t decode_s_golomb(const uint8_t * const base, size_t * const offset)
+{
+  const uint32_t g = decode_u_golomb(base, offset);
+  return (g & 0x1) ? (g + 1) / 2 : -(g / 2);
+}
+
 // reads the specified file into a new buffer
 // the callee must free the buffer
-bool file_get_contents(const char * filename, char ** buffer, size_t * length);
+bool file_get_contents(const char * filename, char ** buffer, size_t * length);

client/renderers/EGL/alert.c

@@ -19,7 +19,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include "alert.h"
 #include "common/debug.h"
-#include "common/locking.h"
+#include "utils.h"
 
 #include "texture.h"
 #include "shader.h"
@@ -215,4 +215,4 @@ void egl_alert_render(EGL_Alert * alert, const float scaleX, const float scaleY)
   egl_model_render(alert->model);
 
   glDisable(GL_BLEND);
-}
+}

client/renderers/EGL/cursor.c

@@ -19,7 +19,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include "cursor.h"
 #include "common/debug.h"
-#include "common/locking.h"
+#include "utils.h"
 
 #include "texture.h"
 #include "shader.h"
@@ -286,4 +286,4 @@ void egl_cursor_render(EGL_Cursor * cursor)
     }
   }
   glDisable(GL_BLEND);
-}
+}

client/renderers/EGL/desktop.c

@@ -20,7 +20,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include "desktop.h"
 #include "common/debug.h"
 #include "common/option.h"
-#include "common/locking.h"
+#include "utils.h"
 
 #include "texture.h"
 #include "shader.h"
@@ -47,19 +47,22 @@ struct DesktopShader
 
 struct EGL_Desktop
 {
-  void * egl;
-
   EGL_Texture          * texture;
   struct DesktopShader * shader; // the active shader
   EGL_Model            * model;
 
-  // internals
-  int width, height;
-
   // shader instances
   struct DesktopShader shader_generic;
   struct DesktopShader shader_yuv;
 
+  // internals
+  LG_Lock              updateLock;
+  enum EGL_PixelFormat pixFmt;
+  unsigned int         width, height;
+  unsigned int         pitch;
+  FrameBuffer          frame;
+  bool                 update;
+
   // night vision
   KeybindHandle kbNV;
   int   nvMax;
@@ -94,7 +97,7 @@ static bool egl_init_desktop_shader(
   return true;
 }
 
-bool egl_desktop_init(void * egl, EGL_Desktop ** desktop)
+bool egl_desktop_init(EGL_Desktop ** desktop)
 {
   *desktop = (EGL_Desktop *)malloc(sizeof(EGL_Desktop));
   if (!*desktop)
@@ -138,7 +141,8 @@ bool egl_desktop_init(void * egl, EGL_Desktop ** desktop)
   egl_model_set_default((*desktop)->model);
   egl_model_set_texture((*desktop)->model, (*desktop)->texture);
 
-  (*desktop)->egl  = egl;
+  LG_LOCK_INIT((*desktop)->updateLock);
+
   (*desktop)->kbNV = app_register_keybind(SDL_SCANCODE_N, egl_desktop_toggle_nv, *desktop);
 
   (*desktop)->nvMax  = option_get_int("egl", "nvGainMax");
@@ -164,6 +168,8 @@ void egl_desktop_free(EGL_Desktop ** desktop)
   if (!*desktop)
     return;
 
+  LG_LOCK_FREE((*desktop)->updateLock);
+
   egl_texture_free(&(*desktop)->texture              );
   egl_shader_free (&(*desktop)->shader_generic.shader);
   egl_shader_free (&(*desktop)->shader_yuv.shader    );
@@ -175,66 +181,80 @@ void egl_desktop_free(EGL_Desktop ** desktop)
   *desktop = NULL;
 }
 
-bool egl_desktop_update(EGL_Desktop * desktop, const bool sourceChanged, const LG_RendererFormat format, const FrameBuffer * frame)
+bool egl_desktop_prepare_update(EGL_Desktop * desktop, const bool sourceChanged, const LG_RendererFormat format, const FrameBuffer frame)
 {
   if (sourceChanged)
   {
-    enum EGL_PixelFormat pixFmt;
+    LG_LOCK(desktop->updateLock);
     switch(format.type)
     {
       case FRAME_TYPE_BGRA:
-        pixFmt = EGL_PF_BGRA;
+        desktop->pixFmt = EGL_PF_BGRA;
         desktop->shader = &desktop->shader_generic;
         break;
 
       case FRAME_TYPE_RGBA:
-        pixFmt = EGL_PF_RGBA;
+        desktop->pixFmt = EGL_PF_RGBA;
         desktop->shader = &desktop->shader_generic;
         break;
 
       case FRAME_TYPE_RGBA10:
-        pixFmt = EGL_PF_RGBA10;
+        desktop->pixFmt = EGL_PF_RGBA10;
         desktop->shader = &desktop->shader_generic;
         break;
 
       case FRAME_TYPE_YUV420:
-        pixFmt = EGL_PF_YUV420;
+        desktop->pixFmt = EGL_PF_YUV420;
         desktop->shader = &desktop->shader_yuv;
         break;
 
       default:
         DEBUG_ERROR("Unsupported frame format");
+        LG_UNLOCK(desktop->updateLock);
         return false;
     }
 
     desktop->width  = format.width;
     desktop->height = format.height;
+    desktop->pitch  = format.pitch;
+    desktop->frame  = frame;
+    desktop->update = true;
 
+    /* defer the actual update as the format has changed and we need to issue GL commands first */
+    LG_UNLOCK(desktop->updateLock);
+    return true;
+  }
+
+  /* update the texture now */
+  return egl_texture_update_from_frame(desktop->texture, frame);
+}
+
+void egl_desktop_perform_update(EGL_Desktop * desktop, const bool sourceChanged)
+{
+  if (sourceChanged)
+  {
+    LG_LOCK(desktop->updateLock);
     if (!egl_texture_setup(
       desktop->texture,
-      pixFmt,
-      format.width,
-      format.height,
-      format.pitch,
+      desktop->pixFmt,
+      desktop->width,
+      desktop->height,
+      desktop->pitch,
       true // streaming texture
     ))
     {
       DEBUG_ERROR("Failed to setup the desktop texture");
-      return false;
+      LG_UNLOCK(desktop->updateLock);
+      return;
     }
+    LG_UNLOCK(desktop->updateLock);
   }
 
-  if (!egl_texture_update_from_frame(desktop->texture, frame))
-    return false;
-
-  enum EGL_TexStatus status;
-  if ((status = egl_texture_process(desktop->texture)) != EGL_TEX_STATUS_OK)
+  if (desktop->update)
   {
-    if (status != EGL_TEX_STATUS_NOTREADY)
-      DEBUG_ERROR("Failed to process the desktop texture");
+    desktop->update = false;
+    egl_texture_update_from_frame(desktop->texture, desktop->frame);
   }
-
-  return true;
 }
 
 bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, const float scaleX, const float scaleY, const bool nearest)
@@ -242,6 +262,9 @@ bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, con
   if (!desktop->shader)
     return false;
 
+  if (egl_texture_process(desktop->texture) != EGL_TEX_STATUS_OK)
+    return false;
+
   const struct DesktopShader * shader = desktop->shader;
   egl_shader_use(shader->shader);
   glUniform4f(shader->uDesktopPos , x, y, scaleX, scaleY);
@@ -258,4 +281,4 @@ bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, con
 
   egl_model_render(desktop->model);
   return true;
-}
+}

client/renderers/EGL/desktop.h

@@ -25,8 +25,9 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 typedef struct EGL_Desktop EGL_Desktop;
 
-bool egl_desktop_init(void * egl, EGL_Desktop ** desktop);
+bool egl_desktop_init(EGL_Desktop ** desktop);
 void egl_desktop_free(EGL_Desktop ** desktop);
 
-bool egl_desktop_update(EGL_Desktop * desktop, const bool sourceChanged, const LG_RendererFormat format, const FrameBuffer * frame);
-bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, const float scaleX, const float scaleY, const bool nearest);
+bool egl_desktop_prepare_update(EGL_Desktop * desktop, const bool sourceChanged, const LG_RendererFormat format, const FrameBuffer frame);
+void egl_desktop_perform_update(EGL_Desktop * desktop, const bool sourceChanged);
+bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, const float scaleX, const float scaleY, const bool nearest);

client/renderers/EGL/egl.c

@@ -22,8 +22,6 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include "common/debug.h"
 #include "common/option.h"
 #include "common/sysinfo.h"
-#include "common/time.h"
-#include "common/locking.h"
 #include "utils.h"
 #include "dynamic/fonts.h"
 
@@ -55,11 +53,12 @@ struct Inst
   LG_RendererParams params;
   struct Options    opt;
 
+  EGLNativeDisplayType nativeDisp;
   EGLNativeWindowType  nativeWind;
   EGLDisplay           display;
   EGLConfig            configs;
   EGLSurface           surface;
-  EGLContext           context, frameContext;
+  EGLContext           context;
 
   EGL_Desktop     * desktop; // the desktop
   EGL_Cursor      * cursor;  // the mouse cursor
@@ -68,7 +67,7 @@ struct Inst
   EGL_Alert       * alert;   // the alert display
 
   LG_RendererFormat    format;
-  bool                 start;
+  bool                 sourceChanged;
   uint64_t             waitFadeTime;
   bool                 waitDone;
 
@@ -110,7 +109,7 @@ static struct Option egl_options[] =
     .name         = "doubleBuffer",
     .description  = "Enable double buffering",
     .type         = OPTION_TYPE_BOOL,
-    .value.x_bool = false
+    .value.x_bool = true
   },
   {
     .module       = "egl",
@@ -199,7 +198,7 @@ bool egl_initialize(void * opaque, Uint32 * sdlFlags)
       if (maxSamples > 4)
         maxSamples = 4;
 
-      DEBUG_INFO("Multisampling enabled, max samples: %d", maxSamples);
+      DEBUG_INFO("Multsampling enabled, max samples: %d", maxSamples);
       SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
       SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, maxSamples);
     }
@@ -221,20 +220,9 @@ void egl_deinitialize(void * opaque)
   egl_splash_free (&this->splash);
   egl_alert_free  (&this->alert );
 
-  LG_LOCK_FREE(this->lock);
-
   free(this);
 }
 
-void egl_on_restart(void * opaque)
-{
-  struct Inst * this = (struct Inst *)opaque;
-
-  eglDestroyContext(this->display, this->frameContext);
-  this->frameContext = NULL;
-  this->start        = false;
-}
-
 void egl_on_resize(void * opaque, const int width, const int height, const LG_RendererRect destRect)
 {
   struct Inst * this = (struct Inst *)opaque;
@@ -308,49 +296,28 @@ bool egl_on_mouse_event(void * opaque, const bool visible, const int x, const in
   return true;
 }
 
-bool egl_on_frame_event(void * opaque, const LG_RendererFormat format, const FrameBuffer * frame)
+bool egl_on_frame_event(void * opaque, const LG_RendererFormat format, const FrameBuffer frame)
 {
   struct Inst * this = (struct Inst *)opaque;
-  const bool sourceChanged = (
+  this->sourceChanged = (
+    this->sourceChanged ||
     this->format.type   != format.type   ||
     this->format.width  != format.width  ||
     this->format.height != format.height ||
     this->format.pitch  != format.pitch
   );
 
-  if (sourceChanged)
+  if (this->sourceChanged)
     memcpy(&this->format, &format, sizeof(LG_RendererFormat));
 
   this->useNearest = this->width < format.width || this->height < format.height;
 
-  /* this event runs in a second thread so we need to init it here */
-  if (!this->frameContext)
+  if (!egl_desktop_prepare_update(this->desktop, this->sourceChanged, format, frame))
   {
-    static EGLint attrs[] = {
-      EGL_CONTEXT_CLIENT_VERSION, 2,
-      EGL_NONE
-    };
-
-    if (!(this->frameContext = eglCreateContext(this->display, this->configs, this->context, attrs)))
-    {
-      DEBUG_ERROR("Failed to create the frame context");
-      return false;
-    }
-
-    if (!eglMakeCurrent(this->display, EGL_NO_SURFACE, EGL_NO_SURFACE, this->frameContext))
-    {
-      DEBUG_ERROR("Failed to make the frame context current");
-      return false;
-    }
-  }
-
-  if (!egl_desktop_update(this->desktop, sourceChanged, format, frame))
-  {
-    DEBUG_INFO("Failed to to update the desktop");
+    DEBUG_INFO("Failed to prepare to update the desktop");
     return false;
   }
 
-  this->start = true;
   return true;
 }
 
@@ -401,26 +368,11 @@ bool egl_render_startup(void * opaque, SDL_Window * window)
     return false;
   }
 
-  const char *client_exts = eglQueryString(NULL, EGL_EXTENSIONS);
-  DEBUG_INFO("Supported extensions: %s", client_exts);
-
-  bool useNative = false;
-  if (strstr(client_exts, "EGL_KHR_platform_base") != NULL)
-    useNative = true;
-
-  DEBUG_INFO("use native: %s", useNative ? "true" : "false");
-
   switch(wminfo.subsystem)
   {
     case SDL_SYSWM_X11:
     {
-      if (!useNative)
-        this->display = eglGetPlatformDisplay(EGL_PLATFORM_X11_KHR, wminfo.info.x11.display, NULL);
-      else
-      {
-        EGLNativeDisplayType native = (EGLNativeDisplayType)wminfo.info.x11.display;
-        this->display = eglGetDisplay(native);
-      }
+      this->nativeDisp = (EGLNativeDisplayType)wminfo.info.x11.display;
       this->nativeWind = (EGLNativeWindowType)wminfo.info.x11.window;
       break;
     }
@@ -430,13 +382,7 @@ bool egl_render_startup(void * opaque, SDL_Window * window)
     {
       int width, height;
       SDL_GetWindowSize(window, &width, &height);
-      if (!useNative)
-        this->display = eglGetPlatformDisplay(EGL_PLATFORM_WAYLAND_KHR, wminfo.info.wl.display, NULL);
-      else
-      {
-        EGLNativeDisplayType native = (EGLNativeDisplayType)wminfo.info.wl.display;
-        this->display = eglGetDisplay(native);
-      }
+      this->nativeDisp = (EGLNativeDisplayType)wminfo.info.wl.display;
       this->nativeWind = (EGLNativeWindowType)wl_egl_window_create(wminfo.info.wl.surface, width, height);
       break;
     }
@@ -447,6 +393,7 @@ bool egl_render_startup(void * opaque, SDL_Window * window)
       return false;
   }
 
+  this->display = eglGetDisplay(this->nativeDisp);
   if (this->display == EGL_NO_DISPLAY)
   {
     DEBUG_ERROR("eglGetDisplay failed");
@@ -503,7 +450,7 @@ bool egl_render_startup(void * opaque, SDL_Window * window)
 
   eglSwapInterval(this->display, this->opt.vsync ? 1 : 0);
 
-  if (!egl_desktop_init(this, &this->desktop))
+  if (!egl_desktop_init(&this->desktop))
   {
     DEBUG_ERROR("Failed to initialize the desktop");
     return false;
@@ -543,10 +490,7 @@ bool egl_render(void * opaque, SDL_Window * window)
   glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
   glClear(GL_COLOR_BUFFER_BIT);
 
-  if (this->start && egl_desktop_render(this->desktop,
-        this->translateX, this->translateY,
-        this->scaleX    , this->scaleY    ,
-        this->useNearest))
+  if (egl_desktop_render(this->desktop, this->translateX, this->translateY, this->scaleX, this->scaleY, this->useNearest))
   {
     if (!this->waitFadeTime)
       this->waitFadeTime = microtime() + SPLASH_FADE_TIME;
@@ -573,11 +517,6 @@ bool egl_render(void * opaque, SDL_Window * window)
     if (!this->waitDone)
       egl_splash_render(this->splash, a, this->splashRatio);
   }
-  else
-  {
-    if (!this->start)
-      egl_splash_render(this->splash, 1.0f, this->splashRatio);
-  }
 
   if (this->showAlert)
   {
@@ -595,6 +534,11 @@ bool egl_render(void * opaque, SDL_Window * window)
 
   egl_fps_render(this->fps, this->screenScaleX, this->screenScaleY);
   eglSwapBuffers(this->display, this->surface);
+
+  // defer texture uploads until after the flip to avoid stalling
+  egl_desktop_perform_update(this->desktop, this->sourceChanged);
+
+  this->sourceChanged = false;
   return true;
 }
 
@@ -614,7 +558,6 @@ struct LG_Renderer LGR_EGL =
   .create         = egl_create,
   .initialize     = egl_initialize,
   .deinitialize   = egl_deinitialize,
-  .on_restart     = egl_on_restart,
   .on_resize      = egl_on_resize,
   .on_mouse_shape = egl_on_mouse_shape,
   .on_mouse_event = egl_on_mouse_event,
@@ -623,4 +566,4 @@ struct LG_Renderer LGR_EGL =
   .render_startup = egl_render_startup,
   .render         = egl_render,
   .update_fps     = egl_update_fps
-};
+};

client/renderers/EGL/fps.c

@@ -44,7 +44,6 @@ struct EGL_FPS
   EGL_Model   * model;
 
   bool  ready;
-  int   iwidth, iheight;
   float width, height;
 
   // uniforms
@@ -145,22 +144,14 @@ void egl_fps_update(EGL_FPS * fps, const float avgFPS, const float renderFPS)
     return;
   }
 
-  if (fps->iwidth != bmp->width || fps->iheight != bmp->height)
-  {
-    fps->iwidth  = bmp->width;
-    fps->iheight = bmp->height;
-    fps->width   = (float)bmp->width;
-    fps->height  = (float)bmp->height;
-
-    egl_texture_setup(
-      fps->texture,
-      EGL_PF_BGRA,
-      bmp->width ,
-      bmp->height,
-      bmp->width * bmp->bpp,
-      false
-    );
-  }
+  egl_texture_setup(
+    fps->texture,
+    EGL_PF_BGRA,
+    bmp->width ,
+    bmp->height,
+    bmp->width * bmp->bpp,
+    false
+  );
 
   egl_texture_update
   (
@@ -168,7 +159,10 @@ void egl_fps_update(EGL_FPS * fps, const float avgFPS, const float renderFPS)
     bmp->pixels
   );
 
+  fps->width  = bmp->width;
+  fps->height = bmp->height;
   fps->ready  = true;
+
   fps->font->release(fps->fontObj, bmp);
 }
 
@@ -193,4 +187,4 @@ void egl_fps_render(EGL_FPS * fps, const float scaleX, const float scaleY)
   egl_model_render(fps->model);
 
   glDisable(GL_BLEND);
-}
+}

client/renderers/EGL/texture.c

@@ -19,6 +19,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include "texture.h"
 #include "common/debug.h"
+#include "common/locking.h"
 #include "common/framebuffer.h"
 #include "debug.h"
 #include "utils.h"
@@ -26,47 +27,33 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <stdatomic.h>
 
 #include <SDL2/SDL_egl.h>
 
-/* this must be a multiple of 2 */
-#define TEXTURE_COUNT 2
-
-struct Tex
-{
-  GLuint t[3];
-  bool   hasPBO;
-  GLuint pbo;
-  void * map;
-  GLsync sync;
-};
-
-struct TexState
-{
-  _Atomic(uint8_t) w, u, s, d;
-};
-
 struct EGL_Texture
 {
   enum   EGL_PixelFormat pixFmt;
-  size_t width, height, stride;
-  size_t bpp;
+  size_t width, height;
   bool   streaming;
   bool   ready;
 
-  int      planeCount;
+  int      textureCount;
+  GLuint   textures[3];
   GLuint   samplers[3];
-  size_t   planes  [3][3];
-  GLintptr offsets [3];
+  size_t   planes[3][3];
+  GLintptr offsets[3];
   GLenum   intFormat;
   GLenum   format;
   GLenum   dataType;
-  size_t   pboBufferSize;
 
-  struct TexState state;
-  int             textureCount;
-  struct Tex      tex[TEXTURE_COUNT];
+  bool         hasPBO;
+  GLuint       pbo[2];
+  int          pboRIndex;
+  int          pboWIndex;
+  volatile int pboCount;
+  size_t       pboBufferSize;
+  void *       pboMap[2];
+  GLsync       pboSync[2];
 };
 
 bool egl_texture_init(EGL_Texture ** texture)
@@ -79,6 +66,7 @@ bool egl_texture_init(EGL_Texture ** texture)
   }
 
   memset(*texture, 0, sizeof(EGL_Texture));
+
   return true;
 }
 
@@ -87,102 +75,44 @@ void egl_texture_free(EGL_Texture ** texture)
   if (!*texture)
     return;
 
-  if ((*texture)->planeCount > 0)
-    glDeleteSamplers((*texture)->planeCount, (*texture)->samplers);
-
-  for(int i = 0; i < (*texture)->textureCount; ++i)
+  if ((*texture)->textureCount > 0)
   {
-    struct Tex * t = &(*texture)->tex[i];
-    if (t->hasPBO)
-    {
-      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, t->pbo);
-      if ((*texture)->tex[i].map)
-      {
-        glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
-        (*texture)->tex[i].map = NULL;
-      }
-      glDeleteBuffers(1, &t->pbo);
-      if (t->sync)
-        glDeleteSync(t->sync);
-    }
-
-   if ((*texture)->planeCount > 0)
-     glDeleteTextures((*texture)->planeCount, t->t);
+    glDeleteTextures((*texture)->textureCount, (*texture)->textures);
+    glDeleteSamplers((*texture)->textureCount, (*texture)->samplers);
+  }
+
+  if ((*texture)->hasPBO)
+  {
+    for(int i = 0; i < 2; ++i)
+    {
+      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, (*texture)->pbo[i]);
+      glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+
+      if ((*texture)->pboSync[i])
+        glDeleteSync((*texture)->pboSync[i]);
+    }
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    glDeleteBuffers(2, (*texture)->pbo);
   }
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
   free(*texture);
   *texture = NULL;
 }
 
-static bool egl_texture_map(EGL_Texture * texture, uint8_t i)
-{
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->tex[i].pbo);
-  texture->tex[i].map = glMapBufferRange(
-    GL_PIXEL_UNPACK_BUFFER,
-    0,
-    texture->pboBufferSize,
-    GL_MAP_WRITE_BIT             |
-    GL_MAP_UNSYNCHRONIZED_BIT    |
-    GL_MAP_INVALIDATE_BUFFER_BIT
-  );
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-
-  if (!texture->tex[i].map)
-  {
-    EGL_ERROR("glMapBufferRange failed for %d of %lu bytes", i, texture->pboBufferSize);
-    return false;
-  }
-
-  return true;
-}
-
-static void egl_texture_unmap(EGL_Texture * texture, uint8_t i)
-{
-  if (!texture->tex[i].map)
-    return;
-
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->tex[i].pbo);
-  glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-  texture->tex[i].map = NULL;
-}
-
 bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt, size_t width, size_t height, size_t stride, bool streaming)
 {
-  int planeCount;
+  int textureCount;
 
-  if (texture->streaming)
-  {
-    for(int i = 0; i < texture->textureCount; ++i)
-    {
-      egl_texture_unmap(texture, i);
-      if (texture->tex[i].hasPBO)
-      {
-        glDeleteBuffers(1, &texture->tex[i].pbo);
-        texture->tex[i].hasPBO = false;
-      }
-    }
-  }
-
-  texture->pixFmt       = pixFmt;
-  texture->width        = width;
-  texture->height       = height;
-  texture->stride       = stride;
-  texture->streaming    = streaming;
-  texture->textureCount = streaming ? TEXTURE_COUNT : 1;
-  texture->ready        = false;
-
-  atomic_store_explicit(&texture->state.w, 0, memory_order_relaxed);
-  atomic_store_explicit(&texture->state.u, 0, memory_order_relaxed);
-  atomic_store_explicit(&texture->state.s, 0, memory_order_relaxed);
-  atomic_store_explicit(&texture->state.d, 0, memory_order_relaxed);
+  texture->pixFmt        = pixFmt;
+  texture->width         = width;
+  texture->height        = height;
+  texture->streaming     = streaming;
+  texture->ready         = false;
 
   switch(pixFmt)
   {
     case EGL_PF_BGRA:
-      planeCount             = 1;
-      texture->bpp           = 4;
+      textureCount           = 1;
       texture->format        = GL_BGRA;
       texture->planes[0][0]  = width;
       texture->planes[0][1]  = height;
@@ -194,8 +124,7 @@ bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt, size_
       break;
 
     case EGL_PF_RGBA:
-      planeCount             = 1;
-      texture->bpp           = 4;
+      textureCount           = 1;
       texture->format        = GL_RGBA;
       texture->planes[0][0]  = width;
       texture->planes[0][1]  = height;
@@ -207,8 +136,7 @@ bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt, size_
       break;
 
     case EGL_PF_RGBA10:
-      planeCount             = 1;
-      texture->bpp           = 4;
+      textureCount           = 1;
       texture->format        = GL_RGBA;
       texture->planes[0][0]  = width;
       texture->planes[0][1]  = height;
@@ -220,8 +148,7 @@ bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt, size_
       break;
 
     case EGL_PF_YUV420:
-      planeCount             = 3;
-      texture->bpp           = 4;
+      textureCount           = 3;
       texture->format        = GL_RED;
       texture->planes[0][0]  = width;
       texture->planes[0][1]  = height;
@@ -244,139 +171,128 @@ bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt, size_
       return false;
   }
 
-  if (planeCount > texture->planeCount)
+  if (textureCount > texture->textureCount)
   {
-    if (texture->planeCount > 0)
-      glDeleteSamplers(texture->planeCount, texture->samplers);
-
-    for(int i = 0; i < texture->textureCount; ++i)
+    if (texture->textureCount > 0)
     {
-      if (texture->planeCount > 0)
-        glDeleteTextures(texture->planeCount, texture->tex[i].t);
-      glGenTextures(planeCount, texture->tex[i].t);
+      glDeleteTextures(texture->textureCount, texture->textures);
+      glDeleteSamplers(texture->textureCount, texture->samplers);
     }
 
-    glGenSamplers(planeCount, texture->samplers);
-    for(int p = 0; p < planeCount; ++p)
-    {
-      glSamplerParameteri(texture->samplers[p], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-      glSamplerParameteri(texture->samplers[p], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-      glSamplerParameteri(texture->samplers[p], GL_TEXTURE_WRAP_S    , GL_CLAMP_TO_EDGE);
-      glSamplerParameteri(texture->samplers[p], GL_TEXTURE_WRAP_T    , GL_CLAMP_TO_EDGE);
-    }
-
-    texture->planeCount = planeCount;
+    texture->textureCount = textureCount;
+    glGenTextures(texture->textureCount, texture->textures);
+    glGenSamplers(texture->textureCount, texture->samplers);
   }
 
-  for(int i = 0; i < texture->textureCount; ++i)
+  for(int i = 0; i < textureCount; ++i)
   {
-    for(int p = 0; p < planeCount; ++p)
-    {
-      glBindTexture(GL_TEXTURE_2D, texture->tex[i].t[p]);
-      glTexImage2D(GL_TEXTURE_2D, 0, texture->intFormat, texture->planes[p][0],
-        texture->planes[p][1], 0, texture->format, texture->dataType, NULL);
-    }
+    glSamplerParameteri(texture->samplers[i], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glSamplerParameteri(texture->samplers[i], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glSamplerParameteri(texture->samplers[i], GL_TEXTURE_WRAP_S    , GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(texture->samplers[i], GL_TEXTURE_WRAP_T    , GL_CLAMP_TO_EDGE);
+
+    glBindTexture(GL_TEXTURE_2D, texture->textures[i]);
+    glTexImage2D(GL_TEXTURE_2D, 0, texture->intFormat, texture->planes[i][0], texture->planes[i][1],
+        0, texture->format, texture->dataType, NULL);
   }
   glBindTexture(GL_TEXTURE_2D, 0);
 
-  if (!streaming)
-    return true;
-
-  for(int i = 0; i < texture->textureCount; ++i)
+  if (streaming)
   {
-    glGenBuffers(1, &texture->tex[i].pbo);
-    texture->tex[i].hasPBO = true;
+    if (texture->hasPBO)
+    {
+      // release old PBOs and delete the buffers
+      for(int i = 0; i < 2; ++i)
+      {
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->pbo[i]);
+        glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+      }
+      glDeleteBuffers(2, texture->pbo);
+    }
 
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->tex[i].pbo);
-    glBufferStorage(
-      GL_PIXEL_UNPACK_BUFFER,
-      texture->pboBufferSize,
-      NULL,
-      GL_MAP_WRITE_BIT
-    );
+    glGenBuffers(2, texture->pbo);
+    texture->hasPBO = true;
+    for(int i = 0; i < 2; ++i)
+    {
+      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->pbo[i]);
+      glBufferStorage(
+        GL_PIXEL_UNPACK_BUFFER,
+        texture->pboBufferSize,
+        NULL,
+        GL_MAP_PERSISTENT_BIT |
+        GL_MAP_WRITE_BIT
+      );
+
+      texture->pboMap[i] = glMapBufferRange(
+        GL_PIXEL_UNPACK_BUFFER,
+        0,
+        texture->pboBufferSize,
+        GL_MAP_PERSISTENT_BIT        |
+        GL_MAP_WRITE_BIT             |
+        GL_MAP_UNSYNCHRONIZED_BIT    |
+        GL_MAP_INVALIDATE_BUFFER_BIT |
+        GL_MAP_FLUSH_EXPLICIT_BIT
+      );
+
+      if (!texture->pboMap[i])
+      {
+        EGL_ERROR("glMapBufferRange failed for %d of %lu bytes", i, texture->pboBufferSize);
+        return false;
+      }
+    }
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
   }
 
   return true;
 }
 
-static void egl_warn_slow()
-{
-  static bool warnDone = false;
-  if (!warnDone)
-  {
-    warnDone = true;
-    DEBUG_BREAK();
-    DEBUG_WARN("The guest is providing updates faster then your computer can display them");
-    DEBUG_WARN("This is a hardware limitation, expect microstutters & frame skips");
-    DEBUG_BREAK();
-  }
-}
-
 bool egl_texture_update(EGL_Texture * texture, const uint8_t * buffer)
 {
   if (texture->streaming)
   {
-    const uint8_t sw =
-      atomic_load_explicit(&texture->state.w, memory_order_acquire);
+    /* NOTE: DO NOT use any gl commands here as streaming must be thread safe */
 
-    if (atomic_load_explicit(&texture->state.u, memory_order_acquire) == sw + 1)
-    {
-      egl_warn_slow();
+    if (texture->pboCount == 2)
       return true;
-    }
 
-    const uint8_t t = sw % TEXTURE_COUNT;
-    if (!egl_texture_map(texture, t))
-      return EGL_TEX_STATUS_ERROR;
+    /* update the GPU buffer */
+    memcpy(texture->pboMap[texture->pboWIndex], buffer, texture->pboBufferSize);
+    texture->pboSync[texture->pboWIndex] = 0;
 
-    memcpy(texture->tex[t].map, buffer, texture->pboBufferSize);
-    atomic_fetch_add_explicit(&texture->state.w, 1, memory_order_release);
-    egl_texture_unmap(texture, t);
+    if (++texture->pboWIndex == 2)
+      texture->pboWIndex = 0;
+    INTERLOCKED_INC(&texture->pboCount);
   }
   else
   {
-    for(int p = 0; p < texture->planeCount; ++p)
+    /* Non streaming, this is NOT thread safe */
+
+    for(int i = 0; i < texture->textureCount; ++i)
     {
-      glBindTexture(GL_TEXTURE_2D, texture->tex[0].t[p]);
-      glPixelStorei(GL_UNPACK_ROW_LENGTH, texture->planes[p][0]);
-      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->planes[p][0], texture->planes[p][1],
-          texture->format, texture->dataType, buffer + texture->offsets[p]);
+      glBindTexture(GL_TEXTURE_2D, texture->textures[i]);
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, texture->planes[i][0]);
+      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->planes[i][0], texture->planes[i][1],
+          texture->format, texture->dataType, buffer + texture->offsets[i]);
     }
     glBindTexture(GL_TEXTURE_2D, 0);
   }
   return true;
 }
 
-bool egl_texture_update_from_frame(EGL_Texture * texture, const FrameBuffer * frame)
+bool egl_texture_update_from_frame(EGL_Texture * texture, const FrameBuffer frame)
 {
   if (!texture->streaming)
     return false;
 
-  const uint8_t sw =
-    atomic_load_explicit(&texture->state.w, memory_order_acquire);
-
-  if (atomic_load_explicit(&texture->state.u, memory_order_acquire) == sw + 1)
-  {
-    egl_warn_slow();
+  if (texture->pboCount == 2)
     return true;
-  }
 
-  const uint8_t t = sw % TEXTURE_COUNT;
-  if (!egl_texture_map(texture, t))
-    return EGL_TEX_STATUS_ERROR;
+  framebuffer_read(frame, texture->pboMap[texture->pboWIndex], texture->pboBufferSize);
+  texture->pboSync[texture->pboWIndex] = 0;
 
-  framebuffer_read(
-    frame,
-    texture->tex[t].map,
-    texture->stride,
-    texture->height,
-    texture->width,
-    texture->bpp,
-    texture->stride
-  );
-
-  atomic_fetch_add_explicit(&texture->state.w, 1, memory_order_release);
-  egl_texture_unmap(texture, t);
+  if (++texture->pboWIndex == 2)
+    texture->pboWIndex = 0;
+  INTERLOCKED_INC(&texture->pboCount);
 
   return true;
 }
@@ -386,87 +302,78 @@ enum EGL_TexStatus egl_texture_process(EGL_Texture * texture)
   if (!texture->streaming)
     return EGL_TEX_STATUS_OK;
 
-  const uint8_t su =
-    atomic_load_explicit(&texture->state.u, memory_order_acquire);
-
-  const uint8_t nextu = su + 1;
-  if (
-      su    == atomic_load_explicit(&texture->state.w, memory_order_acquire) ||
-      nextu == atomic_load_explicit(&texture->state.s, memory_order_acquire) ||
-      nextu == atomic_load_explicit(&texture->state.d, memory_order_acquire))
+  if (texture->pboCount == 0)
     return texture->ready ? EGL_TEX_STATUS_OK : EGL_TEX_STATUS_NOTREADY;
 
-  /* update the texture */
-  const uint8_t t = su % TEXTURE_COUNT;
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->tex[t].pbo);
-  for(int p = 0; p < texture->planeCount; ++p)
+  /* process any buffers that have not yet been flushed */
+  int pos = texture->pboRIndex;
+  for(int i = 0; i < texture->pboCount; ++i)
   {
-    glBindTexture(GL_TEXTURE_2D, texture->tex[t].t[p]);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, texture->planes[p][2]);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->planes[p][0], texture->planes[p][1],
-        texture->format, texture->dataType, (const void *)texture->offsets[p]);
+    if (texture->pboSync[pos] == 0)
+    {
+      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->pbo[pos]);
+      glFlushMappedBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, texture->pboBufferSize);
+      texture->pboSync[pos] = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+    }
 
+    if (++pos == 2)
+      pos = 0;
   }
   glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
-  /* create a fence to prevent usage before the update is complete */
-  texture->tex[t].sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+  /* wait for the buffer to be ready */
+  pos = texture->pboRIndex;
+  switch(glClientWaitSync(texture->pboSync[pos], 0, 0))
+  {
+    case GL_ALREADY_SIGNALED:
+    case GL_CONDITION_SATISFIED:
+      break;
 
-  /* we must flush to ensure the sync is in the command buffer */
-  glFlush();
+    case GL_TIMEOUT_EXPIRED:
+      return texture->ready ? EGL_TEX_STATUS_OK : EGL_TEX_STATUS_NOTREADY;
+
+    case GL_WAIT_FAILED:
+      glDeleteSync(texture->pboSync[pos]);
+      EGL_ERROR("glClientWaitSync failed");
+      return EGL_TEX_STATUS_ERROR;
+  }
+
+  /* delete the sync and bind the buffer */
+  glDeleteSync(texture->pboSync[pos]);
+  texture->pboSync[pos] = 0;
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->pbo[pos]);
+
+  /* update the textures */
+  for(int i = 0; i < texture->textureCount; ++i)
+  {
+    glBindTexture(GL_TEXTURE_2D, texture->textures[i]);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, texture->planes[i][2]);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->planes[i][0], texture->planes[i][1],
+        texture->format, texture->dataType, (const void *)texture->offsets[i]);
+  }
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  /* advance the read index */
+  if (++texture->pboRIndex == 2)
+    texture->pboRIndex = 0;
+  INTERLOCKED_DEC(&texture->pboCount);
 
   texture->ready = true;
-  atomic_fetch_add_explicit(&texture->state.u, 1, memory_order_release);
 
   return EGL_TEX_STATUS_OK;
 }
 
 enum EGL_TexStatus egl_texture_bind(EGL_Texture * texture)
 {
-  uint8_t ss = atomic_load_explicit(&texture->state.s, memory_order_acquire);
-  uint8_t sd = atomic_load_explicit(&texture->state.d, memory_order_acquire);
+  /* if there are no new buffers ready, then just bind the textures */
+  if (texture->streaming && !texture->ready)
+    return EGL_TEX_STATUS_NOTREADY;
 
-  if (texture->streaming)
-  {
-    if (!texture->ready)
-      return EGL_TEX_STATUS_NOTREADY;
-
-    const uint8_t t = ss % TEXTURE_COUNT;
-    if (texture->tex[t].sync != 0)
-    {
-      switch(glClientWaitSync(texture->tex[t].sync, 0, 20000000)) // 20ms
-      {
-        case GL_ALREADY_SIGNALED:
-        case GL_CONDITION_SATISFIED:
-          glDeleteSync(texture->tex[t].sync);
-          texture->tex[t].sync = 0;
-
-          ss = atomic_fetch_add_explicit(&texture->state.s, 1,
-              memory_order_release) + 1;
-          break;
-
-        case GL_TIMEOUT_EXPIRED:
-          break;
-
-        case GL_WAIT_FAILED:
-        case GL_INVALID_VALUE:
-          glDeleteSync(texture->tex[t].sync);
-          texture->tex[t].sync = 0;
-          EGL_ERROR("glClientWaitSync failed");
-          return EGL_TEX_STATUS_ERROR;
-      }
-    }
-
-    if (ss != sd && ss != sd+1)
-      sd = atomic_fetch_add_explicit(&texture->state.d, 1,
-          memory_order_release) + 1;
-  }
-
-  const uint8_t t = sd % TEXTURE_COUNT;
-  for(int i = 0; i < texture->planeCount; ++i)
+  for(int i = 0; i < texture->textureCount; ++i)
   {
     glActiveTexture(GL_TEXTURE0 + i);
-    glBindTexture(GL_TEXTURE_2D, texture->tex[t].t[i]);
+    glBindTexture(GL_TEXTURE_2D, texture->textures[i]);
     glBindSampler(i, texture->samplers[i]);
   }
 
@@ -475,5 +382,5 @@ enum EGL_TexStatus egl_texture_bind(EGL_Texture * texture)
 
 int egl_texture_count(EGL_Texture * texture)
 {
-  return texture->planeCount;
-}
+  return texture->textureCount;
+}

client/renderers/EGL/texture.h

@@ -47,7 +47,7 @@ void egl_texture_free(EGL_Texture ** tex);
 
 bool               egl_texture_setup  (EGL_Texture * texture, enum EGL_PixelFormat pixfmt, size_t width, size_t height, size_t stride, bool streaming);
 bool               egl_texture_update (EGL_Texture * texture, const uint8_t * buffer);
-bool               egl_texture_update_from_frame(EGL_Texture * texture, const FrameBuffer * frame);
+bool               egl_texture_update_from_frame(EGL_Texture * texture, const FrameBuffer frame);
 enum EGL_TexStatus egl_texture_process(EGL_Texture * texture);
 enum EGL_TexStatus egl_texture_bind          (EGL_Texture * texture);
-int                egl_texture_count         (EGL_Texture * texture);
+int                egl_texture_count         (EGL_Texture * texture);

client/renderers/OpenGL/opengl.c

@@ -33,7 +33,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include "common/debug.h"
 #include "common/option.h"
 #include "common/framebuffer.h"
-#include "common/locking.h"
+#include "utils.h"
 #include "dynamic/fonts.h"
 #include "ll.h"
 
@@ -77,8 +77,7 @@ static struct Option opengl_options[] =
     .description  = "Use GL_AMD_pinned_memory if it is available",
     .type         = OPTION_TYPE_BOOL,
     .value.x_bool = true
-  },
-  {0}
+  }
 };
 
 struct OpenGL_Options
@@ -117,14 +116,14 @@ struct Inst
   const LG_Font   * font;
   LG_FontObj        fontObj, alertFontObj;
 
-  LG_Lock             formatLock;
-  LG_RendererFormat   format;
-  GLuint              intFormat;
-  GLuint              vboFormat;
-  GLuint              dataFormat;
-  size_t              texSize;
-  size_t              texPos;
-  const FrameBuffer * frame;
+  LG_Lock           formatLock;
+  LG_RendererFormat format;
+  GLuint            intFormat;
+  GLuint            vboFormat;
+  GLuint            dataFormat;
+  size_t            texSize;
+  size_t            texPos;
+  FrameBuffer       frame;
 
   uint64_t          drawStart;
   bool              hasBuffers;
@@ -170,15 +169,8 @@ struct Inst
 static bool _check_gl_error(unsigned int line, const char * name);
 #define check_gl_error(name) _check_gl_error(__LINE__, name)
 
-enum ConfigStatus
-{
-  CONFIG_STATUS_OK,
-  CONFIG_STATUS_ERROR,
-  CONFIG_STATUS_NOOP
-};
-
 static void deconfigure(struct Inst * this);
-static enum ConfigStatus configure(struct Inst * this, SDL_Window *window);
+static bool configure(struct Inst * this, SDL_Window *window);
 static void update_mouse_shape(struct Inst * this, bool * newShape);
 static bool draw_frame(struct Inst * this);
 static void draw_mouse(struct Inst * this);
@@ -295,12 +287,6 @@ void opengl_deinitialize(void * opaque)
   free(this);
 }
 
-void opengl_on_restart(void * opaque)
-{
-  struct Inst * this = (struct Inst *)opaque;
-  this->waiting = true;
-}
-
 void opengl_on_resize(void * opaque, const int width, const int height, const LG_RendererRect destRect)
 {
   struct Inst * this = (struct Inst *)opaque;
@@ -375,7 +361,7 @@ bool opengl_on_mouse_event(void * opaque, const bool visible, const int x, const
   return false;
 }
 
-bool opengl_on_frame_event(void * opaque, const LG_RendererFormat format, const FrameBuffer * frame)
+bool opengl_on_frame_event(void * opaque, const LG_RendererFormat format, const FrameBuffer frame)
 {
   struct Inst * this = (struct Inst *)opaque;
   if (!this)
@@ -563,18 +549,10 @@ bool opengl_render(void * opaque, SDL_Window * window)
   if (!this)
     return false;
 
-  switch(configure(this, window))
-  {
-    case CONFIG_STATUS_ERROR:
-      DEBUG_ERROR("configure failed");
+  if (configure(this, window))
+    if (!draw_frame(this))
       return false;
 
-    case CONFIG_STATUS_NOOP :
-    case CONFIG_STATUS_OK   :
-     if (!draw_frame(this))
-       return false;
-  }
-
   glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
   glClear(GL_COLOR_BUFFER_BIT);
 
@@ -829,7 +807,6 @@ const LG_Renderer LGR_OpenGL =
   .create         = opengl_create,
   .initialize     = opengl_initialize,
   .deinitialize   = opengl_deinitialize,
-  .on_restart     = opengl_on_restart,
   .on_resize      = opengl_on_resize,
   .on_mouse_shape = opengl_on_mouse_shape,
   .on_mouse_event = opengl_on_mouse_event,
@@ -851,13 +828,13 @@ static bool _check_gl_error(unsigned int line, const char * name)
   return true;
 }
 
-static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
+static bool configure(struct Inst * this, SDL_Window *window)
 {
   LG_LOCK(this->formatLock);
   if (!this->reconfigure)
   {
     LG_UNLOCK(this->formatLock);
-    return CONFIG_STATUS_NOOP;
+    return this->configured;
   }
 
   if (this->configured)
@@ -885,7 +862,7 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
 
     default:
       DEBUG_ERROR("Unknown/unsupported compression type");
-      return CONFIG_STATUS_ERROR;
+      return false;
   }
 
   // calculate the texture size in bytes
@@ -903,36 +880,30 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
   if (this->amdPinnedMemSupport)
   {
     const int pagesize = getpagesize();
+    this->texPixels[0] = memalign(pagesize, this->texSize * BUFFER_COUNT);
+    memset(this->texPixels[0], 0, this->texSize * BUFFER_COUNT);
+    for(int i = 1; i < BUFFER_COUNT; ++i)
+      this->texPixels[i] = this->texPixels[0] + this->texSize;
 
     for(int i = 0; i < BUFFER_COUNT; ++i)
     {
-      this->texPixels[i] = aligned_alloc(pagesize, this->texSize);
-      if (!this->texPixels[i])
-      {
-        DEBUG_ERROR("Failed to allocate memory for texture");
-        return CONFIG_STATUS_ERROR;
-      }
-
-      memset(this->texPixels[i], 0, this->texSize);
-
       glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, this->vboID[i]);
+
       if (check_gl_error("glBindBuffer"))
       {
         LG_UNLOCK(this->formatLock);
-        return CONFIG_STATUS_ERROR;
+        return false;
       }
-
       glBufferData(
         GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD,
         this->texSize,
         this->texPixels[i],
-        GL_STREAM_DRAW
-      );
+        GL_STREAM_DRAW);
 
       if (check_gl_error("glBufferData"))
       {
         LG_UNLOCK(this->formatLock);
-        return CONFIG_STATUS_ERROR;
+        return false;
       }
     }
     glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0);
@@ -945,7 +916,7 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
       if (check_gl_error("glBindBuffer"))
       {
         LG_UNLOCK(this->formatLock);
-        return CONFIG_STATUS_ERROR;
+        return false;
       }
 
       glBufferData(
@@ -957,7 +928,7 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
       if (check_gl_error("glBufferData"))
       {
         LG_UNLOCK(this->formatLock);
-        return CONFIG_STATUS_ERROR;
+        return false;
       }
     }
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
@@ -968,7 +939,7 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
   if (check_gl_error("glGenTextures"))
   {
     LG_UNLOCK(this->formatLock);
-    return CONFIG_STATUS_ERROR;
+    return false;
   }
   this->hasFrames = true;
 
@@ -979,7 +950,7 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
     if (check_gl_error("glBindTexture"))
     {
       LG_UNLOCK(this->formatLock);
-      return CONFIG_STATUS_ERROR;
+      return false;
     }
 
     glTexImage2D(
@@ -996,7 +967,7 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
     if (check_gl_error("glTexImage2D"))
     {
       LG_UNLOCK(this->formatLock);
-      return CONFIG_STATUS_ERROR;
+      return false;
     }
 
     // configure the texture
@@ -1027,7 +998,7 @@ static enum ConfigStatus configure(struct Inst * this, SDL_Window *window)
   this->reconfigure = false;
 
   LG_UNLOCK(this->formatLock);
-  return CONFIG_STATUS_OK;
+  return true;
 }
 
 static void deconfigure(struct Inst * this)
@@ -1055,6 +1026,9 @@ static void deconfigure(struct Inst * this)
 
   if (this->amdPinnedMemSupport)
   {
+    if (this->texPixels[0])
+      free(this->texPixels[0]);
+
     for(int i = 0; i < BUFFER_COUNT; ++i)
     {
       if (this->fences[i])
@@ -1062,12 +1036,7 @@ static void deconfigure(struct Inst * this)
         glDeleteSync(this->fences[i]);
         this->fences[i] = NULL;
       }
-
-      if (this->texPixels[i])
-      {
-        free(this->texPixels[i]);
-        this->texPixels[i] = NULL;
-      }
+      this->texPixels[i] = NULL;
     }
   }
 
@@ -1281,19 +1250,14 @@ static bool draw_frame(struct Inst * this)
   glBindTexture(GL_TEXTURE_2D, this->frames[this->texIndex]);
   glBindBuffer(GL_PIXEL_UNPACK_BUFFER, this->vboID[this->texIndex]);
 
-  const int bpp = this->format.bpp / 8;
-  glPixelStorei(GL_UNPACK_ALIGNMENT , bpp);
-  glPixelStorei(GL_UNPACK_ROW_LENGTH, this->format.width);
+  glPixelStorei(GL_UNPACK_ALIGNMENT  , 4);
+  glPixelStorei(GL_UNPACK_ROW_LENGTH , this->format.stride);
 
   this->texPos = 0;
-
   framebuffer_read_fn(
     this->frame,
-    this->format.height,
-    this->format.width,
-    bpp,
-    this->format.pitch,
     opengl_buffer_fn,
+    this->format.height * this->format.stride,
     this
   );
 
@@ -1355,4 +1319,4 @@ static void draw_mouse(struct Inst * this)
   glTranslatef(this->mousePos.x, this->mousePos.y, 0.0f);
   glCallList(this->mouseList);
   glPopMatrix();
-}
+}

client/spice/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.0)
+project(spice LANGUAGES C)
+
+find_package(PkgConfig)
+pkg_check_modules(SPICE_PKGCONFIG REQUIRED
+	spice-protocol
+	nettle
+	hogweed
+)
+
+add_definitions(-D USE_NETTLE)
+
+add_library(spice STATIC
+	src/spice.c
+	src/rsa.c
+)
+
+target_link_libraries(spice
+	lg_common
+	${SPICE_PKGCONFIG_LIBRARIES}
+)
+
+target_include_directories(spice
+	PUBLIC
+		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+		$<INSTALL_INTERFACE:include>
+	PRIVATE
+		src
+		${SPICE_PKGCONFIG_INCLUDE_DIRS}
+)

client/spice/include/spice/spice.h

@@ -0,0 +1,64 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef enum SpiceDataType
+{
+  SPICE_DATA_TEXT,
+  SPICE_DATA_PNG,
+  SPICE_DATA_BMP,
+  SPICE_DATA_TIFF,
+  SPICE_DATA_JPEG,
+
+  SPICE_DATA_NONE
+}
+SpiceDataType;
+
+typedef void (*SpiceClipboardNotice )(const SpiceDataType type);
+typedef void (*SpiceClipboardData   )(const SpiceDataType type, uint8_t * buffer, uint32_t size);
+typedef void (*SpiceClipboardRelease)();
+typedef void (*SpiceClipboardRequest)(const SpiceDataType type);
+
+bool spice_connect(const char * host, const unsigned short port, const char * password);
+void spice_disconnect();
+bool spice_process();
+bool spice_ready();
+
+bool spice_key_down      (uint32_t code);
+bool spice_key_up        (uint32_t code);
+bool spice_mouse_mode    (bool     server);
+bool spice_mouse_position(uint32_t x, uint32_t y);
+bool spice_mouse_motion  ( int32_t x,  int32_t y);
+bool spice_mouse_press   (uint32_t button);
+bool spice_mouse_release (uint32_t button);
+
+bool spice_clipboard_request(SpiceDataType type);
+bool spice_clipboard_grab   (SpiceDataType type);
+bool spice_clipboard_release();
+bool spice_clipboard_data   (SpiceDataType type, uint8_t * data, size_t size);
+
+/* events */
+bool spice_set_clipboard_cb(
+    SpiceClipboardNotice  cbNoticeFn,
+    SpiceClipboardData    cbDataFn,
+    SpiceClipboardRelease cbReleaseFn,
+    SpiceClipboardRequest cbRequestFn);

client/spice/src/messages.h

@@ -0,0 +1,146 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <stdint.h>
+
+#pragma pack(push,1)
+
+typedef struct SpicePoint16
+{
+  int16_t x, y;
+}
+SpicePoint16;
+
+typedef struct SpiceMsgMainInit
+{
+  uint32_t session_id;
+  uint32_t display_channels_hint;
+  uint32_t supported_mouse_modes;
+  uint32_t current_mouse_mode;
+  uint32_t agent_connected;
+  uint32_t agent_tokens;
+  uint32_t multi_media_time;
+  uint32_t ram_hint;
+}
+SpiceMsgMainInit;
+
+typedef struct SpiceChannelID
+{
+  uint8_t type;
+  uint8_t channel_id;
+}
+SpiceChannelID;
+
+typedef struct SpiceMsgMainChannelsList
+{
+  uint32_t num_of_channels;
+  //SpiceChannelID channels[num_of_channels]
+}
+SpiceMainChannelsList;
+
+typedef struct SpiceMsgcMainMouseModeRequest
+{
+  uint16_t mouse_mode;
+}
+SpiceMsgcMainMouseModeRequest;
+
+typedef struct SpiceMsgPing
+{
+  uint32_t id;
+  uint64_t timestamp;
+}
+SpiceMsgPing,
+SpiceMsgcPong;
+
+typedef struct SpiceMsgSetAck
+{
+  uint32_t generation;
+  uint32_t window;
+}
+SpiceMsgSetAck;
+
+typedef struct SpiceMsgcAckSync
+{
+  uint32_t generation;
+}
+SpiceMsgcAckSync;
+
+typedef struct SpiceMsgNotify
+{
+  uint64_t time_stamp;
+  uint32_t severity;
+  uint32_t visibility;
+  uint32_t what;
+  uint32_t message_len;
+  //char message[message_len+1]
+}
+SpiceMsgNotify;
+
+typedef struct SpiceMsgInputsInit
+{
+  uint16_t modifiers;
+}
+SpiceMsgInputsInit,
+SpiceMsgInputsKeyModifiers,
+SpiceMsgcInputsKeyModifiers;
+
+typedef struct SpiceMsgcKeyDown
+{
+  uint32_t code;
+}
+SpiceMsgcKeyDown,
+SpiceMsgcKeyUp;
+
+typedef struct SpiceMsgcMousePosition
+{
+  uint32_t x;
+  uint32_t y;
+  uint16_t button_state;
+  uint8_t  display_id;
+}
+SpiceMsgcMousePosition;
+
+typedef struct SpiceMsgcMouseMotion
+{
+  int32_t  x;
+  int32_t  y;
+  uint16_t button_state;
+}
+SpiceMsgcMouseMotion;
+
+typedef struct SpiceMsgcMousePress
+{
+  uint8_t  button;
+  uint16_t button_state;
+}
+SpiceMsgcMousePress,
+SpiceMsgcMouseRelease;
+
+
+// spice is missing these defines, the offical reference library incorrectly uses the VD defines
+#define COMMON_CAPS_BYTES (((SPICE_COMMON_CAP_MINI_HEADER + 32) / 8) & ~3)
+#define COMMON_SET_CAPABILITY(caps, index) \
+    { (caps)[(index) / 32] |= (1 << ((index) % 32)); }
+
+#define MAIN_CAPS_BYTES (((SPICE_MAIN_CAP_SEAMLESS_MIGRATE + 32) / 8) & ~3)
+#define MAIN_SET_CAPABILITY(caps, index) \
+    { (caps)[(index) / 32] |= (1 << ((index) % 32)); }
+
+
+#pragma pack(pop)

client/spice/src/rsa.c

@@ -0,0 +1,227 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "rsa.h"
+#include "common/debug.h"
+
+#include <spice/protocol.h>
+#include <malloc.h>
+#include <string.h>
+
+#if defined(USE_OPENSSL) && defined(USE_NETTLE)
+  #error "USE_OPENSSL and USE_NETTLE are both defined"
+#elif !defined(USE_OPENSSL) && !defined(USE_NETTLE)
+  #error "One of USE_OPENSSL or USE_NETTLE must be defined"
+#endif
+
+#if defined(USE_OPENSSL)
+#include <openssl/rsa.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+#endif
+
+#if defined(USE_NETTLE)
+#include <stdlib.h>
+#include <nettle/asn1.h>
+#include <nettle/sha1.h>
+#include <nettle/rsa.h>
+#include <nettle/bignum.h>
+#include <gmp.h>
+
+#define SHA1_HASH_LEN 20
+#endif
+
+#if defined(USE_NETTLE)
+/* the below OAEP implementation is derived from the FreeTDS project */
+static void memxor(uint8_t * a, const uint8_t * b, const unsigned int len)
+{
+  for(unsigned int i = 0; i < len; ++i)
+    a[i] = a[i] ^ b[i];
+}
+
+static void sha1(uint8_t * hash, const uint8_t *data, unsigned int len)
+{
+  struct sha1_ctx ctx;
+
+  sha1_init(&ctx);
+  sha1_update(&ctx, len, data);
+  sha1_digest(&ctx, SHA1_HASH_LEN, hash);
+}
+
+static void oaep_mask(uint8_t * dest, size_t dest_len, const uint8_t * mask, size_t mask_len)
+{
+  uint8_t hash[SHA1_HASH_LEN];
+  uint8_t seed[mask_len + 4 ];
+  memcpy(seed, mask, mask_len);
+
+  for(unsigned int n = 0;; ++n)
+  {
+    (seed+mask_len)[0] = n >> 24;
+    (seed+mask_len)[1] = n >> 16;
+    (seed+mask_len)[2] = n >> 8;
+    (seed+mask_len)[3] = n >> 0;
+
+    sha1(hash, seed, sizeof(seed));
+    if (dest_len <= SHA1_HASH_LEN)
+    {
+      memxor(dest, hash, dest_len);
+      break;
+    }
+
+    memxor(dest, hash, SHA1_HASH_LEN);
+    dest     += SHA1_HASH_LEN;
+    dest_len -= SHA1_HASH_LEN;
+  }
+}
+
+static bool oaep_pad(mpz_t m, unsigned int key_size, const uint8_t * message, unsigned int len)
+{
+  if (len + SHA1_HASH_LEN * 2 + 2 > key_size)
+  {
+    DEBUG_ERROR("Message too long");
+    return false;
+  }
+
+  struct
+  {
+    uint8_t all[1];
+    uint8_t ros[SHA1_HASH_LEN];
+    uint8_t db [key_size - SHA1_HASH_LEN - 1];
+  } em;
+
+  memset(&em, 0, sizeof(em));
+  sha1(em.db, (uint8_t *)"", 0);
+  em.all[key_size - len - 1] = 0x1;
+  memcpy(em.all + (key_size - len), message, len);
+
+  /* we are not too worried about randomness since we are just making a local
+   * connection, should anyone use this code outside of LookingGlass please be
+   * sure to use something better such as `gnutls_rnd` */
+  for(int i = 0; i < SHA1_HASH_LEN; ++i)
+    em.ros[i] = rand() % 255;
+
+  const int db_len = key_size - SHA1_HASH_LEN - 1;
+  oaep_mask(em.db , db_len       , em.ros, SHA1_HASH_LEN);
+  oaep_mask(em.ros, SHA1_HASH_LEN, em.db , db_len       );
+
+  nettle_mpz_set_str_256_u(m, key_size, em.all);
+  return true;
+}
+#endif
+
+bool spice_rsa_encrypt_password(uint8_t * pub_key, char * password, struct spice_password * result)
+{
+  result->size = 0;
+  result->data = NULL;
+
+#if defined(USE_OPENSSL)
+  BIO *bioKey = BIO_new(BIO_s_mem());
+  if (!bioKey)
+  {
+    DEBUG_ERROR("failed to allocate bioKey");
+    return false;
+  }
+
+  BIO_write(bioKey, pub_key, SPICE_TICKET_PUBKEY_BYTES);
+  EVP_PKEY *rsaKey = d2i_PUBKEY_bio(bioKey, NULL);
+  RSA *rsa = EVP_PKEY_get1_RSA(rsaKey);
+
+  result->size = RSA_size(rsa);
+  result->data = (char *)malloc(result->size);
+
+  if (RSA_public_encrypt(
+        strlen(password) + 1,
+        (uint8_t*)password,
+        (uint8_t*)result->data,
+        rsa,
+        RSA_PKCS1_OAEP_PADDING
+  ) <= 0)
+  {
+    free(result->data);
+    result->size = 0;
+    result->data = NULL;
+
+    DEBUG_ERROR("rsa public encrypt failed");
+    EVP_PKEY_free(rsaKey);
+    BIO_free(bioKey);
+    return false;
+  }
+
+  EVP_PKEY_free(rsaKey);
+  BIO_free(bioKey);
+  return true;
+#endif
+
+#if defined(USE_NETTLE)
+  struct asn1_der_iterator der;
+  struct asn1_der_iterator j;
+  struct rsa_public_key    pub;
+
+  if (asn1_der_iterator_first(&der, SPICE_TICKET_PUBKEY_BYTES, pub_key) == ASN1_ITERATOR_CONSTRUCTED
+      && der.type == ASN1_SEQUENCE
+      && asn1_der_decode_constructed_last(&der) == ASN1_ITERATOR_CONSTRUCTED
+      && der.type == ASN1_SEQUENCE
+      && asn1_der_decode_constructed(&der, &j) == ASN1_ITERATOR_PRIMITIVE
+      && j.type == ASN1_IDENTIFIER
+      && asn1_der_iterator_next(&der) == ASN1_ITERATOR_PRIMITIVE
+      && der.type == ASN1_BITSTRING
+      && asn1_der_decode_bitstring_last(&der))
+  {
+    if (j.length != 9)
+    {
+      DEBUG_ERROR("Invalid key, not RSA");
+      return false;
+    }
+
+    if (asn1_der_iterator_next(&j) == ASN1_ITERATOR_PRIMITIVE
+        && j.type == ASN1_NULL
+        && j.length == 0
+        && asn1_der_iterator_next(&j) == ASN1_ITERATOR_END)
+    {
+      rsa_public_key_init(&pub);
+      if (!rsa_public_key_from_der_iterator(&pub, 0, &der))
+      {
+        DEBUG_ERROR("Unable to load public key from DER iterator");
+        rsa_public_key_clear(&pub);
+        return false;
+      }
+    }
+  }
+
+  mpz_t p;
+  mpz_init(p);
+  oaep_pad(p, pub.size, (uint8_t *)password, strlen(password)+1);
+  mpz_powm(p, p, pub.e, pub.n);
+
+  result->size = pub.size;
+  result->data = malloc(pub.size);
+  nettle_mpz_get_str_256(pub.size, (uint8_t *)result->data, p);
+
+  rsa_public_key_clear(&pub);
+  mpz_clear(p);
+  return true;
+#endif
+}
+
+void spice_rsa_free_password(struct spice_password * pass)
+{
+  free(pass->data);
+  pass->size = 0;
+  pass->data = NULL;
+}

client/spice/src/rsa.h

@@ -1,6 +1,6 @@
 /*
 Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
 https://looking-glass.hostfission.com
 
 This program is free software; you can redistribute it and/or modify it under
@@ -17,20 +17,14 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#pragma once
-
 #include <stdbool.h>
+#include <stdint.h>
 
-struct IVSHMEM
+struct spice_password
 {
+  char         * data;
   unsigned int   size;
-  void         * mem;
-
-  // internal use
-  void * opaque;
 };
 
-void ivshmemOptionsInit();
-bool ivshmemOpen(struct IVSHMEM * dev);
-bool ivshmemOpenDev(struct IVSHMEM * dev, const char * shmDev);
-void ivshmemClose(struct IVSHMEM * dev);
+bool spice_rsa_encrypt_password(uint8_t * pub_key, char * password, struct spice_password * result);
+void spice_rsa_free_password(struct spice_password * pass);

client/src/config.c

@@ -28,16 +28,16 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include <unistd.h>
 
 // forwards
-static bool       optRendererParse   (struct Option * opt, const char * str);
-static StringList optRendererValues  (struct Option * opt);
-static char *     optRendererToString(struct Option * opt);
-static bool       optPosParse        (struct Option * opt, const char * str);
-static StringList optPosValues       (struct Option * opt);
-static char *     optPosToString     (struct Option * opt);
-static bool       optSizeParse       (struct Option * opt, const char * str);
-static StringList optSizeValues      (struct Option * opt);
-static char *     optSizeToString    (struct Option * opt);
-static char *     optScancodeToString(struct Option * opt);
+static bool       optRendererParse       (struct Option * opt, const char * str);
+static StringList optRendererValues      (struct Option * opt);
+static char *     optRendererToString    (struct Option * opt);
+static bool       optPosParse            (struct Option * opt, const char * str);
+static StringList optPosValues           (struct Option * opt);
+static char *     optPosToString         (struct Option * opt);
+static bool       optSizeParse           (struct Option * opt, const char * str);
+static StringList optSizeValues          (struct Option * opt);
+static char *     optSizeToString        (struct Option * opt);
+static char *     optScancodeToString    (struct Option * opt);
 
 static void doLicense();
 
@@ -52,6 +52,22 @@ static struct Option options[] =
     .type           = OPTION_TYPE_STRING,
     .value.x_string = NULL,
   },
+  {
+    .module         = "app",
+    .name           = "shmFile",
+    .description    = "The path to the shared memory file",
+    .shortopt       = 'f',
+    .type           = OPTION_TYPE_STRING,
+    .value.x_string = "/dev/shm/looking-glass",
+  },
+  {
+    .module         = "app",
+    .name           = "shmSize",
+    .description    = "Specify the size in MB of the shared memory file (0 = detect)",
+    .shortopt       = 'L',
+    .type           = OPTION_TYPE_INT,
+    .value.x_int    = 0,
+  },
   {
     .module        = "app",
     .name          = "renderer",
@@ -135,13 +151,6 @@ static struct Option options[] =
     .type           = OPTION_TYPE_BOOL,
     .value.x_bool   = true,
   },
-  {
-    .module         = "win",
-    .name           = "forceAspect",
-    .description    = "Force the window to maintain the aspect ratio",
-    .type           = OPTION_TYPE_BOOL,
-    .value.x_bool   = true,
-  },
   {
     .module         = "win",
     .name           = "borderless",
@@ -175,8 +184,8 @@ static struct Option options[] =
   },
   {
     .module         = "win",
-    .name           = "fpsMin",
-    .description    = "Frame rate minimum (0 = disable - not recommended, -1 = auto detect)",
+    .name           = "fpsLimit",
+    .description    = "Frame rate limit (0 = disable - not recommended, -1 = auto detect)",
     .shortopt       = 'K',
     .type           = OPTION_TYPE_INT,
     .value.x_int    = -1,
@@ -309,13 +318,6 @@ static struct Option options[] =
     .type           = OPTION_TYPE_BOOL,
     .value.x_bool   = true
   },
-  {
-    .module         = "spice",
-    .name           = "captureOnStart",
-    .description    = "Capture mouse and keyboard on start",
-    .type           = OPTION_TYPE_BOOL,
-    .value.x_bool   = false
-  },
   {0}
 };
 
@@ -378,6 +380,8 @@ bool config_load(int argc, char * argv[])
   }
 
   // setup the application params for the basic types
+  params.shmFile            = option_get_string("app", "shmFile"           );
+  params.shmSize            = option_get_int   ("app", "shmSize"           ) * 1048576;
   params.cursorPollInterval = option_get_int   ("app", "cursorPollInterval");
   params.framePollInterval  = option_get_int   ("app", "framePollInterval" );
 
@@ -385,11 +389,10 @@ bool config_load(int argc, char * argv[])
   params.autoResize    = option_get_bool  ("win", "autoResize"   );
   params.allowResize   = option_get_bool  ("win", "allowResize"  );
   params.keepAspect    = option_get_bool  ("win", "keepAspect"   );
-  params.forceAspect   = option_get_bool  ("win", "forceAspect"  );
   params.borderless    = option_get_bool  ("win", "borderless"   );
   params.fullscreen    = option_get_bool  ("win", "fullScreen"   );
   params.maximize      = option_get_bool  ("win", "maximize"     );
-  params.fpsMin        = option_get_int   ("win", "fpsMin"       );
+  params.fpsLimit      = option_get_int   ("win", "fpsLimit"     );
   params.showFPS       = option_get_bool  ("win", "showFPS"      );
   params.ignoreQuit    = option_get_bool  ("win", "ignoreQuit"   );
   params.noScreensaver = option_get_bool  ("win", "noScreensaver");
@@ -420,7 +423,6 @@ bool config_load(int argc, char * argv[])
     }
 
     params.scaleMouseInput = option_get_bool("spice", "scaleCursor");
-    params.captureOnStart  = option_get_bool("spice", "captureOnStart");
   }
 
   return true;
@@ -457,9 +459,6 @@ static void doLicense()
 
 static bool optRendererParse(struct Option * opt, const char * str)
 {
-  if (!str)
-    return false;
-
   if (strcasecmp(str, "auto") == 0)
   {
     params.forceRenderer = false;
@@ -501,9 +500,6 @@ static char * optRendererToString(struct Option * opt)
 
 static bool optPosParse(struct Option * opt, const char * str)
 {
-  if (!str)
-    return false;
-
   if (strcmp(str, "center") == 0)
   {
     params.center = true;
@@ -541,9 +537,6 @@ static char * optPosToString(struct Option * opt)
 
 static bool optSizeParse(struct Option * opt, const char * str)
 {
-  if (!str)
-    return false;
-
   if (sscanf(str, "%dx%d", &params.w, &params.h) == 2)
   {
     if (params.w < 1 || params.h < 1)

client/src/ll.c

@@ -19,7 +19,7 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include "ll.h"
 
-#include "common/locking.h"
+#include "utils.h"
 #include <stdlib.h>
 #include <assert.h>
 
@@ -157,4 +157,4 @@ bool ll_walk(struct ll * list, void ** data)
   LG_UNLOCK(list->lock);
 
   return true;
-}
+}

client/src/main.h

@@ -18,27 +18,17 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 #include <stdbool.h>
-#include <stdatomic.h>
 #include <SDL2/SDL.h>
 
 #include "interface/app.h"
 #include "dynamic/renderers.h"
 #include "dynamic/clipboards.h"
-#include "common/ivshmem.h"
 
 #include "spice/spice.h"
-#include <lgmp/client.h>
-
-enum RunState
-{
-  APP_STATE_RUNNING,
-  APP_STATE_RESTART,
-  APP_STATE_SHUTDOWN
-};
 
 struct AppState
 {
-  enum RunState        state;
+  bool                 running;
   bool                 ignoreInput;
   bool                 escapeActive;
   SDL_Scancode         escapeAction;
@@ -51,51 +41,33 @@ struct AppState
   LG_RendererRect      dstRect;
   SDL_Point            cursor;
   bool                 cursorVisible;
-
-  bool  serverMode;
-  bool  haveCursorPos;
-  bool  drawCursor;
-  bool  cursorInView;
-  bool  updateCursor;
-  bool  initialCursorSync;
-  float scaleX, scaleY;
-  float accX, accY;
-  int   curLastX;
-  int   curLastY;
-  bool  haveCurLocal;
-  int   curLocalX;
-  int   curLocalY;
-  bool  haveAligned;
+  bool                 haveCursorPos;
+  float                scaleX, scaleY;
+  float                accX, accY;
 
   const LG_Renderer  * lgr;
   void               * lgrData;
   bool                 lgrResize;
 
+  SDL_Thread         * t_frame;
+
   const LG_Clipboard * lgc;
   SpiceDataType        cbType;
   struct ll          * cbRequestList;
 
-  SDL_SysWMinfo        wminfo;
   SDL_Window         * window;
+  int                  shmFD;
+  struct KVMFRHeader * shm;
+  unsigned int         shmSize;
 
-  struct IVSHMEM       shm;
-  PLGMPClient          lgmp;
-  PLGMPClientQueue     frameQueue;
-  PLGMPClientQueue     pointerQueue;
-
-  atomic_uint_least64_t frameTime;
-  uint64_t              lastFrameTime;
-  uint64_t              renderTime;
-  uint64_t              frameCount;
-  uint64_t              renderCount;
-
-
-  uint64_t resizeTimeout;
-  bool     resizeDone;
+  uint64_t          frameTime;
+  uint64_t          lastFrameTime;
+  uint64_t          renderTime;
+  uint64_t          frameCount;
+  uint64_t          renderCount;
 
   KeybindHandle kbFS;
   KeybindHandle kbInput;
-  KeybindHandle kbQuit;
   KeybindHandle kbMouseSensInc;
   KeybindHandle kbMouseSensDec;
   KeybindHandle kbCtrlAltFn[12];
@@ -109,7 +81,6 @@ struct AppParams
   bool         autoResize;
   bool         allowResize;
   bool         keepAspect;
-  bool         forceAspect;
   bool         borderless;
   bool         fullscreen;
   bool         maximize;
@@ -117,7 +88,9 @@ struct AppParams
   bool         center;
   int          x, y;
   unsigned int w, h;
-  unsigned int fpsMin;
+  const char * shmFile;
+  unsigned int shmSize;
+  unsigned int fpsLimit;
   bool         showFPS;
   bool         useSpiceInput;
   bool         useSpiceClipboard;
@@ -132,7 +105,6 @@ struct AppParams
   bool         grabKeyboard;
   SDL_Scancode escapeKey;
   bool         showAlerts;
-  bool         captureOnStart;
 
   unsigned int cursorPollInterval;
   unsigned int framePollInterval;
@@ -160,4 +132,4 @@ struct KeybindHandle
 
 // forwards
 extern struct AppState  state;
-extern struct AppParams params;
+extern struct AppParams params;

common/CMakeLists.txt

@@ -5,23 +5,37 @@ include_directories(
 	${PROJECT_SOURCE_DIR}/include
 )
 
-add_definitions(-D_GNU_SOURCE)
-
 if(ENABLE_BACKTRACE)
   add_definitions(-DENABLE_BACKTRACE)
 endif()
 
-add_subdirectory(src/platform)
-
 set(COMMON_SOURCES
+  src/objectlist.c
   src/stringutils.c
-  src/stringlist.c
   src/option.c
   src/framebuffer.c
 )
 
-add_library(lg_common STATIC ${COMMON_SOURCES})
-target_link_libraries(lg_common lg_common_platform)
+set(LINUX_SOURCES
+  src/crash.linux.c
+  src/sysinfo.linux.c
+)
+
+set(WINDOWS_SOURCES
+  src/crash.windows.c
+  src/sysinfo.windows.c
+)
+
+if(WIN32)
+  set(SOURCES ${COMMON_SOURCES} ${WINDOWS_SOURCES})
+  add_library(lg_common STATIC ${SOURCES})
+else()
+  set(SOURCES ${COMMON_SOURCES} ${LINUX_SOURCES})
+  add_library(lg_common STATIC ${SOURCES})
+  if(ENABLE_BACKTRACE)
+    target_link_libraries(lg_common bfd)
+  endif()
+endif()
 
 target_include_directories(lg_common
 	INTERFACE

common/include/common/KVMFR.h

@@ -20,8 +20,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 #include <stdint.h>
 
-#define LGMP_Q_POINTER     1
-#define LGMP_Q_FRAME       2
+#define KVMFR_HEADER_MAGIC   "[[KVMFR]]"
+#define KVMFR_HEADER_VERSION 9
 
 typedef enum FrameType
 {
@@ -34,14 +34,6 @@ typedef enum FrameType
 }
 FrameType;
 
-enum
-{
-  CURSOR_FLAG_POSITION = 0x1,
-  CURSOR_FLAG_VISIBLE  = 0x2,
-  CURSOR_FLAG_SHAPE    = 0x4
-};
-typedef uint32_t KVMFRCursorFlags;
-
 typedef enum CursorType
 {
   CURSOR_TYPE_COLOR       ,
@@ -50,34 +42,49 @@ typedef enum CursorType
 }
 CursorType;
 
-#define KVMFR_MAGIC   "KVMFR---"
-#define KVMFR_VERSION 2
-
-typedef struct KVMFR
-{
-  char     magic[8];
-  uint32_t version;
-  char     hostver[32];
-}
-KVMFR;
+#define KVMFR_CURSOR_FLAG_UPDATE  1 // cursor update available
+#define KVMFR_CURSOR_FLAG_VISIBLE 2 // cursor is visible
+#define KVMFR_CURSOR_FLAG_SHAPE   4 // shape updated
+#define KVMFR_CURSOR_FLAG_POS     8 // position updated
 
 typedef struct KVMFRCursor
 {
+  volatile uint8_t flags; // KVMFR_CURSOR_FLAGS
   int16_t    x, y;        // cursor x & y position
+
+  uint32_t   version;     // shape version
   CursorType type;        // shape buffer data type
   uint32_t   width;       // width of the shape
   uint32_t   height;      // height of the shape
   uint32_t   pitch;       // row length in bytes of the shape
+  uint64_t   dataPos;     // offset to the shape data
 }
 KVMFRCursor;
 
+#define KVMFR_FRAME_FLAG_UPDATE 1 // frame update available
+
 typedef struct KVMFRFrame
 {
-  FrameType type;        // the frame data type
-  uint32_t  width;       // the width
-  uint32_t  height;      // the height
-  uint32_t  stride;      // the row stride (zero if compressed data)
-  uint32_t  pitch;       // the row pitch  (stride in bytes or the compressed frame size)
-  uint32_t  offset;      // offset from the start of this header to the FrameBuffer header
+  volatile uint8_t flags;  // KVMFR_FRAME_FLAGS
+  FrameType   type;        // the frame data type
+  uint32_t    width;       // the width
+  uint32_t    height;      // the height
+  uint32_t    stride;      // the row stride (zero if compressed data)
+  uint32_t    pitch;       // the row pitch  (stride in bytes or the compressed frame size)
+  uint64_t    dataPos;     // offset to the frame
 }
 KVMFRFrame;
+
+#define KVMFR_HEADER_FLAG_RESTART 1 // restart signal from client
+#define KVMFR_HEADER_FLAG_READY   2 // ready signal from client
+#define KVMFR_HEADER_FLAG_PAUSED  4 // capture has been paused by the host
+
+typedef struct KVMFRHeader
+{
+  char        magic[sizeof(KVMFR_HEADER_MAGIC)];
+  uint32_t    version;     // version of this structure
+  volatile uint8_t flags;  // KVMFR_HEADER_FLAGS
+  KVMFRFrame  frame;       // the frame information
+  KVMFRCursor cursor;      // the cursor information
+}
+KVMFRHeader;

common/include/common/debug.h

@@ -17,13 +17,8 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
-#endif
-
 #include <stdio.h>
-#include <inttypes.h>
-#include "time.h"
+#include <stdlib.h>
 
 #if defined(_WIN32) && !defined(__GNUC__)
   #define DIRECTORY_SEPARATOR '\\'
@@ -53,16 +48,16 @@ Place, Suite 330, Boston, MA 02111-1307 USA
   sizeof(s) > 20 && (s)[sizeof(s)-21] == DIRECTORY_SEPARATOR ? (s) + sizeof(s) - 20 : \
   sizeof(s) > 21 && (s)[sizeof(s)-22] == DIRECTORY_SEPARATOR ? (s) + sizeof(s) - 21 : (s))
 
-#define DEBUG_PRINT(type, fmt, ...) do {fprintf(stderr, "%12" PRId64 " " type " %20s:%-4u | %-30s | " fmt "\n", microtime(), STRIPPATH(__FILE__), __LINE__, __FUNCTION__, ##__VA_ARGS__);} while (0)
+#define DEBUG_PRINT(type, fmt, ...) do {fprintf(stderr, type " %20s:%-4u | %-30s | " fmt "\n", STRIPPATH(__FILE__), __LINE__, __FUNCTION__, ##__VA_ARGS__);} while (0)
 
-#define DEBUG_BREAK() DEBUG_PRINT("[ ]", "%s", "================================================================================")
 #define DEBUG_INFO(fmt, ...) DEBUG_PRINT("[I]", fmt, ##__VA_ARGS__)
 #define DEBUG_WARN(fmt, ...) DEBUG_PRINT("[W]", fmt, ##__VA_ARGS__)
 #define DEBUG_ERROR(fmt, ...) DEBUG_PRINT("[E]", fmt, ##__VA_ARGS__)
 #define DEBUG_FIXME(fmt, ...) DEBUG_PRINT("[F]", fmt, ##__VA_ARGS__)
+#define DEBUG_FATAL(fmt, ...) do {DEBUG_PRINT("[C]", fmt, ##__VA_ARGS__); abort();} while (0)
 
 #if defined(DEBUG_SPICE) | defined(DEBUG_IVSHMEM)
   #define DEBUG_PROTO(fmt, args...) DEBUG_PRINT("[P]", fmt, ##args)
 #else
   #define DEBUG_PROTO(fmt, ...) do {} while(0)
-#endif
+#endif

common/include/common/event.h

@@ -1,42 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#pragma once
-
-#include <stdbool.h>
-#include <time.h>
-
-#define TIMEOUT_INFINITE ((unsigned int)~0)
-
-typedef struct LGEvent LGEvent;
-
-LGEvent * lgCreateEvent(bool autoReset, unsigned int msSpinTime);
-void      lgFreeEvent  (LGEvent * handle);
-bool      lgWaitEvent  (LGEvent * handle, unsigned int timeout);
-bool      lgWaitEvents (LGEvent * handles[], int count, bool waitAll, unsigned int timeout);
-bool      lgSignalEvent(LGEvent * handle);
-bool      lgResetEvent (LGEvent * handle);
-
-// os specific method to wrap/convert a native event into a LGEvent
-// for windows this is an event HANDLE
-LGEvent * lgWrapEvent(void * handle);
-
-// Posix specific, not implmented/possible in windows
-bool lgWaitEventAbs(LGEvent * handle, struct timespec * ts);
-bool lgWaitEventNS (LGEvent * handle, unsigned int timeout);

common/include/common/framebuffer.h

@@ -23,38 +23,26 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include <stdbool.h>
 #include <stdint.h>
 
-typedef struct stFrameBuffer FrameBuffer;
+typedef struct stFrameBuffer * FrameBuffer;
 
 typedef bool (*FrameBufferReadFn)(void * opaque, const void * src, size_t size);
 
-/**
- * The size of the FrameBuffer struct
- */
-extern const size_t FrameBufferStructSize;
-
-/**
- * Wait for the framebuffer to fill to the specified size
- */
-void framebuffer_wait(const FrameBuffer * frame, size_t size);
-
 /**
  * Read data from the KVMFRFrame into the dst buffer
  */
-bool framebuffer_read(const FrameBuffer * frame, void * dst, size_t dstpitch,
-    size_t height, size_t width, size_t bpp, size_t pitch);
+bool framebuffer_read(const FrameBuffer frame, void * dst, size_t size);
 
 /**
  * Read data from the KVMFRFrame using a callback
  */
-bool framebuffer_read_fn(const FrameBuffer * frame, size_t height, size_t width,
-    size_t bpp, size_t pitch, FrameBufferReadFn fn, void * opaque);
+bool framebuffer_read_fn(const FrameBuffer frame, FrameBufferReadFn fn, size_t size, void * opaque);
 
 /**
  * Prepare the framebuffer for writing
  */
-void framebuffer_prepare(FrameBuffer * frame);
+void framebuffer_prepare(const FrameBuffer frame);
 
 /**
  * Write data from the src buffer into the KVMFRFrame
  */
-bool framebuffer_write(FrameBuffer * frame, const void * src, size_t size);
+bool framebuffer_write(const FrameBuffer frame, const void * src, size_t size);

common/include/common/locking.h

@@ -18,23 +18,14 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #pragma once
 
-#include "time.h"
-
-#include <stdatomic.h>
-
-#define LG_LOCK_MODE "Atomic"
-typedef atomic_flag LG_Lock;
-#define LG_LOCK_INIT(x) atomic_flag_clear(&(x))
-#define LG_LOCK(x) \
-  while(atomic_flag_test_and_set_explicit(&(x), memory_order_acquire)) { ; }
-#define LG_UNLOCK(x) \
-  atomic_flag_clear_explicit(&(x), memory_order_release);
-#define LG_LOCK_FREE(x)
-
-#define INTERLOCKED_INC(x) atomic_fetch_add((x), 1)
-#define INTERLOCKED_DEC(x) atomic_fetch_sub((x), 1)
-
-#define INTERLOCKED_SECTION(lock, x) \
-  LG_LOCK(lock) \
-  x \
-  LG_UNLOCK(lock)
+#if defined(__GCC__) || defined(__GNUC__)
+#define INTERLOCKED_AND8   __sync_fetch_and_and
+#define INTERLOCKED_OR8    __sync_fetch_and_or
+#define INTERLOCKED_INC(x) __sync_fetch_and_add((x), 1)
+#define INTERLOCKED_DEC(x) __sync_fetch_and_sub((x), 1)
+#else
+#define INTERLOCKED_OR8  InterlockedOr8
+#define INTERLOCKED_AND8 InterlockedAnd8
+#define INTERLOCKED_INC  InterlockedIncrement
+#define INTERLOCKED_DEC  InterlockedDecrement
+#endif

common/include/common/objectlist.h

@@ -0,0 +1,35 @@
+/*
+KVMGFX Client - A KVM Client for VGA Passthrough
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <stdbool.h>
+
+typedef struct ObjectList * ObjectList;
+
+typedef void (*ObjectFreeFn)(void * object);
+
+ObjectList   objectlist_new   (ObjectFreeFn free_fn);
+void         objectlist_free  (ObjectList * ol);
+int          objectlist_push  (ObjectList ol, void * object);
+void *       objectlist_pop   (ObjectList ol);
+bool         objectlist_remove(ObjectList ol, unsigned int index);
+unsigned int objectlist_count (ObjectList ol);
+void *       objectlist_at    (ObjectList ol, unsigned int index);
+
+// generic free method
+void objectlist_free_item(void *object);

common/include/common/stringlist.h

@@ -17,12 +17,31 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include <stdbool.h>
+#include "objectlist.h"
 
-typedef struct StringList * StringList;
+typedef ObjectList StringList;
 
-StringList   stringlist_new  (bool owns_strings);
-void         stringlist_free (StringList * sl);
-int          stringlist_push (StringList sl, char * str);
-unsigned int stringlist_count(StringList sl);
-char *       stringlist_at   (StringList sl, unsigned int index);
+inline static StringList stringlist_new(bool owns_strings)
+{
+  return objectlist_new(owns_strings ? objectlist_free_item : 0);
+}
+
+inline static void stringlist_free(StringList * sl)
+{
+  return objectlist_free(sl);
+}
+
+inline static int stringlist_push (StringList sl, char * str)
+{
+  return objectlist_push(sl, str);
+}
+
+inline static unsigned int stringlist_count(StringList sl)
+{
+  return objectlist_count(sl);
+}
+
+inline static char * stringlist_at(StringList sl, unsigned int index)
+{
+  return objectlist_at(sl, index);
+}

common/include/common/stringutils.h

@@ -18,5 +18,4 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 // sprintf but with buffer allocation
-int alloc_sprintf(char ** str, const char * format, ...)
-  __attribute__ ((format (printf, 2, 3)));
+int alloc_sprintf(char ** str, const char * format, ...);

common/include/common/sysinfo.h

@@ -18,7 +18,4 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 // returns the maximum number of multisamples supported by the system
-int sysinfo_gfx_max_multisample();
-
-// returns the page size
-long sysinfo_getPageSize();
+int sysinfo_gfx_max_multisample();

common/include/common/time.h

@@ -1,112 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-
-#if defined(_WIN32)
-#include <windows.h>
-#else
-#include <time.h>
-#include <stdint.h>
-#endif
-
-typedef struct LGTimer LGTimer;
-
-static inline uint64_t microtime()
-{
-#if defined(_WIN32)
-  static LARGE_INTEGER freq = { 0 };
-  if (!freq.QuadPart)
-    QueryPerformanceFrequency(&freq);
-
-  LARGE_INTEGER time;
-  QueryPerformanceCounter(&time);
-  return time.QuadPart / (freq.QuadPart / 1000000LL);
-#else
-  struct timespec time;
-  clock_gettime(CLOCK_MONOTONIC, &time);
-  return (uint64_t)time.tv_sec * 1000000LL + time.tv_nsec / 1000LL;
-#endif
-}
-
-#if !defined(_WIN32)
-//FIXME: make win32 versions
-static inline uint64_t nanotime()
-{
-  struct timespec time;
-  clock_gettime(CLOCK_MONOTONIC_RAW, &time);
-  return ((uint64_t)time.tv_sec * 1000000000LL) + time.tv_nsec;
-}
-
-static inline void nsleep(uint64_t ns)
-{
-  const struct timespec ts =
-  {
-    .tv_sec  = ns / 1e9,
-    .tv_nsec = ns - ((ns / 1e9) * 1e9)
-  };
-  nanosleep(&ts, NULL);
-}
-
-static inline void tsDiff(struct timespec *diff, const struct timespec *left,
-              const struct timespec *right)
-{
-  diff->tv_sec = left->tv_sec - right->tv_sec;
-  diff->tv_nsec = left->tv_nsec - right->tv_nsec;
-  if (diff->tv_nsec < 0)
-  {
-    --diff->tv_sec;
-    diff->tv_nsec += 1000000000;
-  }
-}
-
-static inline uint32_t __iter_div_u64_rem(uint64_t dividend, uint32_t divisor, uint64_t *remainder)
-{
-  uint32_t ret = 0;
-
-  while (dividend >= divisor) {
-    /* The following asm() prevents the compiler from
-       optimising this loop into a modulo operation.  */
-    asm("" : "+rm"(dividend));
-
-    dividend -= divisor;
-    ret++;
-  }
-
-  *remainder = dividend;
-
-  return ret;
-}
-
-static inline void tsAdd(struct timespec *a, uint64_t ns)
-{
-  a->tv_sec  += __iter_div_u64_rem(a->tv_nsec + ns, 1000000000L, &ns);
-  a->tv_nsec = ns;
-}
-#endif
-
-typedef bool (*LGTimerFn)(void * udata);
-
-bool lgCreateTimer(const unsigned int intervalMS, LGTimerFn fn,
-    void * udata, LGTimer ** result);
-
-void lgTimerDestroy(LGTimer * timer);

common/src/crash.linux.c

@@ -17,6 +17,7 @@ this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#define _GNU_SOURCE
 #include "common/crash.h"
 #include "common/debug.h"
 
@@ -97,18 +98,10 @@ static void load_symbols()
 
 static bool lookup_address(bfd_vma pc, const char ** filename, const char ** function, unsigned int * line, unsigned int * discriminator)
 {
-#ifdef bfd_get_section_flags
   if ((bfd_get_section_flags(crash.fd, crash.section) & SEC_ALLOC) == 0)
-#else
-  if ((bfd_section_flags(crash.section) & SEC_ALLOC) == 0)
-#endif
     return false;
 
-#ifdef bfd_get_section_size
   bfd_size_type size = bfd_get_section_size(crash.section);
-#else
-  bfd_size_type size = bfd_section_size(crash.section);
-#endif
   if (pc >= size)
     return false;
 
@@ -237,4 +230,4 @@ bool installCrashHandler(const char * exe)
   return true;
 }
 
-#endif
+#endif

common/src/framebuffer.c

@@ -21,115 +21,53 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include "common/debug.h"
 
 #include <string.h>
-#include <stdatomic.h>
-#include <emmintrin.h>
-#include <smmintrin.h>
-#include <unistd.h>
-
-#define FB_CHUNK_SIZE 1048576 // 1MB
-#define FB_SPIN_LIMIT 10000   // 10ms
+#define FB_CHUNK_SIZE 1024
 
 struct stFrameBuffer
 {
-  atomic_uint_least32_t wp;
-  uint8_t               data[0];
+  uint64_t  wp;
+  uint8_t   data[0];
 };
 
-const size_t FrameBufferStructSize = sizeof(FrameBuffer);
-
-void framebuffer_wait(const FrameBuffer * frame, size_t size)
+bool framebuffer_read(const FrameBuffer frame, void * dst, size_t size)
 {
-  while(atomic_load_explicit(&frame->wp, memory_order_acquire) != size) {}
-}
-
-bool framebuffer_read(const FrameBuffer * frame, void * restrict dst,
-    size_t dstpitch, size_t height, size_t width, size_t bpp, size_t pitch)
-{
-  uint8_t * restrict d     = (uint8_t*)dst;
-  uint_least32_t rp        = 0;
-  size_t         y         = 0;
-  const size_t   linewidth = width * bpp;
-  const size_t   blocks    = linewidth / 64;
-  const size_t   left      = linewidth % 64;
-
-  while(y < height)
+  uint8_t *d  = (uint8_t*)dst;
+  uint64_t rp = 0;
+  while(rp < size)
   {
-    uint_least32_t wp;
-    int spinCount = 0;
-
     /* spinlock */
-    wp = atomic_load_explicit(&frame->wp, memory_order_acquire);
-    while(wp - rp < linewidth)
-    {
-      if (++spinCount == FB_SPIN_LIMIT)
-        return false;
+    while(rp == frame->wp) { }
 
-      usleep(1);
-      wp = atomic_load_explicit(&frame->wp, memory_order_acquire);
-    }
+    /* copy what we can */
+    uint64_t avail = frame->wp - rp;
+    avail = avail > size ? size : avail;
 
-    _mm_mfence();
-    __m128i * restrict s = (__m128i *)(frame->data + rp);
-    for(int i = 0; i < blocks; ++i)
-    {
-      __m128i *_d = (__m128i *)d;
-      __m128i *_s = (__m128i *)s;
-      __m128i v1 = _mm_stream_load_si128(_s + 0);
-      __m128i v2 = _mm_stream_load_si128(_s + 1);
-      __m128i v3 = _mm_stream_load_si128(_s + 2);
-      __m128i v4 = _mm_stream_load_si128(_s + 3);
+    memcpy(d, frame->data + rp, avail);
 
-      _mm_storeu_si128(_d + 0, v1);
-      _mm_storeu_si128(_d + 1, v2);
-      _mm_storeu_si128(_d + 2, v3);
-      _mm_storeu_si128(_d + 3, v4);
-
-      d += 64;
-      s += 4;
-    }
-
-    if (left)
-    {
-      memcpy(d, s, left);
-      d += left;
-    }
-
-    rp += pitch;
-    d  += dstpitch - linewidth;
-    ++y;
+    rp   += avail;
+    d    += avail;
+    size -= avail;
   }
-
   return true;
 }
 
-bool framebuffer_read_fn(const FrameBuffer * frame, size_t height, size_t width,
-    size_t bpp, size_t pitch, FrameBufferReadFn fn, void * opaque)
+bool framebuffer_read_fn(const FrameBuffer frame, FrameBufferReadFn fn, size_t size, void * opaque)
 {
-  uint_least32_t rp        = 0;
-  size_t         y         = 0;
-  const size_t   linewidth = width * bpp;
-
-  while(y < height)
+  uint64_t rp = 0;
+  while(rp < size)
   {
-    uint_least32_t wp;
-    int spinCount = 0;
-
     /* spinlock */
-    wp = atomic_load_explicit(&frame->wp, memory_order_acquire);
-    while(wp - rp < linewidth)
-    {
-      if (++spinCount == FB_SPIN_LIMIT)
-        return false;
+    while(rp == frame->wp) { }
 
-      usleep(1);
-      wp = atomic_load_explicit(&frame->wp, memory_order_acquire);
-    }
+    /* copy what we can */
+    uint64_t avail = frame->wp - rp;
+    avail = avail > size ? size : avail;
 
-    if (!fn(opaque, frame->data + rp, linewidth))
+    if (!fn(opaque, frame->data + rp, avail))
       return false;
 
-    rp += pitch;
-    ++y;
+    rp   += avail;
+    size -= avail;
   }
 
   return true;
@@ -138,49 +76,20 @@ bool framebuffer_read_fn(const FrameBuffer * frame, size_t height, size_t width,
 /**
  * Prepare the framebuffer for writing
  */
-void framebuffer_prepare(FrameBuffer * frame)
+void framebuffer_prepare(const FrameBuffer frame)
 {
-  atomic_store_explicit(&frame->wp, 0, memory_order_release);
+  frame->wp = 0;
 }
 
-bool framebuffer_write(FrameBuffer * frame, const void * restrict src, size_t size)
+bool framebuffer_write(FrameBuffer frame, const void * src, size_t size)
 {
-  __m128i * restrict s = (__m128i *)src;
-  __m128i * restrict d = (__m128i *)frame->data;
-  size_t wp = 0;
-
-  _mm_mfence();
-
   /* copy in chunks */
-  while(size > 63)
+  while(size)
   {
-    __m128i *_d = (__m128i *)d;
-    __m128i *_s = (__m128i *)s;
-    __m128i v1 = _mm_stream_load_si128(_s + 0);
-    __m128i v2 = _mm_stream_load_si128(_s + 1);
-    __m128i v3 = _mm_stream_load_si128(_s + 2);
-    __m128i v4 = _mm_stream_load_si128(_s + 3);
-
-    _mm_store_si128(_d + 0, v1);
-    _mm_store_si128(_d + 1, v2);
-    _mm_store_si128(_d + 2, v3);
-    _mm_store_si128(_d + 3, v4);
-
-    s    += 4;
-    d    += 4;
-    size -= 64;
-    wp   += 64;
-
-    if (wp % FB_CHUNK_SIZE == 0)
-      atomic_store_explicit(&frame->wp, wp, memory_order_release);
+    size_t copy = size < FB_CHUNK_SIZE ? FB_CHUNK_SIZE : size;
+    memcpy(frame->data + frame->wp, src, copy);
+    __sync_fetch_and_add(&frame->wp, copy);
+    size -= copy;
   }
-
-  if(size)
-  {
-    memcpy(frame->data + wp, s, size);
-    wp += size;
-  }
-
-  atomic_store_explicit(&frame->wp, wp, memory_order_release);
   return true;
-}
+}

common/src/objectlist.c

@@ -0,0 +1,112 @@
+/*
+KVMGFX Client - A KVM Client for VGA Passthrough
+Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "common/objectlist.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+struct ObjectList
+{
+  ObjectFreeFn    free_fn;
+  unsigned int    size;
+  unsigned int    count;
+  void         ** list;
+};
+
+ObjectList objectlist_new(ObjectFreeFn free_fn)
+{
+  ObjectList ol = malloc(sizeof(struct ObjectList));
+
+  ol->free_fn      = free_fn;
+  ol->size         = 32;
+  ol->count        = 0;
+  ol->list         = malloc(sizeof(void *) * ol->size);
+
+  return ol;
+}
+
+void objectlist_free(ObjectList * ol)
+{
+  if ((*ol)->free_fn)
+    for(unsigned int i = 0; i < (*ol)->count; ++i)
+      (*ol)->free_fn((*ol)->list[i]);
+
+  free((*ol)->list);
+  free((*ol));
+  *ol = NULL;
+}
+
+int objectlist_push(ObjectList ol, void * object)
+{
+  if (ol->count == ol->size)
+  {
+    ol->size += 32;
+    ol->list  = realloc(ol->list, sizeof(void *) * ol->size);
+  }
+
+  unsigned int index = ol->count;
+  ol->list[ol->count++] = object;
+  return index;
+}
+
+void * objectlist_pop(ObjectList ol)
+{
+  if (ol->count == 0)
+    return NULL;
+
+  return ol->list[--ol->count];
+}
+
+bool objectlist_remove(ObjectList ol, unsigned int index)
+{
+  if (index >= ol->count)
+    return false;
+
+  if (ol->free_fn)
+    ol->free_fn(ol->list[index]);
+
+  void ** newlist = malloc(sizeof(void *) * ol->size);
+
+  --ol->count;
+  memcpy(&newlist[0], &ol->list[0], index * sizeof(void *));
+  memcpy(&newlist[index], &ol->list[index + 1], (ol->count - index) * sizeof(void *));
+
+  free(ol->list);
+  ol->list = newlist;
+  return true;
+}
+
+unsigned int objectlist_count(ObjectList ol)
+{
+  return ol->count;
+}
+
+void * objectlist_at(ObjectList ol, unsigned int index)
+{
+  if (index >= ol->count)
+    return NULL;
+
+  return ol->list[index];
+}
+
+void objectlist_free_item(void *object)
+{
+  free(object);
+}

common/src/option.c

@@ -367,7 +367,6 @@ bool option_load(const char * filename)
   int    lineno      = 1;
   char * module      = NULL;
   bool   line        = true;
-  bool   comment     = false;
   bool   expectLine  = false;
   bool   expectValue = false;
   char * name        = NULL;
@@ -380,10 +379,6 @@ bool option_load(const char * filename)
 
   for(int c = fgetc(fp); !feof(fp); c = fgetc(fp))
   {
-    if (comment && c != '\n')
-      continue;
-    comment = false;
-
     switch(c)
     {
       case '[':
@@ -482,14 +477,6 @@ bool option_load(const char * filename)
         (*p)[(*len)++] = c;
         break;
 
-      case ';':
-        if (line)
-        {
-          comment = true;
-          break;
-        }
-        // fallthrough
-
       default:
         if (expectLine)
         {
@@ -613,7 +600,7 @@ void option_print()
     maxLen = alloc_sprintf(
       &line,
       "%-*s | Short | %-*s | Description",
-      (int)(strlen(state.groups[g].module) + state.groups[g].pad + 1),
+      strlen(state.groups[g].module) + state.groups[g].pad + 1,
       "Long",
       valueLen,
       "Value"
@@ -730,4 +717,4 @@ bool option_get_bool(const char * module, const char * name)
   }
   assert(o->type == OPTION_TYPE_BOOL);
   return o->value.x_bool;
-}
+}

common/src/platform/CMakeLists.txt

@@ -1,11 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-project(lg_common_platform LANGUAGES C)
-
-if (UNIX)
-  add_subdirectory("linux")
-elseif(WIN32)
-  add_subdirectory("windows")
-endif()
-
-add_library(lg_common_platform INTERFACE)
-target_link_libraries(lg_common_platform INTERFACE lg_common_platform_code)

common/src/platform/linux/CMakeLists.txt

@@ -1,25 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-project(lg_common_platform_code LANGUAGES C)
-
-include_directories(
-	${PROJECT_SOURCE_DIR}/include
-)
-
-add_library(lg_common_platform_code STATIC
-    crash.c
-    sysinfo.c
-    thread.c
-    event.c
-    ivshmem.c
-    time.c
-)
-
-if(ENABLE_BACKTRACE)
-  target_link_libraries(lg_common_platform_code bfd)
-endif()
-
-target_link_libraries(lg_common_platform_code
-	lg_common
-	pthread
-	rt
-)

common/src/platform/linux/event.c

@@ -1,201 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/event.h"
-
-#include "common/debug.h"
-
-#include <stdlib.h>
-#include <pthread.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdatomic.h>
-#include <stdint.h>
-
-struct LGEvent
-{
-  pthread_mutex_t mutex;
-  pthread_cond_t  cond;
-  uint32_t        flag;
-  bool            autoReset;
-};
-
-LGEvent * lgCreateEvent(bool autoReset, unsigned int msSpinTime)
-{
-  LGEvent * handle = (LGEvent *)calloc(sizeof(LGEvent), 1);
-  if (!handle)
-  {
-    DEBUG_ERROR("Failed to allocate memory");
-    return NULL;
-  }
-
-  if (pthread_mutex_init(&handle->mutex, NULL) != 0)
-  {
-    DEBUG_ERROR("Failed to create the mutex");
-    free(handle);
-    return NULL;
-  }
-
-  if (pthread_cond_init(&handle->cond, NULL) != 0)
-  {
-    pthread_mutex_destroy(&handle->mutex);
-    free(handle);
-    return NULL;
-  }
-
-  handle->autoReset = autoReset;
-  return handle;
-}
-
-void lgFreeEvent(LGEvent * handle)
-{
-  assert(handle);
-
-  pthread_cond_destroy (&handle->cond );
-  pthread_mutex_destroy(&handle->mutex);
-  free(handle);
-}
-
-bool lgWaitEventAbs(LGEvent * handle, struct timespec * ts)
-{
-  assert(handle);
-
-  if (pthread_mutex_lock(&handle->mutex) != 0)
-  {
-    DEBUG_ERROR("Failed to lock the mutex");
-    return false;
-  }
-
-  bool ret = true;
-  int  res;
-  while(ret && !atomic_load(&handle->flag))
-  {
-    if (!ts)
-    {
-      if ((res = pthread_cond_wait(&handle->cond, &handle->mutex)) != 0)
-      {
-        DEBUG_ERROR("Failed to wait on the condition (err: %d)", res);
-        ret = false;
-      }
-    }
-    else
-    {
-      switch((res = pthread_cond_timedwait(&handle->cond, &handle->mutex, ts)))
-      {
-        case 0:
-          break;
-
-        case ETIMEDOUT:
-          ret = false;
-          break;
-
-        default:
-          ret = false;
-          DEBUG_ERROR("Timed wait failed (err: %d)", res);
-          break;
-      }
-    }
-  }
-
-  if (handle->autoReset)
-    atomic_store(&handle->flag, 0);
-
-  if (pthread_mutex_unlock(&handle->mutex) != 0)
-  {
-    DEBUG_ERROR("Failed to unlock the mutex");
-    return false;
-  }
-
-  return ret;
-}
-
-bool lgWaitEventNS(LGEvent * handle, unsigned int timeout)
-{
-  if (timeout == TIMEOUT_INFINITE)
-    return lgWaitEventAbs(handle, NULL);
-
-  struct timespec ts;
-  clock_gettime(CLOCK_REALTIME, &ts);
-  uint64_t nsec = ts.tv_nsec + timeout;
-  if(nsec > 1e9)
-  {
-    ts.tv_nsec = nsec - 1e9;
-    ++ts.tv_sec;
-  }
-  else
-    ts.tv_nsec = nsec;
-
-  return lgWaitEventAbs(handle, &ts);
-}
-
-bool lgWaitEvent(LGEvent * handle, unsigned int timeout)
-{
-  if (timeout == TIMEOUT_INFINITE)
-    return lgWaitEventAbs(handle, NULL);
-
-  return lgWaitEventNS(handle, timeout * 1000000);
-}
-
-bool lgSignalEvent(LGEvent * handle)
-{
-  assert(handle);
-
-  if (pthread_mutex_lock(&handle->mutex) != 0)
-  {
-    DEBUG_ERROR("Failed to lock the mutex");
-    return false;
-  }
-
-  atomic_store(&handle->flag, 1);
-
-  if (pthread_mutex_unlock(&handle->mutex) != 0)
-  {
-    DEBUG_ERROR("Failed to unlock the mutex");
-    return false;
-  }
-
-  if (pthread_cond_broadcast(&handle->cond) != 0)
-  {
-    DEBUG_ERROR("Failed to signal the condition");
-    return false;
-  }
-
-  return true;
-}
-
-bool lgResetEvent(LGEvent * handle)
-{
-  assert(handle);
-
-  if (pthread_mutex_lock(&handle->mutex) != 0)
-  {
-    DEBUG_ERROR("Failed to lock the mutex");
-    return false;
-  }
-
-  atomic_store(&handle->flag, 0);
-
-  if (pthread_mutex_unlock(&handle->mutex) != 0)
-  {
-    DEBUG_ERROR("Failed to unlock the mutex");
-    return false;
-  }
-
-  return true;
-}

common/src/platform/linux/ivshmem.c

@@ -1,267 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/ivshmem.h"
-
-#include <assert.h>
-#include <dirent.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "common/debug.h"
-#include "common/option.h"
-#include "common/stringutils.h"
-
-struct IVSHMEMInfo
-{
-  int fd;
-  int size;
-};
-
-static int uioOpenFile(const char * shmDevice, const char * file)
-{
-  char * path;
-  alloc_sprintf(&path, "/sys/class/uio/%s/%s", shmDevice, file);
-  int fd = open(path, O_RDONLY);
-  if (fd < 0)
-  {
-    free(path);
-    return -1;
-  }
-
-  free(path);
-  return fd;
-}
-
-static char * uioGetName(const char * shmDevice)
-{
-  int fd = uioOpenFile(shmDevice, "name");
-  if (fd < 0)
-    return NULL;
-
-  char * name = malloc(32);
-  int len = read(fd, name, 31);
-  if (len <= 0)
-  {
-    free(name);
-    close(fd);
-    return NULL;
-  }
-  name[len] = '\0';
-  close(fd);
-
-  while(len > 0 && name[len-1] == '\n')
-  {
-    --len;
-    name[len] = '\0';
-  }
-
-  return name;
-}
-
-static bool ivshmemDeviceValidator(struct Option * opt, const char ** error)
-{
-  // if it's not a uio device, it must be a file on disk
-  if (strlen(opt->value.x_string) > 3 && memcmp(opt->value.x_string, "uio", 3) != 0)
-  {
-    struct stat st;
-    if (stat(opt->value.x_string, &st) != 0)
-    {
-      *error = "Invalid path to the ivshmem file specified";
-      return false;
-    }
-    return true;
-  }
-
-  char * name = uioGetName(opt->value.x_string);
-  if (!name)
-  {
-    *error = "Failed to get the uio device name";
-    return false;
-  }
-
-  if (strcmp(name, "KVMFR") != 0)
-  {
-    free(name);
-    *error = "Device is not a KVMFR device";
-    return false;
-  }
-
-  free(name);
-  return true;
-}
-
-static StringList ivshmemDeviceGetValues(struct Option * option)
-{
-  StringList sl = stringlist_new(true);
-
-  DIR * d = opendir("/sys/class/uio");
-  if (!d)
-    return sl;
-
-  struct dirent * dir;
-  while((dir = readdir(d)) != NULL)
-  {
-    if (dir->d_name[0] == '.')
-      continue;
-
-    char * name = uioGetName(dir->d_name);
-    if (!name)
-      continue;
-
-    if (strcmp(name, "KVMFR") == 0)
-    {
-      char * devName;
-      alloc_sprintf(&devName, "/dev/%s", dir->d_name);
-      stringlist_push(sl, devName);
-    }
-
-    free(name);
-  }
-
-  closedir(d);
-  return sl;
-}
-
-void ivshmemOptionsInit()
-{
-  struct Option options[] =
-  {
-    {
-      .module         = "app",
-      .name           = "shmFile",
-      .shortopt       = 'f',
-      .description    = "The path to the shared memory file, or the name of the uio device to use, ie: uio0",
-      .type           = OPTION_TYPE_STRING,
-      .value.x_string = "/dev/shm/looking-glass",
-      .validator      = ivshmemDeviceValidator,
-      .getValues      = ivshmemDeviceGetValues
-    },
-    {0}
-  };
-
-  option_register(options);
-}
-
-bool ivshmemOpen(struct IVSHMEM * dev)
-{
-  return ivshmemOpenDev(dev, option_get_string("app", "shmFile"));
-}
-
-bool ivshmemOpenDev(struct IVSHMEM * dev, const char * shmDevice)
-{
-  assert(dev);
-
-  unsigned int devSize;
-  int devFD;
-
-  dev->opaque = NULL;
-
-  DEBUG_INFO("KVMFR Device     : %s", shmDevice);
-
-  if (strlen(shmDevice) > 8 && memcmp(shmDevice, "/dev/uio", 8) == 0)
-  {
-    const char * uioDev = shmDevice + 5;
-
-    // get the device size
-    int fd = uioOpenFile(uioDev, "maps/map0/size");
-    if (fd < 0)
-    {
-      DEBUG_ERROR("Failed to open %s/size", uioDev);
-      return false;
-    }
-
-    char size[32];
-    int  len = read(fd, size, sizeof(size) - 1);
-    if (len <= 0)
-    {
-      DEBUG_ERROR("Failed to read the device size");
-      close(fd);
-      return false;
-    }
-    size[len] = '\0';
-    close(fd);
-    devSize = strtoul(size, NULL, 16);
-
-    devFD = open(shmDevice, O_RDWR, (mode_t)0600);
-    if (devFD < 0)
-    {
-      DEBUG_ERROR("Failed to open: %s", shmDevice);
-      DEBUG_ERROR("Do you have permission to access the device?");
-      return false;
-    }
-  }
-  else
-  {
-    struct stat st;
-    if (stat(shmDevice, &st) != 0)
-    {
-      DEBUG_ERROR("Failed to stat: %s", shmDevice);
-      return false;
-    }
-
-    devSize = st.st_size;
-    devFD   = open(shmDevice, O_RDWR, (mode_t)0600);
-    if (devFD < 0)
-    {
-      DEBUG_ERROR("Failed to open: %s", shmDevice);
-      return false;
-    }
-  }
-
-  void * map = mmap(0, devSize, PROT_READ | PROT_WRITE, MAP_SHARED, devFD, 0);
-  if (map == MAP_FAILED)
-  {
-    DEBUG_ERROR("Failed to map the shared memory device: %s", shmDevice);
-    return false;
-  }
-
-  struct IVSHMEMInfo * info =
-    (struct IVSHMEMInfo *)malloc(sizeof(struct IVSHMEMInfo));
-  info->size = devSize;
-  info->fd   = devFD;
-
-  dev->opaque = info;
-  dev->size   = devSize;
-  dev->mem    = map;
-  return true;
-}
-
-void ivshmemClose(struct IVSHMEM * dev)
-{
-  assert(dev);
-
-  if (!dev->opaque)
-    return;
-
-  struct IVSHMEMInfo * info =
-    (struct IVSHMEMInfo *)dev->opaque;
-
-  munmap(dev->mem, info->size);
-  close(info->fd);
-
-  free(info);
-  dev->mem    = NULL;
-  dev->size   = 0;
-  dev->opaque = NULL;
-}

common/src/platform/linux/thread.c

@@ -1,76 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/thread.h"
-
-#include <stdlib.h>
-#include <pthread.h>
-
-#include "common/debug.h"
-
-struct LGThread
-{
-  const char       * name;
-  LGThreadFunction   function;
-  void             * opaque;
-  pthread_t          handle;
-  int                resultCode;
-};
-
-static void * threadWrapper(void * opaque)
-{
-  LGThread * handle = (LGThread *)opaque;
-  handle->resultCode = handle->function(handle->opaque);
-  return NULL;
-}
-
-bool lgCreateThread(const char * name, LGThreadFunction function, void * opaque, LGThread ** handle)
-{
-  *handle = (LGThread*)malloc(sizeof(LGThread));
-  (*handle)->name     = name;
-  (*handle)->function = function;
-  (*handle)->opaque   = opaque;
-
-  if (pthread_create(&(*handle)->handle, NULL, threadWrapper, *handle) != 0)
-  {
-    DEBUG_ERROR("pthread_create failed for thread: %s", name);
-    free(*handle);
-    *handle = NULL;
-    return false;
-  }
-
-  pthread_setname_np((*handle)->handle, name);
-  return true;
-}
-
-bool lgJoinThread(LGThread * handle, int * resultCode)
-{
-  if (pthread_join(handle->handle, NULL) != 0)
-  {
-    DEBUG_ERROR("pthread_join failed for thread: %s", handle->name);
-    free(handle);
-    return false;
-  }
-
-  if (resultCode)
-    *resultCode = handle->resultCode;
-
-  free(handle);
-  return true;
-}

common/src/platform/linux/time.c

@@ -1,109 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2020-2020 Max Sistemich <maximilian.sistemich@rwth-aachen.de>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/time.h"
-#include "common/debug.h"
-
-#include <errno.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-struct LGTimer
-{
-  LGTimerFn   fn;
-  void      * udata;
-  timer_t     id;
-  bool        running;
-};
-
-static void TimerProc(union sigval arg)
-{
-  LGTimer * timer = (LGTimer *)arg.sival_ptr;
-  if (!timer->fn(timer->udata))
-  {
-    if (timer_delete(timer->id))
-      DEBUG_ERROR("failed to destroy the timer: %s", strerror(errno));
-    timer->running = false;
-  }
-}
-
-bool lgCreateTimer(const unsigned int intervalMS, LGTimerFn fn,
-    void * udata, LGTimer ** result)
-{
-  LGTimer * ret = malloc(sizeof(LGTimer));
-
-  if (!ret)
-  {
-    DEBUG_ERROR("failed to malloc LGTimer struct");
-    return false;
-  }
-
-  ret->fn      = fn;
-  ret->udata   = udata;
-  ret->running = true;
-
-  struct sigevent sev =
-  {
-    .sigev_notify = SIGEV_THREAD,
-    .sigev_notify_function = &TimerProc,
-    .sigev_value.sival_ptr = ret,
-  };
-
-  if (timer_create(CLOCK_MONOTONIC, &sev, &ret->id))
-  {
-    DEBUG_ERROR("failed to create timer: %s", strerror(errno));
-    free(ret);
-    return false;
-  }
-
-  struct timespec interval =
-  {
-    .tv_sec = 0,
-    .tv_nsec = intervalMS * 1000 * 1000,
-  };
-  struct itimerspec spec =
-  {
-    .it_interval = interval,
-    .it_value = interval,
-  };
-
-  if (timer_settime(ret->id, 0, &spec, NULL))
-  {
-    DEBUG_ERROR("failed to set timer: %s", strerror(errno));
-    timer_delete(ret->id);
-    free(ret);
-    return false;
-  }
-
-  *result = ret;
-  return true;
-}
-
-void lgTimerDestroy(LGTimer * timer)
-{
-  if (timer->running)
-  {
-    if (timer_delete(timer->id))
-      DEBUG_ERROR("failed to destroy the timer: %s", strerror(errno));
-  }
-
-  free(timer);
-}

common/src/platform/windows/CMakeLists.txt

@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-project(lg_common_platform_code LANGUAGES C)
-
-include_directories(
-        ${PROJECT_TOP}/vendor/ivshmem
-)
-
-add_library(lg_common_platform_code STATIC
-    crash.c
-    sysinfo.c
-    thread.c
-    event.c
-    windebug.c
-    ivshmem.c
-    time.c
-)
-
-target_link_libraries(lg_common_platform_code
-	lg_common
-	setupapi
-)

common/src/platform/windows/event.c

@@ -1,221 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/event.h"
-#include "common/windebug.h"
-#include "common/time.h"
-
-#include <windows.h>
-
-struct LGEvent
-{
-  volatile int  lock;
-  bool          reset;
-  HANDLE        handle;
-  bool          wrapped;
-  unsigned int  msSpinTime;
-  volatile bool signaled;
-};
-
-LGEvent * lgCreateEvent(bool autoReset, unsigned int msSpinTime)
-{
-  LGEvent * event = (LGEvent *)malloc(sizeof(LGEvent));
-  if (!event)
-  {
-    DEBUG_ERROR("out of ram");
-    return NULL;
-  }
-
-  event->lock       = 0;
-  event->reset      = autoReset;
-  event->handle     = CreateEvent(NULL, autoReset ? FALSE : TRUE, FALSE, NULL);
-  event->wrapped    = false;
-  event->msSpinTime = msSpinTime;
-  event->signaled   = false;
-
-  if (!event->handle)
-  {
-    DEBUG_WINERROR("Failed to create the event", GetLastError());
-    free(event);
-    return NULL;
-  }
-
-  return event;
-}
-
-LGEvent * lgWrapEvent(void * handle)
-{
-  LGEvent * event = (LGEvent *)malloc(sizeof(LGEvent));
-  if (!event)
-  {
-    DEBUG_ERROR("out of ram");
-    return NULL;
-  }
-
-  event->lock       = 0;
-  event->reset      = false;
-  event->handle     = (HANDLE)handle;
-  event->wrapped    = true;
-  event->msSpinTime = 0;
-  event->signaled   = false;
-  return event;
-}
-
-void lgFreeEvent(LGEvent * event)
-{
-  CloseHandle(event->handle);
-}
-
-bool lgWaitEvent(LGEvent * event, unsigned int timeout)
-{
-  // wrapped events can't be enahnced
-  if (!event->wrapped)
-  {
-    if (event->signaled)
-    {
-      if (event->reset)
-        event->signaled = false;
-      return true;
-    }
-
-    if (timeout == 0)
-    {
-      bool ret = event->signaled;
-      if (event->reset)
-        event->signaled = false;
-      return ret;
-    }
-
-    if (event->msSpinTime)
-    {
-      unsigned int spinTime = event->msSpinTime;
-      if (timeout != TIMEOUT_INFINITE)
-      {
-        if (timeout > event->msSpinTime)
-          timeout -= event->msSpinTime;
-        else
-        {
-          spinTime -= timeout;
-          timeout   = 0;
-        }
-      }
-
-      uint64_t now = microtime();
-      uint64_t end = now + spinTime * 1000;
-      while(!event->signaled)
-      {
-        now = microtime();
-        if (now >= end)
-          break;
-      }
-
-      if (event->signaled)
-      {
-        if (event->reset)
-          event->signaled = false;
-        return true;
-      }
-    }
-  }
-
-  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
-  while(true)
-  {
-    switch(WaitForSingleObject(event->handle, to))
-    {
-      case WAIT_OBJECT_0:
-        if (!event->reset)
-          event->signaled = true;
-        return true;
-
-      case WAIT_ABANDONED:
-        continue;
-
-      case WAIT_TIMEOUT:
-        if (timeout == TIMEOUT_INFINITE)
-          continue;
-
-        return false;
-
-      case WAIT_FAILED:
-        DEBUG_WINERROR("Wait for event failed", GetLastError());
-        return false;
-    }
-
-    DEBUG_ERROR("Unknown wait event return code");
-    return false;
-  }
-}
-
-bool lgWaitEvents(LGEvent * events[], int count, bool waitAll, unsigned int timeout)
-{
-  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
-
-  HANDLE * handles = (HANDLE *)malloc(sizeof(HANDLE) * count);
-  for(int i = 0; i < count; ++i)
-    handles[i] = events[i]->handle;
-
-  while(true)
-  {
-    DWORD result = WaitForMultipleObjects(count, handles, waitAll, to);
-    if (result >= WAIT_OBJECT_0 && result < count)
-    {
-      // null non signaled events from the handle list
-      for(int i = 0; i < count; ++i)
-        if (i != result && !lgWaitEvent(events[i], 0))
-          events[i] = NULL;
-      free(handles);
-      return true;
-    }
-
-    if (result >= WAIT_ABANDONED_0 && result - WAIT_ABANDONED_0 < count)
-      continue;
-
-    switch(result)
-    {
-      case WAIT_TIMEOUT:
-        if (timeout == TIMEOUT_INFINITE)
-          continue;
-
-        free(handles);
-        return false;
-
-      case WAIT_FAILED:
-        DEBUG_WINERROR("Wait for event failed", GetLastError());
-        free(handles);
-        return false;
-    }
-
-    DEBUG_ERROR("Unknown wait event return code");
-    free(handles);
-    return false;
-  }
-}
-
-bool lgSignalEvent(LGEvent * event)
-{
-  event->signaled = true;
-  return SetEvent(event->handle);
-}
-
-bool lgResetEvent(LGEvent * event)
-{
-  event->signaled = false;
-  return ResetEvent(event->handle);
-}

common/src/platform/windows/ivshmem.c

@@ -1,153 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/ivshmem.h"
-#include "common/option.h"
-#include "common/windebug.h"
-
-#include <windows.h>
-#include "ivshmem.h"
-
-#include <assert.h>
-#include <setupapi.h>
-#include <io.h>
-
-struct IVSHMEMInfo
-{
-  HANDLE handle;
-};
-
-void ivshmemOptionsInit()
-{
-  static struct Option options[] = {
-    {
-      .module         = "os",
-      .name           = "shmDevice",
-      .description    = "The IVSHMEM device to use",
-      .type           = OPTION_TYPE_INT,
-      .value.x_int    = 0
-    },
-    {0}
-  };
-
-  option_register(options);
-}
-
-bool ivshmemOpen(struct IVSHMEM * dev)
-{
-  assert(dev);
-
-  HANDLE devHandle;
-
-  {
-    HDEVINFO                         devInfoSet;
-    PSP_DEVICE_INTERFACE_DETAIL_DATA infData = NULL;
-    SP_DEVICE_INTERFACE_DATA         devInterfaceData = {0};
-
-    devInfoSet = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES | DIGCF_DEVICEINTERFACE);
-    devInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
-
-    const int shmDevice = option_get_int("os", "shmDevice");
-    if (SetupDiEnumDeviceInterfaces(devInfoSet, NULL, &GUID_DEVINTERFACE_IVSHMEM, shmDevice, &devInterfaceData) == FALSE)
-    {
-      DWORD error = GetLastError();
-      if (error == ERROR_NO_MORE_ITEMS)
-      {
-        DEBUG_WINERROR("Unable to enumerate the device, is it attached?", error);
-        return false;
-      }
-
-      DEBUG_WINERROR("SetupDiEnumDeviceInterfaces failed", error);
-      return false;
-    }
-
-    DWORD reqSize = 0;
-    SetupDiGetDeviceInterfaceDetail(devInfoSet, &devInterfaceData, NULL, 0, &reqSize, NULL);
-    if (!reqSize)
-    {
-      DEBUG_WINERROR("SetupDiGetDeviceInterfaceDetail", GetLastError());
-      return false;
-    }
-
-    infData         = (PSP_DEVICE_INTERFACE_DETAIL_DATA)calloc(reqSize, 1);
-    infData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
-    if (!SetupDiGetDeviceInterfaceDetail(devInfoSet, &devInterfaceData, infData, reqSize, NULL, NULL))
-    {
-      free(infData);
-      DEBUG_WINERROR("SetupDiGetDeviceInterfaceDetail", GetLastError());
-      return false;
-    }
-
-    devHandle = CreateFile(infData->DevicePath, 0, 0, NULL, OPEN_EXISTING, 0, 0);
-    if (devHandle == INVALID_HANDLE_VALUE)
-    {
-      SetupDiDestroyDeviceInfoList(devInfoSet);
-      free(infData);
-      DEBUG_WINERROR("CreateFile returned INVALID_HANDLE_VALUE", GetLastError());
-      return false;
-    }
-
-    free(infData);
-    SetupDiDestroyDeviceInfoList(devInfoSet);
-  }
-
-  IVSHMEM_SIZE size;
-  if (!DeviceIoControl(devHandle, IOCTL_IVSHMEM_REQUEST_SIZE, NULL, 0, &size, sizeof(IVSHMEM_SIZE), NULL, NULL))
-  {
-    DEBUG_WINERROR("DeviceIoControl Failed", GetLastError());
-    return 0;
-  }
-
-  IVSHMEM_MMAP_CONFIG config = { .cacheMode = IVSHMEM_CACHE_WRITECOMBINED };
-  IVSHMEM_MMAP map = { 0 };
-  if (!DeviceIoControl(
-    devHandle,
-    IOCTL_IVSHMEM_REQUEST_MMAP,
-    &config, sizeof(IVSHMEM_MMAP_CONFIG),
-    &map   , sizeof(IVSHMEM_MMAP),
-    NULL, NULL))
-  {
-    DEBUG_WINERROR("DeviceIoControl Failed", GetLastError());
-    return false;
-  }
-
-  struct IVSHMEMInfo * info =
-    (struct IVSHMEMInfo *)malloc(sizeof(struct IVSHMEMInfo));
-
-  info->handle = devHandle;
-
-  dev->opaque = info;
-  dev->size   = (unsigned int)size;
-  dev->mem    = map.ptr;
-
-  return true;
-}
-
-void ivshmemClose(struct IVSHMEM * dev)
-{
-  assert(dev);
-
-  struct IVSHMEMInfo * info =
-    (struct IVSHMEMInfo *)dev->opaque;
-
-  if (!DeviceIoControl(info->handle, IOCTL_IVSHMEM_RELEASE_MMAP, NULL, 0, NULL, 0, NULL, NULL))
-    DEBUG_WINERROR("DeviceIoControl failed", GetLastError());
-
-  free(info);
-}

common/src/platform/windows/thread.c

@@ -1,93 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/thread.h"
-#include "common/debug.h"
-#include "common/windebug.h"
-
-#include <windows.h>
-
-struct LGThread
-{
-  const char       * name;
-  LGThreadFunction   function;
-  void             * opaque;
-  HANDLE             handle;
-  DWORD              threadID;
-
-  int                resultCode;
-};
-
-static DWORD WINAPI threadWrapper(LPVOID lpParameter)
-{
-  LGThread * handle = (LGThread *)lpParameter;
-  handle->resultCode = handle->function(handle->opaque);
-  return 0;
-}
-
-bool lgCreateThread(const char * name, LGThreadFunction function, void * opaque, LGThread ** handle)
-{
-  *handle             = (LGThread *)malloc(sizeof(LGThread));
-  (*handle)->name     = name;
-  (*handle)->function = function;
-  (*handle)->opaque   = opaque;
-  (*handle)->handle   = CreateThread(NULL, 0, threadWrapper, *handle, 0, &(*handle)->threadID);
-
-  if (!(*handle)->handle)
-  {
-    free(*handle);
-    *handle = NULL;
-    DEBUG_WINERROR("CreateThread failed", GetLastError());
-    return false;
-  }
-
-  return true;
-}
-
-bool lgJoinThread(LGThread * handle, int * resultCode)
-{
-  while(true)
-  {
-    switch(WaitForSingleObject(handle->handle, INFINITE))
-    {
-      case WAIT_OBJECT_0:
-        if (resultCode)
-          *resultCode = handle->resultCode;
-        CloseHandle(handle->handle);
-        free(handle);
-        return true;
-
-      case WAIT_ABANDONED:
-      case WAIT_TIMEOUT:
-        continue;
-
-      case WAIT_FAILED:
-        DEBUG_WINERROR("Wait for thread failed", GetLastError());
-        CloseHandle(handle->handle);
-        free(handle);
-        return false;
-    }
-
-    break;
-  }
-
-  DEBUG_WINERROR("Unknown failure waiting for thread", GetLastError());
-  return false;
-}
-

common/src/platform/windows/time.c

@@ -1,72 +0,0 @@
-/*
-Looking Glass - KVM FrameRelay (KVMFR) Client
-Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/time.h"
-#include "common/debug.h"
-
-// decared by the platform
-extern HWND MessageHWND;
-
-struct LGTimer
-{
-  LGTimerFn   fn;
-  void      * udata;
-  UINT_PTR    handle;
-  bool        running;
-};
-
-static void TimerProc(HWND Arg1, UINT Arg2, UINT_PTR Arg3, DWORD Arg4)
-{
-  LGTimer * timer = (LGTimer *)Arg3;
-  if (!timer->fn(timer->udata))
-  {
-    KillTimer(Arg1, timer->handle);
-    timer->running = false;
-  }
-}
-
-bool lgCreateTimer(const unsigned int intervalMS, LGTimerFn fn,
-    void * udata, LGTimer ** result)
-{
-  LGTimer * ret = malloc(sizeof(LGTimer));
-  if (!ret)
-  {
-    DEBUG_ERROR("failed to malloc LGTimer struct");
-    return false;
-  }
-
-  ret->fn      = fn;
-  ret->udata   = udata;
-  ret->running = true;
-  ret->handle  = SetTimer(MessageHWND, (UINT_PTR)ret, intervalMS, TimerProc);
-
-  *result = ret;
-  return true;
-}
-
-void lgTimerDestroy(LGTimer * timer)
-{
-  if (timer->running)
-  {
-    if (!KillTimer(MessageHWND, timer->handle))
-      DEBUG_ERROR("failed to destroy the timer");
-  }
-
-  free(timer);
-}

common/src/stringlist.c

@@ -1,79 +0,0 @@
-/*
-KVMGFX Client - A KVM Client for VGA Passthrough
-Copyright (C) 2017-2019 Geoffrey McRae <geoff@hostfission.com>
-https://looking-glass.hostfission.com
-
-This program is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation; either version 2 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "common/stringlist.h"
-
-#include <stdlib.h>
-
-struct StringList
-{
-  bool         owns_strings;
-  unsigned int size;
-  unsigned int count;
-  char ** list;
-};
-
-StringList stringlist_new(bool owns_strings)
-{
-  StringList sl = malloc(sizeof(struct StringList));
-
-  sl->owns_strings = owns_strings;
-  sl->size         = 32;
-  sl->count        = 0;
-  sl->list         = malloc(sizeof(char *) * sl->size);
-
-  return sl;
-}
-
-void stringlist_free(StringList * sl)
-{
-  if ((*sl)->owns_strings)
-    for(unsigned int i = 0; i < (*sl)->count; ++i)
-      free((*sl)->list[i]);
-
-  free((*sl)->list);
-  free((*sl));
-  *sl = NULL;
-}
-
-int stringlist_push (StringList sl, char * str)
-{
-  if (sl->count == sl->size)
-  {
-    sl->size += 32;
-    sl->list  = realloc(sl->list, sizeof(char *) * sl->size);
-  }
-
-  unsigned int index = sl->count;
-  sl->list[sl->count++] = str;
-  return index;
-}
-
-unsigned int stringlist_count(StringList sl)
-{
-  return sl->count;
-}
-
-char * stringlist_at(StringList sl, unsigned int index)
-{
-  if (index >= sl->count)
-    return NULL;
-
-  return sl->list[index];
-}

common/src/stringutils.c

@@ -21,24 +21,26 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include <stdlib.h>
 #include <stdarg.h>
 
-static int valloc_sprintf(char ** str, const char * format, va_list ap)
+int alloc_sprintf(char ** str, const char * format, ...)
 {
   if (!str)
     return -1;
 
   *str = NULL;
-
-  va_list ap1;
-  va_copy(ap1, ap);
-  int len = vsnprintf(NULL, 0, format, ap1);
-  va_end(ap1);
+  va_list ap;
+  va_start(ap, format);
+  int len = vsnprintf(NULL, 0, format, ap);
+  va_end(ap);
 
   if (len < 0)
     return len;
 
   *str = malloc(len+1);
 
+  va_start(ap, format);
   int ret = vsnprintf(*str, len + 1, format, ap);
+  va_end(ap);
+
   if (ret < 0)
   {
     free(*str);
@@ -46,14 +48,5 @@ static int valloc_sprintf(char ** str, const char * format, va_list ap)
     return ret;
   }
 
-  return ret;
-}
-
-int alloc_sprintf(char ** str, const char * format, ...)
-{
-  va_list ap;
-  va_start(ap, format);
-  int ret = valloc_sprintf(str, format, ap);
-  va_end(ap);
   return ret;
 }