kmsvnc/input.c

230 lines
6.7 KiB
C
Raw Permalink Normal View History

2023-04-27 19:35:18 +08:00
#include <stdio.h>
#include <fcntl.h>
#include <linux/uinput.h>
#include <math.h>
#include <stdlib.h>
#include "input.h"
#include "keymap.h"
extern struct kmsvnc_data *kmsvnc;
void uinput_cleanup()
{
if (kmsvnc->input) {
if (kmsvnc->input->uinput_fd > 0){
INP_IOCTL_MAY(kmsvnc->input->uinput_fd, UI_DEV_DESTROY);
close(kmsvnc->input->uinput_fd);
kmsvnc->input->uinput_fd = 0;
}
if (kmsvnc->input->keystate){
free(kmsvnc->input->keystate);
kmsvnc->input->keystate = NULL;
}
free(kmsvnc->input);
kmsvnc->input = NULL;
}
}
static void wake_system_up();
2023-04-27 19:35:18 +08:00
int uinput_init()
{
struct kmsvnc_input_data *inp = malloc(sizeof(struct kmsvnc_input_data));
2023-04-29 02:05:13 +08:00
if (!inp) KMSVNC_FATAL("memory allocation error at %s:%d\n", __FILE__, __LINE__);
2023-04-27 19:35:18 +08:00
memset(inp, 0, sizeof(struct kmsvnc_input_data));
kmsvnc->input = inp;
inp->uinput_fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
if (inp->uinput_fd <= 0)
{
2023-04-29 02:05:13 +08:00
KMSVNC_FATAL("Failed to open uinput\n");
2023-04-27 19:35:18 +08:00
}
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_EVBIT, EV_KEY);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_EVBIT, EV_SYN);
for (int i = 0; i < UINPUT_MAX_KEY; i++)
{
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_KEYBIT, i);
}
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_EVBIT, EV_ABS);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_ABSBIT, ABS_X);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_ABSBIT, ABS_Y);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_EVBIT, EV_REL);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_RELBIT, REL_X);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_RELBIT, REL_Y);
2023-04-27 19:35:18 +08:00
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_KEYBIT, BTN_LEFT);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_KEYBIT, BTN_MIDDLE);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_KEYBIT, BTN_RIGHT);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_EVBIT, EV_REL);
INP_IOCTL_MUST(inp->uinput_fd, UI_SET_RELBIT, REL_WHEEL);
struct uinput_abs_setup abs;
memset(&abs, 0, sizeof(abs));
abs.absinfo.maximum = UINPUT_ABS_MAX;
abs.absinfo.minimum = 0;
abs.code = ABS_X;
INP_IOCTL_MUST(inp->uinput_fd, UI_ABS_SETUP, &abs);
abs.code = ABS_Y;
INP_IOCTL_MUST(inp->uinput_fd, UI_ABS_SETUP, &abs);
struct uinput_setup usetup;
memset(&usetup, 0, sizeof(usetup));
usetup.id.bustype = BUS_USB;
usetup.id.vendor = 0x0011;
usetup.id.product = 0x4514;
strcpy(usetup.name, "kmsvnc");
INP_IOCTL_MUST(inp->uinput_fd, UI_DEV_SETUP, &usetup);
INP_IOCTL_MUST(inp->uinput_fd, UI_DEV_CREATE);
inp->keystate = malloc(UINPUT_MAX_KEY);
2023-04-29 02:05:13 +08:00
if (!inp->keystate) KMSVNC_FATAL("memory allocation error at %s:%d\n", __FILE__, __LINE__);
2023-04-27 19:35:18 +08:00
memset(inp->keystate, 0, UINPUT_MAX_KEY);
if (kmsvnc->input_wakeup) {
printf("waiting for 1 second for userspace to detect the input devive...\n");
sleep(1);
wake_system_up();
printf("waiting for 1 second for mouse input to be processed...\n");
sleep(1);
}
2023-04-27 19:35:18 +08:00
return 0;
}
void rfb_key_hook(rfbBool down, rfbKeySym keysym, rfbClientPtr cl)
{
struct key_iter_search search = {
.keysym = keysym,
.keycode = XKB_KEYCODE_INVALID,
.level = 0,
};
xkb_keymap_key_for_each(kmsvnc->keymap->map, key_iter, &search);
if (search.keycode == XKB_KEYCODE_INVALID)
{
fprintf(stderr, "Keysym %04x not found in our keymap\n", keysym);
return;
}
// printf("key %s, keysym %04x, keycode %u\n", down ? "down" : "up", keysym, search.keycode);
if (search.keycode >= UINPUT_MAX_KEY)
{
fprintf(stderr, "Keycode %d >= %d\n", search.keycode, UINPUT_MAX_KEY);
return;
}
if (down != kmsvnc->input->keystate[search.keycode])
{
struct input_event ies[] = {
{
.type = EV_KEY,
.code = search.keycode - 8, // magic
.value = down,
.time.tv_sec = 0,
.time.tv_usec = 0,
},
{
.type = EV_SYN,
.code = SYN_REPORT,
.value = 0,
},
};
2023-04-29 02:05:13 +08:00
for (int i = 0; i < KMSVNC_ARRAY_ELEMENTS(ies); i++)
2023-04-27 19:35:18 +08:00
{
2023-05-07 00:57:26 +08:00
KMSVNC_WRITE_MAY(kmsvnc->input->uinput_fd, &ies[i], sizeof(ies[0]));
2023-04-27 19:35:18 +08:00
}
kmsvnc->input->keystate[search.keycode] = down;
}
}
void rfb_ptr_hook(int mask, int screen_x, int screen_y, rfbClientPtr cl)
{
// printf("pointer to %d, %d\n", screen_x, screen_y);
2023-07-15 10:38:48 +08:00
float global_x = (float)(screen_x + kmsvnc->input_offx);
float global_y = (float)(screen_y + kmsvnc->input_offy);
int touch_x = round(global_x / (kmsvnc->input_width ?: kmsvnc->drm->mfb->width) * UINPUT_ABS_MAX);
int touch_y = round(global_y / (kmsvnc->input_height ?: kmsvnc->drm->mfb->height) * UINPUT_ABS_MAX);
2023-04-27 19:35:18 +08:00
struct input_event ies1[] = {
{
.type = EV_ABS,
.code = ABS_X,
.value = touch_x,
},
{
.type = EV_ABS,
.code = ABS_Y,
.value = touch_y,
},
{
.type = EV_KEY,
.code = BTN_LEFT,
.value = !!(mask & 0b1)},
{
.type = EV_KEY,
.code = BTN_MIDDLE,
.value = !!(mask & 0b10)},
{
.type = EV_KEY,
.code = BTN_RIGHT,
.value = !!(mask & 0b100)},
{
.type = EV_SYN,
.code = SYN_REPORT,
.value = 0,
},
};
2023-04-29 02:05:13 +08:00
for (int i = 0; i < KMSVNC_ARRAY_ELEMENTS(ies1); i++)
2023-04-27 19:35:18 +08:00
{
2023-05-07 00:57:26 +08:00
KMSVNC_WRITE_MAY(kmsvnc->input->uinput_fd, &ies1[i], sizeof(ies1[0]));
2023-04-27 19:35:18 +08:00
}
if (mask & 0b11000)
{
struct input_event ies2[] = {
{
.type = EV_REL,
.code = REL_WHEEL,
.value = mask & 0b1000 ? 1 : -1,
},
{
.type = EV_SYN,
.code = SYN_REPORT,
.value = 0,
},
};
2023-04-29 02:05:13 +08:00
for (int i = 0; i < KMSVNC_ARRAY_ELEMENTS(ies2); i++)
2023-04-27 19:35:18 +08:00
{
2023-05-07 00:57:26 +08:00
KMSVNC_WRITE_MAY(kmsvnc->input->uinput_fd, &ies2[i], sizeof(ies2[0]));
2023-04-27 19:35:18 +08:00
}
}
}
static void wake_system_up()
{
struct input_event ies1[] = {
{
.type = EV_REL,
.code = REL_X,
.value = 1,
},
{
.type = EV_SYN,
.code = SYN_REPORT,
.value = 0,
},
{
.type = EV_REL,
.code = REL_X,
.value = -1,
},
{
.type = EV_SYN,
.code = SYN_REPORT,
.value = 0,
},
};
for (int i = 0; i < KMSVNC_ARRAY_ELEMENTS(ies1); i++)
{
2023-05-07 00:57:26 +08:00
KMSVNC_WRITE_MAY(kmsvnc->input->uinput_fd, &ies1[i], sizeof(ies1[0]));
}
}