Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2025-10-14 03:20:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[LGMP] start of c-host conversion to use LGMP

Browse Source
This commit is contained in:
Geoffrey McRae
2020-01-09 15:42:32 +11:00
parent 8caa220ad5
commit 0b8f1a18b2
8 changed files with 231 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

343
c-host/src/app.c
View File

@@ -28,6 +28,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
#include "common/thread.h"
#include "common/ivshmem.h"
#include <lgmp/host.h>
#include <stdio.h>
#include <inttypes.h>
#include <unistd.h>
@@ -36,124 +38,51 @@ Place, Suite 330, Boston, MA 02111-1307 USA
#define ALIGN_DN(x) ((uintptr_t)(x) & ~0x7F)
#define ALIGN_UP(x) ALIGN_DN(x + 0x7F)
#define MAX_FRAMES 2
#define LGMP_Q_POINTER 1
#define LGMP_Q_POINTER_LEN 10
#define LGMP_Q_FRAME 2
#define LGMP_Q_FRAME_LEN 2
#define MAX_POINTER_SIZE (sizeof(KVMFRCursor) + (128 * 128 * 4))
struct app
{
unsigned int clientInstance;
PLGMPHost lgmp;
KVMFRHeader * shmHeader;
uint8_t * pointerData;
unsigned int pointerDataSize;
unsigned int pointerOffset;
PLGMPHQueue pointerQueue;
PLGMPMemory pointerMemory[LGMP_Q_POINTER_LEN];
unsigned int pointerIndex;
size_t maxFrameSize;
PLGMPHQueue frameQueue;
PLGMPMemory frameMemory[LGMP_Q_FRAME_LEN];
unsigned int frameIndex;
CaptureInterface * iface;
uint8_t * frames;
unsigned int frameSize;
FrameBuffer frame[MAX_FRAMES];
unsigned int frameOffset[MAX_FRAMES];
bool running;
bool reinit;
LGThread * pointerThread;
LGThread * lgmpThread;
LGThread * frameThread;
};
static struct app app;
static int pointerThread(void * opaque)
static int lgmpThread(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 };
LGMP_STATUS status;
while(app.running)
{
bool resend = false;
pointer.shapeUpdate = false;
switch(app.iface->getPointer(&pointer))
if ((status = lgmpHostProcess(app.lgmp)) != LGMP_OK)
{
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;
}
DEBUG_ERROR("lgmpHostProcess Failed: %s", lgmpStatusString(status));
break;
}
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;
usleep(1000);
}
DEBUG_INFO("Pointer thread stopped");
app.running = false;
return 0;
}
@@ -161,16 +90,23 @@ static int frameThread(void * opaque)
{
DEBUG_INFO("Frame thread started");
volatile KVMFRFrame * fi = &(app.shmHeader->frame);
bool frameValid = false;
bool repeatFrame = false;
int frameIndex = 0;
unsigned int clientInstance = 0;
CaptureFrame frame = { 0 };
(void)frameIndex;
(void)repeatFrame;
while(app.running)
{
//wait until there is room in the queue
if (lgmpHostQueuePending(app.frameQueue) == LGMP_Q_FRAME_LEN)
{
usleep(1);
continue;
}
switch(app.iface->waitFrame(&frame))
{
case CAPTURE_RESULT_OK:
@@ -192,7 +128,7 @@ static int frameThread(void * opaque)
case CAPTURE_RESULT_TIMEOUT:
{
if (frameValid && clientInstance != app.clientInstance)
if (frameValid && lgmpHostNewSubCount(app.frameQueue) > 0)
{
// resend the last frame
repeatFrame = true;
@@ -203,41 +139,40 @@ static int frameThread(void * opaque)
}
}
clientInstance = app.clientInstance;
// wait for the client to finish with the previous frame
while(fi->flags & KVMFR_FRAME_FLAG_UPDATE && app.running)
usleep(1000);
if (repeatFrame)
INTERLOCKED_OR8(&fi->flags, KVMFR_FRAME_FLAG_UPDATE);
else
{
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]);
lgmpHostPost(app.frameQueue, 0, app.frameMemory[app.frameIndex]);
continue;
}
if (++frameIndex == MAX_FRAMES)
// we increment the index first so that if we need to repeat a frame
// the index still points to the latest valid frame
if (frameIndex++ == LGMP_Q_FRAME_LEN)
frameIndex = 0;
KVMFRFrame * fi = lgmpHostMemPtr(app.frameMemory[app.frameIndex]);
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;
frameValid = true;
FrameBuffer fb = (FrameBuffer)(fi + 1);
framebuffer_prepare(fb);
app.iface->getFrame(fb);
lgmpHostPost(app.frameQueue, 0, app.frameMemory[app.frameIndex]);
}
DEBUG_INFO("Frame thread stopped");
return 0;
@@ -246,9 +181,9 @@ static int frameThread(void * opaque)
bool startThreads()
{
app.running = true;
if (!lgCreateThread("CursorThread", pointerThread, NULL, &app.pointerThread))
if (!lgCreateThread("LGMPThread", lgmpThread, NULL, &app.lgmpThread))
{
DEBUG_ERROR("Failed to create the pointer thread");
DEBUG_ERROR("Failed to create the LGMP thread");
return false;
}
@@ -275,12 +210,12 @@ bool stopThreads()
}
app.frameThread = NULL;
if (app.pointerThread && !lgJoinThread(app.pointerThread, NULL))
if (app.lgmpThread && !lgJoinThread(app.lgmpThread, NULL))
{
DEBUG_WARN("Failed to join the pointer thread");
DEBUG_WARN("Failed to join the LGMP thread");
ok = false;
}
app.pointerThread = NULL;
app.lgmpThread = NULL;
return ok;
}
@@ -290,7 +225,7 @@ static bool captureStart()
DEBUG_INFO("Using : %s", app.iface->getName());
const unsigned int maxFrameSize = app.iface->getMaxFrameSize();
if (maxFrameSize > app.frameSize)
if (maxFrameSize > app.maxFrameSize)
{
DEBUG_ERROR("Maximum frame size of %d bytes excceds maximum space available", maxFrameSize);
return false;
@@ -307,7 +242,7 @@ static bool captureRestart()
if (!stopThreads())
return false;
if (!app.iface->deinit() || !app.iface->init(app.pointerData, app.pointerDataSize))
if (!app.iface->deinit() || !app.iface->init())
{
DEBUG_ERROR("Failed to reinitialize the capture device");
return false;
@@ -319,6 +254,57 @@ static bool captureRestart()
return true;
}
bool captureGetPointerBuffer(void ** data, uint32_t * size)
{
if (lgmpHostQueuePending(app.pointerQueue) == LGMP_Q_POINTER_LEN)
return false;
PLGMPMemory mem = app.pointerMemory[app.pointerIndex];
*data = ((uint8_t*)lgmpHostMemPtr(mem)) + sizeof(KVMFRCursor);
*size = MAX_POINTER_SIZE - sizeof(KVMFRCursor);
return true;
}
void capturePostPointerBuffer(CapturePointer pointer)
{
if (lgmpHostQueuePending(app.pointerQueue) == LGMP_Q_POINTER_LEN)
return;
PLGMPMemory mem = app.pointerMemory[app.pointerIndex];
KVMFRCursor *cursor = lgmpHostMemPtr(mem);
cursor->x = pointer.x;
cursor->y = pointer.y;
cursor->visible = pointer.visible;
if (pointer.shapeUpdate)
{
cursor->width = pointer.width;
cursor->height = pointer.height;
cursor->pitch = pointer.pitch;
switch(pointer.format)
{
case CAPTURE_FMT_COLOR : cursor->type = CURSOR_TYPE_COLOR ; break;
case CAPTURE_FMT_MONO : cursor->type = CURSOR_TYPE_MONOCHROME ; break;
case CAPTURE_FMT_MASKED: cursor->type = CURSOR_TYPE_MASKED_COLOR; break;
default:
DEBUG_ERROR("Invalid pointer type");
return;
}
}
LGMP_STATUS status;
if ((status = lgmpHostPost(app.pointerQueue, pointer.shapeUpdate ? 1 : 0, mem)) != LGMP_OK)
{
DEBUG_ERROR("lgmpHostPost Failed (Pointer): %s", lgmpStatusString(status));
return;
}
if (app.pointerIndex++ == LGMP_Q_POINTER_LEN)
app.pointerIndex = 0;
}
// this is called from the platform specific startup routine
int app_main(int argc, char * argv[])
{
@@ -366,37 +352,60 @@ int app_main(int argc, char * argv[])
DEBUG_INFO("IVSHMEM Size : %u MiB", shmDev.size / 1048576);
DEBUG_INFO("IVSHMEM Address : 0x%" PRIXPTR, (uintptr_t)shmDev.mem);
app.shmHeader = (KVMFRHeader *)shmDev.mem;
app.pointerData = (uint8_t *)ALIGN_UP(shmDev.mem + sizeof(KVMFRHeader));
app.pointerDataSize = 1048576; // 1MB fixed for pointer size, should be more then enough
app.pointerOffset = app.pointerData - (uint8_t*)shmDev.mem;
app.frames = (uint8_t *)ALIGN_UP(app.pointerData + app.pointerDataSize);
app.frameSize = ALIGN_DN((shmDev.size - (app.frames - (uint8_t*)shmDev.mem)) / 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)
LGMP_STATUS status;
if ((status = lgmpHostInit(shmDev.mem, shmDev.size, &app.lgmp)) != LGMP_OK)
{
app.frame [i] = (FrameBuffer)(app.frames + i * app.frameSize);
app.frameOffset[i] = (uint8_t *)app.frame[i] - (uint8_t*)shmDev.mem;
DEBUG_INFO("Frame %d : 0x%" PRIXPTR " (0x%08x)", i, (uintptr_t)app.frame[i], app.frameOffset[i]);
DEBUG_ERROR("lgmpHostInit Failed: %s", lgmpStatusString(status));
goto fail;
}
if ((status = lgmpHostAddQueue(app.lgmp, LGMP_Q_POINTER, LGMP_Q_POINTER_LEN, &app.pointerQueue)) != LGMP_OK)
{
DEBUG_ERROR("lgmpHostQueueCreate Failed (Pointer): %s", lgmpStatusString(status));
goto fail;
}
for(int i = 0; i < LGMP_Q_POINTER_LEN; ++i)
{
if ((status = lgmpHostMemAlloc(app.lgmp, MAX_POINTER_SIZE, &app.pointerMemory[i])) != LGMP_OK)
{
DEBUG_ERROR("lgmpHostMemAlloc Failed (Pointer): %s", lgmpStatusString(status));
goto fail;
}
}
if ((status = lgmpHostAddQueue(app.lgmp, LGMP_Q_FRAME, LGMP_Q_FRAME_LEN, &app.frameQueue)) != LGMP_OK)
{
DEBUG_ERROR("lgmpHostQueueCreate Failed (Frame): %s", lgmpStatusString(status));
goto fail;
}
app.maxFrameSize = ALIGN_DN(lgmpHostMemAvail(app.lgmp) / LGMP_Q_FRAME_LEN);
for(int i = 0; i < LGMP_Q_FRAME_LEN; ++i)
{
if ((status = lgmpHostMemAlloc(app.lgmp, app.maxFrameSize, &app.frameMemory[i])) != LGMP_OK)
{
DEBUG_ERROR("lgmpHostMemAlloc Failed (Frame): %s", lgmpStatusString(status));
goto fail;
}
}
DEBUG_INFO("Max Pointer Size : %u KiB", (unsigned int)MAX_POINTER_SIZE);
DEBUG_INFO("Max Frame Size : %u MiB", (unsigned int)(app.maxFrameSize / 1048576LL));
CaptureInterface * iface = NULL;
for(int i = 0; CaptureInterfaces[i]; ++i)
{
iface = CaptureInterfaces[i];
DEBUG_INFO("Trying : %s", iface->getName());
if (!iface->create())
if (!iface->create(captureGetPointerBuffer, capturePostPointerBuffer))
{
iface = NULL;
continue;
}
if (iface->init(app.pointerData, app.pointerDataSize))
if (iface->init())
break;
iface->free();
@@ -412,31 +421,14 @@ int app_main(int argc, char * argv[])
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;
@@ -475,6 +467,13 @@ exit:
iface->deinit();
iface->free();
fail:
for(int i = 0; i < LGMP_Q_POINTER_LEN; ++i)
lgmpHostMemFree(&app.pointerMemory[i]);
for(int i = 0; i < LGMP_Q_FRAME_LEN; ++i)
lgmpHostMemFree(&app.frameMemory[i]);
lgmpHostFree(&app.lgmp);
ivshmemClose(&shmDev);
return exitcode;
}