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 <boram1288.park@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 **************************************************************************/
36 #define WL_HIDE_DEPRECATED
49 #include <tdm-client-protocol.h>
51 #include "tdm_client.h"
53 #include "tdm_macro.h"
56 #include "tdm_private.h"
57 #include <tbm_surface_internal.h>
59 #define TDM_ARRAY_NTH_DATA(array, type, n) (((type*)((array)->data)) + n)
61 typedef struct _tdm_private_client_vblank tdm_private_client_vblank;
62 typedef struct _tdm_private_client_voutput tdm_private_client_voutput;
64 typedef struct _tdm_private_client {
67 struct wl_display *display;
68 struct wl_event_queue *queue;
69 struct wl_registry *registry;
71 struct list_head output_list;
72 struct list_head voutput_list;
74 unsigned int enable_ttrace;
77 tdm_private_client_vblank *temp_vblank;
80 typedef struct _tdm_private_client_output {
81 struct list_head link;
83 tdm_private_client *private_client;
85 char name[TDM_NAME_LEN];
86 struct wl_tdm_output *output;
90 tdm_output_conn_status connection;
92 struct list_head vblank_list;
93 struct list_head change_handler_list;
96 unsigned int watch_output_changes;
98 tdm_private_client_voutput *voutput;
99 } tdm_private_client_output;
101 typedef struct _tdm_private_client_buffer {
102 struct list_head link;
103 struct wl_buffer *wl_buffer;
104 } tdm_private_client_buffer;
106 struct _tdm_private_client_voutput {
107 struct list_head link;
108 struct wl_tdm_voutput *wl_voutput;
109 struct list_head commit_handler_list;
113 tdm_client_output_mode *modes;
116 unsigned int mmwidth;
117 unsigned int mmheight;
121 struct list_head buffer_list;
123 tdm_private_client_buffer *attach_buffer;
125 tdm_private_client *private_client;
126 tdm_private_client_output *private_output;
127 char name[TDM_NAME_LEN];
131 struct _tdm_private_client_vblank {
132 tdm_private_client_output *private_output;
134 struct wl_tdm_vblank *vblank;
135 struct list_head wait_list;
137 char name[TDM_NAME_LEN];
141 unsigned int enable_fake;
142 unsigned int enable_ttrace;
144 unsigned int started;
150 struct list_head link;
153 typedef struct _tdm_client_output_handler_info {
154 tdm_private_client_output *private_output;
156 tdm_client_output_change_handler func;
159 struct list_head link;
160 struct list_head call_link;
161 } tdm_client_output_handler_info;
163 typedef struct _tdm_client_wait_info {
164 tdm_private_client_vblank *private_vblank;
166 tdm_client_vblank_handler func;
173 struct list_head link;
174 struct list_head call_link;
175 } tdm_client_wait_info;
177 typedef struct _tdm_client_voutput_commit_handler_info {
178 tdm_private_client_voutput *private_voutput;
180 tdm_client_voutput_commit_handler func;
183 struct list_head link;
184 struct list_head call_link;
185 } tdm_client_voutput_commit_handler_info;
188 _tdm_client_check_wl_error(tdm_private_client *private_client, const char *func, int line)
191 const struct wl_interface *intf;
194 err = wl_display_get_error(private_client->display);
198 if (err == EINVAL || err == ENOMEM || err == EFAULT || err == EPROTO) {
199 ec = wl_display_get_protocol_error(private_client->display, &intf, &id);
200 TDM_ERR("[%s,%d] errno(%d) Got protocol error '%u' on interface '%s' (object '%u')",
201 func, line, err, ec, (intf) ? intf->name : "destroyed", id);
203 TDM_ERR("[%s,%d] errno(%d)", func, line, err);
209 #define CHECK_WL_PROTOCOL_ERROR(pc) _tdm_client_check_wl_error(pc, __FUNCTION__, __LINE__)
212 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
214 tdm_private_client_vblank *private_vblank = data;
215 tdm_private_client *private_client;
217 TDM_RETURN_IF_FAIL(private_vblank != NULL);
219 private_vblank->stamp = stamp;
221 TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
222 private_client = private_vblank->private_output->private_client;
224 private_client->stamp = stamp;
227 /* LCOV_EXCL_START */
229 _tdm_client_vblank_wait_list_validation_check(tdm_private_client_vblank *private_vblank)
231 if (private_vblank->wait_list.next == NULL || private_vblank->wait_list.prev == NULL) {
232 TDM_ERR("vblank(%p) wait_list broken. prev(%p), next(%p) pid(%d)",
233 private_vblank, private_vblank->wait_list.prev, private_vblank->wait_list.next, getpid());
240 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
241 uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
242 uint32_t tv_usec, uint32_t error)
244 tdm_private_client_vblank *private_vblank = data;
245 tdm_private_client *private_client;
246 tdm_client_wait_info *w = NULL, *wait_info = NULL;
248 TDM_RETURN_IF_FAIL(private_vblank != NULL);
250 private_client = private_vblank->private_output->private_client;
252 private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
254 TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
255 private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
257 _tdm_client_vblank_wait_list_validation_check(private_vblank);
259 LIST_FOR_EACH_ENTRY(w, &private_vblank->wait_list, link) {
260 if (w->req_id != req_id)
268 TDM_ERR("no wait infomation for req_id(%d)", req_id);
272 if (private_vblank->enable_ttrace)
273 TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
275 if (wait_info->req_time >= private_vblank->last_time)
276 TDM_WRN("'req(%.6f) < last(%.6f)' failed. error(%d)", wait_info->req_time, private_vblank->last_time, error);
278 if (wait_info->need_free)
279 LIST_DEL(&wait_info->link);
281 if (wait_info->func) {
282 pthread_mutex_unlock(&private_client->lock);
283 wait_info->func(private_vblank, error, sequence, tv_sec, tv_usec, wait_info->user_data);
284 pthread_mutex_lock(&private_client->lock);
287 if (wait_info->need_free)
290 wait_info->need_free = 1;
294 /* LCOV_EXCL_START */
296 _tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
298 tdm_private_client_vblank *private_vblank = data;
299 tdm_private_client *private_client;
301 TDM_RETURN_IF_FAIL(private_vblank != NULL);
303 private_vblank->enable_ttrace = enable;
305 TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
306 private_client = private_vblank->private_output->private_client;
308 private_client->enable_ttrace = enable;
312 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
313 _tdm_client_vblank_cb_stamp,
314 _tdm_client_vblank_cb_done,
315 _tdm_client_vblank_cb_ttrace,
319 _tdm_client_output_destroy(tdm_private_client_output *private_output)
321 tdm_private_client_vblank *v = NULL, *vv = NULL;
322 tdm_client_output_handler_info *h = NULL, *hh = NULL;
324 LIST_DEL(&private_output->link);
326 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
327 TDM_ERR("vblanks SHOULD be destroyed first!");
329 v->private_output = NULL;
332 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
337 wl_tdm_output_destroy(private_output->output);
339 free(private_output);
343 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
344 uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
346 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
348 TDM_RETURN_IF_FAIL(private_output != NULL);
350 private_output->width = width;
351 private_output->height = height;
352 private_output->refresh = refresh;
354 if (error != TDM_ERROR_NONE)
355 TDM_INFO("mode event error: %d", error);
357 TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
358 private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
359 width, height, refresh);
363 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
365 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
366 tdm_private_client *private_client;
367 tdm_client_output_handler_info *h = NULL, *hh = NULL;
369 struct list_head call_list;
371 TDM_RETURN_IF_FAIL(private_output != NULL);
373 private_client = private_output->private_client;
375 if (private_output->connection == value && value != TDM_OUTPUT_CONN_STATUS_MODE_SETTED)
378 private_output->connection = value;
380 if (error != TDM_ERROR_NONE)
381 TDM_INFO("connection event error: %d", error);
383 TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
385 wl_proxy_get_id((struct wl_proxy*)private_output->output),
388 LIST_INITHEAD(&call_list);
390 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
391 LIST_ADDTAIL(&h->call_link, &call_list);
395 pthread_mutex_unlock(&private_client->lock);
396 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
398 h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
400 pthread_mutex_lock(&private_client->lock);
404 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
406 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
407 tdm_private_client *private_client;
408 tdm_client_output_handler_info *h = NULL, *hh = NULL;
410 struct list_head call_list;
412 TDM_RETURN_IF_FAIL(private_output != NULL);
414 private_client = private_output->private_client;
416 /* If value is extended value, we handle it as DPMS on in client side
417 * The extended DPMS value is valid only in server side.
418 * Or, need to export to client side also?
420 if (value > TDM_OUTPUT_DPMS_OFF)
421 value = TDM_OUTPUT_DPMS_ON;
423 if (private_output->dpms == value)
426 private_output->dpms = value;
428 if (error != TDM_ERROR_NONE)
429 TDM_INFO("dpms event error: %d", error);
431 TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
433 wl_proxy_get_id((struct wl_proxy*)private_output->output),
436 LIST_INITHEAD(&call_list);
438 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
439 LIST_ADDTAIL(&h->call_link, &call_list);
443 pthread_mutex_unlock(&private_client->lock);
444 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
446 h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
448 pthread_mutex_lock(&private_client->lock);
451 static const struct wl_tdm_output_listener tdm_client_output_listener = {
452 _tdm_client_output_cb_mode,
453 _tdm_client_output_cb_connection,
454 _tdm_client_output_cb_dpms,
458 _tdm_client_cb_global(void *data, struct wl_registry *registry,
459 uint32_t name, const char *interface,
462 tdm_private_client *private_client = data;
464 if (strncmp(interface, "wl_tdm", 6) == 0) {
465 private_client->tdm =
466 wl_registry_bind(registry, name, &wl_tdm_interface, version);
467 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
469 wl_display_flush(private_client->display);
473 /* LCOV_EXCL_START */
475 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
480 static const struct wl_registry_listener tdm_client_registry_listener = {
481 _tdm_client_cb_global,
482 _tdm_client_cb_global_remove
486 tdm_client_create(tdm_error *error)
488 tdm_private_client *private_client;
490 private_client = calloc(1, sizeof *private_client);
491 if (!private_client) {
492 /* LCOV_EXCL_START */
494 TDM_ERR("alloc failed");
496 *error = TDM_ERROR_OUT_OF_MEMORY;
502 if (pthread_mutex_init(&private_client->lock, NULL)) {
503 TDM_ERR("mutex init failed: %m");
504 free(private_client);
506 *error = TDM_ERROR_OUT_OF_MEMORY;
510 LIST_INITHEAD(&private_client->output_list);
511 LIST_INITHEAD(&private_client->voutput_list);
513 private_client->display = wl_display_connect("tdm-socket");
514 TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
516 private_client->queue = wl_display_create_queue(private_client->display);
517 TDM_GOTO_IF_FAIL(private_client->queue != NULL, create_failed);
519 private_client->registry = wl_display_get_registry(private_client->display);
520 TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
522 wl_registry_add_listener(private_client->registry,
523 &tdm_client_registry_listener, private_client);
524 wl_display_roundtrip(private_client->display);
526 if (CHECK_WL_PROTOCOL_ERROR(private_client))
529 /* check global objects */
530 TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
533 *error = TDM_ERROR_NONE;
535 return (tdm_client*)private_client;
537 tdm_client_destroy((tdm_client*)private_client);
539 *error = TDM_ERROR_OPERATION_FAILED;
544 tdm_client_destroy(tdm_client *client)
546 tdm_private_client *private_client = (tdm_private_client*)client;
547 tdm_private_client_output *o = NULL, *oo = NULL;
548 tdm_private_client_voutput *vo = NULL, *voo = NULL;
553 pthread_mutex_lock(&private_client->lock);
555 if (private_client->temp_vblank) {
556 pthread_mutex_unlock(&private_client->lock);
557 tdm_client_vblank_destroy(private_client->temp_vblank);
558 pthread_mutex_lock(&private_client->lock);
561 LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
562 _tdm_client_output_destroy(o);
565 LIST_FOR_EACH_ENTRY_SAFE(vo, voo, &private_client->voutput_list, link) {
566 tdm_client_voutput_destroy(vo);
569 if (private_client->tdm)
570 wl_tdm_destroy(private_client->tdm);
571 if (private_client->registry)
572 wl_registry_destroy(private_client->registry);
573 if (private_client->queue)
574 wl_event_queue_destroy(private_client->queue);
575 if (private_client->display)
576 wl_display_disconnect(private_client->display);
578 pthread_mutex_unlock(&private_client->lock);
579 pthread_mutex_destroy(&private_client->lock);
581 free(private_client);
585 tdm_client_get_fd(tdm_client *client, int *fd)
587 tdm_private_client *private_client;
589 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
590 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
592 private_client = (tdm_private_client*)client;
594 pthread_mutex_lock(&private_client->lock);
596 *fd = wl_display_get_fd(private_client->display);
598 pthread_mutex_unlock(&private_client->lock);
601 return TDM_ERROR_OPERATION_FAILED;
603 return TDM_ERROR_NONE;
607 tdm_client_handle_events(tdm_client *client)
609 tdm_private_client *private_client;
611 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
613 /* LCOV_EXCL_START */
614 private_client = (tdm_private_client*)client;
616 pthread_mutex_lock(&private_client->lock);
618 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
619 pthread_mutex_unlock(&private_client->lock);
620 return TDM_ERROR_PROTOCOL_ERROR;
623 if (private_client->enable_ttrace)
624 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
626 wl_display_dispatch(private_client->display);
628 if (private_client->enable_ttrace)
629 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
631 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
632 pthread_mutex_unlock(&private_client->lock);
633 return TDM_ERROR_PROTOCOL_ERROR;
636 pthread_mutex_unlock(&private_client->lock);
638 return TDM_ERROR_NONE;
643 _tdm_client_poll(struct wl_display *display, short int events, int timeout)
646 struct pollfd pfd[1];
648 pfd[0].fd = wl_display_get_fd(display);
649 pfd[0].events = events;
651 ret = poll(pfd, 1, timeout);
652 } while (ret == -1 && errno == EINTR);
658 _tdm_client_dispatch_timeout(tdm_private_client *private_client, int timeout)
661 struct wl_display *display = private_client->display;
663 if (wl_display_prepare_read(display) == -1) {
664 if (wl_display_dispatch_pending(display) > 0)
665 return TDM_ERROR_NONE;
667 return TDM_ERROR_OPERATION_FAILED;
671 ret = wl_display_flush(display);
673 if (ret != -1 || errno != EAGAIN)
676 if (_tdm_client_poll(display, POLLOUT, -1) == -1) {
677 wl_display_cancel_read(display);
678 TDM_ERR("_tdm_client_poll failed");
679 return TDM_ERROR_OPERATION_FAILED;
683 /* Don't stop if flushing hits an EPIPE; continue so we can read any
684 * protocol error that may have triggered it. */
685 if (ret < 0 && errno != EPIPE) {
686 TDM_ERR("ret(%d) errno(%d)", ret, errno);
687 wl_display_cancel_read(display);
688 return TDM_ERROR_OPERATION_FAILED;
691 ret = _tdm_client_poll(display, POLLIN, timeout);
693 wl_display_cancel_read(display);
695 TDM_ERR("_tdm_client_poll timeout.");
696 return TDM_ERROR_TIMEOUT;
698 TDM_ERR("_tdm_client_poll failed. (ret:%d)", ret);
699 return TDM_ERROR_OPERATION_FAILED;
703 if (wl_display_read_events(display) == -1) {
704 TDM_ERR("wl_display_read_events failed");
705 return TDM_ERROR_OPERATION_FAILED;
708 ret = wl_display_dispatch_pending(display);
711 TDM_ERR("_tdm_client_dispatch_timeout failed");
712 return TDM_ERROR_OPERATION_FAILED;
715 return TDM_ERROR_NONE;
719 tdm_client_handle_events_timeout(tdm_client *client, int ms_timeout)
721 tdm_private_client *private_client;
723 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
725 private_client = (tdm_private_client*)client;
727 pthread_mutex_lock(&private_client->lock);
729 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
730 pthread_mutex_unlock(&private_client->lock);
731 return TDM_ERROR_PROTOCOL_ERROR;
734 if (private_client->enable_ttrace)
735 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp);
737 ret = _tdm_client_dispatch_timeout(private_client, ms_timeout);
739 if (private_client->enable_ttrace)
740 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp);
742 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
743 pthread_mutex_unlock(&private_client->lock);
744 return TDM_ERROR_PROTOCOL_ERROR;
747 pthread_mutex_unlock(&private_client->lock);
752 typedef struct _tdm_client_vblank_temp {
753 tdm_client_vblank_handler2 func;
755 } tdm_client_vblank_temp;
757 /* LCOV_EXCL_START */
759 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
760 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
762 tdm_client_vblank_temp *vblank_temp = user_data;
764 TDM_RETURN_IF_FAIL(vblank_temp != NULL);
765 TDM_RETURN_IF_FAIL(vblank != NULL);
767 if (vblank_temp->func)
768 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
774 /* LCOV_EXCL_START */ /* deprecated */
776 tdm_client_wait_vblank(tdm_client *client, char *name,
777 int sw_timer, int interval, int sync,
778 tdm_client_vblank_handler2 func, void *user_data)
780 tdm_private_client *private_client = (tdm_private_client*)client;
781 tdm_client_output *output;
782 tdm_client_vblank_temp *vblank_temp;
785 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
786 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
787 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
789 if (CHECK_WL_PROTOCOL_ERROR(private_client))
790 return TDM_ERROR_PROTOCOL_ERROR;
792 if (!private_client->temp_vblank) {
793 output = tdm_client_get_output(client, name, &ret);
794 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
796 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
797 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
800 tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
801 tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
803 vblank_temp = calloc(1, sizeof *vblank_temp);
804 TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
806 vblank_temp->func = func;
807 vblank_temp->user_data = user_data;
809 return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
814 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
816 tdm_private_client *private_client;
817 tdm_private_client_output *private_output = NULL;
818 struct wl_proxy *wrapper;
821 *error = TDM_ERROR_NONE;
824 TDM_ERR("'!client' failed");
826 *error = TDM_ERROR_INVALID_PARAMETER;
830 private_client = (tdm_private_client*)client;
832 pthread_mutex_lock(&private_client->lock);
834 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
836 *error = TDM_ERROR_PROTOCOL_ERROR;
837 pthread_mutex_unlock(&private_client->lock);
843 } else if (!strncmp(name, "primary", 7) || !strncmp(name, "default", 7)) {
844 TDM_DBG("get primary or default output");
846 tdm_private_client_voutput *private_voutput = NULL;
849 LIST_FOR_EACH_ENTRY(private_voutput, &private_client->voutput_list, link) {
850 if (!strncmp(private_voutput->name, name, TDM_NAME_LEN)) {
857 *error = TDM_ERROR_INVALID_PARAMETER;
858 pthread_mutex_unlock(&private_client->lock);
863 LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
864 if (!strncmp(private_output->name, name, TDM_NAME_LEN)) {
865 pthread_mutex_unlock(&private_client->lock);
866 return (tdm_client_output*)private_output;
870 wrapper = wl_proxy_create_wrapper(private_client->tdm);
872 TDM_ERR("create output_wrapper failed");
874 *error = TDM_ERROR_OUT_OF_MEMORY;
875 pthread_mutex_unlock(&private_client->lock);
879 wl_proxy_set_queue(wrapper, private_client->queue);
881 private_output = calloc(1, sizeof *private_output);
882 if (!private_output) {
883 /* LCOV_EXCL_START */
884 wl_proxy_wrapper_destroy(wrapper);
885 TDM_ERR("alloc failed");
887 *error = TDM_ERROR_OUT_OF_MEMORY;
888 pthread_mutex_unlock(&private_client->lock);
894 private_output->private_client = private_client;
896 snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
897 private_output->output = wl_tdm_create_output((struct wl_tdm *)wrapper, private_output->name);
898 wl_proxy_wrapper_destroy(wrapper);
899 if (!private_output->output) {
900 /* LCOV_EXCL_START */
902 TDM_ERR("couldn't create output resource");
903 free(private_output);
905 *error = TDM_ERROR_OUT_OF_MEMORY;
906 pthread_mutex_unlock(&private_client->lock);
912 LIST_INITHEAD(&private_output->vblank_list);
913 LIST_INITHEAD(&private_output->change_handler_list);
915 wl_tdm_output_add_listener(private_output->output,
916 &tdm_client_output_listener, private_output);
917 wl_display_roundtrip_queue(private_client->display, private_client->queue);
919 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
921 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
922 wl_tdm_output_destroy(private_output->output);
923 free(private_output);
925 *error = TDM_ERROR_PROTOCOL_ERROR;
926 pthread_mutex_unlock(&private_client->lock);
930 LIST_ADDTAIL(&private_output->link, &private_client->output_list);
932 pthread_mutex_unlock(&private_client->lock);
934 return (tdm_client_output*)private_output;
938 tdm_client_output_add_change_handler(tdm_client_output *output,
939 tdm_client_output_change_handler func,
942 tdm_private_client_output *private_output;
943 tdm_private_client *private_client;
944 tdm_client_output_handler_info *h = NULL;
946 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
947 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
949 private_output = (tdm_private_client_output*)output;
950 private_client = private_output->private_client;
952 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
953 if (h->func == func && h->user_data == user_data) {
954 TDM_ERR("can't add twice");
955 return TDM_ERROR_BAD_REQUEST;
959 h = calloc(1, sizeof *h);
960 TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
962 pthread_mutex_lock(&private_client->lock);
964 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
966 pthread_mutex_unlock(&private_client->lock);
967 return TDM_ERROR_PROTOCOL_ERROR;
970 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
971 wl_tdm_output_watch_output_changes(private_output->output, 1);
972 wl_display_roundtrip_queue(private_client->display, private_client->queue);
974 /* TODO: this is very tricky.
975 * If a client adds the change_handler, we might be able to guess that
976 * the client will watch the tdm client's fd and handle tdm events in
977 * event loop. Otherwise, we CAN'T make sure if a client has event loop
978 * which handles tdm events.
980 private_output->watch_output_changes = 1;
983 h->private_output = private_output;
985 h->user_data = user_data;
986 LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
987 LIST_INITHEAD(&h->call_link);
989 pthread_mutex_unlock(&private_client->lock);
991 return TDM_ERROR_NONE;
995 tdm_client_output_remove_change_handler(tdm_client_output *output,
996 tdm_client_output_change_handler func,
999 tdm_private_client_output *private_output;
1000 tdm_private_client *private_client;
1001 tdm_client_output_handler_info *h = NULL;
1003 TDM_RETURN_IF_FAIL(output != NULL);
1004 TDM_RETURN_IF_FAIL(func != NULL);
1006 private_output = (tdm_private_client_output*)output;
1007 private_client = private_output->private_client;
1009 pthread_mutex_lock(&private_client->lock);
1011 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
1012 if (h->func != func || h->user_data != user_data)
1018 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
1019 private_output->watch_output_changes = 0;
1020 if (!CHECK_WL_PROTOCOL_ERROR(private_client)) {
1021 wl_tdm_output_watch_output_changes(private_output->output, 0);
1022 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1026 pthread_mutex_unlock(&private_client->lock);
1031 pthread_mutex_unlock(&private_client->lock);
1035 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
1037 tdm_private_client_output *private_output;
1038 tdm_private_client *private_client;
1040 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1041 TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
1043 private_output = (tdm_private_client_output*)output;
1044 private_client = private_output->private_client;
1046 pthread_mutex_lock(&private_client->lock);
1048 if (private_output->watch_output_changes) {
1049 *refresh = private_output->refresh;
1050 pthread_mutex_unlock(&private_client->lock);
1051 return TDM_ERROR_NONE;
1054 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1055 pthread_mutex_unlock(&private_client->lock);
1056 return TDM_ERROR_PROTOCOL_ERROR;
1059 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1060 wl_tdm_output_get_mode(private_output->output);
1061 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1062 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1064 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1065 pthread_mutex_unlock(&private_client->lock);
1066 return TDM_ERROR_PROTOCOL_ERROR;
1069 *refresh = private_output->refresh;
1071 pthread_mutex_unlock(&private_client->lock);
1073 return TDM_ERROR_NONE;
1077 tdm_client_output_get_mode(tdm_client_output *output, unsigned int *width, unsigned int *height)
1079 tdm_private_client_output *private_output;
1080 tdm_private_client *private_client;
1082 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1083 TDM_RETURN_VAL_IF_FAIL(width != NULL, TDM_ERROR_INVALID_PARAMETER);
1084 TDM_RETURN_VAL_IF_FAIL(height != NULL, TDM_ERROR_INVALID_PARAMETER);
1086 private_output = (tdm_private_client_output*)output;
1087 private_client = private_output->private_client;
1089 pthread_mutex_lock(&private_client->lock);
1091 if (private_output->watch_output_changes) {
1092 *width = private_output->width;
1093 *height = private_output->height;
1094 pthread_mutex_unlock(&private_client->lock);
1095 return TDM_ERROR_NONE;
1098 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1099 pthread_mutex_unlock(&private_client->lock);
1100 return TDM_ERROR_PROTOCOL_ERROR;
1103 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1104 wl_tdm_output_get_mode(private_output->output);
1105 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1106 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1108 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1109 pthread_mutex_unlock(&private_client->lock);
1110 return TDM_ERROR_PROTOCOL_ERROR;
1113 *width = private_output->width;
1114 *height = private_output->height;
1116 pthread_mutex_unlock(&private_client->lock);
1118 return TDM_ERROR_NONE;
1122 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
1124 tdm_private_client_output *private_output;
1125 tdm_private_client *private_client;
1127 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1128 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
1130 private_output = (tdm_private_client_output*)output;
1131 private_client = private_output->private_client;
1133 pthread_mutex_lock(&private_client->lock);
1135 if (private_output->watch_output_changes) {
1136 *status = private_output->connection;
1137 pthread_mutex_unlock(&private_client->lock);
1138 return TDM_ERROR_NONE;
1141 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1142 pthread_mutex_unlock(&private_client->lock);
1143 return TDM_ERROR_PROTOCOL_ERROR;
1146 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1147 wl_tdm_output_get_connection(private_output->output);
1148 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1149 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1151 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1152 pthread_mutex_unlock(&private_client->lock);
1153 return TDM_ERROR_PROTOCOL_ERROR;
1156 *status = private_output->connection;
1158 pthread_mutex_unlock(&private_client->lock);
1160 return TDM_ERROR_NONE;
1164 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
1166 tdm_private_client_output *private_output;
1167 tdm_private_client *private_client;
1169 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1170 TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
1172 private_output = (tdm_private_client_output*)output;
1173 private_client = private_output->private_client;
1175 if (private_output->watch_output_changes) {
1176 *dpms = private_output->dpms;
1177 return TDM_ERROR_NONE;
1180 pthread_mutex_lock(&private_client->lock);
1182 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1183 pthread_mutex_unlock(&private_client->lock);
1184 return TDM_ERROR_PROTOCOL_ERROR;
1187 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1188 wl_tdm_output_get_dpms(private_output->output);
1189 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1190 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1192 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1193 pthread_mutex_unlock(&private_client->lock);
1194 return TDM_ERROR_PROTOCOL_ERROR;
1197 *dpms = private_output->dpms;
1199 pthread_mutex_unlock(&private_client->lock);
1201 return TDM_ERROR_NONE;
1205 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
1207 tdm_private_client *private_client;
1208 tdm_private_client_output *private_output;
1209 tdm_private_client_vblank *private_vblank;
1210 struct wl_proxy *wrapper;
1213 *error = TDM_ERROR_NONE;
1216 TDM_ERR("'!output' failed");
1218 *error = TDM_ERROR_INVALID_PARAMETER;
1222 private_output = (tdm_private_client_output*)output;
1223 private_client = private_output->private_client;
1225 pthread_mutex_lock(&private_client->lock);
1227 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1229 *error = TDM_ERROR_PROTOCOL_ERROR;
1230 pthread_mutex_unlock(&private_client->lock);
1234 wrapper = wl_proxy_create_wrapper(private_output->output);
1236 TDM_ERR("create output_wrapper failed");
1238 *error = TDM_ERROR_OUT_OF_MEMORY;
1239 pthread_mutex_unlock(&private_client->lock);
1243 wl_proxy_set_queue(wrapper, private_client->queue);
1245 private_vblank = calloc(1, sizeof *private_vblank);
1246 if (!private_vblank) {
1247 /* LCOV_EXCL_START */
1249 TDM_ERR("alloc failed");
1250 wl_proxy_wrapper_destroy(wrapper);
1252 *error = TDM_ERROR_OUT_OF_MEMORY;
1253 pthread_mutex_unlock(&private_client->lock);
1256 /* LCOV_EXCL_STOP */
1259 private_vblank->private_output = private_output;
1261 private_vblank->vblank = wl_tdm_output_create_vblank((struct wl_tdm_output*)wrapper);
1262 wl_proxy_wrapper_destroy(wrapper);
1263 if (!private_vblank->vblank) {
1264 /* LCOV_EXCL_START */
1266 TDM_ERR("couldn't create vblank resource");
1267 free(private_vblank);
1269 *error = TDM_ERROR_OUT_OF_MEMORY;
1270 pthread_mutex_unlock(&private_client->lock);
1273 /* LCOV_EXCL_STOP */
1277 private_vblank->fps = private_output->refresh;
1278 private_vblank->offset = 0;
1279 private_vblank->enable_fake = 0;
1281 LIST_INITHEAD(&private_vblank->wait_list);
1283 wl_tdm_vblank_add_listener(private_vblank->vblank,
1284 &tdm_client_vblank_listener, private_vblank);
1285 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1287 wl_proxy_set_queue((struct wl_proxy *)private_vblank->vblank, NULL);
1289 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1290 wl_tdm_vblank_destroy(private_vblank->vblank);
1291 free(private_vblank);
1293 *error = TDM_ERROR_PROTOCOL_ERROR;
1294 pthread_mutex_unlock(&private_client->lock);
1298 LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
1300 pthread_mutex_unlock(&private_client->lock);
1302 return (tdm_client_vblank*)private_vblank;
1306 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
1308 tdm_private_client_vblank *private_vblank;
1309 tdm_private_client_output *private_output;
1310 tdm_private_client *private_client;
1311 tdm_client_wait_info *w = NULL, *ww = NULL;
1313 TDM_RETURN_IF_FAIL(vblank != NULL);
1315 private_vblank = vblank;
1317 private_output = private_vblank->private_output;
1318 if (!private_output) {
1319 TDM_WRN("private_output is already destroyed.");
1320 free(private_vblank);
1324 private_client = private_output->private_client;
1325 if (!private_client) {
1326 TDM_WRN("private_client is already destroyed.");
1327 free(private_vblank);
1331 pthread_mutex_lock(&private_client->lock);
1333 LIST_DEL(&private_vblank->link);
1335 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
1340 wl_tdm_vblank_destroy(private_vblank->vblank);
1342 free(private_vblank);
1344 pthread_mutex_unlock(&private_client->lock);
1348 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
1350 tdm_private_client_vblank *private_vblank;
1351 tdm_private_client *private_client;
1353 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1355 private_vblank = vblank;
1356 private_client = private_vblank->private_output->private_client;
1358 pthread_mutex_lock(&private_client->lock);
1360 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1361 pthread_mutex_unlock(&private_client->lock);
1362 return TDM_ERROR_PROTOCOL_ERROR;
1366 name = TDM_VBLANK_DEFAULT_NAME;
1368 strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
1369 private_vblank->name[TDM_NAME_LEN - 1] = '\0';
1371 wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
1373 pthread_mutex_unlock(&private_client->lock);
1375 return TDM_ERROR_NONE;
1379 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
1381 tdm_private_client_vblank *private_vblank;
1382 tdm_private_client *private_client;
1384 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1386 private_vblank = vblank;
1387 private_client = private_vblank->private_output->private_client;
1389 pthread_mutex_lock(&private_client->lock);
1390 private_vblank->sync = sync;
1391 pthread_mutex_unlock(&private_client->lock);
1393 return TDM_ERROR_NONE;
1397 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
1399 tdm_private_client_vblank *private_vblank;
1400 tdm_private_client *private_client;
1402 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1403 TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
1405 private_vblank = vblank;
1406 private_client = private_vblank->private_output->private_client;
1408 pthread_mutex_lock(&private_client->lock);
1410 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1411 pthread_mutex_unlock(&private_client->lock);
1412 return TDM_ERROR_PROTOCOL_ERROR;
1415 if (private_vblank->fps == fps) {
1416 pthread_mutex_unlock(&private_client->lock);
1417 return TDM_ERROR_NONE;
1420 private_vblank->fps = fps;
1422 wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
1424 pthread_mutex_unlock(&private_client->lock);
1426 return TDM_ERROR_NONE;
1430 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
1432 tdm_private_client_vblank *private_vblank;
1433 tdm_private_client *private_client;
1435 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1437 private_vblank = vblank;
1438 TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
1440 private_client = private_vblank->private_output->private_client;
1442 pthread_mutex_lock(&private_client->lock);
1444 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1445 pthread_mutex_unlock(&private_client->lock);
1446 return TDM_ERROR_PROTOCOL_ERROR;
1449 if (private_vblank->offset == offset_ms) {
1450 pthread_mutex_unlock(&private_client->lock);
1451 return TDM_ERROR_NONE;
1454 private_vblank->offset = offset_ms;
1456 wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
1458 pthread_mutex_unlock(&private_client->lock);
1460 return TDM_ERROR_NONE;
1464 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
1466 tdm_private_client_vblank *private_vblank;
1467 tdm_private_client *private_client;
1469 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1471 private_vblank = vblank;
1472 private_client = private_vblank->private_output->private_client;
1474 pthread_mutex_lock(&private_client->lock);
1476 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1477 pthread_mutex_unlock(&private_client->lock);
1478 return TDM_ERROR_PROTOCOL_ERROR;
1481 if (private_vblank->enable_fake == enable_fake) {
1482 pthread_mutex_unlock(&private_client->lock);
1483 return TDM_ERROR_NONE;
1486 private_vblank->enable_fake = enable_fake;
1488 wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
1490 pthread_mutex_unlock(&private_client->lock);
1492 return TDM_ERROR_NONE;
1496 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
1498 tdm_private_client *private_client;
1499 tdm_private_client_output *private_output;
1500 tdm_private_client_vblank *private_vblank;
1501 tdm_client_wait_info *w;
1503 unsigned int req_sec, req_usec;
1506 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1507 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1508 /* can't support "interval 0" and "getting current_msc" things because
1509 * there is a socket communication between TDM client and server. It's impossible
1510 * to return the current msc or sequence immediately.
1512 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
1514 private_vblank = vblank;
1515 private_output = private_vblank->private_output;
1516 private_client = private_output->private_client;
1518 pthread_mutex_lock(&private_client->lock);
1520 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1521 pthread_mutex_unlock(&private_client->lock);
1522 return TDM_ERROR_PROTOCOL_ERROR;
1525 if (!private_vblank->started)
1526 private_vblank->started = 1;
1528 if (!private_vblank->enable_fake) {
1529 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1530 TDM_ERR("output disconnected");
1531 pthread_mutex_unlock(&private_client->lock);
1532 return TDM_ERROR_OUTPUT_DISCONNECTED;
1534 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1535 TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1536 pthread_mutex_unlock(&private_client->lock);
1537 return TDM_ERROR_DPMS_OFF;
1541 w = calloc(1, sizeof *w);
1543 /* LCOV_EXCL_START */
1545 TDM_ERR("alloc failed");
1546 pthread_mutex_unlock(&private_client->lock);
1547 return TDM_ERROR_OUT_OF_MEMORY;
1549 /* LCOV_EXCL_STOP */
1552 w->private_vblank = private_vblank;
1554 w->user_data = user_data;
1556 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1557 LIST_INITHEAD(&w->call_link);
1559 clock_gettime(CLOCK_MONOTONIC, &tp);
1560 req_sec = (unsigned int)tp.tv_sec;
1561 req_usec = (unsigned int)(tp.tv_nsec / 1000);
1563 w->req_id = ++private_output->req_id;
1564 w->req_time = TDM_TIME(req_sec, req_usec);
1565 w->need_free = (private_vblank->sync) ? 0 : 1;
1567 wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
1569 if (private_vblank->enable_ttrace)
1570 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1572 TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
1573 vblank, interval, w->req_id, w->req_time);
1575 private_vblank->req_time = w->req_time;
1577 if (private_vblank->last_time >= w->req_time)
1578 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1580 if (!private_vblank->sync) {
1581 wl_display_flush(private_client->display);
1582 pthread_mutex_unlock(&private_client->lock);
1583 return TDM_ERROR_NONE;
1586 /* LCOV_EXCL_START */
1588 while (ret != -1 && !w->need_free)
1589 ret = wl_display_dispatch(private_client->display);
1591 clock_gettime(CLOCK_MONOTONIC, &tp);
1592 TDM_DBG("block during %d us",
1593 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1594 - (req_sec * 1000000 + req_usec));
1599 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1600 pthread_mutex_unlock(&private_client->lock);
1601 return TDM_ERROR_PROTOCOL_ERROR;
1604 pthread_mutex_unlock(&private_client->lock);
1606 return TDM_ERROR_NONE;
1608 /* LCOV_EXCL_STOP */
1612 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
1613 tdm_client_vblank_handler func, void *user_data)
1615 tdm_private_client *private_client;
1616 tdm_private_client_output *private_output;
1617 tdm_private_client_vblank *private_vblank;
1618 tdm_client_wait_info *w;
1620 unsigned int req_sec, req_usec;
1623 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1624 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1626 private_vblank = vblank;
1627 private_output = private_vblank->private_output;
1628 private_client = private_output->private_client;
1630 pthread_mutex_lock(&private_client->lock);
1632 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1633 pthread_mutex_unlock(&private_client->lock);
1634 return TDM_ERROR_PROTOCOL_ERROR;
1637 if (!private_vblank->started)
1638 private_vblank->started = 1;
1640 if (!private_vblank->enable_fake) {
1641 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1642 TDM_ERR("output disconnected");
1643 pthread_mutex_unlock(&private_client->lock);
1644 return TDM_ERROR_OUTPUT_DISCONNECTED;
1646 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1647 TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1648 pthread_mutex_unlock(&private_client->lock);
1649 return TDM_ERROR_DPMS_OFF;
1653 w = calloc(1, sizeof *w);
1655 /* LCOV_EXCL_START */
1657 TDM_ERR("alloc failed");
1658 pthread_mutex_unlock(&private_client->lock);
1659 return TDM_ERROR_OUT_OF_MEMORY;
1661 /* LCOV_EXCL_STOP */
1664 w->private_vblank = private_vblank;
1666 w->user_data = user_data;
1668 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1669 LIST_INITHEAD(&w->call_link);
1671 clock_gettime(CLOCK_MONOTONIC, &tp);
1672 req_sec = (unsigned int)tp.tv_sec;
1673 req_usec = (unsigned int)(tp.tv_nsec / 1000);
1675 w->req_id = ++private_output->req_id;
1676 w->req_time = TDM_TIME(req_sec, req_usec);
1677 w->need_free = (private_vblank->sync) ? 0 : 1;
1679 wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1681 if (private_vblank->enable_ttrace)
1682 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1684 TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1685 vblank, sequence, w->req_id, w->req_time);
1687 private_vblank->req_time = w->req_time;
1689 if (private_vblank->last_time >= w->req_time)
1690 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1692 if (!private_vblank->sync) {
1693 wl_display_flush(private_client->display);
1694 pthread_mutex_unlock(&private_client->lock);
1695 return TDM_ERROR_NONE;
1698 /* LCOV_EXCL_START */
1700 while (ret != -1 && !w->need_free)
1701 ret = wl_display_dispatch(private_client->display);
1703 clock_gettime(CLOCK_MONOTONIC, &tp);
1704 TDM_DBG("block during %d us",
1705 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1706 - (req_sec * 1000000 + req_usec));
1711 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1712 pthread_mutex_unlock(&private_client->lock);
1713 return TDM_ERROR_PROTOCOL_ERROR;
1716 pthread_mutex_unlock(&private_client->lock);
1718 return TDM_ERROR_NONE;
1720 /* LCOV_EXCL_STOP */
1724 tdm_client_vblank_is_waiting(tdm_client_vblank *vblank)
1726 tdm_private_client_vblank *private_vblank;
1728 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, 0);
1730 private_vblank = vblank;
1732 return (LIST_LENGTH(&private_vblank->wait_list) > 0) ? 1 : 0;
1735 static tbm_surface_h
1736 _tdm_client_voutput_create_surface_from_param(tbm_bufmgr bufmgr,
1744 struct wl_array *plane_buf_idx,
1745 struct wl_array *plane_offset,
1746 struct wl_array *plane_stride,
1747 struct wl_array *plane_size,
1754 int32_t names[TBM_SURF_PLANE_MAX] = { -1, -1, -1, -1};
1755 tbm_surface_info_s info = { 0, };
1756 tbm_bo bos[TBM_SURF_PLANE_MAX];
1757 int i, numPlane, numName;
1758 tbm_surface_h tbm_surface;
1760 numPlane = tbm_surface_internal_get_num_planes(format);
1761 TDM_RETURN_VAL_IF_FAIL(numPlane == num_plane, NULL);
1764 info.height = height;
1765 info.format = format;
1768 info.num_planes = numPlane;
1771 for (i = 0; i < numPlane; i++) {
1772 info.planes[i].offset = *TDM_ARRAY_NTH_DATA(plane_offset, int32_t, i);
1773 info.planes[i].stride = *TDM_ARRAY_NTH_DATA(plane_stride, int32_t, i);
1774 info.planes[i].size = *TDM_ARRAY_NTH_DATA(plane_size, int32_t, i);
1783 for (i = 0; i < numName; i++) {
1785 bos[i] = tbm_bo_import_fd(bufmgr, names[i]);
1787 bos[i] = tbm_bo_import(bufmgr, names[i]);
1790 tbm_surface = tbm_surface_internal_create_with_bos(&info, bos, numName);
1791 if (tbm_surface == NULL) {
1806 for (i = 0; i < numName; i++)
1807 tbm_bo_unref(bos[i]);
1812 tdm_client_voutput_cb_buffer_import_with_id(void *data,
1813 struct wl_tdm_voutput *wl_voutput,
1814 struct wl_buffer *wl_buffer,
1821 struct wl_array *plane_buf_idx,
1822 struct wl_array *plane_offset,
1823 struct wl_array *plane_stride,
1824 struct wl_array *plane_size,
1831 tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data;
1832 tdm_private_client_buffer *buffer = NULL;
1833 tbm_surface_h tbm_surface;
1835 TDM_RETURN_IF_FAIL(private_voutput != NULL);
1837 buffer = calloc(1, sizeof *buffer);
1838 TDM_RETURN_IF_FAIL(buffer != NULL);
1840 tbm_surface = _tdm_client_voutput_create_surface_from_param(private_voutput->bufmgr, 0,
1841 width, height, format, bpp, size,
1843 plane_buf_idx, plane_offset, plane_stride, plane_size,
1847 TDM_GOTO_IF_FAIL(tbm_surface != NULL, fail);
1849 tbm_surface_internal_ref(tbm_surface);
1850 wl_buffer_set_user_data(wl_buffer, tbm_surface);
1852 buffer->wl_buffer = wl_buffer;
1854 LIST_ADDTAIL(&buffer->link, &private_voutput->buffer_list);
1863 wl_buffer_destroy(wl_buffer);
1867 tdm_client_voutput_cb_buffer_import_with_fd(void *data,
1868 struct wl_tdm_voutput *wl_voutput,
1869 struct wl_buffer *wl_buffer,
1876 struct wl_array *plane_buf_idx,
1877 struct wl_array *plane_offset,
1878 struct wl_array *plane_stride,
1879 struct wl_array *plane_size,
1886 tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data;
1887 tdm_private_client_buffer *buffer = NULL;
1888 tbm_surface_h tbm_surface;
1890 TDM_RETURN_IF_FAIL(private_voutput != NULL);
1892 buffer = calloc(1, sizeof *buffer);
1893 TDM_RETURN_IF_FAIL(buffer != NULL);
1895 tbm_surface = _tdm_client_voutput_create_surface_from_param(private_voutput->bufmgr, 1,
1896 width, height, format, bpp, size,
1898 plane_buf_idx, plane_offset, plane_stride, plane_size,
1902 TDM_GOTO_IF_FAIL(tbm_surface != NULL, fail);
1904 tbm_surface_internal_ref(tbm_surface);
1905 wl_buffer_set_user_data(wl_buffer, tbm_surface);
1907 buffer->wl_buffer = wl_buffer;
1909 LIST_ADDTAIL(&buffer->link, &private_voutput->buffer_list);
1918 wl_buffer_destroy(wl_buffer);
1922 tdm_client_voutput_cb_buffer_destroy(void *data,
1923 struct wl_tdm_voutput *wl_voutput,
1924 struct wl_buffer *wl_buffer)
1926 tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data;
1927 tdm_private_client_buffer *cb = NULL, *cbb = NULL;
1928 tbm_surface_h tbm_surface = NULL;
1930 TDM_RETURN_IF_FAIL(private_voutput != NULL);
1932 LIST_FOR_EACH_ENTRY_SAFE(cb, cbb, &private_voutput->buffer_list, link) {
1933 if (wl_buffer == cb->wl_buffer) {
1934 LIST_DEL(&cb->link);
1936 tbm_surface = (tbm_surface_h)wl_buffer_get_user_data(wl_buffer);
1938 tbm_surface_internal_unref(tbm_surface);
1940 wl_buffer_set_user_data(wl_buffer, NULL);
1941 wl_buffer_destroy(wl_buffer);
1953 tdm_client_voutput_cb_attach_buffer(void *data,
1954 struct wl_tdm_voutput *wl_voutput,
1955 struct wl_buffer *wl_buffer)
1957 tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data;
1958 tdm_private_client_buffer *cb = NULL, *cbb = NULL;
1960 TDM_RETURN_IF_FAIL(private_voutput != NULL);
1962 LIST_FOR_EACH_ENTRY_SAFE(cb, cbb, &private_voutput->buffer_list, link) {
1963 if (wl_buffer == cb->wl_buffer) {
1964 private_voutput->attach_buffer = cb;
1973 tdm_client_voutput_cb_commit(void *data, struct wl_tdm_voutput *wl_voutput)
1975 tdm_private_client_voutput *private_voutput;
1976 tdm_private_client *private_client;
1977 tbm_surface_h buffer = NULL;
1978 tdm_client_voutput_commit_handler_info *h = NULL, *hh = NULL;
1979 struct list_head call_list;
1981 private_voutput = (tdm_private_client_voutput *)data;
1982 TDM_RETURN_IF_FAIL(private_voutput != NULL);
1983 TDM_RETURN_IF_FAIL(private_voutput->attach_buffer != NULL);
1985 buffer = (tbm_surface_h)wl_buffer_get_user_data(private_voutput->attach_buffer->wl_buffer);
1986 TDM_RETURN_IF_FAIL(buffer != NULL);
1988 tbm_surface_internal_ref(buffer);
1990 private_client = private_voutput->private_client;
1992 LIST_INITHEAD(&call_list);
1994 LIST_FOR_EACH_ENTRY(h, &private_voutput->commit_handler_list, link) {
1995 LIST_ADDTAIL(&h->call_link, &call_list);
1998 pthread_mutex_unlock(&private_client->lock);
1999 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
2001 h->func(private_voutput, buffer, h->user_data);
2004 /* if no added commit_handler call commit done immediately */
2005 if (LIST_IS_EMPTY(&private_voutput->commit_handler_list))
2006 tdm_client_voutput_commit_done(private_voutput);
2008 pthread_mutex_lock(&private_client->lock);
2012 tdm_client_voutput_cb_ack_message(void *data, struct wl_tdm_voutput *wl_voutput, uint32_t msg)
2014 tdm_private_client_voutput *private_voutput = data;
2016 private_voutput->msg = msg;
2019 static const struct wl_tdm_voutput_listener tdm_client_voutput_lisntener = {
2020 tdm_client_voutput_cb_buffer_import_with_id,
2021 tdm_client_voutput_cb_buffer_import_with_fd,
2022 tdm_client_voutput_cb_buffer_destroy,
2023 tdm_client_voutput_cb_attach_buffer,
2024 tdm_client_voutput_cb_commit,
2025 tdm_client_voutput_cb_ack_message
2028 tdm_client_voutput *
2029 tdm_client_create_voutput(tdm_client *client, const char *name, tdm_error *error)
2031 tdm_private_client *private_client;
2032 tdm_private_client_output *private_output = NULL;
2033 tdm_private_client_voutput *private_voutput;
2034 struct wl_proxy *wrapper;
2037 *error = TDM_ERROR_NONE;
2040 TDM_ERR("'!client' failed");
2042 *error = TDM_ERROR_INVALID_PARAMETER;
2047 TDM_ERR("'!name' failed");
2049 *error = TDM_ERROR_INVALID_PARAMETER;
2053 private_client = (tdm_private_client *)client;
2055 pthread_mutex_lock(&private_client->lock);
2057 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
2059 *error = TDM_ERROR_PROTOCOL_ERROR;
2060 pthread_mutex_unlock(&private_client->lock);
2064 LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
2065 if (!strncmp(private_output->name, name, TDM_NAME_LEN)) {
2067 *error = TDM_ERROR_INVALID_PARAMETER; // FIXME define new error type.
2068 pthread_mutex_unlock(&private_client->lock);
2073 wrapper = wl_proxy_create_wrapper(private_client->tdm);
2075 TDM_ERR("create virtual output wrapper failed");
2077 *error = TDM_ERROR_OUT_OF_MEMORY;
2078 pthread_mutex_unlock(&private_client->lock);
2082 wl_proxy_set_queue(wrapper, private_client->queue);
2084 private_voutput = calloc(1, sizeof *private_voutput);
2085 if (!private_voutput) {
2086 /* LOCV_EXCL_START */
2087 wl_proxy_wrapper_destroy(wrapper);
2088 TDM_ERR("alloc failed");
2090 *error = TDM_ERROR_OUT_OF_MEMORY;
2091 pthread_mutex_unlock(&private_client->lock);
2093 /* LOCV_EXCL_STOP */
2096 private_voutput->bufmgr = tbm_bufmgr_init(-1);
2097 if (private_voutput->bufmgr == NULL) {
2098 /* LCOV_EXCL_START */
2099 wl_proxy_wrapper_destroy(wrapper);
2100 TDM_ERR("fail tbm_bufmgr_init");
2101 free(private_voutput);
2103 *error = TDM_ERROR_OUT_OF_MEMORY;
2104 pthread_mutex_unlock(&private_client->lock);
2106 /* LCOV_EXCL_STOP */
2109 LIST_INITHEAD(&private_voutput->commit_handler_list);
2110 LIST_INITHEAD(&private_voutput->buffer_list);
2112 private_voutput->private_client = private_client;
2113 strncpy(private_voutput->name, name, TDM_NAME_LEN - 1);
2114 private_voutput->name[TDM_NAME_LEN - 1] = '\0';
2116 private_voutput->wl_voutput = wl_tdm_create_voutput((struct wl_tdm *)wrapper, name);
2117 wl_proxy_wrapper_destroy(wrapper);
2118 if (!private_voutput->wl_voutput) {
2119 /* LCOV_EXCL_START */
2120 TDM_ERR("couldn't create voutput resource");
2121 free(private_voutput);
2123 *error = TDM_ERROR_OUT_OF_MEMORY;
2124 pthread_mutex_unlock(&private_client->lock);
2126 /* LCOV_EXCL_STOP */
2129 wl_tdm_voutput_add_listener(private_voutput->wl_voutput,
2130 &tdm_client_voutput_lisntener, private_voutput);
2131 wl_display_roundtrip_queue(private_client->display, private_client->queue);
2133 wl_proxy_set_queue((struct wl_proxy *)private_voutput->wl_voutput, NULL);
2135 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
2136 wl_tdm_voutput_destroy(private_voutput->wl_voutput);
2137 free(private_voutput);
2139 *error = TDM_ERROR_PROTOCOL_ERROR;
2140 pthread_mutex_unlock(&private_client->lock);
2144 if (private_voutput->msg != WL_TDM_VOUTPUT_MESSAGE_ADDED) {
2145 wl_tdm_voutput_destroy(private_voutput->wl_voutput);
2146 free(private_voutput);
2148 *error = TDM_ERROR_PROTOCOL_ERROR; // FIXME add new error type.
2149 pthread_mutex_unlock(&private_client->lock);
2153 LIST_ADDTAIL(&private_voutput->link, &private_client->voutput_list);
2155 pthread_mutex_unlock(&private_client->lock);
2157 return (tdm_client_voutput *)private_voutput;
2161 tdm_client_voutput_destroy(tdm_client_voutput *voutput)
2163 tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)voutput;
2164 tdm_private_client *private_client;
2165 tdm_client_voutput_commit_handler_info *h = NULL, *hh = NULL;
2167 if (!private_voutput)
2169 private_client = private_voutput->private_client;
2171 pthread_mutex_lock(&private_client->lock);
2173 if (!(LIST_IS_EMPTY(&private_voutput->buffer_list))) {
2174 tdm_private_client_buffer *cb = NULL, *cbb = NULL;
2176 LIST_FOR_EACH_ENTRY_SAFE(cb, cbb, &private_voutput->buffer_list, link) {
2177 tbm_surface_h tbm_surface = NULL;
2179 LIST_DEL(&cb->link);
2181 tbm_surface = (tbm_surface_h)wl_buffer_get_user_data(cb->wl_buffer);
2183 tbm_surface_internal_unref(tbm_surface);
2185 wl_buffer_set_user_data(cb->wl_buffer, NULL);
2186 wl_buffer_destroy(cb->wl_buffer);
2192 if (private_voutput->bufmgr)
2193 tbm_bufmgr_deinit(private_voutput->bufmgr);
2195 if (private_voutput->available_modes.modes)
2196 free(private_voutput->available_modes.modes);
2198 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_voutput->commit_handler_list, link) {
2203 if (private_voutput->get_output)
2204 _tdm_client_output_destroy(private_voutput->private_output);
2206 wl_tdm_voutput_destroy(private_voutput->wl_voutput);
2208 LIST_DEL(&private_voutput->link);
2210 free(private_voutput);
2212 pthread_mutex_unlock(&private_client->lock);
2216 tdm_client_voutput_set_available_modes(tdm_client_voutput *voutput, const tdm_client_output_mode *modes, int count)
2218 tdm_private_client_voutput *private_voutput;
2219 tdm_private_client *private_client;
2220 tdm_error ret = TDM_ERROR_NONE;
2222 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2224 if ((count > 0) && (modes == NULL))
2225 return TDM_ERROR_INVALID_PARAMETER;
2227 private_voutput = (tdm_private_client_voutput *)voutput;
2228 private_client = private_voutput->private_client;
2230 if (!private_voutput->private_output) {
2231 private_voutput->private_output = tdm_client_voutput_get_client_output(private_voutput, &ret);
2232 TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, TDM_ERROR_OPERATION_FAILED);
2235 pthread_mutex_lock(&private_client->lock);
2237 if (private_voutput->private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
2238 pthread_mutex_unlock(&private_client->lock);
2239 return TDM_ERROR_BAD_REQUEST;
2242 if (private_voutput->available_modes.modes)
2243 free(private_voutput->available_modes.modes);
2245 private_voutput->available_modes.count = count;
2248 private_voutput->available_modes.modes = calloc(count, sizeof(tdm_client_output_mode));
2249 if (private_voutput->available_modes.modes == NULL) {
2250 private_voutput->available_modes.count = 0;
2251 pthread_mutex_unlock(&private_client->lock);
2252 return TDM_ERROR_OUT_OF_MEMORY;
2254 memcpy(private_voutput->available_modes.modes, modes, sizeof(tdm_client_output_mode) * count);
2257 pthread_mutex_unlock(&private_client->lock);
2259 return TDM_ERROR_NONE;
2263 tdm_client_voutput_set_physical_size(tdm_client_voutput *voutput, unsigned int mmWidth, unsigned int mmHeight)
2265 tdm_private_client_voutput *private_voutput;
2266 tdm_private_client *private_client;
2267 tdm_error ret = TDM_ERROR_NONE;
2269 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2270 TDM_RETURN_VAL_IF_FAIL(mmWidth != 0, TDM_ERROR_INVALID_PARAMETER);
2271 TDM_RETURN_VAL_IF_FAIL(mmHeight != 0, TDM_ERROR_INVALID_PARAMETER);
2273 private_voutput = (tdm_private_client_voutput *)voutput;
2274 private_client = private_voutput->private_client;
2276 if (!private_voutput->private_output) {
2277 private_voutput->private_output = tdm_client_voutput_get_client_output(private_voutput, &ret);
2278 TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, TDM_ERROR_OPERATION_FAILED);
2281 pthread_mutex_lock(&private_client->lock);
2283 if (private_voutput->private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
2284 pthread_mutex_unlock(&private_client->lock);
2285 return TDM_ERROR_BAD_REQUEST;
2288 private_voutput->mmwidth = mmWidth;
2289 private_voutput->mmheight = mmHeight;
2291 pthread_mutex_unlock(&private_client->lock);
2293 return TDM_ERROR_NONE;
2297 tdm_client_voutput_add_commit_handler(tdm_client_voutput *voutput,
2298 tdm_client_voutput_commit_handler func,
2301 tdm_private_client_voutput *private_voutput;
2302 tdm_private_client *private_client;
2303 tdm_client_voutput_commit_handler_info *h = NULL;
2305 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2306 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
2308 private_voutput = (tdm_private_client_voutput *)voutput;
2309 private_client = private_voutput->private_client;
2311 LIST_FOR_EACH_ENTRY(h, &private_voutput->commit_handler_list, link) {
2312 if (h->func == func && h->user_data == user_data) {
2313 TDM_ERR("can't add twice");
2314 return TDM_ERROR_BAD_REQUEST;
2318 h = calloc(1, sizeof *h);
2319 TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
2321 pthread_mutex_lock(&private_client->lock);
2323 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
2325 pthread_mutex_unlock(&private_client->lock);
2326 return TDM_ERROR_PROTOCOL_ERROR;
2329 h->private_voutput = private_voutput;
2331 h->user_data = user_data;
2332 LIST_ADDTAIL(&h->link, &private_voutput->commit_handler_list);
2333 LIST_INITHEAD(&h->call_link);
2335 pthread_mutex_unlock(&private_client->lock);
2337 return TDM_ERROR_NONE;
2341 tdm_client_voutput_remove_commit_handler(tdm_client_voutput *voutput,
2342 tdm_client_voutput_commit_handler func,
2345 tdm_private_client_voutput *private_voutput;
2346 tdm_private_client *private_client;
2347 tdm_client_voutput_commit_handler_info *h = NULL;
2349 TDM_RETURN_IF_FAIL(voutput != NULL);
2350 TDM_RETURN_IF_FAIL(func != NULL);
2352 private_voutput = (tdm_private_client_voutput *)voutput;
2353 private_client = private_voutput->private_client;
2355 pthread_mutex_lock(&private_client->lock);
2357 LIST_FOR_EACH_ENTRY(h, &private_voutput->commit_handler_list, link) {
2358 if (h->func != func || h->user_data != user_data)
2364 pthread_mutex_unlock(&private_client->lock);
2369 pthread_mutex_unlock(&private_client->lock);
2373 tdm_client_voutput_commit_done(tdm_client_voutput *voutput)
2375 tdm_private_client_voutput *private_voutput;
2376 tdm_private_client *private_client;
2377 tbm_surface_h buffer = NULL;
2379 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2381 private_voutput = (tdm_private_client_voutput *)voutput;
2382 TDM_RETURN_VAL_IF_FAIL(private_voutput->attach_buffer != NULL, TDM_ERROR_NONE);
2384 private_client = private_voutput->private_client;
2386 pthread_mutex_lock(&private_client->lock);
2388 buffer = (tbm_surface_h)wl_buffer_get_user_data(private_voutput->attach_buffer->wl_buffer);
2389 tbm_surface_internal_unref(buffer);
2390 private_voutput->attach_buffer = NULL;
2391 wl_tdm_voutput_commit_done(private_voutput->wl_voutput);
2393 pthread_mutex_unlock(&private_client->lock);
2395 return TDM_ERROR_NONE;
2399 tdm_client_voutput_get_client_output(tdm_client_voutput *voutput, tdm_error *error)
2401 tdm_private_client_voutput *private_voutput;
2402 tdm_private_client_output *private_output = NULL;
2403 tdm_private_client *private_client;
2404 tdm_error ret = TDM_ERROR_NONE;
2407 *error = TDM_ERROR_NONE;
2410 TDM_ERR("'!voutput' failed");
2412 *error = TDM_ERROR_INVALID_PARAMETER;
2416 private_voutput = (tdm_private_client_voutput *)voutput;
2417 private_client = private_voutput->private_client;
2419 pthread_mutex_lock(&private_client->lock);
2421 if (private_voutput->get_output) {
2422 pthread_mutex_unlock(&private_client->lock);
2423 return private_voutput->private_output;
2426 pthread_mutex_unlock(&private_client->lock);
2427 private_output = (tdm_private_client_output *)tdm_client_get_output(private_voutput->private_client, private_voutput->name, &ret);
2428 if (!private_output) {
2429 TDM_ERR("tdm_client_voutput_get_client_output get private_output fail");
2434 pthread_mutex_lock(&private_client->lock);
2435 private_output->voutput = private_voutput;
2436 private_voutput->private_output = private_output;
2437 private_voutput->get_output = 1;
2439 pthread_mutex_unlock(&private_client->lock);
2441 return private_output;
2445 _tdm_client_voutput_send_available_modes(tdm_private_client_voutput *private_voutput)
2447 tdm_client_output_mode *modes, *mode;
2448 struct wl_array array;
2451 modes = private_voutput->available_modes.modes;
2452 size = sizeof(tdm_client_output_mode);
2454 wl_array_init(&array);
2455 for (i = 0; i < private_voutput->available_modes.count; i++) {
2456 mode = wl_array_add(&array, size);
2457 memcpy(mode, &modes[i], size);
2459 wl_tdm_voutput_set_available_modes(private_voutput->wl_voutput, &array);
2460 wl_array_release(&array);
2464 tdm_client_voutput_connect(tdm_client_voutput *voutput)
2466 tdm_private_client_output *private_output = NULL;;
2467 tdm_private_client_voutput *private_voutput = NULL;
2468 tdm_private_client *private_client;
2470 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2472 private_voutput = (tdm_private_client_voutput *)voutput;
2473 private_client = private_voutput->private_client;
2474 private_output = private_voutput->private_output;
2476 pthread_mutex_lock(&private_client->lock);
2478 if (private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
2479 pthread_mutex_unlock(&private_client->lock);
2480 return TDM_ERROR_NONE;
2483 if (!private_output->watch_output_changes)
2484 private_output->connection = TDM_OUTPUT_CONN_STATUS_CONNECTED;
2486 _tdm_client_voutput_send_available_modes(private_voutput);
2488 wl_tdm_voutput_set_physical_size(private_voutput->wl_voutput, private_voutput->mmwidth, private_voutput->mmheight);
2490 wl_tdm_voutput_connect(private_voutput->wl_voutput);
2492 pthread_mutex_unlock(&private_client->lock);
2494 return TDM_ERROR_NONE;
2498 tdm_client_voutput_disconnect(tdm_client_voutput *voutput)
2500 tdm_private_client_output *private_output = NULL;
2501 tdm_private_client_voutput *private_voutput = NULL;
2502 tdm_private_client *private_client;
2504 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2506 private_voutput = (tdm_private_client_voutput *)voutput;
2507 private_client = private_voutput->private_client;
2508 private_output = private_voutput->private_output;
2510 pthread_mutex_lock(&private_client->lock);
2512 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
2513 pthread_mutex_unlock(&private_client->lock);
2514 return TDM_ERROR_NONE;
2517 if (!private_output->watch_output_changes)
2518 private_output->connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
2520 wl_tdm_voutput_disconnect(private_voutput->wl_voutput);
2522 pthread_mutex_unlock(&private_client->lock);
2524 return TDM_ERROR_NONE;
2529 tdm_client_voutput_set_mode(tdm_client_voutput *voutput, int index)
2531 tdm_private_client_output *private_output;
2532 tdm_private_client_voutput *private_voutput = NULL;
2533 tdm_private_client *private_client;
2535 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2536 TDM_RETURN_VAL_IF_FAIL(index >= 0, TDM_ERROR_INVALID_PARAMETER);
2538 private_voutput = (tdm_private_client_voutput *)voutput;
2539 private_client = private_voutput->private_client;
2540 private_output = private_voutput->private_output;
2542 pthread_mutex_lock(&private_client->lock);
2544 if (private_voutput->available_modes.count - 1 < index) {
2545 pthread_mutex_unlock(&private_client->lock);
2546 return TDM_ERROR_INVALID_PARAMETER;
2549 if ((private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ||
2550 (private_voutput->available_modes.count == 0)) {
2551 pthread_mutex_unlock(&private_client->lock);
2552 return TDM_ERROR_BAD_REQUEST;
2555 TDM_DBG("mode_set request : %d", index);
2557 wl_tdm_voutput_set_mode(private_voutput->wl_voutput, index);
2559 pthread_mutex_unlock(&private_client->lock);
2561 return TDM_ERROR_NONE;