[repos] lgprotocol: import shared protocol definitions

Add LGProtocol as a pinned submodule and consume its KVMFR protocol
definitions throughout the client, host, IDD, OBS, and profiler.

Keep Looking Glass framebuffer helpers local while removing duplicated
protocol headers and migrating users to KVMFR-scoped types.

common/src/KVMFR.c

@@ -18,7 +18,7 @@
  * Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
-#include "common/KVMFR.h"
+#include <LGProtocol/KVMFR.h>
 
 const char * FrameTypeStr[FRAME_TYPE_MAX] =
 {

common/src/framebuffer.c

@@ -43,7 +43,7 @@ static bool framebuffer_size_mul(size_t a, size_t b, size_t * result)
   return true;
 }
 
-bool framebuffer_wait_timed(const FrameBuffer * frame, size_t size,
+bool framebuffer_wait_timed(const KVMFRFrameBuffer * frame, size_t size,
     uint64_t * waitTimeNs)
 {
   if (size > UINT_LEAST32_MAX)
@@ -75,27 +75,27 @@ bool framebuffer_wait_timed(const FrameBuffer * frame, size_t size,
   return true;
 }
 
-bool framebuffer_wait(const FrameBuffer * frame, size_t size)
+bool framebuffer_wait(const KVMFRFrameBuffer * frame, size_t size)
 {
   return framebuffer_wait_timed(frame, size, NULL);
 }
 
-static bool framebuffer_read_linear_timed(const FrameBuffer * frame,
+static bool framebuffer_read_linear_timed(const KVMFRFrameBuffer * frame,
     void * restrict dst, size_t size, uint64_t * waitTimeNs)
 {
   if (size > UINT_LEAST32_MAX)
     return false;
 
 #ifdef FB_PROFILE
-  static RunningAvg ra = NULL;
-  static int raCount = 0;
-  const uint64_t ts = microtime();
+  static RunningAvg ra      = NULL;
+  static int        raCount = 0;
+  const uint64_t    ts      = microtime();
   if (!ra)
     ra = runningavg_new(100);
 #endif
 
-  uint8_t * restrict d     = (uint8_t*)dst;
-  size_t rp                = 0;
+  uint8_t * restrict d  = (uint8_t*)dst;
+  size_t             rp = 0;
 
   // copy in large 1MB chunks if the pitches match
   while(size)
@@ -119,13 +119,14 @@ static bool framebuffer_read_linear_timed(const FrameBuffer * frame,
   return true;
 }
 
-bool framebuffer_read_linear(const FrameBuffer * frame, void * restrict dst,
-    size_t size)
+bool framebuffer_read_linear(const KVMFRFrameBuffer * frame,
+    void * restrict dst, size_t size)
 {
   return framebuffer_read_linear_timed(frame, dst, size, NULL);
 }
 
-bool framebuffer_read_timed(const FrameBuffer * frame, void * restrict dst,
+bool framebuffer_read_timed(const KVMFRFrameBuffer * frame,
+    void * restrict dst,
     size_t dstpitch, size_t height, size_t width, size_t bpp, size_t pitch,
     uint64_t * waitTimeNs)
 {
@@ -147,15 +148,15 @@ bool framebuffer_read_timed(const FrameBuffer * frame, void * restrict dst,
         frame, dst, sourceSize, waitTimeNs);
 
 #ifdef FB_PROFILE
-  static RunningAvg ra = NULL;
-  static int raCount = 0;
-  const uint64_t ts = microtime();
+  static RunningAvg ra      = NULL;
+  static int        raCount = 0;
+  const uint64_t    ts      = microtime();
   if (!ra)
     ra = runningavg_new(100);
 #endif
 
-  uint8_t * restrict d     = (uint8_t*)dst;
-  size_t rp                = 0;
+  uint8_t * restrict d  = (uint8_t*)dst;
+  size_t             rp = 0;
 
   // copy per line to match the pitch of the destination buffer
   for(size_t y = 0; y < height; ++y)
@@ -177,15 +178,16 @@ bool framebuffer_read_timed(const FrameBuffer * frame, void * restrict dst,
   return true;
 }
 
-bool framebuffer_read(const FrameBuffer * frame, void * restrict dst,
+bool framebuffer_read(const KVMFRFrameBuffer * frame, void * restrict dst,
     size_t dstpitch, size_t height, size_t width, size_t bpp, size_t pitch)
 {
   return framebuffer_read_timed(frame, dst, dstpitch, height, width, bpp,
       pitch, NULL);
 }
 
-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 KVMFRFrameBuffer * frame, size_t height,
+    size_t width, size_t bpp, size_t pitch, FrameBufferReadFn fn,
+    void * opaque)
 {
   size_t linewidth;
   size_t sourceSize;
@@ -200,15 +202,15 @@ bool framebuffer_read_fn(const FrameBuffer * frame, size_t height, size_t width,
     return true;
 
 #ifdef FB_PROFILE
-  static RunningAvg ra = NULL;
-  static int raCount = 0;
-  const uint64_t ts = microtime();
+  static RunningAvg ra      = NULL;
+  static int        raCount = 0;
+  const uint64_t    ts      = microtime();
   if (!ra)
     ra = runningavg_new(100);
 #endif
 
-  size_t         rp        = 0;
-  size_t         y         = 0;
+  size_t rp = 0;
+  size_t y  = 0;
 
   while(y < height)
   {
@@ -234,37 +236,37 @@ 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(KVMFRFrameBuffer * frame)
 {
   atomic_store_explicit(&frame->wp, 0, memory_order_release);
 }
 
-static bool framebuffer_write_sse4_1(FrameBuffer * frame,
+static bool framebuffer_write_sse4_1(KVMFRFrameBuffer * frame,
     const void * restrict src, size_t size)
 {
 #ifdef FB_PROFILE
-  static RunningAvg ra = NULL;
-  static int raCount = 0;
-  const uint64_t ts = microtime();
+  static RunningAvg ra      = NULL;
+  static int        raCount = 0;
+  const uint64_t    ts      = microtime();
   if (!ra)
     ra = runningavg_new(100);
 #endif
 
-  __m128i * restrict s = (__m128i *)src;
-  __m128i * restrict d = (__m128i *)frame->data;
-  size_t wp = 0;
+  __m128i * restrict s  = (__m128i *)src;
+  __m128i * restrict d  = (__m128i *)frame->data;
+  size_t             wp = 0;
 
   _mm_mfence();
 
   /* copy in chunks */
   while(size > 63)
   {
-    __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);
+    __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);
@@ -303,20 +305,20 @@ static bool framebuffer_write_sse4_1(FrameBuffer * frame,
   #pragma GCC push_options
   #pragma GCC target ("avx2")
 #endif
-bool framebuffer_write_avx2(FrameBuffer * frame,
+bool framebuffer_write_avx2(KVMFRFrameBuffer * frame,
     const void * restrict src, size_t size)
 {
 #ifdef FB_PROFILE
-    static RunningAvg ra = NULL;
-    static int raCount = 0;
-    const uint64_t ts = microtime();
-    if (!ra)
-        ra = runningavg_new(100);
+  static RunningAvg ra      = NULL;
+  static int        raCount = 0;
+  const uint64_t    ts      = microtime();
+  if (!ra)
+    ra = runningavg_new(100);
 #endif
 
-  __m256i *restrict s = (__m256i *)src;
-  __m256i *restrict d = (__m256i *)frame->data;
-  size_t wp = 0;
+  __m256i * restrict s  = (__m256i *)src;
+  __m256i * restrict d  = (__m256i *)frame->data;
+  size_t             wp = 0;
 
   _mm_mfence();
 
@@ -381,7 +383,7 @@ bool framebuffer_write_avx2(FrameBuffer * frame,
   #pragma GCC pop_options
 #endif
 
-static bool _framebuffer_write(FrameBuffer * frame,
+static bool _framebuffer_write(KVMFRFrameBuffer * frame,
     const void * restrict src, size_t size)
 {
   if (cpuInfo_getFeatures()->avx2)
@@ -392,20 +394,20 @@ static bool _framebuffer_write(FrameBuffer * frame,
   return framebuffer_write(frame, src, size);
 }
 
-bool (*framebuffer_write)(FrameBuffer * frame,
-  const void * restrict src, size_t size) = &_framebuffer_write;
+bool (*framebuffer_write)(KVMFRFrameBuffer * frame,
+    const void * restrict src, size_t size) = &_framebuffer_write;
 
-const uint8_t * framebuffer_get_buffer(const FrameBuffer * frame)
+const uint8_t * framebuffer_get_buffer(const KVMFRFrameBuffer * frame)
 {
   return frame->data;
 }
 
-uint8_t * framebuffer_get_data(FrameBuffer * frame)
+uint8_t * framebuffer_get_data(KVMFRFrameBuffer * frame)
 {
   return frame->data;
 }
 
-void framebuffer_set_write_ptr(FrameBuffer * frame, size_t size)
+void framebuffer_set_write_ptr(KVMFRFrameBuffer * frame, size_t size)
 {
   atomic_store_explicit(&frame->wp, size, memory_order_release);
 }

common/src/rects.c

@@ -52,8 +52,8 @@ void rectScaleOutward(struct Rect * rect, double scale)
   rect->h = bottom - top;
 }
 
-inline static bool rectIntersects(const FrameDamageRect * r1,
-    const FrameDamageRect * r2)
+inline static bool rectIntersects(const KVMFRFrameDamageRect * r1,
+    const KVMFRFrameDamageRect * r2)
 {
   return !(
     r1->x > r2->x + r2->width  ||
@@ -62,8 +62,8 @@ inline static bool rectIntersects(const FrameDamageRect * r1,
     r2->y > r1->y + r1->height);
 }
 
-inline static bool rectContains(const FrameDamageRect * r1,
-    const FrameDamageRect * r2)
+inline static bool rectContains(const KVMFRFrameDamageRect * r1,
+    const KVMFRFrameDamageRect * r2)
 {
   return !(
     r2->x              < r1->x              ||
@@ -72,7 +72,7 @@ inline static bool rectContains(const FrameDamageRect * r1,
     r2->y + r2->height > r1->y + r1->height);
 }
 
-inline static int removeRects(FrameDamageRect * rects, int count,
+inline static int removeRects(KVMFRFrameDamageRect * rects, int count,
     bool removed[])
 {
   int o = 0;
@@ -99,7 +99,7 @@ static int cornerCompare(const void * a_, const void * b_)
   return 0;
 }
 
-static bool rectsBufferCopy(const FrameDamageRect * rects,
+static bool rectsBufferCopy(const KVMFRFrameDamageRect * rects,
   int count, int bpp,
   uint8_t * dst, int dstStride, int height,
   const uint8_t * src, int srcStride, void * opaque,
@@ -117,9 +117,9 @@ static bool rectsBufferCopy(const FrameDamageRect * rects,
 
   for (int i = 0; i < count; ++i)
   {
-    const FrameDamageRect * rect = rects + i;
-    const uint64_t right  = (uint64_t)rect->x + rect->width;
-    const uint64_t bottom = (uint64_t)rect->y + rect->height;
+    const KVMFRFrameDamageRect * rect   = rects + i;
+    const uint64_t               right  = (uint64_t)rect->x + rect->width;
+    const uint64_t               bottom = (uint64_t)rect->y + rect->height;
     if (!rect->width || !rect->height || bottom > (uint32_t)height ||
         right > (uint32_t)dstStride / (uint32_t)bpp ||
         right > (uint32_t)srcStride / (uint32_t)bpp)
@@ -133,7 +133,7 @@ static bool rectsBufferCopy(const FrameDamageRect * rects,
 
   for (int i = 0; i < count; ++i)
   {
-    const FrameDamageRect * rect = rects + i;
+    const KVMFRFrameDamageRect * rect = rects + i;
     corners[4 * i + 0] = (struct Corner) {
       .x = rect->x, .y = rect->y, .delta = 1
     };
@@ -233,8 +233,8 @@ static bool rectsBufferCopy(const FrameDamageRect * rects,
 
 struct ToFramebufferData
 {
-  FrameBuffer * frame;
-  int pitch;
+  KVMFRFrameBuffer * frame;
+  int                pitch;
 };
 
 static void fbRowFinish(int y, void * opaque)
@@ -244,9 +244,9 @@ static void fbRowFinish(int y, void * opaque)
       data->frame, (size_t)y * (size_t)data->pitch);
 }
 
-bool rectsBufferToFramebuffer(const FrameDamageRect * rects,
+bool rectsBufferToFramebuffer(const KVMFRFrameDamageRect * rects,
   int count, int bpp,
-  FrameBuffer * frame, int dstPitch, int height,
+  KVMFRFrameBuffer * frame, int dstPitch, int height,
   const uint8_t * src, int srcPitch)
 {
   if (!rects || !frame || count <= 0)
@@ -271,9 +271,9 @@ bool rectsBufferToFramebuffer(const FrameDamageRect * rects,
 
 struct FromFramebufferData
 {
-  const FrameBuffer * frame;
-  int                 pitch;
-  uint64_t          * waitTimeNs;
+  const KVMFRFrameBuffer * frame;
+  int                      pitch;
+  uint64_t               * waitTimeNs;
 };
 
 static bool fbRowStart(int y, void * opaque)
@@ -283,10 +283,10 @@ static bool fbRowStart(int y, void * opaque)
       data->frame, (size_t)y * (size_t)data->pitch, data->waitTimeNs);
 }
 
-bool rectsFramebufferToBufferTimed(const FrameDamageRect * rects,
+bool rectsFramebufferToBufferTimed(const KVMFRFrameDamageRect * rects,
   int count, int bpp,
   uint8_t * dst, int dstPitch, int height,
-  const FrameBuffer * frame, int srcPitch, uint64_t * waitTimeNs)
+  const KVMFRFrameBuffer * frame, int srcPitch, uint64_t * waitTimeNs)
 {
   if (!rects || !frame || count <= 0)
     return false;
@@ -310,16 +310,16 @@ bool rectsFramebufferToBufferTimed(const FrameDamageRect * rects,
   return true;
 }
 
-bool rectsFramebufferToBuffer(const FrameDamageRect * rects,
+bool rectsFramebufferToBuffer(const KVMFRFrameDamageRect * rects,
   int count, int bpp,
   uint8_t * dst, int dstPitch, int height,
-  const FrameBuffer * frame, int srcPitch)
+  const KVMFRFrameBuffer * frame, int srcPitch)
 {
   return rectsFramebufferToBufferTimed(rects, count, bpp, dst, dstPitch,
       height, frame, srcPitch, NULL);
 }
 
-int rectsMergeOverlapping(FrameDamageRect * rects, int count)
+int rectsMergeOverlapping(KVMFRFrameDamageRect * rects, int count)
 {
   if (count == 0)
     return 0;
@@ -362,7 +362,7 @@ int rectsMergeOverlapping(FrameDamageRect * rects, int count)
   return removeRects(rects, count, removed);
 }
 
-int rectsRejectContained(FrameDamageRect * rects, int count)
+int rectsRejectContained(KVMFRFrameDamageRect * rects, int count)
 {
   bool removed[count];
   memset(removed, 0, sizeof(removed));