src/video/kmsdrm/SDL_kmsdrmmouse.c - third_party/sdl - Git at Google

 /*
   Simple DirectMedia Layer
   Copyright (C) 1997-2021 Sam Lantinga <slouken@libsdl.org>
   Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>

   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
   arising from the use of this software.

   Permission is granted to anyone to use this software for any purpose,
   including commercial applications, and to alter it and redistribute it
   freely, subject to the following restrictions:

   1. The origin of this software must not be misrepresented; you must not
      claim that you wrote the original software. If you use this software
      in a product, an acknowledgment in the product documentation would be
      appreciated but is not required.
   2. Altered source versions must be plainly marked as such, and must not be
      misrepresented as being the original software.
   3. This notice may not be removed or altered from any source distribution.
 */

 #include "../../SDL_internal.h"

 #if SDL_VIDEO_DRIVER_KMSDRM

 #include "SDL_kmsdrmvideo.h"
 #include "SDL_kmsdrmmouse.h"
 #include "SDL_kmsdrmdyn.h"
 #include "SDL_assert.h"

 #include "../../events/SDL_mouse_c.h"
 #include "../../events/default_cursor.h"

 static SDL_Cursor *KMSDRM_CreateDefaultCursor(void);
 static SDL_Cursor *KMSDRM_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y);
 static int KMSDRM_ShowCursor(SDL_Cursor * cursor);
 static void KMSDRM_MoveCursor(SDL_Cursor * cursor);
 static void KMSDRM_FreeCursor(SDL_Cursor * cursor);
 static void KMSDRM_WarpMouse(SDL_Window * window, int x, int y);
 static int KMSDRM_WarpMouseGlobal(int x, int y);

 /**********************************/
 /* Atomic helper functions block. */
 /**********************************/

 int
 drm_atomic_movecursor(KMSDRM_CursorData *curdata, uint16_t x, uint16_t y)
 {
     SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);

     if (!dispdata->cursor_plane) /* We can't move a non-existing cursor, but that's ok. */
         return 0;

     /* Do we have a set of changes already in the making? If not, allocate a new one. */
     if (!dispdata->atomic_req)
         dispdata->atomic_req = KMSDRM_drmModeAtomicAlloc();

     add_plane_property(dispdata->atomic_req,
             dispdata->cursor_plane, "CRTC_X", x - curdata->hot_x);
     add_plane_property(dispdata->atomic_req,
             dispdata->cursor_plane, "CRTC_Y", y - curdata->hot_y);

     return 0;
 }

 /***************************************/
 /* Atomic helper functions block ends. */
 /***************************************/

 /* Converts a pixel from straight-alpha [AA, RR, GG, BB], which the SDL cursor surface has,
    to premultiplied-alpha [AA. AA*RR, AA*GG, AA*BB].
    These multiplications have to be done with floats instead of uint32_t's,
    and the resulting values have to be converted to be relative to the 0-255 interval,
    where 255 is 1.00 and anything between 0 and 255 is 0.xx. */
 void alpha_premultiply_ARGB8888 (uint32_t *pixel) {

     uint32_t A, R, G, B;

     /* Component bytes extraction. */
     A = (*pixel >> (3 << 3)) & 0xFF;
     R = (*pixel >> (2 << 3)) & 0xFF;
     G = (*pixel >> (1 << 3)) & 0xFF;
     B = (*pixel >> (0 << 3)) & 0xFF;

     /* Alpha pre-multiplication of each component. */
     R = (float)A * ((float)R /255);
     G = (float)A * ((float)G /255);
     B = (float)A * ((float)B /255);

     /* ARGB8888 pixel recomposition. */
     (*pixel) = (((uint32_t)A << 24) | ((uint32_t)R << 16) | ((uint32_t)G << 8)) | ((uint32_t)B << 0);
 }

 static SDL_Cursor *
 KMSDRM_CreateDefaultCursor(void)
 {
     return SDL_CreateCursor(default_cdata, default_cmask, DEFAULT_CWIDTH, DEFAULT_CHEIGHT, DEFAULT_CHOTX, DEFAULT_CHOTY);
 }

 /* This simply gets the cursor soft-buffer ready. We don't copy it to a GBO BO until ShowCursor()
    because the cusor GBM BO (living in dispata) is destroyed and recreated when we recreate windows, etc. */
 static SDL_Cursor *
 KMSDRM_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
 {
     KMSDRM_CursorData *curdata;
     SDL_Cursor *cursor, *ret;

     curdata = NULL;
     ret = NULL;

     /* All code below assumes ARGB8888 format for the cursor surface,
        like other backends do. Also, the GBM BO pixels have to be
        alpha-premultiplied, but the SDL surface we receive has
        straight-alpha pixels, so we always have to convert. */
     SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888);
     SDL_assert(surface->pitch == surface->w * 4);

     cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
     if (!cursor) {
         SDL_OutOfMemory();
         goto cleanup;
     }
     curdata = (KMSDRM_CursorData *) SDL_calloc(1, sizeof(*curdata));
     if (!curdata) {
         SDL_OutOfMemory();
         goto cleanup;
     }

     /* hox_x and hot_y are the coordinates of the "tip of the cursor" from it's base. */
     curdata->hot_x = hot_x;
     curdata->hot_y = hot_y;
     curdata->w = surface->w;
     curdata->h = surface->h;
     curdata->buffer = NULL;

     /* Configure the cursor buffer info.
        This buffer has the original size of the cursor surface we are given. */
     curdata->buffer_pitch = surface->pitch;
     curdata->buffer_size = surface->pitch * surface->h;
     curdata->buffer = (uint32_t*)SDL_malloc(curdata->buffer_size);

     if (!curdata->buffer) {
         SDL_OutOfMemory();
         goto cleanup;
     }

     if (SDL_MUSTLOCK(surface)) {
         if (SDL_LockSurface(surface) < 0) {
             /* Could not lock surface */
             goto cleanup;
         }
     }

     /* Copy the surface pixels to the cursor buffer, for future use in ShowCursor() */
     SDL_memcpy(curdata->buffer, surface->pixels, curdata->buffer_size);

     if (SDL_MUSTLOCK(surface)) {
         SDL_UnlockSurface(surface);
     }

     cursor->driverdata = curdata;

     ret = cursor;

 cleanup:
     if (ret == NULL) {
 	if (curdata) {
 	    if (curdata->buffer) {
 		SDL_free(curdata->buffer);
 	    }
 	    SDL_free(curdata);
 	}
 	if (cursor) {
 	    SDL_free(cursor);
 	}
     }

     return ret;
 }

 /* When we create a window, we have to test if we have to show the cursor,
    and explicily do so if necessary.
    This is because when we destroy a window, we take the cursor away from the
    cursor plane, and destroy the cusror GBM BO. So we have to re-show it,
    so to say. */
 void
 KMSDRM_InitCursor()
 {
     SDL_Mouse *mouse = NULL;
     mouse = SDL_GetMouse();

     if (!mouse) {
         return;
     }
     if  (!(mouse->cur_cursor)) {
         return;
     }

     if  (!(mouse->cursor_shown)) {
         return;
     }

     KMSDRM_ShowCursor(mouse->cur_cursor);
 }

 /* Show the specified cursor, or hide if cursor is NULL.
    cur_cursor is the current cursor, and cursor is the new cursor.
    A cursor is displayed on a display, so we have to add a pointer to dispdata
    to the driverdata
  */
 static int
 KMSDRM_ShowCursor(SDL_Cursor * cursor)
 {
     SDL_VideoDevice *video_device = SDL_GetVideoDevice();
     //SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
     SDL_Mouse *mouse;
     KMSDRM_CursorData *curdata;
     SDL_VideoDisplay *display = NULL;
     SDL_DisplayData *dispdata = NULL;
     KMSDRM_FBInfo *fb;
     KMSDRM_PlaneInfo info = {0};

     size_t bo_stride;
     size_t bufsize;
     uint32_t *ready_buffer = NULL;
     uint32_t pixel;

     int i,j;
     int ret;

     mouse = SDL_GetMouse();
     if (!mouse) {
         return SDL_SetError("No mouse.");
     }

     if (mouse->focus) {
         display = SDL_GetDisplayForWindow(mouse->focus);
         if (display) {
             dispdata = (SDL_DisplayData*) display->driverdata;
         }
     }

     /**********************************/
     /* if cursor == NULL, HIDE cursor */
     /**********************************/
     if (!cursor) {
         /* Hide CURRENT cursor, a cursor that is already on screen
            and SDL is stored in mouse->cur_cursor. */
         if (mouse->cur_cursor && mouse->cur_cursor->driverdata) {
             if (dispdata && dispdata->cursor_plane) {
                 info.plane = dispdata->cursor_plane;
                 /* The rest of the members are zeroed. */
                 drm_atomic_set_plane_props(&info);
                 if (drm_atomic_commit(display->device, SDL_TRUE, SDL_FALSE))
                     return SDL_SetError("Failed atomic commit in KMSDRM_ShowCursor.");
                 }
                 return 0;
             }
         return SDL_SetError("Couldn't find cursor to hide.");
     }

     /************************************************/
     /* If cursor != NULL, DO show cursor on display */
     /************************************************/
     if (!display) {
         return SDL_SetError("Could not get display for mouse.");
     }
     if (!dispdata) {
         return SDL_SetError("Could not get display driverdata.");
     }
     if (!dispdata->cursor_plane) {
         return SDL_SetError("Hardware cursor plane not initialized.");
     }

     curdata = (KMSDRM_CursorData *) cursor->driverdata;

     if (!curdata || !dispdata->cursor_bo) {
         return SDL_SetError("Cursor not initialized properly.");
     }

     /* Prepare a buffer we can dump to our GBM BO (different size, alpha premultiplication...) */
     bo_stride = KMSDRM_gbm_bo_get_stride(dispdata->cursor_bo);
     bufsize = bo_stride * curdata->h;

     ready_buffer = (uint32_t*)SDL_malloc(bufsize);
     if (!ready_buffer) {
         ret = SDL_OutOfMemory();
         goto cleanup;
     }

     /* Clean the whole buffer we are preparing. */
     SDL_memset(ready_buffer, 0x00, bo_stride * curdata->h);

     /* Copy from the cursor buffer to a buffer that we can dump to the GBM BO,
        pre-multiplying by alpha each pixel as we go. */
     for (i = 0; i < curdata->h; i++) {
         for (j = 0; j < curdata->w; j++) {
             pixel = ((uint32_t*)curdata->buffer)[i * curdata->w + j];
             alpha_premultiply_ARGB8888 (&pixel);
             SDL_memcpy(ready_buffer + (i * dispdata->cursor_w) + j, &pixel, 4);
         }
     }

     /* Dump the cursor buffer to our GBM BO. */
     if (KMSDRM_gbm_bo_write(dispdata->cursor_bo, ready_buffer, bufsize)) {
         ret = SDL_SetError("Could not write to GBM cursor BO");
         goto cleanup;
     }

     /* Get the fb_id for the GBM BO so we can show it on the cursor plane. */
     fb = KMSDRM_FBFromBO(video_device, dispdata->cursor_bo);

     /* Show the GBM BO buffer on the cursor plane. */
     info.plane = dispdata->cursor_plane;
     info.crtc_id = dispdata->crtc->crtc->crtc_id;
     info.fb_id = fb->fb_id;
     info.src_w = curdata->w;
     info.src_h = curdata->h;
     info.crtc_x = mouse->x - curdata->hot_x;
     info.crtc_y = mouse->y - curdata->hot_y;
     info.crtc_w = curdata->w;
     info.crtc_h = curdata->h;

     drm_atomic_set_plane_props(&info);

     if (drm_atomic_commit(display->device, SDL_TRUE, SDL_FALSE)) {
         ret = SDL_SetError("Failed atomic commit in KMSDRM_ShowCursor.");
         goto cleanup;
     }

     ret = 0;

 cleanup:

     if (ready_buffer) {
         SDL_free(ready_buffer);
     }
     return ret;
 }

 /* We have destroyed the cursor by now, in KMSDRM_DestroyCursor.
    This is only for freeing the SDL_cursor.*/
 static void
 KMSDRM_FreeCursor(SDL_Cursor * cursor)
 {
     KMSDRM_CursorData *curdata;

     /* Even if the cursor is not ours, free it. */
     if (cursor) {
         curdata = (KMSDRM_CursorData *) cursor->driverdata;
         /* Free cursor buffer */
         if (curdata->buffer) {
             SDL_free(curdata->buffer);
             curdata->buffer = NULL;
         }
         /* Free cursor itself */
         if (cursor->driverdata) {
             SDL_free(cursor->driverdata);
         }
         SDL_free(cursor);
     }
 }

 /* Warp the mouse to (x,y) */
 static void
 KMSDRM_WarpMouse(SDL_Window * window, int x, int y)
 {
     /* Only one global/fullscreen window is supported */
     KMSDRM_WarpMouseGlobal(x, y);
 }

 /* Warp the mouse to (x,y) */
 static int
 KMSDRM_WarpMouseGlobal(int x, int y)
 {
     KMSDRM_CursorData *curdata;
     SDL_Mouse *mouse = SDL_GetMouse();
     SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);

     if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
         /* Update internal mouse position. */
         SDL_SendMouseMotion(mouse->focus, mouse->mouseID, 0, x, y);

         /* And now update the cursor graphic position on screen. */
         curdata = (KMSDRM_CursorData *) mouse->cur_cursor->driverdata;
         if (dispdata->cursor_bo) {
             if (drm_atomic_movecursor(curdata, x, y)) {
                 return SDL_SetError("drm_atomic_movecursor() failed.");
             }
         } else {
             return SDL_SetError("Cursor not initialized properly.");
         }
     } else {
         return SDL_SetError("No mouse or current cursor.");
     }

     return 0;
 }

 void
 KMSDRM_InitMouse(_THIS)
 {
     /* FIXME: Using UDEV it should be possible to scan all mice
      * but there's no point in doing so as there's no multimice support...yet!
      */

     SDL_VideoDevice *dev = SDL_GetVideoDevice();
     SDL_VideoData *viddata = ((SDL_VideoData *)dev->driverdata);
     SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
     SDL_Mouse *mouse = SDL_GetMouse();

     mouse->CreateCursor = KMSDRM_CreateCursor;
     mouse->ShowCursor = KMSDRM_ShowCursor;
     mouse->MoveCursor = KMSDRM_MoveCursor;
     mouse->FreeCursor = KMSDRM_FreeCursor;
     mouse->WarpMouse = KMSDRM_WarpMouse;
     mouse->WarpMouseGlobal = KMSDRM_WarpMouseGlobal;

     /***************************************************************************/
     /* REMEMBER TO BE SURE OF UNDOING ALL THESE STEPS PROPERLY BEFORE CALLING  */
     /* gbm_device_destroy, OR YOU WON'T BE ABLE TO CREATE A NEW ONE (ERROR -13 */
     /* ON gbm_create_device).                                                  */
     /***************************************************************************/

     /* 1- Init cursor plane, if we haven't yet. */
     if (!dispdata->cursor_plane) {
         setup_plane(_this, &(dispdata->cursor_plane), DRM_PLANE_TYPE_CURSOR);
     }

     /* 2- Create the cursor GBM BO, if we haven't yet. */
     if (!dispdata->cursor_bo) {

         if (!KMSDRM_gbm_device_is_format_supported(viddata->gbm_dev, GBM_FORMAT_ARGB8888,
                                                GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE))
         {
             SDL_SetError("Unsupported pixel format for cursor");
             return;
         }

 	if (KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_CURSOR_WIDTH,  &dispdata->cursor_w) ||
 	    KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_CURSOR_HEIGHT, &dispdata->cursor_h))
 	{
 	    SDL_SetError("Could not get the recommended GBM cursor size");
 	    goto cleanup;
 	}

 	if (dispdata->cursor_w == 0 || dispdata->cursor_h == 0) {
 	    SDL_SetError("Could not get an usable GBM cursor size");
 	    goto cleanup;
 	}

 	dispdata->cursor_bo = KMSDRM_gbm_bo_create(viddata->gbm_dev,
 	    dispdata->cursor_w, dispdata->cursor_h,
 	    GBM_FORMAT_ARGB8888, GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);

 	if (!dispdata->cursor_bo) {
 	    SDL_SetError("Could not create GBM cursor BO");
 	    goto cleanup;
 	}
     }

     /* SDL expects to set the default cursor on screen when we init the mouse. */
     SDL_SetDefaultCursor(KMSDRM_CreateDefaultCursor());

     return;

 cleanup:
     if (dispdata->cursor_bo) {
 	KMSDRM_gbm_bo_destroy(dispdata->cursor_bo);
 	dispdata->cursor_bo = NULL;
     }
 }

 void
 KMSDRM_DeinitMouse(_THIS)
 {
     SDL_VideoDevice *video_device = SDL_GetVideoDevice();
     SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
     KMSDRM_PlaneInfo info = {0};

     /*******************************************/
     /* UNDO WHAT WE DID IN KMSDRM_InitMouse(). */
     /*******************************************/

     /* 1- Destroy the curso GBM BO. */
     if (video_device && dispdata->cursor_bo) {
 	/* Unsethe the cursor BO from the cursor plane.
 	   (The other members of the plane info are zeroed). */
 	info.plane = dispdata->cursor_plane;
 	drm_atomic_set_plane_props(&info);
 	/* Wait until the cursor is unset from the cursor plane
 	   before destroying it's BO. */
 	if (drm_atomic_commit(video_device, SDL_TRUE, SDL_FALSE)) {
 	    SDL_SetError("Failed atomic commit in KMSDRM_DenitMouse.");
 	}
 	/* ..and finally destroy the cursor DRM BO! */
 	KMSDRM_gbm_bo_destroy(dispdata->cursor_bo);
 	dispdata->cursor_bo = NULL;
     }

     /* 2- Free the cursor plane, on which the cursor was being shown. */
     if (dispdata->cursor_plane) {
         free_plane(&dispdata->cursor_plane);
     }

 }

 /* This is called when a mouse motion event occurs */
 static void
 KMSDRM_MoveCursor(SDL_Cursor * cursor)
 {
     SDL_Mouse *mouse = SDL_GetMouse();
     KMSDRM_CursorData *curdata;

     /* We must NOT call SDL_SendMouseMotion() here or we will enter recursivity!
        That's why we move the cursor graphic ONLY. */
     if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
         curdata = (KMSDRM_CursorData *) mouse->cur_cursor->driverdata;

         /* Some programs expect cursor movement even while they don't do SwapWindow() calls,
            and since we ride on the atomic_commit() in SwapWindow() for cursor movement,
            cursor won't move in these situations. We could do an atomic_commit() here
            for each cursor movement request, but it cripples the movement to 30FPS,
            so a future solution is needed. SDLPoP "QUIT?" menu is an example of this
            situation. */

         if (drm_atomic_movecursor(curdata, mouse->x, mouse->y)) {
             SDL_SetError("drm_atomic_movecursor() failed.");
         }
     }
 }

 #endif /* SDL_VIDEO_DRIVER_KMSDRM */

 /* vi: set ts=4 sw=4 expandtab: */
	/*
	Simple DirectMedia Layer
	Copyright (C) 1997-2021 Sam Lantinga <slouken@libsdl.org>
	Atomic KMSDRM backend by Manuel Alfayate Corchete <redwindwanderer@gmail.com>

	This software is provided 'as-is', without any express or implied
	warranty. In no event will the authors be held liable for any damages
	arising from the use of this software.

	Permission is granted to anyone to use this software for any purpose,
	including commercial applications, and to alter it and redistribute it
	freely, subject to the following restrictions:

	1. The origin of this software must not be misrepresented; you must not
	claim that you wrote the original software. If you use this software
	in a product, an acknowledgment in the product documentation would be
	appreciated but is not required.
	2. Altered source versions must be plainly marked as such, and must not be
	misrepresented as being the original software.
	3. This notice may not be removed or altered from any source distribution.
	*/

	#include "../../SDL_internal.h"

	#if SDL_VIDEO_DRIVER_KMSDRM

	#include "SDL_kmsdrmvideo.h"
	#include "SDL_kmsdrmmouse.h"
	#include "SDL_kmsdrmdyn.h"
	#include "SDL_assert.h"

	#include "../../events/SDL_mouse_c.h"
	#include "../../events/default_cursor.h"

	static SDL_Cursor *KMSDRM_CreateDefaultCursor(void);
	static SDL_Cursor KMSDRM_CreateCursor(SDL_Surface surface, int hot_x, int hot_y);
	static int KMSDRM_ShowCursor(SDL_Cursor * cursor);
	static void KMSDRM_MoveCursor(SDL_Cursor * cursor);
	static void KMSDRM_FreeCursor(SDL_Cursor * cursor);
	static void KMSDRM_WarpMouse(SDL_Window * window, int x, int y);
	static int KMSDRM_WarpMouseGlobal(int x, int y);

	/**********************************/
	/* Atomic helper functions block. */
	/**********************************/

	int
	drm_atomic_movecursor(KMSDRM_CursorData *curdata, uint16_t x, uint16_t y)
	{
	SDL_DisplayData dispdata = (SDL_DisplayData )SDL_GetDisplayDriverData(0);

	if (!dispdata->cursor_plane) /* We can't move a non-existing cursor, but that's ok. */
	return 0;

	/* Do we have a set of changes already in the making? If not, allocate a new one. */
	if (!dispdata->atomic_req)
	dispdata->atomic_req = KMSDRM_drmModeAtomicAlloc();

	add_plane_property(dispdata->atomic_req,
	dispdata->cursor_plane, "CRTC_X", x - curdata->hot_x);
	add_plane_property(dispdata->atomic_req,
	dispdata->cursor_plane, "CRTC_Y", y - curdata->hot_y);

	return 0;
	}

	/***************************************/
	/* Atomic helper functions block ends. */
	/***************************************/

	/* Converts a pixel from straight-alpha [AA, RR, GG, BB], which the SDL cursor surface has,
	to premultiplied-alpha [AA. AARR, AAGG, AA*BB].
	These multiplications have to be done with floats instead of uint32_t's,
	and the resulting values have to be converted to be relative to the 0-255 interval,
	where 255 is 1.00 and anything between 0 and 255 is 0.xx. */
	void alpha_premultiply_ARGB8888 (uint32_t *pixel) {

	uint32_t A, R, G, B;

	/* Component bytes extraction. */
	A = (*pixel >> (3 << 3)) & 0xFF;
	R = (*pixel >> (2 << 3)) & 0xFF;
	G = (*pixel >> (1 << 3)) & 0xFF;
	B = (*pixel >> (0 << 3)) & 0xFF;

	/* Alpha pre-multiplication of each component. */
	R = (float)A * ((float)R /255);
	G = (float)A * ((float)G /255);
	B = (float)A * ((float)B /255);

	/* ARGB8888 pixel recomposition. */
	(*pixel) = (((uint32_t)A << 24) \| ((uint32_t)R << 16) \| ((uint32_t)G << 8)) \| ((uint32_t)B << 0);
	}

	static SDL_Cursor *
	KMSDRM_CreateDefaultCursor(void)
	{
	return SDL_CreateCursor(default_cdata, default_cmask, DEFAULT_CWIDTH, DEFAULT_CHEIGHT, DEFAULT_CHOTX, DEFAULT_CHOTY);
	}

	/* This simply gets the cursor soft-buffer ready. We don't copy it to a GBO BO until ShowCursor()
	because the cusor GBM BO (living in dispata) is destroyed and recreated when we recreate windows, etc. */
	static SDL_Cursor *
	KMSDRM_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
	{
	KMSDRM_CursorData *curdata;
	SDL_Cursor cursor, ret;

	curdata = NULL;
	ret = NULL;

	/* All code below assumes ARGB8888 format for the cursor surface,
	like other backends do. Also, the GBM BO pixels have to be
	alpha-premultiplied, but the SDL surface we receive has
	straight-alpha pixels, so we always have to convert. */
	SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888);
	SDL_assert(surface->pitch == surface->w * 4);

	cursor = (SDL_Cursor ) SDL_calloc(1, sizeof(cursor));
	if (!cursor) {
	SDL_OutOfMemory();
	goto cleanup;
	}
	curdata = (KMSDRM_CursorData ) SDL_calloc(1, sizeof(curdata));
	if (!curdata) {
	SDL_OutOfMemory();
	goto cleanup;
	}

	/* hox_x and hot_y are the coordinates of the "tip of the cursor" from it's base. */
	curdata->hot_x = hot_x;
	curdata->hot_y = hot_y;
	curdata->w = surface->w;
	curdata->h = surface->h;
	curdata->buffer = NULL;

	/* Configure the cursor buffer info.
	This buffer has the original size of the cursor surface we are given. */
	curdata->buffer_pitch = surface->pitch;
	curdata->buffer_size = surface->pitch * surface->h;
	curdata->buffer = (uint32_t*)SDL_malloc(curdata->buffer_size);

	if (!curdata->buffer) {
	SDL_OutOfMemory();
	goto cleanup;
	}

	if (SDL_MUSTLOCK(surface)) {
	if (SDL_LockSurface(surface) < 0) {
	/* Could not lock surface */
	goto cleanup;
	}
	}

	/* Copy the surface pixels to the cursor buffer, for future use in ShowCursor() */
	SDL_memcpy(curdata->buffer, surface->pixels, curdata->buffer_size);

	if (SDL_MUSTLOCK(surface)) {
	SDL_UnlockSurface(surface);
	}

	cursor->driverdata = curdata;

	ret = cursor;

	cleanup:
	if (ret == NULL) {
	if (curdata) {
	if (curdata->buffer) {
	SDL_free(curdata->buffer);
	}
	SDL_free(curdata);
	}
	if (cursor) {
	SDL_free(cursor);
	}
	}

	return ret;
	}

	/* When we create a window, we have to test if we have to show the cursor,
	and explicily do so if necessary.
	This is because when we destroy a window, we take the cursor away from the
	cursor plane, and destroy the cusror GBM BO. So we have to re-show it,
	so to say. */
	void
	KMSDRM_InitCursor()
	{
	SDL_Mouse *mouse = NULL;
	mouse = SDL_GetMouse();

	if (!mouse) {
	return;
	}
	if (!(mouse->cur_cursor)) {
	return;
	}

	if (!(mouse->cursor_shown)) {
	return;
	}

	KMSDRM_ShowCursor(mouse->cur_cursor);
	}

	/* Show the specified cursor, or hide if cursor is NULL.
	cur_cursor is the current cursor, and cursor is the new cursor.
	A cursor is displayed on a display, so we have to add a pointer to dispdata
	to the driverdata
	*/
	static int
	KMSDRM_ShowCursor(SDL_Cursor * cursor)
	{
	SDL_VideoDevice *video_device = SDL_GetVideoDevice();
	//SDL_VideoData viddata = ((SDL_VideoData )dev->driverdata);
	SDL_Mouse *mouse;
	KMSDRM_CursorData *curdata;
	SDL_VideoDisplay *display = NULL;
	SDL_DisplayData *dispdata = NULL;
	KMSDRM_FBInfo *fb;
	KMSDRM_PlaneInfo info = {0};

	size_t bo_stride;
	size_t bufsize;
	uint32_t *ready_buffer = NULL;
	uint32_t pixel;

	int i,j;
	int ret;

	mouse = SDL_GetMouse();
	if (!mouse) {
	return SDL_SetError("No mouse.");
	}

	if (mouse->focus) {
	display = SDL_GetDisplayForWindow(mouse->focus);
	if (display) {
	dispdata = (SDL_DisplayData*) display->driverdata;
	}
	}

	/**********************************/
	/* if cursor == NULL, HIDE cursor */
	/**********************************/
	if (!cursor) {
	/* Hide CURRENT cursor, a cursor that is already on screen
	and SDL is stored in mouse->cur_cursor. */
	if (mouse->cur_cursor && mouse->cur_cursor->driverdata) {
	if (dispdata && dispdata->cursor_plane) {
	info.plane = dispdata->cursor_plane;
	/* The rest of the members are zeroed. */
	drm_atomic_set_plane_props(&info);
	if (drm_atomic_commit(display->device, SDL_TRUE, SDL_FALSE))
	return SDL_SetError("Failed atomic commit in KMSDRM_ShowCursor.");
	}
	return 0;
	}
	return SDL_SetError("Couldn't find cursor to hide.");
	}

	/************************************************/
	/* If cursor != NULL, DO show cursor on display */
	/************************************************/
	if (!display) {
	return SDL_SetError("Could not get display for mouse.");
	}
	if (!dispdata) {
	return SDL_SetError("Could not get display driverdata.");
	}
	if (!dispdata->cursor_plane) {
	return SDL_SetError("Hardware cursor plane not initialized.");
	}

	curdata = (KMSDRM_CursorData *) cursor->driverdata;

	if (!curdata \|\| !dispdata->cursor_bo) {
	return SDL_SetError("Cursor not initialized properly.");
	}

	/* Prepare a buffer we can dump to our GBM BO (different size, alpha premultiplication...) */
	bo_stride = KMSDRM_gbm_bo_get_stride(dispdata->cursor_bo);
	bufsize = bo_stride * curdata->h;

	ready_buffer = (uint32_t*)SDL_malloc(bufsize);
	if (!ready_buffer) {
	ret = SDL_OutOfMemory();
	goto cleanup;
	}

	/* Clean the whole buffer we are preparing. */
	SDL_memset(ready_buffer, 0x00, bo_stride * curdata->h);

	/* Copy from the cursor buffer to a buffer that we can dump to the GBM BO,
	pre-multiplying by alpha each pixel as we go. */
	for (i = 0; i < curdata->h; i++) {
	for (j = 0; j < curdata->w; j++) {
	pixel = ((uint32_t)curdata->buffer)[i curdata->w + j];
	alpha_premultiply_ARGB8888 (&pixel);
	SDL_memcpy(ready_buffer + (i * dispdata->cursor_w) + j, &pixel, 4);
	}
	}

	/* Dump the cursor buffer to our GBM BO. */
	if (KMSDRM_gbm_bo_write(dispdata->cursor_bo, ready_buffer, bufsize)) {
	ret = SDL_SetError("Could not write to GBM cursor BO");
	goto cleanup;
	}

	/* Get the fb_id for the GBM BO so we can show it on the cursor plane. */
	fb = KMSDRM_FBFromBO(video_device, dispdata->cursor_bo);

	/* Show the GBM BO buffer on the cursor plane. */
	info.plane = dispdata->cursor_plane;
	info.crtc_id = dispdata->crtc->crtc->crtc_id;
	info.fb_id = fb->fb_id;
	info.src_w = curdata->w;
	info.src_h = curdata->h;
	info.crtc_x = mouse->x - curdata->hot_x;
	info.crtc_y = mouse->y - curdata->hot_y;
	info.crtc_w = curdata->w;
	info.crtc_h = curdata->h;

	drm_atomic_set_plane_props(&info);

	if (drm_atomic_commit(display->device, SDL_TRUE, SDL_FALSE)) {
	ret = SDL_SetError("Failed atomic commit in KMSDRM_ShowCursor.");
	goto cleanup;
	}

	ret = 0;

	cleanup:

	if (ready_buffer) {
	SDL_free(ready_buffer);
	}
	return ret;
	}

	/* We have destroyed the cursor by now, in KMSDRM_DestroyCursor.
	This is only for freeing the SDL_cursor.*/
	static void
	KMSDRM_FreeCursor(SDL_Cursor * cursor)
	{
	KMSDRM_CursorData *curdata;

	/* Even if the cursor is not ours, free it. */
	if (cursor) {
	curdata = (KMSDRM_CursorData *) cursor->driverdata;
	/* Free cursor buffer */
	if (curdata->buffer) {
	SDL_free(curdata->buffer);
	curdata->buffer = NULL;
	}
	/* Free cursor itself */
	if (cursor->driverdata) {
	SDL_free(cursor->driverdata);
	}
	SDL_free(cursor);
	}
	}

	/* Warp the mouse to (x,y) */
	static void
	KMSDRM_WarpMouse(SDL_Window * window, int x, int y)
	{
	/* Only one global/fullscreen window is supported */
	KMSDRM_WarpMouseGlobal(x, y);
	}

	/* Warp the mouse to (x,y) */
	static int
	KMSDRM_WarpMouseGlobal(int x, int y)
	{
	KMSDRM_CursorData *curdata;
	SDL_Mouse *mouse = SDL_GetMouse();
	SDL_DisplayData dispdata = (SDL_DisplayData )SDL_GetDisplayDriverData(0);

	if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
	/* Update internal mouse position. */
	SDL_SendMouseMotion(mouse->focus, mouse->mouseID, 0, x, y);

	/* And now update the cursor graphic position on screen. */
	curdata = (KMSDRM_CursorData *) mouse->cur_cursor->driverdata;
	if (dispdata->cursor_bo) {
	if (drm_atomic_movecursor(curdata, x, y)) {
	return SDL_SetError("drm_atomic_movecursor() failed.");
	}
	} else {
	return SDL_SetError("Cursor not initialized properly.");
	}
	} else {
	return SDL_SetError("No mouse or current cursor.");
	}

	return 0;
	}

	void
	KMSDRM_InitMouse(_THIS)
	{
	/* FIXME: Using UDEV it should be possible to scan all mice
	* but there's no point in doing so as there's no multimice support...yet!
	*/

	SDL_VideoDevice *dev = SDL_GetVideoDevice();
	SDL_VideoData viddata = ((SDL_VideoData )dev->driverdata);
	SDL_DisplayData dispdata = (SDL_DisplayData )SDL_GetDisplayDriverData(0);
	SDL_Mouse *mouse = SDL_GetMouse();

	mouse->CreateCursor = KMSDRM_CreateCursor;
	mouse->ShowCursor = KMSDRM_ShowCursor;
	mouse->MoveCursor = KMSDRM_MoveCursor;
	mouse->FreeCursor = KMSDRM_FreeCursor;
	mouse->WarpMouse = KMSDRM_WarpMouse;
	mouse->WarpMouseGlobal = KMSDRM_WarpMouseGlobal;

	/***************************************************************************/
	/* REMEMBER TO BE SURE OF UNDOING ALL THESE STEPS PROPERLY BEFORE CALLING */
	/* gbm_device_destroy, OR YOU WON'T BE ABLE TO CREATE A NEW ONE (ERROR -13 */
	/* ON gbm_create_device). */
	/***************************************************************************/

	/* 1- Init cursor plane, if we haven't yet. */
	if (!dispdata->cursor_plane) {
	setup_plane(_this, &(dispdata->cursor_plane), DRM_PLANE_TYPE_CURSOR);
	}

	/* 2- Create the cursor GBM BO, if we haven't yet. */
	if (!dispdata->cursor_bo) {

	if (!KMSDRM_gbm_device_is_format_supported(viddata->gbm_dev, GBM_FORMAT_ARGB8888,
	GBM_BO_USE_CURSOR \| GBM_BO_USE_WRITE))
	{
	SDL_SetError("Unsupported pixel format for cursor");
	return;
	}

	if (KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_CURSOR_WIDTH, &dispdata->cursor_w) \|\|
	KMSDRM_drmGetCap(viddata->drm_fd, DRM_CAP_CURSOR_HEIGHT, &dispdata->cursor_h))
	{
	SDL_SetError("Could not get the recommended GBM cursor size");
	goto cleanup;
	}

	if (dispdata->cursor_w == 0 \|\| dispdata->cursor_h == 0) {
	SDL_SetError("Could not get an usable GBM cursor size");
	goto cleanup;
	}

	dispdata->cursor_bo = KMSDRM_gbm_bo_create(viddata->gbm_dev,
	dispdata->cursor_w, dispdata->cursor_h,
	GBM_FORMAT_ARGB8888, GBM_BO_USE_CURSOR \| GBM_BO_USE_WRITE);

	if (!dispdata->cursor_bo) {
	SDL_SetError("Could not create GBM cursor BO");
	goto cleanup;
	}
	}

	/* SDL expects to set the default cursor on screen when we init the mouse. */
	SDL_SetDefaultCursor(KMSDRM_CreateDefaultCursor());

	return;

	cleanup:
	if (dispdata->cursor_bo) {
	KMSDRM_gbm_bo_destroy(dispdata->cursor_bo);
	dispdata->cursor_bo = NULL;
	}
	}

	void
	KMSDRM_DeinitMouse(_THIS)
	{
	SDL_VideoDevice *video_device = SDL_GetVideoDevice();
	SDL_DisplayData dispdata = (SDL_DisplayData )SDL_GetDisplayDriverData(0);
	KMSDRM_PlaneInfo info = {0};

	/*******************************************/
	/* UNDO WHAT WE DID IN KMSDRM_InitMouse(). */
	/*******************************************/

	/* 1- Destroy the curso GBM BO. */
	if (video_device && dispdata->cursor_bo) {
	/* Unsethe the cursor BO from the cursor plane.
	(The other members of the plane info are zeroed). */
	info.plane = dispdata->cursor_plane;
	drm_atomic_set_plane_props(&info);
	/* Wait until the cursor is unset from the cursor plane
	before destroying it's BO. */
	if (drm_atomic_commit(video_device, SDL_TRUE, SDL_FALSE)) {
	SDL_SetError("Failed atomic commit in KMSDRM_DenitMouse.");
	}
	/* ..and finally destroy the cursor DRM BO! */
	KMSDRM_gbm_bo_destroy(dispdata->cursor_bo);
	dispdata->cursor_bo = NULL;
	}

	/* 2- Free the cursor plane, on which the cursor was being shown. */
	if (dispdata->cursor_plane) {
	free_plane(&dispdata->cursor_plane);
	}

	}

	/* This is called when a mouse motion event occurs */
	static void
	KMSDRM_MoveCursor(SDL_Cursor * cursor)
	{
	SDL_Mouse *mouse = SDL_GetMouse();
	KMSDRM_CursorData *curdata;

	/* We must NOT call SDL_SendMouseMotion() here or we will enter recursivity!
	That's why we move the cursor graphic ONLY. */
	if (mouse && mouse->cur_cursor && mouse->cur_cursor->driverdata) {
	curdata = (KMSDRM_CursorData *) mouse->cur_cursor->driverdata;

	/* Some programs expect cursor movement even while they don't do SwapWindow() calls,
	and since we ride on the atomic_commit() in SwapWindow() for cursor movement,
	cursor won't move in these situations. We could do an atomic_commit() here
	for each cursor movement request, but it cripples the movement to 30FPS,
	so a future solution is needed. SDLPoP "QUIT?" menu is an example of this
	situation. */

	if (drm_atomic_movecursor(curdata, mouse->x, mouse->y)) {
	SDL_SetError("drm_atomic_movecursor() failed.");
	}
	}
	}

	#endif /* SDL_VIDEO_DRIVER_KMSDRM */

	/* vi: set ts=4 sw=4 expandtab: */