examples/tdm-backend.c

   1 #include <assert.h>
   2 #include <stdbool.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <signal.h>
   6
   7 #include <wayland-server.h>
   8 #include <libds/log.h>
   9 #include <libds/backend.h>
  10 #include <libds/output.h>
  11 #include <libds/allocator/tbm.h>
  12 #include <libds/backend/tdm.h>
  13 #include <libds/swapchain.h>
  14 #include <libds/compositor.h>
  15
  16 #define WIDTH   1280
  17 #define HEIGHT  720
  18
  19 struct server
  20 {
  21     struct ds_backend *backend;
  22     struct ds_output *output;
  23     struct ds_allocator *allocator;
  24     struct ds_swapchain *swapchain;
  25     struct ds_buffer *front_buffer;
  26
  27     struct wl_display *display;
  28     struct wl_event_source *stdin_source;
  29
  30     struct wl_listener new_output;
  31     struct wl_listener output_destroy;
  32     struct wl_listener output_frame;
  33
  34     int width, height;
  35 };
  36
  37 struct server _server;
  38
  39 static void init_server(struct server *server, struct wl_display *display);
  40 static void fini_server(struct server *server);
  41 static void output_handle_destroy(struct wl_listener *listener, void *data);
  42 static void output_handle_frame(struct wl_listener *listener, void *data);
  43 static void draw_output(struct server *server);
  44 static int stdin_dispatch(int fd, uint32_t mask, void *data);
  45
  46 int
  47 main(void)
  48 {
  49     struct server *server = &_server;
  50     struct wl_display *display;
  51
  52     ds_log_init(DS_DBG, NULL);
  53
  54     display = wl_display_create();
  55     assert(display);
  56
  57     server->width = WIDTH;
  58     server->height = HEIGHT;
  59
  60     init_server(server, display);
  61
  62     ds_backend_start(server->backend);
  63
  64     draw_output(server);
  65
  66     struct wl_event_loop *loop = wl_display_get_event_loop(display);
  67     server->stdin_source = wl_event_loop_add_fd(loop, STDIN_FILENO,
  68             WL_EVENT_READABLE, stdin_dispatch, server);
  69
  70     wl_display_run(display);
  71
  72     fini_server(server);
  73     wl_display_destroy(display);
  74     return 0;
  75 }
  76
  77 static void
  78 backend_handle_new_output(struct wl_listener *listener, void *data)
  79 {
  80     struct server *server;
  81     struct ds_output *output;
  82
  83     server = wl_container_of(listener, server, new_output);
  84     output = data;
  85     ds_inf("New output(%p)", output);
  86
  87
  88     if (server->output)
  89         return;
  90
  91     server->output = output;
  92
  93     server->output_destroy.notify = output_handle_destroy;
  94     ds_output_add_destroy_listener(server->output,
  95             &server->output_destroy);
  96
  97     server->output_frame.notify = output_handle_frame;
  98     ds_output_add_frame_listener(server->output,
  99             &server->output_frame);
 100 }
 101
 102 static void
 103 init_server(struct server *server, struct wl_display *display)
 104 {
 105     server->display = display;
 106     server->front_buffer = NULL;
 107
 108     server->backend = ds_tdm_backend_create(display);
 109     assert(server->backend);
 110
 111
 112     server->new_output.notify = backend_handle_new_output;
 113     ds_backend_add_new_output_listener(server->backend,
 114             &server->new_output);
 115
 116     server->allocator = ds_tbm_allocator_create();
 117     assert(server->allocator);
 118
 119     server->swapchain = ds_swapchain_create(server->allocator,
 120             server->width, server->height, WL_SHM_FORMAT_XRGB8888);
 121     assert(server->swapchain);
 122 }
 123
 124 static void
 125 fini_server(struct server *server)
 126 {
 127     wl_list_remove(&server->new_output.link);
 128     wl_list_remove(&server->output_destroy.link);
 129     wl_list_remove(&server->output_frame.link);
 130     if (server->front_buffer)
 131         ds_buffer_unlock(server->front_buffer);
 132     ds_swapchain_destroy(server->swapchain);
 133     ds_allocator_destroy(server->allocator);
 134 }
 135
 136 static void
 137 output_handle_destroy(struct wl_listener *listener,
 138         void *data __attribute__((unused)))
 139 {
 140     struct server *server =
 141         wl_container_of(listener, server, output_destroy);
 142     wl_display_terminate(server->display);
 143 }
 144
 145 static void
 146 paint_pixels(void *image, int padding, int width, int height, uint32_t time)
 147 {
 148         const int halfh = padding + (height - padding * 2) / 2;
 149         const int halfw = padding + (width - padding * 2) / 2;
 150         int ir, or;
 151         uint32_t *pixel = image;
 152         int y;
 153
 154         /* squared radii thresholds */
 155         or = (halfw < halfh ? halfw : halfh) - 8;
 156         ir = or - 32;
 157         or *= or;
 158         ir *= ir;
 159
 160         pixel += padding * width;
 161         for (y = padding; y < height - padding; y++) {
 162                 int x;
 163                 int y2 = (y - halfh) * (y - halfh);
 164
 165                 pixel += padding;
 166                 for (x = padding; x < width - padding; x++) {
 167                         uint32_t v;
 168
 169                         /* squared distance from center */
 170                         int r2 = (x - halfw) * (x - halfw) + y2;
 171
 172                         if (r2 < ir)
 173                                 v = (r2 / 32 + time / 64) * 0x0080401;
 174                         else if (r2 < or)
 175                                 v = (y + time / 32) * 0x0080401;
 176                         else
 177                                 v = (x + time / 16) * 0x0080401;
 178                         v &= 0x00ffffff;
 179
 180                         /* cross if compositor uses X from XRGB as alpha */
 181                         if (abs(x - y) > 6 && abs(x + y - height) > 6)
 182                                 v |= 0xff000000;
 183
 184                         *pixel++ = v;
 185                 }
 186
 187                 pixel += padding;
 188         }
 189 }
 190
 191 static inline int64_t
 192 timespec_to_msec(const struct timespec *a)
 193 {
 194     return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000;
 195 }
 196
 197 static void
 198 output_handle_frame(struct wl_listener *listener,
 199         void *data __attribute__((unused)))
 200 {
 201     struct server *server =
 202         wl_container_of(listener, server, output_frame);
 203     draw_output(server);
 204 }
 205
 206 static void
 207 draw_output(struct server *server)
 208 {
 209     struct ds_buffer *buffer;
 210     void *data;
 211     uint32_t format;
 212     size_t stride;
 213     struct timespec now;
 214     uint32_t frame_time_msec;
 215
 216     ds_dbg("Redraw output");
 217
 218     clock_gettime(CLOCK_MONOTONIC, &now);
 219     frame_time_msec = timespec_to_msec(&now);
 220
 221     buffer = ds_swapchain_acquire(server->swapchain, NULL);
 222     assert(buffer);
 223
 224     assert(ds_buffer_begin_data_ptr_access(buffer,
 225                 0, &data, &format, &stride) == true);
 226
 227     paint_pixels(data, 20, server->width, server->height, frame_time_msec);
 228
 229     ds_buffer_end_data_ptr_access(buffer);
 230
 231     ds_output_attach_buffer(server->output, buffer);
 232     ds_output_commit(server->output);
 233
 234     if (server->front_buffer)
 235         ds_buffer_unlock(server->front_buffer);
 236
 237     server->front_buffer = buffer;
 238 }
 239
 240 static int
 241 stdin_dispatch(int fd, uint32_t mask, void *data)
 242 {
 243     struct server *server = data;
 244
 245     wl_display_terminate(server->display);
 246
 247     return 1;
 248 }