[WIP] Implement cursor plane rendering for VirtIO GPU

shengwen-tw · shengwen-tw · commit ba1e3c26aca5 · 2025-01-29T19:57:20.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;
 }
@@ -629,9 +650,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 =
@@ -657,7 +680,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 =
@@ -819,6 +844,27 @@ 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);
+
+    if (res_2d != NULL) {
+        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);
+    } else if (cursor->resource_id == 0) {
+        window_lock(cursor->pos.scanout_id);
+        cursor_clear(cursor->pos.scanout_id);
+        window_unlock(cursor->pos.scanout_id);
+    } else {
+        fprintf(stderr, "Invalid resource ID %d.\n", cursor->resource_id);
+    }
+
     /* Write response */
     struct vgpu_ctrl_hdr *response =
         vgpu_mem_host_to_guest(vgpu, vq_desc[1].addr);
@@ -834,6 +880,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
@@ -127,16 +127,27 @@ struct key_map_entry key_map[] = {
 };
 
 struct display_info {
+    /* Request type: primary or cursor */
+    int render_type;
+
+    /* Primary plane */
     struct gpu_resource resource;
-    uint32_t sdl_format;
+    uint32_t primary_sdl_format;
+    SDL_Texture *primary_texture;
+
+    /* Cursor plane */
+    struct gpu_resource cursor;
+    uint32_t cursor_sdl_format;
+    uint32_t *cursor_img;
+    SDL_Rect cursor_rect; /* Cursor size and position */
+    SDL_Texture *cursor_texture;
+
     SDL_mutex *img_mtx;
     SDL_cond *img_cond;
     SDL_Thread *win_thread;
     SDL_Thread *ev_thread;
     SDL_Window *window;
     SDL_Renderer *renderer;
-    SDL_Surface *surface;
-    SDL_Texture *texture;
 };
 
 static struct display_info displays[VIRTIO_GPU_MAX_SCANOUTS];
@@ -203,6 +214,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,
@@ -223,6 +235,9 @@ static int window_thread(void *data)
         exit(2);
     }
 
+    /* FIXME */
+    SDL_SetRenderDrawBlendMode(display->renderer, SDL_BLENDMODE_BLEND);
+
     /* Render the whole screen with black color */
     SDL_SetRenderDrawColor(display->renderer, 0, 0, 0, 255);
     SDL_RenderClear(display->renderer);
@@ -232,24 +247,58 @@ static int window_thread(void *data)
     ((struct display_info *) data)->ev_thread =
         SDL_CreateThread(event_thread, NULL, data);
 
+    SDL_Surface *surface;
+
     while (1) {
+        /* Mutex lock */
         SDL_LockMutex(display->img_mtx);
 
         /* Wait until the image is arrived */
         while (SDL_CondWaitTimeout(display->img_cond, display->img_mtx,
                                    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);
+        if (display->render_type == RENDER_PRIMARY_PLANE) {
+            /* Generate primary plane texture */
+            surface = SDL_CreateRGBSurfaceWithFormatFrom(
+                resource->image, resource->width, resource->height,
+                resource->bits_per_pixel, resource->stride,
+                display->primary_sdl_format);
+
+            SDL_DestroyTexture(display->primary_texture);
+            display->primary_texture =
+                SDL_CreateTextureFromSurface(display->renderer, surface);
+            SDL_FreeSurface(surface);
+        } else if (display->render_type == UPDATE_CURSOR_IMAGE) {
+            /* Generate cursor plane texture */
+            surface = SDL_CreateRGBSurfaceWithFormatFrom(
+                cursor->image, cursor->width, cursor->height,
+                cursor->bits_per_pixel, cursor->stride,
+                /*display->cursor_sdl_format*/
+                SDL_PIXELFORMAT_RGBA32 /* FIXME */);
+
+            SDL_DestroyTexture(display->cursor_texture);
+            display->cursor_texture =
+                SDL_CreateTextureFromSurface(display->renderer, surface);
+            SDL_FreeSurface(surface);
+        } else if (CLEAR_CURSOR) {
+            SDL_DestroyTexture(display->cursor_texture);
+        }
+
+        /* Render primary and cursor planes */
+        SDL_RenderClear(display->renderer);
+
+        if (display->primary_texture)
+            SDL_RenderCopy(display->renderer, display->primary_texture, NULL,
+                           NULL);
+
+        if (display->cursor_texture)
+            SDL_RenderCopy(display->renderer, display->cursor_texture, NULL,
+                           &display->cursor_rect);
+
         SDL_RenderPresent(display->renderer);
-        SDL_DestroyTexture(display->texture);
 
+        /* Mutex unlock */
         SDL_UnlockMutex(display->img_mtx);
     }
 }
@@ -314,15 +363,87 @@ static bool virtio_gpu_to_sdl_format(uint32_t virtio_gpu_format,
     }
 }
 
+void cursor_clear(int scanout_id)
+{
+    /* Reset cursor information */
+    struct display_info *display = &displays[scanout_id];
+    memset(&display->cursor_rect, 0, sizeof(SDL_Rect));
+    display->cursor_sdl_format = 0;
+
+    /* Reset cursor resource */
+    memset(&display->cursor, 0, sizeof(struct gpu_resource));
+    free(display->cursor_img);
+    display->cursor_img = NULL;
+    display->cursor.image = NULL;
+
+    /* Trigger plane rendering */
+    display->render_type = UPDATE_CURSOR_IMAGE;
+    SDL_CondSignal(display->img_cond);
+}
+
+void cursor_update(struct gpu_resource *resource, int scanout_id, int x, int y)
+{
+    /* Convert virtio-gpu resource format to SDL format */
+    uint32_t sdl_format;
+    bool legal_format = virtio_gpu_to_sdl_format(resource->format, &sdl_format);
+
+    if (!legal_format) {
+        fprintf(stderr, "Invalid resource format.\n");
+        return;
+    }
+
+    /* Update cursor information */
+    struct display_info *display = &displays[scanout_id];
+    display->cursor_rect.x = x;
+    display->cursor_rect.y = y;
+    display->cursor_rect.w = resource->width;
+    display->cursor_rect.h = resource->height;
+    display->cursor_sdl_format = sdl_format;
+
+    /* Cursor resource update */
+    memcpy(&display->cursor, resource, sizeof(struct gpu_resource));
+    size_t pixels_size = sizeof(uint32_t) * resource->width * resource->height;
+    free(display->cursor_img); /* FIXME */
+    display->cursor_img = malloc(pixels_size);
+    display->cursor.image = display->cursor_img;
+    memcpy(display->cursor_img, resource->image, pixels_size);
+
+    /* Trigger cursor rendering */
+    display->render_type = CLEAR_CURSOR;
+    SDL_CondSignal(display->img_cond);
+}
+
+void cursor_move(int scanout_id, int x, int y)
+{
+    /* Update cursor position */
+    struct display_info *display = &displays[scanout_id];
+    display->cursor_rect.x = x;
+    display->cursor_rect.y = y;
+
+    /* Trigger cursor rendering */
+    display->render_type = MOVE_CURSOR;
+    SDL_CondSignal(display->img_cond);
+}
+
 void window_render(struct gpu_resource *resource)
 {
     int id = resource->scanout_id;
+    struct display_info *display = &displays[id];
+
+    /* Convert virtio-gpu resource format to SDL format */
+    uint32_t sdl_format;
+    bool legal_format = virtio_gpu_to_sdl_format(resource->format, &sdl_format);
+
+    if (!legal_format) {
+        fprintf(stderr, "Invalid resource format.\n");
+        return;
+    }
 
-    /* Resource update */
-    memcpy(&displays[id].resource, resource, sizeof(struct gpu_resource));
-    bool legal_format =
-        virtio_gpu_to_sdl_format(resource->format, &displays[id].sdl_format);
+    /* Update primary plane resource */
+    display->primary_sdl_format = sdl_format;
+    memcpy(&display->resource, resource, sizeof(struct gpu_resource));
 
-    if (legal_format)
-        SDL_CondSignal(displays[id].img_cond);
+    /* Trigger primary plane rendering */
+    displays[id].render_type = RENDER_PRIMARY_PLANE;
+    SDL_CondSignal(display->img_cond);
 }
diff --git a/window.h b/window.h
@@ -1,5 +1,12 @@
 #pragma once
 
+enum {
+    RENDER_PRIMARY_PLANE,
+    UPDATE_CURSOR_IMAGE,
+    MOVE_CURSOR,
+    CLEAR_CURSOR,
+};
+
 #if SEMU_HAS(VIRTIOGPU)
 /* Public interface to the vgpu_resource_2d structure */
 struct gpu_resource {
@@ -15,6 +22,9 @@ 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_clear(int scanout_id);
+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
