blob: 5fb1f08c9f5f67478b977ca9546da62bb8475ef1 [file] [log] [blame]
Pekka Paalanenef2b5922014-09-23 22:08:49 -04001/*
2 * Copyright © 2011 Benjamin Franzke
3 * Copyright © 2010 Intel Corporation
4 * Copyright © 2014 Collabora, Ltd.
5 *
Bryce Harrington1f6b0d12015-06-10 22:48:59 -07006 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
Pekka Paalanenef2b5922014-09-23 22:08:49 -040012 *
Bryce Harrington1f6b0d12015-06-10 22:48:59 -070013 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
15 * Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
Pekka Paalanenef2b5922014-09-23 22:08:49 -040024 */
25
26#include <config.h>
27
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31#include <stdbool.h>
32#include <assert.h>
33#include <unistd.h>
34#include <sys/mman.h>
35#include <signal.h>
36#include <time.h>
37
38#include <wayland-client.h>
39#include "../shared/os-compatibility.h"
40#include "presentation_timing-client-protocol.h"
41
42#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
43
44enum run_mode {
45 RUN_MODE_FEEDBACK,
46 RUN_MODE_FEEDBACK_IDLE,
47 RUN_MODE_PRESENT,
48};
49
Pekka Paalanen4d012bc2015-02-06 13:50:37 +020050static const char * const run_mode_name[] = {
51 [RUN_MODE_FEEDBACK] = "feedback",
52 [RUN_MODE_FEEDBACK_IDLE] = "feedback-idle",
53 [RUN_MODE_PRESENT] = "low-lat present",
54};
55
Pekka Paalanenef2b5922014-09-23 22:08:49 -040056struct output {
57 struct wl_output *output;
58 uint32_t name;
59 struct wl_list link;
60};
61
62struct display {
63 struct wl_display *display;
64 struct wl_registry *registry;
65 struct wl_compositor *compositor;
66 struct wl_shell *shell;
67
68 struct wl_shm *shm;
69 uint32_t formats;
70
71 struct presentation *presentation;
72 clockid_t clk_id;
73
74 struct wl_list output_list; /* struct output::link */
75};
76
77struct feedback {
78 struct window *window;
79 unsigned frame_no;
80 struct presentation_feedback *feedback;
81 struct timespec commit;
82 struct timespec target;
83 uint32_t frame_stamp;
84 struct wl_list link;
85 struct timespec present;
86};
87
88struct buffer {
89 struct wl_buffer *buffer;
90 void *shm_data;
91 int busy;
92};
93
94struct window {
95 struct display *display;
96 int width, height;
97 enum run_mode mode;
98 struct wl_surface *surface;
99 struct wl_shell_surface *shell_surface;
100
101 struct buffer *buffers;
102 int num_buffers;
103 int next;
104 int refresh_nsec;
105
106 struct wl_callback *callback;
107 struct wl_list feedback_list;
108
109 struct feedback *received_feedback;
110};
111
112#define NSEC_PER_SEC 1000000000
113
114static void
115buffer_release(void *data, struct wl_buffer *buffer)
116{
117 struct buffer *mybuf = data;
118
119 mybuf->busy = 0;
120}
121
122static const struct wl_buffer_listener buffer_listener = {
123 buffer_release
124};
125
126static int
127create_shm_buffers(struct display *display, struct buffer **buffers,
128 int num_buffers, int width, int height, uint32_t format)
129{
130 struct buffer *bufs;
131 struct wl_shm_pool *pool;
132 int fd, size, stride, offset;
133 void *data;
134 int i;
135
136 stride = width * 4;
137 size = stride * height * num_buffers;
138
139 fd = os_create_anonymous_file(size);
140 if (fd < 0) {
141 fprintf(stderr, "creating a buffer file for %d B failed: %m\n",
142 size);
143 return -1;
144 }
145
146 data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
147 if (data == MAP_FAILED) {
148 fprintf(stderr, "mmap failed: %m\n");
149 close(fd);
150 return -1;
151 }
152
153 pool = wl_shm_create_pool(display->shm, fd, size);
154 offset = 0;
155
156 bufs = calloc(num_buffers, sizeof(*bufs));
157 assert(bufs);
158
159 for (i = 0; i < num_buffers; i++) {
160 bufs[i].buffer = wl_shm_pool_create_buffer(pool, offset,
161 width, height,
162 stride, format);
163 assert(bufs[i].buffer);
164 wl_buffer_add_listener(bufs[i].buffer,
165 &buffer_listener, &bufs[i]);
166
167 bufs[i].shm_data = (char *)data + offset;
168 offset += stride * height;
169 }
170
171 wl_shm_pool_destroy(pool);
172 close(fd);
173
174 *buffers = bufs;
175
176 return 0;
177}
178
179static void
180handle_ping(void *data, struct wl_shell_surface *shell_surface,
181 uint32_t serial)
182{
183 wl_shell_surface_pong(shell_surface, serial);
184}
185
186static void
187handle_configure(void *data, struct wl_shell_surface *shell_surface,
188 uint32_t edges, int32_t width, int32_t height)
189{
190}
191
192static void
193handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
194{
195}
196
197static const struct wl_shell_surface_listener shell_surface_listener = {
198 handle_ping,
199 handle_configure,
200 handle_popup_done
201};
202
203static struct window *
204create_window(struct display *display, int width, int height,
205 enum run_mode mode)
206{
207 struct window *window;
Pekka Paalanen4d012bc2015-02-06 13:50:37 +0200208 char title[128];
Pekka Paalanenef2b5922014-09-23 22:08:49 -0400209 int ret;
210
Pekka Paalanen4d012bc2015-02-06 13:50:37 +0200211 snprintf(title, sizeof(title),
212 "presentation-shm: %s", run_mode_name[mode]);
213
Pekka Paalanenef2b5922014-09-23 22:08:49 -0400214 window = calloc(1, sizeof *window);
215 if (!window)
216 return NULL;
217
218 window->mode = mode;
219 window->callback = NULL;
220 wl_list_init(&window->feedback_list);
221 window->display = display;
222 window->width = width;
223 window->height = height;
224 window->surface = wl_compositor_create_surface(display->compositor);
225 window->shell_surface = wl_shell_get_shell_surface(display->shell,
226 window->surface);
227
228 if (window->shell_surface)
229 wl_shell_surface_add_listener(window->shell_surface,
230 &shell_surface_listener, window);
231
Pekka Paalanen4d012bc2015-02-06 13:50:37 +0200232 wl_shell_surface_set_title(window->shell_surface, title);
Pekka Paalanenef2b5922014-09-23 22:08:49 -0400233
234 wl_shell_surface_set_toplevel(window->shell_surface);
235
236 window->num_buffers = 60;
237 window->refresh_nsec = NSEC_PER_SEC / 60; /* 60 Hz guess */
238 window->next = 0;
239 ret = create_shm_buffers(window->display,
240 &window->buffers, window->num_buffers,
241 window->width, window->height,
242 WL_SHM_FORMAT_XRGB8888);
243 assert(ret == 0);
244
245 return window;
246}
247
248static void
249destroy_feedback(struct feedback *feedback)
250{
251 if (feedback->feedback)
252 presentation_feedback_destroy(feedback->feedback);
253
254 wl_list_remove(&feedback->link);
255 free(feedback);
256}
257
258static void
259destroy_window(struct window *window)
260{
261 int i;
262
263 while (!wl_list_empty(&window->feedback_list)) {
264 struct feedback *f;
265
266 f = wl_container_of(window->feedback_list.next, f, link);
267 printf("clean up feedback %u\n", f->frame_no);
268 destroy_feedback(f);
269 }
270
271 if (window->callback)
272 wl_callback_destroy(window->callback);
273
274 wl_shell_surface_destroy(window->shell_surface);
275 wl_surface_destroy(window->surface);
276
277 for (i = 0; i < window->num_buffers; i++)
278 wl_buffer_destroy(window->buffers[i].buffer);
279 /* munmap(window->buffers[0].shm_data, size); */
280 free(window->buffers);
281
282 free(window);
283}
284
285static struct buffer *
286window_next_buffer(struct window *window)
287{
288 struct buffer *buf = &window->buffers[window->next];
289
290 window->next = (window->next + 1) % window->num_buffers;
291
292 return buf;
293}
294
295static void
296paint_pixels(void *image, int width, int height, uint32_t phase)
297{
298 const int halfh = height / 2;
299 const int halfw = width / 2;
300 uint32_t *pixel = image;
301 int y, or;
302 double ang = M_PI * 2.0 / 1000000.0 * phase;
303 double s = sin(ang);
304 double c = cos(ang);
305
306 /* squared radii thresholds */
307 or = (halfw < halfh ? halfw : halfh) - 16;
308 or *= or;
309
310 for (y = 0; y < height; y++) {
311 int x;
312 int oy = y - halfh;
313 int y2 = oy * oy;
314
315 for (x = 0; x < width; x++) {
316 int ox = x - halfw;
317 uint32_t v = 0xff000000;
318 double rx, ry;
319
320 if (ox * ox + y2 > or) {
321 if (ox * oy > 0)
322 *pixel++ = 0xff000000;
323 else
324 *pixel++ = 0xffffffff;
325 continue;
326 }
327
328 rx = c * ox + s * oy;
329 ry = -s * ox + c * oy;
330
331 if (rx < 0.0)
332 v |= 0x00ff0000;
333 if (ry < 0.0)
334 v |= 0x0000ff00;
335 if ((rx < 0.0) == (ry < 0.0))
336 v |= 0x000000ff;
337
338 *pixel++ = v;
339 }
340 }
341}
342
343static void
344feedback_sync_output(void *data,
345 struct presentation_feedback *presentation_feedback,
346 struct wl_output *output)
347{
348 /* not interested */
349}
350
351static char *
352pflags_to_str(uint32_t flags, char *str, unsigned len)
353{
354 static const struct {
355 uint32_t flag;
356 char sym;
357 } desc[] = {
Pekka Paalanen63495862014-12-17 16:20:42 +0200358 { PRESENTATION_FEEDBACK_KIND_VSYNC, 's' },
359 { PRESENTATION_FEEDBACK_KIND_HW_CLOCK, 'c' },
360 { PRESENTATION_FEEDBACK_KIND_HW_COMPLETION, 'e' },
361 { PRESENTATION_FEEDBACK_KIND_ZERO_COPY, 'z' },
Pekka Paalanenef2b5922014-09-23 22:08:49 -0400362 };
363 unsigned i;
364
365 *str = '\0';
366 if (len < ARRAY_LENGTH(desc) + 1)
367 return str;
368
369 for (i = 0; i < ARRAY_LENGTH(desc); i++)
370 str[i] = flags & desc[i].flag ? desc[i].sym : '_';
371 str[ARRAY_LENGTH(desc)] = '\0';
372
373 return str;
374}
375
376static uint32_t
377timespec_to_ms(const struct timespec *ts)
378{
379 return (uint32_t)ts->tv_sec * 1000 + ts->tv_nsec / 1000000;
380}
381
382static void
383timespec_from_proto(struct timespec *tm, uint32_t tv_sec_hi,
384 uint32_t tv_sec_lo, uint32_t tv_nsec)
385{
386 tm->tv_sec = ((uint64_t)tv_sec_hi << 32) + tv_sec_lo;
387 tm->tv_nsec = tv_nsec;
388}
389
390static int
391timespec_diff_to_usec(const struct timespec *a, const struct timespec *b)
392{
393 time_t secs = a->tv_sec - b->tv_sec;
394 long nsec = a->tv_nsec - b->tv_nsec;
395
396 return secs * 1000000 + nsec / 1000;
397}
398
399static void
400feedback_presented(void *data,
401 struct presentation_feedback *presentation_feedback,
402 uint32_t tv_sec_hi,
403 uint32_t tv_sec_lo,
404 uint32_t tv_nsec,
405 uint32_t refresh_nsec,
406 uint32_t seq_hi,
407 uint32_t seq_lo,
408 uint32_t flags)
409{
410 struct feedback *feedback = data;
411 struct window *window = feedback->window;
412 struct feedback *prev_feedback = window->received_feedback;
413 uint64_t seq = ((uint64_t)seq_hi << 32) + seq_lo;
414 const struct timespec *prevpresent;
415 uint32_t commit, present;
416 uint32_t f2c, c2p, f2p;
417 int p2p, t2p;
418 char flagstr[10];
419
420 timespec_from_proto(&feedback->present, tv_sec_hi, tv_sec_lo, tv_nsec);
421 commit = timespec_to_ms(&feedback->commit);
422 present = timespec_to_ms(&feedback->present);
423
424 if (prev_feedback)
425 prevpresent = &prev_feedback->present;
426 else
427 prevpresent = &feedback->present;
428
429 f2c = commit - feedback->frame_stamp;
430 c2p = present - commit;
431 f2p = present - feedback->frame_stamp;
432 p2p = timespec_diff_to_usec(&feedback->present, prevpresent);
433 t2p = timespec_diff_to_usec(&feedback->present, &feedback->target);
434
435 switch (window->mode) {
436 case RUN_MODE_PRESENT:
437 printf("%6u: c2p %4u ms, p2p %5d us, t2p %6d us, [%s] "
438 "seq %" PRIu64 "\n", feedback->frame_no, c2p,
439 p2p, t2p,
440 pflags_to_str(flags, flagstr, sizeof(flagstr)), seq);
441 break;
442 case RUN_MODE_FEEDBACK:
443 case RUN_MODE_FEEDBACK_IDLE:
444 printf("%6u: f2c %2u ms, c2p %2u ms, f2p %2u ms, p2p %5d us, "
445 "t2p %6d, [%s], seq %" PRIu64 "\n", feedback->frame_no,
446 f2c, c2p, f2p, p2p, t2p,
447 pflags_to_str(flags, flagstr, sizeof(flagstr)), seq);
448 }
449
450 if (window->received_feedback)
451 destroy_feedback(window->received_feedback);
452 window->received_feedback = feedback;
453}
454
455static void
456feedback_discarded(void *data,
457 struct presentation_feedback *presentation_feedback)
458{
459 struct feedback *feedback = data;
460
461 printf("discarded %u\n", feedback->frame_no);
462
463 destroy_feedback(feedback);
464}
465
466static const struct presentation_feedback_listener feedback_listener = {
467 feedback_sync_output,
468 feedback_presented,
469 feedback_discarded
470};
471
472static void
473window_create_feedback(struct window *window, uint32_t frame_stamp)
474{
475 static unsigned seq;
476 struct presentation *pres = window->display->presentation;
477 struct feedback *feedback;
478
479 seq++;
480
481 if (!pres)
482 return;
483
484 feedback = calloc(1, sizeof *feedback);
485 if (!feedback)
486 return;
487
488 feedback->window = window;
489 feedback->feedback = presentation_feedback(pres, window->surface);
490 presentation_feedback_add_listener(feedback->feedback,
491 &feedback_listener, feedback);
492
493 feedback->frame_no = seq;
494 clock_gettime(window->display->clk_id, &feedback->commit);
495 feedback->frame_stamp = frame_stamp;
496 feedback->target = feedback->commit;
497
498 wl_list_insert(&window->feedback_list, &feedback->link);
499}
500
501static void
502window_commit_next(struct window *window)
503{
504 struct buffer *buffer;
505
506 buffer = window_next_buffer(window);
507 assert(buffer);
508
509 wl_surface_attach(window->surface, buffer->buffer, 0, 0);
510 wl_surface_damage(window->surface, 0, 0, window->width, window->height);
511 wl_surface_commit(window->surface);
512 buffer->busy = 1;
513}
514
515static const struct wl_callback_listener frame_listener_mode_feedback;
516
517static void
518redraw_mode_feedback(void *data, struct wl_callback *callback, uint32_t time)
519{
520 struct window *window = data;
521
522 if (callback && window->mode == RUN_MODE_FEEDBACK_IDLE)
523 sleep(1);
524
525 if (callback)
526 wl_callback_destroy(callback);
527
528 window->callback = wl_surface_frame(window->surface);
529 wl_callback_add_listener(window->callback,
530 &frame_listener_mode_feedback, window);
531
532 window_create_feedback(window, time);
533 window_commit_next(window);
534}
535
536static const struct wl_callback_listener frame_listener_mode_feedback = {
537 redraw_mode_feedback
538};
539
540static const struct presentation_feedback_listener feedkick_listener;
541
542static void
543window_feedkick(struct window *window)
544{
545 struct presentation *pres = window->display->presentation;
546 struct presentation_feedback *fback;
547
548 fback = presentation_feedback(pres, window->surface);
549 presentation_feedback_add_listener(fback, &feedkick_listener, window);
550}
551
552static void
553feedkick_presented(void *data,
554 struct presentation_feedback *presentation_feedback,
555 uint32_t tv_sec_hi,
556 uint32_t tv_sec_lo,
557 uint32_t tv_nsec,
558 uint32_t refresh_nsec,
559 uint32_t seq_hi,
560 uint32_t seq_lo,
561 uint32_t flags)
562{
563 struct window *window = data;
564
565 presentation_feedback_destroy(presentation_feedback);
566 window->refresh_nsec = refresh_nsec;
567
568 switch (window->mode) {
569 case RUN_MODE_PRESENT:
570 window_create_feedback(window, 0);
571 window_feedkick(window);
572 window_commit_next(window);
573 break;
574 case RUN_MODE_FEEDBACK:
575 case RUN_MODE_FEEDBACK_IDLE:
576 assert(0 && "bad mode");
577 }
578}
579
580static void
581feedkick_discarded(void *data,
582 struct presentation_feedback *presentation_feedback)
583{
584 struct window *window = data;
585
586 presentation_feedback_destroy(presentation_feedback);
587
588 switch (window->mode) {
589 case RUN_MODE_PRESENT:
590 window_create_feedback(window, 0);
591 window_feedkick(window);
592 window_commit_next(window);
593 break;
594 case RUN_MODE_FEEDBACK:
595 case RUN_MODE_FEEDBACK_IDLE:
596 assert(0 && "bad mode");
597 }
598}
599
600static const struct presentation_feedback_listener feedkick_listener = {
601 feedback_sync_output,
602 feedkick_presented,
603 feedkick_discarded
604};
605
606static void
607firstdraw_mode_burst(struct window *window)
608{
609 switch (window->mode) {
610 case RUN_MODE_PRESENT:
611 window_create_feedback(window, 0);
612 break;
613 case RUN_MODE_FEEDBACK:
614 case RUN_MODE_FEEDBACK_IDLE:
615 assert(0 && "bad mode");
616 }
617
618 window_feedkick(window);
619 window_commit_next(window);
620}
621
622static void
623window_prerender(struct window *window)
624{
625 int i;
626 int timefactor = 1000000 / window->num_buffers;
627
628 for (i = 0; i < window->num_buffers; i++) {
629 struct buffer *buf = &window->buffers[i];
630
631 if (buf->busy)
632 fprintf(stderr, "wl_buffer id %u) busy\n",
633 wl_proxy_get_id(
634 (struct wl_proxy *)buf->buffer));
635
636 paint_pixels(buf->shm_data, window->width, window->height,
637 i * timefactor);
638 }
639}
640
641static void
642output_destroy(struct output *o)
643{
644 wl_output_destroy(o->output);
645 wl_list_remove(&o->link);
646 free(o);
647}
648
649static void
650display_add_output(struct display *d, uint32_t name, uint32_t version)
651{
652 struct output *o;
653
654 o = calloc(1, sizeof(*o));
655 assert(o);
656
657 o->output = wl_registry_bind(d->registry, name,
658 &wl_output_interface, 1);
659 o->name = name;
660 wl_list_insert(&d->output_list, &o->link);
661}
662
663static void
664presentation_clock_id(void *data, struct presentation *presentation,
665 uint32_t clk_id)
666{
667 struct display *d = data;
668
669 d->clk_id = clk_id;
670}
671
672static const struct presentation_listener presentation_listener = {
673 presentation_clock_id
674};
675
676static void
677shm_format(void *data, struct wl_shm *wl_shm, uint32_t format)
678{
679 struct display *d = data;
680
681 d->formats |= (1 << format);
682}
683
684static const struct wl_shm_listener shm_listener = {
685 shm_format
686};
687
688static void
689registry_handle_global(void *data, struct wl_registry *registry,
690 uint32_t name, const char *interface, uint32_t version)
691{
692 struct display *d = data;
693
694 if (strcmp(interface, "wl_compositor") == 0) {
695 d->compositor =
696 wl_registry_bind(registry,
697 name, &wl_compositor_interface, 1);
698 } else if (strcmp(interface, "wl_shell") == 0) {
699 d->shell = wl_registry_bind(registry,
700 name, &wl_shell_interface, 1);
701 } else if (strcmp(interface, "wl_shm") == 0) {
702 d->shm = wl_registry_bind(registry,
703 name, &wl_shm_interface, 1);
704 wl_shm_add_listener(d->shm, &shm_listener, d);
705 } else if (strcmp(interface, "wl_output") == 0) {
706 display_add_output(d, name, version);
707 } else if (strcmp(interface, "presentation") == 0) {
708 d->presentation =
709 wl_registry_bind(registry,
710 name, &presentation_interface, 1);
711 presentation_add_listener(d->presentation,
712 &presentation_listener, d);
713 }
714}
715
716static void
717registry_handle_global_remove(void *data, struct wl_registry *registry,
718 uint32_t name)
719{
720 struct display *d = data;
721 struct output *output, *otmp;
722
723 wl_list_for_each_safe(output, otmp, &d->output_list, link) {
724 if (output->name != name)
725 continue;
726
727 output_destroy(output);
728 }
729}
730
731static const struct wl_registry_listener registry_listener = {
732 registry_handle_global,
733 registry_handle_global_remove
734};
735
736static struct display *
737create_display(void)
738{
739 struct display *display;
740
741 display = malloc(sizeof *display);
742 if (display == NULL) {
743 fprintf(stderr, "out of memory\n");
744 exit(1);
745 }
746 display->display = wl_display_connect(NULL);
747 assert(display->display);
748
749 display->formats = 0;
750 display->clk_id = -1;
751 wl_list_init(&display->output_list);
752 display->registry = wl_display_get_registry(display->display);
753 wl_registry_add_listener(display->registry,
754 &registry_listener, display);
755 wl_display_roundtrip(display->display);
756 if (display->shm == NULL) {
757 fprintf(stderr, "No wl_shm global\n");
758 exit(1);
759 }
760
761 wl_display_roundtrip(display->display);
762
763 if (!(display->formats & (1 << WL_SHM_FORMAT_XRGB8888))) {
764 fprintf(stderr, "WL_SHM_FORMAT_XRGB32 not available\n");
765 exit(1);
766 }
767
768 wl_display_get_fd(display->display);
769
770 return display;
771}
772
773static void
774destroy_display(struct display *display)
775{
776 while (!wl_list_empty(&display->output_list)) {
777 struct output *o;
778
779 o = wl_container_of(display->output_list.next, o, link);
780 output_destroy(o);
781 }
782
783 if (display->shm)
784 wl_shm_destroy(display->shm);
785
786 if (display->shell)
787 wl_shell_destroy(display->shell);
788
789 if (display->compositor)
790 wl_compositor_destroy(display->compositor);
791
792 wl_registry_destroy(display->registry);
793 wl_display_flush(display->display);
794 wl_display_disconnect(display->display);
795 free(display);
796}
797
798static int running = 1;
799
800static void
801signal_int(int signum)
802{
803 running = 0;
804}
805
806static void
807usage(const char *prog, int exit_code)
808{
809 fprintf(stderr, "Usage: %s [mode] [options]\n"
810 "where 'mode' is one of\n"
811 " -f\trun in feedback mode (default)\n"
812 " -i\trun in feedback-idle mode; sleep 1s between frames\n"
813 " -p\trun in low-latency presentation mode\n"
814 "and 'options' may include\n",
815 prog);
816
817 fprintf(stderr, "Printed timing statistics, depending on mode:\n"
818 " commit sequence number\n"
819 " f2c: time from frame callback timestamp to commit\n"
820 " c2p: time from commit to presentation\n"
821 " f2p: time from frame callback timestamp to presentation\n"
822 " p2p: time from previous presentation to this one\n"
823 " t2p: time from target timestamp to presentation\n"
824 " seq: MSC\n");
825
826
827 exit(exit_code);
828}
829
830int
831main(int argc, char **argv)
832{
833 struct sigaction sigint;
834 struct display *display;
835 struct window *window;
836 int ret = 0;
837 enum run_mode mode = RUN_MODE_FEEDBACK;
838 int i;
839
840 for (i = 1; i < argc; i++) {
841 if (strcmp("-f", argv[i]) == 0)
842 mode = RUN_MODE_FEEDBACK;
843 else if (strcmp("-i", argv[i]) == 0)
844 mode = RUN_MODE_FEEDBACK_IDLE;
845 else if (strcmp("-p", argv[i]) == 0)
846 mode = RUN_MODE_PRESENT;
847 else
848 usage(argv[0], EXIT_FAILURE);
849 }
850
851 display = create_display();
852 window = create_window(display, 250, 250, mode);
853 if (!window)
854 return 1;
855
856 sigint.sa_handler = signal_int;
857 sigemptyset(&sigint.sa_mask);
858 sigint.sa_flags = SA_RESETHAND;
859 sigaction(SIGINT, &sigint, NULL);
860
861 window_prerender(window);
862
863 switch (mode) {
864 case RUN_MODE_FEEDBACK:
865 case RUN_MODE_FEEDBACK_IDLE:
866 redraw_mode_feedback(window, NULL, 0);
867 break;
868 case RUN_MODE_PRESENT:
869 firstdraw_mode_burst(window);
870 break;
871 }
872
873 while (running && ret != -1)
874 ret = wl_display_dispatch(display->display);
875
876 fprintf(stderr, "presentation-shm exiting\n");
877 destroy_window(window);
878 destroy_display(display);
879
880 return 0;
881}