1 /**************************************************************************
5 * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
7 * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
8 * JinYoung Jeon <jy0.jeon@samsung.com>,
9 * Taeheon Kim <th908.kim@samsung.com>,
10 * YoungJun Cho <yj44.cho@samsung.com>,
11 * SooChan Lim <sc1.lim@samsung.com>,
12 * Boram Park <sc1.lim@samsung.com>
14 * Permission is hereby granted, free of charge, to any person obtaining a
15 * copy of this software and associated documentation files (the
16 * "Software"), to deal in the Software without restriction, including
17 * without limitation the rights to use, copy, modify, merge, publish,
18 * distribute, sub license, and/or sell copies of the Software, and to
19 * permit persons to whom the Software is furnished to do so, subject to
20 * the following conditions:
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
27 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
29 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
30 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
31 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
32 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 **************************************************************************/
46 #include "tdm_client.h"
48 #include "tdm_macro.h"
51 #include "tdm_private.h"
52 #include "tdm-client-protocol.h"
54 typedef struct _tdm_private_client_vblank tdm_private_client_vblank;
56 typedef struct _tdm_private_client {
57 struct wl_display *display;
58 struct wl_registry *registry;
60 struct list_head output_list;
62 tdm_private_client_vblank *temp_vblank;
65 typedef struct _tdm_private_client_output {
66 tdm_private_client *private_client;
68 char name[TDM_NAME_LEN];
69 struct wl_tdm_output *output;
73 tdm_output_conn_status connection;
75 struct list_head vblank_list;
76 struct list_head change_handler_list;
79 unsigned int watch_output_changes;
81 struct list_head link;
82 } tdm_private_client_output;
84 struct _tdm_private_client_vblank {
85 tdm_private_client_output *private_output;
87 struct wl_tdm_vblank *vblank;
88 struct list_head wait_list;
90 char name[TDM_NAME_LEN];
94 unsigned int enable_fake;
95 unsigned int enable_ttrace;
103 struct list_head link;
106 typedef struct _tdm_client_output_handler_info {
107 tdm_private_client_output *private_output;
109 tdm_client_output_change_handler func;
112 struct list_head link;
113 } tdm_client_output_handler_info;
115 typedef struct _tdm_client_wait_info {
116 tdm_private_client_vblank *private_vblank;
118 tdm_client_vblank_handler func;
125 struct list_head link;
126 } tdm_client_wait_info;
129 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
131 tdm_private_client_vblank *private_vblank = data;
133 TDM_RETURN_IF_FAIL(private_vblank != NULL);
135 private_vblank->stamp = stamp;
138 /* LCOV_EXCL_START */
140 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
141 uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
142 uint32_t tv_usec, uint32_t error)
144 tdm_private_client_vblank *private_vblank = data;
145 tdm_client_wait_info *w = NULL, *ww = NULL;
147 TDM_RETURN_IF_FAIL(private_vblank != NULL);
149 private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
151 TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
152 private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
154 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
155 if (w->req_id != req_id)
158 if (private_vblank->enable_ttrace)
159 TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
161 if (w->req_time >= private_vblank->last_time)
162 TDM_WRN("'req(%.6f) < last(%.6f)' failed", w->req_time, private_vblank->last_time);
165 w->func(private_vblank, error, sequence, tv_sec, tv_usec, w->user_data);
177 /* LCOV_EXCL_START */
179 _tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
181 tdm_private_client_vblank *private_vblank = data;
183 TDM_RETURN_IF_FAIL(private_vblank != NULL);
185 private_vblank->enable_ttrace = enable;
189 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
190 _tdm_client_vblank_cb_stamp,
191 _tdm_client_vblank_cb_done,
192 _tdm_client_vblank_cb_ttrace,
196 _tdm_client_output_destroy(tdm_private_client_output *private_output)
198 tdm_private_client_vblank *v = NULL, *vv = NULL;
199 tdm_client_output_handler_info *h = NULL, *hh = NULL;
201 LIST_DEL(&private_output->link);
203 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
204 TDM_ERR("vblanks SHOULD be destroyed first!");
206 v->private_output = NULL;
209 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
214 wl_tdm_output_destroy(private_output->output);
216 free(private_output);
220 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
221 uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
223 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
225 TDM_RETURN_IF_FAIL(private_output != NULL);
227 private_output->width = width;
228 private_output->height = height;
229 private_output->refresh = refresh;
231 if (error != TDM_ERROR_NONE)
232 TDM_INFO("mode event error: %d", error);
234 TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
235 private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
236 width, height, refresh);
240 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
242 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
243 tdm_client_output_handler_info *h = NULL;
246 TDM_RETURN_IF_FAIL(private_output != NULL);
248 if (private_output->connection == value)
251 private_output->connection = value;
253 if (error != TDM_ERROR_NONE)
254 TDM_INFO("connection event error: %d", error);
256 TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
258 wl_proxy_get_id((struct wl_proxy*)private_output->output),
262 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
264 h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
269 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
271 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
272 tdm_client_output_handler_info *h = NULL;
275 TDM_RETURN_IF_FAIL(private_output != NULL);
277 if (private_output->dpms == value)
280 private_output->dpms = value;
282 if (error != TDM_ERROR_NONE)
283 TDM_INFO("dpms event error: %d", error);
285 TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
287 wl_proxy_get_id((struct wl_proxy*)private_output->output),
291 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
293 h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
297 static const struct wl_tdm_output_listener tdm_client_output_listener = {
298 _tdm_client_output_cb_mode,
299 _tdm_client_output_cb_connection,
300 _tdm_client_output_cb_dpms,
304 _tdm_client_cb_global(void *data, struct wl_registry *registry,
305 uint32_t name, const char *interface,
308 tdm_private_client *private_client = data;
310 if (strncmp(interface, "wl_tdm", 6) == 0) {
311 private_client->tdm =
312 wl_registry_bind(registry, name, &wl_tdm_interface, version);
313 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
315 wl_display_flush(private_client->display);
319 /* LCOV_EXCL_START */
321 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
326 static const struct wl_registry_listener tdm_client_registry_listener = {
327 _tdm_client_cb_global,
328 _tdm_client_cb_global_remove
332 tdm_client_create(tdm_error *error)
334 tdm_private_client *private_client;
336 private_client = calloc(1, sizeof *private_client);
337 if (!private_client) {
338 /* LCOV_EXCL_START */
340 TDM_ERR("alloc failed");
342 *error = TDM_ERROR_OUT_OF_MEMORY;
348 LIST_INITHEAD(&private_client->output_list);
350 private_client->display = wl_display_connect("tdm-socket");
351 TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
353 private_client->registry = wl_display_get_registry(private_client->display);
354 TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
356 wl_registry_add_listener(private_client->registry,
357 &tdm_client_registry_listener, private_client);
358 wl_display_roundtrip(private_client->display);
360 /* check global objects */
361 TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
364 *error = TDM_ERROR_NONE;
366 return (tdm_client*)private_client;
368 tdm_client_destroy((tdm_client*)private_client);
370 *error = TDM_ERROR_OPERATION_FAILED;
375 tdm_client_destroy(tdm_client *client)
377 tdm_private_client *private_client = (tdm_private_client*)client;
378 tdm_private_client_output *o = NULL, *oo = NULL;
383 if (private_client->temp_vblank)
384 tdm_client_vblank_destroy(private_client->temp_vblank);
386 LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
387 _tdm_client_output_destroy(o);
390 if (private_client->tdm)
391 wl_tdm_destroy(private_client->tdm);
392 if (private_client->registry)
393 wl_registry_destroy(private_client->registry);
394 if (private_client->display)
395 wl_display_disconnect(private_client->display);
397 free(private_client);
401 tdm_client_get_fd(tdm_client *client, int *fd)
403 tdm_private_client *private_client;
405 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
406 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
408 private_client = (tdm_private_client*)client;
410 *fd = wl_display_get_fd(private_client->display);
412 return TDM_ERROR_OPERATION_FAILED;
414 return TDM_ERROR_NONE;
418 tdm_client_handle_events(tdm_client *client)
420 tdm_private_client *private_client;
422 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
424 /* LCOV_EXCL_START */
425 private_client = (tdm_private_client*)client;
427 wl_display_dispatch(private_client->display);
429 return TDM_ERROR_NONE;
433 typedef struct _tdm_client_vblank_temp {
434 tdm_client_vblank_handler2 func;
436 } tdm_client_vblank_temp;
438 /* LCOV_EXCL_START */
440 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
441 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
443 tdm_client_vblank_temp *vblank_temp = user_data;
445 TDM_RETURN_IF_FAIL(vblank_temp != NULL);
447 if (vblank_temp->func)
448 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
454 /* LCOV_EXCL_START */ /* deprecated */
456 tdm_client_wait_vblank(tdm_client *client, char *name,
457 int sw_timer, int interval, int sync,
458 tdm_client_vblank_handler2 func, void *user_data)
460 tdm_private_client *private_client = (tdm_private_client*)client;
461 tdm_client_output *output;
462 tdm_client_vblank_temp *vblank_temp;
465 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
466 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
467 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
469 if (!private_client->temp_vblank) {
470 output = tdm_client_get_output(client, name, &ret);
471 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
473 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
474 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
477 tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
478 tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
480 vblank_temp = calloc(1, sizeof *vblank_temp);
481 TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
483 vblank_temp->func = func;
484 vblank_temp->user_data = user_data;
486 return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
491 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
493 tdm_private_client *private_client;
494 tdm_private_client_output *private_output = NULL;
497 *error = TDM_ERROR_NONE;
500 TDM_ERR("'!client' failed");
502 *error = TDM_ERROR_INVALID_PARAMETER;
506 private_client = (tdm_private_client*)client;
511 LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
512 if (!strncmp(private_output->name, name, TDM_NAME_LEN))
513 return (tdm_client_output*)private_output;
516 private_output = calloc(1, sizeof *private_output);
517 if (!private_output) {
518 /* LCOV_EXCL_START */
520 TDM_ERR("alloc failed");
522 *error = TDM_ERROR_OUT_OF_MEMORY;
528 private_output->private_client = private_client;
530 snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
531 private_output->output = wl_tdm_create_output(private_client->tdm, private_output->name);
532 if (!private_output->output) {
533 /* LCOV_EXCL_START */
535 TDM_ERR("couldn't create output resource");
536 free(private_output);
538 *error = TDM_ERROR_OUT_OF_MEMORY;
544 LIST_INITHEAD(&private_output->vblank_list);
545 LIST_INITHEAD(&private_output->change_handler_list);
546 LIST_ADDTAIL(&private_output->link, &private_client->output_list);
548 wl_tdm_output_add_listener(private_output->output,
549 &tdm_client_output_listener, private_output);
550 wl_display_roundtrip(private_client->display);
552 return (tdm_client_output*)private_output;
556 tdm_client_output_add_change_handler(tdm_client_output *output,
557 tdm_client_output_change_handler func,
560 tdm_private_client_output *private_output;
561 tdm_client_output_handler_info *h;
563 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
564 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
566 private_output = (tdm_private_client_output*)output;
568 h = calloc(1, sizeof *h);
569 TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
571 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
572 wl_tdm_output_watch_output_changes(private_output->output, 1);
574 /* TODO: this is very tricky.
575 * If a client adds the change_handler, we might be able to guess that
576 * the client will watch the tdm client's fd and handle tdm events in
577 * event loop. Otherwise, we CAN'T make sure if a client has event loop
578 * which handles tdm events.
580 private_output->watch_output_changes = 1;
583 h->private_output = private_output;
585 h->user_data = user_data;
586 LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
588 return TDM_ERROR_NOT_IMPLEMENTED;
592 tdm_client_output_remove_change_handler(tdm_client_output *output,
593 tdm_client_output_change_handler func,
596 tdm_private_client_output *private_output;
597 tdm_client_output_handler_info *h = NULL;
599 TDM_RETURN_IF_FAIL(output != NULL);
600 TDM_RETURN_IF_FAIL(func != NULL);
602 private_output = (tdm_private_client_output*)output;
604 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
605 if (h->func != func || h->user_data != user_data)
611 if (LIST_IS_EMPTY(&private_output->change_handler_list))
612 wl_tdm_output_watch_output_changes(private_output->output, 0);
619 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
621 tdm_private_client_output *private_output;
622 tdm_private_client *private_client;
624 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
625 TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
627 private_output = (tdm_private_client_output*)output;
629 if (private_output->watch_output_changes) {
630 *refresh = private_output->refresh;
631 return TDM_ERROR_NONE;
634 private_client = private_output->private_client;
635 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
637 wl_tdm_output_get_mode(private_output->output);
638 wl_display_roundtrip(private_client->display);
640 *refresh = private_output->refresh;
642 return TDM_ERROR_NONE;
646 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
648 tdm_private_client_output *private_output;
649 tdm_private_client *private_client;
651 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
652 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
654 private_output = (tdm_private_client_output*)output;
656 if (private_output->watch_output_changes) {
657 *status = private_output->connection;
658 return TDM_ERROR_NONE;
661 private_client = private_output->private_client;
662 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
664 wl_tdm_output_get_connection(private_output->output);
665 wl_display_roundtrip(private_client->display);
667 *status = private_output->connection;
669 return TDM_ERROR_NONE;
673 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
675 tdm_private_client_output *private_output;
676 tdm_private_client *private_client;
678 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
679 TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
681 private_output = (tdm_private_client_output*)output;
683 if (private_output->watch_output_changes) {
684 *dpms = private_output->dpms;
685 return TDM_ERROR_NONE;
688 private_client = private_output->private_client;
689 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
691 wl_tdm_output_get_dpms(private_output->output);
692 wl_display_roundtrip(private_client->display);
694 *dpms = private_output->dpms;
696 return TDM_ERROR_NONE;
700 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
702 tdm_private_client *private_client;
703 tdm_private_client_output *private_output;
704 tdm_private_client_vblank *private_vblank;
707 *error = TDM_ERROR_NONE;
710 TDM_ERR("'!output' failed");
712 *error = TDM_ERROR_INVALID_PARAMETER;
716 private_output = (tdm_private_client_output*)output;
717 private_client = private_output->private_client;
719 if (!private_client) {
720 TDM_ERR("'!private_client' failed");
722 *error = TDM_ERROR_INVALID_PARAMETER;
726 private_vblank = calloc(1, sizeof *private_vblank);
727 if (!private_vblank) {
728 /* LCOV_EXCL_START */
730 TDM_ERR("alloc failed");
732 *error = TDM_ERROR_OUT_OF_MEMORY;
738 private_vblank->private_output = private_output;
740 private_vblank->vblank = wl_tdm_output_create_vblank(private_output->output);
741 if (!private_vblank->vblank) {
742 /* LCOV_EXCL_START */
744 TDM_ERR("couldn't create vblank resource");
745 free(private_vblank);
747 *error = TDM_ERROR_OUT_OF_MEMORY;
754 private_vblank->fps = private_output->refresh;
755 private_vblank->offset = 0;
756 private_vblank->enable_fake = 0;
758 LIST_INITHEAD(&private_vblank->wait_list);
759 LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
761 wl_tdm_vblank_add_listener(private_vblank->vblank,
762 &tdm_client_vblank_listener, private_vblank);
763 wl_display_roundtrip(private_client->display);
765 return (tdm_client_vblank*)private_vblank;
769 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
771 tdm_private_client_vblank *private_vblank;
772 tdm_client_wait_info *w = NULL, *ww = NULL;
774 TDM_RETURN_IF_FAIL(vblank != NULL);
776 private_vblank = vblank;
777 LIST_DEL(&private_vblank->link);
779 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
784 wl_tdm_vblank_destroy(private_vblank->vblank);
786 free(private_vblank);
790 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
792 tdm_private_client_vblank *private_vblank;
794 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
796 private_vblank = vblank;
799 name = TDM_VBLANK_DEFAULT_NAME;
801 strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
802 private_vblank->name[TDM_NAME_LEN - 1] = '\0';
804 wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
806 return TDM_ERROR_NONE;
810 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
812 tdm_private_client_vblank *private_vblank;
814 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
816 private_vblank = vblank;
817 private_vblank->sync = sync;
819 return TDM_ERROR_NONE;
823 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
825 tdm_private_client_vblank *private_vblank;
827 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
828 TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
830 private_vblank = vblank;
832 if (private_vblank->fps == fps)
833 return TDM_ERROR_NONE;
834 private_vblank->fps = fps;
836 wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
838 return TDM_ERROR_NONE;
842 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
844 tdm_private_client_vblank *private_vblank;
846 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
848 private_vblank = vblank;
849 TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
851 if (private_vblank->offset == offset_ms)
852 return TDM_ERROR_NONE;
853 private_vblank->offset = offset_ms;
855 wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
857 return TDM_ERROR_NONE;
861 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
863 tdm_private_client_vblank *private_vblank;
865 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
867 private_vblank = vblank;
869 if (private_vblank->enable_fake == enable_fake)
870 return TDM_ERROR_NONE;
871 private_vblank->enable_fake = enable_fake;
873 wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
875 return TDM_ERROR_NONE;
879 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
881 tdm_private_client *private_client;
882 tdm_private_client_output *private_output;
883 tdm_private_client_vblank *private_vblank;
884 tdm_client_wait_info *w;
886 unsigned int req_sec, req_usec;
889 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
890 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
891 /* can't support "interval 0" and "getting current_msc" things because
892 * there is a socket communication between TDM client and server. It's impossible
893 * to return the current msc or sequence immediately.
895 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
897 private_vblank = vblank;
898 private_output = private_vblank->private_output;
899 private_client = private_output->private_client;
901 if (!private_vblank->started)
902 private_vblank->started = 1;
904 if (private_output->watch_output_changes && !private_vblank->enable_fake) {
905 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
906 TDM_ERR("output disconnected");
907 return TDM_ERROR_OUTPUT_DISCONNECTED;
909 if (private_output->dpms != TDM_OUTPUT_DPMS_ON) {
911 return TDM_ERROR_DPMS_OFF;
915 w = calloc(1, sizeof *w);
917 /* LCOV_EXCL_START */
919 TDM_ERR("alloc failed");
920 return TDM_ERROR_OUT_OF_MEMORY;
925 w->private_vblank = private_vblank;
927 w->user_data = user_data;
929 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
931 clock_gettime(CLOCK_MONOTONIC, &tp);
932 req_sec = (unsigned int)tp.tv_sec;
933 req_usec = (unsigned int)(tp.tv_nsec / 1000);
935 w->req_id = ++private_output->req_id;
936 w->req_time = TDM_TIME(req_sec, req_usec);
937 w->need_free = (private_vblank->sync) ? 0 : 1;
939 wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
941 if (private_vblank->enable_ttrace)
942 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
944 TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
945 vblank, interval, w->req_id, w->req_time);
947 private_vblank->req_time = w->req_time;
949 if (private_vblank->last_time >= w->req_time)
950 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
952 if (!private_vblank->sync) {
953 wl_display_flush(private_client->display);
954 return TDM_ERROR_NONE;
957 /* LCOV_EXCL_START */
959 while (ret != -1 && !w->need_free)
960 ret = wl_display_dispatch(private_client->display);
962 clock_gettime(CLOCK_MONOTONIC, &tp);
963 TDM_DBG("block during %d us",
964 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
965 - (req_sec * 1000000 + req_usec));
970 return TDM_ERROR_NONE;
976 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
977 tdm_client_vblank_handler func, void *user_data)
979 tdm_private_client *private_client;
980 tdm_private_client_output *private_output;
981 tdm_private_client_vblank *private_vblank;
982 tdm_client_wait_info *w;
984 unsigned int req_sec, req_usec;
987 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
988 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
990 private_vblank = vblank;
991 private_output = private_vblank->private_output;
992 private_client = private_output->private_client;
994 if (!private_vblank->started)
995 private_vblank->started = 1;
997 if (private_output->watch_output_changes && !private_vblank->enable_fake) {
998 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
999 TDM_ERR("output disconnected");
1000 return TDM_ERROR_OUTPUT_DISCONNECTED;
1002 if (private_output->dpms != TDM_OUTPUT_DPMS_ON) {
1003 TDM_ERR("dpms off");
1004 return TDM_ERROR_DPMS_OFF;
1008 w = calloc(1, sizeof *w);
1010 /* LCOV_EXCL_START */
1012 TDM_ERR("alloc failed");
1013 return TDM_ERROR_OUT_OF_MEMORY;
1015 /* LCOV_EXCL_STOP */
1018 w->private_vblank = private_vblank;
1020 w->user_data = user_data;
1022 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1024 clock_gettime(CLOCK_MONOTONIC, &tp);
1025 req_sec = (unsigned int)tp.tv_sec;
1026 req_usec = (unsigned int)(tp.tv_nsec / 1000);
1028 w->req_id = ++private_output->req_id;
1029 w->req_time = TDM_TIME(req_sec, req_usec);
1030 w->need_free = (private_vblank->sync) ? 0 : 1;
1032 wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1034 if (private_vblank->enable_ttrace)
1035 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1037 TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1038 vblank, sequence, w->req_id, w->req_time);
1040 private_vblank->req_time = w->req_time;
1042 if (private_vblank->last_time >= w->req_time)
1043 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1045 if (!private_vblank->sync) {
1046 wl_display_flush(private_client->display);
1047 return TDM_ERROR_NONE;
1050 /* LCOV_EXCL_START */
1052 while (ret != -1 && !w->need_free)
1053 ret = wl_display_dispatch(private_client->display);
1055 clock_gettime(CLOCK_MONOTONIC, &tp);
1056 TDM_DBG("block during %d us",
1057 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1058 - (req_sec * 1000000 + req_usec));
1063 return TDM_ERROR_NONE;
1065 /* LCOV_EXCL_STOP */