X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=client%2Ftdm_client.c;h=3a2ab481774a1a522883d10c8ae35d01e68ea3a4;hb=21ab2ce9f77ca364d4f9ae1d4f52162b951d4530;hp=f126490eaf9592d6ea3190dd10c830b0e548df4b;hpb=ae652c71b3b123682832bd4d5b60b24de8628cb9;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/client/tdm_client.c b/client/tdm_client.c index f126490..3a2ab48 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -9,7 +9,7 @@ * Taeheon Kim , * YoungJun Cho , * SooChan Lim , - * Boram Park + * Boram Park * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the @@ -33,6 +33,8 @@ * **************************************************************************/ +#define WL_HIDE_DEPRECATED + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -42,6 +44,7 @@ #include #include #include +#include #include @@ -51,14 +54,22 @@ #include "tdm_list.h" #include "tdm.h" #include "tdm_private.h" +#include + +#define TDM_ARRAY_NTH_DATA(array, type, n) (((type*)((array)->data)) + n) typedef struct _tdm_private_client_vblank tdm_private_client_vblank; +typedef struct _tdm_private_client_voutput tdm_private_client_voutput; 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 voutput_list; unsigned int enable_ttrace; unsigned int stamp; @@ -67,6 +78,8 @@ typedef struct _tdm_private_client { } tdm_private_client; typedef struct _tdm_private_client_output { + struct list_head link; + tdm_private_client *private_client; char name[TDM_NAME_LEN]; @@ -82,9 +95,39 @@ typedef struct _tdm_private_client_output { unsigned int req_id; unsigned int watch_output_changes; - struct list_head link; + tdm_private_client_voutput *voutput; } tdm_private_client_output; +typedef struct _tdm_private_client_buffer { + struct list_head link; + struct wl_buffer *wl_buffer; +} tdm_private_client_buffer; + +struct _tdm_private_client_voutput { + struct list_head link; + struct wl_tdm_voutput *wl_voutput; + struct list_head commit_handler_list; + + struct { + int count; + tdm_client_output_mode *modes; + } available_modes; + + unsigned int mmwidth; + unsigned int mmheight; + + uint32_t msg; + + struct list_head buffer_list; + tbm_bufmgr bufmgr; + tdm_private_client_buffer *attach_buffer; + + tdm_private_client *private_client; + tdm_private_client_output *private_output; + char name[TDM_NAME_LEN]; + int get_output; +}; + struct _tdm_private_client_vblank { tdm_private_client_output *private_output; @@ -114,6 +157,7 @@ typedef struct _tdm_client_output_handler_info { void *user_data; struct list_head link; + struct list_head call_link; } tdm_client_output_handler_info; typedef struct _tdm_client_wait_info { @@ -127,8 +171,43 @@ typedef struct _tdm_client_wait_info { int need_free; struct list_head link; + struct list_head call_link; } tdm_client_wait_info; +typedef struct _tdm_client_voutput_commit_handler_info { + tdm_private_client_voutput *private_voutput; + + tdm_client_voutput_commit_handler func; + void *user_data; + + struct list_head link; + struct list_head call_link; +} tdm_client_voutput_commit_handler_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) { @@ -152,35 +231,50 @@ _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t tv_usec, uint32_t error) { tdm_private_client_vblank *private_vblank = data; - tdm_client_wait_info *w = NULL, *ww = NULL; + 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_SAFE(w, ww, &private_vblank->wait_list, link) { + LIST_FOR_EACH_ENTRY(w, &private_vblank->wait_list, link) { if (w->req_id != req_id) continue; - if (private_vblank->enable_ttrace) - TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); + wait_info = w; + break; + } - if (w->req_time >= private_vblank->last_time) - TDM_WRN("'req(%.6f) < last(%.6f)' failed", w->req_time, private_vblank->last_time); + if (!wait_info) { + TDM_ERR("no wait infomation for req_id(%d)", req_id); + return; + } - if (w->func) - w->func(private_vblank, error, sequence, tv_sec, tv_usec, w->user_data); + if (private_vblank->enable_ttrace) + TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); - if (w->need_free) { - LIST_DEL(&w->link); - free(w); - } else - w->need_free = 1; - return; + 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 */ @@ -256,12 +350,16 @@ 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_client_output_handler_info *h = NULL; + 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); - if (private_output->connection == value) + private_client = private_output->private_client; + + if (private_output->connection == value && value != TDM_OUTPUT_CONN_STATUS_MODE_SETTED) return; private_output->connection = value; @@ -274,22 +372,34 @@ _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output wl_proxy_get_id((struct wl_proxy*)private_output->output), value); - v.u32 = 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_client_output_handler_info *h = NULL; + 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? @@ -310,11 +420,19 @@ _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint wl_proxy_get_id((struct wl_proxy*)private_output->output), value); - v.u32 = 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 = { @@ -368,11 +486,23 @@ tdm_client_create(tdm_error *error) /* 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); + LIST_INITHEAD(&private_client->voutput_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); @@ -380,6 +510,9 @@ tdm_client_create(tdm_error *error) &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); @@ -399,24 +532,39 @@ tdm_client_destroy(tdm_client *client) { tdm_private_client *private_client = (tdm_private_client*)client; tdm_private_client_output *o = NULL, *oo = NULL; + tdm_private_client_voutput *vo = NULL, *voo = NULL; if (!private_client) return; - if (private_client->temp_vblank) + 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); } + LIST_FOR_EACH_ENTRY_SAFE(vo, voo, &private_client->voutput_list, link) { + tdm_client_voutput_destroy(vo); + } + 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); } @@ -430,7 +578,12 @@ tdm_client_get_fd(tdm_client *client, int *fd) 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_ERROR_OPERATION_FAILED; @@ -447,6 +600,13 @@ tdm_client_handle_events(tdm_client *client) /* 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); @@ -455,10 +615,127 @@ tdm_client_handle_events(tdm_client *client) 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 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) +{ + 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; + } + + while (true) { + ret = wl_display_flush(display); + + 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; + } + + return TDM_ERROR_NONE; +} + +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; + + 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; @@ -472,6 +749,7 @@ _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsi 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); @@ -495,6 +773,9 @@ tdm_client_wait_vblank(tdm_client *client, char *name, TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); + 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); @@ -521,6 +802,7 @@ 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; @@ -534,21 +816,63 @@ tdm_client_get_output(tdm_client *client, char *name, tdm_error *error) private_client = (tdm_private_client*)client; - if (!name) + 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; + } + + if (!name) { name = "primary"; + } else if (!strncmp(name, "primary", 7) || !strncmp(name, "default", 7)) { + TDM_DBG("get primary or default output"); + } else { + tdm_private_client_voutput *private_voutput = NULL; + int find = 0; + + LIST_FOR_EACH_ENTRY(private_voutput, &private_client->voutput_list, link) { + if (!strncmp(private_voutput->name, name, TDM_NAME_LEN)) { + find = 1; + break; + } + } + if (!find) { + 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)) + 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 */ @@ -557,7 +881,8 @@ tdm_client_get_output(tdm_client *client, char *name, tdm_error *error) private_output->private_client = private_client; snprintf(private_output->name, TDM_NAME_LEN, "%s", name); - private_output->output = wl_tdm_create_output(private_client->tdm, private_output->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 */ @@ -565,6 +890,7 @@ tdm_client_get_output(tdm_client *client, char *name, tdm_error *error) free(private_output); if (error) *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); return NULL; /* LCOV_EXCL_STOP */ @@ -572,11 +898,25 @@ tdm_client_get_output(tdm_client *client, char *name, tdm_error *error) LIST_INITHEAD(&private_output->vblank_list); LIST_INITHEAD(&private_output->change_handler_list); - LIST_ADDTAIL(&private_output->link, &private_client->output_list); wl_tdm_output_add_listener(private_output->output, &tdm_client_output_listener, private_output); - wl_display_roundtrip(private_client->display); + 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; } @@ -587,18 +927,36 @@ tdm_client_output_add_change_handler(tdm_client_output *output, void *user_data) { tdm_private_client_output *private_output; - tdm_client_output_handler_info *h; + 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 @@ -613,8 +971,11 @@ tdm_client_output_add_change_handler(tdm_client_output *output, h->func = func; h->user_data = user_data; LIST_ADDTAIL(&h->link, &private_output->change_handler_list); + LIST_INITHEAD(&h->call_link); - return TDM_ERROR_NOT_IMPLEMENTED; + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; } void @@ -623,12 +984,16 @@ tdm_client_output_remove_change_handler(tdm_client_output *output, 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) @@ -637,11 +1002,20 @@ tdm_client_output_remove_change_handler(tdm_client_output *output, LIST_DEL(&h->link); free(h); - if (LIST_IS_EMPTY(&private_output->change_handler_list)) - wl_tdm_output_watch_output_changes(private_output->output, 0); + 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 @@ -654,20 +1028,80 @@ tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refr 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; } - private_client = private_output->private_client; - TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER); + 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(private_client->display); + 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_mode(tdm_client_output *output, unsigned int *width, unsigned int *height) +{ + 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(width != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(height != 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) { + *width = private_output->width; + *height = private_output->height; + 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; + } + + *width = private_output->width; + *height = private_output->height; + + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; } @@ -681,20 +1115,35 @@ tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_sta 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; } - private_client = private_output->private_client; - TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER); + 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(private_client->display); + 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; } @@ -708,20 +1157,34 @@ tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms) 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; } - private_client = private_output->private_client; - TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER); + 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(private_client->display); + 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; } @@ -731,6 +1194,7 @@ 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; @@ -745,20 +1209,35 @@ tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error) private_output = (tdm_private_client_output*)output; private_client = private_output->private_client; - if (!private_client) { - TDM_ERR("'!private_client' failed"); + pthread_mutex_lock(&private_client->lock); + + if (CHECK_WL_PROTOCOL_ERROR(private_client)) { if (error) - *error = TDM_ERROR_INVALID_PARAMETER; + *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 */ @@ -766,7 +1245,8 @@ tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error) private_vblank->private_output = private_output; - private_vblank->vblank = wl_tdm_output_create_vblank(private_output->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 */ @@ -774,6 +1254,7 @@ tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error) free(private_vblank); if (error) *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); return NULL; /* LCOV_EXCL_STOP */ @@ -785,24 +1266,43 @@ tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error) private_vblank->enable_fake = 0; LIST_INITHEAD(&private_vblank->wait_list); - LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list); wl_tdm_vblank_add_listener(private_vblank->vblank, &tdm_client_vblank_listener, private_vblank); - wl_display_roundtrip(private_client->display); + wl_display_roundtrip_queue(private_client->display, private_client->queue); - return (tdm_client_vblank*)private_vblank; -} - -void -tdm_client_vblank_destroy(tdm_client_vblank *vblank) -{ - tdm_private_client_vblank *private_vblank; - tdm_client_wait_info *w = NULL, *ww = NULL; + 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) { @@ -813,16 +1313,27 @@ tdm_client_vblank_destroy(tdm_client_vblank *vblank) 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; @@ -832,6 +1343,8 @@ tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name) wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name); + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; } @@ -839,11 +1352,16 @@ 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; } @@ -852,18 +1370,32 @@ 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) + 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; } @@ -871,18 +1403,33 @@ 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); - if (private_vblank->offset == offset_ms) + 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; } @@ -890,17 +1437,31 @@ 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) + 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; } @@ -927,16 +1488,25 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli 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_output->watch_output_changes && !private_vblank->enable_fake) { + 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; } } @@ -946,6 +1516,7 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli /* LCOV_EXCL_START */ TDM_ERR("alloc failed"); + pthread_mutex_unlock(&private_client->lock); return TDM_ERROR_OUT_OF_MEMORY; /* LCOV_EXCL_STOP */ @@ -956,6 +1527,7 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli 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; @@ -980,6 +1552,7 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli if (!private_vblank->sync) { wl_display_flush(private_client->display); + pthread_mutex_unlock(&private_client->lock); return TDM_ERROR_NONE; } @@ -996,6 +1569,13 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli 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 */ @@ -1020,16 +1600,25 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, 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_output->watch_output_changes && !private_vblank->enable_fake) { + 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; } } @@ -1039,6 +1628,7 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, /* LCOV_EXCL_START */ TDM_ERR("alloc failed"); + pthread_mutex_unlock(&private_client->lock); return TDM_ERROR_OUT_OF_MEMORY; /* LCOV_EXCL_STOP */ @@ -1049,6 +1639,7 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, 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; @@ -1073,6 +1664,7 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, if (!private_vblank->sync) { wl_display_flush(private_client->display); + pthread_mutex_unlock(&private_client->lock); return TDM_ERROR_NONE; } @@ -1089,7 +1681,849 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, 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; +} + +static tbm_surface_h +_tdm_client_voutput_create_surface_from_param(tbm_bufmgr bufmgr, + int is_fd, + int32_t width, + int32_t height, + uint32_t format, + int32_t bpp, + int32_t size, + int32_t num_plane, + struct wl_array *plane_buf_idx, + struct wl_array *plane_offset, + struct wl_array *plane_stride, + struct wl_array *plane_size, + uint32_t flags, + int32_t num_buf, + uint32_t buf0, + uint32_t buf1, + uint32_t buf2) +{ + int32_t names[TBM_SURF_PLANE_MAX] = { -1, -1, -1, -1}; + tbm_surface_info_s info = { 0, }; + tbm_bo bos[TBM_SURF_PLANE_MAX]; + int i, numPlane, numName; + tbm_surface_h tbm_surface; + + numPlane = tbm_surface_internal_get_num_planes(format); + TDM_RETURN_VAL_IF_FAIL(numPlane == num_plane, NULL); + + info.width = width; + info.height = height; + info.format = format; + info.bpp = bpp; + info.size = size; + info.num_planes = numPlane; + + /*Fill plane info*/ + for (i = 0; i < numPlane; i++) { + info.planes[i].offset = *TDM_ARRAY_NTH_DATA(plane_offset, int32_t, i); + info.planes[i].stride = *TDM_ARRAY_NTH_DATA(plane_stride, int32_t, i); + info.planes[i].size = *TDM_ARRAY_NTH_DATA(plane_size, int32_t, i); + } + + /*Fill buffer*/ + numName = num_buf; + names[0] = buf0; + names[1] = buf1; + names[2] = buf2; + + for (i = 0; i < numName; i++) { + if (is_fd) + bos[i] = tbm_bo_import_fd(bufmgr, names[i]); + else + bos[i] = tbm_bo_import(bufmgr, names[i]); + } + + tbm_surface = tbm_surface_internal_create_with_bos(&info, bos, numName); + if (tbm_surface == NULL) { + if (is_fd) { + close(buf0); + close(buf1); + close(buf2); + } + return NULL; + } + + if (is_fd) { + close(buf0); + close(buf1); + close(buf2); + } + + for (i = 0; i < numName; i++) + tbm_bo_unref(bos[i]); + + return tbm_surface; +} +static void +tdm_client_voutput_cb_buffer_import_with_id(void *data, + struct wl_tdm_voutput *wl_voutput, + struct wl_buffer *wl_buffer, + int32_t width, + int32_t height, + uint32_t format, + int32_t bpp, + int32_t size, + int32_t num_plane, + struct wl_array *plane_buf_idx, + struct wl_array *plane_offset, + struct wl_array *plane_stride, + struct wl_array *plane_size, + uint32_t flags, + int32_t num_buf, + uint32_t buf0, + uint32_t buf1, + uint32_t buf2) +{ + tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data; + tdm_private_client_buffer *buffer = NULL; + tbm_surface_h tbm_surface; + + TDM_RETURN_IF_FAIL(private_voutput != NULL); + + buffer = calloc(1, sizeof *buffer); + TDM_RETURN_IF_FAIL(buffer != NULL); + + tbm_surface = _tdm_client_voutput_create_surface_from_param(private_voutput->bufmgr, 0, + width, height, format, bpp, size, + num_plane, + plane_buf_idx, plane_offset, plane_stride, plane_size, + 0, + num_buf, + buf0, buf1, buf2); + TDM_GOTO_IF_FAIL(tbm_surface != NULL, fail); + + tbm_surface_internal_ref(tbm_surface); + wl_buffer_set_user_data(wl_buffer, tbm_surface); + + buffer->wl_buffer = wl_buffer; + + LIST_ADDTAIL(&buffer->link, &private_voutput->buffer_list); + + return; + +fail: + if (buffer) + free(buffer); + + if (wl_buffer) + wl_buffer_destroy(wl_buffer); +} + +static void +tdm_client_voutput_cb_buffer_import_with_fd(void *data, + struct wl_tdm_voutput *wl_voutput, + struct wl_buffer *wl_buffer, + int32_t width, + int32_t height, + uint32_t format, + int32_t bpp, + int32_t size, + int32_t num_plane, + struct wl_array *plane_buf_idx, + struct wl_array *plane_offset, + struct wl_array *plane_stride, + struct wl_array *plane_size, + uint32_t flags, + int32_t num_buf, + int32_t buf0, + int32_t buf1, + int32_t buf2) +{ + tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data; + tdm_private_client_buffer *buffer = NULL; + tbm_surface_h tbm_surface; + + TDM_RETURN_IF_FAIL(private_voutput != NULL); + + buffer = calloc(1, sizeof *buffer); + TDM_RETURN_IF_FAIL(buffer != NULL); + + tbm_surface = _tdm_client_voutput_create_surface_from_param(private_voutput->bufmgr, 1, + width, height, format, bpp, size, + num_plane, + plane_buf_idx, plane_offset, plane_stride, plane_size, + 0, + num_buf, + buf0, buf1, buf2); + TDM_GOTO_IF_FAIL(tbm_surface != NULL, fail); + + tbm_surface_internal_ref(tbm_surface); + wl_buffer_set_user_data(wl_buffer, tbm_surface); + + buffer->wl_buffer = wl_buffer; + + LIST_ADDTAIL(&buffer->link, &private_voutput->buffer_list); + + return; + +fail: + if (buffer) + free(buffer); + + if (wl_buffer) + wl_buffer_destroy(wl_buffer); +} + +static void +tdm_client_voutput_cb_buffer_destroy(void *data, + struct wl_tdm_voutput *wl_voutput, + struct wl_buffer *wl_buffer) +{ + tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data; + tdm_private_client_buffer *cb = NULL, *cbb = NULL; + tbm_surface_h tbm_surface = NULL; + + TDM_RETURN_IF_FAIL(private_voutput != NULL); + + LIST_FOR_EACH_ENTRY_SAFE(cb, cbb, &private_voutput->buffer_list, link) { + if (wl_buffer == cb->wl_buffer) { + LIST_DEL(&cb->link); + + tbm_surface = (tbm_surface_h)wl_buffer_get_user_data(wl_buffer); + if (tbm_surface) + tbm_surface_internal_unref(tbm_surface); + + wl_buffer_set_user_data(wl_buffer, NULL); + wl_buffer_destroy(wl_buffer); + + free(cb); + + break; + } + } + + return; +} + +void +tdm_client_voutput_cb_attach_buffer(void *data, + struct wl_tdm_voutput *wl_voutput, + struct wl_buffer *wl_buffer) +{ + tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)data; + tdm_private_client_buffer *cb = NULL, *cbb = NULL; + + TDM_RETURN_IF_FAIL(private_voutput != NULL); + + LIST_FOR_EACH_ENTRY_SAFE(cb, cbb, &private_voutput->buffer_list, link) { + if (wl_buffer == cb->wl_buffer) { + private_voutput->attach_buffer = cb; + break; + } + } + + return; +} + +void +tdm_client_voutput_cb_commit(void *data, struct wl_tdm_voutput *wl_voutput) +{ + tdm_private_client_voutput *private_voutput; + tdm_private_client *private_client; + tbm_surface_h buffer = NULL; + tdm_client_voutput_commit_handler_info *h = NULL, *hh = NULL; + struct list_head call_list; + + private_voutput = (tdm_private_client_voutput *)data; + TDM_RETURN_IF_FAIL(private_voutput != NULL); + TDM_RETURN_IF_FAIL(private_voutput->attach_buffer != NULL); + + buffer = (tbm_surface_h)wl_buffer_get_user_data(private_voutput->attach_buffer->wl_buffer); + TDM_RETURN_IF_FAIL(buffer != NULL); + + tbm_surface_internal_ref(buffer); + + private_client = private_voutput->private_client; + + LIST_INITHEAD(&call_list); + + LIST_FOR_EACH_ENTRY(h, &private_voutput->commit_handler_list, link) { + LIST_ADDTAIL(&h->call_link, &call_list); + } + + pthread_mutex_unlock(&private_client->lock); + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) { + if (h->func) + h->func(private_voutput, buffer, h->user_data); + } + + /* if no added commit_handler call commit done immediately */ + if (LIST_IS_EMPTY(&private_voutput->commit_handler_list)) + tdm_client_voutput_commit_done(private_voutput); + + pthread_mutex_lock(&private_client->lock); +} + +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_buffer_import_with_id, + tdm_client_voutput_cb_buffer_import_with_fd, + tdm_client_voutput_cb_buffer_destroy, + tdm_client_voutput_cb_attach_buffer, + tdm_client_voutput_cb_commit, + 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 = NULL; + 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; + pthread_mutex_unlock(&private_client->lock); + return NULL; + /* LOCV_EXCL_STOP */ + } + + private_voutput->bufmgr = tbm_bufmgr_init(-1); + if (private_voutput->bufmgr == NULL) { + /* LCOV_EXCL_START */ + TDM_ERR("fail tbm_bufmgr_init"); + free(private_voutput); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + pthread_mutex_unlock(&private_client->lock); + return NULL; + /* LCOV_EXCL_STOP */ + } + + LIST_INITHEAD(&private_voutput->commit_handler_list); + LIST_INITHEAD(&private_voutput->buffer_list); + + private_voutput->private_client = private_client; + strncpy(private_voutput->name, name, TDM_NAME_LEN - 1); + private_voutput->name[TDM_NAME_LEN - 1] = '\0'; + + private_voutput->wl_voutput = wl_tdm_create_voutput((struct wl_tdm *)wrapper, 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; + } + + LIST_ADDTAIL(&private_voutput->link, &private_client->voutput_list); + + 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; + tdm_private_client *private_client; + tdm_client_voutput_commit_handler_info *h = NULL, *hh = NULL; + + if (!private_voutput) + return; + private_client = private_voutput->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (!(LIST_IS_EMPTY(&private_voutput->buffer_list))) { + tdm_private_client_buffer *cb = NULL, *cbb = NULL; + + LIST_FOR_EACH_ENTRY_SAFE(cb, cbb, &private_voutput->buffer_list, link) { + tbm_surface_h tbm_surface = NULL; + + LIST_DEL(&cb->link); + + tbm_surface = (tbm_surface_h)wl_buffer_get_user_data(cb->wl_buffer); + if (tbm_surface) + tbm_surface_internal_unref(tbm_surface); + + wl_buffer_set_user_data(cb->wl_buffer, NULL); + wl_buffer_destroy(cb->wl_buffer); + + free(cb); + } + } + + if (private_voutput->bufmgr) + tbm_bufmgr_deinit(private_voutput->bufmgr); + + if (private_voutput->available_modes.modes) + free(private_voutput->available_modes.modes); + + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_voutput->commit_handler_list, link) { + LIST_DEL(&h->link); + free(h); + } + + if (private_voutput->get_output) + _tdm_client_output_destroy(private_voutput->private_output); + + wl_tdm_voutput_destroy(private_voutput->wl_voutput); + + LIST_DEL(&private_voutput->link); + + free(private_voutput); + + pthread_mutex_unlock(&private_client->lock); +} + +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_private_client *private_client; + tdm_error ret = TDM_ERROR_NONE; + + 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; + private_client = private_voutput->private_client; + + if (!private_voutput->private_output) { + private_voutput->private_output = tdm_client_voutput_get_client_output(private_voutput, &ret); + TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, TDM_ERROR_OPERATION_FAILED); + } + + pthread_mutex_lock(&private_client->lock); + + if (private_voutput->private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) { + pthread_mutex_unlock(&private_client->lock); + 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); + } + + pthread_mutex_unlock(&private_client->lock); + + 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_private_client *private_client; + tdm_error ret = TDM_ERROR_NONE; + + 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; + private_client = private_voutput->private_client; + + if (!private_voutput->private_output) { + private_voutput->private_output = tdm_client_voutput_get_client_output(private_voutput, &ret); + TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, TDM_ERROR_OPERATION_FAILED); + } + + pthread_mutex_lock(&private_client->lock); + + if (private_voutput->private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_BAD_REQUEST; + } + + private_voutput->mmwidth = mmWidth; + private_voutput->mmheight = mmHeight; + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_voutput_add_commit_handler(tdm_client_voutput *voutput, + tdm_client_voutput_commit_handler func, + void *user_data) +{ + tdm_private_client_voutput *private_voutput; + tdm_private_client *private_client; + tdm_client_voutput_commit_handler_info *h = NULL; + + TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_voutput = (tdm_private_client_voutput *)voutput; + private_client = private_voutput->private_client; + + LIST_FOR_EACH_ENTRY(h, &private_voutput->commit_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; + } + + h->private_voutput = private_voutput; + h->func = func; + h->user_data = user_data; + LIST_ADDTAIL(&h->link, &private_voutput->commit_handler_list); + LIST_INITHEAD(&h->call_link); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +void +tdm_client_voutput_remove_commit_handler(tdm_client_voutput *voutput, + tdm_client_voutput_commit_handler func, + void *user_data) +{ + tdm_private_client_voutput *private_voutput; + tdm_private_client *private_client; + tdm_client_voutput_commit_handler_info *h = NULL; + + TDM_RETURN_IF_FAIL(voutput != NULL); + TDM_RETURN_IF_FAIL(func != NULL); + + private_voutput = (tdm_private_client_voutput *)voutput; + private_client = private_voutput->private_client; + + pthread_mutex_lock(&private_client->lock); + + LIST_FOR_EACH_ENTRY(h, &private_voutput->commit_handler_list, link) { + if (h->func != func || h->user_data != user_data) + continue; + + LIST_DEL(&h->link); + free(h); + + pthread_mutex_unlock(&private_client->lock); + + return; + } + + pthread_mutex_unlock(&private_client->lock); +} + +tdm_error +tdm_client_voutput_commit_done(tdm_client_voutput *voutput) +{ + tdm_private_client_voutput *private_voutput; + tdm_private_client *private_client; + tbm_surface_h buffer = NULL; + + TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_voutput = (tdm_private_client_voutput *)voutput; + TDM_RETURN_VAL_IF_FAIL(private_voutput->attach_buffer != NULL, TDM_ERROR_NONE); + + private_client = private_voutput->private_client; + + pthread_mutex_lock(&private_client->lock); + + buffer = (tbm_surface_h)wl_buffer_get_user_data(private_voutput->attach_buffer->wl_buffer); + tbm_surface_internal_unref(buffer); + private_voutput->attach_buffer = NULL; + wl_tdm_voutput_commit_done(private_voutput->wl_voutput); + + pthread_mutex_unlock(&private_client->lock); + + 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; + tdm_private_client_output *private_output = NULL; + tdm_private_client *private_client; + tdm_error ret = TDM_ERROR_NONE; + + 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; + private_client = private_voutput->private_client; + + pthread_mutex_lock(&private_client->lock); + + if (private_voutput->get_output) { + pthread_mutex_unlock(&private_client->lock); + return private_voutput->private_output; + } + + pthread_mutex_unlock(&private_client->lock); + private_output = (tdm_private_client_output *)tdm_client_get_output(private_voutput->private_client, private_voutput->name, &ret); + if (!private_output) { + TDM_ERR("tdm_client_voutput_get_client_output get private_output fail"); + if (error) + *error = ret; + return NULL; + } + pthread_mutex_lock(&private_client->lock); + private_output->voutput = private_voutput; + private_voutput->private_output = private_output; + private_voutput->get_output = 1; + + pthread_mutex_unlock(&private_client->lock); + + return private_output; +} + +void +_tdm_client_voutput_send_available_modes(tdm_private_client_voutput *private_voutput) +{ + tdm_client_output_mode *modes, *mode; + struct wl_array array; + int i, size; + + modes = private_voutput->available_modes.modes; + size = sizeof(tdm_client_output_mode); + + wl_array_init(&array); + for (i = 0; i < private_voutput->available_modes.count; i++) { + mode = wl_array_add(&array, size); + memcpy(mode, &modes[i], size); + } + wl_tdm_voutput_set_available_modes(private_voutput->wl_voutput, &array); + wl_array_release(&array); +} + +tdm_error +tdm_client_voutput_connect(tdm_client_voutput *voutput) +{ + tdm_private_client_output *private_output = NULL;; + tdm_private_client_voutput *private_voutput = NULL; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_voutput = (tdm_private_client_voutput *)voutput; + private_client = private_voutput->private_client; + private_output = private_voutput->private_output; + + pthread_mutex_lock(&private_client->lock); + + if (private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + if (!private_output->watch_output_changes) + private_output->connection = TDM_OUTPUT_CONN_STATUS_CONNECTED; + + _tdm_client_voutput_send_available_modes(private_voutput); + + wl_tdm_voutput_set_physical_size(private_voutput->wl_voutput, private_voutput->mmwidth, private_voutput->mmheight); + + wl_tdm_voutput_connect(private_voutput->wl_voutput); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_voutput_disconnect(tdm_client_voutput *voutput) +{ + tdm_private_client_output *private_output = NULL; + tdm_private_client_voutput *private_voutput = NULL; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_voutput = (tdm_private_client_voutput *)voutput; + private_client = private_voutput->private_client; + private_output = private_voutput->private_output; + + pthread_mutex_lock(&private_client->lock); + + if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_NONE; + } + + if (!private_output->watch_output_changes) + private_output->connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED; + + wl_tdm_voutput_disconnect(private_voutput->wl_voutput); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +} + + +tdm_error +tdm_client_voutput_set_mode(tdm_client_voutput *voutput, int index) +{ + tdm_private_client_output *private_output; + tdm_private_client_voutput *private_voutput = NULL; + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(index >= 0, TDM_ERROR_INVALID_PARAMETER); + + private_voutput = (tdm_private_client_voutput *)voutput; + private_client = private_voutput->private_client; + private_output = private_voutput->private_output; + + pthread_mutex_lock(&private_client->lock); + + if (private_voutput->available_modes.count - 1 < index) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_INVALID_PARAMETER; + } + + if ((private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) || + (private_voutput->available_modes.count == 0)) { + pthread_mutex_unlock(&private_client->lock); + return TDM_ERROR_BAD_REQUEST; + } + + TDM_DBG("mode_set request : %d", index); + + wl_tdm_voutput_set_mode(private_voutput->wl_voutput, index); + + pthread_mutex_unlock(&private_client->lock); + + return TDM_ERROR_NONE; +}