Add input event specific system calls

This commit integrates a new system call, syscall_poll_event, with SDL's
event system, three types of input-specific events are supported:
keyboard event, mouse motion event and mouse button event, this input
system will improve the interactivity of the demos.

Author: alanjian85

docs/syscall.md

@@ -0,0 +1,19 @@
+# System Calls
+
+## Experimental Display and Event System Calls
+
+These system calls are experimental for demonstration of RISC-V graphics applications, they don't exist in the ABI interface of POSIX and Linux, and are only for the convenience of accessing the SDL library.
+
+### `syscall_draw_frame(screen, width, height)`
+Update the framebuffer of the given size, the window is lazy-initialized, if it does not exist when this system call is called, a new window will be created with the given width and height. This system call also poll events from SDL library, and update the internal input specific event queue if neccessary.
+
+### `syscall_draw_frame_pal(screen, pal, width, height)`
+Same as `syscall_draw_frame`, but with indexed-coloring, `pal` is a RGB look up table which contains 256 distinct colors, all pixels in the framebuffer will be automatically mapped before drawing on the screen.
+
+### `syscall_poll_event(event)`
+Poll a input-specific event from the event system, `event` should contains a 32-bit `type` field, and associated with a suitably sized value buffer, the internal event queue will be updated whenever `syscall_draw_frame` or `syscall_draw_frame_pal` is called.
+
+The following types of event are currently supported:
+* `KEY_EVENT`(`0x0`): Triggered when the status of keyboard is changed, either a key is pressed or released, returns a 32-bit keycode and a 8-bit key state, the hexadecimal keycode values are listed in [SDL Keycode Lookup Table](https://wiki.libsdl.org/SDLKeycodeLookup)
+* `MOUSE_MOTION_EVENT`(`0x1`): A mouse move event, with relative position information, two 32-bit signed integers which is correspond to the x and y delta value, the mouse is repeatedly wrapped in the window border by default.
+* `MOUSE_BUTTON_EVENT`(`0x2`): Whenever the state of a mouse button is changed, either a button is pressed or released, the user code will receive this event, it returns a 8-bit value indicates which button is updated(1 is left, 2 is middle, 3 is right and so on), and the 8-bit state value whether the button is pressed. 

syscall.c

@@ -301,6 +301,7 @@ static void syscall_open(struct riscv_t *rv)
 #ifdef ENABLE_SDL
 extern void syscall_draw_frame(struct riscv_t *rv);
 extern void syscall_draw_frame_pal(struct riscv_t *rv);
+extern void syscall_poll_event(struct riscv_t *rv);
 #endif
 
 void syscall_handler(struct riscv_t *rv)
@@ -343,6 +344,9 @@ void syscall_handler(struct riscv_t *rv)
     case 0xbabe:
         syscall_draw_frame_pal(rv);
         break;
+    case 0xc0de:
+        syscall_poll_event(rv);
+        break;
 #endif
     default:
         fprintf(stderr, "unknown syscall %d\n", (int) syscall);

syscall_sdl.c

@@ -9,9 +9,75 @@
 
 #include "state.h"
 
+/* For optimization, the capcity of event queues must be the power of two to
+ * avoid the expensive modulo operation, the details are explained here:
+ * https://stackoverflow.com/questions/10527581/why-must-a-ring-buffer-size-be-a-power-of-2
+ */
+#define EVENT_QUEUE_CAPACITY 128
+
+enum {
+    KEY_EVENT = 0,
+    MOUSE_MOTION_EVENT = 1,
+    MOUSE_BUTTON_EVENT = 2,
+};
+
+typedef struct {
+    uint32_t keycode;
+    uint8_t state;
+} key_event_t;
+
+typedef struct {
+    int32_t xrel, yrel;
+} mouse_motion_t;
+
+typedef struct {
+    uint8_t button;
+    uint8_t state;
+} mouse_button_t;
+
+typedef struct {
+    uint32_t type;
+    union {
+        key_event_t key_event;
+        mouse_motion_t mouse_motion;
+        mouse_button_t mouse_button;
+    };
+} event_t;
+
+typedef struct {
+    event_t events[EVENT_QUEUE_CAPACITY];
+    size_t start, end;
+    bool full;
+} event_queue_t;
+
 static SDL_Window *window = NULL;
 static SDL_Renderer *renderer;
 static SDL_Texture *texture;
+static event_queue_t event_queue = {
+    .events = {},
+    .start = 0,
+    .end = 0,
+    .full = false,
+};
+
+static bool event_pop(event_t *event)
+{
+    if (event_queue.start == event_queue.end)
+        return false;
+    *event = event_queue.events[event_queue.start++];
+    event_queue.start &= EVENT_QUEUE_CAPACITY - 1;
+    event_queue.full = false;
+    return true;
+}
+
+static void event_push(event_t event)
+{
+    if (event_queue.full)
+        return;
+    event_queue.events[event_queue.end++] = event;
+    event_queue.end &= EVENT_QUEUE_CAPACITY - 1;
+    event_queue.full = (event_queue.start == event_queue.end);
+}
 
 /* check if we need to setup SDL and run event loop */
 static bool check_sdl(struct riscv_t *rv, uint32_t width, uint32_t height)
@@ -43,10 +109,55 @@ static bool check_sdl(struct riscv_t *rv, uint32_t width, uint32_t height)
             rv_halt(rv);
             return false;
         case SDL_KEYDOWN:
-            if (event.key.keysym.sym == SDLK_ESCAPE) {
-                rv_halt(rv);
-                return false;
+            if (event.key.keysym.sym == SDLK_ESCAPE &&
+                SDL_GetRelativeMouseMode() == SDL_TRUE) {
+                SDL_SetRelativeMouseMode(SDL_FALSE);
+                break;
             }
+            /* fall through */
+        case SDL_KEYUP: {
+            if (event.key.repeat)
+                break;
+            event_t new_event = {
+                .type = KEY_EVENT,
+                .key_event =
+                    {
+                        .keycode = event.key.keysym.sym,
+                        .state = (bool) (event.key.state == SDL_PRESSED),
+                    },
+            };
+            event_push(new_event);
+            break;
+        }
+        case SDL_MOUSEMOTION: {
+            event_t new_event = {
+                .type = MOUSE_MOTION_EVENT,
+                .mouse_motion =
+                    {
+                        .xrel = event.motion.xrel,
+                        .yrel = event.motion.yrel,
+                    },
+            };
+            event_push(new_event);
+            break;
+        }
+        case SDL_MOUSEBUTTONDOWN:
+            if (event.button.button == SDL_BUTTON_LEFT &&
+                SDL_GetRelativeMouseMode() == SDL_FALSE) {
+                SDL_SetRelativeMouseMode(SDL_TRUE);
+                break;
+            }
+            /* fall through */
+        case SDL_MOUSEBUTTONUP: {
+            event_t new_event = {
+                .type = MOUSE_BUTTON_EVENT,
+                .mouse_button = {
+                    .button = event.button.button,
+                    .state = (bool) (event.button.state == SDL_PRESSED),
+                }};
+            event_push(new_event);
+            break;
+        }
         }
     }
     return true;
@@ -118,3 +229,35 @@ void syscall_draw_frame_pal(struct riscv_t *rv)
     free(i);
     free(j);
 }
+
+void syscall_poll_event(struct riscv_t *rv)
+{
+    state_t *s = rv_userdata(rv); /* access userdata */
+
+    /* poll_event(base) */
+    const uint32_t base = rv_get_reg(rv, rv_reg_a0);
+
+    event_t event;
+    if (!event_pop(&event)) {
+        rv_set_reg(rv, rv_reg_a0, 0);
+        return;
+    }
+
+    memory_write(s->mem, base + 0, (const uint8_t *) &event.type, 4);
+    switch (event.type) {
+    case KEY_EVENT:
+        memory_write(s->mem, base + 4, (const uint8_t *) &event.key_event,
+                     sizeof(key_event_t));
+        break;
+    case MOUSE_MOTION_EVENT:
+        memory_write(s->mem, base + 4, (const uint8_t *) &event.mouse_motion,
+                     sizeof(mouse_motion_t));
+        break;
+    case MOUSE_BUTTON_EVENT:
+        memory_write(s->mem, base + 4, (const uint8_t *) &event.mouse_button,
+                     sizeof(mouse_button_t));
+        break;
+    }
+
+    rv_set_reg(rv, rv_reg_a0, 1);
+}