X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=client%2Ftdm_client.c;h=9fa0ab552a3930393dbdf15b2d8ff48d24582cf0;hb=refs%2Fchanges%2F30%2F184830%2F1;hp=5e2b750108f779bf9c7e38d6d245d876aa0f6967;hpb=9a9d836fb0d090ad6ce39ed002ead2f0c86187ab;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/client/tdm_client.c b/client/tdm_client.c index 5e2b750..9fa0ab5 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -1,36 +1,36 @@ /************************************************************************** - -libtdm - -Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved. - -Contact: Eunchul Kim , - JinYoung Jeon , - Taeheon Kim , - YoungJun Cho , - SooChan Lim , - Boram Park - -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sub license, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice (including the -next paragraph) shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. -IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR -ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - + * + * libtdm + * + * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved. + * + * Contact: Eunchul Kim , + * JinYoung Jeon , + * Taeheon Kim , + * YoungJun Cho , + * SooChan Lim , + * Boram Park + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * **************************************************************************/ #ifdef HAVE_CONFIG_H @@ -40,38 +40,382 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include #include +#include +#include +#include + +#include #include "tdm_client.h" #include "tdm_log.h" #include "tdm_macro.h" #include "tdm_list.h" -#include "tdm-client-protocol.h" +#include "tdm.h" +#include "tdm_private.h" -extern int tdm_debug; +typedef struct _tdm_private_client_vblank tdm_private_client_vblank; typedef struct _tdm_private_client { + pthread_mutex_t lock; + struct wl_display *display; + struct wl_event_queue *queue; struct wl_registry *registry; struct wl_tdm *tdm; + struct list_head output_list; - struct list_head vblank_list; + unsigned int enable_ttrace; + unsigned int stamp; + + tdm_private_client_vblank *temp_vblank; } tdm_private_client; -typedef struct _tdm_client_vblank_info { +typedef struct _tdm_private_client_output { + tdm_private_client *private_client; + + char name[TDM_NAME_LEN]; + struct wl_tdm_output *output; + int width; + int height; + int refresh; + tdm_output_conn_status connection; + tdm_output_dpms dpms; + struct list_head vblank_list; + struct list_head change_handler_list; + + unsigned int req_id; + unsigned int watch_output_changes; + struct list_head link; +} tdm_private_client_output; + +typedef struct _tdm_private_client_voutput { + tdm_private_client_output base; + struct wl_tdm_voutput *wl_voutput; + + struct + { + int count; + tdm_client_output_mode *modes; + } available_modes; + + unsigned int mmwidth; + unsigned int mmheight; + + uint32_t msg; +} tdm_private_client_voutput; + +struct _tdm_private_client_vblank { + tdm_private_client_output *private_output; + struct wl_tdm_vblank *vblank; + struct list_head wait_list; + + char name[TDM_NAME_LEN]; + unsigned int sync; + unsigned int fps; + int offset; + unsigned int enable_fake; + unsigned int enable_ttrace; + + unsigned int started; + unsigned int stamp; + + double req_time; + double last_time; + + struct list_head link; +}; + +typedef struct _tdm_client_output_handler_info { + tdm_private_client_output *private_output; + + tdm_client_output_change_handler func; + void *user_data; + + struct list_head link; + struct list_head call_link; +} tdm_client_output_handler_info; + +typedef struct _tdm_client_wait_info { + tdm_private_client_vblank *private_vblank; + tdm_client_vblank_handler func; void *user_data; -} tdm_client_vblank_info; + + unsigned int req_id; + double req_time; + int need_free; + + struct list_head link; + struct list_head call_link; +} tdm_client_wait_info; + +static unsigned int +_tdm_client_check_wl_error(tdm_private_client *private_client, const char *func, int line) +{ + uint32_t ec, id; + const struct wl_interface *intf; + int err; + + err = wl_display_get_error(private_client->display); + if (!err) + return false; + + if (err == EINVAL || err == ENOMEM || err == EFAULT || err == EPROTO) { + ec = wl_display_get_protocol_error(private_client->display, &intf, &id); + TDM_ERR("[%s,%d] errno(%d) Got protocol error '%u' on interface '%s' (object '%u')", + func, line, err, ec, (intf) ? intf->name : "destroyed", id); + } else { + TDM_ERR("[%s,%d] errno(%d)", func, line, err); + } + + return true; +} + +#define CHECK_WL_PROTOCOL_ERROR(pc) _tdm_client_check_wl_error(pc, __FUNCTION__, __LINE__) + +static void +_tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp) +{ + tdm_private_client_vblank *private_vblank = data; + tdm_private_client *private_client; + + TDM_RETURN_IF_FAIL(private_vblank != NULL); + + private_vblank->stamp = stamp; + + TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL); + private_client = private_vblank->private_output->private_client; + + private_client->stamp = stamp; +} + +/* LCOV_EXCL_START */ +static void +_tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank, + uint32_t req_id, uint32_t sequence, uint32_t tv_sec, + uint32_t tv_usec, uint32_t error) +{ + tdm_private_client_vblank *private_vblank = data; + tdm_private_client *private_client; + tdm_client_wait_info *w = NULL, *wait_info = NULL; + + TDM_RETURN_IF_FAIL(private_vblank != NULL); + + private_client = private_vblank->private_output->private_client; + + private_vblank->last_time = TDM_TIME(tv_sec, tv_usec); + + TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)", + private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec)); + + LIST_FOR_EACH_ENTRY(w, &private_vblank->wait_list, link) { + if (w->req_id != req_id) + continue; + + wait_info = w; + break; + } + + if (!wait_info) { + TDM_ERR("no wait infomation for req_id(%d)", req_id); + return; + } + + if (private_vblank->enable_ttrace) + TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); + + if (wait_info->req_time >= private_vblank->last_time) + TDM_WRN("'req(%.6f) < last(%.6f)' failed. error(%d)", wait_info->req_time, private_vblank->last_time, error); + + if (wait_info->need_free) + LIST_DEL(&wait_info->link); + + if (wait_info->func) { + pthread_mutex_unlock(&private_client->lock); + wait_info->func(private_vblank, error, sequence, tv_sec, tv_usec, wait_info->user_data); + pthread_mutex_lock(&private_client->lock); + } + + if (wait_info->need_free) + free(w); + else + wait_info->need_free = 1; +} +/* LCOV_EXCL_STOP */ + +/* LCOV_EXCL_START */ +static void +_tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable) +{ + tdm_private_client_vblank *private_vblank = data; + tdm_private_client *private_client; + + TDM_RETURN_IF_FAIL(private_vblank != NULL); + + private_vblank->enable_ttrace = enable; + + TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL); + private_client = private_vblank->private_output->private_client; + + private_client->enable_ttrace = enable; +} +/* LCOV_EXCL_STOP */ + +static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = { + _tdm_client_vblank_cb_stamp, + _tdm_client_vblank_cb_done, + _tdm_client_vblank_cb_ttrace, +}; + +static void +_tdm_client_output_destroy(tdm_private_client_output *private_output) +{ + tdm_private_client_vblank *v = NULL, *vv = NULL; + tdm_client_output_handler_info *h = NULL, *hh = NULL; + + LIST_DEL(&private_output->link); + + LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) { + TDM_ERR("vblanks SHOULD be destroyed first!"); + LIST_DEL(&v->link); + v->private_output = NULL; + } + + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) { + LIST_DEL(&h->link); + free(h); + } + + wl_tdm_output_destroy(private_output->output); + + free(private_output); +} + +static void +_tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output, + uint32_t width, uint32_t height, uint32_t refresh, uint32_t error) +{ + tdm_private_client_output *private_output = (tdm_private_client_output*)data; + + TDM_RETURN_IF_FAIL(private_output != NULL); + + private_output->width = width; + private_output->height = height; + private_output->refresh = refresh; + + if (error != TDM_ERROR_NONE) + TDM_INFO("mode event error: %d", error); + + TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)", + private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output), + width, height, refresh); +} + +static void +_tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error) +{ + tdm_private_client_output *private_output = (tdm_private_client_output*)data; + tdm_private_client *private_client; + tdm_client_output_handler_info *h = NULL, *hh = NULL; + tdm_value v; + struct list_head call_list; + + TDM_RETURN_IF_FAIL(private_output != NULL); + + private_client = private_output->private_client; + + if (private_output->connection == value) + return; + + private_output->connection = value; + + if (error != TDM_ERROR_NONE) + TDM_INFO("connection event error: %d", error); + + TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)", + private_output, + wl_proxy_get_id((struct wl_proxy*)private_output->output), + value); + + LIST_INITHEAD(&call_list); + + LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) { + LIST_ADDTAIL(&h->call_link, &call_list); + } + + v.u32 = value; + pthread_mutex_unlock(&private_client->lock); + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) { + if (h->func) + h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data); + } + pthread_mutex_lock(&private_client->lock); +} + +static void +_tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error) +{ + tdm_private_client_output *private_output = (tdm_private_client_output*)data; + tdm_private_client *private_client; + tdm_client_output_handler_info *h = NULL, *hh = NULL; + tdm_value v; + struct list_head call_list; + + TDM_RETURN_IF_FAIL(private_output != NULL); + + private_client = private_output->private_client; + + /* If value is extended value, we handle it as DPMS on in client side + * The extended DPMS value is valid only in server side. + * Or, need to export to client side also? + */ + if (value > TDM_OUTPUT_DPMS_OFF) + value = TDM_OUTPUT_DPMS_ON; + + if (private_output->dpms == value) + return; + + private_output->dpms = value; + + if (error != TDM_ERROR_NONE) + TDM_INFO("dpms event error: %d", error); + + TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)", + private_output, + wl_proxy_get_id((struct wl_proxy*)private_output->output), + value); + + LIST_INITHEAD(&call_list); + + LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) { + LIST_ADDTAIL(&h->call_link, &call_list); + } + + v.u32 = value; + pthread_mutex_unlock(&private_client->lock); + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) { + if (h->func) + h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data); + } + pthread_mutex_lock(&private_client->lock); +} + +static const struct wl_tdm_output_listener tdm_client_output_listener = { + _tdm_client_output_cb_mode, + _tdm_client_output_cb_connection, + _tdm_client_output_cb_dpms, +}; static void _tdm_client_cb_global(void *data, struct wl_registry *registry, - uint32_t name, const char *interface, - uint32_t version) + uint32_t name, const char *interface, + uint32_t version) { tdm_private_client *private_client = data; - if (strcmp(interface, "wl_tdm") == 0) { + if (strncmp(interface, "wl_tdm", 6) == 0) { private_client->tdm = wl_registry_bind(registry, name, &wl_tdm_interface, version); TDM_RETURN_IF_FAIL(private_client->tdm != NULL); @@ -80,53 +424,72 @@ _tdm_client_cb_global(void *data, struct wl_registry *registry, } } +/* LCOV_EXCL_START */ static void _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name) { } +/* LCOV_EXCL_STOP */ -static const struct wl_registry_listener tdm_client_registry_listener = -{ - _tdm_client_cb_global, - _tdm_client_cb_global_remove +static const struct wl_registry_listener tdm_client_registry_listener = { + _tdm_client_cb_global, + _tdm_client_cb_global_remove }; tdm_client* -tdm_client_create(tdm_client_error *error) +tdm_client_create(tdm_error *error) { tdm_private_client *private_client; private_client = calloc(1, sizeof *private_client); if (!private_client) { + /* LCOV_EXCL_START */ + TDM_ERR("alloc failed"); if (error) - *error = TDM_CLIENT_ERROR_OUT_OF_MEMORY; + *error = TDM_ERROR_OUT_OF_MEMORY; + return NULL; + + /* LCOV_EXCL_STOP */ + } + + if (pthread_mutex_init(&private_client->lock, NULL)) { + TDM_ERR("mutex init failed: %m"); + free(private_client); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; return NULL; } + LIST_INITHEAD(&private_client->output_list); + private_client->display = wl_display_connect("tdm-socket"); TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed); + private_client->queue = wl_display_create_queue(private_client->display); + TDM_GOTO_IF_FAIL(private_client->queue != NULL, create_failed); + private_client->registry = wl_display_get_registry(private_client->display); TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed); wl_registry_add_listener(private_client->registry, - &tdm_client_registry_listener, private_client); + &tdm_client_registry_listener, private_client); wl_display_roundtrip(private_client->display); + if (CHECK_WL_PROTOCOL_ERROR(private_client)) + goto create_failed; + /* check global objects */ TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed); - LIST_INITHEAD(&private_client->vblank_list); - if (error) - *error = TDM_CLIENT_ERROR_NONE; + *error = TDM_ERROR_NONE; return (tdm_client*)private_client; create_failed: tdm_client_destroy((tdm_client*)private_client); if (error) - *error = TDM_CLIENT_ERROR_OPERATION_FAILED; + *error = TDM_ERROR_OPERATION_FAILED; return NULL; } @@ -134,115 +497,1397 @@ void tdm_client_destroy(tdm_client *client) { tdm_private_client *private_client = (tdm_private_client*)client; - tdm_client_vblank_info *v = NULL, *vv = NULL; + tdm_private_client_output *o = NULL, *oo = NULL; if (!private_client) return; - LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_client->vblank_list, link) { - LIST_DEL(&v->link); - wl_tdm_vblank_destroy(v->vblank); - free(v); + pthread_mutex_lock(&private_client->lock); + + if (private_client->temp_vblank) { + pthread_mutex_unlock(&private_client->lock); + tdm_client_vblank_destroy(private_client->temp_vblank); + pthread_mutex_lock(&private_client->lock); + } + + LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) { + _tdm_client_output_destroy(o); } if (private_client->tdm) wl_tdm_destroy(private_client->tdm); if (private_client->registry) wl_registry_destroy(private_client->registry); + if (private_client->queue) + wl_event_queue_destroy(private_client->queue); if (private_client->display) wl_display_disconnect(private_client->display); + pthread_mutex_unlock(&private_client->lock); + pthread_mutex_destroy(&private_client->lock); + free(private_client); } -tdm_client_error +tdm_error tdm_client_get_fd(tdm_client *client, int *fd) { tdm_private_client *private_client; - TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_CLIENT_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_CLIENT_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER); private_client = (tdm_private_client*)client; + pthread_mutex_lock(&private_client->lock); + *fd = wl_display_get_fd(private_client->display); + + pthread_mutex_unlock(&private_client->lock); + if (*fd < 0) - return TDM_CLIENT_ERROR_OPERATION_FAILED; + return TDM_ERROR_OPERATION_FAILED; - return TDM_CLIENT_ERROR_NONE; + return TDM_ERROR_NONE; } -tdm_client_error +tdm_error tdm_client_handle_events(tdm_client *client) { tdm_private_client *private_client; - TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_CLIENT_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER); + /* LCOV_EXCL_START */ private_client = (tdm_private_client*)client; + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (private_client->enable_ttrace) + TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp); + wl_display_dispatch(private_client->display); - return TDM_CLIENT_ERROR_NONE; + if (private_client->enable_ttrace) + TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; + /* LCOV_EXCL_STOP */ } -static void -_tdm_client_cb_vblank_done(void *data, struct wl_tdm_vblank *vblank, - uint32_t sequence, uint32_t tv_sec, uint32_t tv_usec) +static int +_tdm_client_poll(struct wl_display *display, short int events, int timeout) +{ + int ret; + struct pollfd pfd[1]; + + pfd[0].fd = wl_display_get_fd(display); + pfd[0].events = events; + do { + ret = poll(pfd, 1, timeout); + } while (ret == -1 && errno == EINTR); + + return ret; +} + +static tdm_error +_tdm_client_dispatch_timeout(tdm_private_client *private_client, int timeout) { - tdm_client_vblank_info *vblank_info = (tdm_client_vblank_info*)data; + int ret; + struct wl_display *display = private_client->display; + + if (wl_display_prepare_read(display) == -1) { + if (wl_display_dispatch_pending(display) > 0) + return TDM_ERROR_NONE; + else + return TDM_ERROR_OPERATION_FAILED; + } - TDM_RETURN_IF_FAIL(vblank_info != NULL); + while (true) { + ret = wl_display_flush(display); - if (vblank_info->func) { - vblank_info->func(sequence, tv_sec, tv_usec, vblank_info->user_data); + if (ret != -1 || errno != EAGAIN) + break; + + if (_tdm_client_poll(display, POLLOUT, -1) == -1) { + wl_display_cancel_read(display); + TDM_ERR("_tdm_client_poll failed"); + return TDM_ERROR_OPERATION_FAILED; + } + } + + /* Don't stop if flushing hits an EPIPE; continue so we can read any + * protocol error that may have triggered it. */ + if (ret < 0 && errno != EPIPE) { + TDM_ERR("ret(%d) errno(%d)", ret, errno); + wl_display_cancel_read(display); + return TDM_ERROR_OPERATION_FAILED; + } + + ret = _tdm_client_poll(display, POLLIN, timeout); + if (ret <= 0) { + wl_display_cancel_read(display); + if (ret == 0) { + TDM_ERR("_tdm_client_poll timeout."); + return TDM_ERROR_TIMEOUT; + } else { + TDM_ERR("_tdm_client_poll failed. (ret:%d)", ret); + return TDM_ERROR_OPERATION_FAILED; + } + } + + if (wl_display_read_events(display) == -1) { + TDM_ERR("wl_display_read_events failed"); + return TDM_ERROR_OPERATION_FAILED; + } + + ret = wl_display_dispatch_pending(display); + + if (ret < 0) { + TDM_ERR("_tdm_client_dispatch_timeout failed"); + return TDM_ERROR_OPERATION_FAILED; } - LIST_DEL(&vblank_info->link); - free(vblank_info); + return TDM_ERROR_NONE; } -static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = { - _tdm_client_cb_vblank_done, -}; +tdm_error +tdm_client_handle_events_timeout(tdm_client *client, int ms_timeout) +{ + tdm_private_client *private_client; + tdm_error ret; + TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_client = (tdm_private_client*)client; -tdm_client_error -tdm_client_wait_vblank(tdm_client *client, char *name, int interval, int sync, - tdm_client_vblank_handler func, void *user_data) + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (private_client->enable_ttrace) + TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp); + + ret = _tdm_client_dispatch_timeout(private_client, ms_timeout); + + if (private_client->enable_ttrace) + TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + pthread_mutex_unlock(&private_client->lock); + + return ret; +} + +typedef struct _tdm_client_vblank_temp { + tdm_client_vblank_handler2 func; + void *user_data; +} tdm_client_vblank_temp; + +/* LCOV_EXCL_START */ +static void +_tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, void *user_data) +{ + tdm_client_vblank_temp *vblank_temp = user_data; + + TDM_RETURN_IF_FAIL(vblank_temp != NULL); + TDM_RETURN_IF_FAIL(vblank != NULL); + + if (vblank_temp->func) + vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data); + + free(vblank_temp); +} +/* LCOV_EXCL_STOP */ + +/* LCOV_EXCL_START */ /* deprecated */ +tdm_error +tdm_client_wait_vblank(tdm_client *client, char *name, + int sw_timer, int interval, int sync, + tdm_client_vblank_handler2 func, void *user_data) { tdm_private_client *private_client = (tdm_private_client*)client; - tdm_client_vblank_info *vblank_info; + tdm_client_output *output; + tdm_client_vblank_temp *vblank_temp; + tdm_error ret; - TDM_RETURN_VAL_IF_FAIL(name != NULL, TDM_CLIENT_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_CLIENT_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_CLIENT_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_CLIENT_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(private_client->tdm != NULL, TDM_CLIENT_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); - vblank_info = calloc(1, sizeof *vblank_info); - if (!vblank_info) { - TDM_ERR("alloc failed"); - return TDM_CLIENT_ERROR_OUT_OF_MEMORY; + if (CHECK_WL_PROTOCOL_ERROR(private_client)) + return TDM_ERROR_PROTOCOL_ERROR; + + if (!private_client->temp_vblank) { + output = tdm_client_get_output(client, name, &ret); + TDM_RETURN_VAL_IF_FAIL(output != NULL, ret); + + private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret); + TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret); } - vblank_info->vblank = wl_tdm_wait_vblank(private_client->tdm, name, interval); - if (!vblank_info->vblank) { - TDM_ERR("couldn't create vblank resource"); - free(vblank_info); - return TDM_CLIENT_ERROR_OUT_OF_MEMORY; + tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer); + tdm_client_vblank_set_sync(private_client->temp_vblank, sync); + + vblank_temp = calloc(1, sizeof *vblank_temp); + TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY); + + vblank_temp->func = func; + vblank_temp->user_data = user_data; + + return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp); +} +/* LCOV_EXCL_STOP */ + +tdm_client_output* +tdm_client_get_output(tdm_client *client, char *name, tdm_error *error) +{ + tdm_private_client *private_client; + tdm_private_client_output *private_output = NULL; + struct wl_proxy *wrapper; + + if (error) + *error = TDM_ERROR_NONE; + + if (!client) { + TDM_ERR("'!client' failed"); + if (error) + *error = TDM_ERROR_INVALID_PARAMETER; + return NULL; } - wl_tdm_vblank_add_listener(vblank_info->vblank, - &tdm_client_vblank_listener, vblank_info); + private_client = (tdm_private_client*)client; - vblank_info->func = func; - vblank_info->user_data = user_data; - LIST_ADDTAIL(&vblank_info->link, &private_client->vblank_list); + pthread_mutex_lock(&private_client->lock); - if (sync) - wl_display_roundtrip(private_client->display); - else - wl_display_flush(private_client->display); + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + if (error) + *error = TDM_ERROR_PROTOCOL_ERROR; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + if (!name) { + name = "primary"; + } else if (strncmp(name, "primary", 7) && strncmp(name, "default", 7)) { + if (error) + *error = TDM_ERROR_INVALID_PARAMETER; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) { + if (!strncmp(private_output->name, name, TDM_NAME_LEN)) { + pthread_mutex_unlock(&private_client->lock); + return (tdm_client_output*)private_output; + } + } + + wrapper = wl_proxy_create_wrapper(private_client->tdm); + if (!wrapper) { + TDM_ERR("create output_wrapper failed"); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + wl_proxy_set_queue(wrapper, private_client->queue); + + private_output = calloc(1, sizeof *private_output); + if (!private_output) { + /* LCOV_EXCL_START */ + wl_proxy_wrapper_destroy(wrapper); + TDM_ERR("alloc failed"); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + + /* LCOV_EXCL_STOP */ + } + + private_output->private_client = private_client; + + snprintf(private_output->name, TDM_NAME_LEN, "%s", name); + private_output->output = wl_tdm_create_output((struct wl_tdm *)wrapper, private_output->name); + wl_proxy_wrapper_destroy(wrapper); + if (!private_output->output) { + /* LCOV_EXCL_START */ + + TDM_ERR("couldn't create output resource"); + free(private_output); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + + /* LCOV_EXCL_STOP */ + } + + LIST_INITHEAD(&private_output->vblank_list); + LIST_INITHEAD(&private_output->change_handler_list); + + wl_tdm_output_add_listener(private_output->output, + &tdm_client_output_listener, private_output); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + + wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + wl_tdm_output_destroy(private_output->output); + free(private_output); + if (error) + *error = TDM_ERROR_PROTOCOL_ERROR; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + LIST_ADDTAIL(&private_output->link, &private_client->output_list); + + pthread_mutex_unlock(&private_client->lock); + + return (tdm_client_output*)private_output; +} + +tdm_error +tdm_client_output_add_change_handler(tdm_client_output *output, + tdm_client_output_change_handler func, + void *user_data) +{ + tdm_private_client_output *private_output; + tdm_private_client *private_client; + tdm_client_output_handler_info *h = NULL; + + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_output = (tdm_private_client_output*)output; + private_client = private_output->private_client; + + LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) { + if (h->func == func && h->user_data == user_data) { + TDM_ERR("can't add twice"); + return TDM_ERROR_BAD_REQUEST; + } + } + + h = calloc(1, sizeof *h); + TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY); + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + free(h); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (LIST_IS_EMPTY(&private_output->change_handler_list)) { + wl_tdm_output_watch_output_changes(private_output->output, 1); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + + /* TODO: this is very tricky. + * If a client adds the change_handler, we might be able to guess that + * the client will watch the tdm client's fd and handle tdm events in + * event loop. Otherwise, we CAN'T make sure if a client has event loop + * which handles tdm events. + */ + private_output->watch_output_changes = 1; + } + + h->private_output = private_output; + h->func = func; + h->user_data = user_data; + LIST_ADDTAIL(&h->link, &private_output->change_handler_list); + LIST_INITHEAD(&h->call_link); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +void +tdm_client_output_remove_change_handler(tdm_client_output *output, + tdm_client_output_change_handler func, + void *user_data) +{ + tdm_private_client_output *private_output; + tdm_private_client *private_client; + tdm_client_output_handler_info *h = NULL; + + TDM_RETURN_IF_FAIL(output != NULL); + TDM_RETURN_IF_FAIL(func != NULL); + + private_output = (tdm_private_client_output*)output; + private_client = private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) { + if (h->func != func || h->user_data != user_data) + continue; + + LIST_DEL(&h->link); + free(h); + + if (LIST_IS_EMPTY(&private_output->change_handler_list)) { + private_output->watch_output_changes = 0; + if (!CHECK_WL_PROTOCOL_ERROR(private_client)) { + wl_tdm_output_watch_output_changes(private_output->output, 0); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + } + } + + pthread_mutex_unlock(&private_client->lock); + + return; + } + + pthread_mutex_unlock(&private_client->lock); +} + +tdm_error +tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh) +{ + tdm_private_client_output *private_output; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_output = (tdm_private_client_output*)output; + private_client = private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (private_output->watch_output_changes) { + *refresh = private_output->refresh; + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue); + wl_tdm_output_get_mode(private_output->output); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + *refresh = private_output->refresh; + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status) +{ + tdm_private_client_output *private_output; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_output = (tdm_private_client_output*)output; + private_client = private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (private_output->watch_output_changes) { + *status = private_output->connection; + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue); + wl_tdm_output_get_connection(private_output->output); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + *status = private_output->connection; + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms) +{ + tdm_private_client_output *private_output; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_output = (tdm_private_client_output*)output; + private_client = private_output->private_client; + + if (private_output->watch_output_changes) { + *dpms = private_output->dpms; + return TDM_ERROR_NONE; + } + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue); + wl_tdm_output_get_dpms(private_output->output); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + *dpms = private_output->dpms; + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_client_vblank* +tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error) +{ + tdm_private_client *private_client; + tdm_private_client_output *private_output; + tdm_private_client_vblank *private_vblank; + struct wl_proxy *wrapper; + + if (error) + *error = TDM_ERROR_NONE; + + if (!output) { + TDM_ERR("'!output' failed"); + if (error) + *error = TDM_ERROR_INVALID_PARAMETER; + return NULL; + } + + private_output = (tdm_private_client_output*)output; + private_client = private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + if (error) + *error = TDM_ERROR_PROTOCOL_ERROR; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + wrapper = wl_proxy_create_wrapper(private_output->output); + if (!wrapper) { + TDM_ERR("create output_wrapper failed"); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + wl_proxy_set_queue(wrapper, private_client->queue); + + private_vblank = calloc(1, sizeof *private_vblank); + if (!private_vblank) { + /* LCOV_EXCL_START */ + + TDM_ERR("alloc failed"); + wl_proxy_wrapper_destroy(wrapper); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + + /* LCOV_EXCL_STOP */ + } + + private_vblank->private_output = private_output; + + private_vblank->vblank = wl_tdm_output_create_vblank((struct wl_tdm_output*)wrapper); + wl_proxy_wrapper_destroy(wrapper); + if (!private_vblank->vblank) { + /* LCOV_EXCL_START */ + + TDM_ERR("couldn't create vblank resource"); + free(private_vblank); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + + /* LCOV_EXCL_STOP */ + } + + /* initial value */ + private_vblank->fps = private_output->refresh; + private_vblank->offset = 0; + private_vblank->enable_fake = 0; + + LIST_INITHEAD(&private_vblank->wait_list); + + wl_tdm_vblank_add_listener(private_vblank->vblank, + &tdm_client_vblank_listener, private_vblank); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + + wl_proxy_set_queue((struct wl_proxy *)private_vblank->vblank, NULL); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + wl_tdm_vblank_destroy(private_vblank->vblank); + free(private_vblank); + if (error) + *error = TDM_ERROR_PROTOCOL_ERROR; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list); + + pthread_mutex_unlock(&private_client->lock); + + return (tdm_client_vblank*)private_vblank; +} + +void +tdm_client_vblank_destroy(tdm_client_vblank *vblank) +{ + tdm_private_client_vblank *private_vblank; + tdm_private_client *private_client; + tdm_client_wait_info *w = NULL, *ww = NULL; + + TDM_RETURN_IF_FAIL(vblank != NULL); + + private_vblank = vblank; + private_client = private_vblank->private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + LIST_DEL(&private_vblank->link); + + LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) { + LIST_DEL(&w->link); + free(w); + } + + wl_tdm_vblank_destroy(private_vblank->vblank); + + free(private_vblank); + + pthread_mutex_unlock(&private_client->lock); +} + +tdm_error +tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name) +{ + tdm_private_client_vblank *private_vblank; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_vblank = vblank; + private_client = private_vblank->private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (!name) + name = TDM_VBLANK_DEFAULT_NAME; + + strncpy(private_vblank->name, name, TDM_NAME_LEN - 1); + private_vblank->name[TDM_NAME_LEN - 1] = '\0'; + + wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync) +{ + tdm_private_client_vblank *private_vblank; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_vblank = vblank; + private_client = private_vblank->private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + private_vblank->sync = sync; + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps) +{ + tdm_private_client_vblank *private_vblank; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER); + + private_vblank = vblank; + private_client = private_vblank->private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (private_vblank->fps == fps) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + private_vblank->fps = fps; + + wl_tdm_vblank_set_fps(private_vblank->vblank, fps); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms) +{ + tdm_private_client_vblank *private_vblank; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_vblank = vblank; + TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST); + + private_client = private_vblank->private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (private_vblank->offset == offset_ms) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + private_vblank->offset = offset_ms; + + wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake) +{ + tdm_private_client_vblank *private_vblank; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_vblank = vblank; + private_client = private_vblank->private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (private_vblank->enable_fake == enable_fake) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + private_vblank->enable_fake = enable_fake; + + wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data) +{ + tdm_private_client *private_client; + tdm_private_client_output *private_output; + tdm_private_client_vblank *private_vblank; + tdm_client_wait_info *w; + struct timespec tp; + unsigned int req_sec, req_usec; + int ret = 0; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); + /* can't support "interval 0" and "getting current_msc" things because + * there is a socket communication between TDM client and server. It's impossible + * to return the current msc or sequence immediately. + */ + TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER); + + private_vblank = vblank; + private_output = private_vblank->private_output; + private_client = private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (!private_vblank->started) + private_vblank->started = 1; + + if (!private_vblank->enable_fake) { + if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) { + TDM_ERR("output disconnected"); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_OUTPUT_DISCONNECTED; + } + if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) { + TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms)); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_DPMS_OFF; + } + } + + w = calloc(1, sizeof *w); + if (!w) { + /* LCOV_EXCL_START */ + + TDM_ERR("alloc failed"); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_OUT_OF_MEMORY; + + /* LCOV_EXCL_STOP */ + } + + w->private_vblank = private_vblank; + w->func = func; + w->user_data = user_data; + + LIST_ADDTAIL(&w->link, &private_vblank->wait_list); + LIST_INITHEAD(&w->call_link); + + clock_gettime(CLOCK_MONOTONIC, &tp); + req_sec = (unsigned int)tp.tv_sec; + req_usec = (unsigned int)(tp.tv_nsec / 1000); + + w->req_id = ++private_output->req_id; + w->req_time = TDM_TIME(req_sec, req_usec); + w->need_free = (private_vblank->sync) ? 0 : 1; + + wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec); + + if (private_vblank->enable_ttrace) + TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); + + TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)", + vblank, interval, w->req_id, w->req_time); + + private_vblank->req_time = w->req_time; + + if (private_vblank->last_time >= w->req_time) + TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time); + + if (!private_vblank->sync) { + wl_display_flush(private_client->display); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + /* LCOV_EXCL_START */ + + while (ret != -1 && !w->need_free) + ret = wl_display_dispatch(private_client->display); + + clock_gettime(CLOCK_MONOTONIC, &tp); + TDM_DBG("block during %d us", + ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000)) + - (req_sec * 1000000 + req_usec)); + + LIST_DEL(&w->link); + free(w); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; + + /* LCOV_EXCL_STOP */ +} + +tdm_error +tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, + tdm_client_vblank_handler func, void *user_data) +{ + tdm_private_client *private_client; + tdm_private_client_output *private_output; + tdm_private_client_vblank *private_vblank; + tdm_client_wait_info *w; + struct timespec tp; + unsigned int req_sec, req_usec; + int ret = 0; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_vblank = vblank; + private_output = private_vblank->private_output; + private_client = private_output->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + if (!private_vblank->started) + private_vblank->started = 1; + + if (!private_vblank->enable_fake) { + if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) { + TDM_ERR("output disconnected"); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_OUTPUT_DISCONNECTED; + } + if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) { + TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms)); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_DPMS_OFF; + } + } + + w = calloc(1, sizeof *w); + if (!w) { + /* LCOV_EXCL_START */ + + TDM_ERR("alloc failed"); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_OUT_OF_MEMORY; + + /* LCOV_EXCL_STOP */ + } + + w->private_vblank = private_vblank; + w->func = func; + w->user_data = user_data; + + LIST_ADDTAIL(&w->link, &private_vblank->wait_list); + LIST_INITHEAD(&w->call_link); + + clock_gettime(CLOCK_MONOTONIC, &tp); + req_sec = (unsigned int)tp.tv_sec; + req_usec = (unsigned int)(tp.tv_nsec / 1000); + + w->req_id = ++private_output->req_id; + w->req_time = TDM_TIME(req_sec, req_usec); + w->need_free = (private_vblank->sync) ? 0 : 1; + + wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec); + + if (private_vblank->enable_ttrace) + TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); + + TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)", + vblank, sequence, w->req_id, w->req_time); + + private_vblank->req_time = w->req_time; + + if (private_vblank->last_time >= w->req_time) + TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time); + + if (!private_vblank->sync) { + wl_display_flush(private_client->display); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + /* LCOV_EXCL_START */ + + while (ret != -1 && !w->need_free) + ret = wl_display_dispatch(private_client->display); + + clock_gettime(CLOCK_MONOTONIC, &tp); + TDM_DBG("block during %d us", + ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000)) + - (req_sec * 1000000 + req_usec)); + + LIST_DEL(&w->link); + free(w); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_PROTOCOL_ERROR; + } + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; + + /* LCOV_EXCL_STOP */ +} + +unsigned int +tdm_client_vblank_is_waiting(tdm_client_vblank *vblank) +{ + tdm_private_client_vblank *private_vblank; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, 0); + + private_vblank = vblank; + + return (LIST_LENGTH(&private_vblank->wait_list) > 0) ? 1 : 0; +} + +void +tdm_client_voutput_cb_ack_message(void *data, struct wl_tdm_voutput *wl_voutput, uint32_t msg) +{ + tdm_private_client_voutput *private_voutput = data; + + private_voutput->msg = msg; +} + +static const struct wl_tdm_voutput_listener tdm_client_voutput_lisntener = { + tdm_client_voutput_cb_ack_message +}; + +tdm_client_voutput * +tdm_client_create_voutput(tdm_client *client, const char *name, tdm_error *error) +{ + tdm_private_client *private_client; + tdm_private_client_output *private_output; + tdm_private_client_voutput *private_voutput; + struct wl_proxy *wrapper; + + if (error) + *error = TDM_ERROR_NONE; + + if (!client) { + TDM_ERR("'!client' failed"); + if (error) + *error = TDM_ERROR_INVALID_PARAMETER; + return NULL; + } + + if (!name) { + TDM_ERR("'!name' failed"); + if (error) + *error = TDM_ERROR_INVALID_PARAMETER; + return NULL; + } + + private_client = (tdm_private_client *)client; + + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + if (error) + *error = TDM_ERROR_PROTOCOL_ERROR; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) { + if (!strncmp(private_output->name, name, TDM_NAME_LEN)) { + if (error) + *error = TDM_ERROR_INVALID_PARAMETER; // FIXME define new error type. + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + } + + wrapper = wl_proxy_create_wrapper(private_client->tdm); + if (!wrapper) { + TDM_ERR("create virtual output wrapper failed"); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + wl_proxy_set_queue(wrapper, private_client->queue); + + private_voutput = calloc(1, sizeof *private_voutput); + if (!private_voutput) { + /* LOCV_EXCL_START */ + wl_proxy_wrapper_destroy(wrapper); + TDM_ERR("alloc failed"); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + return NULL; + /* LOCV_EXCL_STOP */ + } + + private_voutput->base.private_client = private_client; + + private_voutput->wl_voutput = wl_tdm_create_voutput((struct wl_tdm *)wrapper, private_voutput->base.name); + wl_proxy_wrapper_destroy(wrapper); + if (!private_voutput->wl_voutput) { + /* LCOV_EXCL_START */ + TDM_ERR("couldn't create voutput resource"); + free(private_voutput); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + /* LCOV_EXCL_STOP */ + } + + wl_tdm_voutput_add_listener(private_voutput->wl_voutput, + &tdm_client_voutput_lisntener, private_voutput); + wl_display_roundtrip_queue(private_client->display, private_client->queue); + + wl_proxy_set_queue((struct wl_proxy *)private_voutput->wl_voutput, NULL); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { + wl_tdm_voutput_destroy(private_voutput->wl_voutput); + free(private_voutput); + if (error) + *error = TDM_ERROR_PROTOCOL_ERROR; + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + if (private_voutput->msg != WL_TDM_VOUTPUT_MESSAGE_ADDED) + { + wl_tdm_voutput_destroy(private_voutput->wl_voutput); + free(private_voutput); + if (error) + *error = TDM_ERROR_PROTOCOL_ERROR; // FIXME add new error type. + pthread_mutex_unlock(&private_client->lock); + return NULL; + } + + pthread_mutex_unlock(&private_client->lock); + + return (tdm_client_voutput *)private_voutput; +} + +void +tdm_client_voutput_destroy(tdm_client_voutput *voutput) +{ + tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)voutput; + + if (!private_voutput) + return; + + wl_tdm_voutput_destroy(private_voutput->wl_voutput); + + free(private_voutput); +} + +tdm_error +tdm_client_voutput_set_available_modes(tdm_client_voutput *voutput, const tdm_client_output_mode *modes, int count) +{ + tdm_private_client_voutput *private_voutput; + + TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER); + + if ((count > 0) && (modes == NULL)) + return TDM_ERROR_INVALID_PARAMETER; + + private_voutput = (tdm_private_client_voutput *)voutput; + + if (private_voutput->base.connection == TDM_OUTPUT_CONN_STATUS_CONNECTED) + return TDM_ERROR_BAD_REQUEST; + + if (private_voutput->available_modes.modes) + free(private_voutput->available_modes.modes); + + private_voutput->available_modes.count = count; + + if (count != 0) + { + private_voutput->available_modes.modes = calloc(count, sizeof(tdm_client_output_mode)); + memcpy(private_voutput->available_modes.modes, modes, sizeof(tdm_client_output_mode) * count); + } + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_voutput_set_physical_size(tdm_client_voutput *voutput, unsigned int mmWidth, unsigned int mmHeight) +{ + tdm_private_client_voutput *private_voutput; + + TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(mmWidth != 0, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(mmHeight != 0, TDM_ERROR_INVALID_PARAMETER); + + private_voutput = (tdm_private_client_voutput *)voutput; + + if (private_voutput->base.connection == TDM_OUTPUT_CONN_STATUS_CONNECTED) + return TDM_ERROR_BAD_REQUEST; + + private_voutput->mmwidth = mmWidth; + private_voutput->mmheight = mmHeight; + + return TDM_ERROR_NONE; +} + +tdm_client_output * +tdm_client_voutput_get_client_output(tdm_client_voutput *voutput, tdm_error *error) +{ + tdm_private_client_voutput *private_voutput; + + if (error) + *error = TDM_ERROR_NONE; + + if (!voutput) + { + TDM_ERR("'!voutput' failed"); + if (error) + *error = TDM_ERROR_INVALID_PARAMETER; + return NULL; + } + + private_voutput = (tdm_private_client_voutput *)voutput; + + return &private_voutput->base; +} + +tdm_error +tdm_client_output_get_available_modes(tdm_client_output *output, tdm_client_output_mode **modes, int *count) +{ + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_output_set_mode(tdm_client_output *output, const tdm_client_output_mode *mode) +{ + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_output_connect(tdm_client_output *output) +{ + tdm_private_client_output *private_output; + tdm_private_client_voutput *private_voutput; + tdm_client_output_mode *modes; + int i; + + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_output = (tdm_private_client_output *)output; + private_voutput = (tdm_private_client_voutput *)output; + + TDM_RETURN_VAL_IF_FAIL(private_output->connection != TDM_OUTPUT_CONN_STATUS_CONNECTED, + TDM_ERROR_BAD_REQUEST); + + private_output->connection = TDM_OUTPUT_CONN_STATUS_CONNECTED; + + modes = private_voutput->available_modes.modes; + for (i = 0; i < private_voutput->available_modes.count; i++) { + wl_tdm_voutput_set_available_modes(private_voutput->wl_voutput, i, + modes[i].clock, modes[i].hdisplay, + modes[i].hsync_start, modes[i].hsync_end, + modes[i].htotal, modes[i].hskew, + modes[i].vdisplay, modes[i].vsync_start, + modes[i].vsync_end, modes[i].vtotal, + modes[i].vscan, modes[i].vrefresh, + modes[i].flags, modes[i].type, + modes[i].name); + } + wl_tdm_voutput_set_physical_size(private_voutput->wl_voutput, private_voutput->mmwidth, private_voutput->mmheight); + + wl_tdm_voutput_connect(private_voutput->wl_voutput); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_output_disconnect(tdm_client_output *output) +{ + tdm_private_client_voutput *private_voutput; + tdm_private_client_output *private_output; + + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_output = (tdm_private_client_output *)output; + private_voutput = (tdm_private_client_voutput *)output; + + TDM_RETURN_VAL_IF_FAIL(private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED, + TDM_ERROR_BAD_REQUEST); + + private_output->connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED; + + wl_tdm_voutput_disconnect(private_voutput->wl_voutput); - return TDM_CLIENT_ERROR_NONE; + return TDM_ERROR_NONE; }