8 #include <drm_fourcc.h>
10 #include <wayland-server.h>
11 #include <libds/log.h>
12 #include <libds/backend.h>
13 #include <libds/output.h>
14 #include <libds/compositor.h>
15 #include <libds/xdg_shell.h>
16 #include <libds-tizen/allocator/tbm.h>
17 #include <libds-tizen/backend/tdm.h>
18 #include <libds/backend/libinput.h>
19 #include <libds-tizen/tbm_server.h>
20 #include <libds-tizen/dpms.h>
21 #include <libds/input_device.h>
22 #include <libds/keyboard.h>
23 #include <libds/touch.h>
24 #include <libds/pointer.h>
25 #include <libds/seat.h>
26 #include <libds-tizen/input_devicemgr.h>
27 #include <xkbcommon/xkbcommon.h>
28 #include <libds/interfaces/keyboard.h>
29 #include <libds-tizen/launch.h>
30 #include <libds-tizen/backend/tdm_output_hwc.h>
32 #define USE_TDM_BUFFER_QUEUE
34 #ifdef USE_TDM_BUFFER_QUEUE
35 #include "pixman-tbm-helper.h"
36 #include "tinyds-tdm-renderer.h"
38 #include <libds/swapchain.h>
41 #include "pixman-helper.h"
43 #define TINYDS_UNUSED __attribute__((unused))
44 struct tinyds_keyboard;
45 struct tinyds_pointer;
49 struct tinyds_server *server;
50 struct ds_output *ds_output;
51 struct ds_allocator *allocator;
52 #ifdef USE_TDM_BUFFER_QUEUE
53 struct tinyds_renderer renderer;
54 struct ds_tdm_buffer_queue *buffer_queue;
55 struct wl_listener buffer_queue_acquirable;
57 struct ds_swapchain *swapchain;
59 struct ds_buffer *front_buffer;
61 struct wl_listener output_destroy;
62 struct wl_listener output_frame;
66 struct wl_event_source *idle_commit;
71 struct ds_tdm_output_hwc *hwc;
72 struct ds_tdm_output_hwc_window *bg_hwc_window;
77 struct ds_tizen_dpms *ds_dpms;
78 struct tinyds_server *server;
80 struct wl_listener destroy;
81 struct wl_listener set_dpms;
82 struct wl_listener get_dpms;
87 struct ds_tbm_server *tbm_server;
89 struct wl_display *display;
91 struct ds_backend *backend;
92 struct ds_backend *input_backend;
93 struct ds_compositor *compositor;
94 struct ds_xdg_shell *xdg_shell;
97 double output_x, output_y;
98 struct ds_tizen_input_devicemgr *devicemgr;
99 struct ds_tizen_launch_effect *effect;
100 struct ds_tizen_launch_splash *splash;
102 struct tinyds_output *output;
103 struct tinyds_dpms *dpms;
104 struct wl_event_source *stdin_source;
106 struct wl_list views;
108 struct wl_listener new_output;
109 struct wl_listener new_input;
110 struct wl_listener new_xdg_surface;
111 struct wl_listener devicemgr_destroy;
112 struct wl_listener pointer_warp;
113 struct wl_listener effect_destroy;
114 struct wl_listener effect_type_set;
115 struct wl_listener effect_type_unset;
116 struct wl_listener new_splash;
117 struct wl_listener splash_owner;
119 struct wl_list keyboards;
120 struct wl_list pointers;
125 struct tinyds_server *server;
127 struct tinyds_texture *texture;
128 struct ds_xdg_surface *xdg_surface;
130 struct wl_listener xdg_surface_map;
131 struct wl_listener xdg_surface_unmap;
132 struct wl_listener xdg_surface_destroy;
133 struct wl_listener surface_commit;
134 struct wl_list link; // tinyds_server::views
136 struct ds_tdm_output_hwc_window *hwc_window;
145 struct tinyds_pointer
147 struct ds_input_device *dev;
148 struct tinyds_server *server;
150 struct tinyds_view *focused_view;
152 struct wl_listener destroy;
153 struct wl_listener motion; //relative
154 struct wl_listener button;
155 struct wl_listener frame;
156 struct wl_list link; //tinyds_server::pointers
159 struct tinyds_keyboard
161 struct ds_input_device *dev;
162 struct tinyds_server *server;
164 struct wl_listener destroy;
165 struct wl_listener key;
166 struct wl_list link; //tinyds_server::keyboards
171 struct ds_input_device *dev;
172 struct tinyds_server *server;
174 struct wl_listener destroy;
175 struct wl_listener down;
176 struct wl_listener up;
177 struct wl_listener motion;
180 struct tinyds_server tinyds;
182 static bool init_server(struct tinyds_server *server, struct wl_display *display);
183 static int server_dispatch_stdin(int fd, uint32_t mask, void *data);
184 static void output_handle_destroy(struct wl_listener *listener, void *data);
185 static void output_handle_frame(struct wl_listener *listener, void *data);
186 static void draw_server_with_damage(struct tinyds_server *server);
187 static void draw_output(struct tinyds_output *output);
188 static void output_swap_buffer(struct tinyds_output *output,
189 struct ds_buffer *buffer);
190 static void view_send_frame_done(struct tinyds_view *view);
191 static void output_hwc_init(struct tinyds_output *output);
192 static void output_schedule_commit(struct tinyds_output *output);
193 static void output_commit(struct tinyds_output *output);
194 #ifdef USE_TDM_BUFFER_QUEUE
195 static void output_buffer_queue_init(struct tinyds_output *output);
196 static void output_renderer_init(struct tinyds_output *output);
197 static void output_draw_with_renderer(struct tinyds_output *output);
199 static void output_swapchain_init(struct tinyds_output *output,
200 int width, int height, uint32_t format);
201 static void output_draw_with_swapchain(struct tinyds_output *output);
202 static void draw_view(struct tinyds_view *view, pixman_image_t *dst_image);
204 static void dpms_handle_destroy(struct wl_listener *listener, void *data);
205 static void dpms_handle_set_dpms(struct wl_listener *listener, void *data);
206 static void dpms_handle_get_dpms(struct wl_listener *listener, void *data);
207 static void server_add_keyboard(struct tinyds_server *server,
208 struct ds_input_device *dev);
209 static void server_add_pointer(struct tinyds_server *server,
210 struct ds_input_device *dev);
211 static void server_add_touch(struct tinyds_server *server,
212 struct ds_input_device *dev);
214 static struct tinyds_view *
215 server_view_at(struct tinyds_server *server, double lx, double ly,
216 double *sx, double *sy);
221 struct tinyds_server *server = &tinyds;
222 struct wl_display *display;
223 struct wl_event_loop *loop;
227 ds_log_init(DS_INF, NULL);
229 display = wl_display_create();
232 res = init_server(server, display);
235 socket = wl_display_add_socket_auto(display);
238 ds_backend_start(server->backend);
239 ds_backend_start(server->input_backend);
241 setenv("WAYLAND_DISPLAY", socket, true);
243 ds_inf("Running Wayland compositor on WAYLAND_DISPLAY=%s", socket);
245 loop = wl_display_get_event_loop(display);
246 server->stdin_source = wl_event_loop_add_fd(loop, STDIN_FILENO,
247 WL_EVENT_READABLE, server_dispatch_stdin, server);
249 wl_display_run(display);
251 wl_display_destroy_clients(display);
252 wl_display_destroy(display);
258 view_populate_pid(struct tinyds_view *view)
261 struct wl_client *client = NULL;
262 struct ds_surface *surface = ds_xdg_surface_get_surface(view->xdg_surface);
265 client = wl_resource_get_client(ds_surface_get_wl_resource(surface));
266 wl_client_get_credentials(client, &pid, NULL, NULL);
268 ds_inf("view pid(%u)", pid);
271 view->effect_type = ds_tizen_launch_effect_get_effect_type(view->server->effect, pid);
272 ds_tizen_launch_effect_unset_effect_type(view->server->effect, pid);
273 ds_inf("view effect_type(%d)", view->effect_type);
277 view_handle_xdg_surface_map(struct wl_listener *listener,
278 void *data TINYDS_UNUSED)
280 struct tinyds_view *view;
281 struct ds_keyboard *keyboard;
282 struct tinyds_keyboard *kbd;
284 view = wl_container_of(listener, view, xdg_surface_map);
287 view_populate_pid(view);
289 wl_list_for_each(kbd, &view->server->keyboards, link) {
290 keyboard = ds_input_device_get_keyboard(kbd->dev);
291 if (keyboard != NULL) {
292 ds_seat_keyboard_notify_enter(view->server->seat,
293 ds_xdg_surface_get_surface(view->xdg_surface),
294 keyboard->keycodes, keyboard->num_keycodes,
295 &keyboard->modifiers);
302 view_handle_xdg_surface_unmap(struct wl_listener *listener,
303 void *data TINYDS_UNUSED)
305 struct tinyds_view *view;
307 view = wl_container_of(listener, view, xdg_surface_unmap);
308 view->mapped = false;
312 view_handle_xdg_surface_destroy(struct wl_listener *listener,
313 void *data TINYDS_UNUSED)
315 struct tinyds_view *view;
317 view = wl_container_of(listener, view, xdg_surface_destroy);
319 draw_server_with_damage(view->server);
321 ds_tdm_output_hwc_window_destroy(view->hwc_window);
323 wl_list_remove(&view->xdg_surface_destroy.link);
324 wl_list_remove(&view->xdg_surface_map.link);
325 wl_list_remove(&view->xdg_surface_unmap.link);
326 wl_list_remove(&view->surface_commit.link);
327 wl_list_remove(&view->link);
332 view_handle_surface_commit(struct wl_listener *listener,
333 void *data TINYDS_UNUSED)
335 struct tinyds_view *view;
337 view = wl_container_of(listener, view, surface_commit);
338 draw_server_with_damage(view->server);
342 server_new_xdg_surface(struct wl_listener *listener, void *data)
344 struct tinyds_server *server;
345 struct tinyds_view *view;
346 struct ds_xdg_surface *xdg_surface;
348 server = wl_container_of(listener, server, new_xdg_surface);
351 ds_inf("New xdg_surface(%p)", (void *)xdg_surface);
353 view = calloc(1, sizeof *view);
356 view->server = server;
357 view->xdg_surface = xdg_surface;
359 view->xdg_surface_map.notify = view_handle_xdg_surface_map;
360 ds_xdg_surface_add_map_listener(xdg_surface,
361 &view->xdg_surface_map);
363 view->xdg_surface_unmap.notify = view_handle_xdg_surface_unmap;
364 ds_xdg_surface_add_unmap_listener(xdg_surface,
365 &view->xdg_surface_unmap);
367 view->xdg_surface_destroy.notify = view_handle_xdg_surface_destroy;
368 ds_xdg_surface_add_destroy_listener(xdg_surface,
369 &view->xdg_surface_destroy);
371 view->surface_commit.notify = view_handle_surface_commit;
372 ds_surface_add_commit_listener(
373 ds_xdg_surface_get_surface(xdg_surface),
374 &view->surface_commit);
376 view->x = rand() % 1000;
377 view->y = rand() % 500;
379 view->hwc_window = ds_tdm_output_hwc_window_create(server->output->hwc);
380 assert(view->hwc_window);
382 wl_list_insert(server->views.prev, &view->link);
385 view->effect_type = -1;
387 ds_inf("view at (%d, %d)", view->x, view->y);
391 backend_handle_new_output(struct wl_listener *listener, void *data)
393 struct tinyds_server *server;
394 struct tinyds_output *output;
395 struct ds_output *ds_output;
396 const struct ds_output_mode *mode;
397 struct ds_tdm_box src_box;
399 server = wl_container_of(listener, server, new_output);
402 ds_inf("New output(%p)", ds_output);
407 mode = ds_output_get_preferred_mode(ds_output);
408 ds_output_set_mode(ds_output, mode);
410 output = calloc(1, sizeof *output);
414 output->server = server;
415 output->ds_output = ds_output;
416 output->width = mode->width;
417 output->height = mode->height;
418 output->damaged = true;
419 output->committable = true;
421 output_hwc_init(output);
423 #ifdef USE_TDM_BUFFER_QUEUE
424 output_buffer_queue_init(output);
425 output_renderer_init(output);
427 output_swapchain_init(output, mode->width, mode->height,
428 DRM_FORMAT_XRGB8888);
431 output->bg_hwc_window = ds_tdm_output_hwc_window_create(output->hwc);
432 assert(output->bg_hwc_window);
436 src_box.width = output->width;
437 src_box.height = output->height;
439 ds_tdm_output_hwc_window_set_src_box(output->bg_hwc_window, &src_box);
440 ds_tdm_output_hwc_window_set_position(output->bg_hwc_window, 0, 0);
441 ds_tdm_output_hwc_window_set_dest_size(output->bg_hwc_window, output->width, output->height);
442 ds_tdm_output_hwc_window_set_transform(output->bg_hwc_window, WL_OUTPUT_TRANSFORM_NORMAL);
444 output->output_destroy.notify = output_handle_destroy;
445 ds_output_add_destroy_listener(ds_output, &output->output_destroy);
447 output->output_frame.notify = output_handle_frame;
448 ds_output_add_frame_listener(ds_output, &output->output_frame);
450 ds_tizen_input_devicemgr_set_output_width_height(server->devicemgr, (uint32_t)output->width, (uint32_t)output->height);
452 server->output = output;
454 output_schedule_commit(output);
458 add_new_dpms(struct tinyds_server *server)
460 struct tinyds_dpms *dpms;
462 dpms = calloc(1, sizeof *dpms);
466 dpms->ds_dpms = ds_tizen_dpms_create(server->display);
467 if (!dpms->ds_dpms) {
469 ds_err("Could not create ds_tizen_dpms");
473 dpms->destroy.notify = dpms_handle_destroy;
474 ds_tizen_dpms_add_destroy_listener(dpms->ds_dpms, &dpms->destroy);
476 dpms->set_dpms.notify = dpms_handle_set_dpms;
477 ds_tizen_dpms_add_set_dpms_listener(dpms->ds_dpms, &dpms->set_dpms);
479 dpms->get_dpms.notify = dpms_handle_get_dpms;
480 ds_tizen_dpms_add_get_dpms_listener(dpms->ds_dpms, &dpms->get_dpms);
484 ds_inf("Dpms (%p) added", dpms);
490 backend_handle_new_input(struct wl_listener *listener, void *data)
492 struct tinyds_server *server;
493 struct ds_input_device *dev = data;
494 enum ds_input_device_type dev_type;
496 server = wl_container_of(listener, server, new_input);
498 dev_type = ds_input_device_get_type(dev);
501 case DS_INPUT_DEVICE_KEYBOARD:
502 server_add_keyboard(server, dev);
503 server->seat_caps |= WL_SEAT_CAPABILITY_KEYBOARD;
505 case DS_INPUT_DEVICE_TOUCH:
506 server_add_touch(server, dev);
507 server->seat_caps |= WL_SEAT_CAPABILITY_TOUCH;
509 case DS_INPUT_DEVICE_POINTER:
510 server_add_pointer(server, dev);
511 server->seat_caps |= WL_SEAT_CAPABILITY_POINTER;
514 ds_err("Unknown type(%d) of ds_input_device", dev_type);
518 ds_seat_set_capabilities(server->seat, server->seat_caps);
522 devicemgr_add_keymap_data(struct wl_list *list, const char *name, int keycode)
524 struct ds_tizen_input_devicemgr_keymap_data *data;
526 data = calloc(1, sizeof *data);
528 ds_err("Failed to alloc memory");
532 data->name = strdup(name);
533 data->keycode = keycode;
535 wl_list_insert(list, &data->link);
539 devicemgr_cleanup_keymap_list(struct wl_list *list)
541 struct ds_tizen_input_devicemgr_keymap_data *data, *tmp;
543 wl_list_for_each_safe(data, tmp, list, link) {
544 wl_list_remove(&data->link);
551 devicemgr_set_keymap(struct ds_tizen_input_devicemgr *devicemgr)
553 struct wl_list keymap_list;
556 wl_list_init(&keymap_list);
558 devicemgr_add_keymap_data(&keymap_list, "XF86VolumeRaise", 455);
559 devicemgr_add_keymap_data(&keymap_list, "XF86VolumeLower", 456);
560 devicemgr_add_keymap_data(&keymap_list, "XF86LightOn", 457);
561 devicemgr_add_keymap_data(&keymap_list, "XF86LightOff", 458);
563 res = ds_tizen_input_devicemgr_set_keymap_list(devicemgr, &keymap_list);
565 ds_inf("Failed to set keymap");
567 devicemgr_cleanup_keymap_list(&keymap_list);
571 devicemgr_handle_pointer_warp(struct wl_listener *listener, void *data)
573 struct tinyds_server *server;
574 struct tinyds_pointer *pointer;
575 struct ds_tizen_input_devicemgr_event_pointer_warp *event = data;
576 double sx = 0.f, sy = 0.f;
577 struct tinyds_view *view = NULL;
579 server = wl_container_of(listener, server, pointer_warp);
581 ds_inf("Pointer warp: surface(%p) x(%.2f) y(%.2f)", event->surface,
584 wl_list_for_each(pointer, &server->pointers, link){
585 if (!pointer->focused_view) continue;
586 view = pointer->focused_view;
590 if (event->surface != ds_xdg_surface_get_surface(view->xdg_surface)) {
591 ds_inf("Pointer is not on the requested surface");
595 server->output_x = view->x + (event->x * server->output->width);
596 server->output_y = view->y + (event->y * server->output->height);
598 server_view_at(server, server->output_x, server->output_y, &sx, &sy);
600 ds_inf("notify motion: sx:%.2f sy:%.2f, output_x:%.1f, output_y:%.1f",
601 sx, sy, server->output_x, server->output_y);
603 ds_seat_pointer_notify_motion(server->seat,
604 event->time_msec, sx, sy);
608 devicemgr_handle_destroy(struct wl_listener *listener, void *data TINYDS_UNUSED)
610 struct tinyds_server *server =
611 wl_container_of(listener, server, devicemgr_destroy);
613 wl_list_remove(&server->devicemgr_destroy.link);
614 wl_list_remove(&server->pointer_warp.link);
616 server->devicemgr = NULL;
620 launch_effect_handle_destroy(struct wl_listener *listener, void *data TINYDS_UNUSED)
622 struct tinyds_server *server =
623 wl_container_of(listener, server, effect_destroy);
625 wl_list_remove(&server->effect_destroy.link);
626 wl_list_remove(&server->effect_type_set.link);
627 wl_list_remove(&server->effect_type_unset.link);
628 wl_list_remove(&server->new_splash.link);
630 server->effect = NULL;
634 launch_effect_handle_type_set(struct wl_listener *listener, void *data)
636 struct tinyds_server *server;
637 struct ds_tizen_launch_effect_event_type_set *event = data;
638 struct tinyds_view *view = NULL;
639 bool existing = false;
641 server = wl_container_of(listener, server, effect_type_set);
643 ds_inf("Launch effect. type_set: pid(%u) type:%s", event->pid, (event->effect_type == 1) ? "depth-in" : "launch");
645 wl_list_for_each(view, &server->views, link) {
646 if (view->pid == event->pid) {
647 view->effect_type = event->effect_type;
648 ds_inf("Launch effect. existing pid");
653 ds_tizen_launch_effect_unset_effect_type(server->effect, event->pid);
655 ds_tizen_launch_effect_set_effect_type(server->effect, event->pid, event->effect_type);
660 launch_effect_handle_type_unset(struct wl_listener *listener, void *data)
662 struct tinyds_server *server;
663 struct ds_tizen_launch_effect_event_type_unset *event = data;
664 struct tinyds_view *view = NULL;
666 server = wl_container_of(listener, server, effect_type_unset);
668 ds_inf("Launch effect. type_unset: pid(%u)", event->pid);
670 wl_list_for_each(view, &server->views, link) {
671 if (view->pid == event->pid) {
672 view->effect_type = -1;
673 ds_inf("Launch effect. pid found");
676 ds_tizen_launch_effect_unset_effect_type(server->effect, event->pid);
680 launch_splash_handle_owner(struct wl_listener *listener, void *data)
682 struct tinyds_server *server;
683 struct ds_tizen_launch_splash_event_owner *event = data;
684 struct tinyds_view *view = NULL;
686 server = wl_container_of(listener, server, splash_owner);
688 ds_inf("Splash owner. pid(%u)", event->pid);
690 wl_list_for_each(view, &server->views, link) {
691 if (view->pid == event->pid) {
692 if (event->pid == ds_tizen_launch_splash_get_pid(server->splash))
695 ds_tizen_launch_splash_set_pid(server->splash, event->pid);
702 launch_effect_handle_new_splash(struct wl_listener *listener, void *data)
704 struct tinyds_server *server;
705 struct ds_tizen_launch_splash *splash = data;
706 struct tinyds_view *view = NULL;
708 server = wl_container_of(listener, server, new_splash);
710 ds_inf("Launch new splash. splash(%p)", splash);
713 server->splash = splash;
715 // new view for "Launchscreen"
716 view = calloc(1, sizeof *view);
718 wl_list_insert(server->views.prev, &view->link);
719 view->pid = ds_tizen_launch_splash_get_pid(splash);
721 server->splash_owner.notify = launch_splash_handle_owner;
722 ds_tizen_launch_splash_add_owner_listener(server->splash,
723 &server->splash_owner);
727 init_server(struct tinyds_server *server, struct wl_display *display)
729 server->display = display;
731 wl_list_init(&server->views);
733 if (wl_display_init_shm(display) != 0)
736 server->backend = ds_tdm_backend_create(display);
737 if (!server->backend)
740 server->input_backend = ds_libinput_backend_create(display);
741 if (!server->input_backend) {
742 ds_backend_destroy(server->backend);
746 server->new_output.notify = backend_handle_new_output;
747 ds_backend_add_new_output_listener(server->backend,
748 &server->new_output);
750 wl_list_init(&server->keyboards);
751 wl_list_init(&server->pointers);
752 server->new_input.notify = backend_handle_new_input;
753 ds_backend_add_new_input_listener(server->input_backend, &server->new_input);
755 server->compositor = ds_compositor_create(display);
756 if (!server->compositor)
759 server->tbm_server = ds_tbm_server_create(display);
760 if (!server->tbm_server)
763 server->xdg_shell = ds_xdg_shell_create(display);
764 if (!server->xdg_shell)
767 server->new_xdg_surface.notify = server_new_xdg_surface;
768 ds_xdg_shell_add_new_surface_listener(server->xdg_shell,
769 &server->new_xdg_surface);
771 if (!add_new_dpms(server))
774 server->seat = ds_seat_create(display, "seat0" /* arbitrary name */);
777 server->seat_caps = 0;
779 server->devicemgr = ds_tizen_input_devicemgr_create(
780 server->input_backend, server->seat);
781 if (!server->devicemgr) {
782 ds_err("Could not create ds_tizen_input_devicemgr");
786 devicemgr_set_keymap(server->devicemgr);
788 server->devicemgr_destroy.notify = devicemgr_handle_destroy;
789 ds_tizen_input_devicemgr_add_destroy_listener(server->devicemgr,
790 &server->devicemgr_destroy);
792 server->pointer_warp.notify = devicemgr_handle_pointer_warp;
793 ds_tizen_input_devicemgr_add_pointer_warp_listener(server->devicemgr,
794 &server->pointer_warp);
796 server->effect = ds_tizen_launch_effect_create(display);
797 if (!server->effect) {
801 server->effect_destroy.notify = launch_effect_handle_destroy;
802 ds_tizen_launch_effect_add_destroy_listener(server->effect,
803 &server->effect_destroy);
805 server->effect_type_set.notify = launch_effect_handle_type_set;
806 ds_tizen_launch_effect_add_type_set_listener(server->effect,
807 &server->effect_type_set);
809 server->effect_type_unset.notify = launch_effect_handle_type_unset;
810 ds_tizen_launch_effect_add_type_unset_listener(server->effect,
811 &server->effect_type_unset);
813 server->new_splash.notify = launch_effect_handle_new_splash;
814 ds_tizen_launch_effect_add_new_splash_listener(server->effect,
815 &server->new_splash);
820 ds_backend_destroy(server->backend);
821 ds_backend_destroy(server->input_backend);
827 output_handle_destroy(struct wl_listener *listener, void *data TINYDS_UNUSED)
829 struct tinyds_output *output =
830 wl_container_of(listener, output, output_destroy);
832 if (output->bg_hwc_window)
833 ds_tdm_output_hwc_window_destroy(output->bg_hwc_window);
835 wl_list_remove(&output->output_destroy.link);
836 wl_list_remove(&output->output_frame.link);
838 if (output->front_buffer)
839 ds_buffer_unlock(output->front_buffer);
841 #ifdef USE_TDM_BUFFER_QUEUE
842 fini_renderer(&output->renderer);
844 if (output->swapchain)
845 ds_swapchain_destroy(output->swapchain);
847 if (output->allocator)
848 ds_allocator_destroy(output->allocator);
851 wl_display_terminate(output->server->display);
853 output->server->output = NULL;
859 output_commit(struct tinyds_output *output)
861 uint32_t num_changed = 0;
862 uint32_t num_windows = 0, current_num_windows = 0;
863 struct ds_tdm_output_hwc_window **composited_hwc_windows = NULL;
864 struct ds_tdm_output_hwc_window **changed_hwc_windows = NULL;
865 enum ds_tdm_output_hwc_window_composition composition;
866 struct tinyds_view *view;
868 bool need_target = false;
869 bool fully_obscured = false;
870 struct ds_buffer *ds_buffer;
871 struct ds_tdm_box src_box;
874 if (!output->committable)
877 if (!output->damaged && !output->target_updated)
880 wl_list_for_each_reverse(view, &output->server->views, link) {
881 if (!view->hwc_window)
884 ds_buffer = ds_surface_get_buffer(
885 ds_xdg_surface_get_surface(view->xdg_surface));
894 ds_buffer_get_size(ds_buffer, &w, &h);
896 if ((output->width <= w) && (output->height <= h))
897 fully_obscured = true;
900 if (fully_obscured) {
901 ds_tdm_output_hwc_window_set_composition(output->bg_hwc_window,
902 DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_NONE);
904 ds_tdm_output_hwc_window_set_composition(output->bg_hwc_window,
905 DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_CLIENT);
911 composited_hwc_windows = calloc(num_windows, sizeof *composited_hwc_windows);
912 if (!composited_hwc_windows)
915 wl_list_for_each_reverse(view, &output->server->views, link) {
916 if (!view->hwc_window)
919 ds_buffer = ds_surface_get_buffer(
920 ds_xdg_surface_get_surface(view->xdg_surface));
924 ds_tdm_output_hwc_window_set_buffer(view->hwc_window, ds_buffer);
926 ds_buffer_get_size(ds_buffer, &w, &h);
933 ds_tdm_output_hwc_window_set_src_box(view->hwc_window, &src_box);
934 ds_tdm_output_hwc_window_set_position(view->hwc_window, view->x, view->y);
935 ds_tdm_output_hwc_window_set_dest_size(view->hwc_window, w, h);
936 ds_tdm_output_hwc_window_set_transform(view->hwc_window, WL_OUTPUT_TRANSFORM_NORMAL);
939 ds_tdm_output_hwc_window_set_composition(view->hwc_window,
940 DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_DEVICE);
942 composited_hwc_windows[current_num_windows] = view->hwc_window;
943 current_num_windows++;
945 ds_tdm_output_hwc_window_set_composition(view->hwc_window,
946 DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_NONE);
950 if (!fully_obscured) {
951 composited_hwc_windows[current_num_windows] = output->bg_hwc_window;
952 current_num_windows++;
956 if (!ds_tdm_output_hwc_validate(output->hwc, composited_hwc_windows,
957 num_windows, &num_changed)) {
958 free(composited_hwc_windows);
959 ds_err("Could not hwc validate");
963 if (composited_hwc_windows)
964 free(composited_hwc_windows);
966 if (num_changed > 0) {
967 changed_hwc_windows = calloc(num_windows, sizeof *changed_hwc_windows);
968 if (!changed_hwc_windows)
971 if (!ds_tdm_output_hwc_get_changed_composition(output->hwc, &num_changed,
972 changed_hwc_windows)) {
973 free(changed_hwc_windows);
974 ds_err("Could not get chaged composition");
978 for (i = 0; i < num_changed; i++) {
979 composition = ds_tdm_output_hwc_window_get_composition(changed_hwc_windows[i]);
980 if (composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_CLIENT) {
987 if (changed_hwc_windows)
988 free(changed_hwc_windows);
990 if (need_target && output->damaged)
993 #ifdef USE_TDM_BUFFER_QUEUE
994 struct ds_buffer *buffer;
996 buffer = ds_tdm_buffer_queue_acquire(output->buffer_queue);
998 if (!ds_tdm_output_hwc_set_client_target_buffer(output->hwc, buffer)) {
999 ds_err("Could not set hwc client target buffer");
1003 output_swap_buffer(output, buffer);
1007 if (!ds_tdm_output_hwc_accept_validation(output->hwc)) {
1008 ds_err("Could not hwc accept validateion");
1012 ds_output_commit(output->ds_output);
1014 output->committable = false;
1015 output->damaged = false;
1016 output->target_updated = false;
1018 wl_list_for_each(view, &output->server->views, link) {
1019 enum ds_tdm_output_hwc_window_composition composition;
1024 composition = ds_tdm_output_hwc_window_get_composition(view->hwc_window);
1025 if ((composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_DEVICE) ||
1026 (composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_VIDEO) ||
1027 (composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_CURSOR))
1028 view_send_frame_done(view);
1031 ds_dbg("output:%p commit", output);
1035 output_handle_frame(struct wl_listener *listener, void *data TINYDS_UNUSED)
1037 struct tinyds_output *output =
1038 wl_container_of(listener, output, output_frame);
1040 ds_dbg("output:%p handle frame", output);
1042 output->committable = true;
1044 output_commit(output);
1048 draw_server_with_damage(struct tinyds_server *server)
1050 server->output->damaged = true;
1051 output_schedule_commit(server->output);
1055 output_hwc_init(struct tinyds_output *output)
1057 struct ds_tdm_output *tdm_output;
1059 tdm_output = ds_tdm_output_from_output(output->ds_output);
1062 output->hwc = ds_tdm_output_get_hwc(tdm_output);
1063 assert(output->hwc);
1065 ds_tdm_output_hwc_set_enabled(output->hwc, true);
1068 #ifdef USE_TDM_BUFFER_QUEUE
1070 output_handle_buffer_queue_acquirable(struct wl_listener *listener,
1071 void *data TINYDS_UNUSED)
1073 struct tinyds_output *output;
1075 output = wl_container_of(listener, output, buffer_queue_acquirable);
1077 output->target_updated = true;
1078 output_schedule_commit(output);
1082 output_buffer_queue_init(struct tinyds_output *output)
1084 struct ds_tdm_output *tdm_output;
1086 tdm_output = ds_tdm_output_from_output(output->ds_output);
1089 output->buffer_queue = ds_tdm_output_get_buffer_queue(tdm_output);
1090 assert(output->buffer_queue);
1092 output->buffer_queue_acquirable.notify =
1093 output_handle_buffer_queue_acquirable;
1094 ds_tdm_buffer_queue_add_acquirable_listener(output->buffer_queue,
1095 &output->buffer_queue_acquirable);
1099 output_renderer_init(struct tinyds_output *output)
1101 init_renderer(&output->renderer);
1103 renderer_set_surface_queue(&output->renderer,
1104 ds_tdm_buffer_queue_get_native_queue(output->buffer_queue));
1106 renderer_set_bg_color(&output->renderer, 80, 80, 80);
1110 output_draw_with_renderer(struct tinyds_output *output)
1112 struct tinyds_view *view;
1114 ds_dbg(">> BEGIN UPDATE TEXTURES");
1116 wl_list_for_each(view, &output->server->views, link) {
1117 struct ds_buffer *ds_buffer;
1118 struct ds_tbm_client_buffer *tbm_buffer;
1119 tbm_surface_h surface;
1120 enum ds_tdm_output_hwc_window_composition composition;
1125 composition = ds_tdm_output_hwc_window_get_composition(view->hwc_window);
1126 if ((composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_DEVICE) ||
1127 (composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_VIDEO) ||
1128 (composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_CURSOR))
1131 ds_buffer = ds_surface_get_buffer(
1132 ds_xdg_surface_get_surface(view->xdg_surface));
1136 tbm_buffer = ds_tbm_client_buffer_from_buffer(ds_buffer);
1140 surface = ds_tbm_client_buffer_get_tbm_surface(tbm_buffer);
1144 renderer_add_texture(&output->renderer, surface, view->x, view->y);
1146 view_send_frame_done(view);
1149 ds_dbg("<< END UPDATE TEXTURES");
1151 renderer_draw(&output->renderer);
1155 output_swapchain_init(struct tinyds_output *output,
1156 int width, int height, uint32_t format)
1159 output->allocator = ds_tbm_allocator_create();
1160 assert(output->allocator);
1162 output->swapchain = ds_swapchain_create(output->allocator,
1163 width, height, format);
1164 assert(output->swapchain);
1168 output_draw_with_swapchain(struct tinyds_output *output)
1170 struct tinyds_view *view;
1171 struct ds_buffer *output_buffer;
1172 pixman_image_t *output_image;
1173 enum ds_tdm_output_hwc_window_composition composition;
1175 output_buffer = ds_swapchain_acquire(output->swapchain, NULL);
1179 output_image = pixman_image_from_buffer(output_buffer,
1180 DS_BUFFER_DATA_PTR_ACCESS_WRITE);
1181 if (!output_image) {
1182 ds_buffer_unlock(output_buffer);
1186 pixman_image_fill_color(output_image, 80, 80, 80);
1188 wl_list_for_each(view, &output->server->views, link) {
1192 composition = ds_tdm_output_hwc_window_get_composition(view->hwc_window);
1193 if ((composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_DEVICE) ||
1194 (composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_VIDEO) ||
1195 (composition == DS_TDM_OUTPUT_HWC_WINDOW_COMPOSITION_CURSOR))
1198 draw_view(view, output_image);
1200 pixman_image_unref(output_image);
1202 if (!ds_tdm_output_hwc_set_client_target_buffer(output->hwc, output_buffer)) {
1203 ds_err("Could not set hwc client target buffer");
1204 ds_buffer_unlock(output_buffer);
1208 output_swap_buffer(output, output_buffer);
1212 draw_view(struct tinyds_view *view, pixman_image_t *dst_image)
1214 struct ds_buffer *buffer;
1215 pixman_image_t *src_image;
1217 buffer = ds_surface_get_buffer(
1218 ds_xdg_surface_get_surface(view->xdg_surface));
1222 src_image = pixman_image_from_buffer(buffer,
1223 DS_BUFFER_DATA_PTR_ACCESS_READ);
1224 pixman_image_composite32(PIXMAN_OP_OVER,
1230 pixman_image_get_width(src_image),
1231 pixman_image_get_height(src_image));
1232 pixman_image_unref(src_image);
1234 view_send_frame_done(view);
1239 draw_output(struct tinyds_output *output)
1241 #ifdef USE_TDM_BUFFER_QUEUE
1242 output_draw_with_renderer(output);
1244 output_draw_with_swapchain(output);
1247 ds_dbg("output:%p draw", output);
1251 output_swap_buffer(struct tinyds_output *output, struct ds_buffer *buffer)
1253 ds_output_attach_buffer(output->ds_output, buffer);
1255 if (output->front_buffer)
1256 ds_buffer_unlock(output->front_buffer);
1257 output->front_buffer = buffer;
1261 view_send_frame_done(struct tinyds_view *view)
1263 struct timespec now;
1264 clock_gettime(CLOCK_MONOTONIC, &now);
1265 ds_surface_send_frame_done(ds_xdg_surface_get_surface(view->xdg_surface),
1270 server_dispatch_stdin(int fd, uint32_t mask, void *data)
1272 struct tinyds_server *server = data;
1274 wl_display_terminate(server->display);
1280 dpms_handle_destroy(struct wl_listener *listener, void *data)
1282 struct tinyds_dpms *dpms;
1284 dpms = wl_container_of(listener, dpms, destroy);
1286 ds_inf("Dpms(%p) destroyed", dpms);
1288 wl_list_remove(&dpms->destroy.link);
1289 wl_list_remove(&dpms->set_dpms.link);
1290 wl_list_remove(&dpms->get_dpms.link);
1296 dpms_handle_set_dpms(struct wl_listener *listener, void *data)
1298 struct tinyds_dpms *dpms;
1299 struct ds_tizen_dpms_event *event = data;
1301 dpms = wl_container_of(listener, dpms, set_dpms);
1303 ds_inf("Dpms(%p) set dpms : %d", dpms, event->mode);
1306 //set dpms mode to output
1307 ds_tizen_dpms_send_set_result(dpms->ds_dpms, event->mode,
1308 DS_TIZEN_DPMS_ERROR_NONE);
1312 dpms_handle_get_dpms(struct wl_listener *listener, void *data)
1314 struct tinyds_dpms *dpms;
1316 dpms = wl_container_of(listener, dpms, get_dpms);
1318 ds_inf("Dpms(%p) get dpms", dpms);
1321 //get dpms mode from output
1322 ds_tizen_dpms_send_get_result(dpms->ds_dpms, DS_TIZEN_DPMS_MODE_ON,
1323 DS_TIZEN_DPMS_ERROR_NONE);
1327 keyboard_handle_device_destroy(struct wl_listener *listener, void *data)
1329 struct tinyds_keyboard *kbd;
1331 kbd = wl_container_of(listener, kbd, destroy);
1333 ds_inf("Keyboard(%p) destroyed", kbd);
1335 wl_list_remove(&kbd->destroy.link);
1336 wl_list_remove(&kbd->key.link);
1337 wl_list_remove(&kbd->link);
1343 server_handle_keybinding(struct tinyds_server *server, xkb_keysym_t sym)
1346 case XKB_KEY_BackSpace:
1347 wl_display_terminate(server->display);
1357 keyboard_handle_key(struct wl_listener *listener, void *data)
1359 struct tinyds_keyboard *kbd;
1360 struct ds_event_keyboard_key *event = data;
1361 struct ds_keyboard *ds_keyboard;
1362 struct xkb_state *xkb_state;
1363 const xkb_keysym_t *syms;
1365 bool handled = false;
1367 kbd = wl_container_of(listener, kbd, key);
1369 ds_inf("Keyboard(%p) event key: keycode(%d), state(%d), time_msec(%d), "
1370 "update_state(%d)", kbd->dev,
1371 event->keycode, event->state, event->time_msec,
1372 event->update_state);
1374 ds_keyboard = ds_input_device_get_keyboard(kbd->dev);
1376 if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
1377 xkb_state = ds_keyboard_get_xkb_state(ds_keyboard);
1379 nsyms = xkb_state_key_get_syms(xkb_state, event->keycode + 8,
1381 for (int i = 0; i < nsyms; i++) {
1382 handled = server_handle_keybinding(kbd->server, syms[i]);
1388 ds_seat_keyboard_notify_key(kbd->server->seat, event->time_msec,
1389 event->keycode, event->state);
1394 server_add_keyboard(struct tinyds_server *server, struct ds_input_device *dev)
1396 struct tinyds_keyboard *kbd;
1397 struct xkb_context *context;
1398 struct xkb_keymap *keymap;
1400 kbd = calloc(1, sizeof *kbd);
1404 kbd->server = server;
1406 context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
1407 keymap = xkb_keymap_new_from_names(context, NULL,
1408 XKB_KEYMAP_COMPILE_NO_FLAGS);
1411 ds_err("Failed to compile keymap");
1412 xkb_context_unref(context);
1415 ds_keyboard_set_keymap(ds_input_device_get_keyboard(dev), keymap);
1417 xkb_keymap_unref(keymap);
1418 xkb_context_unref(context);
1420 kbd->destroy.notify = keyboard_handle_device_destroy;
1421 ds_input_device_add_destroy_listener(dev, &kbd->destroy);
1423 kbd->key.notify = keyboard_handle_key;
1424 ds_keyboard_add_key_listener(ds_input_device_get_keyboard(dev), &kbd->key);
1426 wl_list_insert(&server->keyboards, &kbd->link);
1428 ds_inf("Keyboard(%p) added", kbd);
1431 static struct tinyds_view *
1432 server_view_at(struct tinyds_server *server, double lx, double ly,
1433 double *sx, double *sy)
1435 struct tinyds_view *view;
1436 struct ds_surface *surface;
1437 struct ds_buffer *buffer;
1438 int x, y, w = 0, h = 0;
1440 wl_list_for_each(view, &server->views, link) {
1441 surface = ds_xdg_surface_get_surface(view->xdg_surface);
1442 buffer = ds_surface_get_buffer(surface);
1443 ds_buffer_get_size(buffer, &w, &h);
1448 if (lx >= x && lx <= x + w && ly >= y && ly <= y + h) {
1460 touch_handle_device_destroy(struct wl_listener *listener, void *data)
1462 struct tinyds_touch *touch;
1464 touch = wl_container_of(listener, touch, destroy);
1466 ds_inf("Touch(%p) destroyed", touch);
1468 wl_list_remove(&touch->destroy.link);
1469 wl_list_remove(&touch->down.link);
1470 wl_list_remove(&touch->up.link);
1471 wl_list_remove(&touch->motion.link);
1477 touch_handle_down(struct wl_listener *listener, void *data)
1479 struct ds_event_touch_down *event = data;
1480 struct tinyds_touch *touch;
1481 struct tinyds_view *view;
1482 struct tinyds_server *server;
1483 double sx = 0.f, sy = 0.f;
1485 touch = wl_container_of(listener, touch, down);
1487 server = touch->server;
1488 server->output_x = event->x * server->output->width;
1489 server->output_y = event->y * server->output->height;
1491 ds_inf("Touch(%p) event down: id(%d) x %.3f y %.3f output_x %.1f output_y %.1f",
1492 touch->dev, event->id, event->x, event->y, server->output_x, server->output_y);
1494 view = server_view_at(server, server->output_x, server->output_y, &sx, &sy);
1497 ds_seat_touch_notify_down(touch->server->seat, ds_xdg_surface_get_surface(view->xdg_surface),
1498 event->time_msec, event->id, sx, sy);
1503 touch_handle_up(struct wl_listener *listener, void *data)
1505 struct ds_event_touch_up *event = data;
1506 struct tinyds_touch *touch;
1508 touch = wl_container_of(listener, touch, up);
1510 ds_inf("Touch(%p) event up: id(%d) time_msec(%d)",
1511 touch->dev, event->id, event->time_msec);
1513 ds_seat_touch_notify_up(touch->server->seat, event->time_msec, event->id);
1517 touch_handle_motion(struct wl_listener *listener, void *data)
1519 struct ds_event_touch_motion *event = data;
1520 struct tinyds_touch *touch;
1521 struct tinyds_view *view;
1522 struct tinyds_server *server;
1523 double sx = 0.f, sy = 0.f;
1525 touch = wl_container_of(listener, touch, motion);
1527 server = touch->server;
1528 server->output_x = event->x * server->output->width;
1529 server->output_y = event->y * server->output->height;
1531 ds_inf("Touch(%p) event motion: id(%d) x %.3f y %.3f output_x %.1f output_y %.1f",
1532 touch->dev, event->id, event->x, event->y, server->output_x, server->output_y);
1534 view = server_view_at(server, server->output_x, server->output_y, &sx, &sy);
1537 ds_seat_touch_notify_motion(server->seat, event->time_msec,
1543 server_add_touch(struct tinyds_server *server, struct ds_input_device *dev)
1545 struct tinyds_touch *touch;
1547 touch = calloc(1, sizeof *touch);
1551 touch->server = server;
1553 touch->destroy.notify = touch_handle_device_destroy;
1554 ds_input_device_add_destroy_listener(dev, &touch->destroy);
1556 touch->down.notify = touch_handle_down;
1557 ds_touch_add_down_listener(ds_input_device_get_touch(dev), &touch->down);
1559 touch->up.notify = touch_handle_up;
1560 ds_touch_add_up_listener(ds_input_device_get_touch(dev), &touch->up);
1562 touch->motion.notify = touch_handle_motion;
1563 ds_touch_add_motion_listener(ds_input_device_get_touch(dev), &touch->motion);
1565 ds_inf("Touch(%p) added", touch);
1569 pointer_handle_device_destroy(struct wl_listener *listener, void *data)
1571 struct tinyds_pointer *pointer;
1573 pointer = wl_container_of(listener, pointer, destroy);
1575 ds_inf("Pointer(%p) destroyed", pointer);
1577 wl_list_remove(&pointer->destroy.link);
1578 wl_list_remove(&pointer->motion.link);
1579 wl_list_remove(&pointer->button.link);
1580 wl_list_remove(&pointer->frame.link);
1581 wl_list_remove(&pointer->link);
1587 pointer_handle_motion(struct wl_listener *listener, void *data)
1589 struct tinyds_pointer *pointer;
1590 struct ds_event_pointer_motion *event = data;
1591 struct tinyds_view *view;
1592 struct tinyds_server *server;
1596 pointer = wl_container_of(listener, pointer, motion);
1598 server = pointer->server;
1599 if (server->output) {
1600 ow = server->output->width;
1601 oh = server->output->height;
1604 if (server->output_x + event->delta_x >= ow)
1605 server->output_x = ow;
1606 else if(server->output_x + event->delta_x <= 0.f)
1607 server->output_x = 0.f;
1609 server->output_x = server->output_x + event->delta_x ;
1610 if (server->output_y + event->delta_y >= oh)
1611 server->output_y = oh;
1612 else if(server->output_y + event->delta_y <= 0.f)
1613 server->output_y = 0.f;
1615 server->output_y = server->output_y + event->delta_y ;
1617 ds_inf("Pointer(%p) motion: (delta_x %.1f delta_y %.1f) output_x %.1f output_y %.1f",
1618 pointer, event->delta_x, event->delta_y, server->output_x, server->output_y);
1620 view = server_view_at(pointer->server, server->output_x, server->output_y, &sx, &sy);
1622 if (pointer->focused_view != view) {
1623 if (pointer->focused_view) {
1624 ds_inf("Clear pointer focus from view(%p)", pointer->focused_view);
1625 ds_seat_pointer_notify_clear_focus(pointer->server->seat);
1626 pointer->focused_view = NULL;
1630 ds_inf("Set pointer focus to view(%p)", view);
1631 ds_seat_pointer_notify_enter(pointer->server->seat,
1632 ds_xdg_surface_get_surface(view->xdg_surface), sx, sy);
1633 pointer->focused_view = view;
1638 ds_seat_pointer_notify_motion(pointer->server->seat,
1639 event->time_msec, sx, sy);
1644 pointer_handle_button(struct wl_listener *listener, void *data)
1646 struct tinyds_pointer *pointer;
1647 struct ds_event_pointer_button *event = data;
1649 pointer = wl_container_of(listener, pointer, button);
1651 ds_inf("Pointer(%p) button(%d): state(%s) time(%d)",
1652 pointer, event->button,
1653 (event->state == DS_BUTTON_PRESSED) ? "Pressed" : "Released",
1656 ds_seat_pointer_notify_button(pointer->server->seat, event->time_msec, event->button, event->state);
1660 pointer_handle_frame(struct wl_listener *listener, void *data)
1662 struct tinyds_pointer *pointer;
1664 pointer = wl_container_of(listener, pointer, frame);
1666 ds_inf("Pointer(%p) frame", pointer);
1667 ds_seat_pointer_notify_frame(pointer->server->seat);
1671 server_add_pointer(struct tinyds_server *server, struct ds_input_device *dev)
1673 struct tinyds_pointer *pointer;
1675 pointer = calloc(1, sizeof *pointer);
1679 pointer->server = server;
1680 server->output_x = 200;
1681 server->output_y = 200;
1683 pointer->destroy.notify = pointer_handle_device_destroy;
1684 ds_input_device_add_destroy_listener(dev, &pointer->destroy);
1686 pointer->motion.notify = pointer_handle_motion;
1687 ds_pointer_add_motion_listener(ds_input_device_get_pointer(dev),
1690 pointer->button.notify = pointer_handle_button;
1691 ds_pointer_add_button_listener(ds_input_device_get_pointer(dev),
1694 pointer->frame.notify = pointer_handle_frame;
1695 ds_pointer_add_frame_listener(ds_input_device_get_pointer(dev),
1698 pointer->focused_view = NULL;
1700 wl_list_insert(&server->pointers, &pointer->link);
1702 ds_inf("Pointer(%p) added", pointer);
1707 output_schedule_commit_handle_idle_timer(void *data)
1709 struct tinyds_output *output = data;
1710 output->idle_commit = NULL;
1712 output_commit(output);
1716 output_schedule_commit(struct tinyds_output *output)
1718 if (output->idle_commit)
1721 struct wl_event_loop *ev = wl_display_get_event_loop(output->server->display);
1722 output->idle_commit =
1723 wl_event_loop_add_idle(ev, output_schedule_commit_handle_idle_timer, output);