[WIP] Implement cursor plane rendering for VirtIO GPU

shengwen-tw · shengwen-tw · commit 18d5ff751118 · 2025-01-28T03:11:34.000+08:00
diff --git a/virtio-gpu.c b/virtio-gpu.c
@@ -49,6 +49,7 @@ struct vgpu_resource_2d {
     uint32_t stride;
     uint32_t bits_per_pixel;
     uint32_t *image;
+    bool scanout_attached;
     /* Private: */
     uint32_t resource_id;
     size_t page_cnt;
@@ -169,6 +170,22 @@ PACKED(struct virtio_gpu_ctx_create {
     char debug_name[64];
 });
 
+PACKED(struct virtio_gpu_cursor_pos {
+    uint32_t scanout_id;
+    uint32_t x;
+    uint32_t y;
+    uint32_t padding;
+});
+
+PACKED(struct virtio_gpu_update_cursor {
+    struct vgpu_ctrl_hdr hdr;
+    struct virtio_gpu_cursor_pos pos;
+    uint32_t resource_id;
+    uint32_t hot_x;
+    uint32_t hot_y;
+    uint32_t padding;
+});
+
 /* clang-format off */
 PACKED(struct virtio_gpu_ctx_destroy {
     struct vgpu_ctrl_hdr hdr;
@@ -244,6 +261,7 @@ static struct vgpu_resource_2d *create_vgpu_resource_2d(int resource_id)
         return NULL;
 
     res->resource_id = resource_id;
+    res->scanout_attached = false;
     list_add(&res->list, &vgpu_res_2d_list);
     return res;
 }
@@ -267,15 +285,18 @@ static int destroy_vgpu_resource_2d(uint32_t resource_id)
     if (!res_2d)
         return -1;
 
-    window_lock(resource_id);
+    int scanout_id = res_2d->scanout_id;
+    if (res_2d->scanout_attached)
+        window_lock(scanout_id);
 
     /* Release the resource */
     free(res_2d->image);
     list_del(&res_2d->list);
     free(res_2d->iovec);
     free(res_2d);
 
-    window_unlock(resource_id);
+    if (res_2d->scanout_attached)
+        window_unlock(scanout_id);
 
     return 0;
 }
@@ -617,9 +638,11 @@ static void virtio_gpu_cmd_set_scanout_handler(virtio_gpu_state_t *vgpu,
 
     /* Linux's virtio-gpu driver may send scanout command
      * even if the resource does not exist */
-    if (res_2d)
+    if (res_2d) {
         /* Set scanout ID to proper 2D resource */
         res_2d->scanout_id = request->scanout_id;
+        res_2d->scanout_attached = true;
+    }
 
     /* Write response */
     struct vgpu_ctrl_hdr *response =
@@ -645,7 +668,9 @@ static void virtio_gpu_cmd_resource_flush_handler(virtio_gpu_state_t *vgpu,
         acquire_vgpu_resource_2d(request->resource_id);
 
     /* Trigger display window rendering */
+    window_lock(res_2d->scanout_id);
     window_render((struct gpu_resource *) res_2d);
+    window_unlock(res_2d->scanout_id);
 
     /* Write response */
     struct vgpu_ctrl_hdr *response =
@@ -801,6 +826,19 @@ static void virtio_gpu_cmd_update_cursor_handler(virtio_gpu_state_t *vgpu,
                                                  struct virtq_desc *vq_desc,
                                                  uint32_t *plen)
 {
+    /* Read request */
+    struct virtio_gpu_update_cursor *cursor =
+        vgpu_mem_host_to_guest(vgpu, vq_desc[0].addr);
+
+    /* Update cursor image */
+    struct vgpu_resource_2d *res_2d =
+        acquire_vgpu_resource_2d(cursor->resource_id);
+
+    window_lock(cursor->pos.scanout_id);
+    cursor_update((struct gpu_resource *) res_2d, cursor->pos.scanout_id,
+                  cursor->pos.x, cursor->pos.y);
+    window_unlock(cursor->pos.scanout_id);
+
     /* Write response */
     struct vgpu_ctrl_hdr *response =
         vgpu_mem_host_to_guest(vgpu, vq_desc[1].addr);
@@ -816,6 +854,15 @@ static void virtio_gpu_cmd_move_cursor_handler(virtio_gpu_state_t *vgpu,
                                                struct virtq_desc *vq_desc,
                                                uint32_t *plen)
 {
+    /* Read request */
+    struct virtio_gpu_update_cursor *cursor =
+        vgpu_mem_host_to_guest(vgpu, vq_desc[0].addr);
+
+    /* Move cursor to new position */
+    window_lock(cursor->pos.scanout_id);
+    cursor_move(cursor->pos.scanout_id, cursor->pos.x, cursor->pos.y);
+    window_unlock(cursor->pos.scanout_id);
+
     /* Write response */
     struct vgpu_ctrl_hdr *response =
         vgpu_mem_host_to_guest(vgpu, vq_desc[1].addr);
diff --git a/window.c b/window.c
@@ -128,6 +128,10 @@ struct key_map_entry key_map[] = {
 
 struct display_info {
     struct gpu_resource resource;
+    struct gpu_resource cursor;
+    int cursor_x, cursor_y;
+    uint32_t cursor_sdl_format;
+    int render_type;
     uint32_t sdl_format;
     SDL_mutex *img_mtx;
     SDL_cond *img_cond;
@@ -203,6 +207,7 @@ static int window_thread(void *data)
 {
     struct display_info *display = (struct display_info *) data;
     struct gpu_resource *resource = &display->resource;
+    struct gpu_resource *cursor = &display->cursor;
 
     /* Create SDL window */
     display->window = SDL_CreateWindow("semu", SDL_WINDOWPOS_UNDEFINED,
@@ -232,6 +237,8 @@ static int window_thread(void *data)
     ((struct display_info *) data)->ev_thread =
         SDL_CreateThread(event_thread, NULL, data);
 
+    SDL_Texture *cursor_texture = NULL;
+
     while (1) {
         SDL_LockMutex(display->img_mtx);
 
@@ -240,15 +247,40 @@ static int window_thread(void *data)
                                    SDL_COND_TIMEOUT))
             ;
 
-        /* Render image */
-        display->surface = SDL_CreateRGBSurfaceWithFormatFrom(
-            resource->image, resource->width, resource->height,
-            resource->bits_per_pixel, resource->stride, display->sdl_format);
-        display->texture =
-            SDL_CreateTextureFromSurface(display->renderer, display->surface);
-        SDL_RenderCopy(display->renderer, display->texture, NULL, NULL);
-        SDL_RenderPresent(display->renderer);
-        SDL_DestroyTexture(display->texture);
+        if (display->render_type == RENDER_PRIMARY_PLANE) {
+            /* Render main plane */
+            display->surface = SDL_CreateRGBSurfaceWithFormatFrom(
+                resource->image, resource->width, resource->height,
+                resource->bits_per_pixel, resource->stride,
+                display->sdl_format);
+            display->texture = SDL_CreateTextureFromSurface(display->renderer,
+                                                            display->surface);
+            SDL_RenderCopy(display->renderer, display->texture, NULL, NULL);
+            SDL_RenderPresent(display->renderer);
+            SDL_DestroyTexture(display->texture);
+            SDL_FreeSurface(display->surface);
+        } else if (display->render_type == RENDER_CURSOR_PLANE) {
+            SDL_Rect cursor_rect = {
+                .x = display->cursor_x,
+                .y = display->cursor_y,
+                .w = cursor->width,
+                .h = cursor->height,
+            };
+
+            display->surface = SDL_CreateRGBSurfaceWithFormatFrom(
+                cursor->image, cursor->width, cursor->height,
+                cursor->bits_per_pixel, cursor->stride,
+                display->cursor_sdl_format);
+
+            cursor_texture = SDL_CreateTextureFromSurface(display->renderer,
+                                                          display->surface);
+            SDL_SetTextureBlendMode(display->texture, SDL_BLENDMODE_BLEND);
+            SDL_RenderCopy(display->renderer, cursor_texture, NULL,
+                           &cursor_rect);
+            SDL_RenderPresent(display->renderer);
+            SDL_DestroyTexture(cursor_texture);
+            SDL_FreeSurface(display->surface);
+        }
 
         SDL_UnlockMutex(display->img_mtx);
     }
@@ -314,6 +346,39 @@ static bool virtio_gpu_to_sdl_format(uint32_t virtio_gpu_format,
     }
 }
 
+void cursor_update(struct gpu_resource *resource, int scanout_id, int x, int y)
+{
+    displays[scanout_id].render_type = RENDER_CURSOR_PLANE;
+    displays[scanout_id].cursor_x = x;
+    displays[scanout_id].cursor_y = y;
+
+    /* Resource update */
+    memcpy(&displays[scanout_id].cursor, resource, sizeof(struct gpu_resource));
+
+    /* TODO: Cursor image copy (which involves stride calculation, ARGB
+     * ordering, etc.) Without saving the cursor image properlly, the cursor can
+     * not be rendered correctly on the screen. The user should currently only
+     * expect to see a black square moving on the screen) */
+
+    bool legal_format = virtio_gpu_to_sdl_format(
+        resource->format, &displays[scanout_id].cursor_sdl_format);
+
+    if (legal_format) {
+        SDL_CondSignal(displays[scanout_id].img_cond);
+    } else {
+        exit(2);
+    }
+}
+
+void cursor_move(int scanout_id, int x, int y)
+{
+    displays[scanout_id].render_type = RENDER_CURSOR_PLANE;
+    displays[scanout_id].cursor_x = x;
+    displays[scanout_id].cursor_y = y;
+
+    SDL_CondSignal(displays[scanout_id].img_cond);
+}
+
 void window_render(struct gpu_resource *resource)
 {
     int id = resource->scanout_id;
diff --git a/window.h b/window.h
@@ -1,5 +1,10 @@
 #pragma once
 
+enum {
+    RENDER_PRIMARY_PLANE,
+    RENDER_CURSOR_PLANE,
+};
+
 #if SEMU_HAS(VIRTIOGPU)
 /* Public interface to the vgpu_resource_2d structure */
 struct gpu_resource {
@@ -15,6 +20,8 @@ struct gpu_resource {
 void window_init(void);
 void window_add(uint32_t width, uint32_t height);
 void window_render(struct gpu_resource *resource);
+void cursor_update(struct gpu_resource *resource, int scanout_id, int x, int y);
+void cursor_move(int scanout_id, int x, int y);
 void window_lock(uint32_t id);
 void window_unlock(uint32_t id);
 #endif
