*
**************************************************************************/
+#define WL_HIDE_DEPRECATED
+
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "tdm_list.h"
#include "tdm.h"
#include "tdm_private.h"
+#include <tbm_surface_internal.h>
+
+#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_registry *registry;
struct wl_tdm *tdm;
struct list_head output_list;
+ struct list_head voutput_list;
unsigned int enable_ttrace;
unsigned int stamp;
} tdm_private_client;
typedef struct _tdm_private_client_output {
+ struct list_head link;
+
tdm_private_client *private_client;
char name[TDM_NAME_LEN];
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;
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)
{
}
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);
{
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;
_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)
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) {
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;
+}
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);
tdm_client *client;
tdm_client_output *output;
tdm_client_vblank *vblank;
+ tdm_client_voutput *voutput;
double vrefresh_interval, start, end;
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)
{
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;
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,
projects / platform / core / uifw / libtdm.git / commitdiff