Linux /dev/input/event*: lost mouse movement events - c

Question

I wrote a simple code that in theory should track the mouse position using global pixel coordinates based on display width/height.
The application creates a window (1x1 pixel at top left display corner) only for catching "ok" keyboard buttons press to stop it and to move mouse at (0, 0) when application starts. So "write" ok in order to close the application!
When I move the mouse from left to right (or top/bottom) I always obtain a different value when I reach the edge of the screen. My screen is set at 1920x1080 but never reach 1920 when I'm on the right edge. Maybe a normalization problem but this is not the point.
The problem is that if I move the mouse to the left edge of the screen when I'm at right edge I can't reach 0 and when I go right again I don't reach the same value as before.
It seems that some events are lost and the behaviour changes if I move the mouse with higher acceleration.
This is a working code, you only have to change the variable mouseID with your based on output from ls -lh /dev/input/by-id command.
#include <stdio.h>
#include <string.h>
#include "/usr/include/linux/input.h"
#include <poll.h>
#include <fcntl.h>
#include <unistd.h>
#include "SDL.h"
typedef struct connectedMouseInfoStruct
{
struct pollfd fileDescriptors[1];
char devInputStream[96];
unsigned char eventsBuffer[640000];
short type;
short code;
int value;
int currX;
int currY;
int prevX;
int prevY;
}connectedMouseInfo;
int main(int argc, char **argv)
{
char *mouseID = "usb-PixArt_Microsoft_USB_Optical_Mouse-event-mouse";
int exit = 0;
int firstKey = 0;
char *inputEvent = "/dev/input/by-id/";
connectedMouseInfo connectedMouse = {0};
int dx = 0;
int dy = 0;
SDL_Event events;
const Uint8 *keyboardState = NULL;
int bytesRead = 0;
int bufferPosition;
// Start
SDL_InitSubSystem(SDL_INIT_VIDEO);
SDL_DisplayMode currentVideoMode;
SDL_GetCurrentDisplayMode(0, &currentVideoMode);
SDL_Window* gameWindow = NULL;
gameWindow = SDL_CreateWindow(
"MouseEvents",
0,
0,
1,
1,
SDL_WINDOW_HIDDEN);
strcat(connectedMouse.devInputStream, inputEvent);
strcat(connectedMouse.devInputStream, mouseID);
connectedMouse.fileDescriptors[0].fd = open(connectedMouse.devInputStream, O_RDONLY | O_NONBLOCK);
connectedMouse.fileDescriptors[0].events = POLLIN;
SDL_WarpMouseGlobal(0, 0);
while (!exit)
{
while (SDL_PollEvent(&events))
{
keyboardState = SDL_GetKeyboardState(NULL);
if (events.type == SDL_KEYDOWN)
{
if (events.key.keysym.scancode == SDL_SCANCODE_O)
{
firstKey = 1;
}
}
if (firstKey && events.key.keysym.scancode == SDL_SCANCODE_K)
{
exit = 1;
}
}
poll(&connectedMouse.fileDescriptors[0], 1, 0);
if (connectedMouse.fileDescriptors[0].revents == POLLIN)
{
bytesRead = 0;
bytesRead = read(connectedMouse.fileDescriptors[0].fd, connectedMouse.eventsBuffer, 640000);
if (bytesRead == -1)
printf("Read error!!!\n");
else if ((bytesRead % sizeof(struct input_event)) != 0)
printf("Incomplete packet!!!\n");
else
{
printf("Read Bytes: %d\n", bytesRead);
for (bufferPosition = 0; bufferPosition < bytesRead; bufferPosition += sizeof(struct input_event))
{
memcpy(&connectedMouse.type, &connectedMouse.eventsBuffer[bufferPosition + sizeof(struct input_event) - 8], 2);
memcpy(&connectedMouse.code, &connectedMouse.eventsBuffer[bufferPosition + sizeof(struct input_event) - 6], 2);
memcpy(&connectedMouse.value, &connectedMouse.eventsBuffer[bufferPosition + sizeof(struct input_event) - 4], 4);
if (connectedMouse.type == EV_REL)
{
if (connectedMouse.code == REL_X)
{
connectedMouse.currX += connectedMouse.value;
}
else if (connectedMouse.code == REL_Y)
{
connectedMouse.currY += connectedMouse.value;
}
}
}
}
}
if (connectedMouse.currX > currentVideoMode.w - 1)
connectedMouse.currX = currentVideoMode.w - 1;
else if (connectedMouse.currX < 0)
connectedMouse.currX = 0;
if (connectedMouse.currY > currentVideoMode.h - 1)
connectedMouse.currY = currentVideoMode.h - 1;
else if (connectedMouse.currY < 0)
connectedMouse.currY = 0;
dx = connectedMouse.currX - connectedMouse.prevX;
dy = connectedMouse.currY - connectedMouse.prevY;
if (dx != 0 || dy != 0)
{
printf("Display X: %d\n", connectedMouse.currX);
printf("Display Y: %d\n", connectedMouse.currY);
printf("Delta X: %d\n", dx);
printf("Delta Y: %d\n", dy);
printf("\n");
}
connectedMouse.prevX = connectedMouse.currX;
connectedMouse.prevY = connectedMouse.currY;
}
return 0;
}

Answer 1

I don't think you are actually losing mouse events. The position of the cursor on the screen just doesn't match the position you keep track of because of mouse acceleration by the X server. If you turn that off, you will notice the mouse moves very slowly, and the values in your code will increase rapidly. So much so, that you will only cover a portion of the screen - but consistently. This is because the coordinate space is larger than your screen resolution.
Furthermore, you should not adjust the value on receiving an EV_SYN event. See the documentation.

Answer 2

I found a solution: if we set a flat profile for pointer acceleration the coordinates shown by the code exactly match the display width/height. I tried to move the pointer over a well defined pixel on my Desktop background and I always receive the same value.
So the problem was the mouse acceleration profile