From: Seunghun Lee Date: Wed, 27 Jun 2018 10:23:33 +0000 (+0900) Subject: tdm_client: Introduce 'tdm_virtual_output' on the client side. X-Git-Tag: accepted/tizen/5.0/unified/20181108.074357~11 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Flibtdm.git;a=commitdiff_plain;h=4b871459cd1dc0beb11ada9d0f8acace511503e7 tdm_client: Introduce 'tdm_virtual_output' on the client side. NOTE: This needs extra implementation of server side to be operated properly. APIs of 'tdm_virtual_output' will provide services to applications like Wi-Fi display manager. Any application which has proper privilege can ask tdm_server for considering itself as a sort of virtual output. Once an application acquires the instance of 'tdm_virtual_output' successfully, server considers it as a normal output. Change-Id: Ib6085db09521facd90d28637056b48e166f8a90e Signed-off-by: Junkyeong Kim --- diff --git a/client/tdm_client.c b/client/tdm_client.c index 4023208..fbb875b 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -33,6 +33,8 @@ * **************************************************************************/ +#define WL_HIDE_DEPRECATED + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -52,8 +54,12 @@ #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; @@ -63,6 +69,7 @@ typedef struct _tdm_private_client { 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; @@ -71,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]; @@ -86,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; @@ -135,6 +174,16 @@ typedef struct _tdm_client_wait_info { 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) { @@ -446,6 +495,7 @@ tdm_client_create(tdm_error *error) } 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); @@ -482,6 +532,7 @@ 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; @@ -498,6 +549,10 @@ tdm_client_destroy(tdm_client *client) _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) @@ -772,11 +827,24 @@ tdm_client_get_output(tdm_client *client, char *name, tdm_error *error) 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; + } 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) { @@ -1591,3 +1659,825 @@ tdm_client_vblank_is_waiting(tdm_client_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; + 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); + + 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; + + if (!cb) continue; + + 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); + } + + 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; +} diff --git a/client/tdm_client.h b/client/tdm_client.h index a13bf2a..17d63cf 100644 --- a/client/tdm_client.h +++ b/client/tdm_client.h @@ -429,6 +429,45 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, tdm unsigned int tdm_client_vblank_is_waiting(tdm_client_vblank *vblank); + +/* Virtual Output */ +tdm_client_voutput * +tdm_client_create_voutput(tdm_client *client, const char *name, tdm_error *error); + +void +tdm_client_voutput_destroy(tdm_client_voutput *voutput); + +tdm_error +tdm_client_voutput_set_available_modes(tdm_client_voutput *voutput, const tdm_client_output_mode *modes, int count); + +tdm_error +tdm_client_voutput_set_physical_size(tdm_client_voutput *voutput, unsigned int mmWidth, unsigned int mmHeight); + +tdm_error +tdm_client_voutput_add_commit_handler(tdm_client_voutput *voutput, tdm_client_voutput_commit_handler func, void *user_data); + +void +tdm_client_voutput_remove_commit_handler(tdm_client_voutput *voutput, tdm_client_voutput_commit_handler func, void *user_data); + +tdm_error +tdm_client_voutput_get_committed_tbm_surface(tdm_client_voutput *voutput, tbm_surface_h surface); + +tdm_error +tdm_client_voutput_commit_done(tdm_client_voutput *voutput); + +tdm_client_output * +tdm_client_voutput_get_client_output(tdm_client_voutput *voutput, tdm_error *error); + +tdm_error +tdm_client_voutput_set_mode(tdm_client_voutput *voutput, int index); + +tdm_error +tdm_client_voutput_connect(tdm_client_voutput *voutput); + +tdm_error +tdm_client_voutput_disconnect(tdm_client_voutput *voutput); +/* End of Virtual Output */ + #ifdef __cplusplus } #endif diff --git a/client/tdm_client_types.h b/client/tdm_client_types.h index bd7e8a5..569cd1d 100644 --- a/client/tdm_client_types.h +++ b/client/tdm_client_types.h @@ -38,6 +38,8 @@ #include "tdm_common.h" +#include + #ifdef __cplusplus extern "C" { #endif @@ -109,6 +111,24 @@ typedef void unsigned int tv_usec, void *user_data); +/* Virtual Output */ +/* this is a copy of server side's tdm_output_mode */ +typedef struct _tdm_client_output_mode { + unsigned int clock; + unsigned int hdisplay, hsync_start, hsync_end, htotal, hskew; + unsigned int vdisplay, vsync_start, vsync_end, vtotal, vscan; + unsigned int vrefresh; + unsigned int flags; + unsigned int type; + char name[TDM_NAME_LEN]; +} tdm_client_output_mode; + +typedef void tdm_client_voutput; + +typedef void (*tdm_client_voutput_commit_handler)(tdm_client_voutput *voutput, + tbm_surface_h buffer, + void *user_data); +/* End of Virtual Output */ #ifdef __cplusplus } #endif diff --git a/configure.ac b/configure.ac index 3d13ec7..8944c9e 100644 --- a/configure.ac +++ b/configure.ac @@ -45,7 +45,7 @@ fi PKG_CHECK_MODULES(WAYLAND_SCANNER, wayland-scanner >= 1.7.0) PKG_CHECK_MODULES(TDM, dlog libtbm libpng pixman-1 wayland-server iniparser) -PKG_CHECK_MODULES(TDM_CLIENT, dlog wayland-client) +PKG_CHECK_MODULES(TDM_CLIENT, dlog libtbm wayland-client) PKG_CHECK_MODULES(TTRACE, [ttrace], diff --git a/haltests/src/tc_tdm_client.cpp b/haltests/src/tc_tdm_client.cpp index eb537ca..0d54855 100644 --- a/haltests/src/tc_tdm_client.cpp +++ b/haltests/src/tc_tdm_client.cpp @@ -50,6 +50,15 @@ enum { TDM_UT_PIPE_MSG_TERMINATE_SERVER, }; +#define TDM_UT_WAIT(fmt, ...) \ + do { \ + char ch; \ + do { \ + printf(fmt" [n]):next ", ##__VA_ARGS__); \ + ch = tc_tdm_getchar(); \ + } while (ch != 'n'); \ + } while (0) + static int _tc_tdm_pipe_read_msg(int fd); static bool _tc_tdm_pipe_write_msg(int fd, int reply_fd, int msg); static pid_t _tc_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child); @@ -66,6 +75,7 @@ public: tdm_client *client; tdm_client_output *output; tdm_client_vblank *vblank; + tdm_client_voutput *voutput; double vrefresh_interval, start, end; @@ -199,6 +209,23 @@ bool TDMClient::PrepareVblank(void) return true; } +char +tc_tdm_getchar(void) +{ + int c = getchar(); + int ch = c; + + if (ch == '\n' || ch == '\r') + ch = 'y'; + else if (ch < 'a') + ch += ('a' - 'A'); + + while (c != '\n' && c != EOF) + c = getchar(); + + return ch; +} + static int _tc_tdm_pipe_read_msg(int fd) { @@ -719,7 +746,7 @@ TEST_P(TDMClient, ClientOutputGetRefreshRateNullOther) ASSERT_EQ(tdm_client_output_get_refresh_rate(output, NULL), TDM_ERROR_INVALID_PARAMETER); } -/* tdm_client_output_get_refresh_rate */ +/* tdm_client_output_get_conn_status */ TEST_P(TDMClient, ClientOutputGetConnStatus) { tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE; @@ -1358,6 +1385,361 @@ TEST_P(TDMClient, ClientVblankIsWaitingNullObject) ASSERT_EQ(waiting, 0); } +TEST_P(TDMClient, ClientCreateVOutput) +{ + tdm_error ret; + const char name[TDM_NAME_LEN] = "Virtual Output"; + + ASSERT_EQ(PrepareClient(), true); + + voutput = tdm_client_create_voutput(client, name, &ret); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(voutput, NULL); + + tdm_client_voutput_destroy(voutput); +} + +class TDMVirtualOutput : public ::testing::Test +{ +public: + TDMVirtualOutput() {}; + ~TDMVirtualOutput() {}; + + static void SetUpTestCase(); + static void TearDownTestCase(); + static bool PrepareVOutput(void); + +protected: + static tdm_client *client; + static tdm_client_voutput *voutput; + const int MODE_COUNT = 2; + +private: + static pid_t server_pid; + + /* 0: read, 1: write */ + static int pipe_parent[2]; + static int pipe_child[2]; + + static void ServerFork(void); + static void ServerKill(void); +}; + +pid_t TDMVirtualOutput::server_pid = -1; +int TDMVirtualOutput::pipe_parent[2] = {-1, -1}; +int TDMVirtualOutput::pipe_child[2] = {-1, -1}; +tdm_client* TDMVirtualOutput::client = nullptr; +tdm_client_voutput* TDMVirtualOutput::voutput = nullptr; + +void TDMVirtualOutput::ServerKill(void) +{ + if (pipe_child[0] >= 0) + close(pipe_child[0]); + if (pipe_child[1] >= 0) { + if (server_pid > 0) { + bool ret = _tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER); + if (ret) { + if (waitpid(server_pid, NULL, 0) == server_pid) + TDM_INFO("*** server terminated ***"); + else + TDM_ERR("*** failed to terminate server ***"); + } else { + if (kill(server_pid, 9) < 0) + TDM_ERR("*** failed to kill server ***"); + } + } + close(pipe_child[1]); + } + + if (pipe_parent[0] >= 0) + close(pipe_parent[0]); + if (pipe_parent[1] >= 0) + close(pipe_parent[1]); + + server_pid = -1; + pipe_parent[0] = pipe_parent[1] = -1; + pipe_child[0] = pipe_child[1] = -1; +} + +void TDMVirtualOutput::ServerFork(void) +{ + if (server_pid > 0) + return; + + server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child); + ASSERT_GT(server_pid, 0); +} + +void TDMVirtualOutput::SetUpTestCase(void) +{ + setenv("XDG_RUNTIME_DIR", "/run", 1); + setenv("TBM_DISPLAY_SERVER", "1", 1); + + if (server_pid == -1) + ServerFork(); + + ASSERT_EQ(PrepareVOutput(), true); +} + +void TDMVirtualOutput::TearDownTestCase(void) +{ +// TDM_UT_WAIT("check & press"); + + if (voutput) + tdm_client_voutput_destroy(voutput); + + if (client) + tdm_client_destroy(client); + + ServerKill(); + + unsetenv("XDG_RUNTIME_DIR"); + unsetenv("TBM_DISPLAY_SERVER"); +} + +bool TDMVirtualOutput::PrepareVOutput(void) +{ + tdm_error ret; + const char name[TDM_NAME_LEN] = "Virtual Output"; + + client = tdm_client_create(&ret); + TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(client != NULL); + + voutput = tdm_client_create_voutput(client, name, &ret); + TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); + TDM_UT_RETURN_FALSE_IF_FAIL(voutput != NULL); + +// TDM_UT_WAIT("check & press"); + + return true; +} + +static void +_tc_tdm_client_virutual_make_available_mode(tdm_client_output_mode *modes, int count) +{ + int i; + + for (i = 0; i < count; i++) { + modes[i].clock = 25200; + modes[i].hdisplay = 640; + modes[i].hsync_start = 656; + modes[i].hsync_end = 752; + modes[i].htotal = 800; + modes[i].hskew = 0; + modes[i].vdisplay = 480; + modes[i].vsync_start = 490; + modes[i].vsync_end = 492; + modes[i].vtotal = 525; + modes[i].vscan = 0; + modes[i].vrefresh = 30; + modes[i].flags = 0; + modes[i].type = 0; + snprintf(modes[i].name, TDM_NAME_LEN, "%dx%d_%d", modes[i].hdisplay, modes[i].vdisplay, i); + } +} + +TEST_F(TDMVirtualOutput, SetAvailableModes) +{ + tdm_error ret; + tdm_client_output_mode modes[this->MODE_COUNT]; + int count = this->MODE_COUNT; + + _tc_tdm_client_virutual_make_available_mode(modes, count); + + ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); + ASSERT_EQ(ret, TDM_ERROR_NONE); +} + +TEST_F(TDMVirtualOutput, FailTestSetAvailableModes) +{ + tdm_error ret; + tdm_client_output_mode modes[this->MODE_COUNT]; + int count = this->MODE_COUNT; + + ret = tdm_client_voutput_set_available_modes(NULL, modes, count); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); + + ret = tdm_client_voutput_set_available_modes(this->voutput, NULL, count); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); +} + +TEST_F(TDMVirtualOutput, SetPhysicalSize) +{ + tdm_error ret; + unsigned int mmWidth = 1234, mmHeight = 1234; + + ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); + ASSERT_EQ(ret, TDM_ERROR_NONE); +} + +TEST_F(TDMVirtualOutput, FailTestSetPhysicalSize) +{ + tdm_error ret; + unsigned int invalid_mmWidth = 0, invalid_mmHeight = 0; + + ret = tdm_client_voutput_set_physical_size(this->voutput, invalid_mmWidth, invalid_mmHeight); + ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); +} + +static void +_tc_tdm_client_voutput_commit_handler(tdm_client_voutput *voutput, tbm_surface_h buffer, void *user_data) +{ + int *flag; + flag = (int *)user_data; + *flag = 1; +} + +TEST_F(TDMVirtualOutput, AddCommitHandler) +{ + tdm_error ret; + int flag_callback_called = 0; + + ret = tdm_client_voutput_add_commit_handler(this->voutput, + _tc_tdm_client_voutput_commit_handler, + &flag_callback_called); + ASSERT_EQ(ret, TDM_ERROR_NONE); +// ASSERT_EQ(flag_callback_called, 1); + + tdm_client_voutput_remove_commit_handler(this->voutput, + _tc_tdm_client_voutput_commit_handler, + &flag_callback_called); +} + +TEST_F(TDMVirtualOutput, CommitDone) +{ + tdm_error ret; + + ret = tdm_client_voutput_commit_done(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); +} + +TEST_F(TDMVirtualOutput, GetClientOutput) +{ + tdm_error ret; + tdm_client_output *output; + + output = tdm_client_voutput_get_client_output(this->voutput, &ret); + ASSERT_EQ(ret, TDM_ERROR_NONE); + ASSERT_NE(output, NULL); +} + +TEST_F(TDMVirtualOutput, Connect) +{ + tdm_error ret; + unsigned int mmWidth = 300, mmHeight = 150; + tdm_client_output_mode modes[this->MODE_COUNT]; + int count = this->MODE_COUNT; + + ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + _tc_tdm_client_virutual_make_available_mode(modes, count); + ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + ret = tdm_client_voutput_connect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 0); +} + +TEST_F(TDMVirtualOutput, Disconnect) +{ + tdm_error ret; + +// TDM_UT_WAIT("check & press"); + + ret = tdm_client_voutput_disconnect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 0); +} + + +TEST_F(TDMVirtualOutput, SetMode) +{ + tdm_error ret; + unsigned int mmWidth = 300, mmHeight = 150; + tdm_client_output_mode modes[this->MODE_COUNT]; + int count = this->MODE_COUNT; + + ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + _tc_tdm_client_virutual_make_available_mode(modes, count); + ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + ret = tdm_client_voutput_connect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 100); + + ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, count - 1), TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 100); + + ret = tdm_client_voutput_disconnect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 0); +} + +TEST_F(TDMVirtualOutput, SetModeNullObject) +{ + tdm_error ret; + unsigned int mmWidth = 300, mmHeight = 150; + tdm_client_output_mode modes[this->MODE_COUNT]; + int count = this->MODE_COUNT; + + ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + _tc_tdm_client_virutual_make_available_mode(modes, count); + ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + ret = tdm_client_voutput_connect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 100); + + ASSERT_EQ(tdm_client_voutput_set_mode(NULL, 0), TDM_ERROR_INVALID_PARAMETER); + + ret = tdm_client_voutput_disconnect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 0); +} + +TEST_F(TDMVirtualOutput, SetModeInvalidIndex) +{ + tdm_error ret; + unsigned int mmWidth = 300, mmHeight = 150; + tdm_client_output_mode modes[this->MODE_COUNT]; + int count = this->MODE_COUNT; + + ret = tdm_client_voutput_set_physical_size(this->voutput, mmWidth, mmHeight); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + _tc_tdm_client_virutual_make_available_mode(modes, count); + ret = tdm_client_voutput_set_available_modes(this->voutput, modes, count); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + ret = tdm_client_voutput_connect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 100); + + ASSERT_EQ(tdm_client_voutput_set_mode(this->voutput, -1), TDM_ERROR_INVALID_PARAMETER); + + ret = tdm_client_voutput_disconnect(this->voutput); + ASSERT_EQ(ret, TDM_ERROR_NONE); + + tdm_client_handle_events_timeout(this->client, 0); +} + #ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMClientParams, TDMClient, diff --git a/libtdm.pc.in b/libtdm.pc.in index 8c2adf4..7065867 100644 --- a/libtdm.pc.in +++ b/libtdm.pc.in @@ -7,5 +7,5 @@ Name: libtdm Description: Tizen Display Manager Library Version: @TDM_VERSION@ Requires: libtbm -Libs: -L${libdir} -ltdm +Libs: -L${libdir} -ltdm -ltbm Cflags: -I${includedir} diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 5bd715e..7479fce 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -13,6 +13,7 @@ BuildRequires: pkgconfig(libtbm) BuildRequires: pkgconfig(libpng) BuildRequires: pkgconfig(ttrace) BuildRequires: pkgconfig(wayland-server) +BuildRequires: pkgconfig(wayland-client) BuildRequires: pkgconfig(iniparser) BuildRequires: pkgconfig(pixman-1) BuildRequires: gtest-devel diff --git a/protocol/tdm.xml b/protocol/tdm.xml index 6434e98..dbba607 100644 --- a/protocol/tdm.xml +++ b/protocol/tdm.xml @@ -23,6 +23,11 @@ + + + + + @@ -66,6 +71,90 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/tdm_server.c b/src/tdm_server.c index 30bb475..93d6be9 100644 --- a/src/tdm_server.c +++ b/src/tdm_server.c @@ -682,6 +682,91 @@ _tdm_server_cb_create_output(struct wl_client *client, struct wl_resource *resou } } +static void _tdm_voutput_cb_destroy(struct wl_client *client, struct wl_resource *resource) +{ + wl_resource_destroy(resource); +} + +static void +_tdm_voutput_cb_set_available_modes(struct wl_client *client, + struct wl_resource *resource, + struct wl_array *modes) +{ + /* TODO */ +} + +static void +_tdm_voutput_cb_set_physical_size(struct wl_client *client, struct wl_resource *resource, + unsigned int mmwidth, unsigned int mmheight) +{ + /* TODO */ +} + +static void +_tdm_voutput_cb_set_mode(struct wl_client *client, struct wl_resource *resource, unsigned int index) +{ + /* TODO */ +} + +static void +_tdm_voutput_cb_connect(struct wl_client *client, struct wl_resource *resource) +{ + /* TODO */ +} + +static void +_tdm_voutput_cb_disconnect(struct wl_client *client, struct wl_resource *resource) +{ + /* TODO */ +} + +static void +_tdm_voutput_cb_commit_done(struct wl_client *client, struct wl_resource *resource) +{ + /* TODO */ +} + +static const struct wl_tdm_voutput_interface tdm_voutput_implementation = { + _tdm_voutput_cb_destroy, + _tdm_voutput_cb_set_available_modes, + _tdm_voutput_cb_set_physical_size, + _tdm_voutput_cb_set_mode, + _tdm_voutput_cb_connect, + _tdm_voutput_cb_disconnect, + _tdm_voutput_cb_commit_done +}; + +void +tdm_voutput_cb_resource_destroy(struct wl_resource *resource) +{ + /* TODO */ +} + +static void +_tdm_server_cb_create_virtual_output(struct wl_client *client, struct wl_resource *resource, const char *name, uint32_t id) +{ + struct wl_resource *voutput_resource = NULL; + + voutput_resource = + wl_resource_create(client, &wl_tdm_voutput_interface, + wl_resource_get_version(resource), id); + if (!voutput_resource) { + /* LCOV_EXCL_START */ + + wl_resource_post_no_memory(resource); + TDM_ERR("wl_resource_create failed"); + return; + + /* LCOV_EXCL_STOP */ + } + wl_resource_set_implementation(voutput_resource, + &tdm_voutput_implementation, + NULL, + tdm_voutput_cb_resource_destroy); + + wl_tdm_voutput_send_ack_message(voutput_resource, WL_TDM_VOUTPUT_MESSAGE_ADDED); +} + /* LCOV_EXCL_START */ static void _tdm_server_cb_debug(struct wl_client *client, struct wl_resource *resource, const char *options) @@ -727,6 +812,7 @@ _tdm_server_cb_debug(struct wl_client *client, struct wl_resource *resource, con static const struct wl_tdm_interface tdm_implementation = { _tdm_server_cb_debug, _tdm_server_cb_create_output, + _tdm_server_cb_create_virtual_output }; static void